Track sections for expressions.

7 files changed, 506 insertions, 309 deletions

diff --git a/gold/expression.cc b/gold/expression.cc
index d57b45c..d753601 100644
--- a/gold/expression.cc
+++ b/gold/expression.cc
@@ -57,13 +57,13 @@ struct Expression::Expression_eval_info
   // Whether expressions can refer to the dot symbol.  The dot symbol
   // is only available within a SECTIONS clause.
   bool is_dot_available;
-  // Whether the dot symbol currently has a value.
-  bool dot_has_value;
   // The current value of the dot symbol.
   uint64_t dot_value;
-  // Points to the IS_ABSOLUTE variable, which is set to false if the
-  // expression uses a value which is not absolute.
-  bool* is_absolute;
+  // The section in which the dot symbol is defined; this is NULL if
+  // it is absolute.
+  Output_section* dot_section;
+  // Points to where the section of the result should be stored.
+  Output_section** result_section_pointer;
 };
 
 // Evaluate an expression.
@@ -71,19 +71,19 @@ struct Expression::Expression_eval_info
 uint64_t
 Expression::eval(const Symbol_table* symtab, const Layout* layout)
 {
-  bool dummy;
-  return this->eval_maybe_dot(symtab, layout, false, false, 0, &dummy);
+  Output_section* dummy;
+  return this->eval_maybe_dot(symtab, layout, false, 0, NULL, &dummy);
 }
 
 // Evaluate an expression which may refer to the dot symbol.
 
 uint64_t
 Expression::eval_with_dot(const Symbol_table* symtab, const Layout* layout,
-			  bool dot_has_value, uint64_t dot_value,
-			  bool* is_absolute)
+			  uint64_t dot_value, Output_section* dot_section,
+			  Output_section** result_section_pointer)
 {
-  return this->eval_maybe_dot(symtab, layout, true, dot_has_value, dot_value,
-			      is_absolute);
+  return this->eval_maybe_dot(symtab, layout, true, dot_value, dot_section,
+			      result_section_pointer);
 }
 
 // Evaluate an expression which may or may not refer to the dot
@@ -91,20 +91,21 @@ Expression::eval_with_dot(const Symbol_table* symtab, const Layout* layout,
 
 uint64_t
 Expression::eval_maybe_dot(const Symbol_table* symtab, const Layout* layout,
-			   bool is_dot_available, bool dot_has_value,
-			   uint64_t dot_value, bool* is_absolute)
+			   bool is_dot_available, uint64_t dot_value,
+			   Output_section* dot_section,
+			   Output_section** result_section_pointer)
 {
   Expression_eval_info eei;
   eei.symtab = symtab;
   eei.layout = layout;
   eei.is_dot_available = is_dot_available;
-  eei.dot_has_value = dot_has_value;
   eei.dot_value = dot_value;
+  eei.dot_section = dot_section;
 
-  // We assume the value is absolute, and only set this to false if we
-  // find a section relative reference.
-  *is_absolute = true;
-  eei.is_absolute = is_absolute;
+  // We assume the value is absolute, and only set this to a section
+  // if we find a section relative reference.
+  *result_section_pointer = NULL;
+  eei.result_section_pointer = result_section_pointer;
 
   return this->value(&eei);
 }
@@ -167,13 +168,7 @@ Symbol_expression::value(const Expression_eval_info* eei)
       return 0;
     }
 
-  // If this symbol does not have an absolute value, then the whole
-  // expression does not have an absolute value.  This is not strictly
-  // accurate: the subtraction of two symbols in the same section is
-  // absolute.  This is unlikely to matter in practice, as this value
-  // is only used for error checking.
-  if (!sym->value_is_absolute())
-    *eei->is_absolute = false;
+  *eei->result_section_pointer = sym->output_section();
 
   if (parameters->get_size() == 32)
     return eei->symtab->get_sized_symbol<32>(sym)->value();
@@ -209,12 +204,7 @@ Dot_expression::value(const Expression_eval_info* eei)
 		   "SECTIONS clause"));
       return 0;
     }
-  else if (!eei->dot_has_value)
-    {
-      gold_error(_("invalid reference to dot symbol before "
-		   "it has been given a value"));
-      return 0;
-    }
+  *eei->result_section_pointer = eei->dot_section;
   return eei->dot_value;
 }
 
@@ -243,8 +233,15 @@ class Unary_expression : public Expression
 
  protected:
   uint64_t
-  arg_value(const Expression_eval_info* eei) const
-  { return this->arg_->value(eei); }
+  arg_value(const Expression_eval_info* eei,
+	    Output_section** arg_section_pointer) const
+  {
+    return this->arg_->eval_maybe_dot(eei->symtab, eei->layout,
+				      eei->is_dot_available,
+				      eei->dot_value,
+				      eei->dot_section,
+				      arg_section_pointer);
+  }
 
   void
   arg_print(FILE* f) const
@@ -257,31 +254,38 @@ class Unary_expression : public Expression
 // Handle unary operators.  We use a preprocessor macro as a hack to
 // capture the C operator.
 
