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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [ld/] [emultempl/] [elf32.em] - Blame information for rev 38

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
# This file is now misnamed, because it supports both 32 bit and 64 bit
4
# ELF emulations.
5
test -z "${ELFSIZE}" && ELFSIZE=32
6
if [ -z "$MACHINE" ]; then
7
  OUTPUT_ARCH=${ARCH}
8
else
9
  OUTPUT_ARCH=${ARCH}:${MACHINE}
10
fi
11
fragment <
12
/* This file is is generated by a shell script.  DO NOT EDIT! */
13
 
14
/* ${ELFSIZE} bit ELF emulation code for ${EMULATION_NAME}
15
   Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
16
   2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
17
   Written by Steve Chamberlain 
18
   ELF support by Ian Lance Taylor 
19
 
20
   This file is part of the GNU Binutils.
21
 
22
   This program is free software; you can redistribute it and/or modify
23
   it under the terms of the GNU General Public License as published by
24
   the Free Software Foundation; either version 3 of the License, or
25
   (at your option) any later version.
26
 
27
   This program is distributed in the hope that it will be useful,
28
   but WITHOUT ANY WARRANTY; without even the implied warranty of
29
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30
   GNU General Public License for more details.
31
 
32
   You should have received a copy of the GNU General Public License
33
   along with this program; if not, write to the Free Software
34
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
35
   MA 02110-1301, USA.  */
36
 
37
#define TARGET_IS_${EMULATION_NAME}
38
 
39
#include "sysdep.h"
40
#include "bfd.h"
41
#include "libiberty.h"
42
#include "safe-ctype.h"
43
#include "getopt.h"
44
#include "md5.h"
45
#include "sha1.h"
46
#include 
47
 
48
#include "bfdlink.h"
49
 
50
#include "ld.h"
51
#include "ldmain.h"
52
#include "ldmisc.h"
53
#include "ldexp.h"
54
#include "ldlang.h"
55
#include "ldfile.h"
56
#include "ldemul.h"
57
#include 
58
#include "elf/common.h"
59
#include "elf-bfd.h"
60
 
61
/* Declare functions used by various EXTRA_EM_FILEs.  */
62
static void gld${EMULATION_NAME}_before_parse (void);
63
static void gld${EMULATION_NAME}_after_open (void);
64
static void gld${EMULATION_NAME}_before_allocation (void);
65
static bfd_boolean gld${EMULATION_NAME}_place_orphan (asection *s);
66
static void gld${EMULATION_NAME}_finish (void);
67
 
68
EOF
69
 
70
if [ "x${USE_LIBPATH}" = xyes ] ; then
71
  case ${target} in
72
    *-*-linux-* | *-*-k*bsd*-*)
73
  fragment <
74
#ifdef HAVE_GLOB
75
#include 
76
#endif
77
EOF
78
    ;;
79
  esac
80
fi
81
 
82
# Import any needed special functions and/or overrides.
83
#
84
source_em ${srcdir}/emultempl/elf-generic.em
85
if test -n "$EXTRA_EM_FILE" ; then
86
  source_em ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
87
fi
88
 
89
# Functions in this file can be overridden by setting the LDEMUL_* shell
90
# variables.  If the name of the overriding function is the same as is
91
# defined in this file, then don't output this file's version.
92
# If a different overriding name is given then output the standard function
93
# as presumably it is called from the overriding function.
94
#
95
if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
96
fragment <
97
 
98
static void
99
gld${EMULATION_NAME}_before_parse (void)
100
{
101
  ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
102
  config.dynamic_link = ${DYNAMIC_LINK-TRUE};
103
  config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
104
}
105
 
106
EOF
107
fi
108
 
109
if test x"$LDEMUL_RECOGNIZED_FILE" != xgld"${EMULATION_NAME}"_load_symbols; then
110
fragment <
111
/* Handle as_needed DT_NEEDED.  */
112
 
