projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elf32-d10v.c (extract_rel_addend, insert_rel_addend): New functions.
[deliverable/binutils-gdb.git] / bfd / elf32-i860.c
CommitLineData
0e5136c6 1/* Intel i860 specific support for 32-bit ELF.
1049f94e 2 Copyright 1993, 1995, 1999, 2000, 2001, 2002, 2003
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
21Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22
23#include "bfd.h"
24#include "sysdep.h"
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
66 if (reloc_entry->address > input_section->_cooked_size)
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
129 if (reloc_entry->address > input_section->_cooked_size)
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
194 if (reloc_entry->address > input_section->_cooked_size)
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
246 if (reloc_entry->address > input_section->_cooked_size)
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
0e5136c6
JE		 889/* Given a ELF reloc, return the matching HOWTO structure. */
890static void
7734b6e9
JE		 891elf32_i860_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
892 arelent *bfd_reloc,
893 Elf_Internal_Rela *elf_reloc)
0e5136c6 894{
dc810e39
AM		 895 bfd_reloc->howto
896 = lookup_howto ((unsigned) ELF32_R_TYPE (elf_reloc->r_info));
0e5136c6 897}
fdeafce7
JE		 898\f
899/* Specialized relocation handler for R_860_SPLITn. These relocations
900 involves a 16-bit field that is split into two contiguous parts. */
901static bfd_reloc_status_type
7734b6e9
JE		 902elf32_i860_relocate_splitn (bfd *input_bfd,
903 Elf_Internal_Rela *rello,
904 bfd_byte *contents,
905 bfd_vma value)
fdeafce7 906{
ded0649c 907 bfd_vma insn;
fdeafce7 908 reloc_howto_type *howto;
dc810e39 909 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
fdeafce7
JE		 910 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
911
fdeafce7 912 /* Relocate. */
ded0649c 913 value += rello->r_addend;
fdeafce7 914
ded0649c 915 /* Separate the fields and insert. */
a48c6a54 916 value = (((value & 0xf800) << 5) | (value & 0x7ff)) & howto->dst_mask;
fdeafce7
JE		 917 insn = (insn & ~howto->dst_mask) | value;
918
919 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
920 return bfd_reloc_ok;
921}
922
fdeafce7
JE		 923/* Specialized relocation handler for R_860_PC16. This relocation
924 involves a 16-bit, PC-relative field that is split into two contiguous
925 parts. */
926static bfd_reloc_status_type
7734b6e9
JE		 927elf32_i860_relocate_pc16 (bfd *input_bfd,
928 asection *input_section,
929 Elf_Internal_Rela *rello,
930 bfd_byte *contents,
931 bfd_vma value)
fdeafce7 932{
ded0649c 933 bfd_vma insn;
d670a150 934 reloc_howto_type *howto;
dc810e39 935 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
d670a150
JE		 936 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
937
938 /* Adjust for PC-relative relocation. */
939 value -= (input_section->output_section->vma
940 + input_section->output_offset);
941 value -= rello->r_offset;
942
d670a150 943 /* Relocate. */
ded0649c 944 value += rello->r_addend;
d670a150 945
f680ea79
JE		 946 /* Adjust the value by 4, then separate the fields and insert. */
947 value = (value - 4) >> howto->rightshift;
a48c6a54 948 value = (((value & 0xf800) << 5) | (value & 0x7ff)) & howto->dst_mask;
d670a150
JE		 949 insn = (insn & ~howto->dst_mask) | value;
950
951 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
952 return bfd_reloc_ok;
953
fdeafce7 954}
fdeafce7 955
c1e8b710
JE		 956/* Specialized relocation handler for R_860_PC26. This relocation
957 involves a 26-bit, PC-relative field which must be adjusted by 4. */
958static bfd_reloc_status_type
7734b6e9
JE		 959elf32_i860_relocate_pc26 (bfd *input_bfd,
960 asection *input_section,
961 Elf_Internal_Rela *rello,
962 bfd_byte *contents,
963 bfd_vma value)
c1e8b710
JE		 964{
965 bfd_vma insn;
966 reloc_howto_type *howto;
dc810e39 967 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info));
c1e8b710
JE		 968 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
969
970 /* Adjust for PC-relative relocation. */
971 value -= (input_section->output_section->vma
972 + input_section->output_offset);
973 value -= rello->r_offset;
974
975 /* Relocate. */
976 value += rello->r_addend;
977
978 /* Adjust value by 4 and insert the field. */
6609fa74 979 value = ((value - 4) >> howto->rightshift) & howto->dst_mask;
c1e8b710
JE		 980 insn = (insn & ~howto->dst_mask) | value;
981
982 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
983 return bfd_reloc_ok;
984
985}
986
fdeafce7
JE		 987/* Specialized relocation handler for R_860_HIGHADJ. */
988static bfd_reloc_status_type
7734b6e9
JE		 989elf32_i860_relocate_highadj (bfd *input_bfd,
990 Elf_Internal_Rela *rel,
991 bfd_byte *contents,
992 bfd_vma value)
fdeafce7
JE		 993{
994 bfd_vma insn;
995
996 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
997
fdeafce7 998 value += rel->r_addend;
b645cb17 999 value += 0x8000;
fdeafce7 1000 value = ((value >> 16) & 0xffff);
fdeafce7
JE		 1001
1002 insn = (insn & 0xffff0000) | value;
1003
1004 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1005 return bfd_reloc_ok;
1006}
1007
fdeafce7
JE		 1008/* Perform a single relocation. By default we use the standard BFD
1009 routines. However, we handle some specially. */
1010static bfd_reloc_status_type
7734b6e9
JE		 1011i860_final_link_relocate (reloc_howto_type *howto,
1012 bfd *input_bfd,
1013 asection *input_section,
1014 bfd_byte *contents,
1015 Elf_Internal_Rela *rel,
1016 bfd_vma relocation)
fdeafce7
JE		 1017{
1018 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1019 contents, rel->r_offset, relocation,
1020 rel->r_addend);
1021}
1022
fdeafce7 1023/* Relocate an i860 ELF section.
252b5132 1024
fdeafce7 1025 This is boiler-plate code copied from fr30.
fdeafce7
JE		 1026
1027 The RELOCATE_SECTION function is called by the new ELF backend linker
1028 to handle the relocations for a section.
1029
1030 The relocs are always passed as Rela structures; if the section
1031 actually uses Rel structures, the r_addend field will always be
1032 zero.
1033
1034 This function is responsible for adjusting the section contents as
1049f94e 1035 necessary, and (if using Rela relocs and generating a relocatable
fdeafce7
JE		 1036 output file) adjusting the reloc addend as necessary.
1037
1038 This function does not have to worry about setting the reloc
1039 address or the reloc symbol index.
1040
1041 LOCAL_SYMS is a pointer to the swapped in local symbols.
1042
1043 LOCAL_SECTIONS is an array giving the section in the input file
1044 corresponding to the st_shndx field of each local symbol.
1045
1046 The global hash table entry for the global symbols can be found
1047 via elf_sym_hashes (input_bfd).
1048
1049f94e 1049 When generating relocatable output, this function must handle
fdeafce7
JE		 1050 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1051 going to be the section symbol corresponding to the output
1052 section, which means that the addend must be adjusted
1053 accordingly. */
b34976b6 1054static bfd_boolean
7734b6e9
JE		 1055elf32_i860_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1056 struct bfd_link_info *info,
1057 bfd *input_bfd,
1058 asection *input_section,
1059 bfd_byte *contents,
1060 Elf_Internal_Rela *relocs,
1061 Elf_Internal_Sym *local_syms,
1062 asection **local_sections)
fdeafce7 1063{
b34976b6
AM		 1064 Elf_Internal_Shdr *symtab_hdr;
1065 struct elf_link_hash_entry **sym_hashes;
1066 Elf_Internal_Rela *rel;
1067 Elf_Internal_Rela *relend;
fdeafce7 1068
1049f94e 1069 if (info->relocatable)
b34976b6 1070 return TRUE;
b491616a 1071
fdeafce7
JE		 1072 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1073 sym_hashes = elf_sym_hashes (input_bfd);
1074 relend = relocs + input_section->reloc_count;
1075
1076 for (rel = relocs; rel < relend; rel ++)
1077 {
1078 reloc_howto_type * howto;
1079 unsigned long r_symndx;
1080 Elf_Internal_Sym * sym;
1081 asection * sec;
1082 struct elf_link_hash_entry * h;
1083 bfd_vma relocation;
1084 bfd_reloc_status_type r;
1085 const char * name = NULL;
1086 int r_type;
6609fa74 1087
fdeafce7 1088 r_type = ELF32_R_TYPE (rel->r_info);
6609fa74 1089
fdeafce7
JE		 1090#if 0
1091 if ( r_type == R_860_GNU_VTINHERIT
1092 || r_type == R_860_GNU_VTENTRY)
1093 continue;
1094#endif
6609fa74 1095
fdeafce7
JE		 1096 r_symndx = ELF32_R_SYM (rel->r_info);
1097
dc810e39
AM		 1098 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info));
1099 h = NULL;
1100 sym = NULL;
1101 sec = NULL;
6609fa74 1102
fdeafce7
JE		 1103 if (r_symndx < symtab_hdr->sh_info)
1104 {
1105 sym = local_syms + r_symndx;
1106 sec = local_sections [r_symndx];
f8df10f4 1107 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
6609fa74 1108
fdeafce7
JE		 1109 name = bfd_elf_string_from_elf_section
1110 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1111 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1112 }
1113 else
1114 {
1115 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
6609fa74 1116
fdeafce7
JE		 1117 while (h->root.type == bfd_link_hash_indirect
1118 || h->root.type == bfd_link_hash_warning)
1119 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1120
1121 name = h->root.root.string;
6609fa74 1122
fdeafce7
JE		 1123 if (h->root.type == bfd_link_hash_defined
1124 || h->root.type == bfd_link_hash_defweak)
1125 {
1126 sec = h->root.u.def.section;
1127 relocation = (h->root.u.def.value
1128 + sec->output_section->vma
1129 + sec->output_offset);
1130 }
1131 else if (h->root.type == bfd_link_hash_undefweak)
1132 {
1133 relocation = 0;
1134 }
1135 else
1136 {
1137 if (! ((*info->callbacks->undefined_symbol)
1138 (info, h->root.root.string, input_bfd,
b34976b6
AM		 1139 input_section, rel->r_offset, TRUE)))
1140 return FALSE;
fdeafce7
JE		 1141 relocation = 0;
1142 }
1143 }
6609fa74 1144
fdeafce7
JE		 1145 switch (r_type)
1146 {
1147 default:
1148 r = i860_final_link_relocate (howto, input_bfd, input_section,
1149 contents, rel, relocation);
1150 break;
1151
1152 case R_860_HIGHADJ:
1153 r = elf32_i860_relocate_highadj (input_bfd, rel, contents,
1154 relocation);
1155 break;
1156
fdeafce7 1157 case R_860_PC16:
d670a150
JE		 1158 r = elf32_i860_relocate_pc16 (input_bfd, input_section, rel,
1159 contents, relocation);
fdeafce7 1160 break;
fdeafce7 1161
c1e8b710
JE		 1162 case R_860_PC26:
1163 r = elf32_i860_relocate_pc26 (input_bfd, input_section, rel,
1164 contents, relocation);
1165 break;
1166
fdeafce7
JE		 1167 case R_860_SPLIT0:
1168 case R_860_SPLIT1:
1169 case R_860_SPLIT2:
1170 r = elf32_i860_relocate_splitn (input_bfd, rel, contents,
1171 relocation);
1172 break;
1173
1174 /* We do not yet handle GOT/PLT/Dynamic relocations. */
1175 case R_860_COPY:
1176 case R_860_GLOB_DAT:
1177 case R_860_JUMP_SLOT:
1178 case R_860_RELATIVE:
1179 case R_860_PLT26:
1180 case R_860_LOGOT0:
1181 case R_860_SPGOT0:
1182 case R_860_LOGOT1:
1183 case R_860_SPGOT1:
1184 case R_860_LOGOTOFF0:
1185 case R_860_SPGOTOFF0:
1186 case R_860_LOGOTOFF1:
1187 case R_860_SPGOTOFF1:
1188 case R_860_LOGOTOFF2:
1189 case R_860_LOGOTOFF3:
1190 case R_860_LOPC:
1191 case R_860_HAGOT:
1192 case R_860_HAGOTOFF:
1193 case R_860_HAPC:
1194 case R_860_HIGOT:
1195 case R_860_HIGOTOFF:
1196 r = bfd_reloc_notsupported;
1197 break;
6609fa74 1198 }
fdeafce7
JE		 1199
1200 if (r != bfd_reloc_ok)
1201 {
1202 const char * msg = (const char *) NULL;
1203
1204 switch (r)
1205 {
1206 case bfd_reloc_overflow:
1207 r = info->callbacks->reloc_overflow
1208 (info, name, howto->name, (bfd_vma) 0,
1209 input_bfd, input_section, rel->r_offset);
1210 break;
6609fa74 1211
fdeafce7
JE		 1212 case bfd_reloc_undefined:
1213 r = info->callbacks->undefined_symbol
b34976b6 1214 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
fdeafce7 1215 break;
6609fa74 1216
fdeafce7
JE		 1217 case bfd_reloc_outofrange:
1218 msg = _("internal error: out of range error");
1219 break;
1220
1221 case bfd_reloc_notsupported:
1222 msg = _("internal error: unsupported relocation error");
1223 break;
1224
1225 case bfd_reloc_dangerous:
1226 msg = _("internal error: dangerous relocation");
1227 break;
1228
1229 default:
1230 msg = _("internal error: unknown error");
1231 break;
1232 }
1233
1234 if (msg)
1235 r = info->callbacks->warning
1236 (info, msg, name, input_bfd, input_section, rel->r_offset);
1237
1238 if (! r)
b34976b6 1239 return FALSE;
fdeafce7
JE		 1240 }
1241 }
1242
b34976b6 1243 return TRUE;
fdeafce7
JE		 1244}
1245
de24da47
JE		 1246/* Return whether a symbol name implies a local label. SVR4/860 compilers
1247 generate labels of the form ".ep.function_name" to denote the end of a
1248 function prolog. These should be local.
1249 ??? Do any other SVR4 compilers have this convention? If so, this should
1250 be added to the generic routine. */
b34976b6 1251static bfd_boolean
7734b6e9 1252elf32_i860_is_local_label_name (bfd *abfd, const char *name)
de24da47
JE		 1253{
1254 if (name[0] == '.' && name[1] == 'e' && name[2] == 'p' && name[3] == '.')
b34976b6 1255 return TRUE;
de24da47
JE		 1256
1257 return _bfd_elf_is_local_label_name (abfd, name);
1258}
fdeafce7 1259\f
9d751335
JE		 1260#define TARGET_BIG_SYM bfd_elf32_i860_vec
1261#define TARGET_BIG_NAME "elf32-i860"
1262#define TARGET_LITTLE_SYM bfd_elf32_i860_little_vec
1263#define TARGET_LITTLE_NAME "elf32-i860-little"
0e5136c6
JE		 1264#define ELF_ARCH bfd_arch_i860
1265#define ELF_MACHINE_CODE EM_860
1266#define ELF_MAXPAGESIZE 4096
1267
b491616a 1268#define elf_backend_rela_normal 1
fdeafce7 1269#define elf_info_to_howto_rel NULL
0e5136c6 1270#define elf_info_to_howto elf32_i860_info_to_howto_rela
fdeafce7 1271#define elf_backend_relocate_section elf32_i860_relocate_section
0e5136c6 1272#define bfd_elf32_bfd_reloc_type_lookup elf32_i860_reloc_type_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.330702 seconds and 4 git commands to generate.