1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 if [ -z "$MACHINE" ]; then
6 OUTPUT_ARCH=${ARCH}:${MACHINE}
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, 2001,
13 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2012
14 Free Software Foundation, Inc.
15 Written by Steve Chamberlain <sac@cygnus.com>
16 SunOS shared library support by Ian Lance Taylor <ian@cygnus.com>
18 This file is part of the GNU Binutils.
20 This program is free software; you can redistribute it and/or modify
21 it under the terms of the GNU General Public License as published by
22 the Free Software Foundation; either version 3 of the License, or
23 (at your option) any later version.
25 This program is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
30 You should have received a copy of the GNU General Public License
31 along with this program; if not, write to the Free Software
32 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
33 MA 02110-1301, USA. */
35 #define TARGET_IS_${EMULATION_NAME}
40 #include "libiberty.h"
41 #include "safe-ctype.h"
54 # define dirent direct
55 # ifdef HAVE_SYS_NDIR_H
56 # include <sys/ndir.h>
58 # ifdef HAVE_SYS_DIR_H
66 static void gld${EMULATION_NAME}_find_so
67 (lang_input_statement_type *);
68 static char *gld${EMULATION_NAME}_search_dir
69 (const char *, const char *, bfd_boolean *);
70 static void gld${EMULATION_NAME}_check_needed
71 (lang_input_statement_type *);
72 static bfd_boolean gld${EMULATION_NAME}_search_needed
73 (const char *, const char *);
74 static bfd_boolean gld${EMULATION_NAME}_try_needed
75 (const char *, const char *);
76 static void gld${EMULATION_NAME}_find_assignment
77 (lang_statement_union_type *);
78 static void gld${EMULATION_NAME}_find_exp_assignment
80 static void gld${EMULATION_NAME}_count_need
81 (lang_input_statement_type *);
82 static void gld${EMULATION_NAME}_set_need
83 (lang_input_statement_type *);
86 gld${EMULATION_NAME}_before_parse (void)
88 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
89 input_flags.dynamic = TRUE;
90 config.has_shared = TRUE;
93 /* This is called after the command line arguments have been parsed,
94 but before the linker script has been read. If this is a native
95 linker, we add the directories in LD_LIBRARY_PATH to the search
99 gld${EMULATION_NAME}_set_symbols (void)
102 if [ "x${host}" = "x${target}" ] ; then
103 case " ${EMULATION_LIBPATH} " in
104 *" ${EMULATION_NAME} "*)
108 env = (const char *) getenv ("LD_LIBRARY_PATH");
122 ldfile_add_library_path (l, FALSE);
135 /* Despite the name, we use this routine to search for dynamic
136 libraries. On SunOS this requires a directory search. We need to
137 find the .so file with the highest version number. The user may
138 restrict the major version by saying, e.g., -lc.1. Also, if we
139 find a .so file, we need to look for a the same file after
140 replacing .so with .sa; if it exists, it will be an archive which
141 provide some initializations for data symbols, and we need to
142 search it after including the .so file. */
145 gld${EMULATION_NAME}_create_output_section_statements (void)
147 lang_for_each_input_file (gld${EMULATION_NAME}_find_so);
150 /* Search the directory for a .so file for each library search. */
153 gld${EMULATION_NAME}_find_so (lang_input_statement_type *inp)
155 search_dirs_type *search;
160 if (! inp->flags.search_dirs
161 || ! inp->flags.maybe_archive
162 || ! inp->flags.dynamic)
165 ASSERT (CONST_STRNEQ (inp->local_sym_name, "-l"));
167 for (search = search_head; search != NULL; search = search->next)
169 bfd_boolean found_static;
171 found = gld${EMULATION_NAME}_search_dir (search->name, inp->filename,
173 if (found != NULL || found_static)
179 /* We did not find a matching .so file. This isn't an error,
180 since there might still be a matching .a file, which will be
181 found by the usual search. */
185 /* Replace the filename with the one we have found. */
186 alc = (char *) xmalloc (strlen (search->name) + strlen (found) + 2);
187 sprintf (alc, "%s/%s", search->name, found);
190 /* Turn off the search_dirs_flag to prevent ldfile_open_file from
191 searching for this file again. */
192 inp->flags.search_dirs = FALSE;
196 /* Now look for the same file name, but with .sa instead of .so. If
197 found, add it to the list of input files. */
198 alc = (char *) xmalloc (strlen (inp->filename) + 1);
199 strcpy (alc, inp->filename);
200 strstr (alc + strlen (search->name), ".so")[2] = 'a';
201 if (stat (alc, &st) != 0)
205 lang_input_statement_type *sa;
207 /* Add the .sa file to the statement list just before the .so
208 file. This is really a hack. */
209 sa = ((lang_input_statement_type *)
210 xmalloc (sizeof (lang_input_statement_type)));
214 inp->local_sym_name = alc;
216 inp->header.next = (lang_statement_union_type *) sa;
217 inp->next_real_file = (lang_statement_union_type *) sa;
221 /* Search a directory for a .so file. */
224 gld${EMULATION_NAME}_search_dir
225 (const char *dirname, const char *filename, bfd_boolean *found_static)
227 int force_maj, force_min;
232 int max_maj, max_min;
234 struct dirent *entry;
235 unsigned int dirnamelen;
240 *found_static = FALSE;
244 dot = strchr (filename, '.');
247 len = strlen (filename);
252 force_maj = atoi (dot + 1);
254 len = dot - filename;
255 alc = (char *) xmalloc (len + 1);
256 strncpy (alc, filename, len);
260 dot = strchr (dot + 1, '.');
262 force_min = atoi (dot + 1);
266 max_maj = max_min = 0;
268 dir = opendir (dirname);
271 dirnamelen = strlen (dirname);
273 while ((entry = readdir (dir)) != NULL)
276 int found_maj, found_min;
278 if (! CONST_STRNEQ (entry->d_name, "lib")
279 || strncmp (entry->d_name + 3, filename, len) != 0)
283 && strcmp (entry->d_name + 3 + len, ".a") == 0)
285 *found_static = TRUE;
289 /* We accept libfoo.so without a version number, even though the
290 native linker does not. This is more convenient for packages
291 which just generate .so files for shared libraries, as on ELF
293 if (! CONST_STRNEQ (entry->d_name + 3 + len, ".so"))
295 if (entry->d_name[6 + len] == '\0')
297 else if (entry->d_name[6 + len] == '.'
298 && ISDIGIT (entry->d_name[7 + len]))
303 for (s = entry->d_name + 6 + len; *s != '\0'; s++)
304 if (*s != '.' && ! ISDIGIT (*s))
309 /* We've found a .so file. Work out the major and minor
313 sscanf (entry->d_name + 3 + len, ".so.%d.%d",
314 &found_maj, &found_min);
316 if ((force_maj != -1 && force_maj != found_maj)
317 || (force_min != -1 && force_min != found_min))
320 /* Make sure the file really exists (ignore broken symlinks). */
321 full_path = xmalloc (dirnamelen + 1 + strlen (entry->d_name) + 1);
322 sprintf (full_path, "%s/%s", dirname, entry->d_name);
323 statval = stat (full_path, &st);
328 /* We've found a match for the name we are searching for. See
329 if this is the version we should use. If the major and minor
330 versions match, we use the last entry in alphabetical order;
331 I don't know if this is how SunOS distinguishes libc.so.1.8
332 from libc.so.1.8.1, but it ought to suffice. */
334 || (found_maj > max_maj)
335 || (found_maj == max_maj
336 && (found_min > max_min
337 || (found_min == max_min
338 && strcmp (entry->d_name, found) > 0))))
342 found = (char *) xmalloc (strlen (entry->d_name) + 1);
343 strcpy (found, entry->d_name);
357 /* These variables are required to pass information back and forth
358 between after_open and check_needed. */
360 static struct bfd_link_needed_list *global_needed;
361 static bfd_boolean global_found;
363 /* This is called after all the input files have been opened. */
366 gld${EMULATION_NAME}_after_open (void)
368 struct bfd_link_needed_list *needed, *l;
370 after_open_default ();
372 /* We only need to worry about this when doing a final link. */
373 if (link_info.relocatable || link_info.shared)
376 /* Get the list of files which appear in ld_need entries in dynamic
377 objects included in the link. For each such file, we want to
378 track down the corresponding library, and include the symbol
379 table in the link. This is what the runtime dynamic linker will
380 do. Tracking the files down here permits one dynamic object to
381 include another without requiring special action by the person
382 doing the link. Note that the needed list can actually grow
383 while we are stepping through this loop. */
384 needed = bfd_sunos_get_needed_list (link_info.output_bfd, &link_info);
385 for (l = needed; l != NULL; l = l->next)
387 struct bfd_link_needed_list *ll;
389 search_dirs_type *search;
393 /* If we've already seen this file, skip it. */
394 for (ll = needed; ll != l; ll = ll->next)
395 if (strcmp (ll->name, lname) == 0)
400 /* See if this file was included in the link explicitly. */
402 global_found = FALSE;
403 lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
407 if (! CONST_STRNEQ (lname, "-l"))
411 abfd = bfd_openr (lname, bfd_get_target (link_info.output_bfd));
414 if (! bfd_check_format (abfd, bfd_object))
416 (void) bfd_close (abfd);
422 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
424 (void) bfd_close (abfd);
430 /* We've found the needed dynamic object. */
431 if (! bfd_link_add_symbols (abfd, &link_info))
432 einfo ("%F%B: error adding symbols: %E\n", abfd);
436 einfo ("%P: warning: %s, needed by %B, not found\n",
445 /* We want to search for the file in the same way that the
446 dynamic linker will search. That means that we want to use
447 rpath_link, rpath or -L, then the environment variable
448 LD_LIBRARY_PATH (native only), then (if rpath was used) the
449 linker script LIB_SEARCH_DIRS. */
450 if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
453 if (command_line.rpath != NULL)
455 if (gld${EMULATION_NAME}_search_needed (command_line.rpath, lname))
460 for (search = search_head; search != NULL; search = search->next)
461 if (gld${EMULATION_NAME}_try_needed (search->name, lname))
467 if [ "x${host}" = "x${target}" ] ; then
468 case " ${EMULATION_LIBPATH} " in
469 *" ${EMULATION_NAME} "*)
472 const char *lib_path;
474 lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
475 if (gld${EMULATION_NAME}_search_needed (lib_path, lname))
483 if (command_line.rpath != NULL)
485 for (search = search_head; search != NULL; search = search->next)
489 if (gld${EMULATION_NAME}_try_needed (search->name, lname))
496 einfo ("%P: warning: %s, needed by %B, not found\n",
501 /* Search for a needed file in a path. */
504 gld${EMULATION_NAME}_search_needed (const char *path, const char *name)
508 if (path == NULL || *path == '\0')
515 s = strchr (path, ':');
523 dircopy = (char *) xmalloc (s - path + 1);
524 memcpy (dircopy, path, s - path);
525 dircopy[s - path] = '\0';
529 if (gld${EMULATION_NAME}_try_needed (dir, name))
543 /* This function is called for each possible directory for a needed
547 gld${EMULATION_NAME}_try_needed (const char *dir, const char *name)
554 file = gld${EMULATION_NAME}_search_dir (dir, name, &ignore);
558 alc = (char *) xmalloc (strlen (dir) + strlen (file) + 2);
559 sprintf (alc, "%s/%s", dir, file);
561 abfd = bfd_openr (alc, bfd_get_target (link_info.output_bfd));
564 if (! bfd_check_format (abfd, bfd_object))
566 (void) bfd_close (abfd);
569 if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
571 (void) bfd_close (abfd);
575 /* We've found the needed dynamic object. */
577 /* Add this file into the symbol table. */
578 if (! bfd_link_add_symbols (abfd, &link_info))
579 einfo ("%F%B: error adding symbols: %E\n", abfd);
584 /* See if we have already included a needed object in the link. This
585 does not have to be precise, as it does no harm to include a
586 dynamic object more than once. */
589 gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
591 if (s->filename == NULL)
593 if (! CONST_STRNEQ (global_needed->name, "-l"))
595 if (strcmp (s->filename, global_needed->name) == 0)
600 const char *sname, *lname;
601 const char *sdot, *ldot;
602 int lmaj, lmin, smaj, smin;
604 lname = global_needed->name + 2;
606 sname = strrchr (s->filename, '/');
612 if (! CONST_STRNEQ (sname, "lib"))
616 ldot = strchr (lname, '.');
618 ldot = lname + strlen (lname);
620 sdot = strstr (sname, ".so.");
624 if (sdot - sname != ldot - lname
625 || strncmp (lname, sname, sdot - sname) != 0)
629 sscanf (ldot, ".%d.%d", &lmaj, &lmin);
631 sscanf (sdot, ".so.%d.%d", &smaj, &smin);
632 if ((smaj != lmaj && smaj != -1 && lmaj != -1)
633 || (smin != lmin && smin != -1 && lmin != -1))
640 /* We need to use static variables to pass information around the call
641 to lang_for_each_statement. Ick. */
643 static const char *find_assign;
644 static bfd_boolean found_assign;
646 /* We need to use static variables to pass information around the call
647 to lang_for_each_input_file. Ick. */
649 static bfd_size_type need_size;
650 static bfd_size_type need_entries;
651 static bfd_byte *need_contents;
652 static bfd_byte *need_pinfo;
653 static bfd_byte *need_pnames;
655 /* The size of one entry in the .need section, not including the file
658 #define NEED_ENTRY_SIZE (16)
660 /* This is called after the sections have been attached to output
661 sections, but before any sizes or addresses have been set. */
664 gld${EMULATION_NAME}_before_allocation (void)
666 struct bfd_link_hash_entry *hdyn = NULL;
671 /* The SunOS native linker creates a shared library whenever there
672 are any undefined symbols in a link, unless -e is used. This is
673 pretty weird, but we are compatible. */
674 if (! link_info.shared && ! link_info.relocatable && ! entry_from_cmdline)
676 struct bfd_link_hash_entry *h;
678 for (h = link_info.hash->undefs; h != NULL; h = h->u.undef.next)
680 if (h->type == bfd_link_hash_undefined
681 && h->u.undef.abfd != NULL
682 && (h->u.undef.abfd->flags & DYNAMIC) == 0
683 && strcmp (h->root.string, "__DYNAMIC") != 0
684 && strcmp (h->root.string, "__GLOBAL_OFFSET_TABLE_") != 0)
686 find_assign = h->root.string;
687 found_assign = FALSE;
688 lang_for_each_statement (gld${EMULATION_NAME}_find_assignment);
691 link_info.shared = TRUE;
698 if (link_info.shared)
700 lang_output_section_statement_type *os;
702 /* Set the .text section to start at 0x20, not 0x2020. FIXME:
703 This is too magical. */
704 os = lang_output_section_statement_lookup (".text", 0, TRUE);
705 if (os->addr_tree == NULL)
706 os->addr_tree = exp_intop (0x20);
709 /* We need to create a __DYNAMIC symbol. We don't do this in the
710 linker script because we want to set the value to the start of
711 the dynamic section if there is one, or to zero if there isn't
712 one. We need to create the symbol before calling
713 size_dynamic_sections, although we can't set the value until
715 if (! link_info.relocatable)
717 hdyn = bfd_link_hash_lookup (link_info.hash, "__DYNAMIC", TRUE, FALSE,
720 einfo ("%P%F: bfd_link_hash_lookup: %E\n");
721 if (! bfd_sunos_record_link_assignment (link_info.output_bfd, &link_info,
723 einfo ("%P%F: failed to record assignment to __DYNAMIC: %E\n");
726 /* If we are going to make any variable assignments, we need to let
727 the backend linker know about them in case the variables are
728 referred to by dynamic objects. */
729 lang_for_each_statement (gld${EMULATION_NAME}_find_assignment);
731 /* Let the backend linker work out the sizes of any sections
732 required by dynamic linking. */
733 if (! bfd_sunos_size_dynamic_sections (link_info.output_bfd, &link_info,
734 &sdyn, &sneed, &srules))
735 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
739 /* Set up the .need section. See the description of the ld_need
740 field in include/aout/sun4.h. */
745 lang_for_each_input_file (gld${EMULATION_NAME}_count_need);
747 /* We should only have a .need section if we have at least one
749 ASSERT (need_entries != 0);
751 sneed->size = need_size;
752 sneed->contents = (bfd_byte *) xmalloc (need_size);
754 need_contents = sneed->contents;
755 need_pinfo = sneed->contents;
756 need_pnames = sneed->contents + need_entries * 16;
758 lang_for_each_input_file (gld${EMULATION_NAME}_set_need);
760 ASSERT ((bfd_size_type) (need_pnames - sneed->contents) == need_size);
765 /* Set up the .rules section. This is just a PATH like string
766 of the -L arguments given on the command line. We permit the
767 user to specify the directories using the -rpath command line
769 if (command_line.rpath)
771 srules->size = strlen (command_line.rpath);
772 srules->contents = (bfd_byte *) command_line.rpath;
777 search_dirs_type *search;
780 for (search = search_head; search != NULL; search = search->next)
782 size += strlen (search->name) + 1;
788 srules->contents = (bfd_byte *) xmalloc (size);
789 p = (char *) srules->contents;
791 for (search = search_head; search != NULL; search = search->next)
795 if (p != (char *) srules->contents)
797 strcpy (p, search->name);
805 /* We must assign a value to __DYNAMIC. It should be zero if we are
806 not doing a dynamic link, or the start of the .dynamic section if
808 if (! link_info.relocatable)
810 hdyn->type = bfd_link_hash_defined;
811 hdyn->u.def.value = 0;
813 hdyn->u.def.section = sdyn;
815 hdyn->u.def.section = bfd_abs_section_ptr;
818 before_allocation_default ();
821 /* This is called by the before_allocation routine via
822 lang_for_each_statement. It does one of two things: if the
823 variable find_assign is set, it sets found_assign if it finds an
824 assignment to that variable; otherwise it tells the backend linker
825 about all assignment statements, in case they are assignments to
826 symbols which are referred to by dynamic objects. */
829 gld${EMULATION_NAME}_find_assignment (lang_statement_union_type *s)
831 if (s->header.type == lang_assignment_statement_enum
832 && (find_assign == NULL || ! found_assign))
833 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
836 /* Look through an expression for an assignment statement. */
839 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
841 switch (exp->type.node_class)
844 if (find_assign != NULL)
846 if (strcmp (find_assign, exp->assign.dst) == 0)
851 if (strcmp (exp->assign.dst, ".") != 0)
853 if (! bfd_sunos_record_link_assignment (link_info.output_bfd,
856 einfo ("%P%F: failed to record assignment to %s: %E\n",
859 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
863 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
864 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
868 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
869 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
870 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
874 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
882 /* Work out the size of the .need section, and the number of entries.
883 The backend will set the ld_need field of the dynamic linking
884 information to point to the .need section. See include/aout/sun4.h
885 for more information. */
888 gld${EMULATION_NAME}_count_need (lang_input_statement_type *inp)
890 if (inp->the_bfd != NULL
891 && (inp->the_bfd->flags & DYNAMIC) != 0)
894 need_size += NEED_ENTRY_SIZE;
895 if (! inp->flags.maybe_archive)
896 need_size += strlen (inp->filename) + 1;
899 ASSERT (inp->local_sym_name[0] == '-'
900 && inp->local_sym_name[1] == 'l');
901 need_size += strlen (inp->local_sym_name + 2) + 1;
906 /* Fill in the contents of the .need section. */
909 gld${EMULATION_NAME}_set_need (lang_input_statement_type *inp)
911 if (inp->the_bfd != NULL
912 && (inp->the_bfd->flags & DYNAMIC) != 0)
916 /* To really fill in the .need section contents, we need to know
917 the final file position of the section, but we don't.
918 Instead, we use offsets, and rely on the BFD backend to
919 finish the section up correctly. FIXME: Talk about lack of
920 referential locality. */
921 bfd_put_32 (link_info.output_bfd, need_pnames - need_contents,
923 if (! inp->flags.maybe_archive)
925 bfd_put_32 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 4);
926 bfd_put_16 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 8);
927 bfd_put_16 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 10);
928 strcpy ((char *) need_pnames, inp->filename);
935 bfd_put_32 (link_info.output_bfd, (bfd_vma) 0x80000000,
939 verstr = strstr (inp->filename, ".so.");
941 sscanf (verstr, ".so.%d.%d", &maj, &min);
942 bfd_put_16 (link_info.output_bfd, (bfd_vma) maj, need_pinfo + 8);
943 bfd_put_16 (link_info.output_bfd, (bfd_vma) min, need_pinfo + 10);
944 strcpy ((char *) need_pnames, inp->local_sym_name + 2);
947 c = (need_pinfo - need_contents) / NEED_ENTRY_SIZE;
948 if (c + 1 >= need_entries)
949 bfd_put_32 (link_info.output_bfd, (bfd_vma) 0, need_pinfo + 12);
951 bfd_put_32 (link_info.output_bfd, (bfd_vma) (c + 1) * NEED_ENTRY_SIZE,
954 need_pinfo += NEED_ENTRY_SIZE;
955 need_pnames += strlen ((char *) need_pnames) + 1;
960 gld${EMULATION_NAME}_get_script (int *isfile)
963 if test -n "$COMPILE_IN"
965 # Scripts compiled in.
967 # sed commands to quote an ld script as a C string.
968 sc="-f stringify.sed"
974 if (link_info.relocatable && config.build_constructors)
977 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
978 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
979 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
980 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
981 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
982 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
983 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
984 echo ' ; else return' >> e${EMULATION_NAME}.c
985 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
986 echo '; }' >> e${EMULATION_NAME}.c
989 # Scripts read from the filesystem.
995 if (link_info.relocatable && config.build_constructors)
996 return "ldscripts/${EMULATION_NAME}.xu";
997 else if (link_info.relocatable)
998 return "ldscripts/${EMULATION_NAME}.xr";
999 else if (!config.text_read_only)
1000 return "ldscripts/${EMULATION_NAME}.xbn";
1001 else if (!config.magic_demand_paged)
1002 return "ldscripts/${EMULATION_NAME}.xn";
1004 return "ldscripts/${EMULATION_NAME}.x";
1012 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1014 gld${EMULATION_NAME}_before_parse,
1017 after_parse_default,
1018 gld${EMULATION_NAME}_after_open,
1019 after_allocation_default,
1020 set_output_arch_default,
1021 ldemul_default_target,
1022 gld${EMULATION_NAME}_before_allocation,
1023 gld${EMULATION_NAME}_get_script,
1024 "${EMULATION_NAME}",
1027 gld${EMULATION_NAME}_create_output_section_statements,
1028 NULL, /* open dynamic archive */
1029 NULL, /* place orphan */
1030 gld${EMULATION_NAME}_set_symbols,
1031 NULL, /* parse args */
1032 NULL, /* add_options */
1033 NULL, /* handle_option */
1034 NULL, /* unrecognized file */
1035 NULL, /* list options */
1036 NULL, /* recognized file */
1037 NULL, /* find_potential_libraries */
1038 NULL /* new_vers_pattern */