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