113
static bfd_boolean
114
gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *entry)
115
{
116
  int class = 0;
117
 
118
  /* Tell the ELF linker that we don't want the output file to have a
119
     DT_NEEDED entry for this file, unless it is used to resolve
120
     references in a regular object.  */
121
  if (entry->as_needed)
122
    class = DYN_AS_NEEDED;
123
 
124
  /* Tell the ELF linker that we don't want the output file to have a
125
     DT_NEEDED entry for any dynamic library in DT_NEEDED tags from
126
     this file at all.  */
127
  if (!entry->add_needed)
128
    class |= DYN_NO_ADD_NEEDED;
129
 
130
  if (entry->just_syms_flag
131
      && (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0)
132
    einfo (_("%P%F: --just-symbols may not be used on DSO: %B\n"),
133
           entry->the_bfd);
134
 
135
  if (!class
136
      || (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) == 0)
137
    return FALSE;
138
 
139
  bfd_elf_set_dyn_lib_class (entry->the_bfd, class);
140
 
141
  /* Continue on with normal load_symbols processing.  */
142
  return FALSE;
143
}
144
EOF
145
fi
146
 
147
fragment <
148
 
149
/* These variables are required to pass information back and forth
150
   between after_open and check_needed and stat_needed and vercheck.  */
151
 
152
static struct bfd_link_needed_list *global_needed;
153
static struct stat global_stat;
154
static lang_input_statement_type *global_found;
155
static struct bfd_link_needed_list *global_vercheck_needed;
156
static bfd_boolean global_vercheck_failed;
157
 
158
 
159
/* On Linux, it's possible to have different versions of the same
160
   shared library linked against different versions of libc.  The
161
   dynamic linker somehow tags which libc version to use in
162
   /etc/ld.so.cache, and, based on the libc that it sees in the
163
   executable, chooses which version of the shared library to use.
164
 
165
   We try to do a similar check here by checking whether this shared
166
   library needs any other shared libraries which may conflict with
167
   libraries we have already included in the link.  If it does, we
168
   skip it, and try to find another shared library farther on down the
169
   link path.
170
 
171
   This is called via lang_for_each_input_file.
172
   GLOBAL_VERCHECK_NEEDED is the list of objects needed by the object
173
   which we are checking.  This sets GLOBAL_VERCHECK_FAILED if we find
174
   a conflicting version.  */
175
 
176
static void
177
gld${EMULATION_NAME}_vercheck (lang_input_statement_type *s)
178
{
179
  const char *soname;
180
  struct bfd_link_needed_list *l;
181
 
182
  if (global_vercheck_failed)
183
    return;
184
  if (s->the_bfd == NULL
185
      || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0)
186
    return;
187
 
188
  soname = bfd_elf_get_dt_soname (s->the_bfd);
189
  if (soname == NULL)
190
    soname = lbasename (bfd_get_filename (s->the_bfd));
191
 
192
  for (l = global_vercheck_needed; l != NULL; l = l->next)
193
    {
194
      const char *suffix;
195
 
196
      if (strcmp (soname, l->name) == 0)
197
        {
198
          /* Probably can't happen, but it's an easy check.  */
199
          continue;
200
        }
201
 
202
      if (strchr (l->name, '/') != NULL)
203
        continue;
204
 
205
      suffix = strstr (l->name, ".so.");
206
      if (suffix == NULL)
207
        continue;
208
 
209
      suffix += sizeof ".so." - 1;
210
 
211
      if (strncmp (soname, l->name, suffix - l->name) == 0)
212
        {
213
          /* Here we know that S is a dynamic object FOO.SO.VER1, and
214
             the object we are considering needs a dynamic object
215
             FOO.SO.VER2, and VER1 and VER2 are different.  This
216
             appears to be a version mismatch, so we tell the caller
217
             to try a different version of this library.  */
218
          global_vercheck_failed = TRUE;
219
          return;
220
        }
221
    }
222
}
223
 
224
 
225
/* See if an input file matches a DT_NEEDED entry by running stat on
226
   the file.  */
227
 
228
static void
229
gld${EMULATION_NAME}_stat_needed (lang_input_statement_type *s)
230
{
231
  struct stat st;
232
  const char *suffix;
233
  const char *soname;
234
 
235
  if (global_found != NULL)
236
    return;
237
  if (s->the_bfd == NULL)
238
    return;
239
 
240
  /* If this input file was an as-needed entry, and wasn't found to be
241
     needed at the stage it was linked, then don't say we have loaded it.  */
242
  if ((bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
243
    return;
244
 
245
  if (bfd_stat (s->the_bfd, &st) != 0)
246
    {
247
      einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
248
      return;
249
    }
250
 
251
  /* Some operating systems, e.g. Windows, do not provide a meaningful
252
     st_ino; they always set it to zero.  (Windows does provide a
253
     meaningful st_dev.)  Do not indicate a duplicate library in that
254
     case.  While there is no guarantee that a system that provides
255
     meaningful inode numbers will never set st_ino to zero, this is
256
     merely an optimization, so we do not need to worry about false
257
     negatives.  */
258
  if (st.st_dev == global_stat.st_dev
259
      && st.st_ino == global_stat.st_ino
260
      && st.st_ino != 0)
261
    {
262
      global_found = s;
263
      return;
264
    }
265
 
266
  /* We issue a warning if it looks like we are including two
267
     different versions of the same shared library.  For example,
268
     there may be a problem if -lc picks up libc.so.6 but some other
269
     shared library has a DT_NEEDED entry of libc.so.5.  This is a
270
     heuristic test, and it will only work if the name looks like
271
     NAME.so.VERSION.  FIXME: Depending on file names is error-prone.
272
     If we really want to issue warnings about mixing version numbers
273
     of shared libraries, we need to find a better way.  */
274
 
275
  if (strchr (global_needed->name, '/') != NULL)
276
    return;
277
  suffix = strstr (global_needed->name, ".so.");
278
  if (suffix == NULL)
279
    return;
280
  suffix += sizeof ".so." - 1;
281
 
282
  soname = bfd_elf_get_dt_soname (s->the_bfd);
283
  if (soname == NULL)
284
    soname = lbasename (s->filename);
285
 
286
  if (strncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
287
    einfo ("%P: warning: %s, needed by %B, may conflict with %s\n",
288
           global_needed->name, global_needed->by, soname);
289
}
290
 
291
struct dt_needed
292
{
293
  bfd *by;
294
  const char *name;
295
};
296
 
297
/* This function is called for each possible name for a dynamic object
298
   named by a DT_NEEDED entry.  The FORCE parameter indicates whether
299
   to skip the check for a conflicting version.  */
300
 
301
static bfd_boolean
302
gld${EMULATION_NAME}_try_needed (struct dt_needed *needed,
303
                                 int force)
304
{
305
  bfd *abfd;
306
  const char *name = needed->name;
307
  const char *soname;
308
  int class;
309
 
310
  abfd = bfd_openr (name, bfd_get_target (link_info.output_bfd));
311
  if (abfd == NULL)
312
    return FALSE;
313
  if (! bfd_check_format (abfd, bfd_object))
314
    {
315
      bfd_close (abfd);
316
      return FALSE;
317
    }
318
  if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
319
    {
320
      bfd_close (abfd);
321
      return FALSE;
322
    }
323
 
324
  /* For DT_NEEDED, they have to match.  */
325
  if (abfd->xvec != link_info.output_bfd->xvec)
326
    {
327
      bfd_close (abfd);
328
      return FALSE;
329
    }
330
 
331
  /* Check whether this object would include any conflicting library
332
     versions.  If FORCE is set, then we skip this check; we use this
333
     the second time around, if we couldn't find any compatible
334
     instance of the shared library.  */
335
 
336
  if (! force)
337
    {
338
      struct bfd_link_needed_list *needed;
339
 
340
      if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
341
        einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
342
 
343
      if (needed != NULL)
344
        {
345
          global_vercheck_needed = needed;
346
          global_vercheck_failed = FALSE;
347
          lang_for_each_input_file (gld${EMULATION_NAME}_vercheck);
348
          if (global_vercheck_failed)
349
            {
350
              bfd_close (abfd);
351
              /* Return FALSE to force the caller to move on to try
352
                 another file on the search path.  */
353
              return FALSE;
354
            }
355
 
356
          /* But wait!  It gets much worse.  On Linux, if a shared
357
             library does not use libc at all, we are supposed to skip
358
             it the first time around in case we encounter a shared
359
             library later on with the same name which does use the
360
             version of libc that we want.  This is much too horrible
361
             to use on any system other than Linux.  */
362
 
363
EOF
364
case ${target} in
365
  *-*-linux-* | *-*-k*bsd*-*)
366
    fragment <
367
          {
368
            struct bfd_link_needed_list *l;
369
 
370
            for (l = needed; l != NULL; l = l->next)
371
              if (CONST_STRNEQ (l->name, "libc.so"))
372
                break;
373
            if (l == NULL)
374
              {
375
                bfd_close (abfd);
376
                return FALSE;
377
              }
378
          }
379
 
380
EOF
381
    ;;
382
esac
383
fragment <
384
        }
385
    }
386
 
387
  /* We've found a dynamic object matching the DT_NEEDED entry.  */
388
 
389
  /* We have already checked that there is no other input file of the
390
     same name.  We must now check again that we are not including the
391
     same file twice.  We need to do this because on many systems
392
     libc.so is a symlink to, e.g., libc.so.1.  The SONAME entry will
393
     reference libc.so.1.  If we have already included libc.so, we
394
     don't want to include libc.so.1 if they are the same file, and we
395
     can only check that using stat.  */
396
 
397
  if (bfd_stat (abfd, &global_stat) != 0)
398
    einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
399
 
400
  /* First strip off everything before the last '/'.  */
401
  soname = lbasename (abfd->filename);
402
 
403
  if (trace_file_tries)
404
    info_msg (_("found %s at %s\n"), soname, name);
405
 
406
  global_found = NULL;
407
  lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
408
  if (global_found != NULL)
409
    {
410
      /* Return TRUE to indicate that we found the file, even though
411
         we aren't going to do anything with it.  */
412
      return TRUE;
413
    }
414
 
415
  /* Specify the soname to use.  */
416
  bfd_elf_set_dt_needed_name (abfd, soname);
417
 
418
  /* Tell the ELF linker that we don't want the output file to have a
419
     DT_NEEDED entry for this file, unless it is used to resolve
420
     references in a regular object.  */
421
  class = DYN_DT_NEEDED;
422
 
423
  /* Tell the ELF linker that we don't want the output file to have a
424
     DT_NEEDED entry for this file at all if the entry is from a file
425
     with DYN_NO_ADD_NEEDED.  */
426
  if (needed->by != NULL
427
      && (bfd_elf_get_dyn_lib_class (needed->by) & DYN_NO_ADD_NEEDED) != 0)
428
    class |= DYN_NO_NEEDED | DYN_NO_ADD_NEEDED;
429
 
430
  bfd_elf_set_dyn_lib_class (abfd, class);
431
 
432
  /* Add this file into the symbol table.  */
433
  if (! bfd_link_add_symbols (abfd, &link_info))
434
    einfo ("%F%B: could not read symbols: %E\n", abfd);
435
 
436
  return TRUE;
437
}
438
 
439
 
440
/* Search for a needed file in a path.  */
441
 
442
static bfd_boolean
443
gld${EMULATION_NAME}_search_needed (const char *path,
444
                                    struct dt_needed *n, int force)
445
{
446
  const char *s;
447
  const char *name = n->name;
448
  size_t len;
449
  struct dt_needed needed;
450
 
451
  if (name[0] == '/')
452
    return gld${EMULATION_NAME}_try_needed (n, force);
453
 
454
  if (path == NULL || *path == '\0')
455
    return FALSE;
456
 
457
  needed.by = n->by;
458
  needed.name = n->name;
459
 
460
  len = strlen (name);
461
  while (1)
462
    {
463
      char *filename, *sset;
464
 
465
      s = strchr (path, config.rpath_separator);
466
      if (s == NULL)
467
        s = path + strlen (path);
468
 
469
      filename = (char *) xmalloc (s - path + len + 2);
470
      if (s == path)
471
        sset = filename;
472
      else
473
        {
474
          memcpy (filename, path, s - path);
475
          filename[s - path] = '/';
476
          sset = filename + (s - path) + 1;
477
        }
478
      strcpy (sset, name);
479
 
480
      needed.name = filename;
481
      if (gld${EMULATION_NAME}_try_needed (&needed, force))
482
        return TRUE;
483
 
484
      free (filename);
485
 
486
      if (*s == '\0')
487
        break;
488
      path = s + 1;
489
    }
490
 
491
  return FALSE;
492
}
493
 
494
EOF
495
if [ "x${USE_LIBPATH}" = xyes ] ; then
496
  fragment <
497
 
498
/* Add the sysroot to every entry in a path separated by
499
   config.rpath_separator.  */
500
 
501
static char *
502
gld${EMULATION_NAME}_add_sysroot (const char *path)
503
{
504
  int len, colons, i;
505
  char *ret, *p;
506
 
507
  len = strlen (path);
508
  colons = 0;
509
  i = 0;
510
  while (path[i])
511
    if (path[i++] == config.rpath_separator)
512
      colons++;
513
 
514
  if (path[i])
515
    colons++;
516
 
517
  len = len + (colons + 1) * strlen (ld_sysroot);
518
  ret = xmalloc (len + 1);
519
  strcpy (ret, ld_sysroot);
520
  p = ret + strlen (ret);
521
  i = 0;
522
  while (path[i])
523
    if (path[i] == config.rpath_separator)
524
      {
525
        *p++ = path[i++];
526
        strcpy (p, ld_sysroot);
527
        p = p + strlen (p);
528
      }
529
    else
530
      *p++ = path[i++];
531
 
532
  *p = 0;
533
  return ret;
534
}
535
 
536
EOF
537
  case ${target} in
538
    *-*-freebsd* | *-*-dragonfly*)
539
      fragment <
540
/* Read the system search path the FreeBSD way rather than the Linux way.  */
541
#ifdef HAVE_ELF_HINTS_H
542
#include 
543
#else
544
#include "elf-hints-local.h"
545
#endif
546
 
547
static bfd_boolean
548
gld${EMULATION_NAME}_check_ld_elf_hints (const char *name, int force)
549
{
550
  static bfd_boolean initialized;
551
  static char *ld_elf_hints;
552
  struct dt_needed needed;
553
 
554
  if (!initialized)
555
    {
556
      FILE *f;
557
      char *tmppath;
558
 
559
      tmppath = concat (ld_sysroot, _PATH_ELF_HINTS, (const char *) NULL);
560
      f = fopen (tmppath, FOPEN_RB);
561
      free (tmppath);
562
      if (f != NULL)
563
        {
564
          struct elfhints_hdr hdr;
565
 
566
          if (fread (&hdr, 1, sizeof (hdr), f) == sizeof (hdr)
567
              && hdr.magic == ELFHINTS_MAGIC
568
              && hdr.version == 1)
569
            {
570
              if (fseek (f, hdr.strtab + hdr.dirlist, SEEK_SET) != -1)
571
                {
572
                  char *b;
573
 
574
                  b = xmalloc (hdr.dirlistlen + 1);
575
                  if (fread (b, 1, hdr.dirlistlen + 1, f) ==
576
                      hdr.dirlistlen + 1)
577
                    ld_elf_hints = gld${EMULATION_NAME}_add_sysroot (b);
578
 
579
                  free (b);
580
                }
581
            }
582
          fclose (f);
583
        }
584
 
585
      initialized = TRUE;
586
    }
587
 
588
  if (ld_elf_hints == NULL)
589
    return FALSE;
590
 
591
  needed.by = NULL;
592
  needed.name = name;
593
  return gld${EMULATION_NAME}_search_needed (ld_elf_hints, & needed,
594
                                             force);
595
}
596
EOF
597
    # FreeBSD
598
    ;;
599
 
600
    *-*-linux-* | *-*-k*bsd*-*)
601
      fragment <
602
/* For a native linker, check the file /etc/ld.so.conf for directories
603
   in which we may find shared libraries.  /etc/ld.so.conf is really
604
   only meaningful on Linux.  */
605
 
606
struct gld${EMULATION_NAME}_ld_so_conf
607
{
608
  char *path;
609
  size_t len, alloc;
610
};
611
 
612
static bfd_boolean
613
gld${EMULATION_NAME}_parse_ld_so_conf
614
     (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename);
615
 
616
static void
617
gld${EMULATION_NAME}_parse_ld_so_conf_include
618
     (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename,
619
      const char *pattern)
620
{
621
  char *newp = NULL;
622
#ifdef HAVE_GLOB
623
  glob_t gl;
624
#endif
625
 
626
  if (pattern[0] != '/')
627
    {
628
      char *p = strrchr (filename, '/');
629
      size_t patlen = strlen (pattern) + 1;
630
 
631
      newp = xmalloc (p - filename + 1 + patlen);
632
      memcpy (newp, filename, p - filename + 1);
633
      memcpy (newp + (p - filename + 1), pattern, patlen);
634
      pattern = newp;
635
    }
636
 
637
#ifdef HAVE_GLOB
638
  if (glob (pattern, 0, NULL, &gl) == 0)
639
    {
640
      size_t i;
641
 
642
      for (i = 0; i < gl.gl_pathc; ++i)
643
        gld${EMULATION_NAME}_parse_ld_so_conf (info, gl.gl_pathv[i]);
644
      globfree (&gl);
645
    }
646
#else
647
  /* If we do not have glob, treat the pattern as a literal filename.  */
648
  gld${EMULATION_NAME}_parse_ld_so_conf (info, pattern);
649
#endif
650
 
651
  if (newp)
652
    free (newp);
653
}
654
 
655
static bfd_boolean
656
gld${EMULATION_NAME}_parse_ld_so_conf
657
     (struct gld${EMULATION_NAME}_ld_so_conf *info, const char *filename)
658
{
659
  FILE *f = fopen (filename, FOPEN_RT);
660
  char *line;
661
  size_t linelen;
662
 
663
  if (f == NULL)
664
    return FALSE;
665
 
666
  linelen = 256;
667
  line = xmalloc (linelen);
668
  do
669
    {
670
      char *p = line, *q;
671
 
672
      /* Normally this would use getline(3), but we need to be portable.  */
673
      while ((q = fgets (p, linelen - (p - line), f)) != NULL
674
             && strlen (q) == linelen - (p - line) - 1
675
             && line[linelen - 2] != '\n')
676
        {
677
          line = xrealloc (line, 2 * linelen);
678
          p = line + linelen - 1;
679
          linelen += linelen;
680
        }
681
 
682
      if (q == NULL && p == line)
683
        break;
684
 
685
      p = strchr (line, '\n');
686
      if (p)
687
        *p = '\0';
688
 
689
      /* Because the file format does not know any form of quoting we
690
         can search forward for the next '#' character and if found
691
         make it terminating the line.  */
692
      p = strchr (line, '#');
693
      if (p)
694
        *p = '\0';
695
 
696
      /* Remove leading whitespace.  NUL is no whitespace character.  */
697
      p = line;
698
      while (*p == ' ' || *p == '\f' || *p == '\r' || *p == '\t' || *p == '\v')
699
        ++p;
700
 
701
      /* If the line is blank it is ignored.  */
702
      if (p[0] == '\0')
703
        continue;
704
 
705
      if (CONST_STRNEQ (p, "include") && (p[7] == ' ' || p[7] == '\t'))
706
        {
707
          char *dir, c;
708
          p += 8;
709
          do
710
            {
711
              while (*p == ' ' || *p == '\t')
712
                ++p;
713
 
714
              if (*p == '\0')
715
                break;
716
 
717
              dir = p;
718
 
719
              while (*p != ' ' && *p != '\t' && *p)
720
                ++p;
721
 
722
              c = *p;
723
              *p++ = '\0';
724
              if (dir[0] != '\0')
725
                gld${EMULATION_NAME}_parse_ld_so_conf_include (info, filename,
726
                                                               dir);
727
            }
728
          while (c != '\0');
729
        }
730
      else
731
        {
732
          char *dir = p;
733
          while (*p && *p != '=' && *p != ' ' && *p != '\t' && *p != '\f'
734
                 && *p != '\r' && *p != '\v')
735
            ++p;
736
 
737
          while (p != dir && p[-1] == '/')
738
            --p;
739
          if (info->path == NULL)
740
            {
741
              info->alloc = p - dir + 1 + 256;
742
              info->path = xmalloc (info->alloc);
743
              info->len = 0;
744
            }
745
          else
746
            {
747
              if (info->len + 1 + (p - dir) >= info->alloc)
748
                {
749
                  info->alloc += p - dir + 256;
750
                  info->path = xrealloc (info->path, info->alloc);
751
                }
752
              info->path[info->len++] = config.rpath_separator;
753
            }
754
          memcpy (info->path + info->len, dir, p - dir);
755
          info->len += p - dir;
756
          info->path[info->len] = '\0';
757
        }
758
    }
759
  while (! feof (f));
760
  free (line);
761
  fclose (f);
762
  return TRUE;
763
}
764
 
765
static bfd_boolean
766
gld${EMULATION_NAME}_check_ld_so_conf (const char *name, int force)
767
{
768
  static bfd_boolean initialized;
769
  static char *ld_so_conf;
770
  struct dt_needed needed;
771
 
772
  if (! initialized)
773
    {
774
      char *tmppath;
775
      struct gld${EMULATION_NAME}_ld_so_conf info;
776
 
777
      info.path = NULL;
778
      info.len = info.alloc = 0;
779
      tmppath = concat (ld_sysroot, "${prefix}/etc/ld.so.conf",
780
                        (const char *) NULL);
781
      if (!gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath))
782
        {
783
          free (tmppath);
784
          tmppath = concat (ld_sysroot, "/etc/ld.so.conf",
785
                            (const char *) NULL);
786
          gld${EMULATION_NAME}_parse_ld_so_conf (&info, tmppath);
787
        }
788
      free (tmppath);
789
 
790
      if (info.path)
791
        {
792
          char *d = gld${EMULATION_NAME}_add_sysroot (info.path);
793
          free (info.path);
794
          ld_so_conf = d;
795
        }
796
      initialized = TRUE;
797
    }
798
 
799
  if (ld_so_conf == NULL)
800
    return FALSE;
801
 
802
 
803
  needed.by = NULL;
804
  needed.name = name;
805
  return gld${EMULATION_NAME}_search_needed (ld_so_conf, &needed, force);
806
}
807
 
