This patch fixes inherited hidden methods which return a struct
containing hidden fields. This is a rather brute force approach which
just adds a flag saying that hidden fields are OK where needed.
Bootstrapped and ran Go testsuite on x86_64-unknown-linux-gnu.
Committed to mainline.
Ian
diff -r b64b134fd7ac go/statements.cc
--- a/go/statements.cc Fri Sep 09 21:10:35 2011 -0700
+++ b/go/statements.cc Tue Sep 13 09:52:18 2011 -0700
@@ -402,7 +402,13 @@
if (this->type_ != NULL && this->init_ != NULL)
{
std::string reason;
- if (!Type::are_assignable(this->type_, this->init_->type(), &reason))
+ bool ok;
+ if (this->are_hidden_fields_ok_)
+ ok = Type::are_assignable_hidden_ok(this->type_, this->init_->type(),
+ &reason);
+ else
+ ok = Type::are_assignable(this->type_, this->init_->type(), &reason);
+ if (!ok)
{
if (reason.empty())
error_at(this->location(), "incompatible types in assignment");
@@ -504,9 +510,15 @@
Assignment_statement(Expression* lhs, Expression* rhs,
source_location location)
: Statement(STATEMENT_ASSIGNMENT, location),
- lhs_(lhs), rhs_(rhs)
+ lhs_(lhs), rhs_(rhs), are_hidden_fields_ok_(false)
{ }
+ // Note that it is OK for this assignment statement to set hidden
+ // fields.
+ void
+ set_hidden_fields_are_ok()
+ { this->are_hidden_fields_ok_ = true; }
+
protected:
int
do_traverse(Traverse* traverse);
@@ -531,6 +543,9 @@
Expression* lhs_;
// Right hand side--the rvalue.
Expression* rhs_;
+ // True if this statement may set hidden fields in the assignment
+ // statement. This is used for generated method stubs.
+ bool are_hidden_fields_ok_;
};
// Traversal.
@@ -579,7 +594,12 @@
Type* lhs_type = this->lhs_->type();
Type* rhs_type = this->rhs_->type();
std::string reason;
- if (!Type::are_assignable(lhs_type, rhs_type, &reason))
+ bool ok;
+ if (this->are_hidden_fields_ok_)
+ ok = Type::are_assignable_hidden_ok(lhs_type, rhs_type, &reason);
+ else
+ ok = Type::are_assignable(lhs_type, rhs_type, &reason);
+ if (!ok)
{
if (reason.empty())
error_at(this->location(), "incompatible types in assignment");
@@ -820,9 +840,15 @@
Tuple_assignment_statement(Expression_list* lhs, Expression_list* rhs,
source_location location)
: Statement(STATEMENT_TUPLE_ASSIGNMENT, location),
- lhs_(lhs), rhs_(rhs)
+ lhs_(lhs), rhs_(rhs), are_hidden_fields_ok_(false)
{ }
+ // Note that it is OK for this assignment statement to set hidden
+ // fields.
+ void
+ set_hidden_fields_are_ok()
+ { this->are_hidden_fields_ok_ = true; }
+
protected:
int
do_traverse(Traverse* traverse);
@@ -846,6 +872,9 @@
Expression_list* lhs_;
// Right hand side--a list of rvalues.
Expression_list* rhs_;
+ // True if this statement may set hidden fields in the assignment
+ // statement. This is used for generated method stubs.
+ bool are_hidden_fields_ok_;
};
// Traversal.
@@ -901,6 +930,8 @@
Temporary_statement* temp = Statement::make_temporary((*plhs)->type(),
*prhs, loc);
+ if (this->are_hidden_fields_ok_)
+ temp->set_hidden_fields_are_ok();
b->add_statement(temp);
temps.push_back(temp);
@@ -924,6 +955,11 @@
Expression* ref = Expression::make_temporary_reference(*ptemp, loc);
Statement* s = Statement::make_assignment(*plhs, ref, loc);
+ if (this->are_hidden_fields_ok_)
+ {
+ Assignment_statement* as = static_cast<Assignment_statement*>(s);
+ as->set_hidden_fields_are_ok();
+ }
b->add_statement(s);
++ptemp;
}
@@ -2592,7 +2628,12 @@
e->determine_type(&type_context);
std::string reason;
- if (Type::are_assignable(rvtype, e->type(), &reason))
+ bool ok;
+ if (this->are_hidden_fields_ok_)
+ ok = Type::are_assignable_hidden_ok(rvtype, e->type(), &reason);
+ else
+ ok = Type::are_assignable(rvtype, e->type(), &reason);
+ if (ok)
{
Expression* ve = Expression::make_var_reference(rv, e->location());
lhs->push_back(ve);
@@ -2614,13 +2655,28 @@
;
else if (lhs->size() == 1)
{
- b->add_statement(Statement::make_assignment(lhs->front(), rhs->front(),
- loc));
+ Statement* s = Statement::make_assignment(lhs->front(), rhs->front(),
+ loc);
+ if (this->are_hidden_fields_ok_)
+ {
+ Assignment_statement* as = static_cast<Assignment_statement*>(s);
+ as->set_hidden_fields_are_ok();
+ }
+ b->add_statement(s);
delete lhs;
delete rhs;
}
else
- b->add_statement(Statement::make_tuple_assignment(lhs, rhs, loc));
+ {
+ Statement* s = Statement::make_tuple_assignment(lhs, rhs, loc);
+ if (this->are_hidden_fields_ok_)
+ {
+ Tuple_assignment_statement* tas =
+ static_cast<Tuple_assignment_statement*>(s);
+ tas->set_hidden_fields_are_ok();
+ }
+ b->add_statement(s);
+ }
b->add_statement(this);
@@ -2670,7 +2726,7 @@
// Make a return statement.
-Statement*
+Return_statement*
Statement::make_return_statement(Expression_list* vals,
source_location location)
{
diff -r b64b134fd7ac go/statements.h
--- a/go/statements.h Fri Sep 09 21:10:35 2011 -0700
+++ b/go/statements.h Tue Sep 13 09:52:18 2011 -0700
@@ -204,7 +204,7 @@
make_defer_statement(Call_expression* call, source_location);
// Make a return statement.
- static Statement*
+ static Return_statement*
make_return_statement(Expression_list*, source_location);
// Make a break statement.
@@ -482,13 +482,20 @@
public:
Temporary_statement(Type* type, Expression* init, source_location location)
: Statement(STATEMENT_TEMPORARY, location),
- type_(type), init_(init), bvariable_(NULL), is_address_taken_(false)
+ type_(type), init_(init), bvariable_(NULL), are_hidden_fields_ok_(false),
+ is_address_taken_(false)
{ }
// Return the type of the temporary variable.
Type*
type() const;
+ // Note that it is OK for this return statement to set hidden
+ // fields.
+ void
+ set_hidden_fields_are_ok()
+ { this->are_hidden_fields_ok_ = true; }
+
// Record that something takes the address of this temporary
// variable.
void
@@ -526,6 +533,9 @@
Expression* init_;
// The backend representation of the temporary variable.
Bvariable* bvariable_;
+ // True if this statement may pass hidden fields in the return
+ // value. This is used for generated method stubs.
+ bool are_hidden_fields_ok_;
// True if something takes the address of this temporary variable.
bool is_address_taken_;
};
@@ -570,7 +580,7 @@
public:
Return_statement(Expression_list* vals, source_location location)
: Statement(STATEMENT_RETURN, location),
- vals_(vals), is_lowered_(false)
+ vals_(vals), are_hidden_fields_ok_(false), is_lowered_(false)
{ }
// The list of values being returned. This may be NULL.
@@ -578,6 +588,12 @@
vals() const
{ return this->vals_; }
+ // Note that it is OK for this return statement to set hidden
+ // fields.
+ void
+ set_hidden_fields_are_ok()
+ { this->are_hidden_fields_ok_ = true; }
+
protected:
int
do_traverse(Traverse* traverse)
@@ -602,6 +618,9 @@
private:
// Return values. This may be NULL.
Expression_list* vals_;
+ // True if this statement may pass hidden fields in the return
+ // value. This is used for generated method stubs.
+ bool are_hidden_fields_ok_;
// True if this statement has been lowered.
bool is_lowered_;
};
diff -r b64b134fd7ac go/types.cc
--- a/go/types.cc Fri Sep 09 21:10:35 2011 -0700
+++ b/go/types.cc Tue Sep 13 09:52:18 2011 -0700
@@ -7414,7 +7414,13 @@
for (size_t i = 0; i < count; ++i)
retvals->push_back(Expression::make_call_result(call, i));
}
- Statement* retstat = Statement::make_return_statement(retvals, location);
+ Return_statement* retstat = Statement::make_return_statement(retvals,
+ location);
+
+ // We can return values with hidden fields from a stub. This is
+ // necessary if the method is itself hidden.
+ retstat->set_hidden_fields_are_ok();
+
gogo->add_statement(retstat);
}
}
