| Line 1... |
Line 1... |
/* PowerPC-specific support for 32-bit ELF
|
/* PowerPC-specific support for 32-bit ELF
|
Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
|
Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
|
2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
|
2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
|
Written by Ian Lance Taylor, Cygnus Support.
|
Written by Ian Lance Taylor, Cygnus Support.
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
| Line 59... |
Line 59... |
#define PLT_NUM_SINGLE_ENTRIES 8192
|
#define PLT_NUM_SINGLE_ENTRIES 8192
|
|
|
/* For new-style .glink and .plt. */
|
/* For new-style .glink and .plt. */
|
#define GLINK_PLTRESOLVE 16*4
|
#define GLINK_PLTRESOLVE 16*4
|
#define GLINK_ENTRY_SIZE 4*4
|
#define GLINK_ENTRY_SIZE 4*4
|
|
#define TLS_GET_ADDR_GLINK_SIZE 12*4
|
|
|
/* VxWorks uses its own plt layout, filled in by the static linker. */
|
/* VxWorks uses its own plt layout, filled in by the static linker. */
|
|
|
/* The standard VxWorks PLT entry. */
|
/* The standard VxWorks PLT entry. */
|
#define VXWORKS_PLT_ENTRY_SIZE 32
|
#define VXWORKS_PLT_ENTRY_SIZE 32
|
| Line 133... |
Line 134... |
#define ADDIS_11_11 0x3d6b0000
|
#define ADDIS_11_11 0x3d6b0000
|
#define ADDIS_11_30 0x3d7e0000
|
#define ADDIS_11_30 0x3d7e0000
|
#define ADDIS_12_12 0x3d8c0000
|
#define ADDIS_12_12 0x3d8c0000
|
#define ADDI_11_11 0x396b0000
|
#define ADDI_11_11 0x396b0000
|
#define ADD_0_11_11 0x7c0b5a14
|
#define ADD_0_11_11 0x7c0b5a14
|
|
#define ADD_3_12_2 0x7c6c1214
|
#define ADD_11_0_11 0x7d605a14
|
#define ADD_11_0_11 0x7d605a14
|
#define B 0x48000000
|
#define B 0x48000000
|
#define BCL_20_31 0x429f0005
|
#define BCL_20_31 0x429f0005
|
#define BCTR 0x4e800420
|
#define BCTR 0x4e800420
|
|
#define BEQLR 0x4d820020
|
|
#define CMPWI_11_0 0x2c0b0000
|
#define LIS_11 0x3d600000
|
#define LIS_11 0x3d600000
|
#define LIS_12 0x3d800000
|
#define LIS_12 0x3d800000
|
#define LWZU_0_12 0x840c0000
|
#define LWZU_0_12 0x840c0000
|
#define LWZ_0_12 0x800c0000
|
#define LWZ_0_12 0x800c0000
|
|
#define LWZ_11_3 0x81630000
|
#define LWZ_11_11 0x816b0000
|
#define LWZ_11_11 0x816b0000
|
#define LWZ_11_30 0x817e0000
|
#define LWZ_11_30 0x817e0000
|
|
#define LWZ_12_3 0x81830000
|
#define LWZ_12_12 0x818c0000
|
#define LWZ_12_12 0x818c0000
|
|
#define MR_0_3 0x7c601b78
|
|
#define MR_3_0 0x7c030378
|
#define MFLR_0 0x7c0802a6
|
#define MFLR_0 0x7c0802a6
|
#define MFLR_12 0x7d8802a6
|
#define MFLR_12 0x7d8802a6
|
#define MTCTR_0 0x7c0903a6
|
#define MTCTR_0 0x7c0903a6
|
#define MTCTR_11 0x7d6903a6
|
#define MTCTR_11 0x7d6903a6
|
#define MTLR_0 0x7c0803a6
|
#define MTLR_0 0x7c0803a6
|
| Line 155... |
Line 163... |
#define SUB_11_11_12 0x7d6c5850
|
#define SUB_11_11_12 0x7d6c5850
|
|
|
/* Offset of tp and dtp pointers from start of TLS block. */
|
/* Offset of tp and dtp pointers from start of TLS block. */
|
#define TP_OFFSET 0x7000
|
#define TP_OFFSET 0x7000
|
#define DTP_OFFSET 0x8000
|
#define DTP_OFFSET 0x8000
|
|
|
|
/* The value of a defined global symbol. */
|
|
#define SYM_VAL(SYM) \
|
|
((SYM)->root.u.def.section->output_section->vma \
|
|
+ (SYM)->root.u.def.section->output_offset \
|
|
+ (SYM)->root.u.def.value)
|
|
|
static reloc_howto_type *ppc_elf_howto_table[R_PPC_max];
|
static reloc_howto_type *ppc_elf_howto_table[R_PPC_max];
|
|
|
static reloc_howto_type ppc_elf_howto_raw[] = {
|
static reloc_howto_type ppc_elf_howto_raw[] = {
|
/* This reloc does nothing. */
|
/* This reloc does nothing. */
|
| Line 745... |
Line 759... |
FALSE, /* partial_inplace */
|
FALSE, /* partial_inplace */
|
0, /* src_mask */
|
0, /* src_mask */
|
0xffff, /* dst_mask */
|
0xffff, /* dst_mask */
|
FALSE), /* pcrel_offset */
|
FALSE), /* pcrel_offset */
|
|
|
/* Marker reloc for TLS. */
|
/* Marker relocs for TLS. */
|
HOWTO (R_PPC_TLS,
|
HOWTO (R_PPC_TLS,
|
0, /* rightshift */
|
0, /* rightshift */
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
32, /* bitsize */
|
32, /* bitsize */
|
FALSE, /* pc_relative */
|
FALSE, /* pc_relative */
|
| Line 760... |
Line 774... |
FALSE, /* partial_inplace */
|
FALSE, /* partial_inplace */
|
0, /* src_mask */
|
0, /* src_mask */
|
0, /* dst_mask */
|
0, /* dst_mask */
|
FALSE), /* pcrel_offset */
|
FALSE), /* pcrel_offset */
|
|
|
|
HOWTO (R_PPC_TLSGD,
|
|
0, /* rightshift */
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
|
32, /* bitsize */
|
|
FALSE, /* pc_relative */
|
|
0, /* bitpos */
|
|
complain_overflow_dont, /* complain_on_overflow */
|
|
bfd_elf_generic_reloc, /* special_function */
|
|
"R_PPC_TLSGD", /* name */
|
|
FALSE, /* partial_inplace */
|
|
0, /* src_mask */
|
|
0, /* dst_mask */
|
|
FALSE), /* pcrel_offset */
|
|
|
|
HOWTO (R_PPC_TLSLD,
|
|
0, /* rightshift */
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
|
32, /* bitsize */
|
|
FALSE, /* pc_relative */
|
|
0, /* bitpos */
|
|
complain_overflow_dont, /* complain_on_overflow */
|
|
bfd_elf_generic_reloc, /* special_function */
|
|
"R_PPC_TLSLD", /* name */
|
|
FALSE, /* partial_inplace */
|
|
0, /* src_mask */
|
|
0, /* dst_mask */
|
|
FALSE), /* pcrel_offset */
|
|
|
/* Computes the load module index of the load module that contains the
|
/* Computes the load module index of the load module that contains the
|
definition of its TLS sym. */
|
definition of its TLS sym. */
|
HOWTO (R_PPC_DTPMOD32,
|
HOWTO (R_PPC_DTPMOD32,
|
0, /* rightshift */
|
0, /* rightshift */
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
| Line 1264... |
Line 1306... |
0, /* rightshift */
|
0, /* rightshift */
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
16, /* bitsize */
|
16, /* bitsize */
|
FALSE, /* pc_relative */
|
FALSE, /* pc_relative */
|
0, /* bitpos */
|
0, /* bitpos */
|
complain_overflow_bitfield, /* complain_on_overflow */
|
complain_overflow_signed, /* complain_on_overflow */
|
bfd_elf_generic_reloc, /* special_function */
|
bfd_elf_generic_reloc, /* special_function */
|
"R_PPC_EMB_SDAI16", /* name */
|
"R_PPC_EMB_SDAI16", /* name */
|
FALSE, /* partial_inplace */
|
FALSE, /* partial_inplace */
|
0, /* src_mask */
|
0, /* src_mask */
|
0xffff, /* dst_mask */
|
0xffff, /* dst_mask */
|
| Line 1281... |
Line 1323... |
0, /* rightshift */
|
0, /* rightshift */
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
16, /* bitsize */
|
16, /* bitsize */
|
FALSE, /* pc_relative */
|
FALSE, /* pc_relative */
|
0, /* bitpos */
|
0, /* bitpos */
|
complain_overflow_bitfield, /* complain_on_overflow */
|
complain_overflow_signed, /* complain_on_overflow */
|
bfd_elf_generic_reloc, /* special_function */
|
bfd_elf_generic_reloc, /* special_function */
|
"R_PPC_EMB_SDA2I16", /* name */
|
"R_PPC_EMB_SDA2I16", /* name */
|
FALSE, /* partial_inplace */
|
FALSE, /* partial_inplace */
|
0, /* src_mask */
|
0, /* src_mask */
|
0xffff, /* dst_mask */
|
0xffff, /* dst_mask */
|
| Line 1346... |
Line 1388... |
FALSE, /* partial_inplace */
|
FALSE, /* partial_inplace */
|
0, /* src_mask */
|
0, /* src_mask */
|
0xffff, /* dst_mask */
|
0xffff, /* dst_mask */
|
FALSE), /* pcrel_offset */
|
FALSE), /* pcrel_offset */
|
|
|
|
HOWTO (R_PPC_IRELATIVE, /* 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_PPC_IRELATIVE", /* name */
|
|
FALSE, /* partial_inplace */
|
|
0, /* src_mask */
|
|
0xffffffff, /* dst_mask */
|
|
FALSE), /* pcrel_offset */
|
|
|
/* A 16 bit relative relocation. */
|
/* A 16 bit relative relocation. */
|
HOWTO (R_PPC_REL16, /* type */
|
HOWTO (R_PPC_REL16, /* type */
|
0, /* rightshift */
|
0, /* rightshift */
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
16, /* bitsize */
|
16, /* bitsize */
|
| Line 1523... |
Line 1579... |
case BFD_RELOC_HI16_BASEREL: r = R_PPC_SECTOFF_HI; break;
|
case BFD_RELOC_HI16_BASEREL: r = R_PPC_SECTOFF_HI; break;
|
case BFD_RELOC_HI16_S_BASEREL: r = R_PPC_SECTOFF_HA; break;
|
case BFD_RELOC_HI16_S_BASEREL: r = R_PPC_SECTOFF_HA; break;
|
case BFD_RELOC_CTOR: r = R_PPC_ADDR32; break;
|
case BFD_RELOC_CTOR: r = R_PPC_ADDR32; break;
|
case BFD_RELOC_PPC_TOC16: r = R_PPC_TOC16; break;
|
case BFD_RELOC_PPC_TOC16: r = R_PPC_TOC16; break;
|
case BFD_RELOC_PPC_TLS: r = R_PPC_TLS; break;
|
case BFD_RELOC_PPC_TLS: r = R_PPC_TLS; break;
|
|
case BFD_RELOC_PPC_TLSGD: r = R_PPC_TLSGD; break;
|
|
case BFD_RELOC_PPC_TLSLD: r = R_PPC_TLSLD; break;
|
case BFD_RELOC_PPC_DTPMOD: r = R_PPC_DTPMOD32; break;
|
case BFD_RELOC_PPC_DTPMOD: r = R_PPC_DTPMOD32; break;
|
case BFD_RELOC_PPC_TPREL16: r = R_PPC_TPREL16; break;
|
case BFD_RELOC_PPC_TPREL16: r = R_PPC_TPREL16; break;
|
case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC_TPREL16_LO; break;
|
case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC_TPREL16_LO; break;
|
case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC_TPREL16_HI; break;
|
case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC_TPREL16_HI; break;
|
case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC_TPREL16_HA; break;
|
case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC_TPREL16_HA; break;
|
| Line 2289... |
Line 2347... |
free (buffer);
|
free (buffer);
|
|
|
apuinfo_list_finish ();
|
apuinfo_list_finish ();
|
}
|
}
|
|
|
|
static bfd_boolean
|
|
is_nonpic_glink_stub (bfd *abfd, asection *glink, bfd_vma off)
|
|
{
|
|
bfd_byte buf[GLINK_ENTRY_SIZE];
|
|
|
|
if (!bfd_get_section_contents (abfd, glink, buf, off, GLINK_ENTRY_SIZE))
|
|
return FALSE;
|
|
|
|
return ((bfd_get_32 (abfd, buf + 0) & 0xffff0000) == LIS_11
|
|
&& (bfd_get_32 (abfd, buf + 4) & 0xffff0000) == LWZ_11_11
|
|
&& bfd_get_32 (abfd, buf + 8) == MTCTR_11
|
|
&& bfd_get_32 (abfd, buf + 12) == BCTR);
|
|
}
|
|
|
|
static bfd_boolean
|
|
section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
|
|
{
|
|
bfd_vma vma = *(bfd_vma *) ptr;
|
|
return ((section->flags & SEC_ALLOC) != 0
|
|
&& section->vma <= vma
|
|
&& vma < section->vma + section->size);
|
|
}
|
|
|
|
static long
|
|
ppc_elf_get_synthetic_symtab (bfd *abfd, long symcount, asymbol **syms,
|
|
long dynsymcount, asymbol **dynsyms,
|
|
asymbol **ret)
|
|
{
|
|
bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
|
|
asection *plt, *relplt, *dynamic, *glink;
|
|
bfd_vma glink_vma = 0;
|
|
bfd_vma resolv_vma = 0;
|
|
bfd_vma stub_vma;
|
|
asymbol *s;
|
|
arelent *p;
|
|
long count, i;
|
|
size_t size;
|
|
char *names;
|
|
bfd_byte buf[4];
|
|
|
|
*ret = NULL;
|
|
|
|
if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
|
|
return 0;
|
|
|
|
if (dynsymcount <= 0)
|
|
return 0;
|
|
|
|
relplt = bfd_get_section_by_name (abfd, ".rela.plt");
|
|
if (relplt == NULL)
|
|
return 0;
|
|
|
|
plt = bfd_get_section_by_name (abfd, ".plt");
|
|
if (plt == NULL)
|
|
return 0;
|
|
|
|
/* Call common code to handle old-style executable PLTs. */
|
|
if (elf_section_flags (plt) & SHF_EXECINSTR)
|
|
return _bfd_elf_get_synthetic_symtab (abfd, symcount, syms,
|
|
dynsymcount, dynsyms, ret);
|
|
|
|
/* If this object was prelinked, the prelinker stored the address
|
|
of .glink at got[1]. If it wasn't prelinked, got[1] will be zero. */
|
|
dynamic = bfd_get_section_by_name (abfd, ".dynamic");
|
|
if (dynamic != NULL)
|
|
{
|
|
bfd_byte *dynbuf, *extdyn, *extdynend;
|
|
size_t extdynsize;
|
|
void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
|
|
|
|
if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
|
|
return -1;
|
|
|
|
extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
|
|
swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
|
|
|
|
extdyn = dynbuf;
|
|
extdynend = extdyn + dynamic->size;
|
|
for (; extdyn < extdynend; extdyn += extdynsize)
|
|
{
|
|
Elf_Internal_Dyn dyn;
|
|
(*swap_dyn_in) (abfd, extdyn, &dyn);
|
|
|
|
if (dyn.d_tag == DT_NULL)
|
|
break;
|
|
|
|
if (dyn.d_tag == DT_PPC_GOT)
|
|
{
|
|
unsigned int g_o_t = dyn.d_un.d_val;
|
|
asection *got = bfd_get_section_by_name (abfd, ".got");
|
|
if (got != NULL
|
|
&& bfd_get_section_contents (abfd, got, buf,
|
|
g_o_t - got->vma + 4, 4))
|
|
glink_vma = bfd_get_32 (abfd, buf);
|
|
break;
|
|
}
|
|
}
|
|
free (dynbuf);
|
|
}
|
|
|
|
/* Otherwise we read the first plt entry. */
|
|
if (glink_vma == 0)
|
|
{
|
|
if (bfd_get_section_contents (abfd, plt, buf, 0, 4))
|
|
glink_vma = bfd_get_32 (abfd, buf);
|
|
}
|
|
|
|
if (glink_vma == 0)
|
|
return 0;
|
|
|
|
/* The .glink section usually does not survive the final
|
|
link; search for the section (usually .text) where the
|
|
glink stubs now reside. */
|
|
glink = bfd_sections_find_if (abfd, section_covers_vma, &glink_vma);
|
|
if (glink == NULL)
|
|
return 0;
|
|
|
|
/* Determine glink PLT resolver by reading the relative branch
|
|
from the first glink stub. */
|
|
if (bfd_get_section_contents (abfd, glink, buf,
|
|
glink_vma - glink->vma, 4))
|
|
{
|
|
unsigned int insn = bfd_get_32 (abfd, buf);
|
|
|
|
/* The first glink stub may either branch to the resolver ... */
|
|
insn ^= B;
|
|
if ((insn & ~0x3fffffc) == 0)
|
|
resolv_vma = glink_vma + (insn ^ 0x2000000) - 0x2000000;
|
|
|
|
/* ... or fall through a bunch of NOPs. */
|
|
else if ((insn ^ B ^ NOP) == 0)
|
|
for (i = 4;
|
|
bfd_get_section_contents (abfd, glink, buf,
|
|
glink_vma - glink->vma + i, 4);
|
|
i += 4)
|
|
if (bfd_get_32 (abfd, buf) != NOP)
|
|
{
|
|
resolv_vma = glink_vma + i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
count = relplt->size / sizeof (Elf32_External_Rela);
|
|
stub_vma = glink_vma - (bfd_vma) count * 16;
|
|
/* If the stubs are those for -shared/-pie then we might have
|
|
multiple stubs for each plt entry. If that is the case then
|
|
there is no way to associate stubs with their plt entries short
|
|
of figuring out the GOT pointer value used in the stub. */
|
|
if (!is_nonpic_glink_stub (abfd, glink,
|
|
glink_vma - GLINK_ENTRY_SIZE - glink->vma))
|
|
return 0;
|
|
|
|
slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
|
|
if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
|
|
return -1;
|
|
|
|
size = count * sizeof (asymbol);
|
|
p = relplt->relocation;
|
|
for (i = 0; i < count; i++, p++)
|
|
{
|
|
size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
|
|
if (p->addend != 0)
|
|
size += sizeof ("+0x") - 1 + 8;
|
|
}
|
|
|
|
size += sizeof (asymbol) + sizeof ("__glink");
|
|
|
|
if (resolv_vma)
|
|
size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
|
|
|
|
s = *ret = bfd_malloc (size);
|
|
if (s == NULL)
|
|
return -1;
|
|
|
|
names = (char *) (s + count + 1 + (resolv_vma != 0));
|
|
p = relplt->relocation;
|
|
for (i = 0; i < count; i++, p++)
|
|
{
|
|
size_t len;
|
|
|
|
*s = **p->sym_ptr_ptr;
|
|
/* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
|
|
we are defining a symbol, ensure one of them is set. */
|
|
if ((s->flags & BSF_LOCAL) == 0)
|
|
s->flags |= BSF_GLOBAL;
|
|
s->flags |= BSF_SYNTHETIC;
|
|
s->section = glink;
|
|
s->value = stub_vma - glink->vma;
|
|
s->name = names;
|
|
s->udata.p = NULL;
|
|
len = strlen ((*p->sym_ptr_ptr)->name);
|
|
memcpy (names, (*p->sym_ptr_ptr)->name, len);
|
|
names += len;
|
|
if (p->addend != 0)
|
|
{
|
|
memcpy (names, "+0x", sizeof ("+0x") - 1);
|
|
names += sizeof ("+0x") - 1;
|
|
bfd_sprintf_vma (abfd, names, p->addend);
|
|
names += strlen (names);
|
|
}
|
|
memcpy (names, "@plt", sizeof ("@plt"));
|
|
names += sizeof ("@plt");
|
|
++s;
|
|
stub_vma += 16;
|
|
}
|
|
|
|
/* Add a symbol at the start of the glink branch table. */
|
|
memset (s, 0, sizeof *s);
|
|
s->the_bfd = abfd;
|
|
s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
|
|
s->section = glink;
|
|
s->value = glink_vma - glink->vma;
|
|
s->name = names;
|
|
memcpy (names, "__glink", sizeof ("__glink"));
|
|
names += sizeof ("__glink");
|
|
s++;
|
|
count++;
|
|
|
|
if (resolv_vma)
|
|
{
|
|
/* Add a symbol for the glink PLT resolver. */
|
|
memset (s, 0, sizeof *s);
|
|
s->the_bfd = abfd;
|
|
s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
|
|
s->section = glink;
|
|
s->value = resolv_vma - glink->vma;
|
|
s->name = names;
|
|
memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
|
|
names += sizeof ("__glink_PLTresolve");
|
|
s++;
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
/* The following functions are specific to the ELF linker, while
|
/* The following functions are specific to the ELF linker, while
|
functions above are used generally. They appear in this file more
|
functions above are used generally. They appear in this file more
|
or less in the order in which they are called. eg.
|
or less in the order in which they are called. eg.
|
ppc_elf_check_relocs is called early in the link process,
|
ppc_elf_check_relocs is called early in the link process,
|
ppc_elf_finish_dynamic_sections is one of the last functions
|
ppc_elf_finish_dynamic_sections is one of the last functions
|
| Line 2317... |
Line 2611... |
/* Number of pc-relative relocs copied for the input section. */
|
/* Number of pc-relative relocs copied for the input section. */
|
bfd_size_type pc_count;
|
bfd_size_type pc_count;
|
};
|
};
|
|
|
/* Track PLT entries needed for a given symbol. We might need more
|
/* Track PLT entries needed for a given symbol. We might need more
|
than one glink entry per symbol. */
|
than one glink entry per symbol when generating a pic binary. */
|
struct plt_entry
|
struct plt_entry
|
{
|
{
|
struct plt_entry *next;
|
struct plt_entry *next;
|
|
|
/* -fPIC uses multiple GOT sections, one per file, called ".got2".
|
/* -fPIC uses multiple GOT sections, one per file, called ".got2".
|
This field stores the offset into .got2 used to initialise the
|
This field stores the offset into .got2 used to initialise the
|
GOT pointer reg. It will always be at least 32768 (and for
|
GOT pointer reg. It will always be at least 32768. (Current
|
current gcc this is the only offset used). */
|
gcc always uses an offset of 32768, but ld -r will pack .got2
|
|
sections together resulting in larger offsets). */
|
bfd_vma addend;
|
bfd_vma addend;
|
|
|
/* The .got2 section. */
|
/* The .got2 section. */
|
asection *sec;
|
asection *sec;
|
|
|
| Line 2342... |
Line 2637... |
|
|
/* .glink stub offset. */
|
/* .glink stub offset. */
|
bfd_vma glink_offset;
|
bfd_vma glink_offset;
|
};
|
};
|
|
|
/* Of those relocs that might be copied as dynamic relocs, this macro
|
/* Of those relocs that might be copied as dynamic relocs, this function
|
selects those that must be copied when linking a shared library,
|
selects those that must be copied when linking a shared library,
|
even when the symbol is local. */
|
even when the symbol is local. */
|
|
|
#define MUST_BE_DYN_RELOC(RTYPE) \
|
static int
|
((RTYPE) != R_PPC_REL24 \
|
must_be_dyn_reloc (struct bfd_link_info *info,
|
&& (RTYPE) != R_PPC_REL14 \
|
enum elf_ppc_reloc_type r_type)
|
&& (RTYPE) != R_PPC_REL14_BRTAKEN \
|
{
|
&& (RTYPE) != R_PPC_REL14_BRNTAKEN \
|
switch (r_type)
|
&& (RTYPE) != R_PPC_REL32)
|
{
|
|
default:
|
|
return 1;
|
|
|
|
case R_PPC_REL24:
|
|
case R_PPC_REL14:
|
|
case R_PPC_REL14_BRTAKEN:
|
|
case R_PPC_REL14_BRNTAKEN:
|
|
case R_PPC_REL32:
|
|
return 0;
|
|
|
|
case R_PPC_TPREL32:
|
|
case R_PPC_TPREL16:
|
|
case R_PPC_TPREL16_LO:
|
|
case R_PPC_TPREL16_HI:
|
|
case R_PPC_TPREL16_HA:
|
|
return !info->executable;
|
|
}
|
|
}
|
|
|
/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
|
/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
|
copying dynamic variables from a shared lib into an app's dynbss
|
copying dynamic variables from a shared lib into an app's dynbss
|
section, and instead use a dynamic relocation to point into the
|
section, and instead use a dynamic relocation to point into the
|
shared lib. */
|
shared lib. */
|
| Line 2384... |
Line 2697... |
#define TLS_LD 2 /* LD reloc. */
|
#define TLS_LD 2 /* LD reloc. */
|
#define TLS_TPREL 4 /* TPREL reloc, => IE. */
|
#define TLS_TPREL 4 /* TPREL reloc, => IE. */
|
#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
|
#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
|
#define TLS_TLS 16 /* Any TLS reloc. */
|
#define TLS_TLS 16 /* Any TLS reloc. */
|
#define TLS_TPRELGD 32 /* TPREL reloc resulting from GD->IE. */
|
#define TLS_TPRELGD 32 /* TPREL reloc resulting from GD->IE. */
|
|
#define PLT_IFUNC 64 /* STT_GNU_IFUNC. */
|
char tls_mask;
|
char tls_mask;
|
|
|
/* Nonzero if we have seen a small data relocation referring to this
|
/* Nonzero if we have seen a small data relocation referring to this
|
symbol. */
|
symbol. */
|
unsigned char has_sda_refs;
|
unsigned char has_sda_refs;
|
| Line 2405... |
Line 2719... |
asection *got;
|
asection *got;
|
asection *relgot;
|
asection *relgot;
|
asection *glink;
|
asection *glink;
|
asection *plt;
|
asection *plt;
|
asection *relplt;
|
asection *relplt;
|
|
asection *iplt;
|
|
asection *reliplt;
|
asection *dynbss;
|
asection *dynbss;
|
asection *relbss;
|
asection *relbss;
|
asection *dynsbss;
|
asection *dynsbss;
|
asection *relsbss;
|
asection *relsbss;
|
elf_linker_section_t sdata[2];
|
elf_linker_section_t sdata[2];
|
| Line 2418... |
Line 2734... |
asection *srelplt2;
|
asection *srelplt2;
|
|
|
/* The .got.plt section (VxWorks only)*/
|
/* The .got.plt section (VxWorks only)*/
|
asection *sgotplt;
|
asection *sgotplt;
|
|
|
/* Shortcut to .__tls_get_addr. */
|
/* Shortcut to __tls_get_addr. */
|
struct elf_link_hash_entry *tls_get_addr;
|
struct elf_link_hash_entry *tls_get_addr;
|
|
|
/* The bfd that forced an old-style PLT. */
|
/* The bfd that forced an old-style PLT. */
|
bfd *old_bfd;
|
bfd *old_bfd;
|
|
|
| Line 2430... |
Line 2746... |
union {
|
union {
|
bfd_signed_vma refcount;
|
bfd_signed_vma refcount;
|
bfd_vma offset;
|
bfd_vma offset;
|
} tlsld_got;
|
} tlsld_got;
|
|
|
/* Offset of PltResolve function in glink. */
|
/* Offset of branch table to PltResolve function in glink. */
|
bfd_vma glink_pltresolve;
|
bfd_vma glink_pltresolve;
|
|
|
/* Size of reserved GOT entries. */
|
/* Size of reserved GOT entries. */
|
unsigned int got_header_size;
|
unsigned int got_header_size;
|
/* Non-zero if allocating the header left a gap. */
|
/* Non-zero if allocating the header left a gap. */
|
| Line 2444... |
Line 2760... |
enum ppc_elf_plt_type plt_type;
|
enum ppc_elf_plt_type plt_type;
|
|
|
/* Set if we should emit symbols for stubs. */
|
/* Set if we should emit symbols for stubs. */
|
unsigned int emit_stub_syms:1;
|
unsigned int emit_stub_syms:1;
|
|
|
|
/* Set if __tls_get_addr optimization should not be done. */
|
|
unsigned int no_tls_get_addr_opt:1;
|
|
|
/* True if the target system is VxWorks. */
|
/* True if the target system is VxWorks. */
|
unsigned int is_vxworks:1;
|
unsigned int is_vxworks:1;
|
|
|
/* The size of PLT entries. */
|
/* The size of PLT entries. */
|
int plt_entry_size;
|
int plt_entry_size;
|
/* The distance between adjacent PLT slots. */
|
/* The distance between adjacent PLT slots. */
|
int plt_slot_size;
|
int plt_slot_size;
|
/* The size of the first PLT entry. */
|
/* The size of the first PLT entry. */
|
int plt_initial_entry_size;
|
int plt_initial_entry_size;
|
|
|
/* Small local sym to section mapping cache. */
|
/* Small local sym cache. */
|
struct sym_sec_cache sym_sec;
|
struct sym_cache sym_cache;
|
};
|
};
|
|
|
/* Get the PPC ELF linker hash table from a link_info structure. */
|
/* Get the PPC ELF linker hash table from a link_info structure. */
|
|
|
#define ppc_elf_hash_table(p) \
|
#define ppc_elf_hash_table(p) \
|
| Line 2564... |
Line 2883... |
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
|
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
|
if (!bfd_set_section_flags (abfd, s, flags))
|
if (!bfd_set_section_flags (abfd, s, flags))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
|
htab->relgot = bfd_get_section_by_name (abfd, ".rela.got");
|
| SEC_LINKER_CREATED | SEC_READONLY);
|
if (!htab->relgot)
|
htab->relgot = bfd_make_section_with_flags (abfd, ".rela.got", flags);
|
abort ();
|
if (!htab->relgot
|
|
|| ! bfd_set_section_alignment (abfd, htab->relgot, 2))
|
return TRUE;
|
|
}
|
|
|
|
static bfd_boolean
|
|
ppc_elf_create_glink (bfd *abfd, struct bfd_link_info *info)
|
|
{
|
|
struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
|
|
asection *s;
|
|
flagword flags;
|
|
|
|
flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS
|
|
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
|
|
s = bfd_make_section_anyway_with_flags (abfd, ".glink", flags);
|
|
htab->glink = s;
|
|
if (s == NULL
|
|
|| !bfd_set_section_alignment (abfd, s, 4))
|
|
return FALSE;
|
|
|
|
flags = SEC_ALLOC | SEC_LINKER_CREATED;
|
|
s = bfd_make_section_anyway_with_flags (abfd, ".iplt", flags);
|
|
htab->iplt = s;
|
|
if (s == NULL
|
|
|| !bfd_set_section_alignment (abfd, s, 4))
|
return FALSE;
|
return FALSE;
|
|
|
|
flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
|
|
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
|
|
s = bfd_make_section_with_flags (abfd, ".rela.iplt", flags);
|
|
htab->reliplt = s;
|
|
if (s == NULL
|
|
|| ! bfd_set_section_alignment (abfd, s, 2))
|
|
return FALSE;
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* We have to create .dynsbss and .rela.sbss here so that they get mapped
|
/* We have to create .dynsbss and .rela.sbss here so that they get mapped
|
to output sections (just like _bfd_elf_create_dynamic_sections has
|
to output sections (just like _bfd_elf_create_dynamic_sections has
|
| Line 2594... |
Line 2942... |
return FALSE;
|
return FALSE;
|
|
|
if (!_bfd_elf_create_dynamic_sections (abfd, info))
|
if (!_bfd_elf_create_dynamic_sections (abfd, info))
|
return FALSE;
|
return FALSE;
|
|
|
flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
|
if (htab->glink == NULL
|
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
|
&& !ppc_elf_create_glink (abfd, info))
|
|
|
s = bfd_make_section_anyway_with_flags (abfd, ".glink", flags | SEC_CODE);
|
|
htab->glink = s;
|
|
if (s == NULL
|
|
|| !bfd_set_section_alignment (abfd, s, 4))
|
|
return FALSE;
|
return FALSE;
|
|
|
htab->dynbss = bfd_get_section_by_name (abfd, ".dynbss");
|
htab->dynbss = bfd_get_section_by_name (abfd, ".dynbss");
|
s = bfd_make_section_with_flags (abfd, ".dynsbss",
|
s = bfd_make_section_with_flags (abfd, ".dynsbss",
|
SEC_ALLOC | SEC_LINKER_CREATED);
|
SEC_ALLOC | SEC_LINKER_CREATED);
|
| Line 2613... |
Line 2956... |
return FALSE;
|
return FALSE;
|
|
|
if (! info->shared)
|
if (! info->shared)
|
{
|
{
|
htab->relbss = bfd_get_section_by_name (abfd, ".rela.bss");
|
htab->relbss = bfd_get_section_by_name (abfd, ".rela.bss");
|
|
flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
|
|
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
|
s = bfd_make_section_with_flags (abfd, ".rela.sbss", flags);
|
s = bfd_make_section_with_flags (abfd, ".rela.sbss", flags);
|
htab->relsbss = s;
|
htab->relsbss = s;
|
if (s == NULL
|
if (s == NULL
|
|| ! bfd_set_section_alignment (abfd, s, 2))
|
|| ! bfd_set_section_alignment (abfd, s, 2))
|
return FALSE;
|
return FALSE;
|
| Line 2786... |
Line 3131... |
|
|
*secp = htab->sbss;
|
*secp = htab->sbss;
|
*valp = sym->st_size;
|
*valp = sym->st_size;
|
}
|
}
|
|
|
|
if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
|
|
elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
create_sdata_sym (struct ppc_elf_link_hash_table *htab,
|
create_sdata_sym (struct bfd_link_info *info, elf_linker_section_t *lsect)
|
elf_linker_section_t *lsect)
|
|
{
|
{
|
|
struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
|
|
|
lsect->sym = elf_link_hash_lookup (&htab->elf, lsect->sym_name,
|
lsect->sym = elf_link_hash_lookup (&htab->elf, lsect->sym_name,
|
TRUE, FALSE, TRUE);
|
TRUE, FALSE, TRUE);
|
if (lsect->sym == NULL)
|
if (lsect->sym == NULL)
|
return FALSE;
|
return FALSE;
|
if (lsect->sym->root.type == bfd_link_hash_new)
|
if (lsect->sym->root.type == bfd_link_hash_new)
|
lsect->sym->non_elf = 0;
|
lsect->sym->non_elf = 0;
|
lsect->sym->ref_regular = 1;
|
lsect->sym->ref_regular = 1;
|
|
_bfd_elf_link_hash_hide_symbol (info, lsect->sym, TRUE);
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Create a special linker section. */
|
/* Create a special linker section. */
|
|
|
| Line 2829... |
Line 3179... |
if (s == NULL
|
if (s == NULL
|
|| !bfd_set_section_alignment (htab->elf.dynobj, s, 2))
|
|| !bfd_set_section_alignment (htab->elf.dynobj, s, 2))
|
return FALSE;
|
return FALSE;
|
lsect->section = s;
|
lsect->section = s;
|
|
|
return create_sdata_sym (htab, lsect);
|
return create_sdata_sym (info, lsect);
|
}
|
}
|
|
|
/* Find a linker generated pointer with a given addend and type. */
|
/* Find a linker generated pointer with a given addend and type. */
|
|
|
static elf_linker_section_pointers_t *
|
static elf_linker_section_pointers_t *
|
| Line 2934... |
Line 3284... |
#endif
|
#endif
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
static bfd_boolean
|
static struct plt_entry **
|
update_local_sym_info (bfd *abfd,
|
update_local_sym_info (bfd *abfd,
|
Elf_Internal_Shdr *symtab_hdr,
|
Elf_Internal_Shdr *symtab_hdr,
|
unsigned long r_symndx,
|
unsigned long r_symndx,
|
int tls_type)
|
int tls_type)
|
{
|
{
|
bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
|
bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
|
|
struct plt_entry **local_plt;
|
char *local_got_tls_masks;
|
char *local_got_tls_masks;
|
|
|
if (local_got_refcounts == NULL)
|
if (local_got_refcounts == NULL)
|
{
|
{
|
bfd_size_type size = symtab_hdr->sh_info;
|
bfd_size_type size = symtab_hdr->sh_info;
|
|
|
size *= sizeof (*local_got_refcounts) + sizeof (*local_got_tls_masks);
|
size *= (sizeof (*local_got_refcounts)
|
|
+ sizeof (*local_plt)
|
|
+ sizeof (*local_got_tls_masks));
|
local_got_refcounts = bfd_zalloc (abfd, size);
|
local_got_refcounts = bfd_zalloc (abfd, size);
|
if (local_got_refcounts == NULL)
|
if (local_got_refcounts == NULL)
|
return FALSE;
|
return NULL;
|
elf_local_got_refcounts (abfd) = local_got_refcounts;
|
elf_local_got_refcounts (abfd) = local_got_refcounts;
|
}
|
}
|
|
|
local_got_refcounts[r_symndx] += 1;
|
local_plt = (struct plt_entry **) (local_got_refcounts + symtab_hdr->sh_info);
|
local_got_tls_masks = (char *) (local_got_refcounts + symtab_hdr->sh_info);
|
local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
|
local_got_tls_masks[r_symndx] |= tls_type;
|
local_got_tls_masks[r_symndx] |= tls_type;
|
return TRUE;
|
if (tls_type != PLT_IFUNC)
|
|
local_got_refcounts[r_symndx] += 1;
|
|
return local_plt + r_symndx;
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
update_plt_info (bfd *abfd, struct elf_link_hash_entry *h,
|
update_plt_info (bfd *abfd, struct plt_entry **plist,
|
asection *sec, bfd_vma addend)
|
asection *sec, bfd_vma addend)
|
{
|
{
|
struct plt_entry *ent;
|
struct plt_entry *ent;
|
|
|
if (addend < 32768)
|
if (addend < 32768)
|
sec = NULL;
|
sec = NULL;
|
for (ent = h->plt.plist; ent != NULL; ent = ent->next)
|
for (ent = *plist; ent != NULL; ent = ent->next)
|
if (ent->sec == sec && ent->addend == addend)
|
if (ent->sec == sec && ent->addend == addend)
|
break;
|
break;
|
if (ent == NULL)
|
if (ent == NULL)
|
{
|
{
|
bfd_size_type amt = sizeof (*ent);
|
bfd_size_type amt = sizeof (*ent);
|
ent = bfd_alloc (abfd, amt);
|
ent = bfd_alloc (abfd, amt);
|
if (ent == NULL)
|
if (ent == NULL)
|
return FALSE;
|
return FALSE;
|
ent->next = h->plt.plist;
|
ent->next = *plist;
|
ent->sec = sec;
|
ent->sec = sec;
|
ent->addend = addend;
|
ent->addend = addend;
|
ent->plt.refcount = 0;
|
ent->plt.refcount = 0;
|
h->plt.plist = ent;
|
*plist = ent;
|
}
|
}
|
ent->plt.refcount += 1;
|
ent->plt.refcount += 1;
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
static struct plt_entry *
|
static struct plt_entry *
|
find_plt_ent (struct elf_link_hash_entry *h, asection *sec, bfd_vma addend)
|
find_plt_ent (struct plt_entry **plist, asection *sec, bfd_vma addend)
|
{
|
{
|
struct plt_entry *ent;
|
struct plt_entry *ent;
|
|
|
if (addend < 32768)
|
if (addend < 32768)
|
sec = NULL;
|
sec = NULL;
|
for (ent = h->plt.plist; ent != NULL; ent = ent->next)
|
for (ent = *plist; ent != NULL; ent = ent->next)
|
if (ent->sec == sec && ent->addend == addend)
|
if (ent->sec == sec && ent->addend == addend)
|
break;
|
break;
|
return ent;
|
return ent;
|
}
|
}
|
|
|
|
static bfd_boolean
|
|
is_branch_reloc (enum elf_ppc_reloc_type r_type)
|
|
{
|
|
return (r_type == R_PPC_PLTREL24
|
|
|| r_type == R_PPC_LOCAL24PC
|
|
|| r_type == R_PPC_REL24
|
|
|| r_type == R_PPC_REL14
|
|
|| r_type == R_PPC_REL14_BRTAKEN
|
|
|| r_type == R_PPC_REL14_BRNTAKEN
|
|
|| r_type == R_PPC_ADDR24
|
|
|| r_type == R_PPC_ADDR14
|
|
|| r_type == R_PPC_ADDR14_BRTAKEN
|
|
|| r_type == R_PPC_ADDR14_BRNTAKEN);
|
|
}
|
|
|
static void
|
static void
|
bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type)
|
bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type)
|
{
|
{
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B: relocation %s cannot be used when making a shared object"),
|
(_("%B: relocation %s cannot be used when making a shared object"),
|
| Line 3026... |
Line 3396... |
Elf_Internal_Shdr *symtab_hdr;
|
Elf_Internal_Shdr *symtab_hdr;
|
struct elf_link_hash_entry **sym_hashes;
|
struct elf_link_hash_entry **sym_hashes;
|
const Elf_Internal_Rela *rel;
|
const Elf_Internal_Rela *rel;
|
const Elf_Internal_Rela *rel_end;
|
const Elf_Internal_Rela *rel_end;
|
asection *got2, *sreloc;
|
asection *got2, *sreloc;
|
|
struct elf_link_hash_entry *tga;
|
|
|
if (info->relocatable)
|
if (info->relocatable)
|
return TRUE;
|
return TRUE;
|
|
|
/* Don't do anything special with non-loaded, non-alloced sections.
|
/* Don't do anything special with non-loaded, non-alloced sections.
|
| Line 3051... |
Line 3422... |
/* Initialize howto table if not already done. */
|
/* Initialize howto table if not already done. */
|
if (!ppc_elf_howto_table[R_PPC_ADDR32])
|
if (!ppc_elf_howto_table[R_PPC_ADDR32])
|
ppc_elf_howto_init ();
|
ppc_elf_howto_init ();
|
|
|
htab = ppc_elf_hash_table (info);
|
htab = ppc_elf_hash_table (info);
|
|
if (htab->glink == NULL)
|
|
{
|
|
if (htab->elf.dynobj == NULL)
|
|
htab->elf.dynobj = abfd;
|
|
if (!ppc_elf_create_glink (htab->elf.dynobj, info))
|
|
return FALSE;
|
|
}
|
|
tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
|
|
FALSE, FALSE, TRUE);
|
symtab_hdr = &elf_symtab_hdr (abfd);
|
symtab_hdr = &elf_symtab_hdr (abfd);
|
sym_hashes = elf_sym_hashes (abfd);
|
sym_hashes = elf_sym_hashes (abfd);
|
got2 = bfd_get_section_by_name (abfd, ".got2");
|
got2 = bfd_get_section_by_name (abfd, ".got2");
|
sreloc = NULL;
|
sreloc = NULL;
|
|
|
| Line 3062... |
Line 3442... |
for (rel = relocs; rel < rel_end; rel++)
|
for (rel = relocs; rel < rel_end; rel++)
|
{
|
{
|
unsigned long r_symndx;
|
unsigned long r_symndx;
|
enum elf_ppc_reloc_type r_type;
|
enum elf_ppc_reloc_type r_type;
|
struct elf_link_hash_entry *h;
|
struct elf_link_hash_entry *h;
|
int tls_type = 0;
|
int tls_type;
|
|
struct plt_entry **ifunc;
|
|
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
if (r_symndx < symtab_hdr->sh_info)
|
if (r_symndx < symtab_hdr->sh_info)
|
h = NULL;
|
h = NULL;
|
else
|
else
|
| Line 3089... |
Line 3470... |
if (!ppc_elf_create_got (htab->elf.dynobj, info))
|
if (!ppc_elf_create_got (htab->elf.dynobj, info))
|
return FALSE;
|
return FALSE;
|
BFD_ASSERT (h == htab->elf.hgot);
|
BFD_ASSERT (h == htab->elf.hgot);
|
}
|
}
|
|
|
|
tls_type = 0;
|
|
ifunc = NULL;
|
r_type = ELF32_R_TYPE (rel->r_info);
|
r_type = ELF32_R_TYPE (rel->r_info);
|
|
if (!htab->is_vxworks)
|
|
{
|
|
if (h != NULL)
|
|
{
|
|
if (h->type == STT_GNU_IFUNC)
|
|
ifunc = &h->plt.plist;
|
|
}
|
|
else
|
|
{
|
|
Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
|
|
abfd, r_symndx);
|
|
if (isym == NULL)
|
|
return FALSE;
|
|
|
|
if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
|
|
&& (!info->shared
|
|
|| is_branch_reloc (r_type)))
|
|
{
|
|
bfd_vma addend;
|
|
|
|
ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
|
|
PLT_IFUNC);
|
|
if (ifunc == NULL)
|
|
return FALSE;
|
|
|
|
/* STT_GNU_IFUNC symbols must have a PLT entry;
|
|
In a non-pie executable even when there are
|
|
no plt calls. */
|
|
addend = 0;
|
|
if (r_type == R_PPC_PLTREL24)
|
|
{
|
|
ppc_elf_tdata (abfd)->makes_plt_call = 1;
|
|
if (info->shared)
|
|
addend = rel->r_addend;
|
|
}
|
|
if (!update_plt_info (abfd, ifunc, got2, addend))
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!htab->is_vxworks
|
|
&& is_branch_reloc (r_type)
|
|
&& h != NULL
|
|
&& h == tga)
|
|
{
|
|
if (rel != relocs
|
|
&& (ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSGD
|
|
|| ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSLD))
|
|
/* We have a new-style __tls_get_addr call with a marker
|
|
reloc. */
|
|
;
|
|
else
|
|
/* Mark this section as having an old-style call. */
|
|
sec->has_tls_get_addr_call = 1;
|
|
}
|
|
|
switch (r_type)
|
switch (r_type)
|
{
|
{
|
|
case R_PPC_TLSGD:
|
|
case R_PPC_TLSLD:
|
|
/* These special tls relocs tie a call to __tls_get_addr with
|
|
its parameter symbol. */
|
|
break;
|
|
|
case R_PPC_GOT_TLSLD16:
|
case R_PPC_GOT_TLSLD16:
|
case R_PPC_GOT_TLSLD16_LO:
|
case R_PPC_GOT_TLSLD16_LO:
|
case R_PPC_GOT_TLSLD16_HI:
|
case R_PPC_GOT_TLSLD16_HI:
|
case R_PPC_GOT_TLSLD16_HA:
|
case R_PPC_GOT_TLSLD16_HA:
|
tls_type = TLS_TLS | TLS_LD;
|
tls_type = TLS_TLS | TLS_LD;
|
| Line 3110... |
Line 3556... |
|
|
case R_PPC_GOT_TPREL16:
|
case R_PPC_GOT_TPREL16:
|
case R_PPC_GOT_TPREL16_LO:
|
case R_PPC_GOT_TPREL16_LO:
|
case R_PPC_GOT_TPREL16_HI:
|
case R_PPC_GOT_TPREL16_HI:
|
case R_PPC_GOT_TPREL16_HA:
|
case R_PPC_GOT_TPREL16_HA:
|
if (info->shared)
|
if (!info->executable)
|
info->flags |= DF_STATIC_TLS;
|
info->flags |= DF_STATIC_TLS;
|
tls_type = TLS_TLS | TLS_TPREL;
|
tls_type = TLS_TLS | TLS_TPREL;
|
goto dogottls;
|
goto dogottls;
|
|
|
case R_PPC_GOT_DTPREL16:
|
case R_PPC_GOT_DTPREL16:
|
| Line 3146... |
Line 3592... |
}
|
}
|
else
|
else
|
/* This is a global offset table entry for a local symbol. */
|
/* This is a global offset table entry for a local symbol. */
|
if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type))
|
if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type))
|
return FALSE;
|
return FALSE;
|
|
|
|
/* We may also need a plt entry if the symbol turns out to be
|
|
an ifunc. */
|
|
if (h != NULL && !info->shared)
|
|
{
|
|
if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
|
|
return FALSE;
|
|
}
|
break;
|
break;
|
|
|
/* Indirect .sdata relocation. */
|
/* Indirect .sdata relocation. */
|
case R_PPC_EMB_SDAI16:
|
case R_PPC_EMB_SDAI16:
|
if (info->shared)
|
if (info->shared)
|
| Line 3191... |
Line 3645... |
h->non_got_ref = TRUE;
|
h->non_got_ref = TRUE;
|
}
|
}
|
break;
|
break;
|
|
|
case R_PPC_SDAREL16:
|
case R_PPC_SDAREL16:
|
if (info->shared)
|
|
{
|
|
bad_shared_reloc (abfd, r_type);
|
|
return FALSE;
|
|
}
|
|
if (htab->sdata[0].sym == NULL
|
if (htab->sdata[0].sym == NULL
|
&& !create_sdata_sym (htab, &htab->sdata[0]))
|
&& !create_sdata_sym (info, &htab->sdata[0]))
|
return FALSE;
|
return FALSE;
|
if (h != NULL)
|
if (h != NULL)
|
{
|
{
|
ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
|
ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
|
h->non_got_ref = TRUE;
|
h->non_got_ref = TRUE;
|
| Line 3213... |
Line 3662... |
{
|
{
|
bad_shared_reloc (abfd, r_type);
|
bad_shared_reloc (abfd, r_type);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
if (htab->sdata[1].sym == NULL
|
if (htab->sdata[1].sym == NULL
|
&& !create_sdata_sym (htab, &htab->sdata[1]))
|
&& !create_sdata_sym (info, &htab->sdata[1]))
|
return FALSE;
|
return FALSE;
|
if (h != NULL)
|
if (h != NULL)
|
{
|
{
|
ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
|
ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
|
h->non_got_ref = TRUE;
|
h->non_got_ref = TRUE;
|
| Line 3230... |
Line 3679... |
{
|
{
|
bad_shared_reloc (abfd, r_type);
|
bad_shared_reloc (abfd, r_type);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
if (htab->sdata[0].sym == NULL
|
if (htab->sdata[0].sym == NULL
|
&& !create_sdata_sym (htab, &htab->sdata[0]))
|
&& !create_sdata_sym (info, &htab->sdata[0]))
|
return FALSE;
|
return FALSE;
|
if (htab->sdata[1].sym == NULL
|
if (htab->sdata[1].sym == NULL
|
&& !create_sdata_sym (htab, &htab->sdata[1]))
|
&& !create_sdata_sym (info, &htab->sdata[1]))
|
return FALSE;
|
return FALSE;
|
if (h != NULL)
|
if (h != NULL)
|
{
|
{
|
ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
|
ppc_elf_hash_entry (h)->has_sda_refs = TRUE;
|
h->non_got_ref = TRUE;
|
h->non_got_ref = TRUE;
|
| Line 3256... |
Line 3705... |
}
|
}
|
if (h != NULL)
|
if (h != NULL)
|
h->non_got_ref = TRUE;
|
h->non_got_ref = TRUE;
|
break;
|
break;
|
|
|
case R_PPC_PLT32:
|
|
case R_PPC_PLTREL24:
|
case R_PPC_PLTREL24:
|
|
if (h == NULL)
|
|
break;
|
|
/* Fall through */
|
|
case R_PPC_PLT32:
|
case R_PPC_PLTREL32:
|
case R_PPC_PLTREL32:
|
case R_PPC_PLT16_LO:
|
case R_PPC_PLT16_LO:
|
case R_PPC_PLT16_HI:
|
case R_PPC_PLT16_HI:
|
case R_PPC_PLT16_HA:
|
case R_PPC_PLT16_HA:
|
#ifdef DEBUG
|
#ifdef DEBUG
|
| Line 3291... |
Line 3743... |
bfd_vma addend = 0;
|
bfd_vma addend = 0;
|
|
|
if (r_type == R_PPC_PLTREL24)
|
if (r_type == R_PPC_PLTREL24)
|
{
|
{
|
ppc_elf_tdata (abfd)->makes_plt_call = 1;
|
ppc_elf_tdata (abfd)->makes_plt_call = 1;
|
|
if (info->shared)
|
addend = rel->r_addend;
|
addend = rel->r_addend;
|
}
|
}
|
h->needs_plt = 1;
|
h->needs_plt = 1;
|
if (!update_plt_info (abfd, h, got2, addend))
|
if (!update_plt_info (abfd, &h->plt.plist, got2, addend))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
break;
|
break;
|
|
|
/* The following relocations don't need to propagate the
|
/* The following relocations don't need to propagate the
|
| Line 3325... |
Line 3778... |
/* These are just markers. */
|
/* These are just markers. */
|
case R_PPC_TLS:
|
case R_PPC_TLS:
|
case R_PPC_EMB_MRKREF:
|
case R_PPC_EMB_MRKREF:
|
case R_PPC_NONE:
|
case R_PPC_NONE:
|
case R_PPC_max:
|
case R_PPC_max:
|
|
case R_PPC_RELAX:
|
|
case R_PPC_RELAX_PLT:
|
|
case R_PPC_RELAX_PLTREL24:
|
break;
|
break;
|
|
|
/* These should only appear in dynamic objects. */
|
/* These should only appear in dynamic objects. */
|
case R_PPC_COPY:
|
case R_PPC_COPY:
|
case R_PPC_GLOB_DAT:
|
case R_PPC_GLOB_DAT:
|
case R_PPC_JMP_SLOT:
|
case R_PPC_JMP_SLOT:
|
case R_PPC_RELATIVE:
|
case R_PPC_RELATIVE:
|
|
case R_PPC_IRELATIVE:
|
break;
|
break;
|
|
|
/* These aren't handled yet. We'll report an error later. */
|
/* These aren't handled yet. We'll report an error later. */
|
case R_PPC_ADDR30:
|
case R_PPC_ADDR30:
|
case R_PPC_EMB_RELSEC16:
|
case R_PPC_EMB_RELSEC16:
|
| Line 3345... |
Line 3802... |
case R_PPC_EMB_BIT_FLD:
|
case R_PPC_EMB_BIT_FLD:
|
break;
|
break;
|
|
|
/* This refers only to functions defined in the shared library. */
|
/* This refers only to functions defined in the shared library. */
|
case R_PPC_LOCAL24PC:
|
case R_PPC_LOCAL24PC:
|
if (h && h == htab->elf.hgot && htab->plt_type == PLT_UNSET)
|
if (h != NULL && h == htab->elf.hgot && htab->plt_type == PLT_UNSET)
|
{
|
{
|
htab->plt_type = PLT_OLD;
|
htab->plt_type = PLT_OLD;
|
htab->old_bfd = abfd;
|
htab->old_bfd = abfd;
|
}
|
}
|
break;
|
break;
|
| Line 3370... |
Line 3827... |
return FALSE;
|
return FALSE;
|
break;
|
break;
|
|
|
/* We shouldn't really be seeing these. */
|
/* We shouldn't really be seeing these. */
|
case R_PPC_TPREL32:
|
case R_PPC_TPREL32:
|
if (info->shared)
|
case R_PPC_TPREL16:
|
|
case R_PPC_TPREL16_LO:
|
|
case R_PPC_TPREL16_HI:
|
|
case R_PPC_TPREL16_HA:
|
|
if (!info->executable)
|
info->flags |= DF_STATIC_TLS;
|
info->flags |= DF_STATIC_TLS;
|
goto dodyn;
|
goto dodyn;
|
|
|
/* Nor these. */
|
/* Nor these. */
|
case R_PPC_DTPMOD32:
|
case R_PPC_DTPMOD32:
|
case R_PPC_DTPREL32:
|
case R_PPC_DTPREL32:
|
goto dodyn;
|
goto dodyn;
|
|
|
case R_PPC_TPREL16:
|
|
case R_PPC_TPREL16_LO:
|
|
case R_PPC_TPREL16_HI:
|
|
case R_PPC_TPREL16_HA:
|
|
if (info->shared)
|
|
info->flags |= DF_STATIC_TLS;
|
|
goto dodyn;
|
|
|
|
case R_PPC_REL32:
|
case R_PPC_REL32:
|
if (h == NULL
|
if (h == NULL
|
&& got2 != NULL
|
&& got2 != NULL
|
&& (sec->flags & SEC_CODE) != 0
|
&& (sec->flags & SEC_CODE) != 0
|
&& (info->shared || info->pie)
|
&& info->shared
|
&& htab->plt_type == PLT_UNSET)
|
&& htab->plt_type == PLT_UNSET)
|
{
|
{
|
/* Old -fPIC gcc code has .long LCTOC1-LCFx just before
|
/* Old -fPIC gcc code has .long LCTOC1-LCFx just before
|
the start of a function, which assembles to a REL32
|
the start of a function, which assembles to a REL32
|
reference to .got2. If we detect one of these, then
|
reference to .got2. If we detect one of these, then
|
force the old PLT layout because the linker cannot
|
force the old PLT layout because the linker cannot
|
reliably deduce the GOT pointer value needed for
|
reliably deduce the GOT pointer value needed for
|
PLT call stubs. */
|
PLT call stubs. */
|
asection *s;
|
asection *s;
|
|
Elf_Internal_Sym *isym;
|
|
|
|
isym = bfd_sym_from_r_symndx (&htab->sym_cache,
|
|
abfd, r_symndx);
|
|
if (isym == NULL)
|
|
return FALSE;
|
|
|
s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
|
s = bfd_section_from_elf_index (abfd, isym->st_shndx);
|
r_symndx);
|
|
if (s == got2)
|
if (s == got2)
|
{
|
{
|
htab->plt_type = PLT_OLD;
|
htab->plt_type = PLT_OLD;
|
htab->old_bfd = abfd;
|
htab->old_bfd = abfd;
|
}
|
}
|
| Line 3425... |
Line 3883... |
case R_PPC_UADDR16:
|
case R_PPC_UADDR16:
|
if (h != NULL && !info->shared)
|
if (h != NULL && !info->shared)
|
{
|
{
|
/* We may need a plt entry if the symbol turns out to be
|
/* We may need a plt entry if the symbol turns out to be
|
a function defined in a dynamic object. */
|
a function defined in a dynamic object. */
|
if (!update_plt_info (abfd, h, NULL, 0))
|
if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
|
return FALSE;
|
return FALSE;
|
|
|
/* We may need a copy reloc too. */
|
/* We may need a copy reloc too. */
|
h->non_got_ref = 1;
|
h->non_got_ref = 1;
|
h->pointer_equality_needed = 1;
|
h->pointer_equality_needed = 1;
|
| Line 3459... |
Line 3917... |
case R_PPC_ADDR14_BRNTAKEN:
|
case R_PPC_ADDR14_BRNTAKEN:
|
if (h != NULL && !info->shared)
|
if (h != NULL && !info->shared)
|
{
|
{
|
/* We may need a plt entry if the symbol turns out to be
|
/* We may need a plt entry if the symbol turns out to be
|
a function defined in a dynamic object. */
|
a function defined in a dynamic object. */
|
if (!update_plt_info (abfd, h, NULL, 0))
|
h->needs_plt = 1;
|
|
if (!update_plt_info (abfd, &h->plt.plist, NULL, 0))
|
return FALSE;
|
return FALSE;
|
break;
|
break;
|
}
|
}
|
|
|
dodyn:
|
dodyn:
|
| Line 3487... |
Line 3946... |
If on the other hand, we are creating an executable, we
|
If on the other hand, we are creating an executable, we
|
may need to keep relocations for symbols satisfied by a
|
may need to keep relocations for symbols satisfied by a
|
dynamic library if we manage to avoid copy relocs for the
|
dynamic library if we manage to avoid copy relocs for the
|
symbol. */
|
symbol. */
|
if ((info->shared
|
if ((info->shared
|
&& (MUST_BE_DYN_RELOC (r_type)
|
&& (must_be_dyn_reloc (info, r_type)
|
|| (h != NULL
|
|| (h != NULL
|
&& (! info->symbolic
|
&& (! info->symbolic
|
|| h->root.type == bfd_link_hash_defweak
|
|| h->root.type == bfd_link_hash_defweak
|
|| !h->def_regular))))
|
|| !h->def_regular))))
|
|| (ELIMINATE_COPY_RELOCS
|
|| (ELIMINATE_COPY_RELOCS
|
| Line 3499... |
Line 3958... |
&& h != NULL
|
&& h != NULL
|
&& (h->root.type == bfd_link_hash_defweak
|
&& (h->root.type == bfd_link_hash_defweak
|
|| !h->def_regular)))
|
|| !h->def_regular)))
|
{
|
{
|
struct ppc_elf_dyn_relocs *p;
|
struct ppc_elf_dyn_relocs *p;
|
struct ppc_elf_dyn_relocs **head;
|
struct ppc_elf_dyn_relocs **rel_head;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
fprintf (stderr,
|
fprintf (stderr,
|
"ppc_elf_check_relocs needs to "
|
"ppc_elf_check_relocs needs to "
|
"create relocation for %s\n",
|
"create relocation for %s\n",
|
(h && h->root.root.string
|
(h && h->root.root.string
|
? h->root.root.string : "<unknown>"));
|
? h->root.root.string : "<unknown>"));
|
#endif
|
#endif
|
if (sreloc == NULL)
|
if (sreloc == NULL)
|
{
|
{
|
const char *name;
|
|
|
|
name = (bfd_elf_string_from_elf_section
|
|
(abfd,
|
|
elf_elfheader (abfd)->e_shstrndx,
|
|
elf_section_data (sec)->rel_hdr.sh_name));
|
|
if (name == NULL)
|
|
return FALSE;
|
|
|
|
BFD_ASSERT (CONST_STRNEQ (name, ".rela")
|
|
&& strcmp (bfd_get_section_name (abfd, sec),
|
|
name + 5) == 0);
|
|
|
|
if (htab->elf.dynobj == NULL)
|
if (htab->elf.dynobj == NULL)
|
htab->elf.dynobj = abfd;
|
htab->elf.dynobj = abfd;
|
sreloc = bfd_get_section_by_name (htab->elf.dynobj, name);
|
|
if (sreloc == NULL)
|
|
{
|
|
flagword flags;
|
|
|
|
flags = (SEC_HAS_CONTENTS | SEC_READONLY
|
sreloc = _bfd_elf_make_dynamic_reloc_section
|
| SEC_IN_MEMORY | SEC_LINKER_CREATED
|
(sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
|
| SEC_ALLOC | SEC_LOAD);
|
|
sreloc = bfd_make_section_with_flags (htab->elf.dynobj,
|
if (sreloc == NULL)
|
name,
|
|
flags);
|
|
if (sreloc == NULL
|
|
|| ! bfd_set_section_alignment (htab->elf.dynobj,
|
|
sreloc, 2))
|
|
return FALSE;
|
return FALSE;
|
}
|
}
|
elf_section_data (sec)->sreloc = sreloc;
|
|
}
|
|
|
|
/* If this is a global symbol, we count the number of
|
/* If this is a global symbol, we count the number of
|
relocations we need for this symbol. */
|
relocations we need for this symbol. */
|
if (h != NULL)
|
if (h != NULL)
|
{
|
{
|
head = &ppc_elf_hash_entry (h)->dyn_relocs;
|
rel_head = &ppc_elf_hash_entry (h)->dyn_relocs;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Track dynamic relocs needed for local syms too.
|
/* Track dynamic relocs needed for local syms too.
|
We really need local syms available to do this
|
We really need local syms available to do this
|
easily. Oh well. */
|
easily. Oh well. */
|
|
|
asection *s;
|
asection *s;
|
void *vpp;
|
void *vpp;
|
|
Elf_Internal_Sym *isym;
|
|
|
s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
|
isym = bfd_sym_from_r_symndx (&htab->sym_cache,
|
sec, r_symndx);
|
abfd, r_symndx);
|
if (s == NULL)
|
if (isym == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
|
s = bfd_section_from_elf_index (abfd, isym->st_shndx);
|
|
if (s == NULL)
|
|
s = sec;
|
|
|
vpp = &elf_section_data (s)->local_dynrel;
|
vpp = &elf_section_data (s)->local_dynrel;
|
head = (struct ppc_elf_dyn_relocs **) vpp;
|
rel_head = (struct ppc_elf_dyn_relocs **) vpp;
|
}
|
}
|
|
|
p = *head;
|
p = *rel_head;
|
if (p == NULL || p->sec != sec)
|
if (p == NULL || p->sec != sec)
|
{
|
{
|
p = bfd_alloc (htab->elf.dynobj, sizeof *p);
|
p = bfd_alloc (htab->elf.dynobj, sizeof *p);
|
if (p == NULL)
|
if (p == NULL)
|
return FALSE;
|
return FALSE;
|
p->next = *head;
|
p->next = *rel_head;
|
*head = p;
|
*rel_head = p;
|
p->sec = sec;
|
p->sec = sec;
|
p->count = 0;
|
p->count = 0;
|
p->pc_count = 0;
|
p->pc_count = 0;
|
}
|
}
|
|
|
p->count += 1;
|
p->count += 1;
|
if (!MUST_BE_DYN_RELOC (r_type))
|
if (!must_be_dyn_reloc (info, r_type))
|
p->pc_count += 1;
|
p->pc_count += 1;
|
}
|
}
|
|
|
break;
|
break;
|
}
|
}
|
| Line 3631... |
Line 4070... |
else if (in_attr->i == 0)
|
else if (in_attr->i == 0)
|
;
|
;
|
else if (out_attr->i == 1 && in_attr->i == 2)
|
else if (out_attr->i == 1 && in_attr->i == 2)
|
_bfd_error_handler
|
_bfd_error_handler
|
(_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd);
|
(_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd);
|
else if (out_attr->i == 2 && in_attr->i == 1)
|
else if (out_attr->i == 1 && in_attr->i == 3)
|
|
_bfd_error_handler
|
|
(_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
|
|
obfd, ibfd);
|
|
else if (out_attr->i == 3 && in_attr->i == 1)
|
|
_bfd_error_handler
|
|
(_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
|
|
ibfd, obfd);
|
|
else if (out_attr->i == 3 && in_attr->i == 2)
|
|
_bfd_error_handler
|
|
(_("Warning: %B uses soft float, %B uses single-precision hard float"),
|
|
ibfd, obfd);
|
|
else if (out_attr->i == 2 && (in_attr->i == 1 || in_attr->i == 3))
|
_bfd_error_handler
|
_bfd_error_handler
|
(_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd);
|
(_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd);
|
else if (in_attr->i > 2)
|
else if (in_attr->i > 3)
|
_bfd_error_handler
|
_bfd_error_handler
|
(_("Warning: %B uses unknown floating point ABI %d"), ibfd,
|
(_("Warning: %B uses unknown floating point ABI %d"), ibfd,
|
in_attr->i);
|
in_attr->i);
|
else
|
else
|
_bfd_error_handler
|
_bfd_error_handler
|
| Line 3694... |
Line 4145... |
_bfd_error_handler
|
_bfd_error_handler
|
(_("Warning: %B uses vector ABI \"%s\", %B uses \"%s\""),
|
(_("Warning: %B uses vector ABI \"%s\", %B uses \"%s\""),
|
ibfd, obfd, in_abi, out_abi);
|
ibfd, obfd, in_abi, out_abi);
|
}
|
}
|
|
|
|
/* Check for conflicting Tag_GNU_Power_ABI_Struct_Return attributes
|
|
and merge non-conflicting ones. */
|
|
in_attr = &in_attrs[Tag_GNU_Power_ABI_Struct_Return];
|
|
out_attr = &out_attrs[Tag_GNU_Power_ABI_Struct_Return];
|
|
if (in_attr->i != out_attr->i)
|
|
{
|
|
out_attr->type = 1;
|
|
if (out_attr->i == 0)
|
|
out_attr->i = in_attr->i;
|
|
else if (in_attr->i == 0)
|
|
;
|
|
else if (out_attr->i == 1 && in_attr->i == 2)
|
|
_bfd_error_handler
|
|
(_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), obfd, ibfd);
|
|
else if (out_attr->i == 2 && in_attr->i == 1)
|
|
_bfd_error_handler
|
|
(_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), ibfd, obfd);
|
|
else if (in_attr->i > 2)
|
|
_bfd_error_handler
|
|
(_("Warning: %B uses unknown small structure return convention %d"), ibfd,
|
|
in_attr->i);
|
|
else
|
|
_bfd_error_handler
|
|
(_("Warning: %B uses unknown small structure return convention %d"), obfd,
|
|
out_attr->i);
|
|
}
|
|
|
/* Merge Tag_compatibility attributes and any common GNU ones. */
|
/* Merge Tag_compatibility attributes and any common GNU ones. */
|
_bfd_elf_merge_object_attributes (ibfd, obfd);
|
_bfd_elf_merge_object_attributes (ibfd, obfd);
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
| Line 3807... |
Line 4285... |
struct ppc_elf_link_hash_table *htab;
|
struct ppc_elf_link_hash_table *htab;
|
flagword flags;
|
flagword flags;
|
|
|
htab = ppc_elf_hash_table (info);
|
htab = ppc_elf_hash_table (info);
|
|
|
|
htab->emit_stub_syms = emit_stub_syms;
|
|
|
if (htab->plt_type == PLT_UNSET)
|
if (htab->plt_type == PLT_UNSET)
|
{
|
{
|
if (plt_style == PLT_OLD)
|
if (plt_style == PLT_OLD)
|
htab->plt_type = PLT_OLD;
|
htab->plt_type = PLT_OLD;
|
else
|
else
|
| Line 3840... |
Line 4320... |
}
|
}
|
}
|
}
|
if (htab->plt_type == PLT_OLD && plt_style == PLT_NEW)
|
if (htab->plt_type == PLT_OLD && plt_style == PLT_NEW)
|
info->callbacks->info (_("Using bss-plt due to %B"), htab->old_bfd);
|
info->callbacks->info (_("Using bss-plt due to %B"), htab->old_bfd);
|
|
|
htab->emit_stub_syms = emit_stub_syms;
|
|
|
|
BFD_ASSERT (htab->plt_type != PLT_VXWORKS);
|
BFD_ASSERT (htab->plt_type != PLT_VXWORKS);
|
|
|
if (htab->plt_type == PLT_NEW)
|
if (htab->plt_type == PLT_NEW)
|
{
|
{
|
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
|
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
|
| Line 3949... |
Line 4427... |
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
r_type = ELF32_R_TYPE (rel->r_info);
|
r_type = ELF32_R_TYPE (rel->r_info);
|
|
if (!htab->is_vxworks
|
|
&& h == NULL
|
|
&& local_got_refcounts != NULL
|
|
&& (!info->shared
|
|
|| is_branch_reloc (r_type)))
|
|
{
|
|
struct plt_entry **local_plt = (struct plt_entry **)
|
|
(local_got_refcounts + symtab_hdr->sh_info);
|
|
char *local_got_tls_masks = (char *)
|
|
(local_plt + symtab_hdr->sh_info);
|
|
if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
|
|
{
|
|
struct plt_entry **ifunc = local_plt + r_symndx;
|
|
bfd_vma addend = 0;
|
|
struct plt_entry *ent;
|
|
|
|
if (r_type == R_PPC_PLTREL24 && info->shared)
|
|
addend = rel->r_addend;
|
|
ent = find_plt_ent (ifunc, got2, addend);
|
|
if (ent->plt.refcount > 0)
|
|
ent->plt.refcount -= 1;
|
|
continue;
|
|
}
|
|
}
|
|
|
switch (r_type)
|
switch (r_type)
|
{
|
{
|
case R_PPC_GOT_TLSLD16:
|
case R_PPC_GOT_TLSLD16:
|
case R_PPC_GOT_TLSLD16_LO:
|
case R_PPC_GOT_TLSLD16_LO:
|
case R_PPC_GOT_TLSLD16_HI:
|
case R_PPC_GOT_TLSLD16_HI:
|
| Line 3975... |
Line 4478... |
case R_PPC_GOT16_HA:
|
case R_PPC_GOT16_HA:
|
if (h != NULL)
|
if (h != NULL)
|
{
|
{
|
if (h->got.refcount > 0)
|
if (h->got.refcount > 0)
|
h->got.refcount--;
|
h->got.refcount--;
|
|
if (!info->shared)
|
|
{
|
|
struct plt_entry *ent;
|
|
|
|
ent = find_plt_ent (&h->plt.plist, NULL, 0);
|
|
if (ent != NULL && ent->plt.refcount > 0)
|
|
ent->plt.refcount -= 1;
|
|
}
|
}
|
}
|
else if (local_got_refcounts != NULL)
|
else if (local_got_refcounts != NULL)
|
{
|
{
|
if (local_got_refcounts[r_symndx] > 0)
|
if (local_got_refcounts[r_symndx] > 0)
|
local_got_refcounts[r_symndx]--;
|
local_got_refcounts[r_symndx]--;
|
| Line 4014... |
Line 4525... |
case R_PPC_PLT16_LO:
|
case R_PPC_PLT16_LO:
|
case R_PPC_PLT16_HI:
|
case R_PPC_PLT16_HI:
|
case R_PPC_PLT16_HA:
|
case R_PPC_PLT16_HA:
|
if (h != NULL)
|
if (h != NULL)
|
{
|
{
|
bfd_vma addend = r_type == R_PPC_PLTREL24 ? rel->r_addend : 0;
|
bfd_vma addend = 0;
|
struct plt_entry *ent = find_plt_ent (h, got2, addend);
|
struct plt_entry *ent;
|
if (ent->plt.refcount > 0)
|
|
|
if (r_type == R_PPC_PLTREL24 && info->shared)
|
|
addend = rel->r_addend;
|
|
ent = find_plt_ent (&h->plt.plist, got2, addend);
|
|
if (ent != NULL && ent->plt.refcount > 0)
|
ent->plt.refcount -= 1;
|
ent->plt.refcount -= 1;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
| Line 4028... |
Line 4543... |
}
|
}
|
}
|
}
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
|
/* Set plt output section type, htab->tls_get_addr, and call the
|
|
generic ELF tls_setup function. */
|
|
|
asection *
|
asection *
|
ppc_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
|
ppc_elf_tls_setup (bfd *obfd,
|
|
struct bfd_link_info *info,
|
|
int no_tls_get_addr_opt)
|
{
|
{
|
struct ppc_elf_link_hash_table *htab;
|
struct ppc_elf_link_hash_table *htab;
|
|
|
htab = ppc_elf_hash_table (info);
|
htab = ppc_elf_hash_table (info);
|
|
htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
|
|
FALSE, FALSE, TRUE);
|
|
if (!no_tls_get_addr_opt)
|
|
{
|
|
struct elf_link_hash_entry *opt, *tga;
|
|
opt = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
|
|
FALSE, FALSE, TRUE);
|
|
if (opt != NULL
|
|
&& (opt->root.type == bfd_link_hash_defined
|
|
|| opt->root.type == bfd_link_hash_defweak))
|
|
{
|
|
/* If glibc supports an optimized __tls_get_addr call stub,
|
|
signalled by the presence of __tls_get_addr_opt, and we'll
|
|
be calling __tls_get_addr via a plt call stub, then
|
|
make __tls_get_addr point to __tls_get_addr_opt. */
|
|
tga = htab->tls_get_addr;
|
|
if (htab->elf.dynamic_sections_created
|
|
&& tga != NULL
|
|
&& (tga->type == STT_FUNC
|
|
|| tga->needs_plt)
|
|
&& !(SYMBOL_CALLS_LOCAL (info, tga)
|
|
|| (ELF_ST_VISIBILITY (tga->other) != STV_DEFAULT
|
|
&& tga->root.type == bfd_link_hash_undefweak)))
|
|
{
|
|
struct plt_entry *ent;
|
|
for (ent = tga->plt.plist; ent != NULL; ent = ent->next)
|
|
if (ent->plt.refcount > 0)
|
|
break;
|
|
if (ent != NULL)
|
|
{
|
|
tga->root.type = bfd_link_hash_indirect;
|
|
tga->root.u.i.link = &opt->root;
|
|
ppc_elf_copy_indirect_symbol (info, opt, tga);
|
|
if (opt->dynindx != -1)
|
|
{
|
|
/* Use __tls_get_addr_opt in dynamic relocations. */
|
|
opt->dynindx = -1;
|
|
_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
|
|
opt->dynstr_index);
|
|
if (!bfd_elf_link_record_dynamic_symbol (info, opt))
|
|
return FALSE;
|
|
}
|
|
htab->tls_get_addr = opt;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
no_tls_get_addr_opt = TRUE;
|
|
}
|
|
htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
|
if (htab->plt_type == PLT_NEW
|
if (htab->plt_type == PLT_NEW
|
&& htab->plt != NULL
|
&& htab->plt != NULL
|
&& htab->plt->output_section != NULL)
|
&& htab->plt->output_section != NULL)
|
{
|
{
|
elf_section_type (htab->plt->output_section) = SHT_PROGBITS;
|
elf_section_type (htab->plt->output_section) = SHT_PROGBITS;
|
elf_section_flags (htab->plt->output_section) = SHF_ALLOC + SHF_WRITE;
|
elf_section_flags (htab->plt->output_section) = SHF_ALLOC + SHF_WRITE;
|
}
|
}
|
|
|
htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
|
|
FALSE, FALSE, TRUE);
|
|
return _bfd_elf_tls_setup (obfd, info);
|
return _bfd_elf_tls_setup (obfd, info);
|
}
|
}
|
|
|
|
/* Return TRUE iff REL is a branch reloc with a global symbol matching
|
|
HASH. */
|
|
|
|
static bfd_boolean
|
|
branch_reloc_hash_match (const bfd *ibfd,
|
|
const Elf_Internal_Rela *rel,
|
|
const struct elf_link_hash_entry *hash)
|
|
{
|
|
Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
|
|
enum elf_ppc_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
|
|
unsigned int r_symndx = ELF32_R_SYM (rel->r_info);
|
|
|
|
if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
|
|
{
|
|
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
|
|
struct elf_link_hash_entry *h;
|
|
|
|
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
|
|
while (h->root.type == bfd_link_hash_indirect
|
|
|| h->root.type == bfd_link_hash_warning)
|
|
h = (struct elf_link_hash_entry *) h->root.u.i.link;
|
|
if (h == hash)
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
/* Run through all the TLS relocs looking for optimization
|
/* Run through all the TLS relocs looking for optimization
|
opportunities. */
|
opportunities. */
|
|
|
bfd_boolean
|
bfd_boolean
|
ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED,
|
ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED,
|
| Line 4061... |
Line 4654... |
bfd *ibfd;
|
bfd *ibfd;
|
asection *sec;
|
asection *sec;
|
struct ppc_elf_link_hash_table *htab;
|
struct ppc_elf_link_hash_table *htab;
|
int pass;
|
int pass;
|
|
|
if (info->relocatable || info->shared)
|
if (info->relocatable || !info->executable)
|
return TRUE;
|
return TRUE;
|
|
|
htab = ppc_elf_hash_table (info);
|
htab = ppc_elf_hash_table (info);
|
/* Make two passes through the relocs. First time check that tls
|
/* Make two passes through the relocs. First time check that tls
|
relocs involved in setting up a tls_get_addr call are indeed
|
relocs involved in setting up a tls_get_addr call are indeed
|
| Line 4074... |
Line 4667... |
for (pass = 0; pass < 2; ++pass)
|
for (pass = 0; pass < 2; ++pass)
|
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
|
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
|
{
|
{
|
Elf_Internal_Sym *locsyms = NULL;
|
Elf_Internal_Sym *locsyms = NULL;
|
Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
|
Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
|
|
asection *got2 = bfd_get_section_by_name (ibfd, ".got2");
|
|
|
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
|
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
|
if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
|
if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
|
{
|
{
|
Elf_Internal_Rela *relstart, *rel, *relend;
|
Elf_Internal_Rela *relstart, *rel, *relend;
|
| Line 4167... |
Line 4761... |
break;
|
break;
|
}
|
}
|
else
|
else
|
continue;
|
continue;
|
|
|
|
case R_PPC_TLSGD:
|
|
case R_PPC_TLSLD:
|
|
expecting_tls_get_addr = 2;
|
|
tls_set = 0;
|
|
tls_clear = 0;
|
|
break;
|
|
|
default:
|
default:
|
continue;
|
continue;
|
}
|
}
|
|
|
if (pass == 0)
|
if (pass == 0)
|
{
|
{
|
if (!expecting_tls_get_addr)
|
if (!expecting_tls_get_addr
|
|
|| (expecting_tls_get_addr == 1
|
|
&& !sec->has_tls_get_addr_call))
|
continue;
|
continue;
|
|
|
if (rel + 1 < relend)
|
if (rel + 1 < relend
|
{
|
&& branch_reloc_hash_match (ibfd, rel + 1,
|
enum elf_ppc_reloc_type r_type2;
|
htab->tls_get_addr))
|
unsigned long r_symndx2;
|
|
struct elf_link_hash_entry *h2;
|
|
|
|
/* The next instruction should be a call to
|
|
__tls_get_addr. Peek at the reloc to be sure. */
|
|
r_type2 = ELF32_R_TYPE (rel[1].r_info);
|
|
r_symndx2 = ELF32_R_SYM (rel[1].r_info);
|
|
if (r_symndx2 >= symtab_hdr->sh_info
|
|
&& (r_type2 == R_PPC_REL14
|
|
|| r_type2 == R_PPC_REL14_BRTAKEN
|
|
|| r_type2 == R_PPC_REL14_BRNTAKEN
|
|
|| r_type2 == R_PPC_REL24
|
|
|| r_type2 == R_PPC_PLTREL24))
|
|
{
|
|
struct elf_link_hash_entry **sym_hashes;
|
|
|
|
sym_hashes = elf_sym_hashes (ibfd);
|
|
h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
|
|
while (h2->root.type == bfd_link_hash_indirect
|
|
|| h2->root.type == bfd_link_hash_warning)
|
|
h2 = ((struct elf_link_hash_entry *)
|
|
h2->root.u.i.link);
|
|
if (h2 == htab->tls_get_addr)
|
|
continue;
|
continue;
|
}
|
|
}
|
|
|
|
/* Uh oh, we didn't find the expected call. We
|
/* Uh oh, we didn't find the expected call. We
|
could just mark this symbol to exclude it
|
could just mark this symbol to exclude it
|
from tls optimization but it's safer to skip
|
from tls optimization but it's safer to skip
|
the entire section. */
|
the entire section. */
|
sec->has_tls_reloc = 0;
|
sec->has_tls_reloc = 0;
|
break;
|
break;
|
}
|
}
|
|
|
|
if (expecting_tls_get_addr)
|
|
{
|
|
struct plt_entry *ent;
|
|
bfd_vma addend = 0;
|
|
|
|
if (info->shared
|
|
&& ELF32_R_TYPE (rel[1].r_info) == R_PPC_PLTREL24)
|
|
addend = rel[1].r_addend;
|
|
ent = find_plt_ent (&htab->tls_get_addr->plt.plist,
|
|
got2, addend);
|
|
if (ent != NULL && ent->plt.refcount > 0)
|
|
ent->plt.refcount -= 1;
|
|
|
|
if (expecting_tls_get_addr == 2)
|
|
continue;
|
|
}
|
|
|
if (h != NULL)
|
if (h != NULL)
|
{
|
{
|
tls_mask = &ppc_elf_hash_entry (h)->tls_mask;
|
tls_mask = &ppc_elf_hash_entry (h)->tls_mask;
|
got_count = &h->got.refcount;
|
got_count = &h->got.refcount;
|
}
|
}
|
else
|
else
|
{
|
{
|
Elf_Internal_Sym *sym;
|
Elf_Internal_Sym *sym;
|
bfd_signed_vma *lgot_refs;
|
bfd_signed_vma *lgot_refs;
|
|
struct plt_entry **local_plt;
|
char *lgot_masks;
|
char *lgot_masks;
|
|
|
if (locsyms == NULL)
|
if (locsyms == NULL)
|
{
|
{
|
locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
|
locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
|
| Line 4243... |
Line 4839... |
}
|
}
|
sym = locsyms + r_symndx;
|
sym = locsyms + r_symndx;
|
lgot_refs = elf_local_got_refcounts (ibfd);
|
lgot_refs = elf_local_got_refcounts (ibfd);
|
if (lgot_refs == NULL)
|
if (lgot_refs == NULL)
|
abort ();
|
abort ();
|
lgot_masks = (char *) (lgot_refs + symtab_hdr->sh_info);
|
local_plt = (struct plt_entry **)
|
|
(lgot_refs + symtab_hdr->sh_info);
|
|
lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
|
tls_mask = &lgot_masks[r_symndx];
|
tls_mask = &lgot_masks[r_symndx];
|
got_count = &lgot_refs[r_symndx];
|
got_count = &lgot_refs[r_symndx];
|
}
|
}
|
|
|
if (tls_set == 0)
|
if (tls_set == 0)
|
| Line 4255... |
Line 4853... |
/* We managed to get rid of a got entry. */
|
/* We managed to get rid of a got entry. */
|
if (*got_count > 0)
|
if (*got_count > 0)
|
*got_count -= 1;
|
*got_count -= 1;
|
}
|
}
|
|
|
if (expecting_tls_get_addr)
|
|
{
|
|
struct plt_entry *ent;
|
|
|
|
ent = find_plt_ent (htab->tls_get_addr, NULL, 0);
|
|
if (ent != NULL && ent->plt.refcount > 0)
|
|
ent->plt.refcount -= 1;
|
|
}
|
|
|
|
*tls_mask |= tls_set;
|
*tls_mask |= tls_set;
|
*tls_mask &= ~tls_clear;
|
*tls_mask &= ~tls_clear;
|
}
|
}
|
|
|
if (elf_section_data (sec)->relocs != relstart)
|
if (elf_section_data (sec)->relocs != relstart)
|
| Line 4325... |
Line 4914... |
|
|
/* Make sure we know what is going on here. */
|
/* Make sure we know what is going on here. */
|
htab = ppc_elf_hash_table (info);
|
htab = ppc_elf_hash_table (info);
|
BFD_ASSERT (htab->elf.dynobj != NULL
|
BFD_ASSERT (htab->elf.dynobj != NULL
|
&& (h->needs_plt
|
&& (h->needs_plt
|
|
|| h->type == STT_GNU_IFUNC
|
|| h->u.weakdef != NULL
|
|| h->u.weakdef != NULL
|
|| (h->def_dynamic
|
|| (h->def_dynamic
|
&& h->ref_regular
|
&& h->ref_regular
|
&& !h->def_regular)));
|
&& !h->def_regular)));
|
|
|
/* Deal with function syms. */
|
/* Deal with function syms. */
|
if (h->type == STT_FUNC
|
if (h->type == STT_FUNC
|
|
|| h->type == STT_GNU_IFUNC
|
|| h->needs_plt)
|
|| h->needs_plt)
|
{
|
{
|
/* Clear procedure linkage table information for any symbol that
|
/* Clear procedure linkage table information for any symbol that
|
won't need a .plt entry. */
|
won't need a .plt entry. */
|
struct plt_entry *ent;
|
struct plt_entry *ent;
|
for (ent = h->plt.plist; ent != NULL; ent = ent->next)
|
for (ent = h->plt.plist; ent != NULL; ent = ent->next)
|
if (ent->plt.refcount > 0)
|
if (ent->plt.refcount > 0)
|
break;
|
break;
|
if (ent == NULL
|
if (ent == NULL
|
|| SYMBOL_CALLS_LOCAL (info, h)
|
|| (h->type != STT_GNU_IFUNC
|
|
&& (SYMBOL_CALLS_LOCAL (info, h)
|
|| (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
|
|| (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
|
&& h->root.type == bfd_link_hash_undefweak))
|
&& h->root.type == bfd_link_hash_undefweak))))
|
{
|
{
|
/* A PLT entry is not required/allowed when:
|
/* A PLT entry is not required/allowed when:
|
|
|
1. We are not using ld.so; because then the PLT entry
|
1. We are not using ld.so; because then the PLT entry
|
can't be set up, so we can't use one. In this case,
|
can't be set up, so we can't use one. In this case,
|
| Line 4360... |
Line 4952... |
h->plt.plist = NULL;
|
h->plt.plist = NULL;
|
h->needs_plt = 0;
|
h->needs_plt = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* After adjust_dynamic_symbol, non_got_ref set means that
|
/* After adjust_dynamic_symbol, non_got_ref set in the
|
dyn_relocs for this symbol should be discarded.
|
non-shared case means that we have allocated space in
|
|
.dynbss for the symbol and thus dyn_relocs for this
|
|
symbol should be discarded.
|
If we get here we know we are making a PLT entry for this
|
If we get here we know we are making a PLT entry for this
|
symbol, and in an executable we'd normally resolve
|
symbol, and in an executable we'd normally resolve
|
relocations against this symbol to the PLT entry. Allow
|
relocations against this symbol to the PLT entry. Allow
|
dynamic relocs if the reference is weak, and the dynamic
|
dynamic relocs if the reference is weak, and the dynamic
|
relocs will not cause text relocation. */
|
relocs will not cause text relocation. */
|
if (!h->ref_regular_nonweak
|
if (!h->ref_regular_nonweak
|
&& h->non_got_ref
|
&& h->non_got_ref
|
|
&& h->type != STT_GNU_IFUNC
|
&& !htab->is_vxworks
|
&& !htab->is_vxworks
|
&& !ppc_elf_hash_entry (h)->has_sda_refs
|
&& !ppc_elf_hash_entry (h)->has_sda_refs
|
&& !readonly_dynrelocs (h))
|
&& !readonly_dynrelocs (h))
|
h->non_got_ref = 0;
|
h->non_got_ref = 0;
|
}
|
}
|
| Line 4487... |
Line 5082... |
size_t len1, len2, len3;
|
size_t len1, len2, len3;
|
char *name;
|
char *name;
|
const char *stub;
|
const char *stub;
|
struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
|
struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
|
|
|
if (info->shared || info->pie)
|
if (info->shared)
|
stub = ".plt_pic32.";
|
stub = ".plt_pic32.";
|
else
|
else
|
stub = ".plt_call32.";
|
stub = ".plt_call32.";
|
|
|
len1 = strlen (h->root.root.string);
|
len1 = strlen (h->root.root.string);
|
| Line 4579... |
Line 5174... |
entry in the hash table, thus we never get to see the real
|
entry in the hash table, thus we never get to see the real
|
symbol in a hash traversal. So look at it now. */
|
symbol in a hash traversal. So look at it now. */
|
h = (struct elf_link_hash_entry *) h->root.u.i.link;
|
h = (struct elf_link_hash_entry *) h->root.u.i.link;
|
|
|
htab = ppc_elf_hash_table (info);
|
htab = ppc_elf_hash_table (info);
|
if (htab->elf.dynamic_sections_created)
|
if (htab->elf.dynamic_sections_created
|
|
|| h->type == STT_GNU_IFUNC)
|
{
|
{
|
struct plt_entry *ent;
|
struct plt_entry *ent;
|
bfd_boolean doneone = FALSE;
|
bfd_boolean doneone = FALSE;
|
bfd_vma plt_offset = 0, glink_offset = 0;
|
bfd_vma plt_offset = 0, glink_offset = 0;
|
|
bfd_boolean dyn;
|
|
|
for (ent = h->plt.plist; ent != NULL; ent = ent->next)
|
for (ent = h->plt.plist; ent != NULL; ent = ent->next)
|
if (ent->plt.refcount > 0)
|
if (ent->plt.refcount > 0)
|
{
|
{
|
/* Make sure this symbol is output as a dynamic symbol. */
|
/* Make sure this symbol is output as a dynamic symbol. */
|
if (h->dynindx == -1
|
if (h->dynindx == -1
|
&& !h->forced_local)
|
&& !h->forced_local
|
|
&& !h->def_regular
|
|
&& htab->elf.dynamic_sections_created)
|
{
|
{
|
if (! bfd_elf_link_record_dynamic_symbol (info, h))
|
if (! bfd_elf_link_record_dynamic_symbol (info, h))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
|
dyn = htab->elf.dynamic_sections_created;
|
if (info->shared
|
if (info->shared
|
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
|
|| h->type == STT_GNU_IFUNC
|
|
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
|
{
|
{
|
asection *s = htab->plt;
|
asection *s = htab->plt;
|
|
if (!dyn || h->dynindx == -1)
|
|
s = htab->iplt;
|
|
|
if (htab->plt_type == PLT_NEW)
|
if (htab->plt_type == PLT_NEW || !dyn || h->dynindx == -1)
|
{
|
{
|
if (!doneone)
|
if (!doneone)
|
{
|
{
|
plt_offset = s->size;
|
plt_offset = s->size;
|
s->size += 4;
|
s->size += 4;
|
}
|
}
|
ent->plt.offset = plt_offset;
|
ent->plt.offset = plt_offset;
|
|
|
s = htab->glink;
|
s = htab->glink;
|
if (!doneone || info->shared || info->pie)
|
if (!doneone || info->shared)
|
{
|
{
|
glink_offset = s->size;
|
glink_offset = s->size;
|
s->size += GLINK_ENTRY_SIZE;
|
s->size += GLINK_ENTRY_SIZE;
|
|
if (h == htab->tls_get_addr
|
|
&& !htab->no_tls_get_addr_opt)
|
|
s->size += TLS_GET_ADDR_GLINK_SIZE - GLINK_ENTRY_SIZE;
|
}
|
}
|
if (!doneone
|
if (!doneone
|
&& !info->shared
|
&& !info->shared
|
&& h->def_dynamic
|
&& h->def_dynamic
|
&& !h->def_regular)
|
&& !h->def_regular)
|
| Line 4652... |
Line 5258... |
/ htab->plt_entry_size)));
|
/ htab->plt_entry_size)));
|
|
|
/* If this symbol is not defined in a regular
|
/* If this symbol is not defined in a regular
|
file, and we are not generating a shared
|
file, and we are not generating a shared
|
library, then set the symbol to this location
|
library, then set the symbol to this location
|
in the .plt. This is required to make
|
in the .plt. This is to avoid text
|
|
relocations, and is required to make
|
function pointers compare as equal between
|
function pointers compare as equal between
|
the normal executable and the shared library. */
|
the normal executable and the shared library. */
|
if (! info->shared
|
if (! info->shared
|
&& h->def_dynamic
|
&& h->def_dynamic
|
&& !h->def_regular)
|
&& !h->def_regular)
|
| Line 4679... |
Line 5286... |
}
|
}
|
|
|
/* We also need to make an entry in the .rela.plt section. */
|
/* We also need to make an entry in the .rela.plt section. */
|
if (!doneone)
|
if (!doneone)
|
{
|
{
|
|
if (!htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
|
htab->reliplt->size += sizeof (Elf32_External_Rela);
|
|
else
|
|
{
|
htab->relplt->size += sizeof (Elf32_External_Rela);
|
htab->relplt->size += sizeof (Elf32_External_Rela);
|
|
|
if (htab->plt_type == PLT_VXWORKS)
|
if (htab->plt_type == PLT_VXWORKS)
|
{
|
{
|
/* Allocate space for the unloaded relocations. */
|
/* Allocate space for the unloaded relocations. */
|
if (!info->shared)
|
if (!info->shared
|
|
&& htab->elf.dynamic_sections_created)
|
{
|
{
|
if (ent->plt.offset
|
if (ent->plt.offset
|
== (bfd_vma) htab->plt_initial_entry_size)
|
== (bfd_vma) htab->plt_initial_entry_size)
|
{
|
{
|
htab->srelplt2->size
|
htab->srelplt2->size
|
+= sizeof (Elf32_External_Rela)
|
+= (sizeof (Elf32_External_Rela)
|
* VXWORKS_PLTRESOLVE_RELOCS;
|
* VXWORKS_PLTRESOLVE_RELOCS);
|
}
|
}
|
|
|
htab->srelplt2->size
|
htab->srelplt2->size
|
+= sizeof (Elf32_External_Rela)
|
+= (sizeof (Elf32_External_Rela)
|
* VXWORKS_PLT_NON_JMP_SLOT_RELOCS;
|
* VXWORKS_PLT_NON_JMP_SLOT_RELOCS);
|
}
|
}
|
|
|
/* Every PLT entry has an associated GOT entry in
|
/* Every PLT entry has an associated GOT entry in
|
.got.plt. */
|
.got.plt. */
|
htab->sgotplt->size += 4;
|
htab->sgotplt->size += 4;
|
}
|
}
|
|
}
|
doneone = TRUE;
|
doneone = TRUE;
|
}
|
}
|
}
|
}
|
else
|
else
|
ent->plt.offset = (bfd_vma) -1;
|
ent->plt.offset = (bfd_vma) -1;
|
| Line 4727... |
Line 5341... |
}
|
}
|
|
|
eh = (struct ppc_elf_link_hash_entry *) h;
|
eh = (struct ppc_elf_link_hash_entry *) h;
|
if (eh->elf.got.refcount > 0)
|
if (eh->elf.got.refcount > 0)
|
{
|
{
|
|
bfd_boolean dyn;
|
|
unsigned int need;
|
|
|
/* Make sure this symbol is output as a dynamic symbol. */
|
/* Make sure this symbol is output as a dynamic symbol. */
|
if (eh->elf.dynindx == -1
|
if (eh->elf.dynindx == -1
|
&& !eh->elf.forced_local)
|
&& !eh->elf.forced_local
|
|
&& eh->elf.type != STT_GNU_IFUNC
|
|
&& htab->elf.dynamic_sections_created)
|
{
|
{
|
if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf))
|
if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
if (eh->tls_mask == (TLS_TLS | TLS_LD)
|
need = 0;
|
&& !eh->elf.def_dynamic)
|
|
{
|
|
/* If just an LD reloc, we'll just use htab->tlsld_got.offset. */
|
|
htab->tlsld_got.refcount += 1;
|
|
eh->elf.got.offset = (bfd_vma) -1;
|
|
}
|
|
else
|
|
{
|
|
bfd_boolean dyn;
|
|
unsigned int need = 0;
|
|
if ((eh->tls_mask & TLS_TLS) != 0)
|
if ((eh->tls_mask & TLS_TLS) != 0)
|
{
|
{
|
if ((eh->tls_mask & TLS_LD) != 0)
|
if ((eh->tls_mask & TLS_LD) != 0)
|
|
{
|
|
if (!eh->elf.def_dynamic)
|
|
/* We'll just use htab->tlsld_got.offset. This should
|
|
always be the case. It's a little odd if we have
|
|
a local dynamic reloc against a non-local symbol. */
|
|
htab->tlsld_got.refcount += 1;
|
|
else
|
need += 8;
|
need += 8;
|
|
}
|
if ((eh->tls_mask & TLS_GD) != 0)
|
if ((eh->tls_mask & TLS_GD) != 0)
|
need += 8;
|
need += 8;
|
if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
|
if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
|
need += 4;
|
need += 4;
|
if ((eh->tls_mask & TLS_DTPREL) != 0)
|
if ((eh->tls_mask & TLS_DTPREL) != 0)
|
need += 4;
|
need += 4;
|
}
|
}
|
else
|
else
|
need += 4;
|
need += 4;
|
|
if (need == 0)
|
|
eh->elf.got.offset = (bfd_vma) -1;
|
|
else
|
|
{
|
eh->elf.got.offset = allocate_got (htab, need);
|
eh->elf.got.offset = allocate_got (htab, need);
|
dyn = htab->elf.dynamic_sections_created;
|
dyn = htab->elf.dynamic_sections_created;
|
if ((info->shared
|
if ((info->shared
|
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf))
|
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf))
|
&& (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT
|
&& (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT
|
|| eh->elf.root.type != bfd_link_hash_undefweak))
|
|| eh->elf.root.type != bfd_link_hash_undefweak))
|
{
|
{
|
|
asection *rsec = htab->relgot;
|
/* All the entries we allocated need relocs.
|
/* All the entries we allocated need relocs.
|
Except LD only needs one. */
|
Except LD only needs one. */
|
if ((eh->tls_mask & TLS_LD) != 0)
|
if ((eh->tls_mask & TLS_LD) != 0
|
|
&& eh->elf.def_dynamic)
|
need -= 4;
|
need -= 4;
|
htab->relgot->size += need * (sizeof (Elf32_External_Rela) / 4);
|
rsec->size += need * (sizeof (Elf32_External_Rela) / 4);
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
eh->elf.got.offset = (bfd_vma) -1;
|
eh->elf.got.offset = (bfd_vma) -1;
|
|
|
if (eh->dyn_relocs == NULL)
|
if (eh->dyn_relocs == NULL
|
|
|| !htab->elf.dynamic_sections_created)
|
return TRUE;
|
return TRUE;
|
|
|
/* In the shared -Bsymbolic case, discard space allocated for
|
/* In the shared -Bsymbolic case, discard space allocated for
|
dynamic pc-relative relocs against symbols which turn out to be
|
dynamic pc-relative relocs against symbols which turn out to be
|
defined in regular objects. For the normal shared case, discard
|
defined in regular objects. For the normal shared case, discard
|
| Line 4789... |
Line 5413... |
changes. */
|
changes. */
|
|
|
if (info->shared)
|
if (info->shared)
|
{
|
{
|
/* Relocs that use pc_count are those that appear on a call insn,
|
/* Relocs that use pc_count are those that appear on a call insn,
|
or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
|
or certain REL relocs (see must_be_dyn_reloc) that can be
|
generated via assembly. We want calls to protected symbols to
|
generated via assembly. We want calls to protected symbols to
|
resolve directly to the function rather than going via the plt.
|
resolve directly to the function rather than going via the plt.
|
If people want function pointer comparisons to work as expected
|
If people want function pointer comparisons to work as expected
|
then they should avoid writing weird assembly. */
|
then they should avoid writing weird assembly. */
|
if (SYMBOL_CALLS_LOCAL (info, h))
|
if (SYMBOL_CALLS_LOCAL (info, h))
|
| Line 4809... |
Line 5433... |
else
|
else
|
pp = &p->next;
|
pp = &p->next;
|
}
|
}
|
}
|
}
|
|
|
|
if (htab->is_vxworks)
|
|
{
|
|
struct ppc_elf_dyn_relocs **pp;
|
|
|
|
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
|
|
{
|
|
if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
|
|
*pp = p->next;
|
|
else
|
|
pp = &p->next;
|
|
}
|
|
}
|
|
|
|
/* Discard relocs on undefined symbols that must be local. */
|
|
if (eh->dyn_relocs != NULL
|
|
&& h->root.type == bfd_link_hash_undefined
|
|
&& (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
|
|
|| ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
|
|
eh->dyn_relocs = NULL;
|
|
|
/* Also discard relocs on undefined weak syms with non-default
|
/* Also discard relocs on undefined weak syms with non-default
|
visibility. */
|
visibility. */
|
if (eh->dyn_relocs != NULL
|
if (eh->dyn_relocs != NULL
|
&& h->root.type == bfd_link_hash_undefweak)
|
&& h->root.type == bfd_link_hash_undefweak)
|
{
|
{
|
| Line 4820... |
Line 5464... |
eh->dyn_relocs = NULL;
|
eh->dyn_relocs = NULL;
|
|
|
/* Make sure undefined weak symbols are output as a dynamic
|
/* Make sure undefined weak symbols are output as a dynamic
|
symbol in PIEs. */
|
symbol in PIEs. */
|
else if (h->dynindx == -1
|
else if (h->dynindx == -1
|
&& !h->forced_local)
|
&& !h->forced_local
|
|
&& !h->def_regular)
|
{
|
{
|
if (! bfd_elf_link_record_dynamic_symbol (info, h))
|
if (! bfd_elf_link_record_dynamic_symbol (info, h))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
}
|
}
|
| Line 4860... |
Line 5505... |
|
|
/* Finally, allocate space. */
|
/* Finally, allocate space. */
|
for (p = eh->dyn_relocs; p != NULL; p = p->next)
|
for (p = eh->dyn_relocs; p != NULL; p = p->next)
|
{
|
{
|
asection *sreloc = elf_section_data (p->sec)->sreloc;
|
asection *sreloc = elf_section_data (p->sec)->sreloc;
|
|
if (!htab->elf.dynamic_sections_created)
|
|
sreloc = htab->reliplt;
|
sreloc->size += p->count * sizeof (Elf32_External_Rela);
|
sreloc->size += p->count * sizeof (Elf32_External_Rela);
|
}
|
}
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
| Line 4929... |
Line 5576... |
relocs. */
|
relocs. */
|
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
|
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
|
{
|
{
|
bfd_signed_vma *local_got;
|
bfd_signed_vma *local_got;
|
bfd_signed_vma *end_local_got;
|
bfd_signed_vma *end_local_got;
|
|
struct plt_entry **local_plt;
|
|
struct plt_entry **end_local_plt;
|
char *lgot_masks;
|
char *lgot_masks;
|
bfd_size_type locsymcount;
|
bfd_size_type locsymcount;
|
Elf_Internal_Shdr *symtab_hdr;
|
Elf_Internal_Shdr *symtab_hdr;
|
|
|
if (!is_ppc_elf (ibfd))
|
if (!is_ppc_elf (ibfd))
|
| Line 4953... |
Line 5602... |
/* Input section has been discarded, either because
|
/* Input section has been discarded, either because
|
it is a copy of a linkonce section or due to
|
it is a copy of a linkonce section or due to
|
linker script /DISCARD/, so we'll be discarding
|
linker script /DISCARD/, so we'll be discarding
|
the relocs too. */
|
the relocs too. */
|
}
|
}
|
|
else if (htab->is_vxworks
|
|
&& strcmp (p->sec->output_section->name,
|
|
".tls_vars") == 0)
|
|
{
|
|
/* Relocations in vxworks .tls_vars sections are
|
|
handled specially by the loader. */
|
|
}
|
else if (p->count != 0)
|
else if (p->count != 0)
|
{
|
{
|
elf_section_data (p->sec)->sreloc->size
|
asection *sreloc = elf_section_data (p->sec)->sreloc;
|
+= p->count * sizeof (Elf32_External_Rela);
|
if (!htab->elf.dynamic_sections_created)
|
|
sreloc = htab->reliplt;
|
|
sreloc->size += p->count * sizeof (Elf32_External_Rela);
|
if ((p->sec->output_section->flags
|
if ((p->sec->output_section->flags
|
& (SEC_READONLY | SEC_ALLOC))
|
& (SEC_READONLY | SEC_ALLOC))
|
== (SEC_READONLY | SEC_ALLOC))
|
== (SEC_READONLY | SEC_ALLOC))
|
info->flags |= DF_TEXTREL;
|
info->flags |= DF_TEXTREL;
|
}
|
}
|
| Line 4972... |
Line 5630... |
continue;
|
continue;
|
|
|
symtab_hdr = &elf_symtab_hdr (ibfd);
|
symtab_hdr = &elf_symtab_hdr (ibfd);
|
locsymcount = symtab_hdr->sh_info;
|
locsymcount = symtab_hdr->sh_info;
|
end_local_got = local_got + locsymcount;
|
end_local_got = local_got + locsymcount;
|
lgot_masks = (char *) end_local_got;
|
local_plt = (struct plt_entry **) end_local_got;
|
|
end_local_plt = local_plt + locsymcount;
|
|
lgot_masks = (char *) end_local_plt;
|
|
|
for (; local_got < end_local_got; ++local_got, ++lgot_masks)
|
for (; local_got < end_local_got; ++local_got, ++lgot_masks)
|
if (*local_got > 0)
|
if (*local_got > 0)
|
{
|
{
|
if (*lgot_masks == (TLS_TLS | TLS_LD))
|
|
{
|
|
/* If just an LD reloc, we'll just use
|
|
htab->tlsld_got.offset. */
|
|
htab->tlsld_got.refcount += 1;
|
|
*local_got = (bfd_vma) -1;
|
|
}
|
|
else
|
|
{
|
|
unsigned int need = 0;
|
unsigned int need = 0;
|
if ((*lgot_masks & TLS_TLS) != 0)
|
if ((*lgot_masks & TLS_TLS) != 0)
|
{
|
{
|
if ((*lgot_masks & TLS_GD) != 0)
|
if ((*lgot_masks & TLS_GD) != 0)
|
need += 8;
|
need += 8;
|
|
if ((*lgot_masks & TLS_LD) != 0)
|
|
htab->tlsld_got.refcount += 1;
|
if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
|
if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
|
need += 4;
|
need += 4;
|
if ((*lgot_masks & TLS_DTPREL) != 0)
|
if ((*lgot_masks & TLS_DTPREL) != 0)
|
need += 4;
|
need += 4;
|
}
|
}
|
else
|
else
|
need += 4;
|
need += 4;
|
|
if (need == 0)
|
|
*local_got = (bfd_vma) -1;
|
|
else
|
|
{
|
*local_got = allocate_got (htab, need);
|
*local_got = allocate_got (htab, need);
|
if (info->shared)
|
if (info->shared)
|
htab->relgot->size += (need
|
htab->relgot->size += (need
|
* (sizeof (Elf32_External_Rela) / 4));
|
* (sizeof (Elf32_External_Rela) / 4));
|
}
|
}
|
}
|
}
|
else
|
else
|
*local_got = (bfd_vma) -1;
|
*local_got = (bfd_vma) -1;
|
|
|
|
if (htab->is_vxworks)
|
|
continue;
|
|
|
|
/* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
|
|
for (; local_plt < end_local_plt; ++local_plt)
|
|
{
|
|
struct plt_entry *ent;
|
|
bfd_boolean doneone = FALSE;
|
|
bfd_vma plt_offset = 0, glink_offset = 0;
|
|
|
|
for (ent = *local_plt; ent != NULL; ent = ent->next)
|
|
if (ent->plt.refcount > 0)
|
|
{
|
|
s = htab->iplt;
|
|
|
|
if (!doneone)
|
|
{
|
|
plt_offset = s->size;
|
|
s->size += 4;
|
|
}
|
|
ent->plt.offset = plt_offset;
|
|
|
|
s = htab->glink;
|
|
if (!doneone || info->shared)
|
|
{
|
|
glink_offset = s->size;
|
|
s->size += GLINK_ENTRY_SIZE;
|
|
}
|
|
ent->glink_offset = glink_offset;
|
|
|
|
if (!doneone)
|
|
{
|
|
htab->reliplt->size += sizeof (Elf32_External_Rela);
|
|
doneone = TRUE;
|
|
}
|
|
}
|
|
else
|
|
ent->plt.offset = (bfd_vma) -1;
|
|
}
|
}
|
}
|
|
|
/* Allocate space for global sym dynamic relocs. */
|
/* Allocate space for global sym dynamic relocs. */
|
elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
|
elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
|
|
|
| Line 5037... |
Line 5735... |
htab->got->size += htab->got_header_size;
|
htab->got->size += htab->got_header_size;
|
}
|
}
|
|
|
htab->elf.hgot->root.u.def.value = g_o_t;
|
htab->elf.hgot->root.u.def.value = g_o_t;
|
}
|
}
|
|
if (info->shared)
|
|
{
|
|
struct elf_link_hash_entry *sda = htab->sdata[0].sym;
|
|
if (sda != NULL
|
|
&& !(sda->root.type == bfd_link_hash_defined
|
|
|| sda->root.type == bfd_link_hash_defweak))
|
|
{
|
|
sda->root.type = bfd_link_hash_defined;
|
|
sda->root.u.def.section = htab->elf.hgot->root.u.def.section;
|
|
sda->root.u.def.value = htab->elf.hgot->root.u.def.value;
|
|
}
|
|
}
|
|
|
if (htab->glink != NULL && htab->glink->size != 0)
|
if (htab->glink != NULL
|
|
&& htab->glink->size != 0
|
|
&& htab->elf.dynamic_sections_created)
|
{
|
{
|
htab->glink_pltresolve = htab->glink->size;
|
htab->glink_pltresolve = htab->glink->size;
|
/* Space for the branch table. */
|
/* Space for the branch table. */
|
htab->glink->size += htab->glink->size / (GLINK_ENTRY_SIZE / 4) - 4;
|
htab->glink->size += htab->glink->size / (GLINK_ENTRY_SIZE / 4) - 4;
|
/* Pad out to align the start of PLTresolve. */
|
/* Pad out to align the start of PLTresolve. */
|
| Line 5094... |
Line 5806... |
|
|
if ((s->flags & SEC_LINKER_CREATED) == 0)
|
if ((s->flags & SEC_LINKER_CREATED) == 0)
|
continue;
|
continue;
|
|
|
if (s == htab->plt
|
if (s == htab->plt
|
|| s == htab->glink
|
|| s == htab->got)
|
|| s == htab->got
|
|
|| s == htab->sgotplt
|
|
|| s == htab->sbss
|
|
|| s == htab->dynbss
|
|
|| s == htab->dynsbss)
|
|
{
|
{
|
/* We'd like to strip these sections if they aren't needed, but if
|
/* We'd like to strip these sections if they aren't needed, but if
|
we've exported dynamic symbols from them we must leave them.
|
we've exported dynamic symbols from them we must leave them.
|
It's too late to tell BFD to get rid of the symbols. */
|
It's too late to tell BFD to get rid of the symbols. */
|
if ((s == htab->plt || s == htab->got) && htab->elf.hplt != NULL)
|
if (htab->elf.hplt != NULL)
|
strip_section = FALSE;
|
strip_section = FALSE;
|
/* Strip this section if we don't need it; see the
|
/* Strip this section if we don't need it; see the
|
comment below. */
|
comment below. */
|
}
|
}
|
else if (s == htab->sdata[0].section
|
else if (s == htab->iplt
|
|
|| s == htab->glink
|
|
|| s == htab->sgotplt
|
|
|| s == htab->sbss
|
|
|| s == htab->dynbss
|
|
|| s == htab->dynsbss
|
|
|| s == htab->sdata[0].section
|
|| s == htab->sdata[1].section)
|
|| s == htab->sdata[1].section)
|
{
|
{
|
/* Strip these too. */
|
/* Strip these too. */
|
}
|
}
|
else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
|
else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
|
| Line 5185... |
Line 5898... |
|
|
if (htab->glink != NULL && htab->glink->size != 0)
|
if (htab->glink != NULL && htab->glink->size != 0)
|
{
|
{
|
if (!add_dynamic_entry (DT_PPC_GOT, 0))
|
if (!add_dynamic_entry (DT_PPC_GOT, 0))
|
return FALSE;
|
return FALSE;
|
|
if (!htab->no_tls_get_addr_opt
|
|
&& htab->tls_get_addr != NULL
|
|
&& htab->tls_get_addr->plt.plist != NULL
|
|
&& !add_dynamic_entry (DT_PPC_TLSOPT, 0))
|
|
return FALSE;
|
}
|
}
|
|
|
if (relocs)
|
if (relocs)
|
{
|
{
|
if (!add_dynamic_entry (DT_RELA, 0)
|
if (!add_dynamic_entry (DT_RELA, 0)
|
| Line 5231... |
Line 5949... |
return _bfd_elf_hash_symbol (h);
|
return _bfd_elf_hash_symbol (h);
|
}
|
}
|
|
|
#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
|
#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
|
|
|
|
/* Relaxation trampolines. r12 is available for clobbering (r11, is
|
|
used for some functions that are allowed to break the ABI). */
|
static const int shared_stub_entry[] =
|
static const int shared_stub_entry[] =
|
{
|
{
|
0x7c0802a6, /* mflr 0 */
|
0x7c0802a6, /* mflr 0 */
|
0x429f0005, /* bcl 20, 31, .Lxxx */
|
0x429f0005, /* bcl 20, 31, .Lxxx */
|
0x7d6802a6, /* mflr 11 */
|
0x7d8802a6, /* mflr 12 */
|
0x3d6b0000, /* addis 11, 11, (xxx-.Lxxx)@ha */
|
0x3d8c0000, /* addis 12, 12, (xxx-.Lxxx)@ha */
|
0x396b0018, /* addi 11, 11, (xxx-.Lxxx)@l */
|
0x398c0008, /* addi 12, 12, (xxx-.Lxxx)@l */
|
0x7c0803a6, /* mtlr 0 */
|
0x7c0803a6, /* mtlr 0 */
|
0x7d6903a6, /* mtctr 11 */
|
0x7d8903a6, /* mtctr 12 */
|
0x4e800420, /* bctr */
|
0x4e800420, /* bctr */
|
};
|
};
|
|
|
static const int stub_entry[] =
|
static const int stub_entry[] =
|
{
|
{
|
0x3d600000, /* lis 11,xxx@ha */
|
0x3d800000, /* lis 12,xxx@ha */
|
0x396b0000, /* addi 11,11,xxx@l */
|
0x398c0000, /* addi 12,12,xxx@l */
|
0x7d6903a6, /* mtctr 11 */
|
0x7d8903a6, /* mtctr 12 */
|
0x4e800420, /* bctr */
|
0x4e800420, /* bctr */
|
};
|
};
|
|
|
static bfd_boolean
|
static bfd_boolean
|
ppc_elf_relax_section (bfd *abfd,
|
ppc_elf_relax_section (bfd *abfd,
|
| Line 5261... |
Line 5981... |
{
|
{
|
struct one_fixup
|
struct one_fixup
|
{
|
{
|
struct one_fixup *next;
|
struct one_fixup *next;
|
asection *tsec;
|
asection *tsec;
|
|
/* Final link, can use the symbol offset. For a
|
|
relocatable link we use the symbol's index. */
|
bfd_vma toff;
|
bfd_vma toff;
|
bfd_vma trampoff;
|
bfd_vma trampoff;
|
};
|
};
|
|
|
Elf_Internal_Shdr *symtab_hdr;
|
Elf_Internal_Shdr *symtab_hdr;
|
bfd_byte *contents = NULL;
|
bfd_byte *contents = NULL;
|
Elf_Internal_Sym *isymbuf = NULL;
|
Elf_Internal_Sym *isymbuf = NULL;
|
Elf_Internal_Rela *internal_relocs = NULL;
|
Elf_Internal_Rela *internal_relocs = NULL;
|
Elf_Internal_Rela *irel, *irelend;
|
Elf_Internal_Rela *irel, *irelend;
|
struct one_fixup *fixups = NULL;
|
struct one_fixup *fixups = NULL;
|
bfd_boolean changed;
|
unsigned changes = 0;
|
struct ppc_elf_link_hash_table *htab;
|
struct ppc_elf_link_hash_table *htab;
|
bfd_size_type trampoff;
|
bfd_size_type trampoff;
|
asection *got2;
|
asection *got2;
|
|
|
*again = FALSE;
|
*again = FALSE;
|
|
|
/* Nothing to do if there are no relocations, and no need to do
|
/* Nothing to do if there are no relocations, and no need to do
|
anything with non-alloc sections. */
|
anything with non-alloc or non-code sections. */
|
if ((isec->flags & SEC_ALLOC) == 0
|
if ((isec->flags & SEC_ALLOC) == 0
|
|
|| (isec->flags & SEC_CODE) == 0
|
|| (isec->flags & SEC_RELOC) == 0
|
|| (isec->flags & SEC_RELOC) == 0
|
|| isec->reloc_count == 0)
|
|| isec->reloc_count == 0)
|
return TRUE;
|
return TRUE;
|
|
|
|
/* We cannot represent the required PIC relocs in the output, so don't
|
|
do anything. The linker doesn't support mixing -shared and -r
|
|
anyway. */
|
|
if (link_info->relocatable && link_info->shared)
|
|
return TRUE;
|
|
|
trampoff = (isec->size + 3) & (bfd_vma) -4;
|
trampoff = (isec->size + 3) & (bfd_vma) -4;
|
/* Space for a branch around any trampolines. */
|
/* Space for a branch around any trampolines. */
|
trampoff += 4;
|
trampoff += 4;
|
|
|
symtab_hdr = &elf_symtab_hdr (abfd);
|
symtab_hdr = &elf_symtab_hdr (abfd);
|
| Line 5304... |
Line 6033... |
|
|
irelend = internal_relocs + isec->reloc_count;
|
irelend = internal_relocs + isec->reloc_count;
|
for (irel = internal_relocs; irel < irelend; irel++)
|
for (irel = internal_relocs; irel < irelend; irel++)
|
{
|
{
|
unsigned long r_type = ELF32_R_TYPE (irel->r_info);
|
unsigned long r_type = ELF32_R_TYPE (irel->r_info);
|
bfd_vma symaddr, reladdr, toff, roff;
|
bfd_vma toff, roff;
|
asection *tsec;
|
asection *tsec;
|
struct one_fixup *f;
|
struct one_fixup *f;
|
size_t insn_offset = 0;
|
size_t insn_offset = 0;
|
bfd_vma max_branch_offset, val;
|
bfd_vma max_branch_offset, val;
|
bfd_byte *hit_addr;
|
bfd_byte *hit_addr;
|
unsigned long t0;
|
unsigned long t0;
|
|
struct elf_link_hash_entry *h;
|
|
struct plt_entry **plist;
|
unsigned char sym_type;
|
unsigned char sym_type;
|
|
|
switch (r_type)
|
switch (r_type)
|
{
|
{
|
case R_PPC_REL24:
|
case R_PPC_REL24:
|
| Line 5332... |
Line 6063... |
default:
|
default:
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Get the value of the symbol referred to by the reloc. */
|
/* Get the value of the symbol referred to by the reloc. */
|
|
h = NULL;
|
if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
|
if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
|
{
|
{
|
/* A local symbol. */
|
/* A local symbol. */
|
Elf_Internal_Sym *isym;
|
Elf_Internal_Sym *isym;
|
|
|
| Line 5350... |
Line 6082... |
if (isymbuf == 0)
|
if (isymbuf == 0)
|
goto error_return;
|
goto error_return;
|
}
|
}
|
isym = isymbuf + ELF32_R_SYM (irel->r_info);
|
isym = isymbuf + ELF32_R_SYM (irel->r_info);
|
if (isym->st_shndx == SHN_UNDEF)
|
if (isym->st_shndx == SHN_UNDEF)
|
continue; /* We can't do anything with undefined symbols. */
|
tsec = bfd_und_section_ptr;
|
else if (isym->st_shndx == SHN_ABS)
|
else if (isym->st_shndx == SHN_ABS)
|
tsec = bfd_abs_section_ptr;
|
tsec = bfd_abs_section_ptr;
|
else if (isym->st_shndx == SHN_COMMON)
|
else if (isym->st_shndx == SHN_COMMON)
|
tsec = bfd_com_section_ptr;
|
tsec = bfd_com_section_ptr;
|
else
|
else
|
| Line 5365... |
Line 6097... |
}
|
}
|
else
|
else
|
{
|
{
|
/* Global symbol handling. */
|
/* Global symbol handling. */
|
unsigned long indx;
|
unsigned long indx;
|
struct elf_link_hash_entry *h;
|
|
|
|
indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
|
indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
|
h = elf_sym_hashes (abfd)[indx];
|
h = elf_sym_hashes (abfd)[indx];
|
|
|
while (h->root.type == bfd_link_hash_indirect
|
while (h->root.type == bfd_link_hash_indirect
|
|| h->root.type == bfd_link_hash_warning)
|
|| h->root.type == bfd_link_hash_warning)
|
h = (struct elf_link_hash_entry *) h->root.u.i.link;
|
h = (struct elf_link_hash_entry *) h->root.u.i.link;
|
|
|
tsec = NULL;
|
if (h->root.type == bfd_link_hash_defined
|
toff = 0;
|
|| h->root.type == bfd_link_hash_defweak)
|
if (r_type == R_PPC_PLTREL24
|
|
&& htab->plt != NULL)
|
|
{
|
|
struct plt_entry *ent = find_plt_ent (h, got2, irel->r_addend);
|
|
|
|
if (ent != NULL)
|
|
{
|
{
|
if (htab->plt_type == PLT_NEW)
|
tsec = h->root.u.def.section;
|
|
toff = h->root.u.def.value;
|
|
}
|
|
else if (h->root.type == bfd_link_hash_undefined
|
|
|| h->root.type == bfd_link_hash_undefweak)
|
{
|
{
|
tsec = htab->glink;
|
tsec = bfd_und_section_ptr;
|
toff = ent->glink_offset;
|
toff = link_info->relocatable ? indx : 0;
|
}
|
}
|
else
|
else
|
{
|
continue;
|
tsec = htab->plt;
|
|
toff = ent->plt.offset;
|
sym_type = h->type;
|
}
|
|
}
|
}
|
|
|
|
/* The condition here under which we call find_plt_ent must
|
|
match that in relocate_section. If we call find_plt_ent here
|
|
but not in relocate_section, or vice versa, then the branch
|
|
destination used here may be incorrect. */
|
|
plist = NULL;
|
|
if (h != NULL)
|
|
{
|
|
/* We know is_branch_reloc (r_type) is true. */
|
|
if (h->type == STT_GNU_IFUNC
|
|
|| r_type == R_PPC_PLTREL24)
|
|
plist = &h->plt.plist;
|
|
}
|
|
else if (sym_type == STT_GNU_IFUNC
|
|
&& elf_local_got_offsets (abfd) != NULL)
|
|
{
|
|
bfd_vma *local_got_offsets = elf_local_got_offsets (abfd);
|
|
struct plt_entry **local_plt = (struct plt_entry **)
|
|
(local_got_offsets + symtab_hdr->sh_info);
|
|
plist = local_plt + ELF32_R_SYM (irel->r_info);
|
}
|
}
|
if (tsec != NULL)
|
if (plist != NULL)
|
;
|
|
else if (h->root.type == bfd_link_hash_defined
|
|
|| h->root.type == bfd_link_hash_defweak)
|
|
{
|
{
|
tsec = h->root.u.def.section;
|
bfd_vma addend = 0;
|
toff = h->root.u.def.value;
|
struct plt_entry *ent;
|
|
|
|
if (r_type == R_PPC_PLTREL24 && link_info->shared)
|
|
addend = irel->r_addend;
|
|
ent = find_plt_ent (plist, got2, addend);
|
|
if (ent != NULL)
|
|
{
|
|
if (htab->plt_type == PLT_NEW
|
|
|| h == NULL
|
|
|| !htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
|
{
|
|
tsec = htab->glink;
|
|
toff = ent->glink_offset;
|
}
|
}
|
else
|
else
|
continue;
|
{
|
|
tsec = htab->plt;
|
sym_type = h->type;
|
toff = ent->plt.offset;
|
|
}
|
|
}
|
}
|
}
|
|
|
/* If the branch and target are in the same section, you have
|
/* If the branch and target are in the same section, you have
|
no hope of adding stubs. We'll error out later should the
|
no hope of adding stubs. We'll error out later should the
|
branch overflow. */
|
branch overflow. */
|
| Line 5456... |
Line 6216... |
|
|
/* Attempted -shared link of non-pic code loses. */
|
/* Attempted -shared link of non-pic code loses. */
|
if (tsec->output_section == NULL)
|
if (tsec->output_section == NULL)
|
continue;
|
continue;
|
|
|
symaddr = tsec->output_section->vma + tsec->output_offset + toff;
|
|
|
|
roff = irel->r_offset;
|
roff = irel->r_offset;
|
reladdr = isec->output_section->vma + isec->output_offset + roff;
|
|
|
|
/* If the branch is in range, no need to do anything. */
|
/* If the branch is in range, no need to do anything. */
|
|
if (tsec != bfd_und_section_ptr
|
|
&& (!link_info->relocatable
|
|
/* A relocatable link may have sections moved during
|
|
final link, so do not presume they remain in range. */
|
|
|| tsec->output_section == isec->output_section))
|
|
{
|
|
bfd_vma symaddr, reladdr;
|
|
|
|
symaddr = tsec->output_section->vma + tsec->output_offset + toff;
|
|
reladdr = isec->output_section->vma + isec->output_offset + roff;
|
if (symaddr - reladdr + max_branch_offset < 2 * max_branch_offset)
|
if (symaddr - reladdr + max_branch_offset < 2 * max_branch_offset)
|
continue;
|
continue;
|
|
}
|
|
|
/* Look for an existing fixup to this address. */
|
/* Look for an existing fixup to this address. */
|
for (f = fixups; f ; f = f->next)
|
for (f = fixups; f ; f = f->next)
|
if (f->tsec == tsec && f->toff == toff)
|
if (f->tsec == tsec && f->toff == toff)
|
break;
|
break;
|
| Line 5485... |
Line 6253... |
|
|
if (link_info->shared)
|
if (link_info->shared)
|
{
|
{
|
size = 4 * ARRAY_SIZE (shared_stub_entry);
|
size = 4 * ARRAY_SIZE (shared_stub_entry);
|
insn_offset = 12;
|
insn_offset = 12;
|
stub_rtype = R_PPC_RELAX32PC;
|
|
}
|
}
|
else
|
else
|
{
|
{
|
size = 4 * ARRAY_SIZE (stub_entry);
|
size = 4 * ARRAY_SIZE (stub_entry);
|
insn_offset = 0;
|
insn_offset = 0;
|
stub_rtype = R_PPC_RELAX32;
|
|
}
|
}
|
|
stub_rtype = R_PPC_RELAX;
|
if (R_PPC_RELAX32_PLT - R_PPC_RELAX32
|
|
!= R_PPC_RELAX32PC_PLT - R_PPC_RELAX32PC)
|
|
abort ();
|
|
if (tsec == htab->plt
|
if (tsec == htab->plt
|
|| tsec == htab->glink)
|
|| tsec == htab->glink)
|
stub_rtype += R_PPC_RELAX32_PLT - R_PPC_RELAX32;
|
{
|
|
stub_rtype = R_PPC_RELAX_PLT;
|
|
if (r_type == R_PPC_PLTREL24)
|
|
stub_rtype = R_PPC_RELAX_PLTREL24;
|
|
}
|
|
|
/* Hijack the old relocation. Since we need two
|
/* Hijack the old relocation. Since we need two
|
relocations for this use a "composite" reloc. */
|
relocations for this use a "composite" reloc. */
|
irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
|
irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
|
stub_rtype);
|
stub_rtype);
|
irel->r_offset = trampoff + insn_offset;
|
irel->r_offset = trampoff + insn_offset;
|
|
if (r_type == R_PPC_PLTREL24
|
|
&& stub_rtype != R_PPC_RELAX_PLTREL24)
|
|
irel->r_addend = 0;
|
|
|
/* Record the fixup so we don't do it again this section. */
|
/* Record the fixup so we don't do it again this section. */
|
f = bfd_malloc (sizeof (*f));
|
f = bfd_malloc (sizeof (*f));
|
f->next = fixups;
|
f->next = fixups;
|
f->tsec = tsec;
|
f->tsec = tsec;
|
f->toff = toff;
|
f->toff = toff;
|
f->trampoff = trampoff;
|
f->trampoff = trampoff;
|
fixups = f;
|
fixups = f;
|
|
|
trampoff += size;
|
trampoff += size;
|
|
changes++;
|
}
|
}
|
else
|
else
|
{
|
{
|
val = f->trampoff - roff;
|
val = f->trampoff - roff;
|
if (val >= max_branch_offset)
|
if (val >= max_branch_offset)
|
| Line 5566... |
Line 6337... |
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Write out the trampolines. */
|
/* Write out the trampolines. */
|
changed = fixups != NULL;
|
|
if (fixups != NULL)
|
if (fixups != NULL)
|
{
|
{
|
const int *stub;
|
const int *stub;
|
bfd_byte *dest;
|
bfd_byte *dest;
|
bfd_vma val;
|
bfd_vma val;
|
| Line 5588... |
Line 6358... |
if (contents == NULL)
|
if (contents == NULL)
|
goto error_return;
|
goto error_return;
|
|
|
isec->size = (isec->size + 3) & (bfd_vma) -4;
|
isec->size = (isec->size + 3) & (bfd_vma) -4;
|
/* Branch around the trampolines. */
|
/* Branch around the trampolines. */
|
val = trampoff - isec->size + 0x48000000;
|
val = B + trampoff - isec->size;
|
dest = contents + isec->size;
|
dest = contents + isec->size;
|
isec->size = trampoff;
|
isec->size = trampoff;
|
bfd_put_32 (abfd, val, dest);
|
bfd_put_32 (abfd, val, dest);
|
dest += 4;
|
dest += 4;
|
|
|
| Line 5632... |
Line 6402... |
}
|
}
|
|
|
if (contents != NULL
|
if (contents != NULL
|
&& elf_section_data (isec)->this_hdr.contents != contents)
|
&& elf_section_data (isec)->this_hdr.contents != contents)
|
{
|
{
|
if (!changed && !link_info->keep_memory)
|
if (!changes && !link_info->keep_memory)
|
free (contents);
|
free (contents);
|
else
|
else
|
{
|
{
|
/* Cache the section contents for elf_link_input_bfd. */
|
/* Cache the section contents for elf_link_input_bfd. */
|
elf_section_data (isec)->this_hdr.contents = contents;
|
elf_section_data (isec)->this_hdr.contents = contents;
|
}
|
}
|
}
|
}
|
|
|
if (elf_section_data (isec)->relocs != internal_relocs)
|
if (changes != 0)
|
{
|
{
|
if (!changed)
|
/* Append sufficient NOP relocs so we can write out relocation
|
|
information for the trampolines. */
|
|
Elf_Internal_Rela *new_relocs = bfd_malloc ((changes + isec->reloc_count)
|
|
* sizeof (*new_relocs));
|
|
unsigned ix;
|
|
|
|
if (!new_relocs)
|
|
goto error_return;
|
|
memcpy (new_relocs, internal_relocs,
|
|
isec->reloc_count * sizeof (*new_relocs));
|
|
for (ix = changes; ix--;)
|
|
{
|
|
irel = new_relocs + ix + isec->reloc_count;
|
|
|
|
irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
|
|
}
|
|
if (internal_relocs != elf_section_data (isec)->relocs)
|
free (internal_relocs);
|
free (internal_relocs);
|
else
|
elf_section_data (isec)->relocs = new_relocs;
|
elf_section_data (isec)->relocs = internal_relocs;
|
isec->reloc_count += changes;
|
|
elf_section_data (isec)->rel_hdr.sh_size
|
|
+= changes * elf_section_data (isec)->rel_hdr.sh_entsize;
|
|
}
|
|
else if (elf_section_data (isec)->relocs != internal_relocs)
|
|
free (internal_relocs);
|
|
|
|
*again = changes != 0;
|
|
if (!*again && link_info->relocatable)
|
|
{
|
|
/* Convert the internal relax relocs to external form. */
|
|
for (irel = internal_relocs; irel < irelend; irel++)
|
|
if (ELF32_R_TYPE (irel->r_info) == R_PPC_RELAX)
|
|
{
|
|
unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
|
|
|
|
/* Rewrite the reloc and convert one of the trailing nop
|
|
relocs to describe this relocation. */
|
|
BFD_ASSERT (ELF32_R_TYPE (irelend[-1].r_info) == R_PPC_NONE);
|
|
/* The relocs are at the bottom 2 bytes */
|
|
irel[0].r_offset += 2;
|
|
memmove (irel + 1, irel, (irelend - irel - 1) * sizeof (*irel));
|
|
irel[0].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
|
|
irel[1].r_offset += 4;
|
|
irel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
|
|
irel++;
|
|
}
|
}
|
}
|
|
|
*again = changed;
|
|
return TRUE;
|
return TRUE;
|
|
|
error_return:
|
error_return:
|
if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
|
if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
|
free (isymbuf);
|
free (isymbuf);
|
| Line 5726... |
Line 6537... |
relocation + linker_section_ptr->addend,
|
relocation + linker_section_ptr->addend,
|
lsect->section->contents + linker_section_ptr->offset);
|
lsect->section->contents + linker_section_ptr->offset);
|
linker_section_ptr->offset += 1;
|
linker_section_ptr->offset += 1;
|
}
|
}
|
|
|
relocation = (lsect->section->output_offset
|
relocation = (lsect->section->output_section->vma
|
|
+ lsect->section->output_offset
|
+ linker_section_ptr->offset - 1
|
+ linker_section_ptr->offset - 1
|
- 0x8000);
|
- SYM_VAL (lsect->sym));
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
fprintf (stderr,
|
fprintf (stderr,
|
"Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
|
"Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
|
lsect->name, (long) relocation, (long) relocation);
|
lsect->name, (long) relocation, (long) relocation);
|
#endif
|
#endif
|
|
|
/* Subtract out the addend, because it will get added back in by the normal
|
return relocation;
|
processing. */
|
}
|
return relocation - linker_section_ptr->addend;
|
|
|
#define PPC_LO(v) ((v) & 0xffff)
|
|
#define PPC_HI(v) (((v) >> 16) & 0xffff)
|
|
#define PPC_HA(v) PPC_HI ((v) + 0x8000)
|
|
|
|
static void
|
|
write_glink_stub (struct plt_entry *ent, asection *plt_sec, unsigned char *p,
|
|
struct bfd_link_info *info)
|
|
{
|
|
struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
|
|
bfd *output_bfd = info->output_bfd;
|
|
bfd_vma plt;
|
|
|
|
plt = ((ent->plt.offset & ~1)
|
|
+ plt_sec->output_section->vma
|
|
+ plt_sec->output_offset);
|
|
|
|
if (info->shared)
|
|
{
|
|
bfd_vma got = 0;
|
|
|
|
if (ent->addend >= 32768)
|
|
got = (ent->addend
|
|
+ ent->sec->output_section->vma
|
|
+ ent->sec->output_offset);
|
|
else if (htab->elf.hgot != NULL)
|
|
got = SYM_VAL (htab->elf.hgot);
|
|
|
|
plt -= got;
|
|
|
|
if (plt + 0x8000 < 0x10000)
|
|
{
|
|
bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, MTCTR_11, p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, BCTR, p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, NOP, p);
|
|
p += 4;
|
|
}
|
|
else
|
|
{
|
|
bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, MTCTR_11, p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, BCTR, p);
|
|
p += 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, MTCTR_11, p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, BCTR, p);
|
|
p += 4;
|
|
}
|
|
}
|
|
|
|
/* Return true if symbol is defined statically. */
|
|
|
|
static bfd_boolean
|
|
is_static_defined (struct elf_link_hash_entry *h)
|
|
{
|
|
return ((h->root.type == bfd_link_hash_defined
|
|
|| h->root.type == bfd_link_hash_defweak)
|
|
&& h->root.u.def.section != NULL
|
|
&& h->root.u.def.section->output_section != NULL);
|
|
}
|
|
|
|
/* If INSN is an opcode that may be used with an @tls operand, return
|
|
the transformed insn for TLS optimisation, otherwise return 0. If
|
|
REG is non-zero only match an insn with RB or RA equal to REG. */
|
|
|
|
unsigned int
|
|
_bfd_elf_ppc_at_tls_transform (unsigned int insn, unsigned int reg)
|
|
{
|
|
unsigned int rtra;
|
|
|
|
if ((insn & (0x3f << 26)) != 31 << 26)
|
|
return 0;
|
|
|
|
if (reg == 0 || ((insn >> 11) & 0x1f) == reg)
|
|
rtra = insn & ((1 << 26) - (1 << 16));
|
|
else if (((insn >> 16) & 0x1f) == reg)
|
|
rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5);
|
|
else
|
|
return 0;
|
|
|
|
if ((insn & (0x3ff << 1)) == 266 << 1)
|
|
/* add -> addi. */
|
|
insn = 14 << 26;
|
|
else if ((insn & (0x1f << 1)) == 23 << 1
|
|
&& ((insn & (0x1f << 6)) < 14 << 6
|
|
|| ((insn & (0x1f << 6)) >= 16 << 6
|
|
&& (insn & (0x1f << 6)) < 24 << 6)))
|
|
/* load and store indexed -> dform. */
|
|
insn = (32 | ((insn >> 6) & 0x1f)) << 26;
|
|
else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1)
|
|
/* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
|
|
insn = ((58 | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1);
|
|
else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1)
|
|
/* lwax -> lwa. */
|
|
insn = (58 << 26) | 2;
|
|
else
|
|
return 0;
|
|
insn |= rtra;
|
|
return insn;
|
|
}
|
|
|
|
/* If INSN is an opcode that may be used with an @tprel operand, return
|
|
the transformed insn for an undefined weak symbol, ie. with the
|
|
thread pointer REG operand removed. Otherwise return 0. */
|
|
|
|
unsigned int
|
|
_bfd_elf_ppc_at_tprel_transform (unsigned int insn, unsigned int reg)
|
|
{
|
|
if ((insn & (0x1f << 16)) == reg << 16
|
|
&& ((insn & (0x3f << 26)) == 14u << 26 /* addi */
|
|
|| (insn & (0x3f << 26)) == 15u << 26 /* addis */
|
|
|| (insn & (0x3f << 26)) == 32u << 26 /* lwz */
|
|
|| (insn & (0x3f << 26)) == 34u << 26 /* lbz */
|
|
|| (insn & (0x3f << 26)) == 36u << 26 /* stw */
|
|
|| (insn & (0x3f << 26)) == 38u << 26 /* stb */
|
|
|| (insn & (0x3f << 26)) == 40u << 26 /* lhz */
|
|
|| (insn & (0x3f << 26)) == 42u << 26 /* lha */
|
|
|| (insn & (0x3f << 26)) == 44u << 26 /* sth */
|
|
|| (insn & (0x3f << 26)) == 46u << 26 /* lmw */
|
|
|| (insn & (0x3f << 26)) == 47u << 26 /* stmw */
|
|
|| (insn & (0x3f << 26)) == 48u << 26 /* lfs */
|
|
|| (insn & (0x3f << 26)) == 50u << 26 /* lfd */
|
|
|| (insn & (0x3f << 26)) == 52u << 26 /* stfs */
|
|
|| (insn & (0x3f << 26)) == 54u << 26 /* stfd */
|
|
|| ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
|
|
&& (insn & 3) != 1)
|
|
|| ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
|
|
&& ((insn & 3) == 0 || (insn & 3) == 3))))
|
|
{
|
|
insn &= ~(0x1f << 16);
|
|
}
|
|
else if ((insn & (0x1f << 21)) == reg << 21
|
|
&& ((insn & (0x3e << 26)) == 24u << 26 /* ori, oris */
|
|
|| (insn & (0x3e << 26)) == 26u << 26 /* xori,xoris */
|
|
|| (insn & (0x3e << 26)) == 28u << 26 /* andi,andis */))
|
|
{
|
|
insn &= ~(0x1f << 21);
|
|
insn |= (insn & (0x1f << 16)) << 5;
|
|
if ((insn & (0x3e << 26)) == 26 << 26 /* xori,xoris */)
|
|
insn -= 2 >> 26; /* convert to ori,oris */
|
|
}
|
|
else
|
|
insn = 0;
|
|
return insn;
|
}
|
}
|
|
|
/* The RELOCATE_SECTION function is called by the ELF backend linker
|
/* The RELOCATE_SECTION function is called by the ELF backend linker
|
to handle the relocations for a section.
|
to handle the relocations for a section.
|
|
|
| Line 5786... |
Line 6757... |
struct elf_link_hash_entry **sym_hashes;
|
struct elf_link_hash_entry **sym_hashes;
|
struct ppc_elf_link_hash_table *htab;
|
struct ppc_elf_link_hash_table *htab;
|
Elf_Internal_Rela *rel;
|
Elf_Internal_Rela *rel;
|
Elf_Internal_Rela *relend;
|
Elf_Internal_Rela *relend;
|
Elf_Internal_Rela outrel;
|
Elf_Internal_Rela outrel;
|
bfd_byte *loc;
|
|
asection *got2, *sreloc = NULL;
|
asection *got2, *sreloc = NULL;
|
bfd_vma *local_got_offsets;
|
bfd_vma *local_got_offsets;
|
bfd_boolean ret = TRUE;
|
bfd_boolean ret = TRUE;
|
bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
|
bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
|
|
bfd_boolean is_vxworks_tls;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
_bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, "
|
_bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, "
|
"%ld relocations%s",
|
"%ld relocations%s",
|
input_bfd, input_section,
|
input_bfd, input_section,
|
| Line 5810... |
Line 6781... |
|
|
htab = ppc_elf_hash_table (info);
|
htab = ppc_elf_hash_table (info);
|
local_got_offsets = elf_local_got_offsets (input_bfd);
|
local_got_offsets = elf_local_got_offsets (input_bfd);
|
symtab_hdr = &elf_symtab_hdr (input_bfd);
|
symtab_hdr = &elf_symtab_hdr (input_bfd);
|
sym_hashes = elf_sym_hashes (input_bfd);
|
sym_hashes = elf_sym_hashes (input_bfd);
|
|
/* We have to handle relocations in vxworks .tls_vars sections
|
|
specially, because the dynamic loader is 'weird'. */
|
|
is_vxworks_tls = (htab->is_vxworks && info->shared
|
|
&& !strcmp (input_section->output_section->name,
|
|
".tls_vars"));
|
rel = relocs;
|
rel = relocs;
|
relend = relocs + input_section->reloc_count;
|
relend = relocs + input_section->reloc_count;
|
for (; rel < relend; rel++)
|
for (; rel < relend; rel++)
|
{
|
{
|
enum elf_ppc_reloc_type r_type;
|
enum elf_ppc_reloc_type r_type;
|
| Line 5824... |
Line 6800... |
struct elf_link_hash_entry *h;
|
struct elf_link_hash_entry *h;
|
const char *sym_name;
|
const char *sym_name;
|
reloc_howto_type *howto;
|
reloc_howto_type *howto;
|
unsigned long r_symndx;
|
unsigned long r_symndx;
|
bfd_vma relocation;
|
bfd_vma relocation;
|
bfd_vma branch_bit, insn, from;
|
bfd_vma branch_bit, from;
|
bfd_boolean unresolved_reloc;
|
bfd_boolean unresolved_reloc;
|
bfd_boolean warned;
|
bfd_boolean warned;
|
unsigned int tls_type, tls_mask, tls_gd;
|
unsigned int tls_type, tls_mask, tls_gd;
|
|
struct plt_entry **ifunc;
|
|
|
r_type = ELF32_R_TYPE (rel->r_info);
|
r_type = ELF32_R_TYPE (rel->r_info);
|
sym = NULL;
|
sym = NULL;
|
sec = NULL;
|
sec = NULL;
|
h = NULL;
|
h = NULL;
|
| Line 5888... |
Line 6865... |
based on information we collected in tls_optimize. We edit
|
based on information we collected in tls_optimize. We edit
|
RELOCS so that --emit-relocs will output something sensible
|
RELOCS so that --emit-relocs will output something sensible
|
for the final instruction stream. */
|
for the final instruction stream. */
|
tls_mask = 0;
|
tls_mask = 0;
|
tls_gd = 0;
|
tls_gd = 0;
|
if (IS_PPC_TLS_RELOC (r_type))
|
|
{
|
|
if (h != NULL)
|
if (h != NULL)
|
tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
|
tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
|
else if (local_got_offsets != NULL)
|
else if (local_got_offsets != NULL)
|
{
|
{
|
|
struct plt_entry **local_plt;
|
char *lgot_masks;
|
char *lgot_masks;
|
lgot_masks = (char *) (local_got_offsets + symtab_hdr->sh_info);
|
local_plt
|
|
= (struct plt_entry **) (local_got_offsets + symtab_hdr->sh_info);
|
|
lgot_masks = (char *) (local_plt + symtab_hdr->sh_info);
|
tls_mask = lgot_masks[r_symndx];
|
tls_mask = lgot_masks[r_symndx];
|
}
|
}
|
}
|
|
|
|
/* Ensure reloc mapping code below stays sane. */
|
/* Ensure reloc mapping code below stays sane. */
|
if ((R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TLSGD16 & 3)
|
if ((R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TLSGD16 & 3)
|
|| (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
|
|| (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
|
|| (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
|
|| (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
|
| Line 5917... |
Line 6894... |
default:
|
default:
|
break;
|
break;
|
|
|
case R_PPC_GOT_TPREL16:
|
case R_PPC_GOT_TPREL16:
|
case R_PPC_GOT_TPREL16_LO:
|
case R_PPC_GOT_TPREL16_LO:
|
if (tls_mask != 0
|
if ((tls_mask & TLS_TLS) != 0
|
&& (tls_mask & TLS_TPREL) == 0)
|
&& (tls_mask & TLS_TPREL) == 0)
|
{
|
{
|
bfd_vma insn;
|
bfd_vma insn;
|
|
|
insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
|
insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
|
insn &= 31 << 21;
|
insn &= 31 << 21;
|
insn |= 0x3c020000; /* addis 0,2,0 */
|
insn |= 0x3c020000; /* addis 0,2,0 */
|
bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
|
bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
|
r_type = R_PPC_TPREL16_HA;
|
r_type = R_PPC_TPREL16_HA;
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
}
|
}
|
break;
|
break;
|
|
|
case R_PPC_TLS:
|
case R_PPC_TLS:
|
if (tls_mask != 0
|
if ((tls_mask & TLS_TLS) != 0
|
&& (tls_mask & TLS_TPREL) == 0)
|
&& (tls_mask & TLS_TPREL) == 0)
|
{
|
{
|
bfd_vma insn, rtra;
|
bfd_vma insn;
|
|
|
insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
|
insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
|
if ((insn & ((31 << 26) | (31 << 11)))
|
insn = _bfd_elf_ppc_at_tls_transform (insn, 2);
|
== ((31 << 26) | (2 << 11)))
|
if (insn == 0)
|
rtra = insn & ((1 << 26) - (1 << 16));
|
|
else if ((insn & ((31 << 26) | (31 << 16)))
|
|
== ((31 << 26) | (2 << 16)))
|
|
rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
|
|
else
|
|
abort ();
|
|
if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
|
|
/* add -> addi. */
|
|
insn = 14 << 26;
|
|
else if ((insn & (31 << 1)) == 23 << 1
|
|
&& ((insn & (31 << 6)) < 14 << 6
|
|
|| ((insn & (31 << 6)) >= 16 << 6
|
|
&& (insn & (31 << 6)) < 24 << 6)))
|
|
/* load and store indexed -> dform. */
|
|
insn = (32 | ((insn >> 6) & 31)) << 26;
|
|
else if ((insn & (31 << 1)) == 21 << 1
|
|
&& (insn & (0x1a << 6)) == 0)
|
|
/* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
|
|
insn = (((58 | ((insn >> 6) & 4)) << 26)
|
|
| ((insn >> 6) & 1));
|
|
else if ((insn & (31 << 1)) == 21 << 1
|
|
&& (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
|
|
/* lwax -> lwa. */
|
|
insn = (58 << 26) | 2;
|
|
else
|
|
abort ();
|
abort ();
|
insn |= rtra;
|
|
bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
|
bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
|
r_type = R_PPC_TPREL16_LO;
|
r_type = R_PPC_TPREL16_LO;
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
|
|
/* Was PPC_TLS which sits on insn boundary, now
|
/* Was PPC_TLS which sits on insn boundary, now
|
| Line 5978... |
Line 6931... |
break;
|
break;
|
|
|
case R_PPC_GOT_TLSGD16_HI:
|
case R_PPC_GOT_TLSGD16_HI:
|
case R_PPC_GOT_TLSGD16_HA:
|
case R_PPC_GOT_TLSGD16_HA:
|
tls_gd = TLS_TPRELGD;
|
tls_gd = TLS_TPRELGD;
|
if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
|
if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
|
goto tls_gdld_hi;
|
goto tls_gdld_hi;
|
break;
|
break;
|
|
|
case R_PPC_GOT_TLSLD16_HI:
|
case R_PPC_GOT_TLSLD16_HI:
|
case R_PPC_GOT_TLSLD16_HA:
|
case R_PPC_GOT_TLSLD16_HA:
|
if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
|
if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
|
{
|
{
|
tls_gdld_hi:
|
tls_gdld_hi:
|
if ((tls_mask & tls_gd) != 0)
|
if ((tls_mask & tls_gd) != 0)
|
r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
|
r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
|
+ R_PPC_GOT_TPREL16);
|
+ R_PPC_GOT_TPREL16);
|
| Line 6003... |
Line 6956... |
break;
|
break;
|
|
|
case R_PPC_GOT_TLSGD16:
|
case R_PPC_GOT_TLSGD16:
|
case R_PPC_GOT_TLSGD16_LO:
|
case R_PPC_GOT_TLSGD16_LO:
|
tls_gd = TLS_TPRELGD;
|
tls_gd = TLS_TPRELGD;
|
if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
|
if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
|
goto tls_ldgd_opt;
|
goto tls_ldgd_opt;
|
break;
|
break;
|
|
|
case R_PPC_GOT_TLSLD16:
|
case R_PPC_GOT_TLSLD16:
|
case R_PPC_GOT_TLSLD16_LO:
|
case R_PPC_GOT_TLSLD16_LO:
|
if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
|
if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
|
{
|
{
|
bfd_vma insn1, insn2;
|
unsigned int insn1, insn2;
|
bfd_vma offset;
|
bfd_vma offset;
|
|
|
tls_ldgd_opt:
|
tls_ldgd_opt:
|
|
offset = (bfd_vma) -1;
|
|
/* If not using the newer R_PPC_TLSGD/LD to mark
|
|
__tls_get_addr calls, we must trust that the call
|
|
stays with its arg setup insns, ie. that the next
|
|
reloc is the __tls_get_addr call associated with
|
|
the current reloc. Edit both insns. */
|
|
if (input_section->has_tls_get_addr_call
|
|
&& rel + 1 < relend
|
|
&& branch_reloc_hash_match (input_bfd, rel + 1,
|
|
htab->tls_get_addr))
|
offset = rel[1].r_offset;
|
offset = rel[1].r_offset;
|
insn1 = bfd_get_32 (output_bfd,
|
|
contents + rel->r_offset - d_offset);
|
|
if ((tls_mask & tls_gd) != 0)
|
if ((tls_mask & tls_gd) != 0)
|
{
|
{
|
/* IE */
|
/* IE */
|
|
insn1 = bfd_get_32 (output_bfd,
|
|
contents + rel->r_offset - d_offset);
|
insn1 &= (1 << 26) - 1;
|
insn1 &= (1 << 26) - 1;
|
insn1 |= 32 << 26; /* lwz */
|
insn1 |= 32 << 26; /* lwz */
|
|
if (offset != (bfd_vma) -1)
|
|
{
|
|
rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
|
insn2 = 0x7c631214; /* add 3,3,2 */
|
insn2 = 0x7c631214; /* add 3,3,2 */
|
rel[1].r_info
|
bfd_put_32 (output_bfd, insn2, contents + offset);
|
= ELF32_R_INFO (ELF32_R_SYM (rel[1].r_info), R_PPC_NONE);
|
}
|
rel[1].r_addend = 0;
|
|
r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
|
r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
|
+ R_PPC_GOT_TPREL16);
|
+ R_PPC_GOT_TPREL16);
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* LE */
|
/* LE */
|
insn1 = 0x3c620000; /* addis 3,2,0 */
|
insn1 = 0x3c620000; /* addis 3,2,0 */
|
insn2 = 0x38630000; /* addi 3,3,0 */
|
|
if (tls_gd == 0)
|
if (tls_gd == 0)
|
{
|
{
|
/* Was an LD reloc. */
|
/* Was an LD reloc. */
|
|
for (r_symndx = 0;
|
|
r_symndx < symtab_hdr->sh_info;
|
|
r_symndx++)
|
|
if (local_sections[r_symndx] == sec)
|
|
break;
|
|
if (r_symndx >= symtab_hdr->sh_info)
|
r_symndx = 0;
|
r_symndx = 0;
|
rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
|
rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
|
|
if (r_symndx != 0)
|
|
rel->r_addend -= (local_syms[r_symndx].st_value
|
|
+ sec->output_offset
|
|
+ sec->output_section->vma);
|
}
|
}
|
r_type = R_PPC_TPREL16_HA;
|
r_type = R_PPC_TPREL16_HA;
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
rel[1].r_info = ELF32_R_INFO (r_symndx,
|
if (offset != (bfd_vma) -1)
|
R_PPC_TPREL16_LO);
|
{
|
rel[1].r_offset += d_offset;
|
rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
|
|
rel[1].r_offset = offset + d_offset;
|
rel[1].r_addend = rel->r_addend;
|
rel[1].r_addend = rel->r_addend;
|
|
insn2 = 0x38630000; /* addi 3,3,0 */
|
|
bfd_put_32 (output_bfd, insn2, contents + offset);
|
|
}
|
}
|
}
|
bfd_put_32 (output_bfd, insn1,
|
bfd_put_32 (output_bfd, insn1,
|
contents + rel->r_offset - d_offset);
|
contents + rel->r_offset - d_offset);
|
bfd_put_32 (output_bfd, insn2, contents + offset);
|
|
if (tls_gd == 0)
|
if (tls_gd == 0)
|
{
|
{
|
/* We changed the symbol on an LD reloc. Start over
|
/* We changed the symbol on an LD reloc. Start over
|
in order to get h, sym, sec etc. right. */
|
in order to get h, sym, sec etc. right. */
|
rel--;
|
rel--;
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
|
case R_PPC_TLSGD:
|
|
if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
|
|
{
|
|
unsigned int insn2;
|
|
bfd_vma offset = rel->r_offset;
|
|
|
|
if ((tls_mask & TLS_TPRELGD) != 0)
|
|
{
|
|
/* IE */
|
|
r_type = R_PPC_NONE;
|
|
insn2 = 0x7c631214; /* add 3,3,2 */
|
|
}
|
|
else
|
|
{
|
|
/* LE */
|
|
r_type = R_PPC_TPREL16_LO;
|
|
rel->r_offset += d_offset;
|
|
insn2 = 0x38630000; /* addi 3,3,0 */
|
|
}
|
|
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
|
|
bfd_put_32 (output_bfd, insn2, contents + offset);
|
|
/* Zap the reloc on the _tls_get_addr call too. */
|
|
BFD_ASSERT (offset == rel[1].r_offset);
|
|
rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
|
|
}
|
|
break;
|
|
|
|
case R_PPC_TLSLD:
|
|
if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
|
|
{
|
|
unsigned int insn2;
|
|
|
|
for (r_symndx = 0;
|
|
r_symndx < symtab_hdr->sh_info;
|
|
r_symndx++)
|
|
if (local_sections[r_symndx] == sec)
|
|
break;
|
|
if (r_symndx >= symtab_hdr->sh_info)
|
|
r_symndx = 0;
|
|
rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
|
|
if (r_symndx != 0)
|
|
rel->r_addend -= (local_syms[r_symndx].st_value
|
|
+ sec->output_offset
|
|
+ sec->output_section->vma);
|
|
|
|
rel->r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO);
|
|
rel->r_offset += d_offset;
|
|
insn2 = 0x38630000; /* addi 3,3,0 */
|
|
bfd_put_32 (output_bfd, insn2,
|
|
contents + rel->r_offset - d_offset);
|
|
/* Zap the reloc on the _tls_get_addr call too. */
|
|
BFD_ASSERT (rel->r_offset - d_offset == rel[1].r_offset);
|
|
rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE);
|
|
rel--;
|
|
continue;
|
|
}
|
|
break;
|
}
|
}
|
|
|
/* Handle other relocations that tweak non-addend part of insn. */
|
/* Handle other relocations that tweak non-addend part of insn. */
|
branch_bit = 0;
|
branch_bit = 0;
|
switch (r_type)
|
switch (r_type)
|
| Line 6079... |
Line 7114... |
/* Fall thru */
|
/* Fall thru */
|
|
|
/* Branch not taken prediction relocations. */
|
/* Branch not taken prediction relocations. */
|
case R_PPC_ADDR14_BRNTAKEN:
|
case R_PPC_ADDR14_BRNTAKEN:
|
case R_PPC_REL14_BRNTAKEN:
|
case R_PPC_REL14_BRNTAKEN:
|
|
{
|
|
bfd_vma insn;
|
|
|
insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
|
insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
|
insn &= ~BRANCH_PREDICT_BIT;
|
insn &= ~BRANCH_PREDICT_BIT;
|
insn |= branch_bit;
|
insn |= branch_bit;
|
|
|
from = (rel->r_offset
|
from = (rel->r_offset
|
| Line 6094... |
Line 7132... |
insn ^= BRANCH_PREDICT_BIT;
|
insn ^= BRANCH_PREDICT_BIT;
|
|
|
bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
|
bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
|
break;
|
break;
|
}
|
}
|
|
}
|
|
|
|
ifunc = NULL;
|
|
if (!htab->is_vxworks)
|
|
{
|
|
struct plt_entry *ent;
|
|
|
|
if (h != NULL)
|
|
{
|
|
if (h->type == STT_GNU_IFUNC)
|
|
ifunc = &h->plt.plist;
|
|
}
|
|
else if (local_got_offsets != NULL
|
|
&& ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
|
|
{
|
|
struct plt_entry **local_plt;
|
|
|
|
local_plt = (struct plt_entry **) (local_got_offsets
|
|
+ symtab_hdr->sh_info);
|
|
ifunc = local_plt + r_symndx;
|
|
}
|
|
|
|
ent = NULL;
|
|
if (ifunc != NULL
|
|
&& (!info->shared
|
|
|| is_branch_reloc (r_type)))
|
|
{
|
|
addend = 0;
|
|
if (r_type == R_PPC_PLTREL24 && info->shared)
|
|
addend = rel->r_addend;
|
|
ent = find_plt_ent (ifunc, got2, addend);
|
|
}
|
|
if (ent != NULL)
|
|
{
|
|
if (h == NULL && (ent->plt.offset & 1) == 0)
|
|
{
|
|
Elf_Internal_Rela rela;
|
|
bfd_byte *loc;
|
|
|
|
rela.r_offset = (htab->iplt->output_section->vma
|
|
+ htab->iplt->output_offset
|
|
+ ent->plt.offset);
|
|
rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
|
|
rela.r_addend = relocation;
|
|
loc = htab->reliplt->contents;
|
|
loc += (htab->reliplt->reloc_count++
|
|
* sizeof (Elf32_External_Rela));
|
|
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
|
|
|
|
ent->plt.offset |= 1;
|
|
}
|
|
if (h == NULL && (ent->glink_offset & 1) == 0)
|
|
{
|
|
unsigned char *p = ((unsigned char *) htab->glink->contents
|
|
+ ent->glink_offset);
|
|
write_glink_stub (ent, htab->iplt, p, info);
|
|
ent->glink_offset |= 1;
|
|
}
|
|
|
|
unresolved_reloc = FALSE;
|
|
if (htab->plt_type == PLT_NEW
|
|
|| !htab->elf.dynamic_sections_created
|
|
|| h == NULL)
|
|
relocation = (htab->glink->output_section->vma
|
|
+ htab->glink->output_offset
|
|
+ (ent->glink_offset & ~1));
|
|
else
|
|
relocation = (htab->plt->output_section->vma
|
|
+ htab->plt->output_offset
|
|
+ ent->plt.offset);
|
|
}
|
|
}
|
|
|
addend = rel->r_addend;
|
addend = rel->r_addend;
|
tls_type = 0;
|
tls_type = 0;
|
howto = NULL;
|
howto = NULL;
|
if (r_type < R_PPC_max)
|
if (r_type < R_PPC_max)
|
| Line 6113... |
Line 7223... |
ret = FALSE;
|
ret = FALSE;
|
continue;
|
continue;
|
|
|
case R_PPC_NONE:
|
case R_PPC_NONE:
|
case R_PPC_TLS:
|
case R_PPC_TLS:
|
|
case R_PPC_TLSGD:
|
|
case R_PPC_TLSLD:
|
case R_PPC_EMB_MRKREF:
|
case R_PPC_EMB_MRKREF:
|
case R_PPC_GNU_VTINHERIT:
|
case R_PPC_GNU_VTINHERIT:
|
case R_PPC_GNU_VTENTRY:
|
case R_PPC_GNU_VTENTRY:
|
continue;
|
continue;
|
|
|
| Line 6154... |
Line 7266... |
|
|
case R_PPC_GOT16:
|
case R_PPC_GOT16:
|
case R_PPC_GOT16_LO:
|
case R_PPC_GOT16_LO:
|
case R_PPC_GOT16_HI:
|
case R_PPC_GOT16_HI:
|
case R_PPC_GOT16_HA:
|
case R_PPC_GOT16_HA:
|
|
tls_mask = 0;
|
dogot:
|
dogot:
|
{
|
{
|
/* Relocation is to the entry for this symbol in the global
|
/* Relocation is to the entry for this symbol in the global
|
offset table. */
|
offset table. */
|
bfd_vma off;
|
bfd_vma off;
|
| Line 6243... |
Line 7356... |
tls_m = 0;
|
tls_m = 0;
|
}
|
}
|
|
|
/* Generate relocs for the dynamic linker. */
|
/* Generate relocs for the dynamic linker. */
|
if ((info->shared || indx != 0)
|
if ((info->shared || indx != 0)
|
&& (h == NULL
|
&& (offp == &htab->tlsld_got.offset
|
|
|| h == NULL
|
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|
|| h->root.type != bfd_link_hash_undefweak))
|
|| h->root.type != bfd_link_hash_undefweak))
|
{
|
{
|
|
asection *rsec = htab->relgot;
|
|
bfd_byte * loc;
|
|
|
outrel.r_offset = (htab->got->output_section->vma
|
outrel.r_offset = (htab->got->output_section->vma
|
+ htab->got->output_offset
|
+ htab->got->output_offset
|
+ off);
|
+ off);
|
outrel.r_addend = 0;
|
outrel.r_addend = 0;
|
if (tls_ty & (TLS_LD | TLS_GD))
|
if (tls_ty & (TLS_LD | TLS_GD))
|
{
|
{
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
|
if (tls_ty == (TLS_TLS | TLS_GD))
|
if (tls_ty == (TLS_TLS | TLS_GD))
|
{
|
{
|
loc = htab->relgot->contents;
|
loc = rsec->contents;
|
loc += (htab->relgot->reloc_count++
|
loc += (rsec->reloc_count++
|
* sizeof (Elf32_External_Rela));
|
* sizeof (Elf32_External_Rela));
|
bfd_elf32_swap_reloca_out (output_bfd,
|
bfd_elf32_swap_reloca_out (output_bfd,
|
&outrel, loc);
|
&outrel, loc);
|
outrel.r_offset += 4;
|
outrel.r_offset += 4;
|
outrel.r_info
|
outrel.r_info
|
| Line 6270... |
Line 7387... |
}
|
}
|
else if (tls_ty == (TLS_TLS | TLS_DTPREL))
|
else if (tls_ty == (TLS_TLS | TLS_DTPREL))
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
|
else if (tls_ty == (TLS_TLS | TLS_TPREL))
|
else if (tls_ty == (TLS_TLS | TLS_TPREL))
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
|
else if (indx == 0)
|
else if (indx != 0)
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_RELATIVE);
|
|
else
|
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
|
outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
|
if (indx == 0)
|
else if (ifunc != NULL)
|
|
outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
|
|
else
|
|
outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
|
|
if (indx == 0 && tls_ty != (TLS_TLS | TLS_LD))
|
{
|
{
|
outrel.r_addend += relocation;
|
outrel.r_addend += relocation;
|
if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
|
if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
|
outrel.r_addend -= htab->elf.tls_sec->vma;
|
outrel.r_addend -= htab->elf.tls_sec->vma;
|
}
|
}
|
loc = htab->relgot->contents;
|
loc = rsec->contents;
|
loc += (htab->relgot->reloc_count++
|
loc += (rsec->reloc_count++
|
* sizeof (Elf32_External_Rela));
|
* sizeof (Elf32_External_Rela));
|
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
|
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
|
}
|
}
|
|
|
/* Init the .got section contents if we're not
|
/* Init the .got section contents if we're not
|
| Line 6345... |
Line 7464... |
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
relocation = htab->got->output_offset + off;
|
relocation = (htab->got->output_section->vma
|
relocation -= htab->elf.hgot->root.u.def.value;
|
+ htab->got->output_offset
|
|
+ off
|
|
- SYM_VAL (htab->elf.hgot));
|
|
|
/* Addends on got relocations don't make much sense.
|
/* Addends on got relocations don't make much sense.
|
x+off@got is actually x@got+off, and since the got is
|
x+off@got is actually x@got+off, and since the got is
|
generated by a hash table traversal, the value in the
|
generated by a hash table traversal, the value in the
|
got at entry m+n bears little relation to the entry m. */
|
got at entry m+n bears little relation to the entry m. */
|
| Line 6393... |
Line 7514... |
object. */
|
object. */
|
case R_PPC_TPREL16:
|
case R_PPC_TPREL16:
|
case R_PPC_TPREL16_LO:
|
case R_PPC_TPREL16_LO:
|
case R_PPC_TPREL16_HI:
|
case R_PPC_TPREL16_HI:
|
case R_PPC_TPREL16_HA:
|
case R_PPC_TPREL16_HA:
|
|
if (h != NULL
|
|
&& h->root.type == bfd_link_hash_undefweak
|
|
&& h->dynindx == -1)
|
|
{
|
|
/* Make this relocation against an undefined weak symbol
|
|
resolve to zero. This is really just a tweak, since
|
|
code using weak externs ought to check that they are
|
|
defined before using them. */
|
|
bfd_byte *p = contents + rel->r_offset - d_offset;
|
|
unsigned int insn = bfd_get_32 (output_bfd, p);
|
|
insn = _bfd_elf_ppc_at_tprel_transform (insn, 2);
|
|
if (insn != 0)
|
|
bfd_put_32 (output_bfd, insn, p);
|
|
break;
|
|
}
|
addend -= htab->elf.tls_sec->vma + TP_OFFSET;
|
addend -= htab->elf.tls_sec->vma + TP_OFFSET;
|
/* The TPREL16 relocs shouldn't really be used in shared
|
/* The TPREL16 relocs shouldn't really be used in shared
|
libs as they will result in DT_TEXTREL being set, but
|
libs as they will result in DT_TEXTREL being set, but
|
support them anyway. */
|
support them anyway. */
|
goto dodyn;
|
goto dodyn;
|
| Line 6438... |
Line 7574... |
case R_PPC_REL14:
|
case R_PPC_REL14:
|
case R_PPC_REL14_BRTAKEN:
|
case R_PPC_REL14_BRTAKEN:
|
case R_PPC_REL14_BRNTAKEN:
|
case R_PPC_REL14_BRNTAKEN:
|
/* If these relocations are not to a named symbol, they can be
|
/* If these relocations are not to a named symbol, they can be
|
handled right here, no need to bother the dynamic linker. */
|
handled right here, no need to bother the dynamic linker. */
|
if (SYMBOL_REFERENCES_LOCAL (info, h)
|
if (SYMBOL_CALLS_LOCAL (info, h)
|
|| h == htab->elf.hgot)
|
|| h == htab->elf.hgot)
|
break;
|
break;
|
/* fall through */
|
/* fall through */
|
|
|
case R_PPC_ADDR24:
|
case R_PPC_ADDR24:
|
| Line 6452... |
Line 7588... |
if (h != NULL && !info->shared)
|
if (h != NULL && !info->shared)
|
break;
|
break;
|
/* fall through */
|
/* fall through */
|
|
|
dodyn:
|
dodyn:
|
if ((input_section->flags & SEC_ALLOC) == 0)
|
if ((input_section->flags & SEC_ALLOC) == 0
|
|
|| is_vxworks_tls)
|
break;
|
break;
|
|
|
if ((info->shared
|
if ((info->shared
|
&& (h == NULL
|
&& !(h != NULL
|
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|
&& ((h->root.type == bfd_link_hash_undefined
|
|| h->root.type != bfd_link_hash_undefweak)
|
&& (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
|
&& (MUST_BE_DYN_RELOC (r_type)
|
|| ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
|
|
|| (h->root.type == bfd_link_hash_undefweak
|
|
&& ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)))
|
|
&& (must_be_dyn_reloc (info, r_type)
|
|| !SYMBOL_CALLS_LOCAL (info, h)))
|
|| !SYMBOL_CALLS_LOCAL (info, h)))
|
|| (ELIMINATE_COPY_RELOCS
|
|| (ELIMINATE_COPY_RELOCS
|
&& !info->shared
|
&& !info->shared
|
&& h != NULL
|
&& h != NULL
|
&& h->dynindx != -1
|
&& h->dynindx != -1
|
&& !h->non_got_ref
|
&& !h->non_got_ref
|
&& !h->def_regular))
|
&& !h->def_regular))
|
{
|
{
|
int skip;
|
int skip;
|
|
bfd_byte * loc;
|
#ifdef DEBUG
|
#ifdef DEBUG
|
fprintf (stderr, "ppc_elf_relocate_section needs to "
|
fprintf (stderr, "ppc_elf_relocate_section needs to "
|
"create relocation for %s\n",
|
"create relocation for %s\n",
|
(h && h->root.root.string
|
(h && h->root.root.string
|
? h->root.root.string : "<unknown>"));
|
? h->root.root.string : "<unknown>"));
|
| Line 6482... |
Line 7622... |
/* When generating a shared object, these relocations
|
/* When generating a shared object, these relocations
|
are copied into the output file to be resolved at run
|
are copied into the output file to be resolved at run
|
time. */
|
time. */
|
if (sreloc == NULL)
|
if (sreloc == NULL)
|
{
|
{
|
const char *name;
|
sreloc = elf_section_data (input_section)->sreloc;
|
|
if (!htab->elf.dynamic_sections_created)
|
name = (bfd_elf_string_from_elf_section
|
sreloc = htab->reliplt;
|
(input_bfd,
|
if (sreloc == NULL)
|
elf_elfheader (input_bfd)->e_shstrndx,
|
|
elf_section_data (input_section)->rel_hdr.sh_name));
|
|
if (name == NULL)
|
|
return FALSE;
|
return FALSE;
|
|
|
BFD_ASSERT (CONST_STRNEQ (name, ".rela")
|
|
&& strcmp (bfd_get_section_name (input_bfd,
|
|
input_section),
|
|
name + 5) == 0);
|
|
|
|
sreloc = bfd_get_section_by_name (htab->elf.dynobj, name);
|
|
BFD_ASSERT (sreloc != NULL);
|
|
}
|
}
|
|
|
skip = 0;
|
skip = 0;
|
|
|
outrel.r_offset =
|
outrel.r_offset =
|
_bfd_elf_section_offset (output_bfd, info, input_section,
|
_bfd_elf_section_offset (output_bfd, info, input_section,
|
rel->r_offset);
|
rel->r_offset);
|
if (outrel.r_offset == (bfd_vma) -1
|
if (outrel.r_offset == (bfd_vma) -1
|
|| outrel.r_offset == (bfd_vma) -2)
|
|| outrel.r_offset == (bfd_vma) -2)
|
| Line 6513... |
Line 7641... |
outrel.r_offset += (input_section->output_section->vma
|
outrel.r_offset += (input_section->output_section->vma
|
+ input_section->output_offset);
|
+ input_section->output_offset);
|
|
|
if (skip)
|
if (skip)
|
memset (&outrel, 0, sizeof outrel);
|
memset (&outrel, 0, sizeof outrel);
|
else if (!SYMBOL_REFERENCES_LOCAL (info, h))
|
else if ((h != NULL
|
|
&& (h->root.type == bfd_link_hash_undefined
|
|
|| h->root.type == bfd_link_hash_undefweak))
|
|
|| !SYMBOL_REFERENCES_LOCAL (info, h))
|
{
|
{
|
unresolved_reloc = FALSE;
|
unresolved_reloc = FALSE;
|
outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
|
outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
|
outrel.r_addend = rel->r_addend;
|
outrel.r_addend = rel->r_addend;
|
}
|
}
|
else
|
else
|
{
|
{
|
outrel.r_addend = relocation + rel->r_addend;
|
outrel.r_addend = relocation + rel->r_addend;
|
|
|
if (r_type == R_PPC_ADDR32)
|
if (r_type != R_PPC_ADDR32)
|
outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
|
|
else
|
|
{
|
{
|
long indx;
|
long indx = 0;
|
|
|
if (bfd_is_abs_section (sec))
|
if (ifunc != NULL)
|
indx = 0;
|
{
|
|
/* If we get here when building a static
|
|
executable, then the libc startup function
|
|
responsible for applying indirect function
|
|
relocations is going to complain about
|
|
the reloc type.
|
|
If we get here when building a dynamic
|
|
executable, it will be because we have
|
|
a text relocation. The dynamic loader
|
|
will set the text segment writable and
|
|
non-executable to apply text relocations.
|
|
So we'll segfault when trying to run the
|
|
indirection function to resolve the reloc. */
|
|
(*_bfd_error_handler)
|
|
(_("%B(%A+0x%lx): relocation %s for indirect "
|
|
"function %s unsupported"),
|
|
input_bfd,
|
|
input_section,
|
|
(long) rel->r_offset,
|
|
howto->name,
|
|
sym_name);
|
|
ret = FALSE;
|
|
}
|
|
else if (r_symndx == 0 || bfd_is_abs_section (sec))
|
|
;
|
else if (sec == NULL || sec->owner == NULL)
|
else if (sec == NULL || sec->owner == NULL)
|
{
|
{
|
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
return FALSE;
|
ret = FALSE;
|
}
|
}
|
else
|
else
|
{
|
{
|
asection *osec;
|
asection *osec;
|
|
|
/* We are turning this relocation into one
|
/* We are turning this relocation into one
|
against a section symbol. It would be
|
against a section symbol. It would be
|
proper to subtract the symbol's value,
|
proper to subtract the symbol's value,
|
osec->vma, from the emitted reloc addend,
|
osec->vma, from the emitted reloc addend,
|
but ld.so expects buggy relocs. */
|
but ld.so expects buggy relocs.
|
|
FIXME: Why not always use a zero index? */
|
osec = sec->output_section;
|
osec = sec->output_section;
|
indx = elf_section_data (osec)->dynindx;
|
indx = elf_section_data (osec)->dynindx;
|
if (indx == 0)
|
if (indx == 0)
|
{
|
{
|
osec = htab->elf.text_index_section;
|
osec = htab->elf.text_index_section;
|
| Line 6563... |
Line 7717... |
#endif
|
#endif
|
}
|
}
|
|
|
outrel.r_info = ELF32_R_INFO (indx, r_type);
|
outrel.r_info = ELF32_R_INFO (indx, r_type);
|
}
|
}
|
|
else if (ifunc != NULL)
|
|
outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
|
|
else
|
|
outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
|
}
|
}
|
|
|
loc = sreloc->contents;
|
loc = sreloc->contents;
|
loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
|
loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
|
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
|
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
|
| Line 6585... |
Line 7743... |
break;
|
break;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case R_PPC_RELAX32PC_PLT:
|
case R_PPC_RELAX_PLT:
|
case R_PPC_RELAX32_PLT:
|
case R_PPC_RELAX_PLTREL24:
|
|
if (h != NULL)
|
{
|
{
|
struct plt_entry *ent = find_plt_ent (h, got2, addend);
|
struct plt_entry *ent;
|
|
bfd_vma got2_addend = 0;
|
|
|
|
if (r_type == R_PPC_RELAX_PLTREL24)
|
|
{
|
|
if (info->shared)
|
|
got2_addend = addend;
|
|
addend = 0;
|
|
}
|
|
ent = find_plt_ent (&h->plt.plist, got2, got2_addend);
|
if (htab->plt_type == PLT_NEW)
|
if (htab->plt_type == PLT_NEW)
|
relocation = (htab->glink->output_section->vma
|
relocation = (htab->glink->output_section->vma
|
+ htab->glink->output_offset
|
+ htab->glink->output_offset
|
+ ent->glink_offset);
|
+ ent->glink_offset);
|
else
|
else
|
relocation = (htab->plt->output_section->vma
|
relocation = (htab->plt->output_section->vma
|
+ htab->plt->output_offset
|
+ htab->plt->output_offset
|
+ ent->plt.offset);
|
+ ent->plt.offset);
|
addend = 0;
|
|
}
|
}
|
if (r_type == R_PPC_RELAX32_PLT)
|
|
goto relax32;
|
|
/* Fall thru */
|
/* Fall thru */
|
|
|
case R_PPC_RELAX32PC:
|
case R_PPC_RELAX:
|
|
if (info->shared)
|
relocation -= (input_section->output_section->vma
|
relocation -= (input_section->output_section->vma
|
+ input_section->output_offset
|
+ input_section->output_offset
|
+ rel->r_offset - 4);
|
+ rel->r_offset - 4);
|
/* Fall thru */
|
|
|
|
case R_PPC_RELAX32:
|
|
relax32:
|
|
{
|
{
|
unsigned long t0;
|
unsigned long t0;
|
unsigned long t1;
|
unsigned long t1;
|
|
|
t0 = bfd_get_32 (output_bfd, contents + rel->r_offset);
|
t0 = bfd_get_32 (output_bfd, contents + rel->r_offset);
|
| Line 6631... |
Line 7793... |
t0 |= ((relocation + 0x8000) >> 16) & 0xffff;
|
t0 |= ((relocation + 0x8000) >> 16) & 0xffff;
|
t1 |= relocation & 0xffff;
|
t1 |= relocation & 0xffff;
|
|
|
bfd_put_32 (output_bfd, t0, contents + rel->r_offset);
|
bfd_put_32 (output_bfd, t0, contents + rel->r_offset);
|
bfd_put_32 (output_bfd, t1, contents + rel->r_offset + 4);
|
bfd_put_32 (output_bfd, t1, contents + rel->r_offset + 4);
|
|
|
|
/* Rewrite the reloc and convert one of the trailing nop
|
|
relocs to describe this relocation. */
|
|
BFD_ASSERT (ELF32_R_TYPE (relend[-1].r_info) == R_PPC_NONE);
|
|
/* The relocs are at the bottom 2 bytes */
|
|
rel[0].r_offset += 2;
|
|
memmove (rel + 1, rel, (relend - rel - 1) * sizeof (*rel));
|
|
rel[0].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
|
|
rel[1].r_offset += 4;
|
|
rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
|
|
rel++;
|
}
|
}
|
continue;
|
continue;
|
|
|
/* Indirect .sdata relocation. */
|
/* Indirect .sdata relocation. */
|
case R_PPC_EMB_SDAI16:
|
case R_PPC_EMB_SDAI16:
|
BFD_ASSERT (htab->sdata[0].section != NULL);
|
BFD_ASSERT (htab->sdata[0].section != NULL);
|
|
if (!is_static_defined (htab->sdata[0].sym))
|
|
{
|
|
unresolved_reloc = TRUE;
|
|
break;
|
|
}
|
relocation
|
relocation
|
= elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0],
|
= elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0],
|
h, relocation, rel);
|
h, relocation, rel);
|
|
addend = 0;
|
break;
|
break;
|
|
|
/* Indirect .sdata2 relocation. */
|
/* Indirect .sdata2 relocation. */
|
case R_PPC_EMB_SDA2I16:
|
case R_PPC_EMB_SDA2I16:
|
BFD_ASSERT (htab->sdata[1].section != NULL);
|
BFD_ASSERT (htab->sdata[1].section != NULL);
|
|
if (!is_static_defined (htab->sdata[1].sym))
|
|
{
|
|
unresolved_reloc = TRUE;
|
|
break;
|
|
}
|
relocation
|
relocation
|
= elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1],
|
= elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1],
|
h, relocation, rel);
|
h, relocation, rel);
|
|
addend = 0;
|
break;
|
break;
|
|
|
/* Handle the TOC16 reloc. We want to use the offset within the .got
|
/* Handle the TOC16 reloc. We want to use the offset within the .got
|
section, not the actual VMA. This is appropriate when generating
|
section, not the actual VMA. This is appropriate when generating
|
an embedded ELF object, for which the .got section acts like the
|
an embedded ELF object, for which the .got section acts like the
|
AIX .toc section. */
|
AIX .toc section. */
|
case R_PPC_TOC16: /* phony GOT16 relocations */
|
case R_PPC_TOC16: /* phony GOT16 relocations */
|
BFD_ASSERT (sec != NULL);
|
if (sec == NULL || sec->output_section == NULL)
|
BFD_ASSERT (bfd_is_und_section (sec)
|
{
|
|| strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
|
unresolved_reloc = TRUE;
|
|
break;
|
|
}
|
|
BFD_ASSERT (strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
|
|| strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0);
|
|| strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0);
|
|
|
addend -= sec->output_section->vma + sec->output_offset + 0x8000;
|
addend -= sec->output_section->vma + sec->output_offset + 0x8000;
|
break;
|
break;
|
|
|
case R_PPC_PLTREL24:
|
case R_PPC_PLTREL24:
|
|
if (h == NULL || ifunc != NULL)
|
|
break;
|
/* Relocation is to the entry for this symbol in the
|
/* Relocation is to the entry for this symbol in the
|
procedure linkage table. */
|
procedure linkage table. */
|
{
|
{
|
struct plt_entry *ent = find_plt_ent (h, got2, addend);
|
struct plt_entry *ent = find_plt_ent (&h->plt.plist, got2,
|
|
info->shared ? addend : 0);
|
addend = 0;
|
addend = 0;
|
if (ent == NULL
|
if (ent == NULL
|
|| htab->plt == NULL)
|
|| htab->plt == NULL)
|
{
|
{
|
/* We didn't make a PLT entry for this symbol. This
|
/* We didn't make a PLT entry for this symbol. This
|
| Line 6695... |
Line 7885... |
|
|
/* Relocate against _SDA_BASE_. */
|
/* Relocate against _SDA_BASE_. */
|
case R_PPC_SDAREL16:
|
case R_PPC_SDAREL16:
|
{
|
{
|
const char *name;
|
const char *name;
|
struct elf_link_hash_entry *sh;
|
struct elf_link_hash_entry *sda = htab->sdata[0].sym;
|
|
|
|
if (sec == NULL
|
|
|| sec->output_section == NULL
|
|
|| !is_static_defined (sda))
|
|
{
|
|
unresolved_reloc = TRUE;
|
|
break;
|
|
}
|
|
addend -= SYM_VAL (sda);
|
|
|
BFD_ASSERT (sec != NULL);
|
|
name = bfd_get_section_name (abfd, sec->output_section);
|
name = bfd_get_section_name (abfd, sec->output_section);
|
if (! ((CONST_STRNEQ (name, ".sdata")
|
if (! ((CONST_STRNEQ (name, ".sdata")
|
&& (name[6] == 0 || name[6] == '.'))
|
&& (name[6] == 0 || name[6] == '.'))
|
|| (CONST_STRNEQ (name, ".sbss")
|
|| (CONST_STRNEQ (name, ".sbss")
|
&& (name[5] == 0 || name[5] == '.'))))
|
&& (name[5] == 0 || name[5] == '.'))))
|
| Line 6712... |
Line 7910... |
input_bfd,
|
input_bfd,
|
sym_name,
|
sym_name,
|
howto->name,
|
howto->name,
|
name);
|
name);
|
}
|
}
|
sh = htab->sdata[0].sym;
|
|
addend -= (sh->root.u.def.value
|
|
+ sh->root.u.def.section->output_offset
|
|
+ sh->root.u.def.section->output_section->vma);
|
|
}
|
}
|
break;
|
break;
|
|
|
/* Relocate against _SDA2_BASE_. */
|
/* Relocate against _SDA2_BASE_. */
|
case R_PPC_EMB_SDA2REL:
|
case R_PPC_EMB_SDA2REL:
|
{
|
{
|
const char *name;
|
const char *name;
|
struct elf_link_hash_entry *sh;
|
struct elf_link_hash_entry *sda = htab->sdata[1].sym;
|
|
|
|
if (sec == NULL
|
|
|| sec->output_section == NULL
|
|
|| !is_static_defined (sda))
|
|
{
|
|
unresolved_reloc = TRUE;
|
|
break;
|
|
}
|
|
addend -= SYM_VAL (sda);
|
|
|
BFD_ASSERT (sec != NULL);
|
|
name = bfd_get_section_name (abfd, sec->output_section);
|
name = bfd_get_section_name (abfd, sec->output_section);
|
if (! (CONST_STRNEQ (name, ".sdata2")
|
if (! (CONST_STRNEQ (name, ".sdata2")
|
|| CONST_STRNEQ (name, ".sbss2")))
|
|| CONST_STRNEQ (name, ".sbss2")))
|
{
|
{
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
| Line 6737... |
Line 7939... |
"in the wrong output section (%s)"),
|
"in the wrong output section (%s)"),
|
input_bfd,
|
input_bfd,
|
sym_name,
|
sym_name,
|
howto->name,
|
howto->name,
|
name);
|
name);
|
|
|
bfd_set_error (bfd_error_bad_value);
|
|
ret = FALSE;
|
|
continue;
|
|
}
|
}
|
sh = htab->sdata[1].sym;
|
|
addend -= (sh->root.u.def.value
|
|
+ sh->root.u.def.section->output_offset
|
|
+ sh->root.u.def.section->output_section->vma);
|
|
}
|
}
|
break;
|
break;
|
|
|
/* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0. */
|
/* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0. */
|
case R_PPC_EMB_SDA21:
|
case R_PPC_EMB_SDA21:
|
case R_PPC_EMB_RELSDA:
|
case R_PPC_EMB_RELSDA:
|
{
|
{
|
const char *name;
|
const char *name;
|
int reg;
|
int reg;
|
struct elf_link_hash_entry *sh;
|
struct elf_link_hash_entry *sda = NULL;
|
|
|
|
if (sec == NULL || sec->output_section == NULL)
|
|
{
|
|
unresolved_reloc = TRUE;
|
|
break;
|
|
}
|
|
|
BFD_ASSERT (sec != NULL);
|
|
name = bfd_get_section_name (abfd, sec->output_section);
|
name = bfd_get_section_name (abfd, sec->output_section);
|
if (((CONST_STRNEQ (name, ".sdata")
|
if (((CONST_STRNEQ (name, ".sdata")
|
&& (name[6] == 0 || name[6] == '.'))
|
&& (name[6] == 0 || name[6] == '.'))
|
|| (CONST_STRNEQ (name, ".sbss")
|
|| (CONST_STRNEQ (name, ".sbss")
|
&& (name[5] == 0 || name[5] == '.'))))
|
&& (name[5] == 0 || name[5] == '.'))))
|
{
|
{
|
reg = 13;
|
reg = 13;
|
sh = htab->sdata[0].sym;
|
sda = htab->sdata[0].sym;
|
addend -= (sh->root.u.def.value
|
|
+ sh->root.u.def.section->output_offset
|
|
+ sh->root.u.def.section->output_section->vma);
|
|
}
|
}
|
|
|
else if (CONST_STRNEQ (name, ".sdata2")
|
else if (CONST_STRNEQ (name, ".sdata2")
|
|| CONST_STRNEQ (name, ".sbss2"))
|
|| CONST_STRNEQ (name, ".sbss2"))
|
{
|
{
|
reg = 2;
|
reg = 2;
|
sh = htab->sdata[1].sym;
|
sda = htab->sdata[1].sym;
|
addend -= (sh->root.u.def.value
|
|
+ sh->root.u.def.section->output_offset
|
|
+ sh->root.u.def.section->output_section->vma);
|
|
}
|
}
|
|
|
else if (strcmp (name, ".PPC.EMB.sdata0") == 0
|
else if (strcmp (name, ".PPC.EMB.sdata0") == 0
|
|| strcmp (name, ".PPC.EMB.sbss0") == 0)
|
|| strcmp (name, ".PPC.EMB.sbss0") == 0)
|
{
|
{
|
reg = 0;
|
reg = 0;
|
}
|
}
|
|
|
else
|
else
|
{
|
{
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B: the target (%s) of a %s relocation is "
|
(_("%B: the target (%s) of a %s relocation is "
|
"in the wrong output section (%s)"),
|
"in the wrong output section (%s)"),
|
| Line 6802... |
Line 7992... |
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
ret = FALSE;
|
ret = FALSE;
|
continue;
|
continue;
|
}
|
}
|
|
|
|
if (sda != NULL)
|
|
{
|
|
if (!is_static_defined (sda))
|
|
{
|
|
unresolved_reloc = TRUE;
|
|
break;
|
|
}
|
|
addend -= SYM_VAL (sda);
|
|
}
|
|
|
if (r_type == R_PPC_EMB_SDA21)
|
if (r_type == R_PPC_EMB_SDA21)
|
{ /* fill in register field */
|
{
|
|
bfd_vma insn; /* Fill in register field. */
|
|
|
insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
|
insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
|
insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
|
insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
|
bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
|
bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
|
}
|
}
|
}
|
}
|
| Line 6816... |
Line 8018... |
/* Relocate against the beginning of the section. */
|
/* Relocate against the beginning of the section. */
|
case R_PPC_SECTOFF:
|
case R_PPC_SECTOFF:
|
case R_PPC_SECTOFF_LO:
|
case R_PPC_SECTOFF_LO:
|
case R_PPC_SECTOFF_HI:
|
case R_PPC_SECTOFF_HI:
|
case R_PPC_SECTOFF_HA:
|
case R_PPC_SECTOFF_HA:
|
BFD_ASSERT (sec != NULL);
|
if (sec == NULL || sec->output_section == NULL)
|
|
{
|
|
unresolved_reloc = TRUE;
|
|
break;
|
|
}
|
addend -= sec->output_section->vma;
|
addend -= sec->output_section->vma;
|
break;
|
break;
|
|
|
/* Negative relocations. */
|
/* Negative relocations. */
|
case R_PPC_EMB_NADDR32:
|
case R_PPC_EMB_NADDR32:
|
| Line 6833... |
Line 8039... |
|
|
case R_PPC_COPY:
|
case R_PPC_COPY:
|
case R_PPC_GLOB_DAT:
|
case R_PPC_GLOB_DAT:
|
case R_PPC_JMP_SLOT:
|
case R_PPC_JMP_SLOT:
|
case R_PPC_RELATIVE:
|
case R_PPC_RELATIVE:
|
|
case R_PPC_IRELATIVE:
|
case R_PPC_PLT32:
|
case R_PPC_PLT32:
|
case R_PPC_PLTREL32:
|
case R_PPC_PLTREL32:
|
case R_PPC_PLT16_LO:
|
case R_PPC_PLT16_LO:
|
case R_PPC_PLT16_HI:
|
case R_PPC_PLT16_HI:
|
case R_PPC_PLT16_HA:
|
case R_PPC_PLT16_HA:
|
| Line 6968... |
Line 8175... |
#endif
|
#endif
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
#define PPC_LO(v) ((v) & 0xffff)
|
|
#define PPC_HI(v) (((v) >> 16) & 0xffff)
|
|
#define PPC_HA(v) PPC_HI ((v) + 0x8000)
|
|
|
|
/* Finish up dynamic symbol handling. We set the contents of various
|
/* Finish up dynamic symbol handling. We set the contents of various
|
dynamic sections here. */
|
dynamic sections here. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
ppc_elf_finish_dynamic_symbol (bfd *output_bfd,
|
ppc_elf_finish_dynamic_symbol (bfd *output_bfd,
|
| Line 7003... |
Line 8206... |
{
|
{
|
Elf_Internal_Rela rela;
|
Elf_Internal_Rela rela;
|
bfd_byte *loc;
|
bfd_byte *loc;
|
bfd_vma reloc_index;
|
bfd_vma reloc_index;
|
|
|
if (htab->plt_type == PLT_NEW)
|
if (htab->plt_type == PLT_NEW
|
|
|| !htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
reloc_index = ent->plt.offset / 4;
|
reloc_index = ent->plt.offset / 4;
|
else
|
else
|
{
|
{
|
reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size)
|
reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size)
|
/ htab->plt_slot_size);
|
/ htab->plt_slot_size);
|
| Line 7016... |
Line 8221... |
reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
|
reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
|
}
|
}
|
|
|
/* This symbol has an entry in the procedure linkage table.
|
/* This symbol has an entry in the procedure linkage table.
|
Set it up. */
|
Set it up. */
|
if (htab->plt_type == PLT_VXWORKS)
|
if (htab->plt_type == PLT_VXWORKS
|
|
&& htab->elf.dynamic_sections_created
|
|
&& h->dynindx != -1)
|
{
|
{
|
bfd_vma got_offset;
|
bfd_vma got_offset;
|
const bfd_vma *plt_entry;
|
const bfd_vma *plt_entry;
|
|
|
/* The first three entries in .got.plt are reserved. */
|
/* The first three entries in .got.plt are reserved. */
|
| Line 7031... |
Line 8238... |
: ppc_elf_vxworks_plt_entry;
|
: ppc_elf_vxworks_plt_entry;
|
|
|
/* Fill in the .plt on VxWorks. */
|
/* Fill in the .plt on VxWorks. */
|
if (info->shared)
|
if (info->shared)
|
{
|
{
|
bfd_vma got_offset_hi = (got_offset >> 16)
|
|
+ ((got_offset & 0x8000) >> 15);
|
|
|
|
bfd_put_32 (output_bfd,
|
bfd_put_32 (output_bfd,
|
plt_entry[0] | (got_offset_hi & 0xffff),
|
plt_entry[0] | PPC_HA (got_offset),
|
htab->plt->contents + ent->plt.offset + 0);
|
htab->plt->contents + ent->plt.offset + 0);
|
bfd_put_32 (output_bfd,
|
bfd_put_32 (output_bfd,
|
plt_entry[1] | (got_offset & 0xffff),
|
plt_entry[1] | PPC_LO (got_offset),
|
htab->plt->contents + ent->plt.offset + 4);
|
htab->plt->contents + ent->plt.offset + 4);
|
}
|
}
|
else
|
else
|
{
|
{
|
bfd_vma got_loc
|
bfd_vma got_loc = got_offset + SYM_VAL (htab->elf.hgot);
|
= (got_offset
|
|
+ htab->elf.hgot->root.u.def.value
|
|
+ htab->elf.hgot->root.u.def.section->output_offset
|
|
+ htab->elf.hgot->root.u.def.section->output_section->vma);
|
|
bfd_vma got_loc_hi = (got_loc >> 16)
|
|
+ ((got_loc & 0x8000) >> 15);
|
|
|
|
bfd_put_32 (output_bfd,
|
bfd_put_32 (output_bfd,
|
plt_entry[0] | (got_loc_hi & 0xffff),
|
plt_entry[0] | PPC_HA (got_loc),
|
htab->plt->contents + ent->plt.offset + 0);
|
htab->plt->contents + ent->plt.offset + 0);
|
bfd_put_32 (output_bfd,
|
bfd_put_32 (output_bfd,
|
plt_entry[1] | (got_loc & 0xffff),
|
plt_entry[1] | PPC_LO (got_loc),
|
htab->plt->contents + ent->plt.offset + 4);
|
htab->plt->contents + ent->plt.offset + 4);
|
}
|
}
|
|
|
bfd_put_32 (output_bfd, plt_entry[2],
|
bfd_put_32 (output_bfd, plt_entry[2],
|
htab->plt->contents + ent->plt.offset + 8);
|
htab->plt->contents + ent->plt.offset + 8);
|
| Line 7147... |
Line 8345... |
+ got_offset);
|
+ got_offset);
|
|
|
}
|
}
|
else
|
else
|
{
|
{
|
rela.r_offset = (htab->plt->output_section->vma
|
asection *splt = htab->plt;
|
+ htab->plt->output_offset
|
if (!htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
|
splt = htab->iplt;
|
|
|
|
rela.r_offset = (splt->output_section->vma
|
|
+ splt->output_offset
|
+ ent->plt.offset);
|
+ ent->plt.offset);
|
if (htab->plt_type == PLT_OLD)
|
if (htab->plt_type == PLT_OLD
|
|
|| !htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
{
|
{
|
/* We don't need to fill in the .plt. The ppc dynamic
|
/* We don't need to fill in the .plt. The ppc dynamic
|
linker will fill it in. */
|
linker will fill it in. */
|
}
|
}
|
else
|
else
|
{
|
{
|
bfd_vma val = (htab->glink_pltresolve + ent->plt.offset
|
bfd_vma val = (htab->glink_pltresolve + ent->plt.offset
|
+ htab->glink->output_section->vma
|
+ htab->glink->output_section->vma
|
+ htab->glink->output_offset);
|
+ htab->glink->output_offset);
|
bfd_put_32 (output_bfd, val,
|
bfd_put_32 (output_bfd, val,
|
htab->plt->contents + ent->plt.offset);
|
splt->contents + ent->plt.offset);
|
}
|
}
|
}
|
}
|
|
|
/* Fill in the entry in the .rela.plt section. */
|
/* Fill in the entry in the .rela.plt section. */
|
rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
|
|
rela.r_addend = 0;
|
rela.r_addend = 0;
|
|
if (!htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
|
{
|
|
BFD_ASSERT (h->type == STT_GNU_IFUNC
|
|
&& h->def_regular
|
|
&& (h->root.type == bfd_link_hash_defined
|
|
|| h->root.type == bfd_link_hash_defweak));
|
|
rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE);
|
|
rela.r_addend = SYM_VAL (h);
|
|
}
|
|
else
|
|
rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
|
|
|
|
if (!htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
|
loc = (htab->reliplt->contents
|
|
+ (htab->reliplt->reloc_count++
|
|
* sizeof (Elf32_External_Rela)));
|
|
else
|
loc = (htab->relplt->contents
|
loc = (htab->relplt->contents
|
+ reloc_index * sizeof (Elf32_External_Rela));
|
+ reloc_index * sizeof (Elf32_External_Rela));
|
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
|
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
|
|
|
if (!h->def_regular)
|
if (!h->def_regular)
|
| Line 7193... |
Line 8415... |
that is better than breaking tests for a NULL
|
that is better than breaking tests for a NULL
|
function pointer. */
|
function pointer. */
|
sym->st_value = 0;
|
sym->st_value = 0;
|
}
|
}
|
}
|
}
|
|
else if (h->type == STT_GNU_IFUNC
|
|
&& !info->shared)
|
|
{
|
|
/* Set the value of ifunc symbols in a non-pie
|
|
executable to the glink entry. This is to avoid
|
|
text relocations. We can't do this for ifunc in
|
|
allocate_dynrelocs, as we do for normal dynamic
|
|
function symbols with plt entries, because we need
|
|
to keep the original value around for the ifunc
|
|
relocation. */
|
|
sym->st_shndx = (_bfd_elf_section_from_bfd_section
|
|
(output_bfd, htab->glink->output_section));
|
|
sym->st_value = (ent->glink_offset +
|
|
htab->glink->output_offset
|
|
+ htab->glink->output_section->vma);
|
|
}
|
doneone = TRUE;
|
doneone = TRUE;
|
}
|
}
|
|
|
if (htab->plt_type == PLT_NEW)
|
if (htab->plt_type == PLT_NEW
|
|
|| !htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
{
|
{
|
bfd_vma plt;
|
|
unsigned char *p;
|
unsigned char *p;
|
|
asection *splt = htab->plt;
|
|
if (!htab->elf.dynamic_sections_created
|
|
|| h->dynindx == -1)
|
|
splt = htab->iplt;
|
|
|
plt = (ent->plt.offset
|
|
+ htab->plt->output_section->vma
|
|
+ htab->plt->output_offset);
|
|
p = (unsigned char *) htab->glink->contents + ent->glink_offset;
|
p = (unsigned char *) htab->glink->contents + ent->glink_offset;
|
|
|
if (info->shared || info->pie)
|
if (h == htab->tls_get_addr && !htab->no_tls_get_addr_opt)
|
{
|
{
|
bfd_vma got = 0;
|
bfd_put_32 (output_bfd, LWZ_11_3, p);
|
|
|
if (ent->addend >= 32768)
|
|
got = (ent->addend
|
|
+ ent->sec->output_section->vma
|
|
+ ent->sec->output_offset);
|
|
else if (htab->elf.hgot != NULL)
|
|
got = (htab->elf.hgot->root.u.def.value
|
|
+ htab->elf.hgot->root.u.def.section->output_section->vma
|
|
+ htab->elf.hgot->root.u.def.section->output_offset);
|
|
|
|
plt -= got;
|
|
|
|
if (plt + 0x8000 < 0x10000)
|
|
{
|
|
bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p);
|
|
p += 4;
|
p += 4;
|
bfd_put_32 (output_bfd, MTCTR_11, p);
|
bfd_put_32 (output_bfd, LWZ_12_3 + 4, p);
|
p += 4;
|
p += 4;
|
bfd_put_32 (output_bfd, BCTR, p);
|
bfd_put_32 (output_bfd, MR_0_3, p);
|
p += 4;
|
p += 4;
|
bfd_put_32 (output_bfd, NOP, p);
|
bfd_put_32 (output_bfd, CMPWI_11_0, p);
|
p += 4;
|
p += 4;
|
}
|
bfd_put_32 (output_bfd, ADD_3_12_2, p);
|
else
|
|
{
|
|
bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p);
|
|
p += 4;
|
p += 4;
|
bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
|
bfd_put_32 (output_bfd, BEQLR, p);
|
p += 4;
|
p += 4;
|
bfd_put_32 (output_bfd, MTCTR_11, p);
|
bfd_put_32 (output_bfd, MR_3_0, p);
|
p += 4;
|
p += 4;
|
bfd_put_32 (output_bfd, BCTR, p);
|
bfd_put_32 (output_bfd, NOP, p);
|
p += 4;
|
p += 4;
|
}
|
}
|
}
|
|
else
|
|
{
|
|
bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, MTCTR_11, p);
|
|
p += 4;
|
|
bfd_put_32 (output_bfd, BCTR, p);
|
|
p += 4;
|
|
|
|
|
write_glink_stub (ent, splt, p, info);
|
|
|
|
if (!info->shared)
|
/* We only need one non-PIC glink stub. */
|
/* We only need one non-PIC glink stub. */
|
break;
|
break;
|
}
|
}
|
}
|
|
else
|
else
|
break;
|
break;
|
}
|
}
|
|
|
if (h->needs_copy)
|
if (h->needs_copy)
|
| Line 7283... |
Line 8496... |
s = htab->relsbss;
|
s = htab->relsbss;
|
else
|
else
|
s = htab->relbss;
|
s = htab->relbss;
|
BFD_ASSERT (s != NULL);
|
BFD_ASSERT (s != NULL);
|
|
|
rela.r_offset = (h->root.u.def.value
|
rela.r_offset = SYM_VAL (h);
|
+ h->root.u.def.section->output_section->vma
|
|
+ h->root.u.def.section->output_offset);
|
|
rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
|
rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
|
rela.r_addend = 0;
|
rela.r_addend = 0;
|
loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
|
loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
|
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
|
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
|
}
|
}
|
| Line 7336... |
Line 8547... |
asection *sdyn;
|
asection *sdyn;
|
asection *splt;
|
asection *splt;
|
struct ppc_elf_link_hash_table *htab;
|
struct ppc_elf_link_hash_table *htab;
|
bfd_vma got;
|
bfd_vma got;
|
bfd * dynobj;
|
bfd * dynobj;
|
|
bfd_boolean ret = TRUE;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
|
fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
|
#endif
|
#endif
|
|
|
| Line 7351... |
Line 8563... |
else
|
else
|
splt = NULL;
|
splt = NULL;
|
|
|
got = 0;
|
got = 0;
|
if (htab->elf.hgot != NULL)
|
if (htab->elf.hgot != NULL)
|
got = (htab->elf.hgot->root.u.def.value
|
got = SYM_VAL (htab->elf.hgot);
|
+ htab->elf.hgot->root.u.def.section->output_section->vma
|
|
+ htab->elf.hgot->root.u.def.section->output_offset);
|
|
|
|
if (htab->elf.dynamic_sections_created)
|
if (htab->elf.dynamic_sections_created)
|
{
|
{
|
Elf32_External_Dyn *dyncon, *dynconend;
|
Elf32_External_Dyn *dyncon, *dynconend;
|
|
|
| Line 7413... |
Line 8623... |
|
|
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
|
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
|
}
|
}
|
}
|
}
|
|
|
/* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
|
|
easily find the address of the _GLOBAL_OFFSET_TABLE_. */
|
|
if (htab->got != NULL)
|
if (htab->got != NULL)
|
{
|
{
|
unsigned char *p = htab->got->contents;
|
if (htab->elf.hgot->root.u.def.section == htab->got
|
bfd_vma val;
|
|| htab->elf.hgot->root.u.def.section == htab->sgotplt)
|
|
{
|
|
unsigned char *p = htab->elf.hgot->root.u.def.section->contents;
|
|
|
p += htab->elf.hgot->root.u.def.value;
|
p += htab->elf.hgot->root.u.def.value;
|
if (htab->plt_type == PLT_OLD)
|
if (htab->plt_type == PLT_OLD)
|
bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, p - 4);
|
{
|
|
/* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4
|
|
so that a function can easily find the address of
|
|
_GLOBAL_OFFSET_TABLE_. */
|
|
BFD_ASSERT (htab->elf.hgot->root.u.def.value - 4
|
|
< htab->elf.hgot->root.u.def.section->size);
|
|
bfd_put_32 (output_bfd, 0x4e800021, p - 4);
|
|
}
|
|
|
val = 0;
|
|
if (sdyn != NULL)
|
if (sdyn != NULL)
|
val = sdyn->output_section->vma + sdyn->output_offset;
|
{
|
|
bfd_vma val = sdyn->output_section->vma + sdyn->output_offset;
|
|
BFD_ASSERT (htab->elf.hgot->root.u.def.value
|
|
< htab->elf.hgot->root.u.def.section->size);
|
bfd_put_32 (output_bfd, val, p);
|
bfd_put_32 (output_bfd, val, p);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
(*_bfd_error_handler) (_("%s not defined in linker created %s"),
|
|
htab->elf.hgot->root.root.string,
|
|
(htab->sgotplt != NULL
|
|
? htab->sgotplt->name : htab->got->name));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
ret = FALSE;
|
|
}
|
|
|
elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
|
elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
|
}
|
}
|
|
|
/* Fill in the first entry in the VxWorks procedure linkage table. */
|
/* Fill in the first entry in the VxWorks procedure linkage table. */
|
| Line 7442... |
Line 8672... |
plt_entry = info->shared ?
|
plt_entry = info->shared ?
|
ppc_elf_vxworks_pic_plt0_entry : ppc_elf_vxworks_plt0_entry;
|
ppc_elf_vxworks_pic_plt0_entry : ppc_elf_vxworks_plt0_entry;
|
|
|
if (!info->shared)
|
if (!info->shared)
|
{
|
{
|
bfd_vma got_value =
|
bfd_vma got_value = SYM_VAL (htab->elf.hgot);
|
(htab->elf.hgot->root.u.def.section->output_section->vma
|
|
+ htab->elf.hgot->root.u.def.section->output_offset
|
|
+ htab->elf.hgot->root.u.def.value);
|
|
bfd_vma got_hi = (got_value >> 16) + ((got_value & 0x8000) >> 15);
|
|
|
|
bfd_put_32 (output_bfd, plt_entry[0] | (got_hi & 0xffff),
|
bfd_put_32 (output_bfd, plt_entry[0] | PPC_HA (got_value),
|
splt->contents + 0);
|
splt->contents + 0);
|
bfd_put_32 (output_bfd, plt_entry[1] | (got_value & 0xffff),
|
bfd_put_32 (output_bfd, plt_entry[1] | PPC_LO (got_value),
|
splt->contents + 4);
|
splt->contents + 4);
|
}
|
}
|
else
|
else
|
{
|
{
|
bfd_put_32 (output_bfd, plt_entry[0], splt->contents + 0);
|
bfd_put_32 (output_bfd, plt_entry[0], splt->contents + 0);
|
| Line 7515... |
Line 8741... |
loc += sizeof (Elf32_External_Rela);
|
loc += sizeof (Elf32_External_Rela);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (htab->glink != NULL && htab->glink->contents != NULL)
|
if (htab->glink != NULL
|
|
&& htab->glink->contents != NULL
|
|
&& htab->elf.dynamic_sections_created)
|
{
|
{
|
unsigned char *p;
|
unsigned char *p;
|
unsigned char *endp;
|
unsigned char *endp;
|
bfd_vma res0;
|
bfd_vma res0;
|
unsigned int i;
|
unsigned int i;
|
| Line 7532... |
Line 8760... |
* lwz 11,(plt+(i-1)*4-got)@l(11)
|
* lwz 11,(plt+(i-1)*4-got)@l(11)
|
* mtctr 11
|
* mtctr 11
|
* bctr
|
* bctr
|
*
|
*
|
* # A table of branches, one for each plt entry.
|
* # A table of branches, one for each plt entry.
|
* # The idea is that the plt call stub loads ctr (and r11) with these
|
* # The idea is that the plt call stub loads ctr and r11 with these
|
* # addresses, so (r11 - res_0) gives the plt index * 4.
|
* # addresses, so (r11 - res_0) gives the plt index * 4.
|
* res_0: b PLTresolve
|
* res_0: b PLTresolve
|
* res_1: b PLTresolve
|
* res_1: b PLTresolve
|
* .
|
* .
|
* # Some number of entries towards the end can be nops
|
* # Some number of entries towards the end can be nops
|
| Line 7578... |
Line 8806... |
BCTR,
|
BCTR,
|
NOP,
|
NOP,
|
NOP
|
NOP
|
};
|
};
|
|
|
|
/*
|
|
* Non-PIC glink code is a little simpler.
|
|
*
|
|
* # ith PLT code stub.
|
|
* lis 11,(plt+(i-1)*4)@ha
|
|
* lwz 11,(plt+(i-1)*4)@l(11)
|
|
* mtctr 11
|
|
* bctr
|
|
*
|
|
* The branch table is the same, then comes
|
|
*
|
|
* PLTresolve:
|
|
* lis 12,(got+4)@ha
|
|
* addis 11,11,(-res_0)@ha
|
|
* lwz 0,(got+4)@l(12) # got[1] address of dl_runtime_resolve
|
|
* addi 11,11,(-res_0)@l # r11 = index * 4
|
|
* mtctr 0
|
|
* add 0,11,11
|
|
* lwz 12,(got+8)@l(12) # got[2] contains the map address
|
|
* add 11,0,11 # r11 = index * 12 = reloc offset.
|
|
* bctr
|
|
*/
|
static const unsigned int plt_resolve[] =
|
static const unsigned int plt_resolve[] =
|
{
|
{
|
LIS_12,
|
LIS_12,
|
ADDIS_11_11,
|
ADDIS_11_11,
|
LWZ_0_12,
|
LWZ_0_12,
|
| Line 7625... |
Line 8875... |
res0 = (htab->glink_pltresolve
|
res0 = (htab->glink_pltresolve
|
+ htab->glink->output_section->vma
|
+ htab->glink->output_section->vma
|
+ htab->glink->output_offset);
|
+ htab->glink->output_offset);
|
|
|
/* Last comes the PLTresolve stub. */
|
/* Last comes the PLTresolve stub. */
|
if (info->shared || info->pie)
|
if (info->shared)
|
{
|
{
|
bfd_vma bcl;
|
bfd_vma bcl;
|
|
|
for (i = 0; i < ARRAY_SIZE (pic_plt_resolve); i++)
|
for (i = 0; i < ARRAY_SIZE (pic_plt_resolve); i++)
|
{
|
{
|
| Line 7693... |
Line 8943... |
LWZ_12_12 + 4, p + 6*4);
|
LWZ_12_12 + 4, p + 6*4);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return TRUE;
|
return ret;
|
}
|
}
|
|
|
#define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec
|
#define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec
|
#define TARGET_LITTLE_NAME "elf32-powerpcle"
|
#define TARGET_LITTLE_NAME "elf32-powerpcle"
|
#define TARGET_BIG_SYM bfd_elf32_powerpc_vec
|
#define TARGET_BIG_SYM bfd_elf32_powerpc_vec
|
| Line 7731... |
Line 8981... |
#define bfd_elf32_bfd_relax_section ppc_elf_relax_section
|
#define bfd_elf32_bfd_relax_section ppc_elf_relax_section
|
#define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup
|
#define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup
|
#define bfd_elf32_bfd_reloc_name_lookup ppc_elf_reloc_name_lookup
|
#define bfd_elf32_bfd_reloc_name_lookup ppc_elf_reloc_name_lookup
|
#define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags
|
#define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags
|
#define bfd_elf32_bfd_link_hash_table_create ppc_elf_link_hash_table_create
|
#define bfd_elf32_bfd_link_hash_table_create ppc_elf_link_hash_table_create
|
|
#define bfd_elf32_get_synthetic_symtab ppc_elf_get_synthetic_symtab
|
|
|
#define elf_backend_object_p ppc_elf_object_p
|
#define elf_backend_object_p ppc_elf_object_p
|
#define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook
|
#define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook
|
#define elf_backend_gc_sweep_hook ppc_elf_gc_sweep_hook
|
#define elf_backend_gc_sweep_hook ppc_elf_gc_sweep_hook
|
#define elf_backend_section_from_shdr ppc_elf_section_from_shdr
|
#define elf_backend_section_from_shdr ppc_elf_section_from_shdr
|
| Line 7759... |
Line 9010... |
#define elf_backend_write_section ppc_elf_write_section
|
#define elf_backend_write_section ppc_elf_write_section
|
#define elf_backend_get_sec_type_attr ppc_elf_get_sec_type_attr
|
#define elf_backend_get_sec_type_attr ppc_elf_get_sec_type_attr
|
#define elf_backend_plt_sym_val ppc_elf_plt_sym_val
|
#define elf_backend_plt_sym_val ppc_elf_plt_sym_val
|
#define elf_backend_action_discarded ppc_elf_action_discarded
|
#define elf_backend_action_discarded ppc_elf_action_discarded
|
#define elf_backend_init_index_section _bfd_elf_init_1_index_section
|
#define elf_backend_init_index_section _bfd_elf_init_1_index_section
|
|
#define elf_backend_post_process_headers _bfd_elf_set_osabi
|
|
|
#include "elf32-target.h"
|
#include "elf32-target.h"
|
|
|
/* VxWorks Target */
|
/* VxWorks Target */
|
|
|
| Line 7845... |
Line 9097... |
#undef elf_backend_plt_readonly
|
#undef elf_backend_plt_readonly
|
#define elf_backend_plt_readonly 1
|
#define elf_backend_plt_readonly 1
|
#undef elf_backend_got_header_size
|
#undef elf_backend_got_header_size
|
#define elf_backend_got_header_size 12
|
#define elf_backend_got_header_size 12
|
|
|
|
#undef bfd_elf32_get_synthetic_symtab
|
|
|
#undef bfd_elf32_bfd_link_hash_table_create
|
#undef bfd_elf32_bfd_link_hash_table_create
|
#define bfd_elf32_bfd_link_hash_table_create \
|
#define bfd_elf32_bfd_link_hash_table_create \
|
ppc_elf_vxworks_link_hash_table_create
|
ppc_elf_vxworks_link_hash_table_create
|
#undef elf_backend_add_symbol_hook
|
#undef elf_backend_add_symbol_hook
|
#define elf_backend_add_symbol_hook \
|
#define elf_backend_add_symbol_hook \
|
| Line 7866... |
Line 9120... |
#define elf_backend_emit_relocs \
|
#define elf_backend_emit_relocs \
|
elf_vxworks_emit_relocs
|
elf_vxworks_emit_relocs
|
|
|
#undef elf32_bed
|
#undef elf32_bed
|
#define elf32_bed ppc_elf_vxworks_bed
|
#define elf32_bed ppc_elf_vxworks_bed
|
|
#undef elf_backend_post_process_headers
|
|
|
#include "elf32-target.h"
|
#include "elf32-target.h"
|
|
|
No newline at end of file
|
No newline at end of file
|
