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