-#define UNARY_EXPRESSION(NAME, OPERATOR)			\
-  class Unary_ ## NAME : public Unary_expression		\
-  {								\
-   public:							\
-    Unary_ ## NAME(Expression* arg)				\
-      : Unary_expression(arg)					\
-    { }								\
-    								\
-    uint64_t							\
-    value(const Expression_eval_info* eei)			\
-    { return OPERATOR this->arg_value(eei); }			\
-								\
-    void							\
-    print(FILE* f) const					\
-    {								\
-      fprintf(f, "(%s ", #OPERATOR);				\
-      this->arg_print(f);					\
-      fprintf(f, ")");						\
-    }								\
-  };								\
-  								\
-  extern "C" Expression*					\
-  script_exp_unary_ ## NAME(Expression* arg)			\
-  {								\
-    return new Unary_ ## NAME(arg);				\
+#define UNARY_EXPRESSION(NAME, OPERATOR)				\
+  class Unary_ ## NAME : public Unary_expression			\
+  {									\
+  public:								\
+    Unary_ ## NAME(Expression* arg)					\
+      : Unary_expression(arg)						\
+    { }									\
+    									\
+    uint64_t								\
+    value(const Expression_eval_info* eei)				\
+    {									\
+      Output_section* arg_section;					\
+      uint64_t ret = OPERATOR this->arg_value(eei, &arg_section);	\
+      if (arg_section != NULL && parameters->output_is_object())	\
+	gold_warning(_("unary " #NAME " applied to section "		\
+		       "relative value"));				\
+      return ret;							\
+    }									\
+									\
+    void								\
+    print(FILE* f) const						\
+    {									\
+      fprintf(f, "(%s ", #OPERATOR);					\
+      this->arg_print(f);						\
+      fprintf(f, ")");							\
+    }									\
+  };									\
+									\
+  extern "C" Expression*						\
+  script_exp_unary_ ## NAME(Expression* arg)				\
+  {									\
+      return new Unary_ ## NAME(arg);					\
   }
 
 UNARY_EXPRESSION(minus, -)
@@ -305,12 +309,26 @@ class Binary_expression : public Expression
 
  protected:
   uint64_t
-  left_value(const Expression_eval_info* eei) const
-  { return this->left_->value(eei); }
+  left_value(const Expression_eval_info* eei,
+	     Output_section** section_pointer) const
+  {
+    return this->left_->eval_maybe_dot(eei->symtab, eei->layout,
+				       eei->is_dot_available,
+				       eei->dot_value,
+				       eei->dot_section,
+				       section_pointer);
+  }
 
   uint64_t
-  right_value(const Expression_eval_info* eei) const
-  { return this->right_->value(eei); }
+  right_value(const Expression_eval_info* eei,
+	      Output_section** section_pointer) const
+  {
+    return this->right_->eval_maybe_dot(eei->symtab, eei->layout,
+					eei->is_dot_available,
+					eei->dot_value,
+					eei->dot_section,
+					section_pointer);
+  }
 
   void
   left_print(FILE* f) const
@@ -338,9 +356,15 @@ class Binary_expression : public Expression
 };
 
 // Handle binary operators.  We use a preprocessor macro as a hack to
-// capture the C operator.
-
-#define BINARY_EXPRESSION(NAME, OPERATOR)				\
+// capture the C operator.  KEEP_LEFT means that if the left operand
+// is section relative and the right operand is not, the result uses
+// the same section as the left operand.  KEEP_RIGHT is the same with
+// left and right swapped.  IS_DIV means that we need to give an error
+// if the right operand is zero.  WARN means that we should warn if
+// used on section relative values in a relocatable link.  We always
+// warn if used on values in different sections in a relocatable link.
+
+#define BINARY_EXPRESSION(NAME, OPERATOR, KEEP_LEFT, KEEP_RIGHT, IS_DIV, WARN) \
   class Binary_ ## NAME : public Binary_expression			\
   {									\
   public:								\
@@ -351,8 +375,27 @@ class Binary_expression : public Expression
     uint64_t								\
     value(const Expression_eval_info* eei)				\
     {									\
-      return (this->left_value(eei)					\
-	      OPERATOR this->right_value(eei));				\
+      Output_section* left_section;					\
+      uint64_t left = this->left_value(eei, &left_section);		\
+      Output_section* right_section;					\
+      uint64_t right = this->right_value(eei, &right_section);		\
+      if (KEEP_RIGHT && left_section == NULL && right_section != NULL)	\
+	*eei->result_section_pointer = right_section;			\
+      else if (KEEP_LEFT						\
+	       && left_section != NULL					\
+	       && right_section == NULL)				\
+	*eei->result_section_pointer = left_section;			\
+      else if ((WARN || left_section != right_section)			\
+	       && (left_section != NULL || right_section != NULL)	\
+	       && parameters->output_is_object())			\
+	gold_warning(_("binary " #NAME " applied to section "		\
+		       "relative value"));				\
+      if (IS_DIV && right == 0)						\
+	{								\
+	  gold_error(_(#NAME " by zero"));				\
+	  return 0;							\
+	}								\
+      return left OPERATOR right;					\
     }									\
 									\
     void								\
@@ -372,24 +415,24 @@ class Binary_expression : public Expression
     return new Binary_ ## NAME(left, right);				\
   }
 
-BINARY_EXPRESSION(mult, *)
-BINARY_EXPRESSION(div, /)
-BINARY_EXPRESSION(mod, %)
-BINARY_EXPRESSION(add, +)
-BINARY_EXPRESSION(sub, -)
-BINARY_EXPRESSION(lshift, <<)
-BINARY_EXPRESSION(rshift, >>)
-BINARY_EXPRESSION(eq, ==)
-BINARY_EXPRESSION(ne, !=)
-BINARY_EXPRESSION(le, <=)
-BINARY_EXPRESSION(ge, >=)
-BINARY_EXPRESSION(lt, <)
-BINARY_EXPRESSION(gt, >)
-BINARY_EXPRESSION(bitwise_and, &)
-BINARY_EXPRESSION(bitwise_xor, ^)
-BINARY_EXPRESSION(bitwise_or, |)
-BINARY_EXPRESSION(logical_and, &&)
-BINARY_EXPRESSION(logical_or, ||)
+BINARY_EXPRESSION(mult, *, false, false, false, true)
+BINARY_EXPRESSION(div, /, false, false, true, true)
+BINARY_EXPRESSION(mod, %, false, false, true, true)
+BINARY_EXPRESSION(add, +, true, true, false, true)
+BINARY_EXPRESSION(sub, -, true, false, false, false)
+BINARY_EXPRESSION(lshift, <<, false, false, false, true)
+BINARY_EXPRESSION(rshift, >>, false, false, false, true)
+BINARY_EXPRESSION(eq, ==, false, false, false, false)
+BINARY_EXPRESSION(ne, !=, false, false, false, false)
+BINARY_EXPRESSION(le, <=, false, false, false, false)
+BINARY_EXPRESSION(ge, >=, false, false, false, false)
+BINARY_EXPRESSION(lt, <, false, false, false, false)
+BINARY_EXPRESSION(gt, >, false, false, false, false)
+BINARY_EXPRESSION(bitwise_and, &, true, true, false, true)
+BINARY_EXPRESSION(bitwise_xor, ^, true, true, false, true)
+BINARY_EXPRESSION(bitwise_or, |, true, true, false, true)
+BINARY_EXPRESSION(logical_and, &&, false, false, false, true)
+BINARY_EXPRESSION(logical_or, ||, false, false, false, true)
 
 // A trinary expression.
 
@@ -409,16 +452,37 @@ class Trinary_expression : public Expression
 
  protected:
   uint64_t
-  arg1_value(const Expression_eval_info* eei) const
-  { return this->arg1_->value(eei); }
+  arg1_value(const Expression_eval_info* eei,
+	     Output_section** section_pointer) const
+  {
+    return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout,
+				       eei->is_dot_available,
+				       eei->dot_value,
+				       eei->dot_section,
+				       section_pointer);
+  }
 
   uint64_t
-  arg2_value(const Expression_eval_info* eei) const
-  { return this->arg2_->value(eei); }
+  arg2_value(const Expression_eval_info* eei,
+	     Output_section** section_pointer) const
+  {
+    return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout,
+				       eei->is_dot_available,
+				       eei->dot_value,
+				       eei->dot_section,
+				       section_pointer);
+  }
 
   uint64_t
-  arg3_value(const Expression_eval_info* eei) const
-  { return this->arg3_->value(eei); }
+  arg3_value(const Expression_eval_info* eei,
+	     Output_section** section_pointer) const
+  {
+    return this->arg1_->eval_maybe_dot(eei->symtab, eei->layout,
+				       eei->is_dot_available,
+				       eei->dot_value,
+				       eei->dot_section,
+				       section_pointer);
+  }
 
   void
   arg1_print(FILE* f) const
@@ -450,9 +514,11 @@ class Trinary_cond : public Trinary_expression
   uint64_t
   value(const Expression_eval_info* eei)
   {
-    return (this->arg1_value(eei)
-	    ? this->arg2_value(eei)
-	    : this->arg3_value(eei));
+    Output_section* arg1_section;
+    uint64_t arg1 = this->arg1_value(eei, &arg1_section);
+    return (arg1
+	    ? this->arg2_value(eei, eei->result_section_pointer)
+	    : this->arg3_value(eei, eei->result_section_pointer));
   }
 
   void
@@ -485,7 +551,18 @@ class Max_expression : public Binary_expression
 
   uint64_t
   value(const Expression_eval_info* eei)
-  { return std::max(this->left_value(eei), this->right_value(eei)); }
+  {
+    Output_section* left_section;
+    uint64_t left = this->left_value(eei, &left_section);
+    Output_section* right_section;
+    uint64_t right = this->right_value(eei, &right_section);
+    if (left_section == right_section)
+      *eei->result_section_pointer = left_section;
+    else if ((left_section != NULL || right_section != NULL)
+	     && parameters->output_is_object())
+      gold_warning(_("max applied to section relative value"));
+    return std::max(left, right);
+  }
 
   void
   print(FILE* f) const
@@ -509,7 +586,18 @@ class Min_expression : public Binary_expression
 
   uint64_t
   value(const Expression_eval_info* eei)
-  { return std::min(this->left_value(eei), this->right_value(eei)); }
+  {
+    Output_section* left_section;
+    uint64_t left = this->left_value(eei, &left_section);
+    Output_section* right_section;
+    uint64_t right = this->right_value(eei, &right_section);
+    if (left_section == right_section)
+      *eei->result_section_pointer = left_section;
+    else if ((left_section != NULL || right_section != NULL)
+	     && parameters->output_is_object())
+      gold_warning(_("min applied to section relative value"));
+    return std::min(left, right);
+  }
 
   void
   print(FILE* f) const
@@ -534,8 +622,13 @@ class Align_expression : public Binary_expression
   uint64_t
   value(const Expression_eval_info* eei)
   {
-    uint64_t align = this->right_value(eei);
-    uint64_t value = this->left_value(eei);
+    Output_section* align_section;
+    uint64_t align = this->right_value(eei, &align_section);
+    if (align_section != NULL
+	&& parameters->output_is_object())
+      gold_warning(_("aligning to section relative value"));
+
+    uint64_t value = this->left_value(eei, eei->result_section_pointer);
     if (align <= 1)
       return value;
     return ((value + align - 1) / align) * align;
@@ -564,7 +657,7 @@ class Assert_expression : public Unary_expression
   uint64_t
   value(const Expression_eval_info* eei)
   {
-    uint64_t value = this->arg_value(eei);
+    uint64_t value = this->arg_value(eei, eei->result_section_pointer);
     if (!value)
       gold_error("%s", this->message_.c_str());
     return value;
@@ -621,8 +714,7 @@ Addr_expression::value(const Expression_eval_info* eei)
       return 0;
     }
 
-  // Note that the address of a section is an absolute address, and we
-  // should not clear *EEI->IS_ABSOLUTE here.
+  *eei->result_section_pointer = os;
 
   return os->address();
 }
diff --git a/gold/output.h b/gold/output.h
index 5e68e7c..fbfdb25 100644
--- a/gold/output.h
+++ b/gold/output.h
@@ -131,6 +131,11 @@ class Output_data
   is_section_flag_set(elfcpp::Elf_Xword shf) const
   { return this->do_is_section_flag_set(shf); }
 
+  // Return the output section that this goes in, if there is one.
+  Output_section*
+  output_section()
+  { return this->do_output_section(); }
+
   // Return the output section index, if there is an output section.
   unsigned int
   out_shndx() const
@@ -273,6 +278,11 @@ class Output_data
   do_is_section_flag_set(elfcpp::Elf_Xword) const
   { return false; }
 
+  // Return the output section, if there is one.
+  virtual Output_section*
+  do_output_section()
+  { return NULL; }
+
   // Return the output section index, if there is an output section.
   virtual unsigned int
   do_out_shndx() const
@@ -574,6 +584,11 @@ class Output_section_data : public Output_data
   do_addralign() const
   { return this->addralign_; }
 
+  // Return the output section.
+  Output_section*
+  do_output_section()
+  { return this->output_section_; }
+
   // Return the section index of the output section.
   unsigned int
   do_out_shndx() const;
@@ -585,7 +600,7 @@ class Output_section_data : public Output_data
 
  private:
   // The output section for this section.
-  const Output_section* output_section_;
+  Output_section* output_section_;
   // The required alignment.
   uint64_t addralign_;
 };
@@ -1903,6 +1918,11 @@ class Output_section : public Output_data
   print_merge_stats();
 
  protected:
+  // Return the output section--i.e., the object itself.
+  Output_section*
+  do_output_section()
+  { return this; }
+
   // Return the section index in the output file.
   unsigned int
   do_out_shndx() const
diff --git a/gold/script-sections.cc b/gold/script-sections.cc
index 7f51e8b..341599c 100644
--- a/gold/script-sections.cc
+++ b/gold/script-sections.cc
@@ -61,7 +61,7 @@ class Sections_element
 
   // Finalize symbols and check assertions.
   virtual void
-  finalize_symbols(Symbol_table*, const Layout*, bool*, uint64_t*)
+  finalize_symbols(Symbol_table*, const Layout*, uint64_t*)
   { }
 
   // Return the output section name to use for an input file name and
@@ -80,7 +80,7 @@ class Sections_element
   // Set section addresses.  This includes applying assignments if the
   // the expression is an absolute value.
   virtual void
-  set_section_addresses(Symbol_table*, Layout*, bool*, uint64_t*)
+  set_section_addresses(Symbol_table*, Layout*, uint64_t*)
   { }
 
   // Check a constraint (ONLY_IF_RO, etc.) on an output section.  If
@@ -129,10 +129,9 @@ class Sections_element_assignment : public Sections_element
   // Finalize the symbol.
   void
   finalize_symbols(Symbol_table* symtab, const Layout* layout,
-		   bool* dot_has_value, uint64_t* dot_value)
+		   uint64_t* dot_value)
   {
-    this->assignment_.finalize_with_dot(symtab, layout, *dot_has_value,
-					*dot_value);
+    this->assignment_.finalize_with_dot(symtab, layout, *dot_value, NULL);
   }
 
   // Set the section address.  There is no section here, but if the
