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