1 /* bfd backend for oasys objects.
2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support <steve@cygnus.com>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #define UNDERSCORE_HACK 1
30 /* XXX - FIXME. offsetof belongs in the system-specific files in
32 /* Define offsetof for those systems which lack it */
35 #define offsetof(type, identifier) (size_t) &(((type *) 0)->identifier)
38 /* Read in all the section data and relocation stuff too */
39 PROTO(static boolean
,oasys_slurp_section_data
,(bfd
*CONST abfd
));
42 DEFUN(oasys_read_record
,(abfd
, record
),
44 oasys_record_union_type
*record
)
47 bfd_read((PTR
)record
, 1, sizeof(record
->header
), abfd
);
49 if ((size_t) record
->header
.length
<= (size_t) sizeof (record
->header
))
51 bfd_read((PTR
)(((char *)record
)+ sizeof(record
->header
)),
52 1, record
->header
.length
- sizeof(record
->header
),
56 DEFUN(oasys_string_length
,(record
),
57 oasys_record_union_type
*record
)
59 return record
->header
.length
60 - ((char *)record
->symbol
.name
- (char *)record
);
63 /*****************************************************************************/
67 Slurp the symbol table by reading in all the records at the start file
68 till we get to the first section record.
70 We'll sort the symbolss into two lists, defined and undefined. The
71 undefined symbols will be placed into the table according to their
74 We do this by placing all undefined symbols at the front of the table
75 moving in, and the defined symbols at the end of the table moving back.
80 DEFUN(oasys_slurp_symbol_table
,(abfd
),
83 oasys_record_union_type record
;
84 oasys_data_type
*data
= OASYS_DATA(abfd
);
86 asymbol
*dest_defined
;
91 if (data
->symbols
!= (asymbol
*)NULL
) {
94 /* Buy enough memory for all the symbols and all the names */
96 (asymbol
*)bfd_alloc(abfd
, sizeof(asymbol
) * abfd
->symcount
);
97 #ifdef UNDERSCORE_HACK
98 /* buy 1 more char for each symbol to keep the underscore in*/
99 data
->strings
= bfd_alloc(abfd
, data
->symbol_string_length
+
102 data
->strings
= bfd_alloc(abfd
, data
->symbol_string_length
);
106 dest_defined
= data
->symbols
+ abfd
->symcount
-1;
108 string_ptr
= data
->strings
;
109 bfd_seek(abfd
, (file_ptr
)0, SEEK_SET
);
112 oasys_read_record(abfd
, &record
);
113 switch (record
.header
.type
) {
114 case oasys_record_is_header_enum
:
116 case oasys_record_is_local_enum
:
117 case oasys_record_is_symbol_enum
:
119 int flag
= record
.header
.type
== (int)oasys_record_is_local_enum
?
120 (BSF_LOCAL
) : (BSF_GLOBAL
| BSF_EXPORT
);
123 size_t length
= oasys_string_length(&record
);
124 switch (record
.symbol
.relb
& RELOCATION_TYPE_BITS
) {
125 case RELOCATION_TYPE_ABS
:
126 dest
= dest_defined
--;
127 dest
->section
= &bfd_abs_section
;
131 case RELOCATION_TYPE_REL
:
132 dest
= dest_defined
--;
134 OASYS_DATA(abfd
)->sections
[record
.symbol
.relb
&
135 RELOCATION_SECT_BITS
];
136 if (record
.header
.type
== (int)oasys_record_is_local_enum
)
138 dest
->flags
= BSF_LOCAL
;
139 if (dest
->section
==(asection
*)(~0)) {
140 /* It seems that sometimes internal symbols are tied up, but
141 still get output, even though there is no
151 case RELOCATION_TYPE_UND
:
152 dest
= data
->symbols
+ bfd_h_get_16(abfd
, (bfd_byte
*)&record
.symbol
.refno
[0]);
153 dest
->section
= &bfd_und_section
;
155 case RELOCATION_TYPE_COM
:
156 dest
= dest_defined
--;
157 dest
->name
= string_ptr
;
158 dest
->the_bfd
= abfd
;
160 dest
->section
= &bfd_com_section
;
164 dest
= dest_defined
--;
168 dest
->name
= string_ptr
;
169 dest
->the_bfd
= abfd
;
170 dest
->udata
= (PTR
)NULL
;
171 dest
->value
= bfd_h_get_32(abfd
, (bfd_byte
*)&record
.symbol
.value
[0]);
173 #ifdef UNDERSCORE_HACK
174 if (record
.symbol
.name
[0] != '_') {
179 memcpy(string_ptr
, record
.symbol
.name
, length
);
182 string_ptr
[length
] =0;
183 string_ptr
+= length
+1;
194 DEFUN(oasys_get_symtab_upper_bound
,(abfd
),
197 oasys_slurp_symbol_table (abfd
);
199 return (abfd
->symcount
+1) * (sizeof (oasys_symbol_type
*));
205 extern bfd_target oasys_vec
;
208 DEFUN(oasys_get_symtab
,(abfd
, location
),
213 unsigned int counter
;
214 if (oasys_slurp_symbol_table(abfd
) == false) {
217 symbase
= OASYS_DATA(abfd
)->symbols
;
218 for (counter
= 0; counter
< abfd
->symcount
; counter
++) {
219 *(location
++) = symbase
++;
222 return abfd
->symcount
;
225 /***********************************************************************
230 DEFUN(oasys_archive_p
,(abfd
),
233 oasys_archive_header_type header
;
234 oasys_extarchive_header_type header_ext
;
237 bfd_seek(abfd
, (file_ptr
) 0, false);
240 bfd_read((PTR
)&header_ext
, 1, sizeof(header_ext
), abfd
);
243 header
.version
= bfd_h_get_32(abfd
, (bfd_byte
*)header_ext
.version
);
244 header
.mod_count
= bfd_h_get_32(abfd
, (bfd_byte
*)header_ext
.mod_count
);
245 header
.mod_tbl_offset
= bfd_h_get_32(abfd
, (bfd_byte
*)header_ext
.mod_tbl_offset
);
246 header
.sym_tbl_size
= bfd_h_get_32(abfd
, (bfd_byte
*)header_ext
.sym_tbl_size
);
247 header
.sym_count
= bfd_h_get_32(abfd
, (bfd_byte
*)header_ext
.sym_count
);
248 header
.sym_tbl_offset
= bfd_h_get_32(abfd
, (bfd_byte
*)header_ext
.sym_tbl_offset
);
249 header
.xref_count
= bfd_h_get_32(abfd
, (bfd_byte
*)header_ext
.xref_count
);
250 header
.xref_lst_offset
= bfd_h_get_32(abfd
, (bfd_byte
*)header_ext
.xref_lst_offset
);
253 There isn't a magic number in an Oasys archive, so the best we
254 can do to verify reasnableness is to make sure that the values in
255 the header are too weird
258 if (header
.version
>10000 ||
259 header
.mod_count
>10000 ||
260 header
.sym_count
>100000 ||
261 header
.xref_count
> 100000) return (bfd_target
*)NULL
;
264 That all worked, lets buy the space for the header and read in
268 oasys_ar_data_type
*ar
=
269 (oasys_ar_data_type
*) bfd_alloc(abfd
, sizeof(oasys_ar_data_type
));
272 oasys_module_info_type
*module
=
273 (oasys_module_info_type
*)
274 bfd_alloc(abfd
, sizeof(oasys_module_info_type
) * header
.mod_count
);
277 oasys_module_table_type record
;
280 abfd
->tdata
.oasys_ar_data
= ar
;
282 ar
->module_count
= header
.mod_count
;
285 filepos
= header
.mod_tbl_offset
;
286 for (i
= 0; i
< header
.mod_count
; i
++) {
287 bfd_seek(abfd
, filepos
, SEEK_SET
);
289 /* There are two ways of specifying the archive header */
292 oasys_extmodule_table_type_a_type record_ext
;
293 bfd_read((PTR
)&record_ext
, 1, sizeof(record_ext
), abfd
);
295 record
.mod_size
= bfd_h_get_32(abfd
, (bfd_byte
*)record_ext
.mod_size
);
296 record
.file_offset
= bfd_h_get_32(abfd
,
297 (bfd_byte
*) record_ext
.file_offset
);
299 record
.dep_count
= bfd_h_get_32(abfd
, (bfd_byte
*)record_ext
.dep_count
);
300 record
.depee_count
= bfd_h_get_32(abfd
,(bfd_byte
*) record_ext
.depee_count
);
301 record
.sect_count
= bfd_h_get_32(abfd
, (bfd_byte
*) record_ext
.sect_count
);
304 module
[i
].name
= bfd_alloc(abfd
,33);
306 memcpy(module
[i
].name
, record_ext
.mod_name
, 33);
309 record
.dep_count
* 4 +
310 record
.depee_count
* 4 +
311 record
.sect_count
* 8 + 187;
314 oasys_extmodule_table_type_b_type record_ext
;
315 bfd_read((PTR
)&record_ext
, 1, sizeof(record_ext
), abfd
);
317 record
.mod_size
= bfd_h_get_32(abfd
, (bfd_byte
*) record_ext
.mod_size
);
318 record
.file_offset
= bfd_h_get_32(abfd
,
319 (bfd_byte
*)record_ext
.file_offset
);
321 record
.dep_count
= bfd_h_get_32(abfd
, (bfd_byte
*) record_ext
.dep_count
);
322 record
.depee_count
= bfd_h_get_32(abfd
, (bfd_byte
*) record_ext
.depee_count
);
323 record
.sect_count
= bfd_h_get_32(abfd
, (bfd_byte
*) record_ext
.sect_count
);
324 record
.module_name_size
= bfd_h_get_32(abfd
, (bfd_byte
*) record_ext
.mod_name_length
);
326 module
[i
].name
= bfd_alloc(abfd
,record
.module_name_size
+ 1);
327 bfd_read((PTR
)module
[i
].name
, 1, record
.module_name_size
, abfd
);
328 module
[i
].name
[record
.module_name_size
] = 0;
331 record
.dep_count
* 4 +
332 record
.module_name_size
+ 1;
337 module
[i
].size
= record
.mod_size
;
338 module
[i
].pos
= record
.file_offset
;
347 DEFUN(oasys_mkobject
,(abfd
),
351 abfd
->tdata
.oasys_obj_data
= (oasys_data_type
*)bfd_alloc(abfd
, sizeof(oasys_data_type
));
357 DEFUN(oasys_object_p
,(abfd
),
360 oasys_data_type
*oasys
;
361 oasys_data_type
*save
= OASYS_DATA(abfd
);
363 boolean had_usefull
= false;
365 abfd
->tdata
.oasys_obj_data
= 0;
366 oasys_mkobject(abfd
);
367 oasys
= OASYS_DATA(abfd
);
368 memset((PTR
)oasys
->sections
, 0xff, sizeof(oasys
->sections
));
370 /* Point to the start of the file */
371 bfd_seek(abfd
, (file_ptr
)0, SEEK_SET
);
372 oasys
->symbol_string_length
= 0;
373 /* Inspect the records, but only keep the section info -
374 remember the size of the symbols
376 oasys
->first_data_record
= 0;
378 oasys_record_union_type record
;
379 oasys_read_record(abfd
, &record
);
380 if ((size_t)record
.header
.length
< (size_t)sizeof(record
.header
))
384 switch ((oasys_record_enum_type
)(record
.header
.type
)) {
385 case oasys_record_is_header_enum
:
388 case oasys_record_is_symbol_enum
:
389 case oasys_record_is_local_enum
:
390 /* Count symbols and remember their size for a future malloc */
392 oasys
->symbol_string_length
+= 1 + oasys_string_length(&record
);
395 case oasys_record_is_section_enum
:
399 unsigned int section_number
;
400 if (record
.section
.header
.length
!= sizeof(record
.section
))
404 buffer
= bfd_alloc(abfd
, 3);
405 section_number
= record
.section
.relb
& RELOCATION_SECT_BITS
;
406 sprintf(buffer
,"%u", section_number
);
407 s
= bfd_make_section(abfd
,buffer
);
408 oasys
->sections
[section_number
] = s
;
409 switch (record
.section
.relb
& RELOCATION_TYPE_BITS
) {
410 case RELOCATION_TYPE_ABS
:
411 case RELOCATION_TYPE_REL
:
413 case RELOCATION_TYPE_UND
:
414 case RELOCATION_TYPE_COM
:
418 s
->_raw_size
= bfd_h_get_32(abfd
, (bfd_byte
*) & record
.section
.value
[0]) ;
419 s
->vma
= bfd_h_get_32(abfd
, (bfd_byte
*)&record
.section
.vma
[0]);
424 case oasys_record_is_data_enum
:
425 oasys
->first_data_record
= bfd_tell(abfd
) - record
.header
.length
;
426 case oasys_record_is_debug_enum
:
427 case oasys_record_is_module_enum
:
428 case oasys_record_is_named_section_enum
:
429 case oasys_record_is_end_enum
:
430 if (had_usefull
== false) goto fail
;
437 oasys
->symbols
= (asymbol
*)NULL
;
439 Oasys support several architectures, but I can't see a simple way
440 to discover which one is in a particular file - we'll guess
442 bfd_default_set_arch_mach(abfd
, bfd_arch_m68k
, 0);
443 if (abfd
->symcount
!= 0) {
444 abfd
->flags
|= HAS_SYMS
;
448 We don't know if a section has data until we've read it..
451 oasys_slurp_section_data(abfd
);
457 (void) bfd_release(abfd
, oasys
);
458 abfd
->tdata
.oasys_obj_data
= save
;
459 return (bfd_target
*)NULL
;
464 DEFUN(oasys_print_symbol
,(ignore_abfd
, afile
, symbol
, how
),
468 bfd_print_symbol_type how
)
470 FILE *file
= (FILE *)afile
;
473 case bfd_print_symbol_name
:
474 case bfd_print_symbol_more
:
475 fprintf(file
,"%s", symbol
->name
);
477 case bfd_print_symbol_all
:
478 case bfd_print_symbol_nm
:
480 CONST
char *section_name
= symbol
->section
== (asection
*)NULL
?
481 (CONST
char *) "*abs" : symbol
->section
->name
;
483 bfd_print_symbol_vandf((PTR
)file
,symbol
);
485 fprintf(file
," %-5s %s",
493 The howto table is build using the top two bits of a reloc byte to
494 index into it. The bits are PCREL,WORD/LONG
496 static reloc_howto_type howto_table
[]=
499 HOWTO( 0, 0, 1, 16, false,0, true,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false),
500 HOWTO( 0, 0, 2, 32, false,0, true,true,0,"abs32",true,0xffffffff, 0xffffffff,false),
501 HOWTO( 0, 0, 1, 16, true,0, true,true,0,"pcrel16",true,0x0000ffff, 0x0000ffff,false),
502 HOWTO( 0, 0, 2, 32, true,0, true,true,0,"pcrel32",true,0xffffffff, 0xffffffff,false)
505 /* Read in all the section data and relocation stuff too */
507 DEFUN(oasys_slurp_section_data
,(abfd
),
510 oasys_record_union_type record
;
511 oasys_data_type
*data
= OASYS_DATA(abfd
);
514 oasys_per_section_type
*per
;
518 /* See if the data has been slurped already .. */
519 for (s
= abfd
->sections
; s
!= (asection
*)NULL
; s
= s
->next
) {
520 per
= oasys_per_section(s
);
521 if (per
->initialized
== true)
525 if (data
->first_data_record
== 0) return true;
527 bfd_seek(abfd
, data
->first_data_record
, SEEK_SET
);
529 oasys_read_record(abfd
, &record
);
530 switch (record
.header
.type
)
532 case oasys_record_is_header_enum
:
534 case oasys_record_is_data_enum
:
537 uint8e_type
*src
= record
.data
.data
;
538 uint8e_type
*end_src
= ((uint8e_type
*)&record
) +
539 record
.header
.length
;
542 bfd_byte
*dst_base_ptr
;
545 data
->sections
[record
.data
.relb
& RELOCATION_SECT_BITS
];
547 per
= oasys_per_section(section
);
550 if (per
->initialized
== false)
552 per
->data
= (bfd_byte
*) bfd_zalloc(abfd
, section
->_raw_size
);
553 per
->reloc_tail_ptr
= (oasys_reloc_type
**)&(section
->relocation
);
554 per
->had_vma
= false;
555 per
->initialized
= true;
556 section
->reloc_count
= 0;
557 section
->flags
= SEC_ALLOC
;
560 dst_offset
= bfd_h_get_32(abfd
, record
.data
.addr
) ;
561 if (per
->had_vma
== false) {
562 /* Take the first vma we see as the base */
564 section
->vma
= dst_offset
;
569 dst_offset
-= section
->vma
;
572 dst_base_ptr
= oasys_per_section(section
)->data
;
573 dst_ptr
= oasys_per_section(section
)->data
+
577 section
->flags
|= SEC_LOAD
| SEC_HAS_CONTENTS
;
579 while (src
< end_src
) {
580 uint8e_type mod_byte
= *src
++;
581 uint32_type gap
= end_src
- src
;
584 if (mod_byte
== 0 && gap
>= 8) {
597 for (relbit
= 1; count
-- != 0 && src
< end_src
; relbit
<<=1)
599 if (relbit
& mod_byte
)
601 uint8e_type reloc
= *src
;
602 /* This item needs to be relocated */
603 switch (reloc
& RELOCATION_TYPE_BITS
) {
604 case RELOCATION_TYPE_ABS
:
608 case RELOCATION_TYPE_REL
:
610 /* Relocate the item relative to the section */
611 oasys_reloc_type
*r
=
614 sizeof(oasys_reloc_type
));
615 *(per
->reloc_tail_ptr
) = r
;
616 per
->reloc_tail_ptr
= &r
->next
;
617 r
->next
= (oasys_reloc_type
*)NULL
;
618 /* Reference to undefined symbol */
620 /* There is no symbol */
622 /* Work out the howto */
626 data
->sections
[reloc
&
627 RELOCATION_SECT_BITS
];
630 r
->relent
.section
->vma
;
632 r
->relent
.address
= dst_ptr
- dst_base_ptr
;
633 r
->relent
.howto
= &howto_table
[reloc
>>6];
634 r
->relent
.sym_ptr_ptr
= (asymbol
**)NULL
;
635 section
->reloc_count
++;
637 /* Fake up the data to look like it's got the -ve pc in it, this makes
638 it much easier to convert into other formats. This is done by
641 if (r
->relent
.howto
->pc_relative
== true) {
642 r
->relent
.addend
-= dst_ptr
- dst_base_ptr
;
650 case RELOCATION_TYPE_UND
:
652 oasys_reloc_type
*r
=
655 sizeof(oasys_reloc_type
));
656 *(per
->reloc_tail_ptr
) = r
;
657 per
->reloc_tail_ptr
= &r
->next
;
658 r
->next
= (oasys_reloc_type
*)NULL
;
659 /* Reference to undefined symbol */
661 /* Get symbol number */
662 r
->symbol
= (src
[0]<<8) | src
[1];
663 /* Work out the howto */
667 r
->relent
.section
= (asection
670 r
->relent
.addend
= 0;
671 r
->relent
.address
= dst_ptr
- dst_base_ptr
;
672 r
->relent
.howto
= &howto_table
[reloc
>>6];
673 r
->relent
.sym_ptr_ptr
= (asymbol
**)NULL
;
674 section
->reloc_count
++;
677 /* Fake up the data to look like it's got the -ve pc in it, this makes
678 it much easier to convert into other formats. This is done by
681 if (r
->relent
.howto
->pc_relative
== true) {
682 r
->relent
.addend
-= dst_ptr
- dst_base_ptr
;
689 case RELOCATION_TYPE_COM
:
699 case oasys_record_is_local_enum
:
700 case oasys_record_is_symbol_enum
:
701 case oasys_record_is_section_enum
:
714 bfd_error_vector_type bfd_error_vector
;
717 DEFUN(oasys_new_section_hook
,(abfd
, newsect
),
721 newsect
->used_by_bfd
= (PTR
)
722 bfd_alloc(abfd
, sizeof(oasys_per_section_type
));
723 oasys_per_section( newsect
)->data
= (bfd_byte
*)NULL
;
724 oasys_per_section(newsect
)->section
= newsect
;
725 oasys_per_section(newsect
)->offset
= 0;
726 oasys_per_section(newsect
)->initialized
= false;
727 newsect
->alignment_power
= 1;
728 /* Turn the section string into an index */
730 sscanf(newsect
->name
,"%u", &newsect
->target_index
);
737 DEFUN(oasys_get_reloc_upper_bound
, (abfd
, asect
),
741 oasys_slurp_section_data(abfd
);
742 return (asect
->reloc_count
+1) * sizeof(arelent
*);
746 DEFUN(oasys_get_section_contents
,(abfd
, section
, location
, offset
, count
),
753 oasys_per_section_type
*p
= (oasys_per_section_type
*) section
->used_by_bfd
;
754 oasys_slurp_section_data(abfd
);
755 if (p
->initialized
== false)
757 (void) memset(location
, 0, (int)count
);
761 (void) memcpy(location
,(PTR
)( p
->data
+ offset
), (int)count
);
768 DEFUN(oasys_canonicalize_reloc
,(ignore_abfd
, section
, relptr
, symbols
),
774 unsigned int reloc_count
= 0;
775 oasys_reloc_type
*src
= (oasys_reloc_type
*)(section
->relocation
);
776 while (src
!= (oasys_reloc_type
*)NULL
) {
780 if (src
->relent
.section
== (asection
*)NULL
)
782 src
->relent
.sym_ptr_ptr
= symbols
+ src
->symbol
;
786 *relptr
++ = &src
->relent
;
790 *relptr
= (arelent
*)NULL
;
791 return section
->reloc_count
= reloc_count
;
800 /* Calculate the checksum and write one record */
802 DEFUN(oasys_write_record
,(abfd
, type
, record
, size
),
804 CONST oasys_record_enum_type type AND
805 oasys_record_union_type
*record AND
811 record
->header
.length
= size
;
812 record
->header
.type
= (int)type
;
813 record
->header
.check_sum
= 0;
814 record
->header
.fill
= 0;
815 ptr
= &record
->pad
[0];
817 for (i
= 0; i
< size
; i
++) {
820 record
->header
.check_sum
= 0xff & (- checksum
);
821 bfd_write((PTR
)record
, 1, size
, abfd
);
825 /* Write out all the symbols */
827 DEFUN(oasys_write_syms
, (abfd
),
831 asymbol
**generic
= bfd_get_outsymbols(abfd
);
832 unsigned int index
= 0;
833 for (count
= 0; count
< bfd_get_symcount(abfd
); count
++) {
835 oasys_symbol_record_type symbol
;
836 asymbol
* CONST g
= generic
[count
];
838 CONST
char *src
= g
->name
;
839 char *dst
= symbol
.name
;
842 if (g
->section
== & bfd_com_section
) {
843 symbol
.relb
= RELOCATION_TYPE_COM
;
844 bfd_h_put_16(abfd
, index
, (uint8e_type
*)(&symbol
.refno
[0]));
847 else if (g
->section
== & bfd_abs_section
) {
848 symbol
.relb
= RELOCATION_TYPE_ABS
;
849 bfd_h_put_16(abfd
, 0, (uint8e_type
*)(&symbol
.refno
[0]));
852 else if (g
->section
== &bfd_und_section
) {
853 symbol
.relb
= RELOCATION_TYPE_UND
;
854 bfd_h_put_16(abfd
, index
, (uint8e_type
*)(&symbol
.refno
[0]));
855 /* Overload the value field with the output index number */
858 else if (g
->flags
& BSF_DEBUGGING
) {
863 if (g
->section
== (asection
*)NULL
) {
864 /* Sometime, the oasys tools give out a symbol with illegal
865 bits in it, we'll output it in the same broken way */
867 symbol
.relb
= RELOCATION_TYPE_REL
| 0;
870 symbol
.relb
= RELOCATION_TYPE_REL
|g
->section
->output_section
->target_index
;
872 bfd_h_put_16(abfd
, 0, (uint8e_type
*)(&symbol
.refno
[0]));
879 bfd_h_put_32(abfd
, g
->value
, (bfd_byte
*) symbol
.value
);
882 if (g
->flags
& BSF_LOCAL
) {
883 oasys_write_record(abfd
,
884 oasys_record_is_local_enum
,
885 (oasys_record_union_type
*) &symbol
,
886 offsetof(oasys_symbol_record_type
, name
[0]) + l
);
889 oasys_write_record(abfd
,
890 oasys_record_is_symbol_enum
,
891 (oasys_record_union_type
*) &symbol
,
892 offsetof(oasys_symbol_record_type
, name
[0]) + l
);
899 /* Write a section header for each section */
901 DEFUN(oasys_write_sections
, (abfd
),
905 static oasys_section_record_type out
= {0};
907 for (s
= abfd
->sections
; s
!= (asection
*)NULL
; s
= s
->next
) {
908 if (!isdigit(s
->name
[0]))
910 bfd_error_vector
.nonrepresentable_section(abfd
,
913 out
.relb
= RELOCATION_TYPE_REL
| s
->target_index
;
914 bfd_h_put_32(abfd
, s
->_cooked_size
, (bfd_byte
*) out
.value
);
915 bfd_h_put_32(abfd
, s
->vma
, (bfd_byte
*) out
.vma
);
917 oasys_write_record(abfd
,
918 oasys_record_is_section_enum
,
919 (oasys_record_union_type
*) &out
,
925 DEFUN(oasys_write_header
, (abfd
),
928 /* Create and write the header */
929 oasys_header_record_type r
;
930 size_t length
= strlen(abfd
->filename
);
931 if (length
> (size_t)sizeof(r
.module_name
)) {
932 length
= sizeof(r
.module_name
);
935 (void)memcpy(r
.module_name
,
938 (void)memset(r
.module_name
+ length
,
940 sizeof(r
.module_name
) - length
);
942 r
.version_number
= OASYS_VERSION_NUMBER
;
943 r
.rev_number
= OASYS_REV_NUMBER
;
944 oasys_write_record(abfd
,
945 oasys_record_is_header_enum
,
946 (oasys_record_union_type
*)&r
,
947 offsetof(oasys_header_record_type
, description
[0]));
954 DEFUN(oasys_write_end
,(abfd
),
957 oasys_end_record_type end
;
958 uint8e_type null
= 0;
959 end
.relb
= RELOCATION_TYPE_ABS
;
960 bfd_h_put_32(abfd
, abfd
->start_address
, (bfd_byte
*)end
.entry
);
961 bfd_h_put_16(abfd
, 0, (bfd_byte
*)end
.fill
);
963 oasys_write_record(abfd
,
964 oasys_record_is_end_enum
,
965 (oasys_record_union_type
*)&end
,
967 bfd_write((PTR
)&null
, 1, 1, abfd
);
975 arelent
*a
= *((arelent
**)ap
);
976 arelent
*b
= *((arelent
**)bp
);
977 return a
->address
- b
->address
;
985 DEFUN(oasys_write_data
, (abfd
),
989 for (s
= abfd
->sections
; s
!= (asection
*)NULL
; s
= s
->next
) {
990 if (s
->flags
& SEC_LOAD
) {
991 uint8e_type
*raw_data
= oasys_per_section(s
)->data
;
992 oasys_data_record_type processed_data
;
993 bfd_size_type current_byte_index
= 0;
994 unsigned int relocs_to_go
= s
->reloc_count
;
995 arelent
**p
= s
->orelocation
;
996 if (s
->reloc_count
!= 0) {
997 /* Sort the reloc records so it's easy to insert the relocs into the
1000 qsort(s
->orelocation
,
1005 current_byte_index
= 0;
1006 processed_data
.relb
= s
->target_index
| RELOCATION_TYPE_REL
;
1008 while (current_byte_index
< s
->_cooked_size
)
1010 /* Scan forwards by eight bytes or however much is left and see if
1011 there are any relocations going on */
1012 uint8e_type
*mod
= &processed_data
.data
[0];
1013 uint8e_type
*dst
= &processed_data
.data
[1];
1016 unsigned int long_length
= 128;
1019 bfd_h_put_32(abfd
, s
->vma
+ current_byte_index
, processed_data
.addr
);
1020 if ((size_t)(long_length
+ current_byte_index
) > (size_t)(s
->_cooked_size
)) {
1021 long_length
= s
->_cooked_size
- current_byte_index
;
1023 while (long_length
> 0 && (dst
- (uint8e_type
*)&processed_data
< 128)) {
1025 unsigned int length
= long_length
;
1030 for (i
= 0; i
< length
; i
++) {
1031 if (relocs_to_go
!= 0) {
1033 reloc_howto_type
*CONST how
=r
->howto
;
1034 /* There is a relocation, is it for this byte ? */
1035 if (r
->address
== current_byte_index
) {
1036 uint8e_type rel_byte
;
1041 if(how
->pc_relative
) {
1044 /* Also patch the raw data so that it doesn't have
1045 the -ve stuff any more */
1046 if (how
->size
!= 2) {
1048 bfd_get_16(abfd
,raw_data
) +
1049 current_byte_index
, raw_data
);
1054 bfd_get_32(abfd
,raw_data
) +
1055 current_byte_index
, raw_data
);
1061 if (how
->size
==2) {
1065 /* Is this a section relative relocation, or a symbol
1066 relative relocation ? */
1070 if (r
->section
!= (asection
*)NULL
)
1072 /* The relent has a section attached, so it must be section
1074 rel_byte
|= RELOCATION_TYPE_REL
;
1075 rel_byte
|= r
->section
->output_section
->target_index
;
1081 asymbol
*p
= *(r
->sym_ptr_ptr
);
1083 /* If this symbol has a section attached, then it
1084 has already been resolved. Change from a symbol
1085 ref to a section ref */
1086 if(p
->section
!= (asection
*)NULL
) {
1087 rel_byte
|= RELOCATION_TYPE_REL
;
1089 p
->section
->output_section
->target_index
;
1093 rel_byte
|= RELOCATION_TYPE_UND
;
1097 /* Next two bytes are a symbol index - we can get
1098 this from the symbol value which has been zapped
1099 into the symbol index in the table when the
1100 symbol table was written
1102 *dst
++ = p
->value
>> 8;
1109 /* If this is coming from an unloadable section then copy
1111 if (raw_data
== (uint8e_type
*)NULL
) {
1115 *dst
++ = *raw_data
++;
1117 current_byte_index
++;
1120 long_length
-= length
;
1123 oasys_write_record(abfd
,
1124 oasys_record_is_data_enum
,
1125 (oasys_record_union_type
*)&processed_data
,
1126 dst
- (uint8e_type
*)&processed_data
);
1133 DEFUN(oasys_write_object_contents
, (abfd
),
1136 oasys_write_header(abfd
);
1137 oasys_write_syms(abfd
);
1138 oasys_write_sections(abfd
);
1139 oasys_write_data(abfd
);
1140 oasys_write_end(abfd
);
1147 /** exec and core file sections */
1149 /* set section contents is complicated with OASYS since the format is
1150 * not a byte image, but a record stream.
1153 DEFUN(oasys_set_section_contents
,(abfd
, section
, location
, offset
, count
),
1158 bfd_size_type count
)
1161 if (oasys_per_section(section
)->data
== (bfd_byte
*)NULL
)
1163 oasys_per_section(section
)->data
=
1164 (bfd_byte
*)(bfd_alloc(abfd
,section
->_cooked_size
));
1166 (void) memcpy((PTR
)(oasys_per_section(section
)->data
+ offset
),
1175 /* Native-level interface to symbols. */
1177 /* We read the symbols into a buffer, which is discarded when this
1178 function exits. We read the strings into a buffer large enough to
1179 hold them all plus all the cached symbol entries. */
1182 DEFUN(oasys_make_empty_symbol
,(abfd
),
1186 oasys_symbol_type
*new =
1187 (oasys_symbol_type
*)bfd_zalloc (abfd
, sizeof (oasys_symbol_type
));
1188 new->symbol
.the_bfd
= abfd
;
1189 return &new->symbol
;
1196 /* User should have checked the file flags; perhaps we should return
1197 BFD_NO_MORE_SYMBOLS if there are none? */
1200 oasys_openr_next_archived_file(arch
, prev
)
1204 oasys_ar_data_type
*ar
= OASYS_AR_DATA(arch
);
1205 oasys_module_info_type
*p
;
1206 /* take the next one from the arch state, or reset */
1207 if (prev
== (bfd
*)NULL
) {
1208 /* Reset the index - the first two entries are bogus*/
1209 ar
->module_index
= 0;
1212 p
= ar
->module
+ ar
->module_index
;
1215 if (ar
->module_index
<= ar
->module_count
) {
1216 if (p
->abfd
== (bfd
*)NULL
) {
1217 p
->abfd
= _bfd_create_empty_archive_element_shell(arch
);
1218 p
->abfd
->origin
= p
->pos
;
1219 p
->abfd
->filename
= p
->name
;
1221 /* Fixup a pointer to this element for the member */
1222 p
->abfd
->arelt_data
= (PTR
)p
;
1227 bfd_error
= no_more_archived_files
;
1233 oasys_find_nearest_line(abfd
,
1244 char **filename_ptr
;
1245 char **functionname_ptr
;
1246 unsigned int *line_ptr
;
1253 DEFUN(oasys_generic_stat_arch_elt
,(abfd
, buf
),
1257 oasys_module_info_type
*mod
= (oasys_module_info_type
*) abfd
->arelt_data
;
1258 if (mod
== (oasys_module_info_type
*)NULL
) {
1259 bfd_error
= invalid_operation
;
1263 buf
->st_size
= mod
->size
;
1264 buf
->st_mode
= 0666;
1270 DEFUN(oasys_sizeof_headers
,(abfd
, exec
),
1277 #define oasys_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
1278 #define oasys_core_file_failing_signal (int (*)())bfd_0
1279 #define oasys_core_file_matches_executable_p 0
1280 #define oasys_slurp_armap bfd_true
1281 #define oasys_slurp_extended_name_table bfd_true
1282 #define oasys_truncate_arname (void (*)())bfd_nullvoidptr
1283 #define oasys_write_armap 0
1284 #define oasys_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
1285 #define oasys_close_and_cleanup bfd_generic_close_and_cleanup
1286 #define oasys_set_arch_mach bfd_default_set_arch_mach
1287 #define oasys_bfd_debug_info_start bfd_void
1288 #define oasys_bfd_debug_info_end bfd_void
1289 #define oasys_bfd_debug_info_accumulate (FOO(void, (*), (bfd *, asection *)))bfd_void
1290 #define oasys_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
1293 bfd_target oasys_vec
=
1296 bfd_target_oasys_flavour
,
1297 true, /* target byte order */
1298 true, /* target headers byte order */
1299 (HAS_RELOC
| EXEC_P
| /* object flags */
1300 HAS_LINENO
| HAS_DEBUG
|
1301 HAS_SYMS
| HAS_LOCALS
| DYNAMIC
| WP_TEXT
| D_PAGED
),
1302 (SEC_CODE
|SEC_DATA
|SEC_ROM
|SEC_HAS_CONTENTS
1303 |SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
1304 ' ', /* ar_pad_char */
1305 16, /* ar_max_namelen */
1306 1, /* minimum alignment */
1307 _do_getb64
, _do_putb64
, _do_getb32
, _do_putb32
, _do_getb16
, _do_putb16
, /* data */
1308 _do_getb64
, _do_putb64
, _do_getb32
, _do_putb32
, _do_getb16
, _do_putb16
, /* hdrs */
1311 oasys_object_p
, /* bfd_check_format */
1315 { /* bfd_set_format */
1318 _bfd_generic_mkarchive
,
1321 { /* bfd_write_contents */
1323 oasys_write_object_contents
,
1324 _bfd_write_archive_contents
,