static void writeAuxInfo( AUX_INFO *info, unsigned index )
{
hw_reg_set *regs;
hw_reg_set *save_parms;
char *save_objname;
unsigned len;
info->index = index;
save_parms = info->parms;
save_objname = info->objname;
if( save_parms != NULL ) {
len = 0;
regs = save_parms;
for(;;) {
len += sizeof( hw_reg_set );
if( HW_CEqual( *regs, HW_EMPTY ) ) break;
++regs;
}
info->parms = PCHSetUInt( len );
}
if( save_objname != NULL ) {
info->objname = PCHSetUInt( strlen( save_objname ) + 1 );
}
PCHWriteVar( *info );
AsmSysPCHWriteCode( info );
if( save_parms != NULL ) {
PCHWrite( save_parms, PCHGetUInt( info->parms ) );
}
if( save_objname != NULL ) {
PCHWrite( save_objname, PCHGetUInt( info->objname ) );
}
info->parms = save_parms;
info->objname = save_objname;
}
static void saveRewrite( void *e, carve_walk_base *d )
{
REWRITE *s = e;
REWRITE_TOKENS *save_list;
REWRITE_TOKENS *save_curr;
SRCFILE_HANDLE *h;
uint_8 *save_stream;
if( s->free ) {
return;
}
save_stream = s->stream;
save_list = s->list;
save_curr = s->curr;
s->stream = _TokenPosGetIndex( s ); // must be first
s->list = RewriteTokensGetIndex( save_list );
s->curr = RewriteTokensGetIndex( save_curr );
PCHWriteCVIndex( d->index );
PCHWriteVar( *s );
for( h = s->srcfiles_refd; h != NULL; h = h->next ) {
SrcFilePCHWrite( h->srcfile );
}
PCHWriteCVIndexTerm();
s->list = save_list;
s->curr = save_curr;
s->stream = save_stream;
}
pch_status PCHWritePragmaData( void )
{
unsigned depth;
unsigned value;
PCHWriteVar( PragToggle );
CgInfoLibPCHWrite();
writePacks();
writeEnums();
writeExtrefs();
PCHWriteVar( CompInfo.init_priority );
PCHWriteVar( CompInfo.dt_method_speced );
depth = CgBackGetInlineDepth();
PCHWriteUInt( depth );
value = CgBackGetInlineRecursion();
PCHWriteUInt( value );
return( PCHCB_OK );
}
pch_status PCHWriteNames( void )
{
unsigned len;
int i;
idname *name;
idname **p;
PCHWriteVar( nameCount );
PCHWriteVar( nameDummyIndex );
p = nameTranslateTable;
for( i = 0; i < nameCount; ++i ) {
name = *p++;
len = strlen( name->name );
DbgAssert( len != 0 );
PCHWriteUInt( len );
PCHWrite( &(name->xhash), NAME_SIZE_PCH + len + 1 );
}
PCHWriteUInt( 0 );
return( PCHCB_OK );
}
pch_status PCHWriteModuleData( void )
{
uint_8 has_state_table;
SymbolPCHWrite( module_init_func );
ScopePCHWrite( module_init_scope );
ScopePCHWrite( module_fd.fn_scope );
has_state_table = module_fd.has_state_tab;
PCHWriteVar( has_state_table );
LabelPCHWrite( &module_fd.label_mem );
return( PCHCB_OK );
}
static void saveRewriteTokens( void *e, carve_walk_base *d )
{
REWRITE_TOKENS *s = e;
REWRITE_TOKENS *save_next;
if( s->free ) {
return;
}
save_next = s->next;
s->next = RewriteTokensGetIndex( save_next );
PCHWriteCVIndex( d->index );
PCHWriteVar( *s );
s->next = save_next;
}
void PCHWriteUInt( unsigned v )
/*****************************/
{
unsigned write_value;
if( sizeof( unsigned ) <= amountLeft ) {
DbgAssert( (((unsigned)(pointer_int)bufferCursor) & ( PCH_ALIGN - 1 )) == 0 );
*((unsigned *)bufferCursor) = v;
bufferCursor += sizeof( unsigned );
amountLeft -= sizeof( unsigned );
return;
}
write_value = v;
PCHWriteVar( write_value );
}
static void dumpCheckData( char *include_file )
{
SRCFILE src;
time_t stamp;
auto char buff[_MAX_PATH];
PCHWriteVar( GenSwitches );
PCHWriteVar( TargetSwitches );
PCHWriteUInt( ErrPCHVersion() );
PCHWriteUInt( TYPC_LAST );
PCHWriteUInt( sizeof( COMP_FLAGS ) );
PCHWriteVar( CompFlags );
dumpFileString( WholeFName );
include_file = IoSuppFullPath( include_file, buff, sizeof( buff ) );
dumpFileString( include_file );
getcwd( buff, sizeof( buff ) );
dumpFileString( buff );
HFileListStart();
for( ; ; ) {
HFileListNext( buff );
dumpFileString( buff );
if( buff[0] == '\0' ) break;
}
src = SrcFileNotReadOnly( SrcFileWalkInit() );
for( ; src != NULL; ) {
if( ! IsSrcFilePrimary( src ) ) {
dumpFileString( SrcFileName( src ) );
stamp = SrcFileTimeStamp( src );
PCHWriteVar( stamp );
}
src = SrcFileNotReadOnly( SrcFileWalkNext( src ) );
}
buff[0] = '\0';
dumpFileString( buff );
PCHDumpMacroCheck();
}
static void saveConstant( void *e, carve_walk_base *d )
{
POOL_CON *fcon = e;
POOL_CON *save_next;
if( fcon->free ) {
return;
}
save_next = fcon->next;
fcon->next = ConstantPoolGetIndex( save_next );
PCHWriteCVIndex( d->index );
PCHWriteVar( *fcon );
if( fcon->flt ) {
PCHWrite( fcon->u.s.fp_constant, fcon->u.s.len );
}
fcon->next = save_next;
}
static void dumpHeader( void )
{
auto precompiled_header_header header;
memcpy( header.text_header, PHH_TEXT_HEADER, TEXT_HEADER_SIZE );
header.signature[0] = PHH_SIGNATURE_0;
header.signature[1] = PHH_SIGNATURE_1;
header.signature[2] = PHH_SIGNATURE_2;
header.signature[3] = PHH_SIGNATURE_3;
header.major_version = PHH_MAJOR;
header.minor_version = PHH_MINOR;
header.target_architecture = PHH_TARG_ARCHITECTURE;
header.host_system = PHH_HOST_SYSTEM;
header.host_architecture = PHH_HOST_ARCHITECTURE;
header.corrupted = PHH_CORRUPTED_YES;
header.browse_info = 0;
PCHWriteVar( header );
}
static void saveTokenLocn( void *e, carve_walk_base *d )
{
SYM_TOKEN_LOCN *b = e;
SRCFILE save_src_file;
if( b->u.dwh == -1 ) {
return;
}
DbgAssert( b->u.dwh == 0 );
save_src_file = b->tl.src_file;
b->tl.src_file = SrcFileGetIndex( save_src_file );
#ifndef NDEBUG
if( b->u.dwh != 0 ) {
CFatal( "token locn contains dwarf info!" );
}
#endif
PCHWriteCVIndex( d->index );
PCHWriteVar( *b );
b->tl.src_file = save_src_file;
}
static void saveTypeSig( void *e, carve_walk_base *d )
{
TYPE_SIG *s = e;
TYPE_SIG *save_next;
TYPE_SIG *save_base;
TYPE save_type;
SYMBOL save_sym;
SYMBOL save_dtor;
SYMBOL save_default_ctor;
SYMBOL save_copy_ctor;
if( s->free ) {
return;
}
save_next = s->next;
s->next = TypeSigGetIndex( save_next );
save_base = s->base;
s->base = TypeSigGetIndex( save_base );
save_type = s->type;
s->type = TypeGetIndex( save_type );
save_sym = s->sym;
s->sym = SymbolGetIndex( save_sym );
save_dtor = s->dtor;
s->dtor = SymbolGetIndex( save_dtor );
save_default_ctor = s->default_ctor;
s->default_ctor = SymbolGetIndex( save_default_ctor );
save_copy_ctor = s->copy_ctor;
s->copy_ctor = SymbolGetIndex( save_copy_ctor );
PCHWriteCVIndex( d->index );
PCHWriteVar( *s );
s->next = save_next;
s->base = save_base;
s->type = save_type;
s->sym = save_sym;
s->dtor = save_dtor;
s->default_ctor = save_default_ctor;
s->copy_ctor = save_copy_ctor;
}
