]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-v850.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use helpful names instead of cryptically overloaded bfd_reloc error codes.
[thirdparty/binutils-gdb.git] / bfd / elf32-v850.c
1 /* V850-specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 /* XXX FIXME: This code is littered with 32bit int, 16bit short, 8bit char
22 dependencies. As is the gas & simulator code for the v850. */
23
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "bfdlink.h"
27 #include "libbfd.h"
28 #include "elf-bfd.h"
29 #include "elf/v850.h"
30 #include "libiberty.h"
31
32 /* Sign-extend a 24-bit number. */
33 #define SEXT24(x) ((((x) & 0xffffff) ^ 0x800000) - 0x800000)
34
35 static reloc_howto_type *v850_elf_reloc_type_lookup
36 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
37 static void v850_elf_info_to_howto_rel
38 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
39 static void v850_elf_info_to_howto_rela
40 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
41 static bfd_reloc_status_type v850_elf_reloc
42 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
43 static boolean v850_elf_is_local_label_name
44 PARAMS ((bfd *, const char *));
45 static boolean v850_elf_relocate_section
46 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
47 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
48 static bfd_reloc_status_type v850_elf_perform_relocation
49 PARAMS ((bfd *, unsigned int, bfd_vma, bfd_byte *));
50 static boolean v850_elf_check_relocs
51 PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));
52 static void remember_hi16s_reloc
53 PARAMS ((bfd *, bfd_vma, bfd_byte *));
54 static bfd_byte * find_remembered_hi16s_reloc
55 PARAMS ((bfd_vma, boolean *));
56 static bfd_reloc_status_type v850_elf_final_link_relocate
57 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *, bfd_vma,
58 bfd_vma, bfd_vma, struct bfd_link_info *, asection *, int));
59 static boolean v850_elf_object_p
60 PARAMS ((bfd *));
61 static boolean v850_elf_fake_sections
62 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
63 static void v850_elf_final_write_processing
64 PARAMS ((bfd *, boolean));
65 static boolean v850_elf_set_private_flags
66 PARAMS ((bfd *, flagword));
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 *, 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 *, const char *));
83 static boolean v850_elf_gc_sweep_hook
84 PARAMS ((bfd *, struct bfd_link_info *, asection *,
85 const Elf_Internal_Rela *));
86 static asection * v850_elf_gc_mark_hook
87 PARAMS ((asection *, struct bfd_link_info *,
88 Elf_Internal_Rela *, struct elf_link_hash_entry *,
89 Elf_Internal_Sym *));
90 static bfd_reloc_status_type v850_elf_ignore_reloc
91 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
92 static boolean v850_elf_relax_delete_bytes
93 PARAMS ((bfd *, asection *, bfd_vma, bfd_vma, int));
94 static boolean v850_elf_relax_section
95 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
96
97 /* Note: It is REQUIRED that the 'type' value of each entry
98 in this array match the index of the entry in the array. */
99 static reloc_howto_type v850_elf_howto_table[] =
100 {
101 /* This reloc does nothing. */
102 HOWTO (R_V850_NONE, /* type */
103 0, /* rightshift */
104 2, /* size (0 = byte, 1 = short, 2 = long) */
105 32, /* bitsize */
106 false, /* pc_relative */
107 0, /* bitpos */
108 complain_overflow_bitfield, /* complain_on_overflow */
109 bfd_elf_generic_reloc, /* special_function */
110 "R_V850_NONE", /* name */
111 false, /* partial_inplace */
112 0, /* src_mask */
113 0, /* dst_mask */
114 false), /* pcrel_offset */
115
116 /* A PC relative 9 bit branch. */
117 HOWTO (R_V850_9_PCREL, /* type */
118 2, /* rightshift */
119 2, /* size (0 = byte, 1 = short, 2 = long) */
120 26, /* bitsize */
121 true, /* pc_relative */
122 0, /* bitpos */
123 complain_overflow_bitfield, /* complain_on_overflow */
124 v850_elf_reloc, /* special_function */
125 "R_V850_9_PCREL", /* name */
126 false, /* partial_inplace */
127 0x00ffffff, /* src_mask */
128 0x00ffffff, /* dst_mask */
129 true), /* pcrel_offset */
130
131 /* A PC relative 22 bit branch. */
132 HOWTO (R_V850_22_PCREL, /* type */
133 2, /* rightshift */
134 2, /* size (0 = byte, 1 = short, 2 = long) */
135 22, /* bitsize */
136 true, /* pc_relative */
137 7, /* bitpos */
138 complain_overflow_signed, /* complain_on_overflow */
139 v850_elf_reloc, /* special_function */
140 "R_V850_22_PCREL", /* name */
141 false, /* partial_inplace */
142 0x07ffff80, /* src_mask */
143 0x07ffff80, /* dst_mask */
144 true), /* pcrel_offset */
145
146 /* High 16 bits of symbol value. */
147 HOWTO (R_V850_HI16_S, /* type */
148 0, /* rightshift */
149 1, /* size (0 = byte, 1 = short, 2 = long) */
150 16, /* bitsize */
151 false, /* pc_relative */
152 0, /* bitpos */
153 complain_overflow_dont, /* complain_on_overflow */
154 v850_elf_reloc, /* special_function */
155 "R_V850_HI16_S", /* name */
156 false, /* partial_inplace */
157 0xffff, /* src_mask */
158 0xffff, /* dst_mask */
159 false), /* pcrel_offset */
160
161 /* High 16 bits of symbol value. */
162 HOWTO (R_V850_HI16, /* type */
163 0, /* rightshift */
164 1, /* size (0 = byte, 1 = short, 2 = long) */
165 16, /* bitsize */
166 false, /* pc_relative */
167 0, /* bitpos */
168 complain_overflow_dont, /* complain_on_overflow */
169 v850_elf_reloc, /* special_function */
170 "R_V850_HI16", /* name */
171 false, /* partial_inplace */
172 0xffff, /* src_mask */
173 0xffff, /* dst_mask */
174 false), /* pcrel_offset */
175
176 /* Low 16 bits of symbol value. */
177 HOWTO (R_V850_LO16, /* type */
178 0, /* rightshift */
179 1, /* size (0 = byte, 1 = short, 2 = long) */
180 16, /* bitsize */
181 false, /* pc_relative */
182 0, /* bitpos */
183 complain_overflow_dont, /* complain_on_overflow */
184 v850_elf_reloc, /* special_function */
185 "R_V850_LO16", /* name */
186 false, /* partial_inplace */
187 0xffff, /* src_mask */
188 0xffff, /* dst_mask */
189 false), /* pcrel_offset */
190
191 /* Simple 32bit reloc. */
192 HOWTO (R_V850_32, /* type */
193 0, /* rightshift */
194 2, /* size (0 = byte, 1 = short, 2 = long) */
195 32, /* bitsize */
196 false, /* pc_relative */
197 0, /* bitpos */
198 complain_overflow_dont, /* complain_on_overflow */
199 v850_elf_reloc, /* special_function */
200 "R_V850_32", /* name */
201 false, /* partial_inplace */
202 0xffffffff, /* src_mask */
203 0xffffffff, /* dst_mask */
204 false), /* pcrel_offset */
205
206 /* Simple 16bit reloc. */
207 HOWTO (R_V850_16, /* type */
208 0, /* rightshift */
209 1, /* size (0 = byte, 1 = short, 2 = long) */
210 16, /* bitsize */
211 false, /* pc_relative */
212 0, /* bitpos */
213 complain_overflow_dont, /* complain_on_overflow */
214 bfd_elf_generic_reloc, /* special_function */
215 "R_V850_16", /* name */
216 false, /* partial_inplace */
217 0xffff, /* src_mask */
218 0xffff, /* dst_mask */
219 false), /* pcrel_offset */
220
221 /* Simple 8bit reloc. */
222 HOWTO (R_V850_8, /* type */
223 0, /* rightshift */
224 0, /* size (0 = byte, 1 = short, 2 = long) */
225 8, /* bitsize */
226 false, /* pc_relative */
227 0, /* bitpos */
228 complain_overflow_dont, /* complain_on_overflow */
229 bfd_elf_generic_reloc, /* special_function */
230 "R_V850_8", /* name */
231 false, /* partial_inplace */
232 0xff, /* src_mask */
233 0xff, /* dst_mask */
234 false), /* pcrel_offset */
235
236 /* 16 bit offset from the short data area pointer. */
237 HOWTO (R_V850_SDA_16_16_OFFSET, /* type */
238 0, /* rightshift */
239 1, /* size (0 = byte, 1 = short, 2 = long) */
240 16, /* bitsize */
241 false, /* pc_relative */
242 0, /* bitpos */
243 complain_overflow_dont, /* complain_on_overflow */
244 v850_elf_reloc, /* special_function */
245 "R_V850_SDA_16_16_OFFSET", /* name */
246 false, /* partial_inplace */
247 0xffff, /* src_mask */
248 0xffff, /* dst_mask */
249 false), /* pcrel_offset */
250
251 /* 15 bit offset from the short data area pointer. */
252 HOWTO (R_V850_SDA_15_16_OFFSET, /* type */
253 1, /* rightshift */
254 1, /* size (0 = byte, 1 = short, 2 = long) */
255 16, /* bitsize */
256 false, /* pc_relative */
257 1, /* bitpos */
258 complain_overflow_dont, /* complain_on_overflow */
259 v850_elf_reloc, /* special_function */
260 "R_V850_SDA_15_16_OFFSET", /* name */
261 false, /* partial_inplace */
262 0xfffe, /* src_mask */
263 0xfffe, /* dst_mask */
264 false), /* pcrel_offset */
265
266 /* 16 bit offset from the zero data area pointer. */
267 HOWTO (R_V850_ZDA_16_16_OFFSET, /* type */
268 0, /* rightshift */
269 1, /* size (0 = byte, 1 = short, 2 = long) */
270 16, /* bitsize */
271 false, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_dont, /* complain_on_overflow */
274 v850_elf_reloc, /* special_function */
275 "R_V850_ZDA_16_16_OFFSET", /* name */
276 false, /* partial_inplace */
277 0xffff, /* src_mask */
278 0xffff, /* dst_mask */
279 false), /* pcrel_offset */
280
281 /* 15 bit offset from the zero data area pointer. */
282 HOWTO (R_V850_ZDA_15_16_OFFSET, /* type */
283 1, /* rightshift */
284 1, /* size (0 = byte, 1 = short, 2 = long) */
285 16, /* bitsize */
286 false, /* pc_relative */
287 1, /* bitpos */
288 complain_overflow_dont, /* complain_on_overflow */
289 v850_elf_reloc, /* special_function */
290 "R_V850_ZDA_15_16_OFFSET", /* name */
291 false, /* partial_inplace */
292 0xfffe, /* src_mask */
293 0xfffe, /* dst_mask */
294 false), /* pcrel_offset */
295
296 /* 6 bit offset from the tiny data area pointer. */
297 HOWTO (R_V850_TDA_6_8_OFFSET, /* type */
298 2, /* rightshift */
299 1, /* size (0 = byte, 1 = short, 2 = long) */
300 8, /* bitsize */
301 false, /* pc_relative */
302 1, /* bitpos */
303 complain_overflow_dont, /* complain_on_overflow */
304 v850_elf_reloc, /* special_function */
305 "R_V850_TDA_6_8_OFFSET", /* name */
306 false, /* partial_inplace */
307 0x7e, /* src_mask */
308 0x7e, /* dst_mask */
309 false), /* pcrel_offset */
310
311 /* 8 bit offset from the tiny data area pointer. */
312 HOWTO (R_V850_TDA_7_8_OFFSET, /* type */
313 1, /* rightshift */
314 1, /* size (0 = byte, 1 = short, 2 = long) */
315 8, /* bitsize */
316 false, /* pc_relative */
317 0, /* bitpos */
318 complain_overflow_dont, /* complain_on_overflow */
319 v850_elf_reloc, /* special_function */
320 "R_V850_TDA_7_8_OFFSET", /* name */
321 false, /* partial_inplace */
322 0x7f, /* src_mask */
323 0x7f, /* dst_mask */
324 false), /* pcrel_offset */
325
326 /* 7 bit offset from the tiny data area pointer. */
327 HOWTO (R_V850_TDA_7_7_OFFSET, /* type */
328 0, /* rightshift */
329 1, /* size (0 = byte, 1 = short, 2 = long) */
330 7, /* bitsize */
331 false, /* pc_relative */
332 0, /* bitpos */
333 complain_overflow_dont, /* complain_on_overflow */
334 v850_elf_reloc, /* special_function */
335 "R_V850_TDA_7_7_OFFSET", /* name */
336 false, /* partial_inplace */
337 0x7f, /* src_mask */
338 0x7f, /* dst_mask */
339 false), /* pcrel_offset */
340
341 /* 16 bit offset from the tiny data area pointer! */
342 HOWTO (R_V850_TDA_16_16_OFFSET, /* type */
343 0, /* rightshift */
344 1, /* size (0 = byte, 1 = short, 2 = long) */
345 16, /* bitsize */
346 false, /* pc_relative */
347 0, /* bitpos */
348 complain_overflow_dont, /* complain_on_overflow */
349 v850_elf_reloc, /* special_function */
350 "R_V850_TDA_16_16_OFFSET", /* name */
351 false, /* partial_inplace */
352 0xffff, /* src_mask */
353 0xfff, /* dst_mask */
354 false), /* pcrel_offset */
355
356 /* 5 bit offset from the tiny data area pointer. */
357 HOWTO (R_V850_TDA_4_5_OFFSET, /* type */
358 1, /* rightshift */
359 1, /* size (0 = byte, 1 = short, 2 = long) */
360 5, /* bitsize */
361 false, /* pc_relative */
362 0, /* bitpos */
363 complain_overflow_dont, /* complain_on_overflow */
364 v850_elf_reloc, /* special_function */
365 "R_V850_TDA_4_5_OFFSET", /* name */
366 false, /* partial_inplace */
367 0x0f, /* src_mask */
368 0x0f, /* dst_mask */
369 false), /* pcrel_offset */
370
371 /* 4 bit offset from the tiny data area pointer. */
372 HOWTO (R_V850_TDA_4_4_OFFSET, /* type */
373 0, /* rightshift */
374 1, /* size (0 = byte, 1 = short, 2 = long) */
375 4, /* bitsize */
376 false, /* pc_relative */
377 0, /* bitpos */
378 complain_overflow_dont, /* complain_on_overflow */
379 v850_elf_reloc, /* special_function */
380 "R_V850_TDA_4_4_OFFSET", /* name */
381 false, /* partial_inplace */
382 0x0f, /* src_mask */
383 0x0f, /* dst_mask */
384 false), /* pcrel_offset */
385
386 /* 16 bit offset from the short data area pointer. */
387 HOWTO (R_V850_SDA_16_16_SPLIT_OFFSET, /* type */
388 0, /* rightshift */
389 2, /* size (0 = byte, 1 = short, 2 = long) */
390 16, /* bitsize */
391 false, /* pc_relative */
392 0, /* bitpos */
393 complain_overflow_dont, /* complain_on_overflow */
394 v850_elf_reloc, /* special_function */
395 "R_V850_SDA_16_16_SPLIT_OFFSET",/* name */
396 false, /* partial_inplace */
397 0xfffe0020, /* src_mask */
398 0xfffe0020, /* dst_mask */
399 false), /* pcrel_offset */
400
401 /* 16 bit offset from the zero data area pointer. */
402 HOWTO (R_V850_ZDA_16_16_SPLIT_OFFSET, /* type */
403 0, /* rightshift */
404 2, /* size (0 = byte, 1 = short, 2 = long) */
405 16, /* bitsize */
406 false, /* pc_relative */
407 0, /* bitpos */
408 complain_overflow_dont, /* complain_on_overflow */
409 v850_elf_reloc, /* special_function */
410 "R_V850_ZDA_16_16_SPLIT_OFFSET",/* name */
411 false, /* partial_inplace */
412 0xfffe0020, /* src_mask */
413 0xfffe0020, /* dst_mask */
414 false), /* pcrel_offset */
415
416 /* 6 bit offset from the call table base pointer. */
417 HOWTO (R_V850_CALLT_6_7_OFFSET, /* type */
418 0, /* rightshift */
419 1, /* size (0 = byte, 1 = short, 2 = long) */
420 7, /* bitsize */
421 false, /* pc_relative */
422 0, /* bitpos */
423 complain_overflow_dont, /* complain_on_overflow */
424 v850_elf_reloc, /* special_function */
425 "R_V850_CALLT_6_7_OFFSET", /* name */
426 false, /* partial_inplace */
427 0x3f, /* src_mask */
428 0x3f, /* dst_mask */
429 false), /* pcrel_offset */
430
431 /* 16 bit offset from the call table base pointer. */
432 HOWTO (R_V850_CALLT_16_16_OFFSET, /* type */
433 0, /* rightshift */
434 1, /* size (0 = byte, 1 = short, 2 = long) */
435 16, /* bitsize */
436 false, /* pc_relative */
437 0, /* bitpos */
438 complain_overflow_dont, /* complain_on_overflow */
439 v850_elf_reloc, /* special_function */
440 "R_V850_CALLT_16_16_OFFSET", /* name */
441 false, /* partial_inplace */
442 0xffff, /* src_mask */
443 0xffff, /* dst_mask */
444 false), /* pcrel_offset */
445
446 /* GNU extension to record C++ vtable hierarchy */
447 HOWTO (R_V850_GNU_VTINHERIT, /* type */
448 0, /* rightshift */
449 2, /* size (0 = byte, 1 = short, 2 = long) */
450 0, /* bitsize */
451 false, /* pc_relative */
452 0, /* bitpos */
453 complain_overflow_dont, /* complain_on_overflow */
454 NULL, /* special_function */
455 "R_V850_GNU_VTINHERIT", /* name */
456 false, /* partial_inplace */
457 0, /* src_mask */
458 0, /* dst_mask */
459 false), /* pcrel_offset */
460
461 /* GNU extension to record C++ vtable member usage */
462 HOWTO (R_V850_GNU_VTENTRY, /* type */
463 0, /* rightshift */
464 2, /* size (0 = byte, 1 = short, 2 = long) */
465 0, /* bitsize */
466 false, /* pc_relative */
467 0, /* bitpos */
468 complain_overflow_dont, /* complain_on_overflow */
469 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
470 "R_V850_GNU_VTENTRY", /* name */
471 false, /* partial_inplace */
472 0, /* src_mask */
473 0, /* dst_mask */
474 false), /* pcrel_offset */
475
476 /* Indicates a .longcall pseudo-op. The compiler will generate a .longcall
477 pseudo-op when it finds a function call which can be relaxed. */
478 HOWTO (R_V850_LONGCALL, /* type */
479 0, /* rightshift */
480 2, /* size (0 = byte, 1 = short, 2 = long) */
481 32, /* bitsize */
482 true, /* pc_relative */
483 0, /* bitpos */
484 complain_overflow_signed, /* complain_on_overflow */
485 v850_elf_ignore_reloc, /* special_function */
486 "R_V850_LONGCALL", /* name */
487 false, /* partial_inplace */
488 0, /* src_mask */
489 0, /* dst_mask */
490 true), /* pcrel_offset */
491
492 /* Indicates a .longjump pseudo-op. The compiler will generate a
493 .longjump pseudo-op when it finds a branch which can be relaxed. */
494 HOWTO (R_V850_LONGJUMP, /* type */
495 0, /* rightshift */
496 2, /* size (0 = byte, 1 = short, 2 = long) */
497 32, /* bitsize */
498 true, /* pc_relative */
499 0, /* bitpos */
500 complain_overflow_signed, /* complain_on_overflow */
501 v850_elf_ignore_reloc, /* special_function */
502 "R_V850_LONGJUMP", /* name */
503 false, /* partial_inplace */
504 0, /* src_mask */
505 0, /* dst_mask */
506 true), /* pcrel_offset */
507
508 HOWTO (R_V850_ALIGN, /* type */
509 0, /* rightshift */
510 1, /* size (0 = byte, 1 = short, 2 = long) */
511 0, /* bitsize */
512 false, /* pc_relative */
513 0, /* bitpos */
514 complain_overflow_unsigned, /* complain_on_overflow */
515 v850_elf_ignore_reloc, /* special_function */
516 "R_V850_ALIGN", /* name */
517 false, /* partial_inplace */
518 0, /* src_mask */
519 0, /* dst_mask */
520 true), /* pcrel_offset */
521 };
522
523 /* Map BFD reloc types to V850 ELF reloc types. */
524
525 struct v850_elf_reloc_map
526 {
527 /* BFD_RELOC_V850_CALLT_16_16_OFFSET is 258, which will not fix in an
528 unsigned char. */
529 bfd_reloc_code_real_type bfd_reloc_val;
530 unsigned int elf_reloc_val;
531 };
532
533 static const struct v850_elf_reloc_map v850_elf_reloc_map[] =
534 {
535 { BFD_RELOC_NONE, R_V850_NONE },
536 { BFD_RELOC_V850_9_PCREL, R_V850_9_PCREL },
537 { BFD_RELOC_V850_22_PCREL, R_V850_22_PCREL },
538 { BFD_RELOC_HI16_S, R_V850_HI16_S },
539 { BFD_RELOC_HI16, R_V850_HI16 },
540 { BFD_RELOC_LO16, R_V850_LO16 },
541 { BFD_RELOC_32, R_V850_32 },
542 { BFD_RELOC_16, R_V850_16 },
543 { BFD_RELOC_8, R_V850_8 },
544 { BFD_RELOC_V850_SDA_16_16_OFFSET, R_V850_SDA_16_16_OFFSET },
545 { BFD_RELOC_V850_SDA_15_16_OFFSET, R_V850_SDA_15_16_OFFSET },
546 { BFD_RELOC_V850_ZDA_16_16_OFFSET, R_V850_ZDA_16_16_OFFSET },
547 { BFD_RELOC_V850_ZDA_15_16_OFFSET, R_V850_ZDA_15_16_OFFSET },
548 { BFD_RELOC_V850_TDA_6_8_OFFSET, R_V850_TDA_6_8_OFFSET },
549 { BFD_RELOC_V850_TDA_7_8_OFFSET, R_V850_TDA_7_8_OFFSET },
550 { BFD_RELOC_V850_TDA_7_7_OFFSET, R_V850_TDA_7_7_OFFSET },
551 { BFD_RELOC_V850_TDA_16_16_OFFSET, R_V850_TDA_16_16_OFFSET },
552 { BFD_RELOC_V850_TDA_4_5_OFFSET, R_V850_TDA_4_5_OFFSET },
553 { BFD_RELOC_V850_TDA_4_4_OFFSET, R_V850_TDA_4_4_OFFSET },
554 { BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, R_V850_SDA_16_16_SPLIT_OFFSET },
555 { BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, R_V850_ZDA_16_16_SPLIT_OFFSET },
556 { BFD_RELOC_V850_CALLT_6_7_OFFSET, R_V850_CALLT_6_7_OFFSET },
557 { BFD_RELOC_V850_CALLT_16_16_OFFSET, R_V850_CALLT_16_16_OFFSET },
558 { BFD_RELOC_VTABLE_INHERIT, R_V850_GNU_VTINHERIT },
559 { BFD_RELOC_VTABLE_ENTRY, R_V850_GNU_VTENTRY },
560 { BFD_RELOC_V850_LONGCALL, R_V850_LONGCALL },
561 { BFD_RELOC_V850_LONGJUMP, R_V850_LONGJUMP },
562 { BFD_RELOC_V850_ALIGN, R_V850_ALIGN },
563
564 };
565 \f
566 /* Map a bfd relocation into the appropriate howto structure. */
567
568 static reloc_howto_type *
569 v850_elf_reloc_type_lookup (abfd, code)
570 bfd * abfd ATTRIBUTE_UNUSED;
571 bfd_reloc_code_real_type code;
572 {
573 unsigned int i;
574
575 for (i = ARRAY_SIZE (v850_elf_reloc_map); i --;)
576 if (v850_elf_reloc_map[i].bfd_reloc_val == code)
577 {
578 unsigned int elf_reloc_val = v850_elf_reloc_map[i].elf_reloc_val;
579
580 BFD_ASSERT (v850_elf_howto_table[elf_reloc_val].type == elf_reloc_val);
581
582 return v850_elf_howto_table + elf_reloc_val;
583 }
584
585 return NULL;
586 }
587 \f
588 /* Set the howto pointer for an V850 ELF reloc. */
589
590 static void
591 v850_elf_info_to_howto_rel (abfd, cache_ptr, dst)
592 bfd * abfd ATTRIBUTE_UNUSED;
593 arelent * cache_ptr;
594 Elf32_Internal_Rel * dst;
595 {
596 unsigned int r_type;
597
598 r_type = ELF32_R_TYPE (dst->r_info);
599 BFD_ASSERT (r_type < (unsigned int) R_V850_max);
600 cache_ptr->howto = &v850_elf_howto_table[r_type];
601 }
602
603 /* Set the howto pointer for a V850 ELF reloc (type RELA). */
604 static void
605 v850_elf_info_to_howto_rela (abfd, cache_ptr, dst)
606 bfd * abfd ATTRIBUTE_UNUSED;
607 arelent * cache_ptr;
608 Elf32_Internal_Rela *dst;
609 {
610 unsigned int r_type;
611
612 r_type = ELF32_R_TYPE (dst->r_info);
613 BFD_ASSERT (r_type < (unsigned int) R_V850_max);
614 cache_ptr->howto = &v850_elf_howto_table[r_type];
615 }
616 \f
617 /* Look through the relocs for a section during the first phase, and
618 allocate space in the global offset table or procedure linkage
619 table. */
620
621 static boolean
622 v850_elf_check_relocs (abfd, info, sec, relocs)
623 bfd * abfd;
624 struct bfd_link_info * info;
625 asection * sec;
626 const Elf_Internal_Rela * relocs;
627 {
628 boolean ret = true;
629 bfd *dynobj;
630 Elf_Internal_Shdr *symtab_hdr;
631 struct elf_link_hash_entry **sym_hashes;
632 const Elf_Internal_Rela *rel;
633 const Elf_Internal_Rela *rel_end;
634 asection *sreloc;
635 enum v850_reloc_type r_type;
636 int other = 0;
637 const char *common = (const char *)0;
638
639 if (info->relocateable)
640 return true;
641
642 #ifdef DEBUG
643 fprintf (stderr, "v850_elf_check_relocs called for section %s in %s\n",
644 bfd_get_section_name (abfd, sec),
645 bfd_archive_filename (abfd));
646 #endif
647
648 dynobj = elf_hash_table (info)->dynobj;
649 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
650 sym_hashes = elf_sym_hashes (abfd);
651 sreloc = NULL;
652
653 rel_end = relocs + sec->reloc_count;
654 for (rel = relocs; rel < rel_end; rel++)
655 {
656 unsigned long r_symndx;
657 struct elf_link_hash_entry *h;
658
659 r_symndx = ELF32_R_SYM (rel->r_info);
660 if (r_symndx < symtab_hdr->sh_info)
661 h = NULL;
662 else
663 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
664
665 r_type = (enum v850_reloc_type) ELF32_R_TYPE (rel->r_info);
666 switch (r_type)
667 {
668 default:
669 case R_V850_NONE:
670 case R_V850_9_PCREL:
671 case R_V850_22_PCREL:
672 case R_V850_HI16_S:
673 case R_V850_HI16:
674 case R_V850_LO16:
675 case R_V850_32:
676 case R_V850_16:
677 case R_V850_8:
678 case R_V850_CALLT_6_7_OFFSET:
679 case R_V850_CALLT_16_16_OFFSET:
680 break;
681
682 /* This relocation describes the C++ object vtable hierarchy.
683 Reconstruct it for later use during GC. */
684 case R_V850_GNU_VTINHERIT:
685 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
686 return false;
687 break;
688
689 /* This relocation describes which C++ vtable entries
690 are actually used. Record for later use during GC. */
691 case R_V850_GNU_VTENTRY:
692 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
693 return false;
694 break;
695
696 case R_V850_SDA_16_16_SPLIT_OFFSET:
697 case R_V850_SDA_16_16_OFFSET:
698 case R_V850_SDA_15_16_OFFSET:
699 other = V850_OTHER_SDA;
700 common = ".scommon";
701 goto small_data_common;
702
703 case R_V850_ZDA_16_16_SPLIT_OFFSET:
704 case R_V850_ZDA_16_16_OFFSET:
705 case R_V850_ZDA_15_16_OFFSET:
706 other = V850_OTHER_ZDA;
707 common = ".zcommon";
708 goto small_data_common;
709
710 case R_V850_TDA_4_5_OFFSET:
711 case R_V850_TDA_4_4_OFFSET:
712 case R_V850_TDA_6_8_OFFSET:
713 case R_V850_TDA_7_8_OFFSET:
714 case R_V850_TDA_7_7_OFFSET:
715 case R_V850_TDA_16_16_OFFSET:
716 other = V850_OTHER_TDA;
717 common = ".tcommon";
718 /* fall through */
719
720 #define V850_OTHER_MASK (V850_OTHER_TDA | V850_OTHER_SDA | V850_OTHER_ZDA)
721
722 small_data_common:
723 if (h)
724 {
725 /* Flag which type of relocation was used. */
726 h->other |= other;
727 if ((h->other & V850_OTHER_MASK) != (other & V850_OTHER_MASK)
728 && (h->other & V850_OTHER_ERROR) == 0)
729 {
730 const char * msg;
731 static char buff[200]; /* XXX */
732
733 switch (h->other & V850_OTHER_MASK)
734 {
735 default:
736 msg = _("Variable `%s' cannot occupy in multiple small data regions");
737 break;
738 case V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA:
739 msg = _("Variable `%s' can only be in one of the small, zero, and tiny data regions");
740 break;
741 case V850_OTHER_SDA | V850_OTHER_ZDA:
742 msg = _("Variable `%s' cannot be in both small and zero data regions simultaneously");
743 break;
744 case V850_OTHER_SDA | V850_OTHER_TDA:
745 msg = _("Variable `%s' cannot be in both small and tiny data regions simultaneously");
746 break;
747 case V850_OTHER_ZDA | V850_OTHER_TDA:
748 msg = _("Variable `%s' cannot be in both zero and tiny data regions simultaneously");
749 break;
750 }
751
752 sprintf (buff, msg, h->root.root.string);
753 info->callbacks->warning (info, buff, h->root.root.string,
754 abfd, h->root.u.def.section,
755 (bfd_vma) 0);
756
757 bfd_set_error (bfd_error_bad_value);
758 h->other |= V850_OTHER_ERROR;
759 ret = false;
760 }
761 }
762
763 if (h && h->root.type == bfd_link_hash_common
764 && h->root.u.c.p
765 && !strcmp (bfd_get_section_name (abfd, h->root.u.c.p->section), "COMMON"))
766 {
767 asection * section;
768
769 section = h->root.u.c.p->section = bfd_make_section_old_way (abfd, common);
770 section->flags |= SEC_IS_COMMON;
771 }
772
773 #ifdef DEBUG
774 fprintf (stderr, "v850_elf_check_relocs, found %s relocation for %s%s\n",
775 v850_elf_howto_table[ (int)r_type ].name,
776 (h && h->root.root.string) ? h->root.root.string : "<unknown>",
777 (h->root.type == bfd_link_hash_common) ? ", symbol is common" : "");
778 #endif
779 break;
780 }
781 }
782
783 return ret;
784 }
785
786 /* In the old version, when an entry was checked out from the table,
787 it was deleted. This produced an error if the entry was needed
788 more than once, as the second attempted retry failed.
789
790 In the current version, the entry is not deleted, instead we set
791 the field 'found' to true. If a second lookup matches the same
792 entry, then we know that the hi16s reloc has already been updated
793 and does not need to be updated a second time.
794
795 TODO - TOFIX: If it is possible that we need to restore 2 different
796 addresses from the same table entry, where the first generates an
797 overflow, whilst the second do not, then this code will fail. */
798
799 typedef struct hi16s_location
800 {
801 bfd_vma addend;
802 bfd_byte * address;
803 unsigned long counter;
804 boolean found;
805 struct hi16s_location * next;
806 }
807 hi16s_location;
808
809 static hi16s_location * previous_hi16s;
810 static hi16s_location * free_hi16s;
811 static unsigned long hi16s_counter;
812
813 static void
814 remember_hi16s_reloc (abfd, addend, address)
815 bfd * abfd;
816 bfd_vma addend;
817 bfd_byte * address;
818 {
819 hi16s_location * entry = NULL;
820 bfd_size_type amt = sizeof (* free_hi16s);
821
822 /* Find a free structure. */
823 if (free_hi16s == NULL)
824 free_hi16s = (hi16s_location *) bfd_zalloc (abfd, amt);
825
826 entry = free_hi16s;
827 free_hi16s = free_hi16s->next;
828
829 entry->addend = addend;
830 entry->address = address;
831 entry->counter = hi16s_counter ++;
832 entry->found = false;
833 entry->next = previous_hi16s;
834 previous_hi16s = entry;
835
836 /* Cope with wrap around of our counter. */
837 if (hi16s_counter == 0)
838 {
839 /* XXX - Assume that all counter entries differ only in their low 16 bits. */
840 for (entry = previous_hi16s; entry != NULL; entry = entry->next)
841 entry->counter &= 0xffff;
842
843 hi16s_counter = 0x10000;
844 }
845
846 return;
847 }
848
849 static bfd_byte *
850 find_remembered_hi16s_reloc (addend, already_found)
851 bfd_vma addend;
852 boolean * already_found;
853 {
854 hi16s_location * match = NULL;
855 hi16s_location * entry;
856 hi16s_location * previous = NULL;
857 hi16s_location * prev;
858 bfd_byte * addr;
859
860 /* Search the table. Record the most recent entry that matches. */
861 for (entry = previous_hi16s; entry; entry = entry->next)
862 {
863 if (entry->addend == addend
864 && (match == NULL || match->counter < entry->counter))
865 {
866 previous = prev;
867 match = entry;
868 }
869
870 prev = entry;
871 }
872
873 if (match == NULL)
874 return NULL;
875
876 /* Extract the address. */
877 addr = match->address;
878
879 /* Remeber if this entry has already been used before. */
880 if (already_found)
881 * already_found = match->found;
882
883 /* Note that this entry has now been used. */
884 match->found = true;
885
886 return addr;
887 }
888
889 /* FIXME: The code here probably ought to be removed and the code in reloc.c
890 allowed to do its stuff instead. At least for most of the relocs, anwyay. */
891
892 static bfd_reloc_status_type
893 v850_elf_perform_relocation (abfd, r_type, addend, address)
894 bfd *abfd;
895 unsigned int r_type;
896 bfd_vma addend;
897 bfd_byte *address;
898 {
899 unsigned long insn;
900 bfd_signed_vma saddend = (bfd_signed_vma) addend;
901
902 switch (r_type)
903 {
904 default:
905 /* fprintf (stderr, "reloc type %d not SUPPORTED\n", r_type ); */
906 return bfd_reloc_notsupported;
907
908 case R_V850_32:
909 bfd_put_32 (abfd, addend, address);
910 return bfd_reloc_ok;
911
912 case R_V850_22_PCREL:
913 if (saddend > 0x1fffff || saddend < -0x200000)
914 return bfd_reloc_overflow;
915
916 if ((addend % 2) != 0)
917 return bfd_reloc_dangerous;
918
919 insn = bfd_get_32 (abfd, address);
920 insn &= ~0xfffe003f;
921 insn |= (((addend & 0xfffe) << 16) | ((addend & 0x3f0000) >> 16));
922 bfd_put_32 (abfd, (bfd_vma) insn, address);
923 return bfd_reloc_ok;
924
925 case R_V850_9_PCREL:
926 if (saddend > 0xff || saddend < -0x100)
927 return bfd_reloc_overflow;
928
929 if ((addend % 2) != 0)
930 return bfd_reloc_dangerous;
931
932 insn = bfd_get_16 (abfd, address);
933 insn &= ~ 0xf870;
934 insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3);
935 break;
936
937 case R_V850_HI16:
938 addend += (bfd_get_16 (abfd, address) << 16);
939 addend = (addend >> 16);
940 insn = addend;
941 break;
942
943 case R_V850_HI16_S:
944 /* Remember where this relocation took place. */
945 remember_hi16s_reloc (abfd, addend, address);
946
947 addend += (bfd_get_16 (abfd, address) << 16);
948 addend = (addend >> 16) + ((addend & 0x8000) != 0);
949
950 /* This relocation cannot overflow. */
951 if (addend > 0x7fff)
952 addend = 0;
953
954 insn = addend;
955 break;
956
957 case R_V850_LO16:
958 /* Calculate the sum of the value stored in the instruction and the
959 addend and check for overflow from the low 16 bits into the high
960 16 bits. The assembler has already done some of this: If the
961 value stored in the instruction has its 15th bit set, (counting
962 from zero) then the assembler will have added 1 to the value
963 stored in the associated HI16S reloc. So for example, these
964 relocations:
965
966 movhi hi( fred ), r0, r1
967 movea lo( fred ), r1, r1
968
969 will store 0 in the value fields for the MOVHI and MOVEA instructions
970 and addend will be the address of fred, but for these instructions:
971
972 movhi hi( fred + 0x123456), r0, r1
973 movea lo( fred + 0x123456), r1, r1
974
975 the value stored in the MOVHI instruction will be 0x12 and the value
976 stored in the MOVEA instruction will be 0x3456. If however the
977 instructions were:
978
979 movhi hi( fred + 0x10ffff), r0, r1
980 movea lo( fred + 0x10ffff), r1, r1
981
982 then the value stored in the MOVHI instruction would be 0x11 (not
983 0x10) and the value stored in the MOVEA instruction would be 0xffff.
984 Thus (assuming for the moment that the addend is 0), at run time the
985 MOVHI instruction loads 0x110000 into r1, then the MOVEA instruction
986 adds 0xffffffff (sign extension!) producing 0x10ffff. Similarly if
987 the instructions were:
988
989 movhi hi( fred - 1), r0, r1
990 movea lo( fred - 1), r1, r1
991
992 then 0 is stored in the MOVHI instruction and -1 is stored in the
993 MOVEA instruction.
994
995 Overflow can occur if the addition of the value stored in the
996 instruction plus the addend sets the 15th bit when before it was clear.
997 This is because the 15th bit will be sign extended into the high part,
998 thus reducing its value by one, but since the 15th bit was originally
999 clear, the assembler will not have added 1 to the previous HI16S reloc
1000 to compensate for this effect. For example:
1001
1002 movhi hi( fred + 0x123456), r0, r1
1003 movea lo( fred + 0x123456), r1, r1
1004
1005 The value stored in HI16S reloc is 0x12, the value stored in the LO16
1006 reloc is 0x3456. If we assume that the address of fred is 0x00007000
1007 then the relocations become:
1008
1009 HI16S: 0x0012 + (0x00007000 >> 16) = 0x12
1010 LO16: 0x3456 + (0x00007000 & 0xffff) = 0xa456
1011
1012 but when the instructions are executed, the MOVEA instruction's value
1013 is signed extended, so the sum becomes:
1014
1015 0x00120000
1016 + 0xffffa456
1017 ------------
1018 0x0011a456 but 'fred + 0x123456' = 0x0012a456
1019
1020 Note that if the 15th bit was set in the value stored in the LO16
1021 reloc, then we do not have to do anything:
1022
1023 movhi hi( fred + 0x10ffff), r0, r1
1024 movea lo( fred + 0x10ffff), r1, r1
1025
1026 HI16S: 0x0011 + (0x00007000 >> 16) = 0x11
1027 LO16: 0xffff + (0x00007000 & 0xffff) = 0x6fff
1028
1029 0x00110000
1030 + 0x00006fff
1031 ------------
1032 0x00116fff = fred + 0x10ffff = 0x7000 + 0x10ffff
1033
1034 Overflow can also occur if the computation carries into the 16th bit
1035 and it also results in the 15th bit having the same value as the 15th
1036 bit of the original value. What happens is that the HI16S reloc
1037 will have already examined the 15th bit of the original value and
1038 added 1 to the high part if the bit is set. This compensates for the
1039 sign extension of 15th bit of the result of the computation. But now
1040 there is a carry into the 16th bit, and this has not been allowed for.
1041
1042 So, for example if fred is at address 0xf000:
1043
1044 movhi hi( fred + 0xffff), r0, r1 [bit 15 of the offset is set]
1045 movea lo( fred + 0xffff), r1, r1
1046
1047 HI16S: 0x0001 + (0x0000f000 >> 16) = 0x0001
1048 LO16: 0xffff + (0x0000f000 & 0xffff) = 0xefff (carry into bit 16 is lost)
1049
1050 0x00010000
1051 + 0xffffefff
1052 ------------
1053 0x0000efff but 'fred + 0xffff' = 0x0001efff
1054
1055 Similarly, if the 15th bit remains clear, but overflow occurs into
1056 the 16th bit then (assuming the address of fred is 0xf000):
1057
1058 movhi hi( fred + 0x7000), r0, r1 [bit 15 of the offset is clear]
1059 movea lo( fred + 0x7000), r1, r1
1060
1061 HI16S: 0x0000 + (0x0000f000 >> 16) = 0x0000
1062 LO16: 0x7000 + (0x0000f000 & 0xffff) = 0x6fff (carry into bit 16 is lost)
1063
1064 0x00000000
1065 + 0x00006fff
1066 ------------
1067 0x00006fff but 'fred + 0x7000' = 0x00016fff
1068
1069 Note - there is no need to change anything if a carry occurs, and the
1070 15th bit changes its value from being set to being clear, as the HI16S
1071 reloc will have already added in 1 to the high part for us:
1072
1073 movhi hi( fred + 0xffff), r0, r1 [bit 15 of the offset is set]
1074 movea lo( fred + 0xffff), r1, r1
1075
1076 HI16S: 0x0001 + (0x00007000 >> 16)
1077 LO16: 0xffff + (0x00007000 & 0xffff) = 0x6fff (carry into bit 16 is lost)
1078
1079 0x00010000
1080 + 0x00006fff (bit 15 not set, so the top half is zero)
1081 ------------
1082 0x00016fff which is right (assuming that fred is at 0x7000)
1083
1084 but if the 15th bit goes from being clear to being set, then we must
1085 once again handle overflow:
1086
1087 movhi hi( fred + 0x7000), r0, r1 [bit 15 of the offset is clear]
1088 movea lo( fred + 0x7000), r1, r1
1089
1090 HI16S: 0x0000 + (0x0000ffff >> 16)
1091 LO16: 0x7000 + (0x0000ffff & 0xffff) = 0x6fff (carry into bit 16)
1092
1093 0x00000000
1094 + 0x00006fff (bit 15 not set, so the top half is zero)
1095 ------------
1096 0x00006fff which is wrong (assuming that fred is at 0xffff). */
1097 {
1098 long result;
1099
1100 insn = bfd_get_16 (abfd, address);
1101 result = insn + addend;
1102
1103 #define BIT15_SET(x) ((x) & 0x8000)
1104 #define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff)
1105
1106 if ((BIT15_SET (result) && ! BIT15_SET (addend))
1107 || (OVERFLOWS (addend, insn)
1108 && ((! BIT15_SET (insn)) || (BIT15_SET (addend)))))
1109 {
1110 boolean already_updated;
1111 bfd_byte * hi16s_address = find_remembered_hi16s_reloc
1112 (addend, & already_updated);
1113
1114 /* Amend the matching HI16_S relocation. */
1115 if (hi16s_address != NULL)
1116 {
1117 if (! already_updated)
1118 {
1119 insn = bfd_get_16 (abfd, hi16s_address);
1120 insn += 1;
1121 bfd_put_16 (abfd, (bfd_vma) insn, hi16s_address);
1122 }
1123 }
1124 else
1125 {
1126 fprintf (stderr, _("FAILED to find previous HI16 reloc\n"));
1127 return bfd_reloc_overflow;
1128 }
1129 }
1130
1131 /* Do not complain if value has top bit set, as this has been anticipated. */
1132 insn = result & 0xffff;
1133 break;
1134 }
1135
1136 case R_V850_8:
1137 addend += (char) bfd_get_8 (abfd, address);
1138
1139 saddend = (bfd_signed_vma) addend;
1140
1141 if (saddend > 0x7f || saddend < -0x80)
1142 return bfd_reloc_overflow;
1143
1144 bfd_put_8 (abfd, addend, address);
1145 return bfd_reloc_ok;
1146
1147 case R_V850_CALLT_16_16_OFFSET:
1148 addend += bfd_get_16 (abfd, address);
1149
1150 saddend = (bfd_signed_vma) addend;
1151
1152 if (saddend > 0xffff || saddend < 0)
1153 return bfd_reloc_overflow;
1154
1155 insn = addend;
1156 break;
1157
1158 case R_V850_16:
1159
1160 /* drop through */
1161 case R_V850_SDA_16_16_OFFSET:
1162 case R_V850_ZDA_16_16_OFFSET:
1163 case R_V850_TDA_16_16_OFFSET:
1164 addend += bfd_get_16 (abfd, address);
1165
1166 saddend = (bfd_signed_vma) addend;
1167
1168 if (saddend > 0x7fff || saddend < -0x8000)
1169 return bfd_reloc_overflow;
1170
1171 insn = addend;
1172 break;
1173
1174 case R_V850_SDA_15_16_OFFSET:
1175 case R_V850_ZDA_15_16_OFFSET:
1176 insn = bfd_get_16 (abfd, address);
1177 addend += (insn & 0xfffe);
1178
1179 saddend = (bfd_signed_vma) addend;
1180
1181 if (saddend > 0x7ffe || saddend < -0x8000)
1182 return bfd_reloc_overflow;
1183
1184 if (addend & 1)
1185 return bfd_reloc_dangerous;
1186
1187 insn = (addend &~ (bfd_vma) 1) | (insn & 1);
1188 break;
1189
1190 case R_V850_TDA_6_8_OFFSET:
1191 insn = bfd_get_16 (abfd, address);
1192 addend += ((insn & 0x7e) << 1);
1193
1194 saddend = (bfd_signed_vma) addend;
1195
1196 if (saddend > 0xfc || saddend < 0)
1197 return bfd_reloc_overflow;
1198
1199 if (addend & 3)
1200 return bfd_reloc_dangerous;
1201
1202 insn &= 0xff81;
1203 insn |= (addend >> 1);
1204 break;
1205
1206 case R_V850_TDA_7_8_OFFSET:
1207 insn = bfd_get_16 (abfd, address);
1208 addend += ((insn & 0x7f) << 1);
1209
1210 saddend = (bfd_signed_vma) addend;
1211
1212 if (saddend > 0xfe || saddend < 0)
1213 return bfd_reloc_overflow;
1214
1215 if (addend & 1)
1216 return bfd_reloc_dangerous;
1217
1218 insn &= 0xff80;
1219 insn |= (addend >> 1);
1220 break;
1221
1222 case R_V850_TDA_7_7_OFFSET:
1223 insn = bfd_get_16 (abfd, address);
1224 addend += insn & 0x7f;
1225
1226 saddend = (bfd_signed_vma) addend;
1227
1228 if (saddend > 0x7f || saddend < 0)
1229 return bfd_reloc_overflow;
1230
1231 insn &= 0xff80;
1232 insn |= addend;
1233 break;
1234
1235 case R_V850_TDA_4_5_OFFSET:
1236 insn = bfd_get_16 (abfd, address);
1237 addend += ((insn & 0xf) << 1);
1238
1239 saddend = (bfd_signed_vma) addend;
1240
1241 if (saddend > 0x1e || saddend < 0)
1242 return bfd_reloc_overflow;
1243
1244 if (addend & 1)
1245 return bfd_reloc_dangerous;
1246
1247 insn &= 0xfff0;
1248 insn |= (addend >> 1);
1249 break;
1250
1251 case R_V850_TDA_4_4_OFFSET:
1252 insn = bfd_get_16 (abfd, address);
1253 addend += insn & 0xf;
1254
1255 saddend = (bfd_signed_vma) addend;
1256
1257 if (saddend > 0xf || saddend < 0)
1258 return bfd_reloc_overflow;
1259
1260 insn &= 0xfff0;
1261 insn |= addend;
1262 break;
1263
1264 case R_V850_ZDA_16_16_SPLIT_OFFSET:
1265 case R_V850_SDA_16_16_SPLIT_OFFSET:
1266 insn = bfd_get_32 (abfd, address);
1267 addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5);
1268
1269 saddend = (bfd_signed_vma) addend;
1270
1271 if (saddend > 0x7fff || saddend < -0x8000)
1272 return bfd_reloc_overflow;
1273
1274 insn &= 0x0001ffdf;
1275 insn |= (addend & 1) << 5;
1276 insn |= (addend &~ (bfd_vma) 1) << 16;
1277
1278 bfd_put_32 (abfd, (bfd_vma) insn, address);
1279 return bfd_reloc_ok;
1280
1281 case R_V850_CALLT_6_7_OFFSET:
1282 insn = bfd_get_16 (abfd, address);
1283 addend += ((insn & 0x3f) << 1);
1284
1285 saddend = (bfd_signed_vma) addend;
1286
1287 if (saddend > 0x7e || saddend < 0)
1288 return bfd_reloc_overflow;
1289
1290 if (addend & 1)
1291 return bfd_reloc_dangerous;
1292
1293 insn &= 0xff80;
1294 insn |= (addend >> 1);
1295 break;
1296
1297 case R_V850_GNU_VTINHERIT:
1298 case R_V850_GNU_VTENTRY:
1299 return bfd_reloc_ok;
1300
1301 }
1302
1303 bfd_put_16 (abfd, (bfd_vma) insn, address);
1304 return bfd_reloc_ok;
1305 }
1306 \f
1307 /* Insert the addend into the instruction. */
1308
1309 static bfd_reloc_status_type
1310 v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
1311 bfd * abfd ATTRIBUTE_UNUSED;
1312 arelent * reloc;
1313 asymbol * symbol;
1314 PTR data ATTRIBUTE_UNUSED;
1315 asection * isection;
1316 bfd * obfd;
1317 char ** err ATTRIBUTE_UNUSED;
1318 {
1319 long relocation;
1320
1321 /* If there is an output BFD,
1322 and the symbol is not a section name (which is only defined at final link time),
1323 and either we are not putting the addend into the instruction
1324 or the addend is zero, so there is nothing to add into the instruction
1325 then just fixup the address and return. */
1326 if (obfd != (bfd *) NULL
1327 && (symbol->flags & BSF_SECTION_SYM) == 0
1328 && (! reloc->howto->partial_inplace
1329 || reloc->addend == 0))
1330 {
1331 reloc->address += isection->output_offset;
1332 return bfd_reloc_ok;
1333 }
1334
1335 /* Catch relocs involving undefined symbols. */
1336 if (bfd_is_und_section (symbol->section)
1337 && (symbol->flags & BSF_WEAK) == 0
1338 && obfd == NULL)
1339 return bfd_reloc_undefined;
1340
1341 /* We handle final linking of some relocs ourselves. */
1342
1343 /* Is the address of the relocation really within the section? */
1344 if (reloc->address > isection->_cooked_size)
1345 return bfd_reloc_outofrange;
1346
1347 /* Work out which section the relocation is targetted at and the
1348 initial relocation command value. */
1349
1350 if (reloc->howto->pc_relative == true)
1351 return bfd_reloc_ok;
1352
1353 /* Get symbol value. (Common symbols are special.) */
1354 if (bfd_is_com_section (symbol->section))
1355 relocation = 0;
1356 else
1357 relocation = symbol->value;
1358
1359 /* Convert input-section-relative symbol value to absolute + addend. */
1360 relocation += symbol->section->output_section->vma;
1361 relocation += symbol->section->output_offset;
1362 relocation += reloc->addend;
1363
1364 #if 0 /* Since this reloc is going to be processed later on, we should
1365 not make it pc-relative here. To test this, try assembling and
1366 linking this program:
1367
1368 .text
1369 .globl _start
1370 nop
1371 _start:
1372 jr foo
1373
1374 .section ".foo","ax"
1375 nop
1376 foo:
1377 nop */
1378 if (reloc->howto->pc_relative)
1379 {
1380 /* Here the variable relocation holds the final address of the
1381 symbol we are relocating against, plus any addend. */
1382 relocation -= isection->output_section->vma + isection->output_offset;
1383
1384 /* Deal with pcrel_offset. */
1385 relocation -= reloc->address;
1386 }
1387 #endif
1388 reloc->addend = relocation;
1389 return bfd_reloc_ok;
1390 }
1391
1392 /* This function is used for relocs which are only used
1393 for relaxing, which the linker should otherwise ignore. */
1394
1395 static bfd_reloc_status_type
1396 v850_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
1397 output_bfd, error_message)
1398 bfd * abfd ATTRIBUTE_UNUSED;
1399 arelent * reloc_entry;
1400 asymbol * symbol ATTRIBUTE_UNUSED;
1401 PTR data ATTRIBUTE_UNUSED;
1402 asection * input_section;
1403 bfd * output_bfd;
1404 char ** error_message ATTRIBUTE_UNUSED;
1405 {
1406 if (output_bfd != NULL)
1407 reloc_entry->address += input_section->output_offset;
1408
1409 return bfd_reloc_ok;
1410 }
1411 \f
1412 static boolean
1413 v850_elf_is_local_label_name (abfd, name)
1414 bfd * abfd ATTRIBUTE_UNUSED;
1415 const char * name;
1416 {
1417 return ( (name[0] == '.' && (name[1] == 'L' || name[1] == '.'))
1418 || (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_'));
1419 }
1420 \f
1421 /* We overload some of the bfd_reloc error codes for own purposes. */
1422 #define bfd_reloc_gp_not_found bfd_reloc_other
1423 #define bfd_reloc_ep_not_found bfd_reloc_continue
1424 #define bfd_reloc_ctbp_not_found (bfd_reloc_dangerous + 1)
1425
1426 /* Perform a relocation as part of a final link. */
1427
1428 static bfd_reloc_status_type
1429 v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1430 input_section, contents, offset, value,
1431 addend, info, sym_sec, is_local)
1432 reloc_howto_type * howto;
1433 bfd * input_bfd;
1434 bfd * output_bfd ATTRIBUTE_UNUSED;
1435 asection * input_section;
1436 bfd_byte * contents;
1437 bfd_vma offset;
1438 bfd_vma value;
1439 bfd_vma addend;
1440 struct bfd_link_info * info;
1441 asection * sym_sec;
1442 int is_local ATTRIBUTE_UNUSED;
1443 {
1444 unsigned int r_type = howto->type;
1445 bfd_byte * hit_data = contents + offset;
1446
1447 /* Adjust the value according to the relocation. */
1448 switch (r_type)
1449 {
1450 case R_V850_9_PCREL:
1451 value -= (input_section->output_section->vma
1452 + input_section->output_offset);
1453 value -= offset;
1454 break;
1455
1456 case R_V850_22_PCREL:
1457 value -= (input_section->output_section->vma
1458 + input_section->output_offset
1459 + offset);
1460
1461 /* If the sign extension will corrupt the value then we have overflowed. */
1462 if (((value & 0xff000000) != 0x0) && ((value & 0xff000000) != 0xff000000))
1463 return bfd_reloc_overflow;
1464
1465 /* Only the bottom 24 bits of the PC are valid */
1466 value = SEXT24 (value);
1467 break;
1468
1469 case R_V850_HI16_S:
1470 case R_V850_HI16:
1471 case R_V850_LO16:
1472 case R_V850_16:
1473 case R_V850_32:
1474 case R_V850_8:
1475 break;
1476
1477 case R_V850_ZDA_15_16_OFFSET:
1478 case R_V850_ZDA_16_16_OFFSET:
1479 case R_V850_ZDA_16_16_SPLIT_OFFSET:
1480 if (sym_sec == NULL)
1481 return bfd_reloc_undefined;
1482
1483 value -= sym_sec->output_section->vma;
1484 break;
1485
1486 case R_V850_SDA_15_16_OFFSET:
1487 case R_V850_SDA_16_16_OFFSET:
1488 case R_V850_SDA_16_16_SPLIT_OFFSET:
1489 {
1490 unsigned long gp;
1491 struct bfd_link_hash_entry * h;
1492
1493 if (sym_sec == NULL)
1494 return bfd_reloc_undefined;
1495
1496 /* Get the value of __gp. */
1497 h = bfd_link_hash_lookup (info->hash, "__gp", false, false, true);
1498 if (h == (struct bfd_link_hash_entry *) NULL
1499 || h->type != bfd_link_hash_defined)
1500 return bfd_reloc_gp_not_found;
1501
1502 gp = (h->u.def.value
1503 + h->u.def.section->output_section->vma
1504 + h->u.def.section->output_offset);
1505
1506 value -= sym_sec->output_section->vma;
1507 value -= (gp - sym_sec->output_section->vma);
1508 }
1509 break;
1510
1511 case R_V850_TDA_4_4_OFFSET:
1512 case R_V850_TDA_4_5_OFFSET:
1513 case R_V850_TDA_16_16_OFFSET:
1514 case R_V850_TDA_7_7_OFFSET:
1515 case R_V850_TDA_7_8_OFFSET:
1516 case R_V850_TDA_6_8_OFFSET:
1517 {
1518 unsigned long ep;
1519 struct bfd_link_hash_entry * h;
1520
1521 /* Get the value of __ep. */
1522 h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
1523 if (h == (struct bfd_link_hash_entry *) NULL
1524 || h->type != bfd_link_hash_defined)
1525 return bfd_reloc_ep_not_found;
1526
1527 ep = (h->u.def.value
1528 + h->u.def.section->output_section->vma
1529 + h->u.def.section->output_offset);
1530
1531 value -= ep;
1532 }
1533 break;
1534
1535 case R_V850_CALLT_6_7_OFFSET:
1536 {
1537 unsigned long ctbp;
1538 struct bfd_link_hash_entry * h;
1539
1540 /* Get the value of __ctbp. */
1541 h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
1542 if (h == (struct bfd_link_hash_entry *) NULL
1543 || h->type != bfd_link_hash_defined)
1544 return bfd_reloc_ctbp_not_found;
1545
1546 ctbp = (h->u.def.value
1547 + h->u.def.section->output_section->vma
1548 + h->u.def.section->output_offset);
1549 value -= ctbp;
1550 }
1551 break;
1552
1553 case R_V850_CALLT_16_16_OFFSET:
1554 {
1555 unsigned long ctbp;
1556 struct bfd_link_hash_entry * h;
1557
1558 if (sym_sec == NULL)
1559 return bfd_reloc_undefined;
1560
1561 /* Get the value of __ctbp. */
1562 h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
1563 if (h == (struct bfd_link_hash_entry *) NULL
1564 || h->type != bfd_link_hash_defined)
1565 return bfd_reloc_ctbp_not_found;
1566
1567 ctbp = (h->u.def.value
1568 + h->u.def.section->output_section->vma
1569 + h->u.def.section->output_offset);
1570
1571 value -= sym_sec->output_section->vma;
1572 value -= (ctbp - sym_sec->output_section->vma);
1573 }
1574 break;
1575
1576 case R_V850_NONE:
1577 case R_V850_GNU_VTINHERIT:
1578 case R_V850_GNU_VTENTRY:
1579 case R_V850_LONGCALL:
1580 case R_V850_LONGJUMP:
1581 case R_V850_ALIGN:
1582 return bfd_reloc_ok;
1583
1584 default:
1585 return bfd_reloc_notsupported;
1586 }
1587
1588 /* Perform the relocation. */
1589 return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
1590 }
1591 \f
1592 /* Relocate an V850 ELF section. */
1593
1594 static boolean
1595 v850_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1596 contents, relocs, local_syms, local_sections)
1597 bfd * output_bfd;
1598 struct bfd_link_info * info;
1599 bfd * input_bfd;
1600 asection * input_section;
1601 bfd_byte * contents;
1602 Elf_Internal_Rela * relocs;
1603 Elf_Internal_Sym * local_syms;
1604 asection ** local_sections;
1605 {
1606 Elf_Internal_Shdr * symtab_hdr;
1607 struct elf_link_hash_entry ** sym_hashes;
1608 Elf_Internal_Rela * rel;
1609 Elf_Internal_Rela * relend;
1610
1611 if (info->relocateable)
1612 return true;
1613
1614 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1615 sym_hashes = elf_sym_hashes (input_bfd);
1616
1617 if (sym_hashes == NULL)
1618 {
1619 info->callbacks->warning
1620 (info, "no hash table available",
1621 NULL, input_bfd, input_section, (bfd_vma) 0);
1622
1623 return false;
1624 }
1625
1626 /* Reset the list of remembered HI16S relocs to empty. */
1627 free_hi16s = previous_hi16s;
1628 previous_hi16s = NULL;
1629 hi16s_counter = 0;
1630
1631 rel = relocs;
1632 relend = relocs + input_section->reloc_count;
1633 for (; rel < relend; rel++)
1634 {
1635 int r_type;
1636 reloc_howto_type * howto;
1637 unsigned long r_symndx;
1638 Elf_Internal_Sym * sym;
1639 asection * sec;
1640 struct elf_link_hash_entry * h;
1641 bfd_vma relocation;
1642 bfd_reloc_status_type r;
1643
1644 r_symndx = ELF32_R_SYM (rel->r_info);
1645 r_type = ELF32_R_TYPE (rel->r_info);
1646
1647 if (r_type == R_V850_GNU_VTENTRY
1648 || r_type == R_V850_GNU_VTINHERIT)
1649 continue;
1650
1651 /* This is a final link. */
1652 howto = v850_elf_howto_table + r_type;
1653 h = NULL;
1654 sym = NULL;
1655 sec = NULL;
1656 if (r_symndx < symtab_hdr->sh_info)
1657 {
1658 sym = local_syms + r_symndx;
1659 sec = local_sections[r_symndx];
1660 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1661 #if 0
1662 {
1663 char * name;
1664
1665 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name);
1666 name = (name == NULL) ? "<none>" : name;
1667 fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
1668 sec->name, name, sym->st_name,
1669 sec->output_section->vma, sec->output_offset, sym->st_value, rel->r_addend);
1670 }
1671 #endif
1672 }
1673 else
1674 {
1675 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1676
1677 while (h->root.type == bfd_link_hash_indirect
1678 || h->root.type == bfd_link_hash_warning)
1679 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1680
1681 if (h->root.type == bfd_link_hash_defined
1682 || h->root.type == bfd_link_hash_defweak)
1683 {
1684 sec = h->root.u.def.section;
1685 relocation = (h->root.u.def.value
1686 + sec->output_section->vma
1687 + sec->output_offset);
1688 #if 0
1689 fprintf (stderr, "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
1690 sec->name, h->root.root.string, h->root.u.def.value, sec->output_section->vma, sec->output_offset, relocation);
1691 #endif
1692 }
1693 else if (h->root.type == bfd_link_hash_undefweak)
1694 {
1695 #if 0
1696 fprintf (stderr, "undefined: sec: %s, name: %s\n",
1697 sec->name, h->root.root.string);
1698 #endif
1699 relocation = 0;
1700 }
1701 else
1702 {
1703 if (! ((*info->callbacks->undefined_symbol)
1704 (info, h->root.root.string, input_bfd,
1705 input_section, rel->r_offset, true)))
1706 return false;
1707 #if 0
1708 fprintf (stderr, "unknown: name: %s\n", h->root.root.string);
1709 #endif
1710 relocation = 0;
1711 }
1712 }
1713
1714 /* FIXME: We should use the addend, but the COFF relocations don't. */
1715 r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1716 input_section,
1717 contents, rel->r_offset,
1718 relocation, rel->r_addend,
1719 info, sec, h == NULL);
1720
1721 if (r != bfd_reloc_ok)
1722 {
1723 const char * name;
1724 const char * msg = (const char *)0;
1725
1726 if (h != NULL)
1727 name = h->root.root.string;
1728 else
1729 {
1730 name = (bfd_elf_string_from_elf_section
1731 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1732 if (name == NULL || *name == '\0')
1733 name = bfd_section_name (input_bfd, sec);
1734 }
1735
1736 switch (r)
1737 {
1738 case bfd_reloc_overflow:
1739 if (! ((*info->callbacks->reloc_overflow)
1740 (info, name, howto->name, (bfd_vma) 0,
1741 input_bfd, input_section, rel->r_offset)))
1742 return false;
1743 break;
1744
1745 case bfd_reloc_undefined:
1746 if (! ((*info->callbacks->undefined_symbol)
1747 (info, name, input_bfd, input_section,
1748 rel->r_offset, true)))
1749 return false;
1750 break;
1751
1752 case bfd_reloc_outofrange:
1753 msg = _("internal error: out of range error");
1754 goto common_error;
1755
1756 case bfd_reloc_notsupported:
1757 msg = _("internal error: unsupported relocation error");
1758 goto common_error;
1759
1760 case bfd_reloc_dangerous:
1761 msg = _("internal error: dangerous relocation");
1762 goto common_error;
1763
1764 case bfd_reloc_gp_not_found:
1765 msg = _("could not locate special linker symbol __gp");
1766 goto common_error;
1767
1768 case bfd_reloc_ep_not_found:
1769 msg = _("could not locate special linker symbol __ep");
1770 goto common_error;
1771
1772 case bfd_reloc_ctbp_not_found:
1773 msg = _("could not locate special linker symbol __ctbp");
1774 goto common_error;
1775
1776 default:
1777 msg = _("internal error: unknown error");
1778 /* fall through */
1779
1780 common_error:
1781 if (!((*info->callbacks->warning)
1782 (info, msg, name, input_bfd, input_section,
1783 rel->r_offset)))
1784 return false;
1785 break;
1786 }
1787 }
1788 }
1789
1790 return true;
1791 }
1792
1793 static boolean
1794 v850_elf_gc_sweep_hook (abfd, info, sec, relocs)
1795 bfd *abfd ATTRIBUTE_UNUSED;
1796 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1797 asection *sec ATTRIBUTE_UNUSED;
1798 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
1799 {
1800 /* No got and plt entries for v850-elf. */
1801 return true;
1802 }
1803
1804 static asection *
1805 v850_elf_gc_mark_hook (sec, info, rel, h, sym)
1806 asection *sec;
1807 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1808 Elf_Internal_Rela *rel;
1809 struct elf_link_hash_entry *h;
1810 Elf_Internal_Sym *sym;
1811 {
1812 if (h != NULL)
1813 {
1814 switch (ELF32_R_TYPE (rel->r_info))
1815 {
1816 case R_V850_GNU_VTINHERIT:
1817 case R_V850_GNU_VTENTRY:
1818 break;
1819
1820 default:
1821 switch (h->root.type)
1822 {
1823 case bfd_link_hash_defined:
1824 case bfd_link_hash_defweak:
1825 return h->root.u.def.section;
1826
1827 case bfd_link_hash_common:
1828 return h->root.u.c.p->section;
1829
1830 default:
1831 break;
1832 }
1833 }
1834 }
1835 else
1836 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1837
1838 return NULL;
1839 }
1840
1841 /* Set the right machine number. */
1842
1843 static boolean
1844 v850_elf_object_p (abfd)
1845 bfd *abfd;
1846 {
1847 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1848 {
1849 default:
1850 case E_V850_ARCH:
1851 bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850);
1852 break;
1853 case E_V850E_ARCH:
1854 bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e);
1855 break;
1856 }
1857 return true;
1858 }
1859
1860 /* Store the machine number in the flags field. */
1861
1862 static void
1863 v850_elf_final_write_processing (abfd, linker)
1864 bfd * abfd;
1865 boolean linker ATTRIBUTE_UNUSED;
1866 {
1867 unsigned long val;
1868
1869 switch (bfd_get_mach (abfd))
1870 {
1871 default:
1872 case bfd_mach_v850: val = E_V850_ARCH; break;
1873 case bfd_mach_v850e: val = E_V850E_ARCH; break;
1874 }
1875
1876 elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH;
1877 elf_elfheader (abfd)->e_flags |= val;
1878 }
1879
1880 /* Function to keep V850 specific file flags. */
1881
1882 static boolean
1883 v850_elf_set_private_flags (abfd, flags)
1884 bfd * abfd;
1885 flagword flags;
1886 {
1887 BFD_ASSERT (!elf_flags_init (abfd)
1888 || elf_elfheader (abfd)->e_flags == flags);
1889
1890 elf_elfheader (abfd)->e_flags = flags;
1891 elf_flags_init (abfd) = true;
1892 return true;
1893 }
1894
1895 /* Merge backend specific data from an object file
1896 to the output object file when linking. */
1897 static boolean
1898 v850_elf_merge_private_bfd_data (ibfd, obfd)
1899 bfd * ibfd;
1900 bfd * obfd;
1901 {
1902 flagword out_flags;
1903 flagword in_flags;
1904
1905 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1906 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1907 return true;
1908
1909 in_flags = elf_elfheader (ibfd)->e_flags;
1910 out_flags = elf_elfheader (obfd)->e_flags;
1911
1912 if (! elf_flags_init (obfd))
1913 {
1914 /* If the input is the default architecture then do not
1915 bother setting the flags for the output architecture,
1916 instead allow future merges to do this. If no future
1917 merges ever set these flags then they will retain their
1918 unitialised values, which surprise surprise, correspond
1919 to the default values. */
1920 if (bfd_get_arch_info (ibfd)->the_default)
1921 return true;
1922
1923 elf_flags_init (obfd) = true;
1924 elf_elfheader (obfd)->e_flags = in_flags;
1925
1926 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1927 && bfd_get_arch_info (obfd)->the_default)
1928 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1929
1930 return true;
1931 }
1932
1933 /* Check flag compatibility. */
1934 if (in_flags == out_flags)
1935 return true;
1936
1937 if ((in_flags & EF_V850_ARCH) != (out_flags & EF_V850_ARCH)
1938 && (in_flags & EF_V850_ARCH) != E_V850_ARCH)
1939 _bfd_error_handler (_("%s: Architecture mismatch with previous modules"),
1940 bfd_archive_filename (ibfd));
1941
1942 return true;
1943 }
1944
1945 /* Display the flags field. */
1946
1947 static boolean
1948 v850_elf_print_private_bfd_data (abfd, ptr)
1949 bfd * abfd;
1950 PTR ptr;
1951 {
1952 FILE * file = (FILE *) ptr;
1953
1954 BFD_ASSERT (abfd != NULL && ptr != NULL);
1955
1956 _bfd_elf_print_private_bfd_data (abfd, ptr);
1957
1958 /* xgettext:c-format */
1959 fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags);
1960
1961 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1962 {
1963 default:
1964 case E_V850_ARCH: fprintf (file, _("v850 architecture")); break;
1965 case E_V850E_ARCH: fprintf (file, _("v850e architecture")); break;
1966 }
1967
1968 fputc ('\n', file);
1969
1970 return true;
1971 }
1972
1973 /* V850 ELF uses four common sections. One is the usual one, and the
1974 others are for (small) objects in one of the special data areas:
1975 small, tiny and zero. All the objects are kept together, and then
1976 referenced via the gp register, the ep register or the r0 register
1977 respectively, which yields smaller, faster assembler code. This
1978 approach is copied from elf32-mips.c. */
1979
1980 static asection v850_elf_scom_section;
1981 static asymbol v850_elf_scom_symbol;
1982 static asymbol * v850_elf_scom_symbol_ptr;
1983 static asection v850_elf_tcom_section;
1984 static asymbol v850_elf_tcom_symbol;
1985 static asymbol * v850_elf_tcom_symbol_ptr;
1986 static asection v850_elf_zcom_section;
1987 static asymbol v850_elf_zcom_symbol;
1988 static asymbol * v850_elf_zcom_symbol_ptr;
1989
1990 /* Given a BFD section, try to locate the
1991 corresponding ELF section index. */
1992
1993 static boolean
1994 v850_elf_section_from_bfd_section (abfd, sec, retval)
1995 bfd * abfd ATTRIBUTE_UNUSED;
1996 asection * sec;
1997 int * retval;
1998 {
1999 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
2000 *retval = SHN_V850_SCOMMON;
2001 else if (strcmp (bfd_get_section_name (abfd, sec), ".tcommon") == 0)
2002 *retval = SHN_V850_TCOMMON;
2003 else if (strcmp (bfd_get_section_name (abfd, sec), ".zcommon") == 0)
2004 *retval = SHN_V850_ZCOMMON;
2005 else
2006 return false;
2007
2008 return true;
2009 }
2010
2011 /* Handle the special V850 section numbers that a symbol may use. */
2012
2013 static void
2014 v850_elf_symbol_processing (abfd, asym)
2015 bfd * abfd;
2016 asymbol * asym;
2017 {
2018 elf_symbol_type * elfsym = (elf_symbol_type *) asym;
2019 unsigned int indx;
2020
2021 indx = elfsym->internal_elf_sym.st_shndx;
2022
2023 /* If the section index is an "ordinary" index, then it may
2024 refer to a v850 specific section created by the assembler.
2025 Check the section's type and change the index it matches.
2026
2027 FIXME: Should we alter the st_shndx field as well ? */
2028
2029 if (indx < elf_numsections (abfd))
2030 switch (elf_elfsections(abfd)[indx]->sh_type)
2031 {
2032 case SHT_V850_SCOMMON:
2033 indx = SHN_V850_SCOMMON;
2034 break;
2035
2036 case SHT_V850_TCOMMON:
2037 indx = SHN_V850_TCOMMON;
2038 break;
2039
2040 case SHT_V850_ZCOMMON:
2041 indx = SHN_V850_ZCOMMON;
2042 break;
2043
2044 default:
2045 break;
2046 }
2047
2048 switch (indx)
2049 {
2050 case SHN_V850_SCOMMON:
2051 if (v850_elf_scom_section.name == NULL)
2052 {
2053 /* Initialize the small common section. */
2054 v850_elf_scom_section.name = ".scommon";
2055 v850_elf_scom_section.flags = SEC_IS_COMMON | SEC_ALLOC | SEC_DATA;
2056 v850_elf_scom_section.output_section = & v850_elf_scom_section;
2057 v850_elf_scom_section.symbol = & v850_elf_scom_symbol;
2058 v850_elf_scom_section.symbol_ptr_ptr = & v850_elf_scom_symbol_ptr;
2059 v850_elf_scom_symbol.name = ".scommon";
2060 v850_elf_scom_symbol.flags = BSF_SECTION_SYM;
2061 v850_elf_scom_symbol.section = & v850_elf_scom_section;
2062 v850_elf_scom_symbol_ptr = & v850_elf_scom_symbol;
2063 }
2064 asym->section = & v850_elf_scom_section;
2065 asym->value = elfsym->internal_elf_sym.st_size;
2066 break;
2067
2068 case SHN_V850_TCOMMON:
2069 if (v850_elf_tcom_section.name == NULL)
2070 {
2071 /* Initialize the tcommon section. */
2072 v850_elf_tcom_section.name = ".tcommon";
2073 v850_elf_tcom_section.flags = SEC_IS_COMMON;
2074 v850_elf_tcom_section.output_section = & v850_elf_tcom_section;
2075 v850_elf_tcom_section.symbol = & v850_elf_tcom_symbol;
2076 v850_elf_tcom_section.symbol_ptr_ptr = & v850_elf_tcom_symbol_ptr;
2077 v850_elf_tcom_symbol.name = ".tcommon";
2078 v850_elf_tcom_symbol.flags = BSF_SECTION_SYM;
2079 v850_elf_tcom_symbol.section = & v850_elf_tcom_section;
2080 v850_elf_tcom_symbol_ptr = & v850_elf_tcom_symbol;
2081 }
2082 asym->section = & v850_elf_tcom_section;
2083 asym->value = elfsym->internal_elf_sym.st_size;
2084 break;
2085
2086 case SHN_V850_ZCOMMON:
2087 if (v850_elf_zcom_section.name == NULL)
2088 {
2089 /* Initialize the zcommon section. */
2090 v850_elf_zcom_section.name = ".zcommon";
2091 v850_elf_zcom_section.flags = SEC_IS_COMMON;
2092 v850_elf_zcom_section.output_section = & v850_elf_zcom_section;
2093 v850_elf_zcom_section.symbol = & v850_elf_zcom_symbol;
2094 v850_elf_zcom_section.symbol_ptr_ptr = & v850_elf_zcom_symbol_ptr;
2095 v850_elf_zcom_symbol.name = ".zcommon";
2096 v850_elf_zcom_symbol.flags = BSF_SECTION_SYM;
2097 v850_elf_zcom_symbol.section = & v850_elf_zcom_section;
2098 v850_elf_zcom_symbol_ptr = & v850_elf_zcom_symbol;
2099 }
2100 asym->section = & v850_elf_zcom_section;
2101 asym->value = elfsym->internal_elf_sym.st_size;
2102 break;
2103 }
2104 }
2105
2106 /* Hook called by the linker routine which adds symbols from an object
2107 file. We must handle the special v850 section numbers here. */
2108
2109 static boolean
2110 v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2111 bfd * abfd;
2112 struct bfd_link_info * info ATTRIBUTE_UNUSED;
2113 const Elf_Internal_Sym * sym;
2114 const char ** namep ATTRIBUTE_UNUSED;
2115 flagword * flagsp ATTRIBUTE_UNUSED;
2116 asection ** secp;
2117 bfd_vma * valp;
2118 {
2119 unsigned int indx = sym->st_shndx;
2120
2121 /* If the section index is an "ordinary" index, then it may
2122 refer to a v850 specific section created by the assembler.
2123 Check the section's type and change the index it matches.
2124
2125 FIXME: Should we alter the st_shndx field as well ? */
2126
2127 if (indx < elf_numsections (abfd))
2128 switch (elf_elfsections(abfd)[indx]->sh_type)
2129 {
2130 case SHT_V850_SCOMMON:
2131 indx = SHN_V850_SCOMMON;
2132 break;
2133
2134 case SHT_V850_TCOMMON:
2135 indx = SHN_V850_TCOMMON;
2136 break;
2137
2138 case SHT_V850_ZCOMMON:
2139 indx = SHN_V850_ZCOMMON;
2140 break;
2141
2142 default:
2143 break;
2144 }
2145
2146 switch (indx)
2147 {
2148 case SHN_V850_SCOMMON:
2149 *secp = bfd_make_section_old_way (abfd, ".scommon");
2150 (*secp)->flags |= SEC_IS_COMMON;
2151 *valp = sym->st_size;
2152 break;
2153
2154 case SHN_V850_TCOMMON:
2155 *secp = bfd_make_section_old_way (abfd, ".tcommon");
2156 (*secp)->flags |= SEC_IS_COMMON;
2157 *valp = sym->st_size;
2158 break;
2159
2160 case SHN_V850_ZCOMMON:
2161 *secp = bfd_make_section_old_way (abfd, ".zcommon");
2162 (*secp)->flags |= SEC_IS_COMMON;
2163 *valp = sym->st_size;
2164 break;
2165 }
2166
2167 return true;
2168 }
2169
2170 static boolean
2171 v850_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
2172 bfd * abfd ATTRIBUTE_UNUSED;
2173 struct bfd_link_info * info ATTRIBUTE_UNUSED;
2174 const char * name ATTRIBUTE_UNUSED;
2175 Elf_Internal_Sym * sym;
2176 asection * input_sec;
2177 {
2178 /* If we see a common symbol, which implies a relocatable link, then
2179 if a symbol was in a special common section in an input file, mark
2180 it as a special common in the output file. */
2181
2182 if (sym->st_shndx == SHN_COMMON)
2183 {
2184 if (strcmp (input_sec->name, ".scommon") == 0)
2185 sym->st_shndx = SHN_V850_SCOMMON;
2186 else if (strcmp (input_sec->name, ".tcommon") == 0)
2187 sym->st_shndx = SHN_V850_TCOMMON;
2188 else if (strcmp (input_sec->name, ".zcommon") == 0)
2189 sym->st_shndx = SHN_V850_ZCOMMON;
2190 }
2191
2192 return true;
2193 }
2194
2195 static boolean
2196 v850_elf_section_from_shdr (abfd, hdr, name)
2197 bfd * abfd;
2198 Elf_Internal_Shdr * hdr;
2199 const char * name;
2200 {
2201 /* There ought to be a place to keep ELF backend specific flags, but
2202 at the moment there isn't one. We just keep track of the
2203 sections by their name, instead. */
2204
2205 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2206 return false;
2207
2208 switch (hdr->sh_type)
2209 {
2210 case SHT_V850_SCOMMON:
2211 case SHT_V850_TCOMMON:
2212 case SHT_V850_ZCOMMON:
2213 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2214 (bfd_get_section_flags (abfd,
2215 hdr->bfd_section)
2216 | SEC_IS_COMMON)))
2217 return false;
2218 }
2219
2220 return true;
2221 }
2222
2223 /* Set the correct type for a V850 ELF section. We do this
2224 by the section name, which is a hack, but ought to work. */
2225
2226 static boolean
2227 v850_elf_fake_sections (abfd, hdr, sec)
2228 bfd * abfd ATTRIBUTE_UNUSED;
2229 Elf32_Internal_Shdr * hdr;
2230 asection * sec;
2231 {
2232 register const char * name;
2233
2234 name = bfd_get_section_name (abfd, sec);
2235
2236 if (strcmp (name, ".scommon") == 0)
2237 {
2238 hdr->sh_type = SHT_V850_SCOMMON;
2239 }
2240 else if (strcmp (name, ".tcommon") == 0)
2241 {
2242 hdr->sh_type = SHT_V850_TCOMMON;
2243 }
2244 else if (strcmp (name, ".zcommon") == 0)
2245 hdr->sh_type = SHT_V850_ZCOMMON;
2246
2247 return true;
2248 }
2249
2250 /* Delete some bytes from a section while relaxing. */
2251
2252 static boolean
2253 v850_elf_relax_delete_bytes (abfd, sec, addr, toaddr, count)
2254 bfd * abfd;
2255 asection * sec;
2256 bfd_vma addr;
2257 bfd_vma toaddr;
2258 int count;
2259 {
2260 Elf_Internal_Shdr * symtab_hdr;
2261 Elf32_External_Sym * extsyms;
2262 Elf32_External_Sym * esym;
2263 Elf32_External_Sym * esymend;
2264 int index;
2265 unsigned int sec_shndx;
2266 bfd_byte * contents;
2267 Elf_Internal_Rela * irel;
2268 Elf_Internal_Rela * irelend;
2269 struct elf_link_hash_entry * sym_hash;
2270 Elf_Internal_Shdr * shndx_hdr;
2271 Elf_External_Sym_Shndx * shndx;
2272
2273 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2274 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2275
2276 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2277
2278 contents = elf_section_data (sec)->this_hdr.contents;
2279
2280 /* The deletion must stop at the next ALIGN reloc for an alignment
2281 power larger than the number of bytes we are deleting. */
2282
2283 /* Actually delete the bytes. */
2284 #if (DEBUG_RELAX & 2)
2285 fprintf (stderr, "relax_delete: contents: sec: %s %p .. %p %x\n",
2286 sec->name, addr, toaddr, count );
2287 #endif
2288 memmove (contents + addr, contents + addr + count,
2289 toaddr - addr - count);
2290 memset (contents + toaddr-count, 0, count);
2291
2292 /* Adjust all the relocs. */
2293 irel = elf_section_data (sec)->relocs;
2294 irelend = irel + sec->reloc_count;
2295 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2296 shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
2297
2298 for (; irel < irelend; irel++)
2299 {
2300 bfd_vma raddr, paddr, symval;
2301 Elf_Internal_Sym isym;
2302
2303 /* Get the new reloc address. */
2304 raddr = irel->r_offset;
2305 if ((raddr >= (addr + count) && raddr < toaddr))
2306 irel->r_offset -= count;
2307
2308 if (raddr >= addr && raddr < addr + count)
2309 {
2310 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2311 (int) R_V850_NONE);
2312 continue;
2313 }
2314
2315 if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN)
2316 continue;
2317
2318 bfd_elf32_swap_symbol_in (abfd,
2319 extsyms + ELF32_R_SYM (irel->r_info),
2320 shndx ? shndx + ELF32_R_SYM (irel->r_info) : NULL,
2321 & isym);
2322
2323 if (isym.st_shndx != sec_shndx)
2324 continue;
2325
2326 /* Get the value of the symbol referred to by the reloc. */
2327 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2328 {
2329 symval = isym.st_value;
2330 #if (DEBUG_RELAX & 2)
2331 {
2332 char * name = bfd_elf_string_from_elf_section
2333 (abfd, symtab_hdr->sh_link, isym.st_name);
2334 fprintf (stderr,
2335 "relax_delete: local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
2336 sec->name, name, isym.st_name,
2337 sec->output_section->vma, sec->output_offset,
2338 isym.st_value, irel->r_addend);
2339 }
2340 #endif
2341 }
2342 else
2343 {
2344 unsigned long indx;
2345 struct elf_link_hash_entry * h;
2346
2347 /* An external symbol. */
2348 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2349
2350 h = elf_sym_hashes (abfd) [indx];
2351 BFD_ASSERT (h != NULL);
2352
2353 symval = h->root.u.def.value;
2354 #if (DEBUG_RELAX & 2)
2355 fprintf (stderr,
2356 "relax_delete: defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n",
2357 sec->name, h->root.root.string, h->root.u.def.value,
2358 sec->output_section->vma, sec->output_offset, irel->r_addend);
2359 #endif
2360 }
2361
2362 paddr = symval + irel->r_addend;
2363
2364 if ( (symval >= addr + count && symval < toaddr)
2365 && (paddr < addr + count || paddr >= toaddr))
2366 irel->r_addend += count;
2367 else if ( (symval < addr + count || symval >= toaddr)
2368 && (paddr >= addr + count && paddr < toaddr))
2369 irel->r_addend -= count;
2370 }
2371
2372 /* Adjust the local symbols defined in this section. */
2373 esym = extsyms;
2374 esymend = esym + symtab_hdr->sh_info;
2375
2376 for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL))
2377 {
2378 Elf_Internal_Sym isym;
2379
2380 bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym);
2381
2382 if (isym.st_shndx == sec_shndx
2383 && isym.st_value >= addr + count
2384 && isym.st_value < toaddr)
2385 {
2386 isym.st_value -= count;
2387
2388 if (isym.st_value + isym.st_size >= toaddr)
2389 isym.st_size += count;
2390
2391 bfd_elf32_swap_symbol_out (abfd, & isym, shndx, esym);
2392 }
2393 else if (isym.st_shndx == sec_shndx
2394 && isym.st_value < addr + count)
2395 {
2396 if (isym.st_value+isym.st_size >= addr + count
2397 && isym.st_value+isym.st_size < toaddr)
2398 isym.st_size -= count;
2399
2400 if (isym.st_value >= addr
2401 && isym.st_value < addr + count)
2402 isym.st_value = addr;
2403
2404 bfd_elf32_swap_symbol_out (abfd, & isym, shndx, esym);
2405 }
2406 }
2407
2408 /* Now adjust the global symbols defined in this section. */
2409 esym = extsyms + symtab_hdr->sh_info;
2410 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2411
2412 for (index = 0; esym < esymend; esym ++, index ++)
2413 {
2414 Elf_Internal_Sym isym;
2415
2416 bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym);
2417 sym_hash = elf_sym_hashes (abfd) [index];
2418
2419 if (isym.st_shndx == sec_shndx
2420 && ((sym_hash)->root.type == bfd_link_hash_defined
2421 || (sym_hash)->root.type == bfd_link_hash_defweak)
2422 && (sym_hash)->root.u.def.section == sec
2423 && (sym_hash)->root.u.def.value >= addr + count
2424 && (sym_hash)->root.u.def.value < toaddr)
2425 {
2426 if ((sym_hash)->root.u.def.value + isym.st_size >= toaddr)
2427 {
2428 isym.st_size += count;
2429 bfd_elf32_swap_symbol_out (abfd, & isym, shndx, esym);
2430 }
2431
2432 (sym_hash)->root.u.def.value -= count;
2433 }
2434 else if (isym.st_shndx == sec_shndx
2435 && ((sym_hash)->root.type == bfd_link_hash_defined
2436 || (sym_hash)->root.type == bfd_link_hash_defweak)
2437 && (sym_hash)->root.u.def.section == sec
2438 && (sym_hash)->root.u.def.value < addr + count)
2439 {
2440 if ((sym_hash)->root.u.def.value+isym.st_size >= addr + count
2441 && (sym_hash)->root.u.def.value+isym.st_size < toaddr)
2442 isym.st_size -= count;
2443
2444 if ((sym_hash)->root.u.def.value >= addr
2445 && (sym_hash)->root.u.def.value < addr + count)
2446 (sym_hash)->root.u.def.value = addr;
2447
2448 bfd_elf32_swap_symbol_out (abfd, & isym, shndx, esym);
2449 }
2450
2451 if (shndx)
2452 ++ shndx;
2453 }
2454
2455 return true;
2456 }
2457
2458 #define NOP_OPCODE (0x0000)
2459 #define MOVHI 0x0640 /* 4byte */
2460 #define MOVHI_MASK 0x07e0
2461 #define MOVHI_R1(insn) ((insn) & 0x1f) /* 4byte */
2462 #define MOVHI_R2(insn) ((insn) >> 11)
2463 #define MOVEA 0x0620 /* 2byte */
2464 #define MOVEA_MASK 0x07e0
2465 #define MOVEA_R1(insn) ((insn) & 0x1f)
2466 #define MOVEA_R2(insn) ((insn) >> 11)
2467 #define JARL_4 0x00040780 /* 4byte */
2468 #define JARL_4_MASK 0xFFFF07FF
2469 #define JARL_R2(insn) (int)(((insn) & (~JARL_4_MASK)) >> 11)
2470 #define ADD_I 0x0240 /* 2byte */
2471 #define ADD_I_MASK 0x07e0
2472 #define ADD_I5(insn) ((((insn) & 0x001f) << 11) >> 11) /* 2byte */
2473 #define ADD_R2(insn) ((insn) >> 11)
2474 #define JMP_R 0x0060 /* 2byte */
2475 #define JMP_R_MASK 0xFFE0
2476 #define JMP_R1(insn) ((insn) & 0x1f)
2477
2478 static boolean
2479 v850_elf_relax_section (abfd, sec, link_info, again)
2480 bfd * abfd;
2481 asection * sec;
2482 struct bfd_link_info * link_info;
2483 boolean * again;
2484 {
2485 Elf_Internal_Shdr * symtab_hdr;
2486 Elf_Internal_Rela * internal_relocs;
2487 Elf_Internal_Rela * irel;
2488 Elf_Internal_Rela * irelend;
2489 Elf_Internal_Rela * irelalign = NULL;
2490 Elf_Internal_Sym * isymbuf = NULL;
2491 bfd_byte * contents = NULL;
2492 bfd_vma addr = 0;
2493 bfd_vma toaddr;
2494 int align_pad_size = 0;
2495 boolean result = true;
2496
2497 * again = false;
2498
2499 if (link_info->relocateable
2500 || (sec->flags & SEC_RELOC) == 0
2501 || sec->reloc_count == 0)
2502 return true;
2503
2504 /* If this is the first time we have been called
2505 for this section, initialize the cooked size. */
2506 if (sec->_cooked_size == 0)
2507 sec->_cooked_size = sec->_raw_size;
2508
2509 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2510
2511 internal_relocs = (_bfd_elf32_link_read_relocs
2512 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2513 link_info->keep_memory));
2514 if (internal_relocs == NULL)
2515 goto error_return;
2516
2517 irelend = internal_relocs + sec->reloc_count;
2518
2519 while (addr < sec->_cooked_size)
2520 {
2521 toaddr = sec->_cooked_size;
2522
2523 for (irel = internal_relocs; irel < irelend; irel ++)
2524 if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN
2525 && irel->r_offset > addr
2526 && irel->r_offset < toaddr)
2527 toaddr = irel->r_offset;
2528
2529 #ifdef DEBUG_RELAX
2530 fprintf (stderr, "relax region 0x%x to 0x%x align pad %d\n",
2531 addr, toaddr, align_pad_size);
2532 #endif
2533 if (irelalign)
2534 {
2535 bfd_vma alignto;
2536 bfd_vma alignmoveto;
2537
2538 alignmoveto = BFD_ALIGN (addr - align_pad_size, 1 << irelalign->r_addend);
2539 alignto = BFD_ALIGN (addr, 1 << irelalign->r_addend);
2540
2541 if (alignmoveto < alignto)
2542 {
2543 unsigned int i;
2544
2545 align_pad_size = alignto - alignmoveto;
2546 #ifdef DEBUG_RELAX
2547 fprintf (stderr, "relax move region 0x%x to 0x%x delete size 0x%x\n",
2548 alignmoveto, toaddr, align_pad_size);
2549 #endif
2550 if (!v850_elf_relax_delete_bytes (abfd, sec, alignmoveto,
2551 toaddr, align_pad_size))
2552 goto error_return;
2553
2554 for (i = BFD_ALIGN (toaddr - align_pad_size, 1);
2555 (i + 1) < toaddr; i += 2)
2556 bfd_put_16 (abfd, NOP_OPCODE, contents + i);
2557
2558 addr = alignmoveto;
2559 }
2560 else
2561 align_pad_size = 0;
2562 }
2563
2564 for (irel = internal_relocs; irel < irelend; irel++)
2565 {
2566 bfd_vma laddr;
2567 bfd_vma addend;
2568 bfd_vma symval;
2569 int insn[5];
2570 int no_match = -1;
2571 Elf_Internal_Rela * hi_irelfn;
2572 Elf_Internal_Rela * lo_irelfn;
2573 Elf_Internal_Rela * irelcall;
2574 bfd_signed_vma foff;
2575
2576 if (! (irel->r_offset >= addr && irel->r_offset < toaddr
2577 && (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL
2578 || ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP)))
2579 continue;
2580
2581 #ifdef DEBUG_RELAX
2582 fprintf (stderr, "relax check r_info 0x%x r_offset 0x%x r_addend 0x%x\n",
2583 irel->r_info,
2584 irel->r_offset,
2585 irel->r_addend );
2586 #endif
2587
2588 /* Get the section contents. */
2589 if (contents == NULL)
2590 {
2591 if (elf_section_data (sec)->this_hdr.contents != NULL)
2592 contents = elf_section_data (sec)->this_hdr.contents;
2593 else
2594 {
2595 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2596 if (contents == NULL)
2597 goto error_return;
2598
2599 if (! bfd_get_section_contents (abfd, sec, contents,
2600 (file_ptr) 0, sec->_raw_size))
2601 goto error_return;
2602 }
2603 }
2604
2605 /* Read this BFD's local symbols if we haven't done so already. */
2606 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2607 {
2608 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2609 if (isymbuf == NULL)
2610 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2611 symtab_hdr->sh_info, 0,
2612 NULL, NULL, NULL);
2613 if (isymbuf == NULL)
2614 goto error_return;
2615 }
2616
2617 laddr = irel->r_offset;
2618
2619 if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL)
2620 {
2621 /* Check code for -mlong-calls output. */
2622 if (laddr + 16 <= (bfd_vma) sec->_raw_size)
2623 {
2624 insn[0] = bfd_get_16 (abfd, contents + laddr);
2625 insn[1] = bfd_get_16 (abfd, contents + laddr + 4);
2626 insn[2] = bfd_get_32 (abfd, contents + laddr + 8);
2627 insn[3] = bfd_get_16 (abfd, contents + laddr + 12);
2628 insn[4] = bfd_get_16 (abfd, contents + laddr + 14);
2629
2630 if ((insn[0] & MOVHI_MASK) != MOVHI
2631 || MOVHI_R1 (insn[0]) != 0)
2632 no_match = 0;
2633
2634 if (no_match < 0
2635 && ((insn[1] & MOVEA_MASK) != MOVEA
2636 || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1])))
2637 no_match = 1;
2638
2639 if (no_match < 0
2640 && (insn[2] & JARL_4_MASK) != JARL_4)
2641 no_match = 2;
2642
2643 if (no_match < 0
2644 && ((insn[3] & ADD_I_MASK) != ADD_I
2645 || ADD_I5 (insn[3]) != 4
2646 || JARL_R2 (insn[2]) != ADD_R2 (insn[3])))
2647 no_match = 3;
2648
2649 if (no_match < 0
2650 && ((insn[4] & JMP_R_MASK) != JMP_R
2651 || MOVEA_R2 (insn[1]) != JMP_R1 (insn[4])))
2652 no_match = 4;
2653 }
2654 else
2655 {
2656 ((*_bfd_error_handler)
2657 ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insns",
2658 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
2659
2660 continue;
2661 }
2662
2663 if (no_match >= 0)
2664 {
2665 ((*_bfd_error_handler)
2666 ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insn 0x%x",
2667 bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match]));
2668
2669 continue;
2670 }
2671
2672 /* Get the reloc for the address from which the register is
2673 being loaded. This reloc will tell us which function is
2674 actually being called. */
2675 for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++)
2676 if (hi_irelfn->r_offset == laddr + 2
2677 && ELF32_R_TYPE (hi_irelfn->r_info)
2678 == (int) R_V850_HI16_S)
2679 break;
2680
2681 for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++)
2682 if (lo_irelfn->r_offset == laddr + 6
2683 && ELF32_R_TYPE (lo_irelfn->r_info)
2684 == (int) R_V850_LO16)
2685 break;
2686
2687 for (irelcall = internal_relocs; irelcall < irelend; irelcall ++)
2688 if (irelcall->r_offset == laddr + 8
2689 && ELF32_R_TYPE (irelcall->r_info)
2690 == (int) R_V850_22_PCREL)
2691 break;
2692
2693 if ( hi_irelfn == irelend
2694 || lo_irelfn == irelend
2695 || irelcall == irelend)
2696 {
2697 ((*_bfd_error_handler)
2698 ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc",
2699 bfd_get_filename (abfd), (unsigned long) irel->r_offset ));
2700
2701 continue;
2702 }
2703
2704 if (ELF32_R_SYM (irelcall->r_info) < symtab_hdr->sh_info)
2705 {
2706 Elf_Internal_Sym * isym;
2707
2708 /* A local symbol. */
2709 isym = isymbuf + ELF32_R_SYM (irelcall->r_info);
2710
2711 symval = isym->st_value;
2712 }
2713 else
2714 {
2715 unsigned long indx;
2716 struct elf_link_hash_entry * h;
2717
2718 /* An external symbol. */
2719 indx = ELF32_R_SYM (irelcall->r_info) - symtab_hdr->sh_info;
2720 h = elf_sym_hashes (abfd)[indx];
2721 BFD_ASSERT (h != NULL);
2722
2723 if ( h->root.type != bfd_link_hash_defined
2724 && h->root.type != bfd_link_hash_defweak)
2725 /* This appears to be a reference to an undefined
2726 symbol. Just ignore it--it will be caught by the
2727 regular reloc processing. */
2728 continue;
2729
2730 symval = h->root.u.def.value;
2731 }
2732
2733 if (symval + irelcall->r_addend != irelcall->r_offset + 4)
2734 {
2735 ((*_bfd_error_handler)
2736 ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc 0x%lx",
2737 bfd_get_filename (abfd), (unsigned long) irel->r_offset, irelcall->r_offset ));
2738
2739 continue;
2740 }
2741
2742 /* Get the value of the symbol referred to by the reloc. */
2743 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2744 {
2745 Elf_Internal_Sym * isym;
2746 asection * sym_sec;
2747
2748 /* A local symbol. */
2749 isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info);
2750
2751 if (isym->st_shndx == SHN_UNDEF)
2752 sym_sec = bfd_und_section_ptr;
2753 else if (isym->st_shndx == SHN_ABS)
2754 sym_sec = bfd_abs_section_ptr;
2755 else if (isym->st_shndx == SHN_COMMON)
2756 sym_sec = bfd_com_section_ptr;
2757 else
2758 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2759 symval = (isym->st_value
2760 + sym_sec->output_section->vma
2761 + sym_sec->output_offset);
2762 }
2763 else
2764 {
2765 unsigned long indx;
2766 struct elf_link_hash_entry * h;
2767
2768 /* An external symbol. */
2769 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
2770 h = elf_sym_hashes (abfd)[indx];
2771 BFD_ASSERT (h != NULL);
2772
2773 if ( h->root.type != bfd_link_hash_defined
2774 && h->root.type != bfd_link_hash_defweak)
2775 /* This appears to be a reference to an undefined
2776 symbol. Just ignore it--it will be caught by the
2777 regular reloc processing. */
2778 continue;
2779
2780 symval = (h->root.u.def.value
2781 + h->root.u.def.section->output_section->vma
2782 + h->root.u.def.section->output_offset);
2783 }
2784
2785 addend = irel->r_addend;
2786
2787 foff = (symval + addend
2788 - (irel->r_offset
2789 + sec->output_section->vma
2790 + sec->output_offset
2791 + 4));
2792 #ifdef DEBUG_RELAX
2793 fprintf (stderr, "relax longcall r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n",
2794 irel->r_offset,
2795 (irel->r_offset
2796 + sec->output_section->vma
2797 + sec->output_offset),
2798 symval, addend, foff);
2799 #endif
2800
2801 if (foff < -0x100000 || foff >= 0x100000)
2802 /* After all that work, we can't shorten this function call. */
2803 continue;
2804
2805 /* For simplicity of coding, we are going to modify the section
2806 contents, the section relocs, and the BFD symbol table. We
2807 must tell the rest of the code not to free up this
2808 information. It would be possible to instead create a table
2809 of changes which have to be made, as is done in coff-mips.c;
2810 that would be more work, but would require less memory when
2811 the linker is run. */
2812 elf_section_data (sec)->relocs = internal_relocs;
2813 elf_section_data (sec)->this_hdr.contents = contents;
2814 symtab_hdr->contents = (bfd_byte *) isymbuf;
2815
2816 /* Replace the long call with a jarl. */
2817 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_22_PCREL);
2818
2819 addend = 0;
2820
2821 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2822 /* If this needs to be changed because of future relaxing,
2823 it will be handled here like other internal IND12W
2824 relocs. */
2825 bfd_put_32 (abfd,
2826 0x00000780 | (JARL_R2 (insn[2])<<11) | ((addend << 16) & 0xffff) | ((addend >> 16) & 0xf),
2827 contents + irel->r_offset);
2828 else
2829 /* We can't fully resolve this yet, because the external
2830 symbol value may be changed by future relaxing.
2831 We let the final link phase handle it. */
2832 bfd_put_32 (abfd, 0x00000780 | (JARL_R2 (insn[2])<<11),
2833 contents + irel->r_offset);
2834
2835 hi_irelfn->r_info =
2836 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
2837 lo_irelfn->r_info =
2838 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
2839 irelcall->r_info =
2840 ELF32_R_INFO (ELF32_R_SYM (irelcall->r_info), R_V850_NONE);
2841
2842 if (! v850_elf_relax_delete_bytes (abfd, sec,
2843 irel->r_offset + 4, toaddr, 12))
2844 goto error_return;
2845
2846 align_pad_size += 12;
2847 }
2848 else if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP)
2849 {
2850 /* Check code for -mlong-jumps output. */
2851 if (laddr + 10 <= (bfd_vma) sec->_raw_size)
2852 {
2853 insn[0] = bfd_get_16 (abfd, contents + laddr);
2854 insn[1] = bfd_get_16 (abfd, contents + laddr + 4);
2855 insn[2] = bfd_get_16 (abfd, contents + laddr + 8);
2856
2857 if ((insn[0] & MOVHI_MASK) != MOVHI
2858 || MOVHI_R1 (insn[0]) != 0)
2859 no_match = 0;
2860
2861 if (no_match < 0
2862 && ((insn[1] & MOVEA_MASK) != MOVEA
2863 || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1])))
2864 no_match = 1;
2865
2866 if (no_match < 0
2867 && ((insn[2] & JMP_R_MASK) != JMP_R
2868 || MOVEA_R2 (insn[1]) != JMP_R1 (insn[2])))
2869 no_match = 4;
2870 }
2871 else
2872 {
2873 ((*_bfd_error_handler)
2874 ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insns",
2875 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
2876
2877 continue;
2878 }
2879
2880 if (no_match >= 0)
2881 {
2882 ((*_bfd_error_handler)
2883 ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insn 0x%x",
2884 bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match]));
2885
2886 continue;
2887 }
2888
2889 /* Get the reloc for the address from which the register is
2890 being loaded. This reloc will tell us which function is
2891 actually being called. */
2892 for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++)
2893 if (hi_irelfn->r_offset == laddr + 2
2894 && ELF32_R_TYPE (hi_irelfn->r_info) == (int) R_V850_HI16_S)
2895 break;
2896
2897 for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++)
2898 if (lo_irelfn->r_offset == laddr + 6
2899 && ELF32_R_TYPE (lo_irelfn->r_info) == (int) R_V850_LO16)
2900 break;
2901
2902 if ( hi_irelfn == irelend
2903 || lo_irelfn == irelend)
2904 {
2905 ((*_bfd_error_handler)
2906 ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized reloc",
2907 bfd_get_filename (abfd), (unsigned long) irel->r_offset ));
2908
2909 continue;
2910 }
2911
2912 /* Get the value of the symbol referred to by the reloc. */
2913 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2914 {
2915 Elf_Internal_Sym * isym;
2916 asection * sym_sec;
2917
2918 /* A local symbol. */
2919 isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info);
2920
2921 if (isym->st_shndx == SHN_UNDEF)
2922 sym_sec = bfd_und_section_ptr;
2923 else if (isym->st_shndx == SHN_ABS)
2924 sym_sec = bfd_abs_section_ptr;
2925 else if (isym->st_shndx == SHN_COMMON)
2926 sym_sec = bfd_com_section_ptr;
2927 else
2928 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2929 symval = (isym->st_value
2930 + sym_sec->output_section->vma
2931 + sym_sec->output_offset);
2932 #ifdef DEBUG_RELAX
2933 {
2934 char * name = bfd_elf_string_from_elf_section
2935 (abfd, symtab_hdr->sh_link, isym->st_name);
2936
2937 fprintf (stderr, "relax long jump local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
2938 sym_sec->name, name, isym->st_name,
2939 sym_sec->output_section->vma,
2940 sym_sec->output_offset,
2941 isym->st_value, irel->r_addend);
2942 }
2943 #endif
2944 }
2945 else
2946 {
2947 unsigned long indx;
2948 struct elf_link_hash_entry * h;
2949
2950 /* An external symbol. */
2951 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2952 h = elf_sym_hashes (abfd)[indx];
2953 BFD_ASSERT (h != NULL);
2954
2955 if ( h->root.type != bfd_link_hash_defined
2956 && h->root.type != bfd_link_hash_defweak)
2957 /* This appears to be a reference to an undefined
2958 symbol. Just ignore it--it will be caught by the
2959 regular reloc processing. */
2960 continue;
2961
2962 symval = (h->root.u.def.value
2963 + h->root.u.def.section->output_section->vma
2964 + h->root.u.def.section->output_offset);
2965 #ifdef DEBUG_RELAX
2966 fprintf (stderr,
2967 "relax longjump defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n",
2968 sec->name, h->root.root.string, h->root.u.def.value,
2969 sec->output_section->vma, sec->output_offset, irel->r_addend);
2970 #endif
2971 }
2972
2973 addend = irel->r_addend;
2974
2975 foff = (symval + addend
2976 - (irel->r_offset
2977 + sec->output_section->vma
2978 + sec->output_offset
2979 + 4));
2980 #ifdef DEBUG_RELAX
2981 fprintf (stderr, "relax longjump r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n",
2982 irel->r_offset,
2983 (irel->r_offset
2984 + sec->output_section->vma
2985 + sec->output_offset),
2986 symval, addend, foff);
2987 #endif
2988 if (foff < -0x100000 || foff >= 0x100000)
2989 /* After all that work, we can't shorten this function call. */
2990 continue;
2991
2992 /* For simplicity of coding, we are going to modify the section
2993 contents, the section relocs, and the BFD symbol table. We
2994 must tell the rest of the code not to free up this
2995 information. It would be possible to instead create a table
2996 of changes which have to be made, as is done in coff-mips.c;
2997 that would be more work, but would require less memory when
2998 the linker is run. */
2999 elf_section_data (sec)->relocs = internal_relocs;
3000 elf_section_data (sec)->this_hdr.contents = contents;
3001 symtab_hdr->contents = (bfd_byte *) isymbuf;
3002
3003 if (foff < -0x100 || foff >= 0x100)
3004 {
3005 /* Replace the long jump with a jr. */
3006
3007 irel->r_info =
3008 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_22_PCREL);
3009
3010 irel->r_addend = addend;
3011 addend = 0;
3012
3013 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
3014 /* If this needs to be changed because of future relaxing,
3015 it will be handled here like other internal IND12W
3016 relocs. */
3017 bfd_put_32 (abfd,
3018 0x00000780 | ((addend << 15) & 0xffff0000) | ((addend >> 17) & 0xf),
3019 contents + irel->r_offset);
3020 else
3021 /* We can't fully resolve this yet, because the external
3022 symbol value may be changed by future relaxing.
3023 We let the final link phase handle it. */
3024 bfd_put_32 (abfd, 0x00000780, contents + irel->r_offset);
3025
3026 hi_irelfn->r_info =
3027 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
3028 lo_irelfn->r_info =
3029 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
3030 if (!v850_elf_relax_delete_bytes (abfd, sec,
3031 irel->r_offset + 4, toaddr, 6))
3032 goto error_return;
3033
3034 align_pad_size += 6;
3035 }
3036 else
3037 {
3038 /* Replace the long jump with a br. */
3039
3040 irel->r_info =
3041 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_9_PCREL);
3042
3043 irel->r_addend = addend;
3044 addend = 0;
3045
3046 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
3047 /* If this needs to be changed because of future relaxing,
3048 it will be handled here like other internal IND12W
3049 relocs. */
3050 bfd_put_16 (abfd,
3051 0x0585 | ((addend << 10) & 0xf800) | ((addend << 3) & 0x0070),
3052 contents + irel->r_offset);
3053 else
3054 /* We can't fully resolve this yet, because the external
3055 symbol value may be changed by future relaxing.
3056 We let the final link phase handle it. */
3057 bfd_put_16 (abfd, 0x0585, contents + irel->r_offset);
3058
3059 hi_irelfn->r_info =
3060 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
3061 lo_irelfn->r_info =
3062 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
3063 if (!v850_elf_relax_delete_bytes (abfd, sec,
3064 irel->r_offset + 2, toaddr, 8))
3065 goto error_return;
3066
3067 align_pad_size += 8;
3068 }
3069 }
3070 }
3071
3072 irelalign = NULL;
3073 for (irel = internal_relocs; irel < irelend; irel++)
3074 {
3075 if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN
3076 && irel->r_offset == toaddr)
3077 {
3078 irel->r_offset -= align_pad_size;
3079
3080 if (irelalign == NULL || irelalign->r_addend > irel->r_addend)
3081 irelalign = irel;
3082 }
3083 }
3084
3085 addr = toaddr;
3086 }
3087
3088 if (!irelalign)
3089 {
3090 #ifdef DEBUG_RELAX
3091 fprintf (stderr, "relax pad %d shorten %d -> %d\n",
3092 align_pad_size,
3093 sec->_cooked_size,
3094 sec->_cooked_size - align_pad_size);
3095 #endif
3096 sec->_cooked_size -= align_pad_size;
3097 }
3098
3099 finish:
3100 if (internal_relocs != NULL
3101 && elf_section_data (sec)->relocs != internal_relocs)
3102 free (internal_relocs);
3103
3104 if (contents != NULL
3105 && elf_section_data (sec)->this_hdr.contents != (unsigned char *) contents)
3106 free (contents);
3107
3108 if (isymbuf != NULL
3109 && symtab_hdr->contents != (bfd_byte *) isymbuf)
3110 free (isymbuf);
3111
3112 return result;
3113
3114 error_return:
3115 result = false;
3116 goto finish;
3117 }
3118 \f
3119 #define TARGET_LITTLE_SYM bfd_elf32_v850_vec
3120 #define TARGET_LITTLE_NAME "elf32-v850"
3121 #define ELF_ARCH bfd_arch_v850
3122 #define ELF_MACHINE_CODE EM_V850
3123 #define ELF_MACHINE_ALT1 EM_CYGNUS_V850
3124 #define ELF_MAXPAGESIZE 0x1000
3125
3126 #define elf_info_to_howto v850_elf_info_to_howto_rela
3127 #define elf_info_to_howto_rel v850_elf_info_to_howto_rel
3128
3129 #define elf_backend_check_relocs v850_elf_check_relocs
3130 #define elf_backend_relocate_section v850_elf_relocate_section
3131 #define elf_backend_object_p v850_elf_object_p
3132 #define elf_backend_final_write_processing v850_elf_final_write_processing
3133 #define elf_backend_section_from_bfd_section v850_elf_section_from_bfd_section
3134 #define elf_backend_symbol_processing v850_elf_symbol_processing
3135 #define elf_backend_add_symbol_hook v850_elf_add_symbol_hook
3136 #define elf_backend_link_output_symbol_hook v850_elf_link_output_symbol_hook
3137 #define elf_backend_section_from_shdr v850_elf_section_from_shdr
3138 #define elf_backend_fake_sections v850_elf_fake_sections
3139 #define elf_backend_gc_mark_hook v850_elf_gc_mark_hook
3140 #define elf_backend_gc_sweep_hook v850_elf_gc_sweep_hook
3141
3142 #define elf_backend_can_gc_sections 1
3143 #define elf_backend_rela_normal 1
3144
3145 #define bfd_elf32_bfd_is_local_label_name v850_elf_is_local_label_name
3146 #define bfd_elf32_bfd_reloc_type_lookup v850_elf_reloc_type_lookup
3147 #define bfd_elf32_bfd_merge_private_bfd_data v850_elf_merge_private_bfd_data
3148 #define bfd_elf32_bfd_set_private_flags v850_elf_set_private_flags
3149 #define bfd_elf32_bfd_print_private_bfd_data v850_elf_print_private_bfd_data
3150 #define bfd_elf32_bfd_relax_section v850_elf_relax_section
3151
3152 #define elf_symbol_leading_char '_'
3153
3154 #include "elf32-target.h"
A mirror of the official binutils-gdb repository