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 ); }