1 /* BFD back-end for ieee-695 objects.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #define KEEPMINUSPCININST 0
25 /* IEEE 695 format is a stream of records, which we parse using a simple one-
26 token (which is one byte in this lexicon) lookahead recursive decent
37 static boolean ieee_write_byte
PARAMS ((bfd
*, int));
38 static boolean ieee_write_2bytes
PARAMS ((bfd
*, int));
39 static boolean ieee_write_int
PARAMS ((bfd
*, bfd_vma
));
40 static boolean ieee_write_id
PARAMS ((bfd
*, const char *));
41 static boolean ieee_write_expression
42 PARAMS ((bfd
*, bfd_vma
, asymbol
*, boolean
, unsigned int));
43 static void ieee_write_int5
PARAMS ((bfd_byte
*, bfd_vma
));
44 static boolean ieee_write_int5_out
PARAMS ((bfd
*, bfd_vma
));
45 static boolean ieee_write_section_part
PARAMS ((bfd
*));
46 static boolean do_with_relocs
PARAMS ((bfd
*, asection
*));
47 static boolean do_as_repeat
PARAMS ((bfd
*, asection
*));
48 static boolean do_without_relocs
PARAMS ((bfd
*, asection
*));
49 static boolean ieee_write_external_part
PARAMS ((bfd
*));
50 static boolean ieee_write_data_part
PARAMS ((bfd
*));
51 static boolean ieee_write_debug_part
PARAMS ((bfd
*));
52 static boolean ieee_write_me_part
PARAMS ((bfd
*));
53 static boolean ieee_write_processor
PARAMS ((bfd
*));
55 static boolean ieee_slurp_debug
PARAMS ((bfd
*));
56 static boolean ieee_slurp_section_data
PARAMS ((bfd
*));
58 /* Functions for writing to ieee files in the strange way that the
62 ieee_write_byte (abfd
, barg
)
69 if (bfd_write ((PTR
) &byte
, 1, 1, abfd
) != 1)
75 ieee_write_2bytes (abfd
, bytes
)
81 buffer
[0] = bytes
>> 8;
82 buffer
[1] = bytes
& 0xff;
83 if (bfd_write ((PTR
) buffer
, 1, 2, abfd
) != 2)
89 ieee_write_int (abfd
, value
)
95 if (! ieee_write_byte (abfd
, (bfd_byte
) value
))
102 /* How many significant bytes ? */
103 /* FIXME FOR LONGER INTS */
104 if (value
& 0xff000000)
106 else if (value
& 0x00ff0000)
108 else if (value
& 0x0000ff00)
113 if (! ieee_write_byte (abfd
,
114 (bfd_byte
) ((int) ieee_number_repeat_start_enum
120 if (! ieee_write_byte (abfd
, (bfd_byte
) (value
>> 24)))
124 if (! ieee_write_byte (abfd
, (bfd_byte
) (value
>> 16)))
128 if (! ieee_write_byte (abfd
, (bfd_byte
) (value
>> 8)))
132 if (! ieee_write_byte (abfd
, (bfd_byte
) (value
)))
141 ieee_write_id (abfd
, id
)
145 size_t length
= strlen (id
);
149 if (! ieee_write_byte (abfd
, (bfd_byte
) length
))
152 else if (length
< 255)
154 if (! ieee_write_byte (abfd
, ieee_extension_length_1_enum
)
155 || ! ieee_write_byte (abfd
, (bfd_byte
) length
))
158 else if (length
< 65535)
160 if (! ieee_write_byte (abfd
, ieee_extension_length_2_enum
)
161 || ! ieee_write_2bytes (abfd
, (int) length
))
166 (*_bfd_error_handler
)
167 (_("%s: string too long (%d chars, max 65535)"),
168 bfd_get_filename (abfd
), length
);
169 bfd_set_error (bfd_error_invalid_operation
);
173 if (bfd_write ((PTR
) id
, 1, length
, abfd
) != length
)
178 /***************************************************************************
179 Functions for reading from ieee files in the strange way that the
183 #define this_byte(ieee) *((ieee)->input_p)
184 #define next_byte(ieee) ((ieee)->input_p++)
185 #define this_byte_and_next(ieee) (*((ieee)->input_p++))
187 static unsigned short
189 common_header_type
*ieee
;
191 unsigned char c1
= this_byte_and_next (ieee
);
192 unsigned char c2
= this_byte_and_next (ieee
);
193 return (c1
<< 8) | c2
;
197 bfd_get_string (ieee
, string
, length
)
198 common_header_type
*ieee
;
203 for (i
= 0; i
< length
; i
++)
205 string
[i
] = this_byte_and_next (ieee
);
211 common_header_type
*ieee
;
215 length
= this_byte_and_next (ieee
);
218 /* Simple string of length 0 to 127 */
220 else if (length
== 0xde)
222 /* Length is next byte, allowing 0..255 */
223 length
= this_byte_and_next (ieee
);
225 else if (length
== 0xdf)
227 /* Length is next two bytes, allowing 0..65535 */
228 length
= this_byte_and_next (ieee
);
229 length
= (length
* 256) + this_byte_and_next (ieee
);
231 /* Buy memory and read string */
232 string
= bfd_alloc (ieee
->abfd
, length
+ 1);
235 bfd_get_string (ieee
, string
, length
);
241 ieee_write_expression (abfd
, value
, symbol
, pcrel
, index
)
248 unsigned int term_count
= 0;
252 if (! ieee_write_int (abfd
, value
))
257 if (bfd_is_com_section (symbol
->section
)
258 || bfd_is_und_section (symbol
->section
))
260 /* Def of a common symbol */
261 if (! ieee_write_byte (abfd
, ieee_variable_X_enum
)
262 || ! ieee_write_int (abfd
, symbol
->value
))
266 else if (! bfd_is_abs_section (symbol
->section
))
268 /* Ref to defined symbol - */
270 if (symbol
->flags
& BSF_GLOBAL
)
272 if (! ieee_write_byte (abfd
, ieee_variable_I_enum
)
273 || ! ieee_write_int (abfd
, symbol
->value
))
277 else if (symbol
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
))
279 /* This is a reference to a defined local symbol. We can
280 easily do a local as a section+offset. */
281 if (! ieee_write_byte (abfd
, ieee_variable_R_enum
)
282 || ! ieee_write_byte (abfd
,
283 (bfd_byte
) (symbol
->section
->index
284 + IEEE_SECTION_NUMBER_BASE
)))
287 if (symbol
->value
!= 0)
289 if (! ieee_write_int (abfd
, symbol
->value
))
296 (*_bfd_error_handler
)
297 (_("%s: unrecognized symbol `%s' flags 0x%x"),
298 bfd_get_filename (abfd
), bfd_asymbol_name (symbol
),
300 bfd_set_error (bfd_error_invalid_operation
);
307 /* subtract the pc from here by asking for PC of this section*/
308 if (! ieee_write_byte (abfd
, ieee_variable_P_enum
)
309 || ! ieee_write_byte (abfd
,
310 (bfd_byte
) (index
+ IEEE_SECTION_NUMBER_BASE
))
311 || ! ieee_write_byte (abfd
, ieee_function_minus_enum
))
315 /* Handle the degenerate case of a 0 address. */
318 if (! ieee_write_int (abfd
, 0))
322 while (term_count
> 1)
324 if (! ieee_write_byte (abfd
, ieee_function_plus_enum
))
332 /*****************************************************************************/
335 writes any integer into the buffer supplied and always takes 5 bytes
338 ieee_write_int5 (buffer
, value
)
342 buffer
[0] = (bfd_byte
) ieee_number_repeat_4_enum
;
343 buffer
[1] = (value
>> 24) & 0xff;
344 buffer
[2] = (value
>> 16) & 0xff;
345 buffer
[3] = (value
>> 8) & 0xff;
346 buffer
[4] = (value
>> 0) & 0xff;
350 ieee_write_int5_out (abfd
, value
)
356 ieee_write_int5 (b
, value
);
357 if (bfd_write ((PTR
) b
, 1, 5, abfd
) != 5)
363 parse_int (ieee
, value_ptr
)
364 common_header_type
*ieee
;
367 int value
= this_byte (ieee
);
369 if (value
>= 0 && value
<= 127)
375 else if (value
>= 0x80 && value
<= 0x88)
377 unsigned int count
= value
& 0xf;
382 result
= (result
<< 8) | this_byte_and_next (ieee
);
393 common_header_type
*ieee
;
397 *ok
= parse_int (ieee
, &x
);
402 must_parse_int (ieee
)
403 common_header_type
*ieee
;
406 BFD_ASSERT (parse_int (ieee
, &result
) == true);
414 ieee_symbol_index_type symbol
;
418 #if KEEPMINUSPCININST
420 #define SRC_MASK(arg) arg
421 #define PCREL_OFFSET false
425 #define SRC_MASK(arg) 0
426 #define PCREL_OFFSET true
430 static reloc_howto_type abs32_howto
=
437 complain_overflow_bitfield
,
445 static reloc_howto_type abs16_howto
=
452 complain_overflow_bitfield
,
460 static reloc_howto_type abs8_howto
=
467 complain_overflow_bitfield
,
475 static reloc_howto_type rel32_howto
=
482 complain_overflow_signed
,
486 SRC_MASK (0xffffffff),
490 static reloc_howto_type rel16_howto
=
497 complain_overflow_signed
,
501 SRC_MASK (0x0000ffff),
505 static reloc_howto_type rel8_howto
=
512 complain_overflow_signed
,
516 SRC_MASK (0x000000ff),
520 static ieee_symbol_index_type NOSYMBOL
= {0, 0};
523 parse_expression (ieee
, value
, symbol
, pcrel
, extra
, section
)
524 ieee_data_type
*ieee
;
526 ieee_symbol_index_type
*symbol
;
539 ieee_value_type stack
[10];
541 /* The stack pointer always points to the next unused location */
542 #define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC;
543 #define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value;
544 ieee_value_type
*sp
= stack
;
548 switch (this_byte (&(ieee
->h
)))
550 case ieee_variable_P_enum
:
551 /* P variable, current program counter for section n */
554 next_byte (&(ieee
->h
));
556 section_n
= must_parse_int (&(ieee
->h
));
557 PUSH (NOSYMBOL
, bfd_abs_section_ptr
, 0);
560 case ieee_variable_L_enum
:
561 /* L variable address of section N */
562 next_byte (&(ieee
->h
));
563 PUSH (NOSYMBOL
, ieee
->section_table
[must_parse_int (&(ieee
->h
))], 0);
565 case ieee_variable_R_enum
:
566 /* R variable, logical address of section module */
567 /* FIXME, this should be different to L */
568 next_byte (&(ieee
->h
));
569 PUSH (NOSYMBOL
, ieee
->section_table
[must_parse_int (&(ieee
->h
))], 0);
571 case ieee_variable_S_enum
:
572 /* S variable, size in MAUS of section module */
573 next_byte (&(ieee
->h
));
576 ieee
->section_table
[must_parse_int (&(ieee
->h
))]->_raw_size
);
578 case ieee_variable_I_enum
:
579 /* Push the address of variable n */
581 ieee_symbol_index_type sy
;
582 next_byte (&(ieee
->h
));
583 sy
.index
= (int) must_parse_int (&(ieee
->h
));
586 PUSH (sy
, bfd_abs_section_ptr
, 0);
589 case ieee_variable_X_enum
:
590 /* Push the address of external variable n */
592 ieee_symbol_index_type sy
;
593 next_byte (&(ieee
->h
));
594 sy
.index
= (int) (must_parse_int (&(ieee
->h
)));
597 PUSH (sy
, bfd_und_section_ptr
, 0);
600 case ieee_function_minus_enum
:
602 bfd_vma value1
, value2
;
603 asection
*section1
, *section_dummy
;
604 ieee_symbol_index_type sy
;
605 next_byte (&(ieee
->h
));
607 POP (sy
, section1
, value1
);
608 POP (sy
, section_dummy
, value2
);
609 PUSH (sy
, section1
? section1
: section_dummy
, value2
- value1
);
612 case ieee_function_plus_enum
:
614 bfd_vma value1
, value2
;
617 ieee_symbol_index_type sy1
;
618 ieee_symbol_index_type sy2
;
619 next_byte (&(ieee
->h
));
621 POP (sy1
, section1
, value1
);
622 POP (sy2
, section2
, value2
);
623 PUSH (sy1
.letter
? sy1
: sy2
,
624 bfd_is_abs_section (section1
) ? section2
: section1
,
631 BFD_ASSERT (this_byte (&(ieee
->h
)) < (int) ieee_variable_A_enum
632 || this_byte (&(ieee
->h
)) > (int) ieee_variable_Z_enum
);
633 if (parse_int (&(ieee
->h
), &va
))
635 PUSH (NOSYMBOL
, bfd_abs_section_ptr
, va
);
640 Thats all that we can understand. As far as I can see
641 there is a bug in the Microtec IEEE output which I'm
642 using to scan, whereby the comma operator is omitted
643 sometimes in an expression, giving expressions with too
644 many terms. We can tell if that's the case by ensuring
645 that sp == stack here. If not, then we've pushed
646 something too far, so we keep adding. */
648 while (sp
!= stack
+ 1)
651 ieee_symbol_index_type sy1
;
652 POP (sy1
, section1
, *extra
);
657 POP (*symbol
, dummy
, *value
);
670 #define ieee_seek(abfd, offset) \
671 IEEE_DATA(abfd)->h.input_p = IEEE_DATA(abfd)->h.first_byte + offset
673 #define ieee_pos(abfd) \
674 (IEEE_DATA(abfd)->h.input_p - IEEE_DATA(abfd)->h.first_byte)
676 static unsigned int last_index
;
677 static char last_type
; /* is the index for an X or a D */
679 static ieee_symbol_type
*
688 bfd
*abfd ATTRIBUTE_UNUSED
;
689 ieee_data_type
*ieee
;
690 ieee_symbol_type
*last_symbol
;
691 unsigned int *symbol_count
;
692 ieee_symbol_type
***pptr
;
693 unsigned int *max_index
;
697 /* Need a new symbol */
698 unsigned int new_index
= must_parse_int (&(ieee
->h
));
699 if (new_index
!= last_index
|| this_type
!= last_type
)
701 ieee_symbol_type
*new_symbol
= (ieee_symbol_type
*) bfd_alloc (ieee
->h
.abfd
,
702 sizeof (ieee_symbol_type
));
706 new_symbol
->index
= new_index
;
707 last_index
= new_index
;
710 *pptr
= &new_symbol
->next
;
711 if (new_index
> *max_index
)
713 *max_index
= new_index
;
715 last_type
= this_type
;
716 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
723 ieee_slurp_external_symbols (abfd
)
726 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
727 file_ptr offset
= ieee
->w
.r
.external_part
;
729 ieee_symbol_type
**prev_symbols_ptr
= &ieee
->external_symbols
;
730 ieee_symbol_type
**prev_reference_ptr
= &ieee
->external_reference
;
731 ieee_symbol_type
*symbol
= (ieee_symbol_type
*) NULL
;
732 unsigned int symbol_count
= 0;
734 last_index
= 0xffffff;
735 ieee
->symbol_table_full
= true;
737 ieee_seek (abfd
, offset
);
741 switch (this_byte (&(ieee
->h
)))
744 next_byte (&(ieee
->h
));
746 symbol
= get_symbol (abfd
, ieee
, symbol
, &symbol_count
,
748 &ieee
->external_symbol_max_index
, 'I');
752 symbol
->symbol
.the_bfd
= abfd
;
753 symbol
->symbol
.name
= read_id (&(ieee
->h
));
754 symbol
->symbol
.udata
.p
= (PTR
) NULL
;
755 symbol
->symbol
.flags
= BSF_NO_FLAGS
;
757 case ieee_external_symbol_enum
:
758 next_byte (&(ieee
->h
));
760 symbol
= get_symbol (abfd
, ieee
, symbol
, &symbol_count
,
762 &ieee
->external_symbol_max_index
, 'D');
766 BFD_ASSERT (symbol
->index
>= ieee
->external_symbol_min_index
);
768 symbol
->symbol
.the_bfd
= abfd
;
769 symbol
->symbol
.name
= read_id (&(ieee
->h
));
770 symbol
->symbol
.udata
.p
= (PTR
) NULL
;
771 symbol
->symbol
.flags
= BSF_NO_FLAGS
;
773 case ieee_attribute_record_enum
>> 8:
775 unsigned int symbol_name_index
;
776 unsigned int symbol_type_index
;
777 unsigned int symbol_attribute_def
;
779 switch (read_2bytes (ieee
))
781 case ieee_attribute_record_enum
:
782 symbol_name_index
= must_parse_int (&(ieee
->h
));
783 symbol_type_index
= must_parse_int (&(ieee
->h
));
784 symbol_attribute_def
= must_parse_int (&(ieee
->h
));
785 switch (symbol_attribute_def
)
789 parse_int (&ieee
->h
, &value
);
792 (*_bfd_error_handler
)
793 (_("%s: unimplemented ATI record %u for symbol %u"),
794 bfd_get_filename (abfd
), symbol_attribute_def
,
796 bfd_set_error (bfd_error_bad_value
);
801 case ieee_external_reference_info_record_enum
:
802 /* Skip over ATX record. */
803 parse_int (&(ieee
->h
), &value
);
804 parse_int (&(ieee
->h
), &value
);
805 parse_int (&(ieee
->h
), &value
);
806 parse_int (&(ieee
->h
), &value
);
808 case ieee_atn_record_enum
:
809 /* We may get call optimization information here,
810 which we just ignore. The format is
811 {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs} */
812 parse_int (&ieee
->h
, &value
);
813 parse_int (&ieee
->h
, &value
);
814 parse_int (&ieee
->h
, &value
);
817 (*_bfd_error_handler
)
818 (_("%s: unexpected ATN type %d in external part"),
819 bfd_get_filename (abfd
), (int) value
);
820 bfd_set_error (bfd_error_bad_value
);
823 parse_int (&ieee
->h
, &value
);
824 parse_int (&ieee
->h
, &value
);
831 switch (read_2bytes (ieee
))
833 case ieee_asn_record_enum
:
834 parse_int (&ieee
->h
, &val1
);
835 parse_int (&ieee
->h
, &val1
);
839 (*_bfd_error_handler
)
840 (_("%s: unexpected type after ATN"),
841 bfd_get_filename (abfd
));
842 bfd_set_error (bfd_error_bad_value
);
849 case ieee_value_record_enum
>> 8:
851 unsigned int symbol_name_index
;
852 ieee_symbol_index_type symbol_ignore
;
853 boolean pcrel_ignore
;
855 next_byte (&(ieee
->h
));
856 next_byte (&(ieee
->h
));
858 symbol_name_index
= must_parse_int (&(ieee
->h
));
859 parse_expression (ieee
,
860 &symbol
->symbol
.value
,
864 &symbol
->symbol
.section
);
866 /* Fully linked IEEE-695 files tend to give every symbol
867 an absolute value. Try to convert that back into a
868 section relative value. FIXME: This won't always to
870 if (bfd_is_abs_section (symbol
->symbol
.section
)
871 && (abfd
->flags
& HAS_RELOC
) == 0)
876 val
= symbol
->symbol
.value
;
877 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
879 if (val
>= s
->vma
&& val
< s
->vma
+ s
->_raw_size
)
881 symbol
->symbol
.section
= s
;
882 symbol
->symbol
.value
-= s
->vma
;
888 symbol
->symbol
.flags
= BSF_GLOBAL
| BSF_EXPORT
;
892 case ieee_weak_external_reference_enum
:
896 next_byte (&(ieee
->h
));
897 /* Throw away the external reference index */
898 (void) must_parse_int (&(ieee
->h
));
899 /* Fetch the default size if not resolved */
900 size
= must_parse_int (&(ieee
->h
));
901 /* Fetch the defautlt value if available */
902 if (parse_int (&(ieee
->h
), &value
) == false)
906 /* This turns into a common */
907 symbol
->symbol
.section
= bfd_com_section_ptr
;
908 symbol
->symbol
.value
= size
;
912 case ieee_external_reference_enum
:
913 next_byte (&(ieee
->h
));
915 symbol
= get_symbol (abfd
, ieee
, symbol
, &symbol_count
,
917 &ieee
->external_reference_max_index
, 'X');
921 symbol
->symbol
.the_bfd
= abfd
;
922 symbol
->symbol
.name
= read_id (&(ieee
->h
));
923 symbol
->symbol
.udata
.p
= (PTR
) NULL
;
924 symbol
->symbol
.section
= bfd_und_section_ptr
;
925 symbol
->symbol
.value
= (bfd_vma
) 0;
926 symbol
->symbol
.flags
= 0;
928 BFD_ASSERT (symbol
->index
>= ieee
->external_reference_min_index
);
936 if (ieee
->external_symbol_max_index
!= 0)
938 ieee
->external_symbol_count
=
939 ieee
->external_symbol_max_index
-
940 ieee
->external_symbol_min_index
+ 1;
944 ieee
->external_symbol_count
= 0;
947 if (ieee
->external_reference_max_index
!= 0)
949 ieee
->external_reference_count
=
950 ieee
->external_reference_max_index
-
951 ieee
->external_reference_min_index
+ 1;
955 ieee
->external_reference_count
= 0;
959 ieee
->external_reference_count
+ ieee
->external_symbol_count
;
961 if (symbol_count
!= abfd
->symcount
)
963 /* There are gaps in the table -- */
964 ieee
->symbol_table_full
= false;
967 *prev_symbols_ptr
= (ieee_symbol_type
*) NULL
;
968 *prev_reference_ptr
= (ieee_symbol_type
*) NULL
;
974 ieee_slurp_symbol_table (abfd
)
977 if (IEEE_DATA (abfd
)->read_symbols
== false)
979 if (! ieee_slurp_external_symbols (abfd
))
981 IEEE_DATA (abfd
)->read_symbols
= true;
987 ieee_get_symtab_upper_bound (abfd
)
990 if (! ieee_slurp_symbol_table (abfd
))
993 return (abfd
->symcount
!= 0) ?
994 (abfd
->symcount
+ 1) * (sizeof (ieee_symbol_type
*)) : 0;
998 Move from our internal lists to the canon table, and insert in
1002 extern const bfd_target ieee_vec
;
1005 ieee_get_symtab (abfd
, location
)
1009 ieee_symbol_type
*symp
;
1010 static bfd dummy_bfd
;
1011 static asymbol empty_symbol
=
1012 /* the_bfd, name, value, attr, section */
1013 {&dummy_bfd
, " ieee empty", (symvalue
) 0, BSF_DEBUGGING
, bfd_abs_section_ptr
, { 0 }};
1017 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
1018 dummy_bfd
.xvec
= &ieee_vec
;
1019 if (! ieee_slurp_symbol_table (abfd
))
1022 if (ieee
->symbol_table_full
== false)
1024 /* Arrgh - there are gaps in the table, run through and fill them */
1025 /* up with pointers to a null place */
1027 for (i
= 0; i
< abfd
->symcount
; i
++)
1029 location
[i
] = &empty_symbol
;
1033 ieee
->external_symbol_base_offset
= -ieee
->external_symbol_min_index
;
1034 for (symp
= IEEE_DATA (abfd
)->external_symbols
;
1035 symp
!= (ieee_symbol_type
*) NULL
;
1038 /* Place into table at correct index locations */
1039 location
[symp
->index
+ ieee
->external_symbol_base_offset
] = &symp
->symbol
;
1042 /* The external refs are indexed in a bit */
1043 ieee
->external_reference_base_offset
=
1044 -ieee
->external_reference_min_index
+ ieee
->external_symbol_count
;
1046 for (symp
= IEEE_DATA (abfd
)->external_reference
;
1047 symp
!= (ieee_symbol_type
*) NULL
;
1050 location
[symp
->index
+ ieee
->external_reference_base_offset
] =
1057 location
[abfd
->symcount
] = (asymbol
*) NULL
;
1059 return abfd
->symcount
;
1063 get_section_entry (abfd
, ieee
, index
)
1065 ieee_data_type
*ieee
;
1068 if (index
>= ieee
->section_table_size
)
1073 c
= ieee
->section_table_size
;
1080 bfd_realloc (ieee
->section_table
, c
* sizeof (asection
*)));
1084 for (i
= ieee
->section_table_size
; i
< c
; i
++)
1087 ieee
->section_table
= n
;
1088 ieee
->section_table_size
= c
;
1091 if (ieee
->section_table
[index
] == (asection
*) NULL
)
1093 char *tmp
= bfd_alloc (abfd
, 11);
1098 sprintf (tmp
, " fsec%4d", index
);
1099 section
= bfd_make_section (abfd
, tmp
);
1100 ieee
->section_table
[index
] = section
;
1101 section
->flags
= SEC_NO_FLAGS
;
1102 section
->target_index
= index
;
1103 ieee
->section_table
[index
] = section
;
1105 return ieee
->section_table
[index
];
1109 ieee_slurp_sections (abfd
)
1112 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
1113 file_ptr offset
= ieee
->w
.r
.section_part
;
1114 asection
*section
= (asection
*) NULL
;
1119 bfd_byte section_type
[3];
1120 ieee_seek (abfd
, offset
);
1123 switch (this_byte (&(ieee
->h
)))
1125 case ieee_section_type_enum
:
1127 unsigned int section_index
;
1128 next_byte (&(ieee
->h
));
1129 section_index
= must_parse_int (&(ieee
->h
));
1131 section
= get_section_entry (abfd
, ieee
, section_index
);
1133 section_type
[0] = this_byte_and_next (&(ieee
->h
));
1135 /* Set minimal section attributes. Attributes are
1136 extended later, based on section contents. */
1138 switch (section_type
[0])
1141 /* Normal attributes for absolute sections */
1142 section_type
[1] = this_byte (&(ieee
->h
));
1143 section
->flags
= SEC_ALLOC
;
1144 switch (section_type
[1])
1146 case 0xD3: /* AS Absolute section attributes */
1147 next_byte (&(ieee
->h
));
1148 section_type
[2] = this_byte (&(ieee
->h
));
1149 switch (section_type
[2])
1153 next_byte (&(ieee
->h
));
1154 section
->flags
|= SEC_CODE
;
1158 next_byte (&(ieee
->h
));
1159 section
->flags
|= SEC_DATA
;
1162 next_byte (&(ieee
->h
));
1163 /* Normal rom data */
1164 section
->flags
|= SEC_ROM
| SEC_DATA
;
1171 case 0xC3: /* Named relocatable sections (type C) */
1172 section_type
[1] = this_byte (&(ieee
->h
));
1173 section
->flags
= SEC_ALLOC
;
1174 switch (section_type
[1])
1176 case 0xD0: /* Normal code (CP) */
1177 next_byte (&(ieee
->h
));
1178 section
->flags
|= SEC_CODE
;
1180 case 0xC4: /* Normal data (CD) */
1181 next_byte (&(ieee
->h
));
1182 section
->flags
|= SEC_DATA
;
1184 case 0xD2: /* Normal rom data (CR) */
1185 next_byte (&(ieee
->h
));
1186 section
->flags
|= SEC_ROM
| SEC_DATA
;
1193 /* Read section name, use it if non empty. */
1194 name
= read_id (&ieee
->h
);
1196 section
->name
= name
;
1198 /* Skip these fields, which we don't care about */
1200 bfd_vma parent
, brother
, context
;
1201 parse_int (&(ieee
->h
), &parent
);
1202 parse_int (&(ieee
->h
), &brother
);
1203 parse_int (&(ieee
->h
), &context
);
1207 case ieee_section_alignment_enum
:
1209 unsigned int section_index
;
1212 next_byte (&(ieee
->h
));
1213 section_index
= must_parse_int (&ieee
->h
);
1214 section
= get_section_entry (abfd
, ieee
, section_index
);
1215 if (section_index
> ieee
->section_count
)
1217 ieee
->section_count
= section_index
;
1219 section
->alignment_power
=
1220 bfd_log2 (must_parse_int (&ieee
->h
));
1221 (void) parse_int (&(ieee
->h
), &value
);
1224 case ieee_e2_first_byte_enum
:
1226 ieee_record_enum_type t
= (ieee_record_enum_type
) (read_2bytes (&(ieee
->h
)));
1230 case ieee_section_size_enum
:
1231 section
= ieee
->section_table
[must_parse_int (&(ieee
->h
))];
1232 section
->_raw_size
= must_parse_int (&(ieee
->h
));
1234 case ieee_physical_region_size_enum
:
1235 section
= ieee
->section_table
[must_parse_int (&(ieee
->h
))];
1236 section
->_raw_size
= must_parse_int (&(ieee
->h
));
1238 case ieee_region_base_address_enum
:
1239 section
= ieee
->section_table
[must_parse_int (&(ieee
->h
))];
1240 section
->vma
= must_parse_int (&(ieee
->h
));
1241 section
->lma
= section
->vma
;
1243 case ieee_mau_size_enum
:
1244 must_parse_int (&(ieee
->h
));
1245 must_parse_int (&(ieee
->h
));
1247 case ieee_m_value_enum
:
1248 must_parse_int (&(ieee
->h
));
1249 must_parse_int (&(ieee
->h
));
1251 case ieee_section_base_address_enum
:
1252 section
= ieee
->section_table
[must_parse_int (&(ieee
->h
))];
1253 section
->vma
= must_parse_int (&(ieee
->h
));
1254 section
->lma
= section
->vma
;
1256 case ieee_section_offset_enum
:
1257 (void) must_parse_int (&(ieee
->h
));
1258 (void) must_parse_int (&(ieee
->h
));
1272 /* Make a section for the debugging information, if any. We don't try
1273 to interpret the debugging information; we just point the section
1274 at the area in the file so that program which understand can dig it
1278 ieee_slurp_debug (abfd
)
1281 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
1285 if (ieee
->w
.r
.debug_information_part
== 0)
1288 sec
= bfd_make_section (abfd
, ".debug");
1291 sec
->flags
|= SEC_DEBUGGING
| SEC_HAS_CONTENTS
;
1292 sec
->filepos
= ieee
->w
.r
.debug_information_part
;
1294 debug_end
= ieee
->w
.r
.data_part
;
1296 debug_end
= ieee
->w
.r
.trailer_part
;
1298 debug_end
= ieee
->w
.r
.me_record
;
1299 sec
->_raw_size
= debug_end
- ieee
->w
.r
.debug_information_part
;
1304 /***********************************************************************
1309 ieee_archive_p (abfd
)
1314 unsigned char buffer
[512];
1315 file_ptr buffer_offset
= 0;
1316 ieee_ar_data_type
*save
= abfd
->tdata
.ieee_ar_data
;
1317 ieee_ar_data_type
*ieee
;
1318 unsigned int alc_elts
;
1319 ieee_ar_obstack_type
*elts
= NULL
;
1321 abfd
->tdata
.ieee_ar_data
=
1322 (ieee_ar_data_type
*) bfd_alloc (abfd
, sizeof (ieee_ar_data_type
));
1323 if (!abfd
->tdata
.ieee_ar_data
)
1325 ieee
= IEEE_AR_DATA (abfd
);
1327 /* FIXME: Check return value. I'm not sure whether it needs to read
1328 the entire buffer or not. */
1329 bfd_read ((PTR
) buffer
, 1, sizeof (buffer
), abfd
);
1331 ieee
->h
.first_byte
= buffer
;
1332 ieee
->h
.input_p
= buffer
;
1334 ieee
->h
.abfd
= abfd
;
1336 if (this_byte (&(ieee
->h
)) != Module_Beginning
)
1338 abfd
->tdata
.ieee_ar_data
= save
;
1342 next_byte (&(ieee
->h
));
1343 library
= read_id (&(ieee
->h
));
1344 if (strcmp (library
, "LIBRARY") != 0)
1346 bfd_release (abfd
, ieee
);
1347 abfd
->tdata
.ieee_ar_data
= save
;
1350 /* Throw away the filename */
1351 read_id (&(ieee
->h
));
1353 ieee
->element_count
= 0;
1354 ieee
->element_index
= 0;
1356 next_byte (&(ieee
->h
)); /* Drop the ad part */
1357 must_parse_int (&(ieee
->h
)); /* And the two dummy numbers */
1358 must_parse_int (&(ieee
->h
));
1361 elts
= (ieee_ar_obstack_type
*) bfd_malloc (alc_elts
* sizeof *elts
);
1365 /* Read the index of the BB table */
1369 ieee_ar_obstack_type
*t
;
1371 rec
= read_2bytes (&(ieee
->h
));
1372 if (rec
!= (int) ieee_assign_value_to_variable_enum
)
1375 if (ieee
->element_count
>= alc_elts
)
1377 ieee_ar_obstack_type
*n
;
1380 n
= ((ieee_ar_obstack_type
*)
1381 bfd_realloc (elts
, alc_elts
* sizeof *elts
));
1387 t
= &elts
[ieee
->element_count
];
1388 ieee
->element_count
++;
1390 must_parse_int (&(ieee
->h
));
1391 t
->file_offset
= must_parse_int (&(ieee
->h
));
1392 t
->abfd
= (bfd
*) NULL
;
1394 /* Make sure that we don't go over the end of the buffer */
1396 if ((size_t) ieee_pos (abfd
) > sizeof (buffer
) / 2)
1398 /* Past half way, reseek and reprime */
1399 buffer_offset
+= ieee_pos (abfd
);
1400 if (bfd_seek (abfd
, buffer_offset
, SEEK_SET
) != 0)
1402 /* FIXME: Check return value. I'm not sure whether it needs
1403 to read the entire buffer or not. */
1404 bfd_read ((PTR
) buffer
, 1, sizeof (buffer
), abfd
);
1405 ieee
->h
.first_byte
= buffer
;
1406 ieee
->h
.input_p
= buffer
;
1410 ieee
->elements
= ((ieee_ar_obstack_type
*)
1412 ieee
->element_count
* sizeof *ieee
->elements
));
1413 if (ieee
->elements
== NULL
)
1415 memcpy (ieee
->elements
, elts
,
1416 ieee
->element_count
* sizeof *ieee
->elements
);
1420 /* Now scan the area again, and replace BB offsets with file */
1423 for (i
= 2; i
< ieee
->element_count
; i
++)
1425 if (bfd_seek (abfd
, ieee
->elements
[i
].file_offset
, SEEK_SET
) != 0)
1427 /* FIXME: Check return value. I'm not sure whether it needs to
1428 read the entire buffer or not. */
1429 bfd_read ((PTR
) buffer
, 1, sizeof (buffer
), abfd
);
1430 ieee
->h
.first_byte
= buffer
;
1431 ieee
->h
.input_p
= buffer
;
1433 next_byte (&(ieee
->h
)); /* Drop F8 */
1434 next_byte (&(ieee
->h
)); /* Drop 14 */
1435 must_parse_int (&(ieee
->h
)); /* Drop size of block */
1436 if (must_parse_int (&(ieee
->h
)) != 0)
1438 /* This object has been deleted */
1439 ieee
->elements
[i
].file_offset
= 0;
1443 ieee
->elements
[i
].file_offset
= must_parse_int (&(ieee
->h
));
1447 /* abfd->has_armap = ;*/
1458 ieee_mkobject (abfd
)
1461 abfd
->tdata
.ieee_data
= (ieee_data_type
*) bfd_zalloc (abfd
, sizeof (ieee_data_type
));
1462 return abfd
->tdata
.ieee_data
? true : false;
1466 ieee_object_p (abfd
)
1471 ieee_data_type
*ieee
;
1472 unsigned char buffer
[300];
1473 ieee_data_type
*save
= IEEE_DATA (abfd
);
1475 abfd
->tdata
.ieee_data
= 0;
1476 ieee_mkobject (abfd
);
1478 ieee
= IEEE_DATA (abfd
);
1479 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
1481 /* Read the first few bytes in to see if it makes sense */
1482 /* FIXME: Check return value. I'm not sure whether it needs to read
1483 the entire buffer or not. */
1484 bfd_read ((PTR
) buffer
, 1, sizeof (buffer
), abfd
);
1486 ieee
->h
.input_p
= buffer
;
1487 if (this_byte_and_next (&(ieee
->h
)) != Module_Beginning
)
1488 goto got_wrong_format
;
1490 ieee
->read_symbols
= false;
1491 ieee
->read_data
= false;
1492 ieee
->section_count
= 0;
1493 ieee
->external_symbol_max_index
= 0;
1494 ieee
->external_symbol_min_index
= IEEE_PUBLIC_BASE
;
1495 ieee
->external_reference_min_index
= IEEE_REFERENCE_BASE
;
1496 ieee
->external_reference_max_index
= 0;
1497 ieee
->h
.abfd
= abfd
;
1498 ieee
->section_table
= NULL
;
1499 ieee
->section_table_size
= 0;
1501 processor
= ieee
->mb
.processor
= read_id (&(ieee
->h
));
1502 if (strcmp (processor
, "LIBRARY") == 0)
1503 goto got_wrong_format
;
1504 ieee
->mb
.module_name
= read_id (&(ieee
->h
));
1505 if (abfd
->filename
== (CONST
char *) NULL
)
1507 abfd
->filename
= ieee
->mb
.module_name
;
1509 /* Determine the architecture and machine type of the object file.
1512 const bfd_arch_info_type
*arch
;
1515 /* IEEE does not specify the format of the processor identificaton
1516 string, so the compiler is free to put in it whatever it wants.
1517 We try here to recognize different processors belonging to the
1518 m68k family. Code for other processors can be added here. */
1519 if ((processor
[0] == '6') && (processor
[1] == '8'))
1521 if (processor
[2] == '3') /* 683xx integrated processors */
1523 switch (processor
[3])
1525 case '0': /* 68302, 68306, 68307 */
1526 case '2': /* 68322, 68328 */
1527 case '5': /* 68356 */
1528 strcpy (family
, "68000"); /* MC68000-based controllers */
1531 case '3': /* 68330, 68331, 68332, 68333,
1532 68334, 68335, 68336, 68338 */
1533 case '6': /* 68360 */
1534 case '7': /* 68376 */
1535 strcpy (family
, "68332"); /* CPU32 and CPU32+ */
1539 if (processor
[4] == '9') /* 68349 */
1540 strcpy (family
, "68030"); /* CPU030 */
1541 else /* 68340, 68341 */
1542 strcpy (family
, "68332"); /* CPU32 and CPU32+ */
1545 default: /* Does not exist yet */
1546 strcpy (family
, "68332"); /* Guess it will be CPU32 */
1549 else if (toupper (processor
[3]) == 'F') /* 68F333 */
1550 strcpy (family
, "68332"); /* CPU32 */
1551 else if ((toupper (processor
[3]) == 'C') /* Embedded controllers */
1552 && ((toupper (processor
[2]) == 'E')
1553 || (toupper (processor
[2]) == 'H')
1554 || (toupper (processor
[2]) == 'L')))
1556 strcpy (family
, "68");
1557 strncat (family
, processor
+ 4, 7);
1560 else /* "Regular" processors */
1562 strncpy (family
, processor
, 9);
1566 else if ((strncmp (processor
, "cpu32", 5) == 0) /* CPU32 and CPU32+ */
1567 || (strncmp (processor
, "CPU32", 5) == 0))
1568 strcpy (family
, "68332");
1571 strncpy (family
, processor
, 9);
1575 arch
= bfd_scan_arch (family
);
1577 goto got_wrong_format
;
1578 abfd
->arch_info
= arch
;
1581 if (this_byte (&(ieee
->h
)) != (int) ieee_address_descriptor_enum
)
1585 next_byte (&(ieee
->h
));
1587 if (parse_int (&(ieee
->h
), &ieee
->ad
.number_of_bits_mau
) == false)
1591 if (parse_int (&(ieee
->h
), &ieee
->ad
.number_of_maus_in_address
) == false)
1596 /* If there is a byte order info, take it */
1597 if (this_byte (&(ieee
->h
)) == (int) ieee_variable_L_enum
||
1598 this_byte (&(ieee
->h
)) == (int) ieee_variable_M_enum
)
1599 next_byte (&(ieee
->h
));
1601 for (part
= 0; part
< N_W_VARIABLES
; part
++)
1604 if (read_2bytes (&(ieee
->h
)) != (int) ieee_assign_value_to_variable_enum
)
1608 if (this_byte_and_next (&(ieee
->h
)) != part
)
1613 ieee
->w
.offset
[part
] = parse_i (&(ieee
->h
), &ok
);
1621 if (ieee
->w
.r
.external_part
!= 0)
1622 abfd
->flags
= HAS_SYMS
;
1624 /* By now we know that this is a real IEEE file, we're going to read
1625 the whole thing into memory so that we can run up and down it
1626 quickly. We can work out how big the file is from the trailer
1629 IEEE_DATA (abfd
)->h
.first_byte
=
1630 (unsigned char *) bfd_alloc (ieee
->h
.abfd
, ieee
->w
.r
.me_record
+ 1);
1631 if (!IEEE_DATA (abfd
)->h
.first_byte
)
1633 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
1635 /* FIXME: Check return value. I'm not sure whether it needs to read
1636 the entire buffer or not. */
1637 bfd_read ((PTR
) (IEEE_DATA (abfd
)->h
.first_byte
), 1,
1638 ieee
->w
.r
.me_record
+ 1, abfd
);
1640 ieee_slurp_sections (abfd
);
1642 if (! ieee_slurp_debug (abfd
))
1645 /* Parse section data to activate file and section flags implied by
1646 section contents. */
1648 if (! ieee_slurp_section_data (abfd
))
1653 bfd_set_error (bfd_error_wrong_format
);
1655 (void) bfd_release (abfd
, ieee
);
1656 abfd
->tdata
.ieee_data
= save
;
1657 return (const bfd_target
*) NULL
;
1661 ieee_get_symbol_info (ignore_abfd
, symbol
, ret
)
1662 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
1666 bfd_symbol_info (symbol
, ret
);
1667 if (symbol
->name
[0] == ' ')
1668 ret
->name
= "* empty table entry ";
1669 if (!symbol
->section
)
1670 ret
->type
= (symbol
->flags
& BSF_LOCAL
) ? 'a' : 'A';
1674 ieee_print_symbol (ignore_abfd
, afile
, symbol
, how
)
1675 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
1678 bfd_print_symbol_type how
;
1680 FILE *file
= (FILE *) afile
;
1684 case bfd_print_symbol_name
:
1685 fprintf (file
, "%s", symbol
->name
);
1687 case bfd_print_symbol_more
:
1689 fprintf (file
, "%4x %2x", aout_symbol (symbol
)->desc
& 0xffff,
1690 aout_symbol (symbol
)->other
& 0xff);
1694 case bfd_print_symbol_all
:
1696 const char *section_name
=
1697 (symbol
->section
== (asection
*) NULL
1699 : symbol
->section
->name
);
1700 if (symbol
->name
[0] == ' ')
1702 fprintf (file
, "* empty table entry ");
1706 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
1708 fprintf (file
, " %-5s %04x %02x %s",
1710 (unsigned) ieee_symbol (symbol
)->index
,
1720 do_one (ieee
, current_map
, location_ptr
, s
, iterations
)
1721 ieee_data_type
*ieee
;
1722 ieee_per_section_type
*current_map
;
1723 unsigned char *location_ptr
;
1727 switch (this_byte (&(ieee
->h
)))
1729 case ieee_load_constant_bytes_enum
:
1731 unsigned int number_of_maus
;
1733 next_byte (&(ieee
->h
));
1734 number_of_maus
= must_parse_int (&(ieee
->h
));
1736 for (i
= 0; i
< number_of_maus
; i
++)
1738 location_ptr
[current_map
->pc
++] = this_byte (&(ieee
->h
));
1739 next_byte (&(ieee
->h
));
1744 case ieee_load_with_relocation_enum
:
1746 boolean loop
= true;
1747 next_byte (&(ieee
->h
));
1750 switch (this_byte (&(ieee
->h
)))
1752 case ieee_variable_R_enum
:
1754 case ieee_function_signed_open_b_enum
:
1755 case ieee_function_unsigned_open_b_enum
:
1756 case ieee_function_either_open_b_enum
:
1758 unsigned int extra
= 4;
1759 boolean pcrel
= false;
1761 ieee_reloc_type
*r
=
1762 (ieee_reloc_type
*) bfd_alloc (ieee
->h
.abfd
,
1763 sizeof (ieee_reloc_type
));
1767 *(current_map
->reloc_tail_ptr
) = r
;
1768 current_map
->reloc_tail_ptr
= &r
->next
;
1769 r
->next
= (ieee_reloc_type
*) NULL
;
1770 next_byte (&(ieee
->h
));
1772 r
->relent
.sym_ptr_ptr
= 0;
1773 parse_expression (ieee
,
1776 &pcrel
, &extra
, §ion
);
1777 r
->relent
.address
= current_map
->pc
;
1778 s
->flags
|= SEC_RELOC
;
1779 s
->owner
->flags
|= HAS_RELOC
;
1781 if (r
->relent
.sym_ptr_ptr
== NULL
&& section
!= NULL
)
1782 r
->relent
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
1784 if (this_byte (&(ieee
->h
)) == (int) ieee_comma
)
1786 next_byte (&(ieee
->h
));
1787 /* Fetch number of bytes to pad */
1788 extra
= must_parse_int (&(ieee
->h
));
1791 switch (this_byte (&(ieee
->h
)))
1793 case ieee_function_signed_close_b_enum
:
1794 next_byte (&(ieee
->h
));
1796 case ieee_function_unsigned_close_b_enum
:
1797 next_byte (&(ieee
->h
));
1799 case ieee_function_either_close_b_enum
:
1800 next_byte (&(ieee
->h
));
1805 /* Build a relocation entry for this type */
1806 /* If pc rel then stick -ve pc into instruction
1807 and take out of reloc ..
1809 I've changed this. It's all too complicated. I
1810 keep 0 in the instruction now. */
1819 #if KEEPMINUSPCININST
1820 bfd_put_32 (ieee
->h
.abfd
, -current_map
->pc
, location_ptr
+
1822 r
->relent
.howto
= &rel32_howto
;
1826 bfd_put_32 (ieee
->h
.abfd
, 0, location_ptr
+
1828 r
->relent
.howto
= &rel32_howto
;
1833 bfd_put_32 (ieee
->h
.abfd
, 0, location_ptr
+
1835 r
->relent
.howto
= &abs32_howto
;
1837 current_map
->pc
+= 4;
1842 #if KEEPMINUSPCININST
1843 bfd_put_16 (ieee
->h
.abfd
, (int) (-current_map
->pc
), location_ptr
+ current_map
->pc
);
1844 r
->relent
.addend
-= current_map
->pc
;
1845 r
->relent
.howto
= &rel16_howto
;
1848 bfd_put_16 (ieee
->h
.abfd
, 0, location_ptr
+ current_map
->pc
);
1849 r
->relent
.howto
= &rel16_howto
;
1855 bfd_put_16 (ieee
->h
.abfd
, 0, location_ptr
+ current_map
->pc
);
1856 r
->relent
.howto
= &abs16_howto
;
1858 current_map
->pc
+= 2;
1863 #if KEEPMINUSPCININST
1864 bfd_put_8 (ieee
->h
.abfd
, (int) (-current_map
->pc
), location_ptr
+ current_map
->pc
);
1865 r
->relent
.addend
-= current_map
->pc
;
1866 r
->relent
.howto
= &rel8_howto
;
1868 bfd_put_8 (ieee
->h
.abfd
, 0, location_ptr
+ current_map
->pc
);
1869 r
->relent
.howto
= &rel8_howto
;
1874 bfd_put_8 (ieee
->h
.abfd
, 0, location_ptr
+ current_map
->pc
);
1875 r
->relent
.howto
= &abs8_howto
;
1877 current_map
->pc
+= 1;
1889 if (parse_int (&(ieee
->h
), &this_size
) == true)
1892 for (i
= 0; i
< this_size
; i
++)
1894 location_ptr
[current_map
->pc
++] = this_byte (&(ieee
->h
));
1895 next_byte (&(ieee
->h
));
1905 /* Prevent more than the first load-item of an LR record
1906 from being repeated (MRI convention). */
1907 if (iterations
!= 1)
1915 /* Read in all the section data and relocation stuff too */
1917 ieee_slurp_section_data (abfd
)
1920 bfd_byte
*location_ptr
= (bfd_byte
*) NULL
;
1921 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
1922 unsigned int section_number
;
1924 ieee_per_section_type
*current_map
= (ieee_per_section_type
*) NULL
;
1926 /* Seek to the start of the data area */
1927 if (ieee
->read_data
== true)
1929 ieee
->read_data
= true;
1930 ieee_seek (abfd
, ieee
->w
.r
.data_part
);
1932 /* Allocate enough space for all the section contents */
1934 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1936 ieee_per_section_type
*per
= (ieee_per_section_type
*) s
->used_by_bfd
;
1937 if ((s
->flags
& SEC_DEBUGGING
) != 0)
1939 per
->data
= (bfd_byte
*) bfd_alloc (ieee
->h
.abfd
, s
->_raw_size
);
1943 per
->reloc_tail_ptr
=
1944 (ieee_reloc_type
**) & (s
->relocation
);
1949 switch (this_byte (&(ieee
->h
)))
1951 /* IF we see anything strange then quit */
1955 case ieee_set_current_section_enum
:
1956 next_byte (&(ieee
->h
));
1957 section_number
= must_parse_int (&(ieee
->h
));
1958 s
= ieee
->section_table
[section_number
];
1959 s
->flags
|= SEC_LOAD
| SEC_HAS_CONTENTS
;
1960 current_map
= (ieee_per_section_type
*) s
->used_by_bfd
;
1961 location_ptr
= current_map
->data
- s
->vma
;
1962 /* The document I have says that Microtec's compilers reset */
1963 /* this after a sec section, even though the standard says not */
1965 current_map
->pc
= s
->vma
;
1968 case ieee_e2_first_byte_enum
:
1969 next_byte (&(ieee
->h
));
1970 switch (this_byte (&(ieee
->h
)))
1972 case ieee_set_current_pc_enum
& 0xff:
1975 ieee_symbol_index_type symbol
;
1978 next_byte (&(ieee
->h
));
1979 must_parse_int (&(ieee
->h
)); /* Thow away section #*/
1980 parse_expression (ieee
, &value
,
1984 current_map
->pc
= value
;
1985 BFD_ASSERT ((unsigned) (value
- s
->vma
) <= s
->_raw_size
);
1989 case ieee_value_starting_address_enum
& 0xff:
1990 next_byte (&(ieee
->h
));
1991 if (this_byte (&(ieee
->h
)) == ieee_function_either_open_b_enum
)
1992 next_byte (&(ieee
->h
));
1993 abfd
->start_address
= must_parse_int (&(ieee
->h
));
1994 /* We've got to the end of the data now - */
2001 case ieee_repeat_data_enum
:
2003 /* Repeat the following LD or LR n times - we do this by
2004 remembering the stream pointer before running it and
2005 resetting it and running it n times. We special case
2006 the repetition of a repeat_data/load_constant
2009 unsigned int iterations
;
2010 unsigned char *start
;
2011 next_byte (&(ieee
->h
));
2012 iterations
= must_parse_int (&(ieee
->h
));
2013 start
= ieee
->h
.input_p
;
2014 if (start
[0] == (int) ieee_load_constant_bytes_enum
&&
2017 while (iterations
!= 0)
2019 location_ptr
[current_map
->pc
++] = start
[2];
2022 next_byte (&(ieee
->h
));
2023 next_byte (&(ieee
->h
));
2024 next_byte (&(ieee
->h
));
2028 while (iterations
!= 0)
2030 ieee
->h
.input_p
= start
;
2031 if (!do_one (ieee
, current_map
, location_ptr
, s
,
2039 case ieee_load_constant_bytes_enum
:
2040 case ieee_load_with_relocation_enum
:
2042 if (!do_one (ieee
, current_map
, location_ptr
, s
, 1))
2050 ieee_new_section_hook (abfd
, newsect
)
2054 newsect
->used_by_bfd
= (PTR
)
2055 bfd_alloc (abfd
, sizeof (ieee_per_section_type
));
2056 if (!newsect
->used_by_bfd
)
2058 ieee_per_section (newsect
)->data
= (bfd_byte
*) NULL
;
2059 ieee_per_section (newsect
)->section
= newsect
;
2064 ieee_get_reloc_upper_bound (abfd
, asect
)
2068 if ((asect
->flags
& SEC_DEBUGGING
) != 0)
2070 if (! ieee_slurp_section_data (abfd
))
2072 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2076 ieee_get_section_contents (abfd
, section
, location
, offset
, count
)
2081 bfd_size_type count
;
2083 ieee_per_section_type
*p
= (ieee_per_section_type
*) section
->used_by_bfd
;
2084 if ((section
->flags
& SEC_DEBUGGING
) != 0)
2085 return _bfd_generic_get_section_contents (abfd
, section
, location
,
2087 ieee_slurp_section_data (abfd
);
2088 (void) memcpy ((PTR
) location
, (PTR
) (p
->data
+ offset
), (unsigned) count
);
2093 ieee_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2099 /* ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
2100 ieee_reloc_type
*src
= (ieee_reloc_type
*) (section
->relocation
);
2101 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
2103 if ((section
->flags
& SEC_DEBUGGING
) != 0)
2106 while (src
!= (ieee_reloc_type
*) NULL
)
2108 /* Work out which symbol to attach it this reloc to */
2109 switch (src
->symbol
.letter
)
2112 src
->relent
.sym_ptr_ptr
=
2113 symbols
+ src
->symbol
.index
+ ieee
->external_symbol_base_offset
;
2116 src
->relent
.sym_ptr_ptr
=
2117 symbols
+ src
->symbol
.index
+ ieee
->external_reference_base_offset
;
2120 if (src
->relent
.sym_ptr_ptr
!= NULL
)
2121 src
->relent
.sym_ptr_ptr
=
2122 src
->relent
.sym_ptr_ptr
[0]->section
->symbol_ptr_ptr
;
2128 *relptr
++ = &src
->relent
;
2131 *relptr
= (arelent
*) NULL
;
2132 return section
->reloc_count
;
2140 arelent
*a
= *((arelent
**) ap
);
2141 arelent
*b
= *((arelent
**) bp
);
2142 return a
->address
- b
->address
;
2145 /* Write the section headers. */
2148 ieee_write_section_part (abfd
)
2151 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
2153 ieee
->w
.r
.section_part
= bfd_tell (abfd
);
2154 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2156 if (! bfd_is_abs_section (s
)
2157 && (s
->flags
& SEC_DEBUGGING
) == 0)
2159 if (! ieee_write_byte (abfd
, ieee_section_type_enum
)
2160 || ! ieee_write_byte (abfd
,
2161 (bfd_byte
) (s
->index
2162 + IEEE_SECTION_NUMBER_BASE
)))
2165 if (abfd
->flags
& EXEC_P
)
2167 /* This image is executable, so output absolute sections */
2168 if (! ieee_write_byte (abfd
, ieee_variable_A_enum
)
2169 || ! ieee_write_byte (abfd
, ieee_variable_S_enum
))
2174 if (! ieee_write_byte (abfd
, ieee_variable_C_enum
))
2178 switch (s
->flags
& (SEC_CODE
| SEC_DATA
| SEC_ROM
))
2180 case SEC_CODE
| SEC_LOAD
:
2182 if (! ieee_write_byte (abfd
, ieee_variable_P_enum
))
2187 if (! ieee_write_byte (abfd
, ieee_variable_D_enum
))
2191 case SEC_ROM
| SEC_DATA
:
2192 case SEC_ROM
| SEC_LOAD
:
2193 case SEC_ROM
| SEC_DATA
| SEC_LOAD
:
2194 if (! ieee_write_byte (abfd
, ieee_variable_R_enum
))
2199 if (! ieee_write_id (abfd
, s
->name
))
2202 ieee_write_int (abfd
, 0); /* Parent */
2203 ieee_write_int (abfd
, 0); /* Brother */
2204 ieee_write_int (abfd
, 0); /* Context */
2207 if (! ieee_write_byte (abfd
, ieee_section_alignment_enum
)
2208 || ! ieee_write_byte (abfd
,
2209 (bfd_byte
) (s
->index
2210 + IEEE_SECTION_NUMBER_BASE
))
2211 || ! ieee_write_int (abfd
, 1 << s
->alignment_power
))
2215 if (! ieee_write_2bytes (abfd
, ieee_section_size_enum
)
2216 || ! ieee_write_byte (abfd
,
2217 (bfd_byte
) (s
->index
2218 + IEEE_SECTION_NUMBER_BASE
))
2219 || ! ieee_write_int (abfd
, s
->_raw_size
))
2221 if (abfd
->flags
& EXEC_P
)
2223 /* Relocateable sections don't have asl records */
2225 if (! ieee_write_2bytes (abfd
, ieee_section_base_address_enum
)
2226 || ! ieee_write_byte (abfd
,
2229 + IEEE_SECTION_NUMBER_BASE
)))
2230 || ! ieee_write_int (abfd
, s
->lma
))
2241 do_with_relocs (abfd
, s
)
2245 unsigned int number_of_maus_in_address
=
2246 bfd_arch_bits_per_address (abfd
) / bfd_arch_bits_per_byte (abfd
);
2247 unsigned int relocs_to_go
= s
->reloc_count
;
2248 bfd_byte
*stream
= ieee_per_section (s
)->data
;
2249 arelent
**p
= s
->orelocation
;
2250 bfd_size_type current_byte_index
= 0;
2252 qsort (s
->orelocation
,
2254 sizeof (arelent
**),
2257 /* Output the section preheader */
2258 if (! ieee_write_byte (abfd
, ieee_set_current_section_enum
)
2259 || ! ieee_write_byte (abfd
,
2260 (bfd_byte
) (s
->index
+ IEEE_SECTION_NUMBER_BASE
))
2261 || ! ieee_write_2bytes (abfd
, ieee_set_current_pc_enum
)
2262 || ! ieee_write_byte (abfd
,
2263 (bfd_byte
) (s
->index
+ IEEE_SECTION_NUMBER_BASE
)))
2265 if ((abfd
->flags
& EXEC_P
) != 0 && relocs_to_go
== 0)
2267 if (! ieee_write_int (abfd
, s
->lma
))
2272 if (! ieee_write_expression (abfd
, 0, s
->symbol
, 0, 0))
2276 if (relocs_to_go
== 0)
2278 /* If there aren't any relocations then output the load constant
2279 byte opcode rather than the load with relocation opcode */
2281 while (current_byte_index
< s
->_raw_size
)
2284 unsigned int MAXRUN
= 127;
2286 if (run
> s
->_raw_size
- current_byte_index
)
2288 run
= s
->_raw_size
- current_byte_index
;
2293 if (! ieee_write_byte (abfd
, ieee_load_constant_bytes_enum
))
2295 /* Output a stream of bytes */
2296 if (! ieee_write_int (abfd
, run
))
2298 if (bfd_write ((PTR
) (stream
+ current_byte_index
),
2304 current_byte_index
+= run
;
2310 if (! ieee_write_byte (abfd
, ieee_load_with_relocation_enum
))
2313 /* Output the data stream as the longest sequence of bytes
2314 possible, allowing for the a reasonable packet size and
2315 relocation stuffs. */
2317 if ((PTR
) stream
== (PTR
) NULL
)
2319 /* Outputting a section without data, fill it up */
2320 stream
= (unsigned char *) (bfd_alloc (abfd
, s
->_raw_size
));
2323 memset ((PTR
) stream
, 0, (size_t) s
->_raw_size
);
2325 while (current_byte_index
< s
->_raw_size
)
2328 unsigned int MAXRUN
= 127;
2331 run
= (*p
)->address
- current_byte_index
;
2339 if (run
> s
->_raw_size
- current_byte_index
)
2341 run
= s
->_raw_size
- current_byte_index
;
2346 /* Output a stream of bytes */
2347 if (! ieee_write_int (abfd
, run
))
2349 if (bfd_write ((PTR
) (stream
+ current_byte_index
),
2355 current_byte_index
+= run
;
2357 /* Output any relocations here */
2358 if (relocs_to_go
&& (*p
) && (*p
)->address
== current_byte_index
)
2361 && (*p
) && (*p
)->address
== current_byte_index
)
2367 if (r
->howto
->pc_relative
)
2369 r
->addend
+= current_byte_index
;
2373 switch (r
->howto
->size
)
2377 ov
= bfd_get_signed_32 (abfd
,
2378 stream
+ current_byte_index
);
2379 current_byte_index
+= 4;
2382 ov
= bfd_get_signed_16 (abfd
,
2383 stream
+ current_byte_index
);
2384 current_byte_index
+= 2;
2387 ov
= bfd_get_signed_8 (abfd
,
2388 stream
+ current_byte_index
);
2389 current_byte_index
++;
2397 ov
&= r
->howto
->src_mask
;
2399 if (r
->howto
->pc_relative
2400 && ! r
->howto
->pcrel_offset
)
2403 if (! ieee_write_byte (abfd
,
2404 ieee_function_either_open_b_enum
))
2409 if (r
->sym_ptr_ptr
!= (asymbol
**) NULL
)
2411 if (! ieee_write_expression (abfd
, r
->addend
+ ov
,
2413 r
->howto
->pc_relative
,
2419 if (! ieee_write_expression (abfd
, r
->addend
+ ov
,
2421 r
->howto
->pc_relative
,
2426 if (number_of_maus_in_address
2427 != bfd_get_reloc_size (r
->howto
))
2429 if (! ieee_write_int (abfd
,
2430 bfd_get_reloc_size (r
->howto
)))
2433 if (! ieee_write_byte (abfd
,
2434 ieee_function_either_close_b_enum
))
2448 /* If there are no relocations in the output section then we can be
2449 clever about how we write. We block items up into a max of 127
2453 do_as_repeat (abfd
, s
)
2459 if (! ieee_write_byte (abfd
, ieee_set_current_section_enum
)
2460 || ! ieee_write_byte (abfd
,
2461 (bfd_byte
) (s
->index
2462 + IEEE_SECTION_NUMBER_BASE
))
2463 || ! ieee_write_byte (abfd
, ieee_set_current_pc_enum
>> 8)
2464 || ! ieee_write_byte (abfd
, ieee_set_current_pc_enum
& 0xff)
2465 || ! ieee_write_byte (abfd
,
2466 (bfd_byte
) (s
->index
2467 + IEEE_SECTION_NUMBER_BASE
))
2468 || ! ieee_write_int (abfd
, s
->lma
)
2469 || ! ieee_write_byte (abfd
, ieee_repeat_data_enum
)
2470 || ! ieee_write_int (abfd
, s
->_raw_size
)
2471 || ! ieee_write_byte (abfd
, ieee_load_constant_bytes_enum
)
2472 || ! ieee_write_byte (abfd
, 1)
2473 || ! ieee_write_byte (abfd
, 0))
2481 do_without_relocs (abfd
, s
)
2485 bfd_byte
*stream
= ieee_per_section (s
)->data
;
2487 if (stream
== 0 || ((s
->flags
& SEC_LOAD
) == 0))
2489 if (! do_as_repeat (abfd
, s
))
2495 for (i
= 0; i
< s
->_raw_size
; i
++)
2499 if (! do_with_relocs (abfd
, s
))
2504 if (! do_as_repeat (abfd
, s
))
2512 static unsigned char *output_ptr_start
;
2513 static unsigned char *output_ptr
;
2514 static unsigned char *output_ptr_end
;
2515 static unsigned char *input_ptr_start
;
2516 static unsigned char *input_ptr
;
2517 static unsigned char *input_ptr_end
;
2518 static bfd
*input_bfd
;
2519 static bfd
*output_bfd
;
2520 static int output_buffer
;
2525 /* FIXME: Check return value. I'm not sure whether it needs to read
2526 the entire buffer or not. */
2527 bfd_read ((PTR
) input_ptr_start
, 1, input_ptr_end
- input_ptr_start
, input_bfd
);
2528 input_ptr
= input_ptr_start
;
2533 if (bfd_write ((PTR
) (output_ptr_start
), 1, output_ptr
- output_ptr_start
,
2535 != (bfd_size_type
) (output_ptr
- output_ptr_start
))
2537 output_ptr
= output_ptr_start
;
2541 #define THIS() ( *input_ptr )
2542 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
2543 #define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); }
2549 if (value
>= 0 && value
<= 127)
2555 unsigned int length
;
2556 /* How many significant bytes ? */
2557 /* FIXME FOR LONGER INTS */
2558 if (value
& 0xff000000)
2562 else if (value
& 0x00ff0000)
2566 else if (value
& 0x0000ff00)
2573 OUT ((int) ieee_number_repeat_start_enum
+ length
);
2592 int length
= THIS ();
2604 #define VAR(x) ((x | 0x80))
2619 value
= (value
<< 8) | THIS ();
2621 value
= (value
<< 8) | THIS ();
2623 value
= (value
<< 8) | THIS ();
2631 value
= (value
<< 8) | THIS ();
2633 value
= (value
<< 8) | THIS ();
2641 value
= (value
<< 8) | THIS ();
2658 /* Not a number, just bug out with the answer */
2659 write_int (*(--tos
));
2669 int value
= *(--tos
);
2678 ieee_data_type
*ieee
;
2681 section_number
= THIS ();
2684 ieee
= IEEE_DATA (input_bfd
);
2685 s
= ieee
->section_table
[section_number
];
2686 if (s
->output_section
)
2688 value
= s
->output_section
->lma
;
2694 value
+= s
->output_offset
;
2702 write_int (*(--tos
));
2712 /* Drop the int in the buffer, and copy a null into the gap, which we
2713 will overwrite later */
2715 struct output_buffer_struct
2717 unsigned char *ptrp
;
2723 struct output_buffer_struct
*buf
;
2725 if (buf
->buffer
== output_buffer
)
2727 /* Still a chance to output the size */
2728 int value
= output_ptr
- buf
->ptrp
+ 3;
2729 buf
->ptrp
[0] = value
>> 24;
2730 buf
->ptrp
[1] = value
>> 16;
2731 buf
->ptrp
[2] = value
>> 8;
2732 buf
->ptrp
[3] = value
>> 0;
2738 struct output_buffer_struct
*buf
;
2764 buf
->ptrp
= output_ptr
;
2765 buf
->buffer
= output_buffer
;
2805 #define ID copy_id()
2806 #define INT copy_int()
2807 #define EXP copy_expression()
2808 static void copy_till_end ();
2809 #define INTn(q) copy_int()
2810 #define EXPn(q) copy_expression()
2849 EXPn (instruction address
);
2883 EXPn (external function
);
2893 INTn (locked
register);
2916 /* Attribute record */
2974 static void block ();
2986 /* Unique typedefs for module */
2987 /* GLobal typedefs */
2988 /* High level module scope beginning */
2990 struct output_buffer_struct ob
;
3005 /* Global function */
3007 struct output_buffer_struct ob
;
3021 EXPn (size of block
);
3027 /* File name for source line numbers */
3029 struct output_buffer_struct ob
;
3049 /* Local function */
3051 struct output_buffer_struct ob
;
3069 /* Assembler module scope beginning -*/
3071 struct output_buffer_struct ob
;
3097 struct output_buffer_struct ob
;
3104 INTn (section index
);
3112 EXPn (Size in Maus
);
3167 moves all the debug information from the source bfd to the output
3168 bfd, and relocates any expressions it finds
3172 relocate_debug (output
, input
)
3173 bfd
*output ATTRIBUTE_UNUSED
;
3178 unsigned char input_buffer
[IBS
];
3180 input_ptr_start
= input_ptr
= input_buffer
;
3181 input_ptr_end
= input_buffer
+ IBS
;
3183 /* FIXME: Check return value. I'm not sure whether it needs to read
3184 the entire buffer or not. */
3185 bfd_read ((PTR
) input_ptr_start
, 1, IBS
, input
);
3190 During linking, we we told about the bfds which made up our
3191 contents, we have a list of them. They will still be open, so go to
3192 the debug info in each, and copy it out, relocating it as we go.
3196 ieee_write_debug_part (abfd
)
3199 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3200 bfd_chain_type
*chain
= ieee
->chain_root
;
3201 unsigned char output_buffer
[OBS
];
3202 boolean some_debug
= false;
3203 file_ptr here
= bfd_tell (abfd
);
3205 output_ptr_start
= output_ptr
= output_buffer
;
3206 output_ptr_end
= output_buffer
+ OBS
;
3207 output_ptr
= output_buffer
;
3210 if (chain
== (bfd_chain_type
*) NULL
)
3214 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3215 if ((s
->flags
& SEC_DEBUGGING
) != 0)
3219 ieee
->w
.r
.debug_information_part
= 0;
3223 ieee
->w
.r
.debug_information_part
= here
;
3224 if (bfd_write (s
->contents
, 1, s
->_raw_size
, abfd
) != s
->_raw_size
)
3229 while (chain
!= (bfd_chain_type
*) NULL
)
3231 bfd
*entry
= chain
->this;
3232 ieee_data_type
*entry_ieee
= IEEE_DATA (entry
);
3233 if (entry_ieee
->w
.r
.debug_information_part
)
3235 if (bfd_seek (entry
, entry_ieee
->w
.r
.debug_information_part
,
3239 relocate_debug (abfd
, entry
);
3242 chain
= chain
->next
;
3246 ieee
->w
.r
.debug_information_part
= here
;
3250 ieee
->w
.r
.debug_information_part
= 0;
3259 /* Write the data in an ieee way. */
3262 ieee_write_data_part (abfd
)
3266 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3267 ieee
->w
.r
.data_part
= bfd_tell (abfd
);
3268 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
3270 /* Skip sections that have no loadable contents (.bss,
3272 if ((s
->flags
& SEC_LOAD
) == 0)
3275 /* Sort the reloc records so we can insert them in the correct
3277 if (s
->reloc_count
!= 0)
3279 if (! do_with_relocs (abfd
, s
))
3284 if (! do_without_relocs (abfd
, s
))
3294 init_for_output (abfd
)
3298 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
3300 if ((s
->flags
& SEC_DEBUGGING
) != 0)
3302 if (s
->_raw_size
!= 0)
3304 ieee_per_section (s
)->data
= (bfd_byte
*) (bfd_alloc (abfd
, s
->_raw_size
));
3305 if (!ieee_per_section (s
)->data
)
3312 /** exec and core file sections */
3314 /* set section contents is complicated with IEEE since the format is
3315 * not a byte image, but a record stream.
3318 ieee_set_section_contents (abfd
, section
, location
, offset
, count
)
3323 bfd_size_type count
;
3325 if ((section
->flags
& SEC_DEBUGGING
) != 0)
3327 if (section
->contents
== NULL
)
3329 section
->contents
= ((unsigned char *)
3330 bfd_alloc (abfd
, section
->_raw_size
));
3331 if (section
->contents
== NULL
)
3334 /* bfd_set_section_contents has already checked that everything
3336 memcpy (section
->contents
+ offset
, location
, count
);
3340 if (ieee_per_section (section
)->data
== (bfd_byte
*) NULL
)
3342 if (!init_for_output (abfd
))
3345 memcpy ((PTR
) (ieee_per_section (section
)->data
+ offset
),
3347 (unsigned int) count
);
3351 /* Write the external symbols of a file. IEEE considers two sorts of
3352 external symbols, public, and referenced. It uses to internal
3353 forms to index them as well. When we write them out we turn their
3354 symbol values into indexes from the right base. */
3357 ieee_write_external_part (abfd
)
3361 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3363 unsigned int reference_index
= IEEE_REFERENCE_BASE
;
3364 unsigned int public_index
= IEEE_PUBLIC_BASE
+ 2;
3365 file_ptr here
= bfd_tell (abfd
);
3366 boolean hadone
= false;
3367 if (abfd
->outsymbols
!= (asymbol
**) NULL
)
3370 for (q
= abfd
->outsymbols
; *q
!= (asymbol
*) NULL
; q
++)
3373 if (bfd_is_und_section (p
->section
))
3375 /* This must be a symbol reference .. */
3376 if (! ieee_write_byte (abfd
, ieee_external_reference_enum
)
3377 || ! ieee_write_int (abfd
, reference_index
)
3378 || ! ieee_write_id (abfd
, p
->name
))
3380 p
->value
= reference_index
;
3384 else if (bfd_is_com_section (p
->section
))
3386 /* This is a weak reference */
3387 if (! ieee_write_byte (abfd
, ieee_external_reference_enum
)
3388 || ! ieee_write_int (abfd
, reference_index
)
3389 || ! ieee_write_id (abfd
, p
->name
)
3390 || ! ieee_write_byte (abfd
,
3391 ieee_weak_external_reference_enum
)
3392 || ! ieee_write_int (abfd
, reference_index
)
3393 || ! ieee_write_int (abfd
, p
->value
))
3395 p
->value
= reference_index
;
3399 else if (p
->flags
& BSF_GLOBAL
)
3401 /* This must be a symbol definition */
3403 if (! ieee_write_byte (abfd
, ieee_external_symbol_enum
)
3404 || ! ieee_write_int (abfd
, public_index
)
3405 || ! ieee_write_id (abfd
, p
->name
)
3406 || ! ieee_write_2bytes (abfd
, ieee_attribute_record_enum
)
3407 || ! ieee_write_int (abfd
, public_index
)
3408 || ! ieee_write_byte (abfd
, 15) /* instruction address */
3409 || ! ieee_write_byte (abfd
, 19) /* static symbol */
3410 || ! ieee_write_byte (abfd
, 1)) /* one of them */
3413 /* Write out the value */
3414 if (! ieee_write_2bytes (abfd
, ieee_value_record_enum
)
3415 || ! ieee_write_int (abfd
, public_index
))
3417 if (! bfd_is_abs_section (p
->section
))
3419 if (abfd
->flags
& EXEC_P
)
3421 /* If fully linked, then output all symbols
3423 if (! (ieee_write_int
3426 + p
->section
->output_offset
3427 + p
->section
->output_section
->vma
))))
3432 if (! (ieee_write_expression
3434 p
->value
+ p
->section
->output_offset
,
3435 p
->section
->output_section
->symbol
,
3442 if (! ieee_write_expression (abfd
,
3444 bfd_abs_section_ptr
->symbol
,
3448 p
->value
= public_index
;
3454 /* This can happen - when there are gaps in the symbols read */
3455 /* from an input ieee file */
3460 ieee
->w
.r
.external_part
= here
;
3466 static CONST
unsigned char exten
[] =
3469 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3 */
3470 0xf1, 0xce, 0x20, 0x00, 39, 2,/* keep symbol in original case */
3471 0xf1, 0xce, 0x20, 0x00, 38 /* set object type relocateable to x */
3474 static CONST
unsigned char envi
[] =
3478 /* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3481 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */
3483 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix */
3484 /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
3488 ieee_write_me_part (abfd
)
3491 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3492 ieee
->w
.r
.trailer_part
= bfd_tell (abfd
);
3493 if (abfd
->start_address
)
3495 if (! ieee_write_2bytes (abfd
, ieee_value_starting_address_enum
)
3496 || ! ieee_write_byte (abfd
, ieee_function_either_open_b_enum
)
3497 || ! ieee_write_int (abfd
, abfd
->start_address
)
3498 || ! ieee_write_byte (abfd
, ieee_function_either_close_b_enum
))
3501 ieee
->w
.r
.me_record
= bfd_tell (abfd
);
3502 if (! ieee_write_byte (abfd
, ieee_module_end_enum
))
3507 /* Write out the IEEE processor ID. */
3510 ieee_write_processor (abfd
)
3513 const bfd_arch_info_type
*arch
;
3515 arch
= bfd_get_arch_info (abfd
);
3519 if (! ieee_write_id (abfd
, bfd_printable_name (abfd
)))
3524 if (! ieee_write_id (abfd
, "29000"))
3528 case bfd_arch_h8300
:
3529 if (! ieee_write_id (abfd
, "H8/300"))
3533 case bfd_arch_h8500
:
3534 if (! ieee_write_id (abfd
, "H8/500"))
3542 case bfd_mach_i960_core
:
3543 case bfd_mach_i960_ka_sa
:
3544 if (! ieee_write_id (abfd
, "80960KA"))
3548 case bfd_mach_i960_kb_sb
:
3549 if (! ieee_write_id (abfd
, "80960KB"))
3553 case bfd_mach_i960_ca
:
3554 if (! ieee_write_id (abfd
, "80960CA"))
3558 case bfd_mach_i960_mc
:
3559 case bfd_mach_i960_xa
:
3560 if (! ieee_write_id (abfd
, "80960MC"))
3572 default: id
= "68020"; break;
3573 case bfd_mach_m68000
: id
= "68000"; break;
3574 case bfd_mach_m68008
: id
= "68008"; break;
3575 case bfd_mach_m68010
: id
= "68010"; break;
3576 case bfd_mach_m68020
: id
= "68020"; break;
3577 case bfd_mach_m68030
: id
= "68030"; break;
3578 case bfd_mach_m68040
: id
= "68040"; break;
3579 case bfd_mach_m68060
: id
= "68060"; break;
3580 case bfd_mach_cpu32
: id
= "cpu32"; break;
3583 if (! ieee_write_id (abfd
, id
))
3593 ieee_write_object_contents (abfd
)
3596 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3600 /* Fast forward over the header area */
3601 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3604 if (! ieee_write_byte (abfd
, ieee_module_beginning_enum
)
3605 || ! ieee_write_processor (abfd
)
3606 || ! ieee_write_id (abfd
, abfd
->filename
))
3609 /* Fast forward over the variable bits */
3610 if (! ieee_write_byte (abfd
, ieee_address_descriptor_enum
))
3614 if (! ieee_write_byte (abfd
, (bfd_byte
) (bfd_arch_bits_per_byte (abfd
))))
3616 /* MAU's per address */
3617 if (! ieee_write_byte (abfd
,
3618 (bfd_byte
) (bfd_arch_bits_per_address (abfd
)
3619 / bfd_arch_bits_per_byte (abfd
))))
3622 old
= bfd_tell (abfd
);
3623 if (bfd_seek (abfd
, (file_ptr
) (8 * N_W_VARIABLES
), SEEK_CUR
) != 0)
3626 ieee
->w
.r
.extension_record
= bfd_tell (abfd
);
3627 if (bfd_write ((char *) exten
, 1, sizeof (exten
), abfd
) != sizeof (exten
))
3629 if (abfd
->flags
& EXEC_P
)
3631 if (! ieee_write_byte (abfd
, 0x1)) /* Absolute */
3636 if (! ieee_write_byte (abfd
, 0x2)) /* Relocateable */
3640 ieee
->w
.r
.environmental_record
= bfd_tell (abfd
);
3641 if (bfd_write ((char *) envi
, 1, sizeof (envi
), abfd
) != sizeof (envi
))
3644 /* The HP emulator database requires a timestamp in the file. */
3650 t
= (struct tm
*) localtime (&now
);
3651 if (! ieee_write_2bytes (abfd
, (int) ieee_atn_record_enum
)
3652 || ! ieee_write_byte (abfd
, 0x21)
3653 || ! ieee_write_byte (abfd
, 0)
3654 || ! ieee_write_byte (abfd
, 50)
3655 || ! ieee_write_int (abfd
, t
->tm_year
+ 1900)
3656 || ! ieee_write_int (abfd
, t
->tm_mon
+ 1)
3657 || ! ieee_write_int (abfd
, t
->tm_mday
)
3658 || ! ieee_write_int (abfd
, t
->tm_hour
)
3659 || ! ieee_write_int (abfd
, t
->tm_min
)
3660 || ! ieee_write_int (abfd
, t
->tm_sec
))
3668 if (! ieee_write_section_part (abfd
))
3670 /* First write the symbols. This changes their values into table
3671 indeces so we cant use it after this point. */
3672 if (! ieee_write_external_part (abfd
))
3675 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3677 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3680 /* Write any debugs we have been told about. */
3681 if (! ieee_write_debug_part (abfd
))
3684 /* Can only write the data once the symbols have been written, since
3685 the data contains relocation information which points to the
3687 if (! ieee_write_data_part (abfd
))
3690 /* At the end we put the end! */
3691 if (! ieee_write_me_part (abfd
))
3694 /* Generate the header */
3695 if (bfd_seek (abfd
, old
, SEEK_SET
) != 0)
3698 for (i
= 0; i
< N_W_VARIABLES
; i
++)
3700 if (! ieee_write_2bytes (abfd
, ieee_assign_value_to_variable_enum
)
3701 || ! ieee_write_byte (abfd
, (bfd_byte
) i
)
3702 || ! ieee_write_int5_out (abfd
, ieee
->w
.offset
[i
]))
3709 /* Native-level interface to symbols. */
3711 /* We read the symbols into a buffer, which is discarded when this
3712 function exits. We read the strings into a buffer large enough to
3713 hold them all plus all the cached symbol entries. */
3716 ieee_make_empty_symbol (abfd
)
3719 ieee_symbol_type
*new =
3720 (ieee_symbol_type
*) bfd_zmalloc (sizeof (ieee_symbol_type
));
3723 new->symbol
.the_bfd
= abfd
;
3724 return &new->symbol
;
3728 ieee_openr_next_archived_file (arch
, prev
)
3732 ieee_ar_data_type
*ar
= IEEE_AR_DATA (arch
);
3733 /* take the next one from the arch state, or reset */
3734 if (prev
== (bfd
*) NULL
)
3736 /* Reset the index - the first two entries are bogus*/
3737 ar
->element_index
= 2;
3741 ieee_ar_obstack_type
*p
= ar
->elements
+ ar
->element_index
;
3742 ar
->element_index
++;
3743 if (ar
->element_index
<= ar
->element_count
)
3745 if (p
->file_offset
!= (file_ptr
) 0)
3747 if (p
->abfd
== (bfd
*) NULL
)
3749 p
->abfd
= _bfd_create_empty_archive_element_shell (arch
);
3750 p
->abfd
->origin
= p
->file_offset
;
3757 bfd_set_error (bfd_error_no_more_archived_files
);
3758 return (bfd
*) NULL
;
3765 ieee_find_nearest_line (abfd
,
3772 bfd
*abfd ATTRIBUTE_UNUSED
;
3773 asection
*section ATTRIBUTE_UNUSED
;
3774 asymbol
**symbols ATTRIBUTE_UNUSED
;
3775 bfd_vma offset ATTRIBUTE_UNUSED
;
3776 const char **filename_ptr ATTRIBUTE_UNUSED
;
3777 const char **functionname_ptr ATTRIBUTE_UNUSED
;
3778 unsigned int *line_ptr ATTRIBUTE_UNUSED
;
3784 ieee_generic_stat_arch_elt (abfd
, buf
)
3788 ieee_ar_data_type
*ar
= (ieee_ar_data_type
*) NULL
;
3789 ieee_data_type
*ieee
;
3791 if (abfd
->my_archive
!= NULL
)
3792 ar
= abfd
->my_archive
->tdata
.ieee_ar_data
;
3793 if (ar
== (ieee_ar_data_type
*) NULL
)
3795 bfd_set_error (bfd_error_invalid_operation
);
3799 if (IEEE_DATA (abfd
) == NULL
)
3801 if (ieee_object_p (abfd
) == NULL
)
3803 bfd_set_error (bfd_error_wrong_format
);
3808 ieee
= IEEE_DATA (abfd
);
3810 buf
->st_size
= ieee
->w
.r
.me_record
+ 1;
3811 buf
->st_mode
= 0644;
3816 ieee_sizeof_headers (abfd
, x
)
3817 bfd
*abfd ATTRIBUTE_UNUSED
;
3818 boolean x ATTRIBUTE_UNUSED
;
3824 /* The debug info routines are never used. */
3828 ieee_bfd_debug_info_start (abfd
)
3835 ieee_bfd_debug_info_end (abfd
)
3842 /* Add this section to the list of sections we have debug info for, to
3843 be ready to output it at close time
3846 ieee_bfd_debug_info_accumulate (abfd
, section
)
3850 ieee_data_type
*ieee
= IEEE_DATA (section
->owner
);
3851 ieee_data_type
*output_ieee
= IEEE_DATA (abfd
);
3852 /* can only accumulate data from other ieee bfds */
3853 if (section
->owner
->xvec
!= abfd
->xvec
)
3855 /* Only bother once per bfd */
3856 if (ieee
->done_debug
== true)
3858 ieee
->done_debug
= true;
3860 /* Don't bother if there is no debug info */
3861 if (ieee
->w
.r
.debug_information_part
== 0)
3867 bfd_chain_type
*n
= (bfd_chain_type
*) bfd_alloc (abfd
, sizeof (bfd_chain_type
));
3869 abort (); /* FIXME */
3870 n
->this = section
->owner
;
3871 n
->next
= (bfd_chain_type
*) NULL
;
3873 if (output_ieee
->chain_head
)
3875 output_ieee
->chain_head
->next
= n
;
3879 output_ieee
->chain_root
= n
;
3882 output_ieee
->chain_head
= n
;
3888 #define ieee_close_and_cleanup _bfd_generic_close_and_cleanup
3889 #define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3891 #define ieee_slurp_armap bfd_true
3892 #define ieee_slurp_extended_name_table bfd_true
3893 #define ieee_construct_extended_name_table \
3894 ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
3896 #define ieee_truncate_arname bfd_dont_truncate_arname
3897 #define ieee_write_armap \
3899 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
3901 #define ieee_read_ar_hdr bfd_nullvoidptr
3902 #define ieee_update_armap_timestamp bfd_true
3903 #define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
3905 #define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
3906 #define ieee_get_lineno _bfd_nosymbols_get_lineno
3907 #define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3908 #define ieee_read_minisymbols _bfd_generic_read_minisymbols
3909 #define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3911 #define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3913 #define ieee_set_arch_mach _bfd_generic_set_arch_mach
3915 #define ieee_get_section_contents_in_window \
3916 _bfd_generic_get_section_contents_in_window
3917 #define ieee_bfd_get_relocated_section_contents \
3918 bfd_generic_get_relocated_section_contents
3919 #define ieee_bfd_relax_section bfd_generic_relax_section
3920 #define ieee_bfd_gc_sections bfd_generic_gc_sections
3921 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3922 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
3923 #define ieee_bfd_final_link _bfd_generic_final_link
3924 #define ieee_bfd_link_split_section _bfd_generic_link_split_section
3927 const bfd_target ieee_vec
=
3930 bfd_target_ieee_flavour
,
3931 BFD_ENDIAN_UNKNOWN
, /* target byte order */
3932 BFD_ENDIAN_UNKNOWN
, /* target headers byte order */
3933 (HAS_RELOC
| EXEC_P
| /* object flags */
3934 HAS_LINENO
| HAS_DEBUG
|
3935 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
3936 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
3937 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
3938 '_', /* leading underscore */
3939 ' ', /* ar_pad_char */
3940 16, /* ar_max_namelen */
3941 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
3942 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
3943 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
3944 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
3945 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
3946 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
3949 ieee_object_p
, /* bfd_check_format */
3956 _bfd_generic_mkarchive
,
3961 ieee_write_object_contents
,
3962 _bfd_write_archive_contents
,
3966 BFD_JUMP_TABLE_GENERIC (ieee
),
3967 BFD_JUMP_TABLE_COPY (_bfd_generic
),
3968 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
3969 BFD_JUMP_TABLE_ARCHIVE (ieee
),
3970 BFD_JUMP_TABLE_SYMBOLS (ieee
),
3971 BFD_JUMP_TABLE_RELOCS (ieee
),
3972 BFD_JUMP_TABLE_WRITE (ieee
),
3973 BFD_JUMP_TABLE_LINK (ieee
),
3974 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),