static void alignPCH( unsigned i, bool writing )
{
unsigned skip;
char dummy[PCH_ALIGN] = {0};
if( writing ) {
skip = - cursorWriteFilePosition();
skip &= PCH_ALIGN - 1;
PCHWriteUInt( skip );
DbgAssert( skip == 0 );
if( skip != 0 ) {
PCHWrite( dummy, skip );
}
} else {
skip = PCHReadUInt();
if( skip != 0 ) {
PCHRead( dummy, skip );
}
}
#ifndef NDEBUG
if( writing ) {
unsigned w = -i;
PCHWriteUInt( w );
} else {
unsigned r;
r = PCHReadUInt();
if( r != -i ) {
printf( "index = %u\n", i );
CFatal( "pre-compiled header read/write out of synch" );
}
}
#else
i = i;
#endif
}
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;
}
PCHRead( &seg_max, sizeof( seg_max ) );
PCHRead( &dgroup_size, sizeof( dgroup_size ) );
RingFree( &seg_list );
for(;;) {
len = PCHReadUInt();
if( len == 0 ) break;
curr = CMemAlloc( len + extra );
PCHRead( curr, len );
if( curr->module_prefix ) {
if( old_module_len != curr_module_len ) {
suffix_len = len;
suffix_len -= sizeof( PC_SEGMENT ) - sizeof( char );
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 = (size_t) 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) curr->sibling;
if( sib_id != curr->seg_id ) {
curr->sibling = segIdLookup( sib_id );
} else {
curr->sibling = curr;
}
}
static void readEnums( void )
{
unsigned enum_int;
while( HeadEnums != NULL ) {
popPrag( &HeadEnums, NULL );
}
for( ; (enum_int = PCHReadUInt()) != -1; ) {
pushPrag( &HeadEnums, enum_int );
}
CompFlags.make_enums_an_int = PCHReadUInt();
}
pch_status PCHReadGenerators( void )
{
SYMBOL read_symbol;
TYPE read_type;
carveRTN_GEN = CarveRestart( carveRTN_GEN );
useSYMBOL = NULL;
useTYPE = NULL;
while( (read_symbol = SymbolPCHRead()) != NULL ) {
addGenRoutine( &useSYMBOL, PCHReadUInt(), read_symbol );
}
while( (read_type = TypePCHRead()) != NULL ) {
addGenRoutine( &useTYPE, PCHReadUInt(), read_type );
}
return( PCHCB_OK );
}
static void readPacks( void )
{
unsigned pack_amount;
while( HeadPacks != NULL ) {
popPrag( &HeadPacks, &PackAmount );
}
for( ; (pack_amount = PCHReadUInt()) != -1; ) {
pushPrag( &HeadPacks, pack_amount );
}
pack_amount = PCHReadUInt();
if( pack_amount == -1 ) {
pack_amount = GblPackAmount;
}
PackAmount = pack_amount;
}
static char *readFileString( char *buff )
{
unsigned len;
// assumes 'buff' is at least _MAX_PATH bytes
len = PCHReadUInt();
return( PCHRead( buff, len ) );
}
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 PCHReadRTFNames( void )
{
NAME *name;
for( name = runTimeCodeName; name < &runTimeCodeName[ RTF_LAST ]; ++name ) {
*name = NameMapIndex( PCHSetUInt( PCHReadUInt() ) );
}
return( PCHCB_OK );
}
pch_status PCHReadPragmas( void )
{
unsigned size;
unsigned max_index;
unsigned entry_len;
unsigned index;
AUX_ENTRY *e;
AUX_ENTRY *f;
AUX_ENTRY *next_f;
AUX_INFO *info;
for( f = AuxList; f != NULL; f = next_f ) {
next_f = f->next;
freeAuxInfo( f->info );
CMemFree( f->info );
CMemFree( f );
}
max_index = PCHReadUInt();
size = max_index * sizeof( AUX_INFO * );
infoTranslate = CMemAlloc( size );
memset( infoTranslate, 0, size );
// read all aux_info
for( index = PCH_FIRST_INDEX; index < max_index; ++index ) {
if( index < PCH_FIRST_USER_INDEX ) {
info = BuiltinAuxInfo + index - PCH_FIRST_INDEX;
} else {
info = CMemAlloc( sizeof( AUX_INFO ) );
}
infoTranslate[index] = info;
readAuxInfo( info );
}
// read aux entries
AuxList = NULL;
for( ; (entry_len = PCHReadUInt()) != 0; ) {
e = CMemAlloc( offsetof( AUX_ENTRY, name ) + entry_len + 1 );
PCHRead( e->name, entry_len + 1 );
e->info = PragmaMapIndex( PCHSetUInt( PCHReadUInt() ) );
e->next = AuxList;
AuxList = e;
}
return( PCHCB_OK );
}
void CgInfoLibPCHRead( void )
/***************************/
{
size_t len;
LIB_LIST *lib_entry;
CgInfoFreeLibs();
for(;;) {
len = PCHReadUInt();
if( len == 0 ) break;
lib_entry = CMemAlloc( len );
PCHRead( lib_entry, len );
RingAppend( &libRing, lib_entry );
}
}
void AsmSysPCHReadCode( AUX_INFO *info )
/**************************************/
{
byte *p;
byte *s;
byte_seq *code;
unsigned fixup;
SYMBOL sym;
byte_seq_len seq_size;
byte_seq_len code_length;
seq_size = PCHReadUInt();
if( seq_size == 0 ) {
info->code = NULL;
return;
}
code = CMemAlloc( seq_size );
info->code = code;
PCHRead( code, seq_size );
if(( code->length & DO_FLOATING_FIXUPS ) == 0 ) {
/* code has no relocs */
return;
}
code_length = code->length & MAX_BYTE_SEQ_LEN;
p = code->data;
s = code->data + code_length;
while( p != s ) {
if( p[0] == FLOATING_FIXUP_BYTE ) {
fixup = p[1];
p += 2;
if( fixup != FLOATING_FIXUP_BYTE ) {
switch( fixup ) {
case FIX_SYM_OFFSET:
case FIX_SYM_SEGMENT:
case FIX_SYM_RELOFF:
sym = SymbolMapIndex( *((SYMBOL*)p) );
copyCodeLen( p, &sym, sizeof( sym ) );
p += sizeof( SYMBOL ) + sizeof( unsigned long );
break;
default:
break;
}
}
} else {
++p;
}
}
}
static void readExtrefs( void )
{
SYMBOL sym;
unsigned len;
PRAG_EXT_REF *entry;
RingFree( &pragmaExtrefs );
while( (sym = SymbolPCHRead()) != NULL ) {
entry = RingAlloc( &pragmaExtrefs, offsetof( PRAG_EXT_REF, name ) + 1 );
entry->symbol = sym;
entry->name[0] = '\0';
}
while( (len = PCHReadUInt()) != 0 ) {
entry = RingAlloc( &pragmaExtrefs, offsetof( PRAG_EXT_REF, name ) + len + 1 );
PCHRead( entry->name, len + 1 );
entry->symbol = NULL;
}
}
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 PCHReadStats( void )
{
IncLineCount = PCHReadUInt();
return( PCHCB_OK );
}
} else {
class_name = NULL;
}
curr->class_name = class_name;
RingAppend( &seg_list, curr );
}
RingIterBeg( seg_list, curr ) {
sib_id = (fe_seg_id) curr->sibling;
if( sib_id != curr->seg_id ) {
curr->sibling = segIdLookup( sib_id );
} else {
curr->sibling = curr;
}
}
RingIterEnd( curr )
code_def_seg.pcseg = segIdLookup( PCHReadUInt() );
data_def_seg.pcseg = segIdLookup( PCHReadUInt() );
return( PCHCB_OK );
}
pch_status PCHWriteSegments( void )
{
size_t prefix_len;
size_t len;
size_t class_name_len;
SYMBOL save_label;
char *save_class_name;
PC_SEGMENT *save_sibling;
PC_SEGMENT *curr;
prefix_len = strlen( ModuleName );
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 );
}