808
EOF
809
    # Linux
810
    ;;
811
  esac
812
fi
813
fragment <
814
 
815
/* See if an input file matches a DT_NEEDED entry by name.  */
816
 
817
static void
818
gld${EMULATION_NAME}_check_needed (lang_input_statement_type *s)
819
{
820
  const char *soname;
821
 
822
  /* Stop looking if we've found a loaded lib.  */
823
  if (global_found != NULL
824
      && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
825
          & DYN_AS_NEEDED) == 0)
826
    return;
827
 
828
  if (s->filename == NULL || s->the_bfd == NULL)
829
    return;
830
 
831
  /* Don't look for a second non-loaded as-needed lib.  */
832
  if (global_found != NULL
833
      && (bfd_elf_get_dyn_lib_class (s->the_bfd) & DYN_AS_NEEDED) != 0)
834
    return;
835
 
836
  if (strcmp (s->filename, global_needed->name) == 0)
837
    {
838
      global_found = s;
839
      return;
840
    }
841
 
842
  if (s->search_dirs_flag)
843
    {
844
      const char *f = strrchr (s->filename, '/');
845
      if (f != NULL
846
          && strcmp (f + 1, global_needed->name) == 0)
847
        {
848
          global_found = s;
849
          return;
850
        }
851
    }
852
 
853
  soname = bfd_elf_get_dt_soname (s->the_bfd);
854
  if (soname != NULL
855
      && strcmp (soname, global_needed->name) == 0)
856
    {
857
      global_found = s;
858
      return;
859
    }
860
}
861
 
862
EOF
863
 
864
if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then
865
fragment <
866
 
867
static bfd_size_type
868
gld${EMULATION_NAME}_id_note_section_size (bfd *abfd,
869
                                           struct bfd_link_info *link_info)
870
{
871
  const char *style = link_info->emit_note_gnu_build_id;
872
  bfd_size_type size;
873
 
874
  abfd = abfd;
875
 
876
  size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
877
  size = (size + 3) & -(bfd_size_type) 4;
878
 
879
  if (!strcmp (style, "md5") || !strcmp (style, "uuid"))
880
    size += 128 / 8;
881
  else if (!strcmp (style, "sha1"))
882
    size += 160 / 8;
883
  else if (!strncmp (style, "0x", 2))
884
    {
885
      /* ID is in string form (hex).  Convert to bits.  */
886
      const char *id = style + 2;
887
      do
888
        {
889
          if (ISXDIGIT (id[0]) && ISXDIGIT (id[1]))
890
            {
891
              ++size;
892
              id += 2;
893
            }
894
          else if (*id == '-' || *id == ':')
895
            ++id;
896
          else
897
            {
898
              size = 0;
899
              break;
900
            }
901
        } while (*id != '\0');
902
    }
903
  else
904
    size = 0;
905
 
906
  return size;
907
}
908
 
909
static unsigned char
910
read_hex (const char xdigit)
911
{
912
  if (ISDIGIT (xdigit))
913
    return xdigit - '0';
914
  if (ISUPPER (xdigit))
915
    return xdigit - 'A' + 0xa;
916
  if (ISLOWER (xdigit))
917
    return xdigit - 'a' + 0xa;
918
  abort ();
919
  return 0;
920
}
921
 
922
struct build_id_info
923
{
924
  const char *style;
925
  asection *sec;
926
};
927
 
928
static bfd_boolean
929
gld${EMULATION_NAME}_write_build_id_section (bfd *abfd)
930
{
931
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
932
  struct build_id_info *info =
933
    elf_tdata (abfd)->after_write_object_contents_info;
934
  asection *asec;
935
  Elf_Internal_Shdr *i_shdr;
936
  unsigned char *contents, *id_bits;
937
  bfd_size_type size;
938
  Elf_External_Note *e_note;
939
 
940
  asec = info->sec;
941
  if (bfd_is_abs_section (asec->output_section))
942
    {
943
      einfo (_("%P: warning: .note.gnu.build-id section discarded,"
944
               " --build-id ignored.\n"));
945
      return TRUE;
946
    }
947
  i_shdr = &elf_section_data (asec->output_section)->this_hdr;
948
 
949
  if (i_shdr->contents == NULL)
950
    {
951
      if (asec->contents == NULL)
952
        asec->contents = xmalloc (asec->size);
953
      contents = asec->contents;
954
    }
955
  else
956
    contents = i_shdr->contents + asec->output_offset;
957
 
958
  e_note = (void *) contents;
959
  size = offsetof (Elf_External_Note, name[sizeof "GNU"]);
960
  size = (size + 3) & -(bfd_size_type) 4;
961
  id_bits = contents + size;
962
  size = asec->size - size;
963
 
964
  bfd_h_put_32 (abfd, sizeof "GNU", &e_note->namesz);
965
  bfd_h_put_32 (abfd, size, &e_note->descsz);
966
  bfd_h_put_32 (abfd, NT_GNU_BUILD_ID, &e_note->type);
967
  memcpy (e_note->name, "GNU", sizeof "GNU");
968
 
969
  if (!strcmp (info->style, "md5"))
970
    {
971
      struct md5_ctx ctx;
972
      md5_init_ctx (&ctx);
973
      if (bed->s->checksum_contents (abfd,
974
                                     (void (*) (const void *, size_t, void *))
975
                                     &md5_process_bytes,
976
                                     &ctx))
977
        md5_finish_ctx (&ctx, id_bits);
978
      else
979
        return FALSE;
980
    }
981
  else if (!strcmp (info->style, "sha1"))
982
    {
983
      struct sha1_ctx ctx;
984
      sha1_init_ctx (&ctx);
985
      if (bed->s->checksum_contents (abfd,
986
                                     (void (*) (const void *, size_t, void *))
987
                                     &sha1_process_bytes,
988
                                     &ctx))
989
        sha1_finish_ctx (&ctx, id_bits);
990
      else
991
        return FALSE;
992
    }
993
  else if (!strcmp (info->style, "uuid"))
994
    {
995
      int n;
996
      int fd = open ("/dev/urandom", O_RDONLY);
997
      if (fd < 0)
998
        return FALSE;
999
      n = read (fd, id_bits, size);
1000
      close (fd);
1001
      if (n < (int) size)
1002
        return FALSE;
1003
    }
1004
  else if (!strncmp (info->style, "0x", 2))
1005
    {
1006
      /* ID is in string form (hex).  Convert to bits.  */
1007
      const char *id = info->style + 2;
1008
      size_t n = 0;
1009
      do
1010
        {
1011
          if (ISXDIGIT (id[0]) && ISXDIGIT (id[1]))
1012
            {
1013
              id_bits[n] = read_hex (*id++) << 4;
1014
              id_bits[n++] |= read_hex (*id++);
1015
            }
1016
          else if (*id == '-' || *id == ':')
1017
            ++id;
1018
          else
1019
            abort ();           /* Should have been validated earlier.  */
1020
        } while (*id != '\0');
1021
    }
1022
  else
1023
    abort ();                   /* Should have been validated earlier.  */
1024
 
1025
  size = asec->size;
1026
  return (bfd_seek (abfd,
1027
                    i_shdr->sh_offset + asec->output_offset, SEEK_SET) == 0
1028
          && bfd_bwrite (contents, size, abfd) == size);
1029
}
1030
 
