elf32-m32r.c revision 1.1.1.8
1 /* M32R-specific support for 32-bit ELF. 2 Copyright (C) 1996-2020 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 3 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., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libbfd.h" 24 #include "elf-bfd.h" 25 #include "elf/m32r.h" 26 27 #define NOP_INSN 0x7000 28 #define MAKE_PARALLEL(insn) ((insn) | 0x8000) 29 30 /* Use REL instead of RELA to save space. 31 This only saves space in libraries and object files, but perhaps 32 relocs will be put in ROM? All in all though, REL relocs are a pain 33 to work with. */ 34 /* #define USE_REL 1 35 36 #ifndef USE_REL 37 #define USE_REL 0 38 #endif */ 39 /* Use RELA. But use REL to link old objects for backwords compatibility. */ 40 41 /* Functions for the M32R ELF linker. */ 42 43 /* The name of the dynamic interpreter. This is put in the .interp 44 section. */ 45 46 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" 47 48 /* The nop opcode we use. */ 49 50 #define M32R_NOP 0x7000f000 51 52 #define PLT_EMPTY 0x10101010 /* RIE -> RIE */ 53 54 /* The size in bytes of an entry in the procedure linkage table. */ 55 56 #define PLT_ENTRY_SIZE 20 57 #define PLT_HEADER_SIZE 20 58 59 /* The first one entries in a procedure linkage table are reserved, 60 and the initial contents are unimportant (we zero them out). 61 Subsequent entries look like this. */ 62 63 #define PLT0_ENTRY_WORD0 0xd6c00000 /* seth r6, #high(.got+4) */ 64 #define PLT0_ENTRY_WORD1 0x86e60000 /* or3 r6, r6, #low(.got)+4) */ 65 #define PLT0_ENTRY_WORD2 0x24e626c6 /* ld r4, @r6+ -> ld r6, @r6 */ 66 #define PLT0_ENTRY_WORD3 0x1fc6f000 /* jmp r6 || pnop */ 67 #define PLT0_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */ 68 69 #define PLT0_PIC_ENTRY_WORD0 0xa4cc0004 /* ld r4, @(4,r12) */ 70 #define PLT0_PIC_ENTRY_WORD1 0xa6cc0008 /* ld r6, @(8,r12) */ 71 #define PLT0_PIC_ENTRY_WORD2 0x1fc6f000 /* jmp r6 || nop */ 72 #define PLT0_PIC_ENTRY_WORD3 PLT_EMPTY /* RIE -> RIE */ 73 #define PLT0_PIC_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */ 74 75 #define PLT_ENTRY_WORD0 0xe6000000 /* ld24 r6, .name_in_GOT */ 76 #define PLT_ENTRY_WORD1 0x06acf000 /* add r6, r12 || nop */ 77 #define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT) */ 78 #define PLT_ENTRY_WORD1b 0x86e60000 /* or3 r6, r6, #low(.name_in_GOT) */ 79 #define PLT_ENTRY_WORD2 0x26c61fc6 /* ld r6, @r6 -> jmp r6 */ 80 #define PLT_ENTRY_WORD3 0xe5000000 /* ld24 r5, $offset */ 81 #define PLT_ENTRY_WORD4 0xff000000 /* bra .plt0. */ 82 83 84 /* Utility to actually perform an R_M32R_10_PCREL reloc. */ 85 86 static bfd_reloc_status_type 87 m32r_elf_do_10_pcrel_reloc (bfd *abfd, 88 reloc_howto_type *howto, 89 asection *input_section, 90 bfd_byte *data, 91 bfd_vma offset, 92 asection *symbol_section ATTRIBUTE_UNUSED, 93 bfd_vma symbol_value, 94 bfd_vma addend) 95 { 96 bfd_signed_vma relocation; 97 unsigned long x; 98 bfd_reloc_status_type status; 99 100 /* Sanity check the address (offset in section). */ 101 if (offset > bfd_get_section_limit (abfd, input_section)) 102 return bfd_reloc_outofrange; 103 104 relocation = symbol_value + addend; 105 /* Make it pc relative. */ 106 relocation -= (input_section->output_section->vma 107 + input_section->output_offset); 108 /* These jumps mask off the lower two bits of the current address 109 before doing pcrel calculations. */ 110 relocation -= (offset & -(bfd_vma) 4); 111 112 if (relocation < -0x200 || relocation > 0x1ff) 113 status = bfd_reloc_overflow; 114 else 115 status = bfd_reloc_ok; 116 117 x = bfd_get_16 (abfd, data + offset); 118 relocation >>= howto->rightshift; 119 relocation <<= howto->bitpos; 120 x = (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask); 121 bfd_put_16 (abfd, (bfd_vma) x, data + offset); 122 123 return status; 124 } 125 126 /* Handle the R_M32R_10_PCREL reloc. */ 127 128 static bfd_reloc_status_type 129 m32r_elf_10_pcrel_reloc (bfd * abfd, 130 arelent * reloc_entry, 131 asymbol * symbol, 132 void * data, 133 asection * input_section, 134 bfd * output_bfd, 135 char ** error_message ATTRIBUTE_UNUSED) 136 { 137 /* This part is from bfd_elf_generic_reloc. */ 138 if (output_bfd != NULL 139 && (symbol->flags & BSF_SECTION_SYM) == 0 140 && (! reloc_entry->howto->partial_inplace 141 || reloc_entry->addend == 0)) 142 { 143 reloc_entry->address += input_section->output_offset; 144 return bfd_reloc_ok; 145 } 146 147 if (output_bfd != NULL) 148 /* FIXME: See bfd_perform_relocation. Is this right? */ 149 return bfd_reloc_continue; 150 151 return m32r_elf_do_10_pcrel_reloc (abfd, reloc_entry->howto, 152 input_section, 153 data, reloc_entry->address, 154 symbol->section, 155 (symbol->value 156 + symbol->section->output_section->vma 157 + symbol->section->output_offset), 158 reloc_entry->addend); 159 } 160 161 /* Do generic partial_inplace relocation. 162 This is a local replacement for bfd_elf_generic_reloc. */ 163 164 static bfd_reloc_status_type 165 m32r_elf_generic_reloc (bfd *input_bfd, 166 arelent *reloc_entry, 167 asymbol *symbol, 168 void * data, 169 asection *input_section, 170 bfd *output_bfd, 171 char **error_message ATTRIBUTE_UNUSED) 172 { 173 bfd_reloc_status_type ret; 174 bfd_vma relocation; 175 bfd_byte *inplace_address; 176 177 /* This part is from bfd_elf_generic_reloc. 178 If we're relocating, and this an external symbol, we don't want 179 to change anything. */ 180 if (output_bfd != NULL 181 && (symbol->flags & BSF_SECTION_SYM) == 0 182 && reloc_entry->addend == 0) 183 { 184 reloc_entry->address += input_section->output_offset; 185 return bfd_reloc_ok; 186 } 187 188 /* Now do the reloc in the usual way. 189 ??? It would be nice to call bfd_elf_generic_reloc here, 190 but we have partial_inplace set. bfd_elf_generic_reloc will 191 pass the handling back to bfd_install_relocation which will install 192 a section relative addend which is wrong. */ 193 194 /* Sanity check the address (offset in section). */ 195 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section)) 196 return bfd_reloc_outofrange; 197 198 ret = bfd_reloc_ok; 199 if (bfd_is_und_section (symbol->section) 200 && output_bfd == NULL) 201 ret = bfd_reloc_undefined; 202 203 if (bfd_is_com_section (symbol->section) 204 || output_bfd != NULL) 205 relocation = 0; 206 else 207 relocation = symbol->value; 208 209 /* Only do this for a final link. */ 210 if (output_bfd == NULL) 211 { 212 relocation += symbol->section->output_section->vma; 213 relocation += symbol->section->output_offset; 214 } 215 216 relocation += reloc_entry->addend; 217 inplace_address = (bfd_byte *) data + reloc_entry->address; 218 219 #define DOIT(x) \ 220 x = ( (x & ~reloc_entry->howto->dst_mask) | \ 221 (((x & reloc_entry->howto->src_mask) + relocation) & \ 222 reloc_entry->howto->dst_mask)) 223 224 switch (reloc_entry->howto->size) 225 { 226 case 1: 227 { 228 short x = bfd_get_16 (input_bfd, inplace_address); 229 DOIT (x); 230 bfd_put_16 (input_bfd, (bfd_vma) x, inplace_address); 231 } 232 break; 233 case 2: 234 { 235 unsigned long x = bfd_get_32 (input_bfd, inplace_address); 236 DOIT (x); 237 bfd_put_32 (input_bfd, (bfd_vma)x , inplace_address); 238 } 239 break; 240 default: 241 BFD_ASSERT (0); 242 } 243 244 if (output_bfd != NULL) 245 reloc_entry->address += input_section->output_offset; 246 247 return ret; 248 } 249 250 /* Handle the R_M32R_SDA16 reloc. 251 This reloc is used to compute the address of objects in the small data area 252 and to perform loads and stores from that area. 253 The lower 16 bits are sign extended and added to the register specified 254 in the instruction, which is assumed to point to _SDA_BASE_. */ 255 256 static bfd_reloc_status_type 257 m32r_elf_sda16_reloc (bfd *abfd ATTRIBUTE_UNUSED, 258 arelent *reloc_entry, 259 asymbol *symbol, 260 void * data ATTRIBUTE_UNUSED, 261 asection *input_section, 262 bfd *output_bfd, 263 char **error_message ATTRIBUTE_UNUSED) 264 { 265 /* This part is from bfd_elf_generic_reloc. */ 266 if (output_bfd != NULL 267 && (symbol->flags & BSF_SECTION_SYM) == 0 268 && (! reloc_entry->howto->partial_inplace 269 || reloc_entry->addend == 0)) 270 { 271 reloc_entry->address += input_section->output_offset; 272 return bfd_reloc_ok; 273 } 274 275 if (output_bfd != NULL) 276 /* FIXME: See bfd_perform_relocation. Is this right? */ 277 return bfd_reloc_continue; 278 279 /* FIXME: not sure what to do here yet. But then again, the linker 280 may never call us. */ 281 abort (); 282 } 283 284 285 /* Handle the R_M32R_HI16_[SU]LO relocs. 287 HI16_SLO is for the add3 and load/store with displacement instructions. 288 HI16_ULO is for the or3 instruction. 289 For R_M32R_HI16_SLO, the lower 16 bits are sign extended when added to 290 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then 291 we must add one to the high 16 bytes (which will get subtracted off when 292 the low 16 bits are added). 293 These relocs have to be done in combination with an R_M32R_LO16 reloc 294 because there is a carry from the LO16 to the HI16. Here we just save 295 the information we need; we do the actual relocation when we see the LO16. 296 This code is copied from the elf32-mips.c. We also support an arbitrary 297 number of HI16 relocs to be associated with a single LO16 reloc. The 298 assembler sorts the relocs to ensure each HI16 immediately precedes its 299 LO16. However if there are multiple copies, the assembler may not find 300 the real LO16 so it picks the first one it finds. */ 301 302 struct m32r_hi16 303 { 304 struct m32r_hi16 *next; 305 bfd_byte *addr; 306 bfd_vma addend; 307 }; 308 309 /* FIXME: This should not be a static variable. */ 310 311 static struct m32r_hi16 *m32r_hi16_list; 312 313 static bfd_reloc_status_type 314 m32r_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, 315 arelent *reloc_entry, 316 asymbol *symbol, 317 void * data, 318 asection *input_section, 319 bfd *output_bfd, 320 char **error_message ATTRIBUTE_UNUSED) 321 { 322 bfd_reloc_status_type ret; 323 bfd_vma relocation; 324 struct m32r_hi16 *n; 325 326 /* This part is from bfd_elf_generic_reloc. 327 If we're relocating, and this an external symbol, we don't want 328 to change anything. */ 329 if (output_bfd != NULL 330 && (symbol->flags & BSF_SECTION_SYM) == 0 331 && reloc_entry->addend == 0) 332 { 333 reloc_entry->address += input_section->output_offset; 334 return bfd_reloc_ok; 335 } 336 337 /* Sanity check the address (offset in section). */ 338 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 339 return bfd_reloc_outofrange; 340 341 ret = bfd_reloc_ok; 342 if (bfd_is_und_section (symbol->section) 343 && output_bfd == NULL) 344 ret = bfd_reloc_undefined; 345 346 if (bfd_is_com_section (symbol->section)) 347 relocation = 0; 348 else 349 relocation = symbol->value; 350 351 relocation += symbol->section->output_section->vma; 352 relocation += symbol->section->output_offset; 353 relocation += reloc_entry->addend; 354 355 /* Save the information, and let LO16 do the actual relocation. */ 356 n = bfd_malloc ((bfd_size_type) sizeof *n); 357 if (n == NULL) 358 return bfd_reloc_outofrange; 359 n->addr = (bfd_byte *) data + reloc_entry->address; 360 n->addend = relocation; 361 n->next = m32r_hi16_list; 362 m32r_hi16_list = n; 363 364 if (output_bfd != NULL) 365 reloc_entry->address += input_section->output_offset; 366 367 return ret; 368 } 369 370 /* Handle an M32R ELF HI16 reloc. */ 371 372 static void 373 m32r_elf_relocate_hi16 (bfd *input_bfd, 374 int type, 375 Elf_Internal_Rela *relhi, 376 Elf_Internal_Rela *rello, 377 bfd_byte *contents, 378 bfd_vma addend) 379 { 380 unsigned long insn; 381 bfd_vma addlo; 382 383 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); 384 385 addlo = bfd_get_32 (input_bfd, contents + rello->r_offset); 386 if (type == R_M32R_HI16_SLO) 387 addlo = ((addlo & 0xffff) ^ 0x8000) - 0x8000; 388 else 389 addlo &= 0xffff; 390 391 addend += ((insn & 0xffff) << 16) + addlo; 392 393 /* Reaccount for sign extension of low part. */ 394 if (type == R_M32R_HI16_SLO 395 && (addend & 0x8000) != 0) 396 addend += 0x10000; 397 398 bfd_put_32 (input_bfd, 399 (insn & 0xffff0000) | ((addend >> 16) & 0xffff), 400 contents + relhi->r_offset); 401 } 402 403 /* Do an R_M32R_LO16 relocation. This is a straightforward 16 bit 404 inplace relocation; this function exists in order to do the 405 R_M32R_HI16_[SU]LO relocation described above. */ 406 407 static bfd_reloc_status_type 408 m32r_elf_lo16_reloc (bfd *input_bfd, 409 arelent *reloc_entry, 410 asymbol *symbol, 411 void * data, 412 asection *input_section, 413 bfd *output_bfd, 414 char **error_message) 415 { 416 /* This part is from bfd_elf_generic_reloc. 417 If we're relocating, and this an external symbol, we don't want 418 to change anything. */ 419 if (output_bfd != NULL 420 && (symbol->flags & BSF_SECTION_SYM) == 0 421 && reloc_entry->addend == 0) 422 { 423 reloc_entry->address += input_section->output_offset; 424 return bfd_reloc_ok; 425 } 426 427 if (m32r_hi16_list != NULL) 428 { 429 struct m32r_hi16 *l; 430 431 l = m32r_hi16_list; 432 while (l != NULL) 433 { 434 unsigned long insn; 435 unsigned long val; 436 unsigned long vallo; 437 struct m32r_hi16 *next; 438 439 /* Do the HI16 relocation. Note that we actually don't need 440 to know anything about the LO16 itself, except where to 441 find the low 16 bits of the addend needed by the LO16. */ 442 insn = bfd_get_32 (input_bfd, l->addr); 443 vallo = ((bfd_get_32 (input_bfd, (bfd_byte *) data + reloc_entry->address) 444 & 0xffff) ^ 0x8000) - 0x8000; 445 val = ((insn & 0xffff) << 16) + vallo; 446 val += l->addend; 447 448 /* Reaccount for sign extension of low part. */ 449 if ((val & 0x8000) != 0) 450 val += 0x10000; 451 452 insn = (insn &~ (bfd_vma) 0xffff) | ((val >> 16) & 0xffff); 453 bfd_put_32 (input_bfd, (bfd_vma) insn, l->addr); 454 455 next = l->next; 456 free (l); 457 l = next; 458 } 459 460 m32r_hi16_list = NULL; 461 } 462 463 /* Now do the LO16 reloc in the usual way. 464 ??? It would be nice to call bfd_elf_generic_reloc here, 465 but we have partial_inplace set. bfd_elf_generic_reloc will 466 pass the handling back to bfd_install_relocation which will install 467 a section relative addend which is wrong. */ 468 return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data, 469 input_section, output_bfd, error_message); 470 } 471 472 473 static reloc_howto_type m32r_elf_howto_table[] = 475 { 476 /* This reloc does nothing. */ 477 HOWTO (R_M32R_NONE, /* type */ 478 0, /* rightshift */ 479 3, /* size (0 = byte, 1 = short, 2 = long) */ 480 0, /* bitsize */ 481 FALSE, /* pc_relative */ 482 0, /* bitpos */ 483 complain_overflow_dont, /* complain_on_overflow */ 484 bfd_elf_generic_reloc, /* special_function */ 485 "R_M32R_NONE", /* name */ 486 FALSE, /* partial_inplace */ 487 0, /* src_mask */ 488 0, /* dst_mask */ 489 FALSE), /* pcrel_offset */ 490 491 /* A 16 bit absolute relocation. */ 492 HOWTO (R_M32R_16, /* type */ 493 0, /* rightshift */ 494 1, /* size (0 = byte, 1 = short, 2 = long) */ 495 16, /* bitsize */ 496 FALSE, /* pc_relative */ 497 0, /* bitpos */ 498 complain_overflow_bitfield, /* complain_on_overflow */ 499 m32r_elf_generic_reloc,/* special_function */ 500 "R_M32R_16", /* name */ 501 TRUE, /* partial_inplace */ 502 0xffff, /* src_mask */ 503 0xffff, /* dst_mask */ 504 FALSE), /* pcrel_offset */ 505 506 /* A 32 bit absolute relocation. */ 507 HOWTO (R_M32R_32, /* type */ 508 0, /* rightshift */ 509 2, /* size (0 = byte, 1 = short, 2 = long) */ 510 32, /* bitsize */ 511 FALSE, /* pc_relative */ 512 0, /* bitpos */ 513 complain_overflow_bitfield, /* complain_on_overflow */ 514 m32r_elf_generic_reloc,/* special_function */ 515 "R_M32R_32", /* name */ 516 TRUE, /* partial_inplace */ 517 0xffffffff, /* src_mask */ 518 0xffffffff, /* dst_mask */ 519 FALSE), /* pcrel_offset */ 520 521 /* A 24 bit address. */ 522 HOWTO (R_M32R_24, /* type */ 523 0, /* rightshift */ 524 2, /* size (0 = byte, 1 = short, 2 = long) */ 525 24, /* bitsize */ 526 FALSE, /* pc_relative */ 527 0, /* bitpos */ 528 complain_overflow_unsigned, /* complain_on_overflow */ 529 m32r_elf_generic_reloc,/* special_function */ 530 "R_M32R_24", /* name */ 531 TRUE, /* partial_inplace */ 532 0xffffff, /* src_mask */ 533 0xffffff, /* dst_mask */ 534 FALSE), /* pcrel_offset */ 535 536 /* An PC Relative 10-bit relocation, shifted by 2. 537 This reloc is complicated because relocations are relative to pc & -4. 538 i.e. branches in the right insn slot use the address of the left insn 539 slot for pc. */ 540 /* ??? It's not clear whether this should have partial_inplace set or not. 541 Branch relaxing in the assembler can store the addend in the insn, 542 and if bfd_install_relocation gets called the addend may get added 543 again. */ 544 HOWTO (R_M32R_10_PCREL, /* type */ 545 2, /* rightshift */ 546 1, /* size (0 = byte, 1 = short, 2 = long) */ 547 10, /* bitsize */ 548 TRUE, /* pc_relative */ 549 0, /* bitpos */ 550 complain_overflow_signed, /* complain_on_overflow */ 551 m32r_elf_10_pcrel_reloc, /* special_function */ 552 "R_M32R_10_PCREL", /* name */ 553 FALSE, /* partial_inplace */ 554 0xff, /* src_mask */ 555 0xff, /* dst_mask */ 556 TRUE), /* pcrel_offset */ 557 558 /* A relative 18 bit relocation, right shifted by 2. */ 559 HOWTO (R_M32R_18_PCREL, /* type */ 560 2, /* rightshift */ 561 2, /* size (0 = byte, 1 = short, 2 = long) */ 562 16, /* bitsize */ 563 TRUE, /* pc_relative */ 564 0, /* bitpos */ 565 complain_overflow_signed, /* complain_on_overflow */ 566 bfd_elf_generic_reloc, /* special_function */ 567 "R_M32R_18_PCREL", /* name */ 568 FALSE, /* partial_inplace */ 569 0xffff, /* src_mask */ 570 0xffff, /* dst_mask */ 571 TRUE), /* pcrel_offset */ 572 573 /* A relative 26 bit relocation, right shifted by 2. */ 574 /* ??? It's not clear whether this should have partial_inplace set or not. 575 Branch relaxing in the assembler can store the addend in the insn, 576 and if bfd_install_relocation gets called the addend may get added 577 again. */ 578 HOWTO (R_M32R_26_PCREL, /* type */ 579 2, /* rightshift */ 580 2, /* size (0 = byte, 1 = short, 2 = long) */ 581 26, /* bitsize */ 582 TRUE, /* pc_relative */ 583 0, /* bitpos */ 584 complain_overflow_signed, /* complain_on_overflow */ 585 bfd_elf_generic_reloc, /* special_function */ 586 "R_M32R_26_PCREL", /* name */ 587 FALSE, /* partial_inplace */ 588 0xffffff, /* src_mask */ 589 0xffffff, /* dst_mask */ 590 TRUE), /* pcrel_offset */ 591 592 /* High 16 bits of address when lower 16 is or'd in. */ 593 HOWTO (R_M32R_HI16_ULO, /* type */ 594 16, /* rightshift */ 595 2, /* size (0 = byte, 1 = short, 2 = long) */ 596 16, /* bitsize */ 597 FALSE, /* pc_relative */ 598 0, /* bitpos */ 599 complain_overflow_dont, /* complain_on_overflow */ 600 m32r_elf_hi16_reloc, /* special_function */ 601 "R_M32R_HI16_ULO", /* name */ 602 TRUE, /* partial_inplace */ 603 0x0000ffff, /* src_mask */ 604 0x0000ffff, /* dst_mask */ 605 FALSE), /* pcrel_offset */ 606 607 /* High 16 bits of address when lower 16 is added in. */ 608 HOWTO (R_M32R_HI16_SLO, /* type */ 609 16, /* rightshift */ 610 2, /* size (0 = byte, 1 = short, 2 = long) */ 611 16, /* bitsize */ 612 FALSE, /* pc_relative */ 613 0, /* bitpos */ 614 complain_overflow_dont, /* complain_on_overflow */ 615 m32r_elf_hi16_reloc, /* special_function */ 616 "R_M32R_HI16_SLO", /* name */ 617 TRUE, /* partial_inplace */ 618 0x0000ffff, /* src_mask */ 619 0x0000ffff, /* dst_mask */ 620 FALSE), /* pcrel_offset */ 621 622 /* Lower 16 bits of address. */ 623 HOWTO (R_M32R_LO16, /* type */ 624 0, /* rightshift */ 625 2, /* size (0 = byte, 1 = short, 2 = long) */ 626 16, /* bitsize */ 627 FALSE, /* pc_relative */ 628 0, /* bitpos */ 629 complain_overflow_dont, /* complain_on_overflow */ 630 m32r_elf_lo16_reloc, /* special_function */ 631 "R_M32R_LO16", /* name */ 632 TRUE, /* partial_inplace */ 633 0x0000ffff, /* src_mask */ 634 0x0000ffff, /* dst_mask */ 635 FALSE), /* pcrel_offset */ 636 637 /* Small data area 16 bits offset. */ 638 HOWTO (R_M32R_SDA16, /* type */ 639 0, /* rightshift */ 640 2, /* size (0 = byte, 1 = short, 2 = long) */ 641 16, /* bitsize */ 642 FALSE, /* pc_relative */ 643 0, /* bitpos */ 644 complain_overflow_signed, /* complain_on_overflow */ 645 m32r_elf_sda16_reloc, /* special_function */ 646 "R_M32R_SDA16", /* name */ 647 TRUE, /* partial_inplace */ /* FIXME: correct? */ 648 0x0000ffff, /* src_mask */ 649 0x0000ffff, /* dst_mask */ 650 FALSE), /* pcrel_offset */ 651 652 /* GNU extension to record C++ vtable hierarchy. */ 653 HOWTO (R_M32R_GNU_VTINHERIT, /* type */ 654 0, /* rightshift */ 655 2, /* size (0 = byte, 1 = short, 2 = long) */ 656 0, /* bitsize */ 657 FALSE, /* pc_relative */ 658 0, /* bitpos */ 659 complain_overflow_dont, /* complain_on_overflow */ 660 NULL, /* special_function */ 661 "R_M32R_GNU_VTINHERIT", /* name */ 662 FALSE, /* partial_inplace */ 663 0, /* src_mask */ 664 0, /* dst_mask */ 665 FALSE), /* pcrel_offset */ 666 667 /* GNU extension to record C++ vtable member usage. */ 668 HOWTO (R_M32R_GNU_VTENTRY, /* type */ 669 0, /* rightshift */ 670 2, /* size (0 = byte, 1 = short, 2 = long) */ 671 0, /* bitsize */ 672 FALSE, /* pc_relative */ 673 0, /* bitpos */ 674 complain_overflow_dont, /* complain_on_overflow */ 675 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 676 "R_M32R_GNU_VTENTRY", /* name */ 677 FALSE, /* partial_inplace */ 678 0, /* src_mask */ 679 0, /* dst_mask */ 680 FALSE), /* pcrel_offset */ 681 682 EMPTY_HOWTO (13), 683 EMPTY_HOWTO (14), 684 EMPTY_HOWTO (15), 685 EMPTY_HOWTO (16), 686 EMPTY_HOWTO (17), 687 EMPTY_HOWTO (18), 688 EMPTY_HOWTO (19), 689 EMPTY_HOWTO (20), 690 EMPTY_HOWTO (21), 691 EMPTY_HOWTO (22), 692 EMPTY_HOWTO (23), 693 EMPTY_HOWTO (24), 694 EMPTY_HOWTO (25), 695 EMPTY_HOWTO (26), 696 EMPTY_HOWTO (27), 697 EMPTY_HOWTO (28), 698 EMPTY_HOWTO (29), 699 EMPTY_HOWTO (30), 700 EMPTY_HOWTO (31), 701 EMPTY_HOWTO (32), 702 703 /* A 16 bit absolute relocation. */ 704 HOWTO (R_M32R_16_RELA, /* type */ 705 0, /* rightshift */ 706 1, /* size (0 = byte, 1 = short, 2 = long) */ 707 16, /* bitsize */ 708 FALSE, /* pc_relative */ 709 0, /* bitpos */ 710 complain_overflow_bitfield, /* complain_on_overflow */ 711 bfd_elf_generic_reloc, /* special_function */ 712 "R_M32R_16_RELA", /* name */ 713 FALSE, /* partial_inplace */ 714 0xffff, /* src_mask */ 715 0xffff, /* dst_mask */ 716 FALSE), /* pcrel_offset */ 717 718 /* A 32 bit absolute relocation. */ 719 HOWTO (R_M32R_32_RELA, /* type */ 720 0, /* rightshift */ 721 2, /* size (0 = byte, 1 = short, 2 = long) */ 722 32, /* bitsize */ 723 FALSE, /* pc_relative */ 724 0, /* bitpos */ 725 complain_overflow_bitfield, /* complain_on_overflow */ 726 bfd_elf_generic_reloc,/* special_function */ 727 "R_M32R_32_RELA", /* name */ 728 FALSE, /* partial_inplace */ 729 0xffffffff, /* src_mask */ 730 0xffffffff, /* dst_mask */ 731 FALSE), /* pcrel_offset */ 732 733 /* A 24 bit address. */ 734 HOWTO (R_M32R_24_RELA, /* type */ 735 0, /* rightshift */ 736 2, /* size (0 = byte, 1 = short, 2 = long) */ 737 24, /* bitsize */ 738 FALSE, /* pc_relative */ 739 0, /* bitpos */ 740 complain_overflow_unsigned, /* complain_on_overflow */ 741 bfd_elf_generic_reloc,/* special_function */ 742 "R_M32R_24_RELA", /* name */ 743 FALSE, /* partial_inplace */ 744 0xffffff, /* src_mask */ 745 0xffffff, /* dst_mask */ 746 FALSE), /* pcrel_offset */ 747 748 HOWTO (R_M32R_10_PCREL_RELA, /* type */ 749 2, /* rightshift */ 750 1, /* size (0 = byte, 1 = short, 2 = long) */ 751 10, /* bitsize */ 752 TRUE, /* pc_relative */ 753 0, /* bitpos */ 754 complain_overflow_signed, /* complain_on_overflow */ 755 m32r_elf_10_pcrel_reloc, /* special_function */ 756 "R_M32R_10_PCREL_RELA",/* name */ 757 FALSE, /* partial_inplace */ 758 0xff, /* src_mask */ 759 0xff, /* dst_mask */ 760 TRUE), /* pcrel_offset */ 761 762 /* A relative 18 bit relocation, right shifted by 2. */ 763 HOWTO (R_M32R_18_PCREL_RELA, /* type */ 764 2, /* rightshift */ 765 2, /* size (0 = byte, 1 = short, 2 = long) */ 766 16, /* bitsize */ 767 TRUE, /* pc_relative */ 768 0, /* bitpos */ 769 complain_overflow_signed, /* complain_on_overflow */ 770 bfd_elf_generic_reloc, /* special_function */ 771 "R_M32R_18_PCREL_RELA",/* name */ 772 FALSE, /* partial_inplace */ 773 0xffff, /* src_mask */ 774 0xffff, /* dst_mask */ 775 TRUE), /* pcrel_offset */ 776 777 /* A relative 26 bit relocation, right shifted by 2. */ 778 HOWTO (R_M32R_26_PCREL_RELA, /* type */ 779 2, /* rightshift */ 780 2, /* size (0 = byte, 1 = short, 2 = long) */ 781 26, /* bitsize */ 782 TRUE, /* pc_relative */ 783 0, /* bitpos */ 784 complain_overflow_signed, /* complain_on_overflow */ 785 bfd_elf_generic_reloc, /* special_function */ 786 "R_M32R_26_PCREL_RELA",/* name */ 787 FALSE, /* partial_inplace */ 788 0xffffff, /* src_mask */ 789 0xffffff, /* dst_mask */ 790 TRUE), /* pcrel_offset */ 791 792 /* High 16 bits of address when lower 16 is or'd in. */ 793 HOWTO (R_M32R_HI16_ULO_RELA, /* type */ 794 16, /* rightshift */ 795 2, /* size (0 = byte, 1 = short, 2 = long) */ 796 16, /* bitsize */ 797 FALSE, /* pc_relative */ 798 0, /* bitpos */ 799 complain_overflow_dont, /* complain_on_overflow */ 800 bfd_elf_generic_reloc, /* special_function */ 801 "R_M32R_HI16_ULO_RELA",/* name */ 802 FALSE, /* partial_inplace */ 803 0x0000ffff, /* src_mask */ 804 0x0000ffff, /* dst_mask */ 805 FALSE), /* pcrel_offset */ 806 807 /* High 16 bits of address when lower 16 is added in. */ 808 HOWTO (R_M32R_HI16_SLO_RELA, /* type */ 809 16, /* rightshift */ 810 2, /* size (0 = byte, 1 = short, 2 = long) */ 811 16, /* bitsize */ 812 FALSE, /* pc_relative */ 813 0, /* bitpos */ 814 complain_overflow_dont, /* complain_on_overflow */ 815 bfd_elf_generic_reloc, /* special_function */ 816 "R_M32R_HI16_SLO_RELA",/* name */ 817 FALSE, /* partial_inplace */ 818 0x0000ffff, /* src_mask */ 819 0x0000ffff, /* dst_mask */ 820 FALSE), /* pcrel_offset */ 821 822 /* Lower 16 bits of address. */ 823 HOWTO (R_M32R_LO16_RELA, /* type */ 824 0, /* rightshift */ 825 2, /* size (0 = byte, 1 = short, 2 = long) */ 826 16, /* bitsize */ 827 FALSE, /* pc_relative */ 828 0, /* bitpos */ 829 complain_overflow_dont, /* complain_on_overflow */ 830 bfd_elf_generic_reloc, /* special_function */ 831 "R_M32R_LO16_RELA", /* name */ 832 FALSE, /* partial_inplace */ 833 0x0000ffff, /* src_mask */ 834 0x0000ffff, /* dst_mask */ 835 FALSE), /* pcrel_offset */ 836 837 /* Small data area 16 bits offset. */ 838 HOWTO (R_M32R_SDA16_RELA, /* type */ 839 0, /* rightshift */ 840 2, /* size (0 = byte, 1 = short, 2 = long) */ 841 16, /* bitsize */ 842 FALSE, /* pc_relative */ 843 0, /* bitpos */ 844 complain_overflow_signed, /* complain_on_overflow */ 845 bfd_elf_generic_reloc, /* special_function */ 846 "R_M32R_SDA16_RELA", /* name */ 847 TRUE, /* partial_inplace */ /* FIXME: correct? */ 848 0x0000ffff, /* src_mask */ 849 0x0000ffff, /* dst_mask */ 850 FALSE), /* pcrel_offset */ 851 852 /* GNU extension to record C++ vtable hierarchy. */ 853 HOWTO (R_M32R_RELA_GNU_VTINHERIT, /* type */ 854 0, /* rightshift */ 855 2, /* size (0 = byte, 1 = short, 2 = long) */ 856 0, /* bitsize */ 857 FALSE, /* pc_relative */ 858 0, /* bitpos */ 859 complain_overflow_dont, /* complain_on_overflow */ 860 NULL, /* special_function */ 861 "R_M32R_RELA_GNU_VTINHERIT", /* name */ 862 FALSE, /* partial_inplace */ 863 0, /* src_mask */ 864 0, /* dst_mask */ 865 FALSE), /* pcrel_offset */ 866 867 /* GNU extension to record C++ vtable member usage. */ 868 HOWTO (R_M32R_RELA_GNU_VTENTRY, /* type */ 869 0, /* rightshift */ 870 2, /* size (0 = byte, 1 = short, 2 = long) */ 871 0, /* bitsize */ 872 FALSE, /* pc_relative */ 873 0, /* bitpos */ 874 complain_overflow_dont, /* complain_on_overflow */ 875 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 876 "R_M32R_RELA_GNU_VTENTRY", /* name */ 877 FALSE, /* partial_inplace */ 878 0, /* src_mask */ 879 0, /* dst_mask */ 880 FALSE), /* pcrel_offset */ 881 882 /* A 32 bit PC relative relocation. */ 883 HOWTO (R_M32R_REL32, /* type */ 884 0, /* rightshift */ 885 2, /* size (0 = byte, 1 = short, 2 = long) */ 886 32, /* bitsize */ 887 TRUE, /* pc_relative */ 888 0, /* bitpos */ 889 complain_overflow_bitfield, /* complain_on_overflow */ 890 bfd_elf_generic_reloc,/* special_function */ 891 "R_M32R_REL32", /* name */ 892 FALSE, /* partial_inplace */ 893 0xffffffff, /* src_mask */ 894 0xffffffff, /* dst_mask */ 895 TRUE), /* pcrel_offset */ 896 897 EMPTY_HOWTO (46), 898 EMPTY_HOWTO (47), 899 900 /* Like R_M32R_24, but referring to the GOT table entry for 901 the symbol. */ 902 HOWTO (R_M32R_GOT24, /* type */ 903 0, /* rightshift */ 904 2, /* size (0 = byte, 1 = short, 2 = long) */ 905 24, /* bitsize */ 906 FALSE, /* pc_relative */ 907 0, /* bitpos */ 908 complain_overflow_unsigned, /* complain_on_overflow */ 909 bfd_elf_generic_reloc, /* special_function */ 910 "R_M32R_GOT24", /* name */ 911 FALSE, /* partial_inplace */ 912 0xffffff, /* src_mask */ 913 0xffffff, /* dst_mask */ 914 FALSE), /* pcrel_offset */ 915 916 /* Like R_M32R_PCREL, but referring to the procedure linkage table 917 entry for the symbol. */ 918 HOWTO (R_M32R_26_PLTREL, /* type */ 919 2, /* rightshift */ 920 2, /* size (0 = byte, 1 = short, 2 = long) */ 921 24, /* bitsize */ 922 TRUE, /* pc_relative */ 923 0, /* bitpos */ 924 complain_overflow_signed, /* complain_on_overflow */ 925 bfd_elf_generic_reloc, /* special_function */ 926 "R_M32R_26_PLTREL", /* name */ 927 FALSE, /* partial_inplace */ 928 0xffffff, /* src_mask */ 929 0xffffff, /* dst_mask */ 930 TRUE), /* pcrel_offset */ 931 932 /* This is used only by the dynamic linker. The symbol should exist 933 both in the object being run and in some shared library. The 934 dynamic linker copies the data addressed by the symbol from the 935 shared library into the object, because the object being 936 run has to have the data at some particular address. */ 937 HOWTO (R_M32R_COPY, /* type */ 938 0, /* rightshift */ 939 2, /* size (0 = byte, 1 = short, 2 = long) */ 940 32, /* bitsize */ 941 FALSE, /* pc_relative */ 942 0, /* bitpos */ 943 complain_overflow_bitfield, /* complain_on_overflow */ 944 bfd_elf_generic_reloc, /* special_function */ 945 "R_M32R_COPY", /* name */ 946 FALSE, /* partial_inplace */ 947 0xffffffff, /* src_mask */ 948 0xffffffff, /* dst_mask */ 949 FALSE), /* pcrel_offset */ 950 951 /* Like R_M32R_24, but used when setting global offset table 952 entries. */ 953 HOWTO (R_M32R_GLOB_DAT, /* type */ 954 0, /* rightshift */ 955 2, /* size (0 = byte, 1 = short, 2 = long) */ 956 32, /* bitsize */ 957 FALSE, /* pc_relative */ 958 0, /* bitpos */ 959 complain_overflow_bitfield, /* complain_on_overflow */ 960 bfd_elf_generic_reloc, /* special_function */ 961 "R_M32R_GLOB_DAT", /* name */ 962 FALSE, /* partial_inplace */ 963 0xffffffff, /* src_mask */ 964 0xffffffff, /* dst_mask */ 965 FALSE), /* pcrel_offset */ 966 967 /* Marks a procedure linkage table entry for a symbol. */ 968 HOWTO (R_M32R_JMP_SLOT, /* type */ 969 0, /* rightshift */ 970 2, /* size (0 = byte, 1 = short, 2 = long) */ 971 32, /* bitsize */ 972 FALSE, /* pc_relative */ 973 0, /* bitpos */ 974 complain_overflow_bitfield, /* complain_on_overflow */ 975 bfd_elf_generic_reloc, /* special_function */ 976 "R_M32R_JMP_SLOT", /* name */ 977 FALSE, /* partial_inplace */ 978 0xffffffff, /* src_mask */ 979 0xffffffff, /* dst_mask */ 980 FALSE), /* pcrel_offset */ 981 982 /* Used only by the dynamic linker. When the object is run, this 983 longword is set to the load address of the object, plus the 984 addend. */ 985 HOWTO (R_M32R_RELATIVE, /* type */ 986 0, /* rightshift */ 987 2, /* size (0 = byte, 1 = short, 2 = long) */ 988 32, /* bitsize */ 989 FALSE, /* pc_relative */ 990 0, /* bitpos */ 991 complain_overflow_bitfield, /* complain_on_overflow */ 992 bfd_elf_generic_reloc, /* special_function */ 993 "R_M32R_RELATIVE", /* name */ 994 FALSE, /* partial_inplace */ 995 0xffffffff, /* src_mask */ 996 0xffffffff, /* dst_mask */ 997 FALSE), /* pcrel_offset */ 998 999 HOWTO (R_M32R_GOTOFF, /* type */ 1000 0, /* rightshift */ 1001 2, /* size (0 = byte, 1 = short, 2 = long) */ 1002 24, /* bitsize */ 1003 FALSE, /* pc_relative */ 1004 0, /* bitpos */ 1005 complain_overflow_bitfield, /* complain_on_overflow */ 1006 bfd_elf_generic_reloc, /* special_function */ 1007 "R_M32R_GOTOFF", /* name */ 1008 FALSE, /* partial_inplace */ 1009 0xffffff, /* src_mask */ 1010 0xffffff, /* dst_mask */ 1011 FALSE), /* pcrel_offset */ 1012 1013 /* An PC Relative 24-bit relocation used when setting PIC offset 1014 table register. */ 1015 HOWTO (R_M32R_GOTPC24, /* type */ 1016 0, /* rightshift */ 1017 2, /* size (0 = byte, 1 = short, 2 = long) */ 1018 24, /* bitsize */ 1019 TRUE, /* pc_relative */ 1020 0, /* bitpos */ 1021 complain_overflow_unsigned, /* complain_on_overflow */ 1022 bfd_elf_generic_reloc, /* special_function */ 1023 "R_M32R_GOTPC24", /* name */ 1024 FALSE, /* partial_inplace */ 1025 0xffffff, /* src_mask */ 1026 0xffffff, /* dst_mask */ 1027 TRUE), /* pcrel_offset */ 1028 1029 /* Like R_M32R_HI16_ULO, but referring to the GOT table entry for 1030 the symbol. */ 1031 HOWTO (R_M32R_GOT16_HI_ULO, /* type */ 1032 16, /* rightshift */ 1033 2, /* size (0 = byte, 1 = short, 2 = long) */ 1034 16, /* bitsize */ 1035 FALSE, /* pc_relative */ 1036 0, /* bitpos */ 1037 complain_overflow_dont, /* complain_on_overflow */ 1038 bfd_elf_generic_reloc, /* special_function */ 1039 "R_M32R_GOT16_HI_ULO", /* name */ 1040 FALSE, /* partial_inplace */ 1041 0x0000ffff, /* src_mask */ 1042 0x0000ffff, /* dst_mask */ 1043 FALSE), /* pcrel_offset */ 1044 1045 /* Like R_M32R_HI16_SLO, but referring to the GOT table entry for 1046 the symbol. */ 1047 HOWTO (R_M32R_GOT16_HI_SLO, /* type */ 1048 16, /* rightshift */ 1049 2, /* size (0 = byte, 1 = short, 2 = long) */ 1050 16, /* bitsize */ 1051 FALSE, /* pc_relative */ 1052 0, /* bitpos */ 1053 complain_overflow_dont, /* complain_on_overflow */ 1054 bfd_elf_generic_reloc, /* special_function */ 1055 "R_M32R_GOT16_HI_SLO", /* name */ 1056 FALSE, /* partial_inplace */ 1057 0x0000ffff, /* src_mask */ 1058 0x0000ffff, /* dst_mask */ 1059 FALSE), /* pcrel_offset */ 1060 1061 /* Like R_M32R_LO16, but referring to the GOT table entry for 1062 the symbol. */ 1063 HOWTO (R_M32R_GOT16_LO, /* type */ 1064 0, /* rightshift */ 1065 2, /* size (0 = byte, 1 = short, 2 = long) */ 1066 16, /* bitsize */ 1067 FALSE, /* pc_relative */ 1068 0, /* bitpos */ 1069 complain_overflow_dont, /* complain_on_overflow */ 1070 bfd_elf_generic_reloc, /* special_function */ 1071 "R_M32R_GOT16_LO", /* name */ 1072 FALSE, /* partial_inplace */ 1073 0x0000ffff, /* src_mask */ 1074 0x0000ffff, /* dst_mask */ 1075 FALSE), /* pcrel_offset */ 1076 1077 /* An PC Relative relocation used when setting PIC offset table register. 1078 Like R_M32R_HI16_ULO, but referring to the GOT table entry for 1079 the symbol. */ 1080 HOWTO (R_M32R_GOTPC_HI_ULO, /* type */ 1081 16, /* rightshift */ 1082 2, /* size (0 = byte, 1 = short, 2 = long) */ 1083 16, /* bitsize */ 1084 FALSE, /* pc_relative */ 1085 0, /* bitpos */ 1086 complain_overflow_dont, /* complain_on_overflow */ 1087 bfd_elf_generic_reloc, /* special_function */ 1088 "R_M32R_GOTPC_HI_ULO", /* name */ 1089 FALSE, /* partial_inplace */ 1090 0x0000ffff, /* src_mask */ 1091 0x0000ffff, /* dst_mask */ 1092 TRUE), /* pcrel_offset */ 1093 1094 /* An PC Relative relocation used when setting PIC offset table register. 1095 Like R_M32R_HI16_SLO, but referring to the GOT table entry for 1096 the symbol. */ 1097 HOWTO (R_M32R_GOTPC_HI_SLO, /* type */ 1098 16, /* rightshift */ 1099 2, /* size (0 = byte, 1 = short, 2 = long) */ 1100 16, /* bitsize */ 1101 FALSE, /* pc_relative */ 1102 0, /* bitpos */ 1103 complain_overflow_dont, /* complain_on_overflow */ 1104 bfd_elf_generic_reloc, /* special_function */ 1105 "R_M32R_GOTPC_HI_SLO", /* name */ 1106 FALSE, /* partial_inplace */ 1107 0x0000ffff, /* src_mask */ 1108 0x0000ffff, /* dst_mask */ 1109 TRUE), /* pcrel_offset */ 1110 1111 /* An PC Relative relocation used when setting PIC offset table register. 1112 Like R_M32R_LO16, but referring to the GOT table entry for 1113 the symbol. */ 1114 HOWTO (R_M32R_GOTPC_LO, /* type */ 1115 0, /* rightshift */ 1116 2, /* size (0 = byte, 1 = short, 2 = long) */ 1117 16, /* bitsize */ 1118 FALSE, /* pc_relative */ 1119 0, /* bitpos */ 1120 complain_overflow_dont, /* complain_on_overflow */ 1121 bfd_elf_generic_reloc, /* special_function */ 1122 "R_M32R_GOTPC_LO", /* name */ 1123 FALSE, /* partial_inplace */ 1124 0x0000ffff, /* src_mask */ 1125 0x0000ffff, /* dst_mask */ 1126 TRUE), /* pcrel_offset */ 1127 1128 HOWTO (R_M32R_GOTOFF_HI_ULO, /* type */ 1129 16, /* rightshift */ 1130 2, /* size (0 = byte, 1 = short, 2 = long) */ 1131 16, /* bitsize */ 1132 FALSE, /* pc_relative */ 1133 0, /* bitpos */ 1134 complain_overflow_dont, /* complain_on_overflow */ 1135 bfd_elf_generic_reloc, /* special_function */ 1136 "R_M32R_GOTOFF_HI_ULO",/* name */ 1137 FALSE, /* partial_inplace */ 1138 0x0000ffff, /* src_mask */ 1139 0x0000ffff, /* dst_mask */ 1140 FALSE), /* pcrel_offset */ 1141 1142 HOWTO (R_M32R_GOTOFF_HI_SLO, /* type */ 1143 16, /* rightshift */ 1144 2, /* size (0 = byte, 1 = short, 2 = long) */ 1145 16, /* bitsize */ 1146 FALSE, /* pc_relative */ 1147 0, /* bitpos */ 1148 complain_overflow_dont, /* complain_on_overflow */ 1149 bfd_elf_generic_reloc, /* special_function */ 1150 "R_M32R_GOTOFF_HI_SLO",/* name */ 1151 FALSE, /* partial_inplace */ 1152 0x0000ffff, /* src_mask */ 1153 0x0000ffff, /* dst_mask */ 1154 FALSE), /* pcrel_offset */ 1155 1156 HOWTO (R_M32R_GOTOFF_LO, /* type */ 1157 0, /* rightshift */ 1158 2, /* size (0 = byte, 1 = short, 2 = long) */ 1159 16, /* bitsize */ 1160 FALSE, /* pc_relative */ 1161 0, /* bitpos */ 1162 complain_overflow_dont, /* complain_on_overflow */ 1163 bfd_elf_generic_reloc, /* special_function */ 1164 "R_M32R_GOTOFF_LO", /* name */ 1165 FALSE, /* partial_inplace */ 1166 0x0000ffff, /* src_mask */ 1167 0x0000ffff, /* dst_mask */ 1168 FALSE), /* pcrel_offset */ 1169 }; 1170 1171 /* Map BFD reloc types to M32R ELF reloc types. */ 1172 1173 struct m32r_reloc_map 1174 { 1175 bfd_reloc_code_real_type bfd_reloc_val; 1176 unsigned char elf_reloc_val; 1177 }; 1178 1179 #ifdef USE_M32R_OLD_RELOC 1180 static const struct m32r_reloc_map m32r_reloc_map_old[] = 1181 { 1182 { BFD_RELOC_NONE, R_M32R_NONE }, 1183 { BFD_RELOC_16, R_M32R_16 }, 1184 { BFD_RELOC_32, R_M32R_32 }, 1185 { BFD_RELOC_M32R_24, R_M32R_24 }, 1186 { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL }, 1187 { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL }, 1188 { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL }, 1189 { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO }, 1190 { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO }, 1191 { BFD_RELOC_M32R_LO16, R_M32R_LO16 }, 1192 { BFD_RELOC_M32R_SDA16, R_M32R_SDA16 }, 1193 { BFD_RELOC_VTABLE_INHERIT, R_M32R_GNU_VTINHERIT }, 1194 { BFD_RELOC_VTABLE_ENTRY, R_M32R_GNU_VTENTRY }, 1195 }; 1196 #else 1197 static const struct m32r_reloc_map m32r_reloc_map[] = 1198 { 1199 { BFD_RELOC_NONE, R_M32R_NONE }, 1200 { BFD_RELOC_16, R_M32R_16_RELA }, 1201 { BFD_RELOC_32, R_M32R_32_RELA }, 1202 { BFD_RELOC_M32R_24, R_M32R_24_RELA }, 1203 { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL_RELA }, 1204 { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL_RELA }, 1205 { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL_RELA }, 1206 { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO_RELA }, 1207 { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO_RELA }, 1208 { BFD_RELOC_M32R_LO16, R_M32R_LO16_RELA }, 1209 { BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA }, 1210 { BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT }, 1211 { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY }, 1212 { BFD_RELOC_32_PCREL, R_M32R_REL32 }, 1213 1214 { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 }, 1215 { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL }, 1216 { BFD_RELOC_M32R_COPY, R_M32R_COPY }, 1217 { BFD_RELOC_M32R_GLOB_DAT, R_M32R_GLOB_DAT }, 1218 { BFD_RELOC_M32R_JMP_SLOT, R_M32R_JMP_SLOT }, 1219 { BFD_RELOC_M32R_RELATIVE, R_M32R_RELATIVE }, 1220 { BFD_RELOC_M32R_GOTOFF, R_M32R_GOTOFF }, 1221 { BFD_RELOC_M32R_GOTPC24, R_M32R_GOTPC24 }, 1222 { BFD_RELOC_M32R_GOT16_HI_ULO, R_M32R_GOT16_HI_ULO }, 1223 { BFD_RELOC_M32R_GOT16_HI_SLO, R_M32R_GOT16_HI_SLO }, 1224 { BFD_RELOC_M32R_GOT16_LO, R_M32R_GOT16_LO }, 1225 { BFD_RELOC_M32R_GOTPC_HI_ULO, R_M32R_GOTPC_HI_ULO }, 1226 { BFD_RELOC_M32R_GOTPC_HI_SLO, R_M32R_GOTPC_HI_SLO }, 1227 { BFD_RELOC_M32R_GOTPC_LO, R_M32R_GOTPC_LO }, 1228 { BFD_RELOC_M32R_GOTOFF_HI_ULO, R_M32R_GOTOFF_HI_ULO }, 1229 { BFD_RELOC_M32R_GOTOFF_HI_SLO, R_M32R_GOTOFF_HI_SLO }, 1230 { BFD_RELOC_M32R_GOTOFF_LO, R_M32R_GOTOFF_LO }, 1231 }; 1232 #endif 1233 1234 static reloc_howto_type * 1235 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1236 bfd_reloc_code_real_type code) 1237 { 1238 unsigned int i; 1239 1240 #ifdef USE_M32R_OLD_RELOC 1241 for (i = 0; 1242 i < sizeof (m32r_reloc_map_old) / sizeof (struct m32r_reloc_map); 1243 i++) 1244 if (m32r_reloc_map_old[i].bfd_reloc_val == code) 1245 return &m32r_elf_howto_table[m32r_reloc_map_old[i].elf_reloc_val]; 1246 1247 #else /* ! USE_M32R_OLD_RELOC */ 1248 1249 for (i = 0; 1250 i < sizeof (m32r_reloc_map) / sizeof (struct m32r_reloc_map); 1251 i++) 1252 if (m32r_reloc_map[i].bfd_reloc_val == code) 1253 return &m32r_elf_howto_table[m32r_reloc_map[i].elf_reloc_val]; 1254 #endif 1255 1256 return NULL; 1257 } 1258 1259 static reloc_howto_type * 1260 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1261 const char *r_name) 1262 { 1263 unsigned int i; 1264 1265 for (i = 0; 1266 i < sizeof (m32r_elf_howto_table) / sizeof (m32r_elf_howto_table[0]); 1267 i++) 1268 if (m32r_elf_howto_table[i].name != NULL 1269 && strcasecmp (m32r_elf_howto_table[i].name, r_name) == 0) 1270 return &m32r_elf_howto_table[i]; 1271 1272 return NULL; 1273 } 1274 1275 /* Set the howto pointer for an M32R ELF reloc. */ 1276 1277 static bfd_boolean 1278 m32r_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, 1279 arelent *cache_ptr, 1280 Elf_Internal_Rela *dst) 1281 { 1282 unsigned int r_type; 1283 1284 r_type = ELF32_R_TYPE (dst->r_info); 1285 if (r_type > (unsigned int) R_M32R_GNU_VTENTRY) 1286 { 1287 /* xgettext:c-format */ 1288 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 1289 abfd, r_type); 1290 bfd_set_error (bfd_error_bad_value); 1291 return FALSE; 1292 } 1293 cache_ptr->howto = &m32r_elf_howto_table[r_type]; 1294 return TRUE; 1295 } 1296 1297 static bfd_boolean 1298 m32r_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 1299 arelent *cache_ptr, 1300 Elf_Internal_Rela *dst) 1301 { 1302 unsigned int r_type = ELF32_R_TYPE (dst->r_info); 1303 1304 if (r_type == (unsigned int) R_M32R_NONE 1305 || ((r_type > (unsigned int) R_M32R_GNU_VTENTRY) 1306 && (r_type < (unsigned int) R_M32R_max))) 1307 { 1308 cache_ptr->howto = &m32r_elf_howto_table[r_type]; 1309 return TRUE; 1310 } 1311 1312 /* xgettext:c-format */ 1313 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, r_type); 1314 bfd_set_error (bfd_error_bad_value); 1315 return FALSE; 1316 } 1317 1318 1319 /* Given a BFD section, try to locate the corresponding ELF section 1321 index. */ 1322 1323 static bfd_boolean 1324 _bfd_m32r_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 1325 asection *sec, 1326 int *retval) 1327 { 1328 if (strcmp (bfd_section_name (sec), ".scommon") == 0) 1329 { 1330 *retval = SHN_M32R_SCOMMON; 1331 return TRUE; 1332 } 1333 return FALSE; 1334 } 1335 1336 /* M32R ELF uses two common sections. One is the usual one, and the other 1337 is for small objects. All the small objects are kept together, and then 1338 referenced via one register, which yields faster assembler code. It is 1339 up to the compiler to emit an instruction to load the register with 1340 _SDA_BASE. This is what we use for the small common section. This 1341 approach is copied from elf32-mips.c. */ 1342 static asection m32r_elf_scom_section; 1343 static asymbol m32r_elf_scom_symbol; 1344 static asymbol *m32r_elf_scom_symbol_ptr; 1345 1346 /* Handle the special M32R section numbers that a symbol may use. */ 1347 1348 static void 1349 _bfd_m32r_elf_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym) 1350 { 1351 elf_symbol_type *elfsym = (elf_symbol_type *) asym; 1352 1353 switch (elfsym->internal_elf_sym.st_shndx) 1354 { 1355 case SHN_M32R_SCOMMON: 1356 if (m32r_elf_scom_section.name == NULL) 1357 { 1358 /* Initialize the small common section. */ 1359 m32r_elf_scom_section.name = ".scommon"; 1360 m32r_elf_scom_section.flags = SEC_IS_COMMON; 1361 m32r_elf_scom_section.output_section = &m32r_elf_scom_section; 1362 m32r_elf_scom_section.symbol = &m32r_elf_scom_symbol; 1363 m32r_elf_scom_section.symbol_ptr_ptr = &m32r_elf_scom_symbol_ptr; 1364 m32r_elf_scom_symbol.name = ".scommon"; 1365 m32r_elf_scom_symbol.flags = BSF_SECTION_SYM; 1366 m32r_elf_scom_symbol.section = &m32r_elf_scom_section; 1367 m32r_elf_scom_symbol_ptr = &m32r_elf_scom_symbol; 1368 } 1369 asym->section = &m32r_elf_scom_section; 1370 asym->value = elfsym->internal_elf_sym.st_size; 1371 break; 1372 } 1373 } 1374 1375 /* Hook called by the linker routine which adds symbols from an object 1376 file. We must handle the special M32R section numbers here. 1377 We also keep watching for whether we need to create the sdata special 1378 linker sections. */ 1379 1380 static bfd_boolean 1381 m32r_elf_add_symbol_hook (bfd *abfd, 1382 struct bfd_link_info *info, 1383 Elf_Internal_Sym *sym, 1384 const char **namep, 1385 flagword *flagsp ATTRIBUTE_UNUSED, 1386 asection **secp, 1387 bfd_vma *valp) 1388 { 1389 if (! bfd_link_relocatable (info) 1390 && (*namep)[0] == '_' && (*namep)[1] == 'S' 1391 && strcmp (*namep, "_SDA_BASE_") == 0 1392 && is_elf_hash_table (info->hash)) 1393 { 1394 /* This is simpler than using _bfd_elf_create_linker_section 1395 (our needs are simpler than ppc's needs). Also 1396 _bfd_elf_create_linker_section currently has a bug where if a .sdata 1397 section already exists a new one is created that follows it which 1398 screws of _SDA_BASE_ address calcs because output_offset != 0. */ 1399 struct elf_link_hash_entry *h; 1400 struct bfd_link_hash_entry *bh; 1401 asection *s = bfd_get_section_by_name (abfd, ".sdata"); 1402 1403 /* The following code was cobbled from elf32-ppc.c and elflink.c. */ 1404 if (s == NULL) 1405 { 1406 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 1407 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 1408 1409 s = bfd_make_section_anyway_with_flags (abfd, ".sdata", 1410 flags); 1411 if (s == NULL) 1412 return FALSE; 1413 if (!bfd_set_section_alignment (s, 2)) 1414 return FALSE; 1415 } 1416 1417 bh = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", 1418 FALSE, FALSE, FALSE); 1419 1420 if ((bh == NULL || bh->type == bfd_link_hash_undefined) 1421 && !(_bfd_generic_link_add_one_symbol (info, 1422 abfd, 1423 "_SDA_BASE_", 1424 BSF_GLOBAL, 1425 s, 1426 (bfd_vma) 32768, 1427 NULL, 1428 FALSE, 1429 get_elf_backend_data (abfd)->collect, 1430 &bh))) 1431 return FALSE; 1432 h = (struct elf_link_hash_entry *) bh; 1433 h->type = STT_OBJECT; 1434 } 1435 1436 switch (sym->st_shndx) 1437 { 1438 case SHN_M32R_SCOMMON: 1439 *secp = bfd_make_section_old_way (abfd, ".scommon"); 1440 (*secp)->flags |= SEC_IS_COMMON; 1441 *valp = sym->st_size; 1442 break; 1443 } 1444 1445 return TRUE; 1446 } 1447 1448 /* We have to figure out the SDA_BASE value, so that we can adjust the 1449 symbol value correctly. We look up the symbol _SDA_BASE_ in the output 1450 BFD. If we can't find it, we're stuck. We cache it in the ELF 1451 target data. We don't need to adjust the symbol value for an 1452 external symbol if we are producing relocatable output. */ 1453 1454 static bfd_reloc_status_type 1455 m32r_elf_final_sda_base (bfd *output_bfd, 1456 struct bfd_link_info *info, 1457 const char **error_message, 1458 bfd_vma *psb) 1459 { 1460 if (elf_gp (output_bfd) == 0) 1461 { 1462 struct bfd_link_hash_entry *h; 1463 1464 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE); 1465 if (h != NULL && h->type == bfd_link_hash_defined) 1466 elf_gp (output_bfd) = (h->u.def.value 1467 + h->u.def.section->output_section->vma 1468 + h->u.def.section->output_offset); 1469 else 1470 { 1471 /* Only get the error once. */ 1472 *psb = elf_gp (output_bfd) = 4; 1473 *error_message = 1474 (const char *) _("SDA relocation when _SDA_BASE_ not defined"); 1475 return bfd_reloc_dangerous; 1476 } 1477 } 1478 *psb = elf_gp (output_bfd); 1479 return bfd_reloc_ok; 1480 } 1481 1482 /* Return size of a PLT entry. */ 1484 #define elf_m32r_sizeof_plt(info) PLT_ENTRY_SIZE 1485 1486 /* The m32r linker needs to keep track of the number of relocs that it 1487 decides to copy in check_relocs for each symbol. This is so that 1488 it can discard PC relative relocs if it doesn't need them when 1489 linking with -Bsymbolic. We store the information in a field 1490 extending the regular ELF linker hash table. */ 1491 1492 /* This structure keeps track of the number of PC relative relocs we 1493 have copied for a given symbol. */ 1494 1495 struct elf_m32r_pcrel_relocs_copied 1496 { 1497 /* Next section. */ 1498 struct elf_m32r_pcrel_relocs_copied *next; 1499 /* A section in dynobj. */ 1500 asection *section; 1501 /* Number of relocs copied in this section. */ 1502 bfd_size_type count; 1503 }; 1504 1505 /* m32r ELF linker hash entry. */ 1506 1507 struct elf_m32r_link_hash_entry 1508 { 1509 struct elf_link_hash_entry root; 1510 1511 /* Track dynamic relocs copied for this symbol. */ 1512 struct elf_dyn_relocs *dyn_relocs; 1513 }; 1514 1515 /* m32r ELF linker hash table. */ 1516 1517 struct elf_m32r_link_hash_table 1518 { 1519 struct elf_link_hash_table root; 1520 1521 /* Short-cuts to get to dynamic linker sections. */ 1522 asection *sdynbss; 1523 asection *srelbss; 1524 1525 /* Small local sym cache. */ 1526 struct sym_cache sym_cache; 1527 }; 1528 1529 /* Traverse an m32r ELF linker hash table. */ 1530 1531 #define m32r_elf_link_hash_traverse(table, func, info) \ 1532 (elf_link_hash_traverse \ 1533 (&(table)->root, \ 1534 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ 1535 (info))) 1536 1537 /* Get the m32r ELF linker hash table from a link_info structure. */ 1538 1539 #define m32r_elf_hash_table(p) \ 1540 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 1541 == M32R_ELF_DATA ? ((struct elf_m32r_link_hash_table *) ((p)->hash)) : NULL) 1542 1543 /* Create an entry in an m32r ELF linker hash table. */ 1544 1545 static struct bfd_hash_entry * 1546 m32r_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 1547 struct bfd_hash_table *table, 1548 const char *string) 1549 { 1550 struct elf_m32r_link_hash_entry *ret = 1551 (struct elf_m32r_link_hash_entry *) entry; 1552 1553 /* Allocate the structure if it has not already been allocated by a 1554 subclass. */ 1555 if (ret == NULL) 1556 ret = bfd_hash_allocate (table, 1557 sizeof (struct elf_m32r_link_hash_entry)); 1558 if (ret == NULL) 1559 return NULL; 1560 1561 /* Call the allocation method of the superclass. */ 1562 ret = ((struct elf_m32r_link_hash_entry *) 1563 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 1564 table, string)); 1565 if (ret != NULL) 1566 { 1567 struct elf_m32r_link_hash_entry *eh; 1568 1569 eh = (struct elf_m32r_link_hash_entry *) ret; 1570 eh->dyn_relocs = NULL; 1571 } 1572 1573 return (struct bfd_hash_entry *) ret; 1574 } 1575 1576 /* Create an m32r ELF linker hash table. */ 1577 1578 static struct bfd_link_hash_table * 1579 m32r_elf_link_hash_table_create (bfd *abfd) 1580 { 1581 struct elf_m32r_link_hash_table *ret; 1582 bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table); 1583 1584 ret = bfd_zmalloc (amt); 1585 if (ret == NULL) 1586 return NULL; 1587 1588 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 1589 m32r_elf_link_hash_newfunc, 1590 sizeof (struct elf_m32r_link_hash_entry), 1591 M32R_ELF_DATA)) 1592 { 1593 free (ret); 1594 return NULL; 1595 } 1596 1597 return &ret->root.root; 1598 } 1599 1600 /* Create dynamic sections when linking against a dynamic object. */ 1601 1602 static bfd_boolean 1603 m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 1604 { 1605 struct elf_m32r_link_hash_table *htab; 1606 flagword flags, pltflags; 1607 asection *s; 1608 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 1609 int ptralign = 2; /* 32bit */ 1610 1611 htab = m32r_elf_hash_table (info); 1612 if (htab == NULL) 1613 return FALSE; 1614 1615 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 1616 .rel[a].bss sections. */ 1617 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 1618 | SEC_LINKER_CREATED); 1619 1620 pltflags = flags; 1621 pltflags |= SEC_CODE; 1622 if (bed->plt_not_loaded) 1623 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS); 1624 if (bed->plt_readonly) 1625 pltflags |= SEC_READONLY; 1626 1627 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags); 1628 htab->root.splt = s; 1629 if (s == NULL 1630 || !bfd_set_section_alignment (s, bed->plt_alignment)) 1631 return FALSE; 1632 1633 if (bed->want_plt_sym) 1634 { 1635 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the 1636 .plt section. */ 1637 struct bfd_link_hash_entry *bh = NULL; 1638 struct elf_link_hash_entry *h; 1639 1640 if (! (_bfd_generic_link_add_one_symbol 1641 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 1642 (bfd_vma) 0, NULL, FALSE, 1643 get_elf_backend_data (abfd)->collect, &bh))) 1644 return FALSE; 1645 h = (struct elf_link_hash_entry *) bh; 1646 h->def_regular = 1; 1647 h->type = STT_OBJECT; 1648 htab->root.hplt = h; 1649 1650 if (bfd_link_pic (info) 1651 && ! bfd_elf_link_record_dynamic_symbol (info, h)) 1652 return FALSE; 1653 } 1654 1655 s = bfd_make_section_anyway_with_flags (abfd, 1656 bed->default_use_rela_p 1657 ? ".rela.plt" : ".rel.plt", 1658 flags | SEC_READONLY); 1659 htab->root.srelplt = s; 1660 if (s == NULL 1661 || !bfd_set_section_alignment (s, ptralign)) 1662 return FALSE; 1663 1664 if (htab->root.sgot == NULL 1665 && !_bfd_elf_create_got_section (abfd, info)) 1666 return FALSE; 1667 1668 if (bed->want_dynbss) 1669 { 1670 /* The .dynbss section is a place to put symbols which are defined 1671 by dynamic objects, are referenced by regular objects, and are 1672 not functions. We must allocate space for them in the process 1673 image and use a R_*_COPY reloc to tell the dynamic linker to 1674 initialize them at run time. The linker script puts the .dynbss 1675 section into the .bss section of the final image. */ 1676 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss", 1677 SEC_ALLOC | SEC_LINKER_CREATED); 1678 htab->sdynbss = s; 1679 if (s == NULL) 1680 return FALSE; 1681 /* The .rel[a].bss section holds copy relocs. This section is not 1682 normally needed. We need to create it here, though, so that the 1683 linker will map it to an output section. We can't just create it 1684 only if we need it, because we will not know whether we need it 1685 until we have seen all the input files, and the first time the 1686 main linker code calls BFD after examining all the input files 1687 (size_dynamic_sections) the input sections have already been 1688 mapped to the output sections. If the section turns out not to 1689 be needed, we can discard it later. We will never need this 1690 section when generating a shared object, since they do not use 1691 copy relocs. */ 1692 if (! bfd_link_pic (info)) 1693 { 1694 s = bfd_make_section_anyway_with_flags (abfd, 1695 (bed->default_use_rela_p 1696 ? ".rela.bss" : ".rel.bss"), 1697 flags | SEC_READONLY); 1698 htab->srelbss = s; 1699 if (s == NULL 1700 || !bfd_set_section_alignment (s, ptralign)) 1701 return FALSE; 1702 } 1703 } 1704 1705 return TRUE; 1706 } 1707 1708 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 1709 1710 static void 1711 m32r_elf_copy_indirect_symbol (struct bfd_link_info *info, 1712 struct elf_link_hash_entry *dir, 1713 struct elf_link_hash_entry *ind) 1714 { 1715 struct elf_m32r_link_hash_entry * edir; 1716 struct elf_m32r_link_hash_entry * eind; 1717 1718 edir = (struct elf_m32r_link_hash_entry *) dir; 1719 eind = (struct elf_m32r_link_hash_entry *) ind; 1720 1721 if (eind->dyn_relocs != NULL) 1722 { 1723 if (edir->dyn_relocs != NULL) 1724 { 1725 struct elf_dyn_relocs **pp; 1726 struct elf_dyn_relocs *p; 1727 1728 /* Add reloc counts against the indirect sym to the direct sym 1729 list. Merge any entries against the same section. */ 1730 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;) 1731 { 1732 struct elf_dyn_relocs *q; 1733 1734 for (q = edir->dyn_relocs; q != NULL; q = q->next) 1735 if (q->sec == p->sec) 1736 { 1737 q->pc_count += p->pc_count; 1738 q->count += p->count; 1739 *pp = p->next; 1740 break; 1741 } 1742 if (q == NULL) 1743 pp = &p->next; 1744 } 1745 *pp = edir->dyn_relocs; 1746 } 1747 1748 edir->dyn_relocs = eind->dyn_relocs; 1749 eind->dyn_relocs = NULL; 1750 } 1751 1752 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 1753 } 1754 1755 1756 /* Find dynamic relocs for H that apply to read-only sections. */ 1758 1759 static asection * 1760 readonly_dynrelocs (struct elf_link_hash_entry *h) 1761 { 1762 struct elf_dyn_relocs *p; 1763 struct elf_m32r_link_hash_entry *eh = (struct elf_m32r_link_hash_entry *) h; 1764 1765 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1766 { 1767 asection *s = p->sec->output_section; 1768 1769 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1770 return p->sec; 1771 } 1772 return NULL; 1773 } 1774 1775 /* Adjust a symbol defined by a dynamic object and referenced by a 1776 regular object. The current definition is in some section of the 1777 dynamic object, but we're not including those sections. We have to 1778 change the definition to something the rest of the link can 1779 understand. */ 1780 1781 static bfd_boolean 1782 m32r_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 1783 struct elf_link_hash_entry *h) 1784 { 1785 struct elf_m32r_link_hash_table *htab; 1786 bfd *dynobj; 1787 asection *s; 1788 1789 #ifdef DEBUG_PIC 1790 printf ("m32r_elf_adjust_dynamic_symbol()\n"); 1791 #endif 1792 1793 dynobj = elf_hash_table (info)->dynobj; 1794 1795 /* Make sure we know what is going on here. */ 1796 BFD_ASSERT (dynobj != NULL 1797 && (h->needs_plt 1798 || h->is_weakalias 1799 || (h->def_dynamic 1800 && h->ref_regular 1801 && !h->def_regular))); 1802 1803 /* If this is a function, put it in the procedure linkage table. We 1804 will fill in the contents of the procedure linkage table later, 1805 when we know the address of the .got section. */ 1806 if (h->type == STT_FUNC 1807 || h->needs_plt) 1808 { 1809 if (! bfd_link_pic (info) 1810 && !h->def_dynamic 1811 && !h->ref_dynamic 1812 && h->root.type != bfd_link_hash_undefweak 1813 && h->root.type != bfd_link_hash_undefined) 1814 { 1815 /* This case can occur if we saw a PLT reloc in an input 1816 file, but the symbol was never referred to by a dynamic 1817 object. In such a case, we don't actually need to build 1818 a procedure linkage table, and we can just do a PCREL 1819 reloc instead. */ 1820 h->plt.offset = (bfd_vma) -1; 1821 h->needs_plt = 0; 1822 } 1823 1824 return TRUE; 1825 } 1826 else 1827 h->plt.offset = (bfd_vma) -1; 1828 1829 /* If this is a weak symbol, and there is a real definition, the 1830 processor independent code will have arranged for us to see the 1831 real definition first, and we can just use the same value. */ 1832 if (h->is_weakalias) 1833 { 1834 struct elf_link_hash_entry *def = weakdef (h); 1835 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 1836 h->root.u.def.section = def->root.u.def.section; 1837 h->root.u.def.value = def->root.u.def.value; 1838 return TRUE; 1839 } 1840 1841 /* This is a reference to a symbol defined by a dynamic object which 1842 is not a function. */ 1843 1844 /* If we are creating a shared library, we must presume that the 1845 only references to the symbol are via the global offset table. 1846 For such cases we need not do anything here; the relocations will 1847 be handled correctly by relocate_section. */ 1848 if (bfd_link_pic (info)) 1849 return TRUE; 1850 1851 /* If there are no references to this symbol that do not use the 1852 GOT, we don't need to generate a copy reloc. */ 1853 if (!h->non_got_ref) 1854 return TRUE; 1855 1856 /* If -z nocopyreloc was given, we won't generate them either. */ 1857 if (0 && info->nocopyreloc) 1858 { 1859 h->non_got_ref = 0; 1860 return TRUE; 1861 } 1862 1863 /* If we don't find any dynamic relocs in read-only sections, then 1864 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 1865 if (0 && !readonly_dynrelocs (h)) 1866 { 1867 h->non_got_ref = 0; 1868 return TRUE; 1869 } 1870 1871 /* We must allocate the symbol in our .dynbss section, which will 1872 become part of the .bss section of the executable. There will be 1873 an entry for this symbol in the .dynsym section. The dynamic 1874 object will contain position independent code, so all references 1875 from the dynamic object to this symbol will go through the global 1876 offset table. The dynamic linker will use the .dynsym entry to 1877 determine the address it must put in the global offset table, so 1878 both the dynamic object and the regular object will refer to the 1879 same memory location for the variable. */ 1880 1881 htab = m32r_elf_hash_table (info); 1882 if (htab == NULL) 1883 return FALSE; 1884 1885 s = htab->sdynbss; 1886 BFD_ASSERT (s != NULL); 1887 1888 /* We must generate a R_M32R_COPY reloc to tell the dynamic linker 1889 to copy the initial value out of the dynamic object and into the 1890 runtime process image. We need to remember the offset into the 1891 .rela.bss section we are going to use. */ 1892 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 1893 { 1894 asection *srel; 1895 1896 srel = htab->srelbss; 1897 BFD_ASSERT (srel != NULL); 1898 srel->size += sizeof (Elf32_External_Rela); 1899 h->needs_copy = 1; 1900 } 1901 1902 return _bfd_elf_adjust_dynamic_copy (info, h, s); 1903 } 1904 1905 /* Allocate space in .plt, .got and associated reloc sections for 1906 dynamic relocs. */ 1907 1908 static bfd_boolean 1909 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) 1910 { 1911 struct bfd_link_info *info; 1912 struct elf_m32r_link_hash_table *htab; 1913 struct elf_m32r_link_hash_entry *eh; 1914 struct elf_dyn_relocs *p; 1915 1916 if (h->root.type == bfd_link_hash_indirect) 1917 return TRUE; 1918 1919 info = (struct bfd_link_info *) inf; 1920 htab = m32r_elf_hash_table (info); 1921 if (htab == NULL) 1922 return FALSE; 1923 1924 eh = (struct elf_m32r_link_hash_entry *) h; 1925 1926 if (htab->root.dynamic_sections_created 1927 && h->plt.refcount > 0) 1928 { 1929 /* Make sure this symbol is output as a dynamic symbol. 1930 Undefined weak syms won't yet be marked as dynamic. */ 1931 if (h->dynindx == -1 1932 && !h->forced_local) 1933 { 1934 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1935 return FALSE; 1936 } 1937 1938 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)) 1939 { 1940 asection *s = htab->root.splt; 1941 1942 /* If this is the first .plt entry, make room for the special 1943 first entry. */ 1944 if (s->size == 0) 1945 s->size += PLT_ENTRY_SIZE; 1946 1947 h->plt.offset = s->size; 1948 1949 /* If this symbol is not defined in a regular file, and we are 1950 not generating a shared library, then set the symbol to this 1951 location in the .plt. This is required to make function 1952 pointers compare as equal between the normal executable and 1953 the shared library. */ 1954 if (! bfd_link_pic (info) 1955 && !h->def_regular) 1956 { 1957 h->root.u.def.section = s; 1958 h->root.u.def.value = h->plt.offset; 1959 } 1960 1961 /* Make room for this entry. */ 1962 s->size += PLT_ENTRY_SIZE; 1963 1964 /* We also need to make an entry in the .got.plt section, which 1965 will be placed in the .got section by the linker script. */ 1966 htab->root.sgotplt->size += 4; 1967 1968 /* We also need to make an entry in the .rel.plt section. */ 1969 htab->root.srelplt->size += sizeof (Elf32_External_Rela); 1970 } 1971 else 1972 { 1973 h->plt.offset = (bfd_vma) -1; 1974 h->needs_plt = 0; 1975 } 1976 } 1977 else 1978 { 1979 h->plt.offset = (bfd_vma) -1; 1980 h->needs_plt = 0; 1981 } 1982 1983 if (h->got.refcount > 0) 1984 { 1985 asection *s; 1986 bfd_boolean dyn; 1987 1988 /* Make sure this symbol is output as a dynamic symbol. 1989 Undefined weak syms won't yet be marked as dynamic. */ 1990 if (h->dynindx == -1 1991 && !h->forced_local) 1992 { 1993 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1994 return FALSE; 1995 } 1996 1997 s = htab->root.sgot; 1998 1999 h->got.offset = s->size; 2000 s->size += 4; 2001 dyn = htab->root.dynamic_sections_created; 2002 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)) 2003 htab->root.srelgot->size += sizeof (Elf32_External_Rela); 2004 } 2005 else 2006 h->got.offset = (bfd_vma) -1; 2007 2008 if (eh->dyn_relocs == NULL) 2009 return TRUE; 2010 2011 /* In the shared -Bsymbolic case, discard space allocated for 2012 dynamic pc-relative relocs against symbols which turn out to be 2013 defined in regular objects. For the normal shared case, discard 2014 space for pc-relative relocs that have become local due to symbol 2015 visibility changes. */ 2016 2017 if (bfd_link_pic (info)) 2018 { 2019 if (h->def_regular 2020 && (h->forced_local 2021 || info->symbolic)) 2022 { 2023 struct elf_dyn_relocs **pp; 2024 2025 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;) 2026 { 2027 p->count -= p->pc_count; 2028 p->pc_count = 0; 2029 if (p->count == 0) 2030 *pp = p->next; 2031 else 2032 pp = &p->next; 2033 } 2034 } 2035 2036 /* Also discard relocs on undefined weak syms with non-default 2037 visibility. */ 2038 if (eh->dyn_relocs != NULL 2039 && h->root.type == bfd_link_hash_undefweak) 2040 { 2041 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 2042 eh->dyn_relocs = NULL; 2043 2044 /* Make sure undefined weak symbols are output as a dynamic 2045 symbol in PIEs. */ 2046 else if (h->dynindx == -1 2047 && !h->forced_local) 2048 { 2049 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2050 return FALSE; 2051 } 2052 } 2053 } 2054 else 2055 { 2056 /* For the non-shared case, discard space for relocs against 2057 symbols which turn out to need copy relocs or are not 2058 dynamic. */ 2059 2060 if (!h->non_got_ref 2061 && ((h->def_dynamic 2062 && !h->def_regular) 2063 || (htab->root.dynamic_sections_created 2064 && (h->root.type == bfd_link_hash_undefweak 2065 || h->root.type == bfd_link_hash_undefined)))) 2066 { 2067 /* Make sure this symbol is output as a dynamic symbol. 2068 Undefined weak syms won't yet be marked as dynamic. */ 2069 if (h->dynindx == -1 2070 && !h->forced_local) 2071 { 2072 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2073 return FALSE; 2074 } 2075 2076 /* If that succeeded, we know we'll be keeping all the 2077 relocs. */ 2078 if (h->dynindx != -1) 2079 goto keep; 2080 } 2081 2082 eh->dyn_relocs = NULL; 2083 2084 keep: ; 2085 } 2086 2087 /* Finally, allocate space. */ 2088 for (p = eh->dyn_relocs; p != NULL; p = p->next) 2089 { 2090 asection *sreloc = elf_section_data (p->sec)->sreloc; 2091 sreloc->size += p->count * sizeof (Elf32_External_Rela); 2092 } 2093 2094 return TRUE; 2095 } 2096 2097 /* Set DF_TEXTREL if we find any dynamic relocs that apply to 2098 read-only sections. */ 2099 2100 static bfd_boolean 2101 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p) 2102 { 2103 asection *sec; 2104 2105 if (h->root.type == bfd_link_hash_indirect) 2106 return TRUE; 2107 2108 sec = readonly_dynrelocs (h); 2109 if (sec != NULL) 2110 { 2111 struct bfd_link_info *info = (struct bfd_link_info *) info_p; 2112 2113 info->flags |= DF_TEXTREL; 2114 info->callbacks->minfo 2115 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"), 2116 sec->owner, h->root.root.string, sec); 2117 2118 /* Not an error, just cut short the traversal. */ 2119 return FALSE; 2120 } 2121 return TRUE; 2122 } 2123 2124 /* Set the sizes of the dynamic sections. */ 2125 2126 static bfd_boolean 2127 m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 2128 struct bfd_link_info *info) 2129 { 2130 struct elf_m32r_link_hash_table *htab; 2131 bfd *dynobj; 2132 asection *s; 2133 bfd_boolean relocs; 2134 bfd *ibfd; 2135 2136 #ifdef DEBUG_PIC 2137 printf ("m32r_elf_size_dynamic_sections()\n"); 2138 #endif 2139 2140 htab = m32r_elf_hash_table (info); 2141 if (htab == NULL) 2142 return FALSE; 2143 2144 dynobj = htab->root.dynobj; 2145 BFD_ASSERT (dynobj != NULL); 2146 2147 if (htab->root.dynamic_sections_created) 2148 { 2149 /* Set the contents of the .interp section to the interpreter. */ 2150 if (bfd_link_executable (info) && !info->nointerp) 2151 { 2152 s = bfd_get_linker_section (dynobj, ".interp"); 2153 BFD_ASSERT (s != NULL); 2154 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 2155 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 2156 } 2157 } 2158 2159 /* Set up .got offsets for local syms, and space for local dynamic 2160 relocs. */ 2161 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 2162 { 2163 bfd_signed_vma *local_got; 2164 bfd_signed_vma *end_local_got; 2165 bfd_size_type locsymcount; 2166 Elf_Internal_Shdr *symtab_hdr; 2167 asection *srel; 2168 2169 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 2170 continue; 2171 2172 for (s = ibfd->sections; s != NULL; s = s->next) 2173 { 2174 struct elf_dyn_relocs *p; 2175 2176 for (p = ((struct elf_dyn_relocs *) 2177 elf_section_data (s)->local_dynrel); 2178 p != NULL; 2179 p = p->next) 2180 { 2181 if (! bfd_is_abs_section (p->sec) 2182 && bfd_is_abs_section (p->sec->output_section)) 2183 { 2184 /* Input section has been discarded, either because 2185 it is a copy of a linkonce section or due to 2186 linker script /DISCARD/, so we'll be discarding 2187 the relocs too. */ 2188 } 2189 else if (p->count != 0) 2190 { 2191 srel = elf_section_data (p->sec)->sreloc; 2192 srel->size += p->count * sizeof (Elf32_External_Rela); 2193 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 2194 info->flags |= DF_TEXTREL; 2195 } 2196 } 2197 } 2198 2199 local_got = elf_local_got_refcounts (ibfd); 2200 if (!local_got) 2201 continue; 2202 2203 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 2204 locsymcount = symtab_hdr->sh_info; 2205 end_local_got = local_got + locsymcount; 2206 s = htab->root.sgot; 2207 srel = htab->root.srelgot; 2208 for (; local_got < end_local_got; ++local_got) 2209 { 2210 if (*local_got > 0) 2211 { 2212 *local_got = s->size; 2213 s->size += 4; 2214 if (bfd_link_pic (info)) 2215 srel->size += sizeof (Elf32_External_Rela); 2216 } 2217 else 2218 *local_got = (bfd_vma) -1; 2219 } 2220 } 2221 2222 /* Allocate global sym .plt and .got entries, and space for global 2223 sym dynamic relocs. */ 2224 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info); 2225 2226 /* We now have determined the sizes of the various dynamic sections. 2227 Allocate memory for them. */ 2228 relocs = FALSE; 2229 for (s = dynobj->sections; s != NULL; s = s->next) 2230 { 2231 if ((s->flags & SEC_LINKER_CREATED) == 0) 2232 continue; 2233 2234 if (s == htab->root.splt 2235 || s == htab->root.sgot 2236 || s == htab->root.sgotplt 2237 || s == htab->sdynbss) 2238 { 2239 /* Strip this section if we don't need it; see the 2240 comment below. */ 2241 } 2242 else if (CONST_STRNEQ (bfd_section_name (s), ".rela")) 2243 { 2244 if (s->size != 0 && s != htab->root.srelplt) 2245 relocs = TRUE; 2246 2247 /* We use the reloc_count field as a counter if we need 2248 to copy relocs into the output file. */ 2249 s->reloc_count = 0; 2250 } 2251 else 2252 /* It's not one of our sections, so don't allocate space. */ 2253 continue; 2254 2255 if (s->size == 0) 2256 { 2257 /* If we don't need this section, strip it from the 2258 output file. This is mostly to handle .rela.bss and 2259 .rela.plt. We must create both sections in 2260 create_dynamic_sections, because they must be created 2261 before the linker maps input sections to output 2262 sections. The linker does that before 2263 adjust_dynamic_symbol is called, and it is that 2264 function which decides whether anything needs to go 2265 into these sections. */ 2266 s->flags |= SEC_EXCLUDE; 2267 continue; 2268 } 2269 2270 if ((s->flags & SEC_HAS_CONTENTS) == 0) 2271 continue; 2272 2273 /* Allocate memory for the section contents. We use bfd_zalloc 2274 here in case unused entries are not reclaimed before the 2275 section's contents are written out. This should not happen, 2276 but this way if it does, we get a R_M32R_NONE reloc instead 2277 of garbage. */ 2278 s->contents = bfd_zalloc (dynobj, s->size); 2279 if (s->contents == NULL) 2280 return FALSE; 2281 } 2282 2283 if (htab->root.dynamic_sections_created) 2284 { 2285 /* Add some entries to the .dynamic section. We fill in the 2286 values later, in m32r_elf_finish_dynamic_sections, but we 2287 must add the entries now so that we get the correct size for 2288 the .dynamic section. The DT_DEBUG entry is filled in by the 2289 dynamic linker and used by the debugger. */ 2290 #define add_dynamic_entry(TAG, VAL) \ 2291 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 2292 2293 if (bfd_link_executable (info)) 2294 { 2295 if (! add_dynamic_entry (DT_DEBUG, 0)) 2296 return FALSE; 2297 } 2298 2299 if (htab->root.splt->size != 0) 2300 { 2301 if (! add_dynamic_entry (DT_PLTGOT, 0) 2302 || ! add_dynamic_entry (DT_PLTRELSZ, 0) 2303 || ! add_dynamic_entry (DT_PLTREL, DT_RELA) 2304 || ! add_dynamic_entry (DT_JMPREL, 0)) 2305 return FALSE; 2306 } 2307 2308 if (relocs) 2309 { 2310 if (! add_dynamic_entry (DT_RELA, 0) 2311 || ! add_dynamic_entry (DT_RELASZ, 0) 2312 || ! add_dynamic_entry (DT_RELAENT, 2313 sizeof (Elf32_External_Rela))) 2314 return FALSE; 2315 2316 /* If any dynamic relocs apply to a read-only section, 2317 then we need a DT_TEXTREL entry. */ 2318 if ((info->flags & DF_TEXTREL) == 0) 2319 elf_link_hash_traverse (&htab->root, maybe_set_textrel, info); 2320 2321 if ((info->flags & DF_TEXTREL) != 0) 2322 { 2323 if (! add_dynamic_entry (DT_TEXTREL, 0)) 2324 return FALSE; 2325 } 2326 } 2327 } 2328 #undef add_dynamic_entry 2329 2330 return TRUE; 2331 } 2332 2333 /* Relocate an M32R/D ELF section. 2334 There is some attempt to make this function usable for many architectures, 2335 both for RELA and REL type relocs, if only to serve as a learning tool. 2336 2337 The RELOCATE_SECTION function is called by the new ELF backend linker 2338 to handle the relocations for a section. 2339 2340 The relocs are always passed as Rela structures; if the section 2341 actually uses Rel structures, the r_addend field will always be 2342 zero. 2343 2344 This function is responsible for adjust the section contents as 2345 necessary, and (if using Rela relocs and generating a 2346 relocatable output file) adjusting the reloc addend as 2347 necessary. 2348 2349 This function does not have to worry about setting the reloc 2350 address or the reloc symbol index. 2351 2352 LOCAL_SYMS is a pointer to the swapped in local symbols. 2353 2354 LOCAL_SECTIONS is an array giving the section in the input file 2355 corresponding to the st_shndx field of each local symbol. 2356 2357 The global hash table entry for the global symbols can be found 2358 via elf_sym_hashes (input_bfd). 2359 2360 When generating relocatable output, this function must handle 2361 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 2362 going to be the section symbol corresponding to the output 2363 section, which means that the addend must be adjusted 2364 accordingly. */ 2365 2366 static bfd_boolean 2367 m32r_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, 2368 struct bfd_link_info *info, 2369 bfd *input_bfd, 2370 asection *input_section, 2371 bfd_byte *contents, 2372 Elf_Internal_Rela *relocs, 2373 Elf_Internal_Sym *local_syms, 2374 asection **local_sections) 2375 { 2376 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2377 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 2378 Elf_Internal_Rela *rel, *relend; 2379 /* Assume success. */ 2380 bfd_boolean ret = TRUE; 2381 struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info); 2382 bfd_vma *local_got_offsets; 2383 asection *sgot, *splt, *sreloc; 2384 bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section); 2385 2386 if (htab == NULL) 2387 return FALSE; 2388 2389 local_got_offsets = elf_local_got_offsets (input_bfd); 2390 2391 sgot = htab->root.sgot; 2392 splt = htab->root.splt; 2393 sreloc = NULL; 2394 2395 rel = relocs; 2396 relend = relocs + input_section->reloc_count; 2397 for (; rel < relend; rel++) 2398 { 2399 int r_type; 2400 reloc_howto_type *howto; 2401 unsigned long r_symndx; 2402 struct elf_link_hash_entry *h; 2403 /* We can't modify r_addend here as elf_link_input_bfd has an assert to 2404 ensure it's zero (we use REL relocs, not RELA). Therefore this 2405 should be assigning zero to `addend', but for clarity we use 2406 `r_addend'. */ 2407 bfd_vma addend = rel->r_addend; 2408 bfd_vma offset = rel->r_offset; 2409 bfd_vma relocation; 2410 Elf_Internal_Sym *sym; 2411 asection *sec; 2412 const char *sym_name; 2413 bfd_reloc_status_type r; 2414 const char *errmsg = NULL; 2415 bfd_boolean use_rel = FALSE; 2416 2417 h = NULL; 2418 r_type = ELF32_R_TYPE (rel->r_info); 2419 if (r_type < 0 || r_type >= (int) R_M32R_max) 2420 { 2421 /* xgettext:c-format */ 2422 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 2423 input_bfd, (int) r_type); 2424 bfd_set_error (bfd_error_bad_value); 2425 ret = FALSE; 2426 continue; 2427 } 2428 2429 if ( r_type == R_M32R_GNU_VTENTRY 2430 || r_type == R_M32R_GNU_VTINHERIT 2431 || r_type == R_M32R_NONE 2432 || r_type == R_M32R_RELA_GNU_VTENTRY 2433 || r_type == R_M32R_RELA_GNU_VTINHERIT) 2434 continue; 2435 2436 if (r_type <= R_M32R_GNU_VTENTRY) 2437 use_rel = TRUE; 2438 2439 howto = m32r_elf_howto_table + r_type; 2440 r_symndx = ELF32_R_SYM (rel->r_info); 2441 2442 sym = NULL; 2443 sec = NULL; 2444 h = NULL; 2445 2446 if (r_symndx < symtab_hdr->sh_info) 2447 { 2448 /* Local symbol. */ 2449 sym = local_syms + r_symndx; 2450 sec = local_sections[r_symndx]; 2451 sym_name = "<local symbol>"; 2452 2453 if (!use_rel) 2454 { 2455 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2456 addend = rel->r_addend; 2457 } 2458 else 2459 { 2460 relocation = (sec->output_section->vma 2461 + sec->output_offset 2462 + sym->st_value); 2463 } 2464 } 2465 else 2466 { 2467 /* External symbol. */ 2468 relocation = 0; 2469 2470 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2471 2472 if (info->wrap_hash != NULL 2473 && (input_section->flags & SEC_DEBUGGING) != 0) 2474 h = ((struct elf_link_hash_entry *) 2475 unwrap_hash_lookup (info, input_bfd, &h->root)); 2476 2477 while (h->root.type == bfd_link_hash_indirect 2478 || h->root.type == bfd_link_hash_warning) 2479 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2480 sym_name = h->root.root.string; 2481 2482 if (h->root.type == bfd_link_hash_defined 2483 || h->root.type == bfd_link_hash_defweak) 2484 { 2485 bfd_boolean dyn; 2486 sec = h->root.u.def.section; 2487 2488 dyn = htab->root.dynamic_sections_created; 2489 sec = h->root.u.def.section; 2490 if (r_type == R_M32R_GOTPC24 2491 || (r_type == R_M32R_GOTPC_HI_ULO 2492 || r_type == R_M32R_GOTPC_HI_SLO 2493 || r_type == R_M32R_GOTPC_LO) 2494 || (r_type == R_M32R_26_PLTREL 2495 && h->plt.offset != (bfd_vma) -1) 2496 || ((r_type == R_M32R_GOT24 2497 || r_type == R_M32R_GOT16_HI_ULO 2498 || r_type == R_M32R_GOT16_HI_SLO 2499 || r_type == R_M32R_GOT16_LO) 2500 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 2501 bfd_link_pic (info), 2502 h) 2503 && (! bfd_link_pic (info) 2504 || (! info->symbolic && h->dynindx != -1) 2505 || !h->def_regular)) 2506 || (bfd_link_pic (info) 2507 && ((! info->symbolic && h->dynindx != -1) 2508 || !h->def_regular) 2509 && (((r_type == R_M32R_16_RELA 2510 || r_type == R_M32R_32_RELA 2511 || r_type == R_M32R_24_RELA 2512 || r_type == R_M32R_HI16_ULO_RELA 2513 || r_type == R_M32R_HI16_SLO_RELA 2514 || r_type == R_M32R_LO16_RELA) 2515 && !h->forced_local) 2516 || r_type == R_M32R_REL32 2517 || r_type == R_M32R_10_PCREL_RELA 2518 || r_type == R_M32R_18_PCREL_RELA 2519 || r_type == R_M32R_26_PCREL_RELA) 2520 && ((input_section->flags & SEC_ALLOC) != 0 2521 /* DWARF will emit R_M32R_16(24,32) relocations 2522 in its sections against symbols defined 2523 externally in shared libraries. We can't do 2524 anything with them here. */ 2525 || ((input_section->flags & SEC_DEBUGGING) != 0 2526 && h->def_dynamic)))) 2527 { 2528 /* In these cases, we don't need the relocation 2529 value. We check specially because in some 2530 obscure cases sec->output_section will be NULL. */ 2531 } 2532 else if (sec->output_section != NULL) 2533 relocation = (h->root.u.def.value 2534 + sec->output_section->vma 2535 + sec->output_offset); 2536 else if (!bfd_link_relocatable (info) 2537 && (_bfd_elf_section_offset (output_bfd, info, 2538 input_section, 2539 rel->r_offset) 2540 != (bfd_vma) -1)) 2541 { 2542 _bfd_error_handler 2543 /* xgettext:c-format */ 2544 (_("%pB(%pA+%#" PRIx64 "): unresolvable %s relocation " 2545 "against symbol `%s'"), 2546 input_bfd, 2547 input_section, 2548 (uint64_t) rel->r_offset, 2549 howto->name, 2550 h->root.root.string); 2551 } 2552 } 2553 else if (h->root.type == bfd_link_hash_undefweak) 2554 ; 2555 else if (info->unresolved_syms_in_objects == RM_IGNORE 2556 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 2557 ; 2558 else if (!bfd_link_relocatable (info)) 2559 (*info->callbacks->undefined_symbol) 2560 (info, h->root.root.string, input_bfd, 2561 input_section, offset, 2562 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR 2563 || ELF_ST_VISIBILITY (h->other))); 2564 } 2565 2566 if (sec != NULL && discarded_section (sec)) 2567 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 2568 rel, 1, relend, howto, 0, contents); 2569 2570 if (bfd_link_relocatable (info) && !use_rel) 2571 { 2572 /* This is a relocatable link. We don't have to change 2573 anything, unless the reloc is against a section symbol, 2574 in which case we have to adjust according to where the 2575 section symbol winds up in the output section. */ 2576 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 2577 rel->r_addend += sec->output_offset; 2578 continue; 2579 } 2580 2581 if (bfd_link_relocatable (info) && use_rel) 2582 { 2583 /* This is a relocatable link. We don't have to change 2584 anything, unless the reloc is against a section symbol, 2585 in which case we have to adjust according to where the 2586 section symbol winds up in the output section. */ 2587 if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION) 2588 continue; 2589 2590 addend += sec->output_offset; 2591 2592 /* If partial_inplace, we need to store any additional addend 2593 back in the section. */ 2594 if (! howto->partial_inplace) 2595 continue; 2596 /* ??? Here is a nice place to call a special_function 2597 like handler. */ 2598 if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO) 2599 r = _bfd_relocate_contents (howto, input_bfd, 2600 addend, contents + offset); 2601 else 2602 { 2603 Elf_Internal_Rela *lorel; 2604 2605 /* We allow an arbitrary number of HI16 relocs before the 2606 LO16 reloc. This permits gcc to emit the HI and LO relocs 2607 itself. */ 2608 for (lorel = rel + 1; 2609 (lorel < relend 2610 && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO 2611 || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO)); 2612 lorel++) 2613 continue; 2614 if (lorel < relend 2615 && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16) 2616 { 2617 m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel, 2618 contents, addend); 2619 r = bfd_reloc_ok; 2620 } 2621 else 2622 r = _bfd_relocate_contents (howto, input_bfd, 2623 addend, contents + offset); 2624 } 2625 } 2626 else 2627 { 2628 /* Sanity check the address. */ 2629 if (offset > high_address) 2630 { 2631 r = bfd_reloc_outofrange; 2632 goto check_reloc; 2633 } 2634 2635 switch ((int) r_type) 2636 { 2637 case R_M32R_GOTOFF: 2638 /* Relocation is relative to the start of the global offset 2639 table (for ld24 rx, #uimm24). eg access at label+addend 2640 2641 ld24 rx. #label@GOTOFF + addend 2642 sub rx, r12. */ 2643 2644 BFD_ASSERT (sgot != NULL); 2645 2646 relocation = -(relocation - sgot->output_section->vma); 2647 rel->r_addend = -rel->r_addend; 2648 break; 2649 2650 case R_M32R_GOTOFF_HI_ULO: 2651 case R_M32R_GOTOFF_HI_SLO: 2652 case R_M32R_GOTOFF_LO: 2653 BFD_ASSERT (sgot != NULL); 2654 2655 relocation -= sgot->output_section->vma; 2656 2657 if ((r_type == R_M32R_GOTOFF_HI_SLO) 2658 && ((relocation + rel->r_addend) & 0x8000)) 2659 rel->r_addend += 0x10000; 2660 break; 2661 2662 case R_M32R_GOTPC24: 2663 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation 2664 ld24 rx,#_GLOBAL_OFFSET_TABLE_ 2665 */ 2666 relocation = sgot->output_section->vma; 2667 break; 2668 2669 case R_M32R_GOTPC_HI_ULO: 2670 case R_M32R_GOTPC_HI_SLO: 2671 case R_M32R_GOTPC_LO: 2672 { 2673 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation 2674 bl .+4 2675 seth rx,#high(_GLOBAL_OFFSET_TABLE_) 2676 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4) 2677 or 2678 bl .+4 2679 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_) 2680 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4) 2681 */ 2682 relocation = sgot->output_section->vma; 2683 relocation -= (input_section->output_section->vma 2684 + input_section->output_offset 2685 + rel->r_offset); 2686 if ((r_type == R_M32R_GOTPC_HI_SLO) 2687 && ((relocation + rel->r_addend) & 0x8000)) 2688 rel->r_addend += 0x10000; 2689 2690 break; 2691 } 2692 case R_M32R_GOT16_HI_ULO: 2693 case R_M32R_GOT16_HI_SLO: 2694 case R_M32R_GOT16_LO: 2695 /* Fall through. */ 2696 case R_M32R_GOT24: 2697 /* Relocation is to the entry for this symbol in the global 2698 offset table. */ 2699 BFD_ASSERT (sgot != NULL); 2700 2701 if (h != NULL) 2702 { 2703 bfd_boolean dyn; 2704 bfd_vma off; 2705 2706 off = h->got.offset; 2707 BFD_ASSERT (off != (bfd_vma) -1); 2708 2709 dyn = htab->root.dynamic_sections_created; 2710 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 2711 bfd_link_pic (info), 2712 h) 2713 || (bfd_link_pic (info) 2714 && (info->symbolic 2715 || h->dynindx == -1 2716 || h->forced_local) 2717 && h->def_regular)) 2718 { 2719 /* This is actually a static link, or it is a 2720 -Bsymbolic link and the symbol is defined 2721 locally, or the symbol was forced to be local 2722 because of a version file. We must initialize 2723 this entry in the global offset table. Since the 2724 offset must always be a multiple of 4, we use the 2725 least significant bit to record whether we have 2726 initialized it already. 2727 2728 When doing a dynamic link, we create a .rela.got 2729 relocation entry to initialize the value. This 2730 is done in the finish_dynamic_symbol routine. */ 2731 if ((off & 1) != 0) 2732 off &= ~1; 2733 else 2734 { 2735 bfd_put_32 (output_bfd, relocation, 2736 sgot->contents + off); 2737 h->got.offset |= 1; 2738 } 2739 } 2740 2741 relocation = sgot->output_offset + off; 2742 } 2743 else 2744 { 2745 bfd_vma off; 2746 bfd_byte *loc; 2747 2748 BFD_ASSERT (local_got_offsets != NULL 2749 && local_got_offsets[r_symndx] != (bfd_vma) -1); 2750 2751 off = local_got_offsets[r_symndx]; 2752 2753 /* The offset must always be a multiple of 4. We use 2754 the least significant bit to record whether we have 2755 already processed this entry. */ 2756 if ((off & 1) != 0) 2757 off &= ~1; 2758 else 2759 { 2760 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 2761 2762 if (bfd_link_pic (info)) 2763 { 2764 asection *srelgot; 2765 Elf_Internal_Rela outrel; 2766 2767 /* We need to generate a R_M32R_RELATIVE reloc 2768 for the dynamic linker. */ 2769 srelgot = htab->root.srelgot; 2770 BFD_ASSERT (srelgot != NULL); 2771 2772 outrel.r_offset = (sgot->output_section->vma 2773 + sgot->output_offset 2774 + off); 2775 outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE); 2776 outrel.r_addend = relocation; 2777 loc = srelgot->contents; 2778 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela); 2779 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc); 2780 ++srelgot->reloc_count; 2781 } 2782 2783 local_got_offsets[r_symndx] |= 1; 2784 } 2785 2786 relocation = sgot->output_offset + off; 2787 } 2788 if ((r_type == R_M32R_GOT16_HI_SLO) 2789 && ((relocation + rel->r_addend) & 0x8000)) 2790 rel->r_addend += 0x10000; 2791 2792 break; 2793 2794 case R_M32R_26_PLTREL: 2795 /* Relocation is to the entry for this symbol in the 2796 procedure linkage table. */ 2797 2798 /* The native assembler will generate a 26_PLTREL reloc 2799 for a local symbol if you assemble a call from one 2800 section to another when using -K pic. */ 2801 if (h == NULL) 2802 break; 2803 2804 if (h->forced_local) 2805 break; 2806 2807 if (h->plt.offset == (bfd_vma) -1) 2808 /* We didn't make a PLT entry for this symbol. This 2809 happens when statically linking PIC code, or when 2810 using -Bsymbolic. */ 2811 break; 2812 2813 relocation = (splt->output_section->vma 2814 + splt->output_offset 2815 + h->plt.offset); 2816 break; 2817 2818 case R_M32R_HI16_SLO_RELA: 2819 if ((relocation + rel->r_addend) & 0x8000) 2820 rel->r_addend += 0x10000; 2821 /* Fall through. */ 2822 2823 case R_M32R_16_RELA: 2824 case R_M32R_24_RELA: 2825 case R_M32R_32_RELA: 2826 case R_M32R_REL32: 2827 case R_M32R_10_PCREL_RELA: 2828 case R_M32R_18_PCREL_RELA: 2829 case R_M32R_26_PCREL_RELA: 2830 case R_M32R_HI16_ULO_RELA: 2831 case R_M32R_LO16_RELA: 2832 if (bfd_link_pic (info) 2833 && r_symndx != STN_UNDEF 2834 && (input_section->flags & SEC_ALLOC) != 0 2835 && (( r_type != R_M32R_10_PCREL_RELA 2836 && r_type != R_M32R_18_PCREL_RELA 2837 && r_type != R_M32R_26_PCREL_RELA 2838 && r_type != R_M32R_REL32) 2839 || (h != NULL 2840 && h->dynindx != -1 2841 && (! info->symbolic 2842 || !h->def_regular)))) 2843 { 2844 Elf_Internal_Rela outrel; 2845 bfd_boolean skip, relocate; 2846 bfd_byte *loc; 2847 2848 /* When generating a shared object, these relocations 2849 are copied into the output file to be resolved at run 2850 time. */ 2851 if (sreloc == NULL) 2852 { 2853 sreloc = _bfd_elf_get_dynamic_reloc_section 2854 (input_bfd, input_section, /*rela?*/ TRUE); 2855 if (sreloc == NULL) 2856 return FALSE; 2857 } 2858 2859 skip = FALSE; 2860 relocate = FALSE; 2861 2862 outrel.r_offset = _bfd_elf_section_offset (output_bfd, 2863 info, 2864 input_section, 2865 rel->r_offset); 2866 if (outrel.r_offset == (bfd_vma) -1) 2867 skip = TRUE; 2868 else if (outrel.r_offset == (bfd_vma) -2) 2869 skip = relocate = TRUE; 2870 outrel.r_offset += (input_section->output_section->vma 2871 + input_section->output_offset); 2872 2873 if (skip) 2874 memset (&outrel, 0, sizeof outrel); 2875 else if ( r_type == R_M32R_10_PCREL_RELA 2876 || r_type == R_M32R_18_PCREL_RELA 2877 || r_type == R_M32R_26_PCREL_RELA 2878 || r_type == R_M32R_REL32) 2879 { 2880 BFD_ASSERT (h != NULL && h->dynindx != -1); 2881 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 2882 outrel.r_addend = rel->r_addend; 2883 } 2884 else 2885 { 2886 /* h->dynindx may be -1 if this symbol was marked to 2887 become local. */ 2888 if (h == NULL 2889 || ((info->symbolic || h->dynindx == -1) 2890 && h->def_regular)) 2891 { 2892 relocate = TRUE; 2893 outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE); 2894 outrel.r_addend = relocation + rel->r_addend; 2895 } 2896 else 2897 { 2898 BFD_ASSERT (h->dynindx != -1); 2899 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 2900 outrel.r_addend = relocation + rel->r_addend; 2901 } 2902 } 2903 2904 loc = sreloc->contents; 2905 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela); 2906 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc); 2907 ++sreloc->reloc_count; 2908 2909 /* If this reloc is against an external symbol, we do 2910 not want to fiddle with the addend. Otherwise, we 2911 need to include the symbol value so that it becomes 2912 an addend for the dynamic reloc. */ 2913 if (! relocate) 2914 continue; 2915 break; 2916 } 2917 else if (r_type != R_M32R_10_PCREL_RELA) 2918 break; 2919 /* Fall through. */ 2920 2921 case (int) R_M32R_10_PCREL : 2922 r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section, 2923 contents, offset, 2924 sec, relocation, addend); 2925 goto check_reloc; 2926 2927 case (int) R_M32R_HI16_SLO : 2928 case (int) R_M32R_HI16_ULO : 2929 { 2930 Elf_Internal_Rela *lorel; 2931 2932 /* We allow an arbitrary number of HI16 relocs before the 2933 LO16 reloc. This permits gcc to emit the HI and LO relocs 2934 itself. */ 2935 for (lorel = rel + 1; 2936 (lorel < relend 2937 && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO 2938 || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO)); 2939 lorel++) 2940 continue; 2941 if (lorel < relend 2942 && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16) 2943 { 2944 m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel, 2945 contents, relocation + addend); 2946 r = bfd_reloc_ok; 2947 } 2948 else 2949 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 2950 contents, offset, 2951 relocation, addend); 2952 } 2953 2954 goto check_reloc; 2955 2956 case (int) R_M32R_SDA16_RELA: 2957 case (int) R_M32R_SDA16 : 2958 { 2959 const char *name; 2960 2961 BFD_ASSERT (sec != NULL); 2962 name = bfd_section_name (sec); 2963 2964 if ( strcmp (name, ".sdata") == 0 2965 || strcmp (name, ".sbss") == 0 2966 || strcmp (name, ".scommon") == 0) 2967 { 2968 bfd_vma sda_base; 2969 bfd *out_bfd = sec->output_section->owner; 2970 2971 r = m32r_elf_final_sda_base (out_bfd, info, 2972 &errmsg, 2973 &sda_base); 2974 if (r != bfd_reloc_ok) 2975 { 2976 ret = FALSE; 2977 goto check_reloc; 2978 } 2979 2980 /* At this point `relocation' contains the object's 2981 address. */ 2982 relocation -= sda_base; 2983 /* Now it contains the offset from _SDA_BASE_. */ 2984 } 2985 else 2986 { 2987 _bfd_error_handler 2988 /* xgettext:c-format */ 2989 (_("%pB: the target (%s) of an %s relocation" 2990 " is in the wrong section (%pA)"), 2991 input_bfd, 2992 sym_name, 2993 m32r_elf_howto_table[(int) r_type].name, 2994 sec); 2995 /*bfd_set_error (bfd_error_bad_value); ??? why? */ 2996 ret = FALSE; 2997 continue; 2998 } 2999 } 3000 /* Fall through. */ 3001 3002 default : /* OLD_M32R_RELOC */ 3003 3004 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 3005 contents, offset, 3006 relocation, addend); 3007 goto check_reloc; 3008 } 3009 3010 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 3011 contents, rel->r_offset, 3012 relocation, rel->r_addend); 3013 3014 } 3015 3016 check_reloc: 3017 3018 if (r != bfd_reloc_ok) 3019 { 3020 /* FIXME: This should be generic enough to go in a utility. */ 3021 const char *name; 3022 3023 if (h != NULL) 3024 name = h->root.root.string; 3025 else 3026 { 3027 name = (bfd_elf_string_from_elf_section 3028 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 3029 if (name == NULL || *name == '\0') 3030 name = bfd_section_name (sec); 3031 } 3032 3033 if (errmsg != NULL) 3034 goto common_error; 3035 3036 switch (r) 3037 { 3038 case bfd_reloc_overflow: 3039 (*info->callbacks->reloc_overflow) 3040 (info, (h ? &h->root : NULL), name, howto->name, 3041 (bfd_vma) 0, input_bfd, input_section, offset); 3042 break; 3043 3044 case bfd_reloc_undefined: 3045 (*info->callbacks->undefined_symbol) 3046 (info, name, input_bfd, input_section, offset, TRUE); 3047 break; 3048 3049 case bfd_reloc_outofrange: 3050 errmsg = _("internal error: out of range error"); 3051 goto common_error; 3052 3053 case bfd_reloc_notsupported: 3054 errmsg = _("internal error: unsupported relocation error"); 3055 goto common_error; 3056 3057 case bfd_reloc_dangerous: 3058 errmsg = _("internal error: dangerous error"); 3059 goto common_error; 3060 3061 default: 3062 errmsg = _("internal error: unknown error"); 3063 /* fall through */ 3064 3065 common_error: 3066 (*info->callbacks->warning) (info, errmsg, name, input_bfd, 3067 input_section, offset); 3068 break; 3069 } 3070 } 3071 } 3072 3073 return ret; 3074 } 3075 3076 /* Finish up dynamic symbol handling. We set the contents of various 3077 dynamic sections here. */ 3078 3079 static bfd_boolean 3080 m32r_elf_finish_dynamic_symbol (bfd *output_bfd, 3081 struct bfd_link_info *info, 3082 struct elf_link_hash_entry *h, 3083 Elf_Internal_Sym *sym) 3084 { 3085 struct elf_m32r_link_hash_table *htab; 3086 bfd_byte *loc; 3087 3088 #ifdef DEBUG_PIC 3089 printf ("m32r_elf_finish_dynamic_symbol()\n"); 3090 #endif 3091 3092 htab = m32r_elf_hash_table (info); 3093 if (htab == NULL) 3094 return FALSE; 3095 3096 if (h->plt.offset != (bfd_vma) -1) 3097 { 3098 asection *splt; 3099 asection *sgot; 3100 asection *srela; 3101 3102 bfd_vma plt_index; 3103 bfd_vma got_offset; 3104 Elf_Internal_Rela rela; 3105 3106 /* This symbol has an entry in the procedure linkage table. Set 3107 it up. */ 3108 3109 BFD_ASSERT (h->dynindx != -1); 3110 3111 splt = htab->root.splt; 3112 sgot = htab->root.sgotplt; 3113 srela = htab->root.srelplt; 3114 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL); 3115 3116 /* Get the index in the procedure linkage table which 3117 corresponds to this symbol. This is the index of this symbol 3118 in all the symbols for which we are making plt entries. The 3119 first entry in the procedure linkage table is reserved. */ 3120 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; 3121 3122 /* Get the offset into the .got table of the entry that 3123 corresponds to this function. Each .got entry is 4 bytes. 3124 The first three are reserved. */ 3125 got_offset = (plt_index + 3) * 4; 3126 3127 /* Fill in the entry in the procedure linkage table. */ 3128 if (! bfd_link_pic (info)) 3129 { 3130 bfd_put_32 (output_bfd, 3131 (PLT_ENTRY_WORD0b 3132 + (((sgot->output_section->vma 3133 + sgot->output_offset 3134 + got_offset) >> 16) & 0xffff)), 3135 splt->contents + h->plt.offset); 3136 bfd_put_32 (output_bfd, 3137 (PLT_ENTRY_WORD1b 3138 + ((sgot->output_section->vma 3139 + sgot->output_offset 3140 + got_offset) & 0xffff)), 3141 splt->contents + h->plt.offset + 4); 3142 bfd_put_32 (output_bfd, PLT_ENTRY_WORD2, 3143 splt->contents + h->plt.offset + 8); 3144 bfd_put_32 (output_bfd, 3145 (PLT_ENTRY_WORD3 3146 + plt_index * sizeof (Elf32_External_Rela)), 3147 splt->contents + h->plt.offset + 12); 3148 bfd_put_32 (output_bfd, 3149 (PLT_ENTRY_WORD4 3150 + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)), 3151 splt->contents + h->plt.offset + 16); 3152 } 3153 else 3154 { 3155 bfd_put_32 (output_bfd, 3156 PLT_ENTRY_WORD0 + got_offset, 3157 splt->contents + h->plt.offset); 3158 bfd_put_32 (output_bfd, PLT_ENTRY_WORD1, 3159 splt->contents + h->plt.offset + 4); 3160 bfd_put_32 (output_bfd, PLT_ENTRY_WORD2, 3161 splt->contents + h->plt.offset + 8); 3162 bfd_put_32 (output_bfd, 3163 (PLT_ENTRY_WORD3 3164 + plt_index * sizeof (Elf32_External_Rela)), 3165 splt->contents + h->plt.offset + 12); 3166 bfd_put_32 (output_bfd, 3167 (PLT_ENTRY_WORD4 3168 + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)), 3169 splt->contents + h->plt.offset + 16); 3170 } 3171 3172 /* Fill in the entry in the global offset table. */ 3173 bfd_put_32 (output_bfd, 3174 (splt->output_section->vma 3175 + splt->output_offset 3176 + h->plt.offset 3177 + 12), /* same offset */ 3178 sgot->contents + got_offset); 3179 3180 /* Fill in the entry in the .rela.plt section. */ 3181 rela.r_offset = (sgot->output_section->vma 3182 + sgot->output_offset 3183 + got_offset); 3184 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT); 3185 rela.r_addend = 0; 3186 loc = srela->contents; 3187 loc += plt_index * sizeof (Elf32_External_Rela); 3188 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 3189 3190 if (!h->def_regular) 3191 { 3192 /* Mark the symbol as undefined, rather than as defined in 3193 the .plt section. Leave the value alone. */ 3194 sym->st_shndx = SHN_UNDEF; 3195 } 3196 } 3197 3198 if (h->got.offset != (bfd_vma) -1) 3199 { 3200 asection *sgot; 3201 asection *srela; 3202 Elf_Internal_Rela rela; 3203 3204 /* This symbol has an entry in the global offset table. Set it 3205 up. */ 3206 3207 sgot = htab->root.sgot; 3208 srela = htab->root.srelgot; 3209 BFD_ASSERT (sgot != NULL && srela != NULL); 3210 3211 rela.r_offset = (sgot->output_section->vma 3212 + sgot->output_offset 3213 + (h->got.offset &~ 1)); 3214 3215 /* If this is a -Bsymbolic link, and the symbol is defined 3216 locally, we just want to emit a RELATIVE reloc. Likewise if 3217 the symbol was forced to be local because of a version file. 3218 The entry in the global offset table will already have been 3219 initialized in the relocate_section function. */ 3220 if (bfd_link_pic (info) 3221 && (info->symbolic 3222 || h->dynindx == -1 3223 || h->forced_local) 3224 && h->def_regular) 3225 { 3226 rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE); 3227 rela.r_addend = (h->root.u.def.value 3228 + h->root.u.def.section->output_section->vma 3229 + h->root.u.def.section->output_offset); 3230 } 3231 else 3232 { 3233 BFD_ASSERT ((h->got.offset & 1) == 0); 3234 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 3235 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT); 3236 rela.r_addend = 0; 3237 } 3238 3239 loc = srela->contents; 3240 loc += srela->reloc_count * sizeof (Elf32_External_Rela); 3241 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 3242 ++srela->reloc_count; 3243 } 3244 3245 if (h->needs_copy) 3246 { 3247 asection *s; 3248 Elf_Internal_Rela rela; 3249 3250 /* This symbols needs a copy reloc. Set it up. */ 3251 3252 BFD_ASSERT (h->dynindx != -1 3253 && (h->root.type == bfd_link_hash_defined 3254 || h->root.type == bfd_link_hash_defweak)); 3255 3256 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss"); 3257 BFD_ASSERT (s != NULL); 3258 3259 rela.r_offset = (h->root.u.def.value 3260 + h->root.u.def.section->output_section->vma 3261 + h->root.u.def.section->output_offset); 3262 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY); 3263 rela.r_addend = 0; 3264 loc = s->contents; 3265 loc += s->reloc_count * sizeof (Elf32_External_Rela); 3266 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 3267 ++s->reloc_count; 3268 } 3269 3270 /* Mark some specially defined symbols as absolute. */ 3271 if (h == htab->root.hdynamic || h == htab->root.hgot) 3272 sym->st_shndx = SHN_ABS; 3273 3274 return TRUE; 3275 } 3276 3277 3278 /* Finish up the dynamic sections. */ 3279 3280 static bfd_boolean 3281 m32r_elf_finish_dynamic_sections (bfd *output_bfd, 3282 struct bfd_link_info *info) 3283 { 3284 struct elf_m32r_link_hash_table *htab; 3285 bfd *dynobj; 3286 asection *sdyn; 3287 asection *sgot; 3288 3289 #ifdef DEBUG_PIC 3290 printf ("m32r_elf_finish_dynamic_sections()\n"); 3291 #endif 3292 3293 htab = m32r_elf_hash_table (info); 3294 if (htab == NULL) 3295 return FALSE; 3296 3297 dynobj = htab->root.dynobj; 3298 3299 sgot = htab->root.sgotplt; 3300 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 3301 3302 if (htab->root.dynamic_sections_created) 3303 { 3304 asection *splt; 3305 Elf32_External_Dyn *dyncon, *dynconend; 3306 3307 BFD_ASSERT (sgot != NULL && sdyn != NULL); 3308 3309 dyncon = (Elf32_External_Dyn *) sdyn->contents; 3310 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 3311 3312 for (; dyncon < dynconend; dyncon++) 3313 { 3314 Elf_Internal_Dyn dyn; 3315 asection *s; 3316 3317 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 3318 3319 switch (dyn.d_tag) 3320 { 3321 default: 3322 break; 3323 3324 case DT_PLTGOT: 3325 s = htab->root.sgotplt; 3326 goto get_vma; 3327 case DT_JMPREL: 3328 s = htab->root.srelplt; 3329 get_vma: 3330 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 3331 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 3332 break; 3333 3334 case DT_PLTRELSZ: 3335 s = htab->root.srelplt; 3336 dyn.d_un.d_val = s->size; 3337 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 3338 break; 3339 } 3340 } 3341 3342 /* Fill in the first entry in the procedure linkage table. */ 3343 splt = htab->root.splt; 3344 if (splt && splt->size > 0) 3345 { 3346 if (bfd_link_pic (info)) 3347 { 3348 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents); 3349 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4); 3350 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8); 3351 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12); 3352 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16); 3353 } 3354 else 3355 { 3356 unsigned long addr; 3357 /* addr = .got + 4 */ 3358 addr = sgot->output_section->vma + sgot->output_offset + 4; 3359 bfd_put_32 (output_bfd, 3360 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff), 3361 splt->contents); 3362 bfd_put_32 (output_bfd, 3363 PLT0_ENTRY_WORD1 | (addr & 0xffff), 3364 splt->contents + 4); 3365 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8); 3366 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12); 3367 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16); 3368 } 3369 3370 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 3371 PLT_ENTRY_SIZE; 3372 } 3373 } 3374 3375 /* Fill in the first three entries in the global offset table. */ 3376 if (sgot && sgot->size > 0) 3377 { 3378 if (sdyn == NULL) 3379 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 3380 else 3381 bfd_put_32 (output_bfd, 3382 sdyn->output_section->vma + sdyn->output_offset, 3383 sgot->contents); 3384 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 3385 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 3386 3387 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 3388 } 3389 3390 return TRUE; 3391 } 3392 3393 3394 /* Set the right machine number. */ 3396 3397 static bfd_boolean 3398 m32r_elf_object_p (bfd *abfd) 3399 { 3400 switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH) 3401 { 3402 default: 3403 case E_M32R_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r); break; 3404 case E_M32RX_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break; 3405 case E_M32R2_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break; 3406 } 3407 return TRUE; 3408 } 3409 3410 /* Store the machine number in the flags field. */ 3411 3412 static bfd_boolean 3413 m32r_elf_final_write_processing (bfd *abfd) 3414 { 3415 unsigned long val; 3416 3417 switch (bfd_get_mach (abfd)) 3418 { 3419 default: 3420 case bfd_mach_m32r: val = E_M32R_ARCH; break; 3421 case bfd_mach_m32rx: val = E_M32RX_ARCH; break; 3422 case bfd_mach_m32r2: val = E_M32R2_ARCH; break; 3423 } 3424 3425 elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH; 3426 elf_elfheader (abfd)->e_flags |= val; 3427 return _bfd_elf_final_write_processing (abfd); 3428 } 3429 3430 /* Function to keep M32R specific file flags. */ 3431 3432 static bfd_boolean 3433 m32r_elf_set_private_flags (bfd *abfd, flagword flags) 3434 { 3435 BFD_ASSERT (!elf_flags_init (abfd) 3436 || elf_elfheader (abfd)->e_flags == flags); 3437 3438 elf_elfheader (abfd)->e_flags = flags; 3439 elf_flags_init (abfd) = TRUE; 3440 return TRUE; 3441 } 3442 3443 /* Merge backend specific data from an object file to the output 3444 object file when linking. */ 3445 3446 static bfd_boolean 3447 m32r_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 3448 { 3449 bfd *obfd = info->output_bfd; 3450 flagword out_flags; 3451 flagword in_flags; 3452 3453 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour 3454 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 3455 return TRUE; 3456 3457 in_flags = elf_elfheader (ibfd)->e_flags; 3458 out_flags = elf_elfheader (obfd)->e_flags; 3459 3460 if (! elf_flags_init (obfd)) 3461 { 3462 /* If the input is the default architecture then do not 3463 bother setting the flags for the output architecture, 3464 instead allow future merges to do this. If no future 3465 merges ever set these flags then they will retain their 3466 unitialised values, which surprise surprise, correspond 3467 to the default values. */ 3468 if (bfd_get_arch_info (ibfd)->the_default) 3469 return TRUE; 3470 3471 elf_flags_init (obfd) = TRUE; 3472 elf_elfheader (obfd)->e_flags = in_flags; 3473 3474 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 3475 && bfd_get_arch_info (obfd)->the_default) 3476 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 3477 bfd_get_mach (ibfd)); 3478 3479 return TRUE; 3480 } 3481 3482 /* Check flag compatibility. */ 3483 if (in_flags == out_flags) 3484 return TRUE; 3485 3486 if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH)) 3487 { 3488 if ( ((in_flags & EF_M32R_ARCH) != E_M32R_ARCH) 3489 || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH) 3490 || ((in_flags & EF_M32R_ARCH) == E_M32R2_ARCH)) 3491 { 3492 _bfd_error_handler 3493 (_("%pB: instruction set mismatch with previous modules"), ibfd); 3494 3495 bfd_set_error (bfd_error_bad_value); 3496 return FALSE; 3497 } 3498 } 3499 3500 return TRUE; 3501 } 3502 3503 /* Display the flags field. */ 3504 3505 static bfd_boolean 3506 m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr) 3507 { 3508 FILE * file = (FILE *) ptr; 3509 3510 BFD_ASSERT (abfd != NULL && ptr != NULL); 3511 3512 _bfd_elf_print_private_bfd_data (abfd, ptr); 3513 3514 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags); 3515 3516 switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH) 3517 { 3518 default: 3519 case E_M32R_ARCH: fprintf (file, _(": m32r instructions")); break; 3520 case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break; 3521 case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break; 3522 } 3523 3524 fputc ('\n', file); 3525 3526 return TRUE; 3527 } 3528 3529 static asection * 3530 m32r_elf_gc_mark_hook (asection *sec, 3531 struct bfd_link_info *info, 3532 Elf_Internal_Rela *rel, 3533 struct elf_link_hash_entry *h, 3534 Elf_Internal_Sym *sym) 3535 { 3536 if (h != NULL) 3537 switch (ELF32_R_TYPE (rel->r_info)) 3538 { 3539 case R_M32R_GNU_VTINHERIT: 3540 case R_M32R_GNU_VTENTRY: 3541 case R_M32R_RELA_GNU_VTINHERIT: 3542 case R_M32R_RELA_GNU_VTENTRY: 3543 return NULL; 3544 } 3545 3546 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 3547 } 3548 3549 /* Look through the relocs for a section during the first phase. 3550 Since we don't do .gots or .plts, we just need to consider the 3551 virtual table relocs for gc. */ 3552 3553 static bfd_boolean 3554 m32r_elf_check_relocs (bfd *abfd, 3555 struct bfd_link_info *info, 3556 asection *sec, 3557 const Elf_Internal_Rela *relocs) 3558 { 3559 Elf_Internal_Shdr *symtab_hdr; 3560 struct elf_link_hash_entry **sym_hashes; 3561 const Elf_Internal_Rela *rel; 3562 const Elf_Internal_Rela *rel_end; 3563 struct elf_m32r_link_hash_table *htab; 3564 bfd *dynobj; 3565 asection *sreloc; 3566 3567 if (bfd_link_relocatable (info)) 3568 return TRUE; 3569 3570 /* Don't do anything special with non-loaded, non-alloced sections. 3571 In particular, any relocs in such sections should not affect GOT 3572 and PLT reference counting (ie. we don't allow them to create GOT 3573 or PLT entries), there's no possibility or desire to optimize TLS 3574 relocs, and there's not much point in propagating relocs to shared 3575 libs that the dynamic linker won't relocate. */ 3576 if ((sec->flags & SEC_ALLOC) == 0) 3577 return TRUE; 3578 3579 sreloc = NULL; 3580 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3581 sym_hashes = elf_sym_hashes (abfd); 3582 3583 htab = m32r_elf_hash_table (info); 3584 if (htab == NULL) 3585 return FALSE; 3586 3587 dynobj = htab->root.dynobj; 3588 3589 rel_end = relocs + sec->reloc_count; 3590 for (rel = relocs; rel < rel_end; rel++) 3591 { 3592 int r_type; 3593 struct elf_link_hash_entry *h; 3594 unsigned long r_symndx; 3595 3596 r_symndx = ELF32_R_SYM (rel->r_info); 3597 r_type = ELF32_R_TYPE (rel->r_info); 3598 if (r_symndx < symtab_hdr->sh_info) 3599 h = NULL; 3600 else 3601 { 3602 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 3603 while (h->root.type == bfd_link_hash_indirect 3604 || h->root.type == bfd_link_hash_warning) 3605 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3606 } 3607 3608 /* Some relocs require a global offset table. */ 3609 if (htab->root.sgot == NULL) 3610 { 3611 switch (r_type) 3612 { 3613 case R_M32R_GOT16_HI_ULO: 3614 case R_M32R_GOT16_HI_SLO: 3615 case R_M32R_GOTOFF: 3616 case R_M32R_GOTOFF_HI_ULO: 3617 case R_M32R_GOTOFF_HI_SLO: 3618 case R_M32R_GOTOFF_LO: 3619 case R_M32R_GOT16_LO: 3620 case R_M32R_GOTPC24: 3621 case R_M32R_GOTPC_HI_ULO: 3622 case R_M32R_GOTPC_HI_SLO: 3623 case R_M32R_GOTPC_LO: 3624 case R_M32R_GOT24: 3625 if (dynobj == NULL) 3626 htab->root.dynobj = dynobj = abfd; 3627 if (!_bfd_elf_create_got_section (dynobj, info)) 3628 return FALSE; 3629 break; 3630 3631 default: 3632 break; 3633 } 3634 } 3635 3636 switch (r_type) 3637 { 3638 case R_M32R_GOT16_HI_ULO: 3639 case R_M32R_GOT16_HI_SLO: 3640 case R_M32R_GOT16_LO: 3641 case R_M32R_GOT24: 3642 3643 if (h != NULL) 3644 h->got.refcount += 1; 3645 else 3646 { 3647 bfd_signed_vma *local_got_refcounts; 3648 3649 /* This is a global offset table entry for a local 3650 symbol. */ 3651 local_got_refcounts = elf_local_got_refcounts (abfd); 3652 if (local_got_refcounts == NULL) 3653 { 3654 bfd_size_type size; 3655 3656 size = symtab_hdr->sh_info; 3657 size *= sizeof (bfd_signed_vma); 3658 local_got_refcounts = bfd_zalloc (abfd, size); 3659 if (local_got_refcounts == NULL) 3660 return FALSE; 3661 elf_local_got_refcounts (abfd) = local_got_refcounts; 3662 } 3663 local_got_refcounts[r_symndx] += 1; 3664 } 3665 break; 3666 3667 case R_M32R_26_PLTREL: 3668 /* This symbol requires a procedure linkage table entry. We 3669 actually build the entry in adjust_dynamic_symbol, 3670 because this might be a case of linking PIC code without 3671 linking in any dynamic objects, in which case we don't 3672 need to generate a procedure linkage table after all. */ 3673 3674 /* If this is a local symbol, we resolve it directly without 3675 creating a procedure linkage table entry. */ 3676 if (h == NULL) 3677 continue; 3678 3679 if (h->forced_local) 3680 break; 3681 3682 h->needs_plt = 1; 3683 h->plt.refcount += 1; 3684 break; 3685 3686 case R_M32R_16_RELA: 3687 case R_M32R_24_RELA: 3688 case R_M32R_32_RELA: 3689 case R_M32R_REL32: 3690 case R_M32R_HI16_ULO_RELA: 3691 case R_M32R_HI16_SLO_RELA: 3692 case R_M32R_LO16_RELA: 3693 case R_M32R_SDA16_RELA: 3694 case R_M32R_10_PCREL_RELA: 3695 case R_M32R_18_PCREL_RELA: 3696 case R_M32R_26_PCREL_RELA: 3697 3698 if (h != NULL && !bfd_link_pic (info)) 3699 { 3700 h->non_got_ref = 1; 3701 h->plt.refcount += 1; 3702 } 3703 3704 /* If we are creating a shared library, and this is a reloc 3705 against a global symbol, or a non PC relative reloc 3706 against a local symbol, then we need to copy the reloc 3707 into the shared library. However, if we are linking with 3708 -Bsymbolic, we do not need to copy a reloc against a 3709 global symbol which is defined in an object we are 3710 including in the link (i.e., DEF_REGULAR is set). At 3711 this point we have not seen all the input files, so it is 3712 possible that DEF_REGULAR is not set now but will be set 3713 later (it is never cleared). We account for that 3714 possibility below by storing information in the 3715 dyn_relocs field of the hash table entry. A similar 3716 situation occurs when creating shared libraries and symbol 3717 visibility changes render the symbol local. 3718 3719 If on the other hand, we are creating an executable, we 3720 may need to keep relocations for symbols satisfied by a 3721 dynamic library if we manage to avoid copy relocs for the 3722 symbol. */ 3723 if ((bfd_link_pic (info) 3724 && (sec->flags & SEC_ALLOC) != 0 3725 && (( r_type != R_M32R_26_PCREL_RELA 3726 && r_type != R_M32R_18_PCREL_RELA 3727 && r_type != R_M32R_10_PCREL_RELA 3728 && r_type != R_M32R_REL32) 3729 || (h != NULL 3730 && (! info->symbolic 3731 || h->root.type == bfd_link_hash_defweak 3732 || !h->def_regular)))) 3733 || (!bfd_link_pic (info) 3734 && (sec->flags & SEC_ALLOC) != 0 3735 && h != NULL 3736 && (h->root.type == bfd_link_hash_defweak 3737 || !h->def_regular))) 3738 { 3739 struct elf_dyn_relocs *p; 3740 struct elf_dyn_relocs **head; 3741 3742 if (dynobj == NULL) 3743 htab->root.dynobj = dynobj = abfd; 3744 3745 /* When creating a shared object, we must copy these 3746 relocs into the output file. We create a reloc 3747 section in dynobj and make room for the reloc. */ 3748 if (sreloc == NULL) 3749 { 3750 sreloc = _bfd_elf_make_dynamic_reloc_section 3751 (sec, dynobj, 2, abfd, /*rela?*/ TRUE); 3752 3753 if (sreloc == NULL) 3754 return FALSE; 3755 } 3756 3757 /* If this is a global symbol, we count the number of 3758 relocations we need for this symbol. */ 3759 if (h != NULL) 3760 head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs; 3761 else 3762 { 3763 /* Track dynamic relocs needed for local syms too. */ 3764 asection *s; 3765 void *vpp; 3766 Elf_Internal_Sym *isym; 3767 3768 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 3769 abfd, r_symndx); 3770 if (isym == NULL) 3771 return FALSE; 3772 3773 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 3774 if (s == NULL) 3775 s = sec; 3776 3777 vpp = &elf_section_data (s)->local_dynrel; 3778 head = (struct elf_dyn_relocs **) vpp; 3779 } 3780 3781 p = *head; 3782 if (p == NULL || p->sec != sec) 3783 { 3784 bfd_size_type amt = sizeof (*p); 3785 3786 p = bfd_alloc (dynobj, amt); 3787 if (p == NULL) 3788 return FALSE; 3789 p->next = *head; 3790 *head = p; 3791 p->sec = sec; 3792 p->count = 0; 3793 p->pc_count = 0; 3794 } 3795 3796 p->count += 1; 3797 if ( ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA 3798 || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA 3799 || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA 3800 || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32) 3801 p->pc_count += 1; 3802 } 3803 break; 3804 3805 /* This relocation describes the C++ object vtable hierarchy. 3806 Reconstruct it for later use during GC. */ 3807 case R_M32R_RELA_GNU_VTINHERIT: 3808 case R_M32R_GNU_VTINHERIT: 3809 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 3810 return FALSE; 3811 break; 3812 3813 /* This relocation describes which C++ vtable entries are actually 3814 used. Record for later use during GC. */ 3815 case R_M32R_GNU_VTENTRY: 3816 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 3817 return FALSE; 3818 break; 3819 case R_M32R_RELA_GNU_VTENTRY: 3820 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 3821 return FALSE; 3822 break; 3823 } 3824 } 3825 3826 return TRUE; 3827 } 3828 3829 static const struct bfd_elf_special_section m32r_elf_special_sections[] = 3830 { 3831 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 3832 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 3833 { NULL, 0, 0, 0, 0 } 3834 }; 3835 3836 static enum elf_reloc_type_class 3837 m32r_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 3838 const asection *rel_sec ATTRIBUTE_UNUSED, 3839 const Elf_Internal_Rela *rela) 3840 { 3841 switch ((int) ELF32_R_TYPE (rela->r_info)) 3842 { 3843 case R_M32R_RELATIVE: return reloc_class_relative; 3844 case R_M32R_JMP_SLOT: return reloc_class_plt; 3845 case R_M32R_COPY: return reloc_class_copy; 3846 default: return reloc_class_normal; 3847 } 3848 } 3849 3850 #define ELF_ARCH bfd_arch_m32r 3852 #define ELF_TARGET_ID M32R_ELF_DATA 3853 #define ELF_MACHINE_CODE EM_M32R 3854 #define ELF_MACHINE_ALT1 EM_CYGNUS_M32R 3855 #define ELF_MAXPAGESIZE 0x1 /* Explicitly requested by Mitsubishi. */ 3856 3857 #define TARGET_BIG_SYM m32r_elf32_vec 3858 #define TARGET_BIG_NAME "elf32-m32r" 3859 #define TARGET_LITTLE_SYM m32r_elf32_le_vec 3860 #define TARGET_LITTLE_NAME "elf32-m32rle" 3861 3862 #define elf_info_to_howto m32r_info_to_howto 3863 #define elf_info_to_howto_rel m32r_info_to_howto_rel 3864 #define elf_backend_section_from_bfd_section _bfd_m32r_elf_section_from_bfd_section 3865 #define elf_backend_symbol_processing _bfd_m32r_elf_symbol_processing 3866 #define elf_backend_add_symbol_hook m32r_elf_add_symbol_hook 3867 #define elf_backend_relocate_section m32r_elf_relocate_section 3868 #define elf_backend_gc_mark_hook m32r_elf_gc_mark_hook 3869 #define elf_backend_check_relocs m32r_elf_check_relocs 3870 3871 #define elf_backend_create_dynamic_sections m32r_elf_create_dynamic_sections 3872 #define bfd_elf32_bfd_link_hash_table_create m32r_elf_link_hash_table_create 3873 #define elf_backend_size_dynamic_sections m32r_elf_size_dynamic_sections 3874 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all 3875 #define elf_backend_finish_dynamic_sections m32r_elf_finish_dynamic_sections 3876 #define elf_backend_adjust_dynamic_symbol m32r_elf_adjust_dynamic_symbol 3877 #define elf_backend_finish_dynamic_symbol m32r_elf_finish_dynamic_symbol 3878 #define elf_backend_reloc_type_class m32r_elf_reloc_type_class 3879 #define elf_backend_copy_indirect_symbol m32r_elf_copy_indirect_symbol 3880 3881 #define elf_backend_can_gc_sections 1 3882 /*#if !USE_REL 3883 #define elf_backend_rela_normal 1 3884 #endif*/ 3885 #define elf_backend_can_refcount 1 3886 #define elf_backend_want_got_plt 1 3887 #define elf_backend_plt_readonly 1 3888 #define elf_backend_want_plt_sym 0 3889 #define elf_backend_got_header_size 12 3890 #define elf_backend_dtrel_excludes_plt 1 3891 3892 #define elf_backend_may_use_rel_p 1 3893 #ifdef USE_M32R_OLD_RELOC 3894 #define elf_backend_default_use_rela_p 0 3895 #define elf_backend_may_use_rela_p 0 3896 #else 3897 #define elf_backend_default_use_rela_p 1 3898 #define elf_backend_may_use_rela_p 1 3899 #endif 3900 3901 #define elf_backend_object_p m32r_elf_object_p 3902 #define elf_backend_final_write_processing m32r_elf_final_write_processing 3903 #define bfd_elf32_bfd_merge_private_bfd_data m32r_elf_merge_private_bfd_data 3904 #define bfd_elf32_bfd_set_private_flags m32r_elf_set_private_flags 3905 #define bfd_elf32_bfd_print_private_bfd_data m32r_elf_print_private_bfd_data 3906 #define elf_backend_special_sections m32r_elf_special_sections 3907 3908 #define elf_backend_linux_prpsinfo32_ugid16 TRUE 3909 3910 #include "elf32-target.h" 3911 3912 #undef ELF_MAXPAGESIZE 3913 #define ELF_MAXPAGESIZE 0x1000 3914 3915 #undef TARGET_BIG_SYM 3916 #define TARGET_BIG_SYM m32r_elf32_linux_vec 3917 #undef TARGET_BIG_NAME 3918 #define TARGET_BIG_NAME "elf32-m32r-linux" 3919 #undef TARGET_LITTLE_SYM 3920 #define TARGET_LITTLE_SYM m32r_elf32_linux_le_vec 3921 #undef TARGET_LITTLE_NAME 3922 #define TARGET_LITTLE_NAME "elf32-m32rle-linux" 3923 #undef elf32_bed 3924 #define elf32_bed elf32_m32r_lin_bed 3925 3926 #include "elf32-target.h" 3927
Indexes created Tue Sep 15 00:24:42 UTC 2026