1 /* BFD back-end for ieee-695 objects.
2 Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #define KEEPMINUSPCININST 0
23 /* IEEE 695 format is a stream of records, which we parse using a simple one-
24 token (which is one byte in this lexicon) lookahead recursive decent
33 #define obstack_chunk_alloc malloc
34 #define obstack_chunk_free free
36 /* Functions for writing to ieee files in the strange way that the
40 ieee_write_byte (abfd, byte)
44 if (bfd_write ((PTR) & byte, 1, 1, abfd) != 1)
49 ieee_write_twobyte (abfd, twobyte)
54 b[1] = twobyte & 0xff;
56 if (bfd_write ((PTR) & b[0], 1, 2, abfd) != 2)
61 ieee_write_2bytes (abfd, bytes)
66 buffer[0] = bytes >> 8;
67 buffer[1] = bytes & 0xff;
69 if (bfd_write ((PTR) buffer, 1, 2, abfd) != 2)
74 ieee_write_int (abfd, value)
78 if (((unsigned) value) <= 127)
80 ieee_write_byte (abfd, (bfd_byte) value);
85 /* How many significant bytes ? */
86 /* FIXME FOR LONGER INTS */
87 if (value & 0xff000000)
91 else if (value & 0x00ff0000)
95 else if (value & 0x0000ff00)
102 ieee_write_byte (abfd,
103 (bfd_byte) ((int) ieee_number_repeat_start_enum + length));
107 ieee_write_byte (abfd, (bfd_byte) (value >> 24));
109 ieee_write_byte (abfd, (bfd_byte) (value >> 16));
111 ieee_write_byte (abfd, (bfd_byte) (value >> 8));
113 ieee_write_byte (abfd, (bfd_byte) (value));
119 ieee_write_id (abfd, id)
123 size_t length = strlen (id);
126 ieee_write_byte (abfd, (bfd_byte) length);
128 else if (length < 255)
130 ieee_write_byte (abfd, ieee_extension_length_1_enum);
131 ieee_write_byte (abfd, (bfd_byte) length);
133 else if (length < 65535)
135 ieee_write_byte (abfd, ieee_extension_length_2_enum);
136 ieee_write_byte (abfd, (bfd_byte) (length >> 8));
137 ieee_write_byte (abfd, (bfd_byte) (length & 0xff));
143 if (bfd_write ((PTR) id, 1, length, abfd) != length)
148 /***************************************************************************
149 Functions for reading from ieee files in the strange way that the
153 #define this_byte(ieee) *((ieee)->input_p)
154 #define next_byte(ieee) ((ieee)->input_p++)
155 #define this_byte_and_next(ieee) (*((ieee)->input_p++))
157 static unsigned short
159 common_header_type *ieee;
161 unsigned char c1 = this_byte_and_next (ieee);
162 unsigned char c2 = this_byte_and_next (ieee);
163 return (c1 << 8) | c2;
167 bfd_get_string (ieee, string, length)
168 common_header_type *ieee;
173 for (i = 0; i < length; i++)
175 string[i] = this_byte_and_next (ieee);
181 common_header_type *ieee;
185 length = this_byte_and_next (ieee);
188 /* Simple string of length 0 to 127 */
190 else if (length == 0xde)
192 /* Length is next byte, allowing 0..255 */
193 length = this_byte_and_next (ieee);
195 else if (length == 0xdf)
197 /* Length is next two bytes, allowing 0..65535 */
198 length = this_byte_and_next (ieee);
199 length = (length * 256) + this_byte_and_next (ieee);
201 /* Buy memory and read string */
202 string = bfd_alloc (ieee->abfd, length + 1);
205 bfd_set_error (bfd_error_no_memory);
208 bfd_get_string (ieee, string, length);
214 ieee_write_expression (abfd, value, symbol, pcrel, index)
221 unsigned int term_count = 0;
225 ieee_write_int (abfd, value);
229 if (bfd_is_com_section (symbol->section)
230 || symbol->section == &bfd_und_section)
232 /* Def of a common symbol */
233 ieee_write_byte (abfd, ieee_variable_X_enum);
234 ieee_write_int (abfd, symbol->value);
237 else if (symbol->section != &bfd_abs_section)
239 /* Ref to defined symbol - */
241 ieee_write_byte (abfd, ieee_variable_R_enum);
242 ieee_write_byte (abfd,
243 (bfd_byte) (symbol->section->index + IEEE_SECTION_NUMBER_BASE));
245 if (symbol->flags & BSF_GLOBAL)
247 ieee_write_byte (abfd, ieee_variable_I_enum);
248 ieee_write_int (abfd, symbol->value);
251 else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM))
253 /* This is a reference to a defined local symbol,
254 We can easily do a local as a section+offset */
255 ieee_write_byte (abfd, ieee_variable_R_enum); /* or L */
256 ieee_write_byte (abfd,
257 (bfd_byte) (symbol->section->index + IEEE_SECTION_NUMBER_BASE));
258 ieee_write_int (abfd, symbol->value);
269 /* subtract the pc from here by asking for PC of this section*/
270 ieee_write_byte (abfd, ieee_variable_P_enum);
271 ieee_write_byte (abfd, (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE));
272 ieee_write_byte (abfd, ieee_function_minus_enum);
277 ieee_write_byte (abfd, 0);
281 while (term_count > 1)
283 ieee_write_byte (abfd, ieee_function_plus_enum);
290 /*****************************************************************************/
293 writes any integer into the buffer supplied and always takes 5 bytes
296 ieee_write_int5 (buffer, value)
300 buffer[0] = (bfd_byte) ieee_number_repeat_4_enum;
301 buffer[1] = (value >> 24) & 0xff;
302 buffer[2] = (value >> 16) & 0xff;
303 buffer[3] = (value >> 8) & 0xff;
304 buffer[4] = (value >> 0) & 0xff;
308 ieee_write_int5_out (abfd, value)
313 ieee_write_int5 (b, value);
314 if (bfd_write ((PTR) b, 1, 5, abfd) != 5)
319 parse_int (ieee, value_ptr)
320 common_header_type *ieee;
323 int value = this_byte (ieee);
325 if (value >= 0 && value <= 127)
331 else if (value >= 0x80 && value <= 0x88)
333 unsigned int count = value & 0xf;
338 result = (result << 8) | this_byte_and_next (ieee);
349 common_header_type *ieee;
353 *ok = parse_int (ieee, &x);
358 must_parse_int (ieee)
359 common_header_type *ieee;
362 BFD_ASSERT (parse_int (ieee, &result) == true);
370 ieee_symbol_index_type symbol;
375 reloc_howto_type abs32_howto
376 = HOWTO (1, 0, 2, 32, false, 0, complain_overflow_bitfield, 0, "abs32", true, 0xffffffff, 0xffffffff, false);
378 reloc_howto_type abs16_howto
379 = HOWTO (1, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "abs16", true, 0x0000ffff, 0x0000ffff, false);
382 reloc_howto_type abs8_howto
383 = HOWTO (1, 0, 0, 8, false, 0, complain_overflow_bitfield, 0, "abs8", true, 0x000000ff, 0x000000ff, false);
386 reloc_howto_type rel32_howto
387 = HOWTO (1, 0, 2, 32, true, 0, complain_overflow_signed, 0, "rel32", true, 0xffffffff,
391 reloc_howto_type rel16_howto
392 = HOWTO (1, 0, 1, 16, true, 0, complain_overflow_signed, 0, "rel16", true, 0x0000ffff, 0x0000ffff, false);
395 reloc_howto_type rel8_howto
396 = HOWTO (1, 0, 0, 8, true, 0, complain_overflow_signed, 0, "rel8", true, 0x000000ff, 0x000000ff, false);
399 static ieee_symbol_index_type NOSYMBOL =
404 parse_expression (ieee, value, symbol, pcrel, extra, section)
405 ieee_data_type *ieee;
407 ieee_symbol_index_type *symbol;
420 ieee_value_type stack[10];
422 /* The stack pointer always points to the next unused location */
423 #define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC;
424 #define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value;
425 ieee_value_type *sp = stack;
429 switch (this_byte (&(ieee->h)))
431 case ieee_variable_P_enum:
432 /* P variable, current program counter for section n */
435 next_byte (&(ieee->h));
437 section_n = must_parse_int (&(ieee->h));
438 PUSH (NOSYMBOL, &bfd_abs_section,
439 TOS.value = ieee->section_table[section_n]->vma +
440 ieee_per_section (ieee->section_table[section_n])->pc);
443 case ieee_variable_L_enum:
444 /* L variable address of section N */
445 next_byte (&(ieee->h));
446 PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
448 case ieee_variable_R_enum:
449 /* R variable, logical address of section module */
450 /* FIXME, this should be different to L */
451 next_byte (&(ieee->h));
452 PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
454 case ieee_variable_S_enum:
455 /* S variable, size in MAUS of section module */
456 next_byte (&(ieee->h));
459 ieee->section_table[must_parse_int (&(ieee->h))]->_raw_size);
461 case ieee_variable_I_enum:
462 case ieee_variable_X_enum:
463 /* Push the address of external variable n */
465 ieee_symbol_index_type sy;
466 next_byte (&(ieee->h));
467 sy.index = (int) (must_parse_int (&(ieee->h)));
470 PUSH (sy, &bfd_und_section, 0);
473 case ieee_function_minus_enum:
475 bfd_vma value1, value2;
476 asection *section1, *section_dummy;
477 ieee_symbol_index_type sy;
478 next_byte (&(ieee->h));
480 POP (sy, section1, value1);
481 POP (sy, section_dummy, value2);
482 PUSH (sy, section1 ? section1 : section_dummy, value1 - value2);
485 case ieee_function_plus_enum:
487 bfd_vma value1, value2;
490 ieee_symbol_index_type sy1;
491 ieee_symbol_index_type sy2;
492 next_byte (&(ieee->h));
494 POP (sy1, section1, value1);
495 POP (sy2, section2, value2);
496 PUSH (sy1.letter ? sy1 : sy2, section1 != &bfd_abs_section ? section1 : section2, value1 + value2);
502 BFD_ASSERT (this_byte (&(ieee->h)) < (int) ieee_variable_A_enum
503 || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum);
504 if (parse_int (&(ieee->h), &va))
506 PUSH (NOSYMBOL, &bfd_abs_section, va);
511 Thats all that we can understand. As far as I can see
512 there is a bug in the Microtec IEEE output which I'm
513 using to scan, whereby the comma operator is omitted
514 sometimes in an expression, giving expressions with too
515 many terms. We can tell if that's the case by ensuring
516 that sp == stack here. If not, then we've pushed
517 something too far, so we keep adding. */
519 while (sp != stack + 1)
522 ieee_symbol_index_type sy1;
523 POP (sy1, section1, *extra);
528 POP (*symbol, dummy, *value);
541 #define ieee_seek(abfd, offset) \
542 IEEE_DATA(abfd)->h.input_p = IEEE_DATA(abfd)->h.first_byte + offset
544 #define ieee_pos(abfd) IEEE_DATA(abfd)->h.input_p -IEEE_DATA(abfd)->h.first_byte
546 static unsigned int last_index;
547 static char last_type; /* is the index for an X or a D */
549 static ieee_symbol_type *
559 ieee_data_type *ieee;
560 ieee_symbol_type *last_symbol;
561 unsigned int *symbol_count;
562 ieee_symbol_type ***pptr;
563 unsigned int *max_index;
567 /* Need a new symbol */
568 unsigned int new_index = must_parse_int (&(ieee->h));
569 if (new_index != last_index || this_type != last_type)
571 ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd,
572 sizeof (ieee_symbol_type));
575 bfd_set_error (bfd_error_no_memory);
579 new_symbol->index = new_index;
580 last_index = new_index;
583 *pptr = &new_symbol->next;
584 if (new_index > *max_index)
586 *max_index = new_index;
588 last_type = this_type;
595 ieee_slurp_external_symbols (abfd)
598 ieee_data_type *ieee = IEEE_DATA (abfd);
599 file_ptr offset = ieee->w.r.external_part;
601 ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols;
602 ieee_symbol_type **prev_reference_ptr = &ieee->external_reference;
603 ieee_symbol_type *symbol = (ieee_symbol_type *) NULL;
604 unsigned int symbol_count = 0;
606 last_index = 0xffffff;
607 ieee->symbol_table_full = true;
609 ieee_seek (abfd, offset);
613 switch (this_byte (&(ieee->h)))
616 next_byte (&(ieee->h));
618 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
620 &ieee->external_symbol_max_index, 'D');
624 symbol->symbol.the_bfd = abfd;
625 symbol->symbol.name = read_id (&(ieee->h));
626 symbol->symbol.udata = (PTR) NULL;
627 symbol->symbol.flags = BSF_NO_FLAGS;
629 case ieee_external_symbol_enum:
630 next_byte (&(ieee->h));
632 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
634 &ieee->external_symbol_max_index, 'D');
638 BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
640 symbol->symbol.the_bfd = abfd;
641 symbol->symbol.name = read_id (&(ieee->h));
642 symbol->symbol.udata = (PTR) NULL;
643 symbol->symbol.flags = BSF_NO_FLAGS;
645 case ieee_attribute_record_enum >> 8:
647 unsigned int symbol_name_index;
648 unsigned int symbol_type_index;
649 unsigned int symbol_attribute_def;
651 next_byte (&(ieee->h)); /* Skip prefix */
652 next_byte (&(ieee->h));
653 symbol_name_index = must_parse_int (&(ieee->h));
654 symbol_type_index = must_parse_int (&(ieee->h));
655 symbol_attribute_def = must_parse_int (&(ieee->h));
656 switch (symbol_attribute_def)
659 /* Module misc; followed by two fields which describe the
660 current module block. The first fired is the type id
661 number, the second is the number of asn records
662 associated with the directive */
663 parse_int (&(ieee->h), &value);
664 parse_int (&(ieee->h), &value);
668 parse_int (&(ieee->h), &value);
673 case ieee_value_record_enum >> 8:
675 unsigned int symbol_name_index;
676 ieee_symbol_index_type symbol_ignore;
677 boolean pcrel_ignore;
679 next_byte (&(ieee->h));
680 next_byte (&(ieee->h));
682 symbol_name_index = must_parse_int (&(ieee->h));
683 parse_expression (ieee,
684 &symbol->symbol.value,
688 &symbol->symbol.section);
690 symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
694 case ieee_weak_external_reference_enum:
698 next_byte (&(ieee->h));
699 /* Throw away the external reference index */
700 (void) must_parse_int (&(ieee->h));
701 /* Fetch the default size if not resolved */
702 size = must_parse_int (&(ieee->h));
703 /* Fetch the defautlt value if available */
704 if (parse_int (&(ieee->h), &value) == false)
708 /* This turns into a common */
709 symbol->symbol.section = &bfd_com_section;
710 symbol->symbol.value = size;
714 case ieee_external_reference_enum:
715 next_byte (&(ieee->h));
717 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
719 &ieee->external_reference_max_index, 'X');
723 symbol->symbol.the_bfd = abfd;
724 symbol->symbol.name = read_id (&(ieee->h));
725 symbol->symbol.udata = (PTR) NULL;
726 symbol->symbol.section = &bfd_und_section;
727 symbol->symbol.value = (bfd_vma) 0;
728 symbol->symbol.flags = 0;
730 BFD_ASSERT (symbol->index >= ieee->external_reference_min_index);
738 if (ieee->external_symbol_max_index != 0)
740 ieee->external_symbol_count =
741 ieee->external_symbol_max_index -
742 ieee->external_symbol_min_index + 1;
746 ieee->external_symbol_count = 0;
749 if (ieee->external_reference_max_index != 0)
751 ieee->external_reference_count =
752 ieee->external_reference_max_index -
753 ieee->external_reference_min_index + 1;
757 ieee->external_reference_count = 0;
761 ieee->external_reference_count + ieee->external_symbol_count;
763 if (symbol_count != abfd->symcount)
765 /* There are gaps in the table -- */
766 ieee->symbol_table_full = false;
769 *prev_symbols_ptr = (ieee_symbol_type *) NULL;
770 *prev_reference_ptr = (ieee_symbol_type *) NULL;
776 ieee_slurp_symbol_table (abfd)
779 if (IEEE_DATA (abfd)->read_symbols == false)
781 if (! ieee_slurp_external_symbols (abfd))
783 IEEE_DATA (abfd)->read_symbols = true;
789 ieee_get_symtab_upper_bound (abfd)
792 if (! ieee_slurp_symbol_table (abfd))
795 return (abfd->symcount != 0) ?
796 (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0;
800 Move from our internal lists to the canon table, and insert in
804 extern bfd_target ieee_vec;
807 ieee_get_symtab (abfd, location)
811 ieee_symbol_type *symp;
812 static bfd dummy_bfd;
813 static asymbol empty_symbol =
814 /* the_bfd, name, value, attr, section */
815 {&dummy_bfd, " ieee empty", (symvalue) 0, BSF_DEBUGGING, &bfd_abs_section};
819 ieee_data_type *ieee = IEEE_DATA (abfd);
820 dummy_bfd.xvec = &ieee_vec;
821 if (! ieee_slurp_symbol_table (abfd))
824 if (ieee->symbol_table_full == false)
826 /* Arrgh - there are gaps in the table, run through and fill them */
827 /* up with pointers to a null place */
829 for (i = 0; i < abfd->symcount; i++)
831 location[i] = &empty_symbol;
835 ieee->external_symbol_base_offset = -ieee->external_symbol_min_index;
836 for (symp = IEEE_DATA (abfd)->external_symbols;
837 symp != (ieee_symbol_type *) NULL;
840 /* Place into table at correct index locations */
841 location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
844 /* The external refs are indexed in a bit */
845 ieee->external_reference_base_offset =
846 -ieee->external_reference_min_index + ieee->external_symbol_count;
848 for (symp = IEEE_DATA (abfd)->external_reference;
849 symp != (ieee_symbol_type *) NULL;
852 location[symp->index + ieee->external_reference_base_offset] =
859 location[abfd->symcount] = (asymbol *) NULL;
861 return abfd->symcount;
865 get_section_entry (abfd, ieee, index)
867 ieee_data_type *ieee;
870 if (ieee->section_table[index] == (asection *) NULL)
872 char *tmp = bfd_alloc (abfd, 11);
877 bfd_set_error (bfd_error_no_memory);
880 sprintf (tmp, " fsec%4d", index);
881 section = bfd_make_section (abfd, tmp);
882 ieee->section_table[index] = section;
883 section->flags = SEC_NO_FLAGS;
884 section->target_index = index;
885 ieee->section_table[index] = section;
887 return ieee->section_table[index];
891 ieee_slurp_sections (abfd)
894 ieee_data_type *ieee = IEEE_DATA (abfd);
895 file_ptr offset = ieee->w.r.section_part;
896 asection *section = (asection *) NULL;
901 bfd_byte section_type[3];
902 ieee_seek (abfd, offset);
905 switch (this_byte (&(ieee->h)))
907 case ieee_section_type_enum:
909 unsigned int section_index;
910 next_byte (&(ieee->h));
911 section_index = must_parse_int (&(ieee->h));
912 /* Fixme to be nice about a silly number of sections */
913 BFD_ASSERT (section_index < NSECTIONS);
915 section = get_section_entry (abfd, ieee, section_index);
917 section_type[0] = this_byte_and_next (&(ieee->h));
918 switch (section_type[0])
921 /* Normal attributes for absolute sections */
922 section_type[1] = this_byte (&(ieee->h));
923 section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
924 switch (section_type[1])
926 case 0xD3: /* AS Absolute section attributes */
927 next_byte (&(ieee->h));
928 section_type[2] = this_byte (&(ieee->h));
929 switch (section_type[2])
933 next_byte (&(ieee->h));
934 section->flags |= SEC_LOAD | SEC_CODE;
937 next_byte (&(ieee->h));
938 section->flags |= SEC_LOAD | SEC_DATA;
942 next_byte (&(ieee->h));
943 /* Normal rom data */
944 section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA;
951 case 0xC3: /* Named relocatable sections (type C) */
952 section_type[1] = this_byte (&(ieee->h));
953 section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
954 switch (section_type[1])
956 case 0xD0: /* Normal code (CP) */
957 next_byte (&(ieee->h));
958 section->flags |= SEC_LOAD | SEC_CODE;
960 case 0xC4: /* Normal data (CD) */
961 next_byte (&(ieee->h));
962 section->flags |= SEC_LOAD | SEC_DATA;
964 case 0xD2: /* Normal rom data (CR) */
965 next_byte (&(ieee->h));
966 section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA;
973 /* Read section name, use it if non empty. */
974 name = read_id (&ieee->h);
976 section->name = name;
978 /* Skip these fields, which we don't care about */
980 bfd_vma parent, brother, context;
981 parse_int (&(ieee->h), &parent);
982 parse_int (&(ieee->h), &brother);
983 parse_int (&(ieee->h), &context);
987 case ieee_section_alignment_enum:
989 unsigned int section_index;
992 next_byte (&(ieee->h));
993 section_index = must_parse_int (&ieee->h);
994 section = get_section_entry (abfd, ieee, section_index);
995 if (section_index > ieee->section_count)
997 ieee->section_count = section_index;
999 section->alignment_power =
1000 bfd_log2 (must_parse_int (&ieee->h));
1001 (void) parse_int (&(ieee->h), &value);
1004 case ieee_e2_first_byte_enum:
1006 ieee_record_enum_type t = (ieee_record_enum_type) (read_2bytes (&(ieee->h)));
1010 case ieee_section_size_enum:
1011 section = ieee->section_table[must_parse_int (&(ieee->h))];
1012 section->_raw_size = must_parse_int (&(ieee->h));
1014 case ieee_physical_region_size_enum:
1015 section = ieee->section_table[must_parse_int (&(ieee->h))];
1016 section->_raw_size = must_parse_int (&(ieee->h));
1018 case ieee_region_base_address_enum:
1019 section = ieee->section_table[must_parse_int (&(ieee->h))];
1020 section->vma = must_parse_int (&(ieee->h));
1022 case ieee_mau_size_enum:
1023 must_parse_int (&(ieee->h));
1024 must_parse_int (&(ieee->h));
1026 case ieee_m_value_enum:
1027 must_parse_int (&(ieee->h));
1028 must_parse_int (&(ieee->h));
1030 case ieee_section_base_address_enum:
1031 section = ieee->section_table[must_parse_int (&(ieee->h))];
1032 section->vma = must_parse_int (&(ieee->h));
1034 case ieee_section_offset_enum:
1035 (void) must_parse_int (&(ieee->h));
1036 (void) must_parse_int (&(ieee->h));
1051 /***********************************************************************
1056 ieee_archive_p (abfd)
1063 unsigned char buffer[512];
1065 file_ptr buffer_offset = 0;
1066 ieee_ar_data_type *save = abfd->tdata.ieee_ar_data;
1067 ieee_ar_data_type *ieee;
1068 abfd->tdata.ieee_ar_data = (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type));
1069 if (!abfd->tdata.ieee_ar_data)
1071 bfd_set_error (bfd_error_no_memory);
1074 ieee = IEEE_AR_DATA (abfd);
1076 /* FIXME: Check return value. I'm not sure whether it needs to read
1077 the entire buffer or not. */
1078 bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
1080 ieee->h.first_byte = buffer;
1081 ieee->h.input_p = buffer;
1083 ieee->h.abfd = abfd;
1085 if (this_byte (&(ieee->h)) != Module_Beginning)
1087 abfd->tdata.ieee_ar_data = save;
1088 return (bfd_target *) NULL;
1091 next_byte (&(ieee->h));
1092 library = read_id (&(ieee->h));
1093 if (strcmp (library, "LIBRARY") != 0)
1095 bfd_release (abfd, ieee);
1096 abfd->tdata.ieee_ar_data = save;
1097 return (bfd_target *) NULL;
1099 /* Throw away the filename */
1100 read_id (&(ieee->h));
1101 /* This must be an IEEE archive, so we'll buy some space to do
1104 if (!obstack_begin (&ob, 128))
1106 bfd_set_error (bfd_error_no_memory);
1107 return (bfd_target *) NULL;
1110 ieee->element_count = 0;
1111 ieee->element_index = 0;
1113 next_byte (&(ieee->h)); /* Drop the ad part */
1114 must_parse_int (&(ieee->h)); /* And the two dummy numbers */
1115 must_parse_int (&(ieee->h));
1118 /* Read the index of the BB table */
1121 ieee_ar_obstack_type t;
1122 int rec = read_2bytes (&(ieee->h));
1123 if (rec == (int) ieee_assign_value_to_variable_enum)
1125 must_parse_int (&(ieee->h));
1126 t.file_offset = must_parse_int (&(ieee->h));
1127 t.abfd = (bfd *) NULL;
1128 ieee->element_count++;
1130 obstack_grow (&ob, (PTR) & t, sizeof (t));
1132 /* Make sure that we don't go over the end of the buffer */
1134 if (ieee_pos (abfd) > sizeof (buffer) / 2)
1136 /* Past half way, reseek and reprime */
1137 buffer_offset += ieee_pos (abfd);
1138 if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0)
1140 /* FIXME: Check return value. I'm not sure whether it
1141 needs to read the entire buffer or not. */
1142 bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
1143 ieee->h.first_byte = buffer;
1144 ieee->h.input_p = buffer;
1151 ieee->elements = (ieee_ar_obstack_type *) obstack_finish (&ob);
1152 if (!ieee->elements)
1154 bfd_set_error (bfd_error_no_memory);
1155 return (bfd_target *) NULL;
1158 /* Now scan the area again, and replace BB offsets with file */
1161 for (i = 2; i < ieee->element_count; i++)
1163 if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0)
1165 /* FIXME: Check return value. I'm not sure whether it needs to
1166 read the entire buffer or not. */
1167 bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
1168 ieee->h.first_byte = buffer;
1169 ieee->h.input_p = buffer;
1171 next_byte (&(ieee->h)); /* Drop F8 */
1172 next_byte (&(ieee->h)); /* Drop 14 */
1173 must_parse_int (&(ieee->h)); /* Drop size of block */
1174 if (must_parse_int (&(ieee->h)) != 0)
1176 /* This object has been deleted */
1177 ieee->elements[i].file_offset = 0;
1181 ieee->elements[i].file_offset = must_parse_int (&(ieee->h));
1185 /* abfd->has_armap = ;*/
1190 ieee_mkobject (abfd)
1193 abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, sizeof (ieee_data_type));
1194 return abfd->tdata.ieee_data ? true : false;
1198 ieee_object_p (abfd)
1203 ieee_data_type *ieee;
1204 unsigned char buffer[300];
1205 ieee_data_type *save = IEEE_DATA (abfd);
1207 abfd->tdata.ieee_data = 0;
1208 ieee_mkobject (abfd);
1210 ieee = IEEE_DATA (abfd);
1211 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1213 /* Read the first few bytes in to see if it makes sense */
1214 /* FIXME: Check return value. I'm not sure whether it needs to read
1215 the entire buffer or not. */
1216 bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
1218 ieee->h.input_p = buffer;
1219 if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
1222 ieee->read_symbols = false;
1223 ieee->read_data = false;
1224 ieee->section_count = 0;
1225 ieee->external_symbol_max_index = 0;
1226 ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
1227 ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
1228 ieee->external_reference_max_index = 0;
1229 ieee->h.abfd = abfd;
1230 memset ((PTR) ieee->section_table, 0, sizeof (ieee->section_table));
1232 processor = ieee->mb.processor = read_id (&(ieee->h));
1233 if (strcmp (processor, "LIBRARY") == 0)
1235 ieee->mb.module_name = read_id (&(ieee->h));
1236 if (abfd->filename == (CONST char *) NULL)
1238 abfd->filename = ieee->mb.module_name;
1240 /* Determine the architecture and machine type of the object file.
1243 bfd_arch_info_type *arch = bfd_scan_arch (processor);
1246 abfd->arch_info = arch;
1249 if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
1253 next_byte (&(ieee->h));
1255 if (parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau) == false)
1259 if (parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address) == false)
1264 /* If there is a byte order info, take it */
1265 if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum ||
1266 this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
1267 next_byte (&(ieee->h));
1269 for (part = 0; part < N_W_VARIABLES; part++)
1272 if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
1276 if (this_byte_and_next (&(ieee->h)) != part)
1281 ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
1288 abfd->flags = HAS_SYMS;
1289 /* By now we know that this is a real IEEE file, we're going to read
1290 the whole thing into memory so that we can run up and down it
1291 quickly. We can work out how big the file is from the trailer
1294 IEEE_DATA (abfd)->h.first_byte = (unsigned char *) bfd_alloc (ieee->h.abfd, ieee->w.r.me_record
1296 if (!IEEE_DATA (abfd)->h.first_byte)
1298 bfd_set_error (bfd_error_no_memory);
1301 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1303 /* FIXME: Check return value. I'm not sure whether it needs to read
1304 the entire buffer or not. */
1305 bfd_read ((PTR) (IEEE_DATA (abfd)->h.first_byte), 1, ieee->w.r.me_record + 50, abfd);
1307 ieee_slurp_sections (abfd);
1310 (void) bfd_release (abfd, ieee);
1311 abfd->tdata.ieee_data = save;
1312 return (bfd_target *) NULL;
1316 ieee_get_symbol_info (ignore_abfd, symbol, ret)
1321 bfd_symbol_info (symbol, ret);
1322 if (symbol->name[0] == ' ')
1323 ret->name = "* empty table entry ";
1324 if (!symbol->section)
1325 ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
1329 ieee_print_symbol (ignore_abfd, afile, symbol, how)
1333 bfd_print_symbol_type how;
1335 FILE *file = (FILE *) afile;
1339 case bfd_print_symbol_name:
1340 fprintf (file, "%s", symbol->name);
1342 case bfd_print_symbol_more:
1344 fprintf (file, "%4x %2x", aout_symbol (symbol)->desc & 0xffff,
1345 aout_symbol (symbol)->other & 0xff);
1349 case bfd_print_symbol_all:
1351 CONST char *section_name = symbol->section == (asection *) NULL ?
1352 (CONST char *) "*abs" : symbol->section->name;
1353 if (symbol->name[0] == ' ')
1355 fprintf (file, "* empty table entry ");
1359 bfd_print_symbol_vandf ((PTR) file, symbol);
1361 fprintf (file, " %-5s %04x %02x %s",
1363 (unsigned) ieee_symbol (symbol)->index,
1365 aout_symbol(symbol)->desc & 0xffff,
1366 aout_symbol(symbol)->other & 0xff,*/
1375 do_one (ieee, current_map, location_ptr, s)
1376 ieee_data_type *ieee;
1377 ieee_per_section_type *current_map;
1378 unsigned char *location_ptr;
1381 switch (this_byte (&(ieee->h)))
1383 case ieee_load_constant_bytes_enum:
1385 unsigned int number_of_maus;
1387 next_byte (&(ieee->h));
1388 number_of_maus = must_parse_int (&(ieee->h));
1390 for (i = 0; i < number_of_maus; i++)
1392 location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1393 next_byte (&(ieee->h));
1398 case ieee_load_with_relocation_enum:
1400 boolean loop = true;
1401 next_byte (&(ieee->h));
1404 switch (this_byte (&(ieee->h)))
1406 case ieee_variable_R_enum:
1408 case ieee_function_signed_open_b_enum:
1409 case ieee_function_unsigned_open_b_enum:
1410 case ieee_function_either_open_b_enum:
1412 unsigned int extra = 4;
1413 boolean pcrel = false;
1415 ieee_reloc_type *r =
1416 (ieee_reloc_type *) bfd_alloc (ieee->h.abfd,
1417 sizeof (ieee_reloc_type));
1420 bfd_set_error (bfd_error_no_memory);
1424 *(current_map->reloc_tail_ptr) = r;
1425 current_map->reloc_tail_ptr = &r->next;
1426 r->next = (ieee_reloc_type *) NULL;
1427 next_byte (&(ieee->h));
1429 r->relent.sym_ptr_ptr = 0;
1430 parse_expression (ieee,
1433 &pcrel, &extra, §ion);
1434 r->relent.address = current_map->pc;
1436 if (r->relent.sym_ptr_ptr == 0)
1438 r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
1441 if (this_byte (&(ieee->h)) == (int) ieee_comma)
1443 next_byte (&(ieee->h));
1444 /* Fetch number of bytes to pad */
1445 extra = must_parse_int (&(ieee->h));
1448 switch (this_byte (&(ieee->h)))
1450 case ieee_function_signed_close_b_enum:
1451 next_byte (&(ieee->h));
1453 case ieee_function_unsigned_close_b_enum:
1454 next_byte (&(ieee->h));
1456 case ieee_function_either_close_b_enum:
1457 next_byte (&(ieee->h));
1462 /* Build a relocation entry for this type */
1463 /* If pc rel then stick -ve pc into instruction
1464 and take out of reloc ..
1466 I've changed this. It's all too
1467 complicated. I keep 0 in the
1478 #if KEEPMINUSPCININST
1479 bfd_put_32 (ieee->h.abfd, -current_map->pc, location_ptr +
1481 r->relent.howto = &rel32_howto;
1485 bfd_put_32 (ieee->h.abfd, 0, location_ptr +
1487 r->relent.howto = &rel32_howto;
1492 bfd_put_32 (ieee->h.abfd, 0, location_ptr +
1494 r->relent.howto = &abs32_howto;
1496 current_map->pc += 4;
1501 #if KEEPMINUSPCININST
1502 bfd_put_16 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
1503 r->relent.addend -= current_map->pc;
1504 r->relent.howto = &rel16_howto;
1507 bfd_put_16 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1508 r->relent.howto = &rel16_howto;
1514 bfd_put_16 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1515 r->relent.howto = &abs16_howto;
1517 current_map->pc += 2;
1522 #if KEEPMINUSPCININST
1523 bfd_put_8 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
1524 r->relent.addend -= current_map->pc;
1525 r->relent.howto = &rel8_howto;
1527 bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1528 r->relent.howto = &rel8_howto;
1533 bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1534 r->relent.howto = &abs8_howto;
1536 current_map->pc += 1;
1548 if (parse_int (&(ieee->h), &this_size) == true)
1551 for (i = 0; i < this_size; i++)
1553 location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1554 next_byte (&(ieee->h));
1569 /* Read in all the section data and relocation stuff too */
1571 ieee_slurp_section_data (abfd)
1574 bfd_byte *location_ptr = (bfd_byte *) NULL;
1575 ieee_data_type *ieee = IEEE_DATA (abfd);
1576 unsigned int section_number;
1578 ieee_per_section_type *current_map = (ieee_per_section_type *) NULL;
1580 /* Seek to the start of the data area */
1581 if (ieee->read_data == true)
1583 ieee->read_data = true;
1584 ieee_seek (abfd, ieee->w.r.data_part);
1586 /* Allocate enough space for all the section contents */
1588 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1590 ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd;
1591 per->data = (bfd_byte *) bfd_alloc (ieee->h.abfd, s->_raw_size);
1594 bfd_set_error (bfd_error_no_memory);
1598 per->reloc_tail_ptr =
1599 (ieee_reloc_type **) & (s->relocation);
1604 switch (this_byte (&(ieee->h)))
1606 /* IF we see anything strange then quit */
1610 case ieee_set_current_section_enum:
1611 next_byte (&(ieee->h));
1612 section_number = must_parse_int (&(ieee->h));
1613 s = ieee->section_table[section_number];
1614 current_map = (ieee_per_section_type *) s->used_by_bfd;
1615 location_ptr = current_map->data - s->vma;
1616 /* The document I have says that Microtec's compilers reset */
1617 /* this after a sec section, even though the standard says not */
1619 current_map->pc = s->vma;
1622 case ieee_e2_first_byte_enum:
1623 next_byte (&(ieee->h));
1624 switch (this_byte (&(ieee->h)))
1626 case ieee_set_current_pc_enum & 0xff:
1629 ieee_symbol_index_type symbol;
1632 next_byte (&(ieee->h));
1633 must_parse_int (&(ieee->h)); /* Thow away section #*/
1634 parse_expression (ieee, &value,
1638 current_map->pc = value;
1639 BFD_ASSERT ((unsigned) (value - s->vma) <= s->_raw_size);
1643 case ieee_value_starting_address_enum & 0xff:
1644 /* We've got to the end of the data now - */
1651 case ieee_repeat_data_enum:
1653 /* Repeat the following LD or LR n times - we do this by
1654 remembering the stream pointer before running it and
1655 resetting it and running it n times. We special case
1656 the repetition of a repeat_data/load_constant
1659 unsigned int iterations;
1660 unsigned char *start;
1661 next_byte (&(ieee->h));
1662 iterations = must_parse_int (&(ieee->h));
1663 start = ieee->h.input_p;
1664 if (start[0] == (int) ieee_load_constant_bytes_enum &&
1667 while (iterations != 0)
1669 location_ptr[current_map->pc++] = start[2];
1672 next_byte (&(ieee->h));
1673 next_byte (&(ieee->h));
1674 next_byte (&(ieee->h));
1678 while (iterations != 0)
1680 ieee->h.input_p = start;
1681 if (!do_one (ieee, current_map, location_ptr, s))
1688 case ieee_load_constant_bytes_enum:
1689 case ieee_load_with_relocation_enum:
1691 if (!do_one (ieee, current_map, location_ptr, s))
1699 ieee_new_section_hook (abfd, newsect)
1703 newsect->used_by_bfd = (PTR)
1704 bfd_alloc (abfd, sizeof (ieee_per_section_type));
1705 if (!newsect->used_by_bfd)
1707 bfd_set_error (bfd_error_no_memory);
1710 ieee_per_section (newsect)->data = (bfd_byte *) NULL;
1711 ieee_per_section (newsect)->section = newsect;
1716 ieee_get_reloc_upper_bound (abfd, asect)
1720 if (! ieee_slurp_section_data (abfd))
1722 return (asect->reloc_count + 1) * sizeof (arelent *);
1726 ieee_get_section_contents (abfd, section, location, offset, count)
1731 bfd_size_type count;
1733 ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
1734 ieee_slurp_section_data (abfd);
1735 (void) memcpy ((PTR) location, (PTR) (p->data + offset), (unsigned) count);
1740 ieee_canonicalize_reloc (abfd, section, relptr, symbols)
1746 /* ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
1747 ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
1748 ieee_data_type *ieee = IEEE_DATA (abfd);
1750 while (src != (ieee_reloc_type *) NULL)
1752 /* Work out which symbol to attach it this reloc to */
1753 switch (src->symbol.letter)
1756 src->relent.sym_ptr_ptr =
1757 symbols + src->symbol.index + ieee->external_reference_base_offset;
1760 src->relent.sym_ptr_ptr =
1761 src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
1767 *relptr++ = &src->relent;
1770 *relptr = (arelent *) NULL;
1771 return section->reloc_count;
1779 arelent *a = *((arelent **) ap);
1780 arelent *b = *((arelent **) bp);
1781 return a->address - b->address;
1785 Write the section headers
1789 ieee_write_section_part (abfd)
1792 ieee_data_type *ieee = IEEE_DATA (abfd);
1794 ieee->w.r.section_part = bfd_tell (abfd);
1795 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1797 if (s != &bfd_abs_section)
1799 ieee_write_byte (abfd, ieee_section_type_enum);
1800 ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
1802 if (abfd->flags & EXEC_P)
1804 /* This image is executable, so output absolute sections */
1805 ieee_write_byte (abfd, ieee_variable_A_enum);
1806 ieee_write_byte (abfd, ieee_variable_S_enum);
1810 ieee_write_byte (abfd, ieee_variable_C_enum);
1813 switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM))
1815 case SEC_CODE | SEC_LOAD:
1817 ieee_write_byte (abfd, ieee_variable_P_enum);
1821 ieee_write_byte (abfd, ieee_variable_D_enum);
1824 case SEC_ROM | SEC_DATA:
1825 case SEC_ROM | SEC_LOAD:
1826 case SEC_ROM | SEC_DATA | SEC_LOAD:
1828 ieee_write_byte (abfd, ieee_variable_R_enum);
1832 ieee_write_id (abfd, s->name);
1834 ieee_write_int (abfd, 0); /* Parent */
1835 ieee_write_int (abfd, 0); /* Brother */
1836 ieee_write_int (abfd, 0); /* Context */
1839 ieee_write_byte (abfd, ieee_section_alignment_enum);
1840 ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
1841 ieee_write_int (abfd, 1 << s->alignment_power);
1844 ieee_write_2bytes (abfd, ieee_section_size_enum);
1845 ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
1846 ieee_write_int (abfd, s->_raw_size);
1847 if (abfd->flags & EXEC_P)
1849 /* Relocateable sections don't have asl records */
1851 ieee_write_2bytes (abfd, ieee_section_base_address_enum);
1852 ieee_write_byte (abfd,
1853 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
1854 ieee_write_int (abfd, s->vma);
1863 do_with_relocs (abfd, s)
1867 unsigned int relocs_to_go = s->reloc_count;
1869 bfd_byte *stream = ieee_per_section (s)->data;
1870 arelent **p = s->orelocation;
1872 bfd_size_type current_byte_index = 0;
1874 qsort (s->orelocation,
1876 sizeof (arelent **),
1879 /* Output the section preheader */
1880 ieee_write_byte (abfd, ieee_set_current_section_enum);
1881 ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
1883 ieee_write_twobyte (abfd, ieee_set_current_pc_enum);
1884 ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
1885 ieee_write_expression (abfd, 0, s->symbol, 0, 0);
1887 if (relocs_to_go == 0)
1889 /* If there arn't any relocations then output the load constant byte
1890 opcode rather than the load with relocation opcode */
1892 while (current_byte_index < s->_raw_size)
1895 unsigned int MAXRUN = 32;
1897 if (run > s->_raw_size - current_byte_index)
1899 run = s->_raw_size - current_byte_index;
1904 ieee_write_byte (abfd, ieee_load_constant_bytes_enum);
1905 /* Output a stream of bytes */
1906 ieee_write_int (abfd, run);
1907 if (bfd_write ((PTR) (stream + current_byte_index),
1913 current_byte_index += run;
1919 ieee_write_byte (abfd, ieee_load_with_relocation_enum);
1922 /* Output the data stream as the longest sequence of bytes
1923 possible, allowing for the a reasonable packet size and
1924 relocation stuffs */
1926 if ((PTR) stream == (PTR) NULL)
1928 /* Outputting a section without data, fill it up */
1929 stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size));
1932 bfd_set_error (bfd_error_no_memory);
1935 memset ((PTR) stream, 0, s->_raw_size);
1937 while (current_byte_index < s->_raw_size)
1940 unsigned int MAXRUN = 32;
1943 run = (*p)->address - current_byte_index;
1949 if (run > s->_raw_size - current_byte_index)
1951 run = s->_raw_size - current_byte_index;
1956 /* Output a stream of bytes */
1957 ieee_write_int (abfd, run);
1958 if (bfd_write ((PTR) (stream + current_byte_index),
1964 current_byte_index += run;
1966 /* Output any relocations here */
1967 if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
1969 while (relocs_to_go && (*p) && (*p)->address == current_byte_index)
1976 if (r->howto->pc_relative)
1978 r->addend += current_byte_index;
1982 switch (r->howto->size)
1986 ov = bfd_get_32 (abfd,
1987 stream + current_byte_index);
1988 current_byte_index += 4;
1991 ov = bfd_get_16 (abfd,
1992 stream + current_byte_index);
1993 current_byte_index += 2;
1996 ov = bfd_get_8 (abfd,
1997 stream + current_byte_index);
1998 current_byte_index++;
2004 ieee_write_byte (abfd, ieee_function_either_open_b_enum);
2007 if (r->sym_ptr_ptr != (asymbol **) NULL)
2009 ieee_write_expression (abfd, r->addend + ov,
2011 r->howto->pc_relative, s->index);
2015 ieee_write_expression (abfd, r->addend + ov,
2017 r->howto->pc_relative, s->index);
2020 if (1 || r->howto->size != 2)
2022 ieee_write_byte (abfd, ieee_comma);
2023 ieee_write_int (abfd, 1 << r->howto->size);
2025 ieee_write_byte (abfd,
2026 ieee_function_either_close_b_enum);
2038 /* If there are no relocations in the output section then we can
2039 be clever about how we write. We block items up into a max of 127
2043 do_as_repeat (abfd, s)
2049 ieee_write_byte (abfd, ieee_set_current_section_enum);
2050 ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
2051 ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8);
2052 ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff);
2053 ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
2054 ieee_write_int (abfd, s->vma);
2056 ieee_write_byte (abfd, ieee_repeat_data_enum);
2057 ieee_write_int (abfd, s->_raw_size);
2058 ieee_write_byte (abfd, ieee_load_constant_bytes_enum);
2059 ieee_write_byte (abfd, 1);
2060 ieee_write_byte (abfd, 0);
2065 do_without_relocs (abfd, s)
2069 bfd_byte *stream = ieee_per_section (s)->data;
2071 if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
2073 do_as_repeat (abfd, s);
2078 for (i = 0; i < s->_raw_size; i++)
2082 do_with_relocs (abfd, s);
2086 do_as_repeat (abfd, s);
2092 static unsigned char *output_ptr_start;
2093 static unsigned char *output_ptr;
2094 static unsigned char *output_ptr_end;
2095 static unsigned char *input_ptr_start;
2096 static unsigned char *input_ptr;
2097 static unsigned char *input_ptr_end;
2098 static bfd *input_bfd;
2099 static bfd *output_bfd;
2100 static int output_buffer;
2105 /* FIXME: Check return value. I'm not sure whether it needs to read
2106 the entire buffer or not. */
2107 bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
2108 input_ptr = input_ptr_start;
2113 if (bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start,
2115 != output_ptr - output_ptr_start)
2117 output_ptr = output_ptr_start;
2121 #define THIS() ( *input_ptr )
2122 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
2123 #define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); }
2129 if (value >= 0 && value <= 127)
2135 unsigned int length;
2136 /* How many significant bytes ? */
2137 /* FIXME FOR LONGER INTS */
2138 if (value & 0xff000000)
2142 else if (value & 0x00ff0000)
2146 else if (value & 0x0000ff00)
2153 OUT ((int) ieee_number_repeat_start_enum + length);
2172 int length = THIS ();
2184 #define VAR(x) ((x | 0x80))
2199 value = (value << 8) | THIS ();
2201 value = (value << 8) | THIS ();
2203 value = (value << 8) | THIS ();
2211 value = (value << 8) | THIS ();
2213 value = (value << 8) | THIS ();
2221 value = (value << 8) | THIS ();
2238 /* Not a number, just bug out with the answer */
2239 write_int (*(--tos));
2249 int value = *(--tos);
2258 ieee_data_type *ieee;
2261 section_number = THIS ();
2264 ieee = IEEE_DATA (input_bfd);
2265 s = ieee->section_table[section_number];
2266 if (s->output_section)
2268 value = s->output_section->vma;
2274 value += s->output_offset;
2282 write_int (*(--tos));
2292 /* Drop the int in the buffer, and copy a null into the gap, which we
2293 will overwrite later */
2295 struct output_buffer_struct
2297 unsigned char *ptrp;
2303 struct output_buffer_struct *buf;
2305 if (buf->buffer == output_buffer)
2307 /* Still a chance to output the size */
2308 int value = output_ptr - buf->ptrp + 3;
2309 buf->ptrp[0] = value >> 24;
2310 buf->ptrp[1] = value >> 16;
2311 buf->ptrp[2] = value >> 8;
2312 buf->ptrp[3] = value >> 0;
2318 struct output_buffer_struct *buf;
2344 buf->ptrp = output_ptr;
2345 buf->buffer = output_buffer;
2385 #define ID copy_id()
2386 #define INT copy_int()
2387 #define EXP copy_expression()
2388 static void copy_till_end ();
2389 #define INTn(q) copy_int()
2390 #define EXPn(q) copy_expression()
2429 EXPn (instruction address);
2463 EXPn (external function);
2473 INTn (locked register);
2496 /* Attribute record */
2554 static void block ();
2566 /* Unique typedefs for module */
2567 /* GLobal typedefs */
2568 /* High level module scope beginning */
2570 struct output_buffer_struct ob;
2585 /* Global function */
2587 struct output_buffer_struct ob;
2601 EXPn (size of block);
2607 /* File name for source line numbers */
2609 struct output_buffer_struct ob;
2629 /* Local function */
2631 struct output_buffer_struct ob;
2649 /* Assembler module scope beginning -*/
2651 struct output_buffer_struct ob;
2677 struct output_buffer_struct ob;
2684 INTn (section index);
2692 EXPn (Size in Maus);
2747 moves all the debug information from the source bfd to the output
2748 bfd, and relocates any expressions it finds
2752 relocate_debug (output, input)
2758 unsigned char input_buffer[IBS];
2760 input_ptr_start = input_ptr = input_buffer;
2761 input_ptr_end = input_buffer + IBS;
2763 /* FIXME: Check return value. I'm not sure whether it needs to read
2764 the entire buffer or not. */
2765 bfd_read ((PTR) input_ptr_start, 1, IBS, input);
2770 During linking, we we told about the bfds which made up our
2771 contents, we have a list of them. They will still be open, so go to
2772 the debug info in each, and copy it out, relocating it as we go.
2776 ieee_write_debug_part (abfd)
2779 ieee_data_type *ieee = IEEE_DATA (abfd);
2780 bfd_chain_type *chain = ieee->chain_root;
2781 unsigned char output_buffer[OBS];
2782 boolean some_debug = false;
2783 file_ptr here = bfd_tell (abfd);
2785 output_ptr_start = output_ptr = output_buffer;
2786 output_ptr_end = output_buffer + OBS;
2787 output_ptr = output_buffer;
2790 if (chain == (bfd_chain_type *) NULL)
2793 /* There is no debug info, so we'll fake some up */
2794 CONST static char fake[] =
2796 0xf8, 0xa, 0, 5, 't', 't', 't', 't', 't', 0, 2, 3,
2797 '1', '.', '1', 0x82, 1991 >> 8, 1991 & 0xff, 9, 20, 11, 07, 50};
2798 ieee->w.r.debug_information_part = 0;
2804 /* bfd_write(fake, 1, sizeof(fake), abfd);*/
2805 /* Now write a header for each section */
2808 asection *s = abfd->sections;
2811 if (s != abfd->abs_section)
2814 ieee_write_byte (abfd, 0xf8);
2815 ieee_write_byte (abfd, 0x0b);
2816 ieee_write_byte (abfd, 0);
2817 ieee_write_byte (abfd, 0);
2818 ieee_write_byte (abfd, 1);
2819 ieee_write_byte (abfd, i + IEEE_SECTION_NUMBER_BASE);
2820 ieee_write_expression (abfd, 0, s->symbol, 0, 0, 0);
2821 ieee_write_byte (abfd, 0);
2822 ieee_write_byte (abfd, 0xf9);
2823 ieee_write_expression (abfd, s->size,
2824 bfd_abs_section.symbol, 0, 0, 0);
2831 /* Close the scope */
2832 ieee_write_byte (abfd, 0xf9);
2838 while (chain != (bfd_chain_type *) NULL)
2840 bfd *entry = chain->this;
2841 ieee_data_type *entry_ieee = IEEE_DATA (entry);
2842 if (entry_ieee->w.r.debug_information_part)
2844 if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
2848 relocate_debug (abfd, entry);
2851 chain = chain->next;
2855 ieee->w.r.debug_information_part = here;
2859 ieee->w.r.debug_information_part = 0;
2866 /* write the data in an ieee way */
2868 ieee_write_data_part (abfd)
2872 ieee_data_type *ieee = IEEE_DATA (abfd);
2873 ieee->w.r.data_part = bfd_tell (abfd);
2874 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2876 /* Sort the reloc records so we can insert them in the correct
2878 if (s->reloc_count != 0)
2880 do_with_relocs (abfd, s);
2884 do_without_relocs (abfd, s);
2891 init_for_output (abfd)
2895 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2897 if (s->_raw_size != 0)
2899 ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size));
2900 if (!ieee_per_section (s)->data)
2902 bfd_set_error (bfd_error_no_memory);
2910 /** exec and core file sections */
2912 /* set section contents is complicated with IEEE since the format is
2913 * not a byte image, but a record stream.
2916 ieee_set_section_contents (abfd, section, location, offset, count)
2921 bfd_size_type count;
2923 if (ieee_per_section (section)->data == (bfd_byte *) NULL)
2925 if (!init_for_output (abfd))
2928 memcpy ((PTR) (ieee_per_section (section)->data + offset),
2930 (unsigned int) count);
2935 write the external symbols of a file, IEEE considers two sorts of
2936 external symbols, public, and referenced. It uses to internal forms
2937 to index them as well. When we write them out we turn their symbol
2938 values into indexes from the right base.
2941 ieee_write_external_part (abfd)
2945 ieee_data_type *ieee = IEEE_DATA (abfd);
2947 unsigned int reference_index = IEEE_REFERENCE_BASE;
2948 unsigned int public_index = IEEE_PUBLIC_BASE + 2;
2949 file_ptr here = bfd_tell (abfd);
2950 boolean hadone = false;
2951 if (abfd->outsymbols != (asymbol **) NULL)
2954 for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++)
2958 if (p->section == &bfd_und_section)
2960 /* This must be a symbol reference .. */
2961 ieee_write_byte (abfd, ieee_external_reference_enum);
2962 ieee_write_int (abfd, reference_index);
2963 ieee_write_id (abfd, p->name);
2964 p->value = reference_index;
2967 else if (bfd_is_com_section (p->section))
2969 /* This is a weak reference */
2970 ieee_write_byte (abfd, ieee_external_reference_enum);
2971 ieee_write_int (abfd, reference_index);
2972 ieee_write_id (abfd, p->name);
2973 ieee_write_byte (abfd, ieee_weak_external_reference_enum);
2974 ieee_write_int (abfd, reference_index);
2975 ieee_write_int (abfd, p->value);
2976 ieee_write_int (abfd, BFD_FORT_COMM_DEFAULT_VALUE);
2977 p->value = reference_index;
2980 else if (p->flags & BSF_GLOBAL)
2982 /* This must be a symbol definition */
2985 ieee_write_byte (abfd, ieee_external_symbol_enum);
2986 ieee_write_int (abfd, public_index);
2987 ieee_write_id (abfd, p->name);
2989 ieee_write_twobyte (abfd, ieee_attribute_record_enum);
2990 ieee_write_int (abfd, public_index);
2991 ieee_write_byte (abfd, 15); /* instruction address */
2992 ieee_write_byte (abfd, 19); /* static symbol */
2993 ieee_write_byte (abfd, 1); /* one of them */
2996 /* Write out the value */
2997 ieee_write_2bytes (abfd, ieee_value_record_enum);
2998 ieee_write_int (abfd, public_index);
2999 if (p->section != &bfd_abs_section)
3001 if (abfd->flags & EXEC_P)
3003 /* If fully linked, then output all symbols
3005 ieee_write_int (abfd,
3006 p->value + p->section->output_offset + p->section->output_section->vma);
3011 ieee_write_expression (abfd,
3012 p->value + p->section->output_offset,
3013 p->section->output_section->symbol
3019 ieee_write_expression (abfd,
3021 bfd_abs_section.symbol,
3024 p->value = public_index;
3029 /* This can happen - when there are gaps in the symbols read */
3030 /* from an input ieee file */
3035 ieee->w.r.external_part = here;
3040 static CONST unsigned char exten[] =
3043 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3 */
3044 0xf1, 0xce, 0x20, 0x00, 39, 2,/* keep symbol in original case */
3045 0xf1, 0xce, 0x20, 0x00, 38 /* set object type relocateable to x */
3048 static CONST unsigned char envi[] =
3052 /* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3055 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */
3057 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix */
3058 /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
3063 ieee_write_me_part (abfd)
3066 ieee_data_type *ieee = IEEE_DATA (abfd);
3067 ieee->w.r.trailer_part = bfd_tell (abfd);
3068 if (abfd->start_address)
3070 ieee->w.r.me_record = bfd_tell (abfd);
3071 ieee_write_2bytes (abfd, ieee_value_starting_address_enum);
3072 ieee_write_byte (abfd, ieee_function_either_open_b_enum);
3073 ieee_write_int (abfd, abfd->start_address);
3074 ieee_write_byte (abfd, ieee_function_either_close_b_enum);
3078 ieee->w.r.me_record = bfd_tell (abfd);
3080 ieee_write_byte (abfd, ieee_module_end_enum);
3085 ieee_write_object_contents (abfd)
3088 ieee_data_type *ieee = IEEE_DATA (abfd);
3091 /* Fast forward over the header area */
3092 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3094 ieee_write_byte (abfd, ieee_module_beginning_enum);
3096 ieee_write_id (abfd, bfd_printable_name (abfd));
3097 ieee_write_id (abfd, abfd->filename);
3099 /* Fast forward over the variable bits */
3100 ieee_write_byte (abfd, ieee_address_descriptor_enum);
3103 ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd)));
3104 /* MAU's per address */
3105 ieee_write_byte (abfd,
3106 (bfd_byte) (bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd)));
3108 old = bfd_tell (abfd);
3109 if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
3112 ieee->w.r.extension_record = bfd_tell (abfd);
3113 if (bfd_write ((char *) exten, 1, sizeof (exten), abfd) != sizeof (exten))
3115 if (abfd->flags & EXEC_P)
3116 ieee_write_byte (abfd, 0x1);/* Absolute */
3118 ieee_write_byte (abfd, 0x2);/* Relocateable */
3120 ieee->w.r.environmental_record = bfd_tell (abfd);
3121 if (bfd_write ((char *) envi, 1, sizeof (envi), abfd) != sizeof (envi))
3126 ieee_write_section_part (abfd);
3128 First write the symbols, this changes their values into table
3129 indeces so we cant use it after this point
3131 ieee_write_external_part (abfd);
3132 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3135 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3139 Write any debugs we have been told about
3141 ieee_write_debug_part (abfd);
3144 Can only write the data once the symbols have been written since
3145 the data contains relocation information which points to the
3148 ieee_write_data_part (abfd);
3152 At the end we put the end !
3154 ieee_write_me_part (abfd);
3157 /* Generate the header */
3158 if (bfd_seek (abfd, old, SEEK_SET) != 0)
3161 for (i = 0; i < N_W_VARIABLES; i++)
3163 ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum);
3164 ieee_write_byte (abfd, (bfd_byte) i);
3165 ieee_write_int5_out (abfd, ieee->w.offset[i]);
3172 /* Native-level interface to symbols. */
3174 /* We read the symbols into a buffer, which is discarded when this
3175 function exits. We read the strings into a buffer large enough to
3176 hold them all plus all the cached symbol entries. */
3179 ieee_make_empty_symbol (abfd)
3183 ieee_symbol_type *new =
3184 (ieee_symbol_type *) bfd_zmalloc (sizeof (ieee_symbol_type));
3187 bfd_set_error (bfd_error_no_error);
3190 new->symbol.the_bfd = abfd;
3191 return &new->symbol;
3195 ieee_openr_next_archived_file (arch, prev)
3199 ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
3200 /* take the next one from the arch state, or reset */
3201 if (prev == (bfd *) NULL)
3203 /* Reset the index - the first two entries are bogus*/
3204 ar->element_index = 2;
3208 ieee_ar_obstack_type *p = ar->elements + ar->element_index;
3209 ar->element_index++;
3210 if (ar->element_index <= ar->element_count)
3212 if (p->file_offset != (file_ptr) 0)
3214 if (p->abfd == (bfd *) NULL)
3216 p->abfd = _bfd_create_empty_archive_element_shell (arch);
3217 p->abfd->origin = p->file_offset;
3224 bfd_set_error (bfd_error_no_more_archived_files);
3225 return (bfd *) NULL;
3232 ieee_find_nearest_line (abfd,
3243 char **filename_ptr;
3244 char **functionname_ptr;
3251 ieee_generic_stat_arch_elt (abfd, buf)
3255 ieee_ar_data_type *ar = abfd->my_archive->tdata.ieee_ar_data;
3256 if (ar == (ieee_ar_data_type *) NULL)
3258 bfd_set_error (bfd_error_invalid_operation);
3264 buf->st_mode = 0666;
3265 return !ieee_object_p (abfd);
3270 ieee_sizeof_headers (abfd, x)
3279 ieee_bfd_debug_info_start (abfd)
3286 ieee_bfd_debug_info_end (abfd)
3293 /* Add this section to the list of sections we have debug info for, to
3294 be ready to output it at close time
3297 ieee_bfd_debug_info_accumulate (abfd, section)
3301 ieee_data_type *ieee = IEEE_DATA (section->owner);
3302 ieee_data_type *output_ieee = IEEE_DATA (abfd);
3303 /* can only accumulate data from other ieee bfds */
3304 if (section->owner->xvec != abfd->xvec)
3306 /* Only bother once per bfd */
3307 if (ieee->done_debug == true)
3309 ieee->done_debug = true;
3311 /* Don't bother if there is no debug info */
3312 if (ieee->w.r.debug_information_part == 0)
3318 bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type));
3321 bfd_set_error (bfd_error_no_memory);
3322 abort (); /* FIXME */
3324 n->this = section->owner;
3325 n->next = (bfd_chain_type *) NULL;
3327 if (output_ieee->chain_head)
3329 output_ieee->chain_head->next = n;
3333 output_ieee->chain_root = n;
3336 output_ieee->chain_head = n;
3342 #define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
3343 #define ieee_core_file_failing_signal (int (*)())bfd_0
3344 #define ieee_core_file_matches_executable_p ( FOO(boolean, (*),(bfd *, bfd *)))bfd_false
3345 #define ieee_slurp_armap bfd_true
3346 #define ieee_slurp_extended_name_table bfd_true
3347 #define ieee_truncate_arname (void (*)())bfd_nullvoidptr
3348 #define ieee_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
3349 #define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
3350 #define ieee_close_and_cleanup bfd_generic_close_and_cleanup
3351 #define ieee_set_arch_mach bfd_default_set_arch_mach
3352 #define ieee_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
3353 #define ieee_bfd_relax_section bfd_generic_relax_section
3354 #define ieee_bfd_reloc_type_lookup \
3355 ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
3356 #define ieee_bfd_make_debug_symbol \
3357 ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
3358 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3359 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
3360 #define ieee_bfd_final_link _bfd_generic_final_link
3361 #define ieee_bfd_copy_private_section_data \
3362 ((boolean (*) PARAMS ((bfd *, asection *, bfd *, asection *))) bfd_true)
3363 #define ieee_bfd_copy_private_bfd_data \
3364 ((boolean (*) PARAMS ((bfd *, bfd *))) bfd_true)
3365 #define ieee_bfd_is_local_label bfd_generic_is_local_label
3366 #define ieee_bfd_free_cached_info bfd_true
3369 bfd_target ieee_vec =
3372 bfd_target_ieee_flavour,
3373 true, /* target byte order */
3374 true, /* target headers byte order */
3375 (HAS_RELOC | EXEC_P | /* object flags */
3376 HAS_LINENO | HAS_DEBUG |
3377 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
3378 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
3379 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
3380 0, /* leading underscore */
3381 ' ', /* ar_pad_char */
3382 16, /* ar_max_namelen */
3383 1, /* minimum alignment */
3384 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3385 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3386 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
3387 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3388 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3389 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
3392 ieee_object_p, /* bfd_check_format */
3399 _bfd_generic_mkarchive,
3404 ieee_write_object_contents,
3405 _bfd_write_archive_contents,