ld/emultempl/aix.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 cat >e${EMULATION_NAME}.c <<EOF
   4 /* This file is is generated by a shell script.  DO NOT EDIT! */
   5
   6 /* AIX emulation code for ${EMULATION_NAME}
   7    Copyright 1991, 1993, 1995, 1996, 1997, 1998, 2000
   8    Free Software Foundation, Inc.
   9    Written by Steve Chamberlain <sac@cygnus.com>
  10    AIX support by Ian Lance Taylor <ian@cygnus.com>
  11
  12 This file is part of GLD, the Gnu Linker.
  13
  14 This program is free software; you can redistribute it and/or modify
  15 it under the terms of the GNU General Public License as published by
  16 the Free Software Foundation; either version 2 of the License, or
  17 (at your option) any later version.
  18
  19 This program is distributed in the hope that it will be useful,
  20 but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 GNU General Public License for more details.
  23
  24 You should have received a copy of the GNU General Public License
  25 along with this program; if not, write to the Free Software
  26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  27
  28 #define TARGET_IS_${EMULATION_NAME}
  29
  30 #include "bfd.h"
  31 #include "sysdep.h"
  32 #include "libiberty.h"
  33 #include "getopt.h"
  34 #include "obstack.h"
  35 #include "bfdlink.h"
  36
  37 #include <ctype.h>
  38
  39 #include "ld.h"
  40 #include "ldmain.h"
  41 #include "ldmisc.h"
  42 #include "ldexp.h"
  43 #include "ldlang.h"
  44 #include "ldfile.h"
  45 #include "ldemul.h"
  46 #include "ldctor.h"
  47 #include "ldgram.h"
  48
  49 static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
  50 static int gld${EMULATION_NAME}_parse_args PARAMS ((int, char **));
  51 static void gld${EMULATION_NAME}_after_open PARAMS ((void));
  52 static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
  53 static void gld${EMULATION_NAME}_read_file PARAMS ((const char *, boolean));
  54 static void gld${EMULATION_NAME}_free PARAMS ((PTR));
  55 static void gld${EMULATION_NAME}_find_relocs
  56   PARAMS ((lang_statement_union_type *));
  57 static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *));
  58 static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));
  59
  60 /* The file alignment required for each section.  */
  61 static unsigned long file_align;
  62
  63 /* The maximum size the stack is permitted to grow.  This is stored in
  64    the a.out header.  */
  65 static unsigned long maxstack;
  66
  67 /* The maximum data size.  This is stored in the a.out header.  */
  68 static unsigned long maxdata;
  69
  70 /* Whether to perform garbage collection.  */
  71 static int gc = 1;
  72
  73 /* The module type to use.  */
  74 static unsigned short modtype = ('1' << 8) | 'L';
  75
  76 /* Whether the .text section must be read-only (i.e., no relocs
  77    permitted).  */
  78 static int textro;
  79
  80 /* Whether to implement Unix like linker semantics.  */
  81 static int unix_ld;
  82
  83 /* Structure used to hold import file list.  */
  84
  85 struct filelist
  86 {
  87   struct filelist *next;
  88   const char *name;
  89 };
  90
  91 /* List of import files.  */
  92 static struct filelist *import_files;
  93
  94 /* List of export symbols read from the export files.  */
  95
  96 struct export_symbol_list
  97 {
  98   struct export_symbol_list *next;
  99   const char *name;
 100   boolean syscall;
 101 };
 102
 103 static struct export_symbol_list *export_symbols;
 104
 105 /* This routine is called before anything else is done.  */
 106
 107 static void
 108 gld${EMULATION_NAME}_before_parse()
 109 {
 110 #ifndef TARGET_                 /* I.e., if not generic.  */
 111   ldfile_output_architecture = bfd_arch_${ARCH};
 112 #endif /* not TARGET_ */
 113   config.has_shared = true;
 114 }
 115
 116 /* Handle AIX specific options.  */
 117
 118 static int
 119 gld${EMULATION_NAME}_parse_args (argc, argv)
 120      int argc;
 121      char **argv;
 122 {
 123   int prevoptind = optind;
 124   int prevopterr = opterr;
 125   int indx;
 126   int longind;
 127   int optc;
 128   long val;
 129   char *end;
 130
 131 #define OPTION_IGNORE (300)
 132 #define OPTION_AUTOIMP (OPTION_IGNORE + 1)
 133 #define OPTION_ERNOTOK (OPTION_AUTOIMP + 1)
 134 #define OPTION_EROK (OPTION_ERNOTOK + 1)
 135 #define OPTION_EXPORT (OPTION_EROK + 1)
 136 #define OPTION_IMPORT (OPTION_EXPORT + 1)
 137 #define OPTION_LOADMAP (OPTION_IMPORT + 1)
 138 #define OPTION_MAXDATA (OPTION_LOADMAP + 1)
 139 #define OPTION_MAXSTACK (OPTION_MAXDATA + 1)
 140 #define OPTION_MODTYPE (OPTION_MAXSTACK + 1)
 141 #define OPTION_NOAUTOIMP (OPTION_MODTYPE + 1)
 142 #define OPTION_NOSTRCMPCT (OPTION_NOAUTOIMP + 1)
 143 #define OPTION_PD (OPTION_NOSTRCMPCT + 1)
 144 #define OPTION_PT (OPTION_PD + 1)
 145 #define OPTION_STRCMPCT (OPTION_PT + 1)
 146 #define OPTION_UNIX (OPTION_STRCMPCT + 1)
 147
 148   static struct option longopts[] = {
 149     {"basis", no_argument, NULL, OPTION_IGNORE},
 150     {"bautoimp", no_argument, NULL, OPTION_AUTOIMP},
 151     {"bcomprld", no_argument, NULL, OPTION_IGNORE},
 152     {"bcrld", no_argument, NULL, OPTION_IGNORE},
 153     {"bcror31", no_argument, NULL, OPTION_IGNORE},
 154     {"bD", required_argument, NULL, OPTION_MAXDATA},
 155     {"bE", required_argument, NULL, OPTION_EXPORT},
 156     {"bernotok", no_argument, NULL, OPTION_ERNOTOK},
 157     {"berok", no_argument, NULL, OPTION_EROK},
 158     {"berrmsg", no_argument, NULL, OPTION_IGNORE},
 159     {"bexport", required_argument, NULL, OPTION_EXPORT},
 160     {"bf", no_argument, NULL, OPTION_ERNOTOK},
 161     {"bgc", no_argument, &gc, 1},
 162     {"bh", required_argument, NULL, OPTION_IGNORE},
 163     {"bhalt", required_argument, NULL, OPTION_IGNORE},
 164     {"bI", required_argument, NULL, OPTION_IMPORT},
 165     {"bimport", required_argument, NULL, OPTION_IMPORT},
 166     {"bl", required_argument, NULL, OPTION_LOADMAP},
 167     {"bloadmap", required_argument, NULL, OPTION_LOADMAP},
 168     {"bmaxdata", required_argument, NULL, OPTION_MAXDATA},
 169     {"bmaxstack", required_argument, NULL, OPTION_MAXSTACK},
 170     {"bM", required_argument, NULL, OPTION_MODTYPE},
 171     {"bmodtype", required_argument, NULL, OPTION_MODTYPE},
 172     {"bnoautoimp", no_argument, NULL, OPTION_NOAUTOIMP},
 173     {"bnodelcsect", no_argument, NULL, OPTION_IGNORE},
 174     {"bnoentry", no_argument, NULL, OPTION_IGNORE},
 175     {"bnogc", no_argument, &gc, 0},
 176     {"bnso", no_argument, NULL, OPTION_NOAUTOIMP},
 177     {"bnostrcmpct", no_argument, NULL, OPTION_NOSTRCMPCT},
 178     {"bnotextro", no_argument, &textro, 0},
 179     {"bnro", no_argument, &textro, 0},
 180     {"bpD", required_argument, NULL, OPTION_PD},
 181     {"bpT", required_argument, NULL, OPTION_PT},
 182     {"bro", no_argument, &textro, 1},
 183     {"bS", required_argument, NULL, OPTION_MAXSTACK},
 184     {"bso", no_argument, NULL, OPTION_AUTOIMP},
 185     {"bstrcmpct", no_argument, NULL, OPTION_STRCMPCT},
 186     {"btextro", no_argument, &textro, 1},
 187     {"static", no_argument, NULL, OPTION_NOAUTOIMP},
 188     {"unix", no_argument, NULL, OPTION_UNIX},
 189     {NULL, no_argument, NULL, 0}
 190   };
 191
 192   /* Options supported by the AIX linker which we do not support: -f,
 193      -S, -v, -Z, -bbindcmds, -bbinder, -bbindopts, -bcalls, -bcaps,
 194      -bcror15, -bdebugopt, -bdbg, -bdelcsect, -bex?, -bfilelist, -bfl,
 195      -bgcbypass, -bglink, -binsert, -bi, -bloadmap, -bl, -bmap, -bnl,
 196      -bnobind, -bnocomprld, -bnocrld, -bnoerrmsg, -bnoglink,
 197      -bnoloadmap, -bnl, -bnoobjreorder, -bnoquiet, -bnoreorder,
 198      -bnotypchk, -bnox, -bquiet, -bR, -brename, -breorder, -btypchk,
 199      -bx, -bX, -bxref.  */
 200
 201   /* If the current option starts with -b, change the first : to an =.
 202      The AIX linker uses : to separate the option from the argument;
 203      changing it to = lets us treat it as a getopt option.  */
 204   indx = optind;
 205   if (indx == 0)
 206     indx = 1;
 207   if (indx < argc && strncmp (argv[indx], "-b", 2) == 0)
 208     {
 209       char *s;
 210
 211       for (s = argv[indx]; *s != '\0'; s++)
 212         {
 213           if (*s == ':')
 214             {
 215               *s = '=';
 216               break;
 217             }
 218         }
 219     }
 220
 221   /* We add s and u so to the short options list so that -s and -u on
 222      the command line do not match -static and -unix.  */
 223
 224   opterr = 0;
 225   optc = getopt_long_only (argc, argv, "-D:H:KT:zsu", longopts, &longind);
 226   opterr = prevopterr;
 227
 228   switch (optc)
 229     {
 230     case 's':
 231     case 'u':
 232     default:
 233       optind = prevoptind;
 234       return 0;
 235
 236     case 0:
 237       /* Long option which just sets a flag.  */
 238       break;
 239
 240     case 'D':
 241       val = strtol (optarg, &end, 0);
 242       if (*end != '\0')
 243         einfo ("%P: warning: ignoring invalid -D number %s\n", optarg);
 244       else if (val != -1)
 245         lang_section_start (".data", exp_intop (val));
 246       break;
 247
 248     case 'H':
 249       val = strtoul (optarg, &end, 0);
 250       if (*end != '\0'
 251           || (val & (val - 1)) != 0)
 252         einfo ("%P: warning: ignoring invalid -H number %s\n", optarg);
 253       else
 254         file_align = val;
 255       break;
 256
 257     case 'K':
 258     case 'z':
 259       /* FIXME: This should use the page size for the target system.  */
 260       file_align = 4096;
 261       break;
 262
 263     case 'T':
 264       /* On AIX this is the same as GNU ld -Ttext.  When we see -T
 265          number, we assume the AIX option is intended.  Otherwise, we
 266          assume the usual GNU ld -T option is intended.  We can't just
 267          ignore the AIX option, because gcc passes it to the linker.  */
 268       val = strtoul (optarg, &end, 0);
 269       if (*end != '\0')
 270         {
 271           optind = prevoptind;
 272           return 0;
 273         }
 274       lang_section_start (".text", exp_intop (val));
 275       break;
 276
 277     case OPTION_IGNORE:
 278       break;
 279
 280     case OPTION_AUTOIMP:
 281       link_info.static_link = false;
 282       break;
 283
 284     case OPTION_ERNOTOK:
 285       force_make_executable = false;
 286       break;
 287
 288     case OPTION_EROK:
 289       force_make_executable = true;
 290       break;
 291
 292     case OPTION_EXPORT:
 293       gld${EMULATION_NAME}_read_file (optarg, false);
 294       break;
 295
 296     case OPTION_IMPORT:
 297       {
 298         struct filelist *n;
 299         struct filelist **flpp;
 300
 301         n = (struct filelist *) xmalloc (sizeof (struct filelist));
 302         n->next = NULL;
 303         n->name = optarg;
 304         flpp = &import_files;
 305         while (*flpp != NULL)
 306           flpp = &(*flpp)->next;
 307         *flpp = n;
 308       }
 309       break;
 310
 311     case OPTION_LOADMAP:
 312       config.map_filename = optarg;
 313       break;
 314
 315     case OPTION_MAXDATA:
 316       val = strtoul (optarg, &end, 0);
 317       if (*end != '\0')
 318         einfo ("%P: warning: ignoring invalid -bmaxdata number %s\n",
 319                optarg);
 320       else
 321         maxdata = val;
 322       break;
 323
 324     case OPTION_MAXSTACK:
 325       val = strtoul (optarg, &end, 0);
 326       if (*end != '\0')
 327         einfo ("%P: warning: ignoring invalid -bmaxstack number %s\n",
 328                optarg);
 329       else
 330         maxstack = val;
 331       break;
 332
 333     case OPTION_MODTYPE:
 334       if (*optarg == 'S')
 335         {
 336           link_info.shared = true;
 337           ++optarg;
 338         }
 339       if (*optarg == '\0' || optarg[1] == '\0')
 340         einfo ("%P: warning: ignoring invalid module type %s\n", optarg);
 341       else
 342         modtype = (*optarg << 8) | optarg[1];
 343       break;
 344
 345     case OPTION_NOAUTOIMP:
 346       link_info.static_link = true;
 347       break;
 348
 349     case OPTION_NOSTRCMPCT:
 350       link_info.traditional_format = true;
 351       break;
 352
 353     case OPTION_PD:
 354       /* This sets the page that the .data section is supposed to
 355          start on.  The offset within the page should still be the
 356          offset within the file, so we need to build an appropriate
 357          expression.  */
 358       val = strtoul (optarg, &end, 0);
 359       if (*end != '\0')
 360         einfo ("%P: warning: ignoring invalid -pD number %s\n", optarg);
 361       else
 362         {
 363           etree_type *t;
 364
 365           t = exp_binop ('+',
 366                          exp_intop (val),
 367                          exp_binop ('&',
 368                                     exp_nameop (NAME, "."),
 369                                     exp_intop (0xfff)));
 370           t = exp_binop ('&',
 371                          exp_binop ('+', t, exp_intop (31)),
 372                          exp_intop (~ (bfd_vma) 31));
 373           lang_section_start (".data", t);
 374         }
 375       break;
 376
 377     case OPTION_PT:
 378       /* This set the page that the .text section is supposed to start
 379          on.  The offset within the page should still be the offset
 380          within the file.  */
 381       val = strtoul (optarg, &end, 0);
 382       if (*end != '\0')
 383         einfo ("%P: warning: ignoring invalid -pT number %s\n", optarg);
 384       else
 385         {
 386           etree_type *t;
 387
 388           t = exp_binop ('+',
 389                          exp_intop (val),
 390                          exp_nameop (SIZEOF_HEADERS, NULL));
 391           t = exp_binop ('&',
 392                          exp_binop ('+', t, exp_intop (31)),
 393                          exp_intop (~ (bfd_vma) 31));
 394           lang_section_start (".text", t);
 395         }
 396       break;
 397
 398     case OPTION_STRCMPCT:
 399       link_info.traditional_format = false;
 400       break;
 401
 402     case OPTION_UNIX:
 403       unix_ld = true;
 404       break;
 405     }
 406
 407   return 1;
 408 }
 409
 410 /* This is called when an input file can not be recognized as a BFD
 411    object or an archive.  If the file starts with #!, we must treat it
 412    as an import file.  This is for AIX compatibility.  */
 413
 414 static boolean
 415 gld${EMULATION_NAME}_unrecognized_file (entry)
 416      lang_input_statement_type *entry;
 417 {
 418   FILE *e;
 419   boolean ret;
 420
 421   e = fopen (entry->filename, FOPEN_RT);
 422   if (e == NULL)
 423     return false;
 424
 425   ret = false;
 426
 427   if (getc (e) == '#' && getc (e) == '!')
 428     {
 429       struct filelist *n;
 430       struct filelist **flpp;
 431
 432       n = (struct filelist *) xmalloc (sizeof (struct filelist));
 433       n->next = NULL;
 434       n->name = entry->filename;
 435       flpp = &import_files;
 436       while (*flpp != NULL)
 437         flpp = &(*flpp)->next;
 438       *flpp = n;
 439
 440       ret = true;
 441       entry->loaded = true;
 442     }
 443
 444   fclose (e);
 445
 446   return ret;
 447 }
 448
 449 /* This is called after the input files have been opened.  */
 450
 451 static void
 452 gld${EMULATION_NAME}_after_open ()
 453 {
 454   boolean r;
 455   struct set_info *p;
 456
 457   /* Call ldctor_build_sets, after pretending that this is a
 458      relocateable link.  We do this because AIX requires relocation
 459      entries for all references to symbols, even in a final
 460      executable.  Of course, we only want to do this if we are
 461      producing an XCOFF output file.  */
 462   r = link_info.relocateable;
 463   if (strstr (bfd_get_target (output_bfd), "xcoff") != NULL)
 464     link_info.relocateable = true;
 465   ldctor_build_sets ();
 466   link_info.relocateable = r;
 467
 468   /* For each set, record the size, so that the XCOFF backend can
 469      output the correct csect length.  */
 470   for (p = sets; p != (struct set_info *) NULL; p = p->next)
 471     {
 472       bfd_size_type size;
 473
 474       /* If the symbol is defined, we may have been invoked from
 475          collect, and the sets may already have been built, so we do
 476          not do anything.  */
 477       if (p->h->type == bfd_link_hash_defined
 478           || p->h->type == bfd_link_hash_defweak)
 479         continue;
 480
 481       if (p->reloc != BFD_RELOC_CTOR)
 482         {
 483           /* Handle this if we need to.  */
 484           abort ();
 485         }
 486
 487       size = (p->count + 2) * 4;
 488       if (! bfd_xcoff_link_record_set (output_bfd, &link_info, p->h, size))
 489         einfo ("%F%P: bfd_xcoff_link_record_set failed: %E\n");
 490     }
 491 }
 492
 493 /* This is called after the sections have been attached to output
 494    sections, but before any sizes or addresses have been set.  */
 495
 496 static void
 497 gld${EMULATION_NAME}_before_allocation ()
 498 {
 499   struct filelist *fl;
 500   struct export_symbol_list *el;
 501   char *libpath;
 502   asection *special_sections[6];
 503   int i;
 504
 505   /* Handle the import and export files, if any.  */
 506   for (fl = import_files; fl != NULL; fl = fl->next)
 507     gld${EMULATION_NAME}_read_file (fl->name, true);
 508   for (el = export_symbols; el != NULL; el = el->next)
 509     {
 510       struct bfd_link_hash_entry *h;
 511
 512       h = bfd_link_hash_lookup (link_info.hash, el->name, false, false, false);
 513       if (h == NULL)
 514         einfo ("%P%F: bfd_link_hash_lookup of export symbol failed: %E\n");
 515       if (! bfd_xcoff_export_symbol (output_bfd, &link_info, h, el->syscall))
 516         einfo ("%P%F: bfd_xcoff_export_symbol failed: %E\n");
 517     }
 518
 519   /* Track down all relocations called for by the linker script (these
 520      are typically constructor/destructor entries created by
 521      CONSTRUCTORS) and let the backend know it will need to create
 522      .loader relocs for them.  */
 523   lang_for_each_statement (gld${EMULATION_NAME}_find_relocs);
 524
 525   /* We need to build LIBPATH from the -L arguments.  If any -rpath
 526      arguments were used, though, we use -rpath instead, as a GNU
 527      extension.  */
 528   if (command_line.rpath != NULL)
 529     libpath = command_line.rpath;
 530   else if (search_head == NULL)
 531     libpath = (char *) "";
 532   else
 533     {
 534       size_t len;
 535       search_dirs_type *search;
 536
 537       len = strlen (search_head->name);
 538       libpath = xmalloc (len + 1);
 539       strcpy (libpath, search_head->name);
 540       for (search = search_head->next; search != NULL; search = search->next)
 541         {
 542           size_t nlen;
 543
 544           nlen = strlen (search->name);
 545           libpath = xrealloc (libpath, len + nlen + 2);
 546           libpath[len] = ':';
 547           strcpy (libpath + len + 1, search->name);
 548           len += nlen + 1;
 549         }
 550     }
 551
 552   /* Let the XCOFF backend set up the .loader section.  */
 553   if (! bfd_xcoff_size_dynamic_sections (output_bfd, &link_info, libpath,
 554                                          entry_symbol, file_align,
 555                                          maxstack, maxdata,
 556                                          gc && ! unix_ld ? true : false,
 557                                          modtype,
 558                                          textro ? true : false,
 559                                          unix_ld,
 560                                          special_sections))
 561     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
 562
 563   /* Look through the special sections, and put them in the right
 564      place in the link ordering.  This is especially magic.  */
 565   for (i = 0; i < 6; i++)
 566     {
 567       asection *sec;
 568       lang_output_section_statement_type *os;
 569       lang_statement_union_type **pls;
 570       lang_input_section_type *is;
 571       const char *oname;
 572       boolean start;
 573
 574       sec = special_sections[i];
 575       if (sec == NULL)
 576         continue;
 577
 578       /* Remove this section from the list of the output section.
 579          This assumes we know what the script looks like.  */
 580       is = NULL;
 581       os = lang_output_section_find (sec->output_section->name);
 582       if (os == NULL)
 583         einfo ("%P%F: can't find output section %s\n",
 584                sec->output_section->name);
 585       for (pls = &os->children.head; *pls != NULL; pls = &(*pls)->next)
 586         {
 587           if ((*pls)->header.type == lang_input_section_enum
 588               && (*pls)->input_section.section == sec)
 589             {
 590               is = (lang_input_section_type *) *pls;
 591               *pls = (*pls)->next;
 592               break;
 593             }
 594           if ((*pls)->header.type == lang_wild_statement_enum)
 595             {
 596               lang_statement_union_type **pwls;
 597
 598               for (pwls = &(*pls)->wild_statement.children.head;
 599                    *pwls != NULL;
 600                    pwls = &(*pwls)->next)
 601                 {
 602                   if ((*pwls)->header.type == lang_input_section_enum
 603                       && (*pwls)->input_section.section == sec)
 604                     {
 605                       is = (lang_input_section_type *) *pwls;
 606                       *pwls = (*pwls)->next;
 607                       break;
 608                     }
 609                 }
 610               if (is != NULL)
 611                 break;
 612             }
 613         }
 614
 615       if (is == NULL)
 616         einfo ("%P%F: can't find %s in output section\n",
 617                bfd_get_section_name (sec->owner, sec));
 618
 619       /* Now figure out where the section should go.  */
 620       switch (i)
 621         {
 622         default: /* to avoid warnings */
 623         case 0:
 624           /* _text */
 625           oname = ".text";
 626           start = true;
 627           break;
 628         case 1:
 629           /* _etext */
 630           oname = ".text";
 631           start = false;
 632           break;
 633         case 2:
 634           /* _data */
 635           oname = ".data";
 636           start = true;
 637           break;
 638         case 3:
 639           /* _edata */
 640           oname = ".data";
 641           start = false;
 642           break;
 643         case 4:
 644         case 5:
 645           /* _end and end */
 646           oname = ".bss";
 647           start = false;
 648           break;
 649         }
 650
 651       os = lang_output_section_find (oname);
 652
 653       if (start)
 654         {
 655           is->header.next = os->children.head;
 656           os->children.head = (lang_statement_union_type *) is;
 657         }
 658       else
 659         {
 660           is->header.next = NULL;
 661           lang_statement_append (&os->children,
 662                                  (lang_statement_union_type *) is,
 663                                  &is->header.next);
 664         }
 665     }
 666 }
 667
 668 /* Read an import or export file.  For an import file, this is called
 669    by the before_allocation emulation routine.  For an export file,
 670    this is called by the parse_args emulation routine.  */
 671
 672 static void
 673 gld${EMULATION_NAME}_read_file (filename, import)
 674      const char *filename;
 675      boolean import;
 676 {
 677   struct obstack *o;
 678   FILE *f;
 679   int lineno;
 680   int c;
 681   boolean keep;
 682   const char *imppath;
 683   const char *impfile;
 684   const char *impmember;
 685
 686   o = (struct obstack *) xmalloc (sizeof (struct obstack));
 687   obstack_specify_allocation (o, 0, 0, xmalloc, gld${EMULATION_NAME}_free);
 688
 689   f = fopen (filename, FOPEN_RT);
 690   if (f == NULL)
 691     {
 692       bfd_set_error (bfd_error_system_call);
 693       einfo ("%F%s: %E\n", filename);
 694     }
 695
 696   keep = false;
 697
 698   imppath = NULL;
 699   impfile = NULL;
 700   impmember = NULL;
 701
 702   lineno = 0;
 703   while ((c = getc (f)) != EOF)
 704     {
 705       char *s;
 706       char *symname;
 707       boolean syscall;
 708       bfd_vma address;
 709       struct bfd_link_hash_entry *h;
 710
 711       if (c != '\n')
 712         {
 713           obstack_1grow (o, c);
 714           continue;
 715         }
 716
 717       obstack_1grow (o, '\0');
 718       ++lineno;
 719
 720       s = (char *) obstack_base (o);
 721       while (isspace ((unsigned char) *s))
 722         ++s;
 723       if (*s == '\0'
 724           || *s == '*'
 725           || (*s == '#' && s[1] == ' ')
 726           || (! import && *s == '#' && s[1] == '!'))
 727         {
 728           obstack_free (o, obstack_base (o));
 729           continue;
 730         }
 731
 732       if (*s == '#' && s[1] == '!')
 733         {
 734           s += 2;
 735           while (isspace ((unsigned char) *s))
 736             ++s;
 737           if (*s == '\0')
 738             {
 739               imppath = NULL;
 740               impfile = NULL;
 741               impmember = NULL;
 742               obstack_free (o, obstack_base (o));
 743             }
 744           else if (*s == '(')
 745             einfo ("%F%s%d: #! ([member]) is not supported in import files\n",
 746                    filename, lineno);
 747           else
 748             {
 749               char cs;
 750               char *file;
 751
 752               (void) obstack_finish (o);
 753               keep = true;
 754               imppath = s;
 755               file = NULL;
 756               while (! isspace ((unsigned char) *s) && *s != '(' && *s != '\0')
 757                 {
 758                   if (*s == '/')
 759                     file = s + 1;
 760                   ++s;
 761                 }
 762               if (file != NULL)
 763                 {
 764                   file[-1] = '\0';
 765                   impfile = file;
 766                   if (imppath == file - 1)
 767                     imppath = "/";
 768                 }
 769               else
 770                 {
 771                   impfile = imppath;
 772                   imppath = "";
 773                 }
 774               cs = *s;
 775               *s = '\0';
 776               while (isspace ((unsigned char) cs))
 777                 {
 778                   ++s;
 779                   cs = *s;
 780                 }
 781               if (cs != '(')
 782                 {
 783                   impmember = "";
 784                   if (cs != '\0')
 785                     einfo ("%s:%d: warning: syntax error in import file\n",
 786                            filename, lineno);
 787                 }
 788               else
 789                 {
 790                   ++s;
 791                   impmember = s;
 792                   while (*s != ')' && *s != '\0')
 793                     ++s;
 794                   if (*s == ')')
 795                     *s = '\0';
 796                   else
 797                     einfo ("%s:%d: warning: syntax error in import file\n",
 798                            filename, lineno);
 799                 }
 800             }
 801
 802           continue;
 803         }
 804
 805       /* This is a symbol to be imported or exported.  */
 806       symname = s;
 807       syscall = false;
 808       address = (bfd_vma) -1;
 809
 810       while (! isspace ((unsigned char) *s) && *s != '\0')
 811         ++s;
 812       if (*s != '\0')
 813         {
 814           char *se;
 815
 816           *s++ = '\0';
 817
 818           while (isspace ((unsigned char) *s))
 819             ++s;
 820
 821           se = s;
 822           while (! isspace ((unsigned char) *se) && *se != '\0')
 823             ++se;
 824           if (*se != '\0')
 825             {
 826               *se++ = '\0';
 827               while (isspace ((unsigned char) *se))
 828                 ++se;
 829               if (*se != '\0')
 830                 einfo ("%s%d: warning: syntax error in import/export file\n",
 831                        filename, lineno);
 832             }
 833
 834           if (s == se)
 835             {
 836               /* There was no address after all.  */
 837             }
 838           else if (strcasecmp (s, "svc") == 0
 839                    || strcasecmp (s, "syscall") == 0)
 840             syscall = true;
 841           else
 842             {
 843               char *end;
 844
 845               address = strtoul (s, &end, 0);
 846               if (*end != '\0')
 847                 einfo ("%s:%d: warning: syntax error in import/export file\n",
 848                        filename, lineno);
 849             }
 850         }
 851
 852       if (! import)
 853         {
 854           struct export_symbol_list *n;
 855
 856           ldlang_add_undef (symname);
 857           n = ((struct export_symbol_list *)
 858                xmalloc (sizeof (struct export_symbol_list)));
 859           n->next = export_symbols;
 860           n->name = xstrdup (symname);
 861           n->syscall = syscall;
 862           export_symbols = n;
 863         }
 864       else
 865         {
 866           h = bfd_link_hash_lookup (link_info.hash, symname, false, false,
 867                                     true);
 868           if (h == NULL || h->type == bfd_link_hash_new)
 869             {
 870               /* We can just ignore attempts to import an unreferenced
 871                  symbol.  */
 872             }
 873           else
 874             {
 875               if (! bfd_xcoff_import_symbol (output_bfd, &link_info, h,
 876                                              address, imppath, impfile,
 877                                              impmember))
 878                 einfo ("%X%s:%d: failed to import symbol %s: %E\n",
 879                        filename, lineno, symname);
 880             }
 881         }
 882
 883       obstack_free (o, obstack_base (o));
 884     }
 885
 886   if (obstack_object_size (o) > 0)
 887     {
 888       einfo ("%s:%d: warning: ignoring unterminated last line\n",
 889              filename, lineno);
 890       obstack_free (o, obstack_base (o));
 891     }
 892
 893   if (! keep)
 894     {
 895       obstack_free (o, NULL);
 896       free (o);
 897     }
 898 }
 899
 900 /* This routine saves us from worrying about declaring free.  */
 901
 902 static void
 903 gld${EMULATION_NAME}_free (p)
 904      PTR p;
 905 {
 906   free (p);
 907 }
 908
 909 /* This is called by the before_allocation routine via
 910    lang_for_each_statement.  It looks for relocations and assignments
 911    to symbols.  */
 912
 913 static void
 914 gld${EMULATION_NAME}_find_relocs (s)
 915      lang_statement_union_type *s;
 916 {
 917   if (s->header.type == lang_reloc_statement_enum)
 918     {
 919       lang_reloc_statement_type *rs;
 920
 921       rs = &s->reloc_statement;
 922       if (rs->name == NULL)
 923         einfo ("%F%P: only relocations against symbols are permitted\n");
 924       if (! bfd_xcoff_link_count_reloc (output_bfd, &link_info, rs->name))
 925         einfo ("%F%P: bfd_xcoff_link_count_reloc failed: %E\n");
 926     }
 927
 928   if (s->header.type == lang_assignment_statement_enum)
 929     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
 930 }
 931
 932 /* Look through an expression for an assignment statement.  */
 933
 934 static void
 935 gld${EMULATION_NAME}_find_exp_assignment (exp)
 936      etree_type *exp;
 937 {
 938   struct bfd_link_hash_entry *h;
 939
 940   switch (exp->type.node_class)
 941     {
 942     case etree_provide:
 943       h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
 944                                 false, false, false);
 945       if (h == NULL)
 946         break;
 947       /* Fall through.  */
 948     case etree_assign:
 949       if (strcmp (exp->assign.dst, ".") != 0)
 950         {
 951           if (! bfd_xcoff_record_link_assignment (output_bfd, &link_info,
 952                                                   exp->assign.dst))
 953             einfo ("%P%F: failed to record assignment to %s: %E\n",
 954                    exp->assign.dst);
 955         }
 956       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
 957       break;
 958
 959     case etree_binary:
 960       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
 961       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
 962       break;
 963
 964     case etree_trinary:
 965       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
 966       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 967       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
 968       break;
 969
 970     case etree_unary:
 971       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
 972       break;
 973
 974     default:
 975       break;
 976     }
 977 }
 978
 979 static char *
 980 gld${EMULATION_NAME}_get_script(isfile)
 981      int *isfile;
 982 EOF
 983
 984 if test -n "$COMPILE_IN"
 985 then
 986 # Scripts compiled in.
 987
 988 # sed commands to quote an ld script as a C string.
 989 sc="-f stringify.sed"
 990
 991 cat >>e${EMULATION_NAME}.c <<EOF
 992 {
 993   *isfile = 0;
 994
 995   if (link_info.relocateable == true && config.build_constructors == true)
 996     return
 997 EOF
 998 sed $sc ldscripts/${EMULATION_NAME}.xu                     >> e${EMULATION_NAME}.c
 999 echo '  ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1000 sed $sc ldscripts/${EMULATION_NAME}.xr                     >> e${EMULATION_NAME}.c
1001 echo '  ; else if (!config.text_read_only) return'         >> e${EMULATION_NAME}.c
1002 sed $sc ldscripts/${EMULATION_NAME}.xbn                    >> e${EMULATION_NAME}.c
1003 echo '  ; else if (!config.magic_demand_paged) return'     >> e${EMULATION_NAME}.c
1004 sed $sc ldscripts/${EMULATION_NAME}.xn                     >> e${EMULATION_NAME}.c
1005 echo '  ; else return'                                     >> e${EMULATION_NAME}.c
1006 sed $sc ldscripts/${EMULATION_NAME}.x                      >> e${EMULATION_NAME}.c
1007 echo '; }'                                                 >> e${EMULATION_NAME}.c
1008
1009 else
1010 # Scripts read from the filesystem.
1011
1012 cat >>e${EMULATION_NAME}.c <<EOF
1013 {
1014   *isfile = 1;
1015
1016   if (link_info.relocateable == true && config.build_constructors == true)
1017     return "ldscripts/${EMULATION_NAME}.xu";
1018   else if (link_info.relocateable == true)
1019     return "ldscripts/${EMULATION_NAME}.xr";
1020   else if (!config.text_read_only)
1021     return "ldscripts/${EMULATION_NAME}.xbn";
1022   else if (!config.magic_demand_paged)
1023     return "ldscripts/${EMULATION_NAME}.xn";
1024   else
1025     return "ldscripts/${EMULATION_NAME}.x";
1026 }
1027 EOF
1028
1029 fi
1030
1031 cat >>e${EMULATION_NAME}.c <<EOF
1032
1033 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1034 {
1035   gld${EMULATION_NAME}_before_parse,
1036   syslib_default,
1037   hll_default,
1038   after_parse_default,
1039   gld${EMULATION_NAME}_after_open,
1040   after_allocation_default,
1041   set_output_arch_default,
1042   ldemul_default_target,
1043   gld${EMULATION_NAME}_before_allocation,
1044   gld${EMULATION_NAME}_get_script,
1045   "${EMULATION_NAME}",
1046   "${OUTPUT_FORMAT}",
1047   0,    /* finish */
1048   0,    /* create_output_section_statements */
1049   0,    /* open_dynamic_archive */
1050   0,    /* place_orphan */
1051   0,    /* set_symbols */
1052   gld${EMULATION_NAME}_parse_args,
1053   gld${EMULATION_NAME}_unrecognized_file,
1054   NULL  /* find_potential_libraries */
1055 };
1056 EOF