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