projects / deliverable / binutils-gdb.git / blob
? search:


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