1 /* Ubicom IP2xxx specific support for 32-bit ELF 2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 3 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "elf/ip2k.h" 27 28 /* Struct used to pass miscellaneous paramaters which 29 helps to avoid overly long parameter lists. */ 30 struct misc 31 { 32 Elf_Internal_Shdr * symtab_hdr; 33 Elf_Internal_Rela * irelbase; 34 bfd_byte * contents; 35 Elf_Internal_Sym * isymbuf; 36 }; 37 38 struct ip2k_opcode 39 { 40 unsigned short opcode; 41 unsigned short mask; 42 }; 43 44 static bfd_boolean ip2k_relaxed = FALSE; 45 46 static const struct ip2k_opcode ip2k_page_opcode[] = 47 { 48 {0x0010, 0xFFF8}, /* Page. */ 49 {0x0000, 0x0000}, 50 }; 51 52 #define IS_PAGE_OPCODE(code) \ 53 ip2k_is_opcode (code, ip2k_page_opcode) 54 55 static const struct ip2k_opcode ip2k_jmp_opcode[] = 56 { 57 {0xE000, 0xE000}, /* Jmp. */ 58 {0x0000, 0x0000}, 59 }; 60 61 #define IS_JMP_OPCODE(code) \ 62 ip2k_is_opcode (code, ip2k_jmp_opcode) 63 64 static const struct ip2k_opcode ip2k_snc_opcode[] = 65 { 66 {0xA00B, 0xFFFF}, /* Snc. */ 67 {0x0000, 0x0000}, 68 }; 69 70 #define IS_SNC_OPCODE(code) \ 71 ip2k_is_opcode (code, ip2k_snc_opcode) 72 73 static const struct ip2k_opcode ip2k_inc_1sp_opcode[] = 74 { 75 {0x2B81, 0xFFFF}, /* Inc 1(SP). */ 76 {0x0000, 0x0000}, 77 }; 78 79 #define IS_INC_1SP_OPCODE(code) \ 80 ip2k_is_opcode (code, ip2k_inc_1sp_opcode) 81 82 static const struct ip2k_opcode ip2k_add_2sp_w_opcode[] = 83 { 84 {0x1F82, 0xFFFF}, /* Add 2(SP),w. */ 85 {0x0000, 0x0000}, 86 }; 87 88 #define IS_ADD_2SP_W_OPCODE(code) \ 89 ip2k_is_opcode (code, ip2k_add_2sp_w_opcode) 90 91 static const struct ip2k_opcode ip2k_add_w_wreg_opcode[] = 92 { 93 {0x1C0A, 0xFFFF}, /* Add w,wreg. */ 94 {0x1E0A, 0xFFFF}, /* Add wreg,w. */ 95 {0x0000, 0x0000}, 96 }; 97 98 #define IS_ADD_W_WREG_OPCODE(code) \ 99 ip2k_is_opcode (code, ip2k_add_w_wreg_opcode) 100 101 static const struct ip2k_opcode ip2k_add_pcl_w_opcode[] = 102 { 103 {0x1E09, 0xFFFF}, /* Add pcl,w. */ 104 {0x0000, 0x0000}, 105 }; 106 107 #define IS_ADD_PCL_W_OPCODE(code) \ 108 ip2k_is_opcode (code, ip2k_add_pcl_w_opcode) 109 110 static const struct ip2k_opcode ip2k_skip_opcodes[] = 111 { 112 {0xB000, 0xF000}, /* sb */ 113 {0xA000, 0xF000}, /* snb */ 114 {0x7600, 0xFE00}, /* cse/csne #lit */ 115 {0x5800, 0xFC00}, /* incsnz */ 116 {0x4C00, 0xFC00}, /* decsnz */ 117 {0x4000, 0xFC00}, /* cse/csne */ 118 {0x3C00, 0xFC00}, /* incsz */ 119 {0x2C00, 0xFC00}, /* decsz */ 120 {0x0000, 0x0000}, 121 }; 122 123 #define IS_SKIP_OPCODE(code) \ 124 ip2k_is_opcode (code, ip2k_skip_opcodes) 125 126 /* Relocation tables. */ 127 static reloc_howto_type ip2k_elf_howto_table [] = 128 { 129 #define IP2K_HOWTO(t,rs,s,bs,pr,bp,name,sm,dm) \ 130 HOWTO(t, /* type */ \ 131 rs, /* rightshift */ \ 132 s, /* size (0 = byte, 1 = short, 2 = long) */ \ 133 bs, /* bitsize */ \ 134 pr, /* pc_relative */ \ 135 bp, /* bitpos */ \ 136 complain_overflow_dont,/* complain_on_overflow */ \ 137 bfd_elf_generic_reloc,/* special_function */ \ 138 name, /* name */ \ 139 FALSE, /* partial_inplace */ \ 140 sm, /* src_mask */ \ 141 dm, /* dst_mask */ \ 142 pr) /* pcrel_offset */ 143 144 /* This reloc does nothing. */ 145 IP2K_HOWTO (R_IP2K_NONE, 0,2,32, FALSE, 0, "R_IP2K_NONE", 0, 0), 146 /* A 16 bit absolute relocation. */ 147 IP2K_HOWTO (R_IP2K_16, 0,1,16, FALSE, 0, "R_IP2K_16", 0, 0xffff), 148 /* A 32 bit absolute relocation. */ 149 IP2K_HOWTO (R_IP2K_32, 0,2,32, FALSE, 0, "R_IP2K_32", 0, 0xffffffff), 150 /* A 8-bit data relocation for the FR9 field. Ninth bit is computed specially. */ 151 IP2K_HOWTO (R_IP2K_FR9, 0,1,9, FALSE, 0, "R_IP2K_FR9", 0, 0x00ff), 152 /* A 4-bit data relocation. */ 153 IP2K_HOWTO (R_IP2K_BANK, 8,1,4, FALSE, 0, "R_IP2K_BANK", 0, 0x000f), 154 /* A 13-bit insn relocation - word address => right-shift 1 bit extra. */ 155 IP2K_HOWTO (R_IP2K_ADDR16CJP, 1,1,13, FALSE, 0, "R_IP2K_ADDR16CJP", 0, 0x1fff), 156 /* A 3-bit insn relocation - word address => right-shift 1 bit extra. */ 157 IP2K_HOWTO (R_IP2K_PAGE3, 14,1,3, FALSE, 0, "R_IP2K_PAGE3", 0, 0x0007), 158 /* Two 8-bit data relocations. */ 159 IP2K_HOWTO (R_IP2K_LO8DATA, 0,1,8, FALSE, 0, "R_IP2K_LO8DATA", 0, 0x00ff), 160 IP2K_HOWTO (R_IP2K_HI8DATA, 8,1,8, FALSE, 0, "R_IP2K_HI8DATA", 0, 0x00ff), 161 /* Two 8-bit insn relocations. word address => right-shift 1 bit extra. */ 162 IP2K_HOWTO (R_IP2K_LO8INSN, 1,1,8, FALSE, 0, "R_IP2K_LO8INSN", 0, 0x00ff), 163 IP2K_HOWTO (R_IP2K_HI8INSN, 9,1,8, FALSE, 0, "R_IP2K_HI8INSN", 0, 0x00ff), 164 165 /* Special 1 bit relocation for SKIP instructions. */ 166 IP2K_HOWTO (R_IP2K_PC_SKIP, 1,1,1, FALSE, 12, "R_IP2K_PC_SKIP", 0xfffe, 0x1000), 167 /* 16 bit word address. */ 168 IP2K_HOWTO (R_IP2K_TEXT, 1,1,16, FALSE, 0, "R_IP2K_TEXT", 0, 0xffff), 169 /* A 7-bit offset relocation for the FR9 field. Eigth and ninth bit comes from insn. */ 170 IP2K_HOWTO (R_IP2K_FR_OFFSET, 0,1,9, FALSE, 0, "R_IP2K_FR_OFFSET", 0x180, 0x007f), 171 /* Bits 23:16 of an address. */ 172 IP2K_HOWTO (R_IP2K_EX8DATA, 16,1,8, FALSE, 0, "R_IP2K_EX8DATA", 0, 0x00ff), 173 }; 174 175 176 /* Map BFD reloc types to IP2K ELF reloc types. */ 177 178 static reloc_howto_type * 179 ip2k_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 180 bfd_reloc_code_real_type code) 181 { 182 /* Note that the ip2k_elf_howto_table is indxed by the R_ 183 constants. Thus, the order that the howto records appear in the 184 table *must* match the order of the relocation types defined in 185 include/elf/ip2k.h. */ 186 187 switch (code) 188 { 189 case BFD_RELOC_NONE: 190 return &ip2k_elf_howto_table[ (int) R_IP2K_NONE]; 191 case BFD_RELOC_16: 192 return &ip2k_elf_howto_table[ (int) R_IP2K_16]; 193 case BFD_RELOC_32: 194 return &ip2k_elf_howto_table[ (int) R_IP2K_32]; 195 case BFD_RELOC_IP2K_FR9: 196 return &ip2k_elf_howto_table[ (int) R_IP2K_FR9]; 197 case BFD_RELOC_IP2K_BANK: 198 return &ip2k_elf_howto_table[ (int) R_IP2K_BANK]; 199 case BFD_RELOC_IP2K_ADDR16CJP: 200 return &ip2k_elf_howto_table[ (int) R_IP2K_ADDR16CJP]; 201 case BFD_RELOC_IP2K_PAGE3: 202 return &ip2k_elf_howto_table[ (int) R_IP2K_PAGE3]; 203 case BFD_RELOC_IP2K_LO8DATA: 204 return &ip2k_elf_howto_table[ (int) R_IP2K_LO8DATA]; 205 case BFD_RELOC_IP2K_HI8DATA: 206 return &ip2k_elf_howto_table[ (int) R_IP2K_HI8DATA]; 207 case BFD_RELOC_IP2K_LO8INSN: 208 return &ip2k_elf_howto_table[ (int) R_IP2K_LO8INSN]; 209 case BFD_RELOC_IP2K_HI8INSN: 210 return &ip2k_elf_howto_table[ (int) R_IP2K_HI8INSN]; 211 case BFD_RELOC_IP2K_PC_SKIP: 212 return &ip2k_elf_howto_table[ (int) R_IP2K_PC_SKIP]; 213 case BFD_RELOC_IP2K_TEXT: 214 return &ip2k_elf_howto_table[ (int) R_IP2K_TEXT]; 215 case BFD_RELOC_IP2K_FR_OFFSET: 216 return &ip2k_elf_howto_table[ (int) R_IP2K_FR_OFFSET]; 217 case BFD_RELOC_IP2K_EX8DATA: 218 return &ip2k_elf_howto_table[ (int) R_IP2K_EX8DATA]; 219 default: 220 /* Pacify gcc -Wall. */ 221 return NULL; 222 } 223 return NULL; 224 } 225 226 static reloc_howto_type * 227 ip2k_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) 228 { 229 unsigned int i; 230 231 for (i = 0; 232 i < sizeof (ip2k_elf_howto_table) / sizeof (ip2k_elf_howto_table[0]); 233 i++) 234 if (ip2k_elf_howto_table[i].name != NULL 235 && strcasecmp (ip2k_elf_howto_table[i].name, r_name) == 0) 236 return &ip2k_elf_howto_table[i]; 237 238 return NULL; 239 } 240 241 static void 242 ip2k_get_mem (bfd *abfd ATTRIBUTE_UNUSED, 243 bfd_byte *addr, 244 int length, 245 bfd_byte *ptr) 246 { 247 while (length --) 248 * ptr ++ = bfd_get_8 (abfd, addr ++); 249 } 250 251 static bfd_boolean 252 ip2k_is_opcode (bfd_byte *code, const struct ip2k_opcode *opcodes) 253 { 254 unsigned short insn = (code[0] << 8) | code[1]; 255 256 while (opcodes->mask != 0) 257 { 258 if ((insn & opcodes->mask) == opcodes->opcode) 259 return TRUE; 260 261 opcodes ++; 262 } 263 264 return FALSE; 265 } 266 267 #define PAGENO(ABSADDR) ((ABSADDR) & 0xFFFFC000) 268 #define BASEADDR(SEC) ((SEC)->output_section->vma + (SEC)->output_offset) 269 270 #define UNDEFINED_SYMBOL (~(bfd_vma)0) 271 272 /* Return the value of the symbol associated with the relocation IREL. */ 273 274 static bfd_vma 275 symbol_value (bfd *abfd, 276 Elf_Internal_Shdr *symtab_hdr, 277 Elf_Internal_Sym *isymbuf, 278 Elf_Internal_Rela *irel) 279 { 280 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 281 { 282 Elf_Internal_Sym *isym; 283 asection *sym_sec; 284 285 isym = isymbuf + ELF32_R_SYM (irel->r_info); 286 if (isym->st_shndx == SHN_UNDEF) 287 sym_sec = bfd_und_section_ptr; 288 else if (isym->st_shndx == SHN_ABS) 289 sym_sec = bfd_abs_section_ptr; 290 else if (isym->st_shndx == SHN_COMMON) 291 sym_sec = bfd_com_section_ptr; 292 else 293 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 294 295 return isym->st_value + BASEADDR (sym_sec); 296 } 297 else 298 { 299 unsigned long indx; 300 struct elf_link_hash_entry *h; 301 302 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 303 h = elf_sym_hashes (abfd)[indx]; 304 BFD_ASSERT (h != NULL); 305 306 if (h->root.type != bfd_link_hash_defined 307 && h->root.type != bfd_link_hash_defweak) 308 return UNDEFINED_SYMBOL; 309 310 return (h->root.u.def.value + BASEADDR (h->root.u.def.section)); 311 } 312 } 313 314 /* Determine if the instruction sequence matches that for 315 the prologue of a switch dispatch table with fewer than 316 128 entries. 317 318 sc 319 page $nnn0 320 jmp $nnn0 321 add w,wreg 322 add pcl,w 323 addr=> 324 page $nnn1 325 jmp $nnn1 326 page $nnn2 327 jmp $nnn2 328 ... 329 page $nnnN 330 jmp $nnnN 331 332 After relaxation. 333 sc 334 page $nnn0 335 jmp $nnn0 336 add pcl,w 337 addr=> 338 jmp $nnn1 339 jmp $nnn2 340 ... 341 jmp $nnnN */ 342 343 static int 344 ip2k_is_switch_table_128 (bfd *abfd ATTRIBUTE_UNUSED, 345 asection *sec, 346 bfd_vma addr, 347 bfd_byte *contents) 348 { 349 bfd_byte code[4]; 350 int index = 0; 351 352 /* Check current page-jmp. */ 353 if (addr + 4 > sec->size) 354 return -1; 355 356 ip2k_get_mem (abfd, contents + addr, 4, code); 357 358 if ((! IS_PAGE_OPCODE (code + 0)) 359 || (! IS_JMP_OPCODE (code + 2))) 360 return -1; 361 362 /* Search back. */ 363 while (1) 364 { 365 if (addr < 4) 366 return -1; 367 368 /* Check previous 2 instructions. */ 369 ip2k_get_mem (abfd, contents + addr - 4, 4, code); 370 if ((IS_ADD_W_WREG_OPCODE (code + 0)) 371 && (IS_ADD_PCL_W_OPCODE (code + 2))) 372 return index; 373 374 if ((! IS_PAGE_OPCODE (code + 0)) 375 || (! IS_JMP_OPCODE (code + 2))) 376 return -1; 377 378 index++; 379 addr -= 4; 380 } 381 } 382 383 /* Determine if the instruction sequence matches that for 384 the prologue switch dispatch table with fewer than 385 256 entries but more than 127. 386 387 Before relaxation. 388 push %lo8insn(label) ; Push address of table 389 push %hi8insn(label) 390 add w,wreg ; index*2 => offset 391 snc ; CARRY SET? 392 inc 1(sp) ; Propagate MSB into table address 393 add 2(sp),w ; Add low bits of offset to table address 394 snc ; and handle any carry-out 395 inc 1(sp) 396 addr=> 397 page __indjmp ; Do an indirect jump to that location 398 jmp __indjmp 399 label: ; case dispatch table starts here 400 page $nnn1 401 jmp $nnn1 402 page $nnn2 403 jmp $nnn2 404 ... 405 page $nnnN 406 jmp $nnnN 407 408 After relaxation. 409 push %lo8insn(label) ; Push address of table 410 push %hi8insn(label) 411 add 2(sp),w ; Add low bits of offset to table address 412 snc ; and handle any carry-out 413 inc 1(sp) 414 addr=> 415 page __indjmp ; Do an indirect jump to that location 416 jmp __indjmp 417 label: ; case dispatch table starts here 418 jmp $nnn1 419 jmp $nnn2 420 ... 421 jmp $nnnN */ 422 423 static int 424 ip2k_is_switch_table_256 (bfd *abfd ATTRIBUTE_UNUSED, 425 asection *sec, 426 bfd_vma addr, 427 bfd_byte *contents) 428 { 429 bfd_byte code[16]; 430 int index = 0; 431 432 /* Check current page-jmp. */ 433 if (addr + 4 > sec->size) 434 return -1; 435 436 ip2k_get_mem (abfd, contents + addr, 4, code); 437 if ((! IS_PAGE_OPCODE (code + 0)) 438 || (! IS_JMP_OPCODE (code + 2))) 439 return -1; 440 441 /* Search back. */ 442 while (1) 443 { 444 if (addr < 16) 445 return -1; 446 447 /* Check previous 8 instructions. */ 448 ip2k_get_mem (abfd, contents + addr - 16, 16, code); 449 if ((IS_ADD_W_WREG_OPCODE (code + 0)) 450 && (IS_SNC_OPCODE (code + 2)) 451 && (IS_INC_1SP_OPCODE (code + 4)) 452 && (IS_ADD_2SP_W_OPCODE (code + 6)) 453 && (IS_SNC_OPCODE (code + 8)) 454 && (IS_INC_1SP_OPCODE (code + 10)) 455 && (IS_PAGE_OPCODE (code + 12)) 456 && (IS_JMP_OPCODE (code + 14))) 457 return index; 458 459 if ((IS_ADD_W_WREG_OPCODE (code + 2)) 460 && (IS_SNC_OPCODE (code + 4)) 461 && (IS_INC_1SP_OPCODE (code + 6)) 462 && (IS_ADD_2SP_W_OPCODE (code + 8)) 463 && (IS_SNC_OPCODE (code + 10)) 464 && (IS_INC_1SP_OPCODE (code + 12)) 465 && (IS_JMP_OPCODE (code + 14))) 466 return index; 467 468 if ((! IS_PAGE_OPCODE (code + 0)) 469 || (! IS_JMP_OPCODE (code + 2))) 470 return -1; 471 472 index++; 473 addr -= 4; 474 } 475 } 476 477 /* Returns the expected page state for the given instruction not including 478 the effect of page instructions. */ 479 480 static bfd_vma 481 ip2k_nominal_page_bits (bfd *abfd ATTRIBUTE_UNUSED, 482 asection *sec, 483 bfd_vma addr, 484 bfd_byte *contents) 485 { 486 bfd_vma page = PAGENO (BASEADDR (sec) + addr); 487 488 /* Check if section flows into this page. If not then the page 489 bits are assumed to match the PC. This will be true unless 490 the user has a page instruction without a call/jump, in which 491 case they are on their own. */ 492 if (PAGENO (BASEADDR (sec)) == page) 493 return page; 494 495 /* Section flows across page boundary. The page bits should match 496 the PC unless there is a possible flow from the previous page, 497 in which case it is not possible to determine the value of the 498 page bits. */ 499 while (PAGENO (BASEADDR (sec) + addr - 2) == page) 500 { 501 bfd_byte code[2]; 502 503 addr -= 2; 504 ip2k_get_mem (abfd, contents + addr, 2, code); 505 if (!IS_PAGE_OPCODE (code)) 506 continue; 507 508 /* Found a page instruction, check if jump table. */ 509 if (ip2k_is_switch_table_128 (abfd, sec, addr, contents) != -1) 510 /* Jump table => page is conditional. */ 511 continue; 512 513 if (ip2k_is_switch_table_256 (abfd, sec, addr, contents) != -1) 514 /* Jump table => page is conditional. */ 515 continue; 516 517 /* Found a page instruction, check if conditional. */ 518 if (addr >= 2) 519 { 520 ip2k_get_mem (abfd, contents + addr - 2, 2, code); 521 if (IS_SKIP_OPCODE (code)) 522 /* Page is conditional. */ 523 continue; 524 } 525 526 /* Unconditional page instruction => page bits should be correct. */ 527 return page; 528 } 529 530 /* Flow from previous page => page bits are impossible to determine. */ 531 return 0; 532 } 533 534 static bfd_boolean 535 ip2k_test_page_insn (bfd *abfd ATTRIBUTE_UNUSED, 536 asection *sec, 537 Elf_Internal_Rela *irel, 538 struct misc *misc) 539 { 540 bfd_vma symval; 541 542 /* Get the value of the symbol referred to by the reloc. */ 543 symval = symbol_value (abfd, misc->symtab_hdr, misc->isymbuf, irel); 544 if (symval == UNDEFINED_SYMBOL) 545 /* This appears to be a reference to an undefined 546 symbol. Just ignore it--it will be caught by the 547 regular reloc processing. */ 548 return FALSE; 549 550 /* Test if we can delete this page instruction. */ 551 if (PAGENO (symval + irel->r_addend) != 552 ip2k_nominal_page_bits (abfd, sec, irel->r_offset, misc->contents)) 553 return FALSE; 554 555 return TRUE; 556 } 557 558 /* Parts of a Stabs entry. */ 559 560 #define STRDXOFF 0 561 #define TYPEOFF 4 562 #define OTHEROFF 5 563 #define DESCOFF 6 564 #define VALOFF 8 565 #define STABSIZE 12 566 567 /* Adjust all the relocations entries after adding or inserting instructions. */ 568 569 static void 570 adjust_all_relocations (bfd *abfd, 571 asection *sec, 572 bfd_vma addr, 573 bfd_vma endaddr, 574 int count, 575 int noadj) 576 { 577 Elf_Internal_Shdr *symtab_hdr; 578 Elf_Internal_Sym *isymbuf, *isym, *isymend; 579 unsigned int shndx; 580 bfd_byte *contents; 581 Elf_Internal_Rela *irel, *irelend, *irelbase; 582 struct elf_link_hash_entry **sym_hashes; 583 struct elf_link_hash_entry **end_hashes; 584 unsigned int symcount; 585 asection *stab; 586 587 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 588 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 589 590 shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 591 592 contents = elf_section_data (sec)->this_hdr.contents; 593 594 irelbase = elf_section_data (sec)->relocs; 595 irelend = irelbase + sec->reloc_count; 596 597 for (irel = irelbase; irel < irelend; irel++) 598 { 599 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE) 600 { 601 /* Get the value of the symbol referred to by the reloc. */ 602 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 603 { 604 asection *sym_sec; 605 606 /* A local symbol. */ 607 isym = isymbuf + ELF32_R_SYM (irel->r_info); 608 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 609 610 if (isym->st_shndx == shndx) 611 { 612 bfd_vma baseaddr = BASEADDR (sec); 613 bfd_vma symval = BASEADDR (sym_sec) + isym->st_value 614 + irel->r_addend; 615 616 if ((baseaddr + addr + noadj) <= symval 617 && symval < (baseaddr + endaddr)) 618 irel->r_addend += count; 619 } 620 } 621 } 622 623 /* Do this only for PC space relocations. */ 624 if (addr <= irel->r_offset && irel->r_offset < endaddr) 625 irel->r_offset += count; 626 } 627 628 /* Now fix the stab relocations. */ 629 stab = bfd_get_section_by_name (abfd, ".stab"); 630 if (stab) 631 { 632 bfd_byte *stabcontents, *stabend, *stabp; 633 bfd_size_type stab_size = stab->rawsize ? stab->rawsize : stab->size; 634 635 irelbase = elf_section_data (stab)->relocs; 636 irelend = irelbase + stab->reloc_count; 637 638 /* Pull out the contents of the stab section. */ 639 if (elf_section_data (stab)->this_hdr.contents != NULL) 640 stabcontents = elf_section_data (stab)->this_hdr.contents; 641 else 642 { 643 if (!bfd_malloc_and_get_section (abfd, stab, &stabcontents)) 644 { 645 if (stabcontents != NULL) 646 free (stabcontents); 647 return; 648 } 649 650 /* We need to remember this. */ 651 elf_section_data (stab)->this_hdr.contents = stabcontents; 652 } 653 654 stabend = stabcontents + stab_size; 655 656 for (irel = irelbase; irel < irelend; irel++) 657 { 658 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE) 659 { 660 /* Get the value of the symbol referred to by the reloc. */ 661 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 662 { 663 asection *sym_sec; 664 665 /* A local symbol. */ 666 isym = isymbuf + ELF32_R_SYM (irel->r_info); 667 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 668 669 if (sym_sec == sec) 670 { 671 const char *name; 672 unsigned long strx; 673 unsigned char type, other; 674 unsigned short desc; 675 bfd_vma value; 676 bfd_vma baseaddr = BASEADDR (sec); 677 bfd_vma symval = BASEADDR (sym_sec) + isym->st_value 678 + irel->r_addend; 679 680 if ((baseaddr + addr) <= symval 681 && symval <= (baseaddr + endaddr)) 682 irel->r_addend += count; 683 684 /* Go hunt up a function and fix its line info if needed. */ 685 stabp = stabcontents + irel->r_offset - 8; 686 687 /* Go pullout the stab entry. */ 688 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF); 689 type = bfd_h_get_8 (abfd, stabp + TYPEOFF); 690 other = bfd_h_get_8 (abfd, stabp + OTHEROFF); 691 desc = bfd_h_get_16 (abfd, stabp + DESCOFF); 692 value = bfd_h_get_32 (abfd, stabp + VALOFF); 693 694 name = bfd_get_stab_name (type); 695 696 if (strcmp (name, "FUN") == 0) 697 { 698 int function_adjusted = 0; 699 700 if (symval > (baseaddr + addr)) 701 /* Not in this function. */ 702 continue; 703 704 /* Hey we got a function hit. */ 705 stabp += STABSIZE; 706 for (;stabp < stabend; stabp += STABSIZE) 707 { 708 /* Go pullout the stab entry. */ 709 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF); 710 type = bfd_h_get_8 (abfd, stabp + TYPEOFF); 711 other = bfd_h_get_8 (abfd, stabp + OTHEROFF); 712 desc = bfd_h_get_16 (abfd, stabp + DESCOFF); 713 value = bfd_h_get_32 (abfd, stabp + VALOFF); 714 715 name = bfd_get_stab_name (type); 716 717 if (strcmp (name, "FUN") == 0) 718 { 719 /* Hit another function entry. */ 720 if (function_adjusted) 721 { 722 /* Adjust the value. */ 723 value += count; 724 725 /* We need to put it back. */ 726 bfd_h_put_32 (abfd, value,stabp + VALOFF); 727 } 728 729 /* And then bale out. */ 730 break; 731 } 732 733 if (strcmp (name, "SLINE") == 0) 734 { 735 /* Got a line entry. */ 736 if ((baseaddr + addr) <= (symval + value)) 737 { 738 /* Adjust the line entry. */ 739 value += count; 740 741 /* We need to put it back. */ 742 bfd_h_put_32 (abfd, value,stabp + VALOFF); 743 function_adjusted = 1; 744 } 745 } 746 } 747 } 748 } 749 } 750 } 751 } 752 } 753 754 /* When adding an instruction back it is sometimes necessary to move any 755 global or local symbol that was referencing the first instruction of 756 the moved block to refer to the first instruction of the inserted block. 757 758 For example adding a PAGE instruction before a CALL or JMP requires 759 that any label on the CALL or JMP is moved to the PAGE insn. */ 760 addr += noadj; 761 762 /* Adjust the local symbols defined in this section. */ 763 isymend = isymbuf + symtab_hdr->sh_info; 764 for (isym = isymbuf; isym < isymend; isym++) 765 { 766 if (isym->st_shndx == shndx 767 && addr <= isym->st_value 768 && isym->st_value < endaddr) 769 isym->st_value += count; 770 } 771 772 /* Now adjust the global symbols defined in this section. */ 773 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 774 - symtab_hdr->sh_info); 775 sym_hashes = elf_sym_hashes (abfd); 776 end_hashes = sym_hashes + symcount; 777 for (; sym_hashes < end_hashes; sym_hashes++) 778 { 779 struct elf_link_hash_entry *sym_hash = *sym_hashes; 780 781 if ((sym_hash->root.type == bfd_link_hash_defined 782 || sym_hash->root.type == bfd_link_hash_defweak) 783 && sym_hash->root.u.def.section == sec) 784 { 785 if (addr <= sym_hash->root.u.def.value 786 && sym_hash->root.u.def.value < endaddr) 787 sym_hash->root.u.def.value += count; 788 } 789 } 790 791 return; 792 } 793 794 /* Delete some bytes from a section while relaxing. */ 795 796 static bfd_boolean 797 ip2k_elf_relax_delete_bytes (bfd *abfd, 798 asection *sec, 799 bfd_vma addr, 800 int count) 801 { 802 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 803 bfd_vma endaddr = sec->size; 804 805 /* Actually delete the bytes. */ 806 memmove (contents + addr, contents + addr + count, 807 endaddr - addr - count); 808 809 sec->size -= count; 810 811 adjust_all_relocations (abfd, sec, addr + count, endaddr, -count, 0); 812 return TRUE; 813 } 814 815 static bfd_boolean 816 ip2k_delete_page_insn (bfd *abfd ATTRIBUTE_UNUSED, 817 asection *sec, 818 Elf_Internal_Rela *irel, 819 bfd_boolean *again, 820 struct misc *misc) 821 { 822 /* Note that we've changed the relocs, section contents, etc. */ 823 elf_section_data (sec)->relocs = misc->irelbase; 824 elf_section_data (sec)->this_hdr.contents = misc->contents; 825 misc->symtab_hdr->contents = (bfd_byte *) misc->isymbuf; 826 827 /* Fix the relocation's type. */ 828 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_IP2K_NONE); 829 830 /* Delete the PAGE insn. */ 831 if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset, 2)) 832 return FALSE; 833 834 /* Modified => will need to iterate relaxation again. */ 835 *again = TRUE; 836 837 return TRUE; 838 } 839 840 static bfd_boolean 841 ip2k_relax_switch_table_128 (bfd *abfd ATTRIBUTE_UNUSED, 842 asection *sec, 843 Elf_Internal_Rela *irel, 844 bfd_boolean *again, 845 struct misc *misc) 846 { 847 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count; 848 Elf_Internal_Rela *ireltest = irel; 849 bfd_byte code[4]; 850 bfd_vma addr; 851 852 /* Test all page instructions. */ 853 addr = irel->r_offset; 854 while (1) 855 { 856 if (addr + 4 > sec->size) 857 break; 858 859 ip2k_get_mem (abfd, misc->contents + addr, 4, code); 860 if ((! IS_PAGE_OPCODE (code + 0)) 861 || (! IS_JMP_OPCODE (code + 2))) 862 break; 863 864 /* Validate relocation entry (every entry should have a matching 865 relocation entry). */ 866 if (ireltest >= irelend) 867 { 868 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information.")); 869 return FALSE; 870 } 871 872 if (ireltest->r_offset != addr) 873 { 874 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information.")); 875 return FALSE; 876 } 877 878 if (! ip2k_test_page_insn (abfd, sec, ireltest, misc)) 879 /* Un-removable page insn => nothing can be done. */ 880 return TRUE; 881 882 addr += 4; 883 ireltest += 2; 884 } 885 886 /* Relaxable. Adjust table header. */ 887 ip2k_get_mem (abfd, misc->contents + irel->r_offset - 4, 4, code); 888 if ((! IS_ADD_W_WREG_OPCODE (code + 0)) 889 || (! IS_ADD_PCL_W_OPCODE (code + 2))) 890 { 891 _bfd_error_handler (_("ip2k relaxer: switch table header corrupt.")); 892 return FALSE; 893 } 894 895 if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset - 4, 2)) 896 return FALSE; 897 898 *again = TRUE; 899 900 /* Delete all page instructions in table. */ 901 while (irel < ireltest) 902 { 903 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc)) 904 return FALSE; 905 irel += 2; 906 } 907 908 return TRUE; 909 } 910 911 static bfd_boolean 912 ip2k_relax_switch_table_256 (bfd *abfd ATTRIBUTE_UNUSED, 913 asection *sec, 914 Elf_Internal_Rela *irel, 915 bfd_boolean *again, 916 struct misc *misc) 917 { 918 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count; 919 Elf_Internal_Rela *ireltest = irel; 920 bfd_byte code[12]; 921 bfd_vma addr; 922 923 /* Test all page instructions. */ 924 addr = irel->r_offset; 925 926 while (1) 927 { 928 if (addr + 4 > sec->size) 929 break; 930 931 ip2k_get_mem (abfd, misc->contents + addr, 4, code); 932 933 if ((! IS_PAGE_OPCODE (code + 0)) 934 || (! IS_JMP_OPCODE (code + 2))) 935 break; 936 937 /* Validate relocation entry (every entry should have a matching 938 relocation entry). */ 939 if (ireltest >= irelend) 940 { 941 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information.")); 942 return FALSE; 943 } 944 945 if (ireltest->r_offset != addr) 946 { 947 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information.")); 948 return FALSE; 949 } 950 951 if (!ip2k_test_page_insn (abfd, sec, ireltest, misc)) 952 /* Un-removable page insn => nothing can be done. */ 953 return TRUE; 954 955 addr += 4; 956 ireltest += 2; 957 } 958 959 /* Relaxable. Adjust table header. */ 960 ip2k_get_mem (abfd, misc->contents + irel->r_offset - 4, 2, code); 961 if (IS_PAGE_OPCODE (code)) 962 addr = irel->r_offset - 16; 963 else 964 addr = irel->r_offset - 14; 965 966 ip2k_get_mem (abfd, misc->contents + addr, 12, code); 967 if ((!IS_ADD_W_WREG_OPCODE (code + 0)) 968 || (!IS_SNC_OPCODE (code + 2)) 969 || (!IS_INC_1SP_OPCODE (code + 4)) 970 || (!IS_ADD_2SP_W_OPCODE (code + 6)) 971 || (!IS_SNC_OPCODE (code + 8)) 972 || (!IS_INC_1SP_OPCODE (code + 10))) 973 { 974 _bfd_error_handler (_("ip2k relaxer: switch table header corrupt.")); 975 return FALSE; 976 } 977 978 /* Delete first 3 opcodes. */ 979 if (!ip2k_elf_relax_delete_bytes (abfd, sec, addr + 0, 6)) 980 return FALSE; 981 982 *again = TRUE; 983 984 /* Delete all page instructions in table. */ 985 while (irel < ireltest) 986 { 987 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc)) 988 return FALSE; 989 irel += 2; 990 } 991 992 return TRUE; 993 } 994 995 /* This function handles relaxation of a section in a specific page. */ 996 997 static bfd_boolean 998 ip2k_elf_relax_section_page (bfd *abfd, 999 asection *sec, 1000 bfd_boolean *again, 1001 struct misc *misc, 1002 unsigned long page_start, 1003 unsigned long page_end) 1004 { 1005 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count; 1006 Elf_Internal_Rela *irel; 1007 int switch_table_128; 1008 int switch_table_256; 1009 1010 /* Walk thru the section looking for relaxation opportunities. */ 1011 for (irel = misc->irelbase; irel < irelend; irel++) 1012 { 1013 if (ELF32_R_TYPE (irel->r_info) != (int) R_IP2K_PAGE3) 1014 /* Ignore non page instructions. */ 1015 continue; 1016 1017 if (BASEADDR (sec) + irel->r_offset < page_start) 1018 /* Ignore page instructions on earlier page - they have 1019 already been processed. Remember that there is code flow 1020 that crosses a page boundary. */ 1021 continue; 1022 1023 if (BASEADDR (sec) + irel->r_offset > page_end) 1024 /* Flow beyond end of page => nothing more to do for this page. */ 1025 return TRUE; 1026 1027 /* Detect switch tables. */ 1028 switch_table_128 = ip2k_is_switch_table_128 (abfd, sec, irel->r_offset, misc->contents); 1029 switch_table_256 = ip2k_is_switch_table_256 (abfd, sec, irel->r_offset, misc->contents); 1030 1031 if ((switch_table_128 > 0) || (switch_table_256 > 0)) 1032 /* If the index is greater than 0 then it has already been processed. */ 1033 continue; 1034 1035 if (switch_table_128 == 0) 1036 { 1037 if (!ip2k_relax_switch_table_128 (abfd, sec, irel, again, misc)) 1038 return FALSE; 1039 1040 continue; 1041 } 1042 1043 if (switch_table_256 == 0) 1044 { 1045 if (!ip2k_relax_switch_table_256 (abfd, sec, irel, again, misc)) 1046 return FALSE; 1047 1048 continue; 1049 } 1050 1051 /* Simple relax. */ 1052 if (ip2k_test_page_insn (abfd, sec, irel, misc)) 1053 { 1054 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc)) 1055 return FALSE; 1056 1057 continue; 1058 } 1059 } 1060 1061 return TRUE; 1062 } 1063 1064 /* This function handles relaxing for the ip2k. 1065 1066 Principle: Start with the first page and remove page instructions that 1067 are not require on this first page. By removing page instructions more 1068 code will fit into this page - repeat until nothing more can be achieved 1069 for this page. Move on to the next page. 1070 1071 Processing the pages one at a time from the lowest page allows a removal 1072 only policy to be used - pages can be removed but are never reinserted. */ 1073 1074 static bfd_boolean 1075 ip2k_elf_relax_section (bfd *abfd, 1076 asection *sec, 1077 struct bfd_link_info *link_info, 1078 bfd_boolean *again) 1079 { 1080 Elf_Internal_Shdr *symtab_hdr; 1081 Elf_Internal_Rela *internal_relocs; 1082 bfd_byte *contents = NULL; 1083 Elf_Internal_Sym *isymbuf = NULL; 1084 static asection * first_section = NULL; 1085 static unsigned long search_addr; 1086 static unsigned long page_start = 0; 1087 static unsigned long page_end = 0; 1088 static unsigned int pass = 0; 1089 static bfd_boolean new_pass = FALSE; 1090 static bfd_boolean changed = FALSE; 1091 struct misc misc; 1092 asection *stab; 1093 1094 /* Assume nothing changes. */ 1095 *again = FALSE; 1096 1097 if (first_section == NULL) 1098 { 1099 ip2k_relaxed = TRUE; 1100 first_section = sec; 1101 } 1102 1103 if (first_section == sec) 1104 { 1105 pass++; 1106 new_pass = TRUE; 1107 } 1108 1109 /* We don't have to do anything for a relocatable link, 1110 if this section does not have relocs, or if this is 1111 not a code section. */ 1112 if (link_info->relocatable 1113 || (sec->flags & SEC_RELOC) == 0 1114 || sec->reloc_count == 0 1115 || (sec->flags & SEC_CODE) == 0) 1116 return TRUE; 1117 1118 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1119 1120 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 1121 link_info->keep_memory); 1122 if (internal_relocs == NULL) 1123 goto error_return; 1124 1125 /* Make sure the stac.rela stuff gets read in. */ 1126 stab = bfd_get_section_by_name (abfd, ".stab"); 1127 1128 if (stab) 1129 { 1130 /* So stab does exits. */ 1131 Elf_Internal_Rela * irelbase; 1132 1133 irelbase = _bfd_elf_link_read_relocs (abfd, stab, NULL, NULL, 1134 link_info->keep_memory); 1135 } 1136 1137 /* Get section contents cached copy if it exists. */ 1138 if (contents == NULL) 1139 { 1140 /* Get cached copy if it exists. */ 1141 if (elf_section_data (sec)->this_hdr.contents != NULL) 1142 contents = elf_section_data (sec)->this_hdr.contents; 1143 else 1144 { 1145 /* Go get them off disk. */ 1146 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 1147 goto error_return; 1148 } 1149 } 1150 1151 /* Read this BFD's symbols cached copy if it exists. */ 1152 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 1153 { 1154 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1155 if (isymbuf == NULL) 1156 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 1157 symtab_hdr->sh_info, 0, 1158 NULL, NULL, NULL); 1159 if (isymbuf == NULL) 1160 goto error_return; 1161 } 1162 1163 misc.symtab_hdr = symtab_hdr; 1164 misc.isymbuf = isymbuf; 1165 misc.irelbase = internal_relocs; 1166 misc.contents = contents; 1167 1168 /* This is where all the relaxation actually get done. */ 1169 if ((pass == 1) || (new_pass && !changed)) 1170 { 1171 /* On the first pass we simply search for the lowest page that 1172 we havn't relaxed yet. Note that the pass count is reset 1173 each time a page is complete in order to move on to the next page. 1174 If we can't find any more pages then we are finished. */ 1175 if (new_pass) 1176 { 1177 pass = 1; 1178 new_pass = FALSE; 1179 changed = TRUE; /* Pre-initialize to break out of pass 1. */ 1180 search_addr = 0xFFFFFFFF; 1181 } 1182 1183 if ((BASEADDR (sec) + sec->size < search_addr) 1184 && (BASEADDR (sec) + sec->size > page_end)) 1185 { 1186 if (BASEADDR (sec) <= page_end) 1187 search_addr = page_end + 1; 1188 else 1189 search_addr = BASEADDR (sec); 1190 1191 /* Found a page => more work to do. */ 1192 *again = TRUE; 1193 } 1194 } 1195 else 1196 { 1197 if (new_pass) 1198 { 1199 new_pass = FALSE; 1200 changed = FALSE; 1201 page_start = PAGENO (search_addr); 1202 page_end = page_start | 0x00003FFF; 1203 } 1204 1205 /* Only process sections in range. */ 1206 if ((BASEADDR (sec) + sec->size >= page_start) 1207 && (BASEADDR (sec) <= page_end)) 1208 { 1209 if (!ip2k_elf_relax_section_page (abfd, sec, &changed, &misc, page_start, page_end)) 1210 return FALSE; 1211 } 1212 *again = TRUE; 1213 } 1214 1215 /* Perform some house keeping after relaxing the section. */ 1216 1217 if (isymbuf != NULL 1218 && symtab_hdr->contents != (unsigned char *) isymbuf) 1219 { 1220 if (! link_info->keep_memory) 1221 free (isymbuf); 1222 else 1223 symtab_hdr->contents = (unsigned char *) isymbuf; 1224 } 1225 1226 if (contents != NULL 1227 && elf_section_data (sec)->this_hdr.contents != contents) 1228 { 1229 if (! link_info->keep_memory) 1230 free (contents); 1231 else 1232 { 1233 /* Cache the section contents for elf_link_input_bfd. */ 1234 elf_section_data (sec)->this_hdr.contents = contents; 1235 } 1236 } 1237 1238 if (internal_relocs != NULL 1239 && elf_section_data (sec)->relocs != internal_relocs) 1240 free (internal_relocs); 1241 1242 return TRUE; 1243 1244 error_return: 1245 if (isymbuf != NULL 1246 && symtab_hdr->contents != (unsigned char *) isymbuf) 1247 free (isymbuf); 1248 if (contents != NULL 1249 && elf_section_data (sec)->this_hdr.contents != contents) 1250 free (contents); 1251 if (internal_relocs != NULL 1252 && elf_section_data (sec)->relocs != internal_relocs) 1253 free (internal_relocs); 1254 return FALSE; 1255 } 1256 1257 /* Set the howto pointer for a IP2K ELF reloc. */ 1258 1259 static void 1260 ip2k_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED, 1261 arelent * cache_ptr, 1262 Elf_Internal_Rela * dst) 1263 { 1264 unsigned int r_type; 1265 1266 r_type = ELF32_R_TYPE (dst->r_info); 1267 cache_ptr->howto = & ip2k_elf_howto_table [r_type]; 1268 } 1269 1270 /* Perform a single relocation. 1271 By default we use the standard BFD routines. */ 1272 1273 static bfd_reloc_status_type 1274 ip2k_final_link_relocate (reloc_howto_type * howto, 1275 bfd * input_bfd, 1276 asection * input_section, 1277 bfd_byte * contents, 1278 Elf_Internal_Rela * rel, 1279 bfd_vma relocation) 1280 { 1281 static bfd_vma page_addr = 0; 1282 1283 bfd_reloc_status_type r = bfd_reloc_ok; 1284 switch (howto->type) 1285 { 1286 /* Handle data space relocations. */ 1287 case R_IP2K_FR9: 1288 case R_IP2K_BANK: 1289 if ((relocation & IP2K_DATA_MASK) == IP2K_DATA_VALUE) 1290 relocation &= ~IP2K_DATA_MASK; 1291 else 1292 r = bfd_reloc_notsupported; 1293 break; 1294 1295 case R_IP2K_LO8DATA: 1296 case R_IP2K_HI8DATA: 1297 case R_IP2K_EX8DATA: 1298 break; 1299 1300 /* Handle insn space relocations. */ 1301 case R_IP2K_PAGE3: 1302 page_addr = BASEADDR (input_section) + rel->r_offset; 1303 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE) 1304 relocation &= ~IP2K_INSN_MASK; 1305 else 1306 r = bfd_reloc_notsupported; 1307 break; 1308 1309 case R_IP2K_ADDR16CJP: 1310 if (BASEADDR (input_section) + rel->r_offset != page_addr + 2) 1311 { 1312 /* No preceding page instruction, verify that it isn't needed. */ 1313 if (PAGENO (relocation + rel->r_addend) != 1314 ip2k_nominal_page_bits (input_bfd, input_section, 1315 rel->r_offset, contents)) 1316 _bfd_error_handler (_("ip2k linker: missing page instruction at 0x%08lx (dest = 0x%08lx)."), 1317 BASEADDR (input_section) + rel->r_offset, 1318 relocation + rel->r_addend); 1319 } 1320 else if (ip2k_relaxed) 1321 { 1322 /* Preceding page instruction. Verify that the page instruction is 1323 really needed. One reason for the relaxation to miss a page is if 1324 the section is not marked as executable. */ 1325 if (!ip2k_is_switch_table_128 (input_bfd, input_section, 1326 rel->r_offset - 2, contents) 1327 && !ip2k_is_switch_table_256 (input_bfd, input_section, 1328 rel->r_offset - 2, contents) 1329 && (PAGENO (relocation + rel->r_addend) == 1330 ip2k_nominal_page_bits (input_bfd, input_section, 1331 rel->r_offset - 2, contents))) 1332 _bfd_error_handler (_("ip2k linker: redundant page instruction at 0x%08lx (dest = 0x%08lx)."), 1333 page_addr, 1334 relocation + rel->r_addend); 1335 } 1336 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE) 1337 relocation &= ~IP2K_INSN_MASK; 1338 else 1339 r = bfd_reloc_notsupported; 1340 break; 1341 1342 case R_IP2K_LO8INSN: 1343 case R_IP2K_HI8INSN: 1344 case R_IP2K_PC_SKIP: 1345 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE) 1346 relocation &= ~IP2K_INSN_MASK; 1347 else 1348 r = bfd_reloc_notsupported; 1349 break; 1350 1351 case R_IP2K_16: 1352 /* If this is a relocation involving a TEXT 1353 symbol, reduce it to a word address. */ 1354 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE) 1355 howto = &ip2k_elf_howto_table[ (int) R_IP2K_TEXT]; 1356 break; 1357 1358 /* Pass others through. */ 1359 default: 1360 break; 1361 } 1362 1363 /* Only install relocation if above tests did not disqualify it. */ 1364 if (r == bfd_reloc_ok) 1365 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1366 contents, rel->r_offset, 1367 relocation, rel->r_addend); 1368 1369 return r; 1370 } 1371 1372 /* Relocate a IP2K ELF section. 1373 1374 The RELOCATE_SECTION function is called by the new ELF backend linker 1375 to handle the relocations for a section. 1376 1377 The relocs are always passed as Rela structures; if the section 1378 actually uses Rel structures, the r_addend field will always be 1379 zero. 1380 1381 This function is responsible for adjusting the section contents as 1382 necessary, and (if using Rela relocs and generating a relocatable 1383 output file) adjusting the reloc addend as necessary. 1384 1385 This function does not have to worry about setting the reloc 1386 address or the reloc symbol index. 1387 1388 LOCAL_SYMS is a pointer to the swapped in local symbols. 1389 1390 LOCAL_SECTIONS is an array giving the section in the input file 1391 corresponding to the st_shndx field of each local symbol. 1392 1393 The global hash table entry for the global symbols can be found 1394 via elf_sym_hashes (input_bfd). 1395 1396 When generating relocatable output, this function must handle 1397 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 1398 going to be the section symbol corresponding to the output 1399 section, which means that the addend must be adjusted 1400 accordingly. */ 1401 1402 static bfd_boolean 1403 ip2k_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, 1404 struct bfd_link_info *info, 1405 bfd *input_bfd, 1406 asection *input_section, 1407 bfd_byte *contents, 1408 Elf_Internal_Rela *relocs, 1409 Elf_Internal_Sym *local_syms, 1410 asection **local_sections) 1411 { 1412 Elf_Internal_Shdr *symtab_hdr; 1413 struct elf_link_hash_entry **sym_hashes; 1414 Elf_Internal_Rela *rel; 1415 Elf_Internal_Rela *relend; 1416 1417 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 1418 sym_hashes = elf_sym_hashes (input_bfd); 1419 relend = relocs + input_section->reloc_count; 1420 1421 for (rel = relocs; rel < relend; rel ++) 1422 { 1423 reloc_howto_type * howto; 1424 unsigned long r_symndx; 1425 Elf_Internal_Sym * sym; 1426 asection * sec; 1427 struct elf_link_hash_entry * h; 1428 bfd_vma relocation; 1429 bfd_reloc_status_type r; 1430 const char * name = NULL; 1431 int r_type; 1432 1433 r_type = ELF32_R_TYPE (rel->r_info); 1434 r_symndx = ELF32_R_SYM (rel->r_info); 1435 howto = ip2k_elf_howto_table + ELF32_R_TYPE (rel->r_info); 1436 h = NULL; 1437 sym = NULL; 1438 sec = NULL; 1439 1440 if (r_symndx < symtab_hdr->sh_info) 1441 { 1442 sym = local_syms + r_symndx; 1443 sec = local_sections [r_symndx]; 1444 relocation = BASEADDR (sec) + sym->st_value; 1445 1446 name = bfd_elf_string_from_elf_section 1447 (input_bfd, symtab_hdr->sh_link, sym->st_name); 1448 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; 1449 } 1450 else 1451 { 1452 bfd_boolean warned; 1453 bfd_boolean unresolved_reloc; 1454 1455 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1456 r_symndx, symtab_hdr, sym_hashes, 1457 h, sec, relocation, 1458 unresolved_reloc, warned); 1459 1460 name = h->root.root.string; 1461 } 1462 1463 if (sec != NULL && elf_discarded_section (sec)) 1464 { 1465 /* For relocs against symbols from removed linkonce sections, 1466 or sections discarded by a linker script, we just want the 1467 section contents zeroed. Avoid any special processing. */ 1468 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset); 1469 rel->r_info = 0; 1470 rel->r_addend = 0; 1471 continue; 1472 } 1473 1474 if (info->relocatable) 1475 continue; 1476 1477 /* Finally, the sole IP2K-specific part. */ 1478 r = ip2k_final_link_relocate (howto, input_bfd, input_section, 1479 contents, rel, relocation); 1480 1481 if (r != bfd_reloc_ok) 1482 { 1483 const char * msg = NULL; 1484 1485 switch (r) 1486 { 1487 case bfd_reloc_overflow: 1488 r = info->callbacks->reloc_overflow 1489 (info, (h ? &h->root : NULL), name, howto->name, 1490 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 1491 break; 1492 1493 case bfd_reloc_undefined: 1494 r = info->callbacks->undefined_symbol 1495 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 1496 break; 1497 1498 case bfd_reloc_outofrange: 1499 msg = _("internal error: out of range error"); 1500 break; 1501 1502 /* This is how ip2k_final_link_relocate tells us of a non-kosher 1503 reference between insn & data address spaces. */ 1504 case bfd_reloc_notsupported: 1505 if (sym != NULL) /* Only if it's not an unresolved symbol. */ 1506 msg = _("unsupported relocation between data/insn address spaces"); 1507 break; 1508 1509 case bfd_reloc_dangerous: 1510 msg = _("internal error: dangerous relocation"); 1511 break; 1512 1513 default: 1514 msg = _("internal error: unknown error"); 1515 break; 1516 } 1517 1518 if (msg) 1519 r = info->callbacks->warning 1520 (info, msg, name, input_bfd, input_section, rel->r_offset); 1521 1522 if (! r) 1523 return FALSE; 1524 } 1525 } 1526 1527 return TRUE; 1528 } 1529 1530 #define TARGET_BIG_SYM bfd_elf32_ip2k_vec 1531 #define TARGET_BIG_NAME "elf32-ip2k" 1532 1533 #define ELF_ARCH bfd_arch_ip2k 1534 #define ELF_MACHINE_CODE EM_IP2K 1535 #define ELF_MACHINE_ALT1 EM_IP2K_OLD 1536 #define ELF_MAXPAGESIZE 1 /* No pages on the IP2K. */ 1537 1538 #define elf_info_to_howto_rel NULL 1539 #define elf_info_to_howto ip2k_info_to_howto_rela 1540 1541 #define elf_backend_can_gc_sections 1 1542 #define elf_backend_rela_normal 1 1543 #define elf_backend_relocate_section ip2k_elf_relocate_section 1544 1545 #define elf_symbol_leading_char '_' 1546 #define bfd_elf32_bfd_reloc_type_lookup ip2k_reloc_type_lookup 1547 #define bfd_elf32_bfd_reloc_name_lookup ip2k_reloc_name_lookup 1548 #define bfd_elf32_bfd_relax_section ip2k_elf_relax_section 1549 1550 #include "elf32-target.h" 1551