diff options
Diffstat (limited to 'gcc-4.9/gcc/go/gofrontend/statements.cc')
| -rw-r--r-- | gcc-4.9/gcc/go/gofrontend/statements.cc | 6038 |
1 files changed, 6038 insertions, 0 deletions
diff --git a/gcc-4.9/gcc/go/gofrontend/statements.cc b/gcc-4.9/gcc/go/gofrontend/statements.cc new file mode 100644 index 000000000..d195ab984 --- /dev/null +++ b/gcc-4.9/gcc/go/gofrontend/statements.cc @@ -0,0 +1,6038 @@ +// statements.cc -- Go frontend statements. + +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "go-system.h" + +#include "go-c.h" +#include "types.h" +#include "expressions.h" +#include "gogo.h" +#include "runtime.h" +#include "backend.h" +#include "statements.h" +#include "ast-dump.h" + +// Class Statement. + +Statement::Statement(Statement_classification classification, + Location location) + : classification_(classification), location_(location) +{ +} + +Statement::~Statement() +{ +} + +// Traverse the tree. The work of walking the components is handled +// by the subclasses. + +int +Statement::traverse(Block* block, size_t* pindex, Traverse* traverse) +{ + if (this->classification_ == STATEMENT_ERROR) + return TRAVERSE_CONTINUE; + + unsigned int traverse_mask = traverse->traverse_mask(); + + if ((traverse_mask & Traverse::traverse_statements) != 0) + { + int t = traverse->statement(block, pindex, this); + if (t == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + else if (t == TRAVERSE_SKIP_COMPONENTS) + return TRAVERSE_CONTINUE; + } + + // No point in checking traverse_mask here--a statement may contain + // other blocks or statements, and if we got here we always want to + // walk them. + return this->do_traverse(traverse); +} + +// Traverse the contents of a statement. + +int +Statement::traverse_contents(Traverse* traverse) +{ + return this->do_traverse(traverse); +} + +// Traverse assignments. + +bool +Statement::traverse_assignments(Traverse_assignments* tassign) +{ + if (this->classification_ == STATEMENT_ERROR) + return false; + return this->do_traverse_assignments(tassign); +} + +// Traverse an expression in a statement. This is a helper function +// for child classes. + +int +Statement::traverse_expression(Traverse* traverse, Expression** expr) +{ + if ((traverse->traverse_mask() + & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0) + return TRAVERSE_CONTINUE; + return Expression::traverse(expr, traverse); +} + +// Traverse an expression list in a statement. This is a helper +// function for child classes. + +int +Statement::traverse_expression_list(Traverse* traverse, + Expression_list* expr_list) +{ + if (expr_list == NULL) + return TRAVERSE_CONTINUE; + if ((traverse->traverse_mask() + & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0) + return TRAVERSE_CONTINUE; + return expr_list->traverse(traverse); +} + +// Traverse a type in a statement. This is a helper function for +// child classes. + +int +Statement::traverse_type(Traverse* traverse, Type* type) +{ + if ((traverse->traverse_mask() + & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0) + return TRAVERSE_CONTINUE; + return Type::traverse(type, traverse); +} + +// Set type information for unnamed constants. This is really done by +// the child class. + +void +Statement::determine_types() +{ + this->do_determine_types(); +} + +// If this is a thunk statement, return it. + +Thunk_statement* +Statement::thunk_statement() +{ + Thunk_statement* ret = this->convert<Thunk_statement, STATEMENT_GO>(); + if (ret == NULL) + ret = this->convert<Thunk_statement, STATEMENT_DEFER>(); + return ret; +} + +// Convert a Statement to the backend representation. This is really +// done by the child class. + +Bstatement* +Statement::get_backend(Translate_context* context) +{ + if (this->classification_ == STATEMENT_ERROR) + return context->backend()->error_statement(); + return this->do_get_backend(context); +} + +// Dump AST representation for a statement to a dump context. + +void +Statement::dump_statement(Ast_dump_context* ast_dump_context) const +{ + this->do_dump_statement(ast_dump_context); +} + +// Note that this statement is erroneous. This is called by children +// when they discover an error. + +void +Statement::set_is_error() +{ + this->classification_ = STATEMENT_ERROR; +} + +// For children to call to report an error conveniently. + +void +Statement::report_error(const char* msg) +{ + error_at(this->location_, "%s", msg); + this->set_is_error(); +} + +// An error statement, used to avoid crashing after we report an +// error. + +class Error_statement : public Statement +{ + public: + Error_statement(Location location) + : Statement(STATEMENT_ERROR, location) + { } + + protected: + int + do_traverse(Traverse*) + { return TRAVERSE_CONTINUE; } + + Bstatement* + do_get_backend(Translate_context*) + { go_unreachable(); } + + void + do_dump_statement(Ast_dump_context*) const; +}; + +// Dump the AST representation for an error statement. + +void +Error_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "Error statement" << std::endl; +} + +// Make an error statement. + +Statement* +Statement::make_error_statement(Location location) +{ + return new Error_statement(location); +} + +// Class Variable_declaration_statement. + +Variable_declaration_statement::Variable_declaration_statement( + Named_object* var) + : Statement(STATEMENT_VARIABLE_DECLARATION, var->var_value()->location()), + var_(var) +{ +} + +// We don't actually traverse the variable here; it was traversed +// while traversing the Block. + +int +Variable_declaration_statement::do_traverse(Traverse*) +{ + return TRAVERSE_CONTINUE; +} + +// Traverse the assignments in a variable declaration. Note that this +// traversal is different from the usual traversal. + +bool +Variable_declaration_statement::do_traverse_assignments( + Traverse_assignments* tassign) +{ + tassign->initialize_variable(this->var_); + 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; +} + +// Flatten the variable's initialization expression. + +Statement* +Variable_declaration_statement::do_flatten(Gogo* gogo, Named_object* function, + Block*, Statement_inserter* inserter) +{ + this->var_->var_value()->flatten_init_expression(gogo, function, inserter); + return this; +} + +// Convert a variable declaration to the backend representation. + +Bstatement* +Variable_declaration_statement::do_get_backend(Translate_context* context) +{ + Variable* var = this->var_->var_value(); + Bvariable* bvar = this->var_->get_backend_variable(context->gogo(), + context->function()); + tree init = var->get_init_tree(context->gogo(), context->function()); + Bexpression* binit = init == NULL ? NULL : tree_to_expr(init); + + if (!var->is_in_heap()) + { + go_assert(binit != NULL); + return context->backend()->init_statement(bvar, binit); + } + + // Something takes the address of this variable, so the value is + // stored in the heap. Initialize it to newly allocated memory + // space, and assign the initial value to the new space. + Location loc = this->location(); + Named_object* newfn = context->gogo()->lookup_global("new"); + go_assert(newfn != NULL && newfn->is_function_declaration()); + Expression* func = Expression::make_func_reference(newfn, NULL, loc); + 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(), NULL, &call); + Temporary_statement* temp = Statement::make_temporary(NULL, call, loc); + Bstatement* btemp = temp->get_backend(context); + + Bstatement* set = NULL; + if (binit != NULL) + { + Expression* e = Expression::make_temporary_reference(temp, loc); + e = Expression::make_unary(OPERATOR_MULT, e, loc); + Bexpression* be = tree_to_expr(e->get_tree(context)); + set = context->backend()->assignment_statement(be, binit, loc); + } + + Expression* ref = Expression::make_temporary_reference(temp, loc); + Bexpression* bref = tree_to_expr(ref->get_tree(context)); + Bstatement* sinit = context->backend()->init_statement(bvar, bref); + + std::vector<Bstatement*> stats; + stats.reserve(3); + stats.push_back(btemp); + if (set != NULL) + stats.push_back(set); + stats.push_back(sinit); + return context->backend()->statement_list(stats); +} + +// Dump the AST representation for a variable declaration. + +void +Variable_declaration_statement::do_dump_statement( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + + go_assert(var_->is_variable()); + ast_dump_context->ostream() << "var " << this->var_->name() << " "; + Variable* var = this->var_->var_value(); + if (var->has_type()) + { + ast_dump_context->dump_type(var->type()); + ast_dump_context->ostream() << " "; + } + if (var->init() != NULL) + { + ast_dump_context->ostream() << "= "; + ast_dump_context->dump_expression(var->init()); + } + ast_dump_context->ostream() << std::endl; +} + +// Make a variable declaration. + +Statement* +Statement::make_variable_declaration(Named_object* var) +{ + return new Variable_declaration_statement(var); +} + +// Class Temporary_statement. + +// Return the type of the temporary variable. + +Type* +Temporary_statement::type() const +{ + return this->type_ != NULL ? this->type_ : this->init_->type(); +} + +// Traversal. + +int +Temporary_statement::do_traverse(Traverse* traverse) +{ + if (this->type_ != NULL + && this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + if (this->init_ == NULL) + return TRAVERSE_CONTINUE; + else + return this->traverse_expression(traverse, &this->init_); +} + +// Traverse assignments. + +bool +Temporary_statement::do_traverse_assignments(Traverse_assignments* tassign) +{ + if (this->init_ == NULL) + return false; + tassign->value(&this->init_, true, true); + return true; +} + +// Determine types. + +void +Temporary_statement::do_determine_types() +{ + if (this->type_ != NULL && this->type_->is_abstract()) + this->type_ = this->type_->make_non_abstract_type(); + + if (this->init_ != NULL) + { + if (this->type_ == NULL) + this->init_->determine_type_no_context(); + else + { + Type_context context(this->type_, false); + this->init_->determine_type(&context); + } + } + + if (this->type_ == NULL) + { + this->type_ = this->init_->type(); + go_assert(!this->type_->is_abstract()); + } +} + +// Check types. + +void +Temporary_statement::do_check_types(Gogo*) +{ + if (this->type_ != NULL && this->init_ != NULL) + { + std::string 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"); + else + error_at(this->location(), "incompatible types in assignment (%s)", + reason.c_str()); + this->set_is_error(); + } + } +} + +// Convert to backend representation. + +Bstatement* +Temporary_statement::do_get_backend(Translate_context* context) +{ + go_assert(this->bvariable_ == NULL); + + // FIXME: Permitting FUNCTION to be NULL here is a temporary measure + // until we have a better representation of the init function. + Named_object* function = context->function(); + Bfunction* bfunction; + if (function == NULL) + bfunction = NULL; + else + bfunction = tree_to_function(function->func_value()->get_decl()); + + Btype* btype = this->type()->get_backend(context->gogo()); + + Bexpression* binit; + if (this->init_ == NULL) + binit = NULL; + else if (this->type_ == NULL) + binit = tree_to_expr(this->init_->get_tree(context)); + else + { + Expression* init = Expression::make_cast(this->type_, this->init_, + this->location()); + context->gogo()->lower_expression(context->function(), NULL, &init); + binit = tree_to_expr(init->get_tree(context)); + } + + Bstatement* statement; + this->bvariable_ = + context->backend()->temporary_variable(bfunction, context->bblock(), + btype, binit, + this->is_address_taken_, + this->location(), &statement); + return statement; +} + +// Return the backend variable. + +Bvariable* +Temporary_statement::get_backend_variable(Translate_context* context) const +{ + if (this->bvariable_ == NULL) + { + go_assert(saw_errors()); + return context->backend()->error_variable(); + } + return this->bvariable_; +} + +// Dump the AST represemtation for a temporary statement + +void +Temporary_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_temp_variable_name(this); + if (this->type_ != NULL) + { + ast_dump_context->ostream() << " "; + ast_dump_context->dump_type(this->type_); + } + if (this->init_ != NULL) + { + ast_dump_context->ostream() << " = "; + ast_dump_context->dump_expression(this->init_); + } + ast_dump_context->ostream() << std::endl; +} + +// Make and initialize a temporary variable in BLOCK. + +Temporary_statement* +Statement::make_temporary(Type* type, Expression* init, + Location location) +{ + return new Temporary_statement(type, init, location); +} + +// An assignment statement. + +class Assignment_statement : public Statement +{ + public: + Assignment_statement(Expression* lhs, Expression* rhs, + Location location) + : Statement(STATEMENT_ASSIGNMENT, location), + 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); + + bool + do_traverse_assignments(Traverse_assignments*); + + void + do_determine_types(); + + void + do_check_types(Gogo*); + + Bstatement* + do_get_backend(Translate_context*); + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // Left hand side--the lvalue. + 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. + +int +Assignment_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->traverse_expression(traverse, &this->rhs_); +} + +bool +Assignment_statement::do_traverse_assignments(Traverse_assignments* tassign) +{ + tassign->assignment(&this->lhs_, &this->rhs_); + return true; +} + +// Set types for the assignment. + +void +Assignment_statement::do_determine_types() +{ + this->lhs_->determine_type_no_context(); + Type* rhs_context_type = this->lhs_->type(); + if (rhs_context_type->is_sink_type()) + rhs_context_type = NULL; + Type_context context(rhs_context_type, false); + this->rhs_->determine_type(&context); +} + +// Check types for an assignment. + +void +Assignment_statement::do_check_types(Gogo*) +{ + // The left hand side must be either addressable, a map index + // expression, or the blank identifier. + if (!this->lhs_->is_addressable() + && this->lhs_->map_index_expression() == NULL + && !this->lhs_->is_sink_expression()) + { + if (!this->lhs_->type()->is_error()) + this->report_error(_("invalid left hand side of assignment")); + return; + } + + Type* lhs_type = this->lhs_->type(); + Type* rhs_type = this->rhs_->type(); + + // Invalid assignment of nil to the blank identifier. + if (lhs_type->is_sink_type() + && rhs_type->is_nil_type()) + { + this->report_error(_("use of untyped nil")); + return; + } + + std::string 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"); + else + error_at(this->location(), "incompatible types in assignment (%s)", + reason.c_str()); + this->set_is_error(); + } + + if (lhs_type->is_error() || rhs_type->is_error()) + this->set_is_error(); +} + +// Convert an assignment statement to the backend representation. + +Bstatement* +Assignment_statement::do_get_backend(Translate_context* context) +{ + tree rhs_tree = this->rhs_->get_tree(context); + if (this->lhs_->is_sink_expression()) + return context->backend()->expression_statement(tree_to_expr(rhs_tree)); + tree lhs_tree = this->lhs_->get_tree(context); + rhs_tree = Expression::convert_for_assignment(context, this->lhs_->type(), + this->rhs_->type(), rhs_tree, + this->location()); + return context->backend()->assignment_statement(tree_to_expr(lhs_tree), + tree_to_expr(rhs_tree), + this->location()); +} + +// Dump the AST representation for an assignment statement. + +void +Assignment_statement::do_dump_statement(Ast_dump_context* ast_dump_context) + const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(this->lhs_); + ast_dump_context->ostream() << " = " ; + ast_dump_context->dump_expression(this->rhs_); + ast_dump_context->ostream() << std::endl; +} + +// Make an assignment statement. + +Statement* +Statement::make_assignment(Expression* lhs, Expression* rhs, + Location location) +{ + return new Assignment_statement(lhs, rhs, location); +} + +// The Move_subexpressions class is used to move all top-level +// subexpressions of an expression. This is used for things like +// index expressions in which we must evaluate the index value before +// it can be changed by a multiple assignment. + +class Move_subexpressions : public Traverse +{ + public: + Move_subexpressions(int skip, Block* block) + : Traverse(traverse_expressions), + skip_(skip), block_(block) + { } + + protected: + int + expression(Expression**); + + private: + // The number of subexpressions to skip moving. This is used to + // avoid moving the array itself, as we only need to move the index. + int skip_; + // The block where new temporary variables should be added. + Block* block_; +}; + +int +Move_subexpressions::expression(Expression** pexpr) +{ + if (this->skip_ > 0) + --this->skip_; + else if ((*pexpr)->temporary_reference_expression() == NULL) + { + Location loc = (*pexpr)->location(); + Temporary_statement* temp = Statement::make_temporary(NULL, *pexpr, loc); + this->block_->add_statement(temp); + *pexpr = Expression::make_temporary_reference(temp, loc); + } + // We only need to move top-level subexpressions. + return TRAVERSE_SKIP_COMPONENTS; +} + +// The Move_ordered_evals class is used to find any subexpressions of +// an expression that have an evaluation order dependency. It creates +// temporary variables to hold them. + +class Move_ordered_evals : public Traverse +{ + public: + Move_ordered_evals(Block* block) + : Traverse(traverse_expressions), + block_(block) + { } + + protected: + int + expression(Expression**); + + private: + // The block where new temporary variables should be added. + Block* block_; +}; + +int +Move_ordered_evals::expression(Expression** pexpr) +{ + // We have to look at subexpressions first. + if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + + int i; + if ((*pexpr)->must_eval_subexpressions_in_order(&i)) + { + Move_subexpressions ms(i, this->block_); + if ((*pexpr)->traverse_subexpressions(&ms) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + + if ((*pexpr)->must_eval_in_order()) + { + Location loc = (*pexpr)->location(); + Temporary_statement* temp = Statement::make_temporary(NULL, *pexpr, loc); + this->block_->add_statement(temp); + *pexpr = Expression::make_temporary_reference(temp, loc); + } + return TRAVERSE_SKIP_COMPONENTS; +} + +// An assignment operation statement. + +class Assignment_operation_statement : public Statement +{ + public: + Assignment_operation_statement(Operator op, Expression* lhs, Expression* rhs, + Location location) + : Statement(STATEMENT_ASSIGNMENT_OPERATION, location), + op_(op), lhs_(lhs), rhs_(rhs) + { } + + protected: + int + do_traverse(Traverse*); + + bool + do_traverse_assignments(Traverse_assignments*) + { go_unreachable(); } + + Statement* + do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); + + Bstatement* + do_get_backend(Translate_context*) + { go_unreachable(); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // The operator (OPERATOR_PLUSEQ, etc.). + Operator op_; + // Left hand side. + Expression* lhs_; + // Right hand side. + Expression* rhs_; +}; + +// Traversal. + +int +Assignment_operation_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->traverse_expression(traverse, &this->rhs_); +} + +// Lower an assignment operation statement to a regular assignment +// statement. + +Statement* +Assignment_operation_statement::do_lower(Gogo*, Named_object*, + Block* enclosing, Statement_inserter*) +{ + Location loc = this->location(); + + // We have to evaluate the left hand side expression only once. We + // do this by moving out any expression with side effects. + Block* b = new Block(enclosing, loc); + Move_ordered_evals moe(b); + this->lhs_->traverse_subexpressions(&moe); + + Expression* lval = this->lhs_->copy(); + + Operator op; + switch (this->op_) + { + case OPERATOR_PLUSEQ: + op = OPERATOR_PLUS; + break; + case OPERATOR_MINUSEQ: + op = OPERATOR_MINUS; + break; + case OPERATOR_OREQ: + op = OPERATOR_OR; + break; + case OPERATOR_XOREQ: + op = OPERATOR_XOR; + break; + case OPERATOR_MULTEQ: + op = OPERATOR_MULT; + break; + case OPERATOR_DIVEQ: + op = OPERATOR_DIV; + break; + case OPERATOR_MODEQ: + op = OPERATOR_MOD; + break; + case OPERATOR_LSHIFTEQ: + op = OPERATOR_LSHIFT; + break; + case OPERATOR_RSHIFTEQ: + op = OPERATOR_RSHIFT; + break; + case OPERATOR_ANDEQ: + op = OPERATOR_AND; + break; + case OPERATOR_BITCLEAREQ: + op = OPERATOR_BITCLEAR; + break; + default: + go_unreachable(); + } + + Expression* binop = Expression::make_binary(op, lval, this->rhs_, loc); + Statement* s = Statement::make_assignment(this->lhs_, binop, loc); + if (b->statements()->empty()) + { + delete b; + return s; + } + else + { + b->add_statement(s); + return Statement::make_block_statement(b, loc); + } +} + +// Dump the AST representation for an assignment operation statement + +void +Assignment_operation_statement::do_dump_statement( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(this->lhs_); + ast_dump_context->dump_operator(this->op_); + ast_dump_context->dump_expression(this->rhs_); + ast_dump_context->ostream() << std::endl; +} + +// Make an assignment operation statement. + +Statement* +Statement::make_assignment_operation(Operator op, Expression* lhs, + Expression* rhs, Location location) +{ + return new Assignment_operation_statement(op, lhs, rhs, location); +} + +// A tuple assignment statement. This differs from an assignment +// statement in that the right-hand-side expressions are evaluated in +// parallel. + +class Tuple_assignment_statement : public Statement +{ + public: + Tuple_assignment_statement(Expression_list* lhs, Expression_list* rhs, + Location location) + : Statement(STATEMENT_TUPLE_ASSIGNMENT, location), + 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); + + bool + do_traverse_assignments(Traverse_assignments*) + { go_unreachable(); } + + Statement* + do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); + + Bstatement* + do_get_backend(Translate_context*) + { go_unreachable(); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // Left hand side--a list of lvalues. + 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. + +int +Tuple_assignment_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression_list(traverse, this->lhs_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->traverse_expression_list(traverse, this->rhs_); +} + +// Lower a tuple assignment. We use temporary variables to split it +// up into a set of single assignments. + +Statement* +Tuple_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing, + Statement_inserter*) +{ + Location loc = this->location(); + + Block* b = new Block(enclosing, loc); + + // First move out any subexpressions on the left hand side. The + // right hand side will be evaluated in the required order anyhow. + Move_ordered_evals moe(b); + for (Expression_list::iterator plhs = this->lhs_->begin(); + plhs != this->lhs_->end(); + ++plhs) + Expression::traverse(&*plhs, &moe); + + std::vector<Temporary_statement*> temps; + temps.reserve(this->lhs_->size()); + + Expression_list::const_iterator prhs = this->rhs_->begin(); + for (Expression_list::const_iterator plhs = this->lhs_->begin(); + plhs != this->lhs_->end(); + ++plhs, ++prhs) + { + go_assert(prhs != this->rhs_->end()); + + if ((*plhs)->is_error_expression() + || (*plhs)->type()->is_error() + || (*prhs)->is_error_expression() + || (*prhs)->type()->is_error()) + continue; + + if ((*plhs)->is_sink_expression()) + { + if ((*prhs)->type()->is_nil_type()) + this->report_error(_("use of untyped nil")); + else + b->add_statement(Statement::make_statement(*prhs, true)); + continue; + } + + 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); + + } + go_assert(prhs == this->rhs_->end()); + + prhs = this->rhs_->begin(); + std::vector<Temporary_statement*>::const_iterator ptemp = temps.begin(); + for (Expression_list::const_iterator plhs = this->lhs_->begin(); + plhs != this->lhs_->end(); + ++plhs, ++prhs) + { + if ((*plhs)->is_error_expression() + || (*plhs)->type()->is_error() + || (*prhs)->is_error_expression() + || (*prhs)->type()->is_error()) + continue; + + if ((*plhs)->is_sink_expression()) + continue; + + 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; + } + go_assert(ptemp == temps.end() || saw_errors()); + + return Statement::make_block_statement(b, loc); +} + +// Dump the AST representation for a tuple assignment statement. + +void +Tuple_assignment_statement::do_dump_statement( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression_list(this->lhs_); + ast_dump_context->ostream() << " = "; + ast_dump_context->dump_expression_list(this->rhs_); + ast_dump_context->ostream() << std::endl; +} + +// Make a tuple assignment statement. + +Statement* +Statement::make_tuple_assignment(Expression_list* lhs, Expression_list* rhs, + Location location) +{ + return new Tuple_assignment_statement(lhs, rhs, location); +} + +// A tuple assignment from a map index expression. +// v, ok = m[k] + +class Tuple_map_assignment_statement : public Statement +{ +public: + Tuple_map_assignment_statement(Expression* val, Expression* present, + Expression* map_index, + Location location) + : Statement(STATEMENT_TUPLE_MAP_ASSIGNMENT, location), + val_(val), present_(present), map_index_(map_index) + { } + + protected: + int + do_traverse(Traverse* traverse); + + bool + do_traverse_assignments(Traverse_assignments*) + { go_unreachable(); } + + Statement* + do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); + + Bstatement* + do_get_backend(Translate_context*) + { go_unreachable(); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // Lvalue which receives the value from the map. + Expression* val_; + // Lvalue which receives whether the key value was present. + Expression* present_; + // The map index expression. + Expression* map_index_; +}; + +// Traversal. + +int +Tuple_map_assignment_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT + || this->traverse_expression(traverse, &this->present_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->traverse_expression(traverse, &this->map_index_); +} + +// Lower a tuple map assignment. + +Statement* +Tuple_map_assignment_statement::do_lower(Gogo*, Named_object*, + Block* enclosing, Statement_inserter*) +{ + Location loc = this->location(); + + Map_index_expression* map_index = this->map_index_->map_index_expression(); + if (map_index == NULL) + { + this->report_error(_("expected map index on right hand side")); + return Statement::make_error_statement(loc); + } + Map_type* map_type = map_index->get_map_type(); + if (map_type == NULL) + return Statement::make_error_statement(loc); + + Block* b = new Block(enclosing, loc); + + // Move out any subexpressions to make sure that functions are + // called in the required order. + Move_ordered_evals moe(b); + this->val_->traverse_subexpressions(&moe); + this->present_->traverse_subexpressions(&moe); + + // Copy the key value into a temporary so that we can take its + // address without pushing the value onto the heap. + + // var key_temp KEY_TYPE = MAP_INDEX + Temporary_statement* key_temp = + Statement::make_temporary(map_type->key_type(), map_index->index(), loc); + b->add_statement(key_temp); + + // var val_temp VAL_TYPE + Temporary_statement* val_temp = + Statement::make_temporary(map_type->val_type(), NULL, loc); + b->add_statement(val_temp); + + // var present_temp bool + Temporary_statement* present_temp = + Statement::make_temporary(Type::lookup_bool_type(), NULL, loc); + b->add_statement(present_temp); + + // present_temp = mapaccess2(DESCRIPTOR, MAP, &key_temp, &val_temp) + Expression* a1 = Expression::make_type_descriptor(map_type, loc); + Expression* a2 = map_index->map(); + Temporary_reference_expression* ref = + Expression::make_temporary_reference(key_temp, loc); + Expression* a3 = Expression::make_unary(OPERATOR_AND, ref, loc); + ref = Expression::make_temporary_reference(val_temp, loc); + Expression* a4 = Expression::make_unary(OPERATOR_AND, ref, loc); + Expression* call = Runtime::make_call(Runtime::MAPACCESS2, loc, 4, + a1, a2, a3, a4); + + ref = Expression::make_temporary_reference(present_temp, loc); + ref->set_is_lvalue(); + Statement* s = Statement::make_assignment(ref, call, loc); + b->add_statement(s); + + // val = val_temp + ref = Expression::make_temporary_reference(val_temp, loc); + s = Statement::make_assignment(this->val_, ref, loc); + b->add_statement(s); + + // present = present_temp + ref = Expression::make_temporary_reference(present_temp, loc); + s = Statement::make_assignment(this->present_, ref, loc); + b->add_statement(s); + + return Statement::make_block_statement(b, loc); +} + +// Dump the AST representation for a tuple map assignment statement. + +void +Tuple_map_assignment_statement::do_dump_statement( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(this->val_); + ast_dump_context->ostream() << ", "; + ast_dump_context->dump_expression(this->present_); + ast_dump_context->ostream() << " = "; + ast_dump_context->dump_expression(this->map_index_); + ast_dump_context->ostream() << std::endl; +} + +// Make a map assignment statement which returns a pair of values. + +Statement* +Statement::make_tuple_map_assignment(Expression* val, Expression* present, + Expression* map_index, + Location location) +{ + return new Tuple_map_assignment_statement(val, present, map_index, location); +} + +// Assign a pair of entries to a map. +// m[k] = v, p + +class Map_assignment_statement : public Statement +{ + public: + Map_assignment_statement(Expression* map_index, + Expression* val, Expression* should_set, + Location location) + : Statement(STATEMENT_MAP_ASSIGNMENT, location), + map_index_(map_index), val_(val), should_set_(should_set) + { } + + protected: + int + do_traverse(Traverse* traverse); + + bool + do_traverse_assignments(Traverse_assignments*) + { go_unreachable(); } + + Statement* + do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); + + Bstatement* + do_get_backend(Translate_context*) + { go_unreachable(); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // A reference to the map index which should be set or deleted. + Expression* map_index_; + // The value to add to the map. + Expression* val_; + // Whether or not to add the value. + Expression* should_set_; +}; + +// Traverse a map assignment. + +int +Map_assignment_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->map_index_) == TRAVERSE_EXIT + || this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->traverse_expression(traverse, &this->should_set_); +} + +// Lower a map assignment to a function call. + +Statement* +Map_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing, + Statement_inserter*) +{ + Location loc = this->location(); + + Map_index_expression* map_index = this->map_index_->map_index_expression(); + if (map_index == NULL) + { + this->report_error(_("expected map index on left hand side")); + return Statement::make_error_statement(loc); + } + Map_type* map_type = map_index->get_map_type(); + if (map_type == NULL) + return Statement::make_error_statement(loc); + + Block* b = new Block(enclosing, loc); + + // Evaluate the map first to get order of evaluation right. + // map_temp := m // we are evaluating m[k] = v, p + Temporary_statement* map_temp = Statement::make_temporary(map_type, + map_index->map(), + loc); + b->add_statement(map_temp); + + // var key_temp MAP_KEY_TYPE = k + Temporary_statement* key_temp = + Statement::make_temporary(map_type->key_type(), map_index->index(), loc); + b->add_statement(key_temp); + + // var val_temp MAP_VAL_TYPE = v + Temporary_statement* val_temp = + Statement::make_temporary(map_type->val_type(), this->val_, loc); + b->add_statement(val_temp); + + // var insert_temp bool = p + Temporary_statement* insert_temp = + Statement::make_temporary(Type::lookup_bool_type(), this->should_set_, + loc); + b->add_statement(insert_temp); + + // mapassign2(map_temp, &key_temp, &val_temp, p) + Expression* p1 = Expression::make_temporary_reference(map_temp, loc); + Expression* ref = Expression::make_temporary_reference(key_temp, loc); + Expression* p2 = Expression::make_unary(OPERATOR_AND, ref, loc); + ref = Expression::make_temporary_reference(val_temp, loc); + Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc); + Expression* p4 = Expression::make_temporary_reference(insert_temp, loc); + Expression* call = Runtime::make_call(Runtime::MAPASSIGN2, loc, 4, + p1, p2, p3, p4); + Statement* s = Statement::make_statement(call, true); + b->add_statement(s); + + return Statement::make_block_statement(b, loc); +} + +// Dump the AST representation for a map assignment statement. + +void +Map_assignment_statement::do_dump_statement( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(this->map_index_); + ast_dump_context->ostream() << " = "; + ast_dump_context->dump_expression(this->val_); + ast_dump_context->ostream() << ", "; + ast_dump_context->dump_expression(this->should_set_); + ast_dump_context->ostream() << std::endl; +} + +// Make a statement which assigns a pair of entries to a map. + +Statement* +Statement::make_map_assignment(Expression* map_index, + Expression* val, Expression* should_set, + Location location) +{ + return new Map_assignment_statement(map_index, val, should_set, location); +} + +// A tuple assignment from a receive statement. + +class Tuple_receive_assignment_statement : public Statement +{ + public: + Tuple_receive_assignment_statement(Expression* val, Expression* closed, + Expression* channel, Location location) + : Statement(STATEMENT_TUPLE_RECEIVE_ASSIGNMENT, location), + val_(val), closed_(closed), channel_(channel) + { } + + protected: + int + do_traverse(Traverse* traverse); + + bool + do_traverse_assignments(Traverse_assignments*) + { go_unreachable(); } + + Statement* + do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); + + Bstatement* + do_get_backend(Translate_context*) + { go_unreachable(); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // Lvalue which receives the value from the channel. + Expression* val_; + // Lvalue which receives whether the channel is closed. + Expression* closed_; + // The channel on which we receive the value. + Expression* channel_; +}; + +// Traversal. + +int +Tuple_receive_assignment_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT + || this->traverse_expression(traverse, &this->closed_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->traverse_expression(traverse, &this->channel_); +} + +// Lower to a function call. + +Statement* +Tuple_receive_assignment_statement::do_lower(Gogo*, Named_object*, + Block* enclosing, + Statement_inserter*) +{ + Location loc = this->location(); + + Channel_type* channel_type = this->channel_->type()->channel_type(); + if (channel_type == NULL) + { + this->report_error(_("expected channel")); + return Statement::make_error_statement(loc); + } + if (!channel_type->may_receive()) + { + this->report_error(_("invalid receive on send-only channel")); + return Statement::make_error_statement(loc); + } + + Block* b = new Block(enclosing, loc); + + // Make sure that any subexpressions on the left hand side are + // evaluated in the right order. + Move_ordered_evals moe(b); + this->val_->traverse_subexpressions(&moe); + this->closed_->traverse_subexpressions(&moe); + + // var val_temp ELEMENT_TYPE + Temporary_statement* val_temp = + Statement::make_temporary(channel_type->element_type(), NULL, loc); + b->add_statement(val_temp); + + // var closed_temp bool + Temporary_statement* closed_temp = + Statement::make_temporary(Type::lookup_bool_type(), NULL, loc); + b->add_statement(closed_temp); + + // closed_temp = chanrecv2(type, channel, &val_temp) + Expression* td = Expression::make_type_descriptor(this->channel_->type(), + 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(Runtime::CHANRECV2, + loc, 3, td, 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); + + // val = val_temp + ref = Expression::make_temporary_reference(val_temp, loc); + s = Statement::make_assignment(this->val_, ref, loc); + b->add_statement(s); + + // closed = closed_temp + ref = Expression::make_temporary_reference(closed_temp, loc); + s = Statement::make_assignment(this->closed_, ref, loc); + b->add_statement(s); + + return Statement::make_block_statement(b, loc); +} + +// Dump the AST representation for a tuple receive statement. + +void +Tuple_receive_assignment_statement::do_dump_statement( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(this->val_); + ast_dump_context->ostream() << ", "; + ast_dump_context->dump_expression(this->closed_); + ast_dump_context->ostream() << " <- "; + ast_dump_context->dump_expression(this->channel_); + ast_dump_context->ostream() << std::endl; +} + +// Make a nonblocking receive statement. + +Statement* +Statement::make_tuple_receive_assignment(Expression* val, Expression* closed, + Expression* channel, + Location location) +{ + return new Tuple_receive_assignment_statement(val, closed, channel, + location); +} + +// An assignment to a pair of values from a type guard. This is a +// conditional type guard. v, ok = i.(type). + +class Tuple_type_guard_assignment_statement : public Statement +{ + public: + Tuple_type_guard_assignment_statement(Expression* val, Expression* ok, + Expression* expr, Type* type, + Location location) + : Statement(STATEMENT_TUPLE_TYPE_GUARD_ASSIGNMENT, location), + val_(val), ok_(ok), expr_(expr), type_(type) + { } + + protected: + int + do_traverse(Traverse*); + + bool + do_traverse_assignments(Traverse_assignments*) + { go_unreachable(); } + + Statement* + do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); + + Bstatement* + do_get_backend(Translate_context*) + { go_unreachable(); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + Call_expression* + lower_to_type(Runtime::Function); + + void + lower_to_object_type(Block*, Runtime::Function); + + // The variable which recieves the converted value. + Expression* val_; + // The variable which receives the indication of success. + Expression* ok_; + // The expression being converted. + Expression* expr_; + // The type to which the expression is being converted. + Type* type_; +}; + +// Traverse a type guard tuple assignment. + +int +Tuple_type_guard_assignment_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT + || this->traverse_expression(traverse, &this->ok_) == TRAVERSE_EXIT + || this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->traverse_expression(traverse, &this->expr_); +} + +// Lower to a function call. + +Statement* +Tuple_type_guard_assignment_statement::do_lower(Gogo*, Named_object*, + Block* enclosing, + Statement_inserter*) +{ + Location loc = this->location(); + + Type* expr_type = this->expr_->type(); + if (expr_type->interface_type() == NULL) + { + if (!expr_type->is_error() && !this->type_->is_error()) + this->report_error(_("type assertion only valid for interface types")); + return Statement::make_error_statement(loc); + } + + Block* b = new Block(enclosing, loc); + + // Make sure that any subexpressions on the left hand side are + // evaluated in the right order. + Move_ordered_evals moe(b); + this->val_->traverse_subexpressions(&moe); + this->ok_->traverse_subexpressions(&moe); + + bool expr_is_empty = expr_type->interface_type()->is_empty(); + Call_expression* call; + if (this->type_->interface_type() != NULL) + { + if (this->type_->interface_type()->is_empty()) + call = Runtime::make_call((expr_is_empty + ? Runtime::IFACEE2E2 + : Runtime::IFACEI2E2), + loc, 1, this->expr_); + else + call = this->lower_to_type(expr_is_empty + ? Runtime::IFACEE2I2 + : Runtime::IFACEI2I2); + } + else if (this->type_->points_to() != NULL) + call = this->lower_to_type(expr_is_empty + ? Runtime::IFACEE2T2P + : Runtime::IFACEI2T2P); + else + { + this->lower_to_object_type(b, + (expr_is_empty + ? Runtime::IFACEE2T2 + : Runtime::IFACEI2T2)); + call = NULL; + } + + if (call != NULL) + { + Expression* res = Expression::make_call_result(call, 0); + res = Expression::make_unsafe_cast(this->type_, res, loc); + Statement* s = Statement::make_assignment(this->val_, res, loc); + b->add_statement(s); + + res = Expression::make_call_result(call, 1); + s = Statement::make_assignment(this->ok_, res, loc); + b->add_statement(s); + } + + return Statement::make_block_statement(b, loc); +} + +// Lower a conversion to a non-empty interface type or a pointer type. + +Call_expression* +Tuple_type_guard_assignment_statement::lower_to_type(Runtime::Function code) +{ + Location loc = this->location(); + return Runtime::make_call(code, loc, 2, + Expression::make_type_descriptor(this->type_, loc), + this->expr_); +} + +// Lower a conversion to a non-interface non-pointer type. + +void +Tuple_type_guard_assignment_statement::lower_to_object_type( + Block* b, + Runtime::Function code) +{ + Location loc = this->location(); + + // var val_temp TYPE + Temporary_statement* val_temp = Statement::make_temporary(this->type_, + NULL, loc); + b->add_statement(val_temp); + + // ok = CODE(type_descriptor, expr, &val_temp) + Expression* p1 = Expression::make_type_descriptor(this->type_, loc); + Expression* ref = Expression::make_temporary_reference(val_temp, loc); + Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc); + Expression* call = Runtime::make_call(code, loc, 3, p1, this->expr_, p3); + Statement* s = Statement::make_assignment(this->ok_, call, loc); + b->add_statement(s); + + // val = val_temp + ref = Expression::make_temporary_reference(val_temp, loc); + s = Statement::make_assignment(this->val_, ref, loc); + b->add_statement(s); +} + +// Dump the AST representation for a tuple type guard statement. + +void +Tuple_type_guard_assignment_statement::do_dump_statement( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(this->val_); + ast_dump_context->ostream() << ", "; + ast_dump_context->dump_expression(this->ok_); + ast_dump_context->ostream() << " = "; + ast_dump_context->dump_expression(this->expr_); + ast_dump_context->ostream() << " . "; + ast_dump_context->dump_type(this->type_); + ast_dump_context->ostream() << std::endl; +} + +// Make an assignment from a type guard to a pair of variables. + +Statement* +Statement::make_tuple_type_guard_assignment(Expression* val, Expression* ok, + Expression* expr, Type* type, + Location location) +{ + return new Tuple_type_guard_assignment_statement(val, ok, expr, type, + location); +} + +// Class Expression_statement. + +// Constructor. + +Expression_statement::Expression_statement(Expression* expr, bool is_ignored) + : Statement(STATEMENT_EXPRESSION, expr->location()), + expr_(expr), is_ignored_(is_ignored) +{ +} + +// Determine types. + +void +Expression_statement::do_determine_types() +{ + this->expr_->determine_type_no_context(); +} + +// Check the types of an expression statement. The only check we do +// is to possibly give an error about discarding the value of the +// expression. + +void +Expression_statement::do_check_types(Gogo*) +{ + if (!this->is_ignored_) + this->expr_->discarding_value(); +} + +// An expression statement is only a terminating statement if it is +// a call to panic. + +bool +Expression_statement::do_may_fall_through() const +{ + const Call_expression* call = this->expr_->call_expression(); + if (call != NULL) + { + const Expression* fn = call->fn(); + // panic is still an unknown named object. + const Unknown_expression* ue = fn->unknown_expression(); + if (ue != NULL) + { + Named_object* no = ue->named_object(); + + if (no->is_unknown()) + no = no->unknown_value()->real_named_object(); + if (no != NULL) + { + Function_type* fntype; + if (no->is_function()) + fntype = no->func_value()->type(); + else if (no->is_function_declaration()) + fntype = no->func_declaration_value()->type(); + else + fntype = NULL; + + // The builtin function panic does not return. + if (fntype != NULL && fntype->is_builtin() && no->name() == "panic") + return false; + } + } + } + return true; +} + +// Convert to backend representation. + +Bstatement* +Expression_statement::do_get_backend(Translate_context* context) +{ + tree expr_tree = this->expr_->get_tree(context); + return context->backend()->expression_statement(tree_to_expr(expr_tree)); +} + +// Dump the AST representation for an expression statement + +void +Expression_statement::do_dump_statement(Ast_dump_context* ast_dump_context) + const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(expr_); + ast_dump_context->ostream() << std::endl; +} + +// Make an expression statement from an Expression. + +Statement* +Statement::make_statement(Expression* expr, bool is_ignored) +{ + return new Expression_statement(expr, is_ignored); +} + +// A block statement--a list of statements which may include variable +// definitions. + +class Block_statement : public Statement +{ + public: + Block_statement(Block* block, Location location) + : Statement(STATEMENT_BLOCK, location), + block_(block) + { } + + protected: + int + do_traverse(Traverse* traverse) + { return this->block_->traverse(traverse); } + + void + do_determine_types() + { this->block_->determine_types(); } + + bool + do_may_fall_through() const + { return this->block_->may_fall_through(); } + + Bstatement* + do_get_backend(Translate_context* context); + + void + do_dump_statement(Ast_dump_context*) const; + + private: + Block* block_; +}; + +// Convert a block to the backend representation of a statement. + +Bstatement* +Block_statement::do_get_backend(Translate_context* context) +{ + Bblock* bblock = this->block_->get_backend(context); + return context->backend()->block_statement(bblock); +} + +// Dump the AST for a block statement + +void +Block_statement::do_dump_statement(Ast_dump_context*) const +{ + // block statement braces are dumped when traversing. +} + +// Make a block statement. + +Statement* +Statement::make_block_statement(Block* block, Location location) +{ + return new Block_statement(block, location); +} + +// An increment or decrement statement. + +class Inc_dec_statement : public Statement +{ + public: + Inc_dec_statement(bool is_inc, Expression* expr) + : Statement(STATEMENT_INCDEC, expr->location()), + expr_(expr), is_inc_(is_inc) + { } + + protected: + int + do_traverse(Traverse* traverse) + { return this->traverse_expression(traverse, &this->expr_); } + + bool + do_traverse_assignments(Traverse_assignments*) + { go_unreachable(); } + + Statement* + do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); + + Bstatement* + do_get_backend(Translate_context*) + { go_unreachable(); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // The l-value to increment or decrement. + Expression* expr_; + // Whether to increment or decrement. + bool is_inc_; +}; + +// Lower to += or -=. + +Statement* +Inc_dec_statement::do_lower(Gogo*, Named_object*, Block*, Statement_inserter*) +{ + Location loc = this->location(); + + mpz_t oval; + mpz_init_set_ui(oval, 1UL); + Expression* oexpr = Expression::make_integer(&oval, NULL, loc); + mpz_clear(oval); + + Operator op = this->is_inc_ ? OPERATOR_PLUSEQ : OPERATOR_MINUSEQ; + return Statement::make_assignment_operation(op, this->expr_, oexpr, loc); +} + +// Dump the AST representation for a inc/dec statement. + +void +Inc_dec_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(expr_); + ast_dump_context->ostream() << (is_inc_? "++": "--") << std::endl; +} + +// Make an increment statement. + +Statement* +Statement::make_inc_statement(Expression* expr) +{ + return new Inc_dec_statement(true, expr); +} + +// Make a decrement statement. + +Statement* +Statement::make_dec_statement(Expression* expr) +{ + return new Inc_dec_statement(false, expr); +} + +// Class Thunk_statement. This is the base class for go and defer +// statements. + +// Constructor. + +Thunk_statement::Thunk_statement(Statement_classification classification, + Call_expression* call, + Location location) + : Statement(classification, location), + call_(call), struct_type_(NULL) +{ +} + +// Return whether this is a simple statement which does not require a +// thunk. + +bool +Thunk_statement::is_simple(Function_type* fntype) const +{ + // We need a thunk to call a method, or to pass a variable number of + // arguments. + if (fntype->is_method() || fntype->is_varargs()) + return false; + + // A defer statement requires a thunk to set up for whether the + // function can call recover. + if (this->classification() == STATEMENT_DEFER) + return false; + + // We can only permit a single parameter of pointer type. + const Typed_identifier_list* parameters = fntype->parameters(); + if (parameters != NULL + && (parameters->size() > 1 + || (parameters->size() == 1 + && parameters->begin()->type()->points_to() == NULL))) + return false; + + // If the function returns multiple values, or returns a type other + // than integer, floating point, or pointer, then it may get a + // hidden first parameter, in which case we need the more + // complicated approach. This is true even though we are going to + // ignore the return value. + const Typed_identifier_list* results = fntype->results(); + if (results != NULL + && (results->size() > 1 + || (results->size() == 1 + && !results->begin()->type()->is_basic_type() + && results->begin()->type()->points_to() == NULL))) + return false; + + // If this calls something that is not a simple function, then we + // need a thunk. + Expression* fn = this->call_->call_expression()->fn(); + if (fn->func_expression() == NULL) + return false; + + // If the function uses a closure, then we need a thunk. FIXME: We + // could accept a zero argument function with a closure. + if (fn->func_expression()->closure() != NULL) + return false; + + return true; +} + +// Traverse a thunk statement. + +int +Thunk_statement::do_traverse(Traverse* traverse) +{ + return this->traverse_expression(traverse, &this->call_); +} + +// We implement traverse_assignment for a thunk statement because it +// effectively copies the function call. + +bool +Thunk_statement::do_traverse_assignments(Traverse_assignments* tassign) +{ + Expression* fn = this->call_->call_expression()->fn(); + Expression* fn2 = fn; + tassign->value(&fn2, true, false); + return true; +} + +// Determine types in a thunk statement. + +void +Thunk_statement::do_determine_types() +{ + this->call_->determine_type_no_context(); + + // Now that we know the types of the call, build the struct used to + // pass parameters. + Call_expression* ce = this->call_->call_expression(); + if (ce == NULL) + return; + Function_type* fntype = ce->get_function_type(); + if (fntype != NULL && !this->is_simple(fntype)) + this->struct_type_ = this->build_struct(fntype); +} + +// Check types in a thunk statement. + +void +Thunk_statement::do_check_types(Gogo*) +{ + if (!this->call_->discarding_value()) + return; + Call_expression* ce = this->call_->call_expression(); + if (ce == NULL) + { + if (!this->call_->is_error_expression()) + this->report_error("expected call expression"); + return; + } +} + +// The Traverse class used to find and simplify thunk statements. + +class Simplify_thunk_traverse : public Traverse +{ + public: + Simplify_thunk_traverse(Gogo* gogo) + : Traverse(traverse_functions | traverse_blocks), + gogo_(gogo), function_(NULL) + { } + + int + function(Named_object*); + + int + block(Block*); + + private: + // General IR. + Gogo* gogo_; + // The function we are traversing. + Named_object* function_; +}; + +// Keep track of the current function while looking for thunks. + +int +Simplify_thunk_traverse::function(Named_object* no) +{ + go_assert(this->function_ == NULL); + this->function_ = no; + int t = no->func_value()->traverse(this); + this->function_ = NULL; + if (t == TRAVERSE_EXIT) + return t; + return TRAVERSE_SKIP_COMPONENTS; +} + +// Look for thunks in a block. + +int +Simplify_thunk_traverse::block(Block* b) +{ + // The parser ensures that thunk statements always appear at the end + // of a block. + if (b->statements()->size() < 1) + return TRAVERSE_CONTINUE; + Thunk_statement* stat = b->statements()->back()->thunk_statement(); + if (stat == NULL) + return TRAVERSE_CONTINUE; + if (stat->simplify_statement(this->gogo_, this->function_, b)) + return TRAVERSE_SKIP_COMPONENTS; + return TRAVERSE_CONTINUE; +} + +// Simplify all thunk statements. + +void +Gogo::simplify_thunk_statements() +{ + Simplify_thunk_traverse thunk_traverse(this); + this->traverse(&thunk_traverse); +} + +// Return true if the thunk function is a constant, which means that +// it does not need to be passed to the thunk routine. + +bool +Thunk_statement::is_constant_function() const +{ + Call_expression* ce = this->call_->call_expression(); + Function_type* fntype = ce->get_function_type(); + if (fntype == NULL) + { + go_assert(saw_errors()); + return false; + } + if (fntype->is_builtin()) + return true; + Expression* fn = ce->fn(); + if (fn->func_expression() != NULL) + return fn->func_expression()->closure() == NULL; + if (fn->interface_field_reference_expression() != NULL) + return true; + return false; +} + +// Simplify complex thunk statements into simple ones. A complicated +// thunk statement is one which takes anything other than zero +// parameters or a single pointer parameter. We rewrite it into code +// which allocates a struct, stores the parameter values into the +// struct, and does a simple go or defer statement which passes the +// struct to a thunk. The thunk does the real call. + +bool +Thunk_statement::simplify_statement(Gogo* gogo, Named_object* function, + Block* block) +{ + if (this->classification() == STATEMENT_ERROR) + return false; + if (this->call_->is_error_expression()) + return false; + + if (this->classification() == STATEMENT_DEFER) + { + // Make sure that the defer stack exists for the function. We + // will use when converting this statement to the backend + // representation, but we want it to exist when we start + // converting the function. + function->func_value()->defer_stack(this->location()); + } + + Call_expression* ce = this->call_->call_expression(); + Function_type* fntype = ce->get_function_type(); + if (fntype == NULL) + { + go_assert(saw_errors()); + this->set_is_error(); + return false; + } + if (this->is_simple(fntype)) + return false; + + Expression* fn = ce->fn(); + Interface_field_reference_expression* interface_method = + fn->interface_field_reference_expression(); + + Location location = this->location(); + + std::string thunk_name = Gogo::thunk_name(); + + // Build the thunk. + this->build_thunk(gogo, thunk_name); + + // Generate code to call the thunk. + + // Get the values to store into the struct which is the single + // argument to the thunk. + + Expression_list* vals = new Expression_list(); + if (!this->is_constant_function()) + vals->push_back(fn); + + if (interface_method != NULL) + vals->push_back(interface_method->expr()); + + if (ce->args() != NULL) + { + for (Expression_list::const_iterator p = ce->args()->begin(); + p != ce->args()->end(); + ++p) + vals->push_back(*p); + } + + // Build the struct. + Expression* constructor = + Expression::make_struct_composite_literal(this->struct_type_, vals, + location); + + // Allocate the initialized struct on the heap. + constructor = Expression::make_heap_composite(constructor, location); + + // Look up the thunk. + Named_object* named_thunk = gogo->lookup(thunk_name, NULL); + go_assert(named_thunk != NULL && named_thunk->is_function()); + + // Build the call. + Expression* func = Expression::make_func_reference(named_thunk, NULL, + location); + Expression_list* params = new Expression_list(); + params->push_back(constructor); + Call_expression* call = Expression::make_call(func, params, false, location); + + // Build the simple go or defer statement. + Statement* s; + if (this->classification() == STATEMENT_GO) + s = Statement::make_go_statement(call, location); + else if (this->classification() == STATEMENT_DEFER) + s = Statement::make_defer_statement(call, location); + else + go_unreachable(); + + // The current block should end with the go statement. + go_assert(block->statements()->size() >= 1); + go_assert(block->statements()->back() == this); + block->replace_statement(block->statements()->size() - 1, s); + + // We already ran the determine_types pass, so we need to run it now + // for the new statement. + s->determine_types(); + + // Sanity check. + gogo->check_types_in_block(block); + + // Return true to tell the block not to keep looking at statements. + return true; +} + +// Set the name to use for thunk parameter N. + +void +Thunk_statement::thunk_field_param(int n, char* buf, size_t buflen) +{ + snprintf(buf, buflen, "a%d", n); +} + +// Build a new struct type to hold the parameters for a complicated +// thunk statement. FNTYPE is the type of the function call. + +Struct_type* +Thunk_statement::build_struct(Function_type* fntype) +{ + Location location = this->location(); + + Struct_field_list* fields = new Struct_field_list(); + + Call_expression* ce = this->call_->call_expression(); + Expression* fn = ce->fn(); + + if (!this->is_constant_function()) + { + // The function to call. + fields->push_back(Struct_field(Typed_identifier("fn", fntype, + location))); + } + + // If this thunk statement calls a method on an interface, we pass + // the interface object to the thunk. + Interface_field_reference_expression* interface_method = + fn->interface_field_reference_expression(); + if (interface_method != NULL) + { + Typed_identifier tid("object", interface_method->expr()->type(), + location); + fields->push_back(Struct_field(tid)); + } + + // The predeclared recover function has no argument. However, we + // add an argument when building recover thunks. Handle that here. + if (ce->is_recover_call()) + { + fields->push_back(Struct_field(Typed_identifier("can_recover", + Type::lookup_bool_type(), + location))); + } + + const Expression_list* args = ce->args(); + if (args != NULL) + { + int i = 0; + for (Expression_list::const_iterator p = args->begin(); + p != args->end(); + ++p, ++i) + { + char buf[50]; + this->thunk_field_param(i, buf, sizeof buf); + fields->push_back(Struct_field(Typed_identifier(buf, (*p)->type(), + location))); + } + } + + return Type::make_struct_type(fields, location); +} + +// Build the thunk we are going to call. This is a brand new, albeit +// artificial, function. + +void +Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name) +{ + Location location = this->location(); + + Call_expression* ce = this->call_->call_expression(); + + bool may_call_recover = false; + if (this->classification() == STATEMENT_DEFER) + { + Func_expression* fn = ce->fn()->func_expression(); + if (fn == NULL) + may_call_recover = true; + else + { + const Named_object* no = fn->named_object(); + if (!no->is_function()) + may_call_recover = true; + else + may_call_recover = no->func_value()->calls_recover(); + } + } + + // Build the type of the thunk. The thunk takes a single parameter, + // which is a pointer to the special structure we build. + const char* const parameter_name = "__go_thunk_parameter"; + Typed_identifier_list* thunk_parameters = new Typed_identifier_list(); + Type* pointer_to_struct_type = Type::make_pointer_type(this->struct_type_); + thunk_parameters->push_back(Typed_identifier(parameter_name, + pointer_to_struct_type, + location)); + + Typed_identifier_list* thunk_results = NULL; + if (may_call_recover) + { + // When deferring a function which may call recover, add a + // return value, to disable tail call optimizations which will + // break the way we check whether recover is permitted. + thunk_results = new Typed_identifier_list(); + thunk_results->push_back(Typed_identifier("", Type::lookup_bool_type(), + location)); + } + + Function_type* thunk_type = Type::make_function_type(NULL, thunk_parameters, + thunk_results, + location); + + // Start building the thunk. + 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; + if (may_call_recover) + { + retaddr_label = gogo->add_label_reference("retaddr", location, false); + Expression* arg = Expression::make_label_addr(retaddr_label, location); + Expression* call = Runtime::make_call(Runtime::SET_DEFER_RETADDR, + location, 1, arg); + + // This is a hack to prevent the middle-end from deleting the + // label. + gogo->start_block(location); + gogo->add_statement(Statement::make_goto_statement(retaddr_label, + location)); + Block* then_block = gogo->finish_block(location); + then_block->determine_types(); + + Statement* s = Statement::make_if_statement(call, then_block, NULL, + location); + s->determine_types(); + gogo->add_statement(s); + } + + // Get a reference to the parameter. + Named_object* named_parameter = gogo->lookup(parameter_name, NULL); + go_assert(named_parameter != NULL && named_parameter->is_variable()); + + // Build the call. Note that the field names are the same as the + // ones used in build_struct. + Expression* thunk_parameter = Expression::make_var_reference(named_parameter, + location); + thunk_parameter = Expression::make_unary(OPERATOR_MULT, thunk_parameter, + location); + + Interface_field_reference_expression* interface_method = + ce->fn()->interface_field_reference_expression(); + + Expression* func_to_call; + unsigned int next_index; + if (this->is_constant_function()) + { + func_to_call = ce->fn(); + next_index = 0; + } + else + { + func_to_call = Expression::make_field_reference(thunk_parameter, + 0, location); + next_index = 1; + } + + if (interface_method != NULL) + { + // The main program passes the interface object. + go_assert(next_index == 0); + Expression* r = Expression::make_field_reference(thunk_parameter, 0, + location); + const std::string& name(interface_method->name()); + func_to_call = Expression::make_interface_field_reference(r, name, + location); + next_index = 1; + } + + Expression_list* call_params = new Expression_list(); + const Struct_field_list* fields = this->struct_type_->fields(); + Struct_field_list::const_iterator p = fields->begin(); + for (unsigned int i = 0; i < next_index; ++i) + ++p; + bool is_recover_call = ce->is_recover_call(); + Expression* recover_arg = NULL; + for (; p != fields->end(); ++p, ++next_index) + { + Expression* thunk_param = Expression::make_var_reference(named_parameter, + location); + thunk_param = Expression::make_unary(OPERATOR_MULT, thunk_param, + location); + Expression* param = Expression::make_field_reference(thunk_param, + next_index, + location); + if (!is_recover_call) + call_params->push_back(param); + else + { + go_assert(call_params->empty()); + recover_arg = param; + } + } + + if (call_params->empty()) + { + delete call_params; + call_params = NULL; + } + + Call_expression* call = Expression::make_call(func_to_call, call_params, + false, location); + + // This call expression was already lowered before entering the + // thunk statement. Don't try to lower varargs again, as that will + // cause confusion for, e.g., method calls which already have a + // receiver parameter. + call->set_varargs_are_lowered(); + + Statement* call_statement = Statement::make_statement(call, true); + + gogo->add_statement(call_statement); + + // If this is a defer statement, the label comes immediately after + // the call. + if (may_call_recover) + { + gogo->add_label_definition("retaddr", location); + + Expression_list* vals = new Expression_list(); + vals->push_back(Expression::make_boolean(false, location)); + 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); + gogo->flatten_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(); + if (ce == NULL) + go_assert(saw_errors()); + else + { + 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); +} + +// Get the function and argument expressions. + +bool +Thunk_statement::get_fn_and_arg(Expression** pfn, Expression** parg) +{ + if (this->call_->is_error_expression()) + return false; + + Call_expression* ce = this->call_->call_expression(); + + Expression* fn = ce->fn(); + Func_expression* fe = fn->func_expression(); + go_assert(fe != NULL); + *pfn = Expression::make_func_code_reference(fe->named_object(), + fe->location()); + + const Expression_list* args = ce->args(); + if (args == NULL || args->empty()) + *parg = Expression::make_nil(this->location()); + else + { + go_assert(args->size() == 1); + *parg = args->front(); + } + + return true; +} + +// Class Go_statement. + +Bstatement* +Go_statement::do_get_backend(Translate_context* context) +{ + Expression* fn; + Expression* arg; + if (!this->get_fn_and_arg(&fn, &arg)) + return context->backend()->error_statement(); + + Expression* call = Runtime::make_call(Runtime::GO, this->location(), 2, + fn, arg); + tree call_tree = call->get_tree(context); + Bexpression* call_bexpr = tree_to_expr(call_tree); + return context->backend()->expression_statement(call_bexpr); +} + +// Dump the AST representation for go statement. + +void +Go_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "go "; + ast_dump_context->dump_expression(this->call()); + ast_dump_context->ostream() << std::endl; +} + +// Make a go statement. + +Statement* +Statement::make_go_statement(Call_expression* call, Location location) +{ + return new Go_statement(call, location); +} + +// Class Defer_statement. + +Bstatement* +Defer_statement::do_get_backend(Translate_context* context) +{ + Expression* fn; + Expression* arg; + if (!this->get_fn_and_arg(&fn, &arg)) + return context->backend()->error_statement(); + + Location loc = this->location(); + Expression* ds = context->function()->func_value()->defer_stack(loc); + + Expression* call = Runtime::make_call(Runtime::DEFER, loc, 3, + ds, fn, arg); + tree call_tree = call->get_tree(context); + Bexpression* call_bexpr = tree_to_expr(call_tree); + return context->backend()->expression_statement(call_bexpr); +} + +// Dump the AST representation for defer statement. + +void +Defer_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "defer "; + ast_dump_context->dump_expression(this->call()); + ast_dump_context->ostream() << std::endl; +} + +// Make a defer statement. + +Statement* +Statement::make_defer_statement(Call_expression* call, + Location location) +{ + return new Defer_statement(call, location); +} + +// Class Return_statement. + +// Traverse assignments. We treat each return value as a top level +// RHS in an expression. + +bool +Return_statement::do_traverse_assignments(Traverse_assignments* tassign) +{ + Expression_list* vals = this->vals_; + if (vals != NULL) + { + for (Expression_list::iterator p = vals->begin(); + p != vals->end(); + ++p) + tassign->value(&*p, true, true); + } + return true; +} + +// Lower a return statement. If we are returning a function call +// which returns multiple values which match the current function, +// split up the call's results. If the return statement lists +// explicit values, implement this statement by assigning the values +// to the result variables and change this statement to a naked +// return. This lets panic/recover work correctly. + +Statement* +Return_statement::do_lower(Gogo*, Named_object* function, Block* enclosing, + Statement_inserter*) +{ + if (this->is_lowered_) + return this; + + Expression_list* vals = this->vals_; + this->vals_ = NULL; + this->is_lowered_ = true; + + Location loc = this->location(); + + size_t vals_count = vals == NULL ? 0 : vals->size(); + Function::Results* results = function->func_value()->result_variables(); + size_t results_count = results == NULL ? 0 : results->size(); + + if (vals_count == 0) + { + if (results_count > 0 && !function->func_value()->results_are_named()) + { + this->report_error(_("not enough arguments to return")); + return this; + } + return this; + } + + if (results_count == 0) + { + this->report_error(_("return with value in function " + "with no return type")); + return this; + } + + // If the current function has multiple return values, and we are + // returning a single call expression, split up the call expression. + if (results_count > 1 + && vals->size() == 1 + && vals->front()->call_expression() != NULL) + { + Call_expression* call = vals->front()->call_expression(); + delete vals; + vals = new Expression_list; + for (size_t i = 0; i < results_count; ++i) + vals->push_back(Expression::make_call_result(call, i)); + vals_count = results_count; + } + + if (vals_count < results_count) + { + this->report_error(_("not enough arguments to return")); + return this; + } + + if (vals_count > results_count) + { + this->report_error(_("too many values in return statement")); + return this; + } + + Block* b = new Block(enclosing, loc); + + Expression_list* lhs = new Expression_list(); + Expression_list* rhs = new Expression_list(); + + Expression_list::const_iterator pe = vals->begin(); + int i = 1; + for (Function::Results::const_iterator pr = results->begin(); + pr != results->end(); + ++pr, ++pe, ++i) + { + Named_object* rv = *pr; + Expression* e = *pe; + + // Check types now so that we give a good error message. The + // result type is known. We determine the expression type + // early. + + Type *rvtype = rv->result_var_value()->type(); + Type_context type_context(rvtype, false); + e->determine_type(&type_context); + + std::string 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); + rhs->push_back(e); + } + else + { + if (reason.empty()) + error_at(e->location(), "incompatible type for return value %d", i); + else + error_at(e->location(), + "incompatible type for return value %d (%s)", + i, reason.c_str()); + } + } + go_assert(lhs->size() == rhs->size()); + + if (lhs->empty()) + ; + else if (lhs->size() == 1) + { + 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 + { + 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); + + delete vals; + + return Statement::make_block_statement(b, loc); +} + +// Convert a return statement to the backend representation. + +Bstatement* +Return_statement::do_get_backend(Translate_context* context) +{ + Location loc = this->location(); + + Function* function = context->function()->func_value(); + tree fndecl = function->get_decl(); + + Function::Results* results = function->result_variables(); + std::vector<Bexpression*> retvals; + if (results != NULL && !results->empty()) + { + retvals.reserve(results->size()); + for (Function::Results::const_iterator p = results->begin(); + p != results->end(); + p++) + { + Expression* vr = Expression::make_var_reference(*p, loc); + retvals.push_back(tree_to_expr(vr->get_tree(context))); + } + } + + return context->backend()->return_statement(tree_to_function(fndecl), + retvals, loc); +} + +// Dump the AST representation for a return statement. + +void +Return_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "return " ; + ast_dump_context->dump_expression_list(this->vals_); + ast_dump_context->ostream() << std::endl; +} + +// Make a return statement. + +Return_statement* +Statement::make_return_statement(Expression_list* vals, + Location location) +{ + return new Return_statement(vals, location); +} + +// Make a statement that returns the result of a call expression. + +Statement* +Statement::make_return_from_call(Call_expression* call, Location location) +{ + size_t rc = call->result_count(); + if (rc == 0) + return Statement::make_statement(call, true); + else + { + Expression_list* vals = new Expression_list(); + if (rc == 1) + vals->push_back(call); + else + { + for (size_t i = 0; i < rc; ++i) + vals->push_back(Expression::make_call_result(call, i)); + } + return Statement::make_return_statement(vals, location); + } +} + +// A break or continue statement. + +class Bc_statement : public Statement +{ + public: + Bc_statement(bool is_break, Unnamed_label* label, Location location) + : Statement(STATEMENT_BREAK_OR_CONTINUE, location), + label_(label), is_break_(is_break) + { } + + bool + is_break() const + { return this->is_break_; } + + protected: + int + do_traverse(Traverse*) + { return TRAVERSE_CONTINUE; } + + bool + do_may_fall_through() const + { return false; } + + Bstatement* + do_get_backend(Translate_context* context) + { return this->label_->get_goto(context, this->location()); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // The label that this branches to. + Unnamed_label* label_; + // True if this is "break", false if it is "continue". + bool is_break_; +}; + +// Dump the AST representation for a break/continue statement + +void +Bc_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << (this->is_break_ ? "break" : "continue"); + if (this->label_ != NULL) + { + ast_dump_context->ostream() << " "; + ast_dump_context->dump_label_name(this->label_); + } + ast_dump_context->ostream() << std::endl; +} + +// Make a break statement. + +Statement* +Statement::make_break_statement(Unnamed_label* label, Location location) +{ + return new Bc_statement(true, label, location); +} + +// Make a continue statement. + +Statement* +Statement::make_continue_statement(Unnamed_label* label, + Location location) +{ + return new Bc_statement(false, label, location); +} + +// A goto statement. + +class Goto_statement : public Statement +{ + public: + Goto_statement(Label* label, Location location) + : Statement(STATEMENT_GOTO, location), + label_(label) + { } + + protected: + int + do_traverse(Traverse*) + { return TRAVERSE_CONTINUE; } + + void + do_check_types(Gogo*); + + bool + do_may_fall_through() const + { return false; } + + Bstatement* + do_get_backend(Translate_context*); + + void + do_dump_statement(Ast_dump_context*) const; + + private: + Label* label_; +}; + +// Check types for a label. There aren't any types per se, but we use +// this to give an error if the label was never defined. + +void +Goto_statement::do_check_types(Gogo*) +{ + if (!this->label_->is_defined()) + { + error_at(this->location(), "reference to undefined label %qs", + Gogo::message_name(this->label_->name()).c_str()); + this->set_is_error(); + } +} + +// Convert the goto statement to the backend representation. + +Bstatement* +Goto_statement::do_get_backend(Translate_context* context) +{ + Blabel* blabel = this->label_->get_backend_label(context); + return context->backend()->goto_statement(blabel, this->location()); +} + +// Dump the AST representation for a goto statement. + +void +Goto_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "goto " << this->label_->name() << std::endl; +} + +// Make a goto statement. + +Statement* +Statement::make_goto_statement(Label* label, Location location) +{ + return new Goto_statement(label, location); +} + +// A goto statement to an unnamed label. + +class Goto_unnamed_statement : public Statement +{ + public: + Goto_unnamed_statement(Unnamed_label* label, Location location) + : Statement(STATEMENT_GOTO_UNNAMED, location), + label_(label) + { } + + protected: + int + do_traverse(Traverse*) + { return TRAVERSE_CONTINUE; } + + bool + do_may_fall_through() const + { return false; } + + Bstatement* + do_get_backend(Translate_context* context) + { return this->label_->get_goto(context, this->location()); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + Unnamed_label* label_; +}; + +// Dump the AST representation for an unnamed goto statement + +void +Goto_unnamed_statement::do_dump_statement( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "goto "; + ast_dump_context->dump_label_name(this->label_); + ast_dump_context->ostream() << std::endl; +} + +// Make a goto statement to an unnamed label. + +Statement* +Statement::make_goto_unnamed_statement(Unnamed_label* label, + Location location) +{ + return new Goto_unnamed_statement(label, location); +} + +// Class Label_statement. + +// Traversal. + +int +Label_statement::do_traverse(Traverse*) +{ + return TRAVERSE_CONTINUE; +} + +// Return the backend representation of the statement defining this +// label. + +Bstatement* +Label_statement::do_get_backend(Translate_context* context) +{ + Blabel* blabel = this->label_->get_backend_label(context); + return context->backend()->label_definition_statement(blabel); +} + +// Dump the AST for a label definition statement. + +void +Label_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << this->label_->name() << ":" << std::endl; +} + +// Make a label statement. + +Statement* +Statement::make_label_statement(Label* label, Location location) +{ + return new Label_statement(label, location); +} + +// An unnamed label statement. + +class Unnamed_label_statement : public Statement +{ + public: + Unnamed_label_statement(Unnamed_label* label) + : Statement(STATEMENT_UNNAMED_LABEL, label->location()), + label_(label) + { } + + protected: + int + do_traverse(Traverse*) + { return TRAVERSE_CONTINUE; } + + Bstatement* + do_get_backend(Translate_context* context) + { return this->label_->get_definition(context); } + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // The label. + Unnamed_label* label_; +}; + +// Dump the AST representation for an unnamed label definition statement. + +void +Unnamed_label_statement::do_dump_statement(Ast_dump_context* ast_dump_context) + const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_label_name(this->label_); + ast_dump_context->ostream() << ":" << std::endl; +} + +// Make an unnamed label statement. + +Statement* +Statement::make_unnamed_label_statement(Unnamed_label* label) +{ + return new Unnamed_label_statement(label); +} + +// An if statement. + +class If_statement : public Statement +{ + public: + If_statement(Expression* cond, Block* then_block, Block* else_block, + Location location) + : Statement(STATEMENT_IF, location), + cond_(cond), then_block_(then_block), else_block_(else_block) + { } + + protected: + int + do_traverse(Traverse*); + + void + do_determine_types(); + + void + do_check_types(Gogo*); + + bool + do_may_fall_through() const; + + Bstatement* + do_get_backend(Translate_context*); + + void + do_dump_statement(Ast_dump_context*) const; + + private: + Expression* cond_; + Block* then_block_; + Block* else_block_; +}; + +// Traversal. + +int +If_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT + || this->then_block_->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + if (this->else_block_ != NULL) + { + if (this->else_block_->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + return TRAVERSE_CONTINUE; +} + +void +If_statement::do_determine_types() +{ + Type_context context(Type::lookup_bool_type(), false); + this->cond_->determine_type(&context); + this->then_block_->determine_types(); + if (this->else_block_ != NULL) + this->else_block_->determine_types(); +} + +// Check types. + +void +If_statement::do_check_types(Gogo*) +{ + Type* type = this->cond_->type(); + if (type->is_error()) + this->set_is_error(); + else if (!type->is_boolean_type()) + this->report_error(_("expected boolean expression")); +} + +// Whether the overall statement may fall through. + +bool +If_statement::do_may_fall_through() const +{ + return (this->else_block_ == NULL + || this->then_block_->may_fall_through() + || this->else_block_->may_fall_through()); +} + +// Get the backend representation. + +Bstatement* +If_statement::do_get_backend(Translate_context* context) +{ + go_assert(this->cond_->type()->is_boolean_type() + || this->cond_->type()->is_error()); + tree cond_tree = this->cond_->get_tree(context); + Bexpression* cond_expr = tree_to_expr(cond_tree); + Bblock* then_block = this->then_block_->get_backend(context); + Bblock* else_block = (this->else_block_ == NULL + ? NULL + : this->else_block_->get_backend(context)); + return context->backend()->if_statement(cond_expr, then_block, + else_block, this->location()); +} + +// Dump the AST representation for an if statement + +void +If_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "if "; + ast_dump_context->dump_expression(this->cond_); + ast_dump_context->ostream() << std::endl; + if (ast_dump_context->dump_subblocks()) + { + ast_dump_context->dump_block(this->then_block_); + if (this->else_block_ != NULL) + { + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "else" << std::endl; + ast_dump_context->dump_block(this->else_block_); + } + } +} + +// Make an if statement. + +Statement* +Statement::make_if_statement(Expression* cond, Block* then_block, + Block* else_block, Location location) +{ + return new If_statement(cond, then_block, else_block, location); +} + +// Class Case_clauses::Hash_integer_value. + +class Case_clauses::Hash_integer_value +{ + public: + size_t + operator()(Expression*) const; +}; + +size_t +Case_clauses::Hash_integer_value::operator()(Expression* pe) const +{ + Numeric_constant nc; + mpz_t ival; + if (!pe->numeric_constant_value(&nc) || !nc.to_int(&ival)) + go_unreachable(); + size_t ret = mpz_get_ui(ival); + mpz_clear(ival); + return ret; +} + +// Class Case_clauses::Eq_integer_value. + +class Case_clauses::Eq_integer_value +{ + public: + bool + operator()(Expression*, Expression*) const; +}; + +bool +Case_clauses::Eq_integer_value::operator()(Expression* a, Expression* b) const +{ + Numeric_constant anc; + mpz_t aval; + Numeric_constant bnc; + mpz_t bval; + if (!a->numeric_constant_value(&anc) + || !anc.to_int(&aval) + || !b->numeric_constant_value(&bnc) + || !bnc.to_int(&bval)) + go_unreachable(); + bool ret = mpz_cmp(aval, bval) == 0; + mpz_clear(aval); + mpz_clear(bval); + return ret; +} + +// Class Case_clauses::Case_clause. + +// Traversal. + +int +Case_clauses::Case_clause::traverse(Traverse* traverse) +{ + if (this->cases_ != NULL + && (traverse->traverse_mask() + & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0) + { + if (this->cases_->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + if (this->statements_ != NULL) + { + if (this->statements_->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + return TRAVERSE_CONTINUE; +} + +// Check whether all the case expressions are integer constants. + +bool +Case_clauses::Case_clause::is_constant() const +{ + if (this->cases_ != NULL) + { + for (Expression_list::const_iterator p = this->cases_->begin(); + p != this->cases_->end(); + ++p) + if (!(*p)->is_constant() || (*p)->type()->integer_type() == NULL) + return false; + } + return true; +} + +// Lower a case clause for a nonconstant switch. VAL_TEMP is the +// value we are switching on; it may be NULL. If START_LABEL is not +// NULL, it goes at the start of the statements, after the condition +// test. We branch to FINISH_LABEL at the end of the statements. + +void +Case_clauses::Case_clause::lower(Block* b, Temporary_statement* val_temp, + Unnamed_label* start_label, + Unnamed_label* finish_label) const +{ + Location loc = this->location_; + Unnamed_label* next_case_label; + if (this->cases_ == NULL || this->cases_->empty()) + { + go_assert(this->is_default_); + next_case_label = NULL; + } + else + { + Expression* cond = NULL; + + for (Expression_list::const_iterator p = this->cases_->begin(); + p != this->cases_->end(); + ++p) + { + Expression* ref = Expression::make_temporary_reference(val_temp, + loc); + Expression* this_cond = Expression::make_binary(OPERATOR_EQEQ, ref, + *p, loc); + if (cond == NULL) + cond = this_cond; + else + cond = Expression::make_binary(OPERATOR_OROR, cond, this_cond, loc); + } + + Block* then_block = new Block(b, loc); + next_case_label = new Unnamed_label(Linemap::unknown_location()); + Statement* s = Statement::make_goto_unnamed_statement(next_case_label, + loc); + then_block->add_statement(s); + + // if !COND { goto NEXT_CASE_LABEL } + cond = Expression::make_unary(OPERATOR_NOT, cond, loc); + s = Statement::make_if_statement(cond, then_block, NULL, loc); + b->add_statement(s); + } + + if (start_label != NULL) + b->add_statement(Statement::make_unnamed_label_statement(start_label)); + + if (this->statements_ != NULL) + b->add_statement(Statement::make_block_statement(this->statements_, loc)); + + Statement* s = Statement::make_goto_unnamed_statement(finish_label, loc); + b->add_statement(s); + + if (next_case_label != NULL) + b->add_statement(Statement::make_unnamed_label_statement(next_case_label)); +} + +// Determine types. + +void +Case_clauses::Case_clause::determine_types(Type* type) +{ + if (this->cases_ != NULL) + { + Type_context case_context(type, false); + for (Expression_list::iterator p = this->cases_->begin(); + p != this->cases_->end(); + ++p) + (*p)->determine_type(&case_context); + } + if (this->statements_ != NULL) + this->statements_->determine_types(); +} + +// Check types. Returns false if there was an error. + +bool +Case_clauses::Case_clause::check_types(Type* type) +{ + if (this->cases_ != NULL) + { + for (Expression_list::iterator p = this->cases_->begin(); + p != this->cases_->end(); + ++p) + { + if (!Type::are_assignable(type, (*p)->type(), NULL) + && !Type::are_assignable((*p)->type(), type, NULL)) + { + error_at((*p)->location(), + "type mismatch between switch value and case clause"); + return false; + } + } + } + return true; +} + +// Return true if this clause may fall through to the following +// statements. Note that this is not the same as whether the case +// uses the "fallthrough" keyword. + +bool +Case_clauses::Case_clause::may_fall_through() const +{ + if (this->statements_ == NULL) + return true; + return this->statements_->may_fall_through(); +} + +// Convert the case values and statements to the backend +// representation. BREAK_LABEL is the label which break statements +// should branch to. CASE_CONSTANTS is used to detect duplicate +// constants. *CASES should be passed as an empty vector; the values +// for this case will be added to it. If this is the default case, +// *CASES will remain empty. This returns the statement to execute if +// one of these cases is selected. + +Bstatement* +Case_clauses::Case_clause::get_backend(Translate_context* context, + Unnamed_label* break_label, + Case_constants* case_constants, + std::vector<Bexpression*>* cases) const +{ + if (this->cases_ != NULL) + { + go_assert(!this->is_default_); + for (Expression_list::const_iterator p = this->cases_->begin(); + p != this->cases_->end(); + ++p) + { + Expression* e = *p; + if (e->classification() != Expression::EXPRESSION_INTEGER) + { + Numeric_constant nc; + mpz_t ival; + if (!(*p)->numeric_constant_value(&nc) || !nc.to_int(&ival)) + { + // Something went wrong. This can happen with a + // negative constant and an unsigned switch value. + go_assert(saw_errors()); + continue; + } + go_assert(nc.type() != NULL); + e = Expression::make_integer(&ival, nc.type(), e->location()); + mpz_clear(ival); + } + + std::pair<Case_constants::iterator, bool> ins = + case_constants->insert(e); + if (!ins.second) + { + // Value was already present. + error_at(this->location_, "duplicate case in switch"); + e = Expression::make_error(this->location_); + } + + tree case_tree = e->get_tree(context); + Bexpression* case_expr = tree_to_expr(case_tree); + cases->push_back(case_expr); + } + } + + Bstatement* statements; + if (this->statements_ == NULL) + statements = NULL; + else + { + Bblock* bblock = this->statements_->get_backend(context); + statements = context->backend()->block_statement(bblock); + } + + Bstatement* break_stat; + if (this->is_fallthrough_) + break_stat = NULL; + else + break_stat = break_label->get_goto(context, this->location_); + + if (statements == NULL) + return break_stat; + else if (break_stat == NULL) + return statements; + else + return context->backend()->compound_statement(statements, break_stat); +} + +// Dump the AST representation for a case clause + +void +Case_clauses::Case_clause::dump_clause(Ast_dump_context* ast_dump_context) + const +{ + ast_dump_context->print_indent(); + if (this->is_default_) + { + ast_dump_context->ostream() << "default:"; + } + else + { + ast_dump_context->ostream() << "case "; + ast_dump_context->dump_expression_list(this->cases_); + ast_dump_context->ostream() << ":" ; + } + ast_dump_context->dump_block(this->statements_); + if (this->is_fallthrough_) + { + ast_dump_context->print_indent(); + ast_dump_context->ostream() << " (fallthrough)" << std::endl; + } +} + +// Class Case_clauses. + +// Traversal. + +int +Case_clauses::traverse(Traverse* traverse) +{ + for (Clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + if (p->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + return TRAVERSE_CONTINUE; +} + +// Check whether all the case expressions are constant. + +bool +Case_clauses::is_constant() const +{ + for (Clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + if (!p->is_constant()) + return false; + return true; +} + +// Lower case clauses for a nonconstant switch. + +void +Case_clauses::lower(Block* b, Temporary_statement* val_temp, + Unnamed_label* break_label) const +{ + // The default case. + const Case_clause* default_case = NULL; + + // The label for the fallthrough of the previous case. + Unnamed_label* last_fallthrough_label = NULL; + + // The label for the start of the default case. This is used if the + // case before the default case falls through. + Unnamed_label* default_start_label = NULL; + + // The label for the end of the default case. This normally winds + // up as BREAK_LABEL, but it will be different if the default case + // falls through. + Unnamed_label* default_finish_label = NULL; + + for (Clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + // The label to use for the start of the statements for this + // case. This is NULL unless the previous case falls through. + Unnamed_label* start_label = last_fallthrough_label; + + // The label to jump to after the end of the statements for this + // case. + Unnamed_label* finish_label = break_label; + + last_fallthrough_label = NULL; + if (p->is_fallthrough() && p + 1 != this->clauses_.end()) + { + finish_label = new Unnamed_label(p->location()); + last_fallthrough_label = finish_label; + } + + if (!p->is_default()) + p->lower(b, val_temp, start_label, finish_label); + else + { + // We have to move the default case to the end, so that we + // only use it if all the other tests fail. + default_case = &*p; + default_start_label = start_label; + default_finish_label = finish_label; + } + } + + if (default_case != NULL) + default_case->lower(b, val_temp, default_start_label, + default_finish_label); +} + +// Determine types. + +void +Case_clauses::determine_types(Type* type) +{ + for (Clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + p->determine_types(type); +} + +// Check types. Returns false if there was an error. + +bool +Case_clauses::check_types(Type* type) +{ + bool ret = true; + for (Clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + if (!p->check_types(type)) + ret = false; + } + return ret; +} + +// Return true if these clauses may fall through to the statements +// following the switch statement. + +bool +Case_clauses::may_fall_through() const +{ + bool found_default = false; + for (Clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + if (p->may_fall_through() && !p->is_fallthrough()) + return true; + if (p->is_default()) + found_default = true; + } + return !found_default; +} + +// Convert the cases to the backend representation. This sets +// *ALL_CASES and *ALL_STATEMENTS. + +void +Case_clauses::get_backend(Translate_context* context, + Unnamed_label* break_label, + std::vector<std::vector<Bexpression*> >* all_cases, + std::vector<Bstatement*>* all_statements) const +{ + Case_constants case_constants; + + size_t c = this->clauses_.size(); + all_cases->resize(c); + all_statements->resize(c); + + size_t i = 0; + for (Clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p, ++i) + { + std::vector<Bexpression*> cases; + Bstatement* stat = p->get_backend(context, break_label, &case_constants, + &cases); + (*all_cases)[i].swap(cases); + (*all_statements)[i] = stat; + } +} + +// Dump the AST representation for case clauses (from a switch statement) + +void +Case_clauses::dump_clauses(Ast_dump_context* ast_dump_context) const +{ + for (Clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + p->dump_clause(ast_dump_context); +} + +// A constant switch statement. A Switch_statement is lowered to this +// when all the cases are constants. + +class Constant_switch_statement : public Statement +{ + public: + Constant_switch_statement(Expression* val, Case_clauses* clauses, + Unnamed_label* break_label, + Location location) + : Statement(STATEMENT_CONSTANT_SWITCH, location), + val_(val), clauses_(clauses), break_label_(break_label) + { } + + protected: + int + do_traverse(Traverse*); + + void + do_determine_types(); + + void + do_check_types(Gogo*); + + Bstatement* + do_get_backend(Translate_context*); + + void + do_dump_statement(Ast_dump_context*) const; + + private: + // The value to switch on. + Expression* val_; + // The case clauses. + Case_clauses* clauses_; + // The break label, if needed. + Unnamed_label* break_label_; +}; + +// Traversal. + +int +Constant_switch_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->clauses_->traverse(traverse); +} + +// Determine types. + +void +Constant_switch_statement::do_determine_types() +{ + this->val_->determine_type_no_context(); + this->clauses_->determine_types(this->val_->type()); +} + +// Check types. + +void +Constant_switch_statement::do_check_types(Gogo*) +{ + if (!this->clauses_->check_types(this->val_->type())) + this->set_is_error(); +} + +// Convert to GENERIC. + +Bstatement* +Constant_switch_statement::do_get_backend(Translate_context* context) +{ + tree switch_val_tree = this->val_->get_tree(context); + Bexpression* switch_val_expr = tree_to_expr(switch_val_tree); + + Unnamed_label* break_label = this->break_label_; + if (break_label == NULL) + break_label = new Unnamed_label(this->location()); + + std::vector<std::vector<Bexpression*> > all_cases; + std::vector<Bstatement*> all_statements; + this->clauses_->get_backend(context, break_label, &all_cases, + &all_statements); + + Bstatement* switch_statement; + switch_statement = context->backend()->switch_statement(switch_val_expr, + all_cases, + all_statements, + this->location()); + Bstatement* ldef = break_label->get_definition(context); + return context->backend()->compound_statement(switch_statement, ldef); +} + +// Dump the AST representation for a constant switch statement. + +void +Constant_switch_statement::do_dump_statement(Ast_dump_context* ast_dump_context) + const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "switch "; + ast_dump_context->dump_expression(this->val_); + + if (ast_dump_context->dump_subblocks()) + { + ast_dump_context->ostream() << " {" << std::endl; + this->clauses_->dump_clauses(ast_dump_context); + ast_dump_context->ostream() << "}"; + } + + ast_dump_context->ostream() << std::endl; +} + +// Class Switch_statement. + +// Traversal. + +int +Switch_statement::do_traverse(Traverse* traverse) +{ + if (this->val_ != NULL) + { + if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + return this->clauses_->traverse(traverse); +} + +// Lower a Switch_statement to a Constant_switch_statement or a series +// of if statements. + +Statement* +Switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing, + Statement_inserter*) +{ + Location loc = this->location(); + + if (this->val_ != NULL + && (this->val_->is_error_expression() + || this->val_->type()->is_error())) + return Statement::make_error_statement(loc); + + if (this->val_ != NULL + && this->val_->type()->integer_type() != NULL + && !this->clauses_->empty() + && this->clauses_->is_constant()) + return new Constant_switch_statement(this->val_, this->clauses_, + this->break_label_, loc); + + if (this->val_ != NULL + && !this->val_->type()->is_comparable() + && !Type::are_compatible_for_comparison(true, this->val_->type(), + Type::make_nil_type(), NULL)) + { + error_at(this->val_->location(), + "cannot switch on value whose type that may not be compared"); + return Statement::make_error_statement(loc); + } + + Block* b = new Block(enclosing, loc); + + if (this->clauses_->empty()) + { + Expression* val = this->val_; + if (val == NULL) + val = Expression::make_boolean(true, loc); + return Statement::make_statement(val, true); + } + + // var val_temp VAL_TYPE = VAL + Expression* val = this->val_; + if (val == NULL) + val = Expression::make_boolean(true, loc); + Temporary_statement* val_temp = Statement::make_temporary(NULL, val, loc); + b->add_statement(val_temp); + + this->clauses_->lower(b, val_temp, this->break_label()); + + Statement* s = Statement::make_unnamed_label_statement(this->break_label_); + b->add_statement(s); + + return Statement::make_block_statement(b, loc); +} + +// Return the break label for this switch statement, creating it if +// necessary. + +Unnamed_label* +Switch_statement::break_label() +{ + if (this->break_label_ == NULL) + this->break_label_ = new Unnamed_label(this->location()); + return this->break_label_; +} + +// Dump the AST representation for a switch statement. + +void +Switch_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "switch "; + if (this->val_ != NULL) + { + ast_dump_context->dump_expression(this->val_); + } + if (ast_dump_context->dump_subblocks()) + { + ast_dump_context->ostream() << " {" << std::endl; + this->clauses_->dump_clauses(ast_dump_context); + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "}"; + } + ast_dump_context->ostream() << std::endl; +} + +// Return whether this switch may fall through. + +bool +Switch_statement::do_may_fall_through() const +{ + if (this->clauses_ == NULL) + return true; + + // If we have a break label, then some case needed it. That implies + // that the switch statement as a whole can fall through. + if (this->break_label_ != NULL) + return true; + + return this->clauses_->may_fall_through(); +} + +// Make a switch statement. + +Switch_statement* +Statement::make_switch_statement(Expression* val, Location location) +{ + return new Switch_statement(val, location); +} + +// Class Type_case_clauses::Type_case_clause. + +// Traversal. + +int +Type_case_clauses::Type_case_clause::traverse(Traverse* traverse) +{ + if (!this->is_default_ + && ((traverse->traverse_mask() + & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0) + && Type::traverse(this->type_, traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + if (this->statements_ != NULL) + return this->statements_->traverse(traverse); + return TRAVERSE_CONTINUE; +} + +// Lower one clause in a type switch. Add statements to the block B. +// The type descriptor we are switching on is in DESCRIPTOR_TEMP. +// BREAK_LABEL is the label at the end of the type switch. +// *STMTS_LABEL, if not NULL, is a label to put at the start of the +// statements. + +void +Type_case_clauses::Type_case_clause::lower(Type* switch_val_type, + Block* b, + Temporary_statement* descriptor_temp, + Unnamed_label* break_label, + Unnamed_label** stmts_label) const +{ + Location loc = this->location_; + + Unnamed_label* next_case_label = NULL; + if (!this->is_default_) + { + Type* type = this->type_; + + std::string reason; + if (switch_val_type->interface_type() != NULL + && !type->is_nil_constant_as_type() + && type->interface_type() == NULL + && !switch_val_type->interface_type()->implements_interface(type, + &reason)) + { + if (reason.empty()) + error_at(this->location_, "impossible type switch case"); + else + error_at(this->location_, "impossible type switch case (%s)", + reason.c_str()); + } + + Expression* ref = Expression::make_temporary_reference(descriptor_temp, + loc); + + Expression* cond; + // The language permits case nil, which is of course a constant + // rather than a type. It will appear here as an invalid + // forwarding type. + if (type->is_nil_constant_as_type()) + cond = Expression::make_binary(OPERATOR_EQEQ, ref, + Expression::make_nil(loc), + loc); + else + cond = Runtime::make_call((type->interface_type() == NULL + ? Runtime::IFACETYPEEQ + : Runtime::IFACEI2TP), + loc, 2, + Expression::make_type_descriptor(type, loc), + ref); + + Unnamed_label* dest; + if (!this->is_fallthrough_) + { + // if !COND { goto NEXT_CASE_LABEL } + next_case_label = new Unnamed_label(Linemap::unknown_location()); + dest = next_case_label; + cond = Expression::make_unary(OPERATOR_NOT, cond, loc); + } + else + { + // if COND { goto STMTS_LABEL } + go_assert(stmts_label != NULL); + if (*stmts_label == NULL) + *stmts_label = new Unnamed_label(Linemap::unknown_location()); + dest = *stmts_label; + } + Block* then_block = new Block(b, loc); + Statement* s = Statement::make_goto_unnamed_statement(dest, loc); + then_block->add_statement(s); + s = Statement::make_if_statement(cond, then_block, NULL, loc); + b->add_statement(s); + } + + if (this->statements_ != NULL + || (!this->is_fallthrough_ + && stmts_label != NULL + && *stmts_label != NULL)) + { + go_assert(!this->is_fallthrough_); + if (stmts_label != NULL && *stmts_label != NULL) + { + go_assert(!this->is_default_); + if (this->statements_ != NULL) + (*stmts_label)->set_location(this->statements_->start_location()); + Statement* s = Statement::make_unnamed_label_statement(*stmts_label); + b->add_statement(s); + *stmts_label = NULL; + } + if (this->statements_ != NULL) + b->add_statement(Statement::make_block_statement(this->statements_, + loc)); + } + + if (this->is_fallthrough_) + go_assert(next_case_label == NULL); + else + { + Location gloc = (this->statements_ == NULL + ? loc + : this->statements_->end_location()); + b->add_statement(Statement::make_goto_unnamed_statement(break_label, + gloc)); + if (next_case_label != NULL) + { + Statement* s = + Statement::make_unnamed_label_statement(next_case_label); + b->add_statement(s); + } + } +} + +// Return true if this type clause may fall through to the statements +// following the switch. + +bool +Type_case_clauses::Type_case_clause::may_fall_through() const +{ + if (this->is_fallthrough_) + { + // This case means that we automatically fall through to the + // next case (it's used for T1 in case T1, T2:). It does not + // mean that we fall through to the end of the type switch as a + // whole. There is sure to be a next case and that next case + // will determine whether we fall through to the statements + // after the type switch. + return false; + } + if (this->statements_ == NULL) + return true; + return this->statements_->may_fall_through(); +} + +// Dump the AST representation for a type case clause + +void +Type_case_clauses::Type_case_clause::dump_clause( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + if (this->is_default_) + { + ast_dump_context->ostream() << "default:"; + } + else + { + ast_dump_context->ostream() << "case "; + ast_dump_context->dump_type(this->type_); + ast_dump_context->ostream() << ":" ; + } + ast_dump_context->dump_block(this->statements_); + if (this->is_fallthrough_) + { + ast_dump_context->print_indent(); + ast_dump_context->ostream() << " (fallthrough)" << std::endl; + } +} + +// Class Type_case_clauses. + +// Traversal. + +int +Type_case_clauses::traverse(Traverse* traverse) +{ + for (Type_clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + if (p->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + return TRAVERSE_CONTINUE; +} + +// Check for duplicate types. + +void +Type_case_clauses::check_duplicates() const +{ + typedef Unordered_set_hash(const Type*, Type_hash_identical, + Type_identical) Types_seen; + Types_seen types_seen; + for (Type_clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + Type* t = p->type(); + if (t == NULL) + continue; + if (t->is_nil_constant_as_type()) + t = Type::make_nil_type(); + std::pair<Types_seen::iterator, bool> ins = types_seen.insert(t); + if (!ins.second) + error_at(p->location(), "duplicate type in switch"); + } +} + +// Lower the clauses in a type switch. Add statements to the block B. +// The type descriptor we are switching on is in DESCRIPTOR_TEMP. +// BREAK_LABEL is the label at the end of the type switch. + +void +Type_case_clauses::lower(Type* switch_val_type, Block* b, + Temporary_statement* descriptor_temp, + Unnamed_label* break_label) const +{ + const Type_case_clause* default_case = NULL; + + Unnamed_label* stmts_label = NULL; + for (Type_clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + if (!p->is_default()) + p->lower(switch_val_type, b, descriptor_temp, break_label, + &stmts_label); + else + { + // We are generating a series of tests, which means that we + // need to move the default case to the end. + default_case = &*p; + } + } + go_assert(stmts_label == NULL); + + if (default_case != NULL) + default_case->lower(switch_val_type, b, descriptor_temp, break_label, + NULL); +} + +// Return true if these clauses may fall through to the statements +// following the switch statement. + +bool +Type_case_clauses::may_fall_through() const +{ + bool found_default = false; + for (Type_clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + if (p->may_fall_through()) + return true; + if (p->is_default()) + found_default = true; + } + return !found_default; +} + +// Dump the AST representation for case clauses (from a switch statement) + +void +Type_case_clauses::dump_clauses(Ast_dump_context* ast_dump_context) const +{ + for (Type_clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + p->dump_clause(ast_dump_context); +} + +// Class Type_switch_statement. + +// Traversal. + +int +Type_switch_statement::do_traverse(Traverse* traverse) +{ + if (this->var_ == NULL) + { + if (this->traverse_expression(traverse, &this->expr_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + if (this->clauses_ != NULL) + return this->clauses_->traverse(traverse); + return TRAVERSE_CONTINUE; +} + +// Lower a type switch statement to a series of if statements. The gc +// compiler is able to generate a table in some cases. However, that +// does not work for us because we may have type descriptors in +// different shared libraries, so we can't compare them with simple +// equality testing. + +Statement* +Type_switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing, + Statement_inserter*) +{ + const Location loc = this->location(); + + if (this->clauses_ != NULL) + this->clauses_->check_duplicates(); + + Block* b = new Block(enclosing, loc); + + Type* val_type = (this->var_ != NULL + ? this->var_->var_value()->type() + : this->expr_->type()); + + if (val_type->interface_type() == NULL) + { + if (!val_type->is_error()) + this->report_error(_("cannot type switch on non-interface value")); + return Statement::make_error_statement(loc); + } + + // var descriptor_temp DESCRIPTOR_TYPE + Type* descriptor_type = Type::make_type_descriptor_ptr_type(); + Temporary_statement* descriptor_temp = + Statement::make_temporary(descriptor_type, NULL, loc); + b->add_statement(descriptor_temp); + + // descriptor_temp = ifacetype(val_temp) FIXME: This should be + // inlined. + bool is_empty = val_type->interface_type()->is_empty(); + Expression* ref; + if (this->var_ == NULL) + ref = this->expr_; + else + ref = Expression::make_var_reference(this->var_, loc); + Expression* call = Runtime::make_call((is_empty + ? Runtime::EFACETYPE + : Runtime::IFACETYPE), + loc, 1, ref); + 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); + + if (this->clauses_ != NULL) + this->clauses_->lower(val_type, b, descriptor_temp, this->break_label()); + + s = Statement::make_unnamed_label_statement(this->break_label_); + b->add_statement(s); + + return Statement::make_block_statement(b, loc); +} + +// Return whether this switch may fall through. + +bool +Type_switch_statement::do_may_fall_through() const +{ + if (this->clauses_ == NULL) + return true; + + // If we have a break label, then some case needed it. That implies + // that the switch statement as a whole can fall through. + if (this->break_label_ != NULL) + return true; + + return this->clauses_->may_fall_through(); +} + +// Return the break label for this type switch statement, creating it +// if necessary. + +Unnamed_label* +Type_switch_statement::break_label() +{ + if (this->break_label_ == NULL) + this->break_label_ = new Unnamed_label(this->location()); + return this->break_label_; +} + +// Dump the AST representation for a type switch statement + +void +Type_switch_statement::do_dump_statement(Ast_dump_context* ast_dump_context) + const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "switch " << this->var_->name() << " = "; + ast_dump_context->dump_expression(this->expr_); + ast_dump_context->ostream() << " .(type)"; + if (ast_dump_context->dump_subblocks()) + { + ast_dump_context->ostream() << " {" << std::endl; + this->clauses_->dump_clauses(ast_dump_context); + ast_dump_context->ostream() << "}"; + } + ast_dump_context->ostream() << std::endl; +} + +// Make a type switch statement. + +Type_switch_statement* +Statement::make_type_switch_statement(Named_object* var, Expression* expr, + Location location) +{ + return new Type_switch_statement(var, expr, location); +} + +// Class Send_statement. + +// Traversal. + +int +Send_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->channel_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->traverse_expression(traverse, &this->val_); +} + +// Determine types. + +void +Send_statement::do_determine_types() +{ + this->channel_->determine_type_no_context(); + Type* type = this->channel_->type(); + Type_context context; + if (type->channel_type() != NULL) + context.type = type->channel_type()->element_type(); + this->val_->determine_type(&context); +} + +// Check types. + +void +Send_statement::do_check_types(Gogo*) +{ + Type* type = this->channel_->type(); + if (type->is_error()) + { + this->set_is_error(); + return; + } + Channel_type* channel_type = type->channel_type(); + if (channel_type == NULL) + { + error_at(this->location(), "left operand of %<<-%> must be channel"); + this->set_is_error(); + return; + } + Type* element_type = channel_type->element_type(); + if (!Type::are_assignable(element_type, this->val_->type(), NULL)) + { + this->report_error(_("incompatible types in send")); + return; + } + if (!channel_type->may_send()) + { + this->report_error(_("invalid send on receive-only channel")); + return; + } +} + +// Convert a send statement to the backend representation. + +Bstatement* +Send_statement::do_get_backend(Translate_context* context) +{ + Location loc = this->location(); + + Channel_type* channel_type = this->channel_->type()->channel_type(); + Type* element_type = channel_type->element_type(); + Expression* val = Expression::make_cast(element_type, this->val_, loc); + + bool is_small; + bool can_take_address; + switch (element_type->base()->classification()) + { + case Type::TYPE_BOOLEAN: + case Type::TYPE_INTEGER: + case Type::TYPE_FUNCTION: + case Type::TYPE_POINTER: + case Type::TYPE_MAP: + case Type::TYPE_CHANNEL: + is_small = true; + can_take_address = false; + break; + + case Type::TYPE_FLOAT: + case Type::TYPE_COMPLEX: + case Type::TYPE_STRING: + case Type::TYPE_INTERFACE: + is_small = false; + can_take_address = false; + break; + + case Type::TYPE_STRUCT: + is_small = false; + can_take_address = true; + break; + + case Type::TYPE_ARRAY: + is_small = false; + can_take_address = !element_type->is_slice_type(); + break; + + default: + case Type::TYPE_ERROR: + case Type::TYPE_VOID: + case Type::TYPE_SINK: + case Type::TYPE_NIL: + case Type::TYPE_NAMED: + case Type::TYPE_FORWARD: + go_assert(saw_errors()); + return context->backend()->error_statement(); + } + + // Only try to take the address of a variable. We have already + // moved variables to the heap, so this should not cause that to + // happen unnecessarily. + if (can_take_address + && val->var_expression() == NULL + && val->temporary_reference_expression() == NULL) + can_take_address = false; + + Expression* td = Expression::make_type_descriptor(this->channel_->type(), + loc); + + Runtime::Function code; + Bstatement* btemp = NULL; + if (is_small) + { + // Type is small enough to handle as uint64. + code = Runtime::SEND_SMALL; + val = Expression::make_unsafe_cast(Type::lookup_integer_type("uint64"), + val, loc); + } + else if (can_take_address) + { + // Must pass address of value. The function doesn't change the + // value, so just take its address directly. + code = Runtime::SEND_BIG; + val = Expression::make_unary(OPERATOR_AND, val, loc); + } + else + { + // Must pass address of value, but the value is small enough + // that it might be in registers. Copy value into temporary + // variable to take address. + code = Runtime::SEND_BIG; + Temporary_statement* temp = Statement::make_temporary(element_type, + val, loc); + Expression* ref = Expression::make_temporary_reference(temp, loc); + val = Expression::make_unary(OPERATOR_AND, ref, loc); + btemp = temp->get_backend(context); + } + + Expression* call = Runtime::make_call(code, loc, 3, td, this->channel_, val); + + context->gogo()->lower_expression(context->function(), NULL, &call); + Bexpression* bcall = tree_to_expr(call->get_tree(context)); + Bstatement* s = context->backend()->expression_statement(bcall); + + if (btemp == NULL) + return s; + else + return context->backend()->compound_statement(btemp, s); +} + +// Dump the AST representation for a send statement + +void +Send_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->dump_expression(this->channel_); + ast_dump_context->ostream() << " <- "; + ast_dump_context->dump_expression(this->val_); + ast_dump_context->ostream() << std::endl; +} + +// Make a send statement. + +Send_statement* +Statement::make_send_statement(Expression* channel, Expression* val, + Location location) +{ + return new Send_statement(channel, val, location); +} + +// Class Select_clauses::Select_clause. + +// Traversal. + +int +Select_clauses::Select_clause::traverse(Traverse* traverse) +{ + if (!this->is_lowered_ + && (traverse->traverse_mask() + & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0) + { + if (this->channel_ != NULL) + { + if (Expression::traverse(&this->channel_, traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + if (this->val_ != NULL) + { + if (Expression::traverse(&this->val_, traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + if (this->closed_ != NULL) + { + if (Expression::traverse(&this->closed_, traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + } + if (this->statements_ != NULL) + { + if (this->statements_->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + return TRAVERSE_CONTINUE; +} + +// Lowering. We call a function to register this clause, and arrange +// to set any variables in any receive clause. + +void +Select_clauses::Select_clause::lower(Gogo* gogo, Named_object* function, + Block* b, Temporary_statement* sel) +{ + Location loc = this->location_; + + Expression* selref = Expression::make_temporary_reference(sel, loc); + + mpz_t ival; + mpz_init_set_ui(ival, this->index_); + Expression* index_expr = Expression::make_integer(&ival, NULL, loc); + mpz_clear(ival); + + if (this->is_default_) + { + go_assert(this->channel_ == NULL && this->val_ == NULL); + this->lower_default(b, selref, index_expr); + this->is_lowered_ = true; + return; + } + + // Evaluate the channel before the select statement. + Temporary_statement* channel_temp = Statement::make_temporary(NULL, + this->channel_, + loc); + b->add_statement(channel_temp); + Expression* chanref = Expression::make_temporary_reference(channel_temp, + loc); + + if (this->is_send_) + this->lower_send(b, selref, chanref, index_expr); + else + this->lower_recv(gogo, function, b, selref, chanref, index_expr); + + // Now all references should be handled through the statements, not + // through here. + this->is_lowered_ = true; + this->val_ = NULL; + this->var_ = NULL; +} + +// Lower a default clause in a select statement. + +void +Select_clauses::Select_clause::lower_default(Block* b, Expression* selref, + Expression* index_expr) +{ + Location loc = this->location_; + Expression* call = Runtime::make_call(Runtime::SELECTDEFAULT, loc, 2, selref, + index_expr); + b->add_statement(Statement::make_statement(call, true)); +} + +// Lower a send clause in a select statement. + +void +Select_clauses::Select_clause::lower_send(Block* b, Expression* selref, + Expression* chanref, + Expression* index_expr) +{ + Location loc = this->location_; + + Channel_type* ct = this->channel_->type()->channel_type(); + if (ct == NULL) + return; + + Type* valtype = ct->element_type(); + + // Note that copying the value to a temporary here means that we + // evaluate the send values in the required order. + Temporary_statement* val = Statement::make_temporary(valtype, this->val_, + loc); + b->add_statement(val); + + Expression* valref = Expression::make_temporary_reference(val, loc); + Expression* valaddr = Expression::make_unary(OPERATOR_AND, valref, loc); + + Expression* call = Runtime::make_call(Runtime::SELECTSEND, loc, 4, selref, + chanref, valaddr, index_expr); + b->add_statement(Statement::make_statement(call, true)); +} + +// Lower a receive clause in a select statement. + +void +Select_clauses::Select_clause::lower_recv(Gogo* gogo, Named_object* function, + Block* b, Expression* selref, + Expression* chanref, + Expression* index_expr) +{ + Location loc = this->location_; + + Channel_type* ct = this->channel_->type()->channel_type(); + if (ct == NULL) + return; + + Type* valtype = ct->element_type(); + Temporary_statement* val = Statement::make_temporary(valtype, NULL, loc); + b->add_statement(val); + + Expression* valref = Expression::make_temporary_reference(val, loc); + Expression* valaddr = Expression::make_unary(OPERATOR_AND, valref, loc); + + Temporary_statement* closed_temp = NULL; + + Expression* call; + if (this->closed_ == NULL && this->closedvar_ == NULL) + call = Runtime::make_call(Runtime::SELECTRECV, loc, 4, selref, chanref, + valaddr, index_expr); + else + { + closed_temp = Statement::make_temporary(Type::lookup_bool_type(), NULL, + loc); + b->add_statement(closed_temp); + Expression* cref = Expression::make_temporary_reference(closed_temp, + loc); + Expression* caddr = Expression::make_unary(OPERATOR_AND, cref, loc); + call = Runtime::make_call(Runtime::SELECTRECV2, loc, 5, selref, chanref, + valaddr, caddr, index_expr); + } + + b->add_statement(Statement::make_statement(call, true)); + + // If the block of statements is executed, arrange for the received + // value to move from VAL to the place where the statements expect + // it. + + Block* init = NULL; + + if (this->var_ != NULL) + { + go_assert(this->val_ == NULL); + valref = Expression::make_temporary_reference(val, loc); + this->var_->var_value()->set_init(valref); + this->var_->var_value()->clear_type_from_chan_element(); + } + else if (this->val_ != NULL && !this->val_->is_sink_expression()) + { + init = new Block(b, loc); + valref = Expression::make_temporary_reference(val, loc); + init->add_statement(Statement::make_assignment(this->val_, valref, loc)); + } + + if (this->closedvar_ != NULL) + { + go_assert(this->closed_ == NULL); + Expression* cref = Expression::make_temporary_reference(closed_temp, + loc); + this->closedvar_->var_value()->set_init(cref); + } + else if (this->closed_ != NULL && !this->closed_->is_sink_expression()) + { + if (init == NULL) + init = new Block(b, loc); + Expression* cref = Expression::make_temporary_reference(closed_temp, + loc); + init->add_statement(Statement::make_assignment(this->closed_, cref, + loc)); + } + + if (init != NULL) + { + gogo->lower_block(function, init); + + if (this->statements_ != NULL) + init->add_statement(Statement::make_block_statement(this->statements_, + loc)); + this->statements_ = init; + } +} + +// Determine types. + +void +Select_clauses::Select_clause::determine_types() +{ + go_assert(this->is_lowered_); + if (this->statements_ != NULL) + this->statements_->determine_types(); +} + +// Check types. + +void +Select_clauses::Select_clause::check_types() +{ + if (this->is_default_) + return; + + Channel_type* ct = this->channel_->type()->channel_type(); + if (ct == NULL) + { + error_at(this->channel_->location(), "expected channel"); + return; + } + + if (this->is_send_ && !ct->may_send()) + error_at(this->location(), "invalid send on receive-only channel"); + else if (!this->is_send_ && !ct->may_receive()) + error_at(this->location(), "invalid receive on send-only channel"); +} + +// Whether this clause may fall through to the statement which follows +// the overall select statement. + +bool +Select_clauses::Select_clause::may_fall_through() const +{ + if (this->statements_ == NULL) + return true; + return this->statements_->may_fall_through(); +} + +// Return the backend representation for the statements to execute. + +Bstatement* +Select_clauses::Select_clause::get_statements_backend( + Translate_context* context) +{ + if (this->statements_ == NULL) + return NULL; + Bblock* bblock = this->statements_->get_backend(context); + return context->backend()->block_statement(bblock); +} + +// Dump the AST representation for a select case clause + +void +Select_clauses::Select_clause::dump_clause( + Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + if (this->is_default_) + { + ast_dump_context->ostream() << "default:"; + } + else + { + ast_dump_context->ostream() << "case " ; + if (this->is_send_) + { + ast_dump_context->dump_expression(this->channel_); + ast_dump_context->ostream() << " <- " ; + if (this->val_ != NULL) + ast_dump_context->dump_expression(this->val_); + } + else + { + if (this->val_ != NULL) + ast_dump_context->dump_expression(this->val_); + if (this->closed_ != NULL) + { + // FIXME: can val_ == NULL and closed_ ! = NULL? + ast_dump_context->ostream() << " , " ; + ast_dump_context->dump_expression(this->closed_); + } + if (this->closedvar_ != NULL || this->var_ != NULL) + ast_dump_context->ostream() << " := " ; + + ast_dump_context->ostream() << " <- " ; + ast_dump_context->dump_expression(this->channel_); + } + ast_dump_context->ostream() << ":" ; + } + ast_dump_context->dump_block(this->statements_); +} + +// Class Select_clauses. + +// Traversal. + +int +Select_clauses::traverse(Traverse* traverse) +{ + for (Clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + { + if (p->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + return TRAVERSE_CONTINUE; +} + +// Lowering. Here we pull out the channel and the send values, to +// enforce the order of evaluation. We also add explicit send and +// receive statements to the clauses. + +void +Select_clauses::lower(Gogo* gogo, Named_object* function, Block* b, + Temporary_statement* sel) +{ + for (Clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + p->lower(gogo, function, b, sel); +} + +// Determine types. + +void +Select_clauses::determine_types() +{ + for (Clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + p->determine_types(); +} + +// Check types. + +void +Select_clauses::check_types() +{ + for (Clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + p->check_types(); +} + +// Return whether these select clauses fall through to the statement +// following the overall select statement. + +bool +Select_clauses::may_fall_through() const +{ + for (Clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + if (p->may_fall_through()) + return true; + return false; +} + +// Convert to the backend representation. We have already accumulated +// all the select information. Now we call selectgo, which will +// return the index of the clause to execute. + +Bstatement* +Select_clauses::get_backend(Translate_context* context, + Temporary_statement* sel, + Unnamed_label *break_label, + Location location) +{ + size_t count = this->clauses_.size(); + std::vector<std::vector<Bexpression*> > cases(count); + std::vector<Bstatement*> clauses(count); + + Type* int32_type = Type::lookup_integer_type("int32"); + + int i = 0; + for (Clauses::iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p, ++i) + { + int index = p->index(); + mpz_t ival; + mpz_init_set_ui(ival, index); + Expression* index_expr = Expression::make_integer(&ival, int32_type, + location); + mpz_clear(ival); + cases[i].push_back(tree_to_expr(index_expr->get_tree(context))); + + Bstatement* s = p->get_statements_backend(context); + Location gloc = (p->statements() == NULL + ? p->location() + : p->statements()->end_location()); + Bstatement* g = break_label->get_goto(context, gloc); + + if (s == NULL) + clauses[i] = g; + else + clauses[i] = context->backend()->compound_statement(s, g); + } + + Expression* selref = Expression::make_temporary_reference(sel, location); + Expression* call = Runtime::make_call(Runtime::SELECTGO, location, 1, + selref); + context->gogo()->lower_expression(context->function(), NULL, &call); + Bexpression* bcall = tree_to_expr(call->get_tree(context)); + + if (count == 0) + return context->backend()->expression_statement(bcall); + + std::vector<Bstatement*> statements; + statements.reserve(2); + + Bstatement* switch_stmt = context->backend()->switch_statement(bcall, + cases, + clauses, + location); + statements.push_back(switch_stmt); + + Bstatement* ldef = break_label->get_definition(context); + statements.push_back(ldef); + + return context->backend()->statement_list(statements); +} +// Dump the AST representation for select clauses. + +void +Select_clauses::dump_clauses(Ast_dump_context* ast_dump_context) const +{ + for (Clauses::const_iterator p = this->clauses_.begin(); + p != this->clauses_.end(); + ++p) + p->dump_clause(ast_dump_context); +} + +// Class Select_statement. + +// Return the break label for this switch statement, creating it if +// necessary. + +Unnamed_label* +Select_statement::break_label() +{ + if (this->break_label_ == NULL) + this->break_label_ = new Unnamed_label(this->location()); + return this->break_label_; +} + +// Lower a select statement. This will still return a select +// statement, but it will be modified to implement the order of +// evaluation rules, and to include the send and receive statements as +// explicit statements in the clauses. + +Statement* +Select_statement::do_lower(Gogo* gogo, Named_object* function, + Block* enclosing, Statement_inserter*) +{ + if (this->is_lowered_) + return this; + + Location loc = this->location(); + + Block* b = new Block(enclosing, loc); + + go_assert(this->sel_ == NULL); + + mpz_t ival; + mpz_init_set_ui(ival, this->clauses_->size()); + Expression* size_expr = Expression::make_integer(&ival, NULL, loc); + mpz_clear(ival); + + Expression* call = Runtime::make_call(Runtime::NEWSELECT, loc, 1, size_expr); + + this->sel_ = Statement::make_temporary(NULL, call, loc); + b->add_statement(this->sel_); + + this->clauses_->lower(gogo, function, b, this->sel_); + this->is_lowered_ = true; + b->add_statement(this); + + return Statement::make_block_statement(b, loc); +} + +// Whether the select statement itself may fall through to the following +// statement. + +bool +Select_statement::do_may_fall_through() const +{ + // A select statement is terminating if no break statement + // refers to it and all of its clauses are terminating. + if (this->break_label_ != NULL) + return true; + return this->clauses_->may_fall_through(); +} + +// Return the backend representation for a select statement. + +Bstatement* +Select_statement::do_get_backend(Translate_context* context) +{ + return this->clauses_->get_backend(context, this->sel_, this->break_label(), + this->location()); +} + +// Dump the AST representation for a select statement. + +void +Select_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "select"; + if (ast_dump_context->dump_subblocks()) + { + ast_dump_context->ostream() << " {" << std::endl; + this->clauses_->dump_clauses(ast_dump_context); + ast_dump_context->ostream() << "}"; + } + ast_dump_context->ostream() << std::endl; +} + +// Make a select statement. + +Select_statement* +Statement::make_select_statement(Location location) +{ + return new Select_statement(location); +} + +// Class For_statement. + +// Traversal. + +int +For_statement::do_traverse(Traverse* traverse) +{ + if (this->init_ != NULL) + { + if (this->init_->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + if (this->cond_ != NULL) + { + if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + if (this->post_ != NULL) + { + if (this->post_->traverse(traverse) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + return this->statements_->traverse(traverse); +} + +// Lower a For_statement into if statements and gotos. Getting rid of +// complex statements make it easier to handle garbage collection. + +Statement* +For_statement::do_lower(Gogo*, Named_object*, Block* enclosing, + Statement_inserter*) +{ + Statement* s; + Location loc = this->location(); + + Block* b = new Block(enclosing, this->location()); + if (this->init_ != NULL) + { + s = Statement::make_block_statement(this->init_, + this->init_->start_location()); + b->add_statement(s); + } + + Unnamed_label* entry = NULL; + if (this->cond_ != NULL) + { + entry = new Unnamed_label(this->location()); + b->add_statement(Statement::make_goto_unnamed_statement(entry, loc)); + } + + Unnamed_label* top = new Unnamed_label(this->location()); + b->add_statement(Statement::make_unnamed_label_statement(top)); + + s = Statement::make_block_statement(this->statements_, + this->statements_->start_location()); + b->add_statement(s); + + Location end_loc = this->statements_->end_location(); + + Unnamed_label* cont = this->continue_label_; + if (cont != NULL) + b->add_statement(Statement::make_unnamed_label_statement(cont)); + + if (this->post_ != NULL) + { + s = Statement::make_block_statement(this->post_, + this->post_->start_location()); + b->add_statement(s); + end_loc = this->post_->end_location(); + } + + if (this->cond_ == NULL) + b->add_statement(Statement::make_goto_unnamed_statement(top, end_loc)); + else + { + b->add_statement(Statement::make_unnamed_label_statement(entry)); + + Location cond_loc = this->cond_->location(); + Block* then_block = new Block(b, cond_loc); + s = Statement::make_goto_unnamed_statement(top, cond_loc); + then_block->add_statement(s); + + s = Statement::make_if_statement(this->cond_, then_block, NULL, cond_loc); + b->add_statement(s); + } + + Unnamed_label* brk = this->break_label_; + if (brk != NULL) + b->add_statement(Statement::make_unnamed_label_statement(brk)); + + b->set_end_location(end_loc); + + return Statement::make_block_statement(b, loc); +} + +// Return the break label, creating it if necessary. + +Unnamed_label* +For_statement::break_label() +{ + if (this->break_label_ == NULL) + this->break_label_ = new Unnamed_label(this->location()); + return this->break_label_; +} + +// Return the continue LABEL_EXPR. + +Unnamed_label* +For_statement::continue_label() +{ + if (this->continue_label_ == NULL) + this->continue_label_ = new Unnamed_label(this->location()); + return this->continue_label_; +} + +// Set the break and continue labels a for statement. This is used +// when lowering a for range statement. + +void +For_statement::set_break_continue_labels(Unnamed_label* break_label, + Unnamed_label* continue_label) +{ + go_assert(this->break_label_ == NULL && this->continue_label_ == NULL); + this->break_label_ = break_label; + this->continue_label_ = continue_label; +} + +// Whether the overall statement may fall through. + +bool +For_statement::do_may_fall_through() const +{ + // A for loop is terminating if it has no condition and + // no break statement. + if(this->cond_ != NULL) + return true; + if(this->break_label_ != NULL) + return true; + return false; +} + +// Dump the AST representation for a for statement. + +void +For_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + if (this->init_ != NULL && ast_dump_context->dump_subblocks()) + { + ast_dump_context->print_indent(); + ast_dump_context->indent(); + ast_dump_context->ostream() << "// INIT " << std::endl; + ast_dump_context->dump_block(this->init_); + ast_dump_context->unindent(); + } + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "for "; + if (this->cond_ != NULL) + ast_dump_context->dump_expression(this->cond_); + + if (ast_dump_context->dump_subblocks()) + { + ast_dump_context->ostream() << " {" << std::endl; + ast_dump_context->dump_block(this->statements_); + if (this->init_ != NULL) + { + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "// POST " << std::endl; + ast_dump_context->dump_block(this->post_); + } + ast_dump_context->unindent(); + + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "}"; + } + + ast_dump_context->ostream() << std::endl; +} + +// Make a for statement. + +For_statement* +Statement::make_for_statement(Block* init, Expression* cond, Block* post, + Location location) +{ + return new For_statement(init, cond, post, location); +} + +// Class For_range_statement. + +// Traversal. + +int +For_range_statement::do_traverse(Traverse* traverse) +{ + if (this->traverse_expression(traverse, &this->index_var_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + if (this->value_var_ != NULL) + { + if (this->traverse_expression(traverse, &this->value_var_) + == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + } + if (this->traverse_expression(traverse, &this->range_) == TRAVERSE_EXIT) + return TRAVERSE_EXIT; + return this->statements_->traverse(traverse); +} + +// Lower a for range statement. For simplicity we lower this into a +// for statement, which will then be lowered in turn to goto +// statements. + +Statement* +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 + && range_type->points_to()->array_type() != NULL + && !range_type->points_to()->is_slice_type()) + range_type = range_type->points_to(); + + Type* index_type; + Type* value_type = NULL; + if (range_type->array_type() != NULL) + { + index_type = Type::lookup_integer_type("int"); + value_type = range_type->array_type()->element_type(); + } + else if (range_type->is_string_type()) + { + index_type = Type::lookup_integer_type("int"); + value_type = Type::lookup_integer_type("int32"); + } + else if (range_type->map_type() != NULL) + { + index_type = range_type->map_type()->key_type(); + value_type = range_type->map_type()->val_type(); + } + else if (range_type->channel_type() != NULL) + { + index_type = range_type->channel_type()->element_type(); + if (this->value_var_ != NULL) + { + if (!this->value_var_->type()->is_error()) + this->report_error(_("too many variables for range clause " + "with channel")); + return Statement::make_error_statement(this->location()); + } + } + else + { + this->report_error(_("range clause must have " + "array, slice, string, map, or channel type")); + return Statement::make_error_statement(this->location()); + } + + Location loc = this->location(); + Block* temp_block = new Block(enclosing, loc); + + Named_object* range_object = NULL; + Temporary_statement* range_temp = NULL; + Var_expression* ve = this->range_->var_expression(); + if (ve != NULL) + range_object = ve->named_object(); + else + { + range_temp = Statement::make_temporary(NULL, this->range_, loc); + temp_block->add_statement(range_temp); + this->range_ = NULL; + } + + Temporary_statement* index_temp = Statement::make_temporary(index_type, + NULL, loc); + temp_block->add_statement(index_temp); + + Temporary_statement* value_temp = NULL; + if (this->value_var_ != NULL) + { + value_temp = Statement::make_temporary(value_type, NULL, loc); + temp_block->add_statement(value_temp); + } + + Block* body = new Block(temp_block, loc); + + Block* init; + Expression* cond; + Block* iter_init; + Block* post; + + // Arrange to do a loop appropriate for the type. We will produce + // for INIT ; COND ; POST { + // ITER_INIT + // INDEX = INDEX_TEMP + // VALUE = VALUE_TEMP // If there is a value + // original statements + // } + + if (range_type->is_slice_type()) + this->lower_range_slice(gogo, temp_block, body, range_object, range_temp, + index_temp, value_temp, &init, &cond, &iter_init, + &post); + else if (range_type->array_type() != NULL) + this->lower_range_array(gogo, temp_block, body, range_object, range_temp, + index_temp, value_temp, &init, &cond, &iter_init, + &post); + else if (range_type->is_string_type()) + this->lower_range_string(gogo, temp_block, body, range_object, range_temp, + index_temp, value_temp, &init, &cond, &iter_init, + &post); + else if (range_type->map_type() != NULL) + this->lower_range_map(gogo, temp_block, body, range_object, range_temp, + index_temp, value_temp, &init, &cond, &iter_init, + &post); + else if (range_type->channel_type() != NULL) + this->lower_range_channel(gogo, temp_block, body, range_object, range_temp, + index_temp, value_temp, &init, &cond, &iter_init, + &post); + else + go_unreachable(); + + if (iter_init != NULL) + body->add_statement(Statement::make_block_statement(iter_init, loc)); + + Statement* assign; + Expression* index_ref = Expression::make_temporary_reference(index_temp, loc); + if (this->value_var_ == NULL) + { + assign = Statement::make_assignment(this->index_var_, index_ref, loc); + } + else + { + Expression_list* lhs = new Expression_list(); + lhs->push_back(this->index_var_); + lhs->push_back(this->value_var_); + + Expression_list* rhs = new Expression_list(); + rhs->push_back(index_ref); + rhs->push_back(Expression::make_temporary_reference(value_temp, loc)); + + assign = Statement::make_tuple_assignment(lhs, rhs, loc); + } + body->add_statement(assign); + + body->add_statement(Statement::make_block_statement(this->statements_, loc)); + + body->set_end_location(this->statements_->end_location()); + + For_statement* loop = Statement::make_for_statement(init, cond, post, + this->location()); + loop->add_statements(body); + loop->set_break_continue_labels(this->break_label_, this->continue_label_); + + temp_block->add_statement(loop); + + return Statement::make_block_statement(temp_block, loc); +} + +// Return a reference to the range, which may be in RANGE_OBJECT or in +// RANGE_TEMP. + +Expression* +For_range_statement::make_range_ref(Named_object* range_object, + Temporary_statement* range_temp, + Location loc) +{ + if (range_object != NULL) + return Expression::make_var_reference(range_object, loc); + else + return Expression::make_temporary_reference(range_temp, loc); +} + +// Return a call to the predeclared function FUNCNAME passing a +// reference to the temporary variable ARG. + +Expression* +For_range_statement::call_builtin(Gogo* gogo, const char* funcname, + Expression* arg, + Location loc) +{ + Named_object* no = gogo->lookup_global(funcname); + go_assert(no != NULL && no->is_function_declaration()); + Expression* func = Expression::make_func_reference(no, NULL, loc); + Expression_list* params = new Expression_list(); + params->push_back(arg); + return Expression::make_call(func, params, false, loc); +} + +// Lower a for range over an array. + +void +For_range_statement::lower_range_array(Gogo* gogo, + Block* enclosing, + Block* body_block, + Named_object* range_object, + Temporary_statement* range_temp, + Temporary_statement* index_temp, + Temporary_statement* value_temp, + Block** pinit, + Expression** pcond, + Block** piter_init, + Block** ppost) +{ + Location loc = this->location(); + + // The loop we generate: + // len_temp := len(range) + // for index_temp = 0; index_temp < len_temp; index_temp++ { + // value_temp = range[index_temp] + // index = index_temp + // value = value_temp + // original body + // } + + // Set *PINIT to + // var len_temp int + // len_temp = len(range) + // index_temp = 0 + + Block* init = new Block(enclosing, loc); + + Expression* ref = this->make_range_ref(range_object, range_temp, loc); + Expression* len_call = this->call_builtin(gogo, "len", ref, loc); + Temporary_statement* len_temp = Statement::make_temporary(index_temp->type(), + len_call, loc); + init->add_statement(len_temp); + + mpz_t zval; + mpz_init_set_ui(zval, 0UL); + Expression* zexpr = Expression::make_integer(&zval, NULL, loc); + mpz_clear(zval); + + 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; + + // Set *PCOND to + // index_temp < len_temp + + ref = Expression::make_temporary_reference(index_temp, loc); + Expression* ref2 = Expression::make_temporary_reference(len_temp, loc); + Expression* lt = Expression::make_binary(OPERATOR_LT, ref, ref2, loc); + + *pcond = lt; + + // Set *PITER_INIT to + // value_temp = range[index_temp] + + Block* iter_init = NULL; + if (value_temp != NULL) + { + iter_init = new Block(body_block, loc); + + ref = this->make_range_ref(range_object, range_temp, loc); + Expression* ref2 = Expression::make_temporary_reference(index_temp, loc); + Expression* index = Expression::make_index(ref, ref2, NULL, NULL, 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); + } + *piter_init = iter_init; + + // Set *PPOST to + // index_temp++ + + Block* post = new Block(enclosing, loc); + tref = Expression::make_temporary_reference(index_temp, loc); + tref->set_is_lvalue(); + s = Statement::make_inc_statement(tref); + post->add_statement(s); + *ppost = post; +} + +// Lower a for range over a slice. + +void +For_range_statement::lower_range_slice(Gogo* gogo, + Block* enclosing, + Block* body_block, + Named_object* range_object, + Temporary_statement* range_temp, + Temporary_statement* index_temp, + Temporary_statement* value_temp, + Block** pinit, + Expression** pcond, + Block** piter_init, + Block** ppost) +{ + Location loc = this->location(); + + // The loop we generate: + // for_temp := range + // len_temp := len(for_temp) + // for index_temp = 0; index_temp < len_temp; index_temp++ { + // value_temp = for_temp[index_temp] + // index = index_temp + // value = value_temp + // original body + // } + // + // Using for_temp means that we don't need to check bounds when + // fetching range_temp[index_temp]. + + // Set *PINIT to + // range_temp := range + // var len_temp int + // len_temp = len(range_temp) + // index_temp = 0 + + Block* init = new Block(enclosing, loc); + + Expression* ref = this->make_range_ref(range_object, range_temp, loc); + Temporary_statement* for_temp = Statement::make_temporary(NULL, ref, loc); + init->add_statement(for_temp); + + ref = Expression::make_temporary_reference(for_temp, loc); + Expression* len_call = this->call_builtin(gogo, "len", ref, loc); + Temporary_statement* len_temp = Statement::make_temporary(index_temp->type(), + len_call, loc); + init->add_statement(len_temp); + + mpz_t zval; + mpz_init_set_ui(zval, 0UL); + Expression* zexpr = Expression::make_integer(&zval, NULL, loc); + mpz_clear(zval); + + 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; + + // Set *PCOND to + // index_temp < len_temp + + ref = Expression::make_temporary_reference(index_temp, loc); + Expression* ref2 = Expression::make_temporary_reference(len_temp, loc); + Expression* lt = Expression::make_binary(OPERATOR_LT, ref, ref2, loc); + + *pcond = lt; + + // Set *PITER_INIT to + // value_temp = range[index_temp] + + Block* iter_init = NULL; + if (value_temp != NULL) + { + iter_init = new Block(body_block, loc); + + ref = Expression::make_temporary_reference(for_temp, loc); + Expression* ref2 = Expression::make_temporary_reference(index_temp, loc); + Expression* index = Expression::make_index(ref, ref2, NULL, NULL, 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); + } + *piter_init = iter_init; + + // Set *PPOST to + // index_temp++ + + Block* post = new Block(enclosing, loc); + tref = Expression::make_temporary_reference(index_temp, loc); + tref->set_is_lvalue(); + s = Statement::make_inc_statement(tref); + post->add_statement(s); + *ppost = post; +} + +// Lower a for range over a string. + +void +For_range_statement::lower_range_string(Gogo*, + Block* enclosing, + Block* body_block, + Named_object* range_object, + Temporary_statement* range_temp, + Temporary_statement* index_temp, + Temporary_statement* value_temp, + Block** pinit, + Expression** pcond, + Block** piter_init, + Block** ppost) +{ + Location loc = this->location(); + + // The loop we generate: + // var next_index_temp int + // for index_temp = 0; ; index_temp = next_index_temp { + // next_index_temp, value_temp = stringiter2(range, index_temp) + // if next_index_temp == 0 { + // break + // } + // index = index_temp + // value = value_temp + // original body + // } + + // Set *PINIT to + // var next_index_temp int + // index_temp = 0 + + Block* init = new Block(enclosing, loc); + + Temporary_statement* next_index_temp = + Statement::make_temporary(index_temp->type(), NULL, loc); + init->add_statement(next_index_temp); + + mpz_t zval; + mpz_init_set_ui(zval, 0UL); + Expression* zexpr = Expression::make_integer(&zval, NULL, 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); + *pinit = init; + + // The loop has no condition. + + *pcond = NULL; + + // Set *PITER_INIT to + // next_index_temp = runtime.stringiter(range, index_temp) + // or + // next_index_temp, value_temp = runtime.stringiter2(range, index_temp) + // followed by + // if next_index_temp == 0 { + // break + // } + + Block* iter_init = new Block(body_block, loc); + + Expression* p1 = this->make_range_ref(range_object, range_temp, loc); + Expression* p2 = Expression::make_temporary_reference(index_temp, loc); + Call_expression* call = Runtime::make_call((value_temp == NULL + ? Runtime::STRINGITER + : Runtime::STRINGITER2), + loc, 2, p1, p2); + + 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(); + + 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)); + rhs->push_back(Expression::make_call_result(call, 1)); + + s = Statement::make_tuple_assignment(lhs, rhs, loc); + } + iter_init->add_statement(s); + + ref = Expression::make_temporary_reference(next_index_temp, loc); + zexpr = Expression::make_integer(&zval, NULL, loc); + mpz_clear(zval); + Expression* equals = Expression::make_binary(OPERATOR_EQEQ, ref, zexpr, loc); + + Block* then_block = new Block(iter_init, loc); + s = Statement::make_break_statement(this->break_label(), loc); + then_block->add_statement(s); + + s = Statement::make_if_statement(equals, then_block, NULL, loc); + iter_init->add_statement(s); + + *piter_init = iter_init; + + // Set *PPOST to + // index_temp = next_index_temp + + Block* post = new Block(enclosing, 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); + + post->add_statement(s); + *ppost = post; +} + +// Lower a for range over a map. + +void +For_range_statement::lower_range_map(Gogo*, + Block* enclosing, + Block* body_block, + Named_object* range_object, + Temporary_statement* range_temp, + Temporary_statement* index_temp, + Temporary_statement* value_temp, + Block** pinit, + Expression** pcond, + Block** piter_init, + Block** ppost) +{ + Location loc = this->location(); + + // The runtime uses a struct to handle ranges over a map. The + // struct is four pointers long. The first pointer is NULL when we + // have completed the iteration. + + // The loop we generate: + // var hiter map_iteration_struct + // for mapiterinit(range, &hiter); hiter[0] != nil; mapiternext(&hiter) { + // mapiter2(hiter, &index_temp, &value_temp) + // index = index_temp + // value = value_temp + // original body + // } + + // Set *PINIT to + // var hiter map_iteration_struct + // runtime.mapiterinit(range, &hiter) + + Block* init = new Block(enclosing, loc); + + Type* map_iteration_type = Runtime::map_iteration_type(); + Temporary_statement* hiter = Statement::make_temporary(map_iteration_type, + NULL, loc); + init->add_statement(hiter); + + Expression* p1 = this->make_range_ref(range_object, range_temp, loc); + Expression* ref = Expression::make_temporary_reference(hiter, loc); + Expression* p2 = Expression::make_unary(OPERATOR_AND, ref, loc); + Expression* call = Runtime::make_call(Runtime::MAPITERINIT, loc, 2, p1, p2); + init->add_statement(Statement::make_statement(call, true)); + + *pinit = init; + + // Set *PCOND to + // hiter[0] != nil + + ref = Expression::make_temporary_reference(hiter, loc); + + mpz_t zval; + mpz_init_set_ui(zval, 0UL); + Expression* zexpr = Expression::make_integer(&zval, NULL, loc); + mpz_clear(zval); + + Expression* index = Expression::make_index(ref, zexpr, NULL, NULL, loc); + + Expression* ne = Expression::make_binary(OPERATOR_NOTEQ, index, + Expression::make_nil(loc), + loc); + + *pcond = ne; + + // Set *PITER_INIT to + // mapiter1(hiter, &index_temp) + // or + // mapiter2(hiter, &index_temp, &value_temp) + + Block* iter_init = new Block(body_block, loc); + + ref = Expression::make_temporary_reference(hiter, loc); + p1 = Expression::make_unary(OPERATOR_AND, ref, loc); + ref = Expression::make_temporary_reference(index_temp, loc); + p2 = Expression::make_unary(OPERATOR_AND, ref, loc); + if (value_temp == NULL) + call = Runtime::make_call(Runtime::MAPITER1, loc, 2, p1, p2); + else + { + ref = Expression::make_temporary_reference(value_temp, loc); + Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc); + call = Runtime::make_call(Runtime::MAPITER2, loc, 3, p1, p2, p3); + } + iter_init->add_statement(Statement::make_statement(call, true)); + + *piter_init = iter_init; + + // Set *PPOST to + // mapiternext(&hiter) + + Block* post = new Block(enclosing, loc); + + ref = Expression::make_temporary_reference(hiter, loc); + p1 = Expression::make_unary(OPERATOR_AND, ref, loc); + call = Runtime::make_call(Runtime::MAPITERNEXT, loc, 1, p1); + post->add_statement(Statement::make_statement(call, true)); + + *ppost = post; +} + +// Lower a for range over a channel. + +void +For_range_statement::lower_range_channel(Gogo*, + Block*, + Block* body_block, + Named_object* range_object, + Temporary_statement* range_temp, + Temporary_statement* index_temp, + Temporary_statement* value_temp, + Block** pinit, + Expression** pcond, + Block** piter_init, + Block** ppost) +{ + go_assert(value_temp == NULL); + + Location loc = this->location(); + + // The loop we generate: + // for { + // index_temp, ok_temp = <-range + // if !ok_temp { + // break + // } + // index = index_temp + // original body + // } + + // We have no initialization code, no condition, and no post code. + + *pinit = NULL; + *pcond = NULL; + *ppost = NULL; + + // Set *PITER_INIT to + // index_temp, ok_temp = <-range + // if !ok_temp { + // break + // } + + Block* iter_init = new Block(body_block, loc); + + Temporary_statement* ok_temp = + Statement::make_temporary(Type::lookup_bool_type(), NULL, loc); + iter_init->add_statement(ok_temp); + + Expression* cref = this->make_range_ref(range_object, range_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, + loc); + iter_init->add_statement(s); + + Block* then_block = new Block(iter_init, loc); + s = Statement::make_break_statement(this->break_label(), loc); + then_block->add_statement(s); + + oref = Expression::make_temporary_reference(ok_temp, loc); + Expression* cond = Expression::make_unary(OPERATOR_NOT, oref, loc); + s = Statement::make_if_statement(cond, then_block, NULL, loc); + iter_init->add_statement(s); + + *piter_init = iter_init; +} + +// Return the break LABEL_EXPR. + +Unnamed_label* +For_range_statement::break_label() +{ + if (this->break_label_ == NULL) + this->break_label_ = new Unnamed_label(this->location()); + return this->break_label_; +} + +// Return the continue LABEL_EXPR. + +Unnamed_label* +For_range_statement::continue_label() +{ + if (this->continue_label_ == NULL) + this->continue_label_ = new Unnamed_label(this->location()); + return this->continue_label_; +} + +// Dump the AST representation for a for range statement. + +void +For_range_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const +{ + + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "for "; + ast_dump_context->dump_expression(this->index_var_); + if (this->value_var_ != NULL) + { + ast_dump_context->ostream() << ", "; + ast_dump_context->dump_expression(this->value_var_); + } + + ast_dump_context->ostream() << " = range "; + ast_dump_context->dump_expression(this->range_); + if (ast_dump_context->dump_subblocks()) + { + ast_dump_context->ostream() << " {" << std::endl; + + ast_dump_context->indent(); + + ast_dump_context->dump_block(this->statements_); + + ast_dump_context->unindent(); + ast_dump_context->print_indent(); + ast_dump_context->ostream() << "}"; + } + ast_dump_context->ostream() << std::endl; +} + +// Make a for statement with a range clause. + +For_range_statement* +Statement::make_for_range_statement(Expression* index_var, + Expression* value_var, + Expression* range, + Location location) +{ + return new For_range_statement(index_var, value_var, range, location); +} |