@@ -140,10 +139,9 @@ class Sections_element_assignment : public Sections_element
   // absolute symbols when setting dot.
   void
   set_section_addresses(Symbol_table* symtab, Layout* layout,
-			bool* dot_has_value, uint64_t* dot_value)
+			uint64_t* dot_value)
   {
-    this->assignment_.set_if_absolute(symtab, layout, true, *dot_has_value,
-				      *dot_value);
+    this->assignment_.set_if_absolute(symtab, layout, true, *dot_value);
   }
 
   // Print for debugging.
@@ -171,25 +169,24 @@ class Sections_element_dot_assignment : public Sections_element
   // Finalize the symbol.
   void
   finalize_symbols(Symbol_table* symtab, const Layout* layout,
-		   bool* dot_has_value, uint64_t* dot_value)
+		   uint64_t* dot_value)
   {
-    bool dummy;
-    *dot_value = this->val_->eval_with_dot(symtab, layout, *dot_has_value,
-					   *dot_value, &dummy);
-    *dot_has_value = true;
+    // We ignore the section of the result because outside of an
+    // output section definition the dot symbol is always considered
+    // to be absolute.
+    Output_section* dummy;
+    *dot_value = this->val_->eval_with_dot(symtab, layout, *dot_value,
+					   NULL, &dummy);
   }
 
   // Update the dot symbol while setting section addresses.
   void
   set_section_addresses(Symbol_table* symtab, Layout* layout,
-			bool* dot_has_value, uint64_t* dot_value)
+			uint64_t* dot_value)
   {
-    bool is_absolute;
-    *dot_value = this->val_->eval_with_dot(symtab, layout, *dot_has_value,
-					   *dot_value, &is_absolute);
-    if (!is_absolute)
-      gold_error(_("dot set to non-absolute value"));
-    *dot_has_value = true;
+    Output_section* dummy;
+    *dot_value = this->val_->eval_with_dot(symtab, layout, *dot_value,
+					   NULL, &dummy);
   }
 
   // Print for debugging.
