if (member->usrdata != NULL)
{
walk_wild_section (s,
- (lang_input_statement_type *) member->usrdata,
- callback, data);
+ (lang_input_statement_type *) member->usrdata,
+ callback, data);
}
member = bfd_openr_next_archived_file (f->the_bfd, member);
else
{
p = (lang_input_statement_type *)
- stat_alloc (sizeof (lang_input_statement_type));
+ stat_alloc (sizeof (lang_input_statement_type));
p->header.type = lang_input_statement_enum;
p->header.next = NULL;
}
if (entry == NULL)
{
entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,
- sizeof (*ret));
+ sizeof (*ret));
if (entry == NULL)
return entry;
}
for (r = lang_memory_region_list; r != NULL; r = r->next)
for (n = &r->name_list; n != NULL; n = n->next)
if (strcmp (n->name, name) == 0)
- {
- if (create)
- einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
- NULL, name);
- return r;
- }
+ {
+ if (create)
+ einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
+ NULL, name);
+ return r;
+ }
if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
for (r = lang_memory_region_list; r != NULL; r = r->next)
for (n = &r->name_list; n != NULL; n = n->next)
{
- if (region == NULL && strcmp (n->name, region_name) == 0)
- region = r;
- if (strcmp (n->name, alias) == 0)
- einfo (_("%F%P:%S: error: redefinition of memory region "
- "alias `%s'\n"),
- NULL, alias);
+ if (region == NULL && strcmp (n->name, region_name) == 0)
+ region = r;
+ if (strcmp (n->name, alias) == 0)
+ einfo (_("%F%P:%S: error: redefinition of memory region "
+ "alias `%s'\n"),
+ NULL, alias);
}
/* Check if the target region exists. */
if (region == NULL)
einfo (_("%F%P:%S: error: memory region `%s' "
- "for alias `%s' does not exist\n"),
- NULL, region_name, alias);
+ "for alias `%s' does not exist\n"),
+ NULL, region_name, alias);
/* Add alias to region name list. */
n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));
os_tail = ((lang_output_section_statement_type **)
lang_output_section_statement.tail);
os = lang_enter_output_section_statement (secname, address, normal_section,
- NULL, NULL, NULL, constraint);
+ NULL, NULL, NULL, constraint);
ps = NULL;
if (config.build_constructors && *os_tail == os)
struct map_symbol_def *def;
ud = (struct fat_user_section_struct *)
- get_userdata (hash_entry->u.def.section);
+ get_userdata (hash_entry->u.def.section);
if (! ud)
{
/* ??? What do we have to do to initialize this beforehand? */
/* The first time we get here is bfd_abs_section... */
init_map_userdata (0, hash_entry->u.def.section, 0);
ud = (struct fat_user_section_struct *)
- get_userdata (hash_entry->u.def.section);
+ get_userdata (hash_entry->u.def.section);
}
else if (!ud->map_symbol_def_tail)
ud->map_symbol_def_tail = &ud->map_symbol_def_head;
if (!link_info.reduce_memory_overheads)
{
fat_section_userdata_type *new_userdata = (fat_section_userdata_type *)
- stat_alloc (sizeof (fat_section_userdata_type));
+ stat_alloc (sizeof (fat_section_userdata_type));
memset (new_userdata, 0, sizeof (fat_section_userdata_type));
get_userdata (s->bfd_section) = new_userdata;
}
keep = bfd_lookup_section_flags (&link_info, sflag_info, section);
if (!keep)
- return;
+ return;
}
if (section->output_section != NULL)
output_section_statement);
}
-/* Scan for the use of the destination in the right hand side
- of an expression. In such cases we will not compute the
- correct expression, since the value of DST that is used on
- the right hand side will be its final value, not its value
- just before this expression is evaluated. */
-
-static bfd_boolean
-scan_for_self_assignment (const char * dst, etree_type * rhs)
-{
- if (rhs == NULL || dst == NULL)
- return FALSE;
-
- switch (rhs->type.node_class)
- {
- case etree_binary:
- return (scan_for_self_assignment (dst, rhs->binary.lhs)
- || scan_for_self_assignment (dst, rhs->binary.rhs));
-
- case etree_trinary:
- return (scan_for_self_assignment (dst, rhs->trinary.lhs)
- || scan_for_self_assignment (dst, rhs->trinary.rhs));
-
- case etree_assign:
- case etree_provided:
- case etree_provide:
- if (strcmp (dst, rhs->assign.dst) == 0)
- return TRUE;
- return scan_for_self_assignment (dst, rhs->assign.src);
-
- case etree_unary:
- return scan_for_self_assignment (dst, rhs->unary.child);
-
- case etree_value:
- if (rhs->value.str)
- return strcmp (dst, rhs->value.str) == 0;
- return FALSE;
-
- case etree_name:
- if (rhs->name.name)
- return strcmp (dst, rhs->name.name) == 0;
- return FALSE;
-
- default:
- break;
- }
-
- return FALSE;
-}
-
-
static void
print_assignment (lang_assignment_statement_type *assignment,
lang_output_section_statement_type *output_section)
{
unsigned int i;
bfd_boolean is_dot;
- bfd_boolean computation_is_valid = TRUE;
etree_type *tree;
asection *osec;
{
is_dot = FALSE;
tree = assignment->exp->assert_s.child;
- computation_is_valid = TRUE;
}
else
{
const char *dst = assignment->exp->assign.dst;
is_dot = (dst[0] == '.' && dst[1] == 0);
+ expld.assign_name = dst;
tree = assignment->exp->assign.src;
- computation_is_valid = is_dot || !scan_for_self_assignment (dst, tree);
}
osec = output_section->bfd_section;
{
bfd_vma value;
- if (computation_is_valid)
+ if (assignment->exp->type.node_class == etree_assert
+ || is_dot
+ || expld.assign_name != NULL)
{
value = expld.result.value;
minfo (" ");
#endif
}
+ expld.assign_name = NULL;
minfo (" ");
exp_print_tree (assignment->exp);
entries[i] = def->entry;
qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
- hash_entry_addr_cmp);
+ hash_entry_addr_cmp);
/* Print the symbols. */
for (i = 0; i < ud->map_symbol_def_count; i++)
{
/* Make a new padding statement, linked into existing chain. */
pad = (lang_statement_union_type *)
- stat_alloc (sizeof (lang_padding_statement_type));
+ stat_alloc (sizeof (lang_padding_statement_type));
pad->header.next = *ptr;
*ptr = pad;
pad->header.type = lang_padding_statement_enum;
if (current_section == NULL || previous_section == NULL)
return new_segment;
+ /* If this flag is set, the target never wants code and non-code
+ sections comingled in the same segment. */
+ if (config.separate_code
+ && ((current_section->flags ^ previous_section->flags) & SEC_CODE))
+ return TRUE;
+
/* Find the memory regions associated with the two sections.
We call lang_output_section_find() here rather than scanning the list
of output sections looking for a matching section pointer because if
{
alc *= 2;
secs = (asection **) xrealloc (secs,
- alc * sizeof (asection *));
+ alc * sizeof (asection *));
}
secs[c] = os->bfd_section;
++c;
{
e.pattern = c_sym;
expr = (struct bfd_elf_version_expr *)
- htab_find ((htab_t) head->htab, &e);
+ htab_find ((htab_t) head->htab, &e);
while (expr && strcmp (expr->pattern, c_sym) == 0)
if (expr->mask == BFD_ELF_VERSION_C_TYPE)
goto out_ret;
{
e.pattern = cxx_sym;
expr = (struct bfd_elf_version_expr *)
- htab_find ((htab_t) head->htab, &e);
+ htab_find ((htab_t) head->htab, &e);
while (expr && strcmp (expr->pattern, cxx_sym) == 0)
if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
goto out_ret;
{
e.pattern = java_sym;
expr = (struct bfd_elf_version_expr *)
- htab_find ((htab_t) head->htab, &e);
+ htab_find ((htab_t) head->htab, &e);
while (expr && strcmp (expr->pattern, java_sym) == 0)
if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
goto out_ret;
if (t->locals.htab && e1->literal)
{
e2 = (struct bfd_elf_version_expr *)
- htab_find ((htab_t) t->locals.htab, e1);
+ htab_find ((htab_t) t->locals.htab, e1);
while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
{
if (e1->mask == e2->mask)
if (t->globals.htab && e1->literal)
{
e2 = (struct bfd_elf_version_expr *)
- htab_find ((htab_t) t->globals.htab, e1);
+ htab_find ((htab_t) t->globals.htab, e1);
while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
{
if (e1->mask == e2->mask)