Add support for generating DWARF2 debug sections in the x86 PE port
[binutils.git] / bfd / bout.c
bloba39a9a36a9453871196d53b0b945040afddaabbc
1 /* BFD back-end for Intel 960 b.out binaries.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
12 (at your option) any later version.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libbfd.h"
26 #include "bfdlink.h"
27 #include "genlink.h"
28 #include "bout.h"
30 #include "aout/stab_gnu.h"
31 #include "libaout.h" /* BFD a.out internal data structures. */
33 static int aligncode
34 PARAMS ((bfd *abfd, asection *input_section, arelent *r,
35 unsigned int shrink));
36 static void perform_slip
37 PARAMS ((bfd *abfd, unsigned int slip, asection *input_section,
38 bfd_vma value));
39 static bfd_boolean b_out_squirt_out_relocs
40 PARAMS ((bfd *abfd, asection *section));
41 static const bfd_target *b_out_callback
42 PARAMS ((bfd *));
43 static bfd_reloc_status_type calljx_callback
44 PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR src, PTR dst,
45 asection *));
46 static bfd_reloc_status_type callj_callback
47 PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR data,
48 unsigned int srcidx, unsigned int dstidx, asection *, bfd_boolean));
49 static bfd_vma get_value
50 PARAMS ((arelent *, struct bfd_link_info *, asection *));
51 static int abs32code
52 PARAMS ((bfd *, asection *, arelent *, unsigned int,
53 struct bfd_link_info *));
54 static bfd_boolean b_out_bfd_relax_section
55 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
56 static bfd_byte *b_out_bfd_get_relocated_section_contents
57 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
58 bfd_boolean, asymbol **));
59 static int b_out_sizeof_headers
60 PARAMS ((bfd *, bfd_boolean));
61 static bfd_boolean b_out_set_arch_mach
62 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
63 static bfd_boolean b_out_set_section_contents
64 PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type));
65 static long b_out_get_reloc_upper_bound
66 PARAMS ((bfd *, sec_ptr));
67 static long b_out_canonicalize_reloc
68 PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
69 static bfd_boolean b_out_slurp_reloc_table
70 PARAMS ((bfd *, sec_ptr, asymbol **));
71 static reloc_howto_type *b_out_bfd_reloc_type_lookup
72 PARAMS ((bfd *, bfd_reloc_code_real_type));
73 static bfd_boolean b_out_write_object_contents
74 PARAMS ((bfd *));
75 static int b_out_symbol_cmp
76 PARAMS ((const void *, const void *));
77 static bfd_boolean b_out_mkobject
78 PARAMS ((bfd *));
79 static const bfd_target *b_out_object_p
80 PARAMS ((bfd *));
82 void bout_swap_exec_header_in
83 PARAMS ((bfd *, struct external_exec *, struct internal_exec *));
84 void bout_swap_exec_header_out
85 PARAMS ((bfd *, struct internal_exec *, struct external_exec *));
87 /* Swaps the information in an executable header taken from a raw byte
88 stream memory image, into the internal exec_header structure. */
90 void
91 bout_swap_exec_header_in (abfd, raw_bytes, execp)
92 bfd *abfd;
93 struct external_exec *raw_bytes;
94 struct internal_exec *execp;
96 struct external_exec *bytes = (struct external_exec *)raw_bytes;
98 /* Now fill in fields in the execp, from the bytes in the raw data. */
99 execp->a_info = H_GET_32 (abfd, bytes->e_info);
100 execp->a_text = GET_WORD (abfd, bytes->e_text);
101 execp->a_data = GET_WORD (abfd, bytes->e_data);
102 execp->a_bss = GET_WORD (abfd, bytes->e_bss);
103 execp->a_syms = GET_WORD (abfd, bytes->e_syms);
104 execp->a_entry = GET_WORD (abfd, bytes->e_entry);
105 execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
106 execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
107 execp->a_tload = GET_WORD (abfd, bytes->e_tload);
108 execp->a_dload = GET_WORD (abfd, bytes->e_dload);
109 execp->a_talign = bytes->e_talign[0];
110 execp->a_dalign = bytes->e_dalign[0];
111 execp->a_balign = bytes->e_balign[0];
112 execp->a_relaxable = bytes->e_relaxable[0];
115 /* Swaps the information in an internal exec header structure into the
116 supplied buffer ready for writing to disk. */
118 void
119 bout_swap_exec_header_out (abfd, execp, raw_bytes)
120 bfd *abfd;
121 struct internal_exec *execp;
122 struct external_exec *raw_bytes;
124 struct external_exec *bytes = (struct external_exec *)raw_bytes;
126 /* Now fill in fields in the raw data, from the fields in the exec struct. */
127 H_PUT_32 (abfd, execp->a_info , bytes->e_info);
128 PUT_WORD (abfd, execp->a_text , bytes->e_text);
129 PUT_WORD (abfd, execp->a_data , bytes->e_data);
130 PUT_WORD (abfd, execp->a_bss , bytes->e_bss);
131 PUT_WORD (abfd, execp->a_syms , bytes->e_syms);
132 PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
133 PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
134 PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
135 PUT_WORD (abfd, execp->a_tload , bytes->e_tload);
136 PUT_WORD (abfd, execp->a_dload , bytes->e_dload);
137 bytes->e_talign[0] = execp->a_talign;
138 bytes->e_dalign[0] = execp->a_dalign;
139 bytes->e_balign[0] = execp->a_balign;
140 bytes->e_relaxable[0] = execp->a_relaxable;
143 static const bfd_target *
144 b_out_object_p (abfd)
145 bfd *abfd;
147 struct internal_exec anexec;
148 struct external_exec exec_bytes;
149 bfd_size_type amt = EXEC_BYTES_SIZE;
151 if (bfd_bread ((PTR) &exec_bytes, amt, abfd) != amt)
153 if (bfd_get_error () != bfd_error_system_call)
154 bfd_set_error (bfd_error_wrong_format);
155 return 0;
158 anexec.a_info = H_GET_32 (abfd, exec_bytes.e_info);
160 if (N_BADMAG (anexec))
162 bfd_set_error (bfd_error_wrong_format);
163 return 0;
166 bout_swap_exec_header_in (abfd, &exec_bytes, &anexec);
167 return aout_32_some_aout_object_p (abfd, &anexec, b_out_callback);
170 /* Finish up the opening of a b.out file for reading. Fill in all the
171 fields that are not handled by common code. */
173 static const bfd_target *
174 b_out_callback (abfd)
175 bfd *abfd;
177 struct internal_exec *execp = exec_hdr (abfd);
178 unsigned long bss_start;
180 /* Architecture and machine type. */
181 bfd_set_arch_mach(abfd,
182 bfd_arch_i960, /* B.out only used on i960 */
183 bfd_mach_i960_core /* Default */
186 /* The positions of the string table and symbol table. */
187 obj_str_filepos (abfd) = N_STROFF (*execp);
188 obj_sym_filepos (abfd) = N_SYMOFF (*execp);
190 /* The alignments of the sections. */
191 obj_textsec (abfd)->alignment_power = execp->a_talign;
192 obj_datasec (abfd)->alignment_power = execp->a_dalign;
193 obj_bsssec (abfd)->alignment_power = execp->a_balign;
195 /* The starting addresses of the sections. */
196 obj_textsec (abfd)->vma = execp->a_tload;
197 obj_datasec (abfd)->vma = execp->a_dload;
199 obj_textsec (abfd)->lma = obj_textsec (abfd)->vma;
200 obj_datasec (abfd)->lma = obj_datasec (abfd)->vma;
202 /* And reload the sizes, since the aout module zaps them. */
203 obj_textsec (abfd)->_raw_size = execp->a_text;
205 bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section */
206 obj_bsssec (abfd)->vma = align_power (bss_start, execp->a_balign);
208 obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma;
210 /* The file positions of the sections. */
211 obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
212 obj_datasec (abfd)->filepos = N_DATOFF(*execp);
214 /* The file positions of the relocation info. */
215 obj_textsec (abfd)->rel_filepos = N_TROFF(*execp);
216 obj_datasec (abfd)->rel_filepos = N_DROFF(*execp);
218 adata(abfd).page_size = 1; /* Not applicable. */
219 adata(abfd).segment_size = 1; /* Not applicable. */
220 adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
222 if (execp->a_relaxable)
223 abfd->flags |= BFD_IS_RELAXABLE;
224 return abfd->xvec;
227 struct bout_data_struct
229 struct aoutdata a;
230 struct internal_exec e;
233 static bfd_boolean
234 b_out_mkobject (abfd)
235 bfd *abfd;
237 struct bout_data_struct *rawptr;
238 bfd_size_type amt = sizeof (struct bout_data_struct);
240 rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, amt);
241 if (rawptr == NULL)
242 return FALSE;
244 abfd->tdata.bout_data = rawptr;
245 exec_hdr (abfd) = &rawptr->e;
247 obj_textsec (abfd) = (asection *) NULL;
248 obj_datasec (abfd) = (asection *) NULL;
249 obj_bsssec (abfd) = (asection *) NULL;
251 return TRUE;
254 static int
255 b_out_symbol_cmp (a_ptr, b_ptr)
256 const void * a_ptr;
257 const void * b_ptr;
259 struct aout_symbol ** a = (struct aout_symbol **) a_ptr;
260 struct aout_symbol ** b = (struct aout_symbol **) b_ptr;
261 asection *sec;
262 bfd_vma av, bv;
264 /* Primary key is address. */
265 sec = bfd_get_section (&(*a)->symbol);
266 av = sec->output_section->vma + sec->output_offset + (*a)->symbol.value;
267 sec = bfd_get_section (&(*b)->symbol);
268 bv = sec->output_section->vma + sec->output_offset + (*b)->symbol.value;
270 if (av < bv)
271 return -1;
272 if (av > bv)
273 return 1;
275 /* Secondary key puts CALLNAME syms last and BALNAME syms first, so
276 that they have the best chance of being contiguous. */
277 if (IS_BALNAME ((*a)->other) || IS_CALLNAME ((*b)->other))
278 return -1;
279 if (IS_CALLNAME ((*a)->other) || IS_BALNAME ((*b)->other))
280 return 1;
282 return 0;
285 static bfd_boolean
286 b_out_write_object_contents (abfd)
287 bfd *abfd;
289 struct external_exec swapped_hdr;
290 bfd_size_type amt;
292 if (! aout_32_make_sections (abfd))
293 return FALSE;
295 exec_hdr (abfd)->a_info = BMAGIC;
297 exec_hdr (abfd)->a_text = obj_textsec (abfd)->_raw_size;
298 exec_hdr (abfd)->a_data = obj_datasec (abfd)->_raw_size;
299 exec_hdr (abfd)->a_bss = obj_bsssec (abfd)->_raw_size;
300 exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd) * sizeof (struct nlist);
301 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
302 exec_hdr (abfd)->a_trsize = ((obj_textsec (abfd)->reloc_count) *
303 sizeof (struct relocation_info));
304 exec_hdr (abfd)->a_drsize = ((obj_datasec (abfd)->reloc_count) *
305 sizeof (struct relocation_info));
307 exec_hdr (abfd)->a_talign = obj_textsec (abfd)->alignment_power;
308 exec_hdr (abfd)->a_dalign = obj_datasec (abfd)->alignment_power;
309 exec_hdr (abfd)->a_balign = obj_bsssec (abfd)->alignment_power;
311 exec_hdr (abfd)->a_tload = obj_textsec (abfd)->vma;
312 exec_hdr (abfd)->a_dload = obj_datasec (abfd)->vma;
314 bout_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
316 amt = EXEC_BYTES_SIZE;
317 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
318 || bfd_bwrite ((PTR) &swapped_hdr, amt, abfd) != amt)
319 return FALSE;
321 /* Now write out reloc info, followed by syms and strings */
322 if (bfd_get_symcount (abfd) != 0)
324 /* Make sure {CALL,BAL}NAME symbols remain adjacent on output
325 by sorting. This is complicated by the fact that stabs are
326 also ordered. Solve this by shifting all stabs to the end
327 in order, then sorting the rest. */
329 asymbol **outsyms, **p, **q;
331 outsyms = bfd_get_outsymbols (abfd);
332 p = outsyms + bfd_get_symcount (abfd);
334 for (q = p--; p >= outsyms; p--)
336 if ((*p)->flags & BSF_DEBUGGING)
338 asymbol *t = *--q;
339 *q = *p;
340 *p = t;
344 if (q > outsyms)
345 qsort (outsyms, (size_t) (q - outsyms), sizeof (asymbol*),
346 b_out_symbol_cmp);
348 /* Back to your regularly scheduled program. */
349 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*exec_hdr(abfd))), SEEK_SET)
350 != 0)
351 return FALSE;
353 if (! aout_32_write_syms (abfd))
354 return FALSE;
356 if (bfd_seek (abfd, (file_ptr) (N_TROFF(*exec_hdr(abfd))), SEEK_SET)
357 != 0)
358 return FALSE;
360 if (!b_out_squirt_out_relocs (abfd, obj_textsec (abfd)))
361 return FALSE;
362 if (bfd_seek (abfd, (file_ptr) (N_DROFF(*exec_hdr(abfd))), SEEK_SET)
363 != 0)
364 return FALSE;
366 if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd)))
367 return FALSE;
369 return TRUE;
372 /* Some reloc hackery. */
374 #define CALLS 0x66003800 /* Template for 'calls' instruction */
375 #define BAL 0x0b000000 /* Template for 'bal' instruction */
376 #define BAL_MASK 0x00ffffff
377 #define BALX 0x85f00000 /* Template for 'balx' instruction */
378 #define BALX_MASK 0x0007ffff
379 #define CALL 0x09000000
380 #define PCREL13_MASK 0x1fff
382 #define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma)
384 /* Magic to turn callx into calljx. */
386 static bfd_reloc_status_type
387 calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
388 bfd *abfd;
389 struct bfd_link_info *link_info;
390 arelent *reloc_entry;
391 PTR src;
392 PTR dst;
393 asection *input_section;
395 int word = bfd_get_32 (abfd, src);
396 asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
397 aout_symbol_type *symbol = aout_symbol (symbol_in);
398 bfd_vma value;
400 value = get_value (reloc_entry, link_info, input_section);
402 if (IS_CALLNAME (symbol->other))
404 aout_symbol_type *balsym = symbol+1;
405 int inst = bfd_get_32 (abfd, (bfd_byte *) src-4);
406 /* The next symbol should be an N_BALNAME. */
407 BFD_ASSERT (IS_BALNAME (balsym->other));
408 inst &= BALX_MASK;
409 inst |= BALX;
410 bfd_put_32 (abfd, (bfd_vma) inst, (bfd_byte *) dst-4);
411 symbol = balsym;
412 value = (symbol->symbol.value
413 + output_addr (symbol->symbol.section));
416 word += value + reloc_entry->addend;
418 bfd_put_32 (abfd, (bfd_vma) word, dst);
419 return bfd_reloc_ok;
422 /* Magic to turn call into callj. */
424 static bfd_reloc_status_type
425 callj_callback (abfd, link_info, reloc_entry, data, srcidx, dstidx,
426 input_section, shrinking)
427 bfd *abfd;
428 struct bfd_link_info *link_info;
429 arelent *reloc_entry;
430 PTR data;
431 unsigned int srcidx;
432 unsigned int dstidx;
433 asection *input_section;
434 bfd_boolean shrinking;
436 int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
437 asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
438 aout_symbol_type *symbol = aout_symbol (symbol_in);
439 bfd_vma value;
441 value = get_value (reloc_entry, link_info, input_section);
443 if (IS_OTHER(symbol->other))
445 /* Call to a system procedure - replace code with system
446 procedure number. */
447 word = CALLS | (symbol->other - 1);
449 else if (IS_CALLNAME(symbol->other))
451 aout_symbol_type *balsym = symbol+1;
453 /* The next symbol should be an N_BALNAME. */
454 BFD_ASSERT(IS_BALNAME(balsym->other));
456 /* We are calling a leaf, so replace the call instruction with a
457 bal. */
458 word = BAL | ((word
459 + output_addr (balsym->symbol.section)
460 + balsym->symbol.value + reloc_entry->addend
461 - dstidx
462 - output_addr (input_section))
463 & BAL_MASK);
465 else if ((symbol->symbol.flags & BSF_SECTION_SYM) != 0)
467 /* A callj against a symbol in the same section is a fully
468 resolved relative call. We don't need to do anything here.
469 If the symbol is not in the same section, I'm not sure what
470 to do; fortunately, this case will probably never arise. */
471 BFD_ASSERT (! shrinking);
472 BFD_ASSERT (symbol->symbol.section == input_section);
474 else
476 word = CALL | (((word & BAL_MASK)
477 + value
478 + reloc_entry->addend
479 - (shrinking ? dstidx : 0)
480 - output_addr (input_section))
481 & BAL_MASK);
483 bfd_put_32 (abfd, (bfd_vma) word, (bfd_byte *) data + dstidx);
484 return bfd_reloc_ok;
487 /* type rshift size bitsize pcrel bitpos absolute overflow check*/
489 #define ABS32CODE 0
490 #define ABS32CODE_SHRUNK 1
491 #define PCREL24 2
492 #define CALLJ 3
493 #define ABS32 4
494 #define PCREL13 5
495 #define ABS32_MAYBE_RELAXABLE 1
496 #define ABS32_WAS_RELAXABLE 2
498 #define ALIGNER 10
499 #define ALIGNDONE 11
500 static reloc_howto_type howto_reloc_callj =
501 HOWTO(CALLJ, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE);
502 static reloc_howto_type howto_reloc_abs32 =
503 HOWTO(ABS32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"abs32", TRUE, 0xffffffff,0xffffffff,FALSE);
504 static reloc_howto_type howto_reloc_pcrel24 =
505 HOWTO(PCREL24, 0, 2, 24, TRUE, 0, complain_overflow_signed,0,"pcrel24", TRUE, 0x00ffffff,0x00ffffff,FALSE);
507 static reloc_howto_type howto_reloc_pcrel13 =
508 HOWTO(PCREL13, 0, 2, 13, TRUE, 0, complain_overflow_signed,0,"pcrel13", TRUE, 0x00001fff,0x00001fff,FALSE);
510 static reloc_howto_type howto_reloc_abs32codeshrunk =
511 HOWTO(ABS32CODE_SHRUNK, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callx->callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE);
513 static reloc_howto_type howto_reloc_abs32code =
514 HOWTO(ABS32CODE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"callx", TRUE, 0xffffffff,0xffffffff,FALSE);
516 static reloc_howto_type howto_align_table[] = {
517 HOWTO (ALIGNER, 0, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "align16", FALSE, 0, 0, FALSE),
518 HOWTO (ALIGNER, 0, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "align32", FALSE, 0, 0, FALSE),
519 HOWTO (ALIGNER, 0, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "align64", FALSE, 0, 0, FALSE),
520 HOWTO (ALIGNER, 0, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "align128", FALSE, 0, 0, FALSE),
523 static reloc_howto_type howto_done_align_table[] = {
524 HOWTO (ALIGNDONE, 0x1, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "donealign16", FALSE, 0, 0, FALSE),
525 HOWTO (ALIGNDONE, 0x3, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "donealign32", FALSE, 0, 0, FALSE),
526 HOWTO (ALIGNDONE, 0x7, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "donealign64", FALSE, 0, 0, FALSE),
527 HOWTO (ALIGNDONE, 0xf, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "donealign128", FALSE, 0, 0, FALSE),
530 static reloc_howto_type *
531 b_out_bfd_reloc_type_lookup (abfd, code)
532 bfd *abfd ATTRIBUTE_UNUSED;
533 bfd_reloc_code_real_type code;
535 switch (code)
537 default:
538 return 0;
539 case BFD_RELOC_I960_CALLJ:
540 return &howto_reloc_callj;
541 case BFD_RELOC_32:
542 case BFD_RELOC_CTOR:
543 return &howto_reloc_abs32;
544 case BFD_RELOC_24_PCREL:
545 return &howto_reloc_pcrel24;
549 /* Allocate enough room for all the reloc entries, plus pointers to them all. */
551 static bfd_boolean
552 b_out_slurp_reloc_table (abfd, asect, symbols)
553 bfd *abfd;
554 sec_ptr asect;
555 asymbol **symbols;
557 register struct relocation_info *rptr;
558 unsigned int counter;
559 arelent *cache_ptr;
560 int extern_mask, pcrel_mask, callj_mask, length_shift;
561 int incode_mask;
562 int size_mask;
563 bfd_vma prev_addr = 0;
564 unsigned int count;
565 bfd_size_type reloc_size, amt;
566 struct relocation_info *relocs;
567 arelent *reloc_cache;
569 if (asect->relocation)
570 return TRUE;
572 if (!aout_32_slurp_symbol_table (abfd))
573 return FALSE;
575 if (asect == obj_datasec (abfd))
577 reloc_size = exec_hdr(abfd)->a_drsize;
578 goto doit;
581 if (asect == obj_textsec (abfd))
583 reloc_size = exec_hdr(abfd)->a_trsize;
584 goto doit;
587 if (asect == obj_bsssec (abfd))
589 reloc_size = 0;
590 goto doit;
593 bfd_set_error (bfd_error_invalid_operation);
594 return FALSE;
596 doit:
597 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
598 return FALSE;
599 count = reloc_size / sizeof (struct relocation_info);
601 relocs = (struct relocation_info *) bfd_malloc (reloc_size);
602 if (!relocs && reloc_size != 0)
603 return FALSE;
605 amt = ((bfd_size_type) count + 1) * sizeof (arelent);
606 reloc_cache = (arelent *) bfd_malloc (amt);
607 if (!reloc_cache)
609 if (relocs != NULL)
610 free (relocs);
611 return FALSE;
614 if (bfd_bread ((PTR) relocs, reloc_size, abfd) != reloc_size)
616 free (reloc_cache);
617 if (relocs != NULL)
618 free (relocs);
619 return FALSE;
622 if (bfd_header_big_endian (abfd))
624 /* Big-endian bit field allocation order. */
625 pcrel_mask = 0x80;
626 extern_mask = 0x10;
627 incode_mask = 0x08;
628 callj_mask = 0x02;
629 size_mask = 0x20;
630 length_shift = 5;
632 else
634 /* Little-endian bit field allocation order. */
635 pcrel_mask = 0x01;
636 extern_mask = 0x08;
637 incode_mask = 0x10;
638 callj_mask = 0x40;
639 size_mask = 0x02;
640 length_shift = 1;
643 for (rptr = relocs, cache_ptr = reloc_cache, counter = 0;
644 counter < count;
645 counter++, rptr++, cache_ptr++)
647 unsigned char *raw = (unsigned char *)rptr;
648 unsigned int symnum;
650 cache_ptr->address = H_GET_32 (abfd, raw + 0);
651 cache_ptr->howto = 0;
653 if (bfd_header_big_endian (abfd))
654 symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6];
655 else
656 symnum = (raw[6] << 16) | (raw[5] << 8) | raw[4];
658 if (raw[7] & extern_mask)
660 /* If this is set then the r_index is an index into the symbol table;
661 if the bit is not set then r_index contains a section map.
662 We either fill in the sym entry with a pointer to the symbol,
663 or point to the correct section. */
664 cache_ptr->sym_ptr_ptr = symbols + symnum;
665 cache_ptr->addend = 0;
667 else
669 /* In a.out symbols are relative to the beginning of the
670 file rather than sections ?
671 (look in translate_from_native_sym_flags)
672 The reloc entry addend has added to it the offset into the
673 file of the data, so subtract the base to make the reloc
674 section relative. */
675 int s;
677 /* Sign-extend symnum from 24 bits to whatever host uses. */
678 s = symnum;
679 if (s & (1 << 23))
680 s |= (~0) << 24;
682 cache_ptr->sym_ptr_ptr = (asymbol **)NULL;
683 switch (s)
685 case N_TEXT:
686 case N_TEXT | N_EXT:
687 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr;
688 cache_ptr->addend = - obj_textsec (abfd)->vma;
689 break;
690 case N_DATA:
691 case N_DATA | N_EXT:
692 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr;
693 cache_ptr->addend = - obj_datasec (abfd)->vma;
694 break;
695 case N_BSS:
696 case N_BSS | N_EXT:
697 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr;
698 cache_ptr->addend = - obj_bsssec (abfd)->vma;
699 break;
700 case N_ABS:
701 case N_ABS | N_EXT:
702 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr;
703 cache_ptr->addend = 0;
704 break;
705 case -2: /* .align */
706 if (raw[7] & pcrel_mask)
708 cache_ptr->howto = &howto_align_table[(raw[7] >> length_shift) & 3];
709 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
711 else
713 /* .org? */
714 abort ();
716 cache_ptr->addend = 0;
717 break;
718 default:
719 BFD_ASSERT(0);
720 break;
724 /* The i960 only has a few relocation types:
725 abs 32-bit and pcrel 24bit. except for callj's! */
726 if (cache_ptr->howto != 0)
728 else if (raw[7] & callj_mask)
730 cache_ptr->howto = &howto_reloc_callj;
732 else if ( raw[7] & pcrel_mask)
734 if (raw[7] & size_mask)
735 cache_ptr->howto = &howto_reloc_pcrel13;
736 else
737 cache_ptr->howto = &howto_reloc_pcrel24;
739 else
741 if (raw[7] & incode_mask)
742 cache_ptr->howto = &howto_reloc_abs32code;
743 else
744 cache_ptr->howto = &howto_reloc_abs32;
747 if (cache_ptr->address < prev_addr)
749 /* Ouch! this reloc is out of order, insert into the right place. */
750 arelent tmp;
751 arelent *cursor = cache_ptr-1;
752 bfd_vma stop = cache_ptr->address;
754 tmp = *cache_ptr;
755 while (cursor->address > stop && cursor >= reloc_cache)
757 cursor[1] = cursor[0];
758 cursor--;
761 cursor[1] = tmp;
763 else
765 prev_addr = cache_ptr->address;
769 if (relocs != NULL)
770 free (relocs);
771 asect->relocation = reloc_cache;
772 asect->reloc_count = count;
774 return TRUE;
777 static bfd_boolean
778 b_out_squirt_out_relocs (abfd, section)
779 bfd *abfd;
780 asection *section;
782 arelent **generic;
783 int r_extern = 0;
784 int r_idx;
785 int incode_mask;
786 int len_1;
787 unsigned int count = section->reloc_count;
788 struct relocation_info *native, *natptr;
789 bfd_size_type natsize;
790 int extern_mask, pcrel_mask, len_2, callj_mask;
792 if (count == 0)
793 return TRUE;
795 generic = section->orelocation;
796 natsize = (bfd_size_type) count * sizeof (struct relocation_info);
797 native = ((struct relocation_info *) bfd_malloc (natsize));
798 if (!native && natsize != 0)
799 return FALSE;
801 if (bfd_header_big_endian (abfd))
803 /* Big-endian bit field allocation order. */
804 pcrel_mask = 0x80;
805 extern_mask = 0x10;
806 len_2 = 0x40;
807 len_1 = 0x20;
808 callj_mask = 0x02;
809 incode_mask = 0x08;
811 else
813 /* Little-endian bit field allocation order. */
814 pcrel_mask = 0x01;
815 extern_mask = 0x08;
816 len_2 = 0x04;
817 len_1 = 0x02;
818 callj_mask = 0x40;
819 incode_mask = 0x10;
822 for (natptr = native; count > 0; --count, ++natptr, ++generic)
824 arelent *g = *generic;
825 unsigned char *raw = (unsigned char *)natptr;
826 asymbol *sym = *(g->sym_ptr_ptr);
827 asection *output_section = sym->section->output_section;
829 H_PUT_32 (abfd, g->address, raw);
830 /* Find a type in the output format which matches the input howto -
831 at the moment we assume input format == output format FIXME!! */
832 r_idx = 0;
833 /* FIXME: Need callj stuff here, and to check the howto entries to
834 be sure they are real for this architecture. */
835 if (g->howto== &howto_reloc_callj)
836 raw[7] = callj_mask + pcrel_mask + len_2;
837 else if (g->howto == &howto_reloc_pcrel24)
838 raw[7] = pcrel_mask + len_2;
839 else if (g->howto == &howto_reloc_pcrel13)
840 raw[7] = pcrel_mask + len_1;
841 else if (g->howto == &howto_reloc_abs32code)
842 raw[7] = len_2 + incode_mask;
843 else if (g->howto >= howto_align_table
844 && g->howto <= (howto_align_table
845 + sizeof (howto_align_table) / sizeof (howto_align_table[0])
846 - 1))
848 /* symnum == -2; extern_mask not set, pcrel_mask set. */
849 r_idx = -2;
850 r_extern = 0;
851 raw[7] = (pcrel_mask
852 | ((g->howto - howto_align_table) << 1));
854 else
855 raw[7] = len_2;
857 if (r_idx != 0)
858 /* Already mucked with r_extern, r_idx. */;
859 else if (bfd_is_com_section (output_section)
860 || bfd_is_abs_section (output_section)
861 || bfd_is_und_section (output_section))
863 if (bfd_abs_section_ptr->symbol == sym)
865 /* Whoops, looked like an abs symbol, but is really an offset
866 from the abs section. */
867 r_idx = 0;
868 r_extern = 0;
870 else
872 /* Fill in symbol. */
873 r_extern = 1;
874 r_idx = (*g->sym_ptr_ptr)->udata.i;
877 else
879 /* Just an ordinary section. */
880 r_extern = 0;
881 r_idx = output_section->target_index;
884 if (bfd_header_big_endian (abfd))
886 raw[4] = (unsigned char) (r_idx >> 16);
887 raw[5] = (unsigned char) (r_idx >> 8);
888 raw[6] = (unsigned char) (r_idx );
890 else
892 raw[6] = (unsigned char) (r_idx >> 16);
893 raw[5] = (unsigned char) (r_idx>> 8);
894 raw[4] = (unsigned char) (r_idx );
897 if (r_extern)
898 raw[7] |= extern_mask;
901 if (bfd_bwrite ((PTR) native, natsize, abfd) != natsize)
903 free ((PTR)native);
904 return FALSE;
907 free ((PTR)native);
909 return TRUE;
912 /* This is stupid. This function should be a boolean predicate. */
914 static long
915 b_out_canonicalize_reloc (abfd, section, relptr, symbols)
916 bfd *abfd;
917 sec_ptr section;
918 arelent **relptr;
919 asymbol **symbols;
921 arelent *tblptr;
922 unsigned int count;
924 if ((section->flags & SEC_CONSTRUCTOR) != 0)
926 arelent_chain *chain = section->constructor_chain;
928 for (count = 0; count < section->reloc_count; count++)
930 *relptr++ = &chain->relent;
931 chain = chain->next;
934 else
936 if (section->relocation == NULL
937 && ! b_out_slurp_reloc_table (abfd, section, symbols))
938 return -1;
940 tblptr = section->relocation;
941 for (count = 0; count++ < section->reloc_count;)
942 *relptr++ = tblptr++;
945 *relptr = NULL;
947 return section->reloc_count;
950 static long
951 b_out_get_reloc_upper_bound (abfd, asect)
952 bfd *abfd;
953 sec_ptr asect;
955 if (bfd_get_format (abfd) != bfd_object)
957 bfd_set_error (bfd_error_invalid_operation);
958 return -1;
961 if (asect->flags & SEC_CONSTRUCTOR)
962 return sizeof (arelent *) * (asect->reloc_count + 1);
964 if (asect == obj_datasec (abfd))
965 return (sizeof (arelent *) *
966 ((exec_hdr(abfd)->a_drsize / sizeof (struct relocation_info))
967 +1));
969 if (asect == obj_textsec (abfd))
970 return (sizeof (arelent *) *
971 ((exec_hdr(abfd)->a_trsize / sizeof (struct relocation_info))
972 +1));
974 if (asect == obj_bsssec (abfd))
975 return 0;
977 bfd_set_error (bfd_error_invalid_operation);
978 return -1;
982 static bfd_boolean
983 b_out_set_section_contents (abfd, section, location, offset, count)
984 bfd *abfd;
985 asection *section;
986 const PTR location;
987 file_ptr offset;
988 bfd_size_type count;
990 if (! abfd->output_has_begun)
992 /* Set by bfd.c handler. */
993 if (! aout_32_make_sections (abfd))
994 return FALSE;
996 obj_textsec (abfd)->filepos = sizeof (struct internal_exec);
997 obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
998 + obj_textsec (abfd)->_raw_size;
1001 /* Regardless, once we know what we're doing, we might as well get going. */
1002 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
1003 return FALSE;
1005 if (count == 0)
1006 return TRUE;
1008 return bfd_bwrite ((PTR) location, count, abfd) == count;
1011 static bfd_boolean
1012 b_out_set_arch_mach (abfd, arch, machine)
1013 bfd *abfd;
1014 enum bfd_architecture arch;
1015 unsigned long machine;
1017 bfd_default_set_arch_mach(abfd, arch, machine);
1019 if (arch == bfd_arch_unknown) /* Unknown machine arch is OK. */
1020 return TRUE;
1022 if (arch == bfd_arch_i960) /* i960 default is OK. */
1023 switch (machine)
1025 case bfd_mach_i960_core:
1026 case bfd_mach_i960_kb_sb:
1027 case bfd_mach_i960_mc:
1028 case bfd_mach_i960_xa:
1029 case bfd_mach_i960_ca:
1030 case bfd_mach_i960_ka_sa:
1031 case bfd_mach_i960_jx:
1032 case bfd_mach_i960_hx:
1033 case 0:
1034 return TRUE;
1035 default:
1036 return FALSE;
1039 return FALSE;
1042 static int
1043 b_out_sizeof_headers (ignore_abfd, ignore)
1044 bfd *ignore_abfd ATTRIBUTE_UNUSED;
1045 bfd_boolean ignore ATTRIBUTE_UNUSED;
1047 return sizeof (struct internal_exec);
1051 static bfd_vma
1052 get_value (reloc, link_info, input_section)
1053 arelent *reloc;
1054 struct bfd_link_info *link_info;
1055 asection *input_section;
1057 bfd_vma value;
1058 asymbol *symbol = *(reloc->sym_ptr_ptr);
1060 /* A symbol holds a pointer to a section, and an offset from the
1061 base of the section. To relocate, we find where the section will
1062 live in the output and add that in. */
1063 if (bfd_is_und_section (symbol->section))
1065 struct bfd_link_hash_entry *h;
1067 /* The symbol is undefined in this BFD. Look it up in the
1068 global linker hash table. FIXME: This should be changed when
1069 we convert b.out to use a specific final_link function and
1070 change the interface to bfd_relax_section to not require the
1071 generic symbols. */
1072 h = bfd_wrapped_link_hash_lookup (input_section->owner, link_info,
1073 bfd_asymbol_name (symbol),
1074 FALSE, FALSE, TRUE);
1075 if (h != (struct bfd_link_hash_entry *) NULL
1076 && (h->type == bfd_link_hash_defined
1077 || h->type == bfd_link_hash_defweak))
1078 value = h->u.def.value + output_addr (h->u.def.section);
1079 else if (h != (struct bfd_link_hash_entry *) NULL
1080 && h->type == bfd_link_hash_common)
1081 value = h->u.c.size;
1082 else
1084 if (! ((*link_info->callbacks->undefined_symbol)
1085 (link_info, bfd_asymbol_name (symbol),
1086 input_section->owner, input_section, reloc->address,
1087 TRUE)))
1088 abort ();
1089 value = 0;
1092 else
1094 value = symbol->value + output_addr (symbol->section);
1097 /* Add the value contained in the relocation. */
1098 value += reloc->addend;
1100 return value;
1103 static void
1104 perform_slip (abfd, slip, input_section, value)
1105 bfd *abfd;
1106 unsigned int slip;
1107 asection *input_section;
1108 bfd_vma value;
1110 asymbol **s;
1112 s = _bfd_generic_link_get_symbols (abfd);
1113 BFD_ASSERT (s != (asymbol **) NULL);
1115 /* Find all symbols past this point, and make them know
1116 what's happened. */
1117 while (*s)
1119 asymbol *p = *s;
1121 if (p->section == input_section)
1123 /* This was pointing into this section, so mangle it. */
1124 if (p->value > value)
1126 p->value -=slip;
1128 if (p->udata.p != NULL)
1130 struct generic_link_hash_entry *h;
1132 h = (struct generic_link_hash_entry *) p->udata.p;
1133 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
1134 h->root.u.def.value -= slip;
1135 BFD_ASSERT (h->root.u.def.value == p->value);
1139 s++;
1143 /* This routine works out if the thing we want to get to can be
1144 reached with a 24bit offset instead of a 32 bit one.
1145 If it can, then it changes the amode. */
1147 static int
1148 abs32code (abfd, input_section, r, shrink, link_info)
1149 bfd *abfd;
1150 asection *input_section;
1151 arelent *r;
1152 unsigned int shrink;
1153 struct bfd_link_info *link_info;
1155 bfd_vma value = get_value (r, link_info, input_section);
1156 bfd_vma dot = output_addr (input_section) + r->address;
1157 bfd_vma gap;
1159 /* See if the address we're looking at within 2^23 bytes of where
1160 we are, if so then we can use a small branch rather than the
1161 jump we were going to. */
1162 gap = value - (dot - shrink);
1164 if (-1 << 23 < (long)gap && (long)gap < 1 << 23)
1166 /* Change the reloc type from 32bitcode possible 24, to 24bit
1167 possible 32. */
1168 r->howto = &howto_reloc_abs32codeshrunk;
1169 /* The place to relc moves back by four bytes. */
1170 r->address -=4;
1172 /* This will be four bytes smaller in the long run. */
1173 shrink += 4 ;
1174 perform_slip (abfd, 4, input_section, r->address-shrink + 4);
1177 return shrink;
1180 static int
1181 aligncode (abfd, input_section, r, shrink)
1182 bfd *abfd;
1183 asection *input_section;
1184 arelent *r;
1185 unsigned int shrink;
1187 bfd_vma dot = output_addr (input_section) + r->address;
1188 bfd_vma gap;
1189 bfd_vma old_end;
1190 bfd_vma new_end;
1191 unsigned int shrink_delta;
1192 int size = r->howto->size;
1194 /* Reduce the size of the alignment so that it's still aligned but
1195 smaller - the current size is already the same size as or bigger
1196 than the alignment required. */
1198 /* Calculate the first byte following the padding before we optimize. */
1199 old_end = ((dot + size ) & ~size) + size+1;
1200 /* Work out where the new end will be - remember that we're smaller
1201 than we used to be. */
1202 new_end = ((dot - shrink + size) & ~size);
1204 /* This is the new end. */
1205 gap = old_end - ((dot + size) & ~size);
1207 shrink_delta = (old_end - new_end) - shrink;
1209 if (shrink_delta)
1211 /* Change the reloc so that it knows how far to align to. */
1212 r->howto = howto_done_align_table + (r->howto - howto_align_table);
1214 /* Encode the stuff into the addend - for future use we need to
1215 know how big the reloc used to be. */
1216 r->addend = old_end - dot + r->address;
1218 /* This will be N bytes smaller in the long run, adjust all the symbols. */
1219 perform_slip (abfd, shrink_delta, input_section, r->address - shrink);
1220 shrink += shrink_delta;
1223 return shrink;
1226 static bfd_boolean
1227 b_out_bfd_relax_section (abfd, i, link_info, again)
1228 bfd *abfd;
1229 asection *i;
1230 struct bfd_link_info *link_info;
1231 bfd_boolean *again;
1233 /* Get enough memory to hold the stuff. */
1234 bfd *input_bfd = i->owner;
1235 asection *input_section = i;
1236 unsigned int shrink = 0 ;
1237 arelent **reloc_vector = NULL;
1238 long reloc_size = bfd_get_reloc_upper_bound (input_bfd,
1239 input_section);
1241 if (reloc_size < 0)
1242 return FALSE;
1244 /* We only run this relaxation once. It might work to run it
1245 multiple times, but it hasn't been tested. */
1246 *again = FALSE;
1248 if (reloc_size)
1250 long reloc_count;
1252 reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1253 if (reloc_vector == NULL && reloc_size != 0)
1254 goto error_return;
1256 /* Get the relocs and think about them. */
1257 reloc_count =
1258 bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector,
1259 _bfd_generic_link_get_symbols (input_bfd));
1260 if (reloc_count < 0)
1261 goto error_return;
1262 if (reloc_count > 0)
1264 arelent **parent;
1266 for (parent = reloc_vector; *parent; parent++)
1268 arelent *r = *parent;
1270 switch (r->howto->type)
1272 case ALIGNER:
1273 /* An alignment reloc. */
1274 shrink = aligncode (abfd, input_section, r, shrink);
1275 break;
1276 case ABS32CODE:
1277 /* A 32bit reloc in an addressing mode. */
1278 shrink = abs32code (input_bfd, input_section, r, shrink,
1279 link_info);
1280 break;
1281 case ABS32CODE_SHRUNK:
1282 shrink += 4;
1283 break;
1288 input_section->_cooked_size = input_section->_raw_size - shrink;
1290 if (reloc_vector != NULL)
1291 free (reloc_vector);
1292 return TRUE;
1293 error_return:
1294 if (reloc_vector != NULL)
1295 free (reloc_vector);
1296 return FALSE;
1299 static bfd_byte *
1300 b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
1301 data, relocatable, symbols)
1302 bfd *output_bfd;
1303 struct bfd_link_info *link_info;
1304 struct bfd_link_order *link_order;
1305 bfd_byte *data;
1306 bfd_boolean relocatable;
1307 asymbol **symbols;
1309 /* Get enough memory to hold the stuff. */
1310 bfd *input_bfd = link_order->u.indirect.section->owner;
1311 asection *input_section = link_order->u.indirect.section;
1312 long reloc_size = bfd_get_reloc_upper_bound (input_bfd,
1313 input_section);
1314 arelent **reloc_vector = NULL;
1315 long reloc_count;
1317 if (reloc_size < 0)
1318 goto error_return;
1320 /* If producing relocatable output, don't bother to relax. */
1321 if (relocatable)
1322 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1323 link_order,
1324 data, relocatable,
1325 symbols);
1327 reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1328 if (reloc_vector == NULL && reloc_size != 0)
1329 goto error_return;
1331 input_section->reloc_done = 1;
1333 /* Read in the section. */
1334 BFD_ASSERT (bfd_get_section_contents (input_bfd,
1335 input_section,
1336 data,
1337 (bfd_vma) 0,
1338 input_section->_raw_size));
1340 reloc_count = bfd_canonicalize_reloc (input_bfd,
1341 input_section,
1342 reloc_vector,
1343 symbols);
1344 if (reloc_count < 0)
1345 goto error_return;
1346 if (reloc_count > 0)
1348 arelent **parent = reloc_vector;
1349 arelent *reloc ;
1350 unsigned int dst_address = 0;
1351 unsigned int src_address = 0;
1352 unsigned int run;
1353 unsigned int idx;
1355 /* Find how long a run we can do. */
1356 while (dst_address < link_order->size)
1358 reloc = *parent;
1359 if (reloc)
1361 /* Note that the relaxing didn't tie up the addresses in the
1362 relocation, so we use the original address to work out the
1363 run of non-relocated data. */
1364 BFD_ASSERT (reloc->address >= src_address);
1365 run = reloc->address - src_address;
1366 parent++;
1368 else
1370 run = link_order->size - dst_address;
1373 /* Copy the bytes. */
1374 for (idx = 0; idx < run; idx++)
1375 data[dst_address++] = data[src_address++];
1377 /* Now do the relocation. */
1378 if (reloc)
1380 switch (reloc->howto->type)
1382 case ABS32CODE:
1383 calljx_callback (input_bfd, link_info, reloc,
1384 src_address + data, dst_address + data,
1385 input_section);
1386 src_address += 4;
1387 dst_address += 4;
1388 break;
1389 case ABS32:
1390 bfd_put_32 (input_bfd,
1391 (bfd_get_32 (input_bfd, data + src_address)
1392 + get_value (reloc, link_info, input_section)),
1393 data + dst_address);
1394 src_address += 4;
1395 dst_address += 4;
1396 break;
1397 case CALLJ:
1398 callj_callback (input_bfd, link_info, reloc, data,
1399 src_address, dst_address, input_section,
1400 FALSE);
1401 src_address += 4;
1402 dst_address += 4;
1403 break;
1404 case ALIGNDONE:
1405 BFD_ASSERT (reloc->addend >= src_address);
1406 BFD_ASSERT ((bfd_vma) reloc->addend
1407 <= input_section->_raw_size);
1408 src_address = reloc->addend;
1409 dst_address = ((dst_address + reloc->howto->size)
1410 & ~reloc->howto->size);
1411 break;
1412 case ABS32CODE_SHRUNK:
1413 /* This used to be a callx, but we've found out that a
1414 callj will reach, so do the right thing. */
1415 callj_callback (input_bfd, link_info, reloc, data,
1416 src_address + 4, dst_address, input_section,
1417 TRUE);
1418 dst_address += 4;
1419 src_address += 8;
1420 break;
1421 case PCREL24:
1423 long int word = bfd_get_32 (input_bfd,
1424 data + src_address);
1425 bfd_vma value;
1427 value = get_value (reloc, link_info, input_section);
1428 word = ((word & ~BAL_MASK)
1429 | (((word & BAL_MASK)
1430 + value
1431 - output_addr (input_section)
1432 + reloc->addend)
1433 & BAL_MASK));
1435 bfd_put_32 (input_bfd, (bfd_vma) word, data + dst_address);
1436 dst_address += 4;
1437 src_address += 4;
1440 break;
1441 case PCREL13:
1443 long int word = bfd_get_32 (input_bfd,
1444 data + src_address);
1445 bfd_vma value;
1447 value = get_value (reloc, link_info, input_section);
1448 word = ((word & ~PCREL13_MASK)
1449 | (((word & PCREL13_MASK)
1450 + value
1451 + reloc->addend
1452 - output_addr (input_section))
1453 & PCREL13_MASK));
1455 bfd_put_32 (input_bfd, (bfd_vma) word, data + dst_address);
1456 dst_address += 4;
1457 src_address += 4;
1459 break;
1461 default:
1462 abort ();
1467 if (reloc_vector != NULL)
1468 free (reloc_vector);
1469 return data;
1470 error_return:
1471 if (reloc_vector != NULL)
1472 free (reloc_vector);
1473 return NULL;
1477 /* Build the transfer vectors for Big and Little-Endian B.OUT files. */
1479 #define aout_32_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1480 #define aout_32_close_and_cleanup aout_32_bfd_free_cached_info
1482 #define b_out_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1483 #define b_out_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
1484 #define b_out_bfd_link_add_symbols _bfd_generic_link_add_symbols
1485 #define b_out_bfd_link_just_syms _bfd_generic_link_just_syms
1486 #define b_out_bfd_final_link _bfd_generic_final_link
1487 #define b_out_bfd_link_split_section _bfd_generic_link_split_section
1488 #define b_out_bfd_gc_sections bfd_generic_gc_sections
1489 #define b_out_bfd_merge_sections bfd_generic_merge_sections
1490 #define b_out_bfd_discard_group bfd_generic_discard_group
1492 #define aout_32_get_section_contents_in_window \
1493 _bfd_generic_get_section_contents_in_window
1495 extern const bfd_target b_out_vec_little_host;
1497 const bfd_target b_out_vec_big_host =
1499 "b.out.big", /* name */
1500 bfd_target_aout_flavour,
1501 BFD_ENDIAN_LITTLE, /* data byte order is little */
1502 BFD_ENDIAN_BIG, /* hdr byte order is big */
1503 (HAS_RELOC | EXEC_P | /* object flags */
1504 HAS_LINENO | HAS_DEBUG |
1505 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
1506 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1507 '_', /* symbol leading char */
1508 ' ', /* ar_pad_char */
1509 16, /* ar_max_namelen */
1511 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1512 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1513 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1514 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1515 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1516 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1517 {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
1518 bfd_generic_archive_p, _bfd_dummy_target},
1519 {bfd_false, b_out_mkobject, /* bfd_set_format */
1520 _bfd_generic_mkarchive, bfd_false},
1521 {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
1522 _bfd_write_archive_contents, bfd_false},
1524 BFD_JUMP_TABLE_GENERIC (aout_32),
1525 BFD_JUMP_TABLE_COPY (_bfd_generic),
1526 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1527 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
1528 BFD_JUMP_TABLE_SYMBOLS (aout_32),
1529 BFD_JUMP_TABLE_RELOCS (b_out),
1530 BFD_JUMP_TABLE_WRITE (b_out),
1531 BFD_JUMP_TABLE_LINK (b_out),
1532 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1534 & b_out_vec_little_host,
1536 (PTR) 0,
1539 const bfd_target b_out_vec_little_host =
1541 "b.out.little", /* name */
1542 bfd_target_aout_flavour,
1543 BFD_ENDIAN_LITTLE, /* data byte order is little */
1544 BFD_ENDIAN_LITTLE, /* header byte order is little */
1545 (HAS_RELOC | EXEC_P | /* object flags */
1546 HAS_LINENO | HAS_DEBUG |
1547 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
1548 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1549 '_', /* symbol leading char */
1550 ' ', /* ar_pad_char */
1551 16, /* ar_max_namelen */
1552 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1553 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1554 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1555 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1556 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1557 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1559 {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
1560 bfd_generic_archive_p, _bfd_dummy_target},
1561 {bfd_false, b_out_mkobject, /* bfd_set_format */
1562 _bfd_generic_mkarchive, bfd_false},
1563 {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
1564 _bfd_write_archive_contents, bfd_false},
1566 BFD_JUMP_TABLE_GENERIC (aout_32),
1567 BFD_JUMP_TABLE_COPY (_bfd_generic),
1568 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1569 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
1570 BFD_JUMP_TABLE_SYMBOLS (aout_32),
1571 BFD_JUMP_TABLE_RELOCS (b_out),
1572 BFD_JUMP_TABLE_WRITE (b_out),
1573 BFD_JUMP_TABLE_LINK (b_out),
1574 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1576 & b_out_vec_big_host,
1578 (PTR) 0