/* ldctor.c -- constructor support routines
|
/* ldctor.c -- constructor support routines
|
Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
|
Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
|
2002, 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
|
2002, 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
|
By Steve Chamberlain <sac@cygnus.com>
|
By Steve Chamberlain <sac@cygnus.com>
|
|
|
This file is part of the GNU Binutils.
|
This file is part of the GNU Binutils.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
MA 02110-1301, USA. */
|
MA 02110-1301, USA. */
|
|
|
#include "sysdep.h"
|
#include "sysdep.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "bfdlink.h"
|
#include "bfdlink.h"
|
#include "safe-ctype.h"
|
#include "safe-ctype.h"
|
|
|
#include "ld.h"
|
#include "ld.h"
|
#include "ldexp.h"
|
#include "ldexp.h"
|
#include "ldlang.h"
|
#include "ldlang.h"
|
#include "ldmisc.h"
|
#include "ldmisc.h"
|
#include <ldgram.h>
|
#include <ldgram.h>
|
#include "ldmain.h"
|
#include "ldmain.h"
|
#include "ldctor.h"
|
#include "ldctor.h"
|
|
|
/* The list of statements needed to handle constructors. These are
|
/* The list of statements needed to handle constructors. These are
|
invoked by the command CONSTRUCTORS in the linker script. */
|
invoked by the command CONSTRUCTORS in the linker script. */
|
lang_statement_list_type constructor_list;
|
lang_statement_list_type constructor_list;
|
|
|
/* Whether the constructors should be sorted. Note that this is
|
/* Whether the constructors should be sorted. Note that this is
|
global for the entire link; we assume that there is only a single
|
global for the entire link; we assume that there is only a single
|
CONSTRUCTORS command in the linker script. */
|
CONSTRUCTORS command in the linker script. */
|
bfd_boolean constructors_sorted;
|
bfd_boolean constructors_sorted;
|
|
|
/* The sets we have seen. */
|
/* The sets we have seen. */
|
struct set_info *sets;
|
struct set_info *sets;
|
|
|
/* Add an entry to a set. H is the entry in the linker hash table.
|
/* Add an entry to a set. H is the entry in the linker hash table.
|
RELOC is the relocation to use for an entry in the set. SECTION
|
RELOC is the relocation to use for an entry in the set. SECTION
|
and VALUE are the value to add. This is called during the first
|
and VALUE are the value to add. This is called during the first
|
phase of the link, when we are still gathering symbols together.
|
phase of the link, when we are still gathering symbols together.
|
We just record the information now. The ldctor_build_sets
|
We just record the information now. The ldctor_build_sets
|
function will construct the sets. */
|
function will construct the sets. */
|
|
|
void
|
void
|
ldctor_add_set_entry (struct bfd_link_hash_entry *h,
|
ldctor_add_set_entry (struct bfd_link_hash_entry *h,
|
bfd_reloc_code_real_type reloc,
|
bfd_reloc_code_real_type reloc,
|
const char *name,
|
const char *name,
|
asection *section,
|
asection *section,
|
bfd_vma value)
|
bfd_vma value)
|
{
|
{
|
struct set_info *p;
|
struct set_info *p;
|
struct set_element *e;
|
struct set_element *e;
|
struct set_element **epp;
|
struct set_element **epp;
|
|
|
for (p = sets; p != NULL; p = p->next)
|
for (p = sets; p != NULL; p = p->next)
|
if (p->h == h)
|
if (p->h == h)
|
break;
|
break;
|
|
|
if (p == NULL)
|
if (p == NULL)
|
{
|
{
|
p = xmalloc (sizeof (struct set_info));
|
p = xmalloc (sizeof (struct set_info));
|
p->next = sets;
|
p->next = sets;
|
sets = p;
|
sets = p;
|
p->h = h;
|
p->h = h;
|
p->reloc = reloc;
|
p->reloc = reloc;
|
p->count = 0;
|
p->count = 0;
|
p->elements = NULL;
|
p->elements = NULL;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (p->reloc != reloc)
|
if (p->reloc != reloc)
|
{
|
{
|
einfo (_("%P%X: Different relocs used in set %s\n"),
|
einfo (_("%P%X: Different relocs used in set %s\n"),
|
h->root.string);
|
h->root.string);
|
return;
|
return;
|
}
|
}
|
|
|
/* Don't permit a set to be constructed from different object
|
/* Don't permit a set to be constructed from different object
|
file formats. The same reloc may have different results. We
|
file formats. The same reloc may have different results. We
|
actually could sometimes handle this, but the case is
|
actually could sometimes handle this, but the case is
|
unlikely to ever arise. Sometimes constructor symbols are in
|
unlikely to ever arise. Sometimes constructor symbols are in
|
unusual sections, such as the absolute section--this appears
|
unusual sections, such as the absolute section--this appears
|
to be the case in Linux a.out--and in such cases we just
|
to be the case in Linux a.out--and in such cases we just
|
assume everything is OK. */
|
assume everything is OK. */
|
if (p->elements != NULL
|
if (p->elements != NULL
|
&& section->owner != NULL
|
&& section->owner != NULL
|
&& p->elements->section->owner != NULL
|
&& p->elements->section->owner != NULL
|
&& strcmp (bfd_get_target (section->owner),
|
&& strcmp (bfd_get_target (section->owner),
|
bfd_get_target (p->elements->section->owner)) != 0)
|
bfd_get_target (p->elements->section->owner)) != 0)
|
{
|
{
|
einfo (_("%P%X: Different object file formats composing set %s\n"),
|
einfo (_("%P%X: Different object file formats composing set %s\n"),
|
h->root.string);
|
h->root.string);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
e = xmalloc (sizeof (struct set_element));
|
e = xmalloc (sizeof (struct set_element));
|
e->next = NULL;
|
e->next = NULL;
|
e->name = name;
|
e->name = name;
|
e->section = section;
|
e->section = section;
|
e->value = value;
|
e->value = value;
|
|
|
for (epp = &p->elements; *epp != NULL; epp = &(*epp)->next)
|
for (epp = &p->elements; *epp != NULL; epp = &(*epp)->next)
|
;
|
;
|
*epp = e;
|
*epp = e;
|
|
|
++p->count;
|
++p->count;
|
}
|
}
|
|
|
/* Get the priority of a g++ global constructor or destructor from the
|
/* Get the priority of a g++ global constructor or destructor from the
|
symbol name. */
|
symbol name. */
|
|
|
static int
|
static int
|
ctor_prio (const char *name)
|
ctor_prio (const char *name)
|
{
|
{
|
/* The name will look something like _GLOBAL_$I$65535$test02__Fv.
|
/* The name will look something like _GLOBAL_$I$65535$test02__Fv.
|
There might be extra leading underscores, and the $ characters
|
There might be extra leading underscores, and the $ characters
|
might be something else. The I might be a D. */
|
might be something else. The I might be a D. */
|
|
|
while (*name == '_')
|
while (*name == '_')
|
++name;
|
++name;
|
|
|
if (! CONST_STRNEQ (name, "GLOBAL_"))
|
if (! CONST_STRNEQ (name, "GLOBAL_"))
|
return -1;
|
return -1;
|
|
|
name += sizeof "GLOBAL_" - 1;
|
name += sizeof "GLOBAL_" - 1;
|
|
|
if (name[0] != name[2])
|
if (name[0] != name[2])
|
return -1;
|
return -1;
|
if (name[1] != 'I' && name[1] != 'D')
|
if (name[1] != 'I' && name[1] != 'D')
|
return -1;
|
return -1;
|
if (! ISDIGIT (name[3]))
|
if (! ISDIGIT (name[3]))
|
return -1;
|
return -1;
|
|
|
return atoi (name + 3);
|
return atoi (name + 3);
|
}
|
}
|
|
|
/* This function is used to sort constructor elements by priority. It
|
/* This function is used to sort constructor elements by priority. It
|
is called via qsort. */
|
is called via qsort. */
|
|
|
static int
|
static int
|
ctor_cmp (const void *p1, const void *p2)
|
ctor_cmp (const void *p1, const void *p2)
|
{
|
{
|
const struct set_element * const *pe1 = p1;
|
const struct set_element * const *pe1 = p1;
|
const struct set_element * const *pe2 = p2;
|
const struct set_element * const *pe2 = p2;
|
const char *n1;
|
const char *n1;
|
const char *n2;
|
const char *n2;
|
int prio1;
|
int prio1;
|
int prio2;
|
int prio2;
|
|
|
n1 = (*pe1)->name;
|
n1 = (*pe1)->name;
|
if (n1 == NULL)
|
if (n1 == NULL)
|
n1 = "";
|
n1 = "";
|
n2 = (*pe2)->name;
|
n2 = (*pe2)->name;
|
if (n2 == NULL)
|
if (n2 == NULL)
|
n2 = "";
|
n2 = "";
|
|
|
/* We need to sort in reverse order by priority. When two
|
/* We need to sort in reverse order by priority. When two
|
constructors have the same priority, we should maintain their
|
constructors have the same priority, we should maintain their
|
current relative position. */
|
current relative position. */
|
|
|
prio1 = ctor_prio (n1);
|
prio1 = ctor_prio (n1);
|
prio2 = ctor_prio (n2);
|
prio2 = ctor_prio (n2);
|
|
|
/* We sort in reverse order because that is what g++ expects. */
|
/* We sort in reverse order because that is what g++ expects. */
|
if (prio1 < prio2)
|
if (prio1 < prio2)
|
return 1;
|
return 1;
|
else if (prio1 > prio2)
|
else if (prio1 > prio2)
|
return -1;
|
return -1;
|
|
|
/* Force a stable sort. */
|
/* Force a stable sort. */
|
|
|
if (pe1 < pe2)
|
if (pe1 < pe2)
|
return -1;
|
return -1;
|
else if (pe1 > pe2)
|
else if (pe1 > pe2)
|
return 1;
|
return 1;
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* This function is called after the first phase of the link and
|
/* This function is called after the first phase of the link and
|
before the second phase. At this point all set information has
|
before the second phase. At this point all set information has
|
been gathered. We now put the statements to build the sets
|
been gathered. We now put the statements to build the sets
|
themselves into constructor_list. */
|
themselves into constructor_list. */
|
|
|
void
|
void
|
ldctor_build_sets (void)
|
ldctor_build_sets (void)
|
{
|
{
|
static bfd_boolean called;
|
static bfd_boolean called;
|
lang_statement_list_type *old;
|
lang_statement_list_type *old;
|
bfd_boolean header_printed;
|
bfd_boolean header_printed;
|
struct set_info *p;
|
struct set_info *p;
|
|
|
/* The emulation code may call us directly, but we only want to do
|
/* The emulation code may call us directly, but we only want to do
|
this once. */
|
this once. */
|
if (called)
|
if (called)
|
return;
|
return;
|
called = TRUE;
|
called = TRUE;
|
|
|
if (constructors_sorted)
|
if (constructors_sorted)
|
{
|
{
|
for (p = sets; p != NULL; p = p->next)
|
for (p = sets; p != NULL; p = p->next)
|
{
|
{
|
int c, i;
|
int c, i;
|
struct set_element *e;
|
struct set_element *e;
|
struct set_element **array;
|
struct set_element **array;
|
|
|
if (p->elements == NULL)
|
if (p->elements == NULL)
|
continue;
|
continue;
|
|
|
c = 0;
|
c = 0;
|
for (e = p->elements; e != NULL; e = e->next)
|
for (e = p->elements; e != NULL; e = e->next)
|
++c;
|
++c;
|
|
|
array = xmalloc (c * sizeof *array);
|
array = xmalloc (c * sizeof *array);
|
|
|
i = 0;
|
i = 0;
|
for (e = p->elements; e != NULL; e = e->next)
|
for (e = p->elements; e != NULL; e = e->next)
|
{
|
{
|
array[i] = e;
|
array[i] = e;
|
++i;
|
++i;
|
}
|
}
|
|
|
qsort (array, c, sizeof *array, ctor_cmp);
|
qsort (array, c, sizeof *array, ctor_cmp);
|
|
|
e = array[0];
|
e = array[0];
|
p->elements = e;
|
p->elements = e;
|
for (i = 0; i < c - 1; i++)
|
for (i = 0; i < c - 1; i++)
|
array[i]->next = array[i + 1];
|
array[i]->next = array[i + 1];
|
array[i]->next = NULL;
|
array[i]->next = NULL;
|
|
|
free (array);
|
free (array);
|
}
|
}
|
}
|
}
|
|
|
old = stat_ptr;
|
old = stat_ptr;
|
stat_ptr = &constructor_list;
|
stat_ptr = &constructor_list;
|
|
|
lang_list_init (stat_ptr);
|
lang_list_init (stat_ptr);
|
|
|
header_printed = FALSE;
|
header_printed = FALSE;
|
for (p = sets; p != NULL; p = p->next)
|
for (p = sets; p != NULL; p = p->next)
|
{
|
{
|
struct set_element *e;
|
struct set_element *e;
|
reloc_howto_type *howto;
|
reloc_howto_type *howto;
|
int reloc_size, size;
|
int reloc_size, size;
|
|
|
/* If the symbol is defined, we may have been invoked from
|
/* If the symbol is defined, we may have been invoked from
|
collect, and the sets may already have been built, so we do
|
collect, and the sets may already have been built, so we do
|
not do anything. */
|
not do anything. */
|
if (p->h->type == bfd_link_hash_defined
|
if (p->h->type == bfd_link_hash_defined
|
|| p->h->type == bfd_link_hash_defweak)
|
|| p->h->type == bfd_link_hash_defweak)
|
continue;
|
continue;
|
|
|
/* For each set we build:
|
/* For each set we build:
|
set:
|
set:
|
.long number_of_elements
|
.long number_of_elements
|
.long element0
|
.long element0
|
...
|
...
|
.long elementN
|
.long elementN
|
.long 0
|
.long 0
|
except that we use the right size instead of .long. When
|
except that we use the right size instead of .long. When
|
generating relocatable output, we generate relocs instead of
|
generating relocatable output, we generate relocs instead of
|
addresses. */
|
addresses. */
|
howto = bfd_reloc_type_lookup (link_info.output_bfd, p->reloc);
|
howto = bfd_reloc_type_lookup (link_info.output_bfd, p->reloc);
|
if (howto == NULL)
|
if (howto == NULL)
|
{
|
{
|
if (link_info.relocatable)
|
if (link_info.relocatable)
|
{
|
{
|
einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
|
einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
|
bfd_get_target (link_info.output_bfd),
|
bfd_get_target (link_info.output_bfd),
|
bfd_get_reloc_code_name (p->reloc),
|
bfd_get_reloc_code_name (p->reloc),
|
p->h->root.string);
|
p->h->root.string);
|
continue;
|
continue;
|
}
|
}
|
|
|
/* If this is not a relocatable link, all we need is the
|
/* If this is not a relocatable link, all we need is the
|
size, which we can get from the input BFD. */
|
size, which we can get from the input BFD. */
|
if (p->elements->section->owner != NULL)
|
if (p->elements->section->owner != NULL)
|
howto = bfd_reloc_type_lookup (p->elements->section->owner,
|
howto = bfd_reloc_type_lookup (p->elements->section->owner,
|
p->reloc);
|
p->reloc);
|
if (howto == NULL)
|
if (howto == NULL)
|
{
|
{
|
einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
|
einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
|
bfd_get_target (p->elements->section->owner),
|
bfd_get_target (p->elements->section->owner),
|
bfd_get_reloc_code_name (p->reloc),
|
bfd_get_reloc_code_name (p->reloc),
|
p->h->root.string);
|
p->h->root.string);
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
|
|
reloc_size = bfd_get_reloc_size (howto);
|
reloc_size = bfd_get_reloc_size (howto);
|
switch (reloc_size)
|
switch (reloc_size)
|
{
|
{
|
case 1: size = BYTE; break;
|
case 1: size = BYTE; break;
|
case 2: size = SHORT; break;
|
case 2: size = SHORT; break;
|
case 4: size = LONG; break;
|
case 4: size = LONG; break;
|
case 8:
|
case 8:
|
if (howto->complain_on_overflow == complain_overflow_signed)
|
if (howto->complain_on_overflow == complain_overflow_signed)
|
size = SQUAD;
|
size = SQUAD;
|
else
|
else
|
size = QUAD;
|
size = QUAD;
|
break;
|
break;
|
default:
|
default:
|
einfo (_("%P%X: Unsupported size %d for set %s\n"),
|
einfo (_("%P%X: Unsupported size %d for set %s\n"),
|
bfd_get_reloc_size (howto), p->h->root.string);
|
bfd_get_reloc_size (howto), p->h->root.string);
|
size = LONG;
|
size = LONG;
|
break;
|
break;
|
}
|
}
|
|
|
lang_add_assignment (exp_assop ('=', ".",
|
lang_add_assignment (exp_assop ('=', ".",
|
exp_unop (ALIGN_K,
|
exp_unop (ALIGN_K,
|
exp_intop (reloc_size))));
|
exp_intop (reloc_size))));
|
lang_add_assignment (exp_assop ('=', p->h->root.string,
|
lang_add_assignment (exp_assop ('=', p->h->root.string,
|
exp_nameop (NAME, ".")));
|
exp_nameop (NAME, ".")));
|
lang_add_data (size, exp_intop (p->count));
|
lang_add_data (size, exp_intop (p->count));
|
|
|
for (e = p->elements; e != NULL; e = e->next)
|
for (e = p->elements; e != NULL; e = e->next)
|
{
|
{
|
if (config.map_file != NULL)
|
if (config.map_file != NULL)
|
{
|
{
|
int len;
|
int len;
|
|
|
if (! header_printed)
|
if (! header_printed)
|
{
|
{
|
minfo (_("\nSet Symbol\n\n"));
|
minfo (_("\nSet Symbol\n\n"));
|
header_printed = TRUE;
|
header_printed = TRUE;
|
}
|
}
|
|
|
minfo ("%s", p->h->root.string);
|
minfo ("%s", p->h->root.string);
|
len = strlen (p->h->root.string);
|
len = strlen (p->h->root.string);
|
|
|
if (len >= 19)
|
if (len >= 19)
|
{
|
{
|
print_nl ();
|
print_nl ();
|
len = 0;
|
len = 0;
|
}
|
}
|
while (len < 20)
|
while (len < 20)
|
{
|
{
|
print_space ();
|
print_space ();
|
++len;
|
++len;
|
}
|
}
|
|
|
if (e->name != NULL)
|
if (e->name != NULL)
|
minfo ("%T\n", e->name);
|
minfo ("%T\n", e->name);
|
else
|
else
|
minfo ("%G\n", e->section->owner, e->section, e->value);
|
minfo ("%G\n", e->section->owner, e->section, e->value);
|
}
|
}
|
|
|
/* Need SEC_KEEP for --gc-sections. */
|
/* Need SEC_KEEP for --gc-sections. */
|
if (! bfd_is_abs_section (e->section))
|
if (! bfd_is_abs_section (e->section))
|
e->section->flags |= SEC_KEEP;
|
e->section->flags |= SEC_KEEP;
|
|
|
if (link_info.relocatable)
|
if (link_info.relocatable)
|
lang_add_reloc (p->reloc, howto, e->section, e->name,
|
lang_add_reloc (p->reloc, howto, e->section, e->name,
|
exp_intop (e->value));
|
exp_intop (e->value));
|
else
|
else
|
lang_add_data (size, exp_relop (e->section, e->value));
|
lang_add_data (size, exp_relop (e->section, e->value));
|
}
|
}
|
|
|
lang_add_data (size, exp_intop (0));
|
lang_add_data (size, exp_intop (0));
|
}
|
}
|
|
|
stat_ptr = old;
|
stat_ptr = old;
|
}
|
}
|
|
|
