| blob | b2d2a7c399c92b0fd7e10b16a0a0786f8adc061b |
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 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
36 #define TARGET_IS_${EMULATION_NAME}
38 #include "bfd.h"
39 #include "sysdep.h"
40 #include "libiberty.h"
41 #include "safe-ctype.h"
42 #include "getopt.h"
44 #include "bfdlink.h"
46 #include "ld.h"
47 #include "ldmain.h"
48 #include "ldmisc.h"
49 #include "ldexp.h"
50 #include "ldlang.h"
51 #include "ldfile.h"
52 #include "ldemul.h"
53 #include <ldgram.h>
54 #include "elf/common.h"
56 /* Declare functions used by various EXTRA_EM_FILEs. */
57 static void gld${EMULATION_NAME}_before_parse (void);
58 static void gld${EMULATION_NAME}_after_open (void);
59 static void gld${EMULATION_NAME}_before_allocation (void);
60 static bfd_boolean gld${EMULATION_NAME}_place_orphan
61 (lang_input_statement_type *file, asection *s);
62 static void gld${EMULATION_NAME}_finish (void);
64 EOF
66 if [ "x${USE_LIBPATH}" = xyes ] ; then
67 case ${target} in
68 *-*-linux-gnu*)
69 cat >>e${EMULATION_NAME}.c <<EOF
70 #ifdef HAVE_GLOB
71 #include <glob.h>
72 #endif
73 EOF
74 ;;
75 esac
76 fi
78 # Import any needed special functions and/or overrides.
79 #
80 if test -n "$EXTRA_EM_FILE" ; then
81 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
82 fi
84 # Functions in this file can be overridden by setting the LDEMUL_* shell
85 # variables. If the name of the overriding function is the same as is
86 # defined in this file, then don't output this file's version.
87 # If a different overriding name is given then output the standard function
88 # as presumably it is called from the overriding function.
89 #
90 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
91 cat >>e${EMULATION_NAME}.c <<EOF
93 static void
94 gld${EMULATION_NAME}_before_parse (void)
95 {
96 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
97 config.dynamic_link = ${DYNAMIC_LINK-TRUE};
98 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
99 }
101 EOF
102 fi
104 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
105 cat >>e${EMULATION_NAME}.c <<EOF
106 /* Handle as_needed DT_NEEDED. */
108 static bfd_boolean
109 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
110 {
111 int class = 0;
113 /* Tell the ELF linker that we don't want the output file to have a
114 DT_NEEDED entry for this file, unless it is used to resolve
115 references in a regular object. */
116 if (entry->as_needed)
117 class = DYN_AS_NEEDED;
119 /* Tell the ELF linker that we don't want the output file to have a
120 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
121 this file at all. */
122 if (!entry->add_needed)
123 class |= DYN_NO_ADD_NEEDED;
125 if (!class
126 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
127 return FALSE;
129 bfd_elf_set_dyn_lib_class (entry->the_bfd, class);
131 /* Continue on with normal load_symbols processing. */
132 return FALSE;
133 }
134 EOF
135 fi
137 cat >>e${EMULATION_NAME}.c <<EOF
139 /* These variables are required to pass information back and forth
140 between after_open and check_needed and stat_needed and vercheck. */
142 static struct bfd_link_needed_list *global_needed;
143 static struct stat global_stat;
144 static bfd_boolean global_found;
145 static struct bfd_link_needed_list *global_vercheck_needed;
146 static bfd_boolean global_vercheck_failed;
149 /* On Linux, it's possible to have different versions of the same
150 shared library linked against different versions of libc. The
151 dynamic linker somehow tags which libc version to use in
152 /etc/ld.so.cache, and, based on the libc that it sees in the
153 executable, chooses which version of the shared library to use.
155 We try to do a similar check here by checking whether this shared
156 library needs any other shared libraries which may conflict with
157 libraries we have already included in the link. If it does, we
158 skip it, and try to find another shared library farther on down the
159 link path.
161 This is called via lang_for_each_input_file.
162 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
163 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
164 a conflicting version. */
166 static void
167 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
168 {
169 const char *soname;
170 struct bfd_link_needed_list *l;
172 if (global_vercheck_failed)
173 return;
174 if (s->the_bfd == NULL
175 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
176 return;
178 soname = bfd_elf_get_dt_soname (s->the_bfd);
179 if (soname == NULL)
180 soname = lbasename (bfd_get_filename (s->the_bfd));
182 for (l = global_vercheck_needed; l != NULL; l = l->next)
183 {
184 const char *suffix;
186 if (strcmp (soname, l->name) == 0)
187 {
188 /* Probably can't happen, but it's an easy check. */
189 continue;
190 }
192 if (strchr (l->name, '/') != NULL)
193 continue;
195 suffix = strstr (l->name, ".so.");
196 if (suffix == NULL)
197 continue;
199 suffix += sizeof ".so." - 1;
201 if (strncmp (soname, l->name, suffix - l->name) == 0)
202 {
203 /* Here we know that S is a dynamic object FOO.SO.VER1, and
204 the object we are considering needs a dynamic object
205 FOO.SO.VER2, and VER1 and VER2 are different. This
206 appears to be a version mismatch, so we tell the caller
207 to try a different version of this library. */
208 global_vercheck_failed = TRUE;
209 return;
210 }
211 }
212 }
215 /* See if an input file matches a DT_NEEDED entry by running stat on
216 the file. */
218 static void
219 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
220 {
221 struct stat st;
222 const char *suffix;
223 const char *soname;
225 if (global_found)
226 return;
227 if (s->the_bfd == NULL)
228 return;
230 if (bfd_stat (s->the_bfd, &st) != 0)
231 {
232 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
233 return;
234 }
236 /* Some operating systems, e.g. Windows, do not provide a meaningful
237 st_ino; they always set it to zero. (Windows does provide a
238 meaningful st_dev.) Do not indicate a duplicate library in that
239 case. While there is no guarantee that a system that provides
240 meaningful inode numbers will never set st_ino to zero, this is
241 merely an optimization, so we do not need to worry about false
242 negatives. */
243 if (st.st_dev == global_stat.st_dev
244 && st.st_ino == global_stat.st_ino
245 && st.st_ino != 0)
246 {
247 global_found = TRUE;
248 return;
249 }
251 /* We issue a warning if it looks like we are including two
252 different versions of the same shared library. For example,
253 there may be a problem if -lc picks up libc.so.6 but some other
254 shared library has a DT_NEEDED entry of libc.so.5. This is a
255 heuristic test, and it will only work if the name looks like
256 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
257 If we really want to issue warnings about mixing version numbers
258 of shared libraries, we need to find a better way. */
260 if (strchr (global_needed->name, '/') != NULL)
261 return;
262 suffix = strstr (global_needed->name, ".so.");
263 if (suffix == NULL)
264 return;
265 suffix += sizeof ".so." - 1;
267 soname = bfd_elf_get_dt_soname (s->the_bfd);
268 if (soname == NULL)
269 soname = lbasename (s->filename);
271 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
272 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
273 global_needed->name, global_needed->by, soname);
274 }
276 struct dt_needed
277 {
278 bfd *by;
279 const char *name;
280 };
282 /* This function is called for each possible name for a dynamic object
283 named by a DT_NEEDED entry. The FORCE parameter indicates whether
284 to skip the check for a conflicting version. */
286 static bfd_boolean
287 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
288 int force)
289 {
290 bfd *abfd;
291 const char *name = needed->name;
292 const char *soname;
293 int class;
295 abfd = bfd_openr (name, bfd_get_target (output_bfd));
296 if (abfd == NULL)
297 return FALSE;
298 if (! bfd_check_format (abfd, bfd_object))
299 {
300 bfd_close (abfd);
301 return FALSE;
302 }
303 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
304 {
305 bfd_close (abfd);
306 return FALSE;
307 }
309 /* For DT_NEEDED, they have to match. */
310 if (abfd->xvec != output_bfd->xvec)
311 {
312 bfd_close (abfd);
313 return FALSE;
314 }
316 /* Check whether this object would include any conflicting library
317 versions. If FORCE is set, then we skip this check; we use this
318 the second time around, if we couldn't find any compatible
319 instance of the shared library. */
321 if (! force)
322 {
323 struct bfd_link_needed_list *needed;
325 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
326 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
328 if (needed != NULL)
329 {
330 global_vercheck_needed = needed;
331 global_vercheck_failed = FALSE;
332 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
333 if (global_vercheck_failed)
334 {
335 bfd_close (abfd);
336 /* Return FALSE to force the caller to move on to try
337 another file on the search path. */
338 return FALSE;
339 }
341 /* But wait! It gets much worse. On Linux, if a shared
342 library does not use libc at all, we are supposed to skip
343 it the first time around in case we encounter a shared
344 library later on with the same name which does use the
345 version of libc that we want. This is much too horrible
346 to use on any system other than Linux. */
348 EOF
349 case ${target} in
350 *-*-linux-gnu*)
351 cat >>e${EMULATION_NAME}.c <<EOF
352 {
353 struct bfd_link_needed_list *l;
355 for (l = needed; l != NULL; l = l->next)
356 if (strncmp (l->name, "libc.so", 7) == 0)
357 break;
358 if (l == NULL)
359 {
360 bfd_close (abfd);
361 return FALSE;
362 }
363 }
365 EOF
366 ;;
367 esac
368 cat >>e${EMULATION_NAME}.c <<EOF
369 }
370 }
372 /* We've found a dynamic object matching the DT_NEEDED entry. */
374 /* We have already checked that there is no other input file of the
375 same name. We must now check again that we are not including the
376 same file twice. We need to do this because on many systems
377 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
378 reference libc.so.1. If we have already included libc.so, we
379 don't want to include libc.so.1 if they are the same file, and we
380 can only check that using stat. */
382 if (bfd_stat (abfd, &global_stat) != 0)
383 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
385 /* First strip off everything before the last '/'. */
386 soname = lbasename (abfd->filename);
388 if (trace_file_tries)
389 info_msg (_("found %s at %s\n"), soname, name);
391 global_found = FALSE;
392 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
393 if (global_found)
394 {
395 /* Return TRUE to indicate that we found the file, even though
396 we aren't going to do anything with it. */
397 return TRUE;
398 }
400 /* Specify the soname to use. */
401 bfd_elf_set_dt_needed_name (abfd, soname);
403 /* Tell the ELF linker that we don't want the output file to have a
404 DT_NEEDED entry for this file, unless it is used to resolve
405 references in a regular object. */
406 class = DYN_DT_NEEDED;
408 /* Tell the ELF linker that we don't want the output file to have a
409 DT_NEEDED entry for this file at all if the entry is from a file
410 with DYN_NO_ADD_NEEDED. */
411 if (needed->by != NULL
412 && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
413 class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
415 bfd_elf_set_dyn_lib_class (abfd, class);
417 /* Add this file into the symbol table. */
418 if (! bfd_link_add_symbols (abfd, &link_info))
419 einfo ("%F%B: could not read symbols: %E\n", abfd);
421 return TRUE;
422 }
425 /* Search for a needed file in a path. */
427 static bfd_boolean
428 gld${EMULATION_NAME}_search_needed (const char *path,
429 struct dt_needed *n, int force)
430 {
431 const char *s;
432 const char *name = n->name;
433 size_t len;
434 struct dt_needed needed;
436 if (name[0] == '/')
437 return gld${EMULATION_NAME}_try_needed (n, force);
439 if (path == NULL || *path == '\0')
440 return FALSE;
442 needed.by = n->by;
443 needed.name = n->name;
445 len = strlen (name);
446 while (1)
447 {
448 char *filename, *sset;
450 s = strchr (path, ':');
451 if (s == NULL)
452 s = path + strlen (path);
454 filename = (char *) xmalloc (s - path + len + 2);
455 if (s == path)
456 sset = filename;
457 else
458 {
459 memcpy (filename, path, s - path);
460 filename[s - path] = '/';
461 sset = filename + (s - path) + 1;
462 }
463 strcpy (sset, name);
465 needed.name = filename;
466 if (gld${EMULATION_NAME}_try_needed (&needed, force))
467 return TRUE;
469 free (filename);
471 if (*s == '\0')
472 break;
473 path = s + 1;
474 }
476 return FALSE;
477 }
479 EOF
480 if [ "x${USE_LIBPATH}" = xyes ] ; then
481 cat >>e${EMULATION_NAME}.c <<EOF
483 /* Add the sysroot to every entry in a colon-separated path. */
485 static char *
486 gld${EMULATION_NAME}_add_sysroot (const char *path)
487 {
488 int len, colons, i;
489 char *ret, *p;
491 len = strlen (path);
492 colons = 0;
493 i = 0;
494 while (path[i])
495 if (path[i++] == ':')
496 colons++;
498 if (path[i])
499 colons++;
501 len = len + (colons + 1) * strlen (ld_sysroot);
502 ret = xmalloc (len + 1);
503 strcpy (ret, ld_sysroot);
504 p = ret + strlen (ret);
505 i = 0;
506 while (path[i])
507 if (path[i] == ':')
508 {
509 *p++ = path[i++];
510 strcpy (p, ld_sysroot);
511 p = p + strlen (p);
512 }
513 else
514 *p++ = path[i++];
516 *p = 0;
517 return ret;
518 }
520 EOF
521 case ${target} in
522 *-*-linux-gnu*)
523 cat >>e${EMULATION_NAME}.c <<EOF
524 /* For a native linker, check the file /etc/ld.so.conf for directories
525 in which we may find shared libraries. /etc/ld.so.conf is really
526 only meaningful on Linux. */
528 struct gld${EMULATION_NAME}_ld_so_conf
529 {
530 char *path;
531 size_t len, alloc;
532 };
534 static void
535 gld${EMULATION_NAME}_parse_ld_so_conf
536 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
538 static void
539 gld${EMULATION_NAME}_parse_ld_so_conf_include
540 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
541 const char *pattern)
542 {
543 char *newp = NULL;
544 #ifdef HAVE_GLOB
545 glob_t gl;
546 #endif
548 if (pattern[0] != '/')
549 {
550 char *p = strrchr (filename, '/');
551 size_t patlen = strlen (pattern) + 1;
553 newp = xmalloc (p - filename + 1 + patlen);
554 memcpy (newp, filename, p - filename + 1);
555 memcpy (newp + (p - filename + 1), pattern, patlen);
556 pattern = newp;
557 }
559 #ifdef HAVE_GLOB
560 if (glob (pattern, 0, NULL, &gl) == 0)
561 {
562 size_t i;
564 for (i = 0; i < gl.gl_pathc; ++i)
565 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
566 globfree (&gl);
567 }
568 #else
569 /* If we do not have glob, treat the pattern as a literal filename. */
570 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
571 #endif
573 if (newp)
574 free (newp);
575 }
577 static void
578 gld${EMULATION_NAME}_parse_ld_so_conf
579 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
580 {
581 FILE *f = fopen (filename, FOPEN_RT);
582 char *line;
583 size_t linelen;
585 if (f == NULL)
586 return;
588 linelen = 256;
589 line = xmalloc (linelen);
590 do
591 {
592 char *p = line, *q;
594 /* Normally this would use getline(3), but we need to be portable. */
595 while ((q = fgets (p, linelen - (p - line), f)) != NULL
596 && strlen (q) == linelen - (p - line) - 1
597 && line[linelen - 2] != '\n')
598 {
599 line = xrealloc (line, 2 * linelen);
600 p = line + linelen - 1;
601 linelen += linelen;
602 }
604 if (q == NULL && p == line)
605 break;
607 p = strchr (line, '\n');
608 if (p)
609 *p = '\0';
611 /* Because the file format does not know any form of quoting we
612 can search forward for the next '#' character and if found
613 make it terminating the line. */
614 p = strchr (line, '#');
615 if (p)
616 *p = '\0';
618 /* Remove leading whitespace. NUL is no whitespace character. */
619 p = line;
620 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
621 ++p;
623 /* If the line is blank it is ignored. */
624 if (p[0] == '\0')
625 continue;
627 if (!strncmp (p, "include", 7) && (p[7] == ' ' || p[7] == '\t'))
628 {
629 char *dir, c;
630 p += 8;
631 do
632 {
633 while (*p == ' ' || *p == '\t')
634 ++p;
636 if (*p == '\0')
637 break;
639 dir = p;
641 while (*p != ' ' && *p != '\t' && *p)
642 ++p;
644 c = *p;
645 *p++ = '\0';
646 if (dir[0] != '\0')
647 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
648 dir);
649 }
650 while (c != '\0');
651 }
652 else
653 {
654 char *dir = p;
655 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
656 && *p != '\r' && *p != '\v')
657 ++p;
659 while (p != dir && p[-1] == '/')
660 --p;
661 if (info->path == NULL)
662 {
663 info->alloc = p - dir + 1 + 256;
664 info->path = xmalloc (info->alloc);
665 info->len = 0;
666 }
667 else
668 {
669 if (info->len + 1 + (p - dir) >= info->alloc)
670 {
671 info->alloc += p - dir + 256;
672 info->path = xrealloc (info->path, info->alloc);
673 }
674 info->path[info->len++] = ':';
675 }
676 memcpy (info->path + info->len, dir, p - dir);
677 info->len += p - dir;
678 info->path[info->len] = '\0';
679 }
680 }
681 while (! feof (f));
682 free (line);
683 fclose (f);
684 }
686 static bfd_boolean
687 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
688 {
689 static bfd_boolean initialized;
690 static char *ld_so_conf;
691 struct dt_needed needed;
693 if (! initialized)
694 {
695 char *tmppath;
696 struct gld${EMULATION_NAME}_ld_so_conf info;
698 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
699 info.path = NULL;
700 info.len = info.alloc = 0;
701 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
702 free (tmppath);
703 if (info.path)
704 {
705 char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
706 free (info.path);
707 ld_so_conf = d;
708 }
709 initialized = TRUE;
710 }
712 if (ld_so_conf == NULL)
713 return FALSE;
716 needed.by = NULL;
717 needed.name = name;
718 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
719 }
721 EOF
722 # Linux
723 ;;
724 esac
725 fi
726 cat >>e${EMULATION_NAME}.c <<EOF
728 /* See if an input file matches a DT_NEEDED entry by name. */
730 static void
731 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
732 {
733 if (global_found)
734 return;
736 if (s->filename != NULL)
737 {
738 const char *f;
740 if (strcmp (s->filename, global_needed->name) == 0)
741 {
742 global_found = TRUE;
743 return;
744 }
746 if (s->search_dirs_flag)
747 {
748 f = strrchr (s->filename, '/');
749 if (f != NULL
750 && strcmp (f + 1, global_needed->name) == 0)
751 {
752 global_found = TRUE;
753 return;
754 }
755 }
756 }
758 if (s->the_bfd != NULL)
759 {
760 const char *soname;
762 soname = bfd_elf_get_dt_soname (s->the_bfd);
763 if (soname != NULL
764 && strcmp (soname, global_needed->name) == 0)
765 {
766 global_found = TRUE;
767 return;
768 }
769 }
770 }
772 EOF
774 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
775 cat >>e${EMULATION_NAME}.c <<EOF
777 /* This is called after all the input files have been opened. */
779 static void
780 gld${EMULATION_NAME}_after_open (void)
781 {
782 struct bfd_link_needed_list *needed, *l;
784 /* We only need to worry about this when doing a final link. */
785 if (link_info.relocatable || !link_info.executable)
786 return;
788 /* Get the list of files which appear in DT_NEEDED entries in
789 dynamic objects included in the link (often there will be none).
790 For each such file, we want to track down the corresponding
791 library, and include the symbol table in the link. This is what
792 the runtime dynamic linker will do. Tracking the files down here
793 permits one dynamic object to include another without requiring
794 special action by the person doing the link. Note that the
795 needed list can actually grow while we are stepping through this
796 loop. */
797 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
798 for (l = needed; l != NULL; l = l->next)
799 {
800 struct bfd_link_needed_list *ll;
801 struct dt_needed n, nn;
802 int force;
804 /* If the lib that needs this one was --as-needed and wasn't
805 found to be needed, then this lib isn't needed either. */
806 if (l->by != NULL
807 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
808 continue;
810 /* If we've already seen this file, skip it. */
811 for (ll = needed; ll != l; ll = ll->next)
812 if ((ll->by == NULL
813 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
814 && strcmp (ll->name, l->name) == 0)
815 break;
816 if (ll != l)
817 continue;
819 /* See if this file was included in the link explicitly. */
820 global_needed = l;
821 global_found = FALSE;
822 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
823 if (global_found)
824 continue;
826 n.by = l->by;
827 n.name = l->name;
828 nn.by = l->by;
829 if (trace_file_tries)
830 info_msg (_("%s needed by %B\n"), l->name, l->by);
832 /* We need to find this file and include the symbol table. We
833 want to search for the file in the same way that the dynamic
834 linker will search. That means that we want to use
835 rpath_link, rpath, then the environment variable
836 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
837 entries (native only), then the linker script LIB_SEARCH_DIRS.
838 We do not search using the -L arguments.
840 We search twice. The first time, we skip objects which may
841 introduce version mismatches. The second time, we force
842 their use. See gld${EMULATION_NAME}_vercheck comment. */
843 for (force = 0; force < 2; force++)
844 {
845 size_t len;
846 search_dirs_type *search;
847 EOF
848 if [ "x${NATIVE}" = xyes ] ; then
849 cat >>e${EMULATION_NAME}.c <<EOF
850 const char *lib_path;
851 EOF
852 fi
853 if [ "x${USE_LIBPATH}" = xyes ] ; then
854 cat >>e${EMULATION_NAME}.c <<EOF
855 struct bfd_link_needed_list *rp;
856 int found;
857 EOF
858 fi
859 cat >>e${EMULATION_NAME}.c <<EOF
861 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
862 &n, force))
863 break;
864 EOF
865 if [ "x${USE_LIBPATH}" = xyes ] ; then
866 cat >>e${EMULATION_NAME}.c <<EOF
867 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
868 &n, force))
869 break;
870 EOF
871 fi
872 if [ "x${NATIVE}" = xyes ] ; then
873 cat >>e${EMULATION_NAME}.c <<EOF
874 if (command_line.rpath_link == NULL
875 && command_line.rpath == NULL)
876 {
877 lib_path = (const char *) getenv ("LD_RUN_PATH");
878 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
879 force))
880 break;
881 }
882 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
883 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
884 break;
885 EOF
886 fi
887 if [ "x${USE_LIBPATH}" = xyes ] ; then
888 cat >>e${EMULATION_NAME}.c <<EOF
889 found = 0;
890 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
891 for (; !found && rp != NULL; rp = rp->next)
892 {
893 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
894 found = (rp->by == l->by
895 && gld${EMULATION_NAME}_search_needed (tmpname,
896 &n,
897 force));
898 free (tmpname);
899 }
900 if (found)
901 break;
903 EOF
904 fi
905 cat >>e${EMULATION_NAME}.c <<EOF
906 len = strlen (l->name);
907 for (search = search_head; search != NULL; search = search->next)
908 {
909 char *filename;
911 if (search->cmdline)
912 continue;
913 filename = (char *) xmalloc (strlen (search->name) + len + 2);
914 sprintf (filename, "%s/%s", search->name, l->name);
915 nn.name = filename;
916 if (gld${EMULATION_NAME}_try_needed (&nn, force))
917 break;
918 free (filename);
919 }
920 if (search != NULL)
921 break;
922 EOF
923 if [ "x${USE_LIBPATH}" = xyes ] ; then
924 case ${target} in
925 *-*-linux-gnu*)
926 cat >>e${EMULATION_NAME}.c <<EOF
927 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
928 break;
929 EOF
930 # Linux
931 ;;
932 esac
933 fi
934 cat >>e${EMULATION_NAME}.c <<EOF
935 }
937 if (force < 2)
938 continue;
940 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
941 l->name, l->by);
942 }
943 }
945 EOF
946 fi
948 cat >>e${EMULATION_NAME}.c <<EOF
950 /* Look through an expression for an assignment statement. */
952 static void
953 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
954 {
955 bfd_boolean provide = FALSE;
957 switch (exp->type.node_class)
958 {
959 case etree_provide:
960 provide = TRUE;
961 /* Fall thru */
962 case etree_assign:
963 /* We call record_link_assignment even if the symbol is defined.
964 This is because if it is defined by a dynamic object, we
965 actually want to use the value defined by the linker script,
966 not the value from the dynamic object (because we are setting
967 symbols like etext). If the symbol is defined by a regular
968 object, then, as it happens, calling record_link_assignment
969 will do no harm. */
970 if (strcmp (exp->assign.dst, ".") != 0)
971 {
972 if (!bfd_elf_record_link_assignment (output_bfd, &link_info,
973 exp->assign.dst, provide))
974 einfo ("%P%F: failed to record assignment to %s: %E\n",
975 exp->assign.dst);
976 }
977 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
978 break;
980 case etree_binary:
981 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
982 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
983 break;
985 case etree_trinary:
986 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
987 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
988 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
989 break;
991 case etree_unary:
992 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
993 break;
995 default:
996 break;
997 }
998 }
1001 /* This is called by the before_allocation routine via
1002 lang_for_each_statement. It locates any assignment statements, and
1003 tells the ELF backend about them, in case they are assignments to
1004 symbols which are referred to by dynamic objects. */
1006 static void
1007 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1008 {
1009 if (s->header.type == lang_assignment_statement_enum)
1010 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1011 }
1013 EOF
1015 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1016 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1017 ELF_INTERPRETER_SET_DEFAULT="
1018 if (sinterp != NULL)
1019 {
1020 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1021 sinterp->size = strlen ((char *) sinterp->contents) + 1;
1022 }
1024 "
1025 else
1026 ELF_INTERPRETER_SET_DEFAULT=
1027 fi
1028 cat >>e${EMULATION_NAME}.c <<EOF
1030 /* This is called after the sections have been attached to output
1031 sections, but before any sizes or addresses have been set. */
1033 static void
1034 gld${EMULATION_NAME}_before_allocation (void)
1035 {
1036 const char *rpath;
1037 asection *sinterp;
1039 if (link_info.hash->type == bfd_link_elf_hash_table)
1040 _bfd_elf_tls_setup (output_bfd, &link_info);
1042 /* If we are going to make any variable assignments, we need to let
1043 the ELF backend know about them in case the variables are
1044 referred to by dynamic objects. */
1045 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1047 /* Let the ELF backend work out the sizes of any sections required
1048 by dynamic linking. */
1049 rpath = command_line.rpath;
1050 if (rpath == NULL)
1051 rpath = (const char *) getenv ("LD_RUN_PATH");
1052 if (! (bfd_elf_size_dynamic_sections
1053 (output_bfd, command_line.soname, rpath,
1054 command_line.filter_shlib,
1055 (const char * const *) command_line.auxiliary_filters,
1056 &link_info, &sinterp, lang_elf_version_info)))
1057 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1058 ${ELF_INTERPRETER_SET_DEFAULT}
1059 /* Let the user override the dynamic linker we are using. */
1060 if (command_line.interpreter != NULL
1061 && sinterp != NULL)
1062 {
1063 sinterp->contents = (bfd_byte *) command_line.interpreter;
1064 sinterp->size = strlen (command_line.interpreter) + 1;
1065 }
1067 /* Look for any sections named .gnu.warning. As a GNU extensions,
1068 we treat such sections as containing warning messages. We print
1069 out the warning message, and then zero out the section size so
1070 that it does not get copied into the output file. */
1072 {
1073 LANG_FOR_EACH_INPUT_STATEMENT (is)
1074 {
1075 asection *s;
1076 bfd_size_type sz;
1077 bfd_size_type prefix_len;
1078 char *msg;
1079 bfd_boolean ret;
1080 const char * gnu_warning_prefix = _("warning: ");
1082 if (is->just_syms_flag)
1083 continue;
1085 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1086 if (s == NULL)
1087 continue;
1089 sz = s->size;
1090 prefix_len = strlen (gnu_warning_prefix);
1091 msg = xmalloc ((size_t) (prefix_len + sz + 1));
1092 strcpy (msg, gnu_warning_prefix);
1093 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
1094 (file_ptr) 0, sz))
1095 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1096 is->the_bfd);
1097 msg[prefix_len + sz] = '\0';
1098 ret = link_info.callbacks->warning (&link_info, msg,
1099 (const char *) NULL,
1100 is->the_bfd, (asection *) NULL,
1101 (bfd_vma) 0);
1102 ASSERT (ret);
1103 free (msg);
1105 /* Clobber the section size, so that we don't waste copying the
1106 warning into the output file. */
1107 s->size = 0;
1109 /* Also set SEC_EXCLUDE, so that symbols defined in the warning
1110 section don't get copied to the output. */
1111 s->flags |= SEC_EXCLUDE;
1112 }
1113 }
1114 }
1116 EOF
1117 fi
1119 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1120 cat >>e${EMULATION_NAME}.c <<EOF
1122 /* Try to open a dynamic archive. This is where we know that ELF
1123 dynamic libraries have an extension of .so (or .sl on oddball systems
1124 like hpux). */
1126 static bfd_boolean
1127 gld${EMULATION_NAME}_open_dynamic_archive
1128 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1129 {
1130 const char *filename;
1131 char *string;
1133 if (! entry->is_archive)
1134 return FALSE;
1136 filename = entry->filename;
1138 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1139 is defined, but it does not seem worth the headache to optimize
1140 away those two bytes of space. */
1141 string = (char *) xmalloc (strlen (search->name)
1142 + strlen (filename)
1143 + strlen (arch)
1144 #ifdef EXTRA_SHLIB_EXTENSION
1145 + strlen (EXTRA_SHLIB_EXTENSION)
1146 #endif
1147 + sizeof "/lib.so");
1149 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1151 #ifdef EXTRA_SHLIB_EXTENSION
1152 /* Try the .so extension first. If that fails build a new filename
1153 using EXTRA_SHLIB_EXTENSION. */
1154 if (! ldfile_try_open_bfd (string, entry))
1155 sprintf (string, "%s/lib%s%s%s", search->name,
1156 filename, arch, EXTRA_SHLIB_EXTENSION);
1157 #endif
1159 if (! ldfile_try_open_bfd (string, entry))
1160 {
1161 free (string);
1162 return FALSE;
1163 }
1165 entry->filename = string;
1167 /* We have found a dynamic object to include in the link. The ELF
1168 backend linker will create a DT_NEEDED entry in the .dynamic
1169 section naming this file. If this file includes a DT_SONAME
1170 entry, it will be used. Otherwise, the ELF linker will just use
1171 the name of the file. For an archive found by searching, like
1172 this one, the DT_NEEDED entry should consist of just the name of
1173 the file, without the path information used to find it. Note
1174 that we only need to do this if we have a dynamic object; an
1175 archive will never be referenced by a DT_NEEDED entry.
1177 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1178 very pretty. I haven't been able to think of anything that is
1179 pretty, though. */
1180 if (bfd_check_format (entry->the_bfd, bfd_object)
1181 && (entry->the_bfd->flags & DYNAMIC) != 0)
1182 {
1183 ASSERT (entry->is_archive && entry->search_dirs_flag);
1185 /* Rather than duplicating the logic above. Just use the
1186 filename we recorded earlier. */
1188 filename = lbasename (entry->filename);
1189 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1190 }
1192 return TRUE;
1193 }
1195 EOF
1196 fi
1198 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1199 cat >>e${EMULATION_NAME}.c <<EOF
1201 /* A variant of lang_output_section_find used by place_orphan. */
1203 static lang_output_section_statement_type *
1204 output_rel_find (asection *sec, int isdyn)
1205 {
1206 lang_output_section_statement_type *lookup;
1207 lang_output_section_statement_type *last = NULL;
1208 lang_output_section_statement_type *last_alloc = NULL;
1209 lang_output_section_statement_type *last_rel = NULL;
1210 lang_output_section_statement_type *last_rel_alloc = NULL;
1211 int rela = sec->name[4] == 'a';
1213 for (lookup = &lang_output_section_statement.head->output_section_statement;
1214 lookup != NULL;
1215 lookup = lookup->next)
1216 {
1217 if (lookup->constraint != -1
1218 && strncmp (".rel", lookup->name, 4) == 0)
1219 {
1220 int lookrela = lookup->name[4] == 'a';
1222 /* .rel.dyn must come before all other reloc sections, to suit
1223 GNU ld.so. */
1224 if (isdyn)
1225 break;
1227 /* Don't place after .rel.plt as doing so results in wrong
1228 dynamic tags. */
1229 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1230 break;
1232 if (rela == lookrela || last_rel == NULL)
1233 last_rel = lookup;
1234 if ((rela == lookrela || last_rel_alloc == NULL)
1235 && lookup->bfd_section != NULL
1236 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1237 last_rel_alloc = lookup;
1238 }
1240 last = lookup;
1241 if (lookup->bfd_section != NULL
1242 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1243 last_alloc = lookup;
1244 }
1246 if (last_rel_alloc)
1247 return last_rel_alloc;
1249 if (last_rel)
1250 return last_rel;
1252 if (last_alloc)
1253 return last_alloc;
1255 return last;
1256 }
1258 /* Place an orphan section. We use this to put random SHF_ALLOC
1259 sections in the right segment. */
1261 static bfd_boolean
1262 gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1263 {
1264 static struct orphan_save hold[] =
1265 {
1266 { ".text",
1267 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1268 0, 0, 0, 0 },
1269 { ".rodata",
1270 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1271 0, 0, 0, 0 },
1272 { ".data",
1273 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1274 0, 0, 0, 0 },
1275 { ".bss",
1276 SEC_ALLOC,
1277 0, 0, 0, 0 },
1278 { 0,
1279 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1280 0, 0, 0, 0 },
1281 { ".interp",
1282 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1283 0, 0, 0, 0 },
1284 { ".sdata",
1285 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1286 0, 0, 0, 0 }
1287 };
1288 enum orphan_save_index
1289 {
1290 orphan_text = 0,
1291 orphan_rodata,
1292 orphan_data,
1293 orphan_bss,
1294 orphan_rel,
1295 orphan_interp,
1296 orphan_sdata
1297 };
1298 static int orphan_init_done = 0;
1299 struct orphan_save *place;
1300 const char *secname;
1301 lang_output_section_statement_type *after;
1302 lang_output_section_statement_type *os;
1303 int isdyn = 0;
1305 secname = bfd_get_section_name (s->owner, s);
1307 if (! link_info.relocatable
1308 && link_info.combreloc
1309 && (s->flags & SEC_ALLOC)
1310 && strncmp (secname, ".rel", 4) == 0)
1311 {
1312 if (secname[4] == 'a')
1313 secname = ".rela.dyn";
1314 else
1315 secname = ".rel.dyn";
1316 isdyn = 1;
1317 }
1319 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1320 {
1321 /* Look through the script to see where to place this section. */
1322 os = lang_output_section_find (secname);
1324 if (os != NULL
1325 && (os->bfd_section == NULL
1326 || os->bfd_section->flags == 0
1327 || ((s->flags ^ os->bfd_section->flags)
1328 & (SEC_LOAD | SEC_ALLOC)) == 0))
1329 {
1330 /* We already have an output section statement with this
1331 name, and its bfd section, if any, has compatible flags.
1332 If the section already exists but does not have any flags
1333 set, then it has been created by the linker, probably as a
1334 result of a --section-start command line switch. */
1335 lang_add_section (&os->children, s, os, file);
1336 return TRUE;
1337 }
1338 }
1340 if (!orphan_init_done)
1341 {
1342 struct orphan_save *ho;
1343 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1344 if (ho->name != NULL)
1345 {
1346 ho->os = lang_output_section_find (ho->name);
1347 if (ho->os != NULL && ho->os->flags == 0)
1348 ho->os->flags = ho->flags;
1349 }
1350 orphan_init_done = 1;
1351 }
1353 /* If this is a final link, then always put .gnu.warning.SYMBOL
1354 sections into the .text section to get them out of the way. */
1355 if (link_info.executable
1356 && ! link_info.relocatable
1357 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1358 && hold[orphan_text].os != NULL)
1359 {
1360 lang_add_section (&hold[orphan_text].os->children, s,
1361 hold[orphan_text].os, file);
1362 return TRUE;
1363 }
1365 /* Decide which segment the section should go in based on the
1366 section name and section flags. We put loadable .note sections
1367 right after the .interp section, so that the PT_NOTE segment is
1368 stored right after the program headers where the OS can read it
1369 in the first page. */
1371 place = NULL;
1372 if ((s->flags & SEC_ALLOC) == 0)
1373 ;
1374 else if ((s->flags & SEC_LOAD) != 0
1375 && strncmp (secname, ".note", 5) == 0)
1376 place = &hold[orphan_interp];
1377 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1378 place = &hold[orphan_bss];
1379 else if ((s->flags & SEC_SMALL_DATA) != 0)
1380 place = &hold[orphan_sdata];
1381 else if ((s->flags & SEC_READONLY) == 0)
1382 place = &hold[orphan_data];
1383 else if (strncmp (secname, ".rel", 4) == 0
1384 && (s->flags & SEC_LOAD) != 0)
1385 place = &hold[orphan_rel];
1386 else if ((s->flags & SEC_CODE) == 0)
1387 place = &hold[orphan_rodata];
1388 else
1389 place = &hold[orphan_text];
1391 after = NULL;
1392 if (place != NULL)
1393 {
1394 if (place->os == NULL)
1395 {
1396 if (place->name != NULL)
1397 place->os = lang_output_section_find (place->name);
1398 else
1399 place->os = output_rel_find (s, isdyn);
1400 }
1401 after = place->os;
1402 if (after == NULL)
1403 after = lang_output_section_find_by_flags (s, &place->os);
1404 if (after == NULL)
1405 /* *ABS* is always the first output section statement. */
1406 after = &lang_output_section_statement.head->output_section_statement;
1407 }
1409 /* Choose a unique name for the section. This will be needed if the
1410 same section name appears in the input file with different
1411 loadable or allocatable characteristics. */
1412 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1413 {
1414 static int count = 1;
1415 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1416 if (secname == NULL)
1417 einfo ("%F%P: place_orphan failed: %E\n");
1418 }
1420 lang_insert_orphan (file, s, secname, after, place, NULL, NULL);
1422 return TRUE;
1423 }
1424 EOF
1425 fi
1427 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1428 cat >>e${EMULATION_NAME}.c <<EOF
1430 static void
1431 gld${EMULATION_NAME}_provide_bound_symbols (const char *sec,
1432 const char *start,
1433 const char *end)
1434 {
1435 asection *s;
1436 bfd_vma start_val, end_val;
1438 s = bfd_get_section_by_name (output_bfd, sec);
1439 if (s != NULL)
1440 {
1441 start_val = s->vma;
1442 end_val = start_val + s->size;
1443 }
1444 else
1445 {
1446 start_val = 0;
1447 end_val = 0;
1448 }
1449 _bfd_elf_provide_symbol (&link_info, start, start_val);
1450 _bfd_elf_provide_symbol (&link_info, end, end_val);
1451 }
1453 static void
1454 gld${EMULATION_NAME}_finish (void)
1455 {
1456 if (bfd_elf_discard_info (output_bfd, &link_info))
1457 {
1458 lang_reset_memory_regions ();
1460 /* Resize the sections. */
1461 lang_size_sections (stat_ptr->head, abs_output_section,
1462 &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
1464 /* Redo special stuff. */
1465 ldemul_after_allocation ();
1467 /* Do the assignments again. */
1468 lang_do_assignments (stat_ptr->head, abs_output_section,
1469 (fill_type *) 0, (bfd_vma) 0);
1470 }
1472 if (!link_info.relocatable)
1473 {
1474 lang_output_section_statement_type *os;
1476 for (os = &lang_output_section_statement.head->output_section_statement;
1477 os != NULL;
1478 os = os->next)
1479 {
1480 asection *s;
1482 if (os == abs_output_section || os->constraint == -1)
1483 continue;
1484 s = os->bfd_section;
1485 if (s != NULL && s->size == 0 && (s->flags & SEC_KEEP) == 0)
1486 {
1487 asection **p;
1489 for (p = &output_bfd->sections; *p; p = &(*p)->next)
1490 if (*p == s)
1491 {
1492 bfd_section_list_remove (output_bfd, p);
1493 output_bfd->section_count--;
1494 break;
1495 }
1496 }
1497 }
1499 /* If not building shared library, provide
1501 __preinit_array_start
1502 __preinit_array_end
1503 __init_array_start
1504 __init_array_end
1505 __fini_array_start
1506 __fini_array_end
1508 They are set here rather than via PROVIDE in the linker
1509 script, because using PROVIDE inside an output section
1510 statement results in unnecessary output sections. Using
1511 PROVIDE outside an output section statement runs the risk of
1512 section alignment affecting where the section starts. */
1514 if (!link_info.shared)
1515 {
1516 gld${EMULATION_NAME}_provide_bound_symbols
1517 (".preinit_array", "__preinit_array_start",
1518 "__preinit_array_end");
1519 gld${EMULATION_NAME}_provide_bound_symbols
1520 (".init_array", "__init_array_start",
1521 "__init_array_end");
1522 gld${EMULATION_NAME}_provide_bound_symbols
1523 (".fini_array", "__fini_array_start",
1524 "__fini_array_end");
1525 }
1526 }
1527 }
1528 EOF
1529 fi
1531 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1532 cat >>e${EMULATION_NAME}.c <<EOF
1534 static char *
1535 gld${EMULATION_NAME}_get_script (int *isfile)
1536 EOF
1538 if test -n "$COMPILE_IN"
1539 then
1540 # Scripts compiled in.
1542 # sed commands to quote an ld script as a C string.
1543 sc="-f stringify.sed"
1545 cat >>e${EMULATION_NAME}.c <<EOF
1546 {
1547 *isfile = 0;
1549 if (link_info.relocatable && config.build_constructors)
1550 return
1551 EOF
1552 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1553 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1554 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1555 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1556 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1557 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1558 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1559 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1560 fi
1561 if test -n "$GENERATE_PIE_SCRIPT" ; then
1562 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1563 echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1564 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1565 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1566 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
1567 echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1568 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
1569 fi
1570 echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1571 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
1572 fi
1573 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1574 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1575 echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1576 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1577 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1578 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
1579 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1580 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1581 fi
1582 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1583 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1584 fi
1585 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1586 echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1587 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1588 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
1589 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1590 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1591 fi
1592 echo ' ; else return' >> e${EMULATION_NAME}.c
1593 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1594 echo '; }' >> e${EMULATION_NAME}.c
1596 else
1597 # Scripts read from the filesystem.
1599 cat >>e${EMULATION_NAME}.c <<EOF
1600 {
1601 *isfile = 1;
1603 if (link_info.relocatable && config.build_constructors)
1604 return "ldscripts/${EMULATION_NAME}.xu";
1605 else if (link_info.relocatable)
1606 return "ldscripts/${EMULATION_NAME}.xr";
1607 else if (!config.text_read_only)
1608 return "ldscripts/${EMULATION_NAME}.xbn";
1609 EOF
1610 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1611 else
1612 cat >>e${EMULATION_NAME}.c <<EOF
1613 else if (!config.magic_demand_paged)
1614 return "ldscripts/${EMULATION_NAME}.xn";
1615 EOF
1616 fi
1617 if test -n "$GENERATE_PIE_SCRIPT" ; then
1618 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1619 cat >>e${EMULATION_NAME}.c <<EOF
1620 else if (link_info.pie && link_info.combreloc
1621 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1622 return "ldscripts/${EMULATION_NAME}.xdw";
1623 else if (link_info.pie && link_info.combreloc)
1624 return "ldscripts/${EMULATION_NAME}.xdc";
1625 EOF
1626 fi
1627 cat >>e${EMULATION_NAME}.c <<EOF
1628 else if (link_info.pie)
1629 return "ldscripts/${EMULATION_NAME}.xd";
1630 EOF
1631 fi
1632 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1633 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1634 cat >>e${EMULATION_NAME}.c <<EOF
1635 else if (link_info.shared && link_info.combreloc
1636 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1637 return "ldscripts/${EMULATION_NAME}.xsw";
1638 else if (link_info.shared && link_info.combreloc)
1639 return "ldscripts/${EMULATION_NAME}.xsc";
1640 EOF
1641 fi
1642 cat >>e${EMULATION_NAME}.c <<EOF
1643 else if (link_info.shared)
1644 return "ldscripts/${EMULATION_NAME}.xs";
1645 EOF
1646 fi
1647 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1648 cat >>e${EMULATION_NAME}.c <<EOF
1649 else if (link_info.combreloc && link_info.relro
1650 && (link_info.flags & DT_BIND_NOW))
1651 return "ldscripts/${EMULATION_NAME}.xw";
1652 else if (link_info.combreloc)
1653 return "ldscripts/${EMULATION_NAME}.xc";
1654 EOF
1655 fi
1656 cat >>e${EMULATION_NAME}.c <<EOF
1657 else
1658 return "ldscripts/${EMULATION_NAME}.x";
1659 }
1661 EOF
1662 fi
1663 fi
1665 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1667 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1668 cat >>e${EMULATION_NAME}.c <<EOF
1669 $PARSE_AND_LIST_PROLOGUE
1670 EOF
1671 fi
1673 cat >>e${EMULATION_NAME}.c <<EOF
1675 #define OPTION_DISABLE_NEW_DTAGS (400)
1676 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1677 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1678 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1679 #define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1)
1681 static void
1682 gld${EMULATION_NAME}_add_options
1683 (int ns, char **shortopts, int nl, struct option **longopts,
1684 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1685 {
1686 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1687 static const struct option xtra_long[] = {
1688 EOF
1690 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1691 cat >>e${EMULATION_NAME}.c <<EOF
1692 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1693 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1694 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1695 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
1696 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1697 EOF
1698 fi
1700 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1701 cat >>e${EMULATION_NAME}.c <<EOF
1702 $PARSE_AND_LIST_LONGOPTS
1703 EOF
1704 fi
1706 cat >>e${EMULATION_NAME}.c <<EOF
1707 {NULL, no_argument, NULL, 0}
1708 };
1710 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1711 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1712 *longopts = (struct option *)
1713 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1714 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1715 }
1717 static bfd_boolean
1718 gld${EMULATION_NAME}_handle_option (int optc)
1719 {
1720 switch (optc)
1721 {
1722 default:
1723 return FALSE;
1725 EOF
1727 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1728 cat >>e${EMULATION_NAME}.c <<EOF
1729 case OPTION_DISABLE_NEW_DTAGS:
1730 link_info.new_dtags = FALSE;
1731 break;
1733 case OPTION_ENABLE_NEW_DTAGS:
1734 link_info.new_dtags = TRUE;
1735 break;
1737 case OPTION_EH_FRAME_HDR:
1738 link_info.eh_frame_hdr = TRUE;
1739 break;
1741 case OPTION_GROUP:
1742 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1743 /* Groups must be self-contained. */
1744 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1745 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1746 break;
1748 case OPTION_EXCLUDE_LIBS:
1749 add_excluded_libs (optarg);
1750 break;
1752 case 'z':
1753 if (strcmp (optarg, "initfirst") == 0)
1754 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1755 else if (strcmp (optarg, "interpose") == 0)
1756 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1757 else if (strcmp (optarg, "loadfltr") == 0)
1758 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1759 else if (strcmp (optarg, "nodefaultlib") == 0)
1760 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1761 else if (strcmp (optarg, "nodelete") == 0)
1762 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1763 else if (strcmp (optarg, "nodlopen") == 0)
1764 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1765 else if (strcmp (optarg, "nodump") == 0)
1766 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1767 else if (strcmp (optarg, "now") == 0)
1768 {
1769 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1770 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1771 }
1772 else if (strcmp (optarg, "origin") == 0)
1773 {
1774 link_info.flags |= (bfd_vma) DF_ORIGIN;
1775 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1776 }
1777 else if (strcmp (optarg, "defs") == 0)
1778 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1779 else if (strcmp (optarg, "muldefs") == 0)
1780 link_info.allow_multiple_definition = TRUE;
1781 else if (strcmp (optarg, "combreloc") == 0)
1782 link_info.combreloc = TRUE;
1783 else if (strcmp (optarg, "nocombreloc") == 0)
1784 link_info.combreloc = FALSE;
1785 else if (strcmp (optarg, "nocopyreloc") == 0)
1786 link_info.nocopyreloc = TRUE;
1787 else if (strcmp (optarg, "execstack") == 0)
1788 {
1789 link_info.execstack = TRUE;
1790 link_info.noexecstack = FALSE;
1791 }
1792 else if (strcmp (optarg, "noexecstack") == 0)
1793 {
1794 link_info.noexecstack = TRUE;
1795 link_info.execstack = FALSE;
1796 }
1797 else if (strcmp (optarg, "relro") == 0)
1798 link_info.relro = TRUE;
1799 else if (strcmp (optarg, "norelro") == 0)
1800 link_info.relro = FALSE;
1801 /* What about the other Solaris -z options? FIXME. */
1802 break;
1803 EOF
1804 fi
1806 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1807 cat >>e${EMULATION_NAME}.c <<EOF
1808 $PARSE_AND_LIST_ARGS_CASES
1809 EOF
1810 fi
1812 cat >>e${EMULATION_NAME}.c <<EOF
1813 }
1815 return TRUE;
1816 }
1818 EOF
1820 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1821 cat >>e${EMULATION_NAME}.c <<EOF
1823 static void
1824 gld${EMULATION_NAME}_list_options (FILE * file)
1825 {
1826 EOF
1828 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1829 cat >>e${EMULATION_NAME}.c <<EOF
1830 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1831 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1832 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1833 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1834 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1835 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n"));
1836 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n"));
1837 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1838 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1839 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1840 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1841 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1842 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1843 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1844 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1845 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1846 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1847 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n"));
1848 fprintf (file, _(" -z norelro\t\tDon't create RELRO program header\n"));
1849 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1850 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1851 fprintf (file, _(" -z relro\t\tCreate RELRO program header\n"));
1852 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1853 EOF
1854 fi
1856 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1857 cat >>e${EMULATION_NAME}.c <<EOF
1858 $PARSE_AND_LIST_OPTIONS
1859 EOF
1860 fi
1862 cat >>e${EMULATION_NAME}.c <<EOF
1863 }
1864 EOF
1866 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1867 cat >>e${EMULATION_NAME}.c <<EOF
1868 $PARSE_AND_LIST_EPILOGUE
1869 EOF
1870 fi
1871 fi
1872 else
1873 cat >>e${EMULATION_NAME}.c <<EOF
1874 #define gld${EMULATION_NAME}_add_options NULL
1875 #define gld${EMULATION_NAME}_handle_option NULL
1876 EOF
1877 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1878 cat >>e${EMULATION_NAME}.c <<EOF
1879 #define gld${EMULATION_NAME}_list_options NULL
1880 EOF
1881 fi
1882 fi
1884 cat >>e${EMULATION_NAME}.c <<EOF
1886 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1887 {
1888 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1889 ${LDEMUL_SYSLIB-syslib_default},
1890 ${LDEMUL_HLL-hll_default},
1891 ${LDEMUL_AFTER_PARSE-after_parse_default},
1892 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1893 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1894 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1895 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1896 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1897 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1898 "${EMULATION_NAME}",
1899 "${OUTPUT_FORMAT}",
1900 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1901 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1902 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1903 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1904 ${LDEMUL_SET_SYMBOLS-NULL},
1905 ${LDEMUL_PARSE_ARGS-NULL},
1906 gld${EMULATION_NAME}_add_options,
1907 gld${EMULATION_NAME}_handle_option,
1908 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1909 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1910 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1911 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1912 ${LDEMUL_NEW_VERS_PATTERN-NULL}
1913 };
1914 EOF