projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gcc -Wall lint:
[deliverable/binutils-gdb.git] / bfd / oasys.c
1 /* BFD back-end for oasys objects.
2 Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support, <sac@cygnus.com>.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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. */
20
21 #define UNDERSCORE_HACK 1
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25 #include "oasys.h"
26 #include "liboasys.h"
27
28 /* XXX - FIXME. offsetof belongs in the system-specific files in
29 ../include/sys. */
30 /* Define offsetof for those systems which lack it */
31
32 #ifndef offsetof
33 #define offsetof(type, identifier) (size_t) &(((type *) 0)->identifier)
34 #endif
35
36 /* Read in all the section data and relocation stuff too */
37 PROTO(static boolean,oasys_slurp_section_data,(bfd *CONST abfd));
38
39 static void
40 DEFUN(oasys_read_record,(abfd, record),
41 bfd *CONST abfd AND
42 oasys_record_union_type *record)
43 {
44
45 bfd_read((PTR)record, 1, sizeof(record->header), abfd);
46
47 if ((size_t) record->header.length <= (size_t) sizeof (record->header))
48 return;
49 bfd_read((PTR)(((char *)record )+ sizeof(record->header)),
50 1, record->header.length - sizeof(record->header),
51 abfd);
52 }
53 static size_t
54 DEFUN(oasys_string_length,(record),
55 oasys_record_union_type *record)
56 {
57 return record->header.length
58 - ((char *)record->symbol.name - (char *)record);
59 }
60
61 /*****************************************************************************/
62
63 /*
64
65 Slurp the symbol table by reading in all the records at the start file
66 till we get to the first section record.
67
68 We'll sort the symbolss into two lists, defined and undefined. The
69 undefined symbols will be placed into the table according to their
70 refno.
71
72 We do this by placing all undefined symbols at the front of the table
73 moving in, and the defined symbols at the end of the table moving back.
74
75 */
76
77 static boolean
78 DEFUN(oasys_slurp_symbol_table,(abfd),
79 bfd * CONST abfd)
80 {
81 oasys_record_union_type record;
82 oasys_data_type *data = OASYS_DATA(abfd);
83 boolean loop = true;
84 asymbol *dest_defined;
85 asymbol *dest;
86 char *string_ptr;
87
88
89 if (data->symbols != (asymbol *)NULL) {
90 return true;
91 }
92 /* Buy enough memory for all the symbols and all the names */
93 data->symbols =
94 (asymbol *)bfd_alloc(abfd, sizeof(asymbol) * abfd->symcount);
95 #ifdef UNDERSCORE_HACK
96 /* buy 1 more char for each symbol to keep the underscore in*/
97 data->strings = bfd_alloc(abfd, data->symbol_string_length +
98 abfd->symcount);
99 #else
100 data->strings = bfd_alloc(abfd, data->symbol_string_length);
101 #endif
102
103
104 dest_defined = data->symbols + abfd->symcount -1;
105
106 string_ptr = data->strings;
107 bfd_seek(abfd, (file_ptr)0, SEEK_SET);
108 while (loop) {
109
110 oasys_read_record(abfd, &record);
111 switch (record.header.type) {
112 case oasys_record_is_header_enum:
113 break;
114 case oasys_record_is_local_enum:
115 case oasys_record_is_symbol_enum:
116 {
117 int flag = record.header.type == (int)oasys_record_is_local_enum ?
118 (BSF_LOCAL) : (BSF_GLOBAL | BSF_EXPORT);
119
120
121 size_t length = oasys_string_length(&record);
122 switch (record.symbol.relb & RELOCATION_TYPE_BITS) {
123 case RELOCATION_TYPE_ABS:
124 dest = dest_defined--;
125 dest->section = &bfd_abs_section;
126 dest->flags = 0;
127
128 break;
129 case RELOCATION_TYPE_REL:
130 dest = dest_defined--;
131 dest->section =
132 OASYS_DATA(abfd)->sections[record.symbol.relb &
133 RELOCATION_SECT_BITS];
134 if (record.header.type == (int)oasys_record_is_local_enum)
135 {
136 dest->flags = BSF_LOCAL;
137 if (dest->section ==(asection *)(~0)) {
138 /* It seems that sometimes internal symbols are tied up, but
139 still get output, even though there is no
140 section */
141 dest->section = 0;
142 }
143 }
144 else {
145
146 dest->flags = flag;
147 }
148 break;
149 case RELOCATION_TYPE_UND:
150 dest = data->symbols + bfd_h_get_16(abfd, record.symbol.refno);
151 dest->section = &bfd_und_section;
152 break;
153 case RELOCATION_TYPE_COM:
154 dest = dest_defined--;
155 dest->name = string_ptr;
156 dest->the_bfd = abfd;
157
158 dest->section = &bfd_com_section;
159
160 break;
161 default:
162 dest = dest_defined--;
163 BFD_ASSERT(0);
164 break;
165 }
166 dest->name = string_ptr;
167 dest->the_bfd = abfd;
168 dest->udata = (PTR)NULL;
169 dest->value = bfd_h_get_32(abfd, record.symbol.value);
170
171 #ifdef UNDERSCORE_HACK
172 if (record.symbol.name[0] != '_') {
173 string_ptr[0] = '_';
174 string_ptr++;
175 }
176 #endif
177 memcpy(string_ptr, record.symbol.name, length);
178
179
180 string_ptr[length] =0;
181 string_ptr += length +1;
182 }
183 break;
184 default:
185 loop = false;
186 }
187 }
188 return true;
189 }
190
191 static unsigned int
192 DEFUN(oasys_get_symtab_upper_bound,(abfd),
193 bfd *CONST abfd)
194 {
195 oasys_slurp_symbol_table (abfd);
196
197 return (abfd->symcount+1) * (sizeof (oasys_symbol_type *));
198 }
199
200 /*
201 */
202
203 extern bfd_target oasys_vec;
204
205 unsigned int
206 DEFUN(oasys_get_symtab,(abfd, location),
207 bfd *abfd AND
208 asymbol **location)
209 {
210 asymbol *symbase ;
211 unsigned int counter ;
212 if (oasys_slurp_symbol_table(abfd) == false) {
213 return 0;
214 }
215 symbase = OASYS_DATA(abfd)->symbols;
216 for (counter = 0; counter < abfd->symcount; counter++) {
217 *(location++) = symbase++;
218 }
219 *location = 0;
220 return abfd->symcount;
221 }
222
223 /***********************************************************************
224 * archive stuff
225 */
226
227 static bfd_target *
228 DEFUN(oasys_archive_p,(abfd),
229 bfd *abfd)
230 {
231 oasys_archive_header_type header;
232 oasys_extarchive_header_type header_ext;
233 unsigned int i;
234 file_ptr filepos;
235
236 bfd_seek(abfd, (file_ptr) 0, false);
237 bfd_read((PTR)&header_ext, 1, sizeof(header_ext), abfd);
238
239 header.version = bfd_h_get_32(abfd, header_ext.version);
240 header.mod_count = bfd_h_get_32(abfd, header_ext.mod_count);
241 header.mod_tbl_offset = bfd_h_get_32(abfd, header_ext.mod_tbl_offset);
242 header.sym_tbl_size = bfd_h_get_32(abfd, header_ext.sym_tbl_size);
243 header.sym_count = bfd_h_get_32(abfd, header_ext.sym_count);
244 header.sym_tbl_offset = bfd_h_get_32(abfd, header_ext.sym_tbl_offset);
245 header.xref_count = bfd_h_get_32(abfd, header_ext.xref_count);
246 header.xref_lst_offset = bfd_h_get_32(abfd, header_ext.xref_lst_offset);
247
248 /*
249 There isn't a magic number in an Oasys archive, so the best we
250 can do to verify reasnableness is to make sure that the values in
251 the header are too weird
252 */
253
254 if (header.version>10000 ||
255 header.mod_count>10000 ||
256 header.sym_count>100000 ||
257 header.xref_count > 100000) return (bfd_target *)NULL;
258
259 /*
260 That all worked, let's buy the space for the header and read in
261 the headers.
262 */
263 {
264 oasys_ar_data_type *ar =
265 (oasys_ar_data_type*) bfd_alloc(abfd, sizeof(oasys_ar_data_type));
266
267 oasys_module_info_type *module =
268 (oasys_module_info_type*)
269 bfd_alloc(abfd, sizeof(oasys_module_info_type) * header.mod_count);
270
271 oasys_module_table_type record;
272
273 abfd->tdata.oasys_ar_data = ar;
274 ar->module = module;
275 ar->module_count = header.mod_count;
276
277 filepos = header.mod_tbl_offset;
278 for (i = 0; i < header.mod_count; i++) {
279 bfd_seek(abfd, filepos, SEEK_SET);
280
281 /* There are two ways of specifying the archive header */
282
283 if (0) {
284 oasys_extmodule_table_type_a_type record_ext;
285 bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd);
286
287 record.mod_size = bfd_h_get_32(abfd, record_ext.mod_size);
288 record.file_offset = bfd_h_get_32(abfd, record_ext.file_offset);
289
290 record.dep_count = bfd_h_get_32(abfd, record_ext.dep_count);
291 record.depee_count = bfd_h_get_32(abfd, record_ext.depee_count);
292 record.sect_count = bfd_h_get_32(abfd, record_ext.sect_count);
293
294 module[i].name = bfd_alloc(abfd,33);
295
296 memcpy(module[i].name, record_ext.mod_name, 33);
297 filepos +=
298 sizeof(record_ext) +
299 record.dep_count * 4 +
300 record.depee_count * 4 +
301 record.sect_count * 8 + 187;
302 }
303 else {
304 oasys_extmodule_table_type_b_type record_ext;
305 bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd);
306
307 record.mod_size = bfd_h_get_32(abfd, record_ext.mod_size);
308 record.file_offset = bfd_h_get_32(abfd, record_ext.file_offset);
309
310 record.dep_count = bfd_h_get_32(abfd, record_ext.dep_count);
311 record.depee_count = bfd_h_get_32(abfd, record_ext.depee_count);
312 record.sect_count = bfd_h_get_32(abfd, record_ext.sect_count);
313 record.module_name_size = bfd_h_get_32(abfd, record_ext.mod_name_length);
314
315 module[i].name = bfd_alloc(abfd,record.module_name_size + 1);
316 bfd_read((PTR)module[i].name, 1, record.module_name_size, abfd);
317 module[i].name[record.module_name_size] = 0;
318 filepos +=
319 sizeof(record_ext) +
320 record.dep_count * 4 +
321 record.module_name_size + 1;
322
323 }
324
325
326 module[i].size = record.mod_size;
327 module[i].pos = record.file_offset;
328 module[i].abfd = 0;
329 }
330
331 }
332 return abfd->xvec;
333 }
334
335 static boolean
336 DEFUN(oasys_mkobject,(abfd),
337 bfd *abfd)
338 {
339
340 abfd->tdata.oasys_obj_data = (oasys_data_type*)bfd_alloc(abfd, sizeof(oasys_data_type));
341 return true;
342 }
343
344 #define MAX_SECS 16
345 static bfd_target *
346 DEFUN(oasys_object_p,(abfd),
347 bfd *abfd)
348 {
349 oasys_data_type *oasys;
350 oasys_data_type *save = OASYS_DATA(abfd);
351 boolean loop = true;
352 boolean had_usefull = false;
353
354 abfd->tdata.oasys_obj_data = 0;
355 oasys_mkobject(abfd);
356 oasys = OASYS_DATA(abfd);
357 memset((PTR)oasys->sections, 0xff, sizeof(oasys->sections));
358
359 /* Point to the start of the file */
360 bfd_seek(abfd, (file_ptr)0, SEEK_SET);
361 oasys->symbol_string_length = 0;
362 /* Inspect the records, but only keep the section info -
363 remember the size of the symbols
364 */
365 oasys->first_data_record = 0;
366 while (loop) {
367 oasys_record_union_type record;
368 oasys_read_record(abfd, &record);
369 if ((size_t)record.header.length < (size_t)sizeof(record.header))
370 goto fail;
371
372
373 switch ((oasys_record_enum_type)(record.header.type)) {
374 case oasys_record_is_header_enum:
375 had_usefull = true;
376 break;
377 case oasys_record_is_symbol_enum:
378 case oasys_record_is_local_enum:
379 /* Count symbols and remember their size for a future malloc */
380 abfd->symcount++;
381 oasys->symbol_string_length += 1 + oasys_string_length(&record);
382 had_usefull = true;
383 break;
384 case oasys_record_is_section_enum:
385 {
386 asection *s;
387 char *buffer;
388 unsigned int section_number;
389 if (record.section.header.length != sizeof(record.section))
390 {
391 goto fail;
392 }
393 buffer = bfd_alloc(abfd, 3);
394 section_number= record.section.relb & RELOCATION_SECT_BITS;
395 sprintf(buffer,"%u", section_number);
396 s = bfd_make_section(abfd,buffer);
397 oasys->sections[section_number] = s;
398 switch (record.section.relb & RELOCATION_TYPE_BITS) {
399 case RELOCATION_TYPE_ABS:
400 case RELOCATION_TYPE_REL:
401 break;
402 case RELOCATION_TYPE_UND:
403 case RELOCATION_TYPE_COM:
404 BFD_FAIL();
405 }
406
407 s->_raw_size = bfd_h_get_32(abfd, record.section.value);
408 s->vma = bfd_h_get_32(abfd, record.section.vma);
409 s->flags= 0;
410 had_usefull = true;
411 }
412 break;
413 case oasys_record_is_data_enum:
414 oasys->first_data_record = bfd_tell(abfd) - record.header.length;
415 case oasys_record_is_debug_enum:
416 case oasys_record_is_module_enum:
417 case oasys_record_is_named_section_enum:
418 case oasys_record_is_end_enum:
419 if (had_usefull == false) goto fail;
420 loop = false;
421 break;
422 default:
423 goto fail;
424 }
425 }
426 oasys->symbols = (asymbol *)NULL;
427 /*
428 Oasys support several architectures, but I can't see a simple way
429 to discover which one is in a particular file - we'll guess
430 */
431 bfd_default_set_arch_mach(abfd, bfd_arch_m68k, 0);
432 if (abfd->symcount != 0) {
433 abfd->flags |= HAS_SYMS;
434 }
435
436 /*
437 We don't know if a section has data until we've read it..
438 */
439
440 oasys_slurp_section_data(abfd);
441
442
443 return abfd->xvec;
444
445 fail:
446 (void) bfd_release(abfd, oasys);
447 abfd->tdata.oasys_obj_data = save;
448 return (bfd_target *)NULL;
449 }
450
451
452 static void
453 DEFUN(oasys_get_symbol_info,(ignore_abfd, symbol, ret),
454 bfd *ignore_abfd AND
455 asymbol *symbol AND
456 symbol_info *ret)
457 {
458 bfd_symbol_info (symbol, ret);
459 if (!symbol->section)
460 ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
461 }
462
463 static void
464 DEFUN(oasys_print_symbol,(ignore_abfd, afile, symbol, how),
465 bfd *ignore_abfd AND
466 PTR afile AND
467 asymbol *symbol AND
468 bfd_print_symbol_type how)
469 {
470 FILE *file = (FILE *)afile;
471
472 switch (how) {
473 case bfd_print_symbol_name:
474 case bfd_print_symbol_more:
475 fprintf(file,"%s", symbol->name);
476 break;
477 case bfd_print_symbol_all:
478 {
479 CONST char *section_name = symbol->section == (asection *)NULL ?
480 (CONST char *) "*abs" : symbol->section->name;
481
482 bfd_print_symbol_vandf((PTR)file,symbol);
483
484 fprintf(file," %-5s %s",
485 section_name,
486 symbol->name);
487 }
488 break;
489 }
490 }
491 /*
492 The howto table is build using the top two bits of a reloc byte to
493 index into it. The bits are PCREL,WORD/LONG
494 */
495 static reloc_howto_type howto_table[]=
496 {
497
498 HOWTO( 0, 0, 1, 16, false,0,complain_overflow_bitfield,0,"abs16",true,0x0000ffff, 0x0000ffff,false),
499 HOWTO( 0, 0, 2, 32, false,0,complain_overflow_bitfield,0,"abs32",true,0xffffffff, 0xffffffff,false),
500 HOWTO( 0, 0, 1, 16, true,0,complain_overflow_signed,0,"pcrel16",true,0x0000ffff, 0x0000ffff,false),
501 HOWTO( 0, 0, 2, 32, true,0,complain_overflow_signed,0,"pcrel32",true,0xffffffff, 0xffffffff,false)
502 };
503
504 /* Read in all the section data and relocation stuff too */
505 static boolean
506 DEFUN(oasys_slurp_section_data,(abfd),
507 bfd *CONST abfd)
508 {
509 oasys_record_union_type record;
510 oasys_data_type *data = OASYS_DATA(abfd);
511 boolean loop = true;
512
513 oasys_per_section_type *per ;
514
515 asection *s;
516
517 /* See if the data has been slurped already .. */
518 for (s = abfd->sections; s != (asection *)NULL; s= s->next) {
519 per = oasys_per_section(s);
520 if (per->initialized == true)
521 return true;
522 }
523
524 if (data->first_data_record == 0) return true;
525
526 bfd_seek(abfd, data->first_data_record, SEEK_SET);
527 while (loop) {
528 oasys_read_record(abfd, &record);
529 switch (record.header.type)
530 {
531 case oasys_record_is_header_enum:
532 break;
533 case oasys_record_is_data_enum:
534 {
535
536 bfd_byte *src = record.data.data;
537 bfd_byte *end_src = ((bfd_byte *)&record) + record.header.length;
538 bfd_byte *dst_ptr;
539 bfd_byte *dst_base_ptr;
540 unsigned int relbit;
541 unsigned int count;
542 asection * section =
543 data->sections[record.data.relb & RELOCATION_SECT_BITS];
544 bfd_vma dst_offset ;
545
546 per = oasys_per_section(section);
547
548 if (per->initialized == false)
549 {
550 per->data = (bfd_byte *) bfd_zalloc(abfd, section->_raw_size);
551 per->reloc_tail_ptr = (oasys_reloc_type **)&(section->relocation);
552 per->had_vma = false;
553 per->initialized = true;
554 section->reloc_count = 0;
555 section->flags = SEC_ALLOC;
556 }
557
558 dst_offset = bfd_h_get_32(abfd, record.data.addr) ;
559 if (per->had_vma == false) {
560 /* Take the first vma we see as the base */
561 section->vma = dst_offset;
562 per->had_vma = true;
563 }
564
565 dst_offset -= section->vma;
566
567 dst_base_ptr = oasys_per_section(section)->data;
568 dst_ptr = oasys_per_section(section)->data +
569 dst_offset;
570
571 if (src < end_src) {
572 section->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
573 }
574 while (src < end_src) {
575 unsigned char mod_byte = *src++;
576 size_t gap = end_src - src;
577
578 count = 8;
579 if (mod_byte == 0 && gap >= 8) {
580 dst_ptr[0] = src[0];
581 dst_ptr[1] = src[1];
582 dst_ptr[2] = src[2];
583 dst_ptr[3] = src[3];
584 dst_ptr[4] = src[4];
585 dst_ptr[5] = src[5];
586 dst_ptr[6] = src[6];
587 dst_ptr[7] = src[7];
588 dst_ptr+= 8;
589 src += 8;
590 }
591 else {
592 for (relbit = 1; count-- != 0 && src < end_src; relbit <<=1)
593 {
594 if (relbit & mod_byte)
595 {
596 unsigned char reloc = *src;
597 /* This item needs to be relocated */
598 switch (reloc & RELOCATION_TYPE_BITS) {
599 case RELOCATION_TYPE_ABS:
600
601 break;
602
603 case RELOCATION_TYPE_REL:
604 {
605 /* Relocate the item relative to the section */
606 oasys_reloc_type *r =
607 (oasys_reloc_type *)
608 bfd_alloc(abfd,
609 sizeof(oasys_reloc_type));
610 *(per->reloc_tail_ptr) = r;
611 per->reloc_tail_ptr = &r->next;
612 r->next= (oasys_reloc_type *)NULL;
613 /* Reference to undefined symbol */
614 src++;
615 /* There is no symbol */
616 r->symbol = 0;
617 /* Work out the howto */
618 abort();
619 #if 0
620 r->relent.section =
621 data->sections[reloc &
622 RELOCATION_SECT_BITS];
623
624 r->relent.addend = -
625 r->relent.section->vma;
626 #endif
627 r->relent.address = dst_ptr - dst_base_ptr;
628 r->relent.howto = &howto_table[reloc>>6];
629 r->relent.sym_ptr_ptr = (asymbol **)NULL;
630 section->reloc_count++;
631
632 /* Fake up the data to look like it's got the -ve pc in it, this makes
633 it much easier to convert into other formats. This is done by
634 hitting the addend.
635 */
636 if (r->relent.howto->pc_relative == true) {
637 r->relent.addend -= dst_ptr - dst_base_ptr;
638 }
639
640
641 }
642 break;
643
644
645 case RELOCATION_TYPE_UND:
646 {
647 oasys_reloc_type *r =
648 (oasys_reloc_type *)
649 bfd_alloc(abfd,
650 sizeof(oasys_reloc_type));
651 *(per->reloc_tail_ptr) = r;
652 per->reloc_tail_ptr = &r->next;
653 r->next= (oasys_reloc_type *)NULL;
654 /* Reference to undefined symbol */
655 src++;
656 /* Get symbol number */
657 r->symbol = (src[0]<<8) | src[1];
658 /* Work out the howto */
659 abort();
660
661 #if 0
662 r->relent.section = (asection
663 *)NULL;
664 #endif
665 r->relent.addend = 0;
666 r->relent.address = dst_ptr - dst_base_ptr;
667 r->relent.howto = &howto_table[reloc>>6];
668 r->relent.sym_ptr_ptr = (asymbol **)NULL;
669 section->reloc_count++;
670
671 src+=2;
672 /* Fake up the data to look like it's got the -ve pc in it, this makes
673 it much easier to convert into other formats. This is done by
674 hitting the addend.
675 */
676 if (r->relent.howto->pc_relative == true) {
677 r->relent.addend -= dst_ptr - dst_base_ptr;
678 }
679
680
681
682 }
683 break;
684 case RELOCATION_TYPE_COM:
685 BFD_FAIL();
686 }
687 }
688 *dst_ptr++ = *src++;
689 }
690 }
691 }
692 }
693 break;
694 case oasys_record_is_local_enum:
695 case oasys_record_is_symbol_enum:
696 case oasys_record_is_section_enum:
697 break;
698 default:
699 loop = false;
700 }
701 }
702
703 return true;
704
705 }
706
707
708
709 extern bfd_error_vector_type bfd_error_vector;
710
711 static boolean
712 DEFUN(oasys_new_section_hook,(abfd, newsect),
713 bfd *abfd AND
714 asection *newsect)
715 {
716 newsect->used_by_bfd = (PTR)
717 bfd_alloc(abfd, sizeof(oasys_per_section_type));
718 oasys_per_section( newsect)->data = (bfd_byte *)NULL;
719 oasys_per_section(newsect)->section = newsect;
720 oasys_per_section(newsect)->offset = 0;
721 oasys_per_section(newsect)->initialized = false;
722 newsect->alignment_power = 1;
723 /* Turn the section string into an index */
724
725 sscanf(newsect->name,"%u", &newsect->target_index);
726
727 return true;
728 }
729
730
731 static unsigned int
732 DEFUN(oasys_get_reloc_upper_bound, (abfd, asect),
733 bfd *abfd AND
734 sec_ptr asect)
735 {
736 oasys_slurp_section_data(abfd);
737 return (asect->reloc_count+1) * sizeof(arelent *);
738 }
739
740 static boolean
741 DEFUN(oasys_get_section_contents,(abfd, section, location, offset, count),
742 bfd *abfd AND
743 sec_ptr section AND
744 PTR location AND
745 file_ptr offset AND
746 bfd_size_type count)
747 {
748 oasys_per_section_type *p = (oasys_per_section_type *) section->used_by_bfd;
749 oasys_slurp_section_data(abfd);
750 if (p->initialized == false)
751 {
752 (void) memset(location, 0, (int)count);
753 }
754 else
755 {
756 (void) memcpy(location,(PTR)( p->data + offset), (int)count);
757 }
758 return true;
759 }
760
761
762 unsigned int
763 DEFUN(oasys_canonicalize_reloc,(ignore_abfd, section, relptr, symbols),
764 bfd *ignore_abfd AND
765 sec_ptr section AND
766 arelent **relptr AND
767 asymbol **symbols)
768 {
769 unsigned int reloc_count = 0;
770 oasys_reloc_type *src = (oasys_reloc_type *)(section->relocation);
771 while (src != (oasys_reloc_type *)NULL) {
772 abort();
773
774 #if 0
775 if (src->relent.section == (asection *)NULL)
776 {
777 src->relent.sym_ptr_ptr = symbols + src->symbol;
778 }
779 #endif
780
781 *relptr ++ = &src->relent;
782 src = src->next;
783 reloc_count++;
784 }
785 *relptr = (arelent *)NULL;
786 return section->reloc_count = reloc_count;
787 }
788
789
790
791
792 /* Writing */
793
794
795 /* Calculate the checksum and write one record */
796 static void
797 DEFUN(oasys_write_record,(abfd, type, record, size),
798 bfd *CONST abfd AND
799 CONST oasys_record_enum_type type AND
800 oasys_record_union_type *record AND
801 CONST size_t size)
802 {
803 int checksum;
804 size_t i;
805 unsigned char *ptr;
806
807 record->header.length = size;
808 record->header.type = (int)type;
809 record->header.check_sum = 0;
810 record->header.fill = 0;
811 ptr = (unsigned char *)&record->pad[0];
812 checksum = 0;
813 for (i = 0; i < size; i++) {
814 checksum += *ptr++;
815 }
816 record->header.check_sum = 0xff & (- checksum);
817 bfd_write((PTR)record, 1, size, abfd);
818 }
819
820
821 /* Write out all the symbols */
822 static void
823 DEFUN(oasys_write_syms, (abfd),
824 bfd * CONST abfd)
825 {
826 unsigned int count;
827 asymbol **generic = bfd_get_outsymbols(abfd);
828 unsigned int index = 0;
829 for (count = 0; count < bfd_get_symcount(abfd); count++) {
830
831 oasys_symbol_record_type symbol;
832 asymbol * CONST g = generic[count];
833
834 CONST char *src = g->name;
835 char *dst = symbol.name;
836 unsigned int l = 0;
837
838 if (bfd_is_com_section (g->section)) {
839 symbol.relb = RELOCATION_TYPE_COM;
840 bfd_h_put_16(abfd, index, symbol.refno);
841 index++;
842 }
843 else if (g->section == & bfd_abs_section) {
844 symbol.relb = RELOCATION_TYPE_ABS;
845 bfd_h_put_16(abfd, 0, symbol.refno);
846
847 }
848 else if (g->section == &bfd_und_section) {
849 symbol.relb = RELOCATION_TYPE_UND ;
850 bfd_h_put_16(abfd, index, symbol.refno);
851 /* Overload the value field with the output index number */
852 index++;
853 }
854 else if (g->flags & BSF_DEBUGGING) {
855 /* throw it away */
856 continue;
857 }
858 else {
859 if (g->section == (asection *)NULL) {
860 /* Sometime, the oasys tools give out a symbol with illegal
861 bits in it, we'll output it in the same broken way */
862
863 symbol.relb = RELOCATION_TYPE_REL | 0;
864 }
865 else {
866 symbol.relb = RELOCATION_TYPE_REL |g->section->output_section->target_index;
867 }
868 bfd_h_put_16(abfd, 0, symbol.refno);
869 }
870 #ifdef UNDERSCORE_HACK
871 if (src[l] == '_')
872 dst[l++] = '.';
873 #endif
874 while (src[l]) {
875 dst[l] = src[l];
876 l++;
877 }
878
879 bfd_h_put_32(abfd, g->value, symbol.value);
880
881
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);
887 }
888 else {
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);
893 }
894 g->value = index-1;
895 }
896 }
897
898
899 /* Write a section header for each section */
900 static void
901 DEFUN(oasys_write_sections, (abfd),
902 bfd *CONST abfd)
903 {
904 asection *s;
905 static oasys_section_record_type out;
906
907 for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
908 if (!isdigit(s->name[0]))
909 {
910 bfd_error_vector.nonrepresentable_section(abfd,
911 s->name);
912 }
913 out.relb = RELOCATION_TYPE_REL | s->target_index;
914 bfd_h_put_32(abfd, s->_cooked_size, out.value);
915 bfd_h_put_32(abfd, s->vma, out.vma);
916
917 oasys_write_record(abfd,
918 oasys_record_is_section_enum,
919 (oasys_record_union_type *) &out,
920 sizeof(out));
921 }
922 }
923
924 static void
925 DEFUN(oasys_write_header, (abfd),
926 bfd *CONST abfd)
927 {
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);
933 }
934
935 (void)memcpy(r.module_name,
936 abfd->filename,
937 length);
938 (void)memset(r.module_name + length,
939 ' ',
940 sizeof(r.module_name) - length);
941
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]));
948
949
950
951 }
952
953 static void
954 DEFUN(oasys_write_end,(abfd),
955 bfd *CONST abfd)
956 {
957 oasys_end_record_type end;
958 unsigned char null = 0;
959 end.relb = RELOCATION_TYPE_ABS;
960 bfd_h_put_32(abfd, abfd->start_address, end.entry);
961 bfd_h_put_16(abfd, 0, end.fill);
962 end.zero = 0;
963 oasys_write_record(abfd,
964 oasys_record_is_end_enum,
965 (oasys_record_union_type *)&end,
966 sizeof(end));
967 bfd_write((PTR)&null, 1, 1, abfd);
968 }
969
970 static int
971 DEFUN(comp,(ap, bp),
972 CONST PTR ap AND
973 CONST PTR bp)
974 {
975 arelent *a = *((arelent **)ap);
976 arelent *b = *((arelent **)bp);
977 return a->address - b->address;
978 }
979
980 /*
981 Writing data..
982
983 */
984 static void
985 DEFUN(oasys_write_data, (abfd),
986 bfd *CONST abfd)
987 {
988 asection *s;
989 for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
990 if (s->flags & SEC_LOAD) {
991 bfd_byte *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
998 data */
999
1000 qsort(s->orelocation,
1001 s->reloc_count,
1002 sizeof(arelent **),
1003 comp);
1004 }
1005 current_byte_index = 0;
1006 processed_data.relb = s->target_index | RELOCATION_TYPE_REL;
1007
1008 while (current_byte_index < s->_cooked_size)
1009 {
1010 /* Scan forwards by eight bytes or however much is left and see if
1011 there are any relocations going on */
1012 bfd_byte *mod = &processed_data.data[0];
1013 bfd_byte *dst = &processed_data.data[1];
1014
1015 unsigned int i = 0;
1016 *mod = 0;
1017
1018
1019 bfd_h_put_32(abfd, s->vma + current_byte_index,
1020 processed_data.addr);
1021
1022 /* Don't start a relocation unless you're sure you can finish it
1023 within the same data record. The worst case relocation is a
1024 4-byte relocatable value which is split across two modification
1025 bytes (1 relocation byte + 2 symbol reference bytes + 2 data +
1026 1 modification byte + 2 data = 8 bytes total). That's where
1027 the magic number 8 comes from.
1028 */
1029 while (current_byte_index < s->_raw_size && dst <=
1030 &processed_data.data[sizeof(processed_data.data)-8]) {
1031
1032
1033 if (relocs_to_go != 0) {
1034 arelent *r = *p;
1035 reloc_howto_type *CONST how=r->howto;
1036 /* There is a relocation, is it for this byte ? */
1037 if (r->address == current_byte_index) {
1038 unsigned char rel_byte;
1039
1040 p++;
1041 relocs_to_go--;
1042
1043 *mod |= (1<<i);
1044 if(how->pc_relative) {
1045 rel_byte = RELOCATION_PCREL_BIT;
1046
1047 /* Also patch the raw data so that it doesn't have
1048 the -ve stuff any more */
1049 if (how->size != 2) {
1050 bfd_put_16(abfd,
1051 bfd_get_16(abfd,raw_data) +
1052 current_byte_index, raw_data);
1053 }
1054
1055 else {
1056 bfd_put_32(abfd,
1057 bfd_get_32(abfd,raw_data) +
1058 current_byte_index, raw_data);
1059 }
1060 }
1061 else {
1062 rel_byte = 0;
1063 }
1064 if (how->size ==2) {
1065 rel_byte |= RELOCATION_32BIT_BIT;
1066 }
1067
1068 /* Is this a section relative relocation, or a symbol
1069 relative relocation ? */
1070 abort();
1071
1072 #if 0
1073 if (r->section != (asection*)NULL)
1074 {
1075 /* The relent has a section attached, so it must be section
1076 relative */
1077 rel_byte |= RELOCATION_TYPE_REL;
1078 rel_byte |= r->section->output_section->target_index;
1079 *dst++ = rel_byte;
1080 }
1081 else
1082 #endif
1083 {
1084 asymbol *p = *(r->sym_ptr_ptr);
1085
1086 /* If this symbol has a section attached, then it
1087 has already been resolved. Change from a symbol
1088 ref to a section ref */
1089 if(p->section != (asection *)NULL) {
1090 rel_byte |= RELOCATION_TYPE_REL;
1091 rel_byte |=
1092 p->section->output_section->target_index;
1093 *dst++ = rel_byte;
1094 }
1095 else {
1096 rel_byte |= RELOCATION_TYPE_UND;
1097 *dst++ = rel_byte;
1098 /* Next two bytes are a symbol index - we can get
1099 this from the symbol value which has been zapped
1100 into the symbol index in the table when the
1101 symbol table was written
1102 */
1103 *dst++ = p->value >> 8;
1104 *dst++ = p->value;
1105 }
1106 }
1107 #define ADVANCE { if (++i >= 8) { i = 0; mod = dst++; *mod = 0; } current_byte_index++; }
1108 /* relocations never occur from an unloadable section,
1109 so we can assume that raw_data is not NULL
1110 */
1111 *dst++ = *raw_data++;
1112 ADVANCE
1113 *dst++ = *raw_data++;
1114 ADVANCE
1115 if (how->size == 2) {
1116 *dst++ = *raw_data++;
1117 ADVANCE
1118 *dst++ = *raw_data++;
1119 ADVANCE
1120 }
1121 continue;
1122 }
1123 }
1124 /* If this is coming from an unloadable section then copy
1125 zeros */
1126 if (raw_data == NULL) {
1127 *dst++ = 0;
1128 }
1129 else {
1130 *dst++ = *raw_data++;
1131 }
1132 ADVANCE
1133 }
1134
1135 /* Don't write a useless null modification byte */
1136 if (dst == mod+1) {
1137 --dst;
1138 }
1139
1140 oasys_write_record(abfd,
1141 oasys_record_is_data_enum,
1142 (oasys_record_union_type *)&processed_data,
1143 dst - (bfd_byte *)&processed_data);
1144
1145 }
1146 }
1147 }
1148 }
1149 static boolean
1150 DEFUN(oasys_write_object_contents, (abfd),
1151 bfd *abfd)
1152 {
1153 oasys_write_header(abfd);
1154 oasys_write_syms(abfd);
1155 oasys_write_sections(abfd);
1156 oasys_write_data(abfd);
1157 oasys_write_end(abfd);
1158 return true;
1159 }
1160
1161
1162
1163
1164 /** exec and core file sections */
1165
1166 /* set section contents is complicated with OASYS since the format is
1167 * not a byte image, but a record stream.
1168 */
1169 static boolean
1170 DEFUN(oasys_set_section_contents,(abfd, section, location, offset, count),
1171 bfd *abfd AND
1172 sec_ptr section AND
1173 PTR location AND
1174 file_ptr offset AND
1175 bfd_size_type count)
1176 {
1177 if (count != 0) {
1178 if (oasys_per_section(section)->data == (bfd_byte *)NULL )
1179 {
1180 oasys_per_section(section)->data =
1181 (bfd_byte *)(bfd_alloc(abfd,section->_cooked_size));
1182 }
1183 (void) memcpy((PTR)(oasys_per_section(section)->data + offset),
1184 location,
1185 count);
1186 }
1187 return true;
1188 }
1189
1190
1191
1192 /* Native-level interface to symbols. */
1193
1194 /* We read the symbols into a buffer, which is discarded when this
1195 function exits. We read the strings into a buffer large enough to
1196 hold them all plus all the cached symbol entries. */
1197
1198 static asymbol *
1199 DEFUN(oasys_make_empty_symbol,(abfd),
1200 bfd *abfd)
1201 {
1202
1203 oasys_symbol_type *new =
1204 (oasys_symbol_type *)bfd_zalloc (abfd, sizeof (oasys_symbol_type));
1205 new->symbol.the_bfd = abfd;
1206 return &new->symbol;
1207
1208 }
1209
1210
1211 \f
1212
1213 /* User should have checked the file flags; perhaps we should return
1214 BFD_NO_MORE_SYMBOLS if there are none? */
1215
1216 static bfd *
1217 oasys_openr_next_archived_file(arch, prev)
1218 bfd *arch;
1219 bfd *prev;
1220 {
1221 oasys_ar_data_type *ar = OASYS_AR_DATA(arch);
1222 oasys_module_info_type *p;
1223 /* take the next one from the arch state, or reset */
1224 if (prev == (bfd *)NULL) {
1225 /* Reset the index - the first two entries are bogus*/
1226 ar->module_index = 0;
1227 }
1228
1229 p = ar->module + ar->module_index;
1230 ar->module_index++;
1231
1232 if (ar->module_index <= ar->module_count) {
1233 if (p->abfd == (bfd *)NULL) {
1234 p->abfd = _bfd_create_empty_archive_element_shell(arch);
1235 p->abfd->origin = p->pos;
1236 p->abfd->filename = p->name;
1237
1238 /* Fixup a pointer to this element for the member */
1239 p->abfd->arelt_data = (PTR)p;
1240 }
1241 return p->abfd;
1242 }
1243 else {
1244 bfd_error = no_more_archived_files;
1245 return (bfd *)NULL;
1246 }
1247 }
1248
1249 static boolean
1250 oasys_find_nearest_line(abfd,
1251 section,
1252 symbols,
1253 offset,
1254 filename_ptr,
1255 functionname_ptr,
1256 line_ptr)
1257 bfd *abfd;
1258 asection *section;
1259 asymbol **symbols;
1260 bfd_vma offset;
1261 char **filename_ptr;
1262 char **functionname_ptr;
1263 unsigned int *line_ptr;
1264 {
1265 return false;
1266
1267 }
1268
1269 static int
1270 DEFUN(oasys_generic_stat_arch_elt,(abfd, buf),
1271 bfd *abfd AND
1272 struct stat *buf)
1273 {
1274 oasys_module_info_type *mod = (oasys_module_info_type *) abfd->arelt_data;
1275 if (mod == (oasys_module_info_type *)NULL) {
1276 bfd_error = invalid_operation;
1277 return -1;
1278 }
1279 else {
1280 buf->st_size = mod->size;
1281 buf->st_mode = 0666;
1282 return 0;
1283 }
1284 }
1285
1286 static int
1287 DEFUN(oasys_sizeof_headers,(abfd, exec),
1288 bfd *abfd AND
1289 boolean exec)
1290 {
1291 return 0;
1292 }
1293 #define FOO PROTO
1294 #define oasys_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
1295 #define oasys_core_file_failing_signal (int (*)())bfd_0
1296 #define oasys_core_file_matches_executable_p 0
1297 #define oasys_slurp_armap bfd_true
1298 #define oasys_slurp_extended_name_table bfd_true
1299 #define oasys_truncate_arname (void (*)())bfd_nullvoidptr
1300 #define oasys_write_armap 0
1301 #define oasys_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
1302 #define oasys_close_and_cleanup bfd_generic_close_and_cleanup
1303 #define oasys_set_arch_mach bfd_default_set_arch_mach
1304 #define oasys_bfd_debug_info_start bfd_void
1305 #define oasys_bfd_debug_info_end bfd_void
1306 #define oasys_bfd_debug_info_accumulate (FOO(void, (*), (bfd *, asection *)))bfd_void
1307 #define oasys_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
1308 #define oasys_bfd_relax_section bfd_generic_relax_section
1309 #define oasys_bfd_seclet_link bfd_generic_seclet_link
1310 #define oasys_bfd_reloc_type_lookup \
1311 ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
1312 #define oasys_bfd_make_debug_symbol \
1313 ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
1314
1315 /*SUPPRESS 460 */
1316 bfd_target oasys_vec =
1317 {
1318 "oasys", /* name */
1319 bfd_target_oasys_flavour,
1320 true, /* target byte order */
1321 true, /* target headers byte order */
1322 (HAS_RELOC | EXEC_P | /* object flags */
1323 HAS_LINENO | HAS_DEBUG |
1324 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
1325 (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
1326 |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1327 0, /* leading underscore */
1328 ' ', /* ar_pad_char */
1329 16, /* ar_max_namelen */
1330 1, /* minimum alignment */
1331 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1332 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1333 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1334 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1335 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1336 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1337
1338 {_bfd_dummy_target,
1339 oasys_object_p, /* bfd_check_format */
1340 oasys_archive_p,
1341 _bfd_dummy_target,
1342 },
1343 { /* bfd_set_format */
1344 bfd_false,
1345 oasys_mkobject,
1346 _bfd_generic_mkarchive,
1347 bfd_false
1348 },
1349 { /* bfd_write_contents */
1350 bfd_false,
1351 oasys_write_object_contents,
1352 _bfd_write_archive_contents,
1353 bfd_false,
1354 },
1355 JUMP_TABLE(oasys),
1356 (PTR) 0
1357 };
GDB Binutils - Deliverables
This page took 0.059906 seconds and 5 git commands to generate.