Develop and Download Open Source Software

pizzafactory-gnu-tools

Browse Subversion Repository

/[pf3gnuchains]/trunk/bfd/elf32-v850.c

Contents of /trunk/bfd/elf32-v850.c

Parent Directory Parent Directory | Revision Log Revision Log

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