@@ -217,8 +214,7 @@ class Sections_element_assertion : public Sections_element
 
   // Check the assertion.
   void
-  finalize_symbols(Symbol_table* symtab, const Layout* layout, bool*,
-		   uint64_t*)
+  finalize_symbols(Symbol_table* symtab, const Layout* layout, uint64_t*)
   { this->assertion_.check(symtab, layout); }
 
   // Print for debugging.
@@ -254,7 +250,7 @@ class Output_section_element
 
   // Finalize symbols and check assertions.
   virtual void
-  finalize_symbols(Symbol_table*, const Layout*, bool*, uint64_t*)
+  finalize_symbols(Symbol_table*, const Layout*, uint64_t*, Output_section**)
   { }
 
   // Return whether this element matches FILE_NAME and SECTION_NAME.
@@ -267,7 +263,8 @@ class Output_section_element
   // the expression is an absolute value.
   virtual void
   set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
-			uint64_t*, std::string*, Input_section_list*)
+			uint64_t*, Output_section**, std::string*,
+			Input_section_list*)
   { }
 
   // Print the element for debugging purposes.
@@ -313,10 +310,10 @@ class Output_section_element_assignment : public Output_section_element
   // Finalize the symbol.
   void
   finalize_symbols(Symbol_table* symtab, const Layout* layout,
-		   bool* dot_has_value, uint64_t* dot_value)
+		   uint64_t* dot_value, Output_section** dot_section)
   {
-    this->assignment_.finalize_with_dot(symtab, layout, *dot_has_value,
-					*dot_value);
+    this->assignment_.finalize_with_dot(symtab, layout, *dot_value,
+					*dot_section);
   }
 
   // Set the section address.  There is no section here, but if the
@@ -324,10 +321,10 @@ class Output_section_element_assignment : public Output_section_element
   // absolute symbols when setting dot.
   void
   set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
-			uint64_t, uint64_t* dot_value, std::string*,
-			Input_section_list*)
+			uint64_t, uint64_t* dot_value, Output_section**,
+			std::string*, Input_section_list*)
   {
-    this->assignment_.set_if_absolute(symtab, layout, true, true, *dot_value);
+    this->assignment_.set_if_absolute(symtab, layout, true, *dot_value);
   }
 
   // Print for debugging.
@@ -354,19 +351,17 @@ class Output_section_element_dot_assignment : public Output_section_element
   // Finalize the symbol.
   void
   finalize_symbols(Symbol_table* symtab, const Layout* layout,
-		   bool* dot_has_value, uint64_t* dot_value)
+		   uint64_t* dot_value, Output_section** dot_section)
   {
-    bool dummy;
-    *dot_value = this->val_->eval_with_dot(symtab, layout, *dot_has_value,
-					   *dot_value, &dummy);
-    *dot_has_value = true;
+    *dot_value = this->val_->eval_with_dot(symtab, layout, *dot_value,
+					   *dot_section, dot_section);
   }
 
   // Update the dot symbol while setting section addresses.
   void
   set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
-			uint64_t, uint64_t* dot_value, std::string*,
-			Input_section_list*);
+			uint64_t, uint64_t* dot_value, Output_section**,
+			std::string*, Input_section_list*);
 
   // Print for debugging.
   void
@@ -390,14 +385,12 @@ Output_section_element_dot_assignment::set_section_addresses(
     Output_section* output_section,
     uint64_t,
     uint64_t* dot_value,
+    Output_section** dot_section,
     std::string* fill,
     Input_section_list*)
 {
-  bool is_absolute;
-  uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, true,
-						*dot_value, &is_absolute);
-  if (!is_absolute)
-    gold_error(_("dot set to non-absolute value"));
+  uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, *dot_value,
+						*dot_section, dot_section);
   if (next_dot < *dot_value)
     gold_error(_("dot may not move backward"));
   if (next_dot > *dot_value && output_section != NULL)
@@ -438,94 +431,84 @@ class Output_section_element_assertion : public Output_section_element
   Script_assertion assertion_;
 };
 
-// A data item in an output section.
+// We use a special instance of Output_section_data to handle BYTE,
+// SHORT, etc.  This permits forward references to symbols in the
+// expressions.
 
-class Output_section_element_data : public Output_section_element
+class Output_data_expression : public Output_section_data
 {
  public:
-  Output_section_element_data(int size, bool is_signed, Expression* val)
-    : size_(size), is_signed_(is_signed), val_(val)
+  Output_data_expression(int size, bool is_signed, Expression* val,
+			 const Symbol_table* symtab, const Layout* layout,
+			 uint64_t dot_value, Output_section* dot_section)
+    : Output_section_data(size, 0),
+      is_signed_(is_signed), val_(val), symtab_(symtab),
+      layout_(layout), dot_value_(dot_value), dot_section_(dot_section)
   { }
 
-  // Finalize symbols--we just need to update dot.
-  void
-  finalize_symbols(Symbol_table*, const Layout*, bool*, uint64_t* dot_value)
-  { *dot_value += this->size_; }
-
-  // Store the value in the section.
+ protected:
+  // Write the data to the output file.
   void
-  set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
-			uint64_t* dot_value, std::string*,
-			Input_section_list*);
+  do_write(Output_file*);
 
