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