| blob | 1646d2ebf3d721584dc2bf0abf70e3c2f9cdfdcb |
1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 # This file is now misnamed, because it supports both 32 bit and 64 bit
4 # ELF emulations.
5 test -z "${ELFSIZE}" && ELFSIZE=32
6 if [ -z "$MACHINE" ]; then
7 OUTPUT_ARCH=${ARCH}
8 else
9 OUTPUT_ARCH=${ARCH}:${MACHINE}
10 fi
11 cat >e${EMULATION_NAME}.c <<EOF
12 /* This file is is generated by a shell script. DO NOT EDIT! */
14 /* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
15 Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
16 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
17 Written by Steve Chamberlain <sac@cygnus.com>
18 ELF support by Ian Lance Taylor <ian@cygnus.com>
20 This file is part of GLD, the Gnu Linker.
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2 of the License, or
25 (at your option) any later version.
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software
34 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
36 #define TARGET_IS_${EMULATION_NAME}
38 #include "config.h"
39 #include "bfd.h"
40 #include "sysdep.h"
41 #include "libiberty.h"
42 #include "safe-ctype.h"
43 #include "getopt.h"
45 #include "bfdlink.h"
47 #include "ld.h"
48 #include "ldmain.h"
49 #include "ldmisc.h"
50 #include "ldexp.h"
51 #include "ldlang.h"
52 #include "ldfile.h"
53 #include "ldemul.h"
54 #include <ldgram.h>
55 #include "elf/common.h"
56 #include "elf-bfd.h"
58 /* Declare functions used by various EXTRA_EM_FILEs. */
59 static void gld${EMULATION_NAME}_before_parse (void);
60 static void gld${EMULATION_NAME}_after_open (void);
61 static void gld${EMULATION_NAME}_before_allocation (void);
62 static bfd_boolean gld${EMULATION_NAME}_place_orphan (asection *s);
63 static void gld${EMULATION_NAME}_finish (void);
65 EOF
67 if [ "x${USE_LIBPATH}" = xyes ] ; then
68 case ${target} in
69 *-*-linux-* | *-*-k*bsd*-*)
70 cat >>e${EMULATION_NAME}.c <<EOF
71 #ifdef HAVE_GLOB
72 #include <glob.h>
73 #endif
74 EOF
75 ;;
76 esac
77 fi
79 # Import any needed special functions and/or overrides.
80 #
81 . ${srcdir}/emultempl/elf-generic.em
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 lang_input_statement_type *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 != NULL)
233 return;
234 if (s->the_bfd == NULL)
235 return;
237 /* If this input file was an as-needed entry, and wasn't found to be
238 needed at the stage it was linked, then don't say we have loaded it. */
239 if ((bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
240 return;
242 if (bfd_stat (s->the_bfd, &st) != 0)
243 {
244 einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
245 return;
246 }
248 /* Some operating systems, e.g. Windows, do not provide a meaningful
249 st_ino; they always set it to zero. (Windows does provide a
250 meaningful st_dev.) Do not indicate a duplicate library in that
251 case. While there is no guarantee that a system that provides
252 meaningful inode numbers will never set st_ino to zero, this is
253 merely an optimization, so we do not need to worry about false
254 negatives. */
255 if (st.st_dev == global_stat.st_dev
256 && st.st_ino == global_stat.st_ino
257 && st.st_ino != 0)
258 {
259 global_found = s;
260 return;
261 }
263 /* We issue a warning if it looks like we are including two
264 different versions of the same shared library. For example,
265 there may be a problem if -lc picks up libc.so.6 but some other
266 shared library has a DT_NEEDED entry of libc.so.5. This is a
267 heuristic test, and it will only work if the name looks like
268 NAME.so.VERSION. FIXME: Depending on file names is error-prone.
269 If we really want to issue warnings about mixing version numbers
270 of shared libraries, we need to find a better way. */
272 if (strchr (global_needed->name, '/') != NULL)
273 return;
274 suffix = strstr (global_needed->name, ".so.");
275 if (suffix == NULL)
276 return;
277 suffix += sizeof ".so." - 1;
279 soname = bfd_elf_get_dt_soname (s->the_bfd);
280 if (soname == NULL)
281 soname = lbasename (s->filename);
283 if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
284 einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
285 global_needed->name, global_needed->by, soname);
286 }
288 struct dt_needed
289 {
290 bfd *by;
291 const char *name;
292 };
294 /* This function is called for each possible name for a dynamic object
295 named by a DT_NEEDED entry. The FORCE parameter indicates whether
296 to skip the check for a conflicting version. */
298 static bfd_boolean
299 gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
300 int force)
301 {
302 bfd *abfd;
303 const char *name = needed->name;
304 const char *soname;
305 int class;
307 abfd = bfd_openr (name, bfd_get_target (output_bfd));
308 if (abfd == NULL)
309 return FALSE;
310 if (! bfd_check_format (abfd, bfd_object))
311 {
312 bfd_close (abfd);
313 return FALSE;
314 }
315 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
316 {
317 bfd_close (abfd);
318 return FALSE;
319 }
321 /* For DT_NEEDED, they have to match. */
322 if (abfd->xvec != output_bfd->xvec)
323 {
324 bfd_close (abfd);
325 return FALSE;
326 }
328 /* Check whether this object would include any conflicting library
329 versions. If FORCE is set, then we skip this check; we use this
330 the second time around, if we couldn't find any compatible
331 instance of the shared library. */
333 if (! force)
334 {
335 struct bfd_link_needed_list *needed;
337 if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
338 einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
340 if (needed != NULL)
341 {
342 global_vercheck_needed = needed;
343 global_vercheck_failed = FALSE;
344 lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
345 if (global_vercheck_failed)
346 {
347 bfd_close (abfd);
348 /* Return FALSE to force the caller to move on to try
349 another file on the search path. */
350 return FALSE;
351 }
353 /* But wait! It gets much worse. On Linux, if a shared
354 library does not use libc at all, we are supposed to skip
355 it the first time around in case we encounter a shared
356 library later on with the same name which does use the
357 version of libc that we want. This is much too horrible
358 to use on any system other than Linux. */
360 EOF
361 case ${target} in
362 *-*-linux-* | *-*-k*bsd*-*)
363 cat >>e${EMULATION_NAME}.c <<EOF
364 {
365 struct bfd_link_needed_list *l;
367 for (l = needed; l != NULL; l = l->next)
368 if (CONST_STRNEQ (l->name, "libc.so"))
369 break;
370 if (l == NULL)
371 {
372 bfd_close (abfd);
373 return FALSE;
374 }
375 }
377 EOF
378 ;;
379 esac
380 cat >>e${EMULATION_NAME}.c <<EOF
381 }
382 }
384 /* We've found a dynamic object matching the DT_NEEDED entry. */
386 /* We have already checked that there is no other input file of the
387 same name. We must now check again that we are not including the
388 same file twice. We need to do this because on many systems
389 libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
390 reference libc.so.1. If we have already included libc.so, we
391 don't want to include libc.so.1 if they are the same file, and we
392 can only check that using stat. */
394 if (bfd_stat (abfd, &global_stat) != 0)
395 einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
397 /* First strip off everything before the last '/'. */
398 soname = lbasename (abfd->filename);
400 if (trace_file_tries)
401 info_msg (_("found %s at %s\n"), soname, name);
403 global_found = NULL;
404 lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
405 if (global_found != NULL)
406 {
407 /* Return TRUE to indicate that we found the file, even though
408 we aren't going to do anything with it. */
409 return TRUE;
410 }
412 /* Specify the soname to use. */
413 bfd_elf_set_dt_needed_name (abfd, soname);
415 /* Tell the ELF linker that we don't want the output file to have a
416 DT_NEEDED entry for this file, unless it is used to resolve
417 references in a regular object. */
418 class = DYN_DT_NEEDED;
420 /* Tell the ELF linker that we don't want the output file to have a
421 DT_NEEDED entry for this file at all if the entry is from a file
422 with DYN_NO_ADD_NEEDED. */
423 if (needed->by != NULL
424 && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
425 class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
427 bfd_elf_set_dyn_lib_class (abfd, class);
429 /* Add this file into the symbol table. */
430 if (! bfd_link_add_symbols (abfd, &link_info))
431 einfo ("%F%B: could not read symbols: %E\n", abfd);
433 return TRUE;
434 }
437 /* Search for a needed file in a path. */
439 static bfd_boolean
440 gld${EMULATION_NAME}_search_needed (const char *path,
441 struct dt_needed *n, int force)
442 {
443 const char *s;
444 const char *name = n->name;
445 size_t len;
446 struct dt_needed needed;
448 if (name[0] == '/')
449 return gld${EMULATION_NAME}_try_needed (n, force);
451 if (path == NULL || *path == '\0')
452 return FALSE;
454 needed.by = n->by;
455 needed.name = n->name;
457 len = strlen (name);
458 while (1)
459 {
460 char *filename, *sset;
462 s = strchr (path, ':');
463 if (s == NULL)
464 s = path + strlen (path);
466 filename = (char *) xmalloc (s - path + len + 2);
467 if (s == path)
468 sset = filename;
469 else
470 {
471 memcpy (filename, path, s - path);
472 filename[s - path] = '/';
473 sset = filename + (s - path) + 1;
474 }
475 strcpy (sset, name);
477 needed.name = filename;
478 if (gld${EMULATION_NAME}_try_needed (&needed, force))
479 return TRUE;
481 free (filename);
483 if (*s == '\0')
484 break;
485 path = s + 1;
486 }
488 return FALSE;
489 }
491 EOF
492 if [ "x${USE_LIBPATH}" = xyes ] ; then
493 cat >>e${EMULATION_NAME}.c <<EOF
495 /* Add the sysroot to every entry in a colon-separated path. */
497 static char *
498 gld${EMULATION_NAME}_add_sysroot (const char *path)
499 {
500 int len, colons, i;
501 char *ret, *p;
503 len = strlen (path);
504 colons = 0;
505 i = 0;
506 while (path[i])
507 if (path[i++] == ':')
508 colons++;
510 if (path[i])
511 colons++;
513 len = len + (colons + 1) * strlen (ld_sysroot);
514 ret = xmalloc (len + 1);
515 strcpy (ret, ld_sysroot);
516 p = ret + strlen (ret);
517 i = 0;
518 while (path[i])
519 if (path[i] == ':')
520 {
521 *p++ = path[i++];
522 strcpy (p, ld_sysroot);
523 p = p + strlen (p);
524 }
525 else
526 *p++ = path[i++];
528 *p = 0;
529 return ret;
530 }
532 EOF
533 case ${target} in
534 *-*-freebsd* | *-*-dragonfly*)
535 cat >>e${EMULATION_NAME}.c <<EOF
536 /* Read the system search path the FreeBSD way rather than the Linux way. */
537 #ifdef HAVE_ELF_HINTS_H
538 #include <elf-hints.h>
539 #else
540 #include "elf-hints-local.h"
541 #endif
543 static bfd_boolean
544 gld${EMULATION_NAME}_check_ld_elf_hints (const char *name, int force)
545 {
546 static bfd_boolean initialized;
547 static char *ld_elf_hints;
548 struct dt_needed needed;
550 if (!initialized)
551 {
552 FILE *f;
553 char *tmppath;
555 tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, NULL);
556 f = fopen (tmppath, FOPEN_RB);
557 free (tmppath);
558 if (f != NULL)
559 {
560 struct elfhints_hdr hdr;
562 if (fread (&hdr, 1, sizeof (hdr), f) == sizeof (hdr)
563 && hdr.magic == ELFHINTS_MAGIC
564 && hdr.version == 1)
565 {
566 if (fseek (f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1)
567 {
568 char *b;
570 b = xmalloc (hdr.dirlistlen + 1);
571 if (fread (b, 1, hdr.dirlistlen + 1, f) ==
572 hdr.dirlistlen + 1)
573 ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b);
575 free (b);
576 }
577 }
578 fclose (f);
579 }
581 initialized = TRUE;
582 }
584 if (ld_elf_hints == NULL)
585 return FALSE;
587 needed.by = NULL;
588 needed.name = name;
589 return gld${EMULATION_NAME}_search_needed (ld_elf_hints, & needed,
590 force);
591 }
592 EOF
593 # FreeBSD
594 ;;
596 *-*-linux-* | *-*-k*bsd*-*)
597 cat >>e${EMULATION_NAME}.c <<EOF
598 /* For a native linker, check the file /etc/ld.so.conf for directories
599 in which we may find shared libraries. /etc/ld.so.conf is really
600 only meaningful on Linux. */
602 struct gld${EMULATION_NAME}_ld_so_conf
603 {
604 char *path;
605 size_t len, alloc;
606 };
608 static bfd_boolean
609 gld${EMULATION_NAME}_parse_ld_so_conf
610 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
612 static void
613 gld${EMULATION_NAME}_parse_ld_so_conf_include
614 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
615 const char *pattern)
616 {
617 char *newp = NULL;
618 #ifdef HAVE_GLOB
619 glob_t gl;
620 #endif
622 if (pattern[0] != '/')
623 {
624 char *p = strrchr (filename, '/');
625 size_t patlen = strlen (pattern) + 1;
627 newp = xmalloc (p - filename + 1 + patlen);
628 memcpy (newp, filename, p - filename + 1);
629 memcpy (newp + (p - filename + 1), pattern, patlen);
630 pattern = newp;
631 }
633 #ifdef HAVE_GLOB
634 if (glob (pattern, 0, NULL, &gl) == 0)
635 {
636 size_t i;
638 for (i = 0; i < gl.gl_pathc; ++i)
639 gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
640 globfree (&gl);
641 }
642 #else
643 /* If we do not have glob, treat the pattern as a literal filename. */
644 gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
645 #endif
647 if (newp)
648 free (newp);
649 }
651 static bfd_boolean
652 gld${EMULATION_NAME}_parse_ld_so_conf
653 (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
654 {
655 FILE *f = fopen (filename, FOPEN_RT);
656 char *line;
657 size_t linelen;
659 if (f == NULL)
660 return FALSE;
662 linelen = 256;
663 line = xmalloc (linelen);
664 do
665 {
666 char *p = line, *q;
668 /* Normally this would use getline(3), but we need to be portable. */
669 while ((q = fgets (p, linelen - (p - line), f)) != NULL
670 && strlen (q) == linelen - (p - line) - 1
671 && line[linelen - 2] != '\n')
672 {
673 line = xrealloc (line, 2 * linelen);
674 p = line + linelen - 1;
675 linelen += linelen;
676 }
678 if (q == NULL && p == line)
679 break;
681 p = strchr (line, '\n');
682 if (p)
683 *p = '\0';
685 /* Because the file format does not know any form of quoting we
686 can search forward for the next '#' character and if found
687 make it terminating the line. */
688 p = strchr (line, '#');
689 if (p)
690 *p = '\0';
692 /* Remove leading whitespace. NUL is no whitespace character. */
693 p = line;
694 while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
695 ++p;
697 /* If the line is blank it is ignored. */
698 if (p[0] == '\0')
699 continue;
701 if (CONST_STRNEQ (p, "include") && (p[7] == ' ' || p[7] == '\t'))
702 {
703 char *dir, c;
704 p += 8;
705 do
706 {
707 while (*p == ' ' || *p == '\t')
708 ++p;
710 if (*p == '\0')
711 break;
713 dir = p;
715 while (*p != ' ' && *p != '\t' && *p)
716 ++p;
718 c = *p;
719 *p++ = '\0';
720 if (dir[0] != '\0')
721 gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
722 dir);
723 }
724 while (c != '\0');
725 }
726 else
727 {
728 char *dir = p;
729 while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
730 && *p != '\r' && *p != '\v')
731 ++p;
733 while (p != dir && p[-1] == '/')
734 --p;
735 if (info->path == NULL)
736 {
737 info->alloc = p - dir + 1 + 256;
738 info->path = xmalloc (info->alloc);
739 info->len = 0;
740 }
741 else
742 {
743 if (info->len + 1 + (p - dir) >= info->alloc)
744 {
745 info->alloc += p - dir + 256;
746 info->path = xrealloc (info->path, info->alloc);
747 }
748 info->path[info->len++] = ':';
749 }
750 memcpy (info->path + info->len, dir, p - dir);
751 info->len += p - dir;
752 info->path[info->len] = '\0';
753 }
754 }
755 while (! feof (f));
756 free (line);
757 fclose (f);
758 return TRUE;
759 }
761 static bfd_boolean
762 gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
763 {
764 static bfd_boolean initialized;
765 static char *ld_so_conf;
766 struct dt_needed needed;
768 if (! initialized)
769 {
770 char *tmppath;
771 struct gld${EMULATION_NAME}_ld_so_conf info;
773 info.path = NULL;
774 info.len = info.alloc = 0;
775 tmppath = concat (ld_sysroot, "${prefix}/etc/ld.so.conf", NULL);
776 if (!gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath))
777 {
778 free (tmppath);
779 tmppath = concat (ld_sysroot, "/etc/ld.so.conf", NULL);
780 gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
781 }
782 free (tmppath);
784 if (info.path)
785 {
786 char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
787 free (info.path);
788 ld_so_conf = d;
789 }
790 initialized = TRUE;
791 }
793 if (ld_so_conf == NULL)
794 return FALSE;
797 needed.by = NULL;
798 needed.name = name;
799 return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
800 }
802 EOF
803 # Linux
804 ;;
805 esac
806 fi
807 cat >>e${EMULATION_NAME}.c <<EOF
809 /* See if an input file matches a DT_NEEDED entry by name. */
811 static void
812 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
813 {
814 const char *soname;
816 /* Stop looking if we've found a loaded lib. */
817 if (global_found != NULL
818 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
819 & DYN_AS_NEEDED) == 0)
820 return;
822 if (s->filename == NULL || s->the_bfd == NULL)
823 return;
825 /* Don't look for a second non-loaded as-needed lib. */
826 if (global_found != NULL
827 && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
828 return;
830 if (strcmp (s->filename, global_needed->name) == 0)
831 {
832 global_found = s;
833 return;
834 }
836 if (s->search_dirs_flag)
837 {
838 const char *f = strrchr (s->filename, '/');
839 if (f != NULL
840 && strcmp (f + 1, global_needed->name) == 0)
841 {
842 global_found = s;
843 return;
844 }
845 }
847 soname = bfd_elf_get_dt_soname (s->the_bfd);
848 if (soname != NULL
849 && strcmp (soname, global_needed->name) == 0)
850 {
851 global_found = s;
852 return;
853 }
854 }
856 EOF
858 if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
859 cat >>e${EMULATION_NAME}.c <<EOF
861 /* This is called after all the input files have been opened. */
863 static void
864 gld${EMULATION_NAME}_after_open (void)
865 {
866 struct bfd_link_needed_list *needed, *l;
868 if (link_info.eh_frame_hdr
869 && ! link_info.traditional_format
870 && ! link_info.relocatable)
871 {
872 struct elf_link_hash_table *htab;
874 htab = elf_hash_table (&link_info);
875 if (is_elf_hash_table (htab))
876 {
877 bfd *abfd;
878 asection *s;
880 for (abfd = link_info.input_bfds; abfd; abfd = abfd->link_next)
881 {
882 s = bfd_get_section_by_name (abfd, ".eh_frame");
883 if (s && s->size > 8 && !bfd_is_abs_section (s->output_section))
884 break;
885 }
886 if (abfd)
887 {
888 const struct elf_backend_data *bed;
890 bed = get_elf_backend_data (abfd);
891 s = bfd_make_section_with_flags (abfd, ".eh_frame_hdr",
892 bed->dynamic_sec_flags
893 | SEC_READONLY);
894 if (s != NULL
895 && bfd_set_section_alignment (abfd, s, 2))
896 htab->eh_info.hdr_sec = s;
897 else
898 einfo ("%P: warning: Cannot create .eh_frame_hdr section,"
899 " --eh-frame-hdr ignored.\n");
900 }
901 }
902 }
904 /* We only need to worry about this when doing a final link. */
905 if (link_info.relocatable || !link_info.executable)
906 return;
908 /* Get the list of files which appear in DT_NEEDED entries in
909 dynamic objects included in the link (often there will be none).
910 For each such file, we want to track down the corresponding
911 library, and include the symbol table in the link. This is what
912 the runtime dynamic linker will do. Tracking the files down here
913 permits one dynamic object to include another without requiring
914 special action by the person doing the link. Note that the
915 needed list can actually grow while we are stepping through this
916 loop. */
917 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
918 for (l = needed; l != NULL; l = l->next)
919 {
920 struct bfd_link_needed_list *ll;
921 struct dt_needed n, nn;
922 int force;
924 /* If the lib that needs this one was --as-needed and wasn't
925 found to be needed, then this lib isn't needed either. */
926 if (l->by != NULL
927 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
928 continue;
930 /* If we've already seen this file, skip it. */
931 for (ll = needed; ll != l; ll = ll->next)
932 if ((ll->by == NULL
933 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
934 && strcmp (ll->name, l->name) == 0)
935 break;
936 if (ll != l)
937 continue;
939 /* See if this file was included in the link explicitly. */
940 global_needed = l;
941 global_found = NULL;
942 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
943 if (global_found != NULL
944 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
945 & DYN_AS_NEEDED) == 0)
946 continue;
948 n.by = l->by;
949 n.name = l->name;
950 nn.by = l->by;
951 if (trace_file_tries)
952 info_msg (_("%s needed by %B\n"), l->name, l->by);
954 /* As-needed libs specified on the command line (or linker script)
955 take priority over libs found in search dirs. */
956 if (global_found != NULL)
957 {
958 nn.name = global_found->filename;
959 if (gld${EMULATION_NAME}_try_needed (&nn, TRUE))
960 continue;
961 }
963 /* We need to find this file and include the symbol table. We
964 want to search for the file in the same way that the dynamic
965 linker will search. That means that we want to use
966 rpath_link, rpath, then the environment variable
967 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
968 entries (native only), then the linker script LIB_SEARCH_DIRS.
969 We do not search using the -L arguments.
971 We search twice. The first time, we skip objects which may
972 introduce version mismatches. The second time, we force
973 their use. See gld${EMULATION_NAME}_vercheck comment. */
974 for (force = 0; force < 2; force++)
975 {
976 size_t len;
977 search_dirs_type *search;
978 EOF
979 if [ "x${NATIVE}" = xyes ] ; then
980 cat >>e${EMULATION_NAME}.c <<EOF
981 const char *lib_path;
982 EOF
983 fi
984 if [ "x${USE_LIBPATH}" = xyes ] ; then
985 cat >>e${EMULATION_NAME}.c <<EOF
986 struct bfd_link_needed_list *rp;
987 int found;
988 EOF
989 fi
990 cat >>e${EMULATION_NAME}.c <<EOF
992 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
993 &n, force))
994 break;
995 EOF
996 if [ "x${USE_LIBPATH}" = xyes ] ; then
997 cat >>e${EMULATION_NAME}.c <<EOF
998 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
999 &n, force))
1000 break;
1001 EOF
1002 fi
1003 if [ "x${NATIVE}" = xyes ] ; then
1004 cat >>e${EMULATION_NAME}.c <<EOF
1005 if (command_line.rpath_link == NULL
1006 && command_line.rpath == NULL)
1007 {
1008 lib_path = (const char *) getenv ("LD_RUN_PATH");
1009 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
1010 force))
1011 break;
1012 }
1013 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
1014 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
1015 break;
1016 EOF
1017 fi
1018 if [ "x${USE_LIBPATH}" = xyes ] ; then
1019 cat >>e${EMULATION_NAME}.c <<EOF
1020 found = 0;
1021 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
1022 for (; !found && rp != NULL; rp = rp->next)
1023 {
1024 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
1025 found = (rp->by == l->by
1026 && gld${EMULATION_NAME}_search_needed (tmpname,
1027 &n,
1028 force));
1029 free (tmpname);
1030 }
1031 if (found)
1032 break;
1034 EOF
1035 fi
1036 if [ "x${USE_LIBPATH}" = xyes ] ; then
1037 case ${target} in
1038 *-*-freebsd* | *-*-dragonfly*)
1039 cat >>e${EMULATION_NAME}.c <<EOF
1040 if (gld${EMULATION_NAME}_check_ld_elf_hints (l->name, force))
1041 break;
1042 EOF
1043 # FreeBSD
1044 ;;
1046 *-*-linux-* | *-*-k*bsd*-*)
1047 # Linux
1048 cat >>e${EMULATION_NAME}.c <<EOF
1049 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
1050 break;
1052 EOF
1053 ;;
1054 esac
1055 fi
1056 cat >>e${EMULATION_NAME}.c <<EOF
1057 len = strlen (l->name);
1058 for (search = search_head; search != NULL; search = search->next)
1059 {
1060 char *filename;
1062 if (search->cmdline)
1063 continue;
1064 filename = (char *) xmalloc (strlen (search->name) + len + 2);
1065 sprintf (filename, "%s/%s", search->name, l->name);
1066 nn.name = filename;
1067 if (gld${EMULATION_NAME}_try_needed (&nn, force))
1068 break;
1069 free (filename);
1070 }
1071 if (search != NULL)
1072 break;
1073 EOF
1074 cat >>e${EMULATION_NAME}.c <<EOF
1075 }
1077 if (force < 2)
1078 continue;
1080 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
1081 l->name, l->by);
1082 }
1083 }
1085 EOF
1086 fi
1088 cat >>e${EMULATION_NAME}.c <<EOF
1090 /* Look through an expression for an assignment statement. */
1092 static void
1093 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1094 {
1095 bfd_boolean provide = FALSE;
1097 switch (exp->type.node_class)
1098 {
1099 case etree_provide:
1100 provide = TRUE;
1101 /* Fall thru */
1102 case etree_assign:
1103 /* We call record_link_assignment even if the symbol is defined.
1104 This is because if it is defined by a dynamic object, we
1105 actually want to use the value defined by the linker script,
1106 not the value from the dynamic object (because we are setting
1107 symbols like etext). If the symbol is defined by a regular
1108 object, then, as it happens, calling record_link_assignment
1109 will do no harm. */
1110 if (strcmp (exp->assign.dst, ".") != 0)
1111 {
1112 if (!bfd_elf_record_link_assignment (output_bfd, &link_info,
1113 exp->assign.dst, provide,
1114 exp->assign.hidden))
1115 einfo ("%P%F: failed to record assignment to %s: %E\n",
1116 exp->assign.dst);
1117 }
1118 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1119 break;
1121 case etree_binary:
1122 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1123 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1124 break;
1126 case etree_trinary:
1127 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1128 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1129 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1130 break;
1132 case etree_unary:
1133 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1134 break;
1136 default:
1137 break;
1138 }
1139 }
1142 /* This is called by the before_allocation routine via
1143 lang_for_each_statement. It locates any assignment statements, and
1144 tells the ELF backend about them, in case they are assignments to
1145 symbols which are referred to by dynamic objects. */
1147 static void
1148 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1149 {
1150 if (s->header.type == lang_assignment_statement_enum)
1151 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1152 }
1154 EOF
1156 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1157 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1158 ELF_INTERPRETER_SET_DEFAULT="
1159 if (sinterp != NULL)
1160 {
1161 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1162 sinterp->size = strlen ((char *) sinterp->contents) + 1;
1163 }
1165 "
1166 else
1167 ELF_INTERPRETER_SET_DEFAULT=
1168 fi
1169 cat >>e${EMULATION_NAME}.c <<EOF
1171 /* This is called after the sections have been attached to output
1172 sections, but before any sizes or addresses have been set. */
1174 static void
1175 gld${EMULATION_NAME}_before_allocation (void)
1176 {
1177 const char *rpath;
1178 asection *sinterp;
1180 if (link_info.hash->type == bfd_link_elf_hash_table)
1181 _bfd_elf_tls_setup (output_bfd, &link_info);
1183 /* If we are going to make any variable assignments, we need to let
1184 the ELF backend know about them in case the variables are
1185 referred to by dynamic objects. */
1186 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1188 /* Let the ELF backend work out the sizes of any sections required
1189 by dynamic linking. */
1190 rpath = command_line.rpath;
1191 if (rpath == NULL)
1192 rpath = (const char *) getenv ("LD_RUN_PATH");
1193 if (! (bfd_elf_size_dynamic_sections
1194 (output_bfd, command_line.soname, rpath,
1195 command_line.filter_shlib,
1196 (const char * const *) command_line.auxiliary_filters,
1197 &link_info, &sinterp, lang_elf_version_info)))
1198 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1200 ${ELF_INTERPRETER_SET_DEFAULT}
1201 /* Let the user override the dynamic linker we are using. */
1202 if (command_line.interpreter != NULL
1203 && sinterp != NULL)
1204 {
1205 sinterp->contents = (bfd_byte *) command_line.interpreter;
1206 sinterp->size = strlen (command_line.interpreter) + 1;
1207 }
1209 /* Look for any sections named .gnu.warning. As a GNU extensions,
1210 we treat such sections as containing warning messages. We print
1211 out the warning message, and then zero out the section size so
1212 that it does not get copied into the output file. */
1214 {
1215 LANG_FOR_EACH_INPUT_STATEMENT (is)
1216 {
1217 asection *s;
1218 bfd_size_type sz;
1219 char *msg;
1220 bfd_boolean ret;
1222 if (is->just_syms_flag)
1223 continue;
1225 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1226 if (s == NULL)
1227 continue;
1229 sz = s->size;
1230 msg = xmalloc ((size_t) (sz + 1));
1231 if (! bfd_get_section_contents (is->the_bfd, s, msg,
1232 (file_ptr) 0, sz))
1233 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1234 is->the_bfd);
1235 msg[sz] = '\0';
1236 ret = link_info.callbacks->warning (&link_info, msg,
1237 (const char *) NULL,
1238 is->the_bfd, (asection *) NULL,
1239 (bfd_vma) 0);
1240 ASSERT (ret);
1241 free (msg);
1243 /* Clobber the section size, so that we don't waste space
1244 copying the warning into the output file. If we've already
1245 sized the output section, adjust its size. The adjustment
1246 is on rawsize because targets that size sections early will
1247 have called lang_reset_memory_regions after sizing. */
1248 if (s->output_section != NULL
1249 && s->output_section->rawsize >= s->size)
1250 s->output_section->rawsize -= s->size;
1252 s->size = 0;
1254 /* Also set SEC_EXCLUDE, so that local symbols defined in the
1255 warning section don't get copied to the output. */
1256 s->flags |= SEC_EXCLUDE | SEC_KEEP;
1257 }
1258 }
1260 before_allocation_default ();
1262 if (!bfd_elf_size_dynsym_hash_dynstr (output_bfd, &link_info))
1263 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1264 }
1266 EOF
1267 fi
1269 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1270 cat >>e${EMULATION_NAME}.c <<EOF
1272 /* Try to open a dynamic archive. This is where we know that ELF
1273 dynamic libraries have an extension of .so (or .sl on oddball systems
1274 like hpux). */
1276 static bfd_boolean
1277 gld${EMULATION_NAME}_open_dynamic_archive
1278 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1279 {
1280 const char *filename;
1281 char *string;
1283 if (! entry->is_archive)
1284 return FALSE;
1286 filename = entry->filename;
1288 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1289 is defined, but it does not seem worth the headache to optimize
1290 away those two bytes of space. */
1291 string = (char *) xmalloc (strlen (search->name)
1292 + strlen (filename)
1293 + strlen (arch)
1294 #ifdef EXTRA_SHLIB_EXTENSION
1295 + strlen (EXTRA_SHLIB_EXTENSION)
1296 #endif
1297 + sizeof "/lib.so");
1299 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1301 #ifdef EXTRA_SHLIB_EXTENSION
1302 /* Try the .so extension first. If that fails build a new filename
1303 using EXTRA_SHLIB_EXTENSION. */
1304 if (! ldfile_try_open_bfd (string, entry))
1305 sprintf (string, "%s/lib%s%s%s", search->name,
1306 filename, arch, EXTRA_SHLIB_EXTENSION);
1307 #endif
1309 if (! ldfile_try_open_bfd (string, entry))
1310 {
1311 free (string);
1312 return FALSE;
1313 }
1315 entry->filename = string;
1317 /* We have found a dynamic object to include in the link. The ELF
1318 backend linker will create a DT_NEEDED entry in the .dynamic
1319 section naming this file. If this file includes a DT_SONAME
1320 entry, it will be used. Otherwise, the ELF linker will just use
1321 the name of the file. For an archive found by searching, like
1322 this one, the DT_NEEDED entry should consist of just the name of
1323 the file, without the path information used to find it. Note
1324 that we only need to do this if we have a dynamic object; an
1325 archive will never be referenced by a DT_NEEDED entry.
1327 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1328 very pretty. I haven't been able to think of anything that is
1329 pretty, though. */
1330 if (bfd_check_format (entry->the_bfd, bfd_object)
1331 && (entry->the_bfd->flags & DYNAMIC) != 0)
1332 {
1333 ASSERT (entry->is_archive && entry->search_dirs_flag);
1335 /* Rather than duplicating the logic above. Just use the
1336 filename we recorded earlier. */
1338 filename = lbasename (entry->filename);
1339 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1340 }
1342 return TRUE;
1343 }
1345 EOF
1346 fi
1348 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1349 cat >>e${EMULATION_NAME}.c <<EOF
1351 /* A variant of lang_output_section_find used by place_orphan. */
1353 static lang_output_section_statement_type *
1354 output_rel_find (asection *sec, int isdyn)
1355 {
1356 lang_output_section_statement_type *lookup;
1357 lang_output_section_statement_type *last = NULL;
1358 lang_output_section_statement_type *last_alloc = NULL;
1359 lang_output_section_statement_type *last_rel = NULL;
1360 lang_output_section_statement_type *last_rel_alloc = NULL;
1361 int rela = sec->name[4] == 'a';
1363 for (lookup = &lang_output_section_statement.head->output_section_statement;
1364 lookup != NULL;
1365 lookup = lookup->next)
1366 {
1367 if (lookup->constraint != -1
1368 && CONST_STRNEQ (lookup->name, ".rel"))
1369 {
1370 int lookrela = lookup->name[4] == 'a';
1372 /* .rel.dyn must come before all other reloc sections, to suit
1373 GNU ld.so. */
1374 if (isdyn)
1375 break;
1377 /* Don't place after .rel.plt as doing so results in wrong
1378 dynamic tags. */
1379 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1380 break;
1382 if (rela == lookrela || last_rel == NULL)
1383 last_rel = lookup;
1384 if ((rela == lookrela || last_rel_alloc == NULL)
1385 && lookup->bfd_section != NULL
1386 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1387 last_rel_alloc = lookup;
1388 }
1390 last = lookup;
1391 if (lookup->bfd_section != NULL
1392 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1393 last_alloc = lookup;
1394 }
1396 if (last_rel_alloc)
1397 return last_rel_alloc;
1399 if (last_rel)
1400 return last_rel;
1402 if (last_alloc)
1403 return last_alloc;
1405 return last;
1406 }
1408 /* Place an orphan section. We use this to put random SHF_ALLOC
1409 sections in the right segment. */
1411 static bfd_boolean
1412 gld${EMULATION_NAME}_place_orphan (asection *s)
1413 {
1414 static struct orphan_save hold[] =
1415 {
1416 { ".text",
1417 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1418 0, 0, 0, 0 },
1419 { ".rodata",
1420 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1421 0, 0, 0, 0 },
1422 { ".data",
1423 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1424 0, 0, 0, 0 },
1425 { ".bss",
1426 SEC_ALLOC,
1427 0, 0, 0, 0 },
1428 { 0,
1429 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1430 0, 0, 0, 0 },
1431 { ".interp",
1432 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1433 0, 0, 0, 0 },
1434 { ".sdata",
1435 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1436 0, 0, 0, 0 }
1437 };
1438 enum orphan_save_index
1439 {
1440 orphan_text = 0,
1441 orphan_rodata,
1442 orphan_data,
1443 orphan_bss,
1444 orphan_rel,
1445 orphan_interp,
1446 orphan_sdata
1447 };
1448 static int orphan_init_done = 0;
1449 struct orphan_save *place;
1450 const char *secname;
1451 lang_output_section_statement_type *after;
1452 lang_output_section_statement_type *os;
1453 int isdyn = 0;
1454 int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1455 unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1457 secname = bfd_get_section_name (s->owner, s);
1459 if (! link_info.relocatable
1460 && link_info.combreloc
1461 && (s->flags & SEC_ALLOC))
1462 {
1463 if (iself)
1464 switch (sh_type)
1465 {
1466 case SHT_RELA:
1467 secname = ".rela.dyn";
1468 isdyn = 1;
1469 break;
1470 case SHT_REL:
1471 secname = ".rel.dyn";
1472 isdyn = 1;
1473 break;
1474 default:
1475 break;
1476 }
1477 else if (CONST_STRNEQ (secname, ".rel"))
1478 {
1479 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1480 isdyn = 1;
1481 }
1482 }
1484 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1485 {
1486 /* Look through the script to see where to place this section. */
1487 os = lang_output_section_find (secname);
1489 if (os != NULL
1490 && (os->bfd_section == NULL
1491 || os->bfd_section->flags == 0
1492 || (_bfd_elf_match_sections_by_type (output_bfd,
1493 os->bfd_section,
1494 s->owner, s)
1495 && ((s->flags ^ os->bfd_section->flags)
1496 & (SEC_LOAD | SEC_ALLOC)) == 0)))
1497 {
1498 /* We already have an output section statement with this
1499 name, and its bfd section, if any, has compatible flags.
1500 If the section already exists but does not have any flags
1501 set, then it has been created by the linker, probably as a
1502 result of a --section-start command line switch. */
1503 lang_add_section (&os->children, s, os);
1504 return TRUE;
1505 }
1506 }
1508 if (!orphan_init_done)
1509 {
1510 struct orphan_save *ho;
1511 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1512 if (ho->name != NULL)
1513 {
1514 ho->os = lang_output_section_find (ho->name);
1515 if (ho->os != NULL && ho->os->flags == 0)
1516 ho->os->flags = ho->flags;
1517 }
1518 orphan_init_done = 1;
1519 }
1521 /* If this is a final link, then always put .gnu.warning.SYMBOL
1522 sections into the .text section to get them out of the way. */
1523 if (link_info.executable
1524 && ! link_info.relocatable
1525 && CONST_STRNEQ (secname, ".gnu.warning.")
1526 && hold[orphan_text].os != NULL)
1527 {
1528 lang_add_section (&hold[orphan_text].os->children, s,
1529 hold[orphan_text].os);
1530 return TRUE;
1531 }
1533 /* Decide which segment the section should go in based on the
1534 section name and section flags. We put loadable .note sections
1535 right after the .interp section, so that the PT_NOTE segment is
1536 stored right after the program headers where the OS can read it
1537 in the first page. */
1539 place = NULL;
1540 if ((s->flags & SEC_ALLOC) == 0)
1541 ;
1542 else if ((s->flags & SEC_LOAD) != 0
1543 && ((iself && sh_type == SHT_NOTE)
1544 || (!iself && CONST_STRNEQ (secname, ".note"))))
1545 place = &hold[orphan_interp];
1546 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1547 place = &hold[orphan_bss];
1548 else if ((s->flags & SEC_SMALL_DATA) != 0)
1549 place = &hold[orphan_sdata];
1550 else if ((s->flags & SEC_READONLY) == 0)
1551 place = &hold[orphan_data];
1552 else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
1553 || (!iself && CONST_STRNEQ (secname, ".rel")))
1554 && (s->flags & SEC_LOAD) != 0)
1555 place = &hold[orphan_rel];
1556 else if ((s->flags & SEC_CODE) == 0)
1557 place = &hold[orphan_rodata];
1558 else
1559 place = &hold[orphan_text];
1561 after = NULL;
1562 if (place != NULL)
1563 {
1564 if (place->os == NULL)
1565 {
1566 if (place->name != NULL)
1567 place->os = lang_output_section_find (place->name);
1568 else
1569 place->os = output_rel_find (s, isdyn);
1570 }
1571 after = place->os;
1572 if (after == NULL)
1573 after = lang_output_section_find_by_flags
1574 (s, &place->os, _bfd_elf_match_sections_by_type);
1575 if (after == NULL)
1576 /* *ABS* is always the first output section statement. */
1577 after = &lang_output_section_statement.head->output_section_statement;
1578 }
1580 /* Choose a unique name for the section. This will be needed if the
1581 same section name appears in the input file with different
1582 loadable or allocatable characteristics. */
1583 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1584 {
1585 static int count = 1;
1586 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1587 if (secname == NULL)
1588 einfo ("%F%P: place_orphan failed: %E\n");
1589 }
1591 lang_insert_orphan (s, secname, after, place, NULL, NULL);
1593 return TRUE;
1594 }
1595 EOF
1596 fi
1598 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1599 cat >>e${EMULATION_NAME}.c <<EOF
1601 static void
1602 gld${EMULATION_NAME}_finish (void)
1603 {
1604 bfd_boolean need_layout = bfd_elf_discard_info (output_bfd, &link_info);
1606 gld${EMULATION_NAME}_map_segments (need_layout);
1607 finish_default ();
1608 }
1609 EOF
1610 fi
1612 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1613 cat >>e${EMULATION_NAME}.c <<EOF
1615 static char *
1616 gld${EMULATION_NAME}_get_script (int *isfile)
1617 EOF
1619 if test -n "$COMPILE_IN"
1620 then
1621 # Scripts compiled in.
1623 # sed commands to quote an ld script as a C string.
1624 sc="-f stringify.sed"
1626 cat >>e${EMULATION_NAME}.c <<EOF
1627 {
1628 *isfile = 0;
1630 if (link_info.relocatable && config.build_constructors)
1631 return
1632 EOF
1633 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1634 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1635 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1636 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1637 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1638 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1639 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1640 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1641 fi
1642 if test -n "$GENERATE_PIE_SCRIPT" ; then
1643 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1644 echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1645 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1646 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1647 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
1648 echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1649 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
1650 fi
1651 echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1652 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
1653 fi
1654 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1655 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1656 echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1657 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1658 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1659 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
1660 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1661 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1662 fi
1663 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1664 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1665 fi
1666 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1667 echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1668 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1669 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
1670 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1671 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1672 fi
1673 echo ' ; else return' >> e${EMULATION_NAME}.c
1674 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1675 echo '; }' >> e${EMULATION_NAME}.c
1677 else
1678 # Scripts read from the filesystem.
1680 cat >>e${EMULATION_NAME}.c <<EOF
1681 {
1682 *isfile = 1;
1684 if (link_info.relocatable && config.build_constructors)
1685 return "ldscripts/${EMULATION_NAME}.xu";
1686 else if (link_info.relocatable)
1687 return "ldscripts/${EMULATION_NAME}.xr";
1688 else if (!config.text_read_only)
1689 return "ldscripts/${EMULATION_NAME}.xbn";
1690 EOF
1691 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1692 else
1693 cat >>e${EMULATION_NAME}.c <<EOF
1694 else if (!config.magic_demand_paged)
1695 return "ldscripts/${EMULATION_NAME}.xn";
1696 EOF
1697 fi
1698 if test -n "$GENERATE_PIE_SCRIPT" ; then
1699 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1700 cat >>e${EMULATION_NAME}.c <<EOF
1701 else if (link_info.pie && link_info.combreloc
1702 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1703 return "ldscripts/${EMULATION_NAME}.xdw";
1704 else if (link_info.pie && link_info.combreloc)
1705 return "ldscripts/${EMULATION_NAME}.xdc";
1706 EOF
1707 fi
1708 cat >>e${EMULATION_NAME}.c <<EOF
1709 else if (link_info.pie)
1710 return "ldscripts/${EMULATION_NAME}.xd";
1711 EOF
1712 fi
1713 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1714 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1715 cat >>e${EMULATION_NAME}.c <<EOF
1716 else if (link_info.shared && link_info.combreloc
1717 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1718 return "ldscripts/${EMULATION_NAME}.xsw";
1719 else if (link_info.shared && link_info.combreloc)
1720 return "ldscripts/${EMULATION_NAME}.xsc";
1721 EOF
1722 fi
1723 cat >>e${EMULATION_NAME}.c <<EOF
1724 else if (link_info.shared)
1725 return "ldscripts/${EMULATION_NAME}.xs";
1726 EOF
1727 fi
1728 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1729 cat >>e${EMULATION_NAME}.c <<EOF
1730 else if (link_info.combreloc && link_info.relro
1731 && (link_info.flags & DT_BIND_NOW))
1732 return "ldscripts/${EMULATION_NAME}.xw";
1733 else if (link_info.combreloc)
1734 return "ldscripts/${EMULATION_NAME}.xc";
1735 EOF
1736 fi
1737 cat >>e${EMULATION_NAME}.c <<EOF
1738 else
1739 return "ldscripts/${EMULATION_NAME}.x";
1740 }
1742 EOF
1743 fi
1744 fi
1746 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1748 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1749 cat >>e${EMULATION_NAME}.c <<EOF
1750 $PARSE_AND_LIST_PROLOGUE
1751 EOF
1752 fi
1754 cat >>e${EMULATION_NAME}.c <<EOF
1756 #define OPTION_DISABLE_NEW_DTAGS (400)
1757 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1758 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1759 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1760 #define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1)
1761 #define OPTION_HASH_STYLE (OPTION_EXCLUDE_LIBS + 1)
1763 static void
1764 gld${EMULATION_NAME}_add_options
1765 (int ns, char **shortopts, int nl, struct option **longopts,
1766 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1767 {
1768 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1769 static const struct option xtra_long[] = {
1770 EOF
1772 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1773 cat >>e${EMULATION_NAME}.c <<EOF
1774 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1775 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1776 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1777 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
1778 {"hash-style", required_argument, NULL, OPTION_HASH_STYLE},
1779 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1780 EOF
1781 fi
1783 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1784 cat >>e${EMULATION_NAME}.c <<EOF
1785 $PARSE_AND_LIST_LONGOPTS
1786 EOF
1787 fi
1789 cat >>e${EMULATION_NAME}.c <<EOF
1790 {NULL, no_argument, NULL, 0}
1791 };
1793 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1794 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1795 *longopts = (struct option *)
1796 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1797 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1798 }
1800 static bfd_boolean
1801 gld${EMULATION_NAME}_handle_option (int optc)
1802 {
1803 switch (optc)
1804 {
1805 default:
1806 return FALSE;
1808 EOF
1810 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1811 cat >>e${EMULATION_NAME}.c <<EOF
1812 case OPTION_DISABLE_NEW_DTAGS:
1813 link_info.new_dtags = FALSE;
1814 break;
1816 case OPTION_ENABLE_NEW_DTAGS:
1817 link_info.new_dtags = TRUE;
1818 break;
1820 case OPTION_EH_FRAME_HDR:
1821 link_info.eh_frame_hdr = TRUE;
1822 break;
1824 case OPTION_GROUP:
1825 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1826 /* Groups must be self-contained. */
1827 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1828 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1829 break;
1831 case OPTION_EXCLUDE_LIBS:
1832 add_excluded_libs (optarg);
1833 break;
1835 case OPTION_HASH_STYLE:
1836 link_info.emit_hash = FALSE;
1837 link_info.emit_gnu_hash = FALSE;
1838 if (strcmp (optarg, "sysv") == 0)
1839 link_info.emit_hash = TRUE;
1840 else if (strcmp (optarg, "gnu") == 0)
1841 link_info.emit_gnu_hash = TRUE;
1842 else if (strcmp (optarg, "both") == 0)
1843 {
1844 link_info.emit_hash = TRUE;
1845 link_info.emit_gnu_hash = TRUE;
1846 }
1847 else
1848 einfo (_("%P%F: invalid hash style \`%s'\n"), optarg);
1849 break;
1851 case 'z':
1852 if (strcmp (optarg, "initfirst") == 0)
1853 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1854 else if (strcmp (optarg, "interpose") == 0)
1855 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1856 else if (strcmp (optarg, "loadfltr") == 0)
1857 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1858 else if (strcmp (optarg, "nodefaultlib") == 0)
1859 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1860 else if (strcmp (optarg, "nodelete") == 0)
1861 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1862 else if (strcmp (optarg, "nodlopen") == 0)
1863 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1864 else if (strcmp (optarg, "nodump") == 0)
1865 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1866 else if (strcmp (optarg, "now") == 0)
1867 {
1868 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1869 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1870 }
1871 else if (strcmp (optarg, "lazy") == 0)
1872 {
1873 link_info.flags &= ~(bfd_vma) DF_BIND_NOW;
1874 link_info.flags_1 &= ~(bfd_vma) DF_1_NOW;
1875 }
1876 else if (strcmp (optarg, "origin") == 0)
1877 {
1878 link_info.flags |= (bfd_vma) DF_ORIGIN;
1879 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1880 }
1881 else if (strcmp (optarg, "defs") == 0)
1882 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1883 else if (strcmp (optarg, "muldefs") == 0)
1884 link_info.allow_multiple_definition = TRUE;
1885 else if (strcmp (optarg, "combreloc") == 0)
1886 link_info.combreloc = TRUE;
1887 else if (strcmp (optarg, "nocombreloc") == 0)
1888 link_info.combreloc = FALSE;
1889 else if (strcmp (optarg, "nocopyreloc") == 0)
1890 link_info.nocopyreloc = TRUE;
1891 else if (strcmp (optarg, "execstack") == 0)
1892 {
1893 link_info.execstack = TRUE;
1894 link_info.noexecstack = FALSE;
1895 }
1896 else if (strcmp (optarg, "noexecstack") == 0)
1897 {
1898 link_info.noexecstack = TRUE;
1899 link_info.execstack = FALSE;
1900 }
1901 EOF
1903 if test -n "$COMMONPAGESIZE"; then
1904 cat >>e${EMULATION_NAME}.c <<EOF
1905 else if (strcmp (optarg, "relro") == 0)
1906 link_info.relro = TRUE;
1907 else if (strcmp (optarg, "norelro") == 0)
1908 link_info.relro = FALSE;
1909 EOF
1910 fi
1912 cat >>e${EMULATION_NAME}.c <<EOF
1913 else if (CONST_STRNEQ (optarg, "max-page-size="))
1914 {
1915 char *end;
1917 config.maxpagesize = strtoul (optarg + 14, &end, 0);
1918 if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0)
1919 einfo (_("%P%F: invalid maxium page size \`%s'\n"),
1920 optarg + 14);
1921 ASSERT (default_target != NULL);
1922 bfd_emul_set_maxpagesize (default_target, config.maxpagesize);
1923 }
1924 else if (CONST_STRNEQ (optarg, "common-page-size="))
1925 {
1926 char *end;
1927 config.commonpagesize = strtoul (optarg + 17, &end, 0);
1928 if (*end
1929 || (config.commonpagesize & (config.commonpagesize - 1)) != 0)
1930 einfo (_("%P%F: invalid common page size \`%s'\n"),
1931 optarg + 17);
1932 ASSERT (default_target != NULL);
1933 bfd_emul_set_commonpagesize (default_target,
1934 config.commonpagesize);
1935 }
1936 /* What about the other Solaris -z options? FIXME. */
1937 break;
1938 EOF
1939 fi
1941 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1942 cat >>e${EMULATION_NAME}.c <<EOF
1943 $PARSE_AND_LIST_ARGS_CASES
1944 EOF
1945 fi
1947 cat >>e${EMULATION_NAME}.c <<EOF
1948 }
1950 return TRUE;
1951 }
1953 EOF
1955 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1956 cat >>e${EMULATION_NAME}.c <<EOF
1958 static void
1959 gld${EMULATION_NAME}_list_options (FILE * file)
1960 {
1961 EOF
1963 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1964 cat >>e${EMULATION_NAME}.c <<EOF
1965 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1966 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1967 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1968 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1969 fprintf (file, _(" --hash-style=STYLE\tSet hash style to sysv, gnu or both\n"));
1970 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1971 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n"));
1972 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n"));
1973 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1974 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1975 fprintf (file, _(" -z lazy\t\tMark object lazy runtime binding (default)\n"));
1976 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1977 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1978 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1979 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1980 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1981 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1982 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1983 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1984 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n"));
1985 EOF
1987 if test -n "$COMMONPAGESIZE"; then
1988 cat >>e${EMULATION_NAME}.c <<EOF
1989 fprintf (file, _(" -z norelro\t\tDon't create RELRO program header\n"));
1990 EOF
1991 fi
1993 cat >>e${EMULATION_NAME}.c <<EOF
1994 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1995 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1996 EOF
1998 if test -n "$COMMONPAGESIZE"; then
1999 cat >>e${EMULATION_NAME}.c <<EOF
2000 fprintf (file, _(" -z relro\t\tCreate RELRO program header\n"));
2001 EOF
2002 fi
2004 cat >>e${EMULATION_NAME}.c <<EOF
2005 fprintf (file, _(" -z max-page-size=SIZE\tSet maximum page size to SIZE\n"));
2006 fprintf (file, _(" -z common-page-size=SIZE\n\t\t\tSet common page size to SIZE\n"));
2007 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
2008 EOF
2009 fi
2011 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
2012 cat >>e${EMULATION_NAME}.c <<EOF
2013 $PARSE_AND_LIST_OPTIONS
2014 EOF
2015 fi
2017 cat >>e${EMULATION_NAME}.c <<EOF
2018 }
2019 EOF
2021 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
2022 cat >>e${EMULATION_NAME}.c <<EOF
2023 $PARSE_AND_LIST_EPILOGUE
2024 EOF
2025 fi
2026 fi
2027 else
2028 cat >>e${EMULATION_NAME}.c <<EOF
2029 #define gld${EMULATION_NAME}_add_options NULL
2030 #define gld${EMULATION_NAME}_handle_option NULL
2031 EOF
2032 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2033 cat >>e${EMULATION_NAME}.c <<EOF
2034 #define gld${EMULATION_NAME}_list_options NULL
2035 EOF
2036 fi
2037 fi
2039 cat >>e${EMULATION_NAME}.c <<EOF
2041 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2042 {
2043 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
2044 ${LDEMUL_SYSLIB-syslib_default},
2045 ${LDEMUL_HLL-hll_default},
2046 ${LDEMUL_AFTER_PARSE-after_parse_default},
2047 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
2048 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
2049 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
2050 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
2051 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
2052 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
2053 "${EMULATION_NAME}",
2054 "${OUTPUT_FORMAT}",
2055 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
2056 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
2057 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
2058 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
2059 ${LDEMUL_SET_SYMBOLS-NULL},
2060 ${LDEMUL_PARSE_ARGS-NULL},
2061 gld${EMULATION_NAME}_add_options,
2062 gld${EMULATION_NAME}_handle_option,
2063 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
2064 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
2065 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
2066 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
2067 ${LDEMUL_NEW_VERS_PATTERN-NULL}
2068 };
2069 EOF