← Back to branch summary

~ubuntu-branches/ubuntu/utopic/binutils-arm64-cross/utopic

« back to all changes in this revision

Viewing changes to binutils-2.23.52.20130611/ld/ldfile.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-06-20 17:38:09 UTC
  • Revision ID: package-import@ubuntu.com-20130620173809-app8lzgvymy5fg6c
Tags: 0.7
Build-depend on binutils-source (>= 2.23.52.20130620-1~).

Show diffs side-by-side

added added

removed removed

Lines of Context:
binutils-2.23.52.20130611/ld/ldfile.c
 
1
/* Linker file opening and searching.
 
2
   Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
 
3
   2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
 
4
   Free Software Foundation, Inc.
 
5
 
 
6
   This file is part of the GNU Binutils.
 
7
 
 
8
   This program is free software; you can redistribute it and/or modify
 
9
   it under the terms of the GNU General Public License as published by
 
10
   the Free Software Foundation; either version 3 of the License, or
 
11
   (at your option) any later version.
 
12
 
 
13
   This program is distributed in the hope that it will be useful,
 
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
   GNU General Public License for more details.
 
17
 
 
18
   You should have received a copy of the GNU General Public License
 
19
   along with this program; if not, write to the Free Software
 
20
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
 
21
   MA 02110-1301, USA.  */
 
22
 
 
23
#include "sysdep.h"
 
24
#include "bfd.h"
 
25
#include "bfdlink.h"
 
26
#include "safe-ctype.h"
 
27
#include "ld.h"
 
28
#include "ldmisc.h"
 
29
#include "ldexp.h"
 
30
#include "ldlang.h"
 
31
#include "ldfile.h"
 
32
#include "ldmain.h"
 
33
#include <ldgram.h>
 
34
#include "ldlex.h"
 
35
#include "ldemul.h"
 
36
#include "libiberty.h"
 
37
#include "filenames.h"
 
38
#ifdef ENABLE_PLUGINS
 
39
#include "plugin-api.h"
 
40
#include "plugin.h"
 
41
#endif /* ENABLE_PLUGINS */
 
42
 
 
43
bfd_boolean  ldfile_assumed_script = FALSE;
 
44
const char * ldfile_output_machine_name = "";
 
45
unsigned long ldfile_output_machine;
 
46
enum bfd_architecture ldfile_output_architecture;
 
47
search_dirs_type * search_head;
 
48
 
 
49
#ifdef VMS
 
50
static char * slash = "";
 
51
#else
 
52
#if defined (_WIN32) && ! defined (__CYGWIN32__)
 
53
static char * slash = "\\";
 
54
#else
 
55
static char * slash = "/";
 
56
#endif
 
57
#endif
 
58
 
 
59
typedef struct search_arch
 
60
{
 
61
  char *name;
 
62
  struct search_arch *next;
 
63
} search_arch_type;
 
64
 
 
65
static search_dirs_type **search_tail_ptr = &search_head;
 
66
static search_arch_type *search_arch_head;
 
67
static search_arch_type **search_arch_tail_ptr = &search_arch_head;
 
68
 
 
69
/* Test whether a pathname, after canonicalization, is the same or a
 
70
   sub-directory of the sysroot directory.  */
 
71
 
 
72
static bfd_boolean
 
73
is_sysrooted_pathname (const char *name)
 
74
{
 
75
  char *realname;
 
76
  int len;
 
77
  bfd_boolean result;
 
78
 
 
79
  if (ld_canon_sysroot == NULL)
 
80
    return FALSE;
 
81
 
 
82
  realname = lrealpath (name);
 
83
  len = strlen (realname);
 
84
  result = FALSE;
 
85
  if (len > ld_canon_sysroot_len
 
86
      && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))
 
87
    {
 
88
      realname[ld_canon_sysroot_len] = '\0';
 
89
      result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
 
90
    }
 
91
 
 
92
  free (realname);
 
93
  return result;
 
94
}
 
95
 
 
96
/* Adds NAME to the library search path.
 
97
   Makes a copy of NAME using xmalloc().  */
 
98
 
 
99
void
 
