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