PR 6049

	* options.h (DEFINE_set): Add VARNAME_begin and VARNAME_end
	functions.
	(class General_options): Remove existing --undefined, and add
	--no-undefined instead.  Add new --undefined as synonym for -u.
	* archive.cc (Archive::add_symbols): Check whether symbol was
	named with -u.
	* gold.cc (queue_middle_tasks): Add -u symbols to symbol table.
	* symtab.h (class Symbol): Rename CONSTANT to IS_CONSTANT; change
	all uses.  Add IS_UNDEFINED.  Update declarations to split
	different versions of init_base.  Declare init_base_undefined.
	(Symbol::is_defined): Handle IS_UNDEFINED.
	(Symbol::is_undefined): Likewise.
	(Symbol::is_weak_undefined): Call is_undefined.
	(Symbol::is_absolute): Handle IS_CONSTANT.
	(class Sized_symbol): Update declarations to split different
	versions of init.  Declare init_undefined.
	(class Symbol_table): Declare new functions.
	* symtab.cc (Symbol::init_base_object): Rename from init_base.
	Change all callers.
	(Symbol::init_base_output_data): Likewise.
	(Symbol::init_base_output_segment): Likewise.
	(Symbol::init_base_constant): Likewise.
	(Symbol::init_base_undefined): New function.
	(Sized_symbol::init_object): Rename from init.  Change all
	callers.
	(Sized_symbol::init_output_data): Likewise.
	(Sized_symbol::init_output_segment): Likewise.
	(Sized_symbol::init_constant): Likewise.
	(Sized_symbol::init_undefined): New function.
	(Symbol_table::add_undefined_symbols_from_command_line): New
	function.
	(Symbol_table::do_add_undefined_symbols_from_command_line): New
	function.
	(Symbol::final_value_is_known): Handle IS_UNDEFINED.
	(Symbol::output_section): Likewise.
	(Symbol::set_output_section): Likewise.
	(Symbol_table::sized_finalize_symbol): Likewise.
	(Symbol_table::sized_write_globals): Likewise.
	* resolve.cc (Symbol_table::should_override): Likewise.
	(Symbol::override_base_with_special): Likewise.

diff --git a/gold/ChangeLog b/gold/ChangeLog
index ba92005d49ba112994b6e85ebc64ba2d429ebb3f..49acc337921ad64e5cadf89665a7c763596e9978 100644 (file)
--- a/gold/ChangeLog
+++ b/gold/ChangeLog
@@ -1,5 +1,47 @@
 2008-05-06  Ian Lance Taylor  <iant@google.com>
 
+       PR 6049
+       * options.h (DEFINE_set): Add VARNAME_begin and VARNAME_end
+       functions.
+       (class General_options): Remove existing --undefined, and add
+       --no-undefined instead.  Add new --undefined as synonym for -u.
+       * archive.cc (Archive::add_symbols): Check whether symbol was
+       named with -u.
+       * gold.cc (queue_middle_tasks): Add -u symbols to symbol table.
+       * symtab.h (class Symbol): Rename CONSTANT to IS_CONSTANT; change
+       all uses.  Add IS_UNDEFINED.  Update declarations to split
+       different versions of init_base.  Declare init_base_undefined.
+       (Symbol::is_defined): Handle IS_UNDEFINED.
+       (Symbol::is_undefined): Likewise.
+       (Symbol::is_weak_undefined): Call is_undefined.
+       (Symbol::is_absolute): Handle IS_CONSTANT.
+       (class Sized_symbol): Update declarations to split different
+       versions of init.  Declare init_undefined.
+       (class Symbol_table): Declare new functions.
+       * symtab.cc (Symbol::init_base_object): Rename from init_base.
+       Change all callers.
+       (Symbol::init_base_output_data): Likewise.
+       (Symbol::init_base_output_segment): Likewise.
+       (Symbol::init_base_constant): Likewise.
+       (Symbol::init_base_undefined): New function.
+       (Sized_symbol::init_object): Rename from init.  Change all
+       callers.
+       (Sized_symbol::init_output_data): Likewise.
+       (Sized_symbol::init_output_segment): Likewise.
+       (Sized_symbol::init_constant): Likewise.
+       (Sized_symbol::init_undefined): New function.
+       (Symbol_table::add_undefined_symbols_from_command_line): New
+       function.
+       (Symbol_table::do_add_undefined_symbols_from_command_line): New
+       function.
+       (Symbol::final_value_is_known): Handle IS_UNDEFINED.
+       (Symbol::output_section): Likewise.
+       (Symbol::set_output_section): Likewise.
+       (Symbol_table::sized_finalize_symbol): Likewise.
+       (Symbol_table::sized_write_globals): Likewise.
+       * resolve.cc (Symbol_table::should_override): Likewise.
+       (Symbol::override_base_with_special): Likewise.
+
        * symtab.cc (Symbol_table::add_from_dynobj): If we see a protected
        symbol, change it to have default visibility.
        * testsuite/protected_1.cc: New file.

