From 87f86b4ec66450e49987cc9cbc1b21e5fde8070c Mon Sep 17 00:00:00 2001 From: David Henkel-Wallace Date: Thu, 4 Apr 1991 02:12:28 +0000 Subject: [PATCH] Initial revision --- bfd/ieee.c | 1919 ++++++++++++++++++++++++++++++++++++++++++++++++ bfd/libieee.h | 90 +++ bfd/liboasys.h | 70 ++ bfd/oasys.c | 985 +++++++++++++++++++++++++ bfd/obstack.c | 335 +++++++++ bfd/obstack.h | 416 +++++++++++ 6 files changed, 3815 insertions(+) create mode 100644 bfd/ieee.c create mode 100644 bfd/libieee.h create mode 100644 bfd/liboasys.h create mode 100644 bfd/oasys.c create mode 100755 bfd/obstack.c create mode 100755 bfd/obstack.h diff --git a/bfd/ieee.c b/bfd/ieee.c new file mode 100644 index 0000000000..f69adbde3c --- /dev/null +++ b/bfd/ieee.c @@ -0,0 +1,1919 @@ +/* + + bfd backend for ieee objects. + + IEEE format is a stream of records, which we parse using a simple one + token (which is one byte in this lexicon) lookahead recursive decent + parser. + + On output, this module creates files with the parts in this order: + header + external_part, + data_part, + section_part, + + + + */ + + +#include "sysdep.h" +#include "bfd.h" +#include "libbfd.h" +#include "obstack.h" +#include "ieee.h" +#include "libieee.h" + + +#define obstack_chunk_alloc malloc +#define obstack_chunk_free free + +typedef void generic_symbol_type; +static bfd_byte current_c; + +/*************************************************************************** + Functions for writing to ieee files in the strange way that the + standard requires: +*/ + + +static void +ieee_write_byte(abfd, byte) +bfd *abfd; +bfd_byte byte; +{ + bfd_write(&byte, 1, 1, abfd); +} + + +static void +ieee_write_2bytes(abfd, bytes) +bfd *abfd; +int bytes; +{ + bfd_byte buffer[2]; + buffer[0] = bytes >> 8; + buffer[1] = bytes & 0xff; + + bfd_write(buffer, 1, 2, abfd); +} + +static void +ieee_write_int(abfd, value) +bfd *abfd; +bfd_vma value; +{ + if (value >= 0 && value <= 127) { + ieee_write_byte(abfd, value); + } + else { + unsigned int length; + /* How many significant bytes ? */ + /* FIXME FOR LONGER INTS */ + if (value & 0xff000000) { + length = 4; + } + else if (value & 0x00ff0000) { + length = 3; + } + else if (value & 0x0000ff00) { + length = 2; + } + else length = 1; + + ieee_write_byte(abfd, ieee_number_repeat_start_enum + length); + switch (length) { + case 4: + ieee_write_byte(abfd, value >> 24); + case 3: + ieee_write_byte(abfd, value >> 16); + case 2: + ieee_write_byte(abfd, value >> 8); + case 1: + ieee_write_byte(abfd, value); + } + } +} + +static void +ieee_write_id(abfd, id) +bfd *abfd; +char *id; +{ + size_t length = strlen(id); + if (length >= 0 && length <= 127) { + ieee_write_byte(abfd, length); + } + else if (length < 255) { + ieee_write_byte(abfd, ieee_extension_length_1_enum); + ieee_write_byte(abfd, length); + } + else if (length < 65535) { + ieee_write_byte(abfd, ieee_extension_length_2_enum); + ieee_write_byte(abfd, length >> 8); + ieee_write_byte(abfd, length & 0xff); + } + else { + BFD_FAIL(); + } + bfd_write((bfd_byte *)id, 1, length, abfd); +} +/*************************************************************************** +Functions for reading from ieee files in the strange way that the +standard requires: +*/ +static bfd_byte +this_byte(abfd) +bfd *abfd; +{ + return current_c; +} + +static void +next_byte(abfd) +bfd *abfd; +{ + if ( bfd_read(¤t_c, 1, 1, abfd) != 1) { + BFD_FAIL(); + } + +} + + +static bfd_byte this_byte_and_next(abfd) +bfd *abfd; +{ + bfd_byte r = this_byte(abfd); + next_byte(abfd); + return r; +} + + + +static unsigned short read_2bytes(abfd) +bfd *abfd; +{ + unsigned char c1 = this_byte_and_next(abfd); + unsigned char c2 = this_byte_and_next(abfd); + return (c1<<8 ) | c2; + +} + +static void +bfd_get_string(abfd, string, length) +bfd *abfd; +char *string; +size_t length; +{ + size_t i; + for (i= 0; i < length; i++) { + string[i] = this_byte_and_next(abfd); + } +} + +static char *read_id(abfd) +bfd *abfd; +{ + size_t length; + char *string; + length = this_byte_and_next(abfd); + if (length >= 0x00 && length <= 0x7f) { + /* Simple string of length 0 to 127 */ + } + else if (length == 0xde) { + /* Length is next byte, allowing 0..255 */ + length = this_byte_and_next(abfd); + } + else if (length == 0xdf) { + /* Length is next two bytes, allowing 0..65535 */ + length = this_byte_and_next(abfd) ; + length = (length * 256) + this_byte_and_next(abfd); + } + /* Buy memory and read string */ + string = malloc(length+1); + bfd_get_string(abfd, string, length); + string[length] = 0; + return string; +} + +static void +ieee_write_expression(abfd, value, section, symbol) +bfd*abfd; +bfd_vma value; +asection *section; +asymbol *symbol; +{ + unsigned int plus_count = 0; + ieee_write_int(abfd, value); + if (section != (asection *)NULL) { + plus_count++; + ieee_write_byte(abfd, ieee_variable_L_enum); + ieee_write_byte(abfd, section->index +IEEE_SECTION_NUMBER_BASE); + } + + if (symbol != (asymbol *)NULL) { + plus_count++; + if ((symbol->flags & BSF_UNDEFINED ) || + (symbol->flags & BSF_FORT_COMM)) { + ieee_write_byte(abfd, ieee_variable_X_enum); + ieee_write_int(abfd, symbol->value); + } + else if (symbol->flags & BSF_GLOBAL) { + ieee_write_byte(abfd, ieee_variable_I_enum); + ieee_write_int(abfd, symbol->value); + } + else { + BFD_FAIL(); + } + } + + while (plus_count != 0) { + ieee_write_byte(abfd, ieee_function_plus_enum); + plus_count--; + } + +} + + + + + + + + + +/*****************************************************************************/ + +/* +writes any integer into the buffer supplied and always takes 5 bytes +*/ +static void +ieee_write_int5(buffer, value) +bfd_byte*buffer; +bfd_vma value; +{ + buffer[0] = ieee_number_repeat_4_enum; + buffer[1] = (value >> 24 ) & 0xff; + buffer[2] = (value >> 16 ) & 0xff; + buffer[3] = (value >> 8 ) & 0xff; + buffer[4] = (value >> 4 ) & 0xff; +} + + + +static boolean +parse_int(abfd, value_ptr) +bfd *abfd; +bfd_vma *value_ptr; +{ + int value = this_byte(abfd); + int result; + if (value >= 0 && value <= 127) { + *value_ptr = value; + next_byte(abfd); + return true; + } + else if (value >= 0x80 && value <= 0x88) { + unsigned int count = value & 0xf; + result = 0; + next_byte(abfd); + while (count) { + result =(result << 8) | this_byte_and_next(abfd); + count--; + } + *value_ptr = result; + return true; + } + return false; +} +static int parse_i(abfd, ok) +bfd *abfd; +boolean *ok; +{ + bfd_vma x; + *ok = parse_int(abfd, &x); + return x; +} + +static bfd_vma must_parse_int(abfd) +bfd *abfd; +{ + bfd_vma result; + BFD_ASSERT(parse_int(abfd, &result) == true); + return result; +} + +typedef struct +{ + bfd_vma value; + asection *section; + ieee_symbol_index_type symbol; +} ieee_value_type; + + +static +reloc_howto_type abs32_howto + = {1,0,2,32,0,0,0,true,0,"abs32",false,0xffffffff}; +static +reloc_howto_type abs16_howto + = {1,0,1,16,0,0,0,true,0,"abs16",false,0x0000ffff}; + +static ieee_symbol_index_type NOSYMBOL = { 0, 0}; + + +void +frob(abfd, value, section, symbol, pcrel, extra) +bfd *abfd; +bfd_vma *value; +asection **section; +ieee_symbol_index_type *symbol; +boolean *pcrel; +unsigned int *extra; +{ +#define POS sp[1] +#define TOS sp[0] +#define NOS sp[-1] +#define INC sp++; +#define DEC sp--; + + boolean loop = true; + ieee_value_type stack[10]; + + /* The stack pointer always points to the next unused location */ +#define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC; +#define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value; + ieee_value_type *sp = stack; + + while (loop) { + switch (this_byte(abfd)) + { + case ieee_variable_P_enum: + /* P variable, current program counter for section n */ + { + int section_n ; + next_byte(abfd); + section_n = must_parse_int(abfd); + PUSH(NOSYMBOL, 0, + TOS.value = ieee_data(abfd)->section_table[section_n]->vma + + ieee_per_section(ieee_data(abfd)->section_table[section_n])->pc); + break; + } + case ieee_variable_L_enum: + /* L variable address of section N */ + next_byte(abfd); + PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0); + break; + case ieee_variable_R_enum: + /* R variable, logical address of section module */ + /* FIXME, this should be different to L */ + next_byte(abfd); + PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0); + break; + case ieee_variable_S_enum: + /* S variable, size in MAUS of section module */ + next_byte(abfd); + PUSH(NOSYMBOL, + 0, + ieee_data(abfd)->section_table[must_parse_int(abfd)]->size); + break; + + case ieee_variable_X_enum: + /* Push the address of external variable n */ + { + ieee_symbol_index_type sy; + next_byte(abfd); + sy.index = (int)(must_parse_int(abfd)) ; + sy.letter = 'X'; + + PUSH(sy, 0, 0); + } + break; + case ieee_function_minus_enum: + { + bfd_vma value1, value2; + asection *section; + ieee_symbol_index_type sy; + next_byte(abfd); + + POP(sy, section, value1); + POP(sy, section, value2); + PUSH(NOSYMBOL, 0, value1-value2); + } + break; + case ieee_function_plus_enum: + { + bfd_vma value1, value2; + asection *section1; + asection *section2; + ieee_symbol_index_type sy; + next_byte(abfd); + + POP(sy, section1, value1); + POP(sy, section2, value2); + PUSH(NOSYMBOL, section1 ? section1: section2, value1+value2); + } + break; + default: + { + bfd_vma va; + BFD_ASSERT(this_byte(abfd) < ieee_variable_A_enum + || this_byte(abfd) > ieee_variable_Z_enum); + if (parse_int(abfd, &va)) + { + PUSH(NOSYMBOL,0, va); + } + else { + /* + Thats all that we can understand. As far as I can see + there is a bug in the Microtec IEEE output which I'm + using to scan, whereby the comma operator is ommited + sometimes in an expression, giving expressions with too + many terms. We can tell if that's the case by ensuring + that sp == stack here. If not, then we've pushed + something too far. - + */ + + POP(*symbol, *section, *value); + if (sp != stack) { + BFD_ASSERT(*section == 0); + *extra = *value; + /* Get what should be returned */ + POP(*symbol, *section, *value); + } + else { + *extra = 0; + } + loop = false; + } + } + + } + } +} + +static void +ieee_seek(abfd, offset, rel) +bfd *abfd; +file_ptr offset; +boolean rel; +{ + (void) bfd_seek(abfd, offset, rel); + /* Prime look ahead token */ + next_byte(abfd); +} + +static void +ieee_slurp_external_symbols(abfd) +bfd *abfd; +{ + ieee_data_type *ieee = ieee_data(abfd); + file_ptr offset = ieee->w.r.external_part; + + ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols; + ieee_symbol_type **prev_reference_ptr = &ieee->external_reference; + ieee_symbol_type *symbol; + unsigned int symbol_count = 0; + boolean loop = true; + + ieee->symbol_table_full = true; + + ieee_seek(abfd, offset ,false); + + while (loop) { + switch (this_byte(abfd)) { + case ieee_external_symbol_enum: + next_byte(abfd); + symbol = (ieee_symbol_type *)malloc(sizeof(ieee_symbol_type)); + + *prev_symbols_ptr = symbol; + prev_symbols_ptr= &symbol->next; + symbol->index = must_parse_int(abfd); + if (symbol->index > ieee->external_symbol_max_index) { + ieee->external_symbol_max_index = symbol->index; + } + BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index); + symbol_count++; + symbol->symbol.the_bfd = abfd; + symbol->symbol.name = read_id(abfd); + symbol->symbol.udata = (void *)NULL; + symbol->symbol.flags = BSF_NO_FLAGS; + break; + case ieee_attribute_record_enum >> 8: + { + unsigned int symbol_name_index; + unsigned int symbol_type_index; + unsigned int symbol_attribute_def; + bfd_vma value; + next_byte(abfd); /* Skip prefix */ + next_byte(abfd); + symbol_name_index = must_parse_int(abfd); + symbol_type_index = must_parse_int(abfd); + symbol_attribute_def = must_parse_int(abfd); + + parse_int(abfd,&value); + + } + break; + case ieee_value_record_enum >> 8: + { + unsigned int symbol_name_index; + ieee_symbol_index_type symbol_ignore; + boolean *pcrel_ignore; + unsigned int extra_ignore; + next_byte(abfd); + next_byte(abfd); + + symbol_name_index = must_parse_int(abfd); + frob(abfd, + &symbol->symbol.value, + &symbol->symbol.section, + &symbol_ignore, + &pcrel_ignore, + &extra_ignore); + if (symbol->symbol.section != (asection *)NULL) { + symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT; + } + else { + symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT | BSF_ABSOLUTE; + } + } + break; + case ieee_weak_external_reference_enum: + { bfd_vma size; + bfd_vma value ; + next_byte(abfd); + /* Throw away the external reference index */ + (void)must_parse_int(abfd); + /* Fetch the default size if not resolved */ + size = must_parse_int(abfd); + /* Fetch the defautlt value if available */ + if ( parse_int(abfd, &value) == false) { + value = 0; + } + /* This turns into a common */ + symbol->symbol.flags = BSF_FORT_COMM; + symbol->symbol.value = size; + } + break; + + case ieee_external_reference_enum: + next_byte(abfd); + symbol = (ieee_symbol_type *)malloc(sizeof(ieee_symbol_type)); + symbol_count++; + *prev_reference_ptr = symbol; + prev_reference_ptr = &symbol->next; + symbol->index = must_parse_int(abfd); + symbol->symbol.the_bfd = abfd; + symbol->symbol.name = read_id(abfd); + symbol->symbol.udata = (void *)NULL; + symbol->symbol.section = (asection *)NULL; + symbol->symbol.value = (bfd_vma)0; + symbol->symbol.flags = BSF_UNDEFINED; + if (symbol->index > ieee->external_reference_max_index) { + ieee->external_reference_max_index = symbol->index; + } + BFD_ASSERT (symbol->index >= ieee->external_reference_min_index); + break; + + default: + loop = false; + } + } + + if (ieee->external_symbol_max_index != 0) { + ieee->external_symbol_count = + ieee->external_symbol_max_index - + ieee->external_symbol_min_index + 1 ; + } + else { + ieee->external_symbol_count = 0; + } + + + if(ieee->external_reference_max_index != 0) { + ieee->external_reference_count = + ieee->external_reference_max_index - + ieee->external_reference_min_index + 1; + } + else { + ieee->external_reference_count = 0; + } + + abfd->symcount = + ieee->external_reference_count + ieee->external_symbol_count; + + if (symbol_count != abfd->symcount) { + /* There are gaps in the table -- */ + ieee->symbol_table_full = false; + } + *prev_symbols_ptr = (ieee_symbol_type *)NULL; + *prev_reference_ptr = (ieee_symbol_type *)NULL; +} + +static void +ieee_slurp_symbol_table(abfd) +bfd *abfd; +{ + if (ieee_data(abfd)->read_symbols == false) { + ieee_slurp_external_symbols(abfd); + ieee_data(abfd)->read_symbols= true; + } +} + +size_t +ieee_get_symtab_upper_bound (abfd) +bfd *abfd; +{ + ieee_slurp_symbol_table (abfd); + + return (abfd->symcount != 0) ? + (abfd->symcount+1) * (sizeof (ieee_symbol_type *)) : 0; +} + +/* +Move from our internal lists to the canon table, and insert in +symbol index order +*/ + +extern bfd_target ieee_vec; +unsigned int +ieee_get_symtab (abfd, location) +bfd *abfd; +asymbol **location; +{ + ieee_symbol_type *symp; + static bfd dummy_bfd; + static asymbol empty_symbol = + { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_FAKE}; + + ieee_data_type *ieee = ieee_data(abfd); + dummy_bfd.xvec= &ieee_vec; + ieee_slurp_symbol_table(abfd); + + if (ieee->symbol_table_full == false) { + /* Arrgh - there are gaps in the table, run through and fill them */ + /* up with pointers to a null place */ + unsigned int i; + for (i= 0; i < abfd->symcount; i++) { + location[i] = &empty_symbol; + } + } + + + ieee->external_symbol_base_offset= - ieee->external_symbol_min_index; + for (symp = ieee_data(abfd)->external_symbols; + symp != (ieee_symbol_type *)NULL; + symp = symp->next) { + /* Place into table at correct index locations */ + location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol; + + } + + /* The external refs are indexed in a bit */ + ieee->external_reference_base_offset = + - ieee->external_reference_min_index +ieee->external_symbol_count ; + + for (symp = ieee_data(abfd)->external_reference; + symp != (ieee_symbol_type *)NULL; + symp = symp->next) { + location[symp->index + ieee->external_reference_base_offset] = + &symp->symbol; + + } + + + + location[abfd->symcount] = (asymbol *)NULL; + + return abfd->symcount; +} + + +static void +ieee_slurp_sections(abfd) +bfd *abfd; +{ + ieee_data_type *ieee = ieee_data(abfd); + file_ptr offset = ieee->w.r.section_part; + + asection *section = (asection *)NULL; + + if (offset != 0) { + bfd_byte section_type[3]; + ieee_seek(abfd, offset, false); + while (true) { + switch (this_byte(abfd)) { + case ieee_section_type_enum: + { + unsigned int section_index ; + next_byte(abfd); + section_index = must_parse_int(abfd); + /* Fixme to be nice about a silly number of sections */ + BFD_ASSERT(section_index < NSECTIONS); + + section = bfd_make_section(abfd, " tempname"); + ieee->section_table[section_index] = section; + section->flags = SEC_NO_FLAGS; + section->target_index = section_index; + section_type[0] = this_byte_and_next(abfd); + switch (section_type[0]) { + case 0xC3: + section_type[1] = this_byte(abfd); + section->flags = SEC_LOAD; + switch (section_type[1]) { + case 0xD0: + /* Normal code */ + next_byte(abfd); + section->flags |= SEC_LOAD | SEC_CODE; + break; + case 0xC4: + next_byte(abfd); + section->flags |= SEC_LOAD | SEC_DATA; + /* Normal data */ + break; + case 0xD2: + next_byte(abfd); + /* Normal rom data */ + section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; + break; + default: + break; + } + } + section->name = read_id(abfd); + { bfd_vma parent, brother, context; + parse_int(abfd, &parent); + parse_int(abfd, &brother); + parse_int(abfd, &context); + } + + + } + break; + case ieee_section_alignment_enum: + { + unsigned int section_index; + bfd_vma value; + next_byte(abfd); + section_index = must_parse_int(abfd); + if (section_index > ieee->section_count) { + ieee->section_count = section_index; + } + ieee->section_table[section_index]->alignment_power = + bfd_log2(must_parse_int(abfd)); + (void)parse_int(abfd, & value); + } + break; + case ieee_e2_first_byte_enum: + { + ieee_record_enum_type t = read_2bytes(abfd); + switch (t) { + case ieee_section_size_enum: + section = ieee->section_table[must_parse_int(abfd)]; + section->size = must_parse_int(abfd); + break; + case ieee_physical_region_size_enum: + section = ieee->section_table[must_parse_int(abfd)]; + section->size = must_parse_int(abfd); + break; + case ieee_region_base_address_enum: + section = ieee->section_table[must_parse_int(abfd)]; + section->vma = must_parse_int(abfd); + break; + case ieee_mau_size_enum: + must_parse_int(abfd); + must_parse_int(abfd); + break; + case ieee_m_value_enum: + must_parse_int(abfd); + must_parse_int(abfd); + break; + case ieee_section_base_address_enum: + section = ieee->section_table[must_parse_int(abfd)]; + section->vma = must_parse_int(abfd); + break; + case ieee_section_offset_enum: + (void) must_parse_int(abfd); + (void) must_parse_int(abfd); + break; + default: + return; + } + } + break; + default: + return; + } + } + } +} + +/*********************************************************************** +* archive stuff +*/ +bfd_target * +ieee_archive_p(abfd) +bfd *abfd; +{ + char *library; + boolean loop; + ieee_ar_data_type *ar; + unsigned int i; + ieee_seek(abfd, (file_ptr) 0, false); + if (this_byte(abfd) != Module_Beginning) return (bfd_target*)NULL; + next_byte(abfd); + library= read_id(abfd); + if (strcmp(library , "LIBRARY") != 0) { + free(library); + return (bfd_target *)NULL; + } + /* Throw away the filename */ + free( read_id(abfd)); + /* This must be an IEEE archive, so we'll buy some space to do + things */ + ar = (ieee_ar_data_type *) malloc(sizeof(ieee_ar_data_type)); + ieee_ar_data(abfd) = ar; + ar->element_count = 0; + ar->element_index = 0; + obstack_init(&ar->element_obstack); + + next_byte(abfd); /* Drop the ad part */ + must_parse_int(abfd); /* And the two dummy numbers */ + must_parse_int(abfd); + + loop = true; + /* Read the index of the BB table */ + while (loop) { + ieee_ar_obstack_type t; + int rec =read_2bytes(abfd); + if (rec ==ieee_assign_value_to_variable_enum) { + int record_number = must_parse_int(abfd); + t.file_offset = must_parse_int(abfd); + t.abfd = (bfd *)NULL; + ar->element_count++; + obstack_grow(&ar->element_obstack, &t, sizeof(t)); + } + else loop = false; + } + ar->elements = (ieee_ar_obstack_type *)obstack_base(&ar->element_obstack); + + /* Now scan the area again, and replace BB offsets with file */ + /* offsets */ + + + for (i = 2; i < ar->element_count; i++) { + ieee_seek(abfd, ar->elements[i].file_offset, false); + next_byte(abfd); /* Drop F8 */ + next_byte(abfd); /* Drop 14 */ + must_parse_int(abfd); /* Drop size of block */ + if (must_parse_int(abfd) != 0) { + /* This object has been deleted */ + ar->elements[i].file_offset = 0; + } + else { + ar->elements[i].file_offset = must_parse_int(abfd); + } + } + + obstack_finish(&ar->element_obstack); + return abfd->xvec; +} + +bfd_target * +ieee_object_p (abfd) +bfd *abfd; +{ + char *processor; + unsigned int part; + ieee_data_type ieee; + ieee_seek(abfd, (file_ptr)0, false); + + + if (this_byte(abfd) != Module_Beginning) return (bfd_target*)NULL; + + next_byte(abfd); + + ieee.read_symbols= false; + ieee.read_data= false; + ieee.section_count = 0; + ieee.external_symbol_max_index = 0; + ieee.external_symbol_min_index = IEEE_PUBLIC_BASE; + ieee.external_reference_min_index =IEEE_REFERENCE_BASE; + ieee.external_reference_max_index = 0; + memset((PTR)ieee.section_table, 0, sizeof(ieee.section_table)); + + processor = ieee.mb.processor = read_id(abfd); + if (strcmp(processor,"LIBRARY") == 0) return (bfd_target *)NULL; + ieee.mb.module_name = read_id(abfd); + if (abfd->filename == (char *)NULL) { + abfd->filename = ieee.mb.module_name; + } + /* Determine the architecture and machine type of the object file. */ + bfd_scan_arch_mach(processor, &abfd->obj_arch, &abfd->obj_machine); + + if (this_byte(abfd) != ieee_address_descriptor_enum) { + return (bfd_target *)NULL; + } + next_byte(abfd); + + if (parse_int(abfd, &ieee.ad.number_of_bits_mau) == false) { + return (bfd_target *)NULL; + } + if(parse_int(abfd, &ieee.ad.number_of_maus_in_address) == false) { + return (bfd_target *)NULL; + } + + /* If there is a byte order info, take it */ + if (this_byte(abfd) == ieee_variable_L_enum || + this_byte(abfd) == ieee_variable_M_enum) + next_byte(abfd); + + + for (part = 0; part < N_W_VARIABLES; part++) { + boolean ok; + if (read_2bytes(abfd) != ieee_assign_value_to_variable_enum) { + return (bfd_target *)NULL; + } + if (this_byte_and_next(abfd) != part) { + return (bfd_target *)NULL; + } + + + ieee.w.offset[part] = parse_i(abfd, &ok); + if (ok==false) { + return (bfd_target *)NULL; + } + + } + abfd->flags = HAS_SYMS; + + /* Read in the section info */ + ieee_data(abfd) = (ieee_data_type *)(malloc(sizeof(ieee_data_type))); + memcpy(ieee_data(abfd), &ieee, sizeof(ieee)); + ieee_slurp_sections(abfd); + return abfd->xvec; +} + + +void +ieee_print_symbol(ignore_abfd, file, symbol, how) +bfd *ignore_abfd; +FILE *file; +asymbol *symbol; +bfd_print_symbol_enum_type how; +{ + + switch (how) { + case bfd_print_symbol_name_enum: + fprintf(file,"%s", symbol->name); + break; + case bfd_print_symbol_type_enum: +#if 0 + fprintf(file,"%4x %2x",aout_symbol(symbol)->desc & 0xffff, + aout_symbol(symbol)->other & 0xff); +#endif + BFD_FAIL(); + break; + case bfd_print_symbol_all_enum: + { + char *section_name = symbol->section == (asection *)NULL ? + "*abs" : symbol->section->name; + + bfd_print_symbol_vandf((void *)file,symbol); + + fprintf(file," %-5s %04x %02x %s", + section_name, + (unsigned) ieee_symbol(symbol)->index, + (unsigned) 0, /* + aout_symbol(symbol)->desc & 0xffff, + aout_symbol(symbol)->other & 0xff,*/ + symbol->name); + } + break; + } +} + + + +/* Read in all the section data and relocation stuff too */ +static boolean ieee_slurp_section_data(abfd) +bfd *abfd; +{ + bfd_byte *location_ptr ; + ieee_data_type *ieee = ieee_data(abfd); + unsigned int section_number ; + + ieee_per_section_type *current_map; + asection *s; + /* Seek to the start of the data area */ + if (ieee->read_data== true) return true; + ieee->read_data = true; + ieee_seek(abfd, ieee->w.r.data_part, false); + + /* Allocate enough space for all the section contents */ + + + for (s = abfd->sections; s != (asection *)NULL; s = s->next) { + ieee_per_section_type *per = s->used_by_bfd; + per->data = (bfd_byte *) malloc(s->size); + /*SUPPRESS 68*/ + obstack_init( &per->reloc_obstack); + per->reloc_tail_ptr = + (ieee_reloc_type **)&(s->relocation); + } + + + + while (true) { + switch (this_byte(abfd)) + { + /* IF we see anything strange then quit */ + default: + return true; + + case ieee_set_current_section_enum: + next_byte(abfd); + section_number = must_parse_int(abfd); + s = ieee->section_table[section_number]; + current_map = s->used_by_bfd; + location_ptr = current_map->data - s->vma; + /* The document I have says that Microtec's compilers reset */ + /* this after a sec section, even though the standard says not */ + /* to. SO .. */ + current_map->pc =s->vma; + break; + + case ieee_load_constant_bytes_enum: + { + unsigned int number_of_maus; + unsigned int i; + next_byte(abfd); + number_of_maus = must_parse_int(abfd); + + for (i = 0; i < number_of_maus; i++) { + location_ptr[current_map->pc++]= this_byte(abfd); + next_byte(abfd); + } + } + break; + + case ieee_e2_first_byte_enum: + next_byte(abfd); + switch (this_byte(abfd)) + { + case ieee_set_current_pc_enum & 0xff: + { + bfd_vma value; + asection *dsection; + ieee_symbol_index_type symbol; + unsigned int extra; + boolean pcrel; + next_byte(abfd); + must_parse_int(abfd); /* Thow away section #*/ + frob(abfd, &value, &dsection, &symbol, &pcrel, &extra); + current_map->pc = value; + BFD_ASSERT((unsigned)(value - s->vma) < s->size); + } + break; + + case ieee_value_starting_address_enum & 0xff: + /* We've got to the end of the data now - */ + return true; + break; + default: + BFD_FAIL(); + return true; + } + break; + case ieee_load_with_relocation_enum: + { + boolean loop = true; + next_byte(abfd); + while (loop) + { + switch (this_byte(abfd)) + { + case ieee_variable_R_enum: + + case ieee_function_signed_open_b_enum: + case ieee_function_unsigned_open_b_enum: + case ieee_function_either_open_b_enum: + { + unsigned int extra; + boolean pcrel; + + ieee_reloc_type *r = + (ieee_reloc_type *) + obstack_alloc( ¤t_map->reloc_obstack, + sizeof(ieee_reloc_type)); + + *(current_map->reloc_tail_ptr) = r; + current_map->reloc_tail_ptr= &r->next; + r->next = (ieee_reloc_type *)NULL; + next_byte(abfd); + frob(abfd, + &r->relent.addend, + &r->relent.section, + &r->symbol, + &pcrel, + &extra); + r->relent.address = current_map->pc; + s->reloc_count++; + switch (this_byte(abfd)) { + case ieee_function_signed_close_b_enum: + next_byte(abfd); + break; + case ieee_function_unsigned_close_b_enum: + next_byte(abfd); + break; + case ieee_function_either_close_b_enum: + next_byte(abfd); + break; + default: + break; + } + /* Build a relocation entry for this type */ + if (this_byte(abfd) == ieee_comma) { + + next_byte(abfd); + /* Fetch number of bytes to pad */ + extra = must_parse_int(abfd); + BFD_FAIL(); + } + switch (extra) { + case 0: + case 4: + location_ptr[current_map->pc++] = 0; + location_ptr[current_map->pc++] = 0; + location_ptr[current_map->pc++] = 0; + location_ptr[current_map->pc++] = 0; + r->relent.howto = &abs32_howto; + break; + case 2: + location_ptr[current_map->pc++] = 0; + location_ptr[current_map->pc++] = 0; + r->relent.howto = &abs16_howto; + break; + + default: + BFD_FAIL(); + break; + } + } + break; + default: + { + bfd_vma this_size ; + if (parse_int(abfd, &this_size) == true) { + unsigned int i; + for (i = 0; i < this_size; i++) { + location_ptr[current_map->pc ++] = this_byte(abfd); + next_byte(abfd); + } + } + else { + loop = false; + } + } + } + } + } + } + } +} + + + +boolean +ieee_new_section_hook (abfd, newsect) +bfd *abfd; +asection *newsect; +{ + newsect->used_by_bfd = (ieee_per_section_type *) + malloc(sizeof(ieee_per_section_type)); + ieee_per_section( newsect)->data = (bfd_byte *)NULL; + ieee_per_section(newsect)->section = newsect; + return true; +} + + +unsigned int +ieee_get_reloc_upper_bound (abfd, asect) +bfd *abfd; +sec_ptr asect; +{ + ieee_slurp_section_data(abfd); + return (asect->reloc_count+1) * sizeof(arelent *); +} + +static boolean +ieee_get_section_contents (abfd, section, location, offset, count) +bfd *abfd; +sec_ptr section; +void *location; +file_ptr offset; +unsigned int count; +{ + ieee_per_section_type *p = section->used_by_bfd; + ieee_slurp_section_data(abfd); + (void) memcpy(location, p->data + offset, count); + return true; +} + + +unsigned int +ieee_canonicalize_reloc (abfd, section, relptr, symbols) +bfd *abfd; +sec_ptr section; +arelent **relptr; +asymbol **symbols; +{ + ieee_per_section_type *p = section->used_by_bfd; + ieee_reloc_type *src = (ieee_reloc_type *)(section->relocation); + ieee_data_type *ieee = ieee_data(abfd); + + while (src != (ieee_reloc_type *)NULL) { + /* Work out which symbol to attatch it this reloc to */ + switch (src->symbol.letter) { + case 'X': + src->relent.sym_ptr_ptr = + symbols + src->symbol.index + ieee->external_reference_base_offset; + break; + case 0: + src->relent.sym_ptr_ptr = (asymbol **)NULL; + break; + default: + + BFD_FAIL(); + } + *relptr++ = &src->relent; + src = src->next; + } + *relptr = (arelent *)NULL; + return section->reloc_count; +} + +boolean +ieee_set_arch_mach (abfd, arch, machine) +bfd *abfd; +enum bfd_architecture arch; +unsigned long machine; +{ + abfd->obj_arch = arch; + abfd->obj_machine = machine; + return true; +} + +boolean +ieee_mkobject(abfd) +bfd *abfd; +{ + ieee_data_type *ieee = (ieee_data_type *) malloc(sizeof(ieee_data_type)); + ieee_data(abfd) = ieee; + if (ieee == (ieee_data_type *)NULL) { + bfd_error = no_memory; + return false; + } + + return true; +} + + +static int comp(ap, bp) +arelent **ap; +arelent **bp; +{ + arelent *a = *ap; + arelent *b = *bp; + return a->address - b->address; +} +/* +Write the section headers +*/ + +static void +ieee_write_section_part(abfd) +bfd *abfd; +{ + ieee_data_type *ieee = ieee_data(abfd); + asection *s; + ieee->w.r.section_part = bfd_tell(abfd); + for (s = abfd->sections; s != (asection *)NULL; s=s->next) { + ieee_write_byte(abfd, ieee_section_type_enum); + ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); + + switch (s->flags & (SEC_LOAD | SEC_CODE | SEC_DATA | SEC_ROM)) { + case SEC_LOAD | SEC_CODE: + /* Normal named section, code */ + ieee_write_byte(abfd, ieee_variable_C_enum); + ieee_write_byte(abfd, ieee_variable_P_enum); + break; + case SEC_LOAD | SEC_DATA: + /* Normal named section, data */ + ieee_write_byte(abfd, ieee_variable_C_enum); + ieee_write_byte(abfd, ieee_variable_D_enum); + break; + case SEC_LOAD | SEC_DATA | SEC_ROM: + /* Normal named section, data rom */ + ieee_write_byte(abfd, ieee_variable_C_enum); + ieee_write_byte(abfd, ieee_variable_R_enum); + break; + default: + ieee_write_byte(abfd, ieee_variable_C_enum); + break; + } + + ieee_write_id(abfd, s->name); + ieee_write_int(abfd, 0); /* Parent */ + ieee_write_int(abfd, 0); /* Brother */ + ieee_write_int(abfd, 0); /* Context */ + + /* Alignment */ + ieee_write_byte(abfd, ieee_section_alignment_enum); + ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); + ieee_write_int(abfd, 1 << s->alignment_power); + + /* Size */ + ieee_write_2bytes(abfd, ieee_section_size_enum); + ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); + ieee_write_int(abfd, s->size); + + /* Vma */ + ieee_write_2bytes(abfd, ieee_region_base_address_enum); + ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); + ieee_write_int(abfd, s->vma); + + } +} + + + +/* write the data in an ieee way */ +static void +ieee_write_data_part(abfd) +bfd *abfd; +{ + asection *s; + ieee_data_type *ieee = ieee_data(abfd); + ieee->w.r.data_part = bfd_tell(abfd); + for (s = abfd->sections; s != (asection *)NULL; s = s->next) + { + bfd_byte header[11]; + bfd_byte *stream = ieee_per_section(s)->data; + arelent **p = s->orelocation; + size_t current_byte_index = 0; + /* Sort the reloc records so we can insert them in the correct places */ + if (s->reloc_count != 0) { + qsort(s->orelocation, + s->reloc_count, + sizeof(arelent **), + comp); + } + + + /* Output the section preheader */ + header[0] =ieee_set_current_section_enum; + header[1] = s->index + IEEE_SECTION_NUMBER_BASE; + + header[2] = ieee_set_current_pc_enum >> 8; + header[3]= ieee_set_current_pc_enum & 0xff; + header[4] = s->index + IEEE_SECTION_NUMBER_BASE; + ieee_write_int5(header+5, s->vma ); + header[10] = ieee_load_with_relocation_enum; + bfd_write(header, 1, sizeof(header), abfd); + + /* Output the data stream as the longest sequence of bytes possible, */ + /* allowing for the a reasonable packet size and relocation stuffs */ + if (stream == (void *)NULL) { + stream = (bfd_byte *)"UNINITIALIZED AREA! "; + s->size = strlen(stream); + } + while (current_byte_index < s->size) { + size_t run; + unsigned int MAXRUN = 32; + if (p && *p) { + run = (*p)->address - current_byte_index; + } + else { + run = MAXRUN; + } + if (run > s->size - current_byte_index) { + run = s->size - current_byte_index; + } + + if (run != 0) { + /* Output a stream of bytes */ + bfd_byte header[1] ; + header[0]= run; + bfd_write(header, 1, sizeof(header), abfd); + bfd_write(stream + current_byte_index, + 1, + run, + abfd); + current_byte_index += run; + } + /* Output any relocations here */ + if (p && (*p) && (*p)->address == current_byte_index) { + while ((*p) && (*p)->address == current_byte_index) { + + arelent *r = *p; + ieee_write_byte(abfd, ieee_function_either_open_b_enum); + if (r->sym_ptr_ptr != (asymbol **)NULL) { + ieee_write_expression(abfd, r->addend, + r->section, + *(r->sym_ptr_ptr)); + } + else { + ieee_write_expression(abfd, r->addend, + r->section, + (asymbol *)NULL); + } + ieee_write_byte(abfd, ieee_function_either_close_b_enum); + p++; + } + /* FIXME !! Are all relocations 4 bytes ? */ + current_byte_index += 4; + } + } + } +} + + + + + + +static void +init_for_output(abfd) +bfd *abfd; +{ + asection *s; + for (s = abfd->sections; s != (asection *)NULL; s = s->next) { + if (s->size != 0) { + ieee_per_section(s)->data = (bfd_byte *)(malloc(s->size)); + } + } +} + +/** exec and core file sections */ + +/* set section contents is complicated with IEEE since the format is +* not a byte image, but a record stream. +*/ +boolean +ieee_set_section_contents (abfd, section, location, offset, count) +bfd *abfd; +sec_ptr section; +unsigned char *location; +file_ptr offset; +int count; +{ + if (ieee_per_section(section)->data == (bfd_byte *)NULL) { + init_for_output(abfd); + } + (void) memcpy(ieee_per_section(section)->data + offset, location, count); + return true; +} + +/* +write the external symbols of a file, IEEE considers two sorts of +external symbols, public, and referenced. It uses to internal forms +to index them as well. When we write them out we turn their symbol +values into indexes from the right base. +*/ +static void +ieee_write_external_part(abfd) +bfd *abfd; +{ + asymbol **q; + ieee_data_type *ieee = ieee_data(abfd); + + unsigned int reference_index = IEEE_REFERENCE_BASE; + unsigned int public_index = IEEE_PUBLIC_BASE; + ieee->w.r.external_part = bfd_tell(abfd); + if (abfd->outsymbols != (asymbol **)NULL) { + for (q = abfd->outsymbols; *q != (asymbol *)NULL; q++) { + asymbol *p = *q; + if (p->flags & BSF_UNDEFINED) { + /* This must be a symbol reference .. */ + ieee_write_byte(abfd, ieee_external_reference_enum); + ieee_write_int(abfd, reference_index); + ieee_write_id(abfd, p->name); + p->value = reference_index; + reference_index++; + } + else if(p->flags & BSF_FORT_COMM) { + /* This is a weak reference */ + ieee_write_byte(abfd, ieee_external_reference_enum); + ieee_write_int(abfd, reference_index); + ieee_write_id(abfd, p->name); + ieee_write_byte(abfd, ieee_weak_external_reference_enum); + ieee_write_int(abfd, reference_index); + ieee_write_int(abfd, p->value); + ieee_write_int(abfd, BFD_FORT_COMM_DEFAULT_VALUE); + p->value = reference_index; + reference_index++; + } + else if(p->flags & BSF_GLOBAL) { + /* This must be a symbol definition */ + + ieee_write_byte(abfd, ieee_external_symbol_enum); + ieee_write_int(abfd, public_index ); + ieee_write_id(abfd, p->name); + + /* Write out the value */ + ieee_write_2bytes(abfd, ieee_value_record_enum); + ieee_write_int(abfd, public_index); + if (p->section != (asection *)NULL) + { + ieee_write_expression(abfd, + p->value + p->section->output_offset, + p->section->output_section, + (asymbol *)NULL); + } + else + { + ieee_write_expression(abfd, + p->value, + (asection *)NULL, + (asymbol *)NULL); + } + p->value = public_index; + public_index++; + } + else { + /* This can happen - when there are gaps in the symbols read */ + /* from an input ieee file */ + } + } + } + +} + +static +void ieee_write_me_part(abfd) +bfd *abfd; +{ + ieee_data_type *ieee= ieee_data(abfd); + ieee->w.r.me_record = bfd_tell(abfd); + + ieee_write_2bytes(abfd, ieee_value_starting_address_enum); + ieee_write_int(abfd, abfd->start_address); + ieee_write_byte(abfd, ieee_module_end_enum); + +} +boolean +ieee_write_object_contents (abfd) +bfd *abfd; +{ + ieee_data_type *ieee = ieee_data(abfd); + unsigned int i; + + /* Make a guess about the size of the header */ + bfd_seek(abfd, 100, false); + /* + First write the symbols, this changes their values into table + indeces so we cant use it after this point + */ + ieee_write_external_part(abfd); + ieee_write_byte(abfd, ieee_record_seperator_enum); + + ieee_write_section_part(abfd); + ieee_write_byte(abfd, ieee_record_seperator_enum); + /* + Can only write the data once the symbols have been written since + the data contains relocation information which points to the + symbols + */ + ieee_write_data_part(abfd); + ieee_write_byte(abfd, ieee_record_seperator_enum); + + /* + At the end we put the end ! + */ + ieee_write_me_part(abfd); + /* Now write the header */ + /* Generate the header */ + bfd_seek(abfd, (file_ptr)0, false); + + + ieee_write_byte(abfd, ieee_module_beginning_enum); + + ieee_write_id(abfd, bfd_printable_arch_mach(abfd->obj_arch, + abfd->obj_machine)); + ieee_write_id(abfd, abfd->filename); + ieee_write_byte(abfd, ieee_address_descriptor_enum); + ieee_write_byte(abfd, 8); /* Bits per MAU */ + ieee_write_byte(abfd, 4); /* MAU's per address */ + + + for (i= 0; i < N_W_VARIABLES; i++) { + ieee_write_2bytes(abfd,ieee_assign_value_to_variable_enum); + ieee_write_byte(abfd, i); + ieee_write_int(abfd, ieee->w.offset[i]); + } + return true; +} + + + + +/* Native-level interface to symbols. */ + +/* We read the symbols into a buffer, which is discarded when this +function exits. We read the strings into a buffer large enough to +hold them all plus all the cached symbol entries. */ + +asymbol * +ieee_make_empty_symbol (abfd) +bfd *abfd; +{ + + ieee_symbol_type *new = + (ieee_symbol_type *)zalloc (sizeof (ieee_symbol_type)); + new->symbol.the_bfd = abfd; + return &new->symbol; + +} + +void +ieee_reclaim_symbol_table (abfd) +bfd *abfd; +{ +#if 0 + asection *section; + + if (!bfd_get_symcount (abfd)) return; + + for (section = abfd->sections; section != NULL; section = section->next) + if (section->relocation) { + free ((void *)section->relocation); + section->relocation = NULL; + section->reloc_count = 0; + } + + bfd_get_symcount (abfd) = 0; + free ((void *)obj_aout_symbols (abfd)); + obj_aout_symbols (abfd) = (aout_symbol_type *)NULL; +#endif +} + + + + +/* Obsolete procedural interface; better to look at the cache directly */ + +/* User should have checked the file flags; perhaps we should return +BFD_NO_MORE_SYMBOLS if there are none? */ + +int +ieee_get_symcount_upper_bound (abfd) +bfd *abfd; +{ +#if 0 + /* In case we're doing an output file or something...? */ + if (bfd_get_symcount (abfd)) return bfd_get_symcount (abfd); + + return (exec_hdr (abfd)->a_syms) / (sizeof (struct nlist)); +#endif +return 0; +} + +symindex +ieee_get_first_symbol (ignore_abfd) +bfd * ignore_abfd; +{ + return 0; +} + +symindex +ieee_get_next_symbol (abfd, oidx) +bfd *abfd; +symindex oidx; +{ +#if 0 + if (oidx == BFD_NO_MORE_SYMBOLS) return BFD_NO_MORE_SYMBOLS; + return ++oidx >= bfd_get_symcount (abfd) ? BFD_NO_MORE_SYMBOLS : + oidx; +#endif +return 0; +} + +char * +ieee_symbol_name (abfd, idx) +bfd *abfd; +symindex idx; +{ +#if 0 + return (obj_aout_symbols (abfd) + idx)->symbol.name; +#endif +return 0; +} + +long +ieee_symbol_value (abfd, idx) +bfd *abfd; +symindex idx; +{ +#if 0 + return (obj_aout_symbols (abfd) + idx)->symbol.value; +#endif +return 0; +} + +symclass +ieee_classify_symbol (abfd, idx) +bfd *abfd; +symindex idx; +{ +#if 0 + aout_symbol_type *sym = obj_aout_symbols (abfd) + idx; + + if ((sym->symbol.flags & BSF_FORT_COMM) != 0) return bfd_symclass_fcommon; + if ((sym->symbol.flags & BSF_GLOBAL) != 0) return bfd_symclass_global; + if ((sym->symbol.flags & BSF_DEBUGGING) != 0) return bfd_symclass_debugger; + if ((sym->symbol.flags & BSF_UNDEFINED) != 0) return bfd_symclass_undefined; +#endif + return bfd_symclass_unknown; +} + +boolean +ieee_symbol_hasclass (abfd, idx, class) +bfd *abfd; +symindex idx; +symclass class; +{ +#if 0 + aout_symbol_type *sym = obj_aout_symbols (abfd) + idx; + switch (class) { + case bfd_symclass_fcommon: + return (sym->symbol.flags & BSF_FORT_COMM) ? true :false; + case bfd_symclass_global: + return (sym->symbol.flags & BSF_GLOBAL) ? true:false; + case bfd_symclass_debugger: + return (sym->symbol.flags & BSF_DEBUGGING) ? true:false;; + case bfd_symclass_undefined: + return (sym->symbol.flags & BSF_UNDEFINED) ? true:false;; + default: return false; + } +#endif +return 0; +} + + +void +ieee_reclaim_reloc (ignore_abfd, section) +bfd *ignore_abfd; +sec_ptr section; +{ +#if 0 + if (section->relocation) { + free (section->relocation); + section->relocation = NULL; + section->reloc_count = 0; + } +#endif +} + +boolean +ieee_close_and_cleanup (abfd) +bfd *abfd; +{ + if (bfd_read_p (abfd) == false) + switch (abfd->format) { + case bfd_archive: + if (!_bfd_write_archive_contents (abfd)) { + return false; + } + break; + case bfd_object: + if (!ieee_write_object_contents (abfd)) { + return false; + } + break; + default: + bfd_error = invalid_operation; + return false; + } + + + if (ieee_data(abfd) != (ieee_data_type *)NULL) { + /* FIXME MORE LEAKS */ + + } + + return true; +} + +static bfd * +ieee_openr_next_archived_file(arch, prev) +bfd *arch; +bfd *prev; +{ + ieee_ar_data_type *ar = ieee_ar_data(arch); + /* take the next one from the arch state, or reset */ + if (prev == (bfd *)NULL) { + /* Reset the index - the first two entries are bogus*/ + ar->element_index = 2; + } + while (true) { + ieee_ar_obstack_type *p = ar->elements + ar->element_index; + ar->element_index++; + if (ar->element_index <= ar->element_count) { + if (p->file_offset != (file_ptr)0) { + if (p->abfd == (bfd *)NULL) { + p->abfd = _bfd_create_empty_archive_element_shell(arch); + p->abfd->origin = p->file_offset; + } + return p->abfd; + } + } + else { + return (bfd *)NULL; + } + + } +} + +static boolean +ieee_find_nearest_line(abfd, + section, + symbols, + offset, + filename_ptr, + functionname_ptr, + line_ptr) +bfd *abfd; +asection *section; +asymbol **symbols; +bfd_vma offset; +char **filename_ptr; +char **functionname_ptr; +unsigned int *line_ptr; +{ + return false; + +} +/*SUPPRESS 460 */ +bfd_target ieee_vec = +{ + "ieee", /* name */ + bfd_target_ieee_flavour_enum, + true, /* target byte order */ + true, /* target headers byte order */ + (HAS_RELOC | EXEC_P | /* object flags */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), + (SEC_CODE|SEC_DATA|SEC_ROM + |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + 0, /* valid reloc types */ + ' ', /* ar_pad_char */ + 16, /* ar_max_namelen */ + ieee_close_and_cleanup, /* _close_and_cleanup */ + ieee_set_section_contents, /* bfd_set_section_contents */ + ieee_get_section_contents, + ieee_new_section_hook, /* new_section_hook */ + 0, /* _core_file_failing_command */ + 0, /* _core_file_failing_signal */ + 0, /* _core_file_matches_ex...p */ + + 0, /* bfd_slurp_bsd_armap, bfd_slurp_armap */ + bfd_true, /* bfd_slurp_extended_name_table */ + bfd_bsd_truncate_arname, /* bfd_truncate_arname */ + + ieee_get_symtab_upper_bound, /* get_symtab_upper_bound */ + ieee_get_symtab, /* canonicalize_symtab */ + 0, /* ieee_reclaim_symbol_table, bfd_reclaim_symbol_table */ + ieee_get_reloc_upper_bound, /* get_reloc_upper_bound */ + ieee_canonicalize_reloc, /* bfd_canonicalize_reloc */ + 0, /* ieee_reclaim_reloc, bfd_reclaim_reloc */ + 0, /* ieee_get_symcount_upper_bound, bfd_get_symcount_upper_bound */ + 0, /* ieee_get_first_symbol, bfd_get_first_symbol */ + 0, /* ieee_get_next_symbol, bfd_get_next_symbol */ + 0, /* ieee_classify_symbol, bfd_classify_symbol */ + 0, /* ieee_symbol_hasclass, bfd_symbol_hasclass */ + 0, /* ieee_symbol_name, bfd_symbol_name */ + 0, /* ieee_symbol_value, bfd_symbol_value */ + + _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */ + _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ + + {_bfd_dummy_target, + ieee_object_p, /* bfd_check_format */ + ieee_archive_p, + bfd_false + }, + { + bfd_false, + ieee_mkobject, + _bfd_generic_mkarchive, + bfd_false + }, + ieee_make_empty_symbol, + ieee_print_symbol, + bfd_false, /* ieee_get_lineno,*/ + ieee_set_arch_mach, /* bfd_set_arch_mach,*/ + bfd_false, + ieee_openr_next_archived_file, + ieee_find_nearest_line, /* bfd_find_nearest_line */ +}; diff --git a/bfd/libieee.h b/bfd/libieee.h new file mode 100644 index 0000000000..aefc5fdbb7 --- /dev/null +++ b/bfd/libieee.h @@ -0,0 +1,90 @@ +typedef struct { + unsigned int index:24; + char letter; +} ieee_symbol_index_type; + +typedef struct ieee_symbol_struct { + asymbol symbol; + struct ieee_symbol_struct *next; + +unsigned int index; +} ieee_symbol_type; + + +typedef struct ieee_reloc_struct { + arelent relent; + struct ieee_reloc_struct *next; + ieee_symbol_index_type symbol; + +} ieee_reloc_type; + +#define ieee_symbol(x) ((ieee_symbol_type *)(x)) + +typedef struct ieee_per_section_struct +{ + asection *section; + bfd_byte *data; + bfd_vma offset; + struct obstack reloc_obstack; + ieee_reloc_type **reloc_tail_ptr; +bfd_vma pc; + /* For output */ + file_ptr current_pos; + unsigned int current_byte; + boolean initialized; +} ieee_per_section_type; + +#define ieee_per_section(x) ((ieee_per_section_type *)((x)->used_by_bfd)) +#define NSECTIONS 10 + + + +typedef struct { + boolean read_symbols; +boolean read_data; + file_ptr output_cursor; + /* Map of section indexes to section ptrs */ + asection * section_table[NSECTIONS]; + ieee_address_descriptor_type ad; + ieee_module_begin_type mb; + ieee_w_variable_type w; + + unsigned int section_count; + + unsigned int map_idx; + /* List of GLOBAL EXPORT symbols */ + ieee_symbol_type *external_symbols; + /* List of UNDEFINED symbols */ + ieee_symbol_type *external_reference; + +/* When the symbols have been canonicalized, they are in a + * special order, we remember various bases here.. */ + unsigned int external_symbol_max_index; + unsigned int external_symbol_min_index; + unsigned int external_symbol_count; + int external_symbol_base_offset; + + unsigned int external_reference_max_index; + unsigned int external_reference_min_index; + unsigned int external_reference_count; + int external_reference_base_offset; + + +boolean symbol_table_full; +} ieee_data_type; + +typedef struct { + file_ptr file_offset; + bfd *abfd; +} ieee_ar_obstack_type; + +typedef struct { + ieee_ar_obstack_type *elements; + struct obstack element_obstack; + unsigned int element_index ; + unsigned int element_count; +} ieee_ar_data_type; +#define ieee_data(abfd) ((ieee_data_type *)((abfd)->tdata)) +#define ieee_ar_data(abfd) ((ieee_ar_data_type *)((abfd)->tdata)) + + diff --git a/bfd/liboasys.h b/bfd/liboasys.h new file mode 100644 index 0000000000..59e4a89401 --- /dev/null +++ b/bfd/liboasys.h @@ -0,0 +1,70 @@ + + +typedef struct { + asymbol symbol; +} oasys_symbol_type; + +typedef struct oasys_reloc_struct { + arelent relent; + struct oasys_reloc_struct *next; + unsigned int symbol; +} oasys_reloc_type; + + +#define oasys_symbol(x) ((oasys_symbol_type *)(x)) +#define oasys_per_section(x) ((oasys_per_section_type *)(x->used_by_bfd)) +typedef struct oasys_per_section_struct +{ + asection *section; + bfd_byte *data; + bfd_vma offset; + + oasys_reloc_type **reloc_tail_ptr; + bfd_vma pc; + /* For output */ + struct obstack reloc_obstack; + file_ptr current_pos; + unsigned int current_byte; + boolean initialized; +} oasys_per_section_type; + +#define NSECTIONS 10 + + + + + +typedef struct { + file_ptr file_offset; + bfd *abfd; +} oasys_ar_obstack_type; + + +typedef struct { + file_ptr pos; + unsigned int size; + bfd *abfd; +char *name; + +} oasys_module_info_type; + +typedef struct { + oasys_module_info_type *module; + unsigned int module_count; + unsigned int module_index; +} oasys_ar_data_type; + +typedef struct { + + char *strings; + asymbol *symbols; + unsigned int symbol_string_length; + asection *sections[OASYS_MAX_SEC_COUNT]; + file_ptr first_data_record; +} oasys_data_type; + +#define oasys_data(abfd) ((oasys_data_type *)((abfd)->tdata)) +#define oasys_ar_data(abfd) ((oasys_ar_data_type *)((abfd)->tdata)) + + + diff --git a/bfd/oasys.c b/bfd/oasys.c new file mode 100644 index 0000000000..c68ce0704e --- /dev/null +++ b/bfd/oasys.c @@ -0,0 +1,985 @@ +/* + + bfd backend for oasys objects. + + + Object files contain records in order: + + optional header + symbol records + section records + data records + debugging records + end record + + + + Written by Steve Chamberlain + steve@cygnus.com + + + + */ + + +#include +#include "sysdep.h" +#include "bfd.h" +#include "libbfd.h" +#include "obstack.h" +#include "oasys.h" +#include "liboasys.h" + + + +#define obstack_chunk_alloc malloc +#define obstack_chunk_free free + +typedef void generic_symbol_type; + + +void DEFUN(oasys_read_record,(abfd, record), + bfd *abfd AND + oasys_record_union_type *record) +{ + + bfd_read(record, 1, sizeof(record->header), abfd); + + bfd_read(((char *)record )+ sizeof(record->header), + 1, record->header.length - sizeof(record->header), + abfd); +} +static size_t +oasys_string_length(record) +oasys_record_union_type *record; +{ +return record->header.length + - ((char *)record->symbol.name - (char *)record); +} + +/*****************************************************************************/ + +/* + +Slurp the symbol table by reading in all the records at the start file +till we get to the first section record. + +We'll sort the symbols into two lists, defined and undefined. The +undefined symbols will also be sorted by refno. We do this by placing +all undefined symbols at the front of the table moving in, and the +defined symbols at the end of the table moving back. + +*/ + +static boolean +oasys_slurp_symbol_table(abfd) +bfd *abfd; +{ + oasys_record_union_type record; + oasys_data_type *data = oasys_data(abfd); + boolean loop = true; + asymbol *dest_undefined; + asymbol *dest_defined; + asymbol *dest; + char *string_ptr; + + + if (data->symbols != (asymbol *)NULL) { + return true; + } + /* Buy enough memory for all the symbols and all the names */ + data->symbols = + (asymbol *)malloc(sizeof(asymbol) * abfd->symcount); + data->strings = malloc(data->symbol_string_length); + + dest_undefined = data->symbols; + dest_defined = data->symbols + abfd->symcount -1; + + string_ptr = data->strings; + bfd_seek(abfd, (file_ptr)0, SEEK_SET); + while (loop) { + oasys_read_record(abfd, &record); + switch (record.header.type) { + case oasys_record_is_header_enum: + break; + case oasys_record_is_local_enum: + case oasys_record_is_symbol_enum: + { + size_t length = oasys_string_length(&record); + switch (record.symbol.relb[0] & RELOCATION_TYPE_BITS) { + case RELOCATION_TYPE_ABS: + dest = dest_defined--; + dest->section = 0; + dest->flags = BSF_ABSOLUTE | BSF_EXPORT | BSF_GLOBAL; + dest_defined--; + break; + case RELOCATION_TYPE_REL: + dest = dest_defined--; + dest->section = + oasys_data(abfd)->sections[record.symbol.relb[0] & + RELOCATION_SECT_BITS]; + if (record.header.type == oasys_record_is_local_enum) + { + dest->flags = BSF_LOCAL; + } + else { + + dest->flags = BSF_EXPORT | BSF_GLOBAL; + } + break; + case RELOCATION_TYPE_UND: + dest = dest_undefined++; + dest->section = (asection *)NULL; + dest->flags = BSF_UNDEFINED; + break; + case RELOCATION_TYPE_COM: + dest = dest_defined--; + dest->name = string_ptr; + dest->the_bfd = abfd; + + dest->section = (asection *)NULL; + dest->flags = BSF_FORT_COMM; + break; + } + dest->name = string_ptr; + dest->the_bfd = abfd; + + dest->value = bfd_h_getlong(abfd, &record.symbol.value); + memcpy(string_ptr, record.symbol.name, length); + string_ptr[length] =0; + string_ptr += length +1; + } + break; + default: + loop = false; + } + } + return true; + +} + +size_t +oasys_get_symtab_upper_bound (abfd) +bfd *abfd; +{ + oasys_slurp_symbol_table (abfd); + + return (abfd->symcount != 0) ? + (abfd->symcount+1) * (sizeof (oasys_symbol_type *)) : 0; +} + +/* +*/ + +extern bfd_target oasys_vec; + +unsigned int +oasys_get_symtab (abfd, location) +bfd *abfd; +asymbol **location; +{ + asymbol *symbase ; + unsigned int counter ; + if (oasys_slurp_symbol_table(abfd) == false) { + return 0; + } + symbase = oasys_data(abfd)->symbols; + for (counter = 0; counter < abfd->symcount; counter++) { + *(location++) = symbase++; + } + *location = 0; + return abfd->symcount; +} + +/*********************************************************************** +* archive stuff +*/ +#define swap(x) x = bfd_h_get_x(abfd, &x); +bfd_target * +oasys_archive_p(abfd) +bfd *abfd; +{ + oasys_archive_header_type header; + unsigned int i; + + bfd_seek(abfd, (file_ptr) 0, false); + + + bfd_read(&header, 1, sizeof(header), abfd); + + + swap(header.version); + swap(header.mod_count); + swap(header.mod_tbl_offset); + swap(header.sym_tbl_size); + swap(header.sym_count); + swap(header.sym_tbl_offset); + swap(header.xref_count); + swap(header.xref_lst_offset); + + /* + There isn't a magic number in an Oasys archive, so the best we + can do to verify reasnableness is to make sure that the values in + the header are too weird + */ + + if (header.version>10000 || + header.mod_count>10000 || + header.sym_count>100000 || + header.xref_count > 100000) return (bfd_target *)NULL; + + /* + That all worked, lets buy the space for the header and read in + the headers. + */ + { + oasys_ar_data_type *ar = + (oasys_ar_data_type*) malloc(sizeof(oasys_ar_data_type)); + + + oasys_module_info_type *module = + (oasys_module_info_type*) + malloc(sizeof(oasys_module_info_type) * header.mod_count); + + oasys_module_table_type record; + + oasys_ar_data(abfd) =ar; + ar->module = module; + ar->module_count = header.mod_count; + + bfd_seek(abfd , header.mod_tbl_offset, SEEK_SET); + for (i = 0; i < header.mod_count; i++) { + + bfd_read(&record, 1, sizeof(record), abfd); + swap(record.mod_size); + swap(record.file_offset); + swap(record.mod_name_length); + module[i].name = malloc(record.mod_name_length+1); + + bfd_read(module[i].name, 1, record.mod_name_length +1, abfd); + /* SKip some stuff */ + bfd_seek(abfd, record.dep_count * sizeof(int32_type), + SEEK_CUR); + + module[i].size = record.mod_size; + module[i].pos = record.file_offset; + } + + } + return abfd->xvec; +} + +#define MAX_SECS 16 +bfd_target * +oasys_object_p (abfd) +bfd *abfd; +{ + oasys_data_type *oasys; + oasys_data_type static_data; + + boolean loop = true; + + + boolean had_usefull = false; + + memset((PTR)static_data.sections, 0xff, sizeof(static_data.sections)); + + /* Point to the start of the file */ + bfd_seek(abfd, (file_ptr)0, SEEK_SET); + static_data.symbol_string_length = 0; + /* Inspect the records, but only keep the section info - + remember the size of the symbols + */ + while (loop) { + oasys_record_union_type record; + oasys_read_record(abfd, &record); + + + switch ((oasys_record_enum_type)(record.header.type)) { + case oasys_record_is_header_enum: + had_usefull = true; + break; + case oasys_record_is_symbol_enum: + case oasys_record_is_local_enum: + /* Count symbols and remember their size for a future malloc */ + abfd->symcount++; + static_data.symbol_string_length += 1 + oasys_string_length(&record); + had_usefull = true; + break; + case oasys_record_is_section_enum: + { + asection *s; + char *buffer; + unsigned int section_number; + if (record.section.header.length != sizeof(record.section)) + { + return (bfd_target *)NULL; + } + buffer = malloc(3); + section_number= record.section.relb & RELOCATION_SECT_BITS; + sprintf(buffer,"%u", section_number); + s = bfd_make_section(abfd,buffer); + static_data.sections[section_number] = s; + switch (record.section.relb & RELOCATION_TYPE_BITS) { + case RELOCATION_TYPE_ABS: + case RELOCATION_TYPE_REL: + break; + case RELOCATION_TYPE_UND: + case RELOCATION_TYPE_COM: + BFD_FAIL(); + } + + + s->size = bfd_h_getlong(abfd, & record.section.value) ; + s->vma = bfd_h_getlong(abfd, &record.section.vma); + s->flags |= SEC_LOAD | SEC_HAS_CONTENTS; + had_usefull = true; + } + break; + case oasys_record_is_data_enum: + static_data.first_data_record = bfd_tell(abfd) - record.header.length; + case oasys_record_is_debug_enum: + case oasys_record_is_module_enum: + case oasys_record_is_named_section_enum: + case oasys_record_is_end_enum: + if (had_usefull == false) return (bfd_target *)NULL; + loop = false; + break; + default: + return (bfd_target *)NULL; + } + } + oasys_data(abfd) = (oasys_data_type + *)malloc(sizeof(oasys_data_type)); + oasys = oasys_data(abfd); + * oasys = static_data; + + oasys->symbols = (asymbol *)NULL; + /* + Oasys support several architectures, but I can't see a simple way + to discover which one is in a particular file - we'll guess + */ + abfd->obj_arch = bfd_arch_m68k; + abfd->obj_machine =0; + if (abfd->symcount != 0) { + abfd->flags |= HAS_SYMS; + } + return abfd->xvec; +} + + +void +oasys_print_symbol(ignore_abfd, file, symbol, how) +bfd *ignore_abfd; +FILE *file; +asymbol *symbol; +bfd_print_symbol_enum_type how; +{ + switch (how) { + case bfd_print_symbol_name_enum: + case bfd_print_symbol_type_enum: + fprintf(file,"%s", symbol->name); + break; + case bfd_print_symbol_all_enum: + { + char *section_name = symbol->section == (asection *)NULL ? + "*abs" : symbol->section->name; + + bfd_print_symbol_vandf((void *)file,symbol); + + fprintf(file," %-5s %s", + section_name, + symbol->name); + } + break; + } +} +/* + The howto table is build using the top two bits of a reloc byte to + index into it. The bits are PCREL,WORD/LONG +*/ +static reloc_howto_type howto_table[]= +{ +/* T rs size bsz pcrel bitpos abs ovr sf name partial inplace mask */ + +{ 0, 0, 1, 16, false,0, true,true,0,"abs16",true,0x0000ffff}, +{ 0, 0, 2, 32, false,0, true,true,0,"abs32",true,0xffffffff}, +{ 0, 0, 1, 16, true,0, true,true,0,"pcrel16",true,0x0000ffff}, +{ 0, 0, 2, 32, true,0, true,true,0,"pcrel32",true,0xffffffff} +}; + +/* Read in all the section data and relocation stuff too */ +static boolean oasys_slurp_section_data(abfd) +bfd *abfd; +{ + oasys_record_union_type record; + oasys_data_type *data = oasys_data(abfd); + boolean loop = true; + + oasys_per_section_type *per ; + + asection *s; + + /* Buy enough memory for all the section data and relocations */ + for (s = abfd->sections; s != (asection *)NULL; s= s->next) { + per = oasys_per_section(s); + if (per->data != (bfd_byte*)NULL) return true; + per->data = (bfd_byte *) malloc(s->size); + obstack_init(&per->reloc_obstack); + per->reloc_tail_ptr = (oasys_reloc_type **)&(s->relocation); + } + + bfd_seek(abfd, data->first_data_record, SEEK_SET); + while (loop) { + oasys_read_record(abfd, &record); + switch (record.header.type) { + case oasys_record_is_header_enum: + break; + case oasys_record_is_data_enum: + { + + uint8e_type *src = record.data.data; + uint8e_type *end_src = ((uint8e_type *)&record) + record.header.length; + unsigned int relbit; + bfd_byte *dst_ptr ; + bfd_byte *dst_base_ptr ; + asection *section; + unsigned int count; + + bfd_vma dst_offset = bfd_h_getlong(abfd, record.data.addr); + section = data->sections[record.data.relb & RELOCATION_SECT_BITS]; + per = oasys_per_section(section); +dst_base_ptr = dst_ptr = oasys_per_section(section)->data + dst_offset; + + while (src < end_src) { + uint8e_type mod_byte = *src++; + count = 8; + + for (relbit = 1; count-- != 0; relbit <<=1) + { + if (relbit & mod_byte) + { + uint8e_type reloc = *src; + /* This item needs to be relocated */ + switch (reloc & RELOCATION_TYPE_BITS) { + case RELOCATION_TYPE_ABS: + + break; + + case RELOCATION_TYPE_REL: + { + /* Relocate the item relative to the section */ + oasys_reloc_type *r = + (oasys_reloc_type *) + obstack_alloc(&per->reloc_obstack, + sizeof(oasys_reloc_type)); + *(per->reloc_tail_ptr) = r; + per->reloc_tail_ptr = &r->next; + r->next= (oasys_reloc_type *)NULL; + /* Reference to undefined symbol */ + src++; + /* There is no symbol */ + r->symbol = 0; + /* Work out the howto */ + r->relent.section = + data->sections[reloc & RELOCATION_SECT_BITS]; + r->relent.addend = 0; + r->relent.address = dst_ptr - dst_base_ptr; + r->relent.howto = &howto_table[reloc>>6]; + section->reloc_count++; + + } + break; + + + case RELOCATION_TYPE_UND: + { + oasys_reloc_type *r = + (oasys_reloc_type *) + obstack_alloc(&per->reloc_obstack, + sizeof(oasys_reloc_type)); + *(per->reloc_tail_ptr) = r; + per->reloc_tail_ptr = &r->next; + r->next= (oasys_reloc_type *)NULL; + /* Reference to undefined symbol */ + src++; + /* Get symbol number */ + r->symbol = (src[0]<<8) | src[1]; + /* Work out the howto */ + r->relent.section = (asection *)NULL; + r->relent.addend = 0; + r->relent.address = dst_ptr - dst_base_ptr; + r->relent.howto = &howto_table[reloc>>6]; + + section->reloc_count++; + src+=2; + } + break; + case RELOCATION_TYPE_COM: + BFD_FAIL(); + } + } + *dst_ptr++ = *src++; + } + } + } + break; + case oasys_record_is_local_enum: + case oasys_record_is_symbol_enum: + case oasys_record_is_section_enum: + break; + default: + loop = false; + } + } + return true; + +} + + + + + +boolean +oasys_new_section_hook (abfd, newsect) +bfd *abfd; +asection *newsect; +{ + newsect->used_by_bfd = (oasys_per_section_type *) + malloc(sizeof(oasys_per_section_type)); + oasys_per_section( newsect)->data = (bfd_byte *)NULL; + oasys_per_section(newsect)->section = newsect; + oasys_per_section(newsect)->offset = 0; + return true; +} + + +unsigned int +oasys_get_reloc_upper_bound (abfd, asect) +bfd *abfd; +sec_ptr asect; +{ + oasys_slurp_section_data(abfd); + return (asect->reloc_count+1) * sizeof(arelent *); +} + +static boolean +oasys_get_section_contents (abfd, section, location, offset, count) +bfd *abfd; +sec_ptr section; +void *location; +file_ptr offset; +unsigned int count; +{ + oasys_per_section_type *p = section->used_by_bfd; + oasys_slurp_section_data(abfd); + (void) memcpy(location, p->data + offset, count); + return true; +} + + +unsigned int +oasys_canonicalize_reloc (abfd, section, relptr, symbols) +bfd *abfd; +sec_ptr section; +arelent **relptr; +asymbol **symbols; +{ + oasys_reloc_type *src = (oasys_reloc_type *)(section->relocation); + while (src != (oasys_reloc_type *)NULL) { + if (src->relent.section == (asection *)NULL) { + src->relent.sym_ptr_ptr = symbols + src->symbol; + } + *relptr ++ = &src->relent; + src = src->next; + } + *relptr = (arelent *)NULL; + return section->reloc_count; +} + +boolean +oasys_set_arch_mach (abfd, arch, machine) +bfd *abfd; +enum bfd_architecture arch; +unsigned long machine; +{ + abfd->obj_arch = arch; + abfd->obj_machine = machine; + return true; +} + +boolean +oasys_mkobject(abfd) +bfd *abfd; +{ + oasys_data_type *oasys = + (oasys_data_type *) malloc(sizeof(oasys_data_type)); + oasys_data(abfd) = oasys; + if (oasys == (oasys_data_type *)NULL) { + bfd_error = no_memory; + return false; + } + + return true; +} + + + + + + + +static void +init_for_output(abfd) +bfd *abfd; +{ + asection *s; + for (s = abfd->sections; s != (asection *)NULL; s = s->next) { + if (s->size != 0) { + oasys_per_section(s)->data = (bfd_byte *)(malloc(s->size)); + } + } +} + +/** exec and core file sections */ + +/* set section contents is complicated with OASYS since the format is +* not a byte image, but a record stream. +*/ +boolean +oasys_set_section_contents (abfd, section, location, offset, count) +bfd *abfd; +sec_ptr section; +unsigned char *location; +file_ptr offset; +int count; +{ + if (oasys_per_section(section)->data == (bfd_byte *)NULL) { + init_for_output(abfd); + } + (void) memcpy(oasys_per_section(section)->data + offset, location, count); + return true; +} + + + + +/* Native-level interface to symbols. */ + +/* We read the symbols into a buffer, which is discarded when this +function exits. We read the strings into a buffer large enough to +hold them all plus all the cached symbol entries. */ + +asymbol * +oasys_make_empty_symbol (abfd) +bfd *abfd; +{ + + oasys_symbol_type *new = + (oasys_symbol_type *)zalloc (sizeof (oasys_symbol_type)); + new->symbol.the_bfd = abfd; + return &new->symbol; + +} + +void +oasys_reclaim_symbol_table (abfd) +bfd *abfd; +{ +#if 0 + asection *section; + + if (!bfd_get_symcount (abfd)) return; + + for (section = abfd->sections; section != NULL; section = section->next) + if (section->relocation) { + free ((void *)section->relocation); + section->relocation = NULL; + section->reloc_count = 0; + } + + bfd_get_symcount (abfd) = 0; + free ((void *)obj_aout_symbols (abfd)); + obj_aout_symbols (abfd) = (aout_symbol_type *)NULL; +#endif +} + + + + +/* Obsbolete procedural interface; better to look at the cache directly */ + +/* User should have checked the file flags; perhaps we should return +BFD_NO_MORE_SYMBOLS if there are none? */ + +int +oasys_get_symcount_upper_bound (abfd) +bfd *abfd; +{ +#if 0 + /* In case we're doing an output file or something...? */ + if (bfd_get_symcount (abfd)) return bfd_get_symcount (abfd); + + return (exec_hdr (abfd)->a_syms) / (sizeof (struct nlist)); +#endif +} + +symindex +oasys_get_first_symbol (ignore_abfd) +bfd * ignore_abfd; +{ + return 0; +} + +symindex +oasys_get_next_symbol (abfd, oidx) +bfd *abfd; +symindex oidx; +{ +#if 0 + if (oidx == BFD_NO_MORE_SYMBOLS) return BFD_NO_MORE_SYMBOLS; + return ++oidx >= bfd_get_symcount (abfd) ? BFD_NO_MORE_SYMBOLS : + oidx; +#endif +} + +char * +oasys_symbol_name (abfd, idx) +bfd *abfd; +symindex idx; +{ +#if 0 + return (obj_aout_symbols (abfd) + idx)->symbol.name; +#endif +} + +long +oasys_symbol_value (abfd, idx) +bfd *abfd; +symindex idx; +{ +#if 0 + return (obj_aout_symbols (abfd) + idx)->symbol.value; +#endif +} + +symclass +oasys_classify_symbol (abfd, idx) +bfd *abfd; +symindex idx; +{ +#if 0 + aout_symbol_type *sym = obj_aout_symbols (abfd) + idx; + + if ((sym->symbol.flags & BSF_FORT_COMM) != 0) return bfd_symclass_fcommon; + if ((sym->symbol.flags & BSF_GLOBAL) != 0) return bfd_symclass_global; + if ((sym->symbol.flags & BSF_DEBUGGING) != 0) return bfd_symclass_debugger; + if ((sym->symbol.flags & BSF_UNDEFINED) != 0) return bfd_symclass_undefined; +#endif + return bfd_symclass_unknown; +} + +boolean +oasys_symbol_hasclass (abfd, idx, class) +bfd *abfd; +symindex idx; +symclass class; +{ +#if 0 + aout_symbol_type *sym = obj_aout_symbols (abfd) + idx; + switch (class) { + case bfd_symclass_fcommon: + return (sym->symbol.flags & BSF_FORT_COMM) ? true :false; + case bfd_symclass_global: + return (sym->symbol.flags & BSF_GLOBAL) ? true:false; + case bfd_symclass_debugger: + return (sym->symbol.flags & BSF_DEBUGGING) ? true:false;; + case bfd_symclass_undefined: + return (sym->symbol.flags & BSF_UNDEFINED) ? true:false;; + default: return false; + } +#endif +} + + +void +oasys_reclaim_reloc (ignore_abfd, section) +bfd *ignore_abfd; +sec_ptr section; +{ +#if 0 + if (section->relocation) { + free (section->relocation); + section->relocation = NULL; + section->reloc_count = 0; + } +#endif +} + +boolean +oasys_close_and_cleanup (abfd) +bfd *abfd; +{ + if (bfd_read_p (abfd) == false) + switch (abfd->format) { + case bfd_archive: + if (!_bfd_write_archive_contents (abfd)) { + return false; + } + break; + case bfd_object: +/* if (!oasys_write_object_contents (abfd)) */{ + return false; + } + break; + default: + bfd_error = invalid_operation; + return false; + } + + + if (oasys_data(abfd) != (oasys_data_type *)NULL) { + /* FIXME MORE LEAKS */ + + } + + return true; +} + +static bfd * +oasys_openr_next_archived_file(arch, prev) +bfd *arch; +bfd *prev; +{ + oasys_ar_data_type *ar = oasys_ar_data(arch); + oasys_module_info_type *p; + /* take the next one from the arch state, or reset */ + if (prev == (bfd *)NULL) { + /* Reset the index - the first two entries are bogus*/ + ar->module_index = 0; + } + + p = ar->module + ar->module_index; + ar->module_index++; + + if (ar->module_index <= ar->module_count) { + if (p->abfd == (bfd *)NULL) { + p->abfd = _bfd_create_empty_archive_element_shell(arch); + p->abfd->origin = p->pos; + p->abfd->filename = p->name; + + /* Fixup a pointer to this element for the member */ + p->abfd->arelt_data = (void *)p; + } + return p->abfd; + } + else { + bfd_error = no_more_archived_files; + return (bfd *)NULL; + } +} + +static boolean +oasys_find_nearest_line(abfd, + section, + symbols, + offset, + filename_ptr, + functionname_ptr, + line_ptr) +bfd *abfd; +asection *section; +asymbol **symbols; +bfd_vma offset; +char **filename_ptr; +char **functionname_ptr; +unsigned int *line_ptr; +{ + return false; + +} + +static int +oasys_stat_arch_elt(abfd, buf) +bfd *abfd; +struct stat *buf; +{ + oasys_module_info_type *mod = abfd->arelt_data; + if (mod == (oasys_module_info_type *)NULL) { + bfd_error = invalid_operation; + return -1; + } + else { + buf->st_size = mod->size; + buf->st_mode = 0666; + return 0; + } + + +} + + +/*SUPPRESS 460 */ +bfd_target oasys_vec = +{ + "oasys", /* name */ + bfd_target_oasys_flavour_enum, + true, /* target byte order */ + true, /* target headers byte order */ + (HAS_RELOC | EXEC_P | /* object flags */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), + (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS + |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + 0, /* valid reloc types */ + ' ', /* ar_pad_char */ + 16, /* ar_max_namelen */ + oasys_close_and_cleanup, /* _close_and_cleanup */ + oasys_set_section_contents, /* bfd_set_section_contents */ + oasys_get_section_contents, + oasys_new_section_hook, /* new_section_hook */ + 0, /* _core_file_failing_command */ + 0, /* _core_file_failing_signal */ + 0, /* _core_file_matches_ex...p */ + + 0, /* bfd_slurp_bsd_armap, bfd_slurp_armap */ + bfd_true, /* bfd_slurp_extended_name_table */ + bfd_bsd_truncate_arname, /* bfd_truncate_arname */ + + oasys_get_symtab_upper_bound, /* get_symtab_upper_bound */ + oasys_get_symtab, /* canonicalize_symtab */ + 0, /* oasys_reclaim_symbol_table, bfd_reclaim_symbol_table */ + oasys_get_reloc_upper_bound, /* get_reloc_upper_bound */ + oasys_canonicalize_reloc, /* bfd_canonicalize_reloc */ + 0, /* oasys_reclaim_reloc, bfd_reclaim_reloc */ + 0, /* oasys_get_symcount_upper_bound, bfd_get_symcount_upper_bound */ + 0, /* oasys_get_first_symbol, bfd_get_first_symbol */ + 0, /* oasys_get_next_symbol, bfd_get_next_symbol */ + 0, /* oasys_classify_symbol, bfd_classify_symbol */ + 0, /* oasys_symbol_hasclass, bfd_symbol_hasclass */ + 0, /* oasys_symbol_name, bfd_symbol_name */ + 0, /* oasys_symbol_value, bfd_symbol_value */ + + _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */ + _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ + + {_bfd_dummy_target, + oasys_object_p, /* bfd_check_format */ + oasys_archive_p, + bfd_false + }, + { + bfd_false, + oasys_mkobject, + _bfd_generic_mkarchive, + bfd_false + }, + oasys_make_empty_symbol, + oasys_print_symbol, + bfd_false, /* oasys_get_lineno,*/ + oasys_set_arch_mach, /* bfd_set_arch_mach,*/ + bfd_false, + oasys_openr_next_archived_file, + oasys_find_nearest_line, /* bfd_find_nearest_line */ + oasys_stat_arch_elt, /* bfd_stat_arch_elt */ +}; diff --git a/bfd/obstack.c b/bfd/obstack.c new file mode 100755 index 0000000000..52258d36e8 --- /dev/null +++ b/bfd/obstack.c @@ -0,0 +1,335 @@ +/* obstack.c - subroutines used implicitly by object stack macros + Copyright (C) 1988 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 1, or (at your option) any +later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "obstack.h" + +#ifdef __STDC__ +#define POINTER void * +#else +#define POINTER char * +#endif + +/* Determine default alignment. */ +struct fooalign {char x; double d;}; +#define DEFAULT_ALIGNMENT ((char *)&((struct fooalign *) 0)->d - (char *)0) +/* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT. + But in fact it might be less smart and round addresses to as much as + DEFAULT_ROUNDING. So we prepare for it to do that. */ +union fooround {long x; double d;}; +#define DEFAULT_ROUNDING (sizeof (union fooround)) + +/* When we copy a long block of data, this is the unit to do it with. + On some machines, copying successive ints does not work; + in such a case, redefine COPYING_UNIT to `long' (if that works) + or `char' as a last resort. */ +#ifndef COPYING_UNIT +#define COPYING_UNIT int +#endif + +/* The non-GNU-C macros copy the obstack into this global variable + to avoid multiple evaluation. */ + +struct obstack *_obstack; + +/* Initialize an obstack H for use. Specify chunk size SIZE (0 means default). + Objects start on multiples of ALIGNMENT (0 means use default). + CHUNKFUN is the function to use to allocate chunks, + and FREEFUN the function to free them. */ + +void +_obstack_begin (h, size, alignment, chunkfun, freefun) + struct obstack *h; + int size; + int alignment; + POINTER (*chunkfun) (); + void (*freefun) (); +{ + register struct _obstack_chunk* chunk; /* points to new chunk */ + + if (alignment == 0) + alignment = DEFAULT_ALIGNMENT; + if (size == 0) + /* Default size is what GNU malloc can fit in a 4096-byte block. */ + { + /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. + Use the values for range checking, because if range checking is off, + the extra bytes won't be missed terribly, but if range checking is on + and we used a larger request, a whole extra 4096 bytes would be + allocated. + + These number are irrelevant to the new GNU malloc. I suspect it is + less sensitive to the size of the request. */ + int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) + + 4 + DEFAULT_ROUNDING - 1) + & ~(DEFAULT_ROUNDING - 1)); + size = 4096 - extra; + } + + h->chunkfun = chunkfun; + h->freefun = freefun; + h->chunk_size = size; + h->alignment_mask = alignment - 1; + + chunk = h->chunk = (struct _obstack_chunk *)(*h->chunkfun) (h->chunk_size); + h->next_free = h->object_base = chunk->contents; + h->chunk_limit = chunk->limit + = (char *) chunk + h->chunk_size; + chunk->prev = 0; +} + +/* Allocate a new current chunk for the obstack *H + on the assumption that LENGTH bytes need to be added + to the current object, or a new object of length LENGTH allocated. + Copies any partial object from the end of the old chunk + to the beginning of the new one. + + The function must be "int" so it can be used in non-ANSI C + compilers in a : expression. */ + +int +_obstack_newchunk (h, length) + struct obstack *h; + int length; +{ + register struct _obstack_chunk* old_chunk = h->chunk; + register struct _obstack_chunk* new_chunk; + register long new_size; + register int obj_size = h->next_free - h->object_base; + register int i; + int already; + + /* Compute size for new chunk. */ + new_size = (obj_size + length) + (obj_size >> 3) + 100; + if (new_size < h->chunk_size) + new_size = h->chunk_size; + + /* Allocate and initialize the new chunk. */ + new_chunk = h->chunk = (struct _obstack_chunk *)(*h->chunkfun) (new_size); + new_chunk->prev = old_chunk; + new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size; + + /* Move the existing object to the new chunk. + Word at a time is fast and is safe if the object + is sufficiently aligned. */ + if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT) + { + for (i = obj_size / sizeof (COPYING_UNIT) - 1; + i >= 0; i--) + ((COPYING_UNIT *)new_chunk->contents)[i] + = ((COPYING_UNIT *)h->object_base)[i]; + /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT, + but that can cross a page boundary on a machine + which does not do strict alignment for COPYING_UNITS. */ + already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT); + } + else + already = 0; + /* Copy remaining bytes one by one. */ + for (i = already; i < obj_size; i++) + new_chunk->contents[i] = h->object_base[i]; + + h->object_base = new_chunk->contents; + h->next_free = h->object_base + obj_size; +return 0; +} + +/* Return nonzero if object OBJ has been allocated from obstack H. + This is here for debugging. + If you use it in a program, you are probably losing. */ + +int +_obstack_allocated_p (h, obj) + struct obstack *h; + POINTER obj; +{ + register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */ + register struct _obstack_chunk* plp; /* point to previous chunk if any */ + + lp = (h)->chunk; + while (lp != 0 && ((POINTER)lp > obj || (POINTER)(lp)->limit < obj)) + { + plp = lp -> prev; + lp = plp; + } + return lp != 0; +} + +/* Free objects in obstack H, including OBJ and everything allocate + more recently than OBJ. If OBJ is zero, free everything in H. */ + +#ifdef __STDC__ +#undef obstack_free +void +obstack_free (struct obstack *h, POINTER obj) +#else +int +_obstack_free (h, obj) + struct obstack *h; + POINTER obj; +#endif +{ + register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */ + register struct _obstack_chunk* plp; /* point to previous chunk if any */ + + lp = (h)->chunk; + /* We use >= because there cannot be an object at the beginning of a chunk. + But there can be an empty object at that address + at the end of another chunk. */ + while (lp != 0 && ((POINTER)lp >= obj || (POINTER)(lp)->limit < obj)) + { + plp = lp -> prev; + (*h->freefun) ((POINTER) lp); + lp = plp; + } + if (lp) + { + (h)->object_base = (h)->next_free = (char *)(obj); + (h)->chunk_limit = lp->limit; + (h)->chunk = lp; + } + else if (obj != 0) + /* obj is not in any of the chunks! */ + abort (); +} + +/* Let same .o link with output of gcc and other compilers. */ + +#ifdef __STDC__ +int +_obstack_free (h, obj) + struct obstack *h; + POINTER obj; +{ + obstack_free (h, obj); + return 0; +} +#endif + +/* #if 0 */ +/* These are now turned off because the applications do not use it + and it uses bcopy via obstack_grow, which causes trouble on sysV. */ + +/* Now define the functional versions of the obstack macros. + Define them to simply use the corresponding macros to do the job. */ + +#ifdef __STDC__ +/* These function definitions do not work with non-ANSI preprocessors; + they won't pass through the macro names in parentheses. */ + +/* The function names appear in parentheses in order to prevent + the macro-definitions of the names from being expanded there. */ + +POINTER (obstack_base) (obstack) + struct obstack *obstack; +{ + return obstack_base (obstack); +} + +POINTER (obstack_next_free) (obstack) + struct obstack *obstack; +{ + return obstack_next_free (obstack); +} + +int (obstack_object_size) (obstack) + struct obstack *obstack; +{ + return obstack_object_size (obstack); +} + +int (obstack_room) (obstack) + struct obstack *obstack; +{ + return obstack_room (obstack); +} + +void (obstack_grow) (obstack, pointer, length) + struct obstack *obstack; + POINTER pointer; + int length; +{ + obstack_grow (obstack, pointer, length); +} + +void (obstack_grow0) (obstack, pointer, length) + struct obstack *obstack; + POINTER pointer; + int length; +{ + obstack_grow0 (obstack, pointer, length); +} + +void (obstack_1grow) (obstack, character) + struct obstack *obstack; + int character; +{ + obstack_1grow (obstack, character); +} + +void (obstack_blank) (obstack, length) + struct obstack *obstack; + int length; +{ + obstack_blank (obstack, length); +} + +void (obstack_1grow_fast) (obstack, character) + struct obstack *obstack; + int character; +{ + obstack_1grow_fast (obstack, character); +} + +void (obstack_blank_fast) (obstack, length) + struct obstack *obstack; + int length; +{ + obstack_blank_fast (obstack, length); +} + +POINTER (obstack_finish) (obstack) + struct obstack *obstack; +{ + return obstack_finish (obstack); +} + +POINTER (obstack_alloc) (obstack, length) + struct obstack *obstack; + int length; +{ + return obstack_alloc (obstack, length); +} + +POINTER (obstack_copy) (obstack, pointer, length) + struct obstack *obstack; + POINTER pointer; + int length; +{ + return obstack_copy (obstack, pointer, length); +} + +POINTER (obstack_copy0) (obstack, pointer, length) + struct obstack *obstack; + POINTER pointer; + int length; +{ + return obstack_copy0 (obstack, pointer, length); +} + +#endif /* __STDC__ */ + + diff --git a/bfd/obstack.h b/bfd/obstack.h new file mode 100755 index 0000000000..0f3b37c4e0 --- /dev/null +++ b/bfd/obstack.h @@ -0,0 +1,416 @@ +/* obstack.h - object stack macros + Copyright (C) 1988 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 1, or (at your option) any +later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Summary: + +All the apparent functions defined here are macros. The idea +is that you would use these pre-tested macros to solve a +very specific set of problems, and they would run fast. +Caution: no side-effects in arguments please!! They may be +evaluated MANY times!! + +These macros operate a stack of objects. Each object starts life +small, and may grow to maturity. (Consider building a word syllable +by syllable.) An object can move while it is growing. Once it has +been "finished" it never changes address again. So the "top of the +stack" is typically an immature growing object, while the rest of the +stack is of mature, fixed size and fixed address objects. + +These routines grab large chunks of memory, using a function you +supply, called `obstack_chunk_alloc'. On occasion, they free chunks, +by calling `obstack_chunk_free'. You must define them and declare +them before using any obstack macros. + +Each independent stack is represented by a `struct obstack'. +Each of the obstack macros expects a pointer to such a structure +as the first argument. + +One motivation for this package is the problem of growing char strings +in symbol tables. Unless you are "fascist pig with a read-only mind" +[Gosper's immortal quote from HAKMEM item 154, out of context] you +would not like to put any arbitrary upper limit on the length of your +symbols. + +In practice this often means you will build many short symbols and a +few long symbols. At the time you are reading a symbol you don't know +how long it is. One traditional method is to read a symbol into a +buffer, realloc()ating the buffer every time you try to read a symbol +that is longer than the buffer. This is beaut, but you still will +want to copy the symbol from the buffer to a more permanent +symbol-table entry say about half the time. + +With obstacks, you can work differently. Use one obstack for all symbol +names. As you read a symbol, grow the name in the obstack gradually. +When the name is complete, finalize it. Then, if the symbol exists already, +free the newly read name. + +The way we do this is to take a large chunk, allocating memory from +low addresses. When you want to build a symbol in the chunk you just +add chars above the current "high water mark" in the chunk. When you +have finished adding chars, because you got to the end of the symbol, +you know how long the chars are, and you can create a new object. +Mostly the chars will not burst over the highest address of the chunk, +because you would typically expect a chunk to be (say) 100 times as +long as an average object. + +In case that isn't clear, when we have enough chars to make up +the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed) +so we just point to it where it lies. No moving of chars is +needed and this is the second win: potentially long strings need +never be explicitly shuffled. Once an object is formed, it does not +change its address during its lifetime. + +When the chars burst over a chunk boundary, we allocate a larger +chunk, and then copy the partly formed object from the end of the old +chunk to the beginning of the new larger chunk. We then carry on +accreting characters to the end of the object as we normally would. + +A special macro is provided to add a single char at a time to a +growing object. This allows the use of register variables, which +break the ordinary 'growth' macro. + +Summary: + We allocate large chunks. + We carve out one object at a time from the current chunk. + Once carved, an object never moves. + We are free to append data of any size to the currently + growing object. + Exactly one object is growing in an obstack at any one time. + You can run one obstack per control block. + You may have as many control blocks as you dare. + Because of the way we do it, you can `unwind' a obstack + back to a previous state. (You may remove objects much + as you would with a stack.) +*/ + + +/* Don't do the contents of this file more than once. */ + +#ifndef __OBSTACKS__ +#define __OBSTACKS__ + +/* We use subtraction of (char *)0 instead of casting to int + because on word-addressable machines a simple cast to int + may ignore the byte-within-word field of the pointer. */ + +#ifndef __PTR_TO_INT +#define __PTR_TO_INT(P) ((P) - (char *)0) +#endif + +#ifndef __INT_TO_PTR +#define __INT_TO_PTR(P) ((P) + (char *)0) +#endif + +struct _obstack_chunk /* Lives at front of each chunk. */ +{ + char *limit; /* 1 past end of this chunk */ + struct _obstack_chunk *prev; /* address of prior chunk or NULL */ + char contents[4]; /* objects begin here */ +}; + +struct obstack /* control current object in current chunk */ +{ + long chunk_size; /* preferred size to allocate chunks in */ + struct _obstack_chunk* chunk; /* address of current struct obstack_chunk */ + char *object_base; /* address of object we are building */ + char *next_free; /* where to add next char to current object */ + char *chunk_limit; /* address of char after current chunk */ + int temp; /* Temporary for some macros. */ + int alignment_mask; /* Mask of alignment for each object. */ +#ifdef __STDC__ + void *(*chunkfun) (); /* User's fcn to allocate a chunk. */ +#else + char *(*chunkfun) (); /* User's fcn to allocate a chunk. */ +#endif + void (*freefun) (); /* User's function to free a chunk. */ +}; + +#ifdef __STDC__ + +/* Do the function-declarations after the structs + but before defining the macros. */ + +void obstack_init (struct obstack *obstack); + +void * obstack_alloc (struct obstack *obstack, int size); + +void * obstack_copy (struct obstack *obstack, void *address, int size); +void * obstack_copy0 (struct obstack *obstack, void *address, int size); + +void obstack_free (struct obstack *obstack, void *block); + +void obstack_blank (struct obstack *obstack, int size); + +void obstack_grow (struct obstack *obstack, void *data, int size); +void obstack_grow0 (struct obstack *obstack, void *data, int size); + +void obstack_1grow (struct obstack *obstack, int data_char); +void obstack_ptr_grow (struct obstack *obstack, void *data); +void obstack_int_grow (struct obstack *obstack, int data); + +void * obstack_finish (struct obstack *obstack); + +int obstack_object_size (struct obstack *obstack); + +int obstack_room (struct obstack *obstack); +void obstack_1grow_fast (struct obstack *obstack, int data_char); +void obstack_ptr_grow_fast (struct obstack *obstack, void *data); +void obstack_int_grow_fast (struct obstack *obstack, int data); +void obstack_blank_fast (struct obstack *obstack, int size); + +void * obstack_base (struct obstack *obstack); +void * obstack_next_free (struct obstack *obstack); +int obstack_alignment_mask (struct obstack *obstack); +int obstack_chunk_size (struct obstack *obstack); + +#endif /* __STDC__ */ + +/* Non-ANSI C cannot really support alternative functions for these macros, + so we do not declare them. */ + +/* Pointer to beginning of object being allocated or to be allocated next. + Note that this might not be the final address of the object + because a new chunk might be needed to hold the final size. */ + +#define obstack_base(h) ((h)->object_base) + +/* Size for allocating ordinary chunks. */ + +#define obstack_chunk_size(h) ((h)->chunk_size) + +/* Pointer to next byte not yet allocated in current chunk. */ + +#define obstack_next_free(h) ((h)->next_free) + +/* Mask specifying low bits that should be clear in address of an object. */ + +#define obstack_alignment_mask(h) ((h)->alignment_mask) + +#define obstack_init(h) \ + _obstack_begin ((h), 0, 0, obstack_chunk_alloc, obstack_chunk_free) + +#define obstack_begin(h, size) \ + _obstack_begin ((h), (size), 0, obstack_chunk_alloc, obstack_chunk_free) + +#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar) + +#define obstack_blank_fast(h,n) ((h)->next_free += (n)) + +#if defined (__GNUC__) && defined (__STDC__) + +/* For GNU C, if not -traditional, + we can define these macros to compute all args only once + without using a global variable. + Also, we can avoid using the `temp' slot, to make faster code. */ + +#define obstack_object_size(OBSTACK) \ + ({ struct obstack *__o = (OBSTACK); \ + (unsigned) (__o->next_free - __o->object_base); }) + +#define obstack_room(OBSTACK) \ + ({ struct obstack *__o = (OBSTACK); \ + (unsigned) (__o->chunk_limit - __o->next_free); }) + +#define obstack_grow(OBSTACK,where,length) \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + ((__o->next_free + __len > __o->chunk_limit) \ + ? _obstack_newchunk (__o, __len) : 0); \ + bcopy (where, __o->next_free, __len); \ + __o->next_free += __len; \ + (void) 0; }) + +#define obstack_grow0(OBSTACK,where,length) \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + ((__o->next_free + __len + 1 > __o->chunk_limit) \ + ? _obstack_newchunk (__o, __len + 1) : 0), \ + bcopy (where, __o->next_free, __len), \ + __o->next_free += __len, \ + *(__o->next_free)++ = 0; \ + (void) 0; }) + +#define obstack_1grow(OBSTACK,datum) \ +({ struct obstack *__o = (OBSTACK); \ + ((__o->next_free + 1 > __o->chunk_limit) \ + ? _obstack_newchunk (__o, 1) : 0), \ + *(__o->next_free)++ = (datum); \ + (void) 0; }) + +/* These assume that the obstack alignment is good enough for pointers or ints, + and that the data added so far to the current object + shares that much alignment. */ + +#define obstack_ptr_grow(OBSTACK,datum) \ +({ struct obstack *__o = (OBSTACK); \ + ((__o->next_free + sizeof (void *) > __o->chunk_limit) \ + ? _obstack_newchunk (__o, sizeof (void *)) : 0), \ + *((void **)__o->next_free)++ = ((void *)datum); \ + (void) 0; }) + +#define obstack_int_grow(OBSTACK,datum) \ +({ struct obstack *__o = (OBSTACK); \ + ((__o->next_free + sizeof (int) > __o->chunk_limit) \ + ? _obstack_newchunk (__o, sizeof (int)) : 0), \ + *((int *)__o->next_free)++ = ((int)datum); \ + (void) 0; }) + +#define obstack_ptr_grow_fast(h,aptr) (*((void **)(h)->next_free)++ = (void *)aptr) +#define obstack_int_grow_fast(h,aint) (*((int *)(h)->next_free)++ = (int)aint) + +#define obstack_blank(OBSTACK,length) \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + ((__o->chunk_limit - __o->next_free < __len) \ + ? _obstack_newchunk (__o, __len) : 0); \ + __o->next_free += __len; \ + (void) 0; }) + +#define obstack_alloc(OBSTACK,length) \ +({ struct obstack *__h = (OBSTACK); \ + obstack_blank (__h, (length)); \ + obstack_finish (__h); }) + +#define obstack_copy(OBSTACK,where,length) \ +({ struct obstack *__h = (OBSTACK); \ + obstack_grow (__h, (where), (length)); \ + obstack_finish (__h); }) + +#define obstack_copy0(OBSTACK,where,length) \ +({ struct obstack *__h = (OBSTACK); \ + obstack_grow0 (__h, (where), (length)); \ + obstack_finish (__h); }) + +#define obstack_finish(OBSTACK) \ +({ struct obstack *__o = (OBSTACK); \ + void *value = (void *) __o->object_base; \ + __o->next_free \ + = __INT_TO_PTR ((__PTR_TO_INT (__o->next_free)+__o->alignment_mask)\ + & ~ (__o->alignment_mask)); \ + ((__o->next_free - (char *)__o->chunk \ + > __o->chunk_limit - (char *)__o->chunk) \ + ? (__o->next_free = __o->chunk_limit) : 0); \ + __o->object_base = __o->next_free; \ + value; }) + +#define obstack_free(OBSTACK, OBJ) \ +({ struct obstack *__o = (OBSTACK); \ + void *__obj = (OBJ); \ + if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ + __o->next_free = __o->object_base = __obj; \ + else (obstack_free) (__o, __obj); }) + +#else /* not __GNUC__ or not __STDC__ */ + +#define obstack_object_size(h) \ + (unsigned) ((h)->next_free - (h)->object_base) + +#define obstack_room(h) \ + (unsigned) ((h)->chunk_limit - (h)->next_free) + +#define obstack_grow(h,where,length) \ +( (h)->temp = (length), \ + (((h)->next_free + (h)->temp > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), (h)->temp) : 0), \ + bcopy (where, (h)->next_free, (h)->temp), \ + (h)->next_free += (h)->temp) + +#define obstack_grow0(h,where,length) \ +( (h)->temp = (length), \ + (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), (h)->temp + 1) : 0), \ + bcopy (where, (h)->next_free, (h)->temp), \ + (h)->next_free += (h)->temp, \ + *((h)->next_free)++ = 0) + +#define obstack_1grow(h,datum) \ +( (((h)->next_free + 1 > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), 1) : 0), \ + *((h)->next_free)++ = (datum)) + +#define obstack_ptr_grow(h,datum) \ +( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), sizeof (char *)) : 0), \ + *((char **)(h)->next_free)++ = ((char *)datum)) + +#define obstack_int_grow(h,datum) \ +( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), sizeof (int)) : 0), \ + *((int *)(h)->next_free)++ = ((int)datum)) + +#define obstack_ptr_grow_fast(h,aptr) (*((char **)(h)->next_free)++ = (char *)aptr) +#define obstack_int_grow_fast(h,aint) (*((int *)(h)->next_free)++ = (int)aint) + +#define obstack_blank(h,length) \ +( (h)->temp = (length), \ + (((h)->chunk_limit - (h)->next_free < (h)->temp) \ + ? _obstack_newchunk ((h), (h)->temp) : 0), \ + (h)->next_free += (h)->temp) + +#define obstack_alloc(h,length) \ + (obstack_blank ((h), (length)), obstack_finish ((h))) + +#define obstack_copy(h,where,length) \ + (obstack_grow ((h), (where), (length)), obstack_finish ((h))) + +#define obstack_copy0(h,where,length) \ + (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) + +#define obstack_finish(h) \ +( (h)->temp = __PTR_TO_INT ((h)->object_base), \ + (h)->next_free \ + = __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \ + & ~ ((h)->alignment_mask)), \ + (((h)->next_free - (char *)(h)->chunk \ + > (h)->chunk_limit - (char *)(h)->chunk) \ + ? ((h)->next_free = (h)->chunk_limit) : 0), \ + (h)->object_base = (h)->next_free, \ + __INT_TO_PTR ((h)->temp)) + +#ifdef __STDC__ +#define obstack_free(h,obj) \ +( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \ + (((h)->temp >= 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ + ? (int) ((h)->next_free = (h)->object_base \ + = (h)->temp + (char *) (h)->chunk) \ + : ((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0))) +#else +#define obstack_free(h,obj) \ +( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \ + (((h)->temp >= 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ + ? (int) ((h)->next_free = (h)->object_base \ + = (h)->temp + (char *) (h)->chunk) \ + : (int) _obstack_free ((h), (h)->temp + (char *) (h)->chunk))) +#endif + +#endif /* not __GNUC__ or not __STDC__ */ + +/* Declare the external functions we use; they are in obstack.c. */ + +#ifdef __STDC__ + extern int _obstack_newchunk (struct obstack *h, int length); + extern int _obstack_free (struct obstack *h, void *obj); + extern void _obstack_begin (struct obstack *h, int size, int alignment, + void *(*chunkfun) (), void (*freefun) ()); +#else + extern int _obstack_newchunk (); + extern int _obstack_free (); + extern void _obstack_begin (); +#endif + +#endif /* not __OBSTACKS__ */ +