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