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