-  // Print for debugging.
+  // Write the data to a buffer.
   void
-  print(FILE*) const;
+  do_write_to_buffer(unsigned char*);
 
  private:
   template<bool big_endian>
-  std::string
-  set_fill_string(uint64_t);
+  void
+  endian_write_to_buffer(uint64_t, unsigned char*);
 
-  // The size in bytes.
-  int size_;
-  // Whether the value is signed.
   bool is_signed_;
-  // The value.
   Expression* val_;
+  const Symbol_table* symtab_;
+  const Layout* layout_;
+  uint64_t dot_value_;
+  Output_section* dot_section_;
 };
 
-// Store the value in the section.
+// Write the data element to the output file.
 
 void
-Output_section_element_data::set_section_addresses(Symbol_table* symtab,
-						   Layout* layout,
-						   Output_section* os,
-						   uint64_t,
-						   uint64_t* dot_value,
-						   std::string*,
-						   Input_section_list*)
+Output_data_expression::do_write(Output_file* of)
 {
-  gold_assert(os != NULL);
+  unsigned char* view = of->get_output_view(this->offset(), this->data_size());
+  this->write_to_buffer(view);
+  of->write_output_view(this->offset(), this->data_size(), view);
+}
 
-  bool is_absolute;
-  uint64_t val = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
-					   &is_absolute);
-  if (!is_absolute)
-    gold_error(_("data directive with non-absolute value"));
+// Write the data element to a buffer.
+
+void
+Output_data_expression::do_write_to_buffer(unsigned char* buf)
+{
+  Output_section* dummy;
+  uint64_t val = this->val_->eval_with_dot(this->symtab_, this->layout_,
+					   this->dot_value_,
+					   this->dot_section_, &dummy);
 
-  std::string fill;
   if (parameters->is_big_endian())
-    fill = this->set_fill_string<true>(val);
+    this->endian_write_to_buffer<true>(val, buf);
   else
-    fill = this->set_fill_string<false>(val);
-
-  os->add_output_section_data(new Output_data_const(fill, 0));
-
-  *dot_value += this->size_;
+    this->endian_write_to_buffer<false>(val, buf);
 }
 
-// Get the value to store in a std::string.
-
 template<bool big_endian>
-std::string
-    Output_section_element_data::set_fill_string(uint64_t val)
+void
+Output_data_expression::endian_write_to_buffer(uint64_t val,
+					       unsigned char* buf)
 {
-  std::string ret;
-  unsigned char buf[8];
-  switch (this->size_)
+  switch (this->data_size())
     {
     case 1:
       elfcpp::Swap_unaligned<8, big_endian>::writeval(buf, val);
-      ret.assign(reinterpret_cast<char*>(buf), 1);
       break;
     case 2:
       elfcpp::Swap_unaligned<16, big_endian>::writeval(buf, val);
-      ret.assign(reinterpret_cast<char*>(buf), 2);
       break;
     case 4:
       elfcpp::Swap_unaligned<32, big_endian>::writeval(buf, val);
-      ret.assign(reinterpret_cast<char*>(buf), 4);
       break;
     case 8:
       if (parameters->get_size() == 32)
@@ -535,12 +518,68 @@ std::string
 	    val |= 0xffffffff00000000LL;
 	}
       elfcpp::Swap_unaligned<64, big_endian>::writeval(buf, val);
-      ret.assign(reinterpret_cast<char*>(buf), 8);
       break;
     default:
       gold_unreachable();
     }
-  return ret;
+}
+
+// A data item in an output section.
+
+class Output_section_element_data : public Output_section_element
+{
+ public:
+  Output_section_element_data(int size, bool is_signed, Expression* val)
+    : size_(size), is_signed_(is_signed), val_(val)
+  { }
+
+  // Finalize symbols--we just need to update dot.
+  void
+  finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value,
+		   Output_section**)
+  { *dot_value += this->size_; }
+
+  // Store the value in the section.
+  void
+  set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
+			uint64_t* dot_value, Output_section**, std::string*,
+			Input_section_list*);
+
+  // Print for debugging.
+  void
+  print(FILE*) const;
+
+ private:
+  // The size in bytes.
+  int size_;
+  // Whether the value is signed.
+  bool is_signed_;
+  // The value.
+  Expression* val_;
+};
+
+// Store the value in the section.
+
+void
+Output_section_element_data::set_section_addresses(
+    Symbol_table* symtab,
+    Layout* layout,
+    Output_section* os,
+    uint64_t,
+    uint64_t* dot_value,
+    Output_section** dot_section,
+    std::string*,
+    Input_section_list*)
+{
+  gold_assert(os != NULL);
+  os->add_output_section_data(new Output_data_expression(this->size_,
+							 this->is_signed_,
+							 this->val_,
+							 symtab,
+							 layout,
+							 *dot_value,
+							 *dot_section));
+  *dot_value += this->size_;
 }
 
 // Print for debugging.
@@ -586,15 +625,16 @@ class Output_section_element_fill : public Output_section_element
   // Update the fill value while setting section addresses.
   void
   set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
-			uint64_t, uint64_t* dot_value, std::string* fill,
-			Input_section_list*)
+			uint64_t, uint64_t* dot_value,
+			Output_section** dot_section,
+			std::string* fill, Input_section_list*)
   {
-    bool is_absolute;
-    uint64_t fill_val = this->val_->eval_with_dot(symtab, layout, true,
-						  *dot_value,
-						  &is_absolute);
-    if (!is_absolute)
-      gold_error(_("fill set to non-absolute value"));
+    Output_section* fill_section;
+    uint64_t fill_val = this->val_->eval_with_dot(symtab, layout,
+						  *dot_value, *dot_section,
+						  &fill_section);
+    if (fill_section != NULL)
+      gold_warning(_("fill value is not absolute"));
     // FIXME: The GNU linker supports fill values of arbitrary length.
     unsigned char fill_buff[4];
     elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
@@ -633,11 +673,11 @@ class Output_section_element_input : public Output_section_element
 
   // Finalize symbols--just update the value of the dot symbol.
   void
-  finalize_symbols(Symbol_table*, const Layout*, bool* dot_has_value,
-		   uint64_t* dot_value)
+  finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value,
+		   Output_section** dot_section)
   {
     *dot_value = this->final_dot_value_;
-    *dot_has_value = true;
+    *dot_section = this->final_dot_section_;
   }
 
   // See whether we match FILE_NAME and SECTION_NAME as an input
@@ -649,7 +689,8 @@ class Output_section_element_input : public Output_section_element
   void
   set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
 			uint64_t subalign, uint64_t* dot_value,
-			std::string* fill, Input_section_list*);
+			Output_section**, std::string* fill,
+			Input_section_list*);
 
   // Print for debugging.
   void
