X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Felf32-arm.c;h=02d43a86195bd527fec24c845c2e925bc5a45346;hb=7c1f42273567c30e17e1363897ce5c6d0764c643;hp=ce9c2f29bf82b680fea7281ffb723a1c04bd5d0c;hpb=f3185997ac0951edac802e29df03dfc0844fda34;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elf32-arm.c b/bfd/elf32-arm.c index ce9c2f29bf..02d43a8619 100644 --- a/bfd/elf32-arm.c +++ b/bfd/elf32-arm.c @@ -1,5 +1,5 @@ /* 32-bit ELF support for ARM - Copyright (C) 1998-2018 Free Software Foundation, Inc. + Copyright (C) 1998-2020 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -22,13 +22,14 @@ #include #include "bfd.h" -#include "bfd_stdint.h" #include "libiberty.h" #include "libbfd.h" #include "elf-bfd.h" #include "elf-nacl.h" #include "elf-vxworks.h" #include "elf/arm.h" +#include "elf32-arm.h" +#include "cpu-arm.h" /* Return the relocation section associated with NAME. HTAB is the bfd's elf32_arm_link_hash_entry. */ @@ -1743,10 +1744,50 @@ static reloc_howto_type elf32_arm_howto_table_1[] = 0x00000000, /* src_mask. */ 0x00000000, /* dst_mask. */ FALSE), /* pcrel_offset. */ + /* Relocations for Armv8.1-M Mainline. */ + HOWTO (R_ARM_THM_BF16, /* type. */ + 0, /* rightshift. */ + 1, /* size (0 = byte, 1 = short, 2 = long). */ + 16, /* bitsize. */ + TRUE, /* pc_relative. */ + 0, /* bitpos. */ + complain_overflow_dont,/* do not complain_on_overflow. */ + bfd_elf_generic_reloc, /* special_function. */ + "R_ARM_THM_BF16", /* name. */ + FALSE, /* partial_inplace. */ + 0x001f0ffe, /* src_mask. */ + 0x001f0ffe, /* dst_mask. */ + TRUE), /* pcrel_offset. */ + HOWTO (R_ARM_THM_BF12, /* type. */ + 0, /* rightshift. */ + 1, /* size (0 = byte, 1 = short, 2 = long). */ + 12, /* bitsize. */ + TRUE, /* pc_relative. */ + 0, /* bitpos. */ + complain_overflow_dont,/* do not complain_on_overflow. */ + bfd_elf_generic_reloc, /* special_function. */ + "R_ARM_THM_BF12", /* name. */ + FALSE, /* partial_inplace. */ + 0x00010ffe, /* src_mask. */ + 0x00010ffe, /* dst_mask. */ + TRUE), /* pcrel_offset. */ + HOWTO (R_ARM_THM_BF18, /* type. */ + 0, /* rightshift. */ + 1, /* size (0 = byte, 1 = short, 2 = long). */ + 18, /* bitsize. */ + TRUE, /* pc_relative. */ + 0, /* bitpos. */ + complain_overflow_dont,/* do not complain_on_overflow. */ + bfd_elf_generic_reloc, /* special_function. */ + "R_ARM_THM_BF18", /* name. */ + FALSE, /* partial_inplace. */ + 0x007f0ffe, /* src_mask. */ + 0x007f0ffe, /* dst_mask. */ + TRUE), /* pcrel_offset. */ }; /* 160 onwards: */ -static reloc_howto_type elf32_arm_howto_table_2[1] = +static reloc_howto_type elf32_arm_howto_table_2[8] = { HOWTO (R_ARM_IRELATIVE, /* type */ 0, /* rightshift */ @@ -1760,7 +1801,98 @@ static reloc_howto_type elf32_arm_howto_table_2[1] = TRUE, /* partial_inplace */ 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ - FALSE) /* pcrel_offset */ + FALSE), /* pcrel_offset */ + HOWTO (R_ARM_GOTFUNCDESC, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_ARM_GOTFUNCDESC", /* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ + HOWTO (R_ARM_GOTOFFFUNCDESC, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_ARM_GOTOFFFUNCDESC",/* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ + HOWTO (R_ARM_FUNCDESC, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_ARM_FUNCDESC", /* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ + HOWTO (R_ARM_FUNCDESC_VALUE, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 64, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_ARM_FUNCDESC_VALUE",/* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ + HOWTO (R_ARM_TLS_GD32_FDPIC, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_ARM_TLS_GD32_FDPIC",/* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ + HOWTO (R_ARM_TLS_LDM32_FDPIC, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_ARM_TLS_LDM32_FDPIC",/* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ + HOWTO (R_ARM_TLS_IE32_FDPIC, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + bfd_elf_generic_reloc, /* special_function */ + "R_ARM_TLS_IE32_FDPIC",/* name */ + FALSE, /* partial_inplace */ + 0, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ }; /* 249-255 extended, currently unused, relocations: */ @@ -1829,7 +1961,8 @@ elf32_arm_howto_from_type (unsigned int r_type) if (r_type < ARRAY_SIZE (elf32_arm_howto_table_1)) return &elf32_arm_howto_table_1[r_type]; - if (r_type == R_ARM_IRELATIVE) + if (r_type >= R_ARM_IRELATIVE + && r_type < R_ARM_IRELATIVE + ARRAY_SIZE (elf32_arm_howto_table_2)) return &elf32_arm_howto_table_2[r_type - R_ARM_IRELATIVE]; if (r_type >= R_ARM_RREL32 @@ -1913,6 +2046,13 @@ static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] = {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32}, {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32}, {BFD_RELOC_ARM_IRELATIVE, R_ARM_IRELATIVE}, + {BFD_RELOC_ARM_GOTFUNCDESC, R_ARM_GOTFUNCDESC}, + {BFD_RELOC_ARM_GOTOFFFUNCDESC, R_ARM_GOTOFFFUNCDESC}, + {BFD_RELOC_ARM_FUNCDESC, R_ARM_FUNCDESC}, + {BFD_RELOC_ARM_FUNCDESC_VALUE, R_ARM_FUNCDESC_VALUE}, + {BFD_RELOC_ARM_TLS_GD32_FDPIC, R_ARM_TLS_GD32_FDPIC}, + {BFD_RELOC_ARM_TLS_LDM32_FDPIC, R_ARM_TLS_LDM32_FDPIC}, + {BFD_RELOC_ARM_TLS_IE32_FDPIC, R_ARM_TLS_IE32_FDPIC}, {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT}, {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY}, {BFD_RELOC_ARM_MOVW, R_ARM_MOVW_ABS_NC}, @@ -1955,7 +2095,10 @@ static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] = {BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC, R_ARM_THM_ALU_ABS_G3_NC}, {BFD_RELOC_ARM_THUMB_ALU_ABS_G2_NC, R_ARM_THM_ALU_ABS_G2_NC}, {BFD_RELOC_ARM_THUMB_ALU_ABS_G1_NC, R_ARM_THM_ALU_ABS_G1_NC}, - {BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC, R_ARM_THM_ALU_ABS_G0_NC} + {BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC, R_ARM_THM_ALU_ABS_G0_NC}, + {BFD_RELOC_ARM_THUMB_BF17, R_ARM_THM_BF16}, + {BFD_RELOC_ARM_THUMB_BF13, R_ARM_THM_BF12}, + {BFD_RELOC_ARM_THUMB_BF19, R_ARM_THM_BF18} }; static reloc_howto_type * @@ -2069,13 +2212,24 @@ elf32_arm_nabi_write_core_note (bfd *abfd, char *buf, int *bufsiz, case NT_PRPSINFO: { - char data[124]; + char data[124] ATTRIBUTE_NONSTRING; va_list ap; va_start (ap, note_type); memset (data, 0, sizeof (data)); strncpy (data + 28, va_arg (ap, const char *), 16); +#if GCC_VERSION == 8000 || GCC_VERSION == 8001 + DIAGNOSTIC_PUSH; + /* GCC 8.0 and 8.1 warn about 80 equals destination size with + -Wstringop-truncation: + https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643 + */ + DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION; +#endif strncpy (data + 44, va_arg (ap, const char *), 80); +#if GCC_VERSION == 8000 || GCC_VERSION == 8001 + DIAGNOSTIC_POP; +#endif va_end (ap); return elfcore_write_note (abfd, buf, bufsiz, @@ -2148,10 +2302,15 @@ typedef unsigned short int insn16; #define CMSE_PREFIX "__acle_se_" +#define CMSE_STUB_NAME ".gnu.sgstubs" + /* The name of the dynamic interpreter. This is put in the .interp section. */ #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" +/* FDPIC default stack size. */ +#define DEFAULT_STACK_SIZE 0x8000 + static const unsigned long tls_trampoline [] = { 0xe08e0000, /* add r0, lr, r0 */ @@ -2172,6 +2331,43 @@ static const unsigned long dl_tlsdesc_lazy_trampoline [] = 0x00000018, /* 4: .word _GLOBAL_OFFSET_TABLE_ - 2b - 8 */ }; +/* NOTE: [Thumb nop sequence] + When adding code that transitions from Thumb to Arm the instruction that + should be used for the alignment padding should be 0xe7fd (b .-2) instead of + a nop for performance reasons. */ + +/* ARM FDPIC PLT entry. */ +/* The last 5 words contain PLT lazy fragment code and data. */ +static const bfd_vma elf32_arm_fdpic_plt_entry [] = + { + 0xe59fc008, /* ldr r12, .L1 */ + 0xe08cc009, /* add r12, r12, r9 */ + 0xe59c9004, /* ldr r9, [r12, #4] */ + 0xe59cf000, /* ldr pc, [r12] */ + 0x00000000, /* L1. .word foo(GOTOFFFUNCDESC) */ + 0x00000000, /* L1. .word foo(funcdesc_value_reloc_offset) */ + 0xe51fc00c, /* ldr r12, [pc, #-12] */ + 0xe92d1000, /* push {r12} */ + 0xe599c004, /* ldr r12, [r9, #4] */ + 0xe599f000, /* ldr pc, [r9] */ + }; + +/* Thumb FDPIC PLT entry. */ +/* The last 5 words contain PLT lazy fragment code and data. */ +static const bfd_vma elf32_arm_fdpic_thumb_plt_entry [] = + { + 0xc00cf8df, /* ldr.w r12, .L1 */ + 0x0c09eb0c, /* add.w r12, r12, r9 */ + 0x9004f8dc, /* ldr.w r9, [r12, #4] */ + 0xf000f8dc, /* ldr.w pc, [r12] */ + 0x00000000, /* .L1 .word foo(GOTOFFFUNCDESC) */ + 0x00000000, /* .L2 .word foo(funcdesc_value_reloc_offset) */ + 0xc008f85f, /* ldr.w r12, .L2 */ + 0xcd04f84d, /* push {r12} */ + 0xc004f8d9, /* ldr.w r12, [r9, #4] */ + 0xf000f8d9, /* ldr.w pc, [r9] */ + }; + #ifdef FOUR_WORD_PLT /* The first entry in a procedure linkage table looks like @@ -2257,8 +2453,8 @@ static const bfd_vma elf32_thumb2_plt_entry [] = 0x0c00f240, /* movw ip, #0xNNNN */ 0x0c00f2c0, /* movt ip, #0xNNNN */ 0xf8dc44fc, /* add ip, pc */ - 0xbf00f000 /* ldr.w pc, [ip] */ - /* nop */ + 0xe7fcf000 /* ldr.w pc, [ip] */ + /* b .-4 */ }; /* The format of the first entry in the procedure linkage table @@ -2298,7 +2494,7 @@ static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] = static const bfd_vma elf32_arm_plt_thumb_stub [] = { 0x4778, /* bx pc */ - 0x46c0 /* nop */ + 0xe7fd /* b .-2 */ }; /* The entries in a PLT when using a DLL-based target with multiple @@ -2385,6 +2581,8 @@ typedef struct int reloc_addend; } insn_sequence; +/* See note [Thumb nop sequence] when adding a veneer. */ + /* Arm/Thumb -> Arm/Thumb long branch stub. On V5T and above, use blx to reach the stub if necessary. */ static const insn_sequence elf32_arm_stub_long_branch_any_any[] = @@ -2435,7 +2633,7 @@ static const insn_sequence elf32_arm_stub_long_branch_thumb2_only_pure[] = static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb[] = { THUMB16_INSN (0x4778), /* bx pc */ - THUMB16_INSN (0x46c0), /* nop */ + THUMB16_INSN (0xe7fd), /* b .-2 */ ARM_INSN (0xe59fc000), /* ldr ip, [pc, #0] */ ARM_INSN (0xe12fff1c), /* bx ip */ DATA_WORD (0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */ @@ -2446,7 +2644,7 @@ static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb[] = static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm[] = { THUMB16_INSN (0x4778), /* bx pc */ - THUMB16_INSN (0x46c0), /* nop */ + THUMB16_INSN (0xe7fd), /* b .-2 */ ARM_INSN (0xe51ff004), /* ldr pc, [pc, #-4] */ DATA_WORD (0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */ }; @@ -2456,7 +2654,7 @@ static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm[] = static const insn_sequence elf32_arm_stub_short_branch_v4t_thumb_arm[] = { THUMB16_INSN (0x4778), /* bx pc */ - THUMB16_INSN (0x46c0), /* nop */ + THUMB16_INSN (0xe7fd), /* b .-2 */ ARM_REL_INSN (0xea000000, -8), /* b (X-8) */ }; @@ -2494,7 +2692,7 @@ static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb_pic[] = static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm_pic[] = { THUMB16_INSN (0x4778), /* bx pc */ - THUMB16_INSN (0x46c0), /* nop */ + THUMB16_INSN (0xe7fd), /* b .-2 */ ARM_INSN (0xe59fc000), /* ldr ip, [pc, #0] */ ARM_INSN (0xe08cf00f), /* add pc, ip, pc */ DATA_WORD (0, R_ARM_REL32, -4), /* dcd R_ARM_REL32(X) */ @@ -2518,7 +2716,7 @@ static const insn_sequence elf32_arm_stub_long_branch_thumb_only_pic[] = static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb_pic[] = { THUMB16_INSN (0x4778), /* bx pc */ - THUMB16_INSN (0x46c0), /* nop */ + THUMB16_INSN (0xe7fd), /* b .-2 */ ARM_INSN (0xe59fc004), /* ldr ip, [pc, #4] */ ARM_INSN (0xe08fc00c), /* add ip, pc, ip */ ARM_INSN (0xe12fff1c), /* bx ip */ @@ -2539,7 +2737,7 @@ static const insn_sequence elf32_arm_stub_long_branch_any_tls_pic[] = static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_tls_pic[] = { THUMB16_INSN (0x4778), /* bx pc */ - THUMB16_INSN (0x46c0), /* nop */ + THUMB16_INSN (0xe7fd), /* b .-2 */ ARM_INSN (0xe59f1000), /* ldr r1, [pc, #0] */ ARM_INSN (0xe081f00f), /* add pc, r1, pc */ DATA_WORD (0, R_ARM_REL32, -4), /* dcd R_ARM_REL32(X) */ @@ -2944,6 +3142,13 @@ struct arm_local_iplt_info struct elf_dyn_relocs *dyn_relocs; }; +/* Structure to handle FDPIC support for local functions. */ +struct fdpic_local { + unsigned int funcdesc_cnt; + unsigned int gotofffuncdesc_cnt; + int funcdesc_offset; +}; + struct elf_arm_obj_tdata { struct elf_obj_tdata root; @@ -2962,6 +3167,9 @@ struct elf_arm_obj_tdata /* Zero to warn when linking objects with incompatible wchar_t sizes. */ int no_wchar_size_warning; + + /* Maintains FDPIC counters and funcdesc info. */ + struct fdpic_local *local_fdpic_cnts; }; #define elf_arm_tdata(bfd) \ @@ -2976,6 +3184,9 @@ struct elf_arm_obj_tdata #define elf32_arm_local_iplt(bfd) \ (elf_arm_tdata (bfd)->local_iplt) +#define elf32_arm_local_fdpic_cnts(bfd) \ + (elf_arm_tdata (bfd)->local_fdpic_cnts) + #define is_arm_elf(bfd) \ (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ && elf_tdata (bfd) != NULL \ @@ -2990,6 +3201,15 @@ elf32_arm_mkobject (bfd *abfd) #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent)) +/* Structure to handle FDPIC support for extern functions. */ +struct fdpic_global { + unsigned int gotofffuncdesc_cnt; + unsigned int gotfuncdesc_cnt; + unsigned int funcdesc_cnt; + int funcdesc_offset; + int gotfuncdesc_offset; +}; + /* Arm ELF linker hash entry. */ struct elf32_arm_link_hash_entry { @@ -3025,6 +3245,9 @@ struct elf32_arm_link_hash_entry /* A pointer to the most recently used stub hash entry against this symbol. */ struct elf32_arm_stub_hash_entry *stub_cache; + + /* Counter for FDPIC relocations against this symbol. */ + struct fdpic_global fdpic_cnts; }; /* Traverse an arm ELF linker hash table. */ @@ -3182,7 +3405,7 @@ struct elf32_arm_link_hash_table /* Offset in .plt section of tls_arm_trampoline. */ bfd_vma tls_trampoline; - /* Data for R_ARM_TLS_LDM32 relocations. */ + /* Data for R_ARM_TLS_LDM32/R_ARM_TLS_LDM32_FDPIC relocations. */ union { bfd_signed_vma refcount; @@ -3228,8 +3451,25 @@ struct elf32_arm_link_hash_table unsigned int bfd_count; unsigned int top_index; asection **input_list; + + /* True if the target system uses FDPIC. */ + int fdpic_p; + + /* Fixup section. Used for FDPIC. */ + asection *srofixup; }; +/* Add an FDPIC read-only fixup. */ +static void +arm_elf_add_rofixup (bfd *output_bfd, asection *srofixup, bfd_vma offset) +{ + bfd_vma fixup_offset; + + fixup_offset = srofixup->reloc_count++ * 4; + BFD_ASSERT (fixup_offset < srofixup->size); + bfd_put_32 (output_bfd, offset, srofixup->contents + fixup_offset); +} + static inline int ctz (unsigned int mask) { @@ -3267,6 +3507,57 @@ elf32_arm_popcount (unsigned int mask) #endif } +static void elf32_arm_add_dynreloc (bfd *output_bfd, struct bfd_link_info *info, + asection *sreloc, Elf_Internal_Rela *rel); + +static void +arm_elf_fill_funcdesc(bfd *output_bfd, + struct bfd_link_info *info, + int *funcdesc_offset, + int dynindx, + int offset, + bfd_vma addr, + bfd_vma dynreloc_value, + bfd_vma seg) +{ + if ((*funcdesc_offset & 1) == 0) + { + struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info); + asection *sgot = globals->root.sgot; + + if (bfd_link_pic(info)) + { + asection *srelgot = globals->root.srelgot; + Elf_Internal_Rela outrel; + + outrel.r_info = ELF32_R_INFO (dynindx, R_ARM_FUNCDESC_VALUE); + outrel.r_offset = sgot->output_section->vma + sgot->output_offset + offset; + outrel.r_addend = 0; + + elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel); + bfd_put_32 (output_bfd, addr, sgot->contents + offset); + bfd_put_32 (output_bfd, seg, sgot->contents + offset + 4); + } + else + { + struct elf_link_hash_entry *hgot = globals->root.hgot; + bfd_vma got_value = hgot->root.u.def.value + + hgot->root.u.def.section->output_section->vma + + hgot->root.u.def.section->output_offset; + + arm_elf_add_rofixup(output_bfd, globals->srofixup, + sgot->output_section->vma + sgot->output_offset + + offset); + arm_elf_add_rofixup(output_bfd, globals->srofixup, + sgot->output_section->vma + sgot->output_offset + + offset + 4); + bfd_put_32 (output_bfd, dynreloc_value, sgot->contents + offset); + bfd_put_32 (output_bfd, got_value, sgot->contents + offset + 4); + } + *funcdesc_offset |= 1; + } +} + /* Create an entry in an ARM ELF linker hash table. */ static struct bfd_hash_entry * @@ -3302,6 +3593,12 @@ elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry, ret->export_glue = NULL; ret->stub_cache = NULL; + + ret->fdpic_cnts.gotofffuncdesc_cnt = 0; + ret->fdpic_cnts.gotfuncdesc_cnt = 0; + ret->fdpic_cnts.funcdesc_cnt = 0; + ret->fdpic_cnts.funcdesc_offset = -1; + ret->fdpic_cnts.gotfuncdesc_offset = -1; } return (struct bfd_hash_entry *) ret; @@ -3323,11 +3620,15 @@ elf32_arm_allocate_local_sym_info (bfd *abfd) size = num_syms * (sizeof (bfd_signed_vma) + sizeof (struct arm_local_iplt_info *) + sizeof (bfd_vma) - + sizeof (char)); + + sizeof (char) + + sizeof (struct fdpic_local)); data = bfd_zalloc (abfd, size); if (data == NULL) return FALSE; + elf32_arm_local_fdpic_cnts (abfd) = (struct fdpic_local *) data; + data += num_syms * sizeof (struct fdpic_local); + elf_local_got_refcounts (abfd) = (bfd_signed_vma *) data; data += num_syms * sizeof (bfd_signed_vma); @@ -3399,6 +3700,8 @@ elf32_arm_get_plt_info (bfd *abfd, struct elf32_arm_link_hash_table *globals, return TRUE; } +static bfd_boolean using_thumb_only (struct elf32_arm_link_hash_table *globals); + /* Return true if the PLT described by ARM_PLT requires a Thumb stub before it. */ @@ -3409,8 +3712,9 @@ elf32_arm_plt_needs_thumb_stub_p (struct bfd_link_info *info, struct elf32_arm_link_hash_table *htab; htab = elf32_arm_hash_table (info); - return (arm_plt->thumb_refcount != 0 - || (!htab->use_blx && arm_plt->maybe_thumb_refcount != 0)); + + return (!using_thumb_only(htab) && (arm_plt->thumb_refcount != 0 + || (!htab->use_blx && arm_plt->maybe_thumb_refcount != 0))); } /* Return a pointer to the head of the dynamic reloc list that should @@ -3509,6 +3813,17 @@ create_got_section (bfd *dynobj, struct bfd_link_info *info) if (! _bfd_elf_create_got_section (dynobj, info)) return FALSE; + /* Also create .rofixup. */ + if (htab->fdpic_p) + { + htab->srofixup = bfd_make_section_with_flags (dynobj, ".rofixup", + (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS + | SEC_IN_MEMORY | SEC_LINKER_CREATED | SEC_READONLY)); + if (htab->srofixup == NULL + || !bfd_set_section_alignment (htab->srofixup, 2)) + return FALSE; + } + return TRUE; } @@ -3533,7 +3848,7 @@ create_ifunc_sections (struct bfd_link_info *info) s = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags | SEC_READONLY | SEC_CODE); if (s == NULL - || !bfd_set_section_alignment (dynobj, s, bed->plt_alignment)) + || !bfd_set_section_alignment (s, bed->plt_alignment)) return FALSE; htab->root.iplt = s; } @@ -3544,7 +3859,7 @@ create_ifunc_sections (struct bfd_link_info *info) RELOC_SECTION (htab, ".iplt"), flags | SEC_READONLY); if (s == NULL - || !bfd_set_section_alignment (dynobj, s, bed->s->log_file_align)) + || !bfd_set_section_alignment (s, bed->s->log_file_align)) return FALSE; htab->root.irelplt = s; } @@ -3553,7 +3868,7 @@ create_ifunc_sections (struct bfd_link_info *info) { s = bfd_make_section_anyway_with_flags (dynobj, ".igot.plt", flags); if (s == NULL - || !bfd_set_section_alignment (dynobj, s, bed->s->log_file_align)) + || !bfd_set_section_alignment (s, bed->s->log_file_align)) return FALSE; htab->root.igotplt = s; } @@ -3575,13 +3890,14 @@ using_thumb_only (struct elf32_arm_link_hash_table *globals) arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC, Tag_CPU_arch); /* Force return logic to be reviewed for each new architecture. */ - BFD_ASSERT (arch <= TAG_CPU_ARCH_V8M_MAIN); + BFD_ASSERT (arch <= TAG_CPU_ARCH_V8_1M_MAIN); if (arch == TAG_CPU_ARCH_V6_M || arch == TAG_CPU_ARCH_V6S_M || arch == TAG_CPU_ARCH_V7E_M || arch == TAG_CPU_ARCH_V8M_BASE - || arch == TAG_CPU_ARCH_V8M_MAIN) + || arch == TAG_CPU_ARCH_V8M_MAIN + || arch == TAG_CPU_ARCH_V8_1M_MAIN) return TRUE; return FALSE; @@ -3602,14 +3918,15 @@ using_thumb2 (struct elf32_arm_link_hash_table *globals) arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC, Tag_CPU_arch); /* Force return logic to be reviewed for each new architecture. */ - BFD_ASSERT (arch <= TAG_CPU_ARCH_V8M_MAIN); + BFD_ASSERT (arch <= TAG_CPU_ARCH_V8_1M_MAIN); return (arch == TAG_CPU_ARCH_V6T2 || arch == TAG_CPU_ARCH_V7 || arch == TAG_CPU_ARCH_V7E_M || arch == TAG_CPU_ARCH_V8 || arch == TAG_CPU_ARCH_V8R - || arch == TAG_CPU_ARCH_V8M_MAIN); + || arch == TAG_CPU_ARCH_V8M_MAIN + || arch == TAG_CPU_ARCH_V8_1M_MAIN); } /* Determine whether Thumb-2 BL instruction is available. */ @@ -3621,7 +3938,7 @@ using_thumb2_bl (struct elf32_arm_link_hash_table *globals) bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC, Tag_CPU_arch); /* Force return logic to be reviewed for each new architecture. */ - BFD_ASSERT (arch <= TAG_CPU_ARCH_V8M_MAIN); + BFD_ASSERT (arch <= TAG_CPU_ARCH_V8_1M_MAIN); /* Architecture was introduced after ARMv6T2 (eg. ARMv6-M). */ return (arch == TAG_CPU_ARCH_V6T2 @@ -3686,6 +4003,14 @@ elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info) htab->obfd = saved_obfd; } + if (htab->fdpic_p) { + htab->plt_header_size = 0; + if (info->flags & DF_BIND_NOW) + htab->plt_entry_size = 4 * (ARRAY_SIZE(elf32_arm_fdpic_plt_entry) - 5); + else + htab->plt_entry_size = 4 * ARRAY_SIZE(elf32_arm_fdpic_plt_entry); + } + if (!htab->root.splt || !htab->root.srelplt || !htab->root.sdynbss @@ -3748,6 +4073,11 @@ elf32_arm_copy_indirect_symbol (struct bfd_link_info *info, edir->plt.noncall_refcount += eind->plt.noncall_refcount; eind->plt.noncall_refcount = 0; + /* Copy FDPIC counters. */ + edir->fdpic_cnts.gotofffuncdesc_cnt += eind->fdpic_cnts.gotofffuncdesc_cnt; + edir->fdpic_cnts.gotfuncdesc_cnt += eind->fdpic_cnts.gotfuncdesc_cnt; + edir->fdpic_cnts.funcdesc_cnt += eind->fdpic_cnts.funcdesc_cnt; + /* We should only allocate a function to .iplt once the final symbol information is known. */ BFD_ASSERT (!eind->is_iplt); @@ -3780,7 +4110,7 @@ static struct bfd_link_hash_table * elf32_arm_link_hash_table_create (bfd *abfd) { struct elf32_arm_link_hash_table *ret; - bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table); + size_t amt = sizeof (struct elf32_arm_link_hash_table); ret = (struct elf32_arm_link_hash_table *) bfd_zmalloc (amt); if (ret == NULL) @@ -3806,6 +4136,7 @@ elf32_arm_link_hash_table_create (bfd *abfd) #endif ret->use_rel = TRUE; ret->obfd = abfd; + ret->fdpic_p = 0; if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc, sizeof (struct elf32_arm_stub_hash_entry))) @@ -3827,7 +4158,7 @@ arch_has_arm_nop (struct elf32_arm_link_hash_table *globals) Tag_CPU_arch); /* Force return logic to be reviewed for each new architecture. */ - BFD_ASSERT (arch <= TAG_CPU_ARCH_V8M_MAIN); + BFD_ASSERT (arch <= TAG_CPU_ARCH_V8_1M_MAIN); return (arch == TAG_CPU_ARCH_V6T2 || arch == TAG_CPU_ARCH_V6K @@ -4264,6 +4595,27 @@ elf32_arm_get_stub_entry (const asection *input_section, if ((input_section->flags & SEC_CODE) == 0) return NULL; + /* If the input section is the CMSE stubs one and it needs a long + branch stub to reach it's final destination, give up with an + error message: this is not supported. See PR ld/24709. */ + if (!strncmp (input_section->name, CMSE_STUB_NAME, strlen(CMSE_STUB_NAME))) + { + bfd *output_bfd = htab->obfd; + asection *out_sec = bfd_get_section_by_name (output_bfd, CMSE_STUB_NAME); + + _bfd_error_handler (_("ERROR: CMSE stub (%s section) too far " + "(%#" PRIx64 ") from destination (%#" PRIx64 ")"), + CMSE_STUB_NAME, + (uint64_t)out_sec->output_section->vma + + out_sec->output_offset, + (uint64_t)sym_sec->output_section->vma + + sym_sec->output_offset + + h->root.root.u.def.value); + /* Exit, rather than leave incompletely processed + relocations. */ + xexit(1); + } + /* If this input section is part of a group of sections sharing one stub section, then use the id of the first section in the group. Stub names need to include a section id, as there may well be @@ -4357,7 +4709,7 @@ arm_dedicated_stub_output_section_name (enum elf32_arm_stub_type stub_type) switch (stub_type) { case arm_stub_cmse_branch_thumb_only: - return ".gnu.sgstubs"; + return CMSE_STUB_NAME; default: BFD_ASSERT (!arm_dedicated_stub_output_section_required (stub_type)); @@ -4562,7 +4914,7 @@ elf32_arm_tls_transition (struct bfd_link_info *info, int r_type, { int is_local = (h == NULL); - if (bfd_link_pic (info) + if (bfd_link_dll (info) || (h && h->root.type == bfd_link_hash_undefweak)) return r_type; @@ -4712,6 +5064,14 @@ arm_build_one_stub (struct bfd_hash_entry *gen_entry, stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry; info = (struct bfd_link_info *) in_arg; + /* Fail if the target section could not be assigned to an output + section. The user should fix his linker script. */ + if (stub_entry->target_section->output_section == NULL + && info->non_contiguous_regions) + info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. " + "Retry without --enable-non-contiguous-regions.\n"), + stub_entry->target_section); + globals = elf32_arm_hash_table (info); if (globals == NULL) return FALSE; @@ -4952,7 +5312,7 @@ elf32_arm_setup_section_lists (bfd *output_bfd, unsigned int top_id, top_index; asection *section; asection **input_list, **list; - bfd_size_type amt; + size_t amt; struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info); if (htab == NULL) @@ -5653,12 +6013,12 @@ cmse_scan (bfd *input_bfd, struct elf32_arm_link_hash_table *htab, if (i < ext_start) { cmse_sym = &local_syms[i]; - /* Not a special symbol. */ - if (!ARM_GET_SYM_CMSE_SPCL (cmse_sym->st_target_internal)) - continue; sym_name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, cmse_sym->st_name); + if (!sym_name || !CONST_STRNEQ (sym_name, CMSE_PREFIX)) + continue; + /* Special symbol with local binding. */ cmse_invalid = TRUE; } @@ -5666,9 +6026,7 @@ cmse_scan (bfd *input_bfd, struct elf32_arm_link_hash_table *htab, { cmse_hash = elf32_arm_hash_entry (sym_hashes[i - ext_start]); sym_name = (char *) cmse_hash->root.root.root.string; - - /* Not a special symbol. */ - if (!ARM_GET_SYM_CMSE_SPCL (cmse_hash->root.target_internal)) + if (!CONST_STRNEQ (sym_name, CMSE_PREFIX)) continue; /* Special symbol has incorrect binding or type. */ @@ -5905,7 +6263,10 @@ set_cmse_veneer_addr_from_implib (struct bfd_link_info *info, return FALSE; /* Read in the input secure gateway import library's symbol table. */ - sympp = (asymbol **) xmalloc (symsize); + sympp = (asymbol **) bfd_malloc (symsize); + if (sympp == NULL) + return FALSE; + symcount = bfd_canonicalize_symtab (in_implib_bfd, sympp); if (symcount < 0) { @@ -6062,7 +6423,7 @@ set_cmse_veneer_addr_from_implib (struct bfd_link_info *info, ret = FALSE; } -free_sym_buf: + free_sym_buf: free (sympp); return ret; } @@ -6176,6 +6537,10 @@ elf32_arm_size_stubs (bfd *output_bfd, if (!is_arm_elf (input_bfd)) continue; + if ((input_bfd->flags & DYNAMIC) != 0 + && (elf_sym_hashes (input_bfd) == NULL + || (elf_dyn_lib_class (input_bfd) & DYN_AS_NEEDED) != 0)) + continue; num_a8_relocs = 0; @@ -6791,7 +7156,6 @@ find_arm_glue (struct bfd_link_info *link_info, tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1); - BFD_ASSERT (tmp_name); sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name); @@ -6902,7 +7266,7 @@ arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * na s = bfd_get_linker_section (abfd, name); BFD_ASSERT (s != NULL); - contents = (bfd_byte *) bfd_alloc (abfd, size); + contents = (bfd_byte *) bfd_zalloc (abfd, size); BFD_ASSERT (s->size == size); s->contents = contents; @@ -6966,7 +7330,6 @@ record_arm_to_thumb_glue (struct bfd_link_info * link_info, tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1); - BFD_ASSERT (tmp_name); sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name); @@ -7044,7 +7407,6 @@ record_arm_bx_glue (struct bfd_link_info * link_info, int reg) /* Add symbol for veneer. */ tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1); - BFD_ASSERT (tmp_name); sprintf (tmp_name, ARM_BX_GLUE_ENTRY_NAME, reg); @@ -7136,7 +7498,6 @@ record_vfp11_erratum_veneer (struct bfd_link_info *link_info, tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10); - BFD_ASSERT (tmp_name); sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME, @@ -7256,7 +7617,6 @@ record_stm32l4xx_erratum_veneer (struct bfd_link_info *link_info, tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (STM32L4XX_ERRATUM_VENEER_ENTRY_NAME) + 10); - BFD_ASSERT (tmp_name); sprintf (tmp_name, STM32L4XX_ERRATUM_VENEER_ENTRY_NAME, @@ -7361,7 +7721,7 @@ arm_make_glue_section (bfd * abfd, const char * name) sec = bfd_make_section_anyway_with_flags (abfd, name, ARM_GLUE_SECTION_FLAGS); if (sec == NULL - || !bfd_set_section_alignment (abfd, sec, 2)) + || !bfd_set_section_alignment (sec, 2)) return FALSE; /* Set the gc mark to prevent the section from being removed by garbage @@ -7639,7 +7999,7 @@ bfd_elf32_arm_process_before_allocation (bfd *abfd, return TRUE; -error_return: + error_return: if (contents != NULL && elf_section_data (sec)->this_hdr.contents != contents) free (contents); @@ -8149,14 +8509,14 @@ bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info) { unsigned int next_i = i + 4; unsigned int insn = bfd_big_endian (abfd) - ? (contents[i] << 24) - | (contents[i + 1] << 16) - | (contents[i + 2] << 8) - | contents[i + 3] - : (contents[i + 3] << 24) - | (contents[i + 2] << 16) - | (contents[i + 1] << 8) - | contents[i]; + ? (((unsigned) contents[i] << 24) + | (contents[i + 1] << 16) + | (contents[i + 2] << 8) + | contents[i + 3]) + : (((unsigned) contents[i + 3] << 24) + | (contents[i + 2] << 16) + | (contents[i + 1] << 8) + | contents[i]); unsigned int writemask = 0; enum bfd_arm_vfp11_pipe vpipe; @@ -8255,7 +8615,7 @@ bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info) return TRUE; -error_return: + error_return: if (contents != NULL && elf_section_data (sec)->this_hdr.contents != contents) free (contents); @@ -8287,6 +8647,7 @@ bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd, tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10); + BFD_ASSERT (tmp_name); for (sec = abfd->sections; sec != NULL; sec = sec->next) { @@ -8374,6 +8735,7 @@ bfd_elf32_arm_stm32l4xx_fix_veneer_locations (bfd *abfd, tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (STM32L4XX_ERRATUM_VENEER_ENTRY_NAME) + 10); + BFD_ASSERT (tmp_name); for (sec = abfd->sections; sec != NULL; sec = sec->next) { @@ -8690,7 +9052,7 @@ bfd_elf32_arm_stm32l4xx_erratum_scan (bfd *abfd, return TRUE; -error_return: + error_return: if (contents != NULL && elf_section_data (sec)->this_hdr.contents != contents) free (contents); @@ -8712,7 +9074,9 @@ bfd_elf32_arm_set_target_params (struct bfd *output_bfd, return; globals->target1_is_rel = params->target1_is_rel; - if (strcmp (params->target2_type, "rel") == 0) + if (globals->fdpic_p) + globals->target2_reloc = R_ARM_GOT32; + else if (strcmp (params->target2_type, "rel") == 0) globals->target2_reloc = R_ARM_REL32; else if (strcmp (params->target2_type, "abs") == 0) globals->target2_reloc = R_ARM_ABS32; @@ -8727,7 +9091,10 @@ bfd_elf32_arm_set_target_params (struct bfd *output_bfd, globals->use_blx |= params->use_blx; globals->vfp11_fix = params->vfp11_denorm_fix; globals->stm32l4xx_fix = params->stm32l4xx_fix; - globals->pic_veneer = params->pic_veneer; + if (globals->fdpic_p) + globals->pic_veneer = 1; + else + globals->pic_veneer = params->pic_veneer; globals->fix_cortex_a8 = params->fix_cortex_a8; globals->fix_arm1176 = params->fix_arm1176; globals->cmse_implib = params->cmse_implib; @@ -9213,8 +9580,22 @@ elf32_arm_allocate_plt_entry (struct bfd_link_info *info, splt = htab->root.splt; sgotplt = htab->root.sgotplt; - /* Allocate room for an R_JUMP_SLOT relocation in .rel.plt. */ - elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1); + if (htab->fdpic_p) + { + /* Allocate room for R_ARM_FUNCDESC_VALUE. */ + /* For lazy binding, relocations will be put into .rel.plt, in + .rel.got otherwise. */ + /* FIXME: today we don't support lazy binding so put it in .rel.got */ + if (info->flags & DF_BIND_NOW) + elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1); + else + elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1); + } + else + { + /* Allocate room for an R_JUMP_SLOT relocation in .rel.plt. */ + elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1); + } /* If this is the first .plt entry, make room for the special first entry. */ @@ -9238,7 +9619,11 @@ elf32_arm_allocate_plt_entry (struct bfd_link_info *info, arm_plt->got_offset = sgotplt->size; else arm_plt->got_offset = sgotplt->size - 8 * htab->num_tls_desc; - sgotplt->size += 4; + if (htab->fdpic_p) + /* Function descriptor takes 64 bits in GOT. */ + sgotplt->size += 8; + else + sgotplt->size += 4; } } @@ -9347,7 +9732,11 @@ elf32_arm_populate_plt_entry (bfd *output_bfd, struct bfd_link_info *info, in all the symbols for which we are making plt entries. After the reserved .got.plt entries, all symbols appear in the same order as in .plt. */ - plt_index = (got_offset - got_header_size) / 4; + if (htab->fdpic_p) + /* Function descriptor takes 8 bytes. */ + plt_index = (got_offset - got_header_size) / 8; + else + plt_index = (got_offset - got_header_size) / 4; /* Calculate the address of the GOT entry. */ got_address = (sgot->output_section->vma @@ -9455,6 +9844,41 @@ elf32_arm_populate_plt_entry (bfd *output_bfd, struct bfd_link_info *info, | (tail_displacement & 0x00ffffff), ptr + 12); } + else if (htab->fdpic_p) + { + const bfd_vma *plt_entry = using_thumb_only(htab) + ? elf32_arm_fdpic_thumb_plt_entry + : elf32_arm_fdpic_plt_entry; + + /* Fill-up Thumb stub if needed. */ + if (elf32_arm_plt_needs_thumb_stub_p (info, arm_plt)) + { + put_thumb_insn (htab, output_bfd, + elf32_arm_plt_thumb_stub[0], ptr - 4); + put_thumb_insn (htab, output_bfd, + elf32_arm_plt_thumb_stub[1], ptr - 2); + } + /* As we are using 32 bit instructions even for the Thumb + version, we have to use 'put_arm_insn' instead of + 'put_thumb_insn'. */ + put_arm_insn(htab, output_bfd, plt_entry[0], ptr + 0); + put_arm_insn(htab, output_bfd, plt_entry[1], ptr + 4); + put_arm_insn(htab, output_bfd, plt_entry[2], ptr + 8); + put_arm_insn(htab, output_bfd, plt_entry[3], ptr + 12); + bfd_put_32 (output_bfd, got_offset, ptr + 16); + + if (!(info->flags & DF_BIND_NOW)) + { + /* funcdesc_value_reloc_offset. */ + bfd_put_32 (output_bfd, + htab->root.srelplt->reloc_count * RELOC_SIZE (htab), + ptr + 20); + put_arm_insn(htab, output_bfd, plt_entry[6], ptr + 24); + put_arm_insn(htab, output_bfd, plt_entry[7], ptr + 28); + put_arm_insn(htab, output_bfd, plt_entry[8], ptr + 32); + put_arm_insn(htab, output_bfd, plt_entry[9], ptr + 36); + } + } else if (using_thumb_only (htab)) { /* PR ld/16017: Generate thumb only PLT entries. */ @@ -9565,22 +9989,67 @@ elf32_arm_populate_plt_entry (bfd *output_bfd, struct bfd_link_info *info, } else { - rel.r_info = ELF32_R_INFO (dynindx, R_ARM_JUMP_SLOT); - initial_got_entry = (splt->output_section->vma - + splt->output_offset); + /* For FDPIC we will have to resolve a R_ARM_FUNCDESC_VALUE + used by PLT entry. */ + if (htab->fdpic_p) + { + rel.r_info = ELF32_R_INFO (dynindx, R_ARM_FUNCDESC_VALUE); + initial_got_entry = 0; + } + else + { + rel.r_info = ELF32_R_INFO (dynindx, R_ARM_JUMP_SLOT); + initial_got_entry = (splt->output_section->vma + + splt->output_offset); + + /* PR ld/16017 + When thumb only we need to set the LSB for any address that + will be used with an interworking branch instruction. */ + if (using_thumb_only (htab)) + initial_got_entry |= 1; + } } /* Fill in the entry in the global offset table. */ bfd_put_32 (output_bfd, initial_got_entry, sgot->contents + got_offset); + + if (htab->fdpic_p && !(info->flags & DF_BIND_NOW)) + { + /* Setup initial funcdesc value. */ + /* FIXME: we don't support lazy binding because there is a + race condition between both words getting written and + some other thread attempting to read them. The ARM + architecture does not have an atomic 64 bit load/store + instruction that could be used to prevent it; it is + recommended that threaded FDPIC applications run with the + LD_BIND_NOW environment variable set. */ + bfd_put_32(output_bfd, plt_address + 0x18, + sgot->contents + got_offset); + bfd_put_32(output_bfd, -1 /*TODO*/, + sgot->contents + got_offset + 4); + } } if (dynindx == -1) elf32_arm_add_dynreloc (output_bfd, info, srel, &rel); else { - loc = srel->contents + plt_index * RELOC_SIZE (htab); - SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc); + if (htab->fdpic_p) + { + /* For FDPIC we put PLT relocationss into .rel.got when not + lazy binding otherwise we put them in .rel.plt. For now, + we don't support lazy binding so put it in .rel.got. */ + if (info->flags & DF_BIND_NOW) + elf32_arm_add_dynreloc(output_bfd, info, htab->root.srelgot, &rel); + else + elf32_arm_add_dynreloc(output_bfd, info, htab->root.srelplt, &rel); + } + else + { + loc = srel->contents + plt_index * RELOC_SIZE (htab); + SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc); + } } return TRUE; @@ -10086,7 +10555,8 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, relocations are copied into the output file to be resolved at run time. */ if ((bfd_link_pic (info) - || globals->root.is_relocatable_executable) + || globals->root.is_relocatable_executable + || globals->fdpic_p) && (input_section->flags & SEC_ALLOC) && !(globals->vxworks_p && strcmp (input_section->output_section->name, @@ -10107,6 +10577,7 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, { Elf_Internal_Rela outrel; bfd_boolean skip, relocate; + int isrofixup = 0; if ((r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI) && !h->def_regular) @@ -10162,7 +10633,8 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, int symbol; /* This symbol is local, or marked to become local. */ - BFD_ASSERT (r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI); + BFD_ASSERT (r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI + || (globals->fdpic_p && !bfd_link_pic(info))); if (globals->symbian_p) { asection *osec; @@ -10208,6 +10680,8 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, must use an R_ARM_IRELATIVE relocation to obtain the correct run-time address. */ outrel.r_info = ELF32_R_INFO (symbol, R_ARM_IRELATIVE); + else if (globals->fdpic_p && !bfd_link_pic(info)) + isrofixup = 1; else outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE); if (globals->use_rel) @@ -10216,7 +10690,10 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, outrel.r_addend += dynreloc_value; } - elf32_arm_add_dynreloc (output_bfd, info, sreloc, &outrel); + if (isrofixup) + arm_elf_add_rofixup(output_bfd, globals->srofixup, outrel.r_offset); + else + elf32_arm_add_dynreloc (output_bfd, info, sreloc, &outrel); /* If this reloc is against an external symbol, we do not want to fiddle with the addend. Otherwise, we need to include the symbol @@ -10520,7 +10997,7 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, /* PR 21523: Use an absolute value. The user of this reloc will have already selected an ADD or SUB insn appropriately. */ - value = labs (relocation); + value = llabs (relocation); if (value >= 0x1000) return bfd_reloc_overflow; @@ -11092,8 +11569,10 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, else { Elf_Internal_Rela outrel; + int isrofixup = 0; - if (h->dynindx != -1 && !SYMBOL_REFERENCES_LOCAL (info, h)) + if (((h->dynindx != -1) || globals->fdpic_p) + && !SYMBOL_REFERENCES_LOCAL (info, h)) { /* If the symbol doesn't resolve locally in a static object, we have an undefined reference. If the @@ -11113,31 +11592,41 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, if (dynreloc_st_type == STT_GNU_IFUNC) outrel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE); else if (bfd_link_pic (info) - && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT - || h->root.type != bfd_link_hash_undefweak)) + && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); else - outrel.r_info = 0; + { + outrel.r_info = 0; + if (globals->fdpic_p) + isrofixup = 1; + } outrel.r_addend = dynreloc_value; } /* The GOT entry is initialized to zero by default. See if we should install a different value. */ if (outrel.r_addend != 0 - && (outrel.r_info == 0 || globals->use_rel)) + && (globals->use_rel || outrel.r_info == 0)) { bfd_put_32 (output_bfd, outrel.r_addend, sgot->contents + off); outrel.r_addend = 0; } - if (outrel.r_info != 0) + if (isrofixup) + arm_elf_add_rofixup (output_bfd, + elf32_arm_hash_table(info)->srofixup, + sgot->output_section->vma + + sgot->output_offset + off); + + else if (outrel.r_info != 0) { outrel.r_offset = (sgot->output_section->vma + sgot->output_offset + off); elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel); } + h->got.offset |= 1; } value = sgot->output_offset + off; @@ -11158,21 +11647,37 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, off &= ~1; else { - if (globals->use_rel) - bfd_put_32 (output_bfd, dynreloc_value, sgot->contents + off); + Elf_Internal_Rela outrel; + int isrofixup = 0; - if (bfd_link_pic (info) || dynreloc_st_type == STT_GNU_IFUNC) + if (dynreloc_st_type == STT_GNU_IFUNC) + outrel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE); + else if (bfd_link_pic (info)) + outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); + else { - Elf_Internal_Rela outrel; + outrel.r_info = 0; + if (globals->fdpic_p) + isrofixup = 1; + } + + /* The GOT entry is initialized to zero by default. + See if we should install a different value. */ + if (globals->use_rel || outrel.r_info == 0) + bfd_put_32 (output_bfd, dynreloc_value, sgot->contents + off); + + if (isrofixup) + arm_elf_add_rofixup (output_bfd, + globals->srofixup, + sgot->output_section->vma + + sgot->output_offset + off); + else if (outrel.r_info != 0) + { outrel.r_addend = addend + dynreloc_value; outrel.r_offset = (sgot->output_section->vma + sgot->output_offset + off); - if (dynreloc_st_type == STT_GNU_IFUNC) - outrel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE); - else - outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel); } @@ -11196,6 +11701,7 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, rel->r_addend); case R_ARM_TLS_LDM32: + case R_ARM_TLS_LDM32_FDPIC: { bfd_vma off; @@ -11210,7 +11716,7 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, { /* If we don't know the module number, create a relocation for it. */ - if (bfd_link_pic (info)) + if (bfd_link_dll (info)) { Elf_Internal_Rela outrel; @@ -11234,18 +11740,32 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, globals->tls_ldm_got.offset |= 1; } - value = sgot->output_section->vma + sgot->output_offset + off - - (input_section->output_section->vma + input_section->output_offset + rel->r_offset); + if (r_type == R_ARM_TLS_LDM32_FDPIC) + { + bfd_put_32(output_bfd, + globals->root.sgot->output_offset + off, + contents + rel->r_offset); + + return bfd_reloc_ok; + } + else + { + value = sgot->output_section->vma + sgot->output_offset + off + - (input_section->output_section->vma + + input_section->output_offset + rel->r_offset); - return _bfd_final_link_relocate (howto, input_bfd, input_section, - contents, rel->r_offset, value, - rel->r_addend); + return _bfd_final_link_relocate (howto, input_bfd, input_section, + contents, rel->r_offset, value, + rel->r_addend); + } } case R_ARM_TLS_CALL: case R_ARM_THM_TLS_CALL: case R_ARM_TLS_GD32: + case R_ARM_TLS_GD32_FDPIC: case R_ARM_TLS_IE32: + case R_ARM_TLS_IE32_FDPIC: case R_ARM_TLS_GOTDESC: case R_ARM_TLS_DESCSEQ: case R_ARM_THM_TLS_DESCSEQ: @@ -11300,7 +11820,7 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, now, and emit any relocations. If both an IE GOT and a GD GOT are necessary, we emit the GD first. */ - if ((bfd_link_pic (info) || indx != 0) + if ((bfd_link_dll (info) || indx != 0) && (h == NULL || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT && !resolved_to_zero) @@ -11317,7 +11837,7 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, /* We should have relaxed, unless this is an undefined weak symbol. */ BFD_ASSERT ((h && (h->root.type == bfd_link_hash_undefweak)) - || bfd_link_pic (info)); + || bfd_link_dll (info)); BFD_ASSERT (globals->sgotplt_jump_table_size + offplt + 8 <= globals->root.sgotplt->size); @@ -11433,7 +11953,7 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, local_got_offsets[r_symndx] |= 1; } - if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32) + if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32 && r_type != R_ARM_TLS_GD32_FDPIC) off += 8; else if (tls_type & GOT_TLS_GDESC) off = offplt; @@ -11523,9 +12043,9 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, unsigned long data, insn; unsigned thumb; - data = bfd_get_32 (input_bfd, hit_data); + data = bfd_get_signed_32 (input_bfd, hit_data); thumb = data & 1; - data &= ~1u; + data &= ~1ul; if (thumb) { @@ -11592,9 +12112,23 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, - (input_section->output_section->vma + input_section->output_offset + rel->r_offset)); - return _bfd_final_link_relocate (howto, input_bfd, input_section, - contents, rel->r_offset, value, - rel->r_addend); + if (globals->fdpic_p && (r_type == R_ARM_TLS_GD32_FDPIC || + r_type == R_ARM_TLS_IE32_FDPIC)) + { + /* For FDPIC relocations, resolve to the offset of the GOT + entry from the start of GOT. */ + bfd_put_32(output_bfd, + globals->root.sgot->output_offset + off, + contents + rel->r_offset); + + return bfd_reloc_ok; + } + else + { + return _bfd_final_link_relocate (howto, input_bfd, input_section, + contents, rel->r_offset, value, + rel->r_addend); + } } case R_ARM_TLS_LE32: @@ -12176,18 +12710,379 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, *unresolved_reloc_p = FALSE; return bfd_reloc_ok; - default: - return bfd_reloc_notsupported; - } -} + case R_ARM_GOTOFFFUNCDESC: + { + if (h == NULL) + { + struct fdpic_local *local_fdpic_cnts = elf32_arm_local_fdpic_cnts(input_bfd); + int dynindx = elf_section_data (sym_sec->output_section)->dynindx; + int offset = local_fdpic_cnts[r_symndx].funcdesc_offset & ~1; + bfd_vma addr = dynreloc_value - sym_sec->output_section->vma; + bfd_vma seg = -1; + + if (bfd_link_pic(info) && dynindx == 0) + abort(); + + /* Resolve relocation. */ + bfd_put_32(output_bfd, (offset + sgot->output_offset) + , contents + rel->r_offset); + /* Emit R_ARM_FUNCDESC_VALUE or two fixups on funcdesc if + not done yet. */ + arm_elf_fill_funcdesc(output_bfd, info, + &local_fdpic_cnts[r_symndx].funcdesc_offset, + dynindx, offset, addr, dynreloc_value, seg); + } + else + { + int dynindx; + int offset = eh->fdpic_cnts.funcdesc_offset & ~1; + bfd_vma addr; + bfd_vma seg = -1; -/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */ -static void -arm_add_to_rel (bfd * abfd, - bfd_byte * address, - reloc_howto_type * howto, - bfd_signed_vma increment) -{ + /* For static binaries, sym_sec can be null. */ + if (sym_sec) + { + dynindx = elf_section_data (sym_sec->output_section)->dynindx; + addr = dynreloc_value - sym_sec->output_section->vma; + } + else + { + dynindx = 0; + addr = 0; + } + + if (bfd_link_pic(info) && dynindx == 0) + abort(); + + /* This case cannot occur since funcdesc is allocated by + the dynamic loader so we cannot resolve the relocation. */ + if (h->dynindx != -1) + abort(); + + /* Resolve relocation. */ + bfd_put_32(output_bfd, (offset + sgot->output_offset), + contents + rel->r_offset); + /* Emit R_ARM_FUNCDESC_VALUE on funcdesc if not done yet. */ + arm_elf_fill_funcdesc(output_bfd, info, + &eh->fdpic_cnts.funcdesc_offset, + dynindx, offset, addr, dynreloc_value, seg); + } + } + *unresolved_reloc_p = FALSE; + return bfd_reloc_ok; + + case R_ARM_GOTFUNCDESC: + { + if (h != NULL) + { + Elf_Internal_Rela outrel; + + /* Resolve relocation. */ + bfd_put_32(output_bfd, ((eh->fdpic_cnts.gotfuncdesc_offset & ~1) + + sgot->output_offset), + contents + rel->r_offset); + /* Add funcdesc and associated R_ARM_FUNCDESC_VALUE. */ + if(h->dynindx == -1) + { + int dynindx; + int offset = eh->fdpic_cnts.funcdesc_offset & ~1; + bfd_vma addr; + bfd_vma seg = -1; + + /* For static binaries sym_sec can be null. */ + if (sym_sec) + { + dynindx = elf_section_data (sym_sec->output_section)->dynindx; + addr = dynreloc_value - sym_sec->output_section->vma; + } + else + { + dynindx = 0; + addr = 0; + } + + /* Emit R_ARM_FUNCDESC_VALUE on funcdesc if not done yet. */ + arm_elf_fill_funcdesc(output_bfd, info, + &eh->fdpic_cnts.funcdesc_offset, + dynindx, offset, addr, dynreloc_value, seg); + } + + /* Add a dynamic relocation on GOT entry if not already done. */ + if ((eh->fdpic_cnts.gotfuncdesc_offset & 1) == 0) + { + if (h->dynindx == -1) + { + outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); + if (h->root.type == bfd_link_hash_undefweak) + bfd_put_32(output_bfd, 0, sgot->contents + + (eh->fdpic_cnts.gotfuncdesc_offset & ~1)); + else + bfd_put_32(output_bfd, sgot->output_section->vma + + sgot->output_offset + + (eh->fdpic_cnts.funcdesc_offset & ~1), + sgot->contents + + (eh->fdpic_cnts.gotfuncdesc_offset & ~1)); + } + else + { + outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_FUNCDESC); + } + outrel.r_offset = sgot->output_section->vma + + sgot->output_offset + + (eh->fdpic_cnts.gotfuncdesc_offset & ~1); + outrel.r_addend = 0; + if (h->dynindx == -1 && !bfd_link_pic(info)) + if (h->root.type == bfd_link_hash_undefweak) + arm_elf_add_rofixup(output_bfd, globals->srofixup, -1); + else + arm_elf_add_rofixup(output_bfd, globals->srofixup, + outrel.r_offset); + else + elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel); + eh->fdpic_cnts.gotfuncdesc_offset |= 1; + } + } + else + { + /* Such relocation on static function should not have been + emitted by the compiler. */ + abort(); + } + } + *unresolved_reloc_p = FALSE; + return bfd_reloc_ok; + + case R_ARM_FUNCDESC: + { + if (h == NULL) + { + struct fdpic_local *local_fdpic_cnts = elf32_arm_local_fdpic_cnts(input_bfd); + Elf_Internal_Rela outrel; + int dynindx = elf_section_data (sym_sec->output_section)->dynindx; + int offset = local_fdpic_cnts[r_symndx].funcdesc_offset & ~1; + bfd_vma addr = dynreloc_value - sym_sec->output_section->vma; + bfd_vma seg = -1; + + if (bfd_link_pic(info) && dynindx == 0) + abort(); + + /* Replace static FUNCDESC relocation with a + R_ARM_RELATIVE dynamic relocation or with a rofixup for + executable. */ + outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); + outrel.r_offset = input_section->output_section->vma + + input_section->output_offset + rel->r_offset; + outrel.r_addend = 0; + if (bfd_link_pic(info)) + elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel); + else + arm_elf_add_rofixup(output_bfd, globals->srofixup, outrel.r_offset); + + bfd_put_32 (input_bfd, sgot->output_section->vma + + sgot->output_offset + offset, hit_data); + + /* Emit R_ARM_FUNCDESC_VALUE on funcdesc if not done yet. */ + arm_elf_fill_funcdesc(output_bfd, info, + &local_fdpic_cnts[r_symndx].funcdesc_offset, + dynindx, offset, addr, dynreloc_value, seg); + } + else + { + if (h->dynindx == -1) + { + int dynindx; + int offset = eh->fdpic_cnts.funcdesc_offset & ~1; + bfd_vma addr; + bfd_vma seg = -1; + Elf_Internal_Rela outrel; + + /* For static binaries sym_sec can be null. */ + if (sym_sec) + { + dynindx = elf_section_data (sym_sec->output_section)->dynindx; + addr = dynreloc_value - sym_sec->output_section->vma; + } + else + { + dynindx = 0; + addr = 0; + } + + if (bfd_link_pic(info) && dynindx == 0) + abort(); + + /* Replace static FUNCDESC relocation with a + R_ARM_RELATIVE dynamic relocation. */ + outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); + outrel.r_offset = input_section->output_section->vma + + input_section->output_offset + rel->r_offset; + outrel.r_addend = 0; + if (bfd_link_pic(info)) + elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel); + else + arm_elf_add_rofixup(output_bfd, globals->srofixup, outrel.r_offset); + + bfd_put_32 (input_bfd, sgot->output_section->vma + + sgot->output_offset + offset, hit_data); + + /* Emit R_ARM_FUNCDESC_VALUE on funcdesc if not done yet. */ + arm_elf_fill_funcdesc(output_bfd, info, + &eh->fdpic_cnts.funcdesc_offset, + dynindx, offset, addr, dynreloc_value, seg); + } + else + { + Elf_Internal_Rela outrel; + + /* Add a dynamic relocation. */ + outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_FUNCDESC); + outrel.r_offset = input_section->output_section->vma + + input_section->output_offset + rel->r_offset; + outrel.r_addend = 0; + elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel); + } + } + } + *unresolved_reloc_p = FALSE; + return bfd_reloc_ok; + + case R_ARM_THM_BF16: + { + bfd_vma relocation; + bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data); + bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2); + + if (globals->use_rel) + { + bfd_vma immA = (upper_insn & 0x001f); + bfd_vma immB = (lower_insn & 0x07fe) >> 1; + bfd_vma immC = (lower_insn & 0x0800) >> 11; + addend = (immA << 12); + addend |= (immB << 2); + addend |= (immC << 1); + addend |= 1; + /* Sign extend. */ + signed_addend = (addend & 0x10000) ? addend - (1 << 17) : addend; + } + + relocation = value + signed_addend; + relocation -= (input_section->output_section->vma + + input_section->output_offset + + rel->r_offset); + + /* Put RELOCATION back into the insn. */ + { + bfd_vma immA = (relocation & 0x0001f000) >> 12; + bfd_vma immB = (relocation & 0x00000ffc) >> 2; + bfd_vma immC = (relocation & 0x00000002) >> 1; + + upper_insn = (upper_insn & 0xffe0) | immA; + lower_insn = (lower_insn & 0xf001) | (immC << 11) | (immB << 1); + } + + /* Put the relocated value back in the object file: */ + bfd_put_16 (input_bfd, upper_insn, hit_data); + bfd_put_16 (input_bfd, lower_insn, hit_data + 2); + + return bfd_reloc_ok; + } + + case R_ARM_THM_BF12: + { + bfd_vma relocation; + bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data); + bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2); + + if (globals->use_rel) + { + bfd_vma immA = (upper_insn & 0x0001); + bfd_vma immB = (lower_insn & 0x07fe) >> 1; + bfd_vma immC = (lower_insn & 0x0800) >> 11; + addend = (immA << 12); + addend |= (immB << 2); + addend |= (immC << 1); + addend |= 1; + /* Sign extend. */ + addend = (addend & 0x1000) ? addend - (1 << 13) : addend; + signed_addend = addend; + } + + relocation = value + signed_addend; + relocation -= (input_section->output_section->vma + + input_section->output_offset + + rel->r_offset); + + /* Put RELOCATION back into the insn. */ + { + bfd_vma immA = (relocation & 0x00001000) >> 12; + bfd_vma immB = (relocation & 0x00000ffc) >> 2; + bfd_vma immC = (relocation & 0x00000002) >> 1; + + upper_insn = (upper_insn & 0xfffe) | immA; + lower_insn = (lower_insn & 0xf001) | (immC << 11) | (immB << 1); + } + + /* Put the relocated value back in the object file: */ + bfd_put_16 (input_bfd, upper_insn, hit_data); + bfd_put_16 (input_bfd, lower_insn, hit_data + 2); + + return bfd_reloc_ok; + } + + case R_ARM_THM_BF18: + { + bfd_vma relocation; + bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data); + bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2); + + if (globals->use_rel) + { + bfd_vma immA = (upper_insn & 0x007f); + bfd_vma immB = (lower_insn & 0x07fe) >> 1; + bfd_vma immC = (lower_insn & 0x0800) >> 11; + addend = (immA << 12); + addend |= (immB << 2); + addend |= (immC << 1); + addend |= 1; + /* Sign extend. */ + addend = (addend & 0x40000) ? addend - (1 << 19) : addend; + signed_addend = addend; + } + + relocation = value + signed_addend; + relocation -= (input_section->output_section->vma + + input_section->output_offset + + rel->r_offset); + + /* Put RELOCATION back into the insn. */ + { + bfd_vma immA = (relocation & 0x0007f000) >> 12; + bfd_vma immB = (relocation & 0x00000ffc) >> 2; + bfd_vma immC = (relocation & 0x00000002) >> 1; + + upper_insn = (upper_insn & 0xff80) | immA; + lower_insn = (lower_insn & 0xf001) | (immC << 11) | (immB << 1); + } + + /* Put the relocated value back in the object file: */ + bfd_put_16 (input_bfd, upper_insn, hit_data); + bfd_put_16 (input_bfd, lower_insn, hit_data + 2); + + return bfd_reloc_ok; + } + + default: + return bfd_reloc_notsupported; + } +} + +/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */ +static void +arm_add_to_rel (bfd * abfd, + bfd_byte * address, + reloc_howto_type * howto, + bfd_signed_vma increment) +{ bfd_signed_vma addend; if (howto->type == R_ARM_THM_CALL @@ -12257,13 +13152,16 @@ arm_add_to_rel (bfd * abfd, #define IS_ARM_TLS_RELOC(R_TYPE) \ ((R_TYPE) == R_ARM_TLS_GD32 \ + || (R_TYPE) == R_ARM_TLS_GD32_FDPIC \ || (R_TYPE) == R_ARM_TLS_LDO32 \ || (R_TYPE) == R_ARM_TLS_LDM32 \ + || (R_TYPE) == R_ARM_TLS_LDM32_FDPIC \ || (R_TYPE) == R_ARM_TLS_DTPOFF32 \ || (R_TYPE) == R_ARM_TLS_DTPMOD32 \ || (R_TYPE) == R_ARM_TLS_TPOFF32 \ || (R_TYPE) == R_ARM_TLS_LE32 \ || (R_TYPE) == R_ARM_TLS_IE32 \ + || (R_TYPE) == R_ARM_TLS_IE32_FDPIC \ || IS_ARM_TLS_GNU_RELOC (R_TYPE)) /* Specific set of relocations for the gnu tls dialect. */ @@ -12495,7 +13393,7 @@ elf32_arm_relocate_section (bfd * output_bfd, name = (bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name)); if (name == NULL || *name == '\0') - name = bfd_section_name (input_bfd, sec); + name = bfd_section_name (sec); } if (r_symndx != STN_UNDEF @@ -12673,10 +13571,10 @@ adjust_exidx_size(asection *exidx_sec, int adjust) if (!exidx_sec->rawsize) exidx_sec->rawsize = exidx_sec->size; - bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust); + bfd_set_section_size (exidx_sec, exidx_sec->size + adjust); out_sec = exidx_sec->output_section; /* Adjust size of output section. */ - bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust); + bfd_set_section_size (out_sec, out_sec->size +adjust); } /* Insert an EXIDX_CANTUNWIND marker at the end of a section. */ @@ -12974,6 +13872,7 @@ bfd_arm_get_mach_from_attributes (bfd * abfd) switch (arch) { + case TAG_CPU_ARCH_PRE_V4: return bfd_mach_arm_3M; case TAG_CPU_ARCH_V4: return bfd_mach_arm_4; case TAG_CPU_ARCH_V4T: return bfd_mach_arm_4T; case TAG_CPU_ARCH_V5T: return bfd_mach_arm_5T; @@ -13011,7 +13910,40 @@ bfd_arm_get_mach_from_attributes (bfd * abfd) return bfd_mach_arm_5TE; } + case TAG_CPU_ARCH_V5TEJ: + return bfd_mach_arm_5TEJ; + case TAG_CPU_ARCH_V6: + return bfd_mach_arm_6; + case TAG_CPU_ARCH_V6KZ: + return bfd_mach_arm_6KZ; + case TAG_CPU_ARCH_V6T2: + return bfd_mach_arm_6T2; + case TAG_CPU_ARCH_V6K: + return bfd_mach_arm_6K; + case TAG_CPU_ARCH_V7: + return bfd_mach_arm_7; + case TAG_CPU_ARCH_V6_M: + return bfd_mach_arm_6M; + case TAG_CPU_ARCH_V6S_M: + return bfd_mach_arm_6SM; + case TAG_CPU_ARCH_V7E_M: + return bfd_mach_arm_7EM; + case TAG_CPU_ARCH_V8: + return bfd_mach_arm_8; + case TAG_CPU_ARCH_V8R: + return bfd_mach_arm_8R; + case TAG_CPU_ARCH_V8M_BASE: + return bfd_mach_arm_8M_BASE; + case TAG_CPU_ARCH_V8M_MAIN: + return bfd_mach_arm_8M_MAIN; + case TAG_CPU_ARCH_V8_1M_MAIN: + return bfd_mach_arm_8_1M_MAIN; + default: + /* Force entry to be added for any new known Tag_CPU_arch value. */ + BFD_ASSERT (arch > MAX_TAG_CPU_ARCH); + + /* Unknown Tag_CPU_arch value. */ return bfd_mach_arm_unknown; } } @@ -13418,6 +14350,31 @@ tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out, T(V8M_MAIN), /* V8-M BASELINE. */ T(V8M_MAIN) /* V8-M MAINLINE. */ }; + const int v8_1m_mainline[] = + { + -1, /* PRE_V4. */ + -1, /* V4. */ + -1, /* V4T. */ + -1, /* V5T. */ + -1, /* V5TE. */ + -1, /* V5TEJ. */ + -1, /* V6. */ + -1, /* V6KZ. */ + -1, /* V6T2. */ + -1, /* V6K. */ + T(V8_1M_MAIN), /* V7. */ + T(V8_1M_MAIN), /* V6_M. */ + T(V8_1M_MAIN), /* V6S_M. */ + T(V8_1M_MAIN), /* V7E_M. */ + -1, /* V8. */ + -1, /* V8R. */ + T(V8_1M_MAIN), /* V8-M BASELINE. */ + T(V8_1M_MAIN), /* V8-M MAINLINE. */ + -1, /* Unused (18). */ + -1, /* Unused (19). */ + -1, /* Unused (20). */ + T(V8_1M_MAIN) /* V8.1-M MAINLINE. */ + }; const int v4t_plus_v6_m[] = { -1, /* PRE_V4. */ @@ -13438,6 +14395,10 @@ tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out, -1, /* V8R. */ T(V8M_BASE), /* V8-M BASELINE. */ T(V8M_MAIN), /* V8-M MAINLINE. */ + -1, /* Unused (18). */ + -1, /* Unused (19). */ + -1, /* Unused (20). */ + T(V8_1M_MAIN), /* V8.1-M MAINLINE. */ T(V4T_PLUS_V6_M) /* V4T plus V6_M. */ }; const int *comb[] = @@ -13452,6 +14413,10 @@ tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out, v8r, v8m_baseline, v8m_mainline, + NULL, + NULL, + NULL, + v8_1m_mainline, /* Pseudo-architecture. */ v4t_plus_v6_m }; @@ -13732,6 +14697,7 @@ elf32_arm_merge_eabi_attributes (bfd *ibfd, struct bfd_link_info *info) case Tag_CPU_unaligned_access: case Tag_T2EE_use: case Tag_MPextension_use: + case Tag_MVE_arch: /* Use the largest value specified. */ if (in_attr[i].i > out_attr[i].i) out_attr[i].i = in_attr[i].i; @@ -14276,7 +15242,13 @@ elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr) if (flags & EF_ARM_RELEXEC) fprintf (file, _(" [relocatable executable]")); - flags &= ~EF_ARM_RELEXEC; + if (flags & EF_ARM_PIC) + fprintf (file, _(" [position independent]")); + + if (elf_elfheader (abfd)->e_ident[EI_OSABI] == ELFOSABI_ARM_FDPIC) + fprintf (file, _(" [FDPIC ABI supplement]")); + + flags &= ~ (EF_ARM_RELEXEC | EF_ARM_PIC); if (flags) fprintf (file, _("")); @@ -14432,10 +15404,60 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, r_type = elf32_arm_tls_transition (info, r_type, h); switch (r_type) { + case R_ARM_GOTOFFFUNCDESC: + { + if (h == NULL) + { + if (!elf32_arm_allocate_local_sym_info (abfd)) + return FALSE; + elf32_arm_local_fdpic_cnts(abfd)[r_symndx].gotofffuncdesc_cnt += 1; + elf32_arm_local_fdpic_cnts(abfd)[r_symndx].funcdesc_offset = -1; + } + else + { + eh->fdpic_cnts.gotofffuncdesc_cnt++; + } + } + break; + + case R_ARM_GOTFUNCDESC: + { + if (h == NULL) + { + /* Such a relocation is not supposed to be generated + by gcc on a static function. */ + /* Anyway if needed it could be handled. */ + abort(); + } + else + { + eh->fdpic_cnts.gotfuncdesc_cnt++; + } + } + break; + + case R_ARM_FUNCDESC: + { + if (h == NULL) + { + if (!elf32_arm_allocate_local_sym_info (abfd)) + return FALSE; + elf32_arm_local_fdpic_cnts(abfd)[r_symndx].funcdesc_cnt += 1; + elf32_arm_local_fdpic_cnts(abfd)[r_symndx].funcdesc_offset = -1; + } + else + { + eh->fdpic_cnts.funcdesc_cnt++; + } + } + break; + case R_ARM_GOT32: case R_ARM_GOT_PREL: case R_ARM_TLS_GD32: + case R_ARM_TLS_GD32_FDPIC: case R_ARM_TLS_IE32: + case R_ARM_TLS_IE32_FDPIC: case R_ARM_TLS_GOTDESC: case R_ARM_TLS_DESCSEQ: case R_ARM_THM_TLS_DESCSEQ: @@ -14448,8 +15470,10 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, switch (r_type) { case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break; + case R_ARM_TLS_GD32_FDPIC: tls_type = GOT_TLS_GD; break; case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break; + case R_ARM_TLS_IE32_FDPIC: tls_type = GOT_TLS_IE; break; case R_ARM_TLS_GOTDESC: case R_ARM_TLS_CALL: case R_ARM_THM_TLS_CALL: @@ -14507,7 +15531,8 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, /* Fall through. */ case R_ARM_TLS_LDM32: - if (r_type == R_ARM_TLS_LDM32) + case R_ARM_TLS_LDM32_FDPIC: + if (r_type == R_ARM_TLS_LDM32 || r_type == R_ARM_TLS_LDM32_FDPIC) htab->tls_ldm_got.refcount++; /* Fall through. */ @@ -14573,7 +15598,8 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, case R_ARM_THM_MOVT_PREL: /* Should the interworking branches be listed here? */ - if ((bfd_link_pic (info) || htab->root.is_relocatable_executable) + if ((bfd_link_pic (info) || htab->root.is_relocatable_executable + || htab->fdpic_p) && (sec->flags & SEC_ALLOC) != 0) { if (h == NULL @@ -14607,9 +15633,7 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, /* This relocation describes which C++ vtable entries are actually used. Record for later use during GC. */ case R_ARM_GNU_VTENTRY: - BFD_ASSERT (h != NULL); - if (h != NULL - && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) + if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) return FALSE; break; } @@ -14691,9 +15715,9 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, { flagword flags; - flags = bfd_get_section_flags (dynobj, sreloc); + flags = bfd_section_flags (sreloc); flags &= ~(SEC_LOAD | SEC_ALLOC); - bfd_set_section_flags (dynobj, sreloc, flags); + bfd_set_section_flags (sreloc, flags); } } @@ -14711,7 +15735,7 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, p = *head; if (p == NULL || p->sec != sec) { - bfd_size_type amt = sizeof *p; + size_t amt = sizeof *p; p = (struct elf_dyn_relocs *) bfd_alloc (htab->root.dynobj, amt); if (p == NULL) @@ -14726,6 +15750,18 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, if (elf32_arm_howto_from_type (r_type)->pc_relative) p->pc_count += 1; p->count += 1; + if (h == NULL && htab->fdpic_p && !bfd_link_pic(info) + && r_type != R_ARM_ABS32 && r_type != R_ARM_ABS32_NOI) { + /* Here we only support R_ARM_ABS32 and R_ARM_ABS32_NOI + that will become rofixup. */ + /* This is due to the fact that we suppose all will become rofixup. */ + fprintf(stderr, "FDPIC does not yet support %d relocation to become dynamic for executable\n", r_type); + _bfd_error_handler + (_("FDPIC does not yet support %s relocation" + " to become dynamic for executable"), + elf32_arm_howto_table_1[r_type].name); + abort(); + } } } @@ -14801,7 +15837,7 @@ elf32_arm_update_relocs (asection *o, eadi = get_arm_elf_section_data (i); edit_list = eadi->u.exidx.unwind_edit_list; edit_tail = eadi->u.exidx.unwind_edit_tail; - offset = o->vma + i->output_offset; + offset = i->output_offset; if (eadi->elf.rel.hdr && eadi->elf.rel.hdr->sh_entsize == rel_hdr->sh_entsize) @@ -14914,6 +15950,8 @@ elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info, struct elf_link_hash_entry **sym_hashes; struct elf32_arm_link_hash_entry *cmse_hash; bfd_boolean again, is_v8m, first_bfd_browse = TRUE; + bfd_boolean debug_sec_need_to_be_marked = FALSE; + asection *isec; _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook); @@ -14969,14 +16007,32 @@ elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info, /* Assume it is a special symbol. If not, cmse_scan will warn about it and user can do something about it. */ - if (ARM_GET_SYM_CMSE_SPCL (cmse_hash->root.target_internal)) + if (CONST_STRNEQ (cmse_hash->root.root.root.string, + CMSE_PREFIX)) { cmse_sec = cmse_hash->root.root.u.def.section; if (!cmse_sec->gc_mark && !_bfd_elf_gc_mark (info, cmse_sec, gc_mark_hook)) return FALSE; + /* The debug sections related to these secure entry + functions are marked on enabling below flag. */ + debug_sec_need_to_be_marked = TRUE; } } + + if (debug_sec_need_to_be_marked) + { + /* Looping over all the sections of the object file containing + Armv8-M secure entry functions and marking all the debug + sections. */ + for (isec = sub->sections; isec != NULL; isec = isec->next) + { + /* If not a debug sections, skip it. */ + if (!isec->gc_mark && (isec->flags & SEC_DEBUGGING)) + isec->gc_mark = 1 ; + } + debug_sec_need_to_be_marked = FALSE; + } } } first_bfd_browse = FALSE; @@ -14994,119 +16050,44 @@ elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym) BFD_ARM_SPECIAL_SYM_TYPE_ANY); } -/* This is a copy of elf_find_function() from elf.c except that - ARM mapping symbols are ignored when looking for function names - and STT_ARM_TFUNC is considered to a function type. */ +/* If the ELF symbol SYM might be a function in SEC, return the + function size and set *CODE_OFF to the function's entry point, + otherwise return zero. */ -static bfd_boolean -arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED, - asymbol ** symbols, - asection * section, - bfd_vma offset, - const char ** filename_ptr, - const char ** functionname_ptr) +static bfd_size_type +elf32_arm_maybe_function_sym (const asymbol *sym, asection *sec, + bfd_vma *code_off) { - const char * filename = NULL; - asymbol * func = NULL; - bfd_vma low_func = 0; - asymbol ** p; - - for (p = symbols; *p != NULL; p++) - { - elf_symbol_type *q; + bfd_size_type size; - q = (elf_symbol_type *) *p; + if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT + | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0 + || sym->section != sec) + return 0; - switch (ELF_ST_TYPE (q->internal_elf_sym.st_info)) - { - default: - break; - case STT_FILE: - filename = bfd_asymbol_name (&q->symbol); - break; + if (!(sym->flags & BSF_SYNTHETIC)) + switch (ELF_ST_TYPE (((elf_symbol_type *) sym)->internal_elf_sym.st_info)) + { case STT_FUNC: case STT_ARM_TFUNC: case STT_NOTYPE: - /* Skip mapping symbols. */ - if ((q->symbol.flags & BSF_LOCAL) - && bfd_is_arm_special_symbol_name (q->symbol.name, - BFD_ARM_SPECIAL_SYM_TYPE_ANY)) - continue; - /* Fall through. */ - if (bfd_get_section (&q->symbol) == section - && q->symbol.value >= low_func - && q->symbol.value <= offset) - { - func = (asymbol *) q; - low_func = q->symbol.value; - } break; - } - } - - if (func == NULL) - return FALSE; - - if (filename_ptr) - *filename_ptr = filename; - if (functionname_ptr) - *functionname_ptr = bfd_asymbol_name (func); - - return TRUE; -} - - -/* Find the nearest line to a particular section and offset, for error - reporting. This code is a duplicate of the code in elf.c, except - that it uses arm_elf_find_function. */ - -static bfd_boolean -elf32_arm_find_nearest_line (bfd * abfd, - asymbol ** symbols, - asection * section, - bfd_vma offset, - const char ** filename_ptr, - const char ** functionname_ptr, - unsigned int * line_ptr, - unsigned int * discriminator_ptr) -{ - bfd_boolean found = FALSE; - - if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset, - filename_ptr, functionname_ptr, - line_ptr, discriminator_ptr, - dwarf_debug_sections, 0, - & elf_tdata (abfd)->dwarf2_find_line_info)) - { - if (!*functionname_ptr) - arm_elf_find_function (abfd, symbols, section, offset, - *filename_ptr ? NULL : filename_ptr, - functionname_ptr); - - return TRUE; - } - - /* Skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain - uses DWARF1. */ - - if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, - & found, filename_ptr, - functionname_ptr, line_ptr, - & elf_tdata (abfd)->line_info)) - return FALSE; - - if (found && (*functionname_ptr || *line_ptr)) - return TRUE; - - if (symbols == NULL) - return FALSE; + default: + return 0; + } - if (! arm_elf_find_function (abfd, symbols, section, offset, - filename_ptr, functionname_ptr)) - return FALSE; + if ((sym->flags & BSF_LOCAL) + && bfd_is_arm_special_symbol_name (sym->name, + BFD_ARM_SPECIAL_SYM_TYPE_ANY)) + return 0; - *line_ptr = 0; - return TRUE; + *code_off = sym->value; + size = 0; + if (!(sym->flags & BSF_SYNTHETIC)) + size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size; + if (size == 0) + size = 1; + return size; } static bfd_boolean @@ -15388,7 +16369,7 @@ allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf) /* Make sure this symbol is output as a dynamic symbol. Undefined weak syms won't yet be marked as dynamic. */ - if (h->dynindx == -1 && !h->forced_local + if (htab->root.dynamic_sections_created && h->dynindx == -1 && !h->forced_local && h->root.type == bfd_link_hash_undefweak) { if (! bfd_elf_link_record_dynamic_symbol (info, h)) @@ -15423,15 +16404,17 @@ allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf) if (tls_type & GOT_TLS_GD) { - /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. If - the symbol is both GD and GDESC, got.offset may - have been overwritten. */ + /* R_ARM_TLS_GD32 and R_ARM_TLS_GD32_FDPIC need two + consecutive GOT slots. If the symbol is both GD + and GDESC, got.offset may have been + overwritten. */ h->got.offset = s->size; s->size += 8; } if (tls_type & GOT_TLS_IE) - /* R_ARM_TLS_IE32 needs one GOT slot. */ + /* R_ARM_TLS_IE32/R_ARM_TLS_IE32_FDPIC need one GOT + slot. */ s->size += 4; } @@ -15446,7 +16429,7 @@ allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf) indx = h->dynindx; if (tls_type != GOT_NORMAL - && (bfd_link_pic (info) || indx != 0) + && (bfd_link_dll (info) || indx != 0) && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT || h->root.type != bfd_link_hash_undefweak)) { @@ -15468,7 +16451,8 @@ allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf) if ((tls_type & GOT_TLS_GD) && indx != 0) elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1); } - else if (indx != -1 && !SYMBOL_REFERENCES_LOCAL (info, h)) + else if (((indx != -1) || htab->fdpic_p) + && !SYMBOL_REFERENCES_LOCAL (info, h)) { if (htab->root.dynamic_sections_created) /* Reserve room for the GOT entry's R_ARM_GLOB_DAT relocation. */ @@ -15481,15 +16465,113 @@ allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf) GOT entry's R_ARM_IRELATIVE relocation. */ elf32_arm_allocate_irelocs (info, htab->root.srelgot, 1); else if (bfd_link_pic (info) - && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT - || h->root.type != bfd_link_hash_undefweak)) + && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) /* Reserve room for the GOT entry's R_ARM_RELATIVE relocation. */ elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1); + else if (htab->fdpic_p && tls_type == GOT_NORMAL) + /* Reserve room for rofixup for FDPIC executable. */ + /* TLS relocs do not need space since they are completely + resolved. */ + htab->srofixup->size += 4; } } else h->got.offset = (bfd_vma) -1; + /* FDPIC support. */ + if (eh->fdpic_cnts.gotofffuncdesc_cnt > 0) + { + /* Symbol musn't be exported. */ + if (h->dynindx != -1) + abort(); + + /* We only allocate one function descriptor with its associated relocation. */ + if (eh->fdpic_cnts.funcdesc_offset == -1) + { + asection *s = htab->root.sgot; + + eh->fdpic_cnts.funcdesc_offset = s->size; + s->size += 8; + /* We will add an R_ARM_FUNCDESC_VALUE relocation or two rofixups. */ + if (bfd_link_pic(info)) + elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1); + else + htab->srofixup->size += 8; + } + } + + if (eh->fdpic_cnts.gotfuncdesc_cnt > 0) + { + asection *s = htab->root.sgot; + + if (htab->root.dynamic_sections_created && h->dynindx == -1 + && !h->forced_local) + if (! bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + + if (h->dynindx == -1) + { + /* We only allocate one function descriptor with its associated relocation. q */ + if (eh->fdpic_cnts.funcdesc_offset == -1) + { + + eh->fdpic_cnts.funcdesc_offset = s->size; + s->size += 8; + /* We will add an R_ARM_FUNCDESC_VALUE relocation or two rofixups. */ + if (bfd_link_pic(info)) + elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1); + else + htab->srofixup->size += 8; + } + } + + /* Add one entry into the GOT and a R_ARM_FUNCDESC or + R_ARM_RELATIVE/rofixup relocation on it. */ + eh->fdpic_cnts.gotfuncdesc_offset = s->size; + s->size += 4; + if (h->dynindx == -1 && !bfd_link_pic(info)) + htab->srofixup->size += 4; + else + elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1); + } + + if (eh->fdpic_cnts.funcdesc_cnt > 0) + { + if (htab->root.dynamic_sections_created && h->dynindx == -1 + && !h->forced_local) + if (! bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + + if (h->dynindx == -1) + { + /* We only allocate one function descriptor with its associated relocation. */ + if (eh->fdpic_cnts.funcdesc_offset == -1) + { + asection *s = htab->root.sgot; + + eh->fdpic_cnts.funcdesc_offset = s->size; + s->size += 8; + /* We will add an R_ARM_FUNCDESC_VALUE relocation or two rofixups. */ + if (bfd_link_pic(info)) + elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1); + else + htab->srofixup->size += 8; + } + } + if (h->dynindx == -1 && !bfd_link_pic(info)) + { + /* For FDPIC executable we replace R_ARM_RELATIVE with a rofixup. */ + htab->srofixup->size += 4 * eh->fdpic_cnts.funcdesc_cnt; + } + else + { + /* Will need one dynamic reloc per reference. will be either + R_ARM_FUNCDESC or R_ARM_RELATIVE for hidden symbols. */ + elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, + eh->fdpic_cnts.funcdesc_cnt); + } + } + /* Allocate stubs for exported Thumb functions on v4t. */ if (!htab->use_blx && h->dynindx != -1 && h->def_regular @@ -15532,7 +16614,7 @@ allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf) space for pc-relative relocs that have become local due to symbol visibility changes. */ - if (bfd_link_pic (info) || htab->root.is_relocatable_executable) + if (bfd_link_pic (info) || htab->root.is_relocatable_executable || htab->fdpic_p) { /* Relocs that use pc_count are PC-relative forms, which will appear on something like ".long foo - ." or "movw REG, foo - .". We want @@ -15579,7 +16661,7 @@ allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf) /* Make sure undefined weak symbols are output as a dynamic symbol in PIEs. */ - else if (h->dynindx == -1 + else if (htab->root.dynamic_sections_created && h->dynindx == -1 && !h->forced_local) { if (! bfd_elf_link_record_dynamic_symbol (info, h)) @@ -15635,10 +16717,15 @@ allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf) for (p = eh->dyn_relocs; p != NULL; p = p->next) { asection *sreloc = elf_section_data (p->sec)->sreloc; + if (h->type == STT_GNU_IFUNC && eh->plt.noncall_refcount == 0 && SYMBOL_REFERENCES_LOCAL (info, h)) elf32_arm_allocate_irelocs (info, sreloc, p->count); + else if (h->dynindx != -1 && (!bfd_link_pic(info) || !info->symbolic || !h->def_regular)) + elf32_arm_allocate_dynrelocs (info, sreloc, p->count); + else if (htab->fdpic_p && !bfd_link_pic(info)) + htab->srofixup->size += 4 * p->count; else elf32_arm_allocate_dynrelocs (info, sreloc, p->count); } @@ -15670,6 +16757,7 @@ maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p) /* Not an error, just cut short the traversal. */ return FALSE; } + return TRUE; } @@ -15733,6 +16821,7 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, asection *srel; bfd_boolean is_vxworks = htab->vxworks_p; unsigned int symndx; + struct fdpic_local *local_fdpic_cnts; if (! is_arm_elf (ibfd)) continue; @@ -15762,7 +16851,10 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, else if (p->count != 0) { srel = elf_section_data (p->sec)->sreloc; - elf32_arm_allocate_dynrelocs (info, srel, p->count); + if (htab->fdpic_p && !bfd_link_pic(info)) + htab->srofixup->size += 4 * p->count; + else + elf32_arm_allocate_dynrelocs (info, srel, p->count); if ((p->sec->output_section->flags & SEC_READONLY) != 0) info->flags |= DF_TEXTREL; } @@ -15779,15 +16871,54 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, local_iplt_ptr = elf32_arm_local_iplt (ibfd); local_tls_type = elf32_arm_local_got_tls_type (ibfd); local_tlsdesc_gotent = elf32_arm_local_tlsdesc_gotent (ibfd); + local_fdpic_cnts = elf32_arm_local_fdpic_cnts (ibfd); symndx = 0; s = htab->root.sgot; srel = htab->root.srelgot; for (; local_got < end_local_got; ++local_got, ++local_iplt_ptr, ++local_tls_type, - ++local_tlsdesc_gotent, ++symndx) + ++local_tlsdesc_gotent, ++symndx, ++local_fdpic_cnts) { *local_tlsdesc_gotent = (bfd_vma) -1; local_iplt = *local_iplt_ptr; + + /* FDPIC support. */ + if (local_fdpic_cnts->gotofffuncdesc_cnt > 0) + { + if (local_fdpic_cnts->funcdesc_offset == -1) + { + local_fdpic_cnts->funcdesc_offset = s->size; + s->size += 8; + + /* We will add an R_ARM_FUNCDESC_VALUE relocation or two rofixups. */ + if (bfd_link_pic(info)) + elf32_arm_allocate_dynrelocs (info, srel, 1); + else + htab->srofixup->size += 8; + } + } + + if (local_fdpic_cnts->funcdesc_cnt > 0) + { + if (local_fdpic_cnts->funcdesc_offset == -1) + { + local_fdpic_cnts->funcdesc_offset = s->size; + s->size += 8; + + /* We will add an R_ARM_FUNCDESC_VALUE relocation or two rofixups. */ + if (bfd_link_pic(info)) + elf32_arm_allocate_dynrelocs (info, srel, 1); + else + htab->srofixup->size += 8; + } + + /* We will add n R_ARM_RELATIVE relocations or n rofixups. */ + if (bfd_link_pic(info)) + elf32_arm_allocate_dynrelocs (info, srel, local_fdpic_cnts->funcdesc_cnt); + else + htab->srofixup->size += 4 * local_fdpic_cnts->funcdesc_cnt; + } + if (local_iplt != NULL) { struct elf_dyn_relocs *p; @@ -15862,13 +16993,15 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, && (local_iplt == NULL || local_iplt->arm.noncall_refcount == 0)) elf32_arm_allocate_irelocs (info, srel, 1); - else if (bfd_link_pic (info) || output_bfd->flags & DYNAMIC) + else if (bfd_link_pic (info) || output_bfd->flags & DYNAMIC || htab->fdpic_p) { - if ((bfd_link_pic (info) && !(*local_tls_type & GOT_TLS_GDESC)) - || *local_tls_type & GOT_TLS_GD) + if ((bfd_link_pic (info) && !(*local_tls_type & GOT_TLS_GDESC))) elf32_arm_allocate_dynrelocs (info, srel, 1); + else if (htab->fdpic_p && *local_tls_type & GOT_NORMAL) + htab->srofixup->size += 4; - if (bfd_link_pic (info) && *local_tls_type & GOT_TLS_GDESC) + if ((bfd_link_pic (info) || htab->fdpic_p) + && *local_tls_type & GOT_TLS_GDESC) { elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1); @@ -15884,7 +17017,7 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, if (htab->tls_ldm_got.refcount > 0) { /* Allocate two GOT entries and one dynamic relocation (if necessary) - for R_ARM_TLS_LDM32 relocations. */ + for R_ARM_TLS_LDM32/R_ARM_TLS_LDM32_FDPIC relocations. */ htab->tls_ldm_got.offset = htab->root.sgot->size; htab->root.sgot->size += 8; if (bfd_link_pic (info)) @@ -15893,6 +17026,11 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, else htab->tls_ldm_got.offset = -1; + /* At the very end of the .rofixup section is a pointer to the GOT, + reserve space for it. */ + if (htab->fdpic_p && htab->srofixup != NULL) + htab->srofixup->size += 4; + /* Allocate global sym .plt and .got entries, and space for global sym dynamic relocs. */ elf_link_hash_traverse (& htab->root, allocate_dynrelocs_for_symbol, info); @@ -15957,7 +17095,7 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, /* It's OK to base decisions on the section name, because none of the dynobj section names depend upon the input files. */ - name = bfd_get_section_name (dynobj, s); + name = bfd_section_name (s); if (s == htab->root.splt) { @@ -15983,7 +17121,8 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, && s != htab->root.iplt && s != htab->root.igotplt && s != htab->root.sdynbss - && s != htab->root.sdynrelro) + && s != htab->root.sdynrelro + && s != htab->srofixup) { /* It's not one of our sections, so don't allocate space. */ continue; @@ -16089,6 +17228,9 @@ elf32_arm_always_size_sections (bfd *output_bfd, struct bfd_link_info *info) { asection *tls_sec; + struct elf32_arm_link_hash_table *htab; + + htab = elf32_arm_hash_table (info); if (bfd_link_relocatable (info)) return TRUE; @@ -16121,6 +17263,12 @@ elf32_arm_always_size_sections (bfd *output_bfd, (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE); } } + + if (htab->fdpic_p && !bfd_link_relocatable (info) + && !bfd_elf_stack_segment_size (output_bfd, info, + "__stacksize", DEFAULT_STACK_SIZE)) + return FALSE; + return TRUE; } @@ -16205,10 +17353,10 @@ elf32_arm_finish_dynamic_symbol (bfd * output_bfd, } /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks, - the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative - to the ".got" section. */ + and for FDPIC, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: + it is relative to the ".got" section. */ if (h == htab->root.hdynamic - || (!htab->vxworks_p && h == htab->root.hgot)) + || (!htab->fdpic_p && !htab->vxworks_p && h == htab->root.hgot)) sym->st_shndx = SHN_ABS; return TRUE; @@ -16615,22 +17763,38 @@ elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; } + /* At the very end of the .rofixup section is a pointer to the GOT. */ + if (htab->fdpic_p && htab->srofixup != NULL) + { + struct elf_link_hash_entry *hgot = htab->root.hgot; + + bfd_vma got_value = hgot->root.u.def.value + + hgot->root.u.def.section->output_section->vma + + hgot->root.u.def.section->output_offset; + + arm_elf_add_rofixup(output_bfd, htab->srofixup, got_value); + + /* Make sure we allocated and generated the same number of fixups. */ + BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size); + } + return TRUE; } -static void -elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED) +static bfd_boolean +elf32_arm_init_file_header (bfd *abfd, struct bfd_link_info *link_info) { Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */ struct elf32_arm_link_hash_table *globals; struct elf_segment_map *m; + if (!_bfd_elf_init_file_header (abfd, link_info)) + return FALSE; + i_ehdrp = elf_elfheader (abfd); if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN) i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM; - else - _bfd_elf_post_process_headers (abfd, link_info); i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION; if (link_info) @@ -16638,6 +17802,9 @@ elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATT globals = elf32_arm_hash_table (link_info); if (globals != NULL && globals->byteswap_code) i_ehdrp->e_flags |= EF_ARM_BE8; + + if (globals->fdpic_p) + i_ehdrp->e_ident[EI_OSABI] |= ELFOSABI_ARM_FDPIC; } if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_VER5 @@ -16669,6 +17836,7 @@ elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATT m->p_flags_valid = 1; } } + return TRUE; } static enum elf_reloc_type_class @@ -16692,11 +17860,18 @@ elf32_arm_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, } static void -elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED) +arm_final_write_processing (bfd *abfd) { bfd_arm_update_notes (abfd, ARM_NOTE_SECTION); } +static bfd_boolean +elf32_arm_final_write_processing (bfd *abfd) +{ + arm_final_write_processing (abfd); + return _bfd_elf_final_write_processing (abfd); +} + /* Return TRUE if this is an unwinding table entry. */ static bfd_boolean @@ -16715,7 +17890,7 @@ elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec) { const char * name; - name = bfd_get_section_name (abfd, sec); + name = bfd_section_name (sec); if (is_arm_elf_unwind_section_name (abfd, name)) { @@ -16866,6 +18041,23 @@ elf32_arm_output_plt_map_1 (output_arch_syminfo *osi, if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr)) return FALSE; } + else if (htab->fdpic_p) + { + enum map_symbol_type type = using_thumb_only(htab) + ? ARM_MAP_THUMB + : ARM_MAP_ARM; + + if (elf32_arm_plt_needs_thumb_stub_p (osi->info, arm_plt)) + if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr - 4)) + return FALSE; + if (!elf32_arm_output_map_sym (osi, type, addr)) + return FALSE; + if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 16)) + return FALSE; + if (htab->plt_entry_size == 4 * ARRAY_SIZE(elf32_arm_fdpic_plt_entry)) + if (!elf32_arm_output_map_sym (osi, type, addr + 24)) + return FALSE; + } else if (using_thumb_only (htab)) { if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr)) @@ -17222,7 +18414,7 @@ elf32_arm_output_arch_local_syms (bfd *output_bfd, if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0)) return FALSE; } - else if (using_thumb_only (htab)) + else if (using_thumb_only (htab) && !htab->fdpic_p) { if (!elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, 0)) return FALSE; @@ -17231,7 +18423,7 @@ elf32_arm_output_arch_local_syms (bfd *output_bfd, if (!elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, 16)) return FALSE; } - else if (!htab->symbian_p) + else if (!htab->symbian_p && !htab->fdpic_p) { if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0)) return FALSE; @@ -17322,6 +18514,8 @@ elf32_arm_filter_cmse_symbols (bfd *abfd ATTRIBUTE_UNUSED, maxnamelen = 128; cmse_name = (char *) bfd_malloc (maxnamelen); + BFD_ASSERT (cmse_name); + for (src_count = 0; src_count < symcount; src_count++) { struct elf32_arm_link_hash_entry *cmse_hash; @@ -17356,9 +18550,6 @@ elf32_arm_filter_cmse_symbols (bfd *abfd ATTRIBUTE_UNUSED, || cmse_hash->root.type != STT_FUNC) continue; - if (!ARM_GET_SYM_CMSE_SPCL (cmse_hash->root.target_internal)) - continue; - syms[dst_count++] = sym; } free (cmse_name); @@ -17400,7 +18591,7 @@ elf32_arm_new_section_hook (bfd *abfd, asection *sec) if (!sec->used_by_bfd) { _arm_elf_section_data *sdata; - bfd_size_type amt = sizeof (*sdata); + size_t amt = sizeof (*sdata); sdata = (_arm_elf_section_data *) bfd_zalloc (abfd, amt); if (sdata == NULL) @@ -18176,7 +19367,7 @@ stm32l4xx_create_replacing_stub_vldm (struct elf32_arm_link_hash_table * htab, const bfd_byte *const initial_insn_addr, bfd_byte *const base_stub_contents) { - int num_words = ((unsigned int) initial_insn << 24) >> 24; + int num_words = initial_insn & 0xff; bfd_byte *current_stub_contents = base_stub_contents; BFD_ASSERT (is_thumb2_vldm (initial_insn)); @@ -18520,6 +19711,8 @@ elf32_arm_write_section (bfd *output_bfd, unsigned int in_index, out_index; bfd_vma add_to_offsets = 0; + if (edited_contents == NULL) + return FALSE; for (in_index = 0, out_index = 0; in_index * 8 < input_size || edit_node;) { if (edit_node) @@ -18681,9 +19874,6 @@ elf32_arm_swap_symbol_in (bfd * abfd, const void *pshn, Elf_Internal_Sym *dst) { - Elf_Internal_Shdr *symtab_hdr; - const char *name = NULL; - if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst)) return FALSE; dst->st_target_internal = 0; @@ -18712,13 +19902,6 @@ elf32_arm_swap_symbol_in (bfd * abfd, else ARM_SET_SYM_BRANCH_TYPE (dst->st_target_internal, ST_BRANCH_UNKNOWN); - /* Mark CMSE special symbols. */ - symtab_hdr = & elf_symtab_hdr (abfd); - if (symtab_hdr->sh_size) - name = bfd_elf_sym_name (abfd, symtab_hdr, dst, NULL); - if (name && CONST_STRNEQ (name, CMSE_PREFIX)) - ARM_SET_SYM_CMSE_SPCL (dst->st_target_internal); - return TRUE; } @@ -18819,11 +20002,6 @@ elf32_arm_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, Elf_Internal_Sym *sym, const char **namep, flagword *flagsp, asection **secp, bfd_vma *valp) { - if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC - && (abfd->flags & DYNAMIC) == 0 - && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour) - elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc; - if (elf32_arm_hash_table (info) == NULL) return FALSE; @@ -19066,10 +20244,10 @@ elf32_arm_get_synthetic_symtab (bfd *abfd, } static bfd_boolean -elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr * hdr) +elf32_arm_section_flags (const Elf_Internal_Shdr *hdr) { if (hdr->sh_flags & SHF_ARM_PURECODE) - *flags |= SEC_ELF_PURECODE; + hdr->bfd_section->flags |= SEC_ELF_PURECODE; return TRUE; } @@ -19242,7 +20420,6 @@ elf32_arm_backend_symbol_processing (bfd *abfd, asymbol *sym) #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup #define bfd_elf32_bfd_reloc_name_lookup elf32_arm_reloc_name_lookup -#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info #define bfd_elf32_new_section_hook elf32_arm_new_section_hook #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol @@ -19250,6 +20427,7 @@ elf32_arm_backend_symbol_processing (bfd *abfd, asymbol *sym) #define bfd_elf32_get_synthetic_symtab elf32_arm_get_synthetic_symtab #define elf_backend_get_symbol_type elf32_arm_get_symbol_type +#define elf_backend_maybe_function_sym elf32_arm_maybe_function_sym #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook #define elf_backend_gc_mark_extra_sections elf32_arm_gc_mark_extra_sections #define elf_backend_check_relocs elf32_arm_check_relocs @@ -19263,7 +20441,7 @@ elf32_arm_backend_symbol_processing (bfd *abfd, asymbol *sym) #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections #define elf_backend_always_size_sections elf32_arm_always_size_sections #define elf_backend_init_index_section _bfd_elf_init_2_index_sections -#define elf_backend_post_process_headers elf32_arm_post_process_headers +#define elf_backend_init_file_header elf32_arm_init_file_header #define elf_backend_reloc_type_class elf32_arm_reloc_type_class #define elf_backend_object_p elf32_arm_object_p #define elf_backend_fake_sections elf32_arm_fake_sections @@ -19358,11 +20536,11 @@ elf32_arm_nacl_modify_segment_map (bfd *abfd, struct bfd_link_info *info) && nacl_modify_segment_map (abfd, info)); } -static void -elf32_arm_nacl_final_write_processing (bfd *abfd, bfd_boolean linker) +static bfd_boolean +elf32_arm_nacl_final_write_processing (bfd *abfd) { - elf32_arm_final_write_processing (abfd, linker); - nacl_final_write_processing (abfd, linker); + arm_final_write_processing (abfd); + return nacl_final_write_processing (abfd); } static bfd_vma @@ -19383,8 +20561,8 @@ elf32_arm_nacl_plt_sym_val (bfd_vma i, const asection *plt, #define elf_backend_plt_alignment 4 #undef elf_backend_modify_segment_map #define elf_backend_modify_segment_map elf32_arm_nacl_modify_segment_map -#undef elf_backend_modify_program_headers -#define elf_backend_modify_program_headers nacl_modify_program_headers +#undef elf_backend_modify_headers +#define elf_backend_modify_headers nacl_modify_headers #undef elf_backend_final_write_processing #define elf_backend_final_write_processing elf32_arm_nacl_final_write_processing #undef bfd_elf32_get_synthetic_symtab @@ -19402,7 +20580,7 @@ elf32_arm_nacl_plt_sym_val (bfd_vma i, const asection *plt, #undef elf_backend_plt_alignment #undef elf_backend_modify_segment_map #define elf_backend_modify_segment_map elf32_arm_modify_segment_map -#undef elf_backend_modify_program_headers +#undef elf_backend_modify_headers #undef elf_backend_final_write_processing #define elf_backend_final_write_processing elf32_arm_final_write_processing #undef ELF_MINPAGESIZE @@ -19411,6 +20589,78 @@ elf32_arm_nacl_plt_sym_val (bfd_vma i, const asection *plt, #define ELF_COMMONPAGESIZE 0x1000 +/* FDPIC Targets. */ + +#undef TARGET_LITTLE_SYM +#define TARGET_LITTLE_SYM arm_elf32_fdpic_le_vec +#undef TARGET_LITTLE_NAME +#define TARGET_LITTLE_NAME "elf32-littlearm-fdpic" +#undef TARGET_BIG_SYM +#define TARGET_BIG_SYM arm_elf32_fdpic_be_vec +#undef TARGET_BIG_NAME +#define TARGET_BIG_NAME "elf32-bigarm-fdpic" +#undef elf_match_priority +#define elf_match_priority 128 +#undef ELF_OSABI +#define ELF_OSABI ELFOSABI_ARM_FDPIC + +/* Like elf32_arm_link_hash_table_create -- but overrides + appropriately for FDPIC. */ + +static struct bfd_link_hash_table * +elf32_arm_fdpic_link_hash_table_create (bfd *abfd) +{ + struct bfd_link_hash_table *ret; + + ret = elf32_arm_link_hash_table_create (abfd); + if (ret) + { + struct elf32_arm_link_hash_table *htab = (struct elf32_arm_link_hash_table *) ret; + + htab->fdpic_p = 1; + } + return ret; +} + +/* We need dynamic symbols for every section, since segments can + relocate independently. */ +static bfd_boolean +elf32_arm_fdpic_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info + ATTRIBUTE_UNUSED, + asection *p ATTRIBUTE_UNUSED) +{ + switch (elf_section_data (p)->this_hdr.sh_type) + { + case SHT_PROGBITS: + case SHT_NOBITS: + /* If sh_type is yet undecided, assume it could be + SHT_PROGBITS/SHT_NOBITS. */ + case SHT_NULL: + return FALSE; + + /* There shouldn't be section relative relocations + against any other section. */ + default: + return TRUE; + } +} + +#undef elf32_bed +#define elf32_bed elf32_arm_fdpic_bed + +#undef bfd_elf32_bfd_link_hash_table_create +#define bfd_elf32_bfd_link_hash_table_create elf32_arm_fdpic_link_hash_table_create + +#undef elf_backend_omit_section_dynsym +#define elf_backend_omit_section_dynsym elf32_arm_fdpic_omit_section_dynsym + +#include "elf32-target.h" + +#undef elf_match_priority +#undef ELF_OSABI +#undef elf_backend_omit_section_dynsym + /* VxWorks Targets. */ #undef TARGET_LITTLE_SYM @@ -19441,11 +20691,11 @@ elf32_arm_vxworks_link_hash_table_create (bfd *abfd) return ret; } -static void -elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker) +static bfd_boolean +elf32_arm_vxworks_final_write_processing (bfd *abfd) { - elf32_arm_final_write_processing (abfd, linker); - elf_vxworks_final_write_processing (abfd, linker); + arm_final_write_processing (abfd); + return elf_vxworks_final_write_processing (abfd); } #undef elf32_bed @@ -19567,7 +20817,7 @@ elf32_arm_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) if (strcmp (sec->name, ".glue_7") && strcmp (sec->name, ".glue_7t")) { - if ((bfd_get_section_flags (ibfd, sec) + if ((bfd_section_flags (sec) & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) only_data_sections = FALSE;