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