ld/emultempl/aix.em

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