static void *checkArraySize( omf_file_handle ofh, void *old_arr, long num, long inc, long elem ) { long size; void *new_arr; assert( ofh ); assert( num >= 0 ); assert( inc > 0 ); assert( elem > 0 ); if( !( num % inc ) ) { size = ( num + inc ) * elem; new_arr = _ClientAlloc( ofh, size ); if( !new_arr ) return( NULL ); memset( new_arr, 0, size ); if( num ) { assert( old_arr ); size = num * elem; memcpy( new_arr, old_arr, size ); _ClientFree( ofh, old_arr ); } old_arr = new_arr; } return( old_arr ); }
static void emitSectionData( owl_file_handle file ) { //**************************************************** owl_section_info *curr; owl_offset relocs_size; owl_reloc_info *reloc; coff_reloc *next_reloc; coff_reloc *reloc_buffer; for( curr = file->sections; curr != NULL; curr = curr->next ) { emitSectionPadding( curr ); if( !_OwlSectionBSS( curr ) ) { OWLBufferEmit( curr->buffer ); } if( curr->first_reloc != NULL ) { relocs_size = sizeof( coff_reloc ) * curr->num_relocs; reloc_buffer = _ClientAlloc( file, relocs_size ); next_reloc = reloc_buffer; for( reloc = curr->first_reloc; reloc != NULL; reloc = reloc->next ) { emitReloc( file, reloc, next_reloc ); next_reloc++; } _ClientWrite( file, (const char *)reloc_buffer, relocs_size ); _ClientFree( file, reloc_buffer ); } // now emit linenumbers if( curr->num_linenums != 0 ) { OWLBufferEmit( curr->linenum_buffer ); } } }
static void emitSymbolTable( owl_file_handle file ) { //*************************************************** unsigned count; coff_offset symbol_table_size; owl_symbol_info *symbol; coff_symbol *symbol_buffer; symbol_table_size = numSymbols( file ) * sizeof( coff_symbol ); if( symbol_table_size != 0 ) { lastFunc = NULL; lastBf = NULL; lastFile = NULL; symbol_buffer = _ClientAlloc( file, symbol_table_size ); #if 1 memset( symbol_buffer, 0, symbol_table_size ); #else memset( symbol_buffer, 0xBB, symbol_table_size ); #endif count = 0; for( symbol = file->symbol_table->head; symbol != NULL; symbol = symbol->next ) { if( symbol->flags & OWL_SYM_DEAD ) continue; formatOneSymbol( symbol, &symbol_buffer[ count ] ); count += numAuxSymbols( symbol ) + 1; if( symComdat( symbol ) ) { formatComdatSymbol( symbol, &symbol_buffer[ count ] ); count += 1; } } _ClientWrite( file, (const char *)symbol_buffer, symbol_table_size ); _ClientFree( file, symbol_buffer ); } }
static void doReloc( owl_section_handle section, owl_reloc_info *reloc ) { //************************************************************************ owl_offset displacement; owl_offset old_loc; unsigned_32 data; unsigned_32 bit_mask; displacement = OWLRelocTargetDisp( section, reloc->location, reloc->symbol->offset ); bit_mask = OWLRelocBitMask( section->file, reloc ); // OWLBufferPatch( section->buffer, reloc->location, displacement, bitMask ); old_loc = OWLBufferTell( section->buffer ); OWLBufferSeek( section->buffer, reloc->location ); OWLBufferRead( section->buffer, reloc->location, (char *)&data, 4 ); if( section->file->format == OWL_FORMAT_COFF && section->file->info->cpu == OWL_CPU_PPC && reloc->type == OWL_RELOC_JUMP_REL ) { // ugly kludge for the MOTOROLA PPC linker displacement += reloc->location; } if( section->file->format == OWL_FORMAT_ELF && section->file->info->cpu == OWL_CPU_INTEL && reloc->type == OWL_RELOC_BRANCH_REL ) { // ugly kludge for 386 ELF objects displacement += 4; } data = (data&~bit_mask)|(((displacement&bit_mask)+(data&bit_mask))&bit_mask); OWLBufferWrite( section->buffer, (char *)&data, 4 ); OWLBufferSeek( section->buffer, old_loc ); _ClientFree( section->file, reloc ); section->num_relocs -= 1; }
static void binFini( owl_buffer *buffer ) { //***************************************** int i; for( i = 0; i < NUM_BINS; i++ ) { if( buffer->bins[ i ] == NULL ) break; _ClientFree( buffer->file, buffer->bins[ i ] ); } }
static void freeRelocs( owl_file_handle file, owl_reloc_info *relocs ) { /**********************************************************************/ owl_reloc_info *ptr; owl_reloc_info *next; for( ptr = relocs; ptr != NULL; ptr = next ) { next = ptr->next; _ClientFree( file, ptr ); } }
static void free_coff_sec_handles( coff_file_handle coff_file_hnd, coff_quantity num_alloced ) /********************************************************************************************/ { coff_quantity i; if( coff_file_hnd->coff_sec_hnd != NULL ) { for( i = 0; i < num_alloced; i++ ) { if( coff_file_hnd->coff_sec_hnd[i]->name_alloced ) { _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd[i]->name ); } _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd[i] ); } _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd ); } else { for( i = 0; i < num_alloced; i++ ) { _ClientFree( coff_file_hnd, coff_file_hnd->orig_sec_hnd[i] ); } } _ClientFree( coff_file_hnd, coff_file_hnd->orig_sec_hnd ); }
static void free_coff_sec_handles( coff_file_handle coff_file_hnd, int num_alloced ) /****************************************************************/ { int loop; if( coff_file_hnd->coff_sec_hnd != NULL ) { for( loop = 0; loop < num_alloced; loop++ ) { if( coff_file_hnd->coff_sec_hnd[loop]->name_alloced ) { _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd[loop]->name ); } _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd[loop] ); } _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd ); } else { for( loop = 0; loop < num_alloced; loop++ ) { _ClientFree( coff_file_hnd, coff_file_hnd->orig_sec_hnd[loop] ); } } _ClientFree( coff_file_hnd, coff_file_hnd->orig_sec_hnd ); }
static void emitSectionPadding( owl_section_info *curr ) { //******************************************************** char *buffer; owl_offset padding; padding = curr->x.coff.alignment_padding; if( padding != 0 ) { buffer = _ClientAlloc( curr->file, padding ); memset( buffer, 0, padding ); _ClientWrite( curr->file, buffer, padding ); _ClientFree( curr->file, buffer ); } }
static void AddCoffString( coff_lib_file *c_file, const char *name, size_t len ) { char *x; len++; // add space for terminator character if( ( c_file->string_table_size + len ) >= c_file->max_string_table_size ) { c_file->max_string_table_size *= 2; x = _ClientAlloc( c_file->coff_file_hnd, c_file->max_string_table_size ); if( x == NULL ) return; memcpy( x, c_file->string_table, c_file->string_table_size ); _ClientFree( c_file->coff_file_hnd, c_file->string_table ); c_file->string_table = x; } memcpy( c_file->string_table + c_file->string_table_size, name, len ); c_file->string_table_size += (unsigned_32)len; }
static void AddCoffString( coff_lib_file *c_file, char *name, int len ) { char *x; len++; if( ( c_file->string_table_size + len ) >= c_file->max_string_table_size ) { c_file->max_string_table_size *= 2; x = _ClientAlloc( c_file->coff_file_hnd, c_file->max_string_table_size ); if( x == NULL ) return; memcpy( x, c_file->string_table, c_file->string_table_size ); _ClientFree( c_file->coff_file_hnd, c_file->string_table ); c_file->string_table = x; } memcpy( c_file->string_table + c_file->string_table_size, name, len ); c_file->string_table_size += len; }
static void free_coff_file_hnd( coff_file_handle coff_file_hnd ) { int loop; coff_sec_handle coff_sec_hnd; if( coff_file_hnd->coff_sec_hnd ) { for( loop = 0; loop < coff_file_hnd->num_sections; loop++ ) { coff_sec_hnd = coff_file_hnd->coff_sec_hnd[loop]; if( coff_sec_hnd->type == ORL_SEC_TYPE_RELOCS ) { if( coff_sec_hnd->assoc.reloc.relocs ) { _ClientFree( coff_file_hnd, coff_sec_hnd->assoc.reloc.relocs ); } } if( coff_sec_hnd->name_alloced ) { _ClientFree( coff_file_hnd, coff_sec_hnd->name ); } _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd[loop] ); } _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd ); } _ClientFree( coff_file_hnd, coff_file_hnd->orig_sec_hnd ); if( coff_file_hnd->symbol_handles ) { for( loop = 0; loop < coff_file_hnd->num_symbols; loop++ ) { if( coff_file_hnd->symbol_handles[loop].name_alloced ) { _ClientFree( coff_file_hnd, coff_file_hnd->symbol_handles[loop].name ); } loop += coff_file_hnd->symbol_handles[loop].symbol->num_aux; } _ClientFree( coff_file_hnd, coff_file_hnd->symbol_handles ); } if( coff_file_hnd->sec_name_hash_table ) { ORLHashTableFree( coff_file_hnd->sec_name_hash_table ); } if( coff_file_hnd->implib_data != NULL ) { _ClientFree( coff_file_hnd, coff_file_hnd->implib_data ); } _ClientFree( coff_file_hnd, coff_file_hnd ); }
static void bufferCollapse( owl_buffer *buffer ) { //************************************************ char *bin; char *dst; unsigned i; assert( buffer->size == ( buffer->bin_size * NUM_BINS ) ); bin = _ClientAlloc( buffer->file, buffer->size ); for( dst = bin, i = 0; i < NUM_BINS; i++ ) { memcpy( dst, buffer->bins[ i ], buffer->bin_size ); _ClientFree( buffer->file, buffer->bins[ i ] ); buffer->bins[ i ] = NULL; dst += buffer->bin_size; } buffer->bins[ 0 ] = bin; buffer->bin_size = buffer->size; }
void OWLENTRY OWLSectionFree( owl_section_handle section ) { //********************************************************** owl_file_handle file; file = section->file; deleteSection( file, section ); if( section->buffer != NULL ) { OWLBufferFini( section->buffer ); } if( section->linenum_buffer != NULL ) { OWLBufferFini( section->linenum_buffer ); } if( section->first_reloc != NULL ) { freeRelocs( file, section->first_reloc ); } _ClientFree( file, section ); _Log(( file, "OWLSectionFree( %x )\n", section )); }
static void emitSectionHeaders( owl_file_handle file ) { //****************************************************** uint_32 section_table_size; coff_section_header *section_table; unsigned count; owl_section_info *curr; section_table_size = numSections( file ) * sizeof( coff_section_header ); if( section_table_size != 0 ) { section_table = _ClientAlloc( file, section_table_size ); count = 0; for( curr = file->sections; curr != NULL; curr = curr->next ) { formatSectionHeader( curr, §ion_table[ curr->index ] ); curr->index = count++; } _ClientWrite( file, (const char *)section_table, section_table_size ); _ClientFree( file, section_table ); } }
static orl_return checkSegmentLength( omf_sec_handle sh, uint_32 max ) { omf_bytes conts; assert( sh ); if( max > sh->size ) return( ORL_ERROR ); if( max > sh->assoc.seg.cur_size ) { max = ( max / STD_CODE_SIZE ) + 1; max *= STD_CODE_SIZE; conts = _ClientAlloc( sh->omf_file_hnd, max ); if( !conts ) return( ORL_OUT_OF_MEMORY ); memset( conts, 0, max ); if( sh->contents ) { memcpy( conts, sh->contents, sh->assoc.seg.cur_size ); _ClientFree( sh->omf_file_hnd, sh->contents ); } sh->contents = conts; sh->assoc.seg.cur_size = max; } return( ORL_OKAY ); }
static void free_coff_file_hnd( coff_file_handle coff_file_hnd ) { coff_quantity i; coff_sec_handle coff_sec_hnd; if( coff_file_hnd->coff_sec_hnd != NULL ) { for( i = 0; i < coff_file_hnd->num_sections; ++i ) { coff_sec_hnd = coff_file_hnd->coff_sec_hnd[i]; if( coff_sec_hnd->type == ORL_SEC_TYPE_RELOCS ) { if( coff_sec_hnd->assoc.reloc.relocs != NULL ) { _ClientFree( coff_file_hnd, (void *)coff_sec_hnd->assoc.reloc.relocs ); } } if( coff_sec_hnd->name_alloced ) { _ClientFree( coff_file_hnd, coff_sec_hnd->name ); } _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd[i] ); } _ClientFree( coff_file_hnd, coff_file_hnd->coff_sec_hnd ); } _ClientFree( coff_file_hnd, coff_file_hnd->orig_sec_hnd ); if( coff_file_hnd->symbol_handles != NULL ) { for( i = 0; i < coff_file_hnd->num_symbols; ++i ) { if( coff_file_hnd->symbol_handles[i].name_alloced ) { _ClientFree( coff_file_hnd, coff_file_hnd->symbol_handles[i].name ); } i += coff_file_hnd->symbol_handles[i].symbol->num_aux; } _ClientFree( coff_file_hnd, coff_file_hnd->symbol_handles ); } if( coff_file_hnd->sec_name_hash_table != NULL ) { ORLHashTableFree( coff_file_hnd->sec_name_hash_table ); } convert_import_library_fini( coff_file_hnd ); _ClientFree( coff_file_hnd, coff_file_hnd ); }
void OWLENTRY OWLFileFini( owl_file_handle file ) { //************************************************* owl_section_handle curr; owl_section_handle next; resolveRelativeRelocs( file ); resolveLabelNames( file ); resolveComdefSymbols( file ); if( file->format == OWL_FORMAT_COFF ) { COFFFileEmit( file ); } else { ELFFileEmit( file ); } for( curr = file->sections; curr != NULL; curr = next ) { next = curr->next; OWLSectionFree( curr ); } OWLSymbolTableFini( file->symbol_table ); OWLStringFini( file->string_table ); deleteFile( file->info, file ); _ClientFree( file, file ); }
static orl_return load_coff_sec_handles( coff_file_handle coff_file_hnd, coff_file_header *f_hdr ) /**********************************************************************/ { coff_section_header *s_hdr; coff_sec_handle coff_sec_hnd; coff_sec_handle coff_reloc_sec_hnd; coff_quantity i; coff_quantity num_reloc_secs = 0; coff_sec_offset *reloc_sec_offset; coff_sec_size *reloc_sec_size; coff_quantity reloc_secs_created; if( coff_file_hnd->num_sections == 0 ) { reloc_sec_offset = NULL; reloc_sec_size = NULL; coff_file_hnd->orig_sec_hnd = NULL; } else { reloc_sec_offset = (coff_sec_offset *)_ClientAlloc( coff_file_hnd, sizeof( coff_sec_offset ) * coff_file_hnd->num_sections ); if( reloc_sec_offset == NULL ) return( ORL_OUT_OF_MEMORY ); reloc_sec_size = (coff_sec_size *)_ClientAlloc( coff_file_hnd, sizeof( coff_sec_size ) * coff_file_hnd->num_sections ); if( reloc_sec_size == NULL ) { _ClientFree( coff_file_hnd, reloc_sec_offset ); return( ORL_OUT_OF_MEMORY ); } memset( reloc_sec_offset, 0, sizeof( coff_sec_offset ) * coff_file_hnd->num_sections ); memset( reloc_sec_size, 0, sizeof( coff_sec_size ) * coff_file_hnd->num_sections ); coff_file_hnd->orig_sec_hnd = (coff_sec_handle *)_ClientAlloc( coff_file_hnd, sizeof( coff_sec_handle ) * coff_file_hnd->num_sections ); if( coff_file_hnd->orig_sec_hnd == NULL ) { _ClientFree( coff_file_hnd, reloc_sec_offset ); _ClientFree( coff_file_hnd, reloc_sec_size ); return( ORL_OUT_OF_MEMORY ); } } coff_file_hnd->coff_sec_hnd = NULL; s_hdr = (coff_section_header *)coff_file_hnd->s_hdr_table_buffer; for( i = 0; i < coff_file_hnd->num_sections; ++i ) { coff_sec_hnd = (coff_sec_handle)_ClientAlloc( coff_file_hnd, sizeof( ORL_STRUCT( coff_sec_handle ) ) ); if( coff_sec_hnd == NULL ) { free_coff_sec_handles( coff_file_hnd, i ); _ClientFree( coff_file_hnd, reloc_sec_offset ); _ClientFree( coff_file_hnd, reloc_sec_size ); return( ORL_OUT_OF_MEMORY ); } coff_file_hnd->orig_sec_hnd[i] = coff_sec_hnd; if( s_hdr->name[0] != '/' ) { coff_sec_hnd->name = _ClientAlloc( coff_file_hnd, COFF_SEC_NAME_LEN + 1 ); if( coff_sec_hnd->name == NULL ) { free_coff_sec_handles( coff_file_hnd, i ); _ClientFree( coff_file_hnd, reloc_sec_offset ); _ClientFree( coff_file_hnd, reloc_sec_size ); return( ORL_OUT_OF_MEMORY ); } coff_sec_hnd->name_alloced = true; strncpy( coff_sec_hnd->name, s_hdr->name, COFF_SEC_NAME_LEN ); coff_sec_hnd->name[COFF_SEC_NAME_LEN] = 0; } else { coff_sec_hnd->name = s_hdr->name; coff_sec_hnd->name_alloced = false; } coff_sec_hnd->file_format = ORL_COFF; coff_sec_hnd->relocs_done = false; coff_sec_hnd->coff_file_hnd = coff_file_hnd; coff_sec_hnd->size = s_hdr->size; coff_sec_hnd->base = s_hdr->offset; coff_sec_hnd->offset = s_hdr->rawdata_ptr; coff_sec_hnd->hdr = s_hdr; determine_section_specs( coff_sec_hnd, s_hdr ); coff_sec_hnd->contents = NULL; coff_sec_hnd->assoc.normal.reloc_sec = NULL; reloc_sec_offset[i] = s_hdr->reloc_ptr; if( s_hdr->num_relocs > 0 ) { num_reloc_secs++; } reloc_sec_size[i] = s_hdr->num_relocs * sizeof( coff_reloc ); s_hdr++; } /* There are num_reloc_secs + 2 additional section handles to create (one each for the symbol and string tables) */ coff_file_hnd->coff_sec_hnd = (coff_sec_handle *)_ClientAlloc( coff_file_hnd, sizeof( coff_sec_handle ) * (coff_file_hnd->num_sections + num_reloc_secs + 2) ); if( coff_file_hnd->coff_sec_hnd == NULL ) { free_coff_sec_handles( coff_file_hnd, coff_file_hnd->num_sections ); _ClientFree( coff_file_hnd, reloc_sec_offset ); _ClientFree( coff_file_hnd, reloc_sec_size ); return( ORL_OUT_OF_MEMORY ); } memcpy( coff_file_hnd->coff_sec_hnd, coff_file_hnd->orig_sec_hnd, sizeof( coff_sec_handle ) * coff_file_hnd->num_sections ); reloc_secs_created = 0; for( i = 0; i < coff_file_hnd->num_sections; ++i ) { if( reloc_sec_size[i] > 0 ) { reloc_secs_created++; // create a reloc section coff_file_hnd->coff_sec_hnd[coff_file_hnd->num_sections + reloc_secs_created] = (coff_sec_handle)_ClientAlloc( coff_file_hnd, sizeof( ORL_STRUCT( coff_sec_handle ) ) ); coff_reloc_sec_hnd = coff_file_hnd->coff_sec_hnd[coff_file_hnd->num_sections + reloc_secs_created]; if( coff_reloc_sec_hnd == NULL ) { free_coff_sec_handles( coff_file_hnd, coff_file_hnd->num_sections + reloc_secs_created ); _ClientFree( coff_file_hnd, reloc_sec_offset ); _ClientFree( coff_file_hnd, reloc_sec_size ); return( ORL_OUT_OF_MEMORY ); } coff_reloc_sec_hnd->file_format = ORL_COFF; coff_reloc_sec_hnd->coff_file_hnd = coff_file_hnd; coff_reloc_sec_hnd->name = SectionNames[0]; // ".rel" coff_reloc_sec_hnd->name_alloced = false; coff_reloc_sec_hnd->relocs_done = false; coff_reloc_sec_hnd->size = reloc_sec_size[i]; coff_reloc_sec_hnd->base = 0; coff_reloc_sec_hnd->offset = reloc_sec_offset[i]; coff_reloc_sec_hnd->type = ORL_SEC_TYPE_RELOCS; coff_reloc_sec_hnd->flags = ORL_SEC_FLAG_NONE; coff_reloc_sec_hnd->hdr = NULL; coff_reloc_sec_hnd->assoc.reloc.orig_sec = coff_file_hnd->coff_sec_hnd[i]; coff_reloc_sec_hnd->assoc.reloc.relocs = NULL; coff_reloc_sec_hnd->align = 4; coff_file_hnd->coff_sec_hnd[i]->assoc.normal.reloc_sec = coff_reloc_sec_hnd; coff_file_hnd->coff_sec_hnd[coff_file_hnd->num_sections + reloc_secs_created - 1] = coff_reloc_sec_hnd; } } // create the symbol table section coff_file_hnd->symbol_table = (coff_sec_handle)_ClientAlloc( coff_file_hnd, sizeof( ORL_STRUCT( coff_sec_handle ) ) ); if( coff_file_hnd->symbol_table == NULL ) { free_coff_sec_handles( coff_file_hnd, i + coff_file_hnd->num_sections ); _ClientFree( coff_file_hnd, reloc_sec_offset ); _ClientFree( coff_file_hnd, reloc_sec_size ); return( ORL_OUT_OF_MEMORY ); } coff_file_hnd->symbol_table->file_format = ORL_COFF; coff_file_hnd->symbol_table->coff_file_hnd = coff_file_hnd; coff_file_hnd->symbol_table->name = SectionNames[1]; // ".symtab" coff_file_hnd->symbol_table->name_alloced = false; coff_file_hnd->symbol_table->relocs_done = false; coff_file_hnd->symbol_table->size = f_hdr->num_symbols * sizeof( coff_symbol ); coff_file_hnd->symbol_table->base = 0; coff_file_hnd->symbol_table->offset = f_hdr->sym_table; coff_file_hnd->symbol_table->hdr = NULL; coff_file_hnd->symbol_table->assoc.normal.reloc_sec = NULL; coff_file_hnd->symbol_table->type = ORL_SEC_TYPE_SYM_TABLE; coff_file_hnd->symbol_table->flags = ORL_SEC_FLAG_NONE; coff_file_hnd->symbol_table->align = 4; coff_file_hnd->coff_sec_hnd[coff_file_hnd->num_sections + reloc_secs_created] = coff_file_hnd->symbol_table; i++; // create the string table section coff_file_hnd->string_table = (coff_sec_handle)_ClientAlloc( coff_file_hnd, sizeof( ORL_STRUCT( coff_sec_handle ) ) ); if( coff_file_hnd->string_table == NULL ) { free_coff_sec_handles( coff_file_hnd, i + coff_file_hnd->num_sections ); _ClientFree( coff_file_hnd, reloc_sec_offset ); _ClientFree( coff_file_hnd, reloc_sec_size ); return( ORL_OUT_OF_MEMORY ); } coff_file_hnd->string_table->file_format = ORL_COFF; coff_file_hnd->string_table->coff_file_hnd = coff_file_hnd; coff_file_hnd->string_table->name = SectionNames[2]; // ".strtab" coff_file_hnd->string_table->name_alloced = false; coff_file_hnd->string_table->relocs_done = false; coff_file_hnd->string_table->size = 0; // determined later coff_file_hnd->string_table->base = 0; coff_file_hnd->string_table->offset = coff_file_hnd->symbol_table->offset + coff_file_hnd->symbol_table->size; coff_file_hnd->string_table->hdr = NULL; coff_file_hnd->string_table->assoc.normal.reloc_sec = NULL; coff_file_hnd->string_table->type = ORL_SEC_TYPE_STR_TABLE; coff_file_hnd->string_table->flags = ORL_SEC_FLAG_NONE; coff_file_hnd->string_table->align = 4; coff_file_hnd->coff_sec_hnd[coff_file_hnd->num_sections + reloc_secs_created + 1] = coff_file_hnd->string_table; _ClientFree( coff_file_hnd, reloc_sec_offset ); _ClientFree( coff_file_hnd, reloc_sec_size ); coff_file_hnd->num_sections += num_reloc_secs + 2; return( ORL_OKAY ); }
static void emitStringTable( owl_file_handle file ) { //*************************************************** _ClientWrite( file, (const char *)file->x.coff.string_table, sizeof( coff_string_table ) + file->x.coff.string_table->size - 5 ); _ClientFree( file, file->x.coff.string_table ); }
static orl_return applyBakpats( omf_file_handle ofh ) { omf_sec_handle sh; orl_return err = ORL_OKAY; omf_tmp_bkfix tbf; uint_8 *pfix8; uint_16 *pfix16; uint_32 *pfix32; assert( ofh ); assert( ofh->bakpat ); ofh->bakpat->last_fixup = NULL; /* Go through all the backpatches and update the segment data. The BAKPATs * aren't normal fixups and may modify all sorts of instructions. */ while( ofh->bakpat->first_fixup ) { tbf = ofh->bakpat->first_fixup; ofh->bakpat->first_fixup = tbf->next; assert( tbf->segidx || tbf->symidx ); if( tbf->segidx ) sh = findSegment( ofh, tbf->segidx ); else sh = findComDatByName( ofh, tbf->symidx ); if( !sh ) { err = ORL_ERROR; break; } switch( tbf->reltype ) { case ORL_RELOC_TYPE_WORD_8: pfix8 = sh->contents + tbf->offset; *pfix8 += tbf->disp; break; case ORL_RELOC_TYPE_WORD_16: pfix16 = (uint_16 *)(sh->contents + tbf->offset); *pfix16 += tbf->disp; break; case ORL_RELOC_TYPE_WORD_32: pfix32 = (uint_32 *)(sh->contents + tbf->offset); *pfix32 += tbf->disp; break; default: assert( 0 ); err = ORL_ERROR; break; } if( err != ORL_OKAY ) break; _ClientFree( ofh, tbf ); } assert( !(ofh->status & OMF_STATUS_ADD_BAKPAT) ); /* Free the entire bakpat structure as well. */ _ClientFree( ofh, ofh->bakpat ); ofh->bakpat = NULL; return( err ); }
static orl_return expandPrevLIData( omf_file_handle ofh ) { omf_sec_handle sh; int size; omf_bytes buffer; orl_return err = ORL_OKAY; unsigned char tmp[1024]; omf_tmp_fixup ftr; orl_sec_offset offset; assert( ofh ); assert( ofh->work_sec ); assert( ofh->lidata ); sh = ofh->work_sec; size = ofh->lidata->size; if( size > 1024 ) { buffer = _ClientAlloc( ofh, size ); if( !buffer ) return( ORL_OUT_OF_MEMORY ); } else { buffer = tmp; } /* we must remember to save the current offset of the lidata and then * restore it */ ofh->lidata->last_fixup = NULL; offset = sh->assoc.seg.cur_offset; /* make a working copy of the LIDATA */ memcpy( buffer, sh->contents + offset, size ); while( ofh->lidata->size > 0 ) { err = writeAndFixupLIData( ofh, sh, buffer ); if( err != ORL_OKAY ) return( err ); } sh->assoc.seg.cur_offset = offset; if( size > 1024 ) { _ClientFree( ofh, buffer ); } assert( !( ofh->status & OMF_STATUS_ADD_MASK ) ); /* Destroy original fixups */ while( ofh->lidata->first_fixup ) { ftr = ofh->lidata->first_fixup; ofh->lidata->first_fixup = ftr->next; _ClientFree( ofh, ftr ); } /* Add the generated fixups */ while( ofh->lidata->new_fixup ) { ftr = ofh->lidata->new_fixup; err = OmfAddFixupp( ofh, ftr->is32, ftr->mode, ftr->location, ftr->offset, ftr->fmethod, ftr->fidx, ftr->tmethod, ftr->tidx, ftr->disp ); if( err != ORL_OKAY ) break; ofh->lidata->new_fixup = ftr->next; _ClientFree( ofh, ftr ); } ofh->lidata->last_fixup = NULL; return( err ); }
static void FiniCoffLibFile( coff_lib_file *c_file ) { _ClientFree( c_file->coff_file_hnd, c_file->string_table ); }
void OWLENTRY OWLBufferFini( owl_buffer *buffer ) { //************************************************* binFini( buffer ); _ClientFree( buffer->file, buffer ); }