diff options
| -rw-r--r-- | bfd/ChangeLog | 38 | ||||
| -rw-r--r-- | bfd/bfd-in2.h | 8 | ||||
| -rw-r--r-- | bfd/elf32-arm.c | 753 | ||||
| -rw-r--r-- | bfd/libbfd.h | 8 | ||||
| -rw-r--r-- | bfd/reloc.c | 16 | ||||
| -rw-r--r-- | gas/ChangeLog | 9 | ||||
| -rw-r--r-- | gas/config/tc-arm.c | 51 | ||||
| -rw-r--r-- | gas/testsuite/ChangeLog | 5 | ||||
| -rw-r--r-- | gas/testsuite/gas/arm/arm.exp | 2 | ||||
| -rw-r--r-- | gas/testsuite/gas/arm/tls.d | 21 | ||||
| -rw-r--r-- | gas/testsuite/gas/arm/tls.s | 14 | ||||
| -rw-r--r-- | include/elf/ChangeLog | 5 | ||||
| -rw-r--r-- | include/elf/arm.h | 10 | ||||
| -rw-r--r-- | ld/testsuite/ChangeLog | 8 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/arm-dyn.ld | 2 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/arm-elf.exp | 6 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/arm-lib.ld | 2 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/tls-app.d | 18 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/tls-app.r | 12 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/tls-app.s | 34 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/tls-lib.d | 15 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/tls-lib.r | 10 | ||||
| -rw-r--r-- | ld/testsuite/ld-arm/tls-lib.s | 22 |
23 files changed, 984 insertions, 85 deletions
diff --git a/bfd/ChangeLog b/bfd/ChangeLog index c2629c5..c4b62dd 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,4 +1,42 @@ 2005-03-29 Daniel Jacobowitz <dan@codesourcery.com> + Phil Blundell <philb@gnu.org> + + * bfd-in2.h, libbfd.h: Regenerated. + * reloc.c: Add ARM TLS relocations. + * elf32-arm.c (elf32_arm_howto_table): Add dynamic TLS + relocations. + (elf32_arm_tls_gd32_howto, elf32_arm_tls_ldo32_howto) + (elf32_arm_tls_ldm32_howto, elf32_arm_tls_le32_howto) + (elf32_arm_tls_ie32_howto): New. + (elf32_arm_howto_from_type): Support TLS relocations. + (elf32_arm_reloc_map): Likewise. + (elf32_arm_reloc_type_lookup): Likewise. + (TCB_SIZE): Define. + (struct elf32_arm_obj_tdata): New. + (elf32_arm_tdata, elf32_arm_local_got_tls_type): Define. + (elf32_arm_mkobject): New function. + (struct elf32_arm_relocs_copied): Add pc_count. + (elf32_arm_hash_entry, GOT_UNKNOWN, GOT_NORMAL, GOT_TLS_GD) + (GOT_TLS_IE): Define. + (struct elf32_arm_link_hash_table): Add tls_ldm_got. + (elf32_arm_link_hash_newfunc): Initialize tls_type. + (elf32_arm_copy_indirect_symbol): Copy pc_count and tls_type. + (elf32_arm_link_hash_table_create): Initialize tls_ldm_got. + (dtpoff_base, tpoff): New functions. + (elf32_arm_final_link_relocate): Handle TLS relocations. + (IS_ARM_TLS_RELOC): Define. + (elf32_arm_relocate_section): Warn about TLS mismatches. + (elf32_arm_gc_sweep_hook): Handle TLS relocations and pc_count. + (elf32_arm_check_relocs): Detect invalid symbol indexes. Handle + TLS relocations and pc_count. + (elf32_arm_adjust_dynamic_symbol): Check non_got_ref. + (allocate_dynrelocs): Handle TLS. Bind REL32 relocs to local + calls. + (elf32_arm_size_dynamic_sections): Handle TLS. + (elf32_arm_finish_dynamic_symbol): Likewise. + (bfd_elf32_mkobject): Define. + +2005-03-29 Daniel Jacobowitz <dan@codesourcery.com> * elf32-arm.c (elf32_arm_check_relocs): Increment count for all relocation types. Don't count relocations which will use a PLT. diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h index 131bd83..55492cb 100644 --- a/bfd/bfd-in2.h +++ b/bfd/bfd-in2.h @@ -2691,6 +2691,14 @@ field in the instruction. */ BFD_RELOC_ARM_RELATIVE, BFD_RELOC_ARM_GOTOFF, BFD_RELOC_ARM_GOTPC, + BFD_RELOC_ARM_TLS_GD32, + BFD_RELOC_ARM_TLS_LDO32, + BFD_RELOC_ARM_TLS_LDM32, + BFD_RELOC_ARM_TLS_DTPOFF32, + BFD_RELOC_ARM_TLS_DTPMOD32, + BFD_RELOC_ARM_TLS_TPOFF32, + BFD_RELOC_ARM_TLS_IE32, + BFD_RELOC_ARM_TLS_LE32, /* Pc-relative or absolute relocation depending on target. Used for entries in .init_array sections. */ diff --git a/bfd/elf32-arm.c b/bfd/elf32-arm.c index 2e1f1d3..7464bbe 100644 --- a/bfd/elf32-arm.c +++ b/bfd/elf32-arm.c @@ -294,49 +294,49 @@ static reloc_howto_type elf32_arm_howto_table[] = 0x07ff07ff, /* dst_mask */ TRUE), /* pcrel_offset */ - /* These next three relocs are not defined, but we need to fill the space. */ + /* Dynamic TLS relocations. */ - HOWTO (R_ARM_NONE, /* type */ - 0, /* rightshift */ - 0, /* size (0 = byte, 1 = short, 2 = long) */ - 0, /* bitsize */ - FALSE, /* pc_relative */ - 0, /* bitpos */ - complain_overflow_dont,/* complain_on_overflow */ - bfd_elf_generic_reloc, /* special_function */ - "R_ARM_unknown_17", /* name */ - FALSE, /* partial_inplace */ - 0, /* src_mask */ - 0, /* dst_mask */ - FALSE), /* pcrel_offset */ + HOWTO (R_ARM_TLS_DTPMOD32, /* 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_DTPMOD32", /* name */ + TRUE, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ - HOWTO (R_ARM_NONE, /* type */ - 0, /* rightshift */ - 0, /* size (0 = byte, 1 = short, 2 = long) */ - 0, /* bitsize */ - FALSE, /* pc_relative */ - 0, /* bitpos */ - complain_overflow_dont,/* complain_on_overflow */ - bfd_elf_generic_reloc, /* special_function */ - "R_ARM_unknown_18", /* name */ - FALSE, /* partial_inplace */ - 0, /* src_mask */ - 0, /* dst_mask */ - FALSE), /* pcrel_offset */ + HOWTO (R_ARM_TLS_DTPOFF32, /* 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_DTPOFF32", /* name */ + TRUE, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ - HOWTO (R_ARM_NONE, /* type */ - 0, /* rightshift */ - 0, /* size (0 = byte, 1 = short, 2 = long) */ - 0, /* bitsize */ - FALSE, /* pc_relative */ - 0, /* bitpos */ - complain_overflow_dont,/* complain_on_overflow */ - bfd_elf_generic_reloc, /* special_function */ - "R_ARM_unknown_19", /* name */ - FALSE, /* partial_inplace */ - 0, /* src_mask */ - 0, /* dst_mask */ - FALSE), /* pcrel_offset */ + HOWTO (R_ARM_TLS_TPOFF32, /* 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_TPOFF32", /* name */ + TRUE, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE), /* pcrel_offset */ /* Relocs used in ARM Linux */ @@ -663,6 +663,81 @@ static reloc_howto_type elf32_arm_howto_table[] = TRUE), /* pcrel_offset */ }; +static reloc_howto_type elf32_arm_tls_gd32_howto = + HOWTO (R_ARM_TLS_GD32, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + NULL, /* special_function */ + "R_ARM_TLS_GD32", /* name */ + TRUE, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE); /* pcrel_offset */ + +static reloc_howto_type elf32_arm_tls_ldo32_howto = + HOWTO (R_ARM_TLS_LDO32, /* 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_LDO32", /* name */ + TRUE, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE); /* pcrel_offset */ + +static reloc_howto_type elf32_arm_tls_ldm32_howto = + HOWTO (R_ARM_TLS_LDM32, /* 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", /* name */ + TRUE, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE); /* pcrel_offset */ + +static reloc_howto_type elf32_arm_tls_le32_howto = + HOWTO (R_ARM_TLS_LE32, /* 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_LE32", /* name */ + TRUE, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE); /* pcrel_offset */ + +static reloc_howto_type elf32_arm_tls_ie32_howto = + HOWTO (R_ARM_TLS_IE32, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + FALSE, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_bitfield,/* complain_on_overflow */ + NULL, /* special_function */ + "R_ARM_TLS_IE32", /* name */ + TRUE, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + FALSE); /* pcrel_offset */ + /* GNU extension to record C++ vtable hierarchy */ static reloc_howto_type elf32_arm_vtinherit_howto = HOWTO (R_ARM_GNU_VTINHERIT, /* type */ @@ -825,6 +900,26 @@ elf32_arm_howto_from_type (unsigned int r_type) case R_ARM_THM_PC9: return &elf32_arm_thm_pc9_howto; + + case R_ARM_TLS_GD32: + return &elf32_arm_tls_gd32_howto; + break; + + case R_ARM_TLS_LDO32: + return &elf32_arm_tls_ldo32_howto; + break; + + case R_ARM_TLS_LDM32: + return &elf32_arm_tls_ldm32_howto; + break; + + case R_ARM_TLS_IE32: + return &elf32_arm_tls_ie32_howto; + break; + + case R_ARM_TLS_LE32: + return &elf32_arm_tls_le32_howto; + break; case R_ARM_RREL32: case R_ARM_RABS32: @@ -879,7 +974,16 @@ static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] = {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32}, {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32}, {BFD_RELOC_ARM_PREL31, R_ARM_PREL31}, - {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2} + {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2}, + {BFD_RELOC_ARM_PLT32, R_ARM_PLT32}, + {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32}, + {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32}, + {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32}, + {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32}, + {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32}, + {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32}, + {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32}, + {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32}, }; static reloc_howto_type * @@ -903,6 +1007,21 @@ elf32_arm_reloc_type_lookup (abfd, code) case BFD_RELOC_THUMB_PCREL_BRANCH9: return & elf32_arm_thm_pc9_howto; + case BFD_RELOC_ARM_TLS_GD32: + return & elf32_arm_tls_gd32_howto; + + case BFD_RELOC_ARM_TLS_LDO32: + return & elf32_arm_tls_ldo32_howto; + + case BFD_RELOC_ARM_TLS_LDM32: + return & elf32_arm_tls_ldm32_howto; + + case BFD_RELOC_ARM_TLS_IE32: + return & elf32_arm_tls_ie32_howto; + + case BFD_RELOC_ARM_TLS_LE32: + return & elf32_arm_tls_le32_howto; + default: for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++) if (elf32_arm_reloc_map[i].bfd_reloc_val == code) @@ -1093,14 +1212,41 @@ struct _arm_elf_section_data #define elf32_arm_section_data(sec) \ ((struct _arm_elf_section_data *) elf_section_data (sec)) +/* The size of the thread control block. */ +#define TCB_SIZE 8 + +struct elf32_arm_obj_tdata +{ + struct elf_obj_tdata root; + + /* tls_type for each local got entry. */ + char *local_got_tls_type; +}; + +#define elf32_arm_tdata(abfd) \ + ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any) + +#define elf32_arm_local_got_tls_type(abfd) \ + (elf32_arm_tdata (abfd)->local_got_tls_type) + +static bfd_boolean +elf32_arm_mkobject (bfd *abfd) +{ + bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata); + abfd->tdata.any = bfd_zalloc (abfd, amt); + if (abfd->tdata.any == NULL) + return FALSE; + return TRUE; +} + /* The ARM linker needs to keep track of the number of relocs that it decides to copy in check_relocs for each symbol. This is so that it can discard PC relative relocs if it doesn't need them when linking with -Bsymbolic. We store the information in a field extending the regular ELF linker hash table. */ -/* This structure keeps track of the number of PC relative relocs we - have copied for a given symbol. */ +/* This structure keeps track of the number of relocs we have copied + for a given symbol. */ struct elf32_arm_relocs_copied { /* Next section. */ @@ -1109,8 +1255,12 @@ struct elf32_arm_relocs_copied asection * section; /* Number of relocs copied in this section. */ bfd_size_type count; + /* Number of PC-relative relocs copied in this section. */ + bfd_size_type pc_count; }; +#define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent)) + /* Arm ELF linker hash entry. */ struct elf32_arm_link_hash_entry { @@ -1127,6 +1277,12 @@ struct elf32_arm_link_hash_entry used, we need to record the index into .got.plt instead of recomputing it from the PLT offset. */ bfd_signed_vma plt_got_offset; + +#define GOT_UNKNOWN 0 +#define GOT_NORMAL 1 +#define GOT_TLS_GD 2 +#define GOT_TLS_IE 4 + unsigned char tls_type; }; /* Traverse an arm ELF linker hash table. */ @@ -1189,6 +1345,12 @@ struct elf32_arm_link_hash_table asection *sdynbss; asection *srelbss; + /* Data for R_ARM_TLS_LDM32 relocations. */ + union { + bfd_signed_vma refcount; + bfd_vma offset; + } tls_ldm_got; + /* Small local sym to section mapping cache. */ struct sym_sec_cache sym_sec; @@ -1220,6 +1382,7 @@ elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry, if (ret != NULL) { ret->relocs_copied = NULL; + ret->tls_type = GOT_UNKNOWN; ret->plt_thumb_refcount = 0; ret->plt_got_offset = -1; } @@ -1321,6 +1484,7 @@ elf32_arm_copy_indirect_symbol (const struct elf_backend_data *bed, for (q = edir->relocs_copied; q != NULL; q = q->next) if (q->section == p->section) { + q->pc_count += p->pc_count; q->count += p->count; *pp = p->next; break; @@ -1346,6 +1510,13 @@ elf32_arm_copy_indirect_symbol (const struct elf_backend_data *bed, else BFD_ASSERT (eind->plt_thumb_refcount == 0); + if (ind->root.type == bfd_link_hash_indirect + && dir->got.refcount <= 0) + { + edir->tls_type = eind->tls_type; + eind->tls_type = GOT_UNKNOWN; + } + _bfd_elf_link_hash_copy_indirect (bed, dir, ind); } @@ -1392,6 +1563,7 @@ elf32_arm_link_hash_table_create (bfd *abfd) ret->use_rel = 1; ret->sym_sec.abfd = NULL; ret->obfd = abfd; + ret->tls_ldm_got.refcount = 0; return &ret->root.root; } @@ -2228,6 +2400,35 @@ arm_real_reloc_type (struct elf32_arm_link_hash_table * globals, #endif /* OLD_ARM_ABI */ +/* Return the base VMA address which should be subtracted from real addresses + when resolving @dtpoff relocation. + This is PT_TLS segment p_vaddr. */ + +static bfd_vma +dtpoff_base (struct bfd_link_info *info) +{ + /* If tls_sec is NULL, we should have signalled an error already. */ + if (elf_hash_table (info)->tls_sec == NULL) + return 0; + return elf_hash_table (info)->tls_sec->vma; +} + +/* Return the relocation value for @tpoff relocation + if STT_TLS virtual address is ADDRESS. */ + +static bfd_vma +tpoff (struct bfd_link_info *info, bfd_vma address) +{ + struct elf_link_hash_table *htab = elf_hash_table (info); + bfd_vma base; + + /* If tls_sec is NULL, we should have signalled an error already. */ + if (htab->tls_sec == NULL) + return 0; + base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power); + return address - htab->tls_sec->vma + base; +} + /* Perform a relocation as part of a final link. */ static bfd_reloc_status_type @@ -2979,6 +3180,222 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto, contents, rel->r_offset, value, (bfd_vma) 0); + case R_ARM_TLS_LDO32: + value = value - dtpoff_base (info); + + return _bfd_final_link_relocate (howto, input_bfd, input_section, + contents, rel->r_offset, value, (bfd_vma) 0); + + case R_ARM_TLS_LDM32: + { + bfd_vma off; + + if (globals->sgot == NULL) + abort (); + + off = globals->tls_ldm_got.offset; + + if ((off & 1) != 0) + off &= ~1; + else + { + /* If we don't know the module number, create a relocation + for it. */ + if (info->shared) + { + Elf_Internal_Rela outrel; + bfd_byte *loc; + + if (globals->srelgot == NULL) + abort (); + + outrel.r_offset = (globals->sgot->output_section->vma + + globals->sgot->output_offset + off); + outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32); + + bfd_put_32 (output_bfd, 0, globals->sgot->contents + off); + + loc = globals->srelgot->contents; + loc += globals->srelgot->reloc_count++ * sizeof (Elf32_External_Rel); + bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); + } + else + bfd_put_32 (output_bfd, 1, globals->sgot->contents + off); + + globals->tls_ldm_got.offset |= 1; + } + + value = globals->sgot->output_section->vma + globals->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, + (bfd_vma) 0); + } + + case R_ARM_TLS_GD32: + case R_ARM_TLS_IE32: + { + bfd_vma off; + int indx; + char tls_type; + + if (globals->sgot == NULL) + abort (); + + indx = 0; + if (h != NULL) + { + bfd_boolean dyn; + dyn = globals->root.dynamic_sections_created; + if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) + && (!info->shared + || !SYMBOL_REFERENCES_LOCAL (info, h))) + { + *unresolved_reloc_p = FALSE; + indx = h->dynindx; + } + off = h->got.offset; + tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type; + } + else + { + if (local_got_offsets == NULL) + abort (); + off = local_got_offsets[r_symndx]; + tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx]; + } + + if (tls_type == GOT_UNKNOWN) + abort (); + + if ((off & 1) != 0) + off &= ~1; + else + { + bfd_boolean need_relocs = FALSE; + Elf_Internal_Rela outrel; + bfd_byte *loc = NULL; + int cur_off = off; + + /* The GOT entries have not been initialized yet. Do it + now, and emit any relocations. If both an IE GOT and a + GD GOT are necessary, we emit the GD first. */ + + if ((info->shared || indx != 0) + && (h == NULL + || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT + || h->root.type != bfd_link_hash_undefweak)) + { + need_relocs = TRUE; + if (globals->srelgot == NULL) + abort (); + loc = globals->srelgot->contents; + loc += globals->srelgot->reloc_count * sizeof (Elf32_External_Rel); + } + + if (tls_type & GOT_TLS_GD) + { + if (need_relocs) + { + outrel.r_offset = (globals->sgot->output_section->vma + + globals->sgot->output_offset + cur_off); + outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32); + bfd_put_32 (output_bfd, 0, globals->sgot->contents + cur_off); + + bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); + globals->srelgot->reloc_count++; + loc += sizeof (Elf32_External_Rel); + + if (indx == 0) + bfd_put_32 (output_bfd, value - dtpoff_base (info), + globals->sgot->contents + cur_off + 4); + else + { + bfd_put_32 (output_bfd, 0, + globals->sgot->contents + cur_off + 4); + + outrel.r_info = ELF32_R_INFO (indx, + R_ARM_TLS_DTPOFF32); + outrel.r_offset += 4; + bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); + globals->srelgot->reloc_count++; + loc += sizeof (Elf32_External_Rel); + } + } + else + { + /* If we are not emitting relocations for a + general dynamic reference, then we must be in a + static link or an executable link with the + symbol binding locally. Mark it as belonging + to module 1, the executable. */ + bfd_put_32 (output_bfd, 1, + globals->sgot->contents + cur_off); + bfd_put_32 (output_bfd, value - dtpoff_base (info), + globals->sgot->contents + cur_off + 4); + } + + cur_off += 8; + } + + if (tls_type & GOT_TLS_IE) + { + if (need_relocs) + { + outrel.r_offset = (globals->sgot->output_section->vma + + globals->sgot->output_offset + + cur_off); + outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32); + + if (indx == 0) + bfd_put_32 (output_bfd, value - dtpoff_base (info), + globals->sgot->contents + cur_off); + else + bfd_put_32 (output_bfd, 0, + globals->sgot->contents + cur_off); + + bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); + globals->srelgot->reloc_count++; + loc += sizeof (Elf32_External_Rel); + } + else + bfd_put_32 (output_bfd, tpoff (info, value), + globals->sgot->contents + cur_off); + cur_off += 4; + } + + if (h != NULL) + h->got.offset |= 1; + else + local_got_offsets[r_symndx] |= 1; + } + + if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32) + off += 8; + value = globals->sgot->output_section->vma + globals->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, + (bfd_vma) 0); + } + + case R_ARM_TLS_LE32: + if (info->shared) + { + (*_bfd_error_handler) + (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"), + input_bfd, input_section, + (long) rel->r_offset, howto->name); + return FALSE; + } + else + value = tpoff (info, value); + + return _bfd_final_link_relocate (howto, input_bfd, input_section, + contents, rel->r_offset, value, (bfd_vma) 0); + case R_ARM_SBREL32: return bfd_reloc_notsupported; @@ -3098,6 +3515,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_LDO32 \ + || (R_TYPE) == R_ARM_TLS_LDM32 \ + || (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) + /* Relocate an ARM ELF section. */ static bfd_boolean elf32_arm_relocate_section (bfd * output_bfd, @@ -3136,6 +3563,7 @@ elf32_arm_relocate_section (bfd * output_bfd, bfd_vma relocation; bfd_reloc_status_type r; arelent bfd_reloc; + char sym_type; bfd_boolean unresolved_reloc = FALSE; r_symndx = ELF32_R_SYM (rel->r_info); @@ -3179,6 +3607,7 @@ elf32_arm_relocate_section (bfd * output_bfd, if (r_symndx < symtab_hdr->sh_info) { sym = local_syms + r_symndx; + sym_type = ELF32_ST_TYPE (sym->st_info); sec = local_sections[r_symndx]; if (globals->use_rel) { @@ -3232,6 +3661,8 @@ elf32_arm_relocate_section (bfd * output_bfd, r_symndx, symtab_hdr, sym_hashes, h, sec, relocation, unresolved_reloc, warned); + + sym_type = h->type; } if (h != NULL) @@ -3244,6 +3675,24 @@ elf32_arm_relocate_section (bfd * output_bfd, name = bfd_section_name (input_bfd, sec); } + if (r_symndx != 0 + && r_type != R_ARM_NONE + && (h == NULL + || h->root.type == bfd_link_hash_defined + || h->root.type == bfd_link_hash_defweak) + && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS)) + { + (*_bfd_error_handler) + ((sym_type == STT_TLS + ? _("%B(%A+0x%lx): %s used with TLS symbol %s") + : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")), + input_bfd, + input_section, + (long) rel->r_offset, + howto->name, + name); + } + r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd, input_section, contents, rel, relocation, info, sec, name, @@ -3823,10 +4272,10 @@ elf32_arm_gc_mark_hook (asection * sec, /* Update the got entry reference counts for the section being removed. */ static bfd_boolean -elf32_arm_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED, - struct bfd_link_info * info ATTRIBUTE_UNUSED, - asection * sec ATTRIBUTE_UNUSED, - const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED) +elf32_arm_gc_sweep_hook (bfd * abfd, + struct bfd_link_info * info, + asection * sec, + const Elf_Internal_Rela * relocs) { Elf_Internal_Shdr *symtab_hdr; struct elf_link_hash_entry **sym_hashes; @@ -3868,6 +4317,8 @@ elf32_arm_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED, #ifndef OLD_ARM_ABI case R_ARM_GOT_PREL: #endif + case R_ARM_TLS_GD32: + case R_ARM_TLS_IE32: if (h != NULL) { if (h->got.refcount > 0) @@ -3880,6 +4331,10 @@ elf32_arm_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED, } break; + case R_ARM_TLS_LDM32: + elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1; + break; + case R_ARM_ABS32: case R_ARM_REL32: case R_ARM_PC24: @@ -3915,6 +4370,8 @@ elf32_arm_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED, if (p->section == sec) { p->count -= 1; + if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32) + p->pc_count -= 1; if (p->count == 0) *pp = p->next; break; @@ -3986,6 +4443,14 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, #ifndef OLD_ARM_ABI r_type = arm_real_reloc_type (htab, r_type); #endif + + if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) + { + (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd, + r_symndx); + return FALSE; + } + if (r_symndx < symtab_hdr->sh_info) h = NULL; else @@ -3999,33 +4464,69 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, #ifndef OLD_ARM_ABI case R_ARM_GOT_PREL: #endif + case R_ARM_TLS_GD32: + case R_ARM_TLS_IE32: /* This symbol requires a global offset table entry. */ - if (h != NULL) - { - h->got.refcount++; - } - else - { - bfd_signed_vma *local_got_refcounts; + { + int tls_type, old_tls_type; - /* This is a global offset table entry for a local symbol. */ - local_got_refcounts = elf_local_got_refcounts (abfd); - if (local_got_refcounts == NULL) - { - bfd_size_type size; + switch (r_type) + { + case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break; + case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break; + default: tls_type = GOT_NORMAL; break; + } - size = symtab_hdr->sh_info; - size *= (sizeof (bfd_signed_vma) + sizeof (char)); - local_got_refcounts = bfd_zalloc (abfd, size); - if (local_got_refcounts == NULL) - return FALSE; - elf_local_got_refcounts (abfd) = local_got_refcounts; - } - local_got_refcounts[r_symndx] += 1; - } - if (r_type == R_ARM_GOT32) - break; - /* Fall through. */ + if (h != NULL) + { + h->got.refcount++; + old_tls_type = elf32_arm_hash_entry (h)->tls_type; + } + else + { + bfd_signed_vma *local_got_refcounts; + + /* This is a global offset table entry for a local symbol. */ + local_got_refcounts = elf_local_got_refcounts (abfd); + if (local_got_refcounts == NULL) + { + bfd_size_type size; + + size = symtab_hdr->sh_info; + size *= (sizeof (bfd_signed_vma) + sizeof(char)); + local_got_refcounts = bfd_zalloc (abfd, size); + if (local_got_refcounts == NULL) + return FALSE; + elf_local_got_refcounts (abfd) = local_got_refcounts; + elf32_arm_local_got_tls_type (abfd) + = (char *) (local_got_refcounts + symtab_hdr->sh_info); + } + local_got_refcounts[r_symndx] += 1; + old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx]; + } + + /* We will already have issued an error message if there is a + TLS / non-TLS mismatch, based on the symbol type. We don't + support any linker relaxations. So just combine any TLS + types needed. */ + if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL + && tls_type != GOT_NORMAL) + tls_type |= old_tls_type; + + if (old_tls_type != tls_type) + { + if (h != NULL) + elf32_arm_hash_entry (h)->tls_type = tls_type; + else + elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type; + } + } + /* Fall through */ + + case R_ARM_TLS_LDM32: + if (r_type == R_ARM_TLS_LDM32) + htab->tls_ldm_got.refcount++; + /* Fall through */ case R_ARM_GOTOFF: case R_ARM_GOTPC: @@ -4176,8 +4677,11 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, *head = p; p->section = sec; p->count = 0; + p->pc_count = 0; } + if (r_type == R_ARM_REL32) + p->pc_count += 1; p->count += 1; } break; @@ -4404,6 +4908,11 @@ elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info, return TRUE; } + /* If there are no non-GOT references, we do not need a copy + relocation. */ + if (!h->non_got_ref) + return TRUE; + /* This is a reference to a symbol defined by a dynamic object which is not a function. */ @@ -4571,6 +5080,8 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) { asection *s; bfd_boolean dyn; + int tls_type = elf32_arm_hash_entry (h)->tls_type; + int indx; /* Make sure this symbol is output as a dynamic symbol. Undefined weak syms won't yet be marked as dynamic. */ @@ -4585,12 +5096,49 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) { s = htab->sgot; h->got.offset = s->size; - s->size += 4; + + if (tls_type == GOT_UNKNOWN) + abort (); + + if (tls_type == GOT_NORMAL) + /* Non-TLS symbols need one GOT slot. */ + s->size += 4; + else + { + if (tls_type & GOT_TLS_GD) + /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */ + s->size += 8; + if (tls_type & GOT_TLS_IE) + /* R_ARM_TLS_IE32 needs one GOT slot. */ + s->size += 4; + } + dyn = htab->root.dynamic_sections_created; - if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT - || h->root.type != bfd_link_hash_undefweak) - && (info->shared - || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) + + indx = 0; + if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) + && (!info->shared + || !SYMBOL_REFERENCES_LOCAL (info, h))) + indx = h->dynindx; + + if (tls_type != GOT_NORMAL + && (info->shared || indx != 0) + && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT + || h->root.type != bfd_link_hash_undefweak)) + { + if (tls_type & GOT_TLS_IE) + htab->srelgot->size += sizeof (Elf32_External_Rel); + + if (tls_type & GOT_TLS_GD) + htab->srelgot->size += sizeof (Elf32_External_Rel); + + if ((tls_type & GOT_TLS_GD) && indx != 0) + htab->srelgot->size += sizeof (Elf32_External_Rel); + } + else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT + || h->root.type != bfd_link_hash_undefweak) + && (info->shared + || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) htab->srelgot->size += sizeof (Elf32_External_Rel); } } @@ -4608,7 +5156,28 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) if (info->shared || htab->root.is_relocatable_executable) { - /* Discard relocs on undefined weak syms with non-default + /* The only reloc that uses pc_count is R_ARM_REL32, which will + appear on something like ".long foo - .". We want calls to + protected symbols to resolve directly to the function rather + than going via the plt. If people want function pointer + comparisons to work as expected then they should avoid + writing assembly like ".long foo - .". */ + if (SYMBOL_CALLS_LOCAL (info, h)) + { + struct elf32_arm_relocs_copied **pp; + + for (pp = &eh->relocs_copied; (p = *pp) != NULL; ) + { + p->count -= p->pc_count; + p->pc_count = 0; + if (p->count == 0) + *pp = p->next; + else + pp = &p->next; + } + } + + /* Also discard relocs on undefined weak syms with non-default visibility. */ if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT && h->root.type == bfd_link_hash_undefweak) @@ -4773,6 +5342,7 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; locsymcount = symtab_hdr->sh_info; end_local_got = local_got + locsymcount; + local_tls_type = elf32_arm_local_got_tls_type (ibfd); s = htab->sgot; srel = htab->srelgot; for (; local_got < end_local_got; ++local_got, ++local_tls_type) @@ -4780,8 +5350,15 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, if (*local_got > 0) { *local_got = s->size; - s->size += 4; - if (info->shared) + if (*local_tls_type & GOT_TLS_GD) + /* TLS_GD relocs need an 8-byte structure in the GOT. */ + s->size += 8; + if (*local_tls_type & GOT_TLS_IE) + s->size += 4; + if (*local_tls_type == GOT_NORMAL) + s->size += 4; + + if (info->shared || *local_tls_type == GOT_TLS_GD) srel->size += sizeof (Elf32_External_Rel); } else @@ -4789,6 +5366,18 @@ 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. */ + htab->tls_ldm_got.offset = htab->sgot->size; + htab->sgot->size += 8; + if (info->shared) + htab->srelgot->size += sizeof (Elf32_External_Rel); + } + else + htab->tls_ldm_got.offset = -1; + /* Allocate global sym .plt and .got entries, and space for global sym dynamic relocs. */ elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info); @@ -5059,7 +5648,9 @@ elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info, } } - if (h->got.offset != (bfd_vma) -1) + if (h->got.offset != (bfd_vma) -1 + && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0 + && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0) { asection * sgot; asection * srel; @@ -5754,6 +6345,8 @@ const struct elf_size_info elf32_arm_size_info = { #endif #define ELF_MINPAGESIZE 0x1000 +#define bfd_elf32_mkobject elf32_arm_mkobject + #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags diff --git a/bfd/libbfd.h b/bfd/libbfd.h index 3cfed3a..dadba59 100644 --- a/bfd/libbfd.h +++ b/bfd/libbfd.h @@ -1177,6 +1177,14 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@", "BFD_RELOC_ARM_RELATIVE", "BFD_RELOC_ARM_GOTOFF", "BFD_RELOC_ARM_GOTPC", + "BFD_RELOC_ARM_TLS_GD32", + "BFD_RELOC_ARM_TLS_LDO32", + "BFD_RELOC_ARM_TLS_LDM32", + "BFD_RELOC_ARM_TLS_DTPOFF32", + "BFD_RELOC_ARM_TLS_DTPMOD32", + "BFD_RELOC_ARM_TLS_TPOFF32", + "BFD_RELOC_ARM_TLS_IE32", + "BFD_RELOC_ARM_TLS_LE32", "BFD_RELOC_ARM_TARGET1", "BFD_RELOC_ARM_ROSEGREL32", "BFD_RELOC_ARM_SBREL32", diff --git a/bfd/reloc.c b/bfd/reloc.c index d952d1b..17f8a45 100644 --- a/bfd/reloc.c +++ b/bfd/reloc.c @@ -2678,6 +2678,22 @@ ENUMX BFD_RELOC_ARM_GOTOFF ENUMX BFD_RELOC_ARM_GOTPC +ENUMX + BFD_RELOC_ARM_TLS_GD32 +ENUMX + BFD_RELOC_ARM_TLS_LDO32 +ENUMX + BFD_RELOC_ARM_TLS_LDM32 +ENUMX + BFD_RELOC_ARM_TLS_DTPOFF32 +ENUMX + BFD_RELOC_ARM_TLS_DTPMOD32 +ENUMX + BFD_RELOC_ARM_TLS_TPOFF32 +ENUMX + BFD_RELOC_ARM_TLS_IE32 +ENUMX + BFD_RELOC_ARM_TLS_LE32 ENUMDOC These relocs are only used within the ARM assembler. They are not (at present) written to any object files. diff --git a/gas/ChangeLog b/gas/ChangeLog index 2cc9445..d6263e6 100644 --- a/gas/ChangeLog +++ b/gas/ChangeLog @@ -1,3 +1,12 @@ +2005-03-29 Daniel Jacobowitz <dan@codesourcery.com> + Phil Blundell <philb@gnu.org> + + * config/tc-arm.c (arm_parse_reloc): Add TLS relocations. + (md_apply_fix3): Mark TLS symbols. + (tc_gen_reloc): Handle TLS relocations. + (arm_fix_adjustable): Ignore TLS relocations. + (s_arm_elf_cons): Support expressions after decorated symbols. + 2005-03-29 Julian Brown <julian@codesourcery.com> * config/tc-arm.c (marked_pr_dependency): New bitmap, bit N indicates diff --git a/gas/config/tc-arm.c b/gas/config/tc-arm.c index 9baf888..78d126c 100644 --- a/gas/config/tc-arm.c +++ b/gas/config/tc-arm.c @@ -4881,6 +4881,11 @@ arm_parse_reloc (void) MAP ("(target1)", BFD_RELOC_ARM_TARGET1), MAP ("(sbrel)", BFD_RELOC_ARM_SBREL32), MAP ("(target2)", BFD_RELOC_ARM_TARGET2), + MAP ("(tlsgd)", BFD_RELOC_ARM_TLS_GD32), + MAP ("(tlsldm)", BFD_RELOC_ARM_TLS_LDM32), + MAP ("(tlsldo)", BFD_RELOC_ARM_TLS_LDO32), + MAP ("(gottpoff)", BFD_RELOC_ARM_TLS_IE32), + MAP ("(tpoff)", BFD_RELOC_ARM_TLS_LE32), { NULL, 0, BFD_RELOC_UNUSED } #undef MAP }; @@ -12224,6 +12229,14 @@ md_apply_fix3 (fixS * fixP, break; #ifdef OBJ_ELF + case BFD_RELOC_ARM_TLS_GD32: + case BFD_RELOC_ARM_TLS_LE32: + case BFD_RELOC_ARM_TLS_IE32: + case BFD_RELOC_ARM_TLS_LDM32: + case BFD_RELOC_ARM_TLS_LDO32: + S_SET_THREAD_LOCAL (fixP->fx_addsy); + /* fall through */ + case BFD_RELOC_ARM_GOT32: case BFD_RELOC_ARM_GOTOFF: case BFD_RELOC_ARM_TARGET2: @@ -12547,6 +12560,18 @@ tc_gen_reloc (asection * section ATTRIBUTE_UNUSED, case BFD_RELOC_ARM_SBREL32: case BFD_RELOC_ARM_PREL31: case BFD_RELOC_ARM_TARGET2: + case BFD_RELOC_ARM_TLS_LE32: + case BFD_RELOC_ARM_TLS_LDO32: + code = fixp->fx_r_type; + break; + + case BFD_RELOC_ARM_TLS_GD32: + case BFD_RELOC_ARM_TLS_IE32: + case BFD_RELOC_ARM_TLS_LDM32: + /* BFD will include the symbol's address in the addend. + But we don't want that, so subtract it out again here. */ + if (!S_IS_COMMON (fixp->fx_addsy)) + reloc->addend -= (*reloc->sym_ptr_ptr)->value; code = fixp->fx_r_type; break; #endif @@ -13843,6 +13868,11 @@ arm_fix_adjustable (fixS * fixP) if (fixP->fx_r_type == BFD_RELOC_ARM_PLT32 || fixP->fx_r_type == BFD_RELOC_ARM_GOT32 || fixP->fx_r_type == BFD_RELOC_ARM_GOTOFF + || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GD32 + || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LE32 + || fixP->fx_r_type == BFD_RELOC_ARM_TLS_IE32 + || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDM32 + || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDO32 || fixP->fx_r_type == BFD_RELOC_ARM_TARGET2) return 0; @@ -13898,8 +13928,12 @@ s_arm_elf_cons (int nbytes) do { bfd_reloc_code_real_type reloc; + char *sym_start; + int sym_len; + sym_start = input_line_pointer; expression (& exp); + sym_len = input_line_pointer - sym_start; if (exp.X_op == O_symbol && * input_line_pointer == '(' @@ -13913,9 +13947,22 @@ s_arm_elf_cons (int nbytes) howto->name, nbytes); else { - char *p = frag_more ((int) nbytes); + char *p; int offset = nbytes - size; - + char *saved_buf = alloca (sym_len), *saved_input; + + /* We've parsed an expression stopping at O_symbol. But there + may be more expression left now that we have parsed the + relocation marker. Parse it again. */ + saved_input = input_line_pointer - sym_len; + memcpy (saved_buf, saved_input, sym_len); + memmove (saved_input, sym_start, sym_len); + input_line_pointer = saved_input; + expression (& exp); + memcpy (saved_input, saved_buf, sym_len); + assert (input_line_pointer >= saved_input + sym_len); + + p = frag_more ((int) nbytes); fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size, &exp, 0, reloc); } diff --git a/gas/testsuite/ChangeLog b/gas/testsuite/ChangeLog index bef8501..5559174 100644 --- a/gas/testsuite/ChangeLog +++ b/gas/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2005-03-29 Daniel Jacobowitz <dan@codesourcery.com> + + * gas/arm/tls.s, gas/arm/tls.d: New files. + * gas/arm/arm.exp: Run TLS test. + 2005-03-28 H.J. Lu <hongjiu.lu@intel.com> PR 803 diff --git a/gas/testsuite/gas/arm/arm.exp b/gas/testsuite/gas/arm/arm.exp index 4ea6454..7cd5630 100644 --- a/gas/testsuite/gas/arm/arm.exp +++ b/gas/testsuite/gas/arm/arm.exp @@ -72,6 +72,8 @@ if {[istarget *arm*-*-*] || [istarget "xscale-*-*"]} then { run_dump_test "mapping" gas_test "bignum1.s" "" $stdoptlist "bignums" run_dump_test "unwind" + + run_dump_test "tls" } if {! [istarget arm*-*-aout] && ![istarget arm-*-pe]} then { diff --git a/gas/testsuite/gas/arm/tls.d b/gas/testsuite/gas/arm/tls.d new file mode 100644 index 0000000..71a1a6f --- /dev/null +++ b/gas/testsuite/gas/arm/tls.d @@ -0,0 +1,21 @@ +#objdump: -dr +#name: TLS + +# Test generation of TLS relocations + +.*: +file format .*arm.* + +Disassembly of section .text: + +00+0 <main>: + 0: e1a00000 nop \(mov r0,r0\) + 4: e1a00000 nop \(mov r0,r0\) + 8: e1a0f00e mov pc, lr + c: 00000000 andeq r0, r0, r0 + c: R_ARM_TLS_GD32 a + 10: 00000004 andeq r0, r0, r4 + 10: R_ARM_TLS_LDM32 b + 14: 00000008 andeq r0, r0, r8 + 14: R_ARM_TLS_IE32 c + 18: 00000000 andeq r0, r0, r0 + 18: R_ARM_TLS_LE32 d diff --git a/gas/testsuite/gas/arm/tls.s b/gas/testsuite/gas/arm/tls.s new file mode 100644 index 0000000..48722a4 --- /dev/null +++ b/gas/testsuite/gas/arm/tls.s @@ -0,0 +1,14 @@ + .text + .globl main + .type main, %function +main: + nop +.L2: + nop + mov pc, lr + +.Lpool: + .word a(tlsgd) + (. - .L2 - 8) + .word b(tlsldm) + (. - .L2 - 8) + .word c(gottpoff) + (. - .L2 - 8) + .word d(tpoff) diff --git a/include/elf/ChangeLog b/include/elf/ChangeLog index b273adb..1d9aedb 100644 --- a/include/elf/ChangeLog +++ b/include/elf/ChangeLog @@ -1,3 +1,8 @@ +2005-03-29 Daniel Jacobowitz <dan@codesourcery.com> + Phil Blundell <philb@gnu.org> + + * arm.h: Add TLS relocations. + 2005-03-23 Ben Elliston <bje@au.ibm.com> * dwarf.h: Merge with GCC's dwarf.h. diff --git a/include/elf/arm.h b/include/elf/arm.h index de3ed06..81a8de1 100644 --- a/include/elf/arm.h +++ b/include/elf/arm.h @@ -114,6 +114,9 @@ START_RELOC_NUMBERS (elf_arm_reloc_type) RELOC_NUMBER (R_ARM_THM_SWI8, 14) RELOC_NUMBER (R_ARM_XPC25, 15) RELOC_NUMBER (R_ARM_THM_XPC22, 16) + RELOC_NUMBER (R_ARM_TLS_DTPMOD32, 17) + RELOC_NUMBER (R_ARM_TLS_DTPOFF32, 18) + RELOC_NUMBER (R_ARM_TLS_TPOFF32, 19) #endif /* not OLD_ARM_ABI */ RELOC_NUMBER (R_ARM_COPY, 20) /* Copy symbol at runtime. */ RELOC_NUMBER (R_ARM_GLOB_DAT, 21) /* Create GOT entry. */ @@ -153,7 +156,12 @@ START_RELOC_NUMBERS (elf_arm_reloc_type) RELOC_NUMBER (R_ARM_GNU_VTINHERIT, 101) RELOC_NUMBER (R_ARM_THM_PC11, 102) /* Cygnus extension to abi: Thumb unconditional branch. */ RELOC_NUMBER (R_ARM_THM_PC9, 103) /* Cygnus extension to abi: Thumb conditional branch. */ - FAKE_RELOC (FIRST_INVALID_RELOC3, 104) + RELOC_NUMBER (R_ARM_TLS_GD32, 104) + RELOC_NUMBER (R_ARM_TLS_LDM32, 105) + RELOC_NUMBER (R_ARM_TLS_LDO32, 106) + RELOC_NUMBER (R_ARM_TLS_IE32, 107) + RELOC_NUMBER (R_ARM_TLS_LE32, 108) + FAKE_RELOC (FIRST_INVALID_RELOC3, 109) FAKE_RELOC (LAST_INVALID_RELOC3, 248) RELOC_NUMBER (R_ARM_RXPC25, 249) #endif /* not OLD_ARM_ABI */ diff --git a/ld/testsuite/ChangeLog b/ld/testsuite/ChangeLog index 9ae7391..cd9ca63 100644 --- a/ld/testsuite/ChangeLog +++ b/ld/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2005-03-29 Daniel Jacobowitz <dan@codesourcery.com> + + * ld-arm/tls-lib.s, ld-arm/tls-lib.d, ld-arm/tls-lib.r, + ld-arm/tls-app.s, ld-arm/tls-app.d, ld-arm/tls-app.r: New files. + * ld-arm/arm-lib.ld, ld-arm/arm-dyn.ld: Increase data segment + alignment. + * ld-arm/arm-elf.exp: Run TLS tests. + 2005-03-28 H.J. Lu <hongjiu.lu@intel.com> PR 803 diff --git a/ld/testsuite/ld-arm/arm-dyn.ld b/ld/testsuite/ld-arm/arm-dyn.ld index 20b9613..96bc10c 100644 --- a/ld/testsuite/ld-arm/arm-dyn.ld +++ b/ld/testsuite/ld-arm/arm-dyn.ld @@ -76,7 +76,7 @@ SECTIONS .gcc_except_table : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) } /* Adjust the address for the data segment. We want to adjust up to the same address within the page on the next page up. */ - . = ALIGN(256) + (. & (256 - 1)); + . = ALIGN (0x8000) - ((0x8000 - .) & (0x8000 - 1)); . = DATA_SEGMENT_ALIGN (0x8000, 0x1000); /* Exception handling */ .eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) } .gcc_except_table : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) } diff --git a/ld/testsuite/ld-arm/arm-elf.exp b/ld/testsuite/ld-arm/arm-elf.exp index 3e747ca..1a0e5b9 100644 --- a/ld/testsuite/ld-arm/arm-elf.exp +++ b/ld/testsuite/ld-arm/arm-elf.exp @@ -75,6 +75,12 @@ set armelftests { {"arm-rel31" "-static -T arm.ld" "" {arm-rel31.s} {{objdump -s arm-rel31.d}} "arm-rel31"} + {"TLS shared library" "-shared -T arm-lib.ld" "" {tls-lib.s} + {{objdump -fdw tls-lib.d} {objdump -Rw tls-lib.r}} + "tls-lib.so"} + {"TLS dynamic application" "-T arm-dyn.ld tmpdir/tls-lib.so" "" {tls-app.s} + {{objdump -fdw tls-app.d} {objdump -Rw tls-app.r}} + "tls-app"} } run_ld_link_tests $armelftests diff --git a/ld/testsuite/ld-arm/arm-lib.ld b/ld/testsuite/ld-arm/arm-lib.ld index 075eaa4..0415d20 100644 --- a/ld/testsuite/ld-arm/arm-lib.ld +++ b/ld/testsuite/ld-arm/arm-lib.ld @@ -75,7 +75,7 @@ SECTIONS .gcc_except_table : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) } /* Adjust the address for the data segment. We want to adjust up to the same address within the page on the next page up. */ - . = ALIGN(256) + (. & (256 - 1)); + . = ALIGN (0x8000) - ((0x8000 - .) & (0x8000 - 1)); . = DATA_SEGMENT_ALIGN (0x8000, 0x1000); /* Exception handling */ .eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) } .gcc_except_table : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) } diff --git a/ld/testsuite/ld-arm/tls-app.d b/ld/testsuite/ld-arm/tls-app.d new file mode 100644 index 0000000..7f486ef --- /dev/null +++ b/ld/testsuite/ld-arm/tls-app.d @@ -0,0 +1,18 @@ + +.*: file format elf32-.*arm +architecture: arm, flags 0x00000112: +EXEC_P, HAS_SYMS, D_PAGED +start address 0x00008274 + +Disassembly of section .text: + +00008274 <foo>: + 8274: e1a00000 nop \(mov r0,r0\) + 8278: e1a00000 nop \(mov r0,r0\) + 827c: e1a0f00e mov pc, lr + 8280: 000080bc streqh r8, \[r0\], -ip + 8284: 000080b4 streqh r8, \[r0\], -r4 + 8288: 000080ac andeq r8, r0, ip, lsr #1 + 828c: 00000004 andeq r0, r0, r4 + 8290: 000080c4 andeq r8, r0, r4, asr #1 + 8294: 00000014 andeq r0, r0, r4, lsl r0 diff --git a/ld/testsuite/ld-arm/tls-app.r b/ld/testsuite/ld-arm/tls-app.r new file mode 100644 index 0000000..3f02397 --- /dev/null +++ b/ld/testsuite/ld-arm/tls-app.r @@ -0,0 +1,12 @@ + +.*: file format elf32-.*arm + +DYNAMIC RELOCATION RECORDS +OFFSET TYPE VALUE +00010334 R_ARM_TLS_DTPMOD32 app_gd +00010338 R_ARM_TLS_DTPOFF32 app_gd +0001033c R_ARM_TLS_DTPMOD32 lib_gd +00010340 R_ARM_TLS_DTPOFF32 lib_gd +00010344 R_ARM_TLS_TPOFF32 app_ie + + diff --git a/ld/testsuite/ld-arm/tls-app.s b/ld/testsuite/ld-arm/tls-app.s new file mode 100644 index 0000000..d505295 --- /dev/null +++ b/ld/testsuite/ld-arm/tls-app.s @@ -0,0 +1,34 @@ + .text + .globl foo + .type foo, %function +foo: + nop +.L2: + nop + mov pc, lr + +.Lpool: + .word lib_gd(tlsgd) + (. - .L2 - 8) + .word app_gd(tlsgd) + (. - .L2 - 8) + .word app_ld(tlsldm) + (. - .L2 - 8) + .word app_ld(tlsldo) + .word app_ie(gottpoff) + (. - .L2 - 8) + .word app_le(tpoff) + + .section .tdata,"awT" + .global app_gd +app_gd: + .space 4 + + .global app_ld +app_ld: + .space 4 + + .section .tbss,"awT",%nobits + .global app_ie +app_ie: + .space 4 + + .global app_le +app_le: + .space 4 diff --git a/ld/testsuite/ld-arm/tls-lib.d b/ld/testsuite/ld-arm/tls-lib.d new file mode 100644 index 0000000..0492877 --- /dev/null +++ b/ld/testsuite/ld-arm/tls-lib.d @@ -0,0 +1,15 @@ + +.*: file format elf32-.*arm +architecture: arm, flags 0x00000150: +HAS_SYMS, DYNAMIC, D_PAGED +start address 0x.* + +Disassembly of section .text: + +00000328 <foo>: + 328: e1a00000 nop \(mov r0,r0\) + 32c: e1a00000 nop \(mov r0,r0\) + 330: e1a0f00e mov pc, lr + 334: 00008098 muleq r0, r8, r0 + 338: 0000808c andeq r8, r0, ip, lsl #1 + 33c: 00000004 andeq r0, r0, r4 diff --git a/ld/testsuite/ld-arm/tls-lib.r b/ld/testsuite/ld-arm/tls-lib.r new file mode 100644 index 0000000..c0bf4bf --- /dev/null +++ b/ld/testsuite/ld-arm/tls-lib.r @@ -0,0 +1,10 @@ + +.*: file format elf32-.*arm + +DYNAMIC RELOCATION RECORDS +OFFSET TYPE VALUE +000083c4 R_ARM_TLS_DTPMOD32 \*ABS\* +000083cc R_ARM_TLS_DTPMOD32 lib_gd +000083d0 R_ARM_TLS_DTPOFF32 lib_gd + + diff --git a/ld/testsuite/ld-arm/tls-lib.s b/ld/testsuite/ld-arm/tls-lib.s new file mode 100644 index 0000000..fa928c0 --- /dev/null +++ b/ld/testsuite/ld-arm/tls-lib.s @@ -0,0 +1,22 @@ + .text + .globl foo + .type foo, %function +foo: + nop +.L2: + nop + mov pc, lr + +.Lpool: + .word lib_gd(tlsgd) + (. - .L2 - 8) + .word lib_ld(tlsldm) + (. - .L2 - 8) + .word lib_ld(tlsldo) + + .section .tdata,"awT" + .global lib_gd +lib_gd: + .space 4 + + .global lib_ld +lib_ld: + .space 4 |