1 /* BFD back-end for ieee-695 objects.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 1998
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
*
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
);
811 case ieee_value_record_enum
>> 8:
813 unsigned int symbol_name_index
;
814 ieee_symbol_index_type symbol_ignore
;
815 boolean pcrel_ignore
;
817 next_byte (&(ieee
->h
));
818 next_byte (&(ieee
->h
));
820 symbol_name_index
= must_parse_int (&(ieee
->h
));
821 parse_expression (ieee
,
822 &symbol
->symbol
.value
,
826 &symbol
->symbol
.section
);
828 symbol
->symbol
.flags
= BSF_GLOBAL
| BSF_EXPORT
;
832 case ieee_weak_external_reference_enum
:
836 next_byte (&(ieee
->h
));
837 /* Throw away the external reference index */
838 (void) must_parse_int (&(ieee
->h
));
839 /* Fetch the default size if not resolved */
840 size
= must_parse_int (&(ieee
->h
));
841 /* Fetch the defautlt value if available */
842 if (parse_int (&(ieee
->h
), &value
) == false)
846 /* This turns into a common */
847 symbol
->symbol
.section
= bfd_com_section_ptr
;
848 symbol
->symbol
.value
= size
;
852 case ieee_external_reference_enum
:
853 next_byte (&(ieee
->h
));
855 symbol
= get_symbol (abfd
, ieee
, symbol
, &symbol_count
,
857 &ieee
->external_reference_max_index
, 'X');
861 symbol
->symbol
.the_bfd
= abfd
;
862 symbol
->symbol
.name
= read_id (&(ieee
->h
));
863 symbol
->symbol
.udata
.p
= (PTR
) NULL
;
864 symbol
->symbol
.section
= bfd_und_section_ptr
;
865 symbol
->symbol
.value
= (bfd_vma
) 0;
866 symbol
->symbol
.flags
= 0;
868 BFD_ASSERT (symbol
->index
>= ieee
->external_reference_min_index
);
876 if (ieee
->external_symbol_max_index
!= 0)
878 ieee
->external_symbol_count
=
879 ieee
->external_symbol_max_index
-
880 ieee
->external_symbol_min_index
+ 1;
884 ieee
->external_symbol_count
= 0;
887 if (ieee
->external_reference_max_index
!= 0)
889 ieee
->external_reference_count
=
890 ieee
->external_reference_max_index
-
891 ieee
->external_reference_min_index
+ 1;
895 ieee
->external_reference_count
= 0;
899 ieee
->external_reference_count
+ ieee
->external_symbol_count
;
901 if (symbol_count
!= abfd
->symcount
)
903 /* There are gaps in the table -- */
904 ieee
->symbol_table_full
= false;
907 *prev_symbols_ptr
= (ieee_symbol_type
*) NULL
;
908 *prev_reference_ptr
= (ieee_symbol_type
*) NULL
;
914 ieee_slurp_symbol_table (abfd
)
917 if (IEEE_DATA (abfd
)->read_symbols
== false)
919 if (! ieee_slurp_external_symbols (abfd
))
921 IEEE_DATA (abfd
)->read_symbols
= true;
927 ieee_get_symtab_upper_bound (abfd
)
930 if (! ieee_slurp_symbol_table (abfd
))
933 return (abfd
->symcount
!= 0) ?
934 (abfd
->symcount
+ 1) * (sizeof (ieee_symbol_type
*)) : 0;
938 Move from our internal lists to the canon table, and insert in
942 extern const bfd_target ieee_vec
;
945 ieee_get_symtab (abfd
, location
)
949 ieee_symbol_type
*symp
;
950 static bfd dummy_bfd
;
951 static asymbol empty_symbol
=
952 /* the_bfd, name, value, attr, section */
953 {&dummy_bfd
, " ieee empty", (symvalue
) 0, BSF_DEBUGGING
, bfd_abs_section_ptr
};
957 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
958 dummy_bfd
.xvec
= &ieee_vec
;
959 if (! ieee_slurp_symbol_table (abfd
))
962 if (ieee
->symbol_table_full
== false)
964 /* Arrgh - there are gaps in the table, run through and fill them */
965 /* up with pointers to a null place */
967 for (i
= 0; i
< abfd
->symcount
; i
++)
969 location
[i
] = &empty_symbol
;
973 ieee
->external_symbol_base_offset
= -ieee
->external_symbol_min_index
;
974 for (symp
= IEEE_DATA (abfd
)->external_symbols
;
975 symp
!= (ieee_symbol_type
*) NULL
;
978 /* Place into table at correct index locations */
979 location
[symp
->index
+ ieee
->external_symbol_base_offset
] = &symp
->symbol
;
982 /* The external refs are indexed in a bit */
983 ieee
->external_reference_base_offset
=
984 -ieee
->external_reference_min_index
+ ieee
->external_symbol_count
;
986 for (symp
= IEEE_DATA (abfd
)->external_reference
;
987 symp
!= (ieee_symbol_type
*) NULL
;
990 location
[symp
->index
+ ieee
->external_reference_base_offset
] =
997 location
[abfd
->symcount
] = (asymbol
*) NULL
;
999 return abfd
->symcount
;
1003 get_section_entry (abfd
, ieee
, index
)
1005 ieee_data_type
*ieee
;
1008 if (index
>= ieee
->section_table_size
)
1013 c
= ieee
->section_table_size
;
1020 bfd_realloc (ieee
->section_table
, c
* sizeof (asection
*)));
1024 for (i
= ieee
->section_table_size
; i
< c
; i
++)
1027 ieee
->section_table
= n
;
1028 ieee
->section_table_size
= c
;
1031 if (ieee
->section_table
[index
] == (asection
*) NULL
)
1033 char *tmp
= bfd_alloc (abfd
, 11);
1038 sprintf (tmp
, " fsec%4d", index
);
1039 section
= bfd_make_section (abfd
, tmp
);
1040 ieee
->section_table
[index
] = section
;
1041 section
->flags
= SEC_NO_FLAGS
;
1042 section
->target_index
= index
;
1043 ieee
->section_table
[index
] = section
;
1045 return ieee
->section_table
[index
];
1049 ieee_slurp_sections (abfd
)
1052 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
1053 file_ptr offset
= ieee
->w
.r
.section_part
;
1054 asection
*section
= (asection
*) NULL
;
1059 bfd_byte section_type
[3];
1060 ieee_seek (abfd
, offset
);
1063 switch (this_byte (&(ieee
->h
)))
1065 case ieee_section_type_enum
:
1067 unsigned int section_index
;
1068 next_byte (&(ieee
->h
));
1069 section_index
= must_parse_int (&(ieee
->h
));
1071 section
= get_section_entry (abfd
, ieee
, section_index
);
1073 section_type
[0] = this_byte_and_next (&(ieee
->h
));
1075 /* Set minimal section attributes. Attributes are
1076 extended later, based on section contents. */
1078 switch (section_type
[0])
1081 /* Normal attributes for absolute sections */
1082 section_type
[1] = this_byte (&(ieee
->h
));
1083 section
->flags
= SEC_ALLOC
;
1084 switch (section_type
[1])
1086 case 0xD3: /* AS Absolute section attributes */
1087 next_byte (&(ieee
->h
));
1088 section_type
[2] = this_byte (&(ieee
->h
));
1089 switch (section_type
[2])
1093 next_byte (&(ieee
->h
));
1094 section
->flags
|= SEC_CODE
;
1098 next_byte (&(ieee
->h
));
1099 section
->flags
|= SEC_DATA
;
1102 next_byte (&(ieee
->h
));
1103 /* Normal rom data */
1104 section
->flags
|= SEC_ROM
| SEC_DATA
;
1111 case 0xC3: /* Named relocatable sections (type C) */
1112 section_type
[1] = this_byte (&(ieee
->h
));
1113 section
->flags
= SEC_ALLOC
;
1114 switch (section_type
[1])
1116 case 0xD0: /* Normal code (CP) */
1117 next_byte (&(ieee
->h
));
1118 section
->flags
|= SEC_CODE
;
1120 case 0xC4: /* Normal data (CD) */
1121 next_byte (&(ieee
->h
));
1122 section
->flags
|= SEC_DATA
;
1124 case 0xD2: /* Normal rom data (CR) */
1125 next_byte (&(ieee
->h
));
1126 section
->flags
|= SEC_ROM
| SEC_DATA
;
1133 /* Read section name, use it if non empty. */
1134 name
= read_id (&ieee
->h
);
1136 section
->name
= name
;
1138 /* Skip these fields, which we don't care about */
1140 bfd_vma parent
, brother
, context
;
1141 parse_int (&(ieee
->h
), &parent
);
1142 parse_int (&(ieee
->h
), &brother
);
1143 parse_int (&(ieee
->h
), &context
);
1147 case ieee_section_alignment_enum
:
1149 unsigned int section_index
;
1152 next_byte (&(ieee
->h
));
1153 section_index
= must_parse_int (&ieee
->h
);
1154 section
= get_section_entry (abfd
, ieee
, section_index
);
1155 if (section_index
> ieee
->section_count
)
1157 ieee
->section_count
= section_index
;
1159 section
->alignment_power
=
1160 bfd_log2 (must_parse_int (&ieee
->h
));
1161 (void) parse_int (&(ieee
->h
), &value
);
1164 case ieee_e2_first_byte_enum
:
1166 ieee_record_enum_type t
= (ieee_record_enum_type
) (read_2bytes (&(ieee
->h
)));
1170 case ieee_section_size_enum
:
1171 section
= ieee
->section_table
[must_parse_int (&(ieee
->h
))];
1172 section
->_raw_size
= must_parse_int (&(ieee
->h
));
1174 case ieee_physical_region_size_enum
:
1175 section
= ieee
->section_table
[must_parse_int (&(ieee
->h
))];
1176 section
->_raw_size
= must_parse_int (&(ieee
->h
));
1178 case ieee_region_base_address_enum
:
1179 section
= ieee
->section_table
[must_parse_int (&(ieee
->h
))];
1180 section
->vma
= must_parse_int (&(ieee
->h
));
1181 section
->lma
= section
->vma
;
1183 case ieee_mau_size_enum
:
1184 must_parse_int (&(ieee
->h
));
1185 must_parse_int (&(ieee
->h
));
1187 case ieee_m_value_enum
:
1188 must_parse_int (&(ieee
->h
));
1189 must_parse_int (&(ieee
->h
));
1191 case ieee_section_base_address_enum
:
1192 section
= ieee
->section_table
[must_parse_int (&(ieee
->h
))];
1193 section
->vma
= must_parse_int (&(ieee
->h
));
1194 section
->lma
= section
->vma
;
1196 case ieee_section_offset_enum
:
1197 (void) must_parse_int (&(ieee
->h
));
1198 (void) must_parse_int (&(ieee
->h
));
1212 /* Make a section for the debugging information, if any. We don't try
1213 to interpret the debugging information; we just point the section
1214 at the area in the file so that program which understand can dig it
1218 ieee_slurp_debug (abfd
)
1221 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
1224 if (ieee
->w
.r
.debug_information_part
== 0)
1227 sec
= bfd_make_section (abfd
, ".debug");
1230 sec
->flags
|= SEC_DEBUGGING
| SEC_HAS_CONTENTS
;
1231 sec
->filepos
= ieee
->w
.r
.debug_information_part
;
1232 sec
->_raw_size
= ieee
->w
.r
.data_part
- ieee
->w
.r
.debug_information_part
;
1237 /***********************************************************************
1242 ieee_archive_p (abfd
)
1247 unsigned char buffer
[512];
1248 file_ptr buffer_offset
= 0;
1249 ieee_ar_data_type
*save
= abfd
->tdata
.ieee_ar_data
;
1250 ieee_ar_data_type
*ieee
;
1251 unsigned int alc_elts
;
1252 ieee_ar_obstack_type
*elts
= NULL
;
1254 abfd
->tdata
.ieee_ar_data
=
1255 (ieee_ar_data_type
*) bfd_alloc (abfd
, sizeof (ieee_ar_data_type
));
1256 if (!abfd
->tdata
.ieee_ar_data
)
1258 ieee
= IEEE_AR_DATA (abfd
);
1260 /* FIXME: Check return value. I'm not sure whether it needs to read
1261 the entire buffer or not. */
1262 bfd_read ((PTR
) buffer
, 1, sizeof (buffer
), abfd
);
1264 ieee
->h
.first_byte
= buffer
;
1265 ieee
->h
.input_p
= buffer
;
1267 ieee
->h
.abfd
= abfd
;
1269 if (this_byte (&(ieee
->h
)) != Module_Beginning
)
1271 abfd
->tdata
.ieee_ar_data
= save
;
1275 next_byte (&(ieee
->h
));
1276 library
= read_id (&(ieee
->h
));
1277 if (strcmp (library
, "LIBRARY") != 0)
1279 bfd_release (abfd
, ieee
);
1280 abfd
->tdata
.ieee_ar_data
= save
;
1283 /* Throw away the filename */
1284 read_id (&(ieee
->h
));
1286 ieee
->element_count
= 0;
1287 ieee
->element_index
= 0;
1289 next_byte (&(ieee
->h
)); /* Drop the ad part */
1290 must_parse_int (&(ieee
->h
)); /* And the two dummy numbers */
1291 must_parse_int (&(ieee
->h
));
1294 elts
= (ieee_ar_obstack_type
*) bfd_malloc (alc_elts
* sizeof *elts
);
1298 /* Read the index of the BB table */
1302 ieee_ar_obstack_type
*t
;
1304 rec
= read_2bytes (&(ieee
->h
));
1305 if (rec
!= (int) ieee_assign_value_to_variable_enum
)
1308 if (ieee
->element_count
>= alc_elts
)
1310 ieee_ar_obstack_type
*n
;
1313 n
= ((ieee_ar_obstack_type
*)
1314 bfd_realloc (elts
, alc_elts
* sizeof *elts
));
1320 t
= &elts
[ieee
->element_count
];
1321 ieee
->element_count
++;
1323 must_parse_int (&(ieee
->h
));
1324 t
->file_offset
= must_parse_int (&(ieee
->h
));
1325 t
->abfd
= (bfd
*) NULL
;
1327 /* Make sure that we don't go over the end of the buffer */
1329 if ((size_t) ieee_pos (abfd
) > sizeof (buffer
) / 2)
1331 /* Past half way, reseek and reprime */
1332 buffer_offset
+= ieee_pos (abfd
);
1333 if (bfd_seek (abfd
, buffer_offset
, SEEK_SET
) != 0)
1335 /* FIXME: Check return value. I'm not sure whether it needs
1336 to read the entire buffer or not. */
1337 bfd_read ((PTR
) buffer
, 1, sizeof (buffer
), abfd
);
1338 ieee
->h
.first_byte
= buffer
;
1339 ieee
->h
.input_p
= buffer
;
1343 ieee
->elements
= ((ieee_ar_obstack_type
*)
1345 ieee
->element_count
* sizeof *ieee
->elements
));
1346 if (ieee
->elements
== NULL
)
1348 memcpy (ieee
->elements
, elts
,
1349 ieee
->element_count
* sizeof *ieee
->elements
);
1353 /* Now scan the area again, and replace BB offsets with file */
1356 for (i
= 2; i
< ieee
->element_count
; i
++)
1358 if (bfd_seek (abfd
, ieee
->elements
[i
].file_offset
, SEEK_SET
) != 0)
1360 /* FIXME: Check return value. I'm not sure whether it needs to
1361 read the entire buffer or not. */
1362 bfd_read ((PTR
) buffer
, 1, sizeof (buffer
), abfd
);
1363 ieee
->h
.first_byte
= buffer
;
1364 ieee
->h
.input_p
= buffer
;
1366 next_byte (&(ieee
->h
)); /* Drop F8 */
1367 next_byte (&(ieee
->h
)); /* Drop 14 */
1368 must_parse_int (&(ieee
->h
)); /* Drop size of block */
1369 if (must_parse_int (&(ieee
->h
)) != 0)
1371 /* This object has been deleted */
1372 ieee
->elements
[i
].file_offset
= 0;
1376 ieee
->elements
[i
].file_offset
= must_parse_int (&(ieee
->h
));
1380 /* abfd->has_armap = ;*/
1391 ieee_mkobject (abfd
)
1394 abfd
->tdata
.ieee_data
= (ieee_data_type
*) bfd_zalloc (abfd
, sizeof (ieee_data_type
));
1395 return abfd
->tdata
.ieee_data
? true : false;
1399 ieee_object_p (abfd
)
1404 ieee_data_type
*ieee
;
1405 unsigned char buffer
[300];
1406 ieee_data_type
*save
= IEEE_DATA (abfd
);
1408 abfd
->tdata
.ieee_data
= 0;
1409 ieee_mkobject (abfd
);
1411 ieee
= IEEE_DATA (abfd
);
1412 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
1414 /* Read the first few bytes in to see if it makes sense */
1415 /* FIXME: Check return value. I'm not sure whether it needs to read
1416 the entire buffer or not. */
1417 bfd_read ((PTR
) buffer
, 1, sizeof (buffer
), abfd
);
1419 ieee
->h
.input_p
= buffer
;
1420 if (this_byte_and_next (&(ieee
->h
)) != Module_Beginning
)
1421 goto got_wrong_format
;
1423 ieee
->read_symbols
= false;
1424 ieee
->read_data
= false;
1425 ieee
->section_count
= 0;
1426 ieee
->external_symbol_max_index
= 0;
1427 ieee
->external_symbol_min_index
= IEEE_PUBLIC_BASE
;
1428 ieee
->external_reference_min_index
= IEEE_REFERENCE_BASE
;
1429 ieee
->external_reference_max_index
= 0;
1430 ieee
->h
.abfd
= abfd
;
1431 ieee
->section_table
= NULL
;
1432 ieee
->section_table_size
= 0;
1434 processor
= ieee
->mb
.processor
= read_id (&(ieee
->h
));
1435 if (strcmp (processor
, "LIBRARY") == 0)
1436 goto got_wrong_format
;
1437 ieee
->mb
.module_name
= read_id (&(ieee
->h
));
1438 if (abfd
->filename
== (CONST
char *) NULL
)
1440 abfd
->filename
= ieee
->mb
.module_name
;
1442 /* Determine the architecture and machine type of the object file.
1445 const bfd_arch_info_type
*arch
;
1448 /* IEEE does not specify the format of the processor identificaton
1449 string, so the compiler is free to put in it whatever it wants.
1450 We try here to recognize different processors belonging to the
1451 m68k family. Code for other processors can be added here. */
1452 if ((processor
[0] == '6') && (processor
[1] == '8'))
1454 if (processor
[2] == '3') /* 683xx integrated processors */
1456 switch (processor
[3])
1458 case '0': /* 68302, 68306, 68307 */
1459 case '2': /* 68322, 68328 */
1460 case '5': /* 68356 */
1461 strcpy (family
, "68000"); /* MC68000-based controllers */
1464 case '3': /* 68330, 68331, 68332, 68333,
1465 68334, 68335, 68336, 68338 */
1466 case '6': /* 68360 */
1467 case '7': /* 68376 */
1468 strcpy (family
, "68332"); /* CPU32 and CPU32+ */
1472 if (processor
[4] == '9') /* 68349 */
1473 strcpy (family
, "68030"); /* CPU030 */
1474 else /* 68340, 68341 */
1475 strcpy (family
, "68332"); /* CPU32 and CPU32+ */
1478 default: /* Does not exist yet */
1479 strcpy (family
, "68332"); /* Guess it will be CPU32 */
1482 else if (toupper (processor
[3]) == 'F') /* 68F333 */
1483 strcpy (family
, "68332"); /* CPU32 */
1484 else if ((toupper (processor
[3]) == 'C') /* Embedded controllers */
1485 && ((toupper (processor
[2]) == 'E')
1486 || (toupper (processor
[2]) == 'H')
1487 || (toupper (processor
[2]) == 'L')))
1489 strcpy (family
, "68");
1490 strncat (family
, processor
+ 4, 7);
1493 else /* "Regular" processors */
1495 strncpy (family
, processor
, 9);
1499 else if ((strncmp (processor
, "cpu32", 5) == 0) /* CPU32 and CPU32+ */
1500 || (strncmp (processor
, "CPU32", 5) == 0))
1501 strcpy (family
, "68332");
1504 strncpy (family
, processor
, 9);
1508 arch
= bfd_scan_arch (family
);
1510 goto got_wrong_format
;
1511 abfd
->arch_info
= arch
;
1514 if (this_byte (&(ieee
->h
)) != (int) ieee_address_descriptor_enum
)
1518 next_byte (&(ieee
->h
));
1520 if (parse_int (&(ieee
->h
), &ieee
->ad
.number_of_bits_mau
) == false)
1524 if (parse_int (&(ieee
->h
), &ieee
->ad
.number_of_maus_in_address
) == false)
1529 /* If there is a byte order info, take it */
1530 if (this_byte (&(ieee
->h
)) == (int) ieee_variable_L_enum
||
1531 this_byte (&(ieee
->h
)) == (int) ieee_variable_M_enum
)
1532 next_byte (&(ieee
->h
));
1534 for (part
= 0; part
< N_W_VARIABLES
; part
++)
1537 if (read_2bytes (&(ieee
->h
)) != (int) ieee_assign_value_to_variable_enum
)
1541 if (this_byte_and_next (&(ieee
->h
)) != part
)
1546 ieee
->w
.offset
[part
] = parse_i (&(ieee
->h
), &ok
);
1554 if (ieee
->w
.r
.external_part
!= 0)
1555 abfd
->flags
= HAS_SYMS
;
1557 /* By now we know that this is a real IEEE file, we're going to read
1558 the whole thing into memory so that we can run up and down it
1559 quickly. We can work out how big the file is from the trailer
1562 IEEE_DATA (abfd
)->h
.first_byte
=
1563 (unsigned char *) bfd_alloc (ieee
->h
.abfd
, ieee
->w
.r
.me_record
+ 1);
1564 if (!IEEE_DATA (abfd
)->h
.first_byte
)
1566 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
1568 /* FIXME: Check return value. I'm not sure whether it needs to read
1569 the entire buffer or not. */
1570 bfd_read ((PTR
) (IEEE_DATA (abfd
)->h
.first_byte
), 1,
1571 ieee
->w
.r
.me_record
+ 1, abfd
);
1573 ieee_slurp_sections (abfd
);
1575 if (! ieee_slurp_debug (abfd
))
1578 /* Parse section data to activate file and section flags implied by
1579 section contents. */
1581 if (! ieee_slurp_section_data (abfd
))
1586 bfd_set_error (bfd_error_wrong_format
);
1588 (void) bfd_release (abfd
, ieee
);
1589 abfd
->tdata
.ieee_data
= save
;
1590 return (const bfd_target
*) NULL
;
1594 ieee_get_symbol_info (ignore_abfd
, symbol
, ret
)
1599 bfd_symbol_info (symbol
, ret
);
1600 if (symbol
->name
[0] == ' ')
1601 ret
->name
= "* empty table entry ";
1602 if (!symbol
->section
)
1603 ret
->type
= (symbol
->flags
& BSF_LOCAL
) ? 'a' : 'A';
1607 ieee_print_symbol (ignore_abfd
, afile
, symbol
, how
)
1611 bfd_print_symbol_type how
;
1613 FILE *file
= (FILE *) afile
;
1617 case bfd_print_symbol_name
:
1618 fprintf (file
, "%s", symbol
->name
);
1620 case bfd_print_symbol_more
:
1622 fprintf (file
, "%4x %2x", aout_symbol (symbol
)->desc
& 0xffff,
1623 aout_symbol (symbol
)->other
& 0xff);
1627 case bfd_print_symbol_all
:
1629 const char *section_name
=
1630 (symbol
->section
== (asection
*) NULL
1632 : symbol
->section
->name
);
1633 if (symbol
->name
[0] == ' ')
1635 fprintf (file
, "* empty table entry ");
1639 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
1641 fprintf (file
, " %-5s %04x %02x %s",
1643 (unsigned) ieee_symbol (symbol
)->index
,
1653 do_one (ieee
, current_map
, location_ptr
, s
, iterations
)
1654 ieee_data_type
*ieee
;
1655 ieee_per_section_type
*current_map
;
1656 unsigned char *location_ptr
;
1660 switch (this_byte (&(ieee
->h
)))
1662 case ieee_load_constant_bytes_enum
:
1664 unsigned int number_of_maus
;
1666 next_byte (&(ieee
->h
));
1667 number_of_maus
= must_parse_int (&(ieee
->h
));
1669 for (i
= 0; i
< number_of_maus
; i
++)
1671 location_ptr
[current_map
->pc
++] = this_byte (&(ieee
->h
));
1672 next_byte (&(ieee
->h
));
1677 case ieee_load_with_relocation_enum
:
1679 boolean loop
= true;
1680 next_byte (&(ieee
->h
));
1683 switch (this_byte (&(ieee
->h
)))
1685 case ieee_variable_R_enum
:
1687 case ieee_function_signed_open_b_enum
:
1688 case ieee_function_unsigned_open_b_enum
:
1689 case ieee_function_either_open_b_enum
:
1691 unsigned int extra
= 4;
1692 boolean pcrel
= false;
1694 ieee_reloc_type
*r
=
1695 (ieee_reloc_type
*) bfd_alloc (ieee
->h
.abfd
,
1696 sizeof (ieee_reloc_type
));
1700 *(current_map
->reloc_tail_ptr
) = r
;
1701 current_map
->reloc_tail_ptr
= &r
->next
;
1702 r
->next
= (ieee_reloc_type
*) NULL
;
1703 next_byte (&(ieee
->h
));
1705 r
->relent
.sym_ptr_ptr
= 0;
1706 parse_expression (ieee
,
1709 &pcrel
, &extra
, §ion
);
1710 r
->relent
.address
= current_map
->pc
;
1711 s
->flags
|= SEC_RELOC
;
1712 s
->owner
->flags
|= HAS_RELOC
;
1714 if (r
->relent
.sym_ptr_ptr
== NULL
&& section
!= NULL
)
1715 r
->relent
.sym_ptr_ptr
= section
->symbol_ptr_ptr
;
1717 if (this_byte (&(ieee
->h
)) == (int) ieee_comma
)
1719 next_byte (&(ieee
->h
));
1720 /* Fetch number of bytes to pad */
1721 extra
= must_parse_int (&(ieee
->h
));
1724 switch (this_byte (&(ieee
->h
)))
1726 case ieee_function_signed_close_b_enum
:
1727 next_byte (&(ieee
->h
));
1729 case ieee_function_unsigned_close_b_enum
:
1730 next_byte (&(ieee
->h
));
1732 case ieee_function_either_close_b_enum
:
1733 next_byte (&(ieee
->h
));
1738 /* Build a relocation entry for this type */
1739 /* If pc rel then stick -ve pc into instruction
1740 and take out of reloc ..
1742 I've changed this. It's all too complicated. I
1743 keep 0 in the instruction now. */
1752 #if KEEPMINUSPCININST
1753 bfd_put_32 (ieee
->h
.abfd
, -current_map
->pc
, location_ptr
+
1755 r
->relent
.howto
= &rel32_howto
;
1759 bfd_put_32 (ieee
->h
.abfd
, 0, location_ptr
+
1761 r
->relent
.howto
= &rel32_howto
;
1766 bfd_put_32 (ieee
->h
.abfd
, 0, location_ptr
+
1768 r
->relent
.howto
= &abs32_howto
;
1770 current_map
->pc
+= 4;
1775 #if KEEPMINUSPCININST
1776 bfd_put_16 (ieee
->h
.abfd
, (int) (-current_map
->pc
), location_ptr
+ current_map
->pc
);
1777 r
->relent
.addend
-= current_map
->pc
;
1778 r
->relent
.howto
= &rel16_howto
;
1781 bfd_put_16 (ieee
->h
.abfd
, 0, location_ptr
+ current_map
->pc
);
1782 r
->relent
.howto
= &rel16_howto
;
1788 bfd_put_16 (ieee
->h
.abfd
, 0, location_ptr
+ current_map
->pc
);
1789 r
->relent
.howto
= &abs16_howto
;
1791 current_map
->pc
+= 2;
1796 #if KEEPMINUSPCININST
1797 bfd_put_8 (ieee
->h
.abfd
, (int) (-current_map
->pc
), location_ptr
+ current_map
->pc
);
1798 r
->relent
.addend
-= current_map
->pc
;
1799 r
->relent
.howto
= &rel8_howto
;
1801 bfd_put_8 (ieee
->h
.abfd
, 0, location_ptr
+ current_map
->pc
);
1802 r
->relent
.howto
= &rel8_howto
;
1807 bfd_put_8 (ieee
->h
.abfd
, 0, location_ptr
+ current_map
->pc
);
1808 r
->relent
.howto
= &abs8_howto
;
1810 current_map
->pc
+= 1;
1822 if (parse_int (&(ieee
->h
), &this_size
) == true)
1825 for (i
= 0; i
< this_size
; i
++)
1827 location_ptr
[current_map
->pc
++] = this_byte (&(ieee
->h
));
1828 next_byte (&(ieee
->h
));
1838 /* Prevent more than the first load-item of an LR record
1839 from being repeated (MRI convention). */
1840 if (iterations
!= 1)
1848 /* Read in all the section data and relocation stuff too */
1850 ieee_slurp_section_data (abfd
)
1853 bfd_byte
*location_ptr
= (bfd_byte
*) NULL
;
1854 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
1855 unsigned int section_number
;
1857 ieee_per_section_type
*current_map
= (ieee_per_section_type
*) NULL
;
1859 /* Seek to the start of the data area */
1860 if (ieee
->read_data
== true)
1862 ieee
->read_data
= true;
1863 ieee_seek (abfd
, ieee
->w
.r
.data_part
);
1865 /* Allocate enough space for all the section contents */
1867 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1869 ieee_per_section_type
*per
= (ieee_per_section_type
*) s
->used_by_bfd
;
1870 if ((s
->flags
& SEC_DEBUGGING
) != 0)
1872 per
->data
= (bfd_byte
*) bfd_alloc (ieee
->h
.abfd
, s
->_raw_size
);
1876 per
->reloc_tail_ptr
=
1877 (ieee_reloc_type
**) & (s
->relocation
);
1882 switch (this_byte (&(ieee
->h
)))
1884 /* IF we see anything strange then quit */
1888 case ieee_set_current_section_enum
:
1889 next_byte (&(ieee
->h
));
1890 section_number
= must_parse_int (&(ieee
->h
));
1891 s
= ieee
->section_table
[section_number
];
1892 s
->flags
|= SEC_LOAD
| SEC_HAS_CONTENTS
;
1893 current_map
= (ieee_per_section_type
*) s
->used_by_bfd
;
1894 location_ptr
= current_map
->data
- s
->vma
;
1895 /* The document I have says that Microtec's compilers reset */
1896 /* this after a sec section, even though the standard says not */
1898 current_map
->pc
= s
->vma
;
1901 case ieee_e2_first_byte_enum
:
1902 next_byte (&(ieee
->h
));
1903 switch (this_byte (&(ieee
->h
)))
1905 case ieee_set_current_pc_enum
& 0xff:
1908 ieee_symbol_index_type symbol
;
1911 next_byte (&(ieee
->h
));
1912 must_parse_int (&(ieee
->h
)); /* Thow away section #*/
1913 parse_expression (ieee
, &value
,
1917 current_map
->pc
= value
;
1918 BFD_ASSERT ((unsigned) (value
- s
->vma
) <= s
->_raw_size
);
1922 case ieee_value_starting_address_enum
& 0xff:
1923 next_byte (&(ieee
->h
));
1924 if (this_byte (&(ieee
->h
)) == ieee_function_either_open_b_enum
)
1925 next_byte (&(ieee
->h
));
1926 abfd
->start_address
= must_parse_int (&(ieee
->h
));
1927 /* We've got to the end of the data now - */
1934 case ieee_repeat_data_enum
:
1936 /* Repeat the following LD or LR n times - we do this by
1937 remembering the stream pointer before running it and
1938 resetting it and running it n times. We special case
1939 the repetition of a repeat_data/load_constant
1942 unsigned int iterations
;
1943 unsigned char *start
;
1944 next_byte (&(ieee
->h
));
1945 iterations
= must_parse_int (&(ieee
->h
));
1946 start
= ieee
->h
.input_p
;
1947 if (start
[0] == (int) ieee_load_constant_bytes_enum
&&
1950 while (iterations
!= 0)
1952 location_ptr
[current_map
->pc
++] = start
[2];
1955 next_byte (&(ieee
->h
));
1956 next_byte (&(ieee
->h
));
1957 next_byte (&(ieee
->h
));
1961 while (iterations
!= 0)
1963 ieee
->h
.input_p
= start
;
1964 if (!do_one (ieee
, current_map
, location_ptr
, s
,
1972 case ieee_load_constant_bytes_enum
:
1973 case ieee_load_with_relocation_enum
:
1975 if (!do_one (ieee
, current_map
, location_ptr
, s
, 1))
1983 ieee_new_section_hook (abfd
, newsect
)
1987 newsect
->used_by_bfd
= (PTR
)
1988 bfd_alloc (abfd
, sizeof (ieee_per_section_type
));
1989 if (!newsect
->used_by_bfd
)
1991 ieee_per_section (newsect
)->data
= (bfd_byte
*) NULL
;
1992 ieee_per_section (newsect
)->section
= newsect
;
1997 ieee_get_reloc_upper_bound (abfd
, asect
)
2001 if ((asect
->flags
& SEC_DEBUGGING
) != 0)
2003 if (! ieee_slurp_section_data (abfd
))
2005 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2009 ieee_get_section_contents (abfd
, section
, location
, offset
, count
)
2014 bfd_size_type count
;
2016 ieee_per_section_type
*p
= (ieee_per_section_type
*) section
->used_by_bfd
;
2017 if ((section
->flags
& SEC_DEBUGGING
) != 0)
2018 return _bfd_generic_get_section_contents (abfd
, section
, location
,
2020 ieee_slurp_section_data (abfd
);
2021 (void) memcpy ((PTR
) location
, (PTR
) (p
->data
+ offset
), (unsigned) count
);
2026 ieee_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2032 /* ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
2033 ieee_reloc_type
*src
= (ieee_reloc_type
*) (section
->relocation
);
2034 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
2036 if ((section
->flags
& SEC_DEBUGGING
) != 0)
2039 while (src
!= (ieee_reloc_type
*) NULL
)
2041 /* Work out which symbol to attach it this reloc to */
2042 switch (src
->symbol
.letter
)
2045 src
->relent
.sym_ptr_ptr
=
2046 symbols
+ src
->symbol
.index
+ ieee
->external_symbol_base_offset
;
2049 src
->relent
.sym_ptr_ptr
=
2050 symbols
+ src
->symbol
.index
+ ieee
->external_reference_base_offset
;
2053 if (src
->relent
.sym_ptr_ptr
!= NULL
)
2054 src
->relent
.sym_ptr_ptr
=
2055 src
->relent
.sym_ptr_ptr
[0]->section
->symbol_ptr_ptr
;
2061 *relptr
++ = &src
->relent
;
2064 *relptr
= (arelent
*) NULL
;
2065 return section
->reloc_count
;
2073 arelent
*a
= *((arelent
**) ap
);
2074 arelent
*b
= *((arelent
**) bp
);
2075 return a
->address
- b
->address
;
2078 /* Write the section headers. */
2081 ieee_write_section_part (abfd
)
2084 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
2086 ieee
->w
.r
.section_part
= bfd_tell (abfd
);
2087 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2089 if (! bfd_is_abs_section (s
)
2090 && (s
->flags
& SEC_DEBUGGING
) == 0)
2092 if (! ieee_write_byte (abfd
, ieee_section_type_enum
)
2093 || ! ieee_write_byte (abfd
,
2094 (bfd_byte
) (s
->index
2095 + IEEE_SECTION_NUMBER_BASE
)))
2098 if (abfd
->flags
& EXEC_P
)
2100 /* This image is executable, so output absolute sections */
2101 if (! ieee_write_byte (abfd
, ieee_variable_A_enum
)
2102 || ! ieee_write_byte (abfd
, ieee_variable_S_enum
))
2107 if (! ieee_write_byte (abfd
, ieee_variable_C_enum
))
2111 switch (s
->flags
& (SEC_CODE
| SEC_DATA
| SEC_ROM
))
2113 case SEC_CODE
| SEC_LOAD
:
2115 if (! ieee_write_byte (abfd
, ieee_variable_P_enum
))
2120 if (! ieee_write_byte (abfd
, ieee_variable_D_enum
))
2124 case SEC_ROM
| SEC_DATA
:
2125 case SEC_ROM
| SEC_LOAD
:
2126 case SEC_ROM
| SEC_DATA
| SEC_LOAD
:
2127 if (! ieee_write_byte (abfd
, ieee_variable_R_enum
))
2132 if (! ieee_write_id (abfd
, s
->name
))
2135 ieee_write_int (abfd
, 0); /* Parent */
2136 ieee_write_int (abfd
, 0); /* Brother */
2137 ieee_write_int (abfd
, 0); /* Context */
2140 if (! ieee_write_byte (abfd
, ieee_section_alignment_enum
)
2141 || ! ieee_write_byte (abfd
,
2142 (bfd_byte
) (s
->index
2143 + IEEE_SECTION_NUMBER_BASE
))
2144 || ! ieee_write_int (abfd
, 1 << s
->alignment_power
))
2148 if (! ieee_write_2bytes (abfd
, ieee_section_size_enum
)
2149 || ! ieee_write_byte (abfd
,
2150 (bfd_byte
) (s
->index
2151 + IEEE_SECTION_NUMBER_BASE
))
2152 || ! ieee_write_int (abfd
, s
->_raw_size
))
2154 if (abfd
->flags
& EXEC_P
)
2156 /* Relocateable sections don't have asl records */
2158 if (! ieee_write_2bytes (abfd
, ieee_section_base_address_enum
)
2159 || ! ieee_write_byte (abfd
,
2162 + IEEE_SECTION_NUMBER_BASE
)))
2163 || ! ieee_write_int (abfd
, s
->lma
))
2174 do_with_relocs (abfd
, s
)
2178 unsigned int number_of_maus_in_address
=
2179 bfd_arch_bits_per_address (abfd
) / bfd_arch_bits_per_byte (abfd
);
2180 unsigned int relocs_to_go
= s
->reloc_count
;
2181 bfd_byte
*stream
= ieee_per_section (s
)->data
;
2182 arelent
**p
= s
->orelocation
;
2183 bfd_size_type current_byte_index
= 0;
2185 qsort (s
->orelocation
,
2187 sizeof (arelent
**),
2190 /* Output the section preheader */
2191 if (! ieee_write_byte (abfd
, ieee_set_current_section_enum
)
2192 || ! ieee_write_byte (abfd
,
2193 (bfd_byte
) (s
->index
+ IEEE_SECTION_NUMBER_BASE
))
2194 || ! ieee_write_2bytes (abfd
, ieee_set_current_pc_enum
)
2195 || ! ieee_write_byte (abfd
,
2196 (bfd_byte
) (s
->index
+ IEEE_SECTION_NUMBER_BASE
)))
2198 if ((abfd
->flags
& EXEC_P
) != 0 && relocs_to_go
== 0)
2200 if (! ieee_write_int (abfd
, s
->lma
))
2205 if (! ieee_write_expression (abfd
, 0, s
->symbol
, 0, 0))
2209 if (relocs_to_go
== 0)
2211 /* If there aren't any relocations then output the load constant
2212 byte opcode rather than the load with relocation opcode */
2214 while (current_byte_index
< s
->_raw_size
)
2217 unsigned int MAXRUN
= 127;
2219 if (run
> s
->_raw_size
- current_byte_index
)
2221 run
= s
->_raw_size
- current_byte_index
;
2226 if (! ieee_write_byte (abfd
, ieee_load_constant_bytes_enum
))
2228 /* Output a stream of bytes */
2229 if (! ieee_write_int (abfd
, run
))
2231 if (bfd_write ((PTR
) (stream
+ current_byte_index
),
2237 current_byte_index
+= run
;
2243 if (! ieee_write_byte (abfd
, ieee_load_with_relocation_enum
))
2246 /* Output the data stream as the longest sequence of bytes
2247 possible, allowing for the a reasonable packet size and
2248 relocation stuffs. */
2250 if ((PTR
) stream
== (PTR
) NULL
)
2252 /* Outputting a section without data, fill it up */
2253 stream
= (unsigned char *) (bfd_alloc (abfd
, s
->_raw_size
));
2256 memset ((PTR
) stream
, 0, (size_t) s
->_raw_size
);
2258 while (current_byte_index
< s
->_raw_size
)
2261 unsigned int MAXRUN
= 127;
2264 run
= (*p
)->address
- current_byte_index
;
2272 if (run
> s
->_raw_size
- current_byte_index
)
2274 run
= s
->_raw_size
- current_byte_index
;
2279 /* Output a stream of bytes */
2280 if (! ieee_write_int (abfd
, run
))
2282 if (bfd_write ((PTR
) (stream
+ current_byte_index
),
2288 current_byte_index
+= run
;
2290 /* Output any relocations here */
2291 if (relocs_to_go
&& (*p
) && (*p
)->address
== current_byte_index
)
2294 && (*p
) && (*p
)->address
== current_byte_index
)
2300 if (r
->howto
->pc_relative
)
2302 r
->addend
+= current_byte_index
;
2306 switch (r
->howto
->size
)
2310 ov
= bfd_get_signed_32 (abfd
,
2311 stream
+ current_byte_index
);
2312 current_byte_index
+= 4;
2315 ov
= bfd_get_signed_16 (abfd
,
2316 stream
+ current_byte_index
);
2317 current_byte_index
+= 2;
2320 ov
= bfd_get_signed_8 (abfd
,
2321 stream
+ current_byte_index
);
2322 current_byte_index
++;
2330 ov
&= r
->howto
->src_mask
;
2332 if (r
->howto
->pc_relative
2333 && ! r
->howto
->pcrel_offset
)
2336 if (! ieee_write_byte (abfd
,
2337 ieee_function_either_open_b_enum
))
2342 if (r
->sym_ptr_ptr
!= (asymbol
**) NULL
)
2344 if (! ieee_write_expression (abfd
, r
->addend
+ ov
,
2346 r
->howto
->pc_relative
,
2352 if (! ieee_write_expression (abfd
, r
->addend
+ ov
,
2354 r
->howto
->pc_relative
,
2359 if (number_of_maus_in_address
2360 != bfd_get_reloc_size (r
->howto
))
2362 if (! ieee_write_int (abfd
,
2363 bfd_get_reloc_size (r
->howto
)))
2366 if (! ieee_write_byte (abfd
,
2367 ieee_function_either_close_b_enum
))
2381 /* If there are no relocations in the output section then we can be
2382 clever about how we write. We block items up into a max of 127
2386 do_as_repeat (abfd
, s
)
2392 if (! ieee_write_byte (abfd
, ieee_set_current_section_enum
)
2393 || ! ieee_write_byte (abfd
,
2394 (bfd_byte
) (s
->index
2395 + IEEE_SECTION_NUMBER_BASE
))
2396 || ! ieee_write_byte (abfd
, ieee_set_current_pc_enum
>> 8)
2397 || ! ieee_write_byte (abfd
, ieee_set_current_pc_enum
& 0xff)
2398 || ! ieee_write_byte (abfd
,
2399 (bfd_byte
) (s
->index
2400 + IEEE_SECTION_NUMBER_BASE
))
2401 || ! ieee_write_int (abfd
, s
->lma
)
2402 || ! ieee_write_byte (abfd
, ieee_repeat_data_enum
)
2403 || ! ieee_write_int (abfd
, s
->_raw_size
)
2404 || ! ieee_write_byte (abfd
, ieee_load_constant_bytes_enum
)
2405 || ! ieee_write_byte (abfd
, 1)
2406 || ! ieee_write_byte (abfd
, 0))
2414 do_without_relocs (abfd
, s
)
2418 bfd_byte
*stream
= ieee_per_section (s
)->data
;
2420 if (stream
== 0 || ((s
->flags
& SEC_LOAD
) == 0))
2422 if (! do_as_repeat (abfd
, s
))
2428 for (i
= 0; i
< s
->_raw_size
; i
++)
2432 if (! do_with_relocs (abfd
, s
))
2437 if (! do_as_repeat (abfd
, s
))
2445 static unsigned char *output_ptr_start
;
2446 static unsigned char *output_ptr
;
2447 static unsigned char *output_ptr_end
;
2448 static unsigned char *input_ptr_start
;
2449 static unsigned char *input_ptr
;
2450 static unsigned char *input_ptr_end
;
2451 static bfd
*input_bfd
;
2452 static bfd
*output_bfd
;
2453 static int output_buffer
;
2458 /* FIXME: Check return value. I'm not sure whether it needs to read
2459 the entire buffer or not. */
2460 bfd_read ((PTR
) input_ptr_start
, 1, input_ptr_end
- input_ptr_start
, input_bfd
);
2461 input_ptr
= input_ptr_start
;
2466 if (bfd_write ((PTR
) (output_ptr_start
), 1, output_ptr
- output_ptr_start
,
2468 != (bfd_size_type
) (output_ptr
- output_ptr_start
))
2470 output_ptr
= output_ptr_start
;
2474 #define THIS() ( *input_ptr )
2475 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
2476 #define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); }
2482 if (value
>= 0 && value
<= 127)
2488 unsigned int length
;
2489 /* How many significant bytes ? */
2490 /* FIXME FOR LONGER INTS */
2491 if (value
& 0xff000000)
2495 else if (value
& 0x00ff0000)
2499 else if (value
& 0x0000ff00)
2506 OUT ((int) ieee_number_repeat_start_enum
+ length
);
2525 int length
= THIS ();
2537 #define VAR(x) ((x | 0x80))
2552 value
= (value
<< 8) | THIS ();
2554 value
= (value
<< 8) | THIS ();
2556 value
= (value
<< 8) | THIS ();
2564 value
= (value
<< 8) | THIS ();
2566 value
= (value
<< 8) | THIS ();
2574 value
= (value
<< 8) | THIS ();
2591 /* Not a number, just bug out with the answer */
2592 write_int (*(--tos
));
2602 int value
= *(--tos
);
2611 ieee_data_type
*ieee
;
2614 section_number
= THIS ();
2617 ieee
= IEEE_DATA (input_bfd
);
2618 s
= ieee
->section_table
[section_number
];
2619 if (s
->output_section
)
2621 value
= s
->output_section
->lma
;
2627 value
+= s
->output_offset
;
2635 write_int (*(--tos
));
2645 /* Drop the int in the buffer, and copy a null into the gap, which we
2646 will overwrite later */
2648 struct output_buffer_struct
2650 unsigned char *ptrp
;
2656 struct output_buffer_struct
*buf
;
2658 if (buf
->buffer
== output_buffer
)
2660 /* Still a chance to output the size */
2661 int value
= output_ptr
- buf
->ptrp
+ 3;
2662 buf
->ptrp
[0] = value
>> 24;
2663 buf
->ptrp
[1] = value
>> 16;
2664 buf
->ptrp
[2] = value
>> 8;
2665 buf
->ptrp
[3] = value
>> 0;
2671 struct output_buffer_struct
*buf
;
2697 buf
->ptrp
= output_ptr
;
2698 buf
->buffer
= output_buffer
;
2738 #define ID copy_id()
2739 #define INT copy_int()
2740 #define EXP copy_expression()
2741 static void copy_till_end ();
2742 #define INTn(q) copy_int()
2743 #define EXPn(q) copy_expression()
2782 EXPn (instruction address
);
2816 EXPn (external function
);
2826 INTn (locked
register);
2849 /* Attribute record */
2907 static void block ();
2919 /* Unique typedefs for module */
2920 /* GLobal typedefs */
2921 /* High level module scope beginning */
2923 struct output_buffer_struct ob
;
2938 /* Global function */
2940 struct output_buffer_struct ob
;
2954 EXPn (size of block
);
2960 /* File name for source line numbers */
2962 struct output_buffer_struct ob
;
2982 /* Local function */
2984 struct output_buffer_struct ob
;
3002 /* Assembler module scope beginning -*/
3004 struct output_buffer_struct ob
;
3030 struct output_buffer_struct ob
;
3037 INTn (section index
);
3045 EXPn (Size in Maus
);
3100 moves all the debug information from the source bfd to the output
3101 bfd, and relocates any expressions it finds
3105 relocate_debug (output
, input
)
3111 unsigned char input_buffer
[IBS
];
3113 input_ptr_start
= input_ptr
= input_buffer
;
3114 input_ptr_end
= input_buffer
+ IBS
;
3116 /* FIXME: Check return value. I'm not sure whether it needs to read
3117 the entire buffer or not. */
3118 bfd_read ((PTR
) input_ptr_start
, 1, IBS
, input
);
3123 During linking, we we told about the bfds which made up our
3124 contents, we have a list of them. They will still be open, so go to
3125 the debug info in each, and copy it out, relocating it as we go.
3129 ieee_write_debug_part (abfd
)
3132 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3133 bfd_chain_type
*chain
= ieee
->chain_root
;
3134 unsigned char output_buffer
[OBS
];
3135 boolean some_debug
= false;
3136 file_ptr here
= bfd_tell (abfd
);
3138 output_ptr_start
= output_ptr
= output_buffer
;
3139 output_ptr_end
= output_buffer
+ OBS
;
3140 output_ptr
= output_buffer
;
3143 if (chain
== (bfd_chain_type
*) NULL
)
3147 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3148 if ((s
->flags
& SEC_DEBUGGING
) != 0)
3152 ieee
->w
.r
.debug_information_part
= 0;
3156 ieee
->w
.r
.debug_information_part
= here
;
3157 if (bfd_write (s
->contents
, 1, s
->_raw_size
, abfd
) != s
->_raw_size
)
3162 while (chain
!= (bfd_chain_type
*) NULL
)
3164 bfd
*entry
= chain
->this;
3165 ieee_data_type
*entry_ieee
= IEEE_DATA (entry
);
3166 if (entry_ieee
->w
.r
.debug_information_part
)
3168 if (bfd_seek (entry
, entry_ieee
->w
.r
.debug_information_part
,
3172 relocate_debug (abfd
, entry
);
3175 chain
= chain
->next
;
3179 ieee
->w
.r
.debug_information_part
= here
;
3183 ieee
->w
.r
.debug_information_part
= 0;
3192 /* Write the data in an ieee way. */
3195 ieee_write_data_part (abfd
)
3199 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3200 ieee
->w
.r
.data_part
= bfd_tell (abfd
);
3201 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
3203 /* Skip sections that have no loadable contents (.bss,
3205 if ((s
->flags
& SEC_LOAD
) == 0)
3208 /* Sort the reloc records so we can insert them in the correct
3210 if (s
->reloc_count
!= 0)
3212 if (! do_with_relocs (abfd
, s
))
3217 if (! do_without_relocs (abfd
, s
))
3227 init_for_output (abfd
)
3231 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
3233 if ((s
->flags
& SEC_DEBUGGING
) != 0)
3235 if (s
->_raw_size
!= 0)
3237 ieee_per_section (s
)->data
= (bfd_byte
*) (bfd_alloc (abfd
, s
->_raw_size
));
3238 if (!ieee_per_section (s
)->data
)
3245 /** exec and core file sections */
3247 /* set section contents is complicated with IEEE since the format is
3248 * not a byte image, but a record stream.
3251 ieee_set_section_contents (abfd
, section
, location
, offset
, count
)
3256 bfd_size_type count
;
3258 if ((section
->flags
& SEC_DEBUGGING
) != 0)
3260 if (section
->contents
== NULL
)
3262 section
->contents
= ((unsigned char *)
3263 bfd_alloc (abfd
, section
->_raw_size
));
3264 if (section
->contents
== NULL
)
3267 /* bfd_set_section_contents has already checked that everything
3269 memcpy (section
->contents
+ offset
, location
, count
);
3273 if (ieee_per_section (section
)->data
== (bfd_byte
*) NULL
)
3275 if (!init_for_output (abfd
))
3278 memcpy ((PTR
) (ieee_per_section (section
)->data
+ offset
),
3280 (unsigned int) count
);
3284 /* Write the external symbols of a file. IEEE considers two sorts of
3285 external symbols, public, and referenced. It uses to internal
3286 forms to index them as well. When we write them out we turn their
3287 symbol values into indexes from the right base. */
3290 ieee_write_external_part (abfd
)
3294 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3296 unsigned int reference_index
= IEEE_REFERENCE_BASE
;
3297 unsigned int public_index
= IEEE_PUBLIC_BASE
+ 2;
3298 file_ptr here
= bfd_tell (abfd
);
3299 boolean hadone
= false;
3300 if (abfd
->outsymbols
!= (asymbol
**) NULL
)
3303 for (q
= abfd
->outsymbols
; *q
!= (asymbol
*) NULL
; q
++)
3306 if (bfd_is_und_section (p
->section
))
3308 /* This must be a symbol reference .. */
3309 if (! ieee_write_byte (abfd
, ieee_external_reference_enum
)
3310 || ! ieee_write_int (abfd
, reference_index
)
3311 || ! ieee_write_id (abfd
, p
->name
))
3313 p
->value
= reference_index
;
3317 else if (bfd_is_com_section (p
->section
))
3319 /* This is a weak reference */
3320 if (! ieee_write_byte (abfd
, ieee_external_reference_enum
)
3321 || ! ieee_write_int (abfd
, reference_index
)
3322 || ! ieee_write_id (abfd
, p
->name
)
3323 || ! ieee_write_byte (abfd
,
3324 ieee_weak_external_reference_enum
)
3325 || ! ieee_write_int (abfd
, reference_index
)
3326 || ! ieee_write_int (abfd
, p
->value
))
3328 p
->value
= reference_index
;
3332 else if (p
->flags
& BSF_GLOBAL
)
3334 /* This must be a symbol definition */
3336 if (! ieee_write_byte (abfd
, ieee_external_symbol_enum
)
3337 || ! ieee_write_int (abfd
, public_index
)
3338 || ! ieee_write_id (abfd
, p
->name
)
3339 || ! ieee_write_2bytes (abfd
, ieee_attribute_record_enum
)
3340 || ! ieee_write_int (abfd
, public_index
)
3341 || ! ieee_write_byte (abfd
, 15) /* instruction address */
3342 || ! ieee_write_byte (abfd
, 19) /* static symbol */
3343 || ! ieee_write_byte (abfd
, 1)) /* one of them */
3346 /* Write out the value */
3347 if (! ieee_write_2bytes (abfd
, ieee_value_record_enum
)
3348 || ! ieee_write_int (abfd
, public_index
))
3350 if (! bfd_is_abs_section (p
->section
))
3352 if (abfd
->flags
& EXEC_P
)
3354 /* If fully linked, then output all symbols
3356 if (! (ieee_write_int
3359 + p
->section
->output_offset
3360 + p
->section
->output_section
->vma
))))
3365 if (! (ieee_write_expression
3367 p
->value
+ p
->section
->output_offset
,
3368 p
->section
->output_section
->symbol
,
3375 if (! ieee_write_expression (abfd
,
3377 bfd_abs_section_ptr
->symbol
,
3381 p
->value
= public_index
;
3387 /* This can happen - when there are gaps in the symbols read */
3388 /* from an input ieee file */
3393 ieee
->w
.r
.external_part
= here
;
3399 static CONST
unsigned char exten
[] =
3402 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3 */
3403 0xf1, 0xce, 0x20, 0x00, 39, 2,/* keep symbol in original case */
3404 0xf1, 0xce, 0x20, 0x00, 38 /* set object type relocateable to x */
3407 static CONST
unsigned char envi
[] =
3411 /* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3414 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */
3416 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix */
3417 /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
3421 ieee_write_me_part (abfd
)
3424 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3425 ieee
->w
.r
.trailer_part
= bfd_tell (abfd
);
3426 if (abfd
->start_address
)
3428 if (! ieee_write_2bytes (abfd
, ieee_value_starting_address_enum
)
3429 || ! ieee_write_byte (abfd
, ieee_function_either_open_b_enum
)
3430 || ! ieee_write_int (abfd
, abfd
->start_address
)
3431 || ! ieee_write_byte (abfd
, ieee_function_either_close_b_enum
))
3434 ieee
->w
.r
.me_record
= bfd_tell (abfd
);
3435 if (! ieee_write_byte (abfd
, ieee_module_end_enum
))
3440 /* Write out the IEEE processor ID. */
3443 ieee_write_processor (abfd
)
3446 const bfd_arch_info_type
*arch
;
3448 arch
= bfd_get_arch_info (abfd
);
3452 if (! ieee_write_id (abfd
, bfd_printable_name (abfd
)))
3457 if (! ieee_write_id (abfd
, "29000"))
3461 case bfd_arch_h8300
:
3462 if (! ieee_write_id (abfd
, "H8/300"))
3466 case bfd_arch_h8500
:
3467 if (! ieee_write_id (abfd
, "H8/500"))
3475 case bfd_mach_i960_core
:
3476 case bfd_mach_i960_ka_sa
:
3477 if (! ieee_write_id (abfd
, "80960KA"))
3481 case bfd_mach_i960_kb_sb
:
3482 if (! ieee_write_id (abfd
, "80960KB"))
3486 case bfd_mach_i960_ca
:
3487 if (! ieee_write_id (abfd
, "80960CA"))
3491 case bfd_mach_i960_mc
:
3492 case bfd_mach_i960_xa
:
3493 if (! ieee_write_id (abfd
, "80960MC"))
3503 sprintf (ab
, "%lu", arch
->mach
);
3504 if (! ieee_write_id (abfd
, ab
))
3514 ieee_write_object_contents (abfd
)
3517 ieee_data_type
*ieee
= IEEE_DATA (abfd
);
3521 /* Fast forward over the header area */
3522 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3525 if (! ieee_write_byte (abfd
, ieee_module_beginning_enum
)
3526 || ! ieee_write_processor (abfd
)
3527 || ! ieee_write_id (abfd
, abfd
->filename
))
3530 /* Fast forward over the variable bits */
3531 if (! ieee_write_byte (abfd
, ieee_address_descriptor_enum
))
3535 if (! ieee_write_byte (abfd
, (bfd_byte
) (bfd_arch_bits_per_byte (abfd
))))
3537 /* MAU's per address */
3538 if (! ieee_write_byte (abfd
,
3539 (bfd_byte
) (bfd_arch_bits_per_address (abfd
)
3540 / bfd_arch_bits_per_byte (abfd
))))
3543 old
= bfd_tell (abfd
);
3544 if (bfd_seek (abfd
, (file_ptr
) (8 * N_W_VARIABLES
), SEEK_CUR
) != 0)
3547 ieee
->w
.r
.extension_record
= bfd_tell (abfd
);
3548 if (bfd_write ((char *) exten
, 1, sizeof (exten
), abfd
) != sizeof (exten
))
3550 if (abfd
->flags
& EXEC_P
)
3552 if (! ieee_write_byte (abfd
, 0x1)) /* Absolute */
3557 if (! ieee_write_byte (abfd
, 0x2)) /* Relocateable */
3561 ieee
->w
.r
.environmental_record
= bfd_tell (abfd
);
3562 if (bfd_write ((char *) envi
, 1, sizeof (envi
), abfd
) != sizeof (envi
))
3565 /* The HP emulator database requires a timestamp in the file. */
3571 t
= (struct tm
*) localtime (&now
);
3572 if (! ieee_write_2bytes (abfd
, (int) ieee_atn_record_enum
)
3573 || ! ieee_write_byte (abfd
, 0x21)
3574 || ! ieee_write_byte (abfd
, 0)
3575 || ! ieee_write_byte (abfd
, 50)
3576 || ! ieee_write_int (abfd
, t
->tm_year
+ 1900)
3577 || ! ieee_write_int (abfd
, t
->tm_mon
+ 1)
3578 || ! ieee_write_int (abfd
, t
->tm_mday
)
3579 || ! ieee_write_int (abfd
, t
->tm_hour
)
3580 || ! ieee_write_int (abfd
, t
->tm_min
)
3581 || ! ieee_write_int (abfd
, t
->tm_sec
))
3589 if (! ieee_write_section_part (abfd
))
3591 /* First write the symbols. This changes their values into table
3592 indeces so we cant use it after this point. */
3593 if (! ieee_write_external_part (abfd
))
3596 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3598 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3601 /* Write any debugs we have been told about. */
3602 if (! ieee_write_debug_part (abfd
))
3605 /* Can only write the data once the symbols have been written, since
3606 the data contains relocation information which points to the
3608 if (! ieee_write_data_part (abfd
))
3611 /* At the end we put the end! */
3612 if (! ieee_write_me_part (abfd
))
3615 /* Generate the header */
3616 if (bfd_seek (abfd
, old
, SEEK_SET
) != 0)
3619 for (i
= 0; i
< N_W_VARIABLES
; i
++)
3621 if (! ieee_write_2bytes (abfd
, ieee_assign_value_to_variable_enum
)
3622 || ! ieee_write_byte (abfd
, (bfd_byte
) i
)
3623 || ! ieee_write_int5_out (abfd
, ieee
->w
.offset
[i
]))
3630 /* Native-level interface to symbols. */
3632 /* We read the symbols into a buffer, which is discarded when this
3633 function exits. We read the strings into a buffer large enough to
3634 hold them all plus all the cached symbol entries. */
3637 ieee_make_empty_symbol (abfd
)
3640 ieee_symbol_type
*new =
3641 (ieee_symbol_type
*) bfd_zmalloc (sizeof (ieee_symbol_type
));
3644 new->symbol
.the_bfd
= abfd
;
3645 return &new->symbol
;
3649 ieee_openr_next_archived_file (arch
, prev
)
3653 ieee_ar_data_type
*ar
= IEEE_AR_DATA (arch
);
3654 /* take the next one from the arch state, or reset */
3655 if (prev
== (bfd
*) NULL
)
3657 /* Reset the index - the first two entries are bogus*/
3658 ar
->element_index
= 2;
3662 ieee_ar_obstack_type
*p
= ar
->elements
+ ar
->element_index
;
3663 ar
->element_index
++;
3664 if (ar
->element_index
<= ar
->element_count
)
3666 if (p
->file_offset
!= (file_ptr
) 0)
3668 if (p
->abfd
== (bfd
*) NULL
)
3670 p
->abfd
= _bfd_create_empty_archive_element_shell (arch
);
3671 p
->abfd
->origin
= p
->file_offset
;
3678 bfd_set_error (bfd_error_no_more_archived_files
);
3679 return (bfd
*) NULL
;
3686 ieee_find_nearest_line (abfd
,
3697 char **filename_ptr
;
3698 char **functionname_ptr
;
3705 ieee_generic_stat_arch_elt (abfd
, buf
)
3709 ieee_ar_data_type
*ar
= (ieee_ar_data_type
*) NULL
;
3710 ieee_data_type
*ieee
;
3712 if (abfd
->my_archive
!= NULL
)
3713 ar
= abfd
->my_archive
->tdata
.ieee_ar_data
;
3714 if (ar
== (ieee_ar_data_type
*) NULL
)
3716 bfd_set_error (bfd_error_invalid_operation
);
3720 if (IEEE_DATA (abfd
) == NULL
)
3722 if (ieee_object_p (abfd
) == NULL
)
3724 bfd_set_error (bfd_error_wrong_format
);
3729 ieee
= IEEE_DATA (abfd
);
3731 buf
->st_size
= ieee
->w
.r
.me_record
+ 1;
3732 buf
->st_mode
= 0644;
3737 ieee_sizeof_headers (abfd
, x
)
3745 /* The debug info routines are never used. */
3749 ieee_bfd_debug_info_start (abfd
)
3756 ieee_bfd_debug_info_end (abfd
)
3763 /* Add this section to the list of sections we have debug info for, to
3764 be ready to output it at close time
3767 ieee_bfd_debug_info_accumulate (abfd
, section
)
3771 ieee_data_type
*ieee
= IEEE_DATA (section
->owner
);
3772 ieee_data_type
*output_ieee
= IEEE_DATA (abfd
);
3773 /* can only accumulate data from other ieee bfds */
3774 if (section
->owner
->xvec
!= abfd
->xvec
)
3776 /* Only bother once per bfd */
3777 if (ieee
->done_debug
== true)
3779 ieee
->done_debug
= true;
3781 /* Don't bother if there is no debug info */
3782 if (ieee
->w
.r
.debug_information_part
== 0)
3788 bfd_chain_type
*n
= (bfd_chain_type
*) bfd_alloc (abfd
, sizeof (bfd_chain_type
));
3790 abort (); /* FIXME */
3791 n
->this = section
->owner
;
3792 n
->next
= (bfd_chain_type
*) NULL
;
3794 if (output_ieee
->chain_head
)
3796 output_ieee
->chain_head
->next
= n
;
3800 output_ieee
->chain_root
= n
;
3803 output_ieee
->chain_head
= n
;
3809 #define ieee_close_and_cleanup _bfd_generic_close_and_cleanup
3810 #define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3812 #define ieee_slurp_armap bfd_true
3813 #define ieee_slurp_extended_name_table bfd_true
3814 #define ieee_construct_extended_name_table \
3815 ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
3817 #define ieee_truncate_arname bfd_dont_truncate_arname
3818 #define ieee_write_armap \
3820 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
3822 #define ieee_read_ar_hdr bfd_nullvoidptr
3823 #define ieee_update_armap_timestamp bfd_true
3824 #define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
3826 #define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
3827 #define ieee_get_lineno _bfd_nosymbols_get_lineno
3828 #define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3829 #define ieee_read_minisymbols _bfd_generic_read_minisymbols
3830 #define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3832 #define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3834 #define ieee_set_arch_mach _bfd_generic_set_arch_mach
3836 #define ieee_get_section_contents_in_window \
3837 _bfd_generic_get_section_contents_in_window
3838 #define ieee_bfd_get_relocated_section_contents \
3839 bfd_generic_get_relocated_section_contents
3840 #define ieee_bfd_relax_section bfd_generic_relax_section
3841 #define ieee_bfd_gc_sections bfd_generic_gc_sections
3842 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3843 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
3844 #define ieee_bfd_final_link _bfd_generic_final_link
3845 #define ieee_bfd_link_split_section _bfd_generic_link_split_section
3848 const bfd_target ieee_vec
=
3851 bfd_target_ieee_flavour
,
3852 BFD_ENDIAN_UNKNOWN
, /* target byte order */
3853 BFD_ENDIAN_UNKNOWN
, /* target headers byte order */
3854 (HAS_RELOC
| EXEC_P
| /* object flags */
3855 HAS_LINENO
| HAS_DEBUG
|
3856 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
3857 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
3858 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
3859 '_', /* leading underscore */
3860 ' ', /* ar_pad_char */
3861 16, /* ar_max_namelen */
3862 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
3863 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
3864 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
3865 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
3866 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
3867 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
3870 ieee_object_p
, /* bfd_check_format */
3877 _bfd_generic_mkarchive
,
3882 ieee_write_object_contents
,
3883 _bfd_write_archive_contents
,
3887 BFD_JUMP_TABLE_GENERIC (ieee
),
3888 BFD_JUMP_TABLE_COPY (_bfd_generic
),
3889 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
3890 BFD_JUMP_TABLE_ARCHIVE (ieee
),
3891 BFD_JUMP_TABLE_SYMBOLS (ieee
),
3892 BFD_JUMP_TABLE_RELOCS (ieee
),
3893 BFD_JUMP_TABLE_WRITE (ieee
),
3894 BFD_JUMP_TABLE_LINK (ieee
),
3895 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),