| blob | 048917f3b5a5140eb861f24df250426267e130a1 |
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., 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 *-*-linux-* | *-*-k*bsd*-*)
533 cat >>e${EMULATION_NAME}.c <<EOF
534 /* For a native linker, check the file /etc/ld.so.conf for directories
535 in which we may find shared libraries. /etc/ld.so.conf is really
536 only meaningful on Linux. */
538 struct gld${EMULATION_NAME}_ld_so_conf
539 {
540 char *path;
541 size_t len, alloc;
542 };
544 static void
545 gld${EMULATION_NAME}_parse_ld_so_conf
546 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
548 static void
549 gld${EMULATION_NAME}_parse_ld_so_conf_include
550 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
551 const char *pattern)
552 {
553 char *newp = NULL;
554 #ifdef HAVE_GLOB
555 glob_t gl;
556 #endif
558 if (pattern[0] != '/')
559 {
560 char *p = strrchr (filename, '/');
561 size_t patlen = strlen (pattern) + 1;
563 newp = xmalloc (p - filename + 1 + patlen);
564 memcpy (newp, filename, p - filename + 1);
565 memcpy (newp + (p - filename + 1), pattern, patlen);
566 pattern = newp;
567 }
569 #ifdef HAVE_GLOB
570 if (glob (pattern, 0, NULL, &gl) == 0)
571 {
572 size_t i;
574 for (i = 0; i < gl.gl_pathc; ++i)
575 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
576 globfree (&gl);
577 }
578 #else
579 /* If we do not have glob, treat the pattern as a literal filename. */
580 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
581 #endif
583 if (newp)
584 free (newp);
585 }
587 static void
588 gld${EMULATION_NAME}_parse_ld_so_conf
589 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
590 {
591 FILE *f = fopen (filename, FOPEN_RT);
592 char *line;
593 size_t linelen;
595 if (f == NULL)
596 return;
598 linelen = 256;
599 line = xmalloc (linelen);
600 do
601 {
602 char *p = line, *q;
604 /* Normally this would use getline(3), but we need to be portable. */
605 while ((q = fgets (p, linelen - (p - line), f)) != NULL
606 && strlen (q) == linelen - (p - line) - 1
607 && line[linelen - 2] != '\n')
608 {
609 line = xrealloc (line, 2 * linelen);
610 p = line + linelen - 1;
611 linelen += linelen;
612 }
614 if (q == NULL && p == line)
615 break;
617 p = strchr (line, '\n');
618 if (p)
619 *p = '\0';
621 /* Because the file format does not know any form of quoting we
622 can search forward for the next '#' character and if found
623 make it terminating the line. */
624 p = strchr (line, '#');
625 if (p)
626 *p = '\0';
628 /* Remove leading whitespace. NUL is no whitespace character. */
629 p = line;
630 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
631 ++p;
633 /* If the line is blank it is ignored. */
634 if (p[0] == '\0')
635 continue;
637 if (!strncmp (p, "include", 7) && (p[7] == ' ' || p[7] == '\t'))
638 {
639 char *dir, c;
640 p += 8;
641 do
642 {
643 while (*p == ' ' || *p == '\t')
644 ++p;
646 if (*p == '\0')
647 break;
649 dir = p;
651 while (*p != ' ' && *p != '\t' && *p)
652 ++p;
654 c = *p;
655 *p++ = '\0';
656 if (dir[0] != '\0')
657 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
658 dir);
659 }
660 while (c != '\0');
661 }
662 else
663 {
664 char *dir = p;
665 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
666 && *p != '\r' && *p != '\v')
667 ++p;
669 while (p != dir && p[-1] == '/')
670 --p;
671 if (info->path == NULL)
672 {
673 info->alloc = p - dir + 1 + 256;
674 info->path = xmalloc (info->alloc);
675 info->len = 0;
676 }
677 else
678 {
679 if (info->len + 1 + (p - dir) >= info->alloc)
680 {
681 info->alloc += p - dir + 256;
682 info->path = xrealloc (info->path, info->alloc);
683 }
684 info->path[info->len++] = ':';
685 }
686 memcpy (info->path + info->len, dir, p - dir);
687 info->len += p - dir;
688 info->path[info->len] = '\0';
689 }
690 }
691 while (! feof (f));
692 free (line);
693 fclose (f);
694 }
696 static bfd_boolean
697 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
698 {
699 static bfd_boolean initialized;
700 static char *ld_so_conf;
701 struct dt_needed needed;
703 if (! initialized)
704 {
705 char *tmppath;
706 struct gld${EMULATION_NAME}_ld_so_conf info;
708 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
709 info.path = NULL;
710 info.len = info.alloc = 0;
711 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
712 free (tmppath);
713 if (info.path)
714 {
715 char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
716 free (info.path);
717 ld_so_conf = d;
718 }
719 initialized = TRUE;
720 }
722 if (ld_so_conf == NULL)
723 return FALSE;
726 needed.by = NULL;
727 needed.name = name;
728 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
729 }
731 EOF
732 # Linux
733 ;;
734 esac
735 fi
736 cat >>e${EMULATION_NAME}.c <<EOF
738 /* See if an input file matches a DT_NEEDED entry by name. */
740 static void
741 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
742 {
743 if (global_found)
744 return;
746 /* If this input file was an as-needed entry, and wasn't found to be
747 needed at the stage it was linked, then don't say we have loaded it. */
748 if (s->as_needed
749 && (s->the_bfd == NULL
750 || (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0))
751 return;
753 if (s->filename != NULL)
754 {
755 const char *f;
757 if (strcmp (s->filename, global_needed->name) == 0)
758 {
759 global_found = TRUE;
760 return;
761 }
763 if (s->search_dirs_flag)
764 {
765 f = strrchr (s->filename, '/');
766 if (f != NULL
767 && strcmp (f + 1, global_needed->name) == 0)
768 {
769 global_found = TRUE;
770 return;
771 }
772 }
773 }
775 if (s->the_bfd != NULL)
776 {
777 const char *soname;
779 soname = bfd_elf_get_dt_soname (s->the_bfd);
780 if (soname != NULL
781 && strcmp (soname, global_needed->name) == 0)
782 {
783 global_found = TRUE;
784 return;
785 }
786 }
787 }
789 EOF
791 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
792 cat >>e${EMULATION_NAME}.c <<EOF
794 /* This is called after all the input files have been opened. */
796 static void
797 gld${EMULATION_NAME}_after_open (void)
798 {
799 struct bfd_link_needed_list *needed, *l;
801 /* We only need to worry about this when doing a final link. */
802 if (link_info.relocatable || !link_info.executable)
803 return;
805 /* Get the list of files which appear in DT_NEEDED entries in
806 dynamic objects included in the link (often there will be none).
807 For each such file, we want to track down the corresponding
808 library, and include the symbol table in the link. This is what
809 the runtime dynamic linker will do. Tracking the files down here
810 permits one dynamic object to include another without requiring
811 special action by the person doing the link. Note that the
812 needed list can actually grow while we are stepping through this
813 loop. */
814 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
815 for (l = needed; l != NULL; l = l->next)
816 {
817 struct bfd_link_needed_list *ll;
818 struct dt_needed n, nn;
819 int force;
821 /* If the lib that needs this one was --as-needed and wasn't
822 found to be needed, then this lib isn't needed either. */
823 if (l->by != NULL
824 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
825 continue;
827 /* If we've already seen this file, skip it. */
828 for (ll = needed; ll != l; ll = ll->next)
829 if ((ll->by == NULL
830 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
831 && strcmp (ll->name, l->name) == 0)
832 break;
833 if (ll != l)
834 continue;
836 /* See if this file was included in the link explicitly. */
837 global_needed = l;
838 global_found = FALSE;
839 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
840 if (global_found)
841 continue;
843 n.by = l->by;
844 n.name = l->name;
845 nn.by = l->by;
846 if (trace_file_tries)
847 info_msg (_("%s needed by %B\n"), l->name, l->by);
849 /* We need to find this file and include the symbol table. We
850 want to search for the file in the same way that the dynamic
851 linker will search. That means that we want to use
852 rpath_link, rpath, then the environment variable
853 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
854 entries (native only), then the linker script LIB_SEARCH_DIRS.
855 We do not search using the -L arguments.
857 We search twice. The first time, we skip objects which may
858 introduce version mismatches. The second time, we force
859 their use. See gld${EMULATION_NAME}_vercheck comment. */
860 for (force = 0; force < 2; force++)
861 {
862 size_t len;
863 search_dirs_type *search;
864 EOF
865 if [ "x${NATIVE}" = xyes ] ; then
866 cat >>e${EMULATION_NAME}.c <<EOF
867 const char *lib_path;
868 EOF
869 fi
870 if [ "x${USE_LIBPATH}" = xyes ] ; then
871 cat >>e${EMULATION_NAME}.c <<EOF
872 struct bfd_link_needed_list *rp;
873 int found;
874 EOF
875 fi
876 cat >>e${EMULATION_NAME}.c <<EOF
878 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
879 &n, force))
880 break;
881 EOF
882 if [ "x${USE_LIBPATH}" = xyes ] ; then
883 cat >>e${EMULATION_NAME}.c <<EOF
884 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
885 &n, force))
886 break;
887 EOF
888 fi
889 if [ "x${NATIVE}" = xyes ] ; then
890 cat >>e${EMULATION_NAME}.c <<EOF
891 if (command_line.rpath_link == NULL
892 && command_line.rpath == NULL)
893 {
894 lib_path = (const char *) getenv ("LD_RUN_PATH");
895 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
896 force))
897 break;
898 }
899 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
900 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
901 break;
902 EOF
903 fi
904 if [ "x${USE_LIBPATH}" = xyes ] ; then
905 cat >>e${EMULATION_NAME}.c <<EOF
906 found = 0;
907 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
908 for (; !found && rp != NULL; rp = rp->next)
909 {
910 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
911 found = (rp->by == l->by
912 && gld${EMULATION_NAME}_search_needed (tmpname,
913 &n,
914 force));
915 free (tmpname);
916 }
917 if (found)
918 break;
920 EOF
921 fi
922 if [ "x${USE_LIBPATH}" = xyes ] ; then
923 case ${target} in
924 *-*-linux-* | *-*-k*bsd*-*)
925 # Linux
926 cat >>e${EMULATION_NAME}.c <<EOF
927 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
928 break;
930 EOF
931 ;;
932 esac
933 fi
934 cat >>e${EMULATION_NAME}.c <<EOF
935 len = strlen (l->name);
936 for (search = search_head; search != NULL; search = search->next)
937 {
938 char *filename;
940 if (search->cmdline)
941 continue;
942 filename = (char *) xmalloc (strlen (search->name) + len + 2);
943 sprintf (filename, "%s/%s", search->name, l->name);
944 nn.name = filename;
945 if (gld${EMULATION_NAME}_try_needed (&nn, force))
946 break;
947 free (filename);
948 }
949 if (search != NULL)
950 break;
951 EOF
952 cat >>e${EMULATION_NAME}.c <<EOF
953 }
955 if (force < 2)
956 continue;
958 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
959 l->name, l->by);
960 }
961 }
963 EOF
964 fi
966 cat >>e${EMULATION_NAME}.c <<EOF
968 /* Look through an expression for an assignment statement. */
970 static void
971 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
972 {
973 bfd_boolean provide = FALSE;
975 switch (exp->type.node_class)
976 {
977 case etree_provide:
978 provide = TRUE;
979 /* Fall thru */
980 case etree_assign:
981 /* We call record_link_assignment even if the symbol is defined.
982 This is because if it is defined by a dynamic object, we
983 actually want to use the value defined by the linker script,
984 not the value from the dynamic object (because we are setting
985 symbols like etext). If the symbol is defined by a regular
986 object, then, as it happens, calling record_link_assignment
987 will do no harm. */
988 if (strcmp (exp->assign.dst, ".") != 0)
989 {
990 if (!bfd_elf_record_link_assignment (output_bfd, &link_info,
991 exp->assign.dst, provide,
992 exp->assign.hidden))
993 einfo ("%P%F: failed to record assignment to %s: %E\n",
994 exp->assign.dst);
995 }
996 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
997 break;
999 case etree_binary:
1000 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1001 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1002 break;
1004 case etree_trinary:
1005 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1006 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1007 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1008 break;
1010 case etree_unary:
1011 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1012 break;
1014 default:
1015 break;
1016 }
1017 }
1020 /* This is called by the before_allocation routine via
1021 lang_for_each_statement. It locates any assignment statements, and
1022 tells the ELF backend about them, in case they are assignments to
1023 symbols which are referred to by dynamic objects. */
1025 static void
1026 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1027 {
1028 if (s->header.type == lang_assignment_statement_enum)
1029 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1030 }
1032 EOF
1034 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1035 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1036 ELF_INTERPRETER_SET_DEFAULT="
1037 if (sinterp != NULL)
1038 {
1039 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1040 sinterp->size = strlen ((char *) sinterp->contents) + 1;
1041 }
1043 "
1044 else
1045 ELF_INTERPRETER_SET_DEFAULT=
1046 fi
1047 cat >>e${EMULATION_NAME}.c <<EOF
1049 /* This is called after the sections have been attached to output
1050 sections, but before any sizes or addresses have been set. */
1052 static void
1053 gld${EMULATION_NAME}_before_allocation (void)
1054 {
1055 const char *rpath;
1056 asection *sinterp;
1058 if (link_info.hash->type == bfd_link_elf_hash_table)
1059 _bfd_elf_tls_setup (output_bfd, &link_info);
1061 /* If we are going to make any variable assignments, we need to let
1062 the ELF backend know about them in case the variables are
1063 referred to by dynamic objects. */
1064 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1066 /* Let the ELF backend work out the sizes of any sections required
1067 by dynamic linking. */
1068 rpath = command_line.rpath;
1069 if (rpath == NULL)
1070 rpath = (const char *) getenv ("LD_RUN_PATH");
1071 if (! (bfd_elf_size_dynamic_sections
1072 (output_bfd, command_line.soname, rpath,
1073 command_line.filter_shlib,
1074 (const char * const *) command_line.auxiliary_filters,
1075 &link_info, &sinterp, lang_elf_version_info)))
1076 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1078 ${ELF_INTERPRETER_SET_DEFAULT}
1079 /* Let the user override the dynamic linker we are using. */
1080 if (command_line.interpreter != NULL
1081 && sinterp != NULL)
1082 {
1083 sinterp->contents = (bfd_byte *) command_line.interpreter;
1084 sinterp->size = strlen (command_line.interpreter) + 1;
1085 }
1087 /* Look for any sections named .gnu.warning. As a GNU extensions,
1088 we treat such sections as containing warning messages. We print
1089 out the warning message, and then zero out the section size so
1090 that it does not get copied into the output file. */
1092 {
1093 LANG_FOR_EACH_INPUT_STATEMENT (is)
1094 {
1095 asection *s;
1096 bfd_size_type sz;
1097 bfd_size_type prefix_len;
1098 char *msg;
1099 bfd_boolean ret;
1100 const char * gnu_warning_prefix = _("warning: ");
1102 if (is->just_syms_flag)
1103 continue;
1105 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1106 if (s == NULL)
1107 continue;
1109 sz = s->size;
1110 prefix_len = strlen (gnu_warning_prefix);
1111 msg = xmalloc ((size_t) (prefix_len + sz + 1));
1112 strcpy (msg, gnu_warning_prefix);
1113 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
1114 (file_ptr) 0, sz))
1115 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1116 is->the_bfd);
1117 msg[prefix_len + sz] = '\0';
1118 ret = link_info.callbacks->warning (&link_info, msg,
1119 (const char *) NULL,
1120 is->the_bfd, (asection *) NULL,
1121 (bfd_vma) 0);
1122 ASSERT (ret);
1123 free (msg);
1125 /* Clobber the section size, so that we don't waste copying the
1126 warning into the output file. */
1127 s->size = 0;
1129 /* Also set SEC_EXCLUDE, so that symbols defined in the warning
1130 section don't get copied to the output. */
1131 s->flags |= SEC_EXCLUDE;
1132 }
1133 }
1135 before_allocation_default ();
1137 if (!bfd_elf_size_dynsym_hash_dynstr (output_bfd, &link_info))
1138 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1139 }
1141 EOF
1142 fi
1144 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1145 cat >>e${EMULATION_NAME}.c <<EOF
1147 /* Try to open a dynamic archive. This is where we know that ELF
1148 dynamic libraries have an extension of .so (or .sl on oddball systems
1149 like hpux). */
1151 static bfd_boolean
1152 gld${EMULATION_NAME}_open_dynamic_archive
1153 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1154 {
1155 const char *filename;
1156 char *string;
1158 if (! entry->is_archive)
1159 return FALSE;
1161 filename = entry->filename;
1163 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1164 is defined, but it does not seem worth the headache to optimize
1165 away those two bytes of space. */
1166 string = (char *) xmalloc (strlen (search->name)
1167 + strlen (filename)
1168 + strlen (arch)
1169 #ifdef EXTRA_SHLIB_EXTENSION
1170 + strlen (EXTRA_SHLIB_EXTENSION)
1171 #endif
1172 + sizeof "/lib.so");
1174 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1176 #ifdef EXTRA_SHLIB_EXTENSION
1177 /* Try the .so extension first. If that fails build a new filename
1178 using EXTRA_SHLIB_EXTENSION. */
1179 if (! ldfile_try_open_bfd (string, entry))
1180 sprintf (string, "%s/lib%s%s%s", search->name,
1181 filename, arch, EXTRA_SHLIB_EXTENSION);
1182 #endif
1184 if (! ldfile_try_open_bfd (string, entry))
1185 {
1186 free (string);
1187 return FALSE;
1188 }
1190 entry->filename = string;
1192 /* We have found a dynamic object to include in the link. The ELF
1193 backend linker will create a DT_NEEDED entry in the .dynamic
1194 section naming this file. If this file includes a DT_SONAME
1195 entry, it will be used. Otherwise, the ELF linker will just use
1196 the name of the file. For an archive found by searching, like
1197 this one, the DT_NEEDED entry should consist of just the name of
1198 the file, without the path information used to find it. Note
1199 that we only need to do this if we have a dynamic object; an
1200 archive will never be referenced by a DT_NEEDED entry.
1202 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1203 very pretty. I haven't been able to think of anything that is
1204 pretty, though. */
1205 if (bfd_check_format (entry->the_bfd, bfd_object)
1206 && (entry->the_bfd->flags & DYNAMIC) != 0)
1207 {
1208 ASSERT (entry->is_archive && entry->search_dirs_flag);
1210 /* Rather than duplicating the logic above. Just use the
1211 filename we recorded earlier. */
1213 filename = lbasename (entry->filename);
1214 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1215 }
1217 return TRUE;
1218 }
1220 EOF
1221 fi
1223 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1224 cat >>e${EMULATION_NAME}.c <<EOF
1226 /* A variant of lang_output_section_find used by place_orphan. */
1228 static lang_output_section_statement_type *
1229 output_rel_find (asection *sec, int isdyn)
1230 {
1231 lang_output_section_statement_type *lookup;
1232 lang_output_section_statement_type *last = NULL;
1233 lang_output_section_statement_type *last_alloc = NULL;
1234 lang_output_section_statement_type *last_rel = NULL;
1235 lang_output_section_statement_type *last_rel_alloc = NULL;
1236 int rela = sec->name[4] == 'a';
1238 for (lookup = &lang_output_section_statement.head->output_section_statement;
1239 lookup != NULL;
1240 lookup = lookup->next)
1241 {
1242 if (lookup->constraint != -1
1243 && strncmp (".rel", lookup->name, 4) == 0)
1244 {
1245 int lookrela = lookup->name[4] == 'a';
1247 /* .rel.dyn must come before all other reloc sections, to suit
1248 GNU ld.so. */
1249 if (isdyn)
1250 break;
1252 /* Don't place after .rel.plt as doing so results in wrong
1253 dynamic tags. */
1254 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1255 break;
1257 if (rela == lookrela || last_rel == NULL)
1258 last_rel = lookup;
1259 if ((rela == lookrela || last_rel_alloc == NULL)
1260 && lookup->bfd_section != NULL
1261 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1262 last_rel_alloc = lookup;
1263 }
1265 last = lookup;
1266 if (lookup->bfd_section != NULL
1267 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1268 last_alloc = lookup;
1269 }
1271 if (last_rel_alloc)
1272 return last_rel_alloc;
1274 if (last_rel)
1275 return last_rel;
1277 if (last_alloc)
1278 return last_alloc;
1280 return last;
1281 }
1283 /* Place an orphan section. We use this to put random SHF_ALLOC
1284 sections in the right segment. */
1286 static bfd_boolean
1287 gld${EMULATION_NAME}_place_orphan (asection *s)
1288 {
1289 static struct orphan_save hold[] =
1290 {
1291 { ".text",
1292 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1293 0, 0, 0, 0 },
1294 { ".rodata",
1295 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1296 0, 0, 0, 0 },
1297 { ".data",
1298 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1299 0, 0, 0, 0 },
1300 { ".bss",
1301 SEC_ALLOC,
1302 0, 0, 0, 0 },
1303 { 0,
1304 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1305 0, 0, 0, 0 },
1306 { ".interp",
1307 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1308 0, 0, 0, 0 },
1309 { ".sdata",
1310 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1311 0, 0, 0, 0 }
1312 };
1313 enum orphan_save_index
1314 {
1315 orphan_text = 0,
1316 orphan_rodata,
1317 orphan_data,
1318 orphan_bss,
1319 orphan_rel,
1320 orphan_interp,
1321 orphan_sdata
1322 };
1323 static int orphan_init_done = 0;
1324 struct orphan_save *place;
1325 const char *secname;
1326 lang_output_section_statement_type *after;
1327 lang_output_section_statement_type *os;
1328 int isdyn = 0;
1329 int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1330 unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1332 secname = bfd_get_section_name (s->owner, s);
1334 if (! link_info.relocatable
1335 && link_info.combreloc
1336 && (s->flags & SEC_ALLOC))
1337 {
1338 if (iself)
1339 switch (sh_type)
1340 {
1341 case SHT_RELA:
1342 secname = ".rela.dyn";
1343 isdyn = 1;
1344 break;
1345 case SHT_REL:
1346 secname = ".rel.dyn";
1347 isdyn = 1;
1348 break;
1349 default:
1350 break;
1351 }
1352 else if (strncmp (secname, ".rel", 4) == 0)
1353 {
1354 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1355 isdyn = 1;
1356 }
1357 }
1359 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1360 {
1361 /* Look through the script to see where to place this section. */
1362 os = lang_output_section_find (secname);
1364 if (os != NULL
1365 && (os->bfd_section == NULL
1366 || os->bfd_section->flags == 0
1367 || (_bfd_elf_match_sections_by_type (output_bfd,
1368 os->bfd_section,
1369 s->owner, s)
1370 && ((s->flags ^ os->bfd_section->flags)
1371 & (SEC_LOAD | SEC_ALLOC)) == 0)))
1372 {
1373 /* We already have an output section statement with this
1374 name, and its bfd section, if any, has compatible flags.
1375 If the section already exists but does not have any flags
1376 set, then it has been created by the linker, probably as a
1377 result of a --section-start command line switch. */
1378 lang_add_section (&os->children, s, os);
1379 return TRUE;
1380 }
1381 }
1383 if (!orphan_init_done)
1384 {
1385 struct orphan_save *ho;
1386 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1387 if (ho->name != NULL)
1388 {
1389 ho->os = lang_output_section_find (ho->name);
1390 if (ho->os != NULL && ho->os->flags == 0)
1391 ho->os->flags = ho->flags;
1392 }
1393 orphan_init_done = 1;
1394 }
1396 /* If this is a final link, then always put .gnu.warning.SYMBOL
1397 sections into the .text section to get them out of the way. */
1398 if (link_info.executable
1399 && ! link_info.relocatable
1400 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1401 && hold[orphan_text].os != NULL)
1402 {
1403 lang_add_section (&hold[orphan_text].os->children, s,
1404 hold[orphan_text].os);
1405 return TRUE;
1406 }
1408 /* Decide which segment the section should go in based on the
1409 section name and section flags. We put loadable .note sections
1410 right after the .interp section, so that the PT_NOTE segment is
1411 stored right after the program headers where the OS can read it
1412 in the first page. */
1414 place = NULL;
1415 if ((s->flags & SEC_ALLOC) == 0)
1416 ;
1417 else if ((s->flags & SEC_LOAD) != 0
1418 && ((iself && sh_type == SHT_NOTE)
1419 || (!iself && strncmp (secname, ".note", 5) == 0)))
1420 place = &hold[orphan_interp];
1421 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1422 place = &hold[orphan_bss];
1423 else if ((s->flags & SEC_SMALL_DATA) != 0)
1424 place = &hold[orphan_sdata];
1425 else if ((s->flags & SEC_READONLY) == 0)
1426 place = &hold[orphan_data];
1427 else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
1428 || (!iself && strncmp (secname, ".rel", 4) == 0))
1429 && (s->flags & SEC_LOAD) != 0)
1430 place = &hold[orphan_rel];
1431 else if ((s->flags & SEC_CODE) == 0)
1432 place = &hold[orphan_rodata];
1433 else
1434 place = &hold[orphan_text];
1436 after = NULL;
1437 if (place != NULL)
1438 {
1439 if (place->os == NULL)
1440 {
1441 if (place->name != NULL)
1442 place->os = lang_output_section_find (place->name);
1443 else
1444 place->os = output_rel_find (s, isdyn);
1445 }
1446 after = place->os;
1447 if (after == NULL)
1448 after = lang_output_section_find_by_flags
1449 (s, &place->os, _bfd_elf_match_sections_by_type);
1450 if (after == NULL)
1451 /* *ABS* is always the first output section statement. */
1452 after = &lang_output_section_statement.head->output_section_statement;
1453 }
1455 /* Choose a unique name for the section. This will be needed if the
1456 same section name appears in the input file with different
1457 loadable or allocatable characteristics. */
1458 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1459 {
1460 static int count = 1;
1461 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1462 if (secname == NULL)
1463 einfo ("%F%P: place_orphan failed: %E\n");
1464 }
1466 lang_insert_orphan (s, secname, after, place, NULL, NULL);
1468 return TRUE;
1469 }
1470 EOF
1471 fi
1473 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1474 cat >>e${EMULATION_NAME}.c <<EOF
1476 static void
1477 gld${EMULATION_NAME}_layout_sections_again (void)
1478 {
1479 lang_reset_memory_regions ();
1481 /* Resize the sections. */
1482 lang_size_sections (NULL, TRUE);
1484 /* Redo special stuff. */
1485 ldemul_after_allocation ();
1487 /* Do the assignments again. */
1488 lang_do_assignments ();
1489 }
1491 static void
1492 gld${EMULATION_NAME}_finish (void)
1493 {
1494 if (bfd_elf_discard_info (output_bfd, &link_info))
1495 gld${EMULATION_NAME}_layout_sections_again ();
1497 finish_default ();
1498 }
1499 EOF
1500 fi
1502 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1503 cat >>e${EMULATION_NAME}.c <<EOF
1505 static char *
1506 gld${EMULATION_NAME}_get_script (int *isfile)
1507 EOF
1509 if test -n "$COMPILE_IN"
1510 then
1511 # Scripts compiled in.
1513 # sed commands to quote an ld script as a C string.
1514 sc="-f stringify.sed"
1516 cat >>e${EMULATION_NAME}.c <<EOF
1517 {
1518 *isfile = 0;
1520 if (link_info.relocatable && config.build_constructors)
1521 return
1522 EOF
1523 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1524 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1525 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1526 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1527 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1528 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1529 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1530 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1531 fi
1532 if test -n "$GENERATE_PIE_SCRIPT" ; then
1533 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1534 echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1535 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1536 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1537 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
1538 echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1539 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
1540 fi
1541 echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1542 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
1543 fi
1544 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1545 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1546 echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1547 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1548 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1549 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
1550 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1551 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1552 fi
1553 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1554 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1555 fi
1556 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1557 echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1558 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1559 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
1560 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1561 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1562 fi
1563 echo ' ; else return' >> e${EMULATION_NAME}.c
1564 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1565 echo '; }' >> e${EMULATION_NAME}.c
1567 else
1568 # Scripts read from the filesystem.
1570 cat >>e${EMULATION_NAME}.c <<EOF
1571 {
1572 *isfile = 1;
1574 if (link_info.relocatable && config.build_constructors)
1575 return "ldscripts/${EMULATION_NAME}.xu";
1576 else if (link_info.relocatable)
1577 return "ldscripts/${EMULATION_NAME}.xr";
1578 else if (!config.text_read_only)
1579 return "ldscripts/${EMULATION_NAME}.xbn";
1580 EOF
1581 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1582 else
1583 cat >>e${EMULATION_NAME}.c <<EOF
1584 else if (!config.magic_demand_paged)
1585 return "ldscripts/${EMULATION_NAME}.xn";
1586 EOF
1587 fi
1588 if test -n "$GENERATE_PIE_SCRIPT" ; then
1589 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1590 cat >>e${EMULATION_NAME}.c <<EOF
1591 else if (link_info.pie && link_info.combreloc
1592 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1593 return "ldscripts/${EMULATION_NAME}.xdw";
1594 else if (link_info.pie && link_info.combreloc)
1595 return "ldscripts/${EMULATION_NAME}.xdc";
1596 EOF
1597 fi
1598 cat >>e${EMULATION_NAME}.c <<EOF
1599 else if (link_info.pie)
1600 return "ldscripts/${EMULATION_NAME}.xd";
1601 EOF
1602 fi
1603 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1604 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1605 cat >>e${EMULATION_NAME}.c <<EOF
1606 else if (link_info.shared && link_info.combreloc
1607 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1608 return "ldscripts/${EMULATION_NAME}.xsw";
1609 else if (link_info.shared && link_info.combreloc)
1610 return "ldscripts/${EMULATION_NAME}.xsc";
1611 EOF
1612 fi
1613 cat >>e${EMULATION_NAME}.c <<EOF
1614 else if (link_info.shared)
1615 return "ldscripts/${EMULATION_NAME}.xs";
1616 EOF
1617 fi
1618 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1619 cat >>e${EMULATION_NAME}.c <<EOF
1620 else if (link_info.combreloc && link_info.relro
1621 && (link_info.flags & DT_BIND_NOW))
1622 return "ldscripts/${EMULATION_NAME}.xw";
1623 else if (link_info.combreloc)
1624 return "ldscripts/${EMULATION_NAME}.xc";
1625 EOF
1626 fi
1627 cat >>e${EMULATION_NAME}.c <<EOF
1628 else
1629 return "ldscripts/${EMULATION_NAME}.x";
1630 }
1632 EOF
1633 fi
1634 fi
1636 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1638 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1639 cat >>e${EMULATION_NAME}.c <<EOF
1640 $PARSE_AND_LIST_PROLOGUE
1641 EOF
1642 fi
1644 cat >>e${EMULATION_NAME}.c <<EOF
1646 #define OPTION_DISABLE_NEW_DTAGS (400)
1647 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1648 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1649 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1650 #define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1)
1652 static void
1653 gld${EMULATION_NAME}_add_options
1654 (int ns, char **shortopts, int nl, struct option **longopts,
1655 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1656 {
1657 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1658 static const struct option xtra_long[] = {
1659 EOF
1661 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1662 cat >>e${EMULATION_NAME}.c <<EOF
1663 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1664 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1665 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1666 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
1667 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1668 EOF
1669 fi
1671 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1672 cat >>e${EMULATION_NAME}.c <<EOF
1673 $PARSE_AND_LIST_LONGOPTS
1674 EOF
1675 fi
1677 cat >>e${EMULATION_NAME}.c <<EOF
1678 {NULL, no_argument, NULL, 0}
1679 };
1681 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1682 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1683 *longopts = (struct option *)
1684 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1685 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1686 }
1688 static bfd_boolean
1689 gld${EMULATION_NAME}_handle_option (int optc)
1690 {
1691 switch (optc)
1692 {
1693 default:
1694 return FALSE;
1696 EOF
1698 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1699 cat >>e${EMULATION_NAME}.c <<EOF
1700 case OPTION_DISABLE_NEW_DTAGS:
1701 link_info.new_dtags = FALSE;
1702 break;
1704 case OPTION_ENABLE_NEW_DTAGS:
1705 link_info.new_dtags = TRUE;
1706 break;
1708 case OPTION_EH_FRAME_HDR:
1709 link_info.eh_frame_hdr = TRUE;
1710 break;
1712 case OPTION_GROUP:
1713 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1714 /* Groups must be self-contained. */
1715 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1716 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1717 break;
1719 case OPTION_EXCLUDE_LIBS:
1720 add_excluded_libs (optarg);
1721 break;
1723 case 'z':
1724 if (strcmp (optarg, "initfirst") == 0)
1725 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1726 else if (strcmp (optarg, "interpose") == 0)
1727 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1728 else if (strcmp (optarg, "loadfltr") == 0)
1729 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1730 else if (strcmp (optarg, "nodefaultlib") == 0)
1731 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1732 else if (strcmp (optarg, "nodelete") == 0)
1733 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1734 else if (strcmp (optarg, "nodlopen") == 0)
1735 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1736 else if (strcmp (optarg, "nodump") == 0)
1737 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1738 else if (strcmp (optarg, "now") == 0)
1739 {
1740 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1741 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1742 }
1743 else if (strcmp (optarg, "origin") == 0)
1744 {
1745 link_info.flags |= (bfd_vma) DF_ORIGIN;
1746 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1747 }
1748 else if (strcmp (optarg, "defs") == 0)
1749 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1750 else if (strcmp (optarg, "muldefs") == 0)
1751 link_info.allow_multiple_definition = TRUE;
1752 else if (strcmp (optarg, "combreloc") == 0)
1753 link_info.combreloc = TRUE;
1754 else if (strcmp (optarg, "nocombreloc") == 0)
1755 link_info.combreloc = FALSE;
1756 else if (strcmp (optarg, "nocopyreloc") == 0)
1757 link_info.nocopyreloc = TRUE;
1758 else if (strcmp (optarg, "execstack") == 0)
1759 {
1760 link_info.execstack = TRUE;
1761 link_info.noexecstack = FALSE;
1762 }
1763 else if (strcmp (optarg, "noexecstack") == 0)
1764 {
1765 link_info.noexecstack = TRUE;
1766 link_info.execstack = FALSE;
1767 }
1768 else if (strcmp (optarg, "relro") == 0)
1769 link_info.relro = TRUE;
1770 else if (strcmp (optarg, "norelro") == 0)
1771 link_info.relro = FALSE;
1772 /* What about the other Solaris -z options? FIXME. */
1773 break;
1774 EOF
1775 fi
1777 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1778 cat >>e${EMULATION_NAME}.c <<EOF
1779 $PARSE_AND_LIST_ARGS_CASES
1780 EOF
1781 fi
1783 cat >>e${EMULATION_NAME}.c <<EOF
1784 }
1786 return TRUE;
1787 }
1789 EOF
1791 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1792 cat >>e${EMULATION_NAME}.c <<EOF
1794 static void
1795 gld${EMULATION_NAME}_list_options (FILE * file)
1796 {
1797 EOF
1799 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1800 cat >>e${EMULATION_NAME}.c <<EOF
1801 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1802 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1803 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1804 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1805 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1806 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n"));
1807 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n"));
1808 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1809 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1810 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1811 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1812 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1813 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1814 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1815 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1816 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1817 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1818 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n"));
1819 fprintf (file, _(" -z norelro\t\tDon't create RELRO program header\n"));
1820 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1821 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1822 fprintf (file, _(" -z relro\t\tCreate RELRO program header\n"));
1823 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1824 EOF
1825 fi
1827 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1828 cat >>e${EMULATION_NAME}.c <<EOF
1829 $PARSE_AND_LIST_OPTIONS
1830 EOF
1831 fi
1833 cat >>e${EMULATION_NAME}.c <<EOF
1834 }
1835 EOF
1837 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1838 cat >>e${EMULATION_NAME}.c <<EOF
1839 $PARSE_AND_LIST_EPILOGUE
1840 EOF
1841 fi
1842 fi
1843 else
1844 cat >>e${EMULATION_NAME}.c <<EOF
1845 #define gld${EMULATION_NAME}_add_options NULL
1846 #define gld${EMULATION_NAME}_handle_option NULL
1847 EOF
1848 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1849 cat >>e${EMULATION_NAME}.c <<EOF
1850 #define gld${EMULATION_NAME}_list_options NULL
1851 EOF
1852 fi
1853 fi
1855 cat >>e${EMULATION_NAME}.c <<EOF
1857 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1858 {
1859 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1860 ${LDEMUL_SYSLIB-syslib_default},
1861 ${LDEMUL_HLL-hll_default},
1862 ${LDEMUL_AFTER_PARSE-after_parse_default},
1863 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1864 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1865 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1866 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1867 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1868 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1869 "${EMULATION_NAME}",
1870 "${OUTPUT_FORMAT}",
1871 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1872 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1873 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1874 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1875 ${LDEMUL_SET_SYMBOLS-NULL},
1876 ${LDEMUL_PARSE_ARGS-NULL},
1877 gld${EMULATION_NAME}_add_options,
1878 gld${EMULATION_NAME}_handle_option,
1879 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1880 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1881 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1882 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1883 ${LDEMUL_NEW_VERS_PATTERN-NULL}
1884 };
1885 EOF