daily update
[binutils.git] / bfd / ieee.c
blob6efd978e17c004f3f41a6d8638f97f2a8e2a2ca6
1 /* BFD back-end for ieee-695 objects.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 Written by Steve Chamberlain of Cygnus Support.
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
26 #define KEEPMINUSPCININST 0
28 /* IEEE 695 format is a stream of records, which we parse using a simple one-
29 token (which is one byte in this lexicon) lookahead recursive decent
30 parser. */
32 #include "sysdep.h"
33 #include "bfd.h"
34 #include "libbfd.h"
35 #include "ieee.h"
36 #include "libieee.h"
37 #include "safe-ctype.h"
39 struct output_buffer_struct
41 unsigned char *ptrp;
42 int buffer;
45 static unsigned char *output_ptr_start;
46 static unsigned char *output_ptr;
47 static unsigned char *output_ptr_end;
48 static unsigned char *input_ptr_start;
49 static unsigned char *input_ptr;
50 static unsigned char *input_ptr_end;
51 static bfd *input_bfd;
52 static bfd *output_bfd;
53 static int output_buffer;
56 static void block (void);
58 /* Functions for writing to ieee files in the strange way that the
59 standard requires. */
61 static bfd_boolean
62 ieee_write_byte (bfd *abfd, int barg)
64 bfd_byte byte;
66 byte = barg;
67 if (bfd_bwrite ((void *) &byte, (bfd_size_type) 1, abfd) != 1)
68 return FALSE;
69 return TRUE;
72 static bfd_boolean
73 ieee_write_2bytes (bfd *abfd, int bytes)
75 bfd_byte buffer[2];
77 buffer[0] = bytes >> 8;
78 buffer[1] = bytes & 0xff;
79 if (bfd_bwrite ((void *) buffer, (bfd_size_type) 2, abfd) != 2)
80 return FALSE;
81 return TRUE;
84 static bfd_boolean
85 ieee_write_int (bfd *abfd, bfd_vma value)
87 if (value <= 127)
89 if (! ieee_write_byte (abfd, (bfd_byte) value))
90 return FALSE;
92 else
94 unsigned int length;
96 /* How many significant bytes ? */
97 /* FIXME FOR LONGER INTS. */
98 if (value & 0xff000000)
99 length = 4;
100 else if (value & 0x00ff0000)
101 length = 3;
102 else if (value & 0x0000ff00)
103 length = 2;
104 else
105 length = 1;
107 if (! ieee_write_byte (abfd,
108 (bfd_byte) ((int) ieee_number_repeat_start_enum
109 + length)))
110 return FALSE;
111 switch (length)
113 case 4:
114 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24)))
115 return FALSE;
116 /* Fall through. */
117 case 3:
118 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16)))
119 return FALSE;
120 /* Fall through. */
121 case 2:
122 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8)))
123 return FALSE;
124 /* Fall through. */
125 case 1:
126 if (! ieee_write_byte (abfd, (bfd_byte) (value)))
127 return FALSE;
131 return TRUE;
134 static bfd_boolean
135 ieee_write_id (bfd *abfd, const char *id)
137 size_t length = strlen (id);
139 if (length <= 127)
141 if (! ieee_write_byte (abfd, (bfd_byte) length))
142 return FALSE;
144 else if (length < 255)
146 if (! ieee_write_byte (abfd, ieee_extension_length_1_enum)
147 || ! ieee_write_byte (abfd, (bfd_byte) length))
148 return FALSE;
150 else if (length < 65535)
152 if (! ieee_write_byte (abfd, ieee_extension_length_2_enum)
153 || ! ieee_write_2bytes (abfd, (int) length))
154 return FALSE;
156 else
158 (*_bfd_error_handler)
159 (_("%s: string too long (%d chars, max 65535)"),
160 bfd_get_filename (abfd), length);
161 bfd_set_error (bfd_error_invalid_operation);
162 return FALSE;
165 if (bfd_bwrite ((void *) id, (bfd_size_type) length, abfd) != length)
166 return FALSE;
167 return TRUE;
170 /* Functions for reading from ieee files in the strange way that the
171 standard requires. */
173 #define this_byte(ieee) *((ieee)->input_p)
174 #define next_byte(ieee) ((ieee)->input_p++)
175 #define this_byte_and_next(ieee) (*((ieee)->input_p++))
177 static unsigned short
178 read_2bytes (common_header_type *ieee)
180 unsigned char c1 = this_byte_and_next (ieee);
181 unsigned char c2 = this_byte_and_next (ieee);
183 return (c1 << 8) | c2;
186 static void
187 bfd_get_string (common_header_type *ieee, char *string, size_t length)
189 size_t i;
191 for (i = 0; i < length; i++)
192 string[i] = this_byte_and_next (ieee);
195 static char *
196 read_id (common_header_type *ieee)
198 size_t length;
199 char *string;
201 length = this_byte_and_next (ieee);
202 if (length <= 0x7f)
203 /* Simple string of length 0 to 127. */
206 else if (length == 0xde)
207 /* Length is next byte, allowing 0..255. */
208 length = this_byte_and_next (ieee);
210 else if (length == 0xdf)
212 /* Length is next two bytes, allowing 0..65535. */
213 length = this_byte_and_next (ieee);
214 length = (length * 256) + this_byte_and_next (ieee);
217 /* Buy memory and read string. */
218 string = bfd_alloc (ieee->abfd, (bfd_size_type) length + 1);
219 if (!string)
220 return NULL;
221 bfd_get_string (ieee, string, length);
222 string[length] = 0;
223 return string;
226 static bfd_boolean
227 ieee_write_expression (bfd *abfd,
228 bfd_vma value,
229 asymbol *symbol,
230 bfd_boolean pcrel,
231 unsigned int index)
233 unsigned int term_count = 0;
235 if (value != 0)
237 if (! ieee_write_int (abfd, value))
238 return FALSE;
239 term_count++;
242 /* Badly formatted binaries can have a missing symbol,
243 so test here to prevent a seg fault. */
244 if (symbol != NULL)
246 if (bfd_is_com_section (symbol->section)
247 || bfd_is_und_section (symbol->section))
249 /* Def of a common symbol. */
250 if (! ieee_write_byte (abfd, ieee_variable_X_enum)
251 || ! ieee_write_int (abfd, symbol->value))
252 return FALSE;
253 term_count ++;
255 else if (! bfd_is_abs_section (symbol->section))
257 /* Ref to defined symbol - */
258 if (symbol->flags & BSF_GLOBAL)
260 if (! ieee_write_byte (abfd, ieee_variable_I_enum)
261 || ! ieee_write_int (abfd, symbol->value))
262 return FALSE;
263 term_count++;
265 else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM))
267 /* This is a reference to a defined local symbol. We can
268 easily do a local as a section+offset. */
269 if (! ieee_write_byte (abfd, ieee_variable_R_enum)
270 || ! ieee_write_byte (abfd,
271 (bfd_byte) (symbol->section->index
272 + IEEE_SECTION_NUMBER_BASE)))
273 return FALSE;
275 term_count++;
276 if (symbol->value != 0)
278 if (! ieee_write_int (abfd, symbol->value))
279 return FALSE;
280 term_count++;
283 else
285 (*_bfd_error_handler)
286 (_("%s: unrecognized symbol `%s' flags 0x%x"),
287 bfd_get_filename (abfd), bfd_asymbol_name (symbol),
288 symbol->flags);
289 bfd_set_error (bfd_error_invalid_operation);
290 return FALSE;
295 if (pcrel)
297 /* Subtract the pc from here by asking for PC of this section. */
298 if (! ieee_write_byte (abfd, ieee_variable_P_enum)
299 || ! ieee_write_byte (abfd,
300 (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE))
301 || ! ieee_write_byte (abfd, ieee_function_minus_enum))
302 return FALSE;
305 /* Handle the degenerate case of a 0 address. */
306 if (term_count == 0)
307 if (! ieee_write_int (abfd, (bfd_vma) 0))
308 return FALSE;
310 while (term_count > 1)
312 if (! ieee_write_byte (abfd, ieee_function_plus_enum))
313 return FALSE;
314 term_count--;
317 return TRUE;
320 /* Writes any integer into the buffer supplied and always takes 5 bytes. */
322 static void
323 ieee_write_int5 (bfd_byte *buffer, bfd_vma value)
325 buffer[0] = (bfd_byte) ieee_number_repeat_4_enum;
326 buffer[1] = (value >> 24) & 0xff;
327 buffer[2] = (value >> 16) & 0xff;
328 buffer[3] = (value >> 8) & 0xff;
329 buffer[4] = (value >> 0) & 0xff;
332 static bfd_boolean
333 ieee_write_int5_out (bfd *abfd, bfd_vma value)
335 bfd_byte b[5];
337 ieee_write_int5 (b, value);
338 if (bfd_bwrite ((void *) b, (bfd_size_type) 5, abfd) != 5)
339 return FALSE;
340 return TRUE;
343 static bfd_boolean
344 parse_int (common_header_type *ieee, bfd_vma *value_ptr)
346 int value = this_byte (ieee);
347 int result;
349 if (value >= 0 && value <= 127)
351 *value_ptr = value;
352 next_byte (ieee);
353 return TRUE;
355 else if (value >= 0x80 && value <= 0x88)
357 unsigned int count = value & 0xf;
359 result = 0;
360 next_byte (ieee);
361 while (count)
363 result = (result << 8) | this_byte_and_next (ieee);
364 count--;
366 *value_ptr = result;
367 return TRUE;
369 return FALSE;
372 static int
373 parse_i (common_header_type *ieee, bfd_boolean *ok)
375 bfd_vma x = 0;
376 *ok = parse_int (ieee, &x);
377 return x;
380 static bfd_vma
381 must_parse_int (common_header_type *ieee)
383 bfd_vma result = 0;
384 BFD_ASSERT (parse_int (ieee, &result));
385 return result;
388 typedef struct
390 bfd_vma value;
391 asection *section;
392 ieee_symbol_index_type symbol;
393 } ieee_value_type;
396 #if KEEPMINUSPCININST
398 #define SRC_MASK(arg) arg
399 #define PCREL_OFFSET FALSE
401 #else
403 #define SRC_MASK(arg) 0
404 #define PCREL_OFFSET TRUE
406 #endif
408 static reloc_howto_type abs32_howto =
409 HOWTO (1,
413 FALSE,
415 complain_overflow_bitfield,
417 "abs32",
418 TRUE,
419 0xffffffff,
420 0xffffffff,
421 FALSE);
423 static reloc_howto_type abs16_howto =
424 HOWTO (1,
428 FALSE,
430 complain_overflow_bitfield,
432 "abs16",
433 TRUE,
434 0x0000ffff,
435 0x0000ffff,
436 FALSE);
438 static reloc_howto_type abs8_howto =
439 HOWTO (1,
443 FALSE,
445 complain_overflow_bitfield,
447 "abs8",
448 TRUE,
449 0x000000ff,
450 0x000000ff,
451 FALSE);
453 static reloc_howto_type rel32_howto =
454 HOWTO (1,
458 TRUE,
460 complain_overflow_signed,
462 "rel32",
463 TRUE,
464 SRC_MASK (0xffffffff),
465 0xffffffff,
466 PCREL_OFFSET);
468 static reloc_howto_type rel16_howto =
469 HOWTO (1,
473 TRUE,
475 complain_overflow_signed,
477 "rel16",
478 TRUE,
479 SRC_MASK (0x0000ffff),
480 0x0000ffff,
481 PCREL_OFFSET);
483 static reloc_howto_type rel8_howto =
484 HOWTO (1,
488 TRUE,
490 complain_overflow_signed,
492 "rel8",
493 TRUE,
494 SRC_MASK (0x000000ff),
495 0x000000ff,
496 PCREL_OFFSET);
498 static ieee_symbol_index_type NOSYMBOL = {0, 0};
500 static void
501 parse_expression (ieee_data_type *ieee,
502 bfd_vma *value,
503 ieee_symbol_index_type *symbol,
504 bfd_boolean *pcrel,
505 unsigned int *extra,
506 asection **section)
509 bfd_boolean loop = TRUE;
510 ieee_value_type stack[10];
511 ieee_value_type *sp = stack;
512 asection *dummy;
514 #define POS sp[1]
515 #define TOS sp[0]
516 #define NOS sp[-1]
517 #define INC sp++;
518 #define DEC sp--;
520 /* The stack pointer always points to the next unused location. */
521 #define PUSH(x,y,z) TOS.symbol = x; TOS.section = y; TOS.value = z; INC;
522 #define POP(x,y,z) DEC; x = TOS.symbol; y = TOS.section; z = TOS.value;
524 while (loop && ieee->h.input_p < ieee->h.last_byte)
526 switch (this_byte (&(ieee->h)))
528 case ieee_variable_P_enum:
529 /* P variable, current program counter for section n. */
531 int section_n;
533 next_byte (&(ieee->h));
534 *pcrel = TRUE;
535 section_n = must_parse_int (&(ieee->h));
536 PUSH (NOSYMBOL, bfd_abs_section_ptr, 0);
537 break;
539 case ieee_variable_L_enum:
540 /* L variable address of section N. */
541 next_byte (&(ieee->h));
542 PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
543 break;
544 case ieee_variable_R_enum:
545 /* R variable, logical address of section module. */
546 /* FIXME, this should be different to L. */
547 next_byte (&(ieee->h));
548 PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
549 break;
550 case ieee_variable_S_enum:
551 /* S variable, size in MAUS of section module. */
552 next_byte (&(ieee->h));
553 PUSH (NOSYMBOL,
555 ieee->section_table[must_parse_int (&(ieee->h))]->size);
556 break;
557 case ieee_variable_I_enum:
558 /* Push the address of variable n. */
560 ieee_symbol_index_type sy;
562 next_byte (&(ieee->h));
563 sy.index = (int) must_parse_int (&(ieee->h));
564 sy.letter = 'I';
566 PUSH (sy, bfd_abs_section_ptr, 0);
568 break;
569 case ieee_variable_X_enum:
570 /* Push the address of external variable n. */
572 ieee_symbol_index_type sy;
574 next_byte (&(ieee->h));
575 sy.index = (int) (must_parse_int (&(ieee->h)));
576 sy.letter = 'X';
578 PUSH (sy, bfd_und_section_ptr, 0);
580 break;
581 case ieee_function_minus_enum:
583 bfd_vma value1, value2;
584 asection *section1, *section_dummy;
585 ieee_symbol_index_type sy;
587 next_byte (&(ieee->h));
589 POP (sy, section1, value1);
590 POP (sy, section_dummy, value2);
591 PUSH (sy, section1 ? section1 : section_dummy, value2 - value1);
593 break;
594 case ieee_function_plus_enum:
596 bfd_vma value1, value2;
597 asection *section1;
598 asection *section2;
599 ieee_symbol_index_type sy1;
600 ieee_symbol_index_type sy2;
602 next_byte (&(ieee->h));
604 POP (sy1, section1, value1);
605 POP (sy2, section2, value2);
606 PUSH (sy1.letter ? sy1 : sy2,
607 bfd_is_abs_section (section1) ? section2 : section1,
608 value1 + value2);
610 break;
611 default:
613 bfd_vma va;
615 BFD_ASSERT (this_byte (&(ieee->h)) < (int) ieee_variable_A_enum
616 || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum);
617 if (parse_int (&(ieee->h), &va))
619 PUSH (NOSYMBOL, bfd_abs_section_ptr, va);
621 else
622 /* Thats all that we can understand. */
623 loop = FALSE;
628 /* As far as I can see there is a bug in the Microtec IEEE output
629 which I'm using to scan, whereby the comma operator is omitted
630 sometimes in an expression, giving expressions with too many
631 terms. We can tell if that's the case by ensuring that
632 sp == stack here. If not, then we've pushed something too far,
633 so we keep adding. */
634 while (sp != stack + 1)
636 asection *section1;
637 ieee_symbol_index_type sy1;
639 POP (sy1, section1, *extra);
642 POP (*symbol, dummy, *value);
643 if (section)
644 *section = dummy;
648 #define ieee_seek(ieee, offset) \
649 do \
651 ieee->h.input_p = ieee->h.first_byte + offset; \
652 ieee->h.last_byte = (ieee->h.first_byte \
653 + ieee_part_after (ieee, offset)); \
655 while (0)
657 #define ieee_pos(ieee) \
658 (ieee->h.input_p - ieee->h.first_byte)
660 /* Find the first part of the ieee file after HERE. */
662 static file_ptr
663 ieee_part_after (ieee_data_type *ieee, file_ptr here)
665 int part;
666 file_ptr after = ieee->w.r.me_record;
668 /* File parts can come in any order, except that module end is
669 guaranteed to be last (and the header first). */
670 for (part = 0; part < N_W_VARIABLES; part++)
671 if (ieee->w.offset[part] > here && after > ieee->w.offset[part])
672 after = ieee->w.offset[part];
674 return after;
677 static unsigned int last_index;
678 static char last_type; /* Is the index for an X or a D. */
680 static ieee_symbol_type *
681 get_symbol (bfd *abfd ATTRIBUTE_UNUSED,
682 ieee_data_type *ieee,
683 ieee_symbol_type *last_symbol,
684 unsigned int *symbol_count,
685 ieee_symbol_type ***pptr,
686 unsigned int *max_index,
687 int this_type)
689 /* Need a new symbol. */
690 unsigned int new_index = must_parse_int (&(ieee->h));
692 if (new_index != last_index || this_type != last_type)
694 ieee_symbol_type *new_symbol;
695 bfd_size_type amt = sizeof (ieee_symbol_type);
697 new_symbol = bfd_alloc (ieee->h.abfd, amt);
698 if (!new_symbol)
699 return NULL;
701 new_symbol->index = new_index;
702 last_index = new_index;
703 (*symbol_count)++;
704 **pptr = new_symbol;
705 *pptr = &new_symbol->next;
706 if (new_index > *max_index)
707 *max_index = new_index;
709 last_type = this_type;
710 new_symbol->symbol.section = bfd_abs_section_ptr;
711 return new_symbol;
713 return last_symbol;
716 static bfd_boolean
717 ieee_slurp_external_symbols (bfd *abfd)
719 ieee_data_type *ieee = IEEE_DATA (abfd);
720 file_ptr offset = ieee->w.r.external_part;
722 ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols;
723 ieee_symbol_type **prev_reference_ptr = &ieee->external_reference;
724 ieee_symbol_type *symbol = NULL;
725 unsigned int symbol_count = 0;
726 bfd_boolean loop = TRUE;
728 last_index = 0xffffff;
729 ieee->symbol_table_full = TRUE;
731 ieee_seek (ieee, offset);
733 while (loop)
735 switch (this_byte (&(ieee->h)))
737 case ieee_nn_record:
738 next_byte (&(ieee->h));
740 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
741 & prev_symbols_ptr,
742 & ieee->external_symbol_max_index, 'I');
743 if (symbol == NULL)
744 return FALSE;
746 symbol->symbol.the_bfd = abfd;
747 symbol->symbol.name = read_id (&(ieee->h));
748 symbol->symbol.udata.p = NULL;
749 symbol->symbol.flags = BSF_NO_FLAGS;
750 break;
751 case ieee_external_symbol_enum:
752 next_byte (&(ieee->h));
754 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
755 &prev_symbols_ptr,
756 &ieee->external_symbol_max_index, 'D');
757 if (symbol == NULL)
758 return FALSE;
760 BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
762 symbol->symbol.the_bfd = abfd;
763 symbol->symbol.name = read_id (&(ieee->h));
764 symbol->symbol.udata.p = NULL;
765 symbol->symbol.flags = BSF_NO_FLAGS;
766 break;
767 case ieee_attribute_record_enum >> 8:
769 unsigned int symbol_name_index;
770 unsigned int symbol_type_index;
771 unsigned int symbol_attribute_def;
772 bfd_vma value = 0;
774 switch (read_2bytes (&ieee->h))
776 case ieee_attribute_record_enum:
777 symbol_name_index = must_parse_int (&(ieee->h));
778 symbol_type_index = must_parse_int (&(ieee->h));
779 symbol_attribute_def = must_parse_int (&(ieee->h));
780 switch (symbol_attribute_def)
782 case 8:
783 case 19:
784 parse_int (&ieee->h, &value);
785 break;
786 default:
787 (*_bfd_error_handler)
788 (_("%B: unimplemented ATI record %u for symbol %u"),
789 abfd, symbol_attribute_def, symbol_name_index);
790 bfd_set_error (bfd_error_bad_value);
791 return FALSE;
792 break;
794 break;
795 case ieee_external_reference_info_record_enum:
796 /* Skip over ATX record. */
797 parse_int (&(ieee->h), &value);
798 parse_int (&(ieee->h), &value);
799 parse_int (&(ieee->h), &value);
800 parse_int (&(ieee->h), &value);
801 break;
802 case ieee_atn_record_enum:
803 /* We may get call optimization information here,
804 which we just ignore. The format is
805 {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs}. */
806 parse_int (&ieee->h, &value);
807 parse_int (&ieee->h, &value);
808 parse_int (&ieee->h, &value);
809 if (value != 0x3f)
811 (*_bfd_error_handler)
812 (_("%B: unexpected ATN type %d in external part"),
813 abfd, (int) value);
814 bfd_set_error (bfd_error_bad_value);
815 return FALSE;
817 parse_int (&ieee->h, &value);
818 parse_int (&ieee->h, &value);
819 while (value > 0)
821 bfd_vma val1;
823 --value;
825 switch (read_2bytes (&ieee->h))
827 case ieee_asn_record_enum:
828 parse_int (&ieee->h, &val1);
829 parse_int (&ieee->h, &val1);
830 break;
832 default:
833 (*_bfd_error_handler)
834 (_("%B: unexpected type after ATN"), abfd);
835 bfd_set_error (bfd_error_bad_value);
836 return FALSE;
841 break;
842 case ieee_value_record_enum >> 8:
844 unsigned int symbol_name_index;
845 ieee_symbol_index_type symbol_ignore;
846 bfd_boolean pcrel_ignore;
847 unsigned int extra;
849 next_byte (&(ieee->h));
850 next_byte (&(ieee->h));
852 symbol_name_index = must_parse_int (&(ieee->h));
853 parse_expression (ieee,
854 &symbol->symbol.value,
855 &symbol_ignore,
856 &pcrel_ignore,
857 &extra,
858 &symbol->symbol.section);
860 /* Fully linked IEEE-695 files tend to give every symbol
861 an absolute value. Try to convert that back into a
862 section relative value. FIXME: This won't always to
863 the right thing. */
864 if (bfd_is_abs_section (symbol->symbol.section)
865 && (abfd->flags & HAS_RELOC) == 0)
867 bfd_vma val;
868 asection *s;
870 val = symbol->symbol.value;
871 for (s = abfd->sections; s != NULL; s = s->next)
873 if (val >= s->vma && val < s->vma + s->size)
875 symbol->symbol.section = s;
876 symbol->symbol.value -= s->vma;
877 break;
882 symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
885 break;
886 case ieee_weak_external_reference_enum:
888 bfd_vma size;
889 bfd_vma value;
891 next_byte (&(ieee->h));
892 /* Throw away the external reference index. */
893 (void) must_parse_int (&(ieee->h));
894 /* Fetch the default size if not resolved. */
895 size = must_parse_int (&(ieee->h));
896 /* Fetch the default value if available. */
897 if (! parse_int (&(ieee->h), &value))
898 value = 0;
899 /* This turns into a common. */
900 symbol->symbol.section = bfd_com_section_ptr;
901 symbol->symbol.value = size;
903 break;
905 case ieee_external_reference_enum:
906 next_byte (&(ieee->h));
908 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
909 &prev_reference_ptr,
910 &ieee->external_reference_max_index, 'X');
911 if (symbol == NULL)
912 return FALSE;
914 symbol->symbol.the_bfd = abfd;
915 symbol->symbol.name = read_id (&(ieee->h));
916 symbol->symbol.udata.p = NULL;
917 symbol->symbol.section = bfd_und_section_ptr;
918 symbol->symbol.value = (bfd_vma) 0;
919 symbol->symbol.flags = 0;
921 BFD_ASSERT (symbol->index >= ieee->external_reference_min_index);
922 break;
924 default:
925 loop = FALSE;
929 if (ieee->external_symbol_max_index != 0)
931 ieee->external_symbol_count =
932 ieee->external_symbol_max_index -
933 ieee->external_symbol_min_index + 1;
935 else
936 ieee->external_symbol_count = 0;
938 if (ieee->external_reference_max_index != 0)
940 ieee->external_reference_count =
941 ieee->external_reference_max_index -
942 ieee->external_reference_min_index + 1;
944 else
945 ieee->external_reference_count = 0;
947 abfd->symcount =
948 ieee->external_reference_count + ieee->external_symbol_count;
950 if (symbol_count != abfd->symcount)
951 /* There are gaps in the table -- */
952 ieee->symbol_table_full = FALSE;
954 *prev_symbols_ptr = NULL;
955 *prev_reference_ptr = NULL;
957 return TRUE;
960 static bfd_boolean
961 ieee_slurp_symbol_table (bfd *abfd)
963 if (! IEEE_DATA (abfd)->read_symbols)
965 if (! ieee_slurp_external_symbols (abfd))
966 return FALSE;
967 IEEE_DATA (abfd)->read_symbols = TRUE;
969 return TRUE;
972 static long
973 ieee_get_symtab_upper_bound (bfd *abfd)
975 if (! ieee_slurp_symbol_table (abfd))
976 return -1;
978 return (abfd->symcount != 0) ?
979 (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0;
982 /* Move from our internal lists to the canon table, and insert in
983 symbol index order. */
985 extern const bfd_target ieee_vec;
987 static long
988 ieee_canonicalize_symtab (bfd *abfd, asymbol **location)
990 ieee_symbol_type *symp;
991 static bfd dummy_bfd;
992 static asymbol empty_symbol =
994 &dummy_bfd,
995 " ieee empty",
996 (symvalue) 0,
997 BSF_DEBUGGING,
998 bfd_abs_section_ptr
999 #ifdef __STDC__
1000 /* K&R compilers can't initialise unions. */
1001 , { 0 }
1002 #endif
1005 if (abfd->symcount)
1007 ieee_data_type *ieee = IEEE_DATA (abfd);
1009 dummy_bfd.xvec = &ieee_vec;
1010 if (! ieee_slurp_symbol_table (abfd))
1011 return -1;
1013 if (! ieee->symbol_table_full)
1015 /* Arrgh - there are gaps in the table, run through and fill them
1016 up with pointers to a null place. */
1017 unsigned int i;
1019 for (i = 0; i < abfd->symcount; i++)
1020 location[i] = &empty_symbol;
1023 ieee->external_symbol_base_offset = -ieee->external_symbol_min_index;
1024 for (symp = IEEE_DATA (abfd)->external_symbols;
1025 symp != (ieee_symbol_type *) NULL;
1026 symp = symp->next)
1027 /* Place into table at correct index locations. */
1028 location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
1030 /* The external refs are indexed in a bit. */
1031 ieee->external_reference_base_offset =
1032 -ieee->external_reference_min_index + ieee->external_symbol_count;
1034 for (symp = IEEE_DATA (abfd)->external_reference;
1035 symp != (ieee_symbol_type *) NULL;
1036 symp = symp->next)
1037 location[symp->index + ieee->external_reference_base_offset] =
1038 &symp->symbol;
1041 if (abfd->symcount)
1042 location[abfd->symcount] = (asymbol *) NULL;
1044 return abfd->symcount;
1047 static asection *
1048 get_section_entry (bfd *abfd, ieee_data_type *ieee, unsigned int index)
1050 if (index >= ieee->section_table_size)
1052 unsigned int c, i;
1053 asection **n;
1054 bfd_size_type amt;
1056 c = ieee->section_table_size;
1057 if (c == 0)
1058 c = 20;
1059 while (c <= index)
1060 c *= 2;
1062 amt = c;
1063 amt *= sizeof (asection *);
1064 n = bfd_realloc (ieee->section_table, amt);
1065 if (n == NULL)
1066 return NULL;
1068 for (i = ieee->section_table_size; i < c; i++)
1069 n[i] = NULL;
1071 ieee->section_table = n;
1072 ieee->section_table_size = c;
1075 if (ieee->section_table[index] == (asection *) NULL)
1077 char *tmp = bfd_alloc (abfd, (bfd_size_type) 11);
1078 asection *section;
1080 if (!tmp)
1081 return NULL;
1082 sprintf (tmp, " fsec%4d", index);
1083 section = bfd_make_section (abfd, tmp);
1084 ieee->section_table[index] = section;
1085 section->target_index = index;
1086 ieee->section_table[index] = section;
1088 return ieee->section_table[index];
1091 static void
1092 ieee_slurp_sections (bfd *abfd)
1094 ieee_data_type *ieee = IEEE_DATA (abfd);
1095 file_ptr offset = ieee->w.r.section_part;
1096 char *name;
1098 if (offset != 0)
1100 bfd_byte section_type[3];
1102 ieee_seek (ieee, offset);
1103 while (TRUE)
1105 switch (this_byte (&(ieee->h)))
1107 case ieee_section_type_enum:
1109 asection *section;
1110 unsigned int section_index;
1112 next_byte (&(ieee->h));
1113 section_index = must_parse_int (&(ieee->h));
1115 section = get_section_entry (abfd, ieee, section_index);
1117 section_type[0] = this_byte_and_next (&(ieee->h));
1119 /* Set minimal section attributes. Attributes are
1120 extended later, based on section contents. */
1121 switch (section_type[0])
1123 case 0xC1:
1124 /* Normal attributes for absolute sections. */
1125 section_type[1] = this_byte (&(ieee->h));
1126 section->flags = SEC_ALLOC;
1127 switch (section_type[1])
1129 /* AS Absolute section attributes. */
1130 case 0xD3:
1131 next_byte (&(ieee->h));
1132 section_type[2] = this_byte (&(ieee->h));
1133 switch (section_type[2])
1135 case 0xD0:
1136 /* Normal code. */
1137 next_byte (&(ieee->h));
1138 section->flags |= SEC_CODE;
1139 break;
1140 case 0xC4:
1141 /* Normal data. */
1142 next_byte (&(ieee->h));
1143 section->flags |= SEC_DATA;
1144 break;
1145 case 0xD2:
1146 next_byte (&(ieee->h));
1147 /* Normal rom data. */
1148 section->flags |= SEC_ROM | SEC_DATA;
1149 break;
1150 default:
1151 break;
1154 break;
1156 /* Named relocatable sections (type C). */
1157 case 0xC3:
1158 section_type[1] = this_byte (&(ieee->h));
1159 section->flags = SEC_ALLOC;
1160 switch (section_type[1])
1162 case 0xD0: /* Normal code (CP). */
1163 next_byte (&(ieee->h));
1164 section->flags |= SEC_CODE;
1165 break;
1166 case 0xC4: /* Normal data (CD). */
1167 next_byte (&(ieee->h));
1168 section->flags |= SEC_DATA;
1169 break;
1170 case 0xD2: /* Normal rom data (CR). */
1171 next_byte (&(ieee->h));
1172 section->flags |= SEC_ROM | SEC_DATA;
1173 break;
1174 default:
1175 break;
1179 /* Read section name, use it if non empty. */
1180 name = read_id (&ieee->h);
1181 if (name[0])
1182 section->name = name;
1184 /* Skip these fields, which we don't care about. */
1186 bfd_vma parent, brother, context;
1188 parse_int (&(ieee->h), &parent);
1189 parse_int (&(ieee->h), &brother);
1190 parse_int (&(ieee->h), &context);
1193 break;
1194 case ieee_section_alignment_enum:
1196 unsigned int section_index;
1197 bfd_vma value;
1198 asection *section;
1200 next_byte (&(ieee->h));
1201 section_index = must_parse_int (&ieee->h);
1202 section = get_section_entry (abfd, ieee, section_index);
1203 if (section_index > ieee->section_count)
1204 ieee->section_count = section_index;
1206 section->alignment_power =
1207 bfd_log2 (must_parse_int (&ieee->h));
1208 (void) parse_int (&(ieee->h), &value);
1210 break;
1211 case ieee_e2_first_byte_enum:
1213 asection *section;
1214 ieee_record_enum_type t;
1216 t = (ieee_record_enum_type) (read_2bytes (&(ieee->h)));
1217 switch (t)
1219 case ieee_section_size_enum:
1220 section = ieee->section_table[must_parse_int (&(ieee->h))];
1221 section->size = must_parse_int (&(ieee->h));
1222 break;
1223 case ieee_physical_region_size_enum:
1224 section = ieee->section_table[must_parse_int (&(ieee->h))];
1225 section->size = must_parse_int (&(ieee->h));
1226 break;
1227 case ieee_region_base_address_enum:
1228 section = ieee->section_table[must_parse_int (&(ieee->h))];
1229 section->vma = must_parse_int (&(ieee->h));
1230 section->lma = section->vma;
1231 break;
1232 case ieee_mau_size_enum:
1233 must_parse_int (&(ieee->h));
1234 must_parse_int (&(ieee->h));
1235 break;
1236 case ieee_m_value_enum:
1237 must_parse_int (&(ieee->h));
1238 must_parse_int (&(ieee->h));
1239 break;
1240 case ieee_section_base_address_enum:
1241 section = ieee->section_table[must_parse_int (&(ieee->h))];
1242 section->vma = must_parse_int (&(ieee->h));
1243 section->lma = section->vma;
1244 break;
1245 case ieee_section_offset_enum:
1246 (void) must_parse_int (&(ieee->h));
1247 (void) must_parse_int (&(ieee->h));
1248 break;
1249 default:
1250 return;
1253 break;
1254 default:
1255 return;
1261 /* Make a section for the debugging information, if any. We don't try
1262 to interpret the debugging information; we just point the section
1263 at the area in the file so that program which understand can dig it
1264 out. */
1266 static bfd_boolean
1267 ieee_slurp_debug (bfd *abfd)
1269 ieee_data_type *ieee = IEEE_DATA (abfd);
1270 asection *sec;
1271 file_ptr debug_end;
1272 flagword flags;
1274 if (ieee->w.r.debug_information_part == 0)
1275 return TRUE;
1277 flags = SEC_DEBUGGING | SEC_HAS_CONTENTS;
1278 sec = bfd_make_section_with_flags (abfd, ".debug", flags);
1279 if (sec == NULL)
1280 return FALSE;
1281 sec->filepos = ieee->w.r.debug_information_part;
1283 debug_end = ieee_part_after (ieee, ieee->w.r.debug_information_part);
1284 sec->size = debug_end - ieee->w.r.debug_information_part;
1286 return TRUE;
1289 /* Archive stuff. */
1291 static const bfd_target *
1292 ieee_archive_p (bfd *abfd)
1294 char *library;
1295 unsigned int i;
1296 unsigned char buffer[512];
1297 file_ptr buffer_offset = 0;
1298 ieee_ar_data_type *save = abfd->tdata.ieee_ar_data;
1299 ieee_ar_data_type *ieee;
1300 bfd_size_type alc_elts;
1301 ieee_ar_obstack_type *elts = NULL;
1302 bfd_size_type amt = sizeof (ieee_ar_data_type);
1304 abfd->tdata.ieee_ar_data = bfd_alloc (abfd, amt);
1305 if (!abfd->tdata.ieee_ar_data)
1306 goto error_ret_restore;
1307 ieee = IEEE_AR_DATA (abfd);
1309 /* Ignore the return value here. It doesn't matter if we don't read
1310 the entire buffer. We might have a very small ieee file. */
1311 bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1313 ieee->h.first_byte = buffer;
1314 ieee->h.input_p = buffer;
1316 ieee->h.abfd = abfd;
1318 if (this_byte (&(ieee->h)) != Module_Beginning)
1319 goto got_wrong_format_error;
1321 next_byte (&(ieee->h));
1322 library = read_id (&(ieee->h));
1323 if (strcmp (library, "LIBRARY") != 0)
1324 goto got_wrong_format_error;
1326 /* Throw away the filename. */
1327 read_id (&(ieee->h));
1329 ieee->element_count = 0;
1330 ieee->element_index = 0;
1332 next_byte (&(ieee->h)); /* Drop the ad part. */
1333 must_parse_int (&(ieee->h)); /* And the two dummy numbers. */
1334 must_parse_int (&(ieee->h));
1336 alc_elts = 10;
1337 elts = bfd_malloc (alc_elts * sizeof *elts);
1338 if (elts == NULL)
1339 goto error_return;
1341 /* Read the index of the BB table. */
1342 while (1)
1344 int rec;
1345 ieee_ar_obstack_type *t;
1347 rec = read_2bytes (&(ieee->h));
1348 if (rec != (int) ieee_assign_value_to_variable_enum)
1349 break;
1351 if (ieee->element_count >= alc_elts)
1353 ieee_ar_obstack_type *n;
1355 alc_elts *= 2;
1356 n = bfd_realloc (elts, alc_elts * sizeof (* elts));
1357 if (n == NULL)
1358 goto error_return;
1359 elts = n;
1362 t = &elts[ieee->element_count];
1363 ieee->element_count++;
1365 must_parse_int (&(ieee->h));
1366 t->file_offset = must_parse_int (&(ieee->h));
1367 t->abfd = (bfd *) NULL;
1369 /* Make sure that we don't go over the end of the buffer. */
1370 if ((size_t) ieee_pos (IEEE_DATA (abfd)) > sizeof (buffer) / 2)
1372 /* Past half way, reseek and reprime. */
1373 buffer_offset += ieee_pos (IEEE_DATA (abfd));
1374 if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0)
1375 goto error_return;
1377 /* Again ignore return value of bfd_bread. */
1378 bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1379 ieee->h.first_byte = buffer;
1380 ieee->h.input_p = buffer;
1384 amt = ieee->element_count;
1385 amt *= sizeof *ieee->elements;
1386 ieee->elements = bfd_alloc (abfd, amt);
1387 if (ieee->elements == NULL)
1388 goto error_return;
1390 memcpy (ieee->elements, elts, (size_t) amt);
1391 free (elts);
1392 elts = NULL;
1394 /* Now scan the area again, and replace BB offsets with file offsets. */
1395 for (i = 2; i < ieee->element_count; i++)
1397 if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0)
1398 goto error_return;
1400 /* Again ignore return value of bfd_bread. */
1401 bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1402 ieee->h.first_byte = buffer;
1403 ieee->h.input_p = buffer;
1405 next_byte (&(ieee->h)); /* Drop F8. */
1406 next_byte (&(ieee->h)); /* Drop 14. */
1407 must_parse_int (&(ieee->h)); /* Drop size of block. */
1409 if (must_parse_int (&(ieee->h)) != 0)
1410 /* This object has been deleted. */
1411 ieee->elements[i].file_offset = 0;
1412 else
1413 ieee->elements[i].file_offset = must_parse_int (&(ieee->h));
1416 /* abfd->has_armap = ;*/
1418 return abfd->xvec;
1420 got_wrong_format_error:
1421 bfd_set_error (bfd_error_wrong_format);
1422 error_return:
1423 if (elts != NULL)
1424 free (elts);
1425 bfd_release (abfd, ieee);
1426 error_ret_restore:
1427 abfd->tdata.ieee_ar_data = save;
1429 return NULL;
1432 static bfd_boolean
1433 ieee_mkobject (bfd *abfd)
1435 bfd_size_type amt;
1437 output_ptr_start = NULL;
1438 output_ptr = NULL;
1439 output_ptr_end = NULL;
1440 input_ptr_start = NULL;
1441 input_ptr = NULL;
1442 input_ptr_end = NULL;
1443 input_bfd = NULL;
1444 output_bfd = NULL;
1445 output_buffer = 0;
1446 amt = sizeof (ieee_data_type);
1447 abfd->tdata.ieee_data = bfd_zalloc (abfd, amt);
1448 return abfd->tdata.ieee_data != NULL;
1451 static bfd_boolean
1452 do_one (ieee_data_type *ieee,
1453 ieee_per_section_type *current_map,
1454 unsigned char *location_ptr,
1455 asection *s,
1456 int iterations)
1458 switch (this_byte (&(ieee->h)))
1460 case ieee_load_constant_bytes_enum:
1462 unsigned int number_of_maus;
1463 unsigned int i;
1465 next_byte (&(ieee->h));
1466 number_of_maus = must_parse_int (&(ieee->h));
1468 for (i = 0; i < number_of_maus; i++)
1470 location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1471 next_byte (&(ieee->h));
1474 break;
1476 case ieee_load_with_relocation_enum:
1478 bfd_boolean loop = TRUE;
1480 next_byte (&(ieee->h));
1481 while (loop)
1483 switch (this_byte (&(ieee->h)))
1485 case ieee_variable_R_enum:
1487 case ieee_function_signed_open_b_enum:
1488 case ieee_function_unsigned_open_b_enum:
1489 case ieee_function_either_open_b_enum:
1491 unsigned int extra = 4;
1492 bfd_boolean pcrel = FALSE;
1493 asection *section;
1494 ieee_reloc_type *r;
1496 r = bfd_alloc (ieee->h.abfd, sizeof (* r));
1497 if (!r)
1498 return FALSE;
1500 *(current_map->reloc_tail_ptr) = r;
1501 current_map->reloc_tail_ptr = &r->next;
1502 r->next = (ieee_reloc_type *) NULL;
1503 next_byte (&(ieee->h));
1504 /* abort();*/
1505 r->relent.sym_ptr_ptr = 0;
1506 parse_expression (ieee,
1507 &r->relent.addend,
1508 &r->symbol,
1509 &pcrel, &extra, &section);
1510 r->relent.address = current_map->pc;
1511 s->flags |= SEC_RELOC;
1512 s->owner->flags |= HAS_RELOC;
1513 s->reloc_count++;
1514 if (r->relent.sym_ptr_ptr == NULL && section != NULL)
1515 r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
1517 if (this_byte (&(ieee->h)) == (int) ieee_comma)
1519 next_byte (&(ieee->h));
1520 /* Fetch number of bytes to pad. */
1521 extra = must_parse_int (&(ieee->h));
1524 switch (this_byte (&(ieee->h)))
1526 case ieee_function_signed_close_b_enum:
1527 next_byte (&(ieee->h));
1528 break;
1529 case ieee_function_unsigned_close_b_enum:
1530 next_byte (&(ieee->h));
1531 break;
1532 case ieee_function_either_close_b_enum:
1533 next_byte (&(ieee->h));
1534 break;
1535 default:
1536 break;
1538 /* Build a relocation entry for this type. */
1539 /* If pc rel then stick -ve pc into instruction
1540 and take out of reloc ..
1542 I've changed this. It's all too complicated. I
1543 keep 0 in the instruction now. */
1545 switch (extra)
1547 case 0:
1548 case 4:
1550 if (pcrel)
1552 #if KEEPMINUSPCININST
1553 bfd_put_32 (ieee->h.abfd, -current_map->pc,
1554 location_ptr + current_map->pc);
1555 r->relent.howto = &rel32_howto;
1556 r->relent.addend -= current_map->pc;
1557 #else
1558 bfd_put_32 (ieee->h.abfd, (bfd_vma) 0, location_ptr +
1559 current_map->pc);
1560 r->relent.howto = &rel32_howto;
1561 #endif
1563 else
1565 bfd_put_32 (ieee->h.abfd, (bfd_vma) 0,
1566 location_ptr + current_map->pc);
1567 r->relent.howto = &abs32_howto;
1569 current_map->pc += 4;
1570 break;
1571 case 2:
1572 if (pcrel)
1574 #if KEEPMINUSPCININST
1575 bfd_put_16 (ieee->h.abfd, (bfd_vma) -current_map->pc,
1576 location_ptr + current_map->pc);
1577 r->relent.addend -= current_map->pc;
1578 r->relent.howto = &rel16_howto;
1579 #else
1581 bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
1582 location_ptr + current_map->pc);
1583 r->relent.howto = &rel16_howto;
1584 #endif
1587 else
1589 bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
1590 location_ptr + current_map->pc);
1591 r->relent.howto = &abs16_howto;
1593 current_map->pc += 2;
1594 break;
1595 case 1:
1596 if (pcrel)
1598 #if KEEPMINUSPCININST
1599 bfd_put_8 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
1600 r->relent.addend -= current_map->pc;
1601 r->relent.howto = &rel8_howto;
1602 #else
1603 bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1604 r->relent.howto = &rel8_howto;
1605 #endif
1607 else
1609 bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1610 r->relent.howto = &abs8_howto;
1612 current_map->pc += 1;
1613 break;
1615 default:
1616 BFD_FAIL ();
1617 return FALSE;
1620 break;
1621 default:
1623 bfd_vma this_size;
1625 if (parse_int (&(ieee->h), &this_size))
1627 unsigned int i;
1629 for (i = 0; i < this_size; i++)
1631 location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1632 next_byte (&(ieee->h));
1635 else
1636 loop = FALSE;
1640 /* Prevent more than the first load-item of an LR record
1641 from being repeated (MRI convention). */
1642 if (iterations != 1)
1643 loop = FALSE;
1647 return TRUE;
1650 /* Read in all the section data and relocation stuff too. */
1652 static bfd_boolean
1653 ieee_slurp_section_data (bfd *abfd)
1655 bfd_byte *location_ptr = (bfd_byte *) NULL;
1656 ieee_data_type *ieee = IEEE_DATA (abfd);
1657 unsigned int section_number;
1658 ieee_per_section_type *current_map = NULL;
1659 asection *s;
1661 /* Seek to the start of the data area. */
1662 if (ieee->read_data)
1663 return TRUE;
1664 ieee->read_data = TRUE;
1665 ieee_seek (ieee, ieee->w.r.data_part);
1667 /* Allocate enough space for all the section contents. */
1668 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1670 ieee_per_section_type *per = ieee_per_section (s);
1671 arelent **relpp;
1673 if ((s->flags & SEC_DEBUGGING) != 0)
1674 continue;
1675 per->data = bfd_alloc (ieee->h.abfd, s->size);
1676 if (!per->data)
1677 return FALSE;
1678 relpp = &s->relocation;
1679 per->reloc_tail_ptr = (ieee_reloc_type **) relpp;
1682 while (TRUE)
1684 switch (this_byte (&(ieee->h)))
1686 /* IF we see anything strange then quit. */
1687 default:
1688 return TRUE;
1690 case ieee_set_current_section_enum:
1691 next_byte (&(ieee->h));
1692 section_number = must_parse_int (&(ieee->h));
1693 s = ieee->section_table[section_number];
1694 s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
1695 current_map = ieee_per_section (s);
1696 location_ptr = current_map->data - s->vma;
1697 /* The document I have says that Microtec's compilers reset
1698 this after a sec section, even though the standard says not
1699 to, SO... */
1700 current_map->pc = s->vma;
1701 break;
1703 case ieee_e2_first_byte_enum:
1704 next_byte (&(ieee->h));
1705 switch (this_byte (&(ieee->h)))
1707 case ieee_set_current_pc_enum & 0xff:
1709 bfd_vma value;
1710 ieee_symbol_index_type symbol;
1711 unsigned int extra;
1712 bfd_boolean pcrel;
1714 next_byte (&(ieee->h));
1715 must_parse_int (&(ieee->h)); /* Throw away section #. */
1716 parse_expression (ieee, &value,
1717 &symbol,
1718 &pcrel, &extra,
1720 current_map->pc = value;
1721 BFD_ASSERT ((unsigned) (value - s->vma) <= s->size);
1723 break;
1725 case ieee_value_starting_address_enum & 0xff:
1726 next_byte (&(ieee->h));
1727 if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum)
1728 next_byte (&(ieee->h));
1729 abfd->start_address = must_parse_int (&(ieee->h));
1730 /* We've got to the end of the data now - */
1731 return TRUE;
1732 default:
1733 BFD_FAIL ();
1734 return FALSE;
1736 break;
1737 case ieee_repeat_data_enum:
1739 /* Repeat the following LD or LR n times - we do this by
1740 remembering the stream pointer before running it and
1741 resetting it and running it n times. We special case
1742 the repetition of a repeat_data/load_constant. */
1743 unsigned int iterations;
1744 unsigned char *start;
1746 next_byte (&(ieee->h));
1747 iterations = must_parse_int (&(ieee->h));
1748 start = ieee->h.input_p;
1749 if (start[0] == (int) ieee_load_constant_bytes_enum
1750 && start[1] == 1)
1752 while (iterations != 0)
1754 location_ptr[current_map->pc++] = start[2];
1755 iterations--;
1757 next_byte (&(ieee->h));
1758 next_byte (&(ieee->h));
1759 next_byte (&(ieee->h));
1761 else
1763 while (iterations != 0)
1765 ieee->h.input_p = start;
1766 if (!do_one (ieee, current_map, location_ptr, s,
1767 (int) iterations))
1768 return FALSE;
1769 iterations--;
1773 break;
1774 case ieee_load_constant_bytes_enum:
1775 case ieee_load_with_relocation_enum:
1776 if (!do_one (ieee, current_map, location_ptr, s, 1))
1777 return FALSE;
1782 static const bfd_target *
1783 ieee_object_p (bfd *abfd)
1785 char *processor;
1786 unsigned int part;
1787 ieee_data_type *ieee;
1788 unsigned char buffer[300];
1789 ieee_data_type *save = IEEE_DATA (abfd);
1790 bfd_size_type amt;
1792 abfd->tdata.ieee_data = 0;
1793 ieee_mkobject (abfd);
1795 ieee = IEEE_DATA (abfd);
1796 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1797 goto fail;
1798 /* Read the first few bytes in to see if it makes sense. Ignore
1799 bfd_bread return value; The file might be very small. */
1800 bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1802 ieee->h.input_p = buffer;
1803 if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
1804 goto got_wrong_format;
1806 ieee->read_symbols = FALSE;
1807 ieee->read_data = FALSE;
1808 ieee->section_count = 0;
1809 ieee->external_symbol_max_index = 0;
1810 ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
1811 ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
1812 ieee->external_reference_max_index = 0;
1813 ieee->h.abfd = abfd;
1814 ieee->section_table = NULL;
1815 ieee->section_table_size = 0;
1817 processor = ieee->mb.processor = read_id (&(ieee->h));
1818 if (strcmp (processor, "LIBRARY") == 0)
1819 goto got_wrong_format;
1820 ieee->mb.module_name = read_id (&(ieee->h));
1821 if (abfd->filename == (const char *) NULL)
1822 abfd->filename = ieee->mb.module_name;
1824 /* Determine the architecture and machine type of the object file. */
1826 const bfd_arch_info_type *arch;
1827 char family[10];
1829 /* IEEE does not specify the format of the processor identification
1830 string, so the compiler is free to put in it whatever it wants.
1831 We try here to recognize different processors belonging to the
1832 m68k family. Code for other processors can be added here. */
1833 if ((processor[0] == '6') && (processor[1] == '8'))
1835 if (processor[2] == '3') /* 683xx integrated processors. */
1837 switch (processor[3])
1839 case '0': /* 68302, 68306, 68307 */
1840 case '2': /* 68322, 68328 */
1841 case '5': /* 68356 */
1842 strcpy (family, "68000"); /* MC68000-based controllers. */
1843 break;
1845 case '3': /* 68330, 68331, 68332, 68333,
1846 68334, 68335, 68336, 68338 */
1847 case '6': /* 68360 */
1848 case '7': /* 68376 */
1849 strcpy (family, "68332"); /* CPU32 and CPU32+ */
1850 break;
1852 case '4':
1853 if (processor[4] == '9') /* 68349 */
1854 strcpy (family, "68030"); /* CPU030 */
1855 else /* 68340, 68341 */
1856 strcpy (family, "68332"); /* CPU32 and CPU32+ */
1857 break;
1859 default: /* Does not exist yet. */
1860 strcpy (family, "68332"); /* Guess it will be CPU32 */
1863 else if (TOUPPER (processor[3]) == 'F') /* 68F333 */
1864 strcpy (family, "68332"); /* CPU32 */
1865 else if ((TOUPPER (processor[3]) == 'C') /* Embedded controllers. */
1866 && ((TOUPPER (processor[2]) == 'E')
1867 || (TOUPPER (processor[2]) == 'H')
1868 || (TOUPPER (processor[2]) == 'L')))
1870 strcpy (family, "68");
1871 strncat (family, processor + 4, 7);
1872 family[9] = '\0';
1874 else /* "Regular" processors. */
1876 strncpy (family, processor, 9);
1877 family[9] = '\0';
1880 else if ((CONST_STRNEQ (processor, "cpu32")) /* CPU32 and CPU32+ */
1881 || (CONST_STRNEQ (processor, "CPU32")))
1882 strcpy (family, "68332");
1883 else
1885 strncpy (family, processor, 9);
1886 family[9] = '\0';
1889 arch = bfd_scan_arch (family);
1890 if (arch == 0)
1891 goto got_wrong_format;
1892 abfd->arch_info = arch;
1895 if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
1896 goto fail;
1898 next_byte (&(ieee->h));
1900 if (! parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau))
1901 goto fail;
1903 if (! parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address))
1904 goto fail;
1906 /* If there is a byte order info, take it. */
1907 if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum
1908 || this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
1909 next_byte (&(ieee->h));
1911 for (part = 0; part < N_W_VARIABLES; part++)
1913 bfd_boolean ok;
1915 if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
1916 goto fail;
1918 if (this_byte_and_next (&(ieee->h)) != part)
1919 goto fail;
1921 ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
1922 if (! ok)
1923 goto fail;
1926 if (ieee->w.r.external_part != 0)
1927 abfd->flags = HAS_SYMS;
1929 /* By now we know that this is a real IEEE file, we're going to read
1930 the whole thing into memory so that we can run up and down it
1931 quickly. We can work out how big the file is from the trailer
1932 record. */
1934 amt = ieee->w.r.me_record + 1;
1935 IEEE_DATA (abfd)->h.first_byte = bfd_alloc (ieee->h.abfd, amt);
1936 if (!IEEE_DATA (abfd)->h.first_byte)
1937 goto fail;
1938 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1939 goto fail;
1940 /* FIXME: Check return value. I'm not sure whether it needs to read
1941 the entire buffer or not. */
1942 bfd_bread ((void *) (IEEE_DATA (abfd)->h.first_byte),
1943 (bfd_size_type) ieee->w.r.me_record + 1, abfd);
1945 ieee_slurp_sections (abfd);
1947 if (! ieee_slurp_debug (abfd))
1948 goto fail;
1950 /* Parse section data to activate file and section flags implied by
1951 section contents. */
1952 if (! ieee_slurp_section_data (abfd))
1953 goto fail;
1955 return abfd->xvec;
1956 got_wrong_format:
1957 bfd_set_error (bfd_error_wrong_format);
1958 fail:
1959 bfd_release (abfd, ieee);
1960 abfd->tdata.ieee_data = save;
1961 return (const bfd_target *) NULL;
1964 static void
1965 ieee_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1966 asymbol *symbol,
1967 symbol_info *ret)
1969 bfd_symbol_info (symbol, ret);
1970 if (symbol->name[0] == ' ')
1971 ret->name = "* empty table entry ";
1972 if (!symbol->section)
1973 ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
1976 static void
1977 ieee_print_symbol (bfd *abfd,
1978 void * afile,
1979 asymbol *symbol,
1980 bfd_print_symbol_type how)
1982 FILE *file = (FILE *) afile;
1984 switch (how)
1986 case bfd_print_symbol_name:
1987 fprintf (file, "%s", symbol->name);
1988 break;
1989 case bfd_print_symbol_more:
1990 BFD_FAIL ();
1991 break;
1992 case bfd_print_symbol_all:
1994 const char *section_name =
1995 (symbol->section == (asection *) NULL
1996 ? "*abs"
1997 : symbol->section->name);
1999 if (symbol->name[0] == ' ')
2000 fprintf (file, "* empty table entry ");
2001 else
2003 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2005 fprintf (file, " %-5s %04x %02x %s",
2006 section_name,
2007 (unsigned) ieee_symbol (symbol)->index,
2008 (unsigned) 0,
2009 symbol->name);
2012 break;
2016 static bfd_boolean
2017 ieee_new_section_hook (bfd *abfd, asection *newsect)
2019 if (!newsect->used_by_bfd)
2021 newsect->used_by_bfd = bfd_alloc (abfd, sizeof (ieee_per_section_type));
2022 if (!newsect->used_by_bfd)
2023 return FALSE;
2025 ieee_per_section (newsect)->data = NULL;
2026 ieee_per_section (newsect)->section = newsect;
2027 return _bfd_generic_new_section_hook (abfd, newsect);
2030 static long
2031 ieee_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2033 if ((asect->flags & SEC_DEBUGGING) != 0)
2034 return 0;
2035 if (! ieee_slurp_section_data (abfd))
2036 return -1;
2037 return (asect->reloc_count + 1) * sizeof (arelent *);
2040 static bfd_boolean
2041 ieee_get_section_contents (bfd *abfd,
2042 sec_ptr section,
2043 void * location,
2044 file_ptr offset,
2045 bfd_size_type count)
2047 ieee_per_section_type *p = ieee_per_section (section);
2048 if ((section->flags & SEC_DEBUGGING) != 0)
2049 return _bfd_generic_get_section_contents (abfd, section, location,
2050 offset, count);
2051 ieee_slurp_section_data (abfd);
2052 (void) memcpy ((void *) location, (void *) (p->data + offset), (unsigned) count);
2053 return TRUE;
2056 static long
2057 ieee_canonicalize_reloc (bfd *abfd,
2058 sec_ptr section,
2059 arelent **relptr,
2060 asymbol **symbols)
2062 ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
2063 ieee_data_type *ieee = IEEE_DATA (abfd);
2065 if ((section->flags & SEC_DEBUGGING) != 0)
2066 return 0;
2068 while (src != (ieee_reloc_type *) NULL)
2070 /* Work out which symbol to attach it this reloc to. */
2071 switch (src->symbol.letter)
2073 case 'I':
2074 src->relent.sym_ptr_ptr =
2075 symbols + src->symbol.index + ieee->external_symbol_base_offset;
2076 break;
2077 case 'X':
2078 src->relent.sym_ptr_ptr =
2079 symbols + src->symbol.index + ieee->external_reference_base_offset;
2080 break;
2081 case 0:
2082 if (src->relent.sym_ptr_ptr != NULL)
2083 src->relent.sym_ptr_ptr =
2084 src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
2085 break;
2086 default:
2088 BFD_FAIL ();
2090 *relptr++ = &src->relent;
2091 src = src->next;
2093 *relptr = NULL;
2094 return section->reloc_count;
2097 static int
2098 comp (const void * ap, const void * bp)
2100 arelent *a = *((arelent **) ap);
2101 arelent *b = *((arelent **) bp);
2102 return a->address - b->address;
2105 /* Write the section headers. */
2107 static bfd_boolean
2108 ieee_write_section_part (bfd *abfd)
2110 ieee_data_type *ieee = IEEE_DATA (abfd);
2111 asection *s;
2113 ieee->w.r.section_part = bfd_tell (abfd);
2114 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2116 if (! bfd_is_abs_section (s)
2117 && (s->flags & SEC_DEBUGGING) == 0)
2119 if (! ieee_write_byte (abfd, ieee_section_type_enum)
2120 || ! ieee_write_byte (abfd,
2121 (bfd_byte) (s->index
2122 + IEEE_SECTION_NUMBER_BASE)))
2123 return FALSE;
2125 if (abfd->flags & EXEC_P)
2127 /* This image is executable, so output absolute sections. */
2128 if (! ieee_write_byte (abfd, ieee_variable_A_enum)
2129 || ! ieee_write_byte (abfd, ieee_variable_S_enum))
2130 return FALSE;
2132 else
2134 if (! ieee_write_byte (abfd, ieee_variable_C_enum))
2135 return FALSE;
2138 switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM))
2140 case SEC_CODE | SEC_LOAD:
2141 case SEC_CODE:
2142 if (! ieee_write_byte (abfd, ieee_variable_P_enum))
2143 return FALSE;
2144 break;
2145 case SEC_DATA:
2146 default:
2147 if (! ieee_write_byte (abfd, ieee_variable_D_enum))
2148 return FALSE;
2149 break;
2150 case SEC_ROM:
2151 case SEC_ROM | SEC_DATA:
2152 case SEC_ROM | SEC_LOAD:
2153 case SEC_ROM | SEC_DATA | SEC_LOAD:
2154 if (! ieee_write_byte (abfd, ieee_variable_R_enum))
2155 return FALSE;
2159 if (! ieee_write_id (abfd, s->name))
2160 return FALSE;
2161 /* Alignment. */
2162 if (! ieee_write_byte (abfd, ieee_section_alignment_enum)
2163 || ! ieee_write_byte (abfd,
2164 (bfd_byte) (s->index
2165 + IEEE_SECTION_NUMBER_BASE))
2166 || ! ieee_write_int (abfd, (bfd_vma) 1 << s->alignment_power))
2167 return FALSE;
2169 /* Size. */
2170 if (! ieee_write_2bytes (abfd, ieee_section_size_enum)
2171 || ! ieee_write_byte (abfd,
2172 (bfd_byte) (s->index
2173 + IEEE_SECTION_NUMBER_BASE))
2174 || ! ieee_write_int (abfd, s->size))
2175 return FALSE;
2176 if (abfd->flags & EXEC_P)
2178 /* Relocateable sections don't have asl records. */
2179 /* Vma. */
2180 if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum)
2181 || ! ieee_write_byte (abfd,
2182 ((bfd_byte)
2183 (s->index
2184 + IEEE_SECTION_NUMBER_BASE)))
2185 || ! ieee_write_int (abfd, s->lma))
2186 return FALSE;
2191 return TRUE;
2194 static bfd_boolean
2195 do_with_relocs (bfd *abfd, asection *s)
2197 unsigned int number_of_maus_in_address =
2198 bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd);
2199 unsigned int relocs_to_go = s->reloc_count;
2200 bfd_byte *stream = ieee_per_section (s)->data;
2201 arelent **p = s->orelocation;
2202 bfd_size_type current_byte_index = 0;
2204 qsort (s->orelocation,
2205 relocs_to_go,
2206 sizeof (arelent **),
2207 comp);
2209 /* Output the section preheader. */
2210 if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2211 || ! ieee_write_byte (abfd,
2212 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))
2213 || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum)
2214 || ! ieee_write_byte (abfd,
2215 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)))
2216 return FALSE;
2218 if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0)
2220 if (! ieee_write_int (abfd, s->lma))
2221 return FALSE;
2223 else
2225 if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2226 return FALSE;
2229 if (relocs_to_go == 0)
2231 /* If there aren't any relocations then output the load constant
2232 byte opcode rather than the load with relocation opcode. */
2233 while (current_byte_index < s->size)
2235 bfd_size_type run;
2236 unsigned int MAXRUN = 127;
2238 run = MAXRUN;
2239 if (run > s->size - current_byte_index)
2240 run = s->size - current_byte_index;
2242 if (run != 0)
2244 if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum))
2245 return FALSE;
2246 /* Output a stream of bytes. */
2247 if (! ieee_write_int (abfd, run))
2248 return FALSE;
2249 if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd)
2250 != run)
2251 return FALSE;
2252 current_byte_index += run;
2256 else
2258 if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum))
2259 return FALSE;
2261 /* Output the data stream as the longest sequence of bytes
2262 possible, allowing for the a reasonable packet size and
2263 relocation stuffs. */
2264 if (stream == NULL)
2266 /* Outputting a section without data, fill it up. */
2267 stream = bfd_zalloc (abfd, s->size);
2268 if (!stream)
2269 return FALSE;
2271 while (current_byte_index < s->size)
2273 bfd_size_type run;
2274 unsigned int MAXRUN = 127;
2276 if (relocs_to_go)
2278 run = (*p)->address - current_byte_index;
2279 if (run > MAXRUN)
2280 run = MAXRUN;
2282 else
2283 run = MAXRUN;
2285 if (run > s->size - current_byte_index)
2286 run = s->size - current_byte_index;
2288 if (run != 0)
2290 /* Output a stream of bytes. */
2291 if (! ieee_write_int (abfd, run))
2292 return FALSE;
2293 if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd)
2294 != run)
2295 return FALSE;
2296 current_byte_index += run;
2299 /* Output any relocations here. */
2300 if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
2302 while (relocs_to_go
2303 && (*p) && (*p)->address == current_byte_index)
2305 arelent *r = *p;
2306 bfd_signed_vma ov;
2307 switch (r->howto->size)
2309 case 2:
2310 ov = bfd_get_signed_32 (abfd,
2311 stream + current_byte_index);
2312 current_byte_index += 4;
2313 break;
2314 case 1:
2315 ov = bfd_get_signed_16 (abfd,
2316 stream + current_byte_index);
2317 current_byte_index += 2;
2318 break;
2319 case 0:
2320 ov = bfd_get_signed_8 (abfd,
2321 stream + current_byte_index);
2322 current_byte_index++;
2323 break;
2324 default:
2325 ov = 0;
2326 BFD_FAIL ();
2327 return FALSE;
2330 ov &= r->howto->src_mask;
2332 if (r->howto->pc_relative
2333 && ! r->howto->pcrel_offset)
2334 ov += r->address;
2336 if (! ieee_write_byte (abfd,
2337 ieee_function_either_open_b_enum))
2338 return FALSE;
2340 if (r->sym_ptr_ptr != (asymbol **) NULL)
2342 if (! ieee_write_expression (abfd, r->addend + ov,
2343 *(r->sym_ptr_ptr),
2344 r->howto->pc_relative,
2345 (unsigned) s->index))
2346 return FALSE;
2348 else
2350 if (! ieee_write_expression (abfd, r->addend + ov,
2351 (asymbol *) NULL,
2352 r->howto->pc_relative,
2353 (unsigned) s->index))
2354 return FALSE;
2357 if (number_of_maus_in_address
2358 != bfd_get_reloc_size (r->howto))
2360 bfd_vma rsize = bfd_get_reloc_size (r->howto);
2361 if (! ieee_write_int (abfd, rsize))
2362 return FALSE;
2364 if (! ieee_write_byte (abfd,
2365 ieee_function_either_close_b_enum))
2366 return FALSE;
2368 relocs_to_go--;
2369 p++;
2376 return TRUE;
2379 /* If there are no relocations in the output section then we can be
2380 clever about how we write. We block items up into a max of 127
2381 bytes. */
2383 static bfd_boolean
2384 do_as_repeat (bfd *abfd, asection *s)
2386 if (s->size)
2388 if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2389 || ! ieee_write_byte (abfd,
2390 (bfd_byte) (s->index
2391 + IEEE_SECTION_NUMBER_BASE))
2392 || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8)
2393 || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff)
2394 || ! ieee_write_byte (abfd,
2395 (bfd_byte) (s->index
2396 + IEEE_SECTION_NUMBER_BASE)))
2397 return FALSE;
2399 if ((abfd->flags & EXEC_P) != 0)
2401 if (! ieee_write_int (abfd, s->lma))
2402 return FALSE;
2404 else
2406 if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2407 return FALSE;
2410 if (! ieee_write_byte (abfd, ieee_repeat_data_enum)
2411 || ! ieee_write_int (abfd, s->size)
2412 || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)
2413 || ! ieee_write_byte (abfd, 1)
2414 || ! ieee_write_byte (abfd, 0))
2415 return FALSE;
2418 return TRUE;
2421 static bfd_boolean
2422 do_without_relocs (bfd *abfd, asection *s)
2424 bfd_byte *stream = ieee_per_section (s)->data;
2426 if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
2428 if (! do_as_repeat (abfd, s))
2429 return FALSE;
2431 else
2433 unsigned int i;
2435 for (i = 0; i < s->size; i++)
2437 if (stream[i] != 0)
2439 if (! do_with_relocs (abfd, s))
2440 return FALSE;
2441 return TRUE;
2444 if (! do_as_repeat (abfd, s))
2445 return FALSE;
2448 return TRUE;
2451 static void
2452 fill (void)
2454 bfd_size_type amt = input_ptr_end - input_ptr_start;
2455 /* FIXME: Check return value. I'm not sure whether it needs to read
2456 the entire buffer or not. */
2457 bfd_bread ((void *) input_ptr_start, amt, input_bfd);
2458 input_ptr = input_ptr_start;
2461 static void
2462 flush (void)
2464 bfd_size_type amt = output_ptr - output_ptr_start;
2466 if (bfd_bwrite ((void *) (output_ptr_start), amt, output_bfd) != amt)
2467 abort ();
2468 output_ptr = output_ptr_start;
2469 output_buffer++;
2472 #define THIS() ( *input_ptr )
2473 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill (); }
2474 #define OUT(x) { *output_ptr++ = (x); if (output_ptr == output_ptr_end) flush (); }
2476 static void
2477 write_int (int value)
2479 if (value >= 0 && value <= 127)
2481 OUT (value);
2483 else
2485 unsigned int length;
2487 /* How many significant bytes ? */
2488 /* FIXME FOR LONGER INTS. */
2489 if (value & 0xff000000)
2490 length = 4;
2491 else if (value & 0x00ff0000)
2492 length = 3;
2493 else if (value & 0x0000ff00)
2494 length = 2;
2495 else
2496 length = 1;
2498 OUT ((int) ieee_number_repeat_start_enum + length);
2499 switch (length)
2501 case 4:
2502 OUT (value >> 24);
2503 case 3:
2504 OUT (value >> 16);
2505 case 2:
2506 OUT (value >> 8);
2507 case 1:
2508 OUT (value);
2513 static void
2514 copy_id (void)
2516 int length = THIS ();
2517 char ch;
2519 OUT (length);
2520 NEXT ();
2521 while (length--)
2523 ch = THIS ();
2524 OUT (ch);
2525 NEXT ();
2529 #define VAR(x) ((x | 0x80))
2530 static void
2531 copy_expression (void)
2533 int stack[10];
2534 int *tos = stack;
2535 int value;
2537 while (1)
2539 switch (THIS ())
2541 case 0x84:
2542 NEXT ();
2543 value = THIS ();
2544 NEXT ();
2545 value = (value << 8) | THIS ();
2546 NEXT ();
2547 value = (value << 8) | THIS ();
2548 NEXT ();
2549 value = (value << 8) | THIS ();
2550 NEXT ();
2551 *tos++ = value;
2552 break;
2553 case 0x83:
2554 NEXT ();
2555 value = THIS ();
2556 NEXT ();
2557 value = (value << 8) | THIS ();
2558 NEXT ();
2559 value = (value << 8) | THIS ();
2560 NEXT ();
2561 *tos++ = value;
2562 break;
2563 case 0x82:
2564 NEXT ();
2565 value = THIS ();
2566 NEXT ();
2567 value = (value << 8) | THIS ();
2568 NEXT ();
2569 *tos++ = value;
2570 break;
2571 case 0x81:
2572 NEXT ();
2573 value = THIS ();
2574 NEXT ();
2575 *tos++ = value;
2576 break;
2577 case 0x80:
2578 NEXT ();
2579 *tos++ = 0;
2580 break;
2581 default:
2582 if (THIS () > 0x84)
2584 /* Not a number, just bug out with the answer. */
2585 write_int (*(--tos));
2586 return;
2588 *tos++ = THIS ();
2589 NEXT ();
2590 break;
2591 case 0xa5:
2592 /* PLUS anything. */
2593 value = *(--tos);
2594 value += *(--tos);
2595 *tos++ = value;
2596 NEXT ();
2597 break;
2598 case VAR ('R'):
2600 int section_number;
2601 ieee_data_type *ieee;
2602 asection *s;
2604 NEXT ();
2605 section_number = THIS ();
2607 NEXT ();
2608 ieee = IEEE_DATA (input_bfd);
2609 s = ieee->section_table[section_number];
2610 value = 0;
2611 if (s->output_section)
2612 value = s->output_section->lma;
2613 value += s->output_offset;
2614 *tos++ = value;
2616 break;
2617 case 0x90:
2619 NEXT ();
2620 write_int (*(--tos));
2621 OUT (0x90);
2622 return;
2628 /* Drop the int in the buffer, and copy a null into the gap, which we
2629 will overwrite later. */
2631 static void
2632 fill_int (struct output_buffer_struct *buf)
2634 if (buf->buffer == output_buffer)
2636 /* Still a chance to output the size. */
2637 int value = output_ptr - buf->ptrp + 3;
2638 buf->ptrp[0] = value >> 24;
2639 buf->ptrp[1] = value >> 16;
2640 buf->ptrp[2] = value >> 8;
2641 buf->ptrp[3] = value >> 0;
2645 static void
2646 drop_int (struct output_buffer_struct *buf)
2648 int type = THIS ();
2649 int ch;
2651 if (type <= 0x84)
2653 NEXT ();
2654 switch (type)
2656 case 0x84:
2657 ch = THIS ();
2658 NEXT ();
2659 case 0x83:
2660 ch = THIS ();
2661 NEXT ();
2662 case 0x82:
2663 ch = THIS ();
2664 NEXT ();
2665 case 0x81:
2666 ch = THIS ();
2667 NEXT ();
2668 case 0x80:
2669 break;
2672 OUT (0x84);
2673 buf->ptrp = output_ptr;
2674 buf->buffer = output_buffer;
2675 OUT (0);
2676 OUT (0);
2677 OUT (0);
2678 OUT (0);
2681 static void
2682 copy_int (void)
2684 int type = THIS ();
2685 int ch;
2686 if (type <= 0x84)
2688 OUT (type);
2689 NEXT ();
2690 switch (type)
2692 case 0x84:
2693 ch = THIS ();
2694 NEXT ();
2695 OUT (ch);
2696 case 0x83:
2697 ch = THIS ();
2698 NEXT ();
2699 OUT (ch);
2700 case 0x82:
2701 ch = THIS ();
2702 NEXT ();
2703 OUT (ch);
2704 case 0x81:
2705 ch = THIS ();
2706 NEXT ();
2707 OUT (ch);
2708 case 0x80:
2709 break;
2714 #define ID copy_id ()
2715 #define INT copy_int ()
2716 #define EXP copy_expression ()
2717 #define INTn(q) copy_int ()
2718 #define EXPn(q) copy_expression ()
2720 static void
2721 copy_till_end (void)
2723 int ch = THIS ();
2725 while (1)
2727 while (ch <= 0x80)
2729 OUT (ch);
2730 NEXT ();
2731 ch = THIS ();
2733 switch (ch)
2735 case 0x84:
2736 OUT (THIS ());
2737 NEXT ();
2738 case 0x83:
2739 OUT (THIS ());
2740 NEXT ();
2741 case 0x82:
2742 OUT (THIS ());
2743 NEXT ();
2744 case 0x81:
2745 OUT (THIS ());
2746 NEXT ();
2747 OUT (THIS ());
2748 NEXT ();
2750 ch = THIS ();
2751 break;
2752 default:
2753 return;
2759 static void
2760 f1_record (void)
2762 int ch;
2764 /* ATN record. */
2765 NEXT ();
2766 ch = THIS ();
2767 switch (ch)
2769 default:
2770 OUT (0xf1);
2771 OUT (ch);
2772 break;
2773 case 0xc9:
2774 NEXT ();
2775 OUT (0xf1);
2776 OUT (0xc9);
2777 INT;
2778 INT;
2779 ch = THIS ();
2780 switch (ch)
2782 case 0x16:
2783 NEXT ();
2784 break;
2785 case 0x01:
2786 NEXT ();
2787 break;
2788 case 0x00:
2789 NEXT ();
2790 INT;
2791 break;
2792 case 0x03:
2793 NEXT ();
2794 INT;
2795 break;
2796 case 0x13:
2797 EXPn (instruction address);
2798 break;
2799 default:
2800 break;
2802 break;
2803 case 0xd8:
2804 /* EXternal ref. */
2805 NEXT ();
2806 OUT (0xf1);
2807 OUT (0xd8);
2808 EXP;
2809 EXP;
2810 EXP;
2811 EXP;
2812 break;
2813 case 0xce:
2814 NEXT ();
2815 OUT (0xf1);
2816 OUT (0xce);
2817 INT;
2818 INT;
2819 ch = THIS ();
2820 INT;
2821 switch (ch)
2823 case 0x01:
2824 INT;
2825 INT;
2826 break;
2827 case 0x02:
2828 INT;
2829 break;
2830 case 0x04:
2831 EXPn (external function);
2832 break;
2833 case 0x05:
2834 break;
2835 case 0x07:
2836 INTn (line number);
2837 INT;
2838 case 0x08:
2839 break;
2840 case 0x0a:
2841 INTn (locked register);
2842 INT;
2843 break;
2844 case 0x3f:
2845 copy_till_end ();
2846 break;
2847 case 0x3e:
2848 copy_till_end ();
2849 break;
2850 case 0x40:
2851 copy_till_end ();
2852 break;
2853 case 0x41:
2855 break;
2860 static void
2861 f0_record (void)
2863 /* Attribute record. */
2864 NEXT ();
2865 OUT (0xf0);
2866 INTn (Symbol name);
2870 static void
2871 f2_record (void)
2873 NEXT ();
2874 OUT (0xf2);
2875 INT;
2876 NEXT ();
2877 OUT (0xce);
2878 INT;
2879 copy_till_end ();
2882 static void
2883 f8_record (void)
2885 int ch;
2886 NEXT ();
2887 ch = THIS ();
2888 switch (ch)
2890 case 0x01:
2891 case 0x02:
2892 case 0x03:
2893 /* Unique typedefs for module. */
2894 /* GLobal typedefs. */
2895 /* High level module scope beginning. */
2897 struct output_buffer_struct ob;
2899 NEXT ();
2900 OUT (0xf8);
2901 OUT (ch);
2902 drop_int (&ob);
2905 block ();
2907 NEXT ();
2908 fill_int (&ob);
2909 OUT (0xf9);
2911 break;
2912 case 0x04:
2913 /* Global function. */
2915 struct output_buffer_struct ob;
2917 NEXT ();
2918 OUT (0xf8);
2919 OUT (0x04);
2920 drop_int (&ob);
2922 INTn (stack size);
2923 INTn (ret val);
2924 EXPn (offset);
2926 block ();
2928 NEXT ();
2929 OUT (0xf9);
2930 EXPn (size of block);
2931 fill_int (&ob);
2933 break;
2935 case 0x05:
2936 /* File name for source line numbers. */
2938 struct output_buffer_struct ob;
2940 NEXT ();
2941 OUT (0xf8);
2942 OUT (0x05);
2943 drop_int (&ob);
2945 INTn (year);
2946 INTn (month);
2947 INTn (day);
2948 INTn (hour);
2949 INTn (monute);
2950 INTn (second);
2951 block ();
2952 NEXT ();
2953 OUT (0xf9);
2954 fill_int (&ob);
2956 break;
2958 case 0x06:
2959 /* Local function. */
2961 struct output_buffer_struct ob;
2963 NEXT ();
2964 OUT (0xf8);
2965 OUT (0x06);
2966 drop_int (&ob);
2968 INTn (stack size);
2969 INTn (type return);
2970 EXPn (offset);
2971 block ();
2972 NEXT ();
2973 OUT (0xf9);
2974 EXPn (size);
2975 fill_int (&ob);
2977 break;
2979 case 0x0a:
2980 /* Assembler module scope beginning - */
2982 struct output_buffer_struct ob;
2984 NEXT ();
2985 OUT (0xf8);
2986 OUT (0x0a);
2987 drop_int (&ob);
2990 INT;
2992 INT;
2993 INT;
2994 INT;
2995 INT;
2996 INT;
2997 INT;
2999 block ();
3001 NEXT ();
3002 OUT (0xf9);
3003 fill_int (&ob);
3005 break;
3006 case 0x0b:
3008 struct output_buffer_struct ob;
3010 NEXT ();
3011 OUT (0xf8);
3012 OUT (0x0b);
3013 drop_int (&ob);
3015 INT;
3016 INTn (section index);
3017 EXPn (offset);
3018 INTn (stuff);
3020 block ();
3022 OUT (0xf9);
3023 NEXT ();
3024 EXPn (Size in Maus);
3025 fill_int (&ob);
3027 break;
3031 static void
3032 e2_record (void)
3034 OUT (0xe2);
3035 NEXT ();
3036 OUT (0xce);
3037 NEXT ();
3038 INT;
3039 EXP;
3042 static void
3043 block (void)
3045 int ch;
3047 while (1)
3049 ch = THIS ();
3050 switch (ch)
3052 case 0xe1:
3053 case 0xe5:
3054 return;
3055 case 0xf9:
3056 return;
3057 case 0xf0:
3058 f0_record ();
3059 break;
3060 case 0xf1:
3061 f1_record ();
3062 break;
3063 case 0xf2:
3064 f2_record ();
3065 break;
3066 case 0xf8:
3067 f8_record ();
3068 break;
3069 case 0xe2:
3070 e2_record ();
3071 break;
3077 /* Moves all the debug information from the source bfd to the output
3078 bfd, and relocates any expressions it finds. */
3080 static void
3081 relocate_debug (bfd *output ATTRIBUTE_UNUSED,
3082 bfd *input)
3084 #define IBS 400
3085 #define OBS 400
3086 unsigned char input_buffer[IBS];
3088 input_ptr_start = input_ptr = input_buffer;
3089 input_ptr_end = input_buffer + IBS;
3090 input_bfd = input;
3091 /* FIXME: Check return value. I'm not sure whether it needs to read
3092 the entire buffer or not. */
3093 bfd_bread ((void *) input_ptr_start, (bfd_size_type) IBS, input);
3094 block ();
3097 /* Gather together all the debug information from each input BFD into
3098 one place, relocating it and emitting it as we go. */
3100 static bfd_boolean
3101 ieee_write_debug_part (bfd *abfd)
3103 ieee_data_type *ieee = IEEE_DATA (abfd);
3104 bfd_chain_type *chain = ieee->chain_root;
3105 unsigned char obuff[OBS];
3106 bfd_boolean some_debug = FALSE;
3107 file_ptr here = bfd_tell (abfd);
3109 output_ptr_start = output_ptr = obuff;
3110 output_ptr_end = obuff + OBS;
3111 output_ptr = obuff;
3112 output_bfd = abfd;
3114 if (chain == (bfd_chain_type *) NULL)
3116 asection *s;
3118 for (s = abfd->sections; s != NULL; s = s->next)
3119 if ((s->flags & SEC_DEBUGGING) != 0)
3120 break;
3121 if (s == NULL)
3123 ieee->w.r.debug_information_part = 0;
3124 return TRUE;
3127 ieee->w.r.debug_information_part = here;
3128 if (bfd_bwrite (s->contents, s->size, abfd) != s->size)
3129 return FALSE;
3131 else
3133 while (chain != (bfd_chain_type *) NULL)
3135 bfd *entry = chain->this;
3136 ieee_data_type *entry_ieee = IEEE_DATA (entry);
3138 if (entry_ieee->w.r.debug_information_part)
3140 if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
3141 SEEK_SET) != 0)
3142 return FALSE;
3143 relocate_debug (abfd, entry);
3146 chain = chain->next;
3149 if (some_debug)
3150 ieee->w.r.debug_information_part = here;
3151 else
3152 ieee->w.r.debug_information_part = 0;
3154 flush ();
3157 return TRUE;
3160 /* Write the data in an ieee way. */
3162 static bfd_boolean
3163 ieee_write_data_part (bfd *abfd)
3165 asection *s;
3167 ieee_data_type *ieee = IEEE_DATA (abfd);
3168 ieee->w.r.data_part = bfd_tell (abfd);
3170 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3172 /* Skip sections that have no loadable contents (.bss,
3173 debugging, etc.) */
3174 if ((s->flags & SEC_LOAD) == 0)
3175 continue;
3177 /* Sort the reloc records so we can insert them in the correct
3178 places. */
3179 if (s->reloc_count != 0)
3181 if (! do_with_relocs (abfd, s))
3182 return FALSE;
3184 else
3186 if (! do_without_relocs (abfd, s))
3187 return FALSE;
3191 return TRUE;
3194 static bfd_boolean
3195 init_for_output (bfd *abfd)
3197 asection *s;
3199 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3201 if ((s->flags & SEC_DEBUGGING) != 0)
3202 continue;
3203 if (s->size != 0)
3205 bfd_size_type size = s->size;
3206 ieee_per_section (s)->data = bfd_alloc (abfd, size);
3207 if (!ieee_per_section (s)->data)
3208 return FALSE;
3211 return TRUE;
3214 /* Exec and core file sections. */
3216 /* Set section contents is complicated with IEEE since the format is
3217 not a byte image, but a record stream. */
3219 static bfd_boolean
3220 ieee_set_section_contents (bfd *abfd,
3221 sec_ptr section,
3222 const void * location,
3223 file_ptr offset,
3224 bfd_size_type count)
3226 if ((section->flags & SEC_DEBUGGING) != 0)
3228 if (section->contents == NULL)
3230 bfd_size_type size = section->size;
3231 section->contents = bfd_alloc (abfd, size);
3232 if (section->contents == NULL)
3233 return FALSE;
3235 /* bfd_set_section_contents has already checked that everything
3236 is within range. */
3237 memcpy (section->contents + offset, location, (size_t) count);
3238 return TRUE;
3241 if (ieee_per_section (section)->data == (bfd_byte *) NULL)
3243 if (!init_for_output (abfd))
3244 return FALSE;
3246 memcpy ((void *) (ieee_per_section (section)->data + offset),
3247 (void *) location,
3248 (unsigned int) count);
3249 return TRUE;
3252 /* Write the external symbols of a file. IEEE considers two sorts of
3253 external symbols, public, and referenced. It uses to internal
3254 forms to index them as well. When we write them out we turn their
3255 symbol values into indexes from the right base. */
3257 static bfd_boolean
3258 ieee_write_external_part (bfd *abfd)
3260 asymbol **q;
3261 ieee_data_type *ieee = IEEE_DATA (abfd);
3262 unsigned int reference_index = IEEE_REFERENCE_BASE;
3263 unsigned int public_index = IEEE_PUBLIC_BASE + 2;
3264 file_ptr here = bfd_tell (abfd);
3265 bfd_boolean hadone = FALSE;
3267 if (abfd->outsymbols != (asymbol **) NULL)
3270 for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++)
3272 asymbol *p = *q;
3274 if (bfd_is_und_section (p->section))
3276 /* This must be a symbol reference. */
3277 if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3278 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3279 || ! ieee_write_id (abfd, p->name))
3280 return FALSE;
3281 p->value = reference_index;
3282 reference_index++;
3283 hadone = TRUE;
3285 else if (bfd_is_com_section (p->section))
3287 /* This is a weak reference. */
3288 if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3289 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3290 || ! ieee_write_id (abfd, p->name)
3291 || ! ieee_write_byte (abfd,
3292 ieee_weak_external_reference_enum)
3293 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3294 || ! ieee_write_int (abfd, p->value))
3295 return FALSE;
3296 p->value = reference_index;
3297 reference_index++;
3298 hadone = TRUE;
3300 else if (p->flags & BSF_GLOBAL)
3302 /* This must be a symbol definition. */
3303 if (! ieee_write_byte (abfd, ieee_external_symbol_enum)
3304 || ! ieee_write_int (abfd, (bfd_vma) public_index)
3305 || ! ieee_write_id (abfd, p->name)
3306 || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
3307 || ! ieee_write_int (abfd, (bfd_vma) public_index)
3308 || ! ieee_write_byte (abfd, 15) /* Instruction address. */
3309 || ! ieee_write_byte (abfd, 19) /* Static symbol. */
3310 || ! ieee_write_byte (abfd, 1)) /* One of them. */
3311 return FALSE;
3313 /* Write out the value. */
3314 if (! ieee_write_2bytes (abfd, ieee_value_record_enum)
3315 || ! ieee_write_int (abfd, (bfd_vma) public_index))
3316 return FALSE;
3317 if (! bfd_is_abs_section (p->section))
3319 if (abfd->flags & EXEC_P)
3321 /* If fully linked, then output all symbols
3322 relocated. */
3323 if (! (ieee_write_int
3324 (abfd,
3325 (p->value
3326 + p->section->output_offset
3327 + p->section->output_section->vma))))
3328 return FALSE;
3330 else
3332 if (! (ieee_write_expression
3333 (abfd,
3334 p->value + p->section->output_offset,
3335 p->section->output_section->symbol,
3336 FALSE, 0)))
3337 return FALSE;
3340 else
3342 if (! ieee_write_expression (abfd,
3343 p->value,
3344 bfd_abs_section_ptr->symbol,
3345 FALSE, 0))
3346 return FALSE;
3348 p->value = public_index;
3349 public_index++;
3350 hadone = TRUE;
3352 else
3354 /* This can happen - when there are gaps in the symbols read
3355 from an input ieee file. */
3359 if (hadone)
3360 ieee->w.r.external_part = here;
3362 return TRUE;
3366 static const unsigned char exten[] =
3368 0xf0, 0x20, 0x00,
3369 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3. */
3370 0xf1, 0xce, 0x20, 0x00, 39, 2, /* Keep symbol in original case. */
3371 0xf1, 0xce, 0x20, 0x00, 38 /* Set object type relocatable to x. */
3374 static const unsigned char envi[] =
3376 0xf0, 0x21, 0x00,
3378 /* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3379 0x19, 0x2c,
3381 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok. */
3383 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix. */
3384 /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
3387 static bfd_boolean
3388 ieee_write_me_part (bfd *abfd)
3390 ieee_data_type *ieee = IEEE_DATA (abfd);
3391 ieee->w.r.trailer_part = bfd_tell (abfd);
3392 if (abfd->start_address)
3394 if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum)
3395 || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum)
3396 || ! ieee_write_int (abfd, abfd->start_address)
3397 || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum))
3398 return FALSE;
3400 ieee->w.r.me_record = bfd_tell (abfd);
3401 if (! ieee_write_byte (abfd, ieee_module_end_enum))
3402 return FALSE;
3403 return TRUE;
3406 /* Write out the IEEE processor ID. */
3408 static bfd_boolean
3409 ieee_write_processor (bfd *abfd)
3411 const bfd_arch_info_type *arch;
3413 arch = bfd_get_arch_info (abfd);
3414 switch (arch->arch)
3416 default:
3417 if (! ieee_write_id (abfd, bfd_printable_name (abfd)))
3418 return FALSE;
3419 break;
3421 case bfd_arch_h8300:
3422 if (! ieee_write_id (abfd, "H8/300"))
3423 return FALSE;
3424 break;
3426 case bfd_arch_h8500:
3427 if (! ieee_write_id (abfd, "H8/500"))
3428 return FALSE;
3429 break;
3431 case bfd_arch_i960:
3432 switch (arch->mach)
3434 default:
3435 case bfd_mach_i960_core:
3436 case bfd_mach_i960_ka_sa:
3437 if (! ieee_write_id (abfd, "80960KA"))
3438 return FALSE;
3439 break;
3441 case bfd_mach_i960_kb_sb:
3442 if (! ieee_write_id (abfd, "80960KB"))
3443 return FALSE;
3444 break;
3446 case bfd_mach_i960_ca:
3447 if (! ieee_write_id (abfd, "80960CA"))
3448 return FALSE;
3449 break;
3451 case bfd_mach_i960_mc:
3452 case bfd_mach_i960_xa:
3453 if (! ieee_write_id (abfd, "80960MC"))
3454 return FALSE;
3455 break;
3457 break;
3459 case bfd_arch_m68k:
3461 const char *id;
3463 switch (arch->mach)
3465 default: id = "68020"; break;
3466 case bfd_mach_m68000: id = "68000"; break;
3467 case bfd_mach_m68008: id = "68008"; break;
3468 case bfd_mach_m68010: id = "68010"; break;
3469 case bfd_mach_m68020: id = "68020"; break;
3470 case bfd_mach_m68030: id = "68030"; break;
3471 case bfd_mach_m68040: id = "68040"; break;
3472 case bfd_mach_m68060: id = "68060"; break;
3473 case bfd_mach_cpu32: id = "cpu32"; break;
3474 case bfd_mach_mcf_isa_a_nodiv: id = "isa-a:nodiv"; break;
3475 case bfd_mach_mcf_isa_a: id = "isa-a"; break;
3476 case bfd_mach_mcf_isa_a_mac: id = "isa-a:mac"; break;
3477 case bfd_mach_mcf_isa_a_emac: id = "isa-a:emac"; break;
3478 case bfd_mach_mcf_isa_aplus: id = "isa-aplus"; break;
3479 case bfd_mach_mcf_isa_aplus_mac: id = "isa-aplus:mac"; break;
3480 case bfd_mach_mcf_isa_aplus_emac: id = "isa-aplus:mac"; break;
3481 case bfd_mach_mcf_isa_b_nousp: id = "isa-b:nousp"; break;
3482 case bfd_mach_mcf_isa_b_nousp_mac: id = "isa-b:nousp:mac"; break;
3483 case bfd_mach_mcf_isa_b_nousp_emac: id = "isa-b:nousp:emac"; break;
3484 case bfd_mach_mcf_isa_b: id = "isa-b"; break;
3485 case bfd_mach_mcf_isa_b_mac: id = "isa-b:mac"; break;
3486 case bfd_mach_mcf_isa_b_emac: id = "isa-b:emac"; break;
3487 case bfd_mach_mcf_isa_b_float: id = "isa-b:float"; break;
3488 case bfd_mach_mcf_isa_b_float_mac: id = "isa-b:float:mac"; break;
3489 case bfd_mach_mcf_isa_b_float_emac: id = "isa-b:float:emac"; break;
3492 if (! ieee_write_id (abfd, id))
3493 return FALSE;
3495 break;
3498 return TRUE;
3501 static bfd_boolean
3502 ieee_write_object_contents (bfd *abfd)
3504 ieee_data_type *ieee = IEEE_DATA (abfd);
3505 unsigned int i;
3506 file_ptr old;
3508 /* Fast forward over the header area. */
3509 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3510 return FALSE;
3512 if (! ieee_write_byte (abfd, ieee_module_beginning_enum)
3513 || ! ieee_write_processor (abfd)
3514 || ! ieee_write_id (abfd, abfd->filename))
3515 return FALSE;
3517 /* Fast forward over the variable bits. */
3518 if (! ieee_write_byte (abfd, ieee_address_descriptor_enum))
3519 return FALSE;
3521 /* Bits per MAU. */
3522 if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))))
3523 return FALSE;
3524 /* MAU's per address. */
3525 if (! ieee_write_byte (abfd,
3526 (bfd_byte) (bfd_arch_bits_per_address (abfd)
3527 / bfd_arch_bits_per_byte (abfd))))
3528 return FALSE;
3530 old = bfd_tell (abfd);
3531 if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
3532 return FALSE;
3534 ieee->w.r.extension_record = bfd_tell (abfd);
3535 if (bfd_bwrite ((char *) exten, (bfd_size_type) sizeof (exten), abfd)
3536 != sizeof (exten))
3537 return FALSE;
3538 if (abfd->flags & EXEC_P)
3540 if (! ieee_write_byte (abfd, 0x1)) /* Absolute. */
3541 return FALSE;
3543 else
3545 if (! ieee_write_byte (abfd, 0x2)) /* Relocateable. */
3546 return FALSE;
3549 ieee->w.r.environmental_record = bfd_tell (abfd);
3550 if (bfd_bwrite ((char *) envi, (bfd_size_type) sizeof (envi), abfd)
3551 != sizeof (envi))
3552 return FALSE;
3554 /* The HP emulator database requires a timestamp in the file. */
3556 time_t now;
3557 const struct tm *t;
3559 time (&now);
3560 t = (struct tm *) localtime (&now);
3561 if (! ieee_write_2bytes (abfd, (int) ieee_atn_record_enum)
3562 || ! ieee_write_byte (abfd, 0x21)
3563 || ! ieee_write_byte (abfd, 0)
3564 || ! ieee_write_byte (abfd, 50)
3565 || ! ieee_write_int (abfd, (bfd_vma) (t->tm_year + 1900))
3566 || ! ieee_write_int (abfd, (bfd_vma) (t->tm_mon + 1))
3567 || ! ieee_write_int (abfd, (bfd_vma) t->tm_mday)
3568 || ! ieee_write_int (abfd, (bfd_vma) t->tm_hour)
3569 || ! ieee_write_int (abfd, (bfd_vma) t->tm_min)
3570 || ! ieee_write_int (abfd, (bfd_vma) t->tm_sec))
3571 return FALSE;
3574 output_bfd = abfd;
3576 flush ();
3578 if (! ieee_write_section_part (abfd))
3579 return FALSE;
3580 /* First write the symbols. This changes their values into table
3581 indeces so we cant use it after this point. */
3582 if (! ieee_write_external_part (abfd))
3583 return FALSE;
3585 /* Write any debugs we have been told about. */
3586 if (! ieee_write_debug_part (abfd))
3587 return FALSE;
3589 /* Can only write the data once the symbols have been written, since
3590 the data contains relocation information which points to the
3591 symbols. */
3592 if (! ieee_write_data_part (abfd))
3593 return FALSE;
3595 /* At the end we put the end! */
3596 if (! ieee_write_me_part (abfd))
3597 return FALSE;
3599 /* Generate the header. */
3600 if (bfd_seek (abfd, old, SEEK_SET) != 0)
3601 return FALSE;
3603 for (i = 0; i < N_W_VARIABLES; i++)
3605 if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum)
3606 || ! ieee_write_byte (abfd, (bfd_byte) i)
3607 || ! ieee_write_int5_out (abfd, (bfd_vma) ieee->w.offset[i]))
3608 return FALSE;
3611 return TRUE;
3614 /* Native-level interface to symbols. */
3616 /* We read the symbols into a buffer, which is discarded when this
3617 function exits. We read the strings into a buffer large enough to
3618 hold them all plus all the cached symbol entries. */
3620 static asymbol *
3621 ieee_make_empty_symbol (bfd *abfd)
3623 bfd_size_type amt = sizeof (ieee_symbol_type);
3624 ieee_symbol_type *new = bfd_zalloc (abfd, amt);
3626 if (!new)
3627 return NULL;
3628 new->symbol.the_bfd = abfd;
3629 return &new->symbol;
3632 static bfd *
3633 ieee_openr_next_archived_file (bfd *arch, bfd *prev)
3635 ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
3637 /* Take the next one from the arch state, or reset. */
3638 if (prev == (bfd *) NULL)
3639 /* Reset the index - the first two entries are bogus. */
3640 ar->element_index = 2;
3642 while (TRUE)
3644 ieee_ar_obstack_type *p = ar->elements + ar->element_index;
3646 ar->element_index++;
3647 if (ar->element_index <= ar->element_count)
3649 if (p->file_offset != (file_ptr) 0)
3651 if (p->abfd == (bfd *) NULL)
3653 p->abfd = _bfd_create_empty_archive_element_shell (arch);
3654 p->abfd->origin = p->file_offset;
3656 return p->abfd;
3659 else
3661 bfd_set_error (bfd_error_no_more_archived_files);
3662 return NULL;
3667 static bfd_boolean
3668 ieee_find_nearest_line (bfd *abfd ATTRIBUTE_UNUSED,
3669 asection *section ATTRIBUTE_UNUSED,
3670 asymbol **symbols ATTRIBUTE_UNUSED,
3671 bfd_vma offset ATTRIBUTE_UNUSED,
3672 const char **filename_ptr ATTRIBUTE_UNUSED,
3673 const char **functionname_ptr ATTRIBUTE_UNUSED,
3674 unsigned int *line_ptr ATTRIBUTE_UNUSED)
3676 return FALSE;
3679 static bfd_boolean
3680 ieee_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3681 const char **filename_ptr ATTRIBUTE_UNUSED,
3682 const char **functionname_ptr ATTRIBUTE_UNUSED,
3683 unsigned int *line_ptr ATTRIBUTE_UNUSED)
3685 return FALSE;
3688 static int
3689 ieee_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
3691 ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL;
3692 ieee_data_type *ieee;
3694 if (abfd->my_archive != NULL)
3695 ar = abfd->my_archive->tdata.ieee_ar_data;
3696 if (ar == (ieee_ar_data_type *) NULL)
3698 bfd_set_error (bfd_error_invalid_operation);
3699 return -1;
3702 if (IEEE_DATA (abfd) == NULL)
3704 if (ieee_object_p (abfd) == NULL)
3706 bfd_set_error (bfd_error_wrong_format);
3707 return -1;
3711 ieee = IEEE_DATA (abfd);
3713 buf->st_size = ieee->w.r.me_record + 1;
3714 buf->st_mode = 0644;
3715 return 0;
3718 static int
3719 ieee_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
3720 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3722 return 0;
3725 #define ieee_close_and_cleanup _bfd_generic_close_and_cleanup
3726 #define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3728 #define ieee_slurp_armap bfd_true
3729 #define ieee_slurp_extended_name_table bfd_true
3730 #define ieee_construct_extended_name_table \
3731 ((bfd_boolean (*) \
3732 (bfd *, char **, bfd_size_type *, const char **)) \
3733 bfd_true)
3734 #define ieee_truncate_arname bfd_dont_truncate_arname
3735 #define ieee_write_armap \
3736 ((bfd_boolean (*) \
3737 (bfd *, unsigned int, struct orl *, unsigned int, int)) \
3738 bfd_true)
3739 #define ieee_read_ar_hdr bfd_nullvoidptr
3740 #define ieee_update_armap_timestamp bfd_true
3741 #define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
3743 #define ieee_bfd_is_target_special_symbol \
3744 ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
3745 #define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
3746 #define ieee_get_lineno _bfd_nosymbols_get_lineno
3747 #define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3748 #define ieee_read_minisymbols _bfd_generic_read_minisymbols
3749 #define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3751 #define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3752 #define ieee_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
3754 #define ieee_set_arch_mach _bfd_generic_set_arch_mach
3756 #define ieee_get_section_contents_in_window \
3757 _bfd_generic_get_section_contents_in_window
3758 #define ieee_bfd_get_relocated_section_contents \
3759 bfd_generic_get_relocated_section_contents
3760 #define ieee_bfd_relax_section bfd_generic_relax_section
3761 #define ieee_bfd_gc_sections bfd_generic_gc_sections
3762 #define ieee_bfd_merge_sections bfd_generic_merge_sections
3763 #define ieee_bfd_is_group_section bfd_generic_is_group_section
3764 #define ieee_bfd_discard_group bfd_generic_discard_group
3765 #define ieee_section_already_linked \
3766 _bfd_generic_section_already_linked
3767 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3768 #define ieee_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
3769 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
3770 #define ieee_bfd_link_just_syms _bfd_generic_link_just_syms
3771 #define ieee_bfd_final_link _bfd_generic_final_link
3772 #define ieee_bfd_link_split_section _bfd_generic_link_split_section
3774 const bfd_target ieee_vec =
3776 "ieee", /* Name. */
3777 bfd_target_ieee_flavour,
3778 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
3779 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
3780 (HAS_RELOC | EXEC_P | /* Object flags. */
3781 HAS_LINENO | HAS_DEBUG |
3782 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
3783 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
3784 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
3785 '_', /* Leading underscore. */
3786 ' ', /* AR_pad_char. */
3787 16, /* AR_max_namelen. */
3788 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3789 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3790 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
3791 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3792 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3793 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
3795 {_bfd_dummy_target,
3796 ieee_object_p, /* bfd_check_format. */
3797 ieee_archive_p,
3798 _bfd_dummy_target,
3801 bfd_false,
3802 ieee_mkobject,
3803 _bfd_generic_mkarchive,
3804 bfd_false
3807 bfd_false,
3808 ieee_write_object_contents,
3809 _bfd_write_archive_contents,
3810 bfd_false,
3813 /* ieee_close_and_cleanup, ieee_bfd_free_cached_info, ieee_new_section_hook,
3814 ieee_get_section_contents, ieee_get_section_contents_in_window. */
3815 BFD_JUMP_TABLE_GENERIC (ieee),
3817 BFD_JUMP_TABLE_COPY (_bfd_generic),
3818 BFD_JUMP_TABLE_CORE (_bfd_nocore),
3820 /* ieee_slurp_armap, ieee_slurp_extended_name_table,
3821 ieee_construct_extended_name_table, ieee_truncate_arname,
3822 ieee_write_armap, ieee_read_ar_hdr, ieee_openr_next_archived_file,
3823 ieee_get_elt_at_index, ieee_generic_stat_arch_elt,
3824 ieee_update_armap_timestamp. */
3825 BFD_JUMP_TABLE_ARCHIVE (ieee),
3827 /* ieee_get_symtab_upper_bound, ieee_canonicalize_symtab,
3828 ieee_make_empty_symbol, ieee_print_symbol, ieee_get_symbol_info,
3829 ieee_bfd_is_local_label_name, ieee_get_lineno,
3830 ieee_find_nearest_line, ieee_bfd_make_debug_symbol,
3831 ieee_read_minisymbols, ieee_minisymbol_to_symbol. */
3832 BFD_JUMP_TABLE_SYMBOLS (ieee),
3834 /* ieee_get_reloc_upper_bound, ieee_canonicalize_reloc,
3835 ieee_bfd_reloc_type_lookup. */
3836 BFD_JUMP_TABLE_RELOCS (ieee),
3838 /* ieee_set_arch_mach, ieee_set_section_contents. */
3839 BFD_JUMP_TABLE_WRITE (ieee),
3841 /* ieee_sizeof_headers, ieee_bfd_get_relocated_section_contents,
3842 ieee_bfd_relax_section, ieee_bfd_link_hash_table_create,
3843 _bfd_generic_link_hash_table_free,
3844 ieee_bfd_link_add_symbols, ieee_bfd_final_link,
3845 ieee_bfd_link_split_section, ieee_bfd_gc_sections,
3846 ieee_bfd_merge_sections. */
3847 BFD_JUMP_TABLE_LINK (ieee),
3849 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
3851 NULL,
3853 NULL