pch_status PCHReadRewrites( void )
{
SRCFILE srcfile;
REWRITE *r;
REWRITE_TOKENS *rt;
cvinit_t data;
CarveInitStart( carveREWRITE, &data );
for( ; (r = PCHReadCVIndexElement( &data )) != NULL; ) {
PCHReadVar( *r );
r->list = RewriteTokensMapIndex( r->list );
r->curr = RewriteTokensMapIndex( r->curr );
r->stream = _TokenPosMapIndex( r ); // must be last
r->srcfiles_refd = NULL;
while( (srcfile = SrcFilePCHRead()) != NULL ) {
newSrcFileHandle( r, srcfile );
}
}
CarveInitStart( carveREWRITE_TOKENS, &data );
for( ; (rt = PCHReadCVIndexElement( &data )) != NULL; ) {
PCHReadVar( *rt );
rt->next = RewriteTokensMapIndex( rt->next );
}
return( PCHCB_OK );
}
pch_status PCHReadSegments( void )
{
char *src_suffix;
char *dest_suffix;
char *class_name;
size_t class_name_len;
size_t suffix_len;
size_t len;
size_t old_module_len;
size_t curr_module_len;
size_t extra;
fe_seg_id sib_id;
PC_SEGMENT *curr;
curr_module_len = strlen( ModuleName );
old_module_len = PCHReadUInt();
extra = 0;
if( curr_module_len > old_module_len ) {
extra = curr_module_len - old_module_len;
}
PCHReadVar( seg_max );
PCHReadVar( dgroup_size );
RingFree( &seg_list );
for( ; (len = PCHReadUInt()) != 0; ) {
curr = CMemAlloc( len + extra );
PCHRead( curr, len );
if( curr->module_prefix ) {
if( old_module_len != curr_module_len ) {
suffix_len = len;
suffix_len -= offsetof( PC_SEGMENT, name );
suffix_len -= old_module_len;
src_suffix = &(curr->name[old_module_len]);
dest_suffix = &(curr->name[curr_module_len]);
memmove( dest_suffix, src_suffix, suffix_len );
}
memcpy( curr->name, ModuleName, curr_module_len );
}
curr->label = SymbolMapIndex( curr->label );
class_name_len = PCHGetUInt( curr->class_name );
if( class_name_len != 0 ) {
class_name = CPermAlloc( class_name_len );
PCHRead( class_name, class_name_len );
} else {
class_name = NULL;
}
curr->class_name = class_name;
RingAppend( &seg_list, curr );
}
RingIterBeg( seg_list, curr ) {
sib_id = (fe_seg_id)(pointer_int)curr->sibling;
if( sib_id != curr->seg_id ) {
curr->sibling = segIdLookup( sib_id );
} else {
curr->sibling = curr;
}
} RingIterEnd( curr )
pch_status PCHReadPragmaData( void )
{
unsigned depth;
unsigned value;
PCHReadVar( PragToggle );
CgInfoLibPCHRead();
readPacks();
readEnums();
readExtrefs();
PCHReadVar( CompInfo.init_priority );
PCHReadVar( CompInfo.dt_method_speced );
depth = PCHReadUInt();
CgBackSetInlineDepth( depth );
value = PCHReadUInt();
CgBackSetInlineRecursion( value );
return( PCHCB_OK );
}
pch_status PCHReadModuleData( void )
{
uint_8 has_state_table;
module_init_func = SymbolPCHRead();
module_init_scope = ScopePCHRead();
module_fd.fn_scope = ScopePCHRead();
PCHReadVar( has_state_table );
module_fd.has_state_tab = ( has_state_table != 0 );
LabelPCHRead( &module_fd.label_mem );
return( PCHCB_OK );
}
pch_status PCHReadNames( void )
{
unsigned len;
idname **p;
idname **head;
idname *name;
memset( hashTable, 0, sizeof( hashTable ) );
PCHReadVar( nameCount );
PCHReadVar( nameDummyIndex );
nameTranslateTable = CMemAlloc( nameCount * sizeof( idname * ) );
p = nameTranslateTable;
for( ; (len = PCHReadUInt()) != 0; ) {
name = CPermAlloc( NAME_SIZE + len + 1 );
PCHRead( &(name->xhash), NAME_SIZE_PCH + len + 1 );
head = &hashTable[ name->hash ];
name->next = *head;
*head = name;
*p++ = name;
}
return( PCHCB_OK );
}
pch_status PCHReadTokenLocns( void )
{
SYM_TOKEN_LOCN *b;
auto cvinit_t data;
// DbgVerify( sizeof( uint_32 ) >= sizeof( void* ), "Bad assumption" );
CarveInitStart( carveSYMBOL_LOCN, &data );
for( ; (b = PCHReadCVIndexElement( &data )) != NULL; ) {
PCHReadVar( *b );
b->tl.src_file = SrcFileMapIndex( b->tl.src_file );
}
return( PCHCB_OK );
}
static void readAuxInfo( AUX_INFO *i )
{
unsigned len;
PCHReadVar( *i );
AsmSysPCHReadCode( i );
len = PCHGetUInt( i->parms );
if( len != 0 ) {
i->parms = CMemAlloc( len );
PCHRead( i->parms, len );
}
len = PCHGetUInt( i->objname );
if( len != 0 ) {
i->objname = CMemAlloc( len );
PCHRead( i->objname, len );
}
}
pch_status PCHReadTypeSigs( void )
{
TYPE_SIG *s;
auto cvinit_t data;
type_sigs = TypeSigPCHRead();
CarveInitStart( carveTYPE_SIG, &data );
for( ; (s = PCHReadCVIndexElement( &data )) != NULL; ) {
PCHReadVar( *s );
s->next = TypeSigMapIndex( s->next );
s->base = TypeSigMapIndex( s->base );
s->type = TypeMapIndex( s->type );
s->sym = SymbolMapIndex( s->sym );
s->dtor = SymbolMapIndex( s->dtor );
s->default_ctor = SymbolMapIndex( s->default_ctor );
s->copy_ctor = SymbolMapIndex( s->copy_ctor );
}
return( PCHCB_OK );
}
pch_status PCHReadConstantPool( void )
{
unsigned len;
POOL_CON *c;
auto cvinit_t data;
pool_float = ConstantPoolPCHRead();
pool_int64 = ConstantPoolPCHRead();
CarveInitStart( carvePOOL_CON, &data );
for( ; (c = PCHReadCVIndexElement( &data )) != NULL; ) {
PCHReadVar( *c );
c->next = ConstantPoolMapIndex( c->next );
if( c->flt ) {
len = c->u.s.len;
c->u.s.fp_constant = CPermAlloc( len );
PCHRead( c->u.s.fp_constant, len );
}
}
return( PCHCB_OK );
}
void *PCHReadCVIndexElement( cvinit_t *data )
/*******************************************/
{
cv_index index;
void *buff_ptr;
void *end;
PCHTrashAlreadyRead();
buff_ptr = pch_buff_cur;
end = (char *)buff_ptr + sizeof( cv_index );
if( end <= (void *)pch_buff_eob ) {
DbgAssert( ( ((unsigned)(pointer_int)pch_buff_cur) % PCH_ALIGN ) == 0 );
index = *(cv_index *)pch_buff_cur;
pch_buff_cur = end;
} else {
PCHReadVar( index );
}
if( index == PCH_NULL_INDEX ) {
return( NULL );
} else {
return( CarveInitElement( data, index ) );
}
}
pch_absorb PCHeaderAbsorb( char *include_file )
/*********************************************/
{
pch_absorb ret;
int status;
auto jmp_buf restore_state;
#ifndef NDEBUG
clock_t start;
clock_t stop;
start = clock();
#endif
if( ErrCount != 0 ) {
return( PCHA_ERRORS_PRESENT );
}
if( CompFlags.fhw_switch_used ) {
return( PCHA_IGNORE );
}
pchFile = sopen3( PCHFileName(), O_RDONLY | O_BINARY, SH_DENYWR );
if( pchFile == -1 ) {
return( PCHA_NOT_PRESENT );
}
ioBuffer = CMemAlloc( IO_BUFFER_SIZE );
pch_buff_eob = ioBuffer + IO_BUFFER_SIZE;
pch_buff_cur = pch_buff_eob;
ret = PCHA_OK;
abortData = &restore_state;
status = setjmp( restore_state );
if( status == 0 ) {
if( initialRead() == 0 ) {
ret = PCHA_NOT_PRESENT;
} else {
auto precompiled_header_header header;
#ifdef OPT_BR
unsigned long br_posn;
#endif
PCHReadVar( header );
#ifdef OPT_BR
br_posn = header.browse_info;
#endif
if( headerIsOK( &header ) ) {
if( ! stalePCH( include_file ) ) {
execInitFunctions( false );
execControlFunctions( false, readFunctions );
execFiniFunctions( false );
#ifdef OPT_BR
if( 0 != br_posn ) {
BrinfPchRead();
}
#endif
} else {
ret = PCHA_STALE;
}
} else {
pchWarn( WARN_PCH_CONTENTS_HEADER_ERROR );
ret = PCHA_HEADER;
}
}
} else {
CErr1( ERR_PCH_READ_ERROR );
}
abortData = NULL;
CMemFreePtr( &ioBuffer );
close( pchFile );
if( CompFlags.pch_debug_info_opt && ret == PCHA_OK ) {
CompFlags.pch_debug_info_read = true;
}
#ifndef NDEBUG
stop = clock();
printf( "%u ticks to load pre-compiled header\n", (unsigned)( stop - start ) );
#endif
return( ret );
}
static bool stalePCH( char *include_file )
{
time_t stamp;
cg_switches test_gen;
cg_target_switches test_target;
auto char buff1[_MAX_PATH];
auto char buff2[_MAX_PATH];
auto COMP_FLAGS testflags;
PCHReadVar( test_gen );
PCHReadVar( test_target );
if( test_gen != GenSwitches || test_target != TargetSwitches ) {
pchWarn( WARN_PCH_CONTENTS_OPTIONS );
return( true );
}
if( PCHReadUInt() != ErrPCHVersion() ) {
pchWarn( WARN_PCH_CONTENTS_HEADER_ERROR );
return( true );
}
if( PCHReadUInt() != TYPC_LAST ) {
pchWarn( WARN_PCH_CONTENTS_HEADER_ERROR );
return( true );
}
if( PCHReadUInt() != sizeof( COMP_FLAGS ) ) {
pchWarn( WARN_PCH_CONTENTS_HEADER_ERROR );
return( true );
}
PCHReadVar( testflags );
if( checkCompFlags( &testflags ) ) {
pchWarn( WARN_PCH_CONTENTS_OPTIONS );
return( true );
}
readFileString( buff1 );
if( FNAMECMPSTR( buff1, WholeFName ) == 0 ) {
if( CompFlags.pch_debug_info_opt ) {
// this source file created the PCH but it is being recompiled
// so we have to recreate the PCH along with the debug info
pchWarn( WARN_PCH_DEBUG_OPTIMIZE );
return( true );
}
}
readFileString( buff1 );
include_file = IoSuppFullPath( include_file, buff2, sizeof( buff2 ) );
if( FNAMECMPSTR( buff1, include_file ) != 0 ) {
pchWarn( WARN_PCH_CONTENTS_INCFILE );
return( true );
}
readFileString( buff1 );
getcwd( buff2, sizeof( buff2 ) );
if( stringIsDifferent( buff1, buff2, WARN_PCH_CONTENTS_CWD ) ) {
return( true );
}
if( CompFlags.pch_min_check ) {
flushUntilNullString( buff2 );
} else {
HFileListStart();
for(;;) {
HFileListNext( buff1 );
readFileString( buff2 );
if( stringIsDifferent( buff1, buff2, WARN_PCH_CONTENTS_INCLUDE ) ) {
return( true );
}
if( buff1[0] == '\0' ) break;
}
}
for( ; *readFileString( buff1 ) != '\0'; ) {
PCHReadVar( stamp );
if( ! sameStamp( buff1, stamp ) ) {
PCHWarn2p( WARN_PCH_CONTENTS_HFILE, buff1 );
return( true );
}
}
if( ! PCHVerifyMacroCheck() ) {
return( true );
}
transferCompFlags( &testflags );
return( false );
}
