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