1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 if [ -z "$MACHINE" ]; then
6 OUTPUT_ARCH=${ARCH}:${MACHINE}
8 cat >e${EMULATION_NAME}.c <<EOF
9 /* This file is is generated by a shell script. DO NOT EDIT! */
11 /* SunOS emulation code for ${EMULATION_NAME}
12 Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003
13 Free Software Foundation, Inc.
14 Written by Steve Chamberlain <sac@cygnus.com>
15 SunOS shared library support by Ian Lance Taylor <ian@cygnus.com>
17 This file is part of GLD, the Gnu Linker.
19 This program is free software; you can redistribute it and/or modify
20 it under the terms of the GNU General Public License as published by
21 the Free Software Foundation; either version 2 of the License, or
22 (at your option) any later version.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 GNU General Public License for more details.
29 You should have received a copy of the GNU General Public License
30 along with this program; if not, write to the Free Software
31 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33 #define TARGET_IS_${EMULATION_NAME}
38 #include "libiberty.h"
39 #include "safe-ctype.h"
52 # define dirent direct
53 # ifdef HAVE_SYS_NDIR_H
54 # include <sys/ndir.h>
56 # ifdef HAVE_SYS_DIR_H
64 static void gld${EMULATION_NAME}_find_so
65 (lang_input_statement_type *);
66 static char *gld${EMULATION_NAME}_search_dir
67 (const char *, const char *, bfd_boolean *);
68 static void gld${EMULATION_NAME}_check_needed
69 (lang_input_statement_type *);
70 static bfd_boolean gld${EMULATION_NAME}_search_needed
71 (const char *, const char *);
72 static bfd_boolean gld${EMULATION_NAME}_try_needed
73 (const char *, const char *);
74 static void gld${EMULATION_NAME}_find_assignment
75 (lang_statement_union_type *);
76 static void gld${EMULATION_NAME}_find_exp_assignment
78 static void gld${EMULATION_NAME}_count_need
79 (lang_input_statement_type *);
80 static void gld${EMULATION_NAME}_set_need
81 (lang_input_statement_type *);
84 gld${EMULATION_NAME}_before_parse (void)
86 const bfd_arch_info_type *arch = bfd_scan_arch ("${OUTPUT_ARCH}");
89 ldfile_output_architecture = arch->arch;
90 ldfile_output_machine = arch->mach;
91 ldfile_output_machine_name = arch->printable_name;
94 ldfile_output_architecture = bfd_arch_${ARCH};
95 config.dynamic_link = TRUE;
96 config.has_shared = TRUE;
99 /* This is called after the command line arguments have been parsed,
100 but before the linker script has been read. If this is a native
101 linker, we add the directories in LD_LIBRARY_PATH to the search
105 gld${EMULATION_NAME}_set_symbols (void)
108 if [ "x${host}" = "x${target}" ] ; then
109 case " ${EMULATION_LIBPATH} " in
110 *" ${EMULATION_NAME} "*)
111 cat >>e${EMULATION_NAME}.c <<EOF
114 env = (const char *) getenv ("LD_LIBRARY_PATH");
128 ldfile_add_library_path (l, FALSE);
138 cat >>e${EMULATION_NAME}.c <<EOF
141 /* Despite the name, we use this routine to search for dynamic
142 libraries. On SunOS this requires a directory search. We need to
143 find the .so file with the highest version number. The user may
144 restrict the major version by saying, e.g., -lc.1. Also, if we
145 find a .so file, we need to look for a the same file after
146 replacing .so with .sa; if it exists, it will be an archive which
147 provide some initializations for data symbols, and we need to
148 search it after including the .so file. */
151 gld${EMULATION_NAME}_create_output_section_statements (void)
153 lang_for_each_input_file (gld${EMULATION_NAME}_find_so);
156 /* Search the directory for a .so file for each library search. */
159 gld${EMULATION_NAME}_find_so (lang_input_statement_type *inp)
161 search_dirs_type *search;
166 if (! inp->search_dirs_flag
171 ASSERT (strncmp (inp->local_sym_name, "-l", 2) == 0);
173 for (search = search_head; search != NULL; search = search->next)
175 bfd_boolean found_static;
177 found = gld${EMULATION_NAME}_search_dir (search->name, inp->filename,
179 if (found != NULL || found_static)
185 /* We did not find a matching .so file. This isn't an error,
186 since there might still be a matching .a file, which will be
187 found by the usual search. */
191 /* Replace the filename with the one we have found. */
192 alc = (char *) xmalloc (strlen (search->name) + strlen (found) + 2);
193 sprintf (alc, "%s/%s", search->name, found);
196 /* Turn off the search_dirs_flag to prevent ldfile_open_file from
197 searching for this file again. */
198 inp->search_dirs_flag = FALSE;
202 /* Now look for the same file name, but with .sa instead of .so. If
203 found, add it to the list of input files. */
204 alc = (char *) xmalloc (strlen (inp->filename) + 1);
205 strcpy (alc, inp->filename);
206 strstr (alc + strlen (search->name), ".so")[2] = 'a';
207 if (stat (alc, &st) != 0)
211 lang_input_statement_type *sa;
213 /* Add the .sa file to the statement list just before the .so
214 file. This is really a hack. */
215 sa = ((lang_input_statement_type *)
216 xmalloc (sizeof (lang_input_statement_type)));
220 inp->local_sym_name = alc;
222 inp->header.next = (lang_statement_union_type *) sa;
223 inp->next_real_file = (lang_statement_union_type *) sa;
227 /* Search a directory for a .so file. */
230 gld${EMULATION_NAME}_search_dir
231 (const char *dirname, const char *filename, bfd_boolean *found_static)
233 int force_maj, force_min;
238 int max_maj, max_min;
240 struct dirent *entry;
241 unsigned int dirnamelen;
246 *found_static = FALSE;
250 dot = strchr (filename, '.');
253 len = strlen (filename);
258 force_maj = atoi (dot + 1);
260 len = dot - filename;
261 alc = (char *) xmalloc (len + 1);
262 strncpy (alc, filename, len);
266 dot = strchr (dot + 1, '.');
268 force_min = atoi (dot + 1);
272 max_maj = max_min = 0;
274 dir = opendir (dirname);
277 dirnamelen = strlen (dirname);
279 while ((entry = readdir (dir)) != NULL)
282 int found_maj, found_min;
284 if (strncmp (entry->d_name, "lib", 3) != 0
285 || strncmp (entry->d_name + 3, filename, len) != 0)
289 && strcmp (entry->d_name + 3 + len, ".a") == 0)
291 *found_static = TRUE;
295 /* We accept libfoo.so without a version number, even though the
296 native linker does not. This is more convenient for packages
297 which just generate .so files for shared libraries, as on ELF
299 if (strncmp (entry->d_name + 3 + len, ".so", 3) != 0)
301 if (entry->d_name[6 + len] == '\0')
303 else if (entry->d_name[6 + len] == '.'
304 && ISDIGIT (entry->d_name[7 + len]))
309 for (s = entry->d_name + 6 + len; *s != '\0'; s++)
310 if (*s != '.' && ! ISDIGIT (*s))
315 /* We've found a .so file. Work out the major and minor
319 sscanf (entry->d_name + 3 + len, ".so.%d.%d",
320 &found_maj, &found_min);
322 if ((force_maj != -1 && force_maj != found_maj)
323 || (force_min != -1 && force_min != found_min))
326 /* Make sure the file really exists (ignore broken symlinks). */
327 full_path = xmalloc (dirnamelen + 1 + strlen (entry->d_name) + 1);
328 sprintf (full_path, "%s/%s", dirname, entry->d_name);
329 statval = stat (full_path, &st);
334 /* We've found a match for the name we are searching for. See
335 if this is the version we should use. If the major and minor
336 versions match, we use the last entry in alphabetical order;
337 I don't know if this is how SunOS distinguishes libc.so.1.8
338 from libc.so.1.8.1, but it ought to suffice. */
340 || (found_maj > max_maj)
341 || (found_maj == max_maj
342 && (found_min > max_min
343 || (found_min == max_min
344 && strcmp (entry->d_name, found) > 0))))
348 found = (char *) xmalloc (strlen (entry->d_name) + 1);
349 strcpy (found, entry->d_name);
363 /* These variables are required to pass information back and forth
364 between after_open and check_needed. */
366 static struct bfd_link_needed_list *global_needed;
367 static bfd_boolean global_found;
369 /* This is called after all the input files have been opened. */
372 gld${EMULATION_NAME}_after_open (void)
374 struct bfd_link_needed_list *needed, *l;
376 /* We only need to worry about this when doing a final link. */
377 if (link_info.relocatable || link_info.shared)
380 /* Get the list of files which appear in ld_need entries in dynamic
381 objects included in the link. For each such file, we want to
382 track down the corresponding library, and include the symbol
383 table in the link. This is what the runtime dynamic linker will
384 do. Tracking the files down here permits one dynamic object to
385 include another without requiring special action by the person
386 doing the link. Note that the needed list can actually grow
387 while we are stepping through this loop. */
388 needed = bfd_sunos_get_needed_list (output_bfd, &link_info);
389 for (l = needed; l != NULL; l = l->next)
391 struct bfd_link_needed_list *ll;
393 search_dirs_type *search;
397 /* If we've already seen this file, skip it. */
398 for (ll = needed; ll != l; ll = ll->next)
399 if (strcmp (ll->name, lname) == 0)
404 /* See if this file was included in the link explicitly. */
406 global_found = FALSE;
407 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
411 if (strncmp (lname, "-l", 2) != 0)
415 abfd = bfd_openr (lname, bfd_get_target (output_bfd));
418 if (! bfd_check_format (abfd, bfd_object))
420 (void) bfd_close (abfd);
426 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
428 (void) bfd_close (abfd);
434 /* We've found the needed dynamic object. */
435 if (! bfd_link_add_symbols (abfd, &link_info))
436 einfo ("%F%B: could not read symbols: %E\n", abfd);
440 einfo ("%P: warning: %s, needed by %B, not found\n",
449 /* We want to search for the file in the same way that the
450 dynamic linker will search. That means that we want to use
451 rpath_link, rpath or -L, then the environment variable
452 LD_LIBRARY_PATH (native only), then (if rpath was used) the
453 linker script LIB_SEARCH_DIRS. */
454 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
457 if (command_line.rpath != NULL)
459 if (gld${EMULATION_NAME}_search_needed (command_line.rpath, lname))
464 for (search = search_head; search != NULL; search = search->next)
465 if (gld${EMULATION_NAME}_try_needed (search->name, lname))
471 if [ "x${host}" = "x${target}" ] ; then
472 case " ${EMULATION_LIBPATH} " in
473 *" ${EMULATION_NAME} "*)
474 cat >>e${EMULATION_NAME}.c <<EOF
476 const char *lib_path;
478 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
479 if (gld${EMULATION_NAME}_search_needed (lib_path, lname))
486 cat >>e${EMULATION_NAME}.c <<EOF
487 if (command_line.rpath != NULL)
489 for (search = search_head; search != NULL; search = search->next)
493 if (gld${EMULATION_NAME}_try_needed (search->name, lname))
500 einfo ("%P: warning: %s, needed by %B, not found\n",
505 /* Search for a needed file in a path. */
508 gld${EMULATION_NAME}_search_needed (const char *path, const char *name)
512 if (path == NULL || *path == '\0')
519 s = strchr (path, ':');
527 dircopy = (char *) xmalloc (s - path + 1);
528 memcpy (dircopy, path, s - path);
529 dircopy[s - path] = '\0';
533 if (gld${EMULATION_NAME}_try_needed (dir, name))
547 /* This function is called for each possible directory for a needed
551 gld${EMULATION_NAME}_try_needed (const char *dir, const char *name)
558 file = gld${EMULATION_NAME}_search_dir (dir, name, &ignore);
562 alc = (char *) xmalloc (strlen (dir) + strlen (file) + 2);
563 sprintf (alc, "%s/%s", dir, file);
565 abfd = bfd_openr (alc, bfd_get_target (output_bfd));
568 if (! bfd_check_format (abfd, bfd_object))
570 (void) bfd_close (abfd);
573 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
575 (void) bfd_close (abfd);
579 /* We've found the needed dynamic object. */
581 /* Add this file into the symbol table. */
582 if (! bfd_link_add_symbols (abfd, &link_info))
583 einfo ("%F%B: could not read symbols: %E\n", abfd);
588 /* See if we have already included a needed object in the link. This
589 does not have to be precise, as it does no harm to include a
590 dynamic object more than once. */
593 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
595 if (s->filename == NULL)
597 if (strncmp (global_needed->name, "-l", 2) != 0)
599 if (strcmp (s->filename, global_needed->name) == 0)
604 const char *sname, *lname;
605 const char *sdot, *ldot;
606 int lmaj, lmin, smaj, smin;
608 lname = global_needed->name + 2;
610 sname = strrchr (s->filename, '/');
616 if (strncmp (sname, "lib", 3) != 0)
620 ldot = strchr (lname, '.');
622 ldot = lname + strlen (lname);
624 sdot = strstr (sname, ".so.");
628 if (sdot - sname != ldot - lname
629 || strncmp (lname, sname, sdot - sname) != 0)
633 sscanf (ldot, ".%d.%d", &lmaj, &lmin);
635 sscanf (sdot, ".so.%d.%d", &smaj, &smin);
636 if ((smaj != lmaj && smaj != -1 && lmaj != -1)
637 || (smin != lmin && smin != -1 && lmin != -1))
644 /* We need to use static variables to pass information around the call
645 to lang_for_each_statement. Ick. */
647 static const char *find_assign;
648 static bfd_boolean found_assign;
650 /* We need to use static variables to pass information around the call
651 to lang_for_each_input_file. Ick. */
653 static bfd_size_type need_size;
654 static bfd_size_type need_entries;
655 static bfd_byte *need_contents;
656 static bfd_byte *need_pinfo;
657 static bfd_byte *need_pnames;
659 /* The size of one entry in the .need section, not including the file
662 #define NEED_ENTRY_SIZE (16)
664 /* This is called after the sections have been attached to output
665 sections, but before any sizes or addresses have been set. */
668 gld${EMULATION_NAME}_before_allocation (void)
670 struct bfd_link_hash_entry *hdyn = NULL;
675 /* The SunOS native linker creates a shared library whenever there
676 are any undefined symbols in a link, unless -e is used. This is
677 pretty weird, but we are compatible. */
678 if (! link_info.shared && ! link_info.relocatable && ! entry_from_cmdline)
680 struct bfd_link_hash_entry *h;
682 for (h = link_info.hash->undefs; h != NULL; h = h->next)
684 if (h->type == bfd_link_hash_undefined
685 && h->u.undef.abfd != NULL
686 && (h->u.undef.abfd->flags & DYNAMIC) == 0
687 && strcmp (h->root.string, "__DYNAMIC") != 0
688 && strcmp (h->root.string, "__GLOBAL_OFFSET_TABLE_") != 0)
690 find_assign = h->root.string;
691 found_assign = FALSE;
692 lang_for_each_statement (gld${EMULATION_NAME}_find_assignment);
695 link_info.shared = TRUE;
702 if (link_info.shared)
704 lang_output_section_statement_type *os;
706 /* Set the .text section to start at 0x20, not 0x2020. FIXME:
707 This is too magical. */
708 os = lang_output_section_statement_lookup (".text");
709 if (os->addr_tree == NULL)
710 os->addr_tree = exp_intop (0x20);
713 /* We need to create a __DYNAMIC symbol. We don't do this in the
714 linker script because we want to set the value to the start of
715 the dynamic section if there is one, or to zero if there isn't
716 one. We need to create the symbol before calling
717 size_dynamic_sections, although we can't set the value until
719 if (! link_info.relocatable)
721 hdyn = bfd_link_hash_lookup (link_info.hash, "__DYNAMIC", TRUE, FALSE,
724 einfo ("%P%F: bfd_link_hash_lookup: %E\n");
725 if (! bfd_sunos_record_link_assignment (output_bfd, &link_info,
727 einfo ("%P%F: failed to record assignment to __DYNAMIC: %E\n");
730 /* If we are going to make any variable assignments, we need to let
731 the backend linker know about them in case the variables are
732 referred to by dynamic objects. */
733 lang_for_each_statement (gld${EMULATION_NAME}_find_assignment);
735 /* Let the backend linker work out the sizes of any sections
736 required by dynamic linking. */
737 if (! bfd_sunos_size_dynamic_sections (output_bfd, &link_info, &sdyn,
739 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
743 /* Set up the .need section. See the description of the ld_need
744 field in include/aout/sun4.h. */
749 lang_for_each_input_file (gld${EMULATION_NAME}_count_need);
751 /* We should only have a .need section if we have at least one
753 ASSERT (need_entries != 0);
755 sneed->_raw_size = need_size;
756 sneed->contents = (bfd_byte *) xmalloc (need_size);
758 need_contents = sneed->contents;
759 need_pinfo = sneed->contents;
760 need_pnames = sneed->contents + need_entries * 16;
762 lang_for_each_input_file (gld${EMULATION_NAME}_set_need);
764 ASSERT ((bfd_size_type) (need_pnames - sneed->contents) == need_size);
769 /* Set up the .rules section. This is just a PATH like string
770 of the -L arguments given on the command line. We permit the
771 user to specify the directories using the -rpath command line
773 if (command_line.rpath)
775 srules->_raw_size = strlen (command_line.rpath);
776 srules->contents = (bfd_byte *) command_line.rpath;
781 search_dirs_type *search;
784 for (search = search_head; search != NULL; search = search->next)
786 size += strlen (search->name) + 1;
787 srules->_raw_size = size;
792 srules->contents = (bfd_byte *) xmalloc (size);
793 p = (char *) srules->contents;
795 for (search = search_head; search != NULL; search = search->next)
799 if (p != (char *) srules->contents)
801 strcpy (p, search->name);
809 /* We must assign a value to __DYNAMIC. It should be zero if we are
810 not doing a dynamic link, or the start of the .dynamic section if
812 if (! link_info.relocatable)
814 hdyn->type = bfd_link_hash_defined;
815 hdyn->u.def.value = 0;
817 hdyn->u.def.section = sdyn;
819 hdyn->u.def.section = bfd_abs_section_ptr;
823 /* This is called by the before_allocation routine via
824 lang_for_each_statement. It does one of two things: if the
825 variable find_assign is set, it sets found_assign if it finds an
826 assignment to that variable; otherwise it tells the backend linker
827 about all assignment statements, in case they are assignments to
828 symbols which are referred to by dynamic objects. */
831 gld${EMULATION_NAME}_find_assignment (lang_statement_union_type *s)
833 if (s->header.type == lang_assignment_statement_enum
834 && (find_assign == NULL || ! found_assign))
835 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
838 /* Look through an expression for an assignment statement. */
841 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
843 switch (exp->type.node_class)
846 if (find_assign != NULL)
848 if (strcmp (find_assign, exp->assign.dst) == 0)
853 if (strcmp (exp->assign.dst, ".") != 0)
855 if (! bfd_sunos_record_link_assignment (output_bfd, &link_info,
857 einfo ("%P%F: failed to record assignment to %s: %E\n",
860 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
864 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
865 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
869 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
870 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
871 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
875 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
883 /* Work out the size of the .need section, and the number of entries.
884 The backend will set the ld_need field of the dynamic linking
885 information to point to the .need section. See include/aout/sun4.h
886 for more information. */
889 gld${EMULATION_NAME}_count_need (lang_input_statement_type *inp)
891 if (inp->the_bfd != NULL
892 && (inp->the_bfd->flags & DYNAMIC) != 0)
895 need_size += NEED_ENTRY_SIZE;
896 if (! inp->is_archive)
897 need_size += strlen (inp->filename) + 1;
900 ASSERT (inp->local_sym_name[0] == '-'
901 && inp->local_sym_name[1] == 'l');
902 need_size += strlen (inp->local_sym_name + 2) + 1;
907 /* Fill in the contents of the .need section. */
910 gld${EMULATION_NAME}_set_need (lang_input_statement_type *inp)
912 if (inp->the_bfd != NULL
913 && (inp->the_bfd->flags & DYNAMIC) != 0)
917 /* To really fill in the .need section contents, we need to know
918 the final file position of the section, but we don't.
919 Instead, we use offsets, and rely on the BFD backend to
920 finish the section up correctly. FIXME: Talk about lack of
921 referential locality. */
922 bfd_put_32 (output_bfd, need_pnames - need_contents, need_pinfo);
923 if (! inp->is_archive)
925 bfd_put_32 (output_bfd, (bfd_vma) 0, need_pinfo + 4);
926 bfd_put_16 (output_bfd, (bfd_vma) 0, need_pinfo + 8);
927 bfd_put_16 (output_bfd, (bfd_vma) 0, need_pinfo + 10);
928 strcpy (need_pnames, inp->filename);
935 bfd_put_32 (output_bfd, (bfd_vma) 0x80000000, need_pinfo + 4);
938 verstr = strstr (inp->filename, ".so.");
940 sscanf (verstr, ".so.%d.%d", &maj, &min);
941 bfd_put_16 (output_bfd, (bfd_vma) maj, need_pinfo + 8);
942 bfd_put_16 (output_bfd, (bfd_vma) min, need_pinfo + 10);
943 strcpy (need_pnames, inp->local_sym_name + 2);
946 c = (need_pinfo - need_contents) / NEED_ENTRY_SIZE;
947 if (c + 1 >= need_entries)
948 bfd_put_32 (output_bfd, (bfd_vma) 0, need_pinfo + 12);
950 bfd_put_32 (output_bfd, (bfd_vma) (c + 1) * NEED_ENTRY_SIZE,
953 need_pinfo += NEED_ENTRY_SIZE;
954 need_pnames += strlen (need_pnames) + 1;
959 gld${EMULATION_NAME}_get_script (int *isfile)
962 if test -n "$COMPILE_IN"
964 # Scripts compiled in.
966 # sed commands to quote an ld script as a C string.
967 sc="-f stringify.sed"
969 cat >>e${EMULATION_NAME}.c <<EOF
973 if (link_info.relocatable && config.build_constructors)
976 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
977 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
978 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
979 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
980 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
981 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
982 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
983 echo ' ; else return' >> e${EMULATION_NAME}.c
984 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
985 echo '; }' >> e${EMULATION_NAME}.c
988 # Scripts read from the filesystem.
990 cat >>e${EMULATION_NAME}.c <<EOF
994 if (link_info.relocatable && config.build_constructors)
995 return "ldscripts/${EMULATION_NAME}.xu";
996 else if (link_info.relocatable)
997 return "ldscripts/${EMULATION_NAME}.xr";
998 else if (!config.text_read_only)
999 return "ldscripts/${EMULATION_NAME}.xbn";
1000 else if (!config.magic_demand_paged)
1001 return "ldscripts/${EMULATION_NAME}.xn";
1003 return "ldscripts/${EMULATION_NAME}.x";
1009 cat >>e${EMULATION_NAME}.c <<EOF
1011 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1013 gld${EMULATION_NAME}_before_parse,
1016 after_parse_default,
1017 gld${EMULATION_NAME}_after_open,
1018 after_allocation_default,
1019 set_output_arch_default,
1020 ldemul_default_target,
1021 gld${EMULATION_NAME}_before_allocation,
1022 gld${EMULATION_NAME}_get_script,
1023 "${EMULATION_NAME}",
1026 gld${EMULATION_NAME}_create_output_section_statements,
1027 NULL, /* open dynamic archive */
1028 NULL, /* place orphan */
1029 gld${EMULATION_NAME}_set_symbols,
1030 NULL, /* parse args */
1031 NULL, /* add_options */
1032 NULL, /* handle_option */
1033 NULL, /* unrecognized file */
1034 NULL, /* list options */
1035 NULL, /* recognized file */
1036 NULL, /* find_potential_libraries */
1037 NULL /* new_vers_pattern */