Commit | Line | Data |
---|---|---|
d924db55 EB |
1 | /* Visium-specific support for 32-bit ELF. |
2 | ||
2571583a | 3 | Copyright (C) 2003-2017 Free Software Foundation, Inc. |
d924db55 EB |
4 | |
5 | This file is part of BFD, the Binary File Descriptor library. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 3 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
19 | Foundation, Inc., 51 Franklin Street - Fifth Floor, | |
20 | Boston, MA 02110-1301, USA. */ | |
21 | ||
22 | #include "sysdep.h" | |
23 | #include "bfd.h" | |
24 | #include "sysdep.h" | |
25 | #include "libbfd.h" | |
26 | #include "elf-bfd.h" | |
27 | #include "elf/visium.h" | |
28 | ||
29 | static bfd_reloc_status_type visium_elf_howto_parity_reloc | |
30 | (bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **); | |
31 | ||
32 | static reloc_howto_type visium_elf_howto_table[] = { | |
33 | /* This reloc does nothing. */ | |
34 | HOWTO (R_VISIUM_NONE, /* type */ | |
35 | 0, /* rightshift */ | |
6346d5ca AM |
36 | 3, /* size (0 = byte, 1 = short, 2 = long) */ |
37 | 0, /* bitsize */ | |
d924db55 EB |
38 | FALSE, /* pc_relative */ |
39 | 0, /* bitpos */ | |
6346d5ca | 40 | complain_overflow_dont, /* complain_on_overflow */ |
d924db55 EB |
41 | bfd_elf_generic_reloc, /* special_function */ |
42 | "R_VISIUM_NONE", /* name */ | |
43 | FALSE, /* partial_inplace */ | |
44 | 0, /* src_mask */ | |
45 | 0, /* dst_mask */ | |
46 | FALSE), /* pcrel_offset */ | |
47 | ||
48 | /* A 8 bit absolute relocation. */ | |
49 | HOWTO (R_VISIUM_8, /* type */ | |
50 | 0, /* rightshift */ | |
51 | 0, /* size (0 = byte, 1 = short, 2 = long) */ | |
52 | 8, /* bitsize */ | |
53 | FALSE, /* pc_relative */ | |
54 | 0, /* bitpos */ | |
55 | complain_overflow_bitfield, /* complain_on_overflow */ | |
56 | bfd_elf_generic_reloc, /* special_function */ | |
57 | "R_VISIUM_8", /* name */ | |
58 | FALSE, /* partial_inplace */ | |
59 | 0x00, /* src_mask */ | |
60 | 0xff, /* dst_mask */ | |
61 | FALSE), /* pcrel_offset */ | |
62 | ||
63 | /* A 16 bit absolute relocation. */ | |
64 | HOWTO (R_VISIUM_16, /* type */ | |
65 | 0, /* rightshift */ | |
66 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
67 | 16, /* bitsize */ | |
68 | FALSE, /* pc_relative */ | |
69 | 0, /* bitpos */ | |
70 | complain_overflow_bitfield, /* complain_on_overflow */ | |
71 | bfd_elf_generic_reloc, /* special_function */ | |
72 | "R_VISIUM_16", /* name */ | |
73 | FALSE, /* partial_inplace */ | |
74 | 0x0000, /* src_mask */ | |
75 | 0xffff, /* dst_mask */ | |
76 | FALSE), /* pcrel_offset */ | |
77 | ||
78 | /* A 32 bit absolute relocation. */ | |
79 | HOWTO (R_VISIUM_32, /* type */ | |
80 | 0, /* rightshift */ | |
81 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
82 | 32, /* bitsize */ | |
83 | FALSE, /* pc_relative */ | |
84 | 0, /* bitpos */ | |
85 | complain_overflow_bitfield, /* complain_on_overflow */ | |
86 | bfd_elf_generic_reloc, /* special_function */ | |
87 | "R_VISIUM_32", /* name */ | |
88 | FALSE, /* partial_inplace */ | |
89 | 0x00000000, /* src_mask */ | |
90 | 0xffffffff, /* dst_mask */ | |
91 | FALSE), /* pcrel_offset */ | |
92 | ||
93 | ||
94 | /* A 8 bit PC relative relocation. */ | |
95 | HOWTO (R_VISIUM_8_PCREL, /* type */ | |
96 | 0, /* rightshift */ | |
97 | 0, /* size (0 = byte, 1 = short, 2 = long) */ | |
98 | 8, /* bitsize */ | |
99 | TRUE, /* pc_relative */ | |
100 | 0, /* bitpos */ | |
101 | complain_overflow_bitfield, /* complain_on_overflow */ | |
102 | bfd_elf_generic_reloc, /* special_function */ | |
103 | "R_VISIUM_8_PCREL", /* name */ | |
104 | FALSE, /* partial_inplace */ | |
105 | 0x00, /* src_mask */ | |
106 | 0xff, /* dst_mask */ | |
107 | TRUE), /* pcrel_offset */ | |
108 | ||
109 | /* A 16 bit PC relative relocation. */ | |
110 | HOWTO (R_VISIUM_16_PCREL, /* type */ | |
111 | 0, /* rightshift */ | |
112 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
113 | 16, /* bitsize */ | |
114 | TRUE, /* pc_relative */ | |
115 | 0, /* bitpos */ | |
116 | complain_overflow_bitfield, /* complain_on_overflow */ | |
117 | bfd_elf_generic_reloc, /* special_function */ | |
118 | "R_VISIUM_16_PCREL", /* name */ | |
119 | FALSE, /* partial inplace */ | |
120 | 0x0000, /* src_mask */ | |
121 | 0xffff, /* dst_mask */ | |
122 | TRUE), /* pcrel_offset */ | |
123 | ||
124 | /* A 32-bit PC relative relocation. */ | |
125 | HOWTO (R_VISIUM_32_PCREL, /* type */ | |
126 | 0, /* rightshift */ | |
127 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
128 | 32, /* bitsize */ | |
129 | TRUE, /* pc_relative */ | |
130 | 0, /* bitpos */ | |
131 | complain_overflow_bitfield, /* complain_on_overflow */ | |
132 | bfd_elf_generic_reloc, /* special_function */ | |
133 | "R_VISIUM_32_PCREL", /* name */ | |
134 | FALSE, /* partial_inplace */ | |
135 | 0, /* src_mask */ | |
136 | 0xffffffff, /* dst_mask */ | |
137 | TRUE), /* pcrel_offset */ | |
138 | ||
139 | /* A 16-bit PC word relative offset, relative to start of instruction | |
140 | and always in the second half of the instruction. */ | |
141 | HOWTO (R_VISIUM_PC16, /* type */ | |
142 | 2, /* rightshift */ | |
143 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
144 | 16, /* bitsize */ | |
145 | TRUE, /* pc_relative */ | |
146 | 0, /* bitpos */ | |
147 | complain_overflow_signed, /* complain_on_overflow */ | |
148 | visium_elf_howto_parity_reloc, /* special_function */ | |
149 | "R_VISIUM_PC16", /* name */ | |
150 | FALSE, /* partial_inplace */ | |
151 | 0x00000000, /* src_mask */ | |
152 | 0x0000ffff, /* dst_mask */ | |
153 | TRUE), /* pcrel_offset */ | |
154 | ||
155 | /* The high 16 bits of symbol value. */ | |
156 | HOWTO (R_VISIUM_HI16, /* type */ | |
157 | 16, /* rightshift */ | |
158 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
159 | 16, /* bitsize */ | |
160 | FALSE, /* pc_relative */ | |
161 | 0, /* bitpos */ | |
162 | complain_overflow_dont, /* complain_on_overflow */ | |
163 | visium_elf_howto_parity_reloc, /* special_function */ | |
164 | "R_VISIUM_HI16", /* name */ | |
165 | FALSE, /* partial_inplace */ | |
166 | 0x00000000, /* src_mask */ | |
167 | 0x0000ffff, /* dst_mask */ | |
168 | FALSE), /* pcrel_offset */ | |
169 | ||
170 | /* The low 16 bits of symbol value. */ | |
171 | HOWTO (R_VISIUM_LO16, /* type */ | |
172 | 0, /* rightshift */ | |
173 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
174 | 16, /* bitsize */ | |
175 | FALSE, /* pc_relative */ | |
176 | 0, /* bitpos */ | |
177 | complain_overflow_dont, /* complain_on_overflow */ | |
178 | visium_elf_howto_parity_reloc, /* special_function */ | |
179 | "R_VISIUM_LO16", /* name */ | |
180 | FALSE, /* partial_inplace */ | |
181 | 0x00000000, /* src_mask */ | |
182 | 0x0000ffff, /* dst_mask */ | |
183 | FALSE), /* pcrel_offset */ | |
184 | ||
185 | /* A 16 bit immediate value. */ | |
186 | HOWTO (R_VISIUM_IM16, /* type */ | |
187 | 0, /* rightshift */ | |
188 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
189 | 16, /* bitsize */ | |
190 | FALSE, /* pc_relative */ | |
191 | 0, /* bitpos */ | |
192 | complain_overflow_unsigned, /* complain_on_overflow */ | |
193 | visium_elf_howto_parity_reloc, /* special_function */ | |
194 | "R_VISIUM_IM16", /* name */ | |
195 | FALSE, /* partial_inplace */ | |
196 | 0x0000000, /* src_mask */ | |
197 | 0x000ffff, /* dst_mask */ | |
198 | FALSE), /* pcrel_offset */ | |
199 | ||
200 | /* The high 16 bits of symbol value, pc relative. */ | |
201 | HOWTO (R_VISIUM_HI16_PCREL, /* type */ | |
202 | 16, /* rightshift */ | |
203 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
204 | 16, /* bitsize */ | |
205 | TRUE, /* pc_relative */ | |
206 | 0, /* bitpos */ | |
207 | complain_overflow_dont, /* complain_on_overflow */ | |
208 | visium_elf_howto_parity_reloc, /* special_function */ | |
209 | "R_VISIUM_HI16_PCREL", /* name */ | |
210 | FALSE, /* partial_inplace */ | |
211 | 0x00000000, /* src_mask */ | |
212 | 0x0000ffff, /* dst_mask */ | |
213 | TRUE), /* pcrel_offset */ | |
214 | ||
215 | /* The low 16 bits of symbol value, pc relative. */ | |
216 | HOWTO (R_VISIUM_LO16_PCREL, /* type */ | |
217 | 0, /* rightshift */ | |
218 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
219 | 16, /* bitsize */ | |
220 | TRUE, /* pc_relative */ | |
221 | 0, /* bitpos */ | |
222 | complain_overflow_dont, /* complain_on_overflow */ | |
223 | visium_elf_howto_parity_reloc, /* special_function */ | |
224 | "R_VISIUM_LO16_PCREL", /* name */ | |
225 | FALSE, /* partial_inplace */ | |
226 | 0x00000000, /* src_mask */ | |
227 | 0x0000ffff, /* dst_mask */ | |
228 | TRUE), /* pcrel_offset */ | |
229 | ||
230 | /* A 16 bit immediate value, pc relative. */ | |
231 | HOWTO (R_VISIUM_IM16_PCREL, /* type */ | |
232 | 0, /* rightshift */ | |
233 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
234 | 16, /* bitsize */ | |
235 | TRUE, /* pc_relative */ | |
236 | 0, /* bitpos */ | |
237 | complain_overflow_unsigned, /* complain_on_overflow */ | |
238 | visium_elf_howto_parity_reloc, /* special_function */ | |
239 | "R_VISIUM_IM16_PCREL", /* name */ | |
240 | FALSE, /* partial_inplace */ | |
241 | 0x0000000, /* src_mask */ | |
242 | 0x000ffff, /* dst_mask */ | |
243 | TRUE), /* pcrel_offset */ | |
244 | ||
245 | }; | |
246 | ||
247 | /* GNU extension to record C++ vtable hierarchy. */ | |
248 | static reloc_howto_type visium_elf_vtinherit_howto = | |
249 | HOWTO (R_VISIUM_GNU_VTINHERIT, /* type */ | |
250 | 0, /* rightshift */ | |
251 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
252 | 0, /* bitsize */ | |
253 | FALSE, /* pc_relative */ | |
254 | 0, /* bitpos */ | |
255 | complain_overflow_dont, /* complain_on_overflow */ | |
256 | NULL, /* special_function */ | |
257 | "R_VISIUM_GNU_VTINHERIT", /* name */ | |
258 | FALSE, /* partial_inplace */ | |
259 | 0, /* src_mask */ | |
260 | 0, /* dst_mask */ | |
261 | FALSE); /* pcrel_offset */ | |
262 | ||
263 | /* GNU extension to record C++ vtable member usage. */ | |
264 | static reloc_howto_type visium_elf_vtentry_howto = | |
265 | HOWTO (R_VISIUM_GNU_VTENTRY, /* type */ | |
266 | 0, /* rightshift */ | |
267 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
268 | 0, /* bitsize */ | |
269 | FALSE, /* pc_relative */ | |
270 | 0, /* bitpos */ | |
271 | complain_overflow_dont, /* complain_on_overflow */ | |
272 | NULL, /* special_function */ | |
273 | "R_VISIUM_GNU_VTENTRY", /* name */ | |
274 | FALSE, /* partial_inplace */ | |
275 | 0, /* src_mask */ | |
276 | 0, /* dst_mask */ | |
277 | FALSE); /* pcrel_offset */ | |
278 | ||
d924db55 EB |
279 | /* Return the parity bit for INSN shifted to its final position. */ |
280 | ||
281 | static bfd_vma | |
282 | visium_parity_bit (bfd_vma insn) | |
283 | { | |
284 | bfd_vma p = 0; | |
285 | int i; | |
286 | ||
287 | for (i = 0; i < 31; i++) | |
288 | { | |
289 | p ^= (insn & 1); | |
290 | insn >>= 1; | |
291 | } | |
292 | ||
293 | return p << 31; | |
294 | } | |
295 | ||
296 | /* This "special function" will only be used when the input and | |
297 | output files have different formats ie. when generating S-records | |
298 | directly using "--oformat srec". Otherwise we use | |
299 | _bfd_final_link_relocate which uses a howto structure, but does | |
300 | not use the special_function field. | |
301 | ||
302 | It sets instruction parity to even. This cannot be done by a howto. */ | |
303 | ||
304 | static bfd_reloc_status_type | |
305 | visium_elf_howto_parity_reloc (bfd * input_bfd, arelent *reloc_entry, | |
306 | asymbol *symbol, PTR data, | |
307 | asection *input_section, bfd *output_bfd, | |
308 | char **error_message ATTRIBUTE_UNUSED) | |
309 | { | |
310 | bfd_reloc_status_type ret; | |
311 | bfd_vma relocation; | |
312 | bfd_byte *inplace_address; | |
313 | bfd_vma insn; | |
314 | const bfd_vma signmask = 0xffff8000; | |
315 | ||
316 | /* This part is from bfd_elf_generic_reloc. | |
317 | If we're relocating, and this an external symbol, we don't want | |
318 | to change anything. */ | |
319 | if (output_bfd != (bfd *) NULL && (symbol->flags & BSF_SECTION_SYM) == 0) | |
320 | { | |
321 | reloc_entry->address += input_section->output_offset; | |
322 | return bfd_reloc_ok; | |
323 | } | |
324 | ||
325 | /* Now do the reloc in the usual way. */ | |
326 | ||
327 | /* Sanity check the address (offset in section). */ | |
328 | if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section)) | |
329 | return bfd_reloc_outofrange; | |
330 | ||
331 | ret = bfd_reloc_ok; | |
332 | if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL) | |
333 | ret = bfd_reloc_undefined; | |
334 | ||
335 | if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL) | |
336 | relocation = 0; | |
337 | else | |
338 | relocation = symbol->value; | |
339 | ||
340 | /* Only do this for a final link. */ | |
341 | if (output_bfd == (bfd *) NULL) | |
342 | { | |
343 | relocation += symbol->section->output_section->vma; | |
344 | relocation += symbol->section->output_offset; | |
345 | } | |
346 | ||
347 | relocation += reloc_entry->addend; | |
348 | inplace_address = (bfd_byte *) data + reloc_entry->address; | |
349 | insn = bfd_get_32 (input_bfd, inplace_address); | |
350 | ||
351 | if (reloc_entry->howto->pc_relative) | |
352 | { | |
353 | relocation -= input_section->output_section->vma | |
354 | + input_section->output_offset; | |
355 | relocation -= reloc_entry->address; | |
356 | } | |
357 | ||
358 | switch (reloc_entry->howto->type) | |
359 | { | |
360 | case R_VISIUM_PC16: | |
361 | relocation >>= 2; | |
362 | if (ret == bfd_reloc_ok && (relocation & signmask) != 0 | |
363 | && (relocation & signmask) != signmask) | |
364 | ret = bfd_reloc_overflow; | |
365 | relocation &= 0xffff; | |
366 | break; | |
367 | case R_VISIUM_HI16: | |
368 | case R_VISIUM_HI16_PCREL: | |
369 | relocation = (relocation >> 16) & 0xffff; | |
370 | break; | |
371 | case R_VISIUM_LO16: | |
372 | case R_VISIUM_LO16_PCREL: | |
373 | relocation &= 0xffff; | |
374 | break; | |
375 | case R_VISIUM_IM16: | |
376 | case R_VISIUM_IM16_PCREL: | |
377 | if (ret == bfd_reloc_ok && (relocation & 0xffff0000) != 0) | |
378 | ret = bfd_reloc_overflow; | |
379 | relocation &= 0xffff; | |
380 | break; | |
381 | } | |
382 | insn = (insn & 0x7fff0000) | relocation; | |
383 | insn |= visium_parity_bit (insn); | |
384 | bfd_put_32 (input_bfd, insn, inplace_address); | |
385 | ||
386 | if (output_bfd != (bfd *) NULL) | |
387 | reloc_entry->address += input_section->output_offset; | |
388 | ||
389 | return ret; | |
390 | } | |
391 | ||
392 | static reloc_howto_type * | |
393 | visium_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, | |
394 | bfd_reloc_code_real_type code) | |
395 | { | |
396 | /* Note that the visium_elf_howto_table is indexed by the R_ | |
397 | constants. Thus, the order that the howto records appear in the | |
398 | table *must* match the order of the relocation types defined in | |
399 | include/elf/visium.h. */ | |
400 | switch (code) | |
401 | { | |
402 | case BFD_RELOC_NONE: | |
403 | return &visium_elf_howto_table[(int) R_VISIUM_NONE]; | |
404 | case BFD_RELOC_8: | |
405 | return &visium_elf_howto_table[(int) R_VISIUM_8]; | |
406 | case BFD_RELOC_16: | |
407 | return &visium_elf_howto_table[(int) R_VISIUM_16]; | |
408 | case BFD_RELOC_32: | |
409 | return &visium_elf_howto_table[(int) R_VISIUM_32]; | |
410 | case BFD_RELOC_8_PCREL: | |
411 | return &visium_elf_howto_table[(int) R_VISIUM_8_PCREL]; | |
412 | case BFD_RELOC_16_PCREL: | |
413 | return &visium_elf_howto_table[(int) R_VISIUM_16_PCREL]; | |
414 | case BFD_RELOC_32_PCREL: | |
415 | return &visium_elf_howto_table[(int) R_VISIUM_32_PCREL]; | |
416 | case BFD_RELOC_VISIUM_REL16: | |
417 | return &visium_elf_howto_table[(int) R_VISIUM_PC16]; | |
418 | case BFD_RELOC_VISIUM_HI16: | |
419 | return &visium_elf_howto_table[(int) R_VISIUM_HI16]; | |
420 | case BFD_RELOC_VISIUM_LO16: | |
421 | return &visium_elf_howto_table[(int) R_VISIUM_LO16]; | |
422 | case BFD_RELOC_VISIUM_IM16: | |
423 | return &visium_elf_howto_table[(int) R_VISIUM_IM16]; | |
424 | case BFD_RELOC_VISIUM_HI16_PCREL: | |
425 | return &visium_elf_howto_table[(int) R_VISIUM_HI16_PCREL]; | |
426 | case BFD_RELOC_VISIUM_LO16_PCREL: | |
427 | return &visium_elf_howto_table[(int) R_VISIUM_LO16_PCREL]; | |
428 | case BFD_RELOC_VISIUM_IM16_PCREL: | |
429 | return &visium_elf_howto_table[(int) R_VISIUM_IM16_PCREL]; | |
430 | case BFD_RELOC_VTABLE_INHERIT: | |
431 | return &visium_elf_vtinherit_howto; | |
432 | case BFD_RELOC_VTABLE_ENTRY: | |
433 | return &visium_elf_vtentry_howto; | |
434 | default: | |
435 | return NULL; | |
436 | } | |
437 | } | |
438 | ||
439 | static reloc_howto_type * | |
440 | visium_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) | |
441 | { | |
442 | unsigned int i; | |
443 | ||
444 | for (i = 0; | |
445 | i < (sizeof (visium_elf_howto_table) | |
446 | / sizeof (visium_elf_howto_table[0])); i++) | |
447 | if (visium_elf_howto_table[i].name != NULL | |
448 | && strcasecmp (visium_elf_howto_table[i].name, r_name) == 0) | |
449 | return &visium_elf_howto_table[i]; | |
450 | ||
451 | if (strcasecmp (visium_elf_vtinherit_howto.name, r_name) == 0) | |
452 | return &visium_elf_vtinherit_howto; | |
453 | if (strcasecmp (visium_elf_vtentry_howto.name, r_name) == 0) | |
454 | return &visium_elf_vtentry_howto; | |
455 | ||
456 | return NULL; | |
457 | } | |
458 | ||
459 | /* Set the howto pointer for a VISIUM ELF reloc. */ | |
460 | ||
461 | static void | |
462 | visium_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, | |
463 | Elf_Internal_Rela *dst) | |
464 | { | |
465 | unsigned int r_type = ELF32_R_TYPE (dst->r_info); | |
466 | ||
467 | switch (r_type) | |
468 | { | |
469 | case R_VISIUM_GNU_VTINHERIT: | |
470 | cache_ptr->howto = &visium_elf_vtinherit_howto; | |
471 | break; | |
472 | ||
473 | case R_VISIUM_GNU_VTENTRY: | |
474 | cache_ptr->howto = &visium_elf_vtentry_howto; | |
475 | break; | |
476 | ||
477 | default: | |
5860e3f8 NC |
478 | if (r_type >= (unsigned int) R_VISIUM_max) |
479 | { | |
695344c0 | 480 | /* xgettext:c-format */ |
64d29018 | 481 | _bfd_error_handler (_("%B: invalid Visium reloc number: %d"), abfd, r_type); |
5860e3f8 NC |
482 | r_type = 0; |
483 | } | |
d924db55 EB |
484 | cache_ptr->howto = &visium_elf_howto_table[r_type]; |
485 | break; | |
486 | } | |
487 | } | |
488 | ||
489 | /* Look through the relocs for a section during the first phase. | |
490 | Since we don't do .gots or .plts, we just need to consider the | |
491 | virtual table relocs for gc. */ | |
492 | ||
493 | static bfd_boolean | |
494 | visium_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, | |
495 | asection *sec, const Elf_Internal_Rela *relocs) | |
496 | { | |
497 | Elf_Internal_Shdr *symtab_hdr; | |
498 | struct elf_link_hash_entry **sym_hashes; | |
499 | const Elf_Internal_Rela *rel; | |
500 | const Elf_Internal_Rela *rel_end; | |
501 | ||
0e1862bb | 502 | if (bfd_link_relocatable (info)) |
d924db55 EB |
503 | return TRUE; |
504 | ||
505 | symtab_hdr = &elf_tdata (abfd)->symtab_hdr; | |
506 | sym_hashes = elf_sym_hashes (abfd); | |
507 | ||
508 | rel_end = relocs + sec->reloc_count; | |
509 | for (rel = relocs; rel < rel_end; rel++) | |
510 | { | |
511 | struct elf_link_hash_entry *h; | |
512 | unsigned long r_symndx; | |
513 | ||
514 | r_symndx = ELF32_R_SYM (rel->r_info); | |
515 | if (r_symndx < symtab_hdr->sh_info) | |
516 | h = NULL; | |
517 | else | |
518 | { | |
519 | h = sym_hashes[r_symndx - symtab_hdr->sh_info]; | |
520 | while (h->root.type == bfd_link_hash_indirect | |
521 | || h->root.type == bfd_link_hash_warning) | |
522 | h = (struct elf_link_hash_entry *) h->root.u.i.link; | |
523 | } | |
524 | ||
525 | switch (ELF32_R_TYPE (rel->r_info)) | |
526 | { | |
527 | /* This relocation describes the C++ object vtable hierarchy. | |
528 | Reconstruct it for later use during GC. */ | |
529 | case R_VISIUM_GNU_VTINHERIT: | |
530 | if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) | |
531 | return FALSE; | |
532 | break; | |
533 | ||
534 | /* This relocation describes which C++ vtable entries are actually | |
535 | used. Record for later use during GC. */ | |
536 | case R_VISIUM_GNU_VTENTRY: | |
537 | if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) | |
538 | return FALSE; | |
539 | break; | |
540 | } | |
541 | } | |
542 | ||
543 | return TRUE; | |
544 | } | |
545 | ||
546 | /* Relocate a VISIUM ELF section. */ | |
547 | ||
548 | static bfd_boolean | |
549 | visium_elf_relocate_section (bfd *output_bfd, | |
550 | struct bfd_link_info *info, bfd *input_bfd, | |
551 | asection *input_section, bfd_byte *contents, | |
552 | Elf_Internal_Rela *relocs, | |
553 | Elf_Internal_Sym *local_syms, | |
554 | asection **local_sections) | |
555 | { | |
556 | Elf_Internal_Shdr *symtab_hdr; | |
557 | struct elf_link_hash_entry **sym_hashes; | |
558 | Elf_Internal_Rela *rel; | |
559 | Elf_Internal_Rela *relend; | |
560 | ||
561 | symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; | |
562 | sym_hashes = elf_sym_hashes (input_bfd); | |
563 | relend = relocs + input_section->reloc_count; | |
564 | ||
565 | for (rel = relocs; rel < relend; rel++) | |
566 | { | |
567 | reloc_howto_type *howto; | |
568 | unsigned long r_symndx; | |
569 | Elf_Internal_Sym *sym; | |
570 | asection *sec; | |
571 | struct elf_link_hash_entry *h; | |
572 | bfd_vma relocation; | |
573 | bfd_reloc_status_type r; | |
574 | const char *name = NULL; | |
575 | int r_type; | |
576 | bfd_vma insn; | |
577 | ||
578 | r_type = ELF32_R_TYPE (rel->r_info); | |
579 | ||
580 | if (r_type == R_VISIUM_GNU_VTINHERIT || r_type == R_VISIUM_GNU_VTENTRY) | |
581 | continue; | |
582 | ||
583 | r_symndx = ELF32_R_SYM (rel->r_info); | |
584 | ||
585 | howto = visium_elf_howto_table + ELF32_R_TYPE (rel->r_info); | |
586 | h = NULL; | |
587 | sym = NULL; | |
588 | sec = NULL; | |
589 | ||
590 | if (r_symndx < symtab_hdr->sh_info) | |
591 | { | |
592 | /* This is a local symbol. */ | |
593 | sym = local_syms + r_symndx; | |
594 | sec = local_sections[r_symndx]; | |
595 | relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); | |
596 | ||
597 | name = bfd_elf_string_from_elf_section | |
598 | (input_bfd, symtab_hdr->sh_link, sym->st_name); | |
599 | name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; | |
600 | } | |
601 | else | |
602 | { | |
603 | bfd_boolean unresolved_reloc; | |
604 | bfd_boolean warned, ignored; | |
605 | ||
606 | RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, | |
607 | r_symndx, symtab_hdr, sym_hashes, | |
608 | h, sec, relocation, | |
609 | unresolved_reloc, warned, ignored); | |
610 | ||
611 | name = h->root.root.string; | |
612 | } | |
613 | ||
614 | if (sec != NULL && discarded_section (sec)) | |
615 | { | |
616 | /* For relocs against symbols from removed linkonce sections, | |
617 | or sections discarded by a linker script, we just want the | |
618 | section contents zeroed. Avoid any special processing. */ | |
619 | _bfd_clear_contents (howto, input_bfd, input_section, | |
620 | contents + rel->r_offset); | |
621 | ||
622 | rel->r_info = 0; | |
623 | rel->r_addend = 0; | |
624 | continue; | |
625 | } | |
626 | ||
0e1862bb | 627 | if (bfd_link_relocatable (info)) |
d924db55 EB |
628 | continue; |
629 | ||
630 | switch (r_type) | |
631 | { | |
632 | case R_VISIUM_PC16: | |
633 | case R_VISIUM_HI16: | |
634 | case R_VISIUM_LO16: | |
635 | case R_VISIUM_IM16: | |
636 | case R_VISIUM_HI16_PCREL: | |
637 | case R_VISIUM_LO16_PCREL: | |
638 | case R_VISIUM_IM16_PCREL: | |
639 | r = _bfd_final_link_relocate (howto, input_bfd, input_section, | |
640 | contents, rel->r_offset, | |
641 | relocation, rel->r_addend); | |
642 | ||
643 | /* For instruction relocations, the parity needs correcting. */ | |
644 | if (r == bfd_reloc_ok) | |
645 | { | |
646 | insn = bfd_get_32 (input_bfd, contents + rel->r_offset); | |
647 | insn = (insn & 0x7fffffff) | visium_parity_bit (insn); | |
648 | bfd_put_32 (input_bfd, insn, contents + rel->r_offset); | |
649 | } | |
650 | break; | |
651 | ||
652 | default: | |
653 | r = _bfd_final_link_relocate (howto, input_bfd, input_section, | |
654 | contents, rel->r_offset, | |
655 | relocation, rel->r_addend); | |
656 | break; | |
657 | } | |
658 | ||
659 | if (r != bfd_reloc_ok) | |
660 | { | |
661 | const char *msg = (const char *) NULL; | |
662 | ||
663 | switch (r) | |
664 | { | |
665 | case bfd_reloc_overflow: | |
1a72702b | 666 | (*info->callbacks->reloc_overflow) |
d924db55 EB |
667 | (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0, |
668 | input_bfd, input_section, rel->r_offset); | |
669 | break; | |
670 | ||
671 | case bfd_reloc_undefined: | |
1a72702b | 672 | (*info->callbacks->undefined_symbol) |
d924db55 EB |
673 | (info, name, input_bfd, input_section, rel->r_offset, TRUE); |
674 | break; | |
675 | ||
676 | case bfd_reloc_outofrange: | |
677 | msg = _("internal error: out of range error"); | |
678 | break; | |
679 | ||
680 | case bfd_reloc_notsupported: | |
681 | msg = _("internal error: unsupported relocation error"); | |
682 | break; | |
683 | ||
684 | case bfd_reloc_dangerous: | |
685 | msg = _("internal error: dangerous relocation"); | |
686 | break; | |
687 | ||
688 | default: | |
689 | msg = _("internal error: unknown error"); | |
690 | break; | |
691 | } | |
692 | ||
693 | if (msg) | |
1a72702b AM |
694 | (*info->callbacks->warning) (info, msg, name, input_bfd, |
695 | input_section, rel->r_offset); | |
d924db55 EB |
696 | } |
697 | } | |
698 | ||
699 | return TRUE; | |
700 | } | |
701 | ||
702 | /* This function is called during section gc to discover the section a | |
703 | to which a particular relocation refers. Return the section that | |
704 | should be marked against GC for a given relocation. */ | |
705 | ||
706 | static asection * | |
707 | visium_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info, | |
708 | Elf_Internal_Rela *rel, struct elf_link_hash_entry *h, | |
709 | Elf_Internal_Sym *sym) | |
710 | { | |
711 | if (h != NULL) | |
712 | switch (ELF32_R_TYPE (rel->r_info)) | |
713 | { | |
714 | case R_VISIUM_GNU_VTINHERIT: | |
715 | case R_VISIUM_GNU_VTENTRY: | |
716 | return NULL; | |
717 | } | |
718 | ||
719 | return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); | |
720 | } | |
721 | ||
722 | static void | |
723 | visium_elf_post_process_headers (bfd *abfd, | |
724 | struct bfd_link_info *info ATTRIBUTE_UNUSED) | |
725 | { | |
726 | Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); | |
727 | i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_STANDALONE; | |
728 | i_ehdrp->e_ident[EI_ABIVERSION] = 1; | |
729 | } | |
730 | ||
731 | /* Function to set the ELF flag bits. */ | |
732 | ||
733 | static bfd_boolean | |
734 | visium_elf_set_private_flags (bfd *abfd, flagword flags) | |
735 | { | |
736 | elf_elfheader (abfd)->e_flags = flags; | |
737 | elf_flags_init (abfd) = TRUE; | |
738 | return TRUE; | |
739 | } | |
740 | ||
741 | /* Copy backend specific data from one object module to another. */ | |
742 | ||
743 | static bfd_boolean | |
744 | visium_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd) | |
745 | { | |
746 | if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour | |
747 | || bfd_get_flavour (obfd) != bfd_target_elf_flavour) | |
748 | return TRUE; | |
749 | ||
750 | BFD_ASSERT (!elf_flags_init (obfd) | |
751 | || elf_elfheader (obfd)->e_flags == | |
752 | elf_elfheader (ibfd)->e_flags); | |
753 | ||
754 | elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; | |
755 | elf_flags_init (obfd) = TRUE; | |
756 | ||
757 | /* Copy object attributes. */ | |
758 | _bfd_elf_copy_obj_attributes (ibfd, obfd); | |
759 | ||
760 | return TRUE; | |
761 | } | |
762 | ||
763 | /* Merge backend specific data from an object | |
764 | file to the output object file when linking. */ | |
765 | ||
766 | static bfd_boolean | |
50e03d47 | 767 | visium_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) |
d924db55 | 768 | { |
50e03d47 | 769 | bfd *obfd = info->output_bfd; |
d924db55 EB |
770 | flagword old_flags; |
771 | flagword new_flags; | |
772 | flagword mismatch; | |
773 | const char *opt_arch = NULL; | |
774 | const char *new_opt_with = NULL; | |
775 | const char *old_opt_with = NULL; | |
776 | const char *with = "with"; | |
777 | const char *without = "without"; | |
778 | const char *mcm = "mcm"; | |
779 | const char *mcm24 = "mcm24"; | |
780 | const char *gr6 = "gr6"; | |
781 | ||
782 | new_flags = elf_elfheader (ibfd)->e_flags; | |
783 | old_flags = elf_elfheader (obfd)->e_flags; | |
784 | ||
785 | if (!elf_flags_init (obfd)) | |
786 | { | |
787 | /* First call, no flags set. */ | |
788 | elf_flags_init (obfd) = TRUE; | |
789 | elf_elfheader (obfd)->e_flags = new_flags; | |
790 | } | |
791 | else | |
792 | { | |
793 | mismatch = (new_flags ^ old_flags) | |
794 | & (EF_VISIUM_ARCH_MCM | EF_VISIUM_ARCH_MCM24 | EF_VISIUM_ARCH_GR6); | |
795 | if (mismatch & EF_VISIUM_ARCH_GR6) | |
796 | { | |
797 | opt_arch = gr6; | |
798 | new_opt_with = new_flags & EF_VISIUM_ARCH_GR6 ? with : without; | |
799 | old_opt_with = old_flags & EF_VISIUM_ARCH_GR6 ? with : without; | |
800 | } | |
801 | else if (mismatch & EF_VISIUM_ARCH_MCM) | |
802 | { | |
803 | opt_arch = mcm; | |
804 | new_opt_with = new_flags & EF_VISIUM_ARCH_MCM ? with : without; | |
805 | old_opt_with = old_flags & EF_VISIUM_ARCH_MCM ? with : without; | |
806 | } | |
807 | else if (mismatch & EF_VISIUM_ARCH_MCM24) | |
808 | { | |
809 | opt_arch = mcm24; | |
810 | new_opt_with = new_flags & EF_VISIUM_ARCH_MCM24 ? with : without; | |
811 | old_opt_with = old_flags & EF_VISIUM_ARCH_MCM24 ? with : without; | |
812 | } | |
813 | ||
814 | if (mismatch) | |
815 | _bfd_error_handler | |
695344c0 | 816 | /* xgettext:c-format */ |
dae82561 | 817 | (_("%B: compiled %s -mtune=%s and linked with modules" |
695344c0 | 818 | " compiled %s -mtune=%s"), |
dae82561 | 819 | ibfd, new_opt_with, opt_arch, old_opt_with, opt_arch); |
d924db55 EB |
820 | } |
821 | ||
822 | return TRUE; | |
823 | } | |
824 | ||
825 | static bfd_boolean | |
826 | visium_elf_print_private_bfd_data (bfd *abfd, void *ptr) | |
827 | { | |
828 | FILE *file = (FILE *) ptr; | |
829 | flagword flags; | |
830 | ||
831 | BFD_ASSERT (abfd != NULL && ptr != NULL); | |
832 | ||
833 | /* Print normal ELF private data. */ | |
834 | _bfd_elf_print_private_bfd_data (abfd, ptr); | |
835 | ||
836 | flags = elf_elfheader (abfd)->e_flags; | |
837 | fprintf (file, _("private flags = 0x%lx:"), (long) flags); | |
838 | ||
839 | if (flags & EF_VISIUM_ARCH_GR6) | |
840 | fprintf (file, " -mtune=gr6"); | |
841 | else if (flags & EF_VISIUM_ARCH_MCM) | |
842 | fprintf (file, " -mtune=mcm"); | |
843 | else if (flags & EF_VISIUM_ARCH_MCM24) | |
844 | fprintf (file, " -mtune=mcm24"); | |
845 | ||
846 | fputc ('\n', file); | |
847 | return TRUE; | |
848 | } | |
849 | ||
850 | #define ELF_ARCH bfd_arch_visium | |
851 | #define ELF_MACHINE_CODE EM_VISIUM | |
852 | #define ELF_MAXPAGESIZE 1 | |
853 | ||
854 | #define TARGET_BIG_SYM visium_elf32_vec | |
855 | #define TARGET_BIG_NAME "elf32-visium" | |
856 | ||
857 | #define elf_info_to_howto_rel NULL | |
858 | #define elf_info_to_howto visium_info_to_howto_rela | |
859 | #define elf_backend_relocate_section visium_elf_relocate_section | |
860 | #define elf_backend_gc_mark_hook visium_elf_gc_mark_hook | |
861 | #define elf_backend_check_relocs visium_elf_check_relocs | |
862 | #define elf_backend_rela_normal 1 | |
863 | ||
864 | #define elf_backend_can_gc_sections 1 | |
865 | ||
866 | #define bfd_elf32_bfd_reloc_type_lookup visium_reloc_type_lookup | |
867 | #define bfd_elf32_bfd_reloc_name_lookup visium_reloc_name_lookup | |
868 | ||
869 | #define bfd_elf32_bfd_set_private_flags visium_elf_set_private_flags | |
870 | #define bfd_elf32_bfd_copy_private_bfd_data visium_elf_copy_private_bfd_data | |
871 | #define bfd_elf32_bfd_merge_private_bfd_data visium_elf_merge_private_bfd_data | |
872 | #define bfd_elf32_bfd_print_private_bfd_data visium_elf_print_private_bfd_data | |
873 | #define elf_backend_post_process_headers visium_elf_post_process_headers | |
874 | ||
875 | #include "elf32-target.h" |