| blob | 2764a59d9685820cfe89668d33fd5ae9d3fc0725 |
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"
57 /* Declare functions used by various EXTRA_EM_FILEs. */
58 static void gld${EMULATION_NAME}_before_parse (void);
59 static void gld${EMULATION_NAME}_after_open (void);
60 static void gld${EMULATION_NAME}_before_allocation (void);
61 static bfd_boolean gld${EMULATION_NAME}_place_orphan
62 (lang_input_statement_type *file, 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 (!class
128 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
129 return FALSE;
131 bfd_elf_set_dyn_lib_class (entry->the_bfd, class);
133 /* Continue on with normal load_symbols processing. */
134 return FALSE;
135 }
136 EOF
137 fi
139 cat >>e${EMULATION_NAME}.c <<EOF
141 /* These variables are required to pass information back and forth
142 between after_open and check_needed and stat_needed and vercheck. */
144 static struct bfd_link_needed_list *global_needed;
145 static struct stat global_stat;
146 static bfd_boolean global_found;
147 static struct bfd_link_needed_list *global_vercheck_needed;
148 static bfd_boolean global_vercheck_failed;
151 /* On Linux, it's possible to have different versions of the same
152 shared library linked against different versions of libc. The
153 dynamic linker somehow tags which libc version to use in
154 /etc/ld.so.cache, and, based on the libc that it sees in the
155 executable, chooses which version of the shared library to use.
157 We try to do a similar check here by checking whether this shared
158 library needs any other shared libraries which may conflict with
159 libraries we have already included in the link. If it does, we
160 skip it, and try to find another shared library farther on down the
161 link path.
163 This is called via lang_for_each_input_file.
164 GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
165 which we are checking. This sets GLOBAL_VERCHECK_FAILED if we find
166 a conflicting version. */
168 static void
169 gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
170 {
171 const char *soname;
172 struct bfd_link_needed_list *l;
174 if (global_vercheck_failed)
175 return;
176 if (s->the_bfd == NULL
177 || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
178 return;
180 soname = bfd_elf_get_dt_soname (s->the_bfd);
181 if (soname == NULL)
182 soname = lbasename (bfd_get_filename (s->the_bfd));
184 for (l = global_vercheck_needed; l != NULL; l = l->next)
185 {
186 const char *suffix;
188 if (strcmp (soname, l->name) == 0)
189 {
190 /* Probably can't happen, but it's an easy check. */
191 continue;
192 }
194 if (strchr (l->name, '/') != NULL)
195 continue;
197 suffix = strstr (l->name, ".so.");
198 if (suffix == NULL)
199 continue;
201 suffix += sizeof ".so." - 1;
203 if (strncmp (soname, l->name, suffix - l->name) == 0)
204 {
205 /* Here we know that S is a dynamic object FOO.SO.VER1, and
206 the object we are considering needs a dynamic object
207 FOO.SO.VER2, and VER1 and VER2 are different. This
208 appears to be a version mismatch, so we tell the caller
209 to try a different version of this library. */
210 global_vercheck_failed = TRUE;
211 return;
212 }
213 }
214 }
217 /* See if an input file matches a DT_NEEDED entry by running stat on
218 the file. */
220 static void
221 gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
222 {
223 struct stat st;
224 const char *suffix;
225 const char *soname;
227 if (global_found)
228 return;
229 if (s->the_bfd == NULL)
230 return;
231 if (s->as_needed
232 && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
233 return;
235 if (bfd_stat (s->the_bfd, &st) != 0)
236 {
237 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
238 return;
239 }
241 /* Some operating systems, e.g. Windows, do not provide a meaningful
242 st_ino; they always set it to zero. (Windows does provide a
243 meaningful st_dev.) Do not indicate a duplicate library in that
244 case. While there is no guarantee that a system that provides
245 meaningful inode numbers will never set st_ino to zero, this is
246 merely an optimization, so we do not need to worry about false
247 negatives. */
248 if (st.st_dev == global_stat.st_dev
249 && st.st_ino == global_stat.st_ino
250 && st.st_ino != 0)
251 {
252 global_found = TRUE;
253 return;
254 }
256 /* We issue a warning if it looks like we are including two
257 different versions of the same shared library. For example,
258 there may be a problem if -lc picks up libc.so.6 but some other
259 shared library has a DT_NEEDED entry of libc.so.5. This is a
260 heuristic test, and it will only work if the name looks like
261 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
262 If we really want to issue warnings about mixing version numbers
263 of shared libraries, we need to find a better way. */
265 if (strchr (global_needed->name, '/') != NULL)
266 return;
267 suffix = strstr (global_needed->name, ".so.");
268 if (suffix == NULL)
269 return;
270 suffix += sizeof ".so." - 1;
272 soname = bfd_elf_get_dt_soname (s->the_bfd);
273 if (soname == NULL)
274 soname = lbasename (s->filename);
276 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
277 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
278 global_needed->name, global_needed->by, soname);
279 }
281 struct dt_needed
282 {
283 bfd *by;
284 const char *name;
285 };
287 /* This function is called for each possible name for a dynamic object
288 named by a DT_NEEDED entry. The FORCE parameter indicates whether
289 to skip the check for a conflicting version. */
291 static bfd_boolean
292 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
293 int force)
294 {
295 bfd *abfd;
296 const char *name = needed->name;
297 const char *soname;
298 int class;
300 abfd = bfd_openr (name, bfd_get_target (output_bfd));
301 if (abfd == NULL)
302 return FALSE;
303 if (! bfd_check_format (abfd, bfd_object))
304 {
305 bfd_close (abfd);
306 return FALSE;
307 }
308 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
309 {
310 bfd_close (abfd);
311 return FALSE;
312 }
314 /* For DT_NEEDED, they have to match. */
315 if (abfd->xvec != output_bfd->xvec)
316 {
317 bfd_close (abfd);
318 return FALSE;
319 }
321 /* Check whether this object would include any conflicting library
322 versions. If FORCE is set, then we skip this check; we use this
323 the second time around, if we couldn't find any compatible
324 instance of the shared library. */
326 if (! force)
327 {
328 struct bfd_link_needed_list *needed;
330 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
331 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
333 if (needed != NULL)
334 {
335 global_vercheck_needed = needed;
336 global_vercheck_failed = FALSE;
337 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
338 if (global_vercheck_failed)
339 {
340 bfd_close (abfd);
341 /* Return FALSE to force the caller to move on to try
342 another file on the search path. */
343 return FALSE;
344 }
346 /* But wait! It gets much worse. On Linux, if a shared
347 library does not use libc at all, we are supposed to skip
348 it the first time around in case we encounter a shared
349 library later on with the same name which does use the
350 version of libc that we want. This is much too horrible
351 to use on any system other than Linux. */
353 EOF
354 case ${target} in
355 *-*-linux-* | *-*-k*bsd*-*)
356 cat >>e${EMULATION_NAME}.c <<EOF
357 {
358 struct bfd_link_needed_list *l;
360 for (l = needed; l != NULL; l = l->next)
361 if (strncmp (l->name, "libc.so", 7) == 0)
362 break;
363 if (l == NULL)
364 {
365 bfd_close (abfd);
366 return FALSE;
367 }
368 }
370 EOF
371 ;;
372 esac
373 cat >>e${EMULATION_NAME}.c <<EOF
374 }
375 }
377 /* We've found a dynamic object matching the DT_NEEDED entry. */
379 /* We have already checked that there is no other input file of the
380 same name. We must now check again that we are not including the
381 same file twice. We need to do this because on many systems
382 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
383 reference libc.so.1. If we have already included libc.so, we
384 don't want to include libc.so.1 if they are the same file, and we
385 can only check that using stat. */
387 if (bfd_stat (abfd, &global_stat) != 0)
388 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
390 /* First strip off everything before the last '/'. */
391 soname = lbasename (abfd->filename);
393 if (trace_file_tries)
394 info_msg (_("found %s at %s\n"), soname, name);
396 global_found = FALSE;
397 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
398 if (global_found)
399 {
400 /* Return TRUE to indicate that we found the file, even though
401 we aren't going to do anything with it. */
402 return TRUE;
403 }
405 /* Specify the soname to use. */
406 bfd_elf_set_dt_needed_name (abfd, soname);
408 /* Tell the ELF linker that we don't want the output file to have a
409 DT_NEEDED entry for this file, unless it is used to resolve
410 references in a regular object. */
411 class = DYN_DT_NEEDED;
413 /* Tell the ELF linker that we don't want the output file to have a
414 DT_NEEDED entry for this file at all if the entry is from a file
415 with DYN_NO_ADD_NEEDED. */
416 if (needed->by != NULL
417 && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
418 class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
420 bfd_elf_set_dyn_lib_class (abfd, class);
422 /* Add this file into the symbol table. */
423 if (! bfd_link_add_symbols (abfd, &link_info))
424 einfo ("%F%B: could not read symbols: %E\n", abfd);
426 return TRUE;
427 }
430 /* Search for a needed file in a path. */
432 static bfd_boolean
433 gld${EMULATION_NAME}_search_needed (const char *path,
434 struct dt_needed *n, int force)
435 {
436 const char *s;
437 const char *name = n->name;
438 size_t len;
439 struct dt_needed needed;
441 if (name[0] == '/')
442 return gld${EMULATION_NAME}_try_needed (n, force);
444 if (path == NULL || *path == '\0')
445 return FALSE;
447 needed.by = n->by;
448 needed.name = n->name;
450 len = strlen (name);
451 while (1)
452 {
453 char *filename, *sset;
455 s = strchr (path, ':');
456 if (s == NULL)
457 s = path + strlen (path);
459 filename = (char *) xmalloc (s - path + len + 2);
460 if (s == path)
461 sset = filename;
462 else
463 {
464 memcpy (filename, path, s - path);
465 filename[s - path] = '/';
466 sset = filename + (s - path) + 1;
467 }
468 strcpy (sset, name);
470 needed.name = filename;
471 if (gld${EMULATION_NAME}_try_needed (&needed, force))
472 return TRUE;
474 free (filename);
476 if (*s == '\0')
477 break;
478 path = s + 1;
479 }
481 return FALSE;
482 }
484 EOF
485 if [ "x${USE_LIBPATH}" = xyes ] ; then
486 cat >>e${EMULATION_NAME}.c <<EOF
488 /* Add the sysroot to every entry in a colon-separated path. */
490 static char *
491 gld${EMULATION_NAME}_add_sysroot (const char *path)
492 {
493 int len, colons, i;
494 char *ret, *p;
496 len = strlen (path);
497 colons = 0;
498 i = 0;
499 while (path[i])
500 if (path[i++] == ':')
501 colons++;
503 if (path[i])
504 colons++;
506 len = len + (colons + 1) * strlen (ld_sysroot);
507 ret = xmalloc (len + 1);
508 strcpy (ret, ld_sysroot);
509 p = ret + strlen (ret);
510 i = 0;
511 while (path[i])
512 if (path[i] == ':')
513 {
514 *p++ = path[i++];
515 strcpy (p, ld_sysroot);
516 p = p + strlen (p);
517 }
518 else
519 *p++ = path[i++];
521 *p = 0;
522 return ret;
523 }
525 EOF
526 case ${target} in
527 *-*-linux-* | *-*-k*bsd*-*)
528 cat >>e${EMULATION_NAME}.c <<EOF
529 /* For a native linker, check the file /etc/ld.so.conf for directories
530 in which we may find shared libraries. /etc/ld.so.conf is really
531 only meaningful on Linux. */
533 struct gld${EMULATION_NAME}_ld_so_conf
534 {
535 char *path;
536 size_t len, alloc;
537 };
539 static void
540 gld${EMULATION_NAME}_parse_ld_so_conf
541 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
543 static void
544 gld${EMULATION_NAME}_parse_ld_so_conf_include
545 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
546 const char *pattern)
547 {
548 char *newp = NULL;
549 #ifdef HAVE_GLOB
550 glob_t gl;
551 #endif
553 if (pattern[0] != '/')
554 {
555 char *p = strrchr (filename, '/');
556 size_t patlen = strlen (pattern) + 1;
558 newp = xmalloc (p - filename + 1 + patlen);
559 memcpy (newp, filename, p - filename + 1);
560 memcpy (newp + (p - filename + 1), pattern, patlen);
561 pattern = newp;
562 }
564 #ifdef HAVE_GLOB
565 if (glob (pattern, 0, NULL, &gl) == 0)
566 {
567 size_t i;
569 for (i = 0; i < gl.gl_pathc; ++i)
570 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
571 globfree (&gl);
572 }
573 #else
574 /* If we do not have glob, treat the pattern as a literal filename. */
575 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
576 #endif
578 if (newp)
579 free (newp);
580 }
582 static void
583 gld${EMULATION_NAME}_parse_ld_so_conf
584 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
585 {
586 FILE *f = fopen (filename, FOPEN_RT);
587 char *line;
588 size_t linelen;
590 if (f == NULL)
591 return;
593 linelen = 256;
594 line = xmalloc (linelen);
595 do
596 {
597 char *p = line, *q;
599 /* Normally this would use getline(3), but we need to be portable. */
600 while ((q = fgets (p, linelen - (p - line), f)) != NULL
601 && strlen (q) == linelen - (p - line) - 1
602 && line[linelen - 2] != '\n')
603 {
604 line = xrealloc (line, 2 * linelen);
605 p = line + linelen - 1;
606 linelen += linelen;
607 }
609 if (q == NULL && p == line)
610 break;
612 p = strchr (line, '\n');
613 if (p)
614 *p = '\0';
616 /* Because the file format does not know any form of quoting we
617 can search forward for the next '#' character and if found
618 make it terminating the line. */
619 p = strchr (line, '#');
620 if (p)
621 *p = '\0';
623 /* Remove leading whitespace. NUL is no whitespace character. */
624 p = line;
625 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
626 ++p;
628 /* If the line is blank it is ignored. */
629 if (p[0] == '\0')
630 continue;
632 if (!strncmp (p, "include", 7) && (p[7] == ' ' || p[7] == '\t'))
633 {
634 char *dir, c;
635 p += 8;
636 do
637 {
638 while (*p == ' ' || *p == '\t')
639 ++p;
641 if (*p == '\0')
642 break;
644 dir = p;
646 while (*p != ' ' && *p != '\t' && *p)
647 ++p;
649 c = *p;
650 *p++ = '\0';
651 if (dir[0] != '\0')
652 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
653 dir);
654 }
655 while (c != '\0');
656 }
657 else
658 {
659 char *dir = p;
660 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
661 && *p != '\r' && *p != '\v')
662 ++p;
664 while (p != dir && p[-1] == '/')
665 --p;
666 if (info->path == NULL)
667 {
668 info->alloc = p - dir + 1 + 256;
669 info->path = xmalloc (info->alloc);
670 info->len = 0;
671 }
672 else
673 {
674 if (info->len + 1 + (p - dir) >= info->alloc)
675 {
676 info->alloc += p - dir + 256;
677 info->path = xrealloc (info->path, info->alloc);
678 }
679 info->path[info->len++] = ':';
680 }
681 memcpy (info->path + info->len, dir, p - dir);
682 info->len += p - dir;
683 info->path[info->len] = '\0';
684 }
685 }
686 while (! feof (f));
687 free (line);
688 fclose (f);
689 }
691 static bfd_boolean
692 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
693 {
694 static bfd_boolean initialized;
695 static char *ld_so_conf;
696 struct dt_needed needed;
698 if (! initialized)
699 {
700 char *tmppath;
701 struct gld${EMULATION_NAME}_ld_so_conf info;
703 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
704 info.path = NULL;
705 info.len = info.alloc = 0;
706 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
707 free (tmppath);
708 if (info.path)
709 {
710 char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
711 free (info.path);
712 ld_so_conf = d;
713 }
714 initialized = TRUE;
715 }
717 if (ld_so_conf == NULL)
718 return FALSE;
721 needed.by = NULL;
722 needed.name = name;
723 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
724 }
726 EOF
727 # Linux
728 ;;
729 esac
730 fi
731 cat >>e${EMULATION_NAME}.c <<EOF
733 /* See if an input file matches a DT_NEEDED entry by name. */
735 static void
736 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
737 {
738 if (global_found)
739 return;
741 /* If this input file was an as-needed entry, and wasn't found to be
742 needed at the stage it was linked, then don't say we have loaded it. */
743 if (s->as_needed
744 && (s->the_bfd == NULL
745 || (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0))
746 return;
748 if (s->filename != NULL)
749 {
750 const char *f;
752 if (strcmp (s->filename, global_needed->name) == 0)
753 {
754 global_found = TRUE;
755 return;
756 }
758 if (s->search_dirs_flag)
759 {
760 f = strrchr (s->filename, '/');
761 if (f != NULL
762 && strcmp (f + 1, global_needed->name) == 0)
763 {
764 global_found = TRUE;
765 return;
766 }
767 }
768 }
770 if (s->the_bfd != NULL)
771 {
772 const char *soname;
774 soname = bfd_elf_get_dt_soname (s->the_bfd);
775 if (soname != NULL
776 && strcmp (soname, global_needed->name) == 0)
777 {
778 global_found = TRUE;
779 return;
780 }
781 }
782 }
784 EOF
786 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
787 cat >>e${EMULATION_NAME}.c <<EOF
789 /* This is called after all the input files have been opened. */
791 static void
792 gld${EMULATION_NAME}_after_open (void)
793 {
794 struct bfd_link_needed_list *needed, *l;
796 /* We only need to worry about this when doing a final link. */
797 if (link_info.relocatable || !link_info.executable)
798 return;
800 /* Get the list of files which appear in DT_NEEDED entries in
801 dynamic objects included in the link (often there will be none).
802 For each such file, we want to track down the corresponding
803 library, and include the symbol table in the link. This is what
804 the runtime dynamic linker will do. Tracking the files down here
805 permits one dynamic object to include another without requiring
806 special action by the person doing the link. Note that the
807 needed list can actually grow while we are stepping through this
808 loop. */
809 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
810 for (l = needed; l != NULL; l = l->next)
811 {
812 struct bfd_link_needed_list *ll;
813 struct dt_needed n, nn;
814 int force;
816 /* If the lib that needs this one was --as-needed and wasn't
817 found to be needed, then this lib isn't needed either. */
818 if (l->by != NULL
819 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
820 continue;
822 /* If we've already seen this file, skip it. */
823 for (ll = needed; ll != l; ll = ll->next)
824 if ((ll->by == NULL
825 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
826 && strcmp (ll->name, l->name) == 0)
827 break;
828 if (ll != l)
829 continue;
831 /* See if this file was included in the link explicitly. */
832 global_needed = l;
833 global_found = FALSE;
834 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
835 if (global_found)
836 continue;
838 n.by = l->by;
839 n.name = l->name;
840 nn.by = l->by;
841 if (trace_file_tries)
842 info_msg (_("%s needed by %B\n"), l->name, l->by);
844 /* We need to find this file and include the symbol table. We
845 want to search for the file in the same way that the dynamic
846 linker will search. That means that we want to use
847 rpath_link, rpath, then the environment variable
848 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
849 entries (native only), then the linker script LIB_SEARCH_DIRS.
850 We do not search using the -L arguments.
852 We search twice. The first time, we skip objects which may
853 introduce version mismatches. The second time, we force
854 their use. See gld${EMULATION_NAME}_vercheck comment. */
855 for (force = 0; force < 2; force++)
856 {
857 size_t len;
858 search_dirs_type *search;
859 EOF
860 if [ "x${NATIVE}" = xyes ] ; then
861 cat >>e${EMULATION_NAME}.c <<EOF
862 const char *lib_path;
863 EOF
864 fi
865 if [ "x${USE_LIBPATH}" = xyes ] ; then
866 cat >>e${EMULATION_NAME}.c <<EOF
867 struct bfd_link_needed_list *rp;
868 int found;
869 EOF
870 fi
871 cat >>e${EMULATION_NAME}.c <<EOF
873 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
874 &n, force))
875 break;
876 EOF
877 if [ "x${USE_LIBPATH}" = xyes ] ; then
878 cat >>e${EMULATION_NAME}.c <<EOF
879 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
880 &n, force))
881 break;
882 EOF
883 fi
884 if [ "x${NATIVE}" = xyes ] ; then
885 cat >>e${EMULATION_NAME}.c <<EOF
886 if (command_line.rpath_link == NULL
887 && command_line.rpath == NULL)
888 {
889 lib_path = (const char *) getenv ("LD_RUN_PATH");
890 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
891 force))
892 break;
893 }
894 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
895 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
896 break;
897 EOF
898 fi
899 if [ "x${USE_LIBPATH}" = xyes ] ; then
900 cat >>e${EMULATION_NAME}.c <<EOF
901 found = 0;
902 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
903 for (; !found && rp != NULL; rp = rp->next)
904 {
905 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
906 found = (rp->by == l->by
907 && gld${EMULATION_NAME}_search_needed (tmpname,
908 &n,
909 force));
910 free (tmpname);
911 }
912 if (found)
913 break;
915 EOF
916 fi
917 cat >>e${EMULATION_NAME}.c <<EOF
918 len = strlen (l->name);
919 for (search = search_head; search != NULL; search = search->next)
920 {
921 char *filename;
923 if (search->cmdline)
924 continue;
925 filename = (char *) xmalloc (strlen (search->name) + len + 2);
926 sprintf (filename, "%s/%s", search->name, l->name);
927 nn.name = filename;
928 if (gld${EMULATION_NAME}_try_needed (&nn, force))
929 break;
930 free (filename);
931 }
932 if (search != NULL)
933 break;
934 EOF
935 if [ "x${USE_LIBPATH}" = xyes ] ; then
936 case ${target} in
937 *-*-linux-* | *-*-k*bsd*-*)
938 cat >>e${EMULATION_NAME}.c <<EOF
939 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
940 break;
941 EOF
942 # Linux
943 ;;
944 esac
945 fi
946 cat >>e${EMULATION_NAME}.c <<EOF
947 }
949 if (force < 2)
950 continue;
952 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
953 l->name, l->by);
954 }
955 }
957 EOF
958 fi
960 cat >>e${EMULATION_NAME}.c <<EOF
962 /* Look through an expression for an assignment statement. */
964 static void
965 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
966 {
967 bfd_boolean provide = FALSE;
969 switch (exp->type.node_class)
970 {
971 case etree_provide:
972 provide = TRUE;
973 /* Fall thru */
974 case etree_assign:
975 /* We call record_link_assignment even if the symbol is defined.
976 This is because if it is defined by a dynamic object, we
977 actually want to use the value defined by the linker script,
978 not the value from the dynamic object (because we are setting
979 symbols like etext). If the symbol is defined by a regular
980 object, then, as it happens, calling record_link_assignment
981 will do no harm. */
982 if (strcmp (exp->assign.dst, ".") != 0)
983 {
984 if (!bfd_elf_record_link_assignment (&link_info, exp->assign.dst,
985 provide))
986 einfo ("%P%F: failed to record assignment to %s: %E\n",
987 exp->assign.dst);
988 }
989 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
990 break;
992 case etree_binary:
993 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
994 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
995 break;
997 case etree_trinary:
998 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
999 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1000 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1001 break;
1003 case etree_unary:
1004 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1005 break;
1007 default:
1008 break;
1009 }
1010 }
1013 /* This is called by the before_allocation routine via
1014 lang_for_each_statement. It locates any assignment statements, and
1015 tells the ELF backend about them, in case they are assignments to
1016 symbols which are referred to by dynamic objects. */
1018 static void
1019 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1020 {
1021 if (s->header.type == lang_assignment_statement_enum)
1022 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1023 }
1025 EOF
1027 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1028 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1029 ELF_INTERPRETER_SET_DEFAULT="
1030 if (sinterp != NULL)
1031 {
1032 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1033 sinterp->size = strlen ((char *) sinterp->contents) + 1;
1034 }
1036 "
1037 else
1038 ELF_INTERPRETER_SET_DEFAULT=
1039 fi
1040 cat >>e${EMULATION_NAME}.c <<EOF
1042 /* This is called after the sections have been attached to output
1043 sections, but before any sizes or addresses have been set. */
1045 static void
1046 gld${EMULATION_NAME}_before_allocation (void)
1047 {
1048 const char *rpath;
1049 asection *sinterp;
1051 if (link_info.hash->type == bfd_link_elf_hash_table)
1052 _bfd_elf_tls_setup (output_bfd, &link_info);
1054 /* If we are going to make any variable assignments, we need to let
1055 the ELF backend know about them in case the variables are
1056 referred to by dynamic objects. */
1057 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1059 /* Let the ELF backend work out the sizes of any sections required
1060 by dynamic linking. */
1061 rpath = command_line.rpath;
1062 if (rpath == NULL)
1063 rpath = (const char *) getenv ("LD_RUN_PATH");
1064 if (! (bfd_elf_size_dynamic_sections
1065 (output_bfd, command_line.soname, rpath,
1066 command_line.filter_shlib,
1067 (const char * const *) command_line.auxiliary_filters,
1068 &link_info, &sinterp, lang_elf_version_info)))
1069 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1071 ${ELF_INTERPRETER_SET_DEFAULT}
1072 /* Let the user override the dynamic linker we are using. */
1073 if (command_line.interpreter != NULL
1074 && sinterp != NULL)
1075 {
1076 sinterp->contents = (bfd_byte *) command_line.interpreter;
1077 sinterp->size = strlen (command_line.interpreter) + 1;
1078 }
1080 /* Look for any sections named .gnu.warning. As a GNU extensions,
1081 we treat such sections as containing warning messages. We print
1082 out the warning message, and then zero out the section size so
1083 that it does not get copied into the output file. */
1085 {
1086 LANG_FOR_EACH_INPUT_STATEMENT (is)
1087 {
1088 asection *s;
1089 bfd_size_type sz;
1090 bfd_size_type prefix_len;
1091 char *msg;
1092 bfd_boolean ret;
1093 const char * gnu_warning_prefix = _("warning: ");
1095 if (is->just_syms_flag)
1096 continue;
1098 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1099 if (s == NULL)
1100 continue;
1102 sz = s->size;
1103 prefix_len = strlen (gnu_warning_prefix);
1104 msg = xmalloc ((size_t) (prefix_len + sz + 1));
1105 strcpy (msg, gnu_warning_prefix);
1106 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
1107 (file_ptr) 0, sz))
1108 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1109 is->the_bfd);
1110 msg[prefix_len + sz] = '\0';
1111 ret = link_info.callbacks->warning (&link_info, msg,
1112 (const char *) NULL,
1113 is->the_bfd, (asection *) NULL,
1114 (bfd_vma) 0);
1115 ASSERT (ret);
1116 free (msg);
1118 /* Clobber the section size, so that we don't waste copying the
1119 warning into the output file. */
1120 s->size = 0;
1122 /* Also set SEC_EXCLUDE, so that symbols defined in the warning
1123 section don't get copied to the output. */
1124 s->flags |= SEC_EXCLUDE;
1125 }
1126 }
1128 before_allocation_default ();
1130 if (!bfd_elf_size_dynsym_hash_dynstr (output_bfd, &link_info))
1131 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1132 }
1134 EOF
1135 fi
1137 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1138 cat >>e${EMULATION_NAME}.c <<EOF
1140 /* Try to open a dynamic archive. This is where we know that ELF
1141 dynamic libraries have an extension of .so (or .sl on oddball systems
1142 like hpux). */
1144 static bfd_boolean
1145 gld${EMULATION_NAME}_open_dynamic_archive
1146 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1147 {
1148 const char *filename;
1149 char *string;
1151 if (! entry->is_archive)
1152 return FALSE;
1154 filename = entry->filename;
1156 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1157 is defined, but it does not seem worth the headache to optimize
1158 away those two bytes of space. */
1159 string = (char *) xmalloc (strlen (search->name)
1160 + strlen (filename)
1161 + strlen (arch)
1162 #ifdef EXTRA_SHLIB_EXTENSION
1163 + strlen (EXTRA_SHLIB_EXTENSION)
1164 #endif
1165 + sizeof "/lib.so");
1167 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1169 #ifdef EXTRA_SHLIB_EXTENSION
1170 /* Try the .so extension first. If that fails build a new filename
1171 using EXTRA_SHLIB_EXTENSION. */
1172 if (! ldfile_try_open_bfd (string, entry))
1173 sprintf (string, "%s/lib%s%s%s", search->name,
1174 filename, arch, EXTRA_SHLIB_EXTENSION);
1175 #endif
1177 if (! ldfile_try_open_bfd (string, entry))
1178 {
1179 free (string);
1180 return FALSE;
1181 }
1183 entry->filename = string;
1185 /* We have found a dynamic object to include in the link. The ELF
1186 backend linker will create a DT_NEEDED entry in the .dynamic
1187 section naming this file. If this file includes a DT_SONAME
1188 entry, it will be used. Otherwise, the ELF linker will just use
1189 the name of the file. For an archive found by searching, like
1190 this one, the DT_NEEDED entry should consist of just the name of
1191 the file, without the path information used to find it. Note
1192 that we only need to do this if we have a dynamic object; an
1193 archive will never be referenced by a DT_NEEDED entry.
1195 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1196 very pretty. I haven't been able to think of anything that is
1197 pretty, though. */
1198 if (bfd_check_format (entry->the_bfd, bfd_object)
1199 && (entry->the_bfd->flags & DYNAMIC) != 0)
1200 {
1201 ASSERT (entry->is_archive && entry->search_dirs_flag);
1203 /* Rather than duplicating the logic above. Just use the
1204 filename we recorded earlier. */
1206 filename = lbasename (entry->filename);
1207 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1208 }
1210 return TRUE;
1211 }
1213 EOF
1214 fi
1216 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1217 cat >>e${EMULATION_NAME}.c <<EOF
1219 /* A variant of lang_output_section_find used by place_orphan. */
1221 static lang_output_section_statement_type *
1222 output_rel_find (asection *sec, int isdyn)
1223 {
1224 lang_output_section_statement_type *lookup;
1225 lang_output_section_statement_type *last = NULL;
1226 lang_output_section_statement_type *last_alloc = NULL;
1227 lang_output_section_statement_type *last_rel = NULL;
1228 lang_output_section_statement_type *last_rel_alloc = NULL;
1229 int rela = sec->name[4] == 'a';
1231 for (lookup = &lang_output_section_statement.head->output_section_statement;
1232 lookup != NULL;
1233 lookup = lookup->next)
1234 {
1235 if (lookup->constraint != -1
1236 && strncmp (".rel", lookup->name, 4) == 0)
1237 {
1238 int lookrela = lookup->name[4] == 'a';
1240 /* .rel.dyn must come before all other reloc sections, to suit
1241 GNU ld.so. */
1242 if (isdyn)
1243 break;
1245 /* Don't place after .rel.plt as doing so results in wrong
1246 dynamic tags. */
1247 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1248 break;
1250 if (rela == lookrela || last_rel == NULL)
1251 last_rel = lookup;
1252 if ((rela == lookrela || last_rel_alloc == NULL)
1253 && lookup->bfd_section != NULL
1254 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1255 last_rel_alloc = lookup;
1256 }
1258 last = lookup;
1259 if (lookup->bfd_section != NULL
1260 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1261 last_alloc = lookup;
1262 }
1264 if (last_rel_alloc)
1265 return last_rel_alloc;
1267 if (last_rel)
1268 return last_rel;
1270 if (last_alloc)
1271 return last_alloc;
1273 return last;
1274 }
1276 /* Place an orphan section. We use this to put random SHF_ALLOC
1277 sections in the right segment. */
1279 static bfd_boolean
1280 gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1281 {
1282 static struct orphan_save hold[] =
1283 {
1284 { ".text",
1285 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1286 0, 0, 0, 0 },
1287 { ".rodata",
1288 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1289 0, 0, 0, 0 },
1290 { ".data",
1291 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1292 0, 0, 0, 0 },
1293 { ".bss",
1294 SEC_ALLOC,
1295 0, 0, 0, 0 },
1296 { 0,
1297 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1298 0, 0, 0, 0 },
1299 { ".interp",
1300 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1301 0, 0, 0, 0 },
1302 { ".sdata",
1303 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1304 0, 0, 0, 0 }
1305 };
1306 enum orphan_save_index
1307 {
1308 orphan_text = 0,
1309 orphan_rodata,
1310 orphan_data,
1311 orphan_bss,
1312 orphan_rel,
1313 orphan_interp,
1314 orphan_sdata
1315 };
1316 static int orphan_init_done = 0;
1317 struct orphan_save *place;
1318 const char *secname;
1319 lang_output_section_statement_type *after;
1320 lang_output_section_statement_type *os;
1321 int isdyn = 0;
1323 secname = bfd_get_section_name (s->owner, s);
1325 if (! link_info.relocatable
1326 && link_info.combreloc
1327 && (s->flags & SEC_ALLOC)
1328 && strncmp (secname, ".rel", 4) == 0)
1329 {
1330 if (secname[4] == 'a')
1331 secname = ".rela.dyn";
1332 else
1333 secname = ".rel.dyn";
1334 isdyn = 1;
1335 }
1337 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1338 {
1339 /* Look through the script to see where to place this section. */
1340 os = lang_output_section_find (secname);
1342 if (os != NULL
1343 && (os->bfd_section == NULL
1344 || os->bfd_section->flags == 0
1345 || ((s->flags ^ os->bfd_section->flags)
1346 & (SEC_LOAD | SEC_ALLOC)) == 0))
1347 {
1348 /* We already have an output section statement with this
1349 name, and its bfd section, if any, has compatible flags.
1350 If the section already exists but does not have any flags
1351 set, then it has been created by the linker, probably as a
1352 result of a --section-start command line switch. */
1353 lang_add_section (&os->children, s, os, file);
1354 return TRUE;
1355 }
1356 }
1358 if (!orphan_init_done)
1359 {
1360 struct orphan_save *ho;
1361 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1362 if (ho->name != NULL)
1363 {
1364 ho->os = lang_output_section_find (ho->name);
1365 if (ho->os != NULL && ho->os->flags == 0)
1366 ho->os->flags = ho->flags;
1367 }
1368 orphan_init_done = 1;
1369 }
1371 /* If this is a final link, then always put .gnu.warning.SYMBOL
1372 sections into the .text section to get them out of the way. */
1373 if (link_info.executable
1374 && ! link_info.relocatable
1375 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1376 && hold[orphan_text].os != NULL)
1377 {
1378 lang_add_section (&hold[orphan_text].os->children, s,
1379 hold[orphan_text].os, file);
1380 return TRUE;
1381 }
1383 /* Decide which segment the section should go in based on the
1384 section name and section flags. We put loadable .note sections
1385 right after the .interp section, so that the PT_NOTE segment is
1386 stored right after the program headers where the OS can read it
1387 in the first page. */
1389 place = NULL;
1390 if ((s->flags & SEC_ALLOC) == 0)
1391 ;
1392 else if ((s->flags & SEC_LOAD) != 0
1393 && strncmp (secname, ".note", 5) == 0)
1394 place = &hold[orphan_interp];
1395 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1396 place = &hold[orphan_bss];
1397 else if ((s->flags & SEC_SMALL_DATA) != 0)
1398 place = &hold[orphan_sdata];
1399 else if ((s->flags & SEC_READONLY) == 0)
1400 place = &hold[orphan_data];
1401 else if (strncmp (secname, ".rel", 4) == 0
1402 && (s->flags & SEC_LOAD) != 0)
1403 place = &hold[orphan_rel];
1404 else if ((s->flags & SEC_CODE) == 0)
1405 place = &hold[orphan_rodata];
1406 else
1407 place = &hold[orphan_text];
1409 after = NULL;
1410 if (place != NULL)
1411 {
1412 if (place->os == NULL)
1413 {
1414 if (place->name != NULL)
1415 place->os = lang_output_section_find (place->name);
1416 else
1417 place->os = output_rel_find (s, isdyn);
1418 }
1419 after = place->os;
1420 if (after == NULL)
1421 after = lang_output_section_find_by_flags (s, &place->os);
1422 if (after == NULL)
1423 /* *ABS* is always the first output section statement. */
1424 after = &lang_output_section_statement.head->output_section_statement;
1425 }
1427 /* Choose a unique name for the section. This will be needed if the
1428 same section name appears in the input file with different
1429 loadable or allocatable characteristics. */
1430 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1431 {
1432 static int count = 1;
1433 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1434 if (secname == NULL)
1435 einfo ("%F%P: place_orphan failed: %E\n");
1436 }
1438 lang_insert_orphan (file, s, secname, after, place, NULL, NULL);
1440 return TRUE;
1441 }
1442 EOF
1443 fi
1445 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1446 cat >>e${EMULATION_NAME}.c <<EOF
1448 static void
1449 gld${EMULATION_NAME}_layout_sections_again (void)
1450 {
1451 lang_reset_memory_regions ();
1453 /* Resize the sections. */
1454 lang_size_sections (NULL, TRUE);
1456 /* Redo special stuff. */
1457 ldemul_after_allocation ();
1459 /* Do the assignments again. */
1460 lang_do_assignments ();
1461 }
1463 static void
1464 gld${EMULATION_NAME}_finish (void)
1465 {
1466 if (bfd_elf_discard_info (output_bfd, &link_info))
1467 gld${EMULATION_NAME}_layout_sections_again ();
1469 finish_default ();
1470 }
1471 EOF
1472 fi
1474 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1475 cat >>e${EMULATION_NAME}.c <<EOF
1477 static char *
1478 gld${EMULATION_NAME}_get_script (int *isfile)
1479 EOF
1481 if test -n "$COMPILE_IN"
1482 then
1483 # Scripts compiled in.
1485 # sed commands to quote an ld script as a C string.
1486 sc="-f stringify.sed"
1488 cat >>e${EMULATION_NAME}.c <<EOF
1489 {
1490 *isfile = 0;
1492 if (link_info.relocatable && config.build_constructors)
1493 return
1494 EOF
1495 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1496 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1497 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1498 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1499 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1500 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1501 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1502 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1503 fi
1504 if test -n "$GENERATE_PIE_SCRIPT" ; then
1505 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1506 echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1507 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1508 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1509 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
1510 echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1511 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
1512 fi
1513 echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1514 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
1515 fi
1516 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1517 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1518 echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1519 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1520 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1521 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
1522 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1523 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1524 fi
1525 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1526 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1527 fi
1528 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1529 echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1530 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1531 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
1532 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1533 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1534 fi
1535 echo ' ; else return' >> e${EMULATION_NAME}.c
1536 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1537 echo '; }' >> e${EMULATION_NAME}.c
1539 else
1540 # Scripts read from the filesystem.
1542 cat >>e${EMULATION_NAME}.c <<EOF
1543 {
1544 *isfile = 1;
1546 if (link_info.relocatable && config.build_constructors)
1547 return "ldscripts/${EMULATION_NAME}.xu";
1548 else if (link_info.relocatable)
1549 return "ldscripts/${EMULATION_NAME}.xr";
1550 else if (!config.text_read_only)
1551 return "ldscripts/${EMULATION_NAME}.xbn";
1552 EOF
1553 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1554 else
1555 cat >>e${EMULATION_NAME}.c <<EOF
1556 else if (!config.magic_demand_paged)
1557 return "ldscripts/${EMULATION_NAME}.xn";
1558 EOF
1559 fi
1560 if test -n "$GENERATE_PIE_SCRIPT" ; then
1561 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1562 cat >>e${EMULATION_NAME}.c <<EOF
1563 else if (link_info.pie && link_info.combreloc
1564 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1565 return "ldscripts/${EMULATION_NAME}.xdw";
1566 else if (link_info.pie && link_info.combreloc)
1567 return "ldscripts/${EMULATION_NAME}.xdc";
1568 EOF
1569 fi
1570 cat >>e${EMULATION_NAME}.c <<EOF
1571 else if (link_info.pie)
1572 return "ldscripts/${EMULATION_NAME}.xd";
1573 EOF
1574 fi
1575 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1576 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1577 cat >>e${EMULATION_NAME}.c <<EOF
1578 else if (link_info.shared && link_info.combreloc
1579 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1580 return "ldscripts/${EMULATION_NAME}.xsw";
1581 else if (link_info.shared && link_info.combreloc)
1582 return "ldscripts/${EMULATION_NAME}.xsc";
1583 EOF
1584 fi
1585 cat >>e${EMULATION_NAME}.c <<EOF
1586 else if (link_info.shared)
1587 return "ldscripts/${EMULATION_NAME}.xs";
1588 EOF
1589 fi
1590 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1591 cat >>e${EMULATION_NAME}.c <<EOF
1592 else if (link_info.combreloc && link_info.relro
1593 && (link_info.flags & DT_BIND_NOW))
1594 return "ldscripts/${EMULATION_NAME}.xw";
1595 else if (link_info.combreloc)
1596 return "ldscripts/${EMULATION_NAME}.xc";
1597 EOF
1598 fi
1599 cat >>e${EMULATION_NAME}.c <<EOF
1600 else
1601 return "ldscripts/${EMULATION_NAME}.x";
1602 }
1604 EOF
1605 fi
1606 fi
1608 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1610 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1611 cat >>e${EMULATION_NAME}.c <<EOF
1612 $PARSE_AND_LIST_PROLOGUE
1613 EOF
1614 fi
1616 cat >>e${EMULATION_NAME}.c <<EOF
1618 #define OPTION_DISABLE_NEW_DTAGS (400)
1619 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1620 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1621 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1622 #define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1)
1624 static void
1625 gld${EMULATION_NAME}_add_options
1626 (int ns, char **shortopts, int nl, struct option **longopts,
1627 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1628 {
1629 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1630 static const struct option xtra_long[] = {
1631 EOF
1633 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1634 cat >>e${EMULATION_NAME}.c <<EOF
1635 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1636 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1637 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1638 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
1639 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1640 EOF
1641 fi
1643 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1644 cat >>e${EMULATION_NAME}.c <<EOF
1645 $PARSE_AND_LIST_LONGOPTS
1646 EOF
1647 fi
1649 cat >>e${EMULATION_NAME}.c <<EOF
1650 {NULL, no_argument, NULL, 0}
1651 };
1653 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1654 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1655 *longopts = (struct option *)
1656 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1657 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1658 }
1660 static bfd_boolean
1661 gld${EMULATION_NAME}_handle_option (int optc)
1662 {
1663 switch (optc)
1664 {
1665 default:
1666 return FALSE;
1668 EOF
1670 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1671 cat >>e${EMULATION_NAME}.c <<EOF
1672 case OPTION_DISABLE_NEW_DTAGS:
1673 link_info.new_dtags = FALSE;
1674 break;
1676 case OPTION_ENABLE_NEW_DTAGS:
1677 link_info.new_dtags = TRUE;
1678 break;
1680 case OPTION_EH_FRAME_HDR:
1681 link_info.eh_frame_hdr = TRUE;
1682 break;
1684 case OPTION_GROUP:
1685 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1686 /* Groups must be self-contained. */
1687 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1688 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1689 break;
1691 case OPTION_EXCLUDE_LIBS:
1692 add_excluded_libs (optarg);
1693 break;
1695 case 'z':
1696 if (strcmp (optarg, "initfirst") == 0)
1697 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1698 else if (strcmp (optarg, "interpose") == 0)
1699 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1700 else if (strcmp (optarg, "loadfltr") == 0)
1701 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1702 else if (strcmp (optarg, "nodefaultlib") == 0)
1703 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1704 else if (strcmp (optarg, "nodelete") == 0)
1705 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1706 else if (strcmp (optarg, "nodlopen") == 0)
1707 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1708 else if (strcmp (optarg, "nodump") == 0)
1709 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1710 else if (strcmp (optarg, "now") == 0)
1711 {
1712 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1713 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1714 }
1715 else if (strcmp (optarg, "origin") == 0)
1716 {
1717 link_info.flags |= (bfd_vma) DF_ORIGIN;
1718 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1719 }
1720 else if (strcmp (optarg, "defs") == 0)
1721 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1722 else if (strcmp (optarg, "muldefs") == 0)
1723 link_info.allow_multiple_definition = TRUE;
1724 else if (strcmp (optarg, "combreloc") == 0)
1725 link_info.combreloc = TRUE;
1726 else if (strcmp (optarg, "nocombreloc") == 0)
1727 link_info.combreloc = FALSE;
1728 else if (strcmp (optarg, "nocopyreloc") == 0)
1729 link_info.nocopyreloc = TRUE;
1730 else if (strcmp (optarg, "execstack") == 0)
1731 {
1732 link_info.execstack = TRUE;
1733 link_info.noexecstack = FALSE;
1734 }
1735 else if (strcmp (optarg, "noexecstack") == 0)
1736 {
1737 link_info.noexecstack = TRUE;
1738 link_info.execstack = FALSE;
1739 }
1740 else if (strcmp (optarg, "relro") == 0)
1741 link_info.relro = TRUE;
1742 else if (strcmp (optarg, "norelro") == 0)
1743 link_info.relro = FALSE;
1744 /* What about the other Solaris -z options? FIXME. */
1745 break;
1746 EOF
1747 fi
1749 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1750 cat >>e${EMULATION_NAME}.c <<EOF
1751 $PARSE_AND_LIST_ARGS_CASES
1752 EOF
1753 fi
1755 cat >>e${EMULATION_NAME}.c <<EOF
1756 }
1758 return TRUE;
1759 }
1761 EOF
1763 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1764 cat >>e${EMULATION_NAME}.c <<EOF
1766 static void
1767 gld${EMULATION_NAME}_list_options (FILE * file)
1768 {
1769 EOF
1771 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1772 cat >>e${EMULATION_NAME}.c <<EOF
1773 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1774 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1775 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1776 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1777 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1778 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n"));
1779 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n"));
1780 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1781 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1782 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1783 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1784 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1785 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1786 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1787 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1788 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1789 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1790 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n"));
1791 fprintf (file, _(" -z norelro\t\tDon't create RELRO program header\n"));
1792 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1793 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1794 fprintf (file, _(" -z relro\t\tCreate RELRO program header\n"));
1795 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1796 EOF
1797 fi
1799 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1800 cat >>e${EMULATION_NAME}.c <<EOF
1801 $PARSE_AND_LIST_OPTIONS
1802 EOF
1803 fi
1805 cat >>e${EMULATION_NAME}.c <<EOF
1806 }
1807 EOF
1809 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1810 cat >>e${EMULATION_NAME}.c <<EOF
1811 $PARSE_AND_LIST_EPILOGUE
1812 EOF
1813 fi
1814 fi
1815 else
1816 cat >>e${EMULATION_NAME}.c <<EOF
1817 #define gld${EMULATION_NAME}_add_options NULL
1818 #define gld${EMULATION_NAME}_handle_option NULL
1819 EOF
1820 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1821 cat >>e${EMULATION_NAME}.c <<EOF
1822 #define gld${EMULATION_NAME}_list_options NULL
1823 EOF
1824 fi
1825 fi
1827 cat >>e${EMULATION_NAME}.c <<EOF
1829 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1830 {
1831 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1832 ${LDEMUL_SYSLIB-syslib_default},
1833 ${LDEMUL_HLL-hll_default},
1834 ${LDEMUL_AFTER_PARSE-after_parse_default},
1835 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1836 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1837 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1838 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1839 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1840 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1841 "${EMULATION_NAME}",
1842 "${OUTPUT_FORMAT}",
1843 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1844 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1845 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1846 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1847 ${LDEMUL_SET_SYMBOLS-NULL},
1848 ${LDEMUL_PARSE_ARGS-NULL},
1849 gld${EMULATION_NAME}_add_options,
1850 gld${EMULATION_NAME}_handle_option,
1851 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1852 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1853 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1854 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1855 ${LDEMUL_NEW_VERS_PATTERN-NULL}
1856 };
1857 EOF