100
ldfile_add_library_path (const char *name, bfd_boolean cmdline)
 
101
{
 
102
  search_dirs_type *new_dirs;
 
103
 
 
104
  if (!cmdline && config.only_cmd_line_lib_dirs)
 
105
    return;
 
106
 
 
107
  new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
 
108
  new_dirs->next = NULL;
 
109
  new_dirs->cmdline = cmdline;
 
110
  *search_tail_ptr = new_dirs;
 
111
  search_tail_ptr = &new_dirs->next;
 
112
 
 
113
  /* If a directory is marked as honoring sysroot, prepend the sysroot path
 
114
     now.  */
 
115
  if (name[0] == '=')
 
116
    new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
 
117
  else
 
118
    new_dirs->name = xstrdup (name);
 
119
}
 
120
 
 
121
/* Try to open a BFD for a lang_input_statement.  */
 
122
 
 
123
bfd_boolean
 
124
ldfile_try_open_bfd (const char *attempt,
 
125
                     lang_input_statement_type *entry)
 
126
{
 
127
  entry->the_bfd = bfd_openr (attempt, entry->target);
 
128
 
 
129
  if (verbose)
 
130
    {
 
131
      if (entry->the_bfd == NULL)
 
132
        info_msg (_("attempt to open %s failed\n"), attempt);
 
133
      else
 
134
        info_msg (_("attempt to open %s succeeded\n"), attempt);
 
135
    }
 
136
 
 
137
  if (entry->the_bfd == NULL)
 
138
    {
 
139
      if (bfd_get_error () == bfd_error_invalid_target)
 
140
        einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
 
141
      return FALSE;
 
142
    }
 
143
 
 
144
  /* Linker needs to decompress sections.  */
 
145
  entry->the_bfd->flags |= BFD_DECOMPRESS;
 
146
 
 
147
  /* If we are searching for this file, see if the architecture is
 
148
     compatible with the output file.  If it isn't, keep searching.
 
149
     If we can't open the file as an object file, stop the search
 
150
     here.  If we are statically linking, ensure that we don't link
 
151
     a dynamic object.
 
152
 
 
153
     In the code below, it's OK to exit early if the check fails,
 
154
     closing the checked BFD and returning FALSE, but if the BFD
 
155
     checks out compatible, do not exit early returning TRUE, or
 
156
     the plugins will not get a chance to claim the file.  */
 
157
 
 
158
  if (entry->flags.search_dirs || !entry->flags.dynamic)
 
159
    {
 
160
      bfd *check;
 
161
 
 
162
      if (bfd_check_format (entry->the_bfd, bfd_archive))
 
163
        check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
 
164
      else
 
165
        check = entry->the_bfd;
 
166
 
 
167
      if (check != NULL)
 
168
        {
 
169
          if (! bfd_check_format (check, bfd_object))
 
170
            {
 
171
              if (check == entry->the_bfd
 
172
                  && entry->flags.search_dirs
 
173
                  && bfd_get_error () == bfd_error_file_not_recognized
 
174
                  && ! ldemul_unrecognized_file (entry))
 
175
                {
 
176
                  int token, skip = 0;
 
177
                  char *arg, *arg1, *arg2, *arg3;
 
178
                  extern FILE *yyin;
 
179
 
 
180
                  /* Try to interpret the file as a linker script.  */
 
181
                  ldfile_open_command_file (attempt);
 
182
 
 
183
                  ldfile_assumed_script = TRUE;
 
184
                  parser_input = input_selected;
 
185
                  ldlex_both ();
 
186
                  token = INPUT_SCRIPT;
 
187
                  while (token != 0)
 
188
                    {
 
189
                      switch (token)
 
190
                        {
 
191
                        case OUTPUT_FORMAT:
 
192
                          if ((token = yylex ()) != '(')
 
193
                            continue;
 
194
                          if ((token = yylex ()) != NAME)
 
195
                            continue;
 
196
                          arg1 = yylval.name;
 
197
                          arg2 = NULL;
 
198
                          arg3 = NULL;
 
199
                          token = yylex ();
 
200
                          if (token == ',')
 
201
                            {
 
202
                              if ((token = yylex ()) != NAME)
 
203
                                {
 
204
                                  free (arg1);
 
205
                                  continue;
 
206
                                }
 
207
                              arg2 = yylval.name;
 
208
                              if ((token = yylex ()) != ','
 
209
                                  || (token = yylex ()) != NAME)
 
210
                                {
 
211
                                  free (arg1);
 
212
                                  free (arg2);
 
213
                                  continue;
 
214
                                }
 
215
                              arg3 = yylval.name;
 
216
                              token = yylex ();
 
217
                            }
 
218
                          if (token == ')')
 
219
                            {
 
220
                              switch (command_line.endian)
 
221
                                {
 
222
                                default:
 
223
                                case ENDIAN_UNSET:
 
224
                                  arg = arg1; break;
 
225
                                case ENDIAN_BIG:
 
226
                                  arg = arg2 ? arg2 : arg1; break;
 
227
                                case ENDIAN_LITTLE:
 
228
                                  arg = arg3 ? arg3 : arg1; break;
 
229
                                }
 
230
                              if (strcmp (arg, lang_get_output_target ()) != 0)
 
231
                                skip = 1;
 
232
                            }
 
233
                          free (arg1);
 
234
                          if (arg2) free (arg2);
 
235
                          if (arg3) free (arg3);
 
236
                          break;
 
237
                        case NAME:
 
238
                        case LNAME:
 
239
                        case VERS_IDENTIFIER:
 
240
                        case VERS_TAG:
 
241
                          free (yylval.name);
 
242
                          break;
 
243
                        case INT:
 
244
                          if (yylval.bigint.str)
 
245
                            free (yylval.bigint.str);
 
246
                          break;
 
247
                        }
 
248
                      token = yylex ();
 
249
                    }
 
250
                  ldlex_popstate ();
 
251
                  ldfile_assumed_script = FALSE;
 
252
                  fclose (yyin);
 
253
                  yyin = NULL;
 
254
                  if (skip)
 
255
                    {
 
256
                      if (command_line.warn_search_mismatch)
 
257
                        einfo (_("%P: skipping incompatible %s "
 
258
                                 "when searching for %s\n"),
 
259
                               attempt, entry->local_sym_name);
 
260
                      bfd_close (entry->the_bfd);
 
261
                      entry->the_bfd = NULL;
 
262
                      return FALSE;
 
263
                    }
 
264
                }
 
265
              goto success;
 
266
            }
 
267
 
 
268
          if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
 
269
            {
 
270
              einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
 
271
                     attempt);
 
272
              bfd_close (entry->the_bfd);
 
273
              entry->the_bfd = NULL;
 
274
              return FALSE;
 
275
            }
 
276
 
 
277
          if (entry->flags.search_dirs
 
278
              && !bfd_arch_get_compatible (check, link_info.output_bfd,
 
279
                                           command_line.accept_unknown_input_arch)
 
280
              /* XCOFF archives can have 32 and 64 bit objects.  */
 
281
              && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
 
282
                    && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
 
283
                    && bfd_check_format (entry->the_bfd, bfd_archive)))
 
284
            {
 
285
              if (command_line.warn_search_mismatch)
 
286
                einfo (_("%P: skipping incompatible %s "
 
287
                         "when searching for %s\n"),
 
288
                       attempt, entry->local_sym_name);
 
289
              bfd_close (entry->the_bfd);
 
290
              entry->the_bfd = NULL;
 
291
              return FALSE;
 
292
            }
 
293
        }
 
