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