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