This patch adds support for printing out the pdata section of PE objects.
[deliverable/binutils-gdb.git] / ld / emultempl / elf32.em
CommitLineData
252b5132
RH
1# This shell script emits a C file. -*- C -*-
2# It does some substitutions.
3# This file is now misnamed, because it supports both 32 bit and 64 bit
4# ELF emulations.
5test -z "${ELFSIZE}" && ELFSIZE=32
86af25fe
L
6if [ -z "$MACHINE" ]; then
7 OUTPUT_ARCH=${ARCH}
8else
9 OUTPUT_ARCH=${ARCH}:${MACHINE}
10fi
92b93329 11fragment <<EOF
252b5132
RH
12/* This file is is generated by a shell script. DO NOT EDIT! */
13
14/* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
4b95cf5c 15 Copyright (C) 1991-2014 Free Software Foundation, Inc.
252b5132
RH
16 Written by Steve Chamberlain <sac@cygnus.com>
17 ELF support by Ian Lance Taylor <ian@cygnus.com>
18
f96b4a7b
NC
19 This file is part of the GNU Binutils.
20
21 This program is free software; you can redistribute it and/or modify
22 it under the terms of the GNU General Public License as published by
23 the Free Software Foundation; either version 3 of the License, or
24 (at your option) any later version.
25
26 This program is distributed in the hope that it will be useful,
27 but WITHOUT ANY WARRANTY; without even the implied warranty of
28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 GNU General Public License for more details.
30
31 You should have received a copy of the GNU General Public License
32 along with this program; if not, write to the Free Software
33 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
34 MA 02110-1301, USA. */
252b5132
RH
35
36#define TARGET_IS_${EMULATION_NAME}
37
252b5132 38#include "sysdep.h"
3db64b00 39#include "bfd.h"
1c9acd94 40#include "libiberty.h"
8056826a 41#include "safe-ctype.h"
42627821 42#include "filenames.h"
fcf65871 43#include "getopt.h"
24382dca 44#include <fcntl.h>
252b5132
RH
45
46#include "bfdlink.h"
47
48#include "ld.h"
49#include "ldmain.h"
252b5132
RH
50#include "ldmisc.h"
51#include "ldexp.h"
52#include "ldlang.h"
b71e2778
AM
53#include "ldfile.h"
54#include "ldemul.h"
61e2488c 55#include "ldbuildid.h"
df2a7313 56#include <ldgram.h>
e0ee487b 57#include "elf/common.h"
ecca9871 58#include "elf-bfd.h"
07f1e47a 59#include "filenames.h"
252b5132 60
0c7a8e5a
AM
61/* Declare functions used by various EXTRA_EM_FILEs. */
62static void gld${EMULATION_NAME}_before_parse (void);
63static void gld${EMULATION_NAME}_after_open (void);
64static void gld${EMULATION_NAME}_before_allocation (void);
eaeb0a9d 65static void gld${EMULATION_NAME}_after_allocation (void);
c2edb4b8 66static lang_output_section_statement_type *gld${EMULATION_NAME}_place_orphan
8a99a385 67 (asection *, const char *, int);
41392f03
AM
68EOF
69
d3989512
JJ
70if [ "x${USE_LIBPATH}" = xyes ] ; then
71 case ${target} in
a5244b7e 72 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
92b93329 73 fragment <<EOF
0b48acfe 74#ifdef HAVE_GLOB
d3989512 75#include <glob.h>
0b48acfe 76#endif
d3989512
JJ
77EOF
78 ;;
79 esac
80fi
81
41392f03
AM
82# Import any needed special functions and/or overrides.
83#
92b93329 84source_em ${srcdir}/emultempl/elf-generic.em
41392f03 85if test -n "$EXTRA_EM_FILE" ; then
92b93329 86 source_em ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
41392f03
AM
87fi
88
f813923c 89# Functions in this file can be overridden by setting the LDEMUL_* shell
41392f03
AM
90# variables. If the name of the overriding function is the same as is
91# defined in this file, then don't output this file's version.
92# If a different overriding name is given then output the standard function
93# as presumably it is called from the overriding function.
94#
95if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
92b93329 96fragment <<EOF
41392f03 97
252b5132 98static void
0c7a8e5a 99gld${EMULATION_NAME}_before_parse (void)
252b5132 100{
5e2f1575 101 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
66be1055 102 input_flags.dynamic = ${DYNAMIC_LINK-TRUE};
b34976b6 103 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
4724d37e 104 config.separate_code = `if test "x${SEPARATE_CODE}" = xyes ; then echo TRUE ; else echo FALSE ; fi`;
663fa543
L
105}
106
822b8bf4 107EOF
663fa543 108fi
822b8bf4 109
4a43e768 110if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
92b93329 111fragment <<EOF
ddbb8a31 112/* Handle the generation of DT_NEEDED tags. */
4a43e768
AM
113
114static bfd_boolean
115gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
116{
96d56e9f 117 int link_class = 0;
4a43e768
AM
118
119 /* Tell the ELF linker that we don't want the output file to have a
120 DT_NEEDED entry for this file, unless it is used to resolve
121 references in a regular object. */
66be1055 122 if (entry->flags.add_DT_NEEDED_for_regular)
96d56e9f 123 link_class = DYN_AS_NEEDED;
e56f61be
L
124
125 /* Tell the ELF linker that we don't want the output file to have a
126 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
127 this file at all. */
66be1055 128 if (!entry->flags.add_DT_NEEDED_for_dynamic)
96d56e9f 129 link_class |= DYN_NO_ADD_NEEDED;
e56f61be 130
66be1055 131 if (entry->flags.just_syms
12b9ff6c
L
132 && (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0)
133 einfo (_("%P%F: --just-symbols may not be used on DSO: %B\n"),
134 entry->the_bfd);
135
ddbb8a31 136 if (link_class == 0
e56f61be
L
137 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
138 return FALSE;
139
1e9cc1c2 140 bfd_elf_set_dyn_lib_class (entry->the_bfd,
4724d37e 141 (enum dynamic_lib_link_class) link_class);
4a43e768
AM
142
143 /* Continue on with normal load_symbols processing. */
144 return FALSE;
145}
146EOF
147fi
148
92b93329 149fragment <<EOF
252b5132
RH
150
151/* These variables are required to pass information back and forth
152 between after_open and check_needed and stat_needed and vercheck. */
153
154static struct bfd_link_needed_list *global_needed;
155static struct stat global_stat;
e13629bc 156static lang_input_statement_type *global_found;
252b5132 157static struct bfd_link_needed_list *global_vercheck_needed;
b34976b6 158static bfd_boolean global_vercheck_failed;
252b5132 159
7ee314fa
AM
160/* These variables are used to implement target options */
161
162static char *audit; /* colon (typically) separated list of libs */
163static char *depaudit; /* colon (typically) separated list of libs */
252b5132 164
30e8ee25
AM
165/* Style of .note.gnu.build-id section. */
166static const char *emit_note_gnu_build_id;
167
04925e1e
AM
168/* On Linux, it's possible to have different versions of the same
169 shared library linked against different versions of libc. The
170 dynamic linker somehow tags which libc version to use in
171 /etc/ld.so.cache, and, based on the libc that it sees in the
172 executable, chooses which version of the shared library to use.
252b5132 173
04925e1e
AM
174 We try to do a similar check here by checking whether this shared
175 library needs any other shared libraries which may conflict with
176 libraries we have already included in the link. If it does, we
177 skip it, and try to find another shared library farther on down the
178 link path.
252b5132 179
04925e1e
AM
180 This is called via lang_for_each_input_file.
181 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
f813923c 182 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
04925e1e 183 a conflicting version. */
252b5132 184
04925e1e 185static void
0c7a8e5a 186gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
04925e1e 187{
1c9acd94 188 const char *soname;
04925e1e 189 struct bfd_link_needed_list *l;
252b5132 190
04925e1e
AM
191 if (global_vercheck_failed)
192 return;
193 if (s->the_bfd == NULL
194 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
195 return;
252b5132 196
04925e1e
AM
197 soname = bfd_elf_get_dt_soname (s->the_bfd);
198 if (soname == NULL)
fed2999d 199 soname = lbasename (bfd_get_filename (s->the_bfd));
04925e1e
AM
200
201 for (l = global_vercheck_needed; l != NULL; l = l->next)
202 {
203 const char *suffix;
204
42627821 205 if (filename_cmp (soname, l->name) == 0)
04925e1e
AM
206 {
207 /* Probably can't happen, but it's an easy check. */
208 continue;
252b5132
RH
209 }
210
04925e1e 211 if (strchr (l->name, '/') != NULL)
252b5132
RH
212 continue;
213
04925e1e
AM
214 suffix = strstr (l->name, ".so.");
215 if (suffix == NULL)
216 continue;
217
218 suffix += sizeof ".so." - 1;
219
42627821 220 if (filename_ncmp (soname, l->name, suffix - l->name) == 0)
04925e1e
AM
221 {
222 /* Here we know that S is a dynamic object FOO.SO.VER1, and
0c7a8e5a
AM
223 the object we are considering needs a dynamic object
224 FOO.SO.VER2, and VER1 and VER2 are different. This
225 appears to be a version mismatch, so we tell the caller
226 to try a different version of this library. */
b34976b6 227 global_vercheck_failed = TRUE;
04925e1e
AM
228 return;
229 }
252b5132
RH
230 }
231}
232
252b5132 233
04925e1e
AM
234/* See if an input file matches a DT_NEEDED entry by running stat on
235 the file. */
236
237static void
0c7a8e5a 238gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
252b5132 239{
04925e1e
AM
240 struct stat st;
241 const char *suffix;
242 const char *soname;
252b5132 243
e13629bc 244 if (global_found != NULL)
04925e1e
AM
245 return;
246 if (s->the_bfd == NULL)
247 return;
e13629bc
AM
248
249 /* If this input file was an as-needed entry, and wasn't found to be
250 needed at the stage it was linked, then don't say we have loaded it. */
251 if ((bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
7cedef86 252 return;
04925e1e
AM
253
254 if (bfd_stat (s->the_bfd, &st) != 0)
252b5132 255 {
04925e1e
AM
256 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
257 return;
258 }
252b5132 259
9eabd475
ZW
260 /* Some operating systems, e.g. Windows, do not provide a meaningful
261 st_ino; they always set it to zero. (Windows does provide a
262 meaningful st_dev.) Do not indicate a duplicate library in that
263 case. While there is no guarantee that a system that provides
264 meaningful inode numbers will never set st_ino to zero, this is
265 merely an optimization, so we do not need to worry about false
266 negatives. */
04925e1e 267 if (st.st_dev == global_stat.st_dev
9eabd475
ZW
268 && st.st_ino == global_stat.st_ino
269 && st.st_ino != 0)
04925e1e 270 {
e13629bc 271 global_found = s;
04925e1e
AM
272 return;
273 }
252b5132 274
04925e1e
AM
275 /* We issue a warning if it looks like we are including two
276 different versions of the same shared library. For example,
277 there may be a problem if -lc picks up libc.so.6 but some other
278 shared library has a DT_NEEDED entry of libc.so.5. This is a
f813923c 279 heuristic test, and it will only work if the name looks like
04925e1e
AM
280 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
281 If we really want to issue warnings about mixing version numbers
282 of shared libraries, we need to find a better way. */
252b5132 283
04925e1e
AM
284 if (strchr (global_needed->name, '/') != NULL)
285 return;
286 suffix = strstr (global_needed->name, ".so.");
287 if (suffix == NULL)
288 return;
289 suffix += sizeof ".so." - 1;
252b5132 290
04925e1e
AM
291 soname = bfd_elf_get_dt_soname (s->the_bfd);
292 if (soname == NULL)
fed2999d 293 soname = lbasename (s->filename);
252b5132 294
42627821 295 if (filename_ncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
04925e1e 296 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
1c9acd94 297 global_needed->name, global_needed->by, soname);
252b5132
RH
298}
299
e56f61be
L
300struct dt_needed
301{
302 bfd *by;
303 const char *name;
304};
04925e1e 305
252b5132
RH
306/* This function is called for each possible name for a dynamic object
307 named by a DT_NEEDED entry. The FORCE parameter indicates whether
308 to skip the check for a conflicting version. */
309
b34976b6 310static bfd_boolean
e56f61be
L
311gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
312 int force)
252b5132
RH
313{
314 bfd *abfd;
e56f61be 315 const char *name = needed->name;
ec4eb78a 316 const char *soname;
96d56e9f 317 int link_class;
252b5132 318
f13a99db 319 abfd = bfd_openr (name, bfd_get_target (link_info.output_bfd));
252b5132 320 if (abfd == NULL)
b34976b6 321 return FALSE;
4a114e3e
L
322
323 /* Linker needs to decompress sections. */
324 abfd->flags |= BFD_DECOMPRESS;
325
252b5132
RH
326 if (! bfd_check_format (abfd, bfd_object))
327 {
cde43e70 328 bfd_close (abfd);
b34976b6 329 return FALSE;
252b5132
RH
330 }
331 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
332 {
cde43e70 333 bfd_close (abfd);
b34976b6 334 return FALSE;
252b5132
RH
335 }
336
c4bb8067 337 /* For DT_NEEDED, they have to match. */
f13a99db 338 if (abfd->xvec != link_info.output_bfd->xvec)
c4bb8067
L
339 {
340 bfd_close (abfd);
b34976b6 341 return FALSE;
c4bb8067
L
342 }
343
252b5132
RH
344 /* Check whether this object would include any conflicting library
345 versions. If FORCE is set, then we skip this check; we use this
346 the second time around, if we couldn't find any compatible
347 instance of the shared library. */
348
349 if (! force)
350 {
91d6fa6a 351 struct bfd_link_needed_list *needs;
252b5132 352
91d6fa6a 353 if (! bfd_elf_get_bfd_needed_list (abfd, &needs))
252b5132
RH
354 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
355
91d6fa6a 356 if (needs != NULL)
252b5132 357 {
91d6fa6a 358 global_vercheck_needed = needs;
b34976b6 359 global_vercheck_failed = FALSE;
252b5132
RH
360 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
361 if (global_vercheck_failed)
362 {
cde43e70 363 bfd_close (abfd);
b34976b6 364 /* Return FALSE to force the caller to move on to try
0c7a8e5a 365 another file on the search path. */
b34976b6 366 return FALSE;
252b5132
RH
367 }
368
369 /* But wait! It gets much worse. On Linux, if a shared
0c7a8e5a
AM
370 library does not use libc at all, we are supposed to skip
371 it the first time around in case we encounter a shared
372 library later on with the same name which does use the
373 version of libc that we want. This is much too horrible
374 to use on any system other than Linux. */
252b5132
RH
375
376EOF
377case ${target} in
a5244b7e 378 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
92b93329 379 fragment <<EOF
252b5132
RH
380 {
381 struct bfd_link_needed_list *l;
382
91d6fa6a 383 for (l = needs; l != NULL; l = l->next)
0112cd26 384 if (CONST_STRNEQ (l->name, "libc.so"))
252b5132
RH
385 break;
386 if (l == NULL)
387 {
cde43e70 388 bfd_close (abfd);
b34976b6 389 return FALSE;
252b5132
RH
390 }
391 }
392
393EOF
394 ;;
395esac
92b93329 396fragment <<EOF
252b5132
RH
397 }
398 }
399
400 /* We've found a dynamic object matching the DT_NEEDED entry. */
401
04925e1e
AM
402 /* We have already checked that there is no other input file of the
403 same name. We must now check again that we are not including the
404 same file twice. We need to do this because on many systems
405 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
406 reference libc.so.1. If we have already included libc.so, we
407 don't want to include libc.so.1 if they are the same file, and we
408 can only check that using stat. */
409
410 if (bfd_stat (abfd, &global_stat) != 0)
411 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
ec4eb78a
L
412
413 /* First strip off everything before the last '/'. */
fed2999d 414 soname = lbasename (abfd->filename);
ec4eb78a 415
cd6f1cf3 416 if (verbose)
ec4eb78a
L
417 info_msg (_("found %s at %s\n"), soname, name);
418
e13629bc 419 global_found = NULL;
04925e1e 420 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
e13629bc 421 if (global_found != NULL)
04925e1e 422 {
b34976b6 423 /* Return TRUE to indicate that we found the file, even though
0c7a8e5a 424 we aren't going to do anything with it. */
b34976b6 425 return TRUE;
04925e1e
AM
426 }
427
4a43e768
AM
428 /* Specify the soname to use. */
429 bfd_elf_set_dt_needed_name (abfd, soname);
04925e1e 430
4a43e768
AM
431 /* Tell the ELF linker that we don't want the output file to have a
432 DT_NEEDED entry for this file, unless it is used to resolve
433 references in a regular object. */
96d56e9f 434 link_class = DYN_DT_NEEDED;
e56f61be
L
435
436 /* Tell the ELF linker that we don't want the output file to have a
437 DT_NEEDED entry for this file at all if the entry is from a file
438 with DYN_NO_ADD_NEEDED. */
7e9f0867
AM
439 if (needed->by != NULL
440 && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
96d56e9f 441 link_class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
e56f61be 442
1e9cc1c2 443 bfd_elf_set_dyn_lib_class (abfd, (enum dynamic_lib_link_class) link_class);
04925e1e
AM
444
445 /* Add this file into the symbol table. */
446 if (! bfd_link_add_symbols (abfd, &link_info))
8ff4c1f3 447 einfo ("%F%B: error adding symbols: %E\n", abfd);
04925e1e 448
b34976b6 449 return TRUE;
04925e1e
AM
450}
451
452
453/* Search for a needed file in a path. */
454
b34976b6 455static bfd_boolean
e56f61be
L
456gld${EMULATION_NAME}_search_needed (const char *path,
457 struct dt_needed *n, int force)
04925e1e
AM
458{
459 const char *s;
e56f61be 460 const char *name = n->name;
04925e1e 461 size_t len;
e56f61be 462 struct dt_needed needed;
04925e1e 463
cc5ce052 464 if (name[0] == '/')
e56f61be 465 return gld${EMULATION_NAME}_try_needed (n, force);
cc5ce052 466
04925e1e 467 if (path == NULL || *path == '\0')
b34976b6 468 return FALSE;
e56f61be
L
469
470 needed.by = n->by;
471 needed.name = n->name;
472
04925e1e
AM
473 len = strlen (name);
474 while (1)
475 {
476 char *filename, *sset;
477
c76308d2 478 s = strchr (path, config.rpath_separator);
04925e1e
AM
479 if (s == NULL)
480 s = path + strlen (path);
481
07f1e47a
AM
482#if HAVE_DOS_BASED_FILE_SYSTEM
483 /* Assume a match on the second char is part of drive specifier. */
484 else if (config.rpath_separator == ':'
485 && s == path + 1
486 && ISALPHA (*path))
487 {
488 s = strchr (s + 1, config.rpath_separator);
489 if (s == NULL)
490 s = path + strlen (path);
491 }
492#endif
04925e1e
AM
493 filename = (char *) xmalloc (s - path + len + 2);
494 if (s == path)
495 sset = filename;
496 else
497 {
498 memcpy (filename, path, s - path);
499 filename[s - path] = '/';
500 sset = filename + (s - path) + 1;
501 }
502 strcpy (sset, name);
503
e56f61be
L
504 needed.name = filename;
505 if (gld${EMULATION_NAME}_try_needed (&needed, force))
b34976b6 506 return TRUE;
04925e1e
AM
507
508 free (filename);
509
510 if (*s == '\0')
511 break;
512 path = s + 1;
513 }
514
b34976b6 515 return FALSE;
04925e1e
AM
516}
517
518EOF
9c8ebd6a 519if [ "x${USE_LIBPATH}" = xyes ] ; then
92b93329 520 fragment <<EOF
9c8ebd6a 521
c76308d2
RS
522/* Add the sysroot to every entry in a path separated by
523 config.rpath_separator. */
9c8ebd6a
DJ
524
525static char *
0c7a8e5a 526gld${EMULATION_NAME}_add_sysroot (const char *path)
9c8ebd6a
DJ
527{
528 int len, colons, i;
529 char *ret, *p;
530
531 len = strlen (path);
532 colons = 0;
533 i = 0;
534 while (path[i])
c76308d2 535 if (path[i++] == config.rpath_separator)
9c8ebd6a
DJ
536 colons++;
537
538 if (path[i])
539 colons++;
540
42644a89 541 len = len + (colons + 1) * strlen (ld_sysroot);
9c8ebd6a
DJ
542 ret = xmalloc (len + 1);
543 strcpy (ret, ld_sysroot);
544 p = ret + strlen (ret);
545 i = 0;
546 while (path[i])
c76308d2 547 if (path[i] == config.rpath_separator)
9c8ebd6a 548 {
0c7a8e5a 549 *p++ = path[i++];
9c8ebd6a
DJ
550 strcpy (p, ld_sysroot);
551 p = p + strlen (p);
9c8ebd6a
DJ
552 }
553 else
554 *p++ = path[i++];
555
556 *p = 0;
557 return ret;
558}
04925e1e 559
3dc16cab
DJ
560EOF
561 case ${target} in
ebe1fac1 562 *-*-freebsd* | *-*-dragonfly*)
92b93329 563 fragment <<EOF
ebe1fac1
NC
564/* Read the system search path the FreeBSD way rather than the Linux way. */
565#ifdef HAVE_ELF_HINTS_H
566#include <elf-hints.h>
567#else
568#include "elf-hints-local.h"
569#endif
570
571static bfd_boolean
d5c8b1f8
AM
572gld${EMULATION_NAME}_check_ld_elf_hints (const struct bfd_link_needed_list *l,
573 int force)
ebe1fac1
NC
574{
575 static bfd_boolean initialized;
576 static char *ld_elf_hints;
577 struct dt_needed needed;
578
579 if (!initialized)
580 {
581 FILE *f;
582 char *tmppath;
583
ff7a0acf 584 tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, (const char *) NULL);
ebe1fac1
NC
585 f = fopen (tmppath, FOPEN_RB);
586 free (tmppath);
587 if (f != NULL)
588 {
589 struct elfhints_hdr hdr;
590
591 if (fread (&hdr, 1, sizeof (hdr), f) == sizeof (hdr)
592 && hdr.magic == ELFHINTS_MAGIC
593 && hdr.version == 1)
594 {
595 if (fseek (f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1)
596 {
597 char *b;
598
599 b = xmalloc (hdr.dirlistlen + 1);
600 if (fread (b, 1, hdr.dirlistlen + 1, f) ==
601 hdr.dirlistlen + 1)
602 ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b);
e13629bc 603
ebe1fac1
NC
604 free (b);
605 }
606 }
607 fclose (f);
608 }
609
610 initialized = TRUE;
611 }
612
613 if (ld_elf_hints == NULL)
614 return FALSE;
615
d5c8b1f8
AM
616 needed.by = l->by;
617 needed.name = l->name;
618 return gld${EMULATION_NAME}_search_needed (ld_elf_hints, &needed, force);
ebe1fac1
NC
619}
620EOF
621 # FreeBSD
622 ;;
623
a5244b7e 624 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
92b93329 625 fragment <<EOF
04925e1e
AM
626/* For a native linker, check the file /etc/ld.so.conf for directories
627 in which we may find shared libraries. /etc/ld.so.conf is really
482e8b32 628 only meaningful on Linux. */
04925e1e 629
d3989512 630struct gld${EMULATION_NAME}_ld_so_conf
04925e1e 631{
d3989512
JJ
632 char *path;
633 size_t len, alloc;
634};
04925e1e 635
dfcffada 636static bfd_boolean
d3989512
JJ
637gld${EMULATION_NAME}_parse_ld_so_conf
638 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
639
640static void
641gld${EMULATION_NAME}_parse_ld_so_conf_include
642 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
643 const char *pattern)
644{
645 char *newp = NULL;
0b48acfe 646#ifdef HAVE_GLOB
d3989512 647 glob_t gl;
0b48acfe 648#endif
d3989512
JJ
649
650 if (pattern[0] != '/')
04925e1e 651 {
d3989512
JJ
652 char *p = strrchr (filename, '/');
653 size_t patlen = strlen (pattern) + 1;
04925e1e 654
d3989512
JJ
655 newp = xmalloc (p - filename + 1 + patlen);
656 memcpy (newp, filename, p - filename + 1);
657 memcpy (newp + (p - filename + 1), pattern, patlen);
658 pattern = newp;
659 }
04925e1e 660
0b48acfe 661#ifdef HAVE_GLOB
d3989512
JJ
662 if (glob (pattern, 0, NULL, &gl) == 0)
663 {
664 size_t i;
665
666 for (i = 0; i < gl.gl_pathc; ++i)
667 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
668 globfree (&gl);
669 }
0b48acfe
MM
670#else
671 /* If we do not have glob, treat the pattern as a literal filename. */
672 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
673#endif
d3989512
JJ
674
675 if (newp)
676 free (newp);
677}
678
dfcffada 679static bfd_boolean
d3989512
JJ
680gld${EMULATION_NAME}_parse_ld_so_conf
681 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
682{
683 FILE *f = fopen (filename, FOPEN_RT);
563f4125
JJ
684 char *line;
685 size_t linelen;
d3989512
JJ
686
687 if (f == NULL)
dfcffada 688 return FALSE;
d3989512 689
563f4125
JJ
690 linelen = 256;
691 line = xmalloc (linelen);
692 do
d3989512 693 {
563f4125
JJ
694 char *p = line, *q;
695
696 /* Normally this would use getline(3), but we need to be portable. */
697 while ((q = fgets (p, linelen - (p - line), f)) != NULL
698 && strlen (q) == linelen - (p - line) - 1
699 && line[linelen - 2] != '\n')
700 {
701 line = xrealloc (line, 2 * linelen);
702 p = line + linelen - 1;
703 linelen += linelen;
704 }
705
706 if (q == NULL && p == line)
707 break;
d3989512
JJ
708
709 p = strchr (line, '\n');
710 if (p)
711 *p = '\0';
712
713 /* Because the file format does not know any form of quoting we
714 can search forward for the next '#' character and if found
715 make it terminating the line. */
716 p = strchr (line, '#');
717 if (p)
718 *p = '\0';
719
720 /* Remove leading whitespace. NUL is no whitespace character. */
721 p = line;
722 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
723 ++p;
724
725 /* If the line is blank it is ignored. */
726 if (p[0] == '\0')
727 continue;
04925e1e 728
0112cd26 729 if (CONST_STRNEQ (p, "include") && (p[7] == ' ' || p[7] == '\t'))
d3989512
JJ
730 {
731 char *dir, c;
732 p += 8;
733 do
04925e1e 734 {
d3989512
JJ
735 while (*p == ' ' || *p == '\t')
736 ++p;
04925e1e 737
d3989512
JJ
738 if (*p == '\0')
739 break;
252b5132 740
d3989512
JJ
741 dir = p;
742
743 while (*p != ' ' && *p != '\t' && *p)
744 ++p;
745
746 c = *p;
747 *p++ = '\0';
748 if (dir[0] != '\0')
749 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
750 dir);
751 }
752 while (c != '\0');
753 }
754 else
755 {
756 char *dir = p;
757 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
758 && *p != '\r' && *p != '\v')
759 ++p;
760
761 while (p != dir && p[-1] == '/')
762 --p;
763 if (info->path == NULL)
764 {
765 info->alloc = p - dir + 1 + 256;
766 info->path = xmalloc (info->alloc);
767 info->len = 0;
768 }
04925e1e
AM
769 else
770 {
d3989512
JJ
771 if (info->len + 1 + (p - dir) >= info->alloc)
772 {
773 info->alloc += p - dir + 256;
774 info->path = xrealloc (info->path, info->alloc);
775 }
c76308d2 776 info->path[info->len++] = config.rpath_separator;
04925e1e 777 }
d3989512
JJ
778 memcpy (info->path + info->len, dir, p - dir);
779 info->len += p - dir;
780 info->path[info->len] = '\0';
781 }
782 }
563f4125 783 while (! feof (f));
d3989512
JJ
784 free (line);
785 fclose (f);
dfcffada 786 return TRUE;
d3989512 787}
252b5132 788
d3989512 789static bfd_boolean
d5c8b1f8
AM
790gld${EMULATION_NAME}_check_ld_so_conf (const struct bfd_link_needed_list *l,
791 int force)
d3989512
JJ
792{
793 static bfd_boolean initialized;
794 static char *ld_so_conf;
795 struct dt_needed needed;
252b5132 796
d3989512
JJ
797 if (! initialized)
798 {
799 char *tmppath;
800 struct gld${EMULATION_NAME}_ld_so_conf info;
9c8ebd6a 801
d3989512
JJ
802 info.path = NULL;
803 info.len = info.alloc = 0;
ff7a0acf
AM
804 tmppath = concat (ld_sysroot, "${prefix}/etc/ld.so.conf",
805 (const char *) NULL);
dfcffada
AM
806 if (!gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath))
807 {
808 free (tmppath);
ff7a0acf
AM
809 tmppath = concat (ld_sysroot, "/etc/ld.so.conf",
810 (const char *) NULL);
dfcffada
AM
811 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
812 }
d3989512 813 free (tmppath);
dfcffada 814
d3989512
JJ
815 if (info.path)
816 {
817 char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
818 free (info.path);
819 ld_so_conf = d;
04925e1e 820 }
b34976b6 821 initialized = TRUE;
04925e1e 822 }
49e56c49 823
04925e1e 824 if (ld_so_conf == NULL)
b34976b6 825 return FALSE;
252b5132 826
e56f61be 827
d5c8b1f8
AM
828 needed.by = l->by;
829 needed.name = l->name;
e56f61be 830 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
252b5132
RH
831}
832
04925e1e 833EOF
9c8ebd6a
DJ
834 # Linux
835 ;;
04925e1e
AM
836 esac
837fi
92b93329 838fragment <<EOF
04925e1e 839
252b5132
RH
840/* See if an input file matches a DT_NEEDED entry by name. */
841
842static void
0c7a8e5a 843gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
252b5132 844{
e13629bc
AM
845 const char *soname;
846
847 /* Stop looking if we've found a loaded lib. */
848 if (global_found != NULL
849 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
850 & DYN_AS_NEEDED) == 0)
252b5132
RH
851 return;
852
e13629bc
AM
853 if (s->filename == NULL || s->the_bfd == NULL)
854 return;
855
856 /* Don't look for a second non-loaded as-needed lib. */
857 if (global_found != NULL
858 && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
7cedef86
AM
859 return;
860
42627821 861 if (filename_cmp (s->filename, global_needed->name) == 0)
252b5132 862 {
e13629bc
AM
863 global_found = s;
864 return;
865 }
577a0623 866
66be1055 867 if (s->flags.search_dirs)
e13629bc
AM
868 {
869 const char *f = strrchr (s->filename, '/');
870 if (f != NULL
42627821 871 && filename_cmp (f + 1, global_needed->name) == 0)
577a0623 872 {
e13629bc 873 global_found = s;
577a0623
AM
874 return;
875 }
252b5132
RH
876 }
877
e13629bc
AM
878 soname = bfd_elf_get_dt_soname (s->the_bfd);
879 if (soname != NULL
42627821 880 && filename_cmp (soname, global_needed->name) == 0)
252b5132 881 {
e13629bc
AM
882 global_found = s;
883 return;
252b5132 884 }
252b5132
RH
885}
886
41392f03
AM
887EOF
888
889if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
92b93329 890fragment <<EOF
04925e1e 891
24382dca 892static bfd_size_type
677e5a92 893id_note_section_size (bfd *abfd ATTRIBUTE_UNUSED)
24382dca 894{
30e8ee25 895 const char *style = emit_note_gnu_build_id;
24382dca 896 bfd_size_type size;
61e2488c 897 bfd_size_type build_id_size;
24382dca 898
24382dca
RM
899 size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
900 size = (size + 3) & -(bfd_size_type) 4;
901
61e2488c
JT
902 build_id_size = compute_build_id_size (style);
903 if (build_id_size)
904 size += build_id_size;
24382dca
RM
905 else
906 size = 0;
907
908 return size;
909}
910
24382dca 911static bfd_boolean
30e8ee25 912write_build_id (bfd *abfd)
24382dca
RM
913{
914 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
30e8ee25
AM
915 struct elf_obj_tdata *t = elf_tdata (abfd);
916 const char *style;
24382dca
RM
917 asection *asec;
918 Elf_Internal_Shdr *i_shdr;
919 unsigned char *contents, *id_bits;
920 bfd_size_type size;
30e8ee25 921 file_ptr position;
24382dca
RM
922 Elf_External_Note *e_note;
923
c0355132
AM
924 style = t->o->build_id.style;
925 asec = t->o->build_id.sec;
83e4970b 926 if (bfd_is_abs_section (asec->output_section))
24382dca 927 {
83e4970b
AM
928 einfo (_("%P: warning: .note.gnu.build-id section discarded,"
929 " --build-id ignored.\n"));
930 return TRUE;
24382dca
RM
931 }
932 i_shdr = &elf_section_data (asec->output_section)->this_hdr;
933
934 if (i_shdr->contents == NULL)
935 {
b2ff8454 936 if (asec->contents == NULL)
1e9cc1c2 937 asec->contents = (unsigned char *) xmalloc (asec->size);
b2ff8454 938 contents = asec->contents;
24382dca 939 }
b2ff8454
RM
940 else
941 contents = i_shdr->contents + asec->output_offset;
24382dca 942
1e9cc1c2 943 e_note = (Elf_External_Note *) contents;
24382dca
RM
944 size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
945 size = (size + 3) & -(bfd_size_type) 4;
946 id_bits = contents + size;
947 size = asec->size - size;
948
949 bfd_h_put_32 (abfd, sizeof "GNU", &e_note->namesz);
950 bfd_h_put_32 (abfd, size, &e_note->descsz);
951 bfd_h_put_32 (abfd, NT_GNU_BUILD_ID, &e_note->type);
952 memcpy (e_note->name, "GNU", sizeof "GNU");
953
61e2488c 954 generate_build_id (abfd, style, bed->s->checksum_contents, id_bits, size);
24382dca 955
30e8ee25 956 position = i_shdr->sh_offset + asec->output_offset;
b2ff8454 957 size = asec->size;
30e8ee25 958 return (bfd_seek (abfd, position, SEEK_SET) == 0
b2ff8454 959 && bfd_bwrite (contents, size, abfd) == size);
24382dca
RM
960}
961
30e8ee25
AM
962/* Make .note.gnu.build-id section, and set up elf_tdata->build_id. */
963
964static bfd_boolean
965setup_build_id (bfd *ibfd)
966{
967 asection *s;
968 bfd_size_type size;
969 flagword flags;
970
971 size = id_note_section_size (ibfd);
972 if (size == 0)
973 {
974 einfo ("%P: warning: unrecognized --build-id style ignored.\n");
975 return FALSE;
976 }
977
978 flags = (SEC_ALLOC | SEC_LOAD | SEC_IN_MEMORY
979 | SEC_LINKER_CREATED | SEC_READONLY | SEC_DATA);
980 s = bfd_make_section_with_flags (ibfd, ".note.gnu.build-id", flags);
981 if (s != NULL && bfd_set_section_alignment (ibfd, s, 2))
982 {
983 struct elf_obj_tdata *t = elf_tdata (link_info.output_bfd);
c0355132
AM
984 t->o->build_id.after_write_object_contents = &write_build_id;
985 t->o->build_id.style = emit_note_gnu_build_id;
986 t->o->build_id.sec = s;
987 elf_section_type (s) = SHT_NOTE;
988 s->size = size;
989 return TRUE;
30e8ee25
AM
990 }
991
992 einfo ("%P: warning: Cannot create .note.gnu.build-id section,"
993 " --build-id ignored.\n");
994 return FALSE;
995}
24382dca 996
04925e1e 997/* This is called after all the input files have been opened. */
252b5132
RH
998
999static void
0c7a8e5a 1000gld${EMULATION_NAME}_after_open (void)
252b5132 1001{
04925e1e 1002 struct bfd_link_needed_list *needed, *l;
d10e7fcc
AM
1003 struct elf_link_hash_table *htab;
1004
5c3049d2
AM
1005 after_open_default ();
1006
d10e7fcc
AM
1007 htab = elf_hash_table (&link_info);
1008 if (!is_elf_hash_table (htab))
1009 return;
252b5132 1010
30e8ee25 1011 if (emit_note_gnu_build_id != NULL)
c0065db7
RM
1012 {
1013 bfd *abfd;
c0065db7 1014
a654efd6
L
1015 /* Find an ELF input. */
1016 for (abfd = link_info.input_bfds;
c72f2fb2 1017 abfd != (bfd *) NULL; abfd = abfd->link.next)
a654efd6
L
1018 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1019 break;
c0065db7 1020
30e8ee25
AM
1021 /* PR 10555: If there are no ELF input files do not try to
1022 create a .note.gnu-build-id section. */
1023 if (abfd == NULL
1024 || !setup_build_id (abfd))
c0065db7 1025 {
30e8ee25
AM
1026 free ((char *) emit_note_gnu_build_id);
1027 emit_note_gnu_build_id = NULL;
c0065db7
RM
1028 }
1029 }
1030
d10e7fcc 1031 if (link_info.relocatable)
76f0cad6
NC
1032 {
1033 if (link_info.execstack == ! link_info.noexecstack)
1034 /* PR ld/16744: If "-z [no]execstack" has been specified on the
1035 command line and we are perfoming a relocatable link then no
1036 PT_GNU_STACK segment will be created and so the
1037 linkinfo.[no]execstack values set in _handle_option() will have no
1038 effect. Instead we create a .note.GNU-stack section in much the
1039 same way as the assembler does with its --[no]execstack option. */
1040 (void) bfd_make_section_with_flags (link_info.input_bfds,
1041 ".note.GNU-stack",
1042 SEC_READONLY | (link_info.execstack ? SEC_CODE : 0));
1043
1044 return;
1045 }
d10e7fcc 1046
eb3d5f3b 1047 if (link_info.eh_frame_hdr
d10e7fcc 1048 && !link_info.traditional_format)
eb3d5f3b 1049 {
a654efd6
L
1050 bfd *abfd, *elfbfd = NULL;
1051 bfd_boolean warn_eh_frame = FALSE;
d10e7fcc 1052 asection *s;
eb3d5f3b 1053
c72f2fb2 1054 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link.next)
eb3d5f3b 1055 {
a654efd6
L
1056 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1057 elfbfd = abfd;
4440bb77
L
1058 if (!warn_eh_frame)
1059 {
1060 s = bfd_get_section_by_name (abfd, ".eh_frame");
9cf8b46e
AM
1061 while (s != NULL
1062 && (s->size <= 8
1063 || bfd_is_abs_section (s->output_section)))
1064 s = bfd_get_next_section_by_name (s);
1065 warn_eh_frame = s != NULL;
4440bb77
L
1066 }
1067 if (elfbfd && warn_eh_frame)
1068 break;
d10e7fcc 1069 }
a654efd6 1070 if (elfbfd)
d10e7fcc
AM
1071 {
1072 const struct elf_backend_data *bed;
1073
a654efd6
L
1074 bed = get_elf_backend_data (elfbfd);
1075 s = bfd_make_section_with_flags (elfbfd, ".eh_frame_hdr",
1076 bed->dynamic_sec_flags
1077 | SEC_READONLY);
d10e7fcc 1078 if (s != NULL
a654efd6
L
1079 && bfd_set_section_alignment (elfbfd, s, 2))
1080 {
1081 htab->eh_info.hdr_sec = s;
1082 warn_eh_frame = FALSE;
1083 }
eb3d5f3b 1084 }
a654efd6
L
1085 if (warn_eh_frame)
1086 einfo ("%P: warning: Cannot create .eh_frame_hdr section,"
1087 " --eh-frame-hdr ignored.\n");
eb3d5f3b
JB
1088 }
1089
04925e1e
AM
1090 /* Get the list of files which appear in DT_NEEDED entries in
1091 dynamic objects included in the link (often there will be none).
1092 For each such file, we want to track down the corresponding
1093 library, and include the symbol table in the link. This is what
1094 the runtime dynamic linker will do. Tracking the files down here
1095 permits one dynamic object to include another without requiring
1096 special action by the person doing the link. Note that the
1097 needed list can actually grow while we are stepping through this
1098 loop. */
f13a99db 1099 needed = bfd_elf_get_needed_list (link_info.output_bfd, &link_info);
04925e1e 1100 for (l = needed; l != NULL; l = l->next)
252b5132 1101 {
04925e1e 1102 struct bfd_link_needed_list *ll;
e56f61be 1103 struct dt_needed n, nn;
04925e1e 1104 int force;
252b5132 1105
7e9f0867 1106 /* If the lib that needs this one was --as-needed and wasn't
4706eab9 1107 found to be needed, then this lib isn't needed either. */
7e9f0867 1108 if (l->by != NULL
4706eab9
AM
1109 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
1110 continue;
1111
1112 /* Skip the lib if --no-copy-dt-needed-entries and
1113 --allow-shlib-undefined is in effect. */
1114 if (l->by != NULL
1115 && link_info.unresolved_syms_in_shared_libs == RM_IGNORE
1116 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_NO_ADD_NEEDED) != 0)
7e9f0867
AM
1117 continue;
1118
04925e1e
AM
1119 /* If we've already seen this file, skip it. */
1120 for (ll = needed; ll != l; ll = ll->next)
7e9f0867
AM
1121 if ((ll->by == NULL
1122 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
1123 && strcmp (ll->name, l->name) == 0)
04925e1e
AM
1124 break;
1125 if (ll != l)
1126 continue;
252b5132 1127
04925e1e
AM
1128 /* See if this file was included in the link explicitly. */
1129 global_needed = l;
e13629bc 1130 global_found = NULL;
04925e1e 1131 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
e13629bc
AM
1132 if (global_found != NULL
1133 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
1134 & DYN_AS_NEEDED) == 0)
04925e1e 1135 continue;
252b5132 1136
e56f61be
L
1137 n.by = l->by;
1138 n.name = l->name;
1139 nn.by = l->by;
cd6f1cf3 1140 if (verbose)
ec4eb78a
L
1141 info_msg (_("%s needed by %B\n"), l->name, l->by);
1142
e13629bc
AM
1143 /* As-needed libs specified on the command line (or linker script)
1144 take priority over libs found in search dirs. */
1145 if (global_found != NULL)
1146 {
1147 nn.name = global_found->filename;
1148 if (gld${EMULATION_NAME}_try_needed (&nn, TRUE))
1149 continue;
1150 }
1151
04925e1e
AM
1152 /* We need to find this file and include the symbol table. We
1153 want to search for the file in the same way that the dynamic
1154 linker will search. That means that we want to use
1155 rpath_link, rpath, then the environment variable
ec4eb78a
L
1156 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
1157 entries (native only), then the linker script LIB_SEARCH_DIRS.
1158 We do not search using the -L arguments.
252b5132 1159
04925e1e
AM
1160 We search twice. The first time, we skip objects which may
1161 introduce version mismatches. The second time, we force
1162 their use. See gld${EMULATION_NAME}_vercheck comment. */
1163 for (force = 0; force < 2; force++)
1164 {
04925e1e
AM
1165 size_t len;
1166 search_dirs_type *search;
6dd8c765 1167EOF
ff925e69 1168if [ "x${NATIVE}" = xyes ] ; then
92b93329 1169fragment <<EOF
dcb0bd0e 1170 const char *lib_path;
ff925e69
KK
1171EOF
1172fi
1173if [ "x${USE_LIBPATH}" = xyes ] ; then
92b93329 1174fragment <<EOF
6dd8c765
L
1175 struct bfd_link_needed_list *rp;
1176 int found;
1177EOF
6dd8c765 1178fi
92b93329 1179fragment <<EOF
252b5132 1180
04925e1e 1181 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
e56f61be 1182 &n, force))
04925e1e 1183 break;
dcb0bd0e 1184EOF
9c8ebd6a 1185if [ "x${USE_LIBPATH}" = xyes ] ; then
92b93329 1186fragment <<EOF
04925e1e 1187 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
e56f61be 1188 &n, force))
04925e1e 1189 break;
9c8ebd6a
DJ
1190EOF
1191fi
1192if [ "x${NATIVE}" = xyes ] ; then
92b93329 1193fragment <<EOF
04925e1e
AM
1194 if (command_line.rpath_link == NULL
1195 && command_line.rpath == NULL)
1196 {
1197 lib_path = (const char *) getenv ("LD_RUN_PATH");
e56f61be 1198 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
04925e1e
AM
1199 force))
1200 break;
1201 }
04925e1e 1202 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
e56f61be 1203 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
04925e1e 1204 break;
9c8ebd6a
DJ
1205EOF
1206fi
1207if [ "x${USE_LIBPATH}" = xyes ] ; then
92b93329 1208fragment <<EOF
ec4eb78a 1209 found = 0;
f13a99db 1210 rp = bfd_elf_get_runpath_list (link_info.output_bfd, &link_info);
6dd8c765 1211 for (; !found && rp != NULL; rp = rp->next)
ec4eb78a 1212 {
9c8ebd6a 1213 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
ec4eb78a 1214 found = (rp->by == l->by
9c8ebd6a 1215 && gld${EMULATION_NAME}_search_needed (tmpname,
e56f61be 1216 &n,
ec4eb78a 1217 force));
9c8ebd6a 1218 free (tmpname);
ec4eb78a
L
1219 }
1220 if (found)
1221 break;
1222
04925e1e 1223EOF
04925e1e 1224fi
c1446dba
L
1225if [ "x${USE_LIBPATH}" = xyes ] ; then
1226 case ${target} in
ebe1fac1 1227 *-*-freebsd* | *-*-dragonfly*)
92b93329 1228 fragment <<EOF
d5c8b1f8 1229 if (gld${EMULATION_NAME}_check_ld_elf_hints (l, force))
ebe1fac1
NC
1230 break;
1231EOF
1232 # FreeBSD
1233 ;;
1234
a5244b7e 1235 *-*-linux-* | *-*-k*bsd*-* | *-*-gnu*)
92b93329 1236 fragment <<EOF
d5c8b1f8 1237 if (gld${EMULATION_NAME}_check_ld_so_conf (l, force))
c1446dba
L
1238 break;
1239
1240EOF
eeaa4577 1241 # Linux
c1446dba
L
1242 ;;
1243 esac
1244fi
92b93329 1245fragment <<EOF
04925e1e
AM
1246 len = strlen (l->name);
1247 for (search = search_head; search != NULL; search = search->next)
1248 {
1249 char *filename;
252b5132 1250
04925e1e
AM
1251 if (search->cmdline)
1252 continue;
1253 filename = (char *) xmalloc (strlen (search->name) + len + 2);
1254 sprintf (filename, "%s/%s", search->name, l->name);
e56f61be
L
1255 nn.name = filename;
1256 if (gld${EMULATION_NAME}_try_needed (&nn, force))
04925e1e
AM
1257 break;
1258 free (filename);
1259 }
1260 if (search != NULL)
1261 break;
1262EOF
92b93329 1263fragment <<EOF
04925e1e 1264 }
252b5132 1265
04925e1e
AM
1266 if (force < 2)
1267 continue;
252b5132 1268
e374f1d9 1269 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
04925e1e
AM
1270 l->name, l->by);
1271 }
1272}
252b5132 1273
41392f03
AM
1274EOF
1275fi
1276
92b93329 1277fragment <<EOF
252b5132 1278
04925e1e 1279/* Look through an expression for an assignment statement. */
252b5132 1280
04925e1e 1281static void
0c7a8e5a 1282gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
04925e1e 1283{
4ea42fb7 1284 bfd_boolean provide = FALSE;
04925e1e
AM
1285
1286 switch (exp->type.node_class)
252b5132 1287 {
04925e1e 1288 case etree_provide:
bded3693 1289 case etree_provided:
4ea42fb7
AM
1290 provide = TRUE;
1291 /* Fall thru */
1292 case etree_assign:
04925e1e
AM
1293 /* We call record_link_assignment even if the symbol is defined.
1294 This is because if it is defined by a dynamic object, we
1295 actually want to use the value defined by the linker script,
1296 not the value from the dynamic object (because we are setting
1297 symbols like etext). If the symbol is defined by a regular
1298 object, then, as it happens, calling record_link_assignment
1299 will do no harm. */
04925e1e 1300 if (strcmp (exp->assign.dst, ".") != 0)
252b5132 1301 {
f13a99db
AM
1302 if (!bfd_elf_record_link_assignment (link_info.output_bfd,
1303 &link_info,
fe21a8fc
L
1304 exp->assign.dst, provide,
1305 exp->assign.hidden))
04925e1e
AM
1306 einfo ("%P%F: failed to record assignment to %s: %E\n",
1307 exp->assign.dst);
252b5132 1308 }
04925e1e
AM
1309 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1310 break;
252b5132 1311
04925e1e
AM
1312 case etree_binary:
1313 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1314 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1315 break;
252b5132 1316
04925e1e
AM
1317 case etree_trinary:
1318 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1319 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1320 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1321 break;
252b5132 1322
04925e1e
AM
1323 case etree_unary:
1324 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1325 break;
252b5132 1326
04925e1e
AM
1327 default:
1328 break;
252b5132
RH
1329 }
1330}
1331
04925e1e
AM
1332
1333/* This is called by the before_allocation routine via
1334 lang_for_each_statement. It locates any assignment statements, and
1335 tells the ELF backend about them, in case they are assignments to
1336 symbols which are referred to by dynamic objects. */
1337
1338static void
0c7a8e5a 1339gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
04925e1e
AM
1340{
1341 if (s->header.type == lang_assignment_statement_enum)
1342 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1343}
1344
41392f03
AM
1345EOF
1346
1347if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
57e6abd2
AO
1348 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1349 ELF_INTERPRETER_SET_DEFAULT="
1350 if (sinterp != NULL)
1351 {
5718918d
AM
1352 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1353 sinterp->size = strlen ((char *) sinterp->contents) + 1;
57e6abd2
AO
1354 }
1355
1356"
1357 else
1358 ELF_INTERPRETER_SET_DEFAULT=
1359 fi
92b93329 1360fragment <<EOF
04925e1e 1361
7ee314fa 1362/* used by before_allocation and handle_option. */
4724d37e 1363static void
91d6fa6a 1364gld${EMULATION_NAME}_append_to_separated_string (char **to, char *op_arg)
7ee314fa
AM
1365{
1366 if (*to == NULL)
91d6fa6a 1367 *to = xstrdup (op_arg);
7ee314fa
AM
1368 else
1369 {
1370 size_t to_len = strlen (*to);
91d6fa6a 1371 size_t op_arg_len = strlen (op_arg);
7ee314fa
AM
1372 char *buf;
1373 char *cp = *to;
1374
1375 /* First see whether OPTARG is already in the path. */
1376 do
1377 {
91d6fa6a
NC
1378 if (strncmp (op_arg, cp, op_arg_len) == 0
1379 && (cp[op_arg_len] == 0
1380 || cp[op_arg_len] == config.rpath_separator))
7ee314fa
AM
1381 /* We found it. */
1382 break;
1383
1384 /* Not yet found. */
1385 cp = strchr (cp, config.rpath_separator);
1386 if (cp != NULL)
1387 ++cp;
1388 }
1389 while (cp != NULL);
1390
1391 if (cp == NULL)
1392 {
91d6fa6a 1393 buf = xmalloc (to_len + op_arg_len + 2);
7ee314fa 1394 sprintf (buf, "%s%c%s", *to,
91d6fa6a 1395 config.rpath_separator, op_arg);
7ee314fa
AM
1396 free (*to);
1397 *to = buf;
1398 }
1399 }
1400}
1401
252b5132
RH
1402/* This is called after the sections have been attached to output
1403 sections, but before any sizes or addresses have been set. */
1404
1405static void
0c7a8e5a 1406gld${EMULATION_NAME}_before_allocation (void)
252b5132
RH
1407{
1408 const char *rpath;
1409 asection *sinterp;
7ee314fa 1410 bfd *abfd;
4199e3b8 1411 struct elf_link_hash_entry *ehdr_start = NULL;
f9c316c4 1412 struct bfd_link_hash_entry ehdr_start_save = ehdr_start_save;
252b5132 1413
b4d040b1 1414 if (is_elf_hash_table (link_info.hash))
a5382c42
MR
1415 {
1416 _bfd_elf_tls_setup (link_info.output_bfd, &link_info);
e1918d23 1417
cde7cb01
MR
1418 /* Make __ehdr_start hidden if it has been referenced, to
1419 prevent the symbol from being dynamic. */
c2763e27
RM
1420 if (!link_info.relocatable)
1421 {
1422 struct elf_link_hash_entry *h
1423 = elf_link_hash_lookup (elf_hash_table (&link_info), "__ehdr_start",
1424 FALSE, FALSE, TRUE);
1425
1426 /* Only adjust the export class if the symbol was referenced
1427 and not defined, otherwise leave it alone. */
1428 if (h != NULL
1429 && (h->root.type == bfd_link_hash_new
1430 || h->root.type == bfd_link_hash_undefined
1431 || h->root.type == bfd_link_hash_undefweak
1432 || h->root.type == bfd_link_hash_common))
1433 {
1434 _bfd_elf_link_hash_hide_symbol (&link_info, h, TRUE);
1435 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
1436 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
4199e3b8
AM
1437 /* Don't leave the symbol undefined. Undefined hidden
1438 symbols typically won't have dynamic relocations, but
1439 we most likely will need dynamic relocations for
1440 __ehdr_start if we are building a PIE or shared
1441 library. */
1442 ehdr_start = h;
1443 ehdr_start_save = h->root;
1444 h->root.type = bfd_link_hash_defined;
1445 h->root.u.def.section = bfd_abs_section_ptr;
1446 h->root.u.def.value = 0;
c2763e27
RM
1447 }
1448 }
cde7cb01 1449
a5382c42
MR
1450 /* If we are going to make any variable assignments, we need to
1451 let the ELF backend know about them in case the variables are
1452 referred to by dynamic objects. */
1453 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1454 }
252b5132
RH
1455
1456 /* Let the ELF backend work out the sizes of any sections required
1457 by dynamic linking. */
1458 rpath = command_line.rpath;
1459 if (rpath == NULL)
1460 rpath = (const char *) getenv ("LD_RUN_PATH");
7ee314fa 1461
c72f2fb2 1462 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link.next)
8dd881b6
L
1463 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1464 {
1465 const char *audit_libs = elf_dt_audit (abfd);
7ee314fa 1466
4724d37e 1467 /* If the input bfd contains an audit entry, we need to add it as
8dd881b6
L
1468 a dep audit entry. */
1469 if (audit_libs && *audit_libs != '\0')
1470 {
1471 char *cp = xstrdup (audit_libs);
1472 do
1473 {
1474 int more = 0;
1475 char *cp2 = strchr (cp, config.rpath_separator);
7ee314fa 1476
8dd881b6
L
1477 if (cp2)
1478 {
1479 *cp2 = '\0';
1480 more = 1;
1481 }
7ee314fa 1482
8dd881b6
L
1483 if (cp != NULL && *cp != '\0')
1484 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, cp);
1485
1486 cp = more ? ++cp2 : NULL;
1487 }
1488 while (cp != NULL);
1489 }
1490 }
7ee314fa 1491
5a580b3a 1492 if (! (bfd_elf_size_dynamic_sections
f13a99db 1493 (link_info.output_bfd, command_line.soname, rpath,
7ee314fa 1494 command_line.filter_shlib, audit, depaudit,
252b5132 1495 (const char * const *) command_line.auxiliary_filters,
fd91d419 1496 &link_info, &sinterp)))
252b5132 1497 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
8423293d 1498
57e6abd2 1499${ELF_INTERPRETER_SET_DEFAULT}
252b5132
RH
1500 /* Let the user override the dynamic linker we are using. */
1501 if (command_line.interpreter != NULL
1502 && sinterp != NULL)
1503 {
1504 sinterp->contents = (bfd_byte *) command_line.interpreter;
eea6121a 1505 sinterp->size = strlen (command_line.interpreter) + 1;
252b5132
RH
1506 }
1507
1508 /* Look for any sections named .gnu.warning. As a GNU extensions,
1509 we treat such sections as containing warning messages. We print
1510 out the warning message, and then zero out the section size so
1511 that it does not get copied into the output file. */
1512
1513 {
1514 LANG_FOR_EACH_INPUT_STATEMENT (is)
1515 {
1516 asection *s;
1517 bfd_size_type sz;
1518 char *msg;
b34976b6 1519 bfd_boolean ret;
252b5132 1520
66be1055 1521 if (is->flags.just_syms)
252b5132
RH
1522 continue;
1523
1524 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1525 if (s == NULL)
1526 continue;
1527
eea6121a 1528 sz = s->size;
1e9cc1c2 1529 msg = (char *) xmalloc ((size_t) (sz + 1));
bc251d50 1530 if (! bfd_get_section_contents (is->the_bfd, s, msg,
8c675694 1531 (file_ptr) 0, sz))
252b5132
RH
1532 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1533 is->the_bfd);
bc251d50 1534 msg[sz] = '\0';
252b5132
RH
1535 ret = link_info.callbacks->warning (&link_info, msg,
1536 (const char *) NULL,
1537 is->the_bfd, (asection *) NULL,
1538 (bfd_vma) 0);
1539 ASSERT (ret);
1540 free (msg);
1541
9e3be61d
AM
1542 /* Clobber the section size, so that we don't waste space
1543 copying the warning into the output file. If we've already
1544 sized the output section, adjust its size. The adjustment
1545 is on rawsize because targets that size sections early will
1546 have called lang_reset_memory_regions after sizing. */
1547 if (s->output_section != NULL
1548 && s->output_section->rawsize >= s->size)
1549 s->output_section->rawsize -= s->size;
1550
eea6121a 1551 s->size = 0;
11d2f718 1552
9e3be61d
AM
1553 /* Also set SEC_EXCLUDE, so that local symbols defined in the
1554 warning section don't get copied to the output. */
a14a5de3 1555 s->flags |= SEC_EXCLUDE | SEC_KEEP;
252b5132
RH
1556 }
1557 }
8423293d 1558
1e035701 1559 before_allocation_default ();
8423293d 1560
f13a99db 1561 if (!bfd_elf_size_dynsym_hash_dynstr (link_info.output_bfd, &link_info))
8423293d 1562 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
4199e3b8
AM
1563
1564 if (ehdr_start != NULL)
1565 {
1566 /* If we twiddled __ehdr_start to defined earlier, put it back
1567 as it was. */
1568 ehdr_start->root.type = ehdr_start_save.type;
1569 ehdr_start->root.u = ehdr_start_save.u;
1570 }
252b5132
RH
1571}
1572
41392f03
AM
1573EOF
1574fi
1575
1576if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
92b93329 1577fragment <<EOF
252b5132 1578
04925e1e
AM
1579/* Try to open a dynamic archive. This is where we know that ELF
1580 dynamic libraries have an extension of .so (or .sl on oddball systems
1581 like hpux). */
1582
b34976b6 1583static bfd_boolean
0c7a8e5a
AM
1584gld${EMULATION_NAME}_open_dynamic_archive
1585 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
252b5132 1586{
04925e1e
AM
1587 const char *filename;
1588 char *string;
d4ae5fb0
AM
1589 size_t len;
1590 bfd_boolean opened = FALSE;
252b5132 1591
66be1055 1592 if (! entry->flags.maybe_archive)
b34976b6 1593 return FALSE;
252b5132 1594
04925e1e 1595 filename = entry->filename;
d4ae5fb0
AM
1596 len = strlen (search->name) + strlen (filename);
1597 if (entry->flags.full_name_provided)
1598 {
1599 len += sizeof "/";
1600 string = (char *) xmalloc (len);
1601 sprintf (string, "%s/%s", search->name, filename);
1602 }
1603 else
1604 {
1605 size_t xlen = 0;
252b5132 1606
d4ae5fb0 1607 len += strlen (arch) + sizeof "/lib.so";
04925e1e 1608#ifdef EXTRA_SHLIB_EXTENSION
d4ae5fb0
AM
1609 xlen = (strlen (EXTRA_SHLIB_EXTENSION) > 3
1610 ? strlen (EXTRA_SHLIB_EXTENSION) - 3
1611 : 0);
04925e1e 1612#endif
d4ae5fb0
AM
1613 string = (char *) xmalloc (len + xlen);
1614 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
04925e1e 1615#ifdef EXTRA_SHLIB_EXTENSION
d4ae5fb0
AM
1616 /* Try the .so extension first. If that fails build a new filename
1617 using EXTRA_SHLIB_EXTENSION. */
1618 opened = ldfile_try_open_bfd (string, entry);
1619 if (!opened)
1620 strcpy (string + len - 4, EXTRA_SHLIB_EXTENSION);
04925e1e 1621#endif
d4ae5fb0 1622 }
04925e1e 1623
d4ae5fb0 1624 if (!opened && !ldfile_try_open_bfd (string, entry))
252b5132 1625 {
04925e1e 1626 free (string);
b34976b6 1627 return FALSE;
04925e1e 1628 }
252b5132 1629
04925e1e 1630 entry->filename = string;
252b5132 1631
04925e1e
AM
1632 /* We have found a dynamic object to include in the link. The ELF
1633 backend linker will create a DT_NEEDED entry in the .dynamic
1634 section naming this file. If this file includes a DT_SONAME
1635 entry, it will be used. Otherwise, the ELF linker will just use
1636 the name of the file. For an archive found by searching, like
1637 this one, the DT_NEEDED entry should consist of just the name of
1638 the file, without the path information used to find it. Note
1639 that we only need to do this if we have a dynamic object; an
1640 archive will never be referenced by a DT_NEEDED entry.
252b5132 1641
04925e1e
AM
1642 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1643 very pretty. I haven't been able to think of anything that is
1644 pretty, though. */
1645 if (bfd_check_format (entry->the_bfd, bfd_object)
1646 && (entry->the_bfd->flags & DYNAMIC) != 0)
1647 {
66be1055 1648 ASSERT (entry->flags.maybe_archive && entry->flags.search_dirs);
252b5132 1649
04925e1e 1650 /* Rather than duplicating the logic above. Just use the
1c9acd94 1651 filename we recorded earlier. */
04925e1e 1652
d4ae5fb0
AM
1653 if (!entry->flags.full_name_provided)
1654 filename = lbasename (entry->filename);
1c9acd94 1655 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
04925e1e
AM
1656 }
1657
b34976b6 1658 return TRUE;
04925e1e
AM
1659}
1660
41392f03
AM
1661EOF
1662fi
cde43e70
AM
1663
1664if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
92b93329 1665fragment <<EOF
41392f03 1666
afd7a018 1667/* A variant of lang_output_section_find used by place_orphan. */
04925e1e 1668
04925e1e 1669static lang_output_section_statement_type *
2a36a117 1670output_rel_find (asection *sec, int isdyn)
04925e1e 1671{
04925e1e 1672 lang_output_section_statement_type *lookup;
ba493122 1673 lang_output_section_statement_type *last = NULL;
2a36a117 1674 lang_output_section_statement_type *last_alloc = NULL;
48f2ff54 1675 lang_output_section_statement_type *last_ro_alloc = NULL;
ba493122
AM
1676 lang_output_section_statement_type *last_rel = NULL;
1677 lang_output_section_statement_type *last_rel_alloc = NULL;
24cdb50a 1678 int rela = sec->name[4] == 'a';
04925e1e 1679
afd7a018
AM
1680 for (lookup = &lang_output_section_statement.head->output_section_statement;
1681 lookup != NULL;
1682 lookup = lookup->next)
04925e1e 1683 {
66c103b7 1684 if (lookup->constraint >= 0
0112cd26 1685 && CONST_STRNEQ (lookup->name, ".rel"))
04925e1e 1686 {
24cdb50a 1687 int lookrela = lookup->name[4] == 'a';
ba493122 1688
2a36a117
AM
1689 /* .rel.dyn must come before all other reloc sections, to suit
1690 GNU ld.so. */
1691 if (isdyn)
1692 break;
1693
1694 /* Don't place after .rel.plt as doing so results in wrong
1695 dynamic tags. */
1696 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
ba493122 1697 break;
2a36a117
AM
1698
1699 if (rela == lookrela || last_rel == NULL)
24cdb50a 1700 last_rel = lookup;
2a36a117
AM
1701 if ((rela == lookrela || last_rel_alloc == NULL)
1702 && lookup->bfd_section != NULL
ba493122
AM
1703 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1704 last_rel_alloc = lookup;
04925e1e 1705 }
2a36a117
AM
1706
1707 last = lookup;
1708 if (lookup->bfd_section != NULL
1709 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
48f2ff54
AM
1710 {
1711 last_alloc = lookup;
1712 if ((lookup->bfd_section->flags & SEC_READONLY) != 0)
1713 last_ro_alloc = lookup;
1714 }
252b5132 1715 }
ba493122
AM
1716
1717 if (last_rel_alloc)
1718 return last_rel_alloc;
1719
1720 if (last_rel)
1721 return last_rel;
1722
48f2ff54
AM
1723 if (last_ro_alloc)
1724 return last_ro_alloc;
1725
2a36a117
AM
1726 if (last_alloc)
1727 return last_alloc;
1728
ba493122 1729 return last;
252b5132
RH
1730}
1731
1732/* Place an orphan section. We use this to put random SHF_ALLOC
1733 sections in the right segment. */
1734
c2edb4b8 1735static lang_output_section_statement_type *
8a99a385
AM
1736gld${EMULATION_NAME}_place_orphan (asection *s,
1737 const char *secname,
1738 int constraint)
252b5132 1739{
afd7a018
AM
1740 static struct orphan_save hold[] =
1741 {
1742 { ".text",
1743 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1744 0, 0, 0, 0 },
1745 { ".rodata",
1746 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1747 0, 0, 0, 0 },
d85e71fe
L
1748 { ".tdata",
1749 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_THREAD_LOCAL,
1750 0, 0, 0, 0 },
afd7a018
AM
1751 { ".data",
1752 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1753 0, 0, 0, 0 },
1754 { ".bss",
1755 SEC_ALLOC,
1756 0, 0, 0, 0 },
1757 { 0,
1758 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1759 0, 0, 0, 0 },
1760 { ".interp",
1761 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1762 0, 0, 0, 0 },
1763 { ".sdata",
1764 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
07890c07 1765 0, 0, 0, 0 },
175b7cd4 1766 { ".comment",
07890c07
AM
1767 SEC_HAS_CONTENTS,
1768 0, 0, 0, 0 },
afd7a018
AM
1769 };
1770 enum orphan_save_index
1771 {
1772 orphan_text = 0,
1773 orphan_rodata,
d85e71fe 1774 orphan_tdata,
afd7a018
AM
1775 orphan_data,
1776 orphan_bss,
1777 orphan_rel,
1778 orphan_interp,
07890c07
AM
1779 orphan_sdata,
1780 orphan_nonalloc
afd7a018
AM
1781 };
1782 static int orphan_init_done = 0;
6a345e87 1783 struct orphan_save *place;
afd7a018 1784 lang_output_section_statement_type *after;
252b5132 1785 lang_output_section_statement_type *os;
b5f14a6d 1786 lang_output_section_statement_type *match_by_name = NULL;
24cdb50a 1787 int isdyn = 0;
ecca9871
L
1788 int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1789 unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
252b5132 1790
1049f94e 1791 if (! link_info.relocatable
24cdb50a 1792 && link_info.combreloc
ecca9871 1793 && (s->flags & SEC_ALLOC))
24cdb50a 1794 {
ecca9871
L
1795 if (iself)
1796 switch (sh_type)
1797 {
1798 case SHT_RELA:
1799 secname = ".rela.dyn";
1800 isdyn = 1;
1801 break;
1802 case SHT_REL:
1803 secname = ".rel.dyn";
1804 isdyn = 1;
1805 break;
1806 default:
1807 break;
1808 }
0112cd26 1809 else if (CONST_STRNEQ (secname, ".rel"))
ecca9871
L
1810 {
1811 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1812 isdyn = 1;
1813 }
24cdb50a 1814 }
aea4bd9d 1815
bcacc0f5 1816 /* Look through the script to see where to place this section. */
d127ecce
AM
1817 if (constraint == 0)
1818 for (os = lang_output_section_find (secname);
1819 os != NULL;
1820 os = next_matching_output_section_statement (os, 0))
1821 {
1822 /* If we don't match an existing output section, tell
1823 lang_insert_orphan to create a new output section. */
1824 constraint = SPECIAL;
1825
1826 if (os->bfd_section != NULL
1827 && (os->bfd_section->flags == 0
1828 || (_bfd_elf_match_sections_by_type (link_info.output_bfd,
1829 os->bfd_section,
1830 s->owner, s)
1831 && ((s->flags ^ os->bfd_section->flags)
1832 & (SEC_LOAD | SEC_ALLOC)) == 0)))
1833 {
1834 /* We already have an output section statement with this
1835 name, and its bfd section has compatible flags.
1836 If the section already exists but does not have any flags
1837 set, then it has been created by the linker, probably as a
1838 result of a --section-start command line switch. */
b9c361e0 1839 lang_add_section (&os->children, s, NULL, os);
d127ecce
AM
1840 return os;
1841 }
b5f14a6d
DD
1842
1843 /* Save unused output sections in case we can match them
1844 against orphans later. */
1845 if (os->bfd_section == NULL)
1846 match_by_name = os;
d127ecce 1847 }
252b5132 1848
b5f14a6d
DD
1849 /* If we didn't match an active output section, see if we matched an
1850 unused one and use that. */
1851 if (match_by_name)
1852 {
b9c361e0 1853 lang_add_section (&match_by_name->children, s, NULL, match_by_name);
b5f14a6d
DD
1854 return match_by_name;
1855 }
1856
afd7a018
AM
1857 if (!orphan_init_done)
1858 {
1859 struct orphan_save *ho;
07890c07 1860
afd7a018
AM
1861 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1862 if (ho->name != NULL)
1863 {
1864 ho->os = lang_output_section_find (ho->name);
1865 if (ho->os != NULL && ho->os->flags == 0)
1866 ho->os->flags = ho->flags;
1867 }
1868 orphan_init_done = 1;
1869 }
252b5132
RH
1870
1871 /* If this is a final link, then always put .gnu.warning.SYMBOL
1872 sections into the .text section to get them out of the way. */
36af4a4e 1873 if (link_info.executable
1049f94e 1874 && ! link_info.relocatable
bcacc0f5 1875 && CONST_STRNEQ (s->name, ".gnu.warning.")
afd7a018 1876 && hold[orphan_text].os != NULL)
252b5132 1877 {
c2edb4b8 1878 os = hold[orphan_text].os;
b9c361e0 1879 lang_add_section (&os->children, s, NULL, os);
c2edb4b8 1880 return os;
252b5132
RH
1881 }
1882
1883 /* Decide which segment the section should go in based on the
1884 section name and section flags. We put loadable .note sections
1885 right after the .interp section, so that the PT_NOTE segment is
1886 stored right after the program headers where the OS can read it
1887 in the first page. */
aea4bd9d 1888
71bfc0ae 1889 place = NULL;
07890c07
AM
1890 if ((s->flags & (SEC_ALLOC | SEC_DEBUGGING)) == 0)
1891 place = &hold[orphan_nonalloc];
1892 else if ((s->flags & SEC_ALLOC) == 0)
71bfc0ae 1893 ;
252b5132 1894 else if ((s->flags & SEC_LOAD) != 0
ecca9871 1895 && ((iself && sh_type == SHT_NOTE)
0112cd26 1896 || (!iself && CONST_STRNEQ (secname, ".note"))))
afd7a018 1897 place = &hold[orphan_interp];
04c932a2 1898 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) == 0)
afd7a018
AM
1899 place = &hold[orphan_bss];
1900 else if ((s->flags & SEC_SMALL_DATA) != 0)
1901 place = &hold[orphan_sdata];
d85e71fe
L
1902 else if ((s->flags & SEC_THREAD_LOCAL) != 0)
1903 place = &hold[orphan_tdata];
afd7a018
AM
1904 else if ((s->flags & SEC_READONLY) == 0)
1905 place = &hold[orphan_data];
ecca9871 1906 else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
0112cd26 1907 || (!iself && CONST_STRNEQ (secname, ".rel")))
afd7a018
AM
1908 && (s->flags & SEC_LOAD) != 0)
1909 place = &hold[orphan_rel];
1910 else if ((s->flags & SEC_CODE) == 0)
1911 place = &hold[orphan_rodata];
1912 else
1913 place = &hold[orphan_text];
71bfc0ae 1914
afd7a018 1915 after = NULL;
5ba47421 1916 if (place != NULL)
252b5132 1917 {
afd7a018 1918 if (place->os == NULL)
5ba47421 1919 {
afd7a018
AM
1920 if (place->name != NULL)
1921 place->os = lang_output_section_find (place->name);
1922 else
1923 place->os = output_rel_find (s, isdyn);
5ba47421 1924 }
afd7a018
AM
1925 after = place->os;
1926 if (after == NULL)
390fbbf1
AM
1927 after = lang_output_section_find_by_flags
1928 (s, &place->os, _bfd_elf_match_sections_by_type);
afd7a018
AM
1929 if (after == NULL)
1930 /* *ABS* is always the first output section statement. */
1931 after = &lang_output_section_statement.head->output_section_statement;
252b5132
RH
1932 }
1933
c2edb4b8 1934 return lang_insert_orphan (s, secname, constraint, after, place, NULL, NULL);
252b5132 1935}
c56feb2b
AM
1936EOF
1937fi
1938
eaeb0a9d 1939if test x"$LDEMUL_AFTER_ALLOCATION" != xgld"$EMULATION_NAME"_after_allocation; then
92b93329 1940fragment <<EOF
252b5132 1941
deb04cdb 1942static void
eaeb0a9d 1943gld${EMULATION_NAME}_after_allocation (void)
deb04cdb 1944{
75938853
AM
1945 int need_layout = bfd_elf_discard_info (link_info.output_bfd, &link_info);
1946
1947 if (need_layout < 0)
1948 einfo ("%X%P: .eh_frame/.stab edit: %E\n");
1949 else
1950 gld${EMULATION_NAME}_map_segments (need_layout);
73d074b4 1951}
41392f03
AM
1952EOF
1953fi
1954
1955if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
92b93329 1956fragment <<EOF
252b5132
RH
1957
1958static char *
0c7a8e5a 1959gld${EMULATION_NAME}_get_script (int *isfile)
252b5132
RH
1960EOF
1961
7225345d 1962if test x"$COMPILE_IN" = xyes
252b5132
RH
1963then
1964# Scripts compiled in.
1965
1966# sed commands to quote an ld script as a C string.
597e2591 1967sc="-f stringify.sed"
252b5132 1968
92b93329 1969fragment <<EOF
60bcf0fa 1970{
252b5132
RH
1971 *isfile = 0;
1972
1049f94e 1973 if (link_info.relocatable && config.build_constructors)
597e2591 1974 return
252b5132 1975EOF
afd7a018
AM
1976sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1977echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1978sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1979echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1980sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
61585df2 1981if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
afd7a018
AM
1982echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1983sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
db6751f2 1984fi
36af4a4e
JJ
1985if test -n "$GENERATE_PIE_SCRIPT" ; then
1986if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
8c37241b
JJ
1987echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1988echo ' && link_info.relro' >> e${EMULATION_NAME}.c
fbfca19e 1989echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
afd7a018 1990sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
36af4a4e 1991echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
afd7a018 1992sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
36af4a4e 1993fi
afd7a018
AM
1994echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1995sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
36af4a4e 1996fi
252b5132 1997if test -n "$GENERATE_SHLIB_SCRIPT" ; then
82434356 1998if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
8c37241b
JJ
1999echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
2000echo ' && link_info.relro' >> e${EMULATION_NAME}.c
fbfca19e 2001echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
afd7a018 2002sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
db6751f2 2003echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
afd7a018 2004sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
82434356 2005fi
afd7a018
AM
2006echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
2007sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
252b5132 2008fi
82434356 2009if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
8c37241b 2010echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
fbfca19e 2011echo ' && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
afd7a018
AM
2012sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
2013echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
2014sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
82434356 2015fi
afd7a018
AM
2016echo ' ; else return' >> e${EMULATION_NAME}.c
2017sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
2018echo '; }' >> e${EMULATION_NAME}.c
252b5132
RH
2019
2020else
2021# Scripts read from the filesystem.
2022
92b93329 2023fragment <<EOF
60bcf0fa 2024{
252b5132
RH
2025 *isfile = 1;
2026
1049f94e 2027 if (link_info.relocatable && config.build_constructors)
252b5132 2028 return "ldscripts/${EMULATION_NAME}.xu";
1049f94e 2029 else if (link_info.relocatable)
252b5132
RH
2030 return "ldscripts/${EMULATION_NAME}.xr";
2031 else if (!config.text_read_only)
2032 return "ldscripts/${EMULATION_NAME}.xbn";
a060b769
AM
2033EOF
2034if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
2035else
92b93329 2036fragment <<EOF
252b5132
RH
2037 else if (!config.magic_demand_paged)
2038 return "ldscripts/${EMULATION_NAME}.xn";
a060b769
AM
2039EOF
2040fi
36af4a4e
JJ
2041if test -n "$GENERATE_PIE_SCRIPT" ; then
2042if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
92b93329 2043fragment <<EOF
8c37241b 2044 else if (link_info.pie && link_info.combreloc
fbfca19e 2045 && link_info.relro && (link_info.flags & DF_BIND_NOW))
8c37241b 2046 return "ldscripts/${EMULATION_NAME}.xdw";
36af4a4e
JJ
2047 else if (link_info.pie && link_info.combreloc)
2048 return "ldscripts/${EMULATION_NAME}.xdc";
2049EOF
2050fi
92b93329 2051fragment <<EOF
36af4a4e
JJ
2052 else if (link_info.pie)
2053 return "ldscripts/${EMULATION_NAME}.xd";
2054EOF
2055fi
a060b769
AM
2056if test -n "$GENERATE_SHLIB_SCRIPT" ; then
2057if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
92b93329 2058fragment <<EOF
8c37241b 2059 else if (link_info.shared && link_info.combreloc
fbfca19e 2060 && link_info.relro && (link_info.flags & DF_BIND_NOW))
8c37241b 2061 return "ldscripts/${EMULATION_NAME}.xsw";
a060b769
AM
2062 else if (link_info.shared && link_info.combreloc)
2063 return "ldscripts/${EMULATION_NAME}.xsc";
2064EOF
2065fi
92b93329 2066fragment <<EOF
252b5132
RH
2067 else if (link_info.shared)
2068 return "ldscripts/${EMULATION_NAME}.xs";
a060b769
AM
2069EOF
2070fi
2071if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
92b93329 2072fragment <<EOF
8c37241b 2073 else if (link_info.combreloc && link_info.relro
fbfca19e 2074 && (link_info.flags & DF_BIND_NOW))
8c37241b 2075 return "ldscripts/${EMULATION_NAME}.xw";
a060b769
AM
2076 else if (link_info.combreloc)
2077 return "ldscripts/${EMULATION_NAME}.xc";
2078EOF
2079fi
92b93329 2080fragment <<EOF
252b5132
RH
2081 else
2082 return "ldscripts/${EMULATION_NAME}.x";
2083}
252b5132 2084
3b108066 2085EOF
41392f03
AM
2086fi
2087fi
3b108066 2088
e0ee487b 2089if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
92b93329 2090fragment <<EOF
e0ee487b
L
2091 $PARSE_AND_LIST_PROLOGUE
2092EOF
2093fi
2094
92b93329 2095fragment <<EOF
e0ee487b 2096
6c1439be
L
2097#define OPTION_DISABLE_NEW_DTAGS (400)
2098#define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
a1ab1d2a 2099#define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
65765700 2100#define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
b58f81ae 2101#define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1)
fdc90cb4 2102#define OPTION_HASH_STYLE (OPTION_EXCLUDE_LIBS + 1)
c0065db7 2103#define OPTION_BUILD_ID (OPTION_HASH_STYLE + 1)
7ee314fa 2104#define OPTION_AUDIT (OPTION_BUILD_ID + 1)
e13629bc 2105
3bcf5557 2106static void
0c7a8e5a
AM
2107gld${EMULATION_NAME}_add_options
2108 (int ns, char **shortopts, int nl, struct option **longopts,
2109 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
e0ee487b 2110{
fb42df5e
AM
2111EOF
2112if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2113fragment <<EOF
7ee314fa 2114 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:P:";
fb42df5e
AM
2115EOF
2116else
2117fragment <<EOF
2118 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
2119EOF
2120fi
2121fragment <<EOF
3bcf5557 2122 static const struct option xtra_long[] = {
fb42df5e
AM
2123EOF
2124if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2125fragment <<EOF
7ee314fa 2126 {"audit", required_argument, NULL, OPTION_AUDIT},
fb42df5e
AM
2127 {"Bgroup", no_argument, NULL, OPTION_GROUP},
2128EOF
2129fi
2130fragment <<EOF
2131 {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
e0ee487b 2132EOF
e0ee487b 2133if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
92b93329 2134fragment <<EOF
fb42df5e 2135 {"depaudit", required_argument, NULL, 'P'},
3bcf5557
AM
2136 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
2137 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
2138 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
b58f81ae 2139 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
fdc90cb4 2140 {"hash-style", required_argument, NULL, OPTION_HASH_STYLE},
e0ee487b
L
2141EOF
2142fi
e0ee487b 2143if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
92b93329 2144fragment <<EOF
3bcf5557 2145 $PARSE_AND_LIST_LONGOPTS
e0ee487b
L
2146EOF
2147fi
92b93329 2148fragment <<EOF
3bcf5557
AM
2149 {NULL, no_argument, NULL, 0}
2150 };
2151
2152 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
2153 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
2154 *longopts = (struct option *)
2155 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
2156 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
2157}
04925e1e 2158
24382dca 2159#define DEFAULT_BUILD_ID_STYLE "sha1"
c0065db7 2160
3bcf5557 2161static bfd_boolean
0c7a8e5a 2162gld${EMULATION_NAME}_handle_option (int optc)
e0ee487b 2163{
e0ee487b
L
2164 switch (optc)
2165 {
2166 default:
3bcf5557 2167 return FALSE;
6c1439be 2168
c0065db7 2169 case OPTION_BUILD_ID:
30e8ee25 2170 if (emit_note_gnu_build_id != NULL)
c0065db7 2171 {
30e8ee25
AM
2172 free ((char *) emit_note_gnu_build_id);
2173 emit_note_gnu_build_id = NULL;
c0065db7
RM
2174 }
2175 if (optarg == NULL)
2176 optarg = DEFAULT_BUILD_ID_STYLE;
2177 if (strcmp (optarg, "none"))
30e8ee25 2178 emit_note_gnu_build_id = xstrdup (optarg);
c0065db7 2179 break;
fb42df5e
AM
2180
2181EOF
2182
2183if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2184fragment <<EOF
7ee314fa 2185 case OPTION_AUDIT:
4724d37e 2186 gld${EMULATION_NAME}_append_to_separated_string (&audit, optarg);
7ee314fa 2187 break;
fb42df5e 2188
7ee314fa
AM
2189 case 'P':
2190 gld${EMULATION_NAME}_append_to_separated_string (&depaudit, optarg);
2191 break;
c0065db7 2192
6c1439be 2193 case OPTION_DISABLE_NEW_DTAGS:
b34976b6 2194 link_info.new_dtags = FALSE;
6c1439be
L
2195 break;
2196
2197 case OPTION_ENABLE_NEW_DTAGS:
b34976b6 2198 link_info.new_dtags = TRUE;
6c1439be
L
2199 break;
2200
65765700 2201 case OPTION_EH_FRAME_HDR:
b34976b6 2202 link_info.eh_frame_hdr = TRUE;
65765700
JJ
2203 break;
2204
a1ab1d2a
UD
2205 case OPTION_GROUP:
2206 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
2207 /* Groups must be self-contained. */
560e09e9
NC
2208 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2209 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
a1ab1d2a
UD
2210 break;
2211
b58f81ae
DJ
2212 case OPTION_EXCLUDE_LIBS:
2213 add_excluded_libs (optarg);
2214 break;
2215
fdc90cb4
JJ
2216 case OPTION_HASH_STYLE:
2217 link_info.emit_hash = FALSE;
2218 link_info.emit_gnu_hash = FALSE;
2219 if (strcmp (optarg, "sysv") == 0)
2220 link_info.emit_hash = TRUE;
2221 else if (strcmp (optarg, "gnu") == 0)
2222 link_info.emit_gnu_hash = TRUE;
2223 else if (strcmp (optarg, "both") == 0)
2224 {
2225 link_info.emit_hash = TRUE;
2226 link_info.emit_gnu_hash = TRUE;
2227 }
2228 else
2229 einfo (_("%P%F: invalid hash style \`%s'\n"), optarg);
2230 break;
2231
fb42df5e
AM
2232EOF
2233fi
2234fragment <<EOF
e0ee487b 2235 case 'z':
fb42df5e
AM
2236 if (strcmp (optarg, "defs") == 0)
2237 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2238 else if (strcmp (optarg, "muldefs") == 0)
2239 link_info.allow_multiple_definition = TRUE;
2240 else if (CONST_STRNEQ (optarg, "max-page-size="))
2241 {
2242 char *end;
2243
2244 config.maxpagesize = strtoul (optarg + 14, &end, 0);
2245 if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0)
2246 einfo (_("%P%F: invalid maxium page size \`%s'\n"),
2247 optarg + 14);
2248 }
2249 else if (CONST_STRNEQ (optarg, "common-page-size="))
2250 {
2251 char *end;
2252 config.commonpagesize = strtoul (optarg + 17, &end, 0);
2253 if (*end
2254 || (config.commonpagesize & (config.commonpagesize - 1)) != 0)
2255 einfo (_("%P%F: invalid common page size \`%s'\n"),
2256 optarg + 17);
2257 }
04c3a755
NS
2258 else if (CONST_STRNEQ (optarg, "stack-size="))
2259 {
2260 char *end;
2261 link_info.stacksize = strtoul (optarg + 11, &end, 0);
2262 if (*end || link_info.stacksize < 0)
2263 einfo (_("%P%F: invalid stack size \`%s'\n"), optarg + 11);
2264 if (!link_info.stacksize)
2265 /* Use -1 for explicit no-stack, because zero means
2266 'default'. */
2267 link_info.stacksize = -1;
2268 }
fb42df5e
AM
2269 else if (strcmp (optarg, "execstack") == 0)
2270 {
2271 link_info.execstack = TRUE;
2272 link_info.noexecstack = FALSE;
2273 }
2274 else if (strcmp (optarg, "noexecstack") == 0)
2275 {
2276 link_info.noexecstack = TRUE;
2277 link_info.execstack = FALSE;
2278 }
2279EOF
d258b828
IZ
2280
2281if test x"$BNDPLT" = xyes; then
2282fragment <<EOF
2283 else if (strcmp (optarg, "bndplt") == 0)
2284 link_info.bndplt = TRUE;
2285EOF
2286fi
2287
fb42df5e
AM
2288if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2289fragment <<EOF
b039ef04
L
2290 else if (strcmp (optarg, "global") == 0)
2291 link_info.flags_1 |= (bfd_vma) DF_1_GLOBAL;
fb42df5e 2292 else if (strcmp (optarg, "initfirst") == 0)
e0ee487b
L
2293 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
2294 else if (strcmp (optarg, "interpose") == 0)
2295 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
2296 else if (strcmp (optarg, "loadfltr") == 0)
2297 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
2298 else if (strcmp (optarg, "nodefaultlib") == 0)
2299 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
2300 else if (strcmp (optarg, "nodelete") == 0)
2301 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
2302 else if (strcmp (optarg, "nodlopen") == 0)
2303 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
2304 else if (strcmp (optarg, "nodump") == 0)
2305 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
2306 else if (strcmp (optarg, "now") == 0)
2307 {
2308 link_info.flags |= (bfd_vma) DF_BIND_NOW;
2309 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
2310 }
5fa222e4
AM
2311 else if (strcmp (optarg, "lazy") == 0)
2312 {
2313 link_info.flags &= ~(bfd_vma) DF_BIND_NOW;
2314 link_info.flags_1 &= ~(bfd_vma) DF_1_NOW;
2315 }
e0ee487b
L
2316 else if (strcmp (optarg, "origin") == 0)
2317 {
2318 link_info.flags |= (bfd_vma) DF_ORIGIN;
2319 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
2320 }
db6751f2 2321 else if (strcmp (optarg, "combreloc") == 0)
b34976b6 2322 link_info.combreloc = TRUE;
db6751f2 2323 else if (strcmp (optarg, "nocombreloc") == 0)
b34976b6 2324 link_info.combreloc = FALSE;
8bd621d8 2325 else if (strcmp (optarg, "nocopyreloc") == 0)
0c7a8e5a 2326 link_info.nocopyreloc = TRUE;
8c37241b
JJ
2327 else if (strcmp (optarg, "relro") == 0)
2328 link_info.relro = TRUE;
2329 else if (strcmp (optarg, "norelro") == 0)
2330 link_info.relro = FALSE;
c192a133
AM
2331 else if (strcmp (optarg, "text") == 0)
2332 link_info.error_textrel = TRUE;
2333 else if (strcmp (optarg, "notext") == 0)
2334 link_info.error_textrel = FALSE;
2335 else if (strcmp (optarg, "textoff") == 0)
2336 link_info.error_textrel = FALSE;
88b882e9 2337EOF
fb42df5e 2338fi
88b882e9 2339
92b93329 2340fragment <<EOF
fb42df5e
AM
2341 else
2342 einfo (_("%P: warning: -z %s ignored.\n"), optarg);
6c1439be 2343 break;
e0ee487b 2344EOF
e0ee487b
L
2345
2346if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
92b93329 2347fragment <<EOF
e0ee487b
L
2348 $PARSE_AND_LIST_ARGS_CASES
2349EOF
2350fi
2351
92b93329 2352fragment <<EOF
e0ee487b
L
2353 }
2354
3bcf5557 2355 return TRUE;
e0ee487b
L
2356}
2357
41392f03 2358EOF
41392f03 2359
4b209b22 2360if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
92b93329 2361fragment <<EOF
41392f03 2362
e0ee487b 2363static void
0c7a8e5a 2364gld${EMULATION_NAME}_list_options (FILE * file)
e0ee487b 2365{
fb42df5e
AM
2366EOF
2367if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2368fragment <<EOF
7ee314fa
AM
2369 fprintf (file, _("\
2370 --audit=AUDITLIB Specify a library to use for auditing\n"));
2371 fprintf (file, _("\
fb42df5e
AM
2372 -Bgroup Selects group name lookup rules for DSO\n"));
2373EOF
2374fi
2375fragment <<EOF
2376 fprintf (file, _("\
2377 --build-id[=STYLE] Generate build ID note\n"));
e0ee487b 2378EOF
e0ee487b 2379if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
92b93329 2380fragment <<EOF
442996ee 2381 fprintf (file, _("\
fb42df5e 2382 -P AUDITLIB, --depaudit=AUDITLIB\n" "\
4724d37e 2383 Specify a library to use for auditing dependencies\n"));
442996ee
AM
2384 fprintf (file, _("\
2385 --disable-new-dtags Disable new dynamic tags\n"));
2386 fprintf (file, _("\
2387 --enable-new-dtags Enable new dynamic tags\n"));
2388 fprintf (file, _("\
2389 --eh-frame-hdr Create .eh_frame_hdr section\n"));
2390 fprintf (file, _("\
fb42df5e
AM
2391 --exclude-libs=LIBS Make all symbols in LIBS hidden\n"));
2392 fprintf (file, _("\
442996ee
AM
2393 --hash-style=STYLE Set hash style to sysv, gnu or both\n"));
2394 fprintf (file, _("\
2395 -z combreloc Merge dynamic relocs into one section and sort\n"));
fb42df5e
AM
2396EOF
2397fi
2398
2399fragment <<EOF
2400 fprintf (file, _("\
2401 -z common-page-size=SIZE Set common page size to SIZE\n"));
442996ee
AM
2402 fprintf (file, _("\
2403 -z defs Report unresolved symbols in object files.\n"));
2404 fprintf (file, _("\
2405 -z execstack Mark executable as requiring executable stack\n"));
fb42df5e
AM
2406EOF
2407
2408if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2409fragment <<EOF
442996ee 2410 fprintf (file, _("\
b039ef04 2411 -z global Make symbols in DSO available for subsequently\n\
4724d37e 2412 loaded objects\n"));
b039ef04 2413 fprintf (file, _("\
442996ee
AM
2414 -z initfirst Mark DSO to be initialized first at runtime\n"));
2415 fprintf (file, _("\
2416 -z interpose Mark object to interpose all DSOs but executable\n"));
2417 fprintf (file, _("\
2418 -z lazy Mark object lazy runtime binding (default)\n"));
2419 fprintf (file, _("\
2420 -z loadfltr Mark object requiring immediate process\n"));
fb42df5e
AM
2421EOF
2422fi
2423
2424fragment <<EOF
2425 fprintf (file, _("\
2426 -z max-page-size=SIZE Set maximum page size to SIZE\n"));
442996ee
AM
2427 fprintf (file, _("\
2428 -z muldefs Allow multiple definitions\n"));
fb42df5e
AM
2429EOF
2430
2431if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2432fragment <<EOF
442996ee
AM
2433 fprintf (file, _("\
2434 -z nocombreloc Don't merge dynamic relocs into one section\n"));
2435 fprintf (file, _("\
2436 -z nocopyreloc Don't create copy relocs\n"));
2437 fprintf (file, _("\
2438 -z nodefaultlib Mark object not to use default search paths\n"));
2439 fprintf (file, _("\
2440 -z nodelete Mark DSO non-deletable at runtime\n"));
2441 fprintf (file, _("\
2442 -z nodlopen Mark DSO not available to dlopen\n"));
2443 fprintf (file, _("\
2444 -z nodump Mark DSO not available to dldump\n"));
fb42df5e
AM
2445EOF
2446fi
2447fragment <<EOF
442996ee
AM
2448 fprintf (file, _("\
2449 -z noexecstack Mark executable as not requiring executable stack\n"));
88b882e9 2450EOF
fb42df5e 2451if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
92b93329 2452fragment <<EOF
442996ee
AM
2453 fprintf (file, _("\
2454 -z norelro Don't create RELRO program header\n"));
442996ee
AM
2455 fprintf (file, _("\
2456 -z now Mark object non-lazy runtime binding\n"));
2457 fprintf (file, _("\
2458 -z origin Mark object requiring immediate \$ORIGIN\n\
4724d37e 2459 processing at runtime\n"));
442996ee
AM
2460 fprintf (file, _("\
2461 -z relro Create RELRO program header\n"));
07e15f87
NS
2462 fprintf (file, _("\
2463 -z stacksize=SIZE Set size of stack segment\n"));
88b882e9 2464EOF
e0ee487b
L
2465fi
2466
d258b828
IZ
2467if test x"$BNDPLT" = xyes; then
2468fragment <<EOF
2469 fprintf (file, _("\
2470 -z bndplt Always generate BND prefix in PLT entries\n"));
2471EOF
2472fi
2473
e0ee487b 2474if test -n "$PARSE_AND_LIST_OPTIONS" ; then
92b93329 2475fragment <<EOF
e0ee487b
L
2476 $PARSE_AND_LIST_OPTIONS
2477EOF
2478fi
2479
92b93329 2480fragment <<EOF
e0ee487b
L
2481}
2482EOF
e0ee487b
L
2483
2484if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
92b93329 2485fragment <<EOF
e0ee487b
L
2486 $PARSE_AND_LIST_EPILOGUE
2487EOF
2488fi
41392f03 2489fi
e0ee487b 2490
92b93329 2491fragment <<EOF
252b5132 2492
60bcf0fa 2493struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
252b5132 2494{
41392f03
AM
2495 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
2496 ${LDEMUL_SYSLIB-syslib_default},
2497 ${LDEMUL_HLL-hll_default},
eeaa4577 2498 ${LDEMUL_AFTER_PARSE-after_parse_default},
41392f03 2499 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
eaeb0a9d 2500 ${LDEMUL_AFTER_ALLOCATION-gld${EMULATION_NAME}_after_allocation},
41392f03
AM
2501 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
2502 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
2503 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
2504 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
252b5132
RH
2505 "${EMULATION_NAME}",
2506 "${OUTPUT_FORMAT}",
eaeb0a9d 2507 ${LDEMUL_FINISH-finish_default},
41392f03
AM
2508 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
2509 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
2510 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
2511 ${LDEMUL_SET_SYMBOLS-NULL},
3bcf5557
AM
2512 ${LDEMUL_PARSE_ARGS-NULL},
2513 gld${EMULATION_NAME}_add_options,
2514 gld${EMULATION_NAME}_handle_option,
41392f03 2515 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
4b209b22 2516 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
4a43e768 2517 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
41392f03 2518 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
7a2f2d82
DD
2519 ${LDEMUL_NEW_VERS_PATTERN-NULL},
2520 ${LDEMUL_EXTRA_MAP_FILE_TEXT-NULL}
252b5132
RH
2521};
2522EOF
This page took 1.207281 seconds and 4 git commands to generate.