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;
}
void AsmSysPCHWriteCode( AUX_INFO *info )
/***************************************/
{
BYTE_SEQ_SYM sym;
byte_seq_len code_length;
byte_seq_len seq_size;
unsigned fixup;
byte_seq *code;
byte *d;
byte *s;
byte *c;
byte *p;
byte *tmp_buff;
#ifndef NDEBUG
byte buff[8];
#else
byte buff[1024];
#endif
seq_size = 0;
code = info->code;
if( code == NULL ) {
/* no code */
PCHWriteUInt( seq_size );
return;
}
code_length = code->length;
seq_size = offsetof( byte_seq, data ) + code_length;
PCHWriteUInt( seq_size );
if( !code->relocs ) {
/* code has no relocs */
PCHWrite( code, seq_size );
return;
}
/* code has relocs */
tmp_buff = buff;
if( seq_size > sizeof( buff ) ) {
tmp_buff = CMemAlloc( seq_size );
}
c = code->data;
s = code->data + code_length;
d = copyCodeLen( tmp_buff, code, offsetof( byte_seq, data ) );
for( p = c; p != s; ) {
if( p[0] == FLOATING_FIXUP_BYTE ) {
fixup = p[1];
*d++ = *p++;
*d++ = *p++;
if( fixup != FLOATING_FIXUP_BYTE ) {
switch( fixup ) {
case FIX_SYM_OFFSET:
case FIX_SYM_SEGMENT:
case FIX_SYM_RELOFF:
sym = SymbolGetIndex( *((BYTE_SEQ_SYM *)p) );
d = copyCodeLen( d, &sym, sizeof( sym ) );
p += sizeof( BYTE_SEQ_SYM );
d = copyCodeLen( d, p, sizeof( BYTE_SEQ_OFF ) );
p += sizeof( BYTE_SEQ_OFF );
break;
default:
break;
}
}
} else {
*d++ = *p++;
}
}
PCHWrite( tmp_buff, seq_size );
if( tmp_buff != buff ) {
CMemFree( tmp_buff );
}
}
