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