From Craig Silverstein: Have Parameters point to General_options.

1 files changed, 77 insertions, 275 deletions

diff --git a/gold/parameters.h b/gold/parameters.h
index 9d3ebb6..3b10228 100644
--- a/gold/parameters.h
+++ b/gold/parameters.h
@@ -32,16 +32,39 @@ class Target;
 
 // Here we define the Parameters class which simply holds simple
 // general parameters which apply to the entire link.  We use a global
-// variable for this.  This is in contrast to the General_options
-// class, which holds the complete state of position independent
-// command line options.  The hope is that Parameters will stay fairly
-// simple, so that if this turns into a library it will be clear how
-// these parameters should be set.
+// variable for this.  The parameters class holds three types of data:
+//    1) An Errors struct.  Any part of the code that wants to log an
+//       error can use parameters->errors().
+//    2) A const General_options.  These are the options as read on
+//       the commandline.
+//    3) Target information, such as size and endian-ness.  This is
+//       available as soon as we've decided on the Target (after
+//       parsing the first .o file).
+//    4) Whether we're doing a static link or not.  This is set
+//       after all inputs have been read and we know if any is a
+//       dynamic library.
 
 class Parameters
 {
  public:
-  Parameters(Errors*);
+  Parameters()
+    : errors_(NULL), options_(NULL), target_(NULL),
+      doing_static_link_valid_(false), doing_static_link_(false),
+      debug_(0)
+  { }
+
+  // These should be called as soon as they are known.
+  void
+  set_errors(Errors* errors);
+
+  void
+  set_options(const General_options* options);
+
+  void
+  set_target(const Target* target);
+
+  void
+  set_doing_static_link(bool doing_static_link);
 
   // Return the error object.
   Errors*
@@ -52,310 +75,89 @@ class Parameters
   // called, but it is needed by gold_exit.
   bool
   options_valid() const
-  { return this->options_valid_; }
-
-  // Whether to use threads.
-  bool
-  threads() const
-  {
-    gold_assert(this->options_valid_);
-    return this->threads_;
-  }
-
-  // Return the output file name.
-  const char*
-  output_file_name() const
-  {
-    gold_assert(this->options_valid_);
-    return this->output_file_name_;
-  }
-
-  // Whether we are generating a regular executable.
-  bool
-  output_is_executable() const
-  {
-    gold_assert(this->output_file_type_ != OUTPUT_INVALID);
-    return this->output_file_type_ == OUTPUT_EXECUTABLE;
-  }
-
-  // Whether we are generating a shared library.
-  bool
-  output_is_shared() const
-  {
-    gold_assert(this->output_file_type_ != OUTPUT_INVALID);
-    return this->output_file_type_ == OUTPUT_SHARED;
-  }
-
-  // Whether we are generating an object file.
-  bool
-  output_is_object() const
-  {
-    gold_assert(this->output_file_type_ != OUTPUT_INVALID);
-    return this->output_file_type_ == OUTPUT_OBJECT;
-  }
-
-  // Whether we are generating position-independent output.
-  // This is the case when generating either a shared library
-  // or a regular executable with the --pic-executable option.
-  // FIXME: support --pic-executable
-  bool
-  output_is_position_independent() const
-  { return output_is_shared(); }
-
-  // Whether to emit relocations in the output.
-  bool
-  emit_relocs() const
-  { return this->emit_relocs_; }
-
-  // The target system root directory.  This is NULL if there isn't
-  // one.
-  const std::string&
-  sysroot() const
-  {
-    gold_assert(this->options_valid_);
-    return this->sysroot_;
-  }
-
-  // Whether to strip all symbols.
-  bool
-  strip_all() const
-  {
-    gold_assert(this->strip_ != STRIP_INVALID);
-    return this->strip_ == STRIP_ALL;
-  }
-
-  // Whether to strip debugging information.
-  bool
-  strip_debug() const
-  {
-    gold_assert(this->strip_ != STRIP_INVALID);
-    return this->strip_ == STRIP_ALL || this->strip_ == STRIP_DEBUG;
-  }
-
-  // Whether to strip debugging information that's not used by gdb.
-  bool
-  strip_debug_gdb() const
-  {
-    gold_assert(this->strip_ != STRIP_INVALID);
-    return this->strip_debug() || this->strip_ == STRIP_DEBUG_UNUSED_BY_GDB;
-  }
-
-  // Whether to permit unresolved references from shared libraries.
-  bool
-  allow_shlib_undefined() const
-  {
-    gold_assert(this->options_valid_);
-    return this->allow_shlib_undefined_;
-  }
-
-  // Whether we are doing a symbolic link, in which all defined
-  // symbols are bound locally.
-  bool
-  Bsymbolic() const
-  {
-    gold_assert(this->options_valid_);
-    return this->symbolic_;
-  }
-
-  // Whether we should demangle C++ symbols in our log messages.
-  bool
-  demangle() const
-  { return this->demangle_; }
-
-  // Whether we should try to detect violations of the One Definition Rule.
-  bool
-  detect_odr_violations() const
-  {
-    gold_assert(this->options_valid_);
-    return this->detect_odr_violations_;
-  }
-
-  // The general linker optimization level (-O).
-  int
-  optimize() const
-  {
-    gold_assert(this->options_valid_);
-    return this->optimization_level_;
-  }
-
-  // Whether the -E/--export-dynamic flag is set.
-  bool
-  export_dynamic() const
-  {
-    gold_assert(this->options_valid_);
-    return this->export_dynamic_;
-  }
+  { return this->options_ != NULL; }
 
-  // Return the debug flags.  These are the flags for which we should
-  // report internal debugging information.
-  unsigned int
-  debug() const
-  {
-    gold_assert(this->options_valid_);
-    return this->debug_;
-  }
-
-  // Whether we are doing a static link--a link in which none of the
-  // input files are shared libraries.  This is only known after we
-  // have seen all the input files.
-  bool
-  doing_static_link() const
+  // Return the options object.
+  const General_options&
+  options() const
   {
-    gold_assert(this->is_doing_static_link_valid_);
-    return this->doing_static_link_;
+    gold_assert(this->options_valid());
+    return *this->options_;
   }
 
   // Return whether the target field has been set.
   bool
-  is_target_valid() const
-  { return this->is_target_valid_; }
+  target_valid() const
+  { return this->target_ != NULL; }
 
   // The target of the output file we are generating.
-  Target*
+  const Target&
   target() const
   {
-    gold_assert(this->is_target_valid_);
-    return this->target_;
+    gold_assert(this->target_valid());
+    return *this->target_;
   }
 
-  // The size of the output file we are generating.  This should
-  // return 32 or 64.
-  int
-  get_size() const
-  {
-    gold_assert(this->is_target_valid_);
-    return this->size_;
-  }
+  // When we don't have an output file to associate a target, make a
+  // default one, with guesses about size and endianness.
+  const Target&
+  default_target() const;
 
-  // Whether the output is big endian.
   bool
-  is_big_endian() const
-  {
-    gold_assert(this->is_target_valid_);
-    return this->is_big_endian_;
-  }
-
-  // The maximum page size
-  uint64_t
-  max_page_size() const
+  doing_static_link() const
   {
-    gold_assert(this->is_target_valid_);
-    return this->max_page_size_;
+    gold_assert(this->doing_static_link_valid_);
+    return this->doing_static_link_;
   }
 
-  // The common page size
-  uint64_t
-  common_page_size() const
+  // This is just a copy of options().debug().  We make a copy so we
+  // don't have to #include options.h in order to inline
+  // is_debugging_enabled, below.
+  int
+  debug() const
   {
-    gold_assert(this->is_target_valid_);
-    return this->common_page_size_;
+    gold_assert(this->options_valid());
+    return debug_;
   }
 
-  // Set values recorded from options.
-  void
-  set_from_options(const General_options*);
+  // A convenience routine for combining size and endianness.  It also
+  // checks the HAVE_TARGET_FOO configure options and dies if the
+  // current target's size/endianness is not supported according to
+  // HAVE_TARGET_FOO.  Otherwise it returns this enum
+  enum Target_size_endianness
+  { TARGET_32_LITTLE, TARGET_32_BIG, TARGET_64_LITTLE, TARGET_64_BIG };
 
-  // Set whether we are doing a static link.
-  void
-  set_doing_static_link(bool doing_static_link);
+  Target_size_endianness
+  size_and_endianness() const;
 
-  // Set the target.
-  void
-  set_target(Target* target);
 
  private:
-  // The types of output files.
-  enum Output_file_type
-    {
-      // Uninitialized.
-      OUTPUT_INVALID,
-      // Generating executable.
-      OUTPUT_EXECUTABLE,
-      // Generating shared library.
-      OUTPUT_SHARED,
-      // Generating object file.
-      OUTPUT_OBJECT
-    };
-
-  // Which symbols to strip.
-  enum Strip
-  {
-    // Uninitialize.
-    STRIP_INVALID,
-    // Don't strip any symbols.
-    STRIP_NONE,
-    // Strip all symbols.
-    STRIP_ALL,
-    // Strip debugging information.
-    STRIP_DEBUG,
-    // Strip debugging information that's not used by gdb (at least <= 6.7)
-    STRIP_DEBUG_UNUSED_BY_GDB
-  };
-
-  // A pointer to the error handling object.
   Errors* errors_;
-
-  // Whether the fields set from the options are valid.
-  bool options_valid_;
-  // Whether to use threads.
-  bool threads_;
-  // The output file name.
-  const char* output_file_name_;
-  // The type of the output file.
-  Output_file_type output_file_type_;
-  // Whether to emit relocations (-q/--emit-relocs).
-  bool emit_relocs_;
-  // The target system root directory.
-  std::string sysroot_;
-  // Which symbols to strip.
-  Strip strip_;
-  // Whether to allow undefined references from shared libraries.
-  bool allow_shlib_undefined_;
-  // Whether we are doing a symbolic link.
-  bool symbolic_;
-  // Whether we should demangle C++ symbols in our log messages.
-  bool demangle_;
-  // Whether we try to detect One Definition Rule violations.
-  bool detect_odr_violations_;
-  // The optimization level.
-  int optimization_level_;
-  // Whether the -E/--export-dynamic flag is set.
-  bool export_dynamic_;
-  // The debug flags.
-  unsigned int debug_;
-
-  // Whether the doing_static_link_ field is valid.
-  bool is_doing_static_link_valid_;
-  // Whether we are doing a static link.
+  const General_options* options_;
+  const Target* target_;
+  bool doing_static_link_valid_;
   bool doing_static_link_;
-  // Whether the target_ field is valid.
-  bool is_target_valid_;
-  // The target.
-  Target* target_;
-  // The size of the output file--32 or 64.
-  int size_;
-  // Whether the output file is big endian.
-  bool is_big_endian_;
-  // The maximum page size and common page size
-  int max_page_size_;
-  int common_page_size_;
+  int debug_;
 };
 
 // This is a global variable.
 extern const Parameters* parameters;
 
-// Initialize the global variable.
-extern void initialize_parameters(Errors*);
+// We use free functions for these since they affect a global variable
+// that is internal to parameters.cc.
 
-// Set the options.
-extern void set_parameters_from_options(const General_options*);
+extern void
+set_parameters_errors(Errors* errors);
 
-// Set the target recorded in the global parameters variable.
-extern void set_parameters_target(Target* target);
+extern void
+set_parameters_options(const General_options* options);
 
-// Set whether we are doing a static link.
-extern void set_parameters_doing_static_link(bool doing_static_link);
+extern void
+set_parameters_target(const Target* target);
 
+extern void
+set_parameters_doing_static_link(bool doing_static_link);
+  
 // Return whether we are doing a particular debugging type.  The
 // argument is one of the flags from debug.h.