]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/ieee.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bfd
[thirdparty/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, 2003
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 (s);
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 (s);
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
2196 = (PTR) 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 (section);
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_reloc_type *src = (ieee_reloc_type *) (section->relocation);
2241 ieee_data_type *ieee = IEEE_DATA (abfd);
2242
2243 if ((section->flags & SEC_DEBUGGING) != 0)
2244 return 0;
2245
2246 while (src != (ieee_reloc_type *) NULL)
2247 {
2248 /* Work out which symbol to attach it this reloc to */
2249 switch (src->symbol.letter)
2250 {
2251 case 'I':
2252 src->relent.sym_ptr_ptr =
2253 symbols + src->symbol.index + ieee->external_symbol_base_offset;
2254 break;
2255 case 'X':
2256 src->relent.sym_ptr_ptr =
2257 symbols + src->symbol.index + ieee->external_reference_base_offset;
2258 break;
2259 case 0:
2260 if (src->relent.sym_ptr_ptr != NULL)
2261 src->relent.sym_ptr_ptr =
2262 src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
2263 break;
2264 default:
2265
2266 BFD_FAIL ();
2267 }
2268 *relptr++ = &src->relent;
2269 src = src->next;
2270 }
2271 *relptr = (arelent *) NULL;
2272 return section->reloc_count;
2273 }
2274
2275 static int
2276 comp (ap, bp)
2277 const PTR ap;
2278 const PTR bp;
2279 {
2280 arelent *a = *((arelent **) ap);
2281 arelent *b = *((arelent **) bp);
2282 return a->address - b->address;
2283 }
2284
2285 /* Write the section headers. */
2286
2287 static bfd_boolean
2288 ieee_write_section_part (abfd)
2289 bfd *abfd;
2290 {
2291 ieee_data_type *ieee = IEEE_DATA (abfd);
2292 asection *s;
2293 ieee->w.r.section_part = bfd_tell (abfd);
2294 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2295 {
2296 if (! bfd_is_abs_section (s)
2297 && (s->flags & SEC_DEBUGGING) == 0)
2298 {
2299 if (! ieee_write_byte (abfd, ieee_section_type_enum)
2300 || ! ieee_write_byte (abfd,
2301 (bfd_byte) (s->index
2302 + IEEE_SECTION_NUMBER_BASE)))
2303 return FALSE;
2304
2305 if (abfd->flags & EXEC_P)
2306 {
2307 /* This image is executable, so output absolute sections */
2308 if (! ieee_write_byte (abfd, ieee_variable_A_enum)
2309 || ! ieee_write_byte (abfd, ieee_variable_S_enum))
2310 return FALSE;
2311 }
2312 else
2313 {
2314 if (! ieee_write_byte (abfd, ieee_variable_C_enum))
2315 return FALSE;
2316 }
2317
2318 switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM))
2319 {
2320 case SEC_CODE | SEC_LOAD:
2321 case SEC_CODE:
2322 if (! ieee_write_byte (abfd, ieee_variable_P_enum))
2323 return FALSE;
2324 break;
2325 case SEC_DATA:
2326 default:
2327 if (! ieee_write_byte (abfd, ieee_variable_D_enum))
2328 return FALSE;
2329 break;
2330 case SEC_ROM:
2331 case SEC_ROM | SEC_DATA:
2332 case SEC_ROM | SEC_LOAD:
2333 case SEC_ROM | SEC_DATA | SEC_LOAD:
2334 if (! ieee_write_byte (abfd, ieee_variable_R_enum))
2335 return FALSE;
2336 }
2337
2338
2339 if (! ieee_write_id (abfd, s->name))
2340 return FALSE;
2341 #if 0
2342 ieee_write_int (abfd, 0); /* Parent */
2343 ieee_write_int (abfd, 0); /* Brother */
2344 ieee_write_int (abfd, 0); /* Context */
2345 #endif
2346 /* Alignment */
2347 if (! ieee_write_byte (abfd, ieee_section_alignment_enum)
2348 || ! ieee_write_byte (abfd,
2349 (bfd_byte) (s->index
2350 + IEEE_SECTION_NUMBER_BASE))
2351 || ! ieee_write_int (abfd, (bfd_vma) 1 << s->alignment_power))
2352 return FALSE;
2353
2354 /* Size */
2355 if (! ieee_write_2bytes (abfd, ieee_section_size_enum)
2356 || ! ieee_write_byte (abfd,
2357 (bfd_byte) (s->index
2358 + IEEE_SECTION_NUMBER_BASE))
2359 || ! ieee_write_int (abfd, s->_raw_size))
2360 return FALSE;
2361 if (abfd->flags & EXEC_P)
2362 {
2363 /* Relocateable sections don't have asl records */
2364 /* Vma */
2365 if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum)
2366 || ! ieee_write_byte (abfd,
2367 ((bfd_byte)
2368 (s->index
2369 + IEEE_SECTION_NUMBER_BASE)))
2370 || ! ieee_write_int (abfd, s->lma))
2371 return FALSE;
2372 }
2373 }
2374 }
2375
2376 return TRUE;
2377 }
2378
2379
2380 static bfd_boolean
2381 do_with_relocs (abfd, s)
2382 bfd *abfd;
2383 asection *s;
2384 {
2385 unsigned int number_of_maus_in_address =
2386 bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd);
2387 unsigned int relocs_to_go = s->reloc_count;
2388 bfd_byte *stream = ieee_per_section (s)->data;
2389 arelent **p = s->orelocation;
2390 bfd_size_type current_byte_index = 0;
2391
2392 qsort (s->orelocation,
2393 relocs_to_go,
2394 sizeof (arelent **),
2395 comp);
2396
2397 /* Output the section preheader */
2398 if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2399 || ! ieee_write_byte (abfd,
2400 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))
2401 || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum)
2402 || ! ieee_write_byte (abfd,
2403 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)))
2404 return FALSE;
2405
2406 if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0)
2407 {
2408 if (! ieee_write_int (abfd, s->lma))
2409 return FALSE;
2410 }
2411 else
2412 {
2413 if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2414 return FALSE;
2415 }
2416
2417 if (relocs_to_go == 0)
2418 {
2419 /* If there aren't any relocations then output the load constant
2420 byte opcode rather than the load with relocation opcode */
2421
2422 while (current_byte_index < s->_raw_size)
2423 {
2424 bfd_size_type run;
2425 unsigned int MAXRUN = 127;
2426 run = MAXRUN;
2427 if (run > s->_raw_size - current_byte_index)
2428 {
2429 run = s->_raw_size - current_byte_index;
2430 }
2431
2432 if (run != 0)
2433 {
2434 if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum))
2435 return FALSE;
2436 /* Output a stream of bytes */
2437 if (! ieee_write_int (abfd, run))
2438 return FALSE;
2439 if (bfd_bwrite ((PTR) (stream + current_byte_index), run, abfd)
2440 != run)
2441 return FALSE;
2442 current_byte_index += run;
2443 }
2444 }
2445 }
2446 else
2447 {
2448 if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum))
2449 return FALSE;
2450
2451 /* Output the data stream as the longest sequence of bytes
2452 possible, allowing for the a reasonable packet size and
2453 relocation stuffs. */
2454
2455 if ((PTR) stream == (PTR) NULL)
2456 {
2457 /* Outputting a section without data, fill it up */
2458 stream = (unsigned char *) bfd_zalloc (abfd, s->_raw_size);
2459 if (!stream)
2460 return FALSE;
2461 }
2462 while (current_byte_index < s->_raw_size)
2463 {
2464 bfd_size_type run;
2465 unsigned int MAXRUN = 127;
2466 if (relocs_to_go)
2467 {
2468 run = (*p)->address - current_byte_index;
2469 if (run > MAXRUN)
2470 run = MAXRUN;
2471 }
2472 else
2473 {
2474 run = MAXRUN;
2475 }
2476 if (run > s->_raw_size - current_byte_index)
2477 {
2478 run = s->_raw_size - current_byte_index;
2479 }
2480
2481 if (run != 0)
2482 {
2483 /* Output a stream of bytes */
2484 if (! ieee_write_int (abfd, run))
2485 return FALSE;
2486 if (bfd_bwrite ((PTR) (stream + current_byte_index), run, abfd)
2487 != run)
2488 return FALSE;
2489 current_byte_index += run;
2490 }
2491 /* Output any relocations here */
2492 if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
2493 {
2494 while (relocs_to_go
2495 && (*p) && (*p)->address == current_byte_index)
2496 {
2497 arelent *r = *p;
2498 bfd_signed_vma ov;
2499
2500 #if 0
2501 if (r->howto->pc_relative)
2502 {
2503 r->addend += current_byte_index;
2504 }
2505 #endif
2506
2507 switch (r->howto->size)
2508 {
2509 case 2:
2510
2511 ov = bfd_get_signed_32 (abfd,
2512 stream + current_byte_index);
2513 current_byte_index += 4;
2514 break;
2515 case 1:
2516 ov = bfd_get_signed_16 (abfd,
2517 stream + current_byte_index);
2518 current_byte_index += 2;
2519 break;
2520 case 0:
2521 ov = bfd_get_signed_8 (abfd,
2522 stream + current_byte_index);
2523 current_byte_index++;
2524 break;
2525 default:
2526 ov = 0;
2527 BFD_FAIL ();
2528 return FALSE;
2529 }
2530
2531 ov &= r->howto->src_mask;
2532
2533 if (r->howto->pc_relative
2534 && ! r->howto->pcrel_offset)
2535 ov += r->address;
2536
2537 if (! ieee_write_byte (abfd,
2538 ieee_function_either_open_b_enum))
2539 return FALSE;
2540
2541 /* abort();*/
2542
2543 if (r->sym_ptr_ptr != (asymbol **) NULL)
2544 {
2545 if (! ieee_write_expression (abfd, r->addend + ov,
2546 *(r->sym_ptr_ptr),
2547 r->howto->pc_relative,
2548 (unsigned) s->index))
2549 return FALSE;
2550 }
2551 else
2552 {
2553 if (! ieee_write_expression (abfd, r->addend + ov,
2554 (asymbol *) NULL,
2555 r->howto->pc_relative,
2556 (unsigned) s->index))
2557 return FALSE;
2558 }
2559
2560 if (number_of_maus_in_address
2561 != bfd_get_reloc_size (r->howto))
2562 {
2563 bfd_vma rsize = bfd_get_reloc_size (r->howto);
2564 if (! ieee_write_int (abfd, rsize))
2565 return FALSE;
2566 }
2567 if (! ieee_write_byte (abfd,
2568 ieee_function_either_close_b_enum))
2569 return FALSE;
2570
2571 relocs_to_go--;
2572 p++;
2573 }
2574
2575 }
2576 }
2577 }
2578
2579 return TRUE;
2580 }
2581
2582 /* If there are no relocations in the output section then we can be
2583 clever about how we write. We block items up into a max of 127
2584 bytes. */
2585
2586 static bfd_boolean
2587 do_as_repeat (abfd, s)
2588 bfd *abfd;
2589 asection *s;
2590 {
2591 if (s->_raw_size)
2592 {
2593 if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2594 || ! ieee_write_byte (abfd,
2595 (bfd_byte) (s->index
2596 + IEEE_SECTION_NUMBER_BASE))
2597 || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8)
2598 || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff)
2599 || ! ieee_write_byte (abfd,
2600 (bfd_byte) (s->index
2601 + IEEE_SECTION_NUMBER_BASE)))
2602 return FALSE;
2603
2604 if ((abfd->flags & EXEC_P) != 0)
2605 {
2606 if (! ieee_write_int (abfd, s->lma))
2607 return FALSE;
2608 }
2609 else
2610 {
2611 if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2612 return FALSE;
2613 }
2614
2615 if (! ieee_write_byte (abfd, ieee_repeat_data_enum)
2616 || ! ieee_write_int (abfd, s->_raw_size)
2617 || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)
2618 || ! ieee_write_byte (abfd, 1)
2619 || ! ieee_write_byte (abfd, 0))
2620 return FALSE;
2621 }
2622
2623 return TRUE;
2624 }
2625
2626 static bfd_boolean
2627 do_without_relocs (abfd, s)
2628 bfd *abfd;
2629 asection *s;
2630 {
2631 bfd_byte *stream = ieee_per_section (s)->data;
2632
2633 if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
2634 {
2635 if (! do_as_repeat (abfd, s))
2636 return FALSE;
2637 }
2638 else
2639 {
2640 unsigned int i;
2641 for (i = 0; i < s->_raw_size; i++)
2642 {
2643 if (stream[i] != 0)
2644 {
2645 if (! do_with_relocs (abfd, s))
2646 return FALSE;
2647 return TRUE;
2648 }
2649 }
2650 if (! do_as_repeat (abfd, s))
2651 return FALSE;
2652 }
2653
2654 return TRUE;
2655 }
2656
2657
2658 static unsigned char *output_ptr_start;
2659 static unsigned char *output_ptr;
2660 static unsigned char *output_ptr_end;
2661 static unsigned char *input_ptr_start;
2662 static unsigned char *input_ptr;
2663 static unsigned char *input_ptr_end;
2664 static bfd *input_bfd;
2665 static bfd *output_bfd;
2666 static int output_buffer;
2667
2668 static bfd_boolean
2669 ieee_mkobject (abfd)
2670 bfd *abfd;
2671 {
2672 bfd_size_type amt;
2673
2674 output_ptr_start = NULL;
2675 output_ptr = NULL;
2676 output_ptr_end = NULL;
2677 input_ptr_start = NULL;
2678 input_ptr = NULL;
2679 input_ptr_end = NULL;
2680 input_bfd = NULL;
2681 output_bfd = NULL;
2682 output_buffer = 0;
2683 amt = sizeof (ieee_data_type);
2684 abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, amt);
2685 return abfd->tdata.ieee_data != NULL;
2686 }
2687
2688 static void
2689 fill ()
2690 {
2691 bfd_size_type amt = input_ptr_end - input_ptr_start;
2692 /* FIXME: Check return value. I'm not sure whether it needs to read
2693 the entire buffer or not. */
2694 bfd_bread ((PTR) input_ptr_start, amt, input_bfd);
2695 input_ptr = input_ptr_start;
2696 }
2697
2698 static void
2699 flush ()
2700 {
2701 bfd_size_type amt = output_ptr - output_ptr_start;
2702 if (bfd_bwrite ((PTR) (output_ptr_start), amt, output_bfd) != amt)
2703 abort ();
2704 output_ptr = output_ptr_start;
2705 output_buffer++;
2706 }
2707
2708 #define THIS() ( *input_ptr )
2709 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
2710 #define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); }
2711
2712 static void
2713 write_int (value)
2714 int value;
2715 {
2716 if (value >= 0 && value <= 127)
2717 {
2718 OUT (value);
2719 }
2720 else
2721 {
2722 unsigned int length;
2723 /* How many significant bytes ? */
2724 /* FIXME FOR LONGER INTS */
2725 if (value & 0xff000000)
2726 {
2727 length = 4;
2728 }
2729 else if (value & 0x00ff0000)
2730 {
2731 length = 3;
2732 }
2733 else if (value & 0x0000ff00)
2734 {
2735 length = 2;
2736 }
2737 else
2738 length = 1;
2739
2740 OUT ((int) ieee_number_repeat_start_enum + length);
2741 switch (length)
2742 {
2743 case 4:
2744 OUT (value >> 24);
2745 case 3:
2746 OUT (value >> 16);
2747 case 2:
2748 OUT (value >> 8);
2749 case 1:
2750 OUT (value);
2751 }
2752
2753 }
2754 }
2755
2756 static void
2757 copy_id ()
2758 {
2759 int length = THIS ();
2760 char ch;
2761 OUT (length);
2762 NEXT ();
2763 while (length--)
2764 {
2765 ch = THIS ();
2766 OUT (ch);
2767 NEXT ();
2768 }
2769 }
2770
2771 #define VAR(x) ((x | 0x80))
2772 static void
2773 copy_expression ()
2774 {
2775 int stack[10];
2776 int *tos = stack;
2777 int value;
2778 while (1)
2779 {
2780 switch (THIS ())
2781 {
2782 case 0x84:
2783 NEXT ();
2784 value = THIS ();
2785 NEXT ();
2786 value = (value << 8) | THIS ();
2787 NEXT ();
2788 value = (value << 8) | THIS ();
2789 NEXT ();
2790 value = (value << 8) | THIS ();
2791 NEXT ();
2792 *tos++ = value;
2793 break;
2794 case 0x83:
2795 NEXT ();
2796 value = THIS ();
2797 NEXT ();
2798 value = (value << 8) | THIS ();
2799 NEXT ();
2800 value = (value << 8) | THIS ();
2801 NEXT ();
2802 *tos++ = value;
2803 break;
2804 case 0x82:
2805 NEXT ();
2806 value = THIS ();
2807 NEXT ();
2808 value = (value << 8) | THIS ();
2809 NEXT ();
2810 *tos++ = value;
2811 break;
2812 case 0x81:
2813 NEXT ();
2814 value = THIS ();
2815 NEXT ();
2816 *tos++ = value;
2817 break;
2818 case 0x80:
2819 NEXT ();
2820 *tos++ = 0;
2821 break;
2822 default:
2823 if (THIS () > 0x84)
2824 {
2825 /* Not a number, just bug out with the answer */
2826 write_int (*(--tos));
2827 return;
2828 }
2829 *tos++ = THIS ();
2830 NEXT ();
2831 break;
2832 case 0xa5:
2833 /* PLUS anything */
2834 value = *(--tos);
2835 value += *(--tos);
2836 *tos++ = value;
2837 NEXT ();
2838 break;
2839 case VAR ('R'):
2840 {
2841 int section_number;
2842 ieee_data_type *ieee;
2843 asection *s;
2844 NEXT ();
2845 section_number = THIS ();
2846
2847 NEXT ();
2848 ieee = IEEE_DATA (input_bfd);
2849 s = ieee->section_table[section_number];
2850 value = 0;
2851 if (s->output_section)
2852 value = s->output_section->lma;
2853 value += s->output_offset;
2854 *tos++ = value;
2855 }
2856 break;
2857 case 0x90:
2858 {
2859 NEXT ();
2860 write_int (*(--tos));
2861 OUT (0x90);
2862 return;
2863 }
2864 }
2865 }
2866 }
2867
2868 /* Drop the int in the buffer, and copy a null into the gap, which we
2869 will overwrite later */
2870
2871 static void
2872 fill_int (buf)
2873 struct output_buffer_struct *buf;
2874 {
2875 if (buf->buffer == output_buffer)
2876 {
2877 /* Still a chance to output the size */
2878 int value = output_ptr - buf->ptrp + 3;
2879 buf->ptrp[0] = value >> 24;
2880 buf->ptrp[1] = value >> 16;
2881 buf->ptrp[2] = value >> 8;
2882 buf->ptrp[3] = value >> 0;
2883 }
2884 }
2885
2886 static void
2887 drop_int (buf)
2888 struct output_buffer_struct *buf;
2889 {
2890 int type = THIS ();
2891 int ch;
2892 if (type <= 0x84)
2893 {
2894 NEXT ();
2895 switch (type)
2896 {
2897 case 0x84:
2898 ch = THIS ();
2899 NEXT ();
2900 case 0x83:
2901 ch = THIS ();
2902 NEXT ();
2903 case 0x82:
2904 ch = THIS ();
2905 NEXT ();
2906 case 0x81:
2907 ch = THIS ();
2908 NEXT ();
2909 case 0x80:
2910 break;
2911 }
2912 }
2913 OUT (0x84);
2914 buf->ptrp = output_ptr;
2915 buf->buffer = output_buffer;
2916 OUT (0);
2917 OUT (0);
2918 OUT (0);
2919 OUT (0);
2920 }
2921
2922 static void
2923 copy_int ()
2924 {
2925 int type = THIS ();
2926 int ch;
2927 if (type <= 0x84)
2928 {
2929 OUT (type);
2930 NEXT ();
2931 switch (type)
2932 {
2933 case 0x84:
2934 ch = THIS ();
2935 NEXT ();
2936 OUT (ch);
2937 case 0x83:
2938 ch = THIS ();
2939 NEXT ();
2940 OUT (ch);
2941 case 0x82:
2942 ch = THIS ();
2943 NEXT ();
2944 OUT (ch);
2945 case 0x81:
2946 ch = THIS ();
2947 NEXT ();
2948 OUT (ch);
2949 case 0x80:
2950 break;
2951 }
2952 }
2953 }
2954
2955 #define ID copy_id()
2956 #define INT copy_int()
2957 #define EXP copy_expression()
2958 #define INTn(q) copy_int()
2959 #define EXPn(q) copy_expression()
2960
2961 static void
2962 f1_record ()
2963 {
2964 int ch;
2965 /* ATN record */
2966 NEXT ();
2967 ch = THIS ();
2968 switch (ch)
2969 {
2970 default:
2971 OUT (0xf1);
2972 OUT (ch);
2973 break;
2974 case 0xc9:
2975 NEXT ();
2976 OUT (0xf1);
2977 OUT (0xc9);
2978 INT;
2979 INT;
2980 ch = THIS ();
2981 switch (ch)
2982 {
2983 case 0x16:
2984 NEXT ();
2985 break;
2986 case 0x01:
2987 NEXT ();
2988 break;
2989 case 0x00:
2990 NEXT ();
2991 INT;
2992 break;
2993 case 0x03:
2994 NEXT ();
2995 INT;
2996 break;
2997 case 0x13:
2998 EXPn (instruction address);
2999 break;
3000 default:
3001 break;
3002 }
3003 break;
3004 case 0xd8:
3005 /* EXternal ref */
3006 NEXT ();
3007 OUT (0xf1);
3008 OUT (0xd8);
3009 EXP;
3010 EXP;
3011 EXP;
3012 EXP;
3013 break;
3014 case 0xce:
3015 NEXT ();
3016 OUT (0xf1);
3017 OUT (0xce);
3018 INT;
3019 INT;
3020 ch = THIS ();
3021 INT;
3022 switch (ch)
3023 {
3024 case 0x01:
3025 INT;
3026 INT;
3027 break;
3028 case 0x02:
3029 INT;
3030 break;
3031 case 0x04:
3032 EXPn (external function);
3033 break;
3034 case 0x05:
3035 break;
3036 case 0x07:
3037 INTn (line number);
3038 INT;
3039 case 0x08:
3040 break;
3041 case 0x0a:
3042 INTn (locked register);
3043 INT;
3044 break;
3045 case 0x3f:
3046 copy_till_end ();
3047 break;
3048 case 0x3e:
3049 copy_till_end ();
3050 break;
3051 case 0x40:
3052 copy_till_end ();
3053 break;
3054 case 0x41:
3055 ID;
3056 break;
3057 }
3058 }
3059
3060 }
3061
3062 static void
3063 f0_record ()
3064 {
3065 /* Attribute record */
3066 NEXT ();
3067 OUT (0xf0);
3068 INTn (Symbol name);
3069 ID;
3070 }
3071
3072 static void
3073 copy_till_end ()
3074 {
3075 int ch = THIS ();
3076 while (1)
3077 {
3078 while (ch <= 0x80)
3079 {
3080 OUT (ch);
3081 NEXT ();
3082 ch = THIS ();
3083 }
3084 switch (ch)
3085 {
3086 case 0x84:
3087 OUT (THIS ());
3088 NEXT ();
3089 case 0x83:
3090 OUT (THIS ());
3091 NEXT ();
3092 case 0x82:
3093 OUT (THIS ());
3094 NEXT ();
3095 case 0x81:
3096 OUT (THIS ());
3097 NEXT ();
3098 OUT (THIS ());
3099 NEXT ();
3100
3101 ch = THIS ();
3102 break;
3103 default:
3104 return;
3105 }
3106 }
3107
3108 }
3109
3110 static void
3111 f2_record ()
3112 {
3113 NEXT ();
3114 OUT (0xf2);
3115 INT;
3116 NEXT ();
3117 OUT (0xce);
3118 INT;
3119 copy_till_end ();
3120 }
3121
3122
3123 static void
3124 f8_record ()
3125 {
3126 int ch;
3127 NEXT ();
3128 ch = THIS ();
3129 switch (ch)
3130 {
3131 case 0x01:
3132 case 0x02:
3133 case 0x03:
3134 /* Unique typedefs for module */
3135 /* GLobal typedefs */
3136 /* High level module scope beginning */
3137 {
3138 struct output_buffer_struct ob;
3139 NEXT ();
3140 OUT (0xf8);
3141 OUT (ch);
3142 drop_int (&ob);
3143 ID;
3144
3145 block ();
3146
3147 NEXT ();
3148 fill_int (&ob);
3149 OUT (0xf9);
3150 }
3151 break;
3152 case 0x04:
3153 /* Global function */
3154 {
3155 struct output_buffer_struct ob;
3156 NEXT ();
3157 OUT (0xf8);
3158 OUT (0x04);
3159 drop_int (&ob);
3160 ID;
3161 INTn (stack size);
3162 INTn (ret val);
3163 EXPn (offset);
3164
3165 block ();
3166
3167 NEXT ();
3168 OUT (0xf9);
3169 EXPn (size of block);
3170 fill_int (&ob);
3171 }
3172 break;
3173
3174 case 0x05:
3175 /* File name for source line numbers */
3176 {
3177 struct output_buffer_struct ob;
3178 NEXT ();
3179 OUT (0xf8);
3180 OUT (0x05);
3181 drop_int (&ob);
3182 ID;
3183 INTn (year);
3184 INTn (month);
3185 INTn (day);
3186 INTn (hour);
3187 INTn (monute);
3188 INTn (second);
3189 block ();
3190 NEXT ();
3191 OUT (0xf9);
3192 fill_int (&ob);
3193 }
3194 break;
3195
3196 case 0x06:
3197 /* Local function */
3198 {
3199 struct output_buffer_struct ob;
3200 NEXT ();
3201 OUT (0xf8);
3202 OUT (0x06);
3203 drop_int (&ob);
3204 ID;
3205 INTn (stack size);
3206 INTn (type return);
3207 EXPn (offset);
3208 block ();
3209 NEXT ();
3210 OUT (0xf9);
3211 EXPn (size);
3212 fill_int (&ob);
3213 }
3214 break;
3215
3216 case 0x0a:
3217 /* Assembler module scope beginning -*/
3218 {
3219 struct output_buffer_struct ob;
3220
3221 NEXT ();
3222 OUT (0xf8);
3223 OUT (0x0a);
3224 drop_int (&ob);
3225 ID;
3226 ID;
3227 INT;
3228 ID;
3229 INT;
3230 INT;
3231 INT;
3232 INT;
3233 INT;
3234 INT;
3235
3236 block ();
3237
3238 NEXT ();
3239 OUT (0xf9);
3240 fill_int (&ob);
3241 }
3242 break;
3243 case 0x0b:
3244 {
3245 struct output_buffer_struct ob;
3246 NEXT ();
3247 OUT (0xf8);
3248 OUT (0x0b);
3249 drop_int (&ob);
3250 ID;
3251 INT;
3252 INTn (section index);
3253 EXPn (offset);
3254 INTn (stuff);
3255
3256 block ();
3257
3258 OUT (0xf9);
3259 NEXT ();
3260 EXPn (Size in Maus);
3261 fill_int (&ob);
3262 }
3263 break;
3264 }
3265 }
3266
3267 static void
3268 e2_record ()
3269 {
3270 OUT (0xe2);
3271 NEXT ();
3272 OUT (0xce);
3273 NEXT ();
3274 INT;
3275 EXP;
3276 }
3277
3278 static void
3279 block ()
3280 {
3281 int ch;
3282 while (1)
3283 {
3284 ch = THIS ();
3285 switch (ch)
3286 {
3287 case 0xe1:
3288 case 0xe5:
3289 return;
3290 case 0xf9:
3291 return;
3292 case 0xf0:
3293 f0_record ();
3294 break;
3295 case 0xf1:
3296 f1_record ();
3297 break;
3298 case 0xf2:
3299 f2_record ();
3300 break;
3301 case 0xf8:
3302 f8_record ();
3303 break;
3304 case 0xe2:
3305 e2_record ();
3306 break;
3307
3308 }
3309 }
3310 }
3311
3312
3313
3314 /* relocate_debug,
3315 moves all the debug information from the source bfd to the output
3316 bfd, and relocates any expressions it finds
3317 */
3318
3319 static void
3320 relocate_debug (output, input)
3321 bfd *output ATTRIBUTE_UNUSED;
3322 bfd *input;
3323 {
3324 #define IBS 400
3325 #define OBS 400
3326 unsigned char input_buffer[IBS];
3327
3328 input_ptr_start = input_ptr = input_buffer;
3329 input_ptr_end = input_buffer + IBS;
3330 input_bfd = input;
3331 /* FIXME: Check return value. I'm not sure whether it needs to read
3332 the entire buffer or not. */
3333 bfd_bread ((PTR) input_ptr_start, (bfd_size_type) IBS, input);
3334 block ();
3335 }
3336
3337 /* Gather together all the debug information from each input BFD into
3338 one place, relocating it and emitting it as we go. */
3339
3340 static bfd_boolean
3341 ieee_write_debug_part (abfd)
3342 bfd *abfd;
3343 {
3344 ieee_data_type *ieee = IEEE_DATA (abfd);
3345 bfd_chain_type *chain = ieee->chain_root;
3346 unsigned char obuff[OBS];
3347 bfd_boolean some_debug = FALSE;
3348 file_ptr here = bfd_tell (abfd);
3349
3350 output_ptr_start = output_ptr = obuff;
3351 output_ptr_end = obuff + OBS;
3352 output_ptr = obuff;
3353 output_bfd = abfd;
3354
3355 if (chain == (bfd_chain_type *) NULL)
3356 {
3357 asection *s;
3358
3359 for (s = abfd->sections; s != NULL; s = s->next)
3360 if ((s->flags & SEC_DEBUGGING) != 0)
3361 break;
3362 if (s == NULL)
3363 {
3364 ieee->w.r.debug_information_part = 0;
3365 return TRUE;
3366 }
3367
3368 ieee->w.r.debug_information_part = here;
3369 if (bfd_bwrite (s->contents, s->_raw_size, abfd) != s->_raw_size)
3370 return FALSE;
3371 }
3372 else
3373 {
3374 while (chain != (bfd_chain_type *) NULL)
3375 {
3376 bfd *entry = chain->this;
3377 ieee_data_type *entry_ieee = IEEE_DATA (entry);
3378 if (entry_ieee->w.r.debug_information_part)
3379 {
3380 if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
3381 SEEK_SET) != 0)
3382 return FALSE;
3383 relocate_debug (abfd, entry);
3384 }
3385
3386 chain = chain->next;
3387 }
3388 if (some_debug)
3389 {
3390 ieee->w.r.debug_information_part = here;
3391 }
3392 else
3393 {
3394 ieee->w.r.debug_information_part = 0;
3395 }
3396
3397 flush ();
3398 }
3399
3400 return TRUE;
3401 }
3402
3403 /* Write the data in an ieee way. */
3404
3405 static bfd_boolean
3406 ieee_write_data_part (abfd)
3407 bfd *abfd;
3408 {
3409 asection *s;
3410 ieee_data_type *ieee = IEEE_DATA (abfd);
3411 ieee->w.r.data_part = bfd_tell (abfd);
3412 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3413 {
3414 /* Skip sections that have no loadable contents (.bss,
3415 debugging, etc.) */
3416 if ((s->flags & SEC_LOAD) == 0)
3417 continue;
3418
3419 /* Sort the reloc records so we can insert them in the correct
3420 places */
3421 if (s->reloc_count != 0)
3422 {
3423 if (! do_with_relocs (abfd, s))
3424 return FALSE;
3425 }
3426 else
3427 {
3428 if (! do_without_relocs (abfd, s))
3429 return FALSE;
3430 }
3431 }
3432
3433 return TRUE;
3434 }
3435
3436
3437 static bfd_boolean
3438 init_for_output (abfd)
3439 bfd *abfd;
3440 {
3441 asection *s;
3442 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3443 {
3444 if ((s->flags & SEC_DEBUGGING) != 0)
3445 continue;
3446 if (s->_raw_size != 0)
3447 {
3448 bfd_size_type size = s->_raw_size;
3449 ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, size));
3450 if (!ieee_per_section (s)->data)
3451 return FALSE;
3452 }
3453 }
3454 return TRUE;
3455 }
3456 \f
3457 /** exec and core file sections */
3458
3459 /* set section contents is complicated with IEEE since the format is
3460 * not a byte image, but a record stream.
3461 */
3462 static bfd_boolean
3463 ieee_set_section_contents (abfd, section, location, offset, count)
3464 bfd *abfd;
3465 sec_ptr section;
3466 PTR location;
3467 file_ptr offset;
3468 bfd_size_type count;
3469 {
3470 if ((section->flags & SEC_DEBUGGING) != 0)
3471 {
3472 if (section->contents == NULL)
3473 {
3474 bfd_size_type size = section->_raw_size;
3475 section->contents = (unsigned char *) bfd_alloc (abfd, size);
3476 if (section->contents == NULL)
3477 return FALSE;
3478 }
3479 /* bfd_set_section_contents has already checked that everything
3480 is within range. */
3481 memcpy (section->contents + offset, location, (size_t) count);
3482 return TRUE;
3483 }
3484
3485 if (ieee_per_section (section)->data == (bfd_byte *) NULL)
3486 {
3487 if (!init_for_output (abfd))
3488 return FALSE;
3489 }
3490 memcpy ((PTR) (ieee_per_section (section)->data + offset),
3491 (PTR) location,
3492 (unsigned int) count);
3493 return TRUE;
3494 }
3495
3496 /* Write the external symbols of a file. IEEE considers two sorts of
3497 external symbols, public, and referenced. It uses to internal
3498 forms to index them as well. When we write them out we turn their
3499 symbol values into indexes from the right base. */
3500
3501 static bfd_boolean
3502 ieee_write_external_part (abfd)
3503 bfd *abfd;
3504 {
3505 asymbol **q;
3506 ieee_data_type *ieee = IEEE_DATA (abfd);
3507
3508 unsigned int reference_index = IEEE_REFERENCE_BASE;
3509 unsigned int public_index = IEEE_PUBLIC_BASE + 2;
3510 file_ptr here = bfd_tell (abfd);
3511 bfd_boolean hadone = FALSE;
3512 if (abfd->outsymbols != (asymbol **) NULL)
3513 {
3514
3515 for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++)
3516 {
3517 asymbol *p = *q;
3518 if (bfd_is_und_section (p->section))
3519 {
3520 /* This must be a symbol reference .. */
3521 if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3522 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3523 || ! ieee_write_id (abfd, p->name))
3524 return FALSE;
3525 p->value = reference_index;
3526 reference_index++;
3527 hadone = TRUE;
3528 }
3529 else if (bfd_is_com_section (p->section))
3530 {
3531 /* This is a weak reference */
3532 if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3533 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3534 || ! ieee_write_id (abfd, p->name)
3535 || ! ieee_write_byte (abfd,
3536 ieee_weak_external_reference_enum)
3537 || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3538 || ! ieee_write_int (abfd, p->value))
3539 return FALSE;
3540 p->value = reference_index;
3541 reference_index++;
3542 hadone = TRUE;
3543 }
3544 else if (p->flags & BSF_GLOBAL)
3545 {
3546 /* This must be a symbol definition */
3547
3548 if (! ieee_write_byte (abfd, ieee_external_symbol_enum)
3549 || ! ieee_write_int (abfd, (bfd_vma) public_index)
3550 || ! ieee_write_id (abfd, p->name)
3551 || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
3552 || ! ieee_write_int (abfd, (bfd_vma) public_index)
3553 || ! ieee_write_byte (abfd, 15) /* instruction address */
3554 || ! ieee_write_byte (abfd, 19) /* static symbol */
3555 || ! ieee_write_byte (abfd, 1)) /* one of them */
3556 return FALSE;
3557
3558 /* Write out the value */
3559 if (! ieee_write_2bytes (abfd, ieee_value_record_enum)
3560 || ! ieee_write_int (abfd, (bfd_vma) public_index))
3561 return FALSE;
3562 if (! bfd_is_abs_section (p->section))
3563 {
3564 if (abfd->flags & EXEC_P)
3565 {
3566 /* If fully linked, then output all symbols
3567 relocated */
3568 if (! (ieee_write_int
3569 (abfd,
3570 (p->value
3571 + p->section->output_offset
3572 + p->section->output_section->vma))))
3573 return FALSE;
3574 }
3575 else
3576 {
3577 if (! (ieee_write_expression
3578 (abfd,
3579 p->value + p->section->output_offset,
3580 p->section->output_section->symbol,
3581 FALSE, 0)))
3582 return FALSE;
3583 }
3584 }
3585 else
3586 {
3587 if (! ieee_write_expression (abfd,
3588 p->value,
3589 bfd_abs_section_ptr->symbol,
3590 FALSE, 0))
3591 return FALSE;
3592 }
3593 p->value = public_index;
3594 public_index++;
3595 hadone = TRUE;
3596 }
3597 else
3598 {
3599 /* This can happen - when there are gaps in the symbols read */
3600 /* from an input ieee file */
3601 }
3602 }
3603 }
3604 if (hadone)
3605 ieee->w.r.external_part = here;
3606
3607 return TRUE;
3608 }
3609
3610
3611 static const unsigned char exten[] =
3612 {
3613 0xf0, 0x20, 0x00,
3614 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3 */
3615 0xf1, 0xce, 0x20, 0x00, 39, 2,/* keep symbol in original case */
3616 0xf1, 0xce, 0x20, 0x00, 38 /* set object type relocateable to x */
3617 };
3618
3619 static const unsigned char envi[] =
3620 {
3621 0xf0, 0x21, 0x00,
3622
3623 /* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3624 0x19, 0x2c,
3625 */
3626 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */
3627
3628 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix */
3629 /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
3630 };
3631
3632 static bfd_boolean
3633 ieee_write_me_part (abfd)
3634 bfd *abfd;
3635 {
3636 ieee_data_type *ieee = IEEE_DATA (abfd);
3637 ieee->w.r.trailer_part = bfd_tell (abfd);
3638 if (abfd->start_address)
3639 {
3640 if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum)
3641 || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum)
3642 || ! ieee_write_int (abfd, abfd->start_address)
3643 || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum))
3644 return FALSE;
3645 }
3646 ieee->w.r.me_record = bfd_tell (abfd);
3647 if (! ieee_write_byte (abfd, ieee_module_end_enum))
3648 return FALSE;
3649 return TRUE;
3650 }
3651
3652 /* Write out the IEEE processor ID. */
3653
3654 static bfd_boolean
3655 ieee_write_processor (abfd)
3656 bfd *abfd;
3657 {
3658 const bfd_arch_info_type *arch;
3659
3660 arch = bfd_get_arch_info (abfd);
3661 switch (arch->arch)
3662 {
3663 default:
3664 if (! ieee_write_id (abfd, bfd_printable_name (abfd)))
3665 return FALSE;
3666 break;
3667
3668 case bfd_arch_a29k:
3669 if (! ieee_write_id (abfd, "29000"))
3670 return FALSE;
3671 break;
3672
3673 case bfd_arch_h8300:
3674 if (! ieee_write_id (abfd, "H8/300"))
3675 return FALSE;
3676 break;
3677
3678 case bfd_arch_h8500:
3679 if (! ieee_write_id (abfd, "H8/500"))
3680 return FALSE;
3681 break;
3682
3683 case bfd_arch_i960:
3684 switch (arch->mach)
3685 {
3686 default:
3687 case bfd_mach_i960_core:
3688 case bfd_mach_i960_ka_sa:
3689 if (! ieee_write_id (abfd, "80960KA"))
3690 return FALSE;
3691 break;
3692
3693 case bfd_mach_i960_kb_sb:
3694 if (! ieee_write_id (abfd, "80960KB"))
3695 return FALSE;
3696 break;
3697
3698 case bfd_mach_i960_ca:
3699 if (! ieee_write_id (abfd, "80960CA"))
3700 return FALSE;
3701 break;
3702
3703 case bfd_mach_i960_mc:
3704 case bfd_mach_i960_xa:
3705 if (! ieee_write_id (abfd, "80960MC"))
3706 return FALSE;
3707 break;
3708 }
3709 break;
3710
3711 case bfd_arch_m68k:
3712 {
3713 const char *id;
3714
3715 switch (arch->mach)
3716 {
3717 default: id = "68020"; break;
3718 case bfd_mach_m68000: id = "68000"; break;
3719 case bfd_mach_m68008: id = "68008"; break;
3720 case bfd_mach_m68010: id = "68010"; break;
3721 case bfd_mach_m68020: id = "68020"; break;
3722 case bfd_mach_m68030: id = "68030"; break;
3723 case bfd_mach_m68040: id = "68040"; break;
3724 case bfd_mach_m68060: id = "68060"; break;
3725 case bfd_mach_cpu32: id = "cpu32"; break;
3726 case bfd_mach_mcf5200:id = "5200"; break;
3727 case bfd_mach_mcf5206e:id = "5206e"; break;
3728 case bfd_mach_mcf5307:id = "5307"; break;
3729 case bfd_mach_mcf5407:id = "5407"; break;
3730 }
3731
3732 if (! ieee_write_id (abfd, id))
3733 return FALSE;
3734 }
3735 break;
3736 }
3737
3738 return TRUE;
3739 }
3740
3741 static bfd_boolean
3742 ieee_write_object_contents (abfd)
3743 bfd *abfd;
3744 {
3745 ieee_data_type *ieee = IEEE_DATA (abfd);
3746 unsigned int i;
3747 file_ptr old;
3748
3749 /* Fast forward over the header area */
3750 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3751 return FALSE;
3752
3753 if (! ieee_write_byte (abfd, ieee_module_beginning_enum)
3754 || ! ieee_write_processor (abfd)
3755 || ! ieee_write_id (abfd, abfd->filename))
3756 return FALSE;
3757
3758 /* Fast forward over the variable bits */
3759 if (! ieee_write_byte (abfd, ieee_address_descriptor_enum))
3760 return FALSE;
3761
3762 /* Bits per MAU */
3763 if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))))
3764 return FALSE;
3765 /* MAU's per address */
3766 if (! ieee_write_byte (abfd,
3767 (bfd_byte) (bfd_arch_bits_per_address (abfd)
3768 / bfd_arch_bits_per_byte (abfd))))
3769 return FALSE;
3770
3771 old = bfd_tell (abfd);
3772 if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
3773 return FALSE;
3774
3775 ieee->w.r.extension_record = bfd_tell (abfd);
3776 if (bfd_bwrite ((char *) exten, (bfd_size_type) sizeof (exten), abfd)
3777 != sizeof (exten))
3778 return FALSE;
3779 if (abfd->flags & EXEC_P)
3780 {
3781 if (! ieee_write_byte (abfd, 0x1)) /* Absolute */
3782 return FALSE;
3783 }
3784 else
3785 {
3786 if (! ieee_write_byte (abfd, 0x2)) /* Relocateable */
3787 return FALSE;
3788 }
3789
3790 ieee->w.r.environmental_record = bfd_tell (abfd);
3791 if (bfd_bwrite ((char *) envi, (bfd_size_type) sizeof (envi), abfd)
3792 != sizeof (envi))
3793 return FALSE;
3794
3795 /* The HP emulator database requires a timestamp in the file. */
3796 {
3797 time_t now;
3798 const struct tm *t;
3799
3800 time (&now);
3801 t = (struct tm *) localtime (&now);
3802 if (! ieee_write_2bytes (abfd, (int) ieee_atn_record_enum)
3803 || ! ieee_write_byte (abfd, 0x21)
3804 || ! ieee_write_byte (abfd, 0)
3805 || ! ieee_write_byte (abfd, 50)
3806 || ! ieee_write_int (abfd, (bfd_vma) (t->tm_year + 1900))
3807 || ! ieee_write_int (abfd, (bfd_vma) (t->tm_mon + 1))
3808 || ! ieee_write_int (abfd, (bfd_vma) t->tm_mday)
3809 || ! ieee_write_int (abfd, (bfd_vma) t->tm_hour)
3810 || ! ieee_write_int (abfd, (bfd_vma) t->tm_min)
3811 || ! ieee_write_int (abfd, (bfd_vma) t->tm_sec))
3812 return FALSE;
3813 }
3814
3815 output_bfd = abfd;
3816
3817 flush ();
3818
3819 if (! ieee_write_section_part (abfd))
3820 return FALSE;
3821 /* First write the symbols. This changes their values into table
3822 indeces so we cant use it after this point. */
3823 if (! ieee_write_external_part (abfd))
3824 return FALSE;
3825
3826 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3827
3828 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3829
3830
3831 /* Write any debugs we have been told about. */
3832 if (! ieee_write_debug_part (abfd))
3833 return FALSE;
3834
3835 /* Can only write the data once the symbols have been written, since
3836 the data contains relocation information which points to the
3837 symbols. */
3838 if (! ieee_write_data_part (abfd))
3839 return FALSE;
3840
3841 /* At the end we put the end! */
3842 if (! ieee_write_me_part (abfd))
3843 return FALSE;
3844
3845 /* Generate the header */
3846 if (bfd_seek (abfd, old, SEEK_SET) != 0)
3847 return FALSE;
3848
3849 for (i = 0; i < N_W_VARIABLES; i++)
3850 {
3851 if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum)
3852 || ! ieee_write_byte (abfd, (bfd_byte) i)
3853 || ! ieee_write_int5_out (abfd, (bfd_vma) ieee->w.offset[i]))
3854 return FALSE;
3855 }
3856
3857 return TRUE;
3858 }
3859 \f
3860 /* Native-level interface to symbols. */
3861
3862 /* We read the symbols into a buffer, which is discarded when this
3863 function exits. We read the strings into a buffer large enough to
3864 hold them all plus all the cached symbol entries. */
3865
3866 static asymbol *
3867 ieee_make_empty_symbol (abfd)
3868 bfd *abfd;
3869 {
3870 bfd_size_type amt = sizeof (ieee_symbol_type);
3871 ieee_symbol_type *new = (ieee_symbol_type *) bfd_zalloc (abfd, amt);
3872 if (!new)
3873 return NULL;
3874 new->symbol.the_bfd = abfd;
3875 return &new->symbol;
3876 }
3877
3878 static bfd *
3879 ieee_openr_next_archived_file (arch, prev)
3880 bfd *arch;
3881 bfd *prev;
3882 {
3883 ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
3884 /* take the next one from the arch state, or reset */
3885 if (prev == (bfd *) NULL)
3886 {
3887 /* Reset the index - the first two entries are bogus*/
3888 ar->element_index = 2;
3889 }
3890 while (TRUE)
3891 {
3892 ieee_ar_obstack_type *p = ar->elements + ar->element_index;
3893 ar->element_index++;
3894 if (ar->element_index <= ar->element_count)
3895 {
3896 if (p->file_offset != (file_ptr) 0)
3897 {
3898 if (p->abfd == (bfd *) NULL)
3899 {
3900 p->abfd = _bfd_create_empty_archive_element_shell (arch);
3901 p->abfd->origin = p->file_offset;
3902 }
3903 return p->abfd;
3904 }
3905 }
3906 else
3907 {
3908 bfd_set_error (bfd_error_no_more_archived_files);
3909 return (bfd *) NULL;
3910 }
3911
3912 }
3913 }
3914
3915 static bfd_boolean
3916 ieee_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
3917 functionname_ptr, line_ptr)
3918 bfd *abfd ATTRIBUTE_UNUSED;
3919 asection *section ATTRIBUTE_UNUSED;
3920 asymbol **symbols ATTRIBUTE_UNUSED;
3921 bfd_vma offset ATTRIBUTE_UNUSED;
3922 const char **filename_ptr ATTRIBUTE_UNUSED;
3923 const char **functionname_ptr ATTRIBUTE_UNUSED;
3924 unsigned int *line_ptr ATTRIBUTE_UNUSED;
3925 {
3926 return FALSE;
3927 }
3928
3929 static int
3930 ieee_generic_stat_arch_elt (abfd, buf)
3931 bfd *abfd;
3932 struct stat *buf;
3933 {
3934 ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL;
3935 ieee_data_type *ieee;
3936
3937 if (abfd->my_archive != NULL)
3938 ar = abfd->my_archive->tdata.ieee_ar_data;
3939 if (ar == (ieee_ar_data_type *) NULL)
3940 {
3941 bfd_set_error (bfd_error_invalid_operation);
3942 return -1;
3943 }
3944
3945 if (IEEE_DATA (abfd) == NULL)
3946 {
3947 if (ieee_object_p (abfd) == NULL)
3948 {
3949 bfd_set_error (bfd_error_wrong_format);
3950 return -1;
3951 }
3952 }
3953
3954 ieee = IEEE_DATA (abfd);
3955
3956 buf->st_size = ieee->w.r.me_record + 1;
3957 buf->st_mode = 0644;
3958 return 0;
3959 }
3960
3961 static int
3962 ieee_sizeof_headers (abfd, x)
3963 bfd *abfd ATTRIBUTE_UNUSED;
3964 bfd_boolean x ATTRIBUTE_UNUSED;
3965 {
3966 return 0;
3967 }
3968
3969
3970 /* The debug info routines are never used. */
3971 #if 0
3972
3973 static void
3974 ieee_bfd_debug_info_start (abfd)
3975 bfd *abfd;
3976 {
3977
3978 }
3979
3980 static void
3981 ieee_bfd_debug_info_end (abfd)
3982 bfd *abfd;
3983 {
3984
3985 }
3986
3987
3988 /* Add this section to the list of sections we have debug info for, to
3989 be ready to output it at close time
3990 */
3991 static void
3992 ieee_bfd_debug_info_accumulate (abfd, section)
3993 bfd *abfd;
3994 asection *section;
3995 {
3996 ieee_data_type *ieee = IEEE_DATA (section->owner);
3997 ieee_data_type *output_ieee = IEEE_DATA (abfd);
3998 /* can only accumulate data from other ieee bfds */
3999 if (section->owner->xvec != abfd->xvec)
4000 return;
4001 /* Only bother once per bfd */
4002 if (ieee->done_debug)
4003 return;
4004 ieee->done_debug = TRUE;
4005
4006 /* Don't bother if there is no debug info */
4007 if (ieee->w.r.debug_information_part == 0)
4008 return;
4009
4010
4011 /* Add to chain */
4012 {
4013 bfd_size_type amt = sizeof (bfd_chain_type);
4014 bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, amt);
4015 if (!n)
4016 abort (); /* FIXME */
4017 n->this = section->owner;
4018 n->next = (bfd_chain_type *) NULL;
4019
4020 if (output_ieee->chain_head)
4021 {
4022 output_ieee->chain_head->next = n;
4023 }
4024 else
4025 {
4026 output_ieee->chain_root = n;
4027
4028 }
4029 output_ieee->chain_head = n;
4030 }
4031 }
4032
4033 #endif
4034
4035 #define ieee_close_and_cleanup _bfd_generic_close_and_cleanup
4036 #define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4037
4038 #define ieee_slurp_armap bfd_true
4039 #define ieee_slurp_extended_name_table bfd_true
4040 #define ieee_construct_extended_name_table \
4041 ((bfd_boolean (*) \
4042 PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
4043 bfd_true)
4044 #define ieee_truncate_arname bfd_dont_truncate_arname
4045 #define ieee_write_armap \
4046 ((bfd_boolean (*) \
4047 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
4048 bfd_true)
4049 #define ieee_read_ar_hdr bfd_nullvoidptr
4050 #define ieee_update_armap_timestamp bfd_true
4051 #define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
4052
4053 #define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
4054 #define ieee_get_lineno _bfd_nosymbols_get_lineno
4055 #define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
4056 #define ieee_read_minisymbols _bfd_generic_read_minisymbols
4057 #define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4058
4059 #define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4060
4061 #define ieee_set_arch_mach _bfd_generic_set_arch_mach
4062
4063 #define ieee_get_section_contents_in_window \
4064 _bfd_generic_get_section_contents_in_window
4065 #define ieee_bfd_get_relocated_section_contents \
4066 bfd_generic_get_relocated_section_contents
4067 #define ieee_bfd_relax_section bfd_generic_relax_section
4068 #define ieee_bfd_gc_sections bfd_generic_gc_sections
4069 #define ieee_bfd_merge_sections bfd_generic_merge_sections
4070 #define ieee_bfd_discard_group bfd_generic_discard_group
4071 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4072 #define ieee_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
4073 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
4074 #define ieee_bfd_link_just_syms _bfd_generic_link_just_syms
4075 #define ieee_bfd_final_link _bfd_generic_final_link
4076 #define ieee_bfd_link_split_section _bfd_generic_link_split_section
4077
4078 /*SUPPRESS 460 */
4079 const bfd_target ieee_vec =
4080 {
4081 "ieee", /* name */
4082 bfd_target_ieee_flavour,
4083 BFD_ENDIAN_UNKNOWN, /* target byte order */
4084 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
4085 (HAS_RELOC | EXEC_P | /* object flags */
4086 HAS_LINENO | HAS_DEBUG |
4087 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
4088 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
4089 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
4090 '_', /* leading underscore */
4091 ' ', /* ar_pad_char */
4092 16, /* ar_max_namelen */
4093 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
4094 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
4095 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
4096 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
4097 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
4098 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
4099
4100 {_bfd_dummy_target,
4101 ieee_object_p, /* bfd_check_format */
4102 ieee_archive_p,
4103 _bfd_dummy_target,
4104 },
4105 {
4106 bfd_false,
4107 ieee_mkobject,
4108 _bfd_generic_mkarchive,
4109 bfd_false
4110 },
4111 {
4112 bfd_false,
4113 ieee_write_object_contents,
4114 _bfd_write_archive_contents,
4115 bfd_false,
4116 },
4117
4118 /* ieee_close_and_cleanup, ieee_bfd_free_cached_info, ieee_new_section_hook,
4119 ieee_get_section_contents, ieee_get_section_contents_in_window */
4120 BFD_JUMP_TABLE_GENERIC (ieee),
4121
4122 BFD_JUMP_TABLE_COPY (_bfd_generic),
4123 BFD_JUMP_TABLE_CORE (_bfd_nocore),
4124
4125 /* ieee_slurp_armap, ieee_slurp_extended_name_table,
4126 ieee_construct_extended_name_table, ieee_truncate_arname,
4127 ieee_write_armap, ieee_read_ar_hdr, ieee_openr_next_archived_file,
4128 ieee_get_elt_at_index, ieee_generic_stat_arch_elt,
4129 ieee_update_armap_timestamp */
4130 BFD_JUMP_TABLE_ARCHIVE (ieee),
4131
4132 /* ieee_get_symtab_upper_bound, ieee_get_symtab, ieee_make_empty_symbol,
4133 ieee_print_symbol, ieee_get_symbol_info, ieee_bfd_is_local_label_name,
4134 ieee_get_lineno, ieee_find_nearest_line, ieee_bfd_make_debug_symbol,
4135 ieee_read_minisymbols, ieee_minisymbol_to_symbol */
4136 BFD_JUMP_TABLE_SYMBOLS (ieee),
4137
4138 /* ieee_get_reloc_upper_bound, ieee_canonicalize_reloc,
4139 ieee_bfd_reloc_type_lookup */
4140 BFD_JUMP_TABLE_RELOCS (ieee),
4141
4142 /* ieee_set_arch_mach, ieee_set_section_contents */
4143 BFD_JUMP_TABLE_WRITE (ieee),
4144
4145 /* ieee_sizeof_headers, ieee_bfd_get_relocated_section_contents,
4146 ieee_bfd_relax_section, ieee_bfd_link_hash_table_create,
4147 _bfd_generic_link_hash_table_free,
4148 ieee_bfd_link_add_symbols, ieee_bfd_final_link,
4149 ieee_bfd_link_split_section, ieee_bfd_gc_sections,
4150 ieee_bfd_merge_sections */
4151 BFD_JUMP_TABLE_LINK (ieee),
4152
4153 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
4154
4155 NULL,
4156
4157 (PTR) 0
4158 };
A mirror of the official binutils-gdb repository