projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Do not complain if an R_V850_LO16 reloc has bit 15 set.
[binutils-gdb.git] / bfd / elf32-v850.c
1 /* V850-specific support for 32-bit ELF
2 Copyright (C) 1996, 1997 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20
21
22 /* XXX FIXME: This code is littered with 32bit int, 16bit short, 8bit char
23 dependencies. As is the gas & simulator code or the v850. */
24
25
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "bfdlink.h"
29 #include "libbfd.h"
30 #include "elf-bfd.h"
31 #include "elf/v850.h"
32
33 static reloc_howto_type *v850_elf_reloc_type_lookup
34 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
35 static void v850_elf_info_to_howto_rel
36 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
37 static bfd_reloc_status_type v850_elf_reloc
38 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
39 static boolean v850_elf_is_local_label_name PARAMS ((bfd *, const char *));
40 static boolean v850_elf_relocate_section PARAMS((bfd *,
41 struct bfd_link_info *,
42 bfd *,
43 asection *,
44 bfd_byte *,
45 Elf_Internal_Rela *,
46 Elf_Internal_Sym *,
47 asection **));
48 /* Try to minimize the amount of space occupied by relocation tables
49 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
50 #define USE_REL
51
52 /* Note: It is REQUIRED that the 'type' value of each entry in this array
53 match the index of the entry in the array. */
54 static reloc_howto_type v850_elf_howto_table[] =
55 {
56 /* This reloc does nothing. */
57 HOWTO (R_V850_NONE, /* type */
58 0, /* rightshift */
59 2, /* size (0 = byte, 1 = short, 2 = long) */
60 32, /* bitsize */
61 false, /* pc_relative */
62 0, /* bitpos */
63 complain_overflow_bitfield, /* complain_on_overflow */
64 bfd_elf_generic_reloc, /* special_function */
65 "R_V850_NONE", /* name */
66 false, /* partial_inplace */
67 0, /* src_mask */
68 0, /* dst_mask */
69 false), /* pcrel_offset */
70
71 /* A PC relative 9 bit branch. */
72 HOWTO (R_V850_9_PCREL, /* type */
73 2, /* rightshift */
74 2, /* size (0 = byte, 1 = short, 2 = long) */
75 26, /* bitsize */
76 true, /* pc_relative */
77 0, /* bitpos */
78 complain_overflow_bitfield, /* complain_on_overflow */
79 v850_elf_reloc, /* special_function */
80 "R_V850_9_PCREL", /* name */
81 false, /* partial_inplace */
82 0x00ffffff, /* src_mask */
83 0x00ffffff, /* dst_mask */
84 true), /* pcrel_offset */
85
86 /* A PC relative 22 bit branch. */
87 HOWTO (R_V850_22_PCREL, /* type */
88 2, /* rightshift */
89 2, /* size (0 = byte, 1 = short, 2 = long) */
90 22, /* bitsize */
91 true, /* pc_relative */
92 7, /* bitpos */
93 complain_overflow_signed, /* complain_on_overflow */
94 v850_elf_reloc, /* special_function */
95 "R_V850_22_PCREL", /* name */
96 false, /* partial_inplace */
97 0x07ffff80, /* src_mask */
98 0x07ffff80, /* dst_mask */
99 true), /* pcrel_offset */
100
101 /* High 16 bits of symbol value. */
102 HOWTO (R_V850_HI16_S, /* type */
103 0, /* rightshift */
104 1, /* size (0 = byte, 1 = short, 2 = long) */
105 16, /* bitsize */
106 false, /* pc_relative */
107 0, /* bitpos */
108 complain_overflow_dont, /* complain_on_overflow */
109 v850_elf_reloc, /* special_function */
110 "R_V850_HI16_S", /* name */
111 true, /* partial_inplace */
112 0xffff, /* src_mask */
113 0xffff, /* dst_mask */
114 false), /* pcrel_offset */
115
116 /* High 16 bits of symbol value. */
117 HOWTO (R_V850_HI16, /* type */
118 0, /* rightshift */
119 1, /* size (0 = byte, 1 = short, 2 = long) */
120 16, /* bitsize */
121 false, /* pc_relative */
122 0, /* bitpos */
123 complain_overflow_dont, /* complain_on_overflow */
124 v850_elf_reloc, /* special_function */
125 "R_V850_HI16", /* name */
126 true, /* partial_inplace */
127 0xffff, /* src_mask */
128 0xffff, /* dst_mask */
129 false), /* pcrel_offset */
130
131 /* Low 16 bits of symbol value. */
132 HOWTO (R_V850_LO16, /* type */
133 0, /* rightshift */
134 1, /* size (0 = byte, 1 = short, 2 = long) */
135 16, /* bitsize */
136 false, /* pc_relative */
137 0, /* bitpos */
138 complain_overflow_dont, /* complain_on_overflow */
139 v850_elf_reloc, /* special_function */
140 "R_V850_LO16", /* name */
141 true, /* partial_inplace */
142 0xffff, /* src_mask */
143 0xffff, /* dst_mask */
144 false), /* pcrel_offset */
145
146 /* Simple 32bit reloc. */
147 HOWTO (R_V850_32, /* type */
148 0, /* rightshift */
149 2, /* size (0 = byte, 1 = short, 2 = long) */
150 32, /* bitsize */
151 false, /* pc_relative */
152 0, /* bitpos */
153 complain_overflow_dont, /* complain_on_overflow */
154 bfd_elf_generic_reloc, /* special_function */
155 "R_V850_32", /* name */
156 true, /* partial_inplace */
157 0xffffffff, /* src_mask */
158 0xffffffff, /* dst_mask */
159 false), /* pcrel_offset */
160
161 /* Simple 16bit reloc. */
162 HOWTO (R_V850_16, /* type */
163 0, /* rightshift */
164 1, /* size (0 = byte, 1 = short, 2 = long) */
165 16, /* bitsize */
166 false, /* pc_relative */
167 0, /* bitpos */
168 complain_overflow_dont, /* complain_on_overflow */
169 bfd_elf_generic_reloc, /* special_function */
170 "R_V850_16", /* name */
171 true, /* partial_inplace */
172 0xffff, /* src_mask */
173 0xffff, /* dst_mask */
174 false), /* pcrel_offset */
175
176 /* Simple 8bit reloc. */
177 HOWTO (R_V850_8, /* type */
178 0, /* rightshift */
179 0, /* size (0 = byte, 1 = short, 2 = long) */
180 8, /* bitsize */
181 false, /* pc_relative */
182 0, /* bitpos */
183 complain_overflow_dont, /* complain_on_overflow */
184 bfd_elf_generic_reloc, /* special_function */
185 "R_V850_8", /* name */
186 true, /* partial_inplace */
187 0xff, /* src_mask */
188 0xff, /* dst_mask */
189 false), /* pcrel_offset */
190
191 /* 16 bit offset from the short data area pointer. */
192 HOWTO (R_V850_SDA_16_16_OFFSET, /* type */
193 0, /* rightshift */
194 1, /* size (0 = byte, 1 = short, 2 = long) */
195 16, /* bitsize */
196 false, /* pc_relative */
197 0, /* bitpos */
198 complain_overflow_dont, /* complain_on_overflow */
199 v850_elf_reloc, /* special_function */
200 "R_V850_SDA_16_16_OFFSET", /* name */
201 false, /* partial_inplace */
202 0xffff, /* src_mask */
203 0xffff, /* dst_mask */
204 false), /* pcrel_offset */
205
206 /* 15 bit offset from the short data area pointer. */
207 HOWTO (R_V850_SDA_15_16_OFFSET, /* type */
208 1, /* rightshift */
209 1, /* size (0 = byte, 1 = short, 2 = long) */
210 16, /* bitsize */
211 false, /* pc_relative */
212 1, /* bitpos */
213 complain_overflow_dont, /* complain_on_overflow */
214 v850_elf_reloc, /* special_function */
215 "R_V850_SDA_15_16_OFFSET", /* name */
216 false, /* partial_inplace */
217 0xfffe, /* src_mask */
218 0xfffe, /* dst_mask */
219 false), /* pcrel_offset */
220
221 /* 16 bit offset from the zero data area pointer. */
222 HOWTO (R_V850_ZDA_16_16_OFFSET, /* type */
223 0, /* rightshift */
224 1, /* size (0 = byte, 1 = short, 2 = long) */
225 16, /* bitsize */
226 false, /* pc_relative */
227 0, /* bitpos */
228 complain_overflow_dont, /* complain_on_overflow */
229 v850_elf_reloc, /* special_function */
230 "R_V850_ZDA_16_16_OFFSET", /* name */
231 false, /* partial_inplace */
232 0xffff, /* src_mask */
233 0xffff, /* dst_mask */
234 false), /* pcrel_offset */
235
236 /* 15 bit offset from the zero data area pointer. */
237 HOWTO (R_V850_ZDA_15_16_OFFSET, /* type */
238 1, /* rightshift */
239 1, /* size (0 = byte, 1 = short, 2 = long) */
240 16, /* bitsize */
241 false, /* pc_relative */
242 1, /* bitpos */
243 complain_overflow_dont, /* complain_on_overflow */
244 v850_elf_reloc, /* special_function */
245 "R_V850_ZDA_15_16_OFFSET", /* name */
246 false, /* partial_inplace */
247 0xfffe, /* src_mask */
248 0xfffe, /* dst_mask */
249 false), /* pcrel_offset */
250
251 /* 6 bit offset from the tiny data area pointer. */
252 HOWTO (R_V850_TDA_6_8_OFFSET, /* type */
253 2, /* rightshift */
254 1, /* size (0 = byte, 1 = short, 2 = long) */
255 8, /* bitsize */
256 false, /* pc_relative */
257 1, /* bitpos */
258 complain_overflow_dont, /* complain_on_overflow */
259 v850_elf_reloc, /* special_function */
260 "R_V850_TDA_6_8_OFFSET", /* name */
261 false, /* partial_inplace */
262 0x7e, /* src_mask */
263 0x7e, /* dst_mask */
264 false), /* pcrel_offset */
265
266 /* 8 bit offset from the tiny data area pointer. */
267 HOWTO (R_V850_TDA_7_8_OFFSET, /* type */
268 1, /* rightshift */
269 1, /* size (0 = byte, 1 = short, 2 = long) */
270 8, /* bitsize */
271 false, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_dont, /* complain_on_overflow */
274 v850_elf_reloc, /* special_function */
275 "R_V850_TDA_7_8_OFFSET", /* name */
276 false, /* partial_inplace */
277 0x7f, /* src_mask */
278 0x7f, /* dst_mask */
279 false), /* pcrel_offset */
280
281 /* 7 bit offset from the tiny data area pointer. */
282 HOWTO (R_V850_TDA_7_7_OFFSET, /* type */
283 0, /* rightshift */
284 1, /* size (0 = byte, 1 = short, 2 = long) */
285 7, /* bitsize */
286 false, /* pc_relative */
287 0, /* bitpos */
288 complain_overflow_dont, /* complain_on_overflow */
289 v850_elf_reloc, /* special_function */
290 "R_V850_TDA_7_7_OFFSET", /* name */
291 false, /* partial_inplace */
292 0x7f, /* src_mask */
293 0x7f, /* dst_mask */
294 false), /* pcrel_offset */
295
296 /* start-sanitize-v850e */
297
298 /* 5 bit offset from the tiny data area pointer. */
299 HOWTO (R_V850_TDA_4_5_OFFSET, /* type */
300 1, /* rightshift */
301 1, /* size (0 = byte, 1 = short, 2 = long) */
302 5, /* bitsize */
303 false, /* pc_relative */
304 0, /* bitpos */
305 complain_overflow_dont, /* complain_on_overflow */
306 v850_elf_reloc, /* special_function */
307 "R_V850_TDA_4_5_OFFSET", /* name */
308 false, /* partial_inplace */
309 0x0f, /* src_mask */
310 0x0f, /* dst_mask */
311 false), /* pcrel_offset */
312
313 /* 4 bit offset from the tiny data area pointer. */
314 HOWTO (R_V850_TDA_4_4_OFFSET, /* type */
315 0, /* rightshift */
316 1, /* size (0 = byte, 1 = short, 2 = long) */
317 4, /* bitsize */
318 false, /* pc_relative */
319 0, /* bitpos */
320 complain_overflow_dont, /* complain_on_overflow */
321 v850_elf_reloc, /* special_function */
322 "R_V850_TDA_4_4_OFFSET", /* name */
323 false, /* partial_inplace */
324 0x0f, /* src_mask */
325 0x0f, /* dst_mask */
326 false), /* pcrel_offset */
327
328 /* 16 bit offset from the short data area pointer. */
329 HOWTO (R_V850_SDA_16_16_SPLIT_OFFSET, /* type */
330 0, /* rightshift */
331 2, /* size (0 = byte, 1 = short, 2 = long) */
332 16, /* bitsize */
333 false, /* pc_relative */
334 0, /* bitpos */
335 complain_overflow_dont, /* complain_on_overflow */
336 v850_elf_reloc, /* special_function */
337 "R_V850_SDA_16_16_SPLIT_OFFSET",/* name */
338 false, /* partial_inplace */
339 0xfffe0020, /* src_mask */
340 0xfffe0020, /* dst_mask */
341 false), /* pcrel_offset */
342
343 /* 16 bit offset from the zero data area pointer. */
344 HOWTO (R_V850_ZDA_16_16_SPLIT_OFFSET, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 false, /* pc_relative */
349 0, /* bitpos */
350 complain_overflow_dont, /* complain_on_overflow */
351 v850_elf_reloc, /* special_function */
352 "R_V850_ZDA_16_16_SPLIT_OFFSET",/* name */
353 false, /* partial_inplace */
354 0xfffe0020, /* src_mask */
355 0xfffe0020, /* dst_mask */
356 false), /* pcrel_offset */
357
358 /* end-sanitize-v850e */
359 };
360
361 /* Map BFD reloc types to V850 ELF reloc types. */
362
363 struct v850_elf_reloc_map
364 {
365 unsigned char bfd_reloc_val;
366 unsigned char elf_reloc_val;
367 };
368
369 static const struct v850_elf_reloc_map v850_elf_reloc_map[] =
370 {
371 { BFD_RELOC_NONE, R_V850_NONE },
372 { BFD_RELOC_V850_9_PCREL, R_V850_9_PCREL },
373 { BFD_RELOC_V850_22_PCREL, R_V850_22_PCREL },
374 { BFD_RELOC_HI16_S, R_V850_HI16_S },
375 { BFD_RELOC_HI16, R_V850_HI16 },
376 { BFD_RELOC_LO16, R_V850_LO16 },
377 { BFD_RELOC_32, R_V850_32 },
378 { BFD_RELOC_16, R_V850_16 },
379 { BFD_RELOC_8, R_V850_8 },
380 { BFD_RELOC_V850_SDA_16_16_OFFSET, R_V850_SDA_16_16_OFFSET },
381 { BFD_RELOC_V850_SDA_15_16_OFFSET, R_V850_SDA_15_16_OFFSET },
382 { BFD_RELOC_V850_ZDA_16_16_OFFSET, R_V850_ZDA_16_16_OFFSET },
383 { BFD_RELOC_V850_ZDA_15_16_OFFSET, R_V850_ZDA_15_16_OFFSET },
384 { BFD_RELOC_V850_TDA_6_8_OFFSET, R_V850_TDA_6_8_OFFSET },
385 { BFD_RELOC_V850_TDA_7_8_OFFSET, R_V850_TDA_7_8_OFFSET },
386 { BFD_RELOC_V850_TDA_7_7_OFFSET, R_V850_TDA_7_7_OFFSET },
387 /* start-sanitize-v850e */
388 { BFD_RELOC_V850_TDA_4_5_OFFSET, R_V850_TDA_4_5_OFFSET },
389 { BFD_RELOC_V850_TDA_4_4_OFFSET, R_V850_TDA_4_4_OFFSET },
390 { BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, R_V850_SDA_16_16_SPLIT_OFFSET },
391 { BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, R_V850_ZDA_16_16_SPLIT_OFFSET },
392 /* end-sanitize-v850e */
393 };
394
395 \f
396 /* Map a bfd relocation into the appropriate howto structure */
397 static reloc_howto_type *
398 v850_elf_reloc_type_lookup (abfd, code)
399 bfd *abfd;
400 bfd_reloc_code_real_type code;
401 {
402 unsigned int i;
403
404 for (i = 0;
405 i < sizeof (v850_elf_reloc_map) / sizeof (struct v850_elf_reloc_map);
406 i++)
407 {
408 if (v850_elf_reloc_map[i].bfd_reloc_val == code)
409 {
410 BFD_ASSERT (v850_elf_howto_table[v850_elf_reloc_map[i].elf_reloc_val].type == v850_elf_reloc_map[i].elf_reloc_val);
411
412 return & v850_elf_howto_table[v850_elf_reloc_map[i].elf_reloc_val];
413 }
414 }
415
416 return NULL;
417 }
418
419 \f
420 /* Set the howto pointer for an V850 ELF reloc. */
421 static void
422 v850_elf_info_to_howto_rel (abfd, cache_ptr, dst)
423 bfd *abfd;
424 arelent *cache_ptr;
425 Elf32_Internal_Rel *dst;
426 {
427 unsigned int r_type;
428
429 r_type = ELF32_R_TYPE (dst->r_info);
430 BFD_ASSERT (r_type < (unsigned int) R_V850_max);
431 cache_ptr->howto = &v850_elf_howto_table[r_type];
432 }
433
434 \f
435 /* Look through the relocs for a section during the first phase, and
436 allocate space in the global offset table or procedure linkage
437 table. */
438
439 static boolean
440 v850_elf_check_relocs (abfd, info, sec, relocs)
441 bfd *abfd;
442 struct bfd_link_info *info;
443 asection *sec;
444 const Elf_Internal_Rela *relocs;
445 {
446 boolean ret = true;
447 bfd *dynobj;
448 Elf_Internal_Shdr *symtab_hdr;
449 struct elf_link_hash_entry **sym_hashes;
450 const Elf_Internal_Rela *rel;
451 const Elf_Internal_Rela *rel_end;
452 asection *sreloc;
453 enum reloc_type r_type;
454 int other = 0;
455 const char *common = (const char *)0;
456
457 if (info->relocateable)
458 return true;
459
460 #ifdef DEBUG
461 fprintf (stderr, "v850_elf_check_relocs called for section %s in %s\n",
462 bfd_get_section_name (abfd, sec),
463 bfd_get_filename (abfd));
464 #endif
465
466 dynobj = elf_hash_table (info)->dynobj;
467 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
468 sym_hashes = elf_sym_hashes (abfd);
469 sreloc = NULL;
470
471 rel_end = relocs + sec->reloc_count;
472 for (rel = relocs; rel < rel_end; rel++)
473 {
474 unsigned long r_symndx;
475 struct elf_link_hash_entry *h;
476
477 r_symndx = ELF32_R_SYM (rel->r_info);
478 if (r_symndx < symtab_hdr->sh_info)
479 h = NULL;
480 else
481 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
482
483 r_type = (enum reloc_type) ELF32_R_TYPE (rel->r_info);
484 switch (r_type)
485 {
486 default:
487 case R_V850_NONE:
488 case R_V850_9_PCREL:
489 case R_V850_22_PCREL:
490 case R_V850_HI16_S:
491 case R_V850_HI16:
492 case R_V850_LO16:
493 case R_V850_32:
494 case R_V850_16:
495 case R_V850_8:
496 break;
497
498 /* start-sanitize-v850e */
499 case R_V850_SDA_16_16_SPLIT_OFFSET:
500 /* end-sanitize-v850e */
501 case R_V850_SDA_16_16_OFFSET:
502 case R_V850_SDA_15_16_OFFSET:
503 other = V850_OTHER_SDA;
504 common = ".scommon";
505 goto small_data_common;
506
507 /* start-sanitize-v850e */
508 case R_V850_ZDA_16_16_SPLIT_OFFSET:
509 /* end-sanitize-v850e */
510 case R_V850_ZDA_16_16_OFFSET:
511 case R_V850_ZDA_15_16_OFFSET:
512 other = V850_OTHER_ZDA;
513 common = ".zcommon";
514 goto small_data_common;
515
516 /* start-sanitize-v850e */
517 case R_V850_TDA_4_5_OFFSET:
518 case R_V850_TDA_4_4_OFFSET:
519 /* end-sanitize-v850e */
520 case R_V850_TDA_6_8_OFFSET:
521 case R_V850_TDA_7_8_OFFSET:
522 case R_V850_TDA_7_7_OFFSET:
523 other = V850_OTHER_TDA;
524 common = ".tcommon";
525 /* fall through */
526
527 #define V850_OTHER_MASK (V850_OTHER_TDA | V850_OTHER_SDA | V850_OTHER_ZDA)
528
529 small_data_common:
530 if (h)
531 {
532 h->other |= other; /* flag which type of relocation was used */
533 if ((h->other & V850_OTHER_MASK) != (other & V850_OTHER_MASK)
534 && (h->other & V850_OTHER_ERROR) == 0)
535 {
536 const char *msg;
537
538 switch (h->other & V850_OTHER_MASK)
539 {
540 default:
541 msg = "Variable cannot occupy in multiple small data regions";
542 break;
543 case V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA:
544 msg = "Variable can only be in one of the small, zero, and tiny data regions";
545 break;
546 case V850_OTHER_SDA | V850_OTHER_ZDA:
547 msg = "Variable cannot be in both small and zero data regions simultaneously";
548 break;
549 case V850_OTHER_SDA | V850_OTHER_TDA:
550 msg = "Variable cannot be in both small and tiny data regions simultaneously";
551 break;
552 case V850_OTHER_ZDA | V850_OTHER_TDA:
553 msg = "Variable cannot be in both zero and tiny data regions simultaneously";
554 break;
555 }
556
557 (*info->callbacks->warning) (info, msg, h->root.root.string,
558 abfd, h->root.u.def.section, 0);
559
560 bfd_set_error (bfd_error_bad_value);
561 h->other |= V850_OTHER_ERROR;
562 ret = false;
563 }
564 }
565
566 if (h && h->root.type == bfd_link_hash_common
567 && h->root.u.c.p
568 && !strcmp (bfd_get_section_name (abfd, h->root.u.c.p->section), "COMMON"))
569 {
570 asection *section = h->root.u.c.p->section = bfd_make_section_old_way (abfd, common);
571 section->flags |= SEC_IS_COMMON;
572 }
573
574 #ifdef DEBUG
575 fprintf (stderr, "v850_elf_check_relocs, found %s relocation for %s%s\n",
576 v850_elf_howto_table[ (int)r_type ].name,
577 (h && h->root.root.string) ? h->root.root.string : "<unknown>",
578 (h->root.type == bfd_link_hash_common) ? ", symbol is common" : "");
579 #endif
580 break;
581 }
582 }
583
584 return ret;
585 }
586
587 \f
588 /* Insert the addend into the instruction. */
589 static bfd_reloc_status_type
590 v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
591 bfd * abfd;
592 arelent * reloc;
593 asymbol * symbol;
594 PTR data;
595 asection * isection;
596 bfd * obfd;
597 char ** err;
598 {
599 long relocation;
600 long insn;
601
602
603 /* If there is an output BFD,
604 and the symbol is not a section name (which is only defined at final link time),
605 and either we are not putting the addend into the instruction
606 or the addend is zero, so there is nothing to add into the instruction
607 then just fixup the address and return. */
608 if (obfd != (bfd *) NULL
609 && (symbol->flags & BSF_SECTION_SYM) == 0
610 && (! reloc->howto->partial_inplace
611 || reloc->addend == 0))
612 {
613 reloc->address += isection->output_offset;
614 return bfd_reloc_ok;
615 }
616 #if 0
617 else if (obfd != NULL)
618 {
619 return bfd_reloc_continue;
620 }
621 #endif
622
623 /* Catch relocs involving undefined symbols. */
624 if (bfd_is_und_section (symbol->section)
625 && (symbol->flags & BSF_WEAK) == 0
626 && obfd == NULL)
627 return bfd_reloc_undefined;
628
629 /* We handle final linking of some relocs ourselves. */
630
631 /* Is the address of the relocation really within the section? */
632 if (reloc->address > isection->_cooked_size)
633 return bfd_reloc_outofrange;
634
635 /* Work out which section the relocation is targetted at and the
636 initial relocation command value. */
637
638 /* Get symbol value. (Common symbols are special.) */
639 if (bfd_is_com_section (symbol->section))
640 relocation = 0;
641 else
642 relocation = symbol->value;
643
644 /* Convert input-section-relative symbol value to absolute + addend. */
645 relocation += symbol->section->output_section->vma;
646 relocation += symbol->section->output_offset;
647 relocation += reloc->addend;
648
649 if (reloc->howto->pc_relative == true)
650 {
651 /* Here the variable relocation holds the final address of the
652 symbol we are relocating against, plus any addend. */
653 relocation -= isection->output_section->vma + isection->output_offset;
654
655 /* Deal with pcrel_offset */
656 relocation -= reloc->address;
657 }
658
659 /* I've got no clue... */
660 reloc->addend = 0;
661
662 switch (reloc->howto->type)
663 {
664 default:
665 /* fprintf (stderr, "reloc type %d not SUPPORTED\n", reloc->howto->type ); */
666 return bfd_reloc_notsupported;
667
668 case R_V850_22_PCREL:
669 if (relocation > 0x1ffff || relocation < -0x200000)
670 return bfd_reloc_overflow;
671
672 if ((relocation % 2) != 0)
673 return bfd_reloc_dangerous;
674
675 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc->address);
676 insn &= ~0xfffe003f;
677 insn |= (((relocation & 0xfffe) << 16)
678 | ((relocation & 0x3f0000) >> 16));
679 bfd_put_32 (abfd, insn, (bfd_byte *)data + reloc->address);
680 return bfd_reloc_ok;
681
682 case R_V850_9_PCREL:
683 if (relocation > 0xff || relocation < -0x100)
684 return bfd_reloc_overflow;
685
686 if ((relocation % 2) != 0)
687 return bfd_reloc_dangerous;
688
689 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
690 insn &= ~ 0xf870;
691 insn |= ((relocation & 0x1f0) << 7) | ((relocation & 0x0e) << 3);
692 bfd_put_16 (abfd, insn, (bfd_byte *)data + reloc->address);
693 return bfd_reloc_ok;
694
695 case R_V850_HI16_S:
696 relocation += bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
697 relocation = (relocation >> 16) + ((relocation & 0x8000) != 0);
698 bfd_put_16 (abfd, relocation, (bfd_byte *)data + reloc->address);
699 return bfd_reloc_ok;
700
701 case R_V850_HI16:
702 relocation += bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
703 relocation = (relocation >> 16);
704 bfd_put_16 (abfd, relocation, (bfd_byte *)data + reloc->address);
705 return bfd_reloc_ok;
706
707 case R_V850_LO16:
708 relocation += (short)bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
709 /* Do not complain if value has top bit set, as this has been anticipated. */
710 if ((unsigned long)relocation > 0xffff)
711 return bfd_reloc_overflow;
712 bfd_put_16 (abfd, relocation, (bfd_byte *)data + reloc->address);
713 return bfd_reloc_ok;
714
715 case R_V850_16:
716 relocation += (short)bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
717 /* drop through */
718
719 case R_V850_SDA_16_16_OFFSET:
720 case R_V850_ZDA_16_16_OFFSET:
721 if ((long)relocation > 0x7fff || (long)relocation < -0x8000)
722 return bfd_reloc_overflow;
723 bfd_put_16 (abfd, relocation, (bfd_byte *)data + reloc->address);
724 return bfd_reloc_ok;
725
726 case R_V850_SDA_15_16_OFFSET:
727 case R_V850_ZDA_15_16_OFFSET:
728 if ((long)relocation > 0x7ffe || (long)relocation < -0x8000)
729 return bfd_reloc_overflow;
730
731 if (relocation & 1)
732 return bfd_reloc_dangerous;
733
734 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
735 insn &= 1;
736 insn |= (relocation >> 1) & ~1;
737
738 bfd_put_16 (abfd, insn, (bfd_byte *)data + reloc->address);
739 return bfd_reloc_ok;
740
741 case R_V850_TDA_6_8_OFFSET:
742 if ((long) relocation > 0xfc || (long) relocation < 0)
743 return bfd_reloc_overflow;
744
745 if (relocation & 3)
746 return bfd_reloc_dangerous;
747
748 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
749 insn &= 0xff81;
750 insn |= (relocation >> 1);
751
752 bfd_put_16 (abfd, insn, (bfd_byte *)data + reloc->address);
753 return bfd_reloc_ok;
754
755 case R_V850_TDA_7_8_OFFSET:
756 if ((long) relocation > 0xfe || (long) relocation < 0)
757 return bfd_reloc_overflow;
758
759 if (relocation & 1)
760 return bfd_reloc_dangerous;
761
762 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
763 insn &= 0xff80;
764 insn |= (relocation >> 1);
765
766 bfd_put_16 (abfd, insn, (bfd_byte *)data + reloc->address);
767 return bfd_reloc_ok;
768
769 case R_V850_TDA_7_7_OFFSET:
770 if ((long) relocation > 0x7f || (long) relocation < 0)
771 return bfd_reloc_overflow;
772
773 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
774 insn &= 0xff80;
775 insn |= relocation;
776
777 bfd_put_16 (abfd, insn, (bfd_byte *)data + reloc->address);
778 return bfd_reloc_ok;
779
780 /* start-sanitize-v850e */
781 case R_V850_TDA_4_5_OFFSET:
782 if ((long) relocation > 0x1e || (long) relocation < 0)
783 return bfd_reloc_overflow;
784
785 if (relocation & 1)
786 return bfd_reloc_dangerous;
787
788 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
789 insn &= 0xfff0;
790 insn |= (relocation >> 1);
791
792 bfd_put_16 (abfd, insn, (bfd_byte *)data + reloc->address);
793 return bfd_reloc_ok;
794
795 case R_V850_TDA_4_4_OFFSET:
796 if ((long) relocation > 0xf || (long) relocation < 0)
797 return bfd_reloc_overflow;
798
799 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc->address);
800 insn &= 0xfff0;
801 insn |= relocation;
802
803 bfd_put_16 (abfd, insn, (bfd_byte *)data + reloc->address);
804 return bfd_reloc_ok;
805
806 case R_V850_ZDA_16_16_SPLIT_OFFSET:
807 case R_V850_SDA_16_16_SPLIT_OFFSET:
808 if ((long) relocation > 0xffff || (long) relocation < 0)
809 return bfd_reloc_overflow;
810
811 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc->address);
812
813 insn &= 0x0001ffdf;
814 insn |= (relocation & 1) << 5;
815 insn |= (relocation & ~1) << 16;
816
817 bfd_put_32 (abfd, insn, (bfd_byte *)data + reloc->address);
818 return bfd_reloc_ok;
819 /* end-sanitize-v850e */
820 }
821
822 return bfd_reloc_continue;
823 }
824
825 \f
826 /*ARGSUSED*/
827 static boolean
828 v850_elf_is_local_label_name (abfd, name)
829 bfd *abfd;
830 const char *name;
831 {
832 return ((name[0] == '.' && (name[1] == 'L' || name[1] == '.'))
833 || (name[0] == '_' && name[1] == '.' && name[2] == 'L'
834 && name[3] == '_'));
835 }
836
837 \f
838 /* Perform a relocation as part of a final link. */
839 static bfd_reloc_status_type
840 v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
841 input_section, contents, offset, value,
842 addend, info, sym_sec, is_local)
843 reloc_howto_type * howto;
844 bfd * input_bfd;
845 bfd * output_bfd;
846 asection * input_section;
847 bfd_byte * contents;
848 bfd_vma offset;
849 bfd_vma value;
850 bfd_vma addend;
851 struct bfd_link_info * info;
852 asection * sym_sec;
853 int is_local;
854 {
855 unsigned long insn;
856 unsigned long r_type = howto->type;
857 bfd_byte * hit_data = contents + offset;
858
859 switch (r_type)
860 {
861 case R_V850_9_PCREL:
862 value -= (input_section->output_section->vma
863 + input_section->output_offset);
864 value -= offset;
865
866 if ((long)value > 0xff || (long)value < -0x100)
867 return bfd_reloc_overflow;
868
869 if ((value % 2) != 0)
870 return bfd_reloc_dangerous;
871
872 insn = bfd_get_16 (input_bfd, hit_data);
873 insn &= 0x078f;
874 insn |= ((value & 0x1f0) << 7) | ((value & 0x0e) << 3);
875 bfd_put_16 (input_bfd, insn, hit_data);
876 return bfd_reloc_ok;
877
878 case R_V850_22_PCREL:
879 value -= (input_section->output_section->vma
880 + input_section->output_offset);
881 value -= offset;
882
883 if ((long)value > 0x1ffff || (long)value < -0x200000)
884 return bfd_reloc_overflow;
885
886 if ((value % 2) != 0)
887 return bfd_reloc_dangerous;
888
889 insn = bfd_get_32 (input_bfd, hit_data);
890 insn &= 0x1ffc0;
891 insn |= (((value & 0xfffe) << 16) | ((value & 0x3f0000) >> 16));
892 bfd_put_32 (input_bfd, insn, hit_data);
893 return bfd_reloc_ok;
894
895 case R_V850_HI16_S:
896 value += (short)bfd_get_16 (input_bfd, hit_data);
897 value = (value >> 16) + ((value & 0x8000) != 0);
898
899 if ((long)value > 0x7fff || (long)value < -0x8000)
900 return bfd_reloc_overflow;
901
902 bfd_put_16 (input_bfd, value, hit_data);
903 return bfd_reloc_ok;
904
905 case R_V850_HI16:
906 value += (short)bfd_get_16 (input_bfd, hit_data);
907 value >>= 16;
908
909 if ((long)value > 0x7fff || (long)value < -0x8000)
910 return bfd_reloc_overflow;
911
912 bfd_put_16 (input_bfd, value, hit_data);
913 return bfd_reloc_ok;
914
915 case R_V850_LO16:
916 value += (short)bfd_get_16 (input_bfd, hit_data);
917 value &= 0xffff;
918
919 bfd_put_16 (input_bfd, value, hit_data);
920 return bfd_reloc_ok;
921
922 case R_V850_16:
923 value += (short) bfd_get_16 (input_bfd, hit_data);
924
925 if ((long) value > 0x7fff || (long) value < -0x8000)
926 return bfd_reloc_overflow;
927
928 bfd_put_16 (input_bfd, value, hit_data);
929 return bfd_reloc_ok;
930
931 case R_V850_ZDA_16_16_OFFSET:
932 value -= sym_sec->output_section->vma;
933 value += (short) bfd_get_16 (input_bfd, hit_data);
934
935 if ((long) value > 0x7fff || (long) value < -0x8000)
936 return bfd_reloc_overflow;
937
938 bfd_put_16 (input_bfd, value, hit_data);
939 return bfd_reloc_ok;
940
941 case R_V850_ZDA_15_16_OFFSET:
942 insn = bfd_get_16 (input_bfd, hit_data);
943
944 value -= sym_sec->output_section->vma;
945 value += ((insn & 0xfffe) << 1);
946
947 if ((long) value > 0x7ffe || (long) value < -0x8000)
948 return bfd_reloc_overflow;
949
950 value &= ~1;
951 value |= (insn & 1);
952
953 bfd_put_16 (input_bfd, value, hit_data);
954 return bfd_reloc_ok;
955
956 case R_V850_32:
957 value += bfd_get_32 (input_bfd, hit_data);
958 bfd_put_32 (input_bfd, value, hit_data);
959 return bfd_reloc_ok;
960
961 case R_V850_8:
962 value += (char)bfd_get_8 (input_bfd, hit_data);
963
964 if ((long)value > 0x7f || (long)value < -0x80)
965 return bfd_reloc_overflow;
966
967 bfd_put_8 (input_bfd, value, hit_data);
968 return bfd_reloc_ok;
969
970 case R_V850_SDA_16_16_OFFSET:
971 {
972 unsigned long gp;
973 struct bfd_link_hash_entry * h;
974
975 /* Get the value of __gp. */
976 h = bfd_link_hash_lookup (info->hash, "__gp", false, false, true);
977 if (h == (struct bfd_link_hash_entry *) NULL
978 || h->type != bfd_link_hash_defined)
979 return bfd_reloc_other;
980
981 gp = (h->u.def.value
982 + h->u.def.section->output_section->vma
983 + h->u.def.section->output_offset);
984
985 value -= sym_sec->output_section->vma;
986 value -= (gp - sym_sec->output_section->vma);
987 value += (short) bfd_get_16 (input_bfd, hit_data);
988
989 if ((long)value > 0x7fff || (long)value < -0x8000)
990 return bfd_reloc_overflow;
991
992 bfd_put_16 (input_bfd, value, hit_data);
993 return bfd_reloc_ok;
994 }
995
996 case R_V850_SDA_15_16_OFFSET:
997 {
998 unsigned long gp;
999 struct bfd_link_hash_entry * h;
1000
1001 /* Get the value of __gp. */
1002 h = bfd_link_hash_lookup (info->hash, "__gp", false, false, true);
1003 if (h == (struct bfd_link_hash_entry *) NULL
1004 || h->type != bfd_link_hash_defined)
1005 return bfd_reloc_other;
1006
1007 gp = (h->u.def.value
1008 + h->u.def.section->output_section->vma
1009 + h->u.def.section->output_offset);
1010
1011 value -= sym_sec->output_section->vma;
1012 value -= (gp - sym_sec->output_section->vma);
1013
1014 insn = bfd_get_16 (input_bfd, hit_data);
1015
1016 value += ((insn & 0xfffe) << 1);
1017
1018 if ((long)value > 0x7ffe || (long)value < -0x8000)
1019 return bfd_reloc_overflow;
1020
1021 value &= ~1;
1022 value |= (insn & 1);
1023
1024 bfd_put_16 (input_bfd, value, hit_data);
1025 return bfd_reloc_ok;
1026 }
1027
1028 case R_V850_TDA_6_8_OFFSET:
1029 {
1030 unsigned long ep;
1031 struct bfd_link_hash_entry * h;
1032
1033 insn = bfd_get_16 (input_bfd, hit_data);
1034
1035 /* Get the value of __ep. */
1036 h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1037 if (h == (struct bfd_link_hash_entry *) NULL
1038 || h->type != bfd_link_hash_defined)
1039 return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
1040
1041 ep = (h->u.def.value
1042 + h->u.def.section->output_section->vma
1043 + h->u.def.section->output_offset);
1044
1045 value -= ep;
1046 value += ((insn & 0x7e) << 2);
1047
1048 if ((long) value > 0xfc || (long) value < 0)
1049 return bfd_reloc_overflow;
1050
1051 if ((value % 2) != 0)
1052 return bfd_reloc_dangerous;
1053
1054 insn &= 0xff81;
1055 insn |= (value >> 1);
1056
1057 bfd_put_16 (input_bfd, insn, hit_data);
1058 return bfd_reloc_ok;
1059 }
1060
1061 case R_V850_TDA_7_8_OFFSET:
1062 {
1063 unsigned long ep;
1064 struct bfd_link_hash_entry * h;
1065
1066 insn = bfd_get_16 (input_bfd, hit_data);
1067
1068 /* Get the value of __ep. */
1069 h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1070 if (h == (struct bfd_link_hash_entry *) NULL
1071 || h->type != bfd_link_hash_defined)
1072 return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
1073
1074 ep = (h->u.def.value
1075 + h->u.def.section->output_section->vma
1076 + h->u.def.section->output_offset);
1077
1078 value -= ep;
1079 value += ((insn & 0x7f) << 1);
1080
1081 if ((long) value > 0xfe || (long) value < 0)
1082 return bfd_reloc_overflow;
1083
1084 insn &= 0xff80;
1085 insn |= (value >> 1);
1086
1087 bfd_put_16 (input_bfd, insn, hit_data);
1088 return bfd_reloc_ok;
1089 }
1090
1091 case R_V850_TDA_7_7_OFFSET:
1092 {
1093 unsigned long ep;
1094 struct bfd_link_hash_entry * h;
1095
1096 insn = bfd_get_16 (input_bfd, hit_data);
1097
1098 /* Get the value of __ep. */
1099 h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1100 if (h == (struct bfd_link_hash_entry *) NULL
1101 || h->type != bfd_link_hash_defined)
1102 return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
1103
1104 ep = (h->u.def.value
1105 + h->u.def.section->output_section->vma
1106 + h->u.def.section->output_offset);
1107 value -= ep;
1108
1109 value += insn & 0x7f;
1110
1111 if ((long) value > 0x7f || (long) value < 0)
1112 return bfd_reloc_overflow;
1113
1114 insn &= 0xff80;
1115 insn |= value;
1116 bfd_put_16 (input_bfd, insn, hit_data);
1117 return bfd_reloc_ok;
1118 }
1119
1120 /* start-sanitize-v850e */
1121 case R_V850_TDA_4_5_OFFSET:
1122 {
1123 unsigned long ep;
1124 struct bfd_link_hash_entry * h;
1125
1126 /* Get the value of __ep. */
1127 h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1128 if (h == (struct bfd_link_hash_entry *) NULL
1129 || h->type != bfd_link_hash_defined)
1130 return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
1131
1132 ep = (h->u.def.value
1133 + h->u.def.section->output_section->vma
1134 + h->u.def.section->output_offset);
1135 value -= ep;
1136
1137 insn = bfd_get_16 (input_bfd, hit_data);
1138
1139 value += ((insn & 0xf) << 1);
1140
1141 if ((long) value > 0x1e || (long) value < 0)
1142 return bfd_reloc_overflow;
1143
1144 insn &= 0xfff0;
1145 insn |= (value >> 1);
1146 bfd_put_16 (input_bfd, insn, hit_data);
1147 return bfd_reloc_ok;
1148 }
1149
1150 case R_V850_TDA_4_4_OFFSET:
1151 {
1152 unsigned long ep;
1153 struct bfd_link_hash_entry * h;
1154
1155 /* Get the value of __ep. */
1156 h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1157 if (h == (struct bfd_link_hash_entry *) NULL
1158 || h->type != bfd_link_hash_defined)
1159 return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
1160
1161 ep = (h->u.def.value
1162 + h->u.def.section->output_section->vma
1163 + h->u.def.section->output_offset);
1164 value -= ep;
1165
1166 insn = bfd_get_16 (input_bfd, hit_data);
1167
1168 value += insn & 0xf;
1169
1170 if ((long) value > 0xf || (long) value < 0)
1171 return bfd_reloc_overflow;
1172
1173 insn &= 0xfff0;
1174 insn |= value;
1175 bfd_put_16 (input_bfd, insn, hit_data);
1176 return bfd_reloc_ok;
1177 }
1178
1179 case R_V850_SDA_16_16_SPLIT_OFFSET:
1180 {
1181 unsigned long gp;
1182 struct bfd_link_hash_entry * h;
1183
1184 /* Get the value of __gp. */
1185 h = bfd_link_hash_lookup (info->hash, "__gp", false, false, true);
1186 if (h == (struct bfd_link_hash_entry *) NULL
1187 || h->type != bfd_link_hash_defined)
1188 return bfd_reloc_other;
1189
1190 gp = (h->u.def.value
1191 + h->u.def.section->output_section->vma
1192 + h->u.def.section->output_offset);
1193
1194 value -= sym_sec->output_section->vma;
1195 value -= (gp - sym_sec->output_section->vma);
1196
1197 insn = bfd_get_32 (input_bfd, hit_data);
1198
1199 value += ((insn & 0xfffe0000) >> 16);
1200 value += ((insn & 0x20) >> 5);
1201
1202 if ((long)value > 0x7fff || (long)value < -0x8000)
1203 return bfd_reloc_overflow;
1204
1205 insn &= 0x0001ffdf;
1206 insn |= (value & 1) << 5;
1207 insn |= (value & ~1) << 16;
1208
1209 bfd_put_32 (input_bfd, insn, hit_data);
1210 return bfd_reloc_ok;
1211 }
1212
1213 case R_V850_ZDA_16_16_SPLIT_OFFSET:
1214 insn = bfd_get_32 (input_bfd, hit_data);
1215
1216 value -= sym_sec->output_section->vma;
1217 value += ((insn & 0xfffe0000) >> 16);
1218 value += ((insn & 0x20) >> 5);
1219
1220 if ((long)value > 0x7fff || (long)value < -0x8000)
1221 return bfd_reloc_overflow;
1222
1223 insn &= 0x0001ffdf;
1224 insn |= (value & 1) << 5;
1225 insn |= (value & ~1) << 16;
1226
1227 bfd_put_32 (input_bfd, insn, hit_data);
1228 return bfd_reloc_ok;
1229
1230 /* end-sanitize-v850e */
1231
1232
1233 case R_V850_NONE:
1234 return bfd_reloc_ok;
1235
1236 default:
1237 return bfd_reloc_notsupported;
1238 }
1239 }
1240
1241 \f
1242 /* Relocate an V850 ELF section. */
1243 static boolean
1244 v850_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1245 contents, relocs, local_syms, local_sections)
1246 bfd * output_bfd;
1247 struct bfd_link_info * info;
1248 bfd * input_bfd;
1249 asection * input_section;
1250 bfd_byte * contents;
1251 Elf_Internal_Rela * relocs;
1252 Elf_Internal_Sym * local_syms;
1253 asection ** local_sections;
1254 {
1255 Elf_Internal_Shdr * symtab_hdr;
1256 struct elf_link_hash_entry ** sym_hashes;
1257 Elf_Internal_Rela * rel;
1258 Elf_Internal_Rela * relend;
1259
1260 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1261 sym_hashes = elf_sym_hashes (input_bfd);
1262
1263 rel = relocs;
1264 relend = relocs + input_section->reloc_count;
1265 for (; rel < relend; rel++)
1266 {
1267 int r_type;
1268 reloc_howto_type * howto;
1269 unsigned long r_symndx;
1270 Elf_Internal_Sym * sym;
1271 asection * sec;
1272 struct elf_link_hash_entry * h;
1273 bfd_vma relocation;
1274 bfd_reloc_status_type r;
1275
1276 r_symndx = ELF32_R_SYM (rel->r_info);
1277 r_type = ELF32_R_TYPE (rel->r_info);
1278 howto = v850_elf_howto_table + r_type;
1279
1280 if (info->relocateable)
1281 {
1282 /* This is a relocateable link. We don't have to change
1283 anything, unless the reloc is against a section symbol,
1284 in which case we have to adjust according to where the
1285 section symbol winds up in the output section. */
1286 if (r_symndx < symtab_hdr->sh_info)
1287 {
1288 sym = local_syms + r_symndx;
1289 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1290 {
1291 sec = local_sections[r_symndx];
1292 rel->r_addend += sec->output_offset + sym->st_value;
1293 }
1294 }
1295
1296 continue;
1297 }
1298
1299 /* This is a final link. */
1300 h = NULL;
1301 sym = NULL;
1302 sec = NULL;
1303 if (r_symndx < symtab_hdr->sh_info)
1304 {
1305 sym = local_syms + r_symndx;
1306 sec = local_sections[r_symndx];
1307 relocation = (sec->output_section->vma
1308 + sec->output_offset
1309 + sym->st_value);
1310 #if 0
1311 {
1312 char * name;
1313 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name);
1314 name = (name == NULL) ? "<none>" : name;
1315 fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x rel %x\n", sec->name, name, sym->st_name,
1316 sec->output_section->vma, sec->output_offset, sym->st_value, rel->r_addend, rel);
1317 }
1318 #endif
1319 }
1320 else
1321 {
1322 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1323
1324 while (h->root.type == bfd_link_hash_indirect
1325 || h->root.type == bfd_link_hash_warning)
1326 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1327
1328 if (h->root.type == bfd_link_hash_defined
1329 || h->root.type == bfd_link_hash_defweak)
1330 {
1331 sec = h->root.u.def.section;
1332 relocation = (h->root.u.def.value
1333 + sec->output_section->vma
1334 + sec->output_offset);
1335 }
1336 else if (h->root.type == bfd_link_hash_undefweak)
1337 relocation = 0;
1338 else
1339 {
1340 if (! ((*info->callbacks->undefined_symbol)
1341 (info, h->root.root.string, input_bfd,
1342 input_section, rel->r_offset)))
1343 return false;
1344 relocation = 0;
1345 }
1346 }
1347
1348 /* FIXME: We should use the addend, but the COFF relocations
1349 don't. */
1350 r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1351 input_section,
1352 contents, rel->r_offset,
1353 relocation, rel->r_addend,
1354 info, sec, h == NULL);
1355
1356 if (r != bfd_reloc_ok)
1357 {
1358 const char * name;
1359 const char * msg = (const char *)0;
1360
1361 if (h != NULL)
1362 name = h->root.root.string;
1363 else
1364 {
1365 name = (bfd_elf_string_from_elf_section
1366 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1367 if (name == NULL || *name == '\0')
1368 name = bfd_section_name (input_bfd, sec);
1369 }
1370
1371 switch (r)
1372 {
1373 case bfd_reloc_overflow:
1374 if (! ((*info->callbacks->reloc_overflow)
1375 (info, name, howto->name, (bfd_vma) 0,
1376 input_bfd, input_section, rel->r_offset)))
1377 return false;
1378 break;
1379
1380 case bfd_reloc_undefined:
1381 fprintf (stderr, "undef2 %s\n", name );
1382 if (! ((*info->callbacks->undefined_symbol)
1383 (info, name, input_bfd, input_section,
1384 rel->r_offset)))
1385 return false;
1386 break;
1387
1388 case bfd_reloc_outofrange:
1389 msg = "internal error: out of range error";
1390 goto common_error;
1391
1392 case bfd_reloc_notsupported:
1393 msg = "internal error: unsupported relocation error";
1394 goto common_error;
1395
1396 case bfd_reloc_dangerous:
1397 msg = "internal error: dangerous relocation";
1398 goto common_error;
1399
1400 case bfd_reloc_other:
1401 msg = "could not locate special linker symbol __gp";
1402 goto common_error;
1403
1404 case bfd_reloc_continue:
1405 msg = "could not locate special linker symbol __ep";
1406 goto common_error;
1407
1408 default:
1409 msg = "internal error: unknown error";
1410 /* fall through */
1411
1412 common_error:
1413 if (!((*info->callbacks->warning)
1414 (info, msg, name, input_bfd, input_section,
1415 rel->r_offset)))
1416 return false;
1417 break;
1418 }
1419 }
1420 }
1421
1422 return true;
1423 }
1424
1425 /* Set the right machine number. */
1426 static boolean
1427 v850_elf_object_p (abfd)
1428 bfd *abfd;
1429 {
1430 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1431 {
1432 default:
1433 case E_V850_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, 0); break;
1434 /* start-sanitize-v850e */
1435 case E_V850E_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e); break;
1436 /* end-sanitize-v850e */
1437 /* start-sanitize-v850eq */
1438 case E_V850EQ_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850eq); break;
1439 /* start-sanitize-v850eq */
1440 }
1441 }
1442
1443 /* Store the machine number in the flags field. */
1444 void
1445 v850_elf_final_write_processing (abfd, linker)
1446 bfd * abfd;
1447 boolean linker;
1448 {
1449 unsigned long val;
1450
1451 switch (bfd_get_mach (abfd))
1452 {
1453 default:
1454 case 0: val = E_V850_ARCH; break;
1455 /* start-sanitize-v850e */
1456 case bfd_mach_v850e: val = E_V850E_ARCH; break;
1457 /* end-sanitize-v850e */
1458 /* start-sanitize-v850eq */
1459 case bfd_mach_v850eq: val = E_V850EQ_ARCH; break;
1460 /* end-sanitize-v850eq */
1461 }
1462
1463 elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH;
1464 elf_elfheader (abfd)->e_flags |= val;
1465 }
1466
1467 /* Function to keep V850 specific file flags. */
1468 boolean
1469 v850_elf_set_private_flags (abfd, flags)
1470 bfd * abfd;
1471 flagword flags;
1472 {
1473 BFD_ASSERT (!elf_flags_init (abfd)
1474 || elf_elfheader (abfd)->e_flags == flags);
1475
1476 elf_elfheader (abfd)->e_flags = flags;
1477 elf_flags_init (abfd) = true;
1478 return true;
1479 }
1480
1481 /* Copy backend specific data from one object module to another */
1482 boolean
1483 v850_elf_copy_private_bfd_data (ibfd, obfd)
1484 bfd * ibfd;
1485 bfd * obfd;
1486 {
1487 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1488 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1489 return true;
1490
1491 BFD_ASSERT (!elf_flags_init (obfd)
1492 || (elf_elfheader (obfd)->e_flags
1493 == elf_elfheader (ibfd)->e_flags));
1494
1495 elf_gp (obfd) = elf_gp (ibfd);
1496 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1497 elf_flags_init (obfd) = true;
1498 return true;
1499 }
1500
1501 /* Merge backend specific data from an object file to the output
1502 object file when linking. */
1503 boolean
1504 v850_elf_merge_private_bfd_data (ibfd, obfd)
1505 bfd * ibfd;
1506 bfd * obfd;
1507 {
1508 flagword old_flags;
1509 flagword new_flags;
1510
1511 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1512 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1513 return true;
1514
1515 new_flags = elf_elfheader (ibfd)->e_flags;
1516 old_flags = elf_elfheader (obfd)->e_flags;
1517
1518 if (! elf_flags_init (obfd))
1519 {
1520 elf_flags_init (obfd) = true;
1521 elf_elfheader (obfd)->e_flags = new_flags;
1522
1523 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1524 && bfd_get_arch_info (obfd)->the_default)
1525 {
1526 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1527 }
1528
1529 return true;
1530 }
1531
1532 /* Check flag compatibility. */
1533
1534 if (new_flags == old_flags)
1535 return true;
1536
1537 if ((new_flags & EF_V850_ARCH) != (old_flags & EF_V850_ARCH))
1538 {
1539 _bfd_error_handler ("%s: Architecture mismatch with previous modules",
1540 bfd_get_filename (ibfd));
1541 bfd_set_error (bfd_error_bad_value);
1542 return false;
1543 }
1544
1545 return true;
1546 }
1547 /* Display the flags field */
1548
1549 static boolean
1550 v850_elf_print_private_bfd_data (abfd, ptr)
1551 bfd * abfd;
1552 PTR ptr;
1553 {
1554 FILE * file = (FILE *) ptr;
1555
1556 BFD_ASSERT (abfd != NULL && ptr != NULL)
1557
1558 fprintf (file, "private flags = %x", elf_elfheader (abfd)->e_flags);
1559
1560 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1561 {
1562 default:
1563 case E_V850_ARCH: fprintf (file, ": v850 architecture"); break;
1564 /* start-sanitize-v850e */
1565 case E_V850E_ARCH: fprintf (file, ": v850e architecture"); break;
1566 /* end-sanitize-v850e */
1567 /* start-sanitize-v850eq */
1568 case E_V850EQ_ARCH: fprintf (file, ": v850eq architecture"); break;
1569 /* end-sanitize-v850eq */
1570 }
1571
1572 fputc ('\n', file);
1573
1574 return true;
1575 }
1576 \f
1577 #define TARGET_LITTLE_SYM bfd_elf32_v850_vec
1578 #define TARGET_LITTLE_NAME "elf32-v850"
1579 #define ELF_ARCH bfd_arch_v850
1580 #define ELF_MACHINE_CODE EM_CYGNUS_V850
1581 #define ELF_MAXPAGESIZE 0x1000
1582
1583 #define elf_info_to_howto 0
1584 #define elf_info_to_howto_rel v850_elf_info_to_howto_rel
1585 #define elf_backend_check_relocs v850_elf_check_relocs
1586 #define elf_backend_relocate_section v850_elf_relocate_section
1587 #define elf_backend_object_p v850_elf_object_p
1588 #define elf_backend_final_write_processing v850_elf_final_write_processing
1589 #define bfd_elf32_bfd_is_local_label_name v850_elf_is_local_label_name
1590 #define bfd_elf32_bfd_reloc_type_lookup v850_elf_reloc_type_lookup
1591 #define bfd_elf32_bfd_copy_private_bfd_data v850_elf_copy_private_bfd_data
1592 #define bfd_elf32_bfd_merge_private_bfd_data v850_elf_merge_private_bfd_data
1593 #define bfd_elf32_bfd_set_private_flags v850_elf_set_private_flags
1594 #define bfd_elf32_bfd_print_private_bfd_data v850_elf_print_private_bfd_data
1595
1596 #define elf_symbol_leading_char '_'
1597
1598 #include "elf32-target.h"