@@ -707,6 +748,9 @@ class Output_section_element_input : public Output_section_element
   bool keep_;
   // The value of dot after including all matching sections.
   uint64_t final_dot_value_;
+  // The section where dot is defined after including all matching
+  // sections.
+  Output_section* final_dot_section_;
 };
 
 // Construct Output_section_element_input.  The parser records strings
@@ -722,7 +766,8 @@ Output_section_element_input::Output_section_element_input(
     filename_exclusions_(),
     input_section_patterns_(),
     keep_(keep),
-    final_dot_value_(0)
+    final_dot_value_(0),
+    final_dot_section_(NULL)
 {
   // The filename pattern "*" is common, and matches all files.  Turn
   // it into the empty string.
@@ -885,6 +930,7 @@ Output_section_element_input::set_section_addresses(
     Output_section* output_section,
     uint64_t subalign,
     uint64_t* dot_value,
+    Output_section** dot_section,
     std::string* fill,
     Input_section_list* input_sections)
 {
@@ -1001,6 +1047,7 @@ Output_section_element_input::set_section_addresses(
     }
 
   this->final_dot_value_ = *dot_value;
+  this->final_dot_section_ = *dot_section;
 }
 
 // Print for debugging.
@@ -1153,7 +1200,7 @@ class Output_section_definition : public Sections_element
 
   // Finalize symbols and check assertions.
   void
-  finalize_symbols(Symbol_table*, const Layout*, bool*, uint64_t*);
+  finalize_symbols(Symbol_table*, const Layout*, uint64_t*);
 
   // Return the output section name to use for an input file name and
   // section name.
@@ -1168,7 +1215,7 @@ class Output_section_definition : public Sections_element
   // Set the section address.
   void
   set_section_addresses(Symbol_table* symtab, Layout* layout,
-			bool* dot_has_value, uint64_t* dot_value);
+			uint64_t* dot_value);
 
   // Check a constraint (ONLY_IF_RO, etc.) on an output section.  If
   // this section is constrained, and the input sections do not match,
@@ -1333,7 +1380,6 @@ Output_section_definition::add_symbols_to_table(Symbol_table* symtab)
 void
 Output_section_definition::finalize_symbols(Symbol_table* symtab,
 					    const Layout* layout,
-					    bool* dot_has_value,
 					    uint64_t* dot_value)
 {
   if (this->output_section_ != NULL)
@@ -1343,28 +1389,28 @@ Output_section_definition::finalize_symbols(Symbol_table* symtab,
       uint64_t address = *dot_value;
       if (this->address_ != NULL)
 	{
-	  bool dummy;
+	  Output_section* dummy;
 	  address = this->address_->eval_with_dot(symtab, layout,
-						  *dot_has_value, *dot_value,
+						  *dot_value, NULL,
 						  &dummy);
 	}
       if (this->align_ != NULL)
 	{
-	  bool dummy;
+	  Output_section* dummy;
 	  uint64_t align = this->align_->eval_with_dot(symtab, layout,
-						       *dot_has_value,
 						       *dot_value,
+						       NULL,
 						       &dummy);
 	  address = align_address(address, align);
 	}
       *dot_value = address;
     }
-  *dot_has_value = true;
 
+  Output_section* dot_section = this->output_section_;
   for (Output_section_elements::iterator p = this->elements_.begin();
        p != this->elements_.end();
        ++p)
-    (*p)->finalize_symbols(symtab, layout, dot_has_value, dot_value);
+    (*p)->finalize_symbols(symtab, layout, dot_value, &dot_section);
 }
 
 // Return the output section name to use for an input section name.
@@ -1514,25 +1560,16 @@ Output_section_definition::place_orphan_here(const Output_section *os,
 void
 Output_section_definition::set_section_addresses(Symbol_table* symtab,
 						 Layout* layout,
-						 bool* dot_has_value,
 						 uint64_t* dot_value)
 {
-  bool is_absolute;
   uint64_t address;
-  if (this->address_ != NULL)
-    {
-      address = this->address_->eval_with_dot(symtab, layout, *dot_has_value,
-					      *dot_value, &is_absolute);
-      if (!is_absolute)
-	gold_error(_("address of section %s is not absolute"),
-		   this->name_.c_str());
-    }
+  if (this->address_ == NULL)
+    address = *dot_value;
   else
     {
-      if (!*dot_has_value)
-	gold_error(_("no address given for section %s"),
-		   this->name_.c_str());
-      address = *dot_value;
+      Output_section* dummy;
+      address = this->address_->eval_with_dot(symtab, layout, *dot_value,
+					      NULL, &dummy);
     }
 
   uint64_t align;
@@ -1545,11 +1582,12 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab,
     }
   else
     {
-      align = this->align_->eval_with_dot(symtab, layout, *dot_has_value,
-					  *dot_value, &is_absolute);
-      if (!is_absolute)
-	gold_error(_("alignment of section %s is not absolute"),
-		   this->name_.c_str());
+      Output_section* align_section;
+      align = this->align_->eval_with_dot(symtab, layout, *dot_value,
+					  NULL, &align_section);
+      if (align_section != NULL)
+	gold_warning(_("alignment of section %s is not absolute"),
+		     this->name_.c_str());
       if (this->output_section_ != NULL)
 	this->output_section_->set_addralign(align);
     }
@@ -1557,7 +1595,6 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab,
   address = align_address(address, align);
 
   *dot_value = address;
-  *dot_has_value = true;
 
   // The address of non-SHF_ALLOC sections is forced to zero,
   // regardless of what the linker script wants.
@@ -1567,12 +1604,10 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab,
 
   if (this->load_address_ != NULL && this->output_section_ != NULL)
     {
+      Output_section* dummy;
       uint64_t load_address =
-	this->load_address_->eval_with_dot(symtab, layout, *dot_has_value,
-					   *dot_value, &is_absolute);
-      if (!is_absolute)
-	gold_error(_("load address of section %s is not absolute"),
-		   this->name_.c_str());
+	this->load_address_->eval_with_dot(symtab, layout, *dot_value,
+					   this->output_section_, &dummy);
       this->output_section_->set_load_address(load_address);
     }
 
@@ -1581,11 +1616,12 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab,
     subalign = 0;
   else
     {
-      subalign = this->subalign_->eval_with_dot(symtab, layout, *dot_has_value,
-						*dot_value, &is_absolute);
-      if (!is_absolute)
-	gold_error(_("subalign of section %s is not absolute"),
-		   this->name_.c_str());
+      Output_section* subalign_section;
+      subalign = this->subalign_->eval_with_dot(symtab, layout, *dot_value,
+						NULL, &subalign_section);
+      if (subalign_section != NULL)
+	gold_warning(_("subalign of section %s is not absolute"),
+		     this->name_.c_str());
     }
 
   std::string fill;
@@ -1593,13 +1629,14 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab,
     {
       // FIXME: The GNU linker supports fill values of arbitrary
       // length.
+      Output_section* fill_section;
       uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout,
-						     *dot_has_value,
 						     *dot_value,
-						     &is_absolute);
-      if (!is_absolute)
-	gold_error(_("fill of section %s is not absolute"),
-		   this->name_.c_str());
+						     NULL,
+						     &fill_section);
+      if (fill_section != NULL)
+	gold_warning(_("fill of section %s is not absolute"),
+		     this->name_.c_str());
       unsigned char fill_buff[4];
       elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
       fill.assign(reinterpret_cast<char*>(fill_buff), 4);
@@ -1617,11 +1654,13 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab,
       *dot_value = address;
     }
 
