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