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