1 /* bfd backend for oasys objects.
2 Written by Steve Chamberlain of Cygnus Support <steve@cygnus.com> */
4 /* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Diddler.
8 BFD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 1, or (at your option)
13 BFD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with BFD; see the file COPYING. If not, write to
20 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #define UNDERSCORE_HACK 1
25 #define offsetof(type, identifier) (size_t) &(((type *) 0)->identifier)
34 DEFUN(oasys_read_record,(abfd, record),
36 oasys_record_union_type *record)
39 bfd_read((PTR)record, 1, sizeof(record->header), abfd);
41 if ((size_t) record->header.length <= (size_t) sizeof (record->header))
43 bfd_read((PTR)(((char *)record )+ sizeof(record->header)),
44 1, record->header.length - sizeof(record->header),
48 DEFUN(oasys_string_length,(record),
49 oasys_record_union_type *record)
51 return record->header.length
52 - ((char *)record->symbol.name - (char *)record);
55 /*****************************************************************************/
59 Slurp the symbol table by reading in all the records at the start file
60 till we get to the first section record.
62 We'll sort the symbolss into two lists, defined and undefined. The
63 undefined symbols will be placed into the table according to their
66 We do this by placing all undefined symbols at the front of the table
67 moving in, and the defined symbols at the end of the table moving back.
72 DEFUN(oasys_slurp_symbol_table,(abfd),
75 oasys_record_union_type record;
76 oasys_data_type *data = oasys_data(abfd);
78 asymbol *dest_defined;
83 if (data->symbols != (asymbol *)NULL) {
86 /* Buy enough memory for all the symbols and all the names */
88 (asymbol *)bfd_alloc(abfd, sizeof(asymbol) * abfd->symcount);
89 #ifdef UNDERSCORE_HACK
90 /* buy 1 more char for each symbol to keep the underscore in*/
91 data->strings = bfd_alloc(abfd, data->symbol_string_length +
94 data->strings = bfd_alloc(abfd, data->symbol_string_length);
98 dest_defined = data->symbols + abfd->symcount -1;
100 string_ptr = data->strings;
101 bfd_seek(abfd, (file_ptr)0, SEEK_SET);
104 oasys_read_record(abfd, &record);
105 switch (record.header.type) {
106 case oasys_record_is_header_enum:
108 case oasys_record_is_local_enum:
109 case oasys_record_is_symbol_enum:
111 int flag = record.header.type == oasys_record_is_local_enum ?
112 (BSF_LOCAL) : (BSF_GLOBAL | BSF_EXPORT);
115 size_t length = oasys_string_length(&record);
116 switch (record.symbol.relb & RELOCATION_TYPE_BITS) {
117 case RELOCATION_TYPE_ABS:
118 dest = dest_defined--;
120 dest->flags = BSF_ABSOLUTE | flag;
122 case RELOCATION_TYPE_REL:
123 dest = dest_defined--;
125 oasys_data(abfd)->sections[record.symbol.relb &
126 RELOCATION_SECT_BITS];
127 if (record.header.type == oasys_record_is_local_enum)
129 dest->flags = BSF_LOCAL;
136 case RELOCATION_TYPE_UND:
137 dest = data->symbols + bfd_h_getshort(abfd, (bfd_byte *)&record.symbol.refno[0]);
138 dest->section = (asection *)NULL;
139 dest->flags = BSF_UNDEFINED;
141 case RELOCATION_TYPE_COM:
142 dest = dest_defined--;
143 dest->name = string_ptr;
144 dest->the_bfd = abfd;
146 dest->section = (asection *)NULL;
147 dest->flags = BSF_FORT_COMM;
150 dest->name = string_ptr;
151 dest->the_bfd = abfd;
152 dest->udata = (PTR)NULL;
153 dest->value = bfd_h_getlong(abfd, &record.symbol.value[0]);
155 #ifdef UNDERSCORE_HACK
156 if (record.symbol.name[0] != '_') {
161 memcpy(string_ptr, record.symbol.name, length);
164 string_ptr[length] =0;
165 string_ptr += length +1;
177 DEFUN(oasys_get_symtab_upper_bound,(abfd),
180 oasys_slurp_symbol_table (abfd);
182 return (abfd->symcount+1) * (sizeof (oasys_symbol_type *));
188 extern bfd_target oasys_vec;
191 DEFUN(oasys_get_symtab,(abfd, location),
196 unsigned int counter ;
197 if (oasys_slurp_symbol_table(abfd) == false) {
200 symbase = oasys_data(abfd)->symbols;
201 for (counter = 0; counter < abfd->symcount; counter++) {
202 *(location++) = symbase++;
205 return abfd->symcount;
208 /***********************************************************************
211 #define swap(x) x = bfd_h_get_x(abfd, &x);
213 DEFUN(oasys_archive_p,(abfd),
216 oasys_archive_header_type header;
219 bfd_seek(abfd, (file_ptr) 0, false);
222 bfd_read((PTR)&header, 1, sizeof(header), abfd);
225 swap(header.version);
226 swap(header.mod_count);
227 swap(header.mod_tbl_offset);
228 swap(header.sym_tbl_size);
229 swap(header.sym_count);
230 swap(header.sym_tbl_offset);
231 swap(header.xref_count);
232 swap(header.xref_lst_offset);
235 There isn't a magic number in an Oasys archive, so the best we
236 can do to verify reasnableness is to make sure that the values in
237 the header are too weird
240 if (header.version>10000 ||
241 header.mod_count>10000 ||
242 header.sym_count>100000 ||
243 header.xref_count > 100000) return (bfd_target *)NULL;
246 That all worked, lets buy the space for the header and read in
250 oasys_ar_data_type *ar =
251 (oasys_ar_data_type*) bfd_alloc(abfd, sizeof(oasys_ar_data_type));
254 oasys_module_info_type *module =
255 (oasys_module_info_type*)
256 bfd_alloc(abfd, sizeof(oasys_module_info_type) * header.mod_count);
258 oasys_module_table_type record;
262 ar->module_count = header.mod_count;
264 bfd_seek(abfd , header.mod_tbl_offset, SEEK_SET);
265 for (i = 0; i < header.mod_count; i++) {
266 bfd_read((PTR)&record, 1, sizeof(record), abfd);
267 swap(record.mod_size);
268 swap(record.file_offset);
269 swap(record.mod_name_length);
270 module[i].name = bfd_alloc(abfd,record.mod_name_length+1);
272 bfd_read(module[i].name, 1, record.mod_name_length +1, abfd);
273 /* SKip some stuff */
274 bfd_seek(abfd, record.dep_count * sizeof(int32_type),
277 module[i].size = record.mod_size;
278 module[i].pos = record.file_offset;
286 DEFUN(oasys_mkobject,(abfd),
289 oasys_data_type *oasys;
292 (oasys_data_type*)bfd_alloc(abfd, sizeof(oasys_data_type)));
293 oasys = oasys_data(abfd);
299 DEFUN(oasys_object_p,(abfd),
302 oasys_data_type *oasys;
303 oasys_data_type *save = oasys_data(abfd);
305 boolean had_usefull = false;
308 oasys_mkobject(abfd);
309 oasys = oasys_data(abfd);
310 memset((PTR)oasys->sections, 0xff, sizeof(oasys->sections));
312 /* Point to the start of the file */
313 bfd_seek(abfd, (file_ptr)0, SEEK_SET);
314 oasys->symbol_string_length = 0;
315 /* Inspect the records, but only keep the section info -
316 remember the size of the symbols
318 oasys->first_data_record = 0;
320 oasys_record_union_type record;
321 oasys_read_record(abfd, &record);
322 if ((size_t)record.header.length < (size_t)sizeof(record.header))
326 switch ((oasys_record_enum_type)(record.header.type)) {
327 case oasys_record_is_header_enum:
330 case oasys_record_is_symbol_enum:
331 case oasys_record_is_local_enum:
332 /* Count symbols and remember their size for a future malloc */
334 oasys->symbol_string_length += 1 + oasys_string_length(&record);
337 case oasys_record_is_section_enum:
341 unsigned int section_number;
342 if (record.section.header.length != sizeof(record.section))
346 buffer = bfd_alloc(abfd, 3);
347 section_number= record.section.relb & RELOCATION_SECT_BITS;
348 sprintf(buffer,"%u", section_number);
349 s = bfd_make_section(abfd,buffer);
350 oasys->sections[section_number] = s;
351 switch (record.section.relb & RELOCATION_TYPE_BITS) {
352 case RELOCATION_TYPE_ABS:
353 case RELOCATION_TYPE_REL:
355 case RELOCATION_TYPE_UND:
356 case RELOCATION_TYPE_COM:
360 s->size = bfd_h_getlong(abfd, & record.section.value[0]) ;
361 s->vma = bfd_h_getlong(abfd, &record.section.vma[0]);
362 s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
366 case oasys_record_is_data_enum:
367 oasys->first_data_record = bfd_tell(abfd) - record.header.length;
368 case oasys_record_is_debug_enum:
369 case oasys_record_is_module_enum:
370 case oasys_record_is_named_section_enum:
371 case oasys_record_is_end_enum:
372 if (had_usefull == false) goto fail;
379 oasys->symbols = (asymbol *)NULL;
381 Oasys support several architectures, but I can't see a simple way
382 to discover which one is in a particular file - we'll guess
384 abfd->obj_arch = bfd_arch_m68k;
385 abfd->obj_machine =0;
386 if (abfd->symcount != 0) {
387 abfd->flags |= HAS_SYMS;
392 (void) bfd_release(abfd, oasys);
393 oasys_data(abfd) = save;
394 return (bfd_target *)NULL;
399 DEFUN(oasys_print_symbol,(ignore_abfd, file, symbol, how),
403 bfd_print_symbol_enum_type how)
406 case bfd_print_symbol_name_enum:
407 case bfd_print_symbol_type_enum:
408 fprintf(file,"%s", symbol->name);
410 case bfd_print_symbol_all_enum:
412 CONST char *section_name = symbol->section == (asection *)NULL ?
413 "*abs" : symbol->section->name;
415 bfd_print_symbol_vandf((PTR)file,symbol);
417 fprintf(file," %-5s %s",
425 The howto table is build using the top two bits of a reloc byte to
426 index into it. The bits are PCREL,WORD/LONG
428 static reloc_howto_type howto_table[]=
431 HOWTO( 0, 0, 1, 16, false,0, true,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false),
432 HOWTO( 0, 0, 2, 32, false,0, true,true,0,"abs32",true,0xffffffff, 0xffffffff,false),
433 HOWTO( 0, 0, 1, 16, true,0, true,true,0,"pcrel16",true,0x0000ffff, 0x0000ffff,false),
434 HOWTO( 0, 0, 2, 32, true,0, true,true,0,"pcrel32",true,0xffffffff, 0xffffffff,false)
437 /* Read in all the section data and relocation stuff too */
439 DEFUN(oasys_slurp_section_data,(abfd),
442 oasys_record_union_type record;
443 oasys_data_type *data = oasys_data(abfd);
446 oasys_per_section_type *per ;
450 /* Buy enough memory for all the section data and relocations */
451 for (s = abfd->sections; s != (asection *)NULL; s= s->next) {
452 per = oasys_per_section(s);
453 if (per->data != (bfd_byte*)NULL) return true;
454 per->data = (bfd_byte *) bfd_alloc(abfd, s->size);
455 per->reloc_tail_ptr = (oasys_reloc_type **)&(s->relocation);
456 per->had_vma = false;
460 if (data->first_data_record == 0) return true;
461 bfd_seek(abfd, data->first_data_record, SEEK_SET);
463 oasys_read_record(abfd, &record);
464 switch (record.header.type) {
465 case oasys_record_is_header_enum:
467 case oasys_record_is_data_enum:
470 uint8e_type *src = record.data.data;
471 uint8e_type *end_src = ((uint8e_type *)&record) +
472 record.header.length;
475 bfd_byte *dst_base_ptr ;
478 data->sections[record.data.relb & RELOCATION_SECT_BITS];
480 per = oasys_per_section(section);
481 dst_offset = bfd_h_getlong(abfd, record.data.addr) ;
482 if (per->had_vma == false) {
483 /* Take the first vma we see as the base */
485 section->vma = dst_offset;
490 dst_offset -= section->vma;
493 dst_base_ptr = oasys_per_section(section)->data;
494 dst_ptr = oasys_per_section(section)->data +
497 while (src < end_src) {
498 uint32_type gap = end_src - src -1;
499 uint8e_type mod_byte = *src++;
501 if (mod_byte == 0 && gap >= 8) {
514 for (relbit = 1; count-- != 0 && gap != 0; gap --, relbit <<=1)
516 if (relbit & mod_byte)
518 uint8e_type reloc = *src;
519 /* This item needs to be relocated */
520 switch (reloc & RELOCATION_TYPE_BITS) {
521 case RELOCATION_TYPE_ABS:
525 case RELOCATION_TYPE_REL:
527 /* Relocate the item relative to the section */
528 oasys_reloc_type *r =
531 sizeof(oasys_reloc_type));
532 *(per->reloc_tail_ptr) = r;
533 per->reloc_tail_ptr = &r->next;
534 r->next= (oasys_reloc_type *)NULL;
535 /* Reference to undefined symbol */
537 /* There is no symbol */
539 /* Work out the howto */
541 data->sections[reloc & RELOCATION_SECT_BITS];
542 r->relent.addend = - r->relent.section->vma;
543 r->relent.address = dst_ptr - dst_base_ptr;
544 r->relent.howto = &howto_table[reloc>>6];
545 r->relent.sym_ptr_ptr = (asymbol **)NULL;
546 section->reloc_count++;
548 /* Fake up the data to look like it's got the -ve pc in it, this makes
549 it much easier to convert into other formats. This is done by
552 if (r->relent.howto->pc_relative == true) {
553 r->relent.addend -= dst_ptr - dst_base_ptr;
561 case RELOCATION_TYPE_UND:
563 oasys_reloc_type *r =
566 sizeof(oasys_reloc_type));
567 *(per->reloc_tail_ptr) = r;
568 per->reloc_tail_ptr = &r->next;
569 r->next= (oasys_reloc_type *)NULL;
570 /* Reference to undefined symbol */
572 /* Get symbol number */
573 r->symbol = (src[0]<<8) | src[1];
574 /* Work out the howto */
575 r->relent.section = (asection *)NULL;
576 r->relent.addend = 0;
577 r->relent.address = dst_ptr - dst_base_ptr;
578 r->relent.howto = &howto_table[reloc>>6];
579 r->relent.sym_ptr_ptr = (asymbol **)NULL;
580 section->reloc_count++;
583 /* Fake up the data to look like it's got the -ve pc in it, this makes
584 it much easier to convert into other formats. This is done by
587 if (r->relent.howto->pc_relative == true) {
588 r->relent.addend -= dst_ptr - dst_base_ptr;
595 case RELOCATION_TYPE_COM:
605 case oasys_record_is_local_enum:
606 case oasys_record_is_symbol_enum:
607 case oasys_record_is_section_enum:
619 bfd_error_vector_type bfd_error_vector;
622 DEFUN(oasys_new_section_hook,(abfd, newsect),
626 newsect->used_by_bfd = (PTR)
627 bfd_alloc(abfd, sizeof(oasys_per_section_type));
628 oasys_per_section( newsect)->data = (bfd_byte *)NULL;
629 oasys_per_section(newsect)->section = newsect;
630 oasys_per_section(newsect)->offset = 0;
631 newsect->alignment_power = 3;
632 /* Turn the section string into an index */
634 sscanf(newsect->name,"%u", &newsect->target_index);
641 DEFUN(oasys_get_reloc_upper_bound, (abfd, asect),
645 oasys_slurp_section_data(abfd);
646 return (asect->reloc_count+1) * sizeof(arelent *);
650 DEFUN(oasys_get_section_contents,(abfd, section, location, offset, count),
657 oasys_per_section_type *p = (oasys_per_section_type *) section->used_by_bfd;
658 oasys_slurp_section_data(abfd);
659 (void) memcpy(location, p->data + offset, count);
665 DEFUN(oasys_canonicalize_reloc,(abfd, section, relptr, symbols),
671 unsigned int reloc_count = 0;
672 oasys_reloc_type *src = (oasys_reloc_type *)(section->relocation);
673 while (src != (oasys_reloc_type *)NULL) {
674 if (src->relent.section == (asection *)NULL)
676 src->relent.sym_ptr_ptr = symbols + src->symbol;
678 *relptr ++ = &src->relent;
682 *relptr = (arelent *)NULL;
683 return section->reloc_count = reloc_count;
688 DEFUN(oasys_set_arch_mach, (abfd, arch, machine),
690 enum bfd_architecture arch AND
691 unsigned long machine)
693 abfd->obj_arch = arch;
694 abfd->obj_machine = machine;
703 /* Calculate the checksum and write one record */
705 DEFUN(oasys_write_record,(abfd, type, record, size),
707 CONST oasys_record_enum_type type AND
708 oasys_record_union_type *record AND
714 record->header.length = size;
715 record->header.type = type;
716 record->header.check_sum = 0;
717 record->header.fill = 0;
718 ptr = &record->pad[0];
720 for (i = 0; i < size; i++) {
723 record->header.check_sum = 0xff & (- checksum);
724 bfd_write((PTR)record, 1, size, abfd);
728 /* Write out all the symbols */
730 DEFUN(oasys_write_syms, (abfd),
734 asymbol **generic = bfd_get_outsymbols(abfd);
735 unsigned int index = 0;
736 for (count = 0; count < bfd_get_symcount(abfd); count++) {
738 oasys_symbol_record_type symbol;
739 asymbol * CONST g = generic[count];
741 CONST char *src = g->name;
742 char *dst = symbol.name;
745 if (g->flags & BSF_FORT_COMM) {
746 symbol.relb = RELOCATION_TYPE_COM;
747 bfd_h_putshort(abfd, index, (uint8e_type *)(&symbol.refno[0]));
750 else if (g->flags & BSF_ABSOLUTE) {
751 symbol.relb = RELOCATION_TYPE_ABS;
752 bfd_h_putshort(abfd, 0, (uint8e_type *)(&symbol.refno[0]));
755 else if (g->flags & BSF_UNDEFINED) {
756 symbol.relb = RELOCATION_TYPE_UND ;
757 bfd_h_putshort(abfd, index, (uint8e_type *)(&symbol.refno[0]));
758 /* Overload the value field with the output index number */
761 else if (g->flags & BSF_DEBUGGING) {
766 symbol.relb = RELOCATION_TYPE_REL | g->section->output_section->target_index;
767 bfd_h_putshort(abfd, 0, (uint8e_type *)(&symbol.refno[0]));
774 bfd_h_putlong(abfd, g->value, symbol.value);
777 if (g->flags & BSF_LOCAL) {
778 oasys_write_record(abfd,
779 oasys_record_is_local_enum,
780 (oasys_record_union_type *) &symbol,
781 offsetof(oasys_symbol_record_type, name[0]) + l);
784 oasys_write_record(abfd,
785 oasys_record_is_symbol_enum,
786 (oasys_record_union_type *) &symbol,
787 offsetof(oasys_symbol_record_type, name[0]) + l);
794 /* Write a section header for each section */
796 DEFUN(oasys_write_sections, (abfd),
800 static oasys_section_record_type out = {0};
802 for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
803 if (!isdigit(s->name[0]))
805 bfd_error_vector.nonrepresentable_section(abfd,
808 out.relb = RELOCATION_TYPE_REL | s->target_index;
809 bfd_h_putlong(abfd, s->size, out.value);
810 bfd_h_putlong(abfd, s->vma, out.vma);
812 oasys_write_record(abfd,
813 oasys_record_is_section_enum,
814 (oasys_record_union_type *) &out,
820 DEFUN(oasys_write_header, (abfd),
823 /* Create and write the header */
824 oasys_header_record_type r;
825 size_t length = strlen(abfd->filename);
826 if (length > (size_t)sizeof(r.module_name)) {
827 length = sizeof(r.module_name);
830 (void)memcpy(r.module_name,
833 (void)memset(r.module_name + length,
835 sizeof(r.module_name) - length);
837 r.version_number = OASYS_VERSION_NUMBER;
838 r.rev_number = OASYS_REV_NUMBER;
839 oasys_write_record(abfd,
840 oasys_record_is_header_enum,
841 (oasys_record_union_type *)&r,
842 offsetof(oasys_header_record_type, description[0]));
849 DEFUN(oasys_write_end,(abfd),
852 oasys_end_record_type end;
853 uint8e_type null = 0;
854 end.relb = RELOCATION_TYPE_ABS;
855 bfd_h_putlong(abfd, abfd->start_address, end.entry);
856 bfd_h_putshort(abfd, 0, end.fill);
858 oasys_write_record(abfd,
859 oasys_record_is_end_enum,
860 (oasys_record_union_type *)&end,
862 bfd_write((PTR)&null, 1, 1, abfd);
870 arelent *a = *((arelent **)ap);
871 arelent *b = *((arelent **)bp);
872 return a->address - b->address;
880 DEFUN(oasys_write_data, (abfd),
884 for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
885 uint8e_type *raw_data = oasys_per_section(s)->data;
886 oasys_data_record_type processed_data;
887 unsigned int current_byte_index = 0;
888 unsigned int relocs_to_go = s->reloc_count;
889 arelent **p = s->orelocation;
890 if (s->reloc_count != 0) {
891 /* Sort the reloc records so it's easy to insert the relocs into the
894 qsort(s->orelocation,
899 current_byte_index = 0;
900 processed_data.relb = s->target_index | RELOCATION_TYPE_REL;
902 while ((size_t)current_byte_index < s->size)
904 /* Scan forwards by eight bytes or however much is left and see if
905 there are any relocations going on */
906 uint8e_type *mod = &processed_data.data[0];
907 uint8e_type *dst = &processed_data.data[1];
910 unsigned int long_length = 128;
913 bfd_h_putlong(abfd, s->vma + current_byte_index, processed_data.addr);
914 if ((size_t)(long_length + current_byte_index) > (size_t)(s->size)) {
915 long_length = s->size - current_byte_index;
917 while (long_length > 0 && (dst - (uint8e_type*)&processed_data < 128)) {
919 unsigned int length = long_length;
924 for (i = 0; i < length; i++) {
925 if (relocs_to_go != 0) {
927 reloc_howto_type *CONST how=r->howto;
928 /* There is a relocation, is it for this byte ? */
929 if (r->address == current_byte_index) {
930 uint8e_type rel_byte;
935 if(how->pc_relative) {
938 /* Also patch the raw data so that it doesn't have
939 the -ve stuff any more */
940 if (how->size != 2) {
942 bfd_getshort(abfd,raw_data) +
943 current_byte_index, raw_data);
948 bfd_getlong(abfd,raw_data) +
949 current_byte_index, raw_data);
959 /* Is this a section relative relocation, or a symbol
960 relative relocation ? */
961 if (r->section != (asection*)NULL)
963 /* The relent has a section attatched, so it must be section
965 rel_byte |= RELOCATION_TYPE_REL;
966 rel_byte |= r->section->output_section->target_index;
971 asymbol *p = *(r->sym_ptr_ptr);
973 /* If this symbol has a section attatched, then it
974 has already been resolved. Change from a symbol
975 ref to a section ref */
976 if(p->section != (asection *)NULL) {
977 rel_byte |= RELOCATION_TYPE_REL;
979 p->section->output_section->target_index;
983 rel_byte |= RELOCATION_TYPE_UND;
987 /* Next two bytes are a symbol index - we can get
988 this from the symbol value which has been zapped
989 into the symbol index in the table when the
990 symbol table was written
992 *dst++ = p->value >> 8;
999 /* If this is coming from an unloadable section then copy
1001 if (raw_data == (uint8e_type *)NULL) {
1005 *dst++ = *raw_data++;
1007 current_byte_index++;
1010 long_length -= length;
1013 oasys_write_record(abfd,
1014 oasys_record_is_data_enum,
1015 (oasys_record_union_type *)&processed_data,
1016 dst - (uint8e_type*)&processed_data);
1022 DEFUN(oasys_write_object_contents, (abfd),
1025 oasys_write_header(abfd);
1026 oasys_write_syms(abfd);
1027 oasys_write_sections(abfd);
1028 oasys_write_data(abfd);
1029 oasys_write_end(abfd);
1036 /** exec and core file sections */
1038 /* set section contents is complicated with OASYS since the format is
1039 * not a byte image, but a record stream.
1042 DEFUN(oasys_set_section_contents,(abfd, section, location, offset, count),
1045 unsigned char *location AND
1050 if (oasys_per_section(section)->data == (bfd_byte *)NULL )
1052 oasys_per_section(section)->data =
1053 (bfd_byte *)(bfd_alloc(abfd,section->size));
1055 (void) memcpy(oasys_per_section(section)->data + offset,
1064 /* Native-level interface to symbols. */
1066 /* We read the symbols into a buffer, which is discarded when this
1067 function exits. We read the strings into a buffer large enough to
1068 hold them all plus all the cached symbol entries. */
1071 DEFUN(oasys_make_empty_symbol,(abfd),
1075 oasys_symbol_type *new =
1076 (oasys_symbol_type *)bfd_zalloc (abfd, sizeof (oasys_symbol_type));
1077 new->symbol.the_bfd = abfd;
1078 return &new->symbol;
1085 /* User should have checked the file flags; perhaps we should return
1086 BFD_NO_MORE_SYMBOLS if there are none? */
1091 oasys_close_and_cleanup (abfd)
1094 if (bfd_read_p (abfd) == false)
1095 switch (abfd->format) {
1097 if (!_bfd_write_archive_contents (abfd)) {
1102 if (!oasys_write_object_contents (abfd)) {
1107 bfd_error = invalid_operation;
1117 oasys_openr_next_archived_file(arch, prev)
1121 oasys_ar_data_type *ar = oasys_ar_data(arch);
1122 oasys_module_info_type *p;
1123 /* take the next one from the arch state, or reset */
1124 if (prev == (bfd *)NULL) {
1125 /* Reset the index - the first two entries are bogus*/
1126 ar->module_index = 0;
1129 p = ar->module + ar->module_index;
1132 if (ar->module_index <= ar->module_count) {
1133 if (p->abfd == (bfd *)NULL) {
1134 p->abfd = _bfd_create_empty_archive_element_shell(arch);
1135 p->abfd->origin = p->pos;
1136 p->abfd->filename = p->name;
1138 /* Fixup a pointer to this element for the member */
1139 p->abfd->arelt_data = (PTR)p;
1144 bfd_error = no_more_archived_files;
1150 oasys_find_nearest_line(abfd,
1161 char **filename_ptr;
1162 char **functionname_ptr;
1163 unsigned int *line_ptr;
1170 DEFUN(oasys_generic_stat_arch_elt,(abfd, buf),
1174 oasys_module_info_type *mod = (oasys_module_info_type *) abfd->arelt_data;
1175 if (mod == (oasys_module_info_type *)NULL) {
1176 bfd_error = invalid_operation;
1180 buf->st_size = mod->size;
1181 buf->st_mode = 0666;
1187 DEFUN(oasys_sizeof_headers,(abfd, exec),
1194 #define oasys_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
1195 #define oasys_core_file_failing_signal (int (*)())bfd_0
1196 #define oasys_core_file_matches_executable_p 0 /*(PROTO(boolean, (*),(bfd*, bfd*)))bfd_false*/
1197 #define oasys_slurp_armap bfd_true
1198 #define oasys_slurp_extended_name_table bfd_true
1199 #define oasys_truncate_arname (void (*)())bfd_nullvoidptr
1200 #define oasys_write_armap 0 /* (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr*/
1201 #define oasys_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
1207 bfd_target oasys_vec =
1210 bfd_target_oasys_flavour_enum,
1211 true, /* target byte order */
1212 true, /* target headers byte order */
1213 (HAS_RELOC | EXEC_P | /* object flags */
1214 HAS_LINENO | HAS_DEBUG |
1215 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
1216 (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
1217 |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1218 ' ', /* ar_pad_char */
1219 16, /* ar_max_namelen */
1221 _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */
1222 _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */
1225 oasys_object_p, /* bfd_check_format */
1232 _bfd_generic_mkarchive,