/* Locals variables. */
static struct obstack stat_obstack;
+static struct obstack map_obstack;
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
/* Forward declarations. */
static void exp_init_os (etree_type *);
+static void init_map_userdata (bfd *, asection *, void *);
static bfd_boolean wildcardp (const char *);
static lang_input_statement_type *lookup_name (const char *);
static bfd_boolean load_symbols (lang_input_statement_type *,
static struct bfd_hash_entry *lang_definedness_newfunc
(struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
static void insert_undefined (const char *);
+static void print_all_symbols (asection *);
+static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
static void print_statement (lang_statement_union_type *,
lang_output_section_statement_type *);
static void print_statement_list (lang_statement_union_type *,
break;
case lang_output_section_statement_enum:
lang_for_each_statement_worker
- (func,
- s->output_section_statement.children.head);
+ (func, s->output_section_statement.children.head);
break;
case lang_wild_statement_enum:
- lang_for_each_statement_worker
- (func,
- s->wild_statement.children.head);
+ lang_for_each_statement_worker (func,
+ s->wild_statement.children.head);
break;
case lang_group_statement_enum:
lang_for_each_statement_worker (func,
and so we issue a warning. */
static lang_memory_region_type *lang_memory_region_list;
-static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
+static lang_memory_region_type **lang_memory_region_list_tail
+ = &lang_memory_region_list;
lang_memory_region_type *
lang_memory_region_lookup (const char *const name, bfd_boolean create)
if (strcmp (p->name, name) == 0)
{
if (create)
- einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"), name);
+ einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
+ name);
return p;
}
return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
}
-lang_output_section_statement_type *
-lang_output_section_find (const char *const name)
+static lang_output_section_statement_type *
+lang_output_section_find_1 (const char *const name, int constraint)
{
lang_statement_union_type *u;
lang_output_section_statement_type *lookup;
for (u = lang_output_section_statement.head; u != NULL; u = lookup->next)
{
lookup = &u->output_section_statement;
- if (strcmp (name, lookup->name) == 0)
+ if (strcmp (name, lookup->name) == 0
+ && lookup->constraint != -1
+ && (constraint == 0 || constraint == lookup->constraint))
return lookup;
}
return NULL;
}
lang_output_section_statement_type *
-lang_output_section_statement_lookup (const char *const name)
+lang_output_section_find (const char *const name)
+{
+ return lang_output_section_find_1 (name, 0);
+}
+
+static lang_output_section_statement_type *
+lang_output_section_statement_lookup_1 (const char *const name, int constraint)
{
lang_output_section_statement_type *lookup;
- lookup = lang_output_section_find (name);
+ lookup = lang_output_section_find_1 (name, constraint);
if (lookup == NULL)
{
lookup = new_stat (lang_output_section_statement, stat_ptr);
lookup->next = NULL;
lookup->bfd_section = NULL;
lookup->processed = 0;
+ lookup->constraint = constraint;
lookup->sectype = normal_section;
lookup->addr_tree = NULL;
lang_list_init (&lookup->children);
return lookup;
}
+lang_output_section_statement_type *
+lang_output_section_statement_lookup (const char *const name)
+{
+ return lang_output_section_statement_lookup_1 (name, 0);
+}
+
static void
lang_map_flags (flagword flag)
{
lang_map (void)
{
lang_memory_region_type *m;
+ bfd *p;
minfo (_("\nMemory Configuration\n\n"));
fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
+ if (! command_line.reduce_memory_overheads)
+ {
+ obstack_begin (&map_obstack, 1000);
+ for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
+ bfd_map_over_sections (p, init_map_userdata, 0);
+ bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
+ }
print_statements ();
}
+static void
+init_map_userdata (abfd, sec, data)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec;
+ void *data ATTRIBUTE_UNUSED;
+{
+ fat_section_userdata_type *new_data
+ = ((fat_section_userdata_type *) (stat_alloc
+ (sizeof (fat_section_userdata_type))));
+
+ ASSERT (get_userdata (sec) == NULL);
+ get_userdata (sec) = new_data;
+ new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
+}
+
+static bfd_boolean
+sort_def_symbol (hash_entry, info)
+ struct bfd_link_hash_entry *hash_entry;
+ void *info ATTRIBUTE_UNUSED;
+{
+ if (hash_entry->type == bfd_link_hash_defined
+ || hash_entry->type == bfd_link_hash_defweak)
+ {
+ struct fat_user_section_struct *ud;
+ struct map_symbol_def *def;
+
+ ud = 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 = get_userdata (hash_entry->u.def.section);
+ }
+ else if (!ud->map_symbol_def_tail)
+ ud->map_symbol_def_tail = &ud->map_symbol_def_head;
+ def = obstack_alloc (&map_obstack, sizeof *def);
+ def->entry = hash_entry;
+ *ud->map_symbol_def_tail = def;
+ ud->map_symbol_def_tail = &def->next;
+ }
+ return TRUE;
+}
+
/* Initialize an output section. */
static void
init_os (lang_output_section_statement_type *s)
{
- section_userdata_type *new;
+ lean_section_userdata_type *new;
if (s->bfd_section != NULL)
return;
if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
- new = stat_alloc (sizeof (section_userdata_type));
+ new = stat_alloc (SECTION_USERDATA_SIZE);
s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
if (s->bfd_section == NULL)
return;
}
- flags = bfd_get_section_flags (abfd, sec);
-
+ flags = sec->flags;
if ((flags & SEC_LINK_ONCE) == 0)
return;
einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
abfd, name);
else
- einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
+ einfo (_("%P: %B: warning: ignoring duplicate `%s'"
+ " section symbol `%s'\n"),
abfd, name, sec->comdat->name);
break;
case SEC_LINK_DUPLICATES_SAME_SIZE:
if (bfd_section_size (abfd, sec)
!= bfd_section_size (l->sec->owner, l->sec))
- einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
+ einfo (_("%P: %B: warning: duplicate section `%s'"
+ " has different size\n"),
abfd, name);
break;
}
lang_output_section_statement_type *output,
lang_input_statement_type *file)
{
- flagword flags;
+ flagword flags = section->flags;
bfd_boolean discard;
- flags = bfd_get_section_flags (section->owner, section);
-
- discard = FALSE;
-
- /* Discard sections marked with SEC_EXCLUDE if we are doing a final
- link. Discard debugging sections marked with SEC_EXCLUDE on a
- relocatable link too. */
- if ((flags & SEC_EXCLUDE) != 0
- && ((flags & SEC_DEBUGGING) != 0 || !link_info.relocatable))
- discard = TRUE;
+ /* Discard sections marked with SEC_EXCLUDE. */
+ discard = (flags & SEC_EXCLUDE) != 0;
/* Discard input sections which are assigned to a section named
DISCARD_SECTION_NAME. */
if (unique_section_p (section))
return;
- /* If the wild pattern was marked KEEP, the member sections
- should be as well. */
- if (ptr->keep_sections)
- section->flags |= SEC_KEEP;
-
before = wild_sort (ptr, sec, file, section);
/* Here BEFORE points to the lang_input_section which
}
}
+/* Check if all sections in a wild statement for a particular FILE
+ are readonly. */
+
+static void
+check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
+ struct wildcard_list *sec ATTRIBUTE_UNUSED,
+ asection *section,
+ lang_input_statement_type *file ATTRIBUTE_UNUSED,
+ void *data)
+{
+ /* Exclude sections that match UNIQUE_SECTION_LIST. */
+ if (unique_section_p (section))
+ return;
+
+ if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
+ ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
+}
+
/* This is passed a file name which must have been seen already and
added to the statement tree. We will see if it has been opened
already and had its symbols read. If not then we'll read it. */
}
if (search == NULL)
- search = new_afile (name, lang_input_file_is_search_file_enum, default_target,
- FALSE);
+ search = new_afile (name, lang_input_file_is_search_file_enum,
+ default_target, FALSE);
/* If we have already added this file, or this file is not real
(FIXME: can that ever actually happen?) or the name is NULL
/* Oh dear - we could not find any targets that
satisfy our requirements. */
if (winner == NULL)
- einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
+ einfo (_("%P: warning: could not find any targets"
+ " that match endianness requirement\n"));
else
output_target = winner->name;
}
insert_undefined (ptr->name);
}
+/* Check for all readonly or some readwrite sections. */
+
+static void
+check_input_sections
+ (lang_statement_union_type *s,
+ lang_output_section_statement_type *output_section_statement)
+{
+ for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
+ {
+ switch (s->header.type)
+ {
+ case lang_wild_statement_enum:
+ walk_wild (&s->wild_statement, check_section_callback,
+ output_section_statement);
+ if (! output_section_statement->all_input_readonly)
+ return;
+ break;
+ case lang_constructors_statement_enum:
+ check_input_sections (constructor_list.head,
+ output_section_statement);
+ if (! output_section_statement->all_input_readonly)
+ return;
+ break;
+ case lang_group_statement_enum:
+ check_input_sections (s->group_statement.children.head,
+ output_section_statement);
+ if (! output_section_statement->all_input_readonly)
+ return;
+ break;
+ default:
+ break;
+ }
+ }
+}
+
/* Open input files and attach to output sections. */
static void
output_section_statement);
break;
case lang_output_section_statement_enum:
+ if (s->output_section_statement.constraint)
+ {
+ if (s->output_section_statement.constraint == -1)
+ break;
+ s->output_section_statement.all_input_readonly = TRUE;
+ check_input_sections (s->output_section_statement.children.head,
+ &s->output_section_statement);
+ if ((s->output_section_statement.all_input_readonly
+ && s->output_section_statement.constraint == ONLY_IF_RW)
+ || (!s->output_section_statement.all_input_readonly
+ && s->output_section_statement.constraint == ONLY_IF_RO))
+ {
+ s->output_section_statement.constraint = -1;
+ break;
+ }
+ }
+
map_input_to_output_sections (s->output_section_statement.children.head,
target,
&s->output_section_statement);
asection *s;
os = &u->output_section_statement;
+ if (os->constraint == -1)
+ continue;
s = os->bfd_section;
if (s != NULL && (s->flags & SEC_EXCLUDE) != 0)
{
}
/* Print all symbols defined in a particular section. This is called
- via bfd_link_hash_traverse. */
+ via bfd_link_hash_traverse, or by print_all_symbols. */
static bfd_boolean
print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
return TRUE;
}
+static void
+print_all_symbols (sec)
+ asection *sec;
+{
+ struct fat_user_section_struct *ud = get_userdata (sec);
+ struct map_symbol_def *def;
+
+ *ud->map_symbol_def_tail = 0;
+ for (def = ud->map_symbol_def_head; def; def = def->next)
+ print_one_symbol (def->entry, sec);
+}
+
/* Print information about an input section to the map file. */
static void
init_opb ();
if (size != 0)
{
- print_space ();
+ int len;
+ bfd_vma addr;
+ print_space ();
minfo ("%s", i->name);
- if (i->output_section != NULL)
+ len = 1 + strlen (i->name);
+ if (len >= SECTION_NAME_MAP_LENGTH - 1)
+ {
+ print_nl ();
+ len = 0;
+ }
+ while (len < SECTION_NAME_MAP_LENGTH)
{
- int len;
+ print_space ();
+ ++len;
+ }
- len = 1 + strlen (i->name);
- if (len >= SECTION_NAME_MAP_LENGTH - 1)
- {
- print_nl ();
- len = 0;
- }
- while (len < SECTION_NAME_MAP_LENGTH)
- {
- print_space ();
- ++len;
- }
+ if (i->output_section != NULL && (i->flags & SEC_EXCLUDE) == 0)
+ addr = i->output_section->vma + i->output_offset;
+ else
+ {
+ addr = print_dot;
+ size = 0;
+ }
- minfo ("0x%V %W %B\n",
- i->output_section->vma + i->output_offset, TO_ADDR (size),
- i->owner);
+ minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
- if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
- {
- len = SECTION_NAME_MAP_LENGTH + 3;
+ if (size != i->_raw_size)
+ {
+ len = SECTION_NAME_MAP_LENGTH + 3;
#ifdef BFD64
- len += 16;
+ len += 16;
#else
- len += 8;
+ len += 8;
#endif
- while (len > 0)
- {
- print_space ();
- --len;
- }
-
- minfo (_("%W (size before relaxing)\n"), i->_raw_size);
+ while (len > 0)
+ {
+ print_space ();
+ --len;
}
- bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
+ minfo (_("%W (size before relaxing)\n"), i->_raw_size);
+ }
- print_dot = (i->output_section->vma + i->output_offset
- + TO_ADDR (size));
+ if (i->output_section != NULL && (i->flags & SEC_EXCLUDE) == 0)
+ {
+ if (command_line.reduce_memory_overheads)
+ bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
+ else
+ print_all_symbols (i);
+
+ print_dot = addr + TO_ADDR (size);
}
}
}
addr = s->output_offset;
if (s->output_section != NULL)
addr += s->output_section->vma;
- minfo ("0x%V %W ", addr, s->size);
+ minfo ("0x%V %W ", addr, (bfd_vma) s->size);
if (s->fill->size != 0)
{
/* Work out how much this section will move the dot point. */
static bfd_vma
-size_input_section (lang_statement_union_type **this_ptr,
- lang_output_section_statement_type *output_section_statement,
- fill_type *fill,
- bfd_vma dot)
+size_input_section
+ (lang_statement_union_type **this_ptr,
+ lang_output_section_statement_type *output_section_statement,
+ fill_type *fill,
+ bfd_vma dot)
{
lang_input_section_type *is = &((*this_ptr)->input_section);
asection *i = is->section;
- if (!is->ifile->just_syms_flag)
+ if (!is->ifile->just_syms_flag && (i->flags & SEC_EXCLUDE) == 0)
{
unsigned int alignment_needed;
asection *o;
}
#define IGNORE_SECTION(bfd, s) \
- (((bfd_get_section_flags (bfd, s) & SEC_THREAD_LOCAL) \
- ? ((bfd_get_section_flags (bfd, s) & (SEC_LOAD | SEC_NEVER_LOAD)) \
- != SEC_LOAD) \
- : ((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_NEVER_LOAD)) \
- != SEC_ALLOC)) \
+ (((s->flags & SEC_THREAD_LOCAL) != 0 \
+ ? (s->flags & (SEC_LOAD | SEC_NEVER_LOAD)) != SEC_LOAD \
+ : (s->flags & (SEC_ALLOC | SEC_NEVER_LOAD)) != SEC_ALLOC) \
|| bfd_section_size (bfd, s) == 0)
/* Check to see if any allocated sections overlap with other allocated
{
if (tree != NULL)
{
- einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
+ einfo (_("%X%P: address 0x%v of %B section %s"
+ " is not within region %s\n"),
region->current,
os->bfd_section->owner,
os->bfd_section->name,
if (os->children.head == NULL
|| os->children.head->header.next != NULL
- || os->children.head->header.type != lang_input_section_enum)
- einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
- os->name);
+ || (os->children.head->header.type
+ != lang_input_section_enum))
+ einfo (_("%P%X: Internal error on COFF shared library"
+ " section %s\n"), os->name);
input = os->children.head->input_section.section;
bfd_set_section_vma (os->bfd_section->owner,
/* No address specified for this section, get one
from the region specification. */
if (os->region == NULL
- || (((bfd_get_section_flags (output_bfd, os->bfd_section)
- & (SEC_ALLOC | SEC_LOAD)) != 0)
+ || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
&& os->region->name[0] == '*'
- && strcmp (os->region->name, DEFAULT_MEMORY_REGION) == 0))
+ && strcmp (os->region->name,
+ DEFAULT_MEMORY_REGION) == 0))
{
os->region = lang_memory_default (os->bfd_section);
}
if (!IGNORE_SECTION (output_bfd, os->bfd_section)
&& ! link_info.relocatable
&& check_regions
- && strcmp (os->region->name, DEFAULT_MEMORY_REGION) == 0
+ && strcmp (os->region->name,
+ DEFAULT_MEMORY_REGION) == 0
&& lang_memory_region_list != NULL
&& (strcmp (lang_memory_region_list->name,
DEFAULT_MEMORY_REGION) != 0
default memory region we can end up creating an
excessively large binary, or even seg faulting when
attempting to perform a negative seek. See
- http://sources.redhat.com/ml/binutils/2003-04/msg00423.html
+ sources.redhat.com/ml/binutils/2003-04/msg00423.html
for an example of this. This behaviour can be
overridden by the using the --no-check-sections
switch. */
if (command_line.check_section_addresses)
- einfo (_("%P%F: error: no memory region specified for loadable section `%s'\n"),
+ einfo (_("%P%F: error: no memory region specified"
+ " for loadable section `%s'\n"),
bfd_get_section_name (output_bfd,
os->bfd_section));
else
- einfo (_("%P: warning: no memory region specified for loadable section `%s'\n"),
+ einfo (_("%P: warning: no memory region specified"
+ " for loadable section `%s'\n"),
bfd_get_section_name (output_bfd,
os->bfd_section));
}
os->bfd_section->alignment_power);
if (dot != olddot && config.warn_section_align)
- einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
+ einfo (_("%P: warning: changing start of section"
+ " %s by %u bytes\n"),
os->name, (unsigned int) (dot - olddot));
}
}
os->processed = 0;
if (!r.valid_p)
- einfo (_("%F%S: non constant or forward reference address expression for section %s\n"),
+ einfo (_("%F%S: non constant or forward reference"
+ " address expression for section %s\n"),
os->name);
dot = r.value + r.section->bfd_section->vma;
addresses of sections after it. We have to update
dot. */
if (os->region != NULL
- && ((bfd_get_section_flags (output_bfd, os->bfd_section)
- & SEC_NEVER_LOAD) == 0
- || (bfd_get_section_flags (output_bfd, os->bfd_section)
- & (SEC_ALLOC | SEC_LOAD))))
+ && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
+ || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
{
os->region->current = dot;
{
/* If we don't have an output section, then just adjust
the default memory address. */
- lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE)->current = newdot;
+ lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
+ FALSE)->current = newdot;
}
else
{
/* If dot is advanced, this implies that the section should
have space allocated to it, unless the user has explicitly
stated that the section should never be loaded. */
- if (!(output_section_statement->flags & (SEC_NEVER_LOAD | SEC_ALLOC)))
+ if (!(output_section_statement->flags
+ & (SEC_NEVER_LOAD | SEC_ALLOC)))
output_section_statement->bfd_section->flags |= SEC_ALLOC;
dot = newdot;
exp_data_seg.phase = exp_dataseg_none;
result = lang_size_sections_1 (s, output_section_statement, prev, fill,
dot, relax, check_regions);
- if (exp_data_seg.phase == exp_dataseg_end_seen)
+ if (exp_data_seg.phase == exp_dataseg_end_seen
+ && link_info.relro && exp_data_seg.relro_end)
+ {
+ /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
+ to put exp_data_seg.relro on a (common) page boundary. */
+
+ exp_data_seg.phase = exp_dataseg_relro_adjust;
+ result = lang_size_sections_1 (s, output_section_statement, prev, fill,
+ dot, relax, check_regions);
+ link_info.relro_start = exp_data_seg.base;
+ link_info.relro_end = exp_data_seg.relro_end;
+ }
+ else if (exp_data_seg.phase == exp_dataseg_end_seen)
{
/* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
a page could be saved in the data segment. */
{
asection *in = s->input_section.section;
- if (in->_cooked_size != 0)
- dot += TO_ADDR (in->_cooked_size);
- else
- dot += TO_ADDR (in->_raw_size);
+ if ((in->flags & SEC_EXCLUDE) == 0)
+ {
+ if (in->_cooked_size != 0)
+ dot += TO_ADDR (in->_cooked_size);
+ else
+ dot += TO_ADDR (in->_raw_size);
+ }
}
break;
}
void
-lang_do_assignments (lang_statement_union_type *s,
- lang_output_section_statement_type *output_section_statement,
- fill_type *fill,
- bfd_vma dot)
+lang_do_assignments
+ (lang_statement_union_type *s,
+ lang_output_section_statement_type *output_section_statement,
+ fill_type *fill,
+ bfd_vma dot)
{
/* Callers of exp_fold_tree need to increment this. */
lang_statement_iteration++;
if (ts != NULL)
{
if (warn)
- einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
+ einfo (_("%P: warning: cannot find entry symbol %s;"
+ " defaulting to %V\n"),
entry_symbol.name,
bfd_get_section_vma (output_bfd, ts));
if (! bfd_set_start_address (output_bfd,
else
{
if (warn)
- einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
+ einfo (_("%P: warning: cannot find entry symbol %s;"
+ " not setting start address\n"),
entry_symbol.name);
}
}
for (file = file_chain.head; file != NULL; file = file->input_statement.next)
{
input_bfd = file->input_statement.the_bfd;
- compatible = bfd_arch_get_compatible (input_bfd, output_bfd,
- command_line.accept_unknown_input_arch);
+ compatible
+ = bfd_arch_get_compatible (input_bfd, output_bfd,
+ command_line.accept_unknown_input_arch);
/* In general it is not possible to perform a relocatable
link between differing object formats when the input
|| bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
&& (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
{
- einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
+ einfo (_("%P%F: Relocatable linking with relocations from"
+ " format %s (%B) to format %s (%B) is not supported\n"),
bfd_get_target (input_bfd), input_bfd,
bfd_get_target (output_bfd), output_bfd);
/* einfo with %F exits. */
if (compatible == NULL)
{
if (command_line.warn_mismatch)
- einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
+ einfo (_("%P: warning: %s architecture of input file `%B'"
+ " is incompatible with %s output\n"),
bfd_printable_name (input_bfd), input_bfd,
bfd_printable_name (output_bfd));
}
if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
{
if (command_line.warn_mismatch)
- einfo (_("%P%X: failed to merge target specific data of file %B\n"),
- input_bfd);
+ einfo (_("%P%X: failed to merge target specific data"
+ " of file %B\n"), input_bfd);
}
if (! command_line.warn_mismatch)
bfd_set_error_handler (pfn);
around for a sensible place for it to go. */
if (file->just_syms_flag)
- {
- abort ();
- }
+ abort ();
+
+ if ((s->flags & SEC_EXCLUDE) != 0)
+ s->output_section = bfd_abs_section_ptr;
else if (strcmp (s->name, "COMMON") == 0)
{
/* This is a lonely common section which must have
/* This message happens when using the
svr3.ifile linker script, so I have
disabled it. */
- info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
+ info_msg (_("%P: no [COMMON] command,"
+ " defaulting to .bss\n"));
#endif
default_common_section =
lang_output_section_statement_lookup (".bss");
enum section_type sectype,
etree_type *align,
etree_type *subalign,
- etree_type *ebase)
+ etree_type *ebase,
+ int constraint)
{
lang_output_section_statement_type *os;
current_section =
os =
- lang_output_section_statement_lookup (output_section_statement_name);
+ lang_output_section_statement_lookup_1 (output_section_statement_name,
+ constraint);
/* Add this statement to tree. */
#if 0
o->_raw_size = 0;
}
-/* If the wild pattern was marked KEEP, the member sections
- should be as well. */
+/* Worker for lang_gc_sections_1. */
static void
gc_section_callback (lang_wild_statement_type *ptr,
lang_input_statement_type *file ATTRIBUTE_UNUSED,
void *data ATTRIBUTE_UNUSED)
{
+ /* If the wild pattern was marked KEEP, the member sections
+ should be as well. */
if (ptr->keep_sections)
section->flags |= SEC_KEEP;
}
-/* Handle a wild statement, marking it against GC. */
-
-static void
-lang_gc_wild (lang_wild_statement_type *s)
-{
- walk_wild (s, gc_section_callback, NULL);
-}
-
/* Iterate over sections marking them against GC. */
static void
switch (s->header.type)
{
case lang_wild_statement_enum:
- lang_gc_wild (&s->wild_statement);
+ walk_wild (&s->wild_statement, gc_section_callback, NULL);
break;
case lang_constructors_statement_enum:
lang_gc_sections_1 (constructor_list.head);
}
}
- bfd_gc_sections (output_bfd, &link_info);
+ /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
+ the special case of debug info. (See bfd/stabs.c)
+ Twiddle the flag here, to simplify later linker code. */
+ if (link_info.relocatable)
+ {
+ LANG_FOR_EACH_INPUT_STATEMENT (f)
+ {
+ asection *sec;
+ for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
+ if ((sec->flags & SEC_DEBUGGING) == 0)
+ sec->flags &= ~SEC_EXCLUDE;
+ }
+ }
+
+ if (command_line.gc_sections)
+ bfd_gc_sections (output_bfd, &link_info);
}
void
ldctor_build_sets ();
/* Remove unreferenced sections if asked to. */
- if (command_line.gc_sections)
- lang_gc_sections ();
-
- /* If there were any SEC_MERGE sections, finish their merging, so that
- section sizes can be computed. This has to be done after GC of sections,
- so that GCed sections are not merged, but before assigning output
- sections, since removing whole input sections is hard then. */
- bfd_merge_sections (output_bfd, &link_info);
+ lang_gc_sections ();
/* Size up the common data. */
lang_common ();
if (! link_info.relocatable)
{
+ asection *found;
+
+ /* Merge SEC_MERGE sections. This has to be done after GC of
+ sections, so that GCed sections are not merged, but before
+ assigning dynamic symbols, since removing whole input sections
+ is hard then. */
+ bfd_merge_sections (output_bfd, &link_info);
+
/* Look for a text section and set the readonly attribute in it. */
- asection *found = bfd_get_section_by_name (output_bfd, ".text");
+ found = bfd_get_section_by_name (output_bfd, ".text");
if (found != NULL)
{
{
*lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
- /* If no runtime region or VMA has been specified, but the load region has
- been specified, then use the load region for the runtime region as well. */
+ /* If no runtime region or VMA has been specified, but the load region
+ has been specified, then use the load region for the runtime region
+ as well. */
if (lma_memspec != NULL
&& ! have_vma
&& strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
lang_output_section_phdr_list *pl;
os = &u->output_section_statement;
+ if (os->constraint == -1)
+ continue;
pl = os->phdrs;
if (pl != NULL)
{
lang_output_section_phdr_list *pl;
- if (u->output_section_statement.bfd_section == NULL)
+ if (u->output_section_statement.constraint == -1
+ || u->output_section_statement.bfd_section == NULL)
continue;
for (pl = u->output_section_statement.phdrs;
etree_type *size;
lang_enter_output_section_statement (name, overlay_vma, normal_section,
- 0, overlay_subalign, 0);
+ 0, overlay_subalign, 0, 0);
/* If this is the first section, then base the VMA of future
sections on this one. This will work correctly even if `.' is
if ((name[0] == '\0' && lang_elf_version_info != NULL)
|| (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
{
- einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
+ einfo (_("%X%P: anonymous version tag cannot be combined"
+ " with other version tags\n"));
free (version);
return;
}
while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
{
if (e1->mask == e2->mask)
- einfo (_("%X%P: duplicate expression `%s' in version information\n"),
- e1->symbol);
+ einfo (_("%X%P: duplicate expression `%s'"
+ " in version information\n"), e1->symbol);
e2 = e2->next;
}
}
else if (!e1->symbol)
for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
- if (strcmp (e1->pattern, e2->pattern) == 0 && e1->mask == e2->mask)
- einfo (_("%X%P: duplicate expression `%s' in version information\n"),
- e1->pattern);
+ if (strcmp (e1->pattern, e2->pattern) == 0
+ && e1->mask == e2->mask)
+ einfo (_("%X%P: duplicate expression `%s'"
+ " in version information\n"), e1->pattern);
}
}
while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
{
if (e1->mask == e2->mask)
- einfo (_("%X%P: duplicate expression `%s' in version information\n"),
+ einfo (_("%X%P: duplicate expression `%s'"
+ " in version information\n"),
e1->symbol);
e2 = e2->next;
}
}
else if (!e1->symbol)
for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
- if (strcmp (e1->pattern, e2->pattern) == 0 && e1->mask == e2->mask)
- einfo (_("%X%P: duplicate expression `%s' in version information\n"),
- e1->pattern);
+ if (strcmp (e1->pattern, e2->pattern) == 0
+ && e1->mask == e2->mask)
+ einfo (_("%X%P: duplicate expression `%s'"
+ " in version information\n"), e1->pattern);
}
}
/* Do not free the contents, as we used them creating the regex. */
/* Do not include this section in the link. */
- bfd_set_section_flags (is->the_bfd, sec,
- bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
+ sec->flags |= SEC_EXCLUDE;
}
lreg = lang_new_vers_pattern (NULL, "*", NULL);
projects / deliverable / binutils-gdb.git / blobdiff