OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [ld/] [emultempl/] [aix.em] - Blame information for rev 179

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.