294
    }
 
295
success:
 
296
#ifdef ENABLE_PLUGINS
 
297
  /* If plugins are active, they get first chance to claim
 
298
     any successfully-opened input file.  We skip archives
 
299
     here; the plugin wants us to offer it the individual
 
300
     members when we enumerate them, not the whole file.  We
 
301
     also ignore corefiles, because that's just weird.  It is
 
302
     a needed side-effect of calling  bfd_check_format with
 
303
     bfd_object that it sets the bfd's arch and mach, which
 
304
     will be needed when and if we want to bfd_create a new
 
305
     one using this one as a template.  */
 
306
  if (bfd_check_format (entry->the_bfd, bfd_object)
 
307
      && plugin_active_plugins_p ()
 
308
      && !no_more_claiming)
 
309
    {
 
310
      int fd = open (attempt, O_RDONLY | O_BINARY);
 
311
      if (fd >= 0)
 
312
        {
 
313
          struct ld_plugin_input_file file;
 
314
 
 
315
          file.name = attempt;
 
316
          file.offset = 0;
 
317
          file.filesize = lseek (fd, 0, SEEK_END);
 
318
          file.fd = fd;
 
319
          plugin_maybe_claim (&file, entry);
 
320
        }
 
321
    }
 
322
#endif /* ENABLE_PLUGINS */
 