1031
 
1032
/* This is called after all the input files have been opened.  */
1033
 
1034
static void
1035
gld${EMULATION_NAME}_after_open (void)
1036
{
1037
  struct bfd_link_needed_list *needed, *l;
1038
  struct elf_link_hash_table *htab;
1039
 
1040
  htab = elf_hash_table (&link_info);
1041
  if (!is_elf_hash_table (htab))
1042
    return;
1043
 
1044
  if (link_info.emit_note_gnu_build_id)
1045
    {
1046
      bfd *abfd;
1047
      asection *s;
1048
      bfd_size_type size;
1049
 
1050
      abfd = link_info.input_bfds;
1051
 
1052
      size = gld${EMULATION_NAME}_id_note_section_size (abfd, &link_info);
1053
      if (size == 0)
1054
        {
1055
          einfo ("%P: warning: unrecognized --build-id style ignored.\n");
1056
          free (link_info.emit_note_gnu_build_id);
1057
          link_info.emit_note_gnu_build_id = NULL;
1058
        }
1059
      else
1060
        {
1061
          s = bfd_make_section_with_flags (abfd, ".note.gnu.build-id",
1062
                                           SEC_ALLOC | SEC_LOAD
1063
                                           | SEC_IN_MEMORY | SEC_LINKER_CREATED
1064
                                           | SEC_READONLY | SEC_DATA);
1065
          if (s != NULL && bfd_set_section_alignment (abfd, s, 2))
1066
            {
1067
              struct elf_obj_tdata *t = elf_tdata (link_info.output_bfd);
1068
              struct build_id_info *b = xmalloc (sizeof *b);
1069
              b->style = link_info.emit_note_gnu_build_id;
1070
              b->sec = s;
1071
              elf_section_type (s) = SHT_NOTE;
1072
              s->size = size;
1073
              t->after_write_object_contents
1074
                = &gld${EMULATION_NAME}_write_build_id_section;
1075
              t->after_write_object_contents_info = b;
1076
            }
1077
          else
1078
            {
1079
              einfo ("%P: warning: Cannot create .note.gnu.build-id section,"
1080
                     " --build-id ignored.\n");
1081
              free (link_info.emit_note_gnu_build_id);
1082
              link_info.emit_note_gnu_build_id = NULL;
1083
            }
1084
        }
1085
    }
1086
 
1087
  if (link_info.relocatable)
1088
    return;
1089
 
1090
  if (link_info.eh_frame_hdr
1091
      && !link_info.traditional_format)
1092
    {
1093
      bfd *abfd;
1094
      asection *s;
1095
 
1096
      for (abfd = link_info.input_bfds; abfd; abfd = abfd->link_next)
1097
        {
1098
          s = bfd_get_section_by_name (abfd, ".eh_frame");
1099
          if (s && s->size > 8 && !bfd_is_abs_section (s->output_section))
1100
            break;
1101
        }
1102
      if (abfd)
1103
        {
1104
          const struct elf_backend_data *bed;
1105
 
1106
          bed = get_elf_backend_data (abfd);
1107
          s = bfd_make_section_with_flags (abfd, ".eh_frame_hdr",
1108
                                           bed->dynamic_sec_flags
1109
                                           | SEC_READONLY);
1110
          if (s != NULL
1111
              && bfd_set_section_alignment (abfd, s, 2))
1112
            htab->eh_info.hdr_sec = s;
1113
          else
1114
            einfo ("%P: warning: Cannot create .eh_frame_hdr section,"
1115
                   " --eh-frame-hdr ignored.\n");
1116
        }
1117
    }
1118
 
1119
  /* Get the list of files which appear in DT_NEEDED entries in
1120
     dynamic objects included in the link (often there will be none).
1121
     For each such file, we want to track down the corresponding
1122
     library, and include the symbol table in the link.  This is what
1123
     the runtime dynamic linker will do.  Tracking the files down here
1124
     permits one dynamic object to include another without requiring
1125
     special action by the person doing the link.  Note that the
1126
     needed list can actually grow while we are stepping through this
1127
     loop.  */
1128
  if (!link_info.executable)
1129
    return;
1130
  needed = bfd_elf_get_needed_list (link_info.output_bfd, &link_info);
1131
  for (l = needed; l != NULL; l = l->next)
1132
    {
1133
      struct bfd_link_needed_list *ll;
1134
      struct dt_needed n, nn;
1135
      int force;
1136
 
1137
      /* If the lib that needs this one was --as-needed and wasn't
1138
         found to be needed, then this lib isn't needed either.  */
1139
      if (l->by != NULL
1140
          && (bfd_elf_get_dyn_lib_class (l->by) & DYN_AS_NEEDED) != 0)
1141
        continue;
1142
 
1143
      /* If we've already seen this file, skip it.  */
1144
      for (ll = needed; ll != l; ll = ll->next)
1145
        if ((ll->by == NULL
1146
             || (bfd_elf_get_dyn_lib_class (ll->by) & DYN_AS_NEEDED) == 0)
1147
            && strcmp (ll->name, l->name) == 0)
1148
          break;
1149
      if (ll != l)
1150
        continue;
1151
 
1152
      /* See if this file was included in the link explicitly.  */
1153
      global_needed = l;
1154
      global_found = NULL;
1155
      lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
1156
      if (global_found != NULL
1157
          && (bfd_elf_get_dyn_lib_class (global_found->the_bfd)
1158
              & DYN_AS_NEEDED) == 0)
1159
        continue;
1160
 
1161
      n.by = l->by;
1162
      n.name = l->name;
1163
      nn.by = l->by;
1164
      if (trace_file_tries)
1165
        info_msg (_("%s needed by %B\n"), l->name, l->by);
1166
 
1167
      /* As-needed libs specified on the command line (or linker script)
1168
         take priority over libs found in search dirs.  */
1169
      if (global_found != NULL)
1170
        {
1171
          nn.name = global_found->filename;
1172
          if (gld${EMULATION_NAME}_try_needed (&nn, TRUE))
1173
            continue;
1174
        }
1175
 
1176
      /* We need to find this file and include the symbol table.  We
1177
         want to search for the file in the same way that the dynamic
1178
         linker will search.  That means that we want to use
1179
         rpath_link, rpath, then the environment variable
1180
         LD_LIBRARY_PATH (native only), then the DT_RPATH/DT_RUNPATH
1181
         entries (native only), then the linker script LIB_SEARCH_DIRS.
1182
         We do not search using the -L arguments.
1183
 
1184
         We search twice.  The first time, we skip objects which may
1185
         introduce version mismatches.  The second time, we force
1186
         their use.  See gld${EMULATION_NAME}_vercheck comment.  */
1187
      for (force = 0; force < 2; force++)
1188
        {
1189
          size_t len;
1190
          search_dirs_type *search;
1191
EOF
1192
if [ "x${NATIVE}" = xyes ] ; then
1193
fragment <
1194
          const char *lib_path;
1195
EOF
1196
fi
1197
if [ "x${USE_LIBPATH}" = xyes ] ; then
1198
fragment <
1199
          struct bfd_link_needed_list *rp;
1200
          int found;
1201
EOF
1202
fi
1203
fragment <
1204
 
1205
          if (gld${EMULATION_NAME}_search_needed (command_line.rpath_link,
1206
                                                  &n, force))
1207
            break;
1208
EOF
1209
if [ "x${USE_LIBPATH}" = xyes ] ; then
1210
fragment <
1211
          if (gld${EMULATION_NAME}_search_needed (command_line.rpath,
1212
                                                  &n, force))
1213
            break;
1214
EOF
1215
fi
1216
if [ "x${NATIVE}" = xyes ] ; then
1217
fragment <
1218
          if (command_line.rpath_link == NULL
1219
              && command_line.rpath == NULL)
1220
            {
1221
              lib_path = (const char *) getenv ("LD_RUN_PATH");
1222
              if (gld${EMULATION_NAME}_search_needed (lib_path, &n,
1223
                                                      force))
1224
                break;
1225
            }
1226
          lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
1227
          if (gld${EMULATION_NAME}_search_needed (lib_path, &n, force))
1228
            break;
1229
EOF
1230
fi
1231
if [ "x${USE_LIBPATH}" = xyes ] ; then
1232
fragment <
1233
          found = 0;
1234
          rp = bfd_elf_get_runpath_list (link_info.output_bfd, &link_info);
1235
          for (; !found && rp != NULL; rp = rp->next)
1236
            {
1237
              char *tmpname = gld${EMULATION_NAME}_add_sysroot (rp->name);
1238
              found = (rp->by == l->by
1239
                       && gld${EMULATION_NAME}_search_needed (tmpname,
1240
                                                              &n,
1241
                                                              force));
1242
              free (tmpname);
1243
            }
1244
          if (found)
1245
            break;
1246
 
1247
EOF
1248
fi
1249
if [ "x${USE_LIBPATH}" = xyes ] ; then
1250
  case ${target} in
1251
    *-*-freebsd* | *-*-dragonfly*)
1252
      fragment <
1253
          if (gld${EMULATION_NAME}_check_ld_elf_hints (l->name, force))
1254
            break;
1255
EOF
1256
    # FreeBSD
1257
    ;;
1258
 
1259
    *-*-linux-* | *-*-k*bsd*-*)
1260
    # Linux
1261
      fragment <
1262
          if (gld${EMULATION_NAME}_check_ld_so_conf (l->name, force))
1263
            break;
1264
 
1265
EOF
1266
    ;;
1267
  esac
1268
fi
1269
fragment <
1270
          len = strlen (l->name);
1271
          for (search = search_head; search != NULL; search = search->next)
1272
            {
1273
              char *filename;
1274
 
1275
              if (search->cmdline)
1276
                continue;
1277
              filename = (char *) xmalloc (strlen (search->name) + len + 2);
1278
              sprintf (filename, "%s/%s", search->name, l->name);
1279
              nn.name = filename;
1280
              if (gld${EMULATION_NAME}_try_needed (&nn, force))
1281
                break;
1282
              free (filename);
1283
            }
1284
          if (search != NULL)
1285
            break;
1286
EOF
1287
fragment <
1288
        }
