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