1 /* BFD back-end for Intel 960 b.out binaries.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 #include "aout/stab_gnu.h"
30 #include "libaout.h" /* BFD a.out internal data structures */
32 static int aligncode PARAMS ((bfd *abfd, asection *input_section,
33 arelent *r, unsigned int shrink));
34 static void perform_slip PARAMS ((bfd *abfd, unsigned int slip,
35 asection *input_section, bfd_vma value));
36 static boolean b_out_squirt_out_relocs PARAMS ((bfd *abfd, asection *section));
37 static const bfd_target *b_out_callback PARAMS ((bfd *));
38 static bfd_reloc_status_type calljx_callback
39 PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR src, PTR dst,
41 static bfd_reloc_status_type callj_callback
42 PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR data,
43 unsigned int srcidx, unsigned int dstidx, asection *, boolean));
44 static bfd_vma get_value PARAMS ((arelent *, struct bfd_link_info *,
46 static int abs32code PARAMS ((bfd *, asection *, arelent *,
47 unsigned int, struct bfd_link_info *));
48 static boolean b_out_bfd_relax_section PARAMS ((bfd *, asection *,
49 struct bfd_link_info *,
51 static bfd_byte *b_out_bfd_get_relocated_section_contents
52 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
53 bfd_byte *, boolean, asymbol **));
55 /* Swaps the information in an executable header taken from a raw byte
56 stream memory image, into the internal exec_header structure. */
59 bout_swap_exec_header_in (abfd, raw_bytes, execp)
61 struct external_exec *raw_bytes;
62 struct internal_exec *execp;
64 struct external_exec *bytes = (struct external_exec *)raw_bytes;
66 /* Now fill in fields in the execp, from the bytes in the raw data. */
67 execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
68 execp->a_text = GET_WORD (abfd, bytes->e_text);
69 execp->a_data = GET_WORD (abfd, bytes->e_data);
70 execp->a_bss = GET_WORD (abfd, bytes->e_bss);
71 execp->a_syms = GET_WORD (abfd, bytes->e_syms);
72 execp->a_entry = GET_WORD (abfd, bytes->e_entry);
73 execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
74 execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
75 execp->a_tload = GET_WORD (abfd, bytes->e_tload);
76 execp->a_dload = GET_WORD (abfd, bytes->e_dload);
77 execp->a_talign = bytes->e_talign[0];
78 execp->a_dalign = bytes->e_dalign[0];
79 execp->a_balign = bytes->e_balign[0];
80 execp->a_relaxable = bytes->e_relaxable[0];
83 /* Swaps the information in an internal exec header structure into the
84 supplied buffer ready for writing to disk. */
86 PROTO(void, bout_swap_exec_header_out,
88 struct internal_exec *execp,
89 struct external_exec *raw_bytes));
91 bout_swap_exec_header_out (abfd, execp, raw_bytes)
93 struct internal_exec *execp;
94 struct external_exec *raw_bytes;
96 struct external_exec *bytes = (struct external_exec *)raw_bytes;
98 /* Now fill in fields in the raw data, from the fields in the exec struct. */
99 bfd_h_put_32 (abfd, execp->a_info , bytes->e_info);
100 PUT_WORD (abfd, execp->a_text , bytes->e_text);
101 PUT_WORD (abfd, execp->a_data , bytes->e_data);
102 PUT_WORD (abfd, execp->a_bss , bytes->e_bss);
103 PUT_WORD (abfd, execp->a_syms , bytes->e_syms);
104 PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
105 PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
106 PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
107 PUT_WORD (abfd, execp->a_tload , bytes->e_tload);
108 PUT_WORD (abfd, execp->a_dload , bytes->e_dload);
109 bytes->e_talign[0] = execp->a_talign;
110 bytes->e_dalign[0] = execp->a_dalign;
111 bytes->e_balign[0] = execp->a_balign;
112 bytes->e_relaxable[0] = execp->a_relaxable;
115 static const bfd_target *
116 b_out_object_p (abfd)
119 struct internal_exec anexec;
120 struct external_exec exec_bytes;
122 if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
123 != EXEC_BYTES_SIZE) {
124 if (bfd_get_error () != bfd_error_system_call)
125 bfd_set_error (bfd_error_wrong_format);
129 anexec.a_info = bfd_h_get_32 (abfd, exec_bytes.e_info);
131 if (N_BADMAG (anexec)) {
132 bfd_set_error (bfd_error_wrong_format);
136 bout_swap_exec_header_in (abfd, &exec_bytes, &anexec);
137 return aout_32_some_aout_object_p (abfd, &anexec, b_out_callback);
140 /* Finish up the opening of a b.out file for reading. Fill in all the
141 fields that are not handled by common code. */
143 static const bfd_target *
144 b_out_callback (abfd)
147 struct internal_exec *execp = exec_hdr (abfd);
148 unsigned long bss_start;
150 /* Architecture and machine type */
151 bfd_set_arch_mach(abfd,
152 bfd_arch_i960, /* B.out only used on i960 */
153 bfd_mach_i960_core /* Default */
156 /* The positions of the string table and symbol table. */
157 obj_str_filepos (abfd) = N_STROFF (*execp);
158 obj_sym_filepos (abfd) = N_SYMOFF (*execp);
160 /* The alignments of the sections */
161 obj_textsec (abfd)->alignment_power = execp->a_talign;
162 obj_datasec (abfd)->alignment_power = execp->a_dalign;
163 obj_bsssec (abfd)->alignment_power = execp->a_balign;
165 /* The starting addresses of the sections. */
166 obj_textsec (abfd)->vma = execp->a_tload;
167 obj_datasec (abfd)->vma = execp->a_dload;
169 obj_textsec (abfd)->lma = obj_textsec (abfd)->vma;
170 obj_datasec (abfd)->lma = obj_datasec (abfd)->vma;
172 /* And reload the sizes, since the aout module zaps them */
173 obj_textsec (abfd)->_raw_size = execp->a_text;
175 bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section */
176 obj_bsssec (abfd)->vma = align_power (bss_start, execp->a_balign);
178 obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma;
180 /* The file positions of the sections */
181 obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
182 obj_datasec (abfd)->filepos = N_DATOFF(*execp);
184 /* The file positions of the relocation info */
185 obj_textsec (abfd)->rel_filepos = N_TROFF(*execp);
186 obj_datasec (abfd)->rel_filepos = N_DROFF(*execp);
188 adata(abfd).page_size = 1; /* Not applicable. */
189 adata(abfd).segment_size = 1; /* Not applicable. */
190 adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
192 if (execp->a_relaxable)
193 abfd->flags |= BFD_IS_RELAXABLE;
197 struct bout_data_struct {
199 struct internal_exec e;
203 b_out_mkobject (abfd)
206 struct bout_data_struct *rawptr;
208 rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, sizeof (struct bout_data_struct));
212 abfd->tdata.bout_data = rawptr;
213 exec_hdr (abfd) = &rawptr->e;
215 obj_textsec (abfd) = (asection *)NULL;
216 obj_datasec (abfd) = (asection *)NULL;
217 obj_bsssec (abfd) = (asection *)NULL;
223 b_out_symbol_cmp (a, b)
224 struct aout_symbol **a, **b;
229 /* Primary key is address */
230 sec = bfd_get_section (&(*a)->symbol);
231 av = sec->output_section->vma + sec->output_offset + (*a)->symbol.value;
232 sec = bfd_get_section (&(*b)->symbol);
233 bv = sec->output_section->vma + sec->output_offset + (*b)->symbol.value;
240 /* Secondary key puts CALLNAME syms last and BALNAME syms first, so
241 that they have the best chance of being contiguous. */
242 if (IS_BALNAME ((*a)->other) || IS_CALLNAME ((*b)->other))
244 if (IS_CALLNAME ((*a)->other) || IS_BALNAME ((*b)->other))
251 b_out_write_object_contents (abfd)
254 struct external_exec swapped_hdr;
256 if (! aout_32_make_sections (abfd))
259 exec_hdr (abfd)->a_info = BMAGIC;
261 exec_hdr (abfd)->a_text = obj_textsec (abfd)->_raw_size;
262 exec_hdr (abfd)->a_data = obj_datasec (abfd)->_raw_size;
263 exec_hdr (abfd)->a_bss = obj_bsssec (abfd)->_raw_size;
264 exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd) * sizeof (struct nlist);
265 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
266 exec_hdr (abfd)->a_trsize = ((obj_textsec (abfd)->reloc_count) *
267 sizeof (struct relocation_info));
268 exec_hdr (abfd)->a_drsize = ((obj_datasec (abfd)->reloc_count) *
269 sizeof (struct relocation_info));
271 exec_hdr (abfd)->a_talign = obj_textsec (abfd)->alignment_power;
272 exec_hdr (abfd)->a_dalign = obj_datasec (abfd)->alignment_power;
273 exec_hdr (abfd)->a_balign = obj_bsssec (abfd)->alignment_power;
275 exec_hdr (abfd)->a_tload = obj_textsec (abfd)->vma;
276 exec_hdr (abfd)->a_dload = obj_datasec (abfd)->vma;
278 bout_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
280 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
281 || (bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd)
285 /* Now write out reloc info, followed by syms and strings */
286 if (bfd_get_symcount (abfd) != 0)
288 /* Make sure {CALL,BAL}NAME symbols remain adjacent on output
289 by sorting. This is complicated by the fact that stabs are
290 also ordered. Solve this by shifting all stabs to the end
291 in order, then sorting the rest. */
293 asymbol **outsyms, **p, **q;
295 outsyms = bfd_get_outsymbols (abfd);
296 p = outsyms + bfd_get_symcount (abfd);
298 for (q = p--; p >= outsyms; p--)
300 if ((*p)->flags & BSF_DEBUGGING)
309 qsort (outsyms, q - outsyms, sizeof(asymbol*), b_out_symbol_cmp);
311 /* Back to your regularly scheduled program. */
313 if (bfd_seek (abfd, (file_ptr)(N_SYMOFF(*exec_hdr(abfd))), SEEK_SET)
317 if (! aout_32_write_syms (abfd))
320 if (bfd_seek (abfd, (file_ptr)(N_TROFF(*exec_hdr(abfd))), SEEK_SET) != 0)
323 if (!b_out_squirt_out_relocs (abfd, obj_textsec (abfd))) return false;
324 if (bfd_seek (abfd, (file_ptr)(N_DROFF(*exec_hdr(abfd))), SEEK_SET)
328 if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd))) return false;
333 /** Some reloc hackery */
335 #define CALLS 0x66003800 /* Template for 'calls' instruction */
336 #define BAL 0x0b000000 /* Template for 'bal' instruction */
337 #define BAL_MASK 0x00ffffff
338 #define BALX 0x85f00000 /* Template for 'balx' instruction */
339 #define BALX_MASK 0x0007ffff
340 #define CALL 0x09000000
341 #define PCREL13_MASK 0x1fff
343 #define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma)
345 /* Magic to turn callx into calljx */
346 static bfd_reloc_status_type
347 calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
349 struct bfd_link_info *link_info;
350 arelent *reloc_entry;
353 asection *input_section;
355 int word = bfd_get_32 (abfd, src);
356 asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
357 aout_symbol_type *symbol = aout_symbol (symbol_in);
360 value = get_value (reloc_entry, link_info, input_section);
362 if (IS_CALLNAME (symbol->other))
364 aout_symbol_type *balsym = symbol+1;
365 int inst = bfd_get_32 (abfd, (bfd_byte *) src-4);
366 /* The next symbol should be an N_BALNAME */
367 BFD_ASSERT (IS_BALNAME (balsym->other));
370 bfd_put_32 (abfd, inst, (bfd_byte *) dst-4);
372 value = (symbol->symbol.value
373 + output_addr (symbol->symbol.section));
376 word += value + reloc_entry->addend;
378 bfd_put_32(abfd, word, dst);
382 /* Magic to turn call into callj */
383 static bfd_reloc_status_type
384 callj_callback (abfd, link_info, reloc_entry, data, srcidx, dstidx,
385 input_section, shrinking)
387 struct bfd_link_info *link_info;
388 arelent *reloc_entry;
392 asection *input_section;
395 int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
396 asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
397 aout_symbol_type *symbol = aout_symbol (symbol_in);
400 value = get_value (reloc_entry, link_info, input_section);
402 if (IS_OTHER(symbol->other))
404 /* Call to a system procedure - replace code with system
406 word = CALLS | (symbol->other - 1);
408 else if (IS_CALLNAME(symbol->other))
410 aout_symbol_type *balsym = symbol+1;
412 /* The next symbol should be an N_BALNAME. */
413 BFD_ASSERT(IS_BALNAME(balsym->other));
415 /* We are calling a leaf, so replace the call instruction with a
418 + output_addr (balsym->symbol.section)
419 + balsym->symbol.value + reloc_entry->addend
421 - output_addr (input_section))
424 else if ((symbol->symbol.flags & BSF_SECTION_SYM) != 0)
426 /* A callj against a symbol in the same section is a fully
427 resolved relative call. We don't need to do anything here.
428 If the symbol is not in the same section, I'm not sure what
429 to do; fortunately, this case will probably never arise. */
430 BFD_ASSERT (! shrinking);
431 BFD_ASSERT (symbol->symbol.section == input_section);
435 word = CALL | (((word & BAL_MASK)
437 + reloc_entry->addend
438 - (shrinking ? dstidx : 0)
439 - output_addr (input_section))
442 bfd_put_32(abfd, word, (bfd_byte *) data + dstidx);
446 /* type rshift size bitsize pcrel bitpos absolute overflow check*/
449 #define ABS32CODE_SHRUNK 1
454 #define ABS32_MAYBE_RELAXABLE 1
455 #define ABS32_WAS_RELAXABLE 2
459 static reloc_howto_type howto_reloc_callj =
460 HOWTO(CALLJ, 0, 2, 24, true, 0, complain_overflow_signed, 0,"callj", true, 0x00ffffff, 0x00ffffff,false);
461 static reloc_howto_type howto_reloc_abs32 =
462 HOWTO(ABS32, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"abs32", true, 0xffffffff,0xffffffff,false);
463 static reloc_howto_type howto_reloc_pcrel24 =
464 HOWTO(PCREL24, 0, 2, 24, true, 0, complain_overflow_signed,0,"pcrel24", true, 0x00ffffff,0x00ffffff,false);
466 static reloc_howto_type howto_reloc_pcrel13 =
467 HOWTO(PCREL13, 0, 2, 13, true, 0, complain_overflow_signed,0,"pcrel13", true, 0x00001fff,0x00001fff,false);
469 static reloc_howto_type howto_reloc_abs32codeshrunk =
470 HOWTO(ABS32CODE_SHRUNK, 0, 2, 24, true, 0, complain_overflow_signed, 0,"callx->callj", true, 0x00ffffff, 0x00ffffff,false);
472 static reloc_howto_type howto_reloc_abs32code =
473 HOWTO(ABS32CODE, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"callx", true, 0xffffffff,0xffffffff,false);
475 static reloc_howto_type howto_align_table[] = {
476 HOWTO (ALIGNER, 0, 0x1, 0, false, 0, complain_overflow_dont, 0, "align16", false, 0, 0, false),
477 HOWTO (ALIGNER, 0, 0x3, 0, false, 0, complain_overflow_dont, 0, "align32", false, 0, 0, false),
478 HOWTO (ALIGNER, 0, 0x7, 0, false, 0, complain_overflow_dont, 0, "align64", false, 0, 0, false),
479 HOWTO (ALIGNER, 0, 0xf, 0, false, 0, complain_overflow_dont, 0, "align128", false, 0, 0, false),
482 static reloc_howto_type howto_done_align_table[] = {
483 HOWTO (ALIGNDONE, 0x1, 0x1, 0, false, 0, complain_overflow_dont, 0, "donealign16", false, 0, 0, false),
484 HOWTO (ALIGNDONE, 0x3, 0x3, 0, false, 0, complain_overflow_dont, 0, "donealign32", false, 0, 0, false),
485 HOWTO (ALIGNDONE, 0x7, 0x7, 0, false, 0, complain_overflow_dont, 0, "donealign64", false, 0, 0, false),
486 HOWTO (ALIGNDONE, 0xf, 0xf, 0, false, 0, complain_overflow_dont, 0, "donealign128", false, 0, 0, false),
489 static reloc_howto_type *
490 b_out_bfd_reloc_type_lookup (abfd, code)
491 bfd *abfd ATTRIBUTE_UNUSED;
492 bfd_reloc_code_real_type code;
498 case BFD_RELOC_I960_CALLJ:
499 return &howto_reloc_callj;
502 return &howto_reloc_abs32;
503 case BFD_RELOC_24_PCREL:
504 return &howto_reloc_pcrel24;
508 /* Allocate enough room for all the reloc entries, plus pointers to them all */
511 b_out_slurp_reloc_table (abfd, asect, symbols)
516 register struct relocation_info *rptr;
517 unsigned int counter ;
519 int extern_mask, pcrel_mask, callj_mask, length_shift;
522 bfd_vma prev_addr = 0;
525 struct relocation_info *relocs;
526 arelent *reloc_cache;
528 if (asect->relocation)
530 if (!aout_32_slurp_symbol_table (abfd))
533 if (asect == obj_datasec (abfd)) {
534 reloc_size = exec_hdr(abfd)->a_drsize;
538 if (asect == obj_textsec (abfd)) {
539 reloc_size = exec_hdr(abfd)->a_trsize;
543 if (asect == obj_bsssec (abfd)) {
548 bfd_set_error (bfd_error_invalid_operation);
552 if (bfd_seek (abfd, (file_ptr)(asect->rel_filepos), SEEK_SET) != 0)
554 count = reloc_size / sizeof (struct relocation_info);
556 relocs = (struct relocation_info *) bfd_malloc (reloc_size);
557 if (!relocs && reloc_size != 0)
559 reloc_cache = (arelent *) bfd_malloc ((count+1) * sizeof (arelent));
562 free ((char*)relocs);
566 if (bfd_read ((PTR) relocs, 1, reloc_size, abfd) != reloc_size) {
573 if (bfd_header_big_endian (abfd)) {
574 /* big-endian bit field allocation order */
582 /* little-endian bit field allocation order */
591 for (rptr = relocs, cache_ptr = reloc_cache, counter = 0;
593 counter++, rptr++, cache_ptr++)
595 unsigned char *raw = (unsigned char *)rptr;
597 cache_ptr->address = bfd_h_get_32 (abfd, raw + 0);
598 cache_ptr->howto = 0;
599 if (bfd_header_big_endian (abfd))
601 symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6];
605 symnum = (raw[6] << 16) | (raw[5] << 8) | raw[4];
608 if (raw[7] & extern_mask)
610 /* if this is set then the r_index is a index into the symbol table;
611 * if the bit is not set then r_index contains a section map.
612 * we either fill in the sym entry with a pointer to the symbol,
613 * or point to the correct section
615 cache_ptr->sym_ptr_ptr = symbols + symnum;
616 cache_ptr->addend = 0;
619 /* in a.out symbols are relative to the beginning of the
620 * file rather than sections ?
621 * (look in translate_from_native_sym_flags)
622 * the reloc entry addend has added to it the offset into the
623 * file of the data, so subtract the base to make the reloc
624 * section relative */
627 /* sign-extend symnum from 24 bits to whatever host uses */
632 cache_ptr->sym_ptr_ptr = (asymbol **)NULL;
637 cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr;
638 cache_ptr->addend = - obj_textsec(abfd)->vma;
642 cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr;
643 cache_ptr->addend = - obj_datasec(abfd)->vma;
647 cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr;
648 cache_ptr->addend = - obj_bsssec(abfd)->vma;
652 cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr;
653 cache_ptr->addend = 0;
655 case -2: /* .align */
656 if (raw[7] & pcrel_mask)
658 cache_ptr->howto = &howto_align_table[(raw[7] >> length_shift) & 3];
659 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
666 cache_ptr->addend = 0;
675 /* the i960 only has a few relocation types:
676 abs 32-bit and pcrel 24bit. except for callj's! */
677 if (cache_ptr->howto != 0)
679 else if (raw[7] & callj_mask)
681 cache_ptr->howto = &howto_reloc_callj;
683 else if ( raw[7] & pcrel_mask)
685 if (raw[7] & size_mask)
686 cache_ptr->howto = &howto_reloc_pcrel13;
688 cache_ptr->howto = &howto_reloc_pcrel24;
692 if (raw[7] & incode_mask)
694 cache_ptr->howto = &howto_reloc_abs32code;
698 cache_ptr->howto = &howto_reloc_abs32;
701 if (cache_ptr->address < prev_addr)
703 /* Ouch! this reloc is out of order, insert into the right place
706 arelent *cursor = cache_ptr-1;
707 bfd_vma stop = cache_ptr->address;
709 while (cursor->address > stop && cursor >= reloc_cache)
711 cursor[1] = cursor[0];
718 prev_addr = cache_ptr->address;
724 asect->relocation = reloc_cache;
725 asect->reloc_count = count;
731 b_out_squirt_out_relocs (abfd, section)
740 unsigned int count = section->reloc_count;
741 struct relocation_info *native, *natptr;
742 size_t natsize = count * sizeof (struct relocation_info);
743 int extern_mask, pcrel_mask, len_2, callj_mask;
744 if (count == 0) return true;
745 generic = section->orelocation;
746 native = ((struct relocation_info *) bfd_malloc (natsize));
747 if (!native && natsize != 0)
750 if (bfd_header_big_endian (abfd))
752 /* Big-endian bit field allocation order */
762 /* Little-endian bit field allocation order */
771 for (natptr = native; count > 0; --count, ++natptr, ++generic)
773 arelent *g = *generic;
774 unsigned char *raw = (unsigned char *)natptr;
775 asymbol *sym = *(g->sym_ptr_ptr);
777 asection *output_section = sym->section->output_section;
779 bfd_h_put_32(abfd, g->address, raw);
780 /* Find a type in the output format which matches the input howto -
781 * at the moment we assume input format == output format FIXME!!
784 /* FIXME: Need callj stuff here, and to check the howto entries to
785 be sure they are real for this architecture. */
786 if (g->howto== &howto_reloc_callj)
788 raw[7] = callj_mask + pcrel_mask + len_2;
790 else if (g->howto == &howto_reloc_pcrel24)
792 raw[7] = pcrel_mask + len_2;
794 else if (g->howto == &howto_reloc_pcrel13)
796 raw[7] = pcrel_mask + len_1;
798 else if (g->howto == &howto_reloc_abs32code)
800 raw[7] = len_2 + incode_mask;
802 else if (g->howto >= howto_align_table
803 && g->howto <= (howto_align_table
804 + sizeof (howto_align_table) / sizeof (howto_align_table[0])
807 /* symnum == -2; extern_mask not set, pcrel_mask set */
811 | ((g->howto - howto_align_table) << 1));
818 /* already mucked with r_extern, r_idx */;
819 else if (bfd_is_com_section (output_section)
820 || bfd_is_abs_section (output_section)
821 || bfd_is_und_section (output_section))
824 if (bfd_abs_section_ptr->symbol == sym)
826 /* Whoops, looked like an abs symbol, but is really an offset
827 from the abs section */
836 r_idx = (*g->sym_ptr_ptr)->udata.i;
841 /* Just an ordinary section */
843 r_idx = output_section->target_index;
846 if (bfd_header_big_endian (abfd)) {
847 raw[4] = (unsigned char) (r_idx >> 16);
848 raw[5] = (unsigned char) (r_idx >> 8);
849 raw[6] = (unsigned char) (r_idx );
851 raw[6] = (unsigned char) (r_idx >> 16);
852 raw[5] = (unsigned char) (r_idx>> 8);
853 raw[4] = (unsigned char) (r_idx );
856 raw[7] |= extern_mask;
859 if (bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
868 /* This is stupid. This function should be a boolean predicate */
870 b_out_canonicalize_reloc (abfd, section, relptr, symbols)
879 if ((section->flags & SEC_CONSTRUCTOR) != 0)
881 arelent_chain *chain = section->constructor_chain;
882 for (count = 0; count < section->reloc_count; count++)
884 *relptr++ = &chain->relent;
890 if (section->relocation == NULL
891 && ! b_out_slurp_reloc_table (abfd, section, symbols))
894 tblptr = section->relocation;
895 for (count = 0; count++ < section->reloc_count;)
896 *relptr++ = tblptr++;
901 return section->reloc_count;
905 b_out_get_reloc_upper_bound (abfd, asect)
909 if (bfd_get_format (abfd) != bfd_object) {
910 bfd_set_error (bfd_error_invalid_operation);
914 if (asect->flags & SEC_CONSTRUCTOR)
915 return sizeof (arelent *) * (asect->reloc_count + 1);
917 if (asect == obj_datasec (abfd))
918 return (sizeof (arelent *) *
919 ((exec_hdr(abfd)->a_drsize / sizeof (struct relocation_info))
922 if (asect == obj_textsec (abfd))
923 return (sizeof (arelent *) *
924 ((exec_hdr(abfd)->a_trsize / sizeof (struct relocation_info))
927 if (asect == obj_bsssec (abfd))
930 bfd_set_error (bfd_error_invalid_operation);
935 b_out_set_section_contents (abfd, section, location, offset, count)
943 if (abfd->output_has_begun == false) { /* set by bfd.c handler */
944 if (! aout_32_make_sections (abfd))
947 obj_textsec (abfd)->filepos = sizeof(struct internal_exec);
948 obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
949 + obj_textsec (abfd)->_raw_size;
952 /* regardless, once we know what we're doing, we might as well get going */
953 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
957 return (bfd_write ((PTR)location, 1, count, abfd) == count) ?true:false;
963 b_out_set_arch_mach (abfd, arch, machine)
965 enum bfd_architecture arch;
966 unsigned long machine;
968 bfd_default_set_arch_mach(abfd, arch, machine);
970 if (arch == bfd_arch_unknown) /* Unknown machine arch is OK */
972 if (arch == bfd_arch_i960) /* i960 default is OK */
974 case bfd_mach_i960_core:
975 case bfd_mach_i960_kb_sb:
976 case bfd_mach_i960_mc:
977 case bfd_mach_i960_xa:
978 case bfd_mach_i960_ca:
979 case bfd_mach_i960_ka_sa:
980 case bfd_mach_i960_jx:
981 case bfd_mach_i960_hx:
992 b_out_sizeof_headers (ignore_abfd, ignore)
993 bfd *ignore_abfd ATTRIBUTE_UNUSED;
994 boolean ignore ATTRIBUTE_UNUSED;
996 return sizeof(struct internal_exec);
999 /************************************************************************/
1001 get_value (reloc, link_info, input_section)
1003 struct bfd_link_info *link_info;
1004 asection *input_section;
1007 asymbol *symbol = *(reloc->sym_ptr_ptr);
1009 /* A symbol holds a pointer to a section, and an offset from the
1010 base of the section. To relocate, we find where the section will
1011 live in the output and add that in */
1013 if (bfd_is_und_section (symbol->section))
1015 struct bfd_link_hash_entry *h;
1017 /* The symbol is undefined in this BFD. Look it up in the
1018 global linker hash table. FIXME: This should be changed when
1019 we convert b.out to use a specific final_link function and
1020 change the interface to bfd_relax_section to not require the
1022 h = bfd_wrapped_link_hash_lookup (input_section->owner, link_info,
1023 bfd_asymbol_name (symbol),
1024 false, false, true);
1025 if (h != (struct bfd_link_hash_entry *) NULL
1026 && (h->type == bfd_link_hash_defined
1027 || h->type == bfd_link_hash_defweak))
1028 value = h->u.def.value + output_addr (h->u.def.section);
1029 else if (h != (struct bfd_link_hash_entry *) NULL
1030 && h->type == bfd_link_hash_common)
1031 value = h->u.c.size;
1034 if (! ((*link_info->callbacks->undefined_symbol)
1035 (link_info, bfd_asymbol_name (symbol),
1036 input_section->owner, input_section, reloc->address,
1044 value = symbol->value + output_addr (symbol->section);
1047 /* Add the value contained in the relocation */
1048 value += reloc->addend;
1054 perform_slip (abfd, slip, input_section, value)
1057 asection *input_section;
1062 s = _bfd_generic_link_get_symbols (abfd);
1063 BFD_ASSERT (s != (asymbol **) NULL);
1065 /* Find all symbols past this point, and make them know
1070 if (p->section == input_section)
1072 /* This was pointing into this section, so mangle it */
1073 if (p->value > value)
1076 if (p->udata.p != NULL)
1078 struct generic_link_hash_entry *h;
1080 h = (struct generic_link_hash_entry *) p->udata.p;
1081 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
1082 h->root.u.def.value -= slip;
1083 BFD_ASSERT (h->root.u.def.value == p->value);
1092 /* This routine works out if the thing we want to get to can be
1093 reached with a 24bit offset instead of a 32 bit one.
1094 If it can, then it changes the amode */
1097 abs32code (abfd, input_section, r, shrink, link_info)
1099 asection *input_section;
1101 unsigned int shrink;
1102 struct bfd_link_info *link_info;
1104 bfd_vma value = get_value (r, link_info, input_section);
1105 bfd_vma dot = output_addr (input_section) + r->address;
1108 /* See if the address we're looking at within 2^23 bytes of where
1109 we are, if so then we can use a small branch rather than the
1110 jump we were going to */
1112 gap = value - (dot - shrink);
1114 if (-1<<23 < (long)gap && (long)gap < 1<<23 )
1116 /* Change the reloc type from 32bitcode possible 24, to 24bit
1119 r->howto = &howto_reloc_abs32codeshrunk;
1120 /* The place to relc moves back by four bytes */
1123 /* This will be four bytes smaller in the long run */
1125 perform_slip (abfd, 4, input_section, r->address-shrink + 4);
1131 aligncode (abfd, input_section, r, shrink)
1133 asection *input_section;
1135 unsigned int shrink;
1137 bfd_vma dot = output_addr (input_section) + r->address;
1142 int size = r->howto->size;
1144 /* Reduce the size of the alignment so that it's still aligned but
1145 smaller - the current size is already the same size as or bigger
1146 than the alignment required. */
1148 /* calculate the first byte following the padding before we optimize */
1149 old_end = ((dot + size ) & ~size) + size+1;
1150 /* work out where the new end will be - remember that we're smaller
1151 than we used to be */
1152 new_end = ((dot - shrink + size) & ~size);
1154 /* This is the new end */
1155 gap = old_end - ((dot + size) & ~size);
1157 shrink_delta = (old_end - new_end) - shrink;
1161 /* Change the reloc so that it knows how far to align to */
1162 r->howto = howto_done_align_table + (r->howto - howto_align_table);
1164 /* Encode the stuff into the addend - for future use we need to
1165 know how big the reloc used to be */
1166 r->addend = old_end - dot + r->address;
1168 /* This will be N bytes smaller in the long run, adjust all the symbols */
1169 perform_slip (abfd, shrink_delta, input_section, r->address - shrink);
1170 shrink += shrink_delta;
1176 b_out_bfd_relax_section (abfd, i, link_info, again)
1179 struct bfd_link_info *link_info;
1182 /* Get enough memory to hold the stuff */
1183 bfd *input_bfd = i->owner;
1184 asection *input_section = i;
1186 arelent **reloc_vector = NULL;
1187 long reloc_size = bfd_get_reloc_upper_bound(input_bfd,
1193 /* We only run this relaxation once. It might work to run it
1194 multiple times, but it hasn't been tested. */
1201 reloc_vector = (arelent **) bfd_malloc (reloc_size);
1202 if (reloc_vector == NULL && reloc_size != 0)
1205 /* Get the relocs and think about them */
1207 bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector,
1208 _bfd_generic_link_get_symbols (input_bfd));
1209 if (reloc_count < 0)
1211 if (reloc_count > 0)
1214 for (parent = reloc_vector; *parent; parent++)
1216 arelent *r = *parent;
1217 switch (r->howto->type)
1220 /* An alignment reloc */
1221 shrink = aligncode (abfd, input_section, r, shrink);
1224 /* A 32bit reloc in an addressing mode */
1225 shrink = abs32code (input_bfd, input_section, r, shrink,
1228 case ABS32CODE_SHRUNK:
1235 input_section->_cooked_size = input_section->_raw_size - shrink;
1237 if (reloc_vector != NULL)
1238 free (reloc_vector);
1241 if (reloc_vector != NULL)
1242 free (reloc_vector);
1247 b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
1248 data, relocateable, symbols)
1250 struct bfd_link_info *link_info;
1251 struct bfd_link_order *link_order;
1253 boolean relocateable;
1256 /* Get enough memory to hold the stuff */
1257 bfd *input_bfd = link_order->u.indirect.section->owner;
1258 asection *input_section = link_order->u.indirect.section;
1259 long reloc_size = bfd_get_reloc_upper_bound (input_bfd,
1261 arelent **reloc_vector = NULL;
1267 /* If producing relocateable output, don't bother to relax. */
1269 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1274 reloc_vector = (arelent **) bfd_malloc (reloc_size);
1275 if (reloc_vector == NULL && reloc_size != 0)
1278 input_section->reloc_done = 1;
1280 /* read in the section */
1281 BFD_ASSERT (true == bfd_get_section_contents (input_bfd,
1285 input_section->_raw_size));
1287 reloc_count = bfd_canonicalize_reloc (input_bfd,
1291 if (reloc_count < 0)
1293 if (reloc_count > 0)
1295 arelent **parent = reloc_vector;
1298 unsigned int dst_address = 0;
1299 unsigned int src_address = 0;
1303 /* Find how long a run we can do */
1304 while (dst_address < link_order->size)
1309 /* Note that the relaxing didn't tie up the addresses in the
1310 relocation, so we use the original address to work out the
1311 run of non-relocated data */
1312 BFD_ASSERT (reloc->address >= src_address);
1313 run = reloc->address - src_address;
1318 run = link_order->size - dst_address;
1320 /* Copy the bytes */
1321 for (idx = 0; idx < run; idx++)
1323 data[dst_address++] = data[src_address++];
1326 /* Now do the relocation */
1330 switch (reloc->howto->type)
1333 calljx_callback (input_bfd, link_info, reloc,
1334 src_address + data, dst_address + data,
1340 bfd_put_32 (input_bfd,
1341 (bfd_get_32 (input_bfd, data + src_address)
1342 + get_value (reloc, link_info, input_section)),
1343 data + dst_address);
1348 callj_callback (input_bfd, link_info, reloc, data,
1349 src_address, dst_address, input_section,
1355 BFD_ASSERT (reloc->addend >= src_address);
1356 BFD_ASSERT (reloc->addend <= input_section->_raw_size);
1357 src_address = reloc->addend;
1358 dst_address = ((dst_address + reloc->howto->size)
1359 & ~reloc->howto->size);
1361 case ABS32CODE_SHRUNK:
1362 /* This used to be a callx, but we've found out that a
1363 callj will reach, so do the right thing. */
1364 callj_callback (input_bfd, link_info, reloc, data,
1365 src_address + 4, dst_address, input_section,
1372 long int word = bfd_get_32 (input_bfd,
1373 data + src_address);
1376 value = get_value (reloc, link_info, input_section);
1377 word = ((word & ~BAL_MASK)
1378 | (((word & BAL_MASK)
1380 - output_addr (input_section)
1384 bfd_put_32 (input_bfd, word, data + dst_address);
1393 long int word = bfd_get_32 (input_bfd,
1394 data + src_address);
1397 value = get_value (reloc, link_info, input_section);
1398 word = ((word & ~PCREL13_MASK)
1399 | (((word & PCREL13_MASK)
1402 - output_addr (input_section))
1405 bfd_put_32 (input_bfd, word, data + dst_address);
1418 if (reloc_vector != NULL)
1419 free (reloc_vector);
1422 if (reloc_vector != NULL)
1423 free (reloc_vector);
1426 /***********************************************************************/
1428 /* Build the transfer vectors for Big and Little-Endian B.OUT files. */
1430 #define aout_32_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1431 #define aout_32_close_and_cleanup aout_32_bfd_free_cached_info
1433 #define b_out_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1434 #define b_out_bfd_link_add_symbols _bfd_generic_link_add_symbols
1435 #define b_out_bfd_final_link _bfd_generic_final_link
1436 #define b_out_bfd_link_split_section _bfd_generic_link_split_section
1437 #define b_out_bfd_gc_sections bfd_generic_gc_sections
1439 #define aout_32_get_section_contents_in_window \
1440 _bfd_generic_get_section_contents_in_window
1442 extern const bfd_target b_out_vec_little_host;
1444 const bfd_target b_out_vec_big_host =
1446 "b.out.big", /* name */
1447 bfd_target_aout_flavour,
1448 BFD_ENDIAN_LITTLE, /* data byte order is little */
1449 BFD_ENDIAN_BIG, /* hdr byte order is big */
1450 (HAS_RELOC | EXEC_P | /* object flags */
1451 HAS_LINENO | HAS_DEBUG |
1452 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
1453 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1454 '_', /* symbol leading char */
1455 ' ', /* ar_pad_char */
1456 16, /* ar_max_namelen */
1458 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1459 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1460 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1461 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1462 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1463 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1464 {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
1465 bfd_generic_archive_p, _bfd_dummy_target},
1466 {bfd_false, b_out_mkobject, /* bfd_set_format */
1467 _bfd_generic_mkarchive, bfd_false},
1468 {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
1469 _bfd_write_archive_contents, bfd_false},
1471 BFD_JUMP_TABLE_GENERIC (aout_32),
1472 BFD_JUMP_TABLE_COPY (_bfd_generic),
1473 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1474 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
1475 BFD_JUMP_TABLE_SYMBOLS (aout_32),
1476 BFD_JUMP_TABLE_RELOCS (b_out),
1477 BFD_JUMP_TABLE_WRITE (b_out),
1478 BFD_JUMP_TABLE_LINK (b_out),
1479 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1481 & b_out_vec_little_host,
1486 const bfd_target b_out_vec_little_host =
1488 "b.out.little", /* name */
1489 bfd_target_aout_flavour,
1490 BFD_ENDIAN_LITTLE, /* data byte order is little */
1491 BFD_ENDIAN_LITTLE, /* header byte order is little */
1492 (HAS_RELOC | EXEC_P | /* object flags */
1493 HAS_LINENO | HAS_DEBUG |
1494 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
1495 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1496 '_', /* symbol leading char */
1497 ' ', /* ar_pad_char */
1498 16, /* ar_max_namelen */
1499 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1500 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1501 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1502 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1503 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1504 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1506 {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
1507 bfd_generic_archive_p, _bfd_dummy_target},
1508 {bfd_false, b_out_mkobject, /* bfd_set_format */
1509 _bfd_generic_mkarchive, bfd_false},
1510 {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
1511 _bfd_write_archive_contents, bfd_false},
1513 BFD_JUMP_TABLE_GENERIC (aout_32),
1514 BFD_JUMP_TABLE_COPY (_bfd_generic),
1515 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1516 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
1517 BFD_JUMP_TABLE_SYMBOLS (aout_32),
1518 BFD_JUMP_TABLE_RELOCS (b_out),
1519 BFD_JUMP_TABLE_WRITE (b_out),
1520 BFD_JUMP_TABLE_LINK (b_out),
1521 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1523 & b_out_vec_big_host,