/* ldctor.c -- constructor support routines
- Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 1998
- Free Software Foundation, Inc.
+ Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002, 2003 Free Software Foundation, Inc.
By Steve Chamberlain <sac@cygnus.com>
-
+
This file is part of GLD, the Gnu Linker.
GLD is free software; you can redistribute it and/or modify
#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
-
-#include <ctype.h>
+#include "safe-ctype.h"
#include "ld.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldmisc.h"
-#include "ldgram.h"
+#include <ldgram.h>
#include "ldmain.h"
#include "ldctor.h"
-static int ctor_prio PARAMS ((const char *));
-static int ctor_cmp PARAMS ((const PTR, const PTR));
-
/* The list of statements needed to handle constructors. These are
invoked by the command CONSTRUCTORS in the linker script. */
lang_statement_list_type constructor_list;
/* Whether the constructors should be sorted. Note that this is
global for the entire link; we assume that there is only a single
CONSTRUCTORS command in the linker script. */
-boolean constructors_sorted;
+bfd_boolean constructors_sorted;
/* The sets we have seen. */
struct set_info *sets;
function will construct the sets. */
void
-ldctor_add_set_entry (h, reloc, name, section, value)
- struct bfd_link_hash_entry *h;
- bfd_reloc_code_real_type reloc;
- const char *name;
- asection *section;
- bfd_vma value;
+ldctor_add_set_entry (struct bfd_link_hash_entry *h,
+ bfd_reloc_code_real_type reloc,
+ const char *name,
+ asection *section,
+ bfd_vma value)
{
struct set_info *p;
struct set_element *e;
struct set_element **epp;
- for (p = sets; p != (struct set_info *) NULL; p = p->next)
+ for (p = sets; p != NULL; p = p->next)
if (p->h == h)
break;
- if (p == (struct set_info *) NULL)
+ if (p == NULL)
{
- p = (struct set_info *) xmalloc (sizeof (struct set_info));
+ p = xmalloc (sizeof (struct set_info));
p->next = sets;
sets = p;
p->h = h;
{
if (p->reloc != reloc)
{
- einfo (_("%P%X: Different relocs used in set %s\n"), h->root.string);
+ einfo (_("%P%X: Different relocs used in set %s\n"),
+ h->root.string);
return;
}
}
}
- e = (struct set_element *) xmalloc (sizeof (struct set_element));
+ e = xmalloc (sizeof (struct set_element));
e->next = NULL;
e->name = name;
e->section = section;
symbol name. */
static int
-ctor_prio (name)
- const char *name;
+ctor_prio (const char *name)
{
/* The name will look something like _GLOBAL_$I$65535$test02__Fv.
There might be extra leading underscores, and the $ characters
while (*name == '_')
++name;
- if (strncmp (name, "GLOBAL_", sizeof "GLOBAL_" - 1) != 0)
+ if (strncmp (name, "GLOBAL_", sizeof "GLOBAL_" - 1) != 0)
return -1;
name += sizeof "GLOBAL_" - 1;
return -1;
if (name[1] != 'I' && name[1] != 'D')
return -1;
- if (! isdigit ((unsigned char) name[3]))
+ if (! ISDIGIT (name[3]))
return -1;
return atoi (name + 3);
is called via qsort. */
static int
-ctor_cmp (p1, p2)
- const PTR p1;
- const PTR p2;
+ctor_cmp (const void *p1, const void *p2)
{
- const struct set_element **pe1 = (const struct set_element **) p1;
- const struct set_element **pe2 = (const struct set_element **) p2;
+ const struct set_element * const *pe1 = p1;
+ const struct set_element * const *pe2 = p2;
const char *n1;
const char *n2;
int prio1;
int prio2;
- int ret;
n1 = (*pe1)->name;
if (n1 == NULL)
themselves into constructor_list. */
void
-ldctor_build_sets ()
+ldctor_build_sets (void)
{
- static boolean called;
+ static bfd_boolean called;
lang_statement_list_type *old;
- boolean header_printed;
+ bfd_boolean header_printed;
struct set_info *p;
/* The emulation code may call us directly, but we only want to do
this once. */
if (called)
return;
- called = true;
+ called = TRUE;
if (constructors_sorted)
{
for (e = p->elements; e != NULL; e = e->next)
++c;
- array = (struct set_element **) xmalloc (c * sizeof *array);
+ array = xmalloc (c * sizeof *array);
i = 0;
for (e = p->elements; e != NULL; e = e->next)
lang_list_init (stat_ptr);
- header_printed = false;
- for (p = sets; p != (struct set_info *) NULL; p = p->next)
+ header_printed = FALSE;
+ for (p = sets; p != NULL; p = p->next)
{
struct set_element *e;
reloc_howto_type *howto;
.long elementN
.long 0
except that we use the right size instead of .long. When
- generating relocateable output, we generate relocs instead of
+ generating relocatable output, we generate relocs instead of
addresses. */
howto = bfd_reloc_type_lookup (output_bfd, p->reloc);
- if (howto == (reloc_howto_type *) NULL)
+ if (howto == NULL)
{
- if (link_info.relocateable)
+ if (link_info.relocatable)
{
einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
bfd_get_target (output_bfd),
continue;
}
- /* If this is not a relocateable 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. */
- howto = bfd_reloc_type_lookup (p->elements->section->owner,
- p->reloc);
+ if (p->elements->section->owner != NULL)
+ howto = bfd_reloc_type_lookup (p->elements->section->owner,
+ p->reloc);
if (howto == NULL)
{
einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
exp_intop (reloc_size))));
lang_add_assignment (exp_assop ('=', p->h->root.string,
exp_nameop (NAME, ".")));
- lang_add_data (size, exp_intop ((bfd_vma) p->count));
+ lang_add_data (size, exp_intop (p->count));
- for (e = p->elements; e != (struct set_element *) NULL; e = e->next)
+ for (e = p->elements; e != NULL; e = e->next)
{
if (config.map_file != NULL)
{
if (! header_printed)
{
minfo (_("\nSet Symbol\n\n"));
- header_printed = true;
+ header_printed = TRUE;
}
minfo ("%s", p->h->root.string);
minfo ("%G\n", e->section->owner, e->section, e->value);
}
- if (link_info.relocateable)
+ /* Need SEC_KEEP for --gc-sections. */
+ if (! bfd_is_abs_section (e->section))
+ e->section->flags |= SEC_KEEP;
+
+ if (link_info.relocatable)
lang_add_reloc (p->reloc, howto, e->section, e->name,
exp_intop (e->value));
else
projects / deliverable / binutils-gdb.git / blobdiff