ld/emultempl/aix.em

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