| blob | dffcff81b47081ffbef95edc038189e662af277c |
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.
5 test -z "${ELFSIZE}" && ELFSIZE=32
6 if [ -z "$MACHINE" ]; then
7 OUTPUT_ARCH=${ARCH}
8 else
9 OUTPUT_ARCH=${ARCH}:${MACHINE}
10 fi
11 cat >e${EMULATION_NAME}.c <<EOF
12 /* This file is is generated by a shell script. DO NOT EDIT! */
14 /* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
15 Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
16 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
17 Written by Steve Chamberlain <sac@cygnus.com>
18 ELF support by Ian Lance Taylor <ian@cygnus.com>
20 This file is part of GLD, the Gnu Linker.
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2 of the License, or
25 (at your option) any later version.
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software
34 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
36 #define TARGET_IS_${EMULATION_NAME}
38 #include "config.h"
39 #include "bfd.h"
40 #include "sysdep.h"
41 #include "libiberty.h"
42 #include "safe-ctype.h"
43 #include "getopt.h"
45 #include "bfdlink.h"
47 #include "ld.h"
48 #include "ldmain.h"
49 #include "ldmisc.h"
50 #include "ldexp.h"
51 #include "ldlang.h"
52 #include "ldfile.h"
53 #include "ldemul.h"
54 #include <ldgram.h>
55 #include "elf/common.h"
56 #include "elf-bfd.h"
58 /* Declare functions used by various EXTRA_EM_FILEs. */
59 static void gld${EMULATION_NAME}_before_parse (void);
60 static void gld${EMULATION_NAME}_after_open (void);
61 static void gld${EMULATION_NAME}_before_allocation (void);
62 static bfd_boolean gld${EMULATION_NAME}_place_orphan (asection *s);
63 static void gld${EMULATION_NAME}_layout_sections_again (void);
64 static void gld${EMULATION_NAME}_finish (void) ATTRIBUTE_UNUSED;
66 EOF
68 if [ "x${USE_LIBPATH}" = xyes ] ; then
69 case ${target} in
70 *-*-linux-* | *-*-k*bsd*-*)
71 cat >>e${EMULATION_NAME}.c <<EOF
72 #ifdef HAVE_GLOB
73 #include <glob.h>
74 #endif
75 EOF
76 ;;
77 esac
78 fi
80 # Import any needed special functions and/or overrides.
81 #
82 if test -n "$EXTRA_EM_FILE" ; then
83 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
84 fi
86 # Functions in this file can be overridden by setting the LDEMUL_* shell
87 # variables. If the name of the overriding function is the same as is
88 # defined in this file, then don't output this file's version.
89 # If a different overriding name is given then output the standard function
90 # as presumably it is called from the overriding function.
91 #
92 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
93 cat >>e${EMULATION_NAME}.c <<EOF
95 static void
96 gld${EMULATION_NAME}_before_parse (void)
97 {
98 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
99 config.dynamic_link = ${DYNAMIC_LINK-TRUE};
100 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
101 }
103 EOF
104 fi
106 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
107 cat >>e${EMULATION_NAME}.c <<EOF
108 /* Handle as_needed DT_NEEDED. */
110 static bfd_boolean
111 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
112 {
113 int class = 0;
115 /* Tell the ELF linker that we don't want the output file to have a
116 DT_NEEDED entry for this file, unless it is used to resolve
117 references in a regular object. */
118 if (entry->as_needed)
119 class = DYN_AS_NEEDED;
121 /* Tell the ELF linker that we don't want the output file to have a
122 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
123 this file at all. */
124 if (!entry->add_needed)
125 class |= DYN_NO_ADD_NEEDED;
127 if (entry->just_syms_flag
128 && (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0)
129 einfo (_("%P%F: --just-symbols may not be used on DSO: %B\n"),
130 entry->the_bfd);
132 if (!class
133 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
134 return FALSE;
136 bfd_elf_set_dyn_lib_class (entry->the_bfd, class);
138 /* Continue on with normal load_symbols processing. */
139 return FALSE;
140 }
141 EOF
142 fi
144 cat >>e${EMULATION_NAME}.c <<EOF
146 /* These variables are required to pass information back and forth
147 between after_open and check_needed and stat_needed and vercheck. */
149 static struct bfd_link_needed_list *global_needed;
150 static struct stat global_stat;
151 static bfd_boolean global_found;
152 static struct bfd_link_needed_list *global_vercheck_needed;
153 static bfd_boolean global_vercheck_failed;
156 /* On Linux, it's possible to have different versions of the same
157 shared library linked against different versions of libc. The
158 dynamic linker somehow tags which libc version to use in
159 /etc/ld.so.cache, and, based on the libc that it sees in the
160 executable, chooses which version of the shared library to use.
162 We try to do a similar check here by checking whether this shared
163 library needs any other shared libraries which may conflict with
164 libraries we have already included in the link. If it does, we
165 skip it, and try to find another shared library farther on down the
166 link path.
168 This is called via lang_for_each_input_file.
169 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
170 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
171 a conflicting version. */
173 static void
174 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
175 {
176 const char *soname;
177 struct bfd_link_needed_list *l;
179 if (global_vercheck_failed)
180 return;
181 if (s->the_bfd == NULL
182 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
183 return;
185 soname = bfd_elf_get_dt_soname (s->the_bfd);
186 if (soname == NULL)
187 soname = lbasename (bfd_get_filename (s->the_bfd));
189 for (l = global_vercheck_needed; l != NULL; l = l->next)
190 {
191 const char *suffix;
193 if (strcmp (soname, l->name) == 0)
194 {
195 /* Probably can't happen, but it's an easy check. */
196 continue;
197 }
199 if (strchr (l->name, '/') != NULL)
200 continue;
202 suffix = strstr (l->name, ".so.");
203 if (suffix == NULL)
204 continue;
206 suffix += sizeof ".so." - 1;
208 if (strncmp (soname, l->name, suffix - l->name) == 0)
209 {
210 /* Here we know that S is a dynamic object FOO.SO.VER1, and
211 the object we are considering needs a dynamic object
212 FOO.SO.VER2, and VER1 and VER2 are different. This
213 appears to be a version mismatch, so we tell the caller
214 to try a different version of this library. */
215 global_vercheck_failed = TRUE;
216 return;
217 }
218 }
219 }
222 /* See if an input file matches a DT_NEEDED entry by running stat on
223 the file. */
225 static void
226 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
227 {
228 struct stat st;
229 const char *suffix;
230 const char *soname;
232 if (global_found)
233 return;
234 if (s->the_bfd == NULL)
235 return;
236 if (s->as_needed
237 && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
238 return;
240 if (bfd_stat (s->the_bfd, &st) != 0)
241 {
242 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
243 return;
244 }
246 /* Some operating systems, e.g. Windows, do not provide a meaningful
247 st_ino; they always set it to zero. (Windows does provide a
248 meaningful st_dev.) Do not indicate a duplicate library in that
249 case. While there is no guarantee that a system that provides
250 meaningful inode numbers will never set st_ino to zero, this is
251 merely an optimization, so we do not need to worry about false
252 negatives. */
253 if (st.st_dev == global_stat.st_dev
254 && st.st_ino == global_stat.st_ino
255 && st.st_ino != 0)
256 {
257 global_found = TRUE;
258 return;
259 }
261 /* We issue a warning if it looks like we are including two
262 different versions of the same shared library. For example,
263 there may be a problem if -lc picks up libc.so.6 but some other
264 shared library has a DT_NEEDED entry of libc.so.5. This is a
265 heuristic test, and it will only work if the name looks like
266 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
267 If we really want to issue warnings about mixing version numbers
268 of shared libraries, we need to find a better way. */
270 if (strchr (global_needed->name, '/') != NULL)
271 return;
272 suffix = strstr (global_needed->name, ".so.");
273 if (suffix == NULL)
274 return;
275 suffix += sizeof ".so." - 1;
277 soname = bfd_elf_get_dt_soname (s->the_bfd);
278 if (soname == NULL)
279 soname = lbasename (s->filename);
281 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
282 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
283 global_needed->name, global_needed->by, soname);
284 }
286 struct dt_needed
287 {
288 bfd *by;
289 const char *name;
290 };
292 /* This function is called for each possible name for a dynamic object
293 named by a DT_NEEDED entry. The FORCE parameter indicates whether
294 to skip the check for a conflicting version. */
296 static bfd_boolean
297 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
298 int force)
299 {
300 bfd *abfd;
301 const char *name = needed->name;
302 const char *soname;
303 int class;
305 abfd = bfd_openr (name, bfd_get_target (output_bfd));
306 if (abfd == NULL)
307 return FALSE;
308 if (! bfd_check_format (abfd, bfd_object))
309 {
310 bfd_close (abfd);
311 return FALSE;
312 }
313 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
314 {
315 bfd_close (abfd);
316 return FALSE;
317 }
319 /* For DT_NEEDED, they have to match. */
320 if (abfd->xvec != output_bfd->xvec)
321 {
322 bfd_close (abfd);
323 return FALSE;
324 }
326 /* Check whether this object would include any conflicting library
327 versions. If FORCE is set, then we skip this check; we use this
328 the second time around, if we couldn't find any compatible
329 instance of the shared library. */
331 if (! force)
332 {
333 struct bfd_link_needed_list *needed;
335 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
336 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
338 if (needed != NULL)
339 {
340 global_vercheck_needed = needed;
341 global_vercheck_failed = FALSE;
342 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
343 if (global_vercheck_failed)
344 {
345 bfd_close (abfd);
346 /* Return FALSE to force the caller to move on to try
347 another file on the search path. */
348 return FALSE;
349 }
351 /* But wait! It gets much worse. On Linux, if a shared
352 library does not use libc at all, we are supposed to skip
353 it the first time around in case we encounter a shared
354 library later on with the same name which does use the
355 version of libc that we want. This is much too horrible
356 to use on any system other than Linux. */
358 EOF
359 case ${target} in
360 *-*-linux-* | *-*-k*bsd*-*)
361 cat >>e${EMULATION_NAME}.c <<EOF
362 {
363 struct bfd_link_needed_list *l;
365 for (l = needed; l != NULL; l = l->next)
366 if (strncmp (l->name, "libc.so", 7) == 0)
367 break;
368 if (l == NULL)
369 {
370 bfd_close (abfd);
371 return FALSE;
372 }
373 }
375 EOF
376 ;;
377 esac
378 cat >>e${EMULATION_NAME}.c <<EOF
379 }
380 }
382 /* We've found a dynamic object matching the DT_NEEDED entry. */
384 /* We have already checked that there is no other input file of the
385 same name. We must now check again that we are not including the
386 same file twice. We need to do this because on many systems
387 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
388 reference libc.so.1. If we have already included libc.so, we
389 don't want to include libc.so.1 if they are the same file, and we
390 can only check that using stat. */
392 if (bfd_stat (abfd, &global_stat) != 0)
393 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
395 /* First strip off everything before the last '/'. */
396 soname = lbasename (abfd->filename);
398 if (trace_file_tries)
399 info_msg (_("found %s at %s\n"), soname, name);
401 global_found = FALSE;
402 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
403 if (global_found)
404 {
405 /* Return TRUE to indicate that we found the file, even though
406 we aren't going to do anything with it. */
407 return TRUE;
408 }
410 /* Specify the soname to use. */
411 bfd_elf_set_dt_needed_name (abfd, soname);
413 /* Tell the ELF linker that we don't want the output file to have a
414 DT_NEEDED entry for this file, unless it is used to resolve
415 references in a regular object. */
416 class = DYN_DT_NEEDED;
418 /* Tell the ELF linker that we don't want the output file to have a
419 DT_NEEDED entry for this file at all if the entry is from a file
420 with DYN_NO_ADD_NEEDED. */
421 if (needed->by != NULL
422 && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
423 class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
425 bfd_elf_set_dyn_lib_class (abfd, class);
427 /* Add this file into the symbol table. */
428 if (! bfd_link_add_symbols (abfd, &link_info))
429 einfo ("%F%B: could not read symbols: %E\n", abfd);
431 return TRUE;
432 }
435 /* Search for a needed file in a path. */
437 static bfd_boolean
438 gld${EMULATION_NAME}_search_needed (const char *path,
439 struct dt_needed *n, int force)
440 {
441 const char *s;
442 const char *name = n->name;
443 size_t len;
444 struct dt_needed needed;
446 if (name[0] == '/')
447 return gld${EMULATION_NAME}_try_needed (n, force);
449 if (path == NULL || *path == '\0')
450 return FALSE;
452 needed.by = n->by;
453 needed.name = n->name;
455 len = strlen (name);
456 while (1)
457 {
458 char *filename, *sset;
460 s = strchr (path, ':');
461 if (s == NULL)
462 s = path + strlen (path);
464 filename = (char *) xmalloc (s - path + len + 2);
465 if (s == path)
466 sset = filename;
467 else
468 {
469 memcpy (filename, path, s - path);
470 filename[s - path] = '/';
471 sset = filename + (s - path) + 1;
472 }
473 strcpy (sset, name);
475 needed.name = filename;
476 if (gld${EMULATION_NAME}_try_needed (&needed, force))
477 return TRUE;
479 free (filename);
481 if (*s == '\0')
482 break;
483 path = s + 1;
484 }
486 return FALSE;
487 }
489 EOF
490 if [ "x${USE_LIBPATH}" = xyes ] ; then
491 cat >>e${EMULATION_NAME}.c <<EOF
493 /* Add the sysroot to every entry in a colon-separated path. */
495 static char *
496 gld${EMULATION_NAME}_add_sysroot (const char *path)
497 {
498 int len, colons, i;
499 char *ret, *p;
501 len = strlen (path);
502 colons = 0;
503 i = 0;
504 while (path[i])
505 if (path[i++] == ':')
506 colons++;
508 if (path[i])
509 colons++;
511 len = len + (colons + 1) * strlen (ld_sysroot);
512 ret = xmalloc (len + 1);
513 strcpy (ret, ld_sysroot);
514 p = ret + strlen (ret);
515 i = 0;
516 while (path[i])
517 if (path[i] == ':')
518 {
519 *p++ = path[i++];
520 strcpy (p, ld_sysroot);
521 p = p + strlen (p);
522 }
523 else
524 *p++ = path[i++];
526 *p = 0;
527 return ret;
528 }
530 EOF
531 case ${target} in
532 *-*-freebsd* | *-*-dragonfly*)
533 cat >>e${EMULATION_NAME}.c <<EOF
534 /* Read the system search path the FreeBSD way rather than the Linux way. */
535 #ifdef HAVE_ELF_HINTS_H
536 #include <elf-hints.h>
537 #else
538 #include "elf-hints-local.h"
539 #endif
541 static bfd_boolean
542 gld${EMULATION_NAME}_check_ld_elf_hints (const char *name, int force)
543 {
544 static bfd_boolean initialized;
545 static char *ld_elf_hints;
546 struct dt_needed needed;
548 if (!initialized)
549 {
550 FILE *f;
551 char *tmppath;
553 tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, NULL);
554 f = fopen (tmppath, FOPEN_RB);
555 free (tmppath);
556 if (f != NULL)
557 {
558 struct elfhints_hdr hdr;
560 if (fread (&hdr, 1, sizeof (hdr), f) == sizeof (hdr)
561 && hdr.magic == ELFHINTS_MAGIC
562 && hdr.version == 1)
563 {
564 if (fseek (f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1)
565 {
566 char *b;
568 b = xmalloc (hdr.dirlistlen + 1);
569 if (fread (b, 1, hdr.dirlistlen + 1, f) ==
570 hdr.dirlistlen + 1)
571 ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b);
573 free (b);
574 }
575 }
576 fclose (f);
577 }
579 initialized = TRUE;
580 }
582 if (ld_elf_hints == NULL)
583 return FALSE;
585 needed.by = NULL;
586 needed.name = name;
587 return gld${EMULATION_NAME}_search_needed (ld_elf_hints, & needed,
588 force);
589 }
590 EOF
591 # FreeBSD
592 ;;
594 *-*-linux-* | *-*-k*bsd*-*)
595 cat >>e${EMULATION_NAME}.c <<EOF
596 /* For a native linker, check the file /etc/ld.so.conf for directories
597 in which we may find shared libraries. /etc/ld.so.conf is really
598 only meaningful on Linux. */
600 struct gld${EMULATION_NAME}_ld_so_conf
601 {
602 char *path;
603 size_t len, alloc;
604 };
606 static bfd_boolean
607 gld${EMULATION_NAME}_parse_ld_so_conf
608 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
610 static void
611 gld${EMULATION_NAME}_parse_ld_so_conf_include
612 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
613 const char *pattern)
614 {
615 char *newp = NULL;
616 #ifdef HAVE_GLOB
617 glob_t gl;
618 #endif
620 if (pattern[0] != '/')
621 {
622 char *p = strrchr (filename, '/');
623 size_t patlen = strlen (pattern) + 1;
625 newp = xmalloc (p - filename + 1 + patlen);
626 memcpy (newp, filename, p - filename + 1);
627 memcpy (newp + (p - filename + 1), pattern, patlen);
628 pattern = newp;
629 }
631 #ifdef HAVE_GLOB
632 if (glob (pattern, 0, NULL, &gl) == 0)
633 {
634 size_t i;
636 for (i = 0; i < gl.gl_pathc; ++i)
637 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
638 globfree (&gl);
639 }
640 #else
641 /* If we do not have glob, treat the pattern as a literal filename. */
642 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
643 #endif
645 if (newp)
646 free (newp);
647 }
649 static bfd_boolean
650 gld${EMULATION_NAME}_parse_ld_so_conf
651 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
652 {
653 FILE *f = fopen (filename, FOPEN_RT);
654 char *line;
655 size_t linelen;
657 if (f == NULL)
658 return FALSE;
660 linelen = 256;
661 line = xmalloc (linelen);
662 do
663 {
664 char *p = line, *q;
666 /* Normally this would use getline(3), but we need to be portable. */
667 while ((q = fgets (p, linelen - (p - line), f)) != NULL
668 && strlen (q) == linelen - (p - line) - 1
669 && line[linelen - 2] != '\n')
670 {
671 line = xrealloc (line, 2 * linelen);
672 p = line + linelen - 1;
673 linelen += linelen;
674 }
676 if (q == NULL && p == line)
677 break;
679 p = strchr (line, '\n');
680 if (p)
681 *p = '\0';
683 /* Because the file format does not know any form of quoting we
684 can search forward for the next '#' character and if found
685 make it terminating the line. */
686 p = strchr (line, '#');
687 if (p)
688 *p = '\0';
690 /* Remove leading whitespace. NUL is no whitespace character. */
691 p = line;
692 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
693 ++p;
695 /* If the line is blank it is ignored. */
696 if (p[0] == '\0')
697 continue;
699 if (!strncmp (p, "include", 7) && (p[7] == ' ' || p[7] == '\t'))
700 {
701 char *dir, c;
702 p += 8;
703 do
704 {
705 while (*p == ' ' || *p == '\t')
706 ++p;
708 if (*p == '\0')
709 break;
711 dir = p;
713 while (*p != ' ' && *p != '\t' && *p)
714 ++p;
716 c = *p;
717 *p++ = '\0';
718 if (dir[0] != '\0')
719 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
720 dir);
721 }
722 while (c != '\0');
723 }
724 else
725 {
726 char *dir = p;
727 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
728 && *p != '\r' && *p != '\v')
729 ++p;
731 while (p != dir && p[-1] == '/')
732 --p;
733 if (info->path == NULL)
734 {
735 info->alloc = p - dir + 1 + 256;
736 info->path = xmalloc (info->alloc);
737 info->len = 0;
738 }
739 else
740 {
741 if (info->len + 1 + (p - dir) >= info->alloc)
742 {
743 info->alloc += p - dir + 256;
744 info->path = xrealloc (info->path, info->alloc);
745 }
746 info->path[info->len++] = ':';
747 }
748 memcpy (info->path + info->len, dir, p - dir);
749 info->len += p - dir;
750 info->path[info->len] = '\0';
751 }
752 }
753 while (! feof (f));
754 free (line);
755 fclose (f);
756 return TRUE;
757 }
759 static bfd_boolean
760 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
761 {
762 static bfd_boolean initialized;
763 static char *ld_so_conf;
764 struct dt_needed needed;
766 if (! initialized)
767 {
768 char *tmppath;
769 struct gld${EMULATION_NAME}_ld_so_conf info;
771 info.path = NULL;
772 info.len = info.alloc = 0;
773 tmppath = concat (ld_sysroot, "${prefix}/etc/ld.so.conf", NULL);
774 if (!gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath))
775 {
776 free (tmppath);
777 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
778 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
779 }
780 free (tmppath);
782 if (info.path)
783 {
784 char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
785 free (info.path);
786 ld_so_conf = d;
787 }
788 initialized = TRUE;
789 }
791 if (ld_so_conf == NULL)
792 return FALSE;
795 needed.by = NULL;
796 needed.name = name;
797 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
798 }
800 EOF
801 # Linux
802 ;;
803 esac
804 fi
805 cat >>e${EMULATION_NAME}.c <<EOF
807 /* See if an input file matches a DT_NEEDED entry by name. */
809 static void
810 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
811 {
812 if (global_found)
813 return;
815 /* If this input file was an as-needed entry, and wasn't found to be
816 needed at the stage it was linked, then don't say we have loaded it. */
817 if (s->as_needed
818 && (s->the_bfd == NULL
819 || (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0))
820 return;
822 if (s->filename != NULL)
823 {
824 const char *f;
826 if (strcmp (s->filename, global_needed->name) == 0)
827 {
828 global_found = TRUE;
829 return;
830 }
832 if (s->search_dirs_flag)
833 {
834 f = strrchr (s->filename, '/');
835 if (f != NULL
836 && strcmp (f + 1, global_needed->name) == 0)
837 {
838 global_found = TRUE;
839 return;
840 }
841 }
842 }
844 if (s->the_bfd != NULL)
845 {
846 const char *soname;
848 soname = bfd_elf_get_dt_soname (s->the_bfd);
849 if (soname != NULL
850 && strcmp (soname, global_needed->name) == 0)
851 {
852 global_found = TRUE;
853 return;
854 }
855 }
856 }
858 EOF
860 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
861 cat >>e${EMULATION_NAME}.c <<EOF
863 /* This is called after all the input files have been opened. */
865 static void
866 gld${EMULATION_NAME}_after_open (void)
867 {
868 struct bfd_link_needed_list *needed, *l;
870 /* We only need to worry about this when doing a final link. */
871 if (link_info.relocatable || !link_info.executable)
872 return;
874 /* Get the list of files which appear in DT_NEEDED entries in
875 dynamic objects included in the link (often there will be none).
876 For each such file, we want to track down the corresponding
877 library, and include the symbol table in the link. This is what
878 the runtime dynamic linker will do. Tracking the files down here
879 permits one dynamic object to include another without requiring
880 special action by the person doing the link. Note that the
881 needed list can actually grow while we are stepping through this
882 loop. */
883 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
884 for (l = needed; l != NULL; l = l->next)
885 {
886 struct bfd_link_needed_list *ll;
887 struct dt_needed n, nn;
888 int force;
890 /* If the lib that needs this one was --as-needed and wasn't
891 found to be needed, then this lib isn't needed either. */
892 if (l->by != NULL
893 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
894 continue;
896 /* If we've already seen this file, skip it. */
897 for (ll = needed; ll != l; ll = ll->next)
898 if ((ll->by == NULL
899 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
900 && strcmp (ll->name, l->name) == 0)
901 break;
902 if (ll != l)
903 continue;
905 /* See if this file was included in the link explicitly. */
906 global_needed = l;
907 global_found = FALSE;
908 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
909 if (global_found)
910 continue;
912 n.by = l->by;
913 n.name = l->name;
914 nn.by = l->by;
915 if (trace_file_tries)
916 info_msg (_("%s needed by %B\n"), l->name, l->by);
918 /* We need to find this file and include the symbol table. We
919 want to search for the file in the same way that the dynamic
920 linker will search. That means that we want to use
921 rpath_link, rpath, then the environment variable
922 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
923 entries (native only), then the linker script LIB_SEARCH_DIRS.
924 We do not search using the -L arguments.
926 We search twice. The first time, we skip objects which may
927 introduce version mismatches. The second time, we force
928 their use. See gld${EMULATION_NAME}_vercheck comment. */
929 for (force = 0; force < 2; force++)
930 {
931 size_t len;
932 search_dirs_type *search;
933 EOF
934 if [ "x${NATIVE}" = xyes ] ; then
935 cat >>e${EMULATION_NAME}.c <<EOF
936 const char *lib_path;
937 EOF
938 fi
939 if [ "x${USE_LIBPATH}" = xyes ] ; then
940 cat >>e${EMULATION_NAME}.c <<EOF
941 struct bfd_link_needed_list *rp;
942 int found;
943 EOF
944 fi
945 cat >>e${EMULATION_NAME}.c <<EOF
947 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
948 &n, force))
949 break;
950 EOF
951 if [ "x${USE_LIBPATH}" = xyes ] ; then
952 cat >>e${EMULATION_NAME}.c <<EOF
953 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
954 &n, force))
955 break;
956 EOF
957 fi
958 if [ "x${NATIVE}" = xyes ] ; then
959 cat >>e${EMULATION_NAME}.c <<EOF
960 if (command_line.rpath_link == NULL
961 && command_line.rpath == NULL)
962 {
963 lib_path = (const char *) getenv ("LD_RUN_PATH");
964 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
965 force))
966 break;
967 }
968 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
969 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
970 break;
971 EOF
972 fi
973 if [ "x${USE_LIBPATH}" = xyes ] ; then
974 cat >>e${EMULATION_NAME}.c <<EOF
975 found = 0;
976 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
977 for (; !found && rp != NULL; rp = rp->next)
978 {
979 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
980 found = (rp->by == l->by
981 && gld${EMULATION_NAME}_search_needed (tmpname,
982 &n,
983 force));
984 free (tmpname);
985 }
986 if (found)
987 break;
989 EOF
990 fi
991 if [ "x${USE_LIBPATH}" = xyes ] ; then
992 case ${target} in
993 *-*-freebsd* | *-*-dragonfly*)
994 cat >>e${EMULATION_NAME}.c <<EOF
995 if (gld${EMULATION_NAME}_check_ld_elf_hints (l->name, force))
996 break;
997 EOF
998 # FreeBSD
999 ;;
1001 *-*-linux-* | *-*-k*bsd*-*)
1002 # Linux
1003 cat >>e${EMULATION_NAME}.c <<EOF
1004 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
1005 break;
1007 EOF
1008 ;;
1009 esac
1010 fi
1011 cat >>e${EMULATION_NAME}.c <<EOF
1012 len = strlen (l->name);
1013 for (search = search_head; search != NULL; search = search->next)
1014 {
1015 char *filename;
1017 if (search->cmdline)
1018 continue;
1019 filename = (char *) xmalloc (strlen (search->name) + len + 2);
1020 sprintf (filename, "%s/%s", search->name, l->name);
1021 nn.name = filename;
1022 if (gld${EMULATION_NAME}_try_needed (&nn, force))
1023 break;
1024 free (filename);
1025 }
1026 if (search != NULL)
1027 break;
1028 EOF
1029 cat >>e${EMULATION_NAME}.c <<EOF
1030 }
1032 if (force < 2)
1033 continue;
1035 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
1036 l->name, l->by);
1037 }
1038 }
1040 EOF
1041 fi
1043 cat >>e${EMULATION_NAME}.c <<EOF
1045 /* Look through an expression for an assignment statement. */
1047 static void
1048 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1049 {
1050 bfd_boolean provide = FALSE;
1052 switch (exp->type.node_class)
1053 {
1054 case etree_provide:
1055 provide = TRUE;
1056 /* Fall thru */
1057 case etree_assign:
1058 /* We call record_link_assignment even if the symbol is defined.
1059 This is because if it is defined by a dynamic object, we
1060 actually want to use the value defined by the linker script,
1061 not the value from the dynamic object (because we are setting
1062 symbols like etext). If the symbol is defined by a regular
1063 object, then, as it happens, calling record_link_assignment
1064 will do no harm. */
1065 if (strcmp (exp->assign.dst, ".") != 0)
1066 {
1067 if (!bfd_elf_record_link_assignment (output_bfd, &link_info,
1068 exp->assign.dst, provide,
1069 exp->assign.hidden))
1070 einfo ("%P%F: failed to record assignment to %s: %E\n",
1071 exp->assign.dst);
1072 }
1073 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1074 break;
1076 case etree_binary:
1077 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1078 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1079 break;
1081 case etree_trinary:
1082 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1083 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1084 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1085 break;
1087 case etree_unary:
1088 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1089 break;
1091 default:
1092 break;
1093 }
1094 }
1097 /* This is called by the before_allocation routine via
1098 lang_for_each_statement. It locates any assignment statements, and
1099 tells the ELF backend about them, in case they are assignments to
1100 symbols which are referred to by dynamic objects. */
1102 static void
1103 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1104 {
1105 if (s->header.type == lang_assignment_statement_enum)
1106 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1107 }
1109 EOF
1111 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1112 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1113 ELF_INTERPRETER_SET_DEFAULT="
1114 if (sinterp != NULL)
1115 {
1116 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1117 sinterp->size = strlen ((char *) sinterp->contents) + 1;
1118 }
1120 "
1121 else
1122 ELF_INTERPRETER_SET_DEFAULT=
1123 fi
1124 cat >>e${EMULATION_NAME}.c <<EOF
1126 /* This is called after the sections have been attached to output
1127 sections, but before any sizes or addresses have been set. */
1129 static void
1130 gld${EMULATION_NAME}_before_allocation (void)
1131 {
1132 const char *rpath;
1133 asection *sinterp;
1135 if (link_info.hash->type == bfd_link_elf_hash_table)
1136 _bfd_elf_tls_setup (output_bfd, &link_info);
1138 /* If we are going to make any variable assignments, we need to let
1139 the ELF backend know about them in case the variables are
1140 referred to by dynamic objects. */
1141 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1143 /* Let the ELF backend work out the sizes of any sections required
1144 by dynamic linking. */
1145 rpath = command_line.rpath;
1146 if (rpath == NULL)
1147 rpath = (const char *) getenv ("LD_RUN_PATH");
1148 if (! (bfd_elf_size_dynamic_sections
1149 (output_bfd, command_line.soname, rpath,
1150 command_line.filter_shlib,
1151 (const char * const *) command_line.auxiliary_filters,
1152 &link_info, &sinterp, lang_elf_version_info)))
1153 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1155 ${ELF_INTERPRETER_SET_DEFAULT}
1156 /* Let the user override the dynamic linker we are using. */
1157 if (command_line.interpreter != NULL
1158 && sinterp != NULL)
1159 {
1160 sinterp->contents = (bfd_byte *) command_line.interpreter;
1161 sinterp->size = strlen (command_line.interpreter) + 1;
1162 }
1164 /* Look for any sections named .gnu.warning. As a GNU extensions,
1165 we treat such sections as containing warning messages. We print
1166 out the warning message, and then zero out the section size so
1167 that it does not get copied into the output file. */
1169 {
1170 LANG_FOR_EACH_INPUT_STATEMENT (is)
1171 {
1172 asection *s;
1173 bfd_size_type sz;
1174 bfd_size_type prefix_len;
1175 char *msg;
1176 bfd_boolean ret;
1177 const char * gnu_warning_prefix = _("warning: ");
1179 if (is->just_syms_flag)
1180 continue;
1182 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1183 if (s == NULL)
1184 continue;
1186 sz = s->size;
1187 prefix_len = strlen (gnu_warning_prefix);
1188 msg = xmalloc ((size_t) (prefix_len + sz + 1));
1189 strcpy (msg, gnu_warning_prefix);
1190 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
1191 (file_ptr) 0, sz))
1192 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1193 is->the_bfd);
1194 msg[prefix_len + sz] = '\0';
1195 ret = link_info.callbacks->warning (&link_info, msg,
1196 (const char *) NULL,
1197 is->the_bfd, (asection *) NULL,
1198 (bfd_vma) 0);
1199 ASSERT (ret);
1200 free (msg);
1202 /* Clobber the section size, so that we don't waste copying the
1203 warning into the output file. */
1204 s->size = 0;
1206 /* Also set SEC_EXCLUDE, so that symbols defined in the warning
1207 section don't get copied to the output. */
1208 s->flags |= SEC_EXCLUDE;
1209 }
1210 }
1212 before_allocation_default ();
1214 if (!bfd_elf_size_dynsym_hash_dynstr (output_bfd, &link_info))
1215 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1216 }
1218 EOF
1219 fi
1221 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1222 cat >>e${EMULATION_NAME}.c <<EOF
1224 /* Try to open a dynamic archive. This is where we know that ELF
1225 dynamic libraries have an extension of .so (or .sl on oddball systems
1226 like hpux). */
1228 static bfd_boolean
1229 gld${EMULATION_NAME}_open_dynamic_archive
1230 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1231 {
1232 const char *filename;
1233 char *string;
1235 if (! entry->is_archive)
1236 return FALSE;
1238 filename = entry->filename;
1240 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1241 is defined, but it does not seem worth the headache to optimize
1242 away those two bytes of space. */
1243 string = (char *) xmalloc (strlen (search->name)
1244 + strlen (filename)
1245 + strlen (arch)
1246 #ifdef EXTRA_SHLIB_EXTENSION
1247 + strlen (EXTRA_SHLIB_EXTENSION)
1248 #endif
1249 + sizeof "/lib.so");
1251 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1253 #ifdef EXTRA_SHLIB_EXTENSION
1254 /* Try the .so extension first. If that fails build a new filename
1255 using EXTRA_SHLIB_EXTENSION. */
1256 if (! ldfile_try_open_bfd (string, entry))
1257 sprintf (string, "%s/lib%s%s%s", search->name,
1258 filename, arch, EXTRA_SHLIB_EXTENSION);
1259 #endif
1261 if (! ldfile_try_open_bfd (string, entry))
1262 {
1263 free (string);
1264 return FALSE;
1265 }
1267 entry->filename = string;
1269 /* We have found a dynamic object to include in the link. The ELF
1270 backend linker will create a DT_NEEDED entry in the .dynamic
1271 section naming this file. If this file includes a DT_SONAME
1272 entry, it will be used. Otherwise, the ELF linker will just use
1273 the name of the file. For an archive found by searching, like
1274 this one, the DT_NEEDED entry should consist of just the name of
1275 the file, without the path information used to find it. Note
1276 that we only need to do this if we have a dynamic object; an
1277 archive will never be referenced by a DT_NEEDED entry.
1279 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1280 very pretty. I haven't been able to think of anything that is
1281 pretty, though. */
1282 if (bfd_check_format (entry->the_bfd, bfd_object)
1283 && (entry->the_bfd->flags & DYNAMIC) != 0)
1284 {
1285 ASSERT (entry->is_archive && entry->search_dirs_flag);
1287 /* Rather than duplicating the logic above. Just use the
1288 filename we recorded earlier. */
1290 filename = lbasename (entry->filename);
1291 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1292 }
1294 return TRUE;
1295 }
1297 EOF
1298 fi
1300 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1301 cat >>e${EMULATION_NAME}.c <<EOF
1303 /* A variant of lang_output_section_find used by place_orphan. */
1305 static lang_output_section_statement_type *
1306 output_rel_find (asection *sec, int isdyn)
1307 {
1308 lang_output_section_statement_type *lookup;
1309 lang_output_section_statement_type *last = NULL;
1310 lang_output_section_statement_type *last_alloc = NULL;
1311 lang_output_section_statement_type *last_rel = NULL;
1312 lang_output_section_statement_type *last_rel_alloc = NULL;
1313 int rela = sec->name[4] == 'a';
1315 for (lookup = &lang_output_section_statement.head->output_section_statement;
1316 lookup != NULL;
1317 lookup = lookup->next)
1318 {
1319 if (lookup->constraint != -1
1320 && strncmp (".rel", lookup->name, 4) == 0)
1321 {
1322 int lookrela = lookup->name[4] == 'a';
1324 /* .rel.dyn must come before all other reloc sections, to suit
1325 GNU ld.so. */
1326 if (isdyn)
1327 break;
1329 /* Don't place after .rel.plt as doing so results in wrong
1330 dynamic tags. */
1331 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1332 break;
1334 if (rela == lookrela || last_rel == NULL)
1335 last_rel = lookup;
1336 if ((rela == lookrela || last_rel_alloc == NULL)
1337 && lookup->bfd_section != NULL
1338 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1339 last_rel_alloc = lookup;
1340 }
1342 last = lookup;
1343 if (lookup->bfd_section != NULL
1344 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1345 last_alloc = lookup;
1346 }
1348 if (last_rel_alloc)
1349 return last_rel_alloc;
1351 if (last_rel)
1352 return last_rel;
1354 if (last_alloc)
1355 return last_alloc;
1357 return last;
1358 }
1360 /* Place an orphan section. We use this to put random SHF_ALLOC
1361 sections in the right segment. */
1363 static bfd_boolean
1364 gld${EMULATION_NAME}_place_orphan (asection *s)
1365 {
1366 static struct orphan_save hold[] =
1367 {
1368 { ".text",
1369 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1370 0, 0, 0, 0 },
1371 { ".rodata",
1372 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1373 0, 0, 0, 0 },
1374 { ".data",
1375 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1376 0, 0, 0, 0 },
1377 { ".bss",
1378 SEC_ALLOC,
1379 0, 0, 0, 0 },
1380 { 0,
1381 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1382 0, 0, 0, 0 },
1383 { ".interp",
1384 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1385 0, 0, 0, 0 },
1386 { ".sdata",
1387 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1388 0, 0, 0, 0 }
1389 };
1390 enum orphan_save_index
1391 {
1392 orphan_text = 0,
1393 orphan_rodata,
1394 orphan_data,
1395 orphan_bss,
1396 orphan_rel,
1397 orphan_interp,
1398 orphan_sdata
1399 };
1400 static int orphan_init_done = 0;
1401 struct orphan_save *place;
1402 const char *secname;
1403 lang_output_section_statement_type *after;
1404 lang_output_section_statement_type *os;
1405 int isdyn = 0;
1406 int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1407 unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1409 secname = bfd_get_section_name (s->owner, s);
1411 if (! link_info.relocatable
1412 && link_info.combreloc
1413 && (s->flags & SEC_ALLOC))
1414 {
1415 if (iself)
1416 switch (sh_type)
1417 {
1418 case SHT_RELA:
1419 secname = ".rela.dyn";
1420 isdyn = 1;
1421 break;
1422 case SHT_REL:
1423 secname = ".rel.dyn";
1424 isdyn = 1;
1425 break;
1426 default:
1427 break;
1428 }
1429 else if (strncmp (secname, ".rel", 4) == 0)
1430 {
1431 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1432 isdyn = 1;
1433 }
1434 }
1436 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1437 {
1438 /* Look through the script to see where to place this section. */
1439 os = lang_output_section_find (secname);
1441 if (os != NULL
1442 && (os->bfd_section == NULL
1443 || os->bfd_section->flags == 0
1444 || (_bfd_elf_match_sections_by_type (output_bfd,
1445 os->bfd_section,
1446 s->owner, s)
1447 && ((s->flags ^ os->bfd_section->flags)
1448 & (SEC_LOAD | SEC_ALLOC)) == 0)))
1449 {
1450 /* We already have an output section statement with this
1451 name, and its bfd section, if any, has compatible flags.
1452 If the section already exists but does not have any flags
1453 set, then it has been created by the linker, probably as a
1454 result of a --section-start command line switch. */
1455 lang_add_section (&os->children, s, os);
1456 return TRUE;
1457 }
1458 }
1460 if (!orphan_init_done)
1461 {
1462 struct orphan_save *ho;
1463 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1464 if (ho->name != NULL)
1465 {
1466 ho->os = lang_output_section_find (ho->name);
1467 if (ho->os != NULL && ho->os->flags == 0)
1468 ho->os->flags = ho->flags;
1469 }
1470 orphan_init_done = 1;
1471 }
1473 /* If this is a final link, then always put .gnu.warning.SYMBOL
1474 sections into the .text section to get them out of the way. */
1475 if (link_info.executable
1476 && ! link_info.relocatable
1477 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1478 && hold[orphan_text].os != NULL)
1479 {
1480 lang_add_section (&hold[orphan_text].os->children, s,
1481 hold[orphan_text].os);
1482 return TRUE;
1483 }
1485 /* Decide which segment the section should go in based on the
1486 section name and section flags. We put loadable .note sections
1487 right after the .interp section, so that the PT_NOTE segment is
1488 stored right after the program headers where the OS can read it
1489 in the first page. */
1491 place = NULL;
1492 if ((s->flags & SEC_ALLOC) == 0)
1493 ;
1494 else if ((s->flags & SEC_LOAD) != 0
1495 && ((iself && sh_type == SHT_NOTE)
1496 || (!iself && strncmp (secname, ".note", 5) == 0)))
1497 place = &hold[orphan_interp];
1498 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1499 place = &hold[orphan_bss];
1500 else if ((s->flags & SEC_SMALL_DATA) != 0)
1501 place = &hold[orphan_sdata];
1502 else if ((s->flags & SEC_READONLY) == 0)
1503 place = &hold[orphan_data];
1504 else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
1505 || (!iself && strncmp (secname, ".rel", 4) == 0))
1506 && (s->flags & SEC_LOAD) != 0)
1507 place = &hold[orphan_rel];
1508 else if ((s->flags & SEC_CODE) == 0)
1509 place = &hold[orphan_rodata];
1510 else
1511 place = &hold[orphan_text];
1513 after = NULL;
1514 if (place != NULL)
1515 {
1516 if (place->os == NULL)
1517 {
1518 if (place->name != NULL)
1519 place->os = lang_output_section_find (place->name);
1520 else
1521 place->os = output_rel_find (s, isdyn);
1522 }
1523 after = place->os;
1524 if (after == NULL)
1525 after = lang_output_section_find_by_flags
1526 (s, &place->os, _bfd_elf_match_sections_by_type);
1527 if (after == NULL)
1528 /* *ABS* is always the first output section statement. */
1529 after = &lang_output_section_statement.head->output_section_statement;
1530 }
1532 /* Choose a unique name for the section. This will be needed if the
1533 same section name appears in the input file with different
1534 loadable or allocatable characteristics. */
1535 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1536 {
1537 static int count = 1;
1538 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1539 if (secname == NULL)
1540 einfo ("%F%P: place_orphan failed: %E\n");
1541 }
1543 lang_insert_orphan (s, secname, after, place, NULL, NULL);
1545 return TRUE;
1546 }
1547 EOF
1548 fi
1550 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1551 cat >>e${EMULATION_NAME}.c <<EOF
1553 static void
1554 gld${EMULATION_NAME}_layout_sections_again (void)
1555 {
1556 lang_reset_memory_regions ();
1558 /* Resize the sections. */
1559 lang_size_sections (NULL, TRUE);
1561 /* Redo special stuff. */
1562 ldemul_after_allocation ();
1564 /* Do the assignments again. */
1565 lang_do_assignments ();
1566 }
1568 static void
1569 gld${EMULATION_NAME}_finish (void)
1570 {
1571 if (bfd_elf_discard_info (output_bfd, &link_info))
1572 gld${EMULATION_NAME}_layout_sections_again ();
1574 finish_default ();
1575 }
1576 EOF
1577 fi
1579 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1580 cat >>e${EMULATION_NAME}.c <<EOF
1582 static char *
1583 gld${EMULATION_NAME}_get_script (int *isfile)
1584 EOF
1586 if test -n "$COMPILE_IN"
1587 then
1588 # Scripts compiled in.
1590 # sed commands to quote an ld script as a C string.
1591 sc="-f stringify.sed"
1593 cat >>e${EMULATION_NAME}.c <<EOF
1594 {
1595 *isfile = 0;
1597 if (link_info.relocatable && config.build_constructors)
1598 return
1599 EOF
1600 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1601 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1602 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1603 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1604 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1605 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1606 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1607 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1608 fi
1609 if test -n "$GENERATE_PIE_SCRIPT" ; then
1610 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1611 echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1612 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1613 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1614 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
1615 echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1616 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
1617 fi
1618 echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1619 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
1620 fi
1621 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1622 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1623 echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1624 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1625 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1626 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
1627 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1628 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1629 fi
1630 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1631 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1632 fi
1633 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1634 echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1635 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1636 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
1637 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1638 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1639 fi
1640 echo ' ; else return' >> e${EMULATION_NAME}.c
1641 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1642 echo '; }' >> e${EMULATION_NAME}.c
1644 else
1645 # Scripts read from the filesystem.
1647 cat >>e${EMULATION_NAME}.c <<EOF
1648 {
1649 *isfile = 1;
1651 if (link_info.relocatable && config.build_constructors)
1652 return "ldscripts/${EMULATION_NAME}.xu";
1653 else if (link_info.relocatable)
1654 return "ldscripts/${EMULATION_NAME}.xr";
1655 else if (!config.text_read_only)
1656 return "ldscripts/${EMULATION_NAME}.xbn";
1657 EOF
1658 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1659 else
1660 cat >>e${EMULATION_NAME}.c <<EOF
1661 else if (!config.magic_demand_paged)
1662 return "ldscripts/${EMULATION_NAME}.xn";
1663 EOF
1664 fi
1665 if test -n "$GENERATE_PIE_SCRIPT" ; then
1666 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1667 cat >>e${EMULATION_NAME}.c <<EOF
1668 else if (link_info.pie && link_info.combreloc
1669 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1670 return "ldscripts/${EMULATION_NAME}.xdw";
1671 else if (link_info.pie && link_info.combreloc)
1672 return "ldscripts/${EMULATION_NAME}.xdc";
1673 EOF
1674 fi
1675 cat >>e${EMULATION_NAME}.c <<EOF
1676 else if (link_info.pie)
1677 return "ldscripts/${EMULATION_NAME}.xd";
1678 EOF
1679 fi
1680 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1681 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1682 cat >>e${EMULATION_NAME}.c <<EOF
1683 else if (link_info.shared && link_info.combreloc
1684 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1685 return "ldscripts/${EMULATION_NAME}.xsw";
1686 else if (link_info.shared && link_info.combreloc)
1687 return "ldscripts/${EMULATION_NAME}.xsc";
1688 EOF
1689 fi
1690 cat >>e${EMULATION_NAME}.c <<EOF
1691 else if (link_info.shared)
1692 return "ldscripts/${EMULATION_NAME}.xs";
1693 EOF
1694 fi
1695 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1696 cat >>e${EMULATION_NAME}.c <<EOF
1697 else if (link_info.combreloc && link_info.relro
1698 && (link_info.flags & DT_BIND_NOW))
1699 return "ldscripts/${EMULATION_NAME}.xw";
1700 else if (link_info.combreloc)
1701 return "ldscripts/${EMULATION_NAME}.xc";
1702 EOF
1703 fi
1704 cat >>e${EMULATION_NAME}.c <<EOF
1705 else
1706 return "ldscripts/${EMULATION_NAME}.x";
1707 }
1709 EOF
1710 fi
1711 fi
1713 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1715 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1716 cat >>e${EMULATION_NAME}.c <<EOF
1717 $PARSE_AND_LIST_PROLOGUE
1718 EOF
1719 fi
1721 cat >>e${EMULATION_NAME}.c <<EOF
1723 #define OPTION_DISABLE_NEW_DTAGS (400)
1724 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1725 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1726 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1727 #define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1)
1729 static void
1730 gld${EMULATION_NAME}_add_options
1731 (int ns, char **shortopts, int nl, struct option **longopts,
1732 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1733 {
1734 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1735 static const struct option xtra_long[] = {
1736 EOF
1738 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1739 cat >>e${EMULATION_NAME}.c <<EOF
1740 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1741 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1742 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1743 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
1744 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1745 EOF
1746 fi
1748 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1749 cat >>e${EMULATION_NAME}.c <<EOF
1750 $PARSE_AND_LIST_LONGOPTS
1751 EOF
1752 fi
1754 cat >>e${EMULATION_NAME}.c <<EOF
1755 {NULL, no_argument, NULL, 0}
1756 };
1758 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1759 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1760 *longopts = (struct option *)
1761 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1762 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1763 }
1765 static bfd_boolean
1766 gld${EMULATION_NAME}_handle_option (int optc)
1767 {
1768 switch (optc)
1769 {
1770 default:
1771 return FALSE;
1773 EOF
1775 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1776 cat >>e${EMULATION_NAME}.c <<EOF
1777 case OPTION_DISABLE_NEW_DTAGS:
1778 link_info.new_dtags = FALSE;
1779 break;
1781 case OPTION_ENABLE_NEW_DTAGS:
1782 link_info.new_dtags = TRUE;
1783 break;
1785 case OPTION_EH_FRAME_HDR:
1786 link_info.eh_frame_hdr = TRUE;
1787 break;
1789 case OPTION_GROUP:
1790 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1791 /* Groups must be self-contained. */
1792 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1793 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1794 break;
1796 case OPTION_EXCLUDE_LIBS:
1797 add_excluded_libs (optarg);
1798 break;
1800 case 'z':
1801 if (strcmp (optarg, "initfirst") == 0)
1802 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1803 else if (strcmp (optarg, "interpose") == 0)
1804 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1805 else if (strcmp (optarg, "loadfltr") == 0)
1806 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1807 else if (strcmp (optarg, "nodefaultlib") == 0)
1808 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1809 else if (strcmp (optarg, "nodelete") == 0)
1810 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1811 else if (strcmp (optarg, "nodlopen") == 0)
1812 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1813 else if (strcmp (optarg, "nodump") == 0)
1814 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1815 else if (strcmp (optarg, "now") == 0)
1816 {
1817 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1818 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1819 }
1820 else if (strcmp (optarg, "origin") == 0)
1821 {
1822 link_info.flags |= (bfd_vma) DF_ORIGIN;
1823 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1824 }
1825 else if (strcmp (optarg, "defs") == 0)
1826 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1827 else if (strcmp (optarg, "muldefs") == 0)
1828 link_info.allow_multiple_definition = TRUE;
1829 else if (strcmp (optarg, "combreloc") == 0)
1830 link_info.combreloc = TRUE;
1831 else if (strcmp (optarg, "nocombreloc") == 0)
1832 link_info.combreloc = FALSE;
1833 else if (strcmp (optarg, "nocopyreloc") == 0)
1834 link_info.nocopyreloc = TRUE;
1835 else if (strcmp (optarg, "execstack") == 0)
1836 {
1837 link_info.execstack = TRUE;
1838 link_info.noexecstack = FALSE;
1839 }
1840 else if (strcmp (optarg, "noexecstack") == 0)
1841 {
1842 link_info.noexecstack = TRUE;
1843 link_info.execstack = FALSE;
1844 }
1845 else if (strcmp (optarg, "relro") == 0)
1846 link_info.relro = TRUE;
1847 else if (strcmp (optarg, "norelro") == 0)
1848 link_info.relro = FALSE;
1849 /* What about the other Solaris -z options? FIXME. */
1850 break;
1851 EOF
1852 fi
1854 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1855 cat >>e${EMULATION_NAME}.c <<EOF
1856 $PARSE_AND_LIST_ARGS_CASES
1857 EOF
1858 fi
1860 cat >>e${EMULATION_NAME}.c <<EOF
1861 }
1863 return TRUE;
1864 }
1866 EOF
1868 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1869 cat >>e${EMULATION_NAME}.c <<EOF
1871 static void
1872 gld${EMULATION_NAME}_list_options (FILE * file)
1873 {
1874 EOF
1876 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1877 cat >>e${EMULATION_NAME}.c <<EOF
1878 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1879 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1880 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1881 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1882 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1883 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n"));
1884 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n"));
1885 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1886 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1887 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1888 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1889 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1890 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1891 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1892 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1893 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1894 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1895 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n"));
1896 fprintf (file, _(" -z norelro\t\tDon't create RELRO program header\n"));
1897 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1898 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1899 fprintf (file, _(" -z relro\t\tCreate RELRO program header\n"));
1900 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1901 EOF
1902 fi
1904 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1905 cat >>e${EMULATION_NAME}.c <<EOF
1906 $PARSE_AND_LIST_OPTIONS
1907 EOF
1908 fi
1910 cat >>e${EMULATION_NAME}.c <<EOF
1911 }
1912 EOF
1914 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1915 cat >>e${EMULATION_NAME}.c <<EOF
1916 $PARSE_AND_LIST_EPILOGUE
1917 EOF
1918 fi
1919 fi
1920 else
1921 cat >>e${EMULATION_NAME}.c <<EOF
1922 #define gld${EMULATION_NAME}_add_options NULL
1923 #define gld${EMULATION_NAME}_handle_option NULL
1924 EOF
1925 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1926 cat >>e${EMULATION_NAME}.c <<EOF
1927 #define gld${EMULATION_NAME}_list_options NULL
1928 EOF
1929 fi
1930 fi
1932 cat >>e${EMULATION_NAME}.c <<EOF
1934 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1935 {
1936 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1937 ${LDEMUL_SYSLIB-syslib_default},
1938 ${LDEMUL_HLL-hll_default},
1939 ${LDEMUL_AFTER_PARSE-after_parse_default},
1940 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1941 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1942 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1943 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1944 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1945 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1946 "${EMULATION_NAME}",
1947 "${OUTPUT_FORMAT}",
1948 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1949 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1950 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1951 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1952 ${LDEMUL_SET_SYMBOLS-NULL},
1953 ${LDEMUL_PARSE_ARGS-NULL},
1954 gld${EMULATION_NAME}_add_options,
1955 gld${EMULATION_NAME}_handle_option,
1956 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1957 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1958 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1959 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1960 ${LDEMUL_NEW_VERS_PATTERN-NULL}
1961 };
1962 EOF