1 |
227 |
jeremybenn |
/* D10V-specific support for 32-bit ELF
|
2 |
|
|
Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
|
3 |
|
|
2007 Free Software Foundation, Inc.
|
4 |
|
|
Contributed by Martin Hunt (hunt@cygnus.com).
|
5 |
|
|
|
6 |
|
|
This file is part of BFD, the Binary File Descriptor library.
|
7 |
|
|
|
8 |
|
|
This program is free software; you can redistribute it and/or modify
|
9 |
|
|
it under the terms of the GNU General Public License as published by
|
10 |
|
|
the Free Software Foundation; either version 3 of the License, or
|
11 |
|
|
(at your option) any later version.
|
12 |
|
|
|
13 |
|
|
This program is distributed in the hope that it will be useful,
|
14 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
15 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
16 |
|
|
GNU General Public License for more details.
|
17 |
|
|
|
18 |
|
|
You should have received a copy of the GNU General Public License
|
19 |
|
|
along with this program; if not, write to the Free Software
|
20 |
|
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
21 |
|
|
MA 02110-1301, USA. */
|
22 |
|
|
|
23 |
|
|
#include "sysdep.h"
|
24 |
|
|
#include "bfd.h"
|
25 |
|
|
#include "libbfd.h"
|
26 |
|
|
#include "elf-bfd.h"
|
27 |
|
|
#include "elf/d10v.h"
|
28 |
|
|
|
29 |
|
|
/* Use REL instead of RELA to save space. */
|
30 |
|
|
#define USE_REL 1
|
31 |
|
|
|
32 |
|
|
static reloc_howto_type elf_d10v_howto_table[] =
|
33 |
|
|
{
|
34 |
|
|
/* This reloc does nothing. */
|
35 |
|
|
HOWTO (R_D10V_NONE, /* Type. */
|
36 |
|
|
0, /* Rightshift. */
|
37 |
|
|
2, /* Size (0 = byte, 1 = short, 2 = long). */
|
38 |
|
|
32, /* Bitsize. */
|
39 |
|
|
FALSE, /* PC_relative. */
|
40 |
|
|
0, /* Bitpos. */
|
41 |
|
|
complain_overflow_dont,/* Complain_on_overflow. */
|
42 |
|
|
bfd_elf_generic_reloc, /* Special_function. */
|
43 |
|
|
"R_D10V_NONE", /* Name. */
|
44 |
|
|
FALSE, /* Partial_inplace. */
|
45 |
|
|
0, /* Src_mask. */
|
46 |
|
|
0, /* Dst_mask. */
|
47 |
|
|
FALSE), /* PCrel_offset. */
|
48 |
|
|
|
49 |
|
|
/* An PC Relative 10-bit relocation, shifted by 2, right container. */
|
50 |
|
|
HOWTO (R_D10V_10_PCREL_R, /* Type. */
|
51 |
|
|
2, /* Rightshift. */
|
52 |
|
|
2, /* Size (0 = byte, 1 = short, 2 = long). */
|
53 |
|
|
8, /* Bitsize. */
|
54 |
|
|
TRUE, /* PC_relative. */
|
55 |
|
|
0, /* Bitpos. */
|
56 |
|
|
complain_overflow_signed, /* Complain_on_overflow. */
|
57 |
|
|
bfd_elf_generic_reloc, /* Special_function. */
|
58 |
|
|
"R_D10V_10_PCREL_R", /* Name. */
|
59 |
|
|
FALSE, /* Partial_inplace. */
|
60 |
|
|
0xff, /* Src_mask. */
|
61 |
|
|
0xff, /* Dst_mask. */
|
62 |
|
|
TRUE), /* PCrel_offset. */
|
63 |
|
|
|
64 |
|
|
/* An PC Relative 10-bit relocation, shifted by 2, left container. */
|
65 |
|
|
HOWTO (R_D10V_10_PCREL_L, /* Type. */
|
66 |
|
|
2, /* Rightshift. */
|
67 |
|
|
2, /* Size (0 = byte, 1 = short, 2 = long). */
|
68 |
|
|
8, /* Bitsize. */
|
69 |
|
|
TRUE, /* PC_relative. */
|
70 |
|
|
15, /* Bitpos. */
|
71 |
|
|
complain_overflow_signed, /* Complain_on_overflow. */
|
72 |
|
|
bfd_elf_generic_reloc, /* Special_function. */
|
73 |
|
|
"R_D10V_10_PCREL_L", /* Name. */
|
74 |
|
|
FALSE, /* Partial_inplace. */
|
75 |
|
|
0x07f8000, /* Src_mask. */
|
76 |
|
|
0x07f8000, /* Dst_mask. */
|
77 |
|
|
TRUE), /* PCrel_offset. */
|
78 |
|
|
|
79 |
|
|
/* A 16 bit absolute relocation. */
|
80 |
|
|
HOWTO (R_D10V_16, /* Type. */
|
81 |
|
|
0, /* Rightshift. */
|
82 |
|
|
1, /* Size (0 = byte, 1 = short, 2 = long). */
|
83 |
|
|
16, /* Bitsize. */
|
84 |
|
|
FALSE, /* PC_relative. */
|
85 |
|
|
0, /* Bitpos. */
|
86 |
|
|
complain_overflow_dont,/* Complain_on_overflow. */
|
87 |
|
|
bfd_elf_generic_reloc, /* Special_function. */
|
88 |
|
|
"R_D10V_16", /* Name. */
|
89 |
|
|
FALSE, /* Partial_inplace. */
|
90 |
|
|
0xffff, /* Src_mask. */
|
91 |
|
|
0xffff, /* Dst_mask. */
|
92 |
|
|
FALSE), /* PCrel_offset. */
|
93 |
|
|
|
94 |
|
|
/* An 18 bit absolute relocation, right shifted 2. */
|
95 |
|
|
HOWTO (R_D10V_18, /* Type. */
|
96 |
|
|
2, /* Rightshift. */
|
97 |
|
|
1, /* Size (0 = byte, 1 = short, 2 = long). */
|
98 |
|
|
16, /* Bitsize. */
|
99 |
|
|
FALSE, /* PC_relative. */
|
100 |
|
|
0, /* Bitpos. */
|
101 |
|
|
complain_overflow_dont, /* Complain_on_overflow. */
|
102 |
|
|
bfd_elf_generic_reloc, /* Special_function. */
|
103 |
|
|
"R_D10V_18", /* Name. */
|
104 |
|
|
FALSE, /* Partial_inplace. */
|
105 |
|
|
0xffff, /* Src_mask. */
|
106 |
|
|
0xffff, /* Dst_mask. */
|
107 |
|
|
FALSE), /* PCrel_offset. */
|
108 |
|
|
|
109 |
|
|
/* A relative 18 bit relocation, right shifted by 2. */
|
110 |
|
|
HOWTO (R_D10V_18_PCREL, /* Type. */
|
111 |
|
|
2, /* Rightshift. */
|
112 |
|
|
2, /* Size (0 = byte, 1 = short, 2 = long). */
|
113 |
|
|
16, /* Bitsize. */
|
114 |
|
|
TRUE, /* PC_relative. */
|
115 |
|
|
0, /* Bitpos. */
|
116 |
|
|
complain_overflow_signed, /* Complain_on_overflow. */
|
117 |
|
|
bfd_elf_generic_reloc, /* Special_function. */
|
118 |
|
|
"R_D10V_18_PCREL", /* Name. */
|
119 |
|
|
FALSE, /* Partial_inplace. */
|
120 |
|
|
0xffff, /* Src_mask. */
|
121 |
|
|
0xffff, /* Dst_mask. */
|
122 |
|
|
TRUE), /* PCrel_offset. */
|
123 |
|
|
|
124 |
|
|
/* A 32 bit absolute relocation. */
|
125 |
|
|
HOWTO (R_D10V_32, /* Type. */
|
126 |
|
|
0, /* Rightshift. */
|
127 |
|
|
2, /* Size (0 = byte, 1 = short, 2 = long). */
|
128 |
|
|
32, /* Bitsize. */
|
129 |
|
|
FALSE, /* PC_relative. */
|
130 |
|
|
0, /* Bitpos. */
|
131 |
|
|
complain_overflow_dont,/* Complain_on_overflow. */
|
132 |
|
|
bfd_elf_generic_reloc, /* Special_function. */
|
133 |
|
|
"R_D10V_32", /* Name. */
|
134 |
|
|
FALSE, /* Partial_inplace. */
|
135 |
|
|
0xffffffff, /* Src_mask. */
|
136 |
|
|
0xffffffff, /* Dst_mask. */
|
137 |
|
|
FALSE), /* PCrel_offset. */
|
138 |
|
|
|
139 |
|
|
/* GNU extension to record C++ vtable hierarchy. */
|
140 |
|
|
HOWTO (R_D10V_GNU_VTINHERIT, /* Type. */
|
141 |
|
|
0, /* Rightshift. */
|
142 |
|
|
2, /* Size (0 = byte, 1 = short, 2 = long). */
|
143 |
|
|
0, /* Bitsize. */
|
144 |
|
|
FALSE, /* PC_relative. */
|
145 |
|
|
0, /* Bitpos. */
|
146 |
|
|
complain_overflow_dont,/* Complain_on_overflow. */
|
147 |
|
|
NULL, /* Special_function. */
|
148 |
|
|
"R_D10V_GNU_VTINHERIT",/* Name. */
|
149 |
|
|
FALSE, /* Partial_inplace. */
|
150 |
|
|
0, /* Src_mask. */
|
151 |
|
|
0, /* Dst_mask. */
|
152 |
|
|
FALSE), /* PCrel_offset. */
|
153 |
|
|
|
154 |
|
|
/* GNU extension to record C++ vtable member usage. */
|
155 |
|
|
HOWTO (R_D10V_GNU_VTENTRY, /* Type. */
|
156 |
|
|
0, /* Rightshift. */
|
157 |
|
|
2, /* Size (0 = byte, 1 = short, 2 = long). */
|
158 |
|
|
0, /* Bitsize. */
|
159 |
|
|
FALSE, /* PC_relative. */
|
160 |
|
|
0, /* Bitpos. */
|
161 |
|
|
complain_overflow_dont,/* Complain_on_overflow. */
|
162 |
|
|
_bfd_elf_rel_vtable_reloc_fn, /* Special_function. */
|
163 |
|
|
"R_D10V_GNU_VTENTRY", /* Name. */
|
164 |
|
|
FALSE, /* Partial_inplace. */
|
165 |
|
|
0, /* Src_mask. */
|
166 |
|
|
0, /* Dst_mask. */
|
167 |
|
|
FALSE), /* PCrel_offset. */
|
168 |
|
|
};
|
169 |
|
|
|
170 |
|
|
/* Map BFD reloc types to D10V ELF reloc types. */
|
171 |
|
|
|
172 |
|
|
struct d10v_reloc_map
|
173 |
|
|
{
|
174 |
|
|
bfd_reloc_code_real_type bfd_reloc_val;
|
175 |
|
|
unsigned char elf_reloc_val;
|
176 |
|
|
};
|
177 |
|
|
|
178 |
|
|
static const struct d10v_reloc_map d10v_reloc_map[] =
|
179 |
|
|
{
|
180 |
|
|
{ BFD_RELOC_NONE, R_D10V_NONE, },
|
181 |
|
|
{ BFD_RELOC_D10V_10_PCREL_R, R_D10V_10_PCREL_R },
|
182 |
|
|
{ BFD_RELOC_D10V_10_PCREL_L, R_D10V_10_PCREL_L },
|
183 |
|
|
{ BFD_RELOC_16, R_D10V_16 },
|
184 |
|
|
{ BFD_RELOC_D10V_18, R_D10V_18 },
|
185 |
|
|
{ BFD_RELOC_D10V_18_PCREL, R_D10V_18_PCREL },
|
186 |
|
|
{ BFD_RELOC_32, R_D10V_32 },
|
187 |
|
|
{ BFD_RELOC_VTABLE_INHERIT, R_D10V_GNU_VTINHERIT },
|
188 |
|
|
{ BFD_RELOC_VTABLE_ENTRY, R_D10V_GNU_VTENTRY },
|
189 |
|
|
};
|
190 |
|
|
|
191 |
|
|
static reloc_howto_type *
|
192 |
|
|
bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
|
193 |
|
|
bfd_reloc_code_real_type code)
|
194 |
|
|
{
|
195 |
|
|
unsigned int i;
|
196 |
|
|
|
197 |
|
|
for (i = 0;
|
198 |
|
|
i < sizeof (d10v_reloc_map) / sizeof (struct d10v_reloc_map);
|
199 |
|
|
i++)
|
200 |
|
|
if (d10v_reloc_map[i].bfd_reloc_val == code)
|
201 |
|
|
return &elf_d10v_howto_table[d10v_reloc_map[i].elf_reloc_val];
|
202 |
|
|
|
203 |
|
|
return NULL;
|
204 |
|
|
}
|
205 |
|
|
|
206 |
|
|
static reloc_howto_type *
|
207 |
|
|
bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
|
208 |
|
|
const char *r_name)
|
209 |
|
|
{
|
210 |
|
|
unsigned int i;
|
211 |
|
|
|
212 |
|
|
for (i = 0;
|
213 |
|
|
i < sizeof (elf_d10v_howto_table) / sizeof (elf_d10v_howto_table[0]);
|
214 |
|
|
i++)
|
215 |
|
|
if (elf_d10v_howto_table[i].name != NULL
|
216 |
|
|
&& strcasecmp (elf_d10v_howto_table[i].name, r_name) == 0)
|
217 |
|
|
return &elf_d10v_howto_table[i];
|
218 |
|
|
|
219 |
|
|
return NULL;
|
220 |
|
|
}
|
221 |
|
|
|
222 |
|
|
/* Set the howto pointer for an D10V ELF reloc. */
|
223 |
|
|
|
224 |
|
|
static void
|
225 |
|
|
d10v_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
|
226 |
|
|
arelent *cache_ptr,
|
227 |
|
|
Elf_Internal_Rela *dst)
|
228 |
|
|
{
|
229 |
|
|
unsigned int r_type;
|
230 |
|
|
|
231 |
|
|
r_type = ELF32_R_TYPE (dst->r_info);
|
232 |
|
|
BFD_ASSERT (r_type < (unsigned int) R_D10V_max);
|
233 |
|
|
cache_ptr->howto = &elf_d10v_howto_table[r_type];
|
234 |
|
|
}
|
235 |
|
|
|
236 |
|
|
static asection *
|
237 |
|
|
elf32_d10v_gc_mark_hook (asection *sec,
|
238 |
|
|
struct bfd_link_info *info,
|
239 |
|
|
Elf_Internal_Rela *rel,
|
240 |
|
|
struct elf_link_hash_entry *h,
|
241 |
|
|
Elf_Internal_Sym *sym)
|
242 |
|
|
{
|
243 |
|
|
if (h != NULL)
|
244 |
|
|
switch (ELF32_R_TYPE (rel->r_info))
|
245 |
|
|
{
|
246 |
|
|
case R_D10V_GNU_VTINHERIT:
|
247 |
|
|
case R_D10V_GNU_VTENTRY:
|
248 |
|
|
return NULL;
|
249 |
|
|
}
|
250 |
|
|
|
251 |
|
|
return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
|
252 |
|
|
}
|
253 |
|
|
|
254 |
|
|
/* Look through the relocs for a section during the first phase.
|
255 |
|
|
Since we don't do .gots or .plts, we just need to consider the
|
256 |
|
|
virtual table relocs for gc. */
|
257 |
|
|
|
258 |
|
|
static bfd_boolean
|
259 |
|
|
elf32_d10v_check_relocs (bfd *abfd,
|
260 |
|
|
struct bfd_link_info *info,
|
261 |
|
|
asection *sec,
|
262 |
|
|
const Elf_Internal_Rela *relocs)
|
263 |
|
|
{
|
264 |
|
|
Elf_Internal_Shdr *symtab_hdr;
|
265 |
|
|
struct elf_link_hash_entry **sym_hashes;
|
266 |
|
|
const Elf_Internal_Rela *rel;
|
267 |
|
|
const Elf_Internal_Rela *rel_end;
|
268 |
|
|
|
269 |
|
|
if (info->relocatable)
|
270 |
|
|
return TRUE;
|
271 |
|
|
|
272 |
|
|
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
|
273 |
|
|
sym_hashes = elf_sym_hashes (abfd);
|
274 |
|
|
|
275 |
|
|
rel_end = relocs + sec->reloc_count;
|
276 |
|
|
for (rel = relocs; rel < rel_end; rel++)
|
277 |
|
|
{
|
278 |
|
|
struct elf_link_hash_entry *h;
|
279 |
|
|
unsigned long r_symndx;
|
280 |
|
|
|
281 |
|
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
282 |
|
|
if (r_symndx < symtab_hdr->sh_info)
|
283 |
|
|
h = NULL;
|
284 |
|
|
else
|
285 |
|
|
{
|
286 |
|
|
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
|
287 |
|
|
while (h->root.type == bfd_link_hash_indirect
|
288 |
|
|
|| h->root.type == bfd_link_hash_warning)
|
289 |
|
|
h = (struct elf_link_hash_entry *) h->root.u.i.link;
|
290 |
|
|
}
|
291 |
|
|
|
292 |
|
|
switch (ELF32_R_TYPE (rel->r_info))
|
293 |
|
|
{
|
294 |
|
|
/* This relocation describes the C++ object vtable hierarchy.
|
295 |
|
|
Reconstruct it for later use during GC. */
|
296 |
|
|
case R_D10V_GNU_VTINHERIT:
|
297 |
|
|
if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
|
298 |
|
|
return FALSE;
|
299 |
|
|
break;
|
300 |
|
|
|
301 |
|
|
/* This relocation describes which C++ vtable entries are actually
|
302 |
|
|
used. Record for later use during GC. */
|
303 |
|
|
case R_D10V_GNU_VTENTRY:
|
304 |
|
|
BFD_ASSERT (h != NULL);
|
305 |
|
|
if (h != NULL
|
306 |
|
|
&& !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
|
307 |
|
|
return FALSE;
|
308 |
|
|
break;
|
309 |
|
|
}
|
310 |
|
|
}
|
311 |
|
|
|
312 |
|
|
return TRUE;
|
313 |
|
|
}
|
314 |
|
|
|
315 |
|
|
static bfd_vma
|
316 |
|
|
extract_rel_addend (bfd *abfd,
|
317 |
|
|
bfd_byte *where,
|
318 |
|
|
reloc_howto_type *howto)
|
319 |
|
|
{
|
320 |
|
|
bfd_vma insn, val;
|
321 |
|
|
|
322 |
|
|
switch (howto->size)
|
323 |
|
|
{
|
324 |
|
|
case 0:
|
325 |
|
|
insn = bfd_get_8 (abfd, where);
|
326 |
|
|
break;
|
327 |
|
|
case 1:
|
328 |
|
|
insn = bfd_get_16 (abfd, where);
|
329 |
|
|
break;
|
330 |
|
|
case 2:
|
331 |
|
|
insn = bfd_get_32 (abfd, where);
|
332 |
|
|
break;
|
333 |
|
|
default:
|
334 |
|
|
abort ();
|
335 |
|
|
}
|
336 |
|
|
|
337 |
|
|
val = (insn & howto->dst_mask) >> howto->bitpos << howto->rightshift;
|
338 |
|
|
/* We should really be testing for signed addends here, but we don't
|
339 |
|
|
have that info directly in the howto. */
|
340 |
|
|
if (howto->pc_relative)
|
341 |
|
|
{
|
342 |
|
|
bfd_vma sign;
|
343 |
|
|
sign = howto->dst_mask & (~howto->dst_mask >> 1 | ~(-(bfd_vma) 1 >> 1));
|
344 |
|
|
sign = sign >> howto->bitpos << howto->rightshift;
|
345 |
|
|
val = (val ^ sign) - sign;
|
346 |
|
|
}
|
347 |
|
|
return val;
|
348 |
|
|
}
|
349 |
|
|
|
350 |
|
|
static void
|
351 |
|
|
insert_rel_addend (bfd *abfd,
|
352 |
|
|
bfd_byte *where,
|
353 |
|
|
reloc_howto_type *howto,
|
354 |
|
|
bfd_vma addend)
|
355 |
|
|
{
|
356 |
|
|
bfd_vma insn;
|
357 |
|
|
|
358 |
|
|
addend = (addend >> howto->rightshift << howto->bitpos) & howto->dst_mask;
|
359 |
|
|
insn = ~howto->dst_mask;
|
360 |
|
|
switch (howto->size)
|
361 |
|
|
{
|
362 |
|
|
case 0:
|
363 |
|
|
insn &= bfd_get_8 (abfd, where);
|
364 |
|
|
insn |= addend;
|
365 |
|
|
bfd_put_8 (abfd, insn, where);
|
366 |
|
|
break;
|
367 |
|
|
case 1:
|
368 |
|
|
insn &= bfd_get_16 (abfd, where);
|
369 |
|
|
insn |= addend;
|
370 |
|
|
bfd_put_16 (abfd, insn, where);
|
371 |
|
|
break;
|
372 |
|
|
case 2:
|
373 |
|
|
insn &= bfd_get_32 (abfd, where);
|
374 |
|
|
insn |= addend;
|
375 |
|
|
bfd_put_32 (abfd, insn, where);
|
376 |
|
|
break;
|
377 |
|
|
default:
|
378 |
|
|
abort ();
|
379 |
|
|
}
|
380 |
|
|
}
|
381 |
|
|
|
382 |
|
|
/* Relocate a D10V ELF section. */
|
383 |
|
|
|
384 |
|
|
static bfd_boolean
|
385 |
|
|
elf32_d10v_relocate_section (bfd *output_bfd,
|
386 |
|
|
struct bfd_link_info *info,
|
387 |
|
|
bfd *input_bfd,
|
388 |
|
|
asection *input_section,
|
389 |
|
|
bfd_byte *contents,
|
390 |
|
|
Elf_Internal_Rela *relocs,
|
391 |
|
|
Elf_Internal_Sym *local_syms,
|
392 |
|
|
asection **local_sections)
|
393 |
|
|
{
|
394 |
|
|
Elf_Internal_Shdr *symtab_hdr;
|
395 |
|
|
struct elf_link_hash_entry **sym_hashes;
|
396 |
|
|
Elf_Internal_Rela *rel, *relend;
|
397 |
|
|
const char *name;
|
398 |
|
|
|
399 |
|
|
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
|
400 |
|
|
sym_hashes = elf_sym_hashes (input_bfd);
|
401 |
|
|
|
402 |
|
|
rel = relocs;
|
403 |
|
|
relend = relocs + input_section->reloc_count;
|
404 |
|
|
for (; rel < relend; rel++)
|
405 |
|
|
{
|
406 |
|
|
int r_type;
|
407 |
|
|
reloc_howto_type *howto;
|
408 |
|
|
unsigned long r_symndx;
|
409 |
|
|
Elf_Internal_Sym *sym;
|
410 |
|
|
asection *sec;
|
411 |
|
|
struct elf_link_hash_entry *h;
|
412 |
|
|
bfd_vma relocation;
|
413 |
|
|
bfd_reloc_status_type r;
|
414 |
|
|
|
415 |
|
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
416 |
|
|
r_type = ELF32_R_TYPE (rel->r_info);
|
417 |
|
|
|
418 |
|
|
if (r_type == R_D10V_GNU_VTENTRY
|
419 |
|
|
|| r_type == R_D10V_GNU_VTINHERIT)
|
420 |
|
|
continue;
|
421 |
|
|
|
422 |
|
|
howto = elf_d10v_howto_table + r_type;
|
423 |
|
|
h = NULL;
|
424 |
|
|
sym = NULL;
|
425 |
|
|
sec = NULL;
|
426 |
|
|
if (r_symndx < symtab_hdr->sh_info)
|
427 |
|
|
{
|
428 |
|
|
sym = local_syms + r_symndx;
|
429 |
|
|
sec = local_sections[r_symndx];
|
430 |
|
|
relocation = (sec->output_section->vma
|
431 |
|
|
+ sec->output_offset
|
432 |
|
|
+ sym->st_value);
|
433 |
|
|
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
|
434 |
|
|
&& ((sec->flags & SEC_MERGE) != 0
|
435 |
|
|
|| (info->relocatable
|
436 |
|
|
&& sec->output_offset != 0)))
|
437 |
|
|
{
|
438 |
|
|
bfd_vma addend;
|
439 |
|
|
bfd_byte *where = contents + rel->r_offset;
|
440 |
|
|
|
441 |
|
|
addend = extract_rel_addend (input_bfd, where, howto);
|
442 |
|
|
|
443 |
|
|
if (info->relocatable)
|
444 |
|
|
addend += sec->output_offset;
|
445 |
|
|
else
|
446 |
|
|
{
|
447 |
|
|
asection *msec = sec;
|
448 |
|
|
addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
|
449 |
|
|
addend);
|
450 |
|
|
addend -= relocation;
|
451 |
|
|
addend += msec->output_section->vma + msec->output_offset;
|
452 |
|
|
}
|
453 |
|
|
insert_rel_addend (input_bfd, where, howto, addend);
|
454 |
|
|
}
|
455 |
|
|
}
|
456 |
|
|
else
|
457 |
|
|
{
|
458 |
|
|
bfd_boolean unresolved_reloc, warned;
|
459 |
|
|
|
460 |
|
|
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
|
461 |
|
|
r_symndx, symtab_hdr, sym_hashes,
|
462 |
|
|
h, sec, relocation,
|
463 |
|
|
unresolved_reloc, warned);
|
464 |
|
|
}
|
465 |
|
|
|
466 |
|
|
if (sec != NULL && elf_discarded_section (sec))
|
467 |
|
|
{
|
468 |
|
|
/* For relocs against symbols from removed linkonce sections,
|
469 |
|
|
or sections discarded by a linker script, we just want the
|
470 |
|
|
section contents zeroed. Avoid any special processing. */
|
471 |
|
|
_bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
|
472 |
|
|
rel->r_info = 0;
|
473 |
|
|
rel->r_addend = 0;
|
474 |
|
|
continue;
|
475 |
|
|
}
|
476 |
|
|
|
477 |
|
|
if (info->relocatable)
|
478 |
|
|
continue;
|
479 |
|
|
|
480 |
|
|
if (h != NULL)
|
481 |
|
|
name = h->root.root.string;
|
482 |
|
|
else
|
483 |
|
|
{
|
484 |
|
|
name = (bfd_elf_string_from_elf_section
|
485 |
|
|
(input_bfd, symtab_hdr->sh_link, sym->st_name));
|
486 |
|
|
if (name == NULL || *name == '\0')
|
487 |
|
|
name = bfd_section_name (input_bfd, sec);
|
488 |
|
|
}
|
489 |
|
|
|
490 |
|
|
r = _bfd_final_link_relocate (howto, input_bfd, input_section,
|
491 |
|
|
contents, rel->r_offset,
|
492 |
|
|
relocation, (bfd_vma) 0);
|
493 |
|
|
|
494 |
|
|
if (r != bfd_reloc_ok)
|
495 |
|
|
{
|
496 |
|
|
const char * msg = (const char *) 0;
|
497 |
|
|
|
498 |
|
|
switch (r)
|
499 |
|
|
{
|
500 |
|
|
case bfd_reloc_overflow:
|
501 |
|
|
if (!((*info->callbacks->reloc_overflow)
|
502 |
|
|
(info, (h ? &h->root : NULL), name, howto->name,
|
503 |
|
|
(bfd_vma) 0, input_bfd, input_section,
|
504 |
|
|
rel->r_offset)))
|
505 |
|
|
return FALSE;
|
506 |
|
|
break;
|
507 |
|
|
|
508 |
|
|
case bfd_reloc_undefined:
|
509 |
|
|
if (!((*info->callbacks->undefined_symbol)
|
510 |
|
|
(info, name, input_bfd, input_section,
|
511 |
|
|
rel->r_offset, TRUE)))
|
512 |
|
|
return FALSE;
|
513 |
|
|
break;
|
514 |
|
|
|
515 |
|
|
case bfd_reloc_outofrange:
|
516 |
|
|
msg = _("internal error: out of range error");
|
517 |
|
|
goto common_error;
|
518 |
|
|
|
519 |
|
|
case bfd_reloc_notsupported:
|
520 |
|
|
msg = _("internal error: unsupported relocation error");
|
521 |
|
|
goto common_error;
|
522 |
|
|
|
523 |
|
|
case bfd_reloc_dangerous:
|
524 |
|
|
msg = _("internal error: dangerous error");
|
525 |
|
|
goto common_error;
|
526 |
|
|
|
527 |
|
|
default:
|
528 |
|
|
msg = _("internal error: unknown error");
|
529 |
|
|
/* fall through */
|
530 |
|
|
|
531 |
|
|
common_error:
|
532 |
|
|
if (!((*info->callbacks->warning)
|
533 |
|
|
(info, msg, name, input_bfd, input_section,
|
534 |
|
|
rel->r_offset)))
|
535 |
|
|
return FALSE;
|
536 |
|
|
break;
|
537 |
|
|
}
|
538 |
|
|
}
|
539 |
|
|
}
|
540 |
|
|
|
541 |
|
|
return TRUE;
|
542 |
|
|
}
|
543 |
|
|
#define ELF_ARCH bfd_arch_d10v
|
544 |
|
|
#define ELF_MACHINE_CODE EM_D10V
|
545 |
|
|
#define ELF_MACHINE_ALT1 EM_CYGNUS_D10V
|
546 |
|
|
#define ELF_MAXPAGESIZE 0x1000
|
547 |
|
|
|
548 |
|
|
#define TARGET_BIG_SYM bfd_elf32_d10v_vec
|
549 |
|
|
#define TARGET_BIG_NAME "elf32-d10v"
|
550 |
|
|
|
551 |
|
|
#define elf_info_to_howto 0
|
552 |
|
|
#define elf_info_to_howto_rel d10v_info_to_howto_rel
|
553 |
|
|
#define elf_backend_object_p 0
|
554 |
|
|
#define elf_backend_final_write_processing 0
|
555 |
|
|
#define elf_backend_gc_mark_hook elf32_d10v_gc_mark_hook
|
556 |
|
|
#define elf_backend_check_relocs elf32_d10v_check_relocs
|
557 |
|
|
#define elf_backend_relocate_section elf32_d10v_relocate_section
|
558 |
|
|
#define elf_backend_can_gc_sections 1
|
559 |
|
|
|
560 |
|
|
#include "elf32-target.h"
|