| // 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 "go-diagnostics.h" |
| #include "types.h" |
| #include "expressions.h" |
| #include "gogo.h" |
| #include "export.h" |
| #include "import.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(); |
| } |
| |
| // Read a statement from export data. |
| |
| Statement* |
| Statement::import_statement(Import_function_body* ifb, Location loc) |
| { |
| if (ifb->match_c_string("{")) |
| { |
| bool is_lowered_for_statement; |
| Block* block = Block_statement::do_import(ifb, loc, |
| &is_lowered_for_statement); |
| if (block == NULL) |
| return Statement::make_error_statement(loc); |
| Block_statement* s = Statement::make_block_statement(block, loc); |
| if (is_lowered_for_statement) |
| s->set_is_lowered_for_statement(); |
| return s; |
| } |
| else if (ifb->match_c_string("return")) |
| { |
| // After lowering return statements have no expressions. The |
| // return expressions are assigned to result parameters. |
| ifb->advance(6); |
| return Statement::make_return_statement(NULL, loc); |
| } |
| else if (ifb->match_c_string("var $t")) |
| return Temporary_statement::do_import(ifb, loc); |
| else if (ifb->match_c_string("var ")) |
| return Variable_declaration_statement::do_import(ifb, loc); |
| else if (ifb->match_c_string("if ")) |
| return If_statement::do_import(ifb, loc); |
| else if (ifb->match_c_string(":")) |
| return Label_statement::do_import(ifb, loc); |
| else if (ifb->match_c_string("goto ")) |
| return Goto_statement::do_import(ifb, loc); |
| |
| Expression* lhs = Expression::import_expression(ifb, loc); |
| |
| if (ifb->match_c_string(" //")) |
| return Statement::make_statement(lhs, true); |
| |
| ifb->require_c_string(" = "); |
| Expression* rhs = Expression::import_expression(ifb, loc); |
| return Statement::make_assignment(lhs, rhs, loc); |
| } |
| |
| // 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) |
| { |
| go_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; |
| }; |
| |
| // |
| // Helper to tack on available source position information |
| // at the end of a statement. |
| // |
| static std::string |
| dsuffix(Location location) |
| { |
| std::string lstr = Linemap::location_to_string(location); |
| if (lstr == "") |
| return lstr; |
| std::string rval(" // "); |
| rval += lstr; |
| return rval; |
| } |
| |
| // 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) |
| { |
| Variable* var = this->var_->var_value(); |
| if (var->type()->is_error_type() |
| || (var->init() != NULL |
| && var->init()->is_error_expression())) |
| { |
| go_assert(saw_errors()); |
| return Statement::make_error_statement(this->location()); |
| } |
| this->var_->var_value()->flatten_init_expression(gogo, function, inserter); |
| return this; |
| } |
| |
| // Add explicit type conversions. |
| |
| void |
| Variable_declaration_statement::do_add_conversions() |
| { |
| Variable* var = this->var_->var_value(); |
| Expression* init = var->init(); |
| if (init == NULL) |
| return; |
| Type* lt = var->type(); |
| Type* rt = init->type(); |
| if (!Type::are_identical(lt, rt, 0, NULL) |
| && lt->interface_type() != NULL) |
| var->set_init(Expression::make_cast(lt, init, this->location())); |
| } |
| |
| // Convert a variable declaration to the backend representation. |
| |
| Bstatement* |
| Variable_declaration_statement::do_get_backend(Translate_context* context) |
| { |
| Bfunction* bfunction = context->function()->func_value()->get_decl(); |
| Variable* var = this->var_->var_value(); |
| Bvariable* bvar = this->var_->get_backend_variable(context->gogo(), |
| context->function()); |
| Bexpression* binit = var->get_init(context->gogo(), context->function()); |
| |
| if (!var->is_in_heap()) |
| { |
| go_assert(binit != NULL); |
| return context->backend()->init_statement(bfunction, 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_dereference(e, Expression::NIL_CHECK_NOT_NEEDED, |
| loc); |
| Bexpression* be = e->get_backend(context); |
| set = context->backend()->assignment_statement(bfunction, be, binit, loc); |
| } |
| |
| Expression* ref = Expression::make_temporary_reference(temp, loc); |
| Bexpression* bref = ref->get_backend(context); |
| Bstatement* sinit = context->backend()->init_statement(bfunction, 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() << dsuffix(location()) << std::endl; |
| } |
| |
| // Make a variable declaration. |
| |
| Statement* |
| Statement::make_variable_declaration(Named_object* var) |
| { |
| return new Variable_declaration_statement(var); |
| } |
| |
| // Export a variable declaration. |
| |
| void |
| Variable_declaration_statement::do_export_statement(Export_function_body* efb) |
| { |
| efb->write_c_string("var "); |
| efb->write_string(Gogo::unpack_hidden_name(this->var_->name())); |
| efb->write_c_string(" "); |
| Variable* var = this->var_->var_value(); |
| Type* type = var->type(); |
| efb->write_type(type); |
| Expression* init = var->init(); |
| if (init != NULL) |
| { |
| efb->write_c_string(" = "); |
| |
| go_assert(efb->type_context() == NULL); |
| efb->set_type_context(type); |
| |
| init->export_expression(efb); |
| |
| efb->set_type_context(NULL); |
| } |
| } |
| |
| // Import a variable declaration. |
| |
| Statement* |
| Variable_declaration_statement::do_import(Import_function_body* ifb, |
| Location loc) |
| { |
| ifb->require_c_string("var "); |
| std::string id = ifb->read_identifier(); |
| ifb->require_c_string(" "); |
| Type* type = ifb->read_type(); |
| Expression* init = NULL; |
| if (ifb->match_c_string(" = ")) |
| { |
| ifb->advance(3); |
| init = Expression::import_expression(ifb, loc); |
| } |
| Variable* var = new Variable(type, init, false, false, false, loc); |
| var->set_is_used(); |
| // FIXME: The package we are importing does not yet exist, so we |
| // can't pass the correct package here. It probably doesn't matter. |
| Named_object* no = ifb->block()->bindings()->add_variable(id, NULL, var); |
| return Statement::make_variable_declaration(no); |
| } |
| |
| // Class Temporary_statement. |
| |
| // Return the type of the temporary variable. |
| |
| Type* |
| Temporary_statement::type() const |
| { |
| Type* type = this->type_ != NULL ? this->type_ : this->init_->type(); |
| |
| // Temporary variables cannot have a void type. |
| if (type->is_void_type()) |
| { |
| go_assert(saw_errors()); |
| return Type::make_error_type(); |
| } |
| return 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; |
| if (!Type::are_assignable(this->type_, this->init_->type(), &reason)) |
| { |
| if (reason.empty()) |
| go_error_at(this->location(), "incompatible types in assignment"); |
| else |
| go_error_at(this->location(), "incompatible types in assignment (%s)", |
| reason.c_str()); |
| this->set_is_error(); |
| } |
| } |
| } |
| |
| // Flatten a temporary statement: add another temporary when it might |
| // be needed for interface conversion. |
| |
| Statement* |
| Temporary_statement::do_flatten(Gogo*, Named_object*, Block*, |
| Statement_inserter* inserter) |
| { |
| if (this->type()->is_error_type() |
| || (this->init_ != NULL |
| && this->init_->is_error_expression())) |
| { |
| go_assert(saw_errors()); |
| return Statement::make_error_statement(this->location()); |
| } |
| |
| if (this->type_ != NULL |
| && this->init_ != NULL |
| && !Type::are_identical(this->type_, this->init_->type(), |
| Type::COMPARE_ERRORS | Type::COMPARE_TAGS, |
| NULL) |
| && this->init_->type()->interface_type() != NULL |
| && !this->init_->is_multi_eval_safe()) |
| { |
| Temporary_statement *temp = |
| Statement::make_temporary(NULL, this->init_, this->location()); |
| inserter->insert(temp); |
| this->init_ = Expression::make_temporary_reference(temp, |
| this->location()); |
| } |
| return this; |
| } |
| |
| // Add explicit type conversions. |
| |
| void |
| Temporary_statement::do_add_conversions() |
| { |
| if (this->init_ == NULL) |
| return; |
| Type* lt = this->type(); |
| Type* rt = this->init_->type(); |
| if (!Type::are_identical(lt, rt, 0, NULL) |
| && lt->interface_type() != NULL) |
| this->init_ = Expression::make_cast(lt, this->init_, this->location()); |
| } |
| |
| // Convert to backend representation. |
| |
| Bstatement* |
| Temporary_statement::do_get_backend(Translate_context* context) |
| { |
| go_assert(this->bvariable_ == NULL); |
| |
| Named_object* function = context->function(); |
| go_assert(function != NULL); |
| Bfunction* bfunction = 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 = this->init_->get_backend(context); |
| else |
| { |
| Expression* init = Expression::convert_for_assignment(context->gogo(), |
| this->type_, |
| this->init_, |
| this->location()); |
| binit = init->get_backend(context); |
| } |
| |
| if (binit != NULL) |
| binit = context->backend()->convert_expression(btype, binit, |
| this->location()); |
| |
| 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() << dsuffix(location()) << 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); |
| } |
| |
| // Export a temporary statement. |
| |
| void |
| Temporary_statement::do_export_statement(Export_function_body* efb) |
| { |
| unsigned int idx = efb->record_temporary(this); |
| char buf[100]; |
| snprintf(buf, sizeof buf, "var $t%u", idx); |
| efb->write_c_string(buf); |
| if (this->type_ != NULL) |
| { |
| efb->write_c_string(" "); |
| efb->write_type(this->type_); |
| } |
| if (this->init_ != NULL) |
| { |
| efb->write_c_string(" = "); |
| |
| go_assert(efb->type_context() == NULL); |
| efb->set_type_context(this->type_); |
| |
| this->init_->export_expression(efb); |
| |
| efb->set_type_context(NULL); |
| } |
| } |
| |
| // Import a temporary statement. |
| |
| Statement* |
| Temporary_statement::do_import(Import_function_body* ifb, Location loc) |
| { |
| ifb->require_c_string("var "); |
| std::string id = ifb->read_identifier(); |
| go_assert(id[0] == '$' && id[1] == 't'); |
| const char *p = id.c_str(); |
| char *end; |
| long idx = strtol(p + 2, &end, 10); |
| if (*end != '\0' || idx > 0x7fffffff) |
| { |
| if (!ifb->saw_error()) |
| go_error_at(loc, |
| ("invalid export data for %qs: " |
| "bad temporary statement index at %lu"), |
| ifb->name().c_str(), |
| static_cast<unsigned long>(ifb->off())); |
| ifb->set_saw_error(); |
| return Statement::make_error_statement(loc); |
| } |
| |
| Type* type = NULL; |
| if (!ifb->match_c_string(" = ")) |
| { |
| ifb->require_c_string(" "); |
| type = ifb->read_type(); |
| } |
| Expression* init = NULL; |
| if (ifb->match_c_string(" = ")) |
| { |
| ifb->advance(3); |
| init = Expression::import_expression(ifb, loc); |
| } |
| if (type == NULL && init == NULL) |
| { |
| if (!ifb->saw_error()) |
| go_error_at(loc, |
| ("invalid export data for %qs: " |
| "temporary statement has neither type nor init at %lu"), |
| ifb->name().c_str(), |
| static_cast<unsigned long>(ifb->off())); |
| ifb->set_saw_error(); |
| return Statement::make_error_statement(loc); |
| } |
| |
| Temporary_statement* temp = Statement::make_temporary(type, init, loc); |
| |
| ifb->record_temporary(temp, static_cast<unsigned int>(idx)); |
| |
| return temp; |
| } |
| |
| // 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 |
| && !(*pexpr)->is_nil_expression() |
| && !(*pexpr)->is_constant()) |
| { |
| 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()) |
| { |
| Call_expression* call = (*pexpr)->call_expression(); |
| if (call != NULL && call->is_multi_value_arg()) |
| { |
| // A call expression which returns multiple results as an argument |
| // to another call must be handled specially. We can't create a |
| // temporary because there is no type to give it. Instead, group |
| // the caller and this multi-valued call argument and use a temporary |
| // variable to hold them. |
| return TRAVERSE_SKIP_COMPONENTS; |
| } |
| |
| 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; |
| } |
| |
| // Class Assignment_statement. |
| |
| // 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; |
| } |
| |
| // Lower an assignment to a map index expression to a runtime function |
| // call. Mark some slice assignments as not requiring a write barrier. |
| |
| Statement* |
| Assignment_statement::do_lower(Gogo* gogo, Named_object*, Block* enclosing, |
| Statement_inserter*) |
| { |
| Map_index_expression* mie = this->lhs_->map_index_expression(); |
| if (mie != NULL) |
| { |
| Location loc = this->location(); |
| |
| Expression* map = mie->map(); |
| Map_type* mt = map->type()->map_type(); |
| if (mt == NULL) |
| { |
| go_assert(saw_errors()); |
| return Statement::make_error_statement(loc); |
| } |
| |
| Block* b = new Block(enclosing, loc); |
| |
| // Move out any subexpressions on the left hand side to make |
| // sure that functions are called in the required order. |
| Move_ordered_evals moe(b); |
| mie->traverse_subexpressions(&moe); |
| |
| // Copy the key 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(mt->key_type(), |
| mie->index(), |
| loc); |
| b->add_statement(key_temp); |
| |
| // Copy the value into a temporary to ensure that it is |
| // evaluated before we add the key to the map. This may matter |
| // if the value is itself a reference to the map. |
| |
| // var val_temp VAL_TYPE = RHS |
| Temporary_statement* val_temp = Statement::make_temporary(mt->val_type(), |
| this->rhs_, |
| loc); |
| b->add_statement(val_temp); |
| |
| // *mapassign(TYPE, MAP, &key_temp) = RHS |
| Expression* a1 = Expression::make_type_descriptor(mt, loc); |
| Expression* a2 = mie->map(); |
| Temporary_reference_expression* ref = |
| Expression::make_temporary_reference(key_temp, loc); |
| Expression* a3 = Expression::make_unary(OPERATOR_AND, ref, loc); |
| Runtime::Function code; |
| Map_type::Map_alg alg = mt->algorithm(gogo); |
| switch (alg) |
| { |
| case Map_type::MAP_ALG_FAST32: |
| { |
| code = Runtime::MAPASSIGN_FAST32; |
| Type* uint32_type = Type::lookup_integer_type("uint32"); |
| Type* uint32_ptr_type = Type::make_pointer_type(uint32_type); |
| a3 = Expression::make_unsafe_cast(uint32_ptr_type, a3, |
| loc); |
| a3 = Expression::make_dereference(a3, |
| Expression::NIL_CHECK_NOT_NEEDED, |
| loc); |
| break; |
| } |
| case Map_type::MAP_ALG_FAST64: |
| { |
| code = Runtime::MAPASSIGN_FAST64; |
| Type* uint64_type = Type::lookup_integer_type("uint64"); |
| Type* uint64_ptr_type = Type::make_pointer_type(uint64_type); |
| a3 = Expression::make_unsafe_cast(uint64_ptr_type, a3, |
| loc); |
| a3 = Expression::make_dereference(a3, |
| Expression::NIL_CHECK_NOT_NEEDED, |
| loc); |
| break; |
| } |
| case Map_type::MAP_ALG_FAST32PTR: |
| case Map_type::MAP_ALG_FAST64PTR: |
| { |
| code = (alg == Map_type::MAP_ALG_FAST32PTR |
| ? Runtime::MAPASSIGN_FAST32PTR |
| : Runtime::MAPASSIGN_FAST64PTR); |
| Type* ptr_type = |
| Type::make_pointer_type(Type::make_void_type()); |
| Type* ptr_ptr_type = Type::make_pointer_type(ptr_type); |
| a3 = Expression::make_unsafe_cast(ptr_ptr_type, a3, |
| loc); |
| a3 = Expression::make_dereference(a3, |
| Expression::NIL_CHECK_NOT_NEEDED, |
| loc); |
| break; |
| } |
| case Map_type::MAP_ALG_FASTSTR: |
| code = Runtime::MAPASSIGN_FASTSTR; |
| a3 = ref; |
| break; |
| default: |
| code = Runtime::MAPASSIGN; |
| break; |
| } |
| Expression* call = Runtime::make_call(code, loc, 3, |
| a1, a2, a3); |
| Type* ptrval_type = Type::make_pointer_type(mt->val_type()); |
| call = Expression::make_cast(ptrval_type, call, loc); |
| Expression* indir = |
| Expression::make_dereference(call, Expression::NIL_CHECK_NOT_NEEDED, |
| loc); |
| ref = Expression::make_temporary_reference(val_temp, loc); |
| b->add_statement(Statement::make_assignment(indir, ref, loc)); |
| |
| return Statement::make_block_statement(b, loc); |
| } |
| |
| // An assignment of the form s = s[:n] does not require a write |
| // barrier, because the pointer value will not change. |
| Array_index_expression* aie = this->rhs_->array_index_expression(); |
| if (aie != NULL |
| && aie->end() != NULL |
| && Expression::is_same_variable(this->lhs_, aie->array())) |
| { |
| Numeric_constant nc; |
| unsigned long ival; |
| if (aie->start()->numeric_constant_value(&nc) |
| && nc.to_unsigned_long(&ival) == Numeric_constant::NC_UL_VALID |
| && ival == 0) |
| this->omit_write_barrier_ = true; |
| } |
| String_index_expression* sie = this->rhs_->string_index_expression(); |
| if (sie != NULL |
| && sie->end() != NULL |
| && Expression::is_same_variable(this->lhs_, sie->string())) |
| { |
| Numeric_constant nc; |
| unsigned long ival; |
| if (sie->start()->numeric_constant_value(&nc) |
| && nc.to_unsigned_long(&ival) == Numeric_constant::NC_UL_VALID |
| && ival == 0) |
| this->omit_write_barrier_ = true; |
| } |
| |
| return this; |
| } |
| |
| // 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; |
| if (!Type::are_assignable(lhs_type, rhs_type, &reason)) |
| { |
| if (reason.empty()) |
| go_error_at(this->location(), "incompatible types in assignment"); |
| else |
| go_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(); |
| } |
| |
| void |
| Assignment_statement::do_export_statement(Export_function_body* efb) |
| { |
| this->lhs_->export_expression(efb); |
| efb->write_c_string(" = "); |
| this->rhs_->export_expression(efb); |
| } |
| |
| // Flatten an assignment statement. We may need a temporary for |
| // interface conversion. |
| |
| Statement* |
| Assignment_statement::do_flatten(Gogo*, Named_object*, Block*, |
| Statement_inserter* inserter) |
| { |
| if (this->lhs_->is_error_expression() |
| || this->lhs_->type()->is_error_type() |
| || this->rhs_->is_error_expression() |
| || this->rhs_->type()->is_error_type()) |
| { |
| go_assert(saw_errors()); |
| return Statement::make_error_statement(this->location()); |
| } |
| |
| if (!this->lhs_->is_sink_expression() |
| && !Type::are_identical(this->lhs_->type(), this->rhs_->type(), |
| Type::COMPARE_ERRORS | Type::COMPARE_TAGS, |
| NULL) |
| && this->rhs_->type()->interface_type() != NULL |
| && !this->rhs_->is_multi_eval_safe()) |
| { |
| Temporary_statement* temp = |
| Statement::make_temporary(NULL, this->rhs_, this->location()); |
| inserter->insert(temp); |
| this->rhs_ = Expression::make_temporary_reference(temp, |
| this->location()); |
| } |
| return this; |
| } |
| |
| // Add explicit type conversions. |
| |
| void |
| Assignment_statement::do_add_conversions() |
| { |
| Type* lt = this->lhs_->type(); |
| Type* rt = this->rhs_->type(); |
| if (!Type::are_identical(lt, rt, 0, NULL) |
| && lt->interface_type() != NULL) |
| this->rhs_ = Expression::make_cast(lt, this->rhs_, this->location()); |
| } |
| |
| // Convert an assignment statement to the backend representation. |
| |
| Bstatement* |
| Assignment_statement::do_get_backend(Translate_context* context) |
| { |
| if (this->lhs_->is_sink_expression()) |
| { |
| Bexpression* rhs = this->rhs_->get_backend(context); |
| Bfunction* bfunction = context->function()->func_value()->get_decl(); |
| return context->backend()->expression_statement(bfunction, rhs); |
| } |
| |
| Bexpression* lhs = this->lhs_->get_backend(context); |
| Expression* conv = |
| Expression::convert_for_assignment(context->gogo(), this->lhs_->type(), |
| this->rhs_, this->location()); |
| Bexpression* rhs = conv->get_backend(context); |
| Bfunction* bfunction = context->function()->func_value()->get_decl(); |
| return context->backend()->assignment_statement(bfunction, lhs, rhs, |
| 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() << dsuffix(location()) << std::endl; |
| } |
| |
| // Make an assignment statement. |
| |
| Assignment_statement* |
| Statement::make_assignment(Expression* lhs, Expression* rhs, |
| Location location) |
| { |
| Temporary_reference_expression* tre = lhs->temporary_reference_expression(); |
| if (tre != NULL) |
| tre->statement()->set_assigned(); |
| return new Assignment_statement(lhs, rhs, location); |
| } |
| |
| // 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() << dsuffix(location()) << 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) |
| { } |
| |
| 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_; |
| }; |
| |
| // 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); |
| 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); |
| b->add_statement(Statement::make_assignment(*plhs, ref, loc)); |
| ++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() << dsuffix(location()) << 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* 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); |
| |
| // Avoid copy for string([]byte) conversions used in map keys. |
| // mapaccess doesn't keep the reference, so this is safe. |
| Type_conversion_expression* ce = map_index->index()->conversion_expression(); |
| if (ce != NULL && ce->type()->is_string_type() |
| && ce->expr()->type()->is_slice_type()) |
| ce->set_no_copy(true); |
| |
| 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_ptr_temp *VAL_TYPE |
| Type* val_ptr_type = Type::make_pointer_type(map_type->val_type()); |
| Temporary_statement* val_ptr_temp = Statement::make_temporary(val_ptr_type, |
| NULL, loc); |
| b->add_statement(val_ptr_temp); |
| |
| // var present_temp bool |
| Temporary_statement* present_temp = |
| Statement::make_temporary((this->present_->type()->is_sink_type()) |
| ? Type::make_boolean_type() |
| : this->present_->type(), |
| NULL, loc); |
| b->add_statement(present_temp); |
| |
| // val_ptr_temp, present_temp = mapaccess2(DESCRIPTOR, MAP, &key_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); |
| Expression* a4 = map_type->fat_zero_value(gogo); |
| Call_expression* call; |
| if (a4 == NULL) |
| { |
| Runtime::Function code; |
| Map_type::Map_alg alg = map_type->algorithm(gogo); |
| switch (alg) |
| { |
| case Map_type::MAP_ALG_FAST32: |
| case Map_type::MAP_ALG_FAST32PTR: |
| { |
| code = Runtime::MAPACCESS2_FAST32; |
| Type* uint32_type = Type::lookup_integer_type("uint32"); |
| Type* uint32_ptr_type = Type::make_pointer_type(uint32_type); |
| a3 = Expression::make_unsafe_cast(uint32_ptr_type, a3, |
| loc); |
| a3 = Expression::make_dereference(a3, |
| Expression::NIL_CHECK_NOT_NEEDED, |
| loc); |
| break; |
| } |
| case Map_type::MAP_ALG_FAST64: |
| case Map_type::MAP_ALG_FAST64PTR: |
| { |
| code = Runtime::MAPACCESS2_FAST64; |
| Type* uint64_type = Type::lookup_integer_type("uint64"); |
| Type* uint64_ptr_type = Type::make_pointer_type(uint64_type); |
| a3 = Expression::make_unsafe_cast(uint64_ptr_type, a3, |
| loc); |
| a3 = Expression::make_dereference(a3, |
| Expression::NIL_CHECK_NOT_NEEDED, |
| loc); |
| break; |
| } |
| case Map_type::MAP_ALG_FASTSTR: |
| code = Runtime::MAPACCESS2_FASTSTR; |
| a3 = ref; |
| break; |
| default: |
| code = Runtime::MAPACCESS2; |
| break; |
| } |
| call = Runtime::make_call(code, loc, 3, a1, a2, a3); |
| } |
| else |
| call = Runtime::make_call(Runtime::MAPACCESS2_FAT, loc, 4, a1, a2, a3, a4); |
| ref = Expression::make_temporary_reference(val_ptr_temp, loc); |
| ref->set_is_lvalue(); |
| Expression* res = Expression::make_call_result(call, 0); |
| res = Expression::make_unsafe_cast(val_ptr_type, res, loc); |
| Statement* s = Statement::make_assignment(ref, res, loc); |
| b->add_statement(s); |
| ref = Expression::make_temporary_reference(present_temp, loc); |
| ref->set_is_lvalue(); |
| res = Expression::make_call_result(call, 1); |
| s = Statement::make_assignment(ref, res, loc); |
| b->add_statement(s); |
| |
| // val = *val__ptr_temp |
| ref = Expression::make_temporary_reference(val_ptr_temp, loc); |
| Expression* ind = |
| Expression::make_dereference(ref, Expression::NIL_CHECK_NOT_NEEDED, loc); |
| s = Statement::make_assignment(this->val_, ind, 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() << dsuffix(location()) << 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); |
| } |
| |
| // 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((this->closed_->type()->is_sink_type()) |
| ? Type::make_boolean_type() |
| : this->closed_->type(), |
| NULL, loc); |
| b->add_statement(closed_temp); |
| |
| // closed_temp = chanrecv2(channel, &val_temp) |
| 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, 2, this->channel_, p2); |
| ref = Expression::make_temporary_reference(closed_temp, loc); |
| ref->set_is_lvalue(); |
| Statement* s = Statement::make_assignment(ref, call, loc); |
| b->add_statement(s); |
| |
| // 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() << dsuffix(location()) << 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); |
| |
| // var ok_temp bool |
| Temporary_statement* ok_temp = NULL; |
| if (!this->ok_->is_sink_expression()) |
| { |
| ok_temp = Statement::make_temporary(this->ok_->type(), |
| NULL, loc); |
| b->add_statement(ok_temp); |
| } |
| |
| // ok_temp = 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; |
| if (ok_temp == NULL) |
| s = Statement::make_statement(call, true); |
| else |
| { |
| Expression* ok_ref = Expression::make_temporary_reference(ok_temp, loc); |
| s = Statement::make_assignment(ok_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); |
| |
| // ok = ok_temp |
| if (ok_temp != NULL) |
| { |
| ref = Expression::make_temporary_reference(ok_temp, loc); |
| s = Statement::make_assignment(this->ok_, 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() << dsuffix(location()) << 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; |
| } |
| |
| // Export an expression statement. |
| |
| void |
| Expression_statement::do_export_statement(Export_function_body* efb) |
| { |
| this->expr_->export_expression(efb); |
| } |
| |
| // Convert to backend representation. |
| |
| Bstatement* |
| Expression_statement::do_get_backend(Translate_context* context) |
| { |
| Bexpression* bexpr = this->expr_->get_backend(context); |
| Bfunction* bfunction = context->function()->func_value()->get_decl(); |
| return context->backend()->expression_statement(bfunction, bexpr); |
| } |
| |
| // 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() << dsuffix(location()) << 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); |
| } |
| |
| // Export data for a block. |
| |
| void |
| Block_statement::do_export_statement(Export_function_body* efb) |
| { |
| Block_statement::export_block(efb, this->block_, |
| this->is_lowered_for_statement_); |
| } |
| |
| void |
| Block_statement::export_block(Export_function_body* efb, Block* block, |
| bool is_lowered_for_statement) |
| { |
| // We are already indented to the right position. |
| char buf[50]; |
| efb->write_c_string("{"); |
| if (is_lowered_for_statement) |
| efb->write_c_string(" /*for*/"); |
| snprintf(buf, sizeof buf, " //%d\n", |
| Linemap::location_to_line(block->start_location())); |
| efb->write_c_string(buf); |
| |
| block->export_block(efb); |
| // The indentation is correct for the statements in the block, so |
| // subtract one for the closing curly brace. |
| efb->decrement_indent(); |
| efb->indent(); |
| efb->write_c_string("}"); |
| // Increment back to the value the caller thinks it has. |
| efb->increment_indent(); |
| } |
| |
| // Import a block statement, returning the block. |
| |
| Block* |
| Block_statement::do_import(Import_function_body* ifb, Location loc, |
| bool* is_lowered_for_statement) |
| { |
| go_assert(ifb->match_c_string("{")); |
| *is_lowered_for_statement = false; |
| if (ifb->match_c_string(" /*for*/")) |
| { |
| ifb->advance(8); |
| *is_lowered_for_statement = true; |
| } |
| size_t nl = ifb->body().find('\n', ifb->off()); |
| if (nl == std::string::npos) |
| { |
| if (!ifb->saw_error()) |
| go_error_at(ifb->location(), |
| "import error: no newline after %<{%> at %lu", |
| static_cast<unsigned long>(ifb->off())); |
| ifb->set_saw_error(); |
| return NULL; |
| } |
| ifb->set_off(nl + 1); |
| ifb->increment_indent(); |
| Block* block = new Block(ifb->block(), loc); |
| ifb->begin_block(block); |
| bool ok = Block::import_block(block, ifb, loc); |
| ifb->finish_block(); |
| ifb->decrement_indent(); |
| if (!ok) |
| return NULL; |
| return 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. |
| |
| Block_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(); |
| if (!this->expr_->type()->is_numeric_type()) |
| { |
| this->report_error("increment or decrement of non-numeric type"); |
| return Statement::make_error_statement(loc); |
| } |
| Expression* oexpr = Expression::make_integer_ul(1, this->expr_->type(), loc); |
| 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_? "++": "--") << dsuffix(location()) << 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; |
| if (fn->bound_method_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(); |
| Bound_method_expression* bme = fn->bound_method_expression(); |
| |
| Location location = this->location(); |
| |
| bool is_constant_function = this->is_constant_function(); |
| Temporary_statement* fn_temp = NULL; |
| if (!is_constant_function) |
| { |
| fn_temp = Statement::make_temporary(NULL, fn, location); |
| block->insert_statement_before(block->statements()->size() - 1, fn_temp); |
| fn = Expression::make_temporary_reference(fn_temp, 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 (!is_constant_function) |
| vals->push_back(fn); |
| |
| if (interface_method != NULL) |
| vals->push_back(interface_method->expr()); |
| if (bme != NULL) |
| vals->push_back(bme->first_argument()); |
| |
| if (ce->args() != NULL) |
| { |
| for (Expression_list::const_iterator p = ce->args()->begin(); |
| p != ce->args()->end(); |
| ++p) |
| { |
| if ((*p)->is_constant()) |
| continue; |
| 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_expression(constructor, location); |
| if ((Node::make_node(this)->encoding() & ESCAPE_MASK) == Node::ESCAPE_NONE) |
| constructor->heap_expression()->set_allocate_on_stack(); |
| |
| // Throw an error if the function is nil. This is so that for `go |
| // nil` we get a backtrace from the go statement, rather than a |
| // useless backtrace from the brand new goroutine. |
| Expression* param = constructor; |
| if (!is_constant_function && this->classification() == STATEMENT_GO) |
| { |
| fn = Expression::make_temporary_reference(fn_temp, location); |
| Expression* nil = Expression::make_nil(location); |
| Expression* isnil = Expression::make_binary(OPERATOR_EQEQ, fn, nil, |
| location); |
| Expression* crash = Runtime::make_call(Runtime::PANIC_GO_NIL, |
| location, 0); |
| crash = Expression::make_conditional(isnil, crash, |
| Expression::make_nil(location), |
| location); |
| param = Expression::make_compound(crash, 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(param); |
| 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); |
| if ((Node::make_node(this)->encoding() & ESCAPE_MASK) == Node::ESCAPE_NONE) |
| s->defer_statement()->set_on_stack(); |
| } |
| 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)); |
| } |
| |
| // If this thunk statement calls a bound method expression, as in |
| // "go s.m()", we pass the bound method argument to the thunk, |
| // to ensure that we make a copy of it if needed. |
| Bound_method_expression* bme = fn->bound_method_expression(); |
| if (bme != NULL) |
| { |
| Typed_identifier tid("object", bme->first_argument()->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) |
| { |
| if ((*p)->is_constant()) |
| continue; |
| |
| char buf[50]; |
| this->thunk_field_param(i, buf, sizeof buf); |
| fields->push_back(Struct_field(Typed_identifier(buf, (*p)->type(), |
| location))); |
| } |
| } |
| |
| Struct_type *st = Type::make_struct_type(fields, location); |
| st->set_is_struct_incomparable(); |
| return st; |
| } |
| |
| // 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::SETDEFERRETADDR, |
| 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); |
| |
| function->func_value()->set_calls_defer_retaddr(); |
| } |
| |
| // 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_dereference(thunk_parameter, |
| Expression::NIL_CHECK_NOT_NEEDED, |
| location); |
| |
| Interface_field_reference_expression* interface_method = |
| ce->fn()->interface_field_reference_expression(); |
| Bound_method_expression* bme = ce->fn()->bound_method_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; |
| } |
| |
| if (bme != NULL) |
| { |
| // This is a call to a method. |
| go_assert(next_index == 0); |
| Expression* r = Expression::make_field_reference(thunk_parameter, 0, |
| location); |
| func_to_call = Expression::make_bound_method(r, bme->method(), |
| bme->function(), 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; |
| |
| const Expression_list* args = ce->args(); |
| if (args != NULL) |
| { |
| for (Expression_list::const_iterator arg = args->begin(); |
| arg != args->end(); |
| ++arg) |
| { |
| Expression* param; |
| if ((*arg)->is_constant()) |
| param = *arg; |
| else |
| { |
| Expression* thunk_param = |
| Expression::make_var_reference(named_parameter, location); |
| thunk_param = |
| Expression::make_dereference(thunk_param, |
| Expression::NIL_CHECK_NOT_NEEDED, |
| location); |
| param = Expression::make_field_reference(thunk_param, |
| next_index, |
| location); |
| ++next_index; |
| } |
| |
| 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); |
| |
| // 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(); |
| |
| gogo->add_conversions_in_block(b); |
| |
| if (may_call_recover |
| || recover_arg != NULL |
| || this->classification() == STATEMENT_GO) |
| { |
| // 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); |
| ce = es->expr()->call_expression(); |
| if (ce == NULL) |
| go_assert(saw_errors()); |
| else |
| { |
| if (may_call_recover) |
| ce->set_is_deferred(); |
| if (this->classification() == STATEMENT_GO) |
| ce->set_is_concurrent(); |
| if (recover_arg != NULL) |
| ce->set_recover_arg(recover_arg); |
| } |
| } |
| |
| gogo->flatten_block(function, b); |
| |
| // 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); |
| |