1289
 
1290
      if (force < 2)
1291
        continue;
1292
 
1293
      einfo ("%P: warning: %s, needed by %B, not found (try using -rpath or -rpath-link)\n",
1294
             l->name, l->by);
1295
    }
1296
}
1297
 
1298
EOF
1299
fi
1300
 
1301
fragment <
1302
 
1303
/* Look through an expression for an assignment statement.  */
1304
 
1305
static void
1306
gld${EMULATION_NAME}_find_exp_assignment (etree_type *exp)
1307
{
1308
  bfd_boolean provide = FALSE;
1309
 
1310
  switch (exp->type.node_class)
1311
    {
1312
    case etree_provide:
1313
      provide = TRUE;
1314
      /* Fall thru */
1315
    case etree_assign:
1316
      /* We call record_link_assignment even if the symbol is defined.
1317
         This is because if it is defined by a dynamic object, we
1318
         actually want to use the value defined by the linker script,
1319
         not the value from the dynamic object (because we are setting
1320
         symbols like etext).  If the symbol is defined by a regular
1321
         object, then, as it happens, calling record_link_assignment
1322
         will do no harm.  */
1323
      if (strcmp (exp->assign.dst, ".") != 0)
1324
        {
1325
          if (!bfd_elf_record_link_assignment (link_info.output_bfd,
1326
                                               &link_info,
1327
                                               exp->assign.dst, provide,
1328
                                               exp->assign.hidden))
1329
            einfo ("%P%F: failed to record assignment to %s: %E\n",
1330
                   exp->assign.dst);
1331
        }
1332
      gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
1333
      break;
1334
 
1335
    case etree_binary:
1336
      gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
1337
      gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
1338
      break;
1339
 
1340
    case etree_trinary:
1341
      gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.cond);
1342
      gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
1343
      gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
1344
      break;
1345
 
1346
    case etree_unary:
1347
      gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
1348
      break;
1349
 
1350
    default:
1351
      break;
1352
    }
1353
}
1354
 
1355
 
1356
/* This is called by the before_allocation routine via
1357
   lang_for_each_statement.  It locates any assignment statements, and
1358
   tells the ELF backend about them, in case they are assignments to
1359
   symbols which are referred to by dynamic objects.  */
1360
 
1361
static void
1362
gld${EMULATION_NAME}_find_statement_assignment (lang_statement_union_type *s)
1363
{
1364
  if (s->header.type == lang_assignment_statement_enum)
1365
    gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
1366
}
1367
 
1368
EOF
1369
 
1370
if test x"$LDEMUL_BEFORE_ALLOCATION" != xgld"$EMULATION_NAME"_before_allocation; then
1371
  if test x"${ELF_INTERPRETER_NAME+set}" = xset; then
1372
    ELF_INTERPRETER_SET_DEFAULT="
1373
  if (sinterp != NULL)
1374
    {
1375
      sinterp->contents = (unsigned char *) ${ELF_INTERPRETER_NAME};
1376
      sinterp->size = strlen ((char *) sinterp->contents) + 1;
1377
    }
1378
 
1379
"
1380
  else
1381
    ELF_INTERPRETER_SET_DEFAULT=
1382
  fi
1383
fragment <
1384
 
1385
/* This is called after the sections have been attached to output
1386
   sections, but before any sizes or addresses have been set.  */
1387
 
1388
static void
1389
gld${EMULATION_NAME}_before_allocation (void)
1390
{
1391
  const char *rpath;
1392
  asection *sinterp;
1393
 
1394
  if (link_info.hash->type == bfd_link_elf_hash_table)
1395
    _bfd_elf_tls_setup (link_info.output_bfd, &link_info);
1396
 
1397
  /* If we are going to make any variable assignments, we need to let
1398
     the ELF backend know about them in case the variables are
1399
     referred to by dynamic objects.  */
1400
  lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
1401
 
1402
  /* Let the ELF backend work out the sizes of any sections required
1403
     by dynamic linking.  */
1404
  rpath = command_line.rpath;
1405
  if (rpath == NULL)
1406
    rpath = (const char *) getenv ("LD_RUN_PATH");
1407
  if (! (bfd_elf_size_dynamic_sections
1408
         (link_info.output_bfd, command_line.soname, rpath,
1409
          command_line.filter_shlib,
1410
          (const char * const *) command_line.auxiliary_filters,
1411
          &link_info, &sinterp, lang_elf_version_info)))
1412
    einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1413
 
1414
${ELF_INTERPRETER_SET_DEFAULT}
1415
  /* Let the user override the dynamic linker we are using.  */
1416
  if (command_line.interpreter != NULL
1417
      && sinterp != NULL)
1418
    {
1419
      sinterp->contents = (bfd_byte *) command_line.interpreter;
1420
      sinterp->size = strlen (command_line.interpreter) + 1;
1421
    }
1422
 
1423
  /* Look for any sections named .gnu.warning.  As a GNU extensions,
1424
     we treat such sections as containing warning messages.  We print
1425
     out the warning message, and then zero out the section size so
1426
     that it does not get copied into the output file.  */
1427
 
1428
  {
1429
    LANG_FOR_EACH_INPUT_STATEMENT (is)
1430
      {
1431
        asection *s;
1432
        bfd_size_type sz;
1433
        char *msg;
1434
        bfd_boolean ret;
1435
 
1436
        if (is->just_syms_flag)
1437
          continue;
1438
 
1439
        s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
1440
        if (s == NULL)
1441
          continue;
1442
 
1443
        sz = s->size;
1444
        msg = xmalloc ((size_t) (sz + 1));
1445
        if (! bfd_get_section_contents (is->the_bfd, s, msg,
1446
                                        (file_ptr) 0, sz))
1447
          einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
1448
                 is->the_bfd);
1449
        msg[sz] = '\0';
1450
        ret = link_info.callbacks->warning (&link_info, msg,
1451
                                            (const char *) NULL,
1452
                                            is->the_bfd, (asection *) NULL,
1453
                                            (bfd_vma) 0);
1454
        ASSERT (ret);
1455
        free (msg);
1456
 
1457
        /* Clobber the section size, so that we don't waste space
1458
           copying the warning into the output file.  If we've already
1459
           sized the output section, adjust its size.  The adjustment
1460
           is on rawsize because targets that size sections early will
1461
           have called lang_reset_memory_regions after sizing.  */
1462
        if (s->output_section != NULL
1463
            && s->output_section->rawsize >= s->size)
1464
          s->output_section->rawsize -= s->size;
1465
 
1466
        s->size = 0;
1467
 
1468
        /* Also set SEC_EXCLUDE, so that local symbols defined in the
1469
           warning section don't get copied to the output.  */
1470
        s->flags |= SEC_EXCLUDE | SEC_KEEP;
1471
      }
1472
  }
1473
 
1474
  before_allocation_default ();
1475
 
1476
  if (!bfd_elf_size_dynsym_hash_dynstr (link_info.output_bfd, &link_info))
1477
    einfo ("%P%F: failed to set dynamic section sizes: %E\n");
1478
}
1479
 
1480
EOF
1481
fi
1482
 
1483
if test x"$LDEMUL_OPEN_DYNAMIC_ARCHIVE" != xgld"$EMULATION_NAME"_open_dynamic_archive; then
1484
fragment <
1485
 
1486
/* Try to open a dynamic archive.  This is where we know that ELF
1487
   dynamic libraries have an extension of .so (or .sl on oddball systems
1488
   like hpux).  */
1489
 
1490
static bfd_boolean
1491
gld${EMULATION_NAME}_open_dynamic_archive
1492
  (const char *arch, search_dirs_type *search, lang_input_statement_type *entry)
1493
{
1494
  const char *filename;
1495
  char *string;
1496
 
1497
  if (! entry->is_archive)
1498
    return FALSE;
1499
 
1500
  filename = entry->filename;
1501
 
1502
  /* This allocates a few bytes too many when EXTRA_SHLIB_EXTENSION
1503
     is defined, but it does not seem worth the headache to optimize
1504
     away those two bytes of space.  */
1505
  string = (char *) xmalloc (strlen (search->name)
1506
                             + strlen (filename)
1507
                             + strlen (arch)
1508
#ifdef EXTRA_SHLIB_EXTENSION
1509
                             + strlen (EXTRA_SHLIB_EXTENSION)
1510
#endif
1511
                             + sizeof "/lib.so");
1512
 
1513
  sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
1514
 
1515
#ifdef EXTRA_SHLIB_EXTENSION
1516
  /* Try the .so extension first.  If that fails build a new filename
1517
     using EXTRA_SHLIB_EXTENSION.  */
1518
  if (! ldfile_try_open_bfd (string, entry))
1519
    sprintf (string, "%s/lib%s%s%s", search->name,
1520
             filename, arch, EXTRA_SHLIB_EXTENSION);
1521
#endif
1522
 
1523
  if (! ldfile_try_open_bfd (string, entry))
1524
    {
1525
      free (string);
1526
      return FALSE;
1527
    }
1528
 
1529
  entry->filename = string;
1530
 
1531
  /* We have found a dynamic object to include in the link.  The ELF
1532
     backend linker will create a DT_NEEDED entry in the .dynamic
1533
     section naming this file.  If this file includes a DT_SONAME
1534
     entry, it will be used.  Otherwise, the ELF linker will just use
1535
     the name of the file.  For an archive found by searching, like
1536
     this one, the DT_NEEDED entry should consist of just the name of
1537
     the file, without the path information used to find it.  Note
1538
     that we only need to do this if we have a dynamic object; an
1539
     archive will never be referenced by a DT_NEEDED entry.
1540
 
1541
     FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
1542
     very pretty.  I haven't been able to think of anything that is
1543
     pretty, though.  */
1544
  if (bfd_check_format (entry->the_bfd, bfd_object)
1545
      && (entry->the_bfd->flags & DYNAMIC) != 0)
1546
    {
1547
      ASSERT (entry->is_archive && entry->search_dirs_flag);
1548
 
1549
      /* Rather than duplicating the logic above.  Just use the
1550
         filename we recorded earlier.  */
1551
 
1552
      filename = lbasename (entry->filename);
1553
      bfd_elf_set_dt_needed_name (entry->the_bfd, filename);
1554
    }
1555
 
1556
  return TRUE;
1557
}
1558
 
