1*fae548d3Szrj /* Linker command language support.
2*fae548d3Szrj Copyright (C) 1991-2020 Free Software Foundation, Inc.
3*fae548d3Szrj
4*fae548d3Szrj This file is part of the GNU Binutils.
5*fae548d3Szrj
6*fae548d3Szrj This program is free software; you can redistribute it and/or modify
7*fae548d3Szrj it under the terms of the GNU General Public License as published by
8*fae548d3Szrj the Free Software Foundation; either version 3 of the License, or
9*fae548d3Szrj (at your option) any later version.
10*fae548d3Szrj
11*fae548d3Szrj This program is distributed in the hope that it will be useful,
12*fae548d3Szrj but WITHOUT ANY WARRANTY; without even the implied warranty of
13*fae548d3Szrj MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14*fae548d3Szrj GNU General Public License for more details.
15*fae548d3Szrj
16*fae548d3Szrj You should have received a copy of the GNU General Public License
17*fae548d3Szrj along with this program; if not, write to the Free Software
18*fae548d3Szrj Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19*fae548d3Szrj MA 02110-1301, USA. */
20*fae548d3Szrj
21*fae548d3Szrj #include "sysdep.h"
22*fae548d3Szrj #include <limits.h>
23*fae548d3Szrj #include "bfd.h"
24*fae548d3Szrj #include "libiberty.h"
25*fae548d3Szrj #include "filenames.h"
26*fae548d3Szrj #include "safe-ctype.h"
27*fae548d3Szrj #include "obstack.h"
28*fae548d3Szrj #include "bfdlink.h"
29*fae548d3Szrj #include "ctf-api.h"
30*fae548d3Szrj
31*fae548d3Szrj #include "ld.h"
32*fae548d3Szrj #include "ldmain.h"
33*fae548d3Szrj #include "ldexp.h"
34*fae548d3Szrj #include "ldlang.h"
35*fae548d3Szrj #include <ldgram.h>
36*fae548d3Szrj #include "ldlex.h"
37*fae548d3Szrj #include "ldmisc.h"
38*fae548d3Szrj #include "ldctor.h"
39*fae548d3Szrj #include "ldfile.h"
40*fae548d3Szrj #include "ldemul.h"
41*fae548d3Szrj #include "fnmatch.h"
42*fae548d3Szrj #include "demangle.h"
43*fae548d3Szrj #include "hashtab.h"
44*fae548d3Szrj #include "elf-bfd.h"
45*fae548d3Szrj #ifdef ENABLE_PLUGINS
46*fae548d3Szrj #include "plugin.h"
47*fae548d3Szrj #endif /* ENABLE_PLUGINS */
48*fae548d3Szrj
49*fae548d3Szrj #ifndef offsetof
50*fae548d3Szrj #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
51*fae548d3Szrj #endif
52*fae548d3Szrj
53*fae548d3Szrj /* Convert between addresses in bytes and sizes in octets.
54*fae548d3Szrj For currently supported targets, octets_per_byte is always a power
55*fae548d3Szrj of two, so we can use shifts. */
56*fae548d3Szrj #define TO_ADDR(X) ((X) >> opb_shift)
57*fae548d3Szrj #define TO_SIZE(X) ((X) << opb_shift)
58*fae548d3Szrj
59*fae548d3Szrj /* Local variables. */
60*fae548d3Szrj static struct obstack stat_obstack;
61*fae548d3Szrj static struct obstack map_obstack;
62*fae548d3Szrj
63*fae548d3Szrj #define obstack_chunk_alloc xmalloc
64*fae548d3Szrj #define obstack_chunk_free free
65*fae548d3Szrj static const char *entry_symbol_default = "start";
66*fae548d3Szrj static bfd_boolean map_head_is_link_order = FALSE;
67*fae548d3Szrj static lang_output_section_statement_type *default_common_section;
68*fae548d3Szrj static bfd_boolean map_option_f;
69*fae548d3Szrj static bfd_vma print_dot;
70*fae548d3Szrj static lang_input_statement_type *first_file;
71*fae548d3Szrj static const char *current_target;
72*fae548d3Szrj /* Header for list of statements corresponding to any files involved in the
73*fae548d3Szrj link, either specified from the command-line or added implicitely (eg.
74*fae548d3Szrj archive member used to resolved undefined symbol, wildcard statement from
75*fae548d3Szrj linker script, etc.). Next pointer is in next field of a
76*fae548d3Szrj lang_statement_header_type (reached via header field in a
77*fae548d3Szrj lang_statement_union). */
78*fae548d3Szrj static lang_statement_list_type statement_list;
79*fae548d3Szrj static lang_statement_list_type *stat_save[10];
80*fae548d3Szrj static lang_statement_list_type **stat_save_ptr = &stat_save[0];
81*fae548d3Szrj static struct unique_sections *unique_section_list;
82*fae548d3Szrj static struct asneeded_minfo *asneeded_list_head;
83*fae548d3Szrj static unsigned int opb_shift = 0;
84*fae548d3Szrj
85*fae548d3Szrj /* Forward declarations. */
86*fae548d3Szrj static void exp_init_os (etree_type *);
87*fae548d3Szrj static lang_input_statement_type *lookup_name (const char *);
88*fae548d3Szrj static void insert_undefined (const char *);
89*fae548d3Szrj static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
90*fae548d3Szrj static void print_statement (lang_statement_union_type *,
91*fae548d3Szrj lang_output_section_statement_type *);
92*fae548d3Szrj static void print_statement_list (lang_statement_union_type *,
93*fae548d3Szrj lang_output_section_statement_type *);
94*fae548d3Szrj static void print_statements (void);
95*fae548d3Szrj static void print_input_section (asection *, bfd_boolean);
96*fae548d3Szrj static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
97*fae548d3Szrj static void lang_record_phdrs (void);
98*fae548d3Szrj static void lang_do_version_exports_section (void);
99*fae548d3Szrj static void lang_finalize_version_expr_head
100*fae548d3Szrj (struct bfd_elf_version_expr_head *);
101*fae548d3Szrj static void lang_do_memory_regions (void);
102*fae548d3Szrj
103*fae548d3Szrj /* Exported variables. */
104*fae548d3Szrj const char *output_target;
105*fae548d3Szrj lang_output_section_statement_type *abs_output_section;
106*fae548d3Szrj lang_statement_list_type lang_os_list;
107*fae548d3Szrj lang_statement_list_type *stat_ptr = &statement_list;
108*fae548d3Szrj /* Header for list of statements corresponding to files used in the final
109*fae548d3Szrj executable. This can be either object file specified on the command-line
110*fae548d3Szrj or library member resolving an undefined reference. Next pointer is in next
111*fae548d3Szrj field of a lang_input_statement_type (reached via input_statement field in a
112*fae548d3Szrj lang_statement_union). */
113*fae548d3Szrj lang_statement_list_type file_chain = { NULL, NULL };
114*fae548d3Szrj /* Header for list of statements corresponding to files specified on the
115*fae548d3Szrj command-line for linking. It thus contains real object files and archive
116*fae548d3Szrj but not archive members. Next pointer is in next_real_file field of a
117*fae548d3Szrj lang_input_statement_type statement (reached via input_statement field in a
118*fae548d3Szrj lang_statement_union). */
119*fae548d3Szrj lang_statement_list_type input_file_chain;
120*fae548d3Szrj struct bfd_sym_chain entry_symbol = { NULL, NULL };
121*fae548d3Szrj const char *entry_section = ".text";
122*fae548d3Szrj struct lang_input_statement_flags input_flags;
123*fae548d3Szrj bfd_boolean entry_from_cmdline;
124*fae548d3Szrj bfd_boolean undef_from_cmdline;
125*fae548d3Szrj bfd_boolean lang_has_input_file = FALSE;
126*fae548d3Szrj bfd_boolean had_output_filename = FALSE;
127*fae548d3Szrj bfd_boolean lang_float_flag = FALSE;
128*fae548d3Szrj bfd_boolean delete_output_file_on_failure = FALSE;
129*fae548d3Szrj struct lang_phdr *lang_phdr_list;
130*fae548d3Szrj struct lang_nocrossrefs *nocrossref_list;
131*fae548d3Szrj struct asneeded_minfo **asneeded_list_tail;
132*fae548d3Szrj static ctf_file_t *ctf_output;
133*fae548d3Szrj
134*fae548d3Szrj /* Functions that traverse the linker script and might evaluate
135*fae548d3Szrj DEFINED() need to increment this at the start of the traversal. */
136*fae548d3Szrj int lang_statement_iteration = 0;
137*fae548d3Szrj
138*fae548d3Szrj /* Return TRUE if the PATTERN argument is a wildcard pattern.
139*fae548d3Szrj Although backslashes are treated specially if a pattern contains
140*fae548d3Szrj wildcards, we do not consider the mere presence of a backslash to
141*fae548d3Szrj be enough to cause the pattern to be treated as a wildcard.
142*fae548d3Szrj That lets us handle DOS filenames more naturally. */
143*fae548d3Szrj #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
144*fae548d3Szrj
145*fae548d3Szrj #define new_stat(x, y) \
146*fae548d3Szrj (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
147*fae548d3Szrj
148*fae548d3Szrj #define outside_section_address(q) \
149*fae548d3Szrj ((q)->output_offset + (q)->output_section->vma)
150*fae548d3Szrj
151*fae548d3Szrj #define outside_symbol_address(q) \
152*fae548d3Szrj ((q)->value + outside_section_address (q->section))
153*fae548d3Szrj
154*fae548d3Szrj #define SECTION_NAME_MAP_LENGTH (16)
155*fae548d3Szrj
156*fae548d3Szrj /* CTF sections smaller than this are not compressed: compression of
157*fae548d3Szrj dictionaries this small doesn't gain much, and this lets consumers mmap the
158*fae548d3Szrj sections directly out of the ELF file and use them with no decompression
159*fae548d3Szrj overhead if they want to. */
160*fae548d3Szrj #define CTF_COMPRESSION_THRESHOLD 4096
161*fae548d3Szrj
162*fae548d3Szrj void *
stat_alloc(size_t size)163*fae548d3Szrj stat_alloc (size_t size)
164*fae548d3Szrj {
165*fae548d3Szrj return obstack_alloc (&stat_obstack, size);
166*fae548d3Szrj }
167*fae548d3Szrj
168*fae548d3Szrj static int
name_match(const char * pattern,const char * name)169*fae548d3Szrj name_match (const char *pattern, const char *name)
170*fae548d3Szrj {
171*fae548d3Szrj if (wildcardp (pattern))
172*fae548d3Szrj return fnmatch (pattern, name, 0);
173*fae548d3Szrj return strcmp (pattern, name);
174*fae548d3Szrj }
175*fae548d3Szrj
176*fae548d3Szrj /* If PATTERN is of the form archive:file, return a pointer to the
177*fae548d3Szrj separator. If not, return NULL. */
178*fae548d3Szrj
179*fae548d3Szrj static char *
archive_path(const char * pattern)180*fae548d3Szrj archive_path (const char *pattern)
181*fae548d3Szrj {
182*fae548d3Szrj char *p = NULL;
183*fae548d3Szrj
184*fae548d3Szrj if (link_info.path_separator == 0)
185*fae548d3Szrj return p;
186*fae548d3Szrj
187*fae548d3Szrj p = strchr (pattern, link_info.path_separator);
188*fae548d3Szrj #ifdef HAVE_DOS_BASED_FILE_SYSTEM
189*fae548d3Szrj if (p == NULL || link_info.path_separator != ':')
190*fae548d3Szrj return p;
191*fae548d3Szrj
192*fae548d3Szrj /* Assume a match on the second char is part of drive specifier,
193*fae548d3Szrj as in "c:\silly.dos". */
194*fae548d3Szrj if (p == pattern + 1 && ISALPHA (*pattern))
195*fae548d3Szrj p = strchr (p + 1, link_info.path_separator);
196*fae548d3Szrj #endif
197*fae548d3Szrj return p;
198*fae548d3Szrj }
199*fae548d3Szrj
200*fae548d3Szrj /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
201*fae548d3Szrj return whether F matches FILE_SPEC. */
202*fae548d3Szrj
203*fae548d3Szrj static bfd_boolean
input_statement_is_archive_path(const char * file_spec,char * sep,lang_input_statement_type * f)204*fae548d3Szrj input_statement_is_archive_path (const char *file_spec, char *sep,
205*fae548d3Szrj lang_input_statement_type *f)
206*fae548d3Szrj {
207*fae548d3Szrj bfd_boolean match = FALSE;
208*fae548d3Szrj
209*fae548d3Szrj if ((*(sep + 1) == 0
210*fae548d3Szrj || name_match (sep + 1, f->filename) == 0)
211*fae548d3Szrj && ((sep != file_spec)
212*fae548d3Szrj == (f->the_bfd != NULL && f->the_bfd->my_archive != NULL)))
213*fae548d3Szrj {
214*fae548d3Szrj match = TRUE;
215*fae548d3Szrj
216*fae548d3Szrj if (sep != file_spec)
217*fae548d3Szrj {
218*fae548d3Szrj const char *aname = f->the_bfd->my_archive->filename;
219*fae548d3Szrj *sep = 0;
220*fae548d3Szrj match = name_match (file_spec, aname) == 0;
221*fae548d3Szrj *sep = link_info.path_separator;
222*fae548d3Szrj }
223*fae548d3Szrj }
224*fae548d3Szrj return match;
225*fae548d3Szrj }
226*fae548d3Szrj
227*fae548d3Szrj static bfd_boolean
unique_section_p(const asection * sec,const lang_output_section_statement_type * os)228*fae548d3Szrj unique_section_p (const asection *sec,
229*fae548d3Szrj const lang_output_section_statement_type *os)
230*fae548d3Szrj {
231*fae548d3Szrj struct unique_sections *unam;
232*fae548d3Szrj const char *secnam;
233*fae548d3Szrj
234*fae548d3Szrj if (!link_info.resolve_section_groups
235*fae548d3Szrj && sec->owner != NULL
236*fae548d3Szrj && bfd_is_group_section (sec->owner, sec))
237*fae548d3Szrj return !(os != NULL
238*fae548d3Szrj && strcmp (os->name, DISCARD_SECTION_NAME) == 0);
239*fae548d3Szrj
240*fae548d3Szrj secnam = sec->name;
241*fae548d3Szrj for (unam = unique_section_list; unam; unam = unam->next)
242*fae548d3Szrj if (name_match (unam->name, secnam) == 0)
243*fae548d3Szrj return TRUE;
244*fae548d3Szrj
245*fae548d3Szrj return FALSE;
246*fae548d3Szrj }
247*fae548d3Szrj
248*fae548d3Szrj /* Generic traversal routines for finding matching sections. */
249*fae548d3Szrj
250*fae548d3Szrj /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
251*fae548d3Szrj false. */
252*fae548d3Szrj
253*fae548d3Szrj static bfd_boolean
walk_wild_file_in_exclude_list(struct name_list * exclude_list,lang_input_statement_type * file)254*fae548d3Szrj walk_wild_file_in_exclude_list (struct name_list *exclude_list,
255*fae548d3Szrj lang_input_statement_type *file)
256*fae548d3Szrj {
257*fae548d3Szrj struct name_list *list_tmp;
258*fae548d3Szrj
259*fae548d3Szrj for (list_tmp = exclude_list;
260*fae548d3Szrj list_tmp;
261*fae548d3Szrj list_tmp = list_tmp->next)
262*fae548d3Szrj {
263*fae548d3Szrj char *p = archive_path (list_tmp->name);
264*fae548d3Szrj
265*fae548d3Szrj if (p != NULL)
266*fae548d3Szrj {
267*fae548d3Szrj if (input_statement_is_archive_path (list_tmp->name, p, file))
268*fae548d3Szrj return TRUE;
269*fae548d3Szrj }
270*fae548d3Szrj
271*fae548d3Szrj else if (name_match (list_tmp->name, file->filename) == 0)
272*fae548d3Szrj return TRUE;
273*fae548d3Szrj
274*fae548d3Szrj /* FIXME: Perhaps remove the following at some stage? Matching
275*fae548d3Szrj unadorned archives like this was never documented and has
276*fae548d3Szrj been superceded by the archive:path syntax. */
277*fae548d3Szrj else if (file->the_bfd != NULL
278*fae548d3Szrj && file->the_bfd->my_archive != NULL
279*fae548d3Szrj && name_match (list_tmp->name,
280*fae548d3Szrj file->the_bfd->my_archive->filename) == 0)
281*fae548d3Szrj return TRUE;
282*fae548d3Szrj }
283*fae548d3Szrj
284*fae548d3Szrj return FALSE;
285*fae548d3Szrj }
286*fae548d3Szrj
287*fae548d3Szrj /* Try processing a section against a wildcard. This just calls
288*fae548d3Szrj the callback unless the filename exclusion list is present
289*fae548d3Szrj and excludes the file. It's hardly ever present so this
290*fae548d3Szrj function is very fast. */
291*fae548d3Szrj
292*fae548d3Szrj static void
walk_wild_consider_section(lang_wild_statement_type * ptr,lang_input_statement_type * file,asection * s,struct wildcard_list * sec,callback_t callback,void * data)293*fae548d3Szrj walk_wild_consider_section (lang_wild_statement_type *ptr,
294*fae548d3Szrj lang_input_statement_type *file,
295*fae548d3Szrj asection *s,
296*fae548d3Szrj struct wildcard_list *sec,
297*fae548d3Szrj callback_t callback,
298*fae548d3Szrj void *data)
299*fae548d3Szrj {
300*fae548d3Szrj /* Don't process sections from files which were excluded. */
301*fae548d3Szrj if (walk_wild_file_in_exclude_list (sec->spec.exclude_name_list, file))
302*fae548d3Szrj return;
303*fae548d3Szrj
304*fae548d3Szrj (*callback) (ptr, sec, s, ptr->section_flag_list, file, data);
305*fae548d3Szrj }
306*fae548d3Szrj
307*fae548d3Szrj /* Lowest common denominator routine that can handle everything correctly,
308*fae548d3Szrj but slowly. */
309*fae548d3Szrj
310*fae548d3Szrj static void
walk_wild_section_general(lang_wild_statement_type * ptr,lang_input_statement_type * file,callback_t callback,void * data)311*fae548d3Szrj walk_wild_section_general (lang_wild_statement_type *ptr,
312*fae548d3Szrj lang_input_statement_type *file,
313*fae548d3Szrj callback_t callback,
314*fae548d3Szrj void *data)
315*fae548d3Szrj {
316*fae548d3Szrj asection *s;
317*fae548d3Szrj struct wildcard_list *sec;
318*fae548d3Szrj
319*fae548d3Szrj for (s = file->the_bfd->sections; s != NULL; s = s->next)
320*fae548d3Szrj {
321*fae548d3Szrj sec = ptr->section_list;
322*fae548d3Szrj if (sec == NULL)
323*fae548d3Szrj (*callback) (ptr, sec, s, ptr->section_flag_list, file, data);
324*fae548d3Szrj
325*fae548d3Szrj while (sec != NULL)
326*fae548d3Szrj {
327*fae548d3Szrj bfd_boolean skip = FALSE;
328*fae548d3Szrj
329*fae548d3Szrj if (sec->spec.name != NULL)
330*fae548d3Szrj {
331*fae548d3Szrj const char *sname = bfd_section_name (s);
332*fae548d3Szrj
333*fae548d3Szrj skip = name_match (sec->spec.name, sname) != 0;
334*fae548d3Szrj }
335*fae548d3Szrj
336*fae548d3Szrj if (!skip)
337*fae548d3Szrj walk_wild_consider_section (ptr, file, s, sec, callback, data);
338*fae548d3Szrj
339*fae548d3Szrj sec = sec->next;
340*fae548d3Szrj }
341*fae548d3Szrj }
342*fae548d3Szrj }
343*fae548d3Szrj
344*fae548d3Szrj /* Routines to find a single section given its name. If there's more
345*fae548d3Szrj than one section with that name, we report that. */
346*fae548d3Szrj
347*fae548d3Szrj typedef struct
348*fae548d3Szrj {
349*fae548d3Szrj asection *found_section;
350*fae548d3Szrj bfd_boolean multiple_sections_found;
351*fae548d3Szrj } section_iterator_callback_data;
352*fae548d3Szrj
353*fae548d3Szrj static bfd_boolean
section_iterator_callback(bfd * abfd ATTRIBUTE_UNUSED,asection * s,void * data)354*fae548d3Szrj section_iterator_callback (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *data)
355*fae548d3Szrj {
356*fae548d3Szrj section_iterator_callback_data *d = (section_iterator_callback_data *) data;
357*fae548d3Szrj
358*fae548d3Szrj if (d->found_section != NULL)
359*fae548d3Szrj {
360*fae548d3Szrj d->multiple_sections_found = TRUE;
361*fae548d3Szrj return TRUE;
362*fae548d3Szrj }
363*fae548d3Szrj
364*fae548d3Szrj d->found_section = s;
365*fae548d3Szrj return FALSE;
366*fae548d3Szrj }
367*fae548d3Szrj
368*fae548d3Szrj static asection *
find_section(lang_input_statement_type * file,struct wildcard_list * sec,bfd_boolean * multiple_sections_found)369*fae548d3Szrj find_section (lang_input_statement_type *file,
370*fae548d3Szrj struct wildcard_list *sec,
371*fae548d3Szrj bfd_boolean *multiple_sections_found)
372*fae548d3Szrj {
373*fae548d3Szrj section_iterator_callback_data cb_data = { NULL, FALSE };
374*fae548d3Szrj
375*fae548d3Szrj bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
376*fae548d3Szrj section_iterator_callback, &cb_data);
377*fae548d3Szrj *multiple_sections_found = cb_data.multiple_sections_found;
378*fae548d3Szrj return cb_data.found_section;
379*fae548d3Szrj }
380*fae548d3Szrj
381*fae548d3Szrj /* Code for handling simple wildcards without going through fnmatch,
382*fae548d3Szrj which can be expensive because of charset translations etc. */
383*fae548d3Szrj
384*fae548d3Szrj /* A simple wild is a literal string followed by a single '*',
385*fae548d3Szrj where the literal part is at least 4 characters long. */
386*fae548d3Szrj
387*fae548d3Szrj static bfd_boolean
is_simple_wild(const char * name)388*fae548d3Szrj is_simple_wild (const char *name)
389*fae548d3Szrj {
390*fae548d3Szrj size_t len = strcspn (name, "*?[");
391*fae548d3Szrj return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
392*fae548d3Szrj }
393*fae548d3Szrj
394*fae548d3Szrj static bfd_boolean
match_simple_wild(const char * pattern,const char * name)395*fae548d3Szrj match_simple_wild (const char *pattern, const char *name)
396*fae548d3Szrj {
397*fae548d3Szrj /* The first four characters of the pattern are guaranteed valid
398*fae548d3Szrj non-wildcard characters. So we can go faster. */
399*fae548d3Szrj if (pattern[0] != name[0] || pattern[1] != name[1]
400*fae548d3Szrj || pattern[2] != name[2] || pattern[3] != name[3])
401*fae548d3Szrj return FALSE;
402*fae548d3Szrj
403*fae548d3Szrj pattern += 4;
404*fae548d3Szrj name += 4;
405*fae548d3Szrj while (*pattern != '*')
406*fae548d3Szrj if (*name++ != *pattern++)
407*fae548d3Szrj return FALSE;
408*fae548d3Szrj
409*fae548d3Szrj return TRUE;
410*fae548d3Szrj }
411*fae548d3Szrj
412*fae548d3Szrj /* Return the numerical value of the init_priority attribute from
413*fae548d3Szrj section name NAME. */
414*fae548d3Szrj
415*fae548d3Szrj static int
get_init_priority(const asection * sec)416*fae548d3Szrj get_init_priority (const asection *sec)
417*fae548d3Szrj {
418*fae548d3Szrj const char *name = bfd_section_name (sec);
419*fae548d3Szrj const char *dot;
420*fae548d3Szrj
421*fae548d3Szrj /* GCC uses the following section names for the init_priority
422*fae548d3Szrj attribute with numerical values 101 to 65535 inclusive. A
423*fae548d3Szrj lower value means a higher priority.
424*fae548d3Szrj
425*fae548d3Szrj 1: .init_array.NNNNN/.fini_array.NNNNN: Where NNNNN is the
426*fae548d3Szrj decimal numerical value of the init_priority attribute.
427*fae548d3Szrj The order of execution in .init_array is forward and
428*fae548d3Szrj .fini_array is backward.
429*fae548d3Szrj 2: .ctors.NNNNN/.dtors.NNNNN: Where NNNNN is 65535 minus the
430*fae548d3Szrj decimal numerical value of the init_priority attribute.
431*fae548d3Szrj The order of execution in .ctors is backward and .dtors
432*fae548d3Szrj is forward.
433*fae548d3Szrj
434*fae548d3Szrj .init_array.NNNNN sections would normally be placed in an output
435*fae548d3Szrj .init_array section, .fini_array.NNNNN in .fini_array,
436*fae548d3Szrj .ctors.NNNNN in .ctors, and .dtors.NNNNN in .dtors. This means
437*fae548d3Szrj we should sort by increasing number (and could just use
438*fae548d3Szrj SORT_BY_NAME in scripts). However if .ctors.NNNNN sections are
439*fae548d3Szrj being placed in .init_array (which may also contain
440*fae548d3Szrj .init_array.NNNNN sections) or .dtors.NNNNN sections are being
441*fae548d3Szrj placed in .fini_array then we need to extract the init_priority
442*fae548d3Szrj attribute and sort on that. */
443*fae548d3Szrj dot = strrchr (name, '.');
444*fae548d3Szrj if (dot != NULL && ISDIGIT (dot[1]))
445*fae548d3Szrj {
446*fae548d3Szrj char *end;
447*fae548d3Szrj unsigned long init_priority = strtoul (dot + 1, &end, 10);
448*fae548d3Szrj if (*end == 0)
449*fae548d3Szrj {
450*fae548d3Szrj if (dot == name + 6
451*fae548d3Szrj && (strncmp (name, ".ctors", 6) == 0
452*fae548d3Szrj || strncmp (name, ".dtors", 6) == 0))
453*fae548d3Szrj init_priority = 65535 - init_priority;
454*fae548d3Szrj if (init_priority <= INT_MAX)
455*fae548d3Szrj return init_priority;
456*fae548d3Szrj }
457*fae548d3Szrj }
458*fae548d3Szrj return -1;
459*fae548d3Szrj }
460*fae548d3Szrj
461*fae548d3Szrj /* Compare sections ASEC and BSEC according to SORT. */
462*fae548d3Szrj
463*fae548d3Szrj static int
compare_section(sort_type sort,asection * asec,asection * bsec)464*fae548d3Szrj compare_section (sort_type sort, asection *asec, asection *bsec)
465*fae548d3Szrj {
466*fae548d3Szrj int ret;
467*fae548d3Szrj int a_priority, b_priority;
468*fae548d3Szrj
469*fae548d3Szrj switch (sort)
470*fae548d3Szrj {
471*fae548d3Szrj default:
472*fae548d3Szrj abort ();
473*fae548d3Szrj
474*fae548d3Szrj case by_init_priority:
475*fae548d3Szrj a_priority = get_init_priority (asec);
476*fae548d3Szrj b_priority = get_init_priority (bsec);
477*fae548d3Szrj if (a_priority < 0 || b_priority < 0)
478*fae548d3Szrj goto sort_by_name;
479*fae548d3Szrj ret = a_priority - b_priority;
480*fae548d3Szrj if (ret)
481*fae548d3Szrj break;
482*fae548d3Szrj else
483*fae548d3Szrj goto sort_by_name;
484*fae548d3Szrj
485*fae548d3Szrj case by_alignment_name:
486*fae548d3Szrj ret = bfd_section_alignment (bsec) - bfd_section_alignment (asec);
487*fae548d3Szrj if (ret)
488*fae548d3Szrj break;
489*fae548d3Szrj /* Fall through. */
490*fae548d3Szrj
491*fae548d3Szrj case by_name:
492*fae548d3Szrj sort_by_name:
493*fae548d3Szrj ret = strcmp (bfd_section_name (asec), bfd_section_name (bsec));
494*fae548d3Szrj break;
495*fae548d3Szrj
496*fae548d3Szrj case by_name_alignment:
497*fae548d3Szrj ret = strcmp (bfd_section_name (asec), bfd_section_name (bsec));
498*fae548d3Szrj if (ret)
499*fae548d3Szrj break;
500*fae548d3Szrj /* Fall through. */
501*fae548d3Szrj
502*fae548d3Szrj case by_alignment:
503*fae548d3Szrj ret = bfd_section_alignment (bsec) - bfd_section_alignment (asec);
504*fae548d3Szrj break;
505*fae548d3Szrj }
506*fae548d3Szrj
507*fae548d3Szrj return ret;
508*fae548d3Szrj }
509*fae548d3Szrj
510*fae548d3Szrj /* Build a Binary Search Tree to sort sections, unlike insertion sort
511*fae548d3Szrj used in wild_sort(). BST is considerably faster if the number of
512*fae548d3Szrj of sections are large. */
513*fae548d3Szrj
514*fae548d3Szrj static lang_section_bst_type **
wild_sort_fast(lang_wild_statement_type * wild,struct wildcard_list * sec,lang_input_statement_type * file ATTRIBUTE_UNUSED,asection * section)515*fae548d3Szrj wild_sort_fast (lang_wild_statement_type *wild,
516*fae548d3Szrj struct wildcard_list *sec,
517*fae548d3Szrj lang_input_statement_type *file ATTRIBUTE_UNUSED,
518*fae548d3Szrj asection *section)
519*fae548d3Szrj {
520*fae548d3Szrj lang_section_bst_type **tree;
521*fae548d3Szrj
522*fae548d3Szrj tree = &wild->tree;
523*fae548d3Szrj if (!wild->filenames_sorted
524*fae548d3Szrj && (sec == NULL || sec->spec.sorted == none))
525*fae548d3Szrj {
526*fae548d3Szrj /* Append at the right end of tree. */
527*fae548d3Szrj while (*tree)
528*fae548d3Szrj tree = &((*tree)->right);
529*fae548d3Szrj return tree;
530*fae548d3Szrj }
531*fae548d3Szrj
532*fae548d3Szrj while (*tree)
533*fae548d3Szrj {
534*fae548d3Szrj /* Find the correct node to append this section. */
535*fae548d3Szrj if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
536*fae548d3Szrj tree = &((*tree)->left);
537*fae548d3Szrj else
538*fae548d3Szrj tree = &((*tree)->right);
539*fae548d3Szrj }
540*fae548d3Szrj
541*fae548d3Szrj return tree;
542*fae548d3Szrj }
543*fae548d3Szrj
544*fae548d3Szrj /* Use wild_sort_fast to build a BST to sort sections. */
545*fae548d3Szrj
546*fae548d3Szrj static void
output_section_callback_fast(lang_wild_statement_type * ptr,struct wildcard_list * sec,asection * section,struct flag_info * sflag_list ATTRIBUTE_UNUSED,lang_input_statement_type * file,void * output)547*fae548d3Szrj output_section_callback_fast (lang_wild_statement_type *ptr,
548*fae548d3Szrj struct wildcard_list *sec,
549*fae548d3Szrj asection *section,
550*fae548d3Szrj struct flag_info *sflag_list ATTRIBUTE_UNUSED,
551*fae548d3Szrj lang_input_statement_type *file,
552*fae548d3Szrj void *output)
553*fae548d3Szrj {
554*fae548d3Szrj lang_section_bst_type *node;
555*fae548d3Szrj lang_section_bst_type **tree;
556*fae548d3Szrj lang_output_section_statement_type *os;
557*fae548d3Szrj
558*fae548d3Szrj os = (lang_output_section_statement_type *) output;
559*fae548d3Szrj
560*fae548d3Szrj if (unique_section_p (section, os))
561*fae548d3Szrj return;
562*fae548d3Szrj
563*fae548d3Szrj node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type));
564*fae548d3Szrj node->left = 0;
565*fae548d3Szrj node->right = 0;
566*fae548d3Szrj node->section = section;
567*fae548d3Szrj
568*fae548d3Szrj tree = wild_sort_fast (ptr, sec, file, section);
569*fae548d3Szrj if (tree != NULL)
570*fae548d3Szrj *tree = node;
571*fae548d3Szrj }
572*fae548d3Szrj
573*fae548d3Szrj /* Convert a sorted sections' BST back to list form. */
574*fae548d3Szrj
575*fae548d3Szrj static void
output_section_callback_tree_to_list(lang_wild_statement_type * ptr,lang_section_bst_type * tree,void * output)576*fae548d3Szrj output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
577*fae548d3Szrj lang_section_bst_type *tree,
578*fae548d3Szrj void *output)
579*fae548d3Szrj {
580*fae548d3Szrj if (tree->left)
581*fae548d3Szrj output_section_callback_tree_to_list (ptr, tree->left, output);
582*fae548d3Szrj
583*fae548d3Szrj lang_add_section (&ptr->children, tree->section, NULL,
584*fae548d3Szrj (lang_output_section_statement_type *) output);
585*fae548d3Szrj
586*fae548d3Szrj if (tree->right)
587*fae548d3Szrj output_section_callback_tree_to_list (ptr, tree->right, output);
588*fae548d3Szrj
589*fae548d3Szrj free (tree);
590*fae548d3Szrj }
591*fae548d3Szrj
592*fae548d3Szrj /* Specialized, optimized routines for handling different kinds of
593*fae548d3Szrj wildcards */
594*fae548d3Szrj
595*fae548d3Szrj static void
walk_wild_section_specs1_wild0(lang_wild_statement_type * ptr,lang_input_statement_type * file,callback_t callback,void * data)596*fae548d3Szrj walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
597*fae548d3Szrj lang_input_statement_type *file,
598*fae548d3Szrj callback_t callback,
599*fae548d3Szrj void *data)
600*fae548d3Szrj {
601*fae548d3Szrj /* We can just do a hash lookup for the section with the right name.
602*fae548d3Szrj But if that lookup discovers more than one section with the name
603*fae548d3Szrj (should be rare), we fall back to the general algorithm because
604*fae548d3Szrj we would otherwise have to sort the sections to make sure they
605*fae548d3Szrj get processed in the bfd's order. */
606*fae548d3Szrj bfd_boolean multiple_sections_found;
607*fae548d3Szrj struct wildcard_list *sec0 = ptr->handler_data[0];
608*fae548d3Szrj asection *s0 = find_section (file, sec0, &multiple_sections_found);
609*fae548d3Szrj
610*fae548d3Szrj if (multiple_sections_found)
611*fae548d3Szrj walk_wild_section_general (ptr, file, callback, data);
612*fae548d3Szrj else if (s0)
613*fae548d3Szrj walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
614*fae548d3Szrj }
615*fae548d3Szrj
616*fae548d3Szrj static void
walk_wild_section_specs1_wild1(lang_wild_statement_type * ptr,lang_input_statement_type * file,callback_t callback,void * data)617*fae548d3Szrj walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
618*fae548d3Szrj lang_input_statement_type *file,
619*fae548d3Szrj callback_t callback,
620*fae548d3Szrj void *data)
621*fae548d3Szrj {
622*fae548d3Szrj asection *s;
623*fae548d3Szrj struct wildcard_list *wildsec0 = ptr->handler_data[0];
624*fae548d3Szrj
625*fae548d3Szrj for (s = file->the_bfd->sections; s != NULL; s = s->next)
626*fae548d3Szrj {
627*fae548d3Szrj const char *sname = bfd_section_name (s);
628*fae548d3Szrj bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
629*fae548d3Szrj
630*fae548d3Szrj if (!skip)
631*fae548d3Szrj walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
632*fae548d3Szrj }
633*fae548d3Szrj }
634*fae548d3Szrj
635*fae548d3Szrj static void
walk_wild_section_specs2_wild1(lang_wild_statement_type * ptr,lang_input_statement_type * file,callback_t callback,void * data)636*fae548d3Szrj walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
637*fae548d3Szrj lang_input_statement_type *file,
638*fae548d3Szrj callback_t callback,
639*fae548d3Szrj void *data)
640*fae548d3Szrj {
641*fae548d3Szrj asection *s;
642*fae548d3Szrj struct wildcard_list *sec0 = ptr->handler_data[0];
643*fae548d3Szrj struct wildcard_list *wildsec1 = ptr->handler_data[1];
644*fae548d3Szrj bfd_boolean multiple_sections_found;
645*fae548d3Szrj asection *s0 = find_section (file, sec0, &multiple_sections_found);
646*fae548d3Szrj
647*fae548d3Szrj if (multiple_sections_found)
648*fae548d3Szrj {
649*fae548d3Szrj walk_wild_section_general (ptr, file, callback, data);
650*fae548d3Szrj return;
651*fae548d3Szrj }
652*fae548d3Szrj
653*fae548d3Szrj /* Note that if the section was not found, s0 is NULL and
654*fae548d3Szrj we'll simply never succeed the s == s0 test below. */
655*fae548d3Szrj for (s = file->the_bfd->sections; s != NULL; s = s->next)
656*fae548d3Szrj {
657*fae548d3Szrj /* Recall that in this code path, a section cannot satisfy more
658*fae548d3Szrj than one spec, so if s == s0 then it cannot match
659*fae548d3Szrj wildspec1. */
660*fae548d3Szrj if (s == s0)
661*fae548d3Szrj walk_wild_consider_section (ptr, file, s, sec0, callback, data);
662*fae548d3Szrj else
663*fae548d3Szrj {
664*fae548d3Szrj const char *sname = bfd_section_name (s);
665*fae548d3Szrj bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
666*fae548d3Szrj
667*fae548d3Szrj if (!skip)
668*fae548d3Szrj walk_wild_consider_section (ptr, file, s, wildsec1, callback,
669*fae548d3Szrj data);
670*fae548d3Szrj }
671*fae548d3Szrj }
672*fae548d3Szrj }
673*fae548d3Szrj
674*fae548d3Szrj static void
walk_wild_section_specs3_wild2(lang_wild_statement_type * ptr,lang_input_statement_type * file,callback_t callback,void * data)675*fae548d3Szrj walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
676*fae548d3Szrj lang_input_statement_type *file,
677*fae548d3Szrj callback_t callback,
678*fae548d3Szrj void *data)
679*fae548d3Szrj {
680*fae548d3Szrj asection *s;
681*fae548d3Szrj struct wildcard_list *sec0 = ptr->handler_data[0];
682*fae548d3Szrj struct wildcard_list *wildsec1 = ptr->handler_data[1];
683*fae548d3Szrj struct wildcard_list *wildsec2 = ptr->handler_data[2];
684*fae548d3Szrj bfd_boolean multiple_sections_found;
685*fae548d3Szrj asection *s0 = find_section (file, sec0, &multiple_sections_found);
686*fae548d3Szrj
687*fae548d3Szrj if (multiple_sections_found)
688*fae548d3Szrj {
689*fae548d3Szrj walk_wild_section_general (ptr, file, callback, data);
690*fae548d3Szrj return;
691*fae548d3Szrj }
692*fae548d3Szrj
693*fae548d3Szrj for (s = file->the_bfd->sections; s != NULL; s = s->next)
694*fae548d3Szrj {
695*fae548d3Szrj if (s == s0)
696*fae548d3Szrj walk_wild_consider_section (ptr, file, s, sec0, callback, data);
697*fae548d3Szrj else
698*fae548d3Szrj {
699*fae548d3Szrj const char *sname = bfd_section_name (s);
700*fae548d3Szrj bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
701*fae548d3Szrj
702*fae548d3Szrj if (!skip)
703*fae548d3Szrj walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
704*fae548d3Szrj else
705*fae548d3Szrj {
706*fae548d3Szrj skip = !match_simple_wild (wildsec2->spec.name, sname);
707*fae548d3Szrj if (!skip)
708*fae548d3Szrj walk_wild_consider_section (ptr, file, s, wildsec2, callback,
709*fae548d3Szrj data);
710*fae548d3Szrj }
711*fae548d3Szrj }
712*fae548d3Szrj }
713*fae548d3Szrj }
714*fae548d3Szrj
715*fae548d3Szrj static void
walk_wild_section_specs4_wild2(lang_wild_statement_type * ptr,lang_input_statement_type * file,callback_t callback,void * data)716*fae548d3Szrj walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
717*fae548d3Szrj lang_input_statement_type *file,
718*fae548d3Szrj callback_t callback,
719*fae548d3Szrj void *data)
720*fae548d3Szrj {
721*fae548d3Szrj asection *s;
722*fae548d3Szrj struct wildcard_list *sec0 = ptr->handler_data[0];
723*fae548d3Szrj struct wildcard_list *sec1 = ptr->handler_data[1];
724*fae548d3Szrj struct wildcard_list *wildsec2 = ptr->handler_data[2];
725*fae548d3Szrj struct wildcard_list *wildsec3 = ptr->handler_data[3];
726*fae548d3Szrj bfd_boolean multiple_sections_found;
727*fae548d3Szrj asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
728*fae548d3Szrj
729*fae548d3Szrj if (multiple_sections_found)
730*fae548d3Szrj {
731*fae548d3Szrj walk_wild_section_general (ptr, file, callback, data);
732*fae548d3Szrj return;
733*fae548d3Szrj }
734*fae548d3Szrj
735*fae548d3Szrj s1 = find_section (file, sec1, &multiple_sections_found);
736*fae548d3Szrj if (multiple_sections_found)
737*fae548d3Szrj {
738*fae548d3Szrj walk_wild_section_general (ptr, file, callback, data);
739*fae548d3Szrj return;
740*fae548d3Szrj }
741*fae548d3Szrj
742*fae548d3Szrj for (s = file->the_bfd->sections; s != NULL; s = s->next)
743*fae548d3Szrj {
744*fae548d3Szrj if (s == s0)
745*fae548d3Szrj walk_wild_consider_section (ptr, file, s, sec0, callback, data);
746*fae548d3Szrj else
747*fae548d3Szrj if (s == s1)
748*fae548d3Szrj walk_wild_consider_section (ptr, file, s, sec1, callback, data);
749*fae548d3Szrj else
750*fae548d3Szrj {
751*fae548d3Szrj const char *sname = bfd_section_name (s);
752*fae548d3Szrj bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
753*fae548d3Szrj sname);
754*fae548d3Szrj
755*fae548d3Szrj if (!skip)
756*fae548d3Szrj walk_wild_consider_section (ptr, file, s, wildsec2, callback,
757*fae548d3Szrj data);
758*fae548d3Szrj else
759*fae548d3Szrj {
760*fae548d3Szrj skip = !match_simple_wild (wildsec3->spec.name, sname);
761*fae548d3Szrj if (!skip)
762*fae548d3Szrj walk_wild_consider_section (ptr, file, s, wildsec3,
763*fae548d3Szrj callback, data);
764*fae548d3Szrj }
765*fae548d3Szrj }
766*fae548d3Szrj }
767*fae548d3Szrj }
768*fae548d3Szrj
769*fae548d3Szrj static void
walk_wild_section(lang_wild_statement_type * ptr,lang_input_statement_type * file,callback_t callback,void * data)770*fae548d3Szrj walk_wild_section (lang_wild_statement_type *ptr,
771*fae548d3Szrj lang_input_statement_type *file,
772*fae548d3Szrj callback_t callback,
773*fae548d3Szrj void *data)
774*fae548d3Szrj {
775*fae548d3Szrj if (file->flags.just_syms)
776*fae548d3Szrj return;
777*fae548d3Szrj
778*fae548d3Szrj (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
779*fae548d3Szrj }
780*fae548d3Szrj
781*fae548d3Szrj /* Returns TRUE when name1 is a wildcard spec that might match
782*fae548d3Szrj something name2 can match. We're conservative: we return FALSE
783*fae548d3Szrj only if the prefixes of name1 and name2 are different up to the
784*fae548d3Szrj first wildcard character. */
785*fae548d3Szrj
786*fae548d3Szrj static bfd_boolean
wild_spec_can_overlap(const char * name1,const char * name2)787*fae548d3Szrj wild_spec_can_overlap (const char *name1, const char *name2)
788*fae548d3Szrj {
789*fae548d3Szrj size_t prefix1_len = strcspn (name1, "?*[");
790*fae548d3Szrj size_t prefix2_len = strcspn (name2, "?*[");
791*fae548d3Szrj size_t min_prefix_len;
792*fae548d3Szrj
793*fae548d3Szrj /* Note that if there is no wildcard character, then we treat the
794*fae548d3Szrj terminating 0 as part of the prefix. Thus ".text" won't match
795*fae548d3Szrj ".text." or ".text.*", for example. */
796*fae548d3Szrj if (name1[prefix1_len] == '\0')
797*fae548d3Szrj prefix1_len++;
798*fae548d3Szrj if (name2[prefix2_len] == '\0')
799*fae548d3Szrj prefix2_len++;
800*fae548d3Szrj
801*fae548d3Szrj min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
802*fae548d3Szrj
803*fae548d3Szrj return memcmp (name1, name2, min_prefix_len) == 0;
804*fae548d3Szrj }
805*fae548d3Szrj
806*fae548d3Szrj /* Select specialized code to handle various kinds of wildcard
807*fae548d3Szrj statements. */
808*fae548d3Szrj
809*fae548d3Szrj static void
analyze_walk_wild_section_handler(lang_wild_statement_type * ptr)810*fae548d3Szrj analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
811*fae548d3Szrj {
812*fae548d3Szrj int sec_count = 0;
813*fae548d3Szrj int wild_name_count = 0;
814*fae548d3Szrj struct wildcard_list *sec;
815*fae548d3Szrj int signature;
816*fae548d3Szrj int data_counter;
817*fae548d3Szrj
818*fae548d3Szrj ptr->walk_wild_section_handler = walk_wild_section_general;
819*fae548d3Szrj ptr->handler_data[0] = NULL;
820*fae548d3Szrj ptr->handler_data[1] = NULL;
821*fae548d3Szrj ptr->handler_data[2] = NULL;
822*fae548d3Szrj ptr->handler_data[3] = NULL;
823*fae548d3Szrj ptr->tree = NULL;
824*fae548d3Szrj
825*fae548d3Szrj /* Count how many wildcard_specs there are, and how many of those
826*fae548d3Szrj actually use wildcards in the name. Also, bail out if any of the
827*fae548d3Szrj wildcard names are NULL. (Can this actually happen?
828*fae548d3Szrj walk_wild_section used to test for it.) And bail out if any
829*fae548d3Szrj of the wildcards are more complex than a simple string
830*fae548d3Szrj ending in a single '*'. */
831*fae548d3Szrj for (sec = ptr->section_list; sec != NULL; sec = sec->next)
832*fae548d3Szrj {
833*fae548d3Szrj ++sec_count;
834*fae548d3Szrj if (sec->spec.name == NULL)
835*fae548d3Szrj return;
836*fae548d3Szrj if (wildcardp (sec->spec.name))
837*fae548d3Szrj {
838*fae548d3Szrj ++wild_name_count;
839*fae548d3Szrj if (!is_simple_wild (sec->spec.name))
840*fae548d3Szrj return;
841*fae548d3Szrj }
842*fae548d3Szrj }
843*fae548d3Szrj
844*fae548d3Szrj /* The zero-spec case would be easy to optimize but it doesn't
845*fae548d3Szrj happen in practice. Likewise, more than 4 specs doesn't
846*fae548d3Szrj happen in practice. */
847*fae548d3Szrj if (sec_count == 0 || sec_count > 4)
848*fae548d3Szrj return;
849*fae548d3Szrj
850*fae548d3Szrj /* Check that no two specs can match the same section. */
851*fae548d3Szrj for (sec = ptr->section_list; sec != NULL; sec = sec->next)
852*fae548d3Szrj {
853*fae548d3Szrj struct wildcard_list *sec2;
854*fae548d3Szrj for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
855*fae548d3Szrj {
856*fae548d3Szrj if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
857*fae548d3Szrj return;
858*fae548d3Szrj }
859*fae548d3Szrj }
860*fae548d3Szrj
861*fae548d3Szrj signature = (sec_count << 8) + wild_name_count;
862*fae548d3Szrj switch (signature)
863*fae548d3Szrj {
864*fae548d3Szrj case 0x0100:
865*fae548d3Szrj ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
866*fae548d3Szrj break;
867*fae548d3Szrj case 0x0101:
868*fae548d3Szrj ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
869*fae548d3Szrj break;
870*fae548d3Szrj case 0x0201:
871*fae548d3Szrj ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
872*fae548d3Szrj break;
873*fae548d3Szrj case 0x0302:
874*fae548d3Szrj ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
875*fae548d3Szrj break;
876*fae548d3Szrj case 0x0402:
877*fae548d3Szrj ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
878*fae548d3Szrj break;
879*fae548d3Szrj default:
880*fae548d3Szrj return;
881*fae548d3Szrj }
882*fae548d3Szrj
883*fae548d3Szrj /* Now fill the data array with pointers to the specs, first the
884*fae548d3Szrj specs with non-wildcard names, then the specs with wildcard
885*fae548d3Szrj names. It's OK to process the specs in different order from the
886*fae548d3Szrj given order, because we've already determined that no section
887*fae548d3Szrj will match more than one spec. */
888*fae548d3Szrj data_counter = 0;
889*fae548d3Szrj for (sec = ptr->section_list; sec != NULL; sec = sec->next)
890*fae548d3Szrj if (!wildcardp (sec->spec.name))
891*fae548d3Szrj ptr->handler_data[data_counter++] = sec;
892*fae548d3Szrj for (sec = ptr->section_list; sec != NULL; sec = sec->next)
893*fae548d3Szrj if (wildcardp (sec->spec.name))
894*fae548d3Szrj ptr->handler_data[data_counter++] = sec;
895*fae548d3Szrj }
896*fae548d3Szrj
897*fae548d3Szrj /* Handle a wild statement for a single file F. */
898*fae548d3Szrj
899*fae548d3Szrj static void
walk_wild_file(lang_wild_statement_type * s,lang_input_statement_type * f,callback_t callback,void * data)900*fae548d3Szrj walk_wild_file (lang_wild_statement_type *s,
901*fae548d3Szrj lang_input_statement_type *f,
902*fae548d3Szrj callback_t callback,
903*fae548d3Szrj void *data)
904*fae548d3Szrj {
905*fae548d3Szrj if (walk_wild_file_in_exclude_list (s->exclude_name_list, f))
906*fae548d3Szrj return;
907*fae548d3Szrj
908*fae548d3Szrj if (f->the_bfd == NULL
909*fae548d3Szrj || !bfd_check_format (f->the_bfd, bfd_archive))
910*fae548d3Szrj walk_wild_section (s, f, callback, data);
911*fae548d3Szrj else
912*fae548d3Szrj {
913*fae548d3Szrj bfd *member;
914*fae548d3Szrj
915*fae548d3Szrj /* This is an archive file. We must map each member of the
916*fae548d3Szrj archive separately. */
917*fae548d3Szrj member = bfd_openr_next_archived_file (f->the_bfd, NULL);
918*fae548d3Szrj while (member != NULL)
919*fae548d3Szrj {
920*fae548d3Szrj /* When lookup_name is called, it will call the add_symbols
921*fae548d3Szrj entry point for the archive. For each element of the
922*fae548d3Szrj archive which is included, BFD will call ldlang_add_file,
923*fae548d3Szrj which will set the usrdata field of the member to the
924*fae548d3Szrj lang_input_statement. */
925*fae548d3Szrj if (bfd_usrdata (member) != NULL)
926*fae548d3Szrj walk_wild_section (s, bfd_usrdata (member), callback, data);
927*fae548d3Szrj
928*fae548d3Szrj member = bfd_openr_next_archived_file (f->the_bfd, member);
929*fae548d3Szrj }
930*fae548d3Szrj }
931*fae548d3Szrj }
932*fae548d3Szrj
933*fae548d3Szrj static void
walk_wild(lang_wild_statement_type * s,callback_t callback,void * data)934*fae548d3Szrj walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
935*fae548d3Szrj {
936*fae548d3Szrj const char *file_spec = s->filename;
937*fae548d3Szrj char *p;
938*fae548d3Szrj
939*fae548d3Szrj if (file_spec == NULL)
940*fae548d3Szrj {
941*fae548d3Szrj /* Perform the iteration over all files in the list. */
942*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (f)
943*fae548d3Szrj {
944*fae548d3Szrj walk_wild_file (s, f, callback, data);
945*fae548d3Szrj }
946*fae548d3Szrj }
947*fae548d3Szrj else if ((p = archive_path (file_spec)) != NULL)
948*fae548d3Szrj {
949*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (f)
950*fae548d3Szrj {
951*fae548d3Szrj if (input_statement_is_archive_path (file_spec, p, f))
952*fae548d3Szrj walk_wild_file (s, f, callback, data);
953*fae548d3Szrj }
954*fae548d3Szrj }
955*fae548d3Szrj else if (wildcardp (file_spec))
956*fae548d3Szrj {
957*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (f)
958*fae548d3Szrj {
959*fae548d3Szrj if (fnmatch (file_spec, f->filename, 0) == 0)
960*fae548d3Szrj walk_wild_file (s, f, callback, data);
961*fae548d3Szrj }
962*fae548d3Szrj }
963*fae548d3Szrj else
964*fae548d3Szrj {
965*fae548d3Szrj lang_input_statement_type *f;
966*fae548d3Szrj
967*fae548d3Szrj /* Perform the iteration over a single file. */
968*fae548d3Szrj f = lookup_name (file_spec);
969*fae548d3Szrj if (f)
970*fae548d3Szrj walk_wild_file (s, f, callback, data);
971*fae548d3Szrj }
972*fae548d3Szrj }
973*fae548d3Szrj
974*fae548d3Szrj /* lang_for_each_statement walks the parse tree and calls the provided
975*fae548d3Szrj function for each node, except those inside output section statements
976*fae548d3Szrj with constraint set to -1. */
977*fae548d3Szrj
978*fae548d3Szrj void
lang_for_each_statement_worker(void (* func)(lang_statement_union_type *),lang_statement_union_type * s)979*fae548d3Szrj lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
980*fae548d3Szrj lang_statement_union_type *s)
981*fae548d3Szrj {
982*fae548d3Szrj for (; s != NULL; s = s->header.next)
983*fae548d3Szrj {
984*fae548d3Szrj func (s);
985*fae548d3Szrj
986*fae548d3Szrj switch (s->header.type)
987*fae548d3Szrj {
988*fae548d3Szrj case lang_constructors_statement_enum:
989*fae548d3Szrj lang_for_each_statement_worker (func, constructor_list.head);
990*fae548d3Szrj break;
991*fae548d3Szrj case lang_output_section_statement_enum:
992*fae548d3Szrj if (s->output_section_statement.constraint != -1)
993*fae548d3Szrj lang_for_each_statement_worker
994*fae548d3Szrj (func, s->output_section_statement.children.head);
995*fae548d3Szrj break;
996*fae548d3Szrj case lang_wild_statement_enum:
997*fae548d3Szrj lang_for_each_statement_worker (func,
998*fae548d3Szrj s->wild_statement.children.head);
999*fae548d3Szrj break;
1000*fae548d3Szrj case lang_group_statement_enum:
1001*fae548d3Szrj lang_for_each_statement_worker (func,
1002*fae548d3Szrj s->group_statement.children.head);
1003*fae548d3Szrj break;
1004*fae548d3Szrj case lang_data_statement_enum:
1005*fae548d3Szrj case lang_reloc_statement_enum:
1006*fae548d3Szrj case lang_object_symbols_statement_enum:
1007*fae548d3Szrj case lang_output_statement_enum:
1008*fae548d3Szrj case lang_target_statement_enum:
1009*fae548d3Szrj case lang_input_section_enum:
1010*fae548d3Szrj case lang_input_statement_enum:
1011*fae548d3Szrj case lang_assignment_statement_enum:
1012*fae548d3Szrj case lang_padding_statement_enum:
1013*fae548d3Szrj case lang_address_statement_enum:
1014*fae548d3Szrj case lang_fill_statement_enum:
1015*fae548d3Szrj case lang_insert_statement_enum:
1016*fae548d3Szrj break;
1017*fae548d3Szrj default:
1018*fae548d3Szrj FAIL ();
1019*fae548d3Szrj break;
1020*fae548d3Szrj }
1021*fae548d3Szrj }
1022*fae548d3Szrj }
1023*fae548d3Szrj
1024*fae548d3Szrj void
lang_for_each_statement(void (* func)(lang_statement_union_type *))1025*fae548d3Szrj lang_for_each_statement (void (*func) (lang_statement_union_type *))
1026*fae548d3Szrj {
1027*fae548d3Szrj lang_for_each_statement_worker (func, statement_list.head);
1028*fae548d3Szrj }
1029*fae548d3Szrj
1030*fae548d3Szrj /*----------------------------------------------------------------------*/
1031*fae548d3Szrj
1032*fae548d3Szrj void
lang_list_init(lang_statement_list_type * list)1033*fae548d3Szrj lang_list_init (lang_statement_list_type *list)
1034*fae548d3Szrj {
1035*fae548d3Szrj list->head = NULL;
1036*fae548d3Szrj list->tail = &list->head;
1037*fae548d3Szrj }
1038*fae548d3Szrj
1039*fae548d3Szrj static void
lang_statement_append(lang_statement_list_type * list,void * element,void * field)1040*fae548d3Szrj lang_statement_append (lang_statement_list_type *list,
1041*fae548d3Szrj void *element,
1042*fae548d3Szrj void *field)
1043*fae548d3Szrj {
1044*fae548d3Szrj *(list->tail) = element;
1045*fae548d3Szrj list->tail = field;
1046*fae548d3Szrj }
1047*fae548d3Szrj
1048*fae548d3Szrj void
push_stat_ptr(lang_statement_list_type * new_ptr)1049*fae548d3Szrj push_stat_ptr (lang_statement_list_type *new_ptr)
1050*fae548d3Szrj {
1051*fae548d3Szrj if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))
1052*fae548d3Szrj abort ();
1053*fae548d3Szrj *stat_save_ptr++ = stat_ptr;
1054*fae548d3Szrj stat_ptr = new_ptr;
1055*fae548d3Szrj }
1056*fae548d3Szrj
1057*fae548d3Szrj void
pop_stat_ptr(void)1058*fae548d3Szrj pop_stat_ptr (void)
1059*fae548d3Szrj {
1060*fae548d3Szrj if (stat_save_ptr <= stat_save)
1061*fae548d3Szrj abort ();
1062*fae548d3Szrj stat_ptr = *--stat_save_ptr;
1063*fae548d3Szrj }
1064*fae548d3Szrj
1065*fae548d3Szrj /* Build a new statement node for the parse tree. */
1066*fae548d3Szrj
1067*fae548d3Szrj static lang_statement_union_type *
new_statement(enum statement_enum type,size_t size,lang_statement_list_type * list)1068*fae548d3Szrj new_statement (enum statement_enum type,
1069*fae548d3Szrj size_t size,
1070*fae548d3Szrj lang_statement_list_type *list)
1071*fae548d3Szrj {
1072*fae548d3Szrj lang_statement_union_type *new_stmt;
1073*fae548d3Szrj
1074*fae548d3Szrj new_stmt = stat_alloc (size);
1075*fae548d3Szrj new_stmt->header.type = type;
1076*fae548d3Szrj new_stmt->header.next = NULL;
1077*fae548d3Szrj lang_statement_append (list, new_stmt, &new_stmt->header.next);
1078*fae548d3Szrj return new_stmt;
1079*fae548d3Szrj }
1080*fae548d3Szrj
1081*fae548d3Szrj /* Build a new input file node for the language. There are several
1082*fae548d3Szrj ways in which we treat an input file, eg, we only look at symbols,
1083*fae548d3Szrj or prefix it with a -l etc.
1084*fae548d3Szrj
1085*fae548d3Szrj We can be supplied with requests for input files more than once;
1086*fae548d3Szrj they may, for example be split over several lines like foo.o(.text)
1087*fae548d3Szrj foo.o(.data) etc, so when asked for a file we check that we haven't
1088*fae548d3Szrj got it already so we don't duplicate the bfd. */
1089*fae548d3Szrj
1090*fae548d3Szrj static lang_input_statement_type *
new_afile(const char * name,lang_input_file_enum_type file_type,const char * target)1091*fae548d3Szrj new_afile (const char *name,
1092*fae548d3Szrj lang_input_file_enum_type file_type,
1093*fae548d3Szrj const char *target)
1094*fae548d3Szrj {
1095*fae548d3Szrj lang_input_statement_type *p;
1096*fae548d3Szrj
1097*fae548d3Szrj lang_has_input_file = TRUE;
1098*fae548d3Szrj
1099*fae548d3Szrj p = new_stat (lang_input_statement, stat_ptr);
1100*fae548d3Szrj memset (&p->the_bfd, 0,
1101*fae548d3Szrj sizeof (*p) - offsetof (lang_input_statement_type, the_bfd));
1102*fae548d3Szrj p->target = target;
1103*fae548d3Szrj p->flags.dynamic = input_flags.dynamic;
1104*fae548d3Szrj p->flags.add_DT_NEEDED_for_dynamic = input_flags.add_DT_NEEDED_for_dynamic;
1105*fae548d3Szrj p->flags.add_DT_NEEDED_for_regular = input_flags.add_DT_NEEDED_for_regular;
1106*fae548d3Szrj p->flags.whole_archive = input_flags.whole_archive;
1107*fae548d3Szrj p->flags.sysrooted = input_flags.sysrooted;
1108*fae548d3Szrj
1109*fae548d3Szrj switch (file_type)
1110*fae548d3Szrj {
1111*fae548d3Szrj case lang_input_file_is_symbols_only_enum:
1112*fae548d3Szrj p->filename = name;
1113*fae548d3Szrj p->local_sym_name = name;
1114*fae548d3Szrj p->flags.real = TRUE;
1115*fae548d3Szrj p->flags.just_syms = TRUE;
1116*fae548d3Szrj break;
1117*fae548d3Szrj case lang_input_file_is_fake_enum:
1118*fae548d3Szrj p->filename = name;
1119*fae548d3Szrj p->local_sym_name = name;
1120*fae548d3Szrj break;
1121*fae548d3Szrj case lang_input_file_is_l_enum:
1122*fae548d3Szrj if (name[0] == ':' && name[1] != '\0')
1123*fae548d3Szrj {
1124*fae548d3Szrj p->filename = name + 1;
1125*fae548d3Szrj p->flags.full_name_provided = TRUE;
1126*fae548d3Szrj }
1127*fae548d3Szrj else
1128*fae548d3Szrj p->filename = name;
1129*fae548d3Szrj p->local_sym_name = concat ("-l", name, (const char *) NULL);
1130*fae548d3Szrj p->flags.maybe_archive = TRUE;
1131*fae548d3Szrj p->flags.real = TRUE;
1132*fae548d3Szrj p->flags.search_dirs = TRUE;
1133*fae548d3Szrj break;
1134*fae548d3Szrj case lang_input_file_is_marker_enum:
1135*fae548d3Szrj p->filename = name;
1136*fae548d3Szrj p->local_sym_name = name;
1137*fae548d3Szrj p->flags.search_dirs = TRUE;
1138*fae548d3Szrj break;
1139*fae548d3Szrj case lang_input_file_is_search_file_enum:
1140*fae548d3Szrj p->filename = name;
1141*fae548d3Szrj p->local_sym_name = name;
1142*fae548d3Szrj p->flags.real = TRUE;
1143*fae548d3Szrj p->flags.search_dirs = TRUE;
1144*fae548d3Szrj break;
1145*fae548d3Szrj case lang_input_file_is_file_enum:
1146*fae548d3Szrj p->filename = name;
1147*fae548d3Szrj p->local_sym_name = name;
1148*fae548d3Szrj p->flags.real = TRUE;
1149*fae548d3Szrj break;
1150*fae548d3Szrj default:
1151*fae548d3Szrj FAIL ();
1152*fae548d3Szrj }
1153*fae548d3Szrj
1154*fae548d3Szrj lang_statement_append (&input_file_chain, p, &p->next_real_file);
1155*fae548d3Szrj return p;
1156*fae548d3Szrj }
1157*fae548d3Szrj
1158*fae548d3Szrj lang_input_statement_type *
lang_add_input_file(const char * name,lang_input_file_enum_type file_type,const char * target)1159*fae548d3Szrj lang_add_input_file (const char *name,
1160*fae548d3Szrj lang_input_file_enum_type file_type,
1161*fae548d3Szrj const char *target)
1162*fae548d3Szrj {
1163*fae548d3Szrj if (name != NULL
1164*fae548d3Szrj && (*name == '=' || CONST_STRNEQ (name, "$SYSROOT")))
1165*fae548d3Szrj {
1166*fae548d3Szrj lang_input_statement_type *ret;
1167*fae548d3Szrj char *sysrooted_name
1168*fae548d3Szrj = concat (ld_sysroot,
1169*fae548d3Szrj name + (*name == '=' ? 1 : strlen ("$SYSROOT")),
1170*fae548d3Szrj (const char *) NULL);
1171*fae548d3Szrj
1172*fae548d3Szrj /* We've now forcibly prepended the sysroot, making the input
1173*fae548d3Szrj file independent of the context. Therefore, temporarily
1174*fae548d3Szrj force a non-sysrooted context for this statement, so it won't
1175*fae548d3Szrj get the sysroot prepended again when opened. (N.B. if it's a
1176*fae548d3Szrj script, any child nodes with input files starting with "/"
1177*fae548d3Szrj will be handled as "sysrooted" as they'll be found to be
1178*fae548d3Szrj within the sysroot subdirectory.) */
1179*fae548d3Szrj unsigned int outer_sysrooted = input_flags.sysrooted;
1180*fae548d3Szrj input_flags.sysrooted = 0;
1181*fae548d3Szrj ret = new_afile (sysrooted_name, file_type, target);
1182*fae548d3Szrj input_flags.sysrooted = outer_sysrooted;
1183*fae548d3Szrj return ret;
1184*fae548d3Szrj }
1185*fae548d3Szrj
1186*fae548d3Szrj return new_afile (name, file_type, target);
1187*fae548d3Szrj }
1188*fae548d3Szrj
1189*fae548d3Szrj struct out_section_hash_entry
1190*fae548d3Szrj {
1191*fae548d3Szrj struct bfd_hash_entry root;
1192*fae548d3Szrj lang_statement_union_type s;
1193*fae548d3Szrj };
1194*fae548d3Szrj
1195*fae548d3Szrj /* The hash table. */
1196*fae548d3Szrj
1197*fae548d3Szrj static struct bfd_hash_table output_section_statement_table;
1198*fae548d3Szrj
1199*fae548d3Szrj /* Support routines for the hash table used by lang_output_section_find,
1200*fae548d3Szrj initialize the table, fill in an entry and remove the table. */
1201*fae548d3Szrj
1202*fae548d3Szrj static struct bfd_hash_entry *
output_section_statement_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)1203*fae548d3Szrj output_section_statement_newfunc (struct bfd_hash_entry *entry,
1204*fae548d3Szrj struct bfd_hash_table *table,
1205*fae548d3Szrj const char *string)
1206*fae548d3Szrj {
1207*fae548d3Szrj lang_output_section_statement_type **nextp;
1208*fae548d3Szrj struct out_section_hash_entry *ret;
1209*fae548d3Szrj
1210*fae548d3Szrj if (entry == NULL)
1211*fae548d3Szrj {
1212*fae548d3Szrj entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,
1213*fae548d3Szrj sizeof (*ret));
1214*fae548d3Szrj if (entry == NULL)
1215*fae548d3Szrj return entry;
1216*fae548d3Szrj }
1217*fae548d3Szrj
1218*fae548d3Szrj entry = bfd_hash_newfunc (entry, table, string);
1219*fae548d3Szrj if (entry == NULL)
1220*fae548d3Szrj return entry;
1221*fae548d3Szrj
1222*fae548d3Szrj ret = (struct out_section_hash_entry *) entry;
1223*fae548d3Szrj memset (&ret->s, 0, sizeof (ret->s));
1224*fae548d3Szrj ret->s.header.type = lang_output_section_statement_enum;
1225*fae548d3Szrj ret->s.output_section_statement.subsection_alignment = NULL;
1226*fae548d3Szrj ret->s.output_section_statement.section_alignment = NULL;
1227*fae548d3Szrj ret->s.output_section_statement.block_value = 1;
1228*fae548d3Szrj lang_list_init (&ret->s.output_section_statement.children);
1229*fae548d3Szrj lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1230*fae548d3Szrj
1231*fae548d3Szrj /* For every output section statement added to the list, except the
1232*fae548d3Szrj first one, lang_os_list.tail points to the "next"
1233*fae548d3Szrj field of the last element of the list. */
1234*fae548d3Szrj if (lang_os_list.head != NULL)
1235*fae548d3Szrj ret->s.output_section_statement.prev
1236*fae548d3Szrj = ((lang_output_section_statement_type *)
1237*fae548d3Szrj ((char *) lang_os_list.tail
1238*fae548d3Szrj - offsetof (lang_output_section_statement_type, next)));
1239*fae548d3Szrj
1240*fae548d3Szrj /* GCC's strict aliasing rules prevent us from just casting the
1241*fae548d3Szrj address, so we store the pointer in a variable and cast that
1242*fae548d3Szrj instead. */
1243*fae548d3Szrj nextp = &ret->s.output_section_statement.next;
1244*fae548d3Szrj lang_statement_append (&lang_os_list, &ret->s, nextp);
1245*fae548d3Szrj return &ret->root;
1246*fae548d3Szrj }
1247*fae548d3Szrj
1248*fae548d3Szrj static void
output_section_statement_table_init(void)1249*fae548d3Szrj output_section_statement_table_init (void)
1250*fae548d3Szrj {
1251*fae548d3Szrj if (!bfd_hash_table_init_n (&output_section_statement_table,
1252*fae548d3Szrj output_section_statement_newfunc,
1253*fae548d3Szrj sizeof (struct out_section_hash_entry),
1254*fae548d3Szrj 61))
1255*fae548d3Szrj einfo (_("%F%P: can not create hash table: %E\n"));
1256*fae548d3Szrj }
1257*fae548d3Szrj
1258*fae548d3Szrj static void
output_section_statement_table_free(void)1259*fae548d3Szrj output_section_statement_table_free (void)
1260*fae548d3Szrj {
1261*fae548d3Szrj bfd_hash_table_free (&output_section_statement_table);
1262*fae548d3Szrj }
1263*fae548d3Szrj
1264*fae548d3Szrj /* Build enough state so that the parser can build its tree. */
1265*fae548d3Szrj
1266*fae548d3Szrj void
lang_init(void)1267*fae548d3Szrj lang_init (void)
1268*fae548d3Szrj {
1269*fae548d3Szrj obstack_begin (&stat_obstack, 1000);
1270*fae548d3Szrj
1271*fae548d3Szrj stat_ptr = &statement_list;
1272*fae548d3Szrj
1273*fae548d3Szrj output_section_statement_table_init ();
1274*fae548d3Szrj
1275*fae548d3Szrj lang_list_init (stat_ptr);
1276*fae548d3Szrj
1277*fae548d3Szrj lang_list_init (&input_file_chain);
1278*fae548d3Szrj lang_list_init (&lang_os_list);
1279*fae548d3Szrj lang_list_init (&file_chain);
1280*fae548d3Szrj first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1281*fae548d3Szrj NULL);
1282*fae548d3Szrj abs_output_section =
1283*fae548d3Szrj lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);
1284*fae548d3Szrj
1285*fae548d3Szrj abs_output_section->bfd_section = bfd_abs_section_ptr;
1286*fae548d3Szrj
1287*fae548d3Szrj asneeded_list_head = NULL;
1288*fae548d3Szrj asneeded_list_tail = &asneeded_list_head;
1289*fae548d3Szrj }
1290*fae548d3Szrj
1291*fae548d3Szrj void
lang_finish(void)1292*fae548d3Szrj lang_finish (void)
1293*fae548d3Szrj {
1294*fae548d3Szrj output_section_statement_table_free ();
1295*fae548d3Szrj }
1296*fae548d3Szrj
1297*fae548d3Szrj /*----------------------------------------------------------------------
1298*fae548d3Szrj A region is an area of memory declared with the
1299*fae548d3Szrj MEMORY { name:org=exp, len=exp ... }
1300*fae548d3Szrj syntax.
1301*fae548d3Szrj
1302*fae548d3Szrj We maintain a list of all the regions here.
1303*fae548d3Szrj
1304*fae548d3Szrj If no regions are specified in the script, then the default is used
1305*fae548d3Szrj which is created when looked up to be the entire data space.
1306*fae548d3Szrj
1307*fae548d3Szrj If create is true we are creating a region inside a MEMORY block.
1308*fae548d3Szrj In this case it is probably an error to create a region that has
1309*fae548d3Szrj already been created. If we are not inside a MEMORY block it is
1310*fae548d3Szrj dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1311*fae548d3Szrj and so we issue a warning.
1312*fae548d3Szrj
1313*fae548d3Szrj Each region has at least one name. The first name is either
1314*fae548d3Szrj DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1315*fae548d3Szrj alias names to an existing region within a script with
1316*fae548d3Szrj REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1317*fae548d3Szrj region. */
1318*fae548d3Szrj
1319*fae548d3Szrj static lang_memory_region_type *lang_memory_region_list;
1320*fae548d3Szrj static lang_memory_region_type **lang_memory_region_list_tail
1321*fae548d3Szrj = &lang_memory_region_list;
1322*fae548d3Szrj
1323*fae548d3Szrj lang_memory_region_type *
lang_memory_region_lookup(const char * const name,bfd_boolean create)1324*fae548d3Szrj lang_memory_region_lookup (const char *const name, bfd_boolean create)
1325*fae548d3Szrj {
1326*fae548d3Szrj lang_memory_region_name *n;
1327*fae548d3Szrj lang_memory_region_type *r;
1328*fae548d3Szrj lang_memory_region_type *new_region;
1329*fae548d3Szrj
1330*fae548d3Szrj /* NAME is NULL for LMA memspecs if no region was specified. */
1331*fae548d3Szrj if (name == NULL)
1332*fae548d3Szrj return NULL;
1333*fae548d3Szrj
1334*fae548d3Szrj for (r = lang_memory_region_list; r != NULL; r = r->next)
1335*fae548d3Szrj for (n = &r->name_list; n != NULL; n = n->next)
1336*fae548d3Szrj if (strcmp (n->name, name) == 0)
1337*fae548d3Szrj {
1338*fae548d3Szrj if (create)
1339*fae548d3Szrj einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1340*fae548d3Szrj NULL, name);
1341*fae548d3Szrj return r;
1342*fae548d3Szrj }
1343*fae548d3Szrj
1344*fae548d3Szrj if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1345*fae548d3Szrj einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1346*fae548d3Szrj NULL, name);
1347*fae548d3Szrj
1348*fae548d3Szrj new_region = stat_alloc (sizeof (lang_memory_region_type));
1349*fae548d3Szrj
1350*fae548d3Szrj new_region->name_list.name = xstrdup (name);
1351*fae548d3Szrj new_region->name_list.next = NULL;
1352*fae548d3Szrj new_region->next = NULL;
1353*fae548d3Szrj new_region->origin_exp = NULL;
1354*fae548d3Szrj new_region->origin = 0;
1355*fae548d3Szrj new_region->length_exp = NULL;
1356*fae548d3Szrj new_region->length = ~(bfd_size_type) 0;
1357*fae548d3Szrj new_region->current = 0;
1358*fae548d3Szrj new_region->last_os = NULL;
1359*fae548d3Szrj new_region->flags = 0;
1360*fae548d3Szrj new_region->not_flags = 0;
1361*fae548d3Szrj new_region->had_full_message = FALSE;
1362*fae548d3Szrj
1363*fae548d3Szrj *lang_memory_region_list_tail = new_region;
1364*fae548d3Szrj lang_memory_region_list_tail = &new_region->next;
1365*fae548d3Szrj
1366*fae548d3Szrj return new_region;
1367*fae548d3Szrj }
1368*fae548d3Szrj
1369*fae548d3Szrj void
lang_memory_region_alias(const char * alias,const char * region_name)1370*fae548d3Szrj lang_memory_region_alias (const char *alias, const char *region_name)
1371*fae548d3Szrj {
1372*fae548d3Szrj lang_memory_region_name *n;
1373*fae548d3Szrj lang_memory_region_type *r;
1374*fae548d3Szrj lang_memory_region_type *region;
1375*fae548d3Szrj
1376*fae548d3Szrj /* The default region must be unique. This ensures that it is not necessary
1377*fae548d3Szrj to iterate through the name list if someone wants the check if a region is
1378*fae548d3Szrj the default memory region. */
1379*fae548d3Szrj if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0
1380*fae548d3Szrj || strcmp (alias, DEFAULT_MEMORY_REGION) == 0)
1381*fae548d3Szrj einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL);
1382*fae548d3Szrj
1383*fae548d3Szrj /* Look for the target region and check if the alias is not already
1384*fae548d3Szrj in use. */
1385*fae548d3Szrj region = NULL;
1386*fae548d3Szrj for (r = lang_memory_region_list; r != NULL; r = r->next)
1387*fae548d3Szrj for (n = &r->name_list; n != NULL; n = n->next)
1388*fae548d3Szrj {
1389*fae548d3Szrj if (region == NULL && strcmp (n->name, region_name) == 0)
1390*fae548d3Szrj region = r;
1391*fae548d3Szrj if (strcmp (n->name, alias) == 0)
1392*fae548d3Szrj einfo (_("%F%P:%pS: error: redefinition of memory region "
1393*fae548d3Szrj "alias `%s'\n"),
1394*fae548d3Szrj NULL, alias);
1395*fae548d3Szrj }
1396*fae548d3Szrj
1397*fae548d3Szrj /* Check if the target region exists. */
1398*fae548d3Szrj if (region == NULL)
1399*fae548d3Szrj einfo (_("%F%P:%pS: error: memory region `%s' "
1400*fae548d3Szrj "for alias `%s' does not exist\n"),
1401*fae548d3Szrj NULL, region_name, alias);
1402*fae548d3Szrj
1403*fae548d3Szrj /* Add alias to region name list. */
1404*fae548d3Szrj n = stat_alloc (sizeof (lang_memory_region_name));
1405*fae548d3Szrj n->name = xstrdup (alias);
1406*fae548d3Szrj n->next = region->name_list.next;
1407*fae548d3Szrj region->name_list.next = n;
1408*fae548d3Szrj }
1409*fae548d3Szrj
1410*fae548d3Szrj static lang_memory_region_type *
lang_memory_default(asection * section)1411*fae548d3Szrj lang_memory_default (asection *section)
1412*fae548d3Szrj {
1413*fae548d3Szrj lang_memory_region_type *p;
1414*fae548d3Szrj
1415*fae548d3Szrj flagword sec_flags = section->flags;
1416*fae548d3Szrj
1417*fae548d3Szrj /* Override SEC_DATA to mean a writable section. */
1418*fae548d3Szrj if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1419*fae548d3Szrj sec_flags |= SEC_DATA;
1420*fae548d3Szrj
1421*fae548d3Szrj for (p = lang_memory_region_list; p != NULL; p = p->next)
1422*fae548d3Szrj {
1423*fae548d3Szrj if ((p->flags & sec_flags) != 0
1424*fae548d3Szrj && (p->not_flags & sec_flags) == 0)
1425*fae548d3Szrj {
1426*fae548d3Szrj return p;
1427*fae548d3Szrj }
1428*fae548d3Szrj }
1429*fae548d3Szrj return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1430*fae548d3Szrj }
1431*fae548d3Szrj
1432*fae548d3Szrj /* Get the output section statement directly from the userdata. */
1433*fae548d3Szrj
1434*fae548d3Szrj lang_output_section_statement_type *
lang_output_section_get(const asection * output_section)1435*fae548d3Szrj lang_output_section_get (const asection *output_section)
1436*fae548d3Szrj {
1437*fae548d3Szrj return bfd_section_userdata (output_section);
1438*fae548d3Szrj }
1439*fae548d3Szrj
1440*fae548d3Szrj /* Find or create an output_section_statement with the given NAME.
1441*fae548d3Szrj If CONSTRAINT is non-zero match one with that constraint, otherwise
1442*fae548d3Szrj match any non-negative constraint. If CREATE, always make a
1443*fae548d3Szrj new output_section_statement for SPECIAL CONSTRAINT. */
1444*fae548d3Szrj
1445*fae548d3Szrj lang_output_section_statement_type *
lang_output_section_statement_lookup(const char * name,int constraint,bfd_boolean create)1446*fae548d3Szrj lang_output_section_statement_lookup (const char *name,
1447*fae548d3Szrj int constraint,
1448*fae548d3Szrj bfd_boolean create)
1449*fae548d3Szrj {
1450*fae548d3Szrj struct out_section_hash_entry *entry;
1451*fae548d3Szrj
1452*fae548d3Szrj entry = ((struct out_section_hash_entry *)
1453*fae548d3Szrj bfd_hash_lookup (&output_section_statement_table, name,
1454*fae548d3Szrj create, FALSE));
1455*fae548d3Szrj if (entry == NULL)
1456*fae548d3Szrj {
1457*fae548d3Szrj if (create)
1458*fae548d3Szrj einfo (_("%F%P: failed creating section `%s': %E\n"), name);
1459*fae548d3Szrj return NULL;
1460*fae548d3Szrj }
1461*fae548d3Szrj
1462*fae548d3Szrj if (entry->s.output_section_statement.name != NULL)
1463*fae548d3Szrj {
1464*fae548d3Szrj /* We have a section of this name, but it might not have the correct
1465*fae548d3Szrj constraint. */
1466*fae548d3Szrj struct out_section_hash_entry *last_ent;
1467*fae548d3Szrj
1468*fae548d3Szrj name = entry->s.output_section_statement.name;
1469*fae548d3Szrj if (create && constraint == SPECIAL)
1470*fae548d3Szrj /* Not traversing to the end reverses the order of the second
1471*fae548d3Szrj and subsequent SPECIAL sections in the hash table chain,
1472*fae548d3Szrj but that shouldn't matter. */
1473*fae548d3Szrj last_ent = entry;
1474*fae548d3Szrj else
1475*fae548d3Szrj do
1476*fae548d3Szrj {
1477*fae548d3Szrj if (constraint == entry->s.output_section_statement.constraint
1478*fae548d3Szrj || (constraint == 0
1479*fae548d3Szrj && entry->s.output_section_statement.constraint >= 0))
1480*fae548d3Szrj return &entry->s.output_section_statement;
1481*fae548d3Szrj last_ent = entry;
1482*fae548d3Szrj entry = (struct out_section_hash_entry *) entry->root.next;
1483*fae548d3Szrj }
1484*fae548d3Szrj while (entry != NULL
1485*fae548d3Szrj && name == entry->s.output_section_statement.name);
1486*fae548d3Szrj
1487*fae548d3Szrj if (!create)
1488*fae548d3Szrj return NULL;
1489*fae548d3Szrj
1490*fae548d3Szrj entry
1491*fae548d3Szrj = ((struct out_section_hash_entry *)
1492*fae548d3Szrj output_section_statement_newfunc (NULL,
1493*fae548d3Szrj &output_section_statement_table,
1494*fae548d3Szrj name));
1495*fae548d3Szrj if (entry == NULL)
1496*fae548d3Szrj {
1497*fae548d3Szrj einfo (_("%F%P: failed creating section `%s': %E\n"), name);
1498*fae548d3Szrj return NULL;
1499*fae548d3Szrj }
1500*fae548d3Szrj entry->root = last_ent->root;
1501*fae548d3Szrj last_ent->root.next = &entry->root;
1502*fae548d3Szrj }
1503*fae548d3Szrj
1504*fae548d3Szrj entry->s.output_section_statement.name = name;
1505*fae548d3Szrj entry->s.output_section_statement.constraint = constraint;
1506*fae548d3Szrj return &entry->s.output_section_statement;
1507*fae548d3Szrj }
1508*fae548d3Szrj
1509*fae548d3Szrj /* Find the next output_section_statement with the same name as OS.
1510*fae548d3Szrj If CONSTRAINT is non-zero, find one with that constraint otherwise
1511*fae548d3Szrj match any non-negative constraint. */
1512*fae548d3Szrj
1513*fae548d3Szrj lang_output_section_statement_type *
next_matching_output_section_statement(lang_output_section_statement_type * os,int constraint)1514*fae548d3Szrj next_matching_output_section_statement (lang_output_section_statement_type *os,
1515*fae548d3Szrj int constraint)
1516*fae548d3Szrj {
1517*fae548d3Szrj /* All output_section_statements are actually part of a
1518*fae548d3Szrj struct out_section_hash_entry. */
1519*fae548d3Szrj struct out_section_hash_entry *entry = (struct out_section_hash_entry *)
1520*fae548d3Szrj ((char *) os
1521*fae548d3Szrj - offsetof (struct out_section_hash_entry, s.output_section_statement));
1522*fae548d3Szrj const char *name = os->name;
1523*fae548d3Szrj
1524*fae548d3Szrj ASSERT (name == entry->root.string);
1525*fae548d3Szrj do
1526*fae548d3Szrj {
1527*fae548d3Szrj entry = (struct out_section_hash_entry *) entry->root.next;
1528*fae548d3Szrj if (entry == NULL
1529*fae548d3Szrj || name != entry->s.output_section_statement.name)
1530*fae548d3Szrj return NULL;
1531*fae548d3Szrj }
1532*fae548d3Szrj while (constraint != entry->s.output_section_statement.constraint
1533*fae548d3Szrj && (constraint != 0
1534*fae548d3Szrj || entry->s.output_section_statement.constraint < 0));
1535*fae548d3Szrj
1536*fae548d3Szrj return &entry->s.output_section_statement;
1537*fae548d3Szrj }
1538*fae548d3Szrj
1539*fae548d3Szrj /* A variant of lang_output_section_find used by place_orphan.
1540*fae548d3Szrj Returns the output statement that should precede a new output
1541*fae548d3Szrj statement for SEC. If an exact match is found on certain flags,
1542*fae548d3Szrj sets *EXACT too. */
1543*fae548d3Szrj
1544*fae548d3Szrj lang_output_section_statement_type *
lang_output_section_find_by_flags(const asection * sec,flagword sec_flags,lang_output_section_statement_type ** exact,lang_match_sec_type_func match_type)1545*fae548d3Szrj lang_output_section_find_by_flags (const asection *sec,
1546*fae548d3Szrj flagword sec_flags,
1547*fae548d3Szrj lang_output_section_statement_type **exact,
1548*fae548d3Szrj lang_match_sec_type_func match_type)
1549*fae548d3Szrj {
1550*fae548d3Szrj lang_output_section_statement_type *first, *look, *found;
1551*fae548d3Szrj flagword look_flags, differ;
1552*fae548d3Szrj
1553*fae548d3Szrj /* We know the first statement on this list is *ABS*. May as well
1554*fae548d3Szrj skip it. */
1555*fae548d3Szrj first = (void *) lang_os_list.head;
1556*fae548d3Szrj first = first->next;
1557*fae548d3Szrj
1558*fae548d3Szrj /* First try for an exact match. */
1559*fae548d3Szrj found = NULL;
1560*fae548d3Szrj for (look = first; look; look = look->next)
1561*fae548d3Szrj {
1562*fae548d3Szrj look_flags = look->flags;
1563*fae548d3Szrj if (look->bfd_section != NULL)
1564*fae548d3Szrj {
1565*fae548d3Szrj look_flags = look->bfd_section->flags;
1566*fae548d3Szrj if (match_type && !match_type (link_info.output_bfd,
1567*fae548d3Szrj look->bfd_section,
1568*fae548d3Szrj sec->owner, sec))
1569*fae548d3Szrj continue;
1570*fae548d3Szrj }
1571*fae548d3Szrj differ = look_flags ^ sec_flags;
1572*fae548d3Szrj if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1573*fae548d3Szrj | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1574*fae548d3Szrj found = look;
1575*fae548d3Szrj }
1576*fae548d3Szrj if (found != NULL)
1577*fae548d3Szrj {
1578*fae548d3Szrj if (exact != NULL)
1579*fae548d3Szrj *exact = found;
1580*fae548d3Szrj return found;
1581*fae548d3Szrj }
1582*fae548d3Szrj
1583*fae548d3Szrj if ((sec_flags & SEC_CODE) != 0
1584*fae548d3Szrj && (sec_flags & SEC_ALLOC) != 0)
1585*fae548d3Szrj {
1586*fae548d3Szrj /* Try for a rw code section. */
1587*fae548d3Szrj for (look = first; look; look = look->next)
1588*fae548d3Szrj {
1589*fae548d3Szrj look_flags = look->flags;
1590*fae548d3Szrj if (look->bfd_section != NULL)
1591*fae548d3Szrj {
1592*fae548d3Szrj look_flags = look->bfd_section->flags;
1593*fae548d3Szrj if (match_type && !match_type (link_info.output_bfd,
1594*fae548d3Szrj look->bfd_section,
1595*fae548d3Szrj sec->owner, sec))
1596*fae548d3Szrj continue;
1597*fae548d3Szrj }
1598*fae548d3Szrj differ = look_flags ^ sec_flags;
1599*fae548d3Szrj if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1600*fae548d3Szrj | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1601*fae548d3Szrj found = look;
1602*fae548d3Szrj }
1603*fae548d3Szrj }
1604*fae548d3Szrj else if ((sec_flags & SEC_READONLY) != 0
1605*fae548d3Szrj && (sec_flags & SEC_ALLOC) != 0)
1606*fae548d3Szrj {
1607*fae548d3Szrj /* .rodata can go after .text, .sdata2 after .rodata. */
1608*fae548d3Szrj for (look = first; look; look = look->next)
1609*fae548d3Szrj {
1610*fae548d3Szrj look_flags = look->flags;
1611*fae548d3Szrj if (look->bfd_section != NULL)
1612*fae548d3Szrj {
1613*fae548d3Szrj look_flags = look->bfd_section->flags;
1614*fae548d3Szrj if (match_type && !match_type (link_info.output_bfd,
1615*fae548d3Szrj look->bfd_section,
1616*fae548d3Szrj sec->owner, sec))
1617*fae548d3Szrj continue;
1618*fae548d3Szrj }
1619*fae548d3Szrj differ = look_flags ^ sec_flags;
1620*fae548d3Szrj if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1621*fae548d3Szrj | SEC_READONLY | SEC_SMALL_DATA))
1622*fae548d3Szrj || (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1623*fae548d3Szrj | SEC_READONLY))
1624*fae548d3Szrj && !(look_flags & SEC_SMALL_DATA)))
1625*fae548d3Szrj found = look;
1626*fae548d3Szrj }
1627*fae548d3Szrj }
1628*fae548d3Szrj else if ((sec_flags & SEC_THREAD_LOCAL) != 0
1629*fae548d3Szrj && (sec_flags & SEC_ALLOC) != 0)
1630*fae548d3Szrj {
1631*fae548d3Szrj /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1632*fae548d3Szrj as if it were a loaded section, and don't use match_type. */
1633*fae548d3Szrj bfd_boolean seen_thread_local = FALSE;
1634*fae548d3Szrj
1635*fae548d3Szrj match_type = NULL;
1636*fae548d3Szrj for (look = first; look; look = look->next)
1637*fae548d3Szrj {
1638*fae548d3Szrj look_flags = look->flags;
1639*fae548d3Szrj if (look->bfd_section != NULL)
1640*fae548d3Szrj look_flags = look->bfd_section->flags;
1641*fae548d3Szrj
1642*fae548d3Szrj differ = look_flags ^ (sec_flags | SEC_LOAD | SEC_HAS_CONTENTS);
1643*fae548d3Szrj if (!(differ & (SEC_THREAD_LOCAL | SEC_ALLOC)))
1644*fae548d3Szrj {
1645*fae548d3Szrj /* .tdata and .tbss must be adjacent and in that order. */
1646*fae548d3Szrj if (!(look_flags & SEC_LOAD)
1647*fae548d3Szrj && (sec_flags & SEC_LOAD))
1648*fae548d3Szrj /* ..so if we're at a .tbss section and we're placing
1649*fae548d3Szrj a .tdata section stop looking and return the
1650*fae548d3Szrj previous section. */
1651*fae548d3Szrj break;
1652*fae548d3Szrj found = look;
1653*fae548d3Szrj seen_thread_local = TRUE;
1654*fae548d3Szrj }
1655*fae548d3Szrj else if (seen_thread_local)
1656*fae548d3Szrj break;
1657*fae548d3Szrj else if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD)))
1658*fae548d3Szrj found = look;
1659*fae548d3Szrj }
1660*fae548d3Szrj }
1661*fae548d3Szrj else if ((sec_flags & SEC_SMALL_DATA) != 0
1662*fae548d3Szrj && (sec_flags & SEC_ALLOC) != 0)
1663*fae548d3Szrj {
1664*fae548d3Szrj /* .sdata goes after .data, .sbss after .sdata. */
1665*fae548d3Szrj for (look = first; look; look = look->next)
1666*fae548d3Szrj {
1667*fae548d3Szrj look_flags = look->flags;
1668*fae548d3Szrj if (look->bfd_section != NULL)
1669*fae548d3Szrj {
1670*fae548d3Szrj look_flags = look->bfd_section->flags;
1671*fae548d3Szrj if (match_type && !match_type (link_info.output_bfd,
1672*fae548d3Szrj look->bfd_section,
1673*fae548d3Szrj sec->owner, sec))
1674*fae548d3Szrj continue;
1675*fae548d3Szrj }
1676*fae548d3Szrj differ = look_flags ^ sec_flags;
1677*fae548d3Szrj if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1678*fae548d3Szrj | SEC_THREAD_LOCAL))
1679*fae548d3Szrj || ((look_flags & SEC_SMALL_DATA)
1680*fae548d3Szrj && !(sec_flags & SEC_HAS_CONTENTS)))
1681*fae548d3Szrj found = look;
1682*fae548d3Szrj }
1683*fae548d3Szrj }
1684*fae548d3Szrj else if ((sec_flags & SEC_HAS_CONTENTS) != 0
1685*fae548d3Szrj && (sec_flags & SEC_ALLOC) != 0)
1686*fae548d3Szrj {
1687*fae548d3Szrj /* .data goes after .rodata. */
1688*fae548d3Szrj for (look = first; look; look = look->next)
1689*fae548d3Szrj {
1690*fae548d3Szrj look_flags = look->flags;
1691*fae548d3Szrj if (look->bfd_section != NULL)
1692*fae548d3Szrj {
1693*fae548d3Szrj look_flags = look->bfd_section->flags;
1694*fae548d3Szrj if (match_type && !match_type (link_info.output_bfd,
1695*fae548d3Szrj look->bfd_section,
1696*fae548d3Szrj sec->owner, sec))
1697*fae548d3Szrj continue;
1698*fae548d3Szrj }
1699*fae548d3Szrj differ = look_flags ^ sec_flags;
1700*fae548d3Szrj if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1701*fae548d3Szrj | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1702*fae548d3Szrj found = look;
1703*fae548d3Szrj }
1704*fae548d3Szrj }
1705*fae548d3Szrj else if ((sec_flags & SEC_ALLOC) != 0)
1706*fae548d3Szrj {
1707*fae548d3Szrj /* .bss goes after any other alloc section. */
1708*fae548d3Szrj for (look = first; look; look = look->next)
1709*fae548d3Szrj {
1710*fae548d3Szrj look_flags = look->flags;
1711*fae548d3Szrj if (look->bfd_section != NULL)
1712*fae548d3Szrj {
1713*fae548d3Szrj look_flags = look->bfd_section->flags;
1714*fae548d3Szrj if (match_type && !match_type (link_info.output_bfd,
1715*fae548d3Szrj look->bfd_section,
1716*fae548d3Szrj sec->owner, sec))
1717*fae548d3Szrj continue;
1718*fae548d3Szrj }
1719*fae548d3Szrj differ = look_flags ^ sec_flags;
1720*fae548d3Szrj if (!(differ & SEC_ALLOC))
1721*fae548d3Szrj found = look;
1722*fae548d3Szrj }
1723*fae548d3Szrj }
1724*fae548d3Szrj else
1725*fae548d3Szrj {
1726*fae548d3Szrj /* non-alloc go last. */
1727*fae548d3Szrj for (look = first; look; look = look->next)
1728*fae548d3Szrj {
1729*fae548d3Szrj look_flags = look->flags;
1730*fae548d3Szrj if (look->bfd_section != NULL)
1731*fae548d3Szrj look_flags = look->bfd_section->flags;
1732*fae548d3Szrj differ = look_flags ^ sec_flags;
1733*fae548d3Szrj if (!(differ & SEC_DEBUGGING))
1734*fae548d3Szrj found = look;
1735*fae548d3Szrj }
1736*fae548d3Szrj return found;
1737*fae548d3Szrj }
1738*fae548d3Szrj
1739*fae548d3Szrj if (found || !match_type)
1740*fae548d3Szrj return found;
1741*fae548d3Szrj
1742*fae548d3Szrj return lang_output_section_find_by_flags (sec, sec_flags, NULL, NULL);
1743*fae548d3Szrj }
1744*fae548d3Szrj
1745*fae548d3Szrj /* Find the last output section before given output statement.
1746*fae548d3Szrj Used by place_orphan. */
1747*fae548d3Szrj
1748*fae548d3Szrj static asection *
output_prev_sec_find(lang_output_section_statement_type * os)1749*fae548d3Szrj output_prev_sec_find (lang_output_section_statement_type *os)
1750*fae548d3Szrj {
1751*fae548d3Szrj lang_output_section_statement_type *lookup;
1752*fae548d3Szrj
1753*fae548d3Szrj for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1754*fae548d3Szrj {
1755*fae548d3Szrj if (lookup->constraint < 0)
1756*fae548d3Szrj continue;
1757*fae548d3Szrj
1758*fae548d3Szrj if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1759*fae548d3Szrj return lookup->bfd_section;
1760*fae548d3Szrj }
1761*fae548d3Szrj
1762*fae548d3Szrj return NULL;
1763*fae548d3Szrj }
1764*fae548d3Szrj
1765*fae548d3Szrj /* Look for a suitable place for a new output section statement. The
1766*fae548d3Szrj idea is to skip over anything that might be inside a SECTIONS {}
1767*fae548d3Szrj statement in a script, before we find another output section
1768*fae548d3Szrj statement. Assignments to "dot" before an output section statement
1769*fae548d3Szrj are assumed to belong to it, except in two cases; The first
1770*fae548d3Szrj assignment to dot, and assignments before non-alloc sections.
1771*fae548d3Szrj Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1772*fae548d3Szrj similar assignments that set the initial address, or we might
1773*fae548d3Szrj insert non-alloc note sections among assignments setting end of
1774*fae548d3Szrj image symbols. */
1775*fae548d3Szrj
1776*fae548d3Szrj static lang_statement_union_type **
insert_os_after(lang_output_section_statement_type * after)1777*fae548d3Szrj insert_os_after (lang_output_section_statement_type *after)
1778*fae548d3Szrj {
1779*fae548d3Szrj lang_statement_union_type **where;
1780*fae548d3Szrj lang_statement_union_type **assign = NULL;
1781*fae548d3Szrj bfd_boolean ignore_first;
1782*fae548d3Szrj
1783*fae548d3Szrj ignore_first = after == (void *) lang_os_list.head;
1784*fae548d3Szrj
1785*fae548d3Szrj for (where = &after->header.next;
1786*fae548d3Szrj *where != NULL;
1787*fae548d3Szrj where = &(*where)->header.next)
1788*fae548d3Szrj {
1789*fae548d3Szrj switch ((*where)->header.type)
1790*fae548d3Szrj {
1791*fae548d3Szrj case lang_assignment_statement_enum:
1792*fae548d3Szrj if (assign == NULL)
1793*fae548d3Szrj {
1794*fae548d3Szrj lang_assignment_statement_type *ass;
1795*fae548d3Szrj
1796*fae548d3Szrj ass = &(*where)->assignment_statement;
1797*fae548d3Szrj if (ass->exp->type.node_class != etree_assert
1798*fae548d3Szrj && ass->exp->assign.dst[0] == '.'
1799*fae548d3Szrj && ass->exp->assign.dst[1] == 0)
1800*fae548d3Szrj {
1801*fae548d3Szrj if (!ignore_first)
1802*fae548d3Szrj assign = where;
1803*fae548d3Szrj ignore_first = FALSE;
1804*fae548d3Szrj }
1805*fae548d3Szrj }
1806*fae548d3Szrj continue;
1807*fae548d3Szrj case lang_wild_statement_enum:
1808*fae548d3Szrj case lang_input_section_enum:
1809*fae548d3Szrj case lang_object_symbols_statement_enum:
1810*fae548d3Szrj case lang_fill_statement_enum:
1811*fae548d3Szrj case lang_data_statement_enum:
1812*fae548d3Szrj case lang_reloc_statement_enum:
1813*fae548d3Szrj case lang_padding_statement_enum:
1814*fae548d3Szrj case lang_constructors_statement_enum:
1815*fae548d3Szrj assign = NULL;
1816*fae548d3Szrj ignore_first = FALSE;
1817*fae548d3Szrj continue;
1818*fae548d3Szrj case lang_output_section_statement_enum:
1819*fae548d3Szrj if (assign != NULL)
1820*fae548d3Szrj {
1821*fae548d3Szrj asection *s = (*where)->output_section_statement.bfd_section;
1822*fae548d3Szrj
1823*fae548d3Szrj if (s == NULL
1824*fae548d3Szrj || s->map_head.s == NULL
1825*fae548d3Szrj || (s->flags & SEC_ALLOC) != 0)
1826*fae548d3Szrj where = assign;
1827*fae548d3Szrj }
1828*fae548d3Szrj break;
1829*fae548d3Szrj case lang_input_statement_enum:
1830*fae548d3Szrj case lang_address_statement_enum:
1831*fae548d3Szrj case lang_target_statement_enum:
1832*fae548d3Szrj case lang_output_statement_enum:
1833*fae548d3Szrj case lang_group_statement_enum:
1834*fae548d3Szrj case lang_insert_statement_enum:
1835*fae548d3Szrj continue;
1836*fae548d3Szrj }
1837*fae548d3Szrj break;
1838*fae548d3Szrj }
1839*fae548d3Szrj
1840*fae548d3Szrj return where;
1841*fae548d3Szrj }
1842*fae548d3Szrj
1843*fae548d3Szrj lang_output_section_statement_type *
lang_insert_orphan(asection * s,const char * secname,int constraint,lang_output_section_statement_type * after,struct orphan_save * place,etree_type * address,lang_statement_list_type * add_child)1844*fae548d3Szrj lang_insert_orphan (asection *s,
1845*fae548d3Szrj const char *secname,
1846*fae548d3Szrj int constraint,
1847*fae548d3Szrj lang_output_section_statement_type *after,
1848*fae548d3Szrj struct orphan_save *place,
1849*fae548d3Szrj etree_type *address,
1850*fae548d3Szrj lang_statement_list_type *add_child)
1851*fae548d3Szrj {
1852*fae548d3Szrj lang_statement_list_type add;
1853*fae548d3Szrj lang_output_section_statement_type *os;
1854*fae548d3Szrj lang_output_section_statement_type **os_tail;
1855*fae548d3Szrj
1856*fae548d3Szrj /* If we have found an appropriate place for the output section
1857*fae548d3Szrj statements for this orphan, add them to our own private list,
1858*fae548d3Szrj inserting them later into the global statement list. */
1859*fae548d3Szrj if (after != NULL)
1860*fae548d3Szrj {
1861*fae548d3Szrj lang_list_init (&add);
1862*fae548d3Szrj push_stat_ptr (&add);
1863*fae548d3Szrj }
1864*fae548d3Szrj
1865*fae548d3Szrj if (bfd_link_relocatable (&link_info)
1866*fae548d3Szrj || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1867*fae548d3Szrj address = exp_intop (0);
1868*fae548d3Szrj
1869*fae548d3Szrj os_tail = (lang_output_section_statement_type **) lang_os_list.tail;
1870*fae548d3Szrj os = lang_enter_output_section_statement (secname, address, normal_section,
1871*fae548d3Szrj NULL, NULL, NULL, constraint, 0);
1872*fae548d3Szrj
1873*fae548d3Szrj if (add_child == NULL)
1874*fae548d3Szrj add_child = &os->children;
1875*fae548d3Szrj lang_add_section (add_child, s, NULL, os);
1876*fae548d3Szrj
1877*fae548d3Szrj if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0)
1878*fae548d3Szrj {
1879*fae548d3Szrj const char *region = (after->region
1880*fae548d3Szrj ? after->region->name_list.name
1881*fae548d3Szrj : DEFAULT_MEMORY_REGION);
1882*fae548d3Szrj const char *lma_region = (after->lma_region
1883*fae548d3Szrj ? after->lma_region->name_list.name
1884*fae548d3Szrj : NULL);
1885*fae548d3Szrj lang_leave_output_section_statement (NULL, region, after->phdrs,
1886*fae548d3Szrj lma_region);
1887*fae548d3Szrj }
1888*fae548d3Szrj else
1889*fae548d3Szrj lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
1890*fae548d3Szrj NULL);
1891*fae548d3Szrj
1892*fae548d3Szrj /* Restore the global list pointer. */
1893*fae548d3Szrj if (after != NULL)
1894*fae548d3Szrj pop_stat_ptr ();
1895*fae548d3Szrj
1896*fae548d3Szrj if (after != NULL && os->bfd_section != NULL)
1897*fae548d3Szrj {
1898*fae548d3Szrj asection *snew, *as;
1899*fae548d3Szrj bfd_boolean place_after = place->stmt == NULL;
1900*fae548d3Szrj bfd_boolean insert_after = TRUE;
1901*fae548d3Szrj
1902*fae548d3Szrj snew = os->bfd_section;
1903*fae548d3Szrj
1904*fae548d3Szrj /* Shuffle the bfd section list to make the output file look
1905*fae548d3Szrj neater. This is really only cosmetic. */
1906*fae548d3Szrj if (place->section == NULL
1907*fae548d3Szrj && after != (void *) lang_os_list.head)
1908*fae548d3Szrj {
1909*fae548d3Szrj asection *bfd_section = after->bfd_section;
1910*fae548d3Szrj
1911*fae548d3Szrj /* If the output statement hasn't been used to place any input
1912*fae548d3Szrj sections (and thus doesn't have an output bfd_section),
1913*fae548d3Szrj look for the closest prior output statement having an
1914*fae548d3Szrj output section. */
1915*fae548d3Szrj if (bfd_section == NULL)
1916*fae548d3Szrj bfd_section = output_prev_sec_find (after);
1917*fae548d3Szrj
1918*fae548d3Szrj if (bfd_section != NULL && bfd_section != snew)
1919*fae548d3Szrj place->section = &bfd_section->next;
1920*fae548d3Szrj }
1921*fae548d3Szrj
1922*fae548d3Szrj if (place->section == NULL)
1923*fae548d3Szrj place->section = &link_info.output_bfd->sections;
1924*fae548d3Szrj
1925*fae548d3Szrj as = *place->section;
1926*fae548d3Szrj
1927*fae548d3Szrj if (!as)
1928*fae548d3Szrj {
1929*fae548d3Szrj /* Put the section at the end of the list. */
1930*fae548d3Szrj
1931*fae548d3Szrj /* Unlink the section. */
1932*fae548d3Szrj bfd_section_list_remove (link_info.output_bfd, snew);
1933*fae548d3Szrj
1934*fae548d3Szrj /* Now tack it back on in the right place. */
1935*fae548d3Szrj bfd_section_list_append (link_info.output_bfd, snew);
1936*fae548d3Szrj }
1937*fae548d3Szrj else if ((bfd_get_flavour (link_info.output_bfd)
1938*fae548d3Szrj == bfd_target_elf_flavour)
1939*fae548d3Szrj && (bfd_get_flavour (s->owner)
1940*fae548d3Szrj == bfd_target_elf_flavour)
1941*fae548d3Szrj && ((elf_section_type (s) == SHT_NOTE
1942*fae548d3Szrj && (s->flags & SEC_LOAD) != 0)
1943*fae548d3Szrj || (elf_section_type (as) == SHT_NOTE
1944*fae548d3Szrj && (as->flags & SEC_LOAD) != 0)))
1945*fae548d3Szrj {
1946*fae548d3Szrj /* Make sure that output note sections are grouped and sorted
1947*fae548d3Szrj by alignments when inserting a note section or insert a
1948*fae548d3Szrj section after a note section, */
1949*fae548d3Szrj asection *sec;
1950*fae548d3Szrj /* A specific section after which the output note section
1951*fae548d3Szrj should be placed. */
1952*fae548d3Szrj asection *after_sec;
1953*fae548d3Szrj /* True if we need to insert the orphan section after a
1954*fae548d3Szrj specific section to maintain output note section order. */
1955*fae548d3Szrj bfd_boolean after_sec_note = FALSE;
1956*fae548d3Szrj
1957*fae548d3Szrj static asection *first_orphan_note = NULL;
1958*fae548d3Szrj
1959*fae548d3Szrj /* Group and sort output note section by alignments in
1960*fae548d3Szrj ascending order. */
1961*fae548d3Szrj after_sec = NULL;
1962*fae548d3Szrj if (elf_section_type (s) == SHT_NOTE
1963*fae548d3Szrj && (s->flags & SEC_LOAD) != 0)
1964*fae548d3Szrj {
1965*fae548d3Szrj /* Search from the beginning for the last output note
1966*fae548d3Szrj section with equal or larger alignments. NB: Don't
1967*fae548d3Szrj place orphan note section after non-note sections. */
1968*fae548d3Szrj
1969*fae548d3Szrj first_orphan_note = NULL;
1970*fae548d3Szrj for (sec = link_info.output_bfd->sections;
1971*fae548d3Szrj (sec != NULL
1972*fae548d3Szrj && !bfd_is_abs_section (sec));
1973*fae548d3Szrj sec = sec->next)
1974*fae548d3Szrj if (sec != snew
1975*fae548d3Szrj && elf_section_type (sec) == SHT_NOTE
1976*fae548d3Szrj && (sec->flags & SEC_LOAD) != 0)
1977*fae548d3Szrj {
1978*fae548d3Szrj if (!first_orphan_note)
1979*fae548d3Szrj first_orphan_note = sec;
1980*fae548d3Szrj if (sec->alignment_power >= s->alignment_power)
1981*fae548d3Szrj after_sec = sec;
1982*fae548d3Szrj }
1983*fae548d3Szrj else if (first_orphan_note)
1984*fae548d3Szrj {
1985*fae548d3Szrj /* Stop if there is non-note section after the first
1986*fae548d3Szrj orphan note section. */
1987*fae548d3Szrj break;
1988*fae548d3Szrj }
1989*fae548d3Szrj
1990*fae548d3Szrj /* If this will be the first orphan note section, it can
1991*fae548d3Szrj be placed at the default location. */
1992*fae548d3Szrj after_sec_note = first_orphan_note != NULL;
1993*fae548d3Szrj if (after_sec == NULL && after_sec_note)
1994*fae548d3Szrj {
1995*fae548d3Szrj /* If all output note sections have smaller
1996*fae548d3Szrj alignments, place the section before all
1997*fae548d3Szrj output orphan note sections. */
1998*fae548d3Szrj after_sec = first_orphan_note;
1999*fae548d3Szrj insert_after = FALSE;
2000*fae548d3Szrj }
2001*fae548d3Szrj }
2002*fae548d3Szrj else if (first_orphan_note)
2003*fae548d3Szrj {
2004*fae548d3Szrj /* Don't place non-note sections in the middle of orphan
2005*fae548d3Szrj note sections. */
2006*fae548d3Szrj after_sec_note = TRUE;
2007*fae548d3Szrj after_sec = as;
2008*fae548d3Szrj for (sec = as->next;
2009*fae548d3Szrj (sec != NULL
2010*fae548d3Szrj && !bfd_is_abs_section (sec));
2011*fae548d3Szrj sec = sec->next)
2012*fae548d3Szrj if (elf_section_type (sec) == SHT_NOTE
2013*fae548d3Szrj && (sec->flags & SEC_LOAD) != 0)
2014*fae548d3Szrj after_sec = sec;
2015*fae548d3Szrj }
2016*fae548d3Szrj
2017*fae548d3Szrj if (after_sec_note)
2018*fae548d3Szrj {
2019*fae548d3Szrj if (after_sec)
2020*fae548d3Szrj {
2021*fae548d3Szrj /* Search forward to insert OS after AFTER_SEC output
2022*fae548d3Szrj statement. */
2023*fae548d3Szrj lang_output_section_statement_type *stmt, *next;
2024*fae548d3Szrj bfd_boolean found = FALSE;
2025*fae548d3Szrj for (stmt = after; stmt != NULL; stmt = next)
2026*fae548d3Szrj {
2027*fae548d3Szrj next = stmt->next;
2028*fae548d3Szrj if (insert_after)
2029*fae548d3Szrj {
2030*fae548d3Szrj if (stmt->bfd_section == after_sec)
2031*fae548d3Szrj {
2032*fae548d3Szrj place_after = TRUE;
2033*fae548d3Szrj found = TRUE;
2034*fae548d3Szrj after = stmt;
2035*fae548d3Szrj break;
2036*fae548d3Szrj }
2037*fae548d3Szrj }
2038*fae548d3Szrj else
2039*fae548d3Szrj {
2040*fae548d3Szrj /* If INSERT_AFTER is FALSE, place OS before
2041*fae548d3Szrj AFTER_SEC output statement. */
2042*fae548d3Szrj if (next && next->bfd_section == after_sec)
2043*fae548d3Szrj {
2044*fae548d3Szrj place_after = TRUE;
2045*fae548d3Szrj found = TRUE;
2046*fae548d3Szrj after = stmt;
2047*fae548d3Szrj break;
2048*fae548d3Szrj }
2049*fae548d3Szrj }
2050*fae548d3Szrj }
2051*fae548d3Szrj
2052*fae548d3Szrj /* Search backward to insert OS after AFTER_SEC output
2053*fae548d3Szrj statement. */
2054*fae548d3Szrj if (!found)
2055*fae548d3Szrj for (stmt = after; stmt != NULL; stmt = stmt->prev)
2056*fae548d3Szrj {
2057*fae548d3Szrj if (insert_after)
2058*fae548d3Szrj {
2059*fae548d3Szrj if (stmt->bfd_section == after_sec)
2060*fae548d3Szrj {
2061*fae548d3Szrj place_after = TRUE;
2062*fae548d3Szrj after = stmt;
2063*fae548d3Szrj break;
2064*fae548d3Szrj }
2065*fae548d3Szrj }
2066*fae548d3Szrj else
2067*fae548d3Szrj {
2068*fae548d3Szrj /* If INSERT_AFTER is FALSE, place OS before
2069*fae548d3Szrj AFTER_SEC output statement. */
2070*fae548d3Szrj if (stmt->next->bfd_section == after_sec)
2071*fae548d3Szrj {
2072*fae548d3Szrj place_after = TRUE;
2073*fae548d3Szrj after = stmt;
2074*fae548d3Szrj break;
2075*fae548d3Szrj }
2076*fae548d3Szrj }
2077*fae548d3Szrj }
2078*fae548d3Szrj }
2079*fae548d3Szrj
2080*fae548d3Szrj if (after_sec == NULL
2081*fae548d3Szrj || (insert_after && after_sec->next != snew)
2082*fae548d3Szrj || (!insert_after && after_sec->prev != snew))
2083*fae548d3Szrj {
2084*fae548d3Szrj /* Unlink the section. */
2085*fae548d3Szrj bfd_section_list_remove (link_info.output_bfd, snew);
2086*fae548d3Szrj
2087*fae548d3Szrj /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2088*fae548d3Szrj prepend SNEW. */
2089*fae548d3Szrj if (after_sec)
2090*fae548d3Szrj {
2091*fae548d3Szrj if (insert_after)
2092*fae548d3Szrj bfd_section_list_insert_after (link_info.output_bfd,
2093*fae548d3Szrj after_sec, snew);
2094*fae548d3Szrj else
2095*fae548d3Szrj bfd_section_list_insert_before (link_info.output_bfd,
2096*fae548d3Szrj after_sec, snew);
2097*fae548d3Szrj }
2098*fae548d3Szrj else
2099*fae548d3Szrj bfd_section_list_prepend (link_info.output_bfd, snew);
2100*fae548d3Szrj }
2101*fae548d3Szrj }
2102*fae548d3Szrj else if (as != snew && as->prev != snew)
2103*fae548d3Szrj {
2104*fae548d3Szrj /* Unlink the section. */
2105*fae548d3Szrj bfd_section_list_remove (link_info.output_bfd, snew);
2106*fae548d3Szrj
2107*fae548d3Szrj /* Now tack it back on in the right place. */
2108*fae548d3Szrj bfd_section_list_insert_before (link_info.output_bfd,
2109*fae548d3Szrj as, snew);
2110*fae548d3Szrj }
2111*fae548d3Szrj }
2112*fae548d3Szrj else if (as != snew && as->prev != snew)
2113*fae548d3Szrj {
2114*fae548d3Szrj /* Unlink the section. */
2115*fae548d3Szrj bfd_section_list_remove (link_info.output_bfd, snew);
2116*fae548d3Szrj
2117*fae548d3Szrj /* Now tack it back on in the right place. */
2118*fae548d3Szrj bfd_section_list_insert_before (link_info.output_bfd, as, snew);
2119*fae548d3Szrj }
2120*fae548d3Szrj
2121*fae548d3Szrj /* Save the end of this list. Further ophans of this type will
2122*fae548d3Szrj follow the one we've just added. */
2123*fae548d3Szrj place->section = &snew->next;
2124*fae548d3Szrj
2125*fae548d3Szrj /* The following is non-cosmetic. We try to put the output
2126*fae548d3Szrj statements in some sort of reasonable order here, because they
2127*fae548d3Szrj determine the final load addresses of the orphan sections.
2128*fae548d3Szrj In addition, placing output statements in the wrong order may
2129*fae548d3Szrj require extra segments. For instance, given a typical
2130*fae548d3Szrj situation of all read-only sections placed in one segment and
2131*fae548d3Szrj following that a segment containing all the read-write
2132*fae548d3Szrj sections, we wouldn't want to place an orphan read/write
2133*fae548d3Szrj section before or amongst the read-only ones. */
2134*fae548d3Szrj if (add.head != NULL)
2135*fae548d3Szrj {
2136*fae548d3Szrj lang_output_section_statement_type *newly_added_os;
2137*fae548d3Szrj
2138*fae548d3Szrj /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2139*fae548d3Szrj if (place_after)
2140*fae548d3Szrj {
2141*fae548d3Szrj lang_statement_union_type **where = insert_os_after (after);
2142*fae548d3Szrj
2143*fae548d3Szrj *add.tail = *where;
2144*fae548d3Szrj *where = add.head;
2145*fae548d3Szrj
2146*fae548d3Szrj place->os_tail = &after->next;
2147*fae548d3Szrj }
2148*fae548d3Szrj else
2149*fae548d3Szrj {
2150*fae548d3Szrj /* Put it after the last orphan statement we added. */
2151*fae548d3Szrj *add.tail = *place->stmt;
2152*fae548d3Szrj *place->stmt = add.head;
2153*fae548d3Szrj }
2154*fae548d3Szrj
2155*fae548d3Szrj /* Fix the global list pointer if we happened to tack our
2156*fae548d3Szrj new list at the tail. */
2157*fae548d3Szrj if (*stat_ptr->tail == add.head)
2158*fae548d3Szrj stat_ptr->tail = add.tail;
2159*fae548d3Szrj
2160*fae548d3Szrj /* Save the end of this list. */
2161*fae548d3Szrj place->stmt = add.tail;
2162*fae548d3Szrj
2163*fae548d3Szrj /* Do the same for the list of output section statements. */
2164*fae548d3Szrj newly_added_os = *os_tail;
2165*fae548d3Szrj *os_tail = NULL;
2166*fae548d3Szrj newly_added_os->prev = (lang_output_section_statement_type *)
2167*fae548d3Szrj ((char *) place->os_tail
2168*fae548d3Szrj - offsetof (lang_output_section_statement_type, next));
2169*fae548d3Szrj newly_added_os->next = *place->os_tail;
2170*fae548d3Szrj if (newly_added_os->next != NULL)
2171*fae548d3Szrj newly_added_os->next->prev = newly_added_os;
2172*fae548d3Szrj *place->os_tail = newly_added_os;
2173*fae548d3Szrj place->os_tail = &newly_added_os->next;
2174*fae548d3Szrj
2175*fae548d3Szrj /* Fixing the global list pointer here is a little different.
2176*fae548d3Szrj We added to the list in lang_enter_output_section_statement,
2177*fae548d3Szrj trimmed off the new output_section_statment above when
2178*fae548d3Szrj assigning *os_tail = NULL, but possibly added it back in
2179*fae548d3Szrj the same place when assigning *place->os_tail. */
2180*fae548d3Szrj if (*os_tail == NULL)
2181*fae548d3Szrj lang_os_list.tail = (lang_statement_union_type **) os_tail;
2182*fae548d3Szrj }
2183*fae548d3Szrj }
2184*fae548d3Szrj return os;
2185*fae548d3Szrj }
2186*fae548d3Szrj
2187*fae548d3Szrj static void
lang_print_asneeded(void)2188*fae548d3Szrj lang_print_asneeded (void)
2189*fae548d3Szrj {
2190*fae548d3Szrj struct asneeded_minfo *m;
2191*fae548d3Szrj
2192*fae548d3Szrj if (asneeded_list_head == NULL)
2193*fae548d3Szrj return;
2194*fae548d3Szrj
2195*fae548d3Szrj minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2196*fae548d3Szrj
2197*fae548d3Szrj for (m = asneeded_list_head; m != NULL; m = m->next)
2198*fae548d3Szrj {
2199*fae548d3Szrj size_t len;
2200*fae548d3Szrj
2201*fae548d3Szrj minfo ("%s", m->soname);
2202*fae548d3Szrj len = strlen (m->soname);
2203*fae548d3Szrj
2204*fae548d3Szrj if (len >= 29)
2205*fae548d3Szrj {
2206*fae548d3Szrj print_nl ();
2207*fae548d3Szrj len = 0;
2208*fae548d3Szrj }
2209*fae548d3Szrj while (len < 30)
2210*fae548d3Szrj {
2211*fae548d3Szrj print_space ();
2212*fae548d3Szrj ++len;
2213*fae548d3Szrj }
2214*fae548d3Szrj
2215*fae548d3Szrj if (m->ref != NULL)
2216*fae548d3Szrj minfo ("%pB ", m->ref);
2217*fae548d3Szrj minfo ("(%pT)\n", m->name);
2218*fae548d3Szrj }
2219*fae548d3Szrj }
2220*fae548d3Szrj
2221*fae548d3Szrj static void
lang_map_flags(flagword flag)2222*fae548d3Szrj lang_map_flags (flagword flag)
2223*fae548d3Szrj {
2224*fae548d3Szrj if (flag & SEC_ALLOC)
2225*fae548d3Szrj minfo ("a");
2226*fae548d3Szrj
2227*fae548d3Szrj if (flag & SEC_CODE)
2228*fae548d3Szrj minfo ("x");
2229*fae548d3Szrj
2230*fae548d3Szrj if (flag & SEC_READONLY)
2231*fae548d3Szrj minfo ("r");
2232*fae548d3Szrj
2233*fae548d3Szrj if (flag & SEC_DATA)
2234*fae548d3Szrj minfo ("w");
2235*fae548d3Szrj
2236*fae548d3Szrj if (flag & SEC_LOAD)
2237*fae548d3Szrj minfo ("l");
2238*fae548d3Szrj }
2239*fae548d3Szrj
2240*fae548d3Szrj void
lang_map(void)2241*fae548d3Szrj lang_map (void)
2242*fae548d3Szrj {
2243*fae548d3Szrj lang_memory_region_type *m;
2244*fae548d3Szrj bfd_boolean dis_header_printed = FALSE;
2245*fae548d3Szrj
2246*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (file)
2247*fae548d3Szrj {
2248*fae548d3Szrj asection *s;
2249*fae548d3Szrj
2250*fae548d3Szrj if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
2251*fae548d3Szrj || file->flags.just_syms)
2252*fae548d3Szrj continue;
2253*fae548d3Szrj
2254*fae548d3Szrj if (config.print_map_discarded)
2255*fae548d3Szrj for (s = file->the_bfd->sections; s != NULL; s = s->next)
2256*fae548d3Szrj if ((s->output_section == NULL
2257*fae548d3Szrj || s->output_section->owner != link_info.output_bfd)
2258*fae548d3Szrj && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
2259*fae548d3Szrj {
2260*fae548d3Szrj if (! dis_header_printed)
2261*fae548d3Szrj {
2262*fae548d3Szrj fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
2263*fae548d3Szrj dis_header_printed = TRUE;
2264*fae548d3Szrj }
2265*fae548d3Szrj
2266*fae548d3Szrj print_input_section (s, TRUE);
2267*fae548d3Szrj }
2268*fae548d3Szrj }
2269*fae548d3Szrj
2270*fae548d3Szrj minfo (_("\nMemory Configuration\n\n"));
2271*fae548d3Szrj fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
2272*fae548d3Szrj _("Name"), _("Origin"), _("Length"), _("Attributes"));
2273*fae548d3Szrj
2274*fae548d3Szrj for (m = lang_memory_region_list; m != NULL; m = m->next)
2275*fae548d3Szrj {
2276*fae548d3Szrj char buf[100];
2277*fae548d3Szrj int len;
2278*fae548d3Szrj
2279*fae548d3Szrj fprintf (config.map_file, "%-16s ", m->name_list.name);
2280*fae548d3Szrj
2281*fae548d3Szrj sprintf_vma (buf, m->origin);
2282*fae548d3Szrj minfo ("0x%s ", buf);
2283*fae548d3Szrj len = strlen (buf);
2284*fae548d3Szrj while (len < 16)
2285*fae548d3Szrj {
2286*fae548d3Szrj print_space ();
2287*fae548d3Szrj ++len;
2288*fae548d3Szrj }
2289*fae548d3Szrj
2290*fae548d3Szrj minfo ("0x%V", m->length);
2291*fae548d3Szrj if (m->flags || m->not_flags)
2292*fae548d3Szrj {
2293*fae548d3Szrj #ifndef BFD64
2294*fae548d3Szrj minfo (" ");
2295*fae548d3Szrj #endif
2296*fae548d3Szrj if (m->flags)
2297*fae548d3Szrj {
2298*fae548d3Szrj print_space ();
2299*fae548d3Szrj lang_map_flags (m->flags);
2300*fae548d3Szrj }
2301*fae548d3Szrj
2302*fae548d3Szrj if (m->not_flags)
2303*fae548d3Szrj {
2304*fae548d3Szrj minfo (" !");
2305*fae548d3Szrj lang_map_flags (m->not_flags);
2306*fae548d3Szrj }
2307*fae548d3Szrj }
2308*fae548d3Szrj
2309*fae548d3Szrj print_nl ();
2310*fae548d3Szrj }
2311*fae548d3Szrj
2312*fae548d3Szrj fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
2313*fae548d3Szrj
2314*fae548d3Szrj if (!link_info.reduce_memory_overheads)
2315*fae548d3Szrj {
2316*fae548d3Szrj obstack_begin (&map_obstack, 1000);
2317*fae548d3Szrj bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
2318*fae548d3Szrj }
2319*fae548d3Szrj expld.phase = lang_fixed_phase_enum;
2320*fae548d3Szrj lang_statement_iteration++;
2321*fae548d3Szrj print_statements ();
2322*fae548d3Szrj
2323*fae548d3Szrj ldemul_extra_map_file_text (link_info.output_bfd, &link_info,
2324*fae548d3Szrj config.map_file);
2325*fae548d3Szrj }
2326*fae548d3Szrj
2327*fae548d3Szrj static bfd_boolean
sort_def_symbol(struct bfd_link_hash_entry * hash_entry,void * info ATTRIBUTE_UNUSED)2328*fae548d3Szrj sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
2329*fae548d3Szrj void *info ATTRIBUTE_UNUSED)
2330*fae548d3Szrj {
2331*fae548d3Szrj if ((hash_entry->type == bfd_link_hash_defined
2332*fae548d3Szrj || hash_entry->type == bfd_link_hash_defweak)
2333*fae548d3Szrj && hash_entry->u.def.section->owner != link_info.output_bfd
2334*fae548d3Szrj && hash_entry->u.def.section->owner != NULL)
2335*fae548d3Szrj {
2336*fae548d3Szrj input_section_userdata_type *ud;
2337*fae548d3Szrj struct map_symbol_def *def;
2338*fae548d3Szrj
2339*fae548d3Szrj ud = bfd_section_userdata (hash_entry->u.def.section);
2340*fae548d3Szrj if (!ud)
2341*fae548d3Szrj {
2342*fae548d3Szrj ud = stat_alloc (sizeof (*ud));
2343*fae548d3Szrj bfd_set_section_userdata (hash_entry->u.def.section, ud);
2344*fae548d3Szrj ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2345*fae548d3Szrj ud->map_symbol_def_count = 0;
2346*fae548d3Szrj }
2347*fae548d3Szrj else if (!ud->map_symbol_def_tail)
2348*fae548d3Szrj ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2349*fae548d3Szrj
2350*fae548d3Szrj def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def);
2351*fae548d3Szrj def->entry = hash_entry;
2352*fae548d3Szrj *(ud->map_symbol_def_tail) = def;
2353*fae548d3Szrj ud->map_symbol_def_tail = &def->next;
2354*fae548d3Szrj ud->map_symbol_def_count++;
2355*fae548d3Szrj }
2356*fae548d3Szrj return TRUE;
2357*fae548d3Szrj }
2358*fae548d3Szrj
2359*fae548d3Szrj /* Initialize an output section. */
2360*fae548d3Szrj
2361*fae548d3Szrj static void
init_os(lang_output_section_statement_type * s,flagword flags)2362*fae548d3Szrj init_os (lang_output_section_statement_type *s, flagword flags)
2363*fae548d3Szrj {
2364*fae548d3Szrj if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
2365*fae548d3Szrj einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2366*fae548d3Szrj
2367*fae548d3Szrj if (s->constraint != SPECIAL)
2368*fae548d3Szrj s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2369*fae548d3Szrj if (s->bfd_section == NULL)
2370*fae548d3Szrj s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2371*fae548d3Szrj s->name, flags);
2372*fae548d3Szrj if (s->bfd_section == NULL)
2373*fae548d3Szrj {
2374*fae548d3Szrj einfo (_("%F%P: output format %s cannot represent section"
2375*fae548d3Szrj " called %s: %E\n"),
2376*fae548d3Szrj link_info.output_bfd->xvec->name, s->name);
2377*fae548d3Szrj }
2378*fae548d3Szrj s->bfd_section->output_section = s->bfd_section;
2379*fae548d3Szrj s->bfd_section->output_offset = 0;
2380*fae548d3Szrj
2381*fae548d3Szrj /* Set the userdata of the output section to the output section
2382*fae548d3Szrj statement to avoid lookup. */
2383*fae548d3Szrj bfd_set_section_userdata (s->bfd_section, s);
2384*fae548d3Szrj
2385*fae548d3Szrj /* If there is a base address, make sure that any sections it might
2386*fae548d3Szrj mention are initialized. */
2387*fae548d3Szrj if (s->addr_tree != NULL)
2388*fae548d3Szrj exp_init_os (s->addr_tree);
2389*fae548d3Szrj
2390*fae548d3Szrj if (s->load_base != NULL)
2391*fae548d3Szrj exp_init_os (s->load_base);
2392*fae548d3Szrj
2393*fae548d3Szrj /* If supplied an alignment, set it. */
2394*fae548d3Szrj if (s->section_alignment != NULL)
2395*fae548d3Szrj s->bfd_section->alignment_power = exp_get_power (s->section_alignment,
2396*fae548d3Szrj "section alignment");
2397*fae548d3Szrj }
2398*fae548d3Szrj
2399*fae548d3Szrj /* Make sure that all output sections mentioned in an expression are
2400*fae548d3Szrj initialized. */
2401*fae548d3Szrj
2402*fae548d3Szrj static void
exp_init_os(etree_type * exp)2403*fae548d3Szrj exp_init_os (etree_type *exp)
2404*fae548d3Szrj {
2405*fae548d3Szrj switch (exp->type.node_class)
2406*fae548d3Szrj {
2407*fae548d3Szrj case etree_assign:
2408*fae548d3Szrj case etree_provide:
2409*fae548d3Szrj case etree_provided:
2410*fae548d3Szrj exp_init_os (exp->assign.src);
2411*fae548d3Szrj break;
2412*fae548d3Szrj
2413*fae548d3Szrj case etree_binary:
2414*fae548d3Szrj exp_init_os (exp->binary.lhs);
2415*fae548d3Szrj exp_init_os (exp->binary.rhs);
2416*fae548d3Szrj break;
2417*fae548d3Szrj
2418*fae548d3Szrj case etree_trinary:
2419*fae548d3Szrj exp_init_os (exp->trinary.cond);
2420*fae548d3Szrj exp_init_os (exp->trinary.lhs);
2421*fae548d3Szrj exp_init_os (exp->trinary.rhs);
2422*fae548d3Szrj break;
2423*fae548d3Szrj
2424*fae548d3Szrj case etree_assert:
2425*fae548d3Szrj exp_init_os (exp->assert_s.child);
2426*fae548d3Szrj break;
2427*fae548d3Szrj
2428*fae548d3Szrj case etree_unary:
2429*fae548d3Szrj exp_init_os (exp->unary.child);
2430*fae548d3Szrj break;
2431*fae548d3Szrj
2432*fae548d3Szrj case etree_name:
2433*fae548d3Szrj switch (exp->type.node_code)
2434*fae548d3Szrj {
2435*fae548d3Szrj case ADDR:
2436*fae548d3Szrj case LOADADDR:
2437*fae548d3Szrj case SIZEOF:
2438*fae548d3Szrj {
2439*fae548d3Szrj lang_output_section_statement_type *os;
2440*fae548d3Szrj
2441*fae548d3Szrj os = lang_output_section_find (exp->name.name);
2442*fae548d3Szrj if (os != NULL && os->bfd_section == NULL)
2443*fae548d3Szrj init_os (os, 0);
2444*fae548d3Szrj }
2445*fae548d3Szrj }
2446*fae548d3Szrj break;
2447*fae548d3Szrj
2448*fae548d3Szrj default:
2449*fae548d3Szrj break;
2450*fae548d3Szrj }
2451*fae548d3Szrj }
2452*fae548d3Szrj
2453*fae548d3Szrj static void
section_already_linked(bfd * abfd,asection * sec,void * data)2454*fae548d3Szrj section_already_linked (bfd *abfd, asection *sec, void *data)
2455*fae548d3Szrj {
2456*fae548d3Szrj lang_input_statement_type *entry = (lang_input_statement_type *) data;
2457*fae548d3Szrj
2458*fae548d3Szrj /* If we are only reading symbols from this object, then we want to
2459*fae548d3Szrj discard all sections. */
2460*fae548d3Szrj if (entry->flags.just_syms)
2461*fae548d3Szrj {
2462*fae548d3Szrj bfd_link_just_syms (abfd, sec, &link_info);
2463*fae548d3Szrj return;
2464*fae548d3Szrj }
2465*fae548d3Szrj
2466*fae548d3Szrj /* Deal with SHF_EXCLUDE ELF sections. */
2467*fae548d3Szrj if (!bfd_link_relocatable (&link_info)
2468*fae548d3Szrj && (abfd->flags & BFD_PLUGIN) == 0
2469*fae548d3Szrj && (sec->flags & (SEC_GROUP | SEC_KEEP | SEC_EXCLUDE)) == SEC_EXCLUDE)
2470*fae548d3Szrj sec->output_section = bfd_abs_section_ptr;
2471*fae548d3Szrj
2472*fae548d3Szrj if (!(abfd->flags & DYNAMIC))
2473*fae548d3Szrj bfd_section_already_linked (abfd, sec, &link_info);
2474*fae548d3Szrj }
2475*fae548d3Szrj
2476*fae548d3Szrj
2477*fae548d3Szrj /* Returns true if SECTION is one we know will be discarded based on its
2478*fae548d3Szrj section flags, otherwise returns false. */
2479*fae548d3Szrj
2480*fae548d3Szrj static bfd_boolean
lang_discard_section_p(asection * section)2481*fae548d3Szrj lang_discard_section_p (asection *section)
2482*fae548d3Szrj {
2483*fae548d3Szrj bfd_boolean discard;
2484*fae548d3Szrj flagword flags = section->flags;
2485*fae548d3Szrj
2486*fae548d3Szrj /* Discard sections marked with SEC_EXCLUDE. */
2487*fae548d3Szrj discard = (flags & SEC_EXCLUDE) != 0;
2488*fae548d3Szrj
2489*fae548d3Szrj /* Discard the group descriptor sections when we're finally placing the
2490*fae548d3Szrj sections from within the group. */
2491*fae548d3Szrj if ((flags & SEC_GROUP) != 0
2492*fae548d3Szrj && link_info.resolve_section_groups)
2493*fae548d3Szrj discard = TRUE;
2494*fae548d3Szrj
2495*fae548d3Szrj /* Discard debugging sections if we are stripping debugging
2496*fae548d3Szrj information. */
2497*fae548d3Szrj if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2498*fae548d3Szrj && (flags & SEC_DEBUGGING) != 0)
2499*fae548d3Szrj discard = TRUE;
2500*fae548d3Szrj
2501*fae548d3Szrj return discard;
2502*fae548d3Szrj }
2503*fae548d3Szrj
2504*fae548d3Szrj /* The wild routines.
2505*fae548d3Szrj
2506*fae548d3Szrj These expand statements like *(.text) and foo.o to a list of
2507*fae548d3Szrj explicit actions, like foo.o(.text), bar.o(.text) and
2508*fae548d3Szrj foo.o(.text, .data). */
2509*fae548d3Szrj
2510*fae548d3Szrj /* Add SECTION to the output section OUTPUT. Do this by creating a
2511*fae548d3Szrj lang_input_section statement which is placed at PTR. */
2512*fae548d3Szrj
2513*fae548d3Szrj void
lang_add_section(lang_statement_list_type * ptr,asection * section,struct flag_info * sflag_info,lang_output_section_statement_type * output)2514*fae548d3Szrj lang_add_section (lang_statement_list_type *ptr,
2515*fae548d3Szrj asection *section,
2516*fae548d3Szrj struct flag_info *sflag_info,
2517*fae548d3Szrj lang_output_section_statement_type *output)
2518*fae548d3Szrj {
2519*fae548d3Szrj flagword flags = section->flags;
2520*fae548d3Szrj
2521*fae548d3Szrj bfd_boolean discard;
2522*fae548d3Szrj lang_input_section_type *new_section;
2523*fae548d3Szrj bfd *abfd = link_info.output_bfd;
2524*fae548d3Szrj
2525*fae548d3Szrj /* Is this section one we know should be discarded? */
2526*fae548d3Szrj discard = lang_discard_section_p (section);
2527*fae548d3Szrj
2528*fae548d3Szrj /* Discard input sections which are assigned to a section named
2529*fae548d3Szrj DISCARD_SECTION_NAME. */
2530*fae548d3Szrj if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2531*fae548d3Szrj discard = TRUE;
2532*fae548d3Szrj
2533*fae548d3Szrj if (discard)
2534*fae548d3Szrj {
2535*fae548d3Szrj if (section->output_section == NULL)
2536*fae548d3Szrj {
2537*fae548d3Szrj /* This prevents future calls from assigning this section. */
2538*fae548d3Szrj section->output_section = bfd_abs_section_ptr;
2539*fae548d3Szrj }
2540*fae548d3Szrj return;
2541*fae548d3Szrj }
2542*fae548d3Szrj
2543*fae548d3Szrj if (sflag_info)
2544*fae548d3Szrj {
2545*fae548d3Szrj bfd_boolean keep;
2546*fae548d3Szrj
2547*fae548d3Szrj keep = bfd_lookup_section_flags (&link_info, sflag_info, section);
2548*fae548d3Szrj if (!keep)
2549*fae548d3Szrj return;
2550*fae548d3Szrj }
2551*fae548d3Szrj
2552*fae548d3Szrj if (section->output_section != NULL)
2553*fae548d3Szrj return;
2554*fae548d3Szrj
2555*fae548d3Szrj /* We don't copy the SEC_NEVER_LOAD flag from an input section
2556*fae548d3Szrj to an output section, because we want to be able to include a
2557*fae548d3Szrj SEC_NEVER_LOAD section in the middle of an otherwise loaded
2558*fae548d3Szrj section (I don't know why we want to do this, but we do).
2559*fae548d3Szrj build_link_order in ldwrite.c handles this case by turning
2560*fae548d3Szrj the embedded SEC_NEVER_LOAD section into a fill. */
2561*fae548d3Szrj flags &= ~ SEC_NEVER_LOAD;
2562*fae548d3Szrj
2563*fae548d3Szrj /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2564*fae548d3Szrj already been processed. One reason to do this is that on pe
2565*fae548d3Szrj format targets, .text$foo sections go into .text and it's odd
2566*fae548d3Szrj to see .text with SEC_LINK_ONCE set. */
2567*fae548d3Szrj if ((flags & (SEC_LINK_ONCE | SEC_GROUP)) == (SEC_LINK_ONCE | SEC_GROUP))
2568*fae548d3Szrj {
2569*fae548d3Szrj if (link_info.resolve_section_groups)
2570*fae548d3Szrj flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2571*fae548d3Szrj else
2572*fae548d3Szrj flags &= ~(SEC_LINK_DUPLICATES | SEC_RELOC);
2573*fae548d3Szrj }
2574*fae548d3Szrj else if (!bfd_link_relocatable (&link_info))
2575*fae548d3Szrj flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2576*fae548d3Szrj
2577*fae548d3Szrj switch (output->sectype)
2578*fae548d3Szrj {
2579*fae548d3Szrj case normal_section:
2580*fae548d3Szrj case overlay_section:
2581*fae548d3Szrj case first_overlay_section:
2582*fae548d3Szrj break;
2583*fae548d3Szrj case noalloc_section:
2584*fae548d3Szrj flags &= ~SEC_ALLOC;
2585*fae548d3Szrj break;
2586*fae548d3Szrj case noload_section:
2587*fae548d3Szrj flags &= ~SEC_LOAD;
2588*fae548d3Szrj flags |= SEC_NEVER_LOAD;
2589*fae548d3Szrj /* Unfortunately GNU ld has managed to evolve two different
2590*fae548d3Szrj meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2591*fae548d3Szrj alloc, no contents section. All others get a noload, noalloc
2592*fae548d3Szrj section. */
2593*fae548d3Szrj if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
2594*fae548d3Szrj flags &= ~SEC_HAS_CONTENTS;
2595*fae548d3Szrj else
2596*fae548d3Szrj flags &= ~SEC_ALLOC;
2597*fae548d3Szrj break;
2598*fae548d3Szrj }
2599*fae548d3Szrj
2600*fae548d3Szrj if (output->bfd_section == NULL)
2601*fae548d3Szrj init_os (output, flags);
2602*fae548d3Szrj
2603*fae548d3Szrj /* If SEC_READONLY is not set in the input section, then clear
2604*fae548d3Szrj it from the output section. */
2605*fae548d3Szrj output->bfd_section->flags &= flags | ~SEC_READONLY;
2606*fae548d3Szrj
2607*fae548d3Szrj if (output->bfd_section->linker_has_input)
2608*fae548d3Szrj {
2609*fae548d3Szrj /* Only set SEC_READONLY flag on the first input section. */
2610*fae548d3Szrj flags &= ~ SEC_READONLY;
2611*fae548d3Szrj
2612*fae548d3Szrj /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2613*fae548d3Szrj if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2614*fae548d3Szrj != (flags & (SEC_MERGE | SEC_STRINGS))
2615*fae548d3Szrj || ((flags & SEC_MERGE) != 0
2616*fae548d3Szrj && output->bfd_section->entsize != section->entsize))
2617*fae548d3Szrj {
2618*fae548d3Szrj output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2619*fae548d3Szrj flags &= ~ (SEC_MERGE | SEC_STRINGS);
2620*fae548d3Szrj }
2621*fae548d3Szrj }
2622*fae548d3Szrj output->bfd_section->flags |= flags;
2623*fae548d3Szrj
2624*fae548d3Szrj if (!output->bfd_section->linker_has_input)
2625*fae548d3Szrj {
2626*fae548d3Szrj output->bfd_section->linker_has_input = 1;
2627*fae548d3Szrj /* This must happen after flags have been updated. The output
2628*fae548d3Szrj section may have been created before we saw its first input
2629*fae548d3Szrj section, eg. for a data statement. */
2630*fae548d3Szrj bfd_init_private_section_data (section->owner, section,
2631*fae548d3Szrj link_info.output_bfd,
2632*fae548d3Szrj output->bfd_section,
2633*fae548d3Szrj &link_info);
2634*fae548d3Szrj if ((flags & SEC_MERGE) != 0)
2635*fae548d3Szrj output->bfd_section->entsize = section->entsize;
2636*fae548d3Szrj }
2637*fae548d3Szrj
2638*fae548d3Szrj if ((flags & SEC_TIC54X_BLOCK) != 0
2639*fae548d3Szrj && bfd_get_arch (section->owner) == bfd_arch_tic54x)
2640*fae548d3Szrj {
2641*fae548d3Szrj /* FIXME: This value should really be obtained from the bfd... */
2642*fae548d3Szrj output->block_value = 128;
2643*fae548d3Szrj }
2644*fae548d3Szrj
2645*fae548d3Szrj if (section->alignment_power > output->bfd_section->alignment_power)
2646*fae548d3Szrj output->bfd_section->alignment_power = section->alignment_power;
2647*fae548d3Szrj
2648*fae548d3Szrj section->output_section = output->bfd_section;
2649*fae548d3Szrj
2650*fae548d3Szrj if (!map_head_is_link_order)
2651*fae548d3Szrj {
2652*fae548d3Szrj asection *s = output->bfd_section->map_tail.s;
2653*fae548d3Szrj output->bfd_section->map_tail.s = section;
2654*fae548d3Szrj section->map_head.s = NULL;
2655*fae548d3Szrj section->map_tail.s = s;
2656*fae548d3Szrj if (s != NULL)
2657*fae548d3Szrj s->map_head.s = section;
2658*fae548d3Szrj else
2659*fae548d3Szrj output->bfd_section->map_head.s = section;
2660*fae548d3Szrj }
2661*fae548d3Szrj
2662*fae548d3Szrj /* Add a section reference to the list. */
2663*fae548d3Szrj new_section = new_stat (lang_input_section, ptr);
2664*fae548d3Szrj new_section->section = section;
2665*fae548d3Szrj }
2666*fae548d3Szrj
2667*fae548d3Szrj /* Handle wildcard sorting. This returns the lang_input_section which
2668*fae548d3Szrj should follow the one we are going to create for SECTION and FILE,
2669*fae548d3Szrj based on the sorting requirements of WILD. It returns NULL if the
2670*fae548d3Szrj new section should just go at the end of the current list. */
2671*fae548d3Szrj
2672*fae548d3Szrj static lang_statement_union_type *
wild_sort(lang_wild_statement_type * wild,struct wildcard_list * sec,lang_input_statement_type * file,asection * section)2673*fae548d3Szrj wild_sort (lang_wild_statement_type *wild,
2674*fae548d3Szrj struct wildcard_list *sec,
2675*fae548d3Szrj lang_input_statement_type *file,
2676*fae548d3Szrj asection *section)
2677*fae548d3Szrj {
2678*fae548d3Szrj lang_statement_union_type *l;
2679*fae548d3Szrj
2680*fae548d3Szrj if (!wild->filenames_sorted
2681*fae548d3Szrj && (sec == NULL || sec->spec.sorted == none))
2682*fae548d3Szrj return NULL;
2683*fae548d3Szrj
2684*fae548d3Szrj for (l = wild->children.head; l != NULL; l = l->header.next)
2685*fae548d3Szrj {
2686*fae548d3Szrj lang_input_section_type *ls;
2687*fae548d3Szrj
2688*fae548d3Szrj if (l->header.type != lang_input_section_enum)
2689*fae548d3Szrj continue;
2690*fae548d3Szrj ls = &l->input_section;
2691*fae548d3Szrj
2692*fae548d3Szrj /* Sorting by filename takes precedence over sorting by section
2693*fae548d3Szrj name. */
2694*fae548d3Szrj
2695*fae548d3Szrj if (wild->filenames_sorted)
2696*fae548d3Szrj {
2697*fae548d3Szrj const char *fn, *ln;
2698*fae548d3Szrj bfd_boolean fa, la;
2699*fae548d3Szrj int i;
2700*fae548d3Szrj
2701*fae548d3Szrj /* The PE support for the .idata section as generated by
2702*fae548d3Szrj dlltool assumes that files will be sorted by the name of
2703*fae548d3Szrj the archive and then the name of the file within the
2704*fae548d3Szrj archive. */
2705*fae548d3Szrj
2706*fae548d3Szrj if (file->the_bfd != NULL
2707*fae548d3Szrj && file->the_bfd->my_archive != NULL)
2708*fae548d3Szrj {
2709*fae548d3Szrj fn = bfd_get_filename (file->the_bfd->my_archive);
2710*fae548d3Szrj fa = TRUE;
2711*fae548d3Szrj }
2712*fae548d3Szrj else
2713*fae548d3Szrj {
2714*fae548d3Szrj fn = file->filename;
2715*fae548d3Szrj fa = FALSE;
2716*fae548d3Szrj }
2717*fae548d3Szrj
2718*fae548d3Szrj if (ls->section->owner->my_archive != NULL)
2719*fae548d3Szrj {
2720*fae548d3Szrj ln = bfd_get_filename (ls->section->owner->my_archive);
2721*fae548d3Szrj la = TRUE;
2722*fae548d3Szrj }
2723*fae548d3Szrj else
2724*fae548d3Szrj {
2725*fae548d3Szrj ln = ls->section->owner->filename;
2726*fae548d3Szrj la = FALSE;
2727*fae548d3Szrj }
2728*fae548d3Szrj
2729*fae548d3Szrj i = filename_cmp (fn, ln);
2730*fae548d3Szrj if (i > 0)
2731*fae548d3Szrj continue;
2732*fae548d3Szrj else if (i < 0)
2733*fae548d3Szrj break;
2734*fae548d3Szrj
2735*fae548d3Szrj if (fa || la)
2736*fae548d3Szrj {
2737*fae548d3Szrj if (fa)
2738*fae548d3Szrj fn = file->filename;
2739*fae548d3Szrj if (la)
2740*fae548d3Szrj ln = ls->section->owner->filename;
2741*fae548d3Szrj
2742*fae548d3Szrj i = filename_cmp (fn, ln);
2743*fae548d3Szrj if (i > 0)
2744*fae548d3Szrj continue;
2745*fae548d3Szrj else if (i < 0)
2746*fae548d3Szrj break;
2747*fae548d3Szrj }
2748*fae548d3Szrj }
2749*fae548d3Szrj
2750*fae548d3Szrj /* Here either the files are not sorted by name, or we are
2751*fae548d3Szrj looking at the sections for this file. */
2752*fae548d3Szrj
2753*fae548d3Szrj if (sec != NULL
2754*fae548d3Szrj && sec->spec.sorted != none
2755*fae548d3Szrj && sec->spec.sorted != by_none)
2756*fae548d3Szrj if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2757*fae548d3Szrj break;
2758*fae548d3Szrj }
2759*fae548d3Szrj
2760*fae548d3Szrj return l;
2761*fae548d3Szrj }
2762*fae548d3Szrj
2763*fae548d3Szrj /* Expand a wild statement for a particular FILE. SECTION may be
2764*fae548d3Szrj NULL, in which case it is a wild card. */
2765*fae548d3Szrj
2766*fae548d3Szrj static void
output_section_callback(lang_wild_statement_type * ptr,struct wildcard_list * sec,asection * section,struct flag_info * sflag_info,lang_input_statement_type * file,void * output)2767*fae548d3Szrj output_section_callback (lang_wild_statement_type *ptr,
2768*fae548d3Szrj struct wildcard_list *sec,
2769*fae548d3Szrj asection *section,
2770*fae548d3Szrj struct flag_info *sflag_info,
2771*fae548d3Szrj lang_input_statement_type *file,
2772*fae548d3Szrj void *output)
2773*fae548d3Szrj {
2774*fae548d3Szrj lang_statement_union_type *before;
2775*fae548d3Szrj lang_output_section_statement_type *os;
2776*fae548d3Szrj
2777*fae548d3Szrj os = (lang_output_section_statement_type *) output;
2778*fae548d3Szrj
2779*fae548d3Szrj /* Exclude sections that match UNIQUE_SECTION_LIST. */
2780*fae548d3Szrj if (unique_section_p (section, os))
2781*fae548d3Szrj return;
2782*fae548d3Szrj
2783*fae548d3Szrj before = wild_sort (ptr, sec, file, section);
2784*fae548d3Szrj
2785*fae548d3Szrj /* Here BEFORE points to the lang_input_section which
2786*fae548d3Szrj should follow the one we are about to add. If BEFORE
2787*fae548d3Szrj is NULL, then the section should just go at the end
2788*fae548d3Szrj of the current list. */
2789*fae548d3Szrj
2790*fae548d3Szrj if (before == NULL)
2791*fae548d3Szrj lang_add_section (&ptr->children, section, sflag_info, os);
2792*fae548d3Szrj else
2793*fae548d3Szrj {
2794*fae548d3Szrj lang_statement_list_type list;
2795*fae548d3Szrj lang_statement_union_type **pp;
2796*fae548d3Szrj
2797*fae548d3Szrj lang_list_init (&list);
2798*fae548d3Szrj lang_add_section (&list, section, sflag_info, os);
2799*fae548d3Szrj
2800*fae548d3Szrj /* If we are discarding the section, LIST.HEAD will
2801*fae548d3Szrj be NULL. */
2802*fae548d3Szrj if (list.head != NULL)
2803*fae548d3Szrj {
2804*fae548d3Szrj ASSERT (list.head->header.next == NULL);
2805*fae548d3Szrj
2806*fae548d3Szrj for (pp = &ptr->children.head;
2807*fae548d3Szrj *pp != before;
2808*fae548d3Szrj pp = &(*pp)->header.next)
2809*fae548d3Szrj ASSERT (*pp != NULL);
2810*fae548d3Szrj
2811*fae548d3Szrj list.head->header.next = *pp;
2812*fae548d3Szrj *pp = list.head;
2813*fae548d3Szrj }
2814*fae548d3Szrj }
2815*fae548d3Szrj }
2816*fae548d3Szrj
2817*fae548d3Szrj /* Check if all sections in a wild statement for a particular FILE
2818*fae548d3Szrj are readonly. */
2819*fae548d3Szrj
2820*fae548d3Szrj static void
check_section_callback(lang_wild_statement_type * ptr ATTRIBUTE_UNUSED,struct wildcard_list * sec ATTRIBUTE_UNUSED,asection * section,struct flag_info * sflag_info ATTRIBUTE_UNUSED,lang_input_statement_type * file ATTRIBUTE_UNUSED,void * output)2821*fae548d3Szrj check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2822*fae548d3Szrj struct wildcard_list *sec ATTRIBUTE_UNUSED,
2823*fae548d3Szrj asection *section,
2824*fae548d3Szrj struct flag_info *sflag_info ATTRIBUTE_UNUSED,
2825*fae548d3Szrj lang_input_statement_type *file ATTRIBUTE_UNUSED,
2826*fae548d3Szrj void *output)
2827*fae548d3Szrj {
2828*fae548d3Szrj lang_output_section_statement_type *os;
2829*fae548d3Szrj
2830*fae548d3Szrj os = (lang_output_section_statement_type *) output;
2831*fae548d3Szrj
2832*fae548d3Szrj /* Exclude sections that match UNIQUE_SECTION_LIST. */
2833*fae548d3Szrj if (unique_section_p (section, os))
2834*fae548d3Szrj return;
2835*fae548d3Szrj
2836*fae548d3Szrj if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2837*fae548d3Szrj os->all_input_readonly = FALSE;
2838*fae548d3Szrj }
2839*fae548d3Szrj
2840*fae548d3Szrj /* This is passed a file name which must have been seen already and
2841*fae548d3Szrj added to the statement tree. We will see if it has been opened
2842*fae548d3Szrj already and had its symbols read. If not then we'll read it. */
2843*fae548d3Szrj
2844*fae548d3Szrj static lang_input_statement_type *
lookup_name(const char * name)2845*fae548d3Szrj lookup_name (const char *name)
2846*fae548d3Szrj {
2847*fae548d3Szrj lang_input_statement_type *search;
2848*fae548d3Szrj
2849*fae548d3Szrj for (search = (void *) input_file_chain.head;
2850*fae548d3Szrj search != NULL;
2851*fae548d3Szrj search = search->next_real_file)
2852*fae548d3Szrj {
2853*fae548d3Szrj /* Use the local_sym_name as the name of the file that has
2854*fae548d3Szrj already been loaded as filename might have been transformed
2855*fae548d3Szrj via the search directory lookup mechanism. */
2856*fae548d3Szrj const char *filename = search->local_sym_name;
2857*fae548d3Szrj
2858*fae548d3Szrj if (filename != NULL
2859*fae548d3Szrj && filename_cmp (filename, name) == 0)
2860*fae548d3Szrj break;
2861*fae548d3Szrj }
2862*fae548d3Szrj
2863*fae548d3Szrj if (search == NULL)
2864*fae548d3Szrj {
2865*fae548d3Szrj /* Arrange to splice the input statement added by new_afile into
2866*fae548d3Szrj statement_list after the current input_file_chain tail.
2867*fae548d3Szrj We know input_file_chain is not an empty list, and that
2868*fae548d3Szrj lookup_name was called via open_input_bfds. Later calls to
2869*fae548d3Szrj lookup_name should always match an existing input_statement. */
2870*fae548d3Szrj lang_statement_union_type **tail = stat_ptr->tail;
2871*fae548d3Szrj lang_statement_union_type **after
2872*fae548d3Szrj = (void *) ((char *) input_file_chain.tail
2873*fae548d3Szrj - offsetof (lang_input_statement_type, next_real_file)
2874*fae548d3Szrj + offsetof (lang_input_statement_type, header.next));
2875*fae548d3Szrj lang_statement_union_type *rest = *after;
2876*fae548d3Szrj stat_ptr->tail = after;
2877*fae548d3Szrj search = new_afile (name, lang_input_file_is_search_file_enum,
2878*fae548d3Szrj default_target);
2879*fae548d3Szrj *stat_ptr->tail = rest;
2880*fae548d3Szrj if (*tail == NULL)
2881*fae548d3Szrj stat_ptr->tail = tail;
2882*fae548d3Szrj }
2883*fae548d3Szrj
2884*fae548d3Szrj /* If we have already added this file, or this file is not real
2885*fae548d3Szrj don't add this file. */
2886*fae548d3Szrj if (search->flags.loaded || !search->flags.real)
2887*fae548d3Szrj return search;
2888*fae548d3Szrj
2889*fae548d3Szrj if (!load_symbols (search, NULL))
2890*fae548d3Szrj return NULL;
2891*fae548d3Szrj
2892*fae548d3Szrj return search;
2893*fae548d3Szrj }
2894*fae548d3Szrj
2895*fae548d3Szrj /* Save LIST as a list of libraries whose symbols should not be exported. */
2896*fae548d3Szrj
2897*fae548d3Szrj struct excluded_lib
2898*fae548d3Szrj {
2899*fae548d3Szrj char *name;
2900*fae548d3Szrj struct excluded_lib *next;
2901*fae548d3Szrj };
2902*fae548d3Szrj static struct excluded_lib *excluded_libs;
2903*fae548d3Szrj
2904*fae548d3Szrj void
add_excluded_libs(const char * list)2905*fae548d3Szrj add_excluded_libs (const char *list)
2906*fae548d3Szrj {
2907*fae548d3Szrj const char *p = list, *end;
2908*fae548d3Szrj
2909*fae548d3Szrj while (*p != '\0')
2910*fae548d3Szrj {
2911*fae548d3Szrj struct excluded_lib *entry;
2912*fae548d3Szrj end = strpbrk (p, ",:");
2913*fae548d3Szrj if (end == NULL)
2914*fae548d3Szrj end = p + strlen (p);
2915*fae548d3Szrj entry = (struct excluded_lib *) xmalloc (sizeof (*entry));
2916*fae548d3Szrj entry->next = excluded_libs;
2917*fae548d3Szrj entry->name = (char *) xmalloc (end - p + 1);
2918*fae548d3Szrj memcpy (entry->name, p, end - p);
2919*fae548d3Szrj entry->name[end - p] = '\0';
2920*fae548d3Szrj excluded_libs = entry;
2921*fae548d3Szrj if (*end == '\0')
2922*fae548d3Szrj break;
2923*fae548d3Szrj p = end + 1;
2924*fae548d3Szrj }
2925*fae548d3Szrj }
2926*fae548d3Szrj
2927*fae548d3Szrj static void
check_excluded_libs(bfd * abfd)2928*fae548d3Szrj check_excluded_libs (bfd *abfd)
2929*fae548d3Szrj {
2930*fae548d3Szrj struct excluded_lib *lib = excluded_libs;
2931*fae548d3Szrj
2932*fae548d3Szrj while (lib)
2933*fae548d3Szrj {
2934*fae548d3Szrj int len = strlen (lib->name);
2935*fae548d3Szrj const char *filename = lbasename (abfd->filename);
2936*fae548d3Szrj
2937*fae548d3Szrj if (strcmp (lib->name, "ALL") == 0)
2938*fae548d3Szrj {
2939*fae548d3Szrj abfd->no_export = TRUE;
2940*fae548d3Szrj return;
2941*fae548d3Szrj }
2942*fae548d3Szrj
2943*fae548d3Szrj if (filename_ncmp (lib->name, filename, len) == 0
2944*fae548d3Szrj && (filename[len] == '\0'
2945*fae548d3Szrj || (filename[len] == '.' && filename[len + 1] == 'a'
2946*fae548d3Szrj && filename[len + 2] == '\0')))
2947*fae548d3Szrj {
2948*fae548d3Szrj abfd->no_export = TRUE;
2949*fae548d3Szrj return;
2950*fae548d3Szrj }
2951*fae548d3Szrj
2952*fae548d3Szrj lib = lib->next;
2953*fae548d3Szrj }
2954*fae548d3Szrj }
2955*fae548d3Szrj
2956*fae548d3Szrj /* Get the symbols for an input file. */
2957*fae548d3Szrj
2958*fae548d3Szrj bfd_boolean
load_symbols(lang_input_statement_type * entry,lang_statement_list_type * place)2959*fae548d3Szrj load_symbols (lang_input_statement_type *entry,
2960*fae548d3Szrj lang_statement_list_type *place)
2961*fae548d3Szrj {
2962*fae548d3Szrj char **matching;
2963*fae548d3Szrj
2964*fae548d3Szrj if (entry->flags.loaded)
2965*fae548d3Szrj return TRUE;
2966*fae548d3Szrj
2967*fae548d3Szrj ldfile_open_file (entry);
2968*fae548d3Szrj
2969*fae548d3Szrj /* Do not process further if the file was missing. */
2970*fae548d3Szrj if (entry->flags.missing_file)
2971*fae548d3Szrj return TRUE;
2972*fae548d3Szrj
2973*fae548d3Szrj if (trace_files || verbose)
2974*fae548d3Szrj info_msg ("%pI\n", entry);
2975*fae548d3Szrj
2976*fae548d3Szrj if (!bfd_check_format (entry->the_bfd, bfd_archive)
2977*fae548d3Szrj && !bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2978*fae548d3Szrj {
2979*fae548d3Szrj bfd_error_type err;
2980*fae548d3Szrj struct lang_input_statement_flags save_flags;
2981*fae548d3Szrj extern FILE *yyin;
2982*fae548d3Szrj
2983*fae548d3Szrj err = bfd_get_error ();
2984*fae548d3Szrj
2985*fae548d3Szrj /* See if the emulation has some special knowledge. */
2986*fae548d3Szrj if (ldemul_unrecognized_file (entry))
2987*fae548d3Szrj return TRUE;
2988*fae548d3Szrj
2989*fae548d3Szrj if (err == bfd_error_file_ambiguously_recognized)
2990*fae548d3Szrj {
2991*fae548d3Szrj char **p;
2992*fae548d3Szrj
2993*fae548d3Szrj einfo (_("%P: %pB: file not recognized: %E;"
2994*fae548d3Szrj " matching formats:"), entry->the_bfd);
2995*fae548d3Szrj for (p = matching; *p != NULL; p++)
2996*fae548d3Szrj einfo (" %s", *p);
2997*fae548d3Szrj einfo ("%F\n");
2998*fae548d3Szrj }
2999*fae548d3Szrj else if (err != bfd_error_file_not_recognized
3000*fae548d3Szrj || place == NULL)
3001*fae548d3Szrj einfo (_("%F%P: %pB: file not recognized: %E\n"), entry->the_bfd);
3002*fae548d3Szrj
3003*fae548d3Szrj bfd_close (entry->the_bfd);
3004*fae548d3Szrj entry->the_bfd = NULL;
3005*fae548d3Szrj
3006*fae548d3Szrj /* Try to interpret the file as a linker script. */
3007*fae548d3Szrj save_flags = input_flags;
3008*fae548d3Szrj ldfile_open_command_file (entry->filename);
3009*fae548d3Szrj
3010*fae548d3Szrj push_stat_ptr (place);
3011*fae548d3Szrj input_flags.add_DT_NEEDED_for_regular
3012*fae548d3Szrj = entry->flags.add_DT_NEEDED_for_regular;
3013*fae548d3Szrj input_flags.add_DT_NEEDED_for_dynamic
3014*fae548d3Szrj = entry->flags.add_DT_NEEDED_for_dynamic;
3015*fae548d3Szrj input_flags.whole_archive = entry->flags.whole_archive;
3016*fae548d3Szrj input_flags.dynamic = entry->flags.dynamic;
3017*fae548d3Szrj
3018*fae548d3Szrj ldfile_assumed_script = TRUE;
3019*fae548d3Szrj parser_input = input_script;
3020*fae548d3Szrj yyparse ();
3021*fae548d3Szrj ldfile_assumed_script = FALSE;
3022*fae548d3Szrj
3023*fae548d3Szrj /* missing_file is sticky. sysrooted will already have been
3024*fae548d3Szrj restored when seeing EOF in yyparse, but no harm to restore
3025*fae548d3Szrj again. */
3026*fae548d3Szrj save_flags.missing_file |= input_flags.missing_file;
3027*fae548d3Szrj input_flags = save_flags;
3028*fae548d3Szrj pop_stat_ptr ();
3029*fae548d3Szrj fclose (yyin);
3030*fae548d3Szrj yyin = NULL;
3031*fae548d3Szrj entry->flags.loaded = TRUE;
3032*fae548d3Szrj
3033*fae548d3Szrj return TRUE;
3034*fae548d3Szrj }
3035*fae548d3Szrj
3036*fae548d3Szrj if (ldemul_recognized_file (entry))
3037*fae548d3Szrj return TRUE;
3038*fae548d3Szrj
3039*fae548d3Szrj /* We don't call ldlang_add_file for an archive. Instead, the
3040*fae548d3Szrj add_symbols entry point will call ldlang_add_file, via the
3041*fae548d3Szrj add_archive_element callback, for each element of the archive
3042*fae548d3Szrj which is used. */
3043*fae548d3Szrj switch (bfd_get_format (entry->the_bfd))
3044*fae548d3Szrj {
3045*fae548d3Szrj default:
3046*fae548d3Szrj break;
3047*fae548d3Szrj
3048*fae548d3Szrj case bfd_object:
3049*fae548d3Szrj if (!entry->flags.reload)
3050*fae548d3Szrj ldlang_add_file (entry);
3051*fae548d3Szrj break;
3052*fae548d3Szrj
3053*fae548d3Szrj case bfd_archive:
3054*fae548d3Szrj check_excluded_libs (entry->the_bfd);
3055*fae548d3Szrj
3056*fae548d3Szrj bfd_set_usrdata (entry->the_bfd, entry);
3057*fae548d3Szrj if (entry->flags.whole_archive)
3058*fae548d3Szrj {
3059*fae548d3Szrj bfd *member = NULL;
3060*fae548d3Szrj bfd_boolean loaded = TRUE;
3061*fae548d3Szrj
3062*fae548d3Szrj for (;;)
3063*fae548d3Szrj {
3064*fae548d3Szrj bfd *subsbfd;
3065*fae548d3Szrj member = bfd_openr_next_archived_file (entry->the_bfd, member);
3066*fae548d3Szrj
3067*fae548d3Szrj if (member == NULL)
3068*fae548d3Szrj break;
3069*fae548d3Szrj
3070*fae548d3Szrj if (!bfd_check_format (member, bfd_object))
3071*fae548d3Szrj {
3072*fae548d3Szrj einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3073*fae548d3Szrj entry->the_bfd, member);
3074*fae548d3Szrj loaded = FALSE;
3075*fae548d3Szrj }
3076*fae548d3Szrj
3077*fae548d3Szrj subsbfd = member;
3078*fae548d3Szrj if (!(*link_info.callbacks
3079*fae548d3Szrj ->add_archive_element) (&link_info, member,
3080*fae548d3Szrj "--whole-archive", &subsbfd))
3081*fae548d3Szrj abort ();
3082*fae548d3Szrj
3083*fae548d3Szrj /* Potentially, the add_archive_element hook may have set a
3084*fae548d3Szrj substitute BFD for us. */
3085*fae548d3Szrj if (!bfd_link_add_symbols (subsbfd, &link_info))
3086*fae548d3Szrj {
3087*fae548d3Szrj einfo (_("%F%P: %pB: error adding symbols: %E\n"), member);
3088*fae548d3Szrj loaded = FALSE;
3089*fae548d3Szrj }
3090*fae548d3Szrj }
3091*fae548d3Szrj
3092*fae548d3Szrj entry->flags.loaded = loaded;
3093*fae548d3Szrj return loaded;
3094*fae548d3Szrj }
3095*fae548d3Szrj break;
3096*fae548d3Szrj }
3097*fae548d3Szrj
3098*fae548d3Szrj if (bfd_link_add_symbols (entry->the_bfd, &link_info))
3099*fae548d3Szrj entry->flags.loaded = TRUE;
3100*fae548d3Szrj else
3101*fae548d3Szrj einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry->the_bfd);
3102*fae548d3Szrj
3103*fae548d3Szrj return entry->flags.loaded;
3104*fae548d3Szrj }
3105*fae548d3Szrj
3106*fae548d3Szrj /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3107*fae548d3Szrj may be NULL, indicating that it is a wildcard. Separate
3108*fae548d3Szrj lang_input_section statements are created for each part of the
3109*fae548d3Szrj expansion; they are added after the wild statement S. OUTPUT is
3110*fae548d3Szrj the output section. */
3111*fae548d3Szrj
3112*fae548d3Szrj static void
wild(lang_wild_statement_type * s,const char * target ATTRIBUTE_UNUSED,lang_output_section_statement_type * output)3113*fae548d3Szrj wild (lang_wild_statement_type *s,
3114*fae548d3Szrj const char *target ATTRIBUTE_UNUSED,
3115*fae548d3Szrj lang_output_section_statement_type *output)
3116*fae548d3Szrj {
3117*fae548d3Szrj struct wildcard_list *sec;
3118*fae548d3Szrj
3119*fae548d3Szrj if (s->handler_data[0]
3120*fae548d3Szrj && s->handler_data[0]->spec.sorted == by_name
3121*fae548d3Szrj && !s->filenames_sorted)
3122*fae548d3Szrj {
3123*fae548d3Szrj lang_section_bst_type *tree;
3124*fae548d3Szrj
3125*fae548d3Szrj walk_wild (s, output_section_callback_fast, output);
3126*fae548d3Szrj
3127*fae548d3Szrj tree = s->tree;
3128*fae548d3Szrj if (tree)
3129*fae548d3Szrj {
3130*fae548d3Szrj output_section_callback_tree_to_list (s, tree, output);
3131*fae548d3Szrj s->tree = NULL;
3132*fae548d3Szrj }
3133*fae548d3Szrj }
3134*fae548d3Szrj else
3135*fae548d3Szrj walk_wild (s, output_section_callback, output);
3136*fae548d3Szrj
3137*fae548d3Szrj if (default_common_section == NULL)
3138*fae548d3Szrj for (sec = s->section_list; sec != NULL; sec = sec->next)
3139*fae548d3Szrj if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
3140*fae548d3Szrj {
3141*fae548d3Szrj /* Remember the section that common is going to in case we
3142*fae548d3Szrj later get something which doesn't know where to put it. */
3143*fae548d3Szrj default_common_section = output;
3144*fae548d3Szrj break;
3145*fae548d3Szrj }
3146*fae548d3Szrj }
3147*fae548d3Szrj
3148*fae548d3Szrj /* Return TRUE iff target is the sought target. */
3149*fae548d3Szrj
3150*fae548d3Szrj static int
get_target(const bfd_target * target,void * data)3151*fae548d3Szrj get_target (const bfd_target *target, void *data)
3152*fae548d3Szrj {
3153*fae548d3Szrj const char *sought = (const char *) data;
3154*fae548d3Szrj
3155*fae548d3Szrj return strcmp (target->name, sought) == 0;
3156*fae548d3Szrj }
3157*fae548d3Szrj
3158*fae548d3Szrj /* Like strcpy() but convert to lower case as well. */
3159*fae548d3Szrj
3160*fae548d3Szrj static void
stricpy(char * dest,const char * src)3161*fae548d3Szrj stricpy (char *dest, const char *src)
3162*fae548d3Szrj {
3163*fae548d3Szrj char c;
3164*fae548d3Szrj
3165*fae548d3Szrj while ((c = *src++) != 0)
3166*fae548d3Szrj *dest++ = TOLOWER (c);
3167*fae548d3Szrj
3168*fae548d3Szrj *dest = 0;
3169*fae548d3Szrj }
3170*fae548d3Szrj
3171*fae548d3Szrj /* Remove the first occurrence of needle (if any) in haystack
3172*fae548d3Szrj from haystack. */
3173*fae548d3Szrj
3174*fae548d3Szrj static void
strcut(char * haystack,const char * needle)3175*fae548d3Szrj strcut (char *haystack, const char *needle)
3176*fae548d3Szrj {
3177*fae548d3Szrj haystack = strstr (haystack, needle);
3178*fae548d3Szrj
3179*fae548d3Szrj if (haystack)
3180*fae548d3Szrj {
3181*fae548d3Szrj char *src;
3182*fae548d3Szrj
3183*fae548d3Szrj for (src = haystack + strlen (needle); *src;)
3184*fae548d3Szrj *haystack++ = *src++;
3185*fae548d3Szrj
3186*fae548d3Szrj *haystack = 0;
3187*fae548d3Szrj }
3188*fae548d3Szrj }
3189*fae548d3Szrj
3190*fae548d3Szrj /* Compare two target format name strings.
3191*fae548d3Szrj Return a value indicating how "similar" they are. */
3192*fae548d3Szrj
3193*fae548d3Szrj static int
name_compare(const char * first,const char * second)3194*fae548d3Szrj name_compare (const char *first, const char *second)
3195*fae548d3Szrj {
3196*fae548d3Szrj char *copy1;
3197*fae548d3Szrj char *copy2;
3198*fae548d3Szrj int result;
3199*fae548d3Szrj
3200*fae548d3Szrj copy1 = (char *) xmalloc (strlen (first) + 1);
3201*fae548d3Szrj copy2 = (char *) xmalloc (strlen (second) + 1);
3202*fae548d3Szrj
3203*fae548d3Szrj /* Convert the names to lower case. */
3204*fae548d3Szrj stricpy (copy1, first);
3205*fae548d3Szrj stricpy (copy2, second);
3206*fae548d3Szrj
3207*fae548d3Szrj /* Remove size and endian strings from the name. */
3208*fae548d3Szrj strcut (copy1, "big");
3209*fae548d3Szrj strcut (copy1, "little");
3210*fae548d3Szrj strcut (copy2, "big");
3211*fae548d3Szrj strcut (copy2, "little");
3212*fae548d3Szrj
3213*fae548d3Szrj /* Return a value based on how many characters match,
3214*fae548d3Szrj starting from the beginning. If both strings are
3215*fae548d3Szrj the same then return 10 * their length. */
3216*fae548d3Szrj for (result = 0; copy1[result] == copy2[result]; result++)
3217*fae548d3Szrj if (copy1[result] == 0)
3218*fae548d3Szrj {
3219*fae548d3Szrj result *= 10;
3220*fae548d3Szrj break;
3221*fae548d3Szrj }
3222*fae548d3Szrj
3223*fae548d3Szrj free (copy1);
3224*fae548d3Szrj free (copy2);
3225*fae548d3Szrj
3226*fae548d3Szrj return result;
3227*fae548d3Szrj }
3228*fae548d3Szrj
3229*fae548d3Szrj /* Set by closest_target_match() below. */
3230*fae548d3Szrj static const bfd_target *winner;
3231*fae548d3Szrj
3232*fae548d3Szrj /* Scan all the valid bfd targets looking for one that has the endianness
3233*fae548d3Szrj requirement that was specified on the command line, and is the nearest
3234*fae548d3Szrj match to the original output target. */
3235*fae548d3Szrj
3236*fae548d3Szrj static int
closest_target_match(const bfd_target * target,void * data)3237*fae548d3Szrj closest_target_match (const bfd_target *target, void *data)
3238*fae548d3Szrj {
3239*fae548d3Szrj const bfd_target *original = (const bfd_target *) data;
3240*fae548d3Szrj
3241*fae548d3Szrj if (command_line.endian == ENDIAN_BIG
3242*fae548d3Szrj && target->byteorder != BFD_ENDIAN_BIG)
3243*fae548d3Szrj return 0;
3244*fae548d3Szrj
3245*fae548d3Szrj if (command_line.endian == ENDIAN_LITTLE
3246*fae548d3Szrj && target->byteorder != BFD_ENDIAN_LITTLE)
3247*fae548d3Szrj return 0;
3248*fae548d3Szrj
3249*fae548d3Szrj /* Must be the same flavour. */
3250*fae548d3Szrj if (target->flavour != original->flavour)
3251*fae548d3Szrj return 0;
3252*fae548d3Szrj
3253*fae548d3Szrj /* Ignore generic big and little endian elf vectors. */
3254*fae548d3Szrj if (strcmp (target->name, "elf32-big") == 0
3255*fae548d3Szrj || strcmp (target->name, "elf64-big") == 0
3256*fae548d3Szrj || strcmp (target->name, "elf32-little") == 0
3257*fae548d3Szrj || strcmp (target->name, "elf64-little") == 0)
3258*fae548d3Szrj return 0;
3259*fae548d3Szrj
3260*fae548d3Szrj /* If we have not found a potential winner yet, then record this one. */
3261*fae548d3Szrj if (winner == NULL)
3262*fae548d3Szrj {
3263*fae548d3Szrj winner = target;
3264*fae548d3Szrj return 0;
3265*fae548d3Szrj }
3266*fae548d3Szrj
3267*fae548d3Szrj /* Oh dear, we now have two potential candidates for a successful match.
3268*fae548d3Szrj Compare their names and choose the better one. */
3269*fae548d3Szrj if (name_compare (target->name, original->name)
3270*fae548d3Szrj > name_compare (winner->name, original->name))
3271*fae548d3Szrj winner = target;
3272*fae548d3Szrj
3273*fae548d3Szrj /* Keep on searching until wqe have checked them all. */
3274*fae548d3Szrj return 0;
3275*fae548d3Szrj }
3276*fae548d3Szrj
3277*fae548d3Szrj /* Return the BFD target format of the first input file. */
3278*fae548d3Szrj
3279*fae548d3Szrj static const char *
get_first_input_target(void)3280*fae548d3Szrj get_first_input_target (void)
3281*fae548d3Szrj {
3282*fae548d3Szrj const char *target = NULL;
3283*fae548d3Szrj
3284*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (s)
3285*fae548d3Szrj {
3286*fae548d3Szrj if (s->header.type == lang_input_statement_enum
3287*fae548d3Szrj && s->flags.real)
3288*fae548d3Szrj {
3289*fae548d3Szrj ldfile_open_file (s);
3290*fae548d3Szrj
3291*fae548d3Szrj if (s->the_bfd != NULL
3292*fae548d3Szrj && bfd_check_format (s->the_bfd, bfd_object))
3293*fae548d3Szrj {
3294*fae548d3Szrj target = bfd_get_target (s->the_bfd);
3295*fae548d3Szrj
3296*fae548d3Szrj if (target != NULL)
3297*fae548d3Szrj break;
3298*fae548d3Szrj }
3299*fae548d3Szrj }
3300*fae548d3Szrj }
3301*fae548d3Szrj
3302*fae548d3Szrj return target;
3303*fae548d3Szrj }
3304*fae548d3Szrj
3305*fae548d3Szrj const char *
lang_get_output_target(void)3306*fae548d3Szrj lang_get_output_target (void)
3307*fae548d3Szrj {
3308*fae548d3Szrj const char *target;
3309*fae548d3Szrj
3310*fae548d3Szrj /* Has the user told us which output format to use? */
3311*fae548d3Szrj if (output_target != NULL)
3312*fae548d3Szrj return output_target;
3313*fae548d3Szrj
3314*fae548d3Szrj /* No - has the current target been set to something other than
3315*fae548d3Szrj the default? */
3316*fae548d3Szrj if (current_target != default_target && current_target != NULL)
3317*fae548d3Szrj return current_target;
3318*fae548d3Szrj
3319*fae548d3Szrj /* No - can we determine the format of the first input file? */
3320*fae548d3Szrj target = get_first_input_target ();
3321*fae548d3Szrj if (target != NULL)
3322*fae548d3Szrj return target;
3323*fae548d3Szrj
3324*fae548d3Szrj /* Failed - use the default output target. */
3325*fae548d3Szrj return default_target;
3326*fae548d3Szrj }
3327*fae548d3Szrj
3328*fae548d3Szrj /* Open the output file. */
3329*fae548d3Szrj
3330*fae548d3Szrj static void
open_output(const char * name)3331*fae548d3Szrj open_output (const char *name)
3332*fae548d3Szrj {
3333*fae548d3Szrj output_target = lang_get_output_target ();
3334*fae548d3Szrj
3335*fae548d3Szrj /* Has the user requested a particular endianness on the command
3336*fae548d3Szrj line? */
3337*fae548d3Szrj if (command_line.endian != ENDIAN_UNSET)
3338*fae548d3Szrj {
3339*fae548d3Szrj /* Get the chosen target. */
3340*fae548d3Szrj const bfd_target *target
3341*fae548d3Szrj = bfd_iterate_over_targets (get_target, (void *) output_target);
3342*fae548d3Szrj
3343*fae548d3Szrj /* If the target is not supported, we cannot do anything. */
3344*fae548d3Szrj if (target != NULL)
3345*fae548d3Szrj {
3346*fae548d3Szrj enum bfd_endian desired_endian;
3347*fae548d3Szrj
3348*fae548d3Szrj if (command_line.endian == ENDIAN_BIG)
3349*fae548d3Szrj desired_endian = BFD_ENDIAN_BIG;
3350*fae548d3Szrj else
3351*fae548d3Szrj desired_endian = BFD_ENDIAN_LITTLE;
3352*fae548d3Szrj
3353*fae548d3Szrj /* See if the target has the wrong endianness. This should
3354*fae548d3Szrj not happen if the linker script has provided big and
3355*fae548d3Szrj little endian alternatives, but some scrips don't do
3356*fae548d3Szrj this. */
3357*fae548d3Szrj if (target->byteorder != desired_endian)
3358*fae548d3Szrj {
3359*fae548d3Szrj /* If it does, then see if the target provides
3360*fae548d3Szrj an alternative with the correct endianness. */
3361*fae548d3Szrj if (target->alternative_target != NULL
3362*fae548d3Szrj && (target->alternative_target->byteorder == desired_endian))
3363*fae548d3Szrj output_target = target->alternative_target->name;
3364*fae548d3Szrj else
3365*fae548d3Szrj {
3366*fae548d3Szrj /* Try to find a target as similar as possible to
3367*fae548d3Szrj the default target, but which has the desired
3368*fae548d3Szrj endian characteristic. */
3369*fae548d3Szrj bfd_iterate_over_targets (closest_target_match,
3370*fae548d3Szrj (void *) target);
3371*fae548d3Szrj
3372*fae548d3Szrj /* Oh dear - we could not find any targets that
3373*fae548d3Szrj satisfy our requirements. */
3374*fae548d3Szrj if (winner == NULL)
3375*fae548d3Szrj einfo (_("%P: warning: could not find any targets"
3376*fae548d3Szrj " that match endianness requirement\n"));
3377*fae548d3Szrj else
3378*fae548d3Szrj output_target = winner->name;
3379*fae548d3Szrj }
3380*fae548d3Szrj }
3381*fae548d3Szrj }
3382*fae548d3Szrj }
3383*fae548d3Szrj
3384*fae548d3Szrj link_info.output_bfd = bfd_openw (name, output_target);
3385*fae548d3Szrj
3386*fae548d3Szrj if (link_info.output_bfd == NULL)
3387*fae548d3Szrj {
3388*fae548d3Szrj if (bfd_get_error () == bfd_error_invalid_target)
3389*fae548d3Szrj einfo (_("%F%P: target %s not found\n"), output_target);
3390*fae548d3Szrj
3391*fae548d3Szrj einfo (_("%F%P: cannot open output file %s: %E\n"), name);
3392*fae548d3Szrj }
3393*fae548d3Szrj
3394*fae548d3Szrj delete_output_file_on_failure = TRUE;
3395*fae548d3Szrj
3396*fae548d3Szrj if (!bfd_set_format (link_info.output_bfd, bfd_object))
3397*fae548d3Szrj einfo (_("%F%P: %s: can not make object file: %E\n"), name);
3398*fae548d3Szrj if (!bfd_set_arch_mach (link_info.output_bfd,
3399*fae548d3Szrj ldfile_output_architecture,
3400*fae548d3Szrj ldfile_output_machine))
3401*fae548d3Szrj einfo (_("%F%P: %s: can not set architecture: %E\n"), name);
3402*fae548d3Szrj
3403*fae548d3Szrj link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
3404*fae548d3Szrj if (link_info.hash == NULL)
3405*fae548d3Szrj einfo (_("%F%P: can not create hash table: %E\n"));
3406*fae548d3Szrj
3407*fae548d3Szrj bfd_set_gp_size (link_info.output_bfd, g_switch_value);
3408*fae548d3Szrj }
3409*fae548d3Szrj
3410*fae548d3Szrj static void
ldlang_open_output(lang_statement_union_type * statement)3411*fae548d3Szrj ldlang_open_output (lang_statement_union_type *statement)
3412*fae548d3Szrj {
3413*fae548d3Szrj switch (statement->header.type)
3414*fae548d3Szrj {
3415*fae548d3Szrj case lang_output_statement_enum:
3416*fae548d3Szrj ASSERT (link_info.output_bfd == NULL);
3417*fae548d3Szrj open_output (statement->output_statement.name);
3418*fae548d3Szrj ldemul_set_output_arch ();
3419*fae548d3Szrj if (config.magic_demand_paged
3420*fae548d3Szrj && !bfd_link_relocatable (&link_info))
3421*fae548d3Szrj link_info.output_bfd->flags |= D_PAGED;
3422*fae548d3Szrj else
3423*fae548d3Szrj link_info.output_bfd->flags &= ~D_PAGED;
3424*fae548d3Szrj if (config.text_read_only)
3425*fae548d3Szrj link_info.output_bfd->flags |= WP_TEXT;
3426*fae548d3Szrj else
3427*fae548d3Szrj link_info.output_bfd->flags &= ~WP_TEXT;
3428*fae548d3Szrj if (link_info.traditional_format)
3429*fae548d3Szrj link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
3430*fae548d3Szrj else
3431*fae548d3Szrj link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
3432*fae548d3Szrj break;
3433*fae548d3Szrj
3434*fae548d3Szrj case lang_target_statement_enum:
3435*fae548d3Szrj current_target = statement->target_statement.target;
3436*fae548d3Szrj break;
3437*fae548d3Szrj default:
3438*fae548d3Szrj break;
3439*fae548d3Szrj }
3440*fae548d3Szrj }
3441*fae548d3Szrj
3442*fae548d3Szrj static void
init_opb(asection * s)3443*fae548d3Szrj init_opb (asection *s)
3444*fae548d3Szrj {
3445*fae548d3Szrj unsigned int x;
3446*fae548d3Szrj
3447*fae548d3Szrj opb_shift = 0;
3448*fae548d3Szrj if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
3449*fae548d3Szrj && s != NULL
3450*fae548d3Szrj && (s->flags & SEC_ELF_OCTETS) != 0)
3451*fae548d3Szrj return;
3452*fae548d3Szrj
3453*fae548d3Szrj x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3454*fae548d3Szrj ldfile_output_machine);
3455*fae548d3Szrj if (x > 1)
3456*fae548d3Szrj while ((x & 1) == 0)
3457*fae548d3Szrj {
3458*fae548d3Szrj x >>= 1;
3459*fae548d3Szrj ++opb_shift;
3460*fae548d3Szrj }
3461*fae548d3Szrj ASSERT (x == 1);
3462*fae548d3Szrj }
3463*fae548d3Szrj
3464*fae548d3Szrj /* Open all the input files. */
3465*fae548d3Szrj
3466*fae548d3Szrj enum open_bfd_mode
3467*fae548d3Szrj {
3468*fae548d3Szrj OPEN_BFD_NORMAL = 0,
3469*fae548d3Szrj OPEN_BFD_FORCE = 1,
3470*fae548d3Szrj OPEN_BFD_RESCAN = 2
3471*fae548d3Szrj };
3472*fae548d3Szrj #ifdef ENABLE_PLUGINS
3473*fae548d3Szrj static lang_input_statement_type *plugin_insert = NULL;
3474*fae548d3Szrj static struct bfd_link_hash_entry *plugin_undefs = NULL;
3475*fae548d3Szrj #endif
3476*fae548d3Szrj
3477*fae548d3Szrj static void
open_input_bfds(lang_statement_union_type * s,enum open_bfd_mode mode)3478*fae548d3Szrj open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode)
3479*fae548d3Szrj {
3480*fae548d3Szrj for (; s != NULL; s = s->header.next)
3481*fae548d3Szrj {
3482*fae548d3Szrj switch (s->header.type)
3483*fae548d3Szrj {
3484*fae548d3Szrj case lang_constructors_statement_enum:
3485*fae548d3Szrj open_input_bfds (constructor_list.head, mode);
3486*fae548d3Szrj break;
3487*fae548d3Szrj case lang_output_section_statement_enum:
3488*fae548d3Szrj open_input_bfds (s->output_section_statement.children.head, mode);
3489*fae548d3Szrj break;
3490*fae548d3Szrj case lang_wild_statement_enum:
3491*fae548d3Szrj /* Maybe we should load the file's symbols. */
3492*fae548d3Szrj if ((mode & OPEN_BFD_RESCAN) == 0
3493*fae548d3Szrj && s->wild_statement.filename
3494*fae548d3Szrj && !wildcardp (s->wild_statement.filename)
3495*fae548d3Szrj && !archive_path (s->wild_statement.filename))
3496*fae548d3Szrj lookup_name (s->wild_statement.filename);
3497*fae548d3Szrj open_input_bfds (s->wild_statement.children.head, mode);
3498*fae548d3Szrj break;
3499*fae548d3Szrj case lang_group_statement_enum:
3500*fae548d3Szrj {
3501*fae548d3Szrj struct bfd_link_hash_entry *undefs;
3502*fae548d3Szrj #ifdef ENABLE_PLUGINS
3503*fae548d3Szrj lang_input_statement_type *plugin_insert_save;
3504*fae548d3Szrj #endif
3505*fae548d3Szrj
3506*fae548d3Szrj /* We must continually search the entries in the group
3507*fae548d3Szrj until no new symbols are added to the list of undefined
3508*fae548d3Szrj symbols. */
3509*fae548d3Szrj
3510*fae548d3Szrj do
3511*fae548d3Szrj {
3512*fae548d3Szrj #ifdef ENABLE_PLUGINS
3513*fae548d3Szrj plugin_insert_save = plugin_insert;
3514*fae548d3Szrj #endif
3515*fae548d3Szrj undefs = link_info.hash->undefs_tail;
3516*fae548d3Szrj open_input_bfds (s->group_statement.children.head,
3517*fae548d3Szrj mode | OPEN_BFD_FORCE);
3518*fae548d3Szrj }
3519*fae548d3Szrj while (undefs != link_info.hash->undefs_tail
3520*fae548d3Szrj #ifdef ENABLE_PLUGINS
3521*fae548d3Szrj /* Objects inserted by a plugin, which are loaded
3522*fae548d3Szrj before we hit this loop, may have added new
3523*fae548d3Szrj undefs. */
3524*fae548d3Szrj || (plugin_insert != plugin_insert_save && plugin_undefs)
3525*fae548d3Szrj #endif
3526*fae548d3Szrj );
3527*fae548d3Szrj }
3528*fae548d3Szrj break;
3529*fae548d3Szrj case lang_target_statement_enum:
3530*fae548d3Szrj current_target = s->target_statement.target;
3531*fae548d3Szrj break;
3532*fae548d3Szrj case lang_input_statement_enum:
3533*fae548d3Szrj if (s->input_statement.flags.real)
3534*fae548d3Szrj {
3535*fae548d3Szrj lang_statement_union_type **os_tail;
3536*fae548d3Szrj lang_statement_list_type add;
3537*fae548d3Szrj bfd *abfd;
3538*fae548d3Szrj
3539*fae548d3Szrj s->input_statement.target = current_target;
3540*fae548d3Szrj
3541*fae548d3Szrj /* If we are being called from within a group, and this
3542*fae548d3Szrj is an archive which has already been searched, then
3543*fae548d3Szrj force it to be researched unless the whole archive
3544*fae548d3Szrj has been loaded already. Do the same for a rescan.
3545*fae548d3Szrj Likewise reload --as-needed shared libs. */
3546*fae548d3Szrj if (mode != OPEN_BFD_NORMAL
3547*fae548d3Szrj #ifdef ENABLE_PLUGINS
3548*fae548d3Szrj && ((mode & OPEN_BFD_RESCAN) == 0
3549*fae548d3Szrj || plugin_insert == NULL)
3550*fae548d3Szrj #endif
3551*fae548d3Szrj && s->input_statement.flags.loaded
3552*fae548d3Szrj && (abfd = s->input_statement.the_bfd) != NULL
3553*fae548d3Szrj && ((bfd_get_format (abfd) == bfd_archive
3554*fae548d3Szrj && !s->input_statement.flags.whole_archive)
3555*fae548d3Szrj || (bfd_get_format (abfd) == bfd_object
3556*fae548d3Szrj && ((abfd->flags) & DYNAMIC) != 0
3557*fae548d3Szrj && s->input_statement.flags.add_DT_NEEDED_for_regular
3558*fae548d3Szrj && bfd_get_flavour (abfd) == bfd_target_elf_flavour
3559*fae548d3Szrj && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)))
3560*fae548d3Szrj {
3561*fae548d3Szrj s->input_statement.flags.loaded = FALSE;
3562*fae548d3Szrj s->input_statement.flags.reload = TRUE;
3563*fae548d3Szrj }
3564*fae548d3Szrj
3565*fae548d3Szrj os_tail = lang_os_list.tail;
3566*fae548d3Szrj lang_list_init (&add);
3567*fae548d3Szrj
3568*fae548d3Szrj if (!load_symbols (&s->input_statement, &add))
3569*fae548d3Szrj config.make_executable = FALSE;
3570*fae548d3Szrj
3571*fae548d3Szrj if (add.head != NULL)
3572*fae548d3Szrj {
3573*fae548d3Szrj /* If this was a script with output sections then
3574*fae548d3Szrj tack any added statements on to the end of the
3575*fae548d3Szrj list. This avoids having to reorder the output
3576*fae548d3Szrj section statement list. Very likely the user
3577*fae548d3Szrj forgot -T, and whatever we do here will not meet
3578*fae548d3Szrj naive user expectations. */
3579*fae548d3Szrj if (os_tail != lang_os_list.tail)
3580*fae548d3Szrj {
3581*fae548d3Szrj einfo (_("%P: warning: %s contains output sections;"
3582*fae548d3Szrj " did you forget -T?\n"),
3583*fae548d3Szrj s->input_statement.filename);
3584*fae548d3Szrj *stat_ptr->tail = add.head;
3585*fae548d3Szrj stat_ptr->tail = add.tail;
3586*fae548d3Szrj }
3587*fae548d3Szrj else
3588*fae548d3Szrj {
3589*fae548d3Szrj *add.tail = s->header.next;
3590*fae548d3Szrj s->header.next = add.head;
3591*fae548d3Szrj }
3592*fae548d3Szrj }
3593*fae548d3Szrj }
3594*fae548d3Szrj #ifdef ENABLE_PLUGINS
3595*fae548d3Szrj /* If we have found the point at which a plugin added new
3596*fae548d3Szrj files, clear plugin_insert to enable archive rescan. */
3597*fae548d3Szrj if (&s->input_statement == plugin_insert)
3598*fae548d3Szrj plugin_insert = NULL;
3599*fae548d3Szrj #endif
3600*fae548d3Szrj break;
3601*fae548d3Szrj case lang_assignment_statement_enum:
3602*fae548d3Szrj if (s->assignment_statement.exp->type.node_class != etree_assert)
3603*fae548d3Szrj exp_fold_tree_no_dot (s->assignment_statement.exp);
3604*fae548d3Szrj break;
3605*fae548d3Szrj default:
3606*fae548d3Szrj break;
3607*fae548d3Szrj }
3608*fae548d3Szrj }
3609*fae548d3Szrj
3610*fae548d3Szrj /* Exit if any of the files were missing. */
3611*fae548d3Szrj if (input_flags.missing_file)
3612*fae548d3Szrj einfo ("%F");
3613*fae548d3Szrj }
3614*fae548d3Szrj
3615*fae548d3Szrj /* Open the CTF sections in the input files with libctf: if any were opened,
3616*fae548d3Szrj create a fake input file that we'll write the merged CTF data to later
3617*fae548d3Szrj on. */
3618*fae548d3Szrj
3619*fae548d3Szrj static void
ldlang_open_ctf(void)3620*fae548d3Szrj ldlang_open_ctf (void)
3621*fae548d3Szrj {
3622*fae548d3Szrj int any_ctf = 0;
3623*fae548d3Szrj int err;
3624*fae548d3Szrj
3625*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (file)
3626*fae548d3Szrj {
3627*fae548d3Szrj asection *sect;
3628*fae548d3Szrj
3629*fae548d3Szrj /* Incoming files from the compiler have a single ctf_file_t in them
3630*fae548d3Szrj (which is presented to us by the libctf API in a ctf_archive_t
3631*fae548d3Szrj wrapper): files derived from a previous relocatable link have a CTF
3632*fae548d3Szrj archive containing possibly many CTF files. */
3633*fae548d3Szrj
3634*fae548d3Szrj if ((file->the_ctf = ctf_bfdopen (file->the_bfd, &err)) == NULL)
3635*fae548d3Szrj {
3636*fae548d3Szrj if (err != ECTF_NOCTFDATA)
3637*fae548d3Szrj einfo (_("%P: warning: CTF section in `%pI' not loaded: "
3638*fae548d3Szrj "its types will be discarded: `%s'\n"), file,
3639*fae548d3Szrj ctf_errmsg (err));
3640*fae548d3Szrj continue;
3641*fae548d3Szrj }
3642*fae548d3Szrj
3643*fae548d3Szrj /* Prevent the contents of this section from being written, while
3644*fae548d3Szrj requiring the section itself to be duplicated in the output. */
3645*fae548d3Szrj /* This section must exist if ctf_bfdopen() succeeded. */
3646*fae548d3Szrj sect = bfd_get_section_by_name (file->the_bfd, ".ctf");
3647*fae548d3Szrj sect->size = 0;
3648*fae548d3Szrj sect->flags |= SEC_NEVER_LOAD | SEC_HAS_CONTENTS | SEC_LINKER_CREATED;
3649*fae548d3Szrj
3650*fae548d3Szrj any_ctf = 1;
3651*fae548d3Szrj }
3652*fae548d3Szrj
3653*fae548d3Szrj if (!any_ctf)
3654*fae548d3Szrj {
3655*fae548d3Szrj ctf_output = NULL;
3656*fae548d3Szrj return;
3657*fae548d3Szrj }
3658*fae548d3Szrj
3659*fae548d3Szrj if ((ctf_output = ctf_create (&err)) != NULL)
3660*fae548d3Szrj return;
3661*fae548d3Szrj
3662*fae548d3Szrj einfo (_("%P: warning: CTF output not created: `s'\n"),
3663*fae548d3Szrj ctf_errmsg (err));
3664*fae548d3Szrj
3665*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (errfile)
3666*fae548d3Szrj ctf_close (errfile->the_ctf);
3667*fae548d3Szrj }
3668*fae548d3Szrj
3669*fae548d3Szrj /* Merge together CTF sections. After this, only the symtab-dependent
3670*fae548d3Szrj function and data object sections need adjustment. */
3671*fae548d3Szrj
3672*fae548d3Szrj static void
lang_merge_ctf(void)3673*fae548d3Szrj lang_merge_ctf (void)
3674*fae548d3Szrj {
3675*fae548d3Szrj asection *output_sect;
3676*fae548d3Szrj
3677*fae548d3Szrj if (!ctf_output)
3678*fae548d3Szrj return;
3679*fae548d3Szrj
3680*fae548d3Szrj output_sect = bfd_get_section_by_name (link_info.output_bfd, ".ctf");
3681*fae548d3Szrj
3682*fae548d3Szrj /* If the section was discarded, don't waste time merging. */
3683*fae548d3Szrj if (output_sect == NULL)
3684*fae548d3Szrj {
3685*fae548d3Szrj ctf_file_close (ctf_output);
3686*fae548d3Szrj ctf_output = NULL;
3687*fae548d3Szrj
3688*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (file)
3689*fae548d3Szrj {
3690*fae548d3Szrj ctf_close (file->the_ctf);
3691*fae548d3Szrj file->the_ctf = NULL;
3692*fae548d3Szrj }
3693*fae548d3Szrj return;
3694*fae548d3Szrj }
3695*fae548d3Szrj
3696*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (file)
3697*fae548d3Szrj {
3698*fae548d3Szrj if (!file->the_ctf)
3699*fae548d3Szrj continue;
3700*fae548d3Szrj
3701*fae548d3Szrj /* Takes ownership of file->u.the_ctfa. */
3702*fae548d3Szrj if (ctf_link_add_ctf (ctf_output, file->the_ctf, file->filename) < 0)
3703*fae548d3Szrj {
3704*fae548d3Szrj einfo (_("%F%P: cannot link with CTF in %pB: %s\n"), file->the_bfd,
3705*fae548d3Szrj ctf_errmsg (ctf_errno (ctf_output)));
3706*fae548d3Szrj ctf_close (file->the_ctf);
3707*fae548d3Szrj file->the_ctf = NULL;
3708*fae548d3Szrj continue;
3709*fae548d3Szrj }
3710*fae548d3Szrj }
3711*fae548d3Szrj
3712*fae548d3Szrj if (ctf_link (ctf_output, CTF_LINK_SHARE_UNCONFLICTED) < 0)
3713*fae548d3Szrj {
3714*fae548d3Szrj einfo (_("%F%P: CTF linking failed; output will have no CTF section: %s\n"),
3715*fae548d3Szrj ctf_errmsg (ctf_errno (ctf_output)));
3716*fae548d3Szrj if (output_sect)
3717*fae548d3Szrj {
3718*fae548d3Szrj output_sect->size = 0;
3719*fae548d3Szrj output_sect->flags |= SEC_EXCLUDE;
3720*fae548d3Szrj }
3721*fae548d3Szrj }
3722*fae548d3Szrj }
3723*fae548d3Szrj
3724*fae548d3Szrj /* Let the emulation examine the symbol table and strtab to help it optimize the
3725*fae548d3Szrj CTF, if supported. */
3726*fae548d3Szrj
3727*fae548d3Szrj void
ldlang_ctf_apply_strsym(struct elf_sym_strtab * syms,bfd_size_type symcount,struct elf_strtab_hash * symstrtab)3728*fae548d3Szrj ldlang_ctf_apply_strsym (struct elf_sym_strtab *syms, bfd_size_type symcount,
3729*fae548d3Szrj struct elf_strtab_hash *symstrtab)
3730*fae548d3Szrj {
3731*fae548d3Szrj ldemul_examine_strtab_for_ctf (ctf_output, syms, symcount, symstrtab);
3732*fae548d3Szrj }
3733*fae548d3Szrj
3734*fae548d3Szrj /* Write out the CTF section. Called early, if the emulation isn't going to
3735*fae548d3Szrj need to dedup against the strtab and symtab, then possibly called from the
3736*fae548d3Szrj target linker code if the dedup has happened. */
3737*fae548d3Szrj static void
lang_write_ctf(int late)3738*fae548d3Szrj lang_write_ctf (int late)
3739*fae548d3Szrj {
3740*fae548d3Szrj size_t output_size;
3741*fae548d3Szrj asection *output_sect;
3742*fae548d3Szrj
3743*fae548d3Szrj if (!ctf_output)
3744*fae548d3Szrj return;
3745*fae548d3Szrj
3746*fae548d3Szrj if (late)
3747*fae548d3Szrj {
3748*fae548d3Szrj /* Emit CTF late if this emulation says it can do so. */
3749*fae548d3Szrj if (ldemul_emit_ctf_early ())
3750*fae548d3Szrj return;
3751*fae548d3Szrj }
3752*fae548d3Szrj else
3753*fae548d3Szrj {
3754*fae548d3Szrj if (!ldemul_emit_ctf_early ())
3755*fae548d3Szrj return;
3756*fae548d3Szrj }
3757*fae548d3Szrj
3758*fae548d3Szrj /* Emit CTF. */
3759*fae548d3Szrj
3760*fae548d3Szrj output_sect = bfd_get_section_by_name (link_info.output_bfd, ".ctf");
3761*fae548d3Szrj if (output_sect)
3762*fae548d3Szrj {
3763*fae548d3Szrj output_sect->contents = ctf_link_write (ctf_output, &output_size,
3764*fae548d3Szrj CTF_COMPRESSION_THRESHOLD);
3765*fae548d3Szrj output_sect->size = output_size;
3766*fae548d3Szrj output_sect->flags |= SEC_IN_MEMORY | SEC_KEEP;
3767*fae548d3Szrj
3768*fae548d3Szrj if (!output_sect->contents)
3769*fae548d3Szrj {
3770*fae548d3Szrj einfo (_("%F%P: CTF section emission failed; output will have no "
3771*fae548d3Szrj "CTF section: %s\n"), ctf_errmsg (ctf_errno (ctf_output)));
3772*fae548d3Szrj output_sect->size = 0;
3773*fae548d3Szrj output_sect->flags |= SEC_EXCLUDE;
3774*fae548d3Szrj }
3775*fae548d3Szrj }
3776*fae548d3Szrj
3777*fae548d3Szrj /* This also closes every CTF input file used in the link. */
3778*fae548d3Szrj ctf_file_close (ctf_output);
3779*fae548d3Szrj ctf_output = NULL;
3780*fae548d3Szrj
3781*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (file)
3782*fae548d3Szrj file->the_ctf = NULL;
3783*fae548d3Szrj }
3784*fae548d3Szrj
3785*fae548d3Szrj /* Write out the CTF section late, if the emulation needs that. */
3786*fae548d3Szrj
3787*fae548d3Szrj void
ldlang_write_ctf_late(void)3788*fae548d3Szrj ldlang_write_ctf_late (void)
3789*fae548d3Szrj {
3790*fae548d3Szrj /* Trigger a "late call", if the emulation needs one. */
3791*fae548d3Szrj
3792*fae548d3Szrj lang_write_ctf (1);
3793*fae548d3Szrj }
3794*fae548d3Szrj
3795*fae548d3Szrj /* Add the supplied name to the symbol table as an undefined reference.
3796*fae548d3Szrj This is a two step process as the symbol table doesn't even exist at
3797*fae548d3Szrj the time the ld command line is processed. First we put the name
3798*fae548d3Szrj on a list, then, once the output file has been opened, transfer the
3799*fae548d3Szrj name to the symbol table. */
3800*fae548d3Szrj
3801*fae548d3Szrj typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3802*fae548d3Szrj
3803*fae548d3Szrj #define ldlang_undef_chain_list_head entry_symbol.next
3804*fae548d3Szrj
3805*fae548d3Szrj void
ldlang_add_undef(const char * const name,bfd_boolean cmdline)3806*fae548d3Szrj ldlang_add_undef (const char *const name, bfd_boolean cmdline)
3807*fae548d3Szrj {
3808*fae548d3Szrj ldlang_undef_chain_list_type *new_undef;
3809*fae548d3Szrj
3810*fae548d3Szrj undef_from_cmdline = undef_from_cmdline || cmdline;
3811*fae548d3Szrj new_undef = stat_alloc (sizeof (*new_undef));
3812*fae548d3Szrj new_undef->next = ldlang_undef_chain_list_head;
3813*fae548d3Szrj ldlang_undef_chain_list_head = new_undef;
3814*fae548d3Szrj
3815*fae548d3Szrj new_undef->name = xstrdup (name);
3816*fae548d3Szrj
3817*fae548d3Szrj if (link_info.output_bfd != NULL)
3818*fae548d3Szrj insert_undefined (new_undef->name);
3819*fae548d3Szrj }
3820*fae548d3Szrj
3821*fae548d3Szrj /* Insert NAME as undefined in the symbol table. */
3822*fae548d3Szrj
3823*fae548d3Szrj static void
insert_undefined(const char * name)3824*fae548d3Szrj insert_undefined (const char *name)
3825*fae548d3Szrj {
3826*fae548d3Szrj struct bfd_link_hash_entry *h;
3827*fae548d3Szrj
3828*fae548d3Szrj h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3829*fae548d3Szrj if (h == NULL)
3830*fae548d3Szrj einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3831*fae548d3Szrj if (h->type == bfd_link_hash_new)
3832*fae548d3Szrj {
3833*fae548d3Szrj h->type = bfd_link_hash_undefined;
3834*fae548d3Szrj h->u.undef.abfd = NULL;
3835*fae548d3Szrj h->non_ir_ref_regular = TRUE;
3836*fae548d3Szrj if (is_elf_hash_table (link_info.hash))
3837*fae548d3Szrj ((struct elf_link_hash_entry *) h)->mark = 1;
3838*fae548d3Szrj bfd_link_add_undef (link_info.hash, h);
3839*fae548d3Szrj }
3840*fae548d3Szrj }
3841*fae548d3Szrj
3842*fae548d3Szrj /* Run through the list of undefineds created above and place them
3843*fae548d3Szrj into the linker hash table as undefined symbols belonging to the
3844*fae548d3Szrj script file. */
3845*fae548d3Szrj
3846*fae548d3Szrj static void
lang_place_undefineds(void)3847*fae548d3Szrj lang_place_undefineds (void)
3848*fae548d3Szrj {
3849*fae548d3Szrj ldlang_undef_chain_list_type *ptr;
3850*fae548d3Szrj
3851*fae548d3Szrj for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3852*fae548d3Szrj insert_undefined (ptr->name);
3853*fae548d3Szrj }
3854*fae548d3Szrj
3855*fae548d3Szrj /* Structure used to build the list of symbols that the user has required
3856*fae548d3Szrj be defined. */
3857*fae548d3Szrj
3858*fae548d3Szrj struct require_defined_symbol
3859*fae548d3Szrj {
3860*fae548d3Szrj const char *name;
3861*fae548d3Szrj struct require_defined_symbol *next;
3862*fae548d3Szrj };
3863*fae548d3Szrj
3864*fae548d3Szrj /* The list of symbols that the user has required be defined. */
3865*fae548d3Szrj
3866*fae548d3Szrj static struct require_defined_symbol *require_defined_symbol_list;
3867*fae548d3Szrj
3868*fae548d3Szrj /* Add a new symbol NAME to the list of symbols that are required to be
3869*fae548d3Szrj defined. */
3870*fae548d3Szrj
3871*fae548d3Szrj void
ldlang_add_require_defined(const char * const name)3872*fae548d3Szrj ldlang_add_require_defined (const char *const name)
3873*fae548d3Szrj {
3874*fae548d3Szrj struct require_defined_symbol *ptr;
3875*fae548d3Szrj
3876*fae548d3Szrj ldlang_add_undef (name, TRUE);
3877*fae548d3Szrj ptr = stat_alloc (sizeof (*ptr));
3878*fae548d3Szrj ptr->next = require_defined_symbol_list;
3879*fae548d3Szrj ptr->name = strdup (name);
3880*fae548d3Szrj require_defined_symbol_list = ptr;
3881*fae548d3Szrj }
3882*fae548d3Szrj
3883*fae548d3Szrj /* Check that all symbols the user required to be defined, are defined,
3884*fae548d3Szrj raise an error if we find a symbol that is not defined. */
3885*fae548d3Szrj
3886*fae548d3Szrj static void
ldlang_check_require_defined_symbols(void)3887*fae548d3Szrj ldlang_check_require_defined_symbols (void)
3888*fae548d3Szrj {
3889*fae548d3Szrj struct require_defined_symbol *ptr;
3890*fae548d3Szrj
3891*fae548d3Szrj for (ptr = require_defined_symbol_list; ptr != NULL; ptr = ptr->next)
3892*fae548d3Szrj {
3893*fae548d3Szrj struct bfd_link_hash_entry *h;
3894*fae548d3Szrj
3895*fae548d3Szrj h = bfd_link_hash_lookup (link_info.hash, ptr->name,
3896*fae548d3Szrj FALSE, FALSE, TRUE);
3897*fae548d3Szrj if (h == NULL
3898*fae548d3Szrj || (h->type != bfd_link_hash_defined
3899*fae548d3Szrj && h->type != bfd_link_hash_defweak))
3900*fae548d3Szrj einfo(_("%X%P: required symbol `%s' not defined\n"), ptr->name);
3901*fae548d3Szrj }
3902*fae548d3Szrj }
3903*fae548d3Szrj
3904*fae548d3Szrj /* Check for all readonly or some readwrite sections. */
3905*fae548d3Szrj
3906*fae548d3Szrj static void
check_input_sections(lang_statement_union_type * s,lang_output_section_statement_type * output_section_statement)3907*fae548d3Szrj check_input_sections
3908*fae548d3Szrj (lang_statement_union_type *s,
3909*fae548d3Szrj lang_output_section_statement_type *output_section_statement)
3910*fae548d3Szrj {
3911*fae548d3Szrj for (; s != NULL; s = s->header.next)
3912*fae548d3Szrj {
3913*fae548d3Szrj switch (s->header.type)
3914*fae548d3Szrj {
3915*fae548d3Szrj case lang_wild_statement_enum:
3916*fae548d3Szrj walk_wild (&s->wild_statement, check_section_callback,
3917*fae548d3Szrj output_section_statement);
3918*fae548d3Szrj if (!output_section_statement->all_input_readonly)
3919*fae548d3Szrj return;
3920*fae548d3Szrj break;
3921*fae548d3Szrj case lang_constructors_statement_enum:
3922*fae548d3Szrj check_input_sections (constructor_list.head,
3923*fae548d3Szrj output_section_statement);
3924*fae548d3Szrj if (!output_section_statement->all_input_readonly)
3925*fae548d3Szrj return;
3926*fae548d3Szrj break;
3927*fae548d3Szrj case lang_group_statement_enum:
3928*fae548d3Szrj check_input_sections (s->group_statement.children.head,
3929*fae548d3Szrj output_section_statement);
3930*fae548d3Szrj if (!output_section_statement->all_input_readonly)
3931*fae548d3Szrj return;
3932*fae548d3Szrj break;
3933*fae548d3Szrj default:
3934*fae548d3Szrj break;
3935*fae548d3Szrj }
3936*fae548d3Szrj }
3937*fae548d3Szrj }
3938*fae548d3Szrj
3939*fae548d3Szrj /* Update wildcard statements if needed. */
3940*fae548d3Szrj
3941*fae548d3Szrj static void
update_wild_statements(lang_statement_union_type * s)3942*fae548d3Szrj update_wild_statements (lang_statement_union_type *s)
3943*fae548d3Szrj {
3944*fae548d3Szrj struct wildcard_list *sec;
3945*fae548d3Szrj
3946*fae548d3Szrj switch (sort_section)
3947*fae548d3Szrj {
3948*fae548d3Szrj default:
3949*fae548d3Szrj FAIL ();
3950*fae548d3Szrj
3951*fae548d3Szrj case none:
3952*fae548d3Szrj break;
3953*fae548d3Szrj
3954*fae548d3Szrj case by_name:
3955*fae548d3Szrj case by_alignment:
3956*fae548d3Szrj for (; s != NULL; s = s->header.next)
3957*fae548d3Szrj {
3958*fae548d3Szrj switch (s->header.type)
3959*fae548d3Szrj {
3960*fae548d3Szrj default:
3961*fae548d3Szrj break;
3962*fae548d3Szrj
3963*fae548d3Szrj case lang_wild_statement_enum:
3964*fae548d3Szrj for (sec = s->wild_statement.section_list; sec != NULL;
3965*fae548d3Szrj sec = sec->next)
3966*fae548d3Szrj /* Don't sort .init/.fini sections. */
3967*fae548d3Szrj if (strcmp (sec->spec.name, ".init") != 0
3968*fae548d3Szrj && strcmp (sec->spec.name, ".fini") != 0)
3969*fae548d3Szrj switch (sec->spec.sorted)
3970*fae548d3Szrj {
3971*fae548d3Szrj case none:
3972*fae548d3Szrj sec->spec.sorted = sort_section;
3973*fae548d3Szrj break;
3974*fae548d3Szrj case by_name:
3975*fae548d3Szrj if (sort_section == by_alignment)
3976*fae548d3Szrj sec->spec.sorted = by_name_alignment;
3977*fae548d3Szrj break;
3978*fae548d3Szrj case by_alignment:
3979*fae548d3Szrj if (sort_section == by_name)
3980*fae548d3Szrj sec->spec.sorted = by_alignment_name;
3981*fae548d3Szrj break;
3982*fae548d3Szrj default:
3983*fae548d3Szrj break;
3984*fae548d3Szrj }
3985*fae548d3Szrj break;
3986*fae548d3Szrj
3987*fae548d3Szrj case lang_constructors_statement_enum:
3988*fae548d3Szrj update_wild_statements (constructor_list.head);
3989*fae548d3Szrj break;
3990*fae548d3Szrj
3991*fae548d3Szrj case lang_output_section_statement_enum:
3992*fae548d3Szrj update_wild_statements
3993*fae548d3Szrj (s->output_section_statement.children.head);
3994*fae548d3Szrj break;
3995*fae548d3Szrj
3996*fae548d3Szrj case lang_group_statement_enum:
3997*fae548d3Szrj update_wild_statements (s->group_statement.children.head);
3998*fae548d3Szrj break;
3999*fae548d3Szrj }
4000*fae548d3Szrj }
4001*fae548d3Szrj break;
4002*fae548d3Szrj }
4003*fae548d3Szrj }
4004*fae548d3Szrj
4005*fae548d3Szrj /* Open input files and attach to output sections. */
4006*fae548d3Szrj
4007*fae548d3Szrj static void
map_input_to_output_sections(lang_statement_union_type * s,const char * target,lang_output_section_statement_type * os)4008*fae548d3Szrj map_input_to_output_sections
4009*fae548d3Szrj (lang_statement_union_type *s, const char *target,
4010*fae548d3Szrj lang_output_section_statement_type *os)
4011*fae548d3Szrj {
4012*fae548d3Szrj for (; s != NULL; s = s->header.next)
4013*fae548d3Szrj {
4014*fae548d3Szrj lang_output_section_statement_type *tos;
4015*fae548d3Szrj flagword flags;
4016*fae548d3Szrj
4017*fae548d3Szrj switch (s->header.type)
4018*fae548d3Szrj {
4019*fae548d3Szrj case lang_wild_statement_enum:
4020*fae548d3Szrj wild (&s->wild_statement, target, os);
4021*fae548d3Szrj break;
4022*fae548d3Szrj case lang_constructors_statement_enum:
4023*fae548d3Szrj map_input_to_output_sections (constructor_list.head,
4024*fae548d3Szrj target,
4025*fae548d3Szrj os);
4026*fae548d3Szrj break;
4027*fae548d3Szrj case lang_output_section_statement_enum:
4028*fae548d3Szrj tos = &s->output_section_statement;
4029*fae548d3Szrj if (tos->constraint != 0)
4030*fae548d3Szrj {
4031*fae548d3Szrj if (tos->constraint != ONLY_IF_RW
4032*fae548d3Szrj && tos->constraint != ONLY_IF_RO)
4033*fae548d3Szrj break;
4034*fae548d3Szrj tos->all_input_readonly = TRUE;
4035*fae548d3Szrj check_input_sections (tos->children.head, tos);
4036*fae548d3Szrj if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
4037*fae548d3Szrj {
4038*fae548d3Szrj tos->constraint = -1;
4039*fae548d3Szrj break;
4040*fae548d3Szrj }
4041*fae548d3Szrj }
4042*fae548d3Szrj map_input_to_output_sections (tos->children.head,
4043*fae548d3Szrj target,
4044*fae548d3Szrj tos);
4045*fae548d3Szrj break;
4046*fae548d3Szrj case lang_output_statement_enum:
4047*fae548d3Szrj break;
4048*fae548d3Szrj case lang_target_statement_enum:
4049*fae548d3Szrj target = s->target_statement.target;
4050*fae548d3Szrj break;
4051*fae548d3Szrj case lang_group_statement_enum:
4052*fae548d3Szrj map_input_to_output_sections (s->group_statement.children.head,
4053*fae548d3Szrj target,
4054*fae548d3Szrj os);
4055*fae548d3Szrj break;
4056*fae548d3Szrj case lang_data_statement_enum:
4057*fae548d3Szrj /* Make sure that any sections mentioned in the expression
4058*fae548d3Szrj are initialized. */
4059*fae548d3Szrj exp_init_os (s->data_statement.exp);
4060*fae548d3Szrj /* The output section gets CONTENTS, ALLOC and LOAD, but
4061*fae548d3Szrj these may be overridden by the script. */
4062*fae548d3Szrj flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
4063*fae548d3Szrj switch (os->sectype)
4064*fae548d3Szrj {
4065*fae548d3Szrj case normal_section:
4066*fae548d3Szrj case overlay_section:
4067*fae548d3Szrj case first_overlay_section:
4068*fae548d3Szrj break;
4069*fae548d3Szrj case noalloc_section:
4070*fae548d3Szrj flags = SEC_HAS_CONTENTS;
4071*fae548d3Szrj break;
4072*fae548d3Szrj case noload_section:
4073*fae548d3Szrj if (bfd_get_flavour (link_info.output_bfd)
4074*fae548d3Szrj == bfd_target_elf_flavour)
4075*fae548d3Szrj flags = SEC_NEVER_LOAD | SEC_ALLOC;
4076*fae548d3Szrj else
4077*fae548d3Szrj flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS;
4078*fae548d3Szrj break;
4079*fae548d3Szrj }
4080*fae548d3Szrj if (os->bfd_section == NULL)
4081*fae548d3Szrj init_os (os, flags);
4082*fae548d3Szrj else
4083*fae548d3Szrj os->bfd_section->flags |= flags;
4084*fae548d3Szrj break;
4085*fae548d3Szrj case lang_input_section_enum:
4086*fae548d3Szrj break;
4087*fae548d3Szrj case lang_fill_statement_enum:
4088*fae548d3Szrj case lang_object_symbols_statement_enum:
4089*fae548d3Szrj case lang_reloc_statement_enum:
4090*fae548d3Szrj case lang_padding_statement_enum:
4091*fae548d3Szrj case lang_input_statement_enum:
4092*fae548d3Szrj if (os != NULL && os->bfd_section == NULL)
4093*fae548d3Szrj init_os (os, 0);
4094*fae548d3Szrj break;
4095*fae548d3Szrj case lang_assignment_statement_enum:
4096*fae548d3Szrj if (os != NULL && os->bfd_section == NULL)
4097*fae548d3Szrj init_os (os, 0);
4098*fae548d3Szrj
4099*fae548d3Szrj /* Make sure that any sections mentioned in the assignment
4100*fae548d3Szrj are initialized. */
4101*fae548d3Szrj exp_init_os (s->assignment_statement.exp);
4102*fae548d3Szrj break;
4103*fae548d3Szrj case lang_address_statement_enum:
4104*fae548d3Szrj /* Mark the specified section with the supplied address.
4105*fae548d3Szrj If this section was actually a segment marker, then the
4106*fae548d3Szrj directive is ignored if the linker script explicitly
4107*fae548d3Szrj processed the segment marker. Originally, the linker
4108*fae548d3Szrj treated segment directives (like -Ttext on the
4109*fae548d3Szrj command-line) as section directives. We honor the
4110*fae548d3Szrj section directive semantics for backwards compatibility;
4111*fae548d3Szrj linker scripts that do not specifically check for
4112*fae548d3Szrj SEGMENT_START automatically get the old semantics. */
4113*fae548d3Szrj if (!s->address_statement.segment
4114*fae548d3Szrj || !s->address_statement.segment->used)
4115*fae548d3Szrj {
4116*fae548d3Szrj const char *name = s->address_statement.section_name;
4117*fae548d3Szrj
4118*fae548d3Szrj /* Create the output section statement here so that
4119*fae548d3Szrj orphans with a set address will be placed after other
4120*fae548d3Szrj script sections. If we let the orphan placement code
4121*fae548d3Szrj place them in amongst other sections then the address
4122*fae548d3Szrj will affect following script sections, which is
4123*fae548d3Szrj likely to surprise naive users. */
4124*fae548d3Szrj tos = lang_output_section_statement_lookup (name, 0, TRUE);
4125*fae548d3Szrj tos->addr_tree = s->address_statement.address;
4126*fae548d3Szrj if (tos->bfd_section == NULL)
4127*fae548d3Szrj init_os (tos, 0);
4128*fae548d3Szrj }
4129*fae548d3Szrj break;
4130*fae548d3Szrj case lang_insert_statement_enum:
4131*fae548d3Szrj break;
4132*fae548d3Szrj }
4133*fae548d3Szrj }
4134*fae548d3Szrj }
4135*fae548d3Szrj
4136*fae548d3Szrj /* An insert statement snips out all the linker statements from the
4137*fae548d3Szrj start of the list and places them after the output section
4138*fae548d3Szrj statement specified by the insert. This operation is complicated
4139*fae548d3Szrj by the fact that we keep a doubly linked list of output section
4140*fae548d3Szrj statements as well as the singly linked list of all statements.
4141*fae548d3Szrj FIXME someday: Twiddling with the list not only moves statements
4142*fae548d3Szrj from the user's script but also input and group statements that are
4143*fae548d3Szrj built from command line object files and --start-group. We only
4144*fae548d3Szrj get away with this because the list pointers used by file_chain
4145*fae548d3Szrj and input_file_chain are not reordered, and processing via
4146*fae548d3Szrj statement_list after this point mostly ignores input statements.
4147*fae548d3Szrj One exception is the map file, where LOAD and START GROUP/END GROUP
4148*fae548d3Szrj can end up looking odd. */
4149*fae548d3Szrj
4150*fae548d3Szrj static void
process_insert_statements(lang_statement_union_type ** start)4151*fae548d3Szrj process_insert_statements (lang_statement_union_type **start)
4152*fae548d3Szrj {
4153*fae548d3Szrj lang_statement_union_type **s;
4154*fae548d3Szrj lang_output_section_statement_type *first_os = NULL;
4155*fae548d3Szrj lang_output_section_statement_type *last_os = NULL;
4156*fae548d3Szrj lang_output_section_statement_type *os;
4157*fae548d3Szrj
4158*fae548d3Szrj s = start;
4159*fae548d3Szrj while (*s != NULL)
4160*fae548d3Szrj {
4161*fae548d3Szrj if ((*s)->header.type == lang_output_section_statement_enum)
4162*fae548d3Szrj {
4163*fae548d3Szrj /* Keep pointers to the first and last output section
4164*fae548d3Szrj statement in the sequence we may be about to move. */
4165*fae548d3Szrj os = &(*s)->output_section_statement;
4166*fae548d3Szrj
4167*fae548d3Szrj ASSERT (last_os == NULL || last_os->next == os);
4168*fae548d3Szrj last_os = os;
4169*fae548d3Szrj
4170*fae548d3Szrj /* Set constraint negative so that lang_output_section_find
4171*fae548d3Szrj won't match this output section statement. At this
4172*fae548d3Szrj stage in linking constraint has values in the range
4173*fae548d3Szrj [-1, ONLY_IN_RW]. */
4174*fae548d3Szrj last_os->constraint = -2 - last_os->constraint;
4175*fae548d3Szrj if (first_os == NULL)
4176*fae548d3Szrj first_os = last_os;
4177*fae548d3Szrj }
4178*fae548d3Szrj else if ((*s)->header.type == lang_group_statement_enum)
4179*fae548d3Szrj {
4180*fae548d3Szrj /* A user might put -T between --start-group and
4181*fae548d3Szrj --end-group. One way this odd construct might arise is
4182*fae548d3Szrj from a wrapper around ld to change library search
4183*fae548d3Szrj behaviour. For example:
4184*fae548d3Szrj #! /bin/sh
4185*fae548d3Szrj exec real_ld --start-group "$@" --end-group
4186*fae548d3Szrj This isn't completely unreasonable so go looking inside a
4187*fae548d3Szrj group statement for insert statements. */
4188*fae548d3Szrj process_insert_statements (&(*s)->group_statement.children.head);
4189*fae548d3Szrj }
4190*fae548d3Szrj else if ((*s)->header.type == lang_insert_statement_enum)
4191*fae548d3Szrj {
4192*fae548d3Szrj lang_insert_statement_type *i = &(*s)->insert_statement;
4193*fae548d3Szrj lang_output_section_statement_type *where;
4194*fae548d3Szrj lang_statement_union_type **ptr;
4195*fae548d3Szrj lang_statement_union_type *first;
4196*fae548d3Szrj
4197*fae548d3Szrj where = lang_output_section_find (i->where);
4198*fae548d3Szrj if (where != NULL && i->is_before)
4199*fae548d3Szrj {
4200*fae548d3Szrj do
4201*fae548d3Szrj where = where->prev;
4202*fae548d3Szrj while (where != NULL && where->constraint < 0);
4203*fae548d3Szrj }
4204*fae548d3Szrj if (where == NULL)
4205*fae548d3Szrj {
4206*fae548d3Szrj einfo (_("%F%P: %s not found for insert\n"), i->where);
4207*fae548d3Szrj return;
4208*fae548d3Szrj }
4209*fae548d3Szrj
4210*fae548d3Szrj /* Deal with reordering the output section statement list. */
4211*fae548d3Szrj if (last_os != NULL)
4212*fae548d3Szrj {
4213*fae548d3Szrj asection *first_sec, *last_sec;
4214*fae548d3Szrj struct lang_output_section_statement_struct **next;
4215*fae548d3Szrj
4216*fae548d3Szrj /* Snip out the output sections we are moving. */
4217*fae548d3Szrj first_os->prev->next = last_os->next;
4218*fae548d3Szrj if (last_os->next == NULL)
4219*fae548d3Szrj {
4220*fae548d3Szrj next = &first_os->prev->next;
4221*fae548d3Szrj lang_os_list.tail = (lang_statement_union_type **) next;
4222*fae548d3Szrj }
4223*fae548d3Szrj else
4224*fae548d3Szrj last_os->next->prev = first_os->prev;
4225*fae548d3Szrj /* Add them in at the new position. */
4226*fae548d3Szrj last_os->next = where->next;
4227*fae548d3Szrj if (where->next == NULL)
4228*fae548d3Szrj {
4229*fae548d3Szrj next = &last_os->next;
4230*fae548d3Szrj lang_os_list.tail = (lang_statement_union_type **) next;
4231*fae548d3Szrj }
4232*fae548d3Szrj else
4233*fae548d3Szrj where->next->prev = last_os;
4234*fae548d3Szrj first_os->prev = where;
4235*fae548d3Szrj where->next = first_os;
4236*fae548d3Szrj
4237*fae548d3Szrj /* Move the bfd sections in the same way. */
4238*fae548d3Szrj first_sec = NULL;
4239*fae548d3Szrj last_sec = NULL;
4240*fae548d3Szrj for (os = first_os; os != NULL; os = os->next)
4241*fae548d3Szrj {
4242*fae548d3Szrj os->constraint = -2 - os->constraint;
4243*fae548d3Szrj if (os->bfd_section != NULL
4244*fae548d3Szrj && os->bfd_section->owner != NULL)
4245*fae548d3Szrj {
4246*fae548d3Szrj last_sec = os->bfd_section;
4247*fae548d3Szrj if (first_sec == NULL)
4248*fae548d3Szrj first_sec = last_sec;
4249*fae548d3Szrj }
4250*fae548d3Szrj if (os == last_os)
4251*fae548d3Szrj break;
4252*fae548d3Szrj }
4253*fae548d3Szrj if (last_sec != NULL)
4254*fae548d3Szrj {
4255*fae548d3Szrj asection *sec = where->bfd_section;
4256*fae548d3Szrj if (sec == NULL)
4257*fae548d3Szrj sec = output_prev_sec_find (where);
4258*fae548d3Szrj
4259*fae548d3Szrj /* The place we want to insert must come after the
4260*fae548d3Szrj sections we are moving. So if we find no
4261*fae548d3Szrj section or if the section is the same as our
4262*fae548d3Szrj last section, then no move is needed. */
4263*fae548d3Szrj if (sec != NULL && sec != last_sec)
4264*fae548d3Szrj {
4265*fae548d3Szrj /* Trim them off. */
4266*fae548d3Szrj if (first_sec->prev != NULL)
4267*fae548d3Szrj first_sec->prev->next = last_sec->next;
4268*fae548d3Szrj else
4269*fae548d3Szrj link_info.output_bfd->sections = last_sec->next;
4270*fae548d3Szrj if (last_sec->next != NULL)
4271*fae548d3Szrj last_sec->next->prev = first_sec->prev;
4272*fae548d3Szrj else
4273*fae548d3Szrj link_info.output_bfd->section_last = first_sec->prev;
4274*fae548d3Szrj /* Add back. */
4275*fae548d3Szrj last_sec->next = sec->next;
4276*fae548d3Szrj if (sec->next != NULL)
4277*fae548d3Szrj sec->next->prev = last_sec;
4278*fae548d3Szrj else
4279*fae548d3Szrj link_info.output_bfd->section_last = last_sec;
4280*fae548d3Szrj first_sec->prev = sec;
4281*fae548d3Szrj sec->next = first_sec;
4282*fae548d3Szrj }
4283*fae548d3Szrj }
4284*fae548d3Szrj
4285*fae548d3Szrj first_os = NULL;
4286*fae548d3Szrj last_os = NULL;
4287*fae548d3Szrj }
4288*fae548d3Szrj
4289*fae548d3Szrj ptr = insert_os_after (where);
4290*fae548d3Szrj /* Snip everything from the start of the list, up to and
4291*fae548d3Szrj including the insert statement we are currently processing. */
4292*fae548d3Szrj first = *start;
4293*fae548d3Szrj *start = (*s)->header.next;
4294*fae548d3Szrj /* Add them back where they belong, minus the insert. */
4295*fae548d3Szrj *s = *ptr;
4296*fae548d3Szrj if (*s == NULL)
4297*fae548d3Szrj statement_list.tail = s;
4298*fae548d3Szrj *ptr = first;
4299*fae548d3Szrj s = start;
4300*fae548d3Szrj continue;
4301*fae548d3Szrj }
4302*fae548d3Szrj s = &(*s)->header.next;
4303*fae548d3Szrj }
4304*fae548d3Szrj
4305*fae548d3Szrj /* Undo constraint twiddling. */
4306*fae548d3Szrj for (os = first_os; os != NULL; os = os->next)
4307*fae548d3Szrj {
4308*fae548d3Szrj os->constraint = -2 - os->constraint;
4309*fae548d3Szrj if (os == last_os)
4310*fae548d3Szrj break;
4311*fae548d3Szrj }
4312*fae548d3Szrj }
4313*fae548d3Szrj
4314*fae548d3Szrj /* An output section might have been removed after its statement was
4315*fae548d3Szrj added. For example, ldemul_before_allocation can remove dynamic
4316*fae548d3Szrj sections if they turn out to be not needed. Clean them up here. */
4317*fae548d3Szrj
4318*fae548d3Szrj void
strip_excluded_output_sections(void)4319*fae548d3Szrj strip_excluded_output_sections (void)
4320*fae548d3Szrj {
4321*fae548d3Szrj lang_output_section_statement_type *os;
4322*fae548d3Szrj
4323*fae548d3Szrj /* Run lang_size_sections (if not already done). */
4324*fae548d3Szrj if (expld.phase != lang_mark_phase_enum)
4325*fae548d3Szrj {
4326*fae548d3Szrj expld.phase = lang_mark_phase_enum;
4327*fae548d3Szrj expld.dataseg.phase = exp_seg_none;
4328*fae548d3Szrj one_lang_size_sections_pass (NULL, FALSE);
4329*fae548d3Szrj lang_reset_memory_regions ();
4330*fae548d3Szrj }
4331*fae548d3Szrj
4332*fae548d3Szrj for (os = (void *) lang_os_list.head;
4333*fae548d3Szrj os != NULL;
4334*fae548d3Szrj os = os->next)
4335*fae548d3Szrj {
4336*fae548d3Szrj asection *output_section;
4337*fae548d3Szrj bfd_boolean exclude;
4338*fae548d3Szrj
4339*fae548d3Szrj if (os->constraint < 0)
4340*fae548d3Szrj continue;
4341*fae548d3Szrj
4342*fae548d3Szrj output_section = os->bfd_section;
4343*fae548d3Szrj if (output_section == NULL)
4344*fae548d3Szrj continue;
4345*fae548d3Szrj
4346*fae548d3Szrj exclude = (output_section->rawsize == 0
4347*fae548d3Szrj && (output_section->flags & SEC_KEEP) == 0
4348*fae548d3Szrj && !bfd_section_removed_from_list (link_info.output_bfd,
4349*fae548d3Szrj output_section));
4350*fae548d3Szrj
4351*fae548d3Szrj /* Some sections have not yet been sized, notably .gnu.version,
4352*fae548d3Szrj .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4353*fae548d3Szrj input sections, so don't drop output sections that have such
4354*fae548d3Szrj input sections unless they are also marked SEC_EXCLUDE. */
4355*fae548d3Szrj if (exclude && output_section->map_head.s != NULL)
4356*fae548d3Szrj {
4357*fae548d3Szrj asection *s;
4358*fae548d3Szrj
4359*fae548d3Szrj for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
4360*fae548d3Szrj if ((s->flags & SEC_EXCLUDE) == 0
4361*fae548d3Szrj && ((s->flags & SEC_LINKER_CREATED) != 0
4362*fae548d3Szrj || link_info.emitrelocations))
4363*fae548d3Szrj {
4364*fae548d3Szrj exclude = FALSE;
4365*fae548d3Szrj break;
4366*fae548d3Szrj }
4367*fae548d3Szrj }
4368*fae548d3Szrj
4369*fae548d3Szrj if (exclude)
4370*fae548d3Szrj {
4371*fae548d3Szrj /* We don't set bfd_section to NULL since bfd_section of the
4372*fae548d3Szrj removed output section statement may still be used. */
4373*fae548d3Szrj if (!os->update_dot)
4374*fae548d3Szrj os->ignored = TRUE;
4375*fae548d3Szrj output_section->flags |= SEC_EXCLUDE;
4376*fae548d3Szrj bfd_section_list_remove (link_info.output_bfd, output_section);
4377*fae548d3Szrj link_info.output_bfd->section_count--;
4378*fae548d3Szrj }
4379*fae548d3Szrj }
4380*fae548d3Szrj }
4381*fae548d3Szrj
4382*fae548d3Szrj /* Called from ldwrite to clear out asection.map_head and
4383*fae548d3Szrj asection.map_tail for use as link_orders in ldwrite. */
4384*fae548d3Szrj
4385*fae548d3Szrj void
lang_clear_os_map(void)4386*fae548d3Szrj lang_clear_os_map (void)
4387*fae548d3Szrj {
4388*fae548d3Szrj lang_output_section_statement_type *os;
4389*fae548d3Szrj
4390*fae548d3Szrj if (map_head_is_link_order)
4391*fae548d3Szrj return;
4392*fae548d3Szrj
4393*fae548d3Szrj for (os = (void *) lang_os_list.head;
4394*fae548d3Szrj os != NULL;
4395*fae548d3Szrj os = os->next)
4396*fae548d3Szrj {
4397*fae548d3Szrj asection *output_section;
4398*fae548d3Szrj
4399*fae548d3Szrj if (os->constraint < 0)
4400*fae548d3Szrj continue;
4401*fae548d3Szrj
4402*fae548d3Szrj output_section = os->bfd_section;
4403*fae548d3Szrj if (output_section == NULL)
4404*fae548d3Szrj continue;
4405*fae548d3Szrj
4406*fae548d3Szrj /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4407*fae548d3Szrj output_section->map_head.link_order = NULL;
4408*fae548d3Szrj output_section->map_tail.link_order = NULL;
4409*fae548d3Szrj }
4410*fae548d3Szrj
4411*fae548d3Szrj /* Stop future calls to lang_add_section from messing with map_head
4412*fae548d3Szrj and map_tail link_order fields. */
4413*fae548d3Szrj map_head_is_link_order = TRUE;
4414*fae548d3Szrj }
4415*fae548d3Szrj
4416*fae548d3Szrj static void
print_output_section_statement(lang_output_section_statement_type * output_section_statement)4417*fae548d3Szrj print_output_section_statement
4418*fae548d3Szrj (lang_output_section_statement_type *output_section_statement)
4419*fae548d3Szrj {
4420*fae548d3Szrj asection *section = output_section_statement->bfd_section;
4421*fae548d3Szrj int len;
4422*fae548d3Szrj
4423*fae548d3Szrj if (output_section_statement != abs_output_section)
4424*fae548d3Szrj {
4425*fae548d3Szrj minfo ("\n%s", output_section_statement->name);
4426*fae548d3Szrj
4427*fae548d3Szrj if (section != NULL)
4428*fae548d3Szrj {
4429*fae548d3Szrj print_dot = section->vma;
4430*fae548d3Szrj
4431*fae548d3Szrj len = strlen (output_section_statement->name);
4432*fae548d3Szrj if (len >= SECTION_NAME_MAP_LENGTH - 1)
4433*fae548d3Szrj {
4434*fae548d3Szrj print_nl ();
4435*fae548d3Szrj len = 0;
4436*fae548d3Szrj }
4437*fae548d3Szrj while (len < SECTION_NAME_MAP_LENGTH)
4438*fae548d3Szrj {
4439*fae548d3Szrj print_space ();
4440*fae548d3Szrj ++len;
4441*fae548d3Szrj }
4442*fae548d3Szrj
4443*fae548d3Szrj minfo ("0x%V %W", section->vma, TO_ADDR (section->size));
4444*fae548d3Szrj
4445*fae548d3Szrj if (section->vma != section->lma)
4446*fae548d3Szrj minfo (_(" load address 0x%V"), section->lma);
4447*fae548d3Szrj
4448*fae548d3Szrj if (output_section_statement->update_dot_tree != NULL)
4449*fae548d3Szrj exp_fold_tree (output_section_statement->update_dot_tree,
4450*fae548d3Szrj bfd_abs_section_ptr, &print_dot);
4451*fae548d3Szrj }
4452*fae548d3Szrj
4453*fae548d3Szrj print_nl ();
4454*fae548d3Szrj }
4455*fae548d3Szrj
4456*fae548d3Szrj print_statement_list (output_section_statement->children.head,
4457*fae548d3Szrj output_section_statement);
4458*fae548d3Szrj }
4459*fae548d3Szrj
4460*fae548d3Szrj static void
print_assignment(lang_assignment_statement_type * assignment,lang_output_section_statement_type * output_section)4461*fae548d3Szrj print_assignment (lang_assignment_statement_type *assignment,
4462*fae548d3Szrj lang_output_section_statement_type *output_section)
4463*fae548d3Szrj {
4464*fae548d3Szrj unsigned int i;
4465*fae548d3Szrj bfd_boolean is_dot;
4466*fae548d3Szrj etree_type *tree;
4467*fae548d3Szrj asection *osec;
4468*fae548d3Szrj
4469*fae548d3Szrj for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4470*fae548d3Szrj print_space ();
4471*fae548d3Szrj
4472*fae548d3Szrj if (assignment->exp->type.node_class == etree_assert)
4473*fae548d3Szrj {
4474*fae548d3Szrj is_dot = FALSE;
4475*fae548d3Szrj tree = assignment->exp->assert_s.child;
4476*fae548d3Szrj }
4477*fae548d3Szrj else
4478*fae548d3Szrj {
4479*fae548d3Szrj const char *dst = assignment->exp->assign.dst;
4480*fae548d3Szrj
4481*fae548d3Szrj is_dot = (dst[0] == '.' && dst[1] == 0);
4482*fae548d3Szrj tree = assignment->exp;
4483*fae548d3Szrj }
4484*fae548d3Szrj
4485*fae548d3Szrj osec = output_section->bfd_section;
4486*fae548d3Szrj if (osec == NULL)
4487*fae548d3Szrj osec = bfd_abs_section_ptr;
4488*fae548d3Szrj
4489*fae548d3Szrj if (assignment->exp->type.node_class != etree_provide)
4490*fae548d3Szrj exp_fold_tree (tree, osec, &print_dot);
4491*fae548d3Szrj else
4492*fae548d3Szrj expld.result.valid_p = FALSE;
4493*fae548d3Szrj
4494*fae548d3Szrj if (expld.result.valid_p)
4495*fae548d3Szrj {
4496*fae548d3Szrj bfd_vma value;
4497*fae548d3Szrj
4498*fae548d3Szrj if (assignment->exp->type.node_class == etree_assert
4499*fae548d3Szrj || is_dot
4500*fae548d3Szrj || expld.assign_name != NULL)
4501*fae548d3Szrj {
4502*fae548d3Szrj value = expld.result.value;
4503*fae548d3Szrj
4504*fae548d3Szrj if (expld.result.section != NULL)
4505*fae548d3Szrj value += expld.result.section->vma;
4506*fae548d3Szrj
4507*fae548d3Szrj minfo ("0x%V", value);
4508*fae548d3Szrj if (is_dot)
4509*fae548d3Szrj print_dot = value;
4510*fae548d3Szrj }
4511*fae548d3Szrj else
4512*fae548d3Szrj {
4513*fae548d3Szrj struct bfd_link_hash_entry *h;
4514*fae548d3Szrj
4515*fae548d3Szrj h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
4516*fae548d3Szrj FALSE, FALSE, TRUE);
4517*fae548d3Szrj if (h != NULL
4518*fae548d3Szrj && (h->type == bfd_link_hash_defined
4519*fae548d3Szrj || h->type == bfd_link_hash_defweak))
4520*fae548d3Szrj {
4521*fae548d3Szrj value = h->u.def.value;
4522*fae548d3Szrj value += h->u.def.section->output_section->vma;
4523*fae548d3Szrj value += h->u.def.section->output_offset;
4524*fae548d3Szrj
4525*fae548d3Szrj minfo ("[0x%V]", value);
4526*fae548d3Szrj }
4527*fae548d3Szrj else
4528*fae548d3Szrj minfo ("[unresolved]");
4529*fae548d3Szrj }
4530*fae548d3Szrj }
4531*fae548d3Szrj else
4532*fae548d3Szrj {
4533*fae548d3Szrj if (assignment->exp->type.node_class == etree_provide)
4534*fae548d3Szrj minfo ("[!provide]");
4535*fae548d3Szrj else
4536*fae548d3Szrj minfo ("*undef* ");
4537*fae548d3Szrj #ifdef BFD64
4538*fae548d3Szrj minfo (" ");
4539*fae548d3Szrj #endif
4540*fae548d3Szrj }
4541*fae548d3Szrj expld.assign_name = NULL;
4542*fae548d3Szrj
4543*fae548d3Szrj minfo (" ");
4544*fae548d3Szrj exp_print_tree (assignment->exp);
4545*fae548d3Szrj print_nl ();
4546*fae548d3Szrj }
4547*fae548d3Szrj
4548*fae548d3Szrj static void
print_input_statement(lang_input_statement_type * statm)4549*fae548d3Szrj print_input_statement (lang_input_statement_type *statm)
4550*fae548d3Szrj {
4551*fae548d3Szrj if (statm->filename != NULL)
4552*fae548d3Szrj fprintf (config.map_file, "LOAD %s\n", statm->filename);
4553*fae548d3Szrj }
4554*fae548d3Szrj
4555*fae548d3Szrj /* Print all symbols defined in a particular section. This is called
4556*fae548d3Szrj via bfd_link_hash_traverse, or by print_all_symbols. */
4557*fae548d3Szrj
4558*fae548d3Szrj static bfd_boolean
print_one_symbol(struct bfd_link_hash_entry * hash_entry,void * ptr)4559*fae548d3Szrj print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
4560*fae548d3Szrj {
4561*fae548d3Szrj asection *sec = (asection *) ptr;
4562*fae548d3Szrj
4563*fae548d3Szrj if ((hash_entry->type == bfd_link_hash_defined
4564*fae548d3Szrj || hash_entry->type == bfd_link_hash_defweak)
4565*fae548d3Szrj && sec == hash_entry->u.def.section)
4566*fae548d3Szrj {
4567*fae548d3Szrj int i;
4568*fae548d3Szrj
4569*fae548d3Szrj for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4570*fae548d3Szrj print_space ();
4571*fae548d3Szrj minfo ("0x%V ",
4572*fae548d3Szrj (hash_entry->u.def.value
4573*fae548d3Szrj + hash_entry->u.def.section->output_offset
4574*fae548d3Szrj + hash_entry->u.def.section->output_section->vma));
4575*fae548d3Szrj
4576*fae548d3Szrj minfo (" %pT\n", hash_entry->root.string);
4577*fae548d3Szrj }
4578*fae548d3Szrj
4579*fae548d3Szrj return TRUE;
4580*fae548d3Szrj }
4581*fae548d3Szrj
4582*fae548d3Szrj static int
hash_entry_addr_cmp(const void * a,const void * b)4583*fae548d3Szrj hash_entry_addr_cmp (const void *a, const void *b)
4584*fae548d3Szrj {
4585*fae548d3Szrj const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a;
4586*fae548d3Szrj const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b;
4587*fae548d3Szrj
4588*fae548d3Szrj if (l->u.def.value < r->u.def.value)
4589*fae548d3Szrj return -1;
4590*fae548d3Szrj else if (l->u.def.value > r->u.def.value)
4591*fae548d3Szrj return 1;
4592*fae548d3Szrj else
4593*fae548d3Szrj return 0;
4594*fae548d3Szrj }
4595*fae548d3Szrj
4596*fae548d3Szrj static void
print_all_symbols(asection * sec)4597*fae548d3Szrj print_all_symbols (asection *sec)
4598*fae548d3Szrj {
4599*fae548d3Szrj input_section_userdata_type *ud = bfd_section_userdata (sec);
4600*fae548d3Szrj struct map_symbol_def *def;
4601*fae548d3Szrj struct bfd_link_hash_entry **entries;
4602*fae548d3Szrj unsigned int i;
4603*fae548d3Szrj
4604*fae548d3Szrj if (!ud)
4605*fae548d3Szrj return;
4606*fae548d3Szrj
4607*fae548d3Szrj *ud->map_symbol_def_tail = 0;
4608*fae548d3Szrj
4609*fae548d3Szrj /* Sort the symbols by address. */
4610*fae548d3Szrj entries = (struct bfd_link_hash_entry **)
4611*fae548d3Szrj obstack_alloc (&map_obstack,
4612*fae548d3Szrj ud->map_symbol_def_count * sizeof (*entries));
4613*fae548d3Szrj
4614*fae548d3Szrj for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)
4615*fae548d3Szrj entries[i] = def->entry;
4616*fae548d3Szrj
4617*fae548d3Szrj qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
4618*fae548d3Szrj hash_entry_addr_cmp);
4619*fae548d3Szrj
4620*fae548d3Szrj /* Print the symbols. */
4621*fae548d3Szrj for (i = 0; i < ud->map_symbol_def_count; i++)
4622*fae548d3Szrj print_one_symbol (entries[i], sec);
4623*fae548d3Szrj
4624*fae548d3Szrj obstack_free (&map_obstack, entries);
4625*fae548d3Szrj }
4626*fae548d3Szrj
4627*fae548d3Szrj /* Print information about an input section to the map file. */
4628*fae548d3Szrj
4629*fae548d3Szrj static void
print_input_section(asection * i,bfd_boolean is_discarded)4630*fae548d3Szrj print_input_section (asection *i, bfd_boolean is_discarded)
4631*fae548d3Szrj {
4632*fae548d3Szrj bfd_size_type size = i->size;
4633*fae548d3Szrj int len;
4634*fae548d3Szrj bfd_vma addr;
4635*fae548d3Szrj
4636*fae548d3Szrj init_opb (i);
4637*fae548d3Szrj
4638*fae548d3Szrj print_space ();
4639*fae548d3Szrj minfo ("%s", i->name);
4640*fae548d3Szrj
4641*fae548d3Szrj len = 1 + strlen (i->name);
4642*fae548d3Szrj if (len >= SECTION_NAME_MAP_LENGTH - 1)
4643*fae548d3Szrj {
4644*fae548d3Szrj print_nl ();
4645*fae548d3Szrj len = 0;
4646*fae548d3Szrj }
4647*fae548d3Szrj while (len < SECTION_NAME_MAP_LENGTH)
4648*fae548d3Szrj {
4649*fae548d3Szrj print_space ();
4650*fae548d3Szrj ++len;
4651*fae548d3Szrj }
4652*fae548d3Szrj
4653*fae548d3Szrj if (i->output_section != NULL
4654*fae548d3Szrj && i->output_section->owner == link_info.output_bfd)
4655*fae548d3Szrj addr = i->output_section->vma + i->output_offset;
4656*fae548d3Szrj else
4657*fae548d3Szrj {
4658*fae548d3Szrj addr = print_dot;
4659*fae548d3Szrj if (!is_discarded)
4660*fae548d3Szrj size = 0;
4661*fae548d3Szrj }
4662*fae548d3Szrj
4663*fae548d3Szrj minfo ("0x%V %W %pB\n", addr, TO_ADDR (size), i->owner);
4664*fae548d3Szrj
4665*fae548d3Szrj if (size != i->rawsize && i->rawsize != 0)
4666*fae548d3Szrj {
4667*fae548d3Szrj len = SECTION_NAME_MAP_LENGTH + 3;
4668*fae548d3Szrj #ifdef BFD64
4669*fae548d3Szrj len += 16;
4670*fae548d3Szrj #else
4671*fae548d3Szrj len += 8;
4672*fae548d3Szrj #endif
4673*fae548d3Szrj while (len > 0)
4674*fae548d3Szrj {
4675*fae548d3Szrj print_space ();
4676*fae548d3Szrj --len;
4677*fae548d3Szrj }
4678*fae548d3Szrj
4679*fae548d3Szrj minfo (_("%W (size before relaxing)\n"), TO_ADDR (i->rawsize));
4680*fae548d3Szrj }
4681*fae548d3Szrj
4682*fae548d3Szrj if (i->output_section != NULL
4683*fae548d3Szrj && i->output_section->owner == link_info.output_bfd)
4684*fae548d3Szrj {
4685*fae548d3Szrj if (link_info.reduce_memory_overheads)
4686*fae548d3Szrj bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
4687*fae548d3Szrj else
4688*fae548d3Szrj print_all_symbols (i);
4689*fae548d3Szrj
4690*fae548d3Szrj /* Update print_dot, but make sure that we do not move it
4691*fae548d3Szrj backwards - this could happen if we have overlays and a
4692*fae548d3Szrj later overlay is shorter than an earier one. */
4693*fae548d3Szrj if (addr + TO_ADDR (size) > print_dot)
4694*fae548d3Szrj print_dot = addr + TO_ADDR (size);
4695*fae548d3Szrj }
4696*fae548d3Szrj }
4697*fae548d3Szrj
4698*fae548d3Szrj static void
print_fill_statement(lang_fill_statement_type * fill)4699*fae548d3Szrj print_fill_statement (lang_fill_statement_type *fill)
4700*fae548d3Szrj {
4701*fae548d3Szrj size_t size;
4702*fae548d3Szrj unsigned char *p;
4703*fae548d3Szrj fputs (" FILL mask 0x", config.map_file);
4704*fae548d3Szrj for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
4705*fae548d3Szrj fprintf (config.map_file, "%02x", *p);
4706*fae548d3Szrj fputs ("\n", config.map_file);
4707*fae548d3Szrj }
4708*fae548d3Szrj
4709*fae548d3Szrj static void
print_data_statement(lang_data_statement_type * data)4710*fae548d3Szrj print_data_statement (lang_data_statement_type *data)
4711*fae548d3Szrj {
4712*fae548d3Szrj int i;
4713*fae548d3Szrj bfd_vma addr;
4714*fae548d3Szrj bfd_size_type size;
4715*fae548d3Szrj const char *name;
4716*fae548d3Szrj
4717*fae548d3Szrj init_opb (data->output_section);
4718*fae548d3Szrj for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4719*fae548d3Szrj print_space ();
4720*fae548d3Szrj
4721*fae548d3Szrj addr = data->output_offset;
4722*fae548d3Szrj if (data->output_section != NULL)
4723*fae548d3Szrj addr += data->output_section->vma;
4724*fae548d3Szrj
4725*fae548d3Szrj switch (data->type)
4726*fae548d3Szrj {
4727*fae548d3Szrj default:
4728*fae548d3Szrj abort ();
4729*fae548d3Szrj case BYTE:
4730*fae548d3Szrj size = BYTE_SIZE;
4731*fae548d3Szrj name = "BYTE";
4732*fae548d3Szrj break;
4733*fae548d3Szrj case SHORT:
4734*fae548d3Szrj size = SHORT_SIZE;
4735*fae548d3Szrj name = "SHORT";
4736*fae548d3Szrj break;
4737*fae548d3Szrj case LONG:
4738*fae548d3Szrj size = LONG_SIZE;
4739*fae548d3Szrj name = "LONG";
4740*fae548d3Szrj break;
4741*fae548d3Szrj case QUAD:
4742*fae548d3Szrj size = QUAD_SIZE;
4743*fae548d3Szrj name = "QUAD";
4744*fae548d3Szrj break;
4745*fae548d3Szrj case SQUAD:
4746*fae548d3Szrj size = QUAD_SIZE;
4747*fae548d3Szrj name = "SQUAD";
4748*fae548d3Szrj break;
4749*fae548d3Szrj }
4750*fae548d3Szrj
4751*fae548d3Szrj if (size < TO_SIZE ((unsigned) 1))
4752*fae548d3Szrj size = TO_SIZE ((unsigned) 1);
4753*fae548d3Szrj minfo ("0x%V %W %s 0x%v", addr, TO_ADDR (size), name, data->value);
4754*fae548d3Szrj
4755*fae548d3Szrj if (data->exp->type.node_class != etree_value)
4756*fae548d3Szrj {
4757*fae548d3Szrj print_space ();
4758*fae548d3Szrj exp_print_tree (data->exp);
4759*fae548d3Szrj }
4760*fae548d3Szrj
4761*fae548d3Szrj print_nl ();
4762*fae548d3Szrj
4763*fae548d3Szrj print_dot = addr + TO_ADDR (size);
4764*fae548d3Szrj }
4765*fae548d3Szrj
4766*fae548d3Szrj /* Print an address statement. These are generated by options like
4767*fae548d3Szrj -Ttext. */
4768*fae548d3Szrj
4769*fae548d3Szrj static void
print_address_statement(lang_address_statement_type * address)4770*fae548d3Szrj print_address_statement (lang_address_statement_type *address)
4771*fae548d3Szrj {
4772*fae548d3Szrj minfo (_("Address of section %s set to "), address->section_name);
4773*fae548d3Szrj exp_print_tree (address->address);
4774*fae548d3Szrj print_nl ();
4775*fae548d3Szrj }
4776*fae548d3Szrj
4777*fae548d3Szrj /* Print a reloc statement. */
4778*fae548d3Szrj
4779*fae548d3Szrj static void
print_reloc_statement(lang_reloc_statement_type * reloc)4780*fae548d3Szrj print_reloc_statement (lang_reloc_statement_type *reloc)
4781*fae548d3Szrj {
4782*fae548d3Szrj int i;
4783*fae548d3Szrj bfd_vma addr;
4784*fae548d3Szrj bfd_size_type size;
4785*fae548d3Szrj
4786*fae548d3Szrj init_opb (reloc->output_section);
4787*fae548d3Szrj for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4788*fae548d3Szrj print_space ();
4789*fae548d3Szrj
4790*fae548d3Szrj addr = reloc->output_offset;
4791*fae548d3Szrj if (reloc->output_section != NULL)
4792*fae548d3Szrj addr += reloc->output_section->vma;
4793*fae548d3Szrj
4794*fae548d3Szrj size = bfd_get_reloc_size (reloc->howto);
4795*fae548d3Szrj
4796*fae548d3Szrj minfo ("0x%V %W RELOC %s ", addr, TO_ADDR (size), reloc->howto->name);
4797*fae548d3Szrj
4798*fae548d3Szrj if (reloc->name != NULL)
4799*fae548d3Szrj minfo ("%s+", reloc->name);
4800*fae548d3Szrj else
4801*fae548d3Szrj minfo ("%s+", reloc->section->name);
4802*fae548d3Szrj
4803*fae548d3Szrj exp_print_tree (reloc->addend_exp);
4804*fae548d3Szrj
4805*fae548d3Szrj print_nl ();
4806*fae548d3Szrj
4807*fae548d3Szrj print_dot = addr + TO_ADDR (size);
4808*fae548d3Szrj }
4809*fae548d3Szrj
4810*fae548d3Szrj static void
print_padding_statement(lang_padding_statement_type * s)4811*fae548d3Szrj print_padding_statement (lang_padding_statement_type *s)
4812*fae548d3Szrj {
4813*fae548d3Szrj int len;
4814*fae548d3Szrj bfd_vma addr;
4815*fae548d3Szrj
4816*fae548d3Szrj init_opb (s->output_section);
4817*fae548d3Szrj minfo (" *fill*");
4818*fae548d3Szrj
4819*fae548d3Szrj len = sizeof " *fill*" - 1;
4820*fae548d3Szrj while (len < SECTION_NAME_MAP_LENGTH)
4821*fae548d3Szrj {
4822*fae548d3Szrj print_space ();
4823*fae548d3Szrj ++len;
4824*fae548d3Szrj }
4825*fae548d3Szrj
4826*fae548d3Szrj addr = s->output_offset;
4827*fae548d3Szrj if (s->output_section != NULL)
4828*fae548d3Szrj addr += s->output_section->vma;
4829*fae548d3Szrj minfo ("0x%V %W ", addr, TO_ADDR (s->size));
4830*fae548d3Szrj
4831*fae548d3Szrj if (s->fill->size != 0)
4832*fae548d3Szrj {
4833*fae548d3Szrj size_t size;
4834*fae548d3Szrj unsigned char *p;
4835*fae548d3Szrj for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
4836*fae548d3Szrj fprintf (config.map_file, "%02x", *p);
4837*fae548d3Szrj }
4838*fae548d3Szrj
4839*fae548d3Szrj print_nl ();
4840*fae548d3Szrj
4841*fae548d3Szrj print_dot = addr + TO_ADDR (s->size);
4842*fae548d3Szrj }
4843*fae548d3Szrj
4844*fae548d3Szrj static void
print_wild_statement(lang_wild_statement_type * w,lang_output_section_statement_type * os)4845*fae548d3Szrj print_wild_statement (lang_wild_statement_type *w,
4846*fae548d3Szrj lang_output_section_statement_type *os)
4847*fae548d3Szrj {
4848*fae548d3Szrj struct wildcard_list *sec;
4849*fae548d3Szrj
4850*fae548d3Szrj print_space ();
4851*fae548d3Szrj
4852*fae548d3Szrj if (w->exclude_name_list)
4853*fae548d3Szrj {
4854*fae548d3Szrj name_list *tmp;
4855*fae548d3Szrj minfo ("EXCLUDE_FILE(%s", w->exclude_name_list->name);
4856*fae548d3Szrj for (tmp = w->exclude_name_list->next; tmp; tmp = tmp->next)
4857*fae548d3Szrj minfo (" %s", tmp->name);
4858*fae548d3Szrj minfo (") ");
4859*fae548d3Szrj }
4860*fae548d3Szrj
4861*fae548d3Szrj if (w->filenames_sorted)
4862*fae548d3Szrj minfo ("SORT_BY_NAME(");
4863*fae548d3Szrj if (w->filename != NULL)
4864*fae548d3Szrj minfo ("%s", w->filename);
4865*fae548d3Szrj else
4866*fae548d3Szrj minfo ("*");
4867*fae548d3Szrj if (w->filenames_sorted)
4868*fae548d3Szrj minfo (")");
4869*fae548d3Szrj
4870*fae548d3Szrj minfo ("(");
4871*fae548d3Szrj for (sec = w->section_list; sec; sec = sec->next)
4872*fae548d3Szrj {
4873*fae548d3Szrj int closing_paren = 0;
4874*fae548d3Szrj
4875*fae548d3Szrj switch (sec->spec.sorted)
4876*fae548d3Szrj {
4877*fae548d3Szrj case none:
4878*fae548d3Szrj break;
4879*fae548d3Szrj
4880*fae548d3Szrj case by_name:
4881*fae548d3Szrj minfo ("SORT_BY_NAME(");
4882*fae548d3Szrj closing_paren = 1;
4883*fae548d3Szrj break;
4884*fae548d3Szrj
4885*fae548d3Szrj case by_alignment:
4886*fae548d3Szrj minfo ("SORT_BY_ALIGNMENT(");
4887*fae548d3Szrj closing_paren = 1;
4888*fae548d3Szrj break;
4889*fae548d3Szrj
4890*fae548d3Szrj case by_name_alignment:
4891*fae548d3Szrj minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4892*fae548d3Szrj closing_paren = 2;
4893*fae548d3Szrj break;
4894*fae548d3Szrj
4895*fae548d3Szrj case by_alignment_name:
4896*fae548d3Szrj minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4897*fae548d3Szrj closing_paren = 2;
4898*fae548d3Szrj break;
4899*fae548d3Szrj
4900*fae548d3Szrj case by_none:
4901*fae548d3Szrj minfo ("SORT_NONE(");
4902*fae548d3Szrj closing_paren = 1;
4903*fae548d3Szrj break;
4904*fae548d3Szrj
4905*fae548d3Szrj case by_init_priority:
4906*fae548d3Szrj minfo ("SORT_BY_INIT_PRIORITY(");
4907*fae548d3Szrj closing_paren = 1;
4908*fae548d3Szrj break;
4909*fae548d3Szrj }
4910*fae548d3Szrj
4911*fae548d3Szrj if (sec->spec.exclude_name_list != NULL)
4912*fae548d3Szrj {
4913*fae548d3Szrj name_list *tmp;
4914*fae548d3Szrj minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
4915*fae548d3Szrj for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
4916*fae548d3Szrj minfo (" %s", tmp->name);
4917*fae548d3Szrj minfo (") ");
4918*fae548d3Szrj }
4919*fae548d3Szrj if (sec->spec.name != NULL)
4920*fae548d3Szrj minfo ("%s", sec->spec.name);
4921*fae548d3Szrj else
4922*fae548d3Szrj minfo ("*");
4923*fae548d3Szrj for (;closing_paren > 0; closing_paren--)
4924*fae548d3Szrj minfo (")");
4925*fae548d3Szrj if (sec->next)
4926*fae548d3Szrj minfo (" ");
4927*fae548d3Szrj }
4928*fae548d3Szrj minfo (")");
4929*fae548d3Szrj
4930*fae548d3Szrj print_nl ();
4931*fae548d3Szrj
4932*fae548d3Szrj print_statement_list (w->children.head, os);
4933*fae548d3Szrj }
4934*fae548d3Szrj
4935*fae548d3Szrj /* Print a group statement. */
4936*fae548d3Szrj
4937*fae548d3Szrj static void
print_group(lang_group_statement_type * s,lang_output_section_statement_type * os)4938*fae548d3Szrj print_group (lang_group_statement_type *s,
4939*fae548d3Szrj lang_output_section_statement_type *os)
4940*fae548d3Szrj {
4941*fae548d3Szrj fprintf (config.map_file, "START GROUP\n");
4942*fae548d3Szrj print_statement_list (s->children.head, os);
4943*fae548d3Szrj fprintf (config.map_file, "END GROUP\n");
4944*fae548d3Szrj }
4945*fae548d3Szrj
4946*fae548d3Szrj /* Print the list of statements in S.
4947*fae548d3Szrj This can be called for any statement type. */
4948*fae548d3Szrj
4949*fae548d3Szrj static void
print_statement_list(lang_statement_union_type * s,lang_output_section_statement_type * os)4950*fae548d3Szrj print_statement_list (lang_statement_union_type *s,
4951*fae548d3Szrj lang_output_section_statement_type *os)
4952*fae548d3Szrj {
4953*fae548d3Szrj while (s != NULL)
4954*fae548d3Szrj {
4955*fae548d3Szrj print_statement (s, os);
4956*fae548d3Szrj s = s->header.next;
4957*fae548d3Szrj }
4958*fae548d3Szrj }
4959*fae548d3Szrj
4960*fae548d3Szrj /* Print the first statement in statement list S.
4961*fae548d3Szrj This can be called for any statement type. */
4962*fae548d3Szrj
4963*fae548d3Szrj static void
print_statement(lang_statement_union_type * s,lang_output_section_statement_type * os)4964*fae548d3Szrj print_statement (lang_statement_union_type *s,
4965*fae548d3Szrj lang_output_section_statement_type *os)
4966*fae548d3Szrj {
4967*fae548d3Szrj switch (s->header.type)
4968*fae548d3Szrj {
4969*fae548d3Szrj default:
4970*fae548d3Szrj fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
4971*fae548d3Szrj FAIL ();
4972*fae548d3Szrj break;
4973*fae548d3Szrj case lang_constructors_statement_enum:
4974*fae548d3Szrj if (constructor_list.head != NULL)
4975*fae548d3Szrj {
4976*fae548d3Szrj if (constructors_sorted)
4977*fae548d3Szrj minfo (" SORT (CONSTRUCTORS)\n");
4978*fae548d3Szrj else
4979*fae548d3Szrj minfo (" CONSTRUCTORS\n");
4980*fae548d3Szrj print_statement_list (constructor_list.head, os);
4981*fae548d3Szrj }
4982*fae548d3Szrj break;
4983*fae548d3Szrj case lang_wild_statement_enum:
4984*fae548d3Szrj print_wild_statement (&s->wild_statement, os);
4985*fae548d3Szrj break;
4986*fae548d3Szrj case lang_address_statement_enum:
4987*fae548d3Szrj print_address_statement (&s->address_statement);
4988*fae548d3Szrj break;
4989*fae548d3Szrj case lang_object_symbols_statement_enum:
4990*fae548d3Szrj minfo (" CREATE_OBJECT_SYMBOLS\n");
4991*fae548d3Szrj break;
4992*fae548d3Szrj case lang_fill_statement_enum:
4993*fae548d3Szrj print_fill_statement (&s->fill_statement);
4994*fae548d3Szrj break;
4995*fae548d3Szrj case lang_data_statement_enum:
4996*fae548d3Szrj print_data_statement (&s->data_statement);
4997*fae548d3Szrj break;
4998*fae548d3Szrj case lang_reloc_statement_enum:
4999*fae548d3Szrj print_reloc_statement (&s->reloc_statement);
5000*fae548d3Szrj break;
5001*fae548d3Szrj case lang_input_section_enum:
5002*fae548d3Szrj print_input_section (s->input_section.section, FALSE);
5003*fae548d3Szrj break;
5004*fae548d3Szrj case lang_padding_statement_enum:
5005*fae548d3Szrj print_padding_statement (&s->padding_statement);
5006*fae548d3Szrj break;
5007*fae548d3Szrj case lang_output_section_statement_enum:
5008*fae548d3Szrj print_output_section_statement (&s->output_section_statement);
5009*fae548d3Szrj break;
5010*fae548d3Szrj case lang_assignment_statement_enum:
5011*fae548d3Szrj print_assignment (&s->assignment_statement, os);
5012*fae548d3Szrj break;
5013*fae548d3Szrj case lang_target_statement_enum:
5014*fae548d3Szrj fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
5015*fae548d3Szrj break;
5016*fae548d3Szrj case lang_output_statement_enum:
5017*fae548d3Szrj minfo ("OUTPUT(%s", s->output_statement.name);
5018*fae548d3Szrj if (output_target != NULL)
5019*fae548d3Szrj minfo (" %s", output_target);
5020*fae548d3Szrj minfo (")\n");
5021*fae548d3Szrj break;
5022*fae548d3Szrj case lang_input_statement_enum:
5023*fae548d3Szrj print_input_statement (&s->input_statement);
5024*fae548d3Szrj break;
5025*fae548d3Szrj case lang_group_statement_enum:
5026*fae548d3Szrj print_group (&s->group_statement, os);
5027*fae548d3Szrj break;
5028*fae548d3Szrj case lang_insert_statement_enum:
5029*fae548d3Szrj minfo ("INSERT %s %s\n",
5030*fae548d3Szrj s->insert_statement.is_before ? "BEFORE" : "AFTER",
5031*fae548d3Szrj s->insert_statement.where);
5032*fae548d3Szrj break;
5033*fae548d3Szrj }
5034*fae548d3Szrj }
5035*fae548d3Szrj
5036*fae548d3Szrj static void
print_statements(void)5037*fae548d3Szrj print_statements (void)
5038*fae548d3Szrj {
5039*fae548d3Szrj print_statement_list (statement_list.head, abs_output_section);
5040*fae548d3Szrj }
5041*fae548d3Szrj
5042*fae548d3Szrj /* Print the first N statements in statement list S to STDERR.
5043*fae548d3Szrj If N == 0, nothing is printed.
5044*fae548d3Szrj If N < 0, the entire list is printed.
5045*fae548d3Szrj Intended to be called from GDB. */
5046*fae548d3Szrj
5047*fae548d3Szrj void
dprint_statement(lang_statement_union_type * s,int n)5048*fae548d3Szrj dprint_statement (lang_statement_union_type *s, int n)
5049*fae548d3Szrj {
5050*fae548d3Szrj FILE *map_save = config.map_file;
5051*fae548d3Szrj
5052*fae548d3Szrj config.map_file = stderr;
5053*fae548d3Szrj
5054*fae548d3Szrj if (n < 0)
5055*fae548d3Szrj print_statement_list (s, abs_output_section);
5056*fae548d3Szrj else
5057*fae548d3Szrj {
5058*fae548d3Szrj while (s && --n >= 0)
5059*fae548d3Szrj {
5060*fae548d3Szrj print_statement (s, abs_output_section);
5061*fae548d3Szrj s = s->header.next;
5062*fae548d3Szrj }
5063*fae548d3Szrj }
5064*fae548d3Szrj
5065*fae548d3Szrj config.map_file = map_save;
5066*fae548d3Szrj }
5067*fae548d3Szrj
5068*fae548d3Szrj static void
insert_pad(lang_statement_union_type ** ptr,fill_type * fill,bfd_size_type alignment_needed,asection * output_section,bfd_vma dot)5069*fae548d3Szrj insert_pad (lang_statement_union_type **ptr,
5070*fae548d3Szrj fill_type *fill,
5071*fae548d3Szrj bfd_size_type alignment_needed,
5072*fae548d3Szrj asection *output_section,
5073*fae548d3Szrj bfd_vma dot)
5074*fae548d3Szrj {
5075*fae548d3Szrj static fill_type zero_fill;
5076*fae548d3Szrj lang_statement_union_type *pad = NULL;
5077*fae548d3Szrj
5078*fae548d3Szrj if (ptr != &statement_list.head)
5079*fae548d3Szrj pad = ((lang_statement_union_type *)
5080*fae548d3Szrj ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
5081*fae548d3Szrj if (pad != NULL
5082*fae548d3Szrj && pad->header.type == lang_padding_statement_enum
5083*fae548d3Szrj && pad->padding_statement.output_section == output_section)
5084*fae548d3Szrj {
5085*fae548d3Szrj /* Use the existing pad statement. */
5086*fae548d3Szrj }
5087*fae548d3Szrj else if ((pad = *ptr) != NULL
5088*fae548d3Szrj && pad->header.type == lang_padding_statement_enum
5089*fae548d3Szrj && pad->padding_statement.output_section == output_section)
5090*fae548d3Szrj {
5091*fae548d3Szrj /* Use the existing pad statement. */
5092*fae548d3Szrj }
5093*fae548d3Szrj else
5094*fae548d3Szrj {
5095*fae548d3Szrj /* Make a new padding statement, linked into existing chain. */
5096*fae548d3Szrj pad = stat_alloc (sizeof (lang_padding_statement_type));
5097*fae548d3Szrj pad->header.next = *ptr;
5098*fae548d3Szrj *ptr = pad;
5099*fae548d3Szrj pad->header.type = lang_padding_statement_enum;
5100*fae548d3Szrj pad->padding_statement.output_section = output_section;
5101*fae548d3Szrj if (fill == NULL)
5102*fae548d3Szrj fill = &zero_fill;
5103*fae548d3Szrj pad->padding_statement.fill = fill;
5104*fae548d3Szrj }
5105*fae548d3Szrj pad->padding_statement.output_offset = dot - output_section->vma;
5106*fae548d3Szrj pad->padding_statement.size = alignment_needed;
5107*fae548d3Szrj if (!(output_section->flags & SEC_FIXED_SIZE))
5108*fae548d3Szrj output_section->size = TO_SIZE (dot + TO_ADDR (alignment_needed)
5109*fae548d3Szrj - output_section->vma);
5110*fae548d3Szrj }
5111*fae548d3Szrj
5112*fae548d3Szrj /* Work out how much this section will move the dot point. */
5113*fae548d3Szrj
5114*fae548d3Szrj static bfd_vma
size_input_section(lang_statement_union_type ** this_ptr,lang_output_section_statement_type * output_section_statement,fill_type * fill,bfd_vma dot)5115*fae548d3Szrj size_input_section
5116*fae548d3Szrj (lang_statement_union_type **this_ptr,
5117*fae548d3Szrj lang_output_section_statement_type *output_section_statement,
5118*fae548d3Szrj fill_type *fill,
5119*fae548d3Szrj bfd_vma dot)
5120*fae548d3Szrj {
5121*fae548d3Szrj lang_input_section_type *is = &((*this_ptr)->input_section);
5122*fae548d3Szrj asection *i = is->section;
5123*fae548d3Szrj asection *o = output_section_statement->bfd_section;
5124*fae548d3Szrj
5125*fae548d3Szrj if (i->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
5126*fae548d3Szrj i->output_offset = i->vma - o->vma;
5127*fae548d3Szrj else if (((i->flags & SEC_EXCLUDE) != 0)
5128*fae548d3Szrj || output_section_statement->ignored)
5129*fae548d3Szrj i->output_offset = dot - o->vma;
5130*fae548d3Szrj else
5131*fae548d3Szrj {
5132*fae548d3Szrj bfd_size_type alignment_needed;
5133*fae548d3Szrj
5134*fae548d3Szrj /* Align this section first to the input sections requirement,
5135*fae548d3Szrj then to the output section's requirement. If this alignment
5136*fae548d3Szrj is greater than any seen before, then record it too. Perform
5137*fae548d3Szrj the alignment by inserting a magic 'padding' statement. */
5138*fae548d3Szrj
5139*fae548d3Szrj if (output_section_statement->subsection_alignment != NULL)
5140*fae548d3Szrj i->alignment_power
5141*fae548d3Szrj = exp_get_power (output_section_statement->subsection_alignment,
5142*fae548d3Szrj "subsection alignment");
5143*fae548d3Szrj
5144*fae548d3Szrj if (o->alignment_power < i->alignment_power)
5145*fae548d3Szrj o->alignment_power = i->alignment_power;
5146*fae548d3Szrj
5147*fae548d3Szrj alignment_needed = align_power (dot, i->alignment_power) - dot;
5148*fae548d3Szrj
5149*fae548d3Szrj if (alignment_needed != 0)
5150*fae548d3Szrj {
5151*fae548d3Szrj insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
5152*fae548d3Szrj dot += alignment_needed;
5153*fae548d3Szrj }
5154*fae548d3Szrj
5155*fae548d3Szrj /* Remember where in the output section this input section goes. */
5156*fae548d3Szrj i->output_offset = dot - o->vma;
5157*fae548d3Szrj
5158*fae548d3Szrj /* Mark how big the output section must be to contain this now. */
5159*fae548d3Szrj dot += TO_ADDR (i->size);
5160*fae548d3Szrj if (!(o->flags & SEC_FIXED_SIZE))
5161*fae548d3Szrj o->size = TO_SIZE (dot - o->vma);
5162*fae548d3Szrj }
5163*fae548d3Szrj
5164*fae548d3Szrj return dot;
5165*fae548d3Szrj }
5166*fae548d3Szrj
5167*fae548d3Szrj struct check_sec
5168*fae548d3Szrj {
5169*fae548d3Szrj asection *sec;
5170*fae548d3Szrj bfd_boolean warned;
5171*fae548d3Szrj };
5172*fae548d3Szrj
5173*fae548d3Szrj static int
sort_sections_by_lma(const void * arg1,const void * arg2)5174*fae548d3Szrj sort_sections_by_lma (const void *arg1, const void *arg2)
5175*fae548d3Szrj {
5176*fae548d3Szrj const asection *sec1 = ((const struct check_sec *) arg1)->sec;
5177*fae548d3Szrj const asection *sec2 = ((const struct check_sec *) arg2)->sec;
5178*fae548d3Szrj
5179*fae548d3Szrj if (sec1->lma < sec2->lma)
5180*fae548d3Szrj return -1;
5181*fae548d3Szrj else if (sec1->lma > sec2->lma)
5182*fae548d3Szrj return 1;
5183*fae548d3Szrj else if (sec1->id < sec2->id)
5184*fae548d3Szrj return -1;
5185*fae548d3Szrj else if (sec1->id > sec2->id)
5186*fae548d3Szrj return 1;
5187*fae548d3Szrj
5188*fae548d3Szrj return 0;
5189*fae548d3Szrj }
5190*fae548d3Szrj
5191*fae548d3Szrj static int
sort_sections_by_vma(const void * arg1,const void * arg2)5192*fae548d3Szrj sort_sections_by_vma (const void *arg1, const void *arg2)
5193*fae548d3Szrj {
5194*fae548d3Szrj const asection *sec1 = ((const struct check_sec *) arg1)->sec;
5195*fae548d3Szrj const asection *sec2 = ((const struct check_sec *) arg2)->sec;
5196*fae548d3Szrj
5197*fae548d3Szrj if (sec1->vma < sec2->vma)
5198*fae548d3Szrj return -1;
5199*fae548d3Szrj else if (sec1->vma > sec2->vma)
5200*fae548d3Szrj return 1;
5201*fae548d3Szrj else if (sec1->id < sec2->id)
5202*fae548d3Szrj return -1;
5203*fae548d3Szrj else if (sec1->id > sec2->id)
5204*fae548d3Szrj return 1;
5205*fae548d3Szrj
5206*fae548d3Szrj return 0;
5207*fae548d3Szrj }
5208*fae548d3Szrj
5209*fae548d3Szrj #define IS_TBSS(s) \
5210*fae548d3Szrj ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5211*fae548d3Szrj
5212*fae548d3Szrj #define IGNORE_SECTION(s) \
5213*fae548d3Szrj ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5214*fae548d3Szrj
5215*fae548d3Szrj /* Check to see if any allocated sections overlap with other allocated
5216*fae548d3Szrj sections. This can happen if a linker script specifies the output
5217*fae548d3Szrj section addresses of the two sections. Also check whether any memory
5218*fae548d3Szrj region has overflowed. */
5219*fae548d3Szrj
5220*fae548d3Szrj static void
lang_check_section_addresses(void)5221*fae548d3Szrj lang_check_section_addresses (void)
5222*fae548d3Szrj {
5223*fae548d3Szrj asection *s, *p;
5224*fae548d3Szrj struct check_sec *sections;
5225*fae548d3Szrj size_t i, count;
5226*fae548d3Szrj bfd_vma addr_mask;
5227*fae548d3Szrj bfd_vma s_start;
5228*fae548d3Szrj bfd_vma s_end;
5229*fae548d3Szrj bfd_vma p_start = 0;
5230*fae548d3Szrj bfd_vma p_end = 0;
5231*fae548d3Szrj lang_memory_region_type *m;
5232*fae548d3Szrj bfd_boolean overlays;
5233*fae548d3Szrj
5234*fae548d3Szrj /* Detect address space overflow on allocated sections. */
5235*fae548d3Szrj addr_mask = ((bfd_vma) 1 <<
5236*fae548d3Szrj (bfd_arch_bits_per_address (link_info.output_bfd) - 1)) - 1;
5237*fae548d3Szrj addr_mask = (addr_mask << 1) + 1;
5238*fae548d3Szrj for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5239*fae548d3Szrj if ((s->flags & SEC_ALLOC) != 0)
5240*fae548d3Szrj {
5241*fae548d3Szrj s_end = (s->vma + s->size) & addr_mask;
5242*fae548d3Szrj if (s_end != 0 && s_end < (s->vma & addr_mask))
5243*fae548d3Szrj einfo (_("%X%P: section %s VMA wraps around address space\n"),
5244*fae548d3Szrj s->name);
5245*fae548d3Szrj else
5246*fae548d3Szrj {
5247*fae548d3Szrj s_end = (s->lma + s->size) & addr_mask;
5248*fae548d3Szrj if (s_end != 0 && s_end < (s->lma & addr_mask))
5249*fae548d3Szrj einfo (_("%X%P: section %s LMA wraps around address space\n"),
5250*fae548d3Szrj s->name);
5251*fae548d3Szrj }
5252*fae548d3Szrj }
5253*fae548d3Szrj
5254*fae548d3Szrj if (bfd_count_sections (link_info.output_bfd) <= 1)
5255*fae548d3Szrj return;
5256*fae548d3Szrj
5257*fae548d3Szrj count = bfd_count_sections (link_info.output_bfd);
5258*fae548d3Szrj sections = XNEWVEC (struct check_sec, count);
5259*fae548d3Szrj
5260*fae548d3Szrj /* Scan all sections in the output list. */
5261*fae548d3Szrj count = 0;
5262*fae548d3Szrj for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5263*fae548d3Szrj {
5264*fae548d3Szrj if (IGNORE_SECTION (s)
5265*fae548d3Szrj || s->size == 0)
5266*fae548d3Szrj continue;
5267*fae548d3Szrj
5268*fae548d3Szrj sections[count].sec = s;
5269*fae548d3Szrj sections[count].warned = FALSE;
5270*fae548d3Szrj count++;
5271*fae548d3Szrj }
5272*fae548d3Szrj
5273*fae548d3Szrj if (count <= 1)
5274*fae548d3Szrj {
5275*fae548d3Szrj free (sections);
5276*fae548d3Szrj return;
5277*fae548d3Szrj }
5278*fae548d3Szrj
5279*fae548d3Szrj qsort (sections, count, sizeof (*sections), sort_sections_by_lma);
5280*fae548d3Szrj
5281*fae548d3Szrj /* First check section LMAs. There should be no overlap of LMAs on
5282*fae548d3Szrj loadable sections, even with overlays. */
5283*fae548d3Szrj for (p = NULL, i = 0; i < count; i++)
5284*fae548d3Szrj {
5285*fae548d3Szrj s = sections[i].sec;
5286*fae548d3Szrj init_opb (s);
5287*fae548d3Szrj if ((s->flags & SEC_LOAD) != 0)
5288*fae548d3Szrj {
5289*fae548d3Szrj s_start = s->lma;
5290*fae548d3Szrj s_end = s_start + TO_ADDR (s->size) - 1;
5291*fae548d3Szrj
5292*fae548d3Szrj /* Look for an overlap. We have sorted sections by lma, so
5293*fae548d3Szrj we know that s_start >= p_start. Besides the obvious
5294*fae548d3Szrj case of overlap when the current section starts before
5295*fae548d3Szrj the previous one ends, we also must have overlap if the
5296*fae548d3Szrj previous section wraps around the address space. */
5297*fae548d3Szrj if (p != NULL
5298*fae548d3Szrj && (s_start <= p_end
5299*fae548d3Szrj || p_end < p_start))
5300*fae548d3Szrj {
5301*fae548d3Szrj einfo (_("%X%P: section %s LMA [%V,%V]"
5302*fae548d3Szrj " overlaps section %s LMA [%V,%V]\n"),
5303*fae548d3Szrj s->name, s_start, s_end, p->name, p_start, p_end);
5304*fae548d3Szrj sections[i].warned = TRUE;
5305*fae548d3Szrj }
5306*fae548d3Szrj p = s;
5307*fae548d3Szrj p_start = s_start;
5308*fae548d3Szrj p_end = s_end;
5309*fae548d3Szrj }
5310*fae548d3Szrj }
5311*fae548d3Szrj
5312*fae548d3Szrj /* If any non-zero size allocated section (excluding tbss) starts at
5313*fae548d3Szrj exactly the same VMA as another such section, then we have
5314*fae548d3Szrj overlays. Overlays generated by the OVERLAY keyword will have
5315*fae548d3Szrj this property. It is possible to intentionally generate overlays
5316*fae548d3Szrj that fail this test, but it would be unusual. */
5317*fae548d3Szrj qsort (sections, count, sizeof (*sections), sort_sections_by_vma);
5318*fae548d3Szrj overlays = FALSE;
5319*fae548d3Szrj p_start = sections[0].sec->vma;
5320*fae548d3Szrj for (i = 1; i < count; i++)
5321*fae548d3Szrj {
5322*fae548d3Szrj s_start = sections[i].sec->vma;
5323*fae548d3Szrj if (p_start == s_start)
5324*fae548d3Szrj {
5325*fae548d3Szrj overlays = TRUE;
5326*fae548d3Szrj break;
5327*fae548d3Szrj }
5328*fae548d3Szrj p_start = s_start;
5329*fae548d3Szrj }
5330*fae548d3Szrj
5331*fae548d3Szrj /* Now check section VMAs if no overlays were detected. */
5332*fae548d3Szrj if (!overlays)
5333*fae548d3Szrj {
5334*fae548d3Szrj for (p = NULL, i = 0; i < count; i++)
5335*fae548d3Szrj {
5336*fae548d3Szrj s = sections[i].sec;
5337*fae548d3Szrj init_opb (s);
5338*fae548d3Szrj s_start = s->vma;
5339*fae548d3Szrj s_end = s_start + TO_ADDR (s->size) - 1;
5340*fae548d3Szrj
5341*fae548d3Szrj if (p != NULL
5342*fae548d3Szrj && !sections[i].warned
5343*fae548d3Szrj && (s_start <= p_end
5344*fae548d3Szrj || p_end < p_start))
5345*fae548d3Szrj einfo (_("%X%P: section %s VMA [%V,%V]"
5346*fae548d3Szrj " overlaps section %s VMA [%V,%V]\n"),
5347*fae548d3Szrj s->name, s_start, s_end, p->name, p_start, p_end);
5348*fae548d3Szrj p = s;
5349*fae548d3Szrj p_start = s_start;
5350*fae548d3Szrj p_end = s_end;
5351*fae548d3Szrj }
5352*fae548d3Szrj }
5353*fae548d3Szrj
5354*fae548d3Szrj free (sections);
5355*fae548d3Szrj
5356*fae548d3Szrj /* If any memory region has overflowed, report by how much.
5357*fae548d3Szrj We do not issue this diagnostic for regions that had sections
5358*fae548d3Szrj explicitly placed outside their bounds; os_region_check's
5359*fae548d3Szrj diagnostics are adequate for that case.
5360*fae548d3Szrj
5361*fae548d3Szrj FIXME: It is conceivable that m->current - (m->origin + m->length)
5362*fae548d3Szrj might overflow a 32-bit integer. There is, alas, no way to print
5363*fae548d3Szrj a bfd_vma quantity in decimal. */
5364*fae548d3Szrj for (m = lang_memory_region_list; m; m = m->next)
5365*fae548d3Szrj if (m->had_full_message)
5366*fae548d3Szrj {
5367*fae548d3Szrj unsigned long over = m->current - (m->origin + m->length);
5368*fae548d3Szrj einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5369*fae548d3Szrj "%X%P: region `%s' overflowed by %lu bytes\n",
5370*fae548d3Szrj over),
5371*fae548d3Szrj m->name_list.name, over);
5372*fae548d3Szrj }
5373*fae548d3Szrj }
5374*fae548d3Szrj
5375*fae548d3Szrj /* Make sure the new address is within the region. We explicitly permit the
5376*fae548d3Szrj current address to be at the exact end of the region when the address is
5377*fae548d3Szrj non-zero, in case the region is at the end of addressable memory and the
5378*fae548d3Szrj calculation wraps around. */
5379*fae548d3Szrj
5380*fae548d3Szrj static void
os_region_check(lang_output_section_statement_type * os,lang_memory_region_type * region,etree_type * tree,bfd_vma rbase)5381*fae548d3Szrj os_region_check (lang_output_section_statement_type *os,
5382*fae548d3Szrj lang_memory_region_type *region,
5383*fae548d3Szrj etree_type *tree,
5384*fae548d3Szrj bfd_vma rbase)
5385*fae548d3Szrj {
5386*fae548d3Szrj if ((region->current < region->origin
5387*fae548d3Szrj || (region->current - region->origin > region->length))
5388*fae548d3Szrj && ((region->current != region->origin + region->length)
5389*fae548d3Szrj || rbase == 0))
5390*fae548d3Szrj {
5391*fae548d3Szrj if (tree != NULL)
5392*fae548d3Szrj {
5393*fae548d3Szrj einfo (_("%X%P: address 0x%v of %pB section `%s'"
5394*fae548d3Szrj " is not within region `%s'\n"),
5395*fae548d3Szrj region->current,
5396*fae548d3Szrj os->bfd_section->owner,
5397*fae548d3Szrj os->bfd_section->name,
5398*fae548d3Szrj region->name_list.name);
5399*fae548d3Szrj }
5400*fae548d3Szrj else if (!region->had_full_message)
5401*fae548d3Szrj {
5402*fae548d3Szrj region->had_full_message = TRUE;
5403*fae548d3Szrj
5404*fae548d3Szrj einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5405*fae548d3Szrj os->bfd_section->owner,
5406*fae548d3Szrj os->bfd_section->name,
5407*fae548d3Szrj region->name_list.name);
5408*fae548d3Szrj }
5409*fae548d3Szrj }
5410*fae548d3Szrj }
5411*fae548d3Szrj
5412*fae548d3Szrj static void
ldlang_check_relro_region(lang_statement_union_type * s,seg_align_type * seg)5413*fae548d3Szrj ldlang_check_relro_region (lang_statement_union_type *s,
5414*fae548d3Szrj seg_align_type *seg)
5415*fae548d3Szrj {
5416*fae548d3Szrj if (seg->relro == exp_seg_relro_start)
5417*fae548d3Szrj {
5418*fae548d3Szrj if (!seg->relro_start_stat)
5419*fae548d3Szrj seg->relro_start_stat = s;
5420*fae548d3Szrj else
5421*fae548d3Szrj {
5422*fae548d3Szrj ASSERT (seg->relro_start_stat == s);
5423*fae548d3Szrj }
5424*fae548d3Szrj }
5425*fae548d3Szrj else if (seg->relro == exp_seg_relro_end)
5426*fae548d3Szrj {
5427*fae548d3Szrj if (!seg->relro_end_stat)
5428*fae548d3Szrj seg->relro_end_stat = s;
5429*fae548d3Szrj else
5430*fae548d3Szrj {
5431*fae548d3Szrj ASSERT (seg->relro_end_stat == s);
5432*fae548d3Szrj }
5433*fae548d3Szrj }
5434*fae548d3Szrj }
5435*fae548d3Szrj
5436*fae548d3Szrj /* Set the sizes for all the output sections. */
5437*fae548d3Szrj
5438*fae548d3Szrj static bfd_vma
lang_size_sections_1(lang_statement_union_type ** prev,lang_output_section_statement_type * output_section_statement,fill_type * fill,bfd_vma dot,bfd_boolean * relax,bfd_boolean check_regions)5439*fae548d3Szrj lang_size_sections_1
5440*fae548d3Szrj (lang_statement_union_type **prev,
5441*fae548d3Szrj lang_output_section_statement_type *output_section_statement,
5442*fae548d3Szrj fill_type *fill,
5443*fae548d3Szrj bfd_vma dot,
5444*fae548d3Szrj bfd_boolean *relax,
5445*fae548d3Szrj bfd_boolean check_regions)
5446*fae548d3Szrj {
5447*fae548d3Szrj lang_statement_union_type *s;
5448*fae548d3Szrj
5449*fae548d3Szrj /* Size up the sections from their constituent parts. */
5450*fae548d3Szrj for (s = *prev; s != NULL; s = s->header.next)
5451*fae548d3Szrj {
5452*fae548d3Szrj switch (s->header.type)
5453*fae548d3Szrj {
5454*fae548d3Szrj case lang_output_section_statement_enum:
5455*fae548d3Szrj {
5456*fae548d3Szrj bfd_vma newdot, after, dotdelta;
5457*fae548d3Szrj lang_output_section_statement_type *os;
5458*fae548d3Szrj lang_memory_region_type *r;
5459*fae548d3Szrj int section_alignment = 0;
5460*fae548d3Szrj
5461*fae548d3Szrj os = &s->output_section_statement;
5462*fae548d3Szrj init_opb (os->bfd_section);
5463*fae548d3Szrj if (os->constraint == -1)
5464*fae548d3Szrj break;
5465*fae548d3Szrj
5466*fae548d3Szrj /* FIXME: We shouldn't need to zero section vmas for ld -r
5467*fae548d3Szrj here, in lang_insert_orphan, or in the default linker scripts.
5468*fae548d3Szrj This is covering for coff backend linker bugs. See PR6945. */
5469*fae548d3Szrj if (os->addr_tree == NULL
5470*fae548d3Szrj && bfd_link_relocatable (&link_info)
5471*fae548d3Szrj && (bfd_get_flavour (link_info.output_bfd)
5472*fae548d3Szrj == bfd_target_coff_flavour))
5473*fae548d3Szrj os->addr_tree = exp_intop (0);
5474*fae548d3Szrj if (os->addr_tree != NULL)
5475*fae548d3Szrj {
5476*fae548d3Szrj os->processed_vma = FALSE;
5477*fae548d3Szrj exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
5478*fae548d3Szrj
5479*fae548d3Szrj if (expld.result.valid_p)
5480*fae548d3Szrj {
5481*fae548d3Szrj dot = expld.result.value;
5482*fae548d3Szrj if (expld.result.section != NULL)
5483*fae548d3Szrj dot += expld.result.section->vma;
5484*fae548d3Szrj }
5485*fae548d3Szrj else if (expld.phase != lang_mark_phase_enum)
5486*fae548d3Szrj einfo (_("%F%P:%pS: non constant or forward reference"
5487*fae548d3Szrj " address expression for section %s\n"),
5488*fae548d3Szrj os->addr_tree, os->name);
5489*fae548d3Szrj }
5490*fae548d3Szrj
5491*fae548d3Szrj if (os->bfd_section == NULL)
5492*fae548d3Szrj /* This section was removed or never actually created. */
5493*fae548d3Szrj break;
5494*fae548d3Szrj
5495*fae548d3Szrj /* If this is a COFF shared library section, use the size and
5496*fae548d3Szrj address from the input section. FIXME: This is COFF
5497*fae548d3Szrj specific; it would be cleaner if there were some other way
5498*fae548d3Szrj to do this, but nothing simple comes to mind. */
5499*fae548d3Szrj if (((bfd_get_flavour (link_info.output_bfd)
5500*fae548d3Szrj == bfd_target_ecoff_flavour)
5501*fae548d3Szrj || (bfd_get_flavour (link_info.output_bfd)
5502*fae548d3Szrj == bfd_target_coff_flavour))
5503*fae548d3Szrj && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
5504*fae548d3Szrj {
5505*fae548d3Szrj asection *input;
5506*fae548d3Szrj
5507*fae548d3Szrj if (os->children.head == NULL
5508*fae548d3Szrj || os->children.head->header.next != NULL
5509*fae548d3Szrj || (os->children.head->header.type
5510*fae548d3Szrj != lang_input_section_enum))
5511*fae548d3Szrj einfo (_("%X%P: internal error on COFF shared library"
5512*fae548d3Szrj " section %s\n"), os->name);
5513*fae548d3Szrj
5514*fae548d3Szrj input = os->children.head->input_section.section;
5515*fae548d3Szrj bfd_set_section_vma (os->bfd_section,
5516*fae548d3Szrj bfd_section_vma (input));
5517*fae548d3Szrj if (!(os->bfd_section->flags & SEC_FIXED_SIZE))
5518*fae548d3Szrj os->bfd_section->size = input->size;
5519*fae548d3Szrj break;
5520*fae548d3Szrj }
5521*fae548d3Szrj
5522*fae548d3Szrj newdot = dot;
5523*fae548d3Szrj dotdelta = 0;
5524*fae548d3Szrj if (bfd_is_abs_section (os->bfd_section))
5525*fae548d3Szrj {
5526*fae548d3Szrj /* No matter what happens, an abs section starts at zero. */
5527*fae548d3Szrj ASSERT (os->bfd_section->vma == 0);
5528*fae548d3Szrj }
5529*fae548d3Szrj else
5530*fae548d3Szrj {
5531*fae548d3Szrj if (os->addr_tree == NULL)
5532*fae548d3Szrj {
5533*fae548d3Szrj /* No address specified for this section, get one
5534*fae548d3Szrj from the region specification. */
5535*fae548d3Szrj if (os->region == NULL
5536*fae548d3Szrj || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
5537*fae548d3Szrj && os->region->name_list.name[0] == '*'
5538*fae548d3Szrj && strcmp (os->region->name_list.name,
5539*fae548d3Szrj DEFAULT_MEMORY_REGION) == 0))
5540*fae548d3Szrj {
5541*fae548d3Szrj os->region = lang_memory_default (os->bfd_section);
5542*fae548d3Szrj }
5543*fae548d3Szrj
5544*fae548d3Szrj /* If a loadable section is using the default memory
5545*fae548d3Szrj region, and some non default memory regions were
5546*fae548d3Szrj defined, issue an error message. */
5547*fae548d3Szrj if (!os->ignored
5548*fae548d3Szrj && !IGNORE_SECTION (os->bfd_section)
5549*fae548d3Szrj && !bfd_link_relocatable (&link_info)
5550*fae548d3Szrj && check_regions
5551*fae548d3Szrj && strcmp (os->region->name_list.name,
5552*fae548d3Szrj DEFAULT_MEMORY_REGION) == 0
5553*fae548d3Szrj && lang_memory_region_list != NULL
5554*fae548d3Szrj && (strcmp (lang_memory_region_list->name_list.name,
5555*fae548d3Szrj DEFAULT_MEMORY_REGION) != 0
5556*fae548d3Szrj || lang_memory_region_list->next != NULL)
5557*fae548d3Szrj && expld.phase != lang_mark_phase_enum)
5558*fae548d3Szrj {
5559*fae548d3Szrj /* By default this is an error rather than just a
5560*fae548d3Szrj warning because if we allocate the section to the
5561*fae548d3Szrj default memory region we can end up creating an
5562*fae548d3Szrj excessively large binary, or even seg faulting when
5563*fae548d3Szrj attempting to perform a negative seek. See
5564*fae548d3Szrj sources.redhat.com/ml/binutils/2003-04/msg00423.html
5565*fae548d3Szrj for an example of this. This behaviour can be
5566*fae548d3Szrj overridden by the using the --no-check-sections
5567*fae548d3Szrj switch. */
5568*fae548d3Szrj if (command_line.check_section_addresses)
5569*fae548d3Szrj einfo (_("%F%P: error: no memory region specified"
5570*fae548d3Szrj " for loadable section `%s'\n"),
5571*fae548d3Szrj bfd_section_name (os->bfd_section));
5572*fae548d3Szrj else
5573*fae548d3Szrj einfo (_("%P: warning: no memory region specified"
5574*fae548d3Szrj " for loadable section `%s'\n"),
5575*fae548d3Szrj bfd_section_name (os->bfd_section));
5576*fae548d3Szrj }
5577*fae548d3Szrj
5578*fae548d3Szrj newdot = os->region->current;
5579*fae548d3Szrj section_alignment = os->bfd_section->alignment_power;
5580*fae548d3Szrj }
5581*fae548d3Szrj else
5582*fae548d3Szrj section_alignment = exp_get_power (os->section_alignment,
5583*fae548d3Szrj "section alignment");
5584*fae548d3Szrj
5585*fae548d3Szrj /* Align to what the section needs. */
5586*fae548d3Szrj if (section_alignment > 0)
5587*fae548d3Szrj {
5588*fae548d3Szrj bfd_vma savedot = newdot;
5589*fae548d3Szrj newdot = align_power (newdot, section_alignment);
5590*fae548d3Szrj
5591*fae548d3Szrj dotdelta = newdot - savedot;
5592*fae548d3Szrj if (dotdelta != 0
5593*fae548d3Szrj && (config.warn_section_align
5594*fae548d3Szrj || os->addr_tree != NULL)
5595*fae548d3Szrj && expld.phase != lang_mark_phase_enum)
5596*fae548d3Szrj einfo (ngettext ("%P: warning: changing start of "
5597*fae548d3Szrj "section %s by %lu byte\n",
5598*fae548d3Szrj "%P: warning: changing start of "
5599*fae548d3Szrj "section %s by %lu bytes\n",
5600*fae548d3Szrj (unsigned long) dotdelta),
5601*fae548d3Szrj os->name, (unsigned long) dotdelta);
5602*fae548d3Szrj }
5603*fae548d3Szrj
5604*fae548d3Szrj bfd_set_section_vma (os->bfd_section, newdot);
5605*fae548d3Szrj
5606*fae548d3Szrj os->bfd_section->output_offset = 0;
5607*fae548d3Szrj }
5608*fae548d3Szrj
5609*fae548d3Szrj lang_size_sections_1 (&os->children.head, os,
5610*fae548d3Szrj os->fill, newdot, relax, check_regions);
5611*fae548d3Szrj
5612*fae548d3Szrj os->processed_vma = TRUE;
5613*fae548d3Szrj
5614*fae548d3Szrj if (bfd_is_abs_section (os->bfd_section) || os->ignored)
5615*fae548d3Szrj /* Except for some special linker created sections,
5616*fae548d3Szrj no output section should change from zero size
5617*fae548d3Szrj after strip_excluded_output_sections. A non-zero
5618*fae548d3Szrj size on an ignored section indicates that some
5619*fae548d3Szrj input section was not sized early enough. */
5620*fae548d3Szrj ASSERT (os->bfd_section->size == 0);
5621*fae548d3Szrj else
5622*fae548d3Szrj {
5623*fae548d3Szrj dot = os->bfd_section->vma;
5624*fae548d3Szrj
5625*fae548d3Szrj /* Put the section within the requested block size, or
5626*fae548d3Szrj align at the block boundary. */
5627*fae548d3Szrj after = ((dot
5628*fae548d3Szrj + TO_ADDR (os->bfd_section->size)
5629*fae548d3Szrj + os->block_value - 1)
5630*fae548d3Szrj & - (bfd_vma) os->block_value);
5631*fae548d3Szrj
5632*fae548d3Szrj if (!(os->bfd_section->flags & SEC_FIXED_SIZE))
5633*fae548d3Szrj os->bfd_section->size = TO_SIZE (after
5634*fae548d3Szrj - os->bfd_section->vma);
5635*fae548d3Szrj }
5636*fae548d3Szrj
5637*fae548d3Szrj /* Set section lma. */
5638*fae548d3Szrj r = os->region;
5639*fae548d3Szrj if (r == NULL)
5640*fae548d3Szrj r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
5641*fae548d3Szrj
5642*fae548d3Szrj if (os->load_base)
5643*fae548d3Szrj {
5644*fae548d3Szrj bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
5645*fae548d3Szrj os->bfd_section->lma = lma;
5646*fae548d3Szrj }
5647*fae548d3Szrj else if (os->lma_region != NULL)
5648*fae548d3Szrj {
5649*fae548d3Szrj bfd_vma lma = os->lma_region->current;
5650*fae548d3Szrj
5651*fae548d3Szrj if (os->align_lma_with_input)
5652*fae548d3Szrj lma += dotdelta;
5653*fae548d3Szrj else
5654*fae548d3Szrj {
5655*fae548d3Szrj /* When LMA_REGION is the same as REGION, align the LMA
5656*fae548d3Szrj as we did for the VMA, possibly including alignment
5657*fae548d3Szrj from the bfd section. If a different region, then
5658*fae548d3Szrj only align according to the value in the output
5659*fae548d3Szrj statement. */
5660*fae548d3Szrj if (os->lma_region != os->region)
5661*fae548d3Szrj section_alignment = exp_get_power (os->section_alignment,
5662*fae548d3Szrj "section alignment");
5663*fae548d3Szrj if (section_alignment > 0)
5664*fae548d3Szrj lma = align_power (lma, section_alignment);
5665*fae548d3Szrj }
5666*fae548d3Szrj os->bfd_section->lma = lma;
5667*fae548d3Szrj }
5668*fae548d3Szrj else if (r->last_os != NULL
5669*fae548d3Szrj && (os->bfd_section->flags & SEC_ALLOC) != 0)
5670*fae548d3Szrj {
5671*fae548d3Szrj bfd_vma lma;
5672*fae548d3Szrj asection *last;
5673*fae548d3Szrj
5674*fae548d3Szrj last = r->last_os->output_section_statement.bfd_section;
5675*fae548d3Szrj
5676*fae548d3Szrj /* A backwards move of dot should be accompanied by
5677*fae548d3Szrj an explicit assignment to the section LMA (ie.
5678*fae548d3Szrj os->load_base set) because backwards moves can
5679*fae548d3Szrj create overlapping LMAs. */
5680*fae548d3Szrj if (dot < last->vma
5681*fae548d3Szrj && os->bfd_section->size != 0
5682*fae548d3Szrj && dot + TO_ADDR (os->bfd_section->size) <= last->vma)
5683*fae548d3Szrj {
5684*fae548d3Szrj /* If dot moved backwards then leave lma equal to
5685*fae548d3Szrj vma. This is the old default lma, which might
5686*fae548d3Szrj just happen to work when the backwards move is
5687*fae548d3Szrj sufficiently large. Nag if this changes anything,
5688*fae548d3Szrj so people can fix their linker scripts. */
5689*fae548d3Szrj
5690*fae548d3Szrj if (last->vma != last->lma)
5691*fae548d3Szrj einfo (_("%P: warning: dot moved backwards "
5692*fae548d3Szrj "before `%s'\n"), os->name);
5693*fae548d3Szrj }
5694*fae548d3Szrj else
5695*fae548d3Szrj {
5696*fae548d3Szrj /* If this is an overlay, set the current lma to that
5697*fae548d3Szrj at the end of the previous section. */
5698*fae548d3Szrj if (os->sectype == overlay_section)
5699*fae548d3Szrj lma = last->lma + TO_ADDR (last->size);
5700*fae548d3Szrj
5701*fae548d3Szrj /* Otherwise, keep the same lma to vma relationship
5702*fae548d3Szrj as the previous section. */
5703*fae548d3Szrj else
5704*fae548d3Szrj lma = os->bfd_section->vma + last->lma - last->vma;
5705*fae548d3Szrj
5706*fae548d3Szrj if (section_alignment > 0)
5707*fae548d3Szrj lma = align_power (lma, section_alignment);
5708*fae548d3Szrj os->bfd_section->lma = lma;
5709*fae548d3Szrj }
5710*fae548d3Szrj }
5711*fae548d3Szrj os->processed_lma = TRUE;
5712*fae548d3Szrj
5713*fae548d3Szrj /* Keep track of normal sections using the default
5714*fae548d3Szrj lma region. We use this to set the lma for
5715*fae548d3Szrj following sections. Overlays or other linker
5716*fae548d3Szrj script assignment to lma might mean that the
5717*fae548d3Szrj default lma == vma is incorrect.
5718*fae548d3Szrj To avoid warnings about dot moving backwards when using
5719*fae548d3Szrj -Ttext, don't start tracking sections until we find one
5720*fae548d3Szrj of non-zero size or with lma set differently to vma.
5721*fae548d3Szrj Do this tracking before we short-cut the loop so that we
5722*fae548d3Szrj track changes for the case where the section size is zero,
5723*fae548d3Szrj but the lma is set differently to the vma. This is
5724*fae548d3Szrj important, if an orphan section is placed after an
5725*fae548d3Szrj otherwise empty output section that has an explicit lma
5726*fae548d3Szrj set, we want that lma reflected in the orphans lma. */
5727*fae548d3Szrj if (((!IGNORE_SECTION (os->bfd_section)
5728*fae548d3Szrj && (os->bfd_section->size != 0
5729*fae548d3Szrj || (r->last_os == NULL
5730*fae548d3Szrj && os->bfd_section->vma != os->bfd_section->lma)
5731*fae548d3Szrj || (r->last_os != NULL
5732*fae548d3Szrj && dot >= (r->last_os->output_section_statement
5733*fae548d3Szrj .bfd_section->vma))))
5734*fae548d3Szrj || os->sectype == first_overlay_section)
5735*fae548d3Szrj && os->lma_region == NULL
5736*fae548d3Szrj && !bfd_link_relocatable (&link_info))
5737*fae548d3Szrj r->last_os = s;
5738*fae548d3Szrj
5739*fae548d3Szrj if (bfd_is_abs_section (os->bfd_section) || os->ignored)
5740*fae548d3Szrj break;
5741*fae548d3Szrj
5742*fae548d3Szrj /* .tbss sections effectively have zero size. */
5743*fae548d3Szrj if (!IS_TBSS (os->bfd_section)
5744*fae548d3Szrj || bfd_link_relocatable (&link_info))
5745*fae548d3Szrj dotdelta = TO_ADDR (os->bfd_section->size);
5746*fae548d3Szrj else
5747*fae548d3Szrj dotdelta = 0;
5748*fae548d3Szrj dot += dotdelta;
5749*fae548d3Szrj
5750*fae548d3Szrj if (os->update_dot_tree != 0)
5751*fae548d3Szrj exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5752*fae548d3Szrj
5753*fae548d3Szrj /* Update dot in the region ?
5754*fae548d3Szrj We only do this if the section is going to be allocated,
5755*fae548d3Szrj since unallocated sections do not contribute to the region's
5756*fae548d3Szrj overall size in memory. */
5757*fae548d3Szrj if (os->region != NULL
5758*fae548d3Szrj && (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD)))
5759*fae548d3Szrj {
5760*fae548d3Szrj os->region->current = dot;
5761*fae548d3Szrj
5762*fae548d3Szrj if (check_regions)
5763*fae548d3Szrj /* Make sure the new address is within the region. */
5764*fae548d3Szrj os_region_check (os, os->region, os->addr_tree,
5765*fae548d3Szrj os->bfd_section->vma);
5766*fae548d3Szrj
5767*fae548d3Szrj if (os->lma_region != NULL && os->lma_region != os->region
5768*fae548d3Szrj && ((os->bfd_section->flags & SEC_LOAD)
5769*fae548d3Szrj || os->align_lma_with_input))
5770*fae548d3Szrj {
5771*fae548d3Szrj os->lma_region->current = os->bfd_section->lma + dotdelta;
5772*fae548d3Szrj
5773*fae548d3Szrj if (check_regions)
5774*fae548d3Szrj os_region_check (os, os->lma_region, NULL,
5775*fae548d3Szrj os->bfd_section->lma);
5776*fae548d3Szrj }
5777*fae548d3Szrj }
5778*fae548d3Szrj }
5779*fae548d3Szrj break;
5780*fae548d3Szrj
5781*fae548d3Szrj case lang_constructors_statement_enum:
5782*fae548d3Szrj dot = lang_size_sections_1 (&constructor_list.head,
5783*fae548d3Szrj output_section_statement,
5784*fae548d3Szrj fill, dot, relax, check_regions);
5785*fae548d3Szrj break;
5786*fae548d3Szrj
5787*fae548d3Szrj case lang_data_statement_enum:
5788*fae548d3Szrj {
5789*fae548d3Szrj unsigned int size = 0;
5790*fae548d3Szrj
5791*fae548d3Szrj s->data_statement.output_offset =
5792*fae548d3Szrj dot - output_section_statement->bfd_section->vma;
5793*fae548d3Szrj s->data_statement.output_section =
5794*fae548d3Szrj output_section_statement->bfd_section;
5795*fae548d3Szrj
5796*fae548d3Szrj /* We might refer to provided symbols in the expression, and
5797*fae548d3Szrj need to mark them as needed. */
5798*fae548d3Szrj exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5799*fae548d3Szrj
5800*fae548d3Szrj switch (s->data_statement.type)
5801*fae548d3Szrj {
5802*fae548d3Szrj default:
5803*fae548d3Szrj abort ();
5804*fae548d3Szrj case QUAD:
5805*fae548d3Szrj case SQUAD:
5806*fae548d3Szrj size = QUAD_SIZE;
5807*fae548d3Szrj break;
5808*fae548d3Szrj case LONG:
5809*fae548d3Szrj size = LONG_SIZE;
5810*fae548d3Szrj break;
5811*fae548d3Szrj case SHORT:
5812*fae548d3Szrj size = SHORT_SIZE;
5813*fae548d3Szrj break;
5814*fae548d3Szrj case BYTE:
5815*fae548d3Szrj size = BYTE_SIZE;
5816*fae548d3Szrj break;
5817*fae548d3Szrj }
5818*fae548d3Szrj if (size < TO_SIZE ((unsigned) 1))
5819*fae548d3Szrj size = TO_SIZE ((unsigned) 1);
5820*fae548d3Szrj dot += TO_ADDR (size);
5821*fae548d3Szrj if (!(output_section_statement->bfd_section->flags
5822*fae548d3Szrj & SEC_FIXED_SIZE))
5823*fae548d3Szrj output_section_statement->bfd_section->size
5824*fae548d3Szrj = TO_SIZE (dot - output_section_statement->bfd_section->vma);
5825*fae548d3Szrj
5826*fae548d3Szrj }
5827*fae548d3Szrj break;
5828*fae548d3Szrj
5829*fae548d3Szrj case lang_reloc_statement_enum:
5830*fae548d3Szrj {
5831*fae548d3Szrj int size;
5832*fae548d3Szrj
5833*fae548d3Szrj s->reloc_statement.output_offset =
5834*fae548d3Szrj dot - output_section_statement->bfd_section->vma;
5835*fae548d3Szrj s->reloc_statement.output_section =
5836*fae548d3Szrj output_section_statement->bfd_section;
5837*fae548d3Szrj size = bfd_get_reloc_size (s->reloc_statement.howto);
5838*fae548d3Szrj dot += TO_ADDR (size);
5839*fae548d3Szrj if (!(output_section_statement->bfd_section->flags
5840*fae548d3Szrj & SEC_FIXED_SIZE))
5841*fae548d3Szrj output_section_statement->bfd_section->size
5842*fae548d3Szrj = TO_SIZE (dot - output_section_statement->bfd_section->vma);
5843*fae548d3Szrj }
5844*fae548d3Szrj break;
5845*fae548d3Szrj
5846*fae548d3Szrj case lang_wild_statement_enum:
5847*fae548d3Szrj dot = lang_size_sections_1 (&s->wild_statement.children.head,
5848*fae548d3Szrj output_section_statement,
5849*fae548d3Szrj fill, dot, relax, check_regions);
5850*fae548d3Szrj break;
5851*fae548d3Szrj
5852*fae548d3Szrj case lang_object_symbols_statement_enum:
5853*fae548d3Szrj link_info.create_object_symbols_section
5854*fae548d3Szrj = output_section_statement->bfd_section;
5855*fae548d3Szrj output_section_statement->bfd_section->flags |= SEC_KEEP;
5856*fae548d3Szrj break;
5857*fae548d3Szrj
5858*fae548d3Szrj case lang_output_statement_enum:
5859*fae548d3Szrj case lang_target_statement_enum:
5860*fae548d3Szrj break;
5861*fae548d3Szrj
5862*fae548d3Szrj case lang_input_section_enum:
5863*fae548d3Szrj {
5864*fae548d3Szrj asection *i;
5865*fae548d3Szrj
5866*fae548d3Szrj i = s->input_section.section;
5867*fae548d3Szrj if (relax)
5868*fae548d3Szrj {
5869*fae548d3Szrj bfd_boolean again;
5870*fae548d3Szrj
5871*fae548d3Szrj if (!bfd_relax_section (i->owner, i, &link_info, &again))
5872*fae548d3Szrj einfo (_("%F%P: can't relax section: %E\n"));
5873*fae548d3Szrj if (again)
5874*fae548d3Szrj *relax = TRUE;
5875*fae548d3Szrj }
5876*fae548d3Szrj dot = size_input_section (prev, output_section_statement,
5877*fae548d3Szrj fill, dot);
5878*fae548d3Szrj }
5879*fae548d3Szrj break;
5880*fae548d3Szrj
5881*fae548d3Szrj case lang_input_statement_enum:
5882*fae548d3Szrj break;
5883*fae548d3Szrj
5884*fae548d3Szrj case lang_fill_statement_enum:
5885*fae548d3Szrj s->fill_statement.output_section =
5886*fae548d3Szrj output_section_statement->bfd_section;
5887*fae548d3Szrj
5888*fae548d3Szrj fill = s->fill_statement.fill;
5889*fae548d3Szrj break;
5890*fae548d3Szrj
5891*fae548d3Szrj case lang_assignment_statement_enum:
5892*fae548d3Szrj {
5893*fae548d3Szrj bfd_vma newdot = dot;
5894*fae548d3Szrj etree_type *tree = s->assignment_statement.exp;
5895*fae548d3Szrj
5896*fae548d3Szrj expld.dataseg.relro = exp_seg_relro_none;
5897*fae548d3Szrj
5898*fae548d3Szrj exp_fold_tree (tree,
5899*fae548d3Szrj output_section_statement->bfd_section,
5900*fae548d3Szrj &newdot);
5901*fae548d3Szrj
5902*fae548d3Szrj ldlang_check_relro_region (s, &expld.dataseg);
5903*fae548d3Szrj
5904*fae548d3Szrj expld.dataseg.relro = exp_seg_relro_none;
5905*fae548d3Szrj
5906*fae548d3Szrj /* This symbol may be relative to this section. */
5907*fae548d3Szrj if ((tree->type.node_class == etree_provided
5908*fae548d3Szrj || tree->type.node_class == etree_assign)
5909*fae548d3Szrj && (tree->assign.dst [0] != '.'
5910*fae548d3Szrj || tree->assign.dst [1] != '\0'))
5911*fae548d3Szrj output_section_statement->update_dot = 1;
5912*fae548d3Szrj
5913*fae548d3Szrj if (!output_section_statement->ignored)
5914*fae548d3Szrj {
5915*fae548d3Szrj if (output_section_statement == abs_output_section)
5916*fae548d3Szrj {
5917*fae548d3Szrj /* If we don't have an output section, then just adjust
5918*fae548d3Szrj the default memory address. */
5919*fae548d3Szrj lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
5920*fae548d3Szrj FALSE)->current = newdot;
5921*fae548d3Szrj }
5922*fae548d3Szrj else if (newdot != dot)
5923*fae548d3Szrj {
5924*fae548d3Szrj /* Insert a pad after this statement. We can't
5925*fae548d3Szrj put the pad before when relaxing, in case the
5926*fae548d3Szrj assignment references dot. */
5927*fae548d3Szrj insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
5928*fae548d3Szrj output_section_statement->bfd_section, dot);
5929*fae548d3Szrj
5930*fae548d3Szrj /* Don't neuter the pad below when relaxing. */
5931*fae548d3Szrj s = s->header.next;
5932*fae548d3Szrj
5933*fae548d3Szrj /* If dot is advanced, this implies that the section
5934*fae548d3Szrj should have space allocated to it, unless the
5935*fae548d3Szrj user has explicitly stated that the section
5936*fae548d3Szrj should not be allocated. */
5937*fae548d3Szrj if (output_section_statement->sectype != noalloc_section
5938*fae548d3Szrj && (output_section_statement->sectype != noload_section
5939*fae548d3Szrj || (bfd_get_flavour (link_info.output_bfd)
5940*fae548d3Szrj == bfd_target_elf_flavour)))
5941*fae548d3Szrj output_section_statement->bfd_section->flags |= SEC_ALLOC;
5942*fae548d3Szrj }
5943*fae548d3Szrj dot = newdot;
5944*fae548d3Szrj }
5945*fae548d3Szrj }
5946*fae548d3Szrj break;
5947*fae548d3Szrj
5948*fae548d3Szrj case lang_padding_statement_enum:
5949*fae548d3Szrj /* If this is the first time lang_size_sections is called,
5950*fae548d3Szrj we won't have any padding statements. If this is the
5951*fae548d3Szrj second or later passes when relaxing, we should allow
5952*fae548d3Szrj padding to shrink. If padding is needed on this pass, it
5953*fae548d3Szrj will be added back in. */
5954*fae548d3Szrj s->padding_statement.size = 0;
5955*fae548d3Szrj
5956*fae548d3Szrj /* Make sure output_offset is valid. If relaxation shrinks
5957*fae548d3Szrj the section and this pad isn't needed, it's possible to
5958*fae548d3Szrj have output_offset larger than the final size of the
5959*fae548d3Szrj section. bfd_set_section_contents will complain even for
5960*fae548d3Szrj a pad size of zero. */
5961*fae548d3Szrj s->padding_statement.output_offset
5962*fae548d3Szrj = dot - output_section_statement->bfd_section->vma;
5963*fae548d3Szrj break;
5964*fae548d3Szrj
5965*fae548d3Szrj case lang_group_statement_enum:
5966*fae548d3Szrj dot = lang_size_sections_1 (&s->group_statement.children.head,
5967*fae548d3Szrj output_section_statement,
5968*fae548d3Szrj fill, dot, relax, check_regions);
5969*fae548d3Szrj break;
5970*fae548d3Szrj
5971*fae548d3Szrj case lang_insert_statement_enum:
5972*fae548d3Szrj break;
5973*fae548d3Szrj
5974*fae548d3Szrj /* We can only get here when relaxing is turned on. */
5975*fae548d3Szrj case lang_address_statement_enum:
5976*fae548d3Szrj break;
5977*fae548d3Szrj
5978*fae548d3Szrj default:
5979*fae548d3Szrj FAIL ();
5980*fae548d3Szrj break;
5981*fae548d3Szrj }
5982*fae548d3Szrj prev = &s->header.next;
5983*fae548d3Szrj }
5984*fae548d3Szrj return dot;
5985*fae548d3Szrj }
5986*fae548d3Szrj
5987*fae548d3Szrj /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5988*fae548d3Szrj The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5989*fae548d3Szrj CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5990*fae548d3Szrj segments. We are allowed an opportunity to override this decision. */
5991*fae548d3Szrj
5992*fae548d3Szrj bfd_boolean
ldlang_override_segment_assignment(struct bfd_link_info * info ATTRIBUTE_UNUSED,bfd * abfd ATTRIBUTE_UNUSED,asection * current_section,asection * previous_section,bfd_boolean new_segment)5993*fae548d3Szrj ldlang_override_segment_assignment (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5994*fae548d3Szrj bfd *abfd ATTRIBUTE_UNUSED,
5995*fae548d3Szrj asection *current_section,
5996*fae548d3Szrj asection *previous_section,
5997*fae548d3Szrj bfd_boolean new_segment)
5998*fae548d3Szrj {
5999*fae548d3Szrj lang_output_section_statement_type *cur;
6000*fae548d3Szrj lang_output_section_statement_type *prev;
6001*fae548d3Szrj
6002*fae548d3Szrj /* The checks below are only necessary when the BFD library has decided
6003*fae548d3Szrj that the two sections ought to be placed into the same segment. */
6004*fae548d3Szrj if (new_segment)
6005*fae548d3Szrj return TRUE;
6006*fae548d3Szrj
6007*fae548d3Szrj /* Paranoia checks. */
6008*fae548d3Szrj if (current_section == NULL || previous_section == NULL)
6009*fae548d3Szrj return new_segment;
6010*fae548d3Szrj
6011*fae548d3Szrj /* If this flag is set, the target never wants code and non-code
6012*fae548d3Szrj sections comingled in the same segment. */
6013*fae548d3Szrj if (config.separate_code
6014*fae548d3Szrj && ((current_section->flags ^ previous_section->flags) & SEC_CODE))
6015*fae548d3Szrj return TRUE;
6016*fae548d3Szrj
6017*fae548d3Szrj /* Find the memory regions associated with the two sections.
6018*fae548d3Szrj We call lang_output_section_find() here rather than scanning the list
6019*fae548d3Szrj of output sections looking for a matching section pointer because if
6020*fae548d3Szrj we have a large number of sections then a hash lookup is faster. */
6021*fae548d3Szrj cur = lang_output_section_find (current_section->name);
6022*fae548d3Szrj prev = lang_output_section_find (previous_section->name);
6023*fae548d3Szrj
6024*fae548d3Szrj /* More paranoia. */
6025*fae548d3Szrj if (cur == NULL || prev == NULL)
6026*fae548d3Szrj return new_segment;
6027*fae548d3Szrj
6028*fae548d3Szrj /* If the regions are different then force the sections to live in
6029*fae548d3Szrj different segments. See the email thread starting at the following
6030*fae548d3Szrj URL for the reasons why this is necessary:
6031*fae548d3Szrj http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6032*fae548d3Szrj return cur->region != prev->region;
6033*fae548d3Szrj }
6034*fae548d3Szrj
6035*fae548d3Szrj void
one_lang_size_sections_pass(bfd_boolean * relax,bfd_boolean check_regions)6036*fae548d3Szrj one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
6037*fae548d3Szrj {
6038*fae548d3Szrj lang_statement_iteration++;
6039*fae548d3Szrj lang_size_sections_1 (&statement_list.head, abs_output_section,
6040*fae548d3Szrj 0, 0, relax, check_regions);
6041*fae548d3Szrj }
6042*fae548d3Szrj
6043*fae548d3Szrj static bfd_boolean
lang_size_segment(seg_align_type * seg)6044*fae548d3Szrj lang_size_segment (seg_align_type *seg)
6045*fae548d3Szrj {
6046*fae548d3Szrj /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6047*fae548d3Szrj a page could be saved in the data segment. */
6048*fae548d3Szrj bfd_vma first, last;
6049*fae548d3Szrj
6050*fae548d3Szrj first = -seg->base & (seg->pagesize - 1);
6051*fae548d3Szrj last = seg->end & (seg->pagesize - 1);
6052*fae548d3Szrj if (first && last
6053*fae548d3Szrj && ((seg->base & ~(seg->pagesize - 1))
6054*fae548d3Szrj != (seg->end & ~(seg->pagesize - 1)))
6055*fae548d3Szrj && first + last <= seg->pagesize)
6056*fae548d3Szrj {
6057*fae548d3Szrj seg->phase = exp_seg_adjust;
6058*fae548d3Szrj return TRUE;
6059*fae548d3Szrj }
6060*fae548d3Szrj
6061*fae548d3Szrj seg->phase = exp_seg_done;
6062*fae548d3Szrj return FALSE;
6063*fae548d3Szrj }
6064*fae548d3Szrj
6065*fae548d3Szrj static bfd_vma
lang_size_relro_segment_1(seg_align_type * seg)6066*fae548d3Szrj lang_size_relro_segment_1 (seg_align_type *seg)
6067*fae548d3Szrj {
6068*fae548d3Szrj bfd_vma relro_end, desired_end;
6069*fae548d3Szrj asection *sec;
6070*fae548d3Szrj
6071*fae548d3Szrj /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6072*fae548d3Szrj relro_end = ((seg->relro_end + seg->pagesize - 1)
6073*fae548d3Szrj & ~(seg->pagesize - 1));
6074*fae548d3Szrj
6075*fae548d3Szrj /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6076*fae548d3Szrj desired_end = relro_end - seg->relro_offset;
6077*fae548d3Szrj
6078*fae548d3Szrj /* For sections in the relro segment.. */
6079*fae548d3Szrj for (sec = link_info.output_bfd->section_last; sec; sec = sec->prev)
6080*fae548d3Szrj if ((sec->flags & SEC_ALLOC) != 0
6081*fae548d3Szrj && sec->vma >= seg->base
6082*fae548d3Szrj && sec->vma < seg->relro_end - seg->relro_offset)
6083*fae548d3Szrj {
6084*fae548d3Szrj /* Where do we want to put this section so that it ends as
6085*fae548d3Szrj desired? */
6086*fae548d3Szrj bfd_vma start, end, bump;
6087*fae548d3Szrj
6088*fae548d3Szrj end = start = sec->vma;
6089*fae548d3Szrj if (!IS_TBSS (sec))
6090*fae548d3Szrj end += TO_ADDR (sec->size);
6091*fae548d3Szrj bump = desired_end - end;
6092*fae548d3Szrj /* We'd like to increase START by BUMP, but we must heed
6093*fae548d3Szrj alignment so the increase might be less than optimum. */
6094*fae548d3Szrj start += bump;
6095*fae548d3Szrj start &= ~(((bfd_vma) 1 << sec->alignment_power) - 1);
6096*fae548d3Szrj /* This is now the desired end for the previous section. */
6097*fae548d3Szrj desired_end = start;
6098*fae548d3Szrj }
6099*fae548d3Szrj
6100*fae548d3Szrj seg->phase = exp_seg_relro_adjust;
6101*fae548d3Szrj ASSERT (desired_end >= seg->base);
6102*fae548d3Szrj seg->base = desired_end;
6103*fae548d3Szrj return relro_end;
6104*fae548d3Szrj }
6105*fae548d3Szrj
6106*fae548d3Szrj static bfd_boolean
lang_size_relro_segment(bfd_boolean * relax,bfd_boolean check_regions)6107*fae548d3Szrj lang_size_relro_segment (bfd_boolean *relax, bfd_boolean check_regions)
6108*fae548d3Szrj {
6109*fae548d3Szrj bfd_boolean do_reset = FALSE;
6110*fae548d3Szrj bfd_boolean do_data_relro;
6111*fae548d3Szrj bfd_vma data_initial_base, data_relro_end;
6112*fae548d3Szrj
6113*fae548d3Szrj if (link_info.relro && expld.dataseg.relro_end)
6114*fae548d3Szrj {
6115*fae548d3Szrj do_data_relro = TRUE;
6116*fae548d3Szrj data_initial_base = expld.dataseg.base;
6117*fae548d3Szrj data_relro_end = lang_size_relro_segment_1 (&expld.dataseg);
6118*fae548d3Szrj }
6119*fae548d3Szrj else
6120*fae548d3Szrj {
6121*fae548d3Szrj do_data_relro = FALSE;
6122*fae548d3Szrj data_initial_base = data_relro_end = 0;
6123*fae548d3Szrj }
6124*fae548d3Szrj
6125*fae548d3Szrj if (do_data_relro)
6126*fae548d3Szrj {
6127*fae548d3Szrj lang_reset_memory_regions ();
6128*fae548d3Szrj one_lang_size_sections_pass (relax, check_regions);
6129*fae548d3Szrj
6130*fae548d3Szrj /* Assignments to dot, or to output section address in a user
6131*fae548d3Szrj script have increased padding over the original. Revert. */
6132*fae548d3Szrj if (do_data_relro && expld.dataseg.relro_end > data_relro_end)
6133*fae548d3Szrj {
6134*fae548d3Szrj expld.dataseg.base = data_initial_base;;
6135*fae548d3Szrj do_reset = TRUE;
6136*fae548d3Szrj }
6137*fae548d3Szrj }
6138*fae548d3Szrj
6139*fae548d3Szrj if (!do_data_relro && lang_size_segment (&expld.dataseg))
6140*fae548d3Szrj do_reset = TRUE;
6141*fae548d3Szrj
6142*fae548d3Szrj return do_reset;
6143*fae548d3Szrj }
6144*fae548d3Szrj
6145*fae548d3Szrj void
lang_size_sections(bfd_boolean * relax,bfd_boolean check_regions)6146*fae548d3Szrj lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
6147*fae548d3Szrj {
6148*fae548d3Szrj expld.phase = lang_allocating_phase_enum;
6149*fae548d3Szrj expld.dataseg.phase = exp_seg_none;
6150*fae548d3Szrj
6151*fae548d3Szrj one_lang_size_sections_pass (relax, check_regions);
6152*fae548d3Szrj
6153*fae548d3Szrj if (expld.dataseg.phase != exp_seg_end_seen)
6154*fae548d3Szrj expld.dataseg.phase = exp_seg_done;
6155*fae548d3Szrj
6156*fae548d3Szrj if (expld.dataseg.phase == exp_seg_end_seen)
6157*fae548d3Szrj {
6158*fae548d3Szrj bfd_boolean do_reset
6159*fae548d3Szrj = lang_size_relro_segment (relax, check_regions);
6160*fae548d3Szrj
6161*fae548d3Szrj if (do_reset)
6162*fae548d3Szrj {
6163*fae548d3Szrj lang_reset_memory_regions ();
6164*fae548d3Szrj one_lang_size_sections_pass (relax, check_regions);
6165*fae548d3Szrj }
6166*fae548d3Szrj
6167*fae548d3Szrj if (link_info.relro && expld.dataseg.relro_end)
6168*fae548d3Szrj {
6169*fae548d3Szrj link_info.relro_start = expld.dataseg.base;
6170*fae548d3Szrj link_info.relro_end = expld.dataseg.relro_end;
6171*fae548d3Szrj }
6172*fae548d3Szrj }
6173*fae548d3Szrj }
6174*fae548d3Szrj
6175*fae548d3Szrj static lang_output_section_statement_type *current_section;
6176*fae548d3Szrj static lang_assignment_statement_type *current_assign;
6177*fae548d3Szrj static bfd_boolean prefer_next_section;
6178*fae548d3Szrj
6179*fae548d3Szrj /* Worker function for lang_do_assignments. Recursiveness goes here. */
6180*fae548d3Szrj
6181*fae548d3Szrj static bfd_vma
lang_do_assignments_1(lang_statement_union_type * s,lang_output_section_statement_type * current_os,fill_type * fill,bfd_vma dot,bfd_boolean * found_end)6182*fae548d3Szrj lang_do_assignments_1 (lang_statement_union_type *s,
6183*fae548d3Szrj lang_output_section_statement_type *current_os,
6184*fae548d3Szrj fill_type *fill,
6185*fae548d3Szrj bfd_vma dot,
6186*fae548d3Szrj bfd_boolean *found_end)
6187*fae548d3Szrj {
6188*fae548d3Szrj for (; s != NULL; s = s->header.next)
6189*fae548d3Szrj {
6190*fae548d3Szrj switch (s->header.type)
6191*fae548d3Szrj {
6192*fae548d3Szrj case lang_constructors_statement_enum:
6193*fae548d3Szrj dot = lang_do_assignments_1 (constructor_list.head,
6194*fae548d3Szrj current_os, fill, dot, found_end);
6195*fae548d3Szrj break;
6196*fae548d3Szrj
6197*fae548d3Szrj case lang_output_section_statement_enum:
6198*fae548d3Szrj {
6199*fae548d3Szrj lang_output_section_statement_type *os;
6200*fae548d3Szrj bfd_vma newdot;
6201*fae548d3Szrj
6202*fae548d3Szrj os = &(s->output_section_statement);
6203*fae548d3Szrj os->after_end = *found_end;
6204*fae548d3Szrj init_opb (os->bfd_section);
6205*fae548d3Szrj if (os->bfd_section != NULL && !os->ignored)
6206*fae548d3Szrj {
6207*fae548d3Szrj if ((os->bfd_section->flags & SEC_ALLOC) != 0)
6208*fae548d3Szrj {
6209*fae548d3Szrj current_section = os;
6210*fae548d3Szrj prefer_next_section = FALSE;
6211*fae548d3Szrj }
6212*fae548d3Szrj dot = os->bfd_section->vma;
6213*fae548d3Szrj }
6214*fae548d3Szrj newdot = lang_do_assignments_1 (os->children.head,
6215*fae548d3Szrj os, os->fill, dot, found_end);
6216*fae548d3Szrj if (!os->ignored)
6217*fae548d3Szrj {
6218*fae548d3Szrj if (os->bfd_section != NULL)
6219*fae548d3Szrj {
6220*fae548d3Szrj /* .tbss sections effectively have zero size. */
6221*fae548d3Szrj if (!IS_TBSS (os->bfd_section)
6222*fae548d3Szrj || bfd_link_relocatable (&link_info))
6223*fae548d3Szrj dot += TO_ADDR (os->bfd_section->size);
6224*fae548d3Szrj
6225*fae548d3Szrj if (os->update_dot_tree != NULL)
6226*fae548d3Szrj exp_fold_tree (os->update_dot_tree,
6227*fae548d3Szrj bfd_abs_section_ptr, &dot);
6228*fae548d3Szrj }
6229*fae548d3Szrj else
6230*fae548d3Szrj dot = newdot;
6231*fae548d3Szrj }
6232*fae548d3Szrj }
6233*fae548d3Szrj break;
6234*fae548d3Szrj
6235*fae548d3Szrj case lang_wild_statement_enum:
6236*fae548d3Szrj
6237*fae548d3Szrj dot = lang_do_assignments_1 (s->wild_statement.children.head,
6238*fae548d3Szrj current_os, fill, dot, found_end);
6239*fae548d3Szrj break;
6240*fae548d3Szrj
6241*fae548d3Szrj case lang_object_symbols_statement_enum:
6242*fae548d3Szrj case lang_output_statement_enum:
6243*fae548d3Szrj case lang_target_statement_enum:
6244*fae548d3Szrj break;
6245*fae548d3Szrj
6246*fae548d3Szrj case lang_data_statement_enum:
6247*fae548d3Szrj exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
6248*fae548d3Szrj if (expld.result.valid_p)
6249*fae548d3Szrj {
6250*fae548d3Szrj s->data_statement.value = expld.result.value;
6251*fae548d3Szrj if (expld.result.section != NULL)
6252*fae548d3Szrj s->data_statement.value += expld.result.section->vma;
6253*fae548d3Szrj }
6254*fae548d3Szrj else if (expld.phase == lang_final_phase_enum)
6255*fae548d3Szrj einfo (_("%F%P: invalid data statement\n"));
6256*fae548d3Szrj {
6257*fae548d3Szrj unsigned int size;
6258*fae548d3Szrj switch (s->data_statement.type)
6259*fae548d3Szrj {
6260*fae548d3Szrj default:
6261*fae548d3Szrj abort ();
6262*fae548d3Szrj case QUAD:
6263*fae548d3Szrj case SQUAD:
6264*fae548d3Szrj size = QUAD_SIZE;
6265*fae548d3Szrj break;
6266*fae548d3Szrj case LONG:
6267*fae548d3Szrj size = LONG_SIZE;
6268*fae548d3Szrj break;
6269*fae548d3Szrj case SHORT:
6270*fae548d3Szrj size = SHORT_SIZE;
6271*fae548d3Szrj break;
6272*fae548d3Szrj case BYTE:
6273*fae548d3Szrj size = BYTE_SIZE;
6274*fae548d3Szrj break;
6275*fae548d3Szrj }
6276*fae548d3Szrj if (size < TO_SIZE ((unsigned) 1))
6277*fae548d3Szrj size = TO_SIZE ((unsigned) 1);
6278*fae548d3Szrj dot += TO_ADDR (size);
6279*fae548d3Szrj }
6280*fae548d3Szrj break;
6281*fae548d3Szrj
6282*fae548d3Szrj case lang_reloc_statement_enum:
6283*fae548d3Szrj exp_fold_tree (s->reloc_statement.addend_exp,
6284*fae548d3Szrj bfd_abs_section_ptr, &dot);
6285*fae548d3Szrj if (expld.result.valid_p)
6286*fae548d3Szrj s->reloc_statement.addend_value = expld.result.value;
6287*fae548d3Szrj else if (expld.phase == lang_final_phase_enum)
6288*fae548d3Szrj einfo (_("%F%P: invalid reloc statement\n"));
6289*fae548d3Szrj dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
6290*fae548d3Szrj break;
6291*fae548d3Szrj
6292*fae548d3Szrj case lang_input_section_enum:
6293*fae548d3Szrj {
6294*fae548d3Szrj asection *in = s->input_section.section;
6295*fae548d3Szrj
6296*fae548d3Szrj if ((in->flags & SEC_EXCLUDE) == 0)
6297*fae548d3Szrj dot += TO_ADDR (in->size);
6298*fae548d3Szrj }
6299*fae548d3Szrj break;
6300*fae548d3Szrj
6301*fae548d3Szrj case lang_input_statement_enum:
6302*fae548d3Szrj break;
6303*fae548d3Szrj
6304*fae548d3Szrj case lang_fill_statement_enum:
6305*fae548d3Szrj fill = s->fill_statement.fill;
6306*fae548d3Szrj break;
6307*fae548d3Szrj
6308*fae548d3Szrj case lang_assignment_statement_enum:
6309*fae548d3Szrj current_assign = &s->assignment_statement;
6310*fae548d3Szrj if (current_assign->exp->type.node_class != etree_assert)
6311*fae548d3Szrj {
6312*fae548d3Szrj const char *p = current_assign->exp->assign.dst;
6313*fae548d3Szrj
6314*fae548d3Szrj if (current_os == abs_output_section && p[0] == '.' && p[1] == 0)
6315*fae548d3Szrj prefer_next_section = TRUE;
6316*fae548d3Szrj
6317*fae548d3Szrj while (*p == '_')
6318*fae548d3Szrj ++p;
6319*fae548d3Szrj if (strcmp (p, "end") == 0)
6320*fae548d3Szrj *found_end = TRUE;
6321*fae548d3Szrj }
6322*fae548d3Szrj exp_fold_tree (s->assignment_statement.exp,
6323*fae548d3Szrj (current_os->bfd_section != NULL
6324*fae548d3Szrj ? current_os->bfd_section : bfd_und_section_ptr),
6325*fae548d3Szrj &dot);
6326*fae548d3Szrj break;
6327*fae548d3Szrj
6328*fae548d3Szrj case lang_padding_statement_enum:
6329*fae548d3Szrj dot += TO_ADDR (s->padding_statement.size);
6330*fae548d3Szrj break;
6331*fae548d3Szrj
6332*fae548d3Szrj case lang_group_statement_enum:
6333*fae548d3Szrj dot = lang_do_assignments_1 (s->group_statement.children.head,
6334*fae548d3Szrj current_os, fill, dot, found_end);
6335*fae548d3Szrj break;
6336*fae548d3Szrj
6337*fae548d3Szrj case lang_insert_statement_enum:
6338*fae548d3Szrj break;
6339*fae548d3Szrj
6340*fae548d3Szrj case lang_address_statement_enum:
6341*fae548d3Szrj break;
6342*fae548d3Szrj
6343*fae548d3Szrj default:
6344*fae548d3Szrj FAIL ();
6345*fae548d3Szrj break;
6346*fae548d3Szrj }
6347*fae548d3Szrj }
6348*fae548d3Szrj return dot;
6349*fae548d3Szrj }
6350*fae548d3Szrj
6351*fae548d3Szrj void
lang_do_assignments(lang_phase_type phase)6352*fae548d3Szrj lang_do_assignments (lang_phase_type phase)
6353*fae548d3Szrj {
6354*fae548d3Szrj bfd_boolean found_end = FALSE;
6355*fae548d3Szrj
6356*fae548d3Szrj current_section = NULL;
6357*fae548d3Szrj prefer_next_section = FALSE;
6358*fae548d3Szrj expld.phase = phase;
6359*fae548d3Szrj lang_statement_iteration++;
6360*fae548d3Szrj lang_do_assignments_1 (statement_list.head,
6361*fae548d3Szrj abs_output_section, NULL, 0, &found_end);
6362*fae548d3Szrj }
6363*fae548d3Szrj
6364*fae548d3Szrj /* For an assignment statement outside of an output section statement,
6365*fae548d3Szrj choose the best of neighbouring output sections to use for values
6366*fae548d3Szrj of "dot". */
6367*fae548d3Szrj
6368*fae548d3Szrj asection *
section_for_dot(void)6369*fae548d3Szrj section_for_dot (void)
6370*fae548d3Szrj {
6371*fae548d3Szrj asection *s;
6372*fae548d3Szrj
6373*fae548d3Szrj /* Assignments belong to the previous output section, unless there
6374*fae548d3Szrj has been an assignment to "dot", in which case following
6375*fae548d3Szrj assignments belong to the next output section. (The assumption
6376*fae548d3Szrj is that an assignment to "dot" is setting up the address for the
6377*fae548d3Szrj next output section.) Except that past the assignment to "_end"
6378*fae548d3Szrj we always associate with the previous section. This exception is
6379*fae548d3Szrj for targets like SH that define an alloc .stack or other
6380*fae548d3Szrj weirdness after non-alloc sections. */
6381*fae548d3Szrj if (current_section == NULL || prefer_next_section)
6382*fae548d3Szrj {
6383*fae548d3Szrj lang_statement_union_type *stmt;
6384*fae548d3Szrj lang_output_section_statement_type *os;
6385*fae548d3Szrj
6386*fae548d3Szrj for (stmt = (lang_statement_union_type *) current_assign;
6387*fae548d3Szrj stmt != NULL;
6388*fae548d3Szrj stmt = stmt->header.next)
6389*fae548d3Szrj if (stmt->header.type == lang_output_section_statement_enum)
6390*fae548d3Szrj break;
6391*fae548d3Szrj
6392*fae548d3Szrj os = &stmt->output_section_statement;
6393*fae548d3Szrj while (os != NULL
6394*fae548d3Szrj && !os->after_end
6395*fae548d3Szrj && (os->bfd_section == NULL
6396*fae548d3Szrj || (os->bfd_section->flags & SEC_EXCLUDE) != 0
6397*fae548d3Szrj || bfd_section_removed_from_list (link_info.output_bfd,
6398*fae548d3Szrj os->bfd_section)))
6399*fae548d3Szrj os = os->next;
6400*fae548d3Szrj
6401*fae548d3Szrj if (current_section == NULL || os == NULL || !os->after_end)
6402*fae548d3Szrj {
6403*fae548d3Szrj if (os != NULL)
6404*fae548d3Szrj s = os->bfd_section;
6405*fae548d3Szrj else
6406*fae548d3Szrj s = link_info.output_bfd->section_last;
6407*fae548d3Szrj while (s != NULL
6408*fae548d3Szrj && ((s->flags & SEC_ALLOC) == 0
6409*fae548d3Szrj || (s->flags & SEC_THREAD_LOCAL) != 0))
6410*fae548d3Szrj s = s->prev;
6411*fae548d3Szrj if (s != NULL)
6412*fae548d3Szrj return s;
6413*fae548d3Szrj
6414*fae548d3Szrj return bfd_abs_section_ptr;
6415*fae548d3Szrj }
6416*fae548d3Szrj }
6417*fae548d3Szrj
6418*fae548d3Szrj s = current_section->bfd_section;
6419*fae548d3Szrj
6420*fae548d3Szrj /* The section may have been stripped. */
6421*fae548d3Szrj while (s != NULL
6422*fae548d3Szrj && ((s->flags & SEC_EXCLUDE) != 0
6423*fae548d3Szrj || (s->flags & SEC_ALLOC) == 0
6424*fae548d3Szrj || (s->flags & SEC_THREAD_LOCAL) != 0
6425*fae548d3Szrj || bfd_section_removed_from_list (link_info.output_bfd, s)))
6426*fae548d3Szrj s = s->prev;
6427*fae548d3Szrj if (s == NULL)
6428*fae548d3Szrj s = link_info.output_bfd->sections;
6429*fae548d3Szrj while (s != NULL
6430*fae548d3Szrj && ((s->flags & SEC_ALLOC) == 0
6431*fae548d3Szrj || (s->flags & SEC_THREAD_LOCAL) != 0))
6432*fae548d3Szrj s = s->next;
6433*fae548d3Szrj if (s != NULL)
6434*fae548d3Szrj return s;
6435*fae548d3Szrj
6436*fae548d3Szrj return bfd_abs_section_ptr;
6437*fae548d3Szrj }
6438*fae548d3Szrj
6439*fae548d3Szrj /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6440*fae548d3Szrj
6441*fae548d3Szrj static struct bfd_link_hash_entry **start_stop_syms;
6442*fae548d3Szrj static size_t start_stop_count = 0;
6443*fae548d3Szrj static size_t start_stop_alloc = 0;
6444*fae548d3Szrj
6445*fae548d3Szrj /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6446*fae548d3Szrj to start_stop_syms. */
6447*fae548d3Szrj
6448*fae548d3Szrj static void
lang_define_start_stop(const char * symbol,asection * sec)6449*fae548d3Szrj lang_define_start_stop (const char *symbol, asection *sec)
6450*fae548d3Szrj {
6451*fae548d3Szrj struct bfd_link_hash_entry *h;
6452*fae548d3Szrj
6453*fae548d3Szrj h = bfd_define_start_stop (link_info.output_bfd, &link_info, symbol, sec);
6454*fae548d3Szrj if (h != NULL)
6455*fae548d3Szrj {
6456*fae548d3Szrj if (start_stop_count == start_stop_alloc)
6457*fae548d3Szrj {
6458*fae548d3Szrj start_stop_alloc = 2 * start_stop_alloc + 10;
6459*fae548d3Szrj start_stop_syms
6460*fae548d3Szrj = xrealloc (start_stop_syms,
6461*fae548d3Szrj start_stop_alloc * sizeof (*start_stop_syms));
6462*fae548d3Szrj }
6463*fae548d3Szrj start_stop_syms[start_stop_count++] = h;
6464*fae548d3Szrj }
6465*fae548d3Szrj }
6466*fae548d3Szrj
6467*fae548d3Szrj /* Check for input sections whose names match references to
6468*fae548d3Szrj __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6469*fae548d3Szrj preliminary definitions. */
6470*fae548d3Szrj
6471*fae548d3Szrj static void
lang_init_start_stop(void)6472*fae548d3Szrj lang_init_start_stop (void)
6473*fae548d3Szrj {
6474*fae548d3Szrj bfd *abfd;
6475*fae548d3Szrj asection *s;
6476*fae548d3Szrj char leading_char = bfd_get_symbol_leading_char (link_info.output_bfd);
6477*fae548d3Szrj
6478*fae548d3Szrj for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link.next)
6479*fae548d3Szrj for (s = abfd->sections; s != NULL; s = s->next)
6480*fae548d3Szrj {
6481*fae548d3Szrj const char *ps;
6482*fae548d3Szrj const char *secname = s->name;
6483*fae548d3Szrj
6484*fae548d3Szrj for (ps = secname; *ps != '\0'; ps++)
6485*fae548d3Szrj if (!ISALNUM ((unsigned char) *ps) && *ps != '_')
6486*fae548d3Szrj break;
6487*fae548d3Szrj if (*ps == '\0')
6488*fae548d3Szrj {
6489*fae548d3Szrj char *symbol = (char *) xmalloc (10 + strlen (secname));
6490*fae548d3Szrj
6491*fae548d3Szrj symbol[0] = leading_char;
6492*fae548d3Szrj sprintf (symbol + (leading_char != 0), "__start_%s", secname);
6493*fae548d3Szrj lang_define_start_stop (symbol, s);
6494*fae548d3Szrj
6495*fae548d3Szrj symbol[1] = leading_char;
6496*fae548d3Szrj memcpy (symbol + 1 + (leading_char != 0), "__stop", 6);
6497*fae548d3Szrj lang_define_start_stop (symbol + 1, s);
6498*fae548d3Szrj
6499*fae548d3Szrj free (symbol);
6500*fae548d3Szrj }
6501*fae548d3Szrj }
6502*fae548d3Szrj }
6503*fae548d3Szrj
6504*fae548d3Szrj /* Iterate over start_stop_syms. */
6505*fae548d3Szrj
6506*fae548d3Szrj static void
foreach_start_stop(void (* func)(struct bfd_link_hash_entry *))6507*fae548d3Szrj foreach_start_stop (void (*func) (struct bfd_link_hash_entry *))
6508*fae548d3Szrj {
6509*fae548d3Szrj size_t i;
6510*fae548d3Szrj
6511*fae548d3Szrj for (i = 0; i < start_stop_count; ++i)
6512*fae548d3Szrj func (start_stop_syms[i]);
6513*fae548d3Szrj }
6514*fae548d3Szrj
6515*fae548d3Szrj /* __start and __stop symbols are only supposed to be defined by the
6516*fae548d3Szrj linker for orphan sections, but we now extend that to sections that
6517*fae548d3Szrj map to an output section of the same name. The symbols were
6518*fae548d3Szrj defined early for --gc-sections, before we mapped input to output
6519*fae548d3Szrj sections, so undo those that don't satisfy this rule. */
6520*fae548d3Szrj
6521*fae548d3Szrj static void
undef_start_stop(struct bfd_link_hash_entry * h)6522*fae548d3Szrj undef_start_stop (struct bfd_link_hash_entry *h)
6523*fae548d3Szrj {
6524*fae548d3Szrj if (h->ldscript_def)
6525*fae548d3Szrj return;
6526*fae548d3Szrj
6527*fae548d3Szrj if (h->u.def.section->output_section == NULL
6528*fae548d3Szrj || h->u.def.section->output_section->owner != link_info.output_bfd
6529*fae548d3Szrj || strcmp (h->u.def.section->name,
6530*fae548d3Szrj h->u.def.section->output_section->name) != 0)
6531*fae548d3Szrj {
6532*fae548d3Szrj asection *sec = bfd_get_section_by_name (link_info.output_bfd,
6533*fae548d3Szrj h->u.def.section->name);
6534*fae548d3Szrj if (sec != NULL)
6535*fae548d3Szrj {
6536*fae548d3Szrj /* When there are more than one input sections with the same
6537*fae548d3Szrj section name, SECNAME, linker picks the first one to define
6538*fae548d3Szrj __start_SECNAME and __stop_SECNAME symbols. When the first
6539*fae548d3Szrj input section is removed by comdat group, we need to check
6540*fae548d3Szrj if there is still an output section with section name
6541*fae548d3Szrj SECNAME. */
6542*fae548d3Szrj asection *i;
6543*fae548d3Szrj for (i = sec->map_head.s; i != NULL; i = i->map_head.s)
6544*fae548d3Szrj if (strcmp (h->u.def.section->name, i->name) == 0)
6545*fae548d3Szrj {
6546*fae548d3Szrj h->u.def.section = i;
6547*fae548d3Szrj return;
6548*fae548d3Szrj }
6549*fae548d3Szrj }
6550*fae548d3Szrj h->type = bfd_link_hash_undefined;
6551*fae548d3Szrj h->u.undef.abfd = NULL;
6552*fae548d3Szrj }
6553*fae548d3Szrj }
6554*fae548d3Szrj
6555*fae548d3Szrj static void
lang_undef_start_stop(void)6556*fae548d3Szrj lang_undef_start_stop (void)
6557*fae548d3Szrj {
6558*fae548d3Szrj foreach_start_stop (undef_start_stop);
6559*fae548d3Szrj }
6560*fae548d3Szrj
6561*fae548d3Szrj /* Check for output sections whose names match references to
6562*fae548d3Szrj .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6563*fae548d3Szrj preliminary definitions. */
6564*fae548d3Szrj
6565*fae548d3Szrj static void
lang_init_startof_sizeof(void)6566*fae548d3Szrj lang_init_startof_sizeof (void)
6567*fae548d3Szrj {
6568*fae548d3Szrj asection *s;
6569*fae548d3Szrj
6570*fae548d3Szrj for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
6571*fae548d3Szrj {
6572*fae548d3Szrj const char *secname = s->name;
6573*fae548d3Szrj char *symbol = (char *) xmalloc (10 + strlen (secname));
6574*fae548d3Szrj
6575*fae548d3Szrj sprintf (symbol, ".startof.%s", secname);
6576*fae548d3Szrj lang_define_start_stop (symbol, s);
6577*fae548d3Szrj
6578*fae548d3Szrj memcpy (symbol + 1, ".size", 5);
6579*fae548d3Szrj lang_define_start_stop (symbol + 1, s);
6580*fae548d3Szrj free (symbol);
6581*fae548d3Szrj }
6582*fae548d3Szrj }
6583*fae548d3Szrj
6584*fae548d3Szrj /* Set .startof., .sizeof., __start and __stop symbols final values. */
6585*fae548d3Szrj
6586*fae548d3Szrj static void
set_start_stop(struct bfd_link_hash_entry * h)6587*fae548d3Szrj set_start_stop (struct bfd_link_hash_entry *h)
6588*fae548d3Szrj {
6589*fae548d3Szrj if (h->ldscript_def
6590*fae548d3Szrj || h->type != bfd_link_hash_defined)
6591*fae548d3Szrj return;
6592*fae548d3Szrj
6593*fae548d3Szrj if (h->root.string[0] == '.')
6594*fae548d3Szrj {
6595*fae548d3Szrj /* .startof. or .sizeof. symbol.
6596*fae548d3Szrj .startof. already has final value. */
6597*fae548d3Szrj if (h->root.string[2] == 'i')
6598*fae548d3Szrj {
6599*fae548d3Szrj /* .sizeof. */
6600*fae548d3Szrj h->u.def.value = TO_ADDR (h->u.def.section->size);
6601*fae548d3Szrj h->u.def.section = bfd_abs_section_ptr;
6602*fae548d3Szrj }
6603*fae548d3Szrj }
6604*fae548d3Szrj else
6605*fae548d3Szrj {
6606*fae548d3Szrj /* __start or __stop symbol. */
6607*fae548d3Szrj int has_lead = bfd_get_symbol_leading_char (link_info.output_bfd) != 0;
6608*fae548d3Szrj
6609*fae548d3Szrj h->u.def.section = h->u.def.section->output_section;
6610*fae548d3Szrj if (h->root.string[4 + has_lead] == 'o')
6611*fae548d3Szrj {
6612*fae548d3Szrj /* __stop_ */
6613*fae548d3Szrj h->u.def.value = TO_ADDR (h->u.def.section->size);
6614*fae548d3Szrj }
6615*fae548d3Szrj }
6616*fae548d3Szrj }
6617*fae548d3Szrj
6618*fae548d3Szrj static void
lang_finalize_start_stop(void)6619*fae548d3Szrj lang_finalize_start_stop (void)
6620*fae548d3Szrj {
6621*fae548d3Szrj foreach_start_stop (set_start_stop);
6622*fae548d3Szrj }
6623*fae548d3Szrj
6624*fae548d3Szrj static void
lang_end(void)6625*fae548d3Szrj lang_end (void)
6626*fae548d3Szrj {
6627*fae548d3Szrj struct bfd_link_hash_entry *h;
6628*fae548d3Szrj bfd_boolean warn;
6629*fae548d3Szrj
6630*fae548d3Szrj if ((bfd_link_relocatable (&link_info) && !link_info.gc_sections)
6631*fae548d3Szrj || bfd_link_dll (&link_info))
6632*fae548d3Szrj warn = entry_from_cmdline;
6633*fae548d3Szrj else
6634*fae548d3Szrj warn = TRUE;
6635*fae548d3Szrj
6636*fae548d3Szrj /* Force the user to specify a root when generating a relocatable with
6637*fae548d3Szrj --gc-sections, unless --gc-keep-exported was also given. */
6638*fae548d3Szrj if (bfd_link_relocatable (&link_info)
6639*fae548d3Szrj && link_info.gc_sections
6640*fae548d3Szrj && !link_info.gc_keep_exported
6641*fae548d3Szrj && !(entry_from_cmdline || undef_from_cmdline))
6642*fae548d3Szrj einfo (_("%F%P: gc-sections requires either an entry or "
6643*fae548d3Szrj "an undefined symbol\n"));
6644*fae548d3Szrj
6645*fae548d3Szrj if (entry_symbol.name == NULL)
6646*fae548d3Szrj {
6647*fae548d3Szrj /* No entry has been specified. Look for the default entry, but
6648*fae548d3Szrj don't warn if we don't find it. */
6649*fae548d3Szrj entry_symbol.name = entry_symbol_default;
6650*fae548d3Szrj warn = FALSE;
6651*fae548d3Szrj }
6652*fae548d3Szrj
6653*fae548d3Szrj h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
6654*fae548d3Szrj FALSE, FALSE, TRUE);
6655*fae548d3Szrj if (h != NULL
6656*fae548d3Szrj && (h->type == bfd_link_hash_defined
6657*fae548d3Szrj || h->type == bfd_link_hash_defweak)
6658*fae548d3Szrj && h->u.def.section->output_section != NULL)
6659*fae548d3Szrj {
6660*fae548d3Szrj bfd_vma val;
6661*fae548d3Szrj
6662*fae548d3Szrj val = (h->u.def.value
6663*fae548d3Szrj + bfd_section_vma (h->u.def.section->output_section)
6664*fae548d3Szrj + h->u.def.section->output_offset);
6665*fae548d3Szrj if (!bfd_set_start_address (link_info.output_bfd, val))
6666*fae548d3Szrj einfo (_("%F%P: %s: can't set start address\n"), entry_symbol.name);
6667*fae548d3Szrj }
6668*fae548d3Szrj else
6669*fae548d3Szrj {
6670*fae548d3Szrj bfd_vma val;
6671*fae548d3Szrj const char *send;
6672*fae548d3Szrj
6673*fae548d3Szrj /* We couldn't find the entry symbol. Try parsing it as a
6674*fae548d3Szrj number. */
6675*fae548d3Szrj val = bfd_scan_vma (entry_symbol.name, &send, 0);
6676*fae548d3Szrj if (*send == '\0')
6677*fae548d3Szrj {
6678*fae548d3Szrj if (!bfd_set_start_address (link_info.output_bfd, val))
6679*fae548d3Szrj einfo (_("%F%P: can't set start address\n"));
6680*fae548d3Szrj }
6681*fae548d3Szrj else
6682*fae548d3Szrj {
6683*fae548d3Szrj asection *ts;
6684*fae548d3Szrj
6685*fae548d3Szrj /* Can't find the entry symbol, and it's not a number. Use
6686*fae548d3Szrj the first address in the text section. */
6687*fae548d3Szrj ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
6688*fae548d3Szrj if (ts != NULL)
6689*fae548d3Szrj {
6690*fae548d3Szrj if (warn)
6691*fae548d3Szrj einfo (_("%P: warning: cannot find entry symbol %s;"
6692*fae548d3Szrj " defaulting to %V\n"),
6693*fae548d3Szrj entry_symbol.name,
6694*fae548d3Szrj bfd_section_vma (ts));
6695*fae548d3Szrj if (!bfd_set_start_address (link_info.output_bfd,
6696*fae548d3Szrj bfd_section_vma (ts)))
6697*fae548d3Szrj einfo (_("%F%P: can't set start address\n"));
6698*fae548d3Szrj }
6699*fae548d3Szrj else
6700*fae548d3Szrj {
6701*fae548d3Szrj if (warn)
6702*fae548d3Szrj einfo (_("%P: warning: cannot find entry symbol %s;"
6703*fae548d3Szrj " not setting start address\n"),
6704*fae548d3Szrj entry_symbol.name);
6705*fae548d3Szrj }
6706*fae548d3Szrj }
6707*fae548d3Szrj }
6708*fae548d3Szrj }
6709*fae548d3Szrj
6710*fae548d3Szrj /* This is a small function used when we want to ignore errors from
6711*fae548d3Szrj BFD. */
6712*fae548d3Szrj
6713*fae548d3Szrj static void
ignore_bfd_errors(const char * fmt ATTRIBUTE_UNUSED,va_list ap ATTRIBUTE_UNUSED)6714*fae548d3Szrj ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED,
6715*fae548d3Szrj va_list ap ATTRIBUTE_UNUSED)
6716*fae548d3Szrj {
6717*fae548d3Szrj /* Don't do anything. */
6718*fae548d3Szrj }
6719*fae548d3Szrj
6720*fae548d3Szrj /* Check that the architecture of all the input files is compatible
6721*fae548d3Szrj with the output file. Also call the backend to let it do any
6722*fae548d3Szrj other checking that is needed. */
6723*fae548d3Szrj
6724*fae548d3Szrj static void
lang_check(void)6725*fae548d3Szrj lang_check (void)
6726*fae548d3Szrj {
6727*fae548d3Szrj lang_input_statement_type *file;
6728*fae548d3Szrj bfd *input_bfd;
6729*fae548d3Szrj const bfd_arch_info_type *compatible;
6730*fae548d3Szrj
6731*fae548d3Szrj for (file = (void *) file_chain.head;
6732*fae548d3Szrj file != NULL;
6733*fae548d3Szrj file = file->next)
6734*fae548d3Szrj {
6735*fae548d3Szrj #ifdef ENABLE_PLUGINS
6736*fae548d3Szrj /* Don't check format of files claimed by plugin. */
6737*fae548d3Szrj if (file->flags.claimed)
6738*fae548d3Szrj continue;
6739*fae548d3Szrj #endif /* ENABLE_PLUGINS */
6740*fae548d3Szrj input_bfd = file->the_bfd;
6741*fae548d3Szrj compatible
6742*fae548d3Szrj = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
6743*fae548d3Szrj command_line.accept_unknown_input_arch);
6744*fae548d3Szrj
6745*fae548d3Szrj /* In general it is not possible to perform a relocatable
6746*fae548d3Szrj link between differing object formats when the input
6747*fae548d3Szrj file has relocations, because the relocations in the
6748*fae548d3Szrj input format may not have equivalent representations in
6749*fae548d3Szrj the output format (and besides BFD does not translate
6750*fae548d3Szrj relocs for other link purposes than a final link). */
6751*fae548d3Szrj if ((bfd_link_relocatable (&link_info)
6752*fae548d3Szrj || link_info.emitrelocations)
6753*fae548d3Szrj && (compatible == NULL
6754*fae548d3Szrj || (bfd_get_flavour (input_bfd)
6755*fae548d3Szrj != bfd_get_flavour (link_info.output_bfd)))
6756*fae548d3Szrj && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
6757*fae548d3Szrj {
6758*fae548d3Szrj einfo (_("%F%P: relocatable linking with relocations from"
6759*fae548d3Szrj " format %s (%pB) to format %s (%pB) is not supported\n"),
6760*fae548d3Szrj bfd_get_target (input_bfd), input_bfd,
6761*fae548d3Szrj bfd_get_target (link_info.output_bfd), link_info.output_bfd);
6762*fae548d3Szrj /* einfo with %F exits. */
6763*fae548d3Szrj }
6764*fae548d3Szrj
6765*fae548d3Szrj if (compatible == NULL)
6766*fae548d3Szrj {
6767*fae548d3Szrj if (command_line.warn_mismatch)
6768*fae548d3Szrj einfo (_("%X%P: %s architecture of input file `%pB'"
6769*fae548d3Szrj " is incompatible with %s output\n"),
6770*fae548d3Szrj bfd_printable_name (input_bfd), input_bfd,
6771*fae548d3Szrj bfd_printable_name (link_info.output_bfd));
6772*fae548d3Szrj }
6773*fae548d3Szrj else if (bfd_count_sections (input_bfd))
6774*fae548d3Szrj {
6775*fae548d3Szrj /* If the input bfd has no contents, it shouldn't set the
6776*fae548d3Szrj private data of the output bfd. */
6777*fae548d3Szrj
6778*fae548d3Szrj bfd_error_handler_type pfn = NULL;
6779*fae548d3Szrj
6780*fae548d3Szrj /* If we aren't supposed to warn about mismatched input
6781*fae548d3Szrj files, temporarily set the BFD error handler to a
6782*fae548d3Szrj function which will do nothing. We still want to call
6783*fae548d3Szrj bfd_merge_private_bfd_data, since it may set up
6784*fae548d3Szrj information which is needed in the output file. */
6785*fae548d3Szrj if (!command_line.warn_mismatch)
6786*fae548d3Szrj pfn = bfd_set_error_handler (ignore_bfd_errors);
6787*fae548d3Szrj if (!bfd_merge_private_bfd_data (input_bfd, &link_info))
6788*fae548d3Szrj {
6789*fae548d3Szrj if (command_line.warn_mismatch)
6790*fae548d3Szrj einfo (_("%X%P: failed to merge target specific data"
6791*fae548d3Szrj " of file %pB\n"), input_bfd);
6792*fae548d3Szrj }
6793*fae548d3Szrj if (!command_line.warn_mismatch)
6794*fae548d3Szrj bfd_set_error_handler (pfn);
6795*fae548d3Szrj }
6796*fae548d3Szrj }
6797*fae548d3Szrj }
6798*fae548d3Szrj
6799*fae548d3Szrj /* Look through all the global common symbols and attach them to the
6800*fae548d3Szrj correct section. The -sort-common command line switch may be used
6801*fae548d3Szrj to roughly sort the entries by alignment. */
6802*fae548d3Szrj
6803*fae548d3Szrj static void
lang_common(void)6804*fae548d3Szrj lang_common (void)
6805*fae548d3Szrj {
6806*fae548d3Szrj if (link_info.inhibit_common_definition)
6807*fae548d3Szrj return;
6808*fae548d3Szrj if (bfd_link_relocatable (&link_info)
6809*fae548d3Szrj && !command_line.force_common_definition)
6810*fae548d3Szrj return;
6811*fae548d3Szrj
6812*fae548d3Szrj if (!config.sort_common)
6813*fae548d3Szrj bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
6814*fae548d3Szrj else
6815*fae548d3Szrj {
6816*fae548d3Szrj unsigned int power;
6817*fae548d3Szrj
6818*fae548d3Szrj if (config.sort_common == sort_descending)
6819*fae548d3Szrj {
6820*fae548d3Szrj for (power = 4; power > 0; power--)
6821*fae548d3Szrj bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
6822*fae548d3Szrj
6823*fae548d3Szrj power = 0;
6824*fae548d3Szrj bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
6825*fae548d3Szrj }
6826*fae548d3Szrj else
6827*fae548d3Szrj {
6828*fae548d3Szrj for (power = 0; power <= 4; power++)
6829*fae548d3Szrj bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
6830*fae548d3Szrj
6831*fae548d3Szrj power = (unsigned int) -1;
6832*fae548d3Szrj bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
6833*fae548d3Szrj }
6834*fae548d3Szrj }
6835*fae548d3Szrj }
6836*fae548d3Szrj
6837*fae548d3Szrj /* Place one common symbol in the correct section. */
6838*fae548d3Szrj
6839*fae548d3Szrj static bfd_boolean
lang_one_common(struct bfd_link_hash_entry * h,void * info)6840*fae548d3Szrj lang_one_common (struct bfd_link_hash_entry *h, void *info)
6841*fae548d3Szrj {
6842*fae548d3Szrj unsigned int power_of_two;
6843*fae548d3Szrj bfd_vma size;
6844*fae548d3Szrj asection *section;
6845*fae548d3Szrj
6846*fae548d3Szrj if (h->type != bfd_link_hash_common)
6847*fae548d3Szrj return TRUE;
6848*fae548d3Szrj
6849*fae548d3Szrj size = h->u.c.size;
6850*fae548d3Szrj power_of_two = h->u.c.p->alignment_power;
6851*fae548d3Szrj
6852*fae548d3Szrj if (config.sort_common == sort_descending
6853*fae548d3Szrj && power_of_two < *(unsigned int *) info)
6854*fae548d3Szrj return TRUE;
6855*fae548d3Szrj else if (config.sort_common == sort_ascending
6856*fae548d3Szrj && power_of_two > *(unsigned int *) info)
6857*fae548d3Szrj return TRUE;
6858*fae548d3Szrj
6859*fae548d3Szrj section = h->u.c.p->section;
6860*fae548d3Szrj if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))
6861*fae548d3Szrj einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6862*fae548d3Szrj h->root.string);
6863*fae548d3Szrj
6864*fae548d3Szrj if (config.map_file != NULL)
6865*fae548d3Szrj {
6866*fae548d3Szrj static bfd_boolean header_printed;
6867*fae548d3Szrj int len;
6868*fae548d3Szrj char *name;
6869*fae548d3Szrj char buf[50];
6870*fae548d3Szrj
6871*fae548d3Szrj if (!header_printed)
6872*fae548d3Szrj {
6873*fae548d3Szrj minfo (_("\nAllocating common symbols\n"));
6874*fae548d3Szrj minfo (_("Common symbol size file\n\n"));
6875*fae548d3Szrj header_printed = TRUE;
6876*fae548d3Szrj }
6877*fae548d3Szrj
6878*fae548d3Szrj name = bfd_demangle (link_info.output_bfd, h->root.string,
6879*fae548d3Szrj DMGL_ANSI | DMGL_PARAMS);
6880*fae548d3Szrj if (name == NULL)
6881*fae548d3Szrj {
6882*fae548d3Szrj minfo ("%s", h->root.string);
6883*fae548d3Szrj len = strlen (h->root.string);
6884*fae548d3Szrj }
6885*fae548d3Szrj else
6886*fae548d3Szrj {
6887*fae548d3Szrj minfo ("%s", name);
6888*fae548d3Szrj len = strlen (name);
6889*fae548d3Szrj free (name);
6890*fae548d3Szrj }
6891*fae548d3Szrj
6892*fae548d3Szrj if (len >= 19)
6893*fae548d3Szrj {
6894*fae548d3Szrj print_nl ();
6895*fae548d3Szrj len = 0;
6896*fae548d3Szrj }
6897*fae548d3Szrj while (len < 20)
6898*fae548d3Szrj {
6899*fae548d3Szrj print_space ();
6900*fae548d3Szrj ++len;
6901*fae548d3Szrj }
6902*fae548d3Szrj
6903*fae548d3Szrj minfo ("0x");
6904*fae548d3Szrj if (size <= 0xffffffff)
6905*fae548d3Szrj sprintf (buf, "%lx", (unsigned long) size);
6906*fae548d3Szrj else
6907*fae548d3Szrj sprintf_vma (buf, size);
6908*fae548d3Szrj minfo ("%s", buf);
6909*fae548d3Szrj len = strlen (buf);
6910*fae548d3Szrj
6911*fae548d3Szrj while (len < 16)
6912*fae548d3Szrj {
6913*fae548d3Szrj print_space ();
6914*fae548d3Szrj ++len;
6915*fae548d3Szrj }
6916*fae548d3Szrj
6917*fae548d3Szrj minfo ("%pB\n", section->owner);
6918*fae548d3Szrj }
6919*fae548d3Szrj
6920*fae548d3Szrj return TRUE;
6921*fae548d3Szrj }
6922*fae548d3Szrj
6923*fae548d3Szrj /* Handle a single orphan section S, placing the orphan into an appropriate
6924*fae548d3Szrj output section. The effects of the --orphan-handling command line
6925*fae548d3Szrj option are handled here. */
6926*fae548d3Szrj
6927*fae548d3Szrj static void
ldlang_place_orphan(asection * s)6928*fae548d3Szrj ldlang_place_orphan (asection *s)
6929*fae548d3Szrj {
6930*fae548d3Szrj if (config.orphan_handling == orphan_handling_discard)
6931*fae548d3Szrj {
6932*fae548d3Szrj lang_output_section_statement_type *os;
6933*fae548d3Szrj os = lang_output_section_statement_lookup (DISCARD_SECTION_NAME, 0,
6934*fae548d3Szrj TRUE);
6935*fae548d3Szrj if (os->addr_tree == NULL
6936*fae548d3Szrj && (bfd_link_relocatable (&link_info)
6937*fae548d3Szrj || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0))
6938*fae548d3Szrj os->addr_tree = exp_intop (0);
6939*fae548d3Szrj lang_add_section (&os->children, s, NULL, os);
6940*fae548d3Szrj }
6941*fae548d3Szrj else
6942*fae548d3Szrj {
6943*fae548d3Szrj lang_output_section_statement_type *os;
6944*fae548d3Szrj const char *name = s->name;
6945*fae548d3Szrj int constraint = 0;
6946*fae548d3Szrj
6947*fae548d3Szrj if (config.orphan_handling == orphan_handling_error)
6948*fae548d3Szrj einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6949*fae548d3Szrj s, s->owner);
6950*fae548d3Szrj
6951*fae548d3Szrj if (config.unique_orphan_sections || unique_section_p (s, NULL))
6952*fae548d3Szrj constraint = SPECIAL;
6953*fae548d3Szrj
6954*fae548d3Szrj os = ldemul_place_orphan (s, name, constraint);
6955*fae548d3Szrj if (os == NULL)
6956*fae548d3Szrj {
6957*fae548d3Szrj os = lang_output_section_statement_lookup (name, constraint, TRUE);
6958*fae548d3Szrj if (os->addr_tree == NULL
6959*fae548d3Szrj && (bfd_link_relocatable (&link_info)
6960*fae548d3Szrj || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0))
6961*fae548d3Szrj os->addr_tree = exp_intop (0);
6962*fae548d3Szrj lang_add_section (&os->children, s, NULL, os);
6963*fae548d3Szrj }
6964*fae548d3Szrj
6965*fae548d3Szrj if (config.orphan_handling == orphan_handling_warn)
6966*fae548d3Szrj einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6967*fae548d3Szrj "placed in section `%s'\n"),
6968*fae548d3Szrj s, s->owner, os->name);
6969*fae548d3Szrj }
6970*fae548d3Szrj }
6971*fae548d3Szrj
6972*fae548d3Szrj /* Run through the input files and ensure that every input section has
6973*fae548d3Szrj somewhere to go. If one is found without a destination then create
6974*fae548d3Szrj an input request and place it into the statement tree. */
6975*fae548d3Szrj
6976*fae548d3Szrj static void
lang_place_orphans(void)6977*fae548d3Szrj lang_place_orphans (void)
6978*fae548d3Szrj {
6979*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (file)
6980*fae548d3Szrj {
6981*fae548d3Szrj asection *s;
6982*fae548d3Szrj
6983*fae548d3Szrj for (s = file->the_bfd->sections; s != NULL; s = s->next)
6984*fae548d3Szrj {
6985*fae548d3Szrj if (s->output_section == NULL)
6986*fae548d3Szrj {
6987*fae548d3Szrj /* This section of the file is not attached, root
6988*fae548d3Szrj around for a sensible place for it to go. */
6989*fae548d3Szrj
6990*fae548d3Szrj if (file->flags.just_syms)
6991*fae548d3Szrj bfd_link_just_syms (file->the_bfd, s, &link_info);
6992*fae548d3Szrj else if (lang_discard_section_p (s))
6993*fae548d3Szrj s->output_section = bfd_abs_section_ptr;
6994*fae548d3Szrj else if (strcmp (s->name, "COMMON") == 0)
6995*fae548d3Szrj {
6996*fae548d3Szrj /* This is a lonely common section which must have
6997*fae548d3Szrj come from an archive. We attach to the section
6998*fae548d3Szrj with the wildcard. */
6999*fae548d3Szrj if (!bfd_link_relocatable (&link_info)
7000*fae548d3Szrj || command_line.force_common_definition)
7001*fae548d3Szrj {
7002*fae548d3Szrj if (default_common_section == NULL)
7003*fae548d3Szrj default_common_section
7004*fae548d3Szrj = lang_output_section_statement_lookup (".bss", 0,
7005*fae548d3Szrj TRUE);
7006*fae548d3Szrj lang_add_section (&default_common_section->children, s,
7007*fae548d3Szrj NULL, default_common_section);
7008*fae548d3Szrj }
7009*fae548d3Szrj }
7010*fae548d3Szrj else
7011*fae548d3Szrj ldlang_place_orphan (s);
7012*fae548d3Szrj }
7013*fae548d3Szrj }
7014*fae548d3Szrj }
7015*fae548d3Szrj }
7016*fae548d3Szrj
7017*fae548d3Szrj void
lang_set_flags(lang_memory_region_type * ptr,const char * flags,int invert)7018*fae548d3Szrj lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
7019*fae548d3Szrj {
7020*fae548d3Szrj flagword *ptr_flags;
7021*fae548d3Szrj
7022*fae548d3Szrj ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
7023*fae548d3Szrj
7024*fae548d3Szrj while (*flags)
7025*fae548d3Szrj {
7026*fae548d3Szrj switch (*flags)
7027*fae548d3Szrj {
7028*fae548d3Szrj /* PR 17900: An exclamation mark in the attributes reverses
7029*fae548d3Szrj the sense of any of the attributes that follow. */
7030*fae548d3Szrj case '!':
7031*fae548d3Szrj invert = !invert;
7032*fae548d3Szrj ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
7033*fae548d3Szrj break;
7034*fae548d3Szrj
7035*fae548d3Szrj case 'A': case 'a':
7036*fae548d3Szrj *ptr_flags |= SEC_ALLOC;
7037*fae548d3Szrj break;
7038*fae548d3Szrj
7039*fae548d3Szrj case 'R': case 'r':
7040*fae548d3Szrj *ptr_flags |= SEC_READONLY;
7041*fae548d3Szrj break;
7042*fae548d3Szrj
7043*fae548d3Szrj case 'W': case 'w':
7044*fae548d3Szrj *ptr_flags |= SEC_DATA;
7045*fae548d3Szrj break;
7046*fae548d3Szrj
7047*fae548d3Szrj case 'X': case 'x':
7048*fae548d3Szrj *ptr_flags |= SEC_CODE;
7049*fae548d3Szrj break;
7050*fae548d3Szrj
7051*fae548d3Szrj case 'L': case 'l':
7052*fae548d3Szrj case 'I': case 'i':
7053*fae548d3Szrj *ptr_flags |= SEC_LOAD;
7054*fae548d3Szrj break;
7055*fae548d3Szrj
7056*fae548d3Szrj default:
7057*fae548d3Szrj einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7058*fae548d3Szrj *flags, *flags);
7059*fae548d3Szrj break;
7060*fae548d3Szrj }
7061*fae548d3Szrj flags++;
7062*fae548d3Szrj }
7063*fae548d3Szrj }
7064*fae548d3Szrj
7065*fae548d3Szrj /* Call a function on each real input file. This function will be
7066*fae548d3Szrj called on an archive, but not on the elements. */
7067*fae548d3Szrj
7068*fae548d3Szrj void
lang_for_each_input_file(void (* func)(lang_input_statement_type *))7069*fae548d3Szrj lang_for_each_input_file (void (*func) (lang_input_statement_type *))
7070*fae548d3Szrj {
7071*fae548d3Szrj lang_input_statement_type *f;
7072*fae548d3Szrj
7073*fae548d3Szrj for (f = (void *) input_file_chain.head;
7074*fae548d3Szrj f != NULL;
7075*fae548d3Szrj f = f->next_real_file)
7076*fae548d3Szrj if (f->flags.real)
7077*fae548d3Szrj func (f);
7078*fae548d3Szrj }
7079*fae548d3Szrj
7080*fae548d3Szrj /* Call a function on each real file. The function will be called on
7081*fae548d3Szrj all the elements of an archive which are included in the link, but
7082*fae548d3Szrj will not be called on the archive file itself. */
7083*fae548d3Szrj
7084*fae548d3Szrj void
lang_for_each_file(void (* func)(lang_input_statement_type *))7085*fae548d3Szrj lang_for_each_file (void (*func) (lang_input_statement_type *))
7086*fae548d3Szrj {
7087*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (f)
7088*fae548d3Szrj {
7089*fae548d3Szrj if (f->flags.real)
7090*fae548d3Szrj func (f);
7091*fae548d3Szrj }
7092*fae548d3Szrj }
7093*fae548d3Szrj
7094*fae548d3Szrj void
ldlang_add_file(lang_input_statement_type * entry)7095*fae548d3Szrj ldlang_add_file (lang_input_statement_type *entry)
7096*fae548d3Szrj {
7097*fae548d3Szrj lang_statement_append (&file_chain, entry, &entry->next);
7098*fae548d3Szrj
7099*fae548d3Szrj /* The BFD linker needs to have a list of all input BFDs involved in
7100*fae548d3Szrj a link. */
7101*fae548d3Szrj ASSERT (entry->the_bfd->link.next == NULL);
7102*fae548d3Szrj ASSERT (entry->the_bfd != link_info.output_bfd);
7103*fae548d3Szrj
7104*fae548d3Szrj *link_info.input_bfds_tail = entry->the_bfd;
7105*fae548d3Szrj link_info.input_bfds_tail = &entry->the_bfd->link.next;
7106*fae548d3Szrj bfd_set_usrdata (entry->the_bfd, entry);
7107*fae548d3Szrj bfd_set_gp_size (entry->the_bfd, g_switch_value);
7108*fae548d3Szrj
7109*fae548d3Szrj /* Look through the sections and check for any which should not be
7110*fae548d3Szrj included in the link. We need to do this now, so that we can
7111*fae548d3Szrj notice when the backend linker tries to report multiple
7112*fae548d3Szrj definition errors for symbols which are in sections we aren't
7113*fae548d3Szrj going to link. FIXME: It might be better to entirely ignore
7114*fae548d3Szrj symbols which are defined in sections which are going to be
7115*fae548d3Szrj discarded. This would require modifying the backend linker for
7116*fae548d3Szrj each backend which might set the SEC_LINK_ONCE flag. If we do
7117*fae548d3Szrj this, we should probably handle SEC_EXCLUDE in the same way. */
7118*fae548d3Szrj
7119*fae548d3Szrj bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
7120*fae548d3Szrj }
7121*fae548d3Szrj
7122*fae548d3Szrj void
lang_add_output(const char * name,int from_script)7123*fae548d3Szrj lang_add_output (const char *name, int from_script)
7124*fae548d3Szrj {
7125*fae548d3Szrj /* Make -o on command line override OUTPUT in script. */
7126*fae548d3Szrj if (!had_output_filename || !from_script)
7127*fae548d3Szrj {
7128*fae548d3Szrj output_filename = name;
7129*fae548d3Szrj had_output_filename = TRUE;
7130*fae548d3Szrj }
7131*fae548d3Szrj }
7132*fae548d3Szrj
7133*fae548d3Szrj lang_output_section_statement_type *
lang_enter_output_section_statement(const char * output_section_statement_name,etree_type * address_exp,enum section_type sectype,etree_type * align,etree_type * subalign,etree_type * ebase,int constraint,int align_with_input)7134*fae548d3Szrj lang_enter_output_section_statement (const char *output_section_statement_name,
7135*fae548d3Szrj etree_type *address_exp,
7136*fae548d3Szrj enum section_type sectype,
7137*fae548d3Szrj etree_type *align,
7138*fae548d3Szrj etree_type *subalign,
7139*fae548d3Szrj etree_type *ebase,
7140*fae548d3Szrj int constraint,
7141*fae548d3Szrj int align_with_input)
7142*fae548d3Szrj {
7143*fae548d3Szrj lang_output_section_statement_type *os;
7144*fae548d3Szrj
7145*fae548d3Szrj os = lang_output_section_statement_lookup (output_section_statement_name,
7146*fae548d3Szrj constraint, TRUE);
7147*fae548d3Szrj current_section = os;
7148*fae548d3Szrj
7149*fae548d3Szrj if (os->addr_tree == NULL)
7150*fae548d3Szrj {
7151*fae548d3Szrj os->addr_tree = address_exp;
7152*fae548d3Szrj }
7153*fae548d3Szrj os->sectype = sectype;
7154*fae548d3Szrj if (sectype != noload_section)
7155*fae548d3Szrj os->flags = SEC_NO_FLAGS;
7156*fae548d3Szrj else
7157*fae548d3Szrj os->flags = SEC_NEVER_LOAD;
7158*fae548d3Szrj os->block_value = 1;
7159*fae548d3Szrj
7160*fae548d3Szrj /* Make next things chain into subchain of this. */
7161*fae548d3Szrj push_stat_ptr (&os->children);
7162*fae548d3Szrj
7163*fae548d3Szrj os->align_lma_with_input = align_with_input == ALIGN_WITH_INPUT;
7164*fae548d3Szrj if (os->align_lma_with_input && align != NULL)
7165*fae548d3Szrj einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7166*fae548d3Szrj NULL);
7167*fae548d3Szrj
7168*fae548d3Szrj os->subsection_alignment = subalign;
7169*fae548d3Szrj os->section_alignment = align;
7170*fae548d3Szrj
7171*fae548d3Szrj os->load_base = ebase;
7172*fae548d3Szrj return os;
7173*fae548d3Szrj }
7174*fae548d3Szrj
7175*fae548d3Szrj void
lang_final(void)7176*fae548d3Szrj lang_final (void)
7177*fae548d3Szrj {
7178*fae548d3Szrj lang_output_statement_type *new_stmt;
7179*fae548d3Szrj
7180*fae548d3Szrj new_stmt = new_stat (lang_output_statement, stat_ptr);
7181*fae548d3Szrj new_stmt->name = output_filename;
7182*fae548d3Szrj }
7183*fae548d3Szrj
7184*fae548d3Szrj /* Reset the current counters in the regions. */
7185*fae548d3Szrj
7186*fae548d3Szrj void
lang_reset_memory_regions(void)7187*fae548d3Szrj lang_reset_memory_regions (void)
7188*fae548d3Szrj {
7189*fae548d3Szrj lang_memory_region_type *p = lang_memory_region_list;
7190*fae548d3Szrj asection *o;
7191*fae548d3Szrj lang_output_section_statement_type *os;
7192*fae548d3Szrj
7193*fae548d3Szrj for (p = lang_memory_region_list; p != NULL; p = p->next)
7194*fae548d3Szrj {
7195*fae548d3Szrj p->current = p->origin;
7196*fae548d3Szrj p->last_os = NULL;
7197*fae548d3Szrj }
7198*fae548d3Szrj
7199*fae548d3Szrj for (os = (void *) lang_os_list.head;
7200*fae548d3Szrj os != NULL;
7201*fae548d3Szrj os = os->next)
7202*fae548d3Szrj {
7203*fae548d3Szrj os->processed_vma = FALSE;
7204*fae548d3Szrj os->processed_lma = FALSE;
7205*fae548d3Szrj }
7206*fae548d3Szrj
7207*fae548d3Szrj for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
7208*fae548d3Szrj {
7209*fae548d3Szrj /* Save the last size for possible use by bfd_relax_section. */
7210*fae548d3Szrj o->rawsize = o->size;
7211*fae548d3Szrj if (!(o->flags & SEC_FIXED_SIZE))
7212*fae548d3Szrj o->size = 0;
7213*fae548d3Szrj }
7214*fae548d3Szrj }
7215*fae548d3Szrj
7216*fae548d3Szrj /* Worker for lang_gc_sections_1. */
7217*fae548d3Szrj
7218*fae548d3Szrj static void
gc_section_callback(lang_wild_statement_type * ptr,struct wildcard_list * sec ATTRIBUTE_UNUSED,asection * section,struct flag_info * sflag_info ATTRIBUTE_UNUSED,lang_input_statement_type * file ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED)7219*fae548d3Szrj gc_section_callback (lang_wild_statement_type *ptr,
7220*fae548d3Szrj struct wildcard_list *sec ATTRIBUTE_UNUSED,
7221*fae548d3Szrj asection *section,
7222*fae548d3Szrj struct flag_info *sflag_info ATTRIBUTE_UNUSED,
7223*fae548d3Szrj lang_input_statement_type *file ATTRIBUTE_UNUSED,
7224*fae548d3Szrj void *data ATTRIBUTE_UNUSED)
7225*fae548d3Szrj {
7226*fae548d3Szrj /* If the wild pattern was marked KEEP, the member sections
7227*fae548d3Szrj should be as well. */
7228*fae548d3Szrj if (ptr->keep_sections)
7229*fae548d3Szrj section->flags |= SEC_KEEP;
7230*fae548d3Szrj }
7231*fae548d3Szrj
7232*fae548d3Szrj /* Iterate over sections marking them against GC. */
7233*fae548d3Szrj
7234*fae548d3Szrj static void
lang_gc_sections_1(lang_statement_union_type * s)7235*fae548d3Szrj lang_gc_sections_1 (lang_statement_union_type *s)
7236*fae548d3Szrj {
7237*fae548d3Szrj for (; s != NULL; s = s->header.next)
7238*fae548d3Szrj {
7239*fae548d3Szrj switch (s->header.type)
7240*fae548d3Szrj {
7241*fae548d3Szrj case lang_wild_statement_enum:
7242*fae548d3Szrj walk_wild (&s->wild_statement, gc_section_callback, NULL);
7243*fae548d3Szrj break;
7244*fae548d3Szrj case lang_constructors_statement_enum:
7245*fae548d3Szrj lang_gc_sections_1 (constructor_list.head);
7246*fae548d3Szrj break;
7247*fae548d3Szrj case lang_output_section_statement_enum:
7248*fae548d3Szrj lang_gc_sections_1 (s->output_section_statement.children.head);
7249*fae548d3Szrj break;
7250*fae548d3Szrj case lang_group_statement_enum:
7251*fae548d3Szrj lang_gc_sections_1 (s->group_statement.children.head);
7252*fae548d3Szrj break;
7253*fae548d3Szrj default:
7254*fae548d3Szrj break;
7255*fae548d3Szrj }
7256*fae548d3Szrj }
7257*fae548d3Szrj }
7258*fae548d3Szrj
7259*fae548d3Szrj static void
lang_gc_sections(void)7260*fae548d3Szrj lang_gc_sections (void)
7261*fae548d3Szrj {
7262*fae548d3Szrj /* Keep all sections so marked in the link script. */
7263*fae548d3Szrj lang_gc_sections_1 (statement_list.head);
7264*fae548d3Szrj
7265*fae548d3Szrj /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7266*fae548d3Szrj the special case of debug info. (See bfd/stabs.c)
7267*fae548d3Szrj Twiddle the flag here, to simplify later linker code. */
7268*fae548d3Szrj if (bfd_link_relocatable (&link_info))
7269*fae548d3Szrj {
7270*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (f)
7271*fae548d3Szrj {
7272*fae548d3Szrj asection *sec;
7273*fae548d3Szrj #ifdef ENABLE_PLUGINS
7274*fae548d3Szrj if (f->flags.claimed)
7275*fae548d3Szrj continue;
7276*fae548d3Szrj #endif
7277*fae548d3Szrj for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
7278*fae548d3Szrj if ((sec->flags & SEC_DEBUGGING) == 0)
7279*fae548d3Szrj sec->flags &= ~SEC_EXCLUDE;
7280*fae548d3Szrj }
7281*fae548d3Szrj }
7282*fae548d3Szrj
7283*fae548d3Szrj if (link_info.gc_sections)
7284*fae548d3Szrj bfd_gc_sections (link_info.output_bfd, &link_info);
7285*fae548d3Szrj }
7286*fae548d3Szrj
7287*fae548d3Szrj /* Worker for lang_find_relro_sections_1. */
7288*fae548d3Szrj
7289*fae548d3Szrj static void
find_relro_section_callback(lang_wild_statement_type * ptr ATTRIBUTE_UNUSED,struct wildcard_list * sec ATTRIBUTE_UNUSED,asection * section,struct flag_info * sflag_info ATTRIBUTE_UNUSED,lang_input_statement_type * file ATTRIBUTE_UNUSED,void * data)7290*fae548d3Szrj find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
7291*fae548d3Szrj struct wildcard_list *sec ATTRIBUTE_UNUSED,
7292*fae548d3Szrj asection *section,
7293*fae548d3Szrj struct flag_info *sflag_info ATTRIBUTE_UNUSED,
7294*fae548d3Szrj lang_input_statement_type *file ATTRIBUTE_UNUSED,
7295*fae548d3Szrj void *data)
7296*fae548d3Szrj {
7297*fae548d3Szrj /* Discarded, excluded and ignored sections effectively have zero
7298*fae548d3Szrj size. */
7299*fae548d3Szrj if (section->output_section != NULL
7300*fae548d3Szrj && section->output_section->owner == link_info.output_bfd
7301*fae548d3Szrj && (section->output_section->flags & SEC_EXCLUDE) == 0
7302*fae548d3Szrj && !IGNORE_SECTION (section)
7303*fae548d3Szrj && section->size != 0)
7304*fae548d3Szrj {
7305*fae548d3Szrj bfd_boolean *has_relro_section = (bfd_boolean *) data;
7306*fae548d3Szrj *has_relro_section = TRUE;
7307*fae548d3Szrj }
7308*fae548d3Szrj }
7309*fae548d3Szrj
7310*fae548d3Szrj /* Iterate over sections for relro sections. */
7311*fae548d3Szrj
7312*fae548d3Szrj static void
lang_find_relro_sections_1(lang_statement_union_type * s,seg_align_type * seg,bfd_boolean * has_relro_section)7313*fae548d3Szrj lang_find_relro_sections_1 (lang_statement_union_type *s,
7314*fae548d3Szrj seg_align_type *seg,
7315*fae548d3Szrj bfd_boolean *has_relro_section)
7316*fae548d3Szrj {
7317*fae548d3Szrj if (*has_relro_section)
7318*fae548d3Szrj return;
7319*fae548d3Szrj
7320*fae548d3Szrj for (; s != NULL; s = s->header.next)
7321*fae548d3Szrj {
7322*fae548d3Szrj if (s == seg->relro_end_stat)
7323*fae548d3Szrj break;
7324*fae548d3Szrj
7325*fae548d3Szrj switch (s->header.type)
7326*fae548d3Szrj {
7327*fae548d3Szrj case lang_wild_statement_enum:
7328*fae548d3Szrj walk_wild (&s->wild_statement,
7329*fae548d3Szrj find_relro_section_callback,
7330*fae548d3Szrj has_relro_section);
7331*fae548d3Szrj break;
7332*fae548d3Szrj case lang_constructors_statement_enum:
7333*fae548d3Szrj lang_find_relro_sections_1 (constructor_list.head,
7334*fae548d3Szrj seg, has_relro_section);
7335*fae548d3Szrj break;
7336*fae548d3Szrj case lang_output_section_statement_enum:
7337*fae548d3Szrj lang_find_relro_sections_1 (s->output_section_statement.children.head,
7338*fae548d3Szrj seg, has_relro_section);
7339*fae548d3Szrj break;
7340*fae548d3Szrj case lang_group_statement_enum:
7341*fae548d3Szrj lang_find_relro_sections_1 (s->group_statement.children.head,
7342*fae548d3Szrj seg, has_relro_section);
7343*fae548d3Szrj break;
7344*fae548d3Szrj default:
7345*fae548d3Szrj break;
7346*fae548d3Szrj }
7347*fae548d3Szrj }
7348*fae548d3Szrj }
7349*fae548d3Szrj
7350*fae548d3Szrj static void
lang_find_relro_sections(void)7351*fae548d3Szrj lang_find_relro_sections (void)
7352*fae548d3Szrj {
7353*fae548d3Szrj bfd_boolean has_relro_section = FALSE;
7354*fae548d3Szrj
7355*fae548d3Szrj /* Check all sections in the link script. */
7356*fae548d3Szrj
7357*fae548d3Szrj lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
7358*fae548d3Szrj &expld.dataseg, &has_relro_section);
7359*fae548d3Szrj
7360*fae548d3Szrj if (!has_relro_section)
7361*fae548d3Szrj link_info.relro = FALSE;
7362*fae548d3Szrj }
7363*fae548d3Szrj
7364*fae548d3Szrj /* Relax all sections until bfd_relax_section gives up. */
7365*fae548d3Szrj
7366*fae548d3Szrj void
lang_relax_sections(bfd_boolean need_layout)7367*fae548d3Szrj lang_relax_sections (bfd_boolean need_layout)
7368*fae548d3Szrj {
7369*fae548d3Szrj if (RELAXATION_ENABLED)
7370*fae548d3Szrj {
7371*fae548d3Szrj /* We may need more than one relaxation pass. */
7372*fae548d3Szrj int i = link_info.relax_pass;
7373*fae548d3Szrj
7374*fae548d3Szrj /* The backend can use it to determine the current pass. */
7375*fae548d3Szrj link_info.relax_pass = 0;
7376*fae548d3Szrj
7377*fae548d3Szrj while (i--)
7378*fae548d3Szrj {
7379*fae548d3Szrj /* Keep relaxing until bfd_relax_section gives up. */
7380*fae548d3Szrj bfd_boolean relax_again;
7381*fae548d3Szrj
7382*fae548d3Szrj link_info.relax_trip = -1;
7383*fae548d3Szrj do
7384*fae548d3Szrj {
7385*fae548d3Szrj link_info.relax_trip++;
7386*fae548d3Szrj
7387*fae548d3Szrj /* Note: pe-dll.c does something like this also. If you find
7388*fae548d3Szrj you need to change this code, you probably need to change
7389*fae548d3Szrj pe-dll.c also. DJ */
7390*fae548d3Szrj
7391*fae548d3Szrj /* Do all the assignments with our current guesses as to
7392*fae548d3Szrj section sizes. */
7393*fae548d3Szrj lang_do_assignments (lang_assigning_phase_enum);
7394*fae548d3Szrj
7395*fae548d3Szrj /* We must do this after lang_do_assignments, because it uses
7396*fae548d3Szrj size. */
7397*fae548d3Szrj lang_reset_memory_regions ();
7398*fae548d3Szrj
7399*fae548d3Szrj /* Perform another relax pass - this time we know where the
7400*fae548d3Szrj globals are, so can make a better guess. */
7401*fae548d3Szrj relax_again = FALSE;
7402*fae548d3Szrj lang_size_sections (&relax_again, FALSE);
7403*fae548d3Szrj }
7404*fae548d3Szrj while (relax_again);
7405*fae548d3Szrj
7406*fae548d3Szrj link_info.relax_pass++;
7407*fae548d3Szrj }
7408*fae548d3Szrj need_layout = TRUE;
7409*fae548d3Szrj }
7410*fae548d3Szrj
7411*fae548d3Szrj if (need_layout)
7412*fae548d3Szrj {
7413*fae548d3Szrj /* Final extra sizing to report errors. */
7414*fae548d3Szrj lang_do_assignments (lang_assigning_phase_enum);
7415*fae548d3Szrj lang_reset_memory_regions ();
7416*fae548d3Szrj lang_size_sections (NULL, TRUE);
7417*fae548d3Szrj }
7418*fae548d3Szrj }
7419*fae548d3Szrj
7420*fae548d3Szrj #ifdef ENABLE_PLUGINS
7421*fae548d3Szrj /* Find the insert point for the plugin's replacement files. We
7422*fae548d3Szrj place them after the first claimed real object file, or if the
7423*fae548d3Szrj first claimed object is an archive member, after the last real
7424*fae548d3Szrj object file immediately preceding the archive. In the event
7425*fae548d3Szrj no objects have been claimed at all, we return the first dummy
7426*fae548d3Szrj object file on the list as the insert point; that works, but
7427*fae548d3Szrj the callee must be careful when relinking the file_chain as it
7428*fae548d3Szrj is not actually on that chain, only the statement_list and the
7429*fae548d3Szrj input_file list; in that case, the replacement files must be
7430*fae548d3Szrj inserted at the head of the file_chain. */
7431*fae548d3Szrj
7432*fae548d3Szrj static lang_input_statement_type *
find_replacements_insert_point(bfd_boolean * before)7433*fae548d3Szrj find_replacements_insert_point (bfd_boolean *before)
7434*fae548d3Szrj {
7435*fae548d3Szrj lang_input_statement_type *claim1, *lastobject;
7436*fae548d3Szrj lastobject = (void *) input_file_chain.head;
7437*fae548d3Szrj for (claim1 = (void *) file_chain.head;
7438*fae548d3Szrj claim1 != NULL;
7439*fae548d3Szrj claim1 = claim1->next)
7440*fae548d3Szrj {
7441*fae548d3Szrj if (claim1->flags.claimed)
7442*fae548d3Szrj {
7443*fae548d3Szrj *before = claim1->flags.claim_archive;
7444*fae548d3Szrj return claim1->flags.claim_archive ? lastobject : claim1;
7445*fae548d3Szrj }
7446*fae548d3Szrj /* Update lastobject if this is a real object file. */
7447*fae548d3Szrj if (claim1->the_bfd != NULL && claim1->the_bfd->my_archive == NULL)
7448*fae548d3Szrj lastobject = claim1;
7449*fae548d3Szrj }
7450*fae548d3Szrj /* No files were claimed by the plugin. Choose the last object
7451*fae548d3Szrj file found on the list (maybe the first, dummy entry) as the
7452*fae548d3Szrj insert point. */
7453*fae548d3Szrj *before = FALSE;
7454*fae548d3Szrj return lastobject;
7455*fae548d3Szrj }
7456*fae548d3Szrj
7457*fae548d3Szrj /* Find where to insert ADD, an archive element or shared library
7458*fae548d3Szrj added during a rescan. */
7459*fae548d3Szrj
7460*fae548d3Szrj static lang_input_statement_type **
find_rescan_insertion(lang_input_statement_type * add)7461*fae548d3Szrj find_rescan_insertion (lang_input_statement_type *add)
7462*fae548d3Szrj {
7463*fae548d3Szrj bfd *add_bfd = add->the_bfd;
7464*fae548d3Szrj lang_input_statement_type *f;
7465*fae548d3Szrj lang_input_statement_type *last_loaded = NULL;
7466*fae548d3Szrj lang_input_statement_type *before = NULL;
7467*fae548d3Szrj lang_input_statement_type **iter = NULL;
7468*fae548d3Szrj
7469*fae548d3Szrj if (add_bfd->my_archive != NULL)
7470*fae548d3Szrj add_bfd = add_bfd->my_archive;
7471*fae548d3Szrj
7472*fae548d3Szrj /* First look through the input file chain, to find an object file
7473*fae548d3Szrj before the one we've rescanned. Normal object files always
7474*fae548d3Szrj appear on both the input file chain and the file chain, so this
7475*fae548d3Szrj lets us get quickly to somewhere near the correct place on the
7476*fae548d3Szrj file chain if it is full of archive elements. Archives don't
7477*fae548d3Szrj appear on the file chain, but if an element has been extracted
7478*fae548d3Szrj then their input_statement->next points at it. */
7479*fae548d3Szrj for (f = (void *) input_file_chain.head;
7480*fae548d3Szrj f != NULL;
7481*fae548d3Szrj f = f->next_real_file)
7482*fae548d3Szrj {
7483*fae548d3Szrj if (f->the_bfd == add_bfd)
7484*fae548d3Szrj {
7485*fae548d3Szrj before = last_loaded;
7486*fae548d3Szrj if (f->next != NULL)
7487*fae548d3Szrj return &f->next->next;
7488*fae548d3Szrj }
7489*fae548d3Szrj if (f->the_bfd != NULL && f->next != NULL)
7490*fae548d3Szrj last_loaded = f;
7491*fae548d3Szrj }
7492*fae548d3Szrj
7493*fae548d3Szrj for (iter = before ? &before->next : &file_chain.head->input_statement.next;
7494*fae548d3Szrj *iter != NULL;
7495*fae548d3Szrj iter = &(*iter)->next)
7496*fae548d3Szrj if (!(*iter)->flags.claim_archive
7497*fae548d3Szrj && (*iter)->the_bfd->my_archive == NULL)
7498*fae548d3Szrj break;
7499*fae548d3Szrj
7500*fae548d3Szrj return iter;
7501*fae548d3Szrj }
7502*fae548d3Szrj
7503*fae548d3Szrj /* Insert SRCLIST into DESTLIST after given element by chaining
7504*fae548d3Szrj on FIELD as the next-pointer. (Counterintuitively does not need
7505*fae548d3Szrj a pointer to the actual after-node itself, just its chain field.) */
7506*fae548d3Szrj
7507*fae548d3Szrj static void
lang_list_insert_after(lang_statement_list_type * destlist,lang_statement_list_type * srclist,lang_statement_union_type ** field)7508*fae548d3Szrj lang_list_insert_after (lang_statement_list_type *destlist,
7509*fae548d3Szrj lang_statement_list_type *srclist,
7510*fae548d3Szrj lang_statement_union_type **field)
7511*fae548d3Szrj {
7512*fae548d3Szrj *(srclist->tail) = *field;
7513*fae548d3Szrj *field = srclist->head;
7514*fae548d3Szrj if (destlist->tail == field)
7515*fae548d3Szrj destlist->tail = srclist->tail;
7516*fae548d3Szrj }
7517*fae548d3Szrj
7518*fae548d3Szrj /* Detach new nodes added to DESTLIST since the time ORIGLIST
7519*fae548d3Szrj was taken as a copy of it and leave them in ORIGLIST. */
7520*fae548d3Szrj
7521*fae548d3Szrj static void
lang_list_remove_tail(lang_statement_list_type * destlist,lang_statement_list_type * origlist)7522*fae548d3Szrj lang_list_remove_tail (lang_statement_list_type *destlist,
7523*fae548d3Szrj lang_statement_list_type *origlist)
7524*fae548d3Szrj {
7525*fae548d3Szrj union lang_statement_union **savetail;
7526*fae548d3Szrj /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7527*fae548d3Szrj ASSERT (origlist->head == destlist->head);
7528*fae548d3Szrj savetail = origlist->tail;
7529*fae548d3Szrj origlist->head = *(savetail);
7530*fae548d3Szrj origlist->tail = destlist->tail;
7531*fae548d3Szrj destlist->tail = savetail;
7532*fae548d3Szrj *savetail = NULL;
7533*fae548d3Szrj }
7534*fae548d3Szrj
7535*fae548d3Szrj static lang_statement_union_type **
find_next_input_statement(lang_statement_union_type ** s)7536*fae548d3Szrj find_next_input_statement (lang_statement_union_type **s)
7537*fae548d3Szrj {
7538*fae548d3Szrj for ( ; *s; s = &(*s)->header.next)
7539*fae548d3Szrj {
7540*fae548d3Szrj lang_statement_union_type **t;
7541*fae548d3Szrj switch ((*s)->header.type)
7542*fae548d3Szrj {
7543*fae548d3Szrj case lang_input_statement_enum:
7544*fae548d3Szrj return s;
7545*fae548d3Szrj case lang_wild_statement_enum:
7546*fae548d3Szrj t = &(*s)->wild_statement.children.head;
7547*fae548d3Szrj break;
7548*fae548d3Szrj case lang_group_statement_enum:
7549*fae548d3Szrj t = &(*s)->group_statement.children.head;
7550*fae548d3Szrj break;
7551*fae548d3Szrj case lang_output_section_statement_enum:
7552*fae548d3Szrj t = &(*s)->output_section_statement.children.head;
7553*fae548d3Szrj break;
7554*fae548d3Szrj default:
7555*fae548d3Szrj continue;
7556*fae548d3Szrj }
7557*fae548d3Szrj t = find_next_input_statement (t);
7558*fae548d3Szrj if (*t)
7559*fae548d3Szrj return t;
7560*fae548d3Szrj }
7561*fae548d3Szrj return s;
7562*fae548d3Szrj }
7563*fae548d3Szrj #endif /* ENABLE_PLUGINS */
7564*fae548d3Szrj
7565*fae548d3Szrj /* Add NAME to the list of garbage collection entry points. */
7566*fae548d3Szrj
7567*fae548d3Szrj void
lang_add_gc_name(const char * name)7568*fae548d3Szrj lang_add_gc_name (const char *name)
7569*fae548d3Szrj {
7570*fae548d3Szrj struct bfd_sym_chain *sym;
7571*fae548d3Szrj
7572*fae548d3Szrj if (name == NULL)
7573*fae548d3Szrj return;
7574*fae548d3Szrj
7575*fae548d3Szrj sym = stat_alloc (sizeof (*sym));
7576*fae548d3Szrj
7577*fae548d3Szrj sym->next = link_info.gc_sym_list;
7578*fae548d3Szrj sym->name = name;
7579*fae548d3Szrj link_info.gc_sym_list = sym;
7580*fae548d3Szrj }
7581*fae548d3Szrj
7582*fae548d3Szrj /* Check relocations. */
7583*fae548d3Szrj
7584*fae548d3Szrj static void
lang_check_relocs(void)7585*fae548d3Szrj lang_check_relocs (void)
7586*fae548d3Szrj {
7587*fae548d3Szrj if (link_info.check_relocs_after_open_input)
7588*fae548d3Szrj {
7589*fae548d3Szrj bfd *abfd;
7590*fae548d3Szrj
7591*fae548d3Szrj for (abfd = link_info.input_bfds;
7592*fae548d3Szrj abfd != (bfd *) NULL; abfd = abfd->link.next)
7593*fae548d3Szrj if (!bfd_link_check_relocs (abfd, &link_info))
7594*fae548d3Szrj {
7595*fae548d3Szrj /* No object output, fail return. */
7596*fae548d3Szrj config.make_executable = FALSE;
7597*fae548d3Szrj /* Note: we do not abort the loop, but rather
7598*fae548d3Szrj continue the scan in case there are other
7599*fae548d3Szrj bad relocations to report. */
7600*fae548d3Szrj }
7601*fae548d3Szrj }
7602*fae548d3Szrj }
7603*fae548d3Szrj
7604*fae548d3Szrj /* Look through all output sections looking for places where we can
7605*fae548d3Szrj propagate forward the lma region. */
7606*fae548d3Szrj
7607*fae548d3Szrj static void
lang_propagate_lma_regions(void)7608*fae548d3Szrj lang_propagate_lma_regions (void)
7609*fae548d3Szrj {
7610*fae548d3Szrj lang_output_section_statement_type *os;
7611*fae548d3Szrj
7612*fae548d3Szrj for (os = (void *) lang_os_list.head;
7613*fae548d3Szrj os != NULL;
7614*fae548d3Szrj os = os->next)
7615*fae548d3Szrj {
7616*fae548d3Szrj if (os->prev != NULL
7617*fae548d3Szrj && os->lma_region == NULL
7618*fae548d3Szrj && os->load_base == NULL
7619*fae548d3Szrj && os->addr_tree == NULL
7620*fae548d3Szrj && os->region == os->prev->region)
7621*fae548d3Szrj os->lma_region = os->prev->lma_region;
7622*fae548d3Szrj }
7623*fae548d3Szrj }
7624*fae548d3Szrj
7625*fae548d3Szrj void
lang_process(void)7626*fae548d3Szrj lang_process (void)
7627*fae548d3Szrj {
7628*fae548d3Szrj /* Finalize dynamic list. */
7629*fae548d3Szrj if (link_info.dynamic_list)
7630*fae548d3Szrj lang_finalize_version_expr_head (&link_info.dynamic_list->head);
7631*fae548d3Szrj
7632*fae548d3Szrj current_target = default_target;
7633*fae548d3Szrj
7634*fae548d3Szrj /* Open the output file. */
7635*fae548d3Szrj lang_for_each_statement (ldlang_open_output);
7636*fae548d3Szrj init_opb (NULL);
7637*fae548d3Szrj
7638*fae548d3Szrj ldemul_create_output_section_statements ();
7639*fae548d3Szrj
7640*fae548d3Szrj /* Add to the hash table all undefineds on the command line. */
7641*fae548d3Szrj lang_place_undefineds ();
7642*fae548d3Szrj
7643*fae548d3Szrj if (!bfd_section_already_linked_table_init ())
7644*fae548d3Szrj einfo (_("%F%P: can not create hash table: %E\n"));
7645*fae548d3Szrj
7646*fae548d3Szrj /* Create a bfd for each input file. */
7647*fae548d3Szrj current_target = default_target;
7648*fae548d3Szrj lang_statement_iteration++;
7649*fae548d3Szrj open_input_bfds (statement_list.head, OPEN_BFD_NORMAL);
7650*fae548d3Szrj /* open_input_bfds also handles assignments, so we can give values
7651*fae548d3Szrj to symbolic origin/length now. */
7652*fae548d3Szrj lang_do_memory_regions ();
7653*fae548d3Szrj
7654*fae548d3Szrj #ifdef ENABLE_PLUGINS
7655*fae548d3Szrj if (link_info.lto_plugin_active)
7656*fae548d3Szrj {
7657*fae548d3Szrj lang_statement_list_type added;
7658*fae548d3Szrj lang_statement_list_type files, inputfiles;
7659*fae548d3Szrj
7660*fae548d3Szrj /* Now all files are read, let the plugin(s) decide if there
7661*fae548d3Szrj are any more to be added to the link before we call the
7662*fae548d3Szrj emulation's after_open hook. We create a private list of
7663*fae548d3Szrj input statements for this purpose, which we will eventually
7664*fae548d3Szrj insert into the global statement list after the first claimed
7665*fae548d3Szrj file. */
7666*fae548d3Szrj added = *stat_ptr;
7667*fae548d3Szrj /* We need to manipulate all three chains in synchrony. */
7668*fae548d3Szrj files = file_chain;
7669*fae548d3Szrj inputfiles = input_file_chain;
7670*fae548d3Szrj if (plugin_call_all_symbols_read ())
7671*fae548d3Szrj einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7672*fae548d3Szrj plugin_error_plugin ());
7673*fae548d3Szrj /* Open any newly added files, updating the file chains. */
7674*fae548d3Szrj plugin_undefs = link_info.hash->undefs_tail;
7675*fae548d3Szrj open_input_bfds (*added.tail, OPEN_BFD_NORMAL);
7676*fae548d3Szrj if (plugin_undefs == link_info.hash->undefs_tail)
7677*fae548d3Szrj plugin_undefs = NULL;
7678*fae548d3Szrj /* Restore the global list pointer now they have all been added. */
7679*fae548d3Szrj lang_list_remove_tail (stat_ptr, &added);
7680*fae548d3Szrj /* And detach the fresh ends of the file lists. */
7681*fae548d3Szrj lang_list_remove_tail (&file_chain, &files);
7682*fae548d3Szrj lang_list_remove_tail (&input_file_chain, &inputfiles);
7683*fae548d3Szrj /* Were any new files added? */
7684*fae548d3Szrj if (added.head != NULL)
7685*fae548d3Szrj {
7686*fae548d3Szrj /* If so, we will insert them into the statement list immediately
7687*fae548d3Szrj after the first input file that was claimed by the plugin,
7688*fae548d3Szrj unless that file was an archive in which case it is inserted
7689*fae548d3Szrj immediately before. */
7690*fae548d3Szrj bfd_boolean before;
7691*fae548d3Szrj lang_statement_union_type **prev;
7692*fae548d3Szrj plugin_insert = find_replacements_insert_point (&before);
7693*fae548d3Szrj /* If a plugin adds input files without having claimed any, we
7694*fae548d3Szrj don't really have a good idea where to place them. Just putting
7695*fae548d3Szrj them at the start or end of the list is liable to leave them
7696*fae548d3Szrj outside the crtbegin...crtend range. */
7697*fae548d3Szrj ASSERT (plugin_insert != NULL);
7698*fae548d3Szrj /* Splice the new statement list into the old one. */
7699*fae548d3Szrj prev = &plugin_insert->header.next;
7700*fae548d3Szrj if (before)
7701*fae548d3Szrj {
7702*fae548d3Szrj prev = find_next_input_statement (prev);
7703*fae548d3Szrj if (*prev != (void *) plugin_insert->next_real_file)
7704*fae548d3Szrj {
7705*fae548d3Szrj /* We didn't find the expected input statement.
7706*fae548d3Szrj Fall back to adding after plugin_insert. */
7707*fae548d3Szrj prev = &plugin_insert->header.next;
7708*fae548d3Szrj }
7709*fae548d3Szrj }
7710*fae548d3Szrj lang_list_insert_after (stat_ptr, &added, prev);
7711*fae548d3Szrj /* Likewise for the file chains. */
7712*fae548d3Szrj lang_list_insert_after (&input_file_chain, &inputfiles,
7713*fae548d3Szrj (void *) &plugin_insert->next_real_file);
7714*fae548d3Szrj /* We must be careful when relinking file_chain; we may need to
7715*fae548d3Szrj insert the new files at the head of the list if the insert
7716*fae548d3Szrj point chosen is the dummy first input file. */
7717*fae548d3Szrj if (plugin_insert->filename)
7718*fae548d3Szrj lang_list_insert_after (&file_chain, &files,
7719*fae548d3Szrj (void *) &plugin_insert->next);
7720*fae548d3Szrj else
7721*fae548d3Szrj lang_list_insert_after (&file_chain, &files, &file_chain.head);
7722*fae548d3Szrj
7723*fae548d3Szrj /* Rescan archives in case new undefined symbols have appeared. */
7724*fae548d3Szrj files = file_chain;
7725*fae548d3Szrj lang_statement_iteration++;
7726*fae548d3Szrj open_input_bfds (statement_list.head, OPEN_BFD_RESCAN);
7727*fae548d3Szrj lang_list_remove_tail (&file_chain, &files);
7728*fae548d3Szrj while (files.head != NULL)
7729*fae548d3Szrj {
7730*fae548d3Szrj lang_input_statement_type **insert;
7731*fae548d3Szrj lang_input_statement_type **iter, *temp;
7732*fae548d3Szrj bfd *my_arch;
7733*fae548d3Szrj
7734*fae548d3Szrj insert = find_rescan_insertion (&files.head->input_statement);
7735*fae548d3Szrj /* All elements from an archive can be added at once. */
7736*fae548d3Szrj iter = &files.head->input_statement.next;
7737*fae548d3Szrj my_arch = files.head->input_statement.the_bfd->my_archive;
7738*fae548d3Szrj if (my_arch != NULL)
7739*fae548d3Szrj for (; *iter != NULL; iter = &(*iter)->next)
7740*fae548d3Szrj if ((*iter)->the_bfd->my_archive != my_arch)
7741*fae548d3Szrj break;
7742*fae548d3Szrj temp = *insert;
7743*fae548d3Szrj *insert = &files.head->input_statement;
7744*fae548d3Szrj files.head = (lang_statement_union_type *) *iter;
7745*fae548d3Szrj *iter = temp;
7746*fae548d3Szrj if (my_arch != NULL)
7747*fae548d3Szrj {
7748*fae548d3Szrj lang_input_statement_type *parent = bfd_usrdata (my_arch);
7749*fae548d3Szrj if (parent != NULL)
7750*fae548d3Szrj parent->next = (lang_input_statement_type *)
7751*fae548d3Szrj ((char *) iter
7752*fae548d3Szrj - offsetof (lang_input_statement_type, next));
7753*fae548d3Szrj }
7754*fae548d3Szrj }
7755*fae548d3Szrj }
7756*fae548d3Szrj }
7757*fae548d3Szrj #endif /* ENABLE_PLUGINS */
7758*fae548d3Szrj
7759*fae548d3Szrj /* Make sure that nobody has tried to add a symbol to this list
7760*fae548d3Szrj before now. */
7761*fae548d3Szrj ASSERT (link_info.gc_sym_list == NULL);
7762*fae548d3Szrj
7763*fae548d3Szrj link_info.gc_sym_list = &entry_symbol;
7764*fae548d3Szrj
7765*fae548d3Szrj if (entry_symbol.name == NULL)
7766*fae548d3Szrj {
7767*fae548d3Szrj link_info.gc_sym_list = ldlang_undef_chain_list_head;
7768*fae548d3Szrj
7769*fae548d3Szrj /* entry_symbol is normally initialied by a ENTRY definition in the
7770*fae548d3Szrj linker script or the -e command line option. But if neither of
7771*fae548d3Szrj these have been used, the target specific backend may still have
7772*fae548d3Szrj provided an entry symbol via a call to lang_default_entry().
7773*fae548d3Szrj Unfortunately this value will not be processed until lang_end()
7774*fae548d3Szrj is called, long after this function has finished. So detect this
7775*fae548d3Szrj case here and add the target's entry symbol to the list of starting
7776*fae548d3Szrj points for garbage collection resolution. */
7777*fae548d3Szrj lang_add_gc_name (entry_symbol_default);
7778*fae548d3Szrj }
7779*fae548d3Szrj
7780*fae548d3Szrj lang_add_gc_name (link_info.init_function);
7781*fae548d3Szrj lang_add_gc_name (link_info.fini_function);
7782*fae548d3Szrj
7783*fae548d3Szrj ldemul_after_open ();
7784*fae548d3Szrj if (config.map_file != NULL)
7785*fae548d3Szrj lang_print_asneeded ();
7786*fae548d3Szrj
7787*fae548d3Szrj ldlang_open_ctf ();
7788*fae548d3Szrj
7789*fae548d3Szrj bfd_section_already_linked_table_free ();
7790*fae548d3Szrj
7791*fae548d3Szrj /* Make sure that we're not mixing architectures. We call this
7792*fae548d3Szrj after all the input files have been opened, but before we do any
7793*fae548d3Szrj other processing, so that any operations merge_private_bfd_data
7794*fae548d3Szrj does on the output file will be known during the rest of the
7795*fae548d3Szrj link. */
7796*fae548d3Szrj lang_check ();
7797*fae548d3Szrj
7798*fae548d3Szrj /* Handle .exports instead of a version script if we're told to do so. */
7799*fae548d3Szrj if (command_line.version_exports_section)
7800*fae548d3Szrj lang_do_version_exports_section ();
7801*fae548d3Szrj
7802*fae548d3Szrj /* Build all sets based on the information gathered from the input
7803*fae548d3Szrj files. */
7804*fae548d3Szrj ldctor_build_sets ();
7805*fae548d3Szrj
7806*fae548d3Szrj /* Give initial values for __start and __stop symbols, so that ELF
7807*fae548d3Szrj gc_sections will keep sections referenced by these symbols. Must
7808*fae548d3Szrj be done before lang_do_assignments below. */
7809*fae548d3Szrj if (config.build_constructors)
7810*fae548d3Szrj lang_init_start_stop ();
7811*fae548d3Szrj
7812*fae548d3Szrj /* PR 13683: We must rerun the assignments prior to running garbage
7813*fae548d3Szrj collection in order to make sure that all symbol aliases are resolved. */
7814*fae548d3Szrj lang_do_assignments (lang_mark_phase_enum);
7815*fae548d3Szrj expld.phase = lang_first_phase_enum;
7816*fae548d3Szrj
7817*fae548d3Szrj /* Size up the common data. */
7818*fae548d3Szrj lang_common ();
7819*fae548d3Szrj
7820*fae548d3Szrj /* Remove unreferenced sections if asked to. */
7821*fae548d3Szrj lang_gc_sections ();
7822*fae548d3Szrj
7823*fae548d3Szrj /* Check relocations. */
7824*fae548d3Szrj lang_check_relocs ();
7825*fae548d3Szrj
7826*fae548d3Szrj ldemul_after_check_relocs ();
7827*fae548d3Szrj
7828*fae548d3Szrj /* Update wild statements. */
7829*fae548d3Szrj update_wild_statements (statement_list.head);
7830*fae548d3Szrj
7831*fae548d3Szrj /* Run through the contours of the script and attach input sections
7832*fae548d3Szrj to the correct output sections. */
7833*fae548d3Szrj lang_statement_iteration++;
7834*fae548d3Szrj map_input_to_output_sections (statement_list.head, NULL, NULL);
7835*fae548d3Szrj
7836*fae548d3Szrj /* Start at the statement immediately after the special abs_section
7837*fae548d3Szrj output statement, so that it isn't reordered. */
7838*fae548d3Szrj process_insert_statements (&lang_os_list.head->header.next);
7839*fae548d3Szrj
7840*fae548d3Szrj /* Find any sections not attached explicitly and handle them. */
7841*fae548d3Szrj lang_place_orphans ();
7842*fae548d3Szrj
7843*fae548d3Szrj if (!bfd_link_relocatable (&link_info))
7844*fae548d3Szrj {
7845*fae548d3Szrj asection *found;
7846*fae548d3Szrj
7847*fae548d3Szrj /* Merge SEC_MERGE sections. This has to be done after GC of
7848*fae548d3Szrj sections, so that GCed sections are not merged, but before
7849*fae548d3Szrj assigning dynamic symbols, since removing whole input sections
7850*fae548d3Szrj is hard then. */
7851*fae548d3Szrj bfd_merge_sections (link_info.output_bfd, &link_info);
7852*fae548d3Szrj
7853*fae548d3Szrj /* Look for a text section and set the readonly attribute in it. */
7854*fae548d3Szrj found = bfd_get_section_by_name (link_info.output_bfd, ".text");
7855*fae548d3Szrj
7856*fae548d3Szrj if (found != NULL)
7857*fae548d3Szrj {
7858*fae548d3Szrj if (config.text_read_only)
7859*fae548d3Szrj found->flags |= SEC_READONLY;
7860*fae548d3Szrj else
7861*fae548d3Szrj found->flags &= ~SEC_READONLY;
7862*fae548d3Szrj }
7863*fae548d3Szrj }
7864*fae548d3Szrj
7865*fae548d3Szrj /* Merge together CTF sections. After this, only the symtab-dependent
7866*fae548d3Szrj function and data object sections need adjustment. */
7867*fae548d3Szrj lang_merge_ctf ();
7868*fae548d3Szrj
7869*fae548d3Szrj /* Emit the CTF, iff the emulation doesn't need to do late emission after
7870*fae548d3Szrj examining things laid out late, like the strtab. */
7871*fae548d3Szrj lang_write_ctf (0);
7872*fae548d3Szrj
7873*fae548d3Szrj /* Copy forward lma regions for output sections in same lma region. */
7874*fae548d3Szrj lang_propagate_lma_regions ();
7875*fae548d3Szrj
7876*fae548d3Szrj /* Defining __start/__stop symbols early for --gc-sections to work
7877*fae548d3Szrj around a glibc build problem can result in these symbols being
7878*fae548d3Szrj defined when they should not be. Fix them now. */
7879*fae548d3Szrj if (config.build_constructors)
7880*fae548d3Szrj lang_undef_start_stop ();
7881*fae548d3Szrj
7882*fae548d3Szrj /* Define .startof./.sizeof. symbols with preliminary values before
7883*fae548d3Szrj dynamic symbols are created. */
7884*fae548d3Szrj if (!bfd_link_relocatable (&link_info))
7885*fae548d3Szrj lang_init_startof_sizeof ();
7886*fae548d3Szrj
7887*fae548d3Szrj /* Do anything special before sizing sections. This is where ELF
7888*fae548d3Szrj and other back-ends size dynamic sections. */
7889*fae548d3Szrj ldemul_before_allocation ();
7890*fae548d3Szrj
7891*fae548d3Szrj /* We must record the program headers before we try to fix the
7892*fae548d3Szrj section positions, since they will affect SIZEOF_HEADERS. */
7893*fae548d3Szrj lang_record_phdrs ();
7894*fae548d3Szrj
7895*fae548d3Szrj /* Check relro sections. */
7896*fae548d3Szrj if (link_info.relro && !bfd_link_relocatable (&link_info))
7897*fae548d3Szrj lang_find_relro_sections ();
7898*fae548d3Szrj
7899*fae548d3Szrj /* Size up the sections. */
7900*fae548d3Szrj lang_size_sections (NULL, !RELAXATION_ENABLED);
7901*fae548d3Szrj
7902*fae548d3Szrj /* See if anything special should be done now we know how big
7903*fae548d3Szrj everything is. This is where relaxation is done. */
7904*fae548d3Szrj ldemul_after_allocation ();
7905*fae548d3Szrj
7906*fae548d3Szrj /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7907*fae548d3Szrj lang_finalize_start_stop ();
7908*fae548d3Szrj
7909*fae548d3Szrj /* Do all the assignments again, to report errors. Assignment
7910*fae548d3Szrj statements are processed multiple times, updating symbols; In
7911*fae548d3Szrj open_input_bfds, lang_do_assignments, and lang_size_sections.
7912*fae548d3Szrj Since lang_relax_sections calls lang_do_assignments, symbols are
7913*fae548d3Szrj also updated in ldemul_after_allocation. */
7914*fae548d3Szrj lang_do_assignments (lang_final_phase_enum);
7915*fae548d3Szrj
7916*fae548d3Szrj ldemul_finish ();
7917*fae548d3Szrj
7918*fae548d3Szrj /* Convert absolute symbols to section relative. */
7919*fae548d3Szrj ldexp_finalize_syms ();
7920*fae548d3Szrj
7921*fae548d3Szrj /* Make sure that the section addresses make sense. */
7922*fae548d3Szrj if (command_line.check_section_addresses)
7923*fae548d3Szrj lang_check_section_addresses ();
7924*fae548d3Szrj
7925*fae548d3Szrj /* Check any required symbols are known. */
7926*fae548d3Szrj ldlang_check_require_defined_symbols ();
7927*fae548d3Szrj
7928*fae548d3Szrj lang_end ();
7929*fae548d3Szrj }
7930*fae548d3Szrj
7931*fae548d3Szrj /* EXPORTED TO YACC */
7932*fae548d3Szrj
7933*fae548d3Szrj void
lang_add_wild(struct wildcard_spec * filespec,struct wildcard_list * section_list,bfd_boolean keep_sections)7934*fae548d3Szrj lang_add_wild (struct wildcard_spec *filespec,
7935*fae548d3Szrj struct wildcard_list *section_list,
7936*fae548d3Szrj bfd_boolean keep_sections)
7937*fae548d3Szrj {
7938*fae548d3Szrj struct wildcard_list *curr, *next;
7939*fae548d3Szrj lang_wild_statement_type *new_stmt;
7940*fae548d3Szrj
7941*fae548d3Szrj /* Reverse the list as the parser puts it back to front. */
7942*fae548d3Szrj for (curr = section_list, section_list = NULL;
7943*fae548d3Szrj curr != NULL;
7944*fae548d3Szrj section_list = curr, curr = next)
7945*fae548d3Szrj {
7946*fae548d3Szrj next = curr->next;
7947*fae548d3Szrj curr->next = section_list;
7948*fae548d3Szrj }
7949*fae548d3Szrj
7950*fae548d3Szrj if (filespec != NULL && filespec->name != NULL)
7951*fae548d3Szrj {
7952*fae548d3Szrj if (strcmp (filespec->name, "*") == 0)
7953*fae548d3Szrj filespec->name = NULL;
7954*fae548d3Szrj else if (!wildcardp (filespec->name))
7955*fae548d3Szrj lang_has_input_file = TRUE;
7956*fae548d3Szrj }
7957*fae548d3Szrj
7958*fae548d3Szrj new_stmt = new_stat (lang_wild_statement, stat_ptr);
7959*fae548d3Szrj new_stmt->filename = NULL;
7960*fae548d3Szrj new_stmt->filenames_sorted = FALSE;
7961*fae548d3Szrj new_stmt->section_flag_list = NULL;
7962*fae548d3Szrj new_stmt->exclude_name_list = NULL;
7963*fae548d3Szrj if (filespec != NULL)
7964*fae548d3Szrj {
7965*fae548d3Szrj new_stmt->filename = filespec->name;
7966*fae548d3Szrj new_stmt->filenames_sorted = filespec->sorted == by_name;
7967*fae548d3Szrj new_stmt->section_flag_list = filespec->section_flag_list;
7968*fae548d3Szrj new_stmt->exclude_name_list = filespec->exclude_name_list;
7969*fae548d3Szrj }
7970*fae548d3Szrj new_stmt->section_list = section_list;
7971*fae548d3Szrj new_stmt->keep_sections = keep_sections;
7972*fae548d3Szrj lang_list_init (&new_stmt->children);
7973*fae548d3Szrj analyze_walk_wild_section_handler (new_stmt);
7974*fae548d3Szrj }
7975*fae548d3Szrj
7976*fae548d3Szrj void
lang_section_start(const char * name,etree_type * address,const segment_type * segment)7977*fae548d3Szrj lang_section_start (const char *name, etree_type *address,
7978*fae548d3Szrj const segment_type *segment)
7979*fae548d3Szrj {
7980*fae548d3Szrj lang_address_statement_type *ad;
7981*fae548d3Szrj
7982*fae548d3Szrj ad = new_stat (lang_address_statement, stat_ptr);
7983*fae548d3Szrj ad->section_name = name;
7984*fae548d3Szrj ad->address = address;
7985*fae548d3Szrj ad->segment = segment;
7986*fae548d3Szrj }
7987*fae548d3Szrj
7988*fae548d3Szrj /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7989*fae548d3Szrj because of a -e argument on the command line, or zero if this is
7990*fae548d3Szrj called by ENTRY in a linker script. Command line arguments take
7991*fae548d3Szrj precedence. */
7992*fae548d3Szrj
7993*fae548d3Szrj void
lang_add_entry(const char * name,bfd_boolean cmdline)7994*fae548d3Szrj lang_add_entry (const char *name, bfd_boolean cmdline)
7995*fae548d3Szrj {
7996*fae548d3Szrj if (entry_symbol.name == NULL
7997*fae548d3Szrj || cmdline
7998*fae548d3Szrj || !entry_from_cmdline)
7999*fae548d3Szrj {
8000*fae548d3Szrj entry_symbol.name = name;
8001*fae548d3Szrj entry_from_cmdline = cmdline;
8002*fae548d3Szrj }
8003*fae548d3Szrj }
8004*fae548d3Szrj
8005*fae548d3Szrj /* Set the default start symbol to NAME. .em files should use this,
8006*fae548d3Szrj not lang_add_entry, to override the use of "start" if neither the
8007*fae548d3Szrj linker script nor the command line specifies an entry point. NAME
8008*fae548d3Szrj must be permanently allocated. */
8009*fae548d3Szrj void
lang_default_entry(const char * name)8010*fae548d3Szrj lang_default_entry (const char *name)
8011*fae548d3Szrj {
8012*fae548d3Szrj entry_symbol_default = name;
8013*fae548d3Szrj }
8014*fae548d3Szrj
8015*fae548d3Szrj void
lang_add_target(const char * name)8016*fae548d3Szrj lang_add_target (const char *name)
8017*fae548d3Szrj {
8018*fae548d3Szrj lang_target_statement_type *new_stmt;
8019*fae548d3Szrj
8020*fae548d3Szrj new_stmt = new_stat (lang_target_statement, stat_ptr);
8021*fae548d3Szrj new_stmt->target = name;
8022*fae548d3Szrj }
8023*fae548d3Szrj
8024*fae548d3Szrj void
lang_add_map(const char * name)8025*fae548d3Szrj lang_add_map (const char *name)
8026*fae548d3Szrj {
8027*fae548d3Szrj while (*name)
8028*fae548d3Szrj {
8029*fae548d3Szrj switch (*name)
8030*fae548d3Szrj {
8031*fae548d3Szrj case 'F':
8032*fae548d3Szrj map_option_f = TRUE;
8033*fae548d3Szrj break;
8034*fae548d3Szrj }
8035*fae548d3Szrj name++;
8036*fae548d3Szrj }
8037*fae548d3Szrj }
8038*fae548d3Szrj
8039*fae548d3Szrj void
lang_add_fill(fill_type * fill)8040*fae548d3Szrj lang_add_fill (fill_type *fill)
8041*fae548d3Szrj {
8042*fae548d3Szrj lang_fill_statement_type *new_stmt;
8043*fae548d3Szrj
8044*fae548d3Szrj new_stmt = new_stat (lang_fill_statement, stat_ptr);
8045*fae548d3Szrj new_stmt->fill = fill;
8046*fae548d3Szrj }
8047*fae548d3Szrj
8048*fae548d3Szrj void
lang_add_data(int type,union etree_union * exp)8049*fae548d3Szrj lang_add_data (int type, union etree_union *exp)
8050*fae548d3Szrj {
8051*fae548d3Szrj lang_data_statement_type *new_stmt;
8052*fae548d3Szrj
8053*fae548d3Szrj new_stmt = new_stat (lang_data_statement, stat_ptr);
8054*fae548d3Szrj new_stmt->exp = exp;
8055*fae548d3Szrj new_stmt->type = type;
8056*fae548d3Szrj }
8057*fae548d3Szrj
8058*fae548d3Szrj /* Create a new reloc statement. RELOC is the BFD relocation type to
8059*fae548d3Szrj generate. HOWTO is the corresponding howto structure (we could
8060*fae548d3Szrj look this up, but the caller has already done so). SECTION is the
8061*fae548d3Szrj section to generate a reloc against, or NAME is the name of the
8062*fae548d3Szrj symbol to generate a reloc against. Exactly one of SECTION and
8063*fae548d3Szrj NAME must be NULL. ADDEND is an expression for the addend. */
8064*fae548d3Szrj
8065*fae548d3Szrj void
lang_add_reloc(bfd_reloc_code_real_type reloc,reloc_howto_type * howto,asection * section,const char * name,union etree_union * addend)8066*fae548d3Szrj lang_add_reloc (bfd_reloc_code_real_type reloc,
8067*fae548d3Szrj reloc_howto_type *howto,
8068*fae548d3Szrj asection *section,
8069*fae548d3Szrj const char *name,
8070*fae548d3Szrj union etree_union *addend)
8071*fae548d3Szrj {
8072*fae548d3Szrj lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
8073*fae548d3Szrj
8074*fae548d3Szrj p->reloc = reloc;
8075*fae548d3Szrj p->howto = howto;
8076*fae548d3Szrj p->section = section;
8077*fae548d3Szrj p->name = name;
8078*fae548d3Szrj p->addend_exp = addend;
8079*fae548d3Szrj
8080*fae548d3Szrj p->addend_value = 0;
8081*fae548d3Szrj p->output_section = NULL;
8082*fae548d3Szrj p->output_offset = 0;
8083*fae548d3Szrj }
8084*fae548d3Szrj
8085*fae548d3Szrj lang_assignment_statement_type *
lang_add_assignment(etree_type * exp)8086*fae548d3Szrj lang_add_assignment (etree_type *exp)
8087*fae548d3Szrj {
8088*fae548d3Szrj lang_assignment_statement_type *new_stmt;
8089*fae548d3Szrj
8090*fae548d3Szrj new_stmt = new_stat (lang_assignment_statement, stat_ptr);
8091*fae548d3Szrj new_stmt->exp = exp;
8092*fae548d3Szrj return new_stmt;
8093*fae548d3Szrj }
8094*fae548d3Szrj
8095*fae548d3Szrj void
lang_add_attribute(enum statement_enum attribute)8096*fae548d3Szrj lang_add_attribute (enum statement_enum attribute)
8097*fae548d3Szrj {
8098*fae548d3Szrj new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
8099*fae548d3Szrj }
8100*fae548d3Szrj
8101*fae548d3Szrj void
lang_startup(const char * name)8102*fae548d3Szrj lang_startup (const char *name)
8103*fae548d3Szrj {
8104*fae548d3Szrj if (first_file->filename != NULL)
8105*fae548d3Szrj {
8106*fae548d3Szrj einfo (_("%F%P: multiple STARTUP files\n"));
8107*fae548d3Szrj }
8108*fae548d3Szrj first_file->filename = name;
8109*fae548d3Szrj first_file->local_sym_name = name;
8110*fae548d3Szrj first_file->flags.real = TRUE;
8111*fae548d3Szrj }
8112*fae548d3Szrj
8113*fae548d3Szrj void
lang_float(bfd_boolean maybe)8114*fae548d3Szrj lang_float (bfd_boolean maybe)
8115*fae548d3Szrj {
8116*fae548d3Szrj lang_float_flag = maybe;
8117*fae548d3Szrj }
8118*fae548d3Szrj
8119*fae548d3Szrj
8120*fae548d3Szrj /* Work out the load- and run-time regions from a script statement, and
8121*fae548d3Szrj store them in *LMA_REGION and *REGION respectively.
8122*fae548d3Szrj
8123*fae548d3Szrj MEMSPEC is the name of the run-time region, or the value of
8124*fae548d3Szrj DEFAULT_MEMORY_REGION if the statement didn't specify one.
8125*fae548d3Szrj LMA_MEMSPEC is the name of the load-time region, or null if the
8126*fae548d3Szrj statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8127*fae548d3Szrj had an explicit load address.
8128*fae548d3Szrj
8129*fae548d3Szrj It is an error to specify both a load region and a load address. */
8130*fae548d3Szrj
8131*fae548d3Szrj static void
lang_get_regions(lang_memory_region_type ** region,lang_memory_region_type ** lma_region,const char * memspec,const char * lma_memspec,bfd_boolean have_lma,bfd_boolean have_vma)8132*fae548d3Szrj lang_get_regions (lang_memory_region_type **region,
8133*fae548d3Szrj lang_memory_region_type **lma_region,
8134*fae548d3Szrj const char *memspec,
8135*fae548d3Szrj const char *lma_memspec,
8136*fae548d3Szrj bfd_boolean have_lma,
8137*fae548d3Szrj bfd_boolean have_vma)
8138*fae548d3Szrj {
8139*fae548d3Szrj *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
8140*fae548d3Szrj
8141*fae548d3Szrj /* If no runtime region or VMA has been specified, but the load region
8142*fae548d3Szrj has been specified, then use the load region for the runtime region
8143*fae548d3Szrj as well. */
8144*fae548d3Szrj if (lma_memspec != NULL
8145*fae548d3Szrj && !have_vma
8146*fae548d3Szrj && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
8147*fae548d3Szrj *region = *lma_region;
8148*fae548d3Szrj else
8149*fae548d3Szrj *region = lang_memory_region_lookup (memspec, FALSE);
8150*fae548d3Szrj
8151*fae548d3Szrj if (have_lma && lma_memspec != 0)
8152*fae548d3Szrj einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8153*fae548d3Szrj NULL);
8154*fae548d3Szrj }
8155*fae548d3Szrj
8156*fae548d3Szrj void
lang_leave_output_section_statement(fill_type * fill,const char * memspec,lang_output_section_phdr_list * phdrs,const char * lma_memspec)8157*fae548d3Szrj lang_leave_output_section_statement (fill_type *fill, const char *memspec,
8158*fae548d3Szrj lang_output_section_phdr_list *phdrs,
8159*fae548d3Szrj const char *lma_memspec)
8160*fae548d3Szrj {
8161*fae548d3Szrj lang_get_regions (¤t_section->region,
8162*fae548d3Szrj ¤t_section->lma_region,
8163*fae548d3Szrj memspec, lma_memspec,
8164*fae548d3Szrj current_section->load_base != NULL,
8165*fae548d3Szrj current_section->addr_tree != NULL);
8166*fae548d3Szrj
8167*fae548d3Szrj current_section->fill = fill;
8168*fae548d3Szrj current_section->phdrs = phdrs;
8169*fae548d3Szrj pop_stat_ptr ();
8170*fae548d3Szrj }
8171*fae548d3Szrj
8172*fae548d3Szrj /* Set the output format type. -oformat overrides scripts. */
8173*fae548d3Szrj
8174*fae548d3Szrj void
lang_add_output_format(const char * format,const char * big,const char * little,int from_script)8175*fae548d3Szrj lang_add_output_format (const char *format,
8176*fae548d3Szrj const char *big,
8177*fae548d3Szrj const char *little,
8178*fae548d3Szrj int from_script)
8179*fae548d3Szrj {
8180*fae548d3Szrj if (output_target == NULL || !from_script)
8181*fae548d3Szrj {
8182*fae548d3Szrj if (command_line.endian == ENDIAN_BIG
8183*fae548d3Szrj && big != NULL)
8184*fae548d3Szrj format = big;
8185*fae548d3Szrj else if (command_line.endian == ENDIAN_LITTLE
8186*fae548d3Szrj && little != NULL)
8187*fae548d3Szrj format = little;
8188*fae548d3Szrj
8189*fae548d3Szrj output_target = format;
8190*fae548d3Szrj }
8191*fae548d3Szrj }
8192*fae548d3Szrj
8193*fae548d3Szrj void
lang_add_insert(const char * where,int is_before)8194*fae548d3Szrj lang_add_insert (const char *where, int is_before)
8195*fae548d3Szrj {
8196*fae548d3Szrj lang_insert_statement_type *new_stmt;
8197*fae548d3Szrj
8198*fae548d3Szrj new_stmt = new_stat (lang_insert_statement, stat_ptr);
8199*fae548d3Szrj new_stmt->where = where;
8200*fae548d3Szrj new_stmt->is_before = is_before;
8201*fae548d3Szrj saved_script_handle = previous_script_handle;
8202*fae548d3Szrj }
8203*fae548d3Szrj
8204*fae548d3Szrj /* Enter a group. This creates a new lang_group_statement, and sets
8205*fae548d3Szrj stat_ptr to build new statements within the group. */
8206*fae548d3Szrj
8207*fae548d3Szrj void
lang_enter_group(void)8208*fae548d3Szrj lang_enter_group (void)
8209*fae548d3Szrj {
8210*fae548d3Szrj lang_group_statement_type *g;
8211*fae548d3Szrj
8212*fae548d3Szrj g = new_stat (lang_group_statement, stat_ptr);
8213*fae548d3Szrj lang_list_init (&g->children);
8214*fae548d3Szrj push_stat_ptr (&g->children);
8215*fae548d3Szrj }
8216*fae548d3Szrj
8217*fae548d3Szrj /* Leave a group. This just resets stat_ptr to start writing to the
8218*fae548d3Szrj regular list of statements again. Note that this will not work if
8219*fae548d3Szrj groups can occur inside anything else which can adjust stat_ptr,
8220*fae548d3Szrj but currently they can't. */
8221*fae548d3Szrj
8222*fae548d3Szrj void
lang_leave_group(void)8223*fae548d3Szrj lang_leave_group (void)
8224*fae548d3Szrj {
8225*fae548d3Szrj pop_stat_ptr ();
8226*fae548d3Szrj }
8227*fae548d3Szrj
8228*fae548d3Szrj /* Add a new program header. This is called for each entry in a PHDRS
8229*fae548d3Szrj command in a linker script. */
8230*fae548d3Szrj
8231*fae548d3Szrj void
lang_new_phdr(const char * name,etree_type * type,bfd_boolean filehdr,bfd_boolean phdrs,etree_type * at,etree_type * flags)8232*fae548d3Szrj lang_new_phdr (const char *name,
8233*fae548d3Szrj etree_type *type,
8234*fae548d3Szrj bfd_boolean filehdr,
8235*fae548d3Szrj bfd_boolean phdrs,
8236*fae548d3Szrj etree_type *at,
8237*fae548d3Szrj etree_type *flags)
8238*fae548d3Szrj {
8239*fae548d3Szrj struct lang_phdr *n, **pp;
8240*fae548d3Szrj bfd_boolean hdrs;
8241*fae548d3Szrj
8242*fae548d3Szrj n = stat_alloc (sizeof (struct lang_phdr));
8243*fae548d3Szrj n->next = NULL;
8244*fae548d3Szrj n->name = name;
8245*fae548d3Szrj n->type = exp_get_vma (type, 0, "program header type");
8246*fae548d3Szrj n->filehdr = filehdr;
8247*fae548d3Szrj n->phdrs = phdrs;
8248*fae548d3Szrj n->at = at;
8249*fae548d3Szrj n->flags = flags;
8250*fae548d3Szrj
8251*fae548d3Szrj hdrs = n->type == 1 && (phdrs || filehdr);
8252*fae548d3Szrj
8253*fae548d3Szrj for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
8254*fae548d3Szrj if (hdrs
8255*fae548d3Szrj && (*pp)->type == 1
8256*fae548d3Szrj && !((*pp)->filehdr || (*pp)->phdrs))
8257*fae548d3Szrj {
8258*fae548d3Szrj einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8259*fae548d3Szrj " when prior PT_LOAD headers lack them\n"), NULL);
8260*fae548d3Szrj hdrs = FALSE;
8261*fae548d3Szrj }
8262*fae548d3Szrj
8263*fae548d3Szrj *pp = n;
8264*fae548d3Szrj }
8265*fae548d3Szrj
8266*fae548d3Szrj /* Record the program header information in the output BFD. FIXME: We
8267*fae548d3Szrj should not be calling an ELF specific function here. */
8268*fae548d3Szrj
8269*fae548d3Szrj static void
lang_record_phdrs(void)8270*fae548d3Szrj lang_record_phdrs (void)
8271*fae548d3Szrj {
8272*fae548d3Szrj unsigned int alc;
8273*fae548d3Szrj asection **secs;
8274*fae548d3Szrj lang_output_section_phdr_list *last;
8275*fae548d3Szrj struct lang_phdr *l;
8276*fae548d3Szrj lang_output_section_statement_type *os;
8277*fae548d3Szrj
8278*fae548d3Szrj alc = 10;
8279*fae548d3Szrj secs = (asection **) xmalloc (alc * sizeof (asection *));
8280*fae548d3Szrj last = NULL;
8281*fae548d3Szrj
8282*fae548d3Szrj for (l = lang_phdr_list; l != NULL; l = l->next)
8283*fae548d3Szrj {
8284*fae548d3Szrj unsigned int c;
8285*fae548d3Szrj flagword flags;
8286*fae548d3Szrj bfd_vma at;
8287*fae548d3Szrj
8288*fae548d3Szrj c = 0;
8289*fae548d3Szrj for (os = (void *) lang_os_list.head;
8290*fae548d3Szrj os != NULL;
8291*fae548d3Szrj os = os->next)
8292*fae548d3Szrj {
8293*fae548d3Szrj lang_output_section_phdr_list *pl;
8294*fae548d3Szrj
8295*fae548d3Szrj if (os->constraint < 0)
8296*fae548d3Szrj continue;
8297*fae548d3Szrj
8298*fae548d3Szrj pl = os->phdrs;
8299*fae548d3Szrj if (pl != NULL)
8300*fae548d3Szrj last = pl;
8301*fae548d3Szrj else
8302*fae548d3Szrj {
8303*fae548d3Szrj if (os->sectype == noload_section
8304*fae548d3Szrj || os->bfd_section == NULL
8305*fae548d3Szrj || (os->bfd_section->flags & SEC_ALLOC) == 0)
8306*fae548d3Szrj continue;
8307*fae548d3Szrj
8308*fae548d3Szrj /* Don't add orphans to PT_INTERP header. */
8309*fae548d3Szrj if (l->type == 3)
8310*fae548d3Szrj continue;
8311*fae548d3Szrj
8312*fae548d3Szrj if (last == NULL)
8313*fae548d3Szrj {
8314*fae548d3Szrj lang_output_section_statement_type *tmp_os;
8315*fae548d3Szrj
8316*fae548d3Szrj /* If we have not run across a section with a program
8317*fae548d3Szrj header assigned to it yet, then scan forwards to find
8318*fae548d3Szrj one. This prevents inconsistencies in the linker's
8319*fae548d3Szrj behaviour when a script has specified just a single
8320*fae548d3Szrj header and there are sections in that script which are
8321*fae548d3Szrj not assigned to it, and which occur before the first
8322*fae548d3Szrj use of that header. See here for more details:
8323*fae548d3Szrj http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8324*fae548d3Szrj for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
8325*fae548d3Szrj if (tmp_os->phdrs)
8326*fae548d3Szrj {
8327*fae548d3Szrj last = tmp_os->phdrs;
8328*fae548d3Szrj break;
8329*fae548d3Szrj }
8330*fae548d3Szrj if (last == NULL)
8331*fae548d3Szrj einfo (_("%F%P: no sections assigned to phdrs\n"));
8332*fae548d3Szrj }
8333*fae548d3Szrj pl = last;
8334*fae548d3Szrj }
8335*fae548d3Szrj
8336*fae548d3Szrj if (os->bfd_section == NULL)
8337*fae548d3Szrj continue;
8338*fae548d3Szrj
8339*fae548d3Szrj for (; pl != NULL; pl = pl->next)
8340*fae548d3Szrj {
8341*fae548d3Szrj if (strcmp (pl->name, l->name) == 0)
8342*fae548d3Szrj {
8343*fae548d3Szrj if (c >= alc)
8344*fae548d3Szrj {
8345*fae548d3Szrj alc *= 2;
8346*fae548d3Szrj secs = (asection **) xrealloc (secs,
8347*fae548d3Szrj alc * sizeof (asection *));
8348*fae548d3Szrj }
8349*fae548d3Szrj secs[c] = os->bfd_section;
8350*fae548d3Szrj ++c;
8351*fae548d3Szrj pl->used = TRUE;
8352*fae548d3Szrj }
8353*fae548d3Szrj }
8354*fae548d3Szrj }
8355*fae548d3Szrj
8356*fae548d3Szrj if (l->flags == NULL)
8357*fae548d3Szrj flags = 0;
8358*fae548d3Szrj else
8359*fae548d3Szrj flags = exp_get_vma (l->flags, 0, "phdr flags");
8360*fae548d3Szrj
8361*fae548d3Szrj if (l->at == NULL)
8362*fae548d3Szrj at = 0;
8363*fae548d3Szrj else
8364*fae548d3Szrj at = exp_get_vma (l->at, 0, "phdr load address");
8365*fae548d3Szrj
8366*fae548d3Szrj if (!bfd_record_phdr (link_info.output_bfd, l->type,
8367*fae548d3Szrj l->flags != NULL, flags, l->at != NULL,
8368*fae548d3Szrj at, l->filehdr, l->phdrs, c, secs))
8369*fae548d3Szrj einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8370*fae548d3Szrj }
8371*fae548d3Szrj
8372*fae548d3Szrj free (secs);
8373*fae548d3Szrj
8374*fae548d3Szrj /* Make sure all the phdr assignments succeeded. */
8375*fae548d3Szrj for (os = (void *) lang_os_list.head;
8376*fae548d3Szrj os != NULL;
8377*fae548d3Szrj os = os->next)
8378*fae548d3Szrj {
8379*fae548d3Szrj lang_output_section_phdr_list *pl;
8380*fae548d3Szrj
8381*fae548d3Szrj if (os->constraint < 0
8382*fae548d3Szrj || os->bfd_section == NULL)
8383*fae548d3Szrj continue;
8384*fae548d3Szrj
8385*fae548d3Szrj for (pl = os->phdrs;
8386*fae548d3Szrj pl != NULL;
8387*fae548d3Szrj pl = pl->next)
8388*fae548d3Szrj if (!pl->used && strcmp (pl->name, "NONE") != 0)
8389*fae548d3Szrj einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8390*fae548d3Szrj os->name, pl->name);
8391*fae548d3Szrj }
8392*fae548d3Szrj }
8393*fae548d3Szrj
8394*fae548d3Szrj /* Record a list of sections which may not be cross referenced. */
8395*fae548d3Szrj
8396*fae548d3Szrj void
lang_add_nocrossref(lang_nocrossref_type * l)8397*fae548d3Szrj lang_add_nocrossref (lang_nocrossref_type *l)
8398*fae548d3Szrj {
8399*fae548d3Szrj struct lang_nocrossrefs *n;
8400*fae548d3Szrj
8401*fae548d3Szrj n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
8402*fae548d3Szrj n->next = nocrossref_list;
8403*fae548d3Szrj n->list = l;
8404*fae548d3Szrj n->onlyfirst = FALSE;
8405*fae548d3Szrj nocrossref_list = n;
8406*fae548d3Szrj
8407*fae548d3Szrj /* Set notice_all so that we get informed about all symbols. */
8408*fae548d3Szrj link_info.notice_all = TRUE;
8409*fae548d3Szrj }
8410*fae548d3Szrj
8411*fae548d3Szrj /* Record a section that cannot be referenced from a list of sections. */
8412*fae548d3Szrj
8413*fae548d3Szrj void
lang_add_nocrossref_to(lang_nocrossref_type * l)8414*fae548d3Szrj lang_add_nocrossref_to (lang_nocrossref_type *l)
8415*fae548d3Szrj {
8416*fae548d3Szrj lang_add_nocrossref (l);
8417*fae548d3Szrj nocrossref_list->onlyfirst = TRUE;
8418*fae548d3Szrj }
8419*fae548d3Szrj
8420*fae548d3Szrj /* Overlay handling. We handle overlays with some static variables. */
8421*fae548d3Szrj
8422*fae548d3Szrj /* The overlay virtual address. */
8423*fae548d3Szrj static etree_type *overlay_vma;
8424*fae548d3Szrj /* And subsection alignment. */
8425*fae548d3Szrj static etree_type *overlay_subalign;
8426*fae548d3Szrj
8427*fae548d3Szrj /* An expression for the maximum section size seen so far. */
8428*fae548d3Szrj static etree_type *overlay_max;
8429*fae548d3Szrj
8430*fae548d3Szrj /* A list of all the sections in this overlay. */
8431*fae548d3Szrj
8432*fae548d3Szrj struct overlay_list {
8433*fae548d3Szrj struct overlay_list *next;
8434*fae548d3Szrj lang_output_section_statement_type *os;
8435*fae548d3Szrj };
8436*fae548d3Szrj
8437*fae548d3Szrj static struct overlay_list *overlay_list;
8438*fae548d3Szrj
8439*fae548d3Szrj /* Start handling an overlay. */
8440*fae548d3Szrj
8441*fae548d3Szrj void
lang_enter_overlay(etree_type * vma_expr,etree_type * subalign)8442*fae548d3Szrj lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
8443*fae548d3Szrj {
8444*fae548d3Szrj /* The grammar should prevent nested overlays from occurring. */
8445*fae548d3Szrj ASSERT (overlay_vma == NULL
8446*fae548d3Szrj && overlay_subalign == NULL
8447*fae548d3Szrj && overlay_max == NULL);
8448*fae548d3Szrj
8449*fae548d3Szrj overlay_vma = vma_expr;
8450*fae548d3Szrj overlay_subalign = subalign;
8451*fae548d3Szrj }
8452*fae548d3Szrj
8453*fae548d3Szrj /* Start a section in an overlay. We handle this by calling
8454*fae548d3Szrj lang_enter_output_section_statement with the correct VMA.
8455*fae548d3Szrj lang_leave_overlay sets up the LMA and memory regions. */
8456*fae548d3Szrj
8457*fae548d3Szrj void
lang_enter_overlay_section(const char * name)8458*fae548d3Szrj lang_enter_overlay_section (const char *name)
8459*fae548d3Szrj {
8460*fae548d3Szrj struct overlay_list *n;
8461*fae548d3Szrj etree_type *size;
8462*fae548d3Szrj
8463*fae548d3Szrj lang_enter_output_section_statement (name, overlay_vma, overlay_section,
8464*fae548d3Szrj 0, overlay_subalign, 0, 0, 0);
8465*fae548d3Szrj
8466*fae548d3Szrj /* If this is the first section, then base the VMA of future
8467*fae548d3Szrj sections on this one. This will work correctly even if `.' is
8468*fae548d3Szrj used in the addresses. */
8469*fae548d3Szrj if (overlay_list == NULL)
8470*fae548d3Szrj overlay_vma = exp_nameop (ADDR, name);
8471*fae548d3Szrj
8472*fae548d3Szrj /* Remember the section. */
8473*fae548d3Szrj n = (struct overlay_list *) xmalloc (sizeof *n);
8474*fae548d3Szrj n->os = current_section;
8475*fae548d3Szrj n->next = overlay_list;
8476*fae548d3Szrj overlay_list = n;
8477*fae548d3Szrj
8478*fae548d3Szrj size = exp_nameop (SIZEOF, name);
8479*fae548d3Szrj
8480*fae548d3Szrj /* Arrange to work out the maximum section end address. */
8481*fae548d3Szrj if (overlay_max == NULL)
8482*fae548d3Szrj overlay_max = size;
8483*fae548d3Szrj else
8484*fae548d3Szrj overlay_max = exp_binop (MAX_K, overlay_max, size);
8485*fae548d3Szrj }
8486*fae548d3Szrj
8487*fae548d3Szrj /* Finish a section in an overlay. There isn't any special to do
8488*fae548d3Szrj here. */
8489*fae548d3Szrj
8490*fae548d3Szrj void
lang_leave_overlay_section(fill_type * fill,lang_output_section_phdr_list * phdrs)8491*fae548d3Szrj lang_leave_overlay_section (fill_type *fill,
8492*fae548d3Szrj lang_output_section_phdr_list *phdrs)
8493*fae548d3Szrj {
8494*fae548d3Szrj const char *name;
8495*fae548d3Szrj char *clean, *s2;
8496*fae548d3Szrj const char *s1;
8497*fae548d3Szrj char *buf;
8498*fae548d3Szrj
8499*fae548d3Szrj name = current_section->name;
8500*fae548d3Szrj
8501*fae548d3Szrj /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8502*fae548d3Szrj region and that no load-time region has been specified. It doesn't
8503*fae548d3Szrj really matter what we say here, since lang_leave_overlay will
8504*fae548d3Szrj override it. */
8505*fae548d3Szrj lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
8506*fae548d3Szrj
8507*fae548d3Szrj /* Define the magic symbols. */
8508*fae548d3Szrj
8509*fae548d3Szrj clean = (char *) xmalloc (strlen (name) + 1);
8510*fae548d3Szrj s2 = clean;
8511*fae548d3Szrj for (s1 = name; *s1 != '\0'; s1++)
8512*fae548d3Szrj if (ISALNUM (*s1) || *s1 == '_')
8513*fae548d3Szrj *s2++ = *s1;
8514*fae548d3Szrj *s2 = '\0';
8515*fae548d3Szrj
8516*fae548d3Szrj buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");
8517*fae548d3Szrj sprintf (buf, "__load_start_%s", clean);
8518*fae548d3Szrj lang_add_assignment (exp_provide (buf,
8519*fae548d3Szrj exp_nameop (LOADADDR, name),
8520*fae548d3Szrj FALSE));
8521*fae548d3Szrj
8522*fae548d3Szrj buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");
8523*fae548d3Szrj sprintf (buf, "__load_stop_%s", clean);
8524*fae548d3Szrj lang_add_assignment (exp_provide (buf,
8525*fae548d3Szrj exp_binop ('+',
8526*fae548d3Szrj exp_nameop (LOADADDR, name),
8527*fae548d3Szrj exp_nameop (SIZEOF, name)),
8528*fae548d3Szrj FALSE));
8529*fae548d3Szrj
8530*fae548d3Szrj free (clean);
8531*fae548d3Szrj }
8532*fae548d3Szrj
8533*fae548d3Szrj /* Finish an overlay. If there are any overlay wide settings, this
8534*fae548d3Szrj looks through all the sections in the overlay and sets them. */
8535*fae548d3Szrj
8536*fae548d3Szrj void
lang_leave_overlay(etree_type * lma_expr,int nocrossrefs,fill_type * fill,const char * memspec,lang_output_section_phdr_list * phdrs,const char * lma_memspec)8537*fae548d3Szrj lang_leave_overlay (etree_type *lma_expr,
8538*fae548d3Szrj int nocrossrefs,
8539*fae548d3Szrj fill_type *fill,
8540*fae548d3Szrj const char *memspec,
8541*fae548d3Szrj lang_output_section_phdr_list *phdrs,
8542*fae548d3Szrj const char *lma_memspec)
8543*fae548d3Szrj {
8544*fae548d3Szrj lang_memory_region_type *region;
8545*fae548d3Szrj lang_memory_region_type *lma_region;
8546*fae548d3Szrj struct overlay_list *l;
8547*fae548d3Szrj lang_nocrossref_type *nocrossref;
8548*fae548d3Szrj
8549*fae548d3Szrj lang_get_regions (®ion, &lma_region,
8550*fae548d3Szrj memspec, lma_memspec,
8551*fae548d3Szrj lma_expr != NULL, FALSE);
8552*fae548d3Szrj
8553*fae548d3Szrj nocrossref = NULL;
8554*fae548d3Szrj
8555*fae548d3Szrj /* After setting the size of the last section, set '.' to end of the
8556*fae548d3Szrj overlay region. */
8557*fae548d3Szrj if (overlay_list != NULL)
8558*fae548d3Szrj {
8559*fae548d3Szrj overlay_list->os->update_dot = 1;
8560*fae548d3Szrj overlay_list->os->update_dot_tree
8561*fae548d3Szrj = exp_assign (".", exp_binop ('+', overlay_vma, overlay_max), FALSE);
8562*fae548d3Szrj }
8563*fae548d3Szrj
8564*fae548d3Szrj l = overlay_list;
8565*fae548d3Szrj while (l != NULL)
8566*fae548d3Szrj {
8567*fae548d3Szrj struct overlay_list *next;
8568*fae548d3Szrj
8569*fae548d3Szrj if (fill != NULL && l->os->fill == NULL)
8570*fae548d3Szrj l->os->fill = fill;
8571*fae548d3Szrj
8572*fae548d3Szrj l->os->region = region;
8573*fae548d3Szrj l->os->lma_region = lma_region;
8574*fae548d3Szrj
8575*fae548d3Szrj /* The first section has the load address specified in the
8576*fae548d3Szrj OVERLAY statement. The rest are worked out from that.
8577*fae548d3Szrj The base address is not needed (and should be null) if
8578*fae548d3Szrj an LMA region was specified. */
8579*fae548d3Szrj if (l->next == 0)
8580*fae548d3Szrj {
8581*fae548d3Szrj l->os->load_base = lma_expr;
8582*fae548d3Szrj l->os->sectype = first_overlay_section;
8583*fae548d3Szrj }
8584*fae548d3Szrj if (phdrs != NULL && l->os->phdrs == NULL)
8585*fae548d3Szrj l->os->phdrs = phdrs;
8586*fae548d3Szrj
8587*fae548d3Szrj if (nocrossrefs)
8588*fae548d3Szrj {
8589*fae548d3Szrj lang_nocrossref_type *nc;
8590*fae548d3Szrj
8591*fae548d3Szrj nc = (lang_nocrossref_type *) xmalloc (sizeof *nc);
8592*fae548d3Szrj nc->name = l->os->name;
8593*fae548d3Szrj nc->next = nocrossref;
8594*fae548d3Szrj nocrossref = nc;
8595*fae548d3Szrj }
8596*fae548d3Szrj
8597*fae548d3Szrj next = l->next;
8598*fae548d3Szrj free (l);
8599*fae548d3Szrj l = next;
8600*fae548d3Szrj }
8601*fae548d3Szrj
8602*fae548d3Szrj if (nocrossref != NULL)
8603*fae548d3Szrj lang_add_nocrossref (nocrossref);
8604*fae548d3Szrj
8605*fae548d3Szrj overlay_vma = NULL;
8606*fae548d3Szrj overlay_list = NULL;
8607*fae548d3Szrj overlay_max = NULL;
8608*fae548d3Szrj overlay_subalign = NULL;
8609*fae548d3Szrj }
8610*fae548d3Szrj
8611*fae548d3Szrj /* Version handling. This is only useful for ELF. */
8612*fae548d3Szrj
8613*fae548d3Szrj /* If PREV is NULL, return first version pattern matching particular symbol.
8614*fae548d3Szrj If PREV is non-NULL, return first version pattern matching particular
8615*fae548d3Szrj symbol after PREV (previously returned by lang_vers_match). */
8616*fae548d3Szrj
8617*fae548d3Szrj static struct bfd_elf_version_expr *
lang_vers_match(struct bfd_elf_version_expr_head * head,struct bfd_elf_version_expr * prev,const char * sym)8618*fae548d3Szrj lang_vers_match (struct bfd_elf_version_expr_head *head,
8619*fae548d3Szrj struct bfd_elf_version_expr *prev,
8620*fae548d3Szrj const char *sym)
8621*fae548d3Szrj {
8622*fae548d3Szrj const char *c_sym;
8623*fae548d3Szrj const char *cxx_sym = sym;
8624*fae548d3Szrj const char *java_sym = sym;
8625*fae548d3Szrj struct bfd_elf_version_expr *expr = NULL;
8626*fae548d3Szrj enum demangling_styles curr_style;
8627*fae548d3Szrj
8628*fae548d3Szrj curr_style = CURRENT_DEMANGLING_STYLE;
8629*fae548d3Szrj cplus_demangle_set_style (no_demangling);
8630*fae548d3Szrj c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS);
8631*fae548d3Szrj if (!c_sym)
8632*fae548d3Szrj c_sym = sym;
8633*fae548d3Szrj cplus_demangle_set_style (curr_style);
8634*fae548d3Szrj
8635*fae548d3Szrj if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
8636*fae548d3Szrj {
8637*fae548d3Szrj cxx_sym = bfd_demangle (link_info.output_bfd, sym,
8638*fae548d3Szrj DMGL_PARAMS | DMGL_ANSI);
8639*fae548d3Szrj if (!cxx_sym)
8640*fae548d3Szrj cxx_sym = sym;
8641*fae548d3Szrj }
8642*fae548d3Szrj if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
8643*fae548d3Szrj {
8644*fae548d3Szrj java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA);
8645*fae548d3Szrj if (!java_sym)
8646*fae548d3Szrj java_sym = sym;
8647*fae548d3Szrj }
8648*fae548d3Szrj
8649*fae548d3Szrj if (head->htab && (prev == NULL || prev->literal))
8650*fae548d3Szrj {
8651*fae548d3Szrj struct bfd_elf_version_expr e;
8652*fae548d3Szrj
8653*fae548d3Szrj switch (prev ? prev->mask : 0)
8654*fae548d3Szrj {
8655*fae548d3Szrj case 0:
8656*fae548d3Szrj if (head->mask & BFD_ELF_VERSION_C_TYPE)
8657*fae548d3Szrj {
8658*fae548d3Szrj e.pattern = c_sym;
8659*fae548d3Szrj expr = (struct bfd_elf_version_expr *)
8660*fae548d3Szrj htab_find ((htab_t) head->htab, &e);
8661*fae548d3Szrj while (expr && strcmp (expr->pattern, c_sym) == 0)
8662*fae548d3Szrj if (expr->mask == BFD_ELF_VERSION_C_TYPE)
8663*fae548d3Szrj goto out_ret;
8664*fae548d3Szrj else
8665*fae548d3Szrj expr = expr->next;
8666*fae548d3Szrj }
8667*fae548d3Szrj /* Fallthrough */
8668*fae548d3Szrj case BFD_ELF_VERSION_C_TYPE:
8669*fae548d3Szrj if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
8670*fae548d3Szrj {
8671*fae548d3Szrj e.pattern = cxx_sym;
8672*fae548d3Szrj expr = (struct bfd_elf_version_expr *)
8673*fae548d3Szrj htab_find ((htab_t) head->htab, &e);
8674*fae548d3Szrj while (expr && strcmp (expr->pattern, cxx_sym) == 0)
8675*fae548d3Szrj if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
8676*fae548d3Szrj goto out_ret;
8677*fae548d3Szrj else
8678*fae548d3Szrj expr = expr->next;
8679*fae548d3Szrj }
8680*fae548d3Szrj /* Fallthrough */
8681*fae548d3Szrj case BFD_ELF_VERSION_CXX_TYPE:
8682*fae548d3Szrj if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
8683*fae548d3Szrj {
8684*fae548d3Szrj e.pattern = java_sym;
8685*fae548d3Szrj expr = (struct bfd_elf_version_expr *)
8686*fae548d3Szrj htab_find ((htab_t) head->htab, &e);
8687*fae548d3Szrj while (expr && strcmp (expr->pattern, java_sym) == 0)
8688*fae548d3Szrj if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
8689*fae548d3Szrj goto out_ret;
8690*fae548d3Szrj else
8691*fae548d3Szrj expr = expr->next;
8692*fae548d3Szrj }
8693*fae548d3Szrj /* Fallthrough */
8694*fae548d3Szrj default:
8695*fae548d3Szrj break;
8696*fae548d3Szrj }
8697*fae548d3Szrj }
8698*fae548d3Szrj
8699*fae548d3Szrj /* Finally, try the wildcards. */
8700*fae548d3Szrj if (prev == NULL || prev->literal)
8701*fae548d3Szrj expr = head->remaining;
8702*fae548d3Szrj else
8703*fae548d3Szrj expr = prev->next;
8704*fae548d3Szrj for (; expr; expr = expr->next)
8705*fae548d3Szrj {
8706*fae548d3Szrj const char *s;
8707*fae548d3Szrj
8708*fae548d3Szrj if (!expr->pattern)
8709*fae548d3Szrj continue;
8710*fae548d3Szrj
8711*fae548d3Szrj if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
8712*fae548d3Szrj break;
8713*fae548d3Szrj
8714*fae548d3Szrj if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
8715*fae548d3Szrj s = java_sym;
8716*fae548d3Szrj else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
8717*fae548d3Szrj s = cxx_sym;
8718*fae548d3Szrj else
8719*fae548d3Szrj s = c_sym;
8720*fae548d3Szrj if (fnmatch (expr->pattern, s, 0) == 0)
8721*fae548d3Szrj break;
8722*fae548d3Szrj }
8723*fae548d3Szrj
8724*fae548d3Szrj out_ret:
8725*fae548d3Szrj if (c_sym != sym)
8726*fae548d3Szrj free ((char *) c_sym);
8727*fae548d3Szrj if (cxx_sym != sym)
8728*fae548d3Szrj free ((char *) cxx_sym);
8729*fae548d3Szrj if (java_sym != sym)
8730*fae548d3Szrj free ((char *) java_sym);
8731*fae548d3Szrj return expr;
8732*fae548d3Szrj }
8733*fae548d3Szrj
8734*fae548d3Szrj /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8735*fae548d3Szrj return a pointer to the symbol name with any backslash quotes removed. */
8736*fae548d3Szrj
8737*fae548d3Szrj static const char *
realsymbol(const char * pattern)8738*fae548d3Szrj realsymbol (const char *pattern)
8739*fae548d3Szrj {
8740*fae548d3Szrj const char *p;
8741*fae548d3Szrj bfd_boolean changed = FALSE, backslash = FALSE;
8742*fae548d3Szrj char *s, *symbol = (char *) xmalloc (strlen (pattern) + 1);
8743*fae548d3Szrj
8744*fae548d3Szrj for (p = pattern, s = symbol; *p != '\0'; ++p)
8745*fae548d3Szrj {
8746*fae548d3Szrj /* It is a glob pattern only if there is no preceding
8747*fae548d3Szrj backslash. */
8748*fae548d3Szrj if (backslash)
8749*fae548d3Szrj {
8750*fae548d3Szrj /* Remove the preceding backslash. */
8751*fae548d3Szrj *(s - 1) = *p;
8752*fae548d3Szrj backslash = FALSE;
8753*fae548d3Szrj changed = TRUE;
8754*fae548d3Szrj }
8755*fae548d3Szrj else
8756*fae548d3Szrj {
8757*fae548d3Szrj if (*p == '?' || *p == '*' || *p == '[')
8758*fae548d3Szrj {
8759*fae548d3Szrj free (symbol);
8760*fae548d3Szrj return NULL;
8761*fae548d3Szrj }
8762*fae548d3Szrj
8763*fae548d3Szrj *s++ = *p;
8764*fae548d3Szrj backslash = *p == '\\';
8765*fae548d3Szrj }
8766*fae548d3Szrj }
8767*fae548d3Szrj
8768*fae548d3Szrj if (changed)
8769*fae548d3Szrj {
8770*fae548d3Szrj *s = '\0';
8771*fae548d3Szrj return symbol;
8772*fae548d3Szrj }
8773*fae548d3Szrj else
8774*fae548d3Szrj {
8775*fae548d3Szrj free (symbol);
8776*fae548d3Szrj return pattern;
8777*fae548d3Szrj }
8778*fae548d3Szrj }
8779*fae548d3Szrj
8780*fae548d3Szrj /* This is called for each variable name or match expression. NEW_NAME is
8781*fae548d3Szrj the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8782*fae548d3Szrj pattern to be matched against symbol names. */
8783*fae548d3Szrj
8784*fae548d3Szrj struct bfd_elf_version_expr *
lang_new_vers_pattern(struct bfd_elf_version_expr * orig,const char * new_name,const char * lang,bfd_boolean literal_p)8785*fae548d3Szrj lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
8786*fae548d3Szrj const char *new_name,
8787*fae548d3Szrj const char *lang,
8788*fae548d3Szrj bfd_boolean literal_p)
8789*fae548d3Szrj {
8790*fae548d3Szrj struct bfd_elf_version_expr *ret;
8791*fae548d3Szrj
8792*fae548d3Szrj ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
8793*fae548d3Szrj ret->next = orig;
8794*fae548d3Szrj ret->symver = 0;
8795*fae548d3Szrj ret->script = 0;
8796*fae548d3Szrj ret->literal = TRUE;
8797*fae548d3Szrj ret->pattern = literal_p ? new_name : realsymbol (new_name);
8798*fae548d3Szrj if (ret->pattern == NULL)
8799*fae548d3Szrj {
8800*fae548d3Szrj ret->pattern = new_name;
8801*fae548d3Szrj ret->literal = FALSE;
8802*fae548d3Szrj }
8803*fae548d3Szrj
8804*fae548d3Szrj if (lang == NULL || strcasecmp (lang, "C") == 0)
8805*fae548d3Szrj ret->mask = BFD_ELF_VERSION_C_TYPE;
8806*fae548d3Szrj else if (strcasecmp (lang, "C++") == 0)
8807*fae548d3Szrj ret->mask = BFD_ELF_VERSION_CXX_TYPE;
8808*fae548d3Szrj else if (strcasecmp (lang, "Java") == 0)
8809*fae548d3Szrj ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
8810*fae548d3Szrj else
8811*fae548d3Szrj {
8812*fae548d3Szrj einfo (_("%X%P: unknown language `%s' in version information\n"),
8813*fae548d3Szrj lang);
8814*fae548d3Szrj ret->mask = BFD_ELF_VERSION_C_TYPE;
8815*fae548d3Szrj }
8816*fae548d3Szrj
8817*fae548d3Szrj return ldemul_new_vers_pattern (ret);
8818*fae548d3Szrj }
8819*fae548d3Szrj
8820*fae548d3Szrj /* This is called for each set of variable names and match
8821*fae548d3Szrj expressions. */
8822*fae548d3Szrj
8823*fae548d3Szrj struct bfd_elf_version_tree *
lang_new_vers_node(struct bfd_elf_version_expr * globals,struct bfd_elf_version_expr * locals)8824*fae548d3Szrj lang_new_vers_node (struct bfd_elf_version_expr *globals,
8825*fae548d3Szrj struct bfd_elf_version_expr *locals)
8826*fae548d3Szrj {
8827*fae548d3Szrj struct bfd_elf_version_tree *ret;
8828*fae548d3Szrj
8829*fae548d3Szrj ret = (struct bfd_elf_version_tree *) xcalloc (1, sizeof *ret);
8830*fae548d3Szrj ret->globals.list = globals;
8831*fae548d3Szrj ret->locals.list = locals;
8832*fae548d3Szrj ret->match = lang_vers_match;
8833*fae548d3Szrj ret->name_indx = (unsigned int) -1;
8834*fae548d3Szrj return ret;
8835*fae548d3Szrj }
8836*fae548d3Szrj
8837*fae548d3Szrj /* This static variable keeps track of version indices. */
8838*fae548d3Szrj
8839*fae548d3Szrj static int version_index;
8840*fae548d3Szrj
8841*fae548d3Szrj static hashval_t
version_expr_head_hash(const void * p)8842*fae548d3Szrj version_expr_head_hash (const void *p)
8843*fae548d3Szrj {
8844*fae548d3Szrj const struct bfd_elf_version_expr *e =
8845*fae548d3Szrj (const struct bfd_elf_version_expr *) p;
8846*fae548d3Szrj
8847*fae548d3Szrj return htab_hash_string (e->pattern);
8848*fae548d3Szrj }
8849*fae548d3Szrj
8850*fae548d3Szrj static int
version_expr_head_eq(const void * p1,const void * p2)8851*fae548d3Szrj version_expr_head_eq (const void *p1, const void *p2)
8852*fae548d3Szrj {
8853*fae548d3Szrj const struct bfd_elf_version_expr *e1 =
8854*fae548d3Szrj (const struct bfd_elf_version_expr *) p1;
8855*fae548d3Szrj const struct bfd_elf_version_expr *e2 =
8856*fae548d3Szrj (const struct bfd_elf_version_expr *) p2;
8857*fae548d3Szrj
8858*fae548d3Szrj return strcmp (e1->pattern, e2->pattern) == 0;
8859*fae548d3Szrj }
8860*fae548d3Szrj
8861*fae548d3Szrj static void
lang_finalize_version_expr_head(struct bfd_elf_version_expr_head * head)8862*fae548d3Szrj lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
8863*fae548d3Szrj {
8864*fae548d3Szrj size_t count = 0;
8865*fae548d3Szrj struct bfd_elf_version_expr *e, *next;
8866*fae548d3Szrj struct bfd_elf_version_expr **list_loc, **remaining_loc;
8867*fae548d3Szrj
8868*fae548d3Szrj for (e = head->list; e; e = e->next)
8869*fae548d3Szrj {
8870*fae548d3Szrj if (e->literal)
8871*fae548d3Szrj count++;
8872*fae548d3Szrj head->mask |= e->mask;
8873*fae548d3Szrj }
8874*fae548d3Szrj
8875*fae548d3Szrj if (count)
8876*fae548d3Szrj {
8877*fae548d3Szrj head->htab = htab_create (count * 2, version_expr_head_hash,
8878*fae548d3Szrj version_expr_head_eq, NULL);
8879*fae548d3Szrj list_loc = &head->list;
8880*fae548d3Szrj remaining_loc = &head->remaining;
8881*fae548d3Szrj for (e = head->list; e; e = next)
8882*fae548d3Szrj {
8883*fae548d3Szrj next = e->next;
8884*fae548d3Szrj if (!e->literal)
8885*fae548d3Szrj {
8886*fae548d3Szrj *remaining_loc = e;
8887*fae548d3Szrj remaining_loc = &e->next;
8888*fae548d3Szrj }
8889*fae548d3Szrj else
8890*fae548d3Szrj {
8891*fae548d3Szrj void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);
8892*fae548d3Szrj
8893*fae548d3Szrj if (*loc)
8894*fae548d3Szrj {
8895*fae548d3Szrj struct bfd_elf_version_expr *e1, *last;
8896*fae548d3Szrj
8897*fae548d3Szrj e1 = (struct bfd_elf_version_expr *) *loc;
8898*fae548d3Szrj last = NULL;
8899*fae548d3Szrj do
8900*fae548d3Szrj {
8901*fae548d3Szrj if (e1->mask == e->mask)
8902*fae548d3Szrj {
8903*fae548d3Szrj last = NULL;
8904*fae548d3Szrj break;
8905*fae548d3Szrj }
8906*fae548d3Szrj last = e1;
8907*fae548d3Szrj e1 = e1->next;
8908*fae548d3Szrj }
8909*fae548d3Szrj while (e1 && strcmp (e1->pattern, e->pattern) == 0);
8910*fae548d3Szrj
8911*fae548d3Szrj if (last == NULL)
8912*fae548d3Szrj {
8913*fae548d3Szrj /* This is a duplicate. */
8914*fae548d3Szrj /* FIXME: Memory leak. Sometimes pattern is not
8915*fae548d3Szrj xmalloced alone, but in larger chunk of memory. */
8916*fae548d3Szrj /* free (e->pattern); */
8917*fae548d3Szrj free (e);
8918*fae548d3Szrj }
8919*fae548d3Szrj else
8920*fae548d3Szrj {
8921*fae548d3Szrj e->next = last->next;
8922*fae548d3Szrj last->next = e;
8923*fae548d3Szrj }
8924*fae548d3Szrj }
8925*fae548d3Szrj else
8926*fae548d3Szrj {
8927*fae548d3Szrj *loc = e;
8928*fae548d3Szrj *list_loc = e;
8929*fae548d3Szrj list_loc = &e->next;
8930*fae548d3Szrj }
8931*fae548d3Szrj }
8932*fae548d3Szrj }
8933*fae548d3Szrj *remaining_loc = NULL;
8934*fae548d3Szrj *list_loc = head->remaining;
8935*fae548d3Szrj }
8936*fae548d3Szrj else
8937*fae548d3Szrj head->remaining = head->list;
8938*fae548d3Szrj }
8939*fae548d3Szrj
8940*fae548d3Szrj /* This is called when we know the name and dependencies of the
8941*fae548d3Szrj version. */
8942*fae548d3Szrj
8943*fae548d3Szrj void
lang_register_vers_node(const char * name,struct bfd_elf_version_tree * version,struct bfd_elf_version_deps * deps)8944*fae548d3Szrj lang_register_vers_node (const char *name,
8945*fae548d3Szrj struct bfd_elf_version_tree *version,
8946*fae548d3Szrj struct bfd_elf_version_deps *deps)
8947*fae548d3Szrj {
8948*fae548d3Szrj struct bfd_elf_version_tree *t, **pp;
8949*fae548d3Szrj struct bfd_elf_version_expr *e1;
8950*fae548d3Szrj
8951*fae548d3Szrj if (name == NULL)
8952*fae548d3Szrj name = "";
8953*fae548d3Szrj
8954*fae548d3Szrj if (link_info.version_info != NULL
8955*fae548d3Szrj && (name[0] == '\0' || link_info.version_info->name[0] == '\0'))
8956*fae548d3Szrj {
8957*fae548d3Szrj einfo (_("%X%P: anonymous version tag cannot be combined"
8958*fae548d3Szrj " with other version tags\n"));
8959*fae548d3Szrj free (version);
8960*fae548d3Szrj return;
8961*fae548d3Szrj }
8962*fae548d3Szrj
8963*fae548d3Szrj /* Make sure this node has a unique name. */
8964*fae548d3Szrj for (t = link_info.version_info; t != NULL; t = t->next)
8965*fae548d3Szrj if (strcmp (t->name, name) == 0)
8966*fae548d3Szrj einfo (_("%X%P: duplicate version tag `%s'\n"), name);
8967*fae548d3Szrj
8968*fae548d3Szrj lang_finalize_version_expr_head (&version->globals);
8969*fae548d3Szrj lang_finalize_version_expr_head (&version->locals);
8970*fae548d3Szrj
8971*fae548d3Szrj /* Check the global and local match names, and make sure there
8972*fae548d3Szrj aren't any duplicates. */
8973*fae548d3Szrj
8974*fae548d3Szrj for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
8975*fae548d3Szrj {
8976*fae548d3Szrj for (t = link_info.version_info; t != NULL; t = t->next)
8977*fae548d3Szrj {
8978*fae548d3Szrj struct bfd_elf_version_expr *e2;
8979*fae548d3Szrj
8980*fae548d3Szrj if (t->locals.htab && e1->literal)
8981*fae548d3Szrj {
8982*fae548d3Szrj e2 = (struct bfd_elf_version_expr *)
8983*fae548d3Szrj htab_find ((htab_t) t->locals.htab, e1);
8984*fae548d3Szrj while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
8985*fae548d3Szrj {
8986*fae548d3Szrj if (e1->mask == e2->mask)
8987*fae548d3Szrj einfo (_("%X%P: duplicate expression `%s'"
8988*fae548d3Szrj " in version information\n"), e1->pattern);
8989*fae548d3Szrj e2 = e2->next;
8990*fae548d3Szrj }
8991*fae548d3Szrj }
8992*fae548d3Szrj else if (!e1->literal)
8993*fae548d3Szrj for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
8994*fae548d3Szrj if (strcmp (e1->pattern, e2->pattern) == 0
8995*fae548d3Szrj && e1->mask == e2->mask)
8996*fae548d3Szrj einfo (_("%X%P: duplicate expression `%s'"
8997*fae548d3Szrj " in version information\n"), e1->pattern);
8998*fae548d3Szrj }
8999*fae548d3Szrj }
9000*fae548d3Szrj
9001*fae548d3Szrj for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
9002*fae548d3Szrj {
9003*fae548d3Szrj for (t = link_info.version_info; t != NULL; t = t->next)
9004*fae548d3Szrj {
9005*fae548d3Szrj struct bfd_elf_version_expr *e2;
9006*fae548d3Szrj
9007*fae548d3Szrj if (t->globals.htab && e1->literal)
9008*fae548d3Szrj {
9009*fae548d3Szrj e2 = (struct bfd_elf_version_expr *)
9010*fae548d3Szrj htab_find ((htab_t) t->globals.htab, e1);
9011*fae548d3Szrj while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
9012*fae548d3Szrj {
9013*fae548d3Szrj if (e1->mask == e2->mask)
9014*fae548d3Szrj einfo (_("%X%P: duplicate expression `%s'"
9015*fae548d3Szrj " in version information\n"),
9016*fae548d3Szrj e1->pattern);
9017*fae548d3Szrj e2 = e2->next;
9018*fae548d3Szrj }
9019*fae548d3Szrj }
9020*fae548d3Szrj else if (!e1->literal)
9021*fae548d3Szrj for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
9022*fae548d3Szrj if (strcmp (e1->pattern, e2->pattern) == 0
9023*fae548d3Szrj && e1->mask == e2->mask)
9024*fae548d3Szrj einfo (_("%X%P: duplicate expression `%s'"
9025*fae548d3Szrj " in version information\n"), e1->pattern);
9026*fae548d3Szrj }
9027*fae548d3Szrj }
9028*fae548d3Szrj
9029*fae548d3Szrj version->deps = deps;
9030*fae548d3Szrj version->name = name;
9031*fae548d3Szrj if (name[0] != '\0')
9032*fae548d3Szrj {
9033*fae548d3Szrj ++version_index;
9034*fae548d3Szrj version->vernum = version_index;
9035*fae548d3Szrj }
9036*fae548d3Szrj else
9037*fae548d3Szrj version->vernum = 0;
9038*fae548d3Szrj
9039*fae548d3Szrj for (pp = &link_info.version_info; *pp != NULL; pp = &(*pp)->next)
9040*fae548d3Szrj ;
9041*fae548d3Szrj *pp = version;
9042*fae548d3Szrj }
9043*fae548d3Szrj
9044*fae548d3Szrj /* This is called when we see a version dependency. */
9045*fae548d3Szrj
9046*fae548d3Szrj struct bfd_elf_version_deps *
lang_add_vers_depend(struct bfd_elf_version_deps * list,const char * name)9047*fae548d3Szrj lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
9048*fae548d3Szrj {
9049*fae548d3Szrj struct bfd_elf_version_deps *ret;
9050*fae548d3Szrj struct bfd_elf_version_tree *t;
9051*fae548d3Szrj
9052*fae548d3Szrj ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
9053*fae548d3Szrj ret->next = list;
9054*fae548d3Szrj
9055*fae548d3Szrj for (t = link_info.version_info; t != NULL; t = t->next)
9056*fae548d3Szrj {
9057*fae548d3Szrj if (strcmp (t->name, name) == 0)
9058*fae548d3Szrj {
9059*fae548d3Szrj ret->version_needed = t;
9060*fae548d3Szrj return ret;
9061*fae548d3Szrj }
9062*fae548d3Szrj }
9063*fae548d3Szrj
9064*fae548d3Szrj einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
9065*fae548d3Szrj
9066*fae548d3Szrj ret->version_needed = NULL;
9067*fae548d3Szrj return ret;
9068*fae548d3Szrj }
9069*fae548d3Szrj
9070*fae548d3Szrj static void
lang_do_version_exports_section(void)9071*fae548d3Szrj lang_do_version_exports_section (void)
9072*fae548d3Szrj {
9073*fae548d3Szrj struct bfd_elf_version_expr *greg = NULL, *lreg;
9074*fae548d3Szrj
9075*fae548d3Szrj LANG_FOR_EACH_INPUT_STATEMENT (is)
9076*fae548d3Szrj {
9077*fae548d3Szrj asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
9078*fae548d3Szrj char *contents, *p;
9079*fae548d3Szrj bfd_size_type len;
9080*fae548d3Szrj
9081*fae548d3Szrj if (sec == NULL)
9082*fae548d3Szrj continue;
9083*fae548d3Szrj
9084*fae548d3Szrj len = sec->size;
9085*fae548d3Szrj contents = (char *) xmalloc (len);
9086*fae548d3Szrj if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
9087*fae548d3Szrj einfo (_("%X%P: unable to read .exports section contents\n"), sec);
9088*fae548d3Szrj
9089*fae548d3Szrj p = contents;
9090*fae548d3Szrj while (p < contents + len)
9091*fae548d3Szrj {
9092*fae548d3Szrj greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
9093*fae548d3Szrj p = strchr (p, '\0') + 1;
9094*fae548d3Szrj }
9095*fae548d3Szrj
9096*fae548d3Szrj /* Do not free the contents, as we used them creating the regex. */
9097*fae548d3Szrj
9098*fae548d3Szrj /* Do not include this section in the link. */
9099*fae548d3Szrj sec->flags |= SEC_EXCLUDE | SEC_KEEP;
9100*fae548d3Szrj }
9101*fae548d3Szrj
9102*fae548d3Szrj lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
9103*fae548d3Szrj lang_register_vers_node (command_line.version_exports_section,
9104*fae548d3Szrj lang_new_vers_node (greg, lreg), NULL);
9105*fae548d3Szrj }
9106*fae548d3Szrj
9107*fae548d3Szrj /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
9108*fae548d3Szrj
9109*fae548d3Szrj static void
lang_do_memory_regions(void)9110*fae548d3Szrj lang_do_memory_regions (void)
9111*fae548d3Szrj {
9112*fae548d3Szrj lang_memory_region_type *r = lang_memory_region_list;
9113*fae548d3Szrj
9114*fae548d3Szrj for (; r != NULL; r = r->next)
9115*fae548d3Szrj {
9116*fae548d3Szrj if (r->origin_exp)
9117*fae548d3Szrj {
9118*fae548d3Szrj exp_fold_tree_no_dot (r->origin_exp);
9119*fae548d3Szrj if (expld.result.valid_p)
9120*fae548d3Szrj {
9121*fae548d3Szrj r->origin = expld.result.value;
9122*fae548d3Szrj r->current = r->origin;
9123*fae548d3Szrj }
9124*fae548d3Szrj else
9125*fae548d3Szrj einfo (_("%F%P: invalid origin for memory region %s\n"),
9126*fae548d3Szrj r->name_list.name);
9127*fae548d3Szrj }
9128*fae548d3Szrj if (r->length_exp)
9129*fae548d3Szrj {
9130*fae548d3Szrj exp_fold_tree_no_dot (r->length_exp);
9131*fae548d3Szrj if (expld.result.valid_p)
9132*fae548d3Szrj r->length = expld.result.value;
9133*fae548d3Szrj else
9134*fae548d3Szrj einfo (_("%F%P: invalid length for memory region %s\n"),
9135*fae548d3Szrj r->name_list.name);
9136*fae548d3Szrj }
9137*fae548d3Szrj }
9138*fae548d3Szrj }
9139*fae548d3Szrj
9140*fae548d3Szrj void
lang_add_unique(const char * name)9141*fae548d3Szrj lang_add_unique (const char *name)
9142*fae548d3Szrj {
9143*fae548d3Szrj struct unique_sections *ent;
9144*fae548d3Szrj
9145*fae548d3Szrj for (ent = unique_section_list; ent; ent = ent->next)
9146*fae548d3Szrj if (strcmp (ent->name, name) == 0)
9147*fae548d3Szrj return;
9148*fae548d3Szrj
9149*fae548d3Szrj ent = (struct unique_sections *) xmalloc (sizeof *ent);
9150*fae548d3Szrj ent->name = xstrdup (name);
9151*fae548d3Szrj ent->next = unique_section_list;
9152*fae548d3Szrj unique_section_list = ent;
9153*fae548d3Szrj }
9154*fae548d3Szrj
9155*fae548d3Szrj /* Append the list of dynamic symbols to the existing one. */
9156*fae548d3Szrj
9157*fae548d3Szrj void
lang_append_dynamic_list(struct bfd_elf_version_expr * dynamic)9158*fae548d3Szrj lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
9159*fae548d3Szrj {
9160*fae548d3Szrj if (link_info.dynamic_list)
9161*fae548d3Szrj {
9162*fae548d3Szrj struct bfd_elf_version_expr *tail;
9163*fae548d3Szrj for (tail = dynamic; tail->next != NULL; tail = tail->next)
9164*fae548d3Szrj ;
9165*fae548d3Szrj tail->next = link_info.dynamic_list->head.list;
9166*fae548d3Szrj link_info.dynamic_list->head.list = dynamic;
9167*fae548d3Szrj }
9168*fae548d3Szrj else
9169*fae548d3Szrj {
9170*fae548d3Szrj struct bfd_elf_dynamic_list *d;
9171*fae548d3Szrj
9172*fae548d3Szrj d = (struct bfd_elf_dynamic_list *) xcalloc (1, sizeof *d);
9173*fae548d3Szrj d->head.list = dynamic;
9174*fae548d3Szrj d->match = lang_vers_match;
9175*fae548d3Szrj link_info.dynamic_list = d;
9176*fae548d3Szrj }
9177*fae548d3Szrj }
9178*fae548d3Szrj
9179*fae548d3Szrj /* Append the list of C++ typeinfo dynamic symbols to the existing
9180*fae548d3Szrj one. */
9181*fae548d3Szrj
9182*fae548d3Szrj void
lang_append_dynamic_list_cpp_typeinfo(void)9183*fae548d3Szrj lang_append_dynamic_list_cpp_typeinfo (void)
9184*fae548d3Szrj {
9185*fae548d3Szrj const char *symbols[] =
9186*fae548d3Szrj {
9187*fae548d3Szrj "typeinfo name for*",
9188*fae548d3Szrj "typeinfo for*"
9189*fae548d3Szrj };
9190*fae548d3Szrj struct bfd_elf_version_expr *dynamic = NULL;
9191*fae548d3Szrj unsigned int i;
9192*fae548d3Szrj
9193*fae548d3Szrj for (i = 0; i < ARRAY_SIZE (symbols); i++)
9194*fae548d3Szrj dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
9195*fae548d3Szrj FALSE);
9196*fae548d3Szrj
9197*fae548d3Szrj lang_append_dynamic_list (dynamic);
9198*fae548d3Szrj }
9199*fae548d3Szrj
9200*fae548d3Szrj /* Append the list of C++ operator new and delete dynamic symbols to the
9201*fae548d3Szrj existing one. */
9202*fae548d3Szrj
9203*fae548d3Szrj void
lang_append_dynamic_list_cpp_new(void)9204*fae548d3Szrj lang_append_dynamic_list_cpp_new (void)
9205*fae548d3Szrj {
9206*fae548d3Szrj const char *symbols[] =
9207*fae548d3Szrj {
9208*fae548d3Szrj "operator new*",
9209*fae548d3Szrj "operator delete*"
9210*fae548d3Szrj };
9211*fae548d3Szrj struct bfd_elf_version_expr *dynamic = NULL;
9212*fae548d3Szrj unsigned int i;
9213*fae548d3Szrj
9214*fae548d3Szrj for (i = 0; i < ARRAY_SIZE (symbols); i++)
9215*fae548d3Szrj dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
9216*fae548d3Szrj FALSE);
9217*fae548d3Szrj
9218*fae548d3Szrj lang_append_dynamic_list (dynamic);
9219*fae548d3Szrj }
9220*fae548d3Szrj
9221*fae548d3Szrj /* Scan a space and/or comma separated string of features. */
9222*fae548d3Szrj
9223*fae548d3Szrj void
lang_ld_feature(char * str)9224*fae548d3Szrj lang_ld_feature (char *str)
9225*fae548d3Szrj {
9226*fae548d3Szrj char *p, *q;
9227*fae548d3Szrj
9228*fae548d3Szrj p = str;
9229*fae548d3Szrj while (*p)
9230*fae548d3Szrj {
9231*fae548d3Szrj char sep;
9232*fae548d3Szrj while (*p == ',' || ISSPACE (*p))
9233*fae548d3Szrj ++p;
9234*fae548d3Szrj if (!*p)
9235*fae548d3Szrj break;
9236*fae548d3Szrj q = p + 1;
9237*fae548d3Szrj while (*q && *q != ',' && !ISSPACE (*q))
9238*fae548d3Szrj ++q;
9239*fae548d3Szrj sep = *q;
9240*fae548d3Szrj *q = 0;
9241*fae548d3Szrj if (strcasecmp (p, "SANE_EXPR") == 0)
9242*fae548d3Szrj config.sane_expr = TRUE;
9243*fae548d3Szrj else
9244*fae548d3Szrj einfo (_("%X%P: unknown feature `%s'\n"), p);
9245*fae548d3Szrj *q = sep;
9246*fae548d3Szrj p = q;
9247*fae548d3Szrj }
9248*fae548d3Szrj }
9249*fae548d3Szrj
9250*fae548d3Szrj /* Pretty print memory amount. */
9251*fae548d3Szrj
9252*fae548d3Szrj static void
lang_print_memory_size(bfd_vma sz)9253*fae548d3Szrj lang_print_memory_size (bfd_vma sz)
9254*fae548d3Szrj {
9255*fae548d3Szrj if ((sz & 0x3fffffff) == 0)
9256*fae548d3Szrj printf ("%10" BFD_VMA_FMT "u GB", sz >> 30);
9257*fae548d3Szrj else if ((sz & 0xfffff) == 0)
9258*fae548d3Szrj printf ("%10" BFD_VMA_FMT "u MB", sz >> 20);
9259*fae548d3Szrj else if ((sz & 0x3ff) == 0)
9260*fae548d3Szrj printf ("%10" BFD_VMA_FMT "u KB", sz >> 10);
9261*fae548d3Szrj else
9262*fae548d3Szrj printf (" %10" BFD_VMA_FMT "u B", sz);
9263*fae548d3Szrj }
9264*fae548d3Szrj
9265*fae548d3Szrj /* Implement --print-memory-usage: disply per region memory usage. */
9266*fae548d3Szrj
9267*fae548d3Szrj void
lang_print_memory_usage(void)9268*fae548d3Szrj lang_print_memory_usage (void)
9269*fae548d3Szrj {
9270*fae548d3Szrj lang_memory_region_type *r;
9271*fae548d3Szrj
9272*fae548d3Szrj printf ("Memory region Used Size Region Size %%age Used\n");
9273*fae548d3Szrj for (r = lang_memory_region_list; r->next != NULL; r = r->next)
9274*fae548d3Szrj {
9275*fae548d3Szrj bfd_vma used_length = r->current - r->origin;
9276*fae548d3Szrj
9277*fae548d3Szrj printf ("%16s: ",r->name_list.name);
9278*fae548d3Szrj lang_print_memory_size (used_length);
9279*fae548d3Szrj lang_print_memory_size ((bfd_vma) r->length);
9280*fae548d3Szrj
9281*fae548d3Szrj if (r->length != 0)
9282*fae548d3Szrj {
9283*fae548d3Szrj double percent = used_length * 100.0 / r->length;
9284*fae548d3Szrj printf (" %6.2f%%", percent);
9285*fae548d3Szrj }
9286*fae548d3Szrj printf ("\n");
9287*fae548d3Szrj }
9288*fae548d3Szrj }
9289