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