#include "libiberty.h"
#include "safe-ctype.h"
+static etree_value_type exp_fold_tree_1
+ (etree_type *, lang_output_section_statement_type *,
+ lang_phase_type, bfd_vma, bfd_vma *, bfd_boolean);
static etree_value_type exp_fold_tree_no_dot
- (etree_type *, lang_output_section_statement_type *, lang_phase_type);
+ (etree_type *, lang_output_section_statement_type *, lang_phase_type,
+ bfd_boolean);
static bfd_vma align_n
(bfd_vma, bfd_vma);
lang_output_section_statement_type *current_section,
lang_phase_type allocation_done,
bfd_vma dot,
- bfd_vma *dotp)
+ bfd_vma *dotp,
+ bfd_boolean mark_used)
{
etree_value_type result;
- result = exp_fold_tree (tree->unary.child,
- current_section,
- allocation_done, dot, dotp);
+ result = exp_fold_tree_1 (tree->unary.child,
+ current_section,
+ allocation_done, dot, dotp, mark_used);
if (result.valid_p)
{
switch (tree->type.node_code)
lang_output_section_statement_type *current_section,
lang_phase_type allocation_done,
bfd_vma dot,
- bfd_vma *dotp)
+ bfd_vma *dotp,
+ bfd_boolean mark_used)
{
etree_value_type result;
- result = exp_fold_tree (tree->binary.lhs, current_section,
- allocation_done, dot, dotp);
+ result = exp_fold_tree_1 (tree->binary.lhs, current_section,
+ allocation_done, dot, dotp, mark_used);
/* The SEGMENT_START operator is special because its first
operand is a string, not the name of a symbol. */
{
etree_value_type other;
- other = exp_fold_tree (tree->binary.rhs,
- current_section,
- allocation_done, dot, dotp);
+ other = exp_fold_tree_1 (tree->binary.rhs,
+ current_section,
+ allocation_done,
+ dot, dotp, mark_used);
if (other.valid_p)
{
/* If the values are from different sections, or this is an
lang_output_section_statement_type *current_section,
lang_phase_type allocation_done,
bfd_vma dot,
- bfd_vma *dotp)
+ bfd_vma *dotp,
+ bfd_boolean mark_used)
{
etree_value_type result;
- result = exp_fold_tree (tree->trinary.cond, current_section,
- allocation_done, dot, dotp);
+ result = exp_fold_tree_1 (tree->trinary.cond, current_section,
+ allocation_done, dot, dotp, mark_used);
if (result.valid_p)
- result = exp_fold_tree ((result.value
- ? tree->trinary.lhs
- : tree->trinary.rhs),
- current_section,
- allocation_done, dot, dotp);
+ result = exp_fold_tree_1 ((result.value
+ ? tree->trinary.lhs
+ : tree->trinary.rhs),
+ current_section,
+ allocation_done,
+ dot, dotp, mark_used);
return result;
}
fold_name (etree_type *tree,
lang_output_section_statement_type *current_section,
lang_phase_type allocation_done,
- bfd_vma dot)
+ bfd_vma dot,
+ bfd_boolean mark_used)
{
etree_value_type result;
+ h->u.def.section->output_offset),
NULL,
os);
+ os->bfd_section->flags |= SEC_KEEP;
}
}
}
lang_output_section_statement_type *os;
os = lang_output_section_find (tree->name.name);
- if (os && os->processed > 0)
- result = new_rel (0, NULL, os);
+ if (os)
+ {
+ os->bfd_section->flags |= SEC_KEEP;
+ if (os->processed > 0)
+ result = new_rel (0, NULL, os);
+ }
}
break;
lang_output_section_statement_type *os;
os = lang_output_section_find (tree->name.name);
- if (os && os->processed != 0)
+ if (os)
{
- if (os->load_base == NULL)
- result = new_rel (0, NULL, os);
- else
- result = exp_fold_tree_no_dot (os->load_base,
- abs_output_section,
- allocation_done);
+ os->bfd_section->flags |= SEC_KEEP;
+ if (os->processed != 0)
+ {
+ if (os->load_base == NULL)
+ result = new_rel (0, NULL, os);
+ else
+ result = exp_fold_tree_no_dot (os->load_base,
+ abs_output_section,
+ allocation_done,
+ mark_used);
+ }
}
}
break;
lang_output_section_statement_type *os;
os = lang_output_section_find (tree->name.name);
- if (os && os->processed > 0)
- result = new_abs (os->bfd_section->size / opb);
+ if (os)
+ {
+ os->bfd_section->flags |= SEC_KEEP;
+ if (os->processed > 0)
+ result = new_abs (os->bfd_section->size / opb);
+ }
}
break;
return result;
}
-etree_value_type
-exp_fold_tree (etree_type *tree,
- lang_output_section_statement_type *current_section,
- lang_phase_type allocation_done,
- bfd_vma dot,
- bfd_vma *dotp)
+static etree_value_type
+exp_fold_tree_1 (etree_type *tree,
+ lang_output_section_statement_type *current_section,
+ lang_phase_type allocation_done,
+ bfd_vma dot,
+ bfd_vma *dotp,
+ bfd_boolean mark_used)
{
etree_value_type result;
break;
case etree_assert:
- result = exp_fold_tree (tree->assert_s.child,
- current_section,
- allocation_done, dot, dotp);
- if (result.valid_p && !result.value)
- einfo ("%X%P: %s\n", tree->assert_s.message);
+ result = exp_fold_tree_1 (tree->assert_s.child,
+ current_section,
+ allocation_done, dot, dotp,
+ mark_used);
+ if (result.valid_p)
+ {
+ if (mark_used)
+ /* We don't care if assert fails or not when we are just
+ marking if a section is used or not. */
+ result.value = 1;
+ else if (!result.value)
+ einfo ("%X%P: %s\n", tree->assert_s.message);
+ }
break;
case etree_unary:
result = fold_unary (tree, current_section, allocation_done,
- dot, dotp);
+ dot, dotp, mark_used);
break;
case etree_binary:
result = fold_binary (tree, current_section, allocation_done,
- dot, dotp);
+ dot, dotp, mark_used);
break;
case etree_trinary:
result = fold_trinary (tree, current_section, allocation_done,
- dot, dotp);
+ dot, dotp, mark_used);
break;
case etree_assign:
{
/* Notify the folder that this is an assignment to dot. */
assigning_to_dot = TRUE;
- result = exp_fold_tree (tree->assign.src,
- current_section,
- allocation_done, dot, dotp);
+ result = exp_fold_tree_1 (tree->assign.src,
+ current_section,
+ allocation_done,
+ dot, dotp, mark_used);
assigning_to_dot = FALSE;
if (! result.valid_p)
}
else
{
- result = exp_fold_tree (tree->assign.src,
- current_section, allocation_done,
- dot, dotp);
+ result = exp_fold_tree_1 (tree->assign.src,
+ current_section, allocation_done,
+ dot, dotp, mark_used);
if (result.valid_p)
{
bfd_boolean create;
break;
case etree_name:
- result = fold_name (tree, current_section, allocation_done, dot);
+ result = fold_name (tree, current_section, allocation_done, dot,
+ mark_used);
break;
default:
return result;
}
+etree_value_type
+exp_fold_tree (etree_type *tree,
+ lang_output_section_statement_type *current_section,
+ lang_phase_type allocation_done,
+ bfd_vma dot,
+ bfd_vma *dotp)
+{
+ return exp_fold_tree_1 (tree, current_section, allocation_done,
+ dot, dotp, FALSE);
+}
+
static etree_value_type
exp_fold_tree_no_dot (etree_type *tree,
lang_output_section_statement_type *current_section,
- lang_phase_type allocation_done)
+ lang_phase_type allocation_done,
+ bfd_boolean mark_used)
{
- return exp_fold_tree (tree, current_section, allocation_done, 0, NULL);
+ return exp_fold_tree_1 (tree, current_section, allocation_done, 0,
+ NULL, mark_used);
}
etree_type *
value.type.node_class = etree_binary;
r = exp_fold_tree_no_dot (&value,
abs_output_section,
- lang_first_phase_enum);
+ lang_first_phase_enum, FALSE);
if (r.valid_p)
{
return exp_intop (r.value);
value.trinary.cond = cond;
value.trinary.rhs = rhs;
value.type.node_class = etree_trinary;
- r = exp_fold_tree_no_dot (&value, NULL, lang_first_phase_enum);
+ r = exp_fold_tree_no_dot (&value, NULL, lang_first_phase_enum, FALSE);
if (r.valid_p)
return exp_intop (r.value);
value.unary.child = child;
value.unary.type.node_class = etree_unary;
r = exp_fold_tree_no_dot (&value, abs_output_section,
- lang_first_phase_enum);
+ lang_first_phase_enum, FALSE);
if (r.valid_p)
return exp_intop (r.value);
value.name.name = name;
value.name.type.node_class = etree_name;
- r = exp_fold_tree_no_dot (&value, NULL, lang_first_phase_enum);
+ r = exp_fold_tree_no_dot (&value, NULL, lang_first_phase_enum, FALSE);
if (r.valid_p)
return exp_intop (r.value);
if (tree != NULL)
{
- r = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
+ r = exp_fold_tree_no_dot (tree, abs_output_section,
+ allocation_done, FALSE);
if (! r.valid_p && name != NULL)
einfo (_("%F%S nonconstant expression for %s\n"), name);
return r.value;
if (tree == NULL)
return def;
- r = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
+ r = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done,
+ FALSE);
if (! r.valid_p && name != NULL)
einfo (_("%F%S nonconstant expression for %s\n"), name);
lang_phase_type allocation_done)
{
etree_value_type res;
- res = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
+ res = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done,
+ FALSE);
if (res.valid_p)
res.value += res.section->bfd_section->vma;
value = (value + align - 1) / align;
return value * align;
}
+
+void
+exp_mark_used_section
+ (etree_type *tree,
+ lang_output_section_statement_type *current_section)
+{
+ switch (tree->type.node_class)
+ {
+ case etree_value:
+ break;
+
+ case etree_rel:
+ break;
+
+ case etree_assert:
+ break;
+
+ case etree_unary:
+ break;
+
+ case etree_binary:
+ break;
+
+ case etree_trinary:
+ break;
+
+ case etree_assign:
+ case etree_provide:
+ case etree_provided:
+ if (tree->assign.dst[0] != '.' || tree->assign.dst[1] != 0)
+ {
+ etree_value_type result;
+ bfd_vma dot = 0;
+
+ result = exp_fold_tree_1 (tree->assign.src,
+ current_section,
+ lang_allocating_phase_enum,
+ dot, &dot, TRUE);
+ if (result.valid_p)
+ {
+ bfd_boolean create;
+ struct bfd_link_hash_entry *h;
+
+ if (tree->type.node_class == etree_assign)
+ create = TRUE;
+ else
+ create = FALSE;
+ h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
+ create, FALSE, TRUE);
+ if (h == NULL)
+ {
+ if (create)
+ einfo (_("%P%F:%s: hash creation failed\n"),
+ tree->assign.dst);
+ }
+ else if (tree->type.node_class == etree_provide
+ && h->type != bfd_link_hash_new
+ && h->type != bfd_link_hash_undefined
+ && h->type != bfd_link_hash_common)
+ {
+ /* Do nothing. The symbol was defined by some
+ object. */
+ }
+ else
+ {
+ /* FIXME: Should we worry if the symbol is already
+ defined? */
+ lang_update_definedness (tree->assign.dst, h);
+ h->type = bfd_link_hash_defined;
+ h->u.def.value = result.value;
+ h->u.def.section = result.section->bfd_section;
+ if (tree->type.node_class == etree_provide)
+ tree->type.node_class = etree_provided;
+ }
+ }
+ }
+ break;
+
+ case etree_name:
+ fold_name (tree, current_section, lang_allocating_phase_enum, 0,
+ TRUE);
+ break;
+
+ default:
+ abort ();
+ break;
+ }
+}
lookup->bfd_section = NULL;
lookup->processed = 0;
lookup->constraint = constraint;
+ lookup->ignored = FALSE;
lookup->sectype = normal_section;
lookup->addr_tree = NULL;
lang_list_init (&lookup->children);
}
}
+/* Worker function for lang_mark_used_section. Recursiveness goes
+ here. */
+
+static void
+lang_mark_used_section_1
+ (lang_statement_union_type *s,
+ lang_output_section_statement_type *output_section_statement)
+{
+ for (; s != NULL; s = s->header.next)
+ {
+ switch (s->header.type)
+ {
+ case lang_constructors_statement_enum:
+ break;
+
+ case lang_output_section_statement_enum:
+ {
+ lang_output_section_statement_type *os;
+
+ os = &(s->output_section_statement);
+ if (os->bfd_section != NULL)
+ lang_mark_used_section_1 (os->children.head, os);
+ }
+ break;
+ case lang_wild_statement_enum:
+ lang_mark_used_section_1 (s->wild_statement.children.head,
+ output_section_statement);
+
+ break;
+
+ case lang_object_symbols_statement_enum:
+ case lang_output_statement_enum:
+ case lang_target_statement_enum:
+ break;
+ case lang_data_statement_enum:
+ exp_mark_used_section (s->data_statement.exp,
+ abs_output_section);
+ break;
+
+ case lang_reloc_statement_enum:
+ break;
+
+ case lang_input_section_enum:
+ break;
+
+ case lang_input_statement_enum:
+ break;
+ case lang_fill_statement_enum:
+ break;
+ case lang_assignment_statement_enum:
+ exp_mark_used_section (s->assignment_statement.exp,
+ output_section_statement);
+ break;
+ case lang_padding_statement_enum:
+ break;
+
+ case lang_group_statement_enum:
+ lang_mark_used_section_1 (s->group_statement.children.head,
+ output_section_statement);
+ break;
+
+ default:
+ FAIL ();
+ break;
+ case lang_address_statement_enum:
+ break;
+ }
+ }
+}
+
+static void
+lang_mark_used_section (void)
+{
+ unsigned int gc_sections = link_info.gc_sections;
+
+ /* Callers of exp_fold_tree need to increment this. */
+ lang_statement_iteration++;
+ lang_mark_used_section_1 (statement_list.head, abs_output_section);
+
+ link_info.gc_sections = 0;
+ bfd_gc_sections (output_bfd, &link_info);
+ link_info.gc_sections = gc_sections;
+}
+
/* An output section might have been removed after its statement was
added. For example, ldemul_before_allocation can remove dynamic
sections if they turn out to be not needed. Clean them up here. */
{
lang_output_section_statement_type *os;
+ lang_mark_used_section ();
+
for (os = &lang_output_section_statement.head->output_section_statement;
os != NULL;
os = os->next)
{
- asection *s;
+ asection *output_section;
+ bfd_boolean exclude;
if (os->constraint == -1)
continue;
- if (os->bfd_section == NULL || os->bfd_section->map_head.s == NULL)
+ output_section = os->bfd_section;
+ if (output_section == NULL)
continue;
- for (s = os->bfd_section->map_head.s; s != NULL; s = s->map_head.s)
- if ((s->flags & SEC_EXCLUDE) == 0)
- break;
+ exclude = FALSE;
+ if (output_section->map_head.s != NULL)
+ {
+ asection *s;
- os->bfd_section->map_head.link_order = NULL;
- os->bfd_section->map_tail.link_order = NULL;
+ for (s = output_section->map_head.s; s != NULL;
+ s = s->map_head.s)
+ if ((s->flags & SEC_EXCLUDE) == 0)
+ break;
+
+ output_section->map_head.link_order = NULL;
+ output_section->map_tail.link_order = NULL;
+
+ if (s == NULL)
+ exclude = TRUE;
+ }
- if (s == NULL)
+ if (exclude
+ || (output_section->linker_has_input == 0
+ && ((output_section->flags
+ & (SEC_KEEP | SEC_HAS_CONTENTS)) == 0)))
{
- s = os->bfd_section;
- os->bfd_section = NULL;
- if (!bfd_section_removed_from_list (output_bfd, s))
+ if (exclude)
+ os->bfd_section = NULL;
+ else
+ /* We don't set bfd_section to NULL since bfd_section of the
+ * removed output section statement may still be used. */
+ os->ignored = TRUE;
+ if (!bfd_section_removed_from_list (output_bfd,
+ output_section))
{
- bfd_section_list_remove (output_bfd, s);
+ bfd_section_list_remove (output_bfd, output_section);
output_bfd->section_count--;
}
}
lang_output_section_statement_type *os;
os = &s->output_section_statement;
- if (os->bfd_section == NULL)
- /* This section was never actually created. */
+ if (os->bfd_section == NULL || os->ignored)
+ /* This section was removed or never actually created. */
break;
/* If this is a COFF shared library section, use the size and
lang_output_section_statement_type *os;
os = &(s->output_section_statement);
- if (os->bfd_section != NULL)
+ if (os->bfd_section != NULL && !os->ignored)
{
dot = os->bfd_section->vma;
lang_do_assignments_1 (os->children.head, os, os->fill, dot);
{
/* If nothing has been placed into the output section then
it won't have a bfd_section. */
- if (os->bfd_section)
+ if (os->bfd_section && !os->ignored)
{
os->bfd_section->lma
= exp_get_abs_int (os->load_base, 0, "load base",
bfd_gc_sections (output_bfd, &link_info);
}
-static void
-lang_mark_used_section (void)
-{
- unsigned int gc_sections = link_info.gc_sections;
-
- link_info.gc_sections = 0;
- bfd_gc_sections (output_bfd, &link_info);
- link_info.gc_sections = gc_sections;
-}
-
void
lang_process (void)
{
lang_check_section_addresses ();
/* Final stuffs. */
- lang_mark_used_section ();
ldemul_finish ();
lang_finish ();
}
projects / binutils-gdb.git / commitdiff