+  Output_section* dot_section = this->output_section_;
   for (Output_section_elements::iterator p = this->elements_.begin();
        p != this->elements_.end();
        ++p)
     (*p)->set_section_addresses(symtab, layout, this->output_section_,
-				subalign, dot_value, &fill, &input_sections);
+				subalign, dot_value, &dot_section, &fill,
+				&input_sections);
 
   gold_assert(input_sections.empty());
 }
@@ -1806,7 +1845,7 @@ class Orphan_output_section : public Sections_element
 
   // Set section addresses.
   void
-  set_section_addresses(Symbol_table*, Layout*, bool*, uint64_t*);
+  set_section_addresses(Symbol_table*, Layout*, uint64_t*);
 
   // Get the list of segments to use for an allocated section when
   // using a PHDRS clause.  If this is an allocated section, return
@@ -1845,14 +1884,10 @@ Orphan_output_section::place_orphan_here(const Output_section* os,
 
 void
 Orphan_output_section::set_section_addresses(Symbol_table*, Layout*,
-					     bool* dot_has_value,
 					     uint64_t* dot_value)
 {
   typedef std::list<std::pair<Relobj*, unsigned int> > Input_section_list;
 
-  if (!*dot_has_value)
-    gold_error(_("no address for orphan section %s"), this->os_->name());
-
   uint64_t address = *dot_value;
   address = align_address(address, this->os_->addralign());
 
@@ -2177,12 +2212,11 @@ Script_sections::finalize_symbols(Symbol_table* symtab, const Layout* layout)
 {
   if (!this->saw_sections_clause_)
     return;
-  bool dot_has_value = false;
   uint64_t dot_value = 0;
   for (Sections_elements::iterator p = this->sections_elements_->begin();
        p != this->sections_elements_->end();
        ++p)
-    (*p)->finalize_symbols(symtab, layout, &dot_has_value, &dot_value);
+    (*p)->finalize_symbols(symtab, layout, &dot_value);
 }
 
 // Return the name of the output section to use for an input file name
@@ -2290,12 +2324,12 @@ Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout)
 	}
     }
 
-  bool dot_has_value = false;
+  // For a relocatable link, we implicitly set dot to zero.
   uint64_t dot_value = 0;
   for (Sections_elements::iterator p = this->sections_elements_->begin();
        p != this->sections_elements_->end();
        ++p)
-    (*p)->set_section_addresses(symtab, layout, &dot_has_value, &dot_value);
+    (*p)->set_section_addresses(symtab, layout, &dot_value);
 
   if (this->phdrs_elements_ != NULL)
     {
diff --git a/gold/script.cc b/gold/script.cc
index 68784f6..128acae 100644
--- a/gold/script.cc
+++ b/gold/script.cc
@@ -915,7 +915,7 @@ Symbol_assignment::add_to_table(Symbol_table* symtab)
 void
 Symbol_assignment::finalize(Symbol_table* symtab, const Layout* layout)
 {
-  this->finalize_maybe_dot(symtab, layout, false, false, 0);
+  this->finalize_maybe_dot(symtab, layout, false, 0, NULL);
 }
 
 // Finalize a symbol value which can refer to the dot symbol.
@@ -923,10 +923,10 @@ Symbol_assignment::finalize(Symbol_table* symtab, const Layout* layout)
 void
 Symbol_assignment::finalize_with_dot(Symbol_table* symtab,
 				     const Layout* layout,
-				     bool dot_has_value,
-				     uint64_t dot_value)
+				     uint64_t dot_value,
+				     Output_section* dot_section)
 {
-  this->finalize_maybe_dot(symtab, layout, true, dot_has_value, dot_value);
+  this->finalize_maybe_dot(symtab, layout, true, dot_value, dot_section);
 }
 
 // Finalize a symbol value, internal version.
