| blob | af26109180e70a6fc53357ffb73849adea1fa549 |
1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
27 #ifndef NUM_ELEM
28 #define NUM_ELEM(a) (sizeof (a) / (sizeof (a)[0]))
29 #endif
31 #define elf_info_to_howto 0
32 #define elf_info_to_howto_rel elf32_arm_info_to_howto
34 #define ARM_ELF_ABI_VERSION 0
35 #define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
37 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
38 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
39 in that slot. */
42 {
43 /* No relocation */
72 /* 32 bit absolute */
87 /* standard 32bit pc-relative reloc */
102 /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
117 /* 16 bit absolute */
132 /* 12 bit absolute */
161 /* 8 bit absolute */
190 /* FIXME: Has two more bits of offset in Thumb32. */
261 /* BLX instruction for the ARM. */
276 /* BLX instruction for the Thumb. */
291 /* Dynamic TLS relocations. */
335 /* Relocs used in ARM Linux */
799 /* These are declared as 13-bit signed relocations because we can
800 address -4095 .. 4095(base) by altering ADDW to SUBW or vice
801 versa. */
857 };
859 /* Relocations 57 .. 83 are the "group relocations" which we do not
860 support. */
863 {
1025 /* GNU extension to record C++ vtable member usage */
1040 /* GNU extension to record C++ vtable hierarchy */
1083 /* TLS relocations */
1195 };
1197 /* 112-127 private relocations
1198 128 R_ARM_ME_TOO, obsolete
1199 129-255 unallocated in AAELF.
1201 249-255 extended, currently unused, relocations: */
1204 {
1260 };
1264 {
1277 }
1279 static void
1282 {
1287 }
1289 struct elf32_arm_reloc_map
1290 {
1291 bfd_reloc_code_real_type bfd_reloc_val;
1293 };
1295 /* All entries in this list must also be present in elf32_arm_howto_table. */
1297 {
1337 };
1341 bfd_reloc_code_real_type code)
1342 {
1349 }
1351 /* Support for core dump NOTE sections */
1352 static bfd_boolean
1354 {
1359 {
1364 /* pr_cursig */
1367 /* pr_pid */
1370 /* pr_reg */
1375 }
1377 /* Make a ".reg/999" section. */
1380 }
1382 static bfd_boolean
1384 {
1386 {
1395 }
1397 /* Note that for some reason, a spurious space is tacked
1398 onto the end of the args in some (at least one anyway)
1399 implementations, so strip it off if it exists. */
1401 {
1407 }
1410 }
1412 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1414 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1417 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1418 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1423 /* In lieu of proper flags, assume all EABIv4 objects are interworkable. */
1424 #define INTERWORK_FLAG(abfd) \
1425 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) == EF_ARM_EABI_VER4 \
1426 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
1428 /* The linker script knows the section names for placement.
1429 The entry_names are used to do simple name mangling on the stubs.
1430 Given a function name, and its type, the stub can be found. The
1431 name can be changed. The only requirement is the %s be present. */
1438 /* The name of the dynamic interpreter. This is put in the .interp
1439 section. */
1442 #ifdef FOUR_WORD_PLT
1444 /* The first entry in a procedure linkage table looks like
1445 this. It is set up so that any shared library function that is
1446 called before the relocation has been set up calls the dynamic
1447 linker first. */
1449 {
1454 };
1456 /* Subsequent entries in a procedure linkage table look like
1457 this. */
1459 {
1464 };
1466 #else
1468 /* The first entry in a procedure linkage table looks like
1469 this. It is set up so that any shared library function that is
1470 called before the relocation has been set up calls the dynamic
1471 linker first. */
1473 {
1479 };
1481 /* Subsequent entries in a procedure linkage table look like
1482 this. */
1484 {
1488 };
1490 #endif
1492 /* An initial stub used if the PLT entry is referenced from Thumb code. */
1493 #define PLT_THUMB_STUB_SIZE 4
1495 {
1498 };
1500 /* The entries in a PLT when using a DLL-based target with multiple
1501 address spaces. */
1503 {
1506 };
1508 /* Used to build a map of a section. This is required for mixed-endian
1509 code/data. */
1512 {
1513 bfd_vma vma;
1515 }
1516 elf32_arm_section_map;
1518 struct _arm_elf_section_data
1519 {
1523 };
1525 #define elf32_arm_section_data(sec) \
1526 ((struct _arm_elf_section_data *) elf_section_data (sec))
1528 /* The size of the thread control block. */
1529 #define TCB_SIZE 8
1531 struct elf32_arm_obj_tdata
1532 {
1535 /* tls_type for each local got entry. */
1537 };
1539 #define elf32_arm_tdata(abfd) \
1540 ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
1542 #define elf32_arm_local_got_tls_type(abfd) \
1543 (elf32_arm_tdata (abfd)->local_got_tls_type)
1545 static bfd_boolean
1547 {
1553 }
1555 /* The ARM linker needs to keep track of the number of relocs that it
1556 decides to copy in check_relocs for each symbol. This is so that
1557 it can discard PC relative relocs if it doesn't need them when
1558 linking with -Bsymbolic. We store the information in a field
1559 extending the regular ELF linker hash table. */
1561 /* This structure keeps track of the number of relocs we have copied
1562 for a given symbol. */
1563 struct elf32_arm_relocs_copied
1564 {
1565 /* Next section. */
1567 /* A section in dynobj. */
1569 /* Number of relocs copied in this section. */
1570 bfd_size_type count;
1571 /* Number of PC-relative relocs copied in this section. */
1572 bfd_size_type pc_count;
1573 };
1575 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
1577 /* Arm ELF linker hash entry. */
1578 struct elf32_arm_link_hash_entry
1579 {
1582 /* Number of PC relative relocs copied for this symbol. */
1585 /* We reference count Thumb references to a PLT entry separately,
1586 so that we can emit the Thumb trampoline only if needed. */
1587 bfd_signed_vma plt_thumb_refcount;
1589 /* Since PLT entries have variable size if the Thumb prologue is
1590 used, we need to record the index into .got.plt instead of
1591 recomputing it from the PLT offset. */
1592 bfd_signed_vma plt_got_offset;
1594 #define GOT_UNKNOWN 0
1595 #define GOT_NORMAL 1
1596 #define GOT_TLS_GD 2
1597 #define GOT_TLS_IE 4
1599 };
1601 /* Traverse an arm ELF linker hash table. */
1602 #define elf32_arm_link_hash_traverse(table, func, info) \
1603 (elf_link_hash_traverse \
1604 (&(table)->root, \
1605 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1606 (info)))
1608 /* Get the ARM elf linker hash table from a link_info structure. */
1609 #define elf32_arm_hash_table(info) \
1610 ((struct elf32_arm_link_hash_table *) ((info)->hash))
1612 /* ARM ELF linker hash table. */
1613 struct elf32_arm_link_hash_table
1614 {
1615 /* The main hash table. */
1618 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
1619 bfd_size_type thumb_glue_size;
1621 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
1622 bfd_size_type arm_glue_size;
1624 /* An arbitrary input BFD chosen to hold the glue sections. */
1627 /* Nonzero to output a BE8 image. */
1630 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1631 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */
1634 /* The relocation to use for R_ARM_TARGET2 relocations. */
1637 /* Nonzero to fix BX instructions for ARMv4 targets. */
1640 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
1643 /* The number of bytes in the initial entry in the PLT. */
1644 bfd_size_type plt_header_size;
1646 /* The number of bytes in the subsequent PLT etries. */
1647 bfd_size_type plt_entry_size;
1649 /* True if the target system is Symbian OS. */
1652 /* True if the target uses REL relocations. */
1655 /* Short-cuts to get to dynamic linker sections. */
1664 /* Data for R_ARM_TLS_LDM32 relocations. */
1666 bfd_signed_vma refcount;
1667 bfd_vma offset;
1670 /* Small local sym to section mapping cache. */
1673 /* For convenience in allocate_dynrelocs. */
1675 };
1677 /* Create an entry in an ARM ELF linker hash table. */
1683 {
1687 /* Allocate the structure if it has not already been allocated by a
1688 subclass. */
1694 /* Call the allocation method of the superclass. */
1699 {
1704 }
1707 }
1709 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
1710 shortcuts to them in our hash table. */
1712 static bfd_boolean
1714 {
1718 /* BPABI objects never have a GOT, or associated sections. */
1732 | SEC_HAS_CONTENTS
1733 | SEC_IN_MEMORY
1734 | SEC_LINKER_CREATED
1740 }
1742 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1743 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1744 hash table. */
1746 static bfd_boolean
1748 {
1771 }
1773 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1775 static void
1779 {
1786 {
1788 {
1795 /* Add reloc counts against the weak sym to the strong sym
1796 list. Merge any entries against the same section. */
1798 {
1803 {
1808 }
1811 }
1813 }
1817 }
1819 /* If the direct symbol already has an associated PLT entry, the
1820 indirect symbol should not. If it doesn't, swap refcount information
1821 from the indirect symbol. */
1823 {
1826 }
1827 else
1832 {
1835 }
1838 }
1840 /* Create an ARM elf linker hash table. */
1844 {
1853 elf32_arm_link_hash_newfunc))
1854 {
1857 }
1872 #ifdef FOUR_WORD_PLT
1875 #else
1878 #endif
1888 }
1890 /* Locate the Thumb encoded calling stub for NAME. */
1896 {
1901 /* We need a pointer to the armelf specific hash table. */
1911 hash = elf_link_hash_lookup
1915 /* xgettext:c-format */
1922 }
1924 /* Locate the ARM encoded calling stub for NAME. */
1930 {
1935 /* We need a pointer to the elfarm specific hash table. */
1945 myh = elf_link_hash_lookup
1949 /* xgettext:c-format */
1956 }
1958 /* ARM->Thumb glue (static images):
1960 .arm
1961 __func_from_arm:
1962 ldr r12, __func_addr
1963 bx r12
1964 __func_addr:
1965 .word func @ behave as if you saw a ARM_32 reloc.
1967 (relocatable images)
1968 .arm
1969 __func_from_arm:
1970 ldr r12, __func_offset
1971 add r12, r12, pc
1972 bx r12
1973 __func_offset:
1974 .word func - .
1975 */
1977 #define ARM2THUMB_STATIC_GLUE_SIZE 12
1982 #define ARM2THUMB_PIC_GLUE_SIZE 16
1987 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
1989 .thumb .thumb
1990 .align 2 .align 2
1991 __func_from_thumb: __func_from_thumb:
1992 bx pc push {r6, lr}
1993 nop ldr r6, __func_addr
1994 .arm mov lr, pc
1995 __func_change_to_arm: bx r6
1996 b func .arm
1997 __func_back_to_thumb:
1998 ldmia r13! {r6, lr}
1999 bx lr
2000 __func_addr:
2001 .word func */
2003 #define THUMB2ARM_GLUE_SIZE 8
2008 #ifndef ELFARM_NABI_C_INCLUDED
2009 bfd_boolean
2011 {
2021 {
2025 ARM2THUMB_GLUE_SECTION_NAME);
2033 }
2036 {
2039 s = bfd_get_section_by_name
2048 }
2051 }
2053 static void
2056 {
2063 bfd_vma val;
2070 s = bfd_get_section_by_name
2075 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2081 myh = elf_link_hash_lookup
2085 {
2086 /* We've already seen this guy. */
2089 }
2091 /* The only trick here is using hash_table->arm_glue_size as the value.
2092 Even though the section isn't allocated yet, this is where we will be
2093 putting it. */
2108 else
2112 }
2114 static void
2117 {
2124 bfd_vma val;
2131 s = bfd_get_section_by_name
2143 myh = elf_link_hash_lookup
2147 {
2148 /* We've already seen this guy. */
2151 }
2159 /* If we mark it 'Thumb', the disassembler will do a better job. */
2169 /* Allocate another symbol to mark where we switch to Arm mode. */
2188 }
2190 /* Add the glue sections to ABFD. This function is called from the
2191 linker scripts in ld/emultempl/{armelf}.em. */
2193 bfd_boolean
2196 {
2197 flagword flags;
2200 /* If we are only performing a partial
2201 link do not bother adding the glue. */
2208 {
2209 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
2210 will prevent elf_link_input_bfd() from processing the contents
2211 of this section. */
2215 ARM2THUMB_GLUE_SECTION_NAME,
2216 flags);
2222 /* Set the gc mark to prevent the section from being removed by garbage
2223 collection, despite the fact that no relocs refer to this section. */
2225 }
2230 {
2235 THUMB2ARM_GLUE_SECTION_NAME,
2236 flags);
2243 }
2246 }
2248 /* Select a BFD to be used to hold the sections used by the glue code.
2249 This function is called from the linker scripts in ld/emultempl/
2250 {armelf/pe}.em */
2252 bfd_boolean
2254 {
2257 /* If we are only performing a partial link
2258 do not bother getting a bfd to hold the glue. */
2262 /* Make sure we don't attach the glue sections to a dynamic object. */
2272 /* Save the bfd for later use. */
2276 }
2278 bfd_boolean
2282 {
2291 /* If we are only performing a partial link do not bother
2292 to construct any glue. */
2296 /* Here we have a bfd that is to be included on the link. We have a hook
2297 to do reloc rummaging, before section sizes are nailed down. */
2304 {
2306 abfd);
2308 }
2311 /* Rummage around all the relocs and map the glue vectors. */
2318 {
2324 /* Load the relocs. */
2325 internal_relocs
2334 {
2343 /* These are the only relocation types we care about. */
2351 /* Get the section contents if we haven't done so already. */
2353 {
2354 /* Get cached copy if it exists. */
2357 else
2358 {
2359 /* Go get them off disk. */
2362 }
2363 }
2365 /* If the relocation is not against a symbol it cannot concern us. */
2368 /* We don't care about local symbols. */
2372 /* This is an external symbol. */
2377 /* If the relocation is against a static symbol it must be within
2378 the current section and so cannot be a cross ARM/Thumb relocation. */
2382 /* If the call will go through a PLT entry then we do not need
2383 glue. */
2388 {
2393 /* This one is a call from arm code. We need to look up
2394 the target of the call. If it is a thumb target, we
2395 insert glue. */
2401 /* This one is a call from thumb code. We look
2402 up the target of the call. If it is not a thumb
2403 target, we insert glue. */
2410 }
2411 }
2422 }
2426 error_return:
2435 }
2436 #endif
2439 /* Set target relocation values needed during linking. */
2441 void
2447 {
2459 else
2460 {
2462 target2_type);
2463 }
2466 }
2468 /* The thumb form of a long branch is a bit finicky, because the offset
2469 encoding is split over two fields, each in it's own instruction. They
2470 can occur in any order. So given a thumb form of long branch, and an
2471 offset, insert the offset into the thumb branch and return finished
2472 instruction.
2474 It takes two thumb instructions to encode the target address. Each has
2475 11 bits to invest. The upper 11 bits are stored in one (identified by
2476 H-0.. see below), the lower 11 bits are stored in the other (identified
2477 by H-1).
2479 Combine together and shifted left by 1 (it's a half word address) and
2480 there you have it.
2482 Op: 1111 = F,
2483 H-0, upper address-0 = 000
2484 Op: 1111 = F,
2485 H-1, lower address-0 = 800
2487 They can be ordered either way, but the arm tools I've seen always put
2488 the lower one first. It probably doesn't matter. krk@cygnus.com
2490 XXX: Actually the order does matter. The second instruction (H-1)
2491 moves the computed address into the PC, so it must be the second one
2492 in the sequence. The problem, however is that whilst little endian code
2493 stores the instructions in HI then LOW order, big endian code does the
2494 reverse. nickc@cygnus.com. */
2496 #define LOW_HI_ORDER 0xF800F000
2497 #define HI_LOW_ORDER 0xF000F800
2499 static insn32
2501 {
2515 else
2516 /* FIXME: abort is probably not the right call. krk@cygnus.com */
2520 }
2522 /* Thumb code calling an ARM function. */
2524 static int
2532 bfd_vma offset,
2533 bfd_signed_vma addend,
2534 bfd_vma val)
2535 {
2537 bfd_vma my_offset;
2555 THUMB2ARM_GLUE_SECTION_NAME);
2562 {
2566 {
2573 }
2584 ret_offset =
2585 /* Address of destination of the stub. */
2588 /* Offset from the start of the current section
2589 to the start of the stubs. */
2591 /* Offset of the start of this stub from the start of the stubs. */
2592 + my_offset
2593 /* Address of the start of the current section. */
2595 /* The branch instruction is 4 bytes into the stub. */
2597 /* ARM branches work from the pc of the instruction + 8. */
2603 }
2607 /* Now go back and fix up the original BL insn to point to here. */
2608 ret_offset =
2609 /* Address of where the stub is located. */
2611 /* Address of where the BL is located. */
2614 /* Addend in the relocation. */
2615 - addend
2616 /* Biassing for PC-relative addressing. */
2627 }
2629 /* Arm code calling a Thumb function. */
2631 static int
2639 bfd_vma offset,
2640 bfd_signed_vma addend,
2641 bfd_vma val)
2642 {
2644 bfd_vma my_offset;
2661 ARM2THUMB_GLUE_SECTION_NAME);
2667 {
2671 {
2676 }
2682 {
2683 /* For relocatable objects we can't use absolute addresses,
2684 so construct the address from a relative offset. */
2685 /* TODO: If the offset is small it's probably worth
2686 constructing the address with adds. */
2693 /* Adjust the offset by 4 for the position of the add,
2694 and 8 for the pipeline offset. */
2701 }
2702 else
2703 {
2710 /* It's a thumb address. Add the low order bit. */
2713 }
2714 }
2721 /* Somehow these are both 4 too far, so subtract 8. */
2723 + my_offset
2735 }
2737 /* Some relocations map to different relocations depending on the
2738 target. Return the real relocation. */
2739 static int
2742 {
2744 {
2748 else
2756 }
2757 }
2759 /* Return the base VMA address which should be subtracted from real addresses
2760 when resolving @dtpoff relocation.
2761 This is PT_TLS segment p_vaddr. */
2763 static bfd_vma
2765 {
2766 /* If tls_sec is NULL, we should have signalled an error already. */
2770 }
2772 /* Return the relocation value for @tpoff relocation
2773 if STT_TLS virtual address is ADDRESS. */
2775 static bfd_vma
2777 {
2779 bfd_vma base;
2781 /* If tls_sec is NULL, we should have signalled an error already. */
2786 }
2788 /* Perform a relocation as part of a final link. */
2790 static bfd_reloc_status_type
2797 bfd_vma value,
2804 {
2815 bfd_vma addend;
2816 bfd_signed_vma signed_addend;
2821 /* Some relocation type map to different relocations depending on the
2822 target. We pick the right one here. */
2827 /* If the start address has been set, then set the EF_ARM_HASENTRY
2828 flag. Setting this more than once is redundant, but the cost is
2829 not too high, and it keeps the code simple.
2831 The test is done here, rather than somewhere else, because the
2832 start address is only set just before the final link commences.
2834 Note - if the user deliberately sets a start address of 0, the
2835 flag will not be set. */
2841 {
2844 }
2851 {
2855 {
2859 }
2860 else
2862 }
2863 else
2867 {
2869 /* We don't need to find a value for this symbol. It's just a
2870 marker. */
2882 /* r_symndx will be zero only for relocs against symbols
2883 from removed linkonce sections, or sections discarded by
2884 a linker script. */
2888 /* Handle relocations which should use the PLT entry. ABS32/REL32
2889 will use the symbol's value, which may point to a PLT entry, but we
2890 don't need to handle that here. If we created a PLT entry, all
2891 branches in this object should go to it. */
2896 {
2897 /* If we've created a .plt section, and assigned a PLT entry to
2898 this function, it should not be known to bind locally. If
2899 it were, we would have cleared the PLT entry. */
2909 }
2911 /* When generating a shared object or relocatable executable, these
2912 relocations are copied into the output file to be resolved at
2913 run time. */
2926 {
2927 Elf_Internal_Rela outrel;
2934 {
2937 name = (bfd_elf_string_from_elf_section
2946 input_section),
2951 }
2974 else
2975 {
2978 /* This symbol is local, or marked to become local. */
2983 {
2984 /* On Symbian OS, the data segment and text segement
2985 can be relocated independently. Therefore, we
2986 must indicate the segment to which this
2987 relocation is relative. The BPABI allows us to
2988 use any symbol in the right segment; we just use
2989 the section symbol as it is convenient. (We
2990 cannot use the symbol given by "h" directly as it
2991 will not appear in the dynamic symbol table.) */
2994 else
2997 }
2998 else
2999 /* On SVR4-ish systems, the dynamic loader cannot
3000 relocate the text and data segments independently,
3001 so the symbol does not matter. */
3004 }
3010 /* If this reloc is against an external symbol, we do not want to
3011 fiddle with the addend. Otherwise, we need to include the symbol
3012 value so that it becomes an addend for the dynamic reloc. */
3019 }
3021 {
3028 {
3029 /* Check for Arm calling Arm function. */
3030 /* FIXME: Should we translate the instruction into a BL
3031 instruction instead ? */
3035 input_bfd,
3037 }
3038 else
3039 {
3040 /* Check for Arm calling Thumb function. */
3042 {
3048 }
3049 }
3051 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3052 where:
3053 S is the address of the symbol in the relocation.
3054 P is address of the instruction being relocated.
3055 A is the addend (extracted from the instruction) in bytes.
3057 S is held in 'value'.
3058 P is the base address of the section containing the
3059 instruction plus the offset of the reloc into that
3060 section, ie:
3061 (input_section->output_section->vma +
3062 input_section->output_offset +
3063 rel->r_offset).
3064 A is the addend, converted into bytes, ie:
3065 (signed_addend * 4)
3067 Note: None of these operations have knowledge of the pipeline
3068 size of the processor, thus it is up to the assembler to
3069 encode this information into the addend. */
3075 else
3076 /* RELA addends do not have to be adjusted by howto->size. */
3082 /* It is not an error for an undefined weak reference to be
3083 out of range. Any program that branches to such a symbol
3084 is going to crash anyway, so there is no point worrying
3085 about getting the destination exactly right. */
3087 {
3088 /* Perform a signed range check. */
3092 }
3094 /* If necessary set the H bit in the BLX instruction. */
3099 else
3121 {
3122 /* Check for overflow */
3125 }
3131 }
3154 /* Support ldr and str instruction for the arm */
3155 /* Also thumb b (unconditional branch). ??? Really? */
3166 /* Support ldr and str instructions for the thumb. */
3168 {
3169 /* Need to refetch addend. */
3171 /* ??? Need to determine shift amount from operand size. */
3173 }
3176 /* ??? Isn't value unsigned? */
3180 /* ??? Value needs to be properly shifted into place first. */
3187 /* Thumb BL (branch long instruction). */
3188 {
3189 bfd_vma relocation;
3195 bfd_vma check;
3196 bfd_signed_vma signed_check;
3199 /* Need to refetch the addend and squish the two 11 bit pieces
3200 together. */
3202 {
3208 }
3211 {
3212 /* Check for Thumb to Thumb call. */
3213 /* FIXME: Should we translate the instruction into a BL
3214 instruction instead ? */
3218 input_bfd,
3220 }
3221 else
3222 {
3223 /* If it is not a call to Thumb, assume call to Arm.
3224 If it is a call relative to a section name, then it is not a
3225 function call at all, but rather a long jump. Calls through
3226 the PLT do not require stubs. */
3230 {
3235 else
3237 }
3238 }
3240 /* Handle calls via the PLT. */
3242 {
3247 {
3248 /* If the Thumb BLX instruction is available, convert the
3249 BL to a BLX instruction to call the ARM-mode PLT entry. */
3251 {
3254 }
3255 }
3256 else
3257 /* Target the Thumb stub before the ARM PLT entry. */
3260 }
3270 /* If this is a signed value, the rightshift just dropped
3271 leading 1 bits (assuming twos complement). */
3274 else
3277 /* Assumes two's complement. */
3284 /* For a BLX instruction, make sure that the relocation is rounded up
3285 to a word boundary. This follows the semantics of the instruction
3286 which specifies that bit 1 of the target address will come from bit
3287 1 of the base address. */
3290 /* Put RELOCATION back into the insn. */
3294 /* Put the relocated value back in the object file: */
3299 }
3303 /* Thumb32 unconditional branch instruction. */
3304 {
3305 bfd_vma relocation;
3311 bfd_vma check;
3312 bfd_signed_vma signed_check;
3314 /* Need to refetch the addend, reconstruct the top three bits, and glue the
3315 two pieces together. */
3317 {
3330 }
3332 /* ??? Should handle interworking? GCC might someday try to
3333 use this for tail calls. */
3342 /* If this is a signed value, the rightshift just dropped
3343 leading 1 bits (assuming twos complement). */
3346 else
3349 /* Assumes two's complement. */
3353 /* Put RELOCATION back into the insn. */
3354 {
3366 }
3368 /* Put the relocated value back in the object file: */
3373 }
3376 /* Thumb32 conditional branch instruction. */
3377 {
3378 bfd_vma relocation;
3384 bfd_vma check;
3385 bfd_signed_vma signed_check;
3387 /* Need to refetch the addend, reconstruct the top three bits,
3388 and squish the two 11 bit pieces together. */
3390 {
3404 }
3406 /* ??? Should handle interworking? GCC might someday try to
3407 use this for tail calls. */
3416 /* If this is a signed value, the rightshift just dropped
3417 leading 1 bits (assuming twos complement). */
3420 else
3423 /* Assumes two's complement. */
3427 /* Put RELOCATION back into the insn. */
3428 {
3437 }
3439 /* Put the relocated value back in the object file: */
3444 }
3449 /* Thumb B (branch) instruction). */
3450 {
3451 bfd_signed_vma relocation;
3454 bfd_signed_vma signed_check;
3456 /* CZB cannot jump backward. */
3461 {
3462 /* Need to refetch addend. */
3465 {
3469 }
3470 else
3472 /* The value in the insn has been right shifted. We need to
3473 undo this, so that we can perform the address calculation
3474 in terms of bytes. */
3476 }
3488 else
3494 /* Assumes two's complement. */
3499 }
3504 {
3505 bfd_vma insn;
3506 bfd_vma relocation;
3510 {
3511 /* Extract the addend. */
3514 }
3524 }
3532 /* Relocation is relative to the start of the
3533 global offset table. */
3539 /* If we are addressing a Thumb function, we need to adjust the
3540 address by one, so that attempts to call the function pointer will
3541 correctly interpret it as Thumb code. */
3545 /* Note that sgot->output_offset is not involved in this
3546 calculation. We always want the start of .got. If we
3547 define _GLOBAL_OFFSET_TABLE in a different way, as is
3548 permitted by the ABI, we might have to change this
3549 calculation. */
3556 /* Use global offset table as symbol value. */
3570 /* Relocation is to the entry for this symbol in the
3571 global offset table. */
3576 {
3577 bfd_vma off;
3578 bfd_boolean dyn;
3589 {
3590 /* This is actually a static link, or it is a -Bsymbolic link
3591 and the symbol is defined locally. We must initialize this
3592 entry in the global offset table. Since the offset must
3593 always be a multiple of 4, we use the least significant bit
3594 to record whether we have initialized it already.
3596 When doing a dynamic link, we create a .rel.got relocation
3597 entry to initialize the value. This is done in the
3598 finish_dynamic_symbol routine. */
3601 else
3602 {
3603 /* If we are addressing a Thumb function, we need to
3604 adjust the address by one, so that attempts to
3605 call the function pointer will correctly
3606 interpret it as Thumb code. */
3612 }
3613 }
3614 else
3618 }
3619 else
3620 {
3621 bfd_vma off;
3628 /* The offset must always be a multiple of 4. We use the
3629 least significant bit to record whether we have already
3630 generated the necessary reloc. */
3633 else
3634 {
3635 /* If we are addressing a Thumb function, we need to
3636 adjust the address by one, so that attempts to
3637 call the function pointer will correctly
3638 interpret it as Thumb code. */
3645 {
3647 Elf_Internal_Rela outrel;
3660 }
3663 }
3666 }
3681 {
3682 bfd_vma off;
3691 else
3692 {
3693 /* If we don't know the module number, create a relocation
3694 for it. */
3696 {
3697 Elf_Internal_Rela outrel;
3712 }
3713 else
3717 }
3725 }
3729 {
3730 bfd_vma off;
3739 {
3740 bfd_boolean dyn;
3745 {
3748 }
3751 }
3752 else
3753 {
3758 }
3765 else
3766 {
3768 Elf_Internal_Rela outrel;
3772 /* The GOT entries have not been initialized yet. Do it
3773 now, and emit any relocations. If both an IE GOT and a
3774 GD GOT are necessary, we emit the GD first. */
3780 {
3786 }
3789 {
3791 {
3804 else
3805 {
3810 R_ARM_TLS_DTPOFF32);
3815 }
3816 }
3817 else
3818 {
3819 /* If we are not emitting relocations for a
3820 general dynamic reference, then we must be in a
3821 static link or an executable link with the
3822 symbol binding locally. Mark it as belonging
3823 to module 1, the executable. */
3828 }
3831 }
3834 {
3836 {
3845 else
3852 }
3853 else
3857 }
3861 else
3863 }
3873 }
3877 {
3883 }
3884 else
3892 {
3895 /* Ensure that we have a BX instruction. */
3898 /* Preserve Rm (lowest four bits) and the condition code
3899 (highest four bits). Other bits encode MOV PC,Rm. */
3903 }
3908 }
3909 }
3911 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
3912 static void
3916 bfd_signed_vma increment)
3917 {
3918 bfd_signed_vma addend;
3921 {
3939 }
3940 else
3941 {
3942 bfd_vma contents;
3946 /* Get the (signed) value from the instruction. */
3949 {
3950 bfd_signed_vma mask;
3955 }
3957 /* Add in the increment, (which is a byte value). */
3959 {
3971 /* Should we check for overflow here ? */
3973 /* Drop any undesired bits. */
3976 }
3981 }
3982 }
3984 #define IS_ARM_TLS_RELOC(R_TYPE) \
3985 ((R_TYPE) == R_ARM_TLS_GD32 \
3986 || (R_TYPE) == R_ARM_TLS_LDO32 \
3987 || (R_TYPE) == R_ARM_TLS_LDM32 \
3988 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
3989 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
3990 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
3991 || (R_TYPE) == R_ARM_TLS_LE32 \
3992 || (R_TYPE) == R_ARM_TLS_IE32)
3994 /* Relocate an ARM ELF section. */
3995 static bfd_boolean
4004 {
4022 {
4029 bfd_vma relocation;
4030 bfd_reloc_status_type r;
4031 arelent bfd_reloc;
4047 {
4048 /* This is a relocatable link. We don't have to change
4049 anything, unless the reloc is against a section symbol,
4050 in which case we have to adjust according to where the
4051 section symbol winds up in the output section. */
4053 {
4056 {
4059 howto,
4062 }
4063 }
4066 }
4068 /* This is a final link. */
4074 {
4079 {
4085 {
4090 {
4096 }
4100 /* Get the (signed) value from the instruction. */
4103 {
4104 bfd_signed_vma mask;
4109 }
4111 addend =
4117 }
4118 }
4119 else
4121 }
4122 else
4123 {
4124 bfd_boolean warned;
4132 }
4136 else
4137 {
4138 name = (bfd_elf_string_from_elf_section
4142 }
4150 {
4155 input_bfd,
4156 input_section,
4159 name);
4160 }
4169 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4170 because such sections are not SEC_ALLOC and thus ld.so will
4171 not process them. */
4175 {
4181 }
4184 {
4188 {
4190 /* If the overflowing reloc was to an undefined symbol,
4191 we have already printed one error message and there
4192 is no point complaining again. */
4223 /* fall through */
4225 common_error:
4231 }
4232 }
4233 }
4236 }
4238 /* Set the right machine number. */
4240 static bfd_boolean
4242 {
4253 else
4257 }
4259 /* Function to keep ARM specific flags in the ELF header. */
4261 static bfd_boolean
4263 {
4266 {
4268 {
4271 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
4272 abfd);
4273 else
4274 _bfd_error_handler
4276 abfd);
4277 }
4278 }
4279 else
4280 {
4283 }
4286 }
4288 /* Copy backend specific data from one object module to another. */
4290 static bfd_boolean
4292 {
4293 flagword in_flags;
4294 flagword out_flags;
4306 {
4307 /* Cannot mix APCS26 and APCS32 code. */
4311 /* Cannot mix float APCS and non-float APCS code. */
4315 /* If the src and dest have different interworking flags
4316 then turn off the interworking bit. */
4318 {
4320 _bfd_error_handler
4321 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
4325 }
4327 /* Likewise for PIC, though don't warn for this case. */
4330 }
4335 /* Also copy the EI_OSABI field. */
4340 }
4342 /* Merge backend specific data from an object file to the output
4343 object file when linking. */
4345 static bfd_boolean
4347 {
4348 flagword out_flags;
4349 flagword in_flags;
4353 /* Check if we have the same endianess. */
4361 /* The input BFD must have had its flags initialised. */
4362 /* The following seems bogus to me -- The flags are initialized in
4363 the assembler but I don't think an elf_flags_init field is
4364 written into the object. */
4365 /* BFD_ASSERT (elf_flags_init (ibfd)); */
4371 {
4372 /* If the input is the default architecture and had the default
4373 flags then do not bother setting the flags for the output
4374 architecture, instead allow future merges to do this. If no
4375 future merges ever set these flags then they will retain their
4376 uninitialised values, which surprise surprise, correspond
4377 to the default values. */
4390 }
4392 /* Determine what should happen if the input ARM architecture
4393 does not match the output ARM architecture. */
4397 /* Identical flags must be compatible. */
4401 /* Check to see if the input BFD actually contains any sections. If
4402 not, its flags may not have been initialised either, but it
4403 cannot actually cause any incompatibility. Do not short-circuit
4404 dynamic objects; their section list may be emptied by
4405 elf_link_add_object_symbols.
4407 Also check to see if there are no code sections in the input.
4408 In this case there is no need to check for code specific flags.
4409 XXX - do we need to worry about floating-point format compatability
4410 in data sections ? */
4412 {
4417 {
4418 /* Ignore synthetic glue sections. */
4421 {
4429 }
4430 }
4434 }
4436 /* Complain about various flag mismatches. */
4438 {
4439 _bfd_error_handler
4445 }
4447 /* Not sure what needs to be checked for EABI versions >= 1. */
4449 {
4451 {
4452 _bfd_error_handler
4458 }
4461 {
4463 _bfd_error_handler
4466 else
4467 _bfd_error_handler
4472 }
4475 {
4477 _bfd_error_handler
4480 else
4481 _bfd_error_handler
4486 }
4489 {
4491 _bfd_error_handler
4494 else
4495 _bfd_error_handler
4500 }
4502 #ifdef EF_ARM_SOFT_FLOAT
4504 {
4505 /* We can allow interworking between code that is VFP format
4506 layout, and uses either soft float or integer regs for
4507 passing floating point arguments and results. We already
4508 know that the APCS_FLOAT flags match; similarly for VFP
4509 flags. */
4512 {
4514 _bfd_error_handler
4517 else
4518 _bfd_error_handler
4523 }
4524 }
4525 #endif
4527 /* Interworking mismatch is only a warning. */
4529 {
4531 {
4532 _bfd_error_handler
4535 }
4536 else
4537 {
4538 _bfd_error_handler
4541 }
4542 }
4543 }
4546 }
4548 /* Display the flags field. */
4550 static bfd_boolean
4552 {
4558 /* Print normal ELF private data. */
4562 /* Ignore init flag - it may not be set, despite the flags field
4563 containing valid data. */
4565 /* xgettext:c-format */
4569 {
4571 /* The following flag bits are GNU extensions and not part of the
4572 official ARM ELF extended ABI. Hence they are only decoded if
4573 the EABI version is not set. */
4579 else
4586 else
4615 else
4626 else
4658 }
4676 }
4678 static int
4680 {
4682 {
4687 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
4688 This allows us to distinguish between data used by Thumb instructions
4689 and non-data (which is probably code) inside Thumb regions of an
4690 executable. */
4697 }
4700 }
4708 {
4710 {
4712 {
4719 {
4729 }
4730 }
4731 }
4732 else
4736 }
4738 /* Update the got entry reference counts for the section being removed. */
4740 static bfd_boolean
4745 {
4762 {
4769 {
4774 }
4779 {
4785 {
4788 }
4790 {
4793 }
4808 /* Should the interworking branches be here also? */
4811 {
4819 {
4823 }
4827 {
4831 {
4838 }
4839 }
4840 }
4845 }
4846 }
4849 }
4851 /* Look through the relocs for a section during the first phase. */
4853 static bfd_boolean
4856 {
4873 /* Create dynamic sections for relocatable executables so that we can
4874 copy relocations. */
4877 {
4880 }
4887 sym_hashes_end = sym_hashes
4895 {
4906 {
4908 r_symndx);
4910 }
4914 else
4915 {
4920 }
4925 {
4930 /* This symbol requires a global offset table entry. */
4931 {
4935 {
4939 }
4942 {
4945 }
4946 else
4947 {
4950 /* This is a global offset table entry for a local symbol. */
4953 {
4954 bfd_size_type size;
4964 }
4967 }
4969 /* We will already have issued an error message if there is a
4970 TLS / non-TLS mismatch, based on the symbol type. We don't
4971 support any linker relaxations. So just combine any TLS
4972 types needed. */
4978 {
4981 else
4983 }
4984 }
4985 /* Fall through */
4990 /* Fall through */
4995 {
5000 }
5011 /* Should the interworking branches be listed here? */
5013 {
5014 /* If this reloc is in a read-only section, we might
5015 need a copy reloc. We can't check reliably at this
5016 stage whether the section is read-only, as input
5017 sections have not yet been mapped to output sections.
5018 Tentatively set the flag for now, and correct in
5019 adjust_dynamic_symbol. */
5023 /* We may need a .plt entry if the function this reloc
5024 refers to is in a different object. We can't tell for
5025 sure yet, because something later might force the
5026 symbol local. */
5035 /* If we create a PLT entry, this relocation will reference
5036 it, even if it's an ABS32 relocation. */
5041 }
5043 /* If we are creating a shared library or relocatable executable,
5044 and this is a reloc against a global symbol, or a non PC
5045 relative reloc against a local symbol, then we need to copy
5046 the reloc into the shared library. However, if we are linking
5047 with -Bsymbolic, we do not need to copy a reloc against a
5048 global symbol which is defined in an object we are
5049 including in the link (i.e., DEF_REGULAR is set). At
5050 this point we have not seen all the input files, so it is
5051 possible that DEF_REGULAR is not set now but will be set
5052 later (it is never cleared). We account for that
5053 possibility below by storing information in the
5054 relocs_copied field of the hash table entry. */
5060 {
5063 /* When creating a shared object, we must copy these
5064 reloc types into the output file. We create a reloc
5065 section in dynobj and make room for this reloc. */
5067 {
5070 name = (bfd_elf_string_from_elf_section
5083 {
5084 flagword flags;
5089 /* BPABI objects never have dynamic
5090 relocations mapped. */
5094 name,
5095 flags);
5099 }
5102 }
5104 /* If this is a global symbol, we count the number of
5105 relocations we need for this symbol. */
5107 {
5109 }
5110 else
5111 {
5112 /* Track dynamic relocs needed for local syms too.
5113 We really need local syms available to do this
5114 easily. Oh well. */
5124 }
5128 {
5139 }
5144 }
5147 /* This relocation describes the C++ object vtable hierarchy.
5148 Reconstruct it for later use during GC. */
5154 /* This relocation describes which C++ vtable entries are actually
5155 used. Record for later use during GC. */
5160 }
5161 }
5164 }
5166 /* Treat mapping symbols as special target symbols. */
5168 static bfd_boolean
5170 {
5172 }
5174 /* This is a copy of elf_find_function() from elf.c except that
5175 ARM mapping symbols are ignored when looking for function names
5176 and STT_ARM_TFUNC is considered to a function type. */
5178 static bfd_boolean
5182 bfd_vma offset,
5185 {
5192 {
5198 {
5207 /* Skip $a and $t symbols. */
5211 /* Fall through. */
5215 {
5218 }
5220 }
5221 }
5232 }
5235 /* Find the nearest line to a particular section and offset, for error
5236 reporting. This code is a duplicate of the code in elf.c, except
5237 that it uses arm_elf_find_function. */
5239 static bfd_boolean
5243 bfd_vma offset,
5247 {
5250 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
5256 {
5260 functionname_ptr);
5263 }
5283 }
5285 static bfd_boolean
5290 {
5291 bfd_boolean found;
5296 }
5298 /* Adjust a symbol defined by a dynamic object and referenced by a
5299 regular object. The current definition is in some section of the
5300 dynamic object, but we're not including those sections. We have to
5301 change the definition to something the rest of the link can
5302 understand. */
5304 static bfd_boolean
5307 {
5317 /* Make sure we know what is going on here. */
5327 /* If this is a function, put it in the procedure linkage table. We
5328 will fill in the contents of the procedure linkage table later,
5329 when we know the address of the .got section. */
5332 {
5337 {
5338 /* This case can occur if we saw a PLT32 reloc in an input
5339 file, but the symbol was never referred to by a dynamic
5340 object, or if all references were garbage collected. In
5341 such a case, we don't actually need to build a procedure
5342 linkage table, and we can just do a PC24 reloc instead. */
5346 }
5349 }
5350 else
5351 {
5352 /* It's possible that we incorrectly decided a .plt reloc was
5353 needed for an R_ARM_PC24 or similar reloc to a non-function sym
5354 in check_relocs. We can't decide accurately between function
5355 and non-function syms in check-relocs; Objects loaded later in
5356 the link may change h->type. So fix it now. */
5359 }
5361 /* If this is a weak symbol, and there is a real definition, the
5362 processor independent code will have arranged for us to see the
5363 real definition first, and we can just use the same value. */
5365 {
5371 }
5373 /* If there are no non-GOT references, we do not need a copy
5374 relocation. */
5378 /* This is a reference to a symbol defined by a dynamic object which
5379 is not a function. */
5381 /* If we are creating a shared library, we must presume that the
5382 only references to the symbol are via the global offset table.
5383 For such cases we need not do anything here; the relocations will
5384 be handled correctly by relocate_section. Relocatable executables
5385 can reference data in shared objects directly, so we don't need to
5386 do anything here. */
5390 /* We must allocate the symbol in our .dynbss section, which will
5391 become part of the .bss section of the executable. There will be
5392 an entry for this symbol in the .dynsym section. The dynamic
5393 object will contain position independent code, so all references
5394 from the dynamic object to this symbol will go through the global
5395 offset table. The dynamic linker will use the .dynsym entry to
5396 determine the address it must put in the global offset table, so
5397 both the dynamic object and the regular object will refer to the
5398 same memory location for the variable. */
5402 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
5403 copy the initial value out of the dynamic object and into the
5404 runtime process image. We need to remember the offset into the
5405 .rel.bss section we are going to use. */
5407 {
5414 }
5416 /* We need to figure out the alignment required for this symbol. I
5417 have no idea how ELF linkers handle this. */
5422 /* Apply the required alignment. */
5425 {
5428 }
5430 /* Define the symbol as being at this point in the section. */
5434 /* Increment the section size to make room for the symbol. */
5438 }
5440 /* Allocate space in .plt, .got and associated reloc sections for
5441 dynamic relocs. */
5443 static bfd_boolean
5445 {
5457 /* When warning symbols are created, they **replace** the "real"
5458 entry in the hash table, thus we never get to see the real
5459 symbol in a hash traversal. So look at it now. */
5467 {
5468 /* Make sure this symbol is output as a dynamic symbol.
5469 Undefined weak syms won't yet be marked as dynamic. */
5472 {
5475 }
5479 {
5482 /* If this is the first .plt entry, make room for the special
5483 first entry. */
5489 /* If we will insert a Thumb trampoline before this PLT, leave room
5490 for it. */
5492 {
5495 }
5497 /* If this symbol is not defined in a regular file, and we are
5498 not generating a shared library, then set the symbol to this
5499 location in the .plt. This is required to make function
5500 pointers compare as equal between the normal executable and
5501 the shared library. */
5504 {
5508 /* Make sure the function is not marked as Thumb, in case
5509 it is the target of an ABS32 relocation, which will
5510 point to the PLT entry. */
5513 }
5515 /* Make room for this entry. */
5519 {
5520 /* We also need to make an entry in the .got.plt section, which
5521 will be placed in the .got section by the linker script. */
5524 }
5526 /* We also need to make an entry in the .rel.plt section. */
5528 }
5529 else
5530 {
5533 }
5534 }
5535 else
5536 {
5539 }
5542 {
5544 bfd_boolean dyn;
5548 /* Make sure this symbol is output as a dynamic symbol.
5549 Undefined weak syms won't yet be marked as dynamic. */
5552 {
5555 }
5558 {
5566 /* Non-TLS symbols need one GOT slot. */
5568 else
5569 {
5571 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
5574 /* R_ARM_TLS_IE32 needs one GOT slot. */
5576 }
5590 {
5599 }
5605 }
5606 }
5607 else
5613 /* In the shared -Bsymbolic case, discard space allocated for
5614 dynamic pc-relative relocs against symbols which turn out to be
5615 defined in regular objects. For the normal shared case, discard
5616 space for pc-relative relocs that have become local due to symbol
5617 visibility changes. */
5620 {
5621 /* The only reloc that uses pc_count is R_ARM_REL32, which will
5622 appear on something like ".long foo - .". We want calls to
5623 protected symbols to resolve directly to the function rather
5624 than going via the plt. If people want function pointer
5625 comparisons to work as expected then they should avoid
5626 writing assembly like ".long foo - .". */
5628 {
5632 {
5637 else
5639 }
5640 }
5642 /* Also discard relocs on undefined weak syms with non-default
5643 visibility. */
5649 {
5650 /* Output absolute symbols so that we can create relocations
5651 against them. For normal symbols we output a relocation
5652 against the section that contains them. */
5655 }
5657 }
5658 else
5659 {
5660 /* For the non-shared case, discard space for relocs against
5661 symbols which turn out to need copy relocs or are not
5662 dynamic. */
5670 {
5671 /* Make sure this symbol is output as a dynamic symbol.
5672 Undefined weak syms won't yet be marked as dynamic. */
5675 {
5678 }
5680 /* If that succeeded, we know we'll be keeping all the
5681 relocs. */
5684 }
5688 keep: ;
5689 }
5691 /* Finally, allocate space. */
5693 {
5696 }
5699 }
5701 /* Find any dynamic relocs that apply to read-only sections. */
5703 static bfd_boolean
5705 {
5714 {
5718 {
5723 /* Not an error, just cut short the traversal. */
5725 }
5726 }
5728 }
5730 /* Set the sizes of the dynamic sections. */
5732 static bfd_boolean
5735 {
5738 bfd_boolean plt;
5739 bfd_boolean relocs;
5748 {
5749 /* Set the contents of the .interp section to the interpreter. */
5751 {
5756 }
5757 }
5759 /* Set up .got offsets for local syms, and space for local dynamic
5760 relocs. */
5762 {
5766 bfd_size_type locsymcount;
5774 {
5781 {
5784 {
5785 /* Input section has been discarded, either because
5786 it is a copy of a linkonce section or due to
5787 linker script /DISCARD/, so we'll be discarding
5788 the relocs too. */
5789 }
5791 {
5796 }
5797 }
5798 }
5811 {
5813 {
5816 /* TLS_GD relocs need an 8-byte structure in the GOT. */
5825 }
5826 else
5828 }
5829 }
5832 {
5833 /* Allocate two GOT entries and one dynamic relocation (if necessary)
5834 for R_ARM_TLS_LDM32 relocations. */
5839 }
5840 else
5843 /* Allocate global sym .plt and .got entries, and space for global
5844 sym dynamic relocs. */
5847 /* The check_relocs and adjust_dynamic_symbol entry points have
5848 determined the sizes of the various dynamic sections. Allocate
5849 memory for them. */
5853 {
5855 bfd_boolean strip;
5860 /* It's OK to base decisions on the section name, because none
5861 of the dynobj section names depend upon the input files. */
5867 {
5869 {
5870 /* Strip this section if we don't need it; see the
5871 comment below. */
5873 }
5874 else
5875 {
5876 /* Remember whether there is a PLT. */
5878 }
5879 }
5881 {
5883 {
5884 /* If we don't need this section, strip it from the
5885 output file. This is mostly to handle .rel.bss and
5886 .rel.plt. We must create both sections in
5887 create_dynamic_sections, because they must be created
5888 before the linker maps input sections to output
5889 sections. The linker does that before
5890 adjust_dynamic_symbol is called, and it is that
5891 function which decides whether anything needs to go
5892 into these sections. */
5894 }
5895 else
5896 {
5897 /* Remember whether there are any reloc sections other
5898 than .rel.plt. */
5902 /* We use the reloc_count field as a counter if we need
5903 to copy relocs into the output file. */
5905 }
5906 }
5908 {
5909 /* It's not one of our sections, so don't allocate space. */
5911 }
5914 {
5917 }
5919 /* Allocate memory for the section contents. */
5923 }
5926 {
5927 /* Add some entries to the .dynamic section. We fill in the
5928 values later, in elf32_arm_finish_dynamic_sections, but we
5929 must add the entries now so that we get the correct size for
5930 the .dynamic section. The DT_DEBUG entry is filled in by the
5931 dynamic linker and used by the debugger. */
5932 #define add_dynamic_entry(TAG, VAL) \
5933 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5936 {
5939 }
5942 {
5948 }
5951 {
5956 }
5958 /* If any dynamic relocs apply to a read-only section,
5959 then we need a DT_TEXTREL entry. */
5965 {
5969 }
5970 }
5971 #undef add_synamic_entry
5974 }
5976 /* Finish up dynamic symbol handling. We set the contents of various
5977 dynamic sections here. */
5979 static bfd_boolean
5982 {
5992 {
5996 bfd_vma plt_index;
5997 Elf_Internal_Rela rel;
5999 /* This symbol has an entry in the procedure linkage table. Set
6000 it up. */
6008 /* Fill in the entry in the procedure linkage table. */
6010 {
6017 /* Fill in the entry in the .rel.plt section. */
6023 /* Get the index in the procedure linkage table which
6024 corresponds to this symbol. This is the index of this symbol
6025 in all the symbols for which we are making plt entries. The
6026 first entry in the procedure linkage table is reserved. */
6029 }
6030 else
6031 {
6032 bfd_vma got_offset;
6033 bfd_vma got_displacement;
6039 /* Get the offset into the .got.plt table of the entry that
6040 corresponds to this function. */
6043 /* Get the index in the procedure linkage table which
6044 corresponds to this symbol. This is the index of this symbol
6045 in all the symbols for which we are making plt entries. The
6046 first three entries in .got.plt are reserved; after that
6047 symbols appear in the same order as in .plt. */
6050 /* Calculate the displacement between the PLT slot and the
6051 entry in the GOT. The eight-byte offset accounts for the
6052 value produced by adding to pc in the first instruction
6053 of the PLT stub. */
6056 + got_offset
6065 {
6070 }
6078 #ifdef FOUR_WORD_PLT
6081 #endif
6083 /* Fill in the entry in the global offset table. */
6089 /* Fill in the entry in the .rel.plt section. */
6094 }
6100 {
6101 /* Mark the symbol as undefined, rather than as defined in
6102 the .plt section. Leave the value alone. */
6104 /* If the symbol is weak, we do need to clear the value.
6105 Otherwise, the PLT entry would provide a definition for
6106 the symbol even if the symbol wasn't defined anywhere,
6107 and so the symbol would never be NULL. */
6110 }
6111 }
6116 {
6119 Elf_Internal_Rela rel;
6122 /* This symbol has an entry in the global offset table. Set it
6123 up. */
6132 /* If this is a static link, or it is a -Bsymbolic link and the
6133 symbol is defined locally or was forced to be local because
6134 of a version file, we just want to emit a RELATIVE reloc.
6135 The entry in the global offset table will already have been
6136 initialized in the relocate_section function. */
6139 {
6142 }
6143 else
6144 {
6148 }
6152 }
6155 {
6157 Elf_Internal_Rela rel;
6160 /* This symbol needs a copy reloc. Set it up. */
6175 }
6177 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6183 }
6185 /* Finish up the dynamic sections. */
6187 static bfd_boolean
6189 {
6201 {
6214 {
6215 Elf_Internal_Dyn dyn;
6222 {
6252 get_vma:
6257 else
6258 /* In the BPABI, tags in the PT_DYNAMIC section point
6259 at the file offset, not the memory address, for the
6260 convenience of the post linker. */
6265 get_vma_if_bpabi:
6279 {
6280 /* My reading of the SVR4 ABI indicates that the
6281 procedure linkage table relocs (DT_JMPREL) should be
6282 included in the overall relocs (DT_REL). This is
6283 what Solaris does. However, UnixWare can not handle
6284 that case. Therefore, we override the DT_RELSZ entry
6285 here to make it not include the JMPREL relocs. Since
6286 the linker script arranges for .rel.plt to follow all
6287 other relocation sections, we don't have to worry
6288 about changing the DT_REL entry. */
6294 }
6295 /* Fall through */
6300 /* In the BPABI, the DT_REL tag must point at the file
6301 offset, not the VMA, of the first relocation
6302 section. So, we use code similar to that in
6303 elflink.c, but do not check for SHF_ALLOC on the
6304 relcoation section, since relocations sections are
6305 never allocated under the BPABI. The comments above
6306 about Unixware notwithstanding, we include all of the
6307 relocations here. */
6309 {
6315 {
6316 Elf_Internal_Shdr *hdr
6319 {
6326 }
6327 }
6329 }
6332 /* Set the bottom bit of DT_INIT/FINI if the
6333 corresponding function is Thumb. */
6339 get_sym:
6340 /* If it wasn't set by elf_bfd_final_link
6341 then there is nothing to adjust. */
6343 {
6350 {
6353 }
6354 }
6356 }
6357 }
6359 /* Fill in the first entry in the procedure linkage table. */
6361 {
6362 bfd_vma got_displacement;
6364 /* Calculate the displacement between the PLT slot and &GOT[0]. */
6375 #ifdef FOUR_WORD_PLT
6376 /* The displacement value goes in the otherwise-unused last word of
6377 the second entry. */
6379 #else
6381 #endif
6382 }
6384 /* UnixWare sets the entsize of .plt to 4, although that doesn't
6385 really seem like the right value. */
6387 }
6389 /* Fill in the first three entries in the global offset table. */
6391 {
6393 {
6396 else
6402 }
6405 }
6408 }
6410 static void
6412 {
6420 else
6425 {
6429 }
6430 }
6432 static enum elf_reloc_type_class
6434 {
6436 {
6445 }
6446 }
6448 /* Set the right machine number for an Arm ELF file. */
6450 static bfd_boolean
6452 {
6457 }
6459 static void
6461 {
6463 }
6465 /* Return TRUE if this is an unwinding table entry. */
6467 static bfd_boolean
6469 {
6476 }
6479 /* Set the type and flags for an ARM section. We do this by
6480 the section name, which is a hack, but ought to work. */
6482 static bfd_boolean
6484 {
6490 {
6493 }
6495 }
6497 /* Handle an ARM specific section when reading an object file. This is
6498 called when bfd_section_from_shdr finds a section with an unknown
6499 type. */
6501 static bfd_boolean
6506 {
6507 /* There ought to be a place to keep ELF backend specific flags, but
6508 at the moment there isn't one. We just keep track of the
6509 sections by their name, instead. Fortunately, the ABI gives
6510 names for all the ARM specific sections, so we will probably get
6511 away with this. */
6513 {
6519 }
6525 }
6527 /* Called for each symbol. Builds a section map based on mapping symbols.
6528 Does not alter any of the symbols. */
6530 static bfd_boolean
6536 {
6541 /* Only do this on final link. */
6545 /* Only build a map if we need to byteswap code. */
6550 /* We only want mapping symbols. */
6556 /* TODO: This may be inefficient, but we probably don't usually have many
6557 mapping symbols per section. */
6564 }
6567 /* Allocate target specific section data. */
6569 static bfd_boolean
6571 {
6581 }
6584 /* Used to order a list of mapping symbols by address. */
6586 static int
6588 {
6591 }
6594 /* Do code byteswapping. Return FALSE afterwards so that the section is
6595 written out as normal. */
6597 static bfd_boolean
6600 {
6603 bfd_vma ptr;
6604 bfd_vma end;
6605 bfd_vma offset;
6606 bfd_byte tmp;
6616 elf32_arm_compare_mapping);
6621 {
6624 else
6628 {
6630 /* Byte swap code words. */
6632 {
6640 }
6644 /* Byte swap code halfwords. */
6646 {
6651 }
6655 /* Leave data alone. */
6657 }
6659 }
6662 }
6664 /* Display STT_ARM_TFUNC symbols as functions. */
6666 static void
6669 {
6674 }
6677 /* Mangle thumb function symbols as we read them in. */
6679 static void
6684 {
6687 /* New EABI objects mark thumb function symbols by setting the low bit of
6688 the address. Turn these into STT_ARM_TFUNC. */
6691 {
6694 }
6695 }
6698 /* Mangle thumb function symbols as we write them out. */
6700 static void
6705 {
6706 Elf_Internal_Sym newsym;
6708 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
6709 of the address set, as per the new EABI. We do this unconditionally
6710 because objcopy does not set the elf header flags until after
6711 it writes out the symbol table. */
6713 {
6719 }
6721 }
6723 /* Add the PT_ARM_EXIDX program header. */
6725 static bfd_boolean
6728 {
6734 {
6735 /* If there is already a PT_ARM_EXIDX header, then we do not
6736 want to add another one. This situation arises when running
6737 "strip"; the input binary already has the header. */
6742 {
6752 }
6753 }
6756 }
6758 /* We may add a PT_ARM_EXIDX program header. */
6760 static int
6762 {
6768 else
6770 }
6772 /* We use this to override swap_symbol_in and swap_symbol_out. */
6786 bfd_elf32_write_out_phdrs,
6787 bfd_elf32_write_shdrs_and_ehdr,
6788 bfd_elf32_write_relocs,
6789 elf32_arm_swap_symbol_in,
6790 elf32_arm_swap_symbol_out,
6791 bfd_elf32_slurp_reloc_table,
6792 bfd_elf32_slurp_symbol_table,
6793 bfd_elf32_swap_dyn_in,
6794 bfd_elf32_swap_dyn_out,
6795 bfd_elf32_swap_reloc_in,
6796 bfd_elf32_swap_reloc_out,
6797 bfd_elf32_swap_reloca_in,
6798 bfd_elf32_swap_reloca_out
6799 };
6801 #define ELF_ARCH bfd_arch_arm
6802 #define ELF_MACHINE_CODE EM_ARM
6803 #ifdef __QNXTARGET__
6804 #define ELF_MAXPAGESIZE 0x1000
6805 #else
6806 #define ELF_MAXPAGESIZE 0x8000
6807 #endif
6808 #define ELF_MINPAGESIZE 0x1000
6810 #define bfd_elf32_mkobject elf32_arm_mkobject
6812 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
6813 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
6814 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
6815 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
6816 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
6817 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
6818 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
6819 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
6820 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
6821 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
6823 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
6824 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
6825 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
6826 #define elf_backend_check_relocs elf32_arm_check_relocs
6827 #define elf_backend_relocate_section elf32_arm_relocate_section
6828 #define elf_backend_write_section elf32_arm_write_section
6829 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
6830 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
6831 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
6832 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
6833 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
6834 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
6835 #define elf_backend_post_process_headers elf32_arm_post_process_headers
6836 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
6837 #define elf_backend_object_p elf32_arm_object_p
6838 #define elf_backend_section_flags elf32_arm_section_flags
6839 #define elf_backend_fake_sections elf32_arm_fake_sections
6840 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
6841 #define elf_backend_final_write_processing elf32_arm_final_write_processing
6842 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
6843 #define elf_backend_symbol_processing elf32_arm_symbol_processing
6844 #define elf_backend_size_info elf32_arm_size_info
6845 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
6846 #define elf_backend_additional_program_headers \
6847 elf32_arm_additional_program_headers
6849 #define elf_backend_can_refcount 1
6850 #define elf_backend_can_gc_sections 1
6851 #define elf_backend_plt_readonly 1
6852 #define elf_backend_want_got_plt 1
6853 #define elf_backend_want_plt_sym 0
6854 #define elf_backend_may_use_rel_p 1
6855 #define elf_backend_may_use_rela_p 0
6856 #define elf_backend_default_use_rela_p 0
6857 #define elf_backend_rela_normal 0
6859 #define elf_backend_got_header_size 12
6863 /* VxWorks Targets */
6865 #undef TARGET_LITTLE_SYM
6866 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
6867 #undef TARGET_LITTLE_NAME
6869 #undef TARGET_BIG_SYM
6870 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
6871 #undef TARGET_BIG_NAME
6874 /* Like elf32_arm_link_hash_table_create -- but overrides
6875 appropriately for VxWorks. */
6878 {
6883 {
6887 }
6889 }
6891 #undef elf32_bed
6892 #define elf32_bed elf32_arm_vxworks_bed
6894 #undef bfd_elf32_bfd_link_hash_table_create
6895 #define bfd_elf32_bfd_link_hash_table_create \
6896 elf32_arm_vxworks_link_hash_table_create
6898 #undef elf_backend_may_use_rel_p
6899 #define elf_backend_may_use_rel_p 0
6900 #undef elf_backend_may_use_rela_p
6901 #define elf_backend_may_use_rela_p 1
6902 #undef elf_backend_default_use_rela_p
6903 #define elf_backend_default_use_rela_p 1
6904 #undef elf_backend_rela_normal
6905 #define elf_backend_rela_normal 1
6910 /* Symbian OS Targets */
6912 #undef TARGET_LITTLE_SYM
6913 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
6914 #undef TARGET_LITTLE_NAME
6916 #undef TARGET_BIG_SYM
6917 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
6918 #undef TARGET_BIG_NAME
6921 /* Like elf32_arm_link_hash_table_create -- but overrides
6922 appropriately for Symbian OS. */
6925 {
6930 {
6933 /* There is no PLT header for Symbian OS. */
6935 /* The PLT entries are each three instructions. */
6938 /* Symbian uses armv5t or above, so use_blx is always true. */
6941 }
6943 }
6946 symbian_special_sections_d[]=
6947 {
6948 /* In a BPABI executable, the dynamic linking sections do not go in
6949 the loadable read-only segment. The post-linker may wish to
6950 refer to these sections, but they are not part of the final
6951 program image. */
6956 };
6959 symbian_special_sections_g[]=
6960 {
6961 /* In a BPABI executable, the dynamic linking sections do not go in
6962 the loadable read-only segment. The post-linker may wish to
6963 refer to these sections, but they are not part of the final
6964 program image. */
6967 };
6970 symbian_special_sections_h[]=
6971 {
6972 /* In a BPABI executable, the dynamic linking sections do not go in
6973 the loadable read-only segment. The post-linker may wish to
6974 refer to these sections, but they are not part of the final
6975 program image. */
6978 };
6981 symbian_special_sections_i[]=
6982 {
6983 /* These sections do not need to be writable as the SymbianOS
6984 postlinker will arrange things so that no dynamic relocation is
6985 required. */
6988 };
6991 symbian_special_sections_f[]=
6992 {
6993 /* These sections do not need to be writable as the SymbianOS
6994 postlinker will arrange things so that no dynamic relocation is
6995 required. */
6998 };
7001 symbian_special_sections_p[]=
7002 {
7003 /* These sections do not need to be writable as the SymbianOS
7004 postlinker will arrange things so that no dynamic relocation is
7005 required. */
7008 };
7012 {
7039 NULL /* other */
7040 };
7042 static void
7045 ATTRIBUTE_UNUSED)
7046 {
7047 /* BPABI objects are never loaded directly by an OS kernel; they are
7048 processed by a postlinker first, into an OS-specific format. If
7049 the D_PAGED bit is set on the file, BFD will align segments on
7050 page boundaries, so that an OS can directly map the file. With
7051 BPABI objects, that just results in wasted space. In addition,
7052 because we clear the D_PAGED bit, map_sections_to_segments will
7053 recognize that the program headers should not be mapped into any
7054 loadable segment. */
7056 }
7058 static bfd_boolean
7061 {
7065 /* BPABI shared libraries and executables should have a PT_DYNAMIC
7066 segment. However, because the .dynamic section is not marked
7067 with SEC_LOAD, the generic ELF code will not create such a
7068 segment. */
7071 {
7075 }
7077 /* Also call the generic arm routine. */
7079 }
7081 #undef elf32_bed
7082 #define elf32_bed elf32_arm_symbian_bed
7084 /* The dynamic sections are not allocated on SymbianOS; the postlinker
7085 will process them and then discard them. */
7086 #undef ELF_DYNAMIC_SEC_FLAGS
7087 #define ELF_DYNAMIC_SEC_FLAGS \
7088 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
7090 #undef bfd_elf32_bfd_link_hash_table_create
7091 #define bfd_elf32_bfd_link_hash_table_create \
7092 elf32_arm_symbian_link_hash_table_create
7094 #undef elf_backend_special_sections
7095 #define elf_backend_special_sections elf32_arm_symbian_special_sections
7097 #undef elf_backend_begin_write_processing
7098 #define elf_backend_begin_write_processing \
7099 elf32_arm_symbian_begin_write_processing
7101 #undef elf_backend_modify_segment_map
7102 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
7104 /* There is no .got section for BPABI objects, and hence no header. */
7105 #undef elf_backend_got_header_size
7106 #define elf_backend_got_header_size 0
7108 /* Similarly, there is no .got.plt section. */
7109 #undef elf_backend_want_got_plt
7110 #define elf_backend_want_got_plt 0
7112 #undef elf_backend_may_use_rel_p
7113 #define elf_backend_may_use_rel_p 1
7114 #undef elf_backend_may_use_rela_p
7115 #define elf_backend_may_use_rela_p 0
7116 #undef elf_backend_default_use_rela_p
7117 #define elf_backend_default_use_rela_p 0
7118 #undef elf_backend_rela_normal
7119 #define elf_backend_rela_normal 0