| blob | f4660ec4b7e4c539de6ab5404f604f40a9c156da |
1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 if [ -z "$MACHINE" ]; then
4 OUTPUT_ARCH=${ARCH}
5 else
6 OUTPUT_ARCH=${ARCH}:${MACHINE}
7 fi
8 fragment <<EOF
9 /* This file is is generated by a shell script. DO NOT EDIT! */
11 /* AIX emulation code for ${EMULATION_NAME}
12 Copyright 1991, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
13 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
14 Free Software Foundation, Inc.
15 Written by Steve Chamberlain <sac@cygnus.com>
16 AIX support by Ian Lance Taylor <ian@cygnus.com>
17 AIX 64 bit support by Tom Rix <trix@redhat.com>
19 This file is part of the GNU Binutils.
21 This program is free software; you can redistribute it and/or modify
22 it under the terms of the GNU General Public License as published by
23 the Free Software Foundation; either version 3 of the License, or
24 (at your option) any later version.
26 This program is distributed in the hope that it will be useful,
27 but WITHOUT ANY WARRANTY; without even the implied warranty of
28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 GNU General Public License for more details.
31 You should have received a copy of the GNU General Public License
32 along with this program; if not, write to the Free Software
33 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
34 MA 02110-1301, USA. */
36 #define TARGET_IS_${EMULATION_NAME}
38 #include "sysdep.h"
39 #include "bfd.h"
40 #include "libiberty.h"
41 #include "safe-ctype.h"
42 #include "getopt.h"
43 #include "obstack.h"
44 #include "bfdlink.h"
46 #include "ld.h"
47 #include "ldmain.h"
48 #include "ldmisc.h"
49 #include "ldexp.h"
50 #include "ldlang.h"
51 #include "ldfile.h"
52 #include "ldemul.h"
53 #include "ldctor.h"
54 #include <ldgram.h>
56 #include "coff/internal.h"
57 #include "coff/xcoff.h"
58 #include "libcoff.h"
59 #include "libxcoff.h"
61 static void gld${EMULATION_NAME}_read_file (const char *, bfd_boolean);
62 static void gld${EMULATION_NAME}_free (void *);
63 static void gld${EMULATION_NAME}_find_relocs (lang_statement_union_type *);
64 static void gld${EMULATION_NAME}_find_exp_assignment (etree_type *);
67 /* The file alignment required for each section. */
68 static unsigned long file_align;
70 /* The maximum size the stack is permitted to grow. This is stored in
71 the a.out header. */
72 static unsigned long maxstack;
74 /* The maximum data size. This is stored in the a.out header. */
75 static unsigned long maxdata;
77 /* Whether to perform garbage collection. */
78 static int gc = 1;
80 /* The module type to use. */
81 static unsigned short modtype = ('1' << 8) | 'L';
83 /* Whether the .text section must be read-only (i.e., no relocs
84 permitted). */
85 static int textro;
87 /* A mask of XCOFF_EXPALL and XCOFF_EXPFULL flags, as set by their
88 associated -b and -bno options. */
89 static unsigned int auto_export_flags;
91 /* A mask of auto_export_flags bits that were explicitly set on the
92 command line. */
93 static unsigned int explicit_auto_export_flags;
95 /* Whether to implement Unix like linker semantics. */
96 static int unix_ld;
98 /* Structure used to hold import file list. */
100 struct filelist
101 {
102 struct filelist *next;
103 const char *name;
104 };
106 /* List of import files. */
107 static struct filelist *import_files;
109 /* List of export symbols read from the export files. */
111 struct export_symbol_list
112 {
113 struct export_symbol_list *next;
114 const char *name;
115 };
117 static struct export_symbol_list *export_symbols;
119 /* Maintains the 32 or 64 bit mode state of import file */
120 static unsigned int symbol_mode = 0x04;
122 /* Which symbol modes are valid */
123 static unsigned int symbol_mode_mask = 0x0d;
125 /* Whether this is a 64 bit link */
126 static int is_64bit = 0;
128 /* Which syscalls from import file are valid */
129 static unsigned int syscall_mask = 0x77;
131 /* fake file for -binitfini support */
132 static lang_input_statement_type *initfini_file;
134 /* Whether to do run time linking
135 -brtl enables, -bnortl and -bnortllib disable. */
136 static int rtld;
138 /* Explicit command line library path, -blibpath */
139 static char *command_line_blibpath = NULL;
141 /* This routine is called before anything else is done. */
143 static void
144 gld${EMULATION_NAME}_before_parse (void)
145 {
146 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
148 config.dynamic_link = TRUE;
149 config.has_shared = TRUE;
151 /* The link_info.[init|fini]_functions are initialized in ld/lexsup.c.
152 Override them here so we can use the link_info.init_function as a
153 state flag that lets the backend know that -binitfini has been done. */
155 link_info.init_function = NULL;
156 link_info.fini_function = NULL;
157 }
159 /* Handle AIX specific options. */
161 enum
162 {
163 OPTION_IGNORE = 300,
164 OPTION_AUTOIMP,
165 OPTION_ERNOTOK,
166 OPTION_EROK,
167 OPTION_EXPALL,
168 OPTION_EXPFULL,
169 OPTION_EXPORT,
170 OPTION_IMPORT,
171 OPTION_INITFINI,
172 OPTION_LOADMAP,
173 OPTION_MAXDATA,
174 OPTION_MAXSTACK,
175 OPTION_MODTYPE,
176 OPTION_NOAUTOIMP,
177 OPTION_NOEXPALL,
178 OPTION_NOEXPFULL,
179 OPTION_NOSTRCMPCT,
180 OPTION_PD,
181 OPTION_PT,
182 OPTION_STRCMPCT,
183 OPTION_UNIX,
184 OPTION_32,
185 OPTION_64,
186 OPTION_LIBPATH,
187 OPTION_NOLIBPATH,
188 };
190 static void
191 gld${EMULATION_NAME}_add_options
192 (int ns, char **shortopts, int nl, struct option **longopts,
193 int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
194 {
195 static const char xtra_short[] = "D:H:KT:z";
196 static const struct option xtra_long[] = {
197 /* -binitfini has special handling in the linker backend. The native linker
198 uses the arguemnts to generate a table of init and fini functions for
199 the executable. The important use for this option is to support aix 4.2+
200 c++ constructors and destructors. This is tied into gcc via collect2.c.
202 The function table is accessed by the runtime linker/loader by checking if
203 the first symbol in the loader symbol table is __rtinit. The gnu linker
204 generates this symbol and makes it the first loader symbol. */
206 {"basis", no_argument, NULL, OPTION_IGNORE},
207 {"bautoimp", no_argument, NULL, OPTION_AUTOIMP},
208 {"bcomprld", no_argument, NULL, OPTION_IGNORE},
209 {"bcrld", no_argument, NULL, OPTION_IGNORE},
210 {"bcror31", no_argument, NULL, OPTION_IGNORE},
211 {"bD", required_argument, NULL, OPTION_MAXDATA},
212 {"bE", required_argument, NULL, OPTION_EXPORT},
213 {"bernotok", no_argument, NULL, OPTION_ERNOTOK},
214 {"berok", no_argument, NULL, OPTION_EROK},
215 {"berrmsg", no_argument, NULL, OPTION_IGNORE},
216 {"bexpall", no_argument, NULL, OPTION_EXPALL},
217 {"bexpfull", no_argument, NULL, OPTION_EXPFULL},
218 {"bexport", required_argument, NULL, OPTION_EXPORT},
219 {"bbigtoc", no_argument, NULL, OPTION_IGNORE},
220 {"bf", no_argument, NULL, OPTION_ERNOTOK},
221 {"bgc", no_argument, &gc, 1},
222 {"bh", required_argument, NULL, OPTION_IGNORE},
223 {"bhalt", required_argument, NULL, OPTION_IGNORE},
224 {"bI", required_argument, NULL, OPTION_IMPORT},
225 {"bimport", required_argument, NULL, OPTION_IMPORT},
226 {"binitfini", required_argument, NULL, OPTION_INITFINI},
227 {"bl", required_argument, NULL, OPTION_LOADMAP},
228 {"bloadmap", required_argument, NULL, OPTION_LOADMAP},
229 {"bmaxdata", required_argument, NULL, OPTION_MAXDATA},
230 {"bmaxstack", required_argument, NULL, OPTION_MAXSTACK},
231 {"bM", required_argument, NULL, OPTION_MODTYPE},
232 {"bmodtype", required_argument, NULL, OPTION_MODTYPE},
233 {"bnoautoimp", no_argument, NULL, OPTION_NOAUTOIMP},
234 {"bnoexpall", no_argument, NULL, OPTION_NOEXPALL},
235 {"bnoexpfull", no_argument, NULL, OPTION_NOEXPFULL},
236 {"bnodelcsect", no_argument, NULL, OPTION_IGNORE},
237 {"bnoentry", no_argument, NULL, OPTION_IGNORE},
238 {"bnogc", no_argument, &gc, 0},
239 {"bnso", no_argument, NULL, OPTION_NOAUTOIMP},
240 {"bnostrcmpct", no_argument, NULL, OPTION_NOSTRCMPCT},
241 {"bnotextro", no_argument, &textro, 0},
242 {"bnro", no_argument, &textro, 0},
243 {"bpD", required_argument, NULL, OPTION_PD},
244 {"bpT", required_argument, NULL, OPTION_PT},
245 {"bro", no_argument, &textro, 1},
246 {"brtl", no_argument, &rtld, 1},
247 {"bnortl", no_argument, &rtld, 0},
248 {"bnortllib", no_argument, &rtld, 0},
249 {"bS", required_argument, NULL, OPTION_MAXSTACK},
250 {"bso", no_argument, NULL, OPTION_AUTOIMP},
251 {"bstrcmpct", no_argument, NULL, OPTION_STRCMPCT},
252 {"btextro", no_argument, &textro, 1},
253 {"b32", no_argument, NULL, OPTION_32},
254 {"b64", no_argument, NULL, OPTION_64},
255 {"static", no_argument, NULL, OPTION_NOAUTOIMP},
256 {"unix", no_argument, NULL, OPTION_UNIX},
257 {"blibpath", required_argument, NULL, OPTION_LIBPATH},
258 {"bnolibpath", required_argument, NULL, OPTION_NOLIBPATH},
259 {NULL, no_argument, NULL, 0}
260 };
262 /* Options supported by the AIX linker which we do not support:
263 -S, -v, -Z, -bbindcmds, -bbinder, -bbindopts, -bcalls, -bcaps,
264 -bcror15, -bdebugopt, -bdbg, -bdelcsect, -bex?, -bfilelist, -bfl,
265 -bgcbypass, -bglink, -binsert, -bi, -bloadmap, -bl, -bmap, -bnl,
266 -bnobind, -bnocomprld, -bnocrld, -bnoerrmsg, -bnoglink,
267 -bnoloadmap, -bnl, -bnoobjreorder, -bnoquiet, -bnoreorder,
268 -bnotypchk, -bnox, -bquiet, -bR, -brename, -breorder, -btypchk,
269 -bx, -bX, -bxref. */
271 *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
272 memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
273 *longopts = xrealloc (*longopts,
274 nl * sizeof (struct option) + sizeof (xtra_long));
275 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
276 }
278 static bfd_boolean
279 gld${EMULATION_NAME}_parse_args (int argc, char **argv)
280 {
281 int indx;
283 /* If the current option starts with -b, change the first : to an =.
284 The AIX linker uses : to separate the option from the argument;
285 changing it to = lets us treat it as a getopt option. */
286 indx = optind;
287 if (indx == 0)
288 indx = 1;
290 if (indx < argc && CONST_STRNEQ (argv[indx], "-b"))
291 {
292 char *s;
294 for (s = argv[indx]; *s != '\0'; s++)
295 {
296 if (*s == ':')
297 {
298 *s = '=';
299 break;
300 }
301 }
302 }
303 return FALSE;
304 }
306 /* Helper for option '-f', which specify a list of input files.
307 Contrary to the native linker, we don't support shell patterns
308 (simply because glob isn't always available). */
310 static void
311 read_file_list (const char *filename)
312 {
313 FILE *f;
314 /* An upper bound on the number of characters in the file. */
315 long pos;
316 /* File in memory. */
317 char *buffer;
318 size_t len;
319 char *b;
320 char *e;
322 f = fopen (filename, FOPEN_RT);
323 if (f == NULL)
324 {
325 einfo ("%F%P: cannot open %s\n", filename);
326 return;
327 }
328 if (fseek (f, 0L, SEEK_END) == -1)
329 goto error;
330 pos = ftell (f);
331 if (pos == -1)
332 goto error;
333 if (fseek (f, 0L, SEEK_SET) == -1)
334 goto error;
336 buffer = (char *) xmalloc (pos + 1);
337 len = fread (buffer, sizeof (char), pos, f);
338 if (len != (size_t) pos && ferror (f))
339 goto error;
340 /* Add a NUL terminator. */
341 buffer[len] = '\0';
342 fclose (f);
344 /* Parse files. */
345 b = buffer;
346 while (1)
347 {
348 /* Skip empty lines. */
349 while (*b == '\n' || *b == '\r')
350 b++;
352 /* Stop if end of buffer. */
353 if (b == buffer + len)
354 break;
356 /* Eat any byte until end of line. */
357 for (e = b; *e != '\0'; e++)
358 if (*e == '\n' || *e == '\r')
359 break;
361 /* Replace end of line by nul. */
362 if (*e != '\0')
363 *e++ = '\0';
365 if (b != e)
366 lang_add_input_file (b, lang_input_file_is_search_file_enum, NULL);
367 b = e;
368 }
369 return;
371 error:
372 einfo ("%F%P: cannot read %s\n", optarg);
373 fclose (f);
374 }
376 static bfd_boolean
377 gld${EMULATION_NAME}_handle_option (int optc)
378 {
379 bfd_signed_vma val;
380 const char *end;
382 switch (optc)
383 {
384 default:
385 return FALSE;
387 case 0:
388 /* Long option which just sets a flag. */
389 break;
391 case 'f':
392 /* This overrides --auxiliary. This option specifies a file containing
393 a list of input files. */
394 read_file_list (optarg);
395 break;
397 case 'D':
398 val = bfd_scan_vma (optarg, &end, 0);
399 if (*end != '\0')
400 einfo ("%P: warning: ignoring invalid -D number %s\n", optarg);
401 else if (val != -1)
402 lang_section_start (".data", exp_intop (val), NULL);
403 break;
405 case 'H':
406 val = bfd_scan_vma (optarg, &end, 0);
407 if (*end != '\0' || (val & (val - 1)) != 0)
408 einfo ("%P: warning: ignoring invalid -H number %s\n", optarg);
409 else
410 file_align = val;
411 break;
413 case 'K':
414 case 'z':
415 /* FIXME: This should use the page size for the target system. */
416 file_align = 4096;
417 break;
419 case 'T':
420 /* On AIX this is the same as GNU ld -Ttext. When we see -T
421 number, we assume the AIX option is intended. Otherwise, we
422 assume the usual GNU ld -T option is intended. We can't just
423 ignore the AIX option, because gcc passes it to the linker. */
424 val = bfd_scan_vma (optarg, &end, 0);
425 if (*end != '\0')
426 return FALSE;
427 lang_section_start (".text", exp_intop (val), NULL);
428 break;
430 case OPTION_IGNORE:
431 break;
433 case OPTION_INITFINI:
434 {
435 /*
436 * The aix linker init fini has the format :
437 *
438 * -binitfini:[ Initial][:Termination][:Priority]
439 *
440 * it allows the Termination and Priority to be optional.
441 *
442 * Since we support only one init/fini pair, we ignore the Priority.
443 *
444 * Define the special symbol __rtinit.
445 *
446 * strtok does not correctly handle the case of -binitfini::fini: so
447 * do it by hand
448 */
449 char *t, *i, *f;
451 i = t = optarg;
452 while (*t && ':' != *t)
453 t++;
454 if (*t)
455 *t++ = 0;
457 if (0 != strlen (i))
458 link_info.init_function = i;
460 f = t;
461 while (*t && ':' != *t)
462 t++;
463 *t = 0;
465 if (0 != strlen (f))
466 link_info.fini_function = f;
467 }
468 break;
470 case OPTION_AUTOIMP:
471 link_info.static_link = FALSE;
472 break;
474 case OPTION_ERNOTOK:
475 link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
476 link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
477 break;
479 case OPTION_EROK:
480 link_info.unresolved_syms_in_objects = RM_IGNORE;
481 link_info.unresolved_syms_in_shared_libs = RM_IGNORE;
482 break;
484 case OPTION_EXPALL:
485 auto_export_flags |= XCOFF_EXPALL;
486 explicit_auto_export_flags |= XCOFF_EXPALL;
487 break;
489 case OPTION_EXPFULL:
490 auto_export_flags |= XCOFF_EXPFULL;
491 explicit_auto_export_flags |= XCOFF_EXPFULL;
492 break;
494 case OPTION_EXPORT:
495 gld${EMULATION_NAME}_read_file (optarg, FALSE);
496 break;
498 case OPTION_IMPORT:
499 {
500 struct filelist *n;
501 struct filelist **flpp;
503 n = (struct filelist *) xmalloc (sizeof (struct filelist));
504 n->next = NULL;
505 n->name = optarg;
506 flpp = &import_files;
507 while (*flpp != NULL)
508 flpp = &(*flpp)->next;
509 *flpp = n;
510 }
511 break;
513 case OPTION_LOADMAP:
514 config.map_filename = optarg;
515 break;
517 case OPTION_MAXDATA:
518 val = bfd_scan_vma (optarg, &end, 0);
519 if (*end != '\0')
520 einfo ("%P: warning: ignoring invalid -bmaxdata number %s\n", optarg);
521 else
522 maxdata = val;
523 break;
525 case OPTION_MAXSTACK:
526 val = bfd_scan_vma (optarg, &end, 0);
527 if (*end != '\0')
528 einfo ("%P: warning: ignoring invalid -bmaxstack number %s\n",
529 optarg);
530 else
531 maxstack = val;
532 break;
534 case OPTION_MODTYPE:
535 if (*optarg == 'S')
536 {
537 link_info.shared = TRUE;
538 ++optarg;
539 }
540 if (*optarg == '\0' || optarg[1] == '\0')
541 einfo ("%P: warning: ignoring invalid module type %s\n", optarg);
542 else
543 modtype = (*optarg << 8) | optarg[1];
544 break;
546 case OPTION_NOAUTOIMP:
547 link_info.static_link = TRUE;
548 break;
550 case OPTION_NOEXPALL:
551 auto_export_flags &= ~XCOFF_EXPALL;
552 explicit_auto_export_flags |= XCOFF_EXPALL;
553 break;
555 case OPTION_NOEXPFULL:
556 auto_export_flags &= ~XCOFF_EXPFULL;
557 explicit_auto_export_flags |= XCOFF_EXPFULL;
558 break;
560 case OPTION_NOSTRCMPCT:
561 link_info.traditional_format = TRUE;
562 break;
564 case OPTION_PD:
565 /* This sets the page that the .data section is supposed to
566 start on. The offset within the page should still be the
567 offset within the file, so we need to build an appropriate
568 expression. */
569 val = bfd_scan_vma (optarg, &end, 0);
570 if (*end != '\0')
571 einfo ("%P: warning: ignoring invalid -pD number %s\n", optarg);
572 else
573 {
574 etree_type *t;
576 t = exp_binop ('+',
577 exp_intop (val),
578 exp_binop ('&',
579 exp_nameop (NAME, "."),
580 exp_intop (0xfff)));
581 t = exp_binop ('&',
582 exp_binop ('+', t, exp_intop (31)),
583 exp_intop (~(bfd_vma) 31));
584 lang_section_start (".data", t, NULL);
585 }
586 break;
588 case OPTION_PT:
589 /* This set the page that the .text section is supposed to start
590 on. The offset within the page should still be the offset
591 within the file. */
592 val = bfd_scan_vma (optarg, &end, 0);
593 if (*end != '\0')
594 einfo ("%P: warning: ignoring invalid -pT number %s\n", optarg);
595 else
596 {
597 etree_type *t;
599 t = exp_binop ('+',
600 exp_intop (val),
601 exp_nameop (SIZEOF_HEADERS, NULL));
602 t = exp_binop ('&',
603 exp_binop ('+', t, exp_intop (31)),
604 exp_intop (~(bfd_vma) 31));
605 lang_section_start (".text", t, NULL);
606 }
607 break;
609 case OPTION_STRCMPCT:
610 link_info.traditional_format = FALSE;
611 break;
613 case OPTION_UNIX:
614 unix_ld = TRUE;
615 break;
617 case OPTION_32:
618 is_64bit = 0;
619 syscall_mask = 0x77;
620 symbol_mode_mask = 0x0d;
621 break;
623 case OPTION_64:
624 is_64bit = 1;
625 syscall_mask = 0xcc;
626 symbol_mode_mask = 0x0e;
627 break;
629 case OPTION_LIBPATH:
630 command_line_blibpath = optarg;
631 break;
633 case OPTION_NOLIBPATH:
634 command_line_blibpath = NULL;
635 break;
637 }
639 return TRUE;
640 }
642 /* This is called when an input file can not be recognized as a BFD
643 object or an archive. If the file starts with #!, we must treat it
644 as an import file. This is for AIX compatibility. */
646 static bfd_boolean
647 gld${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry)
648 {
649 FILE *e;
650 bfd_boolean ret;
652 e = fopen (entry->filename, FOPEN_RT);
653 if (e == NULL)
654 return FALSE;
656 ret = FALSE;
658 if (getc (e) == '#' && getc (e) == '!')
659 {
660 struct filelist *n;
661 struct filelist **flpp;
663 n = (struct filelist *) xmalloc (sizeof (struct filelist));
664 n->next = NULL;
665 n->name = entry->filename;
666 flpp = &import_files;
667 while (*flpp != NULL)
668 flpp = &(*flpp)->next;
669 *flpp = n;
671 ret = TRUE;
672 entry->loaded = TRUE;
673 }
675 fclose (e);
677 return ret;
678 }
680 /* This is called after the input files have been opened. */
682 static void
683 gld${EMULATION_NAME}_after_open (void)
684 {
685 bfd_boolean r;
686 struct set_info *p;
688 after_open_default ();
690 /* Call ldctor_build_sets, after pretending that this is a
691 relocatable link. We do this because AIX requires relocation
692 entries for all references to symbols, even in a final
693 executable. Of course, we only want to do this if we are
694 producing an XCOFF output file. */
695 r = link_info.relocatable;
696 if (strstr (bfd_get_target (link_info.output_bfd), "xcoff") != NULL)
697 link_info.relocatable = TRUE;
698 ldctor_build_sets ();
699 link_info.relocatable = r;
701 /* For each set, record the size, so that the XCOFF backend can
702 output the correct csect length. */
703 for (p = sets; p != (struct set_info *) NULL; p = p->next)
704 {
705 bfd_size_type size;
707 /* If the symbol is defined, we may have been invoked from
708 collect, and the sets may already have been built, so we do
709 not do anything. */
710 if (p->h->type == bfd_link_hash_defined
711 || p->h->type == bfd_link_hash_defweak)
712 continue;
714 if (p->reloc != BFD_RELOC_CTOR)
715 {
716 /* Handle this if we need to. */
717 abort ();
718 }
720 size = (p->count + 2) * 4;
721 if (!bfd_xcoff_link_record_set (link_info.output_bfd, &link_info,
722 p->h, size))
723 einfo ("%F%P: bfd_xcoff_link_record_set failed: %E\n");
724 }
725 }
727 /* This is called after the sections have been attached to output
728 sections, but before any sizes or addresses have been set. */
730 static void
731 gld${EMULATION_NAME}_before_allocation (void)
732 {
733 struct filelist *fl;
734 struct export_symbol_list *el;
735 char *libpath;
736 asection *special_sections[XCOFF_NUMBER_OF_SPECIAL_SECTIONS];
737 static const char *const must_keep_sections[] = {
738 ".text",
739 ".data",
740 ".bss"
741 };
742 unsigned int i, flags;
744 /* Handle the import and export files, if any. */
745 for (fl = import_files; fl != NULL; fl = fl->next)
746 gld${EMULATION_NAME}_read_file (fl->name, TRUE);
747 for (el = export_symbols; el != NULL; el = el->next)
748 {
749 struct bfd_link_hash_entry *h;
751 h = bfd_link_hash_lookup (link_info.hash, el->name, FALSE, FALSE, FALSE);
752 if (h == NULL)
753 einfo ("%P%F: bfd_link_hash_lookup of export symbol failed: %E\n");
754 if (!bfd_xcoff_export_symbol (link_info.output_bfd, &link_info, h))
755 einfo ("%P%F: bfd_xcoff_export_symbol failed: %E\n");
756 }
758 /* Track down all relocations called for by the linker script (these
759 are typically constructor/destructor entries created by
760 CONSTRUCTORS) and let the backend know it will need to create
761 .loader relocs for them. */
762 lang_for_each_statement (gld${EMULATION_NAME}_find_relocs);
764 /* Precedence of LIBPATH
765 -blibpath: native support always first
766 -rpath: gnu extension
767 -L build from command line -L's */
768 if (command_line_blibpath != NULL)
769 libpath = command_line_blibpath;
770 else if (command_line.rpath != NULL)
771 libpath = command_line.rpath;
772 else if (search_head == NULL)
773 libpath = (char *) "";
774 else
775 {
776 size_t len;
777 search_dirs_type *search;
779 /* PR ld/4023: Strip sysroot prefix from any paths
780 being inserted into the output binary's DT_RPATH. */
781 if (ld_sysroot != NULL
782 && * ld_sysroot != 0)
783 {
784 const char * name = search_head->name;
785 size_t ld_sysroot_len = strlen (ld_sysroot);
787 if (strncmp (name, ld_sysroot, ld_sysroot_len) == 0)
788 name += ld_sysroot_len;
790 len = strlen (name);
791 libpath = xmalloc (len + 1);
792 strcpy (libpath, name);
794 for (search = search_head->next; search != NULL; search = search->next)
795 {
796 size_t nlen;
798 name = search->name;
799 if (strncmp (name, ld_sysroot, ld_sysroot_len) == 0)
800 name += ld_sysroot_len;
802 nlen = strlen (name);
803 libpath = xrealloc (libpath, len + nlen + 2);
804 libpath[len] = ':';
805 strcpy (libpath + len + 1, name);
806 len += nlen + 1;
807 }
808 }
809 else
810 {
811 len = strlen (search_head->name);
812 libpath = xmalloc (len + 1);
813 strcpy (libpath, search_head->name);
815 for (search = search_head->next; search != NULL; search = search->next)
816 {
817 size_t nlen;
819 nlen = strlen (search->name);
820 libpath = xrealloc (libpath, len + nlen + 2);
821 libpath[len] = ':';
822 strcpy (libpath + len + 1, search->name);
823 len += nlen + 1;
824 }
825 }
826 }
828 /* Default to -bexpfull for SVR4-like semantics. */
829 flags = (unix_ld ? XCOFF_EXPFULL : 0);
830 flags &= ~explicit_auto_export_flags;
831 flags |= auto_export_flags;
833 /* Let the XCOFF backend set up the .loader section. */
834 if (!bfd_xcoff_size_dynamic_sections
835 (link_info.output_bfd, &link_info, libpath, entry_symbol.name, file_align,
836 maxstack, maxdata, gc && !unix_ld ? TRUE : FALSE,
837 modtype, textro ? TRUE : FALSE, flags, special_sections,
838 rtld ? TRUE : FALSE))
839 einfo ("%P%F: failed to set dynamic section sizes: %E\n");
841 /* Look through the special sections, and put them in the right
842 place in the link ordering. This is especially magic. */
843 for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++)
844 {
845 asection *sec;
846 lang_output_section_statement_type *os;
847 lang_statement_union_type **pls;
848 lang_input_section_type *is;
849 const char *oname;
850 bfd_boolean start;
852 sec = special_sections[i];
853 if (sec == NULL)
854 continue;
856 /* Remove this section from the list of the output section.
857 This assumes we know what the script looks like. */
858 is = NULL;
859 os = lang_output_section_find (sec->output_section->name);
860 if (os == NULL)
861 einfo ("%P%F: can't find output section %s\n",
862 sec->output_section->name);
864 for (pls = &os->children.head; *pls != NULL; pls = &(*pls)->header.next)
865 {
866 if ((*pls)->header.type == lang_input_section_enum
867 && (*pls)->input_section.section == sec)
868 {
869 is = (lang_input_section_type *) * pls;
870 *pls = (*pls)->header.next;
871 break;
872 }
874 if ((*pls)->header.type == lang_wild_statement_enum)
875 {
876 lang_statement_union_type **pwls;
878 for (pwls = &(*pls)->wild_statement.children.head;
879 *pwls != NULL; pwls = &(*pwls)->header.next)
880 {
882 if ((*pwls)->header.type == lang_input_section_enum
883 && (*pwls)->input_section.section == sec)
884 {
885 is = (lang_input_section_type *) * pwls;
886 *pwls = (*pwls)->header.next;
887 break;
888 }
889 }
891 if (is != NULL)
892 break;
893 }
894 }
896 if (is == NULL)
897 {
898 einfo ("%P%F: can't find %s in output section\n",
899 bfd_get_section_name (sec->owner, sec));
900 }
902 /* Now figure out where the section should go. */
903 switch (i)
904 {
906 default: /* to avoid warnings */
907 case XCOFF_SPECIAL_SECTION_TEXT:
908 /* _text */
909 oname = ".text";
910 start = TRUE;
911 break;
913 case XCOFF_SPECIAL_SECTION_ETEXT:
914 /* _etext */
915 oname = ".text";
916 start = FALSE;
917 break;
919 case XCOFF_SPECIAL_SECTION_DATA:
920 /* _data */
921 oname = ".data";
922 start = TRUE;
923 break;
925 case XCOFF_SPECIAL_SECTION_EDATA:
926 /* _edata */
927 oname = ".data";
928 start = FALSE;
929 break;
931 case XCOFF_SPECIAL_SECTION_END:
932 case XCOFF_SPECIAL_SECTION_END2:
933 /* _end and end */
934 oname = ".bss";
935 start = FALSE;
936 break;
937 }
939 os = lang_output_section_find (oname);
941 if (start)
942 {
943 is->header.next = os->children.head;
944 os->children.head = (lang_statement_union_type *) is;
945 }
946 else
947 {
948 is->header.next = NULL;
949 lang_statement_append (&os->children,
950 (lang_statement_union_type *) is,
951 &is->header.next);
952 }
953 }
955 /* Executables and shared objects must always have .text, .data
956 and .bss output sections, so that the header can refer to them.
957 The kernel refuses to load objects that have missing sections. */
958 if (!link_info.relocatable)
959 for (i = 0; i < ARRAY_SIZE (must_keep_sections); i++)
960 {
961 asection *sec;
963 sec = bfd_get_section_by_name (link_info.output_bfd,
964 must_keep_sections[i]);
965 if (sec == NULL)
966 einfo ("%P: can't find required output section %s\n", must_keep_sections[i]);
967 else
968 sec->flags |= SEC_KEEP;
969 }
971 before_allocation_default ();
972 }
974 static char *
975 gld${EMULATION_NAME}_choose_target (int argc, char **argv)
976 {
977 int i, j, jmax;
978 static char *from_outside;
979 static char *from_inside;
980 static char *argv_to_target[][2] = {
981 {NULL, "${OUTPUT_FORMAT}"},
982 {"-b32", "${OUTPUT_FORMAT_32BIT}"},
983 {"-b64", "${OUTPUT_FORMAT_64BIT}"},
984 };
986 jmax = 3;
988 from_outside = getenv (TARGET_ENVIRON);
989 if (from_outside != (char *) NULL)
990 return from_outside;
992 /* Set to default. */
993 from_inside = argv_to_target[0][1];
994 for (i = 1; i < argc; i++)
995 {
996 for (j = 1; j < jmax; j++)
997 {
998 if (0 == strcmp (argv[i], argv_to_target[j][0]))
999 from_inside = argv_to_target[j][1];
1000 }
1001 }
1003 return from_inside;
1004 }
1006 /* Returns
1007 1 : state changed
1008 0 : no change */
1009 static int
1010 change_symbol_mode (char *input)
1011 {
1012 char *symbol_mode_string[] = {
1013 "# 32", /* 0x01 */
1014 "# 64", /* 0x02 */
1015 "# no32", /* 0x04 */
1016 "# no64", /* 0x08 */
1017 NULL,
1018 };
1020 unsigned int bit;
1021 char *string;
1023 for (bit = 0;; bit++)
1024 {
1025 string = symbol_mode_string[bit];
1026 if (string == NULL)
1027 return 0;
1029 if (0 == strcmp (input, string))
1030 {
1031 symbol_mode = (1 << bit);
1032 return 1;
1033 }
1034 }
1035 /* should not be here */
1036 return 0;
1037 }
1039 /* Returns
1040 1 : yes
1041 0 : ignore
1042 -1 : error, try something else */
1043 static int
1044 is_syscall (char *input, unsigned int *flag)
1045 {
1046 unsigned int bit;
1047 char *string;
1049 struct sc {
1050 char *syscall_string;
1051 unsigned int flag;
1052 } s [] = {
1053 { "svc" /* 0x01 */, XCOFF_SYSCALL32 },
1054 { "svc32" /* 0x02 */, XCOFF_SYSCALL32 },
1055 { "svc3264" /* 0x04 */, XCOFF_SYSCALL32 | XCOFF_SYSCALL64 },
1056 { "svc64" /* 0x08 */, XCOFF_SYSCALL64 },
1057 { "syscall" /* 0x10 */, XCOFF_SYSCALL32 },
1058 { "syscall32" /* 0x20 */, XCOFF_SYSCALL32 },
1059 { "syscall3264" /* 0x40 */, XCOFF_SYSCALL32 | XCOFF_SYSCALL64 },
1060 { "syscall64" /* 0x80 */, XCOFF_SYSCALL64 },
1061 { NULL, 0 },
1062 };
1064 *flag = 0;
1066 for (bit = 0;; bit++)
1067 {
1068 string = s[bit].syscall_string;
1069 if (string == NULL)
1070 return -1;
1072 if (0 == strcmp (input, string))
1073 {
1074 if (1 << bit & syscall_mask)
1075 {
1076 *flag = s[bit].flag;
1077 return 1;
1078 }
1079 else
1080 {
1081 return 0;
1082 }
1083 }
1084 }
1085 /* should not be here */
1086 return -1;
1087 }
1089 /* Read an import or export file. For an import file, this is called
1090 by the before_allocation emulation routine. For an export file,
1091 this is called by the handle_option emulation routine. */
1093 static void
1094 gld${EMULATION_NAME}_read_file (const char *filename, bfd_boolean import)
1095 {
1096 struct obstack *o;
1097 FILE *f;
1098 int lineno;
1099 int c;
1100 bfd_boolean keep;
1101 const char *imppath;
1102 const char *impfile;
1103 const char *impmember;
1105 o = (struct obstack *) xmalloc (sizeof (struct obstack));
1106 obstack_specify_allocation (o, 0, 0, xmalloc, gld${EMULATION_NAME}_free);
1108 f = fopen (filename, FOPEN_RT);
1109 if (f == NULL)
1110 {
1111 bfd_set_error (bfd_error_system_call);
1112 einfo ("%F%s: %E\n", filename);
1113 }
1115 keep = FALSE;
1117 imppath = NULL;
1118 impfile = NULL;
1119 impmember = NULL;
1121 lineno = 0;
1123 /* Default to 32 and 64 bit mode
1124 symbols at top of /lib/syscalls.exp do not have a mode modifier and they
1125 are not repeated, assume 64 bit routines also want to use them.
1126 See the routine change_symbol_mode for more information. */
1128 symbol_mode = 0x04;
1130 while ((c = getc (f)) != EOF)
1131 {
1132 char *s;
1133 char *symname;
1134 unsigned int syscall_flag = 0;
1135 bfd_vma address;
1136 struct bfd_link_hash_entry *h;
1138 if (c != '\n')
1139 {
1140 obstack_1grow (o, c);
1141 continue;
1142 }
1144 obstack_1grow (o, '\0');
1145 ++lineno;
1147 s = (char *) obstack_base (o);
1148 while (ISSPACE (*s))
1149 ++s;
1150 if (*s == '\0'
1151 || *s == '*'
1152 || change_symbol_mode (s)
1153 || (*s == '#' && s[1] == ' ')
1154 || (!import && *s == '#' && s[1] == '!'))
1155 {
1156 obstack_free (o, obstack_base (o));
1157 continue;
1158 }
1160 if (*s == '#' && s[1] == '!')
1161 {
1162 s += 2;
1163 while (ISSPACE (*s))
1164 ++s;
1165 if (*s == '\0')
1166 {
1167 imppath = NULL;
1168 impfile = NULL;
1169 impmember = NULL;
1170 obstack_free (o, obstack_base (o));
1171 }
1172 else if (*s == '(')
1173 einfo ("%F%s%d: #! ([member]) is not supported in import files\n",
1174 filename, lineno);
1175 else
1176 {
1177 char cs;
1178 char *start;
1180 (void) obstack_finish (o);
1181 keep = TRUE;
1182 start = s;
1183 while (!ISSPACE (*s) && *s != '(' && *s != '\0')
1184 ++s;
1185 cs = *s;
1186 *s = '\0';
1187 if (!bfd_xcoff_split_import_path (link_info.output_bfd,
1188 start, &imppath, &impfile))
1189 einfo ("%F%P: Could not parse import path: %E\n");
1190 while (ISSPACE (cs))
1191 {
1192 ++s;
1193 cs = *s;
1194 }
1195 if (cs != '(')
1196 {
1197 impmember = "";
1198 if (cs != '\0')
1199 einfo ("%s:%d: warning: syntax error in import file\n",
1200 filename, lineno);
1201 }
1202 else
1203 {
1204 ++s;
1205 impmember = s;
1206 while (*s != ')' && *s != '\0')
1207 ++s;
1208 if (*s == ')')
1209 *s = '\0';
1210 else
1211 einfo ("%s:%d: warning: syntax error in import file\n",
1212 filename, lineno);
1213 }
1214 }
1216 continue;
1217 }
1219 if (symbol_mode & symbol_mode_mask)
1220 {
1221 /* This is a symbol to be imported or exported. */
1222 symname = s;
1223 syscall_flag = 0;
1224 address = (bfd_vma) -1;
1226 while (!ISSPACE (*s) && *s != '\0')
1227 ++s;
1228 if (*s != '\0')
1229 {
1230 char *se;
1232 *s++ = '\0';
1234 while (ISSPACE (*s))
1235 ++s;
1237 se = s;
1238 while (!ISSPACE (*se) && *se != '\0')
1239 ++se;
1240 if (*se != '\0')
1241 {
1242 *se++ = '\0';
1243 while (ISSPACE (*se))
1244 ++se;
1245 if (*se != '\0')
1246 einfo ("%s%d: warning: syntax error in import/export file\n",
1247 filename, lineno);
1248 }
1250 if (s != se)
1251 {
1252 int status;
1253 const char *end;
1255 status = is_syscall (s, &syscall_flag);
1257 if (0 > status)
1258 {
1259 /* not a system call, check for address */
1260 address = bfd_scan_vma (s, &end, 0);
1261 if (*end != '\0')
1262 {
1263 einfo ("%s:%d: warning: syntax error in import/export file\n",
1264 filename, lineno);
1266 }
1267 }
1268 }
1269 }
1271 if (!import)
1272 {
1273 struct export_symbol_list *n;
1275 ldlang_add_undef (symname, TRUE);
1276 n = ((struct export_symbol_list *)
1277 xmalloc (sizeof (struct export_symbol_list)));
1278 n->next = export_symbols;
1279 n->name = xstrdup (symname);
1280 export_symbols = n;
1281 }
1282 else
1283 {
1284 h = bfd_link_hash_lookup (link_info.hash, symname, FALSE, FALSE,
1285 TRUE);
1286 if (h == NULL || h->type == bfd_link_hash_new)
1287 {
1288 /* We can just ignore attempts to import an unreferenced
1289 symbol. */
1290 }
1291 else
1292 {
1293 if (!bfd_xcoff_import_symbol (link_info.output_bfd,
1294 &link_info, h,
1295 address, imppath, impfile,
1296 impmember, syscall_flag))
1297 einfo ("%X%s:%d: failed to import symbol %s: %E\n",
1298 filename, lineno, symname);
1299 }
1300 }
1301 }
1302 obstack_free (o, obstack_base (o));
1303 }
1305 if (obstack_object_size (o) > 0)
1306 {
1307 einfo ("%s:%d: warning: ignoring unterminated last line\n",
1308 filename, lineno);
1309 obstack_free (o, obstack_base (o));
1310 }
1312 if (!keep)
1313 {
1314 obstack_free (o, NULL);
1315 free (o);
1316 }
1317 }
1319 /* This routine saves us from worrying about declaring free. */
1321 static void
1322 gld${EMULATION_NAME}_free (void *p)
1323 {
1324 free (p);
1325 }
1327 /* This is called by the before_allocation routine via
1328 lang_for_each_statement. It looks for relocations and assignments
1329 to symbols. */
1331 static void
1332 gld${EMULATION_NAME}_find_relocs (lang_statement_union_type *s)
1333 {
1334 if (s->header.type == lang_reloc_statement_enum)
1335 {
1336 lang_reloc_statement_type *rs;
1338 rs = &s->reloc_statement;
1339 if (rs->name == NULL)
1340 einfo ("%F%P: only relocations against symbols are permitted\n");
1341 if (!bfd_xcoff_link_count_reloc (link_info.output_bfd, &link_info,
1342 rs->name))
1343 einfo ("%F%P: bfd_xcoff_link_count_reloc failed: %E\n");
1344 }
1346 if (s->header.type == lang_assignment_statement_enum)
1347 gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1348 }
1350 /* Look through an expression for an assignment statement. */
1352 static void
1353 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1354 {
1355 struct bfd_link_hash_entry *h;
1357 switch (exp->type.node_class)
1358 {
1359 case etree_provide:
1360 h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
1361 FALSE, FALSE, FALSE);
1362 if (h == NULL)
1363 break;
1364 /* Fall through. */
1365 case etree_assign:
1366 if (strcmp (exp->assign.dst, ".") != 0)
1367 {
1368 if (!bfd_xcoff_record_link_assignment (link_info.output_bfd,
1369 &link_info,
1370 exp->assign.dst))
1371 einfo ("%P%F: failed to record assignment to %s: %E\n",
1372 exp->assign.dst);
1373 }
1374 gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1375 break;
1377 case etree_binary:
1378 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1379 gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1380 break;
1382 case etree_trinary:
1383 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1384 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1385 gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1386 break;
1388 case etree_unary:
1389 gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1390 break;
1392 default:
1393 break;
1394 }
1395 }
1397 static char *
1398 gld${EMULATION_NAME}_get_script (int *isfile)
1399 EOF
1401 if test -n "$COMPILE_IN"
1402 then
1403 # Scripts compiled in.
1405 # sed commands to quote an ld script as a C string.
1406 sc="-f ${srcdir}/emultempl/ostring.sed"
1408 fragment <<EOF
1409 {
1410 *isfile = 0;
1412 if (link_info.relocatable && config.build_constructors)
1413 return
1414 EOF
1415 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1416 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
1417 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1418 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1419 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1420 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1421 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1422 echo ' ; else return' >> e${EMULATION_NAME}.c
1423 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1424 echo '; }' >> e${EMULATION_NAME}.c
1426 else
1427 # Scripts read from the filesystem.
1429 fragment <<EOF
1430 {
1431 *isfile = 1;
1433 if (link_info.relocatable && config.build_constructors)
1434 return "ldscripts/${EMULATION_NAME}.xu";
1435 else if (link_info.relocatable)
1436 return "ldscripts/${EMULATION_NAME}.xr";
1437 else if (!config.text_read_only)
1438 return "ldscripts/${EMULATION_NAME}.xbn";
1439 else if (!config.magic_demand_paged)
1440 return "ldscripts/${EMULATION_NAME}.xn";
1441 else
1442 return "ldscripts/${EMULATION_NAME}.x";
1443 }
1444 EOF
1446 fi
1448 fragment <<EOF
1450 static void
1451 gld${EMULATION_NAME}_create_output_section_statements (void)
1452 {
1453 /* __rtinit */
1454 if ((bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour)
1455 && (link_info.init_function != NULL
1456 || link_info.fini_function != NULL
1457 || rtld))
1458 {
1459 initfini_file = lang_add_input_file ("initfini",
1460 lang_input_file_is_file_enum,
1461 NULL);
1463 initfini_file->the_bfd = bfd_create ("initfini", link_info.output_bfd);
1464 if (initfini_file->the_bfd == NULL
1465 || ! bfd_set_arch_mach (initfini_file->the_bfd,
1466 bfd_get_arch (link_info.output_bfd),
1467 bfd_get_mach (link_info.output_bfd)))
1468 {
1469 einfo ("%X%P: can not create BFD %E\n");
1470 return;
1471 }
1473 /* Call backend to fill in the rest */
1474 if (! bfd_xcoff_link_generate_rtinit (initfini_file->the_bfd,
1475 link_info.init_function,
1476 link_info.fini_function,
1477 rtld))
1478 {
1479 einfo ("%X%P: can not create BFD %E\n");
1480 return;
1481 }
1483 /* __rtld defined in /lib/librtl.a */
1484 if (rtld)
1485 lang_add_input_file ("rtl", lang_input_file_is_l_enum, NULL);
1486 }
1487 }
1489 static void
1490 gld${EMULATION_NAME}_set_output_arch (void)
1491 {
1492 bfd_set_arch_mach (link_info.output_bfd,
1493 bfd_xcoff_architecture (link_info.output_bfd),
1494 bfd_xcoff_machine (link_info.output_bfd));
1496 ldfile_output_architecture = bfd_get_arch (link_info.output_bfd);
1497 ldfile_output_machine = bfd_get_mach (link_info.output_bfd);
1498 ldfile_output_machine_name = bfd_printable_name (link_info.output_bfd);
1499 }
1501 static bfd_boolean
1502 gld${EMULATION_NAME}_open_dynamic_archive (const char *arch,
1503 search_dirs_type *search,
1504 lang_input_statement_type *entry)
1505 {
1506 char *path;
1508 if (!entry->maybe_archive)
1509 return FALSE;
1511 path = concat (search->name, "/lib", entry->filename, arch, ".a", NULL);
1512 if (!ldfile_try_open_bfd (path, entry))
1513 {
1514 free (path);
1515 return FALSE;
1516 }
1517 /* Don't include the searched directory in the import path. */
1518 bfd_xcoff_set_archive_import_path (&link_info, entry->the_bfd,
1519 path + strlen (search->name) + 1);
1520 entry->filename = path;
1521 return TRUE;
1522 }
1524 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = {
1525 gld${EMULATION_NAME}_before_parse,
1526 syslib_default,
1527 hll_default,
1528 after_parse_default,
1529 gld${EMULATION_NAME}_after_open,
1530 after_allocation_default,
1531 gld${EMULATION_NAME}_set_output_arch,
1532 gld${EMULATION_NAME}_choose_target,
1533 gld${EMULATION_NAME}_before_allocation,
1534 gld${EMULATION_NAME}_get_script,
1535 "${EMULATION_NAME}",
1536 "${OUTPUT_FORMAT}",
1537 finish_default,
1538 gld${EMULATION_NAME}_create_output_section_statements,
1539 gld${EMULATION_NAME}_open_dynamic_archive,
1540 0, /* place_orphan */
1541 0, /* set_symbols */
1542 gld${EMULATION_NAME}_parse_args,
1543 gld${EMULATION_NAME}_add_options,
1544 gld${EMULATION_NAME}_handle_option,
1545 gld${EMULATION_NAME}_unrecognized_file,
1546 NULL, /* list_options */
1547 NULL, /* recognized_file */
1548 NULL, /* find potential_libraries */
1549 NULL /* new_vers_pattern */
1550 };
1551 EOF