diff --git a/gold/archive.cc b/gold/archive.cc
index be623b511d776038e4ba9e2dbda79285769afbbe..1e16de9c76e764234f64db1a5c52d7dfd9a546b5 100644 (file)
--- a/gold/archive.cc
+++ b/gold/archive.cc
@@ -326,7 +326,11 @@ Archive::add_symbols(Symbol_table* symtab, Layout* layout,
                                  + this->armap_[i].name_offset);
          Symbol* sym = symtab->lookup(sym_name);
          if (sym == NULL)
-           continue;
+           {
+             // Check whether the symbol was named in a -u option.
+             if (!parameters->options().is_undefined(sym_name))
+               continue;
+           }
          else if (!sym->is_undefined())
            {
               this->armap_checked_[i] = true;

diff --git a/gold/gold.cc b/gold/gold.cc
index 54b082823e50c2876bf27a10d6394790be0d8e4a..396a5a940f3744feb63b45e9e64ac38a4be085ad 100644 (file)
--- a/gold/gold.cc
+++ b/gold/gold.cc
@@ -212,6 +212,9 @@ queue_middle_tasks(const General_options& options,
   // Define symbols from any linker scripts.
   layout->define_script_symbols(symtab);
 
+  // Add any symbols named with -u options to the symbol table.
+  symtab->add_undefined_symbols_from_command_line();
+
   // Attach sections to segments.
   layout->attach_sections_to_segments();
 

diff --git a/gold/options.h b/gold/options.h
index cf9b887f1c9360ae794b320230b4d3d9a6a86d65..bfb40c747578eea56ce5d63e9d523c89603c5135 100644 (file)
--- a/gold/options.h
+++ b/gold/options.h
@@ -369,13 +369,22 @@ struct Struct_special : public Struct_var
   bool                                                                    \
   any_##varname__() const                                                 \
   { return !this->varname__##_.value.empty(); }                           \
+                                                                         \
   bool                                                                    \
   is_##varname__(const char* symbol) const                                \
   {                                                                       \
     return (!this->varname__##_.value.empty()                             \
             && (this->varname__##_.value.find(std::string(symbol))        \
                 != this->varname__##_.value.end()));                      \
-  }
+  }                                                                      \
+                                                                         \
+  options::String_set::const_iterator                                    \
+  varname__##_begin() const                                              \
+  { return this->varname__##_.value.begin(); }                           \
+                                                                         \
+  options::String_set::const_iterator                                    \
+  varname__##_end() const                                                \
+  { return this->varname__##_.value.end(); }
 
 // When you have a list of possible values (expressed as string)
 // After helparg__ should come an initializer list, like
@@ -652,6 +661,10 @@ class General_options
   DEFINE_bool(noinhibit_exec, options::TWO_DASHES, '\0', false,
              N_("Create an output file even if errors occur"), NULL);
 
+  DEFINE_bool_alias(no_undefined, defs, options::TWO_DASHES, '\0',
+                   N_("Report undefined symbols (even with --shared)"),
+                   NULL, false);
+
   DEFINE_string(output, options::TWO_DASHES, 'o', "a.out",
                 N_("Set output file name"), N_("FILE"));
 
@@ -733,10 +746,8 @@ class General_options
   DEFINE_uint64(Ttext, options::ONE_DASH, '\0', -1U,
                 N_("Set the address of the text segment"), N_("ADDRESS"));
 
-  DEFINE_bool_alias(undefined, defs, options::TWO_DASHES, '\0',
-                   "Allow undefined symbols with --shared",
-                   "Report undefined symbols (even with --shared)",
-                   true);
+  DEFINE_set(undefined, options::TWO_DASHES, 'u',
+            N_("Create undefined reference to SYMBOL"), N_("SYMBOL"));
 
   DEFINE_bool(verbose, options::TWO_DASHES, '\0', false,
               N_("Synonym for --debug=files"), NULL);

diff --git a/gold/resolve.cc b/gold/resolve.cc
index 21a7fc634f29927161694fccd9fe37fbe3890289..291bca6967337a637fdd858e76019e87caa3afb0 100644 (file)
--- a/gold/resolve.cc
+++ b/gold/resolve.cc
@@ -281,7 +281,10 @@ Symbol_table::should_override(const Symbol* to, unsigned int frombits,
   *adjust_common_sizes = false;
 
   unsigned int tobits;
-  if (to->source() != Symbol::FROM_OBJECT)
+  if (to->source() == Symbol::IS_UNDEFINED)
+    tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_UNDEF, true,
+                           to->type());
+  else if (to->source() != Symbol::FROM_OBJECT)
     tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_ABS, false,
                            to->type());
   else
@@ -662,7 +665,8 @@ Symbol::override_base_with_special(const Symbol* from)
     case IN_OUTPUT_SEGMENT:
       this->u_.in_output_segment = from->u_.in_output_segment;
       break;
-    case CONSTANT:
+    case IS_CONSTANT:
+    case IS_UNDEFINED:
       break;
     default:
       gold_unreachable();

diff --git a/gold/symtab.cc b/gold/symtab.cc
index 522ca620b4bc982644bebbd4e3578d1d34e0c2f5..4d463e2156c9b8a8a39a5fe8bd5023ed54fa29da 100644 (file)
--- a/gold/symtab.cc
+++ b/gold/symtab.cc
@@ -105,9 +105,9 @@ Symbol::demangled_name() const
 
 template<int size, bool big_endian>
 void
-Symbol::init_base(const char* name, const char* version, Object* object,
-                 const elfcpp::Sym<size, big_endian>& sym,
-                 unsigned int st_shndx, bool is_ordinary)
+Symbol::init_base_object(const char* name, const char* version, Object* object,
+                        const elfcpp::Sym<size, big_endian>& sym,
+                        unsigned int st_shndx, bool is_ordinary)
 {
   this->init_fields(name, version, sym.get_st_type(), sym.get_st_bind(),
                    sym.get_st_visibility(), sym.get_st_nonvis());
@@ -123,9 +123,10 @@ Symbol::init_base(const char* name, const char* version, Object* object,
 // in an Output_data.
 
 void
-Symbol::init_base(const char* name, Output_data* od, elfcpp::STT type,
-                 elfcpp::STB binding, elfcpp::STV visibility,
-                 unsigned char nonvis, bool offset_is_from_end)
+Symbol::init_base_output_data(const char* name, Output_data* od,
+                             elfcpp::STT type, elfcpp::STB binding,
+                             elfcpp::STV visibility, unsigned char nonvis,
+                             bool offset_is_from_end)
 {
   this->init_fields(name, NULL, type, binding, visibility, nonvis);
   this->u_.in_output_data.output_data = od;
@@ -138,9 +139,10 @@ Symbol::init_base(const char* name, Output_data* od, elfcpp::STT type,
 // in an Output_segment.
 
 void
-Symbol::init_base(const char* name, Output_segment* os, elfcpp::STT type,
-                 elfcpp::STB binding, elfcpp::STV visibility,
-                 unsigned char nonvis, Segment_offset_base offset_base)
+Symbol::init_base_output_segment(const char* name, Output_segment* os,
+                                elfcpp::STT type, elfcpp::STB binding,
+                                elfcpp::STV visibility, unsigned char nonvis,
+                                Segment_offset_base offset_base)
 {
   this->init_fields(name, NULL, type, binding, visibility, nonvis);
   this->u_.in_output_segment.output_segment = os;
@@ -153,12 +155,25 @@ Symbol::init_base(const char* name, Output_segment* os, elfcpp::STT type,
 // as a constant.
 
 void
-Symbol::init_base(const char* name, elfcpp::STT type,
-                 elfcpp::STB binding, elfcpp::STV visibility,
-                 unsigned char nonvis)
+Symbol::init_base_constant(const char* name, elfcpp::STT type,
+                          elfcpp::STB binding, elfcpp::STV visibility,
+                          unsigned char nonvis)
+{
+  this->init_fields(name, NULL, type, binding, visibility, nonvis);
+  this->source_ = IS_CONSTANT;
+  this->in_reg_ = true;
+}
+
+// Initialize the fields in the base class Symbol for an undefined
+// symbol.
+
+void
+Symbol::init_base_undefined(const char* name, elfcpp::STT type,
+                           elfcpp::STB binding, elfcpp::STV visibility,
+                           unsigned char nonvis)
 {
   this->init_fields(name, NULL, type, binding, visibility, nonvis);
-  this->source_ = CONSTANT;
+  this->source_ = IS_UNDEFINED;
   this->in_reg_ = true;
 }
 
@@ -178,11 +193,12 @@ Symbol::allocate_base_common(Output_data* od)
 template<int size>
 template<bool big_endian>
 void
-Sized_symbol<size>::init(const char* name, const char* version, Object* object,
-                        const elfcpp::Sym<size, big_endian>& sym,
-                        unsigned int st_shndx, bool is_ordinary)
+Sized_symbol<size>::init_object(const char* name, const char* version,
+                               Object* object,
+                               const elfcpp::Sym<size, big_endian>& sym,
+                               unsigned int st_shndx, bool is_ordinary)
 {
-  this->init_base(name, version, object, sym, st_shndx, is_ordinary);
+  this->init_base_object(name, version, object, sym, st_shndx, is_ordinary);
   this->value_ = sym.get_st_value();
   this->symsize_ = sym.get_st_size();
 }
@@ -192,14 +208,15 @@ Sized_symbol<size>::init(const char* name, const char* version, Object* object,
 
 template<int size>
 void
-Sized_symbol<size>::init(const char* name, Output_data* od,
-                        Value_type value, Size_type symsize,
-                        elfcpp::STT type, elfcpp::STB binding,
-                        elfcpp::STV visibility, unsigned char nonvis,
-                        bool offset_is_from_end)
-{
-  this->init_base(name, od, type, binding, visibility, nonvis,
-                 offset_is_from_end);
+Sized_symbol<size>::init_output_data(const char* name, Output_data* od,
+                                    Value_type value, Size_type symsize,
+                                    elfcpp::STT type, elfcpp::STB binding,
+                                    elfcpp::STV visibility,
+                                    unsigned char nonvis,
+                                    bool offset_is_from_end)
+{
+  this->init_base_output_data(name, od, type, binding, visibility, nonvis,
+                             offset_is_from_end);
   this->value_ = value;
   this->symsize_ = symsize;
 }
@@ -209,13 +226,15 @@ Sized_symbol<size>::init(const char* name, Output_data* od,
 
 template<int size>
 void
-Sized_symbol<size>::init(const char* name, Output_segment* os,
-                        Value_type value, Size_type symsize,
-                        elfcpp::STT type, elfcpp::STB binding,
-                        elfcpp::STV visibility, unsigned char nonvis,
-                        Segment_offset_base offset_base)
+Sized_symbol<size>::init_output_segment(const char* name, Output_segment* os,
+                                       Value_type value, Size_type symsize,
+                                       elfcpp::STT type, elfcpp::STB binding,
+                                       elfcpp::STV visibility,
+                                       unsigned char nonvis,
+                                       Segment_offset_base offset_base)
 {
-  this->init_base(name, os, type, binding, visibility, nonvis, offset_base);
+  this->init_base_output_segment(name, os, type, binding, visibility, nonvis,
+                                offset_base);
   this->value_ = value;
   this->symsize_ = symsize;
 }
@@ -225,15 +244,29 @@ Sized_symbol<size>::init(const char* name, Output_segment* os,
 
 template<int size>
 void
-Sized_symbol<size>::init(const char* name, Value_type value, Size_type symsize,
-                        elfcpp::STT type, elfcpp::STB binding,
-                        elfcpp::STV visibility, unsigned char nonvis)
+Sized_symbol<size>::init_constant(const char* name, Value_type value,
+                                 Size_type symsize, elfcpp::STT type,
+                                 elfcpp::STB binding, elfcpp::STV visibility,
+                                 unsigned char nonvis)
 {
-  this->init_base(name, type, binding, visibility, nonvis);
+  this->init_base_constant(name, type, binding, visibility, nonvis);
   this->value_ = value;
   this->symsize_ = symsize;
 }
 
+// Initialize the fields in Sized_symbol for an undefined symbol.
+
+template<int size>
+void
+Sized_symbol<size>::init_undefined(const char* name, elfcpp::STT type,
+                                  elfcpp::STB binding, elfcpp::STV visibility,
+                                  unsigned char nonvis)
+{
+  this->init_base_undefined(name, type, binding, visibility, nonvis);
+  this->value_ = 0;
+  this->symsize_ = 0;
+}
+
 // Allocate a common symbol.
 
 template<int size>
@@ -280,20 +313,25 @@ Symbol::final_value_is_known() const
   if (parameters->options().shared() || parameters->options().relocatable())
     return false;
 
-  // If the symbol is not from an object file, then it is defined, and
-  // known.
+  // If the symbol is not from an object file, and is not undefined,
+  // then it is defined, and known.
   if (this->source_ != FROM_OBJECT)
-    return true;
-
-  // If the symbol is from a dynamic object, then the final value is
-  // not known.
-  if (this->object()->is_dynamic())
-    return false;
+    {
+      if (this->source_ != IS_UNDEFINED)
+       return true;
+    }
+  else
+    {
+      // If the symbol is from a dynamic object, then the final value
+      // is not known.
+      if (this->object()->is_dynamic())
+       return false;
 
-  // If the symbol is not undefined (it is defined or common), then
-  // the final value is known.
-  if (!this->is_undefined())
-    return true;
+      // If the symbol is not undefined (it is defined or common),
+      // then the final value is known.
+      if (!this->is_undefined())
+       return true;
+    }
 
   // If the symbol is undefined, then whether the final value is known
   // depends on whether we are doing a static link.  If we are doing a
@@ -326,7 +364,8 @@ Symbol::output_section() const
       return this->u_.in_output_data.output_data->output_section();
 
     case IN_OUTPUT_SEGMENT:
-    case CONSTANT:
+    case IS_CONSTANT:
+    case IS_UNDEFINED:
       return NULL;
 
     default:
@@ -347,12 +386,13 @@ Symbol::set_output_section(Output_section* os)
     case IN_OUTPUT_DATA:
       gold_assert(this->output_section() == os);
       break;
-    case CONSTANT:
+    case IS_CONSTANT:
       this->source_ = IN_OUTPUT_DATA;
       this->u_.in_output_data.output_data = os;
       this->u_.in_output_data.offset_is_from_end = false;
       break;
     case IN_OUTPUT_SEGMENT:
+    case IS_UNDEFINED:
     default:
       gold_unreachable();
     }
@@ -714,7 +754,7 @@ Symbol_table::add_from_object(Object* object,
                }
            }
 
-         ret->init(name, version, object, sym, st_shndx, is_ordinary);
+         ret->init_object(name, version, object, sym, st_shndx, is_ordinary);
 
          ins.first->second = ret;
          if (def)
@@ -1332,8 +1372,8 @@ Symbol_table::do_define_in_output_data(
     return NULL;
 
   gold_assert(version == NULL || oldsym != NULL);
-  sym->init(name, od, value, symsize, type, binding, visibility, nonvis,
-           offset_is_from_end);
+  sym->init_output_data(name, od, value, symsize, type, binding, visibility,
+                       nonvis, offset_is_from_end);
 
   if (oldsym == NULL)
     {
@@ -1432,8 +1472,8 @@ Symbol_table::do_define_in_output_segment(
     return NULL;
 
   gold_assert(version == NULL || oldsym != NULL);
-  sym->init(name, os, value, symsize, type, binding, visibility, nonvis,
-           offset_base);
+  sym->init_output_segment(name, os, value, symsize, type, binding,
+                          visibility, nonvis, offset_base);
 
   if (oldsym == NULL)
     {
@@ -1532,7 +1572,7 @@ Symbol_table::do_define_as_constant(
     return NULL;
 
   gold_assert(version == NULL || version == name || oldsym != NULL);
-  sym->init(name, value, symsize, type, binding, visibility, nonvis);
+  sym->init_constant(name, value, symsize, type, binding, visibility, nonvis);
 
   if (oldsym == NULL)
     {
@@ -1668,6 +1708,79 @@ Symbol_table::get_copy_source(const Symbol* sym) const
   return p->second;
 }
 
+// Add any undefined symbols named on the command line.
+
+void
+Symbol_table::add_undefined_symbols_from_command_line()
+{
+  if (parameters->options().any_undefined())
+    {
+      if (parameters->target().get_size() == 32)
+       {
+#if defined(HAVE_TARGET_32_LITTL) || defined(HAVE_TARGET_32_BIG)
+         this->do_add_undefined_symbols_from_command_line<32>();
+#else
+         gold_unreachable();
+#endif
+       }
+      else if (parameters->target().get_size() == 64)
+       {
+#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
+         this->do_add_undefined_symbols_from_command_line<64>();
+#else
+         gold_unreachable();
+#endif
+       }
+      else
+       gold_unreachable();
+    }
+}
+
+template<int size>
+void
+Symbol_table::do_add_undefined_symbols_from_command_line()
+{
+  for (options::String_set::const_iterator p =
+        parameters->options().undefined_begin();
+       p != parameters->options().undefined_end();
+       ++p)
+    {
+      const char* name = p->c_str();
+
+      if (this->lookup(name) != NULL)
+       continue;
+
+      const char* version = NULL;
+
+      Sized_symbol<size>* sym;
+      Sized_symbol<size>* oldsym;
+      if (parameters->target().is_big_endian())
+       {
+#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
+         sym = this->define_special_symbol<size, true>(&name, &version,
+                                                       false, &oldsym);
+#else
+         gold_unreachable();
+#endif
+       }
+      else
+       {
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
+         sym = this->define_special_symbol<size, false>(&name, &version,
+                                                        false, &oldsym);
+#else
+         gold_unreachable();
+#endif
+       }
+
+      gold_assert(oldsym == NULL);
+
+      sym->init_undefined(name, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
+                         elfcpp::STV_DEFAULT, 0);
+      ++this->saw_undefined_;
+    }
+}
+
 // Set the dynamic symbol indexes.  INDEX is the index of the first
 // global dynamic symbol.  Pointers to the symbols are stored into the
 // vector SYMS.  The names are added to DYNPOOL.  This returns an
@@ -1927,10 +2040,14 @@ Symbol_table::sized_finalize_symbol(Symbol* unsized_sym)
       }
       break;
 
-    case Symbol::CONSTANT:
+    case Symbol::IS_CONSTANT:
       value = sym->value();
       break;
 
+    case Symbol::IS_UNDEFINED:
+      value = 0;
+      break;
+
     default:
       gold_unreachable();
     }
@@ -2123,10 +2240,14 @@ Symbol_table::sized_write_globals(const Input_objects* input_objects,
          shndx = elfcpp::SHN_ABS;
          break;
 
-       case Symbol::CONSTANT:
+       case Symbol::IS_CONSTANT:
          shndx = elfcpp::SHN_ABS;
          break;
 
+       case Symbol::IS_UNDEFINED:
+         shndx = elfcpp::SHN_UNDEF;
+         break;
+
        default:
          gold_unreachable();
        }

diff --git a/gold/symtab.h b/gold/symtab.h
index 020f242c502aa76c4c6e8d32d9a5bd023ed912eb..b58909be9c4e65c8984fa5edbc681ce4ba23b6b1 100644 (file)
--- a/gold/symtab.h
+++ b/gold/symtab.h
@@ -78,7 +78,9 @@ class Symbol
     // section.
     IN_OUTPUT_SEGMENT,
     // Symbol value is constant.
-    CONSTANT
+    IS_CONSTANT,
+    // Symbol is undefined.
+    IS_UNDEFINED
   };
 
   // When the source is IN_OUTPUT_SEGMENT, we need to describe what
@@ -390,7 +392,7 @@ class Symbol
   {
     bool is_ordinary;
     if (this->source_ != FROM_OBJECT)
-      return true;
+      return this->source_ != IS_UNDEFINED;
     unsigned int shndx = this->shndx(&is_ordinary);
     return (is_ordinary
            ? shndx != elfcpp::SHN_UNDEF
@@ -409,30 +411,26 @@ class Symbol
   is_undefined() const
   {
     bool is_ordinary;
-    return (this->source_ == FROM_OBJECT
-           && this->shndx(&is_ordinary) == elfcpp::SHN_UNDEF
-           && is_ordinary);
+    return ((this->source_ == FROM_OBJECT
+            && this->shndx(&is_ordinary) == elfcpp::SHN_UNDEF
+            && is_ordinary)
+           || this->source_ == IS_UNDEFINED);
   }
 
   // Return whether this is a weak undefined symbol.
   bool
   is_weak_undefined() const
-  {
-    bool is_ordinary;
-    return (this->source_ == FROM_OBJECT
-            && this->binding() == elfcpp::STB_WEAK
-            && this->shndx(&is_ordinary) == elfcpp::SHN_UNDEF
-           && is_ordinary);
-  }
+  { return this->is_undefined() && this->binding() == elfcpp::STB_WEAK; }
 
   // Return whether this is an absolute symbol.
   bool
   is_absolute() const
   {
     bool is_ordinary;
-    return (this->source_ == FROM_OBJECT
-           && this->shndx(&is_ordinary) == elfcpp::SHN_ABS
-           && !is_ordinary);
+    return ((this->source_ == FROM_OBJECT
+            && this->shndx(&is_ordinary) == elfcpp::SHN_ABS
+            && !is_ordinary)
+           || this->source_ == IS_CONSTANT);
   }
 
   // Return whether this is a common symbol.
@@ -664,25 +662,32 @@ class Symbol
   // index rather than a special code.
   template<int size, bool big_endian>
   void
-  init_base(const char *name, const char* version, Object* object,
-           const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
-           bool is_ordinary);
+  init_base_object(const char *name, const char* version, Object* object,
+                  const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
+                  bool is_ordinary);
 
   // Initialize fields for an Output_data.
   void
-  init_base(const char* name, Output_data*, elfcpp::STT, elfcpp::STB,
-           elfcpp::STV, unsigned char nonvis, bool offset_is_from_end);
+  init_base_output_data(const char* name, Output_data*, elfcpp::STT,
+                       elfcpp::STB, elfcpp::STV, unsigned char nonvis,
+                       bool offset_is_from_end);
 
   // Initialize fields for an Output_segment.
   void
-  init_base(const char* name, Output_segment* os, elfcpp::STT type,
-           elfcpp::STB binding, elfcpp::STV visibility,
-           unsigned char nonvis, Segment_offset_base offset_base);
+  init_base_output_segment(const char* name, Output_segment* os,
+                          elfcpp::STT type, elfcpp::STB binding,
+                          elfcpp::STV visibility, unsigned char nonvis,
+                          Segment_offset_base offset_base);
 
   // Initialize fields for a constant.
   void
-  init_base(const char* name, elfcpp::STT type, elfcpp::STB binding,
-           elfcpp::STV visibility, unsigned char nonvis);
+  init_base_constant(const char* name, elfcpp::STT type, elfcpp::STB binding,
+                    elfcpp::STV visibility, unsigned char nonvis);
+
+  // Initialize fields for an undefined symbol.
+  void
+  init_base_undefined(const char* name, elfcpp::STT type, elfcpp::STB binding,
+                     elfcpp::STV visibility, unsigned char nonvis);
 
   // Override existing symbol.
   template<int size, bool big_endian>
@@ -838,26 +843,31 @@ class Sized_symbol : public Symbol
   // index rather than a special code.
   template<bool big_endian>
   void
-  init(const char *name, const char* version, Object* object,
-       const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
-       bool is_ordinary);
+  init_object(const char *name, const char* version, Object* object,
+             const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
+             bool is_ordinary);
 
   // Initialize fields for an Output_data.
   void
-  init(const char* name, Output_data*, Value_type value, Size_type symsize,
-       elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis,
-       bool offset_is_from_end);
+  init_output_data(const char* name, Output_data*, Value_type value,
+                  Size_type symsize, elfcpp::STT, elfcpp::STB, elfcpp::STV,
+                  unsigned char nonvis, bool offset_is_from_end);
 
   // Initialize fields for an Output_segment.
   void
-  init(const char* name, Output_segment*, Value_type value, Size_type symsize,
-       elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis,
-       Segment_offset_base offset_base);
+  init_output_segment(const char* name, Output_segment*, Value_type value,
+                     Size_type symsize, elfcpp::STT, elfcpp::STB, elfcpp::STV,
+                     unsigned char nonvis, Segment_offset_base offset_base);
 
   // Initialize fields for a constant.
   void
-  init(const char* name, Value_type value, Size_type symsize,
-       elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis);
+  init_constant(const char* name, Value_type value, Size_type symsize,
+               elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis);
+
+  // Initialize fields for an undefined symbol.
+  void
+  init_undefined(const char* name, elfcpp::STT, elfcpp::STB, elfcpp::STV,
+                unsigned char nonvis);
 
   // Override existing symbol.
   template<bool big_endian>
@@ -1184,6 +1194,11 @@ class Symbol_table
   void
   detect_odr_violations(const Task*, const char* output_file_name) const;
 
+  // Add any undefined symbols named on the command line to the symbol
+  // table.
+  void
+  add_undefined_symbols_from_command_line();
+
   // SYM is defined using a COPY reloc.  Return the dynamic object
   // where the original definition was found.
   Dynobj*
@@ -1340,6 +1355,12 @@ class Symbol_table
     elfcpp::STV visibility, unsigned char nonvis,
     bool only_if_ref, bool force_override);
 
+  // Add any undefined symbols named on the command line to the symbol
+  // table, sized version.
+  template<int size>
+  void
+  do_add_undefined_symbols_from_command_line();
+
   // Allocate the common symbols, sized version.
   template<int size>
   void