@@ -935,8 +935,8 @@ void
 Symbol_assignment::finalize_maybe_dot(Symbol_table* symtab,
 				      const Layout* layout,
 				      bool is_dot_available,
-				      bool dot_has_value,
-				      uint64_t dot_value)
+				      uint64_t dot_value,
+				      Output_section* dot_section)
 {
   // If we were only supposed to provide this symbol, the sym_ field
   // will be NULL if the symbol was not referenced.
@@ -949,8 +949,8 @@ Symbol_assignment::finalize_maybe_dot(Symbol_table* symtab,
   if (parameters->get_size() == 32)
     {
 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
-      this->sized_finalize<32>(symtab, layout, is_dot_available, dot_has_value,
-			       dot_value);
+      this->sized_finalize<32>(symtab, layout, is_dot_available, dot_value,
+			       dot_section);
 #else
       gold_unreachable();
 #endif
@@ -958,8 +958,8 @@ Symbol_assignment::finalize_maybe_dot(Symbol_table* symtab,
   else if (parameters->get_size() == 64)
     {
 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
-      this->sized_finalize<64>(symtab, layout, is_dot_available, dot_has_value,
-			       dot_value);
+      this->sized_finalize<64>(symtab, layout, is_dot_available, dot_value,
+			       dot_section);
 #else
       gold_unreachable();
 #endif
@@ -971,33 +971,33 @@ Symbol_assignment::finalize_maybe_dot(Symbol_table* symtab,
 template<int size>
 void
 Symbol_assignment::sized_finalize(Symbol_table* symtab, const Layout* layout,
-				  bool is_dot_available, bool dot_has_value,
-				  uint64_t dot_value)
+				  bool is_dot_available, uint64_t dot_value,
+				  Output_section* dot_section)
 {
-  bool dummy;
+  Output_section* section;
   uint64_t final_val = this->val_->eval_maybe_dot(symtab, layout,
 						  is_dot_available,
-						  dot_has_value, dot_value,
-						  &dummy);
+						  dot_value, dot_section,
+						  &section);
   Sized_symbol<size>* ssym = symtab->get_sized_symbol<size>(this->sym_);
   ssym->set_value(final_val);
+  if (section != NULL)
+    ssym->set_output_section(section);
 }
 
 // Set the symbol value if the expression yields an absolute value.
 
 void
 Symbol_assignment::set_if_absolute(Symbol_table* symtab, const Layout* layout,
-				   bool is_dot_available, bool dot_has_value,
-				   uint64_t dot_value)
+				   bool is_dot_available, uint64_t dot_value)
 {
   if (this->sym_ == NULL)
     return;
 
-  bool is_absolute;
+  Output_section* val_section;
   uint64_t val = this->val_->eval_maybe_dot(symtab, layout, is_dot_available,
-					    dot_has_value, dot_value,
-					    &is_absolute);
-  if (!is_absolute)
+					    dot_value, NULL, &val_section);
+  if (val_section != NULL)
     return;
 
   if (parameters->get_size() == 32)
@@ -1158,7 +1158,7 @@ Script_options::set_section_addresses(Symbol_table* symtab, Layout* layout)
   for (Symbol_assignments::iterator p = this->symbol_assignments_.begin();
        p != this->symbol_assignments_.end();
        ++p)
-    (*p)->set_if_absolute(symtab, layout, false, false, 0);
+    (*p)->set_if_absolute(symtab, layout, false, 0);
 
   return this->script_sections_.set_section_addresses(symtab, layout);
 }
diff --git a/gold/script.h b/gold/script.h
index 81e7ab8..64d7fd6 100644
--- a/gold/script.h
+++ b/gold/script.h
@@ -72,20 +72,26 @@ class Expression
   eval(const Symbol_table*, const Layout*);
 
   // Return the value of an expression which is permitted to refer to
-  // the dot symbol.  This sets *IS_ABSOLUTE to indicate whether this
-  // is an absolute value; it will be false if a non-absolute symbol
-  // was referenced in the expression; this is used to detect invalid
-  // uses when setting a section address.
+  // the dot symbol.  DOT_VALUE is the absolute value of the dot
+  // symbol.  DOT_SECTION is the section in which dot is defined; it
+  // should be NULL if the dot symbol has an absolute value (e.g., is
+  // defined in a SECTIONS clause outside of any output section
+  // definition).  This sets *RESULT_SECTION to indicate where the
+  // value is defined.  If the value is absolute *RESULT_SECTION will
+  // be NULL.  Note that the returned value is still an absolute
+  // value; to get a section relative value the caller must subtract
+  // the section address.
   uint64_t
-  eval_with_dot(const Symbol_table*, const Layout*, bool dot_has_value,
-		uint64_t dot_value, bool* is_absolute);
+  eval_with_dot(const Symbol_table*, const Layout*, uint64_t dot_value,
+		Output_section* dot_section, Output_section** result_section);
 
   // Return the value of an expression which may or may not be
   // permitted to refer to the dot symbol, depending on
   // is_dot_available.
   uint64_t
   eval_maybe_dot(const Symbol_table*, const Layout*, bool is_dot_available,
-		 bool dot_has_value, uint64_t dot_value, bool* is_absolute);
+		 uint64_t dot_value, Output_section* dot_section,
+		 Output_section** result_section);
 
   // Print the expression to the FILE.  This is for debugging.
   virtual void
@@ -208,14 +214,15 @@ class Symbol_assignment
 
   // Finalize the symbol value when it can refer to the dot symbol.
   void
-  finalize_with_dot(Symbol_table*, const Layout*, bool dot_has_value,
-		    uint64_t dot_value);
+  finalize_with_dot(Symbol_table*, const Layout*, uint64_t dot_value,
+		    Output_section* dot_section);
 
   // Set the symbol value, but only if the value is absolute.  This is
-  // used while processing a SECTIONS clause.
+  // used while processing a SECTIONS clause.  We assume that dot is
+  // an absolute value here.
   void
   set_if_absolute(Symbol_table*, const Layout*, bool is_dot_available,
-		  bool dot_has_value, uint64_t dot_value);
+		  uint64_t dot_value);
 
   // Print the assignment to the FILE.  This is for debugging.
   void
@@ -225,13 +232,13 @@ class Symbol_assignment
   // Shared by finalize and finalize_with_dot.
   void
   finalize_maybe_dot(Symbol_table*, const Layout*, bool is_dot_available,
-		     bool dot_has_value, uint64_t dot_value);
+		     uint64_t dot_value, Output_section* dot_section);
 
   // Sized version of finalize.
   template<int size>
   void
   sized_finalize(Symbol_table*, const Layout*, bool is_dot_available,
-		 bool dot_has_value, uint64_t dot_value);
+		 uint64_t dot_value, Output_section*);
 
   // Symbol name.
   std::string name_;
diff --git a/gold/symtab.cc b/gold/symtab.cc
index 54ead06..86d8b11 100644
--- a/gold/symtab.cc
+++ b/gold/symtab.cc
@@ -298,20 +298,57 @@ Symbol::final_value_is_known() const
   return parameters->doing_static_link();
 }
 
-// Return whether the symbol has an absolute value.
+// Return the output section where this symbol is defined.
 
-bool
-Symbol::value_is_absolute() const
+Output_section*
+Symbol::output_section() const
 {
   switch (this->source_)
     {
     case FROM_OBJECT:
-      return this->u_.from_object.shndx == elfcpp::SHN_ABS;
+      {
+	unsigned int shndx = this->u_.from_object.shndx;
+	if (shndx != elfcpp::SHN_UNDEF && shndx < elfcpp::SHN_LORESERVE)
+	  {
+	    gold_assert(!this->u_.from_object.object->is_dynamic());
+	    Relobj* relobj = static_cast<Relobj*>(this->u_.from_object.object);
+	    section_offset_type dummy;
+	    return relobj->output_section(shndx, &dummy);
+	  }
+	return NULL;
+      }
+
     case IN_OUTPUT_DATA:
+      return this->u_.in_output_data.output_data->output_section();
+
     case IN_OUTPUT_SEGMENT:
-      return false;
     case CONSTANT:
-      return true;
+      return NULL;
+
+    default:
+      gold_unreachable();
+    }
+}
+
+// Set the symbol's output section.  This is used for symbols defined
+// in scripts.  This should only be called after the symbol table has
+// been finalized.
+
+void
+Symbol::set_output_section(Output_section* os)
+{
+  switch (this->source_)
+    {
+    case FROM_OBJECT:
+    case IN_OUTPUT_DATA:
+      gold_assert(this->output_section() == os);
+      break;
+    case 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:
     default:
       gold_unreachable();
     }
diff --git a/gold/symtab.h b/gold/symtab.h
index 4d25840..b2417f6 100644
--- a/gold/symtab.h
+++ b/gold/symtab.h
@@ -568,9 +568,16 @@ class Symbol
     return true;
   }
 
-  // Return whether this symbol currently has an absolute value.
-  bool
-  value_is_absolute() const;
+  // Return the output section where this symbol is defined.  Return
+  // NULL if the symbol has an absolute value.
+  Output_section*
+  output_section() const;
+
+  // Set the symbol's output section.  This is used for symbols
+  // defined in scripts.  This should only be called after the symbol
+  // table has been finalized.
+  void
+  set_output_section(Output_section*);
 
   // Return whether there should be a warning for references to this
   // symbol.