| blob | a1370e22afb2e29b11e5bf82323090484dbf2ed1 |
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;
1519 {
1523 }
1524 _arm_elf_section_data;
1526 #define elf32_arm_section_data(sec) \
1527 ((_arm_elf_section_data *) elf_section_data (sec))
1529 /* The size of the thread control block. */
1530 #define TCB_SIZE 8
1532 struct elf32_arm_obj_tdata
1533 {
1536 /* tls_type for each local got entry. */
1538 };
1540 #define elf32_arm_tdata(abfd) \
1541 ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
1543 #define elf32_arm_local_got_tls_type(abfd) \
1544 (elf32_arm_tdata (abfd)->local_got_tls_type)
1546 static bfd_boolean
1548 {
1554 }
1556 /* The ARM linker needs to keep track of the number of relocs that it
1557 decides to copy in check_relocs for each symbol. This is so that
1558 it can discard PC relative relocs if it doesn't need them when
1559 linking with -Bsymbolic. We store the information in a field
1560 extending the regular ELF linker hash table. */
1562 /* This structure keeps track of the number of relocs we have copied
1563 for a given symbol. */
1564 struct elf32_arm_relocs_copied
1565 {
1566 /* Next section. */
1568 /* A section in dynobj. */
1570 /* Number of relocs copied in this section. */
1571 bfd_size_type count;
1572 /* Number of PC-relative relocs copied in this section. */
1573 bfd_size_type pc_count;
1574 };
1576 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
1578 /* Arm ELF linker hash entry. */
1579 struct elf32_arm_link_hash_entry
1580 {
1583 /* Number of PC relative relocs copied for this symbol. */
1586 /* We reference count Thumb references to a PLT entry separately,
1587 so that we can emit the Thumb trampoline only if needed. */
1588 bfd_signed_vma plt_thumb_refcount;
1590 /* Since PLT entries have variable size if the Thumb prologue is
1591 used, we need to record the index into .got.plt instead of
1592 recomputing it from the PLT offset. */
1593 bfd_signed_vma plt_got_offset;
1595 #define GOT_UNKNOWN 0
1596 #define GOT_NORMAL 1
1597 #define GOT_TLS_GD 2
1598 #define GOT_TLS_IE 4
1600 };
1602 /* Traverse an arm ELF linker hash table. */
1603 #define elf32_arm_link_hash_traverse(table, func, info) \
1604 (elf_link_hash_traverse \
1605 (&(table)->root, \
1606 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1607 (info)))
1609 /* Get the ARM elf linker hash table from a link_info structure. */
1610 #define elf32_arm_hash_table(info) \
1611 ((struct elf32_arm_link_hash_table *) ((info)->hash))
1613 /* ARM ELF linker hash table. */
1614 struct elf32_arm_link_hash_table
1615 {
1616 /* The main hash table. */
1619 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
1620 bfd_size_type thumb_glue_size;
1622 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
1623 bfd_size_type arm_glue_size;
1625 /* An arbitrary input BFD chosen to hold the glue sections. */
1628 /* Nonzero to output a BE8 image. */
1631 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1632 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */
1635 /* The relocation to use for R_ARM_TARGET2 relocations. */
1638 /* Nonzero to fix BX instructions for ARMv4 targets. */
1641 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
1644 /* The number of bytes in the initial entry in the PLT. */
1645 bfd_size_type plt_header_size;
1647 /* The number of bytes in the subsequent PLT etries. */
1648 bfd_size_type plt_entry_size;
1650 /* True if the target system is Symbian OS. */
1653 /* True if the target uses REL relocations. */
1656 /* Short-cuts to get to dynamic linker sections. */
1665 /* Data for R_ARM_TLS_LDM32 relocations. */
1667 bfd_signed_vma refcount;
1668 bfd_vma offset;
1671 /* Small local sym to section mapping cache. */
1674 /* For convenience in allocate_dynrelocs. */
1676 };
1678 /* Create an entry in an ARM ELF linker hash table. */
1684 {
1688 /* Allocate the structure if it has not already been allocated by a
1689 subclass. */
1695 /* Call the allocation method of the superclass. */
1700 {
1705 }
1708 }
1710 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
1711 shortcuts to them in our hash table. */
1713 static bfd_boolean
1715 {
1719 /* BPABI objects never have a GOT, or associated sections. */
1733 | SEC_HAS_CONTENTS
1734 | SEC_IN_MEMORY
1735 | SEC_LINKER_CREATED
1741 }
1743 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1744 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1745 hash table. */
1747 static bfd_boolean
1749 {
1772 }
1774 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1776 static void
1780 {
1787 {
1789 {
1796 /* Add reloc counts against the weak sym to the strong sym
1797 list. Merge any entries against the same section. */
1799 {
1804 {
1809 }
1812 }
1814 }
1818 }
1820 /* If the direct symbol already has an associated PLT entry, the
1821 indirect symbol should not. If it doesn't, swap refcount information
1822 from the indirect symbol. */
1824 {
1827 }
1828 else
1833 {
1836 }
1839 }
1841 /* Create an ARM elf linker hash table. */
1845 {
1854 elf32_arm_link_hash_newfunc))
1855 {
1858 }
1873 #ifdef FOUR_WORD_PLT
1876 #else
1879 #endif
1889 }
1891 /* Locate the Thumb encoded calling stub for NAME. */
1897 {
1902 /* We need a pointer to the armelf specific hash table. */
1912 hash = elf_link_hash_lookup
1916 /* xgettext:c-format */
1923 }
1925 /* Locate the ARM encoded calling stub for NAME. */
1931 {
1936 /* We need a pointer to the elfarm specific hash table. */
1946 myh = elf_link_hash_lookup
1950 /* xgettext:c-format */
1957 }
1959 /* ARM->Thumb glue (static images):
1961 .arm
1962 __func_from_arm:
1963 ldr r12, __func_addr
1964 bx r12
1965 __func_addr:
1966 .word func @ behave as if you saw a ARM_32 reloc.
1968 (relocatable images)
1969 .arm
1970 __func_from_arm:
1971 ldr r12, __func_offset
1972 add r12, r12, pc
1973 bx r12
1974 __func_offset:
1975 .word func - .
1976 */
1978 #define ARM2THUMB_STATIC_GLUE_SIZE 12
1983 #define ARM2THUMB_PIC_GLUE_SIZE 16
1988 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
1990 .thumb .thumb
1991 .align 2 .align 2
1992 __func_from_thumb: __func_from_thumb:
1993 bx pc push {r6, lr}
1994 nop ldr r6, __func_addr
1995 .arm mov lr, pc
1996 __func_change_to_arm: bx r6
1997 b func .arm
1998 __func_back_to_thumb:
1999 ldmia r13! {r6, lr}
2000 bx lr
2001 __func_addr:
2002 .word func */
2004 #define THUMB2ARM_GLUE_SIZE 8
2009 #ifndef ELFARM_NABI_C_INCLUDED
2010 bfd_boolean
2012 {
2022 {
2026 ARM2THUMB_GLUE_SECTION_NAME);
2034 }
2037 {
2040 s = bfd_get_section_by_name
2049 }
2052 }
2054 static void
2057 {
2064 bfd_vma val;
2071 s = bfd_get_section_by_name
2076 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2082 myh = elf_link_hash_lookup
2086 {
2087 /* We've already seen this guy. */
2090 }
2092 /* The only trick here is using hash_table->arm_glue_size as the value.
2093 Even though the section isn't allocated yet, this is where we will be
2094 putting it. */
2109 else
2113 }
2115 static void
2118 {
2125 bfd_vma val;
2132 s = bfd_get_section_by_name
2144 myh = elf_link_hash_lookup
2148 {
2149 /* We've already seen this guy. */
2152 }
2160 /* If we mark it 'Thumb', the disassembler will do a better job. */
2170 /* Allocate another symbol to mark where we switch to Arm mode. */
2189 }
2191 /* Add the glue sections to ABFD. This function is called from the
2192 linker scripts in ld/emultempl/{armelf}.em. */
2194 bfd_boolean
2197 {
2198 flagword flags;
2201 /* If we are only performing a partial
2202 link do not bother adding the glue. */
2209 {
2210 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
2211 will prevent elf_link_input_bfd() from processing the contents
2212 of this section. */
2216 ARM2THUMB_GLUE_SECTION_NAME,
2217 flags);
2223 /* Set the gc mark to prevent the section from being removed by garbage
2224 collection, despite the fact that no relocs refer to this section. */
2226 }
2231 {
2236 THUMB2ARM_GLUE_SECTION_NAME,
2237 flags);
2244 }
2247 }
2249 /* Select a BFD to be used to hold the sections used by the glue code.
2250 This function is called from the linker scripts in ld/emultempl/
2251 {armelf/pe}.em */
2253 bfd_boolean
2255 {
2258 /* If we are only performing a partial link
2259 do not bother getting a bfd to hold the glue. */
2263 /* Make sure we don't attach the glue sections to a dynamic object. */
2273 /* Save the bfd for later use. */
2277 }
2279 bfd_boolean
2283 {
2292 /* If we are only performing a partial link do not bother
2293 to construct any glue. */
2297 /* Here we have a bfd that is to be included on the link. We have a hook
2298 to do reloc rummaging, before section sizes are nailed down. */
2305 {
2307 abfd);
2309 }
2312 /* Rummage around all the relocs and map the glue vectors. */
2319 {
2325 /* Load the relocs. */
2326 internal_relocs
2335 {
2344 /* These are the only relocation types we care about. */
2352 /* Get the section contents if we haven't done so already. */
2354 {
2355 /* Get cached copy if it exists. */
2358 else
2359 {
2360 /* Go get them off disk. */
2363 }
2364 }
2366 /* If the relocation is not against a symbol it cannot concern us. */
2369 /* We don't care about local symbols. */
2373 /* This is an external symbol. */
2378 /* If the relocation is against a static symbol it must be within
2379 the current section and so cannot be a cross ARM/Thumb relocation. */
2383 /* If the call will go through a PLT entry then we do not need
2384 glue. */
2389 {
2394 /* This one is a call from arm code. We need to look up
2395 the target of the call. If it is a thumb target, we
2396 insert glue. */
2402 /* This one is a call from thumb code. We look
2403 up the target of the call. If it is not a thumb
2404 target, we insert glue. */
2411 }
2412 }
2423 }
2427 error_return:
2436 }
2437 #endif
2440 /* Set target relocation values needed during linking. */
2442 void
2448 {
2460 else
2461 {
2463 target2_type);
2464 }
2467 }
2469 /* The thumb form of a long branch is a bit finicky, because the offset
2470 encoding is split over two fields, each in it's own instruction. They
2471 can occur in any order. So given a thumb form of long branch, and an
2472 offset, insert the offset into the thumb branch and return finished
2473 instruction.
2475 It takes two thumb instructions to encode the target address. Each has
2476 11 bits to invest. The upper 11 bits are stored in one (identified by
2477 H-0.. see below), the lower 11 bits are stored in the other (identified
2478 by H-1).
2480 Combine together and shifted left by 1 (it's a half word address) and
2481 there you have it.
2483 Op: 1111 = F,
2484 H-0, upper address-0 = 000
2485 Op: 1111 = F,
2486 H-1, lower address-0 = 800
2488 They can be ordered either way, but the arm tools I've seen always put
2489 the lower one first. It probably doesn't matter. krk@cygnus.com
2491 XXX: Actually the order does matter. The second instruction (H-1)
2492 moves the computed address into the PC, so it must be the second one
2493 in the sequence. The problem, however is that whilst little endian code
2494 stores the instructions in HI then LOW order, big endian code does the
2495 reverse. nickc@cygnus.com. */
2497 #define LOW_HI_ORDER 0xF800F000
2498 #define HI_LOW_ORDER 0xF000F800
2500 static insn32
2502 {
2516 else
2517 /* FIXME: abort is probably not the right call. krk@cygnus.com */
2521 }
2523 /* Thumb code calling an ARM function. */
2525 static int
2533 bfd_vma offset,
2534 bfd_signed_vma addend,
2535 bfd_vma val)
2536 {
2538 bfd_vma my_offset;
2556 THUMB2ARM_GLUE_SECTION_NAME);
2563 {
2567 {
2574 }
2585 ret_offset =
2586 /* Address of destination of the stub. */
2589 /* Offset from the start of the current section
2590 to the start of the stubs. */
2592 /* Offset of the start of this stub from the start of the stubs. */
2593 + my_offset
2594 /* Address of the start of the current section. */
2596 /* The branch instruction is 4 bytes into the stub. */
2598 /* ARM branches work from the pc of the instruction + 8. */
2604 }
2608 /* Now go back and fix up the original BL insn to point to here. */
2609 ret_offset =
2610 /* Address of where the stub is located. */
2612 /* Address of where the BL is located. */
2615 /* Addend in the relocation. */
2616 - addend
2617 /* Biassing for PC-relative addressing. */
2628 }
2630 /* Arm code calling a Thumb function. */
2632 static int
2640 bfd_vma offset,
2641 bfd_signed_vma addend,
2642 bfd_vma val)
2643 {
2645 bfd_vma my_offset;
2662 ARM2THUMB_GLUE_SECTION_NAME);
2668 {
2672 {
2677 }
2683 {
2684 /* For relocatable objects we can't use absolute addresses,
2685 so construct the address from a relative offset. */
2686 /* TODO: If the offset is small it's probably worth
2687 constructing the address with adds. */
2694 /* Adjust the offset by 4 for the position of the add,
2695 and 8 for the pipeline offset. */
2702 }
2703 else
2704 {
2711 /* It's a thumb address. Add the low order bit. */
2714 }
2715 }
2722 /* Somehow these are both 4 too far, so subtract 8. */
2724 + my_offset
2736 }
2738 /* Some relocations map to different relocations depending on the
2739 target. Return the real relocation. */
2740 static int
2743 {
2745 {
2749 else
2757 }
2758 }
2760 /* Return the base VMA address which should be subtracted from real addresses
2761 when resolving @dtpoff relocation.
2762 This is PT_TLS segment p_vaddr. */
2764 static bfd_vma
2766 {
2767 /* If tls_sec is NULL, we should have signalled an error already. */
2771 }
2773 /* Return the relocation value for @tpoff relocation
2774 if STT_TLS virtual address is ADDRESS. */
2776 static bfd_vma
2778 {
2780 bfd_vma base;
2782 /* If tls_sec is NULL, we should have signalled an error already. */
2787 }
2789 /* Perform a relocation as part of a final link. */
2791 static bfd_reloc_status_type
2798 bfd_vma value,
2805 {
2816 bfd_vma addend;
2817 bfd_signed_vma signed_addend;
2822 /* Some relocation type map to different relocations depending on the
2823 target. We pick the right one here. */
2828 /* If the start address has been set, then set the EF_ARM_HASENTRY
2829 flag. Setting this more than once is redundant, but the cost is
2830 not too high, and it keeps the code simple.
2832 The test is done here, rather than somewhere else, because the
2833 start address is only set just before the final link commences.
2835 Note - if the user deliberately sets a start address of 0, the
2836 flag will not be set. */
2842 {
2845 }
2852 {
2856 {
2860 }
2861 else
2863 }
2864 else
2868 {
2870 /* We don't need to find a value for this symbol. It's just a
2871 marker. */
2883 /* r_symndx will be zero only for relocs against symbols
2884 from removed linkonce sections, or sections discarded by
2885 a linker script. */
2889 /* Handle relocations which should use the PLT entry. ABS32/REL32
2890 will use the symbol's value, which may point to a PLT entry, but we
2891 don't need to handle that here. If we created a PLT entry, all
2892 branches in this object should go to it. */
2897 {
2898 /* If we've created a .plt section, and assigned a PLT entry to
2899 this function, it should not be known to bind locally. If
2900 it were, we would have cleared the PLT entry. */
2910 }
2912 /* When generating a shared object or relocatable executable, these
2913 relocations are copied into the output file to be resolved at
2914 run time. */
2927 {
2928 Elf_Internal_Rela outrel;
2935 {
2938 name = (bfd_elf_string_from_elf_section
2947 input_section),
2952 }
2975 else
2976 {
2979 /* This symbol is local, or marked to become local. */
2984 {
2985 /* On Symbian OS, the data segment and text segement
2986 can be relocated independently. Therefore, we
2987 must indicate the segment to which this
2988 relocation is relative. The BPABI allows us to
2989 use any symbol in the right segment; we just use
2990 the section symbol as it is convenient. (We
2991 cannot use the symbol given by "h" directly as it
2992 will not appear in the dynamic symbol table.) */
2995 else
2998 }
2999 else
3000 /* On SVR4-ish systems, the dynamic loader cannot
3001 relocate the text and data segments independently,
3002 so the symbol does not matter. */
3005 }
3011 /* If this reloc is against an external symbol, we do not want to
3012 fiddle with the addend. Otherwise, we need to include the symbol
3013 value so that it becomes an addend for the dynamic reloc. */
3020 }
3022 {
3029 {
3030 /* Check for Arm calling Arm function. */
3031 /* FIXME: Should we translate the instruction into a BL
3032 instruction instead ? */
3036 input_bfd,
3038 }
3039 else
3040 {
3041 /* Check for Arm calling Thumb function. */
3043 {
3049 }
3050 }
3052 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3053 where:
3054 S is the address of the symbol in the relocation.
3055 P is address of the instruction being relocated.
3056 A is the addend (extracted from the instruction) in bytes.
3058 S is held in 'value'.
3059 P is the base address of the section containing the
3060 instruction plus the offset of the reloc into that
3061 section, ie:
3062 (input_section->output_section->vma +
3063 input_section->output_offset +
3064 rel->r_offset).
3065 A is the addend, converted into bytes, ie:
3066 (signed_addend * 4)
3068 Note: None of these operations have knowledge of the pipeline
3069 size of the processor, thus it is up to the assembler to
3070 encode this information into the addend. */
3076 else
3077 /* RELA addends do not have to be adjusted by howto->size. */
3083 /* It is not an error for an undefined weak reference to be
3084 out of range. Any program that branches to such a symbol
3085 is going to crash anyway, so there is no point worrying
3086 about getting the destination exactly right. */
3088 {
3089 /* Perform a signed range check. */
3093 }
3095 /* If necessary set the H bit in the BLX instruction. */
3100 else
3122 {
3123 /* Check for overflow */
3126 }
3132 }
3155 /* Support ldr and str instruction for the arm */
3156 /* Also thumb b (unconditional branch). ??? Really? */
3167 /* Support ldr and str instructions for the thumb. */
3169 {
3170 /* Need to refetch addend. */
3172 /* ??? Need to determine shift amount from operand size. */
3174 }
3177 /* ??? Isn't value unsigned? */
3181 /* ??? Value needs to be properly shifted into place first. */
3188 /* Thumb BL (branch long instruction). */
3189 {
3190 bfd_vma relocation;
3196 bfd_vma check;
3197 bfd_signed_vma signed_check;
3200 /* Need to refetch the addend and squish the two 11 bit pieces
3201 together. */
3203 {
3209 }
3212 {
3213 /* Check for Thumb to Thumb call. */
3214 /* FIXME: Should we translate the instruction into a BL
3215 instruction instead ? */
3219 input_bfd,
3221 }
3222 else
3223 {
3224 /* If it is not a call to Thumb, assume call to Arm.
3225 If it is a call relative to a section name, then it is not a
3226 function call at all, but rather a long jump. Calls through
3227 the PLT do not require stubs. */
3231 {
3236 else
3238 }
3239 }
3241 /* Handle calls via the PLT. */
3243 {
3248 {
3249 /* If the Thumb BLX instruction is available, convert the
3250 BL to a BLX instruction to call the ARM-mode PLT entry. */
3252 {
3255 }
3256 }
3257 else
3258 /* Target the Thumb stub before the ARM PLT entry. */
3261 }
3271 /* If this is a signed value, the rightshift just dropped
3272 leading 1 bits (assuming twos complement). */
3275 else
3278 /* Assumes two's complement. */
3285 /* For a BLX instruction, make sure that the relocation is rounded up
3286 to a word boundary. This follows the semantics of the instruction
3287 which specifies that bit 1 of the target address will come from bit
3288 1 of the base address. */
3291 /* Put RELOCATION back into the insn. */
3295 /* Put the relocated value back in the object file: */
3300 }
3304 /* Thumb32 unconditional branch instruction. */
3305 {
3306 bfd_vma relocation;
3312 bfd_vma check;
3313 bfd_signed_vma signed_check;
3315 /* Need to refetch the addend, reconstruct the top three bits, and glue the
3316 two pieces together. */
3318 {
3331 }
3333 /* ??? Should handle interworking? GCC might someday try to
3334 use this for tail calls. */
3343 /* If this is a signed value, the rightshift just dropped
3344 leading 1 bits (assuming twos complement). */
3347 else
3350 /* Assumes two's complement. */
3354 /* Put RELOCATION back into the insn. */
3355 {
3367 }
3369 /* Put the relocated value back in the object file: */
3374 }
3377 /* Thumb32 conditional branch instruction. */
3378 {
3379 bfd_vma relocation;
3385 bfd_vma check;
3386 bfd_signed_vma signed_check;
3388 /* Need to refetch the addend, reconstruct the top three bits,
3389 and squish the two 11 bit pieces together. */
3391 {
3405 }
3407 /* ??? Should handle interworking? GCC might someday try to
3408 use this for tail calls. */
3417 /* If this is a signed value, the rightshift just dropped
3418 leading 1 bits (assuming twos complement). */
3421 else
3424 /* Assumes two's complement. */
3428 /* Put RELOCATION back into the insn. */
3429 {
3438 }
3440 /* Put the relocated value back in the object file: */
3445 }
3450 /* Thumb B (branch) instruction). */
3451 {
3452 bfd_signed_vma relocation;
3455 bfd_signed_vma signed_check;
3457 /* CZB cannot jump backward. */
3462 {
3463 /* Need to refetch addend. */
3466 {
3470 }
3471 else
3473 /* The value in the insn has been right shifted. We need to
3474 undo this, so that we can perform the address calculation
3475 in terms of bytes. */
3477 }
3489 else
3495 /* Assumes two's complement. */
3500 }
3505 {
3506 bfd_vma insn;
3507 bfd_vma relocation;
3511 {
3512 /* Extract the addend. */
3515 }
3525 }
3533 /* Relocation is relative to the start of the
3534 global offset table. */
3540 /* If we are addressing a Thumb function, we need to adjust the
3541 address by one, so that attempts to call the function pointer will
3542 correctly interpret it as Thumb code. */
3546 /* Note that sgot->output_offset is not involved in this
3547 calculation. We always want the start of .got. If we
3548 define _GLOBAL_OFFSET_TABLE in a different way, as is
3549 permitted by the ABI, we might have to change this
3550 calculation. */
3557 /* Use global offset table as symbol value. */
3571 /* Relocation is to the entry for this symbol in the
3572 global offset table. */
3577 {
3578 bfd_vma off;
3579 bfd_boolean dyn;
3590 {
3591 /* This is actually a static link, or it is a -Bsymbolic link
3592 and the symbol is defined locally. We must initialize this
3593 entry in the global offset table. Since the offset must
3594 always be a multiple of 4, we use the least significant bit
3595 to record whether we have initialized it already.
3597 When doing a dynamic link, we create a .rel.got relocation
3598 entry to initialize the value. This is done in the
3599 finish_dynamic_symbol routine. */
3602 else
3603 {
3604 /* If we are addressing a Thumb function, we need to
3605 adjust the address by one, so that attempts to
3606 call the function pointer will correctly
3607 interpret it as Thumb code. */
3613 }
3614 }
3615 else
3619 }
3620 else
3621 {
3622 bfd_vma off;
3629 /* The offset must always be a multiple of 4. We use the
3630 least significant bit to record whether we have already
3631 generated the necessary reloc. */
3634 else
3635 {
3636 /* If we are addressing a Thumb function, we need to
3637 adjust the address by one, so that attempts to
3638 call the function pointer will correctly
3639 interpret it as Thumb code. */
3646 {
3648 Elf_Internal_Rela outrel;
3661 }
3664 }
3667 }
3682 {
3683 bfd_vma off;
3692 else
3693 {
3694 /* If we don't know the module number, create a relocation
3695 for it. */
3697 {
3698 Elf_Internal_Rela outrel;
3713 }
3714 else
3718 }
3726 }
3730 {
3731 bfd_vma off;
3740 {
3741 bfd_boolean dyn;
3746 {
3749 }
3752 }
3753 else
3754 {
3759 }
3766 else
3767 {
3769 Elf_Internal_Rela outrel;
3773 /* The GOT entries have not been initialized yet. Do it
3774 now, and emit any relocations. If both an IE GOT and a
3775 GD GOT are necessary, we emit the GD first. */
3781 {
3787 }
3790 {
3792 {
3805 else
3806 {
3811 R_ARM_TLS_DTPOFF32);
3816 }
3817 }
3818 else
3819 {
3820 /* If we are not emitting relocations for a
3821 general dynamic reference, then we must be in a
3822 static link or an executable link with the
3823 symbol binding locally. Mark it as belonging
3824 to module 1, the executable. */
3829 }
3832 }
3835 {
3837 {
3846 else
3853 }
3854 else
3858 }
3862 else
3864 }
3874 }
3878 {
3884 }
3885 else
3893 {
3896 /* Ensure that we have a BX instruction. */
3899 /* Preserve Rm (lowest four bits) and the condition code
3900 (highest four bits). Other bits encode MOV PC,Rm. */
3904 }
3909 }
3910 }
3912 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
3913 static void
3917 bfd_signed_vma increment)
3918 {
3919 bfd_signed_vma addend;
3922 {
3940 }
3941 else
3942 {
3943 bfd_vma contents;
3947 /* Get the (signed) value from the instruction. */
3950 {
3951 bfd_signed_vma mask;
3956 }
3958 /* Add in the increment, (which is a byte value). */
3960 {
3972 /* Should we check for overflow here ? */
3974 /* Drop any undesired bits. */
3977 }
3982 }
3983 }
3985 #define IS_ARM_TLS_RELOC(R_TYPE) \
3986 ((R_TYPE) == R_ARM_TLS_GD32 \
3987 || (R_TYPE) == R_ARM_TLS_LDO32 \
3988 || (R_TYPE) == R_ARM_TLS_LDM32 \
3989 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
3990 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
3991 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
3992 || (R_TYPE) == R_ARM_TLS_LE32 \
3993 || (R_TYPE) == R_ARM_TLS_IE32)
3995 /* Relocate an ARM ELF section. */
3996 static bfd_boolean
4005 {
4023 {
4030 bfd_vma relocation;
4031 bfd_reloc_status_type r;
4032 arelent bfd_reloc;
4048 {
4049 /* This is a relocatable link. We don't have to change
4050 anything, unless the reloc is against a section symbol,
4051 in which case we have to adjust according to where the
4052 section symbol winds up in the output section. */
4054 {
4057 {
4060 howto,
4063 }
4064 }
4067 }
4069 /* This is a final link. */
4075 {
4080 {
4086 {
4091 {
4097 }
4101 /* Get the (signed) value from the instruction. */
4104 {
4105 bfd_signed_vma mask;
4110 }
4112 addend =
4118 }
4119 }
4120 else
4122 }
4123 else
4124 {
4125 bfd_boolean warned;
4133 }
4137 else
4138 {
4139 name = (bfd_elf_string_from_elf_section
4143 }
4151 {
4156 input_bfd,
4157 input_section,
4160 name);
4161 }
4170 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4171 because such sections are not SEC_ALLOC and thus ld.so will
4172 not process them. */
4176 {
4179 input_bfd,
4180 input_section,
4185 }
4188 {
4192 {
4194 /* If the overflowing reloc was to an undefined symbol,
4195 we have already printed one error message and there
4196 is no point complaining again. */
4227 /* fall through */
4229 common_error:
4235 }
4236 }
4237 }
4240 }
4242 /* Set the right machine number. */
4244 static bfd_boolean
4246 {
4257 else
4261 }
4263 /* Function to keep ARM specific flags in the ELF header. */
4265 static bfd_boolean
4267 {
4270 {
4272 {
4275 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
4276 abfd);
4277 else
4278 _bfd_error_handler
4280 abfd);
4281 }
4282 }
4283 else
4284 {
4287 }
4290 }
4292 /* Copy backend specific data from one object module to another. */
4294 static bfd_boolean
4296 {
4297 flagword in_flags;
4298 flagword out_flags;
4310 {
4311 /* Cannot mix APCS26 and APCS32 code. */
4315 /* Cannot mix float APCS and non-float APCS code. */
4319 /* If the src and dest have different interworking flags
4320 then turn off the interworking bit. */
4322 {
4324 _bfd_error_handler
4325 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
4329 }
4331 /* Likewise for PIC, though don't warn for this case. */
4334 }
4339 /* Also copy the EI_OSABI field. */
4344 }
4346 /* Merge backend specific data from an object file to the output
4347 object file when linking. */
4349 static bfd_boolean
4351 {
4352 flagword out_flags;
4353 flagword in_flags;
4357 /* Check if we have the same endianess. */
4365 /* The input BFD must have had its flags initialised. */
4366 /* The following seems bogus to me -- The flags are initialized in
4367 the assembler but I don't think an elf_flags_init field is
4368 written into the object. */
4369 /* BFD_ASSERT (elf_flags_init (ibfd)); */
4375 {
4376 /* If the input is the default architecture and had the default
4377 flags then do not bother setting the flags for the output
4378 architecture, instead allow future merges to do this. If no
4379 future merges ever set these flags then they will retain their
4380 uninitialised values, which surprise surprise, correspond
4381 to the default values. */
4394 }
4396 /* Determine what should happen if the input ARM architecture
4397 does not match the output ARM architecture. */
4401 /* Identical flags must be compatible. */
4405 /* Check to see if the input BFD actually contains any sections. If
4406 not, its flags may not have been initialised either, but it
4407 cannot actually cause any incompatiblity. Do not short-circuit
4408 dynamic objects; their section list may be emptied by
4409 elf_link_add_object_symbols.
4411 Also check to see if there are no code sections in the input.
4412 In this case there is no need to check for code specific flags.
4413 XXX - do we need to worry about floating-point format compatability
4414 in data sections ? */
4416 {
4421 {
4422 /* Ignore synthetic glue sections. */
4425 {
4433 }
4434 }
4438 }
4440 /* Complain about various flag mismatches. */
4442 {
4443 _bfd_error_handler
4449 }
4451 /* Not sure what needs to be checked for EABI versions >= 1. */
4453 {
4455 {
4456 _bfd_error_handler
4462 }
4465 {
4467 _bfd_error_handler
4470 else
4471 _bfd_error_handler
4476 }
4479 {
4481 _bfd_error_handler
4484 else
4485 _bfd_error_handler
4490 }
4493 {
4495 _bfd_error_handler
4498 else
4499 _bfd_error_handler
4504 }
4506 #ifdef EF_ARM_SOFT_FLOAT
4508 {
4509 /* We can allow interworking between code that is VFP format
4510 layout, and uses either soft float or integer regs for
4511 passing floating point arguments and results. We already
4512 know that the APCS_FLOAT flags match; similarly for VFP
4513 flags. */
4516 {
4518 _bfd_error_handler
4521 else
4522 _bfd_error_handler
4527 }
4528 }
4529 #endif
4531 /* Interworking mismatch is only a warning. */
4533 {
4535 {
4536 _bfd_error_handler
4539 }
4540 else
4541 {
4542 _bfd_error_handler
4545 }
4546 }
4547 }
4550 }
4552 /* Display the flags field. */
4554 static bfd_boolean
4556 {
4562 /* Print normal ELF private data. */
4566 /* Ignore init flag - it may not be set, despite the flags field
4567 containing valid data. */
4569 /* xgettext:c-format */
4573 {
4575 /* The following flag bits are GNU extensions and not part of the
4576 official ARM ELF extended ABI. Hence they are only decoded if
4577 the EABI version is not set. */
4583 else
4590 else
4619 else
4630 else
4662 }
4680 }
4682 static int
4684 {
4686 {
4691 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
4692 This allows us to distinguish between data used by Thumb instructions
4693 and non-data (which is probably code) inside Thumb regions of an
4694 executable. */
4701 }
4704 }
4712 {
4714 {
4716 {
4723 {
4733 }
4734 }
4735 }
4736 else
4740 }
4742 /* Update the got entry reference counts for the section being removed. */
4744 static bfd_boolean
4749 {
4766 {
4773 {
4778 }
4783 {
4789 {
4792 }
4794 {
4797 }
4812 /* Should the interworking branches be here also? */
4815 {
4823 {
4827 }
4831 {
4835 {
4842 }
4843 }
4844 }
4849 }
4850 }
4853 }
4855 /* Look through the relocs for a section during the first phase. */
4857 static bfd_boolean
4860 {
4877 /* Create dynamic sections for relocatable executables so that we can
4878 copy relocations. */
4881 {
4884 }
4891 sym_hashes_end = sym_hashes
4899 {
4910 {
4912 r_symndx);
4914 }
4918 else
4919 {
4924 }
4929 {
4934 /* This symbol requires a global offset table entry. */
4935 {
4939 {
4943 }
4946 {
4949 }
4950 else
4951 {
4954 /* This is a global offset table entry for a local symbol. */
4957 {
4958 bfd_size_type size;
4968 }
4971 }
4973 /* We will already have issued an error message if there is a
4974 TLS / non-TLS mismatch, based on the symbol type. We don't
4975 support any linker relaxations. So just combine any TLS
4976 types needed. */
4982 {
4985 else
4987 }
4988 }
4989 /* Fall through */
4994 /* Fall through */
4999 {
5004 }
5015 /* Should the interworking branches be listed here? */
5017 {
5018 /* If this reloc is in a read-only section, we might
5019 need a copy reloc. We can't check reliably at this
5020 stage whether the section is read-only, as input
5021 sections have not yet been mapped to output sections.
5022 Tentatively set the flag for now, and correct in
5023 adjust_dynamic_symbol. */
5027 /* We may need a .plt entry if the function this reloc
5028 refers to is in a different object. We can't tell for
5029 sure yet, because something later might force the
5030 symbol local. */
5039 /* If we create a PLT entry, this relocation will reference
5040 it, even if it's an ABS32 relocation. */
5045 }
5047 /* If we are creating a shared library or relocatable executable,
5048 and this is a reloc against a global symbol, or a non PC
5049 relative reloc against a local symbol, then we need to copy
5050 the reloc into the shared library. However, if we are linking
5051 with -Bsymbolic, we do not need to copy a reloc against a
5052 global symbol which is defined in an object we are
5053 including in the link (i.e., DEF_REGULAR is set). At
5054 this point we have not seen all the input files, so it is
5055 possible that DEF_REGULAR is not set now but will be set
5056 later (it is never cleared). We account for that
5057 possibility below by storing information in the
5058 relocs_copied field of the hash table entry. */
5064 {
5067 /* When creating a shared object, we must copy these
5068 reloc types into the output file. We create a reloc
5069 section in dynobj and make room for this reloc. */
5071 {
5074 name = (bfd_elf_string_from_elf_section
5087 {
5088 flagword flags;
5093 /* BPABI objects never have dynamic
5094 relocations mapped. */
5098 name,
5099 flags);
5103 }
5106 }
5108 /* If this is a global symbol, we count the number of
5109 relocations we need for this symbol. */
5111 {
5113 }
5114 else
5115 {
5116 /* Track dynamic relocs needed for local syms too.
5117 We really need local syms available to do this
5118 easily. Oh well. */
5128 }
5132 {
5143 }
5148 }
5151 /* This relocation describes the C++ object vtable hierarchy.
5152 Reconstruct it for later use during GC. */
5158 /* This relocation describes which C++ vtable entries are actually
5159 used. Record for later use during GC. */
5164 }
5165 }
5168 }
5170 /* Treat mapping symbols as special target symbols. */
5172 static bfd_boolean
5174 {
5176 }
5178 /* This is a copy of elf_find_function() from elf.c except that
5179 ARM mapping symbols are ignored when looking for function names
5180 and STT_ARM_TFUNC is considered to a function type. */
5182 static bfd_boolean
5186 bfd_vma offset,
5189 {
5196 {
5202 {
5211 /* Skip $a and $t symbols. */
5215 /* Fall through. */
5219 {
5222 }
5224 }
5225 }
5236 }
5239 /* Find the nearest line to a particular section and offset, for error
5240 reporting. This code is a duplicate of the code in elf.c, except
5241 that it uses arm_elf_find_function. */
5243 static bfd_boolean
5247 bfd_vma offset,
5251 {
5254 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
5260 {
5264 functionname_ptr);
5267 }
5287 }
5289 static bfd_boolean
5294 {
5295 bfd_boolean found;
5300 }
5302 /* Adjust a symbol defined by a dynamic object and referenced by a
5303 regular object. The current definition is in some section of the
5304 dynamic object, but we're not including those sections. We have to
5305 change the definition to something the rest of the link can
5306 understand. */
5308 static bfd_boolean
5311 {
5321 /* Make sure we know what is going on here. */
5331 /* If this is a function, put it in the procedure linkage table. We
5332 will fill in the contents of the procedure linkage table later,
5333 when we know the address of the .got section. */
5336 {
5341 {
5342 /* This case can occur if we saw a PLT32 reloc in an input
5343 file, but the symbol was never referred to by a dynamic
5344 object, or if all references were garbage collected. In
5345 such a case, we don't actually need to build a procedure
5346 linkage table, and we can just do a PC24 reloc instead. */
5350 }
5353 }
5354 else
5355 {
5356 /* It's possible that we incorrectly decided a .plt reloc was
5357 needed for an R_ARM_PC24 or similar reloc to a non-function sym
5358 in check_relocs. We can't decide accurately between function
5359 and non-function syms in check-relocs; Objects loaded later in
5360 the link may change h->type. So fix it now. */
5363 }
5365 /* If this is a weak symbol, and there is a real definition, the
5366 processor independent code will have arranged for us to see the
5367 real definition first, and we can just use the same value. */
5369 {
5375 }
5377 /* If there are no non-GOT references, we do not need a copy
5378 relocation. */
5382 /* This is a reference to a symbol defined by a dynamic object which
5383 is not a function. */
5385 /* If we are creating a shared library, we must presume that the
5386 only references to the symbol are via the global offset table.
5387 For such cases we need not do anything here; the relocations will
5388 be handled correctly by relocate_section. Relocatable executables
5389 can reference data in shared objects directly, so we don't need to
5390 do anything here. */
5395 {
5399 }
5401 /* We must allocate the symbol in our .dynbss section, which will
5402 become part of the .bss section of the executable. There will be
5403 an entry for this symbol in the .dynsym section. The dynamic
5404 object will contain position independent code, so all references
5405 from the dynamic object to this symbol will go through the global
5406 offset table. The dynamic linker will use the .dynsym entry to
5407 determine the address it must put in the global offset table, so
5408 both the dynamic object and the regular object will refer to the
5409 same memory location for the variable. */
5413 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
5414 copy the initial value out of the dynamic object and into the
5415 runtime process image. We need to remember the offset into the
5416 .rel.bss section we are going to use. */
5418 {
5425 }
5427 /* We need to figure out the alignment required for this symbol. I
5428 have no idea how ELF linkers handle this. */
5433 /* Apply the required alignment. */
5436 {
5439 }
5441 /* Define the symbol as being at this point in the section. */
5445 /* Increment the section size to make room for the symbol. */
5449 }
5451 /* Allocate space in .plt, .got and associated reloc sections for
5452 dynamic relocs. */
5454 static bfd_boolean
5456 {
5468 /* When warning symbols are created, they **replace** the "real"
5469 entry in the hash table, thus we never get to see the real
5470 symbol in a hash traversal. So look at it now. */
5478 {
5479 /* Make sure this symbol is output as a dynamic symbol.
5480 Undefined weak syms won't yet be marked as dynamic. */
5483 {
5486 }
5490 {
5493 /* If this is the first .plt entry, make room for the special
5494 first entry. */
5500 /* If we will insert a Thumb trampoline before this PLT, leave room
5501 for it. */
5503 {
5506 }
5508 /* If this symbol is not defined in a regular file, and we are
5509 not generating a shared library, then set the symbol to this
5510 location in the .plt. This is required to make function
5511 pointers compare as equal between the normal executable and
5512 the shared library. */
5515 {
5519 /* Make sure the function is not marked as Thumb, in case
5520 it is the target of an ABS32 relocation, which will
5521 point to the PLT entry. */
5524 }
5526 /* Make room for this entry. */
5530 {
5531 /* We also need to make an entry in the .got.plt section, which
5532 will be placed in the .got section by the linker script. */
5535 }
5537 /* We also need to make an entry in the .rel.plt section. */
5539 }
5540 else
5541 {
5544 }
5545 }
5546 else
5547 {
5550 }
5553 {
5555 bfd_boolean dyn;
5559 /* Make sure this symbol is output as a dynamic symbol.
5560 Undefined weak syms won't yet be marked as dynamic. */
5563 {
5566 }
5569 {
5577 /* Non-TLS symbols need one GOT slot. */
5579 else
5580 {
5582 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
5585 /* R_ARM_TLS_IE32 needs one GOT slot. */
5587 }
5601 {
5610 }
5616 }
5617 }
5618 else
5624 /* In the shared -Bsymbolic case, discard space allocated for
5625 dynamic pc-relative relocs against symbols which turn out to be
5626 defined in regular objects. For the normal shared case, discard
5627 space for pc-relative relocs that have become local due to symbol
5628 visibility changes. */
5631 {
5632 /* The only reloc that uses pc_count is R_ARM_REL32, which will
5633 appear on something like ".long foo - .". We want calls to
5634 protected symbols to resolve directly to the function rather
5635 than going via the plt. If people want function pointer
5636 comparisons to work as expected then they should avoid
5637 writing assembly like ".long foo - .". */
5639 {
5643 {
5648 else
5650 }
5651 }
5653 /* Also discard relocs on undefined weak syms with non-default
5654 visibility. */
5660 {
5661 /* Output absolute symbols so that we can create relocations
5662 against them. For normal symbols we output a relocation
5663 against the section that contains them. */
5666 }
5668 }
5669 else
5670 {
5671 /* For the non-shared case, discard space for relocs against
5672 symbols which turn out to need copy relocs or are not
5673 dynamic. */
5681 {
5682 /* Make sure this symbol is output as a dynamic symbol.
5683 Undefined weak syms won't yet be marked as dynamic. */
5686 {
5689 }
5691 /* If that succeeded, we know we'll be keeping all the
5692 relocs. */
5695 }
5699 keep: ;
5700 }
5702 /* Finally, allocate space. */
5704 {
5707 }
5710 }
5712 /* Find any dynamic relocs that apply to read-only sections. */
5714 static bfd_boolean
5716 {
5725 {
5729 {
5734 /* Not an error, just cut short the traversal. */
5736 }
5737 }
5739 }
5741 /* Set the sizes of the dynamic sections. */
5743 static bfd_boolean
5746 {
5749 bfd_boolean plt;
5750 bfd_boolean relocs;
5759 {
5760 /* Set the contents of the .interp section to the interpreter. */
5762 {
5767 }
5768 }
5770 /* Set up .got offsets for local syms, and space for local dynamic
5771 relocs. */
5773 {
5777 bfd_size_type locsymcount;
5785 {
5792 {
5795 {
5796 /* Input section has been discarded, either because
5797 it is a copy of a linkonce section or due to
5798 linker script /DISCARD/, so we'll be discarding
5799 the relocs too. */
5800 }
5802 {
5807 }
5808 }
5809 }
5822 {
5824 {
5827 /* TLS_GD relocs need an 8-byte structure in the GOT. */
5836 }
5837 else
5839 }
5840 }
5843 {
5844 /* Allocate two GOT entries and one dynamic relocation (if necessary)
5845 for R_ARM_TLS_LDM32 relocations. */
5850 }
5851 else
5854 /* Allocate global sym .plt and .got entries, and space for global
5855 sym dynamic relocs. */
5858 /* The check_relocs and adjust_dynamic_symbol entry points have
5859 determined the sizes of the various dynamic sections. Allocate
5860 memory for them. */
5864 {
5870 /* It's OK to base decisions on the section name, because none
5871 of the dynobj section names depend upon the input files. */
5875 {
5876 /* Remember whether there is a PLT. */
5878 }
5880 {
5882 {
5883 /* Remember whether there are any reloc sections other
5884 than .rel.plt. */
5888 /* We use the reloc_count field as a counter if we need
5889 to copy relocs into the output file. */
5891 }
5892 }
5895 {
5896 /* It's not one of our sections, so don't allocate space. */
5898 }
5901 {
5902 /* If we don't need this section, strip it from the
5903 output file. This is mostly to handle .rel.bss and
5904 .rel.plt. We must create both sections in
5905 create_dynamic_sections, because they must be created
5906 before the linker maps input sections to output
5907 sections. The linker does that before
5908 adjust_dynamic_symbol is called, and it is that
5909 function which decides whether anything needs to go
5910 into these sections. */
5913 }
5918 /* Allocate memory for the section contents. */
5922 }
5925 {
5926 /* Add some entries to the .dynamic section. We fill in the
5927 values later, in elf32_arm_finish_dynamic_sections, but we
5928 must add the entries now so that we get the correct size for
5929 the .dynamic section. The DT_DEBUG entry is filled in by the
5930 dynamic linker and used by the debugger. */
5931 #define add_dynamic_entry(TAG, VAL) \
5932 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5935 {
5938 }
5941 {
5947 }
5950 {
5955 }
5957 /* If any dynamic relocs apply to a read-only section,
5958 then we need a DT_TEXTREL entry. */
5964 {
5967 }
5968 }
5969 #undef add_dynamic_entry
5972 }
5974 /* Finish up dynamic symbol handling. We set the contents of various
5975 dynamic sections here. */
5977 static bfd_boolean
5980 {
5990 {
5994 bfd_vma plt_index;
5995 Elf_Internal_Rela rel;
5997 /* This symbol has an entry in the procedure linkage table. Set
5998 it up. */
6006 /* Fill in the entry in the procedure linkage table. */
6008 {
6015 /* Fill in the entry in the .rel.plt section. */
6021 /* Get the index in the procedure linkage table which
6022 corresponds to this symbol. This is the index of this symbol
6023 in all the symbols for which we are making plt entries. The
6024 first entry in the procedure linkage table is reserved. */
6027 }
6028 else
6029 {
6030 bfd_vma got_offset;
6031 bfd_vma got_displacement;
6037 /* Get the offset into the .got.plt table of the entry that
6038 corresponds to this function. */
6041 /* Get the index in the procedure linkage table which
6042 corresponds to this symbol. This is the index of this symbol
6043 in all the symbols for which we are making plt entries. The
6044 first three entries in .got.plt are reserved; after that
6045 symbols appear in the same order as in .plt. */
6048 /* Calculate the displacement between the PLT slot and the
6049 entry in the GOT. The eight-byte offset accounts for the
6050 value produced by adding to pc in the first instruction
6051 of the PLT stub. */
6054 + got_offset
6063 {
6068 }
6076 #ifdef FOUR_WORD_PLT
6079 #endif
6081 /* Fill in the entry in the global offset table. */
6087 /* Fill in the entry in the .rel.plt section. */
6092 }
6098 {
6099 /* Mark the symbol as undefined, rather than as defined in
6100 the .plt section. Leave the value alone. */
6102 /* If the symbol is weak, we do need to clear the value.
6103 Otherwise, the PLT entry would provide a definition for
6104 the symbol even if the symbol wasn't defined anywhere,
6105 and so the symbol would never be NULL. */
6108 }
6109 }
6114 {
6117 Elf_Internal_Rela rel;
6120 /* This symbol has an entry in the global offset table. Set it
6121 up. */
6130 /* If this is a static link, or it is a -Bsymbolic link and the
6131 symbol is defined locally or was forced to be local because
6132 of a version file, we just want to emit a RELATIVE reloc.
6133 The entry in the global offset table will already have been
6134 initialized in the relocate_section function. */
6137 {
6140 }
6141 else
6142 {
6146 }
6150 }
6153 {
6155 Elf_Internal_Rela rel;
6158 /* This symbol needs a copy reloc. Set it up. */
6173 }
6175 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6181 }
6183 /* Finish up the dynamic sections. */
6185 static bfd_boolean
6187 {
6199 {
6212 {
6213 Elf_Internal_Dyn dyn;
6220 {
6250 get_vma:
6255 else
6256 /* In the BPABI, tags in the PT_DYNAMIC section point
6257 at the file offset, not the memory address, for the
6258 convenience of the post linker. */
6263 get_vma_if_bpabi:
6277 {
6278 /* My reading of the SVR4 ABI indicates that the
6279 procedure linkage table relocs (DT_JMPREL) should be
6280 included in the overall relocs (DT_REL). This is
6281 what Solaris does. However, UnixWare can not handle
6282 that case. Therefore, we override the DT_RELSZ entry
6283 here to make it not include the JMPREL relocs. Since
6284 the linker script arranges for .rel.plt to follow all
6285 other relocation sections, we don't have to worry
6286 about changing the DT_REL entry. */
6292 }
6293 /* Fall through */
6298 /* In the BPABI, the DT_REL tag must point at the file
6299 offset, not the VMA, of the first relocation
6300 section. So, we use code similar to that in
6301 elflink.c, but do not check for SHF_ALLOC on the
6302 relcoation section, since relocations sections are
6303 never allocated under the BPABI. The comments above
6304 about Unixware notwithstanding, we include all of the
6305 relocations here. */
6307 {
6313 {
6314 Elf_Internal_Shdr *hdr
6317 {
6324 }
6325 }
6327 }
6330 /* Set the bottom bit of DT_INIT/FINI if the
6331 corresponding function is Thumb. */
6337 get_sym:
6338 /* If it wasn't set by elf_bfd_final_link
6339 then there is nothing to adjust. */
6341 {
6348 {
6351 }
6352 }
6354 }
6355 }
6357 /* Fill in the first entry in the procedure linkage table. */
6359 {
6360 bfd_vma got_displacement;
6362 /* Calculate the displacement between the PLT slot and &GOT[0]. */
6373 #ifdef FOUR_WORD_PLT
6374 /* The displacement value goes in the otherwise-unused last word of
6375 the second entry. */
6377 #else
6379 #endif
6380 }
6382 /* UnixWare sets the entsize of .plt to 4, although that doesn't
6383 really seem like the right value. */
6385 }
6387 /* Fill in the first three entries in the global offset table. */
6389 {
6391 {
6394 else
6400 }
6403 }
6406 }
6408 static void
6410 {
6418 else
6423 {
6427 }
6428 }
6430 static enum elf_reloc_type_class
6432 {
6434 {
6443 }
6444 }
6446 /* Set the right machine number for an Arm ELF file. */
6448 static bfd_boolean
6450 {
6455 }
6457 static void
6459 {
6461 }
6463 /* Return TRUE if this is an unwinding table entry. */
6465 static bfd_boolean
6467 {
6474 }
6477 /* Set the type and flags for an ARM section. We do this by
6478 the section name, which is a hack, but ought to work. */
6480 static bfd_boolean
6482 {
6488 {
6491 }
6493 }
6495 /* Handle an ARM specific section when reading an object file. This is
6496 called when bfd_section_from_shdr finds a section with an unknown
6497 type. */
6499 static bfd_boolean
6504 {
6505 /* There ought to be a place to keep ELF backend specific flags, but
6506 at the moment there isn't one. We just keep track of the
6507 sections by their name, instead. Fortunately, the ABI gives
6508 names for all the ARM specific sections, so we will probably get
6509 away with this. */
6511 {
6517 }
6523 }
6525 /* A structure used to record a list of sections, independently
6526 of the next and prev fields in the asection structure. */
6528 {
6532 }
6533 section_list;
6535 /* Unfortunately we need to keep a list of sections for which
6536 an _arm_elf_section_data structure has been allocated. This
6537 is because it is possible for functions like elf32_arm_write_section
6538 to be called on a section which has had an elf_data_structure
6539 allocated for it (and so the used_by_bfd field is valid) but
6540 for which the ARM extended version of this structure - the
6541 _arm_elf_section_data structure - has not been allocated. */
6544 static void
6546 {
6558 }
6562 {
6569 }
6571 static void
6573 {
6578 {
6587 }
6588 }
6590 /* Called for each symbol. Builds a section map based on mapping symbols.
6591 Does not alter any of the symbols. */
6593 static bfd_boolean
6599 {
6606 /* Only do this on final link. */
6610 /* Only build a map if we need to byteswap code. */
6615 /* We only want mapping symbols. */
6619 /* If this section has not been allocated an _arm_elf_section_data
6620 structure then we cannot record anything. */
6627 /* TODO: This may be inefficient, but we probably don't usually have many
6628 mapping symbols per section. */
6631 {
6637 }
6640 }
6642 /* Allocate target specific section data. */
6644 static bfd_boolean
6646 {
6658 }
6661 /* Used to order a list of mapping symbols by address. */
6663 static int
6665 {
6668 }
6671 /* Do code byteswapping. Return FALSE afterwards so that the section is
6672 written out as normal. */
6674 static bfd_boolean
6677 {
6681 bfd_vma ptr;
6682 bfd_vma end;
6683 bfd_vma offset;
6684 bfd_byte tmp;
6687 /* If this section has not been allocated an _arm_elf_section_data
6688 structure then we cannot record anything. */
6704 {
6707 else
6711 {
6713 /* Byte swap code words. */
6715 {
6723 }
6727 /* Byte swap code halfwords. */
6729 {
6734 }
6738 /* Leave data alone. */
6740 }
6742 }
6750 }
6752 static void
6756 {
6758 }
6760 static bfd_boolean
6762 {
6766 }
6768 /* Display STT_ARM_TFUNC symbols as functions. */
6770 static void
6773 {
6778 }
6781 /* Mangle thumb function symbols as we read them in. */
6783 static void
6788 {
6791 /* New EABI objects mark thumb function symbols by setting the low bit of
6792 the address. Turn these into STT_ARM_TFUNC. */
6795 {
6798 }
6799 }
6802 /* Mangle thumb function symbols as we write them out. */
6804 static void
6809 {
6810 Elf_Internal_Sym newsym;
6812 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
6813 of the address set, as per the new EABI. We do this unconditionally
6814 because objcopy does not set the elf header flags until after
6815 it writes out the symbol table. */
6817 {
6823 }
6825 }
6827 /* Add the PT_ARM_EXIDX program header. */
6829 static bfd_boolean
6832 {
6838 {
6839 /* If there is already a PT_ARM_EXIDX header, then we do not
6840 want to add another one. This situation arises when running
6841 "strip"; the input binary already has the header. */
6846 {
6856 }
6857 }
6860 }
6862 /* We may add a PT_ARM_EXIDX program header. */
6864 static int
6866 {
6872 else
6874 }
6876 /* We use this to override swap_symbol_in and swap_symbol_out. */
6890 bfd_elf32_write_out_phdrs,
6891 bfd_elf32_write_shdrs_and_ehdr,
6892 bfd_elf32_write_relocs,
6893 elf32_arm_swap_symbol_in,
6894 elf32_arm_swap_symbol_out,
6895 bfd_elf32_slurp_reloc_table,
6896 bfd_elf32_slurp_symbol_table,
6897 bfd_elf32_swap_dyn_in,
6898 bfd_elf32_swap_dyn_out,
6899 bfd_elf32_swap_reloc_in,
6900 bfd_elf32_swap_reloc_out,
6901 bfd_elf32_swap_reloca_in,
6902 bfd_elf32_swap_reloca_out
6903 };
6905 #define ELF_ARCH bfd_arch_arm
6906 #define ELF_MACHINE_CODE EM_ARM
6907 #ifdef __QNXTARGET__
6908 #define ELF_MAXPAGESIZE 0x1000
6909 #else
6910 #define ELF_MAXPAGESIZE 0x8000
6911 #endif
6912 #define ELF_MINPAGESIZE 0x1000
6914 #define bfd_elf32_mkobject elf32_arm_mkobject
6916 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
6917 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
6918 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
6919 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
6920 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
6921 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
6922 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
6923 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
6924 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
6925 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
6926 #define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup
6928 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
6929 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
6930 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
6931 #define elf_backend_check_relocs elf32_arm_check_relocs
6932 #define elf_backend_relocate_section elf32_arm_relocate_section
6933 #define elf_backend_write_section elf32_arm_write_section
6934 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
6935 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
6936 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
6937 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
6938 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
6939 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
6940 #define elf_backend_post_process_headers elf32_arm_post_process_headers
6941 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
6942 #define elf_backend_object_p elf32_arm_object_p
6943 #define elf_backend_section_flags elf32_arm_section_flags
6944 #define elf_backend_fake_sections elf32_arm_fake_sections
6945 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
6946 #define elf_backend_final_write_processing elf32_arm_final_write_processing
6947 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
6948 #define elf_backend_symbol_processing elf32_arm_symbol_processing
6949 #define elf_backend_size_info elf32_arm_size_info
6950 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
6951 #define elf_backend_additional_program_headers \
6952 elf32_arm_additional_program_headers
6954 #define elf_backend_can_refcount 1
6955 #define elf_backend_can_gc_sections 1
6956 #define elf_backend_plt_readonly 1
6957 #define elf_backend_want_got_plt 1
6958 #define elf_backend_want_plt_sym 0
6959 #define elf_backend_may_use_rel_p 1
6960 #define elf_backend_may_use_rela_p 0
6961 #define elf_backend_default_use_rela_p 0
6962 #define elf_backend_rela_normal 0
6964 #define elf_backend_got_header_size 12
6968 /* VxWorks Targets */
6970 #undef TARGET_LITTLE_SYM
6971 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
6972 #undef TARGET_LITTLE_NAME
6974 #undef TARGET_BIG_SYM
6975 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
6976 #undef TARGET_BIG_NAME
6979 /* Like elf32_arm_link_hash_table_create -- but overrides
6980 appropriately for VxWorks. */
6983 {
6988 {
6992 }
6994 }
6996 #undef elf32_bed
6997 #define elf32_bed elf32_arm_vxworks_bed
6999 #undef bfd_elf32_bfd_link_hash_table_create
7000 #define bfd_elf32_bfd_link_hash_table_create \
7001 elf32_arm_vxworks_link_hash_table_create
7003 #undef elf_backend_may_use_rel_p
7004 #define elf_backend_may_use_rel_p 0
7005 #undef elf_backend_may_use_rela_p
7006 #define elf_backend_may_use_rela_p 1
7007 #undef elf_backend_default_use_rela_p
7008 #define elf_backend_default_use_rela_p 1
7009 #undef elf_backend_rela_normal
7010 #define elf_backend_rela_normal 1
7015 /* Symbian OS Targets */
7017 #undef TARGET_LITTLE_SYM
7018 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
7019 #undef TARGET_LITTLE_NAME
7021 #undef TARGET_BIG_SYM
7022 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
7023 #undef TARGET_BIG_NAME
7026 /* Like elf32_arm_link_hash_table_create -- but overrides
7027 appropriately for Symbian OS. */
7030 {
7035 {
7038 /* There is no PLT header for Symbian OS. */
7040 /* The PLT entries are each three instructions. */
7043 /* Symbian uses armv5t or above, so use_blx is always true. */
7046 }
7048 }
7050 static const struct bfd_elf_special_section
7051 elf32_arm_symbian_special_sections[] =
7052 {
7053 /* In a BPABI executable, the dynamic linking sections do not go in
7054 the loadable read-only segment. The post-linker may wish to
7055 refer to these sections, but they are not part of the final
7056 program image. */
7062 /* These sections do not need to be writable as the SymbianOS
7063 postlinker will arrange things so that no dynamic relocation is
7064 required. */
7069 };
7071 static void
7074 ATTRIBUTE_UNUSED)
7075 {
7076 /* BPABI objects are never loaded directly by an OS kernel; they are
7077 processed by a postlinker first, into an OS-specific format. If
7078 the D_PAGED bit is set on the file, BFD will align segments on
7079 page boundaries, so that an OS can directly map the file. With
7080 BPABI objects, that just results in wasted space. In addition,
7081 because we clear the D_PAGED bit, map_sections_to_segments will
7082 recognize that the program headers should not be mapped into any
7083 loadable segment. */
7085 }
7087 static bfd_boolean
7090 {
7094 /* BPABI shared libraries and executables should have a PT_DYNAMIC
7095 segment. However, because the .dynamic section is not marked
7096 with SEC_LOAD, the generic ELF code will not create such a
7097 segment. */
7100 {
7104 }
7106 /* Also call the generic arm routine. */
7108 }
7110 #undef elf32_bed
7111 #define elf32_bed elf32_arm_symbian_bed
7113 /* The dynamic sections are not allocated on SymbianOS; the postlinker
7114 will process them and then discard them. */
7115 #undef ELF_DYNAMIC_SEC_FLAGS
7116 #define ELF_DYNAMIC_SEC_FLAGS \
7117 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
7119 #undef bfd_elf32_bfd_link_hash_table_create
7120 #define bfd_elf32_bfd_link_hash_table_create \
7121 elf32_arm_symbian_link_hash_table_create
7123 #undef elf_backend_special_sections
7124 #define elf_backend_special_sections elf32_arm_symbian_special_sections
7126 #undef elf_backend_begin_write_processing
7127 #define elf_backend_begin_write_processing \
7128 elf32_arm_symbian_begin_write_processing
7130 #undef elf_backend_modify_segment_map
7131 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
7133 /* There is no .got section for BPABI objects, and hence no header. */
7134 #undef elf_backend_got_header_size
7135 #define elf_backend_got_header_size 0
7137 /* Similarly, there is no .got.plt section. */
7138 #undef elf_backend_want_got_plt
7139 #define elf_backend_want_got_plt 0
7141 #undef elf_backend_may_use_rel_p
7142 #define elf_backend_may_use_rel_p 1
7143 #undef elf_backend_may_use_rela_p
7144 #define elf_backend_may_use_rela_p 0
7145 #undef elf_backend_default_use_rela_p
7146 #define elf_backend_default_use_rela_p 0
7147 #undef elf_backend_rela_normal
7148 #define elf_backend_rela_normal 0