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