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