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, 2010
  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   after_open_default ();
 612
 613   /* Call ldctor_build_sets, after pretending that this is a
 614      relocatable link.  We do this because AIX requires relocation
 615      entries for all references to symbols, even in a final
 616      executable.  Of course, we only want to do this if we are
 617      producing an XCOFF output file.  */
 618   r = link_info.relocatable;
 619   if (strstr (bfd_get_target (link_info.output_bfd), "xcoff") != NULL)
 620     link_info.relocatable = TRUE;
 621   ldctor_build_sets ();
 622   link_info.relocatable = r;
 623
 624   /* For each set, record the size, so that the XCOFF backend can
 625      output the correct csect length.  */
 626   for (p = sets; p != (struct set_info *) NULL; p = p->next)
 627     {
 628       bfd_size_type size;
 629
 630       /* If the symbol is defined, we may have been invoked from
 631          collect, and the sets may already have been built, so we do
 632          not do anything.  */
 633       if (p->h->type == bfd_link_hash_defined
 634           || p->h->type == bfd_link_hash_defweak)
 635         continue;
 636
 637       if (p->reloc != BFD_RELOC_CTOR)
 638         {
 639           /* Handle this if we need to.  */
 640           abort ();
 641         }
 642
 643       size = (p->count + 2) * 4;
 644       if (!bfd_xcoff_link_record_set (link_info.output_bfd, &link_info,
 645                                       p->h, size))
 646         einfo ("%F%P: bfd_xcoff_link_record_set failed: %E\n");
 647     }
 648 }
 649
 650 /* This is called after the sections have been attached to output
 651    sections, but before any sizes or addresses have been set.  */
 652
 653 static void
 654 gld${EMULATION_NAME}_before_allocation (void)
 655 {
 656   struct filelist *fl;
 657   struct export_symbol_list *el;
 658   char *libpath;
 659   asection *special_sections[XCOFF_NUMBER_OF_SPECIAL_SECTIONS];
 660   static const char *const must_keep_sections[] = {
 661     ".text",
 662     ".data",
 663     ".bss"
 664   };
 665   unsigned int i, flags;
 666
 667   /* Handle the import and export files, if any.  */
 668   for (fl = import_files; fl != NULL; fl = fl->next)
 669     gld${EMULATION_NAME}_read_file (fl->name, TRUE);
 670   for (el = export_symbols; el != NULL; el = el->next)
 671     {
 672       struct bfd_link_hash_entry *h;
 673
 674       h = bfd_link_hash_lookup (link_info.hash, el->name, FALSE, FALSE, FALSE);
 675       if (h == NULL)
 676         einfo ("%P%F: bfd_link_hash_lookup of export symbol failed: %E\n");
 677       if (!bfd_xcoff_export_symbol (link_info.output_bfd, &link_info, h))
 678         einfo ("%P%F: bfd_xcoff_export_symbol failed: %E\n");
 679     }
 680
 681   /* Track down all relocations called for by the linker script (these
 682      are typically constructor/destructor entries created by
 683      CONSTRUCTORS) and let the backend know it will need to create
 684      .loader relocs for them.  */
 685   lang_for_each_statement (gld${EMULATION_NAME}_find_relocs);
 686
 687   /* Precedence of LIBPATH
 688      -blibpath:  native support always first
 689      -rpath:     gnu extension
 690      -L          build from command line -L's */
 691   if (command_line_blibpath != NULL)
 692     libpath = command_line_blibpath;
 693   else if (command_line.rpath != NULL)
 694     libpath = command_line.rpath;
 695   else if (search_head == NULL)
 696     libpath = (char *) "";
 697   else
 698     {
 699       size_t len;
 700       search_dirs_type *search;
 701
 702       /* PR ld/4023: Strip sysroot prefix from any paths
 703          being inserted into the output binary's DT_RPATH.  */
 704       if (ld_sysroot != NULL
 705           && * ld_sysroot != 0)
 706         {
 707           const char * name = search_head->name;
 708           size_t ld_sysroot_len = strlen (ld_sysroot);
 709
 710           if (strncmp (name, ld_sysroot, ld_sysroot_len) == 0)
 711             name += ld_sysroot_len;
 712
 713           len = strlen (name);
 714           libpath = xmalloc (len + 1);
 715           strcpy (libpath, name);
 716
 717           for (search = search_head->next; search != NULL; search = search->next)
 718             {
 719               size_t nlen;
 720
 721               name = search->name;
 722               if (strncmp (name, ld_sysroot, ld_sysroot_len) == 0)
 723                 name += ld_sysroot_len;
 724
 725               nlen = strlen (name);
 726               libpath = xrealloc (libpath, len + nlen + 2);
 727               libpath[len] = ':';
 728               strcpy (libpath + len + 1, name);
 729               len += nlen + 1;
 730             }
 731         }
 732       else
 733         {
 734           len = strlen (search_head->name);
 735           libpath = xmalloc (len + 1);
 736           strcpy (libpath, search_head->name);
 737
 738           for (search = search_head->next; search != NULL; search = search->next)
 739             {
 740               size_t nlen;
 741
 742               nlen = strlen (search->name);
 743               libpath = xrealloc (libpath, len + nlen + 2);
 744               libpath[len] = ':';
 745               strcpy (libpath + len + 1, search->name);
 746               len += nlen + 1;
 747             }
 748         }
 749     }
 750
 751   /* Default to -bexpfull for SVR4-like semantics.  */
 752   flags = (unix_ld ? XCOFF_EXPFULL : 0);
 753   flags &= ~explicit_auto_export_flags;
 754   flags |= auto_export_flags;
 755
 756   /* Let the XCOFF backend set up the .loader section.  */
 757   if (!bfd_xcoff_size_dynamic_sections
 758       (link_info.output_bfd, &link_info, libpath, entry_symbol.name, file_align,
 759        maxstack, maxdata, gc && !unix_ld ? TRUE : FALSE,
 760        modtype, textro ? TRUE : FALSE, flags, special_sections,
 761        rtld ? TRUE : FALSE))
 762     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
 763
 764   /* Look through the special sections, and put them in the right
 765      place in the link ordering.  This is especially magic.  */
 766   for (i = 0; i < XCOFF_NUMBER_OF_SPECIAL_SECTIONS; i++)
 767     {
 768       asection *sec;
 769       lang_output_section_statement_type *os;
 770       lang_statement_union_type **pls;
 771       lang_input_section_type *is;
 772       const char *oname;
 773       bfd_boolean start;
 774
 775       sec = special_sections[i];
 776       if (sec == NULL)
 777         continue;
 778
 779       /* Remove this section from the list of the output section.
 780          This assumes we know what the script looks like.  */
 781       is = NULL;
 782       os = lang_output_section_find (sec->output_section->name);
 783       if (os == NULL)
 784         einfo ("%P%F: can't find output section %s\n",
 785                sec->output_section->name);
 786
 787       for (pls = &os->children.head; *pls != NULL; pls = &(*pls)->header.next)
 788         {
 789           if ((*pls)->header.type == lang_input_section_enum
 790               && (*pls)->input_section.section == sec)
 791             {
 792               is = (lang_input_section_type *) * pls;
 793               *pls = (*pls)->header.next;
 794               break;
 795             }
 796
 797           if ((*pls)->header.type == lang_wild_statement_enum)
 798             {
 799               lang_statement_union_type **pwls;
 800
 801               for (pwls = &(*pls)->wild_statement.children.head;
 802                    *pwls != NULL; pwls = &(*pwls)->header.next)
 803                 {
 804
 805                   if ((*pwls)->header.type == lang_input_section_enum
 806                       && (*pwls)->input_section.section == sec)
 807                     {
 808                       is = (lang_input_section_type *) * pwls;
 809                       *pwls = (*pwls)->header.next;
 810                       break;
 811                     }
 812                 }
 813
 814               if (is != NULL)
 815                 break;
 816             }
 817         }
 818
 819       if (is == NULL)
 820         {
 821           einfo ("%P%F: can't find %s in output section\n",
 822                  bfd_get_section_name (sec->owner, sec));
 823         }
 824
 825       /* Now figure out where the section should go.  */
 826       switch (i)
 827         {
 828
 829         default:                /* to avoid warnings */
 830         case XCOFF_SPECIAL_SECTION_TEXT:
 831           /* _text */
 832           oname = ".text";
 833           start = TRUE;
 834           break;
 835
 836         case XCOFF_SPECIAL_SECTION_ETEXT:
 837           /* _etext */
 838           oname = ".text";
 839           start = FALSE;
 840           break;
 841
 842         case XCOFF_SPECIAL_SECTION_DATA:
 843           /* _data */
 844           oname = ".data";
 845           start = TRUE;
 846           break;
 847
 848         case XCOFF_SPECIAL_SECTION_EDATA:
 849           /* _edata */
 850           oname = ".data";
 851           start = FALSE;
 852           break;
 853
 854         case XCOFF_SPECIAL_SECTION_END:
 855         case XCOFF_SPECIAL_SECTION_END2:
 856           /* _end and end */
 857           oname = ".bss";
 858           start = FALSE;
 859           break;
 860         }
 861
 862       os = lang_output_section_find (oname);
 863
 864       if (start)
 865         {
 866           is->header.next = os->children.head;
 867           os->children.head = (lang_statement_union_type *) is;
 868         }
 869       else
 870         {
 871           is->header.next = NULL;
 872           lang_statement_append (&os->children,
 873                                  (lang_statement_union_type *) is,
 874                                  &is->header.next);
 875         }
 876     }
 877
 878   /* Executables and shared objects must always have .text, .data
 879      and .bss output sections, so that the header can refer to them.
 880      The kernel refuses to load objects that have missing sections.  */
 881   if (!link_info.relocatable)
 882     for (i = 0; i < ARRAY_SIZE (must_keep_sections); i++)
 883       {
 884         asection *sec;
 885
 886         sec = bfd_get_section_by_name (link_info.output_bfd,
 887                                        must_keep_sections[i]);
 888         if (sec == NULL)
 889           einfo ("%P: can't find required output section %s\n", must_keep_sections[i]);
 890         else
 891           sec->flags |= SEC_KEEP;
 892       }
 893
 894   before_allocation_default ();
 895 }
 896
 897 static char *
 898 gld${EMULATION_NAME}_choose_target (int argc, char **argv)
 899 {
 900   int i, j, jmax;
 901   static char *from_outside;
 902   static char *from_inside;
 903   static char *argv_to_target[][2] = {
 904     {NULL,   "${OUTPUT_FORMAT}"},
 905     {"-b32", "${OUTPUT_FORMAT_32BIT}"},
 906     {"-b64", "${OUTPUT_FORMAT_64BIT}"},
 907   };
 908
 909   jmax = 3;
 910
 911   from_outside = getenv (TARGET_ENVIRON);
 912   if (from_outside != (char *) NULL)
 913     return from_outside;
 914
 915   /* Set to default. */
 916   from_inside = argv_to_target[0][1];
 917   for (i = 1; i < argc; i++)
 918     {
 919       for (j = 1; j < jmax; j++)
 920         {
 921           if (0 == strcmp (argv[i], argv_to_target[j][0]))
 922             from_inside = argv_to_target[j][1];
 923         }
 924     }
 925
 926   return from_inside;
 927 }
 928
 929 /* Returns
 930    1 : state changed
 931    0 : no change */
 932 static int
 933 change_symbol_mode (char *input)
 934 {
 935   char *symbol_mode_string[] = {
 936     "# 32",                     /* 0x01 */
 937     "# 64",                     /* 0x02 */
 938     "# no32",                   /* 0x04 */
 939     "# no64",                   /* 0x08 */
 940     NULL,
 941   };
 942
 943   unsigned int bit;
 944   char *string;
 945
 946   for (bit = 0;; bit++)
 947     {
 948       string = symbol_mode_string[bit];
 949       if (string == NULL)
 950         return 0;
 951
 952       if (0 == strcmp (input, string))
 953         {
 954           symbol_mode = (1 << bit);
 955           return 1;
 956         }
 957     }
 958   /* should not be here */
 959   return 0;
 960 }
 961
 962 /* Returns
 963    1 : yes
 964    0 : ignore
 965    -1 : error, try something else */
 966 static int
 967 is_syscall (char *input, unsigned int *flag)
 968 {
 969   unsigned int bit;
 970   char *string;
 971
 972   struct sc {
 973     char *syscall_string;
 974     unsigned int flag;
 975   } s [] = {
 976     { "svc"         /* 0x01 */, XCOFF_SYSCALL32 },
 977     { "svc32"       /* 0x02 */, XCOFF_SYSCALL32 },
 978     { "svc3264"     /* 0x04 */, XCOFF_SYSCALL32 | XCOFF_SYSCALL64 },
 979     { "svc64"       /* 0x08 */, XCOFF_SYSCALL64 },
 980     { "syscall"     /* 0x10 */, XCOFF_SYSCALL32 },
 981     { "syscall32"   /* 0x20 */, XCOFF_SYSCALL32 },
 982     { "syscall3264" /* 0x40 */, XCOFF_SYSCALL32 | XCOFF_SYSCALL64 },
 983     { "syscall64"   /* 0x80 */, XCOFF_SYSCALL64 },
 984     { NULL, 0 },
 985   };
 986
 987   *flag = 0;
 988
 989   for (bit = 0;; bit++)
 990     {
 991       string = s[bit].syscall_string;
 992       if (string == NULL)
 993         return -1;
 994
 995       if (0 == strcmp (input, string))
 996         {
 997           if (1 << bit & syscall_mask)
 998             {
 999               *flag = s[bit].flag;
1000               return 1;
1001             }
1002           else
1003             {
1004               return 0;
1005             }
1006         }
1007     }
1008   /* should not be here */
1009   return -1;
1010 }
1011
1012 /* Read an import or export file.  For an import file, this is called
1013    by the before_allocation emulation routine.  For an export file,
1014    this is called by the handle_option emulation routine.  */
1015
1016 static void
1017 gld${EMULATION_NAME}_read_file (const char *filename, bfd_boolean import)
1018 {
1019   struct obstack *o;
1020   FILE *f;
1021   int lineno;
1022   int c;
1023   bfd_boolean keep;
1024   const char *imppath;
1025   const char *impfile;
1026   const char *impmember;
1027
1028   o = (struct obstack *) xmalloc (sizeof (struct obstack));
1029   obstack_specify_allocation (o, 0, 0, xmalloc, gld${EMULATION_NAME}_free);
1030
1031   f = fopen (filename, FOPEN_RT);
1032   if (f == NULL)
1033     {
1034       bfd_set_error (bfd_error_system_call);
1035       einfo ("%F%s: %E\n", filename);
1036     }
1037
1038   keep = FALSE;
1039
1040   imppath = NULL;
1041   impfile = NULL;
1042   impmember = NULL;
1043
1044   lineno = 0;
1045
1046   /* Default to 32 and 64 bit mode
1047      symbols at top of /lib/syscalls.exp do not have a mode modifier and they
1048      are not repeated, assume 64 bit routines also want to use them.
1049      See the routine change_symbol_mode for more information.  */
1050
1051   symbol_mode = 0x04;
1052
1053   while ((c = getc (f)) != EOF)
1054     {
1055       char *s;
1056       char *symname;
1057       unsigned int syscall_flag = 0;
1058       bfd_vma address;
1059       struct bfd_link_hash_entry *h;
1060
1061       if (c != '\n')
1062         {
1063           obstack_1grow (o, c);
1064           continue;
1065         }
1066
1067       obstack_1grow (o, '\0');
1068       ++lineno;
1069
1070       s = (char *) obstack_base (o);
1071       while (ISSPACE (*s))
1072         ++s;
1073       if (*s == '\0'
1074           || *s == '*'
1075           || change_symbol_mode (s)
1076           || (*s == '#' && s[1] == ' ')
1077           || (!import && *s == '#' && s[1] == '!'))
1078         {
1079           obstack_free (o, obstack_base (o));
1080           continue;
1081         }
1082
1083       if (*s == '#' && s[1] == '!')
1084         {
1085           s += 2;
1086           while (ISSPACE (*s))
1087             ++s;
1088           if (*s == '\0')
1089             {
1090               imppath = NULL;
1091               impfile = NULL;
1092               impmember = NULL;
1093               obstack_free (o, obstack_base (o));
1094             }
1095           else if (*s == '(')
1096             einfo ("%F%s%d: #! ([member]) is not supported in import files\n",
1097                    filename, lineno);
1098           else
1099             {
1100               char cs;
1101               char *start;
1102
1103               (void) obstack_finish (o);
1104               keep = TRUE;
1105               start = s;
1106               while (!ISSPACE (*s) && *s != '(' && *s != '\0')
1107                 ++s;
1108               cs = *s;
1109               *s = '\0';
1110               if (!bfd_xcoff_split_import_path (link_info.output_bfd,
1111                                                 start, &imppath, &impfile))
1112                 einfo ("%F%P: Could not parse import path: %E\n");
1113               while (ISSPACE (cs))
1114                 {
1115                   ++s;
1116                   cs = *s;
1117                 }
1118               if (cs != '(')
1119                 {
1120                   impmember = "";
1121                   if (cs != '\0')
1122                     einfo ("%s:%d: warning: syntax error in import file\n",
1123                            filename, lineno);
1124                 }
1125               else
1126                 {
1127                   ++s;
1128                   impmember = s;
1129                   while (*s != ')' && *s != '\0')
1130                     ++s;
1131                   if (*s == ')')
1132                     *s = '\0';
1133                   else
1134                     einfo ("%s:%d: warning: syntax error in import file\n",
1135                            filename, lineno);
1136                 }
1137             }
1138
1139           continue;
1140         }
1141
1142       if (symbol_mode & symbol_mode_mask)
1143         {
1144           /* This is a symbol to be imported or exported.  */
1145           symname = s;
1146           syscall_flag = 0;
1147           address = (bfd_vma) -1;
1148
1149           while (!ISSPACE (*s) && *s != '\0')
1150             ++s;
1151           if (*s != '\0')
1152             {
1153               char *se;
1154
1155               *s++ = '\0';
1156
1157               while (ISSPACE (*s))
1158                 ++s;
1159
1160               se = s;
1161               while (!ISSPACE (*se) && *se != '\0')
1162                 ++se;
1163               if (*se != '\0')
1164                 {
1165                   *se++ = '\0';
1166                   while (ISSPACE (*se))
1167                     ++se;
1168                   if (*se != '\0')
1169                     einfo ("%s%d: warning: syntax error in import/export file\n",
1170                            filename, lineno);
1171                 }
1172
1173               if (s != se)
1174                 {
1175                   int status;
1176                   const char *end;
1177
1178                   status = is_syscall (s, &syscall_flag);
1179
1180                   if (0 > status)
1181                     {
1182                       /* not a system call, check for address */
1183                       address = bfd_scan_vma (s, &end, 0);
1184                       if (*end != '\0')
1185                         {
1186                           einfo ("%s:%d: warning: syntax error in import/export file\n",
1187                                  filename, lineno);
1188
1189                         }
1190                     }
1191                 }
1192             }
1193
1194           if (!import)
1195             {
1196               struct export_symbol_list *n;
1197
1198               ldlang_add_undef (symname, TRUE);
1199               n = ((struct export_symbol_list *)
1200                    xmalloc (sizeof (struct export_symbol_list)));
1201               n->next = export_symbols;
1202               n->name = xstrdup (symname);
1203               export_symbols = n;
1204             }
1205           else
1206             {
1207               h = bfd_link_hash_lookup (link_info.hash, symname, FALSE, FALSE,
1208                                         TRUE);
1209               if (h == NULL || h->type == bfd_link_hash_new)
1210                 {
1211                   /* We can just ignore attempts to import an unreferenced
1212                      symbol.  */
1213                 }
1214               else
1215                 {
1216                   if (!bfd_xcoff_import_symbol (link_info.output_bfd,
1217                                                 &link_info, h,
1218                                                 address, imppath, impfile,
1219                                                 impmember, syscall_flag))
1220                     einfo ("%X%s:%d: failed to import symbol %s: %E\n",
1221                            filename, lineno, symname);
1222                 }
1223             }
1224         }
1225       obstack_free (o, obstack_base (o));
1226     }
1227
1228   if (obstack_object_size (o) > 0)
1229     {
1230       einfo ("%s:%d: warning: ignoring unterminated last line\n",
1231              filename, lineno);
1232       obstack_free (o, obstack_base (o));
1233     }
1234
1235   if (!keep)
1236     {
1237       obstack_free (o, NULL);
1238       free (o);
1239     }
1240 }
1241
1242 /* This routine saves us from worrying about declaring free.  */
1243
1244 static void
1245 gld${EMULATION_NAME}_free (void *p)
1246 {
1247   free (p);
1248 }
1249
1250 /* This is called by the before_allocation routine via
1251    lang_for_each_statement.  It looks for relocations and assignments
1252    to symbols.  */
1253
1254 static void
1255 gld${EMULATION_NAME}_find_relocs (lang_statement_union_type *s)
1256 {
1257   if (s->header.type == lang_reloc_statement_enum)
1258     {
1259       lang_reloc_statement_type *rs;
1260
1261       rs = &s->reloc_statement;
1262       if (rs->name == NULL)
1263         einfo ("%F%P: only relocations against symbols are permitted\n");
1264       if (!bfd_xcoff_link_count_reloc (link_info.output_bfd, &link_info,
1265                                        rs->name))
1266         einfo ("%F%P: bfd_xcoff_link_count_reloc failed: %E\n");
1267     }
1268
1269   if (s->header.type == lang_assignment_statement_enum)
1270     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1271 }
1272
1273 /* Look through an expression for an assignment statement.  */
1274
1275 static void
1276 gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1277 {
1278   struct bfd_link_hash_entry *h;
1279
1280   switch (exp->type.node_class)
1281     {
1282     case etree_provide:
1283       h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
1284                                 FALSE, FALSE, FALSE);
1285       if (h == NULL)
1286         break;
1287       /* Fall through.  */
1288     case etree_assign:
1289       if (strcmp (exp->assign.dst, ".") != 0)
1290         {
1291           if (!bfd_xcoff_record_link_assignment (link_info.output_bfd,
1292                                                  &link_info,
1293                                                  exp->assign.dst))
1294             einfo ("%P%F: failed to record assignment to %s: %E\n",
1295                    exp->assign.dst);
1296         }
1297       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1298       break;
1299
1300     case etree_binary:
1301       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1302       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1303       break;
1304
1305     case etree_trinary:
1306       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1307       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1308       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1309       break;
1310
1311     case etree_unary:
1312       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1313       break;
1314
1315     default:
1316       break;
1317     }
1318 }
1319
1320 static char *
1321 gld${EMULATION_NAME}_get_script (int *isfile)
1322 EOF
1323
1324 if test -n "$COMPILE_IN"
1325 then
1326 # Scripts compiled in.
1327
1328 # sed commands to quote an ld script as a C string.
1329 sc="-f ${srcdir}/emultempl/ostring.sed"
1330
1331 fragment <<EOF
1332 {
1333   *isfile = 0;
1334
1335   if (link_info.relocatable && config.build_constructors)
1336     return
1337 EOF
1338 sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
1339 echo '  ; else if (link_info.relocatable) return'     >> e${EMULATION_NAME}.c
1340 sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
1341 echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
1342 sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
1343 echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1344 sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
1345 echo '  ; else return'                                 >> e${EMULATION_NAME}.c
1346 sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
1347 echo '; }'                                             >> e${EMULATION_NAME}.c
1348
1349 else
1350 # Scripts read from the filesystem.
1351
1352 fragment <<EOF
1353 {
1354   *isfile = 1;
1355
1356   if (link_info.relocatable && config.build_constructors)
1357     return "ldscripts/${EMULATION_NAME}.xu";
1358   else if (link_info.relocatable)
1359     return "ldscripts/${EMULATION_NAME}.xr";
1360   else if (!config.text_read_only)
1361     return "ldscripts/${EMULATION_NAME}.xbn";
1362   else if (!config.magic_demand_paged)
1363     return "ldscripts/${EMULATION_NAME}.xn";
1364   else
1365     return "ldscripts/${EMULATION_NAME}.x";
1366 }
1367 EOF
1368
1369 fi
1370
1371 fragment <<EOF
1372
1373 static void
1374 gld${EMULATION_NAME}_create_output_section_statements (void)
1375 {
1376   /* __rtinit */
1377   if ((bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour)
1378       && (link_info.init_function != NULL
1379           || link_info.fini_function != NULL
1380           || rtld))
1381     {
1382       initfini_file = lang_add_input_file ("initfini",
1383                                            lang_input_file_is_file_enum,
1384                                            NULL);
1385
1386       initfini_file->the_bfd = bfd_create ("initfini", link_info.output_bfd);
1387       if (initfini_file->the_bfd == NULL
1388           || ! bfd_set_arch_mach (initfini_file->the_bfd,
1389                                   bfd_get_arch (link_info.output_bfd),
1390                                   bfd_get_mach (link_info.output_bfd)))
1391         {
1392           einfo ("%X%P: can not create BFD %E\n");
1393           return;
1394         }
1395
1396       /* Call backend to fill in the rest */
1397       if (! bfd_xcoff_link_generate_rtinit (initfini_file->the_bfd,
1398                                             link_info.init_function,
1399                                             link_info.fini_function,
1400                                             rtld))
1401         {
1402           einfo ("%X%P: can not create BFD %E\n");
1403           return;
1404         }
1405
1406       /* __rtld defined in /lib/librtl.a */
1407       if (rtld)
1408         lang_add_input_file ("rtl", lang_input_file_is_l_enum, NULL);
1409     }
1410 }
1411
1412 static void
1413 gld${EMULATION_NAME}_set_output_arch (void)
1414 {
1415   bfd_set_arch_mach (link_info.output_bfd,
1416                      bfd_xcoff_architecture (link_info.output_bfd),
1417                      bfd_xcoff_machine (link_info.output_bfd));
1418
1419   ldfile_output_architecture = bfd_get_arch (link_info.output_bfd);
1420   ldfile_output_machine = bfd_get_mach (link_info.output_bfd);
1421   ldfile_output_machine_name = bfd_printable_name (link_info.output_bfd);
1422 }
1423
1424 static bfd_boolean
1425 gld${EMULATION_NAME}_open_dynamic_archive (const char *arch,
1426                                            search_dirs_type *search,
1427                                            lang_input_statement_type *entry)
1428 {
1429   char *path;
1430
1431   if (!entry->maybe_archive)
1432     return FALSE;
1433
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