procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use temporary variables for calls with multiple results.

Browse source 
From-SVN: r176998
This commit is contained in:
Ian Lance Taylor 2011-08-01 01:44:36 +00:00
parent c469244ec0
commit 8586635cd8
6 changed files with 610 additions and 282 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

224
gcc/go/gofrontend/expressions.cc
View file

@ -926,7 +926,8 @@ Parser_expression::do_type()
// if necessary.
Expression*
Var_expression::do_lower(Gogo* gogo, Named_object* function, int)
Var_expression::do_lower(Gogo* gogo, Named_object* function,
Statement_inserter* inserter, int)
{
if (this->variable_->is_variable())
{
@ -935,8 +936,11 @@ Var_expression::do_lower(Gogo* gogo, Named_object* function, int)
// reference to a variable which is local to an enclosing
// function will be a reference to a field in a closure.
if (var->is_global())
function = NULL;
var->lower_init_expression(gogo, function);
{
function = NULL;
inserter = NULL;
}
var->lower_init_expression(gogo, function, inserter);
}
return this;
}
@ -1061,7 +1065,9 @@ Temporary_reference_expression::do_get_tree(Translate_context* context)
// that here by adding a type cast. We need to use base() to push
// the circularity down one level.
tree ret = var_to_tree(bvar);
if (POINTER_TYPE_P(TREE_TYPE(ret)) && VOID_TYPE_P(TREE_TYPE(TREE_TYPE(ret))))
if (!this->is_lvalue_
&& POINTER_TYPE_P(TREE_TYPE(ret))
&& VOID_TYPE_P(TREE_TYPE(TREE_TYPE(ret))))
{
Btype* type_btype = this->type()->base()->get_backend(context->gogo());
tree type_tree = type_to_tree(type_btype);
@ -1072,7 +1078,7 @@ Temporary_reference_expression::do_get_tree(Translate_context* context)
// Make a reference to a temporary variable.
Expression*
Temporary_reference_expression*
Expression::make_temporary_reference(Temporary_statement* statement,
source_location location)
{
@ -1302,7 +1308,7 @@ Unknown_expression::name() const
// Lower a reference to an unknown name.
Expression*
Unknown_expression::do_lower(Gogo*, Named_object*, int)
Unknown_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{
source_location location = this->location();
Named_object* no = this->named_object_;
@ -2394,7 +2400,7 @@ class Const_expression : public Expression
do_traverse(Traverse*);
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const
@ -2462,7 +2468,8 @@ Const_expression::do_traverse(Traverse* traverse)
// predeclared constant iota into an integer value.
Expression*
Const_expression::do_lower(Gogo* gogo, Named_object*, int iota_value)
Const_expression::do_lower(Gogo* gogo, Named_object*,
Statement_inserter*, int iota_value)
{
if (this->constant_->const_value()->expr()->classification()
== EXPRESSION_IOTA)
@ -2931,7 +2938,7 @@ class Iota_expression : public Parser_expression
protected:
Expression*
do_lower(Gogo*, Named_object*, int)
do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{ go_unreachable(); }
// There should only ever be one of these.
@ -2988,7 +2995,7 @@ class Type_conversion_expression : public Expression
do_traverse(Traverse* traverse);
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const
@ -3057,7 +3064,8 @@ Type_conversion_expression::do_traverse(Traverse* traverse)
// Convert to a constant at lowering time.
Expression*
Type_conversion_expression::do_lower(Gogo*, Named_object*, int)
Type_conversion_expression::do_lower(Gogo*, Named_object*,
Statement_inserter*, int)
{
Type* type = this->type_;
Expression* val = this->expr_;
@ -3753,7 +3761,7 @@ class Unary_expression : public Expression
{ return Expression::traverse(&this->expr_, traverse); }
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const;
@ -3808,7 +3816,7 @@ class Unary_expression : public Expression
// instead.
Expression*
Unary_expression::do_lower(Gogo*, Named_object*, int)
Unary_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{
source_location loc = this->location();
Operator op = this->op_;
@ -5137,7 +5145,7 @@ Binary_expression::eval_complex(Operator op, Type* left_type,
// constants.
Expression*
Binary_expression::do_lower(Gogo*, Named_object*, int)
Binary_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{
source_location location = this->location();
Operator op = this->op_;
@ -6656,7 +6664,7 @@ class Builtin_call_expression : public Call_expression
protected:
// This overrides Call_expression::do_lower.
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const;
@ -6864,7 +6872,8 @@ Find_call_expression::expression(Expression** pexpr)
// specific expressions. We also convert to a constant if we can.
Expression*
Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function, int)
Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function,
Statement_inserter* inserter, int)
{
if (this->classification() == EXPRESSION_ERROR)
return this;
@ -6974,7 +6983,7 @@ Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function, int)
this->set_is_error();
return this;
}
return this->lower_varargs(gogo, function, slice_type, 2);
return this->lower_varargs(gogo, function, inserter, slice_type, 2);
}
return this;
@ -8553,9 +8562,10 @@ Call_expression::do_traverse(Traverse* traverse)
// Lower a call statement.
Expression*
Call_expression::do_lower(Gogo* gogo, Named_object* function, int)
Call_expression::do_lower(Gogo* gogo, Named_object* function,
Statement_inserter* inserter, int)
{
// A type case can look like a function call.
// A type cast can look like a function call.
if (this->fn_->is_type_expression()
&& this->args_ != NULL
&& this->args_->size() == 1)
@ -8597,6 +8607,29 @@ Call_expression::do_lower(Gogo* gogo, Named_object* function, int)
}
}
// If this call returns multiple results, create a temporary
// variable for each result.
size_t rc = this->result_count();
if (rc > 1 && this->results_ == NULL)
{
std::vector<Temporary_statement*>* temps =
new std::vector<Temporary_statement*>;
temps->reserve(rc);
const Typed_identifier_list* results =
this->fn_->type()->function_type()->results();
for (Typed_identifier_list::const_iterator p = results->begin();
p != results->end();
++p)
{
Temporary_statement* temp = Statement::make_temporary(p->type(),
NULL,
p->location());
inserter->insert(temp);
temps->push_back(temp);
}
this->results_ = temps;
}
// Handle a call to a varargs function by packaging up the extra
// parameters.
if (this->fn_->type()->function_type() != NULL
@ -8606,7 +8639,7 @@ Call_expression::do_lower(Gogo* gogo, Named_object* function, int)
const Typed_identifier_list* parameters = fntype->parameters();
go_assert(parameters != NULL && !parameters->empty());
Type* varargs_type = parameters->back().type();
return this->lower_varargs(gogo, function, varargs_type,
return this->lower_varargs(gogo, function, inserter, varargs_type,
parameters->size());
}
@ -8622,6 +8655,7 @@ Call_expression::do_lower(Gogo* gogo, Named_object* function, int)
Expression*
Call_expression::lower_varargs(Gogo* gogo, Named_object* function,
Statement_inserter* inserter,
Type* varargs_type, size_t param_count)
{
if (this->varargs_are_lowered_)
@ -8702,13 +8736,12 @@ Call_expression::lower_varargs(Gogo* gogo, Named_object* function,
// Lower all the new subexpressions.
Expression* ret = this;
gogo->lower_expression(function, &ret);
gogo->lower_expression(function, inserter, &ret);
go_assert(ret == this);
return ret;
}
// Get the function type. Returns NULL if we don't know the type. If
// this returns NULL, and if_ERROR is true, issues an error.
// Get the function type. This can return NULL in error cases.
Function_type*
Call_expression::get_function_type() const
@ -8729,6 +8762,16 @@ Call_expression::result_count() const
return fntype->results()->size();
}
// Return the temporary which holds a result.
Temporary_statement*
Call_expression::result(size_t i) const
{
go_assert(this->results_ != NULL
&& this->results_->size() > i);
return (*this->results_)[i];
}
// Return whether this is a call to the predeclared function recover.
bool
@ -8759,6 +8802,21 @@ Call_expression::do_set_recover_arg(Expression*)
go_unreachable();
}
// We have found an error with this call expression; return true if
// we should report it.
bool
Call_expression::issue_error()
{
if (this->issued_error_)
return false;
else
{
this->issued_error_ = true;
return true;
}
}
// Get the type.
Type*
@ -8941,15 +8999,12 @@ Call_expression::do_check_types(Gogo*)
// Return whether we have to use a temporary variable to ensure that
// we evaluate this call expression in order. If the call returns no
// results then it will inevitably be executed last. If the call
// returns more than one result then it will be used with Call_result
// expressions. So we only have to use a temporary variable if the
// call returns exactly one result.
// results then it will inevitably be executed last.
bool
Call_expression::do_must_eval_in_order() const
{
return this->result_count() == 1;
return this->result_count() > 0;
}
// Get the function and the first argument to use when calling a bound
@ -9193,16 +9248,56 @@ Call_expression::do_get_tree(Translate_context* context)
ret = build1(NOP_EXPR, rettype, ret);
}
// If there is more than one result, we will refer to the call
// multiple times.
if (fntype->results() != NULL && fntype->results()->size() > 1)
ret = save_expr(ret);
if (this->results_ != NULL)
ret = this->set_results(context, ret);
this->tree_ = ret;
return ret;
}
// Set the result variables if this call returns multiple results.
tree
Call_expression::set_results(Translate_context* context, tree call_tree)
{
tree stmt_list = NULL_TREE;
call_tree = save_expr(call_tree);
if (TREE_CODE(TREE_TYPE(call_tree)) != RECORD_TYPE)
{
go_assert(saw_errors());
return call_tree;
}
source_location loc = this->location();
tree field = TYPE_FIELDS(TREE_TYPE(call_tree));
size_t rc = this->result_count();
for (size_t i = 0; i < rc; ++i, field = DECL_CHAIN(field))
{
go_assert(field != NULL_TREE);
Temporary_statement* temp = this->result(i);
Temporary_reference_expression* ref =
Expression::make_temporary_reference(temp, loc);
ref->set_is_lvalue();
tree temp_tree = ref->get_tree(context);
if (temp_tree == error_mark_node)
continue;
tree val_tree = build3_loc(loc, COMPONENT_REF, TREE_TYPE(field),
call_tree, field, NULL_TREE);
tree set_tree = build2_loc(loc, MODIFY_EXPR, void_type_node, temp_tree,
val_tree);
append_to_statement_list(set_tree, &stmt_list);
}
go_assert(field == NULL_TREE);
return save_expr(stmt_list);
}
// Make a call expression.
Call_expression*
@ -9292,10 +9387,11 @@ Call_result_expression::do_type()
return Type::make_error_type();
}
const Typed_identifier_list* results = fntype->results();
if (results == NULL)
if (results == NULL || results->size() < 2)
{
this->report_error(_("number of results does not match "
"number of values"));
if (ce->issue_error())
this->report_error(_("number of results does not match "
"number of values"));
return Type::make_error_type();
}
Typed_identifier_list::const_iterator pr = results->begin();
@ -9307,8 +9403,9 @@ Call_result_expression::do_type()
}
if (pr == results->end())
{
this->report_error(_("number of results does not match "
"number of values"));
if (ce->issue_error())
this->report_error(_("number of results does not match "
"number of values"));
return Type::make_error_type();
}
return pr->type();
@ -9332,27 +9429,18 @@ Call_result_expression::do_determine_type(const Type_context*)
this->call_->determine_type_no_context();
}
// Return the tree.
// Return the tree. We just refer to the temporary set by the call
// expression. We don't do this at lowering time because it makes it
// hard to evaluate the call at the right time.
tree
Call_result_expression::do_get_tree(Translate_context* context)
{
tree call_tree = this->call_->get_tree(context);
if (call_tree == error_mark_node)
return error_mark_node;
if (TREE_CODE(TREE_TYPE(call_tree)) != RECORD_TYPE)
{
go_assert(saw_errors());
return error_mark_node;
}
tree field = TYPE_FIELDS(TREE_TYPE(call_tree));
for (unsigned int i = 0; i < this->index_; ++i)
{
go_assert(field != NULL_TREE);
field = DECL_CHAIN(field);
}
go_assert(field != NULL_TREE);
return build3(COMPONENT_REF, TREE_TYPE(field), call_tree, field, NULL_TREE);
Call_expression* ce = this->call_->call_expression();
go_assert(ce != NULL);
Temporary_statement* ts = ce->result(this->index_);
Expression* ref = Expression::make_temporary_reference(ts, this->location());
return ref->get_tree(context);
}
// Make a reference to a single result of a call which returns
@ -9383,7 +9471,7 @@ Index_expression::do_traverse(Traverse* traverse)
// expression into an array index, a string index, or a map index.
Expression*
Index_expression::do_lower(Gogo*, Named_object*, int)
Index_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{
source_location location = this->location();
Expression* left = this->left_;
@ -10542,7 +10630,7 @@ class Selector_expression : public Parser_expression
{ return Expression::traverse(&this->left_, traverse); }
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_copy()
@ -10565,7 +10653,8 @@ class Selector_expression : public Parser_expression
// hand side.
Expression*
Selector_expression::do_lower(Gogo* gogo, Named_object*, int)
Selector_expression::do_lower(Gogo* gogo, Named_object*, Statement_inserter*,
int)
{
Expression* left = this->left_;
if (left->is_type_expression())
@ -10734,6 +10823,8 @@ Selector_expression::lower_method_expression(Gogo* gogo)
}
}
gogo->start_block(location);
Call_expression* call = Expression::make_call(bm, args,
method_type->is_varargs(),
location);
@ -10756,6 +10847,13 @@ Selector_expression::lower_method_expression(Gogo* gogo)
}
gogo->add_statement(s);
Block* b = gogo->finish_block(location);
gogo->add_block(b, location);
// Lower the call in case there are multiple results.
gogo->lower_block(no, b);
gogo->finish_function(location);
return Expression::make_func_reference(no, NULL, location);
@ -11860,7 +11958,7 @@ class Composite_literal_expression : public Parser_expression
do_traverse(Traverse* traverse);
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_copy()
@ -11884,7 +11982,7 @@ class Composite_literal_expression : public Parser_expression
make_array(Type*, Expression_list*);
Expression*
lower_map(Gogo*, Named_object*, Type*);
lower_map(Gogo*, Named_object*, Statement_inserter*, Type*);
// The type of the composite literal.
Type* type_;
@ -11913,7 +12011,8 @@ Composite_literal_expression::do_traverse(Traverse* traverse)
// the type.
Expression*
Composite_literal_expression::do_lower(Gogo* gogo, Named_object* function, int)
Composite_literal_expression::do_lower(Gogo* gogo, Named_object* function,
Statement_inserter* inserter, int)
{
Type* type = this->type_;
@ -11940,7 +12039,7 @@ Composite_literal_expression::do_lower(Gogo* gogo, Named_object* function, int)
else if (type->array_type() != NULL)
return this->lower_array(type);
else if (type->map_type() != NULL)
return this->lower_map(gogo, function, type);
return this->lower_map(gogo, function, inserter, type);
else
{
error_at(this->location(),
@ -12244,6 +12343,7 @@ Composite_literal_expression::make_array(Type* type, Expression_list* vals)
Expression*
Composite_literal_expression::lower_map(Gogo* gogo, Named_object* function,
Statement_inserter* inserter,
Type* type)
{
source_location location = this->location();
@ -12272,7 +12372,7 @@ Composite_literal_expression::lower_map(Gogo* gogo, Named_object* function,
if ((*p)->unknown_expression() != NULL)
{
(*p)->unknown_expression()->clear_is_composite_literal_key();
gogo->lower_expression(function, &*p);
gogo->lower_expression(function, inserter, &*p);
go_assert((*p)->is_error_expression());
return Expression::make_error(location);
}

76
gcc/go/gofrontend/expressions.h
View file

@ -15,6 +15,7 @@
class Gogo;
class Translate_context;
class Traverse;
class Statement_inserter;
class Type;
struct Type_context;
class Function_type;
@ -128,7 +129,7 @@ class Expression
// Make a reference to a temporary variable. Temporary variables
// are always created by a single statement, which is what we use to
// refer to them.
static Expression*
static Temporary_reference_expression*
make_temporary_reference(Temporary_statement*, source_location);
// Make a sink expression--a reference to the blank identifier _.
@ -521,13 +522,18 @@ class Expression
traverse_subexpressions(Traverse*);
// Lower an expression. This is called immediately after parsing.
// IOTA_VALUE is the value that we should give to any iota
// expressions. This function must resolve expressions which could
// not be fully parsed into their final form. It returns the same
// Expression or a new one.
// FUNCTION is the function we are in; it will be NULL for an
// expression initializing a global variable. INSERTER may be used
// to insert statements before the statement or initializer
// containing this expression; it is normally used to create
// temporary variables. IOTA_VALUE is the value that we should give
// to any iota expressions. This function must resolve expressions
// which could not be fully parsed into their final form. It
// returns the same Expression or a new one.
Expression*
lower(Gogo* gogo, Named_object* function, int iota_value)
{ return this->do_lower(gogo, function, iota_value); }
lower(Gogo* gogo, Named_object* function, Statement_inserter* inserter,
int iota_value)
{ return this->do_lower(gogo, function, inserter, iota_value); }
// Determine the real type of an expression with abstract integer,
// floating point, or complex type. TYPE_CONTEXT describes the
@ -636,7 +642,7 @@ class Expression
// Return a lowered expression.
virtual Expression*
do_lower(Gogo*, Named_object*, int)
do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{ return this; }
// Return whether this is a constant expression.
@ -871,7 +877,7 @@ class Parser_expression : public Expression
protected:
virtual Expression*
do_lower(Gogo*, Named_object*, int) = 0;
do_lower(Gogo*, Named_object*, Statement_inserter*, int) = 0;
Type*
do_type();
@ -906,7 +912,7 @@ class Var_expression : public Expression
protected:
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Type*
do_type();
@ -941,9 +947,15 @@ class Temporary_reference_expression : public Expression
Temporary_reference_expression(Temporary_statement* statement,
source_location location)
: Expression(EXPRESSION_TEMPORARY_REFERENCE, location),
statement_(statement)
statement_(statement), is_lvalue_(false)
{ }
// Indicate that this reference appears on the left hand side of an
// assignment statement.
void
set_is_lvalue()
{ this->is_lvalue_ = true; }
protected:
Type*
do_type();
@ -969,6 +981,9 @@ class Temporary_reference_expression : public Expression
private:
// The statement where the temporary variable is defined.
Temporary_statement* statement_;
// Whether this reference appears on the left hand side of an
// assignment statement.
bool is_lvalue_;
};
// A string expression.
@ -1099,7 +1114,7 @@ class Binary_expression : public Expression
do_traverse(Traverse* traverse);
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const
@ -1156,9 +1171,9 @@ class Call_expression : public Expression
Call_expression(Expression* fn, Expression_list* args, bool is_varargs,
source_location location)
: Expression(EXPRESSION_CALL, location),
fn_(fn), args_(args), type_(NULL), tree_(NULL), is_varargs_(is_varargs),
varargs_are_lowered_(false), types_are_determined_(false),
is_deferred_(false)
fn_(fn), args_(args), type_(NULL), results_(NULL), tree_(NULL),
is_varargs_(is_varargs), varargs_are_lowered_(false),
types_are_determined_(false), is_deferred_(false), issued_error_(false)
{ }
// The function to call.
@ -1183,6 +1198,12 @@ class Call_expression : public Expression
size_t
result_count() const;
// Return the temporary variable which holds result I. This is only
// valid after the expression has been lowered, and is only valid
// for calls which return multiple results.
Temporary_statement*
result(size_t i) const;
// Return whether this is a call to the predeclared function
// recover.
bool
@ -1207,12 +1228,17 @@ class Call_expression : public Expression
set_is_deferred()
{ this->is_deferred_ = true; }
// We have found an error with this call expression; return true if
// we should report it.
bool
issue_error();
protected:
int
do_traverse(Traverse*);
virtual Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
void
do_discarding_value()
@ -1256,8 +1282,8 @@ class Call_expression : public Expression
// Let a builtin expression lower varargs.
Expression*
lower_varargs(Gogo*, Named_object* function, Type* varargs_type,
size_t param_count);
lower_varargs(Gogo*, Named_object* function, Statement_inserter* inserter,
Type* varargs_type, size_t param_count);
// Let a builtin expression check whether types have been
// determined.
@ -1276,6 +1302,9 @@ class Call_expression : public Expression
Interface_field_reference_expression*,
tree*);
tree
set_results(Translate_context*, tree);
// The function to call.
Expression* fn_;
// The arguments to pass. This may be NULL if there are no
@ -1283,6 +1312,9 @@ class Call_expression : public Expression
Expression_list* args_;
// The type of the expression, to avoid recomputing it.
Type* type_;
// The list of temporaries which will hold the results if the
// function returns a tuple.
std::vector<Temporary_statement*>* results_;
// The tree for the call, used for a call which returns a tuple.
tree tree_;
// True if the last argument is a varargs argument (f(a...)).
@ -1293,6 +1325,10 @@ class Call_expression : public Expression
bool types_are_determined_;
// True if the call is an argument to a defer statement.
bool is_deferred_;
// True if we reported an error about a mismatch between call
// results and uses. This is to avoid producing multiple errors
// when there are multiple Call_result_expressions.
bool issued_error_;
};
// An expression which represents a pointer to a function.
@ -1390,7 +1426,7 @@ class Unknown_expression : public Parser_expression
protected:
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_copy()
@ -1425,7 +1461,7 @@ class Index_expression : public Parser_expression
do_traverse(Traverse*);
Expression*
do_lower(Gogo*, Named_object*, int);
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_copy()

340
gcc/go/gofrontend/gogo.cc
View file

@ -1148,9 +1148,13 @@ class Lower_parse_tree : public Traverse
| traverse_functions
| traverse_statements
| traverse_expressions),
gogo_(gogo), function_(function), iota_value_(-1)
gogo_(gogo), function_(function), iota_value_(-1), inserter_()
{ }
void
set_inserter(const Statement_inserter* inserter)
{ this->inserter_ = *inserter; }
int
variable(Named_object*);
@ -1173,18 +1177,44 @@ class Lower_parse_tree : public Traverse
Named_object* function_;
// Value to use for the predeclared constant iota.
int iota_value_;
// Current statement inserter for use by expressions.
Statement_inserter inserter_;
};
// Lower variables. We handle variables specially to break loops in
// which a variable initialization expression refers to itself. The
// loop breaking is in lower_init_expression.
// Lower variables.
int
Lower_parse_tree::variable(Named_object* no)
{
if (no->is_variable())
no->var_value()->lower_init_expression(this->gogo_, this->function_);
return TRAVERSE_CONTINUE;
if (!no->is_variable())
return TRAVERSE_CONTINUE;
if (no->is_variable() && no->var_value()->is_global())
{
// Global variables can have loops in their initialization
// expressions. This is handled in lower_init_expression.
no->var_value()->lower_init_expression(this->gogo_, this->function_,
&this->inserter_);
return TRAVERSE_CONTINUE;
}
// This is a local variable. We are going to return
// TRAVERSE_SKIP_COMPONENTS here because we want to traverse the
// initialization expression when we reach the variable declaration
// statement. However, that means that we need to traverse the type
// ourselves.
if (no->var_value()->has_type())
{
Type* type = no->var_value()->type();
if (type != NULL)
{
if (Type::traverse(type, this) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
}
go_assert(!no->var_value()->has_pre_init());
return TRAVERSE_SKIP_COMPONENTS;
}
// Lower constants. We handle constants specially so that we can set
@ -1238,27 +1268,38 @@ Lower_parse_tree::function(Named_object* no)
int
Lower_parse_tree::statement(Block* block, size_t* pindex, Statement* sorig)
{
Statement_inserter hold_inserter(this->inserter_);
this->inserter_ = Statement_inserter(block, pindex);
// Lower the expressions first.
int t = sorig->traverse_contents(this);
if (t == TRAVERSE_EXIT)
return t;
{
this->inserter_ = hold_inserter;
return t;
}
// Keep lowering until nothing changes.
Statement* s = sorig;
while (true)
{
Statement* snew = s->lower(this->gogo_, this->function_, block);
Statement* snew = s->lower(this->gogo_, this->function_, block,
&this->inserter_);
if (snew == s)
break;
s = snew;
t = s->traverse_contents(this);
if (t == TRAVERSE_EXIT)
return t;
{
this->inserter_ = hold_inserter;
return t;
}
}
if (s != sorig)
block->replace_statement(*pindex, s);
this->inserter_ = hold_inserter;
return TRAVERSE_SKIP_COMPONENTS;
}
@ -1277,7 +1318,7 @@ Lower_parse_tree::expression(Expression** pexpr)
{
Expression* e = *pexpr;
Expression* enew = e->lower(this->gogo_, this->function_,
this->iota_value_);
&this->inserter_, this->iota_value_);
if (enew == e)
break;
*pexpr = enew;
@ -1304,12 +1345,16 @@ Gogo::lower_block(Named_object* function, Block* block)
block->traverse(&lower_parse_tree);
}
// Lower an expression.
// Lower an expression. INSERTER may be NULL, in which case the
// expression had better not need to create any temporaries.
void
Gogo::lower_expression(Named_object* function, Expression** pexpr)
Gogo::lower_expression(Named_object* function, Statement_inserter* inserter,
Expression** pexpr)
{
Lower_parse_tree lower_parse_tree(this, function);
if (inserter != NULL)
lower_parse_tree.set_inserter(inserter);
lower_parse_tree.expression(pexpr);
}
@ -1951,11 +1996,26 @@ Order_eval::statement(Block* block, size_t* pindex, Statement* s)
break;
source_location loc = (*pexpr)->location();
Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
block->insert_statement_before(*pindex, ts);
++*pindex;
Statement* s;
if ((*pexpr)->call_expression() == NULL
|| (*pexpr)->call_expression()->result_count() < 2)
{
Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr,
loc);
s = ts;
*pexpr = Expression::make_temporary_reference(ts, loc);
}
else
{
// A call expression which returns multiple results needs to
// be handled specially. We can't create a temporary
// because there is no type to give it. Any actual uses of
// the values will be done via Call_result_expressions.
s = Statement::make_statement(*pexpr);
}
*pexpr = Expression::make_temporary_reference(ts, loc);
block->insert_statement_before(*pindex, s);
++*pindex;
}
if (init != orig_init)
@ -1978,7 +2038,7 @@ Order_eval::variable(Named_object* no)
return TRAVERSE_CONTINUE;
Find_eval_ordering find_eval_ordering;
init->traverse_subexpressions(&find_eval_ordering);
Expression::traverse(&init, &find_eval_ordering);
if (find_eval_ordering.size() <= 1)
{
@ -1993,9 +2053,22 @@ Order_eval::variable(Named_object* no)
{
Expression** pexpr = *p;
source_location loc = (*pexpr)->location();
Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
var->add_preinit_statement(this->gogo_, ts);
*pexpr = Expression::make_temporary_reference(ts, loc);
Statement* s;
if ((*pexpr)->call_expression() == NULL
|| (*pexpr)->call_expression()->result_count() < 2)
{
Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr,
loc);
s = ts;
*pexpr = Expression::make_temporary_reference(ts, loc);
}
else
{
// A call expression which returns multiple results needs to
// be handled specially.
s = Statement::make_statement(*pexpr);
}
var->add_preinit_statement(this->gogo_, s);
}
return TRAVERSE_SKIP_COMPONENTS;
@ -2181,6 +2254,8 @@ Build_recover_thunks::function(Named_object* orig_no)
}
args->push_back(this->can_recover_arg(location));
gogo->start_block(location);
Call_expression* call = Expression::make_call(fn, args, false, location);
Statement* s;
@ -2202,6 +2277,13 @@ Build_recover_thunks::function(Named_object* orig_no)
s->determine_types();
gogo->add_statement(s);
Block* b = gogo->finish_block(location);
gogo->add_block(b, location);
// Lower the call in case it returns multiple results.
gogo->lower_block(new_no, b);
gogo->finish_function(location);
// Swap the function bodies and types.
@ -3152,78 +3234,64 @@ Block::traverse(Traverse* traverse)
| Traverse::traverse_expressions
| Traverse::traverse_types)) != 0)
{
const unsigned int e_or_t = (Traverse::traverse_expressions
| Traverse::traverse_types);
const unsigned int e_or_t_or_s = (e_or_t
| Traverse::traverse_statements);
for (Bindings::const_definitions_iterator pb =
this->bindings_->begin_definitions();
pb != this->bindings_->end_definitions();
++pb)
{
int t = TRAVERSE_CONTINUE;
switch ((*pb)->classification())
{
case Named_object::NAMED_OBJECT_CONST:
if ((traverse_mask & Traverse::traverse_constants) != 0)
t = traverse->constant(*pb, false);
if (t == TRAVERSE_CONTINUE
&& (traverse_mask & e_or_t) != 0)
{
if (traverse->constant(*pb, false) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if ((traverse_mask & Traverse::traverse_types) != 0
|| (traverse_mask & Traverse::traverse_expressions) != 0)
{
Type* t = (*pb)->const_value()->type();
if (t != NULL
&& Type::traverse(t, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if ((traverse_mask & Traverse::traverse_expressions) != 0
|| (traverse_mask & Traverse::traverse_types) != 0)
{
if ((*pb)->const_value()->traverse_expression(traverse)
== TRAVERSE_EXIT)
Type* tc = (*pb)->const_value()->type();
if (tc != NULL
&& Type::traverse(tc, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
t = (*pb)->const_value()->traverse_expression(traverse);
}
break;
case Named_object::NAMED_OBJECT_VAR:
case Named_object::NAMED_OBJECT_RESULT_VAR:
if ((traverse_mask & Traverse::traverse_variables) != 0)
t = traverse->variable(*pb);
if (t == TRAVERSE_CONTINUE
&& (traverse_mask & e_or_t) != 0)
{
if (traverse->variable(*pb) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if (((traverse_mask & Traverse::traverse_types) != 0
|| (traverse_mask & Traverse::traverse_expressions) != 0)
&& ((*pb)->is_result_variable()
|| (*pb)->var_value()->has_type()))
{
Type* t = ((*pb)->is_variable()
? (*pb)->var_value()->type()
: (*pb)->result_var_value()->type());
if (t != NULL
&& Type::traverse(t, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if ((*pb)->is_variable()
&& ((traverse_mask & Traverse::traverse_expressions) != 0
|| (traverse_mask & Traverse::traverse_types) != 0))
{
if ((*pb)->var_value()->traverse_expression(traverse)
== TRAVERSE_EXIT)
return TRAVERSE_EXIT;
if ((*pb)->is_result_variable()
|| (*pb)->var_value()->has_type())
{
Type* tv = ((*pb)->is_variable()
? (*pb)->var_value()->type()
: (*pb)->result_var_value()->type());
if (tv != NULL
&& Type::traverse(tv, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
}
if (t == TRAVERSE_CONTINUE
&& (traverse_mask & e_or_t_or_s) != 0
&& (*pb)->is_variable())
t = (*pb)->var_value()->traverse_expression(traverse,
traverse_mask);
break;
case Named_object::NAMED_OBJECT_FUNC:
case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
// FIXME: Where will nested functions be found?
go_unreachable();
case Named_object::NAMED_OBJECT_TYPE:
if ((traverse_mask & Traverse::traverse_types) != 0
|| (traverse_mask & Traverse::traverse_expressions) != 0)
{
if (Type::traverse((*pb)->type_value(), traverse)
== TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if ((traverse_mask & e_or_t) != 0)
t = Type::traverse((*pb)->type_value(), traverse);
break;
case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
@ -3237,6 +3305,9 @@ Block::traverse(Traverse* traverse)
default:
go_unreachable();
}
if (t == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
}
@ -3351,14 +3422,17 @@ Variable::Variable(Type* type, Expression* init, bool is_global,
// Traverse the initializer expression.
int
Variable::traverse_expression(Traverse* traverse)
Variable::traverse_expression(Traverse* traverse, unsigned int traverse_mask)
{
if (this->preinit_ != NULL)
{
if (this->preinit_->traverse(traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if (this->init_ != NULL)
if (this->init_ != NULL
&& ((traverse_mask
& (Traverse::traverse_expressions | Traverse::traverse_types))
!= 0))
{
if (Expression::traverse(&this->init_, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
@ -3369,7 +3443,8 @@ Variable::traverse_expression(Traverse* traverse)
// Lower the initialization expression after parsing is complete.
void
Variable::lower_init_expression(Gogo* gogo, Named_object* function)
Variable::lower_init_expression(Gogo* gogo, Named_object* function,
Statement_inserter* inserter)
{
if (this->init_ != NULL && !this->init_is_lowered_)
{
@ -3381,7 +3456,14 @@ Variable::lower_init_expression(Gogo* gogo, Named_object* function)
}
this->seen_ = true;
gogo->lower_expression(function, &this->init_);
Statement_inserter global_inserter;
if (this->is_global_)
{
global_inserter = Statement_inserter(gogo, this);
inserter = &global_inserter;
}
gogo->lower_expression(function, inserter, &this->init_);
this->seen_ = false;
@ -4508,77 +4590,67 @@ Bindings::traverse(Traverse* traverse, bool is_global)
// We don't use an iterator because we permit the traversal to add
// new global objects.
const unsigned int e_or_t = (Traverse::traverse_expressions
| Traverse::traverse_types);
const unsigned int e_or_t_or_s = (e_or_t
| Traverse::traverse_statements);
for (size_t i = 0; i < this->named_objects_.size(); ++i)
{
Named_object* p = this->named_objects_[i];
int t = TRAVERSE_CONTINUE;
switch (p->classification())
{
case Named_object::NAMED_OBJECT_CONST:
if ((traverse_mask & Traverse::traverse_constants) != 0)
t = traverse->constant(p, is_global);
if (t == TRAVERSE_CONTINUE
&& (traverse_mask & e_or_t) != 0)
{
if (traverse->constant(p, is_global) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if ((traverse_mask & Traverse::traverse_types) != 0
|| (traverse_mask & Traverse::traverse_expressions) != 0)
{
Type* t = p->const_value()->type();
if (t != NULL
&& Type::traverse(t, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
if (p->const_value()->traverse_expression(traverse)
== TRAVERSE_EXIT)
Type* tc = p->const_value()->type();
if (tc != NULL
&& Type::traverse(tc, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
t = p->const_value()->traverse_expression(traverse);
}
break;
case Named_object::NAMED_OBJECT_VAR:
case Named_object::NAMED_OBJECT_RESULT_VAR:
if ((traverse_mask & Traverse::traverse_variables) != 0)
t = traverse->variable(p);
if (t == TRAVERSE_CONTINUE
&& (traverse_mask & e_or_t) != 0)
{
if (traverse->variable(p) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if (((traverse_mask & Traverse::traverse_types) != 0
|| (traverse_mask & Traverse::traverse_expressions) != 0)
&& (p->is_result_variable()
|| p->var_value()->has_type()))
{
Type* t = (p->is_variable()
? p->var_value()->type()
: p->result_var_value()->type());
if (t != NULL
&& Type::traverse(t, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if (p->is_variable()
&& ((traverse_mask & Traverse::traverse_types) != 0
|| (traverse_mask & Traverse::traverse_expressions) != 0))
{
if (p->var_value()->traverse_expression(traverse)
== TRAVERSE_EXIT)
return TRAVERSE_EXIT;
if (p->is_result_variable()
|| p->var_value()->has_type())
{
Type* tv = (p->is_variable()
? p->var_value()->type()
: p->result_var_value()->type());
if (tv != NULL
&& Type::traverse(tv, traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
}
if (t == TRAVERSE_CONTINUE
&& (traverse_mask & e_or_t_or_s) != 0
&& p->is_variable())
t = p->var_value()->traverse_expression(traverse, traverse_mask);
break;
case Named_object::NAMED_OBJECT_FUNC:
if ((traverse_mask & Traverse::traverse_functions) != 0)
{
int t = traverse->function(p);
if (t == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
else if (t == TRAVERSE_SKIP_COMPONENTS)
break;
}
t = traverse->function(p);
if ((traverse_mask
& (Traverse::traverse_variables
| Traverse::traverse_constants
| Traverse::traverse_functions
| Traverse::traverse_blocks
| Traverse::traverse_statements
| Traverse::traverse_expressions
| Traverse::traverse_types)) != 0)
if (t == TRAVERSE_CONTINUE
&& (traverse_mask
& (Traverse::traverse_variables
| Traverse::traverse_constants
| Traverse::traverse_functions
| Traverse::traverse_blocks
| Traverse::traverse_statements
| Traverse::traverse_expressions
| Traverse::traverse_types)) != 0)
{
if (p->func_value()->traverse(traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
@ -4591,12 +4663,8 @@ Bindings::traverse(Traverse* traverse, bool is_global)
break;
case Named_object::NAMED_OBJECT_TYPE:
if ((traverse_mask & Traverse::traverse_types) != 0
|| (traverse_mask & Traverse::traverse_expressions) != 0)
{
if (Type::traverse(p->type_value(), traverse) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
if ((traverse_mask & e_or_t) != 0)
t = Type::traverse(p->type_value(), traverse);
break;
case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
@ -4608,6 +4676,9 @@ Bindings::traverse(Traverse* traverse, bool is_global)
default:
go_unreachable();
}
if (t == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
return TRAVERSE_CONTINUE;
@ -4805,3 +4876,20 @@ Traverse::type(Type*)
{
go_unreachable();
}
// Class Statement_inserter.
void
Statement_inserter::insert(Statement* s)
{
if (this->block_ != NULL)
{
go_assert(this->pindex_ != NULL);
this->block_->insert_statement_before(*this->pindex_, s);
++*this->pindex_;
}
else if (this->var_ != NULL)
this->var_->add_preinit_statement(this->gogo_, s);
else
go_unreachable();
}

47
gcc/go/gofrontend/gogo.h
View file

@ -8,6 +8,7 @@
#define GO_GOGO_H
class Traverse;
class Statement_inserter;
class Type;
class Type_hash_identical;
class Type_equal;
@ -366,7 +367,7 @@ class Gogo
// Lower an expression.
void
lower_expression(Named_object* function, Expression**);
lower_expression(Named_object* function, Statement_inserter*, Expression**);
// Lower a constant.
void
@ -1157,7 +1158,7 @@ class Variable
// Lower the initialization expression after parsing is complete.
void
lower_init_expression(Gogo*, Named_object*);
lower_init_expression(Gogo*, Named_object*, Statement_inserter*);
// A special case: the init value is used only to determine the
// type. This is used if the variable is defined using := with the
@ -1208,7 +1209,7 @@ class Variable
// Traverse the initializer expression.
int
traverse_expression(Traverse*);
traverse_expression(Traverse*, unsigned int traverse_mask);
// Determine the type of the variable if necessary.
void
@ -2463,6 +2464,46 @@ class Traverse
Expressions_seen* expressions_seen_;
};
// A class which makes it easier to insert new statements before the
// current statement during a traversal.
class Statement_inserter
{
public:
// Empty constructor.
Statement_inserter()
: block_(NULL), pindex_(NULL), gogo_(NULL), var_(NULL)
{ }
// Constructor for a statement in a block.
Statement_inserter(Block* block, size_t *pindex)
: block_(block), pindex_(pindex), gogo_(NULL), var_(NULL)
{ }
// Constructor for a global variable.
Statement_inserter(Gogo* gogo, Variable* var)
: block_(NULL), pindex_(NULL), gogo_(gogo), var_(var)
{ go_assert(var->is_global()); }
// We use the default copy constructor and assignment operator.
// Insert S before the statement we are traversing, or before the
// initialization expression of a global variable.
void
insert(Statement* s);
private:
// The block that the statement is in.
Block* block_;
// The index of the statement that we are traversing.
size_t* pindex_;
// The IR, needed when looking at an initializer expression for a
// global variable.
Gogo* gogo_;
// The global variable, when looking at an initializer expression.
Variable* var_;
};
// When translating the gogo IR into the backend data structure, this
// is the context we pass down the blocks and statements.

181
gcc/go/gofrontend/statements.cc
View file

@ -217,6 +217,16 @@ Variable_declaration_statement::do_traverse_assignments(
return true;
}
// Lower the variable's initialization expression.
Statement*
Variable_declaration_statement::do_lower(Gogo* gogo, Named_object* function,
Block*, Statement_inserter* inserter)
{
this->var_->var_value()->lower_init_expression(gogo, function, inserter);
return this;
}
// Convert a variable declaration to the backend representation.
Bstatement*
@ -244,7 +254,7 @@ Variable_declaration_statement::do_get_backend(Translate_context* context)
Expression_list* params = new Expression_list();
params->push_back(Expression::make_type(var->type(), loc));
Expression* call = Expression::make_call(func, params, false, loc);
context->gogo()->lower_expression(context->function(), &call);
context->gogo()->lower_expression(context->function(), NULL, &call);
Temporary_statement* temp = Statement::make_temporary(NULL, call, loc);
Bstatement* btemp = temp->get_backend(context);
@ -386,7 +396,7 @@ Temporary_statement::do_get_backend(Translate_context* context)
{
Expression* init = Expression::make_cast(this->type_, this->init_,
this->location());
context->gogo()->lower_expression(context->function(), &init);
context->gogo()->lower_expression(context->function(), NULL, &init);
binit = tree_to_expr(init->get_tree(context));
}
@ -598,7 +608,7 @@ class Assignment_operation_statement : public Statement
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -628,7 +638,7 @@ Assignment_operation_statement::do_traverse(Traverse* traverse)
Statement*
Assignment_operation_statement::do_lower(Gogo*, Named_object*,
Block* enclosing)
Block* enclosing, Statement_inserter*)
{
source_location loc = this->location();
@ -725,7 +735,7 @@ class Tuple_assignment_statement : public Statement
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -752,7 +762,8 @@ Tuple_assignment_statement::do_traverse(Traverse* traverse)
// up into a set of single assignments.
Statement*
Tuple_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
Tuple_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
Statement_inserter*)
{
source_location loc = this->location();
@ -852,7 +863,7 @@ public:
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -882,7 +893,7 @@ Tuple_map_assignment_statement::do_traverse(Traverse* traverse)
Statement*
Tuple_map_assignment_statement::do_lower(Gogo*, Named_object*,
Block* enclosing)
Block* enclosing, Statement_inserter*)
{
source_location loc = this->location();
@ -923,7 +934,8 @@ Tuple_map_assignment_statement::do_lower(Gogo*, Named_object*,
b->add_statement(present_temp);
// present_temp = mapaccess2(MAP, &key_temp, &val_temp)
Expression* ref = Expression::make_temporary_reference(key_temp, loc);
Temporary_reference_expression* ref =
Expression::make_temporary_reference(key_temp, loc);
Expression* a1 = Expression::make_unary(OPERATOR_AND, ref, loc);
ref = Expression::make_temporary_reference(val_temp, loc);
Expression* a2 = Expression::make_unary(OPERATOR_AND, ref, loc);
@ -931,6 +943,7 @@ Tuple_map_assignment_statement::do_lower(Gogo*, Named_object*,
map_index->map(), a1, a2);
ref = Expression::make_temporary_reference(present_temp, loc);
ref->set_is_lvalue();
Statement* s = Statement::make_assignment(ref, call, loc);
b->add_statement(s);
@ -979,7 +992,7 @@ class Map_assignment_statement : public Statement
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -1008,7 +1021,8 @@ Map_assignment_statement::do_traverse(Traverse* traverse)
// Lower a map assignment to a function call.
Statement*
Map_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
Map_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
Statement_inserter*)
{
source_location loc = this->location();
@ -1093,7 +1107,7 @@ class Tuple_receive_assignment_statement : public Statement
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -1125,7 +1139,8 @@ Tuple_receive_assignment_statement::do_traverse(Traverse* traverse)
Statement*
Tuple_receive_assignment_statement::do_lower(Gogo*, Named_object*,
Block* enclosing)
Block* enclosing,
Statement_inserter*)
{
source_location loc = this->location();
@ -1160,13 +1175,15 @@ Tuple_receive_assignment_statement::do_lower(Gogo*, Named_object*,
b->add_statement(closed_temp);
// closed_temp = chanrecv[23](channel, &val_temp)
Expression* ref = Expression::make_temporary_reference(val_temp, loc);
Temporary_reference_expression* ref =
Expression::make_temporary_reference(val_temp, loc);
Expression* p2 = Expression::make_unary(OPERATOR_AND, ref, loc);
Expression* call = Runtime::make_call((this->for_select_
? Runtime::CHANRECV3
: Runtime::CHANRECV2),
loc, 2, this->channel_, p2);
ref = Expression::make_temporary_reference(closed_temp, loc);
ref->set_is_lvalue();
Statement* s = Statement::make_assignment(ref, call, loc);
b->add_statement(s);
@ -1217,7 +1234,7 @@ class Tuple_type_guard_assignment_statement : public Statement
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -1256,7 +1273,8 @@ Tuple_type_guard_assignment_statement::do_traverse(Traverse* traverse)
Statement*
Tuple_type_guard_assignment_statement::do_lower(Gogo*, Named_object*,
Block* enclosing)
Block* enclosing,
Statement_inserter*)
{
source_location loc = this->location();
@ -1378,6 +1396,10 @@ class Expression_statement : public Statement
expr_(expr)
{ }
Expression*
expr()
{ return this->expr_; }
protected:
int
do_traverse(Traverse* traverse)
@ -1513,7 +1535,7 @@ class Inc_dec_statement : public Statement
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -1529,7 +1551,7 @@ class Inc_dec_statement : public Statement
// Lower to += or -=.
Statement*
Inc_dec_statement::do_lower(Gogo*, Named_object*, Block*)
Inc_dec_statement::do_lower(Gogo*, Named_object*, Block*, Statement_inserter*)
{
source_location loc = this->location();
@ -2017,6 +2039,8 @@ Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name,
Named_object* function = gogo->start_function(thunk_name, thunk_type, true,
location);
gogo->start_block(location);
// For a defer statement, start with a call to
// __go_set_defer_retaddr. */
Label* retaddr_label = NULL;
@ -2122,26 +2146,10 @@ Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name,
call_params = NULL;
}
Expression* call = Expression::make_call(func_to_call, call_params, false,
location);
// We need to lower in case this is a builtin function.
call = call->lower(gogo, function, -1);
Call_expression* call_ce = call->call_expression();
if (call_ce != NULL && may_call_recover)
call_ce->set_is_deferred();
Call_expression* call = Expression::make_call(func_to_call, call_params,
false, location);
Statement* call_statement = Statement::make_statement(call);
// We already ran the determine_types pass, so we need to run it
// just for this statement now.
call_statement->determine_types();
// Sanity check.
call->check_types(gogo);
if (call_ce != NULL && recover_arg != NULL)
call_ce->set_recover_arg(recover_arg);
gogo->add_statement(call_statement);
// If this is a defer statement, the label comes immediately after
@ -2155,6 +2163,31 @@ Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name,
gogo->add_statement(Statement::make_return_statement(vals, location));
}
Block* b = gogo->finish_block(location);
gogo->add_block(b, location);
gogo->lower_block(function, b);
// We already ran the determine_types pass, so we need to run it
// just for the call statement now. The other types are known.
call_statement->determine_types();
if (may_call_recover || recover_arg != NULL)
{
// Dig up the call expression, which may have been changed
// during lowering.
go_assert(call_statement->classification() == STATEMENT_EXPRESSION);
Expression_statement* es =
static_cast<Expression_statement*>(call_statement);
Call_expression* ce = es->expr()->call_expression();
go_assert(ce != NULL);
if (may_call_recover)
ce->set_is_deferred();
if (recover_arg != NULL)
ce->set_recover_arg(recover_arg);
}
// That is all the thunk has to do.
gogo->finish_function(location);
}
@ -2265,7 +2298,8 @@ Return_statement::do_traverse_assignments(Traverse_assignments* tassign)
// panic/recover work correctly.
Statement*
Return_statement::do_lower(Gogo*, Named_object* function, Block* enclosing)
Return_statement::do_lower(Gogo*, Named_object* function, Block* enclosing,
Statement_inserter*)
{
if (this->is_lowered_)
return this;
@ -3305,7 +3339,8 @@ Switch_statement::do_traverse(Traverse* traverse)
// of if statements.
Statement*
Switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
Switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
Statement_inserter*)
{
source_location loc = this->location();
@ -3578,7 +3613,8 @@ Type_switch_statement::do_traverse(Traverse* traverse)
// equality testing.
Statement*
Type_switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
Type_switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
Statement_inserter*)
{
const source_location loc = this->location();
@ -3629,8 +3665,9 @@ Type_switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
? Runtime::EFACETYPE
: Runtime::IFACETYPE),
loc, 1, ref);
Expression* lhs = Expression::make_temporary_reference(descriptor_temp,
loc);
Temporary_reference_expression* lhs =
Expression::make_temporary_reference(descriptor_temp, loc);
lhs->set_is_lvalue();
Statement* s = Statement::make_assignment(lhs, call, loc);
b->add_statement(s);
}
@ -3815,7 +3852,7 @@ Send_statement::do_get_backend(Translate_context* context)
call = Runtime::make_call(code, loc, 3, this->channel_, val,
Expression::make_boolean(this->for_select_, loc));
context->gogo()->lower_expression(context->function(), &call);
context->gogo()->lower_expression(context->function(), NULL, &call);
Bexpression* bcall = tree_to_expr(call->get_tree(context));
Bstatement* s = context->backend()->expression_statement(bcall);
@ -4154,7 +4191,7 @@ Select_clauses::get_backend(Translate_context* context,
Expression* nil2 = nil1->copy();
Expression* call = Runtime::make_call(Runtime::SELECT, location, 4,
zero, default_arg, nil1, nil2);
context->gogo()->lower_expression(context->function(), &call);
context->gogo()->lower_expression(context->function(), NULL, &call);
Bexpression* bcall = tree_to_expr(call->get_tree(context));
s = context->backend()->expression_statement(bcall);
}
@ -4175,7 +4212,7 @@ Select_clauses::get_backend(Translate_context* context,
Expression* chans = Expression::make_composite_literal(chan_array_type, 0,
false, chan_init,
location);
context->gogo()->lower_expression(context->function(), &chans);
context->gogo()->lower_expression(context->function(), NULL, &chans);
Temporary_statement* chan_temp = Statement::make_temporary(chan_array_type,
chans,
location);
@ -4187,7 +4224,7 @@ Select_clauses::get_backend(Translate_context* context,
0, false,
is_send_init,
location);
context->gogo()->lower_expression(context->function(), &is_sends);
context->gogo()->lower_expression(context->function(), NULL, &is_sends);
Temporary_statement* is_send_temp =
Statement::make_temporary(is_send_array_type, is_sends, location);
statements.push_back(is_send_temp->get_backend(context));
@ -4213,7 +4250,7 @@ Select_clauses::get_backend(Translate_context* context,
Expression* call = Runtime::make_call(Runtime::SELECT, location, 4,
ecount->copy(), default_arg,
chan_arg, is_send_arg);
context->gogo()->lower_expression(context->function(), &call);
context->gogo()->lower_expression(context->function(), NULL, &call);
Bexpression* bcall = tree_to_expr(call->get_tree(context));
std::vector<std::vector<Bexpression*> > cases;
@ -4309,7 +4346,7 @@ Select_statement::break_label()
Statement*
Select_statement::do_lower(Gogo* gogo, Named_object* function,
Block* enclosing)
Block* enclosing, Statement_inserter*)
{
if (this->is_lowered_)
return this;
@ -4366,7 +4403,8 @@ For_statement::do_traverse(Traverse* traverse)
// complex statements make it easier to handle garbage collection.
Statement*
For_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
For_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
Statement_inserter*)
{
Statement* s;
source_location loc = this->location();
@ -4497,7 +4535,8 @@ For_range_statement::do_traverse(Traverse* traverse)
// statements.
Statement*
For_range_statement::do_lower(Gogo* gogo, Named_object*, Block* enclosing)
For_range_statement::do_lower(Gogo* gogo, Named_object*, Block* enclosing,
Statement_inserter*)
{
Type* range_type = this->range_->type();
if (range_type->points_to() != NULL
@ -4711,8 +4750,10 @@ For_range_statement::lower_range_array(Gogo* gogo,
Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
mpz_clear(zval);
ref = Expression::make_temporary_reference(index_temp, loc);
Statement* s = Statement::make_assignment(ref, zexpr, loc);
Temporary_reference_expression* tref =
Expression::make_temporary_reference(index_temp, loc);
tref->set_is_lvalue();
Statement* s = Statement::make_assignment(tref, zexpr, loc);
init->add_statement(s);
*pinit = init;
@ -4738,8 +4779,9 @@ For_range_statement::lower_range_array(Gogo* gogo,
Expression* ref2 = Expression::make_temporary_reference(index_temp, loc);
Expression* index = Expression::make_index(ref, ref2, NULL, loc);
ref = Expression::make_temporary_reference(value_temp, loc);
s = Statement::make_assignment(ref, index, loc);
tref = Expression::make_temporary_reference(value_temp, loc);
tref->set_is_lvalue();
s = Statement::make_assignment(tref, index, loc);
iter_init->add_statement(s);
}
@ -4749,8 +4791,9 @@ For_range_statement::lower_range_array(Gogo* gogo,
// index_temp++
Block* post = new Block(enclosing, loc);
ref = Expression::make_temporary_reference(index_temp, loc);
s = Statement::make_inc_statement(ref);
tref = Expression::make_temporary_reference(index_temp, loc);
tref->set_is_lvalue();
s = Statement::make_inc_statement(tref);
post->add_statement(s);
*ppost = post;
}
@ -4798,7 +4841,9 @@ For_range_statement::lower_range_string(Gogo*,
mpz_init_set_ui(zval, 0UL);
Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
Expression* ref = Expression::make_temporary_reference(index_temp, loc);
Temporary_reference_expression* ref =
Expression::make_temporary_reference(index_temp, loc);
ref->set_is_lvalue();
Statement* s = Statement::make_assignment(ref, zexpr, loc);
init->add_statement(s);
@ -4829,14 +4874,20 @@ For_range_statement::lower_range_string(Gogo*,
if (value_temp == NULL)
{
ref = Expression::make_temporary_reference(next_index_temp, loc);
ref->set_is_lvalue();
s = Statement::make_assignment(ref, call, loc);
}
else
{
Expression_list* lhs = new Expression_list();
lhs->push_back(Expression::make_temporary_reference(next_index_temp,
loc));
lhs->push_back(Expression::make_temporary_reference(value_temp, loc));
ref = Expression::make_temporary_reference(next_index_temp, loc);
ref->set_is_lvalue();
lhs->push_back(ref);
ref = Expression::make_temporary_reference(value_temp, loc);
ref->set_is_lvalue();
lhs->push_back(ref);
Expression_list* rhs = new Expression_list();
rhs->push_back(Expression::make_call_result(call, 0));
@ -4865,7 +4916,9 @@ For_range_statement::lower_range_string(Gogo*,
Block* post = new Block(enclosing, loc);
Expression* lhs = Expression::make_temporary_reference(index_temp, loc);
Temporary_reference_expression* lhs =
Expression::make_temporary_reference(index_temp, loc);
lhs->set_is_lvalue();
Expression* rhs = Expression::make_temporary_reference(next_index_temp, loc);
s = Statement::make_assignment(lhs, rhs, loc);
@ -5024,8 +5077,12 @@ For_range_statement::lower_range_channel(Gogo*,
iter_init->add_statement(ok_temp);
Expression* cref = this->make_range_ref(range_object, range_temp, loc);
Expression* iref = Expression::make_temporary_reference(index_temp, loc);
Expression* oref = Expression::make_temporary_reference(ok_temp, loc);
Temporary_reference_expression* iref =
Expression::make_temporary_reference(index_temp, loc);
iref->set_is_lvalue();
Temporary_reference_expression* oref =
Expression::make_temporary_reference(ok_temp, loc);
oref->set_is_lvalue();
Statement* s = Statement::make_tuple_receive_assignment(iref, oref, cref,
false, loc);
iter_init->add_statement(s);

24
gcc/go/gofrontend/statements.h
View file

@ -11,6 +11,7 @@
class Gogo;
class Traverse;
class Statement_inserter;
class Block;
class Function;
class Unnamed_label;
@ -290,9 +291,11 @@ class Statement
// simplify statements for further processing. It returns the same
// Statement or a new one. FUNCTION is the function containing this
// statement. BLOCK is the block containing this statement.
// INSERTER can be used to insert new statements before this one.
Statement*
lower(Gogo* gogo, Named_object* function, Block* block)
{ return this->do_lower(gogo, function, block); }
lower(Gogo* gogo, Named_object* function, Block* block,
Statement_inserter* inserter)
{ return this->do_lower(gogo, function, block, inserter); }
// Set type information for unnamed constants.
void
@ -385,7 +388,7 @@ class Statement
// Implemented by the child class: lower this statement to a simpler
// one.
virtual Statement*
do_lower(Gogo*, Named_object*, Block*)
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*)
{ return this; }
// Implemented by child class: set type information for unnamed
@ -535,6 +538,9 @@ class Variable_declaration_statement : public Statement
bool
do_traverse_assignments(Traverse_assignments*);
Statement*
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*);
@ -566,7 +572,7 @@ class Return_statement : public Statement
do_traverse_assignments(Traverse_assignments*);
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
bool
do_may_fall_through() const
@ -806,7 +812,7 @@ class Select_statement : public Statement
{ return this->clauses_->traverse(traverse); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
void
do_determine_types()
@ -993,7 +999,7 @@ class For_statement : public Statement
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -1051,7 +1057,7 @@ class For_range_statement : public Statement
{ go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -1280,7 +1286,7 @@ class Switch_statement : public Statement
do_traverse(Traverse*);
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)
@ -1426,7 +1432,7 @@ class Type_switch_statement : public Statement
do_traverse(Traverse*);
Statement*
do_lower(Gogo*, Named_object*, Block*);
do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
Bstatement*
do_get_backend(Translate_context*)