@@ -135,24 +135,6 @@
this->warn_unused_value();
}
-// This virtual function is the default behaviour for taking the
-// address of an expression.
-
-bool
-Expression::do_address_taken(source_location location, bool)
-{
- this->report_address_taken_error(location);
- return false;
-}
-
-// Report an error taking the address of an expression.
-
-void
-Expression::report_address_taken_error(source_location location)
-{
- error_at(location, "invalid operand for unary %<&%>");
-}
-
// This is the default implementation of the function to handle
// decrementing the reference count of the old value of an lvalue.
// Any expression which may be an l-value must implement this.
@@ -813,11 +795,11 @@
{ return this; }
bool
- do_is_value() const
- { return true; }
-
- bool
- do_address_taken(source_location, bool)
+ do_is_lvalue() const
+ { return true; }
+
+ bool
+ do_is_addressable() const
{ return true; }
Expression*
@@ -930,21 +912,15 @@
// Something takes the address of this variable. This means that we
// may want to move the variable onto the heap.
-bool
-Var_expression::do_address_taken(source_location, bool escapes)
+void
+Var_expression::do_address_taken(bool escapes)
{
if (!escapes)
- return true;
+ ;
else if (this->variable_->is_variable())
- {
- this->variable_->var_value()->set_address_taken();
- return true;
- }
+ this->variable_->var_value()->set_address_taken();
else if (this->variable_->is_result_variable())
- {
- this->variable_->result_var_value()->set_address_taken();
- return true;
- }
+ this->variable_->result_var_value()->set_address_taken();
else
gcc_unreachable();
}
@@ -1017,11 +993,10 @@
// need to know that they must live in the stack rather than in a
// register.
-bool
-Temporary_reference_expression::do_address_taken(source_location, bool)
+void
+Temporary_reference_expression::do_address_taken(bool)
{
this->statement_->set_is_address_taken();
- return true;
}
// The temporary variable is being copied. We may need to increment
@@ -2370,13 +2345,6 @@
do_copy()
{ return this; }
- bool
- do_address_taken(source_location location, bool escapes)
- {
- return this->constant_->const_value()->expr()->address_taken(location,
- escapes);
- }
-
Expression*
do_being_copied(Refcounts*, bool);
@@ -3600,7 +3568,8 @@
{ return this->op_ == OPERATOR_MULT; }
bool
- do_address_taken(source_location, bool);
+ do_is_addressable() const
+ { return this->op_ == OPERATOR_MULT; }
Expression*
do_being_copied(Refcounts*, bool);
@@ -4039,8 +4008,10 @@
break;
case OPERATOR_AND:
- if (!this->expr_->address_taken(this->location(), this->escapes_))
- this->set_is_error();
+ if (!this->expr_->is_addressable())
+ this->report_error(_("invalid operand for unary %<&%>"));
+ else
+ this->expr_->address_taken(this->escapes_);
break;
case OPERATOR_MULT:
@@ -4058,17 +4029,6 @@
}
}
-// &*p is OK.
-
-bool
-Unary_expression::do_address_taken(source_location location, bool)
-{
- if (this->op_ == OPERATOR_MULT)
- return true;
- this->report_address_taken_error(location);
- return false;
-}
-
// Copying a unary expression may require incrementing a reference
// count.
@@ -8882,7 +8842,12 @@
{ return this->end_ == NULL; }
bool
- do_address_taken(source_location, bool);
+ do_is_addressable() const
+ { return this->end_ == NULL; }
+
+ void
+ do_address_taken(bool escapes)
+ { this->array_->address_taken(escapes); }
Expression*
do_being_copied(Refcounts*, bool);
@@ -9015,25 +8980,6 @@
mpz_clear(lval);
}
-// We can take the address of an array index. We don't support taking
-// the address of a slice--I'm not sure what the type of that would
-// be. Taking the address of an array index implies taking the
-// address of the array.
-
-bool
-Array_index_expression::do_address_taken(source_location location,
- bool escapes)
-{
- if (!this->array_->address_taken(location, escapes))
- return false;
- if (this->end_ != NULL)
- {
- error_at(location, "may not take address of array slice");
- return false;
- }
- return true;
-}
-
// Copying an element of an array may require incrementing a reference
// count. Copying a slice requires incrementing the reference count
// of the underlying array.
@@ -9299,10 +9245,6 @@
this->location());
}
- bool
- do_address_taken(source_location, bool)
- { return true; }
-
Expression*
do_being_copied(Refcounts*, bool);
@@ -9588,20 +9530,6 @@
}
}
-// We can take the address of a map index expression if it is an
-// lvalue.
-
-bool
-Map_index_expression::do_address_taken(source_location location, bool)
-{
- if (!this->is_lvalue_)
- {
- this->report_address_taken_error(location);
- return false;
- }
- return true;
-}
-
// If we are copying the map index to a variable, we need to increment
// the reference count.
@@ -9767,18 +9695,6 @@
gcc_assert(struct_type->field(this->field_index_) != NULL);
}
-// We can take the address of a field, and it implies taking the
-// address of the whole structure.
-
-bool
-Field_reference_expression::do_address_taken(source_location location,
- bool escapes)
-{
- if (!this->expr_->address_taken(location, escapes))
- return false;
- return true;
-}
-
// If we are copying the field to a variable, we need to increment the
// reference count.
@@ -10484,11 +10400,8 @@
}
bool
- do_address_taken(source_location, bool)
- {
- gcc_assert(this->is_constant_struct());
- return true;
- }
+ do_is_addressable() const
+ { return true; }
Expression*
do_being_copied(Refcounts*, bool);
@@ -10798,11 +10711,8 @@
do_check_types(Gogo*);
bool
- do_address_taken(source_location, bool)
- {
- gcc_assert(this->is_constant_array());
- return true;
- }
+ do_is_addressable() const
+ { return true; }
Expression*
do_being_copied(Refcounts*, bool);
@@ -11239,11 +11149,6 @@
this->location());
}
- // Should be turned into Heap_composite_expression.
- bool
- do_address_taken(source_location, bool)
- { gcc_unreachable(); }
-
Expression*
do_being_copied(Refcounts*, bool);
@@ -560,12 +560,17 @@
is_lvalue() const
{ return this->do_is_lvalue(); }
- // We are taking the address of this expression. If this is
- // invalid, report an error and return false. ESCAPES is true if
- // this address escapes the current function.
+ // Return whether the expression is addressable--something which may
+ // be used as the operand of the unary & operator.
bool
- address_taken(source_location location, bool escapes)
- { return this->do_address_taken(location, escapes); }
+ is_addressable() const
+ { return this->do_is_addressable(); }
+
+ // Note that we are taking the address of this expression. ESCAPES
+ // is true if this address escapes the current function.
+ void
+ address_taken(bool escapes)
+ { this->do_address_taken(escapes); }
// Return whether this expression must be evaluated in order
// according to the order of evaluation rules. This is basically
@@ -715,9 +720,15 @@
do_is_lvalue() const
{ return false; }
+ // Child class implements whether the expression is addressable.
+ virtual bool
+ do_is_addressable() const
+ { return false; }
+
// Child class implements taking the address of an expression.
- virtual bool
- do_address_taken(source_location, bool);
+ virtual void
+ do_address_taken(bool)
+ { }
// Child class implements whether this expression must be evaluated
// in order.
@@ -760,10 +771,6 @@
void
report_error(const char*);
- // For errors when taking the address.
- void
- report_address_taken_error(source_location);
-
private:
// Convert to the desired statement classification, or return NULL.
// This is a controlled dynamic cast.
@@ -956,7 +963,11 @@
{ return true; }
bool
- do_address_taken(source_location, bool);
+ do_is_addressable() const
+ { return true; }
+
+ void
+ do_address_taken(bool);
Expression*
do_being_copied(Refcounts*, bool);
@@ -1000,7 +1011,11 @@
{ return true; }
bool
- do_address_taken(source_location, bool);
+ do_is_addressable() const
+ { return true; }
+
+ void
+ do_address_taken(bool);
Expression*
do_being_copied(Refcounts*, bool);
@@ -1590,8 +1605,7 @@
do_is_lvalue() const
{ return this->is_lvalue_; }
- bool
- do_address_taken(source_location, bool);
+ // A map index expression is an lvalue but it is not addressable.
Expression*
do_being_copied(Refcounts*, bool);
@@ -1743,7 +1757,8 @@
{ return true; }
bool
- do_address_taken(source_location, bool);
+ do_is_addressable() const
+ { return this->expr_->is_addressable(); }
Expression*
do_being_copied(Refcounts*, bool);
@@ -1819,10 +1834,6 @@
this->location());
}
- bool
- do_address_taken(source_location, bool)
- { return true; }
-
tree
do_get_tree(Translate_context*);