URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [ldlang.c] - Diff between revs 157 and 163

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 157	Rev 163
`/* Linker command language support.`	`/* Linker command language support.`
`Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,`	`Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,`
`2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011`	`2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011`
`Free Software Foundation, Inc.`	`Free Software Foundation, Inc.`

`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 "libiberty.h"`	`#include "libiberty.h"`
`#include "filenames.h"`	`#include "filenames.h"`
`#include "safe-ctype.h"`	`#include "safe-ctype.h"`
`#include "obstack.h"`	`#include "obstack.h"`
`#include "bfdlink.h"`	`#include "bfdlink.h"`

`#include "ld.h"`	`#include "ld.h"`
`#include "ldmain.h"`	`#include "ldmain.h"`
`#include "ldexp.h"`	`#include "ldexp.h"`
`#include "ldlang.h"`	`#include "ldlang.h"`
`#include <ldgram.h>`	`#include <ldgram.h>`
`#include "ldlex.h"`	`#include "ldlex.h"`
`#include "ldmisc.h"`	`#include "ldmisc.h"`
`#include "ldctor.h"`	`#include "ldctor.h"`
`#include "ldfile.h"`	`#include "ldfile.h"`
`#include "ldemul.h"`	`#include "ldemul.h"`
`#include "fnmatch.h"`	`#include "fnmatch.h"`
`#include "demangle.h"`	`#include "demangle.h"`
`#include "hashtab.h"`	`#include "hashtab.h"`
`#include "libbfd.h"`	`#include "libbfd.h"`
`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`#include "plugin.h"`	`#include "plugin.h"`
`#endif /* ENABLE_PLUGINS */`	`#endif /* ENABLE_PLUGINS */`

`#ifndef offsetof`	`#ifndef offsetof`
`#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))`	`#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))`
`#endif`	`#endif`

`/* Locals variables. */`	`/* Locals variables. */`
`static struct obstack stat_obstack;`	`static struct obstack stat_obstack;`
`static struct obstack map_obstack;`	`static struct obstack map_obstack;`

`#define obstack_chunk_alloc xmalloc`	`#define obstack_chunk_alloc xmalloc`
`#define obstack_chunk_free free`	`#define obstack_chunk_free free`
`static const char *entry_symbol_default = "start";`	`static const char *entry_symbol_default = "start";`
`static bfd_boolean placed_commons = FALSE;`	`static bfd_boolean placed_commons = FALSE;`
`static bfd_boolean stripped_excluded_sections = FALSE;`	`static bfd_boolean stripped_excluded_sections = FALSE;`
`static lang_output_section_statement_type *default_common_section;`	`static lang_output_section_statement_type *default_common_section;`
`static bfd_boolean map_option_f;`	`static bfd_boolean map_option_f;`
`static bfd_vma print_dot;`	`static bfd_vma print_dot;`
`static lang_input_statement_type *first_file;`	`static lang_input_statement_type *first_file;`
`static const char *current_target;`	`static const char *current_target;`
`static lang_statement_list_type statement_list;`	`static lang_statement_list_type statement_list;`
`static struct bfd_hash_table lang_definedness_table;`	`static struct bfd_hash_table lang_definedness_table;`
`static lang_statement_list_type *stat_save[10];`	`static lang_statement_list_type *stat_save[10];`
`static lang_statement_list_type **stat_save_ptr = &stat_save[0];`	`static lang_statement_list_type **stat_save_ptr = &stat_save[0];`
`static struct unique_sections *unique_section_list;`	`static struct unique_sections *unique_section_list;`
`static bfd_boolean ldlang_sysrooted_script = FALSE;`	`static bfd_boolean ldlang_sysrooted_script = FALSE;`

`/* Forward declarations. */`	`/* Forward declarations. */`
`static void exp_init_os (etree_type *);`	`static void exp_init_os (etree_type *);`
`static void init_map_userdata (bfd , asection , void *);`	`static void init_map_userdata (bfd , asection , void *);`
`static lang_input_statement_type lookup_name (const char );`	`static lang_input_statement_type lookup_name (const char );`
`static struct bfd_hash_entry *lang_definedness_newfunc`	`static struct bfd_hash_entry *lang_definedness_newfunc`
`(struct bfd_hash_entry , struct bfd_hash_table , const char *);`	`(struct bfd_hash_entry , struct bfd_hash_table , const char *);`
`static void insert_undefined (const char *);`	`static void insert_undefined (const char *);`
`static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry , void );`	`static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry , void );`
`static void print_statement (lang_statement_union_type *,`	`static void print_statement (lang_statement_union_type *,`
`lang_output_section_statement_type *);`	`lang_output_section_statement_type *);`
`static void print_statement_list (lang_statement_union_type *,`	`static void print_statement_list (lang_statement_union_type *,`
`lang_output_section_statement_type *);`	`lang_output_section_statement_type *);`
`static void print_statements (void);`	`static void print_statements (void);`
`static void print_input_section (asection *, bfd_boolean);`	`static void print_input_section (asection *, bfd_boolean);`
`static bfd_boolean lang_one_common (struct bfd_link_hash_entry , void );`	`static bfd_boolean lang_one_common (struct bfd_link_hash_entry , void );`
`static void lang_record_phdrs (void);`	`static void lang_record_phdrs (void);`
`static void lang_do_version_exports_section (void);`	`static void lang_do_version_exports_section (void);`
`static void lang_finalize_version_expr_head`	`static void lang_finalize_version_expr_head`
`(struct bfd_elf_version_expr_head *);`	`(struct bfd_elf_version_expr_head *);`

`/* Exported variables. */`	`/* Exported variables. */`
`const char *output_target;`	`const char *output_target;`
`lang_output_section_statement_type *abs_output_section;`	`lang_output_section_statement_type *abs_output_section;`
`lang_statement_list_type lang_output_section_statement;`	`lang_statement_list_type lang_output_section_statement;`
`lang_statement_list_type *stat_ptr = &statement_list;`	`lang_statement_list_type *stat_ptr = &statement_list;`
`lang_statement_list_type file_chain = { NULL, NULL };`	`lang_statement_list_type file_chain = { NULL, NULL };`
`lang_statement_list_type input_file_chain;`	`lang_statement_list_type input_file_chain;`
`struct bfd_sym_chain entry_symbol = { NULL, NULL };`	`struct bfd_sym_chain entry_symbol = { NULL, NULL };`
`const char *entry_section = ".text";`	`const char *entry_section = ".text";`
`bfd_boolean entry_from_cmdline;`	`bfd_boolean entry_from_cmdline;`
`bfd_boolean undef_from_cmdline;`	`bfd_boolean undef_from_cmdline;`
`bfd_boolean lang_has_input_file = FALSE;`	`bfd_boolean lang_has_input_file = FALSE;`
`bfd_boolean had_output_filename = FALSE;`	`bfd_boolean had_output_filename = FALSE;`
`bfd_boolean lang_float_flag = FALSE;`	`bfd_boolean lang_float_flag = FALSE;`
`bfd_boolean delete_output_file_on_failure = FALSE;`	`bfd_boolean delete_output_file_on_failure = FALSE;`
`struct lang_phdr *lang_phdr_list;`	`struct lang_phdr *lang_phdr_list;`
`struct lang_nocrossrefs *nocrossref_list;`	`struct lang_nocrossrefs *nocrossref_list;`
`bfd_boolean missing_file = FALSE;`	`bfd_boolean missing_file = FALSE;`

`/* Functions that traverse the linker script and might evaluate`	`/* Functions that traverse the linker script and might evaluate`
`DEFINED() need to increment this. */`	`DEFINED() need to increment this. */`
`int lang_statement_iteration = 0;`	`int lang_statement_iteration = 0;`

`etree_type base; / Relocation base - or null */`	`etree_type base; / Relocation base - or null */`

`/* Return TRUE if the PATTERN argument is a wildcard pattern.`	`/* Return TRUE if the PATTERN argument is a wildcard pattern.`
`Although backslashes are treated specially if a pattern contains`	`Although backslashes are treated specially if a pattern contains`
`wildcards, we do not consider the mere presence of a backslash to`	`wildcards, we do not consider the mere presence of a backslash to`
`be enough to cause the pattern to be treated as a wildcard.`	`be enough to cause the pattern to be treated as a wildcard.`
`That lets us handle DOS filenames more naturally. */`	`That lets us handle DOS filenames more naturally. */`
`#define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)`	`#define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)`

`#define new_stat(x, y) \`	`#define new_stat(x, y) \`
`(x##_type *) new_statement (x##_enum, sizeof (x##_type), y)`	`(x##_type *) new_statement (x##_enum, sizeof (x##_type), y)`

`#define outside_section_address(q) \`	`#define outside_section_address(q) \`
`((q)->output_offset + (q)->output_section->vma)`	`((q)->output_offset + (q)->output_section->vma)`

`#define outside_symbol_address(q) \`	`#define outside_symbol_address(q) \`
`((q)->value + outside_section_address (q->section))`	`((q)->value + outside_section_address (q->section))`

`#define SECTION_NAME_MAP_LENGTH (16)`	`#define SECTION_NAME_MAP_LENGTH (16)`

`void *`	`void *`
`stat_alloc (size_t size)`	`stat_alloc (size_t size)`
`{`	`{`
`return obstack_alloc (&stat_obstack, size);`	`return obstack_alloc (&stat_obstack, size);`
`}`	`}`

`static int`	`static int`
`name_match (const char pattern, const char name)`	`name_match (const char pattern, const char name)`
`{`	`{`
`if (wildcardp (pattern))`	`if (wildcardp (pattern))`
`return fnmatch (pattern, name, 0);`	`return fnmatch (pattern, name, 0);`
`return strcmp (pattern, name);`	`return strcmp (pattern, name);`
`}`	`}`

`/* If PATTERN is of the form archive:file, return a pointer to the`	`/* If PATTERN is of the form archive:file, return a pointer to the`
`separator. If not, return NULL. */`	`separator. If not, return NULL. */`

`static char *`	`static char *`
`archive_path (const char *pattern)`	`archive_path (const char *pattern)`
`{`	`{`
`char *p = NULL;`	`char *p = NULL;`

`if (link_info.path_separator == 0)`	`if (link_info.path_separator == 0)`
`return p;`	`return p;`

`p = strchr (pattern, link_info.path_separator);`	`p = strchr (pattern, link_info.path_separator);`
`#ifdef HAVE_DOS_BASED_FILE_SYSTEM`	`#ifdef HAVE_DOS_BASED_FILE_SYSTEM`
`if (p == NULL \|\| link_info.path_separator != ':')`	`if (p == NULL \|\| link_info.path_separator != ':')`
`return p;`	`return p;`

`/* Assume a match on the second char is part of drive specifier,`	`/* Assume a match on the second char is part of drive specifier,`
`as in "c:\silly.dos". */`	`as in "c:\silly.dos". */`
`if (p == pattern + 1 && ISALPHA (*pattern))`	`if (p == pattern + 1 && ISALPHA (*pattern))`
`p = strchr (p + 1, link_info.path_separator);`	`p = strchr (p + 1, link_info.path_separator);`
`#endif`	`#endif`
`return p;`	`return p;`
`}`	`}`

`/* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,`	`/* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,`
`return whether F matches FILE_SPEC. */`	`return whether F matches FILE_SPEC. */`

`static bfd_boolean`	`static bfd_boolean`
`input_statement_is_archive_path (const char file_spec, char sep,`	`input_statement_is_archive_path (const char file_spec, char sep,`
`lang_input_statement_type *f)`	`lang_input_statement_type *f)`
`{`	`{`
`bfd_boolean match = FALSE;`	`bfd_boolean match = FALSE;`

`if ((*(sep + 1) == 0`	`if ((*(sep + 1) == 0`
`\|\| name_match (sep + 1, f->filename) == 0)`	`\|\| name_match (sep + 1, f->filename) == 0)`
`&& ((sep != file_spec)`	`&& ((sep != file_spec)`
`== (f->the_bfd != NULL && f->the_bfd->my_archive != NULL)))`	`== (f->the_bfd != NULL && f->the_bfd->my_archive != NULL)))`
`{`	`{`
`match = TRUE;`	`match = TRUE;`

`if (sep != file_spec)`	`if (sep != file_spec)`
`{`	`{`
`const char *aname = f->the_bfd->my_archive->filename;`	`const char *aname = f->the_bfd->my_archive->filename;`
`*sep = 0;`	`*sep = 0;`
`match = name_match (file_spec, aname) == 0;`	`match = name_match (file_spec, aname) == 0;`
`*sep = link_info.path_separator;`	`*sep = link_info.path_separator;`
`}`	`}`
`}`	`}`
`return match;`	`return match;`
`}`	`}`

`static bfd_boolean`	`static bfd_boolean`
`unique_section_p (const asection *sec,`	`unique_section_p (const asection *sec,`
`const lang_output_section_statement_type *os)`	`const lang_output_section_statement_type *os)`
`{`	`{`
`struct unique_sections *unam;`	`struct unique_sections *unam;`
`const char *secnam;`	`const char *secnam;`

`if (link_info.relocatable`	`if (link_info.relocatable`
`&& sec->owner != NULL`	`&& sec->owner != NULL`
`&& bfd_is_group_section (sec->owner, sec))`	`&& bfd_is_group_section (sec->owner, sec))`
`return !(os != NULL`	`return !(os != NULL`
`&& strcmp (os->name, DISCARD_SECTION_NAME) == 0);`	`&& strcmp (os->name, DISCARD_SECTION_NAME) == 0);`

`secnam = sec->name;`	`secnam = sec->name;`
`for (unam = unique_section_list; unam; unam = unam->next)`	`for (unam = unique_section_list; unam; unam = unam->next)`
`if (name_match (unam->name, secnam) == 0)`	`if (name_match (unam->name, secnam) == 0)`
`return TRUE;`	`return TRUE;`

`return FALSE;`	`return FALSE;`
`}`	`}`

`/* Generic traversal routines for finding matching sections. */`	`/* Generic traversal routines for finding matching sections. */`

`/* Try processing a section against a wildcard. This just calls`	`/* Try processing a section against a wildcard. This just calls`
`the callback unless the filename exclusion list is present`	`the callback unless the filename exclusion list is present`
`and excludes the file. It's hardly ever present so this`	`and excludes the file. It's hardly ever present so this`
`function is very fast. */`	`function is very fast. */`

`static void`	`static void`
`walk_wild_consider_section (lang_wild_statement_type *ptr,`	`walk_wild_consider_section (lang_wild_statement_type *ptr,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`asection *s,`	`asection *s,`
`struct wildcard_list *sec,`	`struct wildcard_list *sec,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`struct name_list *list_tmp;`	`struct name_list *list_tmp;`

`/* Propagate the section_flag_info from the wild statement to the section. */`	`/* Propagate the section_flag_info from the wild statement to the section. */`
`s->section_flag_info = ptr->section_flag_list;`	`s->section_flag_info = ptr->section_flag_list;`

`/* Don't process sections from files which were excluded. */`	`/* Don't process sections from files which were excluded. */`
`for (list_tmp = sec->spec.exclude_name_list;`	`for (list_tmp = sec->spec.exclude_name_list;`
`list_tmp;`	`list_tmp;`
`list_tmp = list_tmp->next)`	`list_tmp = list_tmp->next)`
`{`	`{`
`char *p = archive_path (list_tmp->name);`	`char *p = archive_path (list_tmp->name);`

`if (p != NULL)`	`if (p != NULL)`
`{`	`{`
`if (input_statement_is_archive_path (list_tmp->name, p, file))`	`if (input_statement_is_archive_path (list_tmp->name, p, file))`
`return;`	`return;`
`}`	`}`

`else if (name_match (list_tmp->name, file->filename) == 0)`	`else if (name_match (list_tmp->name, file->filename) == 0)`
`return;`	`return;`

`/* FIXME: Perhaps remove the following at some stage? Matching`	`/* FIXME: Perhaps remove the following at some stage? Matching`
`unadorned archives like this was never documented and has`	`unadorned archives like this was never documented and has`
`been superceded by the archive:path syntax. */`	`been superceded by the archive:path syntax. */`
`else if (file->the_bfd != NULL`	`else if (file->the_bfd != NULL`
`&& file->the_bfd->my_archive != NULL`	`&& file->the_bfd->my_archive != NULL`
`&& name_match (list_tmp->name,`	`&& name_match (list_tmp->name,`
`file->the_bfd->my_archive->filename) == 0)`	`file->the_bfd->my_archive->filename) == 0)`
`return;`	`return;`
`}`	`}`

`(*callback) (ptr, sec, s, file, data);`	`(*callback) (ptr, sec, s, file, data);`
`}`	`}`

`/* Lowest common denominator routine that can handle everything correctly,`	`/* Lowest common denominator routine that can handle everything correctly,`
`but slowly. */`	`but slowly. */`

`static void`	`static void`
`walk_wild_section_general (lang_wild_statement_type *ptr,`	`walk_wild_section_general (lang_wild_statement_type *ptr,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`asection *s;`	`asection *s;`
`struct wildcard_list *sec;`	`struct wildcard_list *sec;`

`for (s = file->the_bfd->sections; s != NULL; s = s->next)`	`for (s = file->the_bfd->sections; s != NULL; s = s->next)`
`{`	`{`
`sec = ptr->section_list;`	`sec = ptr->section_list;`
`if (sec == NULL)`	`if (sec == NULL)`
`(*callback) (ptr, sec, s, file, data);`	`(*callback) (ptr, sec, s, file, data);`

`while (sec != NULL)`	`while (sec != NULL)`
`{`	`{`
`bfd_boolean skip = FALSE;`	`bfd_boolean skip = FALSE;`

`if (sec->spec.name != NULL)`	`if (sec->spec.name != NULL)`
`{`	`{`
`const char *sname = bfd_get_section_name (file->the_bfd, s);`	`const char *sname = bfd_get_section_name (file->the_bfd, s);`

`skip = name_match (sec->spec.name, sname) != 0;`	`skip = name_match (sec->spec.name, sname) != 0;`
`}`	`}`

`if (!skip)`	`if (!skip)`
`walk_wild_consider_section (ptr, file, s, sec, callback, data);`	`walk_wild_consider_section (ptr, file, s, sec, callback, data);`

`sec = sec->next;`	`sec = sec->next;`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Routines to find a single section given its name. If there's more`	`/* Routines to find a single section given its name. If there's more`
`than one section with that name, we report that. */`	`than one section with that name, we report that. */`

`typedef struct`	`typedef struct`
`{`	`{`
`asection *found_section;`	`asection *found_section;`
`bfd_boolean multiple_sections_found;`	`bfd_boolean multiple_sections_found;`
`} section_iterator_callback_data;`	`} section_iterator_callback_data;`

`static bfd_boolean`	`static bfd_boolean`
`section_iterator_callback (bfd abfd ATTRIBUTE_UNUSED, asection s, void *data)`	`section_iterator_callback (bfd abfd ATTRIBUTE_UNUSED, asection s, void *data)`
`{`	`{`
`section_iterator_callback_data d = (section_iterator_callback_data ) data;`	`section_iterator_callback_data d = (section_iterator_callback_data ) data;`

`if (d->found_section != NULL)`	`if (d->found_section != NULL)`
`{`	`{`
`d->multiple_sections_found = TRUE;`	`d->multiple_sections_found = TRUE;`
`return TRUE;`	`return TRUE;`
`}`	`}`

`d->found_section = s;`	`d->found_section = s;`
`return FALSE;`	`return FALSE;`
`}`	`}`

`static asection *`	`static asection *`
`find_section (lang_input_statement_type *file,`	`find_section (lang_input_statement_type *file,`
`struct wildcard_list *sec,`	`struct wildcard_list *sec,`
`bfd_boolean *multiple_sections_found)`	`bfd_boolean *multiple_sections_found)`
`{`	`{`
`section_iterator_callback_data cb_data = { NULL, FALSE };`	`section_iterator_callback_data cb_data = { NULL, FALSE };`

`bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,`	`bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,`
`section_iterator_callback, &cb_data);`	`section_iterator_callback, &cb_data);`
`*multiple_sections_found = cb_data.multiple_sections_found;`	`*multiple_sections_found = cb_data.multiple_sections_found;`
`return cb_data.found_section;`	`return cb_data.found_section;`
`}`	`}`

`/* Code for handling simple wildcards without going through fnmatch,`	`/* Code for handling simple wildcards without going through fnmatch,`
`which can be expensive because of charset translations etc. */`	`which can be expensive because of charset translations etc. */`

`/* A simple wild is a literal string followed by a single '*',`	`/* A simple wild is a literal string followed by a single '*',`
`where the literal part is at least 4 characters long. */`	`where the literal part is at least 4 characters long. */`

`static bfd_boolean`	`static bfd_boolean`
`is_simple_wild (const char *name)`	`is_simple_wild (const char *name)`
`{`	`{`
`size_t len = strcspn (name, "*?[");`	`size_t len = strcspn (name, "*?[");`
`return len >= 4 && name[len] == '*' && name[len + 1] == '\0';`	`return len >= 4 && name[len] == '*' && name[len + 1] == '\0';`
`}`	`}`

`static bfd_boolean`	`static bfd_boolean`
`match_simple_wild (const char pattern, const char name)`	`match_simple_wild (const char pattern, const char name)`
`{`	`{`
`/* The first four characters of the pattern are guaranteed valid`	`/* The first four characters of the pattern are guaranteed valid`
`non-wildcard characters. So we can go faster. */`	`non-wildcard characters. So we can go faster. */`
`if (pattern[0] != name[0] \|\| pattern[1] != name[1]`	`if (pattern[0] != name[0] \|\| pattern[1] != name[1]`
`\|\| pattern[2] != name[2] \|\| pattern[3] != name[3])`	`\|\| pattern[2] != name[2] \|\| pattern[3] != name[3])`
`return FALSE;`	`return FALSE;`

`pattern += 4;`	`pattern += 4;`
`name += 4;`	`name += 4;`
`while (pattern != '')`	`while (pattern != '')`
`if (name++ != pattern++)`	`if (name++ != pattern++)`
`return FALSE;`	`return FALSE;`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Return the numerical value of the init_priority attribute from`	`/* Return the numerical value of the init_priority attribute from`
`section name NAME. */`	`section name NAME. */`

`static unsigned long`	`static unsigned long`
`get_init_priority (const char *name)`	`get_init_priority (const char *name)`
`{`	`{`
`char *end;`	`char *end;`
`unsigned long init_priority;`	`unsigned long init_priority;`

`/* GCC uses the following section names for the init_priority`	`/* GCC uses the following section names for the init_priority`
`attribute with numerical values 101 and 65535 inclusive. A`	`attribute with numerical values 101 and 65535 inclusive. A`
`lower value means a higher priority.`	`lower value means a higher priority.`

`1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the`	`1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the`
`decimal numerical value of the init_priority attribute.`	`decimal numerical value of the init_priority attribute.`
`The order of execution in .init_array is forward and`	`The order of execution in .init_array is forward and`
`.fini_array is backward.`	`.fini_array is backward.`
`2: .ctors.NNNN/.ctors.NNNN: Where NNNN is 65535 minus the`	`2: .ctors.NNNN/.ctors.NNNN: Where NNNN is 65535 minus the`
`decimal numerical value of the init_priority attribute.`	`decimal numerical value of the init_priority attribute.`
`The order of execution in .ctors is backward and .dtors`	`The order of execution in .ctors is backward and .dtors`
`is forward.`	`is forward.`
`*/`	`*/`
`if (strncmp (name, ".init_array.", 12) == 0`	`if (strncmp (name, ".init_array.", 12) == 0`
`\|\| strncmp (name, ".fini_array.", 12) == 0)`	`\|\| strncmp (name, ".fini_array.", 12) == 0)`
`{`	`{`
`init_priority = strtoul (name + 12, &end, 10);`	`init_priority = strtoul (name + 12, &end, 10);`
`return *end ? 0 : init_priority;`	`return *end ? 0 : init_priority;`
`}`	`}`
`else if (strncmp (name, ".ctors.", 7) == 0`	`else if (strncmp (name, ".ctors.", 7) == 0`
`\|\| strncmp (name, ".dtors.", 7) == 0)`	`\|\| strncmp (name, ".dtors.", 7) == 0)`
`{`	`{`
`init_priority = strtoul (name + 7, &end, 10);`	`init_priority = strtoul (name + 7, &end, 10);`
`return *end ? 0 : 65535 - init_priority;`	`return *end ? 0 : 65535 - init_priority;`
`}`	`}`

`return 0;`	`return 0;`
`}`	`}`

`/* Compare sections ASEC and BSEC according to SORT. */`	`/* Compare sections ASEC and BSEC according to SORT. */`

`static int`	`static int`
`compare_section (sort_type sort, asection asec, asection bsec)`	`compare_section (sort_type sort, asection asec, asection bsec)`
`{`	`{`
`int ret;`	`int ret;`
`unsigned long ainit_priority, binit_priority;`	`unsigned long ainit_priority, binit_priority;`

`switch (sort)`	`switch (sort)`
`{`	`{`
`default:`	`default:`
`abort ();`	`abort ();`

`case by_init_priority:`	`case by_init_priority:`
`ainit_priority`	`ainit_priority`
`= get_init_priority (bfd_get_section_name (asec->owner, asec));`	`= get_init_priority (bfd_get_section_name (asec->owner, asec));`
`binit_priority`	`binit_priority`
`= get_init_priority (bfd_get_section_name (bsec->owner, bsec));`	`= get_init_priority (bfd_get_section_name (bsec->owner, bsec));`
`if (ainit_priority == 0 \|\| binit_priority == 0)`	`if (ainit_priority == 0 \|\| binit_priority == 0)`
`goto sort_by_name;`	`goto sort_by_name;`
`ret = ainit_priority - binit_priority;`	`ret = ainit_priority - binit_priority;`
`if (ret)`	`if (ret)`
`break;`	`break;`
`else`	`else`
`goto sort_by_name;`	`goto sort_by_name;`

`case by_alignment_name:`	`case by_alignment_name:`
`ret = (bfd_section_alignment (bsec->owner, bsec)`	`ret = (bfd_section_alignment (bsec->owner, bsec)`
`- bfd_section_alignment (asec->owner, asec));`	`- bfd_section_alignment (asec->owner, asec));`
`if (ret)`	`if (ret)`
`break;`	`break;`
`/* Fall through. */`	`/* Fall through. */`

`case by_name:`	`case by_name:`
`sort_by_name:`	`sort_by_name:`
`ret = strcmp (bfd_get_section_name (asec->owner, asec),`	`ret = strcmp (bfd_get_section_name (asec->owner, asec),`
`bfd_get_section_name (bsec->owner, bsec));`	`bfd_get_section_name (bsec->owner, bsec));`
`break;`	`break;`

`case by_name_alignment:`	`case by_name_alignment:`
`ret = strcmp (bfd_get_section_name (asec->owner, asec),`	`ret = strcmp (bfd_get_section_name (asec->owner, asec),`
`bfd_get_section_name (bsec->owner, bsec));`	`bfd_get_section_name (bsec->owner, bsec));`
`if (ret)`	`if (ret)`
`break;`	`break;`
`/* Fall through. */`	`/* Fall through. */`

`case by_alignment:`	`case by_alignment:`
`ret = (bfd_section_alignment (bsec->owner, bsec)`	`ret = (bfd_section_alignment (bsec->owner, bsec)`
`- bfd_section_alignment (asec->owner, asec));`	`- bfd_section_alignment (asec->owner, asec));`
`break;`	`break;`
`}`	`}`

`return ret;`	`return ret;`
`}`	`}`

`/* Build a Binary Search Tree to sort sections, unlike insertion sort`	`/* Build a Binary Search Tree to sort sections, unlike insertion sort`
`used in wild_sort(). BST is considerably faster if the number of`	`used in wild_sort(). BST is considerably faster if the number of`
`of sections are large. */`	`of sections are large. */`

`static lang_section_bst_type **`	`static lang_section_bst_type **`
`wild_sort_fast (lang_wild_statement_type *wild,`	`wild_sort_fast (lang_wild_statement_type *wild,`
`struct wildcard_list *sec,`	`struct wildcard_list *sec,`
`lang_input_statement_type *file ATTRIBUTE_UNUSED,`	`lang_input_statement_type *file ATTRIBUTE_UNUSED,`
`asection *section)`	`asection *section)`
`{`	`{`
`lang_section_bst_type **tree;`	`lang_section_bst_type **tree;`

`tree = &wild->tree;`	`tree = &wild->tree;`
`if (!wild->filenames_sorted`	`if (!wild->filenames_sorted`
`&& (sec == NULL \|\| sec->spec.sorted == none))`	`&& (sec == NULL \|\| sec->spec.sorted == none))`
`{`	`{`
`/* Append at the right end of tree. */`	`/* Append at the right end of tree. */`
`while (*tree)`	`while (*tree)`
`tree = &((*tree)->right);`	`tree = &((*tree)->right);`
`return tree;`	`return tree;`
`}`	`}`

`while (*tree)`	`while (*tree)`
`{`	`{`
`/* Find the correct node to append this section. */`	`/* Find the correct node to append this section. */`
`if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)`	`if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)`
`tree = &((*tree)->left);`	`tree = &((*tree)->left);`
`else`	`else`
`tree = &((*tree)->right);`	`tree = &((*tree)->right);`
`}`	`}`

`return tree;`	`return tree;`
`}`	`}`

`/* Use wild_sort_fast to build a BST to sort sections. */`	`/* Use wild_sort_fast to build a BST to sort sections. */`

`static void`	`static void`
`output_section_callback_fast (lang_wild_statement_type *ptr,`	`output_section_callback_fast (lang_wild_statement_type *ptr,`
`struct wildcard_list *sec,`	`struct wildcard_list *sec,`
`asection *section,`	`asection *section,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`void *output)`	`void *output)`
`{`	`{`
`lang_section_bst_type *node;`	`lang_section_bst_type *node;`
`lang_section_bst_type **tree;`	`lang_section_bst_type **tree;`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`os = (lang_output_section_statement_type *) output;`	`os = (lang_output_section_statement_type *) output;`

`if (unique_section_p (section, os))`	`if (unique_section_p (section, os))`
`return;`	`return;`

`node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type));`	`node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type));`
`node->left = 0;`	`node->left = 0;`
`node->right = 0;`	`node->right = 0;`
`node->section = section;`	`node->section = section;`

`tree = wild_sort_fast (ptr, sec, file, section);`	`tree = wild_sort_fast (ptr, sec, file, section);`
`if (tree != NULL)`	`if (tree != NULL)`
`*tree = node;`	`*tree = node;`
`}`	`}`

`/* Convert a sorted sections' BST back to list form. */`	`/* Convert a sorted sections' BST back to list form. */`

`static void`	`static void`
`output_section_callback_tree_to_list (lang_wild_statement_type *ptr,`	`output_section_callback_tree_to_list (lang_wild_statement_type *ptr,`
`lang_section_bst_type *tree,`	`lang_section_bst_type *tree,`
`void *output)`	`void *output)`
`{`	`{`
`if (tree->left)`	`if (tree->left)`
`output_section_callback_tree_to_list (ptr, tree->left, output);`	`output_section_callback_tree_to_list (ptr, tree->left, output);`

`lang_add_section (&ptr->children, tree->section,`	`lang_add_section (&ptr->children, tree->section,`
`(lang_output_section_statement_type *) output);`	`(lang_output_section_statement_type *) output);`

`if (tree->right)`	`if (tree->right)`
`output_section_callback_tree_to_list (ptr, tree->right, output);`	`output_section_callback_tree_to_list (ptr, tree->right, output);`

`free (tree);`	`free (tree);`
`}`	`}`

`/* Specialized, optimized routines for handling different kinds of`	`/* Specialized, optimized routines for handling different kinds of`
`wildcards */`	`wildcards */`

`static void`	`static void`
`walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,`	`walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`/* We can just do a hash lookup for the section with the right name.`	`/* We can just do a hash lookup for the section with the right name.`
`But if that lookup discovers more than one section with the name`	`But if that lookup discovers more than one section with the name`
`(should be rare), we fall back to the general algorithm because`	`(should be rare), we fall back to the general algorithm because`
`we would otherwise have to sort the sections to make sure they`	`we would otherwise have to sort the sections to make sure they`
`get processed in the bfd's order. */`	`get processed in the bfd's order. */`
`bfd_boolean multiple_sections_found;`	`bfd_boolean multiple_sections_found;`
`struct wildcard_list *sec0 = ptr->handler_data[0];`	`struct wildcard_list *sec0 = ptr->handler_data[0];`
`asection *s0 = find_section (file, sec0, &multiple_sections_found);`	`asection *s0 = find_section (file, sec0, &multiple_sections_found);`

`if (multiple_sections_found)`	`if (multiple_sections_found)`
`walk_wild_section_general (ptr, file, callback, data);`	`walk_wild_section_general (ptr, file, callback, data);`
`else if (s0)`	`else if (s0)`
`walk_wild_consider_section (ptr, file, s0, sec0, callback, data);`	`walk_wild_consider_section (ptr, file, s0, sec0, callback, data);`
`}`	`}`

`static void`	`static void`
`walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,`	`walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`asection *s;`	`asection *s;`
`struct wildcard_list *wildsec0 = ptr->handler_data[0];`	`struct wildcard_list *wildsec0 = ptr->handler_data[0];`

`for (s = file->the_bfd->sections; s != NULL; s = s->next)`	`for (s = file->the_bfd->sections; s != NULL; s = s->next)`
`{`	`{`
`const char *sname = bfd_get_section_name (file->the_bfd, s);`	`const char *sname = bfd_get_section_name (file->the_bfd, s);`
`bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);`	`bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);`

`if (!skip)`	`if (!skip)`
`walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);`	`walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,`	`walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`asection *s;`	`asection *s;`
`struct wildcard_list *sec0 = ptr->handler_data[0];`	`struct wildcard_list *sec0 = ptr->handler_data[0];`
`struct wildcard_list *wildsec1 = ptr->handler_data[1];`	`struct wildcard_list *wildsec1 = ptr->handler_data[1];`
`bfd_boolean multiple_sections_found;`	`bfd_boolean multiple_sections_found;`
`asection *s0 = find_section (file, sec0, &multiple_sections_found);`	`asection *s0 = find_section (file, sec0, &multiple_sections_found);`

`if (multiple_sections_found)`	`if (multiple_sections_found)`
`{`	`{`
`walk_wild_section_general (ptr, file, callback, data);`	`walk_wild_section_general (ptr, file, callback, data);`
`return;`	`return;`
`}`	`}`

`/* Note that if the section was not found, s0 is NULL and`	`/* Note that if the section was not found, s0 is NULL and`
`we'll simply never succeed the s == s0 test below. */`	`we'll simply never succeed the s == s0 test below. */`
`for (s = file->the_bfd->sections; s != NULL; s = s->next)`	`for (s = file->the_bfd->sections; s != NULL; s = s->next)`
`{`	`{`
`/* Recall that in this code path, a section cannot satisfy more`	`/* Recall that in this code path, a section cannot satisfy more`
`than one spec, so if s == s0 then it cannot match`	`than one spec, so if s == s0 then it cannot match`
`wildspec1. */`	`wildspec1. */`
`if (s == s0)`	`if (s == s0)`
`walk_wild_consider_section (ptr, file, s, sec0, callback, data);`	`walk_wild_consider_section (ptr, file, s, sec0, callback, data);`
`else`	`else`
`{`	`{`
`const char *sname = bfd_get_section_name (file->the_bfd, s);`	`const char *sname = bfd_get_section_name (file->the_bfd, s);`
`bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);`	`bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);`

`if (!skip)`	`if (!skip)`
`walk_wild_consider_section (ptr, file, s, wildsec1, callback,`	`walk_wild_consider_section (ptr, file, s, wildsec1, callback,`
`data);`	`data);`
`}`	`}`
`}`	`}`
`}`	`}`

`static void`	`static void`
`walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,`	`walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`asection *s;`	`asection *s;`
`struct wildcard_list *sec0 = ptr->handler_data[0];`	`struct wildcard_list *sec0 = ptr->handler_data[0];`
`struct wildcard_list *wildsec1 = ptr->handler_data[1];`	`struct wildcard_list *wildsec1 = ptr->handler_data[1];`
`struct wildcard_list *wildsec2 = ptr->handler_data[2];`	`struct wildcard_list *wildsec2 = ptr->handler_data[2];`
`bfd_boolean multiple_sections_found;`	`bfd_boolean multiple_sections_found;`
`asection *s0 = find_section (file, sec0, &multiple_sections_found);`	`asection *s0 = find_section (file, sec0, &multiple_sections_found);`

`if (multiple_sections_found)`	`if (multiple_sections_found)`
`{`	`{`
`walk_wild_section_general (ptr, file, callback, data);`	`walk_wild_section_general (ptr, file, callback, data);`
`return;`	`return;`
`}`	`}`

`for (s = file->the_bfd->sections; s != NULL; s = s->next)`	`for (s = file->the_bfd->sections; s != NULL; s = s->next)`
`{`	`{`
`if (s == s0)`	`if (s == s0)`
`walk_wild_consider_section (ptr, file, s, sec0, callback, data);`	`walk_wild_consider_section (ptr, file, s, sec0, callback, data);`
`else`	`else`
`{`	`{`
`const char *sname = bfd_get_section_name (file->the_bfd, s);`	`const char *sname = bfd_get_section_name (file->the_bfd, s);`
`bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);`	`bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);`

`if (!skip)`	`if (!skip)`
`walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);`	`walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);`
`else`	`else`
`{`	`{`
`skip = !match_simple_wild (wildsec2->spec.name, sname);`	`skip = !match_simple_wild (wildsec2->spec.name, sname);`
`if (!skip)`	`if (!skip)`
`walk_wild_consider_section (ptr, file, s, wildsec2, callback,`	`walk_wild_consider_section (ptr, file, s, wildsec2, callback,`
`data);`	`data);`
`}`	`}`
`}`	`}`
`}`	`}`
`}`	`}`

`static void`	`static void`
`walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,`	`walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`asection *s;`	`asection *s;`
`struct wildcard_list *sec0 = ptr->handler_data[0];`	`struct wildcard_list *sec0 = ptr->handler_data[0];`
`struct wildcard_list *sec1 = ptr->handler_data[1];`	`struct wildcard_list *sec1 = ptr->handler_data[1];`
`struct wildcard_list *wildsec2 = ptr->handler_data[2];`	`struct wildcard_list *wildsec2 = ptr->handler_data[2];`
`struct wildcard_list *wildsec3 = ptr->handler_data[3];`	`struct wildcard_list *wildsec3 = ptr->handler_data[3];`
`bfd_boolean multiple_sections_found;`	`bfd_boolean multiple_sections_found;`
`asection s0 = find_section (file, sec0, &multiple_sections_found), s1;`	`asection s0 = find_section (file, sec0, &multiple_sections_found), s1;`

`if (multiple_sections_found)`	`if (multiple_sections_found)`
`{`	`{`
`walk_wild_section_general (ptr, file, callback, data);`	`walk_wild_section_general (ptr, file, callback, data);`
`return;`	`return;`
`}`	`}`

`s1 = find_section (file, sec1, &multiple_sections_found);`	`s1 = find_section (file, sec1, &multiple_sections_found);`
`if (multiple_sections_found)`	`if (multiple_sections_found)`
`{`	`{`
`walk_wild_section_general (ptr, file, callback, data);`	`walk_wild_section_general (ptr, file, callback, data);`
`return;`	`return;`
`}`	`}`

`for (s = file->the_bfd->sections; s != NULL; s = s->next)`	`for (s = file->the_bfd->sections; s != NULL; s = s->next)`
`{`	`{`
`if (s == s0)`	`if (s == s0)`
`walk_wild_consider_section (ptr, file, s, sec0, callback, data);`	`walk_wild_consider_section (ptr, file, s, sec0, callback, data);`
`else`	`else`
`if (s == s1)`	`if (s == s1)`
`walk_wild_consider_section (ptr, file, s, sec1, callback, data);`	`walk_wild_consider_section (ptr, file, s, sec1, callback, data);`
`else`	`else`
`{`	`{`
`const char *sname = bfd_get_section_name (file->the_bfd, s);`	`const char *sname = bfd_get_section_name (file->the_bfd, s);`
`bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,`	`bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,`
`sname);`	`sname);`

`if (!skip)`	`if (!skip)`
`walk_wild_consider_section (ptr, file, s, wildsec2, callback,`	`walk_wild_consider_section (ptr, file, s, wildsec2, callback,`
`data);`	`data);`
`else`	`else`
`{`	`{`
`skip = !match_simple_wild (wildsec3->spec.name, sname);`	`skip = !match_simple_wild (wildsec3->spec.name, sname);`
`if (!skip)`	`if (!skip)`
`walk_wild_consider_section (ptr, file, s, wildsec3,`	`walk_wild_consider_section (ptr, file, s, wildsec3,`
`callback, data);`	`callback, data);`
`}`	`}`
`}`	`}`
`}`	`}`
`}`	`}`

`static void`	`static void`
`walk_wild_section (lang_wild_statement_type *ptr,`	`walk_wild_section (lang_wild_statement_type *ptr,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`if (file->just_syms_flag)`	`if (file->just_syms_flag)`
`return;`	`return;`

`(*ptr->walk_wild_section_handler) (ptr, file, callback, data);`	`(*ptr->walk_wild_section_handler) (ptr, file, callback, data);`
`}`	`}`

`/* Returns TRUE when name1 is a wildcard spec that might match`	`/* Returns TRUE when name1 is a wildcard spec that might match`
`something name2 can match. We're conservative: we return FALSE`	`something name2 can match. We're conservative: we return FALSE`
`only if the prefixes of name1 and name2 are different up to the`	`only if the prefixes of name1 and name2 are different up to the`
`first wildcard character. */`	`first wildcard character. */`

`static bfd_boolean`	`static bfd_boolean`
`wild_spec_can_overlap (const char name1, const char name2)`	`wild_spec_can_overlap (const char name1, const char name2)`
`{`	`{`
`size_t prefix1_len = strcspn (name1, "?*[");`	`size_t prefix1_len = strcspn (name1, "?*[");`
`size_t prefix2_len = strcspn (name2, "?*[");`	`size_t prefix2_len = strcspn (name2, "?*[");`
`size_t min_prefix_len;`	`size_t min_prefix_len;`

`/* Note that if there is no wildcard character, then we treat the`	`/* Note that if there is no wildcard character, then we treat the`
`terminating 0 as part of the prefix. Thus ".text" won't match`	`terminating 0 as part of the prefix. Thus ".text" won't match`
`".text." or ".text.", for example. /`	`".text." or ".text.", for example. /`
`if (name1[prefix1_len] == '\0')`	`if (name1[prefix1_len] == '\0')`
`prefix1_len++;`	`prefix1_len++;`
`if (name2[prefix2_len] == '\0')`	`if (name2[prefix2_len] == '\0')`
`prefix2_len++;`	`prefix2_len++;`

`min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;`	`min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;`

`return memcmp (name1, name2, min_prefix_len) == 0;`	`return memcmp (name1, name2, min_prefix_len) == 0;`
`}`	`}`

`/* Select specialized code to handle various kinds of wildcard`	`/* Select specialized code to handle various kinds of wildcard`
`statements. */`	`statements. */`

`static void`	`static void`
`analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)`	`analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)`
`{`	`{`
`int sec_count = 0;`	`int sec_count = 0;`
`int wild_name_count = 0;`	`int wild_name_count = 0;`
`struct wildcard_list *sec;`	`struct wildcard_list *sec;`
`int signature;`	`int signature;`
`int data_counter;`	`int data_counter;`

`ptr->walk_wild_section_handler = walk_wild_section_general;`	`ptr->walk_wild_section_handler = walk_wild_section_general;`
`ptr->handler_data[0] = NULL;`	`ptr->handler_data[0] = NULL;`
`ptr->handler_data[1] = NULL;`	`ptr->handler_data[1] = NULL;`
`ptr->handler_data[2] = NULL;`	`ptr->handler_data[2] = NULL;`
`ptr->handler_data[3] = NULL;`	`ptr->handler_data[3] = NULL;`
`ptr->tree = NULL;`	`ptr->tree = NULL;`

`/* Count how many wildcard_specs there are, and how many of those`	`/* Count how many wildcard_specs there are, and how many of those`
`actually use wildcards in the name. Also, bail out if any of the`	`actually use wildcards in the name. Also, bail out if any of the`
`wildcard names are NULL. (Can this actually happen?`	`wildcard names are NULL. (Can this actually happen?`
`walk_wild_section used to test for it.) And bail out if any`	`walk_wild_section used to test for it.) And bail out if any`
`of the wildcards are more complex than a simple string`	`of the wildcards are more complex than a simple string`
`ending in a single ''. /`	`ending in a single ''. /`
`for (sec = ptr->section_list; sec != NULL; sec = sec->next)`	`for (sec = ptr->section_list; sec != NULL; sec = sec->next)`
`{`	`{`
`++sec_count;`	`++sec_count;`
`if (sec->spec.name == NULL)`	`if (sec->spec.name == NULL)`
`return;`	`return;`
`if (wildcardp (sec->spec.name))`	`if (wildcardp (sec->spec.name))`
`{`	`{`
`++wild_name_count;`	`++wild_name_count;`
`if (!is_simple_wild (sec->spec.name))`	`if (!is_simple_wild (sec->spec.name))`
`return;`	`return;`
`}`	`}`
`}`	`}`

`/* The zero-spec case would be easy to optimize but it doesn't`	`/* The zero-spec case would be easy to optimize but it doesn't`
`happen in practice. Likewise, more than 4 specs doesn't`	`happen in practice. Likewise, more than 4 specs doesn't`
`happen in practice. */`	`happen in practice. */`
`if (sec_count == 0 \|\| sec_count > 4)`	`if (sec_count == 0 \|\| sec_count > 4)`
`return;`	`return;`

`/* Check that no two specs can match the same section. */`	`/* Check that no two specs can match the same section. */`
`for (sec = ptr->section_list; sec != NULL; sec = sec->next)`	`for (sec = ptr->section_list; sec != NULL; sec = sec->next)`
`{`	`{`
`struct wildcard_list *sec2;`	`struct wildcard_list *sec2;`
`for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)`	`for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)`
`{`	`{`
`if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))`	`if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))`
`return;`	`return;`
`}`	`}`
`}`	`}`

`signature = (sec_count << 8) + wild_name_count;`	`signature = (sec_count << 8) + wild_name_count;`
`switch (signature)`	`switch (signature)`
`{`	`{`
`case 0x0100:`	`case 0x0100:`
`ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;`	`ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;`
`break;`	`break;`
`case 0x0101:`	`case 0x0101:`
`ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;`	`ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;`
`break;`	`break;`
`case 0x0201:`	`case 0x0201:`
`ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;`	`ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;`
`break;`	`break;`
`case 0x0302:`	`case 0x0302:`
`ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;`	`ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;`
`break;`	`break;`
`case 0x0402:`	`case 0x0402:`
`ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;`	`ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;`
`break;`	`break;`
`default:`	`default:`
`return;`	`return;`
`}`	`}`

`/* Now fill the data array with pointers to the specs, first the`	`/* Now fill the data array with pointers to the specs, first the`
`specs with non-wildcard names, then the specs with wildcard`	`specs with non-wildcard names, then the specs with wildcard`
`names. It's OK to process the specs in different order from the`	`names. It's OK to process the specs in different order from the`
`given order, because we've already determined that no section`	`given order, because we've already determined that no section`
`will match more than one spec. */`	`will match more than one spec. */`
`data_counter = 0;`	`data_counter = 0;`
`for (sec = ptr->section_list; sec != NULL; sec = sec->next)`	`for (sec = ptr->section_list; sec != NULL; sec = sec->next)`
`if (!wildcardp (sec->spec.name))`	`if (!wildcardp (sec->spec.name))`
`ptr->handler_data[data_counter++] = sec;`	`ptr->handler_data[data_counter++] = sec;`
`for (sec = ptr->section_list; sec != NULL; sec = sec->next)`	`for (sec = ptr->section_list; sec != NULL; sec = sec->next)`
`if (wildcardp (sec->spec.name))`	`if (wildcardp (sec->spec.name))`
`ptr->handler_data[data_counter++] = sec;`	`ptr->handler_data[data_counter++] = sec;`
`}`	`}`

`/* Handle a wild statement for a single file F. */`	`/* Handle a wild statement for a single file F. */`

`static void`	`static void`
`walk_wild_file (lang_wild_statement_type *s,`	`walk_wild_file (lang_wild_statement_type *s,`
`lang_input_statement_type *f,`	`lang_input_statement_type *f,`
`callback_t callback,`	`callback_t callback,`
`void *data)`	`void *data)`
`{`	`{`
`if (f->the_bfd == NULL`	`if (f->the_bfd == NULL`
`\|\| ! bfd_check_format (f->the_bfd, bfd_archive))`	`\|\| ! bfd_check_format (f->the_bfd, bfd_archive))`
`walk_wild_section (s, f, callback, data);`	`walk_wild_section (s, f, callback, data);`
`else`	`else`
`{`	`{`
`bfd *member;`	`bfd *member;`

`/* This is an archive file. We must map each member of the`	`/* This is an archive file. We must map each member of the`
`archive separately. */`	`archive separately. */`
`member = bfd_openr_next_archived_file (f->the_bfd, NULL);`	`member = bfd_openr_next_archived_file (f->the_bfd, NULL);`
`while (member != NULL)`	`while (member != NULL)`
`{`	`{`
`/* When lookup_name is called, it will call the add_symbols`	`/* When lookup_name is called, it will call the add_symbols`
`entry point for the archive. For each element of the`	`entry point for the archive. For each element of the`
`archive which is included, BFD will call ldlang_add_file,`	`archive which is included, BFD will call ldlang_add_file,`
`which will set the usrdata field of the member to the`	`which will set the usrdata field of the member to the`
`lang_input_statement. */`	`lang_input_statement. */`
`if (member->usrdata != NULL)`	`if (member->usrdata != NULL)`
`{`	`{`
`walk_wild_section (s,`	`walk_wild_section (s,`
`(lang_input_statement_type *) member->usrdata,`	`(lang_input_statement_type *) member->usrdata,`
`callback, data);`	`callback, data);`
`}`	`}`

`member = bfd_openr_next_archived_file (f->the_bfd, member);`	`member = bfd_openr_next_archived_file (f->the_bfd, member);`
`}`	`}`
`}`	`}`
`}`	`}`

`static void`	`static void`
`walk_wild (lang_wild_statement_type s, callback_t callback, void data)`	`walk_wild (lang_wild_statement_type s, callback_t callback, void data)`
`{`	`{`
`const char *file_spec = s->filename;`	`const char *file_spec = s->filename;`
`char *p;`	`char *p;`

`if (file_spec == NULL)`	`if (file_spec == NULL)`
`{`	`{`
`/* Perform the iteration over all files in the list. */`	`/* Perform the iteration over all files in the list. */`
`LANG_FOR_EACH_INPUT_STATEMENT (f)`	`LANG_FOR_EACH_INPUT_STATEMENT (f)`
`{`	`{`
`walk_wild_file (s, f, callback, data);`	`walk_wild_file (s, f, callback, data);`
`}`	`}`
`}`	`}`
`else if ((p = archive_path (file_spec)) != NULL)`	`else if ((p = archive_path (file_spec)) != NULL)`
`{`	`{`
`LANG_FOR_EACH_INPUT_STATEMENT (f)`	`LANG_FOR_EACH_INPUT_STATEMENT (f)`
`{`	`{`
`if (input_statement_is_archive_path (file_spec, p, f))`	`if (input_statement_is_archive_path (file_spec, p, f))`
`walk_wild_file (s, f, callback, data);`	`walk_wild_file (s, f, callback, data);`
`}`	`}`
`}`	`}`
`else if (wildcardp (file_spec))`	`else if (wildcardp (file_spec))`
`{`	`{`
`LANG_FOR_EACH_INPUT_STATEMENT (f)`	`LANG_FOR_EACH_INPUT_STATEMENT (f)`
`{`	`{`
`if (fnmatch (file_spec, f->filename, 0) == 0)`	`if (fnmatch (file_spec, f->filename, 0) == 0)`
`walk_wild_file (s, f, callback, data);`	`walk_wild_file (s, f, callback, data);`
`}`	`}`
`}`	`}`
`else`	`else`
`{`	`{`
`lang_input_statement_type *f;`	`lang_input_statement_type *f;`

`/* Perform the iteration over a single file. */`	`/* Perform the iteration over a single file. */`
`f = lookup_name (file_spec);`	`f = lookup_name (file_spec);`
`if (f)`	`if (f)`
`walk_wild_file (s, f, callback, data);`	`walk_wild_file (s, f, callback, data);`
`}`	`}`
`}`	`}`

`/* lang_for_each_statement walks the parse tree and calls the provided`	`/* lang_for_each_statement walks the parse tree and calls the provided`
`function for each node, except those inside output section statements`	`function for each node, except those inside output section statements`
`with constraint set to -1. */`	`with constraint set to -1. */`

`void`	`void`
`lang_for_each_statement_worker (void (func) (lang_statement_union_type ),`	`lang_for_each_statement_worker (void (func) (lang_statement_union_type ),`
`lang_statement_union_type *s)`	`lang_statement_union_type *s)`
`{`	`{`
`for (; s != NULL; s = s->header.next)`	`for (; s != NULL; s = s->header.next)`
`{`	`{`
`func (s);`	`func (s);`

`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`lang_for_each_statement_worker (func, constructor_list.head);`	`lang_for_each_statement_worker (func, constructor_list.head);`
`break;`	`break;`
`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`if (s->output_section_statement.constraint != -1)`	`if (s->output_section_statement.constraint != -1)`
`lang_for_each_statement_worker`	`lang_for_each_statement_worker`
`(func, s->output_section_statement.children.head);`	`(func, s->output_section_statement.children.head);`
`break;`	`break;`
`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`lang_for_each_statement_worker (func,`	`lang_for_each_statement_worker (func,`
`s->wild_statement.children.head);`	`s->wild_statement.children.head);`
`break;`	`break;`
`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`lang_for_each_statement_worker (func,`	`lang_for_each_statement_worker (func,`
`s->group_statement.children.head);`	`s->group_statement.children.head);`
`break;`	`break;`
`case lang_data_statement_enum:`	`case lang_data_statement_enum:`
`case lang_reloc_statement_enum:`	`case lang_reloc_statement_enum:`
`case lang_object_symbols_statement_enum:`	`case lang_object_symbols_statement_enum:`
`case lang_output_statement_enum:`	`case lang_output_statement_enum:`
`case lang_target_statement_enum:`	`case lang_target_statement_enum:`
`case lang_input_section_enum:`	`case lang_input_section_enum:`
`case lang_input_statement_enum:`	`case lang_input_statement_enum:`
`case lang_assignment_statement_enum:`	`case lang_assignment_statement_enum:`
`case lang_padding_statement_enum:`	`case lang_padding_statement_enum:`
`case lang_address_statement_enum:`	`case lang_address_statement_enum:`
`case lang_fill_statement_enum:`	`case lang_fill_statement_enum:`
`case lang_insert_statement_enum:`	`case lang_insert_statement_enum:`
`break;`	`break;`
`default:`	`default:`
`FAIL ();`	`FAIL ();`
`break;`	`break;`
`}`	`}`
`}`	`}`
`}`	`}`

`void`	`void`
`lang_for_each_statement (void (func) (lang_statement_union_type ))`	`lang_for_each_statement (void (func) (lang_statement_union_type ))`
`{`	`{`
`lang_for_each_statement_worker (func, statement_list.head);`	`lang_for_each_statement_worker (func, statement_list.head);`
`}`	`}`

`/----------------------------------------------------------------------/`	`/----------------------------------------------------------------------/`

`void`	`void`
`lang_list_init (lang_statement_list_type *list)`	`lang_list_init (lang_statement_list_type *list)`
`{`	`{`
`list->head = NULL;`	`list->head = NULL;`
`list->tail = &list->head;`	`list->tail = &list->head;`
`}`	`}`

`void`	`void`
`push_stat_ptr (lang_statement_list_type *new_ptr)`	`push_stat_ptr (lang_statement_list_type *new_ptr)`
`{`	`{`
`if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))`	`if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))`
`abort ();`	`abort ();`
`*stat_save_ptr++ = stat_ptr;`	`*stat_save_ptr++ = stat_ptr;`
`stat_ptr = new_ptr;`	`stat_ptr = new_ptr;`
`}`	`}`

`void`	`void`
`pop_stat_ptr (void)`	`pop_stat_ptr (void)`
`{`	`{`
`if (stat_save_ptr <= stat_save)`	`if (stat_save_ptr <= stat_save)`
`abort ();`	`abort ();`
`stat_ptr = *--stat_save_ptr;`	`stat_ptr = *--stat_save_ptr;`
`}`	`}`

`/* Build a new statement node for the parse tree. */`	`/* Build a new statement node for the parse tree. */`

`static lang_statement_union_type *`	`static lang_statement_union_type *`
`new_statement (enum statement_enum type,`	`new_statement (enum statement_enum type,`
`size_t size,`	`size_t size,`
`lang_statement_list_type *list)`	`lang_statement_list_type *list)`
`{`	`{`
`lang_statement_union_type *new_stmt;`	`lang_statement_union_type *new_stmt;`

`new_stmt = (lang_statement_union_type *) stat_alloc (size);`	`new_stmt = (lang_statement_union_type *) stat_alloc (size);`
`new_stmt->header.type = type;`	`new_stmt->header.type = type;`
`new_stmt->header.next = NULL;`	`new_stmt->header.next = NULL;`
`lang_statement_append (list, new_stmt, &new_stmt->header.next);`	`lang_statement_append (list, new_stmt, &new_stmt->header.next);`
`return new_stmt;`	`return new_stmt;`
`}`	`}`

`/* Build a new input file node for the language. There are several`	`/* Build a new input file node for the language. There are several`
`ways in which we treat an input file, eg, we only look at symbols,`	`ways in which we treat an input file, eg, we only look at symbols,`
`or prefix it with a -l etc.`	`or prefix it with a -l etc.`

`We can be supplied with requests for input files more than once;`	`We can be supplied with requests for input files more than once;`
`they may, for example be split over several lines like foo.o(.text)`	`they may, for example be split over several lines like foo.o(.text)`
`foo.o(.data) etc, so when asked for a file we check that we haven't`	`foo.o(.data) etc, so when asked for a file we check that we haven't`
`got it already so we don't duplicate the bfd. */`	`got it already so we don't duplicate the bfd. */`

`static lang_input_statement_type *`	`static lang_input_statement_type *`
`new_afile (const char *name,`	`new_afile (const char *name,`
`lang_input_file_enum_type file_type,`	`lang_input_file_enum_type file_type,`
`const char *target,`	`const char *target,`
`bfd_boolean add_to_list)`	`bfd_boolean add_to_list)`
`{`	`{`
`lang_input_statement_type *p;`	`lang_input_statement_type *p;`

`if (add_to_list)`	`if (add_to_list)`
`p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr);`	`p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr);`
`else`	`else`
`{`	`{`
`p = (lang_input_statement_type *)`	`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.type = lang_input_statement_enum;`
`p->header.next = NULL;`	`p->header.next = NULL;`
`}`	`}`

`lang_has_input_file = TRUE;`	`lang_has_input_file = TRUE;`
`p->target = target;`	`p->target = target;`
`p->sysrooted = FALSE;`	`p->sysrooted = FALSE;`

`if (file_type == lang_input_file_is_l_enum`	`if (file_type == lang_input_file_is_l_enum`
`&& name[0] == ':' && name[1] != '\0')`	`&& name[0] == ':' && name[1] != '\0')`
`{`	`{`
`file_type = lang_input_file_is_search_file_enum;`	`file_type = lang_input_file_is_search_file_enum;`
`name = name + 1;`	`name = name + 1;`
`}`	`}`

`switch (file_type)`	`switch (file_type)`
`{`	`{`
`case lang_input_file_is_symbols_only_enum:`	`case lang_input_file_is_symbols_only_enum:`
`p->filename = name;`	`p->filename = name;`
`p->maybe_archive = FALSE;`	`p->maybe_archive = FALSE;`
`p->real = TRUE;`	`p->real = TRUE;`
`p->local_sym_name = name;`	`p->local_sym_name = name;`
`p->just_syms_flag = TRUE;`	`p->just_syms_flag = TRUE;`
`p->search_dirs_flag = FALSE;`	`p->search_dirs_flag = FALSE;`
`break;`	`break;`
`case lang_input_file_is_fake_enum:`	`case lang_input_file_is_fake_enum:`
`p->filename = name;`	`p->filename = name;`
`p->maybe_archive = FALSE;`	`p->maybe_archive = FALSE;`
`p->real = FALSE;`	`p->real = FALSE;`
`p->local_sym_name = name;`	`p->local_sym_name = name;`
`p->just_syms_flag = FALSE;`	`p->just_syms_flag = FALSE;`
`p->search_dirs_flag = FALSE;`	`p->search_dirs_flag = FALSE;`
`break;`	`break;`
`case lang_input_file_is_l_enum:`	`case lang_input_file_is_l_enum:`
`p->maybe_archive = TRUE;`	`p->maybe_archive = TRUE;`
`p->filename = name;`	`p->filename = name;`
`p->real = TRUE;`	`p->real = TRUE;`
`p->local_sym_name = concat ("-l", name, (const char *) NULL);`	`p->local_sym_name = concat ("-l", name, (const char *) NULL);`
`p->just_syms_flag = FALSE;`	`p->just_syms_flag = FALSE;`
`p->search_dirs_flag = TRUE;`	`p->search_dirs_flag = TRUE;`
`break;`	`break;`
`case lang_input_file_is_marker_enum:`	`case lang_input_file_is_marker_enum:`
`p->filename = name;`	`p->filename = name;`
`p->maybe_archive = FALSE;`	`p->maybe_archive = FALSE;`
`p->real = FALSE;`	`p->real = FALSE;`
`p->local_sym_name = name;`	`p->local_sym_name = name;`
`p->just_syms_flag = FALSE;`	`p->just_syms_flag = FALSE;`
`p->search_dirs_flag = TRUE;`	`p->search_dirs_flag = TRUE;`
`break;`	`break;`
`case lang_input_file_is_search_file_enum:`	`case lang_input_file_is_search_file_enum:`
`p->sysrooted = ldlang_sysrooted_script;`	`p->sysrooted = ldlang_sysrooted_script;`
`p->filename = name;`	`p->filename = name;`
`p->maybe_archive = FALSE;`	`p->maybe_archive = FALSE;`
`p->real = TRUE;`	`p->real = TRUE;`
`p->local_sym_name = name;`	`p->local_sym_name = name;`
`p->just_syms_flag = FALSE;`	`p->just_syms_flag = FALSE;`
`p->search_dirs_flag = TRUE;`	`p->search_dirs_flag = TRUE;`
`break;`	`break;`
`case lang_input_file_is_file_enum:`	`case lang_input_file_is_file_enum:`
`p->filename = name;`	`p->filename = name;`
`p->maybe_archive = FALSE;`	`p->maybe_archive = FALSE;`
`p->real = TRUE;`	`p->real = TRUE;`
`p->local_sym_name = name;`	`p->local_sym_name = name;`
`p->just_syms_flag = FALSE;`	`p->just_syms_flag = FALSE;`
`p->search_dirs_flag = FALSE;`	`p->search_dirs_flag = FALSE;`
`break;`	`break;`
`default:`	`default:`
`FAIL ();`	`FAIL ();`
`}`	`}`
`p->the_bfd = NULL;`	`p->the_bfd = NULL;`
`p->next_real_file = NULL;`	`p->next_real_file = NULL;`
`p->next = NULL;`	`p->next = NULL;`
`p->dynamic = config.dynamic_link;`	`p->dynamic = config.dynamic_link;`
`p->add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;`	`p->add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;`
`p->add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;`	`p->add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;`
`p->whole_archive = whole_archive;`	`p->whole_archive = whole_archive;`
`p->loaded = FALSE;`	`p->loaded = FALSE;`
`p->missing_file = FALSE;`	`p->missing_file = FALSE;`
`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`p->claimed = FALSE;`	`p->claimed = FALSE;`
`p->claim_archive = FALSE;`	`p->claim_archive = FALSE;`
	`p->reload = FALSE;`
`#endif /* ENABLE_PLUGINS */`	`#endif /* ENABLE_PLUGINS */`

`lang_statement_append (&input_file_chain,`	`lang_statement_append (&input_file_chain,`
`(lang_statement_union_type *) p,`	`(lang_statement_union_type *) p,`
`&p->next_real_file);`	`&p->next_real_file);`
`return p;`	`return p;`
`}`	`}`

`lang_input_statement_type *`	`lang_input_statement_type *`
`lang_add_input_file (const char *name,`	`lang_add_input_file (const char *name,`
`lang_input_file_enum_type file_type,`	`lang_input_file_enum_type file_type,`
`const char *target)`	`const char *target)`
`{`	`{`
`return new_afile (name, file_type, target, TRUE);`	`return new_afile (name, file_type, target, TRUE);`
`}`	`}`

`struct out_section_hash_entry`	`struct out_section_hash_entry`
`{`	`{`
`struct bfd_hash_entry root;`	`struct bfd_hash_entry root;`
`lang_statement_union_type s;`	`lang_statement_union_type s;`
`};`	`};`

`/* The hash table. */`	`/* The hash table. */`

`static struct bfd_hash_table output_section_statement_table;`	`static struct bfd_hash_table output_section_statement_table;`

`/* Support routines for the hash table used by lang_output_section_find,`	`/* Support routines for the hash table used by lang_output_section_find,`
`initialize the table, fill in an entry and remove the table. */`	`initialize the table, fill in an entry and remove the table. */`

`static struct bfd_hash_entry *`	`static struct bfd_hash_entry *`
`output_section_statement_newfunc (struct bfd_hash_entry *entry,`	`output_section_statement_newfunc (struct bfd_hash_entry *entry,`
`struct bfd_hash_table *table,`	`struct bfd_hash_table *table,`
`const char *string)`	`const char *string)`
`{`	`{`
`lang_output_section_statement_type **nextp;`	`lang_output_section_statement_type **nextp;`
`struct out_section_hash_entry *ret;`	`struct out_section_hash_entry *ret;`

`if (entry == NULL)`	`if (entry == NULL)`
`{`	`{`
`entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,`	`entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,`
`sizeof (*ret));`	`sizeof (*ret));`
`if (entry == NULL)`	`if (entry == NULL)`
`return entry;`	`return entry;`
`}`	`}`

`entry = bfd_hash_newfunc (entry, table, string);`	`entry = bfd_hash_newfunc (entry, table, string);`
`if (entry == NULL)`	`if (entry == NULL)`
`return entry;`	`return entry;`

`ret = (struct out_section_hash_entry *) entry;`	`ret = (struct out_section_hash_entry *) entry;`
`memset (&ret->s, 0, sizeof (ret->s));`	`memset (&ret->s, 0, sizeof (ret->s));`
`ret->s.header.type = lang_output_section_statement_enum;`	`ret->s.header.type = lang_output_section_statement_enum;`
`ret->s.output_section_statement.subsection_alignment = -1;`	`ret->s.output_section_statement.subsection_alignment = -1;`
`ret->s.output_section_statement.section_alignment = -1;`	`ret->s.output_section_statement.section_alignment = -1;`
`ret->s.output_section_statement.block_value = 1;`	`ret->s.output_section_statement.block_value = 1;`
`lang_list_init (&ret->s.output_section_statement.children);`	`lang_list_init (&ret->s.output_section_statement.children);`
`lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);`	`lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);`

`/* For every output section statement added to the list, except the`	`/* For every output section statement added to the list, except the`
`first one, lang_output_section_statement.tail points to the "next"`	`first one, lang_output_section_statement.tail points to the "next"`
`field of the last element of the list. */`	`field of the last element of the list. */`
`if (lang_output_section_statement.head != NULL)`	`if (lang_output_section_statement.head != NULL)`
`ret->s.output_section_statement.prev`	`ret->s.output_section_statement.prev`
`= ((lang_output_section_statement_type *)`	`= ((lang_output_section_statement_type *)`
`((char *) lang_output_section_statement.tail`	`((char *) lang_output_section_statement.tail`
`- offsetof (lang_output_section_statement_type, next)));`	`- offsetof (lang_output_section_statement_type, next)));`

`/* GCC's strict aliasing rules prevent us from just casting the`	`/* GCC's strict aliasing rules prevent us from just casting the`
`address, so we store the pointer in a variable and cast that`	`address, so we store the pointer in a variable and cast that`
`instead. */`	`instead. */`
`nextp = &ret->s.output_section_statement.next;`	`nextp = &ret->s.output_section_statement.next;`
`lang_statement_append (&lang_output_section_statement,`	`lang_statement_append (&lang_output_section_statement,`
`&ret->s,`	`&ret->s,`
`(lang_statement_union_type **) nextp);`	`(lang_statement_union_type **) nextp);`
`return &ret->root;`	`return &ret->root;`
`}`	`}`

`static void`	`static void`
`output_section_statement_table_init (void)`	`output_section_statement_table_init (void)`
`{`	`{`
`if (!bfd_hash_table_init_n (&output_section_statement_table,`	`if (!bfd_hash_table_init_n (&output_section_statement_table,`
`output_section_statement_newfunc,`	`output_section_statement_newfunc,`
`sizeof (struct out_section_hash_entry),`	`sizeof (struct out_section_hash_entry),`
`61))`	`61))`
`einfo (_("%P%F: can not create hash table: %E\n"));`	`einfo (_("%P%F: can not create hash table: %E\n"));`
`}`	`}`

`static void`	`static void`
`output_section_statement_table_free (void)`	`output_section_statement_table_free (void)`
`{`	`{`
`bfd_hash_table_free (&output_section_statement_table);`	`bfd_hash_table_free (&output_section_statement_table);`
`}`	`}`

`/* Build enough state so that the parser can build its tree. */`	`/* Build enough state so that the parser can build its tree. */`

`void`	`void`
`lang_init (void)`	`lang_init (void)`
`{`	`{`
`obstack_begin (&stat_obstack, 1000);`	`obstack_begin (&stat_obstack, 1000);`

`stat_ptr = &statement_list;`	`stat_ptr = &statement_list;`

`output_section_statement_table_init ();`	`output_section_statement_table_init ();`

`lang_list_init (stat_ptr);`	`lang_list_init (stat_ptr);`

`lang_list_init (&input_file_chain);`	`lang_list_init (&input_file_chain);`
`lang_list_init (&lang_output_section_statement);`	`lang_list_init (&lang_output_section_statement);`
`lang_list_init (&file_chain);`	`lang_list_init (&file_chain);`
`first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,`	`first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,`
`NULL);`	`NULL);`
`abs_output_section =`	`abs_output_section =`
`lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);`	`lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);`

`abs_output_section->bfd_section = bfd_abs_section_ptr;`	`abs_output_section->bfd_section = bfd_abs_section_ptr;`

`/* The value "3" is ad-hoc, somewhat related to the expected number of`	`/* The value "3" is ad-hoc, somewhat related to the expected number of`
`DEFINED expressions in a linker script. For most default linker`	`DEFINED expressions in a linker script. For most default linker`
`scripts, there are none. Why a hash table then? Well, it's somewhat`	`scripts, there are none. Why a hash table then? Well, it's somewhat`
`simpler to re-use working machinery than using a linked list in terms`	`simpler to re-use working machinery than using a linked list in terms`
`of code-complexity here in ld, besides the initialization which just`	`of code-complexity here in ld, besides the initialization which just`
`looks like other code here. */`	`looks like other code here. */`
`if (!bfd_hash_table_init_n (&lang_definedness_table,`	`if (!bfd_hash_table_init_n (&lang_definedness_table,`
`lang_definedness_newfunc,`	`lang_definedness_newfunc,`
`sizeof (struct lang_definedness_hash_entry),`	`sizeof (struct lang_definedness_hash_entry),`
`3))`	`3))`
`einfo (_("%P%F: can not create hash table: %E\n"));`	`einfo (_("%P%F: can not create hash table: %E\n"));`
`}`	`}`

`void`	`void`
`lang_finish (void)`	`lang_finish (void)`
`{`	`{`
`output_section_statement_table_free ();`	`output_section_statement_table_free ();`
`}`	`}`

`/*----------------------------------------------------------------------`	`/*----------------------------------------------------------------------`
`A region is an area of memory declared with the`	`A region is an area of memory declared with the`
`MEMORY { name:org=exp, len=exp ... }`	`MEMORY { name:org=exp, len=exp ... }`
`syntax.`	`syntax.`

`We maintain a list of all the regions here.`	`We maintain a list of all the regions here.`

`If no regions are specified in the script, then the default is used`	`If no regions are specified in the script, then the default is used`
`which is created when looked up to be the entire data space.`	`which is created when looked up to be the entire data space.`

`If create is true we are creating a region inside a MEMORY block.`	`If create is true we are creating a region inside a MEMORY block.`
`In this case it is probably an error to create a region that has`	`In this case it is probably an error to create a region that has`
`already been created. If we are not inside a MEMORY block it is`	`already been created. If we are not inside a MEMORY block it is`
`dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)`	`dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)`
`and so we issue a warning.`	`and so we issue a warning.`

`Each region has at least one name. The first name is either`	`Each region has at least one name. The first name is either`
`DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add`	`DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add`
`alias names to an existing region within a script with`	`alias names to an existing region within a script with`
`REGION_ALIAS (alias, region_name). Each name corresponds to at most one`	`REGION_ALIAS (alias, region_name). Each name corresponds to at most one`
`region. */`	`region. */`

`static lang_memory_region_type *lang_memory_region_list;`	`static lang_memory_region_type *lang_memory_region_list;`
`static lang_memory_region_type **lang_memory_region_list_tail`	`static lang_memory_region_type **lang_memory_region_list_tail`
`= &lang_memory_region_list;`	`= &lang_memory_region_list;`

`lang_memory_region_type *`	`lang_memory_region_type *`
`lang_memory_region_lookup (const char *const name, bfd_boolean create)`	`lang_memory_region_lookup (const char *const name, bfd_boolean create)`
`{`	`{`
`lang_memory_region_name *n;`	`lang_memory_region_name *n;`
`lang_memory_region_type *r;`	`lang_memory_region_type *r;`
`lang_memory_region_type *new_region;`	`lang_memory_region_type *new_region;`

`/* NAME is NULL for LMA memspecs if no region was specified. */`	`/* NAME is NULL for LMA memspecs if no region was specified. */`
`if (name == NULL)`	`if (name == NULL)`
`return NULL;`	`return NULL;`

`for (r = lang_memory_region_list; r != NULL; r = r->next)`	`for (r = lang_memory_region_list; r != NULL; r = r->next)`
`for (n = &r->name_list; n != NULL; n = n->next)`	`for (n = &r->name_list; n != NULL; n = n->next)`
`if (strcmp (n->name, name) == 0)`	`if (strcmp (n->name, name) == 0)`
`{`	`{`
`if (create)`	`if (create)`
einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),	einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
`name);`	`name);`
`return r;`	`return r;`
`}`	`}`

`if (!create && strcmp (name, DEFAULT_MEMORY_REGION))`	`if (!create && strcmp (name, DEFAULT_MEMORY_REGION))`
einfo (_("%P:%S: warning: memory region `%s' not declared\n"), name);	einfo (_("%P:%S: warning: memory region `%s' not declared\n"), name);

`new_region = (lang_memory_region_type *)`	`new_region = (lang_memory_region_type *)`
`stat_alloc (sizeof (lang_memory_region_type));`	`stat_alloc (sizeof (lang_memory_region_type));`

`new_region->name_list.name = xstrdup (name);`	`new_region->name_list.name = xstrdup (name);`
`new_region->name_list.next = NULL;`	`new_region->name_list.next = NULL;`
`new_region->next = NULL;`	`new_region->next = NULL;`
`new_region->origin = 0;`	`new_region->origin = 0;`
`new_region->length = ~(bfd_size_type) 0;`	`new_region->length = ~(bfd_size_type) 0;`
`new_region->current = 0;`	`new_region->current = 0;`
`new_region->last_os = NULL;`	`new_region->last_os = NULL;`
`new_region->flags = 0;`	`new_region->flags = 0;`
`new_region->not_flags = 0;`	`new_region->not_flags = 0;`
`new_region->had_full_message = FALSE;`	`new_region->had_full_message = FALSE;`

`*lang_memory_region_list_tail = new_region;`	`*lang_memory_region_list_tail = new_region;`
`lang_memory_region_list_tail = &new_region->next;`	`lang_memory_region_list_tail = &new_region->next;`

`return new_region;`	`return new_region;`
`}`	`}`

`void`	`void`
`lang_memory_region_alias (const char * alias, const char * region_name)`	`lang_memory_region_alias (const char * alias, const char * region_name)`
`{`	`{`
`lang_memory_region_name * n;`	`lang_memory_region_name * n;`
`lang_memory_region_type * r;`	`lang_memory_region_type * r;`
`lang_memory_region_type * region;`	`lang_memory_region_type * region;`

`/* The default region must be unique. This ensures that it is not necessary`	`/* The default region must be unique. This ensures that it is not necessary`
`to iterate through the name list if someone wants the check if a region is`	`to iterate through the name list if someone wants the check if a region is`
`the default memory region. */`	`the default memory region. */`
`if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0`	`if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0`
`\|\| strcmp (alias, DEFAULT_MEMORY_REGION) == 0)`	`\|\| strcmp (alias, DEFAULT_MEMORY_REGION) == 0)`
`einfo (_("%F%P:%S: error: alias for default memory region\n"));`	`einfo (_("%F%P:%S: error: alias for default memory region\n"));`

`/* Look for the target region and check if the alias is not already`	`/* Look for the target region and check if the alias is not already`
`in use. */`	`in use. */`
`region = NULL;`	`region = NULL;`
`for (r = lang_memory_region_list; r != NULL; r = r->next)`	`for (r = lang_memory_region_list; r != NULL; r = r->next)`
`for (n = &r->name_list; n != NULL; n = n->next)`	`for (n = &r->name_list; n != NULL; n = n->next)`
`{`	`{`
`if (region == NULL && strcmp (n->name, region_name) == 0)`	`if (region == NULL && strcmp (n->name, region_name) == 0)`
`region = r;`	`region = r;`
`if (strcmp (n->name, alias) == 0)`	`if (strcmp (n->name, alias) == 0)`
`einfo (_("%F%P:%S: error: redefinition of memory region "`	`einfo (_("%F%P:%S: error: redefinition of memory region "`
"alias `%s'\n"),	"alias `%s'\n"),
`alias);`	`alias);`
`}`	`}`

`/* Check if the target region exists. */`	`/* Check if the target region exists. */`
`if (region == NULL)`	`if (region == NULL)`
einfo (_("%F%P:%S: error: memory region `%s' "	einfo (_("%F%P:%S: error: memory region `%s' "
"for alias `%s' does not exist\n"),	"for alias `%s' does not exist\n"),
`region_name,`	`region_name,`
`alias);`	`alias);`

`/* Add alias to region name list. */`	`/* Add alias to region name list. */`
`n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));`	`n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));`
`n->name = xstrdup (alias);`	`n->name = xstrdup (alias);`
`n->next = region->name_list.next;`	`n->next = region->name_list.next;`
`region->name_list.next = n;`	`region->name_list.next = n;`
`}`	`}`

`static lang_memory_region_type *`	`static lang_memory_region_type *`
`lang_memory_default (asection * section)`	`lang_memory_default (asection * section)`
`{`	`{`
`lang_memory_region_type *p;`	`lang_memory_region_type *p;`

`flagword sec_flags = section->flags;`	`flagword sec_flags = section->flags;`

`/* Override SEC_DATA to mean a writable section. */`	`/* Override SEC_DATA to mean a writable section. */`
`if ((sec_flags & (SEC_ALLOC \| SEC_READONLY \| SEC_CODE)) == SEC_ALLOC)`	`if ((sec_flags & (SEC_ALLOC \| SEC_READONLY \| SEC_CODE)) == SEC_ALLOC)`
`sec_flags \|= SEC_DATA;`	`sec_flags \|= SEC_DATA;`

`for (p = lang_memory_region_list; p != NULL; p = p->next)`	`for (p = lang_memory_region_list; p != NULL; p = p->next)`
`{`	`{`
`if ((p->flags & sec_flags) != 0`	`if ((p->flags & sec_flags) != 0`
`&& (p->not_flags & sec_flags) == 0)`	`&& (p->not_flags & sec_flags) == 0)`
`{`	`{`
`return p;`	`return p;`
`}`	`}`
`}`	`}`
`return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);`	`return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);`
`}`	`}`

`/* Find or create an output_section_statement with the given NAME.`	`/* Find or create an output_section_statement with the given NAME.`
`If CONSTRAINT is non-zero match one with that constraint, otherwise`	`If CONSTRAINT is non-zero match one with that constraint, otherwise`
`match any non-negative constraint. If CREATE, always make a`	`match any non-negative constraint. If CREATE, always make a`
`new output_section_statement for SPECIAL CONSTRAINT. */`	`new output_section_statement for SPECIAL CONSTRAINT. */`

`lang_output_section_statement_type *`	`lang_output_section_statement_type *`
`lang_output_section_statement_lookup (const char *name,`	`lang_output_section_statement_lookup (const char *name,`
`int constraint,`	`int constraint,`
`bfd_boolean create)`	`bfd_boolean create)`
`{`	`{`
`struct out_section_hash_entry *entry;`	`struct out_section_hash_entry *entry;`

`entry = ((struct out_section_hash_entry *)`	`entry = ((struct out_section_hash_entry *)`
`bfd_hash_lookup (&output_section_statement_table, name,`	`bfd_hash_lookup (&output_section_statement_table, name,`
`create, FALSE));`	`create, FALSE));`
`if (entry == NULL)`	`if (entry == NULL)`
`{`	`{`
`if (create)`	`if (create)`
einfo (_("%P%F: failed creating section `%s': %E\n"), name);	einfo (_("%P%F: failed creating section `%s': %E\n"), name);
`return NULL;`	`return NULL;`
`}`	`}`

`if (entry->s.output_section_statement.name != NULL)`	`if (entry->s.output_section_statement.name != NULL)`
`{`	`{`
`/* We have a section of this name, but it might not have the correct`	`/* We have a section of this name, but it might not have the correct`
`constraint. */`	`constraint. */`
`struct out_section_hash_entry *last_ent;`	`struct out_section_hash_entry *last_ent;`

`name = entry->s.output_section_statement.name;`	`name = entry->s.output_section_statement.name;`
`if (create && constraint == SPECIAL)`	`if (create && constraint == SPECIAL)`
`/* Not traversing to the end reverses the order of the second`	`/* Not traversing to the end reverses the order of the second`
`and subsequent SPECIAL sections in the hash table chain,`	`and subsequent SPECIAL sections in the hash table chain,`
`but that shouldn't matter. */`	`but that shouldn't matter. */`
`last_ent = entry;`	`last_ent = entry;`
`else`	`else`
`do`	`do`
`{`	`{`
`if (constraint == entry->s.output_section_statement.constraint`	`if (constraint == entry->s.output_section_statement.constraint`
`\|\| (constraint == 0`	`\|\| (constraint == 0`
`&& entry->s.output_section_statement.constraint >= 0))`	`&& entry->s.output_section_statement.constraint >= 0))`
`return &entry->s.output_section_statement;`	`return &entry->s.output_section_statement;`
`last_ent = entry;`	`last_ent = entry;`
`entry = (struct out_section_hash_entry *) entry->root.next;`	`entry = (struct out_section_hash_entry *) entry->root.next;`
`}`	`}`
`while (entry != NULL`	`while (entry != NULL`
`&& name == entry->s.output_section_statement.name);`	`&& name == entry->s.output_section_statement.name);`

`if (!create)`	`if (!create)`
`return NULL;`	`return NULL;`

`entry`	`entry`
`= ((struct out_section_hash_entry *)`	`= ((struct out_section_hash_entry *)`
`output_section_statement_newfunc (NULL,`	`output_section_statement_newfunc (NULL,`
`&output_section_statement_table,`	`&output_section_statement_table,`
`name));`	`name));`
`if (entry == NULL)`	`if (entry == NULL)`
`{`	`{`
einfo (_("%P%F: failed creating section `%s': %E\n"), name);	einfo (_("%P%F: failed creating section `%s': %E\n"), name);
`return NULL;`	`return NULL;`
`}`	`}`
`entry->root = last_ent->root;`	`entry->root = last_ent->root;`
`last_ent->root.next = &entry->root;`	`last_ent->root.next = &entry->root;`
`}`	`}`

`entry->s.output_section_statement.name = name;`	`entry->s.output_section_statement.name = name;`
`entry->s.output_section_statement.constraint = constraint;`	`entry->s.output_section_statement.constraint = constraint;`
`return &entry->s.output_section_statement;`	`return &entry->s.output_section_statement;`
`}`	`}`

`/* Find the next output_section_statement with the same name as OS.`	`/* Find the next output_section_statement with the same name as OS.`
`If CONSTRAINT is non-zero, find one with that constraint otherwise`	`If CONSTRAINT is non-zero, find one with that constraint otherwise`
`match any non-negative constraint. */`	`match any non-negative constraint. */`

`lang_output_section_statement_type *`	`lang_output_section_statement_type *`
`next_matching_output_section_statement (lang_output_section_statement_type *os,`	`next_matching_output_section_statement (lang_output_section_statement_type *os,`
`int constraint)`	`int constraint)`
`{`	`{`
`/* All output_section_statements are actually part of a`	`/* All output_section_statements are actually part of a`
`struct out_section_hash_entry. */`	`struct out_section_hash_entry. */`
`struct out_section_hash_entry entry = (struct out_section_hash_entry )`	`struct out_section_hash_entry entry = (struct out_section_hash_entry )`
`((char *) os`	`((char *) os`
`- offsetof (struct out_section_hash_entry, s.output_section_statement));`	`- offsetof (struct out_section_hash_entry, s.output_section_statement));`
`const char *name = os->name;`	`const char *name = os->name;`

`ASSERT (name == entry->root.string);`	`ASSERT (name == entry->root.string);`
`do`	`do`
`{`	`{`
`entry = (struct out_section_hash_entry *) entry->root.next;`	`entry = (struct out_section_hash_entry *) entry->root.next;`
`if (entry == NULL`	`if (entry == NULL`
`\|\| name != entry->s.output_section_statement.name)`	`\|\| name != entry->s.output_section_statement.name)`
`return NULL;`	`return NULL;`
`}`	`}`
`while (constraint != entry->s.output_section_statement.constraint`	`while (constraint != entry->s.output_section_statement.constraint`
`&& (constraint != 0`	`&& (constraint != 0`
`\|\| entry->s.output_section_statement.constraint < 0));`	`\|\| entry->s.output_section_statement.constraint < 0));`

`return &entry->s.output_section_statement;`	`return &entry->s.output_section_statement;`
`}`	`}`

`/* A variant of lang_output_section_find used by place_orphan.`	`/* A variant of lang_output_section_find used by place_orphan.`
`Returns the output statement that should precede a new output`	`Returns the output statement that should precede a new output`
`statement for SEC. If an exact match is found on certain flags,`	`statement for SEC. If an exact match is found on certain flags,`
`sets EXACT too. /`	`sets EXACT too. /`

`lang_output_section_statement_type *`	`lang_output_section_statement_type *`
`lang_output_section_find_by_flags (const asection *sec,`	`lang_output_section_find_by_flags (const asection *sec,`
`lang_output_section_statement_type **exact,`	`lang_output_section_statement_type **exact,`
`lang_match_sec_type_func match_type)`	`lang_match_sec_type_func match_type)`
`{`	`{`
`lang_output_section_statement_type first, look, *found;`	`lang_output_section_statement_type first, look, *found;`
`flagword flags;`	`flagword flags;`

`/* We know the first statement on this list is ABS. May as well`	`/* We know the first statement on this list is ABS. May as well`
`skip it. */`	`skip it. */`
`first = &lang_output_section_statement.head->output_section_statement;`	`first = &lang_output_section_statement.head->output_section_statement;`
`first = first->next;`	`first = first->next;`

`/* First try for an exact match. */`	`/* First try for an exact match. */`
`found = NULL;`	`found = NULL;`
`for (look = first; look; look = look->next)`	`for (look = first; look; look = look->next)`
`{`	`{`
`flags = look->flags;`	`flags = look->flags;`
`if (look->bfd_section != NULL)`	`if (look->bfd_section != NULL)`
`{`	`{`
`flags = look->bfd_section->flags;`	`flags = look->bfd_section->flags;`
`if (match_type && !match_type (link_info.output_bfd,`	`if (match_type && !match_type (link_info.output_bfd,`
`look->bfd_section,`	`look->bfd_section,`
`sec->owner, sec))`	`sec->owner, sec))`
`continue;`	`continue;`
`}`	`}`
`flags ^= sec->flags;`	`flags ^= sec->flags;`
`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_READONLY`	`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_READONLY`
`\| SEC_CODE \| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))`	`\| SEC_CODE \| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))`
`found = look;`	`found = look;`
`}`	`}`
`if (found != NULL)`	`if (found != NULL)`
`{`	`{`
`if (exact != NULL)`	`if (exact != NULL)`
`*exact = found;`	`*exact = found;`
`return found;`	`return found;`
`}`	`}`

`if ((sec->flags & SEC_CODE) != 0`	`if ((sec->flags & SEC_CODE) != 0`
`&& (sec->flags & SEC_ALLOC) != 0)`	`&& (sec->flags & SEC_ALLOC) != 0)`
`{`	`{`
`/* Try for a rw code section. */`	`/* Try for a rw code section. */`
`for (look = first; look; look = look->next)`	`for (look = first; look; look = look->next)`
`{`	`{`
`flags = look->flags;`	`flags = look->flags;`
`if (look->bfd_section != NULL)`	`if (look->bfd_section != NULL)`
`{`	`{`
`flags = look->bfd_section->flags;`	`flags = look->bfd_section->flags;`
`if (match_type && !match_type (link_info.output_bfd,`	`if (match_type && !match_type (link_info.output_bfd,`
`look->bfd_section,`	`look->bfd_section,`
`sec->owner, sec))`	`sec->owner, sec))`
`continue;`	`continue;`
`}`	`}`
`flags ^= sec->flags;`	`flags ^= sec->flags;`
`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`	`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`
`\| SEC_CODE \| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))`	`\| SEC_CODE \| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))`
`found = look;`	`found = look;`
`}`	`}`
`}`	`}`
`else if ((sec->flags & (SEC_READONLY \| SEC_THREAD_LOCAL)) != 0`	`else if ((sec->flags & (SEC_READONLY \| SEC_THREAD_LOCAL)) != 0`
`&& (sec->flags & SEC_ALLOC) != 0)`	`&& (sec->flags & SEC_ALLOC) != 0)`
`{`	`{`
`/* .rodata can go after .text, .sdata2 after .rodata. */`	`/* .rodata can go after .text, .sdata2 after .rodata. */`
`for (look = first; look; look = look->next)`	`for (look = first; look; look = look->next)`
`{`	`{`
`flags = look->flags;`	`flags = look->flags;`
`if (look->bfd_section != NULL)`	`if (look->bfd_section != NULL)`
`{`	`{`
`flags = look->bfd_section->flags;`	`flags = look->bfd_section->flags;`
`if (match_type && !match_type (link_info.output_bfd,`	`if (match_type && !match_type (link_info.output_bfd,`
`look->bfd_section,`	`look->bfd_section,`
`sec->owner, sec))`	`sec->owner, sec))`
`continue;`	`continue;`
`}`	`}`
`flags ^= sec->flags;`	`flags ^= sec->flags;`
`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`	`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`
`\| SEC_READONLY \| SEC_SMALL_DATA))`	`\| SEC_READONLY \| SEC_SMALL_DATA))`
`\|\| (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`	`\|\| (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`
`\| SEC_READONLY))`	`\| SEC_READONLY))`
`&& !(look->flags & SEC_SMALL_DATA))`	`&& !(look->flags & SEC_SMALL_DATA))`
`\|\| (!(flags & (SEC_THREAD_LOCAL \| SEC_ALLOC))`	`\|\| (!(flags & (SEC_THREAD_LOCAL \| SEC_ALLOC))`
`&& (look->flags & SEC_THREAD_LOCAL)`	`&& (look->flags & SEC_THREAD_LOCAL)`
`&& (!(flags & SEC_LOAD)`	`&& (!(flags & SEC_LOAD)`
`\|\| (look->flags & SEC_LOAD))))`	`\|\| (look->flags & SEC_LOAD))))`
`found = look;`	`found = look;`
`}`	`}`
`}`	`}`
`else if ((sec->flags & SEC_SMALL_DATA) != 0`	`else if ((sec->flags & SEC_SMALL_DATA) != 0`
`&& (sec->flags & SEC_ALLOC) != 0)`	`&& (sec->flags & SEC_ALLOC) != 0)`
`{`	`{`
`/* .sdata goes after .data, .sbss after .sdata. */`	`/* .sdata goes after .data, .sbss after .sdata. */`
`for (look = first; look; look = look->next)`	`for (look = first; look; look = look->next)`
`{`	`{`
`flags = look->flags;`	`flags = look->flags;`
`if (look->bfd_section != NULL)`	`if (look->bfd_section != NULL)`
`{`	`{`
`flags = look->bfd_section->flags;`	`flags = look->bfd_section->flags;`
`if (match_type && !match_type (link_info.output_bfd,`	`if (match_type && !match_type (link_info.output_bfd,`
`look->bfd_section,`	`look->bfd_section,`
`sec->owner, sec))`	`sec->owner, sec))`
`continue;`	`continue;`
`}`	`}`
`flags ^= sec->flags;`	`flags ^= sec->flags;`
`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`	`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`
`\| SEC_THREAD_LOCAL))`	`\| SEC_THREAD_LOCAL))`
`\|\| ((look->flags & SEC_SMALL_DATA)`	`\|\| ((look->flags & SEC_SMALL_DATA)`
`&& !(sec->flags & SEC_HAS_CONTENTS)))`	`&& !(sec->flags & SEC_HAS_CONTENTS)))`
`found = look;`	`found = look;`
`}`	`}`
`}`	`}`
`else if ((sec->flags & SEC_HAS_CONTENTS) != 0`	`else if ((sec->flags & SEC_HAS_CONTENTS) != 0`
`&& (sec->flags & SEC_ALLOC) != 0)`	`&& (sec->flags & SEC_ALLOC) != 0)`
`{`	`{`
`/* .data goes after .rodata. */`	`/* .data goes after .rodata. */`
`for (look = first; look; look = look->next)`	`for (look = first; look; look = look->next)`
`{`	`{`
`flags = look->flags;`	`flags = look->flags;`
`if (look->bfd_section != NULL)`	`if (look->bfd_section != NULL)`
`{`	`{`
`flags = look->bfd_section->flags;`	`flags = look->bfd_section->flags;`
`if (match_type && !match_type (link_info.output_bfd,`	`if (match_type && !match_type (link_info.output_bfd,`
`look->bfd_section,`	`look->bfd_section,`
`sec->owner, sec))`	`sec->owner, sec))`
`continue;`	`continue;`
`}`	`}`
`flags ^= sec->flags;`	`flags ^= sec->flags;`
`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`	`if (!(flags & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD`
`\| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))`	`\| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))`
`found = look;`	`found = look;`
`}`	`}`
`}`	`}`
`else if ((sec->flags & SEC_ALLOC) != 0)`	`else if ((sec->flags & SEC_ALLOC) != 0)`
`{`	`{`
`/* .bss goes after any other alloc section. */`	`/* .bss goes after any other alloc section. */`
`for (look = first; look; look = look->next)`	`for (look = first; look; look = look->next)`
`{`	`{`
`flags = look->flags;`	`flags = look->flags;`
`if (look->bfd_section != NULL)`	`if (look->bfd_section != NULL)`
`{`	`{`
`flags = look->bfd_section->flags;`	`flags = look->bfd_section->flags;`
`if (match_type && !match_type (link_info.output_bfd,`	`if (match_type && !match_type (link_info.output_bfd,`
`look->bfd_section,`	`look->bfd_section,`
`sec->owner, sec))`	`sec->owner, sec))`
`continue;`	`continue;`
`}`	`}`
`flags ^= sec->flags;`	`flags ^= sec->flags;`
`if (!(flags & SEC_ALLOC))`	`if (!(flags & SEC_ALLOC))`
`found = look;`	`found = look;`
`}`	`}`
`}`	`}`
`else`	`else`
`{`	`{`
`/* non-alloc go last. */`	`/* non-alloc go last. */`
`for (look = first; look; look = look->next)`	`for (look = first; look; look = look->next)`
`{`	`{`
`flags = look->flags;`	`flags = look->flags;`
`if (look->bfd_section != NULL)`	`if (look->bfd_section != NULL)`
`flags = look->bfd_section->flags;`	`flags = look->bfd_section->flags;`
`flags ^= sec->flags;`	`flags ^= sec->flags;`
`if (!(flags & SEC_DEBUGGING))`	`if (!(flags & SEC_DEBUGGING))`
`found = look;`	`found = look;`
`}`	`}`
`return found;`	`return found;`
`}`	`}`

`if (found \|\| !match_type)`	`if (found \|\| !match_type)`
`return found;`	`return found;`

`return lang_output_section_find_by_flags (sec, NULL, NULL);`	`return lang_output_section_find_by_flags (sec, NULL, NULL);`
`}`	`}`

`/* Find the last output section before given output statement.`	`/* Find the last output section before given output statement.`
`Used by place_orphan. */`	`Used by place_orphan. */`

`static asection *`	`static asection *`
`output_prev_sec_find (lang_output_section_statement_type *os)`	`output_prev_sec_find (lang_output_section_statement_type *os)`
`{`	`{`
`lang_output_section_statement_type *lookup;`	`lang_output_section_statement_type *lookup;`

`for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)`	`for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)`
`{`	`{`
`if (lookup->constraint < 0)`	`if (lookup->constraint < 0)`
`continue;`	`continue;`

`if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)`	`if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)`
`return lookup->bfd_section;`	`return lookup->bfd_section;`
`}`	`}`

`return NULL;`	`return NULL;`
`}`	`}`

`/* Look for a suitable place for a new output section statement. The`	`/* Look for a suitable place for a new output section statement. The`
`idea is to skip over anything that might be inside a SECTIONS {}`	`idea is to skip over anything that might be inside a SECTIONS {}`
`statement in a script, before we find another output section`	`statement in a script, before we find another output section`
`statement. Assignments to "dot" before an output section statement`	`statement. Assignments to "dot" before an output section statement`
`are assumed to belong to it, except in two cases; The first`	`are assumed to belong to it, except in two cases; The first`
`assignment to dot, and assignments before non-alloc sections.`	`assignment to dot, and assignments before non-alloc sections.`
`Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or`	`Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or`
`similar assignments that set the initial address, or we might`	`similar assignments that set the initial address, or we might`
`insert non-alloc note sections among assignments setting end of`	`insert non-alloc note sections among assignments setting end of`
`image symbols. */`	`image symbols. */`

`static lang_statement_union_type **`	`static lang_statement_union_type **`
`insert_os_after (lang_output_section_statement_type *after)`	`insert_os_after (lang_output_section_statement_type *after)`
`{`	`{`
`lang_statement_union_type **where;`	`lang_statement_union_type **where;`
`lang_statement_union_type **assign = NULL;`	`lang_statement_union_type **assign = NULL;`
`bfd_boolean ignore_first;`	`bfd_boolean ignore_first;`

`ignore_first`	`ignore_first`
`= after == &lang_output_section_statement.head->output_section_statement;`	`= after == &lang_output_section_statement.head->output_section_statement;`

`for (where = &after->header.next;`	`for (where = &after->header.next;`
`*where != NULL;`	`*where != NULL;`
`where = &(*where)->header.next)`	`where = &(*where)->header.next)`
`{`	`{`
`switch ((*where)->header.type)`	`switch ((*where)->header.type)`
`{`	`{`
`case lang_assignment_statement_enum:`	`case lang_assignment_statement_enum:`
`if (assign == NULL)`	`if (assign == NULL)`
`{`	`{`
`lang_assignment_statement_type *ass;`	`lang_assignment_statement_type *ass;`

`ass = &(*where)->assignment_statement;`	`ass = &(*where)->assignment_statement;`
`if (ass->exp->type.node_class != etree_assert`	`if (ass->exp->type.node_class != etree_assert`
`&& ass->exp->assign.dst[0] == '.'`	`&& ass->exp->assign.dst[0] == '.'`
`&& ass->exp->assign.dst[1] == 0`	`&& ass->exp->assign.dst[1] == 0`
`&& !ignore_first)`	`&& !ignore_first)`
`assign = where;`	`assign = where;`
`}`	`}`
`ignore_first = FALSE;`	`ignore_first = FALSE;`
`continue;`	`continue;`
`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`case lang_input_section_enum:`	`case lang_input_section_enum:`
`case lang_object_symbols_statement_enum:`	`case lang_object_symbols_statement_enum:`
`case lang_fill_statement_enum:`	`case lang_fill_statement_enum:`
`case lang_data_statement_enum:`	`case lang_data_statement_enum:`
`case lang_reloc_statement_enum:`	`case lang_reloc_statement_enum:`
`case lang_padding_statement_enum:`	`case lang_padding_statement_enum:`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`assign = NULL;`	`assign = NULL;`
`continue;`	`continue;`
`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`if (assign != NULL)`	`if (assign != NULL)`
`{`	`{`
`asection s = (where)->output_section_statement.bfd_section;`	`asection s = (where)->output_section_statement.bfd_section;`

`if (s == NULL`	`if (s == NULL`
`\|\| s->map_head.s == NULL`	`\|\| s->map_head.s == NULL`
`\|\| (s->flags & SEC_ALLOC) != 0)`	`\|\| (s->flags & SEC_ALLOC) != 0)`
`where = assign;`	`where = assign;`
`}`	`}`
`break;`	`break;`
`case lang_input_statement_enum:`	`case lang_input_statement_enum:`
`case lang_address_statement_enum:`	`case lang_address_statement_enum:`
`case lang_target_statement_enum:`	`case lang_target_statement_enum:`
`case lang_output_statement_enum:`	`case lang_output_statement_enum:`
`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`case lang_insert_statement_enum:`	`case lang_insert_statement_enum:`
`continue;`	`continue;`
`}`	`}`
`break;`	`break;`
`}`	`}`

`return where;`	`return where;`
`}`	`}`

`lang_output_section_statement_type *`	`lang_output_section_statement_type *`
`lang_insert_orphan (asection *s,`	`lang_insert_orphan (asection *s,`
`const char *secname,`	`const char *secname,`
`int constraint,`	`int constraint,`
`lang_output_section_statement_type *after,`	`lang_output_section_statement_type *after,`
`struct orphan_save *place,`	`struct orphan_save *place,`
`etree_type *address,`	`etree_type *address,`
`lang_statement_list_type *add_child)`	`lang_statement_list_type *add_child)`
`{`	`{`
`lang_statement_list_type add;`	`lang_statement_list_type add;`
`const char *ps;`	`const char *ps;`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`
`lang_output_section_statement_type **os_tail;`	`lang_output_section_statement_type **os_tail;`

`/* If we have found an appropriate place for the output section`	`/* If we have found an appropriate place for the output section`
`statements for this orphan, add them to our own private list,`	`statements for this orphan, add them to our own private list,`
`inserting them later into the global statement list. */`	`inserting them later into the global statement list. */`
`if (after != NULL)`	`if (after != NULL)`
`{`	`{`
`lang_list_init (&add);`	`lang_list_init (&add);`
`push_stat_ptr (&add);`	`push_stat_ptr (&add);`
`}`	`}`

`if (link_info.relocatable \|\| (s->flags & (SEC_LOAD \| SEC_ALLOC)) == 0)`	`if (link_info.relocatable \|\| (s->flags & (SEC_LOAD \| SEC_ALLOC)) == 0)`
`address = exp_intop (0);`	`address = exp_intop (0);`

`os_tail = ((lang_output_section_statement_type **)`	`os_tail = ((lang_output_section_statement_type **)`
`lang_output_section_statement.tail);`	`lang_output_section_statement.tail);`
`os = lang_enter_output_section_statement (secname, address, normal_section,`	`os = lang_enter_output_section_statement (secname, address, normal_section,`
`NULL, NULL, NULL, constraint);`	`NULL, NULL, NULL, constraint);`

`ps = NULL;`	`ps = NULL;`
`if (config.build_constructors && *os_tail == os)`	`if (config.build_constructors && *os_tail == os)`
`{`	`{`
`/* If the name of the section is representable in C, then create`	`/* If the name of the section is representable in C, then create`
`symbols to mark the start and the end of the section. */`	`symbols to mark the start and the end of the section. */`
`for (ps = secname; *ps != '\0'; ps++)`	`for (ps = secname; *ps != '\0'; ps++)`
`if (! ISALNUM ((unsigned char) ps) && ps != '_')`	`if (! ISALNUM ((unsigned char) ps) && ps != '_')`
`break;`	`break;`
`if (*ps == '\0')`	`if (*ps == '\0')`
`{`	`{`
`char *symname;`	`char *symname;`
`etree_type *e_align;`	`etree_type *e_align;`

`symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);`	`symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);`
`symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);`	`symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);`
`sprintf (symname + (symname[0] != 0), "__start_%s", secname);`	`sprintf (symname + (symname[0] != 0), "__start_%s", secname);`
`e_align = exp_unop (ALIGN_K,`	`e_align = exp_unop (ALIGN_K,`
`exp_intop ((bfd_vma) 1 << s->alignment_power));`	`exp_intop ((bfd_vma) 1 << s->alignment_power));`
`lang_add_assignment (exp_assign (".", e_align));`	`lang_add_assignment (exp_assign (".", e_align));`
`lang_add_assignment (exp_provide (symname,`	`lang_add_assignment (exp_provide (symname,`
`exp_unop (ABSOLUTE,`	`exp_unop (ABSOLUTE,`
`exp_nameop (NAME, ".")),`	`exp_nameop (NAME, ".")),`
`FALSE));`	`FALSE));`
`}`	`}`
`}`	`}`

`if (add_child == NULL)`	`if (add_child == NULL)`
`add_child = &os->children;`	`add_child = &os->children;`
`lang_add_section (add_child, s, os);`	`lang_add_section (add_child, s, os);`

`if (after && (s->flags & (SEC_LOAD \| SEC_ALLOC)) != 0)`	`if (after && (s->flags & (SEC_LOAD \| SEC_ALLOC)) != 0)`
`{`	`{`
`const char *region = (after->region`	`const char *region = (after->region`
`? after->region->name_list.name`	`? after->region->name_list.name`
`: DEFAULT_MEMORY_REGION);`	`: DEFAULT_MEMORY_REGION);`
`const char *lma_region = (after->lma_region`	`const char *lma_region = (after->lma_region`
`? after->lma_region->name_list.name`	`? after->lma_region->name_list.name`
`: NULL);`	`: NULL);`
`lang_leave_output_section_statement (NULL, region, after->phdrs,`	`lang_leave_output_section_statement (NULL, region, after->phdrs,`
`lma_region);`	`lma_region);`
`}`	`}`
`else`	`else`
`lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,`	`lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,`
`NULL);`	`NULL);`

`if (ps != NULL && *ps == '\0')`	`if (ps != NULL && *ps == '\0')`
`{`	`{`
`char *symname;`	`char *symname;`

`symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);`	`symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);`
`symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);`	`symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);`
`sprintf (symname + (symname[0] != 0), "__stop_%s", secname);`	`sprintf (symname + (symname[0] != 0), "__stop_%s", secname);`
`lang_add_assignment (exp_provide (symname,`	`lang_add_assignment (exp_provide (symname,`
`exp_nameop (NAME, "."),`	`exp_nameop (NAME, "."),`
`FALSE));`	`FALSE));`
`}`	`}`

`/* Restore the global list pointer. */`	`/* Restore the global list pointer. */`
`if (after != NULL)`	`if (after != NULL)`
`pop_stat_ptr ();`	`pop_stat_ptr ();`

`if (after != NULL && os->bfd_section != NULL)`	`if (after != NULL && os->bfd_section != NULL)`
`{`	`{`
`asection snew, as;`	`asection snew, as;`

`snew = os->bfd_section;`	`snew = os->bfd_section;`

`/* Shuffle the bfd section list to make the output file look`	`/* Shuffle the bfd section list to make the output file look`
`neater. This is really only cosmetic. */`	`neater. This is really only cosmetic. */`
`if (place->section == NULL`	`if (place->section == NULL`
`&& after != (&lang_output_section_statement.head`	`&& after != (&lang_output_section_statement.head`
`->output_section_statement))`	`->output_section_statement))`
`{`	`{`
`asection *bfd_section = after->bfd_section;`	`asection *bfd_section = after->bfd_section;`

`/* If the output statement hasn't been used to place any input`	`/* If the output statement hasn't been used to place any input`
`sections (and thus doesn't have an output bfd_section),`	`sections (and thus doesn't have an output bfd_section),`
`look for the closest prior output statement having an`	`look for the closest prior output statement having an`
`output section. */`	`output section. */`
`if (bfd_section == NULL)`	`if (bfd_section == NULL)`
`bfd_section = output_prev_sec_find (after);`	`bfd_section = output_prev_sec_find (after);`

`if (bfd_section != NULL && bfd_section != snew)`	`if (bfd_section != NULL && bfd_section != snew)`
`place->section = &bfd_section->next;`	`place->section = &bfd_section->next;`
`}`	`}`

`if (place->section == NULL)`	`if (place->section == NULL)`
`place->section = &link_info.output_bfd->sections;`	`place->section = &link_info.output_bfd->sections;`

`as = *place->section;`	`as = *place->section;`

`if (!as)`	`if (!as)`
`{`	`{`
`/* Put the section at the end of the list. */`	`/* Put the section at the end of the list. */`

`/* Unlink the section. */`	`/* Unlink the section. */`
`bfd_section_list_remove (link_info.output_bfd, snew);`	`bfd_section_list_remove (link_info.output_bfd, snew);`

`/* Now tack it back on in the right place. */`	`/* Now tack it back on in the right place. */`
`bfd_section_list_append (link_info.output_bfd, snew);`	`bfd_section_list_append (link_info.output_bfd, snew);`
`}`	`}`
`else if (as != snew && as->prev != snew)`	`else if (as != snew && as->prev != snew)`
`{`	`{`
`/* Unlink the section. */`	`/* Unlink the section. */`
`bfd_section_list_remove (link_info.output_bfd, snew);`	`bfd_section_list_remove (link_info.output_bfd, snew);`

`/* Now tack it back on in the right place. */`	`/* Now tack it back on in the right place. */`
`bfd_section_list_insert_before (link_info.output_bfd, as, snew);`	`bfd_section_list_insert_before (link_info.output_bfd, as, snew);`
`}`	`}`

`/* Save the end of this list. Further ophans of this type will`	`/* Save the end of this list. Further ophans of this type will`
`follow the one we've just added. */`	`follow the one we've just added. */`
`place->section = &snew->next;`	`place->section = &snew->next;`

`/* The following is non-cosmetic. We try to put the output`	`/* The following is non-cosmetic. We try to put the output`
`statements in some sort of reasonable order here, because they`	`statements in some sort of reasonable order here, because they`
`determine the final load addresses of the orphan sections.`	`determine the final load addresses of the orphan sections.`
`In addition, placing output statements in the wrong order may`	`In addition, placing output statements in the wrong order may`
`require extra segments. For instance, given a typical`	`require extra segments. For instance, given a typical`
`situation of all read-only sections placed in one segment and`	`situation of all read-only sections placed in one segment and`
`following that a segment containing all the read-write`	`following that a segment containing all the read-write`
`sections, we wouldn't want to place an orphan read/write`	`sections, we wouldn't want to place an orphan read/write`
`section before or amongst the read-only ones. */`	`section before or amongst the read-only ones. */`
`if (add.head != NULL)`	`if (add.head != NULL)`
`{`	`{`
`lang_output_section_statement_type *newly_added_os;`	`lang_output_section_statement_type *newly_added_os;`

`if (place->stmt == NULL)`	`if (place->stmt == NULL)`
`{`	`{`
`lang_statement_union_type **where = insert_os_after (after);`	`lang_statement_union_type **where = insert_os_after (after);`

`add.tail = where;`	`add.tail = where;`
`*where = add.head;`	`*where = add.head;`

`place->os_tail = &after->next;`	`place->os_tail = &after->next;`
`}`	`}`
`else`	`else`
`{`	`{`
`/* Put it after the last orphan statement we added. */`	`/* Put it after the last orphan statement we added. */`
`add.tail = place->stmt;`	`add.tail = place->stmt;`
`*place->stmt = add.head;`	`*place->stmt = add.head;`
`}`	`}`

`/* Fix the global list pointer if we happened to tack our`	`/* Fix the global list pointer if we happened to tack our`
`new list at the tail. */`	`new list at the tail. */`
`if (*stat_ptr->tail == add.head)`	`if (*stat_ptr->tail == add.head)`
`stat_ptr->tail = add.tail;`	`stat_ptr->tail = add.tail;`

`/* Save the end of this list. */`	`/* Save the end of this list. */`
`place->stmt = add.tail;`	`place->stmt = add.tail;`

`/* Do the same for the list of output section statements. */`	`/* Do the same for the list of output section statements. */`
`newly_added_os = *os_tail;`	`newly_added_os = *os_tail;`
`*os_tail = NULL;`	`*os_tail = NULL;`
`newly_added_os->prev = (lang_output_section_statement_type *)`	`newly_added_os->prev = (lang_output_section_statement_type *)`
`((char *) place->os_tail`	`((char *) place->os_tail`
`- offsetof (lang_output_section_statement_type, next));`	`- offsetof (lang_output_section_statement_type, next));`
`newly_added_os->next = *place->os_tail;`	`newly_added_os->next = *place->os_tail;`
`if (newly_added_os->next != NULL)`	`if (newly_added_os->next != NULL)`
`newly_added_os->next->prev = newly_added_os;`	`newly_added_os->next->prev = newly_added_os;`
`*place->os_tail = newly_added_os;`	`*place->os_tail = newly_added_os;`
`place->os_tail = &newly_added_os->next;`	`place->os_tail = &newly_added_os->next;`

`/* Fixing the global list pointer here is a little different.`	`/* Fixing the global list pointer here is a little different.`
`We added to the list in lang_enter_output_section_statement,`	`We added to the list in lang_enter_output_section_statement,`
`trimmed off the new output_section_statment above when`	`trimmed off the new output_section_statment above when`
`assigning *os_tail = NULL, but possibly added it back in`	`assigning *os_tail = NULL, but possibly added it back in`
`the same place when assigning place->os_tail. /`	`the same place when assigning place->os_tail. /`
`if (*os_tail == NULL)`	`if (*os_tail == NULL)`
`lang_output_section_statement.tail`	`lang_output_section_statement.tail`
`= (lang_statement_union_type **) os_tail;`	`= (lang_statement_union_type **) os_tail;`
`}`	`}`
`}`	`}`
`return os;`	`return os;`
`}`	`}`

`static void`	`static void`
`lang_map_flags (flagword flag)`	`lang_map_flags (flagword flag)`
`{`	`{`
`if (flag & SEC_ALLOC)`	`if (flag & SEC_ALLOC)`
`minfo ("a");`	`minfo ("a");`

`if (flag & SEC_CODE)`	`if (flag & SEC_CODE)`
`minfo ("x");`	`minfo ("x");`

`if (flag & SEC_READONLY)`	`if (flag & SEC_READONLY)`
`minfo ("r");`	`minfo ("r");`

`if (flag & SEC_DATA)`	`if (flag & SEC_DATA)`
`minfo ("w");`	`minfo ("w");`

`if (flag & SEC_LOAD)`	`if (flag & SEC_LOAD)`
`minfo ("l");`	`minfo ("l");`
`}`	`}`

`void`	`void`
`lang_map (void)`	`lang_map (void)`
`{`	`{`
`lang_memory_region_type *m;`	`lang_memory_region_type *m;`
`bfd_boolean dis_header_printed = FALSE;`	`bfd_boolean dis_header_printed = FALSE;`
`bfd *p;`	`bfd *p;`

`LANG_FOR_EACH_INPUT_STATEMENT (file)`	`LANG_FOR_EACH_INPUT_STATEMENT (file)`
`{`	`{`
`asection *s;`	`asection *s;`

`if ((file->the_bfd->flags & (BFD_LINKER_CREATED \| DYNAMIC)) != 0`	`if ((file->the_bfd->flags & (BFD_LINKER_CREATED \| DYNAMIC)) != 0`
`\|\| file->just_syms_flag)`	`\|\| file->just_syms_flag)`
`continue;`	`continue;`

`for (s = file->the_bfd->sections; s != NULL; s = s->next)`	`for (s = file->the_bfd->sections; s != NULL; s = s->next)`
`if ((s->output_section == NULL`	`if ((s->output_section == NULL`
`\|\| s->output_section->owner != link_info.output_bfd)`	`\|\| s->output_section->owner != link_info.output_bfd)`
`&& (s->flags & (SEC_LINKER_CREATED \| SEC_KEEP)) == 0)`	`&& (s->flags & (SEC_LINKER_CREATED \| SEC_KEEP)) == 0)`
`{`	`{`
`if (! dis_header_printed)`	`if (! dis_header_printed)`
`{`	`{`
`fprintf (config.map_file, _("\nDiscarded input sections\n\n"));`	`fprintf (config.map_file, _("\nDiscarded input sections\n\n"));`
`dis_header_printed = TRUE;`	`dis_header_printed = TRUE;`
`}`	`}`

`print_input_section (s, TRUE);`	`print_input_section (s, TRUE);`
`}`	`}`
`}`	`}`

`minfo (_("\nMemory Configuration\n\n"));`	`minfo (_("\nMemory Configuration\n\n"));`
`fprintf (config.map_file, "%-16s %-18s %-18s %s\n",`	`fprintf (config.map_file, "%-16s %-18s %-18s %s\n",`
`_("Name"), _("Origin"), _("Length"), _("Attributes"));`	`_("Name"), _("Origin"), _("Length"), _("Attributes"));`

`for (m = lang_memory_region_list; m != NULL; m = m->next)`	`for (m = lang_memory_region_list; m != NULL; m = m->next)`
`{`	`{`
`char buf[100];`	`char buf[100];`
`int len;`	`int len;`

`fprintf (config.map_file, "%-16s ", m->name_list.name);`	`fprintf (config.map_file, "%-16s ", m->name_list.name);`

`sprintf_vma (buf, m->origin);`	`sprintf_vma (buf, m->origin);`
`minfo ("0x%s ", buf);`	`minfo ("0x%s ", buf);`
`len = strlen (buf);`	`len = strlen (buf);`
`while (len < 16)`	`while (len < 16)`
`{`	`{`
`print_space ();`	`print_space ();`
`++len;`	`++len;`
`}`	`}`

`minfo ("0x%V", m->length);`	`minfo ("0x%V", m->length);`
`if (m->flags \|\| m->not_flags)`	`if (m->flags \|\| m->not_flags)`
`{`	`{`
`#ifndef BFD64`	`#ifndef BFD64`
`minfo (" ");`	`minfo (" ");`
`#endif`	`#endif`
`if (m->flags)`	`if (m->flags)`
`{`	`{`
`print_space ();`	`print_space ();`
`lang_map_flags (m->flags);`	`lang_map_flags (m->flags);`
`}`	`}`

`if (m->not_flags)`	`if (m->not_flags)`
`{`	`{`
`minfo (" !");`	`minfo (" !");`
`lang_map_flags (m->not_flags);`	`lang_map_flags (m->not_flags);`
`}`	`}`
`}`	`}`

`print_nl ();`	`print_nl ();`
`}`	`}`

`fprintf (config.map_file, _("\nLinker script and memory map\n\n"));`	`fprintf (config.map_file, _("\nLinker script and memory map\n\n"));`

`if (! link_info.reduce_memory_overheads)`	`if (! link_info.reduce_memory_overheads)`
`{`	`{`
`obstack_begin (&map_obstack, 1000);`	`obstack_begin (&map_obstack, 1000);`
`for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)`	`for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)`
`bfd_map_over_sections (p, init_map_userdata, 0);`	`bfd_map_over_sections (p, init_map_userdata, 0);`
`bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);`	`bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);`
`}`	`}`
`lang_statement_iteration ++;`	`lang_statement_iteration ++;`
`print_statements ();`	`print_statements ();`
`}`	`}`

`static void`	`static void`
`init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,`	`init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,`
`asection *sec,`	`asection *sec,`
`void *data ATTRIBUTE_UNUSED)`	`void *data ATTRIBUTE_UNUSED)`
`{`	`{`
`fat_section_userdata_type *new_data`	`fat_section_userdata_type *new_data`
`= ((fat_section_userdata_type *) (stat_alloc`	`= ((fat_section_userdata_type *) (stat_alloc`
`(sizeof (fat_section_userdata_type))));`	`(sizeof (fat_section_userdata_type))));`

`ASSERT (get_userdata (sec) == NULL);`	`ASSERT (get_userdata (sec) == NULL);`
`get_userdata (sec) = new_data;`	`get_userdata (sec) = new_data;`
`new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;`	`new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;`
`new_data->map_symbol_def_count = 0;`	`new_data->map_symbol_def_count = 0;`
`}`	`}`

`static bfd_boolean`	`static bfd_boolean`
`sort_def_symbol (struct bfd_link_hash_entry *hash_entry,`	`sort_def_symbol (struct bfd_link_hash_entry *hash_entry,`
`void *info ATTRIBUTE_UNUSED)`	`void *info ATTRIBUTE_UNUSED)`
`{`	`{`
`if (hash_entry->type == bfd_link_hash_defined`	`if (hash_entry->type == bfd_link_hash_defined`
`\|\| hash_entry->type == bfd_link_hash_defweak)`	`\|\| hash_entry->type == bfd_link_hash_defweak)`
`{`	`{`
`struct fat_user_section_struct *ud;`	`struct fat_user_section_struct *ud;`
`struct map_symbol_def *def;`	`struct map_symbol_def *def;`

`ud = (struct fat_user_section_struct *)`	`ud = (struct fat_user_section_struct *)`
`get_userdata (hash_entry->u.def.section);`	`get_userdata (hash_entry->u.def.section);`
`if (! ud)`	`if (! ud)`
`{`	`{`
`/* ??? What do we have to do to initialize this beforehand? */`	`/* ??? What do we have to do to initialize this beforehand? */`
`/* The first time we get here is bfd_abs_section... */`	`/* The first time we get here is bfd_abs_section... */`
`init_map_userdata (0, hash_entry->u.def.section, 0);`	`init_map_userdata (0, hash_entry->u.def.section, 0);`
`ud = (struct fat_user_section_struct *)`	`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)`	`else if (!ud->map_symbol_def_tail)`
`ud->map_symbol_def_tail = &ud->map_symbol_def_head;`	`ud->map_symbol_def_tail = &ud->map_symbol_def_head;`

`def = (struct map_symbol_def ) obstack_alloc (&map_obstack, sizeof def);`	`def = (struct map_symbol_def ) obstack_alloc (&map_obstack, sizeof def);`
`def->entry = hash_entry;`	`def->entry = hash_entry;`
`*(ud->map_symbol_def_tail) = def;`	`*(ud->map_symbol_def_tail) = def;`
`ud->map_symbol_def_tail = &def->next;`	`ud->map_symbol_def_tail = &def->next;`
`ud->map_symbol_def_count++;`	`ud->map_symbol_def_count++;`
`}`	`}`
`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Initialize an output section. */`	`/* Initialize an output section. */`

`static void`	`static void`
`init_os (lang_output_section_statement_type *s, flagword flags)`	`init_os (lang_output_section_statement_type *s, flagword flags)`
`{`	`{`
`if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)`	`if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)`
einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);	einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);

`if (s->constraint != SPECIAL)`	`if (s->constraint != SPECIAL)`
`s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);`	`s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);`
`if (s->bfd_section == NULL)`	`if (s->bfd_section == NULL)`
`s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,`	`s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,`
`s->name, flags);`	`s->name, flags);`
`if (s->bfd_section == NULL)`	`if (s->bfd_section == NULL)`
`{`	`{`
`einfo (_("%P%F: output format %s cannot represent section called %s\n"),`	`einfo (_("%P%F: output format %s cannot represent section called %s\n"),`
`link_info.output_bfd->xvec->name, s->name);`	`link_info.output_bfd->xvec->name, s->name);`
`}`	`}`
`s->bfd_section->output_section = s->bfd_section;`	`s->bfd_section->output_section = s->bfd_section;`
`s->bfd_section->output_offset = 0;`	`s->bfd_section->output_offset = 0;`

`if (!link_info.reduce_memory_overheads)`	`if (!link_info.reduce_memory_overheads)`
`{`	`{`
`fat_section_userdata_type new_userdata = (fat_section_userdata_type )`	`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));`	`memset (new_userdata, 0, sizeof (fat_section_userdata_type));`
`get_userdata (s->bfd_section) = new_userdata;`	`get_userdata (s->bfd_section) = new_userdata;`
`}`	`}`

`/* If there is a base address, make sure that any sections it might`	`/* If there is a base address, make sure that any sections it might`
`mention are initialized. */`	`mention are initialized. */`
`if (s->addr_tree != NULL)`	`if (s->addr_tree != NULL)`
`exp_init_os (s->addr_tree);`	`exp_init_os (s->addr_tree);`

`if (s->load_base != NULL)`	`if (s->load_base != NULL)`
`exp_init_os (s->load_base);`	`exp_init_os (s->load_base);`

`/* If supplied an alignment, set it. */`	`/* If supplied an alignment, set it. */`
`if (s->section_alignment != -1)`	`if (s->section_alignment != -1)`
`s->bfd_section->alignment_power = s->section_alignment;`	`s->bfd_section->alignment_power = s->section_alignment;`
`}`	`}`

`/* Make sure that all output sections mentioned in an expression are`	`/* Make sure that all output sections mentioned in an expression are`
`initialized. */`	`initialized. */`

`static void`	`static void`
`exp_init_os (etree_type *exp)`	`exp_init_os (etree_type *exp)`
`{`	`{`
`switch (exp->type.node_class)`	`switch (exp->type.node_class)`
`{`	`{`
`case etree_assign:`	`case etree_assign:`
`case etree_provide:`	`case etree_provide:`
`exp_init_os (exp->assign.src);`	`exp_init_os (exp->assign.src);`
`break;`	`break;`

`case etree_binary:`	`case etree_binary:`
`exp_init_os (exp->binary.lhs);`	`exp_init_os (exp->binary.lhs);`
`exp_init_os (exp->binary.rhs);`	`exp_init_os (exp->binary.rhs);`
`break;`	`break;`

`case etree_trinary:`	`case etree_trinary:`
`exp_init_os (exp->trinary.cond);`	`exp_init_os (exp->trinary.cond);`
`exp_init_os (exp->trinary.lhs);`	`exp_init_os (exp->trinary.lhs);`
`exp_init_os (exp->trinary.rhs);`	`exp_init_os (exp->trinary.rhs);`
`break;`	`break;`

`case etree_assert:`	`case etree_assert:`
`exp_init_os (exp->assert_s.child);`	`exp_init_os (exp->assert_s.child);`
`break;`	`break;`

`case etree_unary:`	`case etree_unary:`
`exp_init_os (exp->unary.child);`	`exp_init_os (exp->unary.child);`
`break;`	`break;`

`case etree_name:`	`case etree_name:`
`switch (exp->type.node_code)`	`switch (exp->type.node_code)`
`{`	`{`
`case ADDR:`	`case ADDR:`
`case LOADADDR:`	`case LOADADDR:`
`case SIZEOF:`	`case SIZEOF:`
`{`	`{`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`os = lang_output_section_find (exp->name.name);`	`os = lang_output_section_find (exp->name.name);`
`if (os != NULL && os->bfd_section == NULL)`	`if (os != NULL && os->bfd_section == NULL)`
`init_os (os, 0);`	`init_os (os, 0);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`default:`	`default:`
`break;`	`break;`
`}`	`}`
`}`	`}`

`static void`	`static void`
`section_already_linked (bfd abfd, asection sec, void *data)`	`section_already_linked (bfd abfd, asection sec, void *data)`
`{`	`{`
`lang_input_statement_type entry = (lang_input_statement_type ) data;`	`lang_input_statement_type entry = (lang_input_statement_type ) data;`

`/* If we are only reading symbols from this object, then we want to`	`/* If we are only reading symbols from this object, then we want to`
`discard all sections. */`	`discard all sections. */`
`if (entry->just_syms_flag)`	`if (entry->just_syms_flag)`
`{`	`{`
`bfd_link_just_syms (abfd, sec, &link_info);`	`bfd_link_just_syms (abfd, sec, &link_info);`
`return;`	`return;`
`}`	`}`

`if (!(abfd->flags & DYNAMIC))`	`if (!(abfd->flags & DYNAMIC))`
`bfd_section_already_linked (abfd, sec, &link_info);`	`bfd_section_already_linked (abfd, sec, &link_info);`
`}`	`}`

`/* The wild routines.`	`/* The wild routines.`

`These expand statements like *(.text) and foo.o to a list of`	`These expand statements like *(.text) and foo.o to a list of`
`explicit actions, like foo.o(.text), bar.o(.text) and`	`explicit actions, like foo.o(.text), bar.o(.text) and`
`foo.o(.text, .data). */`	`foo.o(.text, .data). */`

`/* Add SECTION to the output section OUTPUT. Do this by creating a`	`/* Add SECTION to the output section OUTPUT. Do this by creating a`
`lang_input_section statement which is placed at PTR. FILE is the`	`lang_input_section statement which is placed at PTR. FILE is the`
`input file which holds SECTION. */`	`input file which holds SECTION. */`

`void`	`void`
`lang_add_section (lang_statement_list_type *ptr,`	`lang_add_section (lang_statement_list_type *ptr,`
`asection *section,`	`asection *section,`
`lang_output_section_statement_type *output)`	`lang_output_section_statement_type *output)`
`{`	`{`
`flagword flags = section->flags;`	`flagword flags = section->flags;`
`struct flag_info *sflag_info = section->section_flag_info;`	`struct flag_info *sflag_info = section->section_flag_info;`

`bfd_boolean discard;`	`bfd_boolean discard;`
`lang_input_section_type *new_section;`	`lang_input_section_type *new_section;`
`bfd *abfd = link_info.output_bfd;`	`bfd *abfd = link_info.output_bfd;`

`/* Discard sections marked with SEC_EXCLUDE. */`	`/* Discard sections marked with SEC_EXCLUDE. */`
`discard = (flags & SEC_EXCLUDE) != 0;`	`discard = (flags & SEC_EXCLUDE) != 0;`

`/* Discard input sections which are assigned to a section named`	`/* Discard input sections which are assigned to a section named`
`DISCARD_SECTION_NAME. */`	`DISCARD_SECTION_NAME. */`
`if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)`	`if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)`
`discard = TRUE;`	`discard = TRUE;`

`/* Discard debugging sections if we are stripping debugging`	`/* Discard debugging sections if we are stripping debugging`
`information. */`	`information. */`
`if ((link_info.strip == strip_debugger \|\| link_info.strip == strip_all)`	`if ((link_info.strip == strip_debugger \|\| link_info.strip == strip_all)`
`&& (flags & SEC_DEBUGGING) != 0)`	`&& (flags & SEC_DEBUGGING) != 0)`
`discard = TRUE;`	`discard = TRUE;`

`if (discard)`	`if (discard)`
`{`	`{`
`if (section->output_section == NULL)`	`if (section->output_section == NULL)`
`{`	`{`
`/* This prevents future calls from assigning this section. */`	`/* This prevents future calls from assigning this section. */`
`section->output_section = bfd_abs_section_ptr;`	`section->output_section = bfd_abs_section_ptr;`
`}`	`}`
`return;`	`return;`
`}`	`}`

`if (sflag_info)`	`if (sflag_info)`
`{`	`{`
`if (sflag_info->flags_initialized == FALSE)`	`if (sflag_info->flags_initialized == FALSE)`
`bfd_lookup_section_flags (&link_info, sflag_info);`	`bfd_lookup_section_flags (&link_info, sflag_info);`

`if (sflag_info->only_with_flags != 0`	`if (sflag_info->only_with_flags != 0`
`&& sflag_info->not_with_flags != 0`	`&& sflag_info->not_with_flags != 0`
`&& ((sflag_info->not_with_flags & flags) != 0`	`&& ((sflag_info->not_with_flags & flags) != 0`
`\|\| (sflag_info->only_with_flags & flags)`	`\|\| (sflag_info->only_with_flags & flags)`
`!= sflag_info->only_with_flags))`	`!= sflag_info->only_with_flags))`
`return;`	`return;`

`if (sflag_info->only_with_flags != 0`	`if (sflag_info->only_with_flags != 0`
`&& (sflag_info->only_with_flags & flags)`	`&& (sflag_info->only_with_flags & flags)`
`!= sflag_info->only_with_flags)`	`!= sflag_info->only_with_flags)`
`return;`	`return;`

`if (sflag_info->not_with_flags != 0`	`if (sflag_info->not_with_flags != 0`
`&& (sflag_info->not_with_flags & flags) != 0)`	`&& (sflag_info->not_with_flags & flags) != 0)`
`return;`	`return;`
`}`	`}`

`if (section->output_section != NULL)`	`if (section->output_section != NULL)`
`return;`	`return;`

`/* We don't copy the SEC_NEVER_LOAD flag from an input section`	`/* We don't copy the SEC_NEVER_LOAD flag from an input section`
`to an output section, because we want to be able to include a`	`to an output section, because we want to be able to include a`
`SEC_NEVER_LOAD section in the middle of an otherwise loaded`	`SEC_NEVER_LOAD section in the middle of an otherwise loaded`
`section (I don't know why we want to do this, but we do).`	`section (I don't know why we want to do this, but we do).`
`build_link_order in ldwrite.c handles this case by turning`	`build_link_order in ldwrite.c handles this case by turning`
`the embedded SEC_NEVER_LOAD section into a fill. */`	`the embedded SEC_NEVER_LOAD section into a fill. */`
`flags &= ~ SEC_NEVER_LOAD;`	`flags &= ~ SEC_NEVER_LOAD;`

`/* If final link, don't copy the SEC_LINK_ONCE flags, they've`	`/* If final link, don't copy the SEC_LINK_ONCE flags, they've`
`already been processed. One reason to do this is that on pe`	`already been processed. One reason to do this is that on pe`
`format targets, .text$foo sections go into .text and it's odd`	`format targets, .text$foo sections go into .text and it's odd`
`to see .text with SEC_LINK_ONCE set. */`	`to see .text with SEC_LINK_ONCE set. */`

`if (!link_info.relocatable)`	`if (!link_info.relocatable)`
`flags &= ~(SEC_LINK_ONCE \| SEC_LINK_DUPLICATES \| SEC_RELOC);`	`flags &= ~(SEC_LINK_ONCE \| SEC_LINK_DUPLICATES \| SEC_RELOC);`

`switch (output->sectype)`	`switch (output->sectype)`
`{`	`{`
`case normal_section:`	`case normal_section:`
`case overlay_section:`	`case overlay_section:`
`break;`	`break;`
`case noalloc_section:`	`case noalloc_section:`
`flags &= ~SEC_ALLOC;`	`flags &= ~SEC_ALLOC;`
`break;`	`break;`
`case noload_section:`	`case noload_section:`
`flags &= ~SEC_LOAD;`	`flags &= ~SEC_LOAD;`
`flags \|= SEC_NEVER_LOAD;`	`flags \|= SEC_NEVER_LOAD;`
`/* Unfortunately GNU ld has managed to evolve two different`	`/* Unfortunately GNU ld has managed to evolve two different`
`meanings to NOLOAD in scripts. ELF gets a .bss style noload,`	`meanings to NOLOAD in scripts. ELF gets a .bss style noload,`
`alloc, no contents section. All others get a noload, noalloc`	`alloc, no contents section. All others get a noload, noalloc`
`section. */`	`section. */`
`if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)`	`if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)`
`flags &= ~SEC_HAS_CONTENTS;`	`flags &= ~SEC_HAS_CONTENTS;`
`else`	`else`
`flags &= ~SEC_ALLOC;`	`flags &= ~SEC_ALLOC;`
`break;`	`break;`
`}`	`}`

`if (output->bfd_section == NULL)`	`if (output->bfd_section == NULL)`
`init_os (output, flags);`	`init_os (output, flags);`

`/* If SEC_READONLY is not set in the input section, then clear`	`/* If SEC_READONLY is not set in the input section, then clear`
`it from the output section. */`	`it from the output section. */`
`output->bfd_section->flags &= flags \| ~SEC_READONLY;`	`output->bfd_section->flags &= flags \| ~SEC_READONLY;`

`if (output->bfd_section->linker_has_input)`	`if (output->bfd_section->linker_has_input)`
`{`	`{`
`/* Only set SEC_READONLY flag on the first input section. */`	`/* Only set SEC_READONLY flag on the first input section. */`
`flags &= ~ SEC_READONLY;`	`flags &= ~ SEC_READONLY;`

`/* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */`	`/* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */`
`if ((output->bfd_section->flags & (SEC_MERGE \| SEC_STRINGS))`	`if ((output->bfd_section->flags & (SEC_MERGE \| SEC_STRINGS))`
`!= (flags & (SEC_MERGE \| SEC_STRINGS))`	`!= (flags & (SEC_MERGE \| SEC_STRINGS))`
`\|\| ((flags & SEC_MERGE) != 0`	`\|\| ((flags & SEC_MERGE) != 0`
`&& output->bfd_section->entsize != section->entsize))`	`&& output->bfd_section->entsize != section->entsize))`
`{`	`{`
`output->bfd_section->flags &= ~ (SEC_MERGE \| SEC_STRINGS);`	`output->bfd_section->flags &= ~ (SEC_MERGE \| SEC_STRINGS);`
`flags &= ~ (SEC_MERGE \| SEC_STRINGS);`	`flags &= ~ (SEC_MERGE \| SEC_STRINGS);`
`}`	`}`
`}`	`}`
`output->bfd_section->flags \|= flags;`	`output->bfd_section->flags \|= flags;`

`if (!output->bfd_section->linker_has_input)`	`if (!output->bfd_section->linker_has_input)`
`{`	`{`
`output->bfd_section->linker_has_input = 1;`	`output->bfd_section->linker_has_input = 1;`
`/* This must happen after flags have been updated. The output`	`/* This must happen after flags have been updated. The output`
`section may have been created before we saw its first input`	`section may have been created before we saw its first input`
`section, eg. for a data statement. */`	`section, eg. for a data statement. */`
`bfd_init_private_section_data (section->owner, section,`	`bfd_init_private_section_data (section->owner, section,`
`link_info.output_bfd,`	`link_info.output_bfd,`
`output->bfd_section,`	`output->bfd_section,`
`&link_info);`	`&link_info);`
`if ((flags & SEC_MERGE) != 0)`	`if ((flags & SEC_MERGE) != 0)`
`output->bfd_section->entsize = section->entsize;`	`output->bfd_section->entsize = section->entsize;`
`}`	`}`

`if ((flags & SEC_TIC54X_BLOCK) != 0`	`if ((flags & SEC_TIC54X_BLOCK) != 0`
`&& bfd_get_arch (section->owner) == bfd_arch_tic54x)`	`&& bfd_get_arch (section->owner) == bfd_arch_tic54x)`
`{`	`{`
`/* FIXME: This value should really be obtained from the bfd... */`	`/* FIXME: This value should really be obtained from the bfd... */`
`output->block_value = 128;`	`output->block_value = 128;`
`}`	`}`

`if (section->alignment_power > output->bfd_section->alignment_power)`	`if (section->alignment_power > output->bfd_section->alignment_power)`
`output->bfd_section->alignment_power = section->alignment_power;`	`output->bfd_section->alignment_power = section->alignment_power;`

`section->output_section = output->bfd_section;`	`section->output_section = output->bfd_section;`

`if (!link_info.relocatable`	`if (!link_info.relocatable`
`&& !stripped_excluded_sections)`	`&& !stripped_excluded_sections)`
`{`	`{`
`asection *s = output->bfd_section->map_tail.s;`	`asection *s = output->bfd_section->map_tail.s;`
`output->bfd_section->map_tail.s = section;`	`output->bfd_section->map_tail.s = section;`
`section->map_head.s = NULL;`	`section->map_head.s = NULL;`
`section->map_tail.s = s;`	`section->map_tail.s = s;`
`if (s != NULL)`	`if (s != NULL)`
`s->map_head.s = section;`	`s->map_head.s = section;`
`else`	`else`
`output->bfd_section->map_head.s = section;`	`output->bfd_section->map_head.s = section;`
`}`	`}`

`/* Add a section reference to the list. */`	`/* Add a section reference to the list. */`
`new_section = new_stat (lang_input_section, ptr);`	`new_section = new_stat (lang_input_section, ptr);`
`new_section->section = section;`	`new_section->section = section;`
`}`	`}`

`/* Handle wildcard sorting. This returns the lang_input_section which`	`/* Handle wildcard sorting. This returns the lang_input_section which`
`should follow the one we are going to create for SECTION and FILE,`	`should follow the one we are going to create for SECTION and FILE,`
`based on the sorting requirements of WILD. It returns NULL if the`	`based on the sorting requirements of WILD. It returns NULL if the`
`new section should just go at the end of the current list. */`	`new section should just go at the end of the current list. */`

`static lang_statement_union_type *`	`static lang_statement_union_type *`
`wild_sort (lang_wild_statement_type *wild,`	`wild_sort (lang_wild_statement_type *wild,`
`struct wildcard_list *sec,`	`struct wildcard_list *sec,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`asection *section)`	`asection *section)`
`{`	`{`
`lang_statement_union_type *l;`	`lang_statement_union_type *l;`

`if (!wild->filenames_sorted`	`if (!wild->filenames_sorted`
`&& (sec == NULL \|\| sec->spec.sorted == none))`	`&& (sec == NULL \|\| sec->spec.sorted == none))`
`return NULL;`	`return NULL;`

`for (l = wild->children.head; l != NULL; l = l->header.next)`	`for (l = wild->children.head; l != NULL; l = l->header.next)`
`{`	`{`
`lang_input_section_type *ls;`	`lang_input_section_type *ls;`

`if (l->header.type != lang_input_section_enum)`	`if (l->header.type != lang_input_section_enum)`
`continue;`	`continue;`
`ls = &l->input_section;`	`ls = &l->input_section;`

`/* Sorting by filename takes precedence over sorting by section`	`/* Sorting by filename takes precedence over sorting by section`
`name. */`	`name. */`

`if (wild->filenames_sorted)`	`if (wild->filenames_sorted)`
`{`	`{`
`const char fn, ln;`	`const char fn, ln;`
`bfd_boolean fa, la;`	`bfd_boolean fa, la;`
`int i;`	`int i;`

`/* The PE support for the .idata section as generated by`	`/* The PE support for the .idata section as generated by`
`dlltool assumes that files will be sorted by the name of`	`dlltool assumes that files will be sorted by the name of`
`the archive and then the name of the file within the`	`the archive and then the name of the file within the`
`archive. */`	`archive. */`

`if (file->the_bfd != NULL`	`if (file->the_bfd != NULL`
`&& bfd_my_archive (file->the_bfd) != NULL)`	`&& bfd_my_archive (file->the_bfd) != NULL)`
`{`	`{`
`fn = bfd_get_filename (bfd_my_archive (file->the_bfd));`	`fn = bfd_get_filename (bfd_my_archive (file->the_bfd));`
`fa = TRUE;`	`fa = TRUE;`
`}`	`}`
`else`	`else`
`{`	`{`
`fn = file->filename;`	`fn = file->filename;`
`fa = FALSE;`	`fa = FALSE;`
`}`	`}`

`if (bfd_my_archive (ls->section->owner) != NULL)`	`if (bfd_my_archive (ls->section->owner) != NULL)`
`{`	`{`
`ln = bfd_get_filename (bfd_my_archive (ls->section->owner));`	`ln = bfd_get_filename (bfd_my_archive (ls->section->owner));`
`la = TRUE;`	`la = TRUE;`
`}`	`}`
`else`	`else`
`{`	`{`
`ln = ls->section->owner->filename;`	`ln = ls->section->owner->filename;`
`la = FALSE;`	`la = FALSE;`
`}`	`}`

`i = filename_cmp (fn, ln);`	`i = filename_cmp (fn, ln);`
`if (i > 0)`	`if (i > 0)`
`continue;`	`continue;`
`else if (i < 0)`	`else if (i < 0)`
`break;`	`break;`

`if (fa \|\| la)`	`if (fa \|\| la)`
`{`	`{`
`if (fa)`	`if (fa)`
`fn = file->filename;`	`fn = file->filename;`
`if (la)`	`if (la)`
`ln = ls->section->owner->filename;`	`ln = ls->section->owner->filename;`

`i = filename_cmp (fn, ln);`	`i = filename_cmp (fn, ln);`
`if (i > 0)`	`if (i > 0)`
`continue;`	`continue;`
`else if (i < 0)`	`else if (i < 0)`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* Here either the files are not sorted by name, or we are`	`/* Here either the files are not sorted by name, or we are`
`looking at the sections for this file. */`	`looking at the sections for this file. */`

`if (sec != NULL && sec->spec.sorted != none)`	`if (sec != NULL && sec->spec.sorted != none)`
`if (compare_section (sec->spec.sorted, section, ls->section) < 0)`	`if (compare_section (sec->spec.sorted, section, ls->section) < 0)`
`break;`	`break;`
`}`	`}`

`return l;`	`return l;`
`}`	`}`

`/* Expand a wild statement for a particular FILE. SECTION may be`	`/* Expand a wild statement for a particular FILE. SECTION may be`
`NULL, in which case it is a wild card. */`	`NULL, in which case it is a wild card. */`

`static void`	`static void`
`output_section_callback (lang_wild_statement_type *ptr,`	`output_section_callback (lang_wild_statement_type *ptr,`
`struct wildcard_list *sec,`	`struct wildcard_list *sec,`
`asection *section,`	`asection *section,`
`lang_input_statement_type *file,`	`lang_input_statement_type *file,`
`void *output)`	`void *output)`
`{`	`{`
`lang_statement_union_type *before;`	`lang_statement_union_type *before;`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`os = (lang_output_section_statement_type *) output;`	`os = (lang_output_section_statement_type *) output;`

`/* Exclude sections that match UNIQUE_SECTION_LIST. */`	`/* Exclude sections that match UNIQUE_SECTION_LIST. */`
`if (unique_section_p (section, os))`	`if (unique_section_p (section, os))`
`return;`	`return;`

`before = wild_sort (ptr, sec, file, section);`	`before = wild_sort (ptr, sec, file, section);`

`/* Here BEFORE points to the lang_input_section which`	`/* Here BEFORE points to the lang_input_section which`
`should follow the one we are about to add. If BEFORE`	`should follow the one we are about to add. If BEFORE`
`is NULL, then the section should just go at the end`	`is NULL, then the section should just go at the end`
`of the current list. */`	`of the current list. */`

`if (before == NULL)`	`if (before == NULL)`
`lang_add_section (&ptr->children, section, os);`	`lang_add_section (&ptr->children, section, os);`
`else`	`else`
`{`	`{`
`lang_statement_list_type list;`	`lang_statement_list_type list;`
`lang_statement_union_type **pp;`	`lang_statement_union_type **pp;`

`lang_list_init (&list);`	`lang_list_init (&list);`
`lang_add_section (&list, section, os);`	`lang_add_section (&list, section, os);`

`/* If we are discarding the section, LIST.HEAD will`	`/* If we are discarding the section, LIST.HEAD will`
`be NULL. */`	`be NULL. */`
`if (list.head != NULL)`	`if (list.head != NULL)`
`{`	`{`
`ASSERT (list.head->header.next == NULL);`	`ASSERT (list.head->header.next == NULL);`

`for (pp = &ptr->children.head;`	`for (pp = &ptr->children.head;`
`*pp != before;`	`*pp != before;`
`pp = &(*pp)->header.next)`	`pp = &(*pp)->header.next)`
`ASSERT (*pp != NULL);`	`ASSERT (*pp != NULL);`

`list.head->header.next = *pp;`	`list.head->header.next = *pp;`
`*pp = list.head;`	`*pp = list.head;`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Check if all sections in a wild statement for a particular FILE`	`/* Check if all sections in a wild statement for a particular FILE`
`are readonly. */`	`are readonly. */`

`static void`	`static void`
`check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,`	`check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,`
`struct wildcard_list *sec ATTRIBUTE_UNUSED,`	`struct wildcard_list *sec ATTRIBUTE_UNUSED,`
`asection *section,`	`asection *section,`
`lang_input_statement_type *file ATTRIBUTE_UNUSED,`	`lang_input_statement_type *file ATTRIBUTE_UNUSED,`
`void *output)`	`void *output)`
`{`	`{`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`os = (lang_output_section_statement_type *) output;`	`os = (lang_output_section_statement_type *) output;`

`/* Exclude sections that match UNIQUE_SECTION_LIST. */`	`/* Exclude sections that match UNIQUE_SECTION_LIST. */`
`if (unique_section_p (section, os))`	`if (unique_section_p (section, os))`
`return;`	`return;`

`if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)`	`if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)`
`os->all_input_readonly = FALSE;`	`os->all_input_readonly = FALSE;`
`}`	`}`

`/* This is passed a file name which must have been seen already and`	`/* 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`	`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. */`	`already and had its symbols read. If not then we'll read it. */`

`static lang_input_statement_type *`	`static lang_input_statement_type *`
`lookup_name (const char *name)`	`lookup_name (const char *name)`
`{`	`{`
`lang_input_statement_type *search;`	`lang_input_statement_type *search;`

`for (search = (lang_input_statement_type *) input_file_chain.head;`	`for (search = (lang_input_statement_type *) input_file_chain.head;`
`search != NULL;`	`search != NULL;`
`search = (lang_input_statement_type *) search->next_real_file)`	`search = (lang_input_statement_type *) search->next_real_file)`
`{`	`{`
`/* Use the local_sym_name as the name of the file that has`	`/* Use the local_sym_name as the name of the file that has`
`already been loaded as filename might have been transformed`	`already been loaded as filename might have been transformed`
`via the search directory lookup mechanism. */`	`via the search directory lookup mechanism. */`
`const char *filename = search->local_sym_name;`	`const char *filename = search->local_sym_name;`

`if (filename != NULL`	`if (filename != NULL`
`&& filename_cmp (filename, name) == 0)`	`&& filename_cmp (filename, name) == 0)`
`break;`	`break;`
`}`	`}`

`if (search == NULL)`	`if (search == NULL)`
`search = new_afile (name, lang_input_file_is_search_file_enum,`	`search = new_afile (name, lang_input_file_is_search_file_enum,`
`default_target, FALSE);`	`default_target, FALSE);`

`/* If we have already added this file, or this file is not real`	`/* If we have already added this file, or this file is not real`
`don't add this file. */`	`don't add this file. */`
`if (search->loaded \|\| !search->real)`	`if (search->loaded \|\| !search->real)`
`return search;`	`return search;`

`if (! load_symbols (search, NULL))`	`if (! load_symbols (search, NULL))`
`return NULL;`	`return NULL;`

`return search;`	`return search;`
`}`	`}`

`/* Save LIST as a list of libraries whose symbols should not be exported. */`	`/* Save LIST as a list of libraries whose symbols should not be exported. */`

`struct excluded_lib`	`struct excluded_lib`
`{`	`{`
`char *name;`	`char *name;`
`struct excluded_lib *next;`	`struct excluded_lib *next;`
`};`	`};`
`static struct excluded_lib *excluded_libs;`	`static struct excluded_lib *excluded_libs;`

`void`	`void`
`add_excluded_libs (const char *list)`	`add_excluded_libs (const char *list)`
`{`	`{`
`const char p = list, end;`	`const char p = list, end;`

`while (*p != '\0')`	`while (*p != '\0')`
`{`	`{`
`struct excluded_lib *entry;`	`struct excluded_lib *entry;`
`end = strpbrk (p, ",:");`	`end = strpbrk (p, ",:");`
`if (end == NULL)`	`if (end == NULL)`
`end = p + strlen (p);`	`end = p + strlen (p);`
`entry = (struct excluded_lib ) xmalloc (sizeof (entry));`	`entry = (struct excluded_lib ) xmalloc (sizeof (entry));`
`entry->next = excluded_libs;`	`entry->next = excluded_libs;`
`entry->name = (char *) xmalloc (end - p + 1);`	`entry->name = (char *) xmalloc (end - p + 1);`
`memcpy (entry->name, p, end - p);`	`memcpy (entry->name, p, end - p);`
`entry->name[end - p] = '\0';`	`entry->name[end - p] = '\0';`
`excluded_libs = entry;`	`excluded_libs = entry;`
`if (*end == '\0')`	`if (*end == '\0')`
`break;`	`break;`
`p = end + 1;`	`p = end + 1;`
`}`	`}`
`}`	`}`

`static void`	`static void`
`check_excluded_libs (bfd *abfd)`	`check_excluded_libs (bfd *abfd)`
`{`	`{`
`struct excluded_lib *lib = excluded_libs;`	`struct excluded_lib *lib = excluded_libs;`

`while (lib)`	`while (lib)`
`{`	`{`
`int len = strlen (lib->name);`	`int len = strlen (lib->name);`
`const char *filename = lbasename (abfd->filename);`	`const char *filename = lbasename (abfd->filename);`

`if (strcmp (lib->name, "ALL") == 0)`	`if (strcmp (lib->name, "ALL") == 0)`
`{`	`{`
`abfd->no_export = TRUE;`	`abfd->no_export = TRUE;`
`return;`	`return;`
`}`	`}`

`if (filename_ncmp (lib->name, filename, len) == 0`	`if (filename_ncmp (lib->name, filename, len) == 0`
`&& (filename[len] == '\0'`	`&& (filename[len] == '\0'`
`\|\| (filename[len] == '.' && filename[len + 1] == 'a'`	`\|\| (filename[len] == '.' && filename[len + 1] == 'a'`
`&& filename[len + 2] == '\0')))`	`&& filename[len + 2] == '\0')))`
`{`	`{`
`abfd->no_export = TRUE;`	`abfd->no_export = TRUE;`
`return;`	`return;`
`}`	`}`

`lib = lib->next;`	`lib = lib->next;`
`}`	`}`
`}`	`}`

`/* Get the symbols for an input file. */`	`/* Get the symbols for an input file. */`

`bfd_boolean`	`bfd_boolean`
`load_symbols (lang_input_statement_type *entry,`	`load_symbols (lang_input_statement_type *entry,`
`lang_statement_list_type *place)`	`lang_statement_list_type *place)`
`{`	`{`
`char **matching;`	`char **matching;`

`if (entry->loaded)`	`if (entry->loaded)`
`return TRUE;`	`return TRUE;`

`ldfile_open_file (entry);`	`ldfile_open_file (entry);`

`/* Do not process further if the file was missing. */`	`/* Do not process further if the file was missing. */`
`if (entry->missing_file)`	`if (entry->missing_file)`
`return TRUE;`	`return TRUE;`

`if (! bfd_check_format (entry->the_bfd, bfd_archive)`	`if (! bfd_check_format (entry->the_bfd, bfd_archive)`
`&& ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))`	`&& ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))`
`{`	`{`
`bfd_error_type err;`	`bfd_error_type err;`
`bfd_boolean save_ldlang_sysrooted_script;`	`bfd_boolean save_ldlang_sysrooted_script;`
`bfd_boolean save_add_DT_NEEDED_for_regular;`	`bfd_boolean save_add_DT_NEEDED_for_regular;`
`bfd_boolean save_add_DT_NEEDED_for_dynamic;`	`bfd_boolean save_add_DT_NEEDED_for_dynamic;`
`bfd_boolean save_whole_archive;`	`bfd_boolean save_whole_archive;`

`err = bfd_get_error ();`	`err = bfd_get_error ();`

`/* See if the emulation has some special knowledge. */`	`/* See if the emulation has some special knowledge. */`
`if (ldemul_unrecognized_file (entry))`	`if (ldemul_unrecognized_file (entry))`
`return TRUE;`	`return TRUE;`

`if (err == bfd_error_file_ambiguously_recognized)`	`if (err == bfd_error_file_ambiguously_recognized)`
`{`	`{`
`char **p;`	`char **p;`

`einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);`	`einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);`
`einfo (_("%B: matching formats:"), entry->the_bfd);`	`einfo (_("%B: matching formats:"), entry->the_bfd);`
`for (p = matching; *p != NULL; p++)`	`for (p = matching; *p != NULL; p++)`
`einfo (" %s", *p);`	`einfo (" %s", *p);`
`einfo ("%F\n");`	`einfo ("%F\n");`
`}`	`}`
`else if (err != bfd_error_file_not_recognized`	`else if (err != bfd_error_file_not_recognized`
`\|\| place == NULL)`	`\|\| place == NULL)`
`einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);`	`einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);`

`bfd_close (entry->the_bfd);`	`bfd_close (entry->the_bfd);`
`entry->the_bfd = NULL;`	`entry->the_bfd = NULL;`

`/* Try to interpret the file as a linker script. */`	`/* Try to interpret the file as a linker script. */`
`ldfile_open_command_file (entry->filename);`	`ldfile_open_command_file (entry->filename);`

`push_stat_ptr (place);`	`push_stat_ptr (place);`
`save_ldlang_sysrooted_script = ldlang_sysrooted_script;`	`save_ldlang_sysrooted_script = ldlang_sysrooted_script;`
`ldlang_sysrooted_script = entry->sysrooted;`	`ldlang_sysrooted_script = entry->sysrooted;`
`save_add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;`	`save_add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;`
`add_DT_NEEDED_for_regular = entry->add_DT_NEEDED_for_regular;`	`add_DT_NEEDED_for_regular = entry->add_DT_NEEDED_for_regular;`
`save_add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;`	`save_add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;`
`add_DT_NEEDED_for_dynamic = entry->add_DT_NEEDED_for_dynamic;`	`add_DT_NEEDED_for_dynamic = entry->add_DT_NEEDED_for_dynamic;`
`save_whole_archive = whole_archive;`	`save_whole_archive = whole_archive;`
`whole_archive = entry->whole_archive;`	`whole_archive = entry->whole_archive;`

`ldfile_assumed_script = TRUE;`	`ldfile_assumed_script = TRUE;`
`parser_input = input_script;`	`parser_input = input_script;`
`/* We want to use the same -Bdynamic/-Bstatic as the one for`	`/* We want to use the same -Bdynamic/-Bstatic as the one for`
`ENTRY. */`	`ENTRY. */`
`config.dynamic_link = entry->dynamic;`	`config.dynamic_link = entry->dynamic;`
`yyparse ();`	`yyparse ();`
`ldfile_assumed_script = FALSE;`	`ldfile_assumed_script = FALSE;`

`ldlang_sysrooted_script = save_ldlang_sysrooted_script;`	`ldlang_sysrooted_script = save_ldlang_sysrooted_script;`
`add_DT_NEEDED_for_regular = save_add_DT_NEEDED_for_regular;`	`add_DT_NEEDED_for_regular = save_add_DT_NEEDED_for_regular;`
`add_DT_NEEDED_for_dynamic = save_add_DT_NEEDED_for_dynamic;`	`add_DT_NEEDED_for_dynamic = save_add_DT_NEEDED_for_dynamic;`
`whole_archive = save_whole_archive;`	`whole_archive = save_whole_archive;`
`pop_stat_ptr ();`	`pop_stat_ptr ();`

`return TRUE;`	`return TRUE;`
`}`	`}`

`if (ldemul_recognized_file (entry))`	`if (ldemul_recognized_file (entry))`
`return TRUE;`	`return TRUE;`

`/* We don't call ldlang_add_file for an archive. Instead, the`	`/* We don't call ldlang_add_file for an archive. Instead, the`
`add_symbols entry point will call ldlang_add_file, via the`	`add_symbols entry point will call ldlang_add_file, via the`
`add_archive_element callback, for each element of the archive`	`add_archive_element callback, for each element of the archive`
`which is used. */`	`which is used. */`
`switch (bfd_get_format (entry->the_bfd))`	`switch (bfd_get_format (entry->the_bfd))`
`{`	`{`
`default:`	`default:`
`break;`	`break;`

`case bfd_object:`	`case bfd_object:`
	`#ifdef ENABLE_PLUGINS`
	`if (!entry->reload)`
	`#endif`
`ldlang_add_file (entry);`	`ldlang_add_file (entry);`
`if (trace_files \|\| trace_file_tries)`	`if (trace_files \|\| trace_file_tries)`
`info_msg ("%I\n", entry);`	`info_msg ("%I\n", entry);`
`break;`	`break;`

`case bfd_archive:`	`case bfd_archive:`
`check_excluded_libs (entry->the_bfd);`	`check_excluded_libs (entry->the_bfd);`

`if (entry->whole_archive)`	`if (entry->whole_archive)`
`{`	`{`
`bfd *member = NULL;`	`bfd *member = NULL;`
`bfd_boolean loaded = TRUE;`	`bfd_boolean loaded = TRUE;`

`for (;;)`	`for (;;)`
`{`	`{`
`bfd *subsbfd;`	`bfd *subsbfd;`
`member = bfd_openr_next_archived_file (entry->the_bfd, member);`	`member = bfd_openr_next_archived_file (entry->the_bfd, member);`

`if (member == NULL)`	`if (member == NULL)`
`break;`	`break;`

`if (! bfd_check_format (member, bfd_object))`	`if (! bfd_check_format (member, bfd_object))`
`{`	`{`
`einfo (_("%F%B: member %B in archive is not an object\n"),`	`einfo (_("%F%B: member %B in archive is not an object\n"),`
`entry->the_bfd, member);`	`entry->the_bfd, member);`
`loaded = FALSE;`	`loaded = FALSE;`
`}`	`}`

`subsbfd = member;`	`subsbfd = member;`
`if (!(*link_info.callbacks`	`if (!(*link_info.callbacks`
`->add_archive_element) (&link_info, member,`	`->add_archive_element) (&link_info, member,`
`"--whole-archive", &subsbfd))`	`"--whole-archive", &subsbfd))`
`abort ();`	`abort ();`

`/* Potentially, the add_archive_element hook may have set a`	`/* Potentially, the add_archive_element hook may have set a`
`substitute BFD for us. */`	`substitute BFD for us. */`
`if (!bfd_link_add_symbols (subsbfd, &link_info))`	`if (!bfd_link_add_symbols (subsbfd, &link_info))`
`{`	`{`
`einfo (_("%F%B: could not read symbols: %E\n"), member);`	`einfo (_("%F%B: could not read symbols: %E\n"), member);`
`loaded = FALSE;`	`loaded = FALSE;`
`}`	`}`
`}`	`}`

`entry->loaded = loaded;`	`entry->loaded = loaded;`
`return loaded;`	`return loaded;`
`}`	`}`
`break;`	`break;`
`}`	`}`

`if (bfd_link_add_symbols (entry->the_bfd, &link_info))`	`if (bfd_link_add_symbols (entry->the_bfd, &link_info))`
`entry->loaded = TRUE;`	`entry->loaded = TRUE;`
`else`	`else`
`einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);`	`einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);`

`return entry->loaded;`	`return entry->loaded;`
`}`	`}`

`/* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both`	`/* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both`
`may be NULL, indicating that it is a wildcard. Separate`	`may be NULL, indicating that it is a wildcard. Separate`
`lang_input_section statements are created for each part of the`	`lang_input_section statements are created for each part of the`
`expansion; they are added after the wild statement S. OUTPUT is`	`expansion; they are added after the wild statement S. OUTPUT is`
`the output section. */`	`the output section. */`

`static void`	`static void`
`wild (lang_wild_statement_type *s,`	`wild (lang_wild_statement_type *s,`
`const char *target ATTRIBUTE_UNUSED,`	`const char *target ATTRIBUTE_UNUSED,`
`lang_output_section_statement_type *output)`	`lang_output_section_statement_type *output)`
`{`	`{`
`struct wildcard_list *sec;`	`struct wildcard_list *sec;`

`if (s->handler_data[0]`	`if (s->handler_data[0]`
`&& s->handler_data[0]->spec.sorted == by_name`	`&& s->handler_data[0]->spec.sorted == by_name`
`&& !s->filenames_sorted)`	`&& !s->filenames_sorted)`
`{`	`{`
`lang_section_bst_type *tree;`	`lang_section_bst_type *tree;`

`walk_wild (s, output_section_callback_fast, output);`	`walk_wild (s, output_section_callback_fast, output);`

`tree = s->tree;`	`tree = s->tree;`
`if (tree)`	`if (tree)`
`{`	`{`
`output_section_callback_tree_to_list (s, tree, output);`	`output_section_callback_tree_to_list (s, tree, output);`
`s->tree = NULL;`	`s->tree = NULL;`
`}`	`}`
`}`	`}`
`else`	`else`
`walk_wild (s, output_section_callback, output);`	`walk_wild (s, output_section_callback, output);`

`if (default_common_section == NULL)`	`if (default_common_section == NULL)`
`for (sec = s->section_list; sec != NULL; sec = sec->next)`	`for (sec = s->section_list; sec != NULL; sec = sec->next)`
`if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)`	`if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)`
`{`	`{`
`/* Remember the section that common is going to in case we`	`/* Remember the section that common is going to in case we`
`later get something which doesn't know where to put it. */`	`later get something which doesn't know where to put it. */`
`default_common_section = output;`	`default_common_section = output;`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* Return TRUE iff target is the sought target. */`	`/* Return TRUE iff target is the sought target. */`

`static int`	`static int`
`get_target (const bfd_target target, void data)`	`get_target (const bfd_target target, void data)`
`{`	`{`
`const char sought = (const char ) data;`	`const char sought = (const char ) data;`

`return strcmp (target->name, sought) == 0;`	`return strcmp (target->name, sought) == 0;`
`}`	`}`

`/* Like strcpy() but convert to lower case as well. */`	`/* Like strcpy() but convert to lower case as well. */`

`static void`	`static void`
`stricpy (char dest, char src)`	`stricpy (char dest, char src)`
`{`	`{`
`char c;`	`char c;`

`while ((c = *src++) != 0)`	`while ((c = *src++) != 0)`
`*dest++ = TOLOWER (c);`	`*dest++ = TOLOWER (c);`

`*dest = 0;`	`*dest = 0;`
`}`	`}`

`/* Remove the first occurrence of needle (if any) in haystack`	`/* Remove the first occurrence of needle (if any) in haystack`
`from haystack. */`	`from haystack. */`

`static void`	`static void`
`strcut (char haystack, char needle)`	`strcut (char haystack, char needle)`
`{`	`{`
`haystack = strstr (haystack, needle);`	`haystack = strstr (haystack, needle);`

`if (haystack)`	`if (haystack)`
`{`	`{`
`char *src;`	`char *src;`

`for (src = haystack + strlen (needle); *src;)`	`for (src = haystack + strlen (needle); *src;)`
`haystack++ = src++;`	`haystack++ = src++;`

`*haystack = 0;`	`*haystack = 0;`
`}`	`}`
`}`	`}`

`/* Compare two target format name strings.`	`/* Compare two target format name strings.`
`Return a value indicating how "similar" they are. */`	`Return a value indicating how "similar" they are. */`

`static int`	`static int`
`name_compare (char first, char second)`	`name_compare (char first, char second)`
`{`	`{`
`char *copy1;`	`char *copy1;`
`char *copy2;`	`char *copy2;`
`int result;`	`int result;`

`copy1 = (char *) xmalloc (strlen (first) + 1);`	`copy1 = (char *) xmalloc (strlen (first) + 1);`
`copy2 = (char *) xmalloc (strlen (second) + 1);`	`copy2 = (char *) xmalloc (strlen (second) + 1);`

`/* Convert the names to lower case. */`	`/* Convert the names to lower case. */`
`stricpy (copy1, first);`	`stricpy (copy1, first);`
`stricpy (copy2, second);`	`stricpy (copy2, second);`

`/* Remove size and endian strings from the name. */`	`/* Remove size and endian strings from the name. */`
`strcut (copy1, "big");`	`strcut (copy1, "big");`
`strcut (copy1, "little");`	`strcut (copy1, "little");`
`strcut (copy2, "big");`	`strcut (copy2, "big");`
`strcut (copy2, "little");`	`strcut (copy2, "little");`

`/* Return a value based on how many characters match,`	`/* Return a value based on how many characters match,`
`starting from the beginning. If both strings are`	`starting from the beginning. If both strings are`
`the same then return 10 * their length. */`	`the same then return 10 * their length. */`
`for (result = 0; copy1[result] == copy2[result]; result++)`	`for (result = 0; copy1[result] == copy2[result]; result++)`
`if (copy1[result] == 0)`	`if (copy1[result] == 0)`
`{`	`{`
`result *= 10;`	`result *= 10;`
`break;`	`break;`
`}`	`}`

`free (copy1);`	`free (copy1);`
`free (copy2);`	`free (copy2);`

`return result;`	`return result;`
`}`	`}`

`/* Set by closest_target_match() below. */`	`/* Set by closest_target_match() below. */`
`static const bfd_target *winner;`	`static const bfd_target *winner;`

`/* Scan all the valid bfd targets looking for one that has the endianness`	`/* Scan all the valid bfd targets looking for one that has the endianness`
`requirement that was specified on the command line, and is the nearest`	`requirement that was specified on the command line, and is the nearest`
`match to the original output target. */`	`match to the original output target. */`

`static int`	`static int`
`closest_target_match (const bfd_target target, void data)`	`closest_target_match (const bfd_target target, void data)`
`{`	`{`
`const bfd_target original = (const bfd_target ) data;`	`const bfd_target original = (const bfd_target ) data;`

`if (command_line.endian == ENDIAN_BIG`	`if (command_line.endian == ENDIAN_BIG`
`&& target->byteorder != BFD_ENDIAN_BIG)`	`&& target->byteorder != BFD_ENDIAN_BIG)`
`return 0;`	`return 0;`

`if (command_line.endian == ENDIAN_LITTLE`	`if (command_line.endian == ENDIAN_LITTLE`
`&& target->byteorder != BFD_ENDIAN_LITTLE)`	`&& target->byteorder != BFD_ENDIAN_LITTLE)`
`return 0;`	`return 0;`

`/* Must be the same flavour. */`	`/* Must be the same flavour. */`
`if (target->flavour != original->flavour)`	`if (target->flavour != original->flavour)`
`return 0;`	`return 0;`

`/* Ignore generic big and little endian elf vectors. */`	`/* Ignore generic big and little endian elf vectors. */`
`if (strcmp (target->name, "elf32-big") == 0`	`if (strcmp (target->name, "elf32-big") == 0`
`\|\| strcmp (target->name, "elf64-big") == 0`	`\|\| strcmp (target->name, "elf64-big") == 0`
`\|\| strcmp (target->name, "elf32-little") == 0`	`\|\| strcmp (target->name, "elf32-little") == 0`
`\|\| strcmp (target->name, "elf64-little") == 0)`	`\|\| strcmp (target->name, "elf64-little") == 0)`
`return 0;`	`return 0;`

`/* If we have not found a potential winner yet, then record this one. */`	`/* If we have not found a potential winner yet, then record this one. */`
`if (winner == NULL)`	`if (winner == NULL)`
`{`	`{`
`winner = target;`	`winner = target;`
`return 0;`	`return 0;`
`}`	`}`

`/* Oh dear, we now have two potential candidates for a successful match.`	`/* Oh dear, we now have two potential candidates for a successful match.`
`Compare their names and choose the better one. */`	`Compare their names and choose the better one. */`
`if (name_compare (target->name, original->name)`	`if (name_compare (target->name, original->name)`
`> name_compare (winner->name, original->name))`	`> name_compare (winner->name, original->name))`
`winner = target;`	`winner = target;`

`/* Keep on searching until wqe have checked them all. */`	`/* Keep on searching until wqe have checked them all. */`
`return 0;`	`return 0;`
`}`	`}`

`/* Return the BFD target format of the first input file. */`	`/* Return the BFD target format of the first input file. */`

`static char *`	`static char *`
`get_first_input_target (void)`	`get_first_input_target (void)`
`{`	`{`
`char *target = NULL;`	`char *target = NULL;`

`LANG_FOR_EACH_INPUT_STATEMENT (s)`	`LANG_FOR_EACH_INPUT_STATEMENT (s)`
`{`	`{`
`if (s->header.type == lang_input_statement_enum`	`if (s->header.type == lang_input_statement_enum`
`&& s->real)`	`&& s->real)`
`{`	`{`
`ldfile_open_file (s);`	`ldfile_open_file (s);`

`if (s->the_bfd != NULL`	`if (s->the_bfd != NULL`
`&& bfd_check_format (s->the_bfd, bfd_object))`	`&& bfd_check_format (s->the_bfd, bfd_object))`
`{`	`{`
`target = bfd_get_target (s->the_bfd);`	`target = bfd_get_target (s->the_bfd);`

`if (target != NULL)`	`if (target != NULL)`
`break;`	`break;`
`}`	`}`
`}`	`}`
`}`	`}`

`return target;`	`return target;`
`}`	`}`

`const char *`	`const char *`
`lang_get_output_target (void)`	`lang_get_output_target (void)`
`{`	`{`
`const char *target;`	`const char *target;`

`/* Has the user told us which output format to use? */`	`/* Has the user told us which output format to use? */`
`if (output_target != NULL)`	`if (output_target != NULL)`
`return output_target;`	`return output_target;`

`/* No - has the current target been set to something other than`	`/* No - has the current target been set to something other than`
`the default? */`	`the default? */`
`if (current_target != default_target && current_target != NULL)`	`if (current_target != default_target && current_target != NULL)`
`return current_target;`	`return current_target;`

`/* No - can we determine the format of the first input file? */`	`/* No - can we determine the format of the first input file? */`
`target = get_first_input_target ();`	`target = get_first_input_target ();`
`if (target != NULL)`	`if (target != NULL)`
`return target;`	`return target;`

`/* Failed - use the default output target. */`	`/* Failed - use the default output target. */`
`return default_target;`	`return default_target;`
`}`	`}`

`/* Open the output file. */`	`/* Open the output file. */`

`static void`	`static void`
`open_output (const char *name)`	`open_output (const char *name)`
`{`	`{`
`output_target = lang_get_output_target ();`	`output_target = lang_get_output_target ();`

`/* Has the user requested a particular endianness on the command`	`/* Has the user requested a particular endianness on the command`
`line? */`	`line? */`
`if (command_line.endian != ENDIAN_UNSET)`	`if (command_line.endian != ENDIAN_UNSET)`
`{`	`{`
`const bfd_target *target;`	`const bfd_target *target;`
`enum bfd_endian desired_endian;`	`enum bfd_endian desired_endian;`

`/* Get the chosen target. */`	`/* Get the chosen target. */`
`target = bfd_search_for_target (get_target, (void *) output_target);`	`target = bfd_search_for_target (get_target, (void *) output_target);`

`/* If the target is not supported, we cannot do anything. */`	`/* If the target is not supported, we cannot do anything. */`
`if (target != NULL)`	`if (target != NULL)`
`{`	`{`
`if (command_line.endian == ENDIAN_BIG)`	`if (command_line.endian == ENDIAN_BIG)`
`desired_endian = BFD_ENDIAN_BIG;`	`desired_endian = BFD_ENDIAN_BIG;`
`else`	`else`
`desired_endian = BFD_ENDIAN_LITTLE;`	`desired_endian = BFD_ENDIAN_LITTLE;`

`/* See if the target has the wrong endianness. This should`	`/* See if the target has the wrong endianness. This should`
`not happen if the linker script has provided big and`	`not happen if the linker script has provided big and`
`little endian alternatives, but some scrips don't do`	`little endian alternatives, but some scrips don't do`
`this. */`	`this. */`
`if (target->byteorder != desired_endian)`	`if (target->byteorder != desired_endian)`
`{`	`{`
`/* If it does, then see if the target provides`	`/* If it does, then see if the target provides`
`an alternative with the correct endianness. */`	`an alternative with the correct endianness. */`
`if (target->alternative_target != NULL`	`if (target->alternative_target != NULL`
`&& (target->alternative_target->byteorder == desired_endian))`	`&& (target->alternative_target->byteorder == desired_endian))`
`output_target = target->alternative_target->name;`	`output_target = target->alternative_target->name;`
`else`	`else`
`{`	`{`
`/* Try to find a target as similar as possible to`	`/* Try to find a target as similar as possible to`
`the default target, but which has the desired`	`the default target, but which has the desired`
`endian characteristic. */`	`endian characteristic. */`
`bfd_search_for_target (closest_target_match,`	`bfd_search_for_target (closest_target_match,`
`(void *) target);`	`(void *) target);`

`/* Oh dear - we could not find any targets that`	`/* Oh dear - we could not find any targets that`
`satisfy our requirements. */`	`satisfy our requirements. */`
`if (winner == NULL)`	`if (winner == NULL)`
`einfo (_("%P: warning: could not find any targets"`	`einfo (_("%P: warning: could not find any targets"`
`" that match endianness requirement\n"));`	`" that match endianness requirement\n"));`
`else`	`else`
`output_target = winner->name;`	`output_target = winner->name;`
`}`	`}`
`}`	`}`
`}`	`}`
`}`	`}`

`link_info.output_bfd = bfd_openw (name, output_target);`	`link_info.output_bfd = bfd_openw (name, output_target);`

`if (link_info.output_bfd == NULL)`	`if (link_info.output_bfd == NULL)`
`{`	`{`
`if (bfd_get_error () == bfd_error_invalid_target)`	`if (bfd_get_error () == bfd_error_invalid_target)`
`einfo (_("%P%F: target %s not found\n"), output_target);`	`einfo (_("%P%F: target %s not found\n"), output_target);`

`einfo (_("%P%F: cannot open output file %s: %E\n"), name);`	`einfo (_("%P%F: cannot open output file %s: %E\n"), name);`
`}`	`}`

`delete_output_file_on_failure = TRUE;`	`delete_output_file_on_failure = TRUE;`

`if (! bfd_set_format (link_info.output_bfd, bfd_object))`	`if (! bfd_set_format (link_info.output_bfd, bfd_object))`
`einfo (_("%P%F:%s: can not make object file: %E\n"), name);`	`einfo (_("%P%F:%s: can not make object file: %E\n"), name);`
`if (! bfd_set_arch_mach (link_info.output_bfd,`	`if (! bfd_set_arch_mach (link_info.output_bfd,`
`ldfile_output_architecture,`	`ldfile_output_architecture,`
`ldfile_output_machine))`	`ldfile_output_machine))`
`einfo (_("%P%F:%s: can not set architecture: %E\n"), name);`	`einfo (_("%P%F:%s: can not set architecture: %E\n"), name);`

`link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);`	`link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);`
`if (link_info.hash == NULL)`	`if (link_info.hash == NULL)`
`einfo (_("%P%F: can not create hash table: %E\n"));`	`einfo (_("%P%F: can not create hash table: %E\n"));`

`bfd_set_gp_size (link_info.output_bfd, g_switch_value);`	`bfd_set_gp_size (link_info.output_bfd, g_switch_value);`
`}`	`}`

`static void`	`static void`
`ldlang_open_output (lang_statement_union_type *statement)`	`ldlang_open_output (lang_statement_union_type *statement)`
`{`	`{`
`switch (statement->header.type)`	`switch (statement->header.type)`
`{`	`{`
`case lang_output_statement_enum:`	`case lang_output_statement_enum:`
`ASSERT (link_info.output_bfd == NULL);`	`ASSERT (link_info.output_bfd == NULL);`
`open_output (statement->output_statement.name);`	`open_output (statement->output_statement.name);`
`ldemul_set_output_arch ();`	`ldemul_set_output_arch ();`
`if (config.magic_demand_paged && !link_info.relocatable)`	`if (config.magic_demand_paged && !link_info.relocatable)`
`link_info.output_bfd->flags \|= D_PAGED;`	`link_info.output_bfd->flags \|= D_PAGED;`
`else`	`else`
`link_info.output_bfd->flags &= ~D_PAGED;`	`link_info.output_bfd->flags &= ~D_PAGED;`
`if (config.text_read_only)`	`if (config.text_read_only)`
`link_info.output_bfd->flags \|= WP_TEXT;`	`link_info.output_bfd->flags \|= WP_TEXT;`
`else`	`else`
`link_info.output_bfd->flags &= ~WP_TEXT;`	`link_info.output_bfd->flags &= ~WP_TEXT;`
`if (link_info.traditional_format)`	`if (link_info.traditional_format)`
`link_info.output_bfd->flags \|= BFD_TRADITIONAL_FORMAT;`	`link_info.output_bfd->flags \|= BFD_TRADITIONAL_FORMAT;`
`else`	`else`
`link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;`	`link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;`
`break;`	`break;`

`case lang_target_statement_enum:`	`case lang_target_statement_enum:`
`current_target = statement->target_statement.target;`	`current_target = statement->target_statement.target;`
`break;`	`break;`
`default:`	`default:`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* Convert between addresses in bytes and sizes in octets.`	`/* Convert between addresses in bytes and sizes in octets.`
`For currently supported targets, octets_per_byte is always a power`	`For currently supported targets, octets_per_byte is always a power`
`of two, so we can use shifts. */`	`of two, so we can use shifts. */`
`#define TO_ADDR(X) ((X) >> opb_shift)`	`#define TO_ADDR(X) ((X) >> opb_shift)`
`#define TO_SIZE(X) ((X) << opb_shift)`	`#define TO_SIZE(X) ((X) << opb_shift)`

`/* Support the above. */`	`/* Support the above. */`
`static unsigned int opb_shift = 0;`	`static unsigned int opb_shift = 0;`

`static void`	`static void`
`init_opb (void)`	`init_opb (void)`
`{`	`{`
`unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,`	`unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,`
`ldfile_output_machine);`	`ldfile_output_machine);`
`opb_shift = 0;`	`opb_shift = 0;`
`if (x > 1)`	`if (x > 1)`
`while ((x & 1) == 0)`	`while ((x & 1) == 0)`
`{`	`{`
`x >>= 1;`	`x >>= 1;`
`++opb_shift;`	`++opb_shift;`
`}`	`}`
`ASSERT (x == 1);`	`ASSERT (x == 1);`
`}`	`}`

`/* Open all the input files. */`	`/* Open all the input files. */`

`enum open_bfd_mode`	`enum open_bfd_mode`
`{`	`{`
`OPEN_BFD_NORMAL = 0,`	`OPEN_BFD_NORMAL = 0,`
`OPEN_BFD_FORCE = 1,`	`OPEN_BFD_FORCE = 1,`
`OPEN_BFD_RESCAN = 2`	`OPEN_BFD_RESCAN = 2`
`};`	`};`
`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`static lang_input_statement_type *plugin_insert = NULL;`	`static lang_input_statement_type *plugin_insert = NULL;`
`#endif`	`#endif`

`static void`	`static void`
`open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode)`	`open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode)`
`{`	`{`
`for (; s != NULL; s = s->header.next)`	`for (; s != NULL; s = s->header.next)`
`{`	`{`
`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`open_input_bfds (constructor_list.head, mode);`	`open_input_bfds (constructor_list.head, mode);`
`break;`	`break;`
`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`open_input_bfds (s->output_section_statement.children.head, mode);`	`open_input_bfds (s->output_section_statement.children.head, mode);`
`break;`	`break;`
`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`/* Maybe we should load the file's symbols. */`	`/* Maybe we should load the file's symbols. */`
`if ((mode & OPEN_BFD_RESCAN) == 0`	`if ((mode & OPEN_BFD_RESCAN) == 0`
`&& s->wild_statement.filename`	`&& s->wild_statement.filename`
`&& !wildcardp (s->wild_statement.filename)`	`&& !wildcardp (s->wild_statement.filename)`
`&& !archive_path (s->wild_statement.filename))`	`&& !archive_path (s->wild_statement.filename))`
`lookup_name (s->wild_statement.filename);`	`lookup_name (s->wild_statement.filename);`
`open_input_bfds (s->wild_statement.children.head, mode);`	`open_input_bfds (s->wild_statement.children.head, mode);`
`break;`	`break;`
`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`{`	`{`
`struct bfd_link_hash_entry *undefs;`	`struct bfd_link_hash_entry *undefs;`

`/* We must continually search the entries in the group`	`/* We must continually search the entries in the group`
`until no new symbols are added to the list of undefined`	`until no new symbols are added to the list of undefined`
`symbols. */`	`symbols. */`

`do`	`do`
`{`	`{`
`undefs = link_info.hash->undefs_tail;`	`undefs = link_info.hash->undefs_tail;`
`open_input_bfds (s->group_statement.children.head,`	`open_input_bfds (s->group_statement.children.head,`
`mode \| OPEN_BFD_FORCE);`	`mode \| OPEN_BFD_FORCE);`
`}`	`}`
`while (undefs != link_info.hash->undefs_tail);`	`while (undefs != link_info.hash->undefs_tail);`
`}`	`}`
`break;`	`break;`
`case lang_target_statement_enum:`	`case lang_target_statement_enum:`
`current_target = s->target_statement.target;`	`current_target = s->target_statement.target;`
`break;`	`break;`
`case lang_input_statement_enum:`	`case lang_input_statement_enum:`
`if (s->input_statement.real)`	`if (s->input_statement.real)`
`{`	`{`
`lang_statement_union_type **os_tail;`	`lang_statement_union_type **os_tail;`
`lang_statement_list_type add;`	`lang_statement_list_type add;`

`s->input_statement.target = current_target;`	`s->input_statement.target = current_target;`

`/* If we are being called from within a group, and this`	`/* If we are being called from within a group, and this`
`is an archive which has already been searched, then`	`is an archive which has already been searched, then`
`force it to be researched unless the whole archive`	`force it to be researched unless the whole archive`
`has been loaded already. Do the same for a rescan. */`	`has been loaded already. Do the same for a rescan. */`
`if (mode != OPEN_BFD_NORMAL`	`if (mode != OPEN_BFD_NORMAL`
`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`&& ((mode & OPEN_BFD_RESCAN) == 0`	`&& ((mode & OPEN_BFD_RESCAN) == 0`
`\|\| plugin_insert == NULL)`	`\|\| plugin_insert == NULL)`
`#endif`	`#endif`
`&& !s->input_statement.whole_archive`	`&& !s->input_statement.whole_archive`
`&& s->input_statement.loaded`	`&& s->input_statement.loaded`
`&& bfd_check_format (s->input_statement.the_bfd,`	`&& bfd_check_format (s->input_statement.the_bfd,`
`bfd_archive))`	`bfd_archive))`
`s->input_statement.loaded = FALSE;`	`s->input_statement.loaded = FALSE;`
	`#ifdef ENABLE_PLUGINS`
	`/* When rescanning, reload --as-needed shared libs. */`
	`else if ((mode & OPEN_BFD_RESCAN) != 0`
	`&& plugin_insert == NULL`
	`&& s->input_statement.loaded`
	`&& s->input_statement.add_DT_NEEDED_for_regular`
	`&& ((s->input_statement.the_bfd->flags) & DYNAMIC) != 0`
	`&& plugin_should_reload (s->input_statement.the_bfd))`
	`{`
	`s->input_statement.loaded = FALSE;`
	`s->input_statement.reload = TRUE;`
	`}`
	`#endif`

`os_tail = lang_output_section_statement.tail;`	`os_tail = lang_output_section_statement.tail;`
`lang_list_init (&add);`	`lang_list_init (&add);`

`if (! load_symbols (&s->input_statement, &add))`	`if (! load_symbols (&s->input_statement, &add))`
`config.make_executable = FALSE;`	`config.make_executable = FALSE;`

`if (add.head != NULL)`	`if (add.head != NULL)`
`{`	`{`
`/* If this was a script with output sections then`	`/* If this was a script with output sections then`
`tack any added statements on to the end of the`	`tack any added statements on to the end of the`
`list. This avoids having to reorder the output`	`list. This avoids having to reorder the output`
`section statement list. Very likely the user`	`section statement list. Very likely the user`
`forgot -T, and whatever we do here will not meet`	`forgot -T, and whatever we do here will not meet`
`naive user expectations. */`	`naive user expectations. */`
`if (os_tail != lang_output_section_statement.tail)`	`if (os_tail != lang_output_section_statement.tail)`
`{`	`{`
`einfo (_("%P: warning: %s contains output sections;"`	`einfo (_("%P: warning: %s contains output sections;"`
`" did you forget -T?\n"),`	`" did you forget -T?\n"),`
`s->input_statement.filename);`	`s->input_statement.filename);`
`*stat_ptr->tail = add.head;`	`*stat_ptr->tail = add.head;`
`stat_ptr->tail = add.tail;`	`stat_ptr->tail = add.tail;`
`}`	`}`
`else`	`else`
`{`	`{`
`*add.tail = s->header.next;`	`*add.tail = s->header.next;`
`s->header.next = add.head;`	`s->header.next = add.head;`
`}`	`}`
`}`	`}`
`}`	`}`
`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`/* If we have found the point at which a plugin added new`	`/* If we have found the point at which a plugin added new`
`files, clear plugin_insert to enable archive rescan. */`	`files, clear plugin_insert to enable archive rescan. */`
`if (&s->input_statement == plugin_insert)`	`if (&s->input_statement == plugin_insert)`
`plugin_insert = NULL;`	`plugin_insert = NULL;`
`#endif`	`#endif`
`break;`	`break;`
`case lang_assignment_statement_enum:`	`case lang_assignment_statement_enum:`
`if (s->assignment_statement.exp->assign.hidden)`	`if (s->assignment_statement.exp->assign.hidden)`
`/* This is from a --defsym on the command line. */`	`/* This is from a --defsym on the command line. */`
`exp_fold_tree_no_dot (s->assignment_statement.exp);`	`exp_fold_tree_no_dot (s->assignment_statement.exp);`
`break;`	`break;`
`default:`	`default:`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* Exit if any of the files were missing. */`	`/* Exit if any of the files were missing. */`
`if (missing_file)`	`if (missing_file)`
`einfo ("%F");`	`einfo ("%F");`
`}`	`}`

`/* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */`	`/* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */`

`void`	`void`
`lang_track_definedness (const char *name)`	`lang_track_definedness (const char *name)`
`{`	`{`
`if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)`	`if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)`
`einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);`	`einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);`
`}`	`}`

`/* New-function for the definedness hash table. */`	`/* New-function for the definedness hash table. */`

`static struct bfd_hash_entry *`	`static struct bfd_hash_entry *`
`lang_definedness_newfunc (struct bfd_hash_entry *entry,`	`lang_definedness_newfunc (struct bfd_hash_entry *entry,`
`struct bfd_hash_table *table ATTRIBUTE_UNUSED,`	`struct bfd_hash_table *table ATTRIBUTE_UNUSED,`
`const char *name ATTRIBUTE_UNUSED)`	`const char *name ATTRIBUTE_UNUSED)`
`{`	`{`
`struct lang_definedness_hash_entry *ret`	`struct lang_definedness_hash_entry *ret`
`= (struct lang_definedness_hash_entry *) entry;`	`= (struct lang_definedness_hash_entry *) entry;`

`if (ret == NULL)`	`if (ret == NULL)`
`ret = (struct lang_definedness_hash_entry *)`	`ret = (struct lang_definedness_hash_entry *)`
`bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));`	`bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));`

`if (ret == NULL)`	`if (ret == NULL)`
`einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);`	`einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);`

`ret->iteration = -1;`	`ret->iteration = -1;`
`return &ret->root;`	`return &ret->root;`
`}`	`}`

`/* Return the iteration when the definition of NAME was last updated. A`	`/* Return the iteration when the definition of NAME was last updated. A`
`value of -1 means that the symbol is not defined in the linker script`	`value of -1 means that the symbol is not defined in the linker script`
`or the command line, but may be defined in the linker symbol table. */`	`or the command line, but may be defined in the linker symbol table. */`

`int`	`int`
`lang_symbol_definition_iteration (const char *name)`	`lang_symbol_definition_iteration (const char *name)`
`{`	`{`
`struct lang_definedness_hash_entry *defentry`	`struct lang_definedness_hash_entry *defentry`
`= (struct lang_definedness_hash_entry *)`	`= (struct lang_definedness_hash_entry *)`
`bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);`	`bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);`

`/* We've already created this one on the presence of DEFINED in the`	`/* We've already created this one on the presence of DEFINED in the`
`script, so it can't be NULL unless something is borked elsewhere in`	`script, so it can't be NULL unless something is borked elsewhere in`
`the code. */`	`the code. */`
`if (defentry == NULL)`	`if (defentry == NULL)`
`FAIL ();`	`FAIL ();`

`return defentry->iteration;`	`return defentry->iteration;`
`}`	`}`

`/* Update the definedness state of NAME. */`	`/* Update the definedness state of NAME. */`

`void`	`void`
`lang_update_definedness (const char name, struct bfd_link_hash_entry h)`	`lang_update_definedness (const char name, struct bfd_link_hash_entry h)`
`{`	`{`
`struct lang_definedness_hash_entry *defentry`	`struct lang_definedness_hash_entry *defentry`
`= (struct lang_definedness_hash_entry *)`	`= (struct lang_definedness_hash_entry *)`
`bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);`	`bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);`

`/* We don't keep track of symbols not tested with DEFINED. */`	`/* We don't keep track of symbols not tested with DEFINED. */`
`if (defentry == NULL)`	`if (defentry == NULL)`
`return;`	`return;`

`/* If the symbol was already defined, and not from an earlier statement`	`/* If the symbol was already defined, and not from an earlier statement`
`iteration, don't update the definedness iteration, because that'd`	`iteration, don't update the definedness iteration, because that'd`
`make the symbol seem defined in the linker script at this point, and`	`make the symbol seem defined in the linker script at this point, and`
`it wasn't; it was defined in some object. If we do anyway, DEFINED`	`it wasn't; it was defined in some object. If we do anyway, DEFINED`
`would start to yield false before this point and the construct "sym =`	`would start to yield false before this point and the construct "sym =`
`DEFINED (sym) ? sym : X;" would change sym to X despite being defined`	`DEFINED (sym) ? sym : X;" would change sym to X despite being defined`
`in an object. */`	`in an object. */`
`if (h->type != bfd_link_hash_undefined`	`if (h->type != bfd_link_hash_undefined`
`&& h->type != bfd_link_hash_common`	`&& h->type != bfd_link_hash_common`
`&& h->type != bfd_link_hash_new`	`&& h->type != bfd_link_hash_new`
`&& defentry->iteration == -1)`	`&& defentry->iteration == -1)`
`return;`	`return;`

`defentry->iteration = lang_statement_iteration;`	`defentry->iteration = lang_statement_iteration;`
`}`	`}`

`/* Add the supplied name to the symbol table as an undefined reference.`	`/* Add the supplied name to the symbol table as an undefined reference.`
`This is a two step process as the symbol table doesn't even exist at`	`This is a two step process as the symbol table doesn't even exist at`
`the time the ld command line is processed. First we put the name`	`the time the ld command line is processed. First we put the name`
`on a list, then, once the output file has been opened, transfer the`	`on a list, then, once the output file has been opened, transfer the`
`name to the symbol table. */`	`name to the symbol table. */`

`typedef struct bfd_sym_chain ldlang_undef_chain_list_type;`	`typedef struct bfd_sym_chain ldlang_undef_chain_list_type;`

`#define ldlang_undef_chain_list_head entry_symbol.next`	`#define ldlang_undef_chain_list_head entry_symbol.next`

`void`	`void`
`ldlang_add_undef (const char *const name, bfd_boolean cmdline)`	`ldlang_add_undef (const char *const name, bfd_boolean cmdline)`
`{`	`{`
`ldlang_undef_chain_list_type *new_undef;`	`ldlang_undef_chain_list_type *new_undef;`

`undef_from_cmdline = undef_from_cmdline \|\| cmdline;`	`undef_from_cmdline = undef_from_cmdline \|\| cmdline;`
`new_undef = (ldlang_undef_chain_list_type ) stat_alloc (sizeof (new_undef));`	`new_undef = (ldlang_undef_chain_list_type ) stat_alloc (sizeof (new_undef));`
`new_undef->next = ldlang_undef_chain_list_head;`	`new_undef->next = ldlang_undef_chain_list_head;`
`ldlang_undef_chain_list_head = new_undef;`	`ldlang_undef_chain_list_head = new_undef;`

`new_undef->name = xstrdup (name);`	`new_undef->name = xstrdup (name);`

`if (link_info.output_bfd != NULL)`	`if (link_info.output_bfd != NULL)`
`insert_undefined (new_undef->name);`	`insert_undefined (new_undef->name);`
`}`	`}`

`/* Insert NAME as undefined in the symbol table. */`	`/* Insert NAME as undefined in the symbol table. */`

`static void`	`static void`
`insert_undefined (const char *name)`	`insert_undefined (const char *name)`
`{`	`{`
`struct bfd_link_hash_entry *h;`	`struct bfd_link_hash_entry *h;`

`h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);`	`h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);`
`if (h == NULL)`	`if (h == NULL)`
`einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));`	`einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));`
`if (h->type == bfd_link_hash_new)`	`if (h->type == bfd_link_hash_new)`
`{`	`{`
`h->type = bfd_link_hash_undefined;`	`h->type = bfd_link_hash_undefined;`
`h->u.undef.abfd = NULL;`	`h->u.undef.abfd = NULL;`
`bfd_link_add_undef (link_info.hash, h);`	`bfd_link_add_undef (link_info.hash, h);`
`}`	`}`
`}`	`}`

`/* Run through the list of undefineds created above and place them`	`/* Run through the list of undefineds created above and place them`
`into the linker hash table as undefined symbols belonging to the`	`into the linker hash table as undefined symbols belonging to the`
`script file. */`	`script file. */`

`static void`	`static void`
`lang_place_undefineds (void)`	`lang_place_undefineds (void)`
`{`	`{`
`ldlang_undef_chain_list_type *ptr;`	`ldlang_undef_chain_list_type *ptr;`

`for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)`	`for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)`
`insert_undefined (ptr->name);`	`insert_undefined (ptr->name);`
`}`	`}`

`/* Check for all readonly or some readwrite sections. */`	`/* Check for all readonly or some readwrite sections. */`

`static void`	`static void`
`check_input_sections`	`check_input_sections`
`(lang_statement_union_type *s,`	`(lang_statement_union_type *s,`
`lang_output_section_statement_type *output_section_statement)`	`lang_output_section_statement_type *output_section_statement)`
`{`	`{`
`for (; s != (lang_statement_union_type *) NULL; s = s->header.next)`	`for (; s != (lang_statement_union_type *) NULL; s = s->header.next)`
`{`	`{`
`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`walk_wild (&s->wild_statement, check_section_callback,`	`walk_wild (&s->wild_statement, check_section_callback,`
`output_section_statement);`	`output_section_statement);`
`if (! output_section_statement->all_input_readonly)`	`if (! output_section_statement->all_input_readonly)`
`return;`	`return;`
`break;`	`break;`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`check_input_sections (constructor_list.head,`	`check_input_sections (constructor_list.head,`
`output_section_statement);`	`output_section_statement);`
`if (! output_section_statement->all_input_readonly)`	`if (! output_section_statement->all_input_readonly)`
`return;`	`return;`
`break;`	`break;`
`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`check_input_sections (s->group_statement.children.head,`	`check_input_sections (s->group_statement.children.head,`
`output_section_statement);`	`output_section_statement);`
`if (! output_section_statement->all_input_readonly)`	`if (! output_section_statement->all_input_readonly)`
`return;`	`return;`
`break;`	`break;`
`default:`	`default:`
`break;`	`break;`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Update wildcard statements if needed. */`	`/* Update wildcard statements if needed. */`

`static void`	`static void`
`update_wild_statements (lang_statement_union_type *s)`	`update_wild_statements (lang_statement_union_type *s)`
`{`	`{`
`struct wildcard_list *sec;`	`struct wildcard_list *sec;`

`switch (sort_section)`	`switch (sort_section)`
`{`	`{`
`default:`	`default:`
`FAIL ();`	`FAIL ();`

`case none:`	`case none:`
`break;`	`break;`

`case by_name:`	`case by_name:`
`case by_alignment:`	`case by_alignment:`
`for (; s != NULL; s = s->header.next)`	`for (; s != NULL; s = s->header.next)`
`{`	`{`
`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`default:`	`default:`
`break;`	`break;`

`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`sec = s->wild_statement.section_list;`	`sec = s->wild_statement.section_list;`
`for (sec = s->wild_statement.section_list; sec != NULL;`	`for (sec = s->wild_statement.section_list; sec != NULL;`
`sec = sec->next)`	`sec = sec->next)`
`{`	`{`
`switch (sec->spec.sorted)`	`switch (sec->spec.sorted)`
`{`	`{`
`case none:`	`case none:`
`sec->spec.sorted = sort_section;`	`sec->spec.sorted = sort_section;`
`break;`	`break;`
`case by_name:`	`case by_name:`
`if (sort_section == by_alignment)`	`if (sort_section == by_alignment)`
`sec->spec.sorted = by_name_alignment;`	`sec->spec.sorted = by_name_alignment;`
`break;`	`break;`
`case by_alignment:`	`case by_alignment:`
`if (sort_section == by_name)`	`if (sort_section == by_name)`
`sec->spec.sorted = by_alignment_name;`	`sec->spec.sorted = by_alignment_name;`
`break;`	`break;`
`default:`	`default:`
`break;`	`break;`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`update_wild_statements (constructor_list.head);`	`update_wild_statements (constructor_list.head);`
`break;`	`break;`

`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`update_wild_statements`	`update_wild_statements`
`(s->output_section_statement.children.head);`	`(s->output_section_statement.children.head);`
`break;`	`break;`

`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`update_wild_statements (s->group_statement.children.head);`	`update_wild_statements (s->group_statement.children.head);`
`break;`	`break;`
`}`	`}`
`}`	`}`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* Open input files and attach to output sections. */`	`/* Open input files and attach to output sections. */`

`static void`	`static void`
`map_input_to_output_sections`	`map_input_to_output_sections`
`(lang_statement_union_type s, const char target,`	`(lang_statement_union_type s, const char target,`
`lang_output_section_statement_type *os)`	`lang_output_section_statement_type *os)`
`{`	`{`
`for (; s != NULL; s = s->header.next)`	`for (; s != NULL; s = s->header.next)`
`{`	`{`
`lang_output_section_statement_type *tos;`	`lang_output_section_statement_type *tos;`
`flagword flags;`	`flagword flags;`

`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`wild (&s->wild_statement, target, os);`	`wild (&s->wild_statement, target, os);`
`break;`	`break;`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`map_input_to_output_sections (constructor_list.head,`	`map_input_to_output_sections (constructor_list.head,`
`target,`	`target,`
`os);`	`os);`
`break;`	`break;`
`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`tos = &s->output_section_statement;`	`tos = &s->output_section_statement;`
`if (tos->constraint != 0)`	`if (tos->constraint != 0)`
`{`	`{`
`if (tos->constraint != ONLY_IF_RW`	`if (tos->constraint != ONLY_IF_RW`
`&& tos->constraint != ONLY_IF_RO)`	`&& tos->constraint != ONLY_IF_RO)`
`break;`	`break;`
`tos->all_input_readonly = TRUE;`	`tos->all_input_readonly = TRUE;`
`check_input_sections (tos->children.head, tos);`	`check_input_sections (tos->children.head, tos);`
`if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))`	`if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))`
`{`	`{`
`tos->constraint = -1;`	`tos->constraint = -1;`
`break;`	`break;`
`}`	`}`
`}`	`}`
`map_input_to_output_sections (tos->children.head,`	`map_input_to_output_sections (tos->children.head,`
`target,`	`target,`
`tos);`	`tos);`
`break;`	`break;`
`case lang_output_statement_enum:`	`case lang_output_statement_enum:`
`break;`	`break;`
`case lang_target_statement_enum:`	`case lang_target_statement_enum:`
`target = s->target_statement.target;`	`target = s->target_statement.target;`
`break;`	`break;`
`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`map_input_to_output_sections (s->group_statement.children.head,`	`map_input_to_output_sections (s->group_statement.children.head,`
`target,`	`target,`
`os);`	`os);`
`break;`	`break;`
`case lang_data_statement_enum:`	`case lang_data_statement_enum:`
`/* Make sure that any sections mentioned in the expression`	`/* Make sure that any sections mentioned in the expression`
`are initialized. */`	`are initialized. */`
`exp_init_os (s->data_statement.exp);`	`exp_init_os (s->data_statement.exp);`
`/* The output section gets CONTENTS, ALLOC and LOAD, but`	`/* The output section gets CONTENTS, ALLOC and LOAD, but`
`these may be overridden by the script. */`	`these may be overridden by the script. */`
`flags = SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD;`	`flags = SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD;`
`switch (os->sectype)`	`switch (os->sectype)`
`{`	`{`
`case normal_section:`	`case normal_section:`
`case overlay_section:`	`case overlay_section:`
`break;`	`break;`
`case noalloc_section:`	`case noalloc_section:`
`flags = SEC_HAS_CONTENTS;`	`flags = SEC_HAS_CONTENTS;`
`break;`	`break;`
`case noload_section:`	`case noload_section:`
`if (bfd_get_flavour (link_info.output_bfd)`	`if (bfd_get_flavour (link_info.output_bfd)`
`== bfd_target_elf_flavour)`	`== bfd_target_elf_flavour)`
`flags = SEC_NEVER_LOAD \| SEC_ALLOC;`	`flags = SEC_NEVER_LOAD \| SEC_ALLOC;`
`else`	`else`
`flags = SEC_NEVER_LOAD \| SEC_HAS_CONTENTS;`	`flags = SEC_NEVER_LOAD \| SEC_HAS_CONTENTS;`
`break;`	`break;`
`}`	`}`
`if (os->bfd_section == NULL)`	`if (os->bfd_section == NULL)`
`init_os (os, flags);`	`init_os (os, flags);`
`else`	`else`
`os->bfd_section->flags \|= flags;`	`os->bfd_section->flags \|= flags;`
`break;`	`break;`
`case lang_input_section_enum:`	`case lang_input_section_enum:`
`break;`	`break;`
`case lang_fill_statement_enum:`	`case lang_fill_statement_enum:`
`case lang_object_symbols_statement_enum:`	`case lang_object_symbols_statement_enum:`
`case lang_reloc_statement_enum:`	`case lang_reloc_statement_enum:`
`case lang_padding_statement_enum:`	`case lang_padding_statement_enum:`
`case lang_input_statement_enum:`	`case lang_input_statement_enum:`
`if (os != NULL && os->bfd_section == NULL)`	`if (os != NULL && os->bfd_section == NULL)`
`init_os (os, 0);`	`init_os (os, 0);`
`break;`	`break;`
`case lang_assignment_statement_enum:`	`case lang_assignment_statement_enum:`
`if (os != NULL && os->bfd_section == NULL)`	`if (os != NULL && os->bfd_section == NULL)`
`init_os (os, 0);`	`init_os (os, 0);`

`/* Make sure that any sections mentioned in the assignment`	`/* Make sure that any sections mentioned in the assignment`
`are initialized. */`	`are initialized. */`
`exp_init_os (s->assignment_statement.exp);`	`exp_init_os (s->assignment_statement.exp);`
`break;`	`break;`
`case lang_address_statement_enum:`	`case lang_address_statement_enum:`
`/* Mark the specified section with the supplied address.`	`/* Mark the specified section with the supplied address.`
`If this section was actually a segment marker, then the`	`If this section was actually a segment marker, then the`
`directive is ignored if the linker script explicitly`	`directive is ignored if the linker script explicitly`
`processed the segment marker. Originally, the linker`	`processed the segment marker. Originally, the linker`
`treated segment directives (like -Ttext on the`	`treated segment directives (like -Ttext on the`
`command-line) as section directives. We honor the`	`command-line) as section directives. We honor the`
`section directive semantics for backwards compatibilty;`	`section directive semantics for backwards compatibilty;`
`linker scripts that do not specifically check for`	`linker scripts that do not specifically check for`
`SEGMENT_START automatically get the old semantics. */`	`SEGMENT_START automatically get the old semantics. */`
`if (!s->address_statement.segment`	`if (!s->address_statement.segment`
`\|\| !s->address_statement.segment->used)`	`\|\| !s->address_statement.segment->used)`
`{`	`{`
`const char *name = s->address_statement.section_name;`	`const char *name = s->address_statement.section_name;`

`/* Create the output section statement here so that`	`/* Create the output section statement here so that`
`orphans with a set address will be placed after other`	`orphans with a set address will be placed after other`
`script sections. If we let the orphan placement code`	`script sections. If we let the orphan placement code`
`place them in amongst other sections then the address`	`place them in amongst other sections then the address`
`will affect following script sections, which is`	`will affect following script sections, which is`
`likely to surprise naive users. */`	`likely to surprise naive users. */`
`tos = lang_output_section_statement_lookup (name, 0, TRUE);`	`tos = lang_output_section_statement_lookup (name, 0, TRUE);`
`tos->addr_tree = s->address_statement.address;`	`tos->addr_tree = s->address_statement.address;`
`if (tos->bfd_section == NULL)`	`if (tos->bfd_section == NULL)`
`init_os (tos, 0);`	`init_os (tos, 0);`
`}`	`}`
`break;`	`break;`
`case lang_insert_statement_enum:`	`case lang_insert_statement_enum:`
`break;`	`break;`
`}`	`}`
`}`	`}`
`}`	`}`

`/* An insert statement snips out all the linker statements from the`	`/* An insert statement snips out all the linker statements from the`
`start of the list and places them after the output section`	`start of the list and places them after the output section`
`statement specified by the insert. This operation is complicated`	`statement specified by the insert. This operation is complicated`
`by the fact that we keep a doubly linked list of output section`	`by the fact that we keep a doubly linked list of output section`
`statements as well as the singly linked list of all statements. */`	`statements as well as the singly linked list of all statements. */`

`static void`	`static void`
`process_insert_statements (void)`	`process_insert_statements (void)`
`{`	`{`
`lang_statement_union_type **s;`	`lang_statement_union_type **s;`
`lang_output_section_statement_type *first_os = NULL;`	`lang_output_section_statement_type *first_os = NULL;`
`lang_output_section_statement_type *last_os = NULL;`	`lang_output_section_statement_type *last_os = NULL;`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`/* "start of list" is actually the statement immediately after`	`/* "start of list" is actually the statement immediately after`
`the special abs_section output statement, so that it isn't`	`the special abs_section output statement, so that it isn't`
`reordered. */`	`reordered. */`
`s = &lang_output_section_statement.head;`	`s = &lang_output_section_statement.head;`
`while ((s = &(s)->header.next) != NULL)`	`while ((s = &(s)->header.next) != NULL)`
`{`	`{`
`if ((*s)->header.type == lang_output_section_statement_enum)`	`if ((*s)->header.type == lang_output_section_statement_enum)`
`{`	`{`
`/* Keep pointers to the first and last output section`	`/* Keep pointers to the first and last output section`
`statement in the sequence we may be about to move. */`	`statement in the sequence we may be about to move. */`
`os = &(*s)->output_section_statement;`	`os = &(*s)->output_section_statement;`

`ASSERT (last_os == NULL \|\| last_os->next == os);`	`ASSERT (last_os == NULL \|\| last_os->next == os);`
`last_os = os;`	`last_os = os;`

`/* Set constraint negative so that lang_output_section_find`	`/* Set constraint negative so that lang_output_section_find`
`won't match this output section statement. At this`	`won't match this output section statement. At this`
`stage in linking constraint has values in the range`	`stage in linking constraint has values in the range`
`[-1, ONLY_IN_RW]. */`	`[-1, ONLY_IN_RW]. */`
`last_os->constraint = -2 - last_os->constraint;`	`last_os->constraint = -2 - last_os->constraint;`
`if (first_os == NULL)`	`if (first_os == NULL)`
`first_os = last_os;`	`first_os = last_os;`
`}`	`}`
`else if ((*s)->header.type == lang_insert_statement_enum)`	`else if ((*s)->header.type == lang_insert_statement_enum)`
`{`	`{`
`lang_insert_statement_type i = &(s)->insert_statement;`	`lang_insert_statement_type i = &(s)->insert_statement;`
`lang_output_section_statement_type *where;`	`lang_output_section_statement_type *where;`
`lang_statement_union_type **ptr;`	`lang_statement_union_type **ptr;`
`lang_statement_union_type *first;`	`lang_statement_union_type *first;`

`where = lang_output_section_find (i->where);`	`where = lang_output_section_find (i->where);`
`if (where != NULL && i->is_before)`	`if (where != NULL && i->is_before)`
`{`	`{`
`do`	`do`
`where = where->prev;`	`where = where->prev;`
`while (where != NULL && where->constraint < 0);`	`while (where != NULL && where->constraint < 0);`
`}`	`}`
`if (where == NULL)`	`if (where == NULL)`
`{`	`{`
`einfo (_("%F%P: %s not found for insert\n"), i->where);`	`einfo (_("%F%P: %s not found for insert\n"), i->where);`
`return;`	`return;`
`}`	`}`

`/* Deal with reordering the output section statement list. */`	`/* Deal with reordering the output section statement list. */`
`if (last_os != NULL)`	`if (last_os != NULL)`
`{`	`{`
`asection first_sec, last_sec;`	`asection first_sec, last_sec;`
`struct lang_output_section_statement_struct **next;`	`struct lang_output_section_statement_struct **next;`

`/* Snip out the output sections we are moving. */`	`/* Snip out the output sections we are moving. */`
`first_os->prev->next = last_os->next;`	`first_os->prev->next = last_os->next;`
`if (last_os->next == NULL)`	`if (last_os->next == NULL)`
`{`	`{`
`next = &first_os->prev->next;`	`next = &first_os->prev->next;`
`lang_output_section_statement.tail`	`lang_output_section_statement.tail`
`= (lang_statement_union_type **) next;`	`= (lang_statement_union_type **) next;`
`}`	`}`
`else`	`else`
`last_os->next->prev = first_os->prev;`	`last_os->next->prev = first_os->prev;`
`/* Add them in at the new position. */`	`/* Add them in at the new position. */`
`last_os->next = where->next;`	`last_os->next = where->next;`
`if (where->next == NULL)`	`if (where->next == NULL)`
`{`	`{`
`next = &last_os->next;`	`next = &last_os->next;`
`lang_output_section_statement.tail`	`lang_output_section_statement.tail`
`= (lang_statement_union_type **) next;`	`= (lang_statement_union_type **) next;`
`}`	`}`
`else`	`else`
`where->next->prev = last_os;`	`where->next->prev = last_os;`
`first_os->prev = where;`	`first_os->prev = where;`
`where->next = first_os;`	`where->next = first_os;`

`/* Move the bfd sections in the same way. */`	`/* Move the bfd sections in the same way. */`
`first_sec = NULL;`	`first_sec = NULL;`
`last_sec = NULL;`	`last_sec = NULL;`
`for (os = first_os; os != NULL; os = os->next)`	`for (os = first_os; os != NULL; os = os->next)`
`{`	`{`
`os->constraint = -2 - os->constraint;`	`os->constraint = -2 - os->constraint;`
`if (os->bfd_section != NULL`	`if (os->bfd_section != NULL`
`&& os->bfd_section->owner != NULL)`	`&& os->bfd_section->owner != NULL)`
`{`	`{`
`last_sec = os->bfd_section;`	`last_sec = os->bfd_section;`
`if (first_sec == NULL)`	`if (first_sec == NULL)`
`first_sec = last_sec;`	`first_sec = last_sec;`
`}`	`}`
`if (os == last_os)`	`if (os == last_os)`
`break;`	`break;`
`}`	`}`
`if (last_sec != NULL)`	`if (last_sec != NULL)`
`{`	`{`
`asection *sec = where->bfd_section;`	`asection *sec = where->bfd_section;`
`if (sec == NULL)`	`if (sec == NULL)`
`sec = output_prev_sec_find (where);`	`sec = output_prev_sec_find (where);`

`/* The place we want to insert must come after the`	`/* The place we want to insert must come after the`
`sections we are moving. So if we find no`	`sections we are moving. So if we find no`
`section or if the section is the same as our`	`section or if the section is the same as our`
`last section, then no move is needed. */`	`last section, then no move is needed. */`
`if (sec != NULL && sec != last_sec)`	`if (sec != NULL && sec != last_sec)`
`{`	`{`
`/* Trim them off. */`	`/* Trim them off. */`
`if (first_sec->prev != NULL)`	`if (first_sec->prev != NULL)`
`first_sec->prev->next = last_sec->next;`	`first_sec->prev->next = last_sec->next;`
`else`	`else`
`link_info.output_bfd->sections = last_sec->next;`	`link_info.output_bfd->sections = last_sec->next;`
`if (last_sec->next != NULL)`	`if (last_sec->next != NULL)`
`last_sec->next->prev = first_sec->prev;`	`last_sec->next->prev = first_sec->prev;`
`else`	`else`
`link_info.output_bfd->section_last = first_sec->prev;`	`link_info.output_bfd->section_last = first_sec->prev;`
`/* Add back. */`	`/* Add back. */`
`last_sec->next = sec->next;`	`last_sec->next = sec->next;`
`if (sec->next != NULL)`	`if (sec->next != NULL)`
`sec->next->prev = last_sec;`	`sec->next->prev = last_sec;`
`else`	`else`
`link_info.output_bfd->section_last = last_sec;`	`link_info.output_bfd->section_last = last_sec;`
`first_sec->prev = sec;`	`first_sec->prev = sec;`
`sec->next = first_sec;`	`sec->next = first_sec;`
`}`	`}`
`}`	`}`

`first_os = NULL;`	`first_os = NULL;`
`last_os = NULL;`	`last_os = NULL;`
`}`	`}`

`ptr = insert_os_after (where);`	`ptr = insert_os_after (where);`
`/* Snip everything after the abs_section output statement we`	`/* Snip everything after the abs_section output statement we`
`know is at the start of the list, up to and including`	`know is at the start of the list, up to and including`
`the insert statement we are currently processing. */`	`the insert statement we are currently processing. */`
`first = lang_output_section_statement.head->header.next;`	`first = lang_output_section_statement.head->header.next;`
`lang_output_section_statement.head->header.next = (*s)->header.next;`	`lang_output_section_statement.head->header.next = (*s)->header.next;`
`/* Add them back where they belong. */`	`/* Add them back where they belong. */`
`s = ptr;`	`s = ptr;`
`if (*s == NULL)`	`if (*s == NULL)`
`statement_list.tail = s;`	`statement_list.tail = s;`
`*ptr = first;`	`*ptr = first;`
`s = &lang_output_section_statement.head;`	`s = &lang_output_section_statement.head;`
`}`	`}`
`}`	`}`

`/* Undo constraint twiddling. */`	`/* Undo constraint twiddling. */`
`for (os = first_os; os != NULL; os = os->next)`	`for (os = first_os; os != NULL; os = os->next)`
`{`	`{`
`os->constraint = -2 - os->constraint;`	`os->constraint = -2 - os->constraint;`
`if (os == last_os)`	`if (os == last_os)`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* An output section might have been removed after its statement was`	`/* An output section might have been removed after its statement was`
`added. For example, ldemul_before_allocation can remove dynamic`	`added. For example, ldemul_before_allocation can remove dynamic`
`sections if they turn out to be not needed. Clean them up here. */`	`sections if they turn out to be not needed. Clean them up here. */`

`void`	`void`
`strip_excluded_output_sections (void)`	`strip_excluded_output_sections (void)`
`{`	`{`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`/* Run lang_size_sections (if not already done). */`	`/* Run lang_size_sections (if not already done). */`
`if (expld.phase != lang_mark_phase_enum)`	`if (expld.phase != lang_mark_phase_enum)`
`{`	`{`
`expld.phase = lang_mark_phase_enum;`	`expld.phase = lang_mark_phase_enum;`
`expld.dataseg.phase = exp_dataseg_none;`	`expld.dataseg.phase = exp_dataseg_none;`
`one_lang_size_sections_pass (NULL, FALSE);`	`one_lang_size_sections_pass (NULL, FALSE);`
`lang_reset_memory_regions ();`	`lang_reset_memory_regions ();`
`}`	`}`

`for (os = &lang_output_section_statement.head->output_section_statement;`	`for (os = &lang_output_section_statement.head->output_section_statement;`
`os != NULL;`	`os != NULL;`
`os = os->next)`	`os = os->next)`
`{`	`{`
`asection *output_section;`	`asection *output_section;`
`bfd_boolean exclude;`	`bfd_boolean exclude;`

`if (os->constraint < 0)`	`if (os->constraint < 0)`
`continue;`	`continue;`

`output_section = os->bfd_section;`	`output_section = os->bfd_section;`
`if (output_section == NULL)`	`if (output_section == NULL)`
`continue;`	`continue;`

`exclude = (output_section->rawsize == 0`	`exclude = (output_section->rawsize == 0`
`&& (output_section->flags & SEC_KEEP) == 0`	`&& (output_section->flags & SEC_KEEP) == 0`
`&& !bfd_section_removed_from_list (link_info.output_bfd,`	`&& !bfd_section_removed_from_list (link_info.output_bfd,`
`output_section));`	`output_section));`

`/* Some sections have not yet been sized, notably .gnu.version,`	`/* Some sections have not yet been sized, notably .gnu.version,`
`.dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED`	`.dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED`
`input sections, so don't drop output sections that have such`	`input sections, so don't drop output sections that have such`
`input sections unless they are also marked SEC_EXCLUDE. */`	`input sections unless they are also marked SEC_EXCLUDE. */`
`if (exclude && output_section->map_head.s != NULL)`	`if (exclude && output_section->map_head.s != NULL)`
`{`	`{`
`asection *s;`	`asection *s;`

`for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)`	`for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)`
`if ((s->flags & SEC_LINKER_CREATED) != 0`	`if ((s->flags & SEC_LINKER_CREATED) != 0`
`&& (s->flags & SEC_EXCLUDE) == 0)`	`&& (s->flags & SEC_EXCLUDE) == 0)`
`{`	`{`
`exclude = FALSE;`	`exclude = FALSE;`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* TODO: Don't just junk map_head.s, turn them into link_orders. */`	`/* TODO: Don't just junk map_head.s, turn them into link_orders. */`
`output_section->map_head.link_order = NULL;`	`output_section->map_head.link_order = NULL;`
`output_section->map_tail.link_order = NULL;`	`output_section->map_tail.link_order = NULL;`

`if (exclude)`	`if (exclude)`
`{`	`{`
`/* We don't set bfd_section to NULL since bfd_section of the`	`/* We don't set bfd_section to NULL since bfd_section of the`
`removed output section statement may still be used. */`	`removed output section statement may still be used. */`
`if (!os->section_relative_symbol`	`if (!os->section_relative_symbol`
`&& !os->update_dot_tree)`	`&& !os->update_dot_tree)`
`os->ignored = TRUE;`	`os->ignored = TRUE;`
`output_section->flags \|= SEC_EXCLUDE;`	`output_section->flags \|= SEC_EXCLUDE;`
`bfd_section_list_remove (link_info.output_bfd, output_section);`	`bfd_section_list_remove (link_info.output_bfd, output_section);`
`link_info.output_bfd->section_count--;`	`link_info.output_bfd->section_count--;`
`}`	`}`
`}`	`}`

`/* Stop future calls to lang_add_section from messing with map_head`	`/* Stop future calls to lang_add_section from messing with map_head`
`and map_tail link_order fields. */`	`and map_tail link_order fields. */`
`stripped_excluded_sections = TRUE;`	`stripped_excluded_sections = TRUE;`
`}`	`}`

`static void`	`static void`
`print_output_section_statement`	`print_output_section_statement`
`(lang_output_section_statement_type *output_section_statement)`	`(lang_output_section_statement_type *output_section_statement)`
`{`	`{`
`asection *section = output_section_statement->bfd_section;`	`asection *section = output_section_statement->bfd_section;`
`int len;`	`int len;`

`if (output_section_statement != abs_output_section)`	`if (output_section_statement != abs_output_section)`
`{`	`{`
`minfo ("\n%s", output_section_statement->name);`	`minfo ("\n%s", output_section_statement->name);`

`if (section != NULL)`	`if (section != NULL)`
`{`	`{`
`print_dot = section->vma;`	`print_dot = section->vma;`

`len = strlen (output_section_statement->name);`	`len = strlen (output_section_statement->name);`
`if (len >= SECTION_NAME_MAP_LENGTH - 1)`	`if (len >= SECTION_NAME_MAP_LENGTH - 1)`
`{`	`{`
`print_nl ();`	`print_nl ();`
`len = 0;`	`len = 0;`
`}`	`}`
`while (len < SECTION_NAME_MAP_LENGTH)`	`while (len < SECTION_NAME_MAP_LENGTH)`
`{`	`{`
`print_space ();`	`print_space ();`
`++len;`	`++len;`
`}`	`}`

`minfo ("0x%V %W", section->vma, section->size);`	`minfo ("0x%V %W", section->vma, section->size);`

`if (section->vma != section->lma)`	`if (section->vma != section->lma)`
`minfo (_(" load address 0x%V"), section->lma);`	`minfo (_(" load address 0x%V"), section->lma);`

`if (output_section_statement->update_dot_tree != NULL)`	`if (output_section_statement->update_dot_tree != NULL)`
`exp_fold_tree (output_section_statement->update_dot_tree,`	`exp_fold_tree (output_section_statement->update_dot_tree,`
`bfd_abs_section_ptr, &print_dot);`	`bfd_abs_section_ptr, &print_dot);`
`}`	`}`

`print_nl ();`	`print_nl ();`
`}`	`}`

`print_statement_list (output_section_statement->children.head,`	`print_statement_list (output_section_statement->children.head,`
`output_section_statement);`	`output_section_statement);`
`}`	`}`

`/* Scan for the use of the destination in the right hand side`	`/* Scan for the use of the destination in the right hand side`
`of an expression. In such cases we will not compute the`	`of an expression. In such cases we will not compute the`
`correct expression, since the value of DST that is used on`	`correct expression, since the value of DST that is used on`
`the right hand side will be its final value, not its value`	`the right hand side will be its final value, not its value`
`just before this expression is evaluated. */`	`just before this expression is evaluated. */`

`static bfd_boolean`	`static bfd_boolean`
`scan_for_self_assignment (const char * dst, etree_type * rhs)`	`scan_for_self_assignment (const char * dst, etree_type * rhs)`
`{`	`{`
`if (rhs == NULL \|\| dst == NULL)`	`if (rhs == NULL \|\| dst == NULL)`
`return FALSE;`	`return FALSE;`

`switch (rhs->type.node_class)`	`switch (rhs->type.node_class)`
`{`	`{`
`case etree_binary:`	`case etree_binary:`
`return (scan_for_self_assignment (dst, rhs->binary.lhs)`	`return (scan_for_self_assignment (dst, rhs->binary.lhs)`
`\|\| scan_for_self_assignment (dst, rhs->binary.rhs));`	`\|\| scan_for_self_assignment (dst, rhs->binary.rhs));`

`case etree_trinary:`	`case etree_trinary:`
`return (scan_for_self_assignment (dst, rhs->trinary.lhs)`	`return (scan_for_self_assignment (dst, rhs->trinary.lhs)`
`\|\| scan_for_self_assignment (dst, rhs->trinary.rhs));`	`\|\| scan_for_self_assignment (dst, rhs->trinary.rhs));`

`case etree_assign:`	`case etree_assign:`
`case etree_provided:`	`case etree_provided:`
`case etree_provide:`	`case etree_provide:`
`if (strcmp (dst, rhs->assign.dst) == 0)`	`if (strcmp (dst, rhs->assign.dst) == 0)`
`return TRUE;`	`return TRUE;`
`return scan_for_self_assignment (dst, rhs->assign.src);`	`return scan_for_self_assignment (dst, rhs->assign.src);`

`case etree_unary:`	`case etree_unary:`
`return scan_for_self_assignment (dst, rhs->unary.child);`	`return scan_for_self_assignment (dst, rhs->unary.child);`

`case etree_value:`	`case etree_value:`
`if (rhs->value.str)`	`if (rhs->value.str)`
`return strcmp (dst, rhs->value.str) == 0;`	`return strcmp (dst, rhs->value.str) == 0;`
`return FALSE;`	`return FALSE;`

`case etree_name:`	`case etree_name:`
`if (rhs->name.name)`	`if (rhs->name.name)`
`return strcmp (dst, rhs->name.name) == 0;`	`return strcmp (dst, rhs->name.name) == 0;`
`return FALSE;`	`return FALSE;`

`default:`	`default:`
`break;`	`break;`
`}`	`}`

`return FALSE;`	`return FALSE;`
`}`	`}`


`static void`	`static void`
`print_assignment (lang_assignment_statement_type *assignment,`	`print_assignment (lang_assignment_statement_type *assignment,`
`lang_output_section_statement_type *output_section)`	`lang_output_section_statement_type *output_section)`
`{`	`{`
`unsigned int i;`	`unsigned int i;`
`bfd_boolean is_dot;`	`bfd_boolean is_dot;`
`bfd_boolean computation_is_valid = TRUE;`	`bfd_boolean computation_is_valid = TRUE;`
`etree_type *tree;`	`etree_type *tree;`
`asection *osec;`	`asection *osec;`

`for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)`	`for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)`
`print_space ();`	`print_space ();`

`if (assignment->exp->type.node_class == etree_assert)`	`if (assignment->exp->type.node_class == etree_assert)`
`{`	`{`
`is_dot = FALSE;`	`is_dot = FALSE;`
`tree = assignment->exp->assert_s.child;`	`tree = assignment->exp->assert_s.child;`
`computation_is_valid = TRUE;`	`computation_is_valid = TRUE;`
`}`	`}`
`else`	`else`
`{`	`{`
`const char *dst = assignment->exp->assign.dst;`	`const char *dst = assignment->exp->assign.dst;`

`is_dot = (dst[0] == '.' && dst[1] == 0);`	`is_dot = (dst[0] == '.' && dst[1] == 0);`
`tree = assignment->exp->assign.src;`	`tree = assignment->exp->assign.src;`
`computation_is_valid = is_dot \|\| !scan_for_self_assignment (dst, tree);`	`computation_is_valid = is_dot \|\| !scan_for_self_assignment (dst, tree);`
`}`	`}`

`osec = output_section->bfd_section;`	`osec = output_section->bfd_section;`
`if (osec == NULL)`	`if (osec == NULL)`
`osec = bfd_abs_section_ptr;`	`osec = bfd_abs_section_ptr;`
`exp_fold_tree (tree, osec, &print_dot);`	`exp_fold_tree (tree, osec, &print_dot);`
`if (expld.result.valid_p)`	`if (expld.result.valid_p)`
`{`	`{`
`bfd_vma value;`	`bfd_vma value;`

`if (computation_is_valid)`	`if (computation_is_valid)`
`{`	`{`
`value = expld.result.value;`	`value = expld.result.value;`

`if (expld.result.section != NULL)`	`if (expld.result.section != NULL)`
`value += expld.result.section->vma;`	`value += expld.result.section->vma;`

`minfo ("0x%V", value);`	`minfo ("0x%V", value);`
`if (is_dot)`	`if (is_dot)`
`print_dot = value;`	`print_dot = value;`
`}`	`}`
`else`	`else`
`{`	`{`
`struct bfd_link_hash_entry *h;`	`struct bfd_link_hash_entry *h;`

`h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,`	`h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,`
`FALSE, FALSE, TRUE);`	`FALSE, FALSE, TRUE);`
`if (h)`	`if (h)`
`{`	`{`
`value = h->u.def.value;`	`value = h->u.def.value;`
`value += h->u.def.section->output_section->vma;`	`value += h->u.def.section->output_section->vma;`
`value += h->u.def.section->output_offset;`	`value += h->u.def.section->output_offset;`

`minfo ("[0x%V]", value);`	`minfo ("[0x%V]", value);`
`}`	`}`
`else`	`else`
`minfo ("[unresolved]");`	`minfo ("[unresolved]");`
`}`	`}`
`}`	`}`
`else`	`else`
`{`	`{`
`minfo ("undef ");`	`minfo ("undef ");`
`#ifdef BFD64`	`#ifdef BFD64`
`minfo (" ");`	`minfo (" ");`
`#endif`	`#endif`
`}`	`}`

`minfo (" ");`	`minfo (" ");`
`exp_print_tree (assignment->exp);`	`exp_print_tree (assignment->exp);`
`print_nl ();`	`print_nl ();`
`}`	`}`

`static void`	`static void`
`print_input_statement (lang_input_statement_type *statm)`	`print_input_statement (lang_input_statement_type *statm)`
`{`	`{`
`if (statm->filename != NULL`	`if (statm->filename != NULL`
`&& (statm->the_bfd == NULL`	`&& (statm->the_bfd == NULL`
`\|\| (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))`	`\|\| (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))`
`fprintf (config.map_file, "LOAD %s\n", statm->filename);`	`fprintf (config.map_file, "LOAD %s\n", statm->filename);`
`}`	`}`

`/* Print all symbols defined in a particular section. This is called`	`/* Print all symbols defined in a particular section. This is called`
`via bfd_link_hash_traverse, or by print_all_symbols. */`	`via bfd_link_hash_traverse, or by print_all_symbols. */`

`static bfd_boolean`	`static bfd_boolean`
`print_one_symbol (struct bfd_link_hash_entry hash_entry, void ptr)`	`print_one_symbol (struct bfd_link_hash_entry hash_entry, void ptr)`
`{`	`{`
`asection sec = (asection ) ptr;`	`asection sec = (asection ) ptr;`

`if ((hash_entry->type == bfd_link_hash_defined`	`if ((hash_entry->type == bfd_link_hash_defined`
`\|\| hash_entry->type == bfd_link_hash_defweak)`	`\|\| hash_entry->type == bfd_link_hash_defweak)`
`&& sec == hash_entry->u.def.section)`	`&& sec == hash_entry->u.def.section)`
`{`	`{`
`int i;`	`int i;`

`for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)`	`for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)`
`print_space ();`	`print_space ();`
`minfo ("0x%V ",`	`minfo ("0x%V ",`
`(hash_entry->u.def.value`	`(hash_entry->u.def.value`
`+ hash_entry->u.def.section->output_offset`	`+ hash_entry->u.def.section->output_offset`
`+ hash_entry->u.def.section->output_section->vma));`	`+ hash_entry->u.def.section->output_section->vma));`

`minfo (" %T\n", hash_entry->root.string);`	`minfo (" %T\n", hash_entry->root.string);`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`static int`	`static int`
`hash_entry_addr_cmp (const void a, const void b)`	`hash_entry_addr_cmp (const void a, const void b)`
`{`	`{`
`const struct bfd_link_hash_entry l = (const struct bfd_link_hash_entry **)a;`	`const struct bfd_link_hash_entry l = (const struct bfd_link_hash_entry **)a;`
`const struct bfd_link_hash_entry r = (const struct bfd_link_hash_entry **)b;`	`const struct bfd_link_hash_entry r = (const struct bfd_link_hash_entry **)b;`

`if (l->u.def.value < r->u.def.value)`	`if (l->u.def.value < r->u.def.value)`
`return -1;`	`return -1;`
`else if (l->u.def.value > r->u.def.value)`	`else if (l->u.def.value > r->u.def.value)`
`return 1;`	`return 1;`
`else`	`else`
`return 0;`	`return 0;`
`}`	`}`

`static void`	`static void`
`print_all_symbols (asection *sec)`	`print_all_symbols (asection *sec)`
`{`	`{`
`struct fat_user_section_struct *ud =`	`struct fat_user_section_struct *ud =`
`(struct fat_user_section_struct *) get_userdata (sec);`	`(struct fat_user_section_struct *) get_userdata (sec);`
`struct map_symbol_def *def;`	`struct map_symbol_def *def;`
`struct bfd_link_hash_entry **entries;`	`struct bfd_link_hash_entry **entries;`
`unsigned int i;`	`unsigned int i;`

`if (!ud)`	`if (!ud)`
`return;`	`return;`

`*ud->map_symbol_def_tail = 0;`	`*ud->map_symbol_def_tail = 0;`

`/* Sort the symbols by address. */`	`/* Sort the symbols by address. */`
`entries = (struct bfd_link_hash_entry **)`	`entries = (struct bfd_link_hash_entry **)`
`obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));`	`obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));`

`for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)`	`for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)`
`entries[i] = def->entry;`	`entries[i] = def->entry;`

`qsort (entries, ud->map_symbol_def_count, sizeof (*entries),`	`qsort (entries, ud->map_symbol_def_count, sizeof (*entries),`
`hash_entry_addr_cmp);`	`hash_entry_addr_cmp);`

`/* Print the symbols. */`	`/* Print the symbols. */`
`for (i = 0; i < ud->map_symbol_def_count; i++)`	`for (i = 0; i < ud->map_symbol_def_count; i++)`
`print_one_symbol (entries[i], sec);`	`print_one_symbol (entries[i], sec);`

`obstack_free (&map_obstack, entries);`	`obstack_free (&map_obstack, entries);`
`}`	`}`

`/* Print information about an input section to the map file. */`	`/* Print information about an input section to the map file. */`

`static void`	`static void`
`print_input_section (asection *i, bfd_boolean is_discarded)`	`print_input_section (asection *i, bfd_boolean is_discarded)`
`{`	`{`
`bfd_size_type size = i->size;`	`bfd_size_type size = i->size;`
`int len;`	`int len;`
`bfd_vma addr;`	`bfd_vma addr;`

`init_opb ();`	`init_opb ();`

`print_space ();`	`print_space ();`
`minfo ("%s", i->name);`	`minfo ("%s", i->name);`

`len = 1 + strlen (i->name);`	`len = 1 + strlen (i->name);`
`if (len >= SECTION_NAME_MAP_LENGTH - 1)`	`if (len >= SECTION_NAME_MAP_LENGTH - 1)`
`{`	`{`
`print_nl ();`	`print_nl ();`
`len = 0;`	`len = 0;`
`}`	`}`
`while (len < SECTION_NAME_MAP_LENGTH)`	`while (len < SECTION_NAME_MAP_LENGTH)`
`{`	`{`
`print_space ();`	`print_space ();`
`++len;`	`++len;`
`}`	`}`

`if (i->output_section != NULL`	`if (i->output_section != NULL`
`&& i->output_section->owner == link_info.output_bfd)`	`&& i->output_section->owner == link_info.output_bfd)`
`addr = i->output_section->vma + i->output_offset;`	`addr = i->output_section->vma + i->output_offset;`
`else`	`else`
`{`	`{`
`addr = print_dot;`	`addr = print_dot;`
`if (!is_discarded)`	`if (!is_discarded)`
`size = 0;`	`size = 0;`
`}`	`}`

`minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);`	`minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);`

`if (size != i->rawsize && i->rawsize != 0)`	`if (size != i->rawsize && i->rawsize != 0)`
`{`	`{`
`len = SECTION_NAME_MAP_LENGTH + 3;`	`len = SECTION_NAME_MAP_LENGTH + 3;`
`#ifdef BFD64`	`#ifdef BFD64`
`len += 16;`	`len += 16;`
`#else`	`#else`
`len += 8;`	`len += 8;`
`#endif`	`#endif`
`while (len > 0)`	`while (len > 0)`
`{`	`{`
`print_space ();`	`print_space ();`
`--len;`	`--len;`
`}`	`}`

`minfo (_("%W (size before relaxing)\n"), i->rawsize);`	`minfo (_("%W (size before relaxing)\n"), i->rawsize);`
`}`	`}`

`if (i->output_section != NULL`	`if (i->output_section != NULL`
`&& i->output_section->owner == link_info.output_bfd)`	`&& i->output_section->owner == link_info.output_bfd)`
`{`	`{`
`if (link_info.reduce_memory_overheads)`	`if (link_info.reduce_memory_overheads)`
`bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);`	`bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);`
`else`	`else`
`print_all_symbols (i);`	`print_all_symbols (i);`

`/* Update print_dot, but make sure that we do not move it`	`/* Update print_dot, but make sure that we do not move it`
`backwards - this could happen if we have overlays and a`	`backwards - this could happen if we have overlays and a`
`later overlay is shorter than an earier one. */`	`later overlay is shorter than an earier one. */`
`if (addr + TO_ADDR (size) > print_dot)`	`if (addr + TO_ADDR (size) > print_dot)`
`print_dot = addr + TO_ADDR (size);`	`print_dot = addr + TO_ADDR (size);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`print_fill_statement (lang_fill_statement_type *fill)`	`print_fill_statement (lang_fill_statement_type *fill)`
`{`	`{`
`size_t size;`	`size_t size;`
`unsigned char *p;`	`unsigned char *p;`
`fputs (" FILL mask 0x", config.map_file);`	`fputs (" FILL mask 0x", config.map_file);`
`for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)`	`for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)`
`fprintf (config.map_file, "%02x", *p);`	`fprintf (config.map_file, "%02x", *p);`
`fputs ("\n", config.map_file);`	`fputs ("\n", config.map_file);`
`}`	`}`

`static void`	`static void`
`print_data_statement (lang_data_statement_type *data)`	`print_data_statement (lang_data_statement_type *data)`
`{`	`{`
`int i;`	`int i;`
`bfd_vma addr;`	`bfd_vma addr;`
`bfd_size_type size;`	`bfd_size_type size;`
`const char *name;`	`const char *name;`

`init_opb ();`	`init_opb ();`
`for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)`	`for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)`
`print_space ();`	`print_space ();`

`addr = data->output_offset;`	`addr = data->output_offset;`
`if (data->output_section != NULL)`	`if (data->output_section != NULL)`
`addr += data->output_section->vma;`	`addr += data->output_section->vma;`

`switch (data->type)`	`switch (data->type)`
`{`	`{`
`default:`	`default:`
`abort ();`	`abort ();`
`case BYTE:`	`case BYTE:`
`size = BYTE_SIZE;`	`size = BYTE_SIZE;`
`name = "BYTE";`	`name = "BYTE";`
`break;`	`break;`
`case SHORT:`	`case SHORT:`
`size = SHORT_SIZE;`	`size = SHORT_SIZE;`
`name = "SHORT";`	`name = "SHORT";`
`break;`	`break;`
`case LONG:`	`case LONG:`
`size = LONG_SIZE;`	`size = LONG_SIZE;`
`name = "LONG";`	`name = "LONG";`
`break;`	`break;`
`case QUAD:`	`case QUAD:`
`size = QUAD_SIZE;`	`size = QUAD_SIZE;`
`name = "QUAD";`	`name = "QUAD";`
`break;`	`break;`
`case SQUAD:`	`case SQUAD:`
`size = QUAD_SIZE;`	`size = QUAD_SIZE;`
`name = "SQUAD";`	`name = "SQUAD";`
`break;`	`break;`
`}`	`}`

`minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);`	`minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);`

`if (data->exp->type.node_class != etree_value)`	`if (data->exp->type.node_class != etree_value)`
`{`	`{`
`print_space ();`	`print_space ();`
`exp_print_tree (data->exp);`	`exp_print_tree (data->exp);`
`}`	`}`

`print_nl ();`	`print_nl ();`

`print_dot = addr + TO_ADDR (size);`	`print_dot = addr + TO_ADDR (size);`
`}`	`}`

`/* Print an address statement. These are generated by options like`	`/* Print an address statement. These are generated by options like`
`-Ttext. */`	`-Ttext. */`

`static void`	`static void`
`print_address_statement (lang_address_statement_type *address)`	`print_address_statement (lang_address_statement_type *address)`
`{`	`{`
`minfo (_("Address of section %s set to "), address->section_name);`	`minfo (_("Address of section %s set to "), address->section_name);`
`exp_print_tree (address->address);`	`exp_print_tree (address->address);`
`print_nl ();`	`print_nl ();`
`}`	`}`

`/* Print a reloc statement. */`	`/* Print a reloc statement. */`

`static void`	`static void`
`print_reloc_statement (lang_reloc_statement_type *reloc)`	`print_reloc_statement (lang_reloc_statement_type *reloc)`
`{`	`{`
`int i;`	`int i;`
`bfd_vma addr;`	`bfd_vma addr;`
`bfd_size_type size;`	`bfd_size_type size;`

`init_opb ();`	`init_opb ();`
`for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)`	`for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)`
`print_space ();`	`print_space ();`

`addr = reloc->output_offset;`	`addr = reloc->output_offset;`
`if (reloc->output_section != NULL)`	`if (reloc->output_section != NULL)`
`addr += reloc->output_section->vma;`	`addr += reloc->output_section->vma;`

`size = bfd_get_reloc_size (reloc->howto);`	`size = bfd_get_reloc_size (reloc->howto);`

`minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);`	`minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);`

`if (reloc->name != NULL)`	`if (reloc->name != NULL)`
`minfo ("%s+", reloc->name);`	`minfo ("%s+", reloc->name);`
`else`	`else`
`minfo ("%s+", reloc->section->name);`	`minfo ("%s+", reloc->section->name);`

`exp_print_tree (reloc->addend_exp);`	`exp_print_tree (reloc->addend_exp);`

`print_nl ();`	`print_nl ();`

`print_dot = addr + TO_ADDR (size);`	`print_dot = addr + TO_ADDR (size);`
`}`	`}`

`static void`	`static void`
`print_padding_statement (lang_padding_statement_type *s)`	`print_padding_statement (lang_padding_statement_type *s)`
`{`	`{`
`int len;`	`int len;`
`bfd_vma addr;`	`bfd_vma addr;`

`init_opb ();`	`init_opb ();`
`minfo (" fill");`	`minfo (" fill");`

`len = sizeof " fill" - 1;`	`len = sizeof " fill" - 1;`
`while (len < SECTION_NAME_MAP_LENGTH)`	`while (len < SECTION_NAME_MAP_LENGTH)`
`{`	`{`
`print_space ();`	`print_space ();`
`++len;`	`++len;`
`}`	`}`

`addr = s->output_offset;`	`addr = s->output_offset;`
`if (s->output_section != NULL)`	`if (s->output_section != NULL)`
`addr += s->output_section->vma;`	`addr += s->output_section->vma;`
`minfo ("0x%V %W ", addr, (bfd_vma) s->size);`	`minfo ("0x%V %W ", addr, (bfd_vma) s->size);`

`if (s->fill->size != 0)`	`if (s->fill->size != 0)`
`{`	`{`
`size_t size;`	`size_t size;`
`unsigned char *p;`	`unsigned char *p;`
`for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)`	`for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)`
`fprintf (config.map_file, "%02x", *p);`	`fprintf (config.map_file, "%02x", *p);`
`}`	`}`

`print_nl ();`	`print_nl ();`

`print_dot = addr + TO_ADDR (s->size);`	`print_dot = addr + TO_ADDR (s->size);`
`}`	`}`

`static void`	`static void`
`print_wild_statement (lang_wild_statement_type *w,`	`print_wild_statement (lang_wild_statement_type *w,`
`lang_output_section_statement_type *os)`	`lang_output_section_statement_type *os)`
`{`	`{`
`struct wildcard_list *sec;`	`struct wildcard_list *sec;`

`print_space ();`	`print_space ();`

`if (w->filenames_sorted)`	`if (w->filenames_sorted)`
`minfo ("SORT(");`	`minfo ("SORT(");`
`if (w->filename != NULL)`	`if (w->filename != NULL)`
`minfo ("%s", w->filename);`	`minfo ("%s", w->filename);`
`else`	`else`
`minfo ("*");`	`minfo ("*");`
`if (w->filenames_sorted)`	`if (w->filenames_sorted)`
`minfo (")");`	`minfo (")");`

`minfo ("(");`	`minfo ("(");`
`for (sec = w->section_list; sec; sec = sec->next)`	`for (sec = w->section_list; sec; sec = sec->next)`
`{`	`{`
`if (sec->spec.sorted)`	`if (sec->spec.sorted)`
`minfo ("SORT(");`	`minfo ("SORT(");`
`if (sec->spec.exclude_name_list != NULL)`	`if (sec->spec.exclude_name_list != NULL)`
`{`	`{`
`name_list *tmp;`	`name_list *tmp;`
`minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);`	`minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);`
`for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)`	`for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)`
`minfo (" %s", tmp->name);`	`minfo (" %s", tmp->name);`
`minfo (") ");`	`minfo (") ");`
`}`	`}`
`if (sec->spec.name != NULL)`	`if (sec->spec.name != NULL)`
`minfo ("%s", sec->spec.name);`	`minfo ("%s", sec->spec.name);`
`else`	`else`
`minfo ("*");`	`minfo ("*");`
`if (sec->spec.sorted)`	`if (sec->spec.sorted)`
`minfo (")");`	`minfo (")");`
`if (sec->next)`	`if (sec->next)`
`minfo (" ");`	`minfo (" ");`
`}`	`}`
`minfo (")");`	`minfo (")");`

`print_nl ();`	`print_nl ();`

`print_statement_list (w->children.head, os);`	`print_statement_list (w->children.head, os);`
`}`	`}`

`/* Print a group statement. */`	`/* Print a group statement. */`

`static void`	`static void`
`print_group (lang_group_statement_type *s,`	`print_group (lang_group_statement_type *s,`
`lang_output_section_statement_type *os)`	`lang_output_section_statement_type *os)`
`{`	`{`
`fprintf (config.map_file, "START GROUP\n");`	`fprintf (config.map_file, "START GROUP\n");`
`print_statement_list (s->children.head, os);`	`print_statement_list (s->children.head, os);`
`fprintf (config.map_file, "END GROUP\n");`	`fprintf (config.map_file, "END GROUP\n");`
`}`	`}`

`/* Print the list of statements in S.`	`/* Print the list of statements in S.`
`This can be called for any statement type. */`	`This can be called for any statement type. */`

`static void`	`static void`
`print_statement_list (lang_statement_union_type *s,`	`print_statement_list (lang_statement_union_type *s,`
`lang_output_section_statement_type *os)`	`lang_output_section_statement_type *os)`
`{`	`{`
`while (s != NULL)`	`while (s != NULL)`
`{`	`{`
`print_statement (s, os);`	`print_statement (s, os);`
`s = s->header.next;`	`s = s->header.next;`
`}`	`}`
`}`	`}`

`/* Print the first statement in statement list S.`	`/* Print the first statement in statement list S.`
`This can be called for any statement type. */`	`This can be called for any statement type. */`

`static void`	`static void`
`print_statement (lang_statement_union_type *s,`	`print_statement (lang_statement_union_type *s,`
`lang_output_section_statement_type *os)`	`lang_output_section_statement_type *os)`
`{`	`{`
`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`default:`	`default:`
`fprintf (config.map_file, _("Fail with %d\n"), s->header.type);`	`fprintf (config.map_file, _("Fail with %d\n"), s->header.type);`
`FAIL ();`	`FAIL ();`
`break;`	`break;`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`if (constructor_list.head != NULL)`	`if (constructor_list.head != NULL)`
`{`	`{`
`if (constructors_sorted)`	`if (constructors_sorted)`
`minfo (" SORT (CONSTRUCTORS)\n");`	`minfo (" SORT (CONSTRUCTORS)\n");`
`else`	`else`
`minfo (" CONSTRUCTORS\n");`	`minfo (" CONSTRUCTORS\n");`
`print_statement_list (constructor_list.head, os);`	`print_statement_list (constructor_list.head, os);`
`}`	`}`
`break;`	`break;`
`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`print_wild_statement (&s->wild_statement, os);`	`print_wild_statement (&s->wild_statement, os);`
`break;`	`break;`
`case lang_address_statement_enum:`	`case lang_address_statement_enum:`
`print_address_statement (&s->address_statement);`	`print_address_statement (&s->address_statement);`
`break;`	`break;`
`case lang_object_symbols_statement_enum:`	`case lang_object_symbols_statement_enum:`
`minfo (" CREATE_OBJECT_SYMBOLS\n");`	`minfo (" CREATE_OBJECT_SYMBOLS\n");`
`break;`	`break;`
`case lang_fill_statement_enum:`	`case lang_fill_statement_enum:`
`print_fill_statement (&s->fill_statement);`	`print_fill_statement (&s->fill_statement);`
`break;`	`break;`
`case lang_data_statement_enum:`	`case lang_data_statement_enum:`
`print_data_statement (&s->data_statement);`	`print_data_statement (&s->data_statement);`
`break;`	`break;`
`case lang_reloc_statement_enum:`	`case lang_reloc_statement_enum:`
`print_reloc_statement (&s->reloc_statement);`	`print_reloc_statement (&s->reloc_statement);`
`break;`	`break;`
`case lang_input_section_enum:`	`case lang_input_section_enum:`
`print_input_section (s->input_section.section, FALSE);`	`print_input_section (s->input_section.section, FALSE);`
`break;`	`break;`
`case lang_padding_statement_enum:`	`case lang_padding_statement_enum:`
`print_padding_statement (&s->padding_statement);`	`print_padding_statement (&s->padding_statement);`
`break;`	`break;`
`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`print_output_section_statement (&s->output_section_statement);`	`print_output_section_statement (&s->output_section_statement);`
`break;`	`break;`
`case lang_assignment_statement_enum:`	`case lang_assignment_statement_enum:`
`print_assignment (&s->assignment_statement, os);`	`print_assignment (&s->assignment_statement, os);`
`break;`	`break;`
`case lang_target_statement_enum:`	`case lang_target_statement_enum:`
`fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);`	`fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);`
`break;`	`break;`
`case lang_output_statement_enum:`	`case lang_output_statement_enum:`
`minfo ("OUTPUT(%s", s->output_statement.name);`	`minfo ("OUTPUT(%s", s->output_statement.name);`
`if (output_target != NULL)`	`if (output_target != NULL)`
`minfo (" %s", output_target);`	`minfo (" %s", output_target);`
`minfo (")\n");`	`minfo (")\n");`
`break;`	`break;`
`case lang_input_statement_enum:`	`case lang_input_statement_enum:`
`print_input_statement (&s->input_statement);`	`print_input_statement (&s->input_statement);`
`break;`	`break;`
`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`print_group (&s->group_statement, os);`	`print_group (&s->group_statement, os);`
`break;`	`break;`
`case lang_insert_statement_enum:`	`case lang_insert_statement_enum:`
`minfo ("INSERT %s %s\n",`	`minfo ("INSERT %s %s\n",`
`s->insert_statement.is_before ? "BEFORE" : "AFTER",`	`s->insert_statement.is_before ? "BEFORE" : "AFTER",`
`s->insert_statement.where);`	`s->insert_statement.where);`
`break;`	`break;`
`}`	`}`
`}`	`}`

`static void`	`static void`
`print_statements (void)`	`print_statements (void)`
`{`	`{`
`print_statement_list (statement_list.head, abs_output_section);`	`print_statement_list (statement_list.head, abs_output_section);`
`}`	`}`

`/* Print the first N statements in statement list S to STDERR.`	`/* Print the first N statements in statement list S to STDERR.`
`If N == 0, nothing is printed.`	`If N == 0, nothing is printed.`
`If N < 0, the entire list is printed.`	`If N < 0, the entire list is printed.`
`Intended to be called from GDB. */`	`Intended to be called from GDB. */`

`void`	`void`
`dprint_statement (lang_statement_union_type *s, int n)`	`dprint_statement (lang_statement_union_type *s, int n)`
`{`	`{`
`FILE *map_save = config.map_file;`	`FILE *map_save = config.map_file;`

`config.map_file = stderr;`	`config.map_file = stderr;`

`if (n < 0)`	`if (n < 0)`
`print_statement_list (s, abs_output_section);`	`print_statement_list (s, abs_output_section);`
`else`	`else`
`{`	`{`
`while (s && --n >= 0)`	`while (s && --n >= 0)`
`{`	`{`
`print_statement (s, abs_output_section);`	`print_statement (s, abs_output_section);`
`s = s->header.next;`	`s = s->header.next;`
`}`	`}`
`}`	`}`

`config.map_file = map_save;`	`config.map_file = map_save;`
`}`	`}`

`static void`	`static void`
`insert_pad (lang_statement_union_type **ptr,`	`insert_pad (lang_statement_union_type **ptr,`
`fill_type *fill,`	`fill_type *fill,`
`unsigned int alignment_needed,`	`unsigned int alignment_needed,`
`asection *output_section,`	`asection *output_section,`
`bfd_vma dot)`	`bfd_vma dot)`
`{`	`{`
`static fill_type zero_fill = { 1, { 0 } };`	`static fill_type zero_fill = { 1, { 0 } };`
`lang_statement_union_type *pad = NULL;`	`lang_statement_union_type *pad = NULL;`

`if (ptr != &statement_list.head)`	`if (ptr != &statement_list.head)`
`pad = ((lang_statement_union_type *)`	`pad = ((lang_statement_union_type *)`
`((char *) ptr - offsetof (lang_statement_union_type, header.next)));`	`((char *) ptr - offsetof (lang_statement_union_type, header.next)));`
`if (pad != NULL`	`if (pad != NULL`
`&& pad->header.type == lang_padding_statement_enum`	`&& pad->header.type == lang_padding_statement_enum`
`&& pad->padding_statement.output_section == output_section)`	`&& pad->padding_statement.output_section == output_section)`
`{`	`{`
`/* Use the existing pad statement. */`	`/* Use the existing pad statement. */`
`}`	`}`
`else if ((pad = *ptr) != NULL`	`else if ((pad = *ptr) != NULL`
`&& pad->header.type == lang_padding_statement_enum`	`&& pad->header.type == lang_padding_statement_enum`
`&& pad->padding_statement.output_section == output_section)`	`&& pad->padding_statement.output_section == output_section)`
`{`	`{`
`/* Use the existing pad statement. */`	`/* Use the existing pad statement. */`
`}`	`}`
`else`	`else`
`{`	`{`
`/* Make a new padding statement, linked into existing chain. */`	`/* Make a new padding statement, linked into existing chain. */`
`pad = (lang_statement_union_type *)`	`pad = (lang_statement_union_type *)`
`stat_alloc (sizeof (lang_padding_statement_type));`	`stat_alloc (sizeof (lang_padding_statement_type));`
`pad->header.next = *ptr;`	`pad->header.next = *ptr;`
`*ptr = pad;`	`*ptr = pad;`
`pad->header.type = lang_padding_statement_enum;`	`pad->header.type = lang_padding_statement_enum;`
`pad->padding_statement.output_section = output_section;`	`pad->padding_statement.output_section = output_section;`
`if (fill == NULL)`	`if (fill == NULL)`
`fill = &zero_fill;`	`fill = &zero_fill;`
`pad->padding_statement.fill = fill;`	`pad->padding_statement.fill = fill;`
`}`	`}`
`pad->padding_statement.output_offset = dot - output_section->vma;`	`pad->padding_statement.output_offset = dot - output_section->vma;`
`pad->padding_statement.size = alignment_needed;`	`pad->padding_statement.size = alignment_needed;`
`output_section->size += alignment_needed;`	`output_section->size += alignment_needed;`
`}`	`}`

`/* Work out how much this section will move the dot point. */`	`/* Work out how much this section will move the dot point. */`

`static bfd_vma`	`static bfd_vma`
`size_input_section`	`size_input_section`
`(lang_statement_union_type **this_ptr,`	`(lang_statement_union_type **this_ptr,`
`lang_output_section_statement_type *output_section_statement,`	`lang_output_section_statement_type *output_section_statement,`
`fill_type *fill,`	`fill_type *fill,`
`bfd_vma dot)`	`bfd_vma dot)`
`{`	`{`
`lang_input_section_type is = &((this_ptr)->input_section);`	`lang_input_section_type is = &((this_ptr)->input_section);`
`asection *i = is->section;`	`asection *i = is->section;`

`if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag`	`if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag`
`&& (i->flags & SEC_EXCLUDE) == 0)`	`&& (i->flags & SEC_EXCLUDE) == 0)`
`{`	`{`
`unsigned int alignment_needed;`	`unsigned int alignment_needed;`
`asection *o;`	`asection *o;`

`/* Align this section first to the input sections requirement,`	`/* Align this section first to the input sections requirement,`
`then to the output section's requirement. If this alignment`	`then to the output section's requirement. If this alignment`
`is greater than any seen before, then record it too. Perform`	`is greater than any seen before, then record it too. Perform`
`the alignment by inserting a magic 'padding' statement. */`	`the alignment by inserting a magic 'padding' statement. */`

`if (output_section_statement->subsection_alignment != -1)`	`if (output_section_statement->subsection_alignment != -1)`
`i->alignment_power = output_section_statement->subsection_alignment;`	`i->alignment_power = output_section_statement->subsection_alignment;`

`o = output_section_statement->bfd_section;`	`o = output_section_statement->bfd_section;`
`if (o->alignment_power < i->alignment_power)`	`if (o->alignment_power < i->alignment_power)`
`o->alignment_power = i->alignment_power;`	`o->alignment_power = i->alignment_power;`

`alignment_needed = align_power (dot, i->alignment_power) - dot;`	`alignment_needed = align_power (dot, i->alignment_power) - dot;`

`if (alignment_needed != 0)`	`if (alignment_needed != 0)`
`{`	`{`
`insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);`	`insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);`
`dot += alignment_needed;`	`dot += alignment_needed;`
`}`	`}`

`/* Remember where in the output section this input section goes. */`	`/* Remember where in the output section this input section goes. */`

`i->output_offset = dot - o->vma;`	`i->output_offset = dot - o->vma;`

`/* Mark how big the output section must be to contain this now. */`	`/* Mark how big the output section must be to contain this now. */`
`dot += TO_ADDR (i->size);`	`dot += TO_ADDR (i->size);`
`o->size = TO_SIZE (dot - o->vma);`	`o->size = TO_SIZE (dot - o->vma);`
`}`	`}`
`else`	`else`
`{`	`{`
`i->output_offset = i->vma - output_section_statement->bfd_section->vma;`	`i->output_offset = i->vma - output_section_statement->bfd_section->vma;`
`}`	`}`

`return dot;`	`return dot;`
`}`	`}`

`static int`	`static int`
`sort_sections_by_lma (const void arg1, const void arg2)`	`sort_sections_by_lma (const void arg1, const void arg2)`
`{`	`{`
`const asection sec1 = (const asection **) arg1;`	`const asection sec1 = (const asection **) arg1;`
`const asection sec2 = (const asection **) arg2;`	`const asection sec2 = (const asection **) arg2;`

`if (bfd_section_lma (sec1->owner, sec1)`	`if (bfd_section_lma (sec1->owner, sec1)`
`< bfd_section_lma (sec2->owner, sec2))`	`< bfd_section_lma (sec2->owner, sec2))`
`return -1;`	`return -1;`
`else if (bfd_section_lma (sec1->owner, sec1)`	`else if (bfd_section_lma (sec1->owner, sec1)`
`> bfd_section_lma (sec2->owner, sec2))`	`> bfd_section_lma (sec2->owner, sec2))`
`return 1;`	`return 1;`
`else if (sec1->id < sec2->id)`	`else if (sec1->id < sec2->id)`
`return -1;`	`return -1;`
`else if (sec1->id > sec2->id)`	`else if (sec1->id > sec2->id)`
`return 1;`	`return 1;`

`return 0;`	`return 0;`
`}`	`}`

`#define IGNORE_SECTION(s) \`	`#define IGNORE_SECTION(s) \`
`((s->flags & SEC_ALLOC) == 0 \`	`((s->flags & SEC_ALLOC) == 0 \`
`\|\| ((s->flags & SEC_THREAD_LOCAL) != 0 \`	`\|\| ((s->flags & SEC_THREAD_LOCAL) != 0 \`
`&& (s->flags & SEC_LOAD) == 0))`	`&& (s->flags & SEC_LOAD) == 0))`

`/* Check to see if any allocated sections overlap with other allocated`	`/* Check to see if any allocated sections overlap with other allocated`
`sections. This can happen if a linker script specifies the output`	`sections. This can happen if a linker script specifies the output`
`section addresses of the two sections. Also check whether any memory`	`section addresses of the two sections. Also check whether any memory`
`region has overflowed. */`	`region has overflowed. */`

`static void`	`static void`
`lang_check_section_addresses (void)`	`lang_check_section_addresses (void)`
`{`	`{`
`asection s, p;`	`asection s, p;`
`asection sections, spp;`	`asection sections, spp;`
`unsigned int count;`	`unsigned int count;`
`bfd_vma s_start;`	`bfd_vma s_start;`
`bfd_vma s_end;`	`bfd_vma s_end;`
`bfd_vma p_start;`	`bfd_vma p_start;`
`bfd_vma p_end;`	`bfd_vma p_end;`
`bfd_size_type amt;`	`bfd_size_type amt;`
`lang_memory_region_type *m;`	`lang_memory_region_type *m;`

`if (bfd_count_sections (link_info.output_bfd) <= 1)`	`if (bfd_count_sections (link_info.output_bfd) <= 1)`
`return;`	`return;`

`amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);`	`amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);`
`sections = (asection **) xmalloc (amt);`	`sections = (asection **) xmalloc (amt);`

`/* Scan all sections in the output list. */`	`/* Scan all sections in the output list. */`
`count = 0;`	`count = 0;`
`for (s = link_info.output_bfd->sections; s != NULL; s = s->next)`	`for (s = link_info.output_bfd->sections; s != NULL; s = s->next)`
`{`	`{`
`/* Only consider loadable sections with real contents. */`	`/* Only consider loadable sections with real contents. */`
`if (!(s->flags & SEC_LOAD)`	`if (!(s->flags & SEC_LOAD)`
`\|\| !(s->flags & SEC_ALLOC)`	`\|\| !(s->flags & SEC_ALLOC)`
`\|\| s->size == 0)`	`\|\| s->size == 0)`
`continue;`	`continue;`

`sections[count] = s;`	`sections[count] = s;`
`count++;`	`count++;`
`}`	`}`

`if (count <= 1)`	`if (count <= 1)`
`return;`	`return;`

`qsort (sections, (size_t) count, sizeof (asection *),`	`qsort (sections, (size_t) count, sizeof (asection *),`
`sort_sections_by_lma);`	`sort_sections_by_lma);`

`spp = sections;`	`spp = sections;`
`s = *spp++;`	`s = *spp++;`
`s_start = s->lma;`	`s_start = s->lma;`
`s_end = s_start + TO_ADDR (s->size) - 1;`	`s_end = s_start + TO_ADDR (s->size) - 1;`
`for (count--; count; count--)`	`for (count--; count; count--)`
`{`	`{`
`/* We must check the sections' LMA addresses not their VMA`	`/* We must check the sections' LMA addresses not their VMA`
`addresses because overlay sections can have overlapping VMAs`	`addresses because overlay sections can have overlapping VMAs`
`but they must have distinct LMAs. */`	`but they must have distinct LMAs. */`
`p = s;`	`p = s;`
`p_start = s_start;`	`p_start = s_start;`
`p_end = s_end;`	`p_end = s_end;`
`s = *spp++;`	`s = *spp++;`
`s_start = s->lma;`	`s_start = s->lma;`
`s_end = s_start + TO_ADDR (s->size) - 1;`	`s_end = s_start + TO_ADDR (s->size) - 1;`

`/* Look for an overlap. We have sorted sections by lma, so we`	`/* Look for an overlap. We have sorted sections by lma, so we`
`know that s_start >= p_start. Besides the obvious case of`	`know that s_start >= p_start. Besides the obvious case of`
`overlap when the current section starts before the previous`	`overlap when the current section starts before the previous`
`one ends, we also must have overlap if the previous section`	`one ends, we also must have overlap if the previous section`
`wraps around the address space. */`	`wraps around the address space. */`
`if (s_start <= p_end`	`if (s_start <= p_end`
`\|\| p_end < p_start)`	`\|\| p_end < p_start)`
`einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),`	`einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),`
`s->name, s_start, s_end, p->name, p_start, p_end);`	`s->name, s_start, s_end, p->name, p_start, p_end);`
`}`	`}`

`free (sections);`	`free (sections);`

`/* If any memory region has overflowed, report by how much.`	`/* If any memory region has overflowed, report by how much.`
`We do not issue this diagnostic for regions that had sections`	`We do not issue this diagnostic for regions that had sections`
`explicitly placed outside their bounds; os_region_check's`	`explicitly placed outside their bounds; os_region_check's`
`diagnostics are adequate for that case.`	`diagnostics are adequate for that case.`

`FIXME: It is conceivable that m->current - (m->origin + m->length)`	`FIXME: It is conceivable that m->current - (m->origin + m->length)`
`might overflow a 32-bit integer. There is, alas, no way to print`	`might overflow a 32-bit integer. There is, alas, no way to print`
`a bfd_vma quantity in decimal. */`	`a bfd_vma quantity in decimal. */`
`for (m = lang_memory_region_list; m; m = m->next)`	`for (m = lang_memory_region_list; m; m = m->next)`
`if (m->had_full_message)`	`if (m->had_full_message)`
einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),	einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
`m->name_list.name, (long)(m->current - (m->origin + m->length)));`	`m->name_list.name, (long)(m->current - (m->origin + m->length)));`

`}`	`}`

`/* Make sure the new address is within the region. We explicitly permit the`	`/* Make sure the new address is within the region. We explicitly permit the`
`current address to be at the exact end of the region when the address is`	`current address to be at the exact end of the region when the address is`
`non-zero, in case the region is at the end of addressable memory and the`	`non-zero, in case the region is at the end of addressable memory and the`
`calculation wraps around. */`	`calculation wraps around. */`

`static void`	`static void`
`os_region_check (lang_output_section_statement_type *os,`	`os_region_check (lang_output_section_statement_type *os,`
`lang_memory_region_type *region,`	`lang_memory_region_type *region,`
`etree_type *tree,`	`etree_type *tree,`
`bfd_vma rbase)`	`bfd_vma rbase)`
`{`	`{`
`if ((region->current < region->origin`	`if ((region->current < region->origin`
`\|\| (region->current - region->origin > region->length))`	`\|\| (region->current - region->origin > region->length))`
`&& ((region->current != region->origin + region->length)`	`&& ((region->current != region->origin + region->length)`
`\|\| rbase == 0))`	`\|\| rbase == 0))`
`{`	`{`
`if (tree != NULL)`	`if (tree != NULL)`
`{`	`{`
einfo (_("%X%P: address 0x%v of %B section `%s'"	einfo (_("%X%P: address 0x%v of %B section `%s'"
" is not within region `%s'\n"),	" is not within region `%s'\n"),
`region->current,`	`region->current,`
`os->bfd_section->owner,`	`os->bfd_section->owner,`
`os->bfd_section->name,`	`os->bfd_section->name,`
`region->name_list.name);`	`region->name_list.name);`
`}`	`}`
`else if (!region->had_full_message)`	`else if (!region->had_full_message)`
`{`	`{`
`region->had_full_message = TRUE;`	`region->had_full_message = TRUE;`

einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),	einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
`os->bfd_section->owner,`	`os->bfd_section->owner,`
`os->bfd_section->name,`	`os->bfd_section->name,`
`region->name_list.name);`	`region->name_list.name);`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Set the sizes for all the output sections. */`	`/* Set the sizes for all the output sections. */`

`static bfd_vma`	`static bfd_vma`
`lang_size_sections_1`	`lang_size_sections_1`
`(lang_statement_union_type **prev,`	`(lang_statement_union_type **prev,`
`lang_output_section_statement_type *output_section_statement,`	`lang_output_section_statement_type *output_section_statement,`
`fill_type *fill,`	`fill_type *fill,`
`bfd_vma dot,`	`bfd_vma dot,`
`bfd_boolean *relax,`	`bfd_boolean *relax,`
`bfd_boolean check_regions)`	`bfd_boolean check_regions)`
`{`	`{`
`lang_statement_union_type *s;`	`lang_statement_union_type *s;`

`/* Size up the sections from their constituent parts. */`	`/* Size up the sections from their constituent parts. */`
`for (s = *prev; s != NULL; s = s->header.next)`	`for (s = *prev; s != NULL; s = s->header.next)`
`{`	`{`
`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`{`	`{`
`bfd_vma newdot, after;`	`bfd_vma newdot, after;`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`
`lang_memory_region_type *r;`	`lang_memory_region_type *r;`
`int section_alignment = 0;`	`int section_alignment = 0;`

`os = &s->output_section_statement;`	`os = &s->output_section_statement;`
`if (os->constraint == -1)`	`if (os->constraint == -1)`
`break;`	`break;`

`/* FIXME: We shouldn't need to zero section vmas for ld -r`	`/* FIXME: We shouldn't need to zero section vmas for ld -r`
`here, in lang_insert_orphan, or in the default linker scripts.`	`here, in lang_insert_orphan, or in the default linker scripts.`
`This is covering for coff backend linker bugs. See PR6945. */`	`This is covering for coff backend linker bugs. See PR6945. */`
`if (os->addr_tree == NULL`	`if (os->addr_tree == NULL`
`&& link_info.relocatable`	`&& link_info.relocatable`
`&& (bfd_get_flavour (link_info.output_bfd)`	`&& (bfd_get_flavour (link_info.output_bfd)`
`== bfd_target_coff_flavour))`	`== bfd_target_coff_flavour))`
`os->addr_tree = exp_intop (0);`	`os->addr_tree = exp_intop (0);`
`if (os->addr_tree != NULL)`	`if (os->addr_tree != NULL)`
`{`	`{`
`os->processed_vma = FALSE;`	`os->processed_vma = FALSE;`
`exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);`	`exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);`

`if (expld.result.valid_p)`	`if (expld.result.valid_p)`
`{`	`{`
`dot = expld.result.value;`	`dot = expld.result.value;`
`if (expld.result.section != NULL)`	`if (expld.result.section != NULL)`
`dot += expld.result.section->vma;`	`dot += expld.result.section->vma;`
`}`	`}`
`else if (expld.phase != lang_mark_phase_enum)`	`else if (expld.phase != lang_mark_phase_enum)`
`einfo (_("%F%S: non constant or forward reference"`	`einfo (_("%F%S: non constant or forward reference"`
`" address expression for section %s\n"),`	`" address expression for section %s\n"),`
`os->name);`	`os->name);`
`}`	`}`

`if (os->bfd_section == NULL)`	`if (os->bfd_section == NULL)`
`/* This section was removed or never actually created. */`	`/* This section was removed or never actually created. */`
`break;`	`break;`

`/* If this is a COFF shared library section, use the size and`	`/* If this is a COFF shared library section, use the size and`
`address from the input section. FIXME: This is COFF`	`address from the input section. FIXME: This is COFF`
`specific; it would be cleaner if there were some other way`	`specific; it would be cleaner if there were some other way`
`to do this, but nothing simple comes to mind. */`	`to do this, but nothing simple comes to mind. */`
`if (((bfd_get_flavour (link_info.output_bfd)`	`if (((bfd_get_flavour (link_info.output_bfd)`
`== bfd_target_ecoff_flavour)`	`== bfd_target_ecoff_flavour)`
`\|\| (bfd_get_flavour (link_info.output_bfd)`	`\|\| (bfd_get_flavour (link_info.output_bfd)`
`== bfd_target_coff_flavour))`	`== bfd_target_coff_flavour))`
`&& (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)`	`&& (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)`
`{`	`{`
`asection *input;`	`asection *input;`

`if (os->children.head == NULL`	`if (os->children.head == NULL`
`\|\| os->children.head->header.next != NULL`	`\|\| os->children.head->header.next != NULL`
`\|\| (os->children.head->header.type`	`\|\| (os->children.head->header.type`
`!= lang_input_section_enum))`	`!= lang_input_section_enum))`
`einfo (_("%P%X: Internal error on COFF shared library"`	`einfo (_("%P%X: Internal error on COFF shared library"`
`" section %s\n"), os->name);`	`" section %s\n"), os->name);`

`input = os->children.head->input_section.section;`	`input = os->children.head->input_section.section;`
`bfd_set_section_vma (os->bfd_section->owner,`	`bfd_set_section_vma (os->bfd_section->owner,`
`os->bfd_section,`	`os->bfd_section,`
`bfd_section_vma (input->owner, input));`	`bfd_section_vma (input->owner, input));`
`os->bfd_section->size = input->size;`	`os->bfd_section->size = input->size;`
`break;`	`break;`
`}`	`}`

`newdot = dot;`	`newdot = dot;`
`if (bfd_is_abs_section (os->bfd_section))`	`if (bfd_is_abs_section (os->bfd_section))`
`{`	`{`
`/* No matter what happens, an abs section starts at zero. */`	`/* No matter what happens, an abs section starts at zero. */`
`ASSERT (os->bfd_section->vma == 0);`	`ASSERT (os->bfd_section->vma == 0);`
`}`	`}`
`else`	`else`
`{`	`{`
`if (os->addr_tree == NULL)`	`if (os->addr_tree == NULL)`
`{`	`{`
`/* No address specified for this section, get one`	`/* No address specified for this section, get one`
`from the region specification. */`	`from the region specification. */`
`if (os->region == NULL`	`if (os->region == NULL`
`\|\| ((os->bfd_section->flags & (SEC_ALLOC \| SEC_LOAD))`	`\|\| ((os->bfd_section->flags & (SEC_ALLOC \| SEC_LOAD))`
`&& os->region->name_list.name[0] == '*'`	`&& os->region->name_list.name[0] == '*'`
`&& strcmp (os->region->name_list.name,`	`&& strcmp (os->region->name_list.name,`
`DEFAULT_MEMORY_REGION) == 0))`	`DEFAULT_MEMORY_REGION) == 0))`
`{`	`{`
`os->region = lang_memory_default (os->bfd_section);`	`os->region = lang_memory_default (os->bfd_section);`
`}`	`}`

`/* If a loadable section is using the default memory`	`/* If a loadable section is using the default memory`
`region, and some non default memory regions were`	`region, and some non default memory regions were`
`defined, issue an error message. */`	`defined, issue an error message. */`
`if (!os->ignored`	`if (!os->ignored`
`&& !IGNORE_SECTION (os->bfd_section)`	`&& !IGNORE_SECTION (os->bfd_section)`
`&& ! link_info.relocatable`	`&& ! link_info.relocatable`
`&& check_regions`	`&& check_regions`
`&& strcmp (os->region->name_list.name,`	`&& strcmp (os->region->name_list.name,`
`DEFAULT_MEMORY_REGION) == 0`	`DEFAULT_MEMORY_REGION) == 0`
`&& lang_memory_region_list != NULL`	`&& lang_memory_region_list != NULL`
`&& (strcmp (lang_memory_region_list->name_list.name,`	`&& (strcmp (lang_memory_region_list->name_list.name,`
`DEFAULT_MEMORY_REGION) != 0`	`DEFAULT_MEMORY_REGION) != 0`
`\|\| lang_memory_region_list->next != NULL)`	`\|\| lang_memory_region_list->next != NULL)`
`&& expld.phase != lang_mark_phase_enum)`	`&& expld.phase != lang_mark_phase_enum)`
`{`	`{`
`/* By default this is an error rather than just a`	`/* By default this is an error rather than just a`
`warning because if we allocate the section to the`	`warning because if we allocate the section to the`
`default memory region we can end up creating an`	`default memory region we can end up creating an`
`excessively large binary, or even seg faulting when`	`excessively large binary, or even seg faulting when`
`attempting to perform a negative seek. See`	`attempting to perform a negative seek. See`
`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`	`for an example of this. This behaviour can be`
`overridden by the using the --no-check-sections`	`overridden by the using the --no-check-sections`
`switch. */`	`switch. */`
`if (command_line.check_section_addresses)`	`if (command_line.check_section_addresses)`
`einfo (_("%P%F: error: no memory region specified"`	`einfo (_("%P%F: error: no memory region specified"`
" for loadable section `%s'\n"),	" for loadable section `%s'\n"),
`bfd_get_section_name (link_info.output_bfd,`	`bfd_get_section_name (link_info.output_bfd,`
`os->bfd_section));`	`os->bfd_section));`
`else`	`else`
`einfo (_("%P: warning: no memory region specified"`	`einfo (_("%P: warning: no memory region specified"`
" for loadable section `%s'\n"),	" for loadable section `%s'\n"),
`bfd_get_section_name (link_info.output_bfd,`	`bfd_get_section_name (link_info.output_bfd,`
`os->bfd_section));`	`os->bfd_section));`
`}`	`}`

`newdot = os->region->current;`	`newdot = os->region->current;`
`section_alignment = os->bfd_section->alignment_power;`	`section_alignment = os->bfd_section->alignment_power;`
`}`	`}`
`else`	`else`
`section_alignment = os->section_alignment;`	`section_alignment = os->section_alignment;`

`/* Align to what the section needs. */`	`/* Align to what the section needs. */`
`if (section_alignment > 0)`	`if (section_alignment > 0)`
`{`	`{`
`bfd_vma savedot = newdot;`	`bfd_vma savedot = newdot;`
`newdot = align_power (newdot, section_alignment);`	`newdot = align_power (newdot, section_alignment);`

`if (newdot != savedot`	`if (newdot != savedot`
`&& (config.warn_section_align`	`&& (config.warn_section_align`
`\|\| os->addr_tree != NULL)`	`\|\| os->addr_tree != NULL)`
`&& expld.phase != lang_mark_phase_enum)`	`&& expld.phase != lang_mark_phase_enum)`
`einfo (_("%P: warning: changing start of section"`	`einfo (_("%P: warning: changing start of section"`
`" %s by %lu bytes\n"),`	`" %s by %lu bytes\n"),`
`os->name, (unsigned long) (newdot - savedot));`	`os->name, (unsigned long) (newdot - savedot));`
`}`	`}`

`bfd_set_section_vma (0, os->bfd_section, newdot);`	`bfd_set_section_vma (0, os->bfd_section, newdot);`

`os->bfd_section->output_offset = 0;`	`os->bfd_section->output_offset = 0;`
`}`	`}`

`lang_size_sections_1 (&os->children.head, os,`	`lang_size_sections_1 (&os->children.head, os,`
`os->fill, newdot, relax, check_regions);`	`os->fill, newdot, relax, check_regions);`

`os->processed_vma = TRUE;`	`os->processed_vma = TRUE;`

`if (bfd_is_abs_section (os->bfd_section) \|\| os->ignored)`	`if (bfd_is_abs_section (os->bfd_section) \|\| os->ignored)`
`/* Except for some special linker created sections,`	`/* Except for some special linker created sections,`
`no output section should change from zero size`	`no output section should change from zero size`
`after strip_excluded_output_sections. A non-zero`	`after strip_excluded_output_sections. A non-zero`
`size on an ignored section indicates that some`	`size on an ignored section indicates that some`
`input section was not sized early enough. */`	`input section was not sized early enough. */`
`ASSERT (os->bfd_section->size == 0);`	`ASSERT (os->bfd_section->size == 0);`
`else`	`else`
`{`	`{`
`dot = os->bfd_section->vma;`	`dot = os->bfd_section->vma;`

`/* Put the section within the requested block size, or`	`/* Put the section within the requested block size, or`
`align at the block boundary. */`	`align at the block boundary. */`
`after = ((dot`	`after = ((dot`
`+ TO_ADDR (os->bfd_section->size)`	`+ TO_ADDR (os->bfd_section->size)`
`+ os->block_value - 1)`	`+ os->block_value - 1)`
`& - (bfd_vma) os->block_value);`	`& - (bfd_vma) os->block_value);`

`os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);`	`os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);`
`}`	`}`

`/* Set section lma. */`	`/* Set section lma. */`
`r = os->region;`	`r = os->region;`
`if (r == NULL)`	`if (r == NULL)`
`r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);`	`r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);`

`if (os->load_base)`	`if (os->load_base)`
`{`	`{`
`bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");`	`bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");`
`os->bfd_section->lma = lma;`	`os->bfd_section->lma = lma;`
`}`	`}`
`else if (os->lma_region != NULL)`	`else if (os->lma_region != NULL)`
`{`	`{`
`bfd_vma lma = os->lma_region->current;`	`bfd_vma lma = os->lma_region->current;`

`if (section_alignment > 0)`	`if (section_alignment > 0)`
`lma = align_power (lma, section_alignment);`	`lma = align_power (lma, section_alignment);`
`os->bfd_section->lma = lma;`	`os->bfd_section->lma = lma;`
`}`	`}`
`else if (r->last_os != NULL`	`else if (r->last_os != NULL`
`&& (os->bfd_section->flags & SEC_ALLOC) != 0)`	`&& (os->bfd_section->flags & SEC_ALLOC) != 0)`
`{`	`{`
`bfd_vma lma;`	`bfd_vma lma;`
`asection *last;`	`asection *last;`

`last = r->last_os->output_section_statement.bfd_section;`	`last = r->last_os->output_section_statement.bfd_section;`

`/* A backwards move of dot should be accompanied by`	`/* A backwards move of dot should be accompanied by`
`an explicit assignment to the section LMA (ie.`	`an explicit assignment to the section LMA (ie.`
`os->load_base set) because backwards moves can`	`os->load_base set) because backwards moves can`
`create overlapping LMAs. */`	`create overlapping LMAs. */`
`if (dot < last->vma`	`if (dot < last->vma`
`&& os->bfd_section->size != 0`	`&& os->bfd_section->size != 0`
`&& dot + os->bfd_section->size <= last->vma)`	`&& dot + os->bfd_section->size <= last->vma)`
`{`	`{`
`/* If dot moved backwards then leave lma equal to`	`/* If dot moved backwards then leave lma equal to`
`vma. This is the old default lma, which might`	`vma. This is the old default lma, which might`
`just happen to work when the backwards move is`	`just happen to work when the backwards move is`
`sufficiently large. Nag if this changes anything,`	`sufficiently large. Nag if this changes anything,`
`so people can fix their linker scripts. */`	`so people can fix their linker scripts. */`

`if (last->vma != last->lma)`	`if (last->vma != last->lma)`
einfo (_("%P: warning: dot moved backwards before `%s'\n"),	einfo (_("%P: warning: dot moved backwards before `%s'\n"),
`os->name);`	`os->name);`
`}`	`}`
`else`	`else`
`{`	`{`
`/* If this is an overlay, set the current lma to that`	`/* If this is an overlay, set the current lma to that`
`at the end of the previous section. */`	`at the end of the previous section. */`
`if (os->sectype == overlay_section)`	`if (os->sectype == overlay_section)`
`lma = last->lma + last->size;`	`lma = last->lma + last->size;`

`/* Otherwise, keep the same lma to vma relationship`	`/* Otherwise, keep the same lma to vma relationship`
`as the previous section. */`	`as the previous section. */`
`else`	`else`
`lma = dot + last->lma - last->vma;`	`lma = dot + last->lma - last->vma;`

`if (section_alignment > 0)`	`if (section_alignment > 0)`
`lma = align_power (lma, section_alignment);`	`lma = align_power (lma, section_alignment);`
`os->bfd_section->lma = lma;`	`os->bfd_section->lma = lma;`
`}`	`}`
`}`	`}`
`os->processed_lma = TRUE;`	`os->processed_lma = TRUE;`

`if (bfd_is_abs_section (os->bfd_section) \|\| os->ignored)`	`if (bfd_is_abs_section (os->bfd_section) \|\| os->ignored)`
`break;`	`break;`

`/* Keep track of normal sections using the default`	`/* Keep track of normal sections using the default`
`lma region. We use this to set the lma for`	`lma region. We use this to set the lma for`
`following sections. Overlays or other linker`	`following sections. Overlays or other linker`
`script assignment to lma might mean that the`	`script assignment to lma might mean that the`
`default lma == vma is incorrect.`	`default lma == vma is incorrect.`
`To avoid warnings about dot moving backwards when using`	`To avoid warnings about dot moving backwards when using`
`-Ttext, don't start tracking sections until we find one`	`-Ttext, don't start tracking sections until we find one`
`of non-zero size or with lma set differently to vma. */`	`of non-zero size or with lma set differently to vma. */`
`if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0`	`if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0`
`\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)`	`\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)`
`&& (os->bfd_section->flags & SEC_ALLOC) != 0`	`&& (os->bfd_section->flags & SEC_ALLOC) != 0`
`&& (os->bfd_section->size != 0`	`&& (os->bfd_section->size != 0`
`\|\| (r->last_os == NULL`	`\|\| (r->last_os == NULL`
`&& os->bfd_section->vma != os->bfd_section->lma)`	`&& os->bfd_section->vma != os->bfd_section->lma)`
`\|\| (r->last_os != NULL`	`\|\| (r->last_os != NULL`
`&& dot >= (r->last_os->output_section_statement`	`&& dot >= (r->last_os->output_section_statement`
`.bfd_section->vma)))`	`.bfd_section->vma)))`
`&& os->lma_region == NULL`	`&& os->lma_region == NULL`
`&& !link_info.relocatable)`	`&& !link_info.relocatable)`
`r->last_os = s;`	`r->last_os = s;`

`/* .tbss sections effectively have zero size. */`	`/* .tbss sections effectively have zero size. */`
`if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0`	`if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0`
`\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0`	`\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0`
`\|\| link_info.relocatable)`	`\|\| link_info.relocatable)`
`dot += TO_ADDR (os->bfd_section->size);`	`dot += TO_ADDR (os->bfd_section->size);`

`if (os->update_dot_tree != 0)`	`if (os->update_dot_tree != 0)`
`exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);`	`exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);`

`/* Update dot in the region ?`	`/* Update dot in the region ?`
`We only do this if the section is going to be allocated,`	`We only do this if the section is going to be allocated,`
`since unallocated sections do not contribute to the region's`	`since unallocated sections do not contribute to the region's`
`overall size in memory. */`	`overall size in memory. */`
`if (os->region != NULL`	`if (os->region != NULL`
`&& (os->bfd_section->flags & (SEC_ALLOC \| SEC_LOAD)))`	`&& (os->bfd_section->flags & (SEC_ALLOC \| SEC_LOAD)))`
`{`	`{`
`os->region->current = dot;`	`os->region->current = dot;`

`if (check_regions)`	`if (check_regions)`
`/* Make sure the new address is within the region. */`	`/* Make sure the new address is within the region. */`
`os_region_check (os, os->region, os->addr_tree,`	`os_region_check (os, os->region, os->addr_tree,`
`os->bfd_section->vma);`	`os->bfd_section->vma);`

`if (os->lma_region != NULL && os->lma_region != os->region`	`if (os->lma_region != NULL && os->lma_region != os->region`
`&& (os->bfd_section->flags & SEC_LOAD))`	`&& (os->bfd_section->flags & SEC_LOAD))`
`{`	`{`
`os->lma_region->current`	`os->lma_region->current`
`= os->bfd_section->lma + TO_ADDR (os->bfd_section->size);`	`= os->bfd_section->lma + TO_ADDR (os->bfd_section->size);`

`if (check_regions)`	`if (check_regions)`
`os_region_check (os, os->lma_region, NULL,`	`os_region_check (os, os->lma_region, NULL,`
`os->bfd_section->lma);`	`os->bfd_section->lma);`
`}`	`}`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`dot = lang_size_sections_1 (&constructor_list.head,`	`dot = lang_size_sections_1 (&constructor_list.head,`
`output_section_statement,`	`output_section_statement,`
`fill, dot, relax, check_regions);`	`fill, dot, relax, check_regions);`
`break;`	`break;`

`case lang_data_statement_enum:`	`case lang_data_statement_enum:`
`{`	`{`
`unsigned int size = 0;`	`unsigned int size = 0;`

`s->data_statement.output_offset =`	`s->data_statement.output_offset =`
`dot - output_section_statement->bfd_section->vma;`	`dot - output_section_statement->bfd_section->vma;`
`s->data_statement.output_section =`	`s->data_statement.output_section =`
`output_section_statement->bfd_section;`	`output_section_statement->bfd_section;`

`/* We might refer to provided symbols in the expression, and`	`/* We might refer to provided symbols in the expression, and`
`need to mark them as needed. */`	`need to mark them as needed. */`
`exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);`	`exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);`

`switch (s->data_statement.type)`	`switch (s->data_statement.type)`
`{`	`{`
`default:`	`default:`
`abort ();`	`abort ();`
`case QUAD:`	`case QUAD:`
`case SQUAD:`	`case SQUAD:`
`size = QUAD_SIZE;`	`size = QUAD_SIZE;`
`break;`	`break;`
`case LONG:`	`case LONG:`
`size = LONG_SIZE;`	`size = LONG_SIZE;`
`break;`	`break;`
`case SHORT:`	`case SHORT:`
`size = SHORT_SIZE;`	`size = SHORT_SIZE;`
`break;`	`break;`
`case BYTE:`	`case BYTE:`
`size = BYTE_SIZE;`	`size = BYTE_SIZE;`
`break;`	`break;`
`}`	`}`
`if (size < TO_SIZE ((unsigned) 1))`	`if (size < TO_SIZE ((unsigned) 1))`
`size = TO_SIZE ((unsigned) 1);`	`size = TO_SIZE ((unsigned) 1);`
`dot += TO_ADDR (size);`	`dot += TO_ADDR (size);`
`output_section_statement->bfd_section->size += size;`	`output_section_statement->bfd_section->size += size;`
`}`	`}`
`break;`	`break;`

`case lang_reloc_statement_enum:`	`case lang_reloc_statement_enum:`
`{`	`{`
`int size;`	`int size;`

`s->reloc_statement.output_offset =`	`s->reloc_statement.output_offset =`
`dot - output_section_statement->bfd_section->vma;`	`dot - output_section_statement->bfd_section->vma;`
`s->reloc_statement.output_section =`	`s->reloc_statement.output_section =`
`output_section_statement->bfd_section;`	`output_section_statement->bfd_section;`
`size = bfd_get_reloc_size (s->reloc_statement.howto);`	`size = bfd_get_reloc_size (s->reloc_statement.howto);`
`dot += TO_ADDR (size);`	`dot += TO_ADDR (size);`
`output_section_statement->bfd_section->size += size;`	`output_section_statement->bfd_section->size += size;`
`}`	`}`
`break;`	`break;`

`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`dot = lang_size_sections_1 (&s->wild_statement.children.head,`	`dot = lang_size_sections_1 (&s->wild_statement.children.head,`
`output_section_statement,`	`output_section_statement,`
`fill, dot, relax, check_regions);`	`fill, dot, relax, check_regions);`
`break;`	`break;`

`case lang_object_symbols_statement_enum:`	`case lang_object_symbols_statement_enum:`
`link_info.create_object_symbols_section =`	`link_info.create_object_symbols_section =`
`output_section_statement->bfd_section;`	`output_section_statement->bfd_section;`
`break;`	`break;`

`case lang_output_statement_enum:`	`case lang_output_statement_enum:`
`case lang_target_statement_enum:`	`case lang_target_statement_enum:`
`break;`	`break;`

`case lang_input_section_enum:`	`case lang_input_section_enum:`
`{`	`{`
`asection *i;`	`asection *i;`

`i = s->input_section.section;`	`i = s->input_section.section;`
`if (relax)`	`if (relax)`
`{`	`{`
`bfd_boolean again;`	`bfd_boolean again;`

`if (! bfd_relax_section (i->owner, i, &link_info, &again))`	`if (! bfd_relax_section (i->owner, i, &link_info, &again))`
`einfo (_("%P%F: can't relax section: %E\n"));`	`einfo (_("%P%F: can't relax section: %E\n"));`
`if (again)`	`if (again)`
`*relax = TRUE;`	`*relax = TRUE;`
`}`	`}`
`dot = size_input_section (prev, output_section_statement,`	`dot = size_input_section (prev, output_section_statement,`
`output_section_statement->fill, dot);`	`output_section_statement->fill, dot);`
`}`	`}`
`break;`	`break;`

`case lang_input_statement_enum:`	`case lang_input_statement_enum:`
`break;`	`break;`

`case lang_fill_statement_enum:`	`case lang_fill_statement_enum:`
`s->fill_statement.output_section =`	`s->fill_statement.output_section =`
`output_section_statement->bfd_section;`	`output_section_statement->bfd_section;`

`fill = s->fill_statement.fill;`	`fill = s->fill_statement.fill;`
`break;`	`break;`

`case lang_assignment_statement_enum:`	`case lang_assignment_statement_enum:`
`{`	`{`
`bfd_vma newdot = dot;`	`bfd_vma newdot = dot;`
`etree_type *tree = s->assignment_statement.exp;`	`etree_type *tree = s->assignment_statement.exp;`

`expld.dataseg.relro = exp_dataseg_relro_none;`	`expld.dataseg.relro = exp_dataseg_relro_none;`

`exp_fold_tree (tree,`	`exp_fold_tree (tree,`
`output_section_statement->bfd_section,`	`output_section_statement->bfd_section,`
`&newdot);`	`&newdot);`

`if (expld.dataseg.relro == exp_dataseg_relro_start)`	`if (expld.dataseg.relro == exp_dataseg_relro_start)`
`{`	`{`
`if (!expld.dataseg.relro_start_stat)`	`if (!expld.dataseg.relro_start_stat)`
`expld.dataseg.relro_start_stat = s;`	`expld.dataseg.relro_start_stat = s;`
`else`	`else`
`{`	`{`
`ASSERT (expld.dataseg.relro_start_stat == s);`	`ASSERT (expld.dataseg.relro_start_stat == s);`
`}`	`}`
`}`	`}`
`else if (expld.dataseg.relro == exp_dataseg_relro_end)`	`else if (expld.dataseg.relro == exp_dataseg_relro_end)`
`{`	`{`
`if (!expld.dataseg.relro_end_stat)`	`if (!expld.dataseg.relro_end_stat)`
`expld.dataseg.relro_end_stat = s;`	`expld.dataseg.relro_end_stat = s;`
`else`	`else`
`{`	`{`
`ASSERT (expld.dataseg.relro_end_stat == s);`	`ASSERT (expld.dataseg.relro_end_stat == s);`
`}`	`}`
`}`	`}`
`expld.dataseg.relro = exp_dataseg_relro_none;`	`expld.dataseg.relro = exp_dataseg_relro_none;`

`/* This symbol is relative to this section. */`	`/* This symbol is relative to this section. */`
`if ((tree->type.node_class == etree_provided`	`if ((tree->type.node_class == etree_provided`
`\|\| tree->type.node_class == etree_assign)`	`\|\| tree->type.node_class == etree_assign)`
`&& (tree->assign.dst [0] != '.'`	`&& (tree->assign.dst [0] != '.'`
`\|\| tree->assign.dst [1] != '\0'))`	`\|\| tree->assign.dst [1] != '\0'))`
`output_section_statement->section_relative_symbol = 1;`	`output_section_statement->section_relative_symbol = 1;`

`if (!output_section_statement->ignored)`	`if (!output_section_statement->ignored)`
`{`	`{`
`if (output_section_statement == abs_output_section)`	`if (output_section_statement == abs_output_section)`
`{`	`{`
`/* If we don't have an output section, then just adjust`	`/* If we don't have an output section, then just adjust`
`the default memory address. */`	`the default memory address. */`
`lang_memory_region_lookup (DEFAULT_MEMORY_REGION,`	`lang_memory_region_lookup (DEFAULT_MEMORY_REGION,`
`FALSE)->current = newdot;`	`FALSE)->current = newdot;`
`}`	`}`
`else if (newdot != dot)`	`else if (newdot != dot)`
`{`	`{`
`/* Insert a pad after this statement. We can't`	`/* Insert a pad after this statement. We can't`
`put the pad before when relaxing, in case the`	`put the pad before when relaxing, in case the`
`assignment references dot. */`	`assignment references dot. */`
`insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),`	`insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),`
`output_section_statement->bfd_section, dot);`	`output_section_statement->bfd_section, dot);`

`/* Don't neuter the pad below when relaxing. */`	`/* Don't neuter the pad below when relaxing. */`
`s = s->header.next;`	`s = s->header.next;`

`/* If dot is advanced, this implies that the section`	`/* If dot is advanced, this implies that the section`
`should have space allocated to it, unless the`	`should have space allocated to it, unless the`
`user has explicitly stated that the section`	`user has explicitly stated that the section`
`should not be allocated. */`	`should not be allocated. */`
`if (output_section_statement->sectype != noalloc_section`	`if (output_section_statement->sectype != noalloc_section`
`&& (output_section_statement->sectype != noload_section`	`&& (output_section_statement->sectype != noload_section`
`\|\| (bfd_get_flavour (link_info.output_bfd)`	`\|\| (bfd_get_flavour (link_info.output_bfd)`
`== bfd_target_elf_flavour)))`	`== bfd_target_elf_flavour)))`
`output_section_statement->bfd_section->flags \|= SEC_ALLOC;`	`output_section_statement->bfd_section->flags \|= SEC_ALLOC;`
`}`	`}`
`dot = newdot;`	`dot = newdot;`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case lang_padding_statement_enum:`	`case lang_padding_statement_enum:`
`/* If this is the first time lang_size_sections is called,`	`/* If this is the first time lang_size_sections is called,`
`we won't have any padding statements. If this is the`	`we won't have any padding statements. If this is the`
`second or later passes when relaxing, we should allow`	`second or later passes when relaxing, we should allow`
`padding to shrink. If padding is needed on this pass, it`	`padding to shrink. If padding is needed on this pass, it`
`will be added back in. */`	`will be added back in. */`
`s->padding_statement.size = 0;`	`s->padding_statement.size = 0;`

`/* Make sure output_offset is valid. If relaxation shrinks`	`/* Make sure output_offset is valid. If relaxation shrinks`
`the section and this pad isn't needed, it's possible to`	`the section and this pad isn't needed, it's possible to`
`have output_offset larger than the final size of the`	`have output_offset larger than the final size of the`
`section. bfd_set_section_contents will complain even for`	`section. bfd_set_section_contents will complain even for`
`a pad size of zero. */`	`a pad size of zero. */`
`s->padding_statement.output_offset`	`s->padding_statement.output_offset`
`= dot - output_section_statement->bfd_section->vma;`	`= dot - output_section_statement->bfd_section->vma;`
`break;`	`break;`

`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`dot = lang_size_sections_1 (&s->group_statement.children.head,`	`dot = lang_size_sections_1 (&s->group_statement.children.head,`
`output_section_statement,`	`output_section_statement,`
`fill, dot, relax, check_regions);`	`fill, dot, relax, check_regions);`
`break;`	`break;`

`case lang_insert_statement_enum:`	`case lang_insert_statement_enum:`
`break;`	`break;`

`/* We can only get here when relaxing is turned on. */`	`/* We can only get here when relaxing is turned on. */`
`case lang_address_statement_enum:`	`case lang_address_statement_enum:`
`break;`	`break;`

`default:`	`default:`
`FAIL ();`	`FAIL ();`
`break;`	`break;`
`}`	`}`
`prev = &s->header.next;`	`prev = &s->header.next;`
`}`	`}`
`return dot;`	`return dot;`
`}`	`}`

`/* Callback routine that is used in _bfd_elf_map_sections_to_segments.`	`/* Callback routine that is used in _bfd_elf_map_sections_to_segments.`
`The BFD library has set NEW_SEGMENT to TRUE iff it thinks that`	`The BFD library has set NEW_SEGMENT to TRUE iff it thinks that`
`CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different`	`CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different`
`segments. We are allowed an opportunity to override this decision. */`	`segments. We are allowed an opportunity to override this decision. */`

`bfd_boolean`	`bfd_boolean`
`ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,`	`ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,`
`bfd * abfd ATTRIBUTE_UNUSED,`	`bfd * abfd ATTRIBUTE_UNUSED,`
`asection * current_section,`	`asection * current_section,`
`asection * previous_section,`	`asection * previous_section,`
`bfd_boolean new_segment)`	`bfd_boolean new_segment)`
`{`	`{`
`lang_output_section_statement_type * cur;`	`lang_output_section_statement_type * cur;`
`lang_output_section_statement_type * prev;`	`lang_output_section_statement_type * prev;`

`/* The checks below are only necessary when the BFD library has decided`	`/* The checks below are only necessary when the BFD library has decided`
`that the two sections ought to be placed into the same segment. */`	`that the two sections ought to be placed into the same segment. */`
`if (new_segment)`	`if (new_segment)`
`return TRUE;`	`return TRUE;`

`/* Paranoia checks. */`	`/* Paranoia checks. */`
`if (current_section == NULL \|\| previous_section == NULL)`	`if (current_section == NULL \|\| previous_section == NULL)`
`return new_segment;`	`return new_segment;`

`/* Find the memory regions associated with the two sections.`	`/* Find the memory regions associated with the two sections.`
`We call lang_output_section_find() here rather than scanning the list`	`We call lang_output_section_find() here rather than scanning the list`
`of output sections looking for a matching section pointer because if`	`of output sections looking for a matching section pointer because if`
`we have a large number of sections then a hash lookup is faster. */`	`we have a large number of sections then a hash lookup is faster. */`
`cur = lang_output_section_find (current_section->name);`	`cur = lang_output_section_find (current_section->name);`
`prev = lang_output_section_find (previous_section->name);`	`prev = lang_output_section_find (previous_section->name);`

`/* More paranoia. */`	`/* More paranoia. */`
`if (cur == NULL \|\| prev == NULL)`	`if (cur == NULL \|\| prev == NULL)`
`return new_segment;`	`return new_segment;`

`/* If the regions are different then force the sections to live in`	`/* If the regions are different then force the sections to live in`
`different segments. See the email thread starting at the following`	`different segments. See the email thread starting at the following`
`URL for the reasons why this is necessary:`	`URL for the reasons why this is necessary:`
`http://sourceware.org/ml/binutils/2007-02/msg00216.html */`	`http://sourceware.org/ml/binutils/2007-02/msg00216.html */`
`return cur->region != prev->region;`	`return cur->region != prev->region;`
`}`	`}`

`void`	`void`
`one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)`	`one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)`
`{`	`{`
`lang_statement_iteration++;`	`lang_statement_iteration++;`
`lang_size_sections_1 (&statement_list.head, abs_output_section,`	`lang_size_sections_1 (&statement_list.head, abs_output_section,`
`0, 0, relax, check_regions);`	`0, 0, relax, check_regions);`
`}`	`}`

`void`	`void`
`lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)`	`lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)`
`{`	`{`
`expld.phase = lang_allocating_phase_enum;`	`expld.phase = lang_allocating_phase_enum;`
`expld.dataseg.phase = exp_dataseg_none;`	`expld.dataseg.phase = exp_dataseg_none;`

`one_lang_size_sections_pass (relax, check_regions);`	`one_lang_size_sections_pass (relax, check_regions);`
`if (expld.dataseg.phase == exp_dataseg_end_seen`	`if (expld.dataseg.phase == exp_dataseg_end_seen`
`&& link_info.relro && expld.dataseg.relro_end)`	`&& link_info.relro && expld.dataseg.relro_end)`
`{`	`{`
`/* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try`	`/* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try`
`to put expld.dataseg.relro on a (common) page boundary. */`	`to put expld.dataseg.relro on a (common) page boundary. */`
`bfd_vma min_base, old_base, relro_end, maxpage;`	`bfd_vma min_base, old_base, relro_end, maxpage;`

`expld.dataseg.phase = exp_dataseg_relro_adjust;`	`expld.dataseg.phase = exp_dataseg_relro_adjust;`
`maxpage = expld.dataseg.maxpagesize;`	`maxpage = expld.dataseg.maxpagesize;`
`/* MIN_BASE is the absolute minimum address we are allowed to start the`	`/* MIN_BASE is the absolute minimum address we are allowed to start the`
`read-write segment (byte before will be mapped read-only). */`	`read-write segment (byte before will be mapped read-only). */`
`min_base = (expld.dataseg.min_base + maxpage - 1) & ~(maxpage - 1);`	`min_base = (expld.dataseg.min_base + maxpage - 1) & ~(maxpage - 1);`
`/* OLD_BASE is the address for a feasible minimum address which will`	`/* OLD_BASE is the address for a feasible minimum address which will`
`still not cause a data overlap inside MAXPAGE causing file offset skip`	`still not cause a data overlap inside MAXPAGE causing file offset skip`
`by MAXPAGE. */`	`by MAXPAGE. */`
`old_base = expld.dataseg.base;`	`old_base = expld.dataseg.base;`
`expld.dataseg.base += (-expld.dataseg.relro_end`	`expld.dataseg.base += (-expld.dataseg.relro_end`
`& (expld.dataseg.pagesize - 1));`	`& (expld.dataseg.pagesize - 1));`
`/* Compute the expected PT_GNU_RELRO segment end. */`	`/* Compute the expected PT_GNU_RELRO segment end. */`
`relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)`	`relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)`
`& ~(expld.dataseg.pagesize - 1));`	`& ~(expld.dataseg.pagesize - 1));`
`if (min_base + maxpage < expld.dataseg.base)`	`if (min_base + maxpage < expld.dataseg.base)`
`{`	`{`
`expld.dataseg.base -= maxpage;`	`expld.dataseg.base -= maxpage;`
`relro_end -= maxpage;`	`relro_end -= maxpage;`
`}`	`}`
`lang_reset_memory_regions ();`	`lang_reset_memory_regions ();`
`one_lang_size_sections_pass (relax, check_regions);`	`one_lang_size_sections_pass (relax, check_regions);`
`if (expld.dataseg.relro_end > relro_end)`	`if (expld.dataseg.relro_end > relro_end)`
`{`	`{`
`/* The alignment of sections between DATA_SEGMENT_ALIGN`	`/* The alignment of sections between DATA_SEGMENT_ALIGN`
`and DATA_SEGMENT_RELRO_END caused huge padding to be`	`and DATA_SEGMENT_RELRO_END caused huge padding to be`
`inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so`	`inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so`
`that the section alignments will fit in. */`	`that the section alignments will fit in. */`
`asection *sec;`	`asection *sec;`
`unsigned int max_alignment_power = 0;`	`unsigned int max_alignment_power = 0;`

`/* Find maximum alignment power of sections between`	`/* Find maximum alignment power of sections between`
`DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */`	`DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */`
`for (sec = link_info.output_bfd->sections; sec; sec = sec->next)`	`for (sec = link_info.output_bfd->sections; sec; sec = sec->next)`
`if (sec->vma >= expld.dataseg.base`	`if (sec->vma >= expld.dataseg.base`
`&& sec->vma < expld.dataseg.relro_end`	`&& sec->vma < expld.dataseg.relro_end`
`&& sec->alignment_power > max_alignment_power)`	`&& sec->alignment_power > max_alignment_power)`
`max_alignment_power = sec->alignment_power;`	`max_alignment_power = sec->alignment_power;`

`if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)`	`if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)`
`{`	`{`
`if (expld.dataseg.base - (1 << max_alignment_power) < old_base)`	`if (expld.dataseg.base - (1 << max_alignment_power) < old_base)`
`expld.dataseg.base += expld.dataseg.pagesize;`	`expld.dataseg.base += expld.dataseg.pagesize;`
`expld.dataseg.base -= (1 << max_alignment_power);`	`expld.dataseg.base -= (1 << max_alignment_power);`
`lang_reset_memory_regions ();`	`lang_reset_memory_regions ();`
`one_lang_size_sections_pass (relax, check_regions);`	`one_lang_size_sections_pass (relax, check_regions);`
`}`	`}`
`}`	`}`
`link_info.relro_start = expld.dataseg.base;`	`link_info.relro_start = expld.dataseg.base;`
`link_info.relro_end = expld.dataseg.relro_end;`	`link_info.relro_end = expld.dataseg.relro_end;`
`}`	`}`
`else if (expld.dataseg.phase == exp_dataseg_end_seen)`	`else if (expld.dataseg.phase == exp_dataseg_end_seen)`
`{`	`{`
`/* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether`	`/* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether`
`a page could be saved in the data segment. */`	`a page could be saved in the data segment. */`
`bfd_vma first, last;`	`bfd_vma first, last;`

`first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);`	`first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);`
`last = expld.dataseg.end & (expld.dataseg.pagesize - 1);`	`last = expld.dataseg.end & (expld.dataseg.pagesize - 1);`
`if (first && last`	`if (first && last`
`&& ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))`	`&& ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))`
`!= (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))`	`!= (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))`
`&& first + last <= expld.dataseg.pagesize)`	`&& first + last <= expld.dataseg.pagesize)`
`{`	`{`
`expld.dataseg.phase = exp_dataseg_adjust;`	`expld.dataseg.phase = exp_dataseg_adjust;`
`lang_reset_memory_regions ();`	`lang_reset_memory_regions ();`
`one_lang_size_sections_pass (relax, check_regions);`	`one_lang_size_sections_pass (relax, check_regions);`
`}`	`}`
`else`	`else`
`expld.dataseg.phase = exp_dataseg_done;`	`expld.dataseg.phase = exp_dataseg_done;`
`}`	`}`
`else`	`else`
`expld.dataseg.phase = exp_dataseg_done;`	`expld.dataseg.phase = exp_dataseg_done;`
`}`	`}`

`/* Worker function for lang_do_assignments. Recursiveness goes here. */`	`/* Worker function for lang_do_assignments. Recursiveness goes here. */`

`static bfd_vma`	`static bfd_vma`
`lang_do_assignments_1 (lang_statement_union_type *s,`	`lang_do_assignments_1 (lang_statement_union_type *s,`
`lang_output_section_statement_type *current_os,`	`lang_output_section_statement_type *current_os,`
`fill_type *fill,`	`fill_type *fill,`
`bfd_vma dot)`	`bfd_vma dot)`
`{`	`{`
`for (; s != NULL; s = s->header.next)`	`for (; s != NULL; s = s->header.next)`
`{`	`{`
`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`dot = lang_do_assignments_1 (constructor_list.head,`	`dot = lang_do_assignments_1 (constructor_list.head,`
`current_os, fill, dot);`	`current_os, fill, dot);`
`break;`	`break;`

`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`{`	`{`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`os = &(s->output_section_statement);`	`os = &(s->output_section_statement);`
`if (os->bfd_section != NULL && !os->ignored)`	`if (os->bfd_section != NULL && !os->ignored)`
`{`	`{`
`dot = os->bfd_section->vma;`	`dot = os->bfd_section->vma;`

`lang_do_assignments_1 (os->children.head, os, os->fill, dot);`	`lang_do_assignments_1 (os->children.head, os, os->fill, dot);`

`/* .tbss sections effectively have zero size. */`	`/* .tbss sections effectively have zero size. */`
`if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0`	`if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0`
`\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0`	`\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0`
`\|\| link_info.relocatable)`	`\|\| link_info.relocatable)`
`dot += TO_ADDR (os->bfd_section->size);`	`dot += TO_ADDR (os->bfd_section->size);`

`if (os->update_dot_tree != NULL)`	`if (os->update_dot_tree != NULL)`
`exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);`	`exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);`
`}`	`}`
`}`	`}`
`break;`	`break;`

`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`

`dot = lang_do_assignments_1 (s->wild_statement.children.head,`	`dot = lang_do_assignments_1 (s->wild_statement.children.head,`
`current_os, fill, dot);`	`current_os, fill, dot);`
`break;`	`break;`

`case lang_object_symbols_statement_enum:`	`case lang_object_symbols_statement_enum:`
`case lang_output_statement_enum:`	`case lang_output_statement_enum:`
`case lang_target_statement_enum:`	`case lang_target_statement_enum:`
`break;`	`break;`

`case lang_data_statement_enum:`	`case lang_data_statement_enum:`
`exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);`	`exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);`
`if (expld.result.valid_p)`	`if (expld.result.valid_p)`
`{`	`{`
`s->data_statement.value = expld.result.value;`	`s->data_statement.value = expld.result.value;`
`if (expld.result.section != NULL)`	`if (expld.result.section != NULL)`
`s->data_statement.value += expld.result.section->vma;`	`s->data_statement.value += expld.result.section->vma;`
`}`	`}`
`else`	`else`
`einfo (_("%F%P: invalid data statement\n"));`	`einfo (_("%F%P: invalid data statement\n"));`
`{`	`{`
`unsigned int size;`	`unsigned int size;`
`switch (s->data_statement.type)`	`switch (s->data_statement.type)`
`{`	`{`
`default:`	`default:`
`abort ();`	`abort ();`
`case QUAD:`	`case QUAD:`
`case SQUAD:`	`case SQUAD:`
`size = QUAD_SIZE;`	`size = QUAD_SIZE;`
`break;`	`break;`
`case LONG:`	`case LONG:`
`size = LONG_SIZE;`	`size = LONG_SIZE;`
`break;`	`break;`
`case SHORT:`	`case SHORT:`
`size = SHORT_SIZE;`	`size = SHORT_SIZE;`
`break;`	`break;`
`case BYTE:`	`case BYTE:`
`size = BYTE_SIZE;`	`size = BYTE_SIZE;`
`break;`	`break;`
`}`	`}`
`if (size < TO_SIZE ((unsigned) 1))`	`if (size < TO_SIZE ((unsigned) 1))`
`size = TO_SIZE ((unsigned) 1);`	`size = TO_SIZE ((unsigned) 1);`
`dot += TO_ADDR (size);`	`dot += TO_ADDR (size);`
`}`	`}`
`break;`	`break;`

`case lang_reloc_statement_enum:`	`case lang_reloc_statement_enum:`
`exp_fold_tree (s->reloc_statement.addend_exp,`	`exp_fold_tree (s->reloc_statement.addend_exp,`
`bfd_abs_section_ptr, &dot);`	`bfd_abs_section_ptr, &dot);`
`if (expld.result.valid_p)`	`if (expld.result.valid_p)`
`s->reloc_statement.addend_value = expld.result.value;`	`s->reloc_statement.addend_value = expld.result.value;`
`else`	`else`
`einfo (_("%F%P: invalid reloc statement\n"));`	`einfo (_("%F%P: invalid reloc statement\n"));`
`dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));`	`dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));`
`break;`	`break;`

`case lang_input_section_enum:`	`case lang_input_section_enum:`
`{`	`{`
`asection *in = s->input_section.section;`	`asection *in = s->input_section.section;`

`if ((in->flags & SEC_EXCLUDE) == 0)`	`if ((in->flags & SEC_EXCLUDE) == 0)`
`dot += TO_ADDR (in->size);`	`dot += TO_ADDR (in->size);`
`}`	`}`
`break;`	`break;`

`case lang_input_statement_enum:`	`case lang_input_statement_enum:`
`break;`	`break;`

`case lang_fill_statement_enum:`	`case lang_fill_statement_enum:`
`fill = s->fill_statement.fill;`	`fill = s->fill_statement.fill;`
`break;`	`break;`

`case lang_assignment_statement_enum:`	`case lang_assignment_statement_enum:`
`exp_fold_tree (s->assignment_statement.exp,`	`exp_fold_tree (s->assignment_statement.exp,`
`current_os->bfd_section,`	`current_os->bfd_section,`
`&dot);`	`&dot);`
`break;`	`break;`

`case lang_padding_statement_enum:`	`case lang_padding_statement_enum:`
`dot += TO_ADDR (s->padding_statement.size);`	`dot += TO_ADDR (s->padding_statement.size);`
`break;`	`break;`

`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`dot = lang_do_assignments_1 (s->group_statement.children.head,`	`dot = lang_do_assignments_1 (s->group_statement.children.head,`
`current_os, fill, dot);`	`current_os, fill, dot);`
`break;`	`break;`

`case lang_insert_statement_enum:`	`case lang_insert_statement_enum:`
`break;`	`break;`

`case lang_address_statement_enum:`	`case lang_address_statement_enum:`
`break;`	`break;`

`default:`	`default:`
`FAIL ();`	`FAIL ();`
`break;`	`break;`
`}`	`}`
`}`	`}`
`return dot;`	`return dot;`
`}`	`}`

`void`	`void`
`lang_do_assignments (lang_phase_type phase)`	`lang_do_assignments (lang_phase_type phase)`
`{`	`{`
`expld.phase = phase;`	`expld.phase = phase;`
`lang_statement_iteration++;`	`lang_statement_iteration++;`
`lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);`	`lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);`
`}`	`}`

`/* Fix any .startof. or .sizeof. symbols. When the assemblers see the`	`/* Fix any .startof. or .sizeof. symbols. When the assemblers see the`
`operator .startof. (section_name), it produces an undefined symbol`	`operator .startof. (section_name), it produces an undefined symbol`
`.startof.section_name. Similarly, when it sees`	`.startof.section_name. Similarly, when it sees`
`.sizeof. (section_name), it produces an undefined symbol`	`.sizeof. (section_name), it produces an undefined symbol`
`.sizeof.section_name. For all the output sections, we look for`	`.sizeof.section_name. For all the output sections, we look for`
`such symbols, and set them to the correct value. */`	`such symbols, and set them to the correct value. */`

`static void`	`static void`
`lang_set_startof (void)`	`lang_set_startof (void)`
`{`	`{`
`asection *s;`	`asection *s;`

`if (link_info.relocatable)`	`if (link_info.relocatable)`
`return;`	`return;`

`for (s = link_info.output_bfd->sections; s != NULL; s = s->next)`	`for (s = link_info.output_bfd->sections; s != NULL; s = s->next)`
`{`	`{`
`const char *secname;`	`const char *secname;`
`char *buf;`	`char *buf;`
`struct bfd_link_hash_entry *h;`	`struct bfd_link_hash_entry *h;`

`secname = bfd_get_section_name (link_info.output_bfd, s);`	`secname = bfd_get_section_name (link_info.output_bfd, s);`
`buf = (char *) xmalloc (10 + strlen (secname));`	`buf = (char *) xmalloc (10 + strlen (secname));`

`sprintf (buf, ".startof.%s", secname);`	`sprintf (buf, ".startof.%s", secname);`
`h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);`	`h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);`
`if (h != NULL && h->type == bfd_link_hash_undefined)`	`if (h != NULL && h->type == bfd_link_hash_undefined)`
`{`	`{`
`h->type = bfd_link_hash_defined;`	`h->type = bfd_link_hash_defined;`
`h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);`	`h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);`
`h->u.def.section = bfd_abs_section_ptr;`	`h->u.def.section = bfd_abs_section_ptr;`
`}`	`}`

`sprintf (buf, ".sizeof.%s", secname);`	`sprintf (buf, ".sizeof.%s", secname);`
`h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);`	`h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);`
`if (h != NULL && h->type == bfd_link_hash_undefined)`	`if (h != NULL && h->type == bfd_link_hash_undefined)`
`{`	`{`
`h->type = bfd_link_hash_defined;`	`h->type = bfd_link_hash_defined;`
`h->u.def.value = TO_ADDR (s->size);`	`h->u.def.value = TO_ADDR (s->size);`
`h->u.def.section = bfd_abs_section_ptr;`	`h->u.def.section = bfd_abs_section_ptr;`
`}`	`}`

`free (buf);`	`free (buf);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`lang_end (void)`	`lang_end (void)`
`{`	`{`
`struct bfd_link_hash_entry *h;`	`struct bfd_link_hash_entry *h;`
`bfd_boolean warn;`	`bfd_boolean warn;`

`if ((link_info.relocatable && !link_info.gc_sections)`	`if ((link_info.relocatable && !link_info.gc_sections)`
`\|\| (link_info.shared && !link_info.executable))`	`\|\| (link_info.shared && !link_info.executable))`
`warn = entry_from_cmdline;`	`warn = entry_from_cmdline;`
`else`	`else`
`warn = TRUE;`	`warn = TRUE;`

`/* Force the user to specify a root when generating a relocatable with`	`/* Force the user to specify a root when generating a relocatable with`
`--gc-sections. */`	`--gc-sections. */`
`if (link_info.gc_sections && link_info.relocatable`	`if (link_info.gc_sections && link_info.relocatable`
`&& !(entry_from_cmdline \|\| undef_from_cmdline))`	`&& !(entry_from_cmdline \|\| undef_from_cmdline))`
`einfo (_("%P%F: gc-sections requires either an entry or "`	`einfo (_("%P%F: gc-sections requires either an entry or "`
`"an undefined symbol\n"));`	`"an undefined symbol\n"));`

`if (entry_symbol.name == NULL)`	`if (entry_symbol.name == NULL)`
`{`	`{`
`/* No entry has been specified. Look for the default entry, but`	`/* No entry has been specified. Look for the default entry, but`
`don't warn if we don't find it. */`	`don't warn if we don't find it. */`
`entry_symbol.name = entry_symbol_default;`	`entry_symbol.name = entry_symbol_default;`
`warn = FALSE;`	`warn = FALSE;`
`}`	`}`

`h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,`	`h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,`
`FALSE, FALSE, TRUE);`	`FALSE, FALSE, TRUE);`
`if (h != NULL`	`if (h != NULL`
`&& (h->type == bfd_link_hash_defined`	`&& (h->type == bfd_link_hash_defined`
`\|\| h->type == bfd_link_hash_defweak)`	`\|\| h->type == bfd_link_hash_defweak)`
`&& h->u.def.section->output_section != NULL)`	`&& h->u.def.section->output_section != NULL)`
`{`	`{`
`bfd_vma val;`	`bfd_vma val;`

`val = (h->u.def.value`	`val = (h->u.def.value`
`+ bfd_get_section_vma (link_info.output_bfd,`	`+ bfd_get_section_vma (link_info.output_bfd,`
`h->u.def.section->output_section)`	`h->u.def.section->output_section)`
`+ h->u.def.section->output_offset);`	`+ h->u.def.section->output_offset);`
`if (! bfd_set_start_address (link_info.output_bfd, val))`	`if (! bfd_set_start_address (link_info.output_bfd, val))`
`einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);`	`einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);`
`}`	`}`
`else`	`else`
`{`	`{`
`bfd_vma val;`	`bfd_vma val;`
`const char *send;`	`const char *send;`

`/* We couldn't find the entry symbol. Try parsing it as a`	`/* We couldn't find the entry symbol. Try parsing it as a`
`number. */`	`number. */`
`val = bfd_scan_vma (entry_symbol.name, &send, 0);`	`val = bfd_scan_vma (entry_symbol.name, &send, 0);`
`if (*send == '\0')`	`if (*send == '\0')`
`{`	`{`
`if (! bfd_set_start_address (link_info.output_bfd, val))`	`if (! bfd_set_start_address (link_info.output_bfd, val))`
`einfo (_("%P%F: can't set start address\n"));`	`einfo (_("%P%F: can't set start address\n"));`
`}`	`}`
`else`	`else`
`{`	`{`
`asection *ts;`	`asection *ts;`

`/* Can't find the entry symbol, and it's not a number. Use`	`/* Can't find the entry symbol, and it's not a number. Use`
`the first address in the text section. */`	`the first address in the text section. */`
`ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);`	`ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);`
`if (ts != NULL)`	`if (ts != NULL)`
`{`	`{`
`if (warn)`	`if (warn)`
`einfo (_("%P: warning: cannot find entry symbol %s;"`	`einfo (_("%P: warning: cannot find entry symbol %s;"`
`" defaulting to %V\n"),`	`" defaulting to %V\n"),`
`entry_symbol.name,`	`entry_symbol.name,`
`bfd_get_section_vma (link_info.output_bfd, ts));`	`bfd_get_section_vma (link_info.output_bfd, ts));`
`if (!(bfd_set_start_address`	`if (!(bfd_set_start_address`
`(link_info.output_bfd,`	`(link_info.output_bfd,`
`bfd_get_section_vma (link_info.output_bfd, ts))))`	`bfd_get_section_vma (link_info.output_bfd, ts))))`
`einfo (_("%P%F: can't set start address\n"));`	`einfo (_("%P%F: can't set start address\n"));`
`}`	`}`
`else`	`else`
`{`	`{`
`if (warn)`	`if (warn)`
`einfo (_("%P: warning: cannot find entry symbol %s;"`	`einfo (_("%P: warning: cannot find entry symbol %s;"`
`" not setting start address\n"),`	`" not setting start address\n"),`
`entry_symbol.name);`	`entry_symbol.name);`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Don't bfd_hash_table_free (&lang_definedness_table);`	`/* Don't bfd_hash_table_free (&lang_definedness_table);`
`map file output may result in a call of lang_track_definedness. */`	`map file output may result in a call of lang_track_definedness. */`
`}`	`}`

`/* This is a small function used when we want to ignore errors from`	`/* This is a small function used when we want to ignore errors from`
`BFD. */`	`BFD. */`

`static void`	`static void`
`ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)`	`ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)`
`{`	`{`
`/* Don't do anything. */`	`/* Don't do anything. */`
`}`	`}`

`/* Check that the architecture of all the input files is compatible`	`/* Check that the architecture of all the input files is compatible`
`with the output file. Also call the backend to let it do any`	`with the output file. Also call the backend to let it do any`
`other checking that is needed. */`	`other checking that is needed. */`

`static void`	`static void`
`lang_check (void)`	`lang_check (void)`
`{`	`{`
`lang_statement_union_type *file;`	`lang_statement_union_type *file;`
`bfd *input_bfd;`	`bfd *input_bfd;`
`const bfd_arch_info_type *compatible;`	`const bfd_arch_info_type *compatible;`

`for (file = file_chain.head; file != NULL; file = file->input_statement.next)`	`for (file = file_chain.head; file != NULL; file = file->input_statement.next)`
`{`	`{`
`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`/* Don't check format of files claimed by plugin. */`	`/* Don't check format of files claimed by plugin. */`
`if (file->input_statement.claimed)`	`if (file->input_statement.claimed)`
`continue;`	`continue;`
`#endif /* ENABLE_PLUGINS */`	`#endif /* ENABLE_PLUGINS */`
`input_bfd = file->input_statement.the_bfd;`	`input_bfd = file->input_statement.the_bfd;`
`compatible`	`compatible`
`= bfd_arch_get_compatible (input_bfd, link_info.output_bfd,`	`= bfd_arch_get_compatible (input_bfd, link_info.output_bfd,`
`command_line.accept_unknown_input_arch);`	`command_line.accept_unknown_input_arch);`

`/* In general it is not possible to perform a relocatable`	`/* In general it is not possible to perform a relocatable`
`link between differing object formats when the input`	`link between differing object formats when the input`
`file has relocations, because the relocations in the`	`file has relocations, because the relocations in the`
`input format may not have equivalent representations in`	`input format may not have equivalent representations in`
`the output format (and besides BFD does not translate`	`the output format (and besides BFD does not translate`
`relocs for other link purposes than a final link). */`	`relocs for other link purposes than a final link). */`
`if ((link_info.relocatable \|\| link_info.emitrelocations)`	`if ((link_info.relocatable \|\| link_info.emitrelocations)`
`&& (compatible == NULL`	`&& (compatible == NULL`
`\|\| (bfd_get_flavour (input_bfd)`	`\|\| (bfd_get_flavour (input_bfd)`
`!= bfd_get_flavour (link_info.output_bfd)))`	`!= bfd_get_flavour (link_info.output_bfd)))`
`&& (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)`	`&& (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)`
`{`	`{`
`einfo (_("%P%F: Relocatable linking with relocations from"`	`einfo (_("%P%F: Relocatable linking with relocations from"`
`" format %s (%B) to format %s (%B) is not supported\n"),`	`" format %s (%B) to format %s (%B) is not supported\n"),`
`bfd_get_target (input_bfd), input_bfd,`	`bfd_get_target (input_bfd), input_bfd,`
`bfd_get_target (link_info.output_bfd), link_info.output_bfd);`	`bfd_get_target (link_info.output_bfd), link_info.output_bfd);`
`/* einfo with %F exits. */`	`/* einfo with %F exits. */`
`}`	`}`

`if (compatible == NULL)`	`if (compatible == NULL)`
`{`	`{`
`if (command_line.warn_mismatch)`	`if (command_line.warn_mismatch)`
einfo (_("%P%X: %s architecture of input file `%B'"	einfo (_("%P%X: %s architecture of input file `%B'"
`" is incompatible with %s output\n"),`	`" is incompatible with %s output\n"),`
`bfd_printable_name (input_bfd), input_bfd,`	`bfd_printable_name (input_bfd), input_bfd,`
`bfd_printable_name (link_info.output_bfd));`	`bfd_printable_name (link_info.output_bfd));`
`}`	`}`
`else if (bfd_count_sections (input_bfd))`	`else if (bfd_count_sections (input_bfd))`
`{`	`{`
`/* If the input bfd has no contents, it shouldn't set the`	`/* If the input bfd has no contents, it shouldn't set the`
`private data of the output bfd. */`	`private data of the output bfd. */`

`bfd_error_handler_type pfn = NULL;`	`bfd_error_handler_type pfn = NULL;`

`/* If we aren't supposed to warn about mismatched input`	`/* If we aren't supposed to warn about mismatched input`
`files, temporarily set the BFD error handler to a`	`files, temporarily set the BFD error handler to a`
`function which will do nothing. We still want to call`	`function which will do nothing. We still want to call`
`bfd_merge_private_bfd_data, since it may set up`	`bfd_merge_private_bfd_data, since it may set up`
`information which is needed in the output file. */`	`information which is needed in the output file. */`
`if (! command_line.warn_mismatch)`	`if (! command_line.warn_mismatch)`
`pfn = bfd_set_error_handler (ignore_bfd_errors);`	`pfn = bfd_set_error_handler (ignore_bfd_errors);`
`if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))`	`if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))`
`{`	`{`
`if (command_line.warn_mismatch)`	`if (command_line.warn_mismatch)`
`einfo (_("%P%X: failed to merge target specific data"`	`einfo (_("%P%X: failed to merge target specific data"`
`" of file %B\n"), input_bfd);`	`" of file %B\n"), input_bfd);`
`}`	`}`
`if (! command_line.warn_mismatch)`	`if (! command_line.warn_mismatch)`
`bfd_set_error_handler (pfn);`	`bfd_set_error_handler (pfn);`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Look through all the global common symbols and attach them to the`	`/* Look through all the global common symbols and attach them to the`
`correct section. The -sort-common command line switch may be used`	`correct section. The -sort-common command line switch may be used`
`to roughly sort the entries by alignment. */`	`to roughly sort the entries by alignment. */`

`static void`	`static void`
`lang_common (void)`	`lang_common (void)`
`{`	`{`
`if (command_line.inhibit_common_definition)`	`if (command_line.inhibit_common_definition)`
`return;`	`return;`
`if (link_info.relocatable`	`if (link_info.relocatable`
`&& ! command_line.force_common_definition)`	`&& ! command_line.force_common_definition)`
`return;`	`return;`

`if (! config.sort_common)`	`if (! config.sort_common)`
`bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);`	`bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);`
`else`	`else`
`{`	`{`
`unsigned int power;`	`unsigned int power;`

`if (config.sort_common == sort_descending)`	`if (config.sort_common == sort_descending)`
`{`	`{`
`for (power = 4; power > 0; power--)`	`for (power = 4; power > 0; power--)`
`bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);`	`bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);`

`power = 0;`	`power = 0;`
`bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);`	`bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);`
`}`	`}`
`else`	`else`
`{`	`{`
`for (power = 0; power <= 4; power++)`	`for (power = 0; power <= 4; power++)`
`bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);`	`bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);`

`power = UINT_MAX;`	`power = UINT_MAX;`
`bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);`	`bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Place one common symbol in the correct section. */`	`/* Place one common symbol in the correct section. */`

`static bfd_boolean`	`static bfd_boolean`
`lang_one_common (struct bfd_link_hash_entry h, void info)`	`lang_one_common (struct bfd_link_hash_entry h, void info)`
`{`	`{`
`unsigned int power_of_two;`	`unsigned int power_of_two;`
`bfd_vma size;`	`bfd_vma size;`
`asection *section;`	`asection *section;`

`if (h->type != bfd_link_hash_common)`	`if (h->type != bfd_link_hash_common)`
`return TRUE;`	`return TRUE;`

`size = h->u.c.size;`	`size = h->u.c.size;`
`power_of_two = h->u.c.p->alignment_power;`	`power_of_two = h->u.c.p->alignment_power;`

`if (config.sort_common == sort_descending`	`if (config.sort_common == sort_descending`
`&& power_of_two < (unsigned int ) info)`	`&& power_of_two < (unsigned int ) info)`
`return TRUE;`	`return TRUE;`
`else if (config.sort_common == sort_ascending`	`else if (config.sort_common == sort_ascending`
`&& power_of_two > (unsigned int ) info)`	`&& power_of_two > (unsigned int ) info)`
`return TRUE;`	`return TRUE;`

`section = h->u.c.p->section;`	`section = h->u.c.p->section;`
`if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))`	`if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))`
einfo (_("%P%F: Could not define common symbol `%T': %E\n"),	einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
`h->root.string);`	`h->root.string);`

`if (config.map_file != NULL)`	`if (config.map_file != NULL)`
`{`	`{`
`static bfd_boolean header_printed;`	`static bfd_boolean header_printed;`
`int len;`	`int len;`
`char *name;`	`char *name;`
`char buf[50];`	`char buf[50];`

`if (! header_printed)`	`if (! header_printed)`
`{`	`{`
`minfo (_("\nAllocating common symbols\n"));`	`minfo (_("\nAllocating common symbols\n"));`
`minfo (_("Common symbol size file\n\n"));`	`minfo (_("Common symbol size file\n\n"));`
`header_printed = TRUE;`	`header_printed = TRUE;`
`}`	`}`

`name = bfd_demangle (link_info.output_bfd, h->root.string,`	`name = bfd_demangle (link_info.output_bfd, h->root.string,`
`DMGL_ANSI \| DMGL_PARAMS);`	`DMGL_ANSI \| DMGL_PARAMS);`
`if (name == NULL)`	`if (name == NULL)`
`{`	`{`
`minfo ("%s", h->root.string);`	`minfo ("%s", h->root.string);`
`len = strlen (h->root.string);`	`len = strlen (h->root.string);`
`}`	`}`
`else`	`else`
`{`	`{`
`minfo ("%s", name);`	`minfo ("%s", name);`
`len = strlen (name);`	`len = strlen (name);`
`free (name);`	`free (name);`
`}`	`}`

`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;`
`}`	`}`

`minfo ("0x");`	`minfo ("0x");`
`if (size <= 0xffffffff)`	`if (size <= 0xffffffff)`
`sprintf (buf, "%lx", (unsigned long) size);`	`sprintf (buf, "%lx", (unsigned long) size);`
`else`	`else`
`sprintf_vma (buf, size);`	`sprintf_vma (buf, size);`
`minfo ("%s", buf);`	`minfo ("%s", buf);`
`len = strlen (buf);`	`len = strlen (buf);`

`while (len < 16)`	`while (len < 16)`
`{`	`{`
`print_space ();`	`print_space ();`
`++len;`	`++len;`
`}`	`}`

`minfo ("%B\n", section->owner);`	`minfo ("%B\n", section->owner);`
`}`	`}`

`return TRUE;`	`return TRUE;`
`}`	`}`

`/* Run through the input files and ensure that every input section has`	`/* Run through the input files and ensure that every input section has`
`somewhere to go. If one is found without a destination then create`	`somewhere to go. If one is found without a destination then create`
`an input request and place it into the statement tree. */`	`an input request and place it into the statement tree. */`

`static void`	`static void`
`lang_place_orphans (void)`	`lang_place_orphans (void)`
`{`	`{`
`LANG_FOR_EACH_INPUT_STATEMENT (file)`	`LANG_FOR_EACH_INPUT_STATEMENT (file)`
`{`	`{`
`asection *s;`	`asection *s;`

`for (s = file->the_bfd->sections; s != NULL; s = s->next)`	`for (s = file->the_bfd->sections; s != NULL; s = s->next)`
`{`	`{`
`if (s->output_section == NULL)`	`if (s->output_section == NULL)`
`{`	`{`
`/* This section of the file is not attached, root`	`/* This section of the file is not attached, root`
`around for a sensible place for it to go. */`	`around for a sensible place for it to go. */`

`if (file->just_syms_flag)`	`if (file->just_syms_flag)`
`bfd_link_just_syms (file->the_bfd, s, &link_info);`	`bfd_link_just_syms (file->the_bfd, s, &link_info);`
`else if ((s->flags & SEC_EXCLUDE) != 0)`	`else if ((s->flags & SEC_EXCLUDE) != 0)`
`s->output_section = bfd_abs_section_ptr;`	`s->output_section = bfd_abs_section_ptr;`
`else if (strcmp (s->name, "COMMON") == 0)`	`else if (strcmp (s->name, "COMMON") == 0)`
`{`	`{`
`/* This is a lonely common section which must have`	`/* This is a lonely common section which must have`
`come from an archive. We attach to the section`	`come from an archive. We attach to the section`
`with the wildcard. */`	`with the wildcard. */`
`if (! link_info.relocatable`	`if (! link_info.relocatable`
`\|\| command_line.force_common_definition)`	`\|\| command_line.force_common_definition)`
`{`	`{`
`if (default_common_section == NULL)`	`if (default_common_section == NULL)`
`default_common_section`	`default_common_section`
`= lang_output_section_statement_lookup (".bss", 0,`	`= lang_output_section_statement_lookup (".bss", 0,`
`TRUE);`	`TRUE);`
`lang_add_section (&default_common_section->children, s,`	`lang_add_section (&default_common_section->children, s,`
`default_common_section);`	`default_common_section);`
`}`	`}`
`}`	`}`
`else`	`else`
`{`	`{`
`const char *name = s->name;`	`const char *name = s->name;`
`int constraint = 0;`	`int constraint = 0;`

`if (config.unique_orphan_sections`	`if (config.unique_orphan_sections`
`\|\| unique_section_p (s, NULL))`	`\|\| unique_section_p (s, NULL))`
`constraint = SPECIAL;`	`constraint = SPECIAL;`

`if (!ldemul_place_orphan (s, name, constraint))`	`if (!ldemul_place_orphan (s, name, constraint))`
`{`	`{`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`
`os = lang_output_section_statement_lookup (name,`	`os = lang_output_section_statement_lookup (name,`
`constraint,`	`constraint,`
`TRUE);`	`TRUE);`
`if (os->addr_tree == NULL`	`if (os->addr_tree == NULL`
`&& (link_info.relocatable`	`&& (link_info.relocatable`
`\|\| (s->flags & (SEC_LOAD \| SEC_ALLOC)) == 0))`	`\|\| (s->flags & (SEC_LOAD \| SEC_ALLOC)) == 0))`
`os->addr_tree = exp_intop (0);`	`os->addr_tree = exp_intop (0);`
`lang_add_section (&os->children, s, os);`	`lang_add_section (&os->children, s, os);`
`}`	`}`
`}`	`}`
`}`	`}`
`}`	`}`
`}`	`}`
`}`	`}`

`void`	`void`
`lang_set_flags (lang_memory_region_type ptr, const char flags, int invert)`	`lang_set_flags (lang_memory_region_type ptr, const char flags, int invert)`
`{`	`{`
`flagword *ptr_flags;`	`flagword *ptr_flags;`

`ptr_flags = invert ? &ptr->not_flags : &ptr->flags;`	`ptr_flags = invert ? &ptr->not_flags : &ptr->flags;`
`while (*flags)`	`while (*flags)`
`{`	`{`
`switch (*flags)`	`switch (*flags)`
`{`	`{`
`case 'A': case 'a':`	`case 'A': case 'a':`
`*ptr_flags \|= SEC_ALLOC;`	`*ptr_flags \|= SEC_ALLOC;`
`break;`	`break;`

`case 'R': case 'r':`	`case 'R': case 'r':`
`*ptr_flags \|= SEC_READONLY;`	`*ptr_flags \|= SEC_READONLY;`
`break;`	`break;`

`case 'W': case 'w':`	`case 'W': case 'w':`
`*ptr_flags \|= SEC_DATA;`	`*ptr_flags \|= SEC_DATA;`
`break;`	`break;`

`case 'X': case 'x':`	`case 'X': case 'x':`
`*ptr_flags \|= SEC_CODE;`	`*ptr_flags \|= SEC_CODE;`
`break;`	`break;`

`case 'L': case 'l':`	`case 'L': case 'l':`
`case 'I': case 'i':`	`case 'I': case 'i':`
`*ptr_flags \|= SEC_LOAD;`	`*ptr_flags \|= SEC_LOAD;`
`break;`	`break;`

`default:`	`default:`
`einfo (_("%P%F: invalid syntax in flags\n"));`	`einfo (_("%P%F: invalid syntax in flags\n"));`
`break;`	`break;`
`}`	`}`
`flags++;`	`flags++;`
`}`	`}`
`}`	`}`

`/* Call a function on each input file. This function will be called`	`/* Call a function on each input file. This function will be called`
`on an archive, but not on the elements. */`	`on an archive, but not on the elements. */`

`void`	`void`
`lang_for_each_input_file (void (func) (lang_input_statement_type ))`	`lang_for_each_input_file (void (func) (lang_input_statement_type ))`
`{`	`{`
`lang_input_statement_type *f;`	`lang_input_statement_type *f;`

`for (f = (lang_input_statement_type *) input_file_chain.head;`	`for (f = (lang_input_statement_type *) input_file_chain.head;`
`f != NULL;`	`f != NULL;`
`f = (lang_input_statement_type *) f->next_real_file)`	`f = (lang_input_statement_type *) f->next_real_file)`
`func (f);`	`func (f);`
`}`	`}`

`/* Call a function on each file. The function will be called on all`	`/* Call a function on each file. The function will be called on all`
`the elements of an archive which are included in the link, but will`	`the elements of an archive which are included in the link, but will`
`not be called on the archive file itself. */`	`not be called on the archive file itself. */`

`void`	`void`
`lang_for_each_file (void (func) (lang_input_statement_type ))`	`lang_for_each_file (void (func) (lang_input_statement_type ))`
`{`	`{`
`LANG_FOR_EACH_INPUT_STATEMENT (f)`	`LANG_FOR_EACH_INPUT_STATEMENT (f)`
`{`	`{`
`func (f);`	`func (f);`
`}`	`}`
`}`	`}`

`void`	`void`
`ldlang_add_file (lang_input_statement_type *entry)`	`ldlang_add_file (lang_input_statement_type *entry)`
`{`	`{`
`lang_statement_append (&file_chain,`	`lang_statement_append (&file_chain,`
`(lang_statement_union_type *) entry,`	`(lang_statement_union_type *) entry,`
`&entry->next);`	`&entry->next);`

`/* The BFD linker needs to have a list of all input BFDs involved in`	`/* The BFD linker needs to have a list of all input BFDs involved in`
`a link. */`	`a link. */`
`ASSERT (entry->the_bfd->link_next == NULL);`	`ASSERT (entry->the_bfd->link_next == NULL);`
`ASSERT (entry->the_bfd != link_info.output_bfd);`	`ASSERT (entry->the_bfd != link_info.output_bfd);`

`*link_info.input_bfds_tail = entry->the_bfd;`	`*link_info.input_bfds_tail = entry->the_bfd;`
`link_info.input_bfds_tail = &entry->the_bfd->link_next;`	`link_info.input_bfds_tail = &entry->the_bfd->link_next;`
`entry->the_bfd->usrdata = entry;`	`entry->the_bfd->usrdata = entry;`
`bfd_set_gp_size (entry->the_bfd, g_switch_value);`	`bfd_set_gp_size (entry->the_bfd, g_switch_value);`

`/* Look through the sections and check for any which should not be`	`/* Look through the sections and check for any which should not be`
`included in the link. We need to do this now, so that we can`	`included in the link. We need to do this now, so that we can`
`notice when the backend linker tries to report multiple`	`notice when the backend linker tries to report multiple`
`definition errors for symbols which are in sections we aren't`	`definition errors for symbols which are in sections we aren't`
`going to link. FIXME: It might be better to entirely ignore`	`going to link. FIXME: It might be better to entirely ignore`
`symbols which are defined in sections which are going to be`	`symbols which are defined in sections which are going to be`
`discarded. This would require modifying the backend linker for`	`discarded. This would require modifying the backend linker for`
`each backend which might set the SEC_LINK_ONCE flag. If we do`	`each backend which might set the SEC_LINK_ONCE flag. If we do`
`this, we should probably handle SEC_EXCLUDE in the same way. */`	`this, we should probably handle SEC_EXCLUDE in the same way. */`

`bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);`	`bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);`
`}`	`}`

`void`	`void`
`lang_add_output (const char *name, int from_script)`	`lang_add_output (const char *name, int from_script)`
`{`	`{`
`/* Make -o on command line override OUTPUT in script. */`	`/* Make -o on command line override OUTPUT in script. */`
`if (!had_output_filename \|\| !from_script)`	`if (!had_output_filename \|\| !from_script)`
`{`	`{`
`output_filename = name;`	`output_filename = name;`
`had_output_filename = TRUE;`	`had_output_filename = TRUE;`
`}`	`}`
`}`	`}`

`static lang_output_section_statement_type *current_section;`	`static lang_output_section_statement_type *current_section;`

`static int`	`static int`
`topower (int x)`	`topower (int x)`
`{`	`{`
`unsigned int i = 1;`	`unsigned int i = 1;`
`int l;`	`int l;`

`if (x < 0)`	`if (x < 0)`
`return -1;`	`return -1;`

`for (l = 0; l < 32; l++)`	`for (l = 0; l < 32; l++)`
`{`	`{`
`if (i >= (unsigned int) x)`	`if (i >= (unsigned int) x)`
`return l;`	`return l;`
`i <<= 1;`	`i <<= 1;`
`}`	`}`

`return 0;`	`return 0;`
`}`	`}`

`lang_output_section_statement_type *`	`lang_output_section_statement_type *`
`lang_enter_output_section_statement (const char *output_section_statement_name,`	`lang_enter_output_section_statement (const char *output_section_statement_name,`
`etree_type *address_exp,`	`etree_type *address_exp,`
`enum section_type sectype,`	`enum section_type sectype,`
`etree_type *align,`	`etree_type *align,`
`etree_type *subalign,`	`etree_type *subalign,`
`etree_type *ebase,`	`etree_type *ebase,`
`int constraint)`	`int constraint)`
`{`	`{`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`os = lang_output_section_statement_lookup (output_section_statement_name,`	`os = lang_output_section_statement_lookup (output_section_statement_name,`
`constraint, TRUE);`	`constraint, TRUE);`
`current_section = os;`	`current_section = os;`

`if (os->addr_tree == NULL)`	`if (os->addr_tree == NULL)`
`{`	`{`
`os->addr_tree = address_exp;`	`os->addr_tree = address_exp;`
`}`	`}`
`os->sectype = sectype;`	`os->sectype = sectype;`
`if (sectype != noload_section)`	`if (sectype != noload_section)`
`os->flags = SEC_NO_FLAGS;`	`os->flags = SEC_NO_FLAGS;`
`else`	`else`
`os->flags = SEC_NEVER_LOAD;`	`os->flags = SEC_NEVER_LOAD;`
`os->block_value = 1;`	`os->block_value = 1;`

`/* Make next things chain into subchain of this. */`	`/* Make next things chain into subchain of this. */`
`push_stat_ptr (&os->children);`	`push_stat_ptr (&os->children);`

`os->subsection_alignment =`	`os->subsection_alignment =`
`topower (exp_get_value_int (subalign, -1, "subsection alignment"));`	`topower (exp_get_value_int (subalign, -1, "subsection alignment"));`
`os->section_alignment =`	`os->section_alignment =`
`topower (exp_get_value_int (align, -1, "section alignment"));`	`topower (exp_get_value_int (align, -1, "section alignment"));`

`os->load_base = ebase;`	`os->load_base = ebase;`
`return os;`	`return os;`
`}`	`}`

`void`	`void`
`lang_final (void)`	`lang_final (void)`
`{`	`{`
`lang_output_statement_type *new_stmt;`	`lang_output_statement_type *new_stmt;`

`new_stmt = new_stat (lang_output_statement, stat_ptr);`	`new_stmt = new_stat (lang_output_statement, stat_ptr);`
`new_stmt->name = output_filename;`	`new_stmt->name = output_filename;`

`}`	`}`

`/* Reset the current counters in the regions. */`	`/* Reset the current counters in the regions. */`

`void`	`void`
`lang_reset_memory_regions (void)`	`lang_reset_memory_regions (void)`
`{`	`{`
`lang_memory_region_type *p = lang_memory_region_list;`	`lang_memory_region_type *p = lang_memory_region_list;`
`asection *o;`	`asection *o;`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`for (p = lang_memory_region_list; p != NULL; p = p->next)`	`for (p = lang_memory_region_list; p != NULL; p = p->next)`
`{`	`{`
`p->current = p->origin;`	`p->current = p->origin;`
`p->last_os = NULL;`	`p->last_os = NULL;`
`}`	`}`

`for (os = &lang_output_section_statement.head->output_section_statement;`	`for (os = &lang_output_section_statement.head->output_section_statement;`
`os != NULL;`	`os != NULL;`
`os = os->next)`	`os = os->next)`
`{`	`{`
`os->processed_vma = FALSE;`	`os->processed_vma = FALSE;`
`os->processed_lma = FALSE;`	`os->processed_lma = FALSE;`
`}`	`}`

`for (o = link_info.output_bfd->sections; o != NULL; o = o->next)`	`for (o = link_info.output_bfd->sections; o != NULL; o = o->next)`
`{`	`{`
`/* Save the last size for possible use by bfd_relax_section. */`	`/* Save the last size for possible use by bfd_relax_section. */`
`o->rawsize = o->size;`	`o->rawsize = o->size;`
`o->size = 0;`	`o->size = 0;`
`}`	`}`
`}`	`}`

`/* Worker for lang_gc_sections_1. */`	`/* Worker for lang_gc_sections_1. */`

`static void`	`static void`
`gc_section_callback (lang_wild_statement_type *ptr,`	`gc_section_callback (lang_wild_statement_type *ptr,`
`struct wildcard_list *sec ATTRIBUTE_UNUSED,`	`struct wildcard_list *sec ATTRIBUTE_UNUSED,`
`asection *section,`	`asection *section,`
`lang_input_statement_type *file ATTRIBUTE_UNUSED,`	`lang_input_statement_type *file ATTRIBUTE_UNUSED,`
`void *data ATTRIBUTE_UNUSED)`	`void *data ATTRIBUTE_UNUSED)`
`{`	`{`
`/* If the wild pattern was marked KEEP, the member sections`	`/* If the wild pattern was marked KEEP, the member sections`
`should be as well. */`	`should be as well. */`
`if (ptr->keep_sections)`	`if (ptr->keep_sections)`
`section->flags \|= SEC_KEEP;`	`section->flags \|= SEC_KEEP;`
`}`	`}`

`/* Iterate over sections marking them against GC. */`	`/* Iterate over sections marking them against GC. */`

`static void`	`static void`
`lang_gc_sections_1 (lang_statement_union_type *s)`	`lang_gc_sections_1 (lang_statement_union_type *s)`
`{`	`{`
`for (; s != NULL; s = s->header.next)`	`for (; s != NULL; s = s->header.next)`
`{`	`{`
`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`walk_wild (&s->wild_statement, gc_section_callback, NULL);`	`walk_wild (&s->wild_statement, gc_section_callback, NULL);`
`break;`	`break;`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`lang_gc_sections_1 (constructor_list.head);`	`lang_gc_sections_1 (constructor_list.head);`
`break;`	`break;`
`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`lang_gc_sections_1 (s->output_section_statement.children.head);`	`lang_gc_sections_1 (s->output_section_statement.children.head);`
`break;`	`break;`
`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`lang_gc_sections_1 (s->group_statement.children.head);`	`lang_gc_sections_1 (s->group_statement.children.head);`
`break;`	`break;`
`default:`	`default:`
`break;`	`break;`
`}`	`}`
`}`	`}`
`}`	`}`

`static void`	`static void`
`lang_gc_sections (void)`	`lang_gc_sections (void)`
`{`	`{`
`/* Keep all sections so marked in the link script. */`	`/* Keep all sections so marked in the link script. */`

`lang_gc_sections_1 (statement_list.head);`	`lang_gc_sections_1 (statement_list.head);`

`/* SEC_EXCLUDE is ignored when doing a relocatable link, except in`	`/* SEC_EXCLUDE is ignored when doing a relocatable link, except in`
`the special case of debug info. (See bfd/stabs.c)`	`the special case of debug info. (See bfd/stabs.c)`
`Twiddle the flag here, to simplify later linker code. */`	`Twiddle the flag here, to simplify later linker code. */`
`if (link_info.relocatable)`	`if (link_info.relocatable)`
`{`	`{`
`LANG_FOR_EACH_INPUT_STATEMENT (f)`	`LANG_FOR_EACH_INPUT_STATEMENT (f)`
`{`	`{`
`asection *sec;`	`asection *sec;`
`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`if (f->claimed)`	`if (f->claimed)`
`continue;`	`continue;`
`#endif`	`#endif`
`for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)`	`for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)`
`if ((sec->flags & SEC_DEBUGGING) == 0)`	`if ((sec->flags & SEC_DEBUGGING) == 0)`
`sec->flags &= ~SEC_EXCLUDE;`	`sec->flags &= ~SEC_EXCLUDE;`
`}`	`}`
`}`	`}`

`if (link_info.gc_sections)`	`if (link_info.gc_sections)`
`bfd_gc_sections (link_info.output_bfd, &link_info);`	`bfd_gc_sections (link_info.output_bfd, &link_info);`
`}`	`}`

`/* Worker for lang_find_relro_sections_1. */`	`/* Worker for lang_find_relro_sections_1. */`

`static void`	`static void`
`find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,`	`find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,`
`struct wildcard_list *sec ATTRIBUTE_UNUSED,`	`struct wildcard_list *sec ATTRIBUTE_UNUSED,`
`asection *section,`	`asection *section,`
`lang_input_statement_type *file ATTRIBUTE_UNUSED,`	`lang_input_statement_type *file ATTRIBUTE_UNUSED,`
`void *data)`	`void *data)`
`{`	`{`
`/* Discarded, excluded and ignored sections effectively have zero`	`/* Discarded, excluded and ignored sections effectively have zero`
`size. */`	`size. */`
`if (section->output_section != NULL`	`if (section->output_section != NULL`
`&& section->output_section->owner == link_info.output_bfd`	`&& section->output_section->owner == link_info.output_bfd`
`&& (section->output_section->flags & SEC_EXCLUDE) == 0`	`&& (section->output_section->flags & SEC_EXCLUDE) == 0`
`&& !IGNORE_SECTION (section)`	`&& !IGNORE_SECTION (section)`
`&& section->size != 0)`	`&& section->size != 0)`
`{`	`{`
`bfd_boolean has_relro_section = (bfd_boolean ) data;`	`bfd_boolean has_relro_section = (bfd_boolean ) data;`
`*has_relro_section = TRUE;`	`*has_relro_section = TRUE;`
`}`	`}`
`}`	`}`

`/* Iterate over sections for relro sections. */`	`/* Iterate over sections for relro sections. */`

`static void`	`static void`
`lang_find_relro_sections_1 (lang_statement_union_type *s,`	`lang_find_relro_sections_1 (lang_statement_union_type *s,`
`bfd_boolean *has_relro_section)`	`bfd_boolean *has_relro_section)`
`{`	`{`
`if (*has_relro_section)`	`if (*has_relro_section)`
`return;`	`return;`

`for (; s != NULL; s = s->header.next)`	`for (; s != NULL; s = s->header.next)`
`{`	`{`
`if (s == expld.dataseg.relro_end_stat)`	`if (s == expld.dataseg.relro_end_stat)`
`break;`	`break;`

`switch (s->header.type)`	`switch (s->header.type)`
`{`	`{`
`case lang_wild_statement_enum:`	`case lang_wild_statement_enum:`
`walk_wild (&s->wild_statement,`	`walk_wild (&s->wild_statement,`
`find_relro_section_callback,`	`find_relro_section_callback,`
`has_relro_section);`	`has_relro_section);`
`break;`	`break;`
`case lang_constructors_statement_enum:`	`case lang_constructors_statement_enum:`
`lang_find_relro_sections_1 (constructor_list.head,`	`lang_find_relro_sections_1 (constructor_list.head,`
`has_relro_section);`	`has_relro_section);`
`break;`	`break;`
`case lang_output_section_statement_enum:`	`case lang_output_section_statement_enum:`
`lang_find_relro_sections_1 (s->output_section_statement.children.head,`	`lang_find_relro_sections_1 (s->output_section_statement.children.head,`
`has_relro_section);`	`has_relro_section);`
`break;`	`break;`
`case lang_group_statement_enum:`	`case lang_group_statement_enum:`
`lang_find_relro_sections_1 (s->group_statement.children.head,`	`lang_find_relro_sections_1 (s->group_statement.children.head,`
`has_relro_section);`	`has_relro_section);`
`break;`	`break;`
`default:`	`default:`
`break;`	`break;`
`}`	`}`
`}`	`}`
`}`	`}`

`static void`	`static void`
`lang_find_relro_sections (void)`	`lang_find_relro_sections (void)`
`{`	`{`
`bfd_boolean has_relro_section = FALSE;`	`bfd_boolean has_relro_section = FALSE;`

`/* Check all sections in the link script. */`	`/* Check all sections in the link script. */`

`lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,`	`lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,`
`&has_relro_section);`	`&has_relro_section);`

`if (!has_relro_section)`	`if (!has_relro_section)`
`link_info.relro = FALSE;`	`link_info.relro = FALSE;`
`}`	`}`

`/* Relax all sections until bfd_relax_section gives up. */`	`/* Relax all sections until bfd_relax_section gives up. */`

`void`	`void`
`lang_relax_sections (bfd_boolean need_layout)`	`lang_relax_sections (bfd_boolean need_layout)`
`{`	`{`
`if (RELAXATION_ENABLED)`	`if (RELAXATION_ENABLED)`
`{`	`{`
`/* We may need more than one relaxation pass. */`	`/* We may need more than one relaxation pass. */`
`int i = link_info.relax_pass;`	`int i = link_info.relax_pass;`

`/* The backend can use it to determine the current pass. */`	`/* The backend can use it to determine the current pass. */`
`link_info.relax_pass = 0;`	`link_info.relax_pass = 0;`

`while (i--)`	`while (i--)`
`{`	`{`
`/* Keep relaxing until bfd_relax_section gives up. */`	`/* Keep relaxing until bfd_relax_section gives up. */`
`bfd_boolean relax_again;`	`bfd_boolean relax_again;`

`link_info.relax_trip = -1;`	`link_info.relax_trip = -1;`
`do`	`do`
`{`	`{`
`link_info.relax_trip++;`	`link_info.relax_trip++;`

`/* Note: pe-dll.c does something like this also. If you find`	`/* Note: pe-dll.c does something like this also. If you find`
`you need to change this code, you probably need to change`	`you need to change this code, you probably need to change`
`pe-dll.c also. DJ */`	`pe-dll.c also. DJ */`

`/* Do all the assignments with our current guesses as to`	`/* Do all the assignments with our current guesses as to`
`section sizes. */`	`section sizes. */`
`lang_do_assignments (lang_assigning_phase_enum);`	`lang_do_assignments (lang_assigning_phase_enum);`

`/* We must do this after lang_do_assignments, because it uses`	`/* We must do this after lang_do_assignments, because it uses`
`size. */`	`size. */`
`lang_reset_memory_regions ();`	`lang_reset_memory_regions ();`

`/* Perform another relax pass - this time we know where the`	`/* Perform another relax pass - this time we know where the`
`globals are, so can make a better guess. */`	`globals are, so can make a better guess. */`
`relax_again = FALSE;`	`relax_again = FALSE;`
`lang_size_sections (&relax_again, FALSE);`	`lang_size_sections (&relax_again, FALSE);`
`}`	`}`
`while (relax_again);`	`while (relax_again);`

`link_info.relax_pass++;`	`link_info.relax_pass++;`
`}`	`}`
`need_layout = TRUE;`	`need_layout = TRUE;`
`}`	`}`

`if (need_layout)`	`if (need_layout)`
`{`	`{`
`/* Final extra sizing to report errors. */`	`/* Final extra sizing to report errors. */`
`lang_do_assignments (lang_assigning_phase_enum);`	`lang_do_assignments (lang_assigning_phase_enum);`
`lang_reset_memory_regions ();`	`lang_reset_memory_regions ();`
`lang_size_sections (NULL, TRUE);`	`lang_size_sections (NULL, TRUE);`
`}`	`}`
`}`	`}`

`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`/* Find the insert point for the plugin's replacement files. We`	`/* Find the insert point for the plugin's replacement files. We`
`place them after the first claimed real object file, or if the`	`place them after the first claimed real object file, or if the`
`first claimed object is an archive member, after the last real`	`first claimed object is an archive member, after the last real`
`object file immediately preceding the archive. In the event`	`object file immediately preceding the archive. In the event`
`no objects have been claimed at all, we return the first dummy`	`no objects have been claimed at all, we return the first dummy`
`object file on the list as the insert point; that works, but`	`object file on the list as the insert point; that works, but`
`the callee must be careful when relinking the file_chain as it`	`the callee must be careful when relinking the file_chain as it`
`is not actually on that chain, only the statement_list and the`	`is not actually on that chain, only the statement_list and the`
`input_file list; in that case, the replacement files must be`	`input_file list; in that case, the replacement files must be`
`inserted at the head of the file_chain. */`	`inserted at the head of the file_chain. */`

`static lang_input_statement_type *`	`static lang_input_statement_type *`
`find_replacements_insert_point (void)`	`find_replacements_insert_point (void)`
`{`	`{`
`lang_input_statement_type claim1, lastobject;`	`lang_input_statement_type claim1, lastobject;`
`lastobject = &input_file_chain.head->input_statement;`	`lastobject = &input_file_chain.head->input_statement;`
`for (claim1 = &file_chain.head->input_statement;`	`for (claim1 = &file_chain.head->input_statement;`
`claim1 != NULL;`	`claim1 != NULL;`
`claim1 = &claim1->next->input_statement)`	`claim1 = &claim1->next->input_statement)`
`{`	`{`
`if (claim1->claimed)`	`if (claim1->claimed)`
`return claim1->claim_archive ? lastobject : claim1;`	`return claim1->claim_archive ? lastobject : claim1;`
`/* Update lastobject if this is a real object file. */`	`/* Update lastobject if this is a real object file. */`
`if (claim1->the_bfd && (claim1->the_bfd->my_archive == NULL))`	`if (claim1->the_bfd && (claim1->the_bfd->my_archive == NULL))`
`lastobject = claim1;`	`lastobject = claim1;`
`}`	`}`
`/* No files were claimed by the plugin. Choose the last object`	`/* No files were claimed by the plugin. Choose the last object`
`file found on the list (maybe the first, dummy entry) as the`	`file found on the list (maybe the first, dummy entry) as the`
`insert point. */`	`insert point. */`
`return lastobject;`	`return lastobject;`
`}`	`}`

`/* Insert SRCLIST into DESTLIST after given element by chaining`	`/* Insert SRCLIST into DESTLIST after given element by chaining`
`on FIELD as the next-pointer. (Counterintuitively does not need`	`on FIELD as the next-pointer. (Counterintuitively does not need`
`a pointer to the actual after-node itself, just its chain field.) */`	`a pointer to the actual after-node itself, just its chain field.) */`

`static void`	`static void`
`lang_list_insert_after (lang_statement_list_type *destlist,`	`lang_list_insert_after (lang_statement_list_type *destlist,`
`lang_statement_list_type *srclist,`	`lang_statement_list_type *srclist,`
`lang_statement_union_type **field)`	`lang_statement_union_type **field)`
`{`	`{`
`(srclist->tail) = field;`	`(srclist->tail) = field;`
`*field = srclist->head;`	`*field = srclist->head;`
`if (destlist->tail == field)`	`if (destlist->tail == field)`
`destlist->tail = srclist->tail;`	`destlist->tail = srclist->tail;`
`}`	`}`

`/* Detach new nodes added to DESTLIST since the time ORIGLIST`	`/* Detach new nodes added to DESTLIST since the time ORIGLIST`
`was taken as a copy of it and leave them in ORIGLIST. */`	`was taken as a copy of it and leave them in ORIGLIST. */`

`static void`	`static void`
`lang_list_remove_tail (lang_statement_list_type *destlist,`	`lang_list_remove_tail (lang_statement_list_type *destlist,`
`lang_statement_list_type *origlist)`	`lang_statement_list_type *origlist)`
`{`	`{`
`union lang_statement_union **savetail;`	`union lang_statement_union **savetail;`
`/* Check that ORIGLIST really is an earlier state of DESTLIST. */`	`/* Check that ORIGLIST really is an earlier state of DESTLIST. */`
`ASSERT (origlist->head == destlist->head);`	`ASSERT (origlist->head == destlist->head);`
`savetail = origlist->tail;`	`savetail = origlist->tail;`
`origlist->head = *(savetail);`	`origlist->head = *(savetail);`
`origlist->tail = destlist->tail;`	`origlist->tail = destlist->tail;`
`destlist->tail = savetail;`	`destlist->tail = savetail;`
`*savetail = NULL;`	`*savetail = NULL;`
`}`	`}`
`#endif /* ENABLE_PLUGINS */`	`#endif /* ENABLE_PLUGINS */`

`void`	`void`
`lang_process (void)`	`lang_process (void)`
`{`	`{`
`/* Finalize dynamic list. */`	`/* Finalize dynamic list. */`
`if (link_info.dynamic_list)`	`if (link_info.dynamic_list)`
`lang_finalize_version_expr_head (&link_info.dynamic_list->head);`	`lang_finalize_version_expr_head (&link_info.dynamic_list->head);`

`current_target = default_target;`	`current_target = default_target;`

`/* Open the output file. */`	`/* Open the output file. */`
`lang_for_each_statement (ldlang_open_output);`	`lang_for_each_statement (ldlang_open_output);`
`init_opb ();`	`init_opb ();`

`ldemul_create_output_section_statements ();`	`ldemul_create_output_section_statements ();`

`/* Add to the hash table all undefineds on the command line. */`	`/* Add to the hash table all undefineds on the command line. */`
`lang_place_undefineds ();`	`lang_place_undefineds ();`

`if (!bfd_section_already_linked_table_init ())`	`if (!bfd_section_already_linked_table_init ())`
`einfo (_("%P%F: Failed to create hash table\n"));`	`einfo (_("%P%F: Failed to create hash table\n"));`

`/* Create a bfd for each input file. */`	`/* Create a bfd for each input file. */`
`current_target = default_target;`	`current_target = default_target;`
`open_input_bfds (statement_list.head, OPEN_BFD_NORMAL);`	`open_input_bfds (statement_list.head, OPEN_BFD_NORMAL);`

`#ifdef ENABLE_PLUGINS`	`#ifdef ENABLE_PLUGINS`
`if (plugin_active_plugins_p ())`	`if (plugin_active_plugins_p ())`
`{`	`{`
`lang_statement_list_type added;`	`lang_statement_list_type added;`
`lang_statement_list_type files, inputfiles;`	`lang_statement_list_type files, inputfiles;`

`/* Now all files are read, let the plugin(s) decide if there`	`/* Now all files are read, let the plugin(s) decide if there`
`are any more to be added to the link before we call the`	`are any more to be added to the link before we call the`
`emulation's after_open hook. We create a private list of`	`emulation's after_open hook. We create a private list of`
`input statements for this purpose, which we will eventually`	`input statements for this purpose, which we will eventually`
`insert into the global statment list after the first claimed`	`insert into the global statment list after the first claimed`
`file. */`	`file. */`
`added = *stat_ptr;`	`added = *stat_ptr;`
`/* We need to manipulate all three chains in synchrony. */`	`/* We need to manipulate all three chains in synchrony. */`
`files = file_chain;`	`files = file_chain;`
`inputfiles = input_file_chain;`	`inputfiles = input_file_chain;`
`if (plugin_call_all_symbols_read ())`	`if (plugin_call_all_symbols_read ())`
`einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),`	`einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),`
`plugin_error_plugin ());`	`plugin_error_plugin ());`
`/* Open any newly added files, updating the file chains. */`	`/* Open any newly added files, updating the file chains. */`
`link_info.loading_lto_outputs = TRUE;`	`link_info.loading_lto_outputs = TRUE;`
`open_input_bfds (added.head, OPEN_BFD_NORMAL);`	`open_input_bfds (added.head, OPEN_BFD_NORMAL);`
`/* Restore the global list pointer now they have all been added. */`	`/* Restore the global list pointer now they have all been added. */`
`lang_list_remove_tail (stat_ptr, &added);`	`lang_list_remove_tail (stat_ptr, &added);`
`/* And detach the fresh ends of the file lists. */`	`/* And detach the fresh ends of the file lists. */`
`lang_list_remove_tail (&file_chain, &files);`	`lang_list_remove_tail (&file_chain, &files);`
`lang_list_remove_tail (&input_file_chain, &inputfiles);`	`lang_list_remove_tail (&input_file_chain, &inputfiles);`
`/* Were any new files added? */`	`/* Were any new files added? */`
`if (added.head != NULL)`	`if (added.head != NULL)`
`{`	`{`
`/* If so, we will insert them into the statement list immediately`	`/* If so, we will insert them into the statement list immediately`
`after the first input file that was claimed by the plugin. */`	`after the first input file that was claimed by the plugin. */`
`plugin_insert = find_replacements_insert_point ();`	`plugin_insert = find_replacements_insert_point ();`
`/* If a plugin adds input files without having claimed any, we`	`/* If a plugin adds input files without having claimed any, we`
`don't really have a good idea where to place them. Just putting`	`don't really have a good idea where to place them. Just putting`
`them at the start or end of the list is liable to leave them`	`them at the start or end of the list is liable to leave them`
`outside the crtbegin...crtend range. */`	`outside the crtbegin...crtend range. */`
`ASSERT (plugin_insert != NULL);`	`ASSERT (plugin_insert != NULL);`
`/* Splice the new statement list into the old one. */`	`/* Splice the new statement list into the old one. */`
`lang_list_insert_after (stat_ptr, &added,`	`lang_list_insert_after (stat_ptr, &added,`
`&plugin_insert->header.next);`	`&plugin_insert->header.next);`
`/* Likewise for the file chains. */`	`/* Likewise for the file chains. */`
`lang_list_insert_after (&input_file_chain, &inputfiles,`	`lang_list_insert_after (&input_file_chain, &inputfiles,`
`&plugin_insert->next_real_file);`	`&plugin_insert->next_real_file);`
`/* We must be careful when relinking file_chain; we may need to`	`/* We must be careful when relinking file_chain; we may need to`
`insert the new files at the head of the list if the insert`	`insert the new files at the head of the list if the insert`
`point chosen is the dummy first input file. */`	`point chosen is the dummy first input file. */`
`if (plugin_insert->filename)`	`if (plugin_insert->filename)`
`lang_list_insert_after (&file_chain, &files, &plugin_insert->next);`	`lang_list_insert_after (&file_chain, &files, &plugin_insert->next);`
`else`	`else`
`lang_list_insert_after (&file_chain, &files, &file_chain.head);`	`lang_list_insert_after (&file_chain, &files, &file_chain.head);`

`/* Rescan archives in case new undefined symbols have appeared. */`	`/* Rescan archives in case new undefined symbols have appeared. */`
`open_input_bfds (statement_list.head, OPEN_BFD_RESCAN);`	`open_input_bfds (statement_list.head, OPEN_BFD_RESCAN);`
`}`	`}`
`}`	`}`
`#endif /* ENABLE_PLUGINS */`	`#endif /* ENABLE_PLUGINS */`

`link_info.gc_sym_list = &entry_symbol;`	`link_info.gc_sym_list = &entry_symbol;`
`if (entry_symbol.name == NULL)`	`if (entry_symbol.name == NULL)`
`link_info.gc_sym_list = ldlang_undef_chain_list_head;`	`link_info.gc_sym_list = ldlang_undef_chain_list_head;`

`ldemul_after_open ();`	`ldemul_after_open ();`

`bfd_section_already_linked_table_free ();`	`bfd_section_already_linked_table_free ();`

`/* Make sure that we're not mixing architectures. We call this`	`/* Make sure that we're not mixing architectures. We call this`
`after all the input files have been opened, but before we do any`	`after all the input files have been opened, but before we do any`
`other processing, so that any operations merge_private_bfd_data`	`other processing, so that any operations merge_private_bfd_data`
`does on the output file will be known during the rest of the`	`does on the output file will be known during the rest of the`
`link. */`	`link. */`
`lang_check ();`	`lang_check ();`

`/* Handle .exports instead of a version script if we're told to do so. */`	`/* Handle .exports instead of a version script if we're told to do so. */`
`if (command_line.version_exports_section)`	`if (command_line.version_exports_section)`
`lang_do_version_exports_section ();`	`lang_do_version_exports_section ();`

`/* Build all sets based on the information gathered from the input`	`/* Build all sets based on the information gathered from the input`
`files. */`	`files. */`
`ldctor_build_sets ();`	`ldctor_build_sets ();`

`/* Remove unreferenced sections if asked to. */`	`/* Remove unreferenced sections if asked to. */`
`lang_gc_sections ();`	`lang_gc_sections ();`

`/* Size up the common data. */`	`/* Size up the common data. */`
`lang_common ();`	`lang_common ();`

`/* Update wild statements. */`	`/* Update wild statements. */`
`update_wild_statements (statement_list.head);`	`update_wild_statements (statement_list.head);`

`/* Run through the contours of the script and attach input sections`	`/* Run through the contours of the script and attach input sections`
`to the correct output sections. */`	`to the correct output sections. */`
`lang_statement_iteration++;`	`lang_statement_iteration++;`
`map_input_to_output_sections (statement_list.head, NULL, NULL);`	`map_input_to_output_sections (statement_list.head, NULL, NULL);`

`process_insert_statements ();`	`process_insert_statements ();`

`/* Find any sections not attached explicitly and handle them. */`	`/* Find any sections not attached explicitly and handle them. */`
`lang_place_orphans ();`	`lang_place_orphans ();`

`if (! link_info.relocatable)`	`if (! link_info.relocatable)`
`{`	`{`
`asection *found;`	`asection *found;`

`/* Merge SEC_MERGE sections. This has to be done after GC of`	`/* Merge SEC_MERGE sections. This has to be done after GC of`
`sections, so that GCed sections are not merged, but before`	`sections, so that GCed sections are not merged, but before`
`assigning dynamic symbols, since removing whole input sections`	`assigning dynamic symbols, since removing whole input sections`
`is hard then. */`	`is hard then. */`
`bfd_merge_sections (link_info.output_bfd, &link_info);`	`bfd_merge_sections (link_info.output_bfd, &link_info);`

`/* Look for a text section and set the readonly attribute in it. */`	`/* Look for a text section and set the readonly attribute in it. */`
`found = bfd_get_section_by_name (link_info.output_bfd, ".text");`	`found = bfd_get_section_by_name (link_info.output_bfd, ".text");`

`if (found != NULL)`	`if (found != NULL)`
`{`	`{`
`if (config.text_read_only)`	`if (config.text_read_only)`
`found->flags \|= SEC_READONLY;`	`found->flags \|= SEC_READONLY;`
`else`	`else`
`found->flags &= ~SEC_READONLY;`	`found->flags &= ~SEC_READONLY;`
`}`	`}`
`}`	`}`

`/* Do anything special before sizing sections. This is where ELF`	`/* Do anything special before sizing sections. This is where ELF`
`and other back-ends size dynamic sections. */`	`and other back-ends size dynamic sections. */`
`ldemul_before_allocation ();`	`ldemul_before_allocation ();`

`/* We must record the program headers before we try to fix the`	`/* We must record the program headers before we try to fix the`
`section positions, since they will affect SIZEOF_HEADERS. */`	`section positions, since they will affect SIZEOF_HEADERS. */`
`lang_record_phdrs ();`	`lang_record_phdrs ();`

`/* Check relro sections. */`	`/* Check relro sections. */`
`if (link_info.relro && ! link_info.relocatable)`	`if (link_info.relro && ! link_info.relocatable)`
`lang_find_relro_sections ();`	`lang_find_relro_sections ();`

`/* Size up the sections. */`	`/* Size up the sections. */`
`lang_size_sections (NULL, ! RELAXATION_ENABLED);`	`lang_size_sections (NULL, ! RELAXATION_ENABLED);`

`/* See if anything special should be done now we know how big`	`/* See if anything special should be done now we know how big`
`everything is. This is where relaxation is done. */`	`everything is. This is where relaxation is done. */`
`ldemul_after_allocation ();`	`ldemul_after_allocation ();`

`/* Fix any .startof. or .sizeof. symbols. */`	`/* Fix any .startof. or .sizeof. symbols. */`
`lang_set_startof ();`	`lang_set_startof ();`

`/* Do all the assignments, now that we know the final resting places`	`/* Do all the assignments, now that we know the final resting places`
`of all the symbols. */`	`of all the symbols. */`
`lang_do_assignments (lang_final_phase_enum);`	`lang_do_assignments (lang_final_phase_enum);`

`ldemul_finish ();`	`ldemul_finish ();`

`/* Make sure that the section addresses make sense. */`	`/* Make sure that the section addresses make sense. */`
`if (command_line.check_section_addresses)`	`if (command_line.check_section_addresses)`
`lang_check_section_addresses ();`	`lang_check_section_addresses ();`

`lang_end ();`	`lang_end ();`
`}`	`}`

`/* EXPORTED TO YACC */`	`/* EXPORTED TO YACC */`

`void`	`void`
`lang_add_wild (struct wildcard_spec *filespec,`	`lang_add_wild (struct wildcard_spec *filespec,`
`struct wildcard_list *section_list,`	`struct wildcard_list *section_list,`
`bfd_boolean keep_sections)`	`bfd_boolean keep_sections)`
`{`	`{`
`struct wildcard_list curr, next;`	`struct wildcard_list curr, next;`
`lang_wild_statement_type *new_stmt;`	`lang_wild_statement_type *new_stmt;`

`/* Reverse the list as the parser puts it back to front. */`	`/* Reverse the list as the parser puts it back to front. */`
`for (curr = section_list, section_list = NULL;`	`for (curr = section_list, section_list = NULL;`
`curr != NULL;`	`curr != NULL;`
`section_list = curr, curr = next)`	`section_list = curr, curr = next)`
`{`	`{`
`if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)`	`if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)`
`placed_commons = TRUE;`	`placed_commons = TRUE;`

`next = curr->next;`	`next = curr->next;`
`curr->next = section_list;`	`curr->next = section_list;`
`}`	`}`

`if (filespec != NULL && filespec->name != NULL)`	`if (filespec != NULL && filespec->name != NULL)`
`{`	`{`
`if (strcmp (filespec->name, "*") == 0)`	`if (strcmp (filespec->name, "*") == 0)`
`filespec->name = NULL;`	`filespec->name = NULL;`
`else if (! wildcardp (filespec->name))`	`else if (! wildcardp (filespec->name))`
`lang_has_input_file = TRUE;`	`lang_has_input_file = TRUE;`
`}`	`}`

`new_stmt = new_stat (lang_wild_statement, stat_ptr);`	`new_stmt = new_stat (lang_wild_statement, stat_ptr);`
`new_stmt->filename = NULL;`	`new_stmt->filename = NULL;`
`new_stmt->filenames_sorted = FALSE;`	`new_stmt->filenames_sorted = FALSE;`
`new_stmt->section_flag_list = NULL;`	`new_stmt->section_flag_list = NULL;`
`if (filespec != NULL)`	`if (filespec != NULL)`
`{`	`{`
`new_stmt->filename = filespec->name;`	`new_stmt->filename = filespec->name;`
`new_stmt->filenames_sorted = filespec->sorted == by_name;`	`new_stmt->filenames_sorted = filespec->sorted == by_name;`
`new_stmt->section_flag_list = filespec->section_flag_list;`	`new_stmt->section_flag_list = filespec->section_flag_list;`
`}`	`}`
`new_stmt->section_list = section_list;`	`new_stmt->section_list = section_list;`
`new_stmt->keep_sections = keep_sections;`	`new_stmt->keep_sections = keep_sections;`
`lang_list_init (&new_stmt->children);`	`lang_list_init (&new_stmt->children);`
`analyze_walk_wild_section_handler (new_stmt);`	`analyze_walk_wild_section_handler (new_stmt);`
`}`	`}`

`void`	`void`
`lang_section_start (const char name, etree_type address,`	`lang_section_start (const char name, etree_type address,`
`const segment_type *segment)`	`const segment_type *segment)`
`{`	`{`
`lang_address_statement_type *ad;`	`lang_address_statement_type *ad;`

`ad = new_stat (lang_address_statement, stat_ptr);`	`ad = new_stat (lang_address_statement, stat_ptr);`
`ad->section_name = name;`	`ad->section_name = name;`
`ad->address = address;`	`ad->address = address;`
`ad->segment = segment;`	`ad->segment = segment;`
`}`	`}`

`/* Set the start symbol to NAME. CMDLINE is nonzero if this is called`	`/* Set the start symbol to NAME. CMDLINE is nonzero if this is called`
`because of a -e argument on the command line, or zero if this is`	`because of a -e argument on the command line, or zero if this is`
`called by ENTRY in a linker script. Command line arguments take`	`called by ENTRY in a linker script. Command line arguments take`
`precedence. */`	`precedence. */`

`void`	`void`
`lang_add_entry (const char *name, bfd_boolean cmdline)`	`lang_add_entry (const char *name, bfd_boolean cmdline)`
`{`	`{`
`if (entry_symbol.name == NULL`	`if (entry_symbol.name == NULL`
`\|\| cmdline`	`\|\| cmdline`
`\|\| ! entry_from_cmdline)`	`\|\| ! entry_from_cmdline)`
`{`	`{`
`entry_symbol.name = name;`	`entry_symbol.name = name;`
`entry_from_cmdline = cmdline;`	`entry_from_cmdline = cmdline;`
`}`	`}`
`}`	`}`

`/* Set the default start symbol to NAME. .em files should use this,`	`/* Set the default start symbol to NAME. .em files should use this,`
`not lang_add_entry, to override the use of "start" if neither the`	`not lang_add_entry, to override the use of "start" if neither the`
`linker script nor the command line specifies an entry point. NAME`	`linker script nor the command line specifies an entry point. NAME`
`must be permanently allocated. */`	`must be permanently allocated. */`
`void`	`void`
`lang_default_entry (const char *name)`	`lang_default_entry (const char *name)`
`{`	`{`
`entry_symbol_default = name;`	`entry_symbol_default = name;`
`}`	`}`

`void`	`void`
`lang_add_target (const char *name)`	`lang_add_target (const char *name)`
`{`	`{`
`lang_target_statement_type *new_stmt;`	`lang_target_statement_type *new_stmt;`

`new_stmt = new_stat (lang_target_statement, stat_ptr);`	`new_stmt = new_stat (lang_target_statement, stat_ptr);`
`new_stmt->target = name;`	`new_stmt->target = name;`
`}`	`}`

`void`	`void`
`lang_add_map (const char *name)`	`lang_add_map (const char *name)`
`{`	`{`
`while (*name)`	`while (*name)`
`{`	`{`
`switch (*name)`	`switch (*name)`
`{`	`{`
`case 'F':`	`case 'F':`
`map_option_f = TRUE;`	`map_option_f = TRUE;`
`break;`	`break;`
`}`	`}`
`name++;`	`name++;`
`}`	`}`
`}`	`}`

`void`	`void`
`lang_add_fill (fill_type *fill)`	`lang_add_fill (fill_type *fill)`
`{`	`{`
`lang_fill_statement_type *new_stmt;`	`lang_fill_statement_type *new_stmt;`

`new_stmt = new_stat (lang_fill_statement, stat_ptr);`	`new_stmt = new_stat (lang_fill_statement, stat_ptr);`
`new_stmt->fill = fill;`	`new_stmt->fill = fill;`
`}`	`}`

`void`	`void`
`lang_add_data (int type, union etree_union *exp)`	`lang_add_data (int type, union etree_union *exp)`
`{`	`{`
`lang_data_statement_type *new_stmt;`	`lang_data_statement_type *new_stmt;`

`new_stmt = new_stat (lang_data_statement, stat_ptr);`	`new_stmt = new_stat (lang_data_statement, stat_ptr);`
`new_stmt->exp = exp;`	`new_stmt->exp = exp;`
`new_stmt->type = type;`	`new_stmt->type = type;`
`}`	`}`

`/* Create a new reloc statement. RELOC is the BFD relocation type to`	`/* Create a new reloc statement. RELOC is the BFD relocation type to`
`generate. HOWTO is the corresponding howto structure (we could`	`generate. HOWTO is the corresponding howto structure (we could`
`look this up, but the caller has already done so). SECTION is the`	`look this up, but the caller has already done so). SECTION is the`
`section to generate a reloc against, or NAME is the name of the`	`section to generate a reloc against, or NAME is the name of the`
`symbol to generate a reloc against. Exactly one of SECTION and`	`symbol to generate a reloc against. Exactly one of SECTION and`
`NAME must be NULL. ADDEND is an expression for the addend. */`	`NAME must be NULL. ADDEND is an expression for the addend. */`

`void`	`void`
`lang_add_reloc (bfd_reloc_code_real_type reloc,`	`lang_add_reloc (bfd_reloc_code_real_type reloc,`
`reloc_howto_type *howto,`	`reloc_howto_type *howto,`
`asection *section,`	`asection *section,`
`const char *name,`	`const char *name,`
`union etree_union *addend)`	`union etree_union *addend)`
`{`	`{`
`lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);`	`lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);`

`p->reloc = reloc;`	`p->reloc = reloc;`
`p->howto = howto;`	`p->howto = howto;`
`p->section = section;`	`p->section = section;`
`p->name = name;`	`p->name = name;`
`p->addend_exp = addend;`	`p->addend_exp = addend;`

`p->addend_value = 0;`	`p->addend_value = 0;`
`p->output_section = NULL;`	`p->output_section = NULL;`
`p->output_offset = 0;`	`p->output_offset = 0;`
`}`	`}`

`lang_assignment_statement_type *`	`lang_assignment_statement_type *`
`lang_add_assignment (etree_type *exp)`	`lang_add_assignment (etree_type *exp)`
`{`	`{`
`lang_assignment_statement_type *new_stmt;`	`lang_assignment_statement_type *new_stmt;`

`new_stmt = new_stat (lang_assignment_statement, stat_ptr);`	`new_stmt = new_stat (lang_assignment_statement, stat_ptr);`
`new_stmt->exp = exp;`	`new_stmt->exp = exp;`
`return new_stmt;`	`return new_stmt;`
`}`	`}`

`void`	`void`
`lang_add_attribute (enum statement_enum attribute)`	`lang_add_attribute (enum statement_enum attribute)`
`{`	`{`
`new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);`	`new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);`
`}`	`}`

`void`	`void`
`lang_startup (const char *name)`	`lang_startup (const char *name)`
`{`	`{`
`if (first_file->filename != NULL)`	`if (first_file->filename != NULL)`
`{`	`{`
`einfo (_("%P%F: multiple STARTUP files\n"));`	`einfo (_("%P%F: multiple STARTUP files\n"));`
`}`	`}`
`first_file->filename = name;`	`first_file->filename = name;`
`first_file->local_sym_name = name;`	`first_file->local_sym_name = name;`
`first_file->real = TRUE;`	`first_file->real = TRUE;`
`}`	`}`

`void`	`void`
`lang_float (bfd_boolean maybe)`	`lang_float (bfd_boolean maybe)`
`{`	`{`
`lang_float_flag = maybe;`	`lang_float_flag = maybe;`
`}`	`}`


`/* Work out the load- and run-time regions from a script statement, and`	`/* Work out the load- and run-time regions from a script statement, and`
`store them in LMA_REGION and REGION respectively.`	`store them in LMA_REGION and REGION respectively.`

`MEMSPEC is the name of the run-time region, or the value of`	`MEMSPEC is the name of the run-time region, or the value of`
`DEFAULT_MEMORY_REGION if the statement didn't specify one.`	`DEFAULT_MEMORY_REGION if the statement didn't specify one.`
`LMA_MEMSPEC is the name of the load-time region, or null if the`	`LMA_MEMSPEC is the name of the load-time region, or null if the`
`statement didn't specify one.HAVE_LMA_P is TRUE if the statement`	`statement didn't specify one.HAVE_LMA_P is TRUE if the statement`
`had an explicit load address.`	`had an explicit load address.`

`It is an error to specify both a load region and a load address. */`	`It is an error to specify both a load region and a load address. */`

`static void`	`static void`
`lang_get_regions (lang_memory_region_type **region,`	`lang_get_regions (lang_memory_region_type **region,`
`lang_memory_region_type **lma_region,`	`lang_memory_region_type **lma_region,`
`const char *memspec,`	`const char *memspec,`
`const char *lma_memspec,`	`const char *lma_memspec,`
`bfd_boolean have_lma,`	`bfd_boolean have_lma,`
`bfd_boolean have_vma)`	`bfd_boolean have_vma)`
`{`	`{`
`*lma_region = lang_memory_region_lookup (lma_memspec, FALSE);`	`*lma_region = lang_memory_region_lookup (lma_memspec, FALSE);`

`/* If no runtime region or VMA has been specified, but the load region`	`/* 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`	`has been specified, then use the load region for the runtime region`
`as well. */`	`as well. */`
`if (lma_memspec != NULL`	`if (lma_memspec != NULL`
`&& ! have_vma`	`&& ! have_vma`
`&& strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)`	`&& strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)`
`region = lma_region;`	`region = lma_region;`
`else`	`else`
`*region = lang_memory_region_lookup (memspec, FALSE);`	`*region = lang_memory_region_lookup (memspec, FALSE);`

`if (have_lma && lma_memspec != 0)`	`if (have_lma && lma_memspec != 0)`
`einfo (_("%X%P:%S: section has both a load address and a load region\n"));`	`einfo (_("%X%P:%S: section has both a load address and a load region\n"));`
`}`	`}`

`void`	`void`
`lang_leave_output_section_statement (fill_type fill, const char memspec,`	`lang_leave_output_section_statement (fill_type fill, const char memspec,`
`lang_output_section_phdr_list *phdrs,`	`lang_output_section_phdr_list *phdrs,`
`const char *lma_memspec)`	`const char *lma_memspec)`
`{`	`{`
`lang_get_regions (&current_section->region,`	`lang_get_regions (&current_section->region,`
`&current_section->lma_region,`	`&current_section->lma_region,`
`memspec, lma_memspec,`	`memspec, lma_memspec,`
`current_section->load_base != NULL,`	`current_section->load_base != NULL,`
`current_section->addr_tree != NULL);`	`current_section->addr_tree != NULL);`

`/* If this section has no load region or base, but uses the same`	`/* If this section has no load region or base, but uses the same`
`region as the previous section, then propagate the previous`	`region as the previous section, then propagate the previous`
`section's load region. */`	`section's load region. */`

`if (current_section->lma_region == NULL`	`if (current_section->lma_region == NULL`
`&& current_section->load_base == NULL`	`&& current_section->load_base == NULL`
`&& current_section->addr_tree == NULL`	`&& current_section->addr_tree == NULL`
`&& current_section->region == current_section->prev->region)`	`&& current_section->region == current_section->prev->region)`
`current_section->lma_region = current_section->prev->lma_region;`	`current_section->lma_region = current_section->prev->lma_region;`

`current_section->fill = fill;`	`current_section->fill = fill;`
`current_section->phdrs = phdrs;`	`current_section->phdrs = phdrs;`
`pop_stat_ptr ();`	`pop_stat_ptr ();`
`}`	`}`

`/* Create an absolute symbol with the given name with the value of the`	`/* Create an absolute symbol with the given name with the value of the`
`address of first byte of the section named.`	`address of first byte of the section named.`

`If the symbol already exists, then do nothing. */`	`If the symbol already exists, then do nothing. */`

`void`	`void`
`lang_abs_symbol_at_beginning_of (const char secname, const char name)`	`lang_abs_symbol_at_beginning_of (const char secname, const char name)`
`{`	`{`
`struct bfd_link_hash_entry *h;`	`struct bfd_link_hash_entry *h;`

`h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);`	`h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);`
`if (h == NULL)`	`if (h == NULL)`
`einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));`	`einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));`

`if (h->type == bfd_link_hash_new`	`if (h->type == bfd_link_hash_new`
`\|\| h->type == bfd_link_hash_undefined)`	`\|\| h->type == bfd_link_hash_undefined)`
`{`	`{`
`asection *sec;`	`asection *sec;`

`h->type = bfd_link_hash_defined;`	`h->type = bfd_link_hash_defined;`

`sec = bfd_get_section_by_name (link_info.output_bfd, secname);`	`sec = bfd_get_section_by_name (link_info.output_bfd, secname);`
`if (sec == NULL)`	`if (sec == NULL)`
`h->u.def.value = 0;`	`h->u.def.value = 0;`
`else`	`else`
`h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);`	`h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);`

`h->u.def.section = bfd_abs_section_ptr;`	`h->u.def.section = bfd_abs_section_ptr;`
`}`	`}`
`}`	`}`

`/* Create an absolute symbol with the given name with the value of the`	`/* Create an absolute symbol with the given name with the value of the`
`address of the first byte after the end of the section named.`	`address of the first byte after the end of the section named.`

`If the symbol already exists, then do nothing. */`	`If the symbol already exists, then do nothing. */`

`void`	`void`
`lang_abs_symbol_at_end_of (const char secname, const char name)`	`lang_abs_symbol_at_end_of (const char secname, const char name)`
`{`	`{`
`struct bfd_link_hash_entry *h;`	`struct bfd_link_hash_entry *h;`

`h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);`	`h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);`
`if (h == NULL)`	`if (h == NULL)`
`einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));`	`einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));`

`if (h->type == bfd_link_hash_new`	`if (h->type == bfd_link_hash_new`
`\|\| h->type == bfd_link_hash_undefined)`	`\|\| h->type == bfd_link_hash_undefined)`
`{`	`{`
`asection *sec;`	`asection *sec;`

`h->type = bfd_link_hash_defined;`	`h->type = bfd_link_hash_defined;`

`sec = bfd_get_section_by_name (link_info.output_bfd, secname);`	`sec = bfd_get_section_by_name (link_info.output_bfd, secname);`
`if (sec == NULL)`	`if (sec == NULL)`
`h->u.def.value = 0;`	`h->u.def.value = 0;`
`else`	`else`
`h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)`	`h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)`
`+ TO_ADDR (sec->size));`	`+ TO_ADDR (sec->size));`

`h->u.def.section = bfd_abs_section_ptr;`	`h->u.def.section = bfd_abs_section_ptr;`
`}`	`}`
`}`	`}`

`void`	`void`
`lang_statement_append (lang_statement_list_type *list,`	`lang_statement_append (lang_statement_list_type *list,`
`lang_statement_union_type *element,`	`lang_statement_union_type *element,`
`lang_statement_union_type **field)`	`lang_statement_union_type **field)`
`{`	`{`
`*(list->tail) = element;`	`*(list->tail) = element;`
`list->tail = field;`	`list->tail = field;`
`}`	`}`

`/* Set the output format type. -oformat overrides scripts. */`	`/* Set the output format type. -oformat overrides scripts. */`

`void`	`void`
`lang_add_output_format (const char *format,`	`lang_add_output_format (const char *format,`
`const char *big,`	`const char *big,`
`const char *little,`	`const char *little,`
`int from_script)`	`int from_script)`
`{`	`{`
`if (output_target == NULL \|\| !from_script)`	`if (output_target == NULL \|\| !from_script)`
`{`	`{`
`if (command_line.endian == ENDIAN_BIG`	`if (command_line.endian == ENDIAN_BIG`
`&& big != NULL)`	`&& big != NULL)`
`format = big;`	`format = big;`
`else if (command_line.endian == ENDIAN_LITTLE`	`else if (command_line.endian == ENDIAN_LITTLE`
`&& little != NULL)`	`&& little != NULL)`
`format = little;`	`format = little;`

`output_target = format;`	`output_target = format;`
`}`	`}`
`}`	`}`

`void`	`void`
`lang_add_insert (const char *where, int is_before)`	`lang_add_insert (const char *where, int is_before)`
`{`	`{`
`lang_insert_statement_type *new_stmt;`	`lang_insert_statement_type *new_stmt;`

`new_stmt = new_stat (lang_insert_statement, stat_ptr);`	`new_stmt = new_stat (lang_insert_statement, stat_ptr);`
`new_stmt->where = where;`	`new_stmt->where = where;`
`new_stmt->is_before = is_before;`	`new_stmt->is_before = is_before;`
`saved_script_handle = previous_script_handle;`	`saved_script_handle = previous_script_handle;`
`}`	`}`

`/* Enter a group. This creates a new lang_group_statement, and sets`	`/* Enter a group. This creates a new lang_group_statement, and sets`
`stat_ptr to build new statements within the group. */`	`stat_ptr to build new statements within the group. */`

`void`	`void`
`lang_enter_group (void)`	`lang_enter_group (void)`
`{`	`{`
`lang_group_statement_type *g;`	`lang_group_statement_type *g;`

`g = new_stat (lang_group_statement, stat_ptr);`	`g = new_stat (lang_group_statement, stat_ptr);`
`lang_list_init (&g->children);`	`lang_list_init (&g->children);`
`push_stat_ptr (&g->children);`	`push_stat_ptr (&g->children);`
`}`	`}`

`/* Leave a group. This just resets stat_ptr to start writing to the`	`/* Leave a group. This just resets stat_ptr to start writing to the`
`regular list of statements again. Note that this will not work if`	`regular list of statements again. Note that this will not work if`
`groups can occur inside anything else which can adjust stat_ptr,`	`groups can occur inside anything else which can adjust stat_ptr,`
`but currently they can't. */`	`but currently they can't. */`

`void`	`void`
`lang_leave_group (void)`	`lang_leave_group (void)`
`{`	`{`
`pop_stat_ptr ();`	`pop_stat_ptr ();`
`}`	`}`

`/* Add a new program header. This is called for each entry in a PHDRS`	`/* Add a new program header. This is called for each entry in a PHDRS`
`command in a linker script. */`	`command in a linker script. */`

`void`	`void`
`lang_new_phdr (const char *name,`	`lang_new_phdr (const char *name,`
`etree_type *type,`	`etree_type *type,`
`bfd_boolean filehdr,`	`bfd_boolean filehdr,`
`bfd_boolean phdrs,`	`bfd_boolean phdrs,`
`etree_type *at,`	`etree_type *at,`
`etree_type *flags)`	`etree_type *flags)`
`{`	`{`
`struct lang_phdr n, *pp;`	`struct lang_phdr n, *pp;`
`bfd_boolean hdrs;`	`bfd_boolean hdrs;`

`n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));`	`n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));`
`n->next = NULL;`	`n->next = NULL;`
`n->name = name;`	`n->name = name;`
`n->type = exp_get_value_int (type, 0, "program header type");`	`n->type = exp_get_value_int (type, 0, "program header type");`
`n->filehdr = filehdr;`	`n->filehdr = filehdr;`
`n->phdrs = phdrs;`	`n->phdrs = phdrs;`
`n->at = at;`	`n->at = at;`
`n->flags = flags;`	`n->flags = flags;`

`hdrs = n->type == 1 && (phdrs \|\| filehdr);`	`hdrs = n->type == 1 && (phdrs \|\| filehdr);`

`for (pp = &lang_phdr_list; pp != NULL; pp = &(pp)->next)`	`for (pp = &lang_phdr_list; pp != NULL; pp = &(pp)->next)`
`if (hdrs`	`if (hdrs`
`&& (*pp)->type == 1`	`&& (*pp)->type == 1`
`&& !((pp)->filehdr \|\| (pp)->phdrs))`	`&& !((pp)->filehdr \|\| (pp)->phdrs))`
`{`	`{`
`einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported when prior PT_LOAD headers lack them\n"));`	`einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported when prior PT_LOAD headers lack them\n"));`
`hdrs = FALSE;`	`hdrs = FALSE;`
`}`	`}`

`*pp = n;`	`*pp = n;`
`}`	`}`

`/* Record the program header information in the output BFD. FIXME: We`	`/* Record the program header information in the output BFD. FIXME: We`
`should not be calling an ELF specific function here. */`	`should not be calling an ELF specific function here. */`

`static void`	`static void`
`lang_record_phdrs (void)`	`lang_record_phdrs (void)`
`{`	`{`
`unsigned int alc;`	`unsigned int alc;`
`asection **secs;`	`asection **secs;`
`lang_output_section_phdr_list *last;`	`lang_output_section_phdr_list *last;`
`struct lang_phdr *l;`	`struct lang_phdr *l;`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`

`alc = 10;`	`alc = 10;`
`secs = (asection *) xmalloc (alc sizeof (asection *));`	`secs = (asection *) xmalloc (alc sizeof (asection *));`
`last = NULL;`	`last = NULL;`

`for (l = lang_phdr_list; l != NULL; l = l->next)`	`for (l = lang_phdr_list; l != NULL; l = l->next)`
`{`	`{`
`unsigned int c;`	`unsigned int c;`
`flagword flags;`	`flagword flags;`
`bfd_vma at;`	`bfd_vma at;`

`c = 0;`	`c = 0;`
`for (os = &lang_output_section_statement.head->output_section_statement;`	`for (os = &lang_output_section_statement.head->output_section_statement;`
`os != NULL;`	`os != NULL;`
`os = os->next)`	`os = os->next)`
`{`	`{`
`lang_output_section_phdr_list *pl;`	`lang_output_section_phdr_list *pl;`

`if (os->constraint < 0)`	`if (os->constraint < 0)`
`continue;`	`continue;`

`pl = os->phdrs;`	`pl = os->phdrs;`
`if (pl != NULL)`	`if (pl != NULL)`
`last = pl;`	`last = pl;`
`else`	`else`
`{`	`{`
`if (os->sectype == noload_section`	`if (os->sectype == noload_section`
`\|\| os->bfd_section == NULL`	`\|\| os->bfd_section == NULL`
`\|\| (os->bfd_section->flags & SEC_ALLOC) == 0)`	`\|\| (os->bfd_section->flags & SEC_ALLOC) == 0)`
`continue;`	`continue;`

`/* Don't add orphans to PT_INTERP header. */`	`/* Don't add orphans to PT_INTERP header. */`
`if (l->type == 3)`	`if (l->type == 3)`
`continue;`	`continue;`

`if (last == NULL)`	`if (last == NULL)`
`{`	`{`
`lang_output_section_statement_type * tmp_os;`	`lang_output_section_statement_type * tmp_os;`

`/* If we have not run across a section with a program`	`/* If we have not run across a section with a program`
`header assigned to it yet, then scan forwards to find`	`header assigned to it yet, then scan forwards to find`
`one. This prevents inconsistencies in the linker's`	`one. This prevents inconsistencies in the linker's`
`behaviour when a script has specified just a single`	`behaviour when a script has specified just a single`
`header and there are sections in that script which are`	`header and there are sections in that script which are`
`not assigned to it, and which occur before the first`	`not assigned to it, and which occur before the first`
`use of that header. See here for more details:`	`use of that header. See here for more details:`
`http://sourceware.org/ml/binutils/2007-02/msg00291.html */`	`http://sourceware.org/ml/binutils/2007-02/msg00291.html */`
`for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)`	`for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)`
`if (tmp_os->phdrs)`	`if (tmp_os->phdrs)`
`{`	`{`
`last = tmp_os->phdrs;`	`last = tmp_os->phdrs;`
`break;`	`break;`
`}`	`}`
`if (last == NULL)`	`if (last == NULL)`
`einfo (_("%F%P: no sections assigned to phdrs\n"));`	`einfo (_("%F%P: no sections assigned to phdrs\n"));`
`}`	`}`
`pl = last;`	`pl = last;`
`}`	`}`

`if (os->bfd_section == NULL)`	`if (os->bfd_section == NULL)`
`continue;`	`continue;`

`for (; pl != NULL; pl = pl->next)`	`for (; pl != NULL; pl = pl->next)`
`{`	`{`
`if (strcmp (pl->name, l->name) == 0)`	`if (strcmp (pl->name, l->name) == 0)`
`{`	`{`
`if (c >= alc)`	`if (c >= alc)`
`{`	`{`
`alc *= 2;`	`alc *= 2;`
`secs = (asection **) xrealloc (secs,`	`secs = (asection **) xrealloc (secs,`
`alc * sizeof (asection *));`	`alc * sizeof (asection *));`
`}`	`}`
`secs[c] = os->bfd_section;`	`secs[c] = os->bfd_section;`
`++c;`	`++c;`
`pl->used = TRUE;`	`pl->used = TRUE;`
`}`	`}`
`}`	`}`
`}`	`}`

`if (l->flags == NULL)`	`if (l->flags == NULL)`
`flags = 0;`	`flags = 0;`
`else`	`else`
`flags = exp_get_vma (l->flags, 0, "phdr flags");`	`flags = exp_get_vma (l->flags, 0, "phdr flags");`

`if (l->at == NULL)`	`if (l->at == NULL)`
`at = 0;`	`at = 0;`
`else`	`else`
`at = exp_get_vma (l->at, 0, "phdr load address");`	`at = exp_get_vma (l->at, 0, "phdr load address");`

`if (! bfd_record_phdr (link_info.output_bfd, l->type,`	`if (! bfd_record_phdr (link_info.output_bfd, l->type,`
`l->flags != NULL, flags, l->at != NULL,`	`l->flags != NULL, flags, l->at != NULL,`
`at, l->filehdr, l->phdrs, c, secs))`	`at, l->filehdr, l->phdrs, c, secs))`
`einfo (_("%F%P: bfd_record_phdr failed: %E\n"));`	`einfo (_("%F%P: bfd_record_phdr failed: %E\n"));`
`}`	`}`

`free (secs);`	`free (secs);`

`/* Make sure all the phdr assignments succeeded. */`	`/* Make sure all the phdr assignments succeeded. */`
`for (os = &lang_output_section_statement.head->output_section_statement;`	`for (os = &lang_output_section_statement.head->output_section_statement;`
`os != NULL;`	`os != NULL;`
`os = os->next)`	`os = os->next)`
`{`	`{`
`lang_output_section_phdr_list *pl;`	`lang_output_section_phdr_list *pl;`

`if (os->constraint < 0`	`if (os->constraint < 0`
`\|\| os->bfd_section == NULL)`	`\|\| os->bfd_section == NULL)`
`continue;`	`continue;`

`for (pl = os->phdrs;`	`for (pl = os->phdrs;`
`pl != NULL;`	`pl != NULL;`
`pl = pl->next)`	`pl = pl->next)`
`if (! pl->used && strcmp (pl->name, "NONE") != 0)`	`if (! pl->used && strcmp (pl->name, "NONE") != 0)`
einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),	einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
`os->name, pl->name);`	`os->name, pl->name);`
`}`	`}`
`}`	`}`

`/* Record a list of sections which may not be cross referenced. */`	`/* Record a list of sections which may not be cross referenced. */`

`void`	`void`
`lang_add_nocrossref (lang_nocrossref_type *l)`	`lang_add_nocrossref (lang_nocrossref_type *l)`
`{`	`{`
`struct lang_nocrossrefs *n;`	`struct lang_nocrossrefs *n;`

`n = (struct lang_nocrossrefs ) xmalloc (sizeof n);`	`n = (struct lang_nocrossrefs ) xmalloc (sizeof n);`
`n->next = nocrossref_list;`	`n->next = nocrossref_list;`
`n->list = l;`	`n->list = l;`
`nocrossref_list = n;`	`nocrossref_list = n;`

`/* Set notice_all so that we get informed about all symbols. */`	`/* Set notice_all so that we get informed about all symbols. */`
`link_info.notice_all = TRUE;`	`link_info.notice_all = TRUE;`
`}`	`}`

`/* Overlay handling. We handle overlays with some static variables. */`	`/* Overlay handling. We handle overlays with some static variables. */`

`/* The overlay virtual address. */`	`/* The overlay virtual address. */`
`static etree_type *overlay_vma;`	`static etree_type *overlay_vma;`
`/* And subsection alignment. */`	`/* And subsection alignment. */`
`static etree_type *overlay_subalign;`	`static etree_type *overlay_subalign;`

`/* An expression for the maximum section size seen so far. */`	`/* An expression for the maximum section size seen so far. */`
`static etree_type *overlay_max;`	`static etree_type *overlay_max;`

`/* A list of all the sections in this overlay. */`	`/* A list of all the sections in this overlay. */`

`struct overlay_list {`	`struct overlay_list {`
`struct overlay_list *next;`	`struct overlay_list *next;`
`lang_output_section_statement_type *os;`	`lang_output_section_statement_type *os;`
`};`	`};`

`static struct overlay_list *overlay_list;`	`static struct overlay_list *overlay_list;`

`/* Start handling an overlay. */`	`/* Start handling an overlay. */`

`void`	`void`
`lang_enter_overlay (etree_type vma_expr, etree_type subalign)`	`lang_enter_overlay (etree_type vma_expr, etree_type subalign)`
`{`	`{`
`/* The grammar should prevent nested overlays from occurring. */`	`/* The grammar should prevent nested overlays from occurring. */`
`ASSERT (overlay_vma == NULL`	`ASSERT (overlay_vma == NULL`
`&& overlay_subalign == NULL`	`&& overlay_subalign == NULL`
`&& overlay_max == NULL);`	`&& overlay_max == NULL);`

`overlay_vma = vma_expr;`	`overlay_vma = vma_expr;`
`overlay_subalign = subalign;`	`overlay_subalign = subalign;`
`}`	`}`

`/* Start a section in an overlay. We handle this by calling`	`/* Start a section in an overlay. We handle this by calling`
`lang_enter_output_section_statement with the correct VMA.`	`lang_enter_output_section_statement with the correct VMA.`
`lang_leave_overlay sets up the LMA and memory regions. */`	`lang_leave_overlay sets up the LMA and memory regions. */`

`void`	`void`
`lang_enter_overlay_section (const char *name)`	`lang_enter_overlay_section (const char *name)`
`{`	`{`
`struct overlay_list *n;`	`struct overlay_list *n;`
`etree_type *size;`	`etree_type *size;`

`lang_enter_output_section_statement (name, overlay_vma, overlay_section,`	`lang_enter_output_section_statement (name, overlay_vma, overlay_section,`
`0, overlay_subalign, 0, 0);`	`0, overlay_subalign, 0, 0);`

`/* If this is the first section, then base the VMA of future`	`/* If this is the first section, then base the VMA of future`
sections on this one. This will work correctly even if `.' is	sections on this one. This will work correctly even if `.' is
`used in the addresses. */`	`used in the addresses. */`
`if (overlay_list == NULL)`	`if (overlay_list == NULL)`
`overlay_vma = exp_nameop (ADDR, name);`	`overlay_vma = exp_nameop (ADDR, name);`

`/* Remember the section. */`	`/* Remember the section. */`
`n = (struct overlay_list ) xmalloc (sizeof n);`	`n = (struct overlay_list ) xmalloc (sizeof n);`
`n->os = current_section;`	`n->os = current_section;`
`n->next = overlay_list;`	`n->next = overlay_list;`
`overlay_list = n;`	`overlay_list = n;`

`size = exp_nameop (SIZEOF, name);`	`size = exp_nameop (SIZEOF, name);`

`/* Arrange to work out the maximum section end address. */`	`/* Arrange to work out the maximum section end address. */`
`if (overlay_max == NULL)`	`if (overlay_max == NULL)`
`overlay_max = size;`	`overlay_max = size;`
`else`	`else`
`overlay_max = exp_binop (MAX_K, overlay_max, size);`	`overlay_max = exp_binop (MAX_K, overlay_max, size);`
`}`	`}`

`/* Finish a section in an overlay. There isn't any special to do`	`/* Finish a section in an overlay. There isn't any special to do`
`here. */`	`here. */`

`void`	`void`
`lang_leave_overlay_section (fill_type *fill,`	`lang_leave_overlay_section (fill_type *fill,`
`lang_output_section_phdr_list *phdrs)`	`lang_output_section_phdr_list *phdrs)`
`{`	`{`
`const char *name;`	`const char *name;`
`char clean, s2;`	`char clean, s2;`
`const char *s1;`	`const char *s1;`
`char *buf;`	`char *buf;`

`name = current_section->name;`	`name = current_section->name;`

`/* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory`	`/* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory`
`region and that no load-time region has been specified. It doesn't`	`region and that no load-time region has been specified. It doesn't`
`really matter what we say here, since lang_leave_overlay will`	`really matter what we say here, since lang_leave_overlay will`
`override it. */`	`override it. */`
`lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);`	`lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);`

`/* Define the magic symbols. */`	`/* Define the magic symbols. */`

`clean = (char *) xmalloc (strlen (name) + 1);`	`clean = (char *) xmalloc (strlen (name) + 1);`
`s2 = clean;`	`s2 = clean;`
`for (s1 = name; *s1 != '\0'; s1++)`	`for (s1 = name; *s1 != '\0'; s1++)`
`if (ISALNUM (s1) \|\| s1 == '_')`	`if (ISALNUM (s1) \|\| s1 == '_')`
`s2++ = s1;`	`s2++ = s1;`
`*s2 = '\0';`	`*s2 = '\0';`

`buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");`	`buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");`
`sprintf (buf, "__load_start_%s", clean);`	`sprintf (buf, "__load_start_%s", clean);`
`lang_add_assignment (exp_provide (buf,`	`lang_add_assignment (exp_provide (buf,`
`exp_nameop (LOADADDR, name),`	`exp_nameop (LOADADDR, name),`
`FALSE));`	`FALSE));`

`buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");`	`buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");`
`sprintf (buf, "__load_stop_%s", clean);`	`sprintf (buf, "__load_stop_%s", clean);`
`lang_add_assignment (exp_provide (buf,`	`lang_add_assignment (exp_provide (buf,`
`exp_binop ('+',`	`exp_binop ('+',`
`exp_nameop (LOADADDR, name),`	`exp_nameop (LOADADDR, name),`
`exp_nameop (SIZEOF, name)),`	`exp_nameop (SIZEOF, name)),`
`FALSE));`	`FALSE));`

`free (clean);`	`free (clean);`
`}`	`}`

`/* Finish an overlay. If there are any overlay wide settings, this`	`/* Finish an overlay. If there are any overlay wide settings, this`
`looks through all the sections in the overlay and sets them. */`	`looks through all the sections in the overlay and sets them. */`

`void`	`void`
`lang_leave_overlay (etree_type *lma_expr,`	`lang_leave_overlay (etree_type *lma_expr,`
`int nocrossrefs,`	`int nocrossrefs,`
`fill_type *fill,`	`fill_type *fill,`
`const char *memspec,`	`const char *memspec,`
`lang_output_section_phdr_list *phdrs,`	`lang_output_section_phdr_list *phdrs,`
`const char *lma_memspec)`	`const char *lma_memspec)`
`{`	`{`
`lang_memory_region_type *region;`	`lang_memory_region_type *region;`
`lang_memory_region_type *lma_region;`	`lang_memory_region_type *lma_region;`
`struct overlay_list *l;`	`struct overlay_list *l;`
`lang_nocrossref_type *nocrossref;`	`lang_nocrossref_type *nocrossref;`

`lang_get_regions (&region, &lma_region,`	`lang_get_regions (&region, &lma_region,`
`memspec, lma_memspec,`	`memspec, lma_memspec,`
`lma_expr != NULL, FALSE);`	`lma_expr != NULL, FALSE);`

`nocrossref = NULL;`	`nocrossref = NULL;`

`/* After setting the size of the last section, set '.' to end of the`	`/* After setting the size of the last section, set '.' to end of the`
`overlay region. */`	`overlay region. */`
`if (overlay_list != NULL)`	`if (overlay_list != NULL)`
`overlay_list->os->update_dot_tree`	`overlay_list->os->update_dot_tree`
`= exp_assign (".", exp_binop ('+', overlay_vma, overlay_max));`	`= exp_assign (".", exp_binop ('+', overlay_vma, overlay_max));`

`l = overlay_list;`	`l = overlay_list;`
`while (l != NULL)`	`while (l != NULL)`
`{`	`{`
`struct overlay_list *next;`	`struct overlay_list *next;`

`if (fill != NULL && l->os->fill == NULL)`	`if (fill != NULL && l->os->fill == NULL)`
`l->os->fill = fill;`	`l->os->fill = fill;`

`l->os->region = region;`	`l->os->region = region;`
`l->os->lma_region = lma_region;`	`l->os->lma_region = lma_region;`

`/* The first section has the load address specified in the`	`/* The first section has the load address specified in the`
`OVERLAY statement. The rest are worked out from that.`	`OVERLAY statement. The rest are worked out from that.`
`The base address is not needed (and should be null) if`	`The base address is not needed (and should be null) if`
`an LMA region was specified. */`	`an LMA region was specified. */`
`if (l->next == 0)`	`if (l->next == 0)`
`{`	`{`
`l->os->load_base = lma_expr;`	`l->os->load_base = lma_expr;`
`l->os->sectype = normal_section;`	`l->os->sectype = normal_section;`
`}`	`}`
`if (phdrs != NULL && l->os->phdrs == NULL)`	`if (phdrs != NULL && l->os->phdrs == NULL)`
`l->os->phdrs = phdrs;`	`l->os->phdrs = phdrs;`

`if (nocrossrefs)`	`if (nocrossrefs)`
`{`	`{`
`lang_nocrossref_type *nc;`	`lang_nocrossref_type *nc;`

`nc = (lang_nocrossref_type ) xmalloc (sizeof nc);`	`nc = (lang_nocrossref_type ) xmalloc (sizeof nc);`
`nc->name = l->os->name;`	`nc->name = l->os->name;`
`nc->next = nocrossref;`	`nc->next = nocrossref;`
`nocrossref = nc;`	`nocrossref = nc;`
`}`	`}`

`next = l->next;`	`next = l->next;`
`free (l);`	`free (l);`
`l = next;`	`l = next;`
`}`	`}`

`if (nocrossref != NULL)`	`if (nocrossref != NULL)`
`lang_add_nocrossref (nocrossref);`	`lang_add_nocrossref (nocrossref);`

`overlay_vma = NULL;`	`overlay_vma = NULL;`
`overlay_list = NULL;`	`overlay_list = NULL;`
`overlay_max = NULL;`	`overlay_max = NULL;`
`}`	`}`

`/* Version handling. This is only useful for ELF. */`	`/* Version handling. This is only useful for ELF. */`

`/* This global variable holds the version tree that we build. */`

`struct bfd_elf_version_tree *lang_elf_version_info;`

`/* If PREV is NULL, return first version pattern matching particular symbol.`	`/* If PREV is NULL, return first version pattern matching particular symbol.`
`If PREV is non-NULL, return first version pattern matching particular`	`If PREV is non-NULL, return first version pattern matching particular`
`symbol after PREV (previously returned by lang_vers_match). */`	`symbol after PREV (previously returned by lang_vers_match). */`

`static struct bfd_elf_version_expr *`	`static struct bfd_elf_version_expr *`
`lang_vers_match (struct bfd_elf_version_expr_head *head,`	`lang_vers_match (struct bfd_elf_version_expr_head *head,`
`struct bfd_elf_version_expr *prev,`	`struct bfd_elf_version_expr *prev,`
`const char *sym)`	`const char *sym)`
`{`	`{`
`const char *c_sym;`	`const char *c_sym;`
`const char *cxx_sym = sym;`	`const char *cxx_sym = sym;`
`const char *java_sym = sym;`	`const char *java_sym = sym;`
`struct bfd_elf_version_expr *expr = NULL;`	`struct bfd_elf_version_expr *expr = NULL;`
`enum demangling_styles curr_style;`	`enum demangling_styles curr_style;`

`curr_style = CURRENT_DEMANGLING_STYLE;`	`curr_style = CURRENT_DEMANGLING_STYLE;`
`cplus_demangle_set_style (no_demangling);`	`cplus_demangle_set_style (no_demangling);`
`c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS);`	`c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS);`
`if (!c_sym)`	`if (!c_sym)`
`c_sym = sym;`	`c_sym = sym;`
`cplus_demangle_set_style (curr_style);`	`cplus_demangle_set_style (curr_style);`

`if (head->mask & BFD_ELF_VERSION_CXX_TYPE)`	`if (head->mask & BFD_ELF_VERSION_CXX_TYPE)`
`{`	`{`
`cxx_sym = bfd_demangle (link_info.output_bfd, sym,`	`cxx_sym = bfd_demangle (link_info.output_bfd, sym,`
`DMGL_PARAMS \| DMGL_ANSI);`	`DMGL_PARAMS \| DMGL_ANSI);`
`if (!cxx_sym)`	`if (!cxx_sym)`
`cxx_sym = sym;`	`cxx_sym = sym;`
`}`	`}`
`if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)`	`if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)`
`{`	`{`
`java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA);`	`java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA);`
`if (!java_sym)`	`if (!java_sym)`
`java_sym = sym;`	`java_sym = sym;`
`}`	`}`

`if (head->htab && (prev == NULL \|\| prev->literal))`	`if (head->htab && (prev == NULL \|\| prev->literal))`
`{`	`{`
`struct bfd_elf_version_expr e;`	`struct bfd_elf_version_expr e;`

`switch (prev ? prev->mask : 0)`	`switch (prev ? prev->mask : 0)`
`{`	`{`
`case 0:`	`case 0:`
`if (head->mask & BFD_ELF_VERSION_C_TYPE)`	`if (head->mask & BFD_ELF_VERSION_C_TYPE)`
`{`	`{`
`e.pattern = c_sym;`	`e.pattern = c_sym;`
`expr = (struct bfd_elf_version_expr *)`	`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)`	`while (expr && strcmp (expr->pattern, c_sym) == 0)`
`if (expr->mask == BFD_ELF_VERSION_C_TYPE)`	`if (expr->mask == BFD_ELF_VERSION_C_TYPE)`
`goto out_ret;`	`goto out_ret;`
`else`	`else`
`expr = expr->next;`	`expr = expr->next;`
`}`	`}`
`/* Fallthrough */`	`/* Fallthrough */`
`case BFD_ELF_VERSION_C_TYPE:`	`case BFD_ELF_VERSION_C_TYPE:`
`if (head->mask & BFD_ELF_VERSION_CXX_TYPE)`	`if (head->mask & BFD_ELF_VERSION_CXX_TYPE)`
`{`	`{`
`e.pattern = cxx_sym;`	`e.pattern = cxx_sym;`
`expr = (struct bfd_elf_version_expr *)`	`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)`	`while (expr && strcmp (expr->pattern, cxx_sym) == 0)`
`if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)`	`if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)`
`goto out_ret;`	`goto out_ret;`
`else`	`else`
`expr = expr->next;`	`expr = expr->next;`
`}`	`}`
`/* Fallthrough */`	`/* Fallthrough */`
`case BFD_ELF_VERSION_CXX_TYPE:`	`case BFD_ELF_VERSION_CXX_TYPE:`
`if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)`	`if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)`
`{`	`{`
`e.pattern = java_sym;`	`e.pattern = java_sym;`
`expr = (struct bfd_elf_version_expr *)`	`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)`	`while (expr && strcmp (expr->pattern, java_sym) == 0)`
`if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)`	`if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)`
`goto out_ret;`	`goto out_ret;`
`else`	`else`
`expr = expr->next;`	`expr = expr->next;`
`}`	`}`
`/* Fallthrough */`	`/* Fallthrough */`
`default:`	`default:`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* Finally, try the wildcards. */`	`/* Finally, try the wildcards. */`
`if (prev == NULL \|\| prev->literal)`	`if (prev == NULL \|\| prev->literal)`
`expr = head->remaining;`	`expr = head->remaining;`
`else`	`else`
`expr = prev->next;`	`expr = prev->next;`
`for (; expr; expr = expr->next)`	`for (; expr; expr = expr->next)`
`{`	`{`
`const char *s;`	`const char *s;`

`if (!expr->pattern)`	`if (!expr->pattern)`
`continue;`	`continue;`

`if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')`	`if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')`
`break;`	`break;`

`if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)`	`if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)`
`s = java_sym;`	`s = java_sym;`
`else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)`	`else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)`
`s = cxx_sym;`	`s = cxx_sym;`
`else`	`else`
`s = c_sym;`	`s = c_sym;`
`if (fnmatch (expr->pattern, s, 0) == 0)`	`if (fnmatch (expr->pattern, s, 0) == 0)`
`break;`	`break;`
`}`	`}`

`out_ret:`	`out_ret:`
`if (c_sym != sym)`	`if (c_sym != sym)`
`free ((char *) c_sym);`	`free ((char *) c_sym);`
`if (cxx_sym != sym)`	`if (cxx_sym != sym)`
`free ((char *) cxx_sym);`	`free ((char *) cxx_sym);`
`if (java_sym != sym)`	`if (java_sym != sym)`
`free ((char *) java_sym);`	`free ((char *) java_sym);`
`return expr;`	`return expr;`
`}`	`}`

`/* Return NULL if the PATTERN argument is a glob pattern, otherwise,`	`/* Return NULL if the PATTERN argument is a glob pattern, otherwise,`
`return a pointer to the symbol name with any backslash quotes removed. */`	`return a pointer to the symbol name with any backslash quotes removed. */`

`static const char *`	`static const char *`
`realsymbol (const char *pattern)`	`realsymbol (const char *pattern)`
`{`	`{`
`const char *p;`	`const char *p;`
`bfd_boolean changed = FALSE, backslash = FALSE;`	`bfd_boolean changed = FALSE, backslash = FALSE;`
`char s, symbol = (char *) xmalloc (strlen (pattern) + 1);`	`char s, symbol = (char *) xmalloc (strlen (pattern) + 1);`

`for (p = pattern, s = symbol; *p != '\0'; ++p)`	`for (p = pattern, s = symbol; *p != '\0'; ++p)`
`{`	`{`
`/* It is a glob pattern only if there is no preceding`	`/* It is a glob pattern only if there is no preceding`
`backslash. */`	`backslash. */`
`if (backslash)`	`if (backslash)`
`{`	`{`
`/* Remove the preceding backslash. */`	`/* Remove the preceding backslash. */`
`(s - 1) = p;`	`(s - 1) = p;`
`backslash = FALSE;`	`backslash = FALSE;`
`changed = TRUE;`	`changed = TRUE;`
`}`	`}`
`else`	`else`
`{`	`{`
`if (p == '?' \|\| p == '' \|\| p == '[')`	`if (p == '?' \|\| p == '' \|\| p == '[')`
`{`	`{`
`free (symbol);`	`free (symbol);`
`return NULL;`	`return NULL;`
`}`	`}`

`s++ = p;`	`s++ = p;`
`backslash = *p == '\\';`	`backslash = *p == '\\';`
`}`	`}`
`}`	`}`

`if (changed)`	`if (changed)`
`{`	`{`
`*s = '\0';`	`*s = '\0';`
`return symbol;`	`return symbol;`
`}`	`}`
`else`	`else`
`{`	`{`
`free (symbol);`	`free (symbol);`
`return pattern;`	`return pattern;`
`}`	`}`
`}`	`}`

`/* This is called for each variable name or match expression. NEW_NAME is`	`/* This is called for each variable name or match expression. NEW_NAME is`
`the name of the symbol to match, or, if LITERAL_P is FALSE, a glob`	`the name of the symbol to match, or, if LITERAL_P is FALSE, a glob`
`pattern to be matched against symbol names. */`	`pattern to be matched against symbol names. */`

`struct bfd_elf_version_expr *`	`struct bfd_elf_version_expr *`
`lang_new_vers_pattern (struct bfd_elf_version_expr *orig,`	`lang_new_vers_pattern (struct bfd_elf_version_expr *orig,`
`const char *new_name,`	`const char *new_name,`
`const char *lang,`	`const char *lang,`
`bfd_boolean literal_p)`	`bfd_boolean literal_p)`
`{`	`{`
`struct bfd_elf_version_expr *ret;`	`struct bfd_elf_version_expr *ret;`

`ret = (struct bfd_elf_version_expr ) xmalloc (sizeof ret);`	`ret = (struct bfd_elf_version_expr ) xmalloc (sizeof ret);`
`ret->next = orig;`	`ret->next = orig;`
`ret->symver = 0;`	`ret->symver = 0;`
`ret->script = 0;`	`ret->script = 0;`
`ret->literal = TRUE;`	`ret->literal = TRUE;`
`ret->pattern = literal_p ? new_name : realsymbol (new_name);`	`ret->pattern = literal_p ? new_name : realsymbol (new_name);`
`if (ret->pattern == NULL)`	`if (ret->pattern == NULL)`
`{`	`{`
`ret->pattern = new_name;`	`ret->pattern = new_name;`
`ret->literal = FALSE;`	`ret->literal = FALSE;`
`}`	`}`

`if (lang == NULL \|\| strcasecmp (lang, "C") == 0)`	`if (lang == NULL \|\| strcasecmp (lang, "C") == 0)`
`ret->mask = BFD_ELF_VERSION_C_TYPE;`	`ret->mask = BFD_ELF_VERSION_C_TYPE;`
`else if (strcasecmp (lang, "C++") == 0)`	`else if (strcasecmp (lang, "C++") == 0)`
`ret->mask = BFD_ELF_VERSION_CXX_TYPE;`	`ret->mask = BFD_ELF_VERSION_CXX_TYPE;`
`else if (strcasecmp (lang, "Java") == 0)`	`else if (strcasecmp (lang, "Java") == 0)`
`ret->mask = BFD_ELF_VERSION_JAVA_TYPE;`	`ret->mask = BFD_ELF_VERSION_JAVA_TYPE;`
`else`	`else`
`{`	`{`
einfo (_("%X%P: unknown language `%s' in version information\n"),	einfo (_("%X%P: unknown language `%s' in version information\n"),
`lang);`	`lang);`
`ret->mask = BFD_ELF_VERSION_C_TYPE;`	`ret->mask = BFD_ELF_VERSION_C_TYPE;`
`}`	`}`

`return ldemul_new_vers_pattern (ret);`	`return ldemul_new_vers_pattern (ret);`
`}`	`}`

`/* This is called for each set of variable names and match`	`/* This is called for each set of variable names and match`
`expressions. */`	`expressions. */`

`struct bfd_elf_version_tree *`	`struct bfd_elf_version_tree *`
`lang_new_vers_node (struct bfd_elf_version_expr *globals,`	`lang_new_vers_node (struct bfd_elf_version_expr *globals,`
`struct bfd_elf_version_expr *locals)`	`struct bfd_elf_version_expr *locals)`
`{`	`{`
`struct bfd_elf_version_tree *ret;`	`struct bfd_elf_version_tree *ret;`

`ret = (struct bfd_elf_version_tree ) xcalloc (1, sizeof ret);`	`ret = (struct bfd_elf_version_tree ) xcalloc (1, sizeof ret);`
`ret->globals.list = globals;`	`ret->globals.list = globals;`
`ret->locals.list = locals;`	`ret->locals.list = locals;`
`ret->match = lang_vers_match;`	`ret->match = lang_vers_match;`
`ret->name_indx = (unsigned int) -1;`	`ret->name_indx = (unsigned int) -1;`
`return ret;`	`return ret;`
`}`	`}`

`/* This static variable keeps track of version indices. */`	`/* This static variable keeps track of version indices. */`

`static int version_index;`	`static int version_index;`

`static hashval_t`	`static hashval_t`
`version_expr_head_hash (const void *p)`	`version_expr_head_hash (const void *p)`
`{`	`{`
`const struct bfd_elf_version_expr *e =`	`const struct bfd_elf_version_expr *e =`
`(const struct bfd_elf_version_expr *) p;`	`(const struct bfd_elf_version_expr *) p;`

`return htab_hash_string (e->pattern);`	`return htab_hash_string (e->pattern);`
`}`	`}`

`static int`	`static int`
`version_expr_head_eq (const void p1, const void p2)`	`version_expr_head_eq (const void p1, const void p2)`
`{`	`{`
`const struct bfd_elf_version_expr *e1 =`	`const struct bfd_elf_version_expr *e1 =`
`(const struct bfd_elf_version_expr *) p1;`	`(const struct bfd_elf_version_expr *) p1;`
`const struct bfd_elf_version_expr *e2 =`	`const struct bfd_elf_version_expr *e2 =`
`(const struct bfd_elf_version_expr *) p2;`	`(const struct bfd_elf_version_expr *) p2;`

`return strcmp (e1->pattern, e2->pattern) == 0;`	`return strcmp (e1->pattern, e2->pattern) == 0;`
`}`	`}`

`static void`	`static void`
`lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)`	`lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)`
`{`	`{`
`size_t count = 0;`	`size_t count = 0;`
`struct bfd_elf_version_expr e, next;`	`struct bfd_elf_version_expr e, next;`
`struct bfd_elf_version_expr list_loc, remaining_loc;`	`struct bfd_elf_version_expr list_loc, remaining_loc;`

`for (e = head->list; e; e = e->next)`	`for (e = head->list; e; e = e->next)`
`{`	`{`
`if (e->literal)`	`if (e->literal)`
`count++;`	`count++;`
`head->mask \|= e->mask;`	`head->mask \|= e->mask;`
`}`	`}`

`if (count)`	`if (count)`
`{`	`{`
`head->htab = htab_create (count * 2, version_expr_head_hash,`	`head->htab = htab_create (count * 2, version_expr_head_hash,`
`version_expr_head_eq, NULL);`	`version_expr_head_eq, NULL);`
`list_loc = &head->list;`	`list_loc = &head->list;`
`remaining_loc = &head->remaining;`	`remaining_loc = &head->remaining;`
`for (e = head->list; e; e = next)`	`for (e = head->list; e; e = next)`
`{`	`{`
`next = e->next;`	`next = e->next;`
`if (!e->literal)`	`if (!e->literal)`
`{`	`{`
`*remaining_loc = e;`	`*remaining_loc = e;`
`remaining_loc = &e->next;`	`remaining_loc = &e->next;`
`}`	`}`
`else`	`else`
`{`	`{`
`void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);`	`void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);`

`if (*loc)`	`if (*loc)`
`{`	`{`
`struct bfd_elf_version_expr e1, last;`	`struct bfd_elf_version_expr e1, last;`

`e1 = (struct bfd_elf_version_expr ) loc;`	`e1 = (struct bfd_elf_version_expr ) loc;`
`last = NULL;`	`last = NULL;`
`do`	`do`
`{`	`{`
`if (e1->mask == e->mask)`	`if (e1->mask == e->mask)`
`{`	`{`
`last = NULL;`	`last = NULL;`
`break;`	`break;`
`}`	`}`
`last = e1;`	`last = e1;`
`e1 = e1->next;`	`e1 = e1->next;`
`}`	`}`
`while (e1 && strcmp (e1->pattern, e->pattern) == 0);`	`while (e1 && strcmp (e1->pattern, e->pattern) == 0);`

`if (last == NULL)`	`if (last == NULL)`
`{`	`{`
`/* This is a duplicate. */`	`/* This is a duplicate. */`
`/* FIXME: Memory leak. Sometimes pattern is not`	`/* FIXME: Memory leak. Sometimes pattern is not`
`xmalloced alone, but in larger chunk of memory. */`	`xmalloced alone, but in larger chunk of memory. */`
`/* free (e->pattern); */`	`/* free (e->pattern); */`
`free (e);`	`free (e);`
`}`	`}`
`else`	`else`
`{`	`{`
`e->next = last->next;`	`e->next = last->next;`
`last->next = e;`	`last->next = e;`
`}`	`}`
`}`	`}`
`else`	`else`
`{`	`{`
`*loc = e;`	`*loc = e;`
`*list_loc = e;`	`*list_loc = e;`
`list_loc = &e->next;`	`list_loc = &e->next;`
`}`	`}`
`}`	`}`
`}`	`}`
`*remaining_loc = NULL;`	`*remaining_loc = NULL;`
`*list_loc = head->remaining;`	`*list_loc = head->remaining;`
`}`	`}`
`else`	`else`
`head->remaining = head->list;`	`head->remaining = head->list;`
`}`	`}`

`/* This is called when we know the name and dependencies of the`	`/* This is called when we know the name and dependencies of the`
`version. */`	`version. */`

`void`	`void`
`lang_register_vers_node (const char *name,`	`lang_register_vers_node (const char *name,`
`struct bfd_elf_version_tree *version,`	`struct bfd_elf_version_tree *version,`
`struct bfd_elf_version_deps *deps)`	`struct bfd_elf_version_deps *deps)`
`{`	`{`
`struct bfd_elf_version_tree t, *pp;`	`struct bfd_elf_version_tree t, *pp;`
`struct bfd_elf_version_expr *e1;`	`struct bfd_elf_version_expr *e1;`

`if (name == NULL)`	`if (name == NULL)`
`name = "";`	`name = "";`

`if ((name[0] == '\0' && lang_elf_version_info != NULL)`	`if (link_info.version_info != NULL`
`\|\| (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))`	`&& (name[0] == '\0' \|\| link_info.version_info->name[0] == '\0'))`
`{`	`{`
`einfo (_("%X%P: anonymous version tag cannot be combined"`	`einfo (_("%X%P: anonymous version tag cannot be combined"`
`" with other version tags\n"));`	`" with other version tags\n"));`
`free (version);`	`free (version);`
`return;`	`return;`
`}`	`}`

`/* Make sure this node has a unique name. */`	`/* Make sure this node has a unique name. */`
`for (t = lang_elf_version_info; t != NULL; t = t->next)`	`for (t = link_info.version_info; t != NULL; t = t->next)`
`if (strcmp (t->name, name) == 0)`	`if (strcmp (t->name, name) == 0)`
einfo (_("%X%P: duplicate version tag `%s'\n"), name);	einfo (_("%X%P: duplicate version tag `%s'\n"), name);

`lang_finalize_version_expr_head (&version->globals);`	`lang_finalize_version_expr_head (&version->globals);`
`lang_finalize_version_expr_head (&version->locals);`	`lang_finalize_version_expr_head (&version->locals);`

`/* Check the global and local match names, and make sure there`	`/* Check the global and local match names, and make sure there`
`aren't any duplicates. */`	`aren't any duplicates. */`

`for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)`	`for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)`
`{`	`{`
`for (t = lang_elf_version_info; t != NULL; t = t->next)`	`for (t = link_info.version_info; t != NULL; t = t->next)`
`{`	`{`
`struct bfd_elf_version_expr *e2;`	`struct bfd_elf_version_expr *e2;`

`if (t->locals.htab && e1->literal)`	`if (t->locals.htab && e1->literal)`
`{`	`{`
`e2 = (struct bfd_elf_version_expr *)`	`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)`	`while (e2 && strcmp (e1->pattern, e2->pattern) == 0)`
`{`	`{`
`if (e1->mask == e2->mask)`	`if (e1->mask == e2->mask)`
einfo (_("%X%P: duplicate expression `%s'"	einfo (_("%X%P: duplicate expression `%s'"
`" in version information\n"), e1->pattern);`	`" in version information\n"), e1->pattern);`
`e2 = e2->next;`	`e2 = e2->next;`
`}`	`}`
`}`	`}`
`else if (!e1->literal)`	`else if (!e1->literal)`
`for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)`	`for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)`
`if (strcmp (e1->pattern, e2->pattern) == 0`	`if (strcmp (e1->pattern, e2->pattern) == 0`
`&& e1->mask == e2->mask)`	`&& e1->mask == e2->mask)`
einfo (_("%X%P: duplicate expression `%s'"	einfo (_("%X%P: duplicate expression `%s'"
`" in version information\n"), e1->pattern);`	`" in version information\n"), e1->pattern);`
`}`	`}`
`}`	`}`

`for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)`	`for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)`
`{`	`{`
`for (t = lang_elf_version_info; t != NULL; t = t->next)`	`for (t = link_info.version_info; t != NULL; t = t->next)`
`{`	`{`
`struct bfd_elf_version_expr *e2;`	`struct bfd_elf_version_expr *e2;`

`if (t->globals.htab && e1->literal)`	`if (t->globals.htab && e1->literal)`
`{`	`{`
`e2 = (struct bfd_elf_version_expr *)`	`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)`	`while (e2 && strcmp (e1->pattern, e2->pattern) == 0)`
`{`	`{`
`if (e1->mask == e2->mask)`	`if (e1->mask == e2->mask)`
einfo (_("%X%P: duplicate expression `%s'"	einfo (_("%X%P: duplicate expression `%s'"
`" in version information\n"),`	`" in version information\n"),`
`e1->pattern);`	`e1->pattern);`
`e2 = e2->next;`	`e2 = e2->next;`
`}`	`}`
`}`	`}`
`else if (!e1->literal)`	`else if (!e1->literal)`
`for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)`	`for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)`
`if (strcmp (e1->pattern, e2->pattern) == 0`	`if (strcmp (e1->pattern, e2->pattern) == 0`
`&& e1->mask == e2->mask)`	`&& e1->mask == e2->mask)`
einfo (_("%X%P: duplicate expression `%s'"	einfo (_("%X%P: duplicate expression `%s'"
`" in version information\n"), e1->pattern);`	`" in version information\n"), e1->pattern);`
`}`	`}`
`}`	`}`

`version->deps = deps;`	`version->deps = deps;`
`version->name = name;`	`version->name = name;`
`if (name[0] != '\0')`	`if (name[0] != '\0')`
`{`	`{`
`++version_index;`	`++version_index;`
`version->vernum = version_index;`	`version->vernum = version_index;`
`}`	`}`
`else`	`else`
`version->vernum = 0;`	`version->vernum = 0;`

`for (pp = &lang_elf_version_info; pp != NULL; pp = &(pp)->next)`	`for (pp = &link_info.version_info; pp != NULL; pp = &(pp)->next)`
`;`	`;`
`*pp = version;`	`*pp = version;`
`}`	`}`

`/* This is called when we see a version dependency. */`	`/* This is called when we see a version dependency. */`

`struct bfd_elf_version_deps *`	`struct bfd_elf_version_deps *`
`lang_add_vers_depend (struct bfd_elf_version_deps list, const char name)`	`lang_add_vers_depend (struct bfd_elf_version_deps list, const char name)`
`{`	`{`
`struct bfd_elf_version_deps *ret;`	`struct bfd_elf_version_deps *ret;`
`struct bfd_elf_version_tree *t;`	`struct bfd_elf_version_tree *t;`

`ret = (struct bfd_elf_version_deps ) xmalloc (sizeof ret);`	`ret = (struct bfd_elf_version_deps ) xmalloc (sizeof ret);`
`ret->next = list;`	`ret->next = list;`

`for (t = lang_elf_version_info; t != NULL; t = t->next)`	`for (t = link_info.version_info; t != NULL; t = t->next)`
`{`	`{`
`if (strcmp (t->name, name) == 0)`	`if (strcmp (t->name, name) == 0)`
`{`	`{`
`ret->version_needed = t;`	`ret->version_needed = t;`
`return ret;`	`return ret;`
`}`	`}`
`}`	`}`

einfo (_("%X%P: unable to find version dependency `%s'\n"), name);	einfo (_("%X%P: unable to find version dependency `%s'\n"), name);

`ret->version_needed = NULL;`	`ret->version_needed = NULL;`
`return ret;`	`return ret;`
`}`	`}`

`static void`	`static void`
`lang_do_version_exports_section (void)`	`lang_do_version_exports_section (void)`
`{`	`{`
`struct bfd_elf_version_expr greg = NULL, lreg;`	`struct bfd_elf_version_expr greg = NULL, lreg;`

`LANG_FOR_EACH_INPUT_STATEMENT (is)`	`LANG_FOR_EACH_INPUT_STATEMENT (is)`
`{`	`{`
`asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");`	`asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");`
`char contents, p;`	`char contents, p;`
`bfd_size_type len;`	`bfd_size_type len;`

`if (sec == NULL)`	`if (sec == NULL)`
`continue;`	`continue;`

`len = sec->size;`	`len = sec->size;`
`contents = (char *) xmalloc (len);`	`contents = (char *) xmalloc (len);`
`if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))`	`if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))`
`einfo (_("%X%P: unable to read .exports section contents\n"), sec);`	`einfo (_("%X%P: unable to read .exports section contents\n"), sec);`

`p = contents;`	`p = contents;`
`while (p < contents + len)`	`while (p < contents + len)`
`{`	`{`
`greg = lang_new_vers_pattern (greg, p, NULL, FALSE);`	`greg = lang_new_vers_pattern (greg, p, NULL, FALSE);`
`p = strchr (p, '\0') + 1;`	`p = strchr (p, '\0') + 1;`
`}`	`}`

`/* Do not free the contents, as we used them creating the regex. */`	`/* Do not free the contents, as we used them creating the regex. */`

`/* Do not include this section in the link. */`	`/* Do not include this section in the link. */`
`sec->flags \|= SEC_EXCLUDE \| SEC_KEEP;`	`sec->flags \|= SEC_EXCLUDE \| SEC_KEEP;`
`}`	`}`

`lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);`	`lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);`
`lang_register_vers_node (command_line.version_exports_section,`	`lang_register_vers_node (command_line.version_exports_section,`
`lang_new_vers_node (greg, lreg), NULL);`	`lang_new_vers_node (greg, lreg), NULL);`
`}`	`}`

`void`	`void`
`lang_add_unique (const char *name)`	`lang_add_unique (const char *name)`
`{`	`{`
`struct unique_sections *ent;`	`struct unique_sections *ent;`

`for (ent = unique_section_list; ent; ent = ent->next)`	`for (ent = unique_section_list; ent; ent = ent->next)`
`if (strcmp (ent->name, name) == 0)`	`if (strcmp (ent->name, name) == 0)`
`return;`	`return;`

`ent = (struct unique_sections ) xmalloc (sizeof ent);`	`ent = (struct unique_sections ) xmalloc (sizeof ent);`
`ent->name = xstrdup (name);`	`ent->name = xstrdup (name);`
`ent->next = unique_section_list;`	`ent->next = unique_section_list;`
`unique_section_list = ent;`	`unique_section_list = ent;`
`}`	`}`

`/* Append the list of dynamic symbols to the existing one. */`	`/* Append the list of dynamic symbols to the existing one. */`

`void`	`void`
`lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)`	`lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)`
`{`	`{`
`if (link_info.dynamic_list)`	`if (link_info.dynamic_list)`
`{`	`{`
`struct bfd_elf_version_expr *tail;`	`struct bfd_elf_version_expr *tail;`
`for (tail = dynamic; tail->next != NULL; tail = tail->next)`	`for (tail = dynamic; tail->next != NULL; tail = tail->next)`
`;`	`;`
`tail->next = link_info.dynamic_list->head.list;`	`tail->next = link_info.dynamic_list->head.list;`
`link_info.dynamic_list->head.list = dynamic;`	`link_info.dynamic_list->head.list = dynamic;`
`}`	`}`
`else`	`else`
`{`	`{`
`struct bfd_elf_dynamic_list *d;`	`struct bfd_elf_dynamic_list *d;`

`d = (struct bfd_elf_dynamic_list ) xcalloc (1, sizeof d);`	`d = (struct bfd_elf_dynamic_list ) xcalloc (1, sizeof d);`
`d->head.list = dynamic;`	`d->head.list = dynamic;`
`d->match = lang_vers_match;`	`d->match = lang_vers_match;`
`link_info.dynamic_list = d;`	`link_info.dynamic_list = d;`
`}`	`}`
`}`	`}`

`/* Append the list of C++ typeinfo dynamic symbols to the existing`	`/* Append the list of C++ typeinfo dynamic symbols to the existing`
`one. */`	`one. */`

`void`	`void`
`lang_append_dynamic_list_cpp_typeinfo (void)`	`lang_append_dynamic_list_cpp_typeinfo (void)`
`{`	`{`
`const char * symbols [] =`	`const char * symbols [] =`
`{`	`{`
`"typeinfo name for*",`	`"typeinfo name for*",`
`"typeinfo for*"`	`"typeinfo for*"`
`};`	`};`
`struct bfd_elf_version_expr *dynamic = NULL;`	`struct bfd_elf_version_expr *dynamic = NULL;`
`unsigned int i;`	`unsigned int i;`

`for (i = 0; i < ARRAY_SIZE (symbols); i++)`	`for (i = 0; i < ARRAY_SIZE (symbols); i++)`
`dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",`	`dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",`
`FALSE);`	`FALSE);`

`lang_append_dynamic_list (dynamic);`	`lang_append_dynamic_list (dynamic);`
`}`	`}`

`/* Append the list of C++ operator new and delete dynamic symbols to the`	`/* Append the list of C++ operator new and delete dynamic symbols to the`
`existing one. */`	`existing one. */`

`void`	`void`
`lang_append_dynamic_list_cpp_new (void)`	`lang_append_dynamic_list_cpp_new (void)`
`{`	`{`
`const char * symbols [] =`	`const char * symbols [] =`
`{`	`{`
`"operator new*",`	`"operator new*",`
`"operator delete*"`	`"operator delete*"`
`};`	`};`
`struct bfd_elf_version_expr *dynamic = NULL;`	`struct bfd_elf_version_expr *dynamic = NULL;`
`unsigned int i;`	`unsigned int i;`

`for (i = 0; i < ARRAY_SIZE (symbols); i++)`	`for (i = 0; i < ARRAY_SIZE (symbols); i++)`
`dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",`	`dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",`
`FALSE);`	`FALSE);`

`lang_append_dynamic_list (dynamic);`	`lang_append_dynamic_list (dynamic);`
`}`	`}`

`/* Scan a space and/or comma separated string of features. */`	`/* Scan a space and/or comma separated string of features. */`

`void`	`void`
`lang_ld_feature (char *str)`	`lang_ld_feature (char *str)`
`{`	`{`
`char p, q;`	`char p, q;`

`p = str;`	`p = str;`
`while (*p)`	`while (*p)`
`{`	`{`
`char sep;`	`char sep;`
`while (p == ',' \|\| ISSPACE (p))`	`while (p == ',' \|\| ISSPACE (p))`
`++p;`	`++p;`
`if (!*p)`	`if (!*p)`
`break;`	`break;`
`q = p + 1;`	`q = p + 1;`
`while (q && q != ',' && !ISSPACE (*q))`	`while (q && q != ',' && !ISSPACE (*q))`
`++q;`	`++q;`
`sep = *q;`	`sep = *q;`
`*q = 0;`	`*q = 0;`
`if (strcasecmp (p, "SANE_EXPR") == 0)`	`if (strcasecmp (p, "SANE_EXPR") == 0)`
`config.sane_expr = TRUE;`	`config.sane_expr = TRUE;`
`else`	`else`
einfo (_("%X%P: unknown feature `%s'\n"), p);	einfo (_("%X%P: unknown feature `%s'\n"), p);
`*q = sep;`	`*q = sep;`
`p = q;`	`p = q;`
`}`	`}`
`}`	`}`

Browse

Tools

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [ldlang.c] - Diff between revs 157 and 163