1 /* Ubicom IP2xxx specific support for 32-bit ELF 2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2012 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 table_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 table_index; 373 374 if ((! IS_PAGE_OPCODE (code + 0)) 375 || (! IS_JMP_OPCODE (code + 2))) 376 return -1; 377 378 table_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 table_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 table_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 table_index; 467 468 if ((! IS_PAGE_OPCODE (code + 0)) 469 || (! IS_JMP_OPCODE (code + 2))) 470 return -1; 471 472 table_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 Elf_Internal_Rela *irel, *irelend, *irelbase; 581 struct elf_link_hash_entry **sym_hashes; 582 struct elf_link_hash_entry **end_hashes; 583 unsigned int symcount; 584 asection *stab; 585 586 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 587 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 588 589 shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 590 591 irelbase = elf_section_data (sec)->relocs; 592 irelend = irelbase + sec->reloc_count; 593 594 for (irel = irelbase; irel < irelend; irel++) 595 { 596 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE) 597 { 598 /* Get the value of the symbol referred to by the reloc. */ 599 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 600 { 601 asection *sym_sec; 602 603 /* A local symbol. */ 604 isym = isymbuf + ELF32_R_SYM (irel->r_info); 605 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 606 607 if (isym->st_shndx == shndx) 608 { 609 bfd_vma baseaddr = BASEADDR (sec); 610 bfd_vma symval = BASEADDR (sym_sec) + isym->st_value 611 + irel->r_addend; 612 613 if ((baseaddr + addr + noadj) <= symval 614 && symval < (baseaddr + endaddr)) 615 irel->r_addend += count; 616 } 617 } 618 } 619 620 /* Do this only for PC space relocations. */ 621 if (addr <= irel->r_offset && irel->r_offset < endaddr) 622 irel->r_offset += count; 623 } 624 625 /* Now fix the stab relocations. */ 626 stab = bfd_get_section_by_name (abfd, ".stab"); 627 if (stab) 628 { 629 bfd_byte *stabcontents, *stabend, *stabp; 630 bfd_size_type stab_size = stab->rawsize ? stab->rawsize : stab->size; 631 632 irelbase = elf_section_data (stab)->relocs; 633 irelend = irelbase + stab->reloc_count; 634 635 /* Pull out the contents of the stab section. */ 636 if (elf_section_data (stab)->this_hdr.contents != NULL) 637 stabcontents = elf_section_data (stab)->this_hdr.contents; 638 else 639 { 640 if (!bfd_malloc_and_get_section (abfd, stab, &stabcontents)) 641 { 642 if (stabcontents != NULL) 643 free (stabcontents); 644 return; 645 } 646 647 /* We need to remember this. */ 648 elf_section_data (stab)->this_hdr.contents = stabcontents; 649 } 650 651 stabend = stabcontents + stab_size; 652 653 for (irel = irelbase; irel < irelend; irel++) 654 { 655 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE) 656 { 657 /* Get the value of the symbol referred to by the reloc. */ 658 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 659 { 660 asection *sym_sec; 661 662 /* A local symbol. */ 663 isym = isymbuf + ELF32_R_SYM (irel->r_info); 664 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 665 666 if (sym_sec == sec) 667 { 668 const char *name; 669 unsigned char type; 670 bfd_vma value; 671 bfd_vma baseaddr = BASEADDR (sec); 672 bfd_vma symval = BASEADDR (sym_sec) + isym->st_value 673 + irel->r_addend; 674 675 if ((baseaddr + addr) <= symval 676 && symval <= (baseaddr + endaddr)) 677 irel->r_addend += count; 678 679 /* Go hunt up a function and fix its line info if needed. */ 680 stabp = stabcontents + irel->r_offset - 8; 681 682 /* Go pullout the stab entry. */ 683 type = bfd_h_get_8 (abfd, stabp + TYPEOFF); 684 value = bfd_h_get_32 (abfd, stabp + VALOFF); 685 686 name = bfd_get_stab_name (type); 687 688 if (strcmp (name, "FUN") == 0) 689 { 690 int function_adjusted = 0; 691 692 if (symval > (baseaddr + addr)) 693 /* Not in this function. */ 694 continue; 695 696 /* Hey we got a function hit. */ 697 stabp += STABSIZE; 698 for (;stabp < stabend; stabp += STABSIZE) 699 { 700 /* Go pullout the stab entry. */ 701 type = bfd_h_get_8 (abfd, stabp + TYPEOFF); 702 value = bfd_h_get_32 (abfd, stabp + VALOFF); 703 704 name = bfd_get_stab_name (type); 705 706 if (strcmp (name, "FUN") == 0) 707 { 708 /* Hit another function entry. */ 709 if (function_adjusted) 710 { 711 /* Adjust the value. */ 712 value += count; 713 714 /* We need to put it back. */ 715 bfd_h_put_32 (abfd, value,stabp + VALOFF); 716 } 717 718 /* And then bale out. */ 719 break; 720 } 721 722 if (strcmp (name, "SLINE") == 0) 723 { 724 /* Got a line entry. */ 725 if ((baseaddr + addr) <= (symval + value)) 726 { 727 /* Adjust the line entry. */ 728 value += count; 729 730 /* We need to put it back. */ 731 bfd_h_put_32 (abfd, value,stabp + VALOFF); 732 function_adjusted = 1; 733 } 734 } 735 } 736 } 737 } 738 } 739 } 740 } 741 } 742 743 /* When adding an instruction back it is sometimes necessary to move any 744 global or local symbol that was referencing the first instruction of 745 the moved block to refer to the first instruction of the inserted block. 746 747 For example adding a PAGE instruction before a CALL or JMP requires 748 that any label on the CALL or JMP is moved to the PAGE insn. */ 749 addr += noadj; 750 751 /* Adjust the local symbols defined in this section. */ 752 isymend = isymbuf + symtab_hdr->sh_info; 753 for (isym = isymbuf; isym < isymend; isym++) 754 { 755 if (isym->st_shndx == shndx 756 && addr <= isym->st_value 757 && isym->st_value < endaddr) 758 isym->st_value += count; 759 } 760 761 /* Now adjust the global symbols defined in this section. */ 762 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 763 - symtab_hdr->sh_info); 764 sym_hashes = elf_sym_hashes (abfd); 765 end_hashes = sym_hashes + symcount; 766 for (; sym_hashes < end_hashes; sym_hashes++) 767 { 768 struct elf_link_hash_entry *sym_hash = *sym_hashes; 769 770 if ((sym_hash->root.type == bfd_link_hash_defined 771 || sym_hash->root.type == bfd_link_hash_defweak) 772 && sym_hash->root.u.def.section == sec) 773 { 774 if (addr <= sym_hash->root.u.def.value 775 && sym_hash->root.u.def.value < endaddr) 776 sym_hash->root.u.def.value += count; 777 } 778 } 779 780 return; 781 } 782 783 /* Delete some bytes from a section while relaxing. */ 784 785 static bfd_boolean 786 ip2k_elf_relax_delete_bytes (bfd *abfd, 787 asection *sec, 788 bfd_vma addr, 789 int count) 790 { 791 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 792 bfd_vma endaddr = sec->size; 793 794 /* Actually delete the bytes. */ 795 memmove (contents + addr, contents + addr + count, 796 endaddr - addr - count); 797 798 sec->size -= count; 799 800 adjust_all_relocations (abfd, sec, addr + count, endaddr, -count, 0); 801 return TRUE; 802 } 803 804 static bfd_boolean 805 ip2k_delete_page_insn (bfd *abfd ATTRIBUTE_UNUSED, 806 asection *sec, 807 Elf_Internal_Rela *irel, 808 bfd_boolean *again, 809 struct misc *misc) 810 { 811 /* Note that we've changed the relocs, section contents, etc. */ 812 elf_section_data (sec)->relocs = misc->irelbase; 813 elf_section_data (sec)->this_hdr.contents = misc->contents; 814 misc->symtab_hdr->contents = (bfd_byte *) misc->isymbuf; 815 816 /* Fix the relocation's type. */ 817 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_IP2K_NONE); 818 819 /* Delete the PAGE insn. */ 820 if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset, 2)) 821 return FALSE; 822 823 /* Modified => will need to iterate relaxation again. */ 824 *again = TRUE; 825 826 return TRUE; 827 } 828 829 static bfd_boolean 830 ip2k_relax_switch_table_128 (bfd *abfd ATTRIBUTE_UNUSED, 831 asection *sec, 832 Elf_Internal_Rela *irel, 833 bfd_boolean *again, 834 struct misc *misc) 835 { 836 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count; 837 Elf_Internal_Rela *ireltest = irel; 838 bfd_byte code[4]; 839 bfd_vma addr; 840 841 /* Test all page instructions. */ 842 addr = irel->r_offset; 843 while (1) 844 { 845 if (addr + 4 > sec->size) 846 break; 847 848 ip2k_get_mem (abfd, misc->contents + addr, 4, code); 849 if ((! IS_PAGE_OPCODE (code + 0)) 850 || (! IS_JMP_OPCODE (code + 2))) 851 break; 852 853 /* Validate relocation entry (every entry should have a matching 854 relocation entry). */ 855 if (ireltest >= irelend) 856 { 857 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information.")); 858 return FALSE; 859 } 860 861 if (ireltest->r_offset != addr) 862 { 863 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information.")); 864 return FALSE; 865 } 866 867 if (! ip2k_test_page_insn (abfd, sec, ireltest, misc)) 868 /* Un-removable page insn => nothing can be done. */ 869 return TRUE; 870 871 addr += 4; 872 ireltest += 2; 873 } 874 875 /* Relaxable. Adjust table header. */ 876 ip2k_get_mem (abfd, misc->contents + irel->r_offset - 4, 4, code); 877 if ((! IS_ADD_W_WREG_OPCODE (code + 0)) 878 || (! IS_ADD_PCL_W_OPCODE (code + 2))) 879 { 880 _bfd_error_handler (_("ip2k relaxer: switch table header corrupt.")); 881 return FALSE; 882 } 883 884 if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset - 4, 2)) 885 return FALSE; 886 887 *again = TRUE; 888 889 /* Delete all page instructions in table. */ 890 while (irel < ireltest) 891 { 892 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc)) 893 return FALSE; 894 irel += 2; 895 } 896 897 return TRUE; 898 } 899 900 static bfd_boolean 901 ip2k_relax_switch_table_256 (bfd *abfd ATTRIBUTE_UNUSED, 902 asection *sec, 903 Elf_Internal_Rela *irel, 904 bfd_boolean *again, 905 struct misc *misc) 906 { 907 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count; 908 Elf_Internal_Rela *ireltest = irel; 909 bfd_byte code[12]; 910 bfd_vma addr; 911 912 /* Test all page instructions. */ 913 addr = irel->r_offset; 914 915 while (1) 916 { 917 if (addr + 4 > sec->size) 918 break; 919 920 ip2k_get_mem (abfd, misc->contents + addr, 4, code); 921 922 if ((! IS_PAGE_OPCODE (code + 0)) 923 || (! IS_JMP_OPCODE (code + 2))) 924 break; 925 926 /* Validate relocation entry (every entry should have a matching 927 relocation entry). */ 928 if (ireltest >= irelend) 929 { 930 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information.")); 931 return FALSE; 932 } 933 934 if (ireltest->r_offset != addr) 935 { 936 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information.")); 937 return FALSE; 938 } 939 940 if (!ip2k_test_page_insn (abfd, sec, ireltest, misc)) 941 /* Un-removable page insn => nothing can be done. */ 942 return TRUE; 943 944 addr += 4; 945 ireltest += 2; 946 } 947 948 /* Relaxable. Adjust table header. */ 949 ip2k_get_mem (abfd, misc->contents + irel->r_offset - 4, 2, code); 950 if (IS_PAGE_OPCODE (code)) 951 addr = irel->r_offset - 16; 952 else 953 addr = irel->r_offset - 14; 954 955 ip2k_get_mem (abfd, misc->contents + addr, 12, code); 956 if ((!IS_ADD_W_WREG_OPCODE (code + 0)) 957 || (!IS_SNC_OPCODE (code + 2)) 958 || (!IS_INC_1SP_OPCODE (code + 4)) 959 || (!IS_ADD_2SP_W_OPCODE (code + 6)) 960 || (!IS_SNC_OPCODE (code + 8)) 961 || (!IS_INC_1SP_OPCODE (code + 10))) 962 { 963 _bfd_error_handler (_("ip2k relaxer: switch table header corrupt.")); 964 return FALSE; 965 } 966 967 /* Delete first 3 opcodes. */ 968 if (!ip2k_elf_relax_delete_bytes (abfd, sec, addr + 0, 6)) 969 return FALSE; 970 971 *again = TRUE; 972 973 /* Delete all page instructions in table. */ 974 while (irel < ireltest) 975 { 976 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc)) 977 return FALSE; 978 irel += 2; 979 } 980 981 return TRUE; 982 } 983 984 /* This function handles relaxation of a section in a specific page. */ 985 986 static bfd_boolean 987 ip2k_elf_relax_section_page (bfd *abfd, 988 asection *sec, 989 bfd_boolean *again, 990 struct misc *misc, 991 unsigned long page_start, 992 unsigned long page_end) 993 { 994 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count; 995 Elf_Internal_Rela *irel; 996 int switch_table_128; 997 int switch_table_256; 998 999 /* Walk thru the section looking for relaxation opportunities. */ 1000 for (irel = misc->irelbase; irel < irelend; irel++) 1001 { 1002 if (ELF32_R_TYPE (irel->r_info) != (int) R_IP2K_PAGE3) 1003 /* Ignore non page instructions. */ 1004 continue; 1005 1006 if (BASEADDR (sec) + irel->r_offset < page_start) 1007 /* Ignore page instructions on earlier page - they have 1008 already been processed. Remember that there is code flow 1009 that crosses a page boundary. */ 1010 continue; 1011 1012 if (BASEADDR (sec) + irel->r_offset > page_end) 1013 /* Flow beyond end of page => nothing more to do for this page. */ 1014 return TRUE; 1015 1016 /* Detect switch tables. */ 1017 switch_table_128 = ip2k_is_switch_table_128 (abfd, sec, irel->r_offset, misc->contents); 1018 switch_table_256 = ip2k_is_switch_table_256 (abfd, sec, irel->r_offset, misc->contents); 1019 1020 if ((switch_table_128 > 0) || (switch_table_256 > 0)) 1021 /* If the index is greater than 0 then it has already been processed. */ 1022 continue; 1023 1024 if (switch_table_128 == 0) 1025 { 1026 if (!ip2k_relax_switch_table_128 (abfd, sec, irel, again, misc)) 1027 return FALSE; 1028 1029 continue; 1030 } 1031 1032 if (switch_table_256 == 0) 1033 { 1034 if (!ip2k_relax_switch_table_256 (abfd, sec, irel, again, misc)) 1035 return FALSE; 1036 1037 continue; 1038 } 1039 1040 /* Simple relax. */ 1041 if (ip2k_test_page_insn (abfd, sec, irel, misc)) 1042 { 1043 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc)) 1044 return FALSE; 1045 1046 continue; 1047 } 1048 } 1049 1050 return TRUE; 1051 } 1052 1053 /* This function handles relaxing for the ip2k. 1054 1055 Principle: Start with the first page and remove page instructions that 1056 are not require on this first page. By removing page instructions more 1057 code will fit into this page - repeat until nothing more can be achieved 1058 for this page. Move on to the next page. 1059 1060 Processing the pages one at a time from the lowest page allows a removal 1061 only policy to be used - pages can be removed but are never reinserted. */ 1062 1063 static bfd_boolean 1064 ip2k_elf_relax_section (bfd *abfd, 1065 asection *sec, 1066 struct bfd_link_info *link_info, 1067 bfd_boolean *again) 1068 { 1069 Elf_Internal_Shdr *symtab_hdr; 1070 Elf_Internal_Rela *internal_relocs; 1071 bfd_byte *contents = NULL; 1072 Elf_Internal_Sym *isymbuf = NULL; 1073 static asection * first_section = NULL; 1074 static unsigned long search_addr; 1075 static unsigned long page_start = 0; 1076 static unsigned long page_end = 0; 1077 static unsigned int pass = 0; 1078 static bfd_boolean new_pass = FALSE; 1079 static bfd_boolean changed = FALSE; 1080 struct misc misc; 1081 1082 /* Assume nothing changes. */ 1083 *again = FALSE; 1084 1085 if (first_section == NULL) 1086 { 1087 ip2k_relaxed = TRUE; 1088 first_section = sec; 1089 } 1090 1091 if (first_section == sec) 1092 { 1093 pass++; 1094 new_pass = TRUE; 1095 } 1096 1097 /* We don't have to do anything for a relocatable link, 1098 if this section does not have relocs, or if this is 1099 not a code section. */ 1100 if (link_info->relocatable 1101 || (sec->flags & SEC_RELOC) == 0 1102 || sec->reloc_count == 0 1103 || (sec->flags & SEC_CODE) == 0) 1104 return TRUE; 1105 1106 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1107 1108 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 1109 link_info->keep_memory); 1110 if (internal_relocs == NULL) 1111 goto error_return; 1112 1113 /* Get section contents cached copy if it exists. */ 1114 if (contents == NULL) 1115 { 1116 /* Get cached copy if it exists. */ 1117 if (elf_section_data (sec)->this_hdr.contents != NULL) 1118 contents = elf_section_data (sec)->this_hdr.contents; 1119 else 1120 { 1121 /* Go get them off disk. */ 1122 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 1123 goto error_return; 1124 } 1125 } 1126 1127 /* Read this BFD's symbols cached copy if it exists. */ 1128 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 1129 { 1130 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1131 if (isymbuf == NULL) 1132 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 1133 symtab_hdr->sh_info, 0, 1134 NULL, NULL, NULL); 1135 if (isymbuf == NULL) 1136 goto error_return; 1137 } 1138 1139 misc.symtab_hdr = symtab_hdr; 1140 misc.isymbuf = isymbuf; 1141 misc.irelbase = internal_relocs; 1142 misc.contents = contents; 1143 1144 /* This is where all the relaxation actually get done. */ 1145 if ((pass == 1) || (new_pass && !changed)) 1146 { 1147 /* On the first pass we simply search for the lowest page that 1148 we havn't relaxed yet. Note that the pass count is reset 1149 each time a page is complete in order to move on to the next page. 1150 If we can't find any more pages then we are finished. */ 1151 if (new_pass) 1152 { 1153 pass = 1; 1154 new_pass = FALSE; 1155 changed = TRUE; /* Pre-initialize to break out of pass 1. */ 1156 search_addr = 0xFFFFFFFF; 1157 } 1158 1159 if ((BASEADDR (sec) + sec->size < search_addr) 1160 && (BASEADDR (sec) + sec->size > page_end)) 1161 { 1162 if (BASEADDR (sec) <= page_end) 1163 search_addr = page_end + 1; 1164 else 1165 search_addr = BASEADDR (sec); 1166 1167 /* Found a page => more work to do. */ 1168 *again = TRUE; 1169 } 1170 } 1171 else 1172 { 1173 if (new_pass) 1174 { 1175 new_pass = FALSE; 1176 changed = FALSE; 1177 page_start = PAGENO (search_addr); 1178 page_end = page_start | 0x00003FFF; 1179 } 1180 1181 /* Only process sections in range. */ 1182 if ((BASEADDR (sec) + sec->size >= page_start) 1183 && (BASEADDR (sec) <= page_end)) 1184 { 1185 if (!ip2k_elf_relax_section_page (abfd, sec, &changed, &misc, page_start, page_end)) 1186 return FALSE; 1187 } 1188 *again = TRUE; 1189 } 1190 1191 /* Perform some house keeping after relaxing the section. */ 1192 1193 if (isymbuf != NULL 1194 && symtab_hdr->contents != (unsigned char *) isymbuf) 1195 { 1196 if (! link_info->keep_memory) 1197 free (isymbuf); 1198 else 1199 symtab_hdr->contents = (unsigned char *) isymbuf; 1200 } 1201 1202 if (contents != NULL 1203 && elf_section_data (sec)->this_hdr.contents != contents) 1204 { 1205 if (! link_info->keep_memory) 1206 free (contents); 1207 else 1208 { 1209 /* Cache the section contents for elf_link_input_bfd. */ 1210 elf_section_data (sec)->this_hdr.contents = contents; 1211 } 1212 } 1213 1214 if (internal_relocs != NULL 1215 && elf_section_data (sec)->relocs != internal_relocs) 1216 free (internal_relocs); 1217 1218 return TRUE; 1219 1220 error_return: 1221 if (isymbuf != NULL 1222 && symtab_hdr->contents != (unsigned char *) isymbuf) 1223 free (isymbuf); 1224 if (contents != NULL 1225 && elf_section_data (sec)->this_hdr.contents != contents) 1226 free (contents); 1227 if (internal_relocs != NULL 1228 && elf_section_data (sec)->relocs != internal_relocs) 1229 free (internal_relocs); 1230 return FALSE; 1231 } 1232 1233 /* Set the howto pointer for a IP2K ELF reloc. */ 1234 1235 static void 1236 ip2k_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED, 1237 arelent * cache_ptr, 1238 Elf_Internal_Rela * dst) 1239 { 1240 unsigned int r_type; 1241 1242 r_type = ELF32_R_TYPE (dst->r_info); 1243 cache_ptr->howto = & ip2k_elf_howto_table [r_type]; 1244 } 1245 1246 /* Perform a single relocation. 1247 By default we use the standard BFD routines. */ 1248 1249 static bfd_reloc_status_type 1250 ip2k_final_link_relocate (reloc_howto_type * howto, 1251 bfd * input_bfd, 1252 asection * input_section, 1253 bfd_byte * contents, 1254 Elf_Internal_Rela * rel, 1255 bfd_vma relocation) 1256 { 1257 static bfd_vma page_addr = 0; 1258 1259 bfd_reloc_status_type r = bfd_reloc_ok; 1260 switch (howto->type) 1261 { 1262 /* Handle data space relocations. */ 1263 case R_IP2K_FR9: 1264 case R_IP2K_BANK: 1265 if ((relocation & IP2K_DATA_MASK) == IP2K_DATA_VALUE) 1266 relocation &= ~IP2K_DATA_MASK; 1267 else 1268 r = bfd_reloc_notsupported; 1269 break; 1270 1271 case R_IP2K_LO8DATA: 1272 case R_IP2K_HI8DATA: 1273 case R_IP2K_EX8DATA: 1274 break; 1275 1276 /* Handle insn space relocations. */ 1277 case R_IP2K_PAGE3: 1278 page_addr = BASEADDR (input_section) + rel->r_offset; 1279 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE) 1280 relocation &= ~IP2K_INSN_MASK; 1281 else 1282 r = bfd_reloc_notsupported; 1283 break; 1284 1285 case R_IP2K_ADDR16CJP: 1286 if (BASEADDR (input_section) + rel->r_offset != page_addr + 2) 1287 { 1288 /* No preceding page instruction, verify that it isn't needed. */ 1289 if (PAGENO (relocation + rel->r_addend) != 1290 ip2k_nominal_page_bits (input_bfd, input_section, 1291 rel->r_offset, contents)) 1292 _bfd_error_handler (_("ip2k linker: missing page instruction at 0x%08lx (dest = 0x%08lx)."), 1293 BASEADDR (input_section) + rel->r_offset, 1294 relocation + rel->r_addend); 1295 } 1296 else if (ip2k_relaxed) 1297 { 1298 /* Preceding page instruction. Verify that the page instruction is 1299 really needed. One reason for the relaxation to miss a page is if 1300 the section is not marked as executable. */ 1301 if (!ip2k_is_switch_table_128 (input_bfd, input_section, 1302 rel->r_offset - 2, contents) 1303 && !ip2k_is_switch_table_256 (input_bfd, input_section, 1304 rel->r_offset - 2, contents) 1305 && (PAGENO (relocation + rel->r_addend) == 1306 ip2k_nominal_page_bits (input_bfd, input_section, 1307 rel->r_offset - 2, contents))) 1308 _bfd_error_handler (_("ip2k linker: redundant page instruction at 0x%08lx (dest = 0x%08lx)."), 1309 page_addr, 1310 relocation + rel->r_addend); 1311 } 1312 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE) 1313 relocation &= ~IP2K_INSN_MASK; 1314 else 1315 r = bfd_reloc_notsupported; 1316 break; 1317 1318 case R_IP2K_LO8INSN: 1319 case R_IP2K_HI8INSN: 1320 case R_IP2K_PC_SKIP: 1321 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE) 1322 relocation &= ~IP2K_INSN_MASK; 1323 else 1324 r = bfd_reloc_notsupported; 1325 break; 1326 1327 case R_IP2K_16: 1328 /* If this is a relocation involving a TEXT 1329 symbol, reduce it to a word address. */ 1330 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE) 1331 howto = &ip2k_elf_howto_table[ (int) R_IP2K_TEXT]; 1332 break; 1333 1334 /* Pass others through. */ 1335 default: 1336 break; 1337 } 1338 1339 /* Only install relocation if above tests did not disqualify it. */ 1340 if (r == bfd_reloc_ok) 1341 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1342 contents, rel->r_offset, 1343 relocation, rel->r_addend); 1344 1345 return r; 1346 } 1347 1348 /* Relocate a IP2K ELF section. 1349 1350 The RELOCATE_SECTION function is called by the new ELF backend linker 1351 to handle the relocations for a section. 1352 1353 The relocs are always passed as Rela structures; if the section 1354 actually uses Rel structures, the r_addend field will always be 1355 zero. 1356 1357 This function is responsible for adjusting the section contents as 1358 necessary, and (if using Rela relocs and generating a relocatable 1359 output file) adjusting the reloc addend as necessary. 1360 1361 This function does not have to worry about setting the reloc 1362 address or the reloc symbol index. 1363 1364 LOCAL_SYMS is a pointer to the swapped in local symbols. 1365 1366 LOCAL_SECTIONS is an array giving the section in the input file 1367 corresponding to the st_shndx field of each local symbol. 1368 1369 The global hash table entry for the global symbols can be found 1370 via elf_sym_hashes (input_bfd). 1371 1372 When generating relocatable output, this function must handle 1373 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 1374 going to be the section symbol corresponding to the output 1375 section, which means that the addend must be adjusted 1376 accordingly. */ 1377 1378 static bfd_boolean 1379 ip2k_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, 1380 struct bfd_link_info *info, 1381 bfd *input_bfd, 1382 asection *input_section, 1383 bfd_byte *contents, 1384 Elf_Internal_Rela *relocs, 1385 Elf_Internal_Sym *local_syms, 1386 asection **local_sections) 1387 { 1388 Elf_Internal_Shdr *symtab_hdr; 1389 struct elf_link_hash_entry **sym_hashes; 1390 Elf_Internal_Rela *rel; 1391 Elf_Internal_Rela *relend; 1392 1393 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 1394 sym_hashes = elf_sym_hashes (input_bfd); 1395 relend = relocs + input_section->reloc_count; 1396 1397 for (rel = relocs; rel < relend; rel ++) 1398 { 1399 reloc_howto_type * howto; 1400 unsigned long r_symndx; 1401 Elf_Internal_Sym * sym; 1402 asection * sec; 1403 struct elf_link_hash_entry * h; 1404 bfd_vma relocation; 1405 bfd_reloc_status_type r; 1406 const char * name = NULL; 1407 int r_type; 1408 1409 r_type = ELF32_R_TYPE (rel->r_info); 1410 r_symndx = ELF32_R_SYM (rel->r_info); 1411 howto = ip2k_elf_howto_table + r_type; 1412 h = NULL; 1413 sym = NULL; 1414 sec = NULL; 1415 1416 if (r_symndx < symtab_hdr->sh_info) 1417 { 1418 sym = local_syms + r_symndx; 1419 sec = local_sections [r_symndx]; 1420 relocation = BASEADDR (sec) + sym->st_value; 1421 1422 name = bfd_elf_string_from_elf_section 1423 (input_bfd, symtab_hdr->sh_link, sym->st_name); 1424 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; 1425 } 1426 else 1427 { 1428 bfd_boolean warned, ignored; 1429 bfd_boolean unresolved_reloc; 1430 1431 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1432 r_symndx, symtab_hdr, sym_hashes, 1433 h, sec, relocation, 1434 unresolved_reloc, warned, ignored); 1435 1436 name = h->root.root.string; 1437 } 1438 1439 if (sec != NULL && discarded_section (sec)) 1440 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 1441 rel, 1, relend, howto, 0, contents); 1442 1443 if (info->relocatable) 1444 continue; 1445 1446 /* Finally, the sole IP2K-specific part. */ 1447 r = ip2k_final_link_relocate (howto, input_bfd, input_section, 1448 contents, rel, relocation); 1449 1450 if (r != bfd_reloc_ok) 1451 { 1452 const char * msg = NULL; 1453 1454 switch (r) 1455 { 1456 case bfd_reloc_overflow: 1457 r = info->callbacks->reloc_overflow 1458 (info, (h ? &h->root : NULL), name, howto->name, 1459 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 1460 break; 1461 1462 case bfd_reloc_undefined: 1463 r = info->callbacks->undefined_symbol 1464 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 1465 break; 1466 1467 case bfd_reloc_outofrange: 1468 msg = _("internal error: out of range error"); 1469 break; 1470 1471 /* This is how ip2k_final_link_relocate tells us of a non-kosher 1472 reference between insn & data address spaces. */ 1473 case bfd_reloc_notsupported: 1474 if (sym != NULL) /* Only if it's not an unresolved symbol. */ 1475 msg = _("unsupported relocation between data/insn address spaces"); 1476 break; 1477 1478 case bfd_reloc_dangerous: 1479 msg = _("internal error: dangerous relocation"); 1480 break; 1481 1482 default: 1483 msg = _("internal error: unknown error"); 1484 break; 1485 } 1486 1487 if (msg) 1488 r = info->callbacks->warning 1489 (info, msg, name, input_bfd, input_section, rel->r_offset); 1490 1491 if (! r) 1492 return FALSE; 1493 } 1494 } 1495 1496 return TRUE; 1497 } 1498 1499 #define TARGET_BIG_SYM bfd_elf32_ip2k_vec 1500 #define TARGET_BIG_NAME "elf32-ip2k" 1501 1502 #define ELF_ARCH bfd_arch_ip2k 1503 #define ELF_MACHINE_CODE EM_IP2K 1504 #define ELF_MACHINE_ALT1 EM_IP2K_OLD 1505 #define ELF_MAXPAGESIZE 1 /* No pages on the IP2K. */ 1506 1507 #define elf_info_to_howto_rel NULL 1508 #define elf_info_to_howto ip2k_info_to_howto_rela 1509 1510 #define elf_backend_can_gc_sections 1 1511 #define elf_backend_rela_normal 1 1512 #define elf_backend_relocate_section ip2k_elf_relocate_section 1513 1514 #define elf_symbol_leading_char '_' 1515 #define bfd_elf32_bfd_reloc_type_lookup ip2k_reloc_type_lookup 1516 #define bfd_elf32_bfd_reloc_name_lookup ip2k_reloc_name_lookup 1517 #define bfd_elf32_bfd_relax_section ip2k_elf_relax_section 1518 1519 #include "elf32-target.h" 1520