1 /* BFD back-end for Intel 960 b.out binaries.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3 Written by Cygnus Support.
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 3 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., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "bfdlink.h"
26 #include "genlink.h"
27 #include "bout.h"
28 #include "libiberty.h"
29
30 #include "aout/stab_gnu.h"
31 #include "libaout.h" /* BFD a.out internal data structures. */
32
33 #define ABS32CODE 0
34 #define ABS32CODE_SHRUNK 1
35 #define PCREL24 2
36 #define CALLJ 3
37 #define ABS32 4
38 #define PCREL13 5
39 #define ABS32_MAYBE_RELAXABLE 1
40 #define ABS32_WAS_RELAXABLE 2
41
42 #define ALIGNER 10
43 #define ALIGNDONE 11
44
45 static reloc_howto_type howto_reloc_callj =
46 HOWTO (CALLJ, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE);
47 static reloc_howto_type howto_reloc_abs32 =
48 HOWTO (ABS32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"abs32", TRUE, 0xffffffff,0xffffffff,FALSE);
49 static reloc_howto_type howto_reloc_pcrel24 =
50 HOWTO (PCREL24, 0, 2, 24, TRUE, 0, complain_overflow_signed,0,"pcrel24", TRUE, 0x00ffffff,0x00ffffff,FALSE);
51 static reloc_howto_type howto_reloc_pcrel13 =
52 HOWTO (PCREL13, 0, 2, 13, TRUE, 0, complain_overflow_signed,0,"pcrel13", TRUE, 0x00001fff,0x00001fff,FALSE);
53 static reloc_howto_type howto_reloc_abs32codeshrunk =
54 HOWTO (ABS32CODE_SHRUNK, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callx->callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE);
55 static reloc_howto_type howto_reloc_abs32code =
56 HOWTO (ABS32CODE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"callx", TRUE, 0xffffffff,0xffffffff,FALSE);
57
58 static reloc_howto_type howto_align_table[] =
59 {
60 HOWTO (ALIGNER, 0, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "align16", FALSE, 0, 0, FALSE),
61 HOWTO (ALIGNER, 0, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "align32", FALSE, 0, 0, FALSE),
62 HOWTO (ALIGNER, 0, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "align64", FALSE, 0, 0, FALSE),
63 HOWTO (ALIGNER, 0, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "align128", FALSE, 0, 0, FALSE),
64 };
65
66 static reloc_howto_type howto_done_align_table[] =
67 {
68 HOWTO (ALIGNDONE, 0x1, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "donealign16", FALSE, 0, 0, FALSE),
69 HOWTO (ALIGNDONE, 0x3, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "donealign32", FALSE, 0, 0, FALSE),
70 HOWTO (ALIGNDONE, 0x7, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "donealign64", FALSE, 0, 0, FALSE),
71 HOWTO (ALIGNDONE, 0xf, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "donealign128", FALSE, 0, 0, FALSE),
72 };
73
74 /* Swaps the information in an executable header taken from a raw byte
75 stream memory image, into the internal exec_header structure. */
76
77 static void
bout_swap_exec_header_in(bfd * abfd,struct external_exec * bytes,struct internal_exec * execp)78 bout_swap_exec_header_in (bfd *abfd,
79 struct external_exec *bytes,
80 struct internal_exec *execp)
81 {
82 /* Now fill in fields in the execp, from the bytes in the raw data. */
83 execp->a_info = H_GET_32 (abfd, bytes->e_info);
84 execp->a_text = GET_WORD (abfd, bytes->e_text);
85 execp->a_data = GET_WORD (abfd, bytes->e_data);
86 execp->a_bss = GET_WORD (abfd, bytes->e_bss);
87 execp->a_syms = GET_WORD (abfd, bytes->e_syms);
88 execp->a_entry = GET_WORD (abfd, bytes->e_entry);
89 execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
90 execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
91 execp->a_tload = GET_WORD (abfd, bytes->e_tload);
92 execp->a_dload = GET_WORD (abfd, bytes->e_dload);
93 execp->a_talign = bytes->e_talign[0];
94 execp->a_dalign = bytes->e_dalign[0];
95 execp->a_balign = bytes->e_balign[0];
96 execp->a_relaxable = bytes->e_relaxable[0];
97 }
98
99 /* Swaps the information in an internal exec header structure into the
100 supplied buffer ready for writing to disk. */
101
102 static void
bout_swap_exec_header_out(bfd * abfd,struct internal_exec * execp,struct external_exec * bytes)103 bout_swap_exec_header_out (bfd *abfd,
104 struct internal_exec *execp,
105 struct external_exec *bytes)
106 {
107 /* Now fill in fields in the raw data, from the fields in the exec struct. */
108 H_PUT_32 (abfd, execp->a_info , bytes->e_info);
109 PUT_WORD (abfd, execp->a_text , bytes->e_text);
110 PUT_WORD (abfd, execp->a_data , bytes->e_data);
111 PUT_WORD (abfd, execp->a_bss , bytes->e_bss);
112 PUT_WORD (abfd, execp->a_syms , bytes->e_syms);
113 PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
114 PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
115 PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
116 PUT_WORD (abfd, execp->a_tload , bytes->e_tload);
117 PUT_WORD (abfd, execp->a_dload , bytes->e_dload);
118 bytes->e_talign[0] = execp->a_talign;
119 bytes->e_dalign[0] = execp->a_dalign;
120 bytes->e_balign[0] = execp->a_balign;
121 bytes->e_relaxable[0] = execp->a_relaxable;
122 }
123
124 /* Finish up the opening of a b.out file for reading. Fill in all the
125 fields that are not handled by common code. */
126
127 static const bfd_target *
b_out_callback(bfd * abfd)128 b_out_callback (bfd *abfd)
129 {
130 struct internal_exec *execp = exec_hdr (abfd);
131 unsigned long bss_start;
132
133 /* Architecture and machine type. */
134 bfd_set_arch_mach (abfd,
135 bfd_arch_i960, /* B.out only used on i960. */
136 bfd_mach_i960_core /* Default. */
137 );
138
139 /* The positions of the string table and symbol table. */
140 obj_str_filepos (abfd) = N_STROFF (*execp);
141 obj_sym_filepos (abfd) = N_SYMOFF (*execp);
142
143 /* The alignments of the sections. */
144 obj_textsec (abfd)->alignment_power = execp->a_talign;
145 obj_datasec (abfd)->alignment_power = execp->a_dalign;
146 obj_bsssec (abfd)->alignment_power = execp->a_balign;
147
148 /* The starting addresses of the sections. */
149 obj_textsec (abfd)->vma = execp->a_tload;
150 obj_datasec (abfd)->vma = execp->a_dload;
151
152 obj_textsec (abfd)->lma = obj_textsec (abfd)->vma;
153 obj_datasec (abfd)->lma = obj_datasec (abfd)->vma;
154
155 /* And reload the sizes, since the aout module zaps them. */
156 obj_textsec (abfd)->size = execp->a_text;
157
158 bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section. */
159 obj_bsssec (abfd)->vma = align_power (bss_start, execp->a_balign);
160
161 obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma;
162
163 /* The file positions of the sections. */
164 obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
165 obj_datasec (abfd)->filepos = N_DATOFF (*execp);
166
167 /* The file positions of the relocation info. */
168 obj_textsec (abfd)->rel_filepos = N_TROFF (*execp);
169 obj_datasec (abfd)->rel_filepos = N_DROFF (*execp);
170
171 adata (abfd).page_size = 1; /* Not applicable. */
172 adata (abfd).segment_size = 1; /* Not applicable. */
173 adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE;
174
175 if (execp->a_relaxable)
176 abfd->flags |= BFD_IS_RELAXABLE;
177 return abfd->xvec;
178 }
179
180 static const bfd_target *
b_out_object_p(bfd * abfd)181 b_out_object_p (bfd *abfd)
182 {
183 struct internal_exec anexec;
184 struct external_exec exec_bytes;
185 bfd_size_type amt = EXEC_BYTES_SIZE;
186
187 if (bfd_bread ((void *) &exec_bytes, amt, abfd) != amt)
188 {
189 if (bfd_get_error () != bfd_error_system_call)
190 bfd_set_error (bfd_error_wrong_format);
191 return 0;
192 }
193
194 anexec.a_info = H_GET_32 (abfd, exec_bytes.e_info);
195
196 if (N_BADMAG (anexec))
197 {
198 bfd_set_error (bfd_error_wrong_format);
199 return 0;
200 }
201
202 bout_swap_exec_header_in (abfd, &exec_bytes, &anexec);
203 return aout_32_some_aout_object_p (abfd, &anexec, b_out_callback);
204 }
205
206 struct bout_data_struct
207 {
208 struct aoutdata a;
209 struct internal_exec e;
210 };
211
212 static bfd_boolean
b_out_mkobject(bfd * abfd)213 b_out_mkobject (bfd *abfd)
214 {
215 struct bout_data_struct *rawptr;
216 bfd_size_type amt = sizeof (struct bout_data_struct);
217
218 rawptr = bfd_zalloc (abfd, amt);
219 if (rawptr == NULL)
220 return FALSE;
221
222 abfd->tdata.bout_data = rawptr;
223 exec_hdr (abfd) = &rawptr->e;
224
225 obj_textsec (abfd) = NULL;
226 obj_datasec (abfd) = NULL;
227 obj_bsssec (abfd) = NULL;
228
229 return TRUE;
230 }
231
232 static int
b_out_symbol_cmp(const void * a_ptr,const void * b_ptr)233 b_out_symbol_cmp (const void * a_ptr, const void * b_ptr)
234 {
235 struct aout_symbol ** a = (struct aout_symbol **) a_ptr;
236 struct aout_symbol ** b = (struct aout_symbol **) b_ptr;
237 asection *sec;
238 bfd_vma av, bv;
239
240 /* Primary key is address. */
241 sec = bfd_get_section (&(*a)->symbol);
242 av = sec->output_section->vma + sec->output_offset + (*a)->symbol.value;
243 sec = bfd_get_section (&(*b)->symbol);
244 bv = sec->output_section->vma + sec->output_offset + (*b)->symbol.value;
245
246 if (av < bv)
247 return -1;
248 if (av > bv)
249 return 1;
250
251 /* Secondary key puts CALLNAME syms last and BALNAME syms first,
252 so that they have the best chance of being contiguous. */
253 if (IS_BALNAME ((*a)->other) || IS_CALLNAME ((*b)->other))
254 return -1;
255 if (IS_CALLNAME ((*a)->other) || IS_BALNAME ((*b)->other))
256 return 1;
257
258 return 0;
259 }
260
261 static bfd_boolean
b_out_squirt_out_relocs(bfd * abfd,asection * section)262 b_out_squirt_out_relocs (bfd *abfd, asection *section)
263 {
264 arelent **generic;
265 int r_extern = 0;
266 int r_idx;
267 int incode_mask;
268 int len_1;
269 unsigned int count = section->reloc_count;
270 struct relocation_info *native, *natptr;
271 bfd_size_type natsize;
272 int extern_mask, pcrel_mask, len_2, callj_mask;
273
274 if (count == 0)
275 return TRUE;
276
277 generic = section->orelocation;
278 natsize = (bfd_size_type) count * sizeof (struct relocation_info);
279 native = bfd_malloc (natsize);
280 if (!native && natsize != 0)
281 return FALSE;
282
283 if (bfd_header_big_endian (abfd))
284 {
285 /* Big-endian bit field allocation order. */
286 pcrel_mask = 0x80;
287 extern_mask = 0x10;
288 len_2 = 0x40;
289 len_1 = 0x20;
290 callj_mask = 0x02;
291 incode_mask = 0x08;
292 }
293 else
294 {
295 /* Little-endian bit field allocation order. */
296 pcrel_mask = 0x01;
297 extern_mask = 0x08;
298 len_2 = 0x04;
299 len_1 = 0x02;
300 callj_mask = 0x40;
301 incode_mask = 0x10;
302 }
303
304 for (natptr = native; count > 0; --count, ++natptr, ++generic)
305 {
306 arelent *g = *generic;
307 unsigned char *raw = (unsigned char *) natptr;
308 asymbol *sym = *(g->sym_ptr_ptr);
309 asection *output_section = sym->section->output_section;
310
311 H_PUT_32 (abfd, g->address, raw);
312 /* Find a type in the output format which matches the input howto -
313 at the moment we assume input format == output format FIXME!! */
314 r_idx = 0;
315 /* FIXME: Need callj stuff here, and to check the howto entries to
316 be sure they are real for this architecture. */
317 if (g->howto== &howto_reloc_callj)
318 raw[7] = callj_mask + pcrel_mask + len_2;
319 else if (g->howto == &howto_reloc_pcrel24)
320 raw[7] = pcrel_mask + len_2;
321 else if (g->howto == &howto_reloc_pcrel13)
322 raw[7] = pcrel_mask + len_1;
323 else if (g->howto == &howto_reloc_abs32code)
324 raw[7] = len_2 + incode_mask;
325 else if (g->howto >= howto_align_table
326 && g->howto <= (howto_align_table + ARRAY_SIZE (howto_align_table) - 1))
327 {
328 /* symnum == -2; extern_mask not set, pcrel_mask set. */
329 r_idx = -2;
330 r_extern = 0;
331 raw[7] = (pcrel_mask
332 | ((g->howto - howto_align_table) << 1));
333 }
334 else
335 raw[7] = len_2;
336
337 if (r_idx != 0)
338 /* Already mucked with r_extern, r_idx. */;
339 else if (bfd_is_com_section (output_section)
340 || bfd_is_abs_section (output_section)
341 || bfd_is_und_section (output_section))
342 {
343 if (bfd_abs_section_ptr->symbol == sym)
344 {
345 /* Whoops, looked like an abs symbol, but is really an offset
346 from the abs section. */
347 r_idx = 0;
348 r_extern = 0;
349 }
350 else
351 {
352 /* Fill in symbol. */
353 r_extern = 1;
354 r_idx = (*g->sym_ptr_ptr)->udata.i;
355 }
356 }
357 else
358 {
359 /* Just an ordinary section. */
360 r_extern = 0;
361 r_idx = output_section->target_index;
362 }
363
364 if (bfd_header_big_endian (abfd))
365 {
366 raw[4] = (unsigned char) (r_idx >> 16);
367 raw[5] = (unsigned char) (r_idx >> 8);
368 raw[6] = (unsigned char) (r_idx );
369 }
370 else
371 {
372 raw[6] = (unsigned char) (r_idx >> 16);
373 raw[5] = (unsigned char) (r_idx>> 8);
374 raw[4] = (unsigned char) (r_idx );
375 }
376
377 if (r_extern)
378 raw[7] |= extern_mask;
379 }
380
381 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
382 {
383 free (native);
384 return FALSE;
385 }
386
387 free (native);
388
389 return TRUE;
390 }
391
392 static bfd_boolean
b_out_write_object_contents(bfd * abfd)393 b_out_write_object_contents (bfd *abfd)
394 {
395 struct external_exec swapped_hdr;
396 bfd_size_type amt;
397
398 if (! aout_32_make_sections (abfd))
399 return FALSE;
400
401 exec_hdr (abfd)->a_info = BMAGIC;
402
403 exec_hdr (abfd)->a_text = obj_textsec (abfd)->size;
404 exec_hdr (abfd)->a_data = obj_datasec (abfd)->size;
405 exec_hdr (abfd)->a_bss = obj_bsssec (abfd)->size;
406 exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd) * 12;
407 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
408 exec_hdr (abfd)->a_trsize = (obj_textsec (abfd)->reloc_count) * 8;
409 exec_hdr (abfd)->a_drsize = (obj_datasec (abfd)->reloc_count) * 8;
410
411 exec_hdr (abfd)->a_talign = obj_textsec (abfd)->alignment_power;
412 exec_hdr (abfd)->a_dalign = obj_datasec (abfd)->alignment_power;
413 exec_hdr (abfd)->a_balign = obj_bsssec (abfd)->alignment_power;
414
415 exec_hdr (abfd)->a_tload = obj_textsec (abfd)->vma;
416 exec_hdr (abfd)->a_dload = obj_datasec (abfd)->vma;
417
418 bout_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
419
420 amt = EXEC_BYTES_SIZE;
421 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
422 || bfd_bwrite ((void *) &swapped_hdr, amt, abfd) != amt)
423 return FALSE;
424
425 /* Now write out reloc info, followed by syms and strings */
426 if (bfd_get_symcount (abfd) != 0)
427 {
428 /* Make sure {CALL,BAL}NAME symbols remain adjacent on output
429 by sorting. This is complicated by the fact that stabs are
430 also ordered. Solve this by shifting all stabs to the end
431 in order, then sorting the rest. */
432
433 asymbol **outsyms, **p, **q;
434
435 outsyms = bfd_get_outsymbols (abfd);
436 p = outsyms + bfd_get_symcount (abfd);
437
438 for (q = p--; p >= outsyms; p--)
439 {
440 if ((*p)->flags & BSF_DEBUGGING)
441 {
442 asymbol *t = *--q;
443 *q = *p;
444 *p = t;
445 }
446 }
447
448 if (q > outsyms)
449 qsort (outsyms, (size_t) (q - outsyms), sizeof (asymbol*),
450 b_out_symbol_cmp);
451
452 /* Back to your regularly scheduled program. */
453 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF (*exec_hdr (abfd))), SEEK_SET)
454 != 0)
455 return FALSE;
456
457 if (! aout_32_write_syms (abfd))
458 return FALSE;
459
460 if (bfd_seek (abfd, (file_ptr) (N_TROFF (*exec_hdr (abfd))), SEEK_SET)
461 != 0)
462 return FALSE;
463
464 if (!b_out_squirt_out_relocs (abfd, obj_textsec (abfd)))
465 return FALSE;
466 if (bfd_seek (abfd, (file_ptr) (N_DROFF (*exec_hdr (abfd))), SEEK_SET)
467 != 0)
468 return FALSE;
469
470 if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd)))
471 return FALSE;
472 }
473 return TRUE;
474 }
475
476 /* Some reloc hackery. */
477
478 #define CALLS 0x66003800 /* Template for 'calls' instruction */
479 #define BAL 0x0b000000 /* Template for 'bal' instruction */
480 #define BAL_MASK 0x00ffffff
481 #define BALX 0x85f00000 /* Template for 'balx' instruction */
482 #define BALX_MASK 0x0007ffff
483 #define CALL 0x09000000
484 #define PCREL13_MASK 0x1fff
485
486 #define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma)
487
488 static bfd_vma
get_value(arelent * reloc,struct bfd_link_info * link_info,asection * input_section)489 get_value (arelent *reloc,
490 struct bfd_link_info *link_info,
491 asection *input_section)
492 {
493 bfd_vma value;
494 asymbol *symbol = *(reloc->sym_ptr_ptr);
495
496 /* A symbol holds a pointer to a section, and an offset from the
497 base of the section. To relocate, we find where the section will
498 live in the output and add that in. */
499 if (bfd_is_und_section (symbol->section))
500 {
501 struct bfd_link_hash_entry *h;
502
503 /* The symbol is undefined in this BFD. Look it up in the
504 global linker hash table. FIXME: This should be changed when
505 we convert b.out to use a specific final_link function and
506 change the interface to bfd_relax_section to not require the
507 generic symbols. */
508 h = bfd_wrapped_link_hash_lookup (input_section->owner, link_info,
509 bfd_asymbol_name (symbol),
510 FALSE, FALSE, TRUE);
511 if (h != (struct bfd_link_hash_entry *) NULL
512 && (h->type == bfd_link_hash_defined
513 || h->type == bfd_link_hash_defweak))
514 value = h->u.def.value + output_addr (h->u.def.section);
515 else if (h != (struct bfd_link_hash_entry *) NULL
516 && h->type == bfd_link_hash_common)
517 value = h->u.c.size;
518 else
519 {
520 if (! ((*link_info->callbacks->undefined_symbol)
521 (link_info, bfd_asymbol_name (symbol),
522 input_section->owner, input_section, reloc->address,
523 TRUE)))
524 abort ();
525 value = 0;
526 }
527 }
528 else
529 value = symbol->value + output_addr (symbol->section);
530
531 /* Add the value contained in the relocation. */
532 value += reloc->addend;
533
534 return value;
535 }
536
537 /* Magic to turn callx into calljx. */
538
539 static bfd_reloc_status_type
calljx_callback(bfd * abfd,struct bfd_link_info * link_info,arelent * reloc_entry,void * src,void * dst,asection * input_section)540 calljx_callback (bfd *abfd,
541 struct bfd_link_info *link_info,
542 arelent *reloc_entry,
543 void * src,
544 void * dst,
545 asection *input_section)
546 {
547 int word = bfd_get_32 (abfd, src);
548 asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
549 aout_symbol_type *symbol = aout_symbol (symbol_in);
550 bfd_vma value;
551
552 value = get_value (reloc_entry, link_info, input_section);
553
554 if (IS_CALLNAME (symbol->other))
555 {
556 aout_symbol_type *balsym = symbol+1;
557 int inst = bfd_get_32 (abfd, (bfd_byte *) src-4);
558
559 /* The next symbol should be an N_BALNAME. */
560 BFD_ASSERT (IS_BALNAME (balsym->other));
561 inst &= BALX_MASK;
562 inst |= BALX;
563 bfd_put_32 (abfd, (bfd_vma) inst, (bfd_byte *) dst-4);
564 symbol = balsym;
565 value = (symbol->symbol.value
566 + output_addr (symbol->symbol.section));
567 }
568
569 word += value + reloc_entry->addend;
570
571 bfd_put_32 (abfd, (bfd_vma) word, dst);
572 return bfd_reloc_ok;
573 }
574
575 /* Magic to turn call into callj. */
576
577 static bfd_reloc_status_type
callj_callback(bfd * abfd,struct bfd_link_info * link_info,arelent * reloc_entry,void * data,unsigned int srcidx,unsigned int dstidx,asection * input_section,bfd_boolean shrinking)578 callj_callback (bfd *abfd,
579 struct bfd_link_info *link_info,
580 arelent *reloc_entry,
581 void * data,
582 unsigned int srcidx,
583 unsigned int dstidx,
584 asection *input_section,
585 bfd_boolean shrinking)
586 {
587 int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
588 asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
589 aout_symbol_type *symbol = aout_symbol (symbol_in);
590 bfd_vma value;
591
592 value = get_value (reloc_entry, link_info, input_section);
593
594 if (IS_OTHER (symbol->other))
595 /* Call to a system procedure - replace code with system
596 procedure number. */
597 word = CALLS | (symbol->other - 1);
598
599 else if (IS_CALLNAME (symbol->other))
600 {
601 aout_symbol_type *balsym = symbol+1;
602
603 /* The next symbol should be an N_BALNAME. */
604 BFD_ASSERT (IS_BALNAME (balsym->other));
605
606 /* We are calling a leaf, so replace the call instruction with a
607 bal. */
608 word = BAL | ((word
609 + output_addr (balsym->symbol.section)
610 + balsym->symbol.value + reloc_entry->addend
611 - dstidx
612 - output_addr (input_section))
613 & BAL_MASK);
614 }
615 else if ((symbol->symbol.flags & BSF_SECTION_SYM) != 0)
616 {
617 /* A callj against a symbol in the same section is a fully
618 resolved relative call. We don't need to do anything here.
619 If the symbol is not in the same section, I'm not sure what
620 to do; fortunately, this case will probably never arise. */
621 BFD_ASSERT (! shrinking);
622 BFD_ASSERT (symbol->symbol.section == input_section);
623 }
624 else
625 word = CALL | (((word & BAL_MASK)
626 + value
627 + reloc_entry->addend
628 - (shrinking ? dstidx : 0)
629 - output_addr (input_section))
630 & BAL_MASK);
631
632 bfd_put_32 (abfd, (bfd_vma) word, (bfd_byte *) data + dstidx);
633 return bfd_reloc_ok;
634 }
635
636 static reloc_howto_type *
b_out_bfd_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)637 b_out_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
638 bfd_reloc_code_real_type code)
639 {
640 switch (code)
641 {
642 default:
643 return 0;
644 case BFD_RELOC_I960_CALLJ:
645 return &howto_reloc_callj;
646 case BFD_RELOC_32:
647 case BFD_RELOC_CTOR:
648 return &howto_reloc_abs32;
649 case BFD_RELOC_24_PCREL:
650 return &howto_reloc_pcrel24;
651 }
652 }
653
654 static reloc_howto_type *
b_out_bfd_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)655 b_out_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
656 const char *r_name)
657 {
658 if (strcasecmp (howto_reloc_callj.name, r_name) == 0)
659 return &howto_reloc_callj;
660 if (strcasecmp (howto_reloc_abs32.name, r_name) == 0)
661 return &howto_reloc_abs32;
662 if (strcasecmp (howto_reloc_pcrel24.name, r_name) == 0)
663 return &howto_reloc_pcrel24;
664
665 return NULL;
666 }
667
668 /* Allocate enough room for all the reloc entries, plus pointers to them all. */
669
670 static bfd_boolean
b_out_slurp_reloc_table(bfd * abfd,sec_ptr asect,asymbol ** symbols)671 b_out_slurp_reloc_table (bfd *abfd, sec_ptr asect, asymbol **symbols)
672 {
673 struct relocation_info *rptr;
674 unsigned int counter;
675 arelent *cache_ptr;
676 int extern_mask, pcrel_mask, callj_mask, length_shift;
677 int incode_mask;
678 int size_mask;
679 bfd_vma prev_addr = 0;
680 unsigned int count;
681 bfd_size_type reloc_size, amt;
682 struct relocation_info *relocs;
683 arelent *reloc_cache;
684
685 if (asect->relocation)
686 return TRUE;
687
688 if (!aout_32_slurp_symbol_table (abfd))
689 return FALSE;
690
691 if (asect == obj_datasec (abfd))
692 reloc_size = exec_hdr (abfd)->a_drsize;
693 else if (asect == obj_textsec (abfd))
694 reloc_size = exec_hdr (abfd)->a_trsize;
695 else if (asect == obj_bsssec (abfd))
696 reloc_size = 0;
697 else
698 {
699 bfd_set_error (bfd_error_invalid_operation);
700 return FALSE;
701 }
702
703 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
704 return FALSE;
705 count = reloc_size / sizeof (struct relocation_info);
706
707 relocs = bfd_malloc (reloc_size);
708 if (!relocs && reloc_size != 0)
709 return FALSE;
710
711 amt = ((bfd_size_type) count + 1) * sizeof (arelent);
712 reloc_cache = bfd_malloc (amt);
713 if (!reloc_cache)
714 {
715 if (relocs != NULL)
716 free (relocs);
717 return FALSE;
718 }
719
720 if (bfd_bread ((void *) relocs, reloc_size, abfd) != reloc_size)
721 {
722 free (reloc_cache);
723 if (relocs != NULL)
724 free (relocs);
725 return FALSE;
726 }
727
728 if (bfd_header_big_endian (abfd))
729 {
730 /* Big-endian bit field allocation order. */
731 pcrel_mask = 0x80;
732 extern_mask = 0x10;
733 incode_mask = 0x08;
734 callj_mask = 0x02;
735 size_mask = 0x20;
736 length_shift = 5;
737 }
738 else
739 {
740 /* Little-endian bit field allocation order. */
741 pcrel_mask = 0x01;
742 extern_mask = 0x08;
743 incode_mask = 0x10;
744 callj_mask = 0x40;
745 size_mask = 0x02;
746 length_shift = 1;
747 }
748
749 for (rptr = relocs, cache_ptr = reloc_cache, counter = 0;
750 counter < count;
751 counter++, rptr++, cache_ptr++)
752 {
753 unsigned char *raw = (unsigned char *)rptr;
754 unsigned int symnum;
755
756 cache_ptr->address = H_GET_32 (abfd, raw + 0);
757 cache_ptr->howto = 0;
758
759 if (bfd_header_big_endian (abfd))
760 symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6];
761 else
762 symnum = (raw[6] << 16) | (raw[5] << 8) | raw[4];
763
764 if (raw[7] & extern_mask)
765 {
766 /* If this is set then the r_index is an index into the symbol table;
767 if the bit is not set then r_index contains a section map.
768 We either fill in the sym entry with a pointer to the symbol,
769 or point to the correct section. */
770 cache_ptr->sym_ptr_ptr = symbols + symnum;
771 cache_ptr->addend = 0;
772 }
773 else
774 {
775 /* In a.out symbols are relative to the beginning of the
776 file rather than sections ?
777 (look in translate_from_native_sym_flags)
778 The reloc entry addend has added to it the offset into the
779 file of the data, so subtract the base to make the reloc
780 section relative. */
781 int s;
782
783 /* Sign-extend symnum from 24 bits to whatever host uses. */
784 s = symnum;
785 if (s & (1 << 23))
786 s |= (~0) << 24;
787
788 cache_ptr->sym_ptr_ptr = (asymbol **)NULL;
789 switch (s)
790 {
791 case N_TEXT:
792 case N_TEXT | N_EXT:
793 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr;
794 cache_ptr->addend = - obj_textsec (abfd)->vma;
795 break;
796 case N_DATA:
797 case N_DATA | N_EXT:
798 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr;
799 cache_ptr->addend = - obj_datasec (abfd)->vma;
800 break;
801 case N_BSS:
802 case N_BSS | N_EXT:
803 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr;
804 cache_ptr->addend = - obj_bsssec (abfd)->vma;
805 break;
806 case N_ABS:
807 case N_ABS | N_EXT:
808 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr;
809 cache_ptr->addend = 0;
810 break;
811 case -2: /* .align */
812 if (raw[7] & pcrel_mask)
813 {
814 cache_ptr->howto = &howto_align_table[(raw[7] >> length_shift) & 3];
815 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
816 }
817 else
818 {
819 /* .org? */
820 abort ();
821 }
822 cache_ptr->addend = 0;
823 break;
824 default:
825 BFD_ASSERT (FALSE);
826 break;
827 }
828 }
829
830 /* The i960 only has a few relocation types:
831 abs 32-bit and pcrel 24bit. except for callj's! */
832 if (cache_ptr->howto != 0)
833 ;
834 else if (raw[7] & callj_mask)
835 {
836 cache_ptr->howto = &howto_reloc_callj;
837 }
838 else if ( raw[7] & pcrel_mask)
839 {
840 if (raw[7] & size_mask)
841 cache_ptr->howto = &howto_reloc_pcrel13;
842 else
843 cache_ptr->howto = &howto_reloc_pcrel24;
844 }
845 else
846 {
847 if (raw[7] & incode_mask)
848 cache_ptr->howto = &howto_reloc_abs32code;
849 else
850 cache_ptr->howto = &howto_reloc_abs32;
851 }
852
853 if (cache_ptr->address < prev_addr)
854 {
855 /* Ouch! this reloc is out of order, insert into the right place. */
856 arelent tmp;
857 arelent *cursor = cache_ptr-1;
858 bfd_vma stop = cache_ptr->address;
859
860 tmp = *cache_ptr;
861 while (cursor->address > stop && cursor >= reloc_cache)
862 {
863 cursor[1] = cursor[0];
864 cursor--;
865 }
866
867 cursor[1] = tmp;
868 }
869 else
870 prev_addr = cache_ptr->address;
871 }
872
873 if (relocs != NULL)
874 free (relocs);
875 asect->relocation = reloc_cache;
876 asect->reloc_count = count;
877
878 return TRUE;
879 }
880
881 /* This is stupid. This function should be a boolean predicate. */
882
883 static long
b_out_canonicalize_reloc(bfd * abfd,sec_ptr section,arelent ** relptr,asymbol ** symbols)884 b_out_canonicalize_reloc (bfd *abfd,
885 sec_ptr section,
886 arelent **relptr,
887 asymbol **symbols)
888 {
889 arelent *tblptr;
890 unsigned int count;
891
892 if ((section->flags & SEC_CONSTRUCTOR) != 0)
893 {
894 arelent_chain *chain = section->constructor_chain;
895
896 for (count = 0; count < section->reloc_count; count++)
897 {
898 *relptr++ = &chain->relent;
899 chain = chain->next;
900 }
901 }
902 else
903 {
904 if (section->relocation == NULL
905 && ! b_out_slurp_reloc_table (abfd, section, symbols))
906 return -1;
907
908 tblptr = section->relocation;
909 for (count = 0; count++ < section->reloc_count;)
910 *relptr++ = tblptr++;
911 }
912
913 *relptr = NULL;
914
915 return section->reloc_count;
916 }
917
918 static long
b_out_get_reloc_upper_bound(bfd * abfd,sec_ptr asect)919 b_out_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
920 {
921 if (bfd_get_format (abfd) != bfd_object)
922 {
923 bfd_set_error (bfd_error_invalid_operation);
924 return -1;
925 }
926
927 if (asect->flags & SEC_CONSTRUCTOR)
928 return sizeof (arelent *) * (asect->reloc_count + 1);
929
930 if (asect == obj_datasec (abfd))
931 return (sizeof (arelent *) *
932 ((exec_hdr (abfd)->a_drsize / sizeof (struct relocation_info))
933 + 1));
934
935 if (asect == obj_textsec (abfd))
936 return (sizeof (arelent *) *
937 ((exec_hdr (abfd)->a_trsize / sizeof (struct relocation_info))
938 + 1));
939
940 if (asect == obj_bsssec (abfd))
941 return 0;
942
943 bfd_set_error (bfd_error_invalid_operation);
944 return -1;
945 }
946
947
948 static bfd_boolean
b_out_set_section_contents(bfd * abfd,asection * section,const void * location,file_ptr offset,bfd_size_type count)949 b_out_set_section_contents (bfd *abfd,
950 asection *section,
951 const void * location,
952 file_ptr offset,
953 bfd_size_type count)
954 {
955 if (! abfd->output_has_begun)
956 {
957 /* Set by bfd.c handler. */
958 if (! aout_32_make_sections (abfd))
959 return FALSE;
960
961 obj_textsec (abfd)->filepos = sizeof (struct external_exec);
962 obj_datasec (abfd)->filepos = obj_textsec (abfd)->filepos
963 + obj_textsec (abfd)->size;
964 }
965
966 /* Regardless, once we know what we're doing, we might as well get going. */
967 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
968 return FALSE;
969
970 if (count == 0)
971 return TRUE;
972
973 return bfd_bwrite ((void *) location, count, abfd) == count;
974 }
975
976 static bfd_boolean
b_out_set_arch_mach(bfd * abfd,enum bfd_architecture arch,unsigned long machine)977 b_out_set_arch_mach (bfd *abfd,
978 enum bfd_architecture arch,
979 unsigned long machine)
980 {
981 bfd_default_set_arch_mach (abfd, arch, machine);
982
983 if (arch == bfd_arch_unknown) /* Unknown machine arch is OK. */
984 return TRUE;
985
986 if (arch == bfd_arch_i960) /* i960 default is OK. */
987 switch (machine)
988 {
989 case bfd_mach_i960_core:
990 case bfd_mach_i960_kb_sb:
991 case bfd_mach_i960_mc:
992 case bfd_mach_i960_xa:
993 case bfd_mach_i960_ca:
994 case bfd_mach_i960_ka_sa:
995 case bfd_mach_i960_jx:
996 case bfd_mach_i960_hx:
997 case 0:
998 return TRUE;
999 default:
1000 return FALSE;
1001 }
1002
1003 return FALSE;
1004 }
1005
1006 static int
b_out_sizeof_headers(bfd * ignore_abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED)1007 b_out_sizeof_headers (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1008 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1009 {
1010 return sizeof (struct external_exec);
1011 }
1012
1013 static void
perform_slip(bfd * abfd,unsigned int slip,asection * input_section,bfd_vma value)1014 perform_slip (bfd *abfd,
1015 unsigned int slip,
1016 asection *input_section,
1017 bfd_vma value)
1018 {
1019 asymbol **s;
1020
1021 s = _bfd_generic_link_get_symbols (abfd);
1022 BFD_ASSERT (s != (asymbol **) NULL);
1023
1024 /* Find all symbols past this point, and make them know
1025 what's happened. */
1026 while (*s)
1027 {
1028 asymbol *p = *s;
1029
1030 if (p->section == input_section)
1031 {
1032 /* This was pointing into this section, so mangle it. */
1033 if (p->value > value)
1034 {
1035 p->value -=slip;
1036
1037 if (p->udata.p != NULL)
1038 {
1039 struct generic_link_hash_entry *h;
1040
1041 h = (struct generic_link_hash_entry *) p->udata.p;
1042 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
1043 h->root.u.def.value -= slip;
1044 BFD_ASSERT (h->root.u.def.value == p->value);
1045 }
1046 }
1047 }
1048 s++;
1049 }
1050 }
1051
1052 /* This routine works out if the thing we want to get to can be
1053 reached with a 24bit offset instead of a 32 bit one.
1054 If it can, then it changes the amode. */
1055
1056 static int
abs32code(bfd * abfd,asection * input_section,arelent * r,unsigned int shrink,struct bfd_link_info * link_info)1057 abs32code (bfd *abfd,
1058 asection *input_section,
1059 arelent *r,
1060 unsigned int shrink,
1061 struct bfd_link_info *link_info)
1062 {
1063 bfd_vma value = get_value (r, link_info, input_section);
1064 bfd_vma dot = output_addr (input_section) + r->address;
1065 bfd_vma gap;
1066
1067 /* See if the address we're looking at within 2^23 bytes of where
1068 we are, if so then we can use a small branch rather than the
1069 jump we were going to. */
1070 gap = value - (dot - shrink);
1071
1072 if (-1 << 23 < (long)gap && (long)gap < 1 << 23)
1073 {
1074 /* Change the reloc type from 32bitcode possible 24, to 24bit
1075 possible 32. */
1076 r->howto = &howto_reloc_abs32codeshrunk;
1077 /* The place to relc moves back by four bytes. */
1078 r->address -=4;
1079
1080 /* This will be four bytes smaller in the long run. */
1081 shrink += 4 ;
1082 perform_slip (abfd, 4, input_section, r->address-shrink + 4);
1083 }
1084
1085 return shrink;
1086 }
1087
1088 static int
aligncode(bfd * abfd,asection * input_section,arelent * r,unsigned int shrink)1089 aligncode (bfd *abfd,
1090 asection *input_section,
1091 arelent *r,
1092 unsigned int shrink)
1093 {
1094 bfd_vma dot = output_addr (input_section) + r->address;
1095 bfd_vma old_end;
1096 bfd_vma new_end;
1097 unsigned int shrink_delta;
1098 int size = r->howto->size;
1099
1100 /* Reduce the size of the alignment so that it's still aligned but
1101 smaller - the current size is already the same size as or bigger
1102 than the alignment required. */
1103
1104 /* Calculate the first byte following the padding before we optimize. */
1105 old_end = ((dot + size ) & ~size) + size+1;
1106 /* Work out where the new end will be - remember that we're smaller
1107 than we used to be. */
1108 new_end = ((dot - shrink + size) & ~size);
1109
1110 shrink_delta = (old_end - new_end) - shrink;
1111
1112 if (shrink_delta)
1113 {
1114 /* Change the reloc so that it knows how far to align to. */
1115 r->howto = howto_done_align_table + (r->howto - howto_align_table);
1116
1117 /* Encode the stuff into the addend - for future use we need to
1118 know how big the reloc used to be. */
1119 r->addend = old_end - dot + r->address;
1120
1121 /* This will be N bytes smaller in the long run, adjust all the symbols. */
1122 perform_slip (abfd, shrink_delta, input_section, r->address - shrink);
1123 shrink += shrink_delta;
1124 }
1125
1126 return shrink;
1127 }
1128
1129 static bfd_boolean
b_out_bfd_relax_section(bfd * abfd,asection * i,struct bfd_link_info * link_info,bfd_boolean * again)1130 b_out_bfd_relax_section (bfd *abfd,
1131 asection *i,
1132 struct bfd_link_info *link_info,
1133 bfd_boolean *again)
1134 {
1135 /* Get enough memory to hold the stuff. */
1136 bfd *input_bfd = i->owner;
1137 asection *input_section = i;
1138 unsigned int shrink = 0 ;
1139 arelent **reloc_vector = NULL;
1140 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
1141
1142 if (link_info->relocatable)
1143 (*link_info->callbacks->einfo)
1144 (_("%P%F: --relax and -r may not be used together\n"));
1145
1146 if (reloc_size < 0)
1147 return FALSE;
1148
1149 /* We only run this relaxation once. It might work to run it
1150 multiple times, but it hasn't been tested. */
1151 *again = FALSE;
1152
1153 if (reloc_size)
1154 {
1155 long reloc_count;
1156
1157 reloc_vector = bfd_malloc ((bfd_size_type) reloc_size);
1158 if (reloc_vector == NULL && reloc_size != 0)
1159 goto error_return;
1160
1161 /* Get the relocs and think about them. */
1162 reloc_count =
1163 bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector,
1164 _bfd_generic_link_get_symbols (input_bfd));
1165 if (reloc_count < 0)
1166 goto error_return;
1167 if (reloc_count > 0)
1168 {
1169 arelent **parent;
1170
1171 for (parent = reloc_vector; *parent; parent++)
1172 {
1173 arelent *r = *parent;
1174
1175 switch (r->howto->type)
1176 {
1177 case ALIGNER:
1178 /* An alignment reloc. */
1179 shrink = aligncode (abfd, input_section, r, shrink);
1180 break;
1181 case ABS32CODE:
1182 /* A 32bit reloc in an addressing mode. */
1183 shrink = abs32code (input_bfd, input_section, r, shrink,
1184 link_info);
1185 break;
1186 case ABS32CODE_SHRUNK:
1187 shrink += 4;
1188 break;
1189 }
1190 }
1191 }
1192 }
1193 input_section->size -= shrink;
1194
1195 if (reloc_vector != NULL)
1196 free (reloc_vector);
1197 return TRUE;
1198 error_return:
1199 if (reloc_vector != NULL)
1200 free (reloc_vector);
1201 return FALSE;
1202 }
1203
1204 static bfd_byte *
b_out_bfd_get_relocated_section_contents(bfd * output_bfd,struct bfd_link_info * link_info,struct bfd_link_order * link_order,bfd_byte * data,bfd_boolean relocatable,asymbol ** symbols)1205 b_out_bfd_get_relocated_section_contents (bfd *output_bfd,
1206 struct bfd_link_info *link_info,
1207 struct bfd_link_order *link_order,
1208 bfd_byte *data,
1209 bfd_boolean relocatable,
1210 asymbol **symbols)
1211 {
1212 /* Get enough memory to hold the stuff. */
1213 bfd *input_bfd = link_order->u.indirect.section->owner;
1214 asection *input_section = link_order->u.indirect.section;
1215 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
1216 arelent **reloc_vector = NULL;
1217 long reloc_count;
1218
1219 if (reloc_size < 0)
1220 goto error_return;
1221
1222 /* If producing relocatable output, don't bother to relax. */
1223 if (relocatable)
1224 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1225 link_order,
1226 data, relocatable,
1227 symbols);
1228
1229 reloc_vector = bfd_malloc ((bfd_size_type) reloc_size);
1230 if (reloc_vector == NULL && reloc_size != 0)
1231 goto error_return;
1232
1233 /* Read in the section. */
1234 BFD_ASSERT (bfd_get_section_contents (input_bfd,
1235 input_section,
1236 data,
1237 (bfd_vma) 0,
1238 input_section->size));
1239
1240 reloc_count = bfd_canonicalize_reloc (input_bfd,
1241 input_section,
1242 reloc_vector,
1243 symbols);
1244 if (reloc_count < 0)
1245 goto error_return;
1246 if (reloc_count > 0)
1247 {
1248 arelent **parent = reloc_vector;
1249 arelent *reloc ;
1250 unsigned int dst_address = 0;
1251 unsigned int src_address = 0;
1252 unsigned int run;
1253 unsigned int idx;
1254
1255 /* Find how long a run we can do. */
1256 while (dst_address < link_order->size)
1257 {
1258 reloc = *parent;
1259 if (reloc)
1260 {
1261 /* Note that the relaxing didn't tie up the addresses in the
1262 relocation, so we use the original address to work out the
1263 run of non-relocated data. */
1264 BFD_ASSERT (reloc->address >= src_address);
1265 run = reloc->address - src_address;
1266 parent++;
1267 }
1268 else
1269 run = link_order->size - dst_address;
1270
1271 /* Copy the bytes. */
1272 for (idx = 0; idx < run; idx++)
1273 data[dst_address++] = data[src_address++];
1274
1275 /* Now do the relocation. */
1276 if (reloc)
1277 {
1278 switch (reloc->howto->type)
1279 {
1280 case ABS32CODE:
1281 calljx_callback (input_bfd, link_info, reloc,
1282 src_address + data, dst_address + data,
1283 input_section);
1284 src_address += 4;
1285 dst_address += 4;
1286 break;
1287 case ABS32:
1288 bfd_put_32 (input_bfd,
1289 (bfd_get_32 (input_bfd, data + src_address)
1290 + get_value (reloc, link_info, input_section)),
1291 data + dst_address);
1292 src_address += 4;
1293 dst_address += 4;
1294 break;
1295 case CALLJ:
1296 callj_callback (input_bfd, link_info, reloc, data,
1297 src_address, dst_address, input_section,
1298 FALSE);
1299 src_address += 4;
1300 dst_address += 4;
1301 break;
1302 case ALIGNDONE:
1303 BFD_ASSERT (reloc->addend >= src_address);
1304 BFD_ASSERT ((bfd_vma) reloc->addend
1305 <= input_section->size);
1306 src_address = reloc->addend;
1307 dst_address = ((dst_address + reloc->howto->size)
1308 & ~reloc->howto->size);
1309 break;
1310 case ABS32CODE_SHRUNK:
1311 /* This used to be a callx, but we've found out that a
1312 callj will reach, so do the right thing. */
1313 callj_callback (input_bfd, link_info, reloc, data,
1314 src_address + 4, dst_address, input_section,
1315 TRUE);
1316 dst_address += 4;
1317 src_address += 8;
1318 break;
1319 case PCREL24:
1320 {
1321 long int word = bfd_get_32 (input_bfd,
1322 data + src_address);
1323 bfd_vma value;
1324
1325 value = get_value (reloc, link_info, input_section);
1326 word = ((word & ~BAL_MASK)
1327 | (((word & BAL_MASK)
1328 + value
1329 - output_addr (input_section)
1330 + reloc->addend)
1331 & BAL_MASK));
1332
1333 bfd_put_32 (input_bfd, (bfd_vma) word, data + dst_address);
1334 dst_address += 4;
1335 src_address += 4;
1336
1337 }
1338 break;
1339 case PCREL13:
1340 {
1341 long int word = bfd_get_32 (input_bfd,
1342 data + src_address);
1343 bfd_vma value;
1344
1345 value = get_value (reloc, link_info, input_section);
1346 word = ((word & ~PCREL13_MASK)
1347 | (((word & PCREL13_MASK)
1348 + value
1349 + reloc->addend
1350 - output_addr (input_section))
1351 & PCREL13_MASK));
1352
1353 bfd_put_32 (input_bfd, (bfd_vma) word, data + dst_address);
1354 dst_address += 4;
1355 src_address += 4;
1356 }
1357 break;
1358
1359 default:
1360 abort ();
1361 }
1362 }
1363 }
1364 }
1365 if (reloc_vector != NULL)
1366 free (reloc_vector);
1367 return data;
1368 error_return:
1369 if (reloc_vector != NULL)
1370 free (reloc_vector);
1371 return NULL;
1372 }
1373
1374
1375 /* Build the transfer vectors for Big and Little-Endian B.OUT files. */
1376
1377 #define aout_32_find_line _bfd_nosymbols_find_line
1378 #define aout_32_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1379 #define aout_32_close_and_cleanup aout_32_bfd_free_cached_info
1380 #define b_out_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1381 #define b_out_bfd_link_add_symbols _bfd_generic_link_add_symbols
1382 #define b_out_bfd_link_just_syms _bfd_generic_link_just_syms
1383 #define b_out_bfd_copy_link_hash_symbol_type \
1384 _bfd_generic_copy_link_hash_symbol_type
1385 #define b_out_bfd_final_link _bfd_generic_final_link
1386 #define b_out_bfd_link_split_section _bfd_generic_link_split_section
1387 #define b_out_bfd_gc_sections bfd_generic_gc_sections
1388 #define b_out_bfd_lookup_section_flags bfd_generic_lookup_section_flags
1389 #define b_out_bfd_merge_sections bfd_generic_merge_sections
1390 #define b_out_bfd_is_group_section bfd_generic_is_group_section
1391 #define b_out_bfd_discard_group bfd_generic_discard_group
1392 #define b_out_section_already_linked _bfd_generic_section_already_linked
1393 #define b_out_bfd_define_common_symbol bfd_generic_define_common_symbol
1394 #define aout_32_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
1395
1396 extern const bfd_target bout_le_vec;
1397
1398 const bfd_target bout_be_vec =
1399 {
1400 "b.out.big", /* Name. */
1401 bfd_target_aout_flavour,
1402 BFD_ENDIAN_LITTLE, /* Data byte order. */
1403 BFD_ENDIAN_BIG, /* Header byte order. */
1404 (HAS_RELOC | EXEC_P | /* Object flags. */
1405 HAS_LINENO | HAS_DEBUG |
1406 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
1407 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1408 '_', /* Symbol leading char. */
1409 ' ', /* AR_pad_char. */
1410 16, /* AR_max_namelen. */
1411 0, /* match priority. */
1412 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1413 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1414 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */
1415 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1416 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1417 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
1418 {_bfd_dummy_target, b_out_object_p, /* bfd_check_format. */
1419 bfd_generic_archive_p, _bfd_dummy_target},
1420 {bfd_false, b_out_mkobject, /* bfd_set_format. */
1421 _bfd_generic_mkarchive, bfd_false},
1422 {bfd_false, b_out_write_object_contents, /* bfd_write_contents. */
1423 _bfd_write_archive_contents, bfd_false},
1424
1425 BFD_JUMP_TABLE_GENERIC (aout_32),
1426 BFD_JUMP_TABLE_COPY (_bfd_generic),
1427 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1428 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
1429 BFD_JUMP_TABLE_SYMBOLS (aout_32),
1430 BFD_JUMP_TABLE_RELOCS (b_out),
1431 BFD_JUMP_TABLE_WRITE (b_out),
1432 BFD_JUMP_TABLE_LINK (b_out),
1433 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1434
1435 & bout_le_vec,
1436
1437 NULL
1438 };
1439
1440 const bfd_target bout_le_vec =
1441 {
1442 "b.out.little", /* Name. */
1443 bfd_target_aout_flavour,
1444 BFD_ENDIAN_LITTLE, /* Data byte order. */
1445 BFD_ENDIAN_LITTLE, /* Header byte order. */
1446 (HAS_RELOC | EXEC_P | /* Object flags. */
1447 HAS_LINENO | HAS_DEBUG |
1448 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
1449 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1450 '_', /* Symbol leading char. */
1451 ' ', /* AR_pad_char. */
1452 16, /* AR_max_namelen. */
1453 0, /* match priority. */
1454 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1455 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1456 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */
1457 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1458 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1459 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers. */
1460
1461 {_bfd_dummy_target, b_out_object_p, /* bfd_check_format. */
1462 bfd_generic_archive_p, _bfd_dummy_target},
1463 {bfd_false, b_out_mkobject, /* bfd_set_format. */
1464 _bfd_generic_mkarchive, bfd_false},
1465 {bfd_false, b_out_write_object_contents, /* bfd_write_contents. */
1466 _bfd_write_archive_contents, bfd_false},
1467
1468 BFD_JUMP_TABLE_GENERIC (aout_32),
1469 BFD_JUMP_TABLE_COPY (_bfd_generic),
1470 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1471 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
1472 BFD_JUMP_TABLE_SYMBOLS (aout_32),
1473 BFD_JUMP_TABLE_RELOCS (b_out),
1474 BFD_JUMP_TABLE_WRITE (b_out),
1475 BFD_JUMP_TABLE_LINK (b_out),
1476 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1477
1478 & bout_be_vec,
1479
1480 NULL
1481 };
1482