1559
EOF
1560
fi
1561
 
1562
if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
1563
fragment <
1564
 
1565
/* A variant of lang_output_section_find used by place_orphan.  */
1566
 
1567
static lang_output_section_statement_type *
1568
output_rel_find (asection *sec, int isdyn)
1569
{
1570
  lang_output_section_statement_type *lookup;
1571
  lang_output_section_statement_type *last = NULL;
1572
  lang_output_section_statement_type *last_alloc = NULL;
1573
  lang_output_section_statement_type *last_ro_alloc = NULL;
1574
  lang_output_section_statement_type *last_rel = NULL;
1575
  lang_output_section_statement_type *last_rel_alloc = NULL;
1576
  int rela = sec->name[4] == 'a';
1577
 
1578
  for (lookup = &lang_output_section_statement.head->output_section_statement;
1579
       lookup != NULL;
1580
       lookup = lookup->next)
1581
    {
1582
      if (lookup->constraint != -1
1583
          && CONST_STRNEQ (lookup->name, ".rel"))
1584
        {
1585
          int lookrela = lookup->name[4] == 'a';
1586
 
1587
          /* .rel.dyn must come before all other reloc sections, to suit
1588
             GNU ld.so.  */
1589
          if (isdyn)
1590
            break;
1591
 
1592
          /* Don't place after .rel.plt as doing so results in wrong
1593
             dynamic tags.  */
1594
          if (strcmp (".plt", lookup->name + 4 + lookrela) == 0)
1595
            break;
1596
 
1597
          if (rela == lookrela || last_rel == NULL)
1598
            last_rel = lookup;
1599
          if ((rela == lookrela || last_rel_alloc == NULL)
1600
              && lookup->bfd_section != NULL
1601
              && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1602
            last_rel_alloc = lookup;
1603
        }
1604
 
1605
      last = lookup;
1606
      if (lookup->bfd_section != NULL
1607
          && (lookup->bfd_section->flags & SEC_ALLOC) != 0)
1608
        {
1609
          last_alloc = lookup;
1610
          if ((lookup->bfd_section->flags & SEC_READONLY) != 0)
1611
            last_ro_alloc = lookup;
1612
        }
1613
    }
1614
 
1615
  if (last_rel_alloc)
1616
    return last_rel_alloc;
1617
 
1618
  if (last_rel)
1619
    return last_rel;
1620
 
1621
  if (last_ro_alloc)
1622
    return last_ro_alloc;
1623
 
1624
  if (last_alloc)
1625
    return last_alloc;
1626
 
1627
  return last;
1628
}
1629
 
1630
/* Place an orphan section.  We use this to put random SHF_ALLOC
1631
   sections in the right segment.  */
1632
 
1633
static bfd_boolean
1634
gld${EMULATION_NAME}_place_orphan (asection *s)
1635
{
1636
  static struct orphan_save hold[] =
1637
    {
1638
      { ".text",
1639
        SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1640
        0, 0, 0, 0 },
1641
      { ".rodata",
1642
        SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1643
        0, 0, 0, 0 },
1644
      { ".data",
1645
        SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1646
        0, 0, 0, 0 },
1647
      { ".bss",
1648
        SEC_ALLOC,
1649
        0, 0, 0, 0 },
1650
      { 0,
1651
        SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1652
        0, 0, 0, 0 },
1653
      { ".interp",
1654
        SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1655
        0, 0, 0, 0 },
1656
      { ".sdata",
1657
        SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_SMALL_DATA,
1658
        0, 0, 0, 0 }
1659
    };
1660
  enum orphan_save_index
1661
    {
1662
      orphan_text = 0,
1663
      orphan_rodata,
1664
      orphan_data,
1665
      orphan_bss,
1666
      orphan_rel,
1667
      orphan_interp,
1668
      orphan_sdata
1669
    };
1670
  static int orphan_init_done = 0;
1671
  struct orphan_save *place;
1672
  const char *secname;
1673
  lang_output_section_statement_type *after;
1674
  lang_output_section_statement_type *os;
1675
  int isdyn = 0;
1676
  int iself = s->owner->xvec->flavour == bfd_target_elf_flavour;
1677
  unsigned int sh_type = iself ? elf_section_type (s) : SHT_NULL;
1678
 
1679
  secname = bfd_get_section_name (s->owner, s);
1680
 
1681
  if (! link_info.relocatable
1682
      && link_info.combreloc
1683
      && (s->flags & SEC_ALLOC))
1684
    {
1685
      if (iself)
1686
        switch (sh_type)
1687
          {
1688
          case SHT_RELA:
1689
            secname = ".rela.dyn";
1690
            isdyn = 1;
1691
            break;
1692
          case SHT_REL:
1693
            secname = ".rel.dyn";
1694
            isdyn = 1;
1695
            break;
1696
          default:
1697
            break;
1698
          }
1699
      else if (CONST_STRNEQ (secname, ".rel"))
1700
        {
1701
          secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
1702
          isdyn = 1;
1703
        }
1704
    }
1705
 
1706
  if (isdyn || (!config.unique_orphan_sections && !unique_section_p (s)))
1707
    {
1708
      /* Look through the script to see where to place this section.  */
1709
      os = lang_output_section_find (secname);
1710
 
1711
      if (os != NULL
1712
          && (os->bfd_section == NULL
1713
              || os->bfd_section->flags == 0
1714
              || (_bfd_elf_match_sections_by_type (link_info.output_bfd,
1715
                                                   os->bfd_section,
1716
                                                   s->owner, s)
1717
                  && ((s->flags ^ os->bfd_section->flags)
1718
                      & (SEC_LOAD | SEC_ALLOC)) == 0)))
1719
        {
1720
          /* We already have an output section statement with this
1721
             name, and its bfd section, if any, has compatible flags.
1722
             If the section already exists but does not have any flags
1723
             set, then it has been created by the linker, probably as a
1724
             result of a --section-start command line switch.  */
1725
          lang_add_section (&os->children, s, os);
1726
          return TRUE;
1727
        }
1728
    }
1729
 
1730
  if (!orphan_init_done)
1731
    {
1732
      struct orphan_save *ho;
1733
      for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1734
        if (ho->name != NULL)
1735
          {
1736
            ho->os = lang_output_section_find (ho->name);
1737
            if (ho->os != NULL && ho->os->flags == 0)
1738
              ho->os->flags = ho->flags;
1739
          }
1740
      orphan_init_done = 1;
1741
    }
1742
 
1743
  /* If this is a final link, then always put .gnu.warning.SYMBOL
1744
     sections into the .text section to get them out of the way.  */
1745
  if (link_info.executable
1746
      && ! link_info.relocatable
1747
      && CONST_STRNEQ (secname, ".gnu.warning.")
1748
      && hold[orphan_text].os != NULL)
1749
    {
1750
      lang_add_section (&hold[orphan_text].os->children, s,
1751
                        hold[orphan_text].os);
1752
      return TRUE;
1753
    }
1754
 
1755
  /* Decide which segment the section should go in based on the
1756
     section name and section flags.  We put loadable .note sections
1757
     right after the .interp section, so that the PT_NOTE segment is
1758
     stored right after the program headers where the OS can read it
1759
     in the first page.  */
1760
 
1761
  place = NULL;
1762
  if ((s->flags & SEC_ALLOC) == 0)
1763
    ;
1764
  else if ((s->flags & SEC_LOAD) != 0
1765
           && ((iself && sh_type == SHT_NOTE)
1766
               || (!iself && CONST_STRNEQ (secname, ".note"))))
1767
    place = &hold[orphan_interp];
1768
  else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1769
    place = &hold[orphan_bss];
1770
  else if ((s->flags & SEC_SMALL_DATA) != 0)
1771
    place = &hold[orphan_sdata];
1772
  else if ((s->flags & SEC_READONLY) == 0)
1773
    place = &hold[orphan_data];
1774
  else if (((iself && (sh_type == SHT_RELA || sh_type == SHT_REL))
1775
            || (!iself && CONST_STRNEQ (secname, ".rel")))
1776
           && (s->flags & SEC_LOAD) != 0)
1777
    place = &hold[orphan_rel];
1778
  else if ((s->flags & SEC_CODE) == 0)
1779
    place = &hold[orphan_rodata];
1780
  else
1781
    place = &hold[orphan_text];
1782
 
1783
  after = NULL;
1784
  if (place != NULL)
1785
    {
1786
      if (place->os == NULL)
1787
        {
1788
          if (place->name != NULL)
1789
            place->os = lang_output_section_find (place->name);
1790
          else
1791
            place->os = output_rel_find (s, isdyn);
1792
        }
1793
      after = place->os;
1794
      if (after == NULL)
1795
        after = lang_output_section_find_by_flags
1796
          (s, &place->os, _bfd_elf_match_sections_by_type);
1797
      if (after == NULL)
1798
        /* *ABS* is always the first output section statement.  */
1799
        after = &lang_output_section_statement.head->output_section_statement;
1800
    }
1801
 
1802
  /* Choose a unique name for the section.  This will be needed if the
1803
     same section name appears in the input file with different
1804
     loadable or allocatable characteristics.  */
1805
  if (bfd_get_section_by_name (link_info.output_bfd, secname) != NULL)
1806
    {
1807
      static int count = 1;
1808
      secname = bfd_get_unique_section_name (link_info.output_bfd,
1809
                                             secname, &count);
1810
      if (secname == NULL)
1811
        einfo ("%F%P: place_orphan failed: %E\n");
1812
    }
1813
 
1814
  lang_insert_orphan (s, secname, after, place, NULL, NULL);
1815
 
1816
  return TRUE;
1817
}
1818
EOF
1819
fi
1820
 
1821
if test x"$LDEMUL_FINISH" != xgld"$EMULATION_NAME"_finish; then
1822
fragment <
1823
 
1824
static void
1825
gld${EMULATION_NAME}_finish (void)
1826
{
1827
  bfd_boolean need_layout = bfd_elf_discard_info (link_info.output_bfd,
1828
                                                  &link_info);
1829
 
1830
  gld${EMULATION_NAME}_map_segments (need_layout);
1831
  finish_default ();
1832
}
1833
EOF
1834
fi
1835
 
1836
if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
1837
fragment <
1838
 
1839
static char *
1840
gld${EMULATION_NAME}_get_script (int *isfile)
1841
EOF
1842
 
1843
if test -n "$COMPILE_IN"
1844
then
1845
# Scripts compiled in.
1846
 
1847
# sed commands to quote an ld script as a C string.
1848
sc="-f stringify.sed"
1849
 
1850
fragment <
1851
{
1852
  *isfile = 0;
1853
 
1854
  if (link_info.relocatable && config.build_constructors)
1855
    return
1856
EOF
1857
sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
1858
echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
1859
sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
1860
echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
1861
sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
1862
if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then : ; else
1863
echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
1864
sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
1865
fi
1866
if test -n "$GENERATE_PIE_SCRIPT" ; then
1867
if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1868
echo '  ; else if (link_info.pie && link_info.combreloc' >> e${EMULATION_NAME}.c
1869
echo '             && link_info.relro' >> e${EMULATION_NAME}.c
1870
echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1871
sed $sc ldscripts/${EMULATION_NAME}.xdw                 >> e${EMULATION_NAME}.c
1872
echo '  ; else if (link_info.pie && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1873
sed $sc ldscripts/${EMULATION_NAME}.xdc                 >> e${EMULATION_NAME}.c
1874
fi
1875
echo '  ; else if (link_info.pie) return'               >> e${EMULATION_NAME}.c
1876
sed $sc ldscripts/${EMULATION_NAME}.xd                  >> e${EMULATION_NAME}.c
1877
fi
1878
if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1879
if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1880
echo '  ; else if (link_info.shared && link_info.combreloc' >> e${EMULATION_NAME}.c
1881
echo '             && link_info.relro' >> e${EMULATION_NAME}.c
1882
echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1883
sed $sc ldscripts/${EMULATION_NAME}.xsw                 >> e${EMULATION_NAME}.c
1884
echo '  ; else if (link_info.shared && link_info.combreloc) return' >> e${EMULATION_NAME}.c
1885
sed $sc ldscripts/${EMULATION_NAME}.xsc                 >> e${EMULATION_NAME}.c
1886
fi
1887
echo '  ; else if (link_info.shared) return'            >> e${EMULATION_NAME}.c
1888
sed $sc ldscripts/${EMULATION_NAME}.xs                  >> e${EMULATION_NAME}.c
1889
fi
1890
if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1891
echo '  ; else if (link_info.combreloc && link_info.relro' >> e${EMULATION_NAME}.c
1892
echo '             && (link_info.flags & DF_BIND_NOW)) return' >> e${EMULATION_NAME}.c
1893
sed $sc ldscripts/${EMULATION_NAME}.xw                  >> e${EMULATION_NAME}.c
1894
echo '  ; else if (link_info.combreloc) return'         >> e${EMULATION_NAME}.c
1895
sed $sc ldscripts/${EMULATION_NAME}.xc                  >> e${EMULATION_NAME}.c
1896
fi
1897
echo '  ; else return'                                  >> e${EMULATION_NAME}.c
1898
sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
1899
echo '; }'                                              >> e${EMULATION_NAME}.c
1900
 
1901
else
1902
# Scripts read from the filesystem.
1903
 
1904
fragment <
1905
{
1906
  *isfile = 1;
1907
 
1908
  if (link_info.relocatable && config.build_constructors)
1909
    return "ldscripts/${EMULATION_NAME}.xu";
1910
  else if (link_info.relocatable)
1911
    return "ldscripts/${EMULATION_NAME}.xr";
1912
  else if (!config.text_read_only)
1913
    return "ldscripts/${EMULATION_NAME}.xbn";
1914
EOF
1915
if cmp -s ldscripts/${EMULATION_NAME}.x ldscripts/${EMULATION_NAME}.xn; then :
1916
else
1917
fragment <
1918
  else if (!config.magic_demand_paged)
1919
    return "ldscripts/${EMULATION_NAME}.xn";
1920
EOF
1921
fi
1922
if test -n "$GENERATE_PIE_SCRIPT" ; then
1923
if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1924
fragment <
1925
  else if (link_info.pie && link_info.combreloc
1926
           && link_info.relro && (link_info.flags & DF_BIND_NOW))
1927
    return "ldscripts/${EMULATION_NAME}.xdw";
1928
  else if (link_info.pie && link_info.combreloc)
1929
    return "ldscripts/${EMULATION_NAME}.xdc";
1930
EOF
1931
fi
1932
fragment <
1933
  else if (link_info.pie)
1934
    return "ldscripts/${EMULATION_NAME}.xd";
1935
EOF
1936
fi
1937
if test -n "$GENERATE_SHLIB_SCRIPT" ; then
1938
if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1939
fragment <
1940
  else if (link_info.shared && link_info.combreloc
1941
           && link_info.relro && (link_info.flags & DF_BIND_NOW))
1942
    return "ldscripts/${EMULATION_NAME}.xsw";
1943
  else if (link_info.shared && link_info.combreloc)
1944
    return "ldscripts/${EMULATION_NAME}.xsc";
1945
EOF
1946
fi
1947
fragment <
1948
  else if (link_info.shared)
1949
    return "ldscripts/${EMULATION_NAME}.xs";
1950
EOF
1951
fi
1952
if test -n "$GENERATE_COMBRELOC_SCRIPT" ; then
1953
fragment <
1954
  else if (link_info.combreloc && link_info.relro
1955
           && (link_info.flags & DF_BIND_NOW))
1956
    return "ldscripts/${EMULATION_NAME}.xw";
1957
  else if (link_info.combreloc)
1958
    return "ldscripts/${EMULATION_NAME}.xc";
1959
EOF
1960
fi
1961
fragment <
1962
  else
1963
    return "ldscripts/${EMULATION_NAME}.x";
1964
}
1965
 
1966
EOF
1967
fi
1968
fi
1969
 
1970
if test -n "$PARSE_AND_LIST_ARGS_CASES" -o x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1971
 
1972
if test -n "$PARSE_AND_LIST_PROLOGUE" ; then
1973
fragment <
1974
 $PARSE_AND_LIST_PROLOGUE
1975
EOF
1976
fi
1977
 
1978
fragment <
1979
 
1980
#define OPTION_DISABLE_NEW_DTAGS        (400)
1981
#define OPTION_ENABLE_NEW_DTAGS         (OPTION_DISABLE_NEW_DTAGS + 1)
1982
#define OPTION_GROUP                    (OPTION_ENABLE_NEW_DTAGS + 1)
1983
#define OPTION_EH_FRAME_HDR             (OPTION_GROUP + 1)
1984
#define OPTION_EXCLUDE_LIBS             (OPTION_EH_FRAME_HDR + 1)
1985
#define OPTION_HASH_STYLE               (OPTION_EXCLUDE_LIBS + 1)
1986
#define OPTION_BUILD_ID                 (OPTION_HASH_STYLE + 1)
1987
 
1988
static void
1989
gld${EMULATION_NAME}_add_options
1990
  (int ns, char **shortopts, int nl, struct option **longopts,
1991
   int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
1992
{
1993
  static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:";
1994
  static const struct option xtra_long[] = {
1995
    {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
1996
EOF
1997
 
1998
if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
1999
fragment <
2000
    {"disable-new-dtags", no_argument, NULL, OPTION_DISABLE_NEW_DTAGS},
2001
    {"enable-new-dtags", no_argument, NULL, OPTION_ENABLE_NEW_DTAGS},
2002
    {"eh-frame-hdr", no_argument, NULL, OPTION_EH_FRAME_HDR},
2003
    {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
2004
    {"hash-style", required_argument, NULL, OPTION_HASH_STYLE},
2005
    {"Bgroup", no_argument, NULL, OPTION_GROUP},
2006
EOF
2007
fi
2008
 
2009
if test -n "$PARSE_AND_LIST_LONGOPTS" ; then
2010
fragment <
2011
    $PARSE_AND_LIST_LONGOPTS
2012
EOF
2013
fi
2014
 
2015
fragment <
2016
    {NULL, no_argument, NULL, 0}
2017
  };
2018
 
2019
  *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
2020
  memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
2021
  *longopts = (struct option *)
2022
    xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
2023
  memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
2024
}
2025
 
2026
#define DEFAULT_BUILD_ID_STYLE  "sha1"
2027
 
2028
static bfd_boolean
2029
gld${EMULATION_NAME}_handle_option (int optc)
2030
{
2031
  switch (optc)
2032
    {
2033
    default:
2034
      return FALSE;
2035
 
2036
    case OPTION_BUILD_ID:
2037
      if (link_info.emit_note_gnu_build_id != NULL)
2038
        {
2039
          free (link_info.emit_note_gnu_build_id);
2040
          link_info.emit_note_gnu_build_id = NULL;
2041
        }
2042
      if (optarg == NULL)
2043
        optarg = DEFAULT_BUILD_ID_STYLE;
2044
      if (strcmp (optarg, "none"))
2045
        link_info.emit_note_gnu_build_id = xstrdup (optarg);
2046
      break;
2047
 
2048
EOF
2049
 
2050
if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2051
fragment <
2052
    case OPTION_DISABLE_NEW_DTAGS:
2053
      link_info.new_dtags = FALSE;
2054
      break;
2055
 
2056
    case OPTION_ENABLE_NEW_DTAGS:
2057
      link_info.new_dtags = TRUE;
2058
      break;
2059
 
2060
    case OPTION_EH_FRAME_HDR:
2061
      link_info.eh_frame_hdr = TRUE;
2062
      break;
2063
 
2064
    case OPTION_GROUP:
2065
      link_info.flags_1 |= (bfd_vma) DF_1_GROUP;
2066
      /* Groups must be self-contained.  */
2067
      link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2068
      link_info.unresolved_syms_in_shared_libs = RM_GENERATE_ERROR;
2069
      break;
2070
 
2071
    case OPTION_EXCLUDE_LIBS:
2072
      add_excluded_libs (optarg);
2073
      break;
2074
 
2075
    case OPTION_HASH_STYLE:
2076
      link_info.emit_hash = FALSE;
2077
      link_info.emit_gnu_hash = FALSE;
2078
      if (strcmp (optarg, "sysv") == 0)
2079
        link_info.emit_hash = TRUE;
2080
      else if (strcmp (optarg, "gnu") == 0)
2081
        link_info.emit_gnu_hash = TRUE;
2082
      else if (strcmp (optarg, "both") == 0)
2083
        {
2084
          link_info.emit_hash = TRUE;
2085
          link_info.emit_gnu_hash = TRUE;
2086
        }
2087
      else
2088
        einfo (_("%P%F: invalid hash style \`%s'\n"), optarg);
2089
      break;
2090
 
2091
    case 'z':
2092
      if (strcmp (optarg, "initfirst") == 0)
2093
        link_info.flags_1 |= (bfd_vma) DF_1_INITFIRST;
2094
      else if (strcmp (optarg, "interpose") == 0)
2095
        link_info.flags_1 |= (bfd_vma) DF_1_INTERPOSE;
2096
      else if (strcmp (optarg, "loadfltr") == 0)
2097
        link_info.flags_1 |= (bfd_vma) DF_1_LOADFLTR;
2098
      else if (strcmp (optarg, "nodefaultlib") == 0)
2099
        link_info.flags_1 |= (bfd_vma) DF_1_NODEFLIB;
2100
      else if (strcmp (optarg, "nodelete") == 0)
2101
        link_info.flags_1 |= (bfd_vma) DF_1_NODELETE;
2102
      else if (strcmp (optarg, "nodlopen") == 0)
2103
        link_info.flags_1 |= (bfd_vma) DF_1_NOOPEN;
2104
      else if (strcmp (optarg, "nodump") == 0)
2105
        link_info.flags_1 |= (bfd_vma) DF_1_NODUMP;
2106
      else if (strcmp (optarg, "now") == 0)
2107
        {
2108
          link_info.flags |= (bfd_vma) DF_BIND_NOW;
2109
          link_info.flags_1 |= (bfd_vma) DF_1_NOW;
2110
        }
2111
      else if (strcmp (optarg, "lazy") == 0)
2112
        {
2113
          link_info.flags &= ~(bfd_vma) DF_BIND_NOW;
2114
          link_info.flags_1 &= ~(bfd_vma) DF_1_NOW;
2115
        }
2116
      else if (strcmp (optarg, "origin") == 0)
2117
        {
2118
          link_info.flags |= (bfd_vma) DF_ORIGIN;
2119
          link_info.flags_1 |= (bfd_vma) DF_1_ORIGIN;
2120
        }
2121
      else if (strcmp (optarg, "defs") == 0)
2122
        link_info.unresolved_syms_in_objects = RM_GENERATE_ERROR;
2123
      else if (strcmp (optarg, "muldefs") == 0)
2124
        link_info.allow_multiple_definition = TRUE;
2125
      else if (strcmp (optarg, "combreloc") == 0)
2126
        link_info.combreloc = TRUE;
2127
      else if (strcmp (optarg, "nocombreloc") == 0)
2128
        link_info.combreloc = FALSE;
2129
      else if (strcmp (optarg, "nocopyreloc") == 0)
2130
        link_info.nocopyreloc = TRUE;
2131
      else if (strcmp (optarg, "execstack") == 0)
2132
        {
2133
          link_info.execstack = TRUE;
2134
          link_info.noexecstack = FALSE;
2135
        }
2136
      else if (strcmp (optarg, "noexecstack") == 0)
2137
        {
2138
          link_info.noexecstack = TRUE;
2139
          link_info.execstack = FALSE;
2140
        }
2141
EOF
2142
 
2143
  if test -n "$COMMONPAGESIZE"; then
2144
fragment <
2145
      else if (strcmp (optarg, "relro") == 0)
2146
        link_info.relro = TRUE;
2147
      else if (strcmp (optarg, "norelro") == 0)
2148
        link_info.relro = FALSE;
2149
EOF
2150
  fi
2151
 
2152
fragment <
2153
      else if (CONST_STRNEQ (optarg, "max-page-size="))
2154
        {
2155
          char *end;
2156
 
2157
          config.maxpagesize = strtoul (optarg + 14, &end, 0);
2158
          if (*end || (config.maxpagesize & (config.maxpagesize - 1)) != 0)
2159
            einfo (_("%P%F: invalid maxium page size \`%s'\n"),
2160
                   optarg + 14);
2161
          ASSERT (default_target != NULL);
2162
          bfd_emul_set_maxpagesize (default_target, config.maxpagesize);
2163
        }
2164
      else if (CONST_STRNEQ (optarg, "common-page-size="))
2165
        {
2166
          char *end;
2167
          config.commonpagesize = strtoul (optarg + 17, &end, 0);
2168
          if (*end
2169
              || (config.commonpagesize & (config.commonpagesize - 1)) != 0)
2170
            einfo (_("%P%F: invalid common page size \`%s'\n"),
2171
                   optarg + 17);
2172
          ASSERT (default_target != NULL);
2173
          bfd_emul_set_commonpagesize (default_target,
2174
                                       config.commonpagesize);
2175
        }
2176
      /* What about the other Solaris -z options? FIXME.  */
2177
      break;
2178
EOF
2179
fi
2180
 
2181
if test -n "$PARSE_AND_LIST_ARGS_CASES" ; then
2182
fragment <
2183
 $PARSE_AND_LIST_ARGS_CASES
2184
EOF
2185
fi
2186
 
2187
fragment <
2188
    }
2189
 
2190
  return TRUE;
2191
}
2192
 
2193
EOF
2194
 
2195
if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2196
fragment <
2197
 
2198
static void
2199
gld${EMULATION_NAME}_list_options (FILE * file)
2200
{
2201
  fprintf (file, _("\
2202
  --build-id[=STYLE]          Generate build ID note\n"));
2203
EOF
2204
 
2205
if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then
2206
fragment <
2207
  fprintf (file, _("\
2208
  -Bgroup                     Selects group name lookup rules for DSO\n"));
2209
  fprintf (file, _("\
2210
  --disable-new-dtags         Disable new dynamic tags\n"));
2211
  fprintf (file, _("\
2212
  --enable-new-dtags          Enable new dynamic tags\n"));
2213
  fprintf (file, _("\
2214
  --eh-frame-hdr              Create .eh_frame_hdr section\n"));
2215
  fprintf (file, _("\
2216
  --hash-style=STYLE          Set hash style to sysv, gnu or both\n"));
2217
  fprintf (file, _("\
2218
  -z combreloc                Merge dynamic relocs into one section and sort\n"));
2219
  fprintf (file, _("\
2220
  -z defs                     Report unresolved symbols in object files.\n"));
2221
  fprintf (file, _("\
2222
  -z execstack                Mark executable as requiring executable stack\n"));
2223
  fprintf (file, _("\
2224
  -z initfirst                Mark DSO to be initialized first at runtime\n"));
2225
  fprintf (file, _("\
2226
  -z interpose                Mark object to interpose all DSOs but executable\n"));
2227
  fprintf (file, _("\
2228
  -z lazy                     Mark object lazy runtime binding (default)\n"));
2229
  fprintf (file, _("\
2230
  -z loadfltr                 Mark object requiring immediate process\n"));
2231
  fprintf (file, _("\
2232
  -z muldefs                  Allow multiple definitions\n"));
2233
  fprintf (file, _("\
2234
  -z nocombreloc              Don't merge dynamic relocs into one section\n"));
2235
  fprintf (file, _("\
2236
  -z nocopyreloc              Don't create copy relocs\n"));
2237
  fprintf (file, _("\
2238
  -z nodefaultlib             Mark object not to use default search paths\n"));
2239
  fprintf (file, _("\
2240
  -z nodelete                 Mark DSO non-deletable at runtime\n"));
2241
  fprintf (file, _("\
2242
  -z nodlopen                 Mark DSO not available to dlopen\n"));
2243
  fprintf (file, _("\
2244
  -z nodump                   Mark DSO not available to dldump\n"));
2245
  fprintf (file, _("\
2246
  -z noexecstack              Mark executable as not requiring executable stack\n"));
2247
EOF
2248
 
2249
  if test -n "$COMMONPAGESIZE"; then
2250
fragment <
2251
  fprintf (file, _("\
2252
  -z norelro                  Don't create RELRO program header\n"));
2253
EOF
2254
  fi
2255
 
2256
fragment <
2257
  fprintf (file, _("\
2258
  -z now                      Mark object non-lazy runtime binding\n"));
2259
  fprintf (file, _("\
2260
  -z origin                   Mark object requiring immediate \$ORIGIN\n\
2261
                                processing at runtime\n"));
2262
EOF
2263
 
2264
  if test -n "$COMMONPAGESIZE"; then
2265
fragment <
2266
  fprintf (file, _("\
2267
  -z relro                    Create RELRO program header\n"));
2268
EOF
2269
  fi
2270
 
2271
fragment <
2272
  fprintf (file, _("\
2273
  -z max-page-size=SIZE       Set maximum page size to SIZE\n"));
2274
  fprintf (file, _("\
2275
  -z common-page-size=SIZE    Set common page size to SIZE\n"));
2276
  fprintf (file, _("\
2277
  -z KEYWORD                  Ignored for Solaris compatibility\n"));
2278
EOF
2279
fi
2280
 
2281
if test -n "$PARSE_AND_LIST_OPTIONS" ; then
2282
fragment <
2283
 $PARSE_AND_LIST_OPTIONS
2284
EOF
2285
fi
2286
 
2287
fragment <
2288
}
2289
EOF
2290
 
2291
if test -n "$PARSE_AND_LIST_EPILOGUE" ; then
2292
fragment <
2293
 $PARSE_AND_LIST_EPILOGUE
2294
EOF
2295
fi
2296
fi
2297
else
2298
fragment <
2299
#define gld${EMULATION_NAME}_add_options NULL
2300
#define gld${EMULATION_NAME}_handle_option NULL
2301
EOF
2302
if test x"$LDEMUL_LIST_OPTIONS" != xgld"$EMULATION_NAME"_list_options; then
2303
fragment <
2304
#define gld${EMULATION_NAME}_list_options NULL
2305
EOF
2306
fi
2307
fi
2308
 
2309
fragment <
2310
 
2311
struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2312
{
2313
  ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
2314
  ${LDEMUL_SYSLIB-syslib_default},
2315
  ${LDEMUL_HLL-hll_default},
2316
  ${LDEMUL_AFTER_PARSE-after_parse_default},
2317
  ${LDEMUL_AFTER_OPEN-gld${EMULATION_NAME}_after_open},
2318
  ${LDEMUL_AFTER_ALLOCATION-after_allocation_default},
2319
  ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
2320
  ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
2321
  ${LDEMUL_BEFORE_ALLOCATION-gld${EMULATION_NAME}_before_allocation},
2322
  ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
2323
  "${EMULATION_NAME}",
2324
  "${OUTPUT_FORMAT}",
2325
  ${LDEMUL_FINISH-gld${EMULATION_NAME}_finish},
2326
  ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
2327
  ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-gld${EMULATION_NAME}_open_dynamic_archive},
2328
  ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
2329
  ${LDEMUL_SET_SYMBOLS-NULL},
2330
  ${LDEMUL_PARSE_ARGS-NULL},
2331
  gld${EMULATION_NAME}_add_options,
2332
  gld${EMULATION_NAME}_handle_option,
2333
  ${LDEMUL_UNRECOGNIZED_FILE-NULL},
2334
  ${LDEMUL_LIST_OPTIONS-gld${EMULATION_NAME}_list_options},
2335
  ${LDEMUL_RECOGNIZED_FILE-gld${EMULATION_NAME}_load_symbols},
2336
  ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
2337
  ${LDEMUL_NEW_VERS_PATTERN-NULL}
2338
};
2339
EOF

powered by: WebSVN 2.1.0

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