Commit | Line | Data |
---|---|---|
e6304bc7 SC |
1 | /* BFD back-end for VERSAdos-E objects. |
2 | ||
3 | Versados is a Motorola trademark. | |
4 | ||
5 | Copyright 1995 Free Software Foundation, Inc. | |
6 | Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>. | |
7 | ||
8 | This file is part of BFD, the Binary File Descriptor library. | |
9 | ||
10 | This program is free software; you can redistribute it and/or modify | |
11 | it under the terms of the GNU General Public License as published by | |
12 | the Free Software Foundation; either version 2 of the License, or | |
13 | (at your option) any later version. | |
14 | ||
15 | This program is distributed in the hope that it will be useful, | |
16 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | GNU General Public License for more details. | |
19 | ||
20 | You should have received a copy of the GNU General Public License | |
21 | along with this program; if not, write to the Free Software | |
c3246d9b | 22 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
e6304bc7 SC |
23 | |
24 | /* | |
25 | SUBSECTION | |
26 | VERSAdos-E relocateable object file format | |
27 | ||
28 | DESCRIPTION | |
29 | ||
30 | This module supports reading of VERSAdos relocateable | |
31 | object files. | |
32 | ||
33 | A VERSAdos file looks like contains | |
34 | ||
35 | o Indentification Record | |
36 | o External Symbol Definition Record | |
37 | o Object Text Recrod | |
38 | o End Record | |
39 | ||
40 | ||
41 | */ | |
42 | ||
43 | #include "bfd.h" | |
44 | #include "sysdep.h" | |
45 | #include "libbfd.h" | |
46 | #include "libiberty.h" | |
47 | ||
48 | ||
49 | static boolean versados_mkobject PARAMS ((bfd *)); | |
50 | static boolean versados_scan PARAMS ((bfd *)); | |
51 | static const bfd_target *versados_object_p PARAMS ((bfd *)); | |
52 | ||
53 | ||
54 | #define VHEADER '1' | |
c3246d9b | 55 | #define VESTDEF '2' |
e6304bc7 SC |
56 | #define VOTR '3' |
57 | #define VEND '4' | |
58 | ||
59 | ||
c3246d9b | 60 | #define ES_BASE 17 /* first symbol has esdid 17 */ |
e6304bc7 SC |
61 | |
62 | /* Per file target dependent information */ | |
63 | ||
64 | /* one for each section */ | |
65 | struct esdid | |
c3246d9b ILT |
66 | { |
67 | asection *section; /* ptr to bfd version */ | |
68 | unsigned char *contents; /* used to build image */ | |
69 | int pc; | |
70 | int relocs; /* reloc count, valid end of pass 1 */ | |
71 | int donerel; /* have relocs been translated */ | |
72 | }; | |
e6304bc7 SC |
73 | |
74 | typedef struct versados_data_struct | |
c3246d9b ILT |
75 | { |
76 | int es_done; /* count of symbol index, starts at ES_BASE */ | |
77 | asymbol *symbols; /* pointer to local symbols */ | |
78 | char *strings; /* strings of all the above */ | |
79 | int stringlen; /* len of string table (valid end of pass1) */ | |
80 | int nsecsyms; /* number of sections */ | |
e6304bc7 | 81 | |
c3246d9b ILT |
82 | int ndefs; /* number of exported symbols (they dont get esdids) */ |
83 | int nrefs; /* number of imported symbols (valid end of pass1) */ | |
e6304bc7 | 84 | |
c3246d9b ILT |
85 | int ref_idx; /* current processed value of the above */ |
86 | int def_idx; | |
e6304bc7 | 87 | |
c3246d9b ILT |
88 | int pass_2_done; |
89 | ||
90 | struct esdid e[16]; /* per section info */ | |
91 | int alert; /* to see if we're trampling */ | |
92 | asymbol *rest[256 - 16]; /* per symbol info */ | |
93 | ||
94 | } | |
e6304bc7 SC |
95 | tdata_type; |
96 | ||
97 | #define VDATA(abfd) (abfd->tdata.versados_data) | |
98 | #define EDATA(abfd, n) (abfd->tdata.versados_data->e[n]) | |
99 | #define RDATA(abfd, n) (abfd->tdata.versados_data->rest[n]) | |
100 | ||
101 | struct ext_otr | |
102 | { | |
103 | unsigned char size; | |
104 | char type; | |
c3246d9b | 105 | unsigned char map[4]; |
e6304bc7 SC |
106 | unsigned char esdid; |
107 | unsigned char data[200]; | |
108 | }; | |
109 | ||
110 | struct ext_vheader | |
111 | { | |
112 | unsigned char size; | |
113 | char type; /* record type */ | |
114 | char name[10]; /* module name */ | |
115 | char rev; /* module rev number */ | |
116 | char lang; | |
117 | char vol[4]; | |
118 | char user[2]; | |
119 | char cat[8]; | |
120 | char fname[8]; | |
121 | char ext[2]; | |
122 | char time[3]; | |
123 | char date[3]; | |
124 | char rest[211]; | |
125 | }; | |
126 | ||
127 | struct ext_esd | |
128 | { | |
129 | unsigned char size; | |
130 | char type; | |
131 | unsigned char esd_entries[1]; | |
132 | }; | |
c3246d9b ILT |
133 | #define ESD_ABS 0 |
134 | #define ESD_COMMON 1 | |
135 | #define ESD_STD_REL_SEC 2 | |
136 | #define ESD_SHRT_REL_SEC 3 | |
e6304bc7 SC |
137 | #define ESD_XDEF_IN_SEC 4 |
138 | #define ESD_XREF_SYM 7 | |
c3246d9b ILT |
139 | #define ESD_XREF_SEC 6 |
140 | #define ESD_XDEF_IN_ABS 5 | |
e6304bc7 SC |
141 | union ext_any |
142 | { | |
c3246d9b | 143 | unsigned char size; |
e6304bc7 SC |
144 | struct ext_vheader header; |
145 | struct ext_esd esd; | |
146 | struct ext_otr otr; | |
147 | }; | |
148 | ||
149 | /* Initialize by filling in the hex conversion array. */ | |
150 | ||
151 | ||
152 | ||
153 | ||
154 | ||
155 | /* Set up the tdata information. */ | |
156 | ||
157 | static boolean | |
158 | versados_mkobject (abfd) | |
159 | bfd *abfd; | |
160 | { | |
161 | if (abfd->tdata.versados_data == NULL) | |
162 | { | |
163 | tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type)); | |
164 | if (tdata == NULL) | |
165 | { | |
166 | bfd_set_error (bfd_error_no_memory); | |
167 | return false; | |
168 | } | |
169 | abfd->tdata.versados_data = tdata; | |
170 | tdata->symbols = NULL; | |
c3246d9b | 171 | VDATA (abfd)->alert = 0x12345678; |
e6304bc7 SC |
172 | } |
173 | ||
174 | bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0); | |
175 | return true; | |
176 | } | |
177 | ||
178 | ||
179 | /* Report a problem in an S record file. FIXME: This probably should | |
180 | not call fprintf, but we really do need some mechanism for printing | |
181 | error messages. */ | |
182 | ||
183 | ||
184 | ||
185 | static asymbol * | |
186 | versados_new_symbol (abfd, snum, name, val, sec) | |
187 | bfd *abfd; | |
188 | int snum; | |
189 | const char *name; | |
190 | bfd_vma val; | |
191 | asection *sec; | |
192 | { | |
193 | asymbol *n = VDATA (abfd)->symbols + snum; | |
194 | n->name = name; | |
195 | n->value = val; | |
196 | n->section = sec; | |
197 | n->the_bfd = abfd; | |
198 | n->flags = 0; | |
199 | return n; | |
200 | } | |
201 | ||
202 | ||
203 | static int | |
204 | get_record (abfd, ptr) | |
205 | bfd *abfd; | |
206 | union ext_any *ptr; | |
207 | { | |
208 | bfd_read (&ptr->size, 1, 1, abfd); | |
209 | if (bfd_read ((char *) ptr + 1, 1, ptr->size, abfd) != ptr->size) | |
210 | return 0; | |
211 | return 1; | |
212 | } | |
213 | ||
214 | int | |
215 | get_4 (pp) | |
216 | unsigned char **pp; | |
217 | { | |
218 | unsigned char *p = *pp; | |
219 | *pp += 4; | |
220 | return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | (p[3] << 0); | |
221 | } | |
222 | ||
223 | void | |
224 | get_10 (pp, name) | |
225 | unsigned char **pp; | |
226 | char *name; | |
227 | { | |
228 | char *p = (char *) *pp; | |
229 | int len = 10; | |
230 | *pp += len; | |
231 | while (*p != ' ' | |
232 | && len) | |
233 | { | |
234 | *name++ = *p++; | |
235 | len--; | |
236 | } | |
237 | *name = 0; | |
238 | } | |
239 | ||
240 | static char * | |
241 | new_symbol_string (abfd, name) | |
242 | bfd *abfd; | |
243 | char *name; | |
244 | { | |
245 | char *n = VDATA (abfd)->strings; | |
246 | strcpy (VDATA (abfd)->strings, name); | |
247 | VDATA (abfd)->strings += strlen (VDATA (abfd)->strings) + 1; | |
248 | return n; | |
249 | } | |
250 | ||
251 | ||
252 | static void | |
253 | process_esd (abfd, esd, pass) | |
254 | bfd *abfd; | |
255 | struct ext_esd *esd; | |
256 | int pass; | |
257 | { | |
258 | /* Read through the ext def for the est entries */ | |
259 | int togo = esd->size - 2; | |
260 | bfd_vma size; | |
261 | bfd_vma start; | |
262 | asection *sec; | |
263 | char name[11]; | |
264 | unsigned char *ptr = esd->esd_entries; | |
265 | unsigned char *end = ptr + togo; | |
266 | while (ptr < end) | |
267 | { | |
268 | int scn = *ptr & 0xf; | |
269 | int typ = (*ptr >> 4) & 0xf; | |
270 | ||
271 | /* Declare this section */ | |
272 | sprintf (name, "%d", scn); | |
273 | sec = bfd_make_section_old_way (abfd, strdup (name)); | |
274 | sec->target_index = scn; | |
275 | EDATA (abfd, scn).section = sec; | |
276 | ptr++; | |
277 | switch (typ) | |
278 | { | |
279 | default: | |
280 | abort (); | |
c3246d9b | 281 | case ESD_XREF_SEC: |
e6304bc7 SC |
282 | case ESD_XREF_SYM: |
283 | { | |
c3246d9b | 284 | int snum = VDATA (abfd)->ref_idx++; |
e6304bc7 SC |
285 | get_10 (&ptr, name); |
286 | if (pass == 1) | |
287 | { | |
288 | VDATA (abfd)->stringlen += strlen (name) + 1; | |
289 | } | |
290 | else | |
291 | { | |
292 | int esidx; | |
293 | asymbol *s; | |
294 | char *n = new_symbol_string (abfd, name); | |
295 | s = versados_new_symbol (abfd, snum, n, 0, | |
296 | &bfd_und_section, scn); | |
297 | esidx = VDATA (abfd)->es_done++; | |
298 | RDATA (abfd, esidx - ES_BASE) = s; | |
299 | } | |
300 | } | |
301 | break; | |
c3246d9b ILT |
302 | |
303 | ||
e6304bc7 SC |
304 | case ESD_ABS: |
305 | size = get_4 (&ptr); | |
306 | start = get_4 (&ptr); | |
307 | break; | |
c3246d9b ILT |
308 | case ESD_STD_REL_SEC: |
309 | case ESD_SHRT_REL_SEC: | |
e6304bc7 SC |
310 | { |
311 | sec->_raw_size = get_4 (&ptr); | |
c3246d9b | 312 | sec->flags |= SEC_ALLOC; |
e6304bc7 SC |
313 | } |
314 | break; | |
c3246d9b ILT |
315 | case ESD_XDEF_IN_ABS: |
316 | sec = (asection *) & bfd_abs_section; | |
e6304bc7 SC |
317 | case ESD_XDEF_IN_SEC: |
318 | { | |
c3246d9b | 319 | int snum = VDATA (abfd)->def_idx++; |
e6304bc7 SC |
320 | long val; |
321 | get_10 (&ptr, name); | |
322 | val = get_4 (&ptr); | |
323 | if (pass == 1) | |
324 | { | |
325 | /* Just remember the symbol */ | |
326 | VDATA (abfd)->stringlen += strlen (name) + 1; | |
327 | } | |
328 | else | |
329 | { | |
330 | asymbol *s; | |
331 | char *n = new_symbol_string (abfd, name); | |
c3246d9b | 332 | s = versados_new_symbol (abfd, snum + VDATA (abfd)->nrefs, n, val, sec, scn); |
e6304bc7 SC |
333 | s->flags |= BSF_GLOBAL; |
334 | } | |
335 | } | |
336 | break; | |
337 | } | |
338 | } | |
339 | } | |
340 | ||
341 | #define R_RELWORD 1 | |
342 | #define R_RELLONG 2 | |
343 | #define R_RELWORD_NEG 3 | |
344 | #define R_RELLONG_NEG 4 | |
345 | ||
346 | reloc_howto_type versados_howto_table[] = | |
347 | { | |
348 | HOWTO (R_RELWORD, 0, 1, 16, false, | |
c3246d9b | 349 | 0, complain_overflow_dont, 0, |
e6304bc7 SC |
350 | "+v16", true, 0x0000ffff, 0x0000ffff, false), |
351 | HOWTO (R_RELLONG, 0, 2, 32, false, | |
c3246d9b | 352 | 0, complain_overflow_dont, 0, |
e6304bc7 SC |
353 | "+v32", true, 0xffffffff, 0xffffffff, false), |
354 | ||
355 | HOWTO (R_RELWORD_NEG, 0, -1, 16, false, | |
c3246d9b | 356 | 0, complain_overflow_dont, 0, |
e6304bc7 SC |
357 | "-v16", true, 0x0000ffff, 0x0000ffff, false), |
358 | HOWTO (R_RELLONG_NEG, 0, -2, 32, false, | |
c3246d9b | 359 | 0, complain_overflow_dont, 0, |
e6304bc7 SC |
360 | "-v32", true, 0xffffffff, 0xffffffff, false), |
361 | }; | |
362 | ||
363 | ||
c3246d9b ILT |
364 | static int |
365 | get_offset (len, ptr) | |
366 | int len; | |
367 | unsigned char *ptr; | |
368 | { | |
369 | int val = 0; | |
370 | if (len) | |
371 | { | |
372 | int i; | |
373 | val = *ptr++; | |
374 | if (val & 0x80) | |
375 | val |= ~0xff; | |
376 | for (i = 1; i < len; i++) | |
377 | val = (val << 8) | *ptr++; | |
378 | } | |
379 | ||
380 | return val; | |
381 | } | |
382 | ||
e6304bc7 SC |
383 | static void |
384 | process_otr (abfd, otr, pass) | |
385 | bfd *abfd; | |
386 | struct ext_otr *otr; | |
387 | int pass; | |
388 | { | |
389 | unsigned long shift; | |
390 | long val; | |
391 | unsigned char *srcp = otr->data; | |
392 | unsigned char *endp = (unsigned char *) otr + otr->size; | |
393 | unsigned int bits = (otr->map[0] << 24) | |
394 | | (otr->map[1] << 16) | |
395 | | (otr->map[2] << 8) | |
396 | | (otr->map[3] << 0); | |
397 | ||
c3246d9b ILT |
398 | struct esdid *esdid = &EDATA (abfd, otr->esdid - 1); |
399 | unsigned char *contents = esdid->contents; | |
400 | int need_contents = 0; | |
401 | int dst_idx = esdid->pc; | |
e6304bc7 | 402 | |
c3246d9b | 403 | for (shift = (1 << 31); shift && srcp < endp; shift >>= 1) |
e6304bc7 SC |
404 | { |
405 | if (bits & shift) | |
406 | { | |
407 | int flag = *srcp++; | |
c3246d9b | 408 | int esdids = (flag >> 5) & 0x7; |
e6304bc7 | 409 | int sizeinwords = ((flag >> 3) & 1) ? 2 : 1; |
c3246d9b | 410 | int offsetlen = flag & 0x7; |
e6304bc7 | 411 | int j; |
e6304bc7 | 412 | |
e6304bc7 | 413 | |
c3246d9b ILT |
414 | if (esdids == 0) |
415 | { | |
416 | /* A zero esdid means the new pc is the offset given */ | |
417 | dst_idx += get_offset (offsetlen, srcp); | |
418 | srcp += offsetlen; | |
e6304bc7 | 419 | } |
c3246d9b | 420 | else |
e6304bc7 | 421 | { |
c3246d9b ILT |
422 | int val = get_offset (offsetlen, srcp + esdids); |
423 | if (pass == 1) | |
424 | need_contents = 1; | |
425 | else | |
426 | for (j = 0; j < sizeinwords * 2; j++) | |
427 | { | |
428 | contents[dst_idx + (sizeinwords * 2) - j - 1] = val; | |
429 | val >>= 8; | |
430 | } | |
431 | ||
432 | for (j = 0; j < esdids; j++) | |
e6304bc7 | 433 | { |
c3246d9b ILT |
434 | int esdid = *srcp++; |
435 | ||
436 | if (esdid) | |
437 | { | |
438 | int rn = EDATA (abfd, otr->esdid - 1).relocs++; | |
439 | if (pass == 1) | |
440 | { | |
441 | /* this is the first pass over the data, | |
442 | just remember that we need a reloc */ | |
443 | } | |
444 | else | |
445 | { | |
446 | arelent *n = | |
447 | EDATA (abfd, otr->esdid - 1).section->relocation + rn; | |
448 | n->address = dst_idx; | |
449 | ||
450 | n->sym_ptr_ptr = (asymbol **) esdid; | |
451 | n->addend = 0; | |
452 | n->howto = versados_howto_table + ((j & 1) * 2) + (sizeinwords - 1); | |
453 | } | |
454 | } | |
e6304bc7 SC |
455 | } |
456 | srcp += offsetlen; | |
c3246d9b | 457 | dst_idx += sizeinwords * 2; |
e6304bc7 | 458 | } |
e6304bc7 SC |
459 | } |
460 | else | |
461 | { | |
c3246d9b ILT |
462 | need_contents = 1; |
463 | if (dst_idx < esdid->section->_raw_size) | |
464 | if (pass == 2) | |
465 | { | |
466 | /* absolute code, comes in 16 bit lumps */ | |
467 | contents[dst_idx] = srcp[0]; | |
468 | contents[dst_idx + 1] = srcp[1]; | |
469 | } | |
e6304bc7 SC |
470 | dst_idx += 2; |
471 | srcp += 2; | |
472 | } | |
473 | } | |
474 | EDATA (abfd, otr->esdid - 1).pc = dst_idx; | |
475 | ||
c3246d9b ILT |
476 | if (!contents && need_contents) |
477 | esdid->contents = (unsigned char *) bfd_alloc (abfd, esdid->section->_raw_size); | |
478 | ||
479 | ||
e6304bc7 SC |
480 | } |
481 | ||
482 | static boolean | |
483 | versados_scan (abfd) | |
484 | bfd *abfd; | |
485 | { | |
486 | int loop = 1; | |
487 | int i; | |
488 | int j; | |
c3246d9b ILT |
489 | int nsecs = 0; |
490 | ||
491 | VDATA (abfd)->nrefs = 0; | |
492 | VDATA (abfd)->ndefs = 0; | |
493 | VDATA (abfd)->ref_idx = 0; | |
494 | VDATA (abfd)->def_idx = 0; | |
e6304bc7 SC |
495 | |
496 | while (loop) | |
497 | { | |
498 | union ext_any any; | |
499 | if (!get_record (abfd, &any)) | |
500 | return true; | |
501 | switch (any.header.type) | |
502 | { | |
503 | case VHEADER: | |
504 | break; | |
505 | case VEND: | |
506 | loop = 0; | |
507 | break; | |
c3246d9b | 508 | case VESTDEF: |
e6304bc7 SC |
509 | process_esd (abfd, &any.esd, 1); |
510 | break; | |
511 | case VOTR: | |
512 | process_otr (abfd, &any.otr, 1); | |
513 | break; | |
514 | } | |
515 | } | |
516 | ||
517 | /* Now allocate space for the relocs and sections */ | |
518 | ||
c3246d9b ILT |
519 | VDATA (abfd)->nrefs = VDATA (abfd)->ref_idx; |
520 | VDATA (abfd)->ndefs = VDATA (abfd)->def_idx; | |
521 | VDATA (abfd)->ref_idx = 0; | |
522 | VDATA (abfd)->def_idx = 0; | |
523 | ||
524 | abfd->symcount = VDATA (abfd)->nrefs + VDATA (abfd)->ndefs; | |
525 | ||
e6304bc7 SC |
526 | for (i = 0; i < 16; i++) |
527 | { | |
528 | struct esdid *esdid = &EDATA (abfd, i); | |
529 | if (esdid->section) | |
530 | { | |
531 | esdid->section->relocation | |
e0151f38 | 532 | = (arelent *) bfd_alloc (abfd, sizeof (arelent) * esdid->relocs); |
e6304bc7 | 533 | |
e6304bc7 | 534 | esdid->pc = 0; |
c3246d9b ILT |
535 | |
536 | if (esdid->contents) | |
537 | esdid->section->flags |= SEC_HAS_CONTENTS | SEC_LOAD; | |
538 | ||
e6304bc7 SC |
539 | esdid->section->reloc_count = esdid->relocs; |
540 | if (esdid->relocs) | |
541 | esdid->section->flags |= SEC_RELOC; | |
c3246d9b | 542 | |
e6304bc7 SC |
543 | esdid->relocs = 0; |
544 | ||
545 | /* Add an entry into the symbol table for it */ | |
c3246d9b | 546 | nsecs++; |
e6304bc7 SC |
547 | VDATA (abfd)->stringlen += strlen (esdid->section->name) + 1; |
548 | } | |
549 | } | |
c3246d9b ILT |
550 | |
551 | abfd->symcount += nsecs; | |
552 | ||
e0151f38 | 553 | VDATA (abfd)->symbols = (asymbol *) bfd_alloc (abfd, |
c3246d9b ILT |
554 | sizeof (asymbol) * (abfd->symcount)); |
555 | ||
e6304bc7 | 556 | VDATA (abfd)->strings = bfd_alloc (abfd, VDATA (abfd)->stringlen); |
e6304bc7 | 557 | |
e6304bc7 | 558 | |
c3246d9b ILT |
559 | /* Actually fill in the section symbols, |
560 | we stick them at the end of the table */ | |
561 | ||
562 | for (j = VDATA (abfd)->nrefs + VDATA (abfd)->ndefs, i = 0; i < 16; i++) | |
e6304bc7 SC |
563 | { |
564 | struct esdid *esdid = &EDATA (abfd, i); | |
565 | asection *sec = esdid->section; | |
566 | if (sec) | |
567 | { | |
568 | asymbol *s = VDATA (abfd)->symbols + j; | |
569 | s->name = new_symbol_string (abfd, sec->name); | |
570 | s->section = sec; | |
571 | s->flags = BSF_LOCAL; | |
572 | s->value = 0; | |
573 | s->the_bfd = abfd; | |
574 | j++; | |
575 | } | |
576 | } | |
e6304bc7 SC |
577 | if (abfd->symcount) |
578 | abfd->flags |= HAS_SYMS; | |
c3246d9b ILT |
579 | |
580 | /* Set this to nsecs - since we've already planted the section | |
581 | symbols */ | |
582 | VDATA (abfd)->nsecsyms = nsecs; | |
583 | ||
584 | VDATA (abfd)->ref_idx = 0; | |
585 | ||
e6304bc7 SC |
586 | return 1; |
587 | } | |
588 | ||
589 | ||
590 | ||
591 | /* Check whether an existing file is a versados file. */ | |
592 | ||
593 | static const bfd_target * | |
594 | versados_object_p (abfd) | |
595 | bfd *abfd; | |
596 | { | |
597 | struct ext_vheader ext; | |
598 | unsigned char len; | |
599 | ||
600 | if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET)) | |
601 | return NULL; | |
602 | ||
603 | ||
604 | bfd_read (&len, 1, 1, abfd); | |
605 | if (bfd_read (&ext.type, 1, len, abfd) != len | |
606 | || ext.type != '1') | |
607 | { | |
608 | bfd_set_error (bfd_error_wrong_format); | |
609 | return NULL; | |
610 | } | |
611 | ||
612 | /* ok, looks like a record, build the tdata and read | |
613 | in.. */ | |
614 | ||
615 | if (!versados_mkobject (abfd) | |
616 | || !versados_scan (abfd)) | |
617 | return NULL; | |
618 | ||
619 | return abfd->xvec; | |
620 | } | |
621 | ||
622 | ||
623 | static boolean | |
624 | versados_pass_2 (abfd) | |
625 | bfd *abfd; | |
626 | { | |
627 | union ext_any any; | |
628 | ||
629 | if (VDATA (abfd)->pass_2_done) | |
630 | return 1; | |
631 | ||
632 | if (bfd_seek (abfd, 0, SEEK_SET) != 0) | |
633 | return 0; | |
634 | ||
635 | VDATA (abfd)->es_done = ES_BASE; | |
636 | ||
c3246d9b | 637 | |
e6304bc7 SC |
638 | /* read records till we get to where we want to be */ |
639 | ||
640 | while (1) | |
641 | { | |
642 | get_record (abfd, &any); | |
643 | switch (any.header.type) | |
644 | { | |
645 | case VEND: | |
646 | VDATA (abfd)->pass_2_done = 1; | |
647 | return 1; | |
c3246d9b | 648 | case VESTDEF: |
e6304bc7 SC |
649 | process_esd (abfd, &any.esd, 2); |
650 | break; | |
651 | case VOTR: | |
652 | process_otr (abfd, &any.otr, 2); | |
653 | break; | |
654 | } | |
655 | } | |
656 | } | |
657 | ||
658 | static boolean | |
659 | versados_get_section_contents (abfd, section, location, offset, count) | |
660 | bfd *abfd; | |
661 | asection *section; | |
662 | PTR location; | |
663 | file_ptr offset; | |
664 | bfd_size_type count; | |
665 | { | |
666 | if (!versados_pass_2 (abfd)) | |
667 | return false; | |
668 | ||
669 | memcpy (location, | |
670 | EDATA (abfd, section->target_index).contents + offset, | |
671 | count); | |
672 | ||
673 | return true; | |
674 | } | |
675 | ||
676 | static boolean | |
677 | versados_set_section_contents (abfd, section, location, offset, bytes_to_do) | |
678 | bfd *abfd; | |
679 | sec_ptr section; | |
680 | PTR location; | |
681 | file_ptr offset; | |
682 | bfd_size_type bytes_to_do; | |
683 | { | |
684 | return false; | |
685 | } | |
686 | ||
687 | ||
688 | /*ARGSUSED */ | |
689 | static int | |
690 | versados_sizeof_headers (abfd, exec) | |
691 | bfd *abfd; | |
692 | boolean exec; | |
693 | { | |
694 | return 0; | |
695 | } | |
696 | ||
697 | static asymbol * | |
698 | versados_make_empty_symbol (abfd) | |
699 | bfd *abfd; | |
700 | { | |
701 | asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol)); | |
702 | if (new) | |
703 | new->the_bfd = abfd; | |
704 | return new; | |
705 | } | |
706 | ||
707 | /* Return the amount of memory needed to read the symbol table. */ | |
708 | ||
709 | static long | |
710 | versados_get_symtab_upper_bound (abfd) | |
711 | bfd *abfd; | |
712 | { | |
713 | return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *); | |
714 | } | |
715 | ||
716 | /* Return the symbol table. */ | |
717 | ||
718 | static long | |
719 | versados_get_symtab (abfd, alocation) | |
720 | bfd *abfd; | |
721 | asymbol **alocation; | |
722 | { | |
723 | unsigned int symcount = bfd_get_symcount (abfd); | |
724 | int i; | |
725 | asymbol *s; | |
726 | ||
727 | versados_pass_2 (abfd); | |
728 | ||
729 | for (i = 0, s = VDATA (abfd)->symbols; | |
730 | i < symcount; | |
731 | s++, i++) | |
732 | { | |
733 | *alocation++ = s; | |
734 | } | |
735 | ||
736 | *alocation = NULL; | |
737 | ||
738 | return symcount; | |
739 | } | |
740 | ||
741 | /*ARGSUSED */ | |
742 | void | |
743 | versados_get_symbol_info (ignore_abfd, symbol, ret) | |
744 | bfd *ignore_abfd; | |
745 | asymbol *symbol; | |
746 | symbol_info *ret; | |
747 | { | |
748 | bfd_symbol_info (symbol, ret); | |
749 | } | |
750 | ||
751 | /*ARGSUSED */ | |
752 | void | |
753 | versados_print_symbol (ignore_abfd, afile, symbol, how) | |
754 | bfd *ignore_abfd; | |
755 | PTR afile; | |
756 | asymbol *symbol; | |
757 | bfd_print_symbol_type how; | |
758 | { | |
759 | FILE *file = (FILE *) afile; | |
760 | switch (how) | |
761 | { | |
762 | case bfd_print_symbol_name: | |
763 | fprintf (file, "%s", symbol->name); | |
764 | break; | |
765 | default: | |
766 | bfd_print_symbol_vandf ((PTR) file, symbol); | |
767 | fprintf (file, " %-5s %s", | |
768 | symbol->section->name, | |
769 | symbol->name); | |
770 | ||
771 | } | |
772 | } | |
773 | ||
774 | long | |
775 | versados_get_reloc_upper_bound (abfd, asect) | |
776 | bfd *abfd; | |
777 | sec_ptr asect; | |
778 | { | |
779 | return (asect->reloc_count + 1) * sizeof (arelent *); | |
780 | } | |
781 | ||
782 | ||
783 | long | |
784 | versados_canonicalize_reloc (abfd, section, relptr, symbols) | |
785 | bfd *abfd; | |
786 | sec_ptr section; | |
787 | arelent **relptr; | |
788 | asymbol **symbols; | |
789 | { | |
790 | int count; | |
791 | arelent *src; | |
792 | ||
793 | versados_pass_2 (abfd); | |
794 | src = section->relocation; | |
795 | if (!EDATA (abfd, section->target_index).donerel) | |
796 | { | |
797 | EDATA (abfd, section->target_index).donerel = 1; | |
798 | /* translate from indexes to symptr ptrs */ | |
799 | for (count = 0; count < section->reloc_count; count++) | |
800 | { | |
801 | int esdid = (int) src[count].sym_ptr_ptr; | |
c3246d9b ILT |
802 | |
803 | if (esdid == 0) | |
e6304bc7 | 804 | { |
c3246d9b ILT |
805 | src[count].sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr; |
806 | } | |
807 | else if (esdid < ES_BASE) /* Section relative thing */ | |
808 | { | |
809 | struct esdid *e = &EDATA (abfd, esdid - 1); | |
810 | if (!section) | |
811 | { | |
812 | /** relocation relative to section which was | |
813 | never declared ! */ | |
814 | } | |
815 | src[count].sym_ptr_ptr = e->section->symbol_ptr_ptr; | |
e6304bc7 SC |
816 | } |
817 | else | |
818 | { | |
c3246d9b | 819 | src[count].sym_ptr_ptr = symbols + esdid - ES_BASE; |
e6304bc7 SC |
820 | } |
821 | ||
822 | } | |
823 | } | |
824 | ||
825 | for (count = 0; count < section->reloc_count; count++) | |
826 | { | |
827 | *relptr++ = src++; | |
828 | } | |
829 | *relptr = 0; | |
830 | return section->reloc_count; | |
831 | } | |
832 | ||
833 | #define versados_close_and_cleanup _bfd_generic_close_and_cleanup | |
834 | #define versados_bfd_free_cached_info _bfd_generic_bfd_free_cached_info | |
835 | #define versados_new_section_hook _bfd_generic_new_section_hook | |
836 | ||
837 | #define versados_bfd_is_local_label bfd_generic_is_local_label | |
838 | #define versados_get_lineno _bfd_nosymbols_get_lineno | |
839 | #define versados_find_nearest_line _bfd_nosymbols_find_nearest_line | |
840 | #define versados_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol | |
c3246d9b ILT |
841 | #define versados_read_minisymbols _bfd_generic_read_minisymbols |
842 | #define versados_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol | |
e6304bc7 SC |
843 | |
844 | #define versados_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup | |
845 | ||
846 | #define versados_set_arch_mach bfd_default_set_arch_mach | |
847 | ||
848 | #define versados_bfd_get_relocated_section_contents \ | |
849 | bfd_generic_get_relocated_section_contents | |
850 | #define versados_bfd_relax_section bfd_generic_relax_section | |
851 | #define versados_bfd_link_hash_table_create _bfd_generic_link_hash_table_create | |
852 | #define versados_bfd_link_add_symbols _bfd_generic_link_add_symbols | |
853 | #define versados_bfd_final_link _bfd_generic_final_link | |
e0151f38 | 854 | #define versados_bfd_link_split_section _bfd_generic_link_split_section |
e6304bc7 SC |
855 | |
856 | const bfd_target versados_vec = | |
857 | { | |
858 | "versados", /* name */ | |
859 | bfd_target_versados_flavour, | |
860 | true, /* target byte order */ | |
861 | true, /* target headers byte order */ | |
862 | (HAS_RELOC | EXEC_P | /* object flags */ | |
863 | HAS_LINENO | HAS_DEBUG | | |
864 | HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), | |
865 | (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS | |
866 | | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ | |
867 | 0, /* leading underscore */ | |
868 | ' ', /* ar_pad_char */ | |
869 | 16, /* ar_max_namelen */ | |
870 | 1, /* minimum alignment */ | |
871 | bfd_getb64, bfd_getb_signed_64, bfd_putb64, | |
872 | bfd_getb32, bfd_getb_signed_32, bfd_putb32, | |
873 | bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ | |
874 | bfd_getb64, bfd_getb_signed_64, bfd_putb64, | |
875 | bfd_getb32, bfd_getb_signed_32, bfd_putb32, | |
876 | bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ | |
877 | ||
878 | { | |
879 | _bfd_dummy_target, | |
880 | versados_object_p, /* bfd_check_format */ | |
881 | _bfd_dummy_target, | |
882 | _bfd_dummy_target, | |
883 | }, | |
884 | { | |
885 | bfd_false, | |
886 | versados_mkobject, | |
887 | _bfd_generic_mkarchive, | |
888 | bfd_false, | |
889 | }, | |
890 | { /* bfd_write_contents */ | |
891 | bfd_false, | |
892 | bfd_false, | |
893 | _bfd_write_archive_contents, | |
894 | bfd_false, | |
895 | }, | |
896 | ||
897 | BFD_JUMP_TABLE_GENERIC (versados), | |
898 | BFD_JUMP_TABLE_COPY (_bfd_generic), | |
899 | BFD_JUMP_TABLE_CORE (_bfd_nocore), | |
900 | BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), | |
901 | BFD_JUMP_TABLE_SYMBOLS (versados), | |
902 | BFD_JUMP_TABLE_RELOCS (versados), | |
903 | BFD_JUMP_TABLE_WRITE (versados), | |
904 | BFD_JUMP_TABLE_LINK (versados), | |
905 | BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), | |
906 | ||
907 | (PTR) 0 | |
908 | }; |