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