]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-v850.c
projects / thirdparty / binutils-gdb.git / blob
? search:


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