1/* 32-bit ELF support for ARM 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 3 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#ifndef USE_REL 22#define USE_REL 0 23#endif 24 25typedef unsigned long int insn32; 26typedef unsigned short int insn16; 27 28/* In lieu of proper flags, assume all EABIv4 objects are interworkable. */ 29#define INTERWORK_FLAG(abfd) \ 30 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) == EF_ARM_EABI_VER4 \ 31 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)) 32 33/* The linker script knows the section names for placement. 34 The entry_names are used to do simple name mangling on the stubs. 35 Given a function name, and its type, the stub can be found. The 36 name can be changed. The only requirement is the %s be present. */ 37#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t" 38#define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb" 39 40#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7" 41#define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm" 42 43/* The name of the dynamic interpreter. This is put in the .interp 44 section. */ 45#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 46 47#ifdef FOUR_WORD_PLT 48 49/* The first entry in a procedure linkage table looks like 50 this. It is set up so that any shared library function that is 51 called before the relocation has been set up calls the dynamic 52 linker first. */ 53static const bfd_vma elf32_arm_plt0_entry [] = 54 { 55 0xe52de004, /* str lr, [sp, #-4]! */ 56 0xe59fe010, /* ldr lr, [pc, #16] */ 57 0xe08fe00e, /* add lr, pc, lr */ 58 0xe5bef008, /* ldr pc, [lr, #8]! */ 59 }; 60 61/* Subsequent entries in a procedure linkage table look like 62 this. */ 63static const bfd_vma elf32_arm_plt_entry [] = 64 { 65 0xe28fc600, /* add ip, pc, #NN */ 66 0xe28cca00, /* add ip, ip, #NN */ 67 0xe5bcf000, /* ldr pc, [ip, #NN]! */ 68 0x00000000, /* unused */ 69 }; 70 71#else 72 73/* The first entry in a procedure linkage table looks like 74 this. It is set up so that any shared library function that is 75 called before the relocation has been set up calls the dynamic 76 linker first. */ 77static const bfd_vma elf32_arm_plt0_entry [] = 78 { 79 0xe52de004, /* str lr, [sp, #-4]! */ 80 0xe59fe004, /* ldr lr, [pc, #4] */ 81 0xe08fe00e, /* add lr, pc, lr */ 82 0xe5bef008, /* ldr pc, [lr, #8]! */ 83 0x00000000, /* &GOT[0] - . */ 84 }; 85 86/* Subsequent entries in a procedure linkage table look like 87 this. */ 88static const bfd_vma elf32_arm_plt_entry [] = 89 { 90 0xe28fc600, /* add ip, pc, #0xNN00000 */ 91 0xe28cca00, /* add ip, ip, #0xNN000 */ 92 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */ 93 }; 94 95#endif 96 97/* The entries in a PLT when using a DLL-based target with multiple 98 address spaces. */ 99static const bfd_vma elf32_arm_symbian_plt_entry [] = 100 { 101 0xe51ff004, /* ldr pr, [pc, #-4] */ 102 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */ 103 }; 104 105/* Used to build a map of a section. This is required for mixed-endian 106 code/data. */ 107 108typedef struct elf32_elf_section_map 109{ 110 bfd_vma vma; 111 char type; 112} 113elf32_arm_section_map; 114 115struct _arm_elf_section_data 116{ 117 struct bfd_elf_section_data elf; 118 int mapcount; 119 elf32_arm_section_map *map; 120}; 121 122#define elf32_arm_section_data(sec) \ 123 ((struct _arm_elf_section_data *) elf_section_data (sec)) 124 125/* The ARM linker needs to keep track of the number of relocs that it 126 decides to copy in check_relocs for each symbol. This is so that 127 it can discard PC relative relocs if it doesn't need them when 128 linking with -Bsymbolic. We store the information in a field 129 extending the regular ELF linker hash table. */ 130 131/* This structure keeps track of the number of PC relative relocs we 132 have copied for a given symbol. */ 133struct elf32_arm_relocs_copied 134 { 135 /* Next section. */ 136 struct elf32_arm_relocs_copied * next; 137 /* A section in dynobj. */ 138 asection * section; 139 /* Number of relocs copied in this section. */ 140 bfd_size_type count; 141 }; 142 143/* Arm ELF linker hash entry. */ 144struct elf32_arm_link_hash_entry 145 { 146 struct elf_link_hash_entry root; 147 148 /* Number of PC relative relocs copied for this symbol. */ 149 struct elf32_arm_relocs_copied * relocs_copied; 150 }; 151 152/* Traverse an arm ELF linker hash table. */ 153#define elf32_arm_link_hash_traverse(table, func, info) \ 154 (elf_link_hash_traverse \ 155 (&(table)->root, \ 156 (bfd_boolean (*) (struct elf_link_hash_entry *, void *))) (func), \ 157 (info))) 158 159/* Get the ARM elf linker hash table from a link_info structure. */ 160#define elf32_arm_hash_table(info) \ 161 ((struct elf32_arm_link_hash_table *) ((info)->hash)) 162 163/* ARM ELF linker hash table. */ 164struct elf32_arm_link_hash_table 165 { 166 /* The main hash table. */ 167 struct elf_link_hash_table root; 168 169 /* The size in bytes of the section containing the Thumb-to-ARM glue. */ 170 bfd_size_type thumb_glue_size; 171 172 /* The size in bytes of the section containing the ARM-to-Thumb glue. */ 173 bfd_size_type arm_glue_size; 174 175 /* An arbitrary input BFD chosen to hold the glue sections. */ 176 bfd * bfd_of_glue_owner; 177 178 /* A boolean indicating whether knowledge of the ARM's pipeline 179 length should be applied by the linker. */ 180 int no_pipeline_knowledge; 181 182 /* Nonzero to output a BE8 image. */ 183 int byteswap_code; 184 185 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32. 186 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */ 187 int target1_is_rel; 188 189 /* The relocation to use for R_ARM_TARGET2 relocations. */ 190 int target2_reloc; 191 192 /* The number of bytes in the initial entry in the PLT. */ 193 bfd_size_type plt_header_size; 194 195 /* The number of bytes in the subsequent PLT etries. */ 196 bfd_size_type plt_entry_size; 197 198 /* True if the target system is Symbian OS. */ 199 int symbian_p; 200 201 /* Short-cuts to get to dynamic linker sections. */ 202 asection *sgot; 203 asection *sgotplt; 204 asection *srelgot; 205 asection *splt; 206 asection *srelplt; 207 asection *sdynbss; 208 asection *srelbss; 209 210 /* Small local sym to section mapping cache. */ 211 struct sym_sec_cache sym_sec; 212 }; 213 214/* Create an entry in an ARM ELF linker hash table. */ 215 216static struct bfd_hash_entry * 217elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry, 218 struct bfd_hash_table * table, 219 const char * string) 220{ 221 struct elf32_arm_link_hash_entry * ret = 222 (struct elf32_arm_link_hash_entry *) entry; 223 224 /* Allocate the structure if it has not already been allocated by a 225 subclass. */ 226 if (ret == (struct elf32_arm_link_hash_entry *) NULL) 227 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry)); 228 if (ret == NULL) 229 return (struct bfd_hash_entry *) ret; 230 231 /* Call the allocation method of the superclass. */ 232 ret = ((struct elf32_arm_link_hash_entry *) 233 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 234 table, string)); 235 if (ret != NULL) 236 ret->relocs_copied = NULL; 237 238 return (struct bfd_hash_entry *) ret; 239} 240 241/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up 242 shortcuts to them in our hash table. */ 243 244static bfd_boolean 245create_got_section (bfd *dynobj, struct bfd_link_info *info) 246{ 247 struct elf32_arm_link_hash_table *htab; 248 249 htab = elf32_arm_hash_table (info); 250 /* BPABI objects never have a GOT, or associated sections. */ 251 if (htab->symbian_p) 252 return TRUE; 253 254 if (! _bfd_elf_create_got_section (dynobj, info)) 255 return FALSE; 256 257 htab->sgot = bfd_get_section_by_name (dynobj, ".got"); 258 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt"); 259 if (!htab->sgot || !htab->sgotplt) 260 abort (); 261 262 htab->srelgot = bfd_make_section (dynobj, ".rel.got"); 263 if (htab->srelgot == NULL 264 || ! bfd_set_section_flags (dynobj, htab->srelgot, 265 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 266 | SEC_IN_MEMORY | SEC_LINKER_CREATED 267 | SEC_READONLY)) 268 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2)) 269 return FALSE; 270 return TRUE; 271} 272 273/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and 274 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our 275 hash table. */ 276 277static bfd_boolean 278elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info) 279{ 280 struct elf32_arm_link_hash_table *htab; 281 282 htab = elf32_arm_hash_table (info); 283 if (!htab->sgot && !create_got_section (dynobj, info)) 284 return FALSE; 285 286 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 287 return FALSE; 288 289 htab->splt = bfd_get_section_by_name (dynobj, ".plt"); 290 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt"); 291 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss"); 292 if (!info->shared) 293 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss"); 294 295 if (!htab->splt 296 || !htab->srelplt 297 || !htab->sdynbss 298 || (!info->shared && !htab->srelbss)) 299 abort (); 300 301 return TRUE; 302} 303 304/* Copy the extra info we tack onto an elf_link_hash_entry. */ 305 306static void 307elf32_arm_copy_indirect_symbol (const struct elf_backend_data *bed, 308 struct elf_link_hash_entry *dir, 309 struct elf_link_hash_entry *ind) 310{ 311 struct elf32_arm_link_hash_entry *edir, *eind; 312 313 edir = (struct elf32_arm_link_hash_entry *) dir; 314 eind = (struct elf32_arm_link_hash_entry *) ind; 315 316 if (eind->relocs_copied != NULL) 317 { 318 if (edir->relocs_copied != NULL) 319 { 320 struct elf32_arm_relocs_copied **pp; 321 struct elf32_arm_relocs_copied *p; 322 323 if (ind->root.type == bfd_link_hash_indirect) 324 abort (); 325 326 /* Add reloc counts against the weak sym to the strong sym 327 list. Merge any entries against the same section. */ 328 for (pp = &eind->relocs_copied; (p = *pp) != NULL; ) 329 { 330 struct elf32_arm_relocs_copied *q; 331 332 for (q = edir->relocs_copied; q != NULL; q = q->next) 333 if (q->section == p->section) 334 { 335 q->count += p->count; 336 *pp = p->next; 337 break; 338 } 339 if (q == NULL) 340 pp = &p->next; 341 } 342 *pp = edir->relocs_copied; 343 } 344 345 edir->relocs_copied = eind->relocs_copied; 346 eind->relocs_copied = NULL; 347 } 348 349 _bfd_elf_link_hash_copy_indirect (bed, dir, ind); 350} 351 352/* Create an ARM elf linker hash table. */ 353 354static struct bfd_link_hash_table * 355elf32_arm_link_hash_table_create (bfd *abfd) 356{ 357 struct elf32_arm_link_hash_table *ret; 358 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table); 359 360 ret = bfd_malloc (amt); 361 if (ret == NULL) 362 return NULL; 363 364 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd, 365 elf32_arm_link_hash_newfunc)) 366 { 367 free (ret); 368 return NULL; 369 } 370 371 ret->sgot = NULL; 372 ret->sgotplt = NULL; 373 ret->srelgot = NULL; 374 ret->splt = NULL; 375 ret->srelplt = NULL; 376 ret->sdynbss = NULL; 377 ret->srelbss = NULL; 378 ret->thumb_glue_size = 0; 379 ret->arm_glue_size = 0; 380 ret->bfd_of_glue_owner = NULL; 381 ret->no_pipeline_knowledge = 0; 382 ret->byteswap_code = 0; 383 ret->target1_is_rel = 0; 384 ret->target2_reloc = R_ARM_NONE; 385#ifdef FOUR_WORD_PLT 386 ret->plt_header_size = 16; 387 ret->plt_entry_size = 16; 388#else 389 ret->plt_header_size = 20; 390 ret->plt_entry_size = 12; 391#endif 392 ret->symbian_p = 0; 393 ret->sym_sec.abfd = NULL; 394 395 return &ret->root.root; 396} 397 398/* Locate the Thumb encoded calling stub for NAME. */ 399 400static struct elf_link_hash_entry * 401find_thumb_glue (struct bfd_link_info *link_info, 402 const char *name, 403 bfd *input_bfd) 404{ 405 char *tmp_name; 406 struct elf_link_hash_entry *hash; 407 struct elf32_arm_link_hash_table *hash_table; 408 409 /* We need a pointer to the armelf specific hash table. */ 410 hash_table = elf32_arm_hash_table (link_info); 411 412 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) 413 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1); 414 415 BFD_ASSERT (tmp_name); 416 417 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name); 418 419 hash = elf_link_hash_lookup 420 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE); 421 422 if (hash == NULL) 423 /* xgettext:c-format */ 424 (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"), 425 input_bfd, tmp_name, name); 426 427 free (tmp_name); 428 429 return hash; 430} 431 432/* Locate the ARM encoded calling stub for NAME. */ 433 434static struct elf_link_hash_entry * 435find_arm_glue (struct bfd_link_info *link_info, 436 const char *name, 437 bfd *input_bfd) 438{ 439 char *tmp_name; 440 struct elf_link_hash_entry *myh; 441 struct elf32_arm_link_hash_table *hash_table; 442 443 /* We need a pointer to the elfarm specific hash table. */ 444 hash_table = elf32_arm_hash_table (link_info); 445 446 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) 447 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1); 448 449 BFD_ASSERT (tmp_name); 450 451 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name); 452 453 myh = elf_link_hash_lookup 454 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE); 455 456 if (myh == NULL) 457 /* xgettext:c-format */ 458 (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"), 459 input_bfd, tmp_name, name); 460 461 free (tmp_name); 462 463 return myh; 464} 465 466/* ARM->Thumb glue: 467 468 .arm 469 __func_from_arm: 470 ldr r12, __func_addr 471 bx r12 472 __func_addr: 473 .word func @ behave as if you saw a ARM_32 reloc. */ 474 475#define ARM2THUMB_GLUE_SIZE 12 476static const insn32 a2t1_ldr_insn = 0xe59fc000; 477static const insn32 a2t2_bx_r12_insn = 0xe12fff1c; 478static const insn32 a2t3_func_addr_insn = 0x00000001; 479 480/* Thumb->ARM: Thumb->(non-interworking aware) ARM 481 482 .thumb .thumb 483 .align 2 .align 2 484 __func_from_thumb: __func_from_thumb: 485 bx pc push {r6, lr} 486 nop ldr r6, __func_addr 487 .arm mov lr, pc 488 __func_change_to_arm: bx r6 489 b func .arm 490 __func_back_to_thumb: 491 ldmia r13! {r6, lr} 492 bx lr 493 __func_addr: 494 .word func */ 495 496#define THUMB2ARM_GLUE_SIZE 8 497static const insn16 t2a1_bx_pc_insn = 0x4778; 498static const insn16 t2a2_noop_insn = 0x46c0; 499static const insn32 t2a3_b_insn = 0xea000000; 500 501#ifndef ELFARM_NABI_C_INCLUDED 502bfd_boolean 503bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info) 504{ 505 asection * s; 506 bfd_byte * foo; 507 struct elf32_arm_link_hash_table * globals; 508 509 globals = elf32_arm_hash_table (info); 510 511 BFD_ASSERT (globals != NULL); 512 513 if (globals->arm_glue_size != 0) 514 { 515 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 516 517 s = bfd_get_section_by_name (globals->bfd_of_glue_owner, 518 ARM2THUMB_GLUE_SECTION_NAME); 519 520 BFD_ASSERT (s != NULL); 521 522 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size); 523 524 s->size = globals->arm_glue_size; 525 s->contents = foo; 526 } 527 528 if (globals->thumb_glue_size != 0) 529 { 530 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 531 532 s = bfd_get_section_by_name 533 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME); 534 535 BFD_ASSERT (s != NULL); 536 537 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size); 538 539 s->size = globals->thumb_glue_size; 540 s->contents = foo; 541 } 542 543 return TRUE; 544} 545 546static void 547record_arm_to_thumb_glue (struct bfd_link_info * link_info, 548 struct elf_link_hash_entry * h) 549{ 550 const char * name = h->root.root.string; 551 asection * s; 552 char * tmp_name; 553 struct elf_link_hash_entry * myh; 554 struct bfd_link_hash_entry * bh; 555 struct elf32_arm_link_hash_table * globals; 556 bfd_vma val; 557 558 globals = elf32_arm_hash_table (link_info); 559 560 BFD_ASSERT (globals != NULL); 561 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 562 563 s = bfd_get_section_by_name 564 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME); 565 566 BFD_ASSERT (s != NULL); 567 568 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1); 569 570 BFD_ASSERT (tmp_name); 571 572 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name); 573 574 myh = elf_link_hash_lookup 575 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE); 576 577 if (myh != NULL) 578 { 579 /* We've already seen this guy. */ 580 free (tmp_name); 581 return; 582 } 583 584 /* The only trick here is using hash_table->arm_glue_size as the value. 585 Even though the section isn't allocated yet, this is where we will be 586 putting it. */ 587 bh = NULL; 588 val = globals->arm_glue_size + 1; 589 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner, 590 tmp_name, BSF_GLOBAL, s, val, 591 NULL, TRUE, FALSE, &bh); 592 593 free (tmp_name); 594 595 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE; 596 597 return; 598} 599 600static void 601record_thumb_to_arm_glue (struct bfd_link_info *link_info, 602 struct elf_link_hash_entry *h) 603{ 604 const char *name = h->root.root.string; 605 asection *s; 606 char *tmp_name; 607 struct elf_link_hash_entry *myh; 608 struct bfd_link_hash_entry *bh; 609 struct elf32_arm_link_hash_table *hash_table; 610 char bind; 611 bfd_vma val; 612 613 hash_table = elf32_arm_hash_table (link_info); 614 615 BFD_ASSERT (hash_table != NULL); 616 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL); 617 618 s = bfd_get_section_by_name 619 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME); 620 621 BFD_ASSERT (s != NULL); 622 623 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) 624 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1); 625 626 BFD_ASSERT (tmp_name); 627 628 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name); 629 630 myh = elf_link_hash_lookup 631 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE); 632 633 if (myh != NULL) 634 { 635 /* We've already seen this guy. */ 636 free (tmp_name); 637 return; 638 } 639 640 bh = NULL; 641 val = hash_table->thumb_glue_size + 1; 642 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, 643 tmp_name, BSF_GLOBAL, s, val, 644 NULL, TRUE, FALSE, &bh); 645 646 /* If we mark it 'Thumb', the disassembler will do a better job. */ 647 myh = (struct elf_link_hash_entry *) bh; 648 bind = ELF_ST_BIND (myh->type); 649 myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC); 650 651 free (tmp_name); 652 653#define CHANGE_TO_ARM "__%s_change_to_arm" 654#define BACK_FROM_ARM "__%s_back_from_arm" 655 656 /* Allocate another symbol to mark where we switch to Arm mode. */ 657 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) 658 + strlen (CHANGE_TO_ARM) + 1); 659 660 BFD_ASSERT (tmp_name); 661 662 sprintf (tmp_name, CHANGE_TO_ARM, name); 663 664 bh = NULL; 665 val = hash_table->thumb_glue_size + 4, 666 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, 667 tmp_name, BSF_LOCAL, s, val, 668 NULL, TRUE, FALSE, &bh); 669 670 free (tmp_name); 671 672 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE; 673 674 return; 675} 676 677/* Add the glue sections to ABFD. This function is called from the 678 linker scripts in ld/emultempl/{armelf}.em. */ 679 680bfd_boolean 681bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd, 682 struct bfd_link_info *info) 683{ 684 flagword flags; 685 asection *sec; 686 687 /* If we are only performing a partial 688 link do not bother adding the glue. */ 689 if (info->relocatable) 690 return TRUE; 691 692 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME); 693 694 if (sec == NULL) 695 { 696 /* Note: we do not include the flag SEC_LINKER_CREATED, as this 697 will prevent elf_link_input_bfd() from processing the contents 698 of this section. */ 699 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY; 700 701 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME); 702 703 if (sec == NULL 704 || !bfd_set_section_flags (abfd, sec, flags) 705 || !bfd_set_section_alignment (abfd, sec, 2)) 706 return FALSE; 707 708 /* Set the gc mark to prevent the section from being removed by garbage 709 collection, despite the fact that no relocs refer to this section. */ 710 sec->gc_mark = 1; 711 } 712 713 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME); 714 715 if (sec == NULL) 716 { 717 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 718 | SEC_CODE | SEC_READONLY; 719 720 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME); 721 722 if (sec == NULL 723 || !bfd_set_section_flags (abfd, sec, flags) 724 || !bfd_set_section_alignment (abfd, sec, 2)) 725 return FALSE; 726 727 sec->gc_mark = 1; 728 } 729 730 return TRUE; 731} 732 733/* Select a BFD to be used to hold the sections used by the glue code. 734 This function is called from the linker scripts in ld/emultempl/ 735 {armelf/pe}.em */ 736 737bfd_boolean 738bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info) 739{ 740 struct elf32_arm_link_hash_table *globals; 741 742 /* If we are only performing a partial link 743 do not bother getting a bfd to hold the glue. */ 744 if (info->relocatable) 745 return TRUE; 746 747 globals = elf32_arm_hash_table (info); 748 749 BFD_ASSERT (globals != NULL); 750 751 if (globals->bfd_of_glue_owner != NULL) 752 return TRUE; 753 754 /* Save the bfd for later use. */ 755 globals->bfd_of_glue_owner = abfd; 756 757 return TRUE; 758} 759 760bfd_boolean 761bfd_elf32_arm_process_before_allocation (bfd *abfd, 762 struct bfd_link_info *link_info, 763 int no_pipeline_knowledge, 764 int byteswap_code) 765{ 766 Elf_Internal_Shdr *symtab_hdr; 767 Elf_Internal_Rela *internal_relocs = NULL; 768 Elf_Internal_Rela *irel, *irelend; 769 bfd_byte *contents = NULL; 770 771 asection *sec; 772 struct elf32_arm_link_hash_table *globals; 773 774 /* If we are only performing a partial link do not bother 775 to construct any glue. */ 776 if (link_info->relocatable) 777 return TRUE; 778 779 /* Here we have a bfd that is to be included on the link. We have a hook 780 to do reloc rummaging, before section sizes are nailed down. */ 781 globals = elf32_arm_hash_table (link_info); 782 783 BFD_ASSERT (globals != NULL); 784 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 785 786 globals->no_pipeline_knowledge = no_pipeline_knowledge; 787 788 if (byteswap_code && !bfd_big_endian (abfd)) 789 { 790 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."), 791 abfd); 792 return FALSE; 793 } 794 globals->byteswap_code = byteswap_code; 795 796 /* Rummage around all the relocs and map the glue vectors. */ 797 sec = abfd->sections; 798 799 if (sec == NULL) 800 return TRUE; 801 802 for (; sec != NULL; sec = sec->next) 803 { 804 if (sec->reloc_count == 0) 805 continue; 806 807 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 808 809 /* Load the relocs. */ 810 internal_relocs 811 = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL, 812 (Elf_Internal_Rela *) NULL, FALSE); 813 814 if (internal_relocs == NULL) 815 goto error_return; 816 817 irelend = internal_relocs + sec->reloc_count; 818 for (irel = internal_relocs; irel < irelend; irel++) 819 { 820 long r_type; 821 unsigned long r_index; 822 823 struct elf_link_hash_entry *h; 824 825 r_type = ELF32_R_TYPE (irel->r_info); 826 r_index = ELF32_R_SYM (irel->r_info); 827 828 /* These are the only relocation types we care about. */ 829 if ( r_type != R_ARM_PC24 830 && r_type != R_ARM_THM_PC22) 831 continue; 832 833 /* Get the section contents if we haven't done so already. */ 834 if (contents == NULL) 835 { 836 /* Get cached copy if it exists. */ 837 if (elf_section_data (sec)->this_hdr.contents != NULL) 838 contents = elf_section_data (sec)->this_hdr.contents; 839 else 840 { 841 /* Go get them off disk. */ 842 if (! bfd_malloc_and_get_section (abfd, sec, &contents)) 843 goto error_return; 844 } 845 } 846 847 /* If the relocation is not against a symbol it cannot concern us. */ 848 h = NULL; 849 850 /* We don't care about local symbols. */ 851 if (r_index < symtab_hdr->sh_info) 852 continue; 853 854 /* This is an external symbol. */ 855 r_index -= symtab_hdr->sh_info; 856 h = (struct elf_link_hash_entry *) 857 elf_sym_hashes (abfd)[r_index]; 858 859 /* If the relocation is against a static symbol it must be within 860 the current section and so cannot be a cross ARM/Thumb relocation. */ 861 if (h == NULL) 862 continue; 863 864 switch (r_type) 865 { 866 case R_ARM_PC24: 867 /* This one is a call from arm code. We need to look up 868 the target of the call. If it is a thumb target, we 869 insert glue. */ 870 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC) 871 record_arm_to_thumb_glue (link_info, h); 872 break; 873 874 case R_ARM_THM_PC22: 875 /* This one is a call from thumb code. We look 876 up the target of the call. If it is not a thumb 877 target, we insert glue. */ 878 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC) 879 record_thumb_to_arm_glue (link_info, h); 880 break; 881 882 default: 883 break; 884 } 885 } 886 887 if (contents != NULL 888 && elf_section_data (sec)->this_hdr.contents != contents) 889 free (contents); 890 contents = NULL; 891 892 if (internal_relocs != NULL 893 && elf_section_data (sec)->relocs != internal_relocs) 894 free (internal_relocs); 895 internal_relocs = NULL; 896 } 897 898 return TRUE; 899 900error_return: 901 if (contents != NULL 902 && elf_section_data (sec)->this_hdr.contents != contents) 903 free (contents); 904 if (internal_relocs != NULL 905 && elf_section_data (sec)->relocs != internal_relocs) 906 free (internal_relocs); 907 908 return FALSE; 909} 910#endif 911 912 913#ifndef OLD_ARM_ABI 914/* Set target relocation values needed during linking. */ 915 916void 917bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info, 918 int target1_is_rel, 919 char * target2_type) 920{ 921 struct elf32_arm_link_hash_table *globals; 922 923 globals = elf32_arm_hash_table (link_info); 924 925 globals->target1_is_rel = target1_is_rel; 926 if (strcmp (target2_type, "rel") == 0) 927 globals->target2_reloc = R_ARM_REL32; 928 else if (strcmp (target2_type, "abs") == 0) 929 globals->target2_reloc = R_ARM_ABS32; 930 else if (strcmp (target2_type, "got-rel") == 0) 931 globals->target2_reloc = R_ARM_GOT_PREL; 932 else 933 { 934 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."), 935 target2_type); 936 } 937} 938#endif 939 940/* The thumb form of a long branch is a bit finicky, because the offset 941 encoding is split over two fields, each in it's own instruction. They 942 can occur in any order. So given a thumb form of long branch, and an 943 offset, insert the offset into the thumb branch and return finished 944 instruction. 945 946 It takes two thumb instructions to encode the target address. Each has 947 11 bits to invest. The upper 11 bits are stored in one (identified by 948 H-0.. see below), the lower 11 bits are stored in the other (identified 949 by H-1). 950 951 Combine together and shifted left by 1 (it's a half word address) and 952 there you have it. 953 954 Op: 1111 = F, 955 H-0, upper address-0 = 000 956 Op: 1111 = F, 957 H-1, lower address-0 = 800 958 959 They can be ordered either way, but the arm tools I've seen always put 960 the lower one first. It probably doesn't matter. krk@cygnus.com 961 962 XXX: Actually the order does matter. The second instruction (H-1) 963 moves the computed address into the PC, so it must be the second one 964 in the sequence. The problem, however is that whilst little endian code 965 stores the instructions in HI then LOW order, big endian code does the 966 reverse. nickc@cygnus.com. */ 967 968#define LOW_HI_ORDER 0xF800F000 969#define HI_LOW_ORDER 0xF000F800 970 971static insn32 972insert_thumb_branch (insn32 br_insn, int rel_off) 973{ 974 unsigned int low_bits; 975 unsigned int high_bits; 976 977 BFD_ASSERT ((rel_off & 1) != 1); 978 979 rel_off >>= 1; /* Half word aligned address. */ 980 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */ 981 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */ 982 983 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER) 984 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits; 985 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER) 986 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits; 987 else 988 /* FIXME: abort is probably not the right call. krk@cygnus.com */ 989 abort (); /* Error - not a valid branch instruction form. */ 990 991 return br_insn; 992} 993 994/* Thumb code calling an ARM function. */ 995 996static int 997elf32_thumb_to_arm_stub (struct bfd_link_info * info, 998 const char * name, 999 bfd * input_bfd, 1000 bfd * output_bfd, 1001 asection * input_section, 1002 bfd_byte * hit_data, 1003 asection * sym_sec, 1004 bfd_vma offset, 1005 bfd_signed_vma addend, 1006 bfd_vma val) 1007{ 1008 asection * s = 0; 1009 bfd_vma my_offset; 1010 unsigned long int tmp; 1011 long int ret_offset; 1012 struct elf_link_hash_entry * myh; 1013 struct elf32_arm_link_hash_table * globals; 1014 1015 myh = find_thumb_glue (info, name, input_bfd); 1016 if (myh == NULL) 1017 return FALSE; 1018 1019 globals = elf32_arm_hash_table (info); 1020 1021 BFD_ASSERT (globals != NULL); 1022 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 1023 1024 my_offset = myh->root.u.def.value; 1025 1026 s = bfd_get_section_by_name (globals->bfd_of_glue_owner, 1027 THUMB2ARM_GLUE_SECTION_NAME); 1028 1029 BFD_ASSERT (s != NULL); 1030 BFD_ASSERT (s->contents != NULL); 1031 BFD_ASSERT (s->output_section != NULL); 1032 1033 if ((my_offset & 0x01) == 0x01) 1034 { 1035 if (sym_sec != NULL 1036 && sym_sec->owner != NULL 1037 && !INTERWORK_FLAG (sym_sec->owner)) 1038 { 1039 (*_bfd_error_handler) 1040 (_("%B(%s): warning: interworking not enabled.\n" 1041 " first occurrence: %B: thumb call to arm"), 1042 sym_sec->owner, input_bfd, name); 1043 1044 return FALSE; 1045 } 1046 1047 --my_offset; 1048 myh->root.u.def.value = my_offset; 1049 1050 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn, 1051 s->contents + my_offset); 1052 1053 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn, 1054 s->contents + my_offset + 2); 1055 1056 ret_offset = 1057 /* Address of destination of the stub. */ 1058 ((bfd_signed_vma) val) 1059 - ((bfd_signed_vma) 1060 /* Offset from the start of the current section 1061 to the start of the stubs. */ 1062 (s->output_offset 1063 /* Offset of the start of this stub from the start of the stubs. */ 1064 + my_offset 1065 /* Address of the start of the current section. */ 1066 + s->output_section->vma) 1067 /* The branch instruction is 4 bytes into the stub. */ 1068 + 4 1069 /* ARM branches work from the pc of the instruction + 8. */ 1070 + 8); 1071 1072 bfd_put_32 (output_bfd, 1073 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF), 1074 s->contents + my_offset + 4); 1075 } 1076 1077 BFD_ASSERT (my_offset <= globals->thumb_glue_size); 1078 1079 /* Now go back and fix up the original BL insn to point to here. */ 1080 ret_offset = 1081 /* Address of where the stub is located. */ 1082 (s->output_section->vma + s->output_offset + my_offset) 1083 /* Address of where the BL is located. */ 1084 - (input_section->output_section->vma + input_section->output_offset 1085 + offset) 1086 /* Addend in the relocation. */ 1087 - addend 1088 /* Biassing for PC-relative addressing. */ 1089 - 8; 1090 1091 tmp = bfd_get_32 (input_bfd, hit_data 1092 - input_section->vma); 1093 1094 bfd_put_32 (output_bfd, 1095 (bfd_vma) insert_thumb_branch (tmp, ret_offset), 1096 hit_data - input_section->vma); 1097 1098 return TRUE; 1099} 1100 1101/* Arm code calling a Thumb function. */ 1102 1103static int 1104elf32_arm_to_thumb_stub (struct bfd_link_info * info, 1105 const char * name, 1106 bfd * input_bfd, 1107 bfd * output_bfd, 1108 asection * input_section, 1109 bfd_byte * hit_data, 1110 asection * sym_sec, 1111 bfd_vma offset, 1112 bfd_signed_vma addend, 1113 bfd_vma val) 1114{ 1115 unsigned long int tmp; 1116 bfd_vma my_offset; 1117 asection * s; 1118 long int ret_offset; 1119 struct elf_link_hash_entry * myh; 1120 struct elf32_arm_link_hash_table * globals; 1121 1122 myh = find_arm_glue (info, name, input_bfd); 1123 if (myh == NULL) 1124 return FALSE; 1125 1126 globals = elf32_arm_hash_table (info); 1127 1128 BFD_ASSERT (globals != NULL); 1129 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 1130 1131 my_offset = myh->root.u.def.value; 1132 s = bfd_get_section_by_name (globals->bfd_of_glue_owner, 1133 ARM2THUMB_GLUE_SECTION_NAME); 1134 BFD_ASSERT (s != NULL); 1135 BFD_ASSERT (s->contents != NULL); 1136 BFD_ASSERT (s->output_section != NULL); 1137 1138 if ((my_offset & 0x01) == 0x01) 1139 { 1140 if (sym_sec != NULL 1141 && sym_sec->owner != NULL 1142 && !INTERWORK_FLAG (sym_sec->owner)) 1143 { 1144 (*_bfd_error_handler) 1145 (_("%B(%s): warning: interworking not enabled.\n" 1146 " first occurrence: %B: arm call to thumb"), 1147 sym_sec->owner, input_bfd, name); 1148 } 1149 1150 --my_offset; 1151 myh->root.u.def.value = my_offset; 1152 1153 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn, 1154 s->contents + my_offset); 1155 1156 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn, 1157 s->contents + my_offset + 4); 1158 1159 /* It's a thumb address. Add the low order bit. */ 1160 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn, 1161 s->contents + my_offset + 8); 1162 } 1163 1164 BFD_ASSERT (my_offset <= globals->arm_glue_size); 1165 1166 tmp = bfd_get_32 (input_bfd, hit_data); 1167 tmp = tmp & 0xFF000000; 1168 1169 /* Somehow these are both 4 too far, so subtract 8. */ 1170 ret_offset = (s->output_offset 1171 + my_offset 1172 + s->output_section->vma 1173 - (input_section->output_offset 1174 + input_section->output_section->vma 1175 + offset + addend) 1176 - 8); 1177 1178 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF); 1179 1180 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma); 1181 1182 return TRUE; 1183} 1184 1185 1186#ifndef OLD_ARM_ABI 1187/* Some relocations map to different relocations depending on the 1188 target. Return the real relocation. */ 1189static int 1190arm_real_reloc_type (struct elf32_arm_link_hash_table * globals, 1191 int r_type) 1192{ 1193 switch (r_type) 1194 { 1195 case R_ARM_TARGET1: 1196 if (globals->target1_is_rel) 1197 return R_ARM_REL32; 1198 else 1199 return R_ARM_ABS32; 1200 1201 case R_ARM_TARGET2: 1202 return globals->target2_reloc; 1203 1204 default: 1205 return r_type; 1206 } 1207} 1208#endif /* OLD_ARM_ABI */ 1209 1210 1211/* Perform a relocation as part of a final link. */ 1212 1213static bfd_reloc_status_type 1214elf32_arm_final_link_relocate (reloc_howto_type * howto, 1215 bfd * input_bfd, 1216 bfd * output_bfd, 1217 asection * input_section, 1218 bfd_byte * contents, 1219 Elf_Internal_Rela * rel, 1220 bfd_vma value, 1221 struct bfd_link_info * info, 1222 asection * sym_sec, 1223 const char * sym_name, 1224 int sym_flags, 1225 struct elf_link_hash_entry * h) 1226{ 1227 unsigned long r_type = howto->type; 1228 unsigned long r_symndx; 1229 bfd_byte * hit_data = contents + rel->r_offset; 1230 bfd * dynobj = NULL; 1231 Elf_Internal_Shdr * symtab_hdr; 1232 struct elf_link_hash_entry ** sym_hashes; 1233 bfd_vma * local_got_offsets; 1234 asection * sgot = NULL; 1235 asection * splt = NULL; 1236 asection * sreloc = NULL; 1237 bfd_vma addend; 1238 bfd_signed_vma signed_addend; 1239 struct elf32_arm_link_hash_table * globals; 1240 1241 globals = elf32_arm_hash_table (info); 1242 1243#ifndef OLD_ARM_ABI 1244 /* Some relocation type map to different relocations depending on the 1245 target. We pick the right one here. */ 1246 r_type = arm_real_reloc_type (globals, r_type); 1247 if (r_type != howto->type) 1248 howto = elf32_arm_howto_from_type (r_type); 1249#endif /* OLD_ARM_ABI */ 1250 1251 /* If the start address has been set, then set the EF_ARM_HASENTRY 1252 flag. Setting this more than once is redundant, but the cost is 1253 not too high, and it keeps the code simple. 1254 1255 The test is done here, rather than somewhere else, because the 1256 start address is only set just before the final link commences. 1257 1258 Note - if the user deliberately sets a start address of 0, the 1259 flag will not be set. */ 1260 if (bfd_get_start_address (output_bfd) != 0) 1261 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY; 1262 1263 dynobj = elf_hash_table (info)->dynobj; 1264 if (dynobj) 1265 { 1266 sgot = bfd_get_section_by_name (dynobj, ".got"); 1267 splt = bfd_get_section_by_name (dynobj, ".plt"); 1268 } 1269 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 1270 sym_hashes = elf_sym_hashes (input_bfd); 1271 local_got_offsets = elf_local_got_offsets (input_bfd); 1272 r_symndx = ELF32_R_SYM (rel->r_info); 1273 1274#if USE_REL 1275 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask; 1276 1277 if (addend & ((howto->src_mask + 1) >> 1)) 1278 { 1279 signed_addend = -1; 1280 signed_addend &= ~ howto->src_mask; 1281 signed_addend |= addend; 1282 } 1283 else 1284 signed_addend = addend; 1285#else 1286 addend = signed_addend = rel->r_addend; 1287#endif 1288 1289 switch (r_type) 1290 { 1291 case R_ARM_NONE: 1292 return bfd_reloc_ok; 1293 1294 case R_ARM_PC24: 1295 case R_ARM_ABS32: 1296 case R_ARM_REL32: 1297#ifndef OLD_ARM_ABI 1298 case R_ARM_XPC25: 1299 case R_ARM_PREL31: 1300#endif 1301 case R_ARM_PLT32: 1302 /* r_symndx will be zero only for relocs against symbols 1303 from removed linkonce sections, or sections discarded by 1304 a linker script. */ 1305 if (r_symndx == 0) 1306 return bfd_reloc_ok; 1307 1308 /* Handle relocations which should use the PLT entry. ABS32/REL32 1309 will use the symbol's value, which may point to a PLT entry, but we 1310 don't need to handle that here. If we created a PLT entry, all 1311 branches in this object should go to it. */ 1312 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32 1313#ifndef OLD_ARM_ABI 1314 && r_type != R_ARM_PREL31 1315#endif 1316 ) 1317 && h != NULL 1318 && splt != NULL 1319 && h->plt.offset != (bfd_vma) -1) 1320 { 1321 /* If we've created a .plt section, and assigned a PLT entry to 1322 this function, it should not be known to bind locally. If 1323 it were, we would have cleared the PLT entry. */ 1324 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h)); 1325 1326 value = (splt->output_section->vma 1327 + splt->output_offset 1328 + h->plt.offset); 1329 return _bfd_final_link_relocate (howto, input_bfd, input_section, 1330 contents, rel->r_offset, value, 1331 (bfd_vma) 0); 1332 } 1333 1334 /* When generating a shared object, these relocations are copied 1335 into the output file to be resolved at run time. */ 1336 if (info->shared 1337 && (input_section->flags & SEC_ALLOC) 1338 && ((r_type != R_ARM_REL32 1339#ifndef OLD_ARM_ABI 1340 && r_type != R_ARM_PREL31 1341#endif 1342 ) || !SYMBOL_CALLS_LOCAL (info, h)) 1343 && (h == NULL 1344 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1345 || h->root.type != bfd_link_hash_undefweak) 1346 && r_type != R_ARM_PC24 1347 && r_type != R_ARM_PLT32) 1348 { 1349 Elf_Internal_Rela outrel; 1350 bfd_byte *loc; 1351 bfd_boolean skip, relocate; 1352 1353 if (sreloc == NULL) 1354 { 1355 const char * name; 1356 1357 name = (bfd_elf_string_from_elf_section 1358 (input_bfd, 1359 elf_elfheader (input_bfd)->e_shstrndx, 1360 elf_section_data (input_section)->rel_hdr.sh_name)); 1361 if (name == NULL) 1362 return bfd_reloc_notsupported; 1363 1364 BFD_ASSERT (strncmp (name, ".rel", 4) == 0 1365 && strcmp (bfd_get_section_name (input_bfd, 1366 input_section), 1367 name + 4) == 0); 1368 1369 sreloc = bfd_get_section_by_name (dynobj, name); 1370 BFD_ASSERT (sreloc != NULL); 1371 } 1372 1373 skip = FALSE; 1374 relocate = FALSE; 1375 1376 outrel.r_offset = 1377 _bfd_elf_section_offset (output_bfd, info, input_section, 1378 rel->r_offset); 1379 if (outrel.r_offset == (bfd_vma) -1) 1380 skip = TRUE; 1381 else if (outrel.r_offset == (bfd_vma) -2) 1382 skip = TRUE, relocate = TRUE; 1383 outrel.r_offset += (input_section->output_section->vma 1384 + input_section->output_offset); 1385 1386 if (skip) 1387 memset (&outrel, 0, sizeof outrel); 1388 else if (h != NULL 1389 && h->dynindx != -1 1390 && (!info->shared 1391 || !info->symbolic 1392 || !h->def_regular)) 1393 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1394 else 1395 { 1396 /* This symbol is local, or marked to become local. */ 1397 relocate = TRUE; 1398 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); 1399 } 1400 1401 loc = sreloc->contents; 1402 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel); 1403 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); 1404 1405 /* If this reloc is against an external symbol, we do not want to 1406 fiddle with the addend. Otherwise, we need to include the symbol 1407 value so that it becomes an addend for the dynamic reloc. */ 1408 if (! relocate) 1409 return bfd_reloc_ok; 1410 1411 return _bfd_final_link_relocate (howto, input_bfd, input_section, 1412 contents, rel->r_offset, value, 1413 (bfd_vma) 0); 1414 } 1415 else switch (r_type) 1416 { 1417#ifndef OLD_ARM_ABI 1418 case R_ARM_XPC25: /* Arm BLX instruction. */ 1419#endif 1420 case R_ARM_PC24: /* Arm B/BL instruction */ 1421 case R_ARM_PLT32: 1422#ifndef OLD_ARM_ABI 1423 if (r_type == R_ARM_XPC25) 1424 { 1425 /* Check for Arm calling Arm function. */ 1426 /* FIXME: Should we translate the instruction into a BL 1427 instruction instead ? */ 1428 if (sym_flags != STT_ARM_TFUNC) 1429 (*_bfd_error_handler) 1430 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."), 1431 input_bfd, 1432 h ? h->root.root.string : "(local)"); 1433 } 1434 else 1435#endif 1436 { 1437 /* Check for Arm calling Thumb function. */ 1438 if (sym_flags == STT_ARM_TFUNC) 1439 { 1440 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, 1441 output_bfd, input_section, 1442 hit_data, sym_sec, rel->r_offset, 1443 signed_addend, value); 1444 return bfd_reloc_ok; 1445 } 1446 } 1447 1448 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0 1449 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0) 1450 { 1451 /* The old way of doing things. Trearing the addend as a 1452 byte sized field and adding in the pipeline offset. */ 1453 value -= (input_section->output_section->vma 1454 + input_section->output_offset); 1455 value -= rel->r_offset; 1456 value += addend; 1457 1458 if (! globals->no_pipeline_knowledge) 1459 value -= 8; 1460 } 1461 else 1462 { 1463 /* The ARM ELF ABI says that this reloc is computed as: S - P + A 1464 where: 1465 S is the address of the symbol in the relocation. 1466 P is address of the instruction being relocated. 1467 A is the addend (extracted from the instruction) in bytes. 1468 1469 S is held in 'value'. 1470 P is the base address of the section containing the 1471 instruction plus the offset of the reloc into that 1472 section, ie: 1473 (input_section->output_section->vma + 1474 input_section->output_offset + 1475 rel->r_offset). 1476 A is the addend, converted into bytes, ie: 1477 (signed_addend * 4) 1478 1479 Note: None of these operations have knowledge of the pipeline 1480 size of the processor, thus it is up to the assembler to 1481 encode this information into the addend. */ 1482 value -= (input_section->output_section->vma 1483 + input_section->output_offset); 1484 value -= rel->r_offset; 1485 value += (signed_addend << howto->size); 1486 1487 /* Previous versions of this code also used to add in the 1488 pipeline offset here. This is wrong because the linker is 1489 not supposed to know about such things, and one day it might 1490 change. In order to support old binaries that need the old 1491 behaviour however, so we attempt to detect which ABI was 1492 used to create the reloc. */ 1493 if (! globals->no_pipeline_knowledge) 1494 { 1495 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */ 1496 1497 i_ehdrp = elf_elfheader (input_bfd); 1498 1499 if (i_ehdrp->e_ident[EI_OSABI] == 0) 1500 value -= 8; 1501 } 1502 } 1503 1504 signed_addend = value; 1505 signed_addend >>= howto->rightshift; 1506 1507 /* It is not an error for an undefined weak reference to be 1508 out of range. Any program that branches to such a symbol 1509 is going to crash anyway, so there is no point worrying 1510 about getting the destination exactly right. */ 1511 if (! h || h->root.type != bfd_link_hash_undefweak) 1512 { 1513 /* Perform a signed range check. */ 1514 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1)) 1515 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1))) 1516 return bfd_reloc_overflow; 1517 } 1518 1519#ifndef OLD_ARM_ABI 1520 /* If necessary set the H bit in the BLX instruction. */ 1521 if (r_type == R_ARM_XPC25 && ((value & 2) == 2)) 1522 value = (signed_addend & howto->dst_mask) 1523 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask)) 1524 | (1 << 24); 1525 else 1526#endif 1527 value = (signed_addend & howto->dst_mask) 1528 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask)); 1529 break; 1530 1531 case R_ARM_ABS32: 1532 value += addend; 1533 if (sym_flags == STT_ARM_TFUNC) 1534 value |= 1; 1535 break; 1536 1537 case R_ARM_REL32: 1538 value -= (input_section->output_section->vma 1539 + input_section->output_offset + rel->r_offset); 1540 value += addend; 1541 break; 1542 1543#ifndef OLD_ARM_ABI 1544 case R_ARM_PREL31: 1545 value -= (input_section->output_section->vma 1546 + input_section->output_offset + rel->r_offset); 1547 value += signed_addend; 1548 if (! h || h->root.type != bfd_link_hash_undefweak) 1549 { 1550 /* Check for overflow */ 1551 if ((value ^ (value >> 1)) & (1 << 30)) 1552 return bfd_reloc_overflow; 1553 } 1554 value &= 0x7fffffff; 1555 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000); 1556 if (sym_flags == STT_ARM_TFUNC) 1557 value |= 1; 1558 break; 1559#endif 1560 } 1561 1562 bfd_put_32 (input_bfd, value, hit_data); 1563 return bfd_reloc_ok; 1564 1565 case R_ARM_ABS8: 1566 value += addend; 1567 if ((long) value > 0x7f || (long) value < -0x80) 1568 return bfd_reloc_overflow; 1569 1570 bfd_put_8 (input_bfd, value, hit_data); 1571 return bfd_reloc_ok; 1572 1573 case R_ARM_ABS16: 1574 value += addend; 1575 1576 if ((long) value > 0x7fff || (long) value < -0x8000) 1577 return bfd_reloc_overflow; 1578 1579 bfd_put_16 (input_bfd, value, hit_data); 1580 return bfd_reloc_ok; 1581 1582 case R_ARM_ABS12: 1583 /* Support ldr and str instruction for the arm */ 1584 /* Also thumb b (unconditional branch). ??? Really? */ 1585 value += addend; 1586 1587 if ((long) value > 0x7ff || (long) value < -0x800) 1588 return bfd_reloc_overflow; 1589 1590 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000); 1591 bfd_put_32 (input_bfd, value, hit_data); 1592 return bfd_reloc_ok; 1593 1594 case R_ARM_THM_ABS5: 1595 /* Support ldr and str instructions for the thumb. */ 1596#if USE_REL 1597 /* Need to refetch addend. */ 1598 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask; 1599 /* ??? Need to determine shift amount from operand size. */ 1600 addend >>= howto->rightshift; 1601#endif 1602 value += addend; 1603 1604 /* ??? Isn't value unsigned? */ 1605 if ((long) value > 0x1f || (long) value < -0x10) 1606 return bfd_reloc_overflow; 1607 1608 /* ??? Value needs to be properly shifted into place first. */ 1609 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f; 1610 bfd_put_16 (input_bfd, value, hit_data); 1611 return bfd_reloc_ok; 1612 1613#ifndef OLD_ARM_ABI 1614 case R_ARM_THM_XPC22: 1615#endif 1616 case R_ARM_THM_PC22: 1617 /* Thumb BL (branch long instruction). */ 1618 { 1619 bfd_vma relocation; 1620 bfd_boolean overflow = FALSE; 1621 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data); 1622 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2); 1623 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift; 1624 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max; 1625 bfd_vma check; 1626 bfd_signed_vma signed_check; 1627 1628#if USE_REL 1629 /* Need to refetch the addend and squish the two 11 bit pieces 1630 together. */ 1631 { 1632 bfd_vma upper = upper_insn & 0x7ff; 1633 bfd_vma lower = lower_insn & 0x7ff; 1634 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */ 1635 addend = (upper << 12) | (lower << 1); 1636 signed_addend = addend; 1637 } 1638#endif 1639#ifndef OLD_ARM_ABI 1640 if (r_type == R_ARM_THM_XPC22) 1641 { 1642 /* Check for Thumb to Thumb call. */ 1643 /* FIXME: Should we translate the instruction into a BL 1644 instruction instead ? */ 1645 if (sym_flags == STT_ARM_TFUNC) 1646 (*_bfd_error_handler) 1647 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."), 1648 input_bfd, 1649 h ? h->root.root.string : "(local)"); 1650 } 1651 else 1652#endif 1653 { 1654 /* If it is not a call to Thumb, assume call to Arm. 1655 If it is a call relative to a section name, then it is not a 1656 function call at all, but rather a long jump. */ 1657 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION) 1658 { 1659 if (elf32_thumb_to_arm_stub 1660 (info, sym_name, input_bfd, output_bfd, input_section, 1661 hit_data, sym_sec, rel->r_offset, signed_addend, value)) 1662 return bfd_reloc_ok; 1663 else 1664 return bfd_reloc_dangerous; 1665 } 1666 } 1667 1668 relocation = value + signed_addend; 1669 1670 relocation -= (input_section->output_section->vma 1671 + input_section->output_offset 1672 + rel->r_offset); 1673 1674 if (! globals->no_pipeline_knowledge) 1675 { 1676 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */ 1677 1678 i_ehdrp = elf_elfheader (input_bfd); 1679 1680 /* Previous versions of this code also used to add in the pipline 1681 offset here. This is wrong because the linker is not supposed 1682 to know about such things, and one day it might change. In order 1683 to support old binaries that need the old behaviour however, so 1684 we attempt to detect which ABI was used to create the reloc. */ 1685 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0 1686 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0 1687 || i_ehdrp->e_ident[EI_OSABI] == 0) 1688 relocation += 4; 1689 } 1690 1691 check = relocation >> howto->rightshift; 1692 1693 /* If this is a signed value, the rightshift just dropped 1694 leading 1 bits (assuming twos complement). */ 1695 if ((bfd_signed_vma) relocation >= 0) 1696 signed_check = check; 1697 else 1698 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift); 1699 1700 /* Assumes two's complement. */ 1701 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min) 1702 overflow = TRUE; 1703 1704#ifndef OLD_ARM_ABI 1705 if (r_type == R_ARM_THM_XPC22 1706 && ((lower_insn & 0x1800) == 0x0800)) 1707 /* For a BLX instruction, make sure that the relocation is rounded up 1708 to a word boundary. This follows the semantics of the instruction 1709 which specifies that bit 1 of the target address will come from bit 1710 1 of the base address. */ 1711 relocation = (relocation + 2) & ~ 3; 1712#endif 1713 /* Put RELOCATION back into the insn. */ 1714 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff); 1715 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff); 1716 1717 /* Put the relocated value back in the object file: */ 1718 bfd_put_16 (input_bfd, upper_insn, hit_data); 1719 bfd_put_16 (input_bfd, lower_insn, hit_data + 2); 1720 1721 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok); 1722 } 1723 break; 1724 1725 case R_ARM_THM_PC11: 1726 /* Thumb B (branch) instruction). */ 1727 { 1728 bfd_signed_vma relocation; 1729 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1; 1730 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max; 1731 bfd_signed_vma signed_check; 1732 1733#if USE_REL 1734 /* Need to refetch addend. */ 1735 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask; 1736 if (addend & ((howto->src_mask + 1) >> 1)) 1737 { 1738 signed_addend = -1; 1739 signed_addend &= ~ howto->src_mask; 1740 signed_addend |= addend; 1741 } 1742 else 1743 signed_addend = addend; 1744 /* The value in the insn has been right shifted. We need to 1745 undo this, so that we can perform the address calculation 1746 in terms of bytes. */ 1747 signed_addend <<= howto->rightshift; 1748#endif 1749 relocation = value + signed_addend; 1750 1751 relocation -= (input_section->output_section->vma 1752 + input_section->output_offset 1753 + rel->r_offset); 1754 1755 relocation >>= howto->rightshift; 1756 signed_check = relocation; 1757 relocation &= howto->dst_mask; 1758 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask)); 1759 1760 bfd_put_16 (input_bfd, relocation, hit_data); 1761 1762 /* Assumes two's complement. */ 1763 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min) 1764 return bfd_reloc_overflow; 1765 1766 return bfd_reloc_ok; 1767 } 1768 1769#ifndef OLD_ARM_ABI 1770 case R_ARM_ALU_PCREL7_0: 1771 case R_ARM_ALU_PCREL15_8: 1772 case R_ARM_ALU_PCREL23_15: 1773 { 1774 bfd_vma insn; 1775 bfd_vma relocation; 1776 1777 insn = bfd_get_32 (input_bfd, hit_data); 1778#if USE_REL 1779 /* Extract the addend. */ 1780 addend = (insn & 0xff) << ((insn & 0xf00) >> 7); 1781 signed_addend = addend; 1782#endif 1783 relocation = value + signed_addend; 1784 1785 relocation -= (input_section->output_section->vma 1786 + input_section->output_offset 1787 + rel->r_offset); 1788 insn = (insn & ~0xfff) 1789 | ((howto->bitpos << 7) & 0xf00) 1790 | ((relocation >> howto->bitpos) & 0xff); 1791 bfd_put_32 (input_bfd, value, hit_data); 1792 } 1793 return bfd_reloc_ok; 1794#endif 1795 1796 case R_ARM_GNU_VTINHERIT: 1797 case R_ARM_GNU_VTENTRY: 1798 return bfd_reloc_ok; 1799 1800 case R_ARM_COPY: 1801 return bfd_reloc_notsupported; 1802 1803 case R_ARM_GLOB_DAT: 1804 return bfd_reloc_notsupported; 1805 1806 case R_ARM_JUMP_SLOT: 1807 return bfd_reloc_notsupported; 1808 1809 case R_ARM_RELATIVE: 1810 return bfd_reloc_notsupported; 1811 1812 case R_ARM_GOTOFF: 1813 /* Relocation is relative to the start of the 1814 global offset table. */ 1815 1816 BFD_ASSERT (sgot != NULL); 1817 if (sgot == NULL) 1818 return bfd_reloc_notsupported; 1819 1820 /* If we are addressing a Thumb function, we need to adjust the 1821 address by one, so that attempts to call the function pointer will 1822 correctly interpret it as Thumb code. */ 1823 if (sym_flags == STT_ARM_TFUNC) 1824 value += 1; 1825 1826 /* Note that sgot->output_offset is not involved in this 1827 calculation. We always want the start of .got. If we 1828 define _GLOBAL_OFFSET_TABLE in a different way, as is 1829 permitted by the ABI, we might have to change this 1830 calculation. */ 1831 value -= sgot->output_section->vma; 1832 return _bfd_final_link_relocate (howto, input_bfd, input_section, 1833 contents, rel->r_offset, value, 1834 (bfd_vma) 0); 1835 1836 case R_ARM_GOTPC: 1837 /* Use global offset table as symbol value. */ 1838 BFD_ASSERT (sgot != NULL); 1839 1840 if (sgot == NULL) 1841 return bfd_reloc_notsupported; 1842 1843 value = sgot->output_section->vma; 1844 return _bfd_final_link_relocate (howto, input_bfd, input_section, 1845 contents, rel->r_offset, value, 1846 (bfd_vma) 0); 1847 1848 case R_ARM_GOT32: 1849#ifndef OLD_ARM_ABI 1850 case R_ARM_GOT_PREL: 1851#endif 1852 /* Relocation is to the entry for this symbol in the 1853 global offset table. */ 1854 if (sgot == NULL) 1855 return bfd_reloc_notsupported; 1856 1857 if (h != NULL) 1858 { 1859 bfd_vma off; 1860 bfd_boolean dyn; 1861 1862 off = h->got.offset; 1863 BFD_ASSERT (off != (bfd_vma) -1); 1864 dyn = globals->root.dynamic_sections_created; 1865 1866 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 1867 || (info->shared 1868 && SYMBOL_REFERENCES_LOCAL (info, h)) 1869 || (ELF_ST_VISIBILITY (h->other) 1870 && h->root.type == bfd_link_hash_undefweak)) 1871 { 1872 /* This is actually a static link, or it is a -Bsymbolic link 1873 and the symbol is defined locally. We must initialize this 1874 entry in the global offset table. Since the offset must 1875 always be a multiple of 4, we use the least significant bit 1876 to record whether we have initialized it already. 1877 1878 When doing a dynamic link, we create a .rel.got relocation 1879 entry to initialize the value. This is done in the 1880 finish_dynamic_symbol routine. */ 1881 if ((off & 1) != 0) 1882 off &= ~1; 1883 else 1884 { 1885 /* If we are addressing a Thumb function, we need to 1886 adjust the address by one, so that attempts to 1887 call the function pointer will correctly 1888 interpret it as Thumb code. */ 1889 if (sym_flags == STT_ARM_TFUNC) 1890 value |= 1; 1891 1892 bfd_put_32 (output_bfd, value, sgot->contents + off); 1893 h->got.offset |= 1; 1894 } 1895 } 1896 1897 value = sgot->output_offset + off; 1898 } 1899 else 1900 { 1901 bfd_vma off; 1902 1903 BFD_ASSERT (local_got_offsets != NULL && 1904 local_got_offsets[r_symndx] != (bfd_vma) -1); 1905 1906 off = local_got_offsets[r_symndx]; 1907 1908 /* The offset must always be a multiple of 4. We use the 1909 least significant bit to record whether we have already 1910 generated the necessary reloc. */ 1911 if ((off & 1) != 0) 1912 off &= ~1; 1913 else 1914 { 1915 bfd_put_32 (output_bfd, value, sgot->contents + off); 1916 1917 if (info->shared) 1918 { 1919 asection * srelgot; 1920 Elf_Internal_Rela outrel; 1921 bfd_byte *loc; 1922 1923 srelgot = bfd_get_section_by_name (dynobj, ".rel.got"); 1924 BFD_ASSERT (srelgot != NULL); 1925 1926 outrel.r_offset = (sgot->output_section->vma 1927 + sgot->output_offset 1928 + off); 1929 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); 1930 loc = srelgot->contents; 1931 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel); 1932 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); 1933 } 1934 1935 local_got_offsets[r_symndx] |= 1; 1936 } 1937 1938 value = sgot->output_offset + off; 1939 } 1940 if (r_type != R_ARM_GOT32) 1941 value += sgot->output_section->vma; 1942 1943 return _bfd_final_link_relocate (howto, input_bfd, input_section, 1944 contents, rel->r_offset, value, 1945 (bfd_vma) 0); 1946 1947 case R_ARM_SBREL32: 1948 return bfd_reloc_notsupported; 1949 1950 case R_ARM_AMP_VCALL9: 1951 return bfd_reloc_notsupported; 1952 1953 case R_ARM_RSBREL32: 1954 return bfd_reloc_notsupported; 1955 1956 case R_ARM_THM_RPC22: 1957 return bfd_reloc_notsupported; 1958 1959 case R_ARM_RREL32: 1960 return bfd_reloc_notsupported; 1961 1962 case R_ARM_RABS32: 1963 return bfd_reloc_notsupported; 1964 1965 case R_ARM_RPC24: 1966 return bfd_reloc_notsupported; 1967 1968 case R_ARM_RBASE: 1969 return bfd_reloc_notsupported; 1970 1971 default: 1972 return bfd_reloc_notsupported; 1973 } 1974} 1975 1976#if USE_REL 1977/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */ 1978static void 1979arm_add_to_rel (bfd * abfd, 1980 bfd_byte * address, 1981 reloc_howto_type * howto, 1982 bfd_signed_vma increment) 1983{ 1984 bfd_signed_vma addend; 1985 1986 if (howto->type == R_ARM_THM_PC22) 1987 { 1988 int upper_insn, lower_insn; 1989 int upper, lower; 1990 1991 upper_insn = bfd_get_16 (abfd, address); 1992 lower_insn = bfd_get_16 (abfd, address + 2); 1993 upper = upper_insn & 0x7ff; 1994 lower = lower_insn & 0x7ff; 1995 1996 addend = (upper << 12) | (lower << 1); 1997 addend += increment; 1998 addend >>= 1; 1999 2000 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff); 2001 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff); 2002 2003 bfd_put_16 (abfd, (bfd_vma) upper_insn, address); 2004 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2); 2005 } 2006 else 2007 { 2008 bfd_vma contents; 2009 2010 contents = bfd_get_32 (abfd, address); 2011 2012 /* Get the (signed) value from the instruction. */ 2013 addend = contents & howto->src_mask; 2014 if (addend & ((howto->src_mask + 1) >> 1)) 2015 { 2016 bfd_signed_vma mask; 2017 2018 mask = -1; 2019 mask &= ~ howto->src_mask; 2020 addend |= mask; 2021 } 2022 2023 /* Add in the increment, (which is a byte value). */ 2024 switch (howto->type) 2025 { 2026 default: 2027 addend += increment; 2028 break; 2029 2030 case R_ARM_PC24: 2031 addend <<= howto->size; 2032 addend += increment; 2033 2034 /* Should we check for overflow here ? */ 2035 2036 /* Drop any undesired bits. */ 2037 addend >>= howto->rightshift; 2038 break; 2039 } 2040 2041 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask); 2042 2043 bfd_put_32 (abfd, contents, address); 2044 } 2045} 2046#endif /* USE_REL */ 2047 2048/* Relocate an ARM ELF section. */ 2049static bfd_boolean 2050elf32_arm_relocate_section (bfd * output_bfd, 2051 struct bfd_link_info * info, 2052 bfd * input_bfd, 2053 asection * input_section, 2054 bfd_byte * contents, 2055 Elf_Internal_Rela * relocs, 2056 Elf_Internal_Sym * local_syms, 2057 asection ** local_sections) 2058{ 2059 Elf_Internal_Shdr *symtab_hdr; 2060 struct elf_link_hash_entry **sym_hashes; 2061 Elf_Internal_Rela *rel; 2062 Elf_Internal_Rela *relend; 2063 const char *name; 2064 2065#if !USE_REL 2066 if (info->relocatable) 2067 return TRUE; 2068#endif 2069 2070 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 2071 sym_hashes = elf_sym_hashes (input_bfd); 2072 2073 rel = relocs; 2074 relend = relocs + input_section->reloc_count; 2075 for (; rel < relend; rel++) 2076 { 2077 int r_type; 2078 reloc_howto_type * howto; 2079 unsigned long r_symndx; 2080 Elf_Internal_Sym * sym; 2081 asection * sec; 2082 struct elf_link_hash_entry * h; 2083 bfd_vma relocation; 2084 bfd_reloc_status_type r; 2085 arelent bfd_reloc; 2086 2087 r_symndx = ELF32_R_SYM (rel->r_info); 2088 r_type = ELF32_R_TYPE (rel->r_info); 2089 2090 if ( r_type == R_ARM_GNU_VTENTRY 2091 || r_type == R_ARM_GNU_VTINHERIT) 2092 continue; 2093 2094 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel); 2095 howto = bfd_reloc.howto; 2096 2097#if USE_REL 2098 if (info->relocatable) 2099 { 2100 /* This is a relocatable link. We don't have to change 2101 anything, unless the reloc is against a section symbol, 2102 in which case we have to adjust according to where the 2103 section symbol winds up in the output section. */ 2104 if (r_symndx < symtab_hdr->sh_info) 2105 { 2106 sym = local_syms + r_symndx; 2107 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 2108 { 2109 sec = local_sections[r_symndx]; 2110 arm_add_to_rel (input_bfd, contents + rel->r_offset, 2111 howto, 2112 (bfd_signed_vma) (sec->output_offset 2113 + sym->st_value)); 2114 } 2115 } 2116 2117 continue; 2118 } 2119#endif 2120 2121 /* This is a final link. */ 2122 h = NULL; 2123 sym = NULL; 2124 sec = NULL; 2125 2126 if (r_symndx < symtab_hdr->sh_info) 2127 { 2128 sym = local_syms + r_symndx; 2129 sec = local_sections[r_symndx]; 2130#if USE_REL 2131 relocation = (sec->output_section->vma 2132 + sec->output_offset 2133 + sym->st_value); 2134 if ((sec->flags & SEC_MERGE) 2135 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 2136 { 2137 asection *msec; 2138 bfd_vma addend, value; 2139 2140 if (howto->rightshift) 2141 { 2142 (*_bfd_error_handler) 2143 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"), 2144 input_bfd, input_section, 2145 (long) rel->r_offset, howto->name); 2146 return FALSE; 2147 } 2148 2149 value = bfd_get_32 (input_bfd, contents + rel->r_offset); 2150 2151 /* Get the (signed) value from the instruction. */ 2152 addend = value & howto->src_mask; 2153 if (addend & ((howto->src_mask + 1) >> 1)) 2154 { 2155 bfd_signed_vma mask; 2156 2157 mask = -1; 2158 mask &= ~ howto->src_mask; 2159 addend |= mask; 2160 } 2161 msec = sec; 2162 addend = 2163 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) 2164 - relocation; 2165 addend += msec->output_section->vma + msec->output_offset; 2166 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask); 2167 bfd_put_32 (input_bfd, value, contents + rel->r_offset); 2168 } 2169#else 2170 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2171#endif 2172 } 2173 else 2174 { 2175 bfd_boolean warned; 2176 bfd_boolean unresolved_reloc; 2177 2178 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 2179 r_symndx, symtab_hdr, sym_hashes, 2180 h, sec, relocation, 2181 unresolved_reloc, warned); 2182 2183 if (unresolved_reloc || relocation != 0) 2184 { 2185 /* In these cases, we don't need the relocation value. 2186 We check specially because in some obscure cases 2187 sec->output_section will be NULL. */ 2188 switch (r_type) 2189 { 2190 case R_ARM_PC24: 2191 case R_ARM_ABS32: 2192 case R_ARM_THM_PC22: 2193 case R_ARM_PLT32: 2194 2195 if (info->shared 2196 && ((!info->symbolic && h->dynindx != -1) 2197 || !h->def_regular) 2198 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2199 && ((input_section->flags & SEC_ALLOC) != 0 2200 /* DWARF will emit R_ARM_ABS32 relocations in its 2201 sections against symbols defined externally 2202 in shared libraries. We can't do anything 2203 with them here. */ 2204 || ((input_section->flags & SEC_DEBUGGING) != 0 2205 && h->def_dynamic)) 2206 ) 2207 relocation = 0; 2208 break; 2209 2210 case R_ARM_GOTPC: 2211 relocation = 0; 2212 break; 2213 2214 case R_ARM_GOT32: 2215#ifndef OLD_ARM_ABI 2216 case R_ARM_GOT_PREL: 2217#endif 2218 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL 2219 (elf_hash_table (info)->dynamic_sections_created, 2220 info->shared, h)) 2221 && (!info->shared 2222 || (!info->symbolic && h->dynindx != -1) 2223 || !h->def_regular)) 2224 relocation = 0; 2225 break; 2226 2227 default: 2228 if (unresolved_reloc) 2229 _bfd_error_handler 2230 (_("%B(%A): warning: unresolvable relocation %d against symbol `%s'"), 2231 input_bfd, input_section, 2232 r_type, 2233 h->root.root.string); 2234 break; 2235 } 2236 } 2237 } 2238 2239 if (h != NULL) 2240 name = h->root.root.string; 2241 else 2242 { 2243 name = (bfd_elf_string_from_elf_section 2244 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 2245 if (name == NULL || *name == '\0') 2246 name = bfd_section_name (input_bfd, sec); 2247 } 2248 2249 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd, 2250 input_section, contents, rel, 2251 relocation, info, sec, name, 2252 (h ? ELF_ST_TYPE (h->type) : 2253 ELF_ST_TYPE (sym->st_info)), h); 2254 2255 if (r != bfd_reloc_ok) 2256 { 2257 const char * msg = (const char *) 0; 2258 2259 switch (r) 2260 { 2261 case bfd_reloc_overflow: 2262 /* If the overflowing reloc was to an undefined symbol, 2263 we have already printed one error message and there 2264 is no point complaining again. */ 2265 if ((! h || 2266 h->root.type != bfd_link_hash_undefined) 2267 && (!((*info->callbacks->reloc_overflow) 2268 (info, name, howto->name, (bfd_vma) 0, 2269 input_bfd, input_section, rel->r_offset)))) 2270 return FALSE; 2271 break; 2272 2273 case bfd_reloc_undefined: 2274 if (!((*info->callbacks->undefined_symbol) 2275 (info, name, input_bfd, input_section, 2276 rel->r_offset, TRUE))) 2277 return FALSE; 2278 break; 2279 2280 case bfd_reloc_outofrange: 2281 msg = _("internal error: out of range error"); 2282 goto common_error; 2283 2284 case bfd_reloc_notsupported: 2285 msg = _("internal error: unsupported relocation error"); 2286 goto common_error; 2287 2288 case bfd_reloc_dangerous: 2289 msg = _("internal error: dangerous error"); 2290 goto common_error; 2291 2292 default: 2293 msg = _("internal error: unknown error"); 2294 /* fall through */ 2295 2296 common_error: 2297 if (!((*info->callbacks->warning) 2298 (info, msg, name, input_bfd, input_section, 2299 rel->r_offset))) 2300 return FALSE; 2301 break; 2302 } 2303 } 2304 } 2305 2306 return TRUE; 2307} 2308 2309/* Set the right machine number. */ 2310 2311static bfd_boolean 2312elf32_arm_object_p (bfd *abfd) 2313{ 2314 unsigned int mach; 2315 2316 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION); 2317 2318 if (mach != bfd_mach_arm_unknown) 2319 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach); 2320 2321 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT) 2322 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312); 2323 2324 else 2325 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach); 2326 2327 return TRUE; 2328} 2329 2330/* Function to keep ARM specific flags in the ELF header. */ 2331 2332static bfd_boolean 2333elf32_arm_set_private_flags (bfd *abfd, flagword flags) 2334{ 2335 if (elf_flags_init (abfd) 2336 && elf_elfheader (abfd)->e_flags != flags) 2337 { 2338 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN) 2339 { 2340 if (flags & EF_ARM_INTERWORK) 2341 (*_bfd_error_handler) 2342 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"), 2343 abfd); 2344 else 2345 _bfd_error_handler 2346 (_("Warning: Clearing the interworking flag of %B due to outside request"), 2347 abfd); 2348 } 2349 } 2350 else 2351 { 2352 elf_elfheader (abfd)->e_flags = flags; 2353 elf_flags_init (abfd) = TRUE; 2354 } 2355 2356 return TRUE; 2357} 2358 2359/* Copy backend specific data from one object module to another. */ 2360 2361static bfd_boolean 2362elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 2363{ 2364 flagword in_flags; 2365 flagword out_flags; 2366 2367 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour 2368 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 2369 return TRUE; 2370 2371 in_flags = elf_elfheader (ibfd)->e_flags; 2372 out_flags = elf_elfheader (obfd)->e_flags; 2373 2374 if (elf_flags_init (obfd) 2375 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN 2376 && in_flags != out_flags) 2377 { 2378 /* Cannot mix APCS26 and APCS32 code. */ 2379 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26)) 2380 return FALSE; 2381 2382 /* Cannot mix float APCS and non-float APCS code. */ 2383 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT)) 2384 return FALSE; 2385 2386 /* If the src and dest have different interworking flags 2387 then turn off the interworking bit. */ 2388 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK)) 2389 { 2390 if (out_flags & EF_ARM_INTERWORK) 2391 _bfd_error_handler 2392 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"), 2393 obfd, ibfd); 2394 2395 in_flags &= ~EF_ARM_INTERWORK; 2396 } 2397 2398 /* Likewise for PIC, though don't warn for this case. */ 2399 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC)) 2400 in_flags &= ~EF_ARM_PIC; 2401 } 2402 2403 elf_elfheader (obfd)->e_flags = in_flags; 2404 elf_flags_init (obfd) = TRUE; 2405 2406 return TRUE; 2407} 2408 2409/* Merge backend specific data from an object file to the output 2410 object file when linking. */ 2411 2412static bfd_boolean 2413elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd) 2414{ 2415 flagword out_flags; 2416 flagword in_flags; 2417 bfd_boolean flags_compatible = TRUE; 2418 asection *sec; 2419 2420 /* Check if we have the same endianess. */ 2421 if (! _bfd_generic_verify_endian_match (ibfd, obfd)) 2422 return FALSE; 2423 2424 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour 2425 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 2426 return TRUE; 2427 2428 /* The input BFD must have had its flags initialised. */ 2429 /* The following seems bogus to me -- The flags are initialized in 2430 the assembler but I don't think an elf_flags_init field is 2431 written into the object. */ 2432 /* BFD_ASSERT (elf_flags_init (ibfd)); */ 2433 2434 in_flags = elf_elfheader (ibfd)->e_flags; 2435 out_flags = elf_elfheader (obfd)->e_flags; 2436 2437 if (!elf_flags_init (obfd)) 2438 { 2439 /* If the input is the default architecture and had the default 2440 flags then do not bother setting the flags for the output 2441 architecture, instead allow future merges to do this. If no 2442 future merges ever set these flags then they will retain their 2443 uninitialised values, which surprise surprise, correspond 2444 to the default values. */ 2445 if (bfd_get_arch_info (ibfd)->the_default 2446 && elf_elfheader (ibfd)->e_flags == 0) 2447 return TRUE; 2448 2449 elf_flags_init (obfd) = TRUE; 2450 elf_elfheader (obfd)->e_flags = in_flags; 2451 2452 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 2453 && bfd_get_arch_info (obfd)->the_default) 2454 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd)); 2455 2456 return TRUE; 2457 } 2458 2459 /* Determine what should happen if the input ARM architecture 2460 does not match the output ARM architecture. */ 2461 if (! bfd_arm_merge_machines (ibfd, obfd)) 2462 return FALSE; 2463 2464 /* Identical flags must be compatible. */ 2465 if (in_flags == out_flags) 2466 return TRUE; 2467 2468 /* Check to see if the input BFD actually contains any sections. If 2469 not, its flags may not have been initialised either, but it 2470 cannot actually cause any incompatibility. Do not short-circuit 2471 dynamic objects; their section list may be emptied by 2472 elf_link_add_object_symbols. 2473 2474 Also check to see if there are no code sections in the input. 2475 In this case there is no need to check for code specific flags. 2476 XXX - do we need to worry about floating-point format compatability 2477 in data sections ? */ 2478 if (!(ibfd->flags & DYNAMIC)) 2479 { 2480 bfd_boolean null_input_bfd = TRUE; 2481 bfd_boolean only_data_sections = TRUE; 2482 2483 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 2484 { 2485 /* Ignore synthetic glue sections. */ 2486 if (strcmp (sec->name, ".glue_7") 2487 && strcmp (sec->name, ".glue_7t")) 2488 { 2489 if ((bfd_get_section_flags (ibfd, sec) 2490 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 2491 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 2492 only_data_sections = FALSE; 2493 2494 null_input_bfd = FALSE; 2495 break; 2496 } 2497 } 2498 2499 if (null_input_bfd || only_data_sections) 2500 return TRUE; 2501 } 2502 2503 /* Complain about various flag mismatches. */ 2504 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags)) 2505 { 2506 _bfd_error_handler 2507 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"), 2508 ibfd, obfd, 2509 (in_flags & EF_ARM_EABIMASK) >> 24, 2510 (out_flags & EF_ARM_EABIMASK) >> 24); 2511 return FALSE; 2512 } 2513 2514 /* Not sure what needs to be checked for EABI versions >= 1. */ 2515 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN) 2516 { 2517 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26)) 2518 { 2519 _bfd_error_handler 2520 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"), 2521 ibfd, obfd, 2522 in_flags & EF_ARM_APCS_26 ? 26 : 32, 2523 out_flags & EF_ARM_APCS_26 ? 26 : 32); 2524 flags_compatible = FALSE; 2525 } 2526 2527 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT)) 2528 { 2529 if (in_flags & EF_ARM_APCS_FLOAT) 2530 _bfd_error_handler 2531 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"), 2532 ibfd, obfd); 2533 else 2534 _bfd_error_handler 2535 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"), 2536 ibfd, obfd); 2537 2538 flags_compatible = FALSE; 2539 } 2540 2541 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT)) 2542 { 2543 if (in_flags & EF_ARM_VFP_FLOAT) 2544 _bfd_error_handler 2545 (_("ERROR: %B uses VFP instructions, whereas %B does not"), 2546 ibfd, obfd); 2547 else 2548 _bfd_error_handler 2549 (_("ERROR: %B uses FPA instructions, whereas %B does not"), 2550 ibfd, obfd); 2551 2552 flags_compatible = FALSE; 2553 } 2554 2555 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT)) 2556 { 2557 if (in_flags & EF_ARM_MAVERICK_FLOAT) 2558 _bfd_error_handler 2559 (_("ERROR: %B uses Maverick instructions, whereas %B does not"), 2560 ibfd, obfd); 2561 else 2562 _bfd_error_handler 2563 (_("ERROR: %B does not use Maverick instructions, whereas %B does"), 2564 ibfd, obfd); 2565 2566 flags_compatible = FALSE; 2567 } 2568 2569#ifdef EF_ARM_SOFT_FLOAT 2570 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT)) 2571 { 2572 /* We can allow interworking between code that is VFP format 2573 layout, and uses either soft float or integer regs for 2574 passing floating point arguments and results. We already 2575 know that the APCS_FLOAT flags match; similarly for VFP 2576 flags. */ 2577 if ((in_flags & EF_ARM_APCS_FLOAT) != 0 2578 || (in_flags & EF_ARM_VFP_FLOAT) == 0) 2579 { 2580 if (in_flags & EF_ARM_SOFT_FLOAT) 2581 _bfd_error_handler 2582 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"), 2583 ibfd, obfd); 2584 else 2585 _bfd_error_handler 2586 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"), 2587 ibfd, obfd); 2588 2589 flags_compatible = FALSE; 2590 } 2591 } 2592#endif 2593 2594 /* Interworking mismatch is only a warning. */ 2595 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK)) 2596 { 2597 if (in_flags & EF_ARM_INTERWORK) 2598 { 2599 _bfd_error_handler 2600 (_("Warning: %B supports interworking, whereas %B does not"), 2601 ibfd, obfd); 2602 } 2603 else 2604 { 2605 _bfd_error_handler 2606 (_("Warning: %B does not support interworking, whereas %B does"), 2607 ibfd, obfd); 2608 } 2609 } 2610 } 2611 2612 return flags_compatible; 2613} 2614 2615/* Display the flags field. */ 2616 2617static bfd_boolean 2618elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr) 2619{ 2620 FILE * file = (FILE *) ptr; 2621 unsigned long flags; 2622 2623 BFD_ASSERT (abfd != NULL && ptr != NULL); 2624 2625 /* Print normal ELF private data. */ 2626 _bfd_elf_print_private_bfd_data (abfd, ptr); 2627 2628 flags = elf_elfheader (abfd)->e_flags; 2629 /* Ignore init flag - it may not be set, despite the flags field 2630 containing valid data. */ 2631 2632 /* xgettext:c-format */ 2633 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 2634 2635 switch (EF_ARM_EABI_VERSION (flags)) 2636 { 2637 case EF_ARM_EABI_UNKNOWN: 2638 /* The following flag bits are GNU extensions and not part of the 2639 official ARM ELF extended ABI. Hence they are only decoded if 2640 the EABI version is not set. */ 2641 if (flags & EF_ARM_INTERWORK) 2642 fprintf (file, _(" [interworking enabled]")); 2643 2644 if (flags & EF_ARM_APCS_26) 2645 fprintf (file, " [APCS-26]"); 2646 else 2647 fprintf (file, " [APCS-32]"); 2648 2649 if (flags & EF_ARM_VFP_FLOAT) 2650 fprintf (file, _(" [VFP float format]")); 2651 else if (flags & EF_ARM_MAVERICK_FLOAT) 2652 fprintf (file, _(" [Maverick float format]")); 2653 else 2654 fprintf (file, _(" [FPA float format]")); 2655 2656 if (flags & EF_ARM_APCS_FLOAT) 2657 fprintf (file, _(" [floats passed in float registers]")); 2658 2659 if (flags & EF_ARM_PIC) 2660 fprintf (file, _(" [position independent]")); 2661 2662 if (flags & EF_ARM_NEW_ABI) 2663 fprintf (file, _(" [new ABI]")); 2664 2665 if (flags & EF_ARM_OLD_ABI) 2666 fprintf (file, _(" [old ABI]")); 2667 2668 if (flags & EF_ARM_SOFT_FLOAT) 2669 fprintf (file, _(" [software FP]")); 2670 2671 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT 2672 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI 2673 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT 2674 | EF_ARM_MAVERICK_FLOAT); 2675 break; 2676 2677 case EF_ARM_EABI_VER1: 2678 fprintf (file, _(" [Version1 EABI]")); 2679 2680 if (flags & EF_ARM_SYMSARESORTED) 2681 fprintf (file, _(" [sorted symbol table]")); 2682 else 2683 fprintf (file, _(" [unsorted symbol table]")); 2684 2685 flags &= ~ EF_ARM_SYMSARESORTED; 2686 break; 2687 2688 case EF_ARM_EABI_VER2: 2689 fprintf (file, _(" [Version2 EABI]")); 2690 2691 if (flags & EF_ARM_SYMSARESORTED) 2692 fprintf (file, _(" [sorted symbol table]")); 2693 else 2694 fprintf (file, _(" [unsorted symbol table]")); 2695 2696 if (flags & EF_ARM_DYNSYMSUSESEGIDX) 2697 fprintf (file, _(" [dynamic symbols use segment index]")); 2698 2699 if (flags & EF_ARM_MAPSYMSFIRST) 2700 fprintf (file, _(" [mapping symbols precede others]")); 2701 2702 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX 2703 | EF_ARM_MAPSYMSFIRST); 2704 break; 2705 2706 case EF_ARM_EABI_VER3: 2707 fprintf (file, _(" [Version3 EABI]")); 2708 break; 2709 2710 case EF_ARM_EABI_VER4: 2711 fprintf (file, _(" [Version4 EABI]")); 2712 2713 if (flags & EF_ARM_BE8) 2714 fprintf (file, _(" [BE8]")); 2715 2716 if (flags & EF_ARM_LE8) 2717 fprintf (file, _(" [LE8]")); 2718 2719 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8); 2720 break; 2721 2722 default: 2723 fprintf (file, _(" <EABI version unrecognised>")); 2724 break; 2725 } 2726 2727 flags &= ~ EF_ARM_EABIMASK; 2728 2729 if (flags & EF_ARM_RELEXEC) 2730 fprintf (file, _(" [relocatable executable]")); 2731 2732 if (flags & EF_ARM_HASENTRY) 2733 fprintf (file, _(" [has entry point]")); 2734 2735 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY); 2736 2737 if (flags) 2738 fprintf (file, _("<Unrecognised flag bits set>")); 2739 2740 fputc ('\n', file); 2741 2742 return TRUE; 2743} 2744 2745static int 2746elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type) 2747{ 2748 switch (ELF_ST_TYPE (elf_sym->st_info)) 2749 { 2750 case STT_ARM_TFUNC: 2751 return ELF_ST_TYPE (elf_sym->st_info); 2752 2753 case STT_ARM_16BIT: 2754 /* If the symbol is not an object, return the STT_ARM_16BIT flag. 2755 This allows us to distinguish between data used by Thumb instructions 2756 and non-data (which is probably code) inside Thumb regions of an 2757 executable. */ 2758 if (type != STT_OBJECT) 2759 return ELF_ST_TYPE (elf_sym->st_info); 2760 break; 2761 2762 default: 2763 break; 2764 } 2765 2766 return type; 2767} 2768 2769static asection * 2770elf32_arm_gc_mark_hook (asection * sec, 2771 struct bfd_link_info * info ATTRIBUTE_UNUSED, 2772 Elf_Internal_Rela * rel, 2773 struct elf_link_hash_entry * h, 2774 Elf_Internal_Sym * sym) 2775{ 2776 if (h != NULL) 2777 { 2778 switch (ELF32_R_TYPE (rel->r_info)) 2779 { 2780 case R_ARM_GNU_VTINHERIT: 2781 case R_ARM_GNU_VTENTRY: 2782 break; 2783 2784 default: 2785 switch (h->root.type) 2786 { 2787 case bfd_link_hash_defined: 2788 case bfd_link_hash_defweak: 2789 return h->root.u.def.section; 2790 2791 case bfd_link_hash_common: 2792 return h->root.u.c.p->section; 2793 2794 default: 2795 break; 2796 } 2797 } 2798 } 2799 else 2800 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 2801 2802 return NULL; 2803} 2804 2805/* Update the got entry reference counts for the section being removed. */ 2806 2807static bfd_boolean 2808elf32_arm_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED, 2809 struct bfd_link_info * info ATTRIBUTE_UNUSED, 2810 asection * sec ATTRIBUTE_UNUSED, 2811 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED) 2812{ 2813 Elf_Internal_Shdr *symtab_hdr; 2814 struct elf_link_hash_entry **sym_hashes; 2815 bfd_signed_vma *local_got_refcounts; 2816 const Elf_Internal_Rela *rel, *relend; 2817 unsigned long r_symndx; 2818 struct elf_link_hash_entry *h; 2819 struct elf32_arm_link_hash_table * globals; 2820 2821 globals = elf32_arm_hash_table (info); 2822 2823 elf_section_data (sec)->local_dynrel = NULL; 2824 2825 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2826 sym_hashes = elf_sym_hashes (abfd); 2827 local_got_refcounts = elf_local_got_refcounts (abfd); 2828 2829 relend = relocs + sec->reloc_count; 2830 for (rel = relocs; rel < relend; rel++) 2831 { 2832 int r_type; 2833 2834 r_type = ELF32_R_TYPE (rel->r_info); 2835#ifndef OLD_ARM_ABI 2836 r_type = arm_real_reloc_type (globals, r_type); 2837#endif 2838 switch (r_type) 2839 { 2840 case R_ARM_GOT32: 2841#ifndef OLD_ARM_ABI 2842 case R_ARM_GOT_PREL: 2843#endif 2844 r_symndx = ELF32_R_SYM (rel->r_info); 2845 if (r_symndx >= symtab_hdr->sh_info) 2846 { 2847 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2848 if (h->got.refcount > 0) 2849 h->got.refcount -= 1; 2850 } 2851 else if (local_got_refcounts != NULL) 2852 { 2853 if (local_got_refcounts[r_symndx] > 0) 2854 local_got_refcounts[r_symndx] -= 1; 2855 } 2856 break; 2857 2858 case R_ARM_ABS32: 2859 case R_ARM_REL32: 2860 case R_ARM_PC24: 2861 case R_ARM_PLT32: 2862#ifndef OLD_ARM_ABI 2863 case R_ARM_PREL31: 2864#endif 2865 r_symndx = ELF32_R_SYM (rel->r_info); 2866 if (r_symndx >= symtab_hdr->sh_info) 2867 { 2868 struct elf32_arm_link_hash_entry *eh; 2869 struct elf32_arm_relocs_copied **pp; 2870 struct elf32_arm_relocs_copied *p; 2871 2872 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2873 2874 if (h->plt.refcount > 0) 2875 h->plt.refcount -= 1; 2876 2877 if (r_type == R_ARM_ABS32 2878#ifndef OLD_ARM_ABI 2879 || r_type == R_ARM_PREL31 2880#endif 2881 || r_type == R_ARM_REL32) 2882 { 2883 eh = (struct elf32_arm_link_hash_entry *) h; 2884 2885 for (pp = &eh->relocs_copied; (p = *pp) != NULL; 2886 pp = &p->next) 2887 if (p->section == sec) 2888 { 2889 p->count -= 1; 2890 if (p->count == 0) 2891 *pp = p->next; 2892 break; 2893 } 2894 } 2895 } 2896 break; 2897 2898 default: 2899 break; 2900 } 2901 } 2902 2903 return TRUE; 2904} 2905 2906/* Look through the relocs for a section during the first phase. */ 2907 2908static bfd_boolean 2909elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, 2910 asection *sec, const Elf_Internal_Rela *relocs) 2911{ 2912 Elf_Internal_Shdr *symtab_hdr; 2913 struct elf_link_hash_entry **sym_hashes; 2914 struct elf_link_hash_entry **sym_hashes_end; 2915 const Elf_Internal_Rela *rel; 2916 const Elf_Internal_Rela *rel_end; 2917 bfd *dynobj; 2918 asection *sreloc; 2919 bfd_vma *local_got_offsets; 2920 struct elf32_arm_link_hash_table *htab; 2921 2922 if (info->relocatable) 2923 return TRUE; 2924 2925 htab = elf32_arm_hash_table (info); 2926 sreloc = NULL; 2927 2928 dynobj = elf_hash_table (info)->dynobj; 2929 local_got_offsets = elf_local_got_offsets (abfd); 2930 2931 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2932 sym_hashes = elf_sym_hashes (abfd); 2933 sym_hashes_end = sym_hashes 2934 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym); 2935 2936 if (!elf_bad_symtab (abfd)) 2937 sym_hashes_end -= symtab_hdr->sh_info; 2938 2939 rel_end = relocs + sec->reloc_count; 2940 for (rel = relocs; rel < rel_end; rel++) 2941 { 2942 struct elf_link_hash_entry *h; 2943 unsigned long r_symndx; 2944 int r_type; 2945 2946 r_symndx = ELF32_R_SYM (rel->r_info); 2947 r_type = ELF32_R_TYPE (rel->r_info); 2948#ifndef OLD_ARM_ABI 2949 r_type = arm_real_reloc_type (htab, r_type); 2950#endif 2951 if (r_symndx < symtab_hdr->sh_info) 2952 h = NULL; 2953 else 2954 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2955 2956 switch (r_type) 2957 { 2958 case R_ARM_GOT32: 2959#ifndef OLD_ARM_ABI 2960 case R_ARM_GOT_PREL: 2961#endif 2962 /* This symbol requires a global offset table entry. */ 2963 if (h != NULL) 2964 { 2965 h->got.refcount++; 2966 } 2967 else 2968 { 2969 bfd_signed_vma *local_got_refcounts; 2970 2971 /* This is a global offset table entry for a local symbol. */ 2972 local_got_refcounts = elf_local_got_refcounts (abfd); 2973 if (local_got_refcounts == NULL) 2974 { 2975 bfd_size_type size; 2976 2977 size = symtab_hdr->sh_info; 2978 size *= (sizeof (bfd_signed_vma) + sizeof (char)); 2979 local_got_refcounts = bfd_zalloc (abfd, size); 2980 if (local_got_refcounts == NULL) 2981 return FALSE; 2982 elf_local_got_refcounts (abfd) = local_got_refcounts; 2983 } 2984 local_got_refcounts[r_symndx] += 1; 2985 } 2986 if (r_type == R_ARM_GOT32) 2987 break; 2988 /* Fall through. */ 2989 2990 case R_ARM_GOTOFF: 2991 case R_ARM_GOTPC: 2992 if (htab->sgot == NULL) 2993 { 2994 if (htab->root.dynobj == NULL) 2995 htab->root.dynobj = abfd; 2996 if (!create_got_section (htab->root.dynobj, info)) 2997 return FALSE; 2998 } 2999 break; 3000 3001 case R_ARM_ABS32: 3002 case R_ARM_REL32: 3003 case R_ARM_PC24: 3004 case R_ARM_PLT32: 3005#ifndef OLD_ARM_ABI 3006 case R_ARM_PREL31: 3007#endif 3008 if (h != NULL) 3009 { 3010 /* If this reloc is in a read-only section, we might 3011 need a copy reloc. We can't check reliably at this 3012 stage whether the section is read-only, as input 3013 sections have not yet been mapped to output sections. 3014 Tentatively set the flag for now, and correct in 3015 adjust_dynamic_symbol. */ 3016 if (!info->shared) 3017 h->non_got_ref = 1; 3018 3019 /* We may need a .plt entry if the function this reloc 3020 refers to is in a different object. We can't tell for 3021 sure yet, because something later might force the 3022 symbol local. */ 3023 if (r_type == R_ARM_PC24 3024 || r_type == R_ARM_PLT32) 3025 h->needs_plt = 1; 3026 3027 /* If we create a PLT entry, this relocation will reference 3028 it, even if it's an ABS32 relocation. */ 3029 h->plt.refcount += 1; 3030 } 3031 3032 /* If we are creating a shared library, and this is a reloc 3033 against a global symbol, or a non PC relative reloc 3034 against a local symbol, then we need to copy the reloc 3035 into the shared library. However, if we are linking with 3036 -Bsymbolic, we do not need to copy a reloc against a 3037 global symbol which is defined in an object we are 3038 including in the link (i.e., DEF_REGULAR is set). At 3039 this point we have not seen all the input files, so it is 3040 possible that DEF_REGULAR is not set now but will be set 3041 later (it is never cleared). We account for that 3042 possibility below by storing information in the 3043 relocs_copied field of the hash table entry. */ 3044 if (info->shared 3045 && (sec->flags & SEC_ALLOC) != 0 3046 && ((r_type != R_ARM_PC24 3047 && r_type != R_ARM_PLT32 3048#ifndef OLD_ARM_ABI 3049 && r_type != R_ARM_PREL31 3050#endif 3051 && r_type != R_ARM_REL32) 3052 || (h != NULL 3053 && (! info->symbolic 3054 || !h->def_regular)))) 3055 { 3056 struct elf32_arm_relocs_copied *p, **head; 3057 3058 /* When creating a shared object, we must copy these 3059 reloc types into the output file. We create a reloc 3060 section in dynobj and make room for this reloc. */ 3061 if (sreloc == NULL) 3062 { 3063 const char * name; 3064 3065 name = (bfd_elf_string_from_elf_section 3066 (abfd, 3067 elf_elfheader (abfd)->e_shstrndx, 3068 elf_section_data (sec)->rel_hdr.sh_name)); 3069 if (name == NULL) 3070 return FALSE; 3071 3072 BFD_ASSERT (strncmp (name, ".rel", 4) == 0 3073 && strcmp (bfd_get_section_name (abfd, sec), 3074 name + 4) == 0); 3075 3076 sreloc = bfd_get_section_by_name (dynobj, name); 3077 if (sreloc == NULL) 3078 { 3079 flagword flags; 3080 3081 sreloc = bfd_make_section (dynobj, name); 3082 flags = (SEC_HAS_CONTENTS | SEC_READONLY 3083 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 3084 if ((sec->flags & SEC_ALLOC) != 0 3085 /* BPABI objects never have dynamic 3086 relocations mapped. */ 3087 && !htab->symbian_p) 3088 flags |= SEC_ALLOC | SEC_LOAD; 3089 if (sreloc == NULL 3090 || ! bfd_set_section_flags (dynobj, sreloc, flags) 3091 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 3092 return FALSE; 3093 } 3094 3095 elf_section_data (sec)->sreloc = sreloc; 3096 } 3097 3098 /* If this is a global symbol, we count the number of 3099 relocations we need for this symbol. */ 3100 if (h != NULL) 3101 { 3102 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied; 3103 } 3104 else 3105 { 3106 /* Track dynamic relocs needed for local syms too. 3107 We really need local syms available to do this 3108 easily. Oh well. */ 3109 3110 asection *s; 3111 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 3112 sec, r_symndx); 3113 if (s == NULL) 3114 return FALSE; 3115 3116 head = ((struct elf32_arm_relocs_copied **) 3117 &elf_section_data (s)->local_dynrel); 3118 } 3119 3120 p = *head; 3121 if (p == NULL || p->section != sec) 3122 { 3123 bfd_size_type amt = sizeof *p; 3124 3125 p = bfd_alloc (htab->root.dynobj, amt); 3126 if (p == NULL) 3127 return FALSE; 3128 p->next = *head; 3129 *head = p; 3130 p->section = sec; 3131 p->count = 0; 3132 } 3133 3134 if (r_type == R_ARM_ABS32 3135#ifndef OLD_ARM_ABI 3136 || r_type == R_ARM_PREL31 3137#endif 3138 || r_type == R_ARM_REL32) 3139 p->count += 1; 3140 } 3141 break; 3142 3143 /* This relocation describes the C++ object vtable hierarchy. 3144 Reconstruct it for later use during GC. */ 3145 case R_ARM_GNU_VTINHERIT: 3146 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 3147 return FALSE; 3148 break; 3149 3150 /* This relocation describes which C++ vtable entries are actually 3151 used. Record for later use during GC. */ 3152 case R_ARM_GNU_VTENTRY: 3153 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 3154 return FALSE; 3155 break; 3156 } 3157 } 3158 3159 return TRUE; 3160} 3161 3162static bfd_boolean 3163is_arm_mapping_symbol_name (const char * name) 3164{ 3165 return (name != NULL) 3166 && (name[0] == '$') 3167 && ((name[1] == 'a') || (name[1] == 't') || (name[1] == 'd')) 3168 && (name[2] == 0); 3169} 3170 3171/* Treat mapping symbols as special target symbols. */ 3172 3173static bfd_boolean 3174elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym) 3175{ 3176 return is_arm_mapping_symbol_name (sym->name); 3177} 3178 3179/* This is a copy of elf_find_function() from elf.c except that 3180 ARM mapping symbols are ignored when looking for function names 3181 and STT_ARM_TFUNC is considered to a function type. */ 3182 3183static bfd_boolean 3184arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED, 3185 asection * section, 3186 asymbol ** symbols, 3187 bfd_vma offset, 3188 const char ** filename_ptr, 3189 const char ** functionname_ptr) 3190{ 3191 const char * filename = NULL; 3192 asymbol * func = NULL; 3193 bfd_vma low_func = 0; 3194 asymbol ** p; 3195 3196 for (p = symbols; *p != NULL; p++) 3197 { 3198 elf_symbol_type *q; 3199 3200 q = (elf_symbol_type *) *p; 3201 3202 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info)) 3203 { 3204 default: 3205 break; 3206 case STT_FILE: 3207 filename = bfd_asymbol_name (&q->symbol); 3208 break; 3209 case STT_FUNC: 3210 case STT_ARM_TFUNC: 3211 /* Skip $a and $t symbols. */ 3212 if ((q->symbol.flags & BSF_LOCAL) 3213 && is_arm_mapping_symbol_name (q->symbol.name)) 3214 continue; 3215 /* Fall through. */ 3216 case STT_NOTYPE: 3217 if (bfd_get_section (&q->symbol) == section 3218 && q->symbol.value >= low_func 3219 && q->symbol.value <= offset) 3220 { 3221 func = (asymbol *) q; 3222 low_func = q->symbol.value; 3223 } 3224 break; 3225 } 3226 } 3227 3228 if (func == NULL) 3229 return FALSE; 3230 3231 if (filename_ptr) 3232 *filename_ptr = filename; 3233 if (functionname_ptr) 3234 *functionname_ptr = bfd_asymbol_name (func); 3235 3236 return TRUE; 3237} 3238 3239 3240/* Find the nearest line to a particular section and offset, for error 3241 reporting. This code is a duplicate of the code in elf.c, except 3242 that it uses arm_elf_find_function. */ 3243 3244static bfd_boolean 3245elf32_arm_find_nearest_line (bfd * abfd, 3246 asection * section, 3247 asymbol ** symbols, 3248 bfd_vma offset, 3249 const char ** filename_ptr, 3250 const char ** functionname_ptr, 3251 unsigned int * line_ptr) 3252{ 3253 bfd_boolean found = FALSE; 3254 3255 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */ 3256 3257 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset, 3258 filename_ptr, functionname_ptr, 3259 line_ptr, 0, 3260 & elf_tdata (abfd)->dwarf2_find_line_info)) 3261 { 3262 if (!*functionname_ptr) 3263 arm_elf_find_function (abfd, section, symbols, offset, 3264 *filename_ptr ? NULL : filename_ptr, 3265 functionname_ptr); 3266 3267 return TRUE; 3268 } 3269 3270 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, 3271 & found, filename_ptr, 3272 functionname_ptr, line_ptr, 3273 & elf_tdata (abfd)->line_info)) 3274 return FALSE; 3275 3276 if (found && (*functionname_ptr || *line_ptr)) 3277 return TRUE; 3278 3279 if (symbols == NULL) 3280 return FALSE; 3281 3282 if (! arm_elf_find_function (abfd, section, symbols, offset, 3283 filename_ptr, functionname_ptr)) 3284 return FALSE; 3285 3286 *line_ptr = 0; 3287 return TRUE; 3288} 3289 3290/* Adjust a symbol defined by a dynamic object and referenced by a 3291 regular object. The current definition is in some section of the 3292 dynamic object, but we're not including those sections. We have to 3293 change the definition to something the rest of the link can 3294 understand. */ 3295 3296static bfd_boolean 3297elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info, 3298 struct elf_link_hash_entry * h) 3299{ 3300 bfd * dynobj; 3301 asection * s; 3302 unsigned int power_of_two; 3303 3304 dynobj = elf_hash_table (info)->dynobj; 3305 3306 /* Make sure we know what is going on here. */ 3307 BFD_ASSERT (dynobj != NULL 3308 && (h->needs_plt 3309 || h->u.weakdef != NULL 3310 || (h->def_dynamic 3311 && h->ref_regular 3312 && !h->def_regular))); 3313 3314 /* If this is a function, put it in the procedure linkage table. We 3315 will fill in the contents of the procedure linkage table later, 3316 when we know the address of the .got section. */ 3317 if (h->type == STT_FUNC 3318 || h->needs_plt) 3319 { 3320 if (h->plt.refcount <= 0 3321 || SYMBOL_CALLS_LOCAL (info, h) 3322 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 3323 && h->root.type == bfd_link_hash_undefweak)) 3324 { 3325 /* This case can occur if we saw a PLT32 reloc in an input 3326 file, but the symbol was never referred to by a dynamic 3327 object, or if all references were garbage collected. In 3328 such a case, we don't actually need to build a procedure 3329 linkage table, and we can just do a PC24 reloc instead. */ 3330 h->plt.offset = (bfd_vma) -1; 3331 h->needs_plt = 0; 3332 } 3333 3334 return TRUE; 3335 } 3336 else 3337 /* It's possible that we incorrectly decided a .plt reloc was 3338 needed for an R_ARM_PC24 reloc to a non-function sym in 3339 check_relocs. We can't decide accurately between function and 3340 non-function syms in check-relocs; Objects loaded later in 3341 the link may change h->type. So fix it now. */ 3342 h->plt.offset = (bfd_vma) -1; 3343 3344 /* If this is a weak symbol, and there is a real definition, the 3345 processor independent code will have arranged for us to see the 3346 real definition first, and we can just use the same value. */ 3347 if (h->u.weakdef != NULL) 3348 { 3349 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 3350 || h->u.weakdef->root.type == bfd_link_hash_defweak); 3351 h->root.u.def.section = h->u.weakdef->root.u.def.section; 3352 h->root.u.def.value = h->u.weakdef->root.u.def.value; 3353 return TRUE; 3354 } 3355 3356 /* This is a reference to a symbol defined by a dynamic object which 3357 is not a function. */ 3358 3359 /* If we are creating a shared library, we must presume that the 3360 only references to the symbol are via the global offset table. 3361 For such cases we need not do anything here; the relocations will 3362 be handled correctly by relocate_section. */ 3363 if (info->shared) 3364 return TRUE; 3365 3366 /* We must allocate the symbol in our .dynbss section, which will 3367 become part of the .bss section of the executable. There will be 3368 an entry for this symbol in the .dynsym section. The dynamic 3369 object will contain position independent code, so all references 3370 from the dynamic object to this symbol will go through the global 3371 offset table. The dynamic linker will use the .dynsym entry to 3372 determine the address it must put in the global offset table, so 3373 both the dynamic object and the regular object will refer to the 3374 same memory location for the variable. */ 3375 s = bfd_get_section_by_name (dynobj, ".dynbss"); 3376 BFD_ASSERT (s != NULL); 3377 3378 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to 3379 copy the initial value out of the dynamic object and into the 3380 runtime process image. We need to remember the offset into the 3381 .rel.bss section we are going to use. */ 3382 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 3383 { 3384 asection *srel; 3385 3386 srel = bfd_get_section_by_name (dynobj, ".rel.bss"); 3387 BFD_ASSERT (srel != NULL); 3388 srel->size += sizeof (Elf32_External_Rel); 3389 h->needs_copy = 1; 3390 } 3391 3392 /* We need to figure out the alignment required for this symbol. I 3393 have no idea how ELF linkers handle this. */ 3394 power_of_two = bfd_log2 (h->size); 3395 if (power_of_two > 3) 3396 power_of_two = 3; 3397 3398 /* Apply the required alignment. */ 3399 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two)); 3400 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 3401 { 3402 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 3403 return FALSE; 3404 } 3405 3406 /* Define the symbol as being at this point in the section. */ 3407 h->root.u.def.section = s; 3408 h->root.u.def.value = s->size; 3409 3410 /* Increment the section size to make room for the symbol. */ 3411 s->size += h->size; 3412 3413 return TRUE; 3414} 3415 3416/* Allocate space in .plt, .got and associated reloc sections for 3417 dynamic relocs. */ 3418 3419static bfd_boolean 3420allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) 3421{ 3422 struct bfd_link_info *info; 3423 struct elf32_arm_link_hash_table *htab; 3424 struct elf32_arm_link_hash_entry *eh; 3425 struct elf32_arm_relocs_copied *p; 3426 3427 if (h->root.type == bfd_link_hash_indirect) 3428 return TRUE; 3429 3430 if (h->root.type == bfd_link_hash_warning) 3431 /* When warning symbols are created, they **replace** the "real" 3432 entry in the hash table, thus we never get to see the real 3433 symbol in a hash traversal. So look at it now. */ 3434 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3435 3436 info = (struct bfd_link_info *) inf; 3437 htab = elf32_arm_hash_table (info); 3438 3439 if (htab->root.dynamic_sections_created 3440 && h->plt.refcount > 0) 3441 { 3442 /* Make sure this symbol is output as a dynamic symbol. 3443 Undefined weak syms won't yet be marked as dynamic. */ 3444 if (h->dynindx == -1 3445 && !h->forced_local) 3446 { 3447 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3448 return FALSE; 3449 } 3450 3451 if (info->shared 3452 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 3453 { 3454 asection *s = htab->splt; 3455 3456 /* If this is the first .plt entry, make room for the special 3457 first entry. */ 3458 if (s->size == 0) 3459 s->size += htab->plt_header_size; 3460 3461 h->plt.offset = s->size; 3462 3463 /* If this symbol is not defined in a regular file, and we are 3464 not generating a shared library, then set the symbol to this 3465 location in the .plt. This is required to make function 3466 pointers compare as equal between the normal executable and 3467 the shared library. */ 3468 if (! info->shared 3469 && !h->def_regular) 3470 { 3471 h->root.u.def.section = s; 3472 h->root.u.def.value = h->plt.offset; 3473 } 3474 3475 /* Make room for this entry. */ 3476 s->size += htab->plt_entry_size; 3477 3478 if (!htab->symbian_p) 3479 /* We also need to make an entry in the .got.plt section, which 3480 will be placed in the .got section by the linker script. */ 3481 htab->sgotplt->size += 4; 3482 3483 /* We also need to make an entry in the .rel.plt section. */ 3484 htab->srelplt->size += sizeof (Elf32_External_Rel); 3485 } 3486 else 3487 { 3488 h->plt.offset = (bfd_vma) -1; 3489 h->needs_plt = 0; 3490 } 3491 } 3492 else 3493 { 3494 h->plt.offset = (bfd_vma) -1; 3495 h->needs_plt = 0; 3496 } 3497 3498 if (h->got.refcount > 0) 3499 { 3500 asection *s; 3501 bfd_boolean dyn; 3502 3503 /* Make sure this symbol is output as a dynamic symbol. 3504 Undefined weak syms won't yet be marked as dynamic. */ 3505 if (h->dynindx == -1 3506 && !h->forced_local) 3507 { 3508 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3509 return FALSE; 3510 } 3511 3512 if (!htab->symbian_p) 3513 { 3514 s = htab->sgot; 3515 h->got.offset = s->size; 3516 s->size += 4; 3517 dyn = htab->root.dynamic_sections_created; 3518 if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 3519 || h->root.type != bfd_link_hash_undefweak) 3520 && (info->shared 3521 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 3522 htab->srelgot->size += sizeof (Elf32_External_Rel); 3523 } 3524 } 3525 else 3526 h->got.offset = (bfd_vma) -1; 3527 3528 eh = (struct elf32_arm_link_hash_entry *) h; 3529 if (eh->relocs_copied == NULL) 3530 return TRUE; 3531 3532 /* In the shared -Bsymbolic case, discard space allocated for 3533 dynamic pc-relative relocs against symbols which turn out to be 3534 defined in regular objects. For the normal shared case, discard 3535 space for pc-relative relocs that have become local due to symbol 3536 visibility changes. */ 3537 3538 if (info->shared) 3539 { 3540 /* Discard relocs on undefined weak syms with non-default 3541 visibility. */ 3542 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 3543 && h->root.type == bfd_link_hash_undefweak) 3544 eh->relocs_copied = NULL; 3545 } 3546 else 3547 { 3548 /* For the non-shared case, discard space for relocs against 3549 symbols which turn out to need copy relocs or are not 3550 dynamic. */ 3551 3552 if (!h->non_got_ref 3553 && ((h->def_dynamic 3554 && !h->def_regular) 3555 || (htab->root.dynamic_sections_created 3556 && (h->root.type == bfd_link_hash_undefweak 3557 || h->root.type == bfd_link_hash_undefined)))) 3558 { 3559 /* Make sure this symbol is output as a dynamic symbol. 3560 Undefined weak syms won't yet be marked as dynamic. */ 3561 if (h->dynindx == -1 3562 && !h->forced_local) 3563 { 3564 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3565 return FALSE; 3566 } 3567 3568 /* If that succeeded, we know we'll be keeping all the 3569 relocs. */ 3570 if (h->dynindx != -1) 3571 goto keep; 3572 } 3573 3574 eh->relocs_copied = NULL; 3575 3576 keep: ; 3577 } 3578 3579 /* Finally, allocate space. */ 3580 for (p = eh->relocs_copied; p != NULL; p = p->next) 3581 { 3582 asection *sreloc = elf_section_data (p->section)->sreloc; 3583 sreloc->size += p->count * sizeof (Elf32_External_Rel); 3584 } 3585 3586 return TRUE; 3587} 3588 3589/* Set the sizes of the dynamic sections. */ 3590 3591static bfd_boolean 3592elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, 3593 struct bfd_link_info * info) 3594{ 3595 bfd * dynobj; 3596 asection * s; 3597 bfd_boolean plt; 3598 bfd_boolean relocs; 3599 bfd *ibfd; 3600 struct elf32_arm_link_hash_table *htab; 3601 3602 htab = elf32_arm_hash_table (info); 3603 dynobj = elf_hash_table (info)->dynobj; 3604 BFD_ASSERT (dynobj != NULL); 3605 3606 if (elf_hash_table (info)->dynamic_sections_created) 3607 { 3608 /* Set the contents of the .interp section to the interpreter. */ 3609 if (info->executable) 3610 { 3611 s = bfd_get_section_by_name (dynobj, ".interp"); 3612 BFD_ASSERT (s != NULL); 3613 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 3614 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 3615 } 3616 } 3617 3618 /* Set up .got offsets for local syms, and space for local dynamic 3619 relocs. */ 3620 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 3621 { 3622 bfd_signed_vma *local_got; 3623 bfd_signed_vma *end_local_got; 3624 char *local_tls_type; 3625 bfd_size_type locsymcount; 3626 Elf_Internal_Shdr *symtab_hdr; 3627 asection *srel; 3628 3629 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 3630 continue; 3631 3632 for (s = ibfd->sections; s != NULL; s = s->next) 3633 { 3634 struct elf32_arm_relocs_copied *p; 3635 3636 for (p = *((struct elf32_arm_relocs_copied **) 3637 &elf_section_data (s)->local_dynrel); 3638 p != NULL; 3639 p = p->next) 3640 { 3641 if (!bfd_is_abs_section (p->section) 3642 && bfd_is_abs_section (p->section->output_section)) 3643 { 3644 /* Input section has been discarded, either because 3645 it is a copy of a linkonce section or due to 3646 linker script /DISCARD/, so we'll be discarding 3647 the relocs too. */ 3648 } 3649 else if (p->count != 0) 3650 { 3651 srel = elf_section_data (p->section)->sreloc; 3652 srel->size += p->count * sizeof (Elf32_External_Rel); 3653 if ((p->section->output_section->flags & SEC_READONLY) != 0) 3654 info->flags |= DF_TEXTREL; 3655 } 3656 } 3657 } 3658 3659 local_got = elf_local_got_refcounts (ibfd); 3660 if (!local_got) 3661 continue; 3662 3663 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 3664 locsymcount = symtab_hdr->sh_info; 3665 end_local_got = local_got + locsymcount; 3666 s = htab->sgot; 3667 srel = htab->srelgot; 3668 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 3669 { 3670 if (*local_got > 0) 3671 { 3672 *local_got = s->size; 3673 s->size += 4; 3674 if (info->shared) 3675 srel->size += sizeof (Elf32_External_Rel); 3676 } 3677 else 3678 *local_got = (bfd_vma) -1; 3679 } 3680 } 3681 3682 /* Allocate global sym .plt and .got entries, and space for global 3683 sym dynamic relocs. */ 3684 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info); 3685 3686 /* The check_relocs and adjust_dynamic_symbol entry points have 3687 determined the sizes of the various dynamic sections. Allocate 3688 memory for them. */ 3689 plt = FALSE; 3690 relocs = FALSE; 3691 for (s = dynobj->sections; s != NULL; s = s->next) 3692 { 3693 const char * name; 3694 bfd_boolean strip; 3695 3696 if ((s->flags & SEC_LINKER_CREATED) == 0) 3697 continue; 3698 3699 /* It's OK to base decisions on the section name, because none 3700 of the dynobj section names depend upon the input files. */ 3701 name = bfd_get_section_name (dynobj, s); 3702 3703 strip = FALSE; 3704 3705 if (strcmp (name, ".plt") == 0) 3706 { 3707 if (s->size == 0) 3708 { 3709 /* Strip this section if we don't need it; see the 3710 comment below. */ 3711 strip = TRUE; 3712 } 3713 else 3714 { 3715 /* Remember whether there is a PLT. */ 3716 plt = TRUE; 3717 } 3718 } 3719 else if (strncmp (name, ".rel", 4) == 0) 3720 { 3721 if (s->size == 0) 3722 { 3723 /* If we don't need this section, strip it from the 3724 output file. This is mostly to handle .rel.bss and 3725 .rel.plt. We must create both sections in 3726 create_dynamic_sections, because they must be created 3727 before the linker maps input sections to output 3728 sections. The linker does that before 3729 adjust_dynamic_symbol is called, and it is that 3730 function which decides whether anything needs to go 3731 into these sections. */ 3732 strip = TRUE; 3733 } 3734 else 3735 { 3736 /* Remember whether there are any reloc sections other 3737 than .rel.plt. */ 3738 if (strcmp (name, ".rel.plt") != 0) 3739 relocs = TRUE; 3740 3741 /* We use the reloc_count field as a counter if we need 3742 to copy relocs into the output file. */ 3743 s->reloc_count = 0; 3744 } 3745 } 3746 else if (strncmp (name, ".got", 4) != 0) 3747 { 3748 /* It's not one of our sections, so don't allocate space. */ 3749 continue; 3750 } 3751 3752 if (strip) 3753 { 3754 _bfd_strip_section_from_output (info, s); 3755 continue; 3756 } 3757 3758 /* Allocate memory for the section contents. */ 3759 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 3760 if (s->contents == NULL && s->size != 0) 3761 return FALSE; 3762 } 3763 3764 if (elf_hash_table (info)->dynamic_sections_created) 3765 { 3766 /* Add some entries to the .dynamic section. We fill in the 3767 values later, in elf32_arm_finish_dynamic_sections, but we 3768 must add the entries now so that we get the correct size for 3769 the .dynamic section. The DT_DEBUG entry is filled in by the 3770 dynamic linker and used by the debugger. */ 3771#define add_dynamic_entry(TAG, VAL) \ 3772 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 3773 3774 if (!info->shared) 3775 { 3776 if (!add_dynamic_entry (DT_DEBUG, 0)) 3777 return FALSE; 3778 } 3779 3780 if (plt) 3781 { 3782 if ( !add_dynamic_entry (DT_PLTGOT, 0) 3783 || !add_dynamic_entry (DT_PLTRELSZ, 0) 3784 || !add_dynamic_entry (DT_PLTREL, DT_REL) 3785 || !add_dynamic_entry (DT_JMPREL, 0)) 3786 return FALSE; 3787 } 3788 3789 if (relocs) 3790 { 3791 if ( !add_dynamic_entry (DT_REL, 0) 3792 || !add_dynamic_entry (DT_RELSZ, 0) 3793 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel))) 3794 return FALSE; 3795 } 3796 3797 if ((info->flags & DF_TEXTREL) != 0) 3798 { 3799 if (!add_dynamic_entry (DT_TEXTREL, 0)) 3800 return FALSE; 3801 info->flags |= DF_TEXTREL; 3802 } 3803 } 3804#undef add_synamic_entry 3805 3806 return TRUE; 3807} 3808 3809/* Finish up dynamic symbol handling. We set the contents of various 3810 dynamic sections here. */ 3811 3812static bfd_boolean 3813elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info, 3814 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym) 3815{ 3816 bfd * dynobj; 3817 struct elf32_arm_link_hash_table *htab; 3818 3819 dynobj = elf_hash_table (info)->dynobj; 3820 htab = elf32_arm_hash_table (info); 3821 3822 if (h->plt.offset != (bfd_vma) -1) 3823 { 3824 asection * splt; 3825 asection * srel; 3826 bfd_byte *loc; 3827 bfd_vma plt_index; 3828 Elf_Internal_Rela rel; 3829 3830 /* This symbol has an entry in the procedure linkage table. Set 3831 it up. */ 3832 3833 BFD_ASSERT (h->dynindx != -1); 3834 3835 splt = bfd_get_section_by_name (dynobj, ".plt"); 3836 srel = bfd_get_section_by_name (dynobj, ".rel.plt"); 3837 BFD_ASSERT (splt != NULL && srel != NULL); 3838 3839 /* Get the index in the procedure linkage table which 3840 corresponds to this symbol. This is the index of this symbol 3841 in all the symbols for which we are making plt entries. The 3842 first entry in the procedure linkage table is reserved. */ 3843 plt_index = ((h->plt.offset - htab->plt_header_size) 3844 / htab->plt_entry_size); 3845 3846 /* Fill in the entry in the procedure linkage table. */ 3847 if (htab->symbian_p) 3848 { 3849 unsigned i; 3850 for (i = 0; i < htab->plt_entry_size / 4; ++i) 3851 bfd_put_32 (output_bfd, 3852 elf32_arm_symbian_plt_entry[i], 3853 splt->contents + h->plt.offset + 4 * i); 3854 3855 /* Fill in the entry in the .rel.plt section. */ 3856 rel.r_offset = (splt->output_section->vma 3857 + splt->output_offset 3858 + h->plt.offset + 4 * (i - 1)); 3859 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT); 3860 } 3861 else 3862 { 3863 bfd_vma got_offset; 3864 bfd_vma got_displacement; 3865 asection * sgot; 3866 3867 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 3868 BFD_ASSERT (sgot != NULL); 3869 3870 /* Get the offset into the .got table of the entry that 3871 corresponds to this function. Each .got entry is 4 bytes. 3872 The first three are reserved. */ 3873 got_offset = (plt_index + 3) * 4; 3874 3875 /* Calculate the displacement between the PLT slot and the 3876 entry in the GOT. */ 3877 got_displacement = (sgot->output_section->vma 3878 + sgot->output_offset 3879 + got_offset 3880 - splt->output_section->vma 3881 - splt->output_offset 3882 - h->plt.offset 3883 - 8); 3884 3885 BFD_ASSERT ((got_displacement & 0xf0000000) == 0); 3886 3887 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20), 3888 splt->contents + h->plt.offset + 0); 3889 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12), 3890 splt->contents + h->plt.offset + 4); 3891 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff), 3892 splt->contents + h->plt.offset + 8); 3893#ifdef FOUR_WORD_PLT 3894 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], 3895 splt->contents + h->plt.offset + 12); 3896#endif 3897 3898 /* Fill in the entry in the global offset table. */ 3899 bfd_put_32 (output_bfd, 3900 (splt->output_section->vma 3901 + splt->output_offset), 3902 sgot->contents + got_offset); 3903 3904 /* Fill in the entry in the .rel.plt section. */ 3905 rel.r_offset = (sgot->output_section->vma 3906 + sgot->output_offset 3907 + got_offset); 3908 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT); 3909 } 3910 3911 loc = srel->contents + plt_index * sizeof (Elf32_External_Rel); 3912 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 3913 3914 if (!h->def_regular) 3915 { 3916 /* Mark the symbol as undefined, rather than as defined in 3917 the .plt section. Leave the value alone. */ 3918 sym->st_shndx = SHN_UNDEF; 3919 /* If the symbol is weak, we do need to clear the value. 3920 Otherwise, the PLT entry would provide a definition for 3921 the symbol even if the symbol wasn't defined anywhere, 3922 and so the symbol would never be NULL. */ 3923 if (!h->ref_regular_nonweak) 3924 sym->st_value = 0; 3925 } 3926 } 3927 3928 if (h->got.offset != (bfd_vma) -1) 3929 { 3930 asection * sgot; 3931 asection * srel; 3932 Elf_Internal_Rela rel; 3933 bfd_byte *loc; 3934 3935 /* This symbol has an entry in the global offset table. Set it 3936 up. */ 3937 sgot = bfd_get_section_by_name (dynobj, ".got"); 3938 srel = bfd_get_section_by_name (dynobj, ".rel.got"); 3939 BFD_ASSERT (sgot != NULL && srel != NULL); 3940 3941 rel.r_offset = (sgot->output_section->vma 3942 + sgot->output_offset 3943 + (h->got.offset &~ (bfd_vma) 1)); 3944 3945 /* If this is a static link, or it is a -Bsymbolic link and the 3946 symbol is defined locally or was forced to be local because 3947 of a version file, we just want to emit a RELATIVE reloc. 3948 The entry in the global offset table will already have been 3949 initialized in the relocate_section function. */ 3950 if (info->shared 3951 && SYMBOL_REFERENCES_LOCAL (info, h)) 3952 { 3953 BFD_ASSERT((h->got.offset & 1) != 0); 3954 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); 3955 } 3956 else 3957 { 3958 BFD_ASSERT((h->got.offset & 1) == 0); 3959 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 3960 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT); 3961 } 3962 3963 loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel); 3964 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 3965 } 3966 3967 if (h->needs_copy) 3968 { 3969 asection * s; 3970 Elf_Internal_Rela rel; 3971 bfd_byte *loc; 3972 3973 /* This symbol needs a copy reloc. Set it up. */ 3974 BFD_ASSERT (h->dynindx != -1 3975 && (h->root.type == bfd_link_hash_defined 3976 || h->root.type == bfd_link_hash_defweak)); 3977 3978 s = bfd_get_section_by_name (h->root.u.def.section->owner, 3979 ".rel.bss"); 3980 BFD_ASSERT (s != NULL); 3981 3982 rel.r_offset = (h->root.u.def.value 3983 + h->root.u.def.section->output_section->vma 3984 + h->root.u.def.section->output_offset); 3985 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY); 3986 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel); 3987 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 3988 } 3989 3990 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 3991 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 3992 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 3993 sym->st_shndx = SHN_ABS; 3994 3995 return TRUE; 3996} 3997 3998/* Finish up the dynamic sections. */ 3999 4000static bfd_boolean 4001elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info) 4002{ 4003 bfd * dynobj; 4004 asection * sgot; 4005 asection * sdyn; 4006 4007 dynobj = elf_hash_table (info)->dynobj; 4008 4009 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 4010 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL); 4011 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 4012 4013 if (elf_hash_table (info)->dynamic_sections_created) 4014 { 4015 asection *splt; 4016 Elf32_External_Dyn *dyncon, *dynconend; 4017 struct elf32_arm_link_hash_table *htab; 4018 4019 htab = elf32_arm_hash_table (info); 4020 splt = bfd_get_section_by_name (dynobj, ".plt"); 4021 BFD_ASSERT (splt != NULL && sdyn != NULL); 4022 4023 dyncon = (Elf32_External_Dyn *) sdyn->contents; 4024 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 4025 4026 for (; dyncon < dynconend; dyncon++) 4027 { 4028 Elf_Internal_Dyn dyn; 4029 const char * name; 4030 asection * s; 4031 4032 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 4033 4034 switch (dyn.d_tag) 4035 { 4036 unsigned int type; 4037 4038 default: 4039 break; 4040 4041 case DT_HASH: 4042 name = ".hash"; 4043 goto get_vma_if_bpabi; 4044 case DT_STRTAB: 4045 name = ".dynstr"; 4046 goto get_vma_if_bpabi; 4047 case DT_SYMTAB: 4048 name = ".dynsym"; 4049 goto get_vma_if_bpabi; 4050 case DT_VERSYM: 4051 name = ".gnu.version"; 4052 goto get_vma_if_bpabi; 4053 case DT_VERDEF: 4054 name = ".gnu.version_d"; 4055 goto get_vma_if_bpabi; 4056 case DT_VERNEED: 4057 name = ".gnu.version_r"; 4058 goto get_vma_if_bpabi; 4059 4060 case DT_PLTGOT: 4061 name = ".got"; 4062 goto get_vma; 4063 case DT_JMPREL: 4064 name = ".rel.plt"; 4065 get_vma: 4066 s = bfd_get_section_by_name (output_bfd, name); 4067 BFD_ASSERT (s != NULL); 4068 if (!htab->symbian_p) 4069 dyn.d_un.d_ptr = s->vma; 4070 else 4071 /* In the BPABI, tags in the PT_DYNAMIC section point 4072 at the file offset, not the memory address, for the 4073 convenience of the post linker. */ 4074 dyn.d_un.d_ptr = s->filepos; 4075 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4076 break; 4077 4078 get_vma_if_bpabi: 4079 if (htab->symbian_p) 4080 goto get_vma; 4081 break; 4082 4083 case DT_PLTRELSZ: 4084 s = bfd_get_section_by_name (output_bfd, ".rel.plt"); 4085 BFD_ASSERT (s != NULL); 4086 dyn.d_un.d_val = s->size; 4087 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4088 break; 4089 4090 case DT_RELSZ: 4091 if (!htab->symbian_p) 4092 { 4093 /* My reading of the SVR4 ABI indicates that the 4094 procedure linkage table relocs (DT_JMPREL) should be 4095 included in the overall relocs (DT_REL). This is 4096 what Solaris does. However, UnixWare can not handle 4097 that case. Therefore, we override the DT_RELSZ entry 4098 here to make it not include the JMPREL relocs. Since 4099 the linker script arranges for .rel.plt to follow all 4100 other relocation sections, we don't have to worry 4101 about changing the DT_REL entry. */ 4102 s = bfd_get_section_by_name (output_bfd, ".rel.plt"); 4103 if (s != NULL) 4104 dyn.d_un.d_val -= s->size; 4105 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4106 break; 4107 } 4108 /* Fall through */ 4109 4110 case DT_REL: 4111 case DT_RELA: 4112 case DT_RELASZ: 4113 /* In the BPABI, the DT_REL tag must point at the file 4114 offset, not the VMA, of the first relocation 4115 section. So, we use code similar to that in 4116 elflink.c, but do not check for SHF_ALLOC on the 4117 relcoation section, since relocations sections are 4118 never allocated under the BPABI. The comments above 4119 about Unixware notwithstanding, we include all of the 4120 relocations here. */ 4121 if (htab->symbian_p) 4122 { 4123 unsigned int i; 4124 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ) 4125 ? SHT_REL : SHT_RELA); 4126 dyn.d_un.d_val = 0; 4127 for (i = 1; i < elf_numsections (output_bfd); i++) 4128 { 4129 Elf_Internal_Shdr *hdr 4130 = elf_elfsections (output_bfd)[i]; 4131 if (hdr->sh_type == type) 4132 { 4133 if (dyn.d_tag == DT_RELSZ 4134 || dyn.d_tag == DT_RELASZ) 4135 dyn.d_un.d_val += hdr->sh_size; 4136 else if (dyn.d_un.d_val == 0 4137 || hdr->sh_offset < dyn.d_un.d_val) 4138 dyn.d_un.d_val = hdr->sh_offset; 4139 } 4140 } 4141 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4142 } 4143 break; 4144 4145 /* Set the bottom bit of DT_INIT/FINI if the 4146 corresponding function is Thumb. */ 4147 case DT_INIT: 4148 name = info->init_function; 4149 goto get_sym; 4150 case DT_FINI: 4151 name = info->fini_function; 4152 get_sym: 4153 /* If it wasn't set by elf_bfd_final_link 4154 then there is nothing to adjust. */ 4155 if (dyn.d_un.d_val != 0) 4156 { 4157 struct elf_link_hash_entry * eh; 4158 4159 eh = elf_link_hash_lookup (elf_hash_table (info), name, 4160 FALSE, FALSE, TRUE); 4161 if (eh != (struct elf_link_hash_entry *) NULL 4162 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC) 4163 { 4164 dyn.d_un.d_val |= 1; 4165 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 4166 } 4167 } 4168 break; 4169 } 4170 } 4171 4172 /* Fill in the first entry in the procedure linkage table. */ 4173 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size) 4174 { 4175 bfd_vma got_displacement; 4176 4177 /* Calculate the displacement between the PLT slot and &GOT[0]. */ 4178 got_displacement = (sgot->output_section->vma 4179 + sgot->output_offset 4180 - splt->output_section->vma 4181 - splt->output_offset 4182 - 16); 4183 4184 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0); 4185 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4); 4186 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8); 4187 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12); 4188#ifdef FOUR_WORD_PLT 4189 /* The displacement value goes in the otherwise-unused last word of 4190 the second entry. */ 4191 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28); 4192#else 4193 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16); 4194#endif 4195 } 4196 4197 /* UnixWare sets the entsize of .plt to 4, although that doesn't 4198 really seem like the right value. */ 4199 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 4200 } 4201 4202 /* Fill in the first three entries in the global offset table. */ 4203 if (sgot) 4204 { 4205 if (sgot->size > 0) 4206 { 4207 if (sdyn == NULL) 4208 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 4209 else 4210 bfd_put_32 (output_bfd, 4211 sdyn->output_section->vma + sdyn->output_offset, 4212 sgot->contents); 4213 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 4214 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 4215 } 4216 4217 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 4218 } 4219 4220 return TRUE; 4221} 4222 4223static void 4224elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED) 4225{ 4226 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */ 4227 struct elf32_arm_link_hash_table *globals; 4228 4229 i_ehdrp = elf_elfheader (abfd); 4230 4231 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION; 4232 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION; 4233 4234 if (link_info) 4235 { 4236 globals = elf32_arm_hash_table (link_info); 4237 if (globals->byteswap_code) 4238 i_ehdrp->e_flags |= EF_ARM_BE8; 4239 } 4240} 4241 4242static enum elf_reloc_type_class 4243elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela) 4244{ 4245 switch ((int) ELF32_R_TYPE (rela->r_info)) 4246 { 4247 case R_ARM_RELATIVE: 4248 return reloc_class_relative; 4249 case R_ARM_JUMP_SLOT: 4250 return reloc_class_plt; 4251 case R_ARM_COPY: 4252 return reloc_class_copy; 4253 default: 4254 return reloc_class_normal; 4255 } 4256} 4257 4258/* Set the right machine number for an Arm ELF file. */ 4259 4260static bfd_boolean 4261elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr) 4262{ 4263 if (hdr->sh_type == SHT_NOTE) 4264 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS; 4265 4266 return TRUE; 4267} 4268 4269static void 4270elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED) 4271{ 4272 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION); 4273} 4274 4275/* Return TRUE if this is an unwinding table entry. */ 4276 4277static bfd_boolean 4278is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name) 4279{ 4280 size_t len1, len2; 4281 4282 len1 = sizeof (ELF_STRING_ARM_unwind) - 1; 4283 len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1; 4284 return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0 4285 || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0); 4286} 4287 4288 4289/* Set the type and flags for an ARM section. We do this by 4290 the section name, which is a hack, but ought to work. */ 4291 4292static bfd_boolean 4293elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec) 4294{ 4295 const char * name; 4296 4297 name = bfd_get_section_name (abfd, sec); 4298 4299 if (is_arm_elf_unwind_section_name (abfd, name)) 4300 { 4301 hdr->sh_type = SHT_ARM_EXIDX; 4302 hdr->sh_flags |= SHF_LINK_ORDER; 4303 } 4304 return TRUE; 4305} 4306 4307/* Handle an ARM specific section when reading an object file. 4308 This is called when elf.c finds a section with an unknown type. */ 4309 4310static bfd_boolean 4311elf32_arm_section_from_shdr (bfd *abfd, 4312 Elf_Internal_Shdr * hdr, 4313 const char *name) 4314{ 4315 /* There ought to be a place to keep ELF backend specific flags, but 4316 at the moment there isn't one. We just keep track of the 4317 sections by their name, instead. Fortunately, the ABI gives 4318 names for all the ARM specific sections, so we will probably get 4319 away with this. */ 4320 switch (hdr->sh_type) 4321 { 4322 case SHT_ARM_EXIDX: 4323 break; 4324 4325 default: 4326 return FALSE; 4327 } 4328 4329 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name)) 4330 return FALSE; 4331 4332 return TRUE; 4333} 4334 4335/* Called for each symbol. Builds a section map based on mapping symbols. 4336 Does not alter any of the symbols. */ 4337 4338static bfd_boolean 4339elf32_arm_output_symbol_hook (struct bfd_link_info *info, 4340 const char *name, 4341 Elf_Internal_Sym *elfsym, 4342 asection *input_sec, 4343 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) 4344{ 4345 int mapcount; 4346 elf32_arm_section_map *map; 4347 struct elf32_arm_link_hash_table *globals; 4348 4349 /* Only do this on final link. */ 4350 if (info->relocatable) 4351 return TRUE; 4352 4353 /* Only build a map if we need to byteswap code. */ 4354 globals = elf32_arm_hash_table (info); 4355 if (!globals->byteswap_code) 4356 return TRUE; 4357 4358 /* We only want mapping symbols. */ 4359 if (! is_arm_mapping_symbol_name (name)) 4360 return TRUE; 4361 4362 mapcount = ++(elf32_arm_section_data (input_sec)->mapcount); 4363 map = elf32_arm_section_data (input_sec)->map; 4364 /* TODO: This may be inefficient, but we probably don't usually have many 4365 mapping symbols per section. */ 4366 map = bfd_realloc (map, mapcount * sizeof (elf32_arm_section_map)); 4367 elf32_arm_section_data (input_sec)->map = map; 4368 4369 map[mapcount - 1].vma = elfsym->st_value; 4370 map[mapcount - 1].type = name[1]; 4371 return TRUE; 4372} 4373 4374 4375/* Allocate target specific section data. */ 4376 4377static bfd_boolean 4378elf32_arm_new_section_hook (bfd *abfd, asection *sec) 4379{ 4380 struct _arm_elf_section_data *sdata; 4381 bfd_size_type amt = sizeof (*sdata); 4382 4383 sdata = bfd_zalloc (abfd, amt); 4384 if (sdata == NULL) 4385 return FALSE; 4386 sec->used_by_bfd = sdata; 4387 4388 return _bfd_elf_new_section_hook (abfd, sec); 4389} 4390 4391 4392/* Used to order a list of mapping symbols by address. */ 4393 4394static int 4395elf32_arm_compare_mapping (const void * a, const void * b) 4396{ 4397 return ((const elf32_arm_section_map *) a)->vma 4398 > ((const elf32_arm_section_map *) b)->vma; 4399} 4400 4401 4402/* Do code byteswapping. Return FALSE afterwards so that the section is 4403 written out as normal. */ 4404 4405static bfd_boolean 4406elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec, 4407 bfd_byte *contents) 4408{ 4409 int mapcount; 4410 elf32_arm_section_map *map; 4411 bfd_vma ptr; 4412 bfd_vma end; 4413 bfd_vma offset; 4414 bfd_byte tmp; 4415 int i; 4416 4417 mapcount = elf32_arm_section_data (sec)->mapcount; 4418 map = elf32_arm_section_data (sec)->map; 4419 4420 if (mapcount == 0) 4421 return FALSE; 4422 4423 qsort (map, mapcount, sizeof (elf32_arm_section_map), 4424 elf32_arm_compare_mapping); 4425 4426 offset = sec->output_section->vma + sec->output_offset; 4427 ptr = map[0].vma - offset; 4428 for (i = 0; i < mapcount; i++) 4429 { 4430 if (i == mapcount - 1) 4431 end = sec->size; 4432 else 4433 end = map[i + 1].vma - offset; 4434 4435 switch (map[i].type) 4436 { 4437 case 'a': 4438 /* Byte swap code words. */ 4439 while (ptr + 3 < end) 4440 { 4441 tmp = contents[ptr]; 4442 contents[ptr] = contents[ptr + 3]; 4443 contents[ptr + 3] = tmp; 4444 tmp = contents[ptr + 1]; 4445 contents[ptr + 1] = contents[ptr + 2]; 4446 contents[ptr + 2] = tmp; 4447 ptr += 4; 4448 } 4449 break; 4450 4451 case 't': 4452 /* Byte swap code halfwords. */ 4453 while (ptr + 1 < end) 4454 { 4455 tmp = contents[ptr]; 4456 contents[ptr] = contents[ptr + 1]; 4457 contents[ptr + 1] = tmp; 4458 ptr += 2; 4459 } 4460 break; 4461 4462 case 'd': 4463 /* Leave data alone. */ 4464 break; 4465 } 4466 ptr = end; 4467 } 4468 free (map); 4469 return FALSE; 4470} 4471 4472#define ELF_ARCH bfd_arch_arm 4473#define ELF_MACHINE_CODE EM_ARM 4474#ifdef __QNXTARGET__ 4475#define ELF_MAXPAGESIZE 0x1000 4476#else 4477#define ELF_MAXPAGESIZE 0x8000 4478#endif 4479 4480#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data 4481#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data 4482#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags 4483#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data 4484#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create 4485#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup 4486#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line 4487#define bfd_elf32_new_section_hook elf32_arm_new_section_hook 4488#define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol 4489 4490#define elf_backend_get_symbol_type elf32_arm_get_symbol_type 4491#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook 4492#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook 4493#define elf_backend_check_relocs elf32_arm_check_relocs 4494#define elf_backend_relocate_section elf32_arm_relocate_section 4495#define elf_backend_write_section elf32_arm_write_section 4496#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol 4497#define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections 4498#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol 4499#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections 4500#define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook 4501#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections 4502#define elf_backend_post_process_headers elf32_arm_post_process_headers 4503#define elf_backend_reloc_type_class elf32_arm_reloc_type_class 4504#define elf_backend_object_p elf32_arm_object_p 4505#define elf_backend_section_flags elf32_arm_section_flags 4506#define elf_backend_fake_sections elf32_arm_fake_sections 4507#define elf_backend_section_from_shdr elf32_arm_section_from_shdr 4508#define elf_backend_final_write_processing elf32_arm_final_write_processing 4509#define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol 4510 4511#define elf_backend_can_refcount 1 4512#define elf_backend_can_gc_sections 1 4513#define elf_backend_plt_readonly 1 4514#define elf_backend_want_got_plt 1 4515#define elf_backend_want_plt_sym 0 4516#if !USE_REL 4517#define elf_backend_rela_normal 1 4518#endif 4519 4520#define elf_backend_got_header_size 12 4521 4522#include "elf32-target.h" 4523