Commit | Line | Data |
---|---|---|
d172d4ba | 1 | /* DLX specific support for 32-bit ELF |
eea6121a | 2 | Copyright 2002, 2003, 2004 Free Software Foundation, Inc. |
d172d4ba NC |
3 | |
4 | This file is part of BFD, the Binary File Descriptor library. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; if not, write to the Free Software | |
18 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
19 | ||
20 | #include "bfd.h" | |
21 | #include "sysdep.h" | |
22 | #include "libbfd.h" | |
23 | #include "elf-bfd.h" | |
24 | #include "elf/dlx.h" | |
25 | ||
26 | int set_dlx_skip_hi16_flag PARAMS ((int)); | |
27 | ||
b34976b6 AM |
28 | static bfd_boolean elf32_dlx_check_relocs |
29 | PARAMS ((bfd *, struct bfd_link_info *, asection *, | |
30 | const Elf_Internal_Rela *)); | |
d172d4ba | 31 | static void elf32_dlx_info_to_howto |
947216bf | 32 | PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); |
d172d4ba | 33 | static void elf32_dlx_info_to_howto_rel |
947216bf | 34 | PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); |
d172d4ba NC |
35 | static bfd_reloc_status_type elf32_dlx_relocate16 |
36 | PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); | |
37 | static bfd_reloc_status_type elf32_dlx_relocate26 | |
38 | PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); | |
39 | static reloc_howto_type *elf32_dlx_reloc_type_lookup | |
40 | PARAMS ((bfd *, bfd_reloc_code_real_type)); | |
41 | static bfd_reloc_status_type _bfd_dlx_elf_hi16_reloc | |
42 | PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); | |
43 | static reloc_howto_type * dlx_rtype_to_howto | |
44 | PARAMS ((unsigned int)); | |
45 | ||
46 | ||
47 | #define USE_REL 1 | |
48 | ||
49 | #define bfd_elf32_bfd_reloc_type_lookup elf32_dlx_reloc_type_lookup | |
50 | #define elf_info_to_howto elf32_dlx_info_to_howto | |
51 | #define elf_info_to_howto_rel elf32_dlx_info_to_howto_rel | |
52 | #define elf_backend_check_relocs elf32_dlx_check_relocs | |
53 | ||
54 | static reloc_howto_type dlx_elf_howto_table[]= | |
55 | { | |
56 | /* No relocation. */ | |
57 | HOWTO (R_DLX_NONE, /* type */ | |
58 | 0, /* rightshift */ | |
59 | 0, /* size (0 = byte, 1 = short, 2 = long) */ | |
60 | 0, /* bitsize */ | |
b34976b6 | 61 | FALSE, /* pc_relative */ |
d172d4ba NC |
62 | 0, /* bitpos */ |
63 | complain_overflow_dont,/* complain_on_overflow */ | |
64 | bfd_elf_generic_reloc, /* special_function */ | |
65 | "R_DLX_NONE", /* name */ | |
b34976b6 | 66 | FALSE, /* partial_inplace */ |
d172d4ba NC |
67 | 0, /* src_mask */ |
68 | 0, /* dst_mask */ | |
b34976b6 | 69 | FALSE), /* pcrel_offset */ |
d172d4ba NC |
70 | |
71 | /* 8 bit relocation. */ | |
72 | HOWTO (R_DLX_RELOC_8, /* type */ | |
73 | 0, /* rightshift */ | |
74 | 0, /* size (0 = byte, 1 = short, 2 = long) */ | |
75 | 8, /* bitsize */ | |
b34976b6 | 76 | FALSE, /* pc_relative */ |
d172d4ba NC |
77 | 0, /* bitpos */ |
78 | complain_overflow_dont,/* complain_on_overflow */ | |
79 | bfd_elf_generic_reloc, /* special_function */ | |
80 | "R_DLX_RELOC_8", /* name */ | |
b34976b6 | 81 | TRUE, /* partial_inplace */ |
d172d4ba NC |
82 | 0xff, /* src_mask */ |
83 | 0xff, /* dst_mask */ | |
b34976b6 | 84 | FALSE), /* pcrel_offset */ |
d172d4ba NC |
85 | |
86 | /* 16 bit relocation. */ | |
87 | HOWTO (R_DLX_RELOC_16, /* type */ | |
88 | 0, /* rightshift */ | |
89 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
90 | 16, /* bitsize */ | |
b34976b6 | 91 | FALSE, /* pc_relative */ |
d172d4ba NC |
92 | 0, /* bitpos */ |
93 | complain_overflow_dont,/* complain_on_overflow */ | |
94 | bfd_elf_generic_reloc, /* special_function */ | |
95 | "R_DLX_RELOC_16", /* name */ | |
b34976b6 | 96 | TRUE, /* partial_inplace */ |
d172d4ba NC |
97 | 0xffff, /* src_mask */ |
98 | 0xffff, /* dst_mask */ | |
b34976b6 | 99 | FALSE), /* pcrel_offset */ |
d172d4ba | 100 | |
d172d4ba NC |
101 | /* 32 bit relocation. */ |
102 | HOWTO (R_DLX_RELOC_32, /* type */ | |
103 | 0, /* rightshift */ | |
104 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
105 | 32, /* bitsize */ | |
b34976b6 | 106 | FALSE, /* pc_relative */ |
d172d4ba NC |
107 | 0, /* bitpos */ |
108 | complain_overflow_dont,/* complain_on_overflow */ | |
109 | bfd_elf_generic_reloc, /* special_function */ | |
110 | "R_DLX_RELOC_32", /* name */ | |
b34976b6 | 111 | TRUE, /* partial_inplace */ |
d172d4ba NC |
112 | 0xffffffff, /* src_mask */ |
113 | 0xffffffff, /* dst_mask */ | |
b34976b6 | 114 | FALSE), /* pcrel_offset */ |
d172d4ba NC |
115 | |
116 | /* GNU extension to record C++ vtable hierarchy */ | |
117 | HOWTO (R_DLX_GNU_VTINHERIT, /* type */ | |
118 | 0, /* rightshift */ | |
119 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
120 | 0, /* bitsize */ | |
b34976b6 | 121 | FALSE, /* pc_relative */ |
d172d4ba NC |
122 | 0, /* bitpos */ |
123 | complain_overflow_dont,/* complain_on_overflow */ | |
124 | NULL, /* special_function */ | |
125 | "R_DLX_GNU_VTINHERIT", /* name */ | |
b34976b6 | 126 | FALSE, /* partial_inplace */ |
d172d4ba NC |
127 | 0, /* src_mask */ |
128 | 0, /* dst_mask */ | |
b34976b6 | 129 | FALSE), /* pcrel_offset */ |
d172d4ba NC |
130 | |
131 | /* GNU extension to record C++ vtable member usage */ | |
132 | HOWTO (R_DLX_GNU_VTENTRY, /* type */ | |
133 | 0, /* rightshift */ | |
134 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
135 | 0, /* bitsize */ | |
b34976b6 | 136 | FALSE, /* pc_relative */ |
d172d4ba NC |
137 | 0, /* bitpos */ |
138 | complain_overflow_dont,/* complain_on_overflow */ | |
139 | _bfd_elf_rel_vtable_reloc_fn,/* special_function */ | |
140 | "R_DLX_GNU_VTENTRY", /* name */ | |
b34976b6 | 141 | FALSE, /* partial_inplace */ |
d172d4ba NC |
142 | 0, /* src_mask */ |
143 | 0, /* dst_mask */ | |
b34976b6 | 144 | FALSE) /* pcrel_offset */ |
d172d4ba NC |
145 | }; |
146 | ||
147 | /* 16 bit offset for pc-relative branches. */ | |
148 | static reloc_howto_type elf_dlx_gnu_rel16_s2 = | |
149 | HOWTO (R_DLX_RELOC_16_PCREL, /* type */ | |
150 | 0, /* rightshift */ | |
151 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
152 | 16, /* bitsize */ | |
b34976b6 | 153 | TRUE, /* pc_relative */ |
d172d4ba NC |
154 | 0, /* bitpos */ |
155 | complain_overflow_signed, /* complain_on_overflow */ | |
156 | elf32_dlx_relocate16, /* special_function */ | |
157 | "R_DLX_RELOC_16_PCREL",/* name */ | |
b34976b6 | 158 | TRUE, /* partial_inplace */ |
d172d4ba NC |
159 | 0xffff, /* src_mask */ |
160 | 0xffff, /* dst_mask */ | |
b34976b6 | 161 | TRUE); /* pcrel_offset */ |
d172d4ba NC |
162 | |
163 | /* 26 bit offset for pc-relative branches. */ | |
164 | static reloc_howto_type elf_dlx_gnu_rel26_s2 = | |
165 | HOWTO (R_DLX_RELOC_26_PCREL, /* type */ | |
166 | 0, /* rightshift */ | |
167 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
168 | 26, /* bitsize */ | |
b34976b6 | 169 | TRUE, /* pc_relative */ |
d172d4ba NC |
170 | 0, /* bitpos */ |
171 | complain_overflow_dont,/* complain_on_overflow */ | |
172 | elf32_dlx_relocate26, /* special_function */ | |
173 | "R_DLX_RELOC_26_PCREL",/* name */ | |
b34976b6 | 174 | TRUE, /* partial_inplace */ |
d172d4ba NC |
175 | 0xffff, /* src_mask */ |
176 | 0xffff, /* dst_mask */ | |
b34976b6 | 177 | TRUE); /* pcrel_offset */ |
d172d4ba NC |
178 | |
179 | /* High 16 bits of symbol value. */ | |
180 | static reloc_howto_type elf_dlx_reloc_16_hi = | |
181 | HOWTO (R_DLX_RELOC_16_HI, /* type */ | |
182 | 16, /* rightshift */ | |
183 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
184 | 32, /* bitsize */ | |
b34976b6 | 185 | FALSE, /* pc_relative */ |
d172d4ba NC |
186 | 0, /* bitpos */ |
187 | complain_overflow_dont, /* complain_on_overflow */ | |
188 | _bfd_dlx_elf_hi16_reloc,/* special_function */ | |
189 | "R_DLX_RELOC_16_HI", /* name */ | |
b34976b6 | 190 | TRUE, /* partial_inplace */ |
d172d4ba NC |
191 | 0xFFFF, /* src_mask */ |
192 | 0xffff, /* dst_mask */ | |
b34976b6 | 193 | FALSE); /* pcrel_offset */ |
d172d4ba NC |
194 | |
195 | /* Low 16 bits of symbol value. */ | |
196 | static reloc_howto_type elf_dlx_reloc_16_lo = | |
197 | HOWTO (R_DLX_RELOC_16_LO, /* type */ | |
198 | 0, /* rightshift */ | |
199 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
200 | 16, /* bitsize */ | |
b34976b6 | 201 | FALSE, /* pc_relative */ |
d172d4ba NC |
202 | 0, /* bitpos */ |
203 | complain_overflow_dont,/* complain_on_overflow */ | |
204 | bfd_elf_generic_reloc, /* special_function */ | |
205 | "R_DLX_RELOC_16_LO", /* name */ | |
b34976b6 | 206 | TRUE, /* partial_inplace */ |
d172d4ba NC |
207 | 0xffff, /* src_mask */ |
208 | 0xffff, /* dst_mask */ | |
b34976b6 | 209 | FALSE); /* pcrel_offset */ |
d172d4ba NC |
210 | |
211 | ||
4cc11e76 | 212 | /* The gas default behavior is not to preform the %hi modifier so that the |
d172d4ba NC |
213 | GNU assembler can have the lower 16 bits offset placed in the insn, BUT |
214 | we do like the gas to indicate it is %hi reloc type so when we in the link | |
215 | loader phase we can have the corrected hi16 vale replace the buggous lo16 | |
216 | value that was placed there by gas. */ | |
217 | ||
218 | static int skip_dlx_elf_hi16_reloc = 0; | |
219 | ||
220 | int | |
221 | set_dlx_skip_hi16_flag (flag) | |
222 | int flag; | |
223 | { | |
224 | skip_dlx_elf_hi16_reloc = flag; | |
225 | return flag; | |
226 | } | |
227 | ||
228 | static bfd_reloc_status_type | |
229 | _bfd_dlx_elf_hi16_reloc (abfd, reloc_entry, symbol, data, | |
230 | input_section, output_bfd, error_message) | |
231 | bfd *abfd; | |
232 | arelent *reloc_entry; | |
233 | asymbol *symbol; | |
234 | PTR data; | |
235 | asection *input_section; | |
236 | bfd *output_bfd; | |
237 | char **error_message; | |
238 | { | |
239 | bfd_reloc_status_type ret; | |
240 | bfd_vma relocation; | |
241 | ||
242 | /* If the skip flag is set then we simply do the generic relocating, this | |
243 | is more of a hack for dlx gas/gld, so we do not need to do the %hi/%lo | |
244 | fixup like mips gld did. */ | |
d172d4ba NC |
245 | if (skip_dlx_elf_hi16_reloc) |
246 | return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, | |
247 | input_section, output_bfd, error_message); | |
248 | ||
249 | /* If we're relocating, and this an external symbol, we don't want | |
250 | to change anything. */ | |
251 | if (output_bfd != (bfd *) NULL | |
252 | && (symbol->flags & BSF_SECTION_SYM) == 0 | |
253 | && reloc_entry->addend == 0) | |
254 | { | |
255 | reloc_entry->address += input_section->output_offset; | |
256 | return bfd_reloc_ok; | |
257 | } | |
258 | ||
259 | ret = bfd_reloc_ok; | |
260 | ||
261 | if (bfd_is_und_section (symbol->section) | |
262 | && output_bfd == (bfd *) NULL) | |
263 | ret = bfd_reloc_undefined; | |
264 | ||
d172d4ba NC |
265 | relocation = (bfd_is_com_section (symbol->section)) ? 0 : symbol->value; |
266 | relocation += symbol->section->output_section->vma; | |
267 | relocation += symbol->section->output_offset; | |
268 | relocation += reloc_entry->addend; | |
269 | relocation += bfd_get_16 (abfd, (bfd_byte *)data + reloc_entry->address); | |
270 | ||
07515404 | 271 | if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) |
d172d4ba NC |
272 | return bfd_reloc_outofrange; |
273 | ||
d172d4ba NC |
274 | bfd_put_16 (abfd, (short)((relocation >> 16) & 0xFFFF), |
275 | (bfd_byte *)data + reloc_entry->address); | |
276 | ||
277 | return ret; | |
278 | } | |
279 | ||
1049f94e | 280 | /* ELF relocs are against symbols. If we are producing relocatable |
d172d4ba NC |
281 | output, and the reloc is against an external symbol, and nothing |
282 | has given us any additional addend, the resulting reloc will also | |
283 | be against the same symbol. In such a case, we don't want to | |
284 | change anything about the way the reloc is handled, since it will | |
285 | all be done at final link time. Rather than put special case code | |
286 | into bfd_perform_relocation, all the reloc types use this howto | |
287 | function. It just short circuits the reloc if producing | |
1049f94e | 288 | relocatable output against an external symbol. */ |
d172d4ba NC |
289 | |
290 | static bfd_reloc_status_type | |
291 | elf32_dlx_relocate16 (abfd, reloc_entry, symbol, data, | |
292 | input_section, output_bfd, error_message) | |
293 | bfd *abfd; | |
294 | arelent *reloc_entry; | |
295 | asymbol *symbol; | |
296 | PTR data; | |
297 | asection *input_section; | |
298 | bfd *output_bfd; | |
299 | char **error_message ATTRIBUTE_UNUSED; | |
300 | { | |
301 | unsigned long insn, vallo, allignment; | |
302 | int val; | |
303 | ||
304 | /* HACK: I think this first condition is necessary when producing | |
305 | relocatable output. After the end of HACK, the code is identical | |
306 | to bfd_elf_generic_reloc(). I would _guess_ the first change | |
307 | belongs there rather than here. martindo 1998-10-23. */ | |
308 | ||
309 | if (skip_dlx_elf_hi16_reloc) | |
310 | return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, | |
311 | input_section, output_bfd, error_message); | |
312 | ||
313 | /* Check undefined section and undefined symbols */ | |
314 | if (bfd_is_und_section (symbol->section) | |
315 | && output_bfd == (bfd *) NULL) | |
316 | return bfd_reloc_undefined; | |
317 | ||
318 | /* Can not support a long jump to sections other then .text */ | |
319 | if (strcmp (input_section->name, symbol->section->output_section->name) != 0) | |
320 | { | |
321 | fprintf (stderr, | |
322 | "BFD Link Error: branch (PC rel16) to section (%s) not supported\n", | |
323 | symbol->section->output_section->name); | |
324 | return bfd_reloc_undefined; | |
325 | } | |
326 | ||
327 | insn = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address); | |
328 | allignment = 1 << (input_section->output_section->alignment_power - 1); | |
329 | vallo = insn & 0x0000FFFF; | |
330 | ||
331 | if (vallo & 0x8000) | |
332 | vallo = ~(vallo | 0xFFFF0000) + 1; | |
333 | ||
334 | /* vallo points to the vma of next instruction. */ | |
335 | vallo += (((unsigned long)(input_section->output_section->vma + | |
336 | input_section->output_offset) + | |
337 | allignment) & ~allignment); | |
338 | ||
339 | /* val is the displacement (PC relative to next instruction). */ | |
340 | val = (symbol->section->output_offset + | |
341 | symbol->section->output_section->vma + | |
342 | symbol->value) - vallo; | |
d172d4ba NC |
343 | |
344 | if (abs ((int) val) > 0x00007FFF) | |
345 | return bfd_reloc_outofrange; | |
346 | ||
347 | insn = (insn & 0xFFFF0000) | (val & 0x0000FFFF); | |
348 | ||
349 | bfd_put_32 (abfd, insn, | |
350 | (bfd_byte *) data + reloc_entry->address); | |
351 | ||
352 | return bfd_reloc_ok; | |
353 | } | |
354 | ||
355 | static bfd_reloc_status_type | |
356 | elf32_dlx_relocate26 (abfd, reloc_entry, symbol, data, | |
357 | input_section, output_bfd, error_message) | |
358 | bfd *abfd; | |
359 | arelent *reloc_entry; | |
360 | asymbol *symbol; | |
361 | PTR data; | |
362 | asection *input_section; | |
363 | bfd *output_bfd; | |
364 | char **error_message ATTRIBUTE_UNUSED; | |
365 | { | |
366 | unsigned long insn, vallo, allignment; | |
367 | int val; | |
368 | ||
369 | /* HACK: I think this first condition is necessary when producing | |
370 | relocatable output. After the end of HACK, the code is identical | |
371 | to bfd_elf_generic_reloc(). I would _guess_ the first change | |
372 | belongs there rather than here. martindo 1998-10-23. */ | |
373 | ||
374 | if (skip_dlx_elf_hi16_reloc) | |
375 | return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, | |
376 | input_section, output_bfd, error_message); | |
377 | ||
378 | /* Check undefined section and undefined symbols. */ | |
379 | if (bfd_is_und_section (symbol->section) | |
380 | && output_bfd == (bfd *) NULL) | |
381 | return bfd_reloc_undefined; | |
382 | ||
383 | /* Can not support a long jump to sections other then .text */ | |
384 | if (strcmp (input_section->name, symbol->section->output_section->name) != 0) | |
385 | { | |
386 | fprintf (stderr, | |
387 | "BFD Link Error: jump (PC rel26) to section (%s) not supported\n", | |
388 | symbol->section->output_section->name); | |
389 | return bfd_reloc_undefined; | |
390 | } | |
391 | ||
392 | insn = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address); | |
393 | allignment = 1 << (input_section->output_section->alignment_power - 1); | |
394 | vallo = insn & 0x03FFFFFF; | |
395 | ||
396 | if (vallo & 0x03000000) | |
397 | vallo = ~(vallo | 0xFC000000) + 1; | |
398 | ||
399 | /* vallo is the vma for the next instruction. */ | |
400 | vallo += (((unsigned long) (input_section->output_section->vma + | |
401 | input_section->output_offset) + | |
402 | allignment) & ~allignment); | |
403 | ||
404 | /* val is the displacement (PC relative to next instruction). */ | |
405 | val = (symbol->section->output_offset + | |
406 | symbol->section->output_section->vma + symbol->value) | |
407 | - vallo; | |
d172d4ba NC |
408 | |
409 | if (abs ((int) val) > 0x01FFFFFF) | |
410 | return bfd_reloc_outofrange; | |
411 | ||
412 | insn = (insn & 0xFC000000) | (val & 0x03FFFFFF); | |
413 | bfd_put_32 (abfd, insn, | |
414 | (bfd_byte *) data + reloc_entry->address); | |
415 | ||
416 | return bfd_reloc_ok; | |
417 | } | |
418 | ||
419 | /* A mapping from BFD reloc types to DLX ELF reloc types. | |
420 | Stolen from elf32-mips.c. | |
cedb70c5 | 421 | |
d172d4ba NC |
422 | More about this table - for dlx elf relocation we do not really |
423 | need this table, if we have a rtype defined in this table will | |
424 | caused tc_gen_relocate confused and die on us, but if we remove | |
4cc11e76 | 425 | this table it will caused more problem, so for now simple solution |
d172d4ba NC |
426 | is to remove those entries which may cause problem. */ |
427 | struct elf_reloc_map | |
428 | { | |
429 | bfd_reloc_code_real_type bfd_reloc_val; | |
430 | enum elf_dlx_reloc_type elf_reloc_val; | |
431 | }; | |
432 | ||
3f9c735e | 433 | static const struct elf_reloc_map dlx_reloc_map[] = |
d172d4ba NC |
434 | { |
435 | { BFD_RELOC_NONE, R_DLX_NONE }, | |
436 | { BFD_RELOC_16, R_DLX_RELOC_16 }, | |
d172d4ba NC |
437 | { BFD_RELOC_32, R_DLX_RELOC_32 }, |
438 | { BFD_RELOC_DLX_HI16_S, R_DLX_RELOC_16_HI }, | |
439 | { BFD_RELOC_DLX_LO16, R_DLX_RELOC_16_LO }, | |
440 | { BFD_RELOC_VTABLE_INHERIT, R_DLX_GNU_VTINHERIT }, | |
441 | { BFD_RELOC_VTABLE_ENTRY, R_DLX_GNU_VTENTRY } | |
442 | }; | |
443 | ||
444 | ||
445 | /* Look through the relocs for a section during the first phase. | |
446 | Since we don't do .gots or .plts, we just need to consider the | |
447 | virtual table relocs for gc. */ | |
448 | ||
b34976b6 | 449 | static bfd_boolean |
d172d4ba NC |
450 | elf32_dlx_check_relocs (abfd, info, sec, relocs) |
451 | bfd *abfd; | |
452 | struct bfd_link_info *info; | |
453 | asection *sec; | |
454 | const Elf_Internal_Rela *relocs; | |
455 | { | |
456 | Elf_Internal_Shdr *symtab_hdr; | |
457 | struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; | |
458 | const Elf_Internal_Rela *rel; | |
459 | const Elf_Internal_Rela *rel_end; | |
460 | ||
1049f94e | 461 | if (info->relocatable) |
b34976b6 | 462 | return TRUE; |
d172d4ba NC |
463 | |
464 | symtab_hdr = &elf_tdata (abfd)->symtab_hdr; | |
465 | sym_hashes = elf_sym_hashes (abfd); | |
466 | sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym); | |
467 | if (!elf_bad_symtab (abfd)) | |
468 | sym_hashes_end -= symtab_hdr->sh_info; | |
469 | ||
470 | rel_end = relocs + sec->reloc_count; | |
471 | for (rel = relocs; rel < rel_end; rel++) | |
472 | { | |
473 | struct elf_link_hash_entry *h; | |
474 | unsigned long r_symndx; | |
475 | ||
476 | r_symndx = ELF32_R_SYM (rel->r_info); | |
477 | if (r_symndx < symtab_hdr->sh_info) | |
478 | h = NULL; | |
479 | else | |
480 | h = sym_hashes[r_symndx - symtab_hdr->sh_info]; | |
481 | ||
482 | switch (ELF32_R_TYPE (rel->r_info)) | |
483 | { | |
484 | /* This relocation describes the C++ object vtable hierarchy. | |
485 | Reconstruct it for later use during GC. */ | |
486 | case R_DLX_GNU_VTINHERIT: | |
c152c796 | 487 | if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) |
b34976b6 | 488 | return FALSE; |
d172d4ba NC |
489 | break; |
490 | ||
491 | /* This relocation describes which C++ vtable entries are actually | |
492 | used. Record for later use during GC. */ | |
493 | case R_DLX_GNU_VTENTRY: | |
c152c796 | 494 | if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) |
b34976b6 | 495 | return FALSE; |
d172d4ba NC |
496 | break; |
497 | } | |
498 | } | |
499 | ||
b34976b6 | 500 | return TRUE; |
d172d4ba NC |
501 | } |
502 | ||
503 | /* Given a BFD reloc type, return a howto structure. */ | |
504 | ||
505 | static reloc_howto_type * | |
506 | elf32_dlx_reloc_type_lookup (abfd, code) | |
507 | bfd *abfd ATTRIBUTE_UNUSED; | |
508 | bfd_reloc_code_real_type code; | |
509 | { | |
510 | unsigned int i; | |
511 | ||
512 | for (i = 0; i < sizeof (dlx_reloc_map) / sizeof (struct elf_reloc_map); i++) | |
513 | if (dlx_reloc_map[i].bfd_reloc_val == code) | |
514 | return &dlx_elf_howto_table[(int) dlx_reloc_map[i].elf_reloc_val]; | |
515 | ||
516 | switch (code) | |
517 | { | |
518 | default: | |
519 | bfd_set_error (bfd_error_bad_value); | |
520 | return NULL; | |
521 | case BFD_RELOC_16_PCREL_S2: | |
522 | return &elf_dlx_gnu_rel16_s2; | |
523 | case BFD_RELOC_DLX_JMP26: | |
524 | return &elf_dlx_gnu_rel26_s2; | |
525 | case BFD_RELOC_HI16_S: | |
526 | return &elf_dlx_reloc_16_hi; | |
527 | case BFD_RELOC_LO16: | |
528 | return &elf_dlx_reloc_16_lo; | |
529 | } | |
530 | } | |
531 | ||
532 | static reloc_howto_type * | |
533 | dlx_rtype_to_howto (r_type) | |
534 | unsigned int r_type; | |
535 | { | |
536 | switch (r_type) | |
537 | { | |
538 | case R_DLX_RELOC_16_PCREL: | |
539 | return & elf_dlx_gnu_rel16_s2; | |
540 | break; | |
541 | case R_DLX_RELOC_26_PCREL: | |
542 | return & elf_dlx_gnu_rel26_s2; | |
543 | break; | |
544 | case R_DLX_RELOC_16_HI: | |
545 | return & elf_dlx_reloc_16_hi; | |
546 | break; | |
547 | case R_DLX_RELOC_16_LO: | |
548 | return & elf_dlx_reloc_16_lo; | |
549 | break; | |
550 | ||
551 | default: | |
552 | BFD_ASSERT (r_type < (unsigned int) R_DLX_max); | |
553 | return & dlx_elf_howto_table[r_type]; | |
554 | break; | |
555 | } | |
556 | } | |
557 | ||
558 | static void | |
559 | elf32_dlx_info_to_howto (abfd, cache_ptr, dst) | |
560 | bfd * abfd ATTRIBUTE_UNUSED; | |
561 | arelent * cache_ptr ATTRIBUTE_UNUSED; | |
947216bf | 562 | Elf_Internal_Rela * dst ATTRIBUTE_UNUSED; |
d172d4ba NC |
563 | { |
564 | abort (); | |
565 | } | |
566 | ||
567 | static void | |
568 | elf32_dlx_info_to_howto_rel (abfd, cache_ptr, dst) | |
569 | bfd *abfd ATTRIBUTE_UNUSED; | |
570 | arelent *cache_ptr; | |
947216bf | 571 | Elf_Internal_Rela *dst; |
d172d4ba NC |
572 | { |
573 | unsigned int r_type; | |
574 | ||
575 | r_type = ELF32_R_TYPE (dst->r_info); | |
576 | cache_ptr->howto = dlx_rtype_to_howto (r_type); | |
577 | return; | |
578 | } | |
579 | ||
580 | #define TARGET_BIG_SYM bfd_elf32_dlx_big_vec | |
581 | #define TARGET_BIG_NAME "elf32-dlx" | |
582 | #define ELF_ARCH bfd_arch_dlx | |
583 | #define ELF_MACHINE_CODE EM_DLX | |
584 | #define ELF_MAXPAGESIZE 1 /* FIXME: This number is wrong, It should be the page size in bytes. */ | |
585 | ||
586 | #include "elf32-target.h" |