projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update copyright notices
[deliverable/binutils-gdb.git] / bfd / elf32-v850.c
1 /* V850-specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 /* XXX FIXME: This code is littered with 32bit int, 16bit short, 8bit char
22 dependencies. As is the gas & simulator code or the v850. */
23
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "bfdlink.h"
27 #include "libbfd.h"
28 #include "elf-bfd.h"
29 #include "elf/v850.h"
30
31 /* sign-extend a 24-bit number */
32 #define SEXT24(x) ((((x) & 0xffffff) ^ (~ 0x7fffff)) + 0x800000)
33
34 static reloc_howto_type *v850_elf_reloc_type_lookup
35 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
36 static void v850_elf_info_to_howto_rel
37 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
38 static void v850_elf_info_to_howto_rela
39 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
40 static bfd_reloc_status_type v850_elf_reloc
41 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
42 static boolean v850_elf_is_local_label_name
43 PARAMS ((bfd *, const char *));
44 static boolean v850_elf_relocate_section
45 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
46 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
47 static bfd_reloc_status_type v850_elf_perform_relocation
48 PARAMS ((bfd *, int, bfd_vma, bfd_byte *));
49 static boolean v850_elf_check_relocs
50 PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));
51 static void remember_hi16s_reloc
52 PARAMS ((bfd *, bfd_vma, bfd_byte *));
53 static bfd_byte * find_remembered_hi16s_reloc
54 PARAMS ((bfd_vma, boolean *));
55 static bfd_reloc_status_type v850_elf_final_link_relocate
56 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *, bfd_vma,
57 bfd_vma, bfd_vma, struct bfd_link_info *, asection *, int));
58 static boolean v850_elf_object_p
59 PARAMS ((bfd *));
60 static boolean v850_elf_fake_sections
61 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
62 static void v850_elf_final_write_processing
63 PARAMS ((bfd *, boolean));
64 static boolean v850_elf_set_private_flags
65 PARAMS ((bfd *, flagword));
66 static boolean v850_elf_copy_private_bfd_data
67 PARAMS ((bfd *, bfd *));
68 static boolean v850_elf_merge_private_bfd_data
69 PARAMS ((bfd *, bfd *));
70 static boolean v850_elf_print_private_bfd_data
71 PARAMS ((bfd *, PTR));
72 static boolean v850_elf_section_from_bfd_section
73 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *, int *));
74 static void v850_elf_symbol_processing
75 PARAMS ((bfd *, asymbol *));
76 static boolean v850_elf_add_symbol_hook
77 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
78 const char **, flagword *, asection **, bfd_vma *));
79 static boolean v850_elf_link_output_symbol_hook
80 PARAMS ((bfd *, struct bfd_link_info *, const char *,
81 Elf_Internal_Sym *, asection *));
82 static boolean v850_elf_section_from_shdr
83 PARAMS ((bfd *, Elf_Internal_Shdr *, char *));
84
85 /* Note: It is REQUIRED that the 'type' value of each entry in this array
86 match the index of the entry in the array. */
87 static reloc_howto_type v850_elf_howto_table[] =
88 {
89 /* This reloc does nothing. */
90 HOWTO (R_V850_NONE, /* type */
91 0, /* rightshift */
92 2, /* size (0 = byte, 1 = short, 2 = long) */
93 32, /* bitsize */
94 false, /* pc_relative */
95 0, /* bitpos */
96 complain_overflow_bitfield, /* complain_on_overflow */
97 bfd_elf_generic_reloc, /* special_function */
98 "R_V850_NONE", /* name */
99 false, /* partial_inplace */
100 0, /* src_mask */
101 0, /* dst_mask */
102 false), /* pcrel_offset */
103
104 /* A PC relative 9 bit branch. */
105 HOWTO (R_V850_9_PCREL, /* type */
106 2, /* rightshift */
107 2, /* size (0 = byte, 1 = short, 2 = long) */
108 26, /* bitsize */
109 true, /* pc_relative */
110 0, /* bitpos */
111 complain_overflow_bitfield, /* complain_on_overflow */
112 v850_elf_reloc, /* special_function */
113 "R_V850_9_PCREL", /* name */
114 false, /* partial_inplace */
115 0x00ffffff, /* src_mask */
116 0x00ffffff, /* dst_mask */
117 true), /* pcrel_offset */
118
119 /* A PC relative 22 bit branch. */
120 HOWTO (R_V850_22_PCREL, /* type */
121 2, /* rightshift */
122 2, /* size (0 = byte, 1 = short, 2 = long) */
123 22, /* bitsize */
124 true, /* pc_relative */
125 7, /* bitpos */
126 complain_overflow_signed, /* complain_on_overflow */
127 v850_elf_reloc, /* special_function */
128 "R_V850_22_PCREL", /* name */
129 false, /* partial_inplace */
130 0x07ffff80, /* src_mask */
131 0x07ffff80, /* dst_mask */
132 true), /* pcrel_offset */
133
134 /* High 16 bits of symbol value. */
135 HOWTO (R_V850_HI16_S, /* type */
136 0, /* rightshift */
137 1, /* size (0 = byte, 1 = short, 2 = long) */
138 16, /* bitsize */
139 false, /* pc_relative */
140 0, /* bitpos */
141 complain_overflow_dont, /* complain_on_overflow */
142 v850_elf_reloc, /* special_function */
143 "R_V850_HI16_S", /* name */
144 false, /* partial_inplace */
145 0xffff, /* src_mask */
146 0xffff, /* dst_mask */
147 false), /* pcrel_offset */
148
149 /* High 16 bits of symbol value. */
150 HOWTO (R_V850_HI16, /* type */
151 0, /* rightshift */
152 1, /* size (0 = byte, 1 = short, 2 = long) */
153 16, /* bitsize */
154 false, /* pc_relative */
155 0, /* bitpos */
156 complain_overflow_dont, /* complain_on_overflow */
157 v850_elf_reloc, /* special_function */
158 "R_V850_HI16", /* name */
159 false, /* partial_inplace */
160 0xffff, /* src_mask */
161 0xffff, /* dst_mask */
162 false), /* pcrel_offset */
163
164 /* Low 16 bits of symbol value. */
165 HOWTO (R_V850_LO16, /* type */
166 0, /* rightshift */
167 1, /* size (0 = byte, 1 = short, 2 = long) */
168 16, /* bitsize */
169 false, /* pc_relative */
170 0, /* bitpos */
171 complain_overflow_dont, /* complain_on_overflow */
172 v850_elf_reloc, /* special_function */
173 "R_V850_LO16", /* name */
174 false, /* partial_inplace */
175 0xffff, /* src_mask */
176 0xffff, /* dst_mask */
177 false), /* pcrel_offset */
178
179 /* Simple 32bit reloc. */
180 HOWTO (R_V850_32, /* type */
181 0, /* rightshift */
182 2, /* size (0 = byte, 1 = short, 2 = long) */
183 32, /* bitsize */
184 false, /* pc_relative */
185 0, /* bitpos */
186 complain_overflow_dont, /* complain_on_overflow */
187 v850_elf_reloc, /* special_function */
188 "R_V850_32", /* name */
189 false, /* partial_inplace */
190 0xffffffff, /* src_mask */
191 0xffffffff, /* dst_mask */
192 false), /* pcrel_offset */
193
194 /* Simple 16bit reloc. */
195 HOWTO (R_V850_16, /* type */
196 0, /* rightshift */
197 1, /* size (0 = byte, 1 = short, 2 = long) */
198 16, /* bitsize */
199 false, /* pc_relative */
200 0, /* bitpos */
201 complain_overflow_dont, /* complain_on_overflow */
202 bfd_elf_generic_reloc, /* special_function */
203 "R_V850_16", /* name */
204 false, /* partial_inplace */
205 0xffff, /* src_mask */
206 0xffff, /* dst_mask */
207 false), /* pcrel_offset */
208
209 /* Simple 8bit reloc. */
210 HOWTO (R_V850_8, /* type */
211 0, /* rightshift */
212 0, /* size (0 = byte, 1 = short, 2 = long) */
213 8, /* bitsize */
214 false, /* pc_relative */
215 0, /* bitpos */
216 complain_overflow_dont, /* complain_on_overflow */
217 bfd_elf_generic_reloc, /* special_function */
218 "R_V850_8", /* name */
219 false, /* partial_inplace */
220 0xff, /* src_mask */
221 0xff, /* dst_mask */
222 false), /* pcrel_offset */
223
224 /* 16 bit offset from the short data area pointer. */
225 HOWTO (R_V850_SDA_16_16_OFFSET, /* type */
226 0, /* rightshift */
227 1, /* size (0 = byte, 1 = short, 2 = long) */
228 16, /* bitsize */
229 false, /* pc_relative */
230 0, /* bitpos */
231 complain_overflow_dont, /* complain_on_overflow */
232 v850_elf_reloc, /* special_function */
233 "R_V850_SDA_16_16_OFFSET", /* name */
234 false, /* partial_inplace */
235 0xffff, /* src_mask */
236 0xffff, /* dst_mask */
237 false), /* pcrel_offset */
238
239 /* 15 bit offset from the short data area pointer. */
240 HOWTO (R_V850_SDA_15_16_OFFSET, /* type */
241 1, /* rightshift */
242 1, /* size (0 = byte, 1 = short, 2 = long) */
243 16, /* bitsize */
244 false, /* pc_relative */
245 1, /* bitpos */
246 complain_overflow_dont, /* complain_on_overflow */
247 v850_elf_reloc, /* special_function */
248 "R_V850_SDA_15_16_OFFSET", /* name */
249 false, /* partial_inplace */
250 0xfffe, /* src_mask */
251 0xfffe, /* dst_mask */
252 false), /* pcrel_offset */
253
254 /* 16 bit offset from the zero data area pointer. */
255 HOWTO (R_V850_ZDA_16_16_OFFSET, /* type */
256 0, /* rightshift */
257 1, /* size (0 = byte, 1 = short, 2 = long) */
258 16, /* bitsize */
259 false, /* pc_relative */
260 0, /* bitpos */
261 complain_overflow_dont, /* complain_on_overflow */
262 v850_elf_reloc, /* special_function */
263 "R_V850_ZDA_16_16_OFFSET", /* name */
264 false, /* partial_inplace */
265 0xffff, /* src_mask */
266 0xffff, /* dst_mask */
267 false), /* pcrel_offset */
268
269 /* 15 bit offset from the zero data area pointer. */
270 HOWTO (R_V850_ZDA_15_16_OFFSET, /* type */
271 1, /* rightshift */
272 1, /* size (0 = byte, 1 = short, 2 = long) */
273 16, /* bitsize */
274 false, /* pc_relative */
275 1, /* bitpos */
276 complain_overflow_dont, /* complain_on_overflow */
277 v850_elf_reloc, /* special_function */
278 "R_V850_ZDA_15_16_OFFSET", /* name */
279 false, /* partial_inplace */
280 0xfffe, /* src_mask */
281 0xfffe, /* dst_mask */
282 false), /* pcrel_offset */
283
284 /* 6 bit offset from the tiny data area pointer. */
285 HOWTO (R_V850_TDA_6_8_OFFSET, /* type */
286 2, /* rightshift */
287 1, /* size (0 = byte, 1 = short, 2 = long) */
288 8, /* bitsize */
289 false, /* pc_relative */
290 1, /* bitpos */
291 complain_overflow_dont, /* complain_on_overflow */
292 v850_elf_reloc, /* special_function */
293 "R_V850_TDA_6_8_OFFSET", /* name */
294 false, /* partial_inplace */
295 0x7e, /* src_mask */
296 0x7e, /* dst_mask */
297 false), /* pcrel_offset */
298
299 /* 8 bit offset from the tiny data area pointer. */
300 HOWTO (R_V850_TDA_7_8_OFFSET, /* type */
301 1, /* rightshift */
302 1, /* size (0 = byte, 1 = short, 2 = long) */
303 8, /* bitsize */
304 false, /* pc_relative */
305 0, /* bitpos */
306 complain_overflow_dont, /* complain_on_overflow */
307 v850_elf_reloc, /* special_function */
308 "R_V850_TDA_7_8_OFFSET", /* name */
309 false, /* partial_inplace */
310 0x7f, /* src_mask */
311 0x7f, /* dst_mask */
312 false), /* pcrel_offset */
313
314 /* 7 bit offset from the tiny data area pointer. */
315 HOWTO (R_V850_TDA_7_7_OFFSET, /* type */
316 0, /* rightshift */
317 1, /* size (0 = byte, 1 = short, 2 = long) */
318 7, /* bitsize */
319 false, /* pc_relative */
320 0, /* bitpos */
321 complain_overflow_dont, /* complain_on_overflow */
322 v850_elf_reloc, /* special_function */
323 "R_V850_TDA_7_7_OFFSET", /* name */
324 false, /* partial_inplace */
325 0x7f, /* src_mask */
326 0x7f, /* dst_mask */
327 false), /* pcrel_offset */
328
329 /* 16 bit offset from the tiny data area pointer! */
330 HOWTO (R_V850_TDA_16_16_OFFSET, /* type */
331 0, /* rightshift */
332 1, /* size (0 = byte, 1 = short, 2 = long) */
333 16, /* bitsize */
334 false, /* pc_relative */
335 0, /* bitpos */
336 complain_overflow_dont, /* complain_on_overflow */
337 v850_elf_reloc, /* special_function */
338 "R_V850_TDA_16_16_OFFSET", /* name */
339 false, /* partial_inplace */
340 0xffff, /* src_mask */
341 0xfff, /* dst_mask */
342 false), /* pcrel_offset */
343
344 /* 5 bit offset from the tiny data area pointer. */
345 HOWTO (R_V850_TDA_4_5_OFFSET, /* type */
346 1, /* rightshift */
347 1, /* size (0 = byte, 1 = short, 2 = long) */
348 5, /* bitsize */
349 false, /* pc_relative */
350 0, /* bitpos */
351 complain_overflow_dont, /* complain_on_overflow */
352 v850_elf_reloc, /* special_function */
353 "R_V850_TDA_4_5_OFFSET", /* name */
354 false, /* partial_inplace */
355 0x0f, /* src_mask */
356 0x0f, /* dst_mask */
357 false), /* pcrel_offset */
358
359 /* 4 bit offset from the tiny data area pointer. */
360 HOWTO (R_V850_TDA_4_4_OFFSET, /* type */
361 0, /* rightshift */
362 1, /* size (0 = byte, 1 = short, 2 = long) */
363 4, /* bitsize */
364 false, /* pc_relative */
365 0, /* bitpos */
366 complain_overflow_dont, /* complain_on_overflow */
367 v850_elf_reloc, /* special_function */
368 "R_V850_TDA_4_4_OFFSET", /* name */
369 false, /* partial_inplace */
370 0x0f, /* src_mask */
371 0x0f, /* dst_mask */
372 false), /* pcrel_offset */
373
374 /* 16 bit offset from the short data area pointer. */
375 HOWTO (R_V850_SDA_16_16_SPLIT_OFFSET, /* type */
376 0, /* rightshift */
377 2, /* size (0 = byte, 1 = short, 2 = long) */
378 16, /* bitsize */
379 false, /* pc_relative */
380 0, /* bitpos */
381 complain_overflow_dont, /* complain_on_overflow */
382 v850_elf_reloc, /* special_function */
383 "R_V850_SDA_16_16_SPLIT_OFFSET",/* name */
384 false, /* partial_inplace */
385 0xfffe0020, /* src_mask */
386 0xfffe0020, /* dst_mask */
387 false), /* pcrel_offset */
388
389 /* 16 bit offset from the zero data area pointer. */
390 HOWTO (R_V850_ZDA_16_16_SPLIT_OFFSET, /* type */
391 0, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 16, /* bitsize */
394 false, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_dont, /* complain_on_overflow */
397 v850_elf_reloc, /* special_function */
398 "R_V850_ZDA_16_16_SPLIT_OFFSET",/* name */
399 false, /* partial_inplace */
400 0xfffe0020, /* src_mask */
401 0xfffe0020, /* dst_mask */
402 false), /* pcrel_offset */
403
404 /* 6 bit offset from the call table base pointer. */
405 HOWTO (R_V850_CALLT_6_7_OFFSET, /* type */
406 0, /* rightshift */
407 1, /* size (0 = byte, 1 = short, 2 = long) */
408 7, /* bitsize */
409 false, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_dont, /* complain_on_overflow */
412 v850_elf_reloc, /* special_function */
413 "R_V850_CALLT_6_7_OFFSET", /* name */
414 false, /* partial_inplace */
415 0x3f, /* src_mask */
416 0x3f, /* dst_mask */
417 false), /* pcrel_offset */
418
419 /* 16 bit offset from the call table base pointer. */
420 HOWTO (R_V850_CALLT_16_16_OFFSET, /* type */
421 0, /* rightshift */
422 1, /* size (0 = byte, 1 = short, 2 = long) */
423 16, /* bitsize */
424 false, /* pc_relative */
425 0, /* bitpos */
426 complain_overflow_dont, /* complain_on_overflow */
427 v850_elf_reloc, /* special_function */
428 "R_V850_CALLT_16_16_OFFSET", /* name */
429 false, /* partial_inplace */
430 0xffff, /* src_mask */
431 0xffff, /* dst_mask */
432 false), /* pcrel_offset */
433
434 /* GNU extension to record C++ vtable hierarchy */
435 HOWTO (R_V850_GNU_VTINHERIT, /* type */
436 0, /* rightshift */
437 2, /* size (0 = byte, 1 = short, 2 = long) */
438 0, /* bitsize */
439 false, /* pc_relative */
440 0, /* bitpos */
441 complain_overflow_dont, /* complain_on_overflow */
442 NULL, /* special_function */
443 "R_V850_GNU_VTINHERIT", /* name */
444 false, /* partial_inplace */
445 0, /* src_mask */
446 0, /* dst_mask */
447 false), /* pcrel_offset */
448
449 /* GNU extension to record C++ vtable member usage */
450 HOWTO (R_V850_GNU_VTENTRY, /* type */
451 0, /* rightshift */
452 2, /* size (0 = byte, 1 = short, 2 = long) */
453 0, /* bitsize */
454 false, /* pc_relative */
455 0, /* bitpos */
456 complain_overflow_dont, /* complain_on_overflow */
457 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
458 "R_V850_GNU_VTENTRY", /* name */
459 false, /* partial_inplace */
460 0, /* src_mask */
461 0, /* dst_mask */
462 false), /* pcrel_offset */
463
464 };
465
466 /* Map BFD reloc types to V850 ELF reloc types. */
467
468 struct v850_elf_reloc_map
469 {
470 /* BFD_RELOC_V850_CALLT_16_16_OFFSET is 258, which will not fix in an
471 unsigned char. */
472 bfd_reloc_code_real_type bfd_reloc_val;
473 unsigned char elf_reloc_val;
474 };
475
476 static const struct v850_elf_reloc_map v850_elf_reloc_map[] =
477 {
478 { BFD_RELOC_NONE, R_V850_NONE },
479 { BFD_RELOC_V850_9_PCREL, R_V850_9_PCREL },
480 { BFD_RELOC_V850_22_PCREL, R_V850_22_PCREL },
481 { BFD_RELOC_HI16_S, R_V850_HI16_S },
482 { BFD_RELOC_HI16, R_V850_HI16 },
483 { BFD_RELOC_LO16, R_V850_LO16 },
484 { BFD_RELOC_32, R_V850_32 },
485 { BFD_RELOC_16, R_V850_16 },
486 { BFD_RELOC_8, R_V850_8 },
487 { BFD_RELOC_V850_SDA_16_16_OFFSET, R_V850_SDA_16_16_OFFSET },
488 { BFD_RELOC_V850_SDA_15_16_OFFSET, R_V850_SDA_15_16_OFFSET },
489 { BFD_RELOC_V850_ZDA_16_16_OFFSET, R_V850_ZDA_16_16_OFFSET },
490 { BFD_RELOC_V850_ZDA_15_16_OFFSET, R_V850_ZDA_15_16_OFFSET },
491 { BFD_RELOC_V850_TDA_6_8_OFFSET, R_V850_TDA_6_8_OFFSET },
492 { BFD_RELOC_V850_TDA_7_8_OFFSET, R_V850_TDA_7_8_OFFSET },
493 { BFD_RELOC_V850_TDA_7_7_OFFSET, R_V850_TDA_7_7_OFFSET },
494 { BFD_RELOC_V850_TDA_16_16_OFFSET, R_V850_TDA_16_16_OFFSET },
495 { BFD_RELOC_V850_TDA_4_5_OFFSET, R_V850_TDA_4_5_OFFSET },
496 { BFD_RELOC_V850_TDA_4_4_OFFSET, R_V850_TDA_4_4_OFFSET },
497 { BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, R_V850_SDA_16_16_SPLIT_OFFSET },
498 { BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, R_V850_ZDA_16_16_SPLIT_OFFSET },
499 { BFD_RELOC_V850_CALLT_6_7_OFFSET, R_V850_CALLT_6_7_OFFSET },
500 { BFD_RELOC_V850_CALLT_16_16_OFFSET, R_V850_CALLT_16_16_OFFSET },
501 { BFD_RELOC_VTABLE_INHERIT, R_V850_GNU_VTINHERIT },
502 { BFD_RELOC_VTABLE_ENTRY, R_V850_GNU_VTENTRY },
503
504 };
505 \f
506 /* Map a bfd relocation into the appropriate howto structure */
507 static reloc_howto_type *
508 v850_elf_reloc_type_lookup (abfd, code)
509 bfd * abfd ATTRIBUTE_UNUSED;
510 bfd_reloc_code_real_type code;
511 {
512 unsigned int i;
513
514 for (i = 0;
515 i < sizeof (v850_elf_reloc_map) / sizeof (struct v850_elf_reloc_map);
516 i++)
517 {
518 if (v850_elf_reloc_map[i].bfd_reloc_val == code)
519 {
520 BFD_ASSERT (v850_elf_howto_table[v850_elf_reloc_map[i].elf_reloc_val].type == v850_elf_reloc_map[i].elf_reloc_val);
521
522 return & v850_elf_howto_table[v850_elf_reloc_map[i].elf_reloc_val];
523 }
524 }
525
526 return NULL;
527 }
528 \f
529 /* Set the howto pointer for an V850 ELF reloc. */
530 static void
531 v850_elf_info_to_howto_rel (abfd, cache_ptr, dst)
532 bfd * abfd ATTRIBUTE_UNUSED;
533 arelent * cache_ptr;
534 Elf32_Internal_Rel * dst;
535 {
536 unsigned int r_type;
537
538 r_type = ELF32_R_TYPE (dst->r_info);
539 BFD_ASSERT (r_type < (unsigned int) R_V850_max);
540 cache_ptr->howto = &v850_elf_howto_table[r_type];
541 }
542
543 /* Set the howto pointer for a V850 ELF reloc (type RELA). */
544 static void
545 v850_elf_info_to_howto_rela (abfd, cache_ptr, dst)
546 bfd * abfd ATTRIBUTE_UNUSED;
547 arelent * cache_ptr;
548 Elf32_Internal_Rela *dst;
549 {
550 unsigned int r_type;
551
552 r_type = ELF32_R_TYPE (dst->r_info);
553 BFD_ASSERT (r_type < (unsigned int) R_V850_max);
554 cache_ptr->howto = &v850_elf_howto_table[r_type];
555 }
556 \f
557 /* Look through the relocs for a section during the first phase, and
558 allocate space in the global offset table or procedure linkage
559 table. */
560
561 static boolean
562 v850_elf_check_relocs (abfd, info, sec, relocs)
563 bfd * abfd;
564 struct bfd_link_info * info;
565 asection * sec;
566 const Elf_Internal_Rela * relocs;
567 {
568 boolean ret = true;
569 bfd *dynobj;
570 Elf_Internal_Shdr *symtab_hdr;
571 struct elf_link_hash_entry **sym_hashes;
572 const Elf_Internal_Rela *rel;
573 const Elf_Internal_Rela *rel_end;
574 asection *sreloc;
575 enum v850_reloc_type r_type;
576 int other = 0;
577 const char *common = (const char *)0;
578
579 if (info->relocateable)
580 return true;
581
582 #ifdef DEBUG
583 fprintf (stderr, "v850_elf_check_relocs called for section %s in %s\n",
584 bfd_get_section_name (abfd, sec),
585 bfd_get_filename (abfd));
586 #endif
587
588 dynobj = elf_hash_table (info)->dynobj;
589 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
590 sym_hashes = elf_sym_hashes (abfd);
591 sreloc = NULL;
592
593 rel_end = relocs + sec->reloc_count;
594 for (rel = relocs; rel < rel_end; rel++)
595 {
596 unsigned long r_symndx;
597 struct elf_link_hash_entry *h;
598
599 r_symndx = ELF32_R_SYM (rel->r_info);
600 if (r_symndx < symtab_hdr->sh_info)
601 h = NULL;
602 else
603 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
604
605 r_type = (enum v850_reloc_type) ELF32_R_TYPE (rel->r_info);
606 switch (r_type)
607 {
608 default:
609 case R_V850_NONE:
610 case R_V850_9_PCREL:
611 case R_V850_22_PCREL:
612 case R_V850_HI16_S:
613 case R_V850_HI16:
614 case R_V850_LO16:
615 case R_V850_32:
616 case R_V850_16:
617 case R_V850_8:
618 case R_V850_CALLT_6_7_OFFSET:
619 case R_V850_CALLT_16_16_OFFSET:
620 break;
621
622 /* This relocation describes the C++ object vtable hierarchy.
623 Reconstruct it for later use during GC. */
624 case R_V850_GNU_VTINHERIT:
625 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
626 return false;
627 break;
628
629 /* This relocation describes which C++ vtable entries are actually
630 used. Record for later use during GC. */
631 case R_V850_GNU_VTENTRY:
632 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
633 return false;
634 break;
635
636 case R_V850_SDA_16_16_SPLIT_OFFSET:
637 case R_V850_SDA_16_16_OFFSET:
638 case R_V850_SDA_15_16_OFFSET:
639 other = V850_OTHER_SDA;
640 common = ".scommon";
641 goto small_data_common;
642
643 case R_V850_ZDA_16_16_SPLIT_OFFSET:
644 case R_V850_ZDA_16_16_OFFSET:
645 case R_V850_ZDA_15_16_OFFSET:
646 other = V850_OTHER_ZDA;
647 common = ".zcommon";
648 goto small_data_common;
649
650 case R_V850_TDA_4_5_OFFSET:
651 case R_V850_TDA_4_4_OFFSET:
652 case R_V850_TDA_6_8_OFFSET:
653 case R_V850_TDA_7_8_OFFSET:
654 case R_V850_TDA_7_7_OFFSET:
655 case R_V850_TDA_16_16_OFFSET:
656 other = V850_OTHER_TDA;
657 common = ".tcommon";
658 /* fall through */
659
660 #define V850_OTHER_MASK (V850_OTHER_TDA | V850_OTHER_SDA | V850_OTHER_ZDA)
661
662 small_data_common:
663 if (h)
664 {
665 h->other |= other; /* flag which type of relocation was used */
666 if ((h->other & V850_OTHER_MASK) != (other & V850_OTHER_MASK)
667 && (h->other & V850_OTHER_ERROR) == 0)
668 {
669 const char * msg;
670 static char buff[200]; /* XXX */
671
672 switch (h->other & V850_OTHER_MASK)
673 {
674 default:
675 msg = _("Variable `%s' cannot occupy in multiple small data regions");
676 break;
677 case V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA:
678 msg = _("Variable `%s' can only be in one of the small, zero, and tiny data regions");
679 break;
680 case V850_OTHER_SDA | V850_OTHER_ZDA:
681 msg = _("Variable `%s' cannot be in both small and zero data regions simultaneously");
682 break;
683 case V850_OTHER_SDA | V850_OTHER_TDA:
684 msg = _("Variable `%s' cannot be in both small and tiny data regions simultaneously");
685 break;
686 case V850_OTHER_ZDA | V850_OTHER_TDA:
687 msg = _("Variable `%s' cannot be in both zero and tiny data regions simultaneously");
688 break;
689 }
690
691 sprintf (buff, msg, h->root.root.string);
692 info->callbacks->warning (info, buff, h->root.root.string,
693 abfd, h->root.u.def.section, 0);
694
695 bfd_set_error (bfd_error_bad_value);
696 h->other |= V850_OTHER_ERROR;
697 ret = false;
698 }
699 }
700
701 if (h && h->root.type == bfd_link_hash_common
702 && h->root.u.c.p
703 && !strcmp (bfd_get_section_name (abfd, h->root.u.c.p->section), "COMMON"))
704 {
705 asection *section = h->root.u.c.p->section = bfd_make_section_old_way (abfd, common);
706 section->flags |= SEC_IS_COMMON;
707 }
708
709 #ifdef DEBUG
710 fprintf (stderr, "v850_elf_check_relocs, found %s relocation for %s%s\n",
711 v850_elf_howto_table[ (int)r_type ].name,
712 (h && h->root.root.string) ? h->root.root.string : "<unknown>",
713 (h->root.type == bfd_link_hash_common) ? ", symbol is common" : "");
714 #endif
715 break;
716 }
717 }
718
719 return ret;
720 }
721
722 /*
723 * In the old version, when an entry was checked out from the table,
724 * it was deleted. This produced an error if the entry was needed
725 * more than once, as the second attempted retry failed.
726 *
727 * In the current version, the entry is not deleted, instead we set
728 * the field 'found' to true. If a second lookup matches the same
729 * entry, then we know that the hi16s reloc has already been updated
730 * and does not need to be updated a second time.
731 *
732 * TODO - TOFIX: If it is possible that we need to restore 2 different
733 * addresses from the same table entry, where the first generates an
734 * overflow, whilst the second do not, then this code will fail.
735 */
736
737 typedef struct hi16s_location
738 {
739 bfd_vma addend;
740 bfd_byte * address;
741 unsigned long counter;
742 boolean found;
743 struct hi16s_location * next;
744 }
745 hi16s_location;
746
747 static hi16s_location * previous_hi16s;
748 static hi16s_location * free_hi16s;
749 static unsigned long hi16s_counter;
750
751 static void
752 remember_hi16s_reloc (abfd, addend, address)
753 bfd * abfd;
754 bfd_vma addend;
755 bfd_byte * address;
756 {
757 hi16s_location * entry = NULL;
758
759 /* Find a free structure. */
760 if (free_hi16s == NULL)
761 free_hi16s = (hi16s_location *) bfd_zalloc (abfd, sizeof (* free_hi16s));
762
763 entry = free_hi16s;
764 free_hi16s = free_hi16s->next;
765
766 entry->addend = addend;
767 entry->address = address;
768 entry->counter = hi16s_counter ++;
769 entry->found = false;
770 entry->next = previous_hi16s;
771 previous_hi16s = entry;
772
773 /* Cope with wrap around of our counter. */
774 if (hi16s_counter == 0)
775 {
776 /* XXX - Assume that all counter entries differ only in their low 16 bits. */
777 for (entry = previous_hi16s; entry != NULL; entry = entry->next)
778 entry->counter &= 0xffff;
779
780 hi16s_counter = 0x10000;
781 }
782
783 return;
784 }
785
786 static bfd_byte *
787 find_remembered_hi16s_reloc (addend, already_found)
788 bfd_vma addend;
789 boolean * already_found;
790 {
791 hi16s_location * match = NULL;
792 hi16s_location * entry;
793 hi16s_location * previous = NULL;
794 hi16s_location * prev;
795 bfd_byte * addr;
796
797 /* Search the table. Record the most recent entry that matches. */
798 for (entry = previous_hi16s; entry; entry = entry->next)
799 {
800 if (entry->addend == addend
801 && (match == NULL || match->counter < entry->counter))
802 {
803 previous = prev;
804 match = entry;
805 }
806
807 prev = entry;
808 }
809
810 if (match == NULL)
811 return NULL;
812
813 /* Extract the address. */
814 addr = match->address;
815
816 /* Remeber if this entry has already been used before. */
817 if (already_found)
818 * already_found = match->found;
819
820 /* Note that this entry has now been used. */
821 match->found = true;
822
823 return addr;
824 }
825
826 /* FIXME: The code here probably ought to be removed and the code in reloc.c
827 allowed to do its stuff instead. At least for most of the relocs, anwyay. */
828 static bfd_reloc_status_type
829 v850_elf_perform_relocation (abfd, r_type, addend, address)
830 bfd * abfd;
831 int r_type;
832 bfd_vma addend;
833 bfd_byte * address;
834 {
835 unsigned long insn;
836 bfd_signed_vma saddend = (bfd_signed_vma) addend;
837
838 switch (r_type)
839 {
840 default:
841 /* fprintf (stderr, "reloc type %d not SUPPORTED\n", r_type ); */
842 return bfd_reloc_notsupported;
843
844 case R_V850_32:
845 bfd_put_32 (abfd, addend, address);
846 return bfd_reloc_ok;
847
848 case R_V850_22_PCREL:
849 if (saddend > 0x1fffff || saddend < -0x200000)
850 return bfd_reloc_overflow;
851
852 if ((addend % 2) != 0)
853 return bfd_reloc_dangerous;
854
855 insn = bfd_get_32 (abfd, address);
856 insn &= ~0xfffe003f;
857 insn |= (((addend & 0xfffe) << 16) | ((addend & 0x3f0000) >> 16));
858 bfd_put_32 (abfd, insn, address);
859 return bfd_reloc_ok;
860
861 case R_V850_9_PCREL:
862 if (saddend > 0xff || saddend < -0x100)
863 return bfd_reloc_overflow;
864
865 if ((addend % 2) != 0)
866 return bfd_reloc_dangerous;
867
868 insn = bfd_get_16 (abfd, address);
869 insn &= ~ 0xf870;
870 insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3);
871 break;
872
873 case R_V850_HI16:
874 addend += (bfd_get_16 (abfd, address) << 16);
875 addend = (addend >> 16);
876 insn = addend;
877 break;
878
879 case R_V850_HI16_S:
880 /* Remember where this relocation took place. */
881 remember_hi16s_reloc (abfd, addend, address);
882
883 addend += (bfd_get_16 (abfd, address) << 16);
884 addend = (addend >> 16) + ((addend & 0x8000) != 0);
885
886 /* This relocation cannot overflow. */
887 if (addend > 0x7fff)
888 addend = 0;
889
890 insn = addend;
891 break;
892
893 case R_V850_LO16:
894 /* Calculate the sum of the value stored in the instruction and the
895 addend and check for overflow from the low 16 bits into the high
896 16 bits. The assembler has already done some of this: If the
897 value stored in the instruction has its 15th bit set, (counting
898 from zero) then the assembler will have added 1 to the value
899 stored in the associated HI16S reloc. So for example, these
900 relocations:
901
902 movhi hi( fred ), r0, r1
903 movea lo( fred ), r1, r1
904
905 will store 0 in the value fields for the MOVHI and MOVEA instructions
906 and addend will be the address of fred, but for these instructions:
907
908 movhi hi( fred + 0x123456), r0, r1
909 movea lo( fred + 0x123456), r1, r1
910
911 the value stored in the MOVHI instruction will be 0x12 and the value
912 stored in the MOVEA instruction will be 0x3456. If however the
913 instructions were:
914
915 movhi hi( fred + 0x10ffff), r0, r1
916 movea lo( fred + 0x10ffff), r1, r1
917
918 then the value stored in the MOVHI instruction would be 0x11 (not
919 0x10) and the value stored in the MOVEA instruction would be 0xffff.
920 Thus (assuming for the moment that the addend is 0), at run time the
921 MOVHI instruction loads 0x110000 into r1, then the MOVEA instruction
922 adds 0xffffffff (sign extension!) producing 0x10ffff. Similarly if
923 the instructions were:
924
925 movhi hi( fred - 1), r0, r1
926 movea lo( fred - 1), r1, r1
927
928 then 0 is stored in the MOVHI instruction and -1 is stored in the
929 MOVEA instruction.
930
931 Overflow can occur if the addition of the value stored in the
932 instruction plus the addend sets the 15th bit when before it was clear.
933 This is because the 15th bit will be sign extended into the high part,
934 thus reducing its value by one, but since the 15th bit was originally
935 clear, the assembler will not have added 1 to the previous HI16S reloc
936 to compensate for this effect. For example:
937
938 movhi hi( fred + 0x123456), r0, r1
939 movea lo( fred + 0x123456), r1, r1
940
941 The value stored in HI16S reloc is 0x12, the value stored in the LO16
942 reloc is 0x3456. If we assume that the address of fred is 0x00007000
943 then the relocations become:
944
945 HI16S: 0x0012 + (0x00007000 >> 16) = 0x12
946 LO16: 0x3456 + (0x00007000 & 0xffff) = 0xa456
947
948 but when the instructions are executed, the MOVEA instruction's value
949 is signed extended, so the sum becomes:
950
951 0x00120000
952 + 0xffffa456
953 ------------
954 0x0011a456 but 'fred + 0x123456' = 0x0012a456
955
956 Note that if the 15th bit was set in the value stored in the LO16
957 reloc, then we do not have to do anything:
958
959 movhi hi( fred + 0x10ffff), r0, r1
960 movea lo( fred + 0x10ffff), r1, r1
961
962 HI16S: 0x0011 + (0x00007000 >> 16) = 0x11
963 LO16: 0xffff + (0x00007000 & 0xffff) = 0x6fff
964
965 0x00110000
966 + 0x00006fff
967 ------------
968 0x00116fff = fred + 0x10ffff = 0x7000 + 0x10ffff
969
970 Overflow can also occur if the computation carries into the 16th bit
971 and it also results in the 15th bit having the same value as the 15th
972 bit of the original value. What happens is that the HI16S reloc
973 will have already examined the 15th bit of the original value and
974 added 1 to the high part if the bit is set. This compensates for the
975 sign extension of 15th bit of the result of the computation. But now
976 there is a carry into the 16th bit, and this has not been allowed for.
977
978 So, for example if fred is at address 0xf000:
979
980 movhi hi( fred + 0xffff), r0, r1 [bit 15 of the offset is set]
981 movea lo( fred + 0xffff), r1, r1
982
983 HI16S: 0x0001 + (0x0000f000 >> 16) = 0x0001
984 LO16: 0xffff + (0x0000f000 & 0xffff) = 0xefff (carry into bit 16 is lost)
985
986 0x00010000
987 + 0xffffefff
988 ------------
989 0x0000efff but 'fred + 0xffff' = 0x0001efff
990
991 Similarly, if the 15th bit remains clear, but overflow occurs into
992 the 16th bit then (assuming the address of fred is 0xf000):
993
994 movhi hi( fred + 0x7000), r0, r1 [bit 15 of the offset is clear]
995 movea lo( fred + 0x7000), r1, r1
996
997 HI16S: 0x0000 + (0x0000f000 >> 16) = 0x0000
998 LO16: 0x7000 + (0x0000f000 & 0xffff) = 0x6fff (carry into bit 16 is lost)
999
1000 0x00000000
1001 + 0x00006fff
1002 ------------
1003 0x00006fff but 'fred + 0x7000' = 0x00016fff
1004
1005 Note - there is no need to change anything if a carry occurs, and the
1006 15th bit changes its value from being set to being clear, as the HI16S
1007 reloc will have already added in 1 to the high part for us:
1008
1009 movhi hi( fred + 0xffff), r0, r1 [bit 15 of the offset is set]
1010 movea lo( fred + 0xffff), r1, r1
1011
1012 HI16S: 0x0001 + (0x00007000 >> 16)
1013 LO16: 0xffff + (0x00007000 & 0xffff) = 0x6fff (carry into bit 16 is lost)
1014
1015 0x00010000
1016 + 0x00006fff (bit 15 not set, so the top half is zero)
1017 ------------
1018 0x00016fff which is right (assuming that fred is at 0x7000)
1019
1020 but if the 15th bit goes from being clear to being set, then we must
1021 once again handle overflow:
1022
1023 movhi hi( fred + 0x7000), r0, r1 [bit 15 of the offset is clear]
1024 movea lo( fred + 0x7000), r1, r1
1025
1026 HI16S: 0x0000 + (0x0000ffff >> 16)
1027 LO16: 0x7000 + (0x0000ffff & 0xffff) = 0x6fff (carry into bit 16)
1028
1029 0x00000000
1030 + 0x00006fff (bit 15 not set, so the top half is zero)
1031 ------------
1032 0x00006fff which is wrong (assuming that fred is at 0xffff)
1033 */
1034
1035 {
1036 long result;
1037
1038 insn = bfd_get_16 (abfd, address);
1039 result = insn + addend;
1040
1041 #define BIT15_SET(x) ((x) & 0x8000)
1042 #define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff)
1043
1044 if ((BIT15_SET (result) && ! BIT15_SET (addend))
1045 || (OVERFLOWS (addend, insn)
1046 && ((! BIT15_SET (insn)) || (BIT15_SET (addend)))))
1047 {
1048 boolean already_updated;
1049 bfd_byte * hi16s_address = find_remembered_hi16s_reloc
1050 (addend, & already_updated);
1051
1052 /* Amend the matching HI16_S relocation. */
1053 if (hi16s_address != NULL)
1054 {
1055 if (! already_updated)
1056 {
1057 insn = bfd_get_16 (abfd, hi16s_address);
1058 insn += 1;
1059 bfd_put_16 (abfd, insn, hi16s_address);
1060 }
1061 }
1062 else
1063 {
1064 fprintf (stderr, _("FAILED to find previous HI16 reloc\n"));
1065 return bfd_reloc_overflow;
1066 }
1067 }
1068
1069 /* Do not complain if value has top bit set, as this has been anticipated. */
1070 insn = result & 0xffff;
1071 break;
1072 }
1073
1074 case R_V850_8:
1075 addend += (char) bfd_get_8 (abfd, address);
1076
1077 saddend = (bfd_signed_vma) addend;
1078
1079 if (saddend > 0x7f || saddend < -0x80)
1080 return bfd_reloc_overflow;
1081
1082 bfd_put_8 (abfd, addend, address);
1083 return bfd_reloc_ok;
1084
1085 case R_V850_CALLT_16_16_OFFSET:
1086 addend += bfd_get_16 (abfd, address);
1087
1088 saddend = (bfd_signed_vma) addend;
1089
1090 if (saddend > 0xffff || saddend < 0)
1091 return bfd_reloc_overflow;
1092
1093 insn = addend;
1094 break;
1095
1096 case R_V850_16:
1097
1098 /* drop through */
1099 case R_V850_SDA_16_16_OFFSET:
1100 case R_V850_ZDA_16_16_OFFSET:
1101 case R_V850_TDA_16_16_OFFSET:
1102 addend += bfd_get_16 (abfd, address);
1103
1104 saddend = (bfd_signed_vma) addend;
1105
1106 if (saddend > 0x7fff || saddend < -0x8000)
1107 return bfd_reloc_overflow;
1108
1109 insn = addend;
1110 break;
1111
1112 case R_V850_SDA_15_16_OFFSET:
1113 case R_V850_ZDA_15_16_OFFSET:
1114 insn = bfd_get_16 (abfd, address);
1115 addend += (insn & 0xfffe);
1116
1117 saddend = (bfd_signed_vma) addend;
1118
1119 if (saddend > 0x7ffe || saddend < -0x8000)
1120 return bfd_reloc_overflow;
1121
1122 if (addend & 1)
1123 return bfd_reloc_dangerous;
1124
1125 insn = (addend & ~1) | (insn & 1);
1126 break;
1127
1128 case R_V850_TDA_6_8_OFFSET:
1129 insn = bfd_get_16 (abfd, address);
1130 addend += ((insn & 0x7e) << 1);
1131
1132 saddend = (bfd_signed_vma) addend;
1133
1134 if (saddend > 0xfc || saddend < 0)
1135 return bfd_reloc_overflow;
1136
1137 if (addend & 3)
1138 return bfd_reloc_dangerous;
1139
1140 insn &= 0xff81;
1141 insn |= (addend >> 1);
1142 break;
1143
1144 case R_V850_TDA_7_8_OFFSET:
1145 insn = bfd_get_16 (abfd, address);
1146 addend += ((insn & 0x7f) << 1);
1147
1148 saddend = (bfd_signed_vma) addend;
1149
1150 if (saddend > 0xfe || saddend < 0)
1151 return bfd_reloc_overflow;
1152
1153 if (addend & 1)
1154 return bfd_reloc_dangerous;
1155
1156 insn &= 0xff80;
1157 insn |= (addend >> 1);
1158 break;
1159
1160 case R_V850_TDA_7_7_OFFSET:
1161 insn = bfd_get_16 (abfd, address);
1162 addend += insn & 0x7f;
1163
1164 saddend = (bfd_signed_vma) addend;
1165
1166 if (saddend > 0x7f || saddend < 0)
1167 return bfd_reloc_overflow;
1168
1169 insn &= 0xff80;
1170 insn |= addend;
1171 break;
1172
1173 case R_V850_TDA_4_5_OFFSET:
1174 insn = bfd_get_16 (abfd, address);
1175 addend += ((insn & 0xf) << 1);
1176
1177 saddend = (bfd_signed_vma) addend;
1178
1179 if (saddend > 0x1e || saddend < 0)
1180 return bfd_reloc_overflow;
1181
1182 if (addend & 1)
1183 return bfd_reloc_dangerous;
1184
1185 insn &= 0xfff0;
1186 insn |= (addend >> 1);
1187 break;
1188
1189 case R_V850_TDA_4_4_OFFSET:
1190 insn = bfd_get_16 (abfd, address);
1191 addend += insn & 0xf;
1192
1193 saddend = (bfd_signed_vma) addend;
1194
1195 if (saddend > 0xf || saddend < 0)
1196 return bfd_reloc_overflow;
1197
1198 insn &= 0xfff0;
1199 insn |= addend;
1200 break;
1201
1202 case R_V850_ZDA_16_16_SPLIT_OFFSET:
1203 case R_V850_SDA_16_16_SPLIT_OFFSET:
1204 insn = bfd_get_32 (abfd, address);
1205 addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5);
1206
1207 saddend = (bfd_signed_vma) addend;
1208
1209 if (saddend > 0x7fff || saddend < -0x8000)
1210 return bfd_reloc_overflow;
1211
1212 insn &= 0x0001ffdf;
1213 insn |= (addend & 1) << 5;
1214 insn |= (addend & ~1) << 16;
1215
1216 bfd_put_32 (abfd, insn, address);
1217 return bfd_reloc_ok;
1218
1219 case R_V850_CALLT_6_7_OFFSET:
1220 insn = bfd_get_16 (abfd, address);
1221 addend += ((insn & 0x3f) << 1);
1222
1223 saddend = (bfd_signed_vma) addend;
1224
1225 if (saddend > 0x7e || saddend < 0)
1226 return bfd_reloc_overflow;
1227
1228 if (addend & 1)
1229 return bfd_reloc_dangerous;
1230
1231 insn &= 0xff80;
1232 insn |= (addend >> 1);
1233 break;
1234
1235 case R_V850_GNU_VTINHERIT:
1236 case R_V850_GNU_VTENTRY:
1237 return bfd_reloc_ok;
1238
1239 }
1240
1241 bfd_put_16 (abfd, insn, address);
1242 return bfd_reloc_ok;
1243 }
1244 \f
1245 /* Insert the addend into the instruction. */
1246 static bfd_reloc_status_type
1247 v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
1248 bfd * abfd ATTRIBUTE_UNUSED;
1249 arelent * reloc;
1250 asymbol * symbol;
1251 PTR data ATTRIBUTE_UNUSED;
1252 asection * isection;
1253 bfd * obfd;
1254 char ** err ATTRIBUTE_UNUSED;
1255 {
1256 long relocation;
1257
1258 /* If there is an output BFD,
1259 and the symbol is not a section name (which is only defined at final link time),
1260 and either we are not putting the addend into the instruction
1261 or the addend is zero, so there is nothing to add into the instruction
1262 then just fixup the address and return. */
1263 if (obfd != (bfd *) NULL
1264 && (symbol->flags & BSF_SECTION_SYM) == 0
1265 && (! reloc->howto->partial_inplace
1266 || reloc->addend == 0))
1267 {
1268 reloc->address += isection->output_offset;
1269 return bfd_reloc_ok;
1270 }
1271 #if 0
1272 else if (obfd != NULL)
1273 {
1274 return bfd_reloc_continue;
1275 }
1276 #endif
1277
1278 /* Catch relocs involving undefined symbols. */
1279 if (bfd_is_und_section (symbol->section)
1280 && (symbol->flags & BSF_WEAK) == 0
1281 && obfd == NULL)
1282 return bfd_reloc_undefined;
1283
1284 /* We handle final linking of some relocs ourselves. */
1285
1286 /* Is the address of the relocation really within the section? */
1287 if (reloc->address > isection->_cooked_size)
1288 return bfd_reloc_outofrange;
1289
1290 /* Work out which section the relocation is targetted at and the
1291 initial relocation command value. */
1292
1293 /* Get symbol value. (Common symbols are special.) */
1294 if (bfd_is_com_section (symbol->section))
1295 relocation = 0;
1296 else
1297 relocation = symbol->value;
1298
1299 /* Convert input-section-relative symbol value to absolute + addend. */
1300 relocation += symbol->section->output_section->vma;
1301 relocation += symbol->section->output_offset;
1302 relocation += reloc->addend;
1303
1304 #if 0 /* Since this reloc is going to be processed later on, we should
1305 not make it pc-relative here. To test this, try assembling and
1306 linking this program:
1307
1308 .text
1309 .globl _start
1310 nop
1311 _start:
1312 jr foo
1313
1314 .section ".foo","ax"
1315 nop
1316 foo:
1317 nop
1318 */
1319 if (reloc->howto->pc_relative == true)
1320 {
1321 /* Here the variable relocation holds the final address of the
1322 symbol we are relocating against, plus any addend. */
1323 relocation -= isection->output_section->vma + isection->output_offset;
1324
1325 /* Deal with pcrel_offset */
1326 relocation -= reloc->address;
1327 }
1328 #endif
1329 reloc->addend = relocation;
1330 return bfd_reloc_ok;
1331 }
1332 \f
1333 static boolean
1334 v850_elf_is_local_label_name (abfd, name)
1335 bfd * abfd ATTRIBUTE_UNUSED;
1336 const char * name;
1337 {
1338 return ( (name[0] == '.' && (name[1] == 'L' || name[1] == '.'))
1339 || (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_'));
1340 }
1341 \f
1342 /* Perform a relocation as part of a final link. */
1343 static bfd_reloc_status_type
1344 v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1345 input_section, contents, offset, value,
1346 addend, info, sym_sec, is_local)
1347 reloc_howto_type * howto;
1348 bfd * input_bfd;
1349 bfd * output_bfd ATTRIBUTE_UNUSED;
1350 asection * input_section;
1351 bfd_byte * contents;
1352 bfd_vma offset;
1353 bfd_vma value;
1354 bfd_vma addend;
1355 struct bfd_link_info * info;
1356 asection * sym_sec;
1357 int is_local ATTRIBUTE_UNUSED;
1358 {
1359 unsigned long r_type = howto->type;
1360 bfd_byte * hit_data = contents + offset;
1361
1362 /* Adjust the value according to the relocation. */
1363 switch (r_type)
1364 {
1365 case R_V850_9_PCREL:
1366 value -= (input_section->output_section->vma
1367 + input_section->output_offset);
1368 value -= offset;
1369 break;
1370
1371 case R_V850_22_PCREL:
1372 value -= (input_section->output_section->vma
1373 + input_section->output_offset
1374 + offset);
1375
1376 /* If the sign extension will corrupt the value then we have overflowed. */
1377 if (((value & 0xff000000) != 0x0) && ((value & 0xff000000) != 0xff000000))
1378 return bfd_reloc_overflow;
1379
1380 value = SEXT24 (value); /* Only the bottom 24 bits of the PC are valid */
1381 break;
1382
1383 case R_V850_HI16_S:
1384 case R_V850_HI16:
1385 case R_V850_LO16:
1386 case R_V850_16:
1387 case R_V850_32:
1388 case R_V850_8:
1389 break;
1390
1391 case R_V850_ZDA_15_16_OFFSET:
1392 case R_V850_ZDA_16_16_OFFSET:
1393 case R_V850_ZDA_16_16_SPLIT_OFFSET:
1394 if (sym_sec == NULL)
1395 return bfd_reloc_undefined;
1396
1397 value -= sym_sec->output_section->vma;
1398 break;
1399
1400 case R_V850_SDA_15_16_OFFSET:
1401 case R_V850_SDA_16_16_OFFSET:
1402 case R_V850_SDA_16_16_SPLIT_OFFSET:
1403 {
1404 unsigned long gp;
1405 struct bfd_link_hash_entry * h;
1406
1407 if (sym_sec == NULL)
1408 return bfd_reloc_undefined;
1409
1410 /* Get the value of __gp. */
1411 h = bfd_link_hash_lookup (info->hash, "__gp", false, false, true);
1412 if (h == (struct bfd_link_hash_entry *) NULL
1413 || h->type != bfd_link_hash_defined)
1414 return bfd_reloc_other;
1415
1416 gp = (h->u.def.value
1417 + h->u.def.section->output_section->vma
1418 + h->u.def.section->output_offset);
1419
1420 value -= sym_sec->output_section->vma;
1421 value -= (gp - sym_sec->output_section->vma);
1422 }
1423 break;
1424
1425 case R_V850_TDA_4_4_OFFSET:
1426 case R_V850_TDA_4_5_OFFSET:
1427 case R_V850_TDA_16_16_OFFSET:
1428 case R_V850_TDA_7_7_OFFSET:
1429 case R_V850_TDA_7_8_OFFSET:
1430 case R_V850_TDA_6_8_OFFSET:
1431 {
1432 unsigned long ep;
1433 struct bfd_link_hash_entry * h;
1434
1435 /* Get the value of __ep. */
1436 h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1437 if (h == (struct bfd_link_hash_entry *) NULL
1438 || h->type != bfd_link_hash_defined)
1439 return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
1440
1441 ep = (h->u.def.value
1442 + h->u.def.section->output_section->vma
1443 + h->u.def.section->output_offset);
1444
1445 value -= ep;
1446 }
1447 break;
1448
1449 case R_V850_CALLT_6_7_OFFSET:
1450 {
1451 unsigned long ctbp;
1452 struct bfd_link_hash_entry * h;
1453
1454 /* Get the value of __ctbp. */
1455 h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
1456 if (h == (struct bfd_link_hash_entry *) NULL
1457 || h->type != bfd_link_hash_defined)
1458 return (bfd_reloc_dangerous + 1); /* Actually this indicates that __ctbp could not be found. */
1459
1460 ctbp = (h->u.def.value
1461 + h->u.def.section->output_section->vma
1462 + h->u.def.section->output_offset);
1463 value -= ctbp;
1464 }
1465 break;
1466
1467 case R_V850_CALLT_16_16_OFFSET:
1468 {
1469 unsigned long ctbp;
1470 struct bfd_link_hash_entry * h;
1471
1472 if (sym_sec == NULL)
1473 return bfd_reloc_undefined;
1474
1475 /* Get the value of __ctbp. */
1476 h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
1477 if (h == (struct bfd_link_hash_entry *) NULL
1478 || h->type != bfd_link_hash_defined)
1479 return (bfd_reloc_dangerous + 1);
1480
1481 ctbp = (h->u.def.value
1482 + h->u.def.section->output_section->vma
1483 + h->u.def.section->output_offset);
1484
1485 value -= sym_sec->output_section->vma;
1486 value -= (ctbp - sym_sec->output_section->vma);
1487 }
1488 break;
1489
1490 case R_V850_NONE:
1491 case R_V850_GNU_VTINHERIT:
1492 case R_V850_GNU_VTENTRY:
1493 return bfd_reloc_ok;
1494
1495 default:
1496 return bfd_reloc_notsupported;
1497 }
1498
1499 /* Perform the relocation. */
1500 return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
1501 }
1502 \f
1503 /* Relocate an V850 ELF section. */
1504 static boolean
1505 v850_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1506 contents, relocs, local_syms, local_sections)
1507 bfd * output_bfd;
1508 struct bfd_link_info * info;
1509 bfd * input_bfd;
1510 asection * input_section;
1511 bfd_byte * contents;
1512 Elf_Internal_Rela * relocs;
1513 Elf_Internal_Sym * local_syms;
1514 asection ** local_sections;
1515 {
1516 Elf_Internal_Shdr * symtab_hdr;
1517 struct elf_link_hash_entry ** sym_hashes;
1518 Elf_Internal_Rela * rel;
1519 Elf_Internal_Rela * relend;
1520
1521 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1522 sym_hashes = elf_sym_hashes (input_bfd);
1523
1524 if (sym_hashes == NULL)
1525 {
1526 info->callbacks->warning
1527 (info, "no hash table available", NULL, input_bfd, input_section, 0);
1528
1529 return false;
1530 }
1531
1532 /* Reset the list of remembered HI16S relocs to empty. */
1533 free_hi16s = previous_hi16s;
1534 previous_hi16s = NULL;
1535 hi16s_counter = 0;
1536
1537 rel = relocs;
1538 relend = relocs + input_section->reloc_count;
1539 for (; rel < relend; rel++)
1540 {
1541 int r_type;
1542 reloc_howto_type * howto;
1543 unsigned long r_symndx;
1544 Elf_Internal_Sym * sym;
1545 asection * sec;
1546 struct elf_link_hash_entry * h;
1547 bfd_vma relocation;
1548 bfd_reloc_status_type r;
1549
1550 r_symndx = ELF32_R_SYM (rel->r_info);
1551 r_type = ELF32_R_TYPE (rel->r_info);
1552
1553 if (r_type == R_V850_GNU_VTENTRY
1554 || r_type == R_V850_GNU_VTINHERIT)
1555 continue;
1556
1557 howto = v850_elf_howto_table + r_type;
1558
1559 if (info->relocateable)
1560 {
1561 /* This is a relocateable link. We don't have to change
1562 anything, unless the reloc is against a section symbol,
1563 in which case we have to adjust according to where the
1564 section symbol winds up in the output section. */
1565 if (r_symndx < symtab_hdr->sh_info)
1566 {
1567 sym = local_syms + r_symndx;
1568 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1569 {
1570 sec = local_sections[r_symndx];
1571 rel->r_addend += sec->output_offset + sym->st_value;
1572 }
1573 }
1574
1575 continue;
1576 }
1577
1578 /* This is a final link. */
1579 h = NULL;
1580 sym = NULL;
1581 sec = NULL;
1582 if (r_symndx < symtab_hdr->sh_info)
1583 {
1584 sym = local_syms + r_symndx;
1585 sec = local_sections[r_symndx];
1586 relocation = (sec->output_section->vma
1587 + sec->output_offset
1588 + sym->st_value);
1589 #if 0
1590 {
1591 char * name;
1592 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name);
1593 name = (name == NULL) ? "<none>" : name;
1594 fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
1595 sec->name, name, sym->st_name,
1596 sec->output_section->vma, sec->output_offset, sym->st_value, rel->r_addend);
1597 }
1598 #endif
1599 }
1600 else
1601 {
1602 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1603
1604 while (h->root.type == bfd_link_hash_indirect
1605 || h->root.type == bfd_link_hash_warning)
1606 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1607
1608 if (h->root.type == bfd_link_hash_defined
1609 || h->root.type == bfd_link_hash_defweak)
1610 {
1611 sec = h->root.u.def.section;
1612 relocation = (h->root.u.def.value
1613 + sec->output_section->vma
1614 + sec->output_offset);
1615 #if 0
1616 fprintf (stderr, "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
1617 sec->name, h->root.root.string, h->root.u.def.value, sec->output_section->vma, sec->output_offset, relocation);
1618 #endif
1619 }
1620 else if (h->root.type == bfd_link_hash_undefweak)
1621 {
1622 #if 0
1623 fprintf (stderr, "undefined: sec: %s, name: %s\n",
1624 sec->name, h->root.root.string);
1625 #endif
1626 relocation = 0;
1627 }
1628 else
1629 {
1630 if (! ((*info->callbacks->undefined_symbol)
1631 (info, h->root.root.string, input_bfd,
1632 input_section, rel->r_offset, true)))
1633 return false;
1634 #if 0
1635 fprintf (stderr, "unknown: name: %s\n", h->root.root.string);
1636 #endif
1637 relocation = 0;
1638 }
1639 }
1640
1641 /* FIXME: We should use the addend, but the COFF relocations
1642 don't. */
1643 r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1644 input_section,
1645 contents, rel->r_offset,
1646 relocation, rel->r_addend,
1647 info, sec, h == NULL);
1648
1649 if (r != bfd_reloc_ok)
1650 {
1651 const char * name;
1652 const char * msg = (const char *)0;
1653
1654 if (h != NULL)
1655 name = h->root.root.string;
1656 else
1657 {
1658 name = (bfd_elf_string_from_elf_section
1659 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1660 if (name == NULL || *name == '\0')
1661 name = bfd_section_name (input_bfd, sec);
1662 }
1663
1664 switch (r)
1665 {
1666 case bfd_reloc_overflow:
1667 if (! ((*info->callbacks->reloc_overflow)
1668 (info, name, howto->name, (bfd_vma) 0,
1669 input_bfd, input_section, rel->r_offset)))
1670 return false;
1671 break;
1672
1673 case bfd_reloc_undefined:
1674 if (! ((*info->callbacks->undefined_symbol)
1675 (info, name, input_bfd, input_section,
1676 rel->r_offset, true)))
1677 return false;
1678 break;
1679
1680 case bfd_reloc_outofrange:
1681 msg = _("internal error: out of range error");
1682 goto common_error;
1683
1684 case bfd_reloc_notsupported:
1685 msg = _("internal error: unsupported relocation error");
1686 goto common_error;
1687
1688 case bfd_reloc_dangerous:
1689 msg = _("internal error: dangerous relocation");
1690 goto common_error;
1691
1692 case bfd_reloc_other:
1693 msg = _("could not locate special linker symbol __gp");
1694 goto common_error;
1695
1696 case bfd_reloc_continue:
1697 msg = _("could not locate special linker symbol __ep");
1698 goto common_error;
1699
1700 case (bfd_reloc_dangerous + 1):
1701 msg = _("could not locate special linker symbol __ctbp");
1702 goto common_error;
1703
1704 default:
1705 msg = _("internal error: unknown error");
1706 /* fall through */
1707
1708 common_error:
1709 if (!((*info->callbacks->warning)
1710 (info, msg, name, input_bfd, input_section,
1711 rel->r_offset)))
1712 return false;
1713 break;
1714 }
1715 }
1716 }
1717
1718 return true;
1719 }
1720
1721 static boolean
1722 v850_elf_gc_sweep_hook (abfd, info, sec, relocs)
1723 bfd *abfd ATTRIBUTE_UNUSED;
1724 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1725 asection *sec ATTRIBUTE_UNUSED;
1726 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
1727 {
1728 /* No got and plt entries for v850-elf */
1729 return true;
1730 }
1731
1732 static asection *
1733 v850_elf_gc_mark_hook (abfd, info, rel, h, sym)
1734 bfd *abfd;
1735 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1736 Elf_Internal_Rela *rel;
1737 struct elf_link_hash_entry *h;
1738 Elf_Internal_Sym *sym;
1739 {
1740 if (h != NULL)
1741 {
1742 switch (ELF32_R_TYPE (rel->r_info))
1743 {
1744 case R_V850_GNU_VTINHERIT:
1745 case R_V850_GNU_VTENTRY:
1746 break;
1747
1748 default:
1749 switch (h->root.type)
1750 {
1751 case bfd_link_hash_defined:
1752 case bfd_link_hash_defweak:
1753 return h->root.u.def.section;
1754
1755 case bfd_link_hash_common:
1756 return h->root.u.c.p->section;
1757
1758 default:
1759 break;
1760 }
1761 }
1762 }
1763 else
1764 {
1765 if (!(elf_bad_symtab (abfd)
1766 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1767 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1768 && sym->st_shndx != SHN_COMMON))
1769 {
1770 return bfd_section_from_elf_index (abfd, sym->st_shndx);
1771 }
1772 }
1773 return NULL;
1774 }
1775 /* Set the right machine number. */
1776 static boolean
1777 v850_elf_object_p (abfd)
1778 bfd *abfd;
1779 {
1780 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1781 {
1782 default:
1783 case E_V850_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, 0); break;
1784 case E_V850E_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e); break;
1785 case E_V850EA_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850ea); break;
1786 }
1787 return true;
1788 }
1789
1790 /* Store the machine number in the flags field. */
1791 static void
1792 v850_elf_final_write_processing (abfd, linker)
1793 bfd * abfd;
1794 boolean linker ATTRIBUTE_UNUSED;
1795 {
1796 unsigned long val;
1797
1798 switch (bfd_get_mach (abfd))
1799 {
1800 default:
1801 case 0: val = E_V850_ARCH; break;
1802 case bfd_mach_v850e: val = E_V850E_ARCH; break;
1803 case bfd_mach_v850ea: val = E_V850EA_ARCH; break;
1804 }
1805
1806 elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH;
1807 elf_elfheader (abfd)->e_flags |= val;
1808 }
1809
1810 /* Function to keep V850 specific file flags. */
1811 static boolean
1812 v850_elf_set_private_flags (abfd, flags)
1813 bfd * abfd;
1814 flagword flags;
1815 {
1816 BFD_ASSERT (!elf_flags_init (abfd)
1817 || elf_elfheader (abfd)->e_flags == flags);
1818
1819 elf_elfheader (abfd)->e_flags = flags;
1820 elf_flags_init (abfd) = true;
1821 return true;
1822 }
1823
1824 /* Copy backend specific data from one object module to another */
1825 static boolean
1826 v850_elf_copy_private_bfd_data (ibfd, obfd)
1827 bfd * ibfd;
1828 bfd * obfd;
1829 {
1830 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1831 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1832 return true;
1833
1834 BFD_ASSERT (!elf_flags_init (obfd)
1835 || (elf_elfheader (obfd)->e_flags
1836 == elf_elfheader (ibfd)->e_flags));
1837
1838 elf_gp (obfd) = elf_gp (ibfd);
1839 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1840 elf_flags_init (obfd) = true;
1841 return true;
1842 }
1843
1844 /* Merge backend specific data from an object file to the output
1845 object file when linking. */
1846 static boolean
1847 v850_elf_merge_private_bfd_data (ibfd, obfd)
1848 bfd * ibfd;
1849 bfd * obfd;
1850 {
1851 flagword out_flags;
1852 flagword in_flags;
1853
1854 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1855 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1856 return true;
1857
1858 in_flags = elf_elfheader (ibfd)->e_flags;
1859 out_flags = elf_elfheader (obfd)->e_flags;
1860
1861 if (! elf_flags_init (obfd))
1862 {
1863 /* If the input is the default architecture then do not
1864 bother setting the flags for the output architecture,
1865 instead allow future merges to do this. If no future
1866 merges ever set these flags then they will retain their
1867 unitialised values, which surprise surprise, correspond
1868 to the default values. */
1869 if (bfd_get_arch_info (ibfd)->the_default)
1870 return true;
1871
1872 elf_flags_init (obfd) = true;
1873 elf_elfheader (obfd)->e_flags = in_flags;
1874
1875 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1876 && bfd_get_arch_info (obfd)->the_default)
1877 {
1878 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1879 }
1880
1881 return true;
1882 }
1883
1884 /* Check flag compatibility. */
1885 if (in_flags == out_flags)
1886 return true;
1887
1888 if ((in_flags & EF_V850_ARCH) != (out_flags & EF_V850_ARCH)
1889 && (in_flags & EF_V850_ARCH) != E_V850_ARCH)
1890 _bfd_error_handler (_("%s: Architecture mismatch with previous modules"),
1891 bfd_get_filename (ibfd));
1892
1893 return true;
1894 }
1895 /* Display the flags field */
1896
1897 static boolean
1898 v850_elf_print_private_bfd_data (abfd, ptr)
1899 bfd * abfd;
1900 PTR ptr;
1901 {
1902 FILE * file = (FILE *) ptr;
1903
1904 BFD_ASSERT (abfd != NULL && ptr != NULL);
1905
1906 _bfd_elf_print_private_bfd_data (abfd, ptr);
1907
1908 /* xgettext:c-format */
1909 fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags);
1910
1911 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1912 {
1913 default:
1914 case E_V850_ARCH: fprintf (file, _("v850 architecture")); break;
1915 case E_V850E_ARCH: fprintf (file, _("v850e architecture")); break;
1916 case E_V850EA_ARCH: fprintf (file, _("v850ea architecture")); break;
1917 }
1918
1919 fputc ('\n', file);
1920
1921 return true;
1922 }
1923
1924 /* V850 ELF uses four common sections. One is the usual one, and the
1925 others are for (small) objects in one of the special data areas:
1926 small, tiny and zero. All the objects are kept together, and then
1927 referenced via the gp register, the ep register or the r0 register
1928 respectively, which yields smaller, faster assembler code. This
1929 approach is copied from elf32-mips.c. */
1930
1931 static asection v850_elf_scom_section;
1932 static asymbol v850_elf_scom_symbol;
1933 static asymbol * v850_elf_scom_symbol_ptr;
1934 static asection v850_elf_tcom_section;
1935 static asymbol v850_elf_tcom_symbol;
1936 static asymbol * v850_elf_tcom_symbol_ptr;
1937 static asection v850_elf_zcom_section;
1938 static asymbol v850_elf_zcom_symbol;
1939 static asymbol * v850_elf_zcom_symbol_ptr;
1940
1941 /* Given a BFD section, try to locate the corresponding ELF section
1942 index. */
1943
1944 static boolean
1945 v850_elf_section_from_bfd_section (abfd, hdr, sec, retval)
1946 bfd * abfd ATTRIBUTE_UNUSED;
1947 Elf32_Internal_Shdr * hdr ATTRIBUTE_UNUSED;
1948 asection * sec;
1949 int * retval;
1950 {
1951 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1952 *retval = SHN_V850_SCOMMON;
1953 else if (strcmp (bfd_get_section_name (abfd, sec), ".tcommon") == 0)
1954 *retval = SHN_V850_TCOMMON;
1955 else if (strcmp (bfd_get_section_name (abfd, sec), ".zcommon") == 0)
1956 *retval = SHN_V850_ZCOMMON;
1957 else
1958 return false;
1959
1960 return true;
1961 }
1962
1963 /* Handle the special V850 section numbers that a symbol may use. */
1964
1965 static void
1966 v850_elf_symbol_processing (abfd, asym)
1967 bfd * abfd;
1968 asymbol * asym;
1969 {
1970 elf_symbol_type * elfsym = (elf_symbol_type *) asym;
1971 unsigned short index;
1972
1973 index = elfsym->internal_elf_sym.st_shndx;
1974
1975 /* If the section index is an "ordinary" index, then it may
1976 refer to a v850 specific section created by the assembler.
1977 Check the section's type and change the index it matches.
1978
1979 FIXME: Should we alter the st_shndx field as well ? */
1980
1981 if (index < elf_elfheader(abfd)[0].e_shnum)
1982 switch (elf_elfsections(abfd)[index]->sh_type)
1983 {
1984 case SHT_V850_SCOMMON:
1985 index = SHN_V850_SCOMMON;
1986 break;
1987
1988 case SHT_V850_TCOMMON:
1989 index = SHN_V850_TCOMMON;
1990 break;
1991
1992 case SHT_V850_ZCOMMON:
1993 index = SHN_V850_ZCOMMON;
1994 break;
1995
1996 default:
1997 break;
1998 }
1999
2000 switch (index)
2001 {
2002 case SHN_V850_SCOMMON:
2003 if (v850_elf_scom_section.name == NULL)
2004 {
2005 /* Initialize the small common section. */
2006 v850_elf_scom_section.name = ".scommon";
2007 v850_elf_scom_section.flags = SEC_IS_COMMON | SEC_ALLOC | SEC_DATA;
2008 v850_elf_scom_section.output_section = & v850_elf_scom_section;
2009 v850_elf_scom_section.symbol = & v850_elf_scom_symbol;
2010 v850_elf_scom_section.symbol_ptr_ptr = & v850_elf_scom_symbol_ptr;
2011 v850_elf_scom_symbol.name = ".scommon";
2012 v850_elf_scom_symbol.flags = BSF_SECTION_SYM;
2013 v850_elf_scom_symbol.section = & v850_elf_scom_section;
2014 v850_elf_scom_symbol_ptr = & v850_elf_scom_symbol;
2015 }
2016 asym->section = & v850_elf_scom_section;
2017 asym->value = elfsym->internal_elf_sym.st_size;
2018 break;
2019
2020 case SHN_V850_TCOMMON:
2021 if (v850_elf_tcom_section.name == NULL)
2022 {
2023 /* Initialize the tcommon section. */
2024 v850_elf_tcom_section.name = ".tcommon";
2025 v850_elf_tcom_section.flags = SEC_IS_COMMON;
2026 v850_elf_tcom_section.output_section = & v850_elf_tcom_section;
2027 v850_elf_tcom_section.symbol = & v850_elf_tcom_symbol;
2028 v850_elf_tcom_section.symbol_ptr_ptr = & v850_elf_tcom_symbol_ptr;
2029 v850_elf_tcom_symbol.name = ".tcommon";
2030 v850_elf_tcom_symbol.flags = BSF_SECTION_SYM;
2031 v850_elf_tcom_symbol.section = & v850_elf_tcom_section;
2032 v850_elf_tcom_symbol_ptr = & v850_elf_tcom_symbol;
2033 }
2034 asym->section = & v850_elf_tcom_section;
2035 asym->value = elfsym->internal_elf_sym.st_size;
2036 break;
2037
2038 case SHN_V850_ZCOMMON:
2039 if (v850_elf_zcom_section.name == NULL)
2040 {
2041 /* Initialize the zcommon section. */
2042 v850_elf_zcom_section.name = ".zcommon";
2043 v850_elf_zcom_section.flags = SEC_IS_COMMON;
2044 v850_elf_zcom_section.output_section = & v850_elf_zcom_section;
2045 v850_elf_zcom_section.symbol = & v850_elf_zcom_symbol;
2046 v850_elf_zcom_section.symbol_ptr_ptr = & v850_elf_zcom_symbol_ptr;
2047 v850_elf_zcom_symbol.name = ".zcommon";
2048 v850_elf_zcom_symbol.flags = BSF_SECTION_SYM;
2049 v850_elf_zcom_symbol.section = & v850_elf_zcom_section;
2050 v850_elf_zcom_symbol_ptr = & v850_elf_zcom_symbol;
2051 }
2052 asym->section = & v850_elf_zcom_section;
2053 asym->value = elfsym->internal_elf_sym.st_size;
2054 break;
2055 }
2056 }
2057
2058 /* Hook called by the linker routine which adds symbols from an object
2059 file. We must handle the special v850 section numbers here. */
2060
2061 static boolean
2062 v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2063 bfd * abfd;
2064 struct bfd_link_info * info ATTRIBUTE_UNUSED;
2065 const Elf_Internal_Sym * sym;
2066 const char ** namep ATTRIBUTE_UNUSED;
2067 flagword * flagsp ATTRIBUTE_UNUSED;
2068 asection ** secp;
2069 bfd_vma * valp;
2070 {
2071 int index = sym->st_shndx;
2072
2073 /* If the section index is an "ordinary" index, then it may
2074 refer to a v850 specific section created by the assembler.
2075 Check the section's type and change the index it matches.
2076
2077 FIXME: Should we alter the st_shndx field as well ? */
2078
2079 if (index < elf_elfheader(abfd)[0].e_shnum)
2080 switch (elf_elfsections(abfd)[index]->sh_type)
2081 {
2082 case SHT_V850_SCOMMON:
2083 index = SHN_V850_SCOMMON;
2084 break;
2085
2086 case SHT_V850_TCOMMON:
2087 index = SHN_V850_TCOMMON;
2088 break;
2089
2090 case SHT_V850_ZCOMMON:
2091 index = SHN_V850_ZCOMMON;
2092 break;
2093
2094 default:
2095 break;
2096 }
2097
2098 switch (index)
2099 {
2100 case SHN_V850_SCOMMON:
2101 *secp = bfd_make_section_old_way (abfd, ".scommon");
2102 (*secp)->flags |= SEC_IS_COMMON;
2103 *valp = sym->st_size;
2104 break;
2105
2106 case SHN_V850_TCOMMON:
2107 *secp = bfd_make_section_old_way (abfd, ".tcommon");
2108 (*secp)->flags |= SEC_IS_COMMON;
2109 *valp = sym->st_size;
2110 break;
2111
2112 case SHN_V850_ZCOMMON:
2113 *secp = bfd_make_section_old_way (abfd, ".zcommon");
2114 (*secp)->flags |= SEC_IS_COMMON;
2115 *valp = sym->st_size;
2116 break;
2117 }
2118
2119 return true;
2120 }
2121
2122 /*ARGSIGNORED*/
2123 static boolean
2124 v850_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
2125 bfd * abfd ATTRIBUTE_UNUSED;
2126 struct bfd_link_info * info ATTRIBUTE_UNUSED;
2127 const char * name ATTRIBUTE_UNUSED;
2128 Elf_Internal_Sym * sym;
2129 asection * input_sec;
2130 {
2131 /* If we see a common symbol, which implies a relocatable link, then
2132 if a symbol was in a special common section in an input file, mark
2133 it as a special common in the output file. */
2134
2135 if (sym->st_shndx == SHN_COMMON)
2136 {
2137 if (strcmp (input_sec->name, ".scommon") == 0)
2138 sym->st_shndx = SHN_V850_SCOMMON;
2139 else if (strcmp (input_sec->name, ".tcommon") == 0)
2140 sym->st_shndx = SHN_V850_TCOMMON;
2141 else if (strcmp (input_sec->name, ".zcommon") == 0)
2142 sym->st_shndx = SHN_V850_ZCOMMON;
2143 }
2144
2145 return true;
2146 }
2147
2148 static boolean
2149 v850_elf_section_from_shdr (abfd, hdr, name)
2150 bfd * abfd;
2151 Elf_Internal_Shdr * hdr;
2152 char * name;
2153 {
2154 /* There ought to be a place to keep ELF backend specific flags, but
2155 at the moment there isn't one. We just keep track of the
2156 sections by their name, instead. */
2157
2158 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2159 return false;
2160
2161 switch (hdr->sh_type)
2162 {
2163 case SHT_V850_SCOMMON:
2164 case SHT_V850_TCOMMON:
2165 case SHT_V850_ZCOMMON:
2166 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2167 (bfd_get_section_flags (abfd,
2168 hdr->bfd_section)
2169 | SEC_IS_COMMON)))
2170 return false;
2171 }
2172
2173 return true;
2174 }
2175
2176 /* Set the correct type for a V850 ELF section. We do this by the
2177 section name, which is a hack, but ought to work. */
2178 static boolean
2179 v850_elf_fake_sections (abfd, hdr, sec)
2180 bfd * abfd ATTRIBUTE_UNUSED;
2181 Elf32_Internal_Shdr * hdr;
2182 asection * sec;
2183 {
2184 register const char * name;
2185
2186 name = bfd_get_section_name (abfd, sec);
2187
2188 if (strcmp (name, ".scommon") == 0)
2189 {
2190 hdr->sh_type = SHT_V850_SCOMMON;
2191 }
2192 else if (strcmp (name, ".tcommon") == 0)
2193 {
2194 hdr->sh_type = SHT_V850_TCOMMON;
2195 }
2196 else if (strcmp (name, ".zcommon") == 0)
2197 hdr->sh_type = SHT_V850_ZCOMMON;
2198
2199 return true;
2200 }
2201 \f
2202 #define TARGET_LITTLE_SYM bfd_elf32_v850_vec
2203 #define TARGET_LITTLE_NAME "elf32-v850"
2204 #define ELF_ARCH bfd_arch_v850
2205 #define ELF_MACHINE_CODE EM_CYGNUS_V850
2206 #define ELF_MAXPAGESIZE 0x1000
2207
2208 #define elf_info_to_howto v850_elf_info_to_howto_rela
2209 #define elf_info_to_howto_rel v850_elf_info_to_howto_rel
2210
2211 #define elf_backend_check_relocs v850_elf_check_relocs
2212 #define elf_backend_relocate_section v850_elf_relocate_section
2213 #define elf_backend_object_p v850_elf_object_p
2214 #define elf_backend_final_write_processing v850_elf_final_write_processing
2215 #define elf_backend_section_from_bfd_section v850_elf_section_from_bfd_section
2216 #define elf_backend_symbol_processing v850_elf_symbol_processing
2217 #define elf_backend_add_symbol_hook v850_elf_add_symbol_hook
2218 #define elf_backend_link_output_symbol_hook v850_elf_link_output_symbol_hook
2219 #define elf_backend_section_from_shdr v850_elf_section_from_shdr
2220 #define elf_backend_fake_sections v850_elf_fake_sections
2221 #define elf_backend_gc_mark_hook v850_elf_gc_mark_hook
2222 #define elf_backend_gc_sweep_hook v850_elf_gc_sweep_hook
2223
2224 #define elf_backend_can_gc_sections 1
2225
2226 #define bfd_elf32_bfd_is_local_label_name v850_elf_is_local_label_name
2227 #define bfd_elf32_bfd_reloc_type_lookup v850_elf_reloc_type_lookup
2228 #define bfd_elf32_bfd_copy_private_bfd_data v850_elf_copy_private_bfd_data
2229 #define bfd_elf32_bfd_merge_private_bfd_data v850_elf_merge_private_bfd_data
2230 #define bfd_elf32_bfd_set_private_flags v850_elf_set_private_flags
2231 #define bfd_elf32_bfd_print_private_bfd_data v850_elf_print_private_bfd_data
2232
2233 #define elf_symbol_leading_char '_'
2234
2235 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.07725 seconds and 5 git commands to generate.