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