/* Motorola 68k series support for 32-bit ELF
Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
- 2004, 2005 Free Software Foundation, Inc.
+ 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/m68k.h"
+#include "opcode/m68k.h"
static reloc_howto_type *reloc_type_lookup
PARAMS ((bfd *, bfd_reloc_code_real_type));
#define CFV4E_PLT_ENTRY_SIZE 24
-#define CFV4E_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_CFV4E)
+#define CFV4E_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_M68K_CFV4E)
static const bfd_byte elf_cfv4e_plt0_entry[CFV4E_PLT_ENTRY_SIZE] =
{
0, 0, 0, 0 /* Replaced with offset to start of .plt. */
};
-#define CPU32_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_CPU32)
+#define CPU32_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_M68K_CPU32)
#define PLT_CPU32_ENTRY_SIZE 24
/* Procedure linkage table entries for the cpu32 */
if (ret == (struct elf_m68k_link_hash_table *) NULL)
return NULL;
- if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
- elf_m68k_link_hash_newfunc))
+ if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
+ elf_m68k_link_hash_newfunc,
+ sizeof (struct elf_m68k_link_hash_entry)))
{
free (ret);
return NULL;
return &ret->root.root;
}
+/* Set the right machine number. */
+
+static bfd_boolean
+elf32_m68k_object_p (bfd *abfd)
+{
+ unsigned int mach = 0;
+ unsigned features = 0;
+ flagword eflags = elf_elfheader (abfd)->e_flags;
+
+ if (eflags & EF_M68K_M68000)
+ features |= m68000;
+ else if (eflags & EF_M68K_CPU32)
+ features |= cpu32;
+ else if (eflags & EF_M68K_ISA_MASK)
+ {
+ switch (eflags & EF_M68K_ISA_MASK)
+ {
+ case EF_M68K_ISA_A_NODIV:
+ features |= mcfisa_a;
+ break;
+ case EF_M68K_ISA_A:
+ features |= mcfisa_a|mcfhwdiv;
+ break;
+ case EF_M68K_ISA_A_PLUS:
+ features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
+ break;
+ case EF_M68K_ISA_B_NOUSP:
+ features |= mcfisa_a|mcfisa_b|mcfhwdiv;
+ break;
+ case EF_M68K_ISA_B:
+ features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
+ break;
+ }
+ switch (eflags & EF_M68K_MAC_MASK)
+ {
+ case EF_M68K_MAC:
+ features |= mcfmac;
+ break;
+ case EF_M68K_EMAC:
+ features |= mcfemac;
+ break;
+ }
+ if (eflags & EF_M68K_FLOAT)
+ features |= cfloat;
+ }
+
+ mach = bfd_m68k_features_to_mach (features);
+ bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
+
+ return TRUE;
+}
+
/* Keep m68k-specific flags in the ELF header. */
static bfd_boolean
elf32_m68k_set_private_flags (abfd, flags)
{
flagword out_flags;
flagword in_flags;
-
+ unsigned in_mach, out_mach;
+
if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return TRUE;
-
+ return FALSE;
+
+ in_mach = bfd_get_mach (ibfd);
+ out_mach = bfd_get_mach (obfd);
+ if (!out_mach || !in_mach)
+ /* One is unknown, copy the input machine. */
+ out_mach = in_mach;
+ else if (in_mach != out_mach)
+ {
+ if (in_mach <= bfd_mach_m68060 && out_mach <= bfd_mach_m68060)
+ {
+ /* Merge m68k machine. */
+ if (in_mach > out_mach)
+ out_mach = in_mach;
+ }
+ else if (in_mach >= bfd_mach_mcf_isa_a_nodiv
+ && out_mach >= bfd_mach_mcf_isa_a_nodiv)
+ /* Merge cf machine. */
+ out_mach = bfd_m68k_features_to_mach
+ (bfd_m68k_mach_to_features (in_mach)
+ | bfd_m68k_mach_to_features (out_mach));
+ else
+ /* They are incompatible. */
+ return FALSE;
+ }
+ bfd_set_arch_mach (obfd, bfd_arch_m68k, out_mach);
+
in_flags = elf_elfheader (ibfd)->e_flags;
out_flags = elf_elfheader (obfd)->e_flags;
if (!elf_flags_init (obfd))
{
elf_flags_init (obfd) = TRUE;
- elf_elfheader (obfd)->e_flags = in_flags;
+ out_flags = in_flags;
}
+ else
+ {
+ flagword isa_in = in_flags & EF_M68K_ISA_MASK;
+ flagword isa_out = out_flags & EF_M68K_ISA_MASK;
+
+
+ /* Copy legacy flags. */
+ out_flags |= in_flags & (EF_M68K_CPU32 | EF_M68K_M68000 | EF_M68K_CFV4E);
+
+ if ((isa_in | isa_out)
+ && ((in_flags | out_flags) & (EF_M68K_CPU32 | EF_M68K_M68000)))
+ /* Mixing m68k and cf is not allowed */
+ return FALSE;
+
+ if (isa_in)
+ {
+ if (isa_out)
+ {
+ if (isa_out == EF_M68K_ISA_A_PLUS
+ && (isa_in == EF_M68K_ISA_B_NOUSP
+ || isa_in == EF_M68K_ISA_B))
+ /* Cannot mix A+ and B */
+ return FALSE;
+ if (isa_in == EF_M68K_ISA_A_PLUS
+ && (isa_out == EF_M68K_ISA_B_NOUSP
+ || isa_out == EF_M68K_ISA_B))
+ /* Cannot mix B and A+ */
+ return FALSE;
+
+ if (isa_in > isa_out)
+ out_flags ^= isa_in ^ isa_out;
+
+ out_flags |= in_flags & EF_M68K_FLOAT;
+ if (in_flags & EF_M68K_MAC_MASK)
+ {
+ if (!(out_flags & EF_M68K_MAC_MASK))
+ out_flags |= in_flags & EF_M68K_MAC_MASK;
+ else if ((out_flags & EF_M68K_MAC_MASK)
+ != (in_flags & EF_M68K_MAC_MASK))
+ /* Cannot mix MACs */
+ return FALSE;
+ }
+ }
+ else
+ {
+ /* Copy the coldfire bits. */
+ out_flags &= ~EF_M68K_CF_MASK;
+ out_flags |= in_flags & EF_M68K_CF_MASK;
+ }
+ }
+ }
+ elf_elfheader (obfd)->e_flags = out_flags;
return TRUE;
}
PTR ptr;
{
FILE *file = (FILE *) ptr;
+ flagword eflags = elf_elfheader (abfd)->e_flags;
BFD_ASSERT (abfd != NULL && ptr != NULL);
/* xgettext:c-format */
fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
- if (elf_elfheader (abfd)->e_flags & EF_CPU32)
- fprintf (file, _(" [cpu32]"));
+ if (eflags & EF_M68K_CPU32)
+ fprintf (file, " [cpu32]");
+
+ if (eflags & EF_M68K_M68000)
+ fprintf (file, " [m68000]");
- if (elf_elfheader (abfd)->e_flags & EF_M68000)
- fprintf (file, _(" [m68000]"));
+ if (eflags & EF_M68K_CFV4E)
+ fprintf (file, " [cfv4e]");
+ if (eflags & EF_M68K_ISA_MASK)
+ {
+ char const *isa = _("unknown");
+ char const *mac = _("unknown");
+ char const *additional = "";
+
+ switch (eflags & EF_M68K_ISA_MASK)
+ {
+ case EF_M68K_ISA_A_NODIV:
+ isa = "A";
+ additional = " [nodiv]";
+ break;
+ case EF_M68K_ISA_A:
+ isa = "A";
+ break;
+ case EF_M68K_ISA_A_PLUS:
+ isa = "A+";
+ break;
+ case EF_M68K_ISA_B_NOUSP:
+ isa = "B";
+ additional = " [nousp]";
+ break;
+ case EF_M68K_ISA_B:
+ isa = "B";
+ break;
+ }
+ fprintf (file, " [isa %s]%s", isa, additional);
+ if (eflags & EF_M68K_FLOAT)
+ fprintf (file, " [float]");
+ switch (eflags & EF_M68K_MAC_MASK)
+ {
+ case 0:
+ mac = NULL;
+ break;
+ case EF_M68K_MAC:
+ mac = "mac";
+ break;
+ case EF_M68K_EMAC:
+ mac = "emac";
+ break;
+ }
+ if (mac)
+ fprintf (file, " [%s]", mac);
+ }
+
fputc ('\n', file);
return TRUE;
if (r_symndx < symtab_hdr->sh_info)
h = NULL;
else
- h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ {
+ 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;
+ }
switch (ELF32_R_TYPE (rel->r_info))
{
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
if (srelgot == NULL)
{
- srelgot = bfd_make_section (dynobj, ".rela.got");
+ srelgot = bfd_make_section_with_flags (dynobj,
+ ".rela.got",
+ (SEC_ALLOC
+ | SEC_LOAD
+ | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY
+ | SEC_LINKER_CREATED
+ | SEC_READONLY));
if (srelgot == NULL
- || !bfd_set_section_flags (dynobj, srelgot,
- (SEC_ALLOC
- | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY))
|| !bfd_set_section_alignment (dynobj, srelgot, 2))
return FALSE;
}
sreloc = bfd_get_section_by_name (dynobj, name);
if (sreloc == NULL)
{
- sreloc = bfd_make_section (dynobj, name);
+ sreloc = bfd_make_section_with_flags (dynobj,
+ name,
+ (SEC_ALLOC
+ | SEC_LOAD
+ | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY
+ | SEC_LINKER_CREATED
+ | SEC_READONLY));
if (sreloc == NULL
- || !bfd_set_section_flags (dynobj, sreloc,
- (SEC_ALLOC
- | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY))
|| !bfd_set_section_alignment (dynobj, sreloc, 2))
return FALSE;
}
else
{
asection *s;
+ void *vpp;
+
s = (bfd_section_from_r_symndx
(abfd, &elf_m68k_hash_table (info)->sym_sec,
sec, r_symndx));
if (s == NULL)
return FALSE;
- head = ((struct elf_m68k_pcrel_relocs_copied **)
- &elf_section_data (s)->local_dynrel);
+ vpp = &elf_section_data (s)->local_dynrel;
+ head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
}
for (p = *head; p != NULL; p = p->next)
if (info->shared)
return TRUE;
+ if (h->size == 0)
+ {
+ (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
+ h->root.root.string);
+ return TRUE;
+ }
+
/* We must allocate the symbol in our .dynbss section, which will
become part of the .bss section of the executable. There will be
an entry for this symbol in the .dynsym section. The dynamic
for (s = dynobj->sections; s != NULL; s = s->next)
{
const char *name;
- bfd_boolean strip;
if ((s->flags & SEC_LINKER_CREATED) == 0)
continue;
of the dynobj section names depend upon the input files. */
name = bfd_get_section_name (dynobj, s);
- strip = FALSE;
-
if (strcmp (name, ".plt") == 0)
{
- if (s->size == 0)
- {
- /* Strip this section if we don't need it; see the
- comment below. */
- strip = TRUE;
- }
- else
- {
- /* Remember whether there is a PLT. */
- plt = TRUE;
- }
+ /* Remember whether there is a PLT. */
+ plt = s->size != 0;
}
else if (strncmp (name, ".rela", 5) == 0)
{
- if (s->size == 0)
- {
- /* If we don't need this section, strip it from the
- output file. This is mostly to handle .rela.bss and
- .rela.plt. We must create both sections in
- create_dynamic_sections, because they must be created
- before the linker maps input sections to output
- sections. The linker does that before
- adjust_dynamic_symbol is called, and it is that
- function which decides whether anything needs to go
- into these sections. */
- strip = TRUE;
- }
- else
+ if (s->size != 0)
{
relocs = TRUE;
s->reloc_count = 0;
}
}
- else if (strncmp (name, ".got", 4) != 0)
+ else if (strncmp (name, ".got", 4) != 0
+ && strcmp (name, ".dynbss") != 0)
{
/* It's not one of our sections, so don't allocate space. */
continue;
}
- if (strip)
+ if (s->size == 0)
{
+ /* If we don't need this section, strip it from the
+ output file. This is mostly to handle .rela.bss and
+ .rela.plt. We must create both sections in
+ create_dynamic_sections, because they must be created
+ before the linker maps input sections to output
+ sections. The linker does that before
+ adjust_dynamic_symbol is called, and it is that
+ function which decides whether anything needs to go
+ into these sections. */
s->flags |= SEC_EXCLUDE;
continue;
}
+ if ((s->flags & SEC_HAS_CONTENTS) == 0)
+ continue;
+
/* Allocate memory for the section contents. */
/* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
Unused entries should be reclaimed before the section's contents
order to prevent writing out garbage, we initialise the section's
contents to zero. */
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
- if (s->contents == NULL && s->size != 0)
+ if (s->contents == NULL)
return FALSE;
}
&& h->def_dynamic))
{
(*_bfd_error_handler)
- (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
+ (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
(long) rel->r_offset,
+ howto->name,
h->root.root.string);
return FALSE;
}
+ got_offset
- (splt->output_section->vma
+ h->plt.offset
- + CFV4E_FLAG (output_bfd) ? 8 : 2),
+ + (CFV4E_FLAG (output_bfd) ? 8 : 2)),
splt->contents + h->plt.offset + plt_off1);
bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
(splt->output_section->vma
+ splt->output_offset
+ h->plt.offset
- + CFV4E_FLAG (output_bfd) ? 12 : 8),
+ + (CFV4E_FLAG (output_bfd) ? 12 : 8)),
sgot->contents + got_offset);
/* Fill in the entry in the .rela.plt section. */
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
if (strcmp (h->root.root.string, "_DYNAMIC") == 0
- || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
+ || h == elf_hash_table (info)->hgot)
sym->st_shndx = SHN_ABS;
return TRUE;
elf32_m68k_print_private_bfd_data
#define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
#define elf_backend_plt_sym_val elf_m68k_plt_sym_val
+#define elf_backend_object_p elf32_m68k_object_p
#define elf_backend_can_gc_sections 1
#define elf_backend_can_refcount 1
projects / deliverable / binutils-gdb.git / blobdiff