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