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