?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* elf64-alpha.c (elf64_alpha_relax_section): Ignore non-allocated
[binutils.git] / bfd / ieee.c
blobe2b0b6aeb856e60c7aa73d9dfbdcdf29354d9cb7
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
4 Free Software Foundation, Inc.
5
6 Written by Steve Chamberlain of Cygnus Support.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
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 2 of the License, or
13 (at your option) any later version.
14
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.
19
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, MA 02110-1301, USA. */
23
24 #define KEEPMINUSPCININST 0
25
26 /* IEEE 695 format is a stream of records, which we parse using a simple one-
27 token (which is one byte in this lexicon) lookahead recursive decent
28 parser. */
29
30 #include "bfd.h"
31 #include "sysdep.h"
32 #include "libbfd.h"
33 #include "ieee.h"
34 #include "libieee.h"
35 #include "safe-ctype.h"
36
37 struct output_buffer_struct
38 {
39 unsigned char *ptrp;
40 int buffer;
41 };
42
43 static unsigned char *output_ptr_start;
44 static unsigned char *output_ptr;
45 static unsigned char *output_ptr_end;
46 static unsigned char *input_ptr_start;
47 static unsigned char *input_ptr;
48 static unsigned char *input_ptr_end;
49 static bfd *input_bfd;
50 static bfd *output_bfd;
51 static int output_buffer;
52
53
54 static void block (void);
55
56 /* Functions for writing to ieee files in the strange way that the
57 standard requires. */
58
59 static bfd_boolean
60 ieee_write_byte (bfd *abfd, int barg)
61 {
62 bfd_byte byte;
63
64 byte = barg;
65 if (bfd_bwrite ((void *) &byte, (bfd_size_type) 1, abfd) != 1)
66 return FALSE;
67 return TRUE;
68 }
69
70 static bfd_boolean
71 ieee_write_2bytes (bfd *abfd, int bytes)
72 {
73 bfd_byte buffer[2];
74
75 buffer[0] = bytes >> 8;
76 buffer[1] = bytes & 0xff;
77 if (bfd_bwrite ((void *) buffer, (bfd_size_type) 2, abfd) != 2)
78 return FALSE;
79 return TRUE;
80 }
81
82 static bfd_boolean
83 ieee_write_int (bfd *abfd, bfd_vma value)
84 {
85 if (value <= 127)
86 {
87 if (! ieee_write_byte (abfd, (bfd_byte) value))
88 return FALSE;
89 }
90 else
91 {
92 unsigned int length;
93
94 /* How many significant bytes ? */
95 /* FIXME FOR LONGER INTS. */
96 if (value & 0xff000000)
97 length = 4;
98 else if (value & 0x00ff0000)
99 length = 3;
100 else if (value & 0x0000ff00)
101 length = 2;
102 else
103 length = 1;
104
105 if (! ieee_write_byte (abfd,
106 (bfd_byte) ((int) ieee_number_repeat_start_enum
107 + length)))
108 return FALSE;
109 switch (length)
110 {
111 case 4:
112 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24)))
113 return FALSE;
114 /* Fall through. */
115 case 3:
116 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16)))
117 return FALSE;
118 /* Fall through. */
119 case 2:
120 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8)))
121 return FALSE;
122 /* Fall through. */
123 case 1:
124 if (! ieee_write_byte (abfd, (bfd_byte) (value)))
125 return FALSE;
126 }
127 }
128
129 return TRUE;
130 }
131
132 static bfd_boolean
133 ieee_write_id (bfd *abfd, const char *id)
134 {
135 size_t length = strlen (id);
136
137 if (length <= 127)
138 {
139 if (! ieee_write_byte (abfd, (bfd_byte) length))
140 return FALSE;
141 }
142 else if (length < 255)
143 {
144 if (! ieee_write_byte (abfd, ieee_extension_length_1_enum)
145 || ! ieee_write_byte (abfd, (bfd_byte) length))
146 return FALSE;
147 }
148 else if (length < 65535)
149 {
150 if (! ieee_write_byte (abfd, ieee_extension_length_2_enum)
151 || ! ieee_write_2bytes (abfd, (int) length))
152 return FALSE;
153 }
154 else
155 {
156 (*_bfd_error_handler)
157 (_("%s: string too long (%d chars, max 65535)"),
158 bfd_get_filename (abfd), length);
159 bfd_set_error (bfd_error_invalid_operation);
160 return FALSE;
161 }
162
163 if (bfd_bwrite ((void *) id, (bfd_size_type) length, abfd) != length)
164 return FALSE;
165 return TRUE;
166 }
167 \f
168 /* Functions for reading from ieee files in the strange way that the
169 standard requires. */
170
171 #define this_byte(ieee) *((ieee)->input_p)
172 #define next_byte(ieee) ((ieee)->input_p++)
173 #define this_byte_and_next(ieee) (*((ieee)->input_p++))
174
175 static unsigned short
176 read_2bytes (common_header_type *ieee)
177 {
178 unsigned char c1 = this_byte_and_next (ieee);
179 unsigned char c2 = this_byte_and_next (ieee);
180
181 return (c1 << 8) | c2;
182 }
183
184 static void
185 bfd_get_string (common_header_type *ieee, char *string, size_t length)
186 {
187 size_t i;
188
189 for (i = 0; i < length; i++)
190 string[i] = this_byte_and_next (ieee);
191 }
192
193 static char *
194 read_id (common_header_type *ieee)
195 {
196 size_t length;
197 char *string;
198
199 length = this_byte_and_next (ieee);
200 if (length <= 0x7f)
201 /* Simple string of length 0 to 127. */
202 ;
203
204 else if (length == 0xde)
205 /* Length is next byte, allowing 0..255. */
206 length = this_byte_and_next (ieee);
207
208 else if (length == 0xdf)
209 {
210 /* Length is next two bytes, allowing 0..65535. */
211 length = this_byte_and_next (ieee);
212 length = (length * 256) + this_byte_and_next (ieee);
213 }
214
215 /* Buy memory and read string. */
216 string = bfd_alloc (ieee->abfd, (bfd_size_type) length + 1);
217 if (!string)
218 return NULL;
219 bfd_get_string (ieee, string, length);
220 string[length] = 0;
221 return string;
222 }
223
224 static bfd_boolean
225 ieee_write_expression (bfd *abfd,
226 bfd_vma value,
227 asymbol *symbol,
228 bfd_boolean pcrel,
229 unsigned int index)
230 {
231 unsigned int term_count = 0;
232
233 if (value != 0)
234 {
235 if (! ieee_write_int (abfd, value))
236 return FALSE;
237 term_count++;
238 }
239
240 /* Badly formatted binaries can have a missing symbol,
241 so test here to prevent a seg fault. */
242 if (symbol != NULL)
243 {
244 if (bfd_is_com_section (symbol->section)
245 || bfd_is_und_section (symbol->section))
246 {
247 /* Def of a common symbol. */
248 if (! ieee_write_byte (abfd, ieee_variable_X_enum)
249 || ! ieee_write_int (abfd, symbol->value))
250 return FALSE;
251 term_count ++;
252 }
253 else if (! bfd_is_abs_section (symbol->section))
254 {
255 /* Ref to defined symbol - */
256 if (symbol->flags & BSF_GLOBAL)
257 {
258 if (! ieee_write_byte (abfd, ieee_variable_I_enum)
259 || ! ieee_write_int (abfd, symbol->value))
260 return FALSE;
261 term_count++;
262 }
263 else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM))
264 {
265 /* This is a reference to a defined local symbol. We can
266 easily do a local as a section+offset. */
267 if (! ieee_write_byte (abfd, ieee_variable_R_enum)
268 || ! ieee_write_byte (abfd,
269 (bfd_byte) (symbol->section->index
270 + IEEE_SECTION_NUMBER_BASE)))
271 return FALSE;
272
273 term_count++;
274 if (symbol->value != 0)
275 {
276 if (! ieee_write_int (abfd, symbol->value))
277 return FALSE;
278 term_count++;
279 }
280 }
281 else
282 {
283 (*_bfd_error_handler)
284 (_("%s: unrecognized symbol `%s' flags 0x%x"),
285 bfd_get_filename (abfd), bfd_asymbol_name (symbol),
286 symbol->flags);
287 bfd_set_error (bfd_error_invalid_operation);
288 return FALSE;
289 }
290 }
291 }
292
293 if (pcrel)
294 {
295 /* Subtract the pc from here by asking for PC of this section. */
296 if (! ieee_write_byte (abfd, ieee_variable_P_enum)
297 || ! ieee_write_byte (abfd,
298 (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE))
299 || ! ieee_write_byte (abfd, ieee_function_minus_enum))
300 return FALSE;
301 }
302
303 /* Handle the degenerate case of a 0 address. */
304 if (term_count == 0)
305 if (! ieee_write_int (abfd, (bfd_vma) 0))
306 return FALSE;
307
308 while (term_count > 1)
309 {
310 if (! ieee_write_byte (abfd, ieee_function_plus_enum))
311 return FALSE;
312 term_count--;
313 }
314
315 return TRUE;
316 }
317 \f
318 /* Writes any integer into the buffer supplied and always takes 5 bytes. */
319
320 static void
321 ieee_write_int5 (bfd_byte *buffer, bfd_vma value)
322 {
323 buffer[0] = (bfd_byte) ieee_number_repeat_4_enum;
324 buffer[1] = (value >> 24) & 0xff;
325 buffer[2] = (value >> 16) & 0xff;
326 buffer[3] = (value >> 8) & 0xff;
327 buffer[4] = (value >> 0) & 0xff;
328 }
329
330 static bfd_boolean
331 ieee_write_int5_out (bfd *abfd, bfd_vma value)
332 {
333 bfd_byte b[5];
334
335 ieee_write_int5 (b, value);
336 if (bfd_bwrite ((void *) b, (bfd_size_type) 5, abfd) != 5)
337 return FALSE;
338 return TRUE;
339 }
340
341 static bfd_boolean
342 parse_int (common_header_type *ieee, bfd_vma *value_ptr)
343 {
344 int value = this_byte (ieee);
345 int result;
346
347 if (value >= 0 && value <= 127)
348 {
349 *value_ptr = value;
350 next_byte (ieee);
351 return TRUE;
352 }
353 else if (value >= 0x80 && value <= 0x88)
354 {
355 unsigned int count = value & 0xf;
356
357 result = 0;
358 next_byte (ieee);
359 while (count)
360 {
361 result = (result << 8) | this_byte_and_next (ieee);
362 count--;
363 }
364 *value_ptr = result;
365 return TRUE;
366 }
367 return FALSE;
368 }
369
370 static int
371 parse_i (common_header_type *ieee, bfd_boolean *ok)
372 {
373 bfd_vma x;
374 *ok = parse_int (ieee, &x);
375 return x;
376 }
377
378 static bfd_vma
379 must_parse_int (common_header_type *ieee)
380 {
381 bfd_vma result;
382 BFD_ASSERT (parse_int (ieee, &result));
383 return result;
384 }
385
386 typedef struct
387 {
388 bfd_vma value;
389 asection *section;
390 ieee_symbol_index_type symbol;
391 } ieee_value_type;
392
393
394 #if KEEPMINUSPCININST
395
396 #define SRC_MASK(arg) arg
397 #define PCREL_OFFSET FALSE
398
399 #else
400
401 #define SRC_MASK(arg) 0
402 #define PCREL_OFFSET TRUE
403
404 #endif
405
406 static reloc_howto_type abs32_howto =
407 HOWTO (1,
408 0,
409 2,
410 32,
411 FALSE,
412 0,
413 complain_overflow_bitfield,
414 0,
415 "abs32",
416 TRUE,
417 0xffffffff,
418 0xffffffff,
419 FALSE);
420
421 static reloc_howto_type abs16_howto =
422 HOWTO (1,
423 0,
424 1,
425 16,
426 FALSE,
427 0,
428 complain_overflow_bitfield,
429 0,
430 "abs16",
431 TRUE,
432 0x0000ffff,
433 0x0000ffff,
434 FALSE);
435
436 static reloc_howto_type abs8_howto =
437 HOWTO (1,
438 0,
439 0,
440 8,
441 FALSE,
442 0,
443 complain_overflow_bitfield,
444 0,
445 "abs8",
446 TRUE,
447 0x000000ff,
448 0x000000ff,
449 FALSE);
450
451 static reloc_howto_type rel32_howto =
452 HOWTO (1,
453 0,
454 2,
455 32,
456 TRUE,
457 0,
458 complain_overflow_signed,
459 0,
460 "rel32",
461 TRUE,
462 SRC_MASK (0xffffffff),
463 0xffffffff,
464 PCREL_OFFSET);
465
466 static reloc_howto_type rel16_howto =
467 HOWTO (1,
468 0,
469 1,
470 16,
471 TRUE,
472 0,
473 complain_overflow_signed,
474 0,
475 "rel16",
476 TRUE,
477 SRC_MASK (0x0000ffff),
478 0x0000ffff,
479 PCREL_OFFSET);
480
481 static reloc_howto_type rel8_howto =
482 HOWTO (1,
483 0,
484 0,
485 8,
486 TRUE,
487 0,
488 complain_overflow_signed,
489 0,
490 "rel8",
491 TRUE,
492 SRC_MASK (0x000000ff),
493 0x000000ff,
494 PCREL_OFFSET);
495
496 static ieee_symbol_index_type NOSYMBOL = {0, 0};
497
498 static void
499 parse_expression (ieee_data_type *ieee,
500 bfd_vma *value,
501 ieee_symbol_index_type *symbol,
502 bfd_boolean *pcrel,
503 unsigned int *extra,
504 asection **section)
505
506 {
507 bfd_boolean loop = TRUE;
508 ieee_value_type stack[10];
509 ieee_value_type *sp = stack;
510 asection *dummy;
511
512 #define POS sp[1]
513 #define TOS sp[0]
514 #define NOS sp[-1]
515 #define INC sp++;
516 #define DEC sp--;
517
518 /* The stack pointer always points to the next unused location. */
519 #define PUSH(x,y,z) TOS.symbol = x; TOS.section = y; TOS.value = z; INC;
520 #define POP(x,y,z) DEC; x = TOS.symbol; y = TOS.section; z = TOS.value;
521
522 while (loop && ieee->h.input_p < ieee->h.last_byte)
523 {
524 switch (this_byte (&(ieee->h)))
525 {
526 case ieee_variable_P_enum:
527 /* P variable, current program counter for section n. */
528 {
529 int section_n;
530
531 next_byte (&(ieee->h));
532 *pcrel = TRUE;
533 section_n = must_parse_int (&(ieee->h));
534 PUSH (NOSYMBOL, bfd_abs_section_ptr, 0);
535 break;
536 }
537 case ieee_variable_L_enum:
538 /* L variable address of section N. */
539 next_byte (&(ieee->h));
540 PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
541 break;
542 case ieee_variable_R_enum:
543 /* R variable, logical address of section module. */
544 /* FIXME, this should be different to L. */
545 next_byte (&(ieee->h));
546 PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
547 break;
548 case ieee_variable_S_enum:
549 /* S variable, size in MAUS of section module. */
550 next_byte (&(ieee->h));
551 PUSH (NOSYMBOL,
552 0,
553 ieee->section_table[must_parse_int (&(ieee->h))]->size);
554 break;
555 case ieee_variable_I_enum:
556 /* Push the address of variable n. */
557 {
558 ieee_symbol_index_type sy;
559
560 next_byte (&(ieee->h));
561 sy.index = (int) must_parse_int (&(ieee->h));
562 sy.letter = 'I';
563
564 PUSH (sy, bfd_abs_section_ptr, 0);
565 }
566 break;
567 case ieee_variable_X_enum:
568 /* Push the address of external variable n. */
569 {
570 ieee_symbol_index_type sy;
571
572 next_byte (&(ieee->h));
573 sy.index = (int) (must_parse_int (&(ieee->h)));
574 sy.letter = 'X';
575
576 PUSH (sy, bfd_und_section_ptr, 0);
577 }
578 break;
579 case ieee_function_minus_enum:
580 {
581 bfd_vma value1, value2;
582 asection *section1, *section_dummy;
583 ieee_symbol_index_type sy;
584
585 next_byte (&(ieee->h));
586
587 POP (sy, section1, value1);
588 POP (sy, section_dummy, value2);
589 PUSH (sy, section1 ? section1 : section_dummy, value2 - value1);
590 }
591 break;
592 case ieee_function_plus_enum:
593 {
594 bfd_vma value1, value2;
595 asection *section1;
596 asection *section2;
597 ieee_symbol_index_type sy1;
598 ieee_symbol_index_type sy2;
599
600 next_byte (&(ieee->h));
601
602 POP (sy1, section1, value1);
603 POP (sy2, section2, value2);
604 PUSH (sy1.letter ? sy1 : sy2,
605 bfd_is_abs_section (section1) ? section2 : section1,
606 value1 + value2);
607 }
608 break;
609 default:
610 {
611 bfd_vma va;
612
613 BFD_ASSERT (this_byte (&(ieee->h)) < (int) ieee_variable_A_enum
614 || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum);
615 if (parse_int (&(ieee->h), &va))
616 {
617 PUSH (NOSYMBOL, bfd_abs_section_ptr, va);
618 }
619 else
620 /* Thats all that we can understand. */
621 loop = FALSE;
622 }
623 }
624 }
625
626 /* As far as I can see there is a bug in the Microtec IEEE output
627 which I'm using to scan, whereby the comma operator is omitted
628 sometimes in an expression, giving expressions with too many
629 terms. We can tell if that's the case by ensuring that
630 sp == stack here. If not, then we've pushed something too far,
631 so we keep adding. */
632 while (sp != stack + 1)
633 {
634 asection *section1;
635 ieee_symbol_index_type sy1;
636
637 POP (sy1, section1, *extra);
638 }
639
640 POP (*symbol, dummy, *value);
641 if (section)
642 *section = dummy;
643 }
644
645
646 #define ieee_seek(ieee, offset) \
647 do \
648 { \
649 ieee->h.input_p = ieee->h.first_byte + offset; \
650 ieee->h.last_byte = (ieee->h.first_byte \
651 + ieee_part_after (ieee, offset)); \
652 } \
653 while (0)
654
655 #define ieee_pos(ieee) \
656 (ieee->h.input_p - ieee->h.first_byte)
657
658 /* Find the first part of the ieee file after HERE. */
659
660 static file_ptr
661 ieee_part_after (ieee_data_type *ieee, file_ptr here)
662 {
663 int part;
664 file_ptr after = ieee->w.r.me_record;
665
666 /* File parts can come in any order, except that module end is
667 guaranteed to be last (and the header first). */
668 for (part = 0; part < N_W_VARIABLES; part++)
669 if (ieee->w.offset[part] > here && after > ieee->w.offset[part])
670 after = ieee->w.offset[part];
671
672 return after;
673 }
674
675 static unsigned int last_index;
676 static char last_type; /* Is the index for an X or a D. */
677
678 static ieee_symbol_type *
679 get_symbol (bfd *abfd ATTRIBUTE_UNUSED,
680 ieee_data_type *ieee,
681 ieee_symbol_type *last_symbol,
682 unsigned int *symbol_count,
683 ieee_symbol_type ***pptr,
684 unsigned int *max_index,
685 int this_type)
686 {
687 /* Need a new symbol. */
688 unsigned int new_index = must_parse_int (&(ieee->h));
689
690 if (new_index != last_index || this_type != last_type)
691 {
692 ieee_symbol_type *new_symbol;
693 bfd_size_type amt = sizeof (ieee_symbol_type);
694
695 new_symbol = bfd_alloc (ieee->h.abfd, amt);
696 if (!new_symbol)
697 return NULL;
698
699 new_symbol->index = new_index;
700 last_index = new_index;
701 (*symbol_count)++;
702 **pptr = new_symbol;
703 *pptr = &new_symbol->next;
704 if (new_index > *max_index)
705 *max_index = new_index;
706
707 last_type = this_type;
708 new_symbol->symbol.section = bfd_abs_section_ptr;
709 return new_symbol;
710 }
711 return last_symbol;
712 }
713
714 static bfd_boolean
715 ieee_slurp_external_symbols (bfd *abfd)
716 {
717 ieee_data_type *ieee = IEEE_DATA (abfd);
718 file_ptr offset = ieee->w.r.external_part;
719
720 ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols;
721 ieee_symbol_type **prev_reference_ptr = &ieee->external_reference;
722 ieee_symbol_type *symbol = NULL;
723 unsigned int symbol_count = 0;
724 bfd_boolean loop = TRUE;
725
726 last_index = 0xffffff;
727 ieee->symbol_table_full = TRUE;
728
729 ieee_seek (ieee, offset);
730
731 while (loop)
732 {
733 switch (this_byte (&(ieee->h)))
734 {
735 case ieee_nn_record:
736 next_byte (&(ieee->h));
737
738 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
739 & prev_symbols_ptr,
740 & ieee->external_symbol_max_index, 'I');
741 if (symbol == NULL)
742 return FALSE;
743
744 symbol->symbol.the_bfd = abfd;
745 symbol->symbol.name = read_id (&(ieee->h));
746 symbol->symbol.udata.p = NULL;
747 symbol->symbol.flags = BSF_NO_FLAGS;
748 break;
749 case ieee_external_symbol_enum:
750 next_byte (&(ieee->h));
751
752 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
753 &prev_symbols_ptr,
754 &ieee->external_symbol_max_index, 'D');
755 if (symbol == NULL)
756 return FALSE;
757
758 BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
759
760 symbol->symbol.the_bfd = abfd;
761 symbol->symbol.name = read_id (&(ieee->h));
762 symbol->symbol.udata.p = NULL;
763 symbol->symbol.flags = BSF_NO_FLAGS;
764 break;
765 case ieee_attribute_record_enum >> 8:
766 {
767 unsigned int symbol_name_index;
768 unsigned int symbol_type_index;
769 unsigned int symbol_attribute_def;
770 bfd_vma value;
771
772 switch (read_2bytes (&ieee->h))
773 {
774 case ieee_attribute_record_enum:
775 symbol_name_index = must_parse_int (&(ieee->h));
776 symbol_type_index = must_parse_int (&(ieee->h));
777 symbol_attribute_def = must_parse_int (&(ieee->h));
778 switch (symbol_attribute_def)
779 {
780 case 8:
781 case 19:
782 parse_int (&ieee->h, &value);
783 break;
784 default:
785 (*_bfd_error_handler)
786 (_("%B: unimplemented ATI record %u for symbol %u"),
787 abfd, symbol_attribute_def, symbol_name_index);
788 bfd_set_error (bfd_error_bad_value);
789 return FALSE;
790 break;
791 }
792 break;
793 case ieee_external_reference_info_record_enum:
794 /* Skip over ATX record. */
795 parse_int (&(ieee->h), &value);
796 parse_int (&(ieee->h), &value);
797 parse_int (&(ieee->h), &value);
798 parse_int (&(ieee->h), &value);
799 break;
800 case ieee_atn_record_enum:
801 /* We may get call optimization information here,
802 which we just ignore. The format is
803 {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs}. */
804 parse_int (&ieee->h, &value);
805 parse_int (&ieee->h, &value);
806 parse_int (&ieee->h, &value);
807 if (value != 0x3f)
808 {
809 (*_bfd_error_handler)
810 (_("%B: unexpected ATN type %d in external part"),
811 abfd, (int) value);
812 bfd_set_error (bfd_error_bad_value);
813 return FALSE;
814 }
815 parse_int (&ieee->h, &value);
816 parse_int (&ieee->h, &value);
817 while (value > 0)
818 {
819 bfd_vma val1;
820
821 --value;
822
823 switch (read_2bytes (&ieee->h))
824 {
825 case ieee_asn_record_enum:
826 parse_int (&ieee->h, &val1);
827 parse_int (&ieee->h, &val1);
828 break;
829
830 default:
831 (*_bfd_error_handler)
832 (_("%B: unexpected type after ATN"), abfd);
833 bfd_set_error (bfd_error_bad_value);
834 return FALSE;
835 }
836 }
837 }
838 }
839 break;
840 case ieee_value_record_enum >> 8:
841 {
842 unsigned int symbol_name_index;
843 ieee_symbol_index_type symbol_ignore;
844 bfd_boolean pcrel_ignore;
845 unsigned int extra;
846
847 next_byte (&(ieee->h));
848 next_byte (&(ieee->h));
849
850 symbol_name_index = must_parse_int (&(ieee->h));
851 parse_expression (ieee,
852 &symbol->symbol.value,
853 &symbol_ignore,
854 &pcrel_ignore,
855 &extra,
856 &symbol->symbol.section);
857
858 /* Fully linked IEEE-695 files tend to give every symbol
859 an absolute value. Try to convert that back into a
860 section relative value. FIXME: This won't always to
861 the right thing. */
862 if (bfd_is_abs_section (symbol->symbol.section)
863 && (abfd->flags & HAS_RELOC) == 0)
864 {
865 bfd_vma val;
866 asection *s;
867
868 val = symbol->symbol.value;
869 for (s = abfd->sections; s != NULL; s = s->next)
870 {
871 if (val >= s->vma && val < s->vma + s->size)
872 {
873 symbol->symbol.section = s;
874 symbol->symbol.value -= s->vma;
875 break;
876 }
877 }
878 }
879
880 symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
881
882 }
883 break;
884 case ieee_weak_external_reference_enum:
885 {
886 bfd_vma size;
887 bfd_vma value;
888
889 next_byte (&(ieee->h));
890 /* Throw away the external reference index. */
891 (void) must_parse_int (&(ieee->h));
892 /* Fetch the default size if not resolved. */
893 size = must_parse_int (&(ieee->h));
894 /* Fetch the default value if available. */
895 if (! parse_int (&(ieee->h), &value))
896 value = 0;
897 /* This turns into a common. */
898 symbol->symbol.section = bfd_com_section_ptr;
899 symbol->symbol.value = size;
900 }
901 break;
902
903 case ieee_external_reference_enum:
904 next_byte (&(ieee->h));
905
906 symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
907 &prev_reference_ptr,
908 &ieee->external_reference_max_index, 'X');
909 if (symbol == NULL)
910 return FALSE;
911
912 symbol->symbol.the_bfd = abfd;
913 symbol->symbol.name = read_id (&(ieee->h));
914 symbol->symbol.udata.p = NULL;
915 symbol->symbol.section = bfd_und_section_ptr;
916 symbol->symbol.value = (bfd_vma) 0;
917 symbol->symbol.flags = 0;
918
919 BFD_ASSERT (symbol->index >= ieee->external_reference_min_index);
920 break;
921
922 default:
923 loop = FALSE;
924 }
925 }
926
927 if (ieee->external_symbol_max_index != 0)
928 {
929 ieee->external_symbol_count =
930 ieee->external_symbol_max_index -
931 ieee->external_symbol_min_index + 1;
932 }
933 else
934 ieee->external_symbol_count = 0;
935
936 if (ieee->external_reference_max_index != 0)
937 {
938 ieee->external_reference_count =
939 ieee->external_reference_max_index -
940 ieee->external_reference_min_index + 1;
941 }
942 else
943 ieee->external_reference_count = 0;
944
945 abfd->symcount =
946 ieee->external_reference_count + ieee->external_symbol_count;
947
948 if (symbol_count != abfd->symcount)
949 /* There are gaps in the table -- */
950 ieee->symbol_table_full = FALSE;
951
952 *prev_symbols_ptr = NULL;
953 *prev_reference_ptr = NULL;
954
955 return TRUE;
956 }
957
958 static bfd_boolean
959 ieee_slurp_symbol_table (bfd *abfd)
960 {
961 if (! IEEE_DATA (abfd)->read_symbols)
962 {
963 if (! ieee_slurp_external_symbols (abfd))
964 return FALSE;
965 IEEE_DATA (abfd)->read_symbols = TRUE;
966 }
967 return TRUE;
968 }
969
970 static long
971 ieee_get_symtab_upper_bound (bfd *abfd)
972 {
973 if (! ieee_slurp_symbol_table (abfd))
974 return -1;
975
976 return (abfd->symcount != 0) ?
977 (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0;
978 }
979
980 /* Move from our internal lists to the canon table, and insert in
981 symbol index order. */
982
983 extern const bfd_target ieee_vec;
984
985 static long
986 ieee_canonicalize_symtab (bfd *abfd, asymbol **location)
987 {
988 ieee_symbol_type *symp;
989 static bfd dummy_bfd;
990 static asymbol empty_symbol =
991 {
992 &dummy_bfd,
993 " ieee empty",
994 (symvalue) 0,
995 BSF_DEBUGGING,
996 bfd_abs_section_ptr
997 #ifdef __STDC__
998 /* K&R compilers can't initialise unions. */
999 , { 0 }
1000 #endif
1001 };
1002
1003 if (abfd->symcount)
1004 {
1005 ieee_data_type *ieee = IEEE_DATA (abfd);
1006
1007 dummy_bfd.xvec = &ieee_vec;
1008 if (! ieee_slurp_symbol_table (abfd))
1009 return -1;
1010
1011 if (! ieee->symbol_table_full)
1012 {
1013 /* Arrgh - there are gaps in the table, run through and fill them
1014 up with pointers to a null place. */
1015 unsigned int i;
1016
1017 for (i = 0; i < abfd->symcount; i++)
1018 location[i] = &empty_symbol;
1019 }
1020
1021 ieee->external_symbol_base_offset = -ieee->external_symbol_min_index;
1022 for (symp = IEEE_DATA (abfd)->external_symbols;
1023 symp != (ieee_symbol_type *) NULL;
1024 symp = symp->next)
1025 /* Place into table at correct index locations. */
1026 location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
1027
1028 /* The external refs are indexed in a bit. */
1029 ieee->external_reference_base_offset =
1030 -ieee->external_reference_min_index + ieee->external_symbol_count;
1031
1032 for (symp = IEEE_DATA (abfd)->external_reference;
1033 symp != (ieee_symbol_type *) NULL;
1034 symp = symp->next)
1035 location[symp->index + ieee->external_reference_base_offset] =
1036 &symp->symbol;
1037 }
1038
1039 if (abfd->symcount)
1040 location[abfd->symcount] = (asymbol *) NULL;
1041
1042 return abfd->symcount;
1043 }
1044
1045 static asection *
1046 get_section_entry (bfd *abfd, ieee_data_type *ieee, unsigned int index)
1047 {
1048 if (index >= ieee->section_table_size)
1049 {
1050 unsigned int c, i;
1051 asection **n;
1052 bfd_size_type amt;
1053
1054 c = ieee->section_table_size;
1055 if (c == 0)
1056 c = 20;
1057 while (c <= index)
1058 c *= 2;
1059
1060 amt = c;
1061 amt *= sizeof (asection *);
1062 n = bfd_realloc (ieee->section_table, amt);
1063 if (n == NULL)
1064 return NULL;
1065
1066 for (i = ieee->section_table_size; i < c; i++)
1067 n[i] = NULL;
1068
1069 ieee->section_table = n;
1070 ieee->section_table_size = c;
1071 }
1072
1073 if (ieee->section_table[index] == (asection *) NULL)
1074 {
1075 char *tmp = bfd_alloc (abfd, (bfd_size_type) 11);
1076 asection *section;
1077
1078 if (!tmp)
1079 return NULL;
1080 sprintf (tmp, " fsec%4d", index);
1081 section = bfd_make_section (abfd, tmp);
1082 ieee->section_table[index] = section;
1083 section->flags = SEC_NO_FLAGS;
1084 section->target_index = index;
1085 ieee->section_table[index] = section;
1086 }
1087 return ieee->section_table[index];
1088 }
1089
1090 static void
1091 ieee_slurp_sections (bfd *abfd)
1092 {
1093 ieee_data_type *ieee = IEEE_DATA (abfd);
1094 file_ptr offset = ieee->w.r.section_part;
1095 char *name;
1096
1097 if (offset != 0)
1098 {
1099 bfd_byte section_type[3];
1100
1101 ieee_seek (ieee, offset);
1102 while (TRUE)
1103 {
1104 switch (this_byte (&(ieee->h)))
1105 {
1106 case ieee_section_type_enum:
1107 {
1108 asection *section;
1109 unsigned int section_index;
1110
1111 next_byte (&(ieee->h));
1112 section_index = must_parse_int (&(ieee->h));
1113
1114 section = get_section_entry (abfd, ieee, section_index);
1115
1116 section_type[0] = this_byte_and_next (&(ieee->h));
1117
1118 /* Set minimal section attributes. Attributes are
1119 extended later, based on section contents. */
1120 switch (section_type[0])
1121 {
1122 case 0xC1:
1123 /* Normal attributes for absolute sections. */
1124 section_type[1] = this_byte (&(ieee->h));
1125 section->flags = SEC_ALLOC;
1126 switch (section_type[1])
1127 {
1128 /* AS Absolute section attributes. */
1129 case 0xD3:
1130 next_byte (&(ieee->h));
1131 section_type[2] = this_byte (&(ieee->h));
1132 switch (section_type[2])
1133 {
1134 case 0xD0:
1135 /* Normal code. */
1136 next_byte (&(ieee->h));
1137 section->flags |= SEC_CODE;
1138 break;
1139 case 0xC4:
1140 /* Normal data. */
1141 next_byte (&(ieee->h));
1142 section->flags |= SEC_DATA;
1143 break;
1144 case 0xD2:
1145 next_byte (&(ieee->h));
1146 /* Normal rom data. */
1147 section->flags |= SEC_ROM | SEC_DATA;
1148 break;
1149 default:
1150 break;
1151 }
1152 }
1153 break;
1154
1155 /* Named relocatable sections (type C). */
1156 case 0xC3:
1157 section_type[1] = this_byte (&(ieee->h));
1158 section->flags = SEC_ALLOC;
1159 switch (section_type[1])
1160 {
1161 case 0xD0: /* Normal code (CP). */
1162 next_byte (&(ieee->h));
1163 section->flags |= SEC_CODE;
1164 break;
1165 case 0xC4: /* Normal data (CD). */
1166 next_byte (&(ieee->h));
1167 section->flags |= SEC_DATA;
1168 break;
1169 case 0xD2: /* Normal rom data (CR). */
1170 next_byte (&(ieee->h));
1171 section->flags |= SEC_ROM | SEC_DATA;
1172 break;
1173 default:
1174 break;
1175 }
1176 }
1177
1178 /* Read section name, use it if non empty. */
1179 name = read_id (&ieee->h);
1180 if (name[0])
1181 section->name = name;
1182
1183 /* Skip these fields, which we don't care about. */
1184 {
1185 bfd_vma parent, brother, context;
1186
1187 parse_int (&(ieee->h), &parent);
1188 parse_int (&(ieee->h), &brother);
1189 parse_int (&(ieee->h), &context);
1190 }
1191 }
1192 break;
1193 case ieee_section_alignment_enum:
1194 {
1195 unsigned int section_index;
1196 bfd_vma value;
1197 asection *section;
1198
1199 next_byte (&(ieee->h));
1200 section_index = must_parse_int (&ieee->h);
1201 section = get_section_entry (abfd, ieee, section_index);
1202 if (section_index > ieee->section_count)
1203 ieee->section_count = section_index;
1204
1205 section->alignment_power =
1206 bfd_log2 (must_parse_int (&ieee->h));
1207 (void) parse_int (&(ieee->h), &value);
1208 }
1209 break;
1210 case ieee_e2_first_byte_enum:
1211 {
1212 asection *section;
1213 ieee_record_enum_type t;
1214
1215 t = (ieee_record_enum_type) (read_2bytes (&(ieee->h)));
1216 switch (t)
1217 {
1218 case ieee_section_size_enum:
1219 section = ieee->section_table[must_parse_int (&(ieee->h))];
1220 section->size = must_parse_int (&(ieee->h));
1221 break;
1222 case ieee_physical_region_size_enum:
1223 section = ieee->section_table[must_parse_int (&(ieee->h))];
1224 section->size = must_parse_int (&(ieee->h));
1225 break;
1226 case ieee_region_base_address_enum:
1227 section = ieee->section_table[must_parse_int (&(ieee->h))];
1228 section->vma = must_parse_int (&(ieee->h));
1229 section->lma = section->vma;
1230 break;
1231 case ieee_mau_size_enum:
1232 must_parse_int (&(ieee->h));
1233 must_parse_int (&(ieee->h));
1234 break;
1235 case ieee_m_value_enum:
1236 must_parse_int (&(ieee->h));
1237 must_parse_int (&(ieee->h));
1238 break;
1239 case ieee_section_base_address_enum:
1240 section = ieee->section_table[must_parse_int (&(ieee->h))];
1241 section->vma = must_parse_int (&(ieee->h));
1242 section->lma = section->vma;
1243 break;
1244 case ieee_section_offset_enum:
1245 (void) must_parse_int (&(ieee->h));
1246 (void) must_parse_int (&(ieee->h));
1247 break;
1248 default:
1249 return;
1250 }
1251 }
1252 break;
1253 default:
1254 return;
1255 }
1256 }
1257 }
1258 }
1259
1260 /* Make a section for the debugging information, if any. We don't try
1261 to interpret the debugging information; we just point the section
1262 at the area in the file so that program which understand can dig it
1263 out. */
1264
1265 static bfd_boolean
1266 ieee_slurp_debug (bfd *abfd)
1267 {
1268 ieee_data_type *ieee = IEEE_DATA (abfd);
1269 asection *sec;
1270 file_ptr debug_end;
1271
1272 if (ieee->w.r.debug_information_part == 0)
1273 return TRUE;
1274
1275 sec = bfd_make_section (abfd, ".debug");
1276 if (sec == NULL)
1277 return FALSE;
1278 sec->flags |= SEC_DEBUGGING | SEC_HAS_CONTENTS;
1279 sec->filepos = ieee->w.r.debug_information_part;
1280
1281 debug_end = ieee_part_after (ieee, ieee->w.r.debug_information_part);
1282 sec->size = debug_end - ieee->w.r.debug_information_part;
1283
1284 return TRUE;
1285 }
1286 \f
1287 /* Archive stuff. */
1288
1289 static const bfd_target *
1290 ieee_archive_p (bfd *abfd)
1291 {
1292 char *library;
1293 unsigned int i;
1294 unsigned char buffer[512];
1295 file_ptr buffer_offset = 0;
1296 ieee_ar_data_type *save = abfd->tdata.ieee_ar_data;
1297 ieee_ar_data_type *ieee;
1298 bfd_size_type alc_elts;
1299 ieee_ar_obstack_type *elts = NULL;
1300 bfd_size_type amt = sizeof (ieee_ar_data_type);
1301
1302 abfd->tdata.ieee_ar_data = bfd_alloc (abfd, amt);
1303 if (!abfd->tdata.ieee_ar_data)
1304 goto error_ret_restore;
1305 ieee = IEEE_AR_DATA (abfd);
1306
1307 /* Ignore the return value here. It doesn't matter if we don't read
1308 the entire buffer. We might have a very small ieee file. */
1309 bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1310
1311 ieee->h.first_byte = buffer;
1312 ieee->h.input_p = buffer;
1313
1314 ieee->h.abfd = abfd;
1315
1316 if (this_byte (&(ieee->h)) != Module_Beginning)
1317 goto got_wrong_format_error;
1318
1319 next_byte (&(ieee->h));
1320 library = read_id (&(ieee->h));
1321 if (strcmp (library, "LIBRARY") != 0)
1322 goto got_wrong_format_error;
1323
1324 /* Throw away the filename. */
1325 read_id (&(ieee->h));
1326
1327 ieee->element_count = 0;
1328 ieee->element_index = 0;
1329
1330 next_byte (&(ieee->h)); /* Drop the ad part. */
1331 must_parse_int (&(ieee->h)); /* And the two dummy numbers. */
1332 must_parse_int (&(ieee->h));
1333
1334 alc_elts = 10;
1335 elts = bfd_malloc (alc_elts * sizeof *elts);
1336 if (elts == NULL)
1337 goto error_return;
1338
1339 /* Read the index of the BB table. */
1340 while (1)
1341 {
1342 int rec;
1343 ieee_ar_obstack_type *t;
1344
1345 rec = read_2bytes (&(ieee->h));
1346 if (rec != (int) ieee_assign_value_to_variable_enum)
1347 break;
1348
1349 if (ieee->element_count >= alc_elts)
1350 {
1351 ieee_ar_obstack_type *n;
1352
1353 alc_elts *= 2;
1354 n = bfd_realloc (elts, alc_elts * sizeof (* elts));
1355 if (n == NULL)
1356 goto error_return;
1357 elts = n;
1358 }
1359
1360 t = &elts[ieee->element_count];
1361 ieee->element_count++;
1362
1363 must_parse_int (&(ieee->h));
1364 t->file_offset = must_parse_int (&(ieee->h));
1365 t->abfd = (bfd *) NULL;
1366
1367 /* Make sure that we don't go over the end of the buffer. */
1368 if ((size_t) ieee_pos (IEEE_DATA (abfd)) > sizeof (buffer) / 2)
1369 {
1370 /* Past half way, reseek and reprime. */
1371 buffer_offset += ieee_pos (IEEE_DATA (abfd));
1372 if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0)
1373 goto error_return;
1374
1375 /* Again ignore return value of bfd_bread. */
1376 bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1377 ieee->h.first_byte = buffer;
1378 ieee->h.input_p = buffer;
1379 }
1380 }
1381
1382 amt = ieee->element_count;
1383 amt *= sizeof *ieee->elements;
1384 ieee->elements = bfd_alloc (abfd, amt);
1385 if (ieee->elements == NULL)
1386 goto error_return;
1387
1388 memcpy (ieee->elements, elts, (size_t) amt);
1389 free (elts);
1390 elts = NULL;
1391
1392 /* Now scan the area again, and replace BB offsets with file offsets. */
1393 for (i = 2; i < ieee->element_count; i++)
1394 {
1395 if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0)
1396 goto error_return;
1397
1398 /* Again ignore return value of bfd_bread. */
1399 bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1400 ieee->h.first_byte = buffer;
1401 ieee->h.input_p = buffer;
1402
1403 next_byte (&(ieee->h)); /* Drop F8. */
1404 next_byte (&(ieee->h)); /* Drop 14. */
1405 must_parse_int (&(ieee->h)); /* Drop size of block. */
1406
1407 if (must_parse_int (&(ieee->h)) != 0)
1408 /* This object has been deleted. */
1409 ieee->elements[i].file_offset = 0;
1410 else
1411 ieee->elements[i].file_offset = must_parse_int (&(ieee->h));
1412 }
1413
1414 /* abfd->has_armap = ;*/
1415
1416 return abfd->xvec;
1417
1418 got_wrong_format_error:
1419 bfd_set_error (bfd_error_wrong_format);
1420 error_return:
1421 if (elts != NULL)
1422 free (elts);
1423 bfd_release (abfd, ieee);
1424 error_ret_restore:
1425 abfd->tdata.ieee_ar_data = save;
1426
1427 return NULL;
1428 }
1429
1430 static bfd_boolean
1431 ieee_mkobject (bfd *abfd)
1432 {
1433 bfd_size_type amt;
1434
1435 output_ptr_start = NULL;
1436 output_ptr = NULL;
1437 output_ptr_end = NULL;
1438 input_ptr_start = NULL;
1439 input_ptr = NULL;
1440 input_ptr_end = NULL;
1441 input_bfd = NULL;
1442 output_bfd = NULL;
1443 output_buffer = 0;
1444 amt = sizeof (ieee_data_type);
1445 abfd->tdata.ieee_data = bfd_zalloc (abfd, amt);
1446 return abfd->tdata.ieee_data != NULL;
1447 }
1448
1449 static bfd_boolean
1450 do_one (ieee_data_type *ieee,
1451 ieee_per_section_type *current_map,
1452 unsigned char *location_ptr,
1453 asection *s,
1454 int iterations)
1455 {
1456 switch (this_byte (&(ieee->h)))
1457 {
1458 case ieee_load_constant_bytes_enum:
1459 {
1460 unsigned int number_of_maus;
1461 unsigned int i;
1462
1463 next_byte (&(ieee->h));
1464 number_of_maus = must_parse_int (&(ieee->h));
1465
1466 for (i = 0; i < number_of_maus; i++)
1467 {
1468 location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1469 next_byte (&(ieee->h));
1470 }
1471 }
1472 break;
1473
1474 case ieee_load_with_relocation_enum:
1475 {
1476 bfd_boolean loop = TRUE;
1477
1478 next_byte (&(ieee->h));
1479 while (loop)
1480 {
1481 switch (this_byte (&(ieee->h)))
1482 {
1483 case ieee_variable_R_enum:
1484
1485 case ieee_function_signed_open_b_enum:
1486 case ieee_function_unsigned_open_b_enum:
1487 case ieee_function_either_open_b_enum:
1488 {
1489 unsigned int extra = 4;
1490 bfd_boolean pcrel = FALSE;
1491 asection *section;
1492 ieee_reloc_type *r;
1493
1494 r = bfd_alloc (ieee->h.abfd, sizeof (* r));
1495 if (!r)
1496 return FALSE;
1497
1498 *(current_map->reloc_tail_ptr) = r;
1499 current_map->reloc_tail_ptr = &r->next;
1500 r->next = (ieee_reloc_type *) NULL;
1501 next_byte (&(ieee->h));
1502 /* abort();*/
1503 r->relent.sym_ptr_ptr = 0;
1504 parse_expression (ieee,
1505 &r->relent.addend,
1506 &r->symbol,
1507 &pcrel, &extra, &section);
1508 r->relent.address = current_map->pc;
1509 s->flags |= SEC_RELOC;
1510 s->owner->flags |= HAS_RELOC;
1511 s->reloc_count++;
1512 if (r->relent.sym_ptr_ptr == NULL && section != NULL)
1513 r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
1514
1515 if (this_byte (&(ieee->h)) == (int) ieee_comma)
1516 {
1517 next_byte (&(ieee->h));
1518 /* Fetch number of bytes to pad. */
1519 extra = must_parse_int (&(ieee->h));
1520 };
1521
1522 switch (this_byte (&(ieee->h)))
1523 {
1524 case ieee_function_signed_close_b_enum:
1525 next_byte (&(ieee->h));
1526 break;
1527 case ieee_function_unsigned_close_b_enum:
1528 next_byte (&(ieee->h));
1529 break;
1530 case ieee_function_either_close_b_enum:
1531 next_byte (&(ieee->h));
1532 break;
1533 default:
1534 break;
1535 }
1536 /* Build a relocation entry for this type. */
1537 /* If pc rel then stick -ve pc into instruction
1538 and take out of reloc ..
1539
1540 I've changed this. It's all too complicated. I
1541 keep 0 in the instruction now. */
1542
1543 switch (extra)
1544 {
1545 case 0:
1546 case 4:
1547
1548 if (pcrel)
1549 {
1550 #if KEEPMINUSPCININST
1551 bfd_put_32 (ieee->h.abfd, -current_map->pc,
1552 location_ptr + current_map->pc);
1553 r->relent.howto = &rel32_howto;
1554 r->relent.addend -= current_map->pc;
1555 #else
1556 bfd_put_32 (ieee->h.abfd, (bfd_vma) 0, location_ptr +
1557 current_map->pc);
1558 r->relent.howto = &rel32_howto;
1559 #endif
1560 }
1561 else
1562 {
1563 bfd_put_32 (ieee->h.abfd, (bfd_vma) 0,
1564 location_ptr + current_map->pc);
1565 r->relent.howto = &abs32_howto;
1566 }
1567 current_map->pc += 4;
1568 break;
1569 case 2:
1570 if (pcrel)
1571 {
1572 #if KEEPMINUSPCININST
1573 bfd_put_16 (ieee->h.abfd, (bfd_vma) -current_map->pc,
1574 location_ptr + current_map->pc);
1575 r->relent.addend -= current_map->pc;
1576 r->relent.howto = &rel16_howto;
1577 #else
1578
1579 bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
1580 location_ptr + current_map->pc);
1581 r->relent.howto = &rel16_howto;
1582 #endif
1583 }
1584
1585 else
1586 {
1587 bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
1588 location_ptr + current_map->pc);
1589 r->relent.howto = &abs16_howto;
1590 }
1591 current_map->pc += 2;
1592 break;
1593 case 1:
1594 if (pcrel)
1595 {
1596 #if KEEPMINUSPCININST
1597 bfd_put_8 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
1598 r->relent.addend -= current_map->pc;
1599 r->relent.howto = &rel8_howto;
1600 #else
1601 bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1602 r->relent.howto = &rel8_howto;
1603 #endif
1604 }
1605 else
1606 {
1607 bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1608 r->relent.howto = &abs8_howto;
1609 }
1610 current_map->pc += 1;
1611 break;
1612
1613 default:
1614 BFD_FAIL ();
1615 return FALSE;
1616 }
1617 }
1618 break;
1619 default:
1620 {
1621 bfd_vma this_size;
1622
1623 if (parse_int (&(ieee->h), &this_size))
1624 {
1625 unsigned int i;
1626
1627 for (i = 0; i < this_size; i++)
1628 {
1629 location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1630 next_byte (&(ieee->h));
1631 }
1632 }
1633 else
1634 loop = FALSE;
1635 }
1636 }
1637
1638 /* Prevent more than the first load-item of an LR record
1639 from being repeated (MRI convention). */
1640 if (iterations != 1)
1641 loop = FALSE;
1642 }
1643 }
1644 }
1645 return TRUE;
1646 }
1647
1648 /* Read in all the section data and relocation stuff too. */
1649
1650 static bfd_boolean
1651 ieee_slurp_section_data (bfd *abfd)
1652 {
1653 bfd_byte *location_ptr = (bfd_byte *) NULL;
1654 ieee_data_type *ieee = IEEE_DATA (abfd);
1655 unsigned int section_number;
1656 ieee_per_section_type *current_map = NULL;
1657 asection *s;
1658
1659 /* Seek to the start of the data area. */
1660 if (ieee->read_data)
1661 return TRUE;
1662 ieee->read_data = TRUE;
1663 ieee_seek (ieee, ieee->w.r.data_part);
1664
1665 /* Allocate enough space for all the section contents. */
1666 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1667 {
1668 ieee_per_section_type *per = ieee_per_section (s);
1669
1670 if ((s->flags & SEC_DEBUGGING) != 0)
1671 continue;
1672 per->data = bfd_alloc (ieee->h.abfd, s->size);
1673 if (!per->data)
1674 return FALSE;
1675 per->reloc_tail_ptr =
1676 (ieee_reloc_type **) & (s->relocation);
1677 }
1678
1679 while (TRUE)
1680 {
1681 switch (this_byte (&(ieee->h)))
1682 {
1683 /* IF we see anything strange then quit. */
1684 default:
1685 return TRUE;
1686
1687 case ieee_set_current_section_enum:
1688 next_byte (&(ieee->h));
1689 section_number = must_parse_int (&(ieee->h));
1690 s = ieee->section_table[section_number];
1691 s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
1692 current_map = ieee_per_section (s);
1693 location_ptr = current_map->data - s->vma;
1694 /* The document I have says that Microtec's compilers reset
1695 this after a sec section, even though the standard says not
1696 to, SO... */
1697 current_map->pc = s->vma;
1698 break;
1699
1700 case ieee_e2_first_byte_enum:
1701 next_byte (&(ieee->h));
1702 switch (this_byte (&(ieee->h)))
1703 {
1704 case ieee_set_current_pc_enum & 0xff:
1705 {
1706 bfd_vma value;
1707 ieee_symbol_index_type symbol;
1708 unsigned int extra;
1709 bfd_boolean pcrel;
1710
1711 next_byte (&(ieee->h));
1712 must_parse_int (&(ieee->h)); /* Throw away section #. */
1713 parse_expression (ieee, &value,
1714 &symbol,
1715 &pcrel, &extra,
1716 0);
1717 current_map->pc = value;
1718 BFD_ASSERT ((unsigned) (value - s->vma) <= s->size);
1719 }
1720 break;
1721
1722 case ieee_value_starting_address_enum & 0xff:
1723 next_byte (&(ieee->h));
1724 if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum)
1725 next_byte (&(ieee->h));
1726 abfd->start_address = must_parse_int (&(ieee->h));
1727 /* We've got to the end of the data now - */
1728 return TRUE;
1729 default:
1730 BFD_FAIL ();
1731 return FALSE;
1732 }
1733 break;
1734 case ieee_repeat_data_enum:
1735 {
1736 /* Repeat the following LD or LR n times - we do this by
1737 remembering the stream pointer before running it and
1738 resetting it and running it n times. We special case
1739 the repetition of a repeat_data/load_constant. */
1740 unsigned int iterations;
1741 unsigned char *start;
1742
1743 next_byte (&(ieee->h));
1744 iterations = must_parse_int (&(ieee->h));
1745 start = ieee->h.input_p;
1746 if (start[0] == (int) ieee_load_constant_bytes_enum
1747 && start[1] == 1)
1748 {
1749 while (iterations != 0)
1750 {
1751 location_ptr[current_map->pc++] = start[2];
1752 iterations--;
1753 }
1754 next_byte (&(ieee->h));
1755 next_byte (&(ieee->h));
1756 next_byte (&(ieee->h));
1757 }
1758 else
1759 {
1760 while (iterations != 0)
1761 {
1762 ieee->h.input_p = start;
1763 if (!do_one (ieee, current_map, location_ptr, s,
1764 (int) iterations))
1765 return FALSE;
1766 iterations--;
1767 }
1768 }
1769 }
1770 break;
1771 case ieee_load_constant_bytes_enum:
1772 case ieee_load_with_relocation_enum:
1773 if (!do_one (ieee, current_map, location_ptr, s, 1))
1774 return FALSE;
1775 }
1776 }
1777 }
1778
1779 static const bfd_target *
1780 ieee_object_p (bfd *abfd)
1781 {
1782 char *processor;
1783 unsigned int part;
1784 ieee_data_type *ieee;
1785 unsigned char buffer[300];
1786 ieee_data_type *save = IEEE_DATA (abfd);
1787 bfd_size_type amt;
1788
1789 abfd->tdata.ieee_data = 0;
1790 ieee_mkobject (abfd);
1791
1792 ieee = IEEE_DATA (abfd);
1793 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1794 goto fail;
1795 /* Read the first few bytes in to see if it makes sense. Ignore
1796 bfd_bread return value; The file might be very small. */
1797 bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1798
1799 ieee->h.input_p = buffer;
1800 if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
1801 goto got_wrong_format;
1802
1803 ieee->read_symbols = FALSE;
1804 ieee->read_data = FALSE;
1805 ieee->section_count = 0;
1806 ieee->external_symbol_max_index = 0;
1807 ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
1808 ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
1809 ieee->external_reference_max_index = 0;
1810 ieee->h.abfd = abfd;
1811 ieee->section_table = NULL;
1812 ieee->section_table_size = 0;
1813
1814 processor = ieee->mb.processor = read_id (&(ieee->h));
1815 if (strcmp (processor, "LIBRARY") == 0)
1816 goto got_wrong_format;
1817 ieee->mb.module_name = read_id (&(ieee->h));
1818 if (abfd->filename == (const char *) NULL)
1819 abfd->filename = ieee->mb.module_name;
1820
1821 /* Determine the architecture and machine type of the object file. */
1822 {
1823 const bfd_arch_info_type *arch;
1824 char family[10];
1825
1826 /* IEEE does not specify the format of the processor identification
1827 string, so the compiler is free to put in it whatever it wants.
1828 We try here to recognize different processors belonging to the
1829 m68k family. Code for other processors can be added here. */
1830 if ((processor[0] == '6') && (processor[1] == '8'))
1831 {
1832 if (processor[2] == '3') /* 683xx integrated processors. */
1833 {
1834 switch (processor[3])
1835 {
1836 case '0': /* 68302, 68306, 68307 */
1837 case '2': /* 68322, 68328 */
1838 case '5': /* 68356 */
1839 strcpy (family, "68000"); /* MC68000-based controllers. */
1840 break;
1841
1842 case '3': /* 68330, 68331, 68332, 68333,
1843 68334, 68335, 68336, 68338 */
1844 case '6': /* 68360 */
1845 case '7': /* 68376 */
1846 strcpy (family, "68332"); /* CPU32 and CPU32+ */
1847 break;
1848
1849 case '4':
1850 if (processor[4] == '9') /* 68349 */
1851 strcpy (family, "68030"); /* CPU030 */
1852 else /* 68340, 68341 */
1853 strcpy (family, "68332"); /* CPU32 and CPU32+ */
1854 break;
1855
1856 default: /* Does not exist yet. */
1857 strcpy (family, "68332"); /* Guess it will be CPU32 */
1858 }
1859 }
1860 else if (TOUPPER (processor[3]) == 'F') /* 68F333 */
1861 strcpy (family, "68332"); /* CPU32 */
1862 else if ((TOUPPER (processor[3]) == 'C') /* Embedded controllers. */
1863 && ((TOUPPER (processor[2]) == 'E')
1864 || (TOUPPER (processor[2]) == 'H')
1865 || (TOUPPER (processor[2]) == 'L')))
1866 {
1867 strcpy (family, "68");
1868 strncat (family, processor + 4, 7);
1869 family[9] = '\0';
1870 }
1871 else /* "Regular" processors. */
1872 {
1873 strncpy (family, processor, 9);
1874 family[9] = '\0';
1875 }
1876 }
1877 else if ((strncmp (processor, "cpu32", 5) == 0) /* CPU32 and CPU32+ */
1878 || (strncmp (processor, "CPU32", 5) == 0))
1879 strcpy (family, "68332");
1880 else
1881 {
1882 strncpy (family, processor, 9);
1883 family[9] = '\0';
1884 }
1885
1886 arch = bfd_scan_arch (family);
1887 if (arch == 0)
1888 goto got_wrong_format;
1889 abfd->arch_info = arch;
1890 }
1891
1892 if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
1893 goto fail;
1894
1895 next_byte (&(ieee->h));
1896
1897 if (! parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau))
1898 goto fail;
1899
1900 if (! parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address))
1901 goto fail;
1902
1903 /* If there is a byte order info, take it. */
1904 if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum
1905 || this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
1906 next_byte (&(ieee->h));
1907
1908 for (part = 0; part < N_W_VARIABLES; part++)
1909 {
1910 bfd_boolean ok;
1911
1912 if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
1913 goto fail;
1914
1915 if (this_byte_and_next (&(ieee->h)) != part)
1916 goto fail;
1917
1918 ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
1919 if (! ok)
1920 goto fail;
1921 }
1922
1923 if (ieee->w.r.external_part != 0)
1924 abfd->flags = HAS_SYMS;
1925
1926 /* By now we know that this is a real IEEE file, we're going to read
1927 the whole thing into memory so that we can run up and down it
1928 quickly. We can work out how big the file is from the trailer
1929 record. */
1930
1931 amt = ieee->w.r.me_record + 1;
1932 IEEE_DATA (abfd)->h.first_byte = bfd_alloc (ieee->h.abfd, amt);
1933 if (!IEEE_DATA (abfd)->h.first_byte)
1934 goto fail;
1935 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1936 goto fail;
1937 /* FIXME: Check return value. I'm not sure whether it needs to read
1938 the entire buffer or not. */
1939 bfd_bread ((void *) (IEEE_DATA (abfd)->h.first_byte),
1940 (bfd_size_type) ieee->w.r.me_record + 1, abfd);
1941
1942 ieee_slurp_sections (abfd);
1943
1944 if (! ieee_slurp_debug (abfd))
1945 goto fail;
1946
1947 /* Parse section data to activate file and section flags implied by
1948 section contents. */
1949 if (! ieee_slurp_section_data (abfd))
1950 goto fail;
1951
1952 return abfd->xvec;
1953 got_wrong_format:
1954 bfd_set_error (bfd_error_wrong_format);
1955 fail:
1956 bfd_release (abfd, ieee);
1957 abfd->tdata.ieee_data = save;
1958 return (const bfd_target *) NULL;
1959 }
1960
1961 static void
1962 ieee_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1963 asymbol *symbol,
1964 symbol_info *ret)
1965 {
1966 bfd_symbol_info (symbol, ret);
1967 if (symbol->name[0] == ' ')
1968 ret->name = "* empty table entry ";
1969 if (!symbol->section)
1970 ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
1971 }
1972
1973 static void
1974 ieee_print_symbol (bfd *abfd,
1975 void * afile,
1976 asymbol *symbol,
1977 bfd_print_symbol_type how)
1978 {
1979 FILE *file = (FILE *) afile;
1980
1981 switch (how)
1982 {
1983 case bfd_print_symbol_name:
1984 fprintf (file, "%s", symbol->name);
1985 break;
1986 case bfd_print_symbol_more:
1987 BFD_FAIL ();
1988 break;
1989 case bfd_print_symbol_all:
1990 {
1991 const char *section_name =
1992 (symbol->section == (asection *) NULL
1993 ? "*abs"
1994 : symbol->section->name);
1995
1996 if (symbol->name[0] == ' ')
1997 fprintf (file, "* empty table entry ");
1998 else
1999 {
2000 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2001
2002 fprintf (file, " %-5s %04x %02x %s",
2003 section_name,
2004 (unsigned) ieee_symbol (symbol)->index,
2005 (unsigned) 0,
2006 symbol->name);
2007 }
2008 }
2009 break;
2010 }
2011 }
2012
2013 static bfd_boolean
2014 ieee_new_section_hook (bfd *abfd, asection *newsect)
2015 {
2016 newsect->used_by_bfd = bfd_alloc (abfd, (bfd_size_type) sizeof (ieee_per_section_type));
2017 if (!newsect->used_by_bfd)
2018 return FALSE;
2019 ieee_per_section (newsect)->data = NULL;
2020 ieee_per_section (newsect)->section = newsect;
2021 return TRUE;
2022 }
2023
2024 static long
2025 ieee_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2026 {
2027 if ((asect->flags & SEC_DEBUGGING) != 0)
2028 return 0;
2029 if (! ieee_slurp_section_data (abfd))
2030 return -1;
2031 return (asect->reloc_count + 1) * sizeof (arelent *);
2032 }
2033
2034 static bfd_boolean
2035 ieee_get_section_contents (bfd *abfd,
2036 sec_ptr section,
2037 void * location,
2038 file_ptr offset,
2039 bfd_size_type count)
2040 {
2041 ieee_per_section_type *p = ieee_per_section (section);
2042 if ((section->flags & SEC_DEBUGGING) != 0)
2043 return _bfd_generic_get_section_contents (abfd, section, location,
2044 offset, count);
2045 ieee_slurp_section_data (abfd);
2046 (void) memcpy ((void *) location, (void *) (p->data + offset), (unsigned) count);
2047 return TRUE;
2048 }
2049
2050 static long
2051 ieee_canonicalize_reloc (bfd *abfd,
2052 sec_ptr section,
2053 arelent **relptr,
2054 asymbol **symbols)
2055 {
2056 ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
2057 ieee_data_type *ieee = IEEE_DATA (abfd);
2058
2059 if ((section->flags & SEC_DEBUGGING) != 0)
2060 return 0;
2061
2062 while (src != (ieee_reloc_type *) NULL)
2063 {
2064 /* Work out which symbol to attach it this reloc to. */
2065 switch (src->symbol.letter)
2066 {
2067 case 'I':
2068 src->relent.sym_ptr_ptr =
2069 symbols + src->symbol.index + ieee->external_symbol_base_offset;
2070 break;
2071 case 'X':
2072 src->relent.sym_ptr_ptr =
2073 symbols + src->symbol.index + ieee->external_reference_base_offset;
2074 break;
2075 case 0:
2076 if (src->relent.sym_ptr_ptr != NULL)
2077 src->relent.sym_ptr_ptr =
2078 src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
2079 break;
2080 default:
2081
2082 BFD_FAIL ();
2083 }
2084 *relptr++ = &src->relent;
2085 src = src->next;
2086 }
2087 *relptr = NULL;
2088 return section->reloc_count;
2089 }
2090
2091 static int
2092 comp (const void * ap, const void * bp)
2093 {
2094 arelent *a = *((arelent **) ap);
2095 arelent *b = *((arelent **) bp);
2096 return a->address - b->address;
2097 }
2098
2099 /* Write the section headers. */
2100
2101 static bfd_boolean
2102 ieee_write_section_part (bfd *abfd)
2103 {
2104 ieee_data_type *ieee = IEEE_DATA (abfd);
2105 asection *s;
2106
2107 ieee->w.r.section_part = bfd_tell (abfd);
2108 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2109 {
2110 if (! bfd_is_abs_section (s)
2111 && (s->flags & SEC_DEBUGGING) == 0)
2112 {
2113 if (! ieee_write_byte (abfd, ieee_section_type_enum)
2114 || ! ieee_write_byte (abfd,
2115 (bfd_byte) (s->index
2116 + IEEE_SECTION_NUMBER_BASE)))
2117 return FALSE;
2118
2119 if (abfd->flags & EXEC_P)
2120 {
2121 /* This image is executable, so output absolute sections. */
2122 if (! ieee_write_byte (abfd, ieee_variable_A_enum)
2123 || ! ieee_write_byte (abfd, ieee_variable_S_enum))
2124 return FALSE;
2125 }
2126 else
2127 {
2128 if (! ieee_write_byte (abfd, ieee_variable_C_enum))
2129 return FALSE;
2130 }
2131
2132 switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM))
2133 {
2134 case SEC_CODE | SEC_LOAD:
2135 case SEC_CODE:
2136 if (! ieee_write_byte (abfd, ieee_variable_P_enum))
2137 return FALSE;
2138 break;
2139 case SEC_DATA:
2140 default:
2141 if (! ieee_write_byte (abfd, ieee_variable_D_enum))
2142 return FALSE;
2143 break;
2144 case SEC_ROM:
2145 case SEC_ROM | SEC_DATA:
2146 case SEC_ROM | SEC_LOAD:
2147 case SEC_ROM | SEC_DATA | SEC_LOAD:
2148 if (! ieee_write_byte (abfd, ieee_variable_R_enum))
2149 return FALSE;
2150 }
2151
2152
2153 if (! ieee_write_id (abfd, s->name))
2154 return FALSE;
2155 /* Alignment. */
2156 if (! ieee_write_byte (abfd, ieee_section_alignment_enum)
2157 || ! ieee_write_byte (abfd,
2158 (bfd_byte) (s->index
2159 + IEEE_SECTION_NUMBER_BASE))
2160 || ! ieee_write_int (abfd, (bfd_vma) 1 << s->alignment_power))
2161 return FALSE;
2162
2163 /* Size. */
2164 if (! ieee_write_2bytes (abfd, ieee_section_size_enum)
2165 || ! ieee_write_byte (abfd,
2166 (bfd_byte) (s->index
2167 + IEEE_SECTION_NUMBER_BASE))
2168 || ! ieee_write_int (abfd, s->size))
2169 return FALSE;
2170 if (abfd->flags & EXEC_P)
2171 {
2172 /* Relocateable sections don't have asl records. */
2173 /* Vma. */
2174 if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum)
2175 || ! ieee_write_byte (abfd,
2176 ((bfd_byte)
2177 (s->index
2178 + IEEE_SECTION_NUMBER_BASE)))
2179 || ! ieee_write_int (abfd, s->lma))
2180 return FALSE;
2181 }
2182 }
2183 }
2184
2185 return TRUE;
2186 }
2187
2188 static bfd_boolean
2189 do_with_relocs (bfd *abfd, asection *s)
2190 {
2191 unsigned int number_of_maus_in_address =
2192 bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd);
2193 unsigned int relocs_to_go = s->reloc_count;
2194 bfd_byte *stream = ieee_per_section (s)->data;
2195 arelent **p = s->orelocation;
2196 bfd_size_type current_byte_index = 0;
2197
2198 qsort (s->orelocation,
2199 relocs_to_go,
2200 sizeof (arelent **),
2201 comp);
2202
2203 /* Output the section preheader. */
2204 if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2205 || ! ieee_write_byte (abfd,
2206 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))
2207 || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum)
2208 || ! ieee_write_byte (abfd,
2209 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)))
2210 return FALSE;
2211
2212 if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0)
2213 {
2214 if (! ieee_write_int (abfd, s->lma))
2215 return FALSE;
2216 }
2217 else
2218 {
2219 if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2220 return FALSE;
2221 }
2222
2223 if (relocs_to_go == 0)
2224 {
2225 /* If there aren't any relocations then output the load constant
2226 byte opcode rather than the load with relocation opcode. */
2227 while (current_byte_index < s->size)
2228 {
2229 bfd_size_type run;
2230 unsigned int MAXRUN = 127;
2231
2232 run = MAXRUN;
2233 if (run > s->size - current_byte_index)
2234 run = s->size - current_byte_index;
2235
2236 if (run != 0)
2237 {
2238 if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum))
2239 return FALSE;
2240 /* Output a stream of bytes. */
2241 if (! ieee_write_int (abfd, run))
2242 return FALSE;
2243 if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd)
2244 != run)
2245 return FALSE;
2246 current_byte_index += run;
2247 }
2248 }
2249 }
2250 else
2251 {
2252 if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum))
2253 return FALSE;
2254
2255 /* Output the data stream as the longest sequence of bytes
2256 possible, allowing for the a reasonable packet size and
2257 relocation stuffs. */
2258 if (stream == NULL)
2259 {
2260 /* Outputting a section without data, fill it up. */
2261 stream = bfd_zalloc (abfd, s->size);
2262 if (!stream)
2263 return FALSE;
2264 }
2265 while (current_byte_index < s->size)
2266 {
2267 bfd_size_type run;
2268 unsigned int MAXRUN = 127;
2269
2270 if (relocs_to_go)
2271 {
2272 run = (*p)->address - current_byte_index;
2273 if (run > MAXRUN)
2274 run = MAXRUN;
2275 }
2276 else
2277 run = MAXRUN;
2278
2279 if (run > s->size - current_byte_index)
2280 run = s->size - current_byte_index;
2281
2282 if (run != 0)
2283 {
2284 /* Output a stream of bytes. */
2285 if (! ieee_write_int (abfd, run))
2286 return FALSE;
2287 if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd)
2288 != run)
2289 return FALSE;
2290 current_byte_index += run;
2291 }
2292
2293 /* Output any relocations here. */
2294 if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
2295 {
2296 while (relocs_to_go
2297 && (*p) && (*p)->address == current_byte_index)
2298 {
2299 arelent *r = *p;
2300 bfd_signed_vma ov;
2301 switch (r->howto->size)
2302 {
2303 case 2:
2304 ov = bfd_get_signed_32 (abfd,
2305 stream + current_byte_index);
2306 current_byte_index += 4;
2307 break;
2308 case 1:
2309 ov = bfd_get_signed_16 (abfd,
2310 stream + current_byte_index);
2311 current_byte_index += 2;
2312 break;
2313 case 0:
2314 ov = bfd_get_signed_8 (abfd,
2315 stream + current_byte_index);
2316 current_byte_index++;
2317 break;
2318 default:
2319 ov = 0;
2320 BFD_FAIL ();
2321 return FALSE;
2322 }
2323
2324 ov &= r->howto->src_mask;
2325
2326 if (r->howto->pc_relative
2327 && ! r->howto->pcrel_offset)
2328 ov += r->address;
2329
2330 if (! ieee_write_byte (abfd,
2331 ieee_function_either_open_b_enum))
2332 return FALSE;
2333
2334 if (r->sym_ptr_ptr != (asymbol **) NULL)
2335 {
2336 if (! ieee_write_expression (abfd, r->addend + ov,
2337 *(r->sym_ptr_ptr),
2338 r->howto->pc_relative,
2339 (unsigned) s->index))
2340 return FALSE;
2341 }
2342 else
2343 {
2344 if (! ieee_write_expression (abfd, r->addend + ov,
2345 (asymbol *) NULL,
2346 r->howto->pc_relative,
2347 (unsigned) s->index))
2348 return FALSE;
2349 }
2350
2351 if (number_of_maus_in_address
2352 != bfd_get_reloc_size (r->howto))
2353 {
2354 bfd_vma rsize = bfd_get_reloc_size (r->howto);
2355 if (! ieee_write_int (abfd, rsize))
2356 return FALSE;
2357 }
2358 if (! ieee_write_byte (abfd,
2359 ieee_function_either_close_b_enum))
2360 return FALSE;
2361
2362 relocs_to_go--;
2363 p++;
2364 }
2365
2366 }
2367 }
2368 }
2369
2370 return TRUE;
2371 }
2372
2373 /* If there are no relocations in the output section then we can be
2374 clever about how we write. We block items up into a max of 127
2375 bytes. */
2376
2377 static bfd_boolean
2378 do_as_repeat (bfd *abfd, asection *s)
2379 {
2380 if (s->size)
2381 {
2382 if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2383 || ! ieee_write_byte (abfd,
2384 (bfd_byte) (s->index
2385 + IEEE_SECTION_NUMBER_BASE))
2386 || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8)
2387 || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff)
2388 || ! ieee_write_byte (abfd,
2389 (bfd_byte) (s->index
2390 + IEEE_SECTION_NUMBER_BASE)))
2391 return FALSE;
2392
2393 if ((abfd->flags & EXEC_P) != 0)
2394 {
2395 if (! ieee_write_int (abfd, s->lma))
2396 return FALSE;
2397 }
2398 else
2399 {
2400 if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2401 return FALSE;
2402 }
2403
2404 if (! ieee_write_byte (abfd, ieee_repeat_data_enum)
2405 || ! ieee_write_int (abfd, s->size)
2406 || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)
2407 || ! ieee_write_byte (abfd, 1)
2408 || ! ieee_write_byte (abfd, 0))
2409 return FALSE;
2410 }
2411
2412 return TRUE;
2413 }
2414
2415 static bfd_boolean
2416 do_without_relocs (bfd *abfd, asection *s)
2417 {
2418 bfd_byte *stream = ieee_per_section (s)->data;
2419
2420 if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
2421 {
2422 if (! do_as_repeat (abfd, s))
2423 return FALSE;
2424 }
2425 else
2426 {
2427 unsigned int i;
2428
2429 for (i = 0; i < s->size; i++)
2430 {
2431 if (stream[i] != 0)
2432 {
2433 if (! do_with_relocs (abfd, s))
2434 return FALSE;
2435 return TRUE;
2436 }
2437 }
2438 if (! do_as_repeat (abfd, s))
2439 return FALSE;
2440 }
2441
2442 return TRUE;
2443 }
2444
2445 static void
2446 fill (void)
2447 {
2448 bfd_size_type amt = input_ptr_end - input_ptr_start;
2449 /* FIXME: Check return value. I'm not sure whether it needs to read
2450 the entire buffer or not. */
2451 bfd_bread ((void *) input_ptr_start, amt, input_bfd);
2452 input_ptr = input_ptr_start;
2453 }
2454
2455 static void
2456 flush (void)
2457 {
2458 bfd_size_type amt = output_ptr - output_ptr_start;
2459
2460 if (bfd_bwrite ((void *) (output_ptr_start), amt, output_bfd) != amt)
2461 abort ();
2462 output_ptr = output_ptr_start;
2463 output_buffer++;
2464 }
2465
2466 #define THIS() ( *input_ptr )
2467 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill (); }
2468 #define OUT(x) { *output_ptr++ = (x); if (output_ptr == output_ptr_end) flush (); }
2469
2470 static void
2471 write_int (int value)
2472 {
2473 if (value >= 0 && value <= 127)
2474 {
2475 OUT (value);
2476 }
2477 else
2478 {
2479 unsigned int length;
2480
2481 /* How many significant bytes ? */
2482 /* FIXME FOR LONGER INTS. */
2483 if (value & 0xff000000)
2484 length = 4;
2485 else if (value & 0x00ff0000)
2486 length = 3;
2487 else if (value & 0x0000ff00)
2488 length = 2;
2489 else
2490 length = 1;
2491
2492 OUT ((int) ieee_number_repeat_start_enum + length);
2493 switch (length)
2494 {
2495 case 4:
2496 OUT (value >> 24);
2497 case 3:
2498 OUT (value >> 16);
2499 case 2:
2500 OUT (value >> 8);
2501 case 1:
2502 OUT (value);
2503 }
2504 }
2505 }
2506
2507 static void
2508 copy_id (void)
2509 {
2510 int length = THIS ();
2511 char ch;
2512
2513 OUT (length);
2514 NEXT ();
2515 while (length--)
2516 {
2517 ch = THIS ();
2518 OUT (ch);
2519 NEXT ();
2520 }
2521 }
2522
2523 #define VAR(x) ((x | 0x80))
2524 static void
2525 copy_expression (void)
2526 {
2527 int stack[10];
2528 int *tos = stack;
2529 int value;
2530
2531 while (1)
2532 {
2533 switch (THIS ())
2534 {
2535 case 0x84:
2536 NEXT ();
2537 value = THIS ();
2538 NEXT ();
2539 value = (value << 8) | THIS ();
2540 NEXT ();
2541 value = (value << 8) | THIS ();
2542 NEXT ();
2543 value = (value << 8) | THIS ();
2544 NEXT ();
2545 *tos++ = value;
2546 break;
2547 case 0x83:
2548 NEXT ();
2549 value = THIS ();
2550 NEXT ();
2551 value = (value << 8) | THIS ();
2552 NEXT ();
2553 value = (value << 8) | THIS ();
2554 NEXT ();
2555 *tos++ = value;
2556 break;
2557 case 0x82:
2558 NEXT ();
2559 value = THIS ();
2560 NEXT ();
2561 value = (value << 8) | THIS ();
2562 NEXT ();
2563 *tos++ = value;
2564 break;
2565 case 0x81:
2566 NEXT ();
2567 value = THIS ();
2568 NEXT ();
2569 *tos++ = value;
2570 break;
2571 case 0x80:
2572 NEXT ();
2573 *tos++ = 0;
2574 break;
2575 default:
2576 if (THIS () > 0x84)
2577 {
2578 /* Not a number, just bug out with the answer. */
2579 write_int (*(--tos));
2580 return;
2581 }
2582 *tos++ = THIS ();
2583 NEXT ();
2584 break;
2585 case 0xa5:
2586 /* PLUS anything. */
2587 value = *(--tos);
2588 value += *(--tos);
2589 *tos++ = value;
2590 NEXT ();
2591 break;
2592 case VAR ('R'):
2593 {
2594 int section_number;
2595 ieee_data_type *ieee;
2596 asection *s;
2597
2598 NEXT ();
2599 section_number = THIS ();
2600
2601 NEXT ();
2602 ieee = IEEE_DATA (input_bfd);
2603 s = ieee->section_table[section_number];
2604 value = 0;
2605 if (s->output_section)
2606 value = s->output_section->lma;
2607 value += s->output_offset;
2608 *tos++ = value;
2609 }
2610 break;
2611 case 0x90:
2612 {
2613 NEXT ();
2614 write_int (*(--tos));
2615 OUT (0x90);
2616 return;
2617 }
2618 }
2619 }
2620 }
2621
2622 /* Drop the int in the buffer, and copy a null into the gap, which we
2623 will overwrite later. */
2624
2625 static void
2626 fill_int (struct output_buffer_struct *buf)
2627 {
2628 if (buf->buffer == output_buffer)
2629 {
2630 /* Still a chance to output the size. */
2631 int value = output_ptr - buf->ptrp + 3;
2632 buf->ptrp[0] = value >> 24;
2633 buf->ptrp[1] = value >> 16;
2634 buf->ptrp[2] = value >> 8;
2635 buf->ptrp[3] = value >> 0;
2636 }
2637 }
2638
2639 static void
2640 drop_int (struct output_buffer_struct *buf)
2641 {
2642 int type = THIS ();
2643 int ch;
2644
2645 if (type <= 0x84)
2646 {
2647 NEXT ();
2648 switch (type)
2649 {
2650 case 0x84:
2651 ch = THIS ();
2652 NEXT ();
2653 case 0x83:
2654 ch = THIS ();
2655 NEXT ();
2656 case 0x82:
2657 ch = THIS ();
2658 NEXT ();
2659 case 0x81:
2660 ch = THIS ();
2661 NEXT ();
2662 case 0x80:
2663 break;
2664 }
2665 }
2666 OUT (0x84);
2667 buf->ptrp = output_ptr;
2668 buf->buffer = output_buffer;
2669 OUT (0);
2670 OUT (0);
2671 OUT (0);
2672 OUT (0);
2673 }
2674
2675 static void
2676 copy_int (void)
2677 {
2678 int type = THIS ();
2679 int ch;
2680 if (type <= 0x84)
2681 {
2682 OUT (type);
2683 NEXT ();
2684 switch (type)
2685 {
2686 case 0x84:
2687 ch = THIS ();
2688 NEXT ();
2689 OUT (ch);
2690 case 0x83:
2691 ch = THIS ();
2692 NEXT ();
2693 OUT (ch);
2694 case 0x82:
2695 ch = THIS ();
2696 NEXT ();
2697 OUT (ch);
2698 case 0x81:
2699 ch = THIS ();
2700 NEXT ();
2701 OUT (ch);
2702 case 0x80:
2703 break;
2704 }
2705 }
2706 }
2707
2708 #define ID copy_id ()
2709 #define INT copy_int ()
2710 #define EXP copy_expression ()
2711 #define INTn(q) copy_int ()
2712 #define EXPn(q) copy_expression ()
2713
2714 static void
2715 copy_till_end (void)
2716 {
2717 int ch = THIS ();
2718
2719 while (1)
2720 {
2721 while (ch <= 0x80)
2722 {
2723 OUT (ch);
2724 NEXT ();
2725 ch = THIS ();
2726 }
2727 switch (ch)
2728 {
2729 case 0x84:
2730 OUT (THIS ());
2731 NEXT ();
2732 case 0x83:
2733 OUT (THIS ());
2734 NEXT ();
2735 case 0x82:
2736 OUT (THIS ());
2737 NEXT ();
2738 case 0x81:
2739 OUT (THIS ());
2740 NEXT ();
2741 OUT (THIS ());
2742 NEXT ();
2743
2744 ch = THIS ();
2745 break;
2746 default:
2747 return;
2748 }
2749 }
2750
2751 }
2752
2753 static void
2754 f1_record (void)
2755 {
2756 int ch;
2757
2758 /* ATN record. */
2759 NEXT ();
2760 ch = THIS ();
2761 switch (ch)
2762 {
2763 default:
2764 OUT (0xf1);
2765 OUT (ch);
2766 break;
2767 case 0xc9:
2768 NEXT ();
2769 OUT (0xf1);
2770 OUT (0xc9);
2771 INT;
2772 INT;
2773 ch = THIS ();
2774 switch (ch)
2775 {
2776 case 0x16:
2777 NEXT ();
2778 break;
2779 case 0x01:
2780 NEXT ();
2781 break;
2782 case 0x00:
2783 NEXT ();
2784 INT;
2785 break;
2786 case 0x03:
2787 NEXT ();
2788 INT;
2789 break;
2790 case 0x13:
2791 EXPn (instruction address);
2792 break;
2793 default:
2794 break;
2795 }
2796 break;
2797 case 0xd8:
2798 /* EXternal ref. */
2799 NEXT ();
2800 OUT (0xf1);
2801 OUT (0xd8);
2802 EXP;
2803 EXP;
2804 EXP;
2805 EXP;
2806 break;
2807 case 0xce:
2808 NEXT ();
2809 OUT (0xf1);
2810 OUT (0xce);
2811 INT;
2812 INT;
2813 ch = THIS ();
2814 INT;
2815 switch (ch)
2816 {
2817 case 0x01:
2818 INT;
2819 INT;
2820 break;
2821 case 0x02:
2822 INT;
2823 break;
2824 case 0x04:
2825 EXPn (external function);
2826 break;
2827 case 0x05:
2828 break;
2829 case 0x07:
2830 INTn (line number);
2831 INT;
2832 case 0x08:
2833 break;
2834 case 0x0a:
2835 INTn (locked register);
2836 INT;
2837 break;
2838 case 0x3f:
2839 copy_till_end ();
2840 break;
2841 case 0x3e:
2842 copy_till_end ();
2843 break;
2844 case 0x40:
2845 copy_till_end ();
2846 break;
2847 case 0x41:
2848 ID;
2849 break;
2850 }
2851 }
2852 }
2853
2854 static void
2855 f0_record (void)
2856 {
2857 /* Attribute record. */
2858 NEXT ();
2859 OUT (0xf0);
2860 INTn (Symbol name);
2861 ID;
2862 }
2863
2864 static void
2865 f2_record (void)
2866 {
2867 NEXT ();
2868 OUT (0xf2);
2869 INT;
2870 NEXT ();
2871 OUT (0xce);
2872 INT;
2873 copy_till_end ();
2874 }
2875
2876 static void
2877 f8_record (void)
2878 {
2879 int ch;
2880 NEXT ();
2881 ch = THIS ();
2882 switch (ch)
2883 {
2884 case 0x01:
2885 case 0x02:
2886 case 0x03:
2887 /* Unique typedefs for module. */
2888 /* GLobal typedefs. */
2889 /* High level module scope beginning. */
2890 {
2891 struct output_buffer_struct ob;
2892
2893 NEXT ();
2894 OUT (0xf8);
2895 OUT (ch);
2896 drop_int (&ob);
2897 ID;
2898
2899 block ();
2900
2901 NEXT ();
2902 fill_int (&ob);
2903 OUT (0xf9);
2904 }
2905 break;
2906 case 0x04:
2907 /* Global function. */
2908 {
2909 struct output_buffer_struct ob;
2910
2911 NEXT ();
2912 OUT (0xf8);
2913 OUT (0x04);
2914 drop_int (&ob);
2915 ID;
2916 INTn (stack size);
2917 INTn (ret val);
2918 EXPn (offset);
2919
2920 block ();
2921
2922 NEXT ();
2923 OUT (0xf9);
2924 EXPn (size of block);
2925 fill_int (&ob);
2926 }
2927 break;
2928
2929 case 0x05:
2930 /* File name for source line numbers. */
2931 {
2932 struct output_buffer_struct ob;
2933
2934 NEXT ();
2935 OUT (0xf8);
2936 OUT (0x05);
2937 drop_int (&ob);
2938 ID;
2939 INTn (year);
2940 INTn (month);
2941 INTn (day);
2942 INTn (hour);
2943 INTn (monute);
2944 INTn (second);
2945 block ();
2946 NEXT ();
2947 OUT (0xf9);
2948 fill_int (&ob);
2949 }
2950 break;
2951
2952 case 0x06:
2953 /* Local function. */
2954 {
2955 struct output_buffer_struct ob;
2956
2957 NEXT ();
2958 OUT (0xf8);
2959 OUT (0x06);
2960 drop_int (&ob);
2961 ID;
2962 INTn (stack size);
2963 INTn (type return);
2964 EXPn (offset);
2965 block ();
2966 NEXT ();
2967 OUT (0xf9);
2968 EXPn (size);
2969 fill_int (&ob);
2970 }
2971 break;
2972
2973 case 0x0a:
2974 /* Assembler module scope beginning - */
2975 {
2976 struct output_buffer_struct ob;
2977
2978 NEXT ();
2979 OUT (0xf8);
2980 OUT (0x0a);
2981 drop_int (&ob);
2982 ID;
2983 ID;
2984 INT;
2985 ID;
2986 INT;
2987 INT;
2988 INT;
2989 INT;
2990 INT;
2991 INT;
2992
2993 block ();
2994
2995 NEXT ();
2996 OUT (0xf9);
2997 fill_int (&ob);
2998 }
2999 break;
3000 case 0x0b:
3001 {
3002 struct output_buffer_struct ob;
3003
3004 NEXT ();
3005 OUT (0xf8);
3006 OUT (0x0b);
3007 drop_int (&ob);
3008 ID;
3009 INT;
3010 INTn (section index);
3011 EXPn (offset);
3012 INTn (stuff);
3013
3014 block ();
3015
3016 OUT (0xf9);
3017 NEXT ();
3018 EXPn (Size in Maus);
3019 fill_int (&ob);
3020 }
3021 break;
3022 }
3023 }
3024
3025 static void
3026 e2_record (void)
3027 {
3028 OUT (0xe2);
3029 NEXT ();
3030 OUT (0xce);
3031 NEXT ();
3032 INT;
3033 EXP;
3034 }
3035
3036 static void
3037 block (void)
3038 {
3039 int ch;
3040
3041 while (1)
3042 {
3043 ch = THIS ();
3044 switch (ch)
3045 {
3046 case 0xe1:
3047 case 0xe5:
3048 return;
3049 case 0xf9:
3050 return;
3051 case 0xf0:
3052 f0_record ();
3053 break;
3054 case 0xf1:
3055 f1_record ();
3056 break;
3057 case 0xf2:
3058 f2_record ();
3059 break;
3060 case 0xf8:
3061 f8_record ();
3062 break;
3063 case 0xe2:
3064 e2_record ();
3065 break;
3066
3067 }
3068 }
3069 }
3070
3071 /* Moves all the debug information from the source bfd to the output
3072 bfd, and relocates any expressions it finds. */
3073
3074 static void
3075 relocate_debug (bfd *output ATTRIBUTE_UNUSED,
3076 bfd *input)
3077 {
3078 #define IBS 400
3079 #define OBS 400
3080 unsigned char input_buffer[IBS];
3081
3082 input_ptr_start = input_ptr = input_buffer;
3083 input_ptr_end = input_buffer + IBS;
3084 input_bfd = input;
3085 /* FIXME: Check return value. I'm not sure whether it needs to read
3086 the entire buffer or not. */
3087 bfd_bread ((void *) input_ptr_start, (bfd_size_type) IBS, input);
3088 block ();
3089 }
3090
3091 /* Gather together all the debug information from each input BFD into
3092 one place, relocating it and emitting it as we go. */
3093
3094 static bfd_boolean
3095 ieee_write_debug_part (bfd *abfd)
3096 {
3097 ieee_data_type *ieee = IEEE_DATA (abfd);
3098 bfd_chain_type *chain = ieee->chain_root;
3099 unsigned char obuff[OBS];
3100 bfd_boolean some_debug = FALSE;
3101 file_ptr here = bfd_tell (abfd);
3102
3103 output_ptr_start = output_ptr = obuff;
3104 output_ptr_end = obuff + OBS;
3105 output_ptr = obuff;
3106 output_bfd = abfd;
3107
3108 if (chain == (bfd_chain_type *) NULL)
3109 {
3110 asection *s;
3111
3112 for (s = abfd->sections; s != NULL; s = s->next)
3113 if ((s->flags & SEC_DEBUGGING) != 0)
3114 break;
3115 if (s == NULL)
3116 {
3117 ieee->w.r.debug_information_part = 0;
3118 return TRUE;
3119 }
3120
3121 ieee->w.r.debug_information_part = here;
3122 if (bfd_bwrite (s->contents, s->size, abfd) != s->size)
3123 return FALSE;
3124 }
3125 else
3126 {
3127 while (chain != (bfd_chain_type *) NULL)
3128 {
3129 bfd *entry = chain->this;
3130 ieee_data_type *entry_ieee = IEEE_DATA (entry);
3131
3132 if (entry_ieee->w.r.debug_information_part)
3133 {
3134 if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
3135 SEEK_SET) != 0)
3136 return FALSE;
3137 relocate_debug (abfd, entry);
3138 }
3139
3140 chain = chain->next;
3141 }
3142
3143 if (some_debug)
3144 ieee->w.r.debug_information_part = here;
3145 else
3146 ieee->w.r.debug_information_part = 0;
3147
3148 flush ();
3149 }
3150
3151 return TRUE;
3152 }
3153
3154 /* Write the data in an ieee way. */
3155
3156 static bfd_boolean
3157 ieee_write_data_part (bfd *abfd)
3158 {
3159 asection *s;
3160
3161 ieee_data_type *ieee = IEEE_DATA (abfd);
3162 ieee->w.r.data_part = bfd_tell (abfd);
3163
3164 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3165 {
3166 /* Skip sections that have no loadable contents (.bss,
3167 debugging, etc.) */
3168 if ((s->flags & SEC_LOAD) == 0)
3169 continue;
3170
3171 /* Sort the reloc records so we can insert them in the correct
3172 places. */
3173 if (s->reloc_count != 0)
3174 {
3175 if (! do_with_relocs (abfd, s))
3176 return FALSE;
3177 }
3178 else
3179 {
3180 if (! do_without_relocs (abfd, s))
3181 return FALSE;
3182 }
3183 }
3184
3185 return TRUE;
3186 }
3187
3188 static bfd_boolean
3189 init_for_output (bfd *abfd)
3190 {
3191 asection *s;
3192
3193 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3194 {
3195 if ((s->flags & SEC_DEBUGGING) != 0)
3196 continue;
3197 if (s->size != 0)
3198 {
3199 bfd_size_type size = s->size;
3200 ieee_per_section (s)->data = bfd_alloc (abfd, size);
3201 if (!ieee_per_section (s)->data)
3202 return FALSE;
3203 }
3204 }
3205 return TRUE;
3206 }
3207 \f
3208 /* Exec and core file sections. */
3209
3210 /* Set section contents is complicated with IEEE since the format is
3211 not a byte image, but a record stream. */
3212
3213 static bfd_boolean
3214 ieee_set_section_contents (bfd *abfd,
3215 sec_ptr section,
3216 const void * location,
3217 file_ptr offset,
3218 bfd_size_type count)
3219 {
3220 if ((section->flags & SEC_DEBUGGING) != 0)
3221 {
3222 if (section->contents == NULL)
3223 {
3224 bfd_size_type size = section->size;
3225 section->contents = bfd_alloc (abfd, size);
3226 if (section->contents == NULL)
3227 return FALSE;
3228 }
3229 /* bfd_set_section_contents has already checked that everything
3230 is within range. */
3231 memcpy (section->contents + offset, location, (size_t) count);
3232 return TRUE;
3233 }
3234
3235 if (ieee_per_section (section)->data == (bfd_byte *) NULL)
3236 {
3237 if (!init_for_output (abfd))
3238 return FALSE;
3239 }
3240 memcpy ((void *) (ieee_per_section (section)->data + offset),
3241 (void *) location,
3242 (unsigned int) count);
3243 return TRUE;
3244 }
3245
3246 /* Write the external symbols of a file. IEEE considers two sorts of
3247 external symbols, public, and referenced. It uses to internal
3248 forms to index them as well. When we write them out we turn their
3249 symbol values into indexes from the right base. */
3250
3251 static bfd_boolean
3252 ieee_write_external_part (bfd *abfd)
3253 {
3254 asymbol **q;
3255 ieee_data_type *ieee = IEEE_DATA (abfd);
3256 unsigned int reference_index = IEEE_REFERENCE_BASE;
3257 unsigned int public_index = IEEE_PUBLIC_BASE + 2;
3258 file_ptr here = bfd_tell (abfd);
3259 bfd_boolean hadone = FALSE;
3260
3261 if (abfd->outsymbols != (asymbol **) NULL)
3262 {
3263
3264 for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++)
3265 {
3266 asymbol *p = *q;
3267
3268 if (bfd_is_und_section (p->section))
3269 {
3270 /* This must be a symbol reference. */
3271 if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3272 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3273 || ! ieee_write_id (abfd, p->name))
3274 return FALSE;
3275 p->value = reference_index;
3276 reference_index++;
3277 hadone = TRUE;
3278 }
3279 else if (bfd_is_com_section (p->section))
3280 {
3281 /* This is a weak reference. */
3282 if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3283 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3284 || ! ieee_write_id (abfd, p->name)
3285 || ! ieee_write_byte (abfd,
3286 ieee_weak_external_reference_enum)
3287 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3288 || ! ieee_write_int (abfd, p->value))
3289 return FALSE;
3290 p->value = reference_index;
3291 reference_index++;
3292 hadone = TRUE;
3293 }
3294 else if (p->flags & BSF_GLOBAL)
3295 {
3296 /* This must be a symbol definition. */
3297 if (! ieee_write_byte (abfd, ieee_external_symbol_enum)
3298 || ! ieee_write_int (abfd, (bfd_vma) public_index)
3299 || ! ieee_write_id (abfd, p->name)
3300 || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
3301 || ! ieee_write_int (abfd, (bfd_vma) public_index)
3302 || ! ieee_write_byte (abfd, 15) /* Instruction address. */
3303 || ! ieee_write_byte (abfd, 19) /* Static symbol. */
3304 || ! ieee_write_byte (abfd, 1)) /* One of them. */
3305 return FALSE;
3306
3307 /* Write out the value. */
3308 if (! ieee_write_2bytes (abfd, ieee_value_record_enum)
3309 || ! ieee_write_int (abfd, (bfd_vma) public_index))
3310 return FALSE;
3311 if (! bfd_is_abs_section (p->section))
3312 {
3313 if (abfd->flags & EXEC_P)
3314 {
3315 /* If fully linked, then output all symbols
3316 relocated. */
3317 if (! (ieee_write_int
3318 (abfd,
3319 (p->value
3320 + p->section->output_offset
3321 + p->section->output_section->vma))))
3322 return FALSE;
3323 }
3324 else
3325 {
3326 if (! (ieee_write_expression
3327 (abfd,
3328 p->value + p->section->output_offset,
3329 p->section->output_section->symbol,
3330 FALSE, 0)))
3331 return FALSE;
3332 }
3333 }
3334 else
3335 {
3336 if (! ieee_write_expression (abfd,
3337 p->value,
3338 bfd_abs_section_ptr->symbol,
3339 FALSE, 0))
3340 return FALSE;
3341 }
3342 p->value = public_index;
3343 public_index++;
3344 hadone = TRUE;
3345 }
3346 else
3347 {
3348 /* This can happen - when there are gaps in the symbols read
3349 from an input ieee file. */
3350 }
3351 }
3352 }
3353 if (hadone)
3354 ieee->w.r.external_part = here;
3355
3356 return TRUE;
3357 }
3358
3359
3360 static const unsigned char exten[] =
3361 {
3362 0xf0, 0x20, 0x00,
3363 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3. */
3364 0xf1, 0xce, 0x20, 0x00, 39, 2, /* Keep symbol in original case. */
3365 0xf1, 0xce, 0x20, 0x00, 38 /* Set object type relocatable to x. */
3366 };
3367
3368 static const unsigned char envi[] =
3369 {
3370 0xf0, 0x21, 0x00,
3371
3372 /* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3373 0x19, 0x2c,
3374 */
3375 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok. */
3376
3377 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix. */
3378 /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
3379 };
3380
3381 static bfd_boolean
3382 ieee_write_me_part (bfd *abfd)
3383 {
3384 ieee_data_type *ieee = IEEE_DATA (abfd);
3385 ieee->w.r.trailer_part = bfd_tell (abfd);
3386 if (abfd->start_address)
3387 {
3388 if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum)
3389 || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum)
3390 || ! ieee_write_int (abfd, abfd->start_address)
3391 || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum))
3392 return FALSE;
3393 }
3394 ieee->w.r.me_record = bfd_tell (abfd);
3395 if (! ieee_write_byte (abfd, ieee_module_end_enum))
3396 return FALSE;
3397 return TRUE;
3398 }
3399
3400 /* Write out the IEEE processor ID. */
3401
3402 static bfd_boolean
3403 ieee_write_processor (bfd *abfd)
3404 {
3405 const bfd_arch_info_type *arch;
3406
3407 arch = bfd_get_arch_info (abfd);
3408 switch (arch->arch)
3409 {
3410 default:
3411 if (! ieee_write_id (abfd, bfd_printable_name (abfd)))
3412 return FALSE;
3413 break;
3414
3415 case bfd_arch_a29k:
3416 if (! ieee_write_id (abfd, "29000"))
3417 return FALSE;
3418 break;
3419
3420 case bfd_arch_h8300:
3421 if (! ieee_write_id (abfd, "H8/300"))
3422 return FALSE;
3423 break;
3424
3425 case bfd_arch_h8500:
3426 if (! ieee_write_id (abfd, "H8/500"))
3427 return FALSE;
3428 break;
3429
3430 case bfd_arch_i960:
3431 switch (arch->mach)
3432 {
3433 default:
3434 case bfd_mach_i960_core:
3435 case bfd_mach_i960_ka_sa:
3436 if (! ieee_write_id (abfd, "80960KA"))
3437 return FALSE;
3438 break;
3439
3440 case bfd_mach_i960_kb_sb:
3441 if (! ieee_write_id (abfd, "80960KB"))
3442 return FALSE;
3443 break;
3444
3445 case bfd_mach_i960_ca:
3446 if (! ieee_write_id (abfd, "80960CA"))
3447 return FALSE;
3448 break;
3449
3450 case bfd_mach_i960_mc:
3451 case bfd_mach_i960_xa:
3452 if (! ieee_write_id (abfd, "80960MC"))
3453 return FALSE;
3454 break;
3455 }
3456 break;
3457
3458 case bfd_arch_m68k:
3459 {
3460 const char *id;
3461
3462 switch (arch->mach)
3463 {
3464 default: id = "68020"; break;
3465 case bfd_mach_m68000: id = "68000"; break;
3466 case bfd_mach_m68008: id = "68008"; break;
3467 case bfd_mach_m68010: id = "68010"; break;
3468 case bfd_mach_m68020: id = "68020"; break;
3469 case bfd_mach_m68030: id = "68030"; break;
3470 case bfd_mach_m68040: id = "68040"; break;
3471 case bfd_mach_m68060: id = "68060"; break;
3472 case bfd_mach_cpu32: id = "cpu32"; break;
3473 case bfd_mach_mcf5200:id = "5200"; break;
3474 case bfd_mach_mcf5206e:id = "5206e"; break;
3475 case bfd_mach_mcf5307:id = "5307"; break;
3476 case bfd_mach_mcf5407:id = "5407"; break;
3477 case bfd_mach_mcf528x:id = "5282"; break;
3478 }
3479
3480 if (! ieee_write_id (abfd, id))
3481 return FALSE;
3482 }
3483 break;
3484 }
3485
3486 return TRUE;
3487 }
3488
3489 static bfd_boolean
3490 ieee_write_object_contents (bfd *abfd)
3491 {
3492 ieee_data_type *ieee = IEEE_DATA (abfd);
3493 unsigned int i;
3494 file_ptr old;
3495
3496 /* Fast forward over the header area. */
3497 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3498 return FALSE;
3499
3500 if (! ieee_write_byte (abfd, ieee_module_beginning_enum)
3501 || ! ieee_write_processor (abfd)
3502 || ! ieee_write_id (abfd, abfd->filename))
3503 return FALSE;
3504
3505 /* Fast forward over the variable bits. */
3506 if (! ieee_write_byte (abfd, ieee_address_descriptor_enum))
3507 return FALSE;
3508
3509 /* Bits per MAU. */
3510 if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))))
3511 return FALSE;
3512 /* MAU's per address. */
3513 if (! ieee_write_byte (abfd,
3514 (bfd_byte) (bfd_arch_bits_per_address (abfd)
3515 / bfd_arch_bits_per_byte (abfd))))
3516 return FALSE;
3517
3518 old = bfd_tell (abfd);
3519 if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
3520 return FALSE;
3521
3522 ieee->w.r.extension_record = bfd_tell (abfd);
3523 if (bfd_bwrite ((char *) exten, (bfd_size_type) sizeof (exten), abfd)
3524 != sizeof (exten))
3525 return FALSE;
3526 if (abfd->flags & EXEC_P)
3527 {
3528 if (! ieee_write_byte (abfd, 0x1)) /* Absolute. */
3529 return FALSE;
3530 }
3531 else
3532 {
3533 if (! ieee_write_byte (abfd, 0x2)) /* Relocateable. */
3534 return FALSE;
3535 }
3536
3537 ieee->w.r.environmental_record = bfd_tell (abfd);
3538 if (bfd_bwrite ((char *) envi, (bfd_size_type) sizeof (envi), abfd)
3539 != sizeof (envi))
3540 return FALSE;
3541
3542 /* The HP emulator database requires a timestamp in the file. */
3543 {
3544 time_t now;
3545 const struct tm *t;
3546
3547 time (&now);
3548 t = (struct tm *) localtime (&now);
3549 if (! ieee_write_2bytes (abfd, (int) ieee_atn_record_enum)
3550 || ! ieee_write_byte (abfd, 0x21)
3551 || ! ieee_write_byte (abfd, 0)
3552 || ! ieee_write_byte (abfd, 50)
3553 || ! ieee_write_int (abfd, (bfd_vma) (t->tm_year + 1900))
3554 || ! ieee_write_int (abfd, (bfd_vma) (t->tm_mon + 1))
3555 || ! ieee_write_int (abfd, (bfd_vma) t->tm_mday)
3556 || ! ieee_write_int (abfd, (bfd_vma) t->tm_hour)
3557 || ! ieee_write_int (abfd, (bfd_vma) t->tm_min)
3558 || ! ieee_write_int (abfd, (bfd_vma) t->tm_sec))
3559 return FALSE;
3560 }
3561
3562 output_bfd = abfd;
3563
3564 flush ();
3565
3566 if (! ieee_write_section_part (abfd))
3567 return FALSE;
3568 /* First write the symbols. This changes their values into table
3569 indeces so we cant use it after this point. */
3570 if (! ieee_write_external_part (abfd))
3571 return FALSE;
3572
3573 /* Write any debugs we have been told about. */
3574 if (! ieee_write_debug_part (abfd))
3575 return FALSE;
3576
3577 /* Can only write the data once the symbols have been written, since
3578 the data contains relocation information which points to the
3579 symbols. */
3580 if (! ieee_write_data_part (abfd))
3581 return FALSE;
3582
3583 /* At the end we put the end! */
3584 if (! ieee_write_me_part (abfd))
3585 return FALSE;
3586
3587 /* Generate the header. */
3588 if (bfd_seek (abfd, old, SEEK_SET) != 0)
3589 return FALSE;
3590
3591 for (i = 0; i < N_W_VARIABLES; i++)
3592 {
3593 if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum)
3594 || ! ieee_write_byte (abfd, (bfd_byte) i)
3595 || ! ieee_write_int5_out (abfd, (bfd_vma) ieee->w.offset[i]))
3596 return FALSE;
3597 }
3598
3599 return TRUE;
3600 }
3601 \f
3602 /* Native-level interface to symbols. */
3603
3604 /* We read the symbols into a buffer, which is discarded when this
3605 function exits. We read the strings into a buffer large enough to
3606 hold them all plus all the cached symbol entries. */
3607
3608 static asymbol *
3609 ieee_make_empty_symbol (bfd *abfd)
3610 {
3611 bfd_size_type amt = sizeof (ieee_symbol_type);
3612 ieee_symbol_type *new = bfd_zalloc (abfd, amt);
3613
3614 if (!new)
3615 return NULL;
3616 new->symbol.the_bfd = abfd;
3617 return &new->symbol;
3618 }
3619
3620 static bfd *
3621 ieee_openr_next_archived_file (bfd *arch, bfd *prev)
3622 {
3623 ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
3624
3625 /* Take the next one from the arch state, or reset. */
3626 if (prev == (bfd *) NULL)
3627 /* Reset the index - the first two entries are bogus. */
3628 ar->element_index = 2;
3629
3630 while (TRUE)
3631 {
3632 ieee_ar_obstack_type *p = ar->elements + ar->element_index;
3633
3634 ar->element_index++;
3635 if (ar->element_index <= ar->element_count)
3636 {
3637 if (p->file_offset != (file_ptr) 0)
3638 {
3639 if (p->abfd == (bfd *) NULL)
3640 {
3641 p->abfd = _bfd_create_empty_archive_element_shell (arch);
3642 p->abfd->origin = p->file_offset;
3643 }
3644 return p->abfd;
3645 }
3646 }
3647 else
3648 {
3649 bfd_set_error (bfd_error_no_more_archived_files);
3650 return NULL;
3651 }
3652 }
3653 }
3654
3655 static bfd_boolean
3656 ieee_find_nearest_line (bfd *abfd ATTRIBUTE_UNUSED,
3657 asection *section ATTRIBUTE_UNUSED,
3658 asymbol **symbols ATTRIBUTE_UNUSED,
3659 bfd_vma offset ATTRIBUTE_UNUSED,
3660 const char **filename_ptr ATTRIBUTE_UNUSED,
3661 const char **functionname_ptr ATTRIBUTE_UNUSED,
3662 unsigned int *line_ptr ATTRIBUTE_UNUSED)
3663 {
3664 return FALSE;
3665 }
3666
3667 static int
3668 ieee_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
3669 {
3670 ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL;
3671 ieee_data_type *ieee;
3672
3673 if (abfd->my_archive != NULL)
3674 ar = abfd->my_archive->tdata.ieee_ar_data;
3675 if (ar == (ieee_ar_data_type *) NULL)
3676 {
3677 bfd_set_error (bfd_error_invalid_operation);
3678 return -1;
3679 }
3680
3681 if (IEEE_DATA (abfd) == NULL)
3682 {
3683 if (ieee_object_p (abfd) == NULL)
3684 {
3685 bfd_set_error (bfd_error_wrong_format);
3686 return -1;
3687 }
3688 }
3689
3690 ieee = IEEE_DATA (abfd);
3691
3692 buf->st_size = ieee->w.r.me_record + 1;
3693 buf->st_mode = 0644;
3694 return 0;
3695 }
3696
3697 static int
3698 ieee_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
3699 bfd_boolean x ATTRIBUTE_UNUSED)
3700 {
3701 return 0;
3702 }
3703
3704 #define ieee_close_and_cleanup _bfd_generic_close_and_cleanup
3705 #define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3706
3707 #define ieee_slurp_armap bfd_true
3708 #define ieee_slurp_extended_name_table bfd_true
3709 #define ieee_construct_extended_name_table \
3710 ((bfd_boolean (*) \
3711 (bfd *, char **, bfd_size_type *, const char **)) \
3712 bfd_true)
3713 #define ieee_truncate_arname bfd_dont_truncate_arname
3714 #define ieee_write_armap \
3715 ((bfd_boolean (*) \
3716 (bfd *, unsigned int, struct orl *, unsigned int, int)) \
3717 bfd_true)
3718 #define ieee_read_ar_hdr bfd_nullvoidptr
3719 #define ieee_update_armap_timestamp bfd_true
3720 #define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
3721
3722 #define ieee_bfd_is_target_special_symbol \
3723 ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
3724 #define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
3725 #define ieee_get_lineno _bfd_nosymbols_get_lineno
3726 #define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3727 #define ieee_read_minisymbols _bfd_generic_read_minisymbols
3728 #define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3729
3730 #define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3731
3732 #define ieee_set_arch_mach _bfd_generic_set_arch_mach
3733
3734 #define ieee_get_section_contents_in_window \
3735 _bfd_generic_get_section_contents_in_window
3736 #define ieee_bfd_get_relocated_section_contents \
3737 bfd_generic_get_relocated_section_contents
3738 #define ieee_bfd_relax_section bfd_generic_relax_section
3739 #define ieee_bfd_gc_sections bfd_generic_gc_sections
3740 #define ieee_bfd_merge_sections bfd_generic_merge_sections
3741 #define ieee_bfd_is_group_section bfd_generic_is_group_section
3742 #define ieee_bfd_discard_group bfd_generic_discard_group
3743 #define ieee_section_already_linked \
3744 _bfd_generic_section_already_linked
3745 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3746 #define ieee_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
3747 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
3748 #define ieee_bfd_link_just_syms _bfd_generic_link_just_syms
3749 #define ieee_bfd_final_link _bfd_generic_final_link
3750 #define ieee_bfd_link_split_section _bfd_generic_link_split_section
3751
3752 const bfd_target ieee_vec =
3753 {
3754 "ieee", /* Name. */
3755 bfd_target_ieee_flavour,
3756 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
3757 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
3758 (HAS_RELOC | EXEC_P | /* Object flags. */
3759 HAS_LINENO | HAS_DEBUG |
3760 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
3761 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
3762 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
3763 '_', /* Leading underscore. */
3764 ' ', /* AR_pad_char. */
3765 16, /* AR_max_namelen. */
3766 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3767 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3768 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
3769 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3770 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3771 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
3772
3773 {_bfd_dummy_target,
3774 ieee_object_p, /* bfd_check_format. */
3775 ieee_archive_p,
3776 _bfd_dummy_target,
3777 },
3778 {
3779 bfd_false,
3780 ieee_mkobject,
3781 _bfd_generic_mkarchive,
3782 bfd_false
3783 },
3784 {
3785 bfd_false,
3786 ieee_write_object_contents,
3787 _bfd_write_archive_contents,
3788 bfd_false,
3789 },
3790
3791 /* ieee_close_and_cleanup, ieee_bfd_free_cached_info, ieee_new_section_hook,
3792 ieee_get_section_contents, ieee_get_section_contents_in_window. */
3793 BFD_JUMP_TABLE_GENERIC (ieee),
3794
3795 BFD_JUMP_TABLE_COPY (_bfd_generic),
3796 BFD_JUMP_TABLE_CORE (_bfd_nocore),
3797
3798 /* ieee_slurp_armap, ieee_slurp_extended_name_table,
3799 ieee_construct_extended_name_table, ieee_truncate_arname,
3800 ieee_write_armap, ieee_read_ar_hdr, ieee_openr_next_archived_file,
3801 ieee_get_elt_at_index, ieee_generic_stat_arch_elt,
3802 ieee_update_armap_timestamp. */
3803 BFD_JUMP_TABLE_ARCHIVE (ieee),
3804
3805 /* ieee_get_symtab_upper_bound, ieee_canonicalize_symtab,
3806 ieee_make_empty_symbol, ieee_print_symbol, ieee_get_symbol_info,
3807 ieee_bfd_is_local_label_name, ieee_get_lineno,
3808 ieee_find_nearest_line, ieee_bfd_make_debug_symbol,
3809 ieee_read_minisymbols, ieee_minisymbol_to_symbol. */
3810 BFD_JUMP_TABLE_SYMBOLS (ieee),
3811
3812 /* ieee_get_reloc_upper_bound, ieee_canonicalize_reloc,
3813 ieee_bfd_reloc_type_lookup. */
3814 BFD_JUMP_TABLE_RELOCS (ieee),
3815
3816 /* ieee_set_arch_mach, ieee_set_section_contents. */
3817 BFD_JUMP_TABLE_WRITE (ieee),
3818
3819 /* ieee_sizeof_headers, ieee_bfd_get_relocated_section_contents,
3820 ieee_bfd_relax_section, ieee_bfd_link_hash_table_create,
3821 _bfd_generic_link_hash_table_free,
3822 ieee_bfd_link_add_symbols, ieee_bfd_final_link,
3823 ieee_bfd_link_split_section, ieee_bfd_gc_sections,
3824 ieee_bfd_merge_sections. */
3825 BFD_JUMP_TABLE_LINK (ieee),
3826
3827 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
3828
3829 NULL,
3830
3831 NULL
3832 };
git-cvsimport of binutils cvsroot