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