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