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