projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elf.c (assign_file_positions_for_load_sections): Ensure bss
[deliverable/binutils-gdb.git] / bfd / elf32-i860.c
CommitLineData
0e5136c6 1/* Intel i860 specific support for 32-bit ELF.
ab96bf03 2 Copyright 1993, 1995, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
b491616a 3 Free Software Foundation, Inc.
9d751335 4
0e5136c6 5 Full i860 support contributed by Jason Eckhardt <jle@cygnus.com>.
252b5132
RH		 6
7This file is part of BFD, the Binary File Descriptor library.
8
9This program is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2 of the License, or
12(at your option) any later version.
13
14This program is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with this program; if not, write to the Free Software
3e110533 21Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
252b5132 22
252b5132 23#include "sysdep.h"
3db64b00 24#include "bfd.h"
252b5132
RH		 25#include "libbfd.h"
26#include "elf-bfd.h"
0e5136c6
JE		 27#include "elf/i860.h"
28
32d920dd 29/* special_function for R_860_PC26 relocation. */
d539b3aa
CG		 30static bfd_reloc_status_type
31i860_howto_pc26_reloc (bfd *abfd ATTRIBUTE_UNUSED,
32 arelent *reloc_entry,
33 asymbol *symbol,
34 void *data ATTRIBUTE_UNUSED,
35 asection *input_section,
36 bfd *output_bfd,
37 char **error_message ATTRIBUTE_UNUSED)
38{
1c0881dd
CG		 39 bfd_vma insn;
40 bfd_vma relocation;
41 bfd_byte *addr;
42
d539b3aa
CG		 43 if (output_bfd != NULL
44 && (symbol->flags & BSF_SECTION_SYM) == 0
45 && (! reloc_entry->howto->partial_inplace
46 || reloc_entry->addend == 0))
47 {
48 reloc_entry->address += input_section->output_offset;
49 return bfd_reloc_ok;
50 }
51
1c0881dd
CG		 52 /* Used elf32-mips.c as an example. */
53 if (bfd_is_und_section (symbol->section)
54 && output_bfd == (bfd *) NULL)
55 return bfd_reloc_undefined;
56
57 if (bfd_is_com_section (symbol->section))
58 relocation = 0;
59 else
60 relocation = symbol->value;
61
62 relocation += symbol->section->output_section->vma;
63 relocation += symbol->section->output_offset;
64 relocation += reloc_entry->addend;
65
07515404 66 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1c0881dd
CG		 67 return bfd_reloc_outofrange;
68
69 /* Adjust for PC-relative relocation. */
70 relocation -= (input_section->output_section->vma
71 + input_section->output_offset
72 + reloc_entry->address
73 + 4);
74
75 /* Check for target out of range. */
76 if ((bfd_signed_vma)relocation > (0x3ffffff << 2)
77 || (bfd_signed_vma)relocation < (-0x4000000 << 2))
78 return bfd_reloc_outofrange;
79
80 addr = (bfd_byte *) data + reloc_entry->address;
81 insn = bfd_get_32 (abfd, addr);
82
83 relocation >>= reloc_entry->howto->rightshift;
84 insn = (insn & ~reloc_entry->howto->dst_mask)
85 | (relocation & reloc_entry->howto->dst_mask);
86
87 bfd_put_32 (abfd, (bfd_vma) insn, addr);
88
89 return bfd_reloc_ok;
d539b3aa
CG		 90}
91
92/* special_function for R_860_PC16 relocation. */
93static bfd_reloc_status_type
94i860_howto_pc16_reloc (bfd *abfd,
95 arelent *reloc_entry,
96 asymbol *symbol,
97 void *data,
98 asection *input_section,
99 bfd *output_bfd,
100 char **error_message ATTRIBUTE_UNUSED)
101{
102 bfd_vma insn;
103 bfd_vma relocation;
104 bfd_byte *addr;
105
106 if (output_bfd != NULL
107 && (symbol->flags & BSF_SECTION_SYM) == 0
108 && (! reloc_entry->howto->partial_inplace
109 || reloc_entry->addend == 0))
110 {
111 reloc_entry->address += input_section->output_offset;
112 return bfd_reloc_ok;
113 }
114
115 /* Used elf32-mips.c as an example. */
116 if (bfd_is_und_section (symbol->section)
117 && output_bfd == (bfd *) NULL)
118 return bfd_reloc_undefined;
119
120 if (bfd_is_com_section (symbol->section))
121 relocation = 0;
122 else
123 relocation = symbol->value;
124
125 relocation += symbol->section->output_section->vma;
126 relocation += symbol->section->output_offset;
127 relocation += reloc_entry->addend;
128
07515404 129 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
d539b3aa
CG		 130 return bfd_reloc_outofrange;
131
132 /* Adjust for PC-relative relocation. */
133 relocation -= (input_section->output_section->vma
134 + input_section->output_offset
135 + reloc_entry->address
136 + 4);
137
138 /* Check for target out of range. */
139 if ((bfd_signed_vma)relocation > (0x7fff << 2)
140 || (bfd_signed_vma)relocation < (-0x8000 << 2))
141 return bfd_reloc_outofrange;
142
143 addr = (bfd_byte *) data + reloc_entry->address;
144 insn = bfd_get_32 (abfd, addr);
145
146 relocation >>= reloc_entry->howto->rightshift;
147 relocation = (((relocation & 0xf800) << 5) | (relocation & 0x7ff))
148 & reloc_entry->howto->dst_mask;
149 insn = (insn & ~reloc_entry->howto->dst_mask) | relocation;
150
151 bfd_put_32 (abfd, (bfd_vma) insn, addr);
152
153 return bfd_reloc_ok;
154}
155
156/* special_function for R_860_HIGHADJ relocation. */
157static bfd_reloc_status_type
158i860_howto_highadj_reloc (bfd *abfd,
159 arelent *reloc_entry,
160 asymbol *symbol,
161 void *data,
162 asection *input_section,
163 bfd *output_bfd,
164 char **error_message ATTRIBUTE_UNUSED)
165{
166 bfd_vma insn;
167 bfd_vma relocation;
168 bfd_byte *addr;
169
170 if (output_bfd != NULL
171 && (symbol->flags & BSF_SECTION_SYM) == 0
172 && (! reloc_entry->howto->partial_inplace
173 || reloc_entry->addend == 0))
174 {
175 reloc_entry->address += input_section->output_offset;
176 return bfd_reloc_ok;
177 }
178
179 /* Used elf32-mips.c as an example. */
180 if (bfd_is_und_section (symbol->section)
181 && output_bfd == (bfd *) NULL)
182 return bfd_reloc_undefined;
183
184 if (bfd_is_com_section (symbol->section))
185 relocation = 0;
186 else
187 relocation = symbol->value;
188
189 relocation += symbol->section->output_section->vma;
190 relocation += symbol->section->output_offset;
191 relocation += reloc_entry->addend;
192 relocation += 0x8000;
193
07515404 194 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
d539b3aa
CG		 195 return bfd_reloc_outofrange;
196
197 addr = (bfd_byte *) data + reloc_entry->address;
198 insn = bfd_get_32 (abfd, addr);
199
200 relocation = ((relocation >> 16) & 0xffff);
201
202 insn = (insn & 0xffff0000) | relocation;
203
204 bfd_put_32 (abfd, (bfd_vma) insn, addr);
205
206 return bfd_reloc_ok;
207}
208
209/* special_function for R_860_SPLITn relocations. */
210static bfd_reloc_status_type
211i860_howto_splitn_reloc (bfd *abfd,
212 arelent *reloc_entry,
213 asymbol *symbol,
214 void *data,
215 asection *input_section,
216 bfd *output_bfd,
217 char **error_message ATTRIBUTE_UNUSED)
218{
219 bfd_vma insn;
220 bfd_vma relocation;
221 bfd_byte *addr;
222
223 if (output_bfd != NULL
224 && (symbol->flags & BSF_SECTION_SYM) == 0
225 && (! reloc_entry->howto->partial_inplace
226 || reloc_entry->addend == 0))
227 {
228 reloc_entry->address += input_section->output_offset;
229 return bfd_reloc_ok;
230 }
231
232 /* Used elf32-mips.c as an example. */
233 if (bfd_is_und_section (symbol->section)
234 && output_bfd == (bfd *) NULL)
235 return bfd_reloc_undefined;
236
237 if (bfd_is_com_section (symbol->section))
238 relocation = 0;
239 else
240 relocation = symbol->value;
241
242 relocation += symbol->section->output_section->vma;
243 relocation += symbol->section->output_offset;
244 relocation += reloc_entry->addend;
245
07515404 246 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
d539b3aa
CG		 247 return bfd_reloc_outofrange;
248
249 addr = (bfd_byte *) data + reloc_entry->address;
250 insn = bfd_get_32 (abfd, addr);
251
252 relocation = (((relocation & 0xf800) << 5) | (relocation & 0x7ff))
253 & reloc_entry->howto->dst_mask;
254 insn = (insn & ~reloc_entry->howto->dst_mask) | relocation;
255
256 bfd_put_32 (abfd, (bfd_vma) insn, addr);
257
258 return bfd_reloc_ok;
259}
de24da47 260
0e5136c6
JE		 261/* This howto table is preliminary. */
262static reloc_howto_type elf32_i860_howto_table [] =
263{
264 /* This relocation does nothing. */
265 HOWTO (R_860_NONE, /* type */
266 0, /* rightshift */
267 2, /* size (0 = byte, 1 = short, 2 = long) */
268 32, /* bitsize */
b34976b6 269 FALSE, /* pc_relative */
0e5136c6
JE		 270 0, /* bitpos */
271 complain_overflow_bitfield, /* complain_on_overflow */
272 bfd_elf_generic_reloc, /* special_function */
273 "R_860_NONE", /* name */
b34976b6 274 FALSE, /* partial_inplace */
0e5136c6
JE		 275 0, /* src_mask */
276 0, /* dst_mask */
b34976b6 277 FALSE), /* pcrel_offset */
0e5136c6
JE		 278
279 /* A 32-bit absolute relocation. */
280 HOWTO (R_860_32, /* type */
281 0, /* rightshift */
282 2, /* size (0 = byte, 1 = short, 2 = long) */
283 32, /* bitsize */
b34976b6 284 FALSE, /* pc_relative */
0e5136c6
JE		 285 0, /* bitpos */
286 complain_overflow_bitfield, /* complain_on_overflow */
287 bfd_elf_generic_reloc, /* special_function */
288 "R_860_32", /* name */
b34976b6 289 FALSE, /* partial_inplace */
0e5136c6
JE		 290 0xffffffff, /* src_mask */
291 0xffffffff, /* dst_mask */
b34976b6 292 FALSE), /* pcrel_offset */
0e5136c6
JE		 293
294 HOWTO (R_860_COPY, /* type */
295 0, /* rightshift */
296 2, /* size (0 = byte, 1 = short, 2 = long) */
297 32, /* bitsize */
b34976b6 298 FALSE, /* pc_relative */
0e5136c6
JE		 299 0, /* bitpos */
300 complain_overflow_bitfield, /* complain_on_overflow */
301 bfd_elf_generic_reloc, /* special_function */
302 "R_860_COPY", /* name */
b34976b6 303 TRUE, /* partial_inplace */
0e5136c6
JE		 304 0xffffffff, /* src_mask */
305 0xffffffff, /* dst_mask */
b34976b6 306 FALSE), /* pcrel_offset */
0e5136c6
JE		 307
308 HOWTO (R_860_GLOB_DAT, /* type */
309 0, /* rightshift */
310 2, /* size (0 = byte, 1 = short, 2 = long) */
311 32, /* bitsize */
b34976b6 312 FALSE, /* pc_relative */
0e5136c6
JE		 313 0, /* bitpos */
314 complain_overflow_bitfield, /* complain_on_overflow */
315 bfd_elf_generic_reloc, /* special_function */
316 "R_860_GLOB_DAT", /* name */
b34976b6 317 TRUE, /* partial_inplace */
0e5136c6
JE		 318 0xffffffff, /* src_mask */
319 0xffffffff, /* dst_mask */
b34976b6 320 FALSE), /* pcrel_offset */
0e5136c6
JE		 321
322 HOWTO (R_860_JUMP_SLOT, /* type */
323 0, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 32, /* bitsize */
b34976b6 326 FALSE, /* pc_relative */
0e5136c6
JE		 327 0, /* bitpos */
328 complain_overflow_bitfield, /* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_860_JUMP_SLOT", /* name */
b34976b6 331 TRUE, /* partial_inplace */
0e5136c6
JE		 332 0xffffffff, /* src_mask */
333 0xffffffff, /* dst_mask */
b34976b6 334 FALSE), /* pcrel_offset */
0e5136c6
JE		 335
336 HOWTO (R_860_RELATIVE, /* type */
337 0, /* rightshift */
338 2, /* size (0 = byte, 1 = short, 2 = long) */
339 32, /* bitsize */
b34976b6 340 FALSE, /* pc_relative */
0e5136c6
JE		 341 0, /* bitpos */
342 complain_overflow_bitfield, /* complain_on_overflow */
343 bfd_elf_generic_reloc, /* special_function */
344 "R_860_RELATIVE", /* name */
b34976b6 345 TRUE, /* partial_inplace */
0e5136c6
JE		 346 0xffffffff, /* src_mask */
347 0xffffffff, /* dst_mask */
b34976b6 348 FALSE), /* pcrel_offset */
0e5136c6
JE		 349
350 /* A 26-bit PC-relative relocation. */
351 HOWTO (R_860_PC26, /* type */
fdeafce7 352 2, /* rightshift */
0e5136c6
JE		 353 2, /* size (0 = byte, 1 = short, 2 = long) */
354 26, /* bitsize */
b34976b6 355 TRUE, /* pc_relative */
0e5136c6
JE		 356 0, /* bitpos */
357 complain_overflow_bitfield, /* complain_on_overflow */
d539b3aa 358 i860_howto_pc26_reloc, /* special_function */
0e5136c6 359 "R_860_PC26", /* name */
b34976b6 360 FALSE, /* partial_inplace */
0e5136c6
JE		 361 0x3ffffff, /* src_mask */
362 0x3ffffff, /* dst_mask */
b34976b6 363 TRUE), /* pcrel_offset */
0e5136c6
JE		 364
365 HOWTO (R_860_PLT26, /* type */
366 0, /* rightshift */
367 2, /* size (0 = byte, 1 = short, 2 = long) */
368 26, /* bitsize */
b34976b6 369 TRUE, /* pc_relative */
0e5136c6
JE		 370 0, /* bitpos */
371 complain_overflow_bitfield, /* complain_on_overflow */
372 bfd_elf_generic_reloc, /* special_function */
373 "R_860_PLT26", /* name */
b34976b6 374 TRUE, /* partial_inplace */
0e5136c6
JE		 375 0xffffffff, /* src_mask */
376 0xffffffff, /* dst_mask */
b34976b6 377 TRUE), /* pcrel_offset */
0e5136c6
JE		 378
379 /* A 16-bit PC-relative relocation. */
380 HOWTO (R_860_PC16, /* type */
fdeafce7 381 2, /* rightshift */
0e5136c6
JE		 382 2, /* size (0 = byte, 1 = short, 2 = long) */
383 16, /* bitsize */
b34976b6 384 TRUE, /* pc_relative */
0e5136c6
JE		 385 0, /* bitpos */
386 complain_overflow_bitfield, /* complain_on_overflow */
d539b3aa 387 i860_howto_pc16_reloc, /* special_function */
0e5136c6 388 "R_860_PC16", /* name */
b34976b6 389 FALSE, /* partial_inplace */
305d537e
JE		 390 0x1f07ff, /* src_mask */
391 0x1f07ff, /* dst_mask */
b34976b6 392 TRUE), /* pcrel_offset */
0e5136c6
JE		 393
394 HOWTO (R_860_LOW0, /* type */
395 0, /* rightshift */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
397 16, /* bitsize */
b34976b6 398 FALSE, /* pc_relative */
0e5136c6
JE		 399 0, /* bitpos */
400 complain_overflow_dont, /* complain_on_overflow */
401 bfd_elf_generic_reloc, /* special_function */
402 "R_860_LOW0", /* name */
b34976b6 403 FALSE, /* partial_inplace */
0e5136c6
JE		 404 0xffff, /* src_mask */
405 0xffff, /* dst_mask */
b34976b6 406 FALSE), /* pcrel_offset */
0e5136c6
JE		 407
408 HOWTO (R_860_SPLIT0, /* type */
409 0, /* rightshift */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
411 16, /* bitsize */
b34976b6 412 FALSE, /* pc_relative */
0e5136c6
JE		 413 0, /* bitpos */
414 complain_overflow_dont, /* complain_on_overflow */
d539b3aa 415 i860_howto_splitn_reloc, /* special_function */
0e5136c6 416 "R_860_SPLIT0", /* name */
b34976b6 417 FALSE, /* partial_inplace */
0e5136c6
JE		 418 0x1f07ff, /* src_mask */
419 0x1f07ff, /* dst_mask */
b34976b6 420 FALSE), /* pcrel_offset */
0e5136c6
JE		 421
422 HOWTO (R_860_LOW1, /* type */
423 0, /* rightshift */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
425 16, /* bitsize */
b34976b6 426 FALSE, /* pc_relative */
0e5136c6
JE		 427 0, /* bitpos */
428 complain_overflow_dont, /* complain_on_overflow */
429 bfd_elf_generic_reloc, /* special_function */
430 "R_860_LOW1", /* name */
b34976b6 431 FALSE, /* partial_inplace */
0e5136c6
JE		 432 0xfffe, /* src_mask */
433 0xfffe, /* dst_mask */
b34976b6 434 FALSE), /* pcrel_offset */
0e5136c6
JE		 435
436 HOWTO (R_860_SPLIT1, /* type */
437 0, /* rightshift */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
439 16, /* bitsize */
b34976b6 440 FALSE, /* pc_relative */
0e5136c6
JE		 441 0, /* bitpos */
442 complain_overflow_dont, /* complain_on_overflow */
d539b3aa 443 i860_howto_splitn_reloc, /* special_function */
0e5136c6 444 "R_860_SPLIT1", /* name */
b34976b6 445 FALSE, /* partial_inplace */
305d537e
JE		 446 0x1f07fe, /* src_mask */
447 0x1f07fe, /* dst_mask */
b34976b6 448 FALSE), /* pcrel_offset */
0e5136c6
JE		 449
450 HOWTO (R_860_LOW2, /* type */
451 0, /* rightshift */
452 2, /* size (0 = byte, 1 = short, 2 = long) */
453 16, /* bitsize */
b34976b6 454 FALSE, /* pc_relative */
0e5136c6
JE		 455 0, /* bitpos */
456 complain_overflow_dont, /* complain_on_overflow */
457 bfd_elf_generic_reloc, /* special_function */
458 "R_860_LOW2", /* name */
b34976b6 459 FALSE, /* partial_inplace */
0e5136c6
JE		 460 0xfffc, /* src_mask */
461 0xfffc, /* dst_mask */
b34976b6 462 FALSE), /* pcrel_offset */
0e5136c6
JE		 463
464 HOWTO (R_860_SPLIT2, /* type */
465 0, /* rightshift */
466 2, /* size (0 = byte, 1 = short, 2 = long) */
467 16, /* bitsize */
b34976b6 468 FALSE, /* pc_relative */
0e5136c6
JE		 469 0, /* bitpos */
470 complain_overflow_dont, /* complain_on_overflow */
d539b3aa 471 i860_howto_splitn_reloc, /* special_function */
0e5136c6 472 "R_860_SPLIT2", /* name */
b34976b6 473 FALSE, /* partial_inplace */
305d537e
JE		 474 0x1f07fc, /* src_mask */
475 0x1f07fc, /* dst_mask */
b34976b6 476 FALSE), /* pcrel_offset */
0e5136c6
JE		 477
478 HOWTO (R_860_LOW3, /* type */
479 0, /* rightshift */
480 2, /* size (0 = byte, 1 = short, 2 = long) */
481 16, /* bitsize */
b34976b6 482 FALSE, /* pc_relative */
0e5136c6
JE		 483 0, /* bitpos */
484 complain_overflow_dont, /* complain_on_overflow */
485 bfd_elf_generic_reloc, /* special_function */
486 "R_860_LOW3", /* name */
b34976b6 487 FALSE, /* partial_inplace */
0e5136c6
JE		 488 0xfff8, /* src_mask */
489 0xfff8, /* dst_mask */
b34976b6 490 FALSE), /* pcrel_offset */
0e5136c6
JE		 491
492 HOWTO (R_860_LOGOT0, /* type */
493 0, /* rightshift */
494 2, /* size (0 = byte, 1 = short, 2 = long) */
495 16, /* bitsize */
b34976b6 496 FALSE, /* pc_relative */
0e5136c6
JE		 497 0, /* bitpos */
498 complain_overflow_dont, /* complain_on_overflow */
499 bfd_elf_generic_reloc, /* special_function */
500 "R_860_LOGOT0", /* name */
b34976b6 501 FALSE, /* partial_inplace */
0e5136c6
JE		 502 0, /* src_mask */
503 0xffff, /* dst_mask */
b34976b6 504 TRUE), /* pcrel_offset */
0e5136c6
JE		 505
506 HOWTO (R_860_SPGOT0, /* type */
507 0, /* rightshift */
508 2, /* size (0 = byte, 1 = short, 2 = long) */
509 16, /* bitsize */
b34976b6 510 FALSE, /* pc_relative */
0e5136c6
JE		 511 0, /* bitpos */
512 complain_overflow_dont, /* complain_on_overflow */
513 bfd_elf_generic_reloc, /* special_function */
514 "R_860_SPGOT0", /* name */
b34976b6 515 FALSE, /* partial_inplace */
0e5136c6
JE		 516 0, /* src_mask */
517 0xffff, /* dst_mask */
b34976b6 518 TRUE), /* pcrel_offset */
0e5136c6
JE		 519
520 HOWTO (R_860_LOGOT1, /* type */
521 0, /* rightshift */
522 2, /* size (0 = byte, 1 = short, 2 = long) */
523 16, /* bitsize */
b34976b6 524 FALSE, /* pc_relative */
0e5136c6
JE		 525 0, /* bitpos */
526 complain_overflow_dont, /* complain_on_overflow */
527 bfd_elf_generic_reloc, /* special_function */
528 "R_860_LOGOT1", /* name */
b34976b6 529 FALSE, /* partial_inplace */
0e5136c6
JE		 530 0, /* src_mask */
531 0xffff, /* dst_mask */
b34976b6 532 TRUE), /* pcrel_offset */
0e5136c6
JE		 533
534 HOWTO (R_860_SPGOT1, /* type */
535 0, /* rightshift */
536 2, /* size (0 = byte, 1 = short, 2 = long) */
537 16, /* bitsize */
b34976b6 538 FALSE, /* pc_relative */
0e5136c6
JE		 539 0, /* bitpos */
540 complain_overflow_dont, /* complain_on_overflow */
541 bfd_elf_generic_reloc, /* special_function */
542 "R_860_SPGOT1", /* name */
b34976b6 543 FALSE, /* partial_inplace */
0e5136c6
JE		 544 0, /* src_mask */
545 0xffff, /* dst_mask */
b34976b6 546 TRUE), /* pcrel_offset */
0e5136c6
JE		 547
548 HOWTO (R_860_LOGOTOFF0, /* type */
549 0, /* rightshift */
550 2, /* size (0 = byte, 1 = short, 2 = long) */
551 32, /* bitsize */
b34976b6 552 FALSE, /* pc_relative */
0e5136c6
JE		 553 0, /* bitpos */
554 complain_overflow_dont, /* complain_on_overflow */
555 bfd_elf_generic_reloc, /* special_function */
556 "R_860_LOGOTOFF0", /* name */
b34976b6 557 TRUE, /* partial_inplace */
0e5136c6
JE		 558 0xffffffff, /* src_mask */
559 0xffffffff, /* dst_mask */
b34976b6 560 FALSE), /* pcrel_offset */
0e5136c6
JE		 561
562 HOWTO (R_860_SPGOTOFF0, /* type */
563 0, /* rightshift */
564 2, /* size (0 = byte, 1 = short, 2 = long) */
565 32, /* bitsize */
b34976b6 566 FALSE, /* pc_relative */
0e5136c6
JE		 567 0, /* bitpos */
568 complain_overflow_dont, /* complain_on_overflow */
569 bfd_elf_generic_reloc, /* special_function */
570 "R_860_SPGOTOFF0", /* name */
b34976b6 571 TRUE, /* partial_inplace */
0e5136c6
JE		 572 0xffffffff, /* src_mask */
573 0xffffffff, /* dst_mask */
b34976b6 574 FALSE), /* pcrel_offset */
0e5136c6
JE		 575
576 HOWTO (R_860_LOGOTOFF1, /* type */
577 0, /* rightshift */
578 2, /* size (0 = byte, 1 = short, 2 = long) */
579 32, /* bitsize */
b34976b6 580 FALSE, /* pc_relative */
0e5136c6
JE		 581 0, /* bitpos */
582 complain_overflow_dont, /* complain_on_overflow */
583 bfd_elf_generic_reloc, /* special_function */
584 "R_860_LOGOTOFF1", /* name */
b34976b6 585 TRUE, /* partial_inplace */
0e5136c6
JE		 586 0xffffffff, /* src_mask */
587 0xffffffff, /* dst_mask */
b34976b6 588 FALSE), /* pcrel_offset */
0e5136c6
JE		 589
590 HOWTO (R_860_SPGOTOFF1, /* type */
591 0, /* rightshift */
592 2, /* size (0 = byte, 1 = short, 2 = long) */
593 32, /* bitsize */
b34976b6 594 FALSE, /* pc_relative */
0e5136c6
JE		 595 0, /* bitpos */
596 complain_overflow_dont, /* complain_on_overflow */
597 bfd_elf_generic_reloc, /* special_function */
598 "R_860_SPGOTOFF1", /* name */
b34976b6 599 TRUE, /* partial_inplace */
0e5136c6
JE		 600 0xffffffff, /* src_mask */
601 0xffffffff, /* dst_mask */
b34976b6 602 FALSE), /* pcrel_offset */
0e5136c6
JE		 603
604 HOWTO (R_860_LOGOTOFF2, /* type */
605 0, /* rightshift */
606 2, /* size (0 = byte, 1 = short, 2 = long) */
607 32, /* bitsize */
b34976b6 608 FALSE, /* pc_relative */
0e5136c6
JE		 609 0, /* bitpos */
610 complain_overflow_dont, /* complain_on_overflow */
611 bfd_elf_generic_reloc, /* special_function */
612 "R_860_LOGOTOFF2", /* name */
b34976b6 613 TRUE, /* partial_inplace */
0e5136c6
JE		 614 0xffffffff, /* src_mask */
615 0xffffffff, /* dst_mask */
b34976b6 616 FALSE), /* pcrel_offset */
0e5136c6
JE		 617
618 HOWTO (R_860_LOGOTOFF3, /* type */
619 0, /* rightshift */
620 2, /* size (0 = byte, 1 = short, 2 = long) */
621 32, /* bitsize */
b34976b6 622 FALSE, /* pc_relative */
0e5136c6
JE		 623 0, /* bitpos */
624 complain_overflow_dont, /* complain_on_overflow */
625 bfd_elf_generic_reloc, /* special_function */
626 "R_860_LOGOTOFF3", /* name */
b34976b6 627 TRUE, /* partial_inplace */
0e5136c6
JE		 628 0xffffffff, /* src_mask */
629 0xffffffff, /* dst_mask */
b34976b6 630 FALSE), /* pcrel_offset */
0e5136c6
JE		 631
632 HOWTO (R_860_LOPC, /* type */
633 0, /* rightshift */
634 2, /* size (0 = byte, 1 = short, 2 = long) */
635 16, /* bitsize */
b34976b6 636 TRUE, /* pc_relative */
0e5136c6
JE		 637 0, /* bitpos */
638 complain_overflow_bitfield, /* complain_on_overflow */
639 bfd_elf_generic_reloc, /* special_function */
640 "R_860_LOPC", /* name */
b34976b6 641 FALSE, /* partial_inplace */
0e5136c6
JE		 642 0xffff, /* src_mask */
643 0xffff, /* dst_mask */
b34976b6 644 TRUE), /* pcrel_offset */
0e5136c6
JE		 645
646 HOWTO (R_860_HIGHADJ, /* type */
647 0, /* rightshift */
648 2, /* size (0 = byte, 1 = short, 2 = long) */
649 16, /* bitsize */
b34976b6 650 FALSE, /* pc_relative */
0e5136c6
JE		 651 0, /* bitpos */
652 complain_overflow_dont, /* complain_on_overflow */
d539b3aa 653 i860_howto_highadj_reloc, /* special_function */
0e5136c6 654 "R_860_HIGHADJ", /* name */
b34976b6 655 FALSE, /* partial_inplace */
0e5136c6
JE		 656 0xffff, /* src_mask */
657 0xffff, /* dst_mask */
b34976b6 658 FALSE), /* pcrel_offset */
0e5136c6
JE		 659
660 HOWTO (R_860_HAGOT, /* type */
661 0, /* rightshift */
662 2, /* size (0 = byte, 1 = short, 2 = long) */
663 16, /* bitsize */
b34976b6 664 FALSE, /* pc_relative */
0e5136c6
JE		 665 0, /* bitpos */
666 complain_overflow_dont, /* complain_on_overflow */
667 bfd_elf_generic_reloc, /* special_function */
668 "R_860_HAGOT", /* name */
b34976b6 669 FALSE, /* partial_inplace */
0e5136c6
JE		 670 0, /* src_mask */
671 0xffff, /* dst_mask */
b34976b6 672 TRUE), /* pcrel_offset */
0e5136c6
JE		 673
674 HOWTO (R_860_HAGOTOFF, /* type */
675 0, /* rightshift */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
677 32, /* bitsize */
b34976b6 678 FALSE, /* pc_relative */
0e5136c6
JE		 679 0, /* bitpos */
680 complain_overflow_dont, /* complain_on_overflow */
681 bfd_elf_generic_reloc, /* special_function */
682 "R_860_HAGOTOFF", /* name */
b34976b6 683 TRUE, /* partial_inplace */
0e5136c6
JE		 684 0xffffffff, /* src_mask */
685 0xffffffff, /* dst_mask */
b34976b6 686 FALSE), /* pcrel_offset */
0e5136c6
JE		 687
688 HOWTO (R_860_HAPC, /* type */
689 0, /* rightshift */
690 2, /* size (0 = byte, 1 = short, 2 = long) */
691 16, /* bitsize */
b34976b6 692 TRUE, /* pc_relative */
0e5136c6
JE		 693 0, /* bitpos */
694 complain_overflow_bitfield, /* complain_on_overflow */
695 bfd_elf_generic_reloc, /* special_function */
696 "R_860_HAPC", /* name */
b34976b6 697 FALSE, /* partial_inplace */
0e5136c6
JE		 698 0xffff, /* src_mask */
699 0xffff, /* dst_mask */
b34976b6 700 TRUE), /* pcrel_offset */
0e5136c6
JE		 701
702 HOWTO (R_860_HIGH, /* type */
fdeafce7 703 16, /* rightshift */
0e5136c6
JE		 704 2, /* size (0 = byte, 1 = short, 2 = long) */
705 16, /* bitsize */
b34976b6 706 FALSE, /* pc_relative */
0e5136c6
JE		 707 0, /* bitpos */
708 complain_overflow_dont, /* complain_on_overflow */
709 bfd_elf_generic_reloc, /* special_function */
710 "R_860_HIGH", /* name */
b34976b6 711 FALSE, /* partial_inplace */
0e5136c6
JE		 712 0xffff, /* src_mask */
713 0xffff, /* dst_mask */
b34976b6 714 FALSE), /* pcrel_offset */
0e5136c6
JE		 715
716 HOWTO (R_860_HIGOT, /* type */
717 0, /* rightshift */
718 2, /* size (0 = byte, 1 = short, 2 = long) */
719 16, /* bitsize */
b34976b6 720 FALSE, /* pc_relative */
0e5136c6
JE		 721 0, /* bitpos */
722 complain_overflow_dont, /* complain_on_overflow */
723 bfd_elf_generic_reloc, /* special_function */
724 "R_860_HIGOT", /* name */
b34976b6 725 FALSE, /* partial_inplace */
0e5136c6
JE		 726 0, /* src_mask */
727 0xffff, /* dst_mask */
b34976b6 728 TRUE), /* pcrel_offset */
0e5136c6
JE		 729
730 HOWTO (R_860_HIGOTOFF, /* type */
731 0, /* rightshift */
732 2, /* size (0 = byte, 1 = short, 2 = long) */
733 32, /* bitsize */
b34976b6 734 FALSE, /* pc_relative */
0e5136c6
JE		 735 0, /* bitpos */
736 complain_overflow_dont, /* complain_on_overflow */
737 bfd_elf_generic_reloc, /* special_function */
738 "R_860_HIGOTOFF", /* name */
b34976b6 739 TRUE, /* partial_inplace */
0e5136c6
JE		 740 0xffffffff, /* src_mask */
741 0xffffffff, /* dst_mask */
b34976b6 742 FALSE), /* pcrel_offset */
0e5136c6 743};
0e5136c6
JE		 744\f
745static unsigned char elf_code_to_howto_index[R_860_max + 1];
746
747static reloc_howto_type *
7734b6e9 748lookup_howto (unsigned int rtype)
0e5136c6
JE		 749{
750 static int initialized = 0;
751 int i;
752 int howto_tbl_size = (int) (sizeof (elf32_i860_howto_table)
753 / sizeof (elf32_i860_howto_table[0]));
754
755 if (! initialized)
756 {
757 initialized = 1;
758 memset (elf_code_to_howto_index, 0xff,
759 sizeof (elf_code_to_howto_index));
760 for (i = 0; i < howto_tbl_size; i++)
761 elf_code_to_howto_index[elf32_i860_howto_table[i].type] = i;
762 }
763
764 BFD_ASSERT (rtype <= R_860_max);
765 i = elf_code_to_howto_index[rtype];
766 if (i >= howto_tbl_size)
767 return 0;
768 return elf32_i860_howto_table + i;
769}
770
0e5136c6
JE		 771/* Given a BFD reloc, return the matching HOWTO structure. */
772static reloc_howto_type *
7734b6e9
JE		 773elf32_i860_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
774 bfd_reloc_code_real_type code)
0e5136c6
JE		 775{
776 unsigned int rtype;
777
778 switch (code)
779 {
780 case BFD_RELOC_NONE:
781 rtype = R_860_NONE;
782 break;
783 case BFD_RELOC_32:
784 rtype = R_860_32;
785 break;
786 case BFD_RELOC_860_COPY:
787 rtype = R_860_COPY;
788 break;
789 case BFD_RELOC_860_GLOB_DAT:
6609fa74 790 rtype = R_860_GLOB_DAT;
0e5136c6
JE		 791 break;
792 case BFD_RELOC_860_JUMP_SLOT:
793 rtype = R_860_JUMP_SLOT;
794 break;
795 case BFD_RELOC_860_RELATIVE:
796 rtype = R_860_RELATIVE;
797 break;
798 case BFD_RELOC_860_PC26:
799 rtype = R_860_PC26;
800 break;
801 case BFD_RELOC_860_PLT26:
802 rtype = R_860_PLT26;
803 break;
804 case BFD_RELOC_860_PC16:
805 rtype = R_860_PC16;
806 break;
807 case BFD_RELOC_860_LOW0:
808 rtype = R_860_LOW0;
809 break;
810 case BFD_RELOC_860_SPLIT0:
811 rtype = R_860_SPLIT0;
812 break;
813 case BFD_RELOC_860_LOW1:
814 rtype = R_860_LOW1;
815 break;
816 case BFD_RELOC_860_SPLIT1:
817 rtype = R_860_SPLIT1;
818 break;
819 case BFD_RELOC_860_LOW2:
820 rtype = R_860_LOW2;
821 break;
822 case BFD_RELOC_860_SPLIT2:
823 rtype = R_860_SPLIT2;
824 break;
825 case BFD_RELOC_860_LOW3:
826 rtype = R_860_LOW3;
827 break;
828 case BFD_RELOC_860_LOGOT0:
829 rtype = R_860_LOGOT0;
830 break;
831 case BFD_RELOC_860_SPGOT0:
832 rtype = R_860_SPGOT0;
833 break;
834 case BFD_RELOC_860_LOGOT1:
835 rtype = R_860_LOGOT1;
836 break;
837 case BFD_RELOC_860_SPGOT1:
838 rtype = R_860_SPGOT1;
839 break;
840 case BFD_RELOC_860_LOGOTOFF0:
841 rtype = R_860_LOGOTOFF0;
842 break;
843 case BFD_RELOC_860_SPGOTOFF0:
844 rtype = R_860_SPGOTOFF0;
845 break;
846 case BFD_RELOC_860_LOGOTOFF1:
847 rtype = R_860_LOGOTOFF1;
848 break;
849 case BFD_RELOC_860_SPGOTOFF1:
850 rtype = R_860_SPGOTOFF1;
851 break;
852 case BFD_RELOC_860_LOGOTOFF2:
853 rtype = R_860_LOGOTOFF2;
854 break;
855 case BFD_RELOC_860_LOGOTOFF3:
856 rtype = R_860_LOGOTOFF3;
857 break;
858 case BFD_RELOC_860_LOPC:
859 rtype = R_860_LOPC;
860 break;
861 case BFD_RELOC_860_HIGHADJ:
862 rtype = R_860_HIGHADJ;
863 break;
864 case BFD_RELOC_860_HAGOT:
865 rtype = R_860_HAGOT;
866 break;
867 case BFD_RELOC_860_HAGOTOFF:
868 rtype = R_860_HAGOTOFF;
869 break;
870 case BFD_RELOC_860_HAPC:
871 rtype = R_860_HAPC;
872 break;
873 case BFD_RELOC_860_HIGH:
874 rtype = R_860_HIGH;
875 break;
876 case BFD_RELOC_860_HIGOT:
877 rtype = R_860_HIGOT;
878 break;
879 case BFD_RELOC_860_HIGOTOFF:
880 rtype = R_860_HIGOTOFF;
881 break;
882 default:
883 rtype = 0;
884 break;
885 }
886 return lookup_howto (rtype);
887}
888
157090f7
AM		 889static reloc_howto_type *
890elf32_i860_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
891 const char *r_name)
892{
893 unsigned int i;
894
895 for (i = 0;
896 i < (sizeof (elf32_i860_howto_table)
897 / sizeof (elf32_i860_howto_table[0]));
898 i++)
899 if (elf32_i860_howto_table[i].name != NULL
900 && strcasecmp (elf32_i860_howto_table[i].name, r_name) == 0)
901 return &elf32_i860_howto_table[i];
902
903 return NULL;
904}
905
0e5136c6
JE		 906/* Given a ELF reloc, return the matching HOWTO structure. */
907static void
7734b6e9
JE		 908elf32_i860_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
909 arelent *bfd_reloc,
910 Elf_Internal_Rela *elf_reloc)
0e5136c6 911{
dc810e39
AM		 912 bfd_reloc->howto
913 = lookup_howto ((unsigned) ELF32_R_TYPE (elf_reloc->r_info));
0e5136c6 914}
fdeafce7
JE		 915\f
916/* Specialized relocation handler for R_860_SPLITn. These relocations
917 involves a 16-bit field that is split into two contiguous parts. */
918static bfd_reloc_status_type
7734b6e9
JE		 919elf32_i860_relocate_splitn (bfd *input_bfd,
920 Elf_Internal_Rela *rello,
921 bfd_byte *contents,
922 bfd_vma value)
fdeafce7 923{
ded0649c 924 bfd_vma insn;
fdeafce7 925 reloc_howto_type *howto;
dc810e39 926 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
fdeafce7
JE		 927 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
928
fdeafce7 929 /* Relocate. */
ded0649c 930 value += rello->r_addend;
fdeafce7 931
ded0649c 932 /* Separate the fields and insert. */
a48c6a54 933 value = (((value & 0xf800) << 5) | (value & 0x7ff)) & howto->dst_mask;
fdeafce7
JE		 934 insn = (insn & ~howto->dst_mask) | value;
935
936 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
937 return bfd_reloc_ok;
938}
939
fdeafce7
JE		 940/* Specialized relocation handler for R_860_PC16. This relocation
941 involves a 16-bit, PC-relative field that is split into two contiguous
942 parts. */
943static bfd_reloc_status_type
7734b6e9
JE		 944elf32_i860_relocate_pc16 (bfd *input_bfd,
945 asection *input_section,
946 Elf_Internal_Rela *rello,
947 bfd_byte *contents,
948 bfd_vma value)
fdeafce7 949{
ded0649c 950 bfd_vma insn;
d670a150 951 reloc_howto_type *howto;
dc810e39 952 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
d670a150
JE		 953 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
954
955 /* Adjust for PC-relative relocation. */
956 value -= (input_section->output_section->vma
957 + input_section->output_offset);
958 value -= rello->r_offset;
959
d670a150 960 /* Relocate. */
ded0649c 961 value += rello->r_addend;
d670a150 962
f680ea79
JE		 963 /* Adjust the value by 4, then separate the fields and insert. */
964 value = (value - 4) >> howto->rightshift;
a48c6a54 965 value = (((value & 0xf800) << 5) | (value & 0x7ff)) & howto->dst_mask;
d670a150
JE		 966 insn = (insn & ~howto->dst_mask) | value;
967
968 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
969 return bfd_reloc_ok;
970
fdeafce7 971}
fdeafce7 972
c1e8b710
JE		 973/* Specialized relocation handler for R_860_PC26. This relocation
974 involves a 26-bit, PC-relative field which must be adjusted by 4. */
975static bfd_reloc_status_type
7734b6e9
JE		 976elf32_i860_relocate_pc26 (bfd *input_bfd,
977 asection *input_section,
978 Elf_Internal_Rela *rello,
979 bfd_byte *contents,
980 bfd_vma value)
c1e8b710
JE		 981{
982 bfd_vma insn;
983 reloc_howto_type *howto;
dc810e39 984 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
c1e8b710
JE		 985 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
986
987 /* Adjust for PC-relative relocation. */
988 value -= (input_section->output_section->vma
989 + input_section->output_offset);
990 value -= rello->r_offset;
991
992 /* Relocate. */
993 value += rello->r_addend;
994
995 /* Adjust value by 4 and insert the field. */
6609fa74 996 value = ((value - 4) >> howto->rightshift) & howto->dst_mask;
c1e8b710
JE		 997 insn = (insn & ~howto->dst_mask) | value;
998
999 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
1000 return bfd_reloc_ok;
1001
1002}
1003
fdeafce7
JE		 1004/* Specialized relocation handler for R_860_HIGHADJ. */
1005static bfd_reloc_status_type
7734b6e9
JE		 1006elf32_i860_relocate_highadj (bfd *input_bfd,
1007 Elf_Internal_Rela *rel,
1008 bfd_byte *contents,
1009 bfd_vma value)
fdeafce7
JE		 1010{
1011 bfd_vma insn;
1012
1013 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1014
fdeafce7 1015 value += rel->r_addend;
b645cb17 1016 value += 0x8000;
fdeafce7 1017 value = ((value >> 16) & 0xffff);
fdeafce7
JE		 1018
1019 insn = (insn & 0xffff0000) | value;
1020
1021 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1022 return bfd_reloc_ok;
1023}
1024
fdeafce7
JE		 1025/* Perform a single relocation. By default we use the standard BFD
1026 routines. However, we handle some specially. */
1027static bfd_reloc_status_type
7734b6e9
JE		 1028i860_final_link_relocate (reloc_howto_type *howto,
1029 bfd *input_bfd,
1030 asection *input_section,
1031 bfd_byte *contents,
1032 Elf_Internal_Rela *rel,
1033 bfd_vma relocation)
fdeafce7
JE		 1034{
1035 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1036 contents, rel->r_offset, relocation,
1037 rel->r_addend);
1038}
1039
fdeafce7 1040/* Relocate an i860 ELF section.
252b5132 1041
fdeafce7 1042 This is boiler-plate code copied from fr30.
fdeafce7
JE		 1043
1044 The RELOCATE_SECTION function is called by the new ELF backend linker
1045 to handle the relocations for a section.
1046
1047 The relocs are always passed as Rela structures; if the section
1048 actually uses Rel structures, the r_addend field will always be
1049 zero.
1050
1051 This function is responsible for adjusting the section contents as
1049f94e 1052 necessary, and (if using Rela relocs and generating a relocatable
fdeafce7
JE		 1053 output file) adjusting the reloc addend as necessary.
1054
1055 This function does not have to worry about setting the reloc
1056 address or the reloc symbol index.
1057
1058 LOCAL_SYMS is a pointer to the swapped in local symbols.
1059
1060 LOCAL_SECTIONS is an array giving the section in the input file
1061 corresponding to the st_shndx field of each local symbol.
1062
1063 The global hash table entry for the global symbols can be found
1064 via elf_sym_hashes (input_bfd).
1065
1049f94e 1066 When generating relocatable output, this function must handle
fdeafce7
JE		 1067 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1068 going to be the section symbol corresponding to the output
1069 section, which means that the addend must be adjusted
1070 accordingly. */
b34976b6 1071static bfd_boolean
7734b6e9
JE		 1072elf32_i860_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1073 struct bfd_link_info *info,
1074 bfd *input_bfd,
1075 asection *input_section,
1076 bfd_byte *contents,
1077 Elf_Internal_Rela *relocs,
1078 Elf_Internal_Sym *local_syms,
1079 asection **local_sections)
fdeafce7 1080{
b34976b6
AM		 1081 Elf_Internal_Shdr *symtab_hdr;
1082 struct elf_link_hash_entry **sym_hashes;
1083 Elf_Internal_Rela *rel;
1084 Elf_Internal_Rela *relend;
fdeafce7
JE		 1085
1086 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1087 sym_hashes = elf_sym_hashes (input_bfd);
1088 relend = relocs + input_section->reloc_count;
1089
1090 for (rel = relocs; rel < relend; rel ++)
1091 {
1092 reloc_howto_type * howto;
1093 unsigned long r_symndx;
1094 Elf_Internal_Sym * sym;
1095 asection * sec;
1096 struct elf_link_hash_entry * h;
1097 bfd_vma relocation;
1098 bfd_reloc_status_type r;
1099 const char * name = NULL;
1100 int r_type;
6609fa74 1101
fdeafce7 1102 r_type = ELF32_R_TYPE (rel->r_info);
fdeafce7
JE		 1103 r_symndx = ELF32_R_SYM (rel->r_info);
1104
dc810e39
AM		 1105 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info));
1106 h = NULL;
1107 sym = NULL;
1108 sec = NULL;
6609fa74 1109
fdeafce7
JE		 1110 if (r_symndx < symtab_hdr->sh_info)
1111 {
1112 sym = local_syms + r_symndx;
1113 sec = local_sections [r_symndx];
8517fae7 1114 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
6609fa74 1115
fdeafce7
JE		 1116 name = bfd_elf_string_from_elf_section
1117 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1118 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1119 }
1120 else
1121 {
59c2e50f
L		 1122 bfd_boolean unresolved_reloc, warned;
1123
b2a8e766
AM		 1124 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1125 r_symndx, symtab_hdr, sym_hashes,
1126 h, sec, relocation,
1127 unresolved_reloc, warned);
fdeafce7 1128 }
6609fa74 1129
ab96bf03
AM		 1130 if (sec != NULL && elf_discarded_section (sec))
1131 {
1132 /* For relocs against symbols from removed linkonce sections,
1133 or sections discarded by a linker script, we just want the
1134 section contents zeroed. Avoid any special processing. */
1135 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1136 rel->r_info = 0;
1137 rel->r_addend = 0;
1138 continue;
1139 }
1140
1141 if (info->relocatable)
1142 continue;
1143
fdeafce7
JE		 1144 switch (r_type)
1145 {
1146 default:
1147 r = i860_final_link_relocate (howto, input_bfd, input_section,
1148 contents, rel, relocation);
1149 break;
1150
1151 case R_860_HIGHADJ:
1152 r = elf32_i860_relocate_highadj (input_bfd, rel, contents,
1153 relocation);
1154 break;
1155
fdeafce7 1156 case R_860_PC16:
d670a150
JE		 1157 r = elf32_i860_relocate_pc16 (input_bfd, input_section, rel,
1158 contents, relocation);
fdeafce7 1159 break;
fdeafce7 1160
c1e8b710
JE		 1161 case R_860_PC26:
1162 r = elf32_i860_relocate_pc26 (input_bfd, input_section, rel,
1163 contents, relocation);
1164 break;
1165
fdeafce7
JE		 1166 case R_860_SPLIT0:
1167 case R_860_SPLIT1:
1168 case R_860_SPLIT2:
1169 r = elf32_i860_relocate_splitn (input_bfd, rel, contents,
1170 relocation);
1171 break;
1172
1173 /* We do not yet handle GOT/PLT/Dynamic relocations. */
1174 case R_860_COPY:
1175 case R_860_GLOB_DAT:
1176 case R_860_JUMP_SLOT:
1177 case R_860_RELATIVE:
1178 case R_860_PLT26:
1179 case R_860_LOGOT0:
1180 case R_860_SPGOT0:
1181 case R_860_LOGOT1:
1182 case R_860_SPGOT1:
1183 case R_860_LOGOTOFF0:
1184 case R_860_SPGOTOFF0:
1185 case R_860_LOGOTOFF1:
1186 case R_860_SPGOTOFF1:
1187 case R_860_LOGOTOFF2:
1188 case R_860_LOGOTOFF3:
1189 case R_860_LOPC:
1190 case R_860_HAGOT:
1191 case R_860_HAGOTOFF:
1192 case R_860_HAPC:
1193 case R_860_HIGOT:
1194 case R_860_HIGOTOFF:
1195 r = bfd_reloc_notsupported;
1196 break;
6609fa74 1197 }
fdeafce7
JE		 1198
1199 if (r != bfd_reloc_ok)
1200 {
1201 const char * msg = (const char *) NULL;
1202
1203 switch (r)
1204 {
1205 case bfd_reloc_overflow:
1206 r = info->callbacks->reloc_overflow
dfeffb9f
L		 1207 (info, (h ? &h->root : NULL), name, howto->name,
1208 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
fdeafce7 1209 break;
6609fa74 1210
fdeafce7
JE		 1211 case bfd_reloc_undefined:
1212 r = info->callbacks->undefined_symbol
b34976b6 1213 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
fdeafce7 1214 break;
6609fa74 1215
fdeafce7
JE		 1216 case bfd_reloc_outofrange:
1217 msg = _("internal error: out of range error");
1218 break;
1219
1220 case bfd_reloc_notsupported:
1221 msg = _("internal error: unsupported relocation error");
1222 break;
1223
1224 case bfd_reloc_dangerous:
1225 msg = _("internal error: dangerous relocation");
1226 break;
1227
1228 default:
1229 msg = _("internal error: unknown error");
1230 break;
1231 }
1232
1233 if (msg)
1234 r = info->callbacks->warning
1235 (info, msg, name, input_bfd, input_section, rel->r_offset);
1236
1237 if (! r)
b34976b6 1238 return FALSE;
fdeafce7
JE		 1239 }
1240 }
1241
b34976b6 1242 return TRUE;
fdeafce7
JE		 1243}
1244
de24da47
JE		 1245/* Return whether a symbol name implies a local label. SVR4/860 compilers
1246 generate labels of the form ".ep.function_name" to denote the end of a
1247 function prolog. These should be local.
1248 ??? Do any other SVR4 compilers have this convention? If so, this should
1249 be added to the generic routine. */
b34976b6 1250static bfd_boolean
7734b6e9 1251elf32_i860_is_local_label_name (bfd *abfd, const char *name)
de24da47
JE		 1252{
1253 if (name[0] == '.' && name[1] == 'e' && name[2] == 'p' && name[3] == '.')
b34976b6 1254 return TRUE;
de24da47
JE		 1255
1256 return _bfd_elf_is_local_label_name (abfd, name);
1257}
fdeafce7 1258\f
9d751335
JE		 1259#define TARGET_BIG_SYM bfd_elf32_i860_vec
1260#define TARGET_BIG_NAME "elf32-i860"
1261#define TARGET_LITTLE_SYM bfd_elf32_i860_little_vec
1262#define TARGET_LITTLE_NAME "elf32-i860-little"
0e5136c6
JE		 1263#define ELF_ARCH bfd_arch_i860
1264#define ELF_MACHINE_CODE EM_860
1265#define ELF_MAXPAGESIZE 4096
1266
b491616a 1267#define elf_backend_rela_normal 1
fdeafce7 1268#define elf_info_to_howto_rel NULL
0e5136c6 1269#define elf_info_to_howto elf32_i860_info_to_howto_rela
fdeafce7 1270#define elf_backend_relocate_section elf32_i860_relocate_section
0e5136c6 1271#define bfd_elf32_bfd_reloc_type_lookup elf32_i860_reloc_type_lookup
157090f7 1272#define bfd_elf32_bfd_reloc_name_lookup elf32_i860_reloc_name_lookup
de24da47 1273#define bfd_elf32_bfd_is_local_label_name elf32_i860_is_local_label_name
252b5132
RH		 1274
1275#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.456142 seconds and 4 git commands to generate.