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