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