| blob | 19259796053997913c3469cf763e81207bee484a |
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}_layout_sections_again (void);
64 static void gld${EMULATION_NAME}_finish (void) ATTRIBUTE_UNUSED;
66 EOF
68 if [ "x${USE_LIBPATH}" = xyes ] ; then
69 case ${target} in
70 *-*-linux-* | *-*-k*bsd*-*)
71 cat >>e${EMULATION_NAME}.c <<EOF
72 #ifdef HAVE_GLOB
73 #include <glob.h>
74 #endif
75 EOF
76 ;;
77 esac
78 fi
80 # Import any needed special functions and/or overrides.
81 #
82 if test -n "$EXTRA_EM_FILE" ; then
83 . ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
84 fi
86 # Functions in this file can be overridden by setting the LDEMUL_* shell
87 # variables. If the name of the overriding function is the same as is
88 # defined in this file, then don't output this file's version.
89 # If a different overriding name is given then output the standard function
90 # as presumably it is called from the overriding function.
91 #
92 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
93 cat >>e${EMULATION_NAME}.c <<EOF
95 static void
96 gld${EMULATION_NAME}_before_parse (void)
97 {
98 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
99 config.dynamic_link = ${DYNAMIC_LINK-TRUE};
100 config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
101 }
103 EOF
104 fi
106 if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
107 cat >>e${EMULATION_NAME}.c <<EOF
108 /* Handle as_needed DT_NEEDED. */
110 static bfd_boolean
111 gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
112 {
113 int class = 0;
115 /* Tell the ELF linker that we don't want the output file to have a
116 DT_NEEDED entry for this file, unless it is used to resolve
117 references in a regular object. */
118 if (entry->as_needed)
119 class = DYN_AS_NEEDED;
121 /* Tell the ELF linker that we don't want the output file to have a
122 DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
123 this file at all. */
124 if (!entry->add_needed)
125 class |= DYN_NO_ADD_NEEDED;
127 if (entry->just_syms_flag
128 && (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0)
129 einfo (_("%P%F: --just-symbols may not be used on DSO: %B\n"),
130 entry->the_bfd);
132 if (!class
133 || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
134 return FALSE;
136 bfd_elf_set_dyn_lib_class (entry->the_bfd, class);
138 /* Continue on with normal load_symbols processing. */
139 return FALSE;
140 }
141 EOF
142 fi
144 cat >>e${EMULATION_NAME}.c <<EOF
146 /* These variables are required to pass information back and forth
147 between after_open and check_needed and stat_needed and vercheck. */
149 static struct bfd_link_needed_list *global_needed;
150 static struct stat global_stat;
151 static 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 (strncmp (l->name, "libc.so", 7) == 0)
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 (!strncmp (p, "include", 7) && (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 /* We only need to worry about this when doing a final link. */
869 if (link_info.relocatable || !link_info.executable)
870 return;
872 /* Get the list of files which appear in DT_NEEDED entries in
873 dynamic objects included in the link (often there will be none).
874 For each such file, we want to track down the corresponding
875 library, and include the symbol table in the link. This is what
876 the runtime dynamic linker will do. Tracking the files down here
877 permits one dynamic object to include another without requiring
878 special action by the person doing the link. Note that the
879 needed list can actually grow while we are stepping through this
880 loop. */
881 needed = bfd_elf_get_needed_list (output_bfd, &link_info);
882 for (l = needed; l != NULL; l = l->next)
883 {
884 struct bfd_link_needed_list *ll;
885 struct dt_needed n, nn;
886 int force;
888 /* If the lib that needs this one was --as-needed and wasn't
889 found to be needed, then this lib isn't needed either. */
890 if (l->by != NULL
891 && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
892 continue;
894 /* If we've already seen this file, skip it. */
895 for (ll = needed; ll != l; ll = ll->next)
896 if ((ll->by == NULL
897 || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
898 && strcmp (ll->name, l->name) == 0)
899 break;
900 if (ll != l)
901 continue;
903 /* See if this file was included in the link explicitly. */
904 global_needed = l;
905 global_found = NULL;
906 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
907 if (global_found != NULL
908 && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
909 & DYN_AS_NEEDED) == 0)
910 continue;
912 n.by = l->by;
913 n.name = l->name;
914 nn.by = l->by;
915 if (trace_file_tries)
916 info_msg (_("%s needed by %B\n"), l->name, l->by);
918 /* As-needed libs specified on the command line (or linker script)
919 take priority over libs found in search dirs. */
920 if (global_found != NULL)
921 {
922 nn.name = global_found->filename;
923 if (gld${EMULATION_NAME}_try_needed (&nn, TRUE))
924 continue;
925 }
927 /* We need to find this file and include the symbol table. We
928 want to search for the file in the same way that the dynamic
929 linker will search. That means that we want to use
930 rpath_link, rpath, then the environment variable
931 LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
932 entries (native only), then the linker script LIB_SEARCH_DIRS.
933 We do not search using the -L arguments.
935 We search twice. The first time, we skip objects which may
936 introduce version mismatches. The second time, we force
937 their use. See gld${EMULATION_NAME}_vercheck comment. */
938 for (force = 0; force < 2; force++)
939 {
940 size_t len;
941 search_dirs_type *search;
942 EOF
943 if [ "x${NATIVE}" = xyes ] ; then
944 cat >>e${EMULATION_NAME}.c <<EOF
945 const char *lib_path;
946 EOF
947 fi
948 if [ "x${USE_LIBPATH}" = xyes ] ; then
949 cat >>e${EMULATION_NAME}.c <<EOF
950 struct bfd_link_needed_list *rp;
951 int found;
952 EOF
953 fi
954 cat >>e${EMULATION_NAME}.c <<EOF
956 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
957 &n, force))
958 break;
959 EOF
960 if [ "x${USE_LIBPATH}" = xyes ] ; then
961 cat >>e${EMULATION_NAME}.c <<EOF
962 if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
963 &n, force))
964 break;
965 EOF
966 fi
967 if [ "x${NATIVE}" = xyes ] ; then
968 cat >>e${EMULATION_NAME}.c <<EOF
969 if (command_line.rpath_link == NULL
970 && command_line.rpath == NULL)
971 {
972 lib_path = (const char *) getenv ("LD_RUN_PATH");
973 if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
974 force))
975 break;
976 }
977 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
978 if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
979 break;
980 EOF
981 fi
982 if [ "x${USE_LIBPATH}" = xyes ] ; then
983 cat >>e${EMULATION_NAME}.c <<EOF
984 found = 0;
985 rp = bfd_elf_get_runpath_list (output_bfd, &link_info);
986 for (; !found && rp != NULL; rp = rp->next)
987 {
988 char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
989 found = (rp->by == l->by
990 && gld${EMULATION_NAME}_search_needed (tmpname,
991 &n,
992 force));
993 free (tmpname);
994 }
995 if (found)
996 break;
998 EOF
999 fi
1000 if [ "x${USE_LIBPATH}" = xyes ] ; then
1001 case ${target} in
1002 *-*-freebsd* | *-*-dragonfly*)
1003 cat >>e${EMULATION_NAME}.c <<EOF
1004 if (gld${EMULATION_NAME}_check_ld_elf_hints (l->name, force))
1005 break;
1006 EOF
1007 # FreeBSD
1008 ;;
1010 *-*-linux-* | *-*-k*bsd*-*)
1011 # Linux
1012 cat >>e${EMULATION_NAME}.c <<EOF
1013 if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
1014 break;
1016 EOF
1017 ;;
1018 esac
1019 fi
1020 cat >>e${EMULATION_NAME}.c <<EOF
1021 len = strlen (l->name);
1022 for (search = search_head; search != NULL; search = search->next)
1023 {
1024 char *filename;
1026 if (search->cmdline)
1027 continue;
1028 filename = (char *) xmalloc (strlen (search->name) + len + 2);
1029 sprintf (filename, "%s/%s", search->name, l->name);
1030 nn.name = filename;
1031 if (gld${EMULATION_NAME}_try_needed (&nn, force))
1032 break;
1033 free (filename);
1034 }
1035 if (search != NULL)
1036 break;
1037 EOF
1038 cat >>e${EMULATION_NAME}.c <<EOF
1039 }
1041 if (force < 2)
1042 continue;
1044 einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
1045 l->name, l->by);
1046 }
1047 }
1049 EOF
1050 fi
1052 cat >>e${EMULATION_NAME}.c <<EOF
1054 /* Look through an expression for an assignment statement. */
1056 static void
1057 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1058 {
1059 bfd_boolean provide = FALSE;
1061 switch (exp->type.node_class)
1062 {
1063 case etree_provide:
1064 provide = TRUE;
1065 /* Fall thru */
1066 case etree_assign:
1067 /* We call record_link_assignment even if the symbol is defined.
1068 This is because if it is defined by a dynamic object, we
1069 actually want to use the value defined by the linker script,
1070 not the value from the dynamic object (because we are setting
1071 symbols like etext). If the symbol is defined by a regular
1072 object, then, as it happens, calling record_link_assignment
1073 will do no harm. */
1074 if (strcmp (exp->assign.dst, ".") != 0)
1075 {
1076 if (!bfd_elf_record_link_assignment (output_bfd, &link_info,
1077 exp->assign.dst, provide,
1078 exp->assign.hidden))
1079 einfo ("%P%F: failed to record assignment to %s: %E\n",
1080 exp->assign.dst);
1081 }
1082 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1083 break;
1085 case etree_binary:
1086 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1087 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1088 break;
1090 case etree_trinary:
1091 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1092 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1093 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1094 break;
1096 case etree_unary:
1097 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1098 break;
1100 default:
1101 break;
1102 }
1103 }
1106 /* This is called by the before_allocation routine via
1107 lang_for_each_statement. It locates any assignment statements, and
1108 tells the ELF backend about them, in case they are assignments to
1109 symbols which are referred to by dynamic objects. */
1111 static void
1112 gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1113 {
1114 if (s->header.type == lang_assignment_statement_enum)
1115 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1116 }
1118 EOF
1120 if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1121 if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1122 ELF_INTERPRETER_SET_DEFAULT="
1123 if (sinterp != NULL)
1124 {
1125 sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1126 sinterp->size = strlen ((char *) sinterp->contents) + 1;
1127 }
1129 "
1130 else
1131 ELF_INTERPRETER_SET_DEFAULT=
1132 fi
1133 cat >>e${EMULATION_NAME}.c <<EOF
1135 /* This is called after the sections have been attached to output
1136 sections, but before any sizes or addresses have been set. */
1138 static void
1139 gld${EMULATION_NAME}_before_allocation (void)
1140 {
1141 const char *rpath;
1142 asection *sinterp;
1144 if (link_info.hash->type == bfd_link_elf_hash_table)
1145 _bfd_elf_tls_setup (output_bfd, &link_info);
1147 /* If we are going to make any variable assignments, we need to let
1148 the ELF backend know about them in case the variables are
1149 referred to by dynamic objects. */
1150 lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1152 /* Let the ELF backend work out the sizes of any sections required
1153 by dynamic linking. */
1154 rpath = command_line.rpath;
1155 if (rpath == NULL)
1156 rpath = (const char *) getenv ("LD_RUN_PATH");
1157 if (! (bfd_elf_size_dynamic_sections
1158 (output_bfd, command_line.soname, rpath,
1159 command_line.filter_shlib,
1160 (const char * const *) command_line.auxiliary_filters,
1161 &link_info, &sinterp, lang_elf_version_info)))
1162 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1164 ${ELF_INTERPRETER_SET_DEFAULT}
1165 /* Let the user override the dynamic linker we are using. */
1166 if (command_line.interpreter != NULL
1167 && sinterp != NULL)
1168 {
1169 sinterp->contents = (bfd_byte *) command_line.interpreter;
1170 sinterp->size = strlen (command_line.interpreter) + 1;
1171 }
1173 /* Look for any sections named .gnu.warning. As a GNU extensions,
1174 we treat such sections as containing warning messages. We print
1175 out the warning message, and then zero out the section size so
1176 that it does not get copied into the output file. */
1178 {
1179 LANG_FOR_EACH_INPUT_STATEMENT (is)
1180 {
1181 asection *s;
1182 bfd_size_type sz;
1183 bfd_size_type prefix_len;
1184 char *msg;
1185 bfd_boolean ret;
1186 const char * gnu_warning_prefix = _("warning: ");
1188 if (is->just_syms_flag)
1189 continue;
1191 s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1192 if (s == NULL)
1193 continue;
1195 sz = s->size;
1196 prefix_len = strlen (gnu_warning_prefix);
1197 msg = xmalloc ((size_t) (prefix_len + sz + 1));
1198 strcpy (msg, gnu_warning_prefix);
1199 if (! bfd_get_section_contents (is->the_bfd, s, msg + prefix_len,
1200 (file_ptr) 0, sz))
1201 einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1202 is->the_bfd);
1203 msg[prefix_len + sz] = '\0';
1204 ret = link_info.callbacks->warning (&link_info, msg,
1205 (const char *) NULL,
1206 is->the_bfd, (asection *) NULL,
1207 (bfd_vma) 0);
1208 ASSERT (ret);
1209 free (msg);
1211 /* Clobber the section size, so that we don't waste copying the
1212 warning into the output file. */
1213 s->size = 0;
1215 /* Also set SEC_EXCLUDE, so that symbols defined in the warning
1216 section don't get copied to the output. */
1217 s->flags |= SEC_EXCLUDE;
1218 }
1219 }
1221 before_allocation_default ();
1223 if (!bfd_elf_size_dynsym_hash_dynstr (output_bfd, &link_info))
1224 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1225 }
1227 EOF
1228 fi
1230 if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1231 cat >>e${EMULATION_NAME}.c <<EOF
1233 /* Try to open a dynamic archive. This is where we know that ELF
1234 dynamic libraries have an extension of .so (or .sl on oddball systems
1235 like hpux). */
1237 static bfd_boolean
1238 gld${EMULATION_NAME}_open_dynamic_archive
1239 (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1240 {
1241 const char *filename;
1242 char *string;
1244 if (! entry->is_archive)
1245 return FALSE;
1247 filename = entry->filename;
1249 /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1250 is defined, but it does not seem worth the headache to optimize
1251 away those two bytes of space. */
1252 string = (char *) xmalloc (strlen (search->name)
1253 + strlen (filename)
1254 + strlen (arch)
1255 #ifdef EXTRA_SHLIB_EXTENSION
1256 + strlen (EXTRA_SHLIB_EXTENSION)
1257 #endif
1258 + sizeof "/lib.so");
1260 sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1262 #ifdef EXTRA_SHLIB_EXTENSION
1263 /* Try the .so extension first. If that fails build a new filename
1264 using EXTRA_SHLIB_EXTENSION. */
1265 if (! ldfile_try_open_bfd (string, entry))
1266 sprintf (string, "%s/lib%s%s%s", search->name,
1267 filename, arch, EXTRA_SHLIB_EXTENSION);
1268 #endif
1270 if (! ldfile_try_open_bfd (string, entry))
1271 {
1272 free (string);
1273 return FALSE;
1274 }
1276 entry->filename = string;
1278 /* We have found a dynamic object to include in the link. The ELF
1279 backend linker will create a DT_NEEDED entry in the .dynamic
1280 section naming this file. If this file includes a DT_SONAME
1281 entry, it will be used. Otherwise, the ELF linker will just use
1282 the name of the file. For an archive found by searching, like
1283 this one, the DT_NEEDED entry should consist of just the name of
1284 the file, without the path information used to find it. Note
1285 that we only need to do this if we have a dynamic object; an
1286 archive will never be referenced by a DT_NEEDED entry.
1288 FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1289 very pretty. I haven't been able to think of anything that is
1290 pretty, though. */
1291 if (bfd_check_format (entry->the_bfd, bfd_object)
1292 && (entry->the_bfd->flags & DYNAMIC) != 0)
1293 {
1294 ASSERT (entry->is_archive && entry->search_dirs_flag);
1296 /* Rather than duplicating the logic above. Just use the
1297 filename we recorded earlier. */
1299 filename = lbasename (entry->filename);
1300 bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1301 }
1303 return TRUE;
1304 }
1306 EOF
1307 fi
1309 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1310 cat >>e${EMULATION_NAME}.c <<EOF
1312 /* A variant of lang_output_section_find used by place_orphan. */
1314 static lang_output_section_statement_type *
1315 output_rel_find (asection *sec, int isdyn)
1316 {
1317 lang_output_section_statement_type *lookup;
1318 lang_output_section_statement_type *last = NULL;
1319 lang_output_section_statement_type *last_alloc = NULL;
1320 lang_output_section_statement_type *last_rel = NULL;
1321 lang_output_section_statement_type *last_rel_alloc = NULL;
1322 int rela = sec->name[4] == 'a';
1324 for (lookup = &lang_output_section_statement.head->output_section_statement;
1325 lookup != NULL;
1326 lookup = lookup->next)
1327 {
1328 if (lookup->constraint != -1
1329 && strncmp (".rel", lookup->name, 4) == 0)
1330 {
1331 int lookrela = lookup->name[4] == 'a';
1333 /* .rel.dyn must come before all other reloc sections, to suit
1334 GNU ld.so. */
1335 if (isdyn)
1336 break;
1338 /* Don't place after .rel.plt as doing so results in wrong
1339 dynamic tags. */
1340 if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1341 break;
1343 if (rela == lookrela || last_rel == NULL)
1344 last_rel = lookup;
1345 if ((rela == lookrela || last_rel_alloc == NULL)
1346 && lookup->bfd_section != NULL
1347 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1348 last_rel_alloc = lookup;
1349 }
1351 last = lookup;
1352 if (lookup->bfd_section != NULL
1353 && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1354 last_alloc = lookup;
1355 }
1357 if (last_rel_alloc)
1358 return last_rel_alloc;
1360 if (last_rel)
1361 return last_rel;
1363 if (last_alloc)
1364 return last_alloc;
1366 return last;
1367 }
1369 /* Place an orphan section. We use this to put random SHF_ALLOC
1370 sections in the right segment. */
1372 static bfd_boolean
1373 gld${EMULATION_NAME}_place_orphan (asection *s)
1374 {
1375 static struct orphan_save hold[] =
1376 {
1377 { ".text",
1378 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1379 0, 0, 0, 0 },
1380 { ".rodata",
1381 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1382 0, 0, 0, 0 },
1383 { ".data",
1384 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1385 0, 0, 0, 0 },
1386 { ".bss",
1387 SEC_ALLOC,
1388 0, 0, 0, 0 },
1389 { 0,
1390 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1391 0, 0, 0, 0 },
1392 { ".interp",
1393 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1394 0, 0, 0, 0 },
1395 { ".sdata",
1396 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1397 0, 0, 0, 0 }
1398 };
1399 enum orphan_save_index
1400 {
1401 orphan_text = 0,
1402 orphan_rodata,
1403 orphan_data,
1404 orphan_bss,
1405 orphan_rel,
1406 orphan_interp,
1407 orphan_sdata
1408 };
1409 static int orphan_init_done = 0;
1410 struct orphan_save *place;
1411 const char *secname;
1412 lang_output_section_statement_type *after;
1413 lang_output_section_statement_type *os;
1414 int isdyn = 0;
1415 int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1416 unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1418 secname = bfd_get_section_name (s->owner, s);
1420 if (! link_info.relocatable
1421 && link_info.combreloc
1422 && (s->flags & SEC_ALLOC))
1423 {
1424 if (iself)
1425 switch (sh_type)
1426 {
1427 case SHT_RELA:
1428 secname = ".rela.dyn";
1429 isdyn = 1;
1430 break;
1431 case SHT_REL:
1432 secname = ".rel.dyn";
1433 isdyn = 1;
1434 break;
1435 default:
1436 break;
1437 }
1438 else if (strncmp (secname, ".rel", 4) == 0)
1439 {
1440 secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1441 isdyn = 1;
1442 }
1443 }
1445 if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1446 {
1447 /* Look through the script to see where to place this section. */
1448 os = lang_output_section_find (secname);
1450 if (os != NULL
1451 && (os->bfd_section == NULL
1452 || os->bfd_section->flags == 0
1453 || (_bfd_elf_match_sections_by_type (output_bfd,
1454 os->bfd_section,
1455 s->owner, s)
1456 && ((s->flags ^ os->bfd_section->flags)
1457 & (SEC_LOAD | SEC_ALLOC)) == 0)))
1458 {
1459 /* We already have an output section statement with this
1460 name, and its bfd section, if any, has compatible flags.
1461 If the section already exists but does not have any flags
1462 set, then it has been created by the linker, probably as a
1463 result of a --section-start command line switch. */
1464 lang_add_section (&os->children, s, os);
1465 return TRUE;
1466 }
1467 }
1469 if (!orphan_init_done)
1470 {
1471 struct orphan_save *ho;
1472 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1473 if (ho->name != NULL)
1474 {
1475 ho->os = lang_output_section_find (ho->name);
1476 if (ho->os != NULL && ho->os->flags == 0)
1477 ho->os->flags = ho->flags;
1478 }
1479 orphan_init_done = 1;
1480 }
1482 /* If this is a final link, then always put .gnu.warning.SYMBOL
1483 sections into the .text section to get them out of the way. */
1484 if (link_info.executable
1485 && ! link_info.relocatable
1486 && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
1487 && hold[orphan_text].os != NULL)
1488 {
1489 lang_add_section (&hold[orphan_text].os->children, s,
1490 hold[orphan_text].os);
1491 return TRUE;
1492 }
1494 /* Decide which segment the section should go in based on the
1495 section name and section flags. We put loadable .note sections
1496 right after the .interp section, so that the PT_NOTE segment is
1497 stored right after the program headers where the OS can read it
1498 in the first page. */
1500 place = NULL;
1501 if ((s->flags & SEC_ALLOC) == 0)
1502 ;
1503 else if ((s->flags & SEC_LOAD) != 0
1504 && ((iself && sh_type == SHT_NOTE)
1505 || (!iself && strncmp (secname, ".note", 5) == 0)))
1506 place = &hold[orphan_interp];
1507 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1508 place = &hold[orphan_bss];
1509 else if ((s->flags & SEC_SMALL_DATA) != 0)
1510 place = &hold[orphan_sdata];
1511 else if ((s->flags & SEC_READONLY) == 0)
1512 place = &hold[orphan_data];
1513 else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
1514 || (!iself && strncmp (secname, ".rel", 4) == 0))
1515 && (s->flags & SEC_LOAD) != 0)
1516 place = &hold[orphan_rel];
1517 else if ((s->flags & SEC_CODE) == 0)
1518 place = &hold[orphan_rodata];
1519 else
1520 place = &hold[orphan_text];
1522 after = NULL;
1523 if (place != NULL)
1524 {
1525 if (place->os == NULL)
1526 {
1527 if (place->name != NULL)
1528 place->os = lang_output_section_find (place->name);
1529 else
1530 place->os = output_rel_find (s, isdyn);
1531 }
1532 after = place->os;
1533 if (after == NULL)
1534 after = lang_output_section_find_by_flags
1535 (s, &place->os, _bfd_elf_match_sections_by_type);
1536 if (after == NULL)
1537 /* *ABS* is always the first output section statement. */
1538 after = &lang_output_section_statement.head->output_section_statement;
1539 }
1541 /* Choose a unique name for the section. This will be needed if the
1542 same section name appears in the input file with different
1543 loadable or allocatable characteristics. */
1544 if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1545 {
1546 static int count = 1;
1547 secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1548 if (secname == NULL)
1549 einfo ("%F%P: place_orphan failed: %E\n");
1550 }
1552 lang_insert_orphan (s, secname, after, place, NULL, NULL);
1554 return TRUE;
1555 }
1556 EOF
1557 fi
1559 if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1560 cat >>e${EMULATION_NAME}.c <<EOF
1562 static void
1563 gld${EMULATION_NAME}_layout_sections_again (void)
1564 {
1565 lang_reset_memory_regions ();
1567 /* Resize the sections. */
1568 lang_size_sections (NULL, TRUE);
1570 /* Redo special stuff. */
1571 ldemul_after_allocation ();
1573 /* Do the assignments again. */
1574 lang_do_assignments ();
1575 }
1577 static void
1578 gld${EMULATION_NAME}_finish (void)
1579 {
1580 if (bfd_elf_discard_info (output_bfd, &link_info))
1581 gld${EMULATION_NAME}_layout_sections_again ();
1583 finish_default ();
1584 }
1585 EOF
1586 fi
1588 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1589 cat >>e${EMULATION_NAME}.c <<EOF
1591 static char *
1592 gld${EMULATION_NAME}_get_script (int *isfile)
1593 EOF
1595 if test -n "$COMPILE_IN"
1596 then
1597 # Scripts compiled in.
1599 # sed commands to quote an ld script as a C string.
1600 sc="-f stringify.sed"
1602 cat >>e${EMULATION_NAME}.c <<EOF
1603 {
1604 *isfile = 0;
1606 if (link_info.relocatable && config.build_constructors)
1607 return
1608 EOF
1609 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1610 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1611 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1612 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1613 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1614 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1615 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1616 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1617 fi
1618 if test -n "$GENERATE_PIE_SCRIPT" ; then
1619 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1620 echo ' ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1621 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1622 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1623 sed $sc ldscripts/${EMULATION_NAME}.xdw >> e${EMULATION_NAME}.c
1624 echo ' ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1625 sed $sc ldscripts/${EMULATION_NAME}.xdc >> e${EMULATION_NAME}.c
1626 fi
1627 echo ' ; else if (link_info.pie) return' >> e${EMULATION_NAME}.c
1628 sed $sc ldscripts/${EMULATION_NAME}.xd >> e${EMULATION_NAME}.c
1629 fi
1630 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1631 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1632 echo ' ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1633 echo ' && link_info.relro' >> e${EMULATION_NAME}.c
1634 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1635 sed $sc ldscripts/${EMULATION_NAME}.xsw >> e${EMULATION_NAME}.c
1636 echo ' ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1637 sed $sc ldscripts/${EMULATION_NAME}.xsc >> e${EMULATION_NAME}.c
1638 fi
1639 echo ' ; else if (link_info.shared) return' >> e${EMULATION_NAME}.c
1640 sed $sc ldscripts/${EMULATION_NAME}.xs >> e${EMULATION_NAME}.c
1641 fi
1642 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1643 echo ' ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1644 echo ' && (link_info.flags & DT_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1645 sed $sc ldscripts/${EMULATION_NAME}.xw >> e${EMULATION_NAME}.c
1646 echo ' ; else if (link_info.combreloc) return' >> e${EMULATION_NAME}.c
1647 sed $sc ldscripts/${EMULATION_NAME}.xc >> e${EMULATION_NAME}.c
1648 fi
1649 echo ' ; else return' >> e${EMULATION_NAME}.c
1650 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1651 echo '; }' >> e${EMULATION_NAME}.c
1653 else
1654 # Scripts read from the filesystem.
1656 cat >>e${EMULATION_NAME}.c <<EOF
1657 {
1658 *isfile = 1;
1660 if (link_info.relocatable && config.build_constructors)
1661 return "ldscripts/${EMULATION_NAME}.xu";
1662 else if (link_info.relocatable)
1663 return "ldscripts/${EMULATION_NAME}.xr";
1664 else if (!config.text_read_only)
1665 return "ldscripts/${EMULATION_NAME}.xbn";
1666 EOF
1667 if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1668 else
1669 cat >>e${EMULATION_NAME}.c <<EOF
1670 else if (!config.magic_demand_paged)
1671 return "ldscripts/${EMULATION_NAME}.xn";
1672 EOF
1673 fi
1674 if test -n "$GENERATE_PIE_SCRIPT" ; then
1675 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1676 cat >>e${EMULATION_NAME}.c <<EOF
1677 else if (link_info.pie && link_info.combreloc
1678 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1679 return "ldscripts/${EMULATION_NAME}.xdw";
1680 else if (link_info.pie && link_info.combreloc)
1681 return "ldscripts/${EMULATION_NAME}.xdc";
1682 EOF
1683 fi
1684 cat >>e${EMULATION_NAME}.c <<EOF
1685 else if (link_info.pie)
1686 return "ldscripts/${EMULATION_NAME}.xd";
1687 EOF
1688 fi
1689 if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1690 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1691 cat >>e${EMULATION_NAME}.c <<EOF
1692 else if (link_info.shared && link_info.combreloc
1693 && link_info.relro && (link_info.flags & DT_BIND_NOW))
1694 return "ldscripts/${EMULATION_NAME}.xsw";
1695 else if (link_info.shared && link_info.combreloc)
1696 return "ldscripts/${EMULATION_NAME}.xsc";
1697 EOF
1698 fi
1699 cat >>e${EMULATION_NAME}.c <<EOF
1700 else if (link_info.shared)
1701 return "ldscripts/${EMULATION_NAME}.xs";
1702 EOF
1703 fi
1704 if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1705 cat >>e${EMULATION_NAME}.c <<EOF
1706 else if (link_info.combreloc && link_info.relro
1707 && (link_info.flags & DT_BIND_NOW))
1708 return "ldscripts/${EMULATION_NAME}.xw";
1709 else if (link_info.combreloc)
1710 return "ldscripts/${EMULATION_NAME}.xc";
1711 EOF
1712 fi
1713 cat >>e${EMULATION_NAME}.c <<EOF
1714 else
1715 return "ldscripts/${EMULATION_NAME}.x";
1716 }
1718 EOF
1719 fi
1720 fi
1722 if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1724 if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1725 cat >>e${EMULATION_NAME}.c <<EOF
1726 $PARSE_AND_LIST_PROLOGUE
1727 EOF
1728 fi
1730 cat >>e${EMULATION_NAME}.c <<EOF
1732 #define OPTION_DISABLE_NEW_DTAGS (400)
1733 #define OPTION_ENABLE_NEW_DTAGS (OPTION_DISABLE_NEW_DTAGS + 1)
1734 #define OPTION_GROUP (OPTION_ENABLE_NEW_DTAGS + 1)
1735 #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1)
1736 #define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1)
1738 static void
1739 gld${EMULATION_NAME}_add_options
1740 (int ns, char **shortopts, int nl, struct option **longopts,
1741 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1742 {
1743 static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1744 static const struct option xtra_long[] = {
1745 EOF
1747 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1748 cat >>e${EMULATION_NAME}.c <<EOF
1749 {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
1750 {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
1751 {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
1752 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
1753 {"Bgroup", no_argument, NULL, OPTION_GROUP},
1754 EOF
1755 fi
1757 if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
1758 cat >>e${EMULATION_NAME}.c <<EOF
1759 $PARSE_AND_LIST_LONGOPTS
1760 EOF
1761 fi
1763 cat >>e${EMULATION_NAME}.c <<EOF
1764 {NULL, no_argument, NULL, 0}
1765 };
1767 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
1768 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
1769 *longopts = (struct option *)
1770 xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
1771 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
1772 }
1774 static bfd_boolean
1775 gld${EMULATION_NAME}_handle_option (int optc)
1776 {
1777 switch (optc)
1778 {
1779 default:
1780 return FALSE;
1782 EOF
1784 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1785 cat >>e${EMULATION_NAME}.c <<EOF
1786 case OPTION_DISABLE_NEW_DTAGS:
1787 link_info.new_dtags = FALSE;
1788 break;
1790 case OPTION_ENABLE_NEW_DTAGS:
1791 link_info.new_dtags = TRUE;
1792 break;
1794 case OPTION_EH_FRAME_HDR:
1795 link_info.eh_frame_hdr = TRUE;
1796 break;
1798 case OPTION_GROUP:
1799 link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
1800 /* Groups must be self-contained. */
1801 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1802 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
1803 break;
1805 case OPTION_EXCLUDE_LIBS:
1806 add_excluded_libs (optarg);
1807 break;
1809 case 'z':
1810 if (strcmp (optarg, "initfirst") == 0)
1811 link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
1812 else if (strcmp (optarg, "interpose") == 0)
1813 link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
1814 else if (strcmp (optarg, "loadfltr") == 0)
1815 link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
1816 else if (strcmp (optarg, "nodefaultlib") == 0)
1817 link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
1818 else if (strcmp (optarg, "nodelete") == 0)
1819 link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
1820 else if (strcmp (optarg, "nodlopen") == 0)
1821 link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
1822 else if (strcmp (optarg, "nodump") == 0)
1823 link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
1824 else if (strcmp (optarg, "now") == 0)
1825 {
1826 link_info.flags |= (bfd_vma) DF_BIND_NOW;
1827 link_info.flags_1 |= (bfd_vma) DF_1_NOW;
1828 }
1829 else if (strcmp (optarg, "origin") == 0)
1830 {
1831 link_info.flags |= (bfd_vma) DF_ORIGIN;
1832 link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
1833 }
1834 else if (strcmp (optarg, "defs") == 0)
1835 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
1836 else if (strcmp (optarg, "muldefs") == 0)
1837 link_info.allow_multiple_definition = TRUE;
1838 else if (strcmp (optarg, "combreloc") == 0)
1839 link_info.combreloc = TRUE;
1840 else if (strcmp (optarg, "nocombreloc") == 0)
1841 link_info.combreloc = FALSE;
1842 else if (strcmp (optarg, "nocopyreloc") == 0)
1843 link_info.nocopyreloc = TRUE;
1844 else if (strcmp (optarg, "execstack") == 0)
1845 {
1846 link_info.execstack = TRUE;
1847 link_info.noexecstack = FALSE;
1848 }
1849 else if (strcmp (optarg, "noexecstack") == 0)
1850 {
1851 link_info.noexecstack = TRUE;
1852 link_info.execstack = FALSE;
1853 }
1854 else if (strcmp (optarg, "relro") == 0)
1855 link_info.relro = TRUE;
1856 else if (strcmp (optarg, "norelro") == 0)
1857 link_info.relro = FALSE;
1858 /* What about the other Solaris -z options? FIXME. */
1859 break;
1860 EOF
1861 fi
1863 if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
1864 cat >>e${EMULATION_NAME}.c <<EOF
1865 $PARSE_AND_LIST_ARGS_CASES
1866 EOF
1867 fi
1869 cat >>e${EMULATION_NAME}.c <<EOF
1870 }
1872 return TRUE;
1873 }
1875 EOF
1877 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1878 cat >>e${EMULATION_NAME}.c <<EOF
1880 static void
1881 gld${EMULATION_NAME}_list_options (FILE * file)
1882 {
1883 EOF
1885 if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1886 cat >>e${EMULATION_NAME}.c <<EOF
1887 fprintf (file, _(" -Bgroup\t\tSelects group name lookup rules for DSO\n"));
1888 fprintf (file, _(" --disable-new-dtags\tDisable new dynamic tags\n"));
1889 fprintf (file, _(" --enable-new-dtags\tEnable new dynamic tags\n"));
1890 fprintf (file, _(" --eh-frame-hdr\tCreate .eh_frame_hdr section\n"));
1891 fprintf (file, _(" -z combreloc\t\tMerge dynamic relocs into one section and sort\n"));
1892 fprintf (file, _(" -z defs\t\tReport unresolved symbols in object files.\n"));
1893 fprintf (file, _(" -z execstack\t\tMark executable as requiring executable stack\n"));
1894 fprintf (file, _(" -z initfirst\t\tMark DSO to be initialized first at runtime\n"));
1895 fprintf (file, _(" -z interpose\t\tMark object to interpose all DSOs but executable\n"));
1896 fprintf (file, _(" -z loadfltr\t\tMark object requiring immediate process\n"));
1897 fprintf (file, _(" -z muldefs\t\tAllow multiple definitions\n"));
1898 fprintf (file, _(" -z nocombreloc\tDon't merge dynamic relocs into one section\n"));
1899 fprintf (file, _(" -z nocopyreloc\tDon't create copy relocs\n"));
1900 fprintf (file, _(" -z nodefaultlib\tMark object not to use default search paths\n"));
1901 fprintf (file, _(" -z nodelete\t\tMark DSO non-deletable at runtime\n"));
1902 fprintf (file, _(" -z nodlopen\t\tMark DSO not available to dlopen\n"));
1903 fprintf (file, _(" -z nodump\t\tMark DSO not available to dldump\n"));
1904 fprintf (file, _(" -z noexecstack\tMark executable as not requiring executable stack\n"));
1905 fprintf (file, _(" -z norelro\t\tDon't create RELRO program header\n"));
1906 fprintf (file, _(" -z now\t\tMark object non-lazy runtime binding\n"));
1907 fprintf (file, _(" -z origin\t\tMark object requiring immediate \$ORIGIN processing\n\t\t\t at runtime\n"));
1908 fprintf (file, _(" -z relro\t\tCreate RELRO program header\n"));
1909 fprintf (file, _(" -z KEYWORD\t\tIgnored for Solaris compatibility\n"));
1910 EOF
1911 fi
1913 if test -n "$PARSE_AND_LIST_OPTIONS" ; then
1914 cat >>e${EMULATION_NAME}.c <<EOF
1915 $PARSE_AND_LIST_OPTIONS
1916 EOF
1917 fi
1919 cat >>e${EMULATION_NAME}.c <<EOF
1920 }
1921 EOF
1923 if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
1924 cat >>e${EMULATION_NAME}.c <<EOF
1925 $PARSE_AND_LIST_EPILOGUE
1926 EOF
1927 fi
1928 fi
1929 else
1930 cat >>e${EMULATION_NAME}.c <<EOF
1931 #define gld${EMULATION_NAME}_add_options NULL
1932 #define gld${EMULATION_NAME}_handle_option NULL
1933 EOF
1934 if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
1935 cat >>e${EMULATION_NAME}.c <<EOF
1936 #define gld${EMULATION_NAME}_list_options NULL
1937 EOF
1938 fi
1939 fi
1941 cat >>e${EMULATION_NAME}.c <<EOF
1943 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1944 {
1945 ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
1946 ${LDEMUL_SYSLIB-syslib_default},
1947 ${LDEMUL_HLL-hll_default},
1948 ${LDEMUL_AFTER_PARSE-after_parse_default},
1949 ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
1950 ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
1951 ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
1952 ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
1953 ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
1954 ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
1955 "${EMULATION_NAME}",
1956 "${OUTPUT_FORMAT}",
1957 ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
1958 ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
1959 ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
1960 ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
1961 ${LDEMUL_SET_SYMBOLS-NULL},
1962 ${LDEMUL_PARSE_ARGS-NULL},
1963 gld${EMULATION_NAME}_add_options,
1964 gld${EMULATION_NAME}_handle_option,
1965 ${LDEMUL_UNRECOGNIZED_FILE-NULL},
1966 ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
1967 ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
1968 ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
1969 ${LDEMUL_NEW_VERS_PATTERN-NULL}
1970 };
1971 EOF