1 |
163 |
khays |
/* Adapteva epiphany specific support for 32-bit ELF
|
2 |
|
|
Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2011
|
3 |
|
|
Free Software Foundation, Inc.
|
4 |
|
|
Contributed by Embecosm on behalf of Adapteva, Inc.
|
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/epiphany.h"
|
28 |
|
|
#include "libiberty.h"
|
29 |
|
|
|
30 |
|
|
/* Struct used to pass miscellaneous paramaters which
|
31 |
|
|
helps to avoid overly long parameter lists. */
|
32 |
|
|
struct misc
|
33 |
|
|
{
|
34 |
|
|
Elf_Internal_Shdr * symtab_hdr;
|
35 |
|
|
Elf_Internal_Rela * irelbase;
|
36 |
|
|
bfd_byte * contents;
|
37 |
|
|
Elf_Internal_Sym * isymbuf;
|
38 |
|
|
};
|
39 |
|
|
|
40 |
|
|
struct epiphany_opcode
|
41 |
|
|
{
|
42 |
|
|
unsigned short opcode;
|
43 |
|
|
unsigned short mask;
|
44 |
|
|
};
|
45 |
|
|
|
46 |
|
|
static bfd_boolean epiphany_relaxed = FALSE;
|
47 |
|
|
|
48 |
|
|
/* Relocation tables. */
|
49 |
|
|
static reloc_howto_type epiphany_elf_howto_table [] =
|
50 |
|
|
{
|
51 |
|
|
#define AHOW(t,rs,s,bs,pr,bp,co,name,sm,dm) \
|
52 |
|
|
HOWTO(t, /* type */ \
|
53 |
|
|
rs, /* rightshift */ \
|
54 |
|
|
s, /* size (0 = byte, 1 = short, 2 = long) */ \
|
55 |
|
|
bs, /* bitsize */ \
|
56 |
|
|
pr, /* pc_relative */ \
|
57 |
|
|
bp, /* bitpos */ \
|
58 |
|
|
co, /* complain_on_overflow */ \
|
59 |
|
|
bfd_elf_generic_reloc,/* special_function */ \
|
60 |
|
|
name, /* name */ \
|
61 |
|
|
FALSE, /* partial_inplace */ \
|
62 |
|
|
sm, /* src_mask */ \
|
63 |
|
|
dm, /* dst_mask */ \
|
64 |
|
|
pr) /* pcrel_offset */
|
65 |
|
|
|
66 |
|
|
/* This reloc does nothing. */
|
67 |
|
|
AHOW (R_EPIPHANY_NONE, 0, 0,32, FALSE, 0, complain_overflow_dont, "R_EPIPHANY_NONE", 0, 0),
|
68 |
|
|
|
69 |
|
|
/* 8 bit absolute (not likely) */
|
70 |
|
|
AHOW (R_EPIPHANY_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_8", 0x000000ff, 0x000000ff),
|
71 |
|
|
/* 16 bit absolute */
|
72 |
|
|
AHOW (R_EPIPHANY_16, 0, 1,16, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_16", 0x0000ffff, 0x00ff1fe0),
|
73 |
|
|
/* A 32 bit absolute relocation. */
|
74 |
|
|
AHOW (R_EPIPHANY_32, 0, 2,32, FALSE, 0, complain_overflow_dont, "R_EPIPHANY_32", 0xffffffff, 0xffffffff),
|
75 |
|
|
|
76 |
|
|
/* 8 bit relative relocation */
|
77 |
|
|
HOWTO ( R_EPIPHANY_8_PCREL, 0, 0, 8, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),
|
78 |
|
|
/* 16 bit relative relocation */
|
79 |
|
|
HOWTO ( R_EPIPHANY_16_PCREL, 0, 1, 16, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),
|
80 |
|
|
/* 32 bit relative relocation */
|
81 |
|
|
HOWTO ( R_EPIPHANY_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),
|
82 |
|
|
|
83 |
|
|
/* 8 bit pc-relative relocation */
|
84 |
|
|
AHOW (R_EPIPHANY_SIMM8, 1, 0, 8, TRUE, 8, complain_overflow_signed, "R_EPIPHANY_SIMM8", 0x000000ff, 0x0000ff00),
|
85 |
|
|
/* 24 bit pc-relative relocation */
|
86 |
|
|
AHOW (R_EPIPHANY_SIMM24, 1, 2,24, TRUE, 8, complain_overflow_signed, "R_EPIPHANY_SIMM24", 0x00ffffff, 0xffffff00),
|
87 |
|
|
|
88 |
|
|
/* %HIGH(EA) */
|
89 |
|
|
AHOW (R_EPIPHANY_HIGH, 0, 2,16, FALSE, 0, complain_overflow_dont, "R_EPIPHANY_HIGH", 0x0ff01fe0, 0x0ff01fe0),
|
90 |
|
|
|
91 |
|
|
/* %LOW(EA) */
|
92 |
|
|
AHOW (R_EPIPHANY_LOW, 0, 2,16, FALSE, 0, complain_overflow_dont, "R_EPIPHANY_LOW", 0x0ff01fe0, 0x0ff01fe0),
|
93 |
|
|
|
94 |
|
|
/* simm11 */
|
95 |
|
|
AHOW (R_EPIPHANY_SIMM11, 0, 2,11, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_SIMM11", 0x00ff0380, 0x00ff0380),
|
96 |
|
|
/* imm12 - sign-magnitude */
|
97 |
|
|
AHOW (R_EPIPHANY_IMM11, 0, 2,11, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_IMM12", 0x00ff0380, 0x00ff0380),
|
98 |
|
|
/* imm8 */
|
99 |
|
|
AHOW (R_EPIPHANY_IMM8, 0, 1, 8, FALSE, 8, complain_overflow_signed, "R_EPIPHANY_IMM8", 0x0000ff00, 0x0000ff00)
|
100 |
|
|
|
101 |
|
|
|
102 |
|
|
};
|
103 |
|
|
#undef AHOW
|
104 |
|
|
|
105 |
|
|
/* Map BFD reloc types to EPIPHANY ELF reloc types. */
|
106 |
|
|
|
107 |
|
|
static reloc_howto_type *
|
108 |
|
|
epiphany_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
|
109 |
|
|
bfd_reloc_code_real_type code)
|
110 |
|
|
{
|
111 |
|
|
/* Note that the epiphany_elf_howto_table is indxed by the R_
|
112 |
|
|
constants. Thus, the order that the howto records appear in the
|
113 |
|
|
table *must* match the order of the relocation types defined in
|
114 |
|
|
include/elf/epiphany.h. */
|
115 |
|
|
|
116 |
|
|
switch (code)
|
117 |
|
|
{
|
118 |
|
|
case BFD_RELOC_NONE:
|
119 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_NONE];
|
120 |
|
|
|
121 |
|
|
case BFD_RELOC_EPIPHANY_SIMM8:
|
122 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM8];
|
123 |
|
|
case BFD_RELOC_EPIPHANY_SIMM24:
|
124 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM24];
|
125 |
|
|
|
126 |
|
|
case BFD_RELOC_8_PCREL:
|
127 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_8_PCREL];
|
128 |
|
|
case BFD_RELOC_16_PCREL:
|
129 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_16_PCREL];
|
130 |
|
|
case BFD_RELOC_32_PCREL:
|
131 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_32_PCREL];
|
132 |
|
|
|
133 |
|
|
case BFD_RELOC_8:
|
134 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_8];
|
135 |
|
|
case BFD_RELOC_16:
|
136 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_16];
|
137 |
|
|
case BFD_RELOC_32:
|
138 |
|
|
return &epiphany_elf_howto_table[ (int) R_EPIPHANY_32];
|
139 |
|
|
|
140 |
|
|
case BFD_RELOC_EPIPHANY_HIGH:
|
141 |
|
|
return & epiphany_elf_howto_table[ (int) R_EPIPHANY_HIGH];
|
142 |
|
|
case BFD_RELOC_EPIPHANY_LOW:
|
143 |
|
|
return & epiphany_elf_howto_table[ (int) R_EPIPHANY_LOW];
|
144 |
|
|
|
145 |
|
|
case BFD_RELOC_EPIPHANY_SIMM11:
|
146 |
|
|
return & epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM11];
|
147 |
|
|
case BFD_RELOC_EPIPHANY_IMM11:
|
148 |
|
|
return & epiphany_elf_howto_table[ (int) R_EPIPHANY_IMM11];
|
149 |
|
|
|
150 |
|
|
case BFD_RELOC_EPIPHANY_IMM8:
|
151 |
|
|
return & epiphany_elf_howto_table[ (int) R_EPIPHANY_IMM8];
|
152 |
|
|
|
153 |
|
|
default:
|
154 |
|
|
/* Pacify gcc -Wall. */
|
155 |
|
|
return NULL;
|
156 |
|
|
}
|
157 |
|
|
return NULL;
|
158 |
|
|
}
|
159 |
|
|
|
160 |
|
|
static reloc_howto_type *
|
161 |
|
|
epiphany_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
|
162 |
|
|
{
|
163 |
|
|
unsigned int i;
|
164 |
|
|
|
165 |
|
|
for (i = 0; i < ARRAY_SIZE (epiphany_elf_howto_table); i++)
|
166 |
|
|
if (epiphany_elf_howto_table[i].name != NULL
|
167 |
|
|
&& strcasecmp (epiphany_elf_howto_table[i].name, r_name) == 0)
|
168 |
|
|
return &epiphany_elf_howto_table[i];
|
169 |
|
|
|
170 |
|
|
return NULL;
|
171 |
|
|
}
|
172 |
|
|
|
173 |
|
|
#define PAGENO(ABSADDR) ((ABSADDR) & 0xFFFFC000)
|
174 |
|
|
#define BASEADDR(SEC) ((SEC)->output_section->vma + (SEC)->output_offset)
|
175 |
|
|
|
176 |
|
|
/* This function handles relaxing for the epiphany.
|
177 |
|
|
Dummy placeholder for future optimizations. */
|
178 |
|
|
|
179 |
|
|
static bfd_boolean
|
180 |
|
|
epiphany_elf_relax_section (bfd *abfd, asection *sec,
|
181 |
|
|
struct bfd_link_info *link_info,
|
182 |
|
|
bfd_boolean *again)
|
183 |
|
|
{
|
184 |
|
|
Elf_Internal_Shdr *symtab_hdr;
|
185 |
|
|
Elf_Internal_Rela *internal_relocs;
|
186 |
|
|
bfd_byte *contents = NULL;
|
187 |
|
|
Elf_Internal_Sym *isymbuf = NULL;
|
188 |
|
|
static asection * first_section = NULL;
|
189 |
|
|
static unsigned long search_addr;
|
190 |
|
|
static unsigned long page_start = 0;
|
191 |
|
|
static unsigned long page_end = 0;
|
192 |
|
|
static unsigned int pass = 0;
|
193 |
|
|
static bfd_boolean new_pass = FALSE;
|
194 |
|
|
static bfd_boolean changed = FALSE;
|
195 |
|
|
struct misc misc ATTRIBUTE_UNUSED;
|
196 |
|
|
asection *stab;
|
197 |
|
|
|
198 |
|
|
/* Assume nothing changes. */
|
199 |
|
|
*again = FALSE;
|
200 |
|
|
|
201 |
|
|
if (first_section == NULL)
|
202 |
|
|
{
|
203 |
|
|
epiphany_relaxed = TRUE;
|
204 |
|
|
first_section = sec;
|
205 |
|
|
}
|
206 |
|
|
|
207 |
|
|
if (first_section == sec)
|
208 |
|
|
{
|
209 |
|
|
pass++;
|
210 |
|
|
new_pass = TRUE;
|
211 |
|
|
}
|
212 |
|
|
|
213 |
|
|
/* We don't have to do anything for a relocatable link,
|
214 |
|
|
if this section does not have relocs, or if this is
|
215 |
|
|
not a code section. */
|
216 |
|
|
if (link_info->relocatable
|
217 |
|
|
|| (sec->flags & SEC_RELOC) == 0
|
218 |
|
|
|| sec->reloc_count == 0
|
219 |
|
|
|| (sec->flags & SEC_CODE) == 0)
|
220 |
|
|
return TRUE;
|
221 |
|
|
|
222 |
|
|
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
|
223 |
|
|
|
224 |
|
|
internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
|
225 |
|
|
link_info->keep_memory);
|
226 |
|
|
if (internal_relocs == NULL)
|
227 |
|
|
goto error_return;
|
228 |
|
|
|
229 |
|
|
/* Make sure the stac.rela stuff gets read in. */
|
230 |
|
|
stab = bfd_get_section_by_name (abfd, ".stab");
|
231 |
|
|
|
232 |
|
|
if (stab)
|
233 |
|
|
{
|
234 |
|
|
/* So stab does exits. */
|
235 |
|
|
Elf_Internal_Rela * irelbase ATTRIBUTE_UNUSED;
|
236 |
|
|
|
237 |
|
|
irelbase = _bfd_elf_link_read_relocs (abfd, stab, NULL, NULL,
|
238 |
|
|
link_info->keep_memory);
|
239 |
|
|
}
|
240 |
|
|
|
241 |
|
|
/* Get section contents cached copy if it exists. */
|
242 |
|
|
if (contents == NULL)
|
243 |
|
|
{
|
244 |
|
|
/* Get cached copy if it exists. */
|
245 |
|
|
if (elf_section_data (sec)->this_hdr.contents != NULL)
|
246 |
|
|
contents = elf_section_data (sec)->this_hdr.contents;
|
247 |
|
|
else
|
248 |
|
|
{
|
249 |
|
|
/* Go get them off disk. */
|
250 |
|
|
if (!bfd_malloc_and_get_section (abfd, sec, &contents))
|
251 |
|
|
goto error_return;
|
252 |
|
|
}
|
253 |
|
|
}
|
254 |
|
|
|
255 |
|
|
/* Read this BFD's symbols cached copy if it exists. */
|
256 |
|
|
if (isymbuf == NULL && symtab_hdr->sh_info != 0)
|
257 |
|
|
{
|
258 |
|
|
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
|
259 |
|
|
if (isymbuf == NULL)
|
260 |
|
|
isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
|
261 |
|
|
symtab_hdr->sh_info, 0,
|
262 |
|
|
NULL, NULL, NULL);
|
263 |
|
|
if (isymbuf == NULL)
|
264 |
|
|
goto error_return;
|
265 |
|
|
}
|
266 |
|
|
|
267 |
|
|
misc.symtab_hdr = symtab_hdr;
|
268 |
|
|
misc.isymbuf = isymbuf;
|
269 |
|
|
misc.irelbase = internal_relocs;
|
270 |
|
|
misc.contents = contents;
|
271 |
|
|
|
272 |
|
|
/* This is where all the relaxation actually get done. */
|
273 |
|
|
if ((pass == 1) || (new_pass && !changed))
|
274 |
|
|
{
|
275 |
|
|
/* On the first pass we simply search for the lowest page that
|
276 |
|
|
we havn't relaxed yet. Note that the pass count is reset
|
277 |
|
|
each time a page is complete in order to move on to the next page.
|
278 |
|
|
If we can't find any more pages then we are finished. */
|
279 |
|
|
if (new_pass)
|
280 |
|
|
{
|
281 |
|
|
pass = 1;
|
282 |
|
|
new_pass = FALSE;
|
283 |
|
|
changed = TRUE; /* Pre-initialize to break out of pass 1. */
|
284 |
|
|
search_addr = 0xFFFFFFFF;
|
285 |
|
|
}
|
286 |
|
|
|
287 |
|
|
if ((BASEADDR (sec) + sec->size < search_addr)
|
288 |
|
|
&& (BASEADDR (sec) + sec->size > page_end))
|
289 |
|
|
{
|
290 |
|
|
if (BASEADDR (sec) <= page_end)
|
291 |
|
|
search_addr = page_end + 1;
|
292 |
|
|
else
|
293 |
|
|
search_addr = BASEADDR (sec);
|
294 |
|
|
|
295 |
|
|
/* Found a page => more work to do. */
|
296 |
|
|
*again = TRUE;
|
297 |
|
|
}
|
298 |
|
|
}
|
299 |
|
|
else
|
300 |
|
|
{
|
301 |
|
|
if (new_pass)
|
302 |
|
|
{
|
303 |
|
|
new_pass = FALSE;
|
304 |
|
|
changed = FALSE;
|
305 |
|
|
page_start = PAGENO (search_addr);
|
306 |
|
|
page_end = page_start | 0x00003FFF;
|
307 |
|
|
}
|
308 |
|
|
|
309 |
|
|
/* Only process sections in range. */
|
310 |
|
|
if ((BASEADDR (sec) + sec->size >= page_start)
|
311 |
|
|
&& (BASEADDR (sec) <= page_end))
|
312 |
|
|
{
|
313 |
|
|
#if 0
|
314 |
|
|
if (!epiphany_elf_relax_section_page (abfd, sec, &changed, &misc,
|
315 |
|
|
page_start, page_end))
|
316 |
|
|
#endif
|
317 |
|
|
return FALSE;
|
318 |
|
|
}
|
319 |
|
|
*again = TRUE;
|
320 |
|
|
}
|
321 |
|
|
|
322 |
|
|
/* Perform some house keeping after relaxing the section. */
|
323 |
|
|
|
324 |
|
|
if (isymbuf != NULL
|
325 |
|
|
&& symtab_hdr->contents != (unsigned char *) isymbuf)
|
326 |
|
|
{
|
327 |
|
|
if (! link_info->keep_memory)
|
328 |
|
|
free (isymbuf);
|
329 |
|
|
else
|
330 |
|
|
symtab_hdr->contents = (unsigned char *) isymbuf;
|
331 |
|
|
}
|
332 |
|
|
|
333 |
|
|
if (contents != NULL
|
334 |
|
|
&& elf_section_data (sec)->this_hdr.contents != contents)
|
335 |
|
|
{
|
336 |
|
|
if (! link_info->keep_memory)
|
337 |
|
|
free (contents);
|
338 |
|
|
else
|
339 |
|
|
{
|
340 |
|
|
/* Cache the section contents for elf_link_input_bfd. */
|
341 |
|
|
elf_section_data (sec)->this_hdr.contents = contents;
|
342 |
|
|
}
|
343 |
|
|
}
|
344 |
|
|
|
345 |
|
|
if (internal_relocs != NULL
|
346 |
|
|
&& elf_section_data (sec)->relocs != internal_relocs)
|
347 |
|
|
free (internal_relocs);
|
348 |
|
|
|
349 |
|
|
return TRUE;
|
350 |
|
|
|
351 |
|
|
error_return:
|
352 |
|
|
if (isymbuf != NULL
|
353 |
|
|
&& symtab_hdr->contents != (unsigned char *) isymbuf)
|
354 |
|
|
free (isymbuf);
|
355 |
|
|
if (contents != NULL
|
356 |
|
|
&& elf_section_data (sec)->this_hdr.contents != contents)
|
357 |
|
|
free (contents);
|
358 |
|
|
if (internal_relocs != NULL
|
359 |
|
|
&& elf_section_data (sec)->relocs != internal_relocs)
|
360 |
|
|
free (internal_relocs);
|
361 |
|
|
return FALSE;
|
362 |
|
|
}
|
363 |
|
|
|
364 |
|
|
/* Set the howto pointer for a EPIPHANY ELF reloc. */
|
365 |
|
|
|
366 |
|
|
static void
|
367 |
|
|
epiphany_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
|
368 |
|
|
arelent * cache_ptr,
|
369 |
|
|
Elf_Internal_Rela * dst)
|
370 |
|
|
{
|
371 |
|
|
unsigned int r_type;
|
372 |
|
|
|
373 |
|
|
r_type = ELF32_R_TYPE (dst->r_info);
|
374 |
|
|
cache_ptr->howto = & epiphany_elf_howto_table [r_type];
|
375 |
|
|
}
|
376 |
|
|
|
377 |
|
|
/* Perform a single relocation.
|
378 |
|
|
By default we use the standard BFD routines. */
|
379 |
|
|
|
380 |
|
|
static bfd_reloc_status_type
|
381 |
|
|
epiphany_final_link_relocate (reloc_howto_type * howto,
|
382 |
|
|
bfd * input_bfd,
|
383 |
|
|
asection * input_section,
|
384 |
|
|
bfd_byte * contents,
|
385 |
|
|
Elf_Internal_Rela * rel,
|
386 |
|
|
bfd_vma relocation)
|
387 |
|
|
{
|
388 |
|
|
switch (howto->type)
|
389 |
|
|
{
|
390 |
|
|
/* Handle 16 bit immediates. */
|
391 |
|
|
case R_EPIPHANY_HIGH:
|
392 |
|
|
relocation += rel->r_addend;
|
393 |
|
|
relocation >>= 16;
|
394 |
|
|
goto common;
|
395 |
|
|
|
396 |
|
|
case R_EPIPHANY_LOW:
|
397 |
|
|
relocation += rel->r_addend;
|
398 |
|
|
common:
|
399 |
|
|
relocation = ((relocation & 0xff00L) << 12)
|
400 |
|
|
| ((relocation & 0x00ffL) << 5);
|
401 |
|
|
/* Sanity check the address. */
|
402 |
|
|
if (rel->r_offset > bfd_get_section_limit (input_bfd, input_section))
|
403 |
|
|
return bfd_reloc_outofrange;
|
404 |
|
|
|
405 |
|
|
return _bfd_relocate_contents (howto, input_bfd, relocation,
|
406 |
|
|
contents + rel->r_offset);
|
407 |
|
|
|
408 |
|
|
case R_EPIPHANY_SIMM11:
|
409 |
|
|
relocation += rel->r_addend;
|
410 |
|
|
/* Check signed overflow. */
|
411 |
|
|
if ((int)relocation > 1023 || (int)relocation < -1024)
|
412 |
|
|
return bfd_reloc_outofrange;
|
413 |
|
|
goto disp11;
|
414 |
|
|
|
415 |
|
|
case R_EPIPHANY_IMM11:
|
416 |
|
|
relocation += rel->r_addend;
|
417 |
|
|
if ((unsigned int) relocation > 0x7ff)
|
418 |
|
|
return bfd_reloc_outofrange;
|
419 |
|
|
disp11:
|
420 |
|
|
relocation = ((relocation & 7) << 5)
|
421 |
|
|
|| ((relocation & 0x7f8 ) << 13);
|
422 |
|
|
return _bfd_relocate_contents (howto, input_bfd, relocation,
|
423 |
|
|
contents + rel->r_offset);
|
424 |
|
|
|
425 |
|
|
/* Pass others through. */
|
426 |
|
|
default:
|
427 |
|
|
break;
|
428 |
|
|
}
|
429 |
|
|
|
430 |
|
|
/* Only install relocation if above tests did not disqualify it. */
|
431 |
|
|
return _bfd_final_link_relocate (howto, input_bfd, input_section,
|
432 |
|
|
contents, rel->r_offset,
|
433 |
|
|
relocation, rel->r_addend);
|
434 |
|
|
}
|
435 |
|
|
|
436 |
|
|
/* Relocate an EPIPHANY ELF section.
|
437 |
|
|
|
438 |
|
|
The RELOCATE_SECTION function is called by the new ELF backend linker
|
439 |
|
|
to handle the relocations for a section.
|
440 |
|
|
|
441 |
|
|
The relocs are always passed as Rela structures; if the section
|
442 |
|
|
actually uses Rel structures, the r_addend field will always be
|
443 |
|
|
zero.
|
444 |
|
|
|
445 |
|
|
This function is responsible for adjusting the section contents as
|
446 |
|
|
necessary, and (if using Rela relocs and generating a relocatable
|
447 |
|
|
output file) adjusting the reloc addend as necessary.
|
448 |
|
|
|
449 |
|
|
This function does not have to worry about setting the reloc
|
450 |
|
|
address or the reloc symbol index.
|
451 |
|
|
|
452 |
|
|
LOCAL_SYMS is a pointer to the swapped in local symbols.
|
453 |
|
|
|
454 |
|
|
LOCAL_SECTIONS is an array giving the section in the input file
|
455 |
|
|
corresponding to the st_shndx field of each local symbol.
|
456 |
|
|
|
457 |
|
|
The global hash table entry for the global symbols can be found
|
458 |
|
|
via elf_sym_hashes (input_bfd).
|
459 |
|
|
|
460 |
|
|
When generating relocatable output, this function must handle
|
461 |
|
|
STB_LOCAL/STT_SECTION symbols specially. The output symbol is
|
462 |
|
|
going to be the section symbol corresponding to the output
|
463 |
|
|
section, which means that the addend must be adjusted
|
464 |
|
|
accordingly. */
|
465 |
|
|
|
466 |
|
|
static bfd_boolean
|
467 |
|
|
epiphany_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
|
468 |
|
|
struct bfd_link_info *info,
|
469 |
|
|
bfd *input_bfd,
|
470 |
|
|
asection *input_section,
|
471 |
|
|
bfd_byte *contents,
|
472 |
|
|
Elf_Internal_Rela *relocs,
|
473 |
|
|
Elf_Internal_Sym *local_syms,
|
474 |
|
|
asection **local_sections)
|
475 |
|
|
{
|
476 |
|
|
Elf_Internal_Shdr *symtab_hdr;
|
477 |
|
|
struct elf_link_hash_entry **sym_hashes;
|
478 |
|
|
Elf_Internal_Rela *rel;
|
479 |
|
|
Elf_Internal_Rela *relend;
|
480 |
|
|
|
481 |
|
|
symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
|
482 |
|
|
sym_hashes = elf_sym_hashes (input_bfd);
|
483 |
|
|
relend = relocs + input_section->reloc_count;
|
484 |
|
|
|
485 |
|
|
for (rel = relocs; rel < relend; rel ++)
|
486 |
|
|
{
|
487 |
|
|
reloc_howto_type * howto;
|
488 |
|
|
unsigned long r_symndx;
|
489 |
|
|
Elf_Internal_Sym * sym;
|
490 |
|
|
asection * sec;
|
491 |
|
|
struct elf_link_hash_entry * h;
|
492 |
|
|
bfd_vma relocation;
|
493 |
|
|
bfd_reloc_status_type r;
|
494 |
|
|
const char * name = NULL;
|
495 |
|
|
int r_type ATTRIBUTE_UNUSED;
|
496 |
|
|
|
497 |
|
|
r_type = ELF32_R_TYPE (rel->r_info);
|
498 |
|
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
499 |
|
|
howto = epiphany_elf_howto_table + ELF32_R_TYPE (rel->r_info);
|
500 |
|
|
h = NULL;
|
501 |
|
|
sym = NULL;
|
502 |
|
|
sec = NULL;
|
503 |
|
|
|
504 |
|
|
if (r_symndx < symtab_hdr->sh_info)
|
505 |
|
|
{
|
506 |
|
|
sym = local_syms + r_symndx;
|
507 |
|
|
sec = local_sections [r_symndx];
|
508 |
|
|
relocation = BASEADDR (sec) + sym->st_value;
|
509 |
|
|
|
510 |
|
|
name = bfd_elf_string_from_elf_section
|
511 |
|
|
(input_bfd, symtab_hdr->sh_link, sym->st_name);
|
512 |
|
|
name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
|
513 |
|
|
}
|
514 |
|
|
else
|
515 |
|
|
{
|
516 |
|
|
bfd_boolean warned ATTRIBUTE_UNUSED;
|
517 |
|
|
bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
|
518 |
|
|
|
519 |
|
|
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
|
520 |
|
|
r_symndx, symtab_hdr, sym_hashes,
|
521 |
|
|
h, sec, relocation,
|
522 |
|
|
unresolved_reloc, warned);
|
523 |
|
|
|
524 |
|
|
name = h->root.root.string;
|
525 |
|
|
}
|
526 |
|
|
|
527 |
|
|
if (sec != NULL && elf_discarded_section (sec))
|
528 |
|
|
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
|
529 |
|
|
rel, relend, howto, contents);
|
530 |
|
|
|
531 |
|
|
if (info->relocatable)
|
532 |
|
|
continue;
|
533 |
|
|
|
534 |
|
|
/* Finally, the sole EPIPHANY-specific part. */
|
535 |
|
|
r = epiphany_final_link_relocate (howto, input_bfd, input_section,
|
536 |
|
|
contents, rel, relocation);
|
537 |
|
|
|
538 |
|
|
if (r != bfd_reloc_ok)
|
539 |
|
|
{
|
540 |
|
|
const char * msg = NULL;
|
541 |
|
|
|
542 |
|
|
switch (r)
|
543 |
|
|
{
|
544 |
|
|
case bfd_reloc_overflow:
|
545 |
|
|
r = info->callbacks->reloc_overflow
|
546 |
|
|
(info, (h ? &h->root : NULL), name, howto->name,
|
547 |
|
|
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
|
548 |
|
|
break;
|
549 |
|
|
|
550 |
|
|
case bfd_reloc_undefined:
|
551 |
|
|
r = info->callbacks->undefined_symbol
|
552 |
|
|
(info, name, input_bfd, input_section, rel->r_offset, TRUE);
|
553 |
|
|
break;
|
554 |
|
|
|
555 |
|
|
case bfd_reloc_outofrange:
|
556 |
|
|
msg = _("internal error: out of range error");
|
557 |
|
|
break;
|
558 |
|
|
|
559 |
|
|
/* This is how epiphany_final_link_relocate tells us of a
|
560 |
|
|
non-kosher reference between insn & data address spaces. */
|
561 |
|
|
case bfd_reloc_notsupported:
|
562 |
|
|
if (sym != NULL) /* Only if it's not an unresolved symbol. */
|
563 |
|
|
msg = _("unsupported relocation between data/insn address spaces");
|
564 |
|
|
break;
|
565 |
|
|
|
566 |
|
|
case bfd_reloc_dangerous:
|
567 |
|
|
msg = _("internal error: dangerous relocation");
|
568 |
|
|
break;
|
569 |
|
|
|
570 |
|
|
default:
|
571 |
|
|
msg = _("internal error: unknown error");
|
572 |
|
|
break;
|
573 |
|
|
}
|
574 |
|
|
|
575 |
|
|
if (msg)
|
576 |
|
|
r = info->callbacks->warning
|
577 |
|
|
(info, msg, name, input_bfd, input_section, rel->r_offset);
|
578 |
|
|
|
579 |
|
|
if (! r)
|
580 |
|
|
return FALSE;
|
581 |
|
|
}
|
582 |
|
|
}
|
583 |
|
|
|
584 |
|
|
return TRUE;
|
585 |
|
|
}
|
586 |
|
|
|
587 |
|
|
/* We only have a little-endian target. */
|
588 |
|
|
#define TARGET_LITTLE_SYM bfd_elf32_epiphany_vec
|
589 |
|
|
#define TARGET_LITTLE_NAME "elf32-epiphany"
|
590 |
|
|
|
591 |
|
|
#define ELF_ARCH bfd_arch_epiphany
|
592 |
|
|
#define ELF_MACHINE_CODE EM_ADAPTEVA_EPIPHANY
|
593 |
|
|
|
594 |
|
|
#define ELF_MAXPAGESIZE 0x8000 /* No pages on the EPIPHANY. */
|
595 |
|
|
|
596 |
|
|
#define elf_info_to_howto_rel NULL
|
597 |
|
|
#define elf_info_to_howto epiphany_info_to_howto_rela
|
598 |
|
|
|
599 |
|
|
#define elf_backend_can_gc_sections 1
|
600 |
|
|
#define elf_backend_rela_normal 1
|
601 |
|
|
#define elf_backend_relocate_section epiphany_elf_relocate_section
|
602 |
|
|
|
603 |
|
|
#define elf_symbol_leading_char '_'
|
604 |
|
|
#define bfd_elf32_bfd_reloc_type_lookup epiphany_reloc_type_lookup
|
605 |
|
|
#define bfd_elf32_bfd_reloc_name_lookup epiphany_reloc_name_lookup
|
606 |
|
|
#define bfd_elf32_bfd_relax_section epiphany_elf_relax_section
|
607 |
|
|
|
608 |
|
|
#include "elf32-target.h"
|