323
 
 
324
  /* It opened OK, the format checked out, and the plugins have had
 
325
     their chance to claim it, so this is success.  */
 
326
  return TRUE;
 
327
}
 
328
 
 
329
/* Search for and open the file specified by ENTRY.  If it is an
 
330
   archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 
331
 
 
332
bfd_boolean
 
333
ldfile_open_file_search (const char *arch,
 
334
                         lang_input_statement_type *entry,
 
335
                         const char *lib,
 
336
                         const char *suffix)
 
337
{
 
338
  search_dirs_type *search;
 
339
 
 
340
  /* If this is not an archive, try to open it in the current
 
341
     directory first.  */
 
342
  if (! entry->flags.maybe_archive)
 
343
    {
 
344
      if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
 
345
        {
 
346
          char *name = concat (ld_sysroot, entry->filename,
 
347
                               (const char *) NULL);
 
348
          if (ldfile_try_open_bfd (name, entry))
 
349
            {
 
350
              entry->filename = name;
 
351
              return TRUE;
 
352
            }
 
353
          free (name);
 
354
        }
 
355
      else if (ldfile_try_open_bfd (entry->filename, entry))
 
356
        return TRUE;
 
357
 
 
358
      if (IS_ABSOLUTE_PATH (entry->filename))
 
359
        return FALSE;
 
360
    }
 
361
 
 
362
  for (search = search_head; search != NULL; search = search->next)
 
363
    {
 
364
      char *string;
 
365
 
 
366
      if (entry->flags.dynamic && ! link_info.relocatable)
 
367
        {
 
368
          if (ldemul_open_dynamic_archive (arch, search, entry))
 
369
            return TRUE;
 
370
        }
 
371
 
 
372
      if (entry->flags.maybe_archive)
 
373
        string = concat (search->name, slash, lib, entry->filename,
 
374
                         arch, suffix, (const char *) NULL);
 
375
      else
 
376
        string = concat (search->name, slash, entry->filename,
 
377
                         (const char *) 0);
 
378
 
 
379
      if (ldfile_try_open_bfd (string, entry))
 
380
        {
 
381
          entry->filename = string;
 
382
          return TRUE;
 
383
        }
 
384
 
 
385
      free (string);
 
386
    }
 
387
 
 
388
  return FALSE;
 
389
}
 
390
 
 
391
/* Open the input file specified by ENTRY.
 
392
   PR 4437: Do not stop on the first missing file, but
 
393
   continue processing other input files in case there
 
394
   are more errors to report.  */
 
395
 
 
396
void
 
397
ldfile_open_file (lang_input_statement_type *entry)
 
398
{
 
399
  if (entry->the_bfd != NULL)
 
400
    return;
 
401
 
 
402
  if (! entry->flags.search_dirs)
 
403
    {
 
404
      if (ldfile_try_open_bfd (entry->filename, entry))
 
405
        return;
 
406
 
 
407
      if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
 
408
        einfo (_("%P: cannot find %s (%s): %E\n"),
 
409
               entry->filename, entry->local_sym_name);
 
410
      else
 
411
        einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
 
412
 
 
413
      entry->flags.missing_file = TRUE;
 
414
      input_flags.missing_file = TRUE;
 
415
    }
 
416
  else
 
417
    {
 
418
      search_arch_type *arch;
 
419
      bfd_boolean found = FALSE;
 
420
 
 
421
      /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 
422
      for (arch = search_arch_head; arch != NULL; arch = arch->next)
 
423
        {
 
424
          found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
 
425
          if (found)
 
426
            break;
 
427
#ifdef VMS
 
428
          found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
 
429
          if (found)
 
430
            break;
 
431
#endif
 
432
          found = ldemul_find_potential_libraries (arch->name, entry);
 
433
          if (found)
 
434
            break;
 
435
        }
 
436
 
 
437
      /* If we have found the file, we don't need to search directories
 
438
         again.  */
 
439
      if (found)
 
440
        entry->flags.search_dirs = FALSE;
 
441
      else
 
442
        {
 
443
          if (entry->flags.sysrooted
 
444
               && ld_sysroot
 
445
               && IS_ABSOLUTE_PATH (entry->local_sym_name))
 
446
            einfo (_("%P: cannot find %s inside %s\n"),
 
447
                   entry->local_sym_name, ld_sysroot);
 
448
          else
 
449
            einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
 
450
          entry->flags.missing_file = TRUE;
 
451
          input_flags.missing_file = TRUE;
 
452
        }
 
453
    }
 
454
}
 
455
 
 
456
/* Try to open NAME.  */
 
457
 
 
458
static FILE *
 
459
try_open (const char *name, bfd_boolean *sysrooted)
 
460
{
 
461
  FILE *result;
 
462
 
 
463
  result = fopen (name, "r");
 
464
 
 
465
  if (result != NULL)
 
466
    *sysrooted = is_sysrooted_pathname (name);
 
467
 
 
468
  if (verbose)
 
469
    {
 
470
      if (result == NULL)
 
471
        info_msg (_("cannot find script file %s\n"), name);
 
472
      else
 
473
        info_msg (_("opened script file %s\n"), name);
 
474
    }
 
475
 
 
476
  return result;
 
477
}
 
478
 
 
479
/* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 
480
 
 
481
static bfd_boolean
 
482
check_for_scripts_dir (char *dir)
 
483
{
 
484
  char *buf;
 
485
  struct stat s;
 
486
  bfd_boolean res;
 
487
 
 
488
  buf = concat (dir, "/ldscripts", (const char *) NULL);
 
489
  res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 
490
  free (buf);
 
491
  return res;
 
492
}
 
493
 
 
494
/* Return the default directory for finding script files.
 
495
   We look for the "ldscripts" directory in:
 
496
 
 
497
   SCRIPTDIR (passed from Makefile)
 
498
             (adjusted according to the current location of the binary)
 
499
   the dir where this program is (for using it from the build tree).  */
 
500
 
 
501
static char *
 
502
find_scripts_dir (void)
 
503
{
 
504
  char *dir;
 
505
 
 
506
  dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 
507
  if (dir)
 
508
    {
 
509
      if (check_for_scripts_dir (dir))
 
510
        return dir;
 
511
      free (dir);
 
512
    }
 
513
 
 
514
  dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 
515
  if (dir)
 
516
    {
 
517
      if (check_for_scripts_dir (dir))
 
518
        return dir;
 
519
      free (dir);
 
520
    }
 
521
 
 
522
  /* Look for "ldscripts" in the dir where our binary is.  */
 
523
  dir = make_relative_prefix (program_name, ".", ".");
 
524
  if (dir)
 
525
    {
 
526
      if (check_for_scripts_dir (dir))
 
527
        return dir;
 
528
      free (dir);
 
529
    }
 
530
 
 
531
  return NULL;
 
532
}
 
533
 
 
534
/* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
 
535
   it in directories specified with -L, then in the default script
 
536
   directory.  If DEFAULT_ONLY is true, the search is restricted to
 
537
   the default script location.  */
 
538
 
 
539
static FILE *
 
540
ldfile_find_command_file (const char *name,
 
541
                          bfd_boolean default_only,
 
542
                          bfd_boolean *sysrooted)
 
543
{
 
544
  search_dirs_type *search;
 
545
  FILE *result = NULL;
 
546
  char *path;
 
547
  static search_dirs_type *script_search;
 
548
 
 
549
  if (!default_only)
 
550
    {
 
551
      /* First try raw name.  */
 
552
      result = try_open (name, sysrooted);
 
553
      if (result != NULL)
 
554
        return result;
 
555
    }
 
556
 
 
557
  if (!script_search)
 
558
    {
 
559
      char *script_dir = find_scripts_dir ();
 
560
      if (script_dir)
 
561
        {
 
562
          search_dirs_type **save_tail_ptr = search_tail_ptr;
 
563
          search_tail_ptr = &script_search;
 
564
          ldfile_add_library_path (script_dir, TRUE);
 
565
          search_tail_ptr = save_tail_ptr;
 
566
        }
 
567
    }
 
568
 
 
569
  /* Temporarily append script_search to the path list so that the
 
570
     paths specified with -L will be searched first.  */
 
571
  *search_tail_ptr = script_search;
 
572
 
 
573
  /* Try now prefixes.  */
 
574
  for (search = default_only ? script_search : search_head;
 
575
       search != NULL;
 
576
       search = search->next)
 
577
    {
 
578
      path = concat (search->name, slash, name, (const char *) NULL);
 
579
      result = try_open (path, sysrooted);
 
580
      free (path);
 
581
      if (result)
 
582
        break;
 
583
    }
 
584
 
 
585
  /* Restore the original path list.  */
 
586
  *search_tail_ptr = NULL;
 
587
 
 
588
  return result;
 
589
}
 
590
 
 
591
/* Open command file NAME.  */
 
592
 
 
593
static void
 
594
ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
 
595
{
 
596
  FILE *ldlex_input_stack;
 
597
  bfd_boolean sysrooted;
 
598
 
 
599
  ldlex_input_stack = ldfile_find_command_file (name, default_only, &sysrooted);
 
600
 
 
601
  if (ldlex_input_stack == NULL)
 
602
    {
 
603
      bfd_set_error (bfd_error_system_call);
 
604
      einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
 
605
      return;
 
606
    }
 
607
 
 
608
  lex_push_file (ldlex_input_stack, name, sysrooted);
 
609
 
 
610
  lineno = 1;
 
611
 
 
612
  saved_script_handle = ldlex_input_stack;
 
613
}
 
614
 
 
615
/* Open command file NAME in the current directory, -L directories,
 
616
   the default script location, in that order.  */
 
617
 
 
618
void
 
619
ldfile_open_command_file (const char *name)
 
620
{
 
621
  ldfile_open_command_file_1 (name, FALSE);
 
622
}
 
623
 
 
624
/* Open command file NAME at the default script location.  */
 
625
 
 
626
void
 
627
ldfile_open_default_command_file (const char *name)
 
628
{
 
629
  ldfile_open_command_file_1 (name, TRUE);
 
630
}
 
631
 
 
632
void
 
633
ldfile_add_arch (const char *in_name)
 
634
{
 
635
  char *name = xstrdup (in_name);
 
636
  search_arch_type *new_arch = (search_arch_type *)
 
637
      xmalloc (sizeof (search_arch_type));
 
638
 
 
639
  ldfile_output_machine_name = in_name;
 
640
 
 
641
  new_arch->name = name;
 
642
  new_arch->next = NULL;
 
643
  while (*name)
 
644
    {
 
645
      *name = TOLOWER (*name);
 
646
      name++;
 
647
    }
 
648
  *search_arch_tail_ptr = new_arch;
 
649
  search_arch_tail_ptr = &new_arch->next;
 
650
 
 
651
}
 
652
 
 
653
/* Set the output architecture.  */
 
654
 
 
655
void
 
656
ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
 
657
{
 
658
  const bfd_arch_info_type *arch = bfd_scan_arch (string);
 
659
 
 
660
  if (arch)
 
661
    {
 
662
      ldfile_output_architecture = arch->arch;
 
663
      ldfile_output_machine = arch->mach;
 
664
      ldfile_output_machine_name = arch->printable_name;
 
665
    }
 
666
  else if (defarch != bfd_arch_unknown)
 
667
    ldfile_output_architecture = defarch;
 
668
  else
 
669
    einfo (_("%P%F: cannot represent machine `%s'\n"), string);
 
670
}