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