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-2021 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#include "ctf-api.h"
44
45#include "ld.h"
46#include "ldmain.h"
47#include "ldmisc.h"
48#include "ldexp.h"
49#include "ldlang.h"
50#include "ldfile.h"
51#include "ldemul.h"
52#include "ldctor.h"
53#include <ldgram.h>
54
55#include "coff/internal.h"
56#include "coff/xcoff.h"
57#include "libcoff.h"
58#include "libxcoff.h"
59#include "xcofflink.h"
60
61static void gld${EMULATION_NAME}_read_file (const char *, bool);
62static void gld${EMULATION_NAME}_free (void *);
63static void gld${EMULATION_NAME}_find_relocs (lang_statement_union_type *);
64static void gld${EMULATION_NAME}_find_exp_assignment (etree_type *);
65
66
67/* The file alignment required for each section.  */
68static unsigned long file_align;
69
70/* The maximum size the stack is permitted to grow.  This is stored in
71   the a.out header.  */
72static unsigned long maxstack;
73
74/* The maximum data size.  This is stored in the a.out header.  */
75static unsigned long maxdata;
76
77/* Whether to perform garbage collection.  */
78static int gc = 1;
79
80/* The module type to use.  */
81static unsigned short modtype = ('1' << 8) | 'L';
82
83/* Whether the .text section must be read-only (i.e., no relocs
84   permitted).  */
85static int textro;
86
87/* A mask of XCOFF_EXPALL and XCOFF_EXPFULL flags, as set by their
88   associated -b and -bno options.  */
89static unsigned int auto_export_flags;
90
91/* A mask of auto_export_flags bits that were explicitly set on the
92   command line.  */
93static unsigned int explicit_auto_export_flags;
94
95/* Whether to implement Unix like linker semantics.  */
96static int unix_ld;
97
98/* Structure used to hold import file list.  */
99
100struct filelist
101{
102  struct filelist *next;
103  const char *name;
104};
105
106/* List of import files.  */
107static struct filelist *import_files;
108
109/* List of export symbols read from the export files.  */
110
111struct export_symbol_list
112{
113  struct export_symbol_list *next;
114  const char *name;
115};
116
117static struct export_symbol_list *export_symbols;
118
119/* Maintains the 32 or 64 bit mode state of import file */
120static unsigned int symbol_mode = 0x04;
121
122/* Which symbol modes are valid */
123static unsigned int symbol_mode_mask = 0x0d;
124
125/* Whether this is a 64 bit link */
126static int is_64bit = 0;
127
128/* Which syscalls from import file are valid */
129static unsigned int syscall_mask = 0x77;
130
131/* fake file for -binitfini support */
132static lang_input_statement_type *initfini_file;
133
134/* Whether to do run time linking
135   -brtl enables, -bnortl and -bnortllib disable. */
136static int rtld;
137
138/* Explicit command line library path, -blibpath */
139static char *command_line_blibpath = NULL;
140
141/* This routine is called before anything else is done.  */
142
143static void
144gld${EMULATION_NAME}_before_parse (void)
145{
146  ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
147
148  input_flags.dynamic = true;
149  config.has_shared = true;
150
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.  */
154
155  link_info.init_function = NULL;
156  link_info.fini_function = NULL;
157}
158
159/* Handle AIX specific options.  */
160
161enum
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  };
189
190static void
191gld${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.
201
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.  */
205
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  };
261
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.  */
270
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}
277
278static bool
279gld${EMULATION_NAME}_parse_args (int argc, char **argv)
280{
281  int indx;
282
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;
289
290  if (indx < argc && startswith (argv[indx], "-b"))
291    {
292      char *s;
293
294      for (s = argv[indx]; *s != '\0'; s++)
295	{
296	  if (*s == ':')
297	    {
298	      *s = '=';
299	      break;
300	    }
301	}
302    }
303  return false;
304}
305
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).  */
309
310static void
311read_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;
321
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;
335
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);
343
344  /* Parse files.  */
345  b = buffer;
346  while (1)
347    {
348      /* Skip empty lines.  */
349      while (*b == '\n' || *b == '\r')
350	b++;
351
352      /* Stop if end of buffer.  */
353      if (b == buffer + len)
354	break;
355
356      /* Eat any byte until end of line.  */
357      for (e = b; *e != '\0'; e++)
358	if (*e == '\n' || *e == '\r')
359	  break;
360
361      /* Replace end of line by nul.  */
362      if (*e != '\0')
363	*e++ = '\0';
364
365      if (b != e)
366	lang_add_input_file (b, lang_input_file_is_search_file_enum, NULL);
367      b = e;
368    }
369  return;
370
371 error:
372  einfo (_("%F%P: cannot read %s\n"), optarg);
373  fclose (f);
374}
375
376static bool
377gld${EMULATION_NAME}_handle_option (int optc)
378{
379  bfd_signed_vma val;
380  const char *end;
381
382  switch (optc)
383    {
384    default:
385      return false;
386
387    case 0:
388      /* Long option which just sets a flag.  */
389      break;
390
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;
396
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;
404
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;
412
413    case 'K':
414    case 'z':
415      /* FIXME: This should use the page size for the target system.  */
416      file_align = 4096;
417      break;
418
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;
429
430    case OPTION_IGNORE:
431      break;
432
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;
450
451	i = t = optarg;
452	while (*t && ':' != *t)
453	  t++;
454	if (*t)
455	  *t++ = 0;
456
457	if (0 != strlen (i))
458	  link_info.init_function = i;
459
460	f = t;
461	while (*t && ':' != *t)
462	  t++;
463	*t = 0;
464
465	if (0 != strlen (f))
466	  link_info.fini_function = f;
467      }
468      break;
469
470    case OPTION_AUTOIMP:
471      link_info.static_link = false;
472      break;
473
474    case OPTION_ERNOTOK:
475      link_info.unresolved_syms_in_objects = RM_DIAGNOSE;
476      link_info.unresolved_syms_in_shared_libs = RM_DIAGNOSE;
477      break;
478
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;
483
484    case OPTION_EXPALL:
485      auto_export_flags |= XCOFF_EXPALL;
486      explicit_auto_export_flags |= XCOFF_EXPALL;
487      break;
488
489    case OPTION_EXPFULL:
490      auto_export_flags |= XCOFF_EXPFULL;
491      explicit_auto_export_flags |= XCOFF_EXPFULL;
492      break;
493
494    case OPTION_EXPORT:
495      gld${EMULATION_NAME}_read_file (optarg, false);
496      break;
497
498    case OPTION_IMPORT:
499      {
500	struct filelist *n;
501	struct filelist **flpp;
502
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;
512
513    case OPTION_LOADMAP:
514      config.map_filename = optarg;
515      break;
516
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"),
521	       optarg);
522      else
523	maxdata = val;
524      break;
525
526    case OPTION_MAXSTACK:
527      val = bfd_scan_vma (optarg, &end, 0);
528      if (*end != '\0')
529	einfo (_("%P: warning: ignoring invalid -bmaxstack number %s\n"),
530	       optarg);
531      else
532	maxstack = val;
533      break;
534
535    case OPTION_MODTYPE:
536      if (*optarg == 'S')
537	{
538	  link_info.type = type_dll;
539	  ++optarg;
540	}
541      if (*optarg == '\0' || optarg[1] == '\0')
542	einfo (_("%P: warning: ignoring invalid module type %s\n"), optarg);
543      else
544	modtype = (*optarg << 8) | optarg[1];
545      break;
546
547    case OPTION_NOAUTOIMP:
548      link_info.static_link = true;
549      break;
550
551    case OPTION_NOEXPALL:
552      auto_export_flags &= ~XCOFF_EXPALL;
553      explicit_auto_export_flags |= XCOFF_EXPALL;
554      break;
555
556    case OPTION_NOEXPFULL:
557      auto_export_flags &= ~XCOFF_EXPFULL;
558      explicit_auto_export_flags |= XCOFF_EXPFULL;
559      break;
560
561    case OPTION_NOSTRCMPCT:
562      link_info.traditional_format = true;
563      break;
564
565    case OPTION_PD:
566      /* This sets the page that the .data section is supposed to
567	 start on.  The offset within the page should still be the
568	 offset within the file, so we need to build an appropriate
569	 expression.  */
570      val = bfd_scan_vma (optarg, &end, 0);
571      if (*end != '\0')
572	einfo (_("%P: warning: ignoring invalid -pD number %s\n"), optarg);
573      else
574	{
575	  etree_type *t;
576
577	  t = exp_binop ('+',
578			 exp_intop (val),
579			 exp_binop ('&',
580				    exp_nameop (NAME, "."),
581				    exp_intop (0xfff)));
582	  t = exp_binop ('&',
583			 exp_binop ('+', t, exp_intop (31)),
584			 exp_intop (~(bfd_vma) 31));
585	  lang_section_start (".data", t, NULL);
586	}
587      break;
588
589    case OPTION_PT:
590      /* This set the page that the .text section is supposed to start
591	 on.  The offset within the page should still be the offset
592	 within the file.  */
593      val = bfd_scan_vma (optarg, &end, 0);
594      if (*end != '\0')
595	einfo (_("%P: warning: ignoring invalid -pT number %s\n"), optarg);
596      else
597	{
598	  etree_type *t;
599
600	  t = exp_binop ('+',
601			 exp_intop (val),
602			 exp_nameop (SIZEOF_HEADERS, NULL));
603	  t = exp_binop ('&',
604			 exp_binop ('+', t, exp_intop (31)),
605			 exp_intop (~(bfd_vma) 31));
606	  lang_section_start (".text", t, NULL);
607	}
608      break;
609
610    case OPTION_STRCMPCT:
611      link_info.traditional_format = false;
612      break;
613
614    case OPTION_UNIX:
615      unix_ld = true;
616      break;
617
618    case OPTION_32:
619      is_64bit = 0;
620      syscall_mask = 0x77;
621      symbol_mode_mask = 0x0d;
622      break;
623
624    case OPTION_64:
625      is_64bit = 1;
626      syscall_mask = 0xcc;
627      symbol_mode_mask = 0x0e;
628      break;
629
630    case OPTION_LIBPATH:
631      command_line_blibpath = optarg;
632      break;
633
634    case OPTION_NOLIBPATH:
635      command_line_blibpath = NULL;
636      break;
637
638    }
639
640  return true;
641}
642
643/* This is called when an input file can not be recognized as a BFD
644   object or an archive.  If the file starts with #!, we must treat it
645   as an import file.  This is for AIX compatibility.  */
646
647static bool
648gld${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry)
649{
650  FILE *e;
651  bool ret;
652
653  e = fopen (entry->filename, FOPEN_RT);
654  if (e == NULL)
655    return false;
656
657  ret = false;
658
659  if (getc (e) == '#' && getc (e) == '!')
660    {
661      struct filelist *n;
662      struct filelist **flpp;
663
664      n = (struct filelist *) xmalloc (sizeof (struct filelist));
665      n->next = NULL;
666      n->name = entry->filename;
667      flpp = &import_files;
668      while (*flpp != NULL)
669	flpp = &(*flpp)->next;
670      *flpp = n;
671
672      ret = true;
673      entry->flags.loaded = true;
674    }
675
676  fclose (e);
677
678  return ret;
679}
680
681/* This is called after the input files have been opened.  */
682
683static void
684gld${EMULATION_NAME}_after_open (void)
685{
686  enum output_type t;
687  struct set_info *p;
688
689  after_open_default ();
690
691  /* Call ldctor_build_sets, after pretending that this is a
692     relocatable link.  We do this because AIX requires relocation
693     entries for all references to symbols, even in a final
694     executable.  Of course, we only want to do this if we are
695     producing an XCOFF output file.  */
696  t = link_info.type;
697  if (strstr (bfd_get_target (link_info.output_bfd), "xcoff") != NULL)
698    link_info.type = type_relocatable;
699  ldctor_build_sets ();
700  link_info.type = t;
701
702  /* For each set, record the size, so that the XCOFF backend can
703     output the correct csect length.  */
704  for (p = sets; p != (struct set_info *) NULL; p = p->next)
705    {
706      bfd_size_type size;
707
708      /* If the symbol is defined, we may have been invoked from
709	 collect, and the sets may already have been built, so we do
710	 not do anything.  */
711      if (p->h->type == bfd_link_hash_defined
712	  || p->h->type == bfd_link_hash_defweak)
713	continue;
714
715      if (p->reloc != BFD_RELOC_CTOR)
716	{
717	  /* Handle this if we need to.  */
718	  abort ();
719	}
720
721      size = (p->count + 2) * 4;
722      if (!bfd_xcoff_link_record_set (link_info.output_bfd, &link_info,
723				      p->h, size))
724	einfo (_("%F%P: bfd_xcoff_link_record_set failed: %E\n"));
725    }
726}
727
728/* This is called after the sections have been attached to output
729   sections, but before any sizes or addresses have been set.  */
730
731static void
732gld${EMULATION_NAME}_before_allocation (void)
733{
734  struct filelist *fl;
735  struct export_symbol_list *el;
736  char *libpath;
737  asection *special_sections[XCOFF_NUMBER_OF_SPECIAL_SECTIONS];
738  static const char *const must_keep_sections[] = {
739    ".text",
740    ".data",
741    ".bss"
742  };
743  unsigned int i, flags;
744
745  /* Handle the import and export files, if any.  */
746  for (fl = import_files; fl != NULL; fl = fl->next)
747    gld${EMULATION_NAME}_read_file (fl->name, true);
748  for (el = export_symbols; el != NULL; el = el->next)
749    {
750      struct bfd_link_hash_entry *h;
751
752      h = bfd_link_hash_lookup (link_info.hash, el->name, false, false, false);
753      if (h == NULL)
754	einfo (_("%F%P: bfd_link_hash_lookup of export symbol failed: %E\n"));
755      if (!bfd_xcoff_export_symbol (link_info.output_bfd, &link_info, h))
756	einfo (_("%F%P: bfd_xcoff_export_symbol failed: %E\n"));
757    }
758
759  /* Track down all relocations called for by the linker script (these
760     are typically constructor/destructor entries created by
761     CONSTRUCTORS) and let the backend know it will need to create
762     .loader relocs for them.  */
763  lang_for_each_statement (gld${EMULATION_NAME}_find_relocs);
764
765  /* Precedence of LIBPATH
766     -blibpath:	 native support always first
767     -rpath:	 gnu extension
768     -L		 build from command line -L's */
769  if (command_line_blibpath != NULL)
770    libpath = command_line_blibpath;
771  else if (command_line.rpath != NULL)
772    libpath = command_line.rpath;
773  else if (search_head == NULL)
774    libpath = (char *) "";
775  else
776    {
777      size_t len;
778      search_dirs_type *search;
779
780      /* PR ld/4023: Strip sysroot prefix from any paths
781	 being inserted into the output binary's DT_RPATH.  */
782      if (ld_sysroot != NULL
783	  && * ld_sysroot != 0)
784	{
785	  const char * name = search_head->name;
786	  size_t ld_sysroot_len = strlen (ld_sysroot);
787
788	  if (strncmp (name, ld_sysroot, ld_sysroot_len) == 0)
789	    name += ld_sysroot_len;
790
791	  len = strlen (name);
792	  libpath = xmalloc (len + 1);
793	  strcpy (libpath, name);
794
795	  for (search = search_head->next; search != NULL; search = search->next)
796	    {
797	      size_t nlen;
798
799	      name = search->name;
800	      if (strncmp (name, ld_sysroot, ld_sysroot_len) == 0)
801		name += ld_sysroot_len;
802
803	      nlen = strlen (name);
804	      libpath = xrealloc (libpath, len + nlen + 2);
805	      libpath[len] = ':';
806	      strcpy (libpath + len + 1, name);
807	      len += nlen + 1;
808	    }
809	}
810      else
811	{
812	  len = strlen (search_head->name);
813	  libpath = xmalloc (len + 1);
814	  strcpy (libpath, search_head->name);
815
816	  for (search = search_head->next; search != NULL; search = search->next)
817	    {
818	      size_t nlen;
819
820	      nlen = strlen (search->name);
821	      libpath = xrealloc (libpath, len + nlen + 2);
822	      libpath[len] = ':';
823	      strcpy (libpath + len + 1, search->name);
824	      len += nlen + 1;
825	    }
826	}
827    }
828
829  /* Default to -bexpfull for SVR4-like semantics.  */
830  flags = (unix_ld ? XCOFF_EXPFULL : 0);
831  flags &= ~explicit_auto_export_flags;
832  flags |= auto_export_flags;
833
834  /* Let the XCOFF backend set up the .loader section.  */
835  if (!bfd_xcoff_size_dynamic_sections
836      (link_info.output_bfd, &link_info, libpath, entry_symbol.name,
837       file_align, maxstack, maxdata, gc && !unix_ld,
838       modtype, textro, flags, special_sections, rtld))
839    einfo (_("%F%P: failed to set dynamic section sizes: %E\n"));
840
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      bool start;
851
852      sec = special_sections[i];
853      if (sec == NULL)
854	continue;
855
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_get (sec->output_section);
860      if (os == NULL)
861	einfo (_("%F%P: can't find output section %s\n"),
862	       sec->output_section->name);
863
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	    }
873
874	  if ((*pls)->header.type == lang_wild_statement_enum)
875	    {
876	      lang_statement_union_type **pwls;
877
878	      for (pwls = &(*pls)->wild_statement.children.head;
879		   *pwls != NULL; pwls = &(*pwls)->header.next)
880		{
881
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		}
890
891	      if (is != NULL)
892		break;
893	    }
894	}
895
896      if (is == NULL)
897	{
898	  einfo (_("%F%P: can't find %s in output section\n"),
899		 bfd_section_name (sec));
900	}
901
902      /* Now figure out where the section should go.  */
903      switch (i)
904	{
905
906	default:		/* to avoid warnings */
907	case XCOFF_SPECIAL_SECTION_TEXT:
908	  /* _text */
909	  oname = ".text";
910	  start = true;
911	  break;
912
913	case XCOFF_SPECIAL_SECTION_ETEXT:
914	  /* _etext */
915	  oname = ".text";
916	  start = false;
917	  break;
918
919	case XCOFF_SPECIAL_SECTION_DATA:
920	  /* _data */
921	  oname = ".data";
922	  start = true;
923	  break;
924
925	case XCOFF_SPECIAL_SECTION_EDATA:
926	  /* _edata */
927	  oname = ".data";
928	  start = false;
929	  break;
930
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	}
938
939      os = lang_output_section_find (oname);
940
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	  *os->children.tail = (lang_statement_union_type *) is;
950	  os->children.tail = &is->header.next;
951	}
952    }
953
954  /* Executables and shared objects must always have .text, .data
955     and .bss output sections, so that the header can refer to them.
956     The kernel refuses to load objects that have missing sections.  */
957  if (!bfd_link_relocatable (&link_info))
958    for (i = 0; i < ARRAY_SIZE (must_keep_sections); i++)
959      {
960	asection *sec;
961
962	sec = bfd_get_section_by_name (link_info.output_bfd,
963				       must_keep_sections[i]);
964	if (sec == NULL)
965	  einfo (_("%P: can't find required output section %s\n"),
966		 must_keep_sections[i]);
967	else
968	  sec->flags |= SEC_KEEP;
969      }
970
971  /* Make sure .tdata is removed if empty, even with -r flag.
972     .tdata is always being generated because its size is needed
973     to cumpute .data address.  */
974  if (bfd_link_relocatable (&link_info))
975    {
976      static const char *const thread_sections[] = {
977	".tdata",
978	".tbss"
979      };
980
981      /* Run lang_size_sections (if not already done).  */
982      if (expld.phase != lang_mark_phase_enum)
983	{
984	  expld.phase = lang_mark_phase_enum;
985	  expld.dataseg.phase = exp_seg_none;
986	  one_lang_size_sections_pass (NULL, false);
987	  lang_reset_memory_regions ();
988	}
989
990      for (i = 0; i < ARRAY_SIZE (thread_sections); i++)
991	{
992	  asection *sec;
993
994	  sec = bfd_get_section_by_name (link_info.output_bfd,
995					 thread_sections[i]);
996
997	  if (sec != NULL && sec->rawsize == 0
998	      && (sec->flags & SEC_KEEP) == 0
999	      && !bfd_section_removed_from_list (link_info.output_bfd,
1000						 sec))
1001	    {
1002	      sec->flags |= SEC_EXCLUDE;
1003	      bfd_section_list_remove (link_info.output_bfd, sec);
1004	      link_info.output_bfd->section_count--;
1005	    }
1006	}
1007    }
1008
1009  before_allocation_default ();
1010}
1011
1012static char *
1013gld${EMULATION_NAME}_choose_target (int argc, char **argv)
1014{
1015  int i, j, jmax;
1016  static char *from_outside;
1017  static char *from_inside;
1018  static char *argv_to_target[][2] = {
1019    {NULL,   "${OUTPUT_FORMAT}"},
1020    {"-b32", "${OUTPUT_FORMAT_32BIT}"},
1021    {"-b64", "${OUTPUT_FORMAT_64BIT}"},
1022  };
1023
1024  jmax = 3;
1025
1026  from_outside = getenv (TARGET_ENVIRON);
1027  if (from_outside != (char *) NULL)
1028    return from_outside;
1029
1030  /* Set to default. */
1031  from_inside = argv_to_target[0][1];
1032  for (i = 1; i < argc; i++)
1033    {
1034      for (j = 1; j < jmax; j++)
1035	{
1036	  if (0 == strcmp (argv[i], argv_to_target[j][0]))
1037	    from_inside = argv_to_target[j][1];
1038	}
1039    }
1040
1041  return from_inside;
1042}
1043
1044/* Returns
1045   1 : state changed
1046   0 : no change */
1047static int
1048change_symbol_mode (char *input)
1049{
1050  char *symbol_mode_string[] = {
1051    "# 32",			/* 0x01 */
1052    "# 64",			/* 0x02 */
1053    "# no32",			/* 0x04 */
1054    "# no64",			/* 0x08 */
1055    NULL,
1056  };
1057
1058  unsigned int bit;
1059  char *string;
1060
1061  for (bit = 0;; bit++)
1062    {
1063      string = symbol_mode_string[bit];
1064      if (string == NULL)
1065	return 0;
1066
1067      if (0 == strcmp (input, string))
1068	{
1069	  symbol_mode = (1 << bit);
1070	  return 1;
1071	}
1072    }
1073  /* should not be here */
1074  return 0;
1075}
1076
1077/* Returns
1078   1 : yes
1079   0 : ignore
1080   -1 : error, try something else */
1081static int
1082is_syscall (char *input, unsigned int *flag)
1083{
1084  unsigned int bit;
1085  char *string;
1086
1087  struct sc {
1088    char *syscall_string;
1089    unsigned int flag;
1090  } s [] = {
1091    { "svc"	    /* 0x01 */, XCOFF_SYSCALL32 },
1092    { "svc32"	    /* 0x02 */, XCOFF_SYSCALL32 },
1093    { "svc3264"     /* 0x04 */, XCOFF_SYSCALL32 | XCOFF_SYSCALL64 },
1094    { "svc64"	    /* 0x08 */, XCOFF_SYSCALL64 },
1095    { "syscall"     /* 0x10 */, XCOFF_SYSCALL32 },
1096    { "syscall32"   /* 0x20 */, XCOFF_SYSCALL32 },
1097    { "syscall3264" /* 0x40 */, XCOFF_SYSCALL32 | XCOFF_SYSCALL64 },
1098    { "syscall64"   /* 0x80 */, XCOFF_SYSCALL64 },
1099    { NULL, 0 },
1100  };
1101
1102  *flag = 0;
1103
1104  for (bit = 0;; bit++)
1105    {
1106      string = s[bit].syscall_string;
1107      if (string == NULL)
1108	return -1;
1109
1110      if (0 == strcmp (input, string))
1111	{
1112	  if (1 << bit & syscall_mask)
1113	    {
1114	      *flag = s[bit].flag;
1115	      return 1;
1116	    }
1117	  else
1118	    {
1119	      return 0;
1120	    }
1121	}
1122    }
1123  /* should not be here */
1124  return -1;
1125}
1126
1127/* Read an import or export file.  For an import file, this is called
1128   by the before_allocation emulation routine.  For an export file,
1129   this is called by the handle_option emulation routine.  */
1130
1131static void
1132gld${EMULATION_NAME}_read_file (const char *filename, bool import)
1133{
1134  struct obstack *o;
1135  FILE *f;
1136  int lineno;
1137  int c;
1138  bool keep;
1139  const char *imppath;
1140  const char *impfile;
1141  const char *impmember;
1142
1143  o = (struct obstack *) xmalloc (sizeof (struct obstack));
1144  obstack_specify_allocation (o, 0, 0, xmalloc, gld${EMULATION_NAME}_free);
1145
1146  f = fopen (filename, FOPEN_RT);
1147  if (f == NULL)
1148    {
1149      bfd_set_error (bfd_error_system_call);
1150      einfo ("%F%P: %s: %E\n", filename);
1151      return;
1152    }
1153
1154  keep = false;
1155
1156  imppath = NULL;
1157  impfile = NULL;
1158  impmember = NULL;
1159
1160  lineno = 0;
1161
1162  /* Default to 32 and 64 bit mode
1163     symbols at top of /lib/syscalls.exp do not have a mode modifier and they
1164     are not repeated, assume 64 bit routines also want to use them.
1165     See the routine change_symbol_mode for more information.  */
1166
1167  symbol_mode = 0x04;
1168
1169  while ((c = getc (f)) != EOF)
1170    {
1171      char *s;
1172      char *symname;
1173      unsigned int syscall_flag = 0;
1174      bfd_vma address;
1175      struct bfd_link_hash_entry *h;
1176
1177      if (c != '\n')
1178	{
1179	  obstack_1grow (o, c);
1180	  continue;
1181	}
1182
1183      obstack_1grow (o, '\0');
1184      ++lineno;
1185
1186      s = (char *) obstack_base (o);
1187      while (ISSPACE (*s))
1188	++s;
1189      if (*s == '\0'
1190	  || *s == '*'
1191	  || change_symbol_mode (s)
1192	  || (*s == '#' && s[1] == ' ')
1193	  || (!import && *s == '#' && s[1] == '!'))
1194	{
1195	  obstack_free (o, obstack_base (o));
1196	  continue;
1197	}
1198
1199      if (*s == '#' && s[1] == '!')
1200	{
1201	  s += 2;
1202	  while (ISSPACE (*s))
1203	    ++s;
1204	  if (*s == '\0')
1205	    {
1206	      imppath = NULL;
1207	      impfile = NULL;
1208	      impmember = NULL;
1209	      obstack_free (o, obstack_base (o));
1210	    }
1211	  else if (*s == '(')
1212	    einfo (_("%F%P:%s:%d: #! ([member]) is not supported "
1213		     "in import files\n"),
1214		   filename, lineno);
1215	  else
1216	    {
1217	      char cs;
1218	      char *start;
1219
1220	      (void) obstack_finish (o);
1221	      keep = true;
1222	      start = s;
1223	      while (!ISSPACE (*s) && *s != '(' && *s != '\0')
1224		++s;
1225	      cs = *s;
1226	      *s = '\0';
1227	      if (!bfd_xcoff_split_import_path (link_info.output_bfd,
1228						start, &imppath, &impfile))
1229		einfo (_("%F%P: could not parse import path: %E\n"));
1230	      while (ISSPACE (cs))
1231		{
1232		  ++s;
1233		  cs = *s;
1234		}
1235	      if (cs != '(')
1236		{
1237		  impmember = "";
1238		  if (cs != '\0')
1239		    einfo (_("%P:%s:%d: warning: syntax error in import file\n"),
1240			   filename, lineno);
1241		}
1242	      else
1243		{
1244		  ++s;
1245		  impmember = s;
1246		  while (*s != ')' && *s != '\0')
1247		    ++s;
1248		  if (*s == ')')
1249		    *s = '\0';
1250		  else
1251		    einfo (_("%P:%s:%d: warning: syntax error in import file\n"),
1252			   filename, lineno);
1253		}
1254	    }
1255
1256	  continue;
1257	}
1258
1259      if (symbol_mode & symbol_mode_mask)
1260	{
1261	  /* This is a symbol to be imported or exported.  */
1262	  symname = s;
1263	  syscall_flag = 0;
1264	  address = (bfd_vma) -1;
1265
1266	  while (!ISSPACE (*s) && *s != '\0')
1267	    ++s;
1268	  if (*s != '\0')
1269	    {
1270	      char *se;
1271
1272	      *s++ = '\0';
1273
1274	      while (ISSPACE (*s))
1275		++s;
1276
1277	      se = s;
1278	      while (!ISSPACE (*se) && *se != '\0')
1279		++se;
1280	      if (*se != '\0')
1281		{
1282		  *se++ = '\0';
1283		  while (ISSPACE (*se))
1284		    ++se;
1285		  if (*se != '\0')
1286		    einfo (_("%P:%s%d: warning: syntax error in "
1287			     "import/export file\n"),
1288			   filename, lineno);
1289		}
1290
1291	      if (s != se)
1292		{
1293		  int status;
1294		  const char *end;
1295
1296		  status = is_syscall (s, &syscall_flag);
1297
1298		  if (0 > status)
1299		    {
1300		      /* not a system call, check for address */
1301		      address = bfd_scan_vma (s, &end, 0);
1302		      if (*end != '\0')
1303			{
1304			  einfo (_("%P:%s:%d: warning: syntax error in "
1305				   "import/export file\n"),
1306				 filename, lineno);
1307
1308			}
1309		    }
1310		}
1311	    }
1312
1313	  if (!import)
1314	    {
1315	      struct export_symbol_list *n;
1316
1317	      ldlang_add_undef (symname, true);
1318	      n = ((struct export_symbol_list *)
1319		   xmalloc (sizeof (struct export_symbol_list)));
1320	      n->next = export_symbols;
1321	      n->name = xstrdup (symname);
1322	      export_symbols = n;
1323	    }
1324	  else
1325	    {
1326	      h = bfd_link_hash_lookup (link_info.hash, symname, false, false,
1327					true);
1328	      if (h == NULL || h->type == bfd_link_hash_new)
1329		{
1330		  /* We can just ignore attempts to import an unreferenced
1331		     symbol.  */
1332		}
1333	      else
1334		{
1335		  if (!bfd_xcoff_import_symbol (link_info.output_bfd,
1336						&link_info, h,
1337						address, imppath, impfile,
1338						impmember, syscall_flag))
1339		    einfo (_("%X%P:%s:%d: failed to import symbol %s: %E\n"),
1340			   filename, lineno, symname);
1341		}
1342	    }
1343	}
1344      obstack_free (o, obstack_base (o));
1345    }
1346
1347  if (obstack_object_size (o) > 0)
1348    {
1349      einfo (_("%P:%s:%d: warning: ignoring unterminated last line\n"),
1350	     filename, lineno);
1351      obstack_free (o, obstack_base (o));
1352    }
1353
1354  if (!keep)
1355    {
1356      obstack_free (o, NULL);
1357      free (o);
1358    }
1359
1360  fclose (f);
1361}
1362
1363/* This routine saves us from worrying about declaring free.  */
1364
1365static void
1366gld${EMULATION_NAME}_free (void *p)
1367{
1368  free (p);
1369}
1370
1371/* This is called by the before_allocation routine via
1372   lang_for_each_statement.  It looks for relocations and assignments
1373   to symbols.  */
1374
1375static void
1376gld${EMULATION_NAME}_find_relocs (lang_statement_union_type *s)
1377{
1378  if (s->header.type == lang_reloc_statement_enum)
1379    {
1380      lang_reloc_statement_type *rs;
1381
1382      rs = &s->reloc_statement;
1383      if (rs->name == NULL)
1384	einfo (_("%F%P: only relocations against symbols are permitted\n"));
1385      if (!bfd_xcoff_link_count_reloc (link_info.output_bfd, &link_info,
1386				       rs->name))
1387	einfo (_("%F%P: bfd_xcoff_link_count_reloc failed: %E\n"));
1388    }
1389
1390  if (s->header.type == lang_assignment_statement_enum)
1391    gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1392}
1393
1394/* Look through an expression for an assignment statement.  */
1395
1396static void
1397gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1398{
1399  struct bfd_link_hash_entry *h;
1400
1401  switch (exp->type.node_class)
1402    {
1403    case etree_provide:
1404    case etree_provided:
1405      h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
1406				false, false, false);
1407      if (h == NULL)
1408	break;
1409      /* Fall through.  */
1410    case etree_assign:
1411      if (strcmp (exp->assign.dst, ".") != 0)
1412	{
1413	  if (!bfd_xcoff_record_link_assignment (link_info.output_bfd,
1414						 &link_info,
1415						 exp->assign.dst))
1416	    einfo (_("%F%P: failed to record assignment to %s: %E\n"),
1417		   exp->assign.dst);
1418	}
1419      gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1420      break;
1421
1422    case etree_binary:
1423      gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1424      gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1425      break;
1426
1427    case etree_trinary:
1428      gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1429      gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1430      gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1431      break;
1432
1433    case etree_unary:
1434      gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1435      break;
1436
1437    default:
1438      break;
1439    }
1440}
1441
1442static char *
1443gld${EMULATION_NAME}_get_script (int *isfile)
1444EOF
1445
1446if test x"$COMPILE_IN" = xyes
1447then
1448# Scripts compiled in.
1449
1450# sed commands to quote an ld script as a C string.
1451sc="-f ${srcdir}/emultempl/ostring.sed"
1452
1453fragment <<EOF
1454{
1455  *isfile = 0;
1456
1457  if (bfd_link_relocatable (&link_info) && config.build_constructors)
1458    return
1459EOF
1460sed $sc ldscripts/${EMULATION_NAME}.xu		       >> e${EMULATION_NAME}.c
1461echo '  ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c
1462sed $sc ldscripts/${EMULATION_NAME}.xr		       >> e${EMULATION_NAME}.c
1463echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
1464sed $sc ldscripts/${EMULATION_NAME}.xbn		       >> e${EMULATION_NAME}.c
1465echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1466sed $sc ldscripts/${EMULATION_NAME}.xn		       >> e${EMULATION_NAME}.c
1467echo '  ; else return'				       >> e${EMULATION_NAME}.c
1468sed $sc ldscripts/${EMULATION_NAME}.x		       >> e${EMULATION_NAME}.c
1469echo '; }'					       >> e${EMULATION_NAME}.c
1470
1471else
1472# Scripts read from the filesystem.
1473
1474fragment <<EOF
1475{
1476  *isfile = 1;
1477
1478  if (bfd_link_relocatable (&link_info) && config.build_constructors)
1479    return "ldscripts/${EMULATION_NAME}.xu";
1480  else if (bfd_link_relocatable (&link_info))
1481    return "ldscripts/${EMULATION_NAME}.xr";
1482  else if (!config.text_read_only)
1483    return "ldscripts/${EMULATION_NAME}.xbn";
1484  else if (!config.magic_demand_paged)
1485    return "ldscripts/${EMULATION_NAME}.xn";
1486  else
1487    return "ldscripts/${EMULATION_NAME}.x";
1488}
1489EOF
1490
1491fi
1492
1493fragment <<EOF
1494
1495static void
1496gld${EMULATION_NAME}_create_output_section_statements (void)
1497{
1498  /* __rtinit */
1499  if ((bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour)
1500      && (link_info.init_function != NULL
1501	  || link_info.fini_function != NULL
1502	  || rtld))
1503    {
1504      initfini_file = lang_add_input_file ("initfini",
1505					   lang_input_file_is_file_enum,
1506					   NULL);
1507
1508      initfini_file->the_bfd = bfd_create ("initfini", link_info.output_bfd);
1509      if (initfini_file->the_bfd == NULL
1510	  || ! bfd_set_arch_mach (initfini_file->the_bfd,
1511				  bfd_get_arch (link_info.output_bfd),
1512				  bfd_get_mach (link_info.output_bfd)))
1513	{
1514	  einfo (_("%F%P: can not create BFD: %E\n"));
1515	  return;
1516	}
1517
1518      /* Call backend to fill in the rest */
1519      if (! bfd_xcoff_link_generate_rtinit (initfini_file->the_bfd,
1520					    link_info.init_function,
1521					    link_info.fini_function,
1522					    rtld))
1523	{
1524	  einfo (_("%F%P: can not create BFD: %E\n"));
1525	  return;
1526	}
1527
1528      /* __rtld defined in /lib/librtl.a */
1529      if (rtld)
1530	lang_add_input_file ("rtl", lang_input_file_is_l_enum, NULL);
1531    }
1532}
1533
1534static void
1535gld${EMULATION_NAME}_set_output_arch (void)
1536{
1537  bfd_set_arch_mach (link_info.output_bfd,
1538		     bfd_xcoff_architecture (link_info.output_bfd),
1539		     bfd_xcoff_machine (link_info.output_bfd));
1540
1541  ldfile_output_architecture = bfd_get_arch (link_info.output_bfd);
1542  ldfile_output_machine = bfd_get_mach (link_info.output_bfd);
1543  ldfile_output_machine_name = bfd_printable_name (link_info.output_bfd);
1544}
1545
1546static bool
1547gld${EMULATION_NAME}_open_dynamic_archive (const char *arch,
1548					   search_dirs_type *search,
1549					   lang_input_statement_type *entry)
1550{
1551  char *path;
1552
1553  if (!entry->flags.maybe_archive)
1554    return false;
1555
1556  if (entry->flags.full_name_provided)
1557    path = concat (search->name, "/", entry->filename,
1558		   (const char *) NULL);
1559  else
1560    path = concat (search->name, "/lib", entry->filename, arch, ".a",
1561		   (const char *) NULL);
1562
1563  if (!ldfile_try_open_bfd (path, entry))
1564    {
1565      free (path);
1566      return false;
1567    }
1568  /* Don't include the searched directory in the import path.  */
1569  bfd_xcoff_set_archive_import_path (&link_info, entry->the_bfd,
1570				     path + strlen (search->name) + 1);
1571  entry->filename = path;
1572  return true;
1573}
1574
1575static bool
1576gld${EMULATION_NAME}_print_symbol (struct bfd_link_hash_entry *hash_entry,
1577				   void *ptr)
1578{
1579  asection *sec = (asection *) ptr;
1580
1581  if ((hash_entry->type == bfd_link_hash_defined
1582       || hash_entry->type == bfd_link_hash_defweak)
1583      && sec == hash_entry->u.def.section)
1584    {
1585      int i;
1586      struct xcoff_link_hash_entry *h;
1587
1588      for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
1589	print_space ();
1590      minfo ("0x%V   ",
1591	     (hash_entry->u.def.value
1592	      + hash_entry->u.def.section->output_offset
1593	      + hash_entry->u.def.section->output_section->vma));
1594
1595      /* Flag symbol if it has been garbage collected.  */
1596      h = (struct xcoff_link_hash_entry *) hash_entry;
1597      if ((h != NULL) && !(h->flags & XCOFF_MARK))
1598	minfo (" -->gc");
1599      minfo ("             %pT\n", hash_entry->root.string);
1600    }
1601
1602  return true;
1603}
1604
1605struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation = {
1606  gld${EMULATION_NAME}_before_parse,
1607  syslib_default,
1608  hll_default,
1609  after_parse_default,
1610  gld${EMULATION_NAME}_after_open,
1611  after_check_relocs_default,
1612  before_place_orphans_default,
1613  after_allocation_default,
1614  gld${EMULATION_NAME}_set_output_arch,
1615  gld${EMULATION_NAME}_choose_target,
1616  gld${EMULATION_NAME}_before_allocation,
1617  gld${EMULATION_NAME}_get_script,
1618  "${EMULATION_NAME}",
1619  "${OUTPUT_FORMAT}",
1620  finish_default,
1621  gld${EMULATION_NAME}_create_output_section_statements,
1622  gld${EMULATION_NAME}_open_dynamic_archive,
1623  0,				/* place_orphan */
1624  0,				/* set_symbols */
1625  gld${EMULATION_NAME}_parse_args,
1626  gld${EMULATION_NAME}_add_options,
1627  gld${EMULATION_NAME}_handle_option,
1628  gld${EMULATION_NAME}_unrecognized_file,
1629  NULL,				/* list_options */
1630  NULL,				/* recognized_file */
1631  NULL,				/* find potential_libraries */
1632  NULL,				/* new_vers_pattern */
1633  NULL,				/* extra_map_file_text */
1634  ${LDEMUL_EMIT_CTF_EARLY-NULL},
1635  ${LDEMUL_ACQUIRE_STRINGS_FOR_CTF-NULL},
1636  ${LDEMUL_NEW_DYNSYM_FOR_CTF-NULL},
1637  gld${EMULATION_NAME}_print_symbol
1638};
1639EOF
1640