?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* gas/mn10300/am33_5.s: Check that negative SP offsets are encoded
[binutils.git] / bfd / elf32-v850.c
blob4fe28fc92b912a13a94092fb211c67a28c273291
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
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 ATTRIBUTE_UNUSED;
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 ATTRIBUTE_UNUSED;
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 ATTRIBUTE_UNUSED;
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 bfd_byte * addr;
801
802 /* Search the table. Record the most recent entry that matches. */
803 for (entry = previous_hi16s; entry; entry = entry->next)
804 {
805 if (entry->addend == addend
806 && (match == NULL || match->counter < entry->counter))
807 {
808 previous = prev;
809 match = entry;
810 }
811
812 prev = entry;
813 }
814
815 if (match == NULL)
816 return NULL;
817
818 /* Extract the address. */
819 addr = match->address;
820
821 /* Remeber if this entry has already been used before. */
822 if (already_found)
823 * already_found = match->found;
824
825 /* Note that this entry has now been used. */
826 match->found = true;
827
828 return addr;
829 }
830
831 /* FIXME: The code here probably ought to be removed and the code in reloc.c
832 allowed to do its stuff instead. At least for most of the relocs, anwyay. */
833 static bfd_reloc_status_type
834 v850_elf_perform_relocation (abfd, r_type, addend, address)
835 bfd * abfd;
836 int r_type;
837 bfd_vma addend;
838 bfd_byte * address;
839 {
840 unsigned long insn;
841 bfd_signed_vma saddend = (bfd_signed_vma) addend;
842
843 switch (r_type)
844 {
845 default:
846 /* fprintf (stderr, "reloc type %d not SUPPORTED\n", r_type ); */
847 return bfd_reloc_notsupported;
848
849 case R_V850_32:
850 bfd_put_32 (abfd, addend, address);
851 return bfd_reloc_ok;
852
853 case R_V850_22_PCREL:
854 if (saddend > 0x1fffff || saddend < -0x200000)
855 return bfd_reloc_overflow;
856
857 if ((addend % 2) != 0)
858 return bfd_reloc_dangerous;
859
860 insn = bfd_get_32 (abfd, address);
861 insn &= ~0xfffe003f;
862 insn |= (((addend & 0xfffe) << 16) | ((addend & 0x3f0000) >> 16));
863 bfd_put_32 (abfd, insn, address);
864 return bfd_reloc_ok;
865
866 case R_V850_9_PCREL:
867 if (saddend > 0xff || saddend < -0x100)
868 return bfd_reloc_overflow;
869
870 if ((addend % 2) != 0)
871 return bfd_reloc_dangerous;
872
873 insn = bfd_get_16 (abfd, address);
874 insn &= ~ 0xf870;
875 insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3);
876 break;
877
878 case R_V850_HI16:
879 addend += (bfd_get_16 (abfd, address) << 16);
880 addend = (addend >> 16);
881 insn = addend;
882 break;
883
884 case R_V850_HI16_S:
885 /* Remember where this relocation took place. */
886 remember_hi16s_reloc (abfd, addend, address);
887
888 addend += (bfd_get_16 (abfd, address) << 16);
889 addend = (addend >> 16) + ((addend & 0x8000) != 0);
890
891 /* This relocation cannot overflow. */
892 if (addend > 0x7fff)
893 addend = 0;
894
895 insn = addend;
896 break;
897
898 case R_V850_LO16:
899 /* Calculate the sum of the value stored in the instruction and the
900 addend and check for overflow from the low 16 bits into the high
901 16 bits. The assembler has already done some of this: If the
902 value stored in the instruction has its 15th bit set, (counting
903 from zero) then the assembler will have added 1 to the value
904 stored in the associated HI16S reloc. So for example, these
905 relocations:
906
907 movhi hi( fred ), r0, r1
908 movea lo( fred ), r1, r1
909
910 will store 0 in the value fields for the MOVHI and MOVEA instructions
911 and addend will be the address of fred, but for these instructions:
912
913 movhi hi( fred + 0x123456), r0, r1
914 movea lo( fred + 0x123456), r1, r1
915
916 the value stored in the MOVHI instruction will be 0x12 and the value
917 stored in the MOVEA instruction will be 0x3456. If however the
918 instructions were:
919
920 movhi hi( fred + 0x10ffff), r0, r1
921 movea lo( fred + 0x10ffff), r1, r1
922
923 then the value stored in the MOVHI instruction would be 0x11 (not
924 0x10) and the value stored in the MOVEA instruction would be 0xffff.
925 Thus (assuming for the moment that the addend is 0), at run time the
926 MOVHI instruction loads 0x110000 into r1, then the MOVEA instruction
927 adds 0xffffffff (sign extension!) producing 0x10ffff. Similarly if
928 the instructions were:
929
930 movhi hi( fred - 1), r0, r1
931 movea lo( fred - 1), r1, r1
932
933 then 0 is stored in the MOVHI instruction and -1 is stored in the
934 MOVEA instruction.
935
936 Overflow can occur if the addition of the value stored in the
937 instruction plus the addend sets the 15th bit when before it was clear.
938 This is because the 15th bit will be sign extended into the high part,
939 thus reducing its value by one, but since the 15th bit was originally
940 clear, the assembler will not have added 1 to the previous HI16S reloc
941 to compensate for this effect. For example:
942
943 movhi hi( fred + 0x123456), r0, r1
944 movea lo( fred + 0x123456), r1, r1
945
946 The value stored in HI16S reloc is 0x12, the value stored in the LO16
947 reloc is 0x3456. If we assume that the address of fred is 0x00007000
948 then the relocations become:
949
950 HI16S: 0x0012 + (0x00007000 >> 16) = 0x12
951 LO16: 0x3456 + (0x00007000 & 0xffff) = 0xa456
952
953 but when the instructions are executed, the MOVEA instruction's value
954 is signed extended, so the sum becomes:
955
956 0x00120000
957 + 0xffffa456
958 ------------
959 0x0011a456 but 'fred + 0x123456' = 0x0012a456
960
961 Note that if the 15th bit was set in the value stored in the LO16
962 reloc, then we do not have to do anything:
963
964 movhi hi( fred + 0x10ffff), r0, r1
965 movea lo( fred + 0x10ffff), r1, r1
966
967 HI16S: 0x0011 + (0x00007000 >> 16) = 0x11
968 LO16: 0xffff + (0x00007000 & 0xffff) = 0x6fff
969
970 0x00110000
971 + 0x00006fff
972 ------------
973 0x00116fff = fred + 0x10ffff = 0x7000 + 0x10ffff
974
975
976 Overflow can also occur if the computation carries into the 16th bit
977 and it also results in the 15th bit having the same value as the 15th
978 bit of the original value. What happens is that the HI16S reloc
979 will have already examined the 15th bit of the original value and
980 added 1 to the high part if the bit is set. This compensates for the
981 sign extension of 15th bit of the result of the computation. But now
982 there is a carry into the 16th bit, and this has not been allowed for.
983
984 So, for example if fred is at address 0xf000:
985
986 movhi hi( fred + 0xffff), r0, r1 [bit 15 of the offset is set]
987 movea lo( fred + 0xffff), r1, r1
988
989 HI16S: 0x0001 + (0x0000f000 >> 16) = 0x0001
990 LO16: 0xffff + (0x0000f000 & 0xffff) = 0xefff (carry into bit 16 is lost)
991
992 0x00010000
993 + 0xffffefff
994 ------------
995 0x0000efff but 'fred + 0xffff' = 0x0001efff
996
997 Similarly, if the 15th bit remains clear, but overflow occurs into
998 the 16th bit then (assuming the address of fred is 0xf000):
999
1000 movhi hi( fred + 0x7000), r0, r1 [bit 15 of the offset is clear]
1001 movea lo( fred + 0x7000), r1, r1
1002
1003 HI16S: 0x0000 + (0x0000f000 >> 16) = 0x0000
1004 LO16: 0x7000 + (0x0000f000 & 0xffff) = 0x6fff (carry into bit 16 is lost)
1005
1006 0x00000000
1007 + 0x00006fff
1008 ------------
1009 0x00006fff but 'fred + 0x7000' = 0x00016fff
1010
1011 Note - there is no need to change anything if a carry occurs, and the
1012 15th bit changes its value from being set to being clear, as the HI16S
1013 reloc will have already added in 1 to the high part for us:
1014
1015 movhi hi( fred + 0xffff), r0, r1 [bit 15 of the offset is set]
1016 movea lo( fred + 0xffff), r1, r1
1017
1018 HI16S: 0x0001 + (0x00007000 >> 16)
1019 LO16: 0xffff + (0x00007000 & 0xffff) = 0x6fff (carry into bit 16 is lost)
1020
1021 0x00010000
1022 + 0x00006fff (bit 15 not set, so the top half is zero)
1023 ------------
1024 0x00016fff which is right (assuming that fred is at 0x7000)
1025
1026 but if the 15th bit goes from being clear to being set, then we must
1027 once again handle overflow:
1028
1029 movhi hi( fred + 0x7000), r0, r1 [bit 15 of the offset is clear]
1030 movea lo( fred + 0x7000), r1, r1
1031
1032 HI16S: 0x0000 + (0x0000ffff >> 16)
1033 LO16: 0x7000 + (0x0000ffff & 0xffff) = 0x6fff (carry into bit 16)
1034
1035 0x00000000
1036 + 0x00006fff (bit 15 not set, so the top half is zero)
1037 ------------
1038 0x00006fff which is wrong (assuming that fred is at 0xffff)
1039 */
1040
1041 {
1042 long result;
1043
1044 insn = bfd_get_16 (abfd, address);
1045 result = insn + addend;
1046
1047 #define BIT15_SET(x) ((x) & 0x8000)
1048 #define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff)
1049
1050 if ((BIT15_SET (result) && ! BIT15_SET (addend))
1051 || (OVERFLOWS (addend, insn)
1052 && ((! BIT15_SET (insn)) || (BIT15_SET (addend)))))
1053 {
1054 boolean already_updated;
1055 bfd_byte * hi16s_address = find_remembered_hi16s_reloc
1056 (addend, & already_updated);
1057
1058 /* Amend the matching HI16_S relocation. */
1059 if (hi16s_address != NULL)
1060 {
1061 if (! already_updated)
1062 {
1063 insn = bfd_get_16 (abfd, hi16s_address);
1064 insn += 1;
1065 bfd_put_16 (abfd, insn, hi16s_address);
1066 }
1067 }
1068 else
1069 {
1070 fprintf (stderr, _("FAILED to find previous HI16 reloc\n"));
1071 return bfd_reloc_overflow;
1072 }
1073 }
1074
1075 /* Do not complain if value has top bit set, as this has been anticipated. */
1076 insn = result & 0xffff;
1077 break;
1078 }
1079
1080 case R_V850_8:
1081 addend += (char) bfd_get_8 (abfd, address);
1082
1083 saddend = (bfd_signed_vma) addend;
1084
1085 if (saddend > 0x7f || saddend < -0x80)
1086 return bfd_reloc_overflow;
1087
1088 bfd_put_8 (abfd, addend, address);
1089 return bfd_reloc_ok;
1090
1091 case R_V850_CALLT_16_16_OFFSET:
1092 addend += bfd_get_16 (abfd, address);
1093
1094 saddend = (bfd_signed_vma) addend;
1095
1096 if (saddend > 0xffff || saddend < 0)
1097 return bfd_reloc_overflow;
1098
1099 insn = addend;
1100 break;
1101
1102 case R_V850_16:
1103
1104 /* drop through */
1105 case R_V850_SDA_16_16_OFFSET:
1106 case R_V850_ZDA_16_16_OFFSET:
1107 case R_V850_TDA_16_16_OFFSET:
1108 addend += bfd_get_16 (abfd, address);
1109
1110 saddend = (bfd_signed_vma) addend;
1111
1112 if (saddend > 0x7fff || saddend < -0x8000)
1113 return bfd_reloc_overflow;
1114
1115 insn = addend;
1116 break;
1117
1118 case R_V850_SDA_15_16_OFFSET:
1119 case R_V850_ZDA_15_16_OFFSET:
1120 insn = bfd_get_16 (abfd, address);
1121 addend += (insn & 0xfffe);
1122
1123 saddend = (bfd_signed_vma) addend;
1124
1125 if (saddend > 0x7ffe || saddend < -0x8000)
1126 return bfd_reloc_overflow;
1127
1128 if (addend & 1)
1129 return bfd_reloc_dangerous;
1130
1131 insn = (addend & ~1) | (insn & 1);
1132 break;
1133
1134 case R_V850_TDA_6_8_OFFSET:
1135 insn = bfd_get_16 (abfd, address);
1136 addend += ((insn & 0x7e) << 1);
1137
1138 saddend = (bfd_signed_vma) addend;
1139
1140 if (saddend > 0xfc || saddend < 0)
1141 return bfd_reloc_overflow;
1142
1143 if (addend & 3)
1144 return bfd_reloc_dangerous;
1145
1146 insn &= 0xff81;
1147 insn |= (addend >> 1);
1148 break;
1149
1150 case R_V850_TDA_7_8_OFFSET:
1151 insn = bfd_get_16 (abfd, address);
1152 addend += ((insn & 0x7f) << 1);
1153
1154 saddend = (bfd_signed_vma) addend;
1155
1156 if (saddend > 0xfe || saddend < 0)
1157 return bfd_reloc_overflow;
1158
1159 if (addend & 1)
1160 return bfd_reloc_dangerous;
1161
1162 insn &= 0xff80;
1163 insn |= (addend >> 1);
1164 break;
1165
1166 case R_V850_TDA_7_7_OFFSET:
1167 insn = bfd_get_16 (abfd, address);
1168 addend += insn & 0x7f;
1169
1170 saddend = (bfd_signed_vma) addend;
1171
1172 if (saddend > 0x7f || saddend < 0)
1173 return bfd_reloc_overflow;
1174
1175 insn &= 0xff80;
1176 insn |= addend;
1177 break;
1178
1179 case R_V850_TDA_4_5_OFFSET:
1180 insn = bfd_get_16 (abfd, address);
1181 addend += ((insn & 0xf) << 1);
1182
1183 saddend = (bfd_signed_vma) addend;
1184
1185 if (saddend > 0x1e || saddend < 0)
1186 return bfd_reloc_overflow;
1187
1188 if (addend & 1)
1189 return bfd_reloc_dangerous;
1190
1191 insn &= 0xfff0;
1192 insn |= (addend >> 1);
1193 break;
1194
1195 case R_V850_TDA_4_4_OFFSET:
1196 insn = bfd_get_16 (abfd, address);
1197 addend += insn & 0xf;
1198
1199 saddend = (bfd_signed_vma) addend;
1200
1201 if (saddend > 0xf || saddend < 0)
1202 return bfd_reloc_overflow;
1203
1204 insn &= 0xfff0;
1205 insn |= addend;
1206 break;
1207
1208 case R_V850_ZDA_16_16_SPLIT_OFFSET:
1209 case R_V850_SDA_16_16_SPLIT_OFFSET:
1210 insn = bfd_get_32 (abfd, address);
1211 addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5);
1212
1213 saddend = (bfd_signed_vma) addend;
1214
1215 if (saddend > 0x7fff || saddend < -0x8000)
1216 return bfd_reloc_overflow;
1217
1218 insn &= 0x0001ffdf;
1219 insn |= (addend & 1) << 5;
1220 insn |= (addend & ~1) << 16;
1221
1222 bfd_put_32 (abfd, insn, address);
1223 return bfd_reloc_ok;
1224
1225 case R_V850_CALLT_6_7_OFFSET:
1226 insn = bfd_get_16 (abfd, address);
1227 addend += ((insn & 0x3f) << 1);
1228
1229 saddend = (bfd_signed_vma) addend;
1230
1231 if (saddend > 0x7e || saddend < 0)
1232 return bfd_reloc_overflow;
1233
1234 if (addend & 1)
1235 return bfd_reloc_dangerous;
1236
1237 insn &= 0xff80;
1238 insn |= (addend >> 1);
1239 break;
1240
1241 case R_V850_GNU_VTINHERIT:
1242 case R_V850_GNU_VTENTRY:
1243 return bfd_reloc_ok;
1244
1245 }
1246
1247 bfd_put_16 (abfd, insn, address);
1248 return bfd_reloc_ok;
1249 }
1250
1251 \f
1252 /* Insert the addend into the instruction. */
1253 static bfd_reloc_status_type
1254 v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
1255 bfd * abfd ATTRIBUTE_UNUSED;
1256 arelent * reloc;
1257 asymbol * symbol;
1258 PTR data ATTRIBUTE_UNUSED;
1259 asection * isection;
1260 bfd * obfd;
1261 char ** err ATTRIBUTE_UNUSED;
1262 {
1263 long relocation;
1264
1265 /* If there is an output BFD,
1266 and the symbol is not a section name (which is only defined at final link time),
1267 and either we are not putting the addend into the instruction
1268 or the addend is zero, so there is nothing to add into the instruction
1269 then just fixup the address and return. */
1270 if (obfd != (bfd *) NULL
1271 && (symbol->flags & BSF_SECTION_SYM) == 0
1272 && (! reloc->howto->partial_inplace
1273 || reloc->addend == 0))
1274 {
1275 reloc->address += isection->output_offset;
1276 return bfd_reloc_ok;
1277 }
1278 #if 0
1279 else if (obfd != NULL)
1280 {
1281 return bfd_reloc_continue;
1282 }
1283 #endif
1284
1285 /* Catch relocs involving undefined symbols. */
1286 if (bfd_is_und_section (symbol->section)
1287 && (symbol->flags & BSF_WEAK) == 0
1288 && obfd == NULL)
1289 return bfd_reloc_undefined;
1290
1291 /* We handle final linking of some relocs ourselves. */
1292
1293 /* Is the address of the relocation really within the section? */
1294 if (reloc->address > isection->_cooked_size)
1295 return bfd_reloc_outofrange;
1296
1297 /* Work out which section the relocation is targetted at and the
1298 initial relocation command value. */
1299
1300 /* Get symbol value. (Common symbols are special.) */
1301 if (bfd_is_com_section (symbol->section))
1302 relocation = 0;
1303 else
1304 relocation = symbol->value;
1305
1306 /* Convert input-section-relative symbol value to absolute + addend. */
1307 relocation += symbol->section->output_section->vma;
1308 relocation += symbol->section->output_offset;
1309 relocation += reloc->addend;
1310
1311 if (reloc->howto->pc_relative == true)
1312 {
1313 /* Here the variable relocation holds the final address of the
1314 symbol we are relocating against, plus any addend. */
1315 relocation -= isection->output_section->vma + isection->output_offset;
1316
1317 /* Deal with pcrel_offset */
1318 relocation -= reloc->address;
1319 }
1320
1321 reloc->addend = relocation;
1322 return bfd_reloc_ok;
1323 }
1324
1325 \f
1326 /*ARGSUSED*/
1327 static boolean
1328 v850_elf_is_local_label_name (abfd, name)
1329 bfd * abfd ATTRIBUTE_UNUSED;
1330 const char * name;
1331 {
1332 return ( (name[0] == '.' && (name[1] == 'L' || name[1] == '.'))
1333 || (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_'));
1334 }
1335
1336 \f
1337 /* Perform a relocation as part of a final link. */
1338 static bfd_reloc_status_type
1339 v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1340 input_section, contents, offset, value,
1341 addend, info, sym_sec, is_local)
1342 reloc_howto_type * howto;
1343 bfd * input_bfd;
1344 bfd * output_bfd ATTRIBUTE_UNUSED;
1345 asection * input_section;
1346 bfd_byte * contents;
1347 bfd_vma offset;
1348 bfd_vma value;
1349 bfd_vma addend;
1350 struct bfd_link_info * info;
1351 asection * sym_sec;
1352 int is_local ATTRIBUTE_UNUSED;
1353 {
1354 unsigned long r_type = howto->type;
1355 bfd_byte * hit_data = contents + offset;
1356
1357 /* Adjust the value according to the relocation. */
1358 switch (r_type)
1359 {
1360 case R_V850_9_PCREL:
1361 value -= (input_section->output_section->vma
1362 + input_section->output_offset);
1363 value -= offset;
1364 break;
1365
1366 case R_V850_22_PCREL:
1367 value -= (input_section->output_section->vma
1368 + input_section->output_offset
1369 + offset);
1370
1371 /* If the sign extension will corrupt the value then we have overflowed. */
1372 if (((value & 0xff000000) != 0x0) && ((value & 0xff000000) != 0xff000000))
1373 return bfd_reloc_overflow;
1374
1375 value = SEXT24 (value); /* Only the bottom 24 bits of the PC are valid */
1376 break;
1377
1378 case R_V850_HI16_S:
1379 case R_V850_HI16:
1380 case R_V850_LO16:
1381 case R_V850_16:
1382 case R_V850_32:
1383 case R_V850_8:
1384 break;
1385
1386 case R_V850_ZDA_15_16_OFFSET:
1387 case R_V850_ZDA_16_16_OFFSET:
1388 case R_V850_ZDA_16_16_SPLIT_OFFSET:
1389 if (sym_sec == NULL)
1390 return bfd_reloc_undefined;
1391
1392 value -= sym_sec->output_section->vma;
1393 break;
1394
1395 case R_V850_SDA_15_16_OFFSET:
1396 case R_V850_SDA_16_16_OFFSET:
1397 case R_V850_SDA_16_16_SPLIT_OFFSET:
1398 {
1399 unsigned long gp;
1400 struct bfd_link_hash_entry * h;
1401
1402 if (sym_sec == NULL)
1403 return bfd_reloc_undefined;
1404
1405 /* Get the value of __gp. */
1406 h = bfd_link_hash_lookup (info->hash, "__gp", false, false, true);
1407 if (h == (struct bfd_link_hash_entry *) NULL
1408 || h->type != bfd_link_hash_defined)
1409 return bfd_reloc_other;
1410
1411 gp = (h->u.def.value
1412 + h->u.def.section->output_section->vma
1413 + h->u.def.section->output_offset);
1414
1415 value -= sym_sec->output_section->vma;
1416 value -= (gp - sym_sec->output_section->vma);
1417 }
1418 break;
1419
1420 case R_V850_TDA_4_4_OFFSET:
1421 case R_V850_TDA_4_5_OFFSET:
1422 case R_V850_TDA_16_16_OFFSET:
1423 case R_V850_TDA_7_7_OFFSET:
1424 case R_V850_TDA_7_8_OFFSET:
1425 case R_V850_TDA_6_8_OFFSET:
1426 {
1427 unsigned long ep;
1428 struct bfd_link_hash_entry * h;
1429
1430 /* Get the value of __ep. */
1431 h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1432 if (h == (struct bfd_link_hash_entry *) NULL
1433 || h->type != bfd_link_hash_defined)
1434 return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
1435
1436 ep = (h->u.def.value
1437 + h->u.def.section->output_section->vma
1438 + h->u.def.section->output_offset);
1439
1440 value -= ep;
1441 }
1442 break;
1443
1444 case R_V850_CALLT_6_7_OFFSET:
1445 {
1446 unsigned long ctbp;
1447 struct bfd_link_hash_entry * h;
1448
1449 /* Get the value of __ctbp. */
1450 h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
1451 if (h == (struct bfd_link_hash_entry *) NULL
1452 || h->type != bfd_link_hash_defined)
1453 return (bfd_reloc_dangerous + 1); /* Actually this indicates that __ctbp could not be found. */
1454
1455 ctbp = (h->u.def.value
1456 + h->u.def.section->output_section->vma
1457 + h->u.def.section->output_offset);
1458 value -= ctbp;
1459 }
1460 break;
1461
1462 case R_V850_CALLT_16_16_OFFSET:
1463 {
1464 unsigned long ctbp;
1465 struct bfd_link_hash_entry * h;
1466
1467 if (sym_sec == NULL)
1468 return bfd_reloc_undefined;
1469
1470 /* Get the value of __ctbp. */
1471 h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
1472 if (h == (struct bfd_link_hash_entry *) NULL
1473 || h->type != bfd_link_hash_defined)
1474 return (bfd_reloc_dangerous + 1);
1475
1476 ctbp = (h->u.def.value
1477 + h->u.def.section->output_section->vma
1478 + h->u.def.section->output_offset);
1479
1480 value -= sym_sec->output_section->vma;
1481 value -= (ctbp - sym_sec->output_section->vma);
1482 }
1483 break;
1484
1485 case R_V850_NONE:
1486 case R_V850_GNU_VTINHERIT:
1487 case R_V850_GNU_VTENTRY:
1488 return bfd_reloc_ok;
1489
1490 default:
1491 return bfd_reloc_notsupported;
1492 }
1493
1494 /* Perform the relocation. */
1495 return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
1496 }
1497
1498 \f
1499 /* Relocate an V850 ELF section. */
1500 static boolean
1501 v850_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1502 contents, relocs, local_syms, local_sections)
1503 bfd * output_bfd;
1504 struct bfd_link_info * info;
1505 bfd * input_bfd;
1506 asection * input_section;
1507 bfd_byte * contents;
1508 Elf_Internal_Rela * relocs;
1509 Elf_Internal_Sym * local_syms;
1510 asection ** local_sections;
1511 {
1512 Elf_Internal_Shdr * symtab_hdr;
1513 struct elf_link_hash_entry ** sym_hashes;
1514 Elf_Internal_Rela * rel;
1515 Elf_Internal_Rela * relend;
1516
1517 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1518 sym_hashes = elf_sym_hashes (input_bfd);
1519
1520 if (sym_hashes == NULL)
1521 {
1522 info->callbacks->warning
1523 (info, "no hash table available", NULL, input_bfd, input_section, 0);
1524
1525 return false;
1526 }
1527
1528 /* Reset the list of remembered HI16S relocs to empty. */
1529 free_hi16s = previous_hi16s;
1530 previous_hi16s = NULL;
1531 hi16s_counter = 0;
1532
1533 rel = relocs;
1534 relend = relocs + input_section->reloc_count;
1535 for (; rel < relend; rel++)
1536 {
1537 int r_type;
1538 reloc_howto_type * howto;
1539 unsigned long r_symndx;
1540 Elf_Internal_Sym * sym;
1541 asection * sec;
1542 struct elf_link_hash_entry * h;
1543 bfd_vma relocation;
1544 bfd_reloc_status_type r;
1545
1546 r_symndx = ELF32_R_SYM (rel->r_info);
1547 r_type = ELF32_R_TYPE (rel->r_info);
1548
1549 if (r_type == R_V850_GNU_VTENTRY
1550 || r_type == R_V850_GNU_VTINHERIT)
1551 continue;
1552
1553 howto = v850_elf_howto_table + r_type;
1554
1555 if (info->relocateable)
1556 {
1557 /* This is a relocateable link. We don't have to change
1558 anything, unless the reloc is against a section symbol,
1559 in which case we have to adjust according to where the
1560 section symbol winds up in the output section. */
1561 if (r_symndx < symtab_hdr->sh_info)
1562 {
1563 sym = local_syms + r_symndx;
1564 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1565 {
1566 sec = local_sections[r_symndx];
1567 rel->r_addend += sec->output_offset + sym->st_value;
1568 }
1569 }
1570
1571 continue;
1572 }
1573
1574 /* This is a final link. */
1575 h = NULL;
1576 sym = NULL;
1577 sec = NULL;
1578 if (r_symndx < symtab_hdr->sh_info)
1579 {
1580 sym = local_syms + r_symndx;
1581 sec = local_sections[r_symndx];
1582 relocation = (sec->output_section->vma
1583 + sec->output_offset
1584 + sym->st_value);
1585 #if 0
1586 {
1587 char * name;
1588 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name);
1589 name = (name == NULL) ? "<none>" : name;
1590 fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
1591 sec->name, name, sym->st_name,
1592 sec->output_section->vma, sec->output_offset, sym->st_value, rel->r_addend);
1593 }
1594 #endif
1595 }
1596 else
1597 {
1598 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1599
1600 while (h->root.type == bfd_link_hash_indirect
1601 || h->root.type == bfd_link_hash_warning)
1602 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1603
1604 if (h->root.type == bfd_link_hash_defined
1605 || h->root.type == bfd_link_hash_defweak)
1606 {
1607 sec = h->root.u.def.section;
1608 relocation = (h->root.u.def.value
1609 + sec->output_section->vma
1610 + sec->output_offset);
1611 #if 0
1612 fprintf (stderr, "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
1613 sec->name, h->root.root.string, h->root.u.def.value, sec->output_section->vma, sec->output_offset, relocation);
1614 #endif
1615 }
1616 else if (h->root.type == bfd_link_hash_undefweak)
1617 {
1618 #if 0
1619 fprintf (stderr, "undefined: sec: %s, name: %s\n",
1620 sec->name, h->root.root.string);
1621 #endif
1622 relocation = 0;
1623 }
1624 else
1625 {
1626 if (! ((*info->callbacks->undefined_symbol)
1627 (info, h->root.root.string, input_bfd,
1628 input_section, rel->r_offset, true)))
1629 return false;
1630 #if 0
1631 fprintf (stderr, "unknown: name: %s\n", h->root.root.string);
1632 #endif
1633 relocation = 0;
1634 }
1635 }
1636
1637 /* FIXME: We should use the addend, but the COFF relocations
1638 don't. */
1639 r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1640 input_section,
1641 contents, rel->r_offset,
1642 relocation, rel->r_addend,
1643 info, sec, h == NULL);
1644
1645 if (r != bfd_reloc_ok)
1646 {
1647 const char * name;
1648 const char * msg = (const char *)0;
1649
1650 if (h != NULL)
1651 name = h->root.root.string;
1652 else
1653 {
1654 name = (bfd_elf_string_from_elf_section
1655 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1656 if (name == NULL || *name == '\0')
1657 name = bfd_section_name (input_bfd, sec);
1658 }
1659
1660 switch (r)
1661 {
1662 case bfd_reloc_overflow:
1663 if (! ((*info->callbacks->reloc_overflow)
1664 (info, name, howto->name, (bfd_vma) 0,
1665 input_bfd, input_section, rel->r_offset)))
1666 return false;
1667 break;
1668
1669 case bfd_reloc_undefined:
1670 if (! ((*info->callbacks->undefined_symbol)
1671 (info, name, input_bfd, input_section,
1672 rel->r_offset, true)))
1673 return false;
1674 break;
1675
1676 case bfd_reloc_outofrange:
1677 msg = _("internal error: out of range error");
1678 goto common_error;
1679
1680 case bfd_reloc_notsupported:
1681 msg = _("internal error: unsupported relocation error");
1682 goto common_error;
1683
1684 case bfd_reloc_dangerous:
1685 msg = _("internal error: dangerous relocation");
1686 goto common_error;
1687
1688 case bfd_reloc_other:
1689 msg = _("could not locate special linker symbol __gp");
1690 goto common_error;
1691
1692 case bfd_reloc_continue:
1693 msg = _("could not locate special linker symbol __ep");
1694 goto common_error;
1695
1696 case (bfd_reloc_dangerous + 1):
1697 msg = _("could not locate special linker symbol __ctbp");
1698 goto common_error;
1699
1700 default:
1701 msg = _("internal error: unknown error");
1702 /* fall through */
1703
1704 common_error:
1705 if (!((*info->callbacks->warning)
1706 (info, msg, name, input_bfd, input_section,
1707 rel->r_offset)))
1708 return false;
1709 break;
1710 }
1711 }
1712 }
1713
1714 return true;
1715 }
1716
1717 static boolean
1718 v850_elf_gc_sweep_hook (abfd, info, sec, relocs)
1719 bfd *abfd ATTRIBUTE_UNUSED;
1720 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1721 asection *sec ATTRIBUTE_UNUSED;
1722 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
1723 {
1724 /* No got and plt entries for v850-elf */
1725 return true;
1726 }
1727
1728 static asection *
1729 v850_elf_gc_mark_hook (abfd, info, rel, h, sym)
1730 bfd *abfd;
1731 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1732 Elf_Internal_Rela *rel;
1733 struct elf_link_hash_entry *h;
1734 Elf_Internal_Sym *sym;
1735 {
1736 if (h != NULL)
1737 {
1738 switch (ELF32_R_TYPE (rel->r_info))
1739 {
1740 case R_V850_GNU_VTINHERIT:
1741 case R_V850_GNU_VTENTRY:
1742 break;
1743
1744 default:
1745 switch (h->root.type)
1746 {
1747 case bfd_link_hash_defined:
1748 case bfd_link_hash_defweak:
1749 return h->root.u.def.section;
1750
1751 case bfd_link_hash_common:
1752 return h->root.u.c.p->section;
1753
1754 default:
1755 break;
1756 }
1757 }
1758 }
1759 else
1760 {
1761 if (!(elf_bad_symtab (abfd)
1762 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1763 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1764 && sym->st_shndx != SHN_COMMON))
1765 {
1766 return bfd_section_from_elf_index (abfd, sym->st_shndx);
1767 }
1768 }
1769 return NULL;
1770 }
1771 /* Set the right machine number. */
1772 static boolean
1773 v850_elf_object_p (abfd)
1774 bfd *abfd;
1775 {
1776 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1777 {
1778 default:
1779 case E_V850_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, 0); break;
1780 case E_V850E_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e); break;
1781 case E_V850EA_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850ea); break;
1782 }
1783 return true;
1784 }
1785
1786 /* Store the machine number in the flags field. */
1787 static void
1788 v850_elf_final_write_processing (abfd, linker)
1789 bfd * abfd;
1790 boolean linker ATTRIBUTE_UNUSED;
1791 {
1792 unsigned long val;
1793
1794 switch (bfd_get_mach (abfd))
1795 {
1796 default:
1797 case 0: val = E_V850_ARCH; break;
1798 case bfd_mach_v850e: val = E_V850E_ARCH; break;
1799 case bfd_mach_v850ea: val = E_V850EA_ARCH; break;
1800 }
1801
1802 elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH;
1803 elf_elfheader (abfd)->e_flags |= val;
1804 }
1805
1806 /* Function to keep V850 specific file flags. */
1807 static boolean
1808 v850_elf_set_private_flags (abfd, flags)
1809 bfd * abfd;
1810 flagword flags;
1811 {
1812 BFD_ASSERT (!elf_flags_init (abfd)
1813 || elf_elfheader (abfd)->e_flags == flags);
1814
1815 elf_elfheader (abfd)->e_flags = flags;
1816 elf_flags_init (abfd) = true;
1817 return true;
1818 }
1819
1820 /* Copy backend specific data from one object module to another */
1821 static boolean
1822 v850_elf_copy_private_bfd_data (ibfd, obfd)
1823 bfd * ibfd;
1824 bfd * obfd;
1825 {
1826 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1827 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1828 return true;
1829
1830 BFD_ASSERT (!elf_flags_init (obfd)
1831 || (elf_elfheader (obfd)->e_flags
1832 == elf_elfheader (ibfd)->e_flags));
1833
1834 elf_gp (obfd) = elf_gp (ibfd);
1835 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1836 elf_flags_init (obfd) = true;
1837 return true;
1838 }
1839
1840 /* Merge backend specific data from an object file to the output
1841 object file when linking. */
1842 static boolean
1843 v850_elf_merge_private_bfd_data (ibfd, obfd)
1844 bfd * ibfd;
1845 bfd * obfd;
1846 {
1847 flagword out_flags;
1848 flagword in_flags;
1849
1850 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1851 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1852 return true;
1853
1854 in_flags = elf_elfheader (ibfd)->e_flags;
1855 out_flags = elf_elfheader (obfd)->e_flags;
1856
1857 if (! elf_flags_init (obfd))
1858 {
1859 /* If the input is the default architecture then do not
1860 bother setting the flags for the output architecture,
1861 instead allow future merges to do this. If no future
1862 merges ever set these flags then they will retain their
1863 unitialised values, which surprise surprise, correspond
1864 to the default values. */
1865 if (bfd_get_arch_info (ibfd)->the_default)
1866 return true;
1867
1868 elf_flags_init (obfd) = true;
1869 elf_elfheader (obfd)->e_flags = in_flags;
1870
1871 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1872 && bfd_get_arch_info (obfd)->the_default)
1873 {
1874 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1875 }
1876
1877 return true;
1878 }
1879
1880 /* Check flag compatibility. */
1881 if (in_flags == out_flags)
1882 return true;
1883
1884 if ((in_flags & EF_V850_ARCH) != (out_flags & EF_V850_ARCH)
1885 && (in_flags & EF_V850_ARCH) != E_V850_ARCH)
1886 _bfd_error_handler (_("%s: Architecture mismatch with previous modules"),
1887 bfd_get_filename (ibfd));
1888
1889 return true;
1890 }
1891 /* Display the flags field */
1892
1893 static boolean
1894 v850_elf_print_private_bfd_data (abfd, ptr)
1895 bfd * abfd;
1896 PTR ptr;
1897 {
1898 FILE * file = (FILE *) ptr;
1899
1900 BFD_ASSERT (abfd != NULL && ptr != NULL);
1901
1902 _bfd_elf_print_private_bfd_data (abfd, ptr);
1903
1904 /* xgettext:c-format */
1905 fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags);
1906
1907 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1908 {
1909 default:
1910 case E_V850_ARCH: fprintf (file, _("v850 architecture")); break;
1911 case E_V850E_ARCH: fprintf (file, _("v850e architecture")); break;
1912 case E_V850EA_ARCH: fprintf (file, _("v850ea architecture")); break;
1913 }
1914
1915 fputc ('\n', file);
1916
1917 return true;
1918 }
1919
1920 /* V850 ELF uses four common sections. One is the usual one, and the
1921 others are for (small) objects in one of the special data areas:
1922 small, tiny and zero. All the objects are kept together, and then
1923 referenced via the gp register, the ep register or the r0 register
1924 respectively, which yields smaller, faster assembler code. This
1925 approach is copied from elf32-mips.c. */
1926
1927 static asection v850_elf_scom_section;
1928 static asymbol v850_elf_scom_symbol;
1929 static asymbol * v850_elf_scom_symbol_ptr;
1930 static asection v850_elf_tcom_section;
1931 static asymbol v850_elf_tcom_symbol;
1932 static asymbol * v850_elf_tcom_symbol_ptr;
1933 static asection v850_elf_zcom_section;
1934 static asymbol v850_elf_zcom_symbol;
1935 static asymbol * v850_elf_zcom_symbol_ptr;
1936
1937
1938 /* Given a BFD section, try to locate the corresponding ELF section
1939 index. */
1940
1941 static boolean
1942 v850_elf_section_from_bfd_section (abfd, hdr, sec, retval)
1943 bfd * abfd ATTRIBUTE_UNUSED;
1944 Elf32_Internal_Shdr * hdr ATTRIBUTE_UNUSED;
1945 asection * sec;
1946 int * retval;
1947 {
1948 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1949 *retval = SHN_V850_SCOMMON;
1950 else if (strcmp (bfd_get_section_name (abfd, sec), ".tcommon") == 0)
1951 *retval = SHN_V850_TCOMMON;
1952 else if (strcmp (bfd_get_section_name (abfd, sec), ".zcommon") == 0)
1953 *retval = SHN_V850_ZCOMMON;
1954 else
1955 return false;
1956
1957 return true;
1958 }
1959
1960 /* Handle the special V850 section numbers that a symbol may use. */
1961
1962 static void
1963 v850_elf_symbol_processing (abfd, asym)
1964 bfd * abfd;
1965 asymbol * asym;
1966 {
1967 elf_symbol_type * elfsym = (elf_symbol_type *) asym;
1968 unsigned short index;
1969
1970 index = elfsym->internal_elf_sym.st_shndx;
1971
1972 /* If the section index is an "ordinary" index, then it may
1973 refer to a v850 specific section created by the assembler.
1974 Check the section's type and change the index it matches.
1975
1976 FIXME: Should we alter the st_shndx field as well ? */
1977
1978 if (index < elf_elfheader(abfd)[0].e_shnum)
1979 switch (elf_elfsections(abfd)[index]->sh_type)
1980 {
1981 case SHT_V850_SCOMMON:
1982 index = SHN_V850_SCOMMON;
1983 break;
1984
1985 case SHT_V850_TCOMMON:
1986 index = SHN_V850_TCOMMON;
1987 break;
1988
1989 case SHT_V850_ZCOMMON:
1990 index = SHN_V850_ZCOMMON;
1991 break;
1992
1993 default:
1994 break;
1995 }
1996
1997 switch (index)
1998 {
1999 case SHN_V850_SCOMMON:
2000 if (v850_elf_scom_section.name == NULL)
2001 {
2002 /* Initialize the small common section. */
2003 v850_elf_scom_section.name = ".scommon";
2004 v850_elf_scom_section.flags = SEC_IS_COMMON | SEC_ALLOC | SEC_DATA;
2005 v850_elf_scom_section.output_section = & v850_elf_scom_section;
2006 v850_elf_scom_section.symbol = & v850_elf_scom_symbol;
2007 v850_elf_scom_section.symbol_ptr_ptr = & v850_elf_scom_symbol_ptr;
2008 v850_elf_scom_symbol.name = ".scommon";
2009 v850_elf_scom_symbol.flags = BSF_SECTION_SYM;
2010 v850_elf_scom_symbol.section = & v850_elf_scom_section;
2011 v850_elf_scom_symbol_ptr = & v850_elf_scom_symbol;
2012 }
2013 asym->section = & v850_elf_scom_section;
2014 asym->value = elfsym->internal_elf_sym.st_size;
2015 break;
2016
2017 case SHN_V850_TCOMMON:
2018 if (v850_elf_tcom_section.name == NULL)
2019 {
2020 /* Initialize the tcommon section. */
2021 v850_elf_tcom_section.name = ".tcommon";
2022 v850_elf_tcom_section.flags = SEC_IS_COMMON;
2023 v850_elf_tcom_section.output_section = & v850_elf_tcom_section;
2024 v850_elf_tcom_section.symbol = & v850_elf_tcom_symbol;
2025 v850_elf_tcom_section.symbol_ptr_ptr = & v850_elf_tcom_symbol_ptr;
2026 v850_elf_tcom_symbol.name = ".tcommon";
2027 v850_elf_tcom_symbol.flags = BSF_SECTION_SYM;
2028 v850_elf_tcom_symbol.section = & v850_elf_tcom_section;
2029 v850_elf_tcom_symbol_ptr = & v850_elf_tcom_symbol;
2030 }
2031 asym->section = & v850_elf_tcom_section;
2032 asym->value = elfsym->internal_elf_sym.st_size;
2033 break;
2034
2035 case SHN_V850_ZCOMMON:
2036 if (v850_elf_zcom_section.name == NULL)
2037 {
2038 /* Initialize the zcommon section. */
2039 v850_elf_zcom_section.name = ".zcommon";
2040 v850_elf_zcom_section.flags = SEC_IS_COMMON;
2041 v850_elf_zcom_section.output_section = & v850_elf_zcom_section;
2042 v850_elf_zcom_section.symbol = & v850_elf_zcom_symbol;
2043 v850_elf_zcom_section.symbol_ptr_ptr = & v850_elf_zcom_symbol_ptr;
2044 v850_elf_zcom_symbol.name = ".zcommon";
2045 v850_elf_zcom_symbol.flags = BSF_SECTION_SYM;
2046 v850_elf_zcom_symbol.section = & v850_elf_zcom_section;
2047 v850_elf_zcom_symbol_ptr = & v850_elf_zcom_symbol;
2048 }
2049 asym->section = & v850_elf_zcom_section;
2050 asym->value = elfsym->internal_elf_sym.st_size;
2051 break;
2052 }
2053 }
2054
2055 /* Hook called by the linker routine which adds symbols from an object
2056 file. We must handle the special v850 section numbers here. */
2057
2058 /*ARGSUSED*/
2059 static boolean
2060 v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2061 bfd * abfd;
2062 struct bfd_link_info * info ATTRIBUTE_UNUSED;
2063 const Elf_Internal_Sym * sym;
2064 const char ** namep ATTRIBUTE_UNUSED;
2065 flagword * flagsp ATTRIBUTE_UNUSED;
2066 asection ** secp;
2067 bfd_vma * valp;
2068 {
2069 int index = sym->st_shndx;
2070
2071 /* If the section index is an "ordinary" index, then it may
2072 refer to a v850 specific section created by the assembler.
2073 Check the section's type and change the index it matches.
2074
2075 FIXME: Should we alter the st_shndx field as well ? */
2076
2077 if (index < elf_elfheader(abfd)[0].e_shnum)
2078 switch (elf_elfsections(abfd)[index]->sh_type)
2079 {
2080 case SHT_V850_SCOMMON:
2081 index = SHN_V850_SCOMMON;
2082 break;
2083
2084 case SHT_V850_TCOMMON:
2085 index = SHN_V850_TCOMMON;
2086 break;
2087
2088 case SHT_V850_ZCOMMON:
2089 index = SHN_V850_ZCOMMON;
2090 break;
2091
2092 default:
2093 break;
2094 }
2095
2096 switch (index)
2097 {
2098 case SHN_V850_SCOMMON:
2099 *secp = bfd_make_section_old_way (abfd, ".scommon");
2100 (*secp)->flags |= SEC_IS_COMMON;
2101 *valp = sym->st_size;
2102 break;
2103
2104 case SHN_V850_TCOMMON:
2105 *secp = bfd_make_section_old_way (abfd, ".tcommon");
2106 (*secp)->flags |= SEC_IS_COMMON;
2107 *valp = sym->st_size;
2108 break;
2109
2110 case SHN_V850_ZCOMMON:
2111 *secp = bfd_make_section_old_way (abfd, ".zcommon");
2112 (*secp)->flags |= SEC_IS_COMMON;
2113 *valp = sym->st_size;
2114 break;
2115 }
2116
2117 return true;
2118 }
2119
2120 /*ARGSIGNORED*/
2121 static boolean
2122 v850_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
2123 bfd * abfd ATTRIBUTE_UNUSED;
2124 struct bfd_link_info * info ATTRIBUTE_UNUSED;
2125 const char * name ATTRIBUTE_UNUSED;
2126 Elf_Internal_Sym * sym;
2127 asection * input_sec;
2128 {
2129 /* If we see a common symbol, which implies a relocatable link, then
2130 if a symbol was in a special common section in an input file, mark
2131 it as a special common in the output file. */
2132
2133 if (sym->st_shndx == SHN_COMMON)
2134 {
2135 if (strcmp (input_sec->name, ".scommon") == 0)
2136 sym->st_shndx = SHN_V850_SCOMMON;
2137 else if (strcmp (input_sec->name, ".tcommon") == 0)
2138 sym->st_shndx = SHN_V850_TCOMMON;
2139 else if (strcmp (input_sec->name, ".zcommon") == 0)
2140 sym->st_shndx = SHN_V850_ZCOMMON;
2141 }
2142
2143 return true;
2144 }
2145
2146 static boolean
2147 v850_elf_section_from_shdr (abfd, hdr, name)
2148 bfd * abfd;
2149 Elf_Internal_Shdr * hdr;
2150 char * name;
2151 {
2152 /* There ought to be a place to keep ELF backend specific flags, but
2153 at the moment there isn't one. We just keep track of the
2154 sections by their name, instead. */
2155
2156 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2157 return false;
2158
2159 switch (hdr->sh_type)
2160 {
2161 case SHT_V850_SCOMMON:
2162 case SHT_V850_TCOMMON:
2163 case SHT_V850_ZCOMMON:
2164 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2165 (bfd_get_section_flags (abfd,
2166 hdr->bfd_section)
2167 | SEC_IS_COMMON)))
2168 return false;
2169 }
2170
2171 return true;
2172 }
2173
2174 /* Set the correct type for a V850 ELF section. We do this by the
2175 section name, which is a hack, but ought to work. */
2176 static boolean
2177 v850_elf_fake_sections (abfd, hdr, sec)
2178 bfd * abfd ATTRIBUTE_UNUSED;
2179 Elf32_Internal_Shdr * hdr;
2180 asection * sec;
2181 {
2182 register const char * name;
2183
2184 name = bfd_get_section_name (abfd, sec);
2185
2186 if (strcmp (name, ".scommon") == 0)
2187 {
2188 hdr->sh_type = SHT_V850_SCOMMON;
2189 }
2190 else if (strcmp (name, ".tcommon") == 0)
2191 {
2192 hdr->sh_type = SHT_V850_TCOMMON;
2193 }
2194 else if (strcmp (name, ".zcommon") == 0)
2195 hdr->sh_type = SHT_V850_ZCOMMON;
2196
2197 return true;
2198 }
2199
2200
2201 \f
2202 #define TARGET_LITTLE_SYM bfd_elf32_v850_vec
2203 #define TARGET_LITTLE_NAME "elf32-v850"
2204 #define ELF_ARCH bfd_arch_v850
2205 #define ELF_MACHINE_CODE EM_CYGNUS_V850
2206 #define ELF_MAXPAGESIZE 0x1000
2207
2208 #define elf_info_to_howto v850_elf_info_to_howto_rela
2209 #define elf_info_to_howto_rel v850_elf_info_to_howto_rel
2210
2211 #define elf_backend_check_relocs v850_elf_check_relocs
2212 #define elf_backend_relocate_section v850_elf_relocate_section
2213 #define elf_backend_object_p v850_elf_object_p
2214 #define elf_backend_final_write_processing v850_elf_final_write_processing
2215 #define elf_backend_section_from_bfd_section v850_elf_section_from_bfd_section
2216 #define elf_backend_symbol_processing v850_elf_symbol_processing
2217 #define elf_backend_add_symbol_hook v850_elf_add_symbol_hook
2218 #define elf_backend_link_output_symbol_hook v850_elf_link_output_symbol_hook
2219 #define elf_backend_section_from_shdr v850_elf_section_from_shdr
2220 #define elf_backend_fake_sections v850_elf_fake_sections
2221 #define elf_backend_gc_mark_hook v850_elf_gc_mark_hook
2222 #define elf_backend_gc_sweep_hook v850_elf_gc_sweep_hook
2223
2224 #define elf_backend_can_gc_sections 1
2225
2226
2227 #define bfd_elf32_bfd_is_local_label_name v850_elf_is_local_label_name
2228 #define bfd_elf32_bfd_reloc_type_lookup v850_elf_reloc_type_lookup
2229 #define bfd_elf32_bfd_copy_private_bfd_data v850_elf_copy_private_bfd_data
2230 #define bfd_elf32_bfd_merge_private_bfd_data v850_elf_merge_private_bfd_data
2231 #define bfd_elf32_bfd_set_private_flags v850_elf_set_private_flags
2232 #define bfd_elf32_bfd_print_private_bfd_data v850_elf_print_private_bfd_data
2233
2234 #define elf_symbol_leading_char '_'
2235
2236 #include "elf32-target.h"
git-cvsimport of binutils cvsroot