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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [gold/] [options.cc] - Blame information for rev 818

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
// options.c -- handle command line options for gold
2
 
3
// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4
// Written by Ian Lance Taylor <iant@google.com>.
5
 
6
// This file is part of gold.
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 "gold.h"
24
 
25
#include <cerrno>
26
#include <cstdlib>
27
#include <cstring>
28
#include <fstream>
29
#include <vector>
30
#include <iostream>
31
#include <sys/stat.h>
32
#include "filenames.h"
33
#include "libiberty.h"
34
#include "demangle.h"
35
#include "../bfd/bfdver.h"
36
 
37
#include "debug.h"
38
#include "script.h"
39
#include "target-select.h"
40
#include "options.h"
41
#include "plugin.h"
42
 
43
namespace gold
44
{
45
 
46
General_options
47
Position_dependent_options::default_options_;
48
 
49
namespace options
50
{
51
 
52
// This flag is TRUE if we should register the command-line options as they
53
// are constructed.  It is set after contruction of the options within
54
// class Position_dependent_options.
55
static bool ready_to_register = false;
56
 
57
// This global variable is set up as General_options is constructed.
58
static std::vector<const One_option*> registered_options;
59
 
60
// These are set up at the same time -- the variables that accept one
61
// dash, two, or require -z.  A single variable may be in more than
62
// one of thes data structures.
63
typedef Unordered_map<std::string, One_option*> Option_map;
64
static Option_map* long_options = NULL;
65
static One_option* short_options[128];
66
 
67
void
68
One_option::register_option()
69
{
70
  if (!ready_to_register)
71
    return;
72
 
73
  registered_options.push_back(this);
74
 
75
  // We can't make long_options a static Option_map because we can't
76
  // guarantee that will be initialized before register_option() is
77
  // first called.
78
  if (long_options == NULL)
79
    long_options = new Option_map;
80
 
81
  // TWO_DASHES means that two dashes are preferred, but one is ok too.
82
  if (!this->longname.empty())
83
    (*long_options)[this->longname] = this;
84
 
85
  const int shortname_as_int = static_cast<int>(this->shortname);
86
  gold_assert(shortname_as_int >= 0 && shortname_as_int < 128);
87
  if (this->shortname != '\0')
88
    {
89
      gold_assert(short_options[shortname_as_int] == NULL);
90
      short_options[shortname_as_int] = this;
91
    }
92
}
93
 
94
void
95
One_option::print() const
96
{
97
  bool comma = false;
98
  printf("  ");
99
  int len = 2;
100
  if (this->shortname != '\0')
101
    {
102
      len += printf("-%c", this->shortname);
103
      if (this->helparg)
104
        {
105
          // -z takes long-names only.
106
          gold_assert(this->dashes != DASH_Z);
107
          len += printf(" %s", gettext(this->helparg));
108
        }
109
      comma = true;
110
    }
111
  if (!this->longname.empty()
112
      && !(this->longname[0] == this->shortname
113
           && this->longname[1] == '\0'))
114
    {
115
      if (comma)
116
        len += printf(", ");
117
      switch (this->dashes)
118
        {
119
        case options::ONE_DASH: case options::EXACTLY_ONE_DASH:
120
          len += printf("-");
121
          break;
122
        case options::TWO_DASHES: case options::EXACTLY_TWO_DASHES:
123
          len += printf("--");
124
          break;
125
        case options::DASH_Z:
126
          len += printf("-z ");
127
          break;
128
        default:
129
          gold_unreachable();
130
        }
131
      len += printf("%s", this->longname.c_str());
132
      if (this->helparg)
133
        {
134
          // For most options, we print "--frob FOO".  But for -z
135
          // we print "-z frob=FOO".
136
          len += printf("%c%s", this->dashes == options::DASH_Z ? '=' : ' ',
137
                        gettext(this->helparg));
138
        }
139
    }
140
 
141
  if (len >= 30)
142
    {
143
      printf("\n");
144
      len = 0;
145
    }
146
  for (; len < 30; ++len)
147
    std::putchar(' ');
148
 
149
  // TODO: if we're boolean, add " (default)" when appropriate.
150
  printf("%s\n", gettext(this->helpstring));
151
}
152
 
153
void
154
help()
155
{
156
  printf(_("Usage: %s [options] file...\nOptions:\n"), gold::program_name);
157
 
158
  std::vector<const One_option*>::const_iterator it;
159
  for (it = registered_options.begin(); it != registered_options.end(); ++it)
160
    (*it)->print();
161
 
162
  // config.guess and libtool.m4 look in ld --help output for the
163
  // string "supported targets".
164
  printf(_("%s: supported targets:"), gold::program_name);
165
  std::vector<const char*> supported_names;
166
  gold::supported_target_names(&supported_names);
167
  for (std::vector<const char*>::const_iterator p = supported_names.begin();
168
       p != supported_names.end();
169
       ++p)
170
    printf(" %s", *p);
171
  printf("\n");
172
 
173
  // REPORT_BUGS_TO is defined in bfd/bfdver.h.
174
  const char* report = REPORT_BUGS_TO;
175
  if (*report != '\0')
176
    printf(_("Report bugs to %s\n"), report);
177
}
178
 
179
// For bool, arg will be NULL (boolean options take no argument);
180
// we always just set to true.
181
void
182
parse_bool(const char*, const char*, bool* retval)
183
{
184
  *retval = true;
185
}
186
 
187
void
188
parse_uint(const char* option_name, const char* arg, int* retval)
189
{
190
  char* endptr;
191
  *retval = strtol(arg, &endptr, 0);
192
  if (*endptr != '\0' || retval < 0)
193
    gold_fatal(_("%s: invalid option value (expected an integer): %s"),
194
               option_name, arg);
195
}
196
 
197
void
198
parse_int(const char* option_name, const char* arg, int* retval)
199
{
200
  char* endptr;
201
  *retval = strtol(arg, &endptr, 0);
202
  if (*endptr != '\0')
203
    gold_fatal(_("%s: invalid option value (expected an integer): %s"),
204
               option_name, arg);
205
}
206
 
207
void
208
parse_uint64(const char* option_name, const char* arg, uint64_t *retval)
209
{
210
  char* endptr;
211
  *retval = strtoull(arg, &endptr, 0);
212
  if (*endptr != '\0')
213
    gold_fatal(_("%s: invalid option value (expected an integer): %s"),
214
               option_name, arg);
215
}
216
 
217
void
218
parse_double(const char* option_name, const char* arg, double* retval)
219
{
220
  char* endptr;
221
  *retval = strtod(arg, &endptr);
222
  if (*endptr != '\0')
223
    gold_fatal(_("%s: invalid option value "
224
                 "(expected a floating point number): %s"),
225
               option_name, arg);
226
}
227
 
228
void
229
parse_string(const char* option_name, const char* arg, const char** retval)
230
{
231
  if (*arg == '\0')
232
    gold_fatal(_("%s: must take a non-empty argument"), option_name);
233
  *retval = arg;
234
}
235
 
236
void
237
parse_optional_string(const char*, const char* arg, const char** retval)
238
{
239
  *retval = arg;
240
}
241
 
242
void
243
parse_dirlist(const char*, const char* arg, Dir_list* retval)
244
{
245
  retval->push_back(Search_directory(arg, false));
246
}
247
 
248
void
249
parse_set(const char*, const char* arg, String_set* retval)
250
{
251
  retval->insert(std::string(arg));
252
}
253
 
254
void
255
parse_choices(const char* option_name, const char* arg, const char** retval,
256
              const char* choices[], int num_choices)
257
{
258
  for (int i = 0; i < num_choices; i++)
259
    if (strcmp(choices[i], arg) == 0)
260
      {
261
        *retval = arg;
262
        return;
263
      }
264
 
265
  // If we get here, the user did not enter a valid choice, so we die.
266
  std::string choices_list;
267
  for (int i = 0; i < num_choices; i++)
268
    {
269
      choices_list += choices[i];
270
      if (i != num_choices - 1)
271
        choices_list += ", ";
272
    }
273
  gold_fatal(_("%s: must take one of the following arguments: %s"),
274
             option_name, choices_list.c_str());
275
}
276
 
277
} // End namespace options.
278
 
279
// Define the handler for "special" options (set via DEFINE_special).
280
 
281
void
282
General_options::parse_help(const char*, const char*, Command_line*)
283
{
284
  options::help();
285
  ::exit(EXIT_SUCCESS);
286
}
287
 
288
void
289
General_options::parse_version(const char* opt, const char*, Command_line*)
290
{
291
  gold::print_version(opt[0] == '-' && opt[1] == 'v');
292
  ::exit(EXIT_SUCCESS);
293
}
294
 
295
void
296
General_options::parse_V(const char*, const char*, Command_line*)
297
{
298
  gold::print_version(true);
299
  this->printed_version_ = true;
300
  printf(_("  Supported targets:\n"));
301
  std::vector<const char*> supported_names;
302
  gold::supported_target_names(&supported_names);
303
  for (std::vector<const char*>::const_iterator p = supported_names.begin();
304
       p != supported_names.end();
305
       ++p)
306
    printf("   %s\n", *p);
307
}
308
 
309
void
310
General_options::parse_defsym(const char*, const char* arg,
311
                              Command_line* cmdline)
312
{
313
  cmdline->script_options().define_symbol(arg);
314
}
315
 
316
void
317
General_options::parse_incremental_changed(const char*, const char*,
318
                                           Command_line*)
319
{
320
  this->implicit_incremental_ = true;
321
  this->incremental_disposition_ = INCREMENTAL_CHANGED;
322
}
323
 
324
void
325
General_options::parse_incremental_unchanged(const char*, const char*,
326
                                             Command_line*)
327
{
328
  this->implicit_incremental_ = true;
329
  this->incremental_disposition_ = INCREMENTAL_UNCHANGED;
330
}
331
 
332
void
333
General_options::parse_incremental_unknown(const char*, const char*,
334
                                           Command_line*)
335
{
336
  this->implicit_incremental_ = true;
337
  this->incremental_disposition_ = INCREMENTAL_CHECK;
338
}
339
 
340
void
341
General_options::parse_library(const char*, const char* arg,
342
                               Command_line* cmdline)
343
{
344
  Input_file_argument::Input_file_type type;
345
  const char *name;
346
  if (arg[0] == ':')
347
    {
348
      type = Input_file_argument::INPUT_FILE_TYPE_SEARCHED_FILE;
349
      name = arg + 1;
350
    }
351
  else
352
    {
353
      type = Input_file_argument::INPUT_FILE_TYPE_LIBRARY;
354
      name = arg;
355
    }
356
  Input_file_argument file(name, type, "", false, *this);
357
  cmdline->inputs().add_file(file);
358
}
359
 
360
#ifdef ENABLE_PLUGINS
361
void
362
General_options::parse_plugin(const char*, const char* arg,
363
                              Command_line*)
364
{
365
  this->add_plugin(arg);
366
}
367
 
368
// Parse --plugin-opt.
369
 
370
void
371
General_options::parse_plugin_opt(const char*, const char* arg,
372
                                  Command_line*)
373
{
374
  this->add_plugin_option(arg);
375
}
376
#endif // ENABLE_PLUGINS
377
 
378
void
379
General_options::parse_R(const char* option, const char* arg,
380
                         Command_line* cmdline)
381
{
382
  struct stat s;
383
  if (::stat(arg, &s) != 0 || S_ISDIR(s.st_mode))
384
    this->add_to_rpath(arg);
385
  else
386
    this->parse_just_symbols(option, arg, cmdline);
387
}
388
 
389
void
390
General_options::parse_just_symbols(const char*, const char* arg,
391
                                    Command_line* cmdline)
392
{
393
  Input_file_argument file(arg, Input_file_argument::INPUT_FILE_TYPE_FILE,
394
                           "", true, *this);
395
  cmdline->inputs().add_file(file);
396
}
397
 
398
void
399
General_options::parse_static(const char*, const char*, Command_line*)
400
{
401
  this->set_static(true);
402
}
403
 
404
void
405
General_options::parse_script(const char*, const char* arg,
406
                              Command_line* cmdline)
407
{
408
  if (!read_commandline_script(arg, cmdline))
409
    gold::gold_fatal(_("unable to parse script file %s"), arg);
410
}
411
 
412
void
413
General_options::parse_version_script(const char*, const char* arg,
414
                                      Command_line* cmdline)
415
{
416
  if (!read_version_script(arg, cmdline))
417
    gold::gold_fatal(_("unable to parse version script file %s"), arg);
418
}
419
 
420
void
421
General_options::parse_dynamic_list(const char*, const char* arg,
422
                                    Command_line* cmdline)
423
{
424
  if (!read_dynamic_list(arg, cmdline, &this->dynamic_list_))
425
    gold::gold_fatal(_("unable to parse dynamic-list script file %s"), arg);
426
}
427
 
428
void
429
General_options::parse_start_group(const char*, const char*,
430
                                   Command_line* cmdline)
431
{
432
  cmdline->inputs().start_group();
433
}
434
 
435
void
436
General_options::parse_end_group(const char*, const char*,
437
                                 Command_line* cmdline)
438
{
439
  cmdline->inputs().end_group();
440
}
441
 
442
// The function add_excluded_libs() in ld/ldlang.c of GNU ld breaks up a list
443
// of names seperated by commas or colons and puts them in a linked list.
444
// We implement the same parsing of names here but store names in an unordered
445
// map to speed up searching of names.
446
 
447
void
448
General_options::parse_exclude_libs(const char*, const char* arg,
449
                                    Command_line*)
450
{
451
  const char *p = arg;
452
 
453
  while (*p != '\0')
454
    {
455
      size_t length = strcspn(p, ",:");
456
      this->excluded_libs_.insert(std::string(p, length));
457
      p += (p[length] ? length + 1 : length);
458
    }
459
}
460
 
461
// The checking logic is based on the function check_excluded_libs() in
462
// ld/ldlang.c of GNU ld but our implementation is different because we use
463
// an unordered map instead of a linked list, which is what GNU ld uses.  GNU
464
// ld searches sequentially in the excluded libs list.  For a given archive,
465
// a match is found if the archive's name matches exactly one of the list
466
// entry or if the archive's name is of the form FOO.a and FOO matches exactly
467
// one of the list entry.  An entry "ALL" in the list is considered as a
468
// wild-card and matches any given name.
469
 
470
bool
471
General_options::check_excluded_libs (const std::string &name) const
472
{
473
  Unordered_set<std::string>::const_iterator p;
474
 
475
  // Exit early for the most common case.
476
  if (excluded_libs_.empty())
477
    return false;
478
 
479
  // If we see "ALL", all archives are excluded from automatic export.
480
  p = excluded_libs_.find(std::string("ALL"));
481
  if (p != excluded_libs_.end())
482
    return true;
483
 
484
  // First strip off any directories in name.
485
  const char *basename = lbasename(name.c_str());
486
 
487
  // Try finding an exact match.
488
  p = excluded_libs_.find(std::string(basename));
489
  if (p != excluded_libs_.end())
490
    return true;
491
 
492
  // Try matching NAME without ".a" at the end.
493
  size_t length = strlen(basename);
494
  if ((length >= 2)
495
      && (basename[length - 2] == '.')
496
      && (basename[length - 1] == 'a'))
497
    {
498
      p = excluded_libs_.find(std::string(basename, length - 2));
499
      if (p != excluded_libs_.end())
500
        return true;
501
    }
502
 
503
  return false;
504
}
505
 
506
// Recognize input and output target names.  The GNU linker accepts
507
// these with --format and --oformat.  This code is intended to be
508
// minimally compatible.  In practice for an ELF target this would be
509
// the same target as the input files; that name always start with
510
// "elf".  Non-ELF targets would be "srec", "symbolsrec", "tekhex",
511
// "binary", "ihex".
512
 
513
General_options::Object_format
514
General_options::string_to_object_format(const char* arg)
515
{
516
  if (strncmp(arg, "elf", 3) == 0)
517
    return gold::General_options::OBJECT_FORMAT_ELF;
518
  else if (strcmp(arg, "binary") == 0)
519
    return gold::General_options::OBJECT_FORMAT_BINARY;
520
  else
521
    {
522
      gold::gold_error(_("format '%s' not supported; treating as elf "
523
                         "(supported formats: elf, binary)"),
524
                       arg);
525
      return gold::General_options::OBJECT_FORMAT_ELF;
526
    }
527
}
528
 
529
} // End namespace gold.
530
 
531
namespace
532
{
533
 
534
void
535
usage()
536
{
537
  fprintf(stderr,
538
          _("%s: use the --help option for usage information\n"),
539
          gold::program_name);
540
  ::exit(EXIT_FAILURE);
541
}
542
 
543
void
544
usage(const char* msg, const char *opt)
545
{
546
  fprintf(stderr,
547
          _("%s: %s: %s\n"),
548
          gold::program_name, opt, msg);
549
  usage();
550
}
551
 
552
// If the default sysroot is relocatable, try relocating it based on
553
// the prefix FROM.
554
 
555
static char*
556
get_relative_sysroot(const char* from)
557
{
558
  char* path = make_relative_prefix(gold::program_name, from,
559
                                    TARGET_SYSTEM_ROOT);
560
  if (path != NULL)
561
    {
562
      struct stat s;
563
      if (::stat(path, &s) == 0 && S_ISDIR(s.st_mode))
564
        return path;
565
      free(path);
566
    }
567
 
568
  return NULL;
569
}
570
 
571
// Return the default sysroot.  This is set by the --with-sysroot
572
// option to configure.  Note we do not free the return value of
573
// get_relative_sysroot, which is a small memory leak, but is
574
// necessary since we store this pointer directly in General_options.
575
 
576
static const char*
577
get_default_sysroot()
578
{
579
  const char* sysroot = TARGET_SYSTEM_ROOT;
580
  if (*sysroot == '\0')
581
    return NULL;
582
 
583
  if (TARGET_SYSTEM_ROOT_RELOCATABLE)
584
    {
585
      char* path = get_relative_sysroot(BINDIR);
586
      if (path == NULL)
587
        path = get_relative_sysroot(TOOLBINDIR);
588
      if (path != NULL)
589
        return path;
590
    }
591
 
592
  return sysroot;
593
}
594
 
595
// Parse a long option.  Such options have the form
596
// <-|--><option>[=arg].  If "=arg" is not present but the option
597
// takes an argument, the next word is taken to the be the argument.
598
// If equals_only is set, then only the <option>=<arg> form is
599
// accepted, not the <option><space><arg> form.  Returns a One_option
600
// struct or NULL if argv[i] cannot be parsed as a long option.  In
601
// the not-NULL case, *arg is set to the option's argument (NULL if
602
// the option takes no argument), and *i is advanced past this option.
603
// NOTE: it is safe for argv and arg to point to the same place.
604
gold::options::One_option*
605
parse_long_option(int argc, const char** argv, bool equals_only,
606
                  const char** arg, int* i)
607
{
608
  const char* const this_argv = argv[*i];
609
 
610
  const char* equals = strchr(this_argv, '=');
611
  const char* option_start = this_argv + strspn(this_argv, "-");
612
  std::string option(option_start,
613
                     equals ? equals - option_start : strlen(option_start));
614
 
615
  gold::options::Option_map::iterator it
616
      = gold::options::long_options->find(option);
617
  if (it == gold::options::long_options->end())
618
    return NULL;
619
 
620
  gold::options::One_option* retval = it->second;
621
 
622
  // If the dash-count doesn't match, we fail.
623
  if (this_argv[0] != '-')  // no dashes at all: had better be "-z <longopt>"
624
    {
625
      if (retval->dashes != gold::options::DASH_Z)
626
        return NULL;
627
    }
628
  else if (this_argv[1] != '-')   // one dash
629
    {
630
      if (retval->dashes != gold::options::ONE_DASH
631
          && retval->dashes != gold::options::EXACTLY_ONE_DASH
632
          && retval->dashes != gold::options::TWO_DASHES)
633
        return NULL;
634
    }
635
  else                            // two dashes (or more!)
636
    {
637
      if (retval->dashes != gold::options::TWO_DASHES
638
          && retval->dashes != gold::options::EXACTLY_TWO_DASHES
639
          && retval->dashes != gold::options::ONE_DASH)
640
        return NULL;
641
    }
642
 
643
  // Now that we know the option is good (or else bad in a way that
644
  // will cause us to die), increment i to point past this argv.
645
  ++(*i);
646
 
647
  // Figure out the option's argument, if any.
648
  if (!retval->takes_argument())
649
    {
650
      if (equals)
651
        usage(_("unexpected argument"), this_argv);
652
      else
653
        *arg = NULL;
654
    }
655
  else
656
    {
657
      if (equals)
658
        *arg = equals + 1;
659
      else if (retval->takes_optional_argument())
660
        *arg = retval->default_value;
661
      else if (*i < argc && !equals_only)
662
        *arg = argv[(*i)++];
663
      else
664
        usage(_("missing argument"), this_argv);
665
    }
666
 
667
  return retval;
668
}
669
 
670
// Parse a short option.  Such options have the form -<option>[arg].
671
// If "arg" is not present but the option takes an argument, the next
672
// word is taken to the be the argument.  If the option does not take
673
// an argument, it may be followed by another short option.  Returns a
674
// One_option struct or NULL if argv[i] cannot be parsed as a short
675
// option.  In the not-NULL case, *arg is set to the option's argument
676
// (NULL if the option takes no argument), and *i is advanced past
677
// this option.  This function keeps *i the same if we parsed a short
678
// option that does not take an argument, that looks to be followed by
679
// another short option in the same word.
680
gold::options::One_option*
681
parse_short_option(int argc, const char** argv, int pos_in_argv_i,
682
                   const char** arg, int* i)
683
{
684
  const char* const this_argv = argv[*i];
685
 
686
  if (this_argv[0] != '-')
687
    return NULL;
688
 
689
  // We handle -z as a special case.
690
  static gold::options::One_option dash_z("", gold::options::DASH_Z,
691
                                          'z', "", NULL, "Z-OPTION", false,
692
                                          NULL);
693
  gold::options::One_option* retval = NULL;
694
  if (this_argv[pos_in_argv_i] == 'z')
695
    retval = &dash_z;
696
  else
697
    {
698
      const int char_as_int = static_cast<int>(this_argv[pos_in_argv_i]);
699
      if (char_as_int > 0 && char_as_int < 128)
700
        retval = gold::options::short_options[char_as_int];
701
    }
702
 
703
  if (retval == NULL)
704
    return NULL;
705
 
706
  // Figure out the option's argument, if any.
707
  if (!retval->takes_argument())
708
    {
709
      *arg = NULL;
710
      // We only advance past this argument if it's the only one in argv.
711
      if (this_argv[pos_in_argv_i + 1] == '\0')
712
        ++(*i);
713
    }
714
  else
715
    {
716
      // If we take an argument, we'll eat up this entire argv entry.
717
      ++(*i);
718
      if (this_argv[pos_in_argv_i + 1] != '\0')
719
        *arg = this_argv + pos_in_argv_i + 1;
720
      else if (retval->takes_optional_argument())
721
        *arg = retval->default_value;
722
      else if (*i < argc)
723
        *arg = argv[(*i)++];
724
      else
725
        usage(_("missing argument"), this_argv);
726
    }
727
 
728
  // If we're a -z option, we need to parse our argument as a
729
  // long-option, e.g. "-z stacksize=8192".
730
  if (retval == &dash_z)
731
    {
732
      int dummy_i = 0;
733
      const char* dash_z_arg = *arg;
734
      retval = parse_long_option(1, arg, true, arg, &dummy_i);
735
      if (retval == NULL)
736
        usage(_("unknown -z option"), dash_z_arg);
737
    }
738
 
739
  return retval;
740
}
741
 
742
} // End anonymous namespace.
743
 
744
namespace gold
745
{
746
 
747
General_options::General_options()
748
  : printed_version_(false),
749
    execstack_status_(General_options::EXECSTACK_FROM_INPUT), static_(false),
750
    do_demangle_(false), plugins_(),
751
    incremental_disposition_(INCREMENTAL_CHECK), implicit_incremental_(false)
752
{
753
  // Turn off option registration once construction is complete.
754
  gold::options::ready_to_register = false;
755
}
756
 
757
General_options::Object_format
758
General_options::format_enum() const
759
{
760
  return General_options::string_to_object_format(this->format());
761
}
762
 
763
General_options::Object_format
764
General_options::oformat_enum() const
765
{
766
  return General_options::string_to_object_format(this->oformat());
767
}
768
 
769
// Add the sysroot, if any, to the search paths.
770
 
771
void
772
General_options::add_sysroot()
773
{
774
  if (this->sysroot() == NULL || this->sysroot()[0] == '\0')
775
    {
776
      this->set_sysroot(get_default_sysroot());
777
      if (this->sysroot() == NULL || this->sysroot()[0] == '\0')
778
        return;
779
    }
780
 
781
  char* canonical_sysroot = lrealpath(this->sysroot());
782
 
783
  for (Dir_list::iterator p = this->library_path_.value.begin();
784
       p != this->library_path_.value.end();
785
       ++p)
786
    p->add_sysroot(this->sysroot(), canonical_sysroot);
787
 
788
  free(canonical_sysroot);
789
}
790
 
791
// Return whether FILENAME is in a system directory.
792
 
793
bool
794
General_options::is_in_system_directory(const std::string& filename) const
795
{
796
  for (Dir_list::const_iterator p = this->library_path_.value.begin();
797
       p != this->library_path_.value.end();
798
       ++p)
799
    {
800
      // We use a straight string comparison rather than calling
801
      // FILENAME_CMP because we are only interested in the cases
802
      // where we found the file in a system directory, which means
803
      // that we used the directory name as a prefix for a -L search.
804
      if (p->is_system_directory()
805
          && filename.compare(0, p->name().size(), p->name()) == 0)
806
        return true;
807
    }
808
  return false;
809
}
810
 
811
// Add a plugin to the list of plugins.
812
 
813
void
814
General_options::add_plugin(const char* filename)
815
{
816
  if (this->plugins_ == NULL)
817
    this->plugins_ = new Plugin_manager(*this);
818
  this->plugins_->add_plugin(filename);
819
}
820
 
821
// Add a plugin option to a plugin.
822
 
823
void
824
General_options::add_plugin_option(const char* arg)
825
{
826
  if (this->plugins_ == NULL)
827
    gold_fatal("--plugin-opt requires --plugin.");
828
  this->plugins_->add_plugin_option(arg);
829
}
830
 
831
// Set up variables and other state that isn't set up automatically by
832
// the parse routine, and ensure options don't contradict each other
833
// and are otherwise kosher.
834
 
835
void
836
General_options::finalize()
837
{
838
  // Normalize the strip modifiers.  They have a total order:
839
  // strip_all > strip_debug > strip_non_line > strip_debug_gdb.
840
  // If one is true, set all beneath it to true as well.
841
  if (this->strip_all())
842
    this->set_strip_debug(true);
843
  if (this->strip_debug())
844
    this->set_strip_debug_non_line(true);
845
  if (this->strip_debug_non_line())
846
    this->set_strip_debug_gdb(true);
847
 
848
  if (this->Bshareable())
849
    this->set_shared(true);
850
 
851
  // If the user specifies both -s and -r, convert the -s to -S.
852
  // -r requires us to keep externally visible symbols!
853
  if (this->strip_all() && this->relocatable())
854
    {
855
      this->set_strip_all(false);
856
      gold_assert(this->strip_debug());
857
    }
858
 
859
  // For us, -dc and -dp are synonyms for --define-common.
860
  if (this->dc())
861
    this->set_define_common(true);
862
  if (this->dp())
863
    this->set_define_common(true);
864
 
865
  // We also set --define-common if we're not relocatable, as long as
866
  // the user didn't explicitly ask for something different.
867
  if (!this->user_set_define_common())
868
    this->set_define_common(!this->relocatable());
869
 
870
  // execstack_status_ is a three-state variable; update it based on
871
  // -z [no]execstack.
872
  if (this->execstack())
873
    this->set_execstack_status(EXECSTACK_YES);
874
  else if (this->noexecstack())
875
    this->set_execstack_status(EXECSTACK_NO);
876
 
877
  // icf_status_ is a three-state variable; update it based on the
878
  // value of this->icf().
879
  if (strcmp(this->icf(), "none") == 0)
880
    this->set_icf_status(ICF_NONE);
881
  else if (strcmp(this->icf(), "safe") == 0)
882
    this->set_icf_status(ICF_SAFE);
883
  else
884
    this->set_icf_status(ICF_ALL);
885
 
886
  // Handle the optional argument for --demangle.
887
  if (this->user_set_demangle())
888
    {
889
      this->set_do_demangle(true);
890
      const char* style = this->demangle();
891
      if (*style != '\0')
892
        {
893
          enum demangling_styles style_code;
894
 
895
          style_code = cplus_demangle_name_to_style(style);
896
          if (style_code == unknown_demangling)
897
            gold_fatal("unknown demangling style '%s'", style);
898
          cplus_demangle_set_style(style_code);
899
        }
900
    }
901
  else if (this->user_set_no_demangle())
902
    this->set_do_demangle(false);
903
  else
904
    {
905
      // Testing COLLECT_NO_DEMANGLE makes our default demangling
906
      // behaviour identical to that of gcc's linker wrapper.
907
      this->set_do_demangle(getenv("COLLECT_NO_DEMANGLE") == NULL);
908
    }
909
 
910
  // -M is equivalent to "-Map -".
911
  if (this->print_map() && !this->user_set_Map())
912
    {
913
      this->set_Map("-");
914
      this->set_user_set_Map();
915
    }
916
 
917
  // Using -n or -N implies -static.
918
  if (this->nmagic() || this->omagic())
919
    this->set_static(true);
920
 
921
  // If --thread_count is specified, it applies to
922
  // --thread-count-{initial,middle,final}, though it doesn't override
923
  // them.
924
  if (this->thread_count() > 0 && this->thread_count_initial() == 0)
925
    this->set_thread_count_initial(this->thread_count());
926
  if (this->thread_count() > 0 && this->thread_count_middle() == 0)
927
    this->set_thread_count_middle(this->thread_count());
928
  if (this->thread_count() > 0 && this->thread_count_final() == 0)
929
    this->set_thread_count_final(this->thread_count());
930
 
931
  // Let's warn if you set the thread-count but we're going to ignore it.
932
#ifndef ENABLE_THREADS
933
  if (this->threads())
934
    {
935
      gold_warning(_("ignoring --threads: "
936
                     "%s was compiled without thread support"),
937
                   program_name);
938
      this->set_threads(false);
939
    }
940
  if (this->thread_count() > 0 || this->thread_count_initial() > 0
941
      || this->thread_count_middle() > 0 || this->thread_count_final() > 0)
942
    gold_warning(_("ignoring --thread-count: "
943
                   "%s was compiled without thread support"),
944
                 program_name);
945
#endif
946
 
947
  if (this->user_set_Y())
948
    {
949
      std::string s = this->Y();
950
      if (s.compare(0, 2, "P,") == 0)
951
        s.erase(0, 2);
952
 
953
      size_t pos = 0;
954
      size_t next_pos;
955
      do
956
        {
957
          next_pos = s.find(':', pos);
958
          size_t len = (next_pos == std::string::npos
959
                        ? next_pos
960
                        : next_pos - pos);
961
          if (len != 0)
962
            this->add_to_library_path_with_sysroot(s.substr(pos, len).c_str());
963
          pos = next_pos + 1;
964
        }
965
      while (next_pos != std::string::npos);
966
    }
967
  else
968
    {
969
      // Even if they don't specify it, we add -L /lib and -L /usr/lib.
970
      // FIXME: We should only do this when configured in native mode.
971
      this->add_to_library_path_with_sysroot("/lib");
972
      this->add_to_library_path_with_sysroot("/usr/lib");
973
    }
974
 
975
  // Parse the contents of -retain-symbols-file into a set.
976
  if (this->retain_symbols_file())
977
    {
978
      std::ifstream in;
979
      in.open(this->retain_symbols_file());
980
      if (!in)
981
        gold_fatal(_("unable to open -retain-symbols-file file %s: %s"),
982
                   this->retain_symbols_file(), strerror(errno));
983
      std::string line;
984
      std::getline(in, line);   // this chops off the trailing \n, if any
985
      while (in)
986
        {
987
          if (!line.empty() && line[line.length() - 1] == '\r')   // Windows
988
            line.resize(line.length() - 1);
989
          this->symbols_to_retain_.insert(line);
990
          std::getline(in, line);
991
        }
992
    }
993
 
994
  if (this->shared() && !this->user_set_allow_shlib_undefined())
995
    this->set_allow_shlib_undefined(true);
996
 
997
  // Normalize library_path() by adding the sysroot to all directories
998
  // in the path, as appropriate.
999
  this->add_sysroot();
1000
 
1001
  // Now that we've normalized the options, check for contradictory ones.
1002
  if (this->shared() && this->is_static())
1003
    gold_fatal(_("-shared and -static are incompatible"));
1004
  if (this->shared() && this->pie())
1005
    gold_fatal(_("-shared and -pie are incompatible"));
1006
 
1007
  if (this->shared() && this->relocatable())
1008
    gold_fatal(_("-shared and -r are incompatible"));
1009
  if (this->pie() && this->relocatable())
1010
    gold_fatal(_("-pie and -r are incompatible"));
1011
 
1012
  // TODO: implement support for -retain-symbols-file with -r, if needed.
1013
  if (this->relocatable() && this->retain_symbols_file())
1014
    gold_fatal(_("-retain-symbols-file does not yet work with -r"));
1015
 
1016
  if (this->oformat_enum() != General_options::OBJECT_FORMAT_ELF
1017
      && (this->shared()
1018
          || this->pie()
1019
          || this->relocatable()))
1020
    gold_fatal(_("binary output format not compatible "
1021
                 "with -shared or -pie or -r"));
1022
 
1023
  if (this->user_set_hash_bucket_empty_fraction()
1024
      && (this->hash_bucket_empty_fraction() < 0.0
1025
          || this->hash_bucket_empty_fraction() >= 1.0))
1026
    gold_fatal(_("--hash-bucket-empty-fraction value %g out of range "
1027
                 "[0.0, 1.0)"),
1028
               this->hash_bucket_empty_fraction());
1029
 
1030
  if (this->implicit_incremental_ && !this->incremental())
1031
    gold_fatal(_("Options --incremental-changed, --incremental-unchanged, "
1032
                 "--incremental-unknown require the use of --incremental"));
1033
 
1034
  // FIXME: we can/should be doing a lot more sanity checking here.
1035
}
1036
 
1037
// Search_directory methods.
1038
 
1039
// This is called if we have a sysroot.  Apply the sysroot if
1040
// appropriate.  Record whether the directory is in the sysroot.
1041
 
1042
void
1043
Search_directory::add_sysroot(const char* sysroot,
1044
                              const char* canonical_sysroot)
1045
{
1046
  gold_assert(*sysroot != '\0');
1047
  if (this->put_in_sysroot_)
1048
    {
1049
      if (!IS_DIR_SEPARATOR(this->name_[0])
1050
          && !IS_DIR_SEPARATOR(sysroot[strlen(sysroot) - 1]))
1051
        this->name_ = '/' + this->name_;
1052
      this->name_ = sysroot + this->name_;
1053
      this->is_in_sysroot_ = true;
1054
    }
1055
  else
1056
    {
1057
      // Check whether this entry is in the sysroot.  To do this
1058
      // correctly, we need to use canonical names.  Otherwise we will
1059
      // get confused by the ../../.. paths that gcc tends to use.
1060
      char* canonical_name = lrealpath(this->name_.c_str());
1061
      int canonical_name_len = strlen(canonical_name);
1062
      int canonical_sysroot_len = strlen(canonical_sysroot);
1063
      if (canonical_name_len > canonical_sysroot_len
1064
          && IS_DIR_SEPARATOR(canonical_name[canonical_sysroot_len]))
1065
        {
1066
          canonical_name[canonical_sysroot_len] = '\0';
1067
          if (FILENAME_CMP(canonical_name, canonical_sysroot) == 0)
1068
            this->is_in_sysroot_ = true;
1069
        }
1070
      free(canonical_name);
1071
    }
1072
}
1073
 
1074
// Input_arguments methods.
1075
 
1076
// Add a file to the list.
1077
 
1078
void
1079
Input_arguments::add_file(const Input_file_argument& file)
1080
{
1081
  if (!this->in_group_)
1082
    this->input_argument_list_.push_back(Input_argument(file));
1083
  else
1084
    {
1085
      gold_assert(!this->input_argument_list_.empty());
1086
      gold_assert(this->input_argument_list_.back().is_group());
1087
      this->input_argument_list_.back().group()->add_file(file);
1088
    }
1089
}
1090
 
1091
// Start a group.
1092
 
1093
void
1094
Input_arguments::start_group()
1095
{
1096
  if (this->in_group_)
1097
    gold_fatal(_("May not nest groups"));
1098
  Input_file_group* group = new Input_file_group();
1099
  this->input_argument_list_.push_back(Input_argument(group));
1100
  this->in_group_ = true;
1101
}
1102
 
1103
// End a group.
1104
 
1105
void
1106
Input_arguments::end_group()
1107
{
1108
  if (!this->in_group_)
1109
    gold_fatal(_("Group end without group start"));
1110
  this->in_group_ = false;
1111
}
1112
 
1113
// Command_line options.
1114
 
1115
Command_line::Command_line()
1116
{
1117
}
1118
 
1119
// Pre_options is the hook that sets the ready_to_register flag.
1120
 
1121
Command_line::Pre_options::Pre_options()
1122
{
1123
  gold::options::ready_to_register = true;
1124
}
1125
 
1126
// Process the command line options.  For process_one_option, i is the
1127
// index of argv to process next, and must be an option (that is,
1128
// start with a dash).  The return value is the index of the next
1129
// option to process (i+1 or i+2, or argc to indicate processing is
1130
// done).  no_more_options is set to true if (and when) "--" is seen
1131
// as an option.
1132
 
1133
int
1134
Command_line::process_one_option(int argc, const char** argv, int i,
1135
                                 bool* no_more_options)
1136
{
1137
  gold_assert(argv[i][0] == '-' && !(*no_more_options));
1138
 
1139
  // If we are reading "--", then just set no_more_options and return.
1140
  if (argv[i][1] == '-' && argv[i][2] == '\0')
1141
    {
1142
      *no_more_options = true;
1143
      return i + 1;
1144
    }
1145
 
1146
  int new_i = i;
1147
  options::One_option* option = NULL;
1148
  const char* arg = NULL;
1149
 
1150
  // First, try to process argv as a long option.
1151
  option = parse_long_option(argc, argv, false, &arg, &new_i);
1152
  if (option)
1153
    {
1154
      option->reader->parse_to_value(argv[i], arg, this, &this->options_);
1155
      return new_i;
1156
    }
1157
 
1158
  // Now, try to process argv as a short option.  Since several short
1159
  // options can be combined in one argv, we may have to parse a lot
1160
  // until we're done reading this argv.
1161
  int pos_in_argv_i = 1;
1162
  while (new_i == i)
1163
    {
1164
      option = parse_short_option(argc, argv, pos_in_argv_i, &arg, &new_i);
1165
      if (!option)
1166
        break;
1167
      option->reader->parse_to_value(argv[i], arg, this, &this->options_);
1168
      ++pos_in_argv_i;
1169
    }
1170
  if (option)
1171
    return new_i;
1172
 
1173
  // I guess it's neither a long option nor a short option.
1174
  usage(_("unknown option"), argv[i]);
1175
  return argc;
1176
}
1177
 
1178
 
1179
void
1180
Command_line::process(int argc, const char** argv)
1181
{
1182
  bool no_more_options = false;
1183
  int i = 0;
1184
  while (i < argc)
1185
    {
1186
      this->position_options_.copy_from_options(this->options());
1187
      if (no_more_options || argv[i][0] != '-')
1188
        {
1189
          Input_file_argument file(argv[i],
1190
                                   Input_file_argument::INPUT_FILE_TYPE_FILE,
1191
                                   "", false, this->position_options_);
1192
          this->inputs_.add_file(file);
1193
          ++i;
1194
        }
1195
      else
1196
        i = process_one_option(argc, argv, i, &no_more_options);
1197
    }
1198
 
1199
  if (this->inputs_.in_group())
1200
    {
1201
      fprintf(stderr, _("%s: missing group end\n"), program_name);
1202
      usage();
1203
    }
1204
 
1205
  // Normalize the options and ensure they don't contradict each other.
1206
  this->options_.finalize();
1207
}
1208
 
1209
} // End namespace gold.

powered by: WebSVN 2.1.0

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