LCOV - code coverage report
Current view: top level - gcc/go/gofrontend - statements.cc (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2747 3301 83.2 %
Date: 2020-07-04 13:15:35 Functions: 222 280 79.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // statements.cc -- Go frontend statements.
       2                 :            : 
       3                 :            : // Copyright 2009 The Go Authors. All rights reserved.
       4                 :            : // Use of this source code is governed by a BSD-style
       5                 :            : // license that can be found in the LICENSE file.
       6                 :            : 
       7                 :            : #include "go-system.h"
       8                 :            : 
       9                 :            : #include "go-c.h"
      10                 :            : #include "go-diagnostics.h"
      11                 :            : #include "types.h"
      12                 :            : #include "expressions.h"
      13                 :            : #include "gogo.h"
      14                 :            : #include "export.h"
      15                 :            : #include "import.h"
      16                 :            : #include "runtime.h"
      17                 :            : #include "backend.h"
      18                 :            : #include "statements.h"
      19                 :            : #include "ast-dump.h"
      20                 :            : 
      21                 :            : // Class Statement.
      22                 :            : 
      23                 :    6703911 : Statement::Statement(Statement_classification classification,
      24                 :    6703911 :                      Location location)
      25                 :    6703911 :   : classification_(classification), location_(location)
      26                 :            : {
      27                 :    6703911 : }
      28                 :            : 
      29                 :          0 : Statement::~Statement()
      30                 :            : {
      31                 :          0 : }
      32                 :            : 
      33                 :            : // Traverse the tree.  The work of walking the components is handled
      34                 :            : // by the subclasses.
      35                 :            : 
      36                 :            : int
      37                 :   80260348 : Statement::traverse(Block* block, size_t* pindex, Traverse* traverse)
      38                 :            : {
      39                 :   80260348 :   if (this->classification_ == STATEMENT_ERROR)
      40                 :            :     return TRAVERSE_CONTINUE;
      41                 :            : 
      42                 :   80258848 :   unsigned int traverse_mask = traverse->traverse_mask();
      43                 :            : 
      44                 :   80258848 :   if ((traverse_mask & Traverse::traverse_statements) != 0)
      45                 :            :     {
      46                 :   47909885 :       int t = traverse->statement(block, pindex, this);
      47                 :   47909885 :       if (t == TRAVERSE_EXIT)
      48                 :            :         return TRAVERSE_EXIT;
      49                 :   47892471 :       else if (t == TRAVERSE_SKIP_COMPONENTS)
      50                 :            :         return TRAVERSE_CONTINUE;
      51                 :            :     }
      52                 :            : 
      53                 :            :   // No point in checking traverse_mask here--a statement may contain
      54                 :            :   // other blocks or statements, and if we got here we always want to
      55                 :            :   // walk them.
      56                 :   68557472 :   return this->do_traverse(traverse);
      57                 :            : }
      58                 :            : 
      59                 :            : // Traverse the contents of a statement.
      60                 :            : 
      61                 :            : int
      62                 :   19974388 : Statement::traverse_contents(Traverse* traverse)
      63                 :            : {
      64                 :   19974388 :   return this->do_traverse(traverse);
      65                 :            : }
      66                 :            : 
      67                 :            : // Traverse assignments.
      68                 :            : 
      69                 :            : bool
      70                 :          0 : Statement::traverse_assignments(Traverse_assignments* tassign)
      71                 :            : {
      72                 :          0 :   if (this->classification_ == STATEMENT_ERROR)
      73                 :            :     return false;
      74                 :          0 :   return this->do_traverse_assignments(tassign);
      75                 :            : }
      76                 :            : 
      77                 :            : // Traverse an expression in a statement.  This is a helper function
      78                 :            : // for child classes.
      79                 :            : 
      80                 :            : int
      81                 :   60759759 : Statement::traverse_expression(Traverse* traverse, Expression** expr)
      82                 :            : {
      83                 :   60759759 :   if ((traverse->traverse_mask()
      84                 :   60759759 :        & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
      85                 :            :     return TRAVERSE_CONTINUE;
      86                 :   44397029 :   return Expression::traverse(expr, traverse);
      87                 :            : }
      88                 :            : 
      89                 :            : // Traverse an expression list in a statement.  This is a helper
      90                 :            : // function for child classes.
      91                 :            : 
      92                 :            : int
      93                 :    6088630 : Statement::traverse_expression_list(Traverse* traverse,
      94                 :            :                                     Expression_list* expr_list)
      95                 :            : {
      96                 :    6088630 :   if (expr_list == NULL)
      97                 :            :     return TRAVERSE_CONTINUE;
      98                 :     633941 :   if ((traverse->traverse_mask()
      99                 :     633941 :        & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
     100                 :            :     return TRAVERSE_CONTINUE;
     101                 :     633941 :   return expr_list->traverse(traverse);
     102                 :            : }
     103                 :            : 
     104                 :            : // Traverse a type in a statement.  This is a helper function for
     105                 :            : // child classes.
     106                 :            : 
     107                 :            : int
     108                 :   10052180 : Statement::traverse_type(Traverse* traverse, Type* type)
     109                 :            : {
     110                 :   10052180 :   if ((traverse->traverse_mask()
     111                 :   10052180 :        & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
     112                 :            :     return TRAVERSE_CONTINUE;
     113                 :    7176332 :   return Type::traverse(type, traverse);
     114                 :            : }
     115                 :            : 
     116                 :            : // Set type information for unnamed constants.  This is really done by
     117                 :            : // the child class.
     118                 :            : 
     119                 :            : void
     120                 :    3197639 : Statement::determine_types()
     121                 :            : {
     122                 :    3197639 :   this->do_determine_types();
     123                 :    3197639 : }
     124                 :            : 
     125                 :            : // Read a statement from export data.
     126                 :            : 
     127                 :            : Statement*
     128                 :      54720 : Statement::import_statement(Import_function_body* ifb, Location loc)
     129                 :            : {
     130                 :      54720 :   if (ifb->match_c_string("{"))
     131                 :            :     {
     132                 :      17042 :       bool is_lowered_for_statement;
     133                 :      17042 :       Block* block = Block_statement::do_import(ifb, loc,
     134                 :            :                                                 &is_lowered_for_statement);
     135                 :      17042 :       if (block == NULL)
     136                 :          0 :         return Statement::make_error_statement(loc);
     137                 :      17042 :       Block_statement* s = Statement::make_block_statement(block, loc);
     138                 :      17042 :       if (is_lowered_for_statement)
     139                 :          0 :         s->set_is_lowered_for_statement();
     140                 :      17042 :       return s;
     141                 :            :     }
     142                 :      37678 :   else if (ifb->match_c_string("return"))
     143                 :            :     {
     144                 :            :       // After lowering return statements have no expressions.  The
     145                 :            :       // return expressions are assigned to result parameters.
     146                 :      10782 :       ifb->advance(6);
     147                 :      10782 :       return Statement::make_return_statement(NULL, loc);
     148                 :            :     }
     149                 :      26896 :   else if (ifb->match_c_string("var $t"))
     150                 :       1269 :     return Temporary_statement::do_import(ifb, loc);
     151                 :      25627 :   else if (ifb->match_c_string("var "))
     152                 :       2360 :     return Variable_declaration_statement::do_import(ifb, loc);
     153                 :      23267 :   else if (ifb->match_c_string("if "))
     154                 :       3999 :     return If_statement::do_import(ifb, loc);
     155                 :      19268 :   else if (ifb->match_c_string(":"))
     156                 :       1108 :     return Label_statement::do_import(ifb, loc);
     157                 :      18160 :   else if (ifb->match_c_string("goto "))
     158                 :       1163 :     return Goto_statement::do_import(ifb, loc);
     159                 :            : 
     160                 :      16997 :   Expression* lhs = Expression::import_expression(ifb, loc);
     161                 :            : 
     162                 :      16997 :   if (ifb->match_c_string(" //"))
     163                 :       3194 :     return Statement::make_statement(lhs, true);
     164                 :            : 
     165                 :      13803 :   ifb->require_c_string(" = ");
     166                 :      13803 :   Expression* rhs = Expression::import_expression(ifb, loc);
     167                 :      13803 :   return Statement::make_assignment(lhs, rhs, loc);
     168                 :            : }
     169                 :            : 
     170                 :            : // If this is a thunk statement, return it.
     171                 :            : 
     172                 :            : Thunk_statement*
     173                 :    1799819 : Statement::thunk_statement()
     174                 :            : {
     175                 :    1799819 :   Thunk_statement* ret = this->convert<Thunk_statement, STATEMENT_GO>();
     176                 :    1795202 :   if (ret == NULL)
     177                 :    1795202 :     ret = this->convert<Thunk_statement, STATEMENT_DEFER>();
     178                 :    1799819 :   return ret;
     179                 :            : }
     180                 :            : 
     181                 :            : // Convert a Statement to the backend representation.  This is really
     182                 :            : // done by the child class.
     183                 :            : 
     184                 :            : Bstatement*
     185                 :    6267013 : Statement::get_backend(Translate_context* context)
     186                 :            : {
     187                 :    6267013 :   if (this->classification_ == STATEMENT_ERROR)
     188                 :        362 :     return context->backend()->error_statement();
     189                 :    6266651 :   return this->do_get_backend(context);
     190                 :            : }
     191                 :            : 
     192                 :            : // Dump AST representation for a statement to a dump context.
     193                 :            : 
     194                 :            : void
     195                 :          0 : Statement::dump_statement(Ast_dump_context* ast_dump_context) const
     196                 :            : {
     197                 :          0 :   this->do_dump_statement(ast_dump_context);
     198                 :          0 : }
     199                 :            : 
     200                 :            : // Note that this statement is erroneous.  This is called by children
     201                 :            : // when they discover an error.
     202                 :            : 
     203                 :            : void
     204                 :        182 : Statement::set_is_error()
     205                 :            : {
     206                 :        182 :   this->classification_ = STATEMENT_ERROR;
     207                 :        182 : }
     208                 :            : 
     209                 :            : // For children to call to report an error conveniently.
     210                 :            : 
     211                 :            : void
     212                 :         18 : Statement::report_error(const char* msg)
     213                 :            : {
     214                 :         18 :   go_error_at(this->location_, "%s", msg);
     215                 :         18 :   this->set_is_error();
     216                 :         18 : }
     217                 :            : 
     218                 :            : // An error statement, used to avoid crashing after we report an
     219                 :            : // error.
     220                 :            : 
     221                 :            : class Error_statement : public Statement
     222                 :            : {
     223                 :            :  public:
     224                 :        228 :   Error_statement(Location location)
     225                 :        456 :     : Statement(STATEMENT_ERROR, location)
     226                 :            :   { }
     227                 :            : 
     228                 :            :  protected:
     229                 :            :   int
     230                 :        228 :   do_traverse(Traverse*)
     231                 :        228 :   { return TRAVERSE_CONTINUE; }
     232                 :            : 
     233                 :            :   Bstatement*
     234                 :          0 :   do_get_backend(Translate_context*)
     235                 :          0 :   { go_unreachable(); }
     236                 :            : 
     237                 :            :   void
     238                 :            :   do_dump_statement(Ast_dump_context*) const;
     239                 :            : };
     240                 :            : 
     241                 :            : //
     242                 :            : // Helper to tack on available source position information
     243                 :            : // at the end of a statement.
     244                 :            : //
     245                 :            : static std::string
     246                 :          0 : dsuffix(Location location)
     247                 :            : {
     248                 :          0 :   std::string lstr = Linemap::location_to_string(location);
     249                 :          0 :   if (lstr == "")
     250                 :          0 :     return lstr;
     251                 :          0 :   std::string rval(" // ");
     252                 :          0 :   rval += lstr;
     253                 :          0 :   return rval;
     254                 :            : }
     255                 :            : 
     256                 :            : // Dump the AST representation for an error statement.
     257                 :            : 
     258                 :            : void
     259                 :          0 : Error_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
     260                 :            : {
     261                 :          0 :   ast_dump_context->print_indent();
     262                 :          0 :   ast_dump_context->ostream() << "Error statement" << std::endl;
     263                 :          0 : }
     264                 :            : 
     265                 :            : // Make an error statement.
     266                 :            : 
     267                 :            : Statement*
     268                 :        228 : Statement::make_error_statement(Location location)
     269                 :            : {
     270                 :        228 :   return new Error_statement(location);
     271                 :            : }
     272                 :            : 
     273                 :            : // Class Variable_declaration_statement.
     274                 :            : 
     275                 :     308910 : Variable_declaration_statement::Variable_declaration_statement(
     276                 :     308910 :     Named_object* var)
     277                 :            :   : Statement(STATEMENT_VARIABLE_DECLARATION, var->var_value()->location()),
     278                 :     308910 :     var_(var)
     279                 :            : {
     280                 :     308910 : }
     281                 :            : 
     282                 :            : // We don't actually traverse the variable here; it was traversed
     283                 :            : // while traversing the Block.
     284                 :            : 
     285                 :            : int
     286                 :    6710326 : Variable_declaration_statement::do_traverse(Traverse*)
     287                 :            : {
     288                 :    6710326 :   return TRAVERSE_CONTINUE;
     289                 :            : }
     290                 :            : 
     291                 :            : // Traverse the assignments in a variable declaration.  Note that this
     292                 :            : // traversal is different from the usual traversal.
     293                 :            : 
     294                 :            : bool
     295                 :          0 : Variable_declaration_statement::do_traverse_assignments(
     296                 :            :     Traverse_assignments* tassign)
     297                 :            : {
     298                 :          0 :   tassign->initialize_variable(this->var_);
     299                 :          0 :   return true;
     300                 :            : }
     301                 :            : 
     302                 :            : // Lower the variable's initialization expression.
     303                 :            : 
     304                 :            : Statement*
     305                 :     445817 : Variable_declaration_statement::do_lower(Gogo* gogo, Named_object* function,
     306                 :            :                                          Block*, Statement_inserter* inserter)
     307                 :            : {
     308                 :     445817 :   this->var_->var_value()->lower_init_expression(gogo, function, inserter);
     309                 :     445817 :   return this;
     310                 :            : }
     311                 :            : 
     312                 :            : // Flatten the variable's initialization expression.
     313                 :            : 
     314                 :            : Statement*
     315                 :     325293 : Variable_declaration_statement::do_flatten(Gogo* gogo, Named_object* function,
     316                 :            :                                            Block*, Statement_inserter* inserter)
     317                 :            : {
     318                 :     325293 :   Variable* var = this->var_->var_value();
     319                 :     325293 :   if (var->type()->is_error_type()
     320                 :     325293 :       || (var->init() != NULL
     321                 :     246917 :           && var->init()->is_error_expression()))
     322                 :            :     {
     323                 :         33 :       go_assert(saw_errors());
     324                 :         33 :       return Statement::make_error_statement(this->location());
     325                 :            :     }
     326                 :     325260 :   this->var_->var_value()->flatten_init_expression(gogo, function, inserter);
     327                 :     325260 :   return this;
     328                 :            : }
     329                 :            : 
     330                 :            : // Add explicit type conversions.
     331                 :            : 
     332                 :            : void
     333                 :     307879 : Variable_declaration_statement::do_add_conversions()
     334                 :            : {
     335                 :     307879 :   Variable* var = this->var_->var_value();
     336                 :     307879 :   Expression* init = var->init();
     337                 :     307879 :   if (init == NULL)
     338                 :            :     return;
     339                 :     239782 :   Type* lt = var->type();
     340                 :     239782 :   Type* rt = init->type();
     341                 :     239782 :   if (!Type::are_identical(lt, rt, 0, NULL)
     342                 :     239782 :       && lt->interface_type() != NULL)
     343                 :        243 :     var->set_init(Expression::make_cast(lt, init, this->location()));
     344                 :            : }
     345                 :            : 
     346                 :            : // Convert a variable declaration to the backend representation.
     347                 :            : 
     348                 :            : Bstatement*
     349                 :     307778 : Variable_declaration_statement::do_get_backend(Translate_context* context)
     350                 :            : {
     351                 :     307778 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
     352                 :     307778 :   Variable* var = this->var_->var_value();
     353                 :     307778 :   Bvariable* bvar = this->var_->get_backend_variable(context->gogo(),
     354                 :            :                                                      context->function());
     355                 :     307778 :   Bexpression* binit = var->get_init(context->gogo(), context->function());
     356                 :            : 
     357                 :     307778 :   if (!var->is_in_heap())
     358                 :            :     {
     359                 :     295832 :       go_assert(binit != NULL);
     360                 :     295832 :       return context->backend()->init_statement(bfunction, bvar, binit);
     361                 :            :     }
     362                 :            : 
     363                 :            :   // Something takes the address of this variable, so the value is
     364                 :            :   // stored in the heap.  Initialize it to newly allocated memory
     365                 :            :   // space, and assign the initial value to the new space.
     366                 :      11946 :   Location loc = this->location();
     367                 :      11946 :   Named_object* newfn = context->gogo()->lookup_global("new");
     368                 :      11946 :   go_assert(newfn != NULL && newfn->is_function_declaration());
     369                 :      11946 :   Expression* func = Expression::make_func_reference(newfn, NULL, loc);
     370                 :      11946 :   Expression_list* params = new Expression_list();
     371                 :      11946 :   params->push_back(Expression::make_type(var->type(), loc));
     372                 :      11946 :   Expression* call = Expression::make_call(func, params, false, loc);
     373                 :      11946 :   context->gogo()->lower_expression(context->function(), NULL, &call);
     374                 :      11946 :   Temporary_statement* temp = Statement::make_temporary(NULL, call, loc);
     375                 :      11946 :   Bstatement* btemp = temp->get_backend(context);
     376                 :            : 
     377                 :      11946 :   Bstatement* set = NULL;
     378                 :      11946 :   if (binit != NULL)
     379                 :            :     {
     380                 :        978 :       Expression* e = Expression::make_temporary_reference(temp, loc);
     381                 :        978 :       e = Expression::make_dereference(e, Expression::NIL_CHECK_NOT_NEEDED,
     382                 :            :                                        loc);
     383                 :        978 :       Bexpression* be = e->get_backend(context);
     384                 :        978 :       set = context->backend()->assignment_statement(bfunction, be, binit, loc);
     385                 :            :     }
     386                 :            : 
     387                 :      11946 :   Expression* ref = Expression::make_temporary_reference(temp, loc);
     388                 :      11946 :   Bexpression* bref = ref->get_backend(context);
     389                 :      11946 :   Bstatement* sinit = context->backend()->init_statement(bfunction, bvar, bref);
     390                 :            : 
     391                 :      11946 :   std::vector<Bstatement*> stats;
     392                 :      11946 :   stats.reserve(3);
     393                 :      11946 :   stats.push_back(btemp);
     394                 :      11946 :   if (set != NULL)
     395                 :        978 :     stats.push_back(set);
     396                 :      11946 :   stats.push_back(sinit);
     397                 :      11946 :   return context->backend()->statement_list(stats);
     398                 :            : }
     399                 :            : 
     400                 :            : // Dump the AST representation for a variable declaration.
     401                 :            : 
     402                 :            : void
     403                 :          0 : Variable_declaration_statement::do_dump_statement(
     404                 :            :     Ast_dump_context* ast_dump_context) const
     405                 :            : {
     406                 :          0 :   ast_dump_context->print_indent();
     407                 :            : 
     408                 :          0 :   go_assert(var_->is_variable());
     409                 :          0 :   ast_dump_context->ostream() << "var " << this->var_->name() <<  " ";
     410                 :          0 :   Variable* var = this->var_->var_value();
     411                 :          0 :   if (var->has_type())
     412                 :            :     {
     413                 :          0 :       ast_dump_context->dump_type(var->type());
     414                 :          0 :       ast_dump_context->ostream() << " ";
     415                 :            :     }
     416                 :          0 :   if (var->init() != NULL)
     417                 :            :     {
     418                 :          0 :       ast_dump_context->ostream() <<  "= ";
     419                 :          0 :       ast_dump_context->dump_expression(var->init());
     420                 :            :     }
     421                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
     422                 :          0 : }
     423                 :            : 
     424                 :            : // Make a variable declaration.
     425                 :            : 
     426                 :            : Statement*
     427                 :     308910 : Statement::make_variable_declaration(Named_object* var)
     428                 :            : {
     429                 :     308910 :   return new Variable_declaration_statement(var);
     430                 :            : }
     431                 :            : 
     432                 :            : // Export a variable declaration.
     433                 :            : 
     434                 :            : void
     435                 :       3677 : Variable_declaration_statement::do_export_statement(Export_function_body* efb)
     436                 :            : {
     437                 :       3677 :   efb->write_c_string("var ");
     438                 :       3677 :   efb->write_string(Gogo::unpack_hidden_name(this->var_->name()));
     439                 :       3677 :   efb->write_c_string(" ");
     440                 :       3677 :   Variable* var = this->var_->var_value();
     441                 :       3677 :   Type* type = var->type();
     442                 :       3677 :   efb->write_type(type);
     443                 :       3677 :   Expression* init = var->init();
     444                 :       3677 :   if (init != NULL)
     445                 :            :     {
     446                 :       2631 :       efb->write_c_string(" = ");
     447                 :            : 
     448                 :       2631 :       go_assert(efb->type_context() == NULL);
     449                 :       2631 :       efb->set_type_context(type);
     450                 :            : 
     451                 :       2631 :       init->export_expression(efb);
     452                 :            : 
     453                 :       2631 :       efb->set_type_context(NULL);
     454                 :            :     }
     455                 :       3677 : }
     456                 :            : 
     457                 :            : // Import a variable declaration.
     458                 :            : 
     459                 :            : Statement*
     460                 :       2360 : Variable_declaration_statement::do_import(Import_function_body* ifb,
     461                 :            :                                           Location loc)
     462                 :            : {
     463                 :       2360 :   ifb->require_c_string("var ");
     464                 :       2360 :   std::string id = ifb->read_identifier();
     465                 :       2360 :   ifb->require_c_string(" ");
     466                 :       2360 :   Type* type = ifb->read_type();
     467                 :       2360 :   Expression* init = NULL;
     468                 :       2360 :   if (ifb->match_c_string(" = "))
     469                 :            :     {
     470                 :       1845 :       ifb->advance(3);
     471                 :       1845 :       init = Expression::import_expression(ifb, loc);
     472                 :            :     }
     473                 :       2360 :   Variable* var = new Variable(type, init, false, false, false, loc);
     474                 :       2360 :   var->set_is_used();
     475                 :            :   // FIXME: The package we are importing does not yet exist, so we
     476                 :            :   // can't pass the correct package here.  It probably doesn't matter.
     477                 :       2360 :   Named_object* no = ifb->block()->bindings()->add_variable(id, NULL, var);
     478                 :       2360 :   return Statement::make_variable_declaration(no);
     479                 :            : }
     480                 :            : 
     481                 :            : // Class Temporary_statement.
     482                 :            : 
     483                 :            : // Return the type of the temporary variable.
     484                 :            : 
     485                 :            : Type*
     486                 :   23443732 : Temporary_statement::type() const
     487                 :            : {
     488                 :   23443732 :   Type* type = this->type_ != NULL ? this->type_ : this->init_->type();
     489                 :            : 
     490                 :            :   // Temporary variables cannot have a void type.
     491                 :   23443732 :   if (type->is_void_type())
     492                 :            :     {
     493                 :          0 :       go_assert(saw_errors());
     494                 :          0 :       return Type::make_error_type();
     495                 :            :     }
     496                 :            :   return type;
     497                 :            : }
     498                 :            : 
     499                 :            : // Traversal.
     500                 :            : 
     501                 :            : int
     502                 :   14838091 : Temporary_statement::do_traverse(Traverse* traverse)
     503                 :            : {
     504                 :   14838091 :   if (this->type_ != NULL
     505                 :   14838091 :       && this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT)
     506                 :            :     return TRAVERSE_EXIT;
     507                 :   14838091 :   if (this->init_ == NULL)
     508                 :            :     return TRAVERSE_CONTINUE;
     509                 :            :   else
     510                 :   11607856 :     return this->traverse_expression(traverse, &this->init_);
     511                 :            : }
     512                 :            : 
     513                 :            : // Traverse assignments.
     514                 :            : 
     515                 :            : bool
     516                 :          0 : Temporary_statement::do_traverse_assignments(Traverse_assignments* tassign)
     517                 :            : {
     518                 :          0 :   if (this->init_ == NULL)
     519                 :            :     return false;
     520                 :          0 :   tassign->value(&this->init_, true, true);
     521                 :          0 :   return true;
     522                 :            : }
     523                 :            : 
     524                 :            : // Determine types.
     525                 :            : 
     526                 :            : void
     527                 :     387297 : Temporary_statement::do_determine_types()
     528                 :            : {
     529                 :     387297 :   if (this->type_ != NULL && this->type_->is_abstract())
     530                 :        238 :     this->type_ = this->type_->make_non_abstract_type();
     531                 :            : 
     532                 :     387297 :   if (this->init_ != NULL)
     533                 :            :     {
     534                 :     250175 :       if (this->type_ == NULL)
     535                 :      61622 :         this->init_->determine_type_no_context();
     536                 :            :       else
     537                 :            :         {
     538                 :     188553 :           Type_context context(this->type_, false);
     539                 :     188553 :           this->init_->determine_type(&context);
     540                 :            :         }
     541                 :            :     }
     542                 :            : 
     543                 :     387297 :   if (this->type_ == NULL)
     544                 :            :     {
     545                 :      61622 :       this->type_ = this->init_->type();
     546                 :      61622 :       go_assert(!this->type_->is_abstract());
     547                 :            :     }
     548                 :     387297 : }
     549                 :            : 
     550                 :            : // Check types.
     551                 :            : 
     552                 :            : void
     553                 :     390907 : Temporary_statement::do_check_types(Gogo*)
     554                 :            : {
     555                 :     390907 :   if (this->type_ != NULL && this->init_ != NULL)
     556                 :            :     {
     557                 :     500366 :       std::string reason;
     558                 :     250183 :       if (!Type::are_assignable(this->type_, this->init_->type(), &reason))
     559                 :            :         {
     560                 :          0 :           if (reason.empty())
     561                 :          0 :             go_error_at(this->location(), "incompatible types in assignment");
     562                 :            :           else
     563                 :          0 :             go_error_at(this->location(), "incompatible types in assignment (%s)",
     564                 :            :                      reason.c_str());
     565                 :          0 :           this->set_is_error();
     566                 :            :         }
     567                 :            :     }
     568                 :     390907 : }
     569                 :            : 
     570                 :            : // Flatten a temporary statement: add another temporary when it might
     571                 :            : // be needed for interface conversion.
     572                 :            : 
     573                 :            : Statement*
     574                 :    1175572 : Temporary_statement::do_flatten(Gogo*, Named_object*, Block*,
     575                 :            :                                 Statement_inserter* inserter)
     576                 :            : {
     577                 :    1175572 :   if (this->type()->is_error_type()
     578                 :    1175572 :       || (this->init_ != NULL
     579                 :    1007284 :           && this->init_->is_error_expression()))
     580                 :            :     {
     581                 :         24 :       go_assert(saw_errors());
     582                 :         24 :       return Statement::make_error_statement(this->location());
     583                 :            :     }
     584                 :            : 
     585                 :    1175548 :   if (this->type_ != NULL
     586                 :     588033 :       && this->init_ != NULL
     587                 :     419762 :       && !Type::are_identical(this->type_, this->init_->type(),
     588                 :            :                               Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
     589                 :            :                               NULL)
     590                 :      12584 :       && this->init_->type()->interface_type() != NULL
     591                 :    1175548 :       && !this->init_->is_variable())
     592                 :            :     {
     593                 :          0 :       Temporary_statement *temp =
     594                 :          0 :         Statement::make_temporary(NULL, this->init_, this->location());
     595                 :          0 :       inserter->insert(temp);
     596                 :          0 :       this->init_ = Expression::make_temporary_reference(temp,
     597                 :            :                                                          this->location());
     598                 :            :     }
     599                 :    1175548 :   return this;
     600                 :            : }
     601                 :            : 
     602                 :            : // Add explicit type conversions.
     603                 :            : 
     604                 :            : void
     605                 :     385843 : Temporary_statement::do_add_conversions()
     606                 :            : {
     607                 :     385843 :   if (this->init_ == NULL)
     608                 :            :     return;
     609                 :     249219 :   Type* lt = this->type();
     610                 :     249219 :   Type* rt = this->init_->type();
     611                 :     249219 :   if (!Type::are_identical(lt, rt, 0, NULL)
     612                 :     249219 :       && lt->interface_type() != NULL)
     613                 :      18104 :     this->init_ = Expression::make_cast(lt, this->init_, this->location());
     614                 :            : }
     615                 :            : 
     616                 :            : // Convert to backend representation.
     617                 :            : 
     618                 :            : Bstatement*
     619                 :    1828533 : Temporary_statement::do_get_backend(Translate_context* context)
     620                 :            : {
     621                 :    1828533 :   go_assert(this->bvariable_ == NULL);
     622                 :            : 
     623                 :    1828533 :   Named_object* function = context->function();
     624                 :    1828533 :   go_assert(function != NULL);
     625                 :    1828533 :   Bfunction* bfunction = function->func_value()->get_decl();
     626                 :    1828533 :   Btype* btype = this->type()->get_backend(context->gogo());
     627                 :            : 
     628                 :    1828533 :   Bexpression* binit;
     629                 :    1828533 :   if (this->init_ == NULL)
     630                 :            :     binit = NULL;
     631                 :    1661121 :   else if (this->type_ == NULL)
     632                 :    1201612 :     binit = this->init_->get_backend(context);
     633                 :            :   else
     634                 :            :     {
     635                 :     459509 :       Expression* init = Expression::convert_for_assignment(context->gogo(),
     636                 :            :                                                             this->type_,
     637                 :            :                                                             this->init_,
     638                 :            :                                                             this->location());
     639                 :     459509 :       binit = init->get_backend(context);
     640                 :            :     }
     641                 :            : 
     642                 :    1661121 :   if (binit != NULL)
     643                 :    1661121 :     binit = context->backend()->convert_expression(btype, binit,
     644                 :    1661121 :                                                    this->location());
     645                 :            : 
     646                 :    1828533 :   Bstatement* statement;
     647                 :    1828533 :   this->bvariable_ =
     648                 :    1828533 :     context->backend()->temporary_variable(bfunction, context->bblock(),
     649                 :            :                                            btype, binit,
     650                 :    1828533 :                                            this->is_address_taken_,
     651                 :    1828533 :                                            this->location(), &statement);
     652                 :    1828533 :   return statement;
     653                 :            : }
     654                 :            : 
     655                 :            : // Return the backend variable.
     656                 :            : 
     657                 :            : Bvariable*
     658                 :    3373951 : Temporary_statement::get_backend_variable(Translate_context* context) const
     659                 :            : {
     660                 :    3373951 :   if (this->bvariable_ == NULL)
     661                 :            :     {
     662                 :          6 :       go_assert(saw_errors());
     663                 :          6 :       return context->backend()->error_variable();
     664                 :            :     }
     665                 :            :   return this->bvariable_;
     666                 :            : }
     667                 :            : 
     668                 :            : // Dump the AST represemtation for a temporary statement
     669                 :            : 
     670                 :            : void
     671                 :          0 : Temporary_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
     672                 :            : {
     673                 :          0 :   ast_dump_context->print_indent();
     674                 :          0 :   ast_dump_context->dump_temp_variable_name(this);
     675                 :          0 :   if (this->type_ != NULL)
     676                 :            :     {
     677                 :          0 :       ast_dump_context->ostream() << " ";
     678                 :          0 :       ast_dump_context->dump_type(this->type_);
     679                 :            :     }
     680                 :          0 :   if (this->init_ != NULL)
     681                 :            :     {
     682                 :          0 :       ast_dump_context->ostream() << " = ";
     683                 :          0 :       ast_dump_context->dump_expression(this->init_);
     684                 :            :     }
     685                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
     686                 :          0 : }
     687                 :            : 
     688                 :            : // Make and initialize a temporary variable in BLOCK.
     689                 :            : 
     690                 :            : Temporary_statement*
     691                 :    1830458 : Statement::make_temporary(Type* type, Expression* init,
     692                 :            :                           Location location)
     693                 :            : {
     694                 :    1830458 :   return new Temporary_statement(type, init, location);
     695                 :            : }
     696                 :            : 
     697                 :            : // Export a temporary statement.
     698                 :            : 
     699                 :            : void
     700                 :       3818 : Temporary_statement::do_export_statement(Export_function_body* efb)
     701                 :            : {
     702                 :       3818 :   unsigned int idx = efb->record_temporary(this);
     703                 :       3818 :   char buf[100];
     704                 :       3818 :   snprintf(buf, sizeof buf, "var $t%u", idx);
     705                 :       3818 :   efb->write_c_string(buf);
     706                 :       3818 :   if (this->type_ != NULL)
     707                 :            :     {
     708                 :       3818 :       efb->write_c_string(" ");
     709                 :       3818 :       efb->write_type(this->type_);
     710                 :            :     }
     711                 :       3818 :   if (this->init_ != NULL)
     712                 :            :     {
     713                 :       3308 :       efb->write_c_string(" = ");
     714                 :            : 
     715                 :       3308 :       go_assert(efb->type_context() == NULL);
     716                 :       3308 :       efb->set_type_context(this->type_);
     717                 :            : 
     718                 :       3308 :       this->init_->export_expression(efb);
     719                 :            : 
     720                 :       3308 :       efb->set_type_context(NULL);
     721                 :            :     }
     722                 :       3818 : }
     723                 :            : 
     724                 :            : // Import a temporary statement.
     725                 :            : 
     726                 :            : Statement*
     727                 :       1269 : Temporary_statement::do_import(Import_function_body* ifb, Location loc)
     728                 :            : {
     729                 :       1269 :   ifb->require_c_string("var ");
     730                 :       1269 :   std::string id = ifb->read_identifier();
     731                 :       1269 :   go_assert(id[0] == '$' && id[1] == 't');
     732                 :       1269 :   const char *p = id.c_str();
     733                 :       1269 :   char *end;
     734                 :       1269 :   long idx = strtol(p + 2, &end, 10);
     735                 :       1269 :   if (*end != '\0' || idx > 0x7fffffff)
     736                 :            :     {
     737                 :          0 :       if (!ifb->saw_error())
     738                 :          0 :         go_error_at(loc,
     739                 :            :                     ("invalid export data for %qs: "
     740                 :            :                      "bad temporary statement index at %lu"),
     741                 :          0 :                     ifb->name().c_str(),
     742                 :          0 :                     static_cast<unsigned long>(ifb->off()));
     743                 :          0 :       ifb->set_saw_error();
     744                 :          0 :       return Statement::make_error_statement(loc);
     745                 :            :     }
     746                 :            : 
     747                 :       1269 :   Type* type = NULL;
     748                 :       1269 :   if (!ifb->match_c_string(" = "))
     749                 :            :     {
     750                 :       1269 :       ifb->require_c_string(" ");
     751                 :       1269 :       type = ifb->read_type();
     752                 :            :     }
     753                 :       1269 :   Expression* init = NULL;
     754                 :       1269 :   if (ifb->match_c_string(" = "))
     755                 :            :     {
     756                 :        927 :       ifb->advance(3);
     757                 :        927 :       init = Expression::import_expression(ifb, loc);
     758                 :            :     }
     759                 :       1269 :   if (type == NULL && init == NULL)
     760                 :            :     {
     761                 :          0 :       if (!ifb->saw_error())
     762                 :          0 :         go_error_at(loc,
     763                 :            :                     ("invalid export data for %qs: "
     764                 :            :                      "temporary statement has neither type nor init at %lu"),
     765                 :          0 :                     ifb->name().c_str(),
     766                 :          0 :                     static_cast<unsigned long>(ifb->off()));
     767                 :          0 :       ifb->set_saw_error();
     768                 :          0 :       return Statement::make_error_statement(loc);
     769                 :            :     }
     770                 :            : 
     771                 :       1269 :   Temporary_statement* temp = Statement::make_temporary(type, init, loc);
     772                 :            : 
     773                 :       1269 :   ifb->record_temporary(temp, static_cast<unsigned int>(idx));
     774                 :            : 
     775                 :       1269 :   return temp;
     776                 :            : }
     777                 :            : 
     778                 :            : // The Move_subexpressions class is used to move all top-level
     779                 :            : // subexpressions of an expression.  This is used for things like
     780                 :            : // index expressions in which we must evaluate the index value before
     781                 :            : // it can be changed by a multiple assignment.
     782                 :            : 
     783                 :      15376 : class Move_subexpressions : public Traverse
     784                 :            : {
     785                 :            :  public:
     786                 :      15376 :   Move_subexpressions(int skip, Block* block)
     787                 :      15376 :     : Traverse(traverse_expressions),
     788                 :      15376 :       skip_(skip), block_(block)
     789                 :            :   { }
     790                 :            : 
     791                 :            :  protected:
     792                 :            :   int
     793                 :            :   expression(Expression**);
     794                 :            : 
     795                 :            :  private:
     796                 :            :   // The number of subexpressions to skip moving.  This is used to
     797                 :            :   // avoid moving the array itself, as we only need to move the index.
     798                 :            :   int skip_;
     799                 :            :   // The block where new temporary variables should be added.
     800                 :            :   Block* block_;
     801                 :            : };
     802                 :            : 
     803                 :            : int
     804                 :      17528 : Move_subexpressions::expression(Expression** pexpr)
     805                 :            : {
     806                 :      17528 :   if (this->skip_ > 0)
     807                 :        577 :     --this->skip_;
     808                 :      16951 :   else if ((*pexpr)->temporary_reference_expression() == NULL
     809                 :      16688 :            && !(*pexpr)->is_nil_expression()
     810                 :      16675 :            && !(*pexpr)->is_constant())
     811                 :            :     {
     812                 :      16017 :       Location loc = (*pexpr)->location();
     813                 :      16017 :       Temporary_statement* temp = Statement::make_temporary(NULL, *pexpr, loc);
     814                 :      16017 :       this->block_->add_statement(temp);
     815                 :      16017 :       *pexpr = Expression::make_temporary_reference(temp, loc);
     816                 :            :     }
     817                 :            :   // We only need to move top-level subexpressions.
     818                 :      17528 :   return TRAVERSE_SKIP_COMPONENTS;
     819                 :            : }
     820                 :            : 
     821                 :            : // The Move_ordered_evals class is used to find any subexpressions of
     822                 :            : // an expression that have an evaluation order dependency.  It creates
     823                 :            : // temporary variables to hold them.
     824                 :            : 
     825                 :      87294 : class Move_ordered_evals : public Traverse
     826                 :            : {
     827                 :            :  public:
     828                 :     166175 :   Move_ordered_evals(Block* block)
     829                 :     166175 :     : Traverse(traverse_expressions),
     830                 :     166175 :       block_(block)
     831                 :            :   { }
     832                 :            : 
     833                 :            :  protected:
     834                 :            :   int
     835                 :            :   expression(Expression**);
     836                 :            : 
     837                 :            :  private:
     838                 :            :   // The block where new temporary variables should be added.
     839                 :            :   Block* block_;
     840                 :            : };
     841                 :            : 
     842                 :            : int
     843                 :     219325 : Move_ordered_evals::expression(Expression** pexpr)
     844                 :            : {
     845                 :            :   // We have to look at subexpressions first.
     846                 :     219325 :   if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
     847                 :            :     return TRAVERSE_EXIT;
     848                 :            : 
     849                 :     219325 :   int i;
     850                 :     219325 :   if ((*pexpr)->must_eval_subexpressions_in_order(&i))
     851                 :            :     {
     852                 :      30752 :       Move_subexpressions ms(i, this->block_);
     853                 :      15376 :       if ((*pexpr)->traverse_subexpressions(&ms) == TRAVERSE_EXIT)
     854                 :          0 :         return TRAVERSE_EXIT;
     855                 :            :     }
     856                 :            : 
     857                 :     219325 :   if ((*pexpr)->must_eval_in_order())
     858                 :            :     {
     859                 :        557 :       Call_expression* call = (*pexpr)->call_expression();
     860                 :        556 :       if (call != NULL && call->is_multi_value_arg())
     861                 :            :         {
     862                 :            :           // A call expression which returns multiple results as an argument
     863                 :            :           // to another call must be handled specially.  We can't create a
     864                 :            :           // temporary because there is no type to give it.  Instead, group
     865                 :            :           // the caller and this multi-valued call argument and use a temporary
     866                 :            :           // variable to hold them.
     867                 :          0 :           return TRAVERSE_SKIP_COMPONENTS;
     868                 :            :         }
     869                 :            : 
     870                 :        557 :       Location loc = (*pexpr)->location();
     871                 :        557 :       Temporary_statement* temp = Statement::make_temporary(NULL, *pexpr, loc);
     872                 :        557 :       this->block_->add_statement(temp);
     873                 :        557 :       *pexpr = Expression::make_temporary_reference(temp, loc);
     874                 :            :     }
     875                 :            :   return TRAVERSE_SKIP_COMPONENTS;
     876                 :            : }
     877                 :            : 
     878                 :            : // Class Assignment_statement.
     879                 :            : 
     880                 :            : // Traversal.
     881                 :            : 
     882                 :            : int
     883                 :   16559284 : Assignment_statement::do_traverse(Traverse* traverse)
     884                 :            : {
     885                 :   16559284 :   if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT)
     886                 :            :     return TRAVERSE_EXIT;
     887                 :   16503686 :   return this->traverse_expression(traverse, &this->rhs_);
     888                 :            : }
     889                 :            : 
     890                 :            : bool
     891                 :          0 : Assignment_statement::do_traverse_assignments(Traverse_assignments* tassign)
     892                 :            : {
     893                 :          0 :   tassign->assignment(&this->lhs_, &this->rhs_);
     894                 :          0 :   return true;
     895                 :            : }
     896                 :            : 
     897                 :            : // Lower an assignment to a map index expression to a runtime function
     898                 :            : // call.  Mark some slice assignments as not requiring a write barrier.
     899                 :            : 
     900                 :            : Statement*
     901                 :    1180662 : Assignment_statement::do_lower(Gogo* gogo, Named_object*, Block* enclosing,
     902                 :            :                                Statement_inserter*)
     903                 :            : {
     904                 :    1180662 :   Map_index_expression* mie = this->lhs_->map_index_expression();
     905                 :       4666 :   if (mie != NULL)
     906                 :            :     {
     907                 :       4666 :       Location loc = this->location();
     908                 :            : 
     909                 :       4666 :       Expression* map = mie->map();
     910                 :       4666 :       Map_type* mt = map->type()->map_type();
     911                 :       4666 :       if (mt == NULL)
     912                 :            :         {
     913                 :          0 :           go_assert(saw_errors());
     914                 :          0 :           return Statement::make_error_statement(loc);
     915                 :            :         }
     916                 :            : 
     917                 :       4666 :       Block* b = new Block(enclosing, loc);
     918                 :            : 
     919                 :            :       // Move out any subexpressions on the left hand side to make
     920                 :            :       // sure that functions are called in the required order.
     921                 :       9332 :       Move_ordered_evals moe(b);
     922                 :       4666 :       mie->traverse_subexpressions(&moe);
     923                 :            : 
     924                 :            :       // Copy the key into a temporary so that we can take its address
     925                 :            :       // without pushing the value onto the heap.
     926                 :            : 
     927                 :            :       // var key_temp KEY_TYPE = MAP_INDEX
     928                 :       4666 :       Temporary_statement* key_temp = Statement::make_temporary(mt->key_type(),
     929                 :            :                                                                 mie->index(),
     930                 :            :                                                                 loc);
     931                 :       4666 :       b->add_statement(key_temp);
     932                 :            : 
     933                 :            :       // Copy the value into a temporary to ensure that it is
     934                 :            :       // evaluated before we add the key to the map.  This may matter
     935                 :            :       // if the value is itself a reference to the map.
     936                 :            : 
     937                 :            :       // var val_temp VAL_TYPE = RHS
     938                 :       4666 :       Temporary_statement* val_temp = Statement::make_temporary(mt->val_type(),
     939                 :            :                                                                 this->rhs_,
     940                 :            :                                                                 loc);
     941                 :       4666 :       b->add_statement(val_temp);
     942                 :            : 
     943                 :            :       // *mapassign(TYPE, MAP, &key_temp) = RHS
     944                 :       4666 :       Expression* a1 = Expression::make_type_descriptor(mt, loc);
     945                 :       4666 :       Expression* a2 = mie->map();
     946                 :       4666 :       Temporary_reference_expression* ref =
     947                 :       4666 :         Expression::make_temporary_reference(key_temp, loc);
     948                 :       4666 :       Expression* a3 = Expression::make_unary(OPERATOR_AND, ref, loc);
     949                 :       4666 :       Runtime::Function code;
     950                 :       4666 :       Map_type::Map_alg alg = mt->algorithm(gogo);
     951                 :       4666 :       switch (alg)
     952                 :            :         {
     953                 :        308 :           case Map_type::MAP_ALG_FAST32:
     954                 :        308 :             {
     955                 :        308 :               code = Runtime::MAPASSIGN_FAST32;
     956                 :        308 :               Type* uint32_type = Type::lookup_integer_type("uint32");
     957                 :        308 :               Type* uint32_ptr_type = Type::make_pointer_type(uint32_type);
     958                 :        308 :               a3 = Expression::make_unsafe_cast(uint32_ptr_type, a3,
     959                 :            :                                                 loc);
     960                 :        308 :               a3 = Expression::make_dereference(a3,
     961                 :            :                                                 Expression::NIL_CHECK_NOT_NEEDED,
     962                 :            :                                                 loc);
     963                 :        308 :               break;
     964                 :            :             }
     965                 :        701 :           case Map_type::MAP_ALG_FAST64:
     966                 :        701 :             {
     967                 :        701 :               code = Runtime::MAPASSIGN_FAST64;
     968                 :        701 :               Type* uint64_type = Type::lookup_integer_type("uint64");
     969                 :        701 :               Type* uint64_ptr_type = Type::make_pointer_type(uint64_type);
     970                 :        701 :               a3 = Expression::make_unsafe_cast(uint64_ptr_type, a3,
     971                 :            :                                                 loc);
     972                 :        701 :               a3 = Expression::make_dereference(a3,
     973                 :            :                                                 Expression::NIL_CHECK_NOT_NEEDED,
     974                 :            :                                                 loc);
     975                 :        701 :               break;
     976                 :            :             }
     977                 :        469 :           case Map_type::MAP_ALG_FAST32PTR:
     978                 :        469 :           case Map_type::MAP_ALG_FAST64PTR:
     979                 :        469 :             {
     980                 :        938 :               code = (alg == Map_type::MAP_ALG_FAST32PTR
     981                 :        469 :                       ? Runtime::MAPASSIGN_FAST32PTR
     982                 :            :                       : Runtime::MAPASSIGN_FAST64PTR);
     983                 :        469 :               Type* ptr_type =
     984                 :        469 :                 Type::make_pointer_type(Type::make_void_type());
     985                 :        469 :               Type* ptr_ptr_type = Type::make_pointer_type(ptr_type);
     986                 :        469 :               a3 = Expression::make_unsafe_cast(ptr_ptr_type, a3,
     987                 :            :                                                 loc);
     988                 :        469 :               a3 = Expression::make_dereference(a3,
     989                 :            :                                                 Expression::NIL_CHECK_NOT_NEEDED,
     990                 :            :                                                 loc);
     991                 :        469 :               break;
     992                 :            :             }
     993                 :            :           case Map_type::MAP_ALG_FASTSTR:
     994                 :            :             code = Runtime::MAPASSIGN_FASTSTR;
     995                 :            :             a3 = ref;
     996                 :            :             break;
     997                 :        994 :           default:
     998                 :        994 :             code = Runtime::MAPASSIGN;
     999                 :        994 :             break;
    1000                 :            :         }
    1001                 :       4666 :       Expression* call = Runtime::make_call(code, loc, 3,
    1002                 :            :                                             a1, a2, a3);
    1003                 :       4666 :       Type* ptrval_type = Type::make_pointer_type(mt->val_type());
    1004                 :       4666 :       call = Expression::make_cast(ptrval_type, call, loc);
    1005                 :       4666 :       Expression* indir =
    1006                 :       4666 :           Expression::make_dereference(call, Expression::NIL_CHECK_NOT_NEEDED,
    1007                 :            :                                        loc);
    1008                 :       4666 :       ref = Expression::make_temporary_reference(val_temp, loc);
    1009                 :       4666 :       b->add_statement(Statement::make_assignment(indir, ref, loc));
    1010                 :            : 
    1011                 :       4666 :       return Statement::make_block_statement(b, loc);
    1012                 :            :     }
    1013                 :            : 
    1014                 :            :   // An assignment of the form s = s[:n] does not require a write
    1015                 :            :   // barrier, because the pointer value will not change.
    1016                 :    1175996 :   Array_index_expression* aie = this->rhs_->array_index_expression();
    1017                 :      61133 :   if (aie != NULL
    1018                 :      61133 :       && aie->end() != NULL
    1019                 :      13279 :       && Expression::is_same_variable(this->lhs_, aie->array()))
    1020                 :            :     {
    1021                 :      14950 :       Numeric_constant nc;
    1022                 :       7475 :       unsigned long ival;
    1023                 :       7475 :       if (aie->start()->numeric_constant_value(&nc)
    1024                 :       5483 :           && nc.to_unsigned_long(&ival) == Numeric_constant::NC_UL_VALID
    1025                 :      12958 :           && ival == 0)
    1026                 :       3623 :         this->omit_write_barrier_ = true;
    1027                 :            :     }
    1028                 :    1175996 :   String_index_expression* sie = this->rhs_->string_index_expression();
    1029                 :       6135 :   if (sie != NULL
    1030                 :       6135 :       && sie->end() != NULL
    1031                 :       5408 :       && Expression::is_same_variable(this->lhs_, sie->string()))
    1032                 :            :     {
    1033                 :       7232 :       Numeric_constant nc;
    1034                 :       3616 :       unsigned long ival;
    1035                 :       3616 :       if (sie->start()->numeric_constant_value(&nc)
    1036                 :       2600 :           && nc.to_unsigned_long(&ival) == Numeric_constant::NC_UL_VALID
    1037                 :       6216 :           && ival == 0)
    1038                 :        768 :         this->omit_write_barrier_ = true;
    1039                 :            :     }
    1040                 :            : 
    1041                 :    1175996 :   return this;
    1042                 :            : }
    1043                 :            : 
    1044                 :            : // Set types for the assignment.
    1045                 :            : 
    1046                 :            : void
    1047                 :     610253 : Assignment_statement::do_determine_types()
    1048                 :            : {
    1049                 :     610253 :   this->lhs_->determine_type_no_context();
    1050                 :     610253 :   Type* rhs_context_type = this->lhs_->type();
    1051                 :     610253 :   if (rhs_context_type->is_sink_type())
    1052                 :       4933 :     rhs_context_type = NULL;
    1053                 :     610253 :   Type_context context(rhs_context_type, false);
    1054                 :     610253 :   this->rhs_->determine_type(&context);
    1055                 :     610253 : }
    1056                 :            : 
    1057                 :            : // Check types for an assignment.
    1058                 :            : 
    1059                 :            : void
    1060                 :     610253 : Assignment_statement::do_check_types(Gogo*)
    1061                 :            : {
    1062                 :            :   // The left hand side must be either addressable, a map index
    1063                 :            :   // expression, or the blank identifier.
    1064                 :     610253 :   if (!this->lhs_->is_addressable()
    1065                 :       4938 :       && this->lhs_->map_index_expression() == NULL
    1066                 :     615191 :       && !this->lhs_->is_sink_expression())
    1067                 :            :     {
    1068                 :          5 :       if (!this->lhs_->type()->is_error())
    1069                 :          5 :         this->report_error(_("invalid left hand side of assignment"));
    1070                 :          6 :       return;
    1071                 :            :     }
    1072                 :            : 
    1073                 :     610248 :   Type* lhs_type = this->lhs_->type();
    1074                 :     610248 :   Type* rhs_type = this->rhs_->type();
    1075                 :            : 
    1076                 :            :   // Invalid assignment of nil to the blank identifier.
    1077                 :     610248 :   if (lhs_type->is_sink_type()
    1078                 :     610248 :       && rhs_type->is_nil_type())
    1079                 :            :     {
    1080                 :          1 :       this->report_error(_("use of untyped nil"));
    1081                 :          1 :       return;
    1082                 :            :     }
    1083                 :            : 
    1084                 :    1220494 :   std::string reason;
    1085                 :     610247 :   if (!Type::are_assignable(lhs_type, rhs_type, &reason))
    1086                 :            :     {
    1087                 :         97 :       if (reason.empty())
    1088                 :         55 :         go_error_at(this->location(), "incompatible types in assignment");
    1089                 :            :       else
    1090                 :         42 :         go_error_at(this->location(), "incompatible types in assignment (%s)",
    1091                 :            :                     reason.c_str());
    1092                 :         97 :       this->set_is_error();
    1093                 :            :     }
    1094                 :            : 
    1095                 :     610247 :   if (lhs_type->is_error() || rhs_type->is_error())
    1096                 :         60 :     this->set_is_error();
    1097                 :            : }
    1098                 :            : 
    1099                 :            : void
    1100                 :      18171 : Assignment_statement::do_export_statement(Export_function_body* efb)
    1101                 :            : {
    1102                 :      18171 :   this->lhs_->export_expression(efb);
    1103                 :      18171 :   efb->write_c_string(" = ");
    1104                 :      18171 :   this->rhs_->export_expression(efb);
    1105                 :      18171 : }
    1106                 :            : 
    1107                 :            : // Flatten an assignment statement.  We may need a temporary for
    1108                 :            : // interface conversion.
    1109                 :            : 
    1110                 :            : Statement*
    1111                 :     962769 : Assignment_statement::do_flatten(Gogo*, Named_object*, Block*,
    1112                 :            :                                  Statement_inserter* inserter)
    1113                 :            : {
    1114                 :     962769 :   if (this->lhs_->is_error_expression()
    1115                 :     962768 :       || this->lhs_->type()->is_error_type()
    1116                 :     962768 :       || this->rhs_->is_error_expression()
    1117                 :    1925373 :       || this->rhs_->type()->is_error_type())
    1118                 :            :     {
    1119                 :        165 :       go_assert(saw_errors());
    1120                 :        165 :       return Statement::make_error_statement(this->location());
    1121                 :            :     }
    1122                 :            : 
    1123                 :     962604 :   if (!this->lhs_->is_sink_expression()
    1124                 :     957622 :       && !Type::are_identical(this->lhs_->type(), this->rhs_->type(),
    1125                 :            :                               Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
    1126                 :            :                               NULL)
    1127                 :      21460 :       && this->rhs_->type()->interface_type() != NULL
    1128                 :     962604 :       && !this->rhs_->is_variable())
    1129                 :            :     {
    1130                 :          0 :       Temporary_statement* temp =
    1131                 :          0 :         Statement::make_temporary(NULL, this->rhs_, this->location());
    1132                 :          0 :       inserter->insert(temp);
    1133                 :          0 :       this->rhs_ = Expression::make_temporary_reference(temp,
    1134                 :            :                                                         this->location());
    1135                 :            :     }
    1136                 :     962604 :   return this;
    1137                 :            : }
    1138                 :            : 
    1139                 :            : // Add explicit type conversions.
    1140                 :            : 
    1141                 :            : void
    1142                 :     614491 : Assignment_statement::do_add_conversions()
    1143                 :            : {
    1144                 :     614491 :   Type* lt = this->lhs_->type();
    1145                 :     614491 :   Type* rt = this->rhs_->type();
    1146                 :     614491 :   if (!Type::are_identical(lt, rt, 0, NULL)
    1147                 :     614491 :       && lt->interface_type() != NULL)
    1148                 :      18228 :     this->rhs_ = Expression::make_cast(lt, this->rhs_, this->location());
    1149                 :     614491 : }
    1150                 :            : 
    1151                 :            : // Convert an assignment statement to the backend representation.
    1152                 :            : 
    1153                 :            : Bstatement*
    1154                 :    1032841 : Assignment_statement::do_get_backend(Translate_context* context)
    1155                 :            : {
    1156                 :    1032841 :   if (this->lhs_->is_sink_expression())
    1157                 :            :     {
    1158                 :       3462 :       Bexpression* rhs = this->rhs_->get_backend(context);
    1159                 :       3462 :       Bfunction* bfunction = context->function()->func_value()->get_decl();
    1160                 :       3462 :       return context->backend()->expression_statement(bfunction, rhs);
    1161                 :            :     }
    1162                 :            : 
    1163                 :    1029379 :   Bexpression* lhs = this->lhs_->get_backend(context);
    1164                 :    1029379 :   Expression* conv =
    1165                 :    1029379 :       Expression::convert_for_assignment(context->gogo(), this->lhs_->type(),
    1166                 :            :                                          this->rhs_, this->location());
    1167                 :    1029379 :   Bexpression* rhs = conv->get_backend(context);
    1168                 :    1029379 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
    1169                 :    1029379 :   return context->backend()->assignment_statement(bfunction, lhs, rhs,
    1170                 :    1029379 :                                                   this->location());
    1171                 :            : }
    1172                 :            : 
    1173                 :            : // Dump the AST representation for an assignment statement.
    1174                 :            : 
    1175                 :            : void
    1176                 :          0 : Assignment_statement::do_dump_statement(Ast_dump_context* ast_dump_context)
    1177                 :            :     const
    1178                 :            : {
    1179                 :          0 :   ast_dump_context->print_indent();
    1180                 :          0 :   ast_dump_context->dump_expression(this->lhs_);
    1181                 :          0 :   ast_dump_context->ostream() << " = " ;
    1182                 :          0 :   ast_dump_context->dump_expression(this->rhs_);
    1183                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    1184                 :          0 : }
    1185                 :            : 
    1186                 :            : // Make an assignment statement.
    1187                 :            : 
    1188                 :            : Assignment_statement*
    1189                 :    1133105 : Statement::make_assignment(Expression* lhs, Expression* rhs,
    1190                 :            :                            Location location)
    1191                 :            : {
    1192                 :    1133105 :   Temporary_reference_expression* tre = lhs->temporary_reference_expression();
    1193                 :     177744 :   if (tre != NULL)
    1194                 :     177744 :     tre->statement()->set_assigned();
    1195                 :    1133105 :   return new Assignment_statement(lhs, rhs, location);
    1196                 :            : }
    1197                 :            : 
    1198                 :            : // An assignment operation statement.
    1199                 :            : 
    1200                 :            : class Assignment_operation_statement : public Statement
    1201                 :            : {
    1202                 :            :  public:
    1203                 :      74990 :   Assignment_operation_statement(Operator op, Expression* lhs, Expression* rhs,
    1204                 :            :                                  Location location)
    1205                 :      74990 :     : Statement(STATEMENT_ASSIGNMENT_OPERATION, location),
    1206                 :     149980 :       op_(op), lhs_(lhs), rhs_(rhs)
    1207                 :            :   { }
    1208                 :            : 
    1209                 :            :  protected:
    1210                 :            :   int
    1211                 :            :   do_traverse(Traverse*);
    1212                 :            : 
    1213                 :            :   bool
    1214                 :          0 :   do_traverse_assignments(Traverse_assignments*)
    1215                 :          0 :   { go_unreachable(); }
    1216                 :            : 
    1217                 :            :   Statement*
    1218                 :            :   do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
    1219                 :            : 
    1220                 :            :   Bstatement*
    1221                 :          0 :   do_get_backend(Translate_context*)
    1222                 :          0 :   { go_unreachable(); }
    1223                 :            : 
    1224                 :            :   void
    1225                 :            :   do_dump_statement(Ast_dump_context*) const;
    1226                 :            : 
    1227                 :            :  private:
    1228                 :            :   // The operator (OPERATOR_PLUSEQ, etc.).
    1229                 :            :   Operator op_;
    1230                 :            :   // Left hand side.
    1231                 :            :   Expression* lhs_;
    1232                 :            :   // Right hand side.
    1233                 :            :   Expression* rhs_;
    1234                 :            : };
    1235                 :            : 
    1236                 :            : // Traversal.
    1237                 :            : 
    1238                 :            : int
    1239                 :      98716 : Assignment_operation_statement::do_traverse(Traverse* traverse)
    1240                 :            : {
    1241                 :      98716 :   if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT)
    1242                 :            :     return TRAVERSE_EXIT;
    1243                 :      98716 :   return this->traverse_expression(traverse, &this->rhs_);
    1244                 :            : }
    1245                 :            : 
    1246                 :            : // Lower an assignment operation statement to a regular assignment
    1247                 :            : // statement.
    1248                 :            : 
    1249                 :            : Statement*
    1250                 :      74965 : Assignment_operation_statement::do_lower(Gogo*, Named_object*,
    1251                 :            :                                          Block* enclosing, Statement_inserter*)
    1252                 :            : {
    1253                 :      74965 :   Location loc = this->location();
    1254                 :            : 
    1255                 :            :   // We have to evaluate the left hand side expression only once.  We
    1256                 :            :   // do this by moving out any expression with side effects.
    1257                 :      74965 :   Block* b = new Block(enclosing, loc);
    1258                 :      74965 :   Move_ordered_evals moe(b);
    1259                 :      74965 :   this->lhs_->traverse_subexpressions(&moe);
    1260                 :            : 
    1261                 :      74965 :   Expression* lval = this->lhs_->copy();
    1262                 :            : 
    1263                 :      74965 :   Operator op;
    1264                 :      74965 :   switch (this->op_)
    1265                 :            :     {
    1266                 :            :     case OPERATOR_PLUSEQ:
    1267                 :            :       op = OPERATOR_PLUS;
    1268                 :            :       break;
    1269                 :            :     case OPERATOR_MINUSEQ:
    1270                 :            :       op = OPERATOR_MINUS;
    1271                 :            :       break;
    1272                 :            :     case OPERATOR_OREQ:
    1273                 :            :       op = OPERATOR_OR;
    1274                 :            :       break;
    1275                 :            :     case OPERATOR_XOREQ:
    1276                 :            :       op = OPERATOR_XOR;
    1277                 :            :       break;
    1278                 :            :     case OPERATOR_MULTEQ:
    1279                 :            :       op = OPERATOR_MULT;
    1280                 :            :       break;
    1281                 :            :     case OPERATOR_DIVEQ:
    1282                 :            :       op = OPERATOR_DIV;
    1283                 :            :       break;
    1284                 :            :     case OPERATOR_MODEQ:
    1285                 :            :       op = OPERATOR_MOD;
    1286                 :            :       break;
    1287                 :            :     case OPERATOR_LSHIFTEQ:
    1288                 :            :       op = OPERATOR_LSHIFT;
    1289                 :            :       break;
    1290                 :            :     case OPERATOR_RSHIFTEQ:
    1291                 :            :       op = OPERATOR_RSHIFT;
    1292                 :            :       break;
    1293                 :            :     case OPERATOR_ANDEQ:
    1294                 :            :       op = OPERATOR_AND;
    1295                 :            :       break;
    1296                 :            :     case OPERATOR_BITCLEAREQ:
    1297                 :            :       op = OPERATOR_BITCLEAR;
    1298                 :            :       break;
    1299                 :          0 :     default:
    1300                 :          0 :       go_unreachable();
    1301                 :            :     }
    1302                 :            : 
    1303                 :      74965 :   Expression* binop = Expression::make_binary(op, lval, this->rhs_, loc);
    1304                 :      74965 :   Statement* s = Statement::make_assignment(this->lhs_, binop, loc);
    1305                 :      74965 :   if (b->statements()->empty())
    1306                 :            :     {
    1307                 :      67776 :       delete b;
    1308                 :      67776 :       return s;
    1309                 :            :     }
    1310                 :            :   else
    1311                 :            :     {
    1312                 :       7189 :       b->add_statement(s);
    1313                 :       7189 :       return Statement::make_block_statement(b, loc);
    1314                 :            :     }
    1315                 :            : }
    1316                 :            : 
    1317                 :            : // Dump the AST representation for an assignment operation statement
    1318                 :            : 
    1319                 :            : void
    1320                 :          0 : Assignment_operation_statement::do_dump_statement(
    1321                 :            :     Ast_dump_context* ast_dump_context) const
    1322                 :            : {
    1323                 :          0 :   ast_dump_context->print_indent();
    1324                 :          0 :   ast_dump_context->dump_expression(this->lhs_);
    1325                 :          0 :   ast_dump_context->dump_operator(this->op_);
    1326                 :          0 :   ast_dump_context->dump_expression(this->rhs_);
    1327                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    1328                 :          0 : }
    1329                 :            : 
    1330                 :            : // Make an assignment operation statement.
    1331                 :            : 
    1332                 :            : Statement*
    1333                 :      74990 : Statement::make_assignment_operation(Operator op, Expression* lhs,
    1334                 :            :                                      Expression* rhs, Location location)
    1335                 :            : {
    1336                 :      74990 :   return new Assignment_operation_statement(op, lhs, rhs, location);
    1337                 :            : }
    1338                 :            : 
    1339                 :            : // A tuple assignment statement.  This differs from an assignment
    1340                 :            : // statement in that the right-hand-side expressions are evaluated in
    1341                 :            : // parallel.
    1342                 :            : 
    1343                 :            : class Tuple_assignment_statement : public Statement
    1344                 :            : {
    1345                 :            :  public:
    1346                 :      78881 :   Tuple_assignment_statement(Expression_list* lhs, Expression_list* rhs,
    1347                 :            :                              Location location)
    1348                 :      78881 :     : Statement(STATEMENT_TUPLE_ASSIGNMENT, location),
    1349                 :     157762 :       lhs_(lhs), rhs_(rhs)
    1350                 :            :   { }
    1351                 :            : 
    1352                 :            :  protected:
    1353                 :            :   int
    1354                 :            :   do_traverse(Traverse* traverse);
    1355                 :            : 
    1356                 :            :   bool
    1357                 :          0 :   do_traverse_assignments(Traverse_assignments*)
    1358                 :          0 :   { go_unreachable(); }
    1359                 :            : 
    1360                 :            :   Statement*
    1361                 :            :   do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
    1362                 :            : 
    1363                 :            :   Bstatement*
    1364                 :          0 :   do_get_backend(Translate_context*)
    1365                 :          0 :   { go_unreachable(); }
    1366                 :            : 
    1367                 :            :   void
    1368                 :            :   do_dump_statement(Ast_dump_context*) const;
    1369                 :            : 
    1370                 :            :  private:
    1371                 :            :   // Left hand side--a list of lvalues.
    1372                 :            :   Expression_list* lhs_;
    1373                 :            :   // Right hand side--a list of rvalues.
    1374                 :            :   Expression_list* rhs_;
    1375                 :            : };
    1376                 :            : 
    1377                 :            : // Traversal.
    1378                 :            : 
    1379                 :            : int
    1380                 :      93424 : Tuple_assignment_statement::do_traverse(Traverse* traverse)
    1381                 :            : {
    1382                 :      93424 :   if (this->traverse_expression_list(traverse, this->lhs_) == TRAVERSE_EXIT)
    1383                 :            :     return TRAVERSE_EXIT;
    1384                 :      93424 :   return this->traverse_expression_list(traverse, this->rhs_);
    1385                 :            : }
    1386                 :            : 
    1387                 :            : // Lower a tuple assignment.  We use temporary variables to split it
    1388                 :            : // up into a set of single assignments.
    1389                 :            : 
    1390                 :            : Statement*
    1391                 :      78881 : Tuple_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
    1392                 :            :                                      Statement_inserter*)
    1393                 :            : {
    1394                 :      78881 :   Location loc = this->location();
    1395                 :            : 
    1396                 :      78881 :   Block* b = new Block(enclosing, loc);
    1397                 :            : 
    1398                 :            :   // First move out any subexpressions on the left hand side.  The
    1399                 :            :   // right hand side will be evaluated in the required order anyhow.
    1400                 :      78881 :   Move_ordered_evals moe(b);
    1401                 :     246422 :   for (Expression_list::iterator plhs = this->lhs_->begin();
    1402                 :     246422 :        plhs != this->lhs_->end();
    1403                 :     246422 :        ++plhs)
    1404                 :     167541 :     Expression::traverse(&*plhs, &moe);
    1405                 :            : 
    1406                 :     157762 :   std::vector<Temporary_statement*> temps;
    1407                 :      78881 :   temps.reserve(this->lhs_->size());
    1408                 :            : 
    1409                 :      78881 :   Expression_list::const_iterator prhs = this->rhs_->begin();
    1410                 :     246422 :   for (Expression_list::const_iterator plhs = this->lhs_->begin();
    1411                 :     246422 :        plhs != this->lhs_->end();
    1412                 :     246422 :        ++plhs, ++prhs)
    1413                 :            :     {
    1414                 :     167541 :       go_assert(prhs != this->rhs_->end());
    1415                 :            : 
    1416                 :     167541 :       if ((*plhs)->is_error_expression()
    1417                 :     167541 :           || (*plhs)->type()->is_error()
    1418                 :     167540 :           || (*prhs)->is_error_expression()
    1419                 :     335080 :           || (*prhs)->type()->is_error())
    1420                 :      16715 :         continue;
    1421                 :            : 
    1422                 :     167538 :       if ((*plhs)->is_sink_expression())
    1423                 :            :         {
    1424                 :      16712 :           if ((*prhs)->type()->is_nil_type())
    1425                 :          2 :             this->report_error(_("use of untyped nil"));
    1426                 :            :           else
    1427                 :      16710 :             b->add_statement(Statement::make_statement(*prhs, true));
    1428                 :      16712 :           continue;
    1429                 :            :         }
    1430                 :            : 
    1431                 :     150826 :       Temporary_statement* temp = Statement::make_temporary((*plhs)->type(),
    1432                 :     150826 :                                                             *prhs, loc);
    1433                 :     150826 :       b->add_statement(temp);
    1434                 :     150826 :       temps.push_back(temp);
    1435                 :            : 
    1436                 :            :     }
    1437                 :      78881 :   go_assert(prhs == this->rhs_->end());
    1438                 :            : 
    1439                 :      78881 :   prhs = this->rhs_->begin();
    1440                 :      78881 :   std::vector<Temporary_statement*>::const_iterator ptemp = temps.begin();
    1441                 :      78881 :   for (Expression_list::const_iterator plhs = this->lhs_->begin();
    1442                 :     246422 :        plhs != this->lhs_->end();
    1443                 :     246422 :        ++plhs, ++prhs)
    1444                 :            :     {
    1445                 :     167541 :       if ((*plhs)->is_error_expression()
    1446                 :     167541 :           || (*plhs)->type()->is_error()
    1447                 :     167540 :           || (*prhs)->is_error_expression()
    1448                 :     335080 :           || (*prhs)->type()->is_error())
    1449                 :          3 :         continue;
    1450                 :            : 
    1451                 :     167538 :       if ((*plhs)->is_sink_expression())
    1452                 :      16712 :         continue;
    1453                 :            : 
    1454                 :     150826 :       Expression* ref = Expression::make_temporary_reference(*ptemp, loc);
    1455                 :     150826 :       b->add_statement(Statement::make_assignment(*plhs, ref, loc));
    1456                 :     167541 :       ++ptemp;
    1457                 :            :     }
    1458                 :      78881 :   go_assert(ptemp == temps.end() || saw_errors());
    1459                 :            : 
    1460                 :      78881 :   return Statement::make_block_statement(b, loc);
    1461                 :            : }
    1462                 :            : 
    1463                 :            : // Dump the AST representation for a tuple assignment statement.
    1464                 :            : 
    1465                 :            : void
    1466                 :          0 : Tuple_assignment_statement::do_dump_statement(
    1467                 :            :     Ast_dump_context* ast_dump_context) const
    1468                 :            : {
    1469                 :          0 :   ast_dump_context->print_indent();
    1470                 :          0 :   ast_dump_context->dump_expression_list(this->lhs_);
    1471                 :          0 :   ast_dump_context->ostream() << " = ";
    1472                 :          0 :   ast_dump_context->dump_expression_list(this->rhs_);
    1473                 :          0 :   ast_dump_context->ostream()  << dsuffix(location()) << std::endl;
    1474                 :          0 : }
    1475                 :            : 
    1476                 :            : // Make a tuple assignment statement.
    1477                 :            : 
    1478                 :            : Statement*
    1479                 :      78881 : Statement::make_tuple_assignment(Expression_list* lhs, Expression_list* rhs,
    1480                 :            :                                  Location location)
    1481                 :            : {
    1482                 :      78881 :   return new Tuple_assignment_statement(lhs, rhs, location);
    1483                 :            : }
    1484                 :            : 
    1485                 :            : // A tuple assignment from a map index expression.
    1486                 :            : //   v, ok = m[k]
    1487                 :            : 
    1488                 :            : class Tuple_map_assignment_statement : public Statement
    1489                 :            : {
    1490                 :            : public:
    1491                 :       1926 :   Tuple_map_assignment_statement(Expression* val, Expression* present,
    1492                 :            :                                  Expression* map_index,
    1493                 :            :                                  Location location)
    1494                 :       1926 :     : Statement(STATEMENT_TUPLE_MAP_ASSIGNMENT, location),
    1495                 :       3852 :       val_(val), present_(present), map_index_(map_index)
    1496                 :            :   { }
    1497                 :            : 
    1498                 :            :  protected:
    1499                 :            :   int
    1500                 :            :   do_traverse(Traverse* traverse);
    1501                 :            : 
    1502                 :            :   bool
    1503                 :          0 :   do_traverse_assignments(Traverse_assignments*)
    1504                 :          0 :   { go_unreachable(); }
    1505                 :            : 
    1506                 :            :   Statement*
    1507                 :            :   do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
    1508                 :            : 
    1509                 :            :   Bstatement*
    1510                 :          0 :   do_get_backend(Translate_context*)
    1511                 :          0 :   { go_unreachable(); }
    1512                 :            : 
    1513                 :            :   void
    1514                 :            :   do_dump_statement(Ast_dump_context*) const;
    1515                 :            : 
    1516                 :            :  private:
    1517                 :            :   // Lvalue which receives the value from the map.
    1518                 :            :   Expression* val_;
    1519                 :            :   // Lvalue which receives whether the key value was present.
    1520                 :            :   Expression* present_;
    1521                 :            :   // The map index expression.
    1522                 :            :   Expression* map_index_;
    1523                 :            : };
    1524                 :            : 
    1525                 :            : // Traversal.
    1526                 :            : 
    1527                 :            : int
    1528                 :       3852 : Tuple_map_assignment_statement::do_traverse(Traverse* traverse)
    1529                 :            : {
    1530                 :       3852 :   if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
    1531                 :       3852 :       || this->traverse_expression(traverse, &this->present_) == TRAVERSE_EXIT)
    1532                 :          0 :     return TRAVERSE_EXIT;
    1533                 :       3852 :   return this->traverse_expression(traverse, &this->map_index_);
    1534                 :            : }
    1535                 :            : 
    1536                 :            : // Lower a tuple map assignment.
    1537                 :            : 
    1538                 :            : Statement*
    1539                 :       1926 : Tuple_map_assignment_statement::do_lower(Gogo* gogo, Named_object*,
    1540                 :            :                                          Block* enclosing, Statement_inserter*)
    1541                 :            : {
    1542                 :       1926 :   Location loc = this->location();
    1543                 :            : 
    1544                 :       1926 :   Map_index_expression* map_index = this->map_index_->map_index_expression();
    1545                 :       1926 :   if (map_index == NULL)
    1546                 :            :     {
    1547                 :          0 :       this->report_error(_("expected map index on right hand side"));
    1548                 :          0 :       return Statement::make_error_statement(loc);
    1549                 :            :     }
    1550                 :       1926 :   Map_type* map_type = map_index->get_map_type();
    1551                 :       1926 :   if (map_type == NULL)
    1552                 :          0 :     return Statement::make_error_statement(loc);
    1553                 :            : 
    1554                 :            :   // Avoid copy for string([]byte) conversions used in map keys.
    1555                 :            :   // mapaccess doesn't keep the reference, so this is safe.
    1556                 :       1926 :   Type_conversion_expression* ce = map_index->index()->conversion_expression();
    1557                 :         26 :   if (ce != NULL && ce->type()->is_string_type()
    1558                 :         26 :       && ce->expr()->type()->is_slice_type())
    1559                 :         26 :     ce->set_no_copy(true);
    1560                 :            : 
    1561                 :       1926 :   Block* b = new Block(enclosing, loc);
    1562                 :            : 
    1563                 :            :   // Move out any subexpressions to make sure that functions are
    1564                 :            :   // called in the required order.
    1565                 :       1926 :   Move_ordered_evals moe(b);
    1566                 :       1926 :   this->val_->traverse_subexpressions(&moe);
    1567                 :       1926 :   this->present_->traverse_subexpressions(&moe);
    1568                 :            : 
    1569                 :            :   // Copy the key value into a temporary so that we can take its
    1570                 :            :   // address without pushing the value onto the heap.
    1571                 :            : 
    1572                 :            :   // var key_temp KEY_TYPE = MAP_INDEX
    1573                 :       1926 :   Temporary_statement* key_temp =
    1574                 :       1926 :     Statement::make_temporary(map_type->key_type(), map_index->index(), loc);
    1575                 :       1926 :   b->add_statement(key_temp);
    1576                 :            : 
    1577                 :            :   // var val_ptr_temp *VAL_TYPE
    1578                 :       1926 :   Type* val_ptr_type = Type::make_pointer_type(map_type->val_type());
    1579                 :       1926 :   Temporary_statement* val_ptr_temp = Statement::make_temporary(val_ptr_type,
    1580                 :            :                                                                 NULL, loc);
    1581                 :       1926 :   b->add_statement(val_ptr_temp);
    1582                 :            : 
    1583                 :            :   // var present_temp bool
    1584                 :       1926 :   Temporary_statement* present_temp =
    1585                 :       3852 :     Statement::make_temporary((this->present_->type()->is_sink_type())
    1586                 :         21 :                               ? Type::make_boolean_type()
    1587                 :       1905 :                               : this->present_->type(),
    1588                 :            :                               NULL, loc);
    1589                 :       1926 :   b->add_statement(present_temp);
    1590                 :            : 
    1591                 :            :   // val_ptr_temp, present_temp = mapaccess2(DESCRIPTOR, MAP, &key_temp)
    1592                 :       1926 :   Expression* a1 = Expression::make_type_descriptor(map_type, loc);
    1593                 :       1926 :   Expression* a2 = map_index->map();
    1594                 :       1926 :   Temporary_reference_expression* ref =
    1595                 :       1926 :     Expression::make_temporary_reference(key_temp, loc);
    1596                 :       1926 :   Expression* a3 = Expression::make_unary(OPERATOR_AND, ref, loc);
    1597                 :       1926 :   Expression* a4 = map_type->fat_zero_value(gogo);
    1598                 :       1926 :   Call_expression* call;
    1599                 :       1926 :   if (a4 == NULL)
    1600                 :            :     {
    1601                 :       1923 :       Runtime::Function code;
    1602                 :       1923 :       Map_type::Map_alg alg = map_type->algorithm(gogo);
    1603                 :       1923 :       switch (alg)
    1604                 :            :         {
    1605                 :        225 :           case Map_type::MAP_ALG_FAST32:
    1606                 :        225 :           case Map_type::MAP_ALG_FAST32PTR:
    1607                 :        225 :             {
    1608                 :        225 :               code = Runtime::MAPACCESS2_FAST32;
    1609                 :        225 :               Type* uint32_type = Type::lookup_integer_type("uint32");
    1610                 :        225 :               Type* uint32_ptr_type = Type::make_pointer_type(uint32_type);
    1611                 :        225 :               a3 = Expression::make_unsafe_cast(uint32_ptr_type, a3,
    1612                 :            :                                                 loc);
    1613                 :        225 :               a3 = Expression::make_dereference(a3,
    1614                 :            :                                                 Expression::NIL_CHECK_NOT_NEEDED,
    1615                 :            :                                                 loc);
    1616                 :        225 :               break;
    1617                 :            :             }
    1618                 :        250 :           case Map_type::MAP_ALG_FAST64:
    1619                 :        250 :           case Map_type::MAP_ALG_FAST64PTR:
    1620                 :        250 :             {
    1621                 :        250 :               code = Runtime::MAPACCESS2_FAST64;
    1622                 :        250 :               Type* uint64_type = Type::lookup_integer_type("uint64");
    1623                 :        250 :               Type* uint64_ptr_type = Type::make_pointer_type(uint64_type);
    1624                 :        250 :               a3 = Expression::make_unsafe_cast(uint64_ptr_type, a3,
    1625                 :            :                                                 loc);
    1626                 :        250 :               a3 = Expression::make_dereference(a3,
    1627                 :            :                                                 Expression::NIL_CHECK_NOT_NEEDED,
    1628                 :            :                                                 loc);
    1629                 :        250 :               break;
    1630                 :            :             }
    1631                 :            :           case Map_type::MAP_ALG_FASTSTR:
    1632                 :            :             code = Runtime::MAPACCESS2_FASTSTR;
    1633                 :            :             a3 = ref;
    1634                 :            :             break;
    1635                 :        398 :           default:
    1636                 :        398 :             code = Runtime::MAPACCESS2;
    1637                 :        398 :             break;
    1638                 :            :         }
    1639                 :       1923 :       call = Runtime::make_call(code, loc, 3, a1, a2, a3);
    1640                 :            :     }
    1641                 :            :   else
    1642                 :          3 :     call = Runtime::make_call(Runtime::MAPACCESS2_FAT, loc, 4, a1, a2, a3, a4);
    1643                 :       1926 :   ref = Expression::make_temporary_reference(val_ptr_temp, loc);
    1644                 :       1926 :   ref->set_is_lvalue();
    1645                 :       1926 :   Expression* res = Expression::make_call_result(call, 0);
    1646                 :       1926 :   res = Expression::make_unsafe_cast(val_ptr_type, res, loc);
    1647                 :       1926 :   Statement* s = Statement::make_assignment(ref, res, loc);
    1648                 :       1926 :   b->add_statement(s);
    1649                 :       1926 :   ref = Expression::make_temporary_reference(present_temp, loc);
    1650                 :       1926 :   ref->set_is_lvalue();
    1651                 :       1926 :   res = Expression::make_call_result(call, 1);
    1652                 :       1926 :   s = Statement::make_assignment(ref, res, loc);
    1653                 :       1926 :   b->add_statement(s);
    1654                 :            : 
    1655                 :            :   // val = *val__ptr_temp
    1656                 :       1926 :   ref = Expression::make_temporary_reference(val_ptr_temp, loc);
    1657                 :       1926 :   Expression* ind =
    1658                 :       1926 :       Expression::make_dereference(ref, Expression::NIL_CHECK_NOT_NEEDED, loc);
    1659                 :       1926 :   s = Statement::make_assignment(this->val_, ind, loc);
    1660                 :       1926 :   b->add_statement(s);
    1661                 :            : 
    1662                 :            :   // present = present_temp
    1663                 :       1926 :   ref = Expression::make_temporary_reference(present_temp, loc);
    1664                 :       1926 :   s = Statement::make_assignment(this->present_, ref, loc);
    1665                 :       1926 :   b->add_statement(s);
    1666                 :            : 
    1667                 :       1926 :   return Statement::make_block_statement(b, loc);
    1668                 :            : }
    1669                 :            : 
    1670                 :            : // Dump the AST representation for a tuple map assignment statement.
    1671                 :            : 
    1672                 :            : void
    1673                 :          0 : Tuple_map_assignment_statement::do_dump_statement(
    1674                 :            :     Ast_dump_context* ast_dump_context) const
    1675                 :            : {
    1676                 :          0 :   ast_dump_context->print_indent();
    1677                 :          0 :   ast_dump_context->dump_expression(this->val_);
    1678                 :          0 :   ast_dump_context->ostream() << ", ";
    1679                 :          0 :   ast_dump_context->dump_expression(this->present_);
    1680                 :          0 :   ast_dump_context->ostream() << " = ";
    1681                 :          0 :   ast_dump_context->dump_expression(this->map_index_);
    1682                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    1683                 :          0 : }
    1684                 :            : 
    1685                 :            : // Make a map assignment statement which returns a pair of values.
    1686                 :            : 
    1687                 :            : Statement*
    1688                 :       1926 : Statement::make_tuple_map_assignment(Expression* val, Expression* present,
    1689                 :            :                                      Expression* map_index,
    1690                 :            :                                      Location location)
    1691                 :            : {
    1692                 :       1926 :   return new Tuple_map_assignment_statement(val, present, map_index, location);
    1693                 :            : }
    1694                 :            : 
    1695                 :            : // A tuple assignment from a receive statement.
    1696                 :            : 
    1697                 :            : class Tuple_receive_assignment_statement : public Statement
    1698                 :            : {
    1699                 :            :  public:
    1700                 :        146 :   Tuple_receive_assignment_statement(Expression* val, Expression* closed,
    1701                 :            :                                      Expression* channel, Location location)
    1702                 :        146 :     : Statement(STATEMENT_TUPLE_RECEIVE_ASSIGNMENT, location),
    1703                 :        292 :       val_(val), closed_(closed), channel_(channel)
    1704                 :            :   { }
    1705                 :            : 
    1706                 :            :  protected:
    1707                 :            :   int
    1708                 :            :   do_traverse(Traverse* traverse);
    1709                 :            : 
    1710                 :            :   bool
    1711                 :          0 :   do_traverse_assignments(Traverse_assignments*)
    1712                 :          0 :   { go_unreachable(); }
    1713                 :            : 
    1714                 :            :   Statement*
    1715                 :            :   do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
    1716                 :            : 
    1717                 :            :   Bstatement*
    1718                 :          0 :   do_get_backend(Translate_context*)
    1719                 :          0 :   { go_unreachable(); }
    1720                 :            : 
    1721                 :            :   void
    1722                 :            :   do_dump_statement(Ast_dump_context*) const;
    1723                 :            : 
    1724                 :            :  private:
    1725                 :            :   // Lvalue which receives the value from the channel.
    1726                 :            :   Expression* val_;
    1727                 :            :   // Lvalue which receives whether the channel is closed.
    1728                 :            :   Expression* closed_;
    1729                 :            :   // The channel on which we receive the value.
    1730                 :            :   Expression* channel_;
    1731                 :            : };
    1732                 :            : 
    1733                 :            : // Traversal.
    1734                 :            : 
    1735                 :            : int
    1736                 :        188 : Tuple_receive_assignment_statement::do_traverse(Traverse* traverse)
    1737                 :            : {
    1738                 :        188 :   if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
    1739                 :        188 :       || this->traverse_expression(traverse, &this->closed_) == TRAVERSE_EXIT)
    1740                 :          0 :     return TRAVERSE_EXIT;
    1741                 :        188 :   return this->traverse_expression(traverse, &this->channel_);
    1742                 :            : }
    1743                 :            : 
    1744                 :            : // Lower to a function call.
    1745                 :            : 
    1746                 :            : Statement*
    1747                 :        146 : Tuple_receive_assignment_statement::do_lower(Gogo*, Named_object*,
    1748                 :            :                                              Block* enclosing,
    1749                 :            :                                              Statement_inserter*)
    1750                 :            : {
    1751                 :        146 :   Location loc = this->location();
    1752                 :            : 
    1753                 :        146 :   Channel_type* channel_type = this->channel_->type()->channel_type();
    1754                 :        146 :   if (channel_type == NULL)
    1755                 :            :     {
    1756                 :          0 :       this->report_error(_("expected channel"));
    1757                 :          0 :       return Statement::make_error_statement(loc);
    1758                 :            :     }
    1759                 :        146 :   if (!channel_type->may_receive())
    1760                 :            :     {
    1761                 :          2 :       this->report_error(_("invalid receive on send-only channel"));
    1762                 :          2 :       return Statement::make_error_statement(loc);
    1763                 :            :     }
    1764                 :            : 
    1765                 :        144 :   Block* b = new Block(enclosing, loc);
    1766                 :            : 
    1767                 :            :   // Make sure that any subexpressions on the left hand side are
    1768                 :            :   // evaluated in the right order.
    1769                 :        144 :   Move_ordered_evals moe(b);
    1770                 :        144 :   this->val_->traverse_subexpressions(&moe);
    1771                 :        144 :   this->closed_->traverse_subexpressions(&moe);
    1772                 :            : 
    1773                 :            :   // var val_temp ELEMENT_TYPE
    1774                 :        144 :   Temporary_statement* val_temp =
    1775                 :        144 :     Statement::make_temporary(channel_type->element_type(), NULL, loc);
    1776                 :        144 :   b->add_statement(val_temp);
    1777                 :            : 
    1778                 :            :   // var closed_temp bool
    1779                 :        144 :   Temporary_statement* closed_temp =
    1780                 :        288 :     Statement::make_temporary((this->closed_->type()->is_sink_type())
    1781                 :          3 :                               ? Type::make_boolean_type()
    1782                 :        141 :                               : this->closed_->type(),
    1783                 :            :                               NULL, loc);
    1784                 :        144 :   b->add_statement(closed_temp);
    1785                 :            : 
    1786                 :            :   // closed_temp = chanrecv2(channel, &val_temp)
    1787                 :        144 :   Temporary_reference_expression* ref =
    1788                 :        144 :     Expression::make_temporary_reference(val_temp, loc);
    1789                 :        144 :   Expression* p2 = Expression::make_unary(OPERATOR_AND, ref, loc);
    1790                 :        144 :   Expression* call = Runtime::make_call(Runtime::CHANRECV2,
    1791                 :            :                                         loc, 2, this->channel_, p2);
    1792                 :        144 :   ref = Expression::make_temporary_reference(closed_temp, loc);
    1793                 :        144 :   ref->set_is_lvalue();
    1794                 :        144 :   Statement* s = Statement::make_assignment(ref, call, loc);
    1795                 :        144 :   b->add_statement(s);
    1796                 :            : 
    1797                 :            :   // val = val_temp
    1798                 :        144 :   ref = Expression::make_temporary_reference(val_temp, loc);
    1799                 :        144 :   s = Statement::make_assignment(this->val_, ref, loc);
    1800                 :        144 :   b->add_statement(s);
    1801                 :            : 
    1802                 :            :   // closed = closed_temp
    1803                 :        144 :   ref = Expression::make_temporary_reference(closed_temp, loc);
    1804                 :        144 :   s = Statement::make_assignment(this->closed_, ref, loc);
    1805                 :        144 :   b->add_statement(s);
    1806                 :            : 
    1807                 :        144 :   return Statement::make_block_statement(b, loc);
    1808                 :            : }
    1809                 :            : 
    1810                 :            : // Dump the AST representation for a tuple receive statement.
    1811                 :            : 
    1812                 :            : void
    1813                 :          0 : Tuple_receive_assignment_statement::do_dump_statement(
    1814                 :            :     Ast_dump_context* ast_dump_context) const
    1815                 :            : {
    1816                 :          0 :   ast_dump_context->print_indent();
    1817                 :          0 :   ast_dump_context->dump_expression(this->val_);
    1818                 :          0 :   ast_dump_context->ostream() << ", ";
    1819                 :          0 :   ast_dump_context->dump_expression(this->closed_);
    1820                 :          0 :   ast_dump_context->ostream() << " <- ";
    1821                 :          0 :   ast_dump_context->dump_expression(this->channel_);
    1822                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    1823                 :          0 : }
    1824                 :            : 
    1825                 :            : // Make a nonblocking receive statement.
    1826                 :            : 
    1827                 :            : Statement*
    1828                 :        146 : Statement::make_tuple_receive_assignment(Expression* val, Expression* closed,
    1829                 :            :                                          Expression* channel,
    1830                 :            :                                          Location location)
    1831                 :            : {
    1832                 :        146 :   return new Tuple_receive_assignment_statement(val, closed, channel,
    1833                 :        146 :                                                 location);
    1834                 :            : }
    1835                 :            : 
    1836                 :            : // An assignment to a pair of values from a type guard.  This is a
    1837                 :            : // conditional type guard.  v, ok = i.(type).
    1838                 :            : 
    1839                 :            : class Tuple_type_guard_assignment_statement : public Statement
    1840                 :            : {
    1841                 :            :  public:
    1842                 :       5593 :   Tuple_type_guard_assignment_statement(Expression* val, Expression* ok,
    1843                 :            :                                         Expression* expr, Type* type,
    1844                 :            :                                         Location location)
    1845                 :       5593 :     : Statement(STATEMENT_TUPLE_TYPE_GUARD_ASSIGNMENT, location),
    1846                 :      11186 :       val_(val), ok_(ok), expr_(expr), type_(type)
    1847                 :            :   { }
    1848                 :            : 
    1849                 :            :  protected:
    1850                 :            :   int
    1851                 :            :   do_traverse(Traverse*);
    1852                 :            : 
    1853                 :            :   bool
    1854                 :          0 :   do_traverse_assignments(Traverse_assignments*)
    1855                 :          0 :   { go_unreachable(); }
    1856                 :            : 
    1857                 :            :   Statement*
    1858                 :            :   do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
    1859                 :            : 
    1860                 :            :   Bstatement*
    1861                 :          0 :   do_get_backend(Translate_context*)
    1862                 :          0 :   { go_unreachable(); }
    1863                 :            : 
    1864                 :            :   void
    1865                 :            :   do_dump_statement(Ast_dump_context*) const;
    1866                 :            : 
    1867                 :            :  private:
    1868                 :            :   Call_expression*
    1869                 :            :   lower_to_type(Runtime::Function);
    1870                 :            : 
    1871                 :            :   void
    1872                 :            :   lower_to_object_type(Block*, Runtime::Function);
    1873                 :            : 
    1874                 :            :   // The variable which recieves the converted value.
    1875                 :            :   Expression* val_;
    1876                 :            :   // The variable which receives the indication of success.
    1877                 :            :   Expression* ok_;
    1878                 :            :   // The expression being converted.
    1879                 :            :   Expression* expr_;
    1880                 :            :   // The type to which the expression is being converted.
    1881                 :            :   Type* type_;
    1882                 :            : };
    1883                 :            : 
    1884                 :            : // Traverse a type guard tuple assignment.
    1885                 :            : 
    1886                 :            : int
    1887                 :      11186 : Tuple_type_guard_assignment_statement::do_traverse(Traverse* traverse)
    1888                 :            : {
    1889                 :      11186 :   if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
    1890                 :      11186 :       || this->traverse_expression(traverse, &this->ok_) == TRAVERSE_EXIT
    1891                 :      22372 :       || this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT)
    1892                 :          0 :     return TRAVERSE_EXIT;
    1893                 :      11186 :   return this->traverse_expression(traverse, &this->expr_);
    1894                 :            : }
    1895                 :            : 
    1896                 :            : // Lower to a function call.
    1897                 :            : 
    1898                 :            : Statement*
    1899                 :       5593 : Tuple_type_guard_assignment_statement::do_lower(Gogo*, Named_object*,
    1900                 :            :                                                 Block* enclosing,
    1901                 :            :                                                 Statement_inserter*)
    1902                 :            : {
    1903                 :       5593 :   Location loc = this->location();
    1904                 :            : 
    1905                 :       5593 :   Type* expr_type = this->expr_->type();
    1906                 :       5593 :   if (expr_type->interface_type() == NULL)
    1907                 :            :     {
    1908                 :          0 :       if (!expr_type->is_error() && !this->type_->is_error())
    1909                 :          0 :         this->report_error(_("type assertion only valid for interface types"));
    1910                 :          0 :       return Statement::make_error_statement(loc);
    1911                 :            :     }
    1912                 :            : 
    1913                 :       5593 :   Block* b = new Block(enclosing, loc);
    1914                 :            : 
    1915                 :            :   // Make sure that any subexpressions on the left hand side are
    1916                 :            :   // evaluated in the right order.
    1917                 :       5593 :   Move_ordered_evals moe(b);
    1918                 :       5593 :   this->val_->traverse_subexpressions(&moe);
    1919                 :       5593 :   this->ok_->traverse_subexpressions(&moe);
    1920                 :            : 
    1921                 :      11186 :   bool expr_is_empty = expr_type->interface_type()->is_empty();
    1922                 :       5593 :   Call_expression* call;
    1923                 :       5593 :   if (this->type_->interface_type() != NULL)
    1924                 :            :     {
    1925                 :       2258 :       if (this->type_->interface_type()->is_empty())
    1926                 :         19 :         call = Runtime::make_call((expr_is_empty
    1927                 :            :                                    ? Runtime::IFACEE2E2
    1928                 :            :                                    : Runtime::IFACEI2E2),
    1929                 :            :                                   loc, 1, this->expr_);
    1930                 :            :       else
    1931                 :       1961 :         call = this->lower_to_type(expr_is_empty
    1932                 :            :                                    ? Runtime::IFACEE2I2
    1933                 :            :                                    : Runtime::IFACEI2I2);
    1934                 :            :     }
    1935                 :       4464 :   else if (this->type_->points_to() != NULL)
    1936                 :       6118 :     call = this->lower_to_type(expr_is_empty
    1937                 :            :                                ? Runtime::IFACEE2T2P
    1938                 :            :                                : Runtime::IFACEI2T2P);
    1939                 :            :   else
    1940                 :            :     {
    1941                 :       1184 :       this->lower_to_object_type(b,
    1942                 :            :                                  (expr_is_empty
    1943                 :            :                                   ? Runtime::IFACEE2T2
    1944                 :            :                                   : Runtime::IFACEI2T2));
    1945                 :       1184 :       call = NULL;
    1946                 :            :     }
    1947                 :            : 
    1948                 :       5593 :   if (call != NULL)
    1949                 :            :     {
    1950                 :       4409 :       Expression* res = Expression::make_call_result(call, 0);
    1951                 :       4409 :       res = Expression::make_unsafe_cast(this->type_, res, loc);
    1952                 :       4409 :       Statement* s = Statement::make_assignment(this->val_, res, loc);
    1953                 :       4409 :       b->add_statement(s);
    1954                 :            : 
    1955                 :       4409 :       res = Expression::make_call_result(call, 1);
    1956                 :       4409 :       s = Statement::make_assignment(this->ok_, res, loc);
    1957                 :       4409 :       b->add_statement(s);
    1958                 :            :     }
    1959                 :            : 
    1960                 :       5593 :   return Statement::make_block_statement(b, loc);
    1961                 :            : }
    1962                 :            : 
    1963                 :            : // Lower a conversion to a non-empty interface type or a pointer type.
    1964                 :            : 
    1965                 :            : Call_expression*
    1966                 :       4396 : Tuple_type_guard_assignment_statement::lower_to_type(Runtime::Function code)
    1967                 :            : {
    1968                 :       4396 :   Location loc = this->location();
    1969                 :       4396 :   return Runtime::make_call(code, loc, 2,
    1970                 :            :                             Expression::make_type_descriptor(this->type_, loc),
    1971                 :       4396 :                             this->expr_);
    1972                 :            : }
    1973                 :            : 
    1974                 :            : // Lower a conversion to a non-interface non-pointer type.
    1975                 :            : 
    1976                 :            : void
    1977                 :       1184 : Tuple_type_guard_assignment_statement::lower_to_object_type(
    1978                 :            :     Block* b,
    1979                 :            :     Runtime::Function code)
    1980                 :            : {
    1981                 :       1184 :   Location loc = this->location();
    1982                 :            : 
    1983                 :            :   // var val_temp TYPE
    1984                 :       1184 :   Temporary_statement* val_temp = Statement::make_temporary(this->type_,
    1985                 :            :                                                             NULL, loc);
    1986                 :       1184 :   b->add_statement(val_temp);
    1987                 :            : 
    1988                 :            :   // ok = CODE(type_descriptor, expr, &val_temp)
    1989                 :       1184 :   Expression* p1 = Expression::make_type_descriptor(this->type_, loc);
    1990                 :       1184 :   Expression* ref = Expression::make_temporary_reference(val_temp, loc);
    1991                 :       1184 :   Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc);
    1992                 :       1184 :   Expression* call = Runtime::make_call(code, loc, 3, p1, this->expr_, p3);
    1993                 :       1184 :   Statement* s = Statement::make_assignment(this->ok_, call, loc);
    1994                 :       1184 :   b->add_statement(s);
    1995                 :            : 
    1996                 :            :   // val = val_temp
    1997                 :       1184 :   ref = Expression::make_temporary_reference(val_temp, loc);
    1998                 :       1184 :   s = Statement::make_assignment(this->val_, ref, loc);
    1999                 :       1184 :   b->add_statement(s);
    2000                 :       1184 : }
    2001                 :            : 
    2002                 :            : // Dump the AST representation for a tuple type guard statement.
    2003                 :            : 
    2004                 :            : void
    2005                 :          0 : Tuple_type_guard_assignment_statement::do_dump_statement(
    2006                 :            :     Ast_dump_context* ast_dump_context) const
    2007                 :            : {
    2008                 :          0 :   ast_dump_context->print_indent();
    2009                 :          0 :   ast_dump_context->dump_expression(this->val_);
    2010                 :          0 :   ast_dump_context->ostream() << ", ";
    2011                 :          0 :   ast_dump_context->dump_expression(this->ok_);
    2012                 :          0 :   ast_dump_context->ostream() << " = ";
    2013                 :          0 :   ast_dump_context->dump_expression(this->expr_);
    2014                 :          0 :   ast_dump_context->ostream() << " . ";
    2015                 :          0 :   ast_dump_context->dump_type(this->type_);
    2016                 :          0 :   ast_dump_context->ostream()  << dsuffix(location()) << std::endl;
    2017                 :          0 : }
    2018                 :            : 
    2019                 :            : // Make an assignment from a type guard to a pair of variables.
    2020                 :            : 
    2021                 :            : Statement*
    2022                 :       5593 : Statement::make_tuple_type_guard_assignment(Expression* val, Expression* ok,
    2023                 :            :                                             Expression* expr, Type* type,
    2024                 :            :                                             Location location)
    2025                 :            : {
    2026                 :       5593 :   return new Tuple_type_guard_assignment_statement(val, ok, expr, type,
    2027                 :       5593 :                                                    location);
    2028                 :            : }
    2029                 :            : 
    2030                 :            : // Class Expression_statement.
    2031                 :            : 
    2032                 :            : // Constructor.
    2033                 :            : 
    2034                 :     716637 : Expression_statement::Expression_statement(Expression* expr, bool is_ignored)
    2035                 :            :   : Statement(STATEMENT_EXPRESSION, expr->location()),
    2036                 :     716637 :     expr_(expr), is_ignored_(is_ignored)
    2037                 :            : {
    2038                 :     716637 : }
    2039                 :            : 
    2040                 :            : // Determine types.
    2041                 :            : 
    2042                 :            : void
    2043                 :     259907 : Expression_statement::do_determine_types()
    2044                 :            : {
    2045                 :     259907 :   this->expr_->determine_type_no_context();
    2046                 :     259907 : }
    2047                 :            : 
    2048                 :            : // Check the types of an expression statement.  The only check we do
    2049                 :            : // is to possibly give an error about discarding the value of the
    2050                 :            : // expression.
    2051                 :            : 
    2052                 :            : void
    2053                 :     247223 : Expression_statement::do_check_types(Gogo*)
    2054                 :            : {
    2055                 :     247223 :   if (!this->is_ignored_)
    2056                 :     217254 :     this->expr_->discarding_value();
    2057                 :     247223 : }
    2058                 :            : 
    2059                 :            : // An expression statement is only a terminating statement if it is
    2060                 :            : // a call to panic.
    2061                 :            : 
    2062                 :            : bool
    2063                 :        983 : Expression_statement::do_may_fall_through() const
    2064                 :            : {
    2065                 :        983 :   const Call_expression* call = this->expr_->call_expression();
    2066                 :        983 :   if (call != NULL)
    2067                 :            :     {
    2068                 :        983 :       const Expression* fn = call->fn();
    2069                 :            :       // panic is still an unknown named object.
    2070                 :        983 :       const Unknown_expression* ue = fn->unknown_expression();
    2071                 :        979 :       if (ue != NULL)
    2072                 :            :         {
    2073                 :        979 :           Named_object* no = ue->named_object();
    2074                 :            : 
    2075                 :        979 :           if (no->is_unknown())
    2076                 :        979 :             no = no->unknown_value()->real_named_object();
    2077                 :        979 :           if (no != NULL)
    2078                 :            :             {
    2079                 :        979 :               Function_type* fntype;
    2080                 :        979 :               if (no->is_function())
    2081                 :          0 :                 fntype = no->func_value()->type();
    2082                 :        979 :               else if (no->is_function_declaration())
    2083                 :        979 :                 fntype = no->func_declaration_value()->type();
    2084                 :            :               else
    2085                 :            :                 fntype = NULL;
    2086                 :            : 
    2087                 :            :               // The builtin function panic does not return.
    2088                 :        979 :               if (fntype != NULL && fntype->is_builtin() && no->name() == "panic")
    2089                 :        914 :                 return false;
    2090                 :            :             }
    2091                 :            :         }
    2092                 :            :     }
    2093                 :            :   return true;
    2094                 :            : }
    2095                 :            : 
    2096                 :            : // Export an expression statement.
    2097                 :            : 
    2098                 :            : void
    2099                 :       4313 : Expression_statement::do_export_statement(Export_function_body* efb)
    2100                 :            : {
    2101                 :       4313 :   this->expr_->export_expression(efb);
    2102                 :       4313 : }
    2103                 :            : 
    2104                 :            : // Convert to backend representation.
    2105                 :            : 
    2106                 :            : Bstatement*
    2107                 :     711985 : Expression_statement::do_get_backend(Translate_context* context)
    2108                 :            : {
    2109                 :     711985 :   Bexpression* bexpr = this->expr_->get_backend(context);
    2110                 :     711985 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
    2111                 :     711985 :   return context->backend()->expression_statement(bfunction, bexpr);
    2112                 :            : }
    2113                 :            : 
    2114                 :            : // Dump the AST representation for an expression statement
    2115                 :            : 
    2116                 :            : void
    2117                 :          0 : Expression_statement::do_dump_statement(Ast_dump_context* ast_dump_context)
    2118                 :            :     const
    2119                 :            : {
    2120                 :          0 :   ast_dump_context->print_indent();
    2121                 :          0 :   ast_dump_context->dump_expression(expr_);
    2122                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    2123                 :          0 : }
    2124                 :            : 
    2125                 :            : // Make an expression statement from an Expression.
    2126                 :            : 
    2127                 :            : Statement*
    2128                 :     716637 : Statement::make_statement(Expression* expr, bool is_ignored)
    2129                 :            : {
    2130                 :     716637 :   return new Expression_statement(expr, is_ignored);
    2131                 :            : }
    2132                 :            : 
    2133                 :            : // Export data for a block.
    2134                 :            : 
    2135                 :            : void
    2136                 :      20065 : Block_statement::do_export_statement(Export_function_body* efb)
    2137                 :            : {
    2138                 :      20065 :   Block_statement::export_block(efb, this->block_,
    2139                 :      20065 :                                 this->is_lowered_for_statement_);
    2140                 :      20065 : }
    2141                 :            : 
    2142                 :            : void
    2143                 :      24164 : Block_statement::export_block(Export_function_body* efb, Block* block,
    2144                 :            :                               bool is_lowered_for_statement)
    2145                 :            : {
    2146                 :            :   // We are already indented to the right position.
    2147                 :      24164 :   char buf[50];
    2148                 :      24164 :   efb->write_c_string("{");
    2149                 :      24164 :   if (is_lowered_for_statement)
    2150                 :        393 :     efb->write_c_string(" /*for*/");
    2151                 :      24164 :   snprintf(buf, sizeof buf, " //%d\n",
    2152                 :            :            Linemap::location_to_line(block->start_location()));
    2153                 :      24164 :   efb->write_c_string(buf);
    2154                 :            : 
    2155                 :      24164 :   block->export_block(efb);
    2156                 :            :   // The indentation is correct for the statements in the block, so
    2157                 :            :   // subtract one for the closing curly brace.
    2158                 :      24164 :   efb->decrement_indent();
    2159                 :      24164 :   efb->indent();
    2160                 :      24164 :   efb->write_c_string("}");
    2161                 :            :   // Increment back to the value the caller thinks it has.
    2162                 :      24164 :   efb->increment_indent();
    2163                 :      24164 : }
    2164                 :            : 
    2165                 :            : // Import a block statement, returning the block.
    2166                 :            : 
    2167                 :            : Block*
    2168                 :      21164 : Block_statement::do_import(Import_function_body* ifb, Location loc,
    2169                 :            :                            bool* is_lowered_for_statement)
    2170                 :            : {
    2171                 :      21164 :   go_assert(ifb->match_c_string("{"));
    2172                 :      21164 :   *is_lowered_for_statement = false;
    2173                 :      21164 :   if (ifb->match_c_string(" /*for*/"))
    2174                 :            :     {
    2175                 :          0 :       ifb->advance(8);
    2176                 :          0 :       *is_lowered_for_statement = true;
    2177                 :            :     }
    2178                 :      21164 :   size_t nl = ifb->body().find('\n', ifb->off());
    2179                 :      21164 :   if (nl == std::string::npos)
    2180                 :            :     {
    2181                 :          0 :       if (!ifb->saw_error())
    2182                 :          0 :         go_error_at(ifb->location(),
    2183                 :            :                     "import error: no newline after %<{%> at %lu",
    2184                 :          0 :                     static_cast<unsigned long>(ifb->off()));
    2185                 :          0 :       ifb->set_saw_error();
    2186                 :          0 :       return NULL;
    2187                 :            :     }
    2188                 :      21164 :   ifb->set_off(nl + 1);
    2189                 :      21164 :   ifb->increment_indent();
    2190                 :      21164 :   Block* block = new Block(ifb->block(), loc);
    2191                 :      21164 :   ifb->begin_block(block);
    2192                 :      21164 :   bool ok = Block::import_block(block, ifb, loc);
    2193                 :      21164 :   ifb->finish_block();
    2194                 :      21164 :   ifb->decrement_indent();
    2195                 :      21164 :   if (!ok)
    2196                 :          0 :     return NULL;
    2197                 :            :   return block;
    2198                 :            : }
    2199                 :            : 
    2200                 :            : // Convert a block to the backend representation of a statement.
    2201                 :            : 
    2202                 :            : Bstatement*
    2203                 :    1134587 : Block_statement::do_get_backend(Translate_context* context)
    2204                 :            : {
    2205                 :    1134587 :   Bblock* bblock = this->block_->get_backend(context);
    2206                 :    1134587 :   return context->backend()->block_statement(bblock);
    2207                 :            : }
    2208                 :            : 
    2209                 :            : // Dump the AST for a block statement
    2210                 :            : 
    2211                 :            : void
    2212                 :          0 : Block_statement::do_dump_statement(Ast_dump_context*) const
    2213                 :            : {
    2214                 :            :   // block statement braces are dumped when traversing.
    2215                 :          0 : }
    2216                 :            : 
    2217                 :            : // Make a block statement.
    2218                 :            : 
    2219                 :            : Block_statement*
    2220                 :    1137589 : Statement::make_block_statement(Block* block, Location location)
    2221                 :            : {
    2222                 :    1137589 :   return new Block_statement(block, location);
    2223                 :            : }
    2224                 :            : 
    2225                 :            : // An increment or decrement statement.
    2226                 :            : 
    2227                 :            : class Inc_dec_statement : public Statement
    2228                 :            : {
    2229                 :            :  public:
    2230                 :      51214 :   Inc_dec_statement(bool is_inc, Expression* expr)
    2231                 :      51214 :     : Statement(STATEMENT_INCDEC, expr->location()),
    2232                 :     102428 :       expr_(expr), is_inc_(is_inc)
    2233                 :            :   { }
    2234                 :            : 
    2235                 :            :  protected:
    2236                 :            :   int
    2237                 :      76699 :   do_traverse(Traverse* traverse)
    2238                 :      76699 :   { return this->traverse_expression(traverse, &this->expr_); }
    2239                 :            : 
    2240                 :            :   bool
    2241                 :          0 :   do_traverse_assignments(Traverse_assignments*)
    2242                 :          0 :   { go_unreachable(); }
    2243                 :            : 
    2244                 :            :   Statement*
    2245                 :            :   do_lower(Gogo*, Named_object*, Block*, Statement_inserter*);
    2246                 :            : 
    2247                 :            :   Bstatement*
    2248                 :          0 :   do_get_backend(Translate_context*)
    2249                 :          0 :   { go_unreachable(); }
    2250                 :            : 
    2251                 :            :   void
    2252                 :            :   do_dump_statement(Ast_dump_context*) const;
    2253                 :            : 
    2254                 :            :  private:
    2255                 :            :   // The l-value to increment or decrement.
    2256                 :            :   Expression* expr_;
    2257                 :            :   // Whether to increment or decrement.
    2258                 :            :   bool is_inc_;
    2259                 :            : };
    2260                 :            : 
    2261                 :            : // Lower to += or -=.
    2262                 :            : 
    2263                 :            : Statement*
    2264                 :      51214 : Inc_dec_statement::do_lower(Gogo*, Named_object*, Block*, Statement_inserter*)
    2265                 :            : {
    2266                 :      51214 :   Location loc = this->location();
    2267                 :      51214 :   if (!this->expr_->type()->is_numeric_type())
    2268                 :            :     {
    2269                 :          0 :       this->report_error("increment or decrement of non-numeric type");
    2270                 :          0 :       return Statement::make_error_statement(loc);
    2271                 :            :     }
    2272                 :      51214 :   Expression* oexpr = Expression::make_integer_ul(1, this->expr_->type(), loc);
    2273                 :      51214 :   Operator op = this->is_inc_ ? OPERATOR_PLUSEQ : OPERATOR_MINUSEQ;
    2274                 :      51214 :   return Statement::make_assignment_operation(op, this->expr_, oexpr, loc);
    2275                 :            : }
    2276                 :            : 
    2277                 :            : // Dump the AST representation for a inc/dec statement.
    2278                 :            : 
    2279                 :            : void
    2280                 :          0 : Inc_dec_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    2281                 :            : {
    2282                 :          0 :   ast_dump_context->print_indent();
    2283                 :          0 :   ast_dump_context->dump_expression(expr_);
    2284                 :          0 :   ast_dump_context->ostream() << (is_inc_? "++": "--") << dsuffix(location()) << std::endl;
    2285                 :          0 : }
    2286                 :            : 
    2287                 :            : // Make an increment statement.
    2288                 :            : 
    2289                 :            : Statement*
    2290                 :      47190 : Statement::make_inc_statement(Expression* expr)
    2291                 :            : {
    2292                 :      47190 :   return new Inc_dec_statement(true, expr);
    2293                 :            : }
    2294                 :            : 
    2295                 :            : // Make a decrement statement.
    2296                 :            : 
    2297                 :            : Statement*
    2298                 :       4024 : Statement::make_dec_statement(Expression* expr)
    2299                 :            : {
    2300                 :       4024 :   return new Inc_dec_statement(false, expr);
    2301                 :            : }
    2302                 :            : 
    2303                 :            : // Class Thunk_statement.  This is the base class for go and defer
    2304                 :            : // statements.
    2305                 :            : 
    2306                 :            : // Constructor.
    2307                 :            : 
    2308                 :      24236 : Thunk_statement::Thunk_statement(Statement_classification classification,
    2309                 :            :                                  Call_expression* call,
    2310                 :      24236 :                                  Location location)
    2311                 :            :     : Statement(classification, location),
    2312                 :      24236 :       call_(call), struct_type_(NULL)
    2313                 :            : {
    2314                 :      24236 : }
    2315                 :            : 
    2316                 :            : // Return whether this is a simple statement which does not require a
    2317                 :            : // thunk.
    2318                 :            : 
    2319                 :            : bool
    2320                 :      36314 : Thunk_statement::is_simple(Function_type* fntype) const
    2321                 :            : {
    2322                 :            :   // We need a thunk to call a method, or to pass a variable number of
    2323                 :            :   // arguments.
    2324                 :      36314 :   if (fntype->is_method() || fntype->is_varargs())
    2325                 :            :     return false;
    2326                 :            : 
    2327                 :            :   // A defer statement requires a thunk to set up for whether the
    2328                 :            :   // function can call recover.
    2329                 :      26084 :   if (this->classification() == STATEMENT_DEFER)
    2330                 :            :     return false;
    2331                 :            : 
    2332                 :            :   // We can only permit a single parameter of pointer type.
    2333                 :       6394 :   const Typed_identifier_list* parameters = fntype->parameters();
    2334                 :       6394 :   if (parameters != NULL
    2335                 :       6394 :       && (parameters->size() > 1
    2336                 :       2846 :           || (parameters->size() == 1
    2337                 :       2846 :               && parameters->begin()->type()->points_to() == NULL)))
    2338                 :       1210 :     return false;
    2339                 :            : 
    2340                 :            :   // If the function returns multiple values, or returns a type other
    2341                 :            :   // than integer, floating point, or pointer, then it may get a
    2342                 :            :   // hidden first parameter, in which case we need the more
    2343                 :            :   // complicated approach.  This is true even though we are going to
    2344                 :            :   // ignore the return value.
    2345                 :       5184 :   const Typed_identifier_list* results = fntype->results();
    2346                 :       5184 :   if (results != NULL
    2347                 :       5184 :       && (results->size() > 1
    2348                 :         20 :           || (results->size() == 1
    2349                 :         20 :               && !results->begin()->type()->is_basic_type()
    2350                 :         18 :               && results->begin()->type()->points_to() == NULL)))
    2351                 :         18 :     return false;
    2352                 :            : 
    2353                 :            :   // If this calls something that is not a simple function, then we
    2354                 :            :   // need a thunk.
    2355                 :       5166 :   Expression* fn = this->call_->call_expression()->fn();
    2356                 :       5166 :   if (fn->func_expression() == NULL)
    2357                 :            :     return false;
    2358                 :            : 
    2359                 :            :   // If the function uses a closure, then we need a thunk.  FIXME: We
    2360                 :            :   // could accept a zero argument function with a closure.
    2361                 :       5076 :   if (fn->func_expression()->closure() != NULL)
    2362                 :       2670 :     return false;
    2363                 :            : 
    2364                 :            :   return true;
    2365                 :            : }
    2366                 :            : 
    2367                 :            : // Traverse a thunk statement.
    2368                 :            : 
    2369                 :            : int
    2370                 :     279849 : Thunk_statement::do_traverse(Traverse* traverse)
    2371                 :            : {
    2372                 :     279849 :   return this->traverse_expression(traverse, &this->call_);
    2373                 :            : }
    2374                 :            : 
    2375                 :            : // We implement traverse_assignment for a thunk statement because it
    2376                 :            : // effectively copies the function call.
    2377                 :            : 
    2378                 :            : bool
    2379                 :          0 : Thunk_statement::do_traverse_assignments(Traverse_assignments* tassign)
    2380                 :            : {
    2381                 :          0 :   Expression* fn = this->call_->call_expression()->fn();
    2382                 :          0 :   Expression* fn2 = fn;
    2383                 :          0 :   tassign->value(&fn2, true, false);
    2384                 :          0 :   return true;
    2385                 :            : }
    2386                 :            : 
    2387                 :            : // Determine types in a thunk statement.
    2388                 :            : 
    2389                 :            : void
    2390                 :      24236 : Thunk_statement::do_determine_types()
    2391                 :            : {
    2392                 :      24236 :   this->call_->determine_type_no_context();
    2393                 :            : 
    2394                 :            :   // Now that we know the types of the call, build the struct used to
    2395                 :            :   // pass parameters.
    2396                 :      24236 :   Call_expression* ce = this->call_->call_expression();
    2397                 :      24206 :   if (ce == NULL)
    2398                 :            :     return;
    2399                 :      24206 :   Function_type* fntype = ce->get_function_type();
    2400                 :      24206 :   if (fntype != NULL && !this->is_simple(fntype))
    2401                 :      21887 :     this->struct_type_ = this->build_struct(fntype);
    2402                 :            : }
    2403                 :            : 
    2404                 :            : // Check types in a thunk statement.
    2405                 :            : 
    2406                 :            : void
    2407                 :      24236 : Thunk_statement::do_check_types(Gogo*)
    2408                 :            : {
    2409                 :      24236 :   if (!this->call_->discarding_value())
    2410                 :            :     return;
    2411                 :      24194 :   Call_expression* ce = this->call_->call_expression();
    2412                 :            :   if (ce == NULL)
    2413                 :            :     {
    2414                 :          2 :       if (!this->call_->is_error_expression())
    2415                 :          0 :         this->report_error("expected call expression");
    2416                 :          2 :       return;
    2417                 :            :     }
    2418                 :            : }
    2419                 :            : 
    2420                 :            : // The Traverse class used to find and simplify thunk statements.
    2421                 :            : 
    2422                 :       6756 : class Simplify_thunk_traverse : public Traverse
    2423                 :            : {
    2424                 :            :  public:
    2425                 :       3378 :   Simplify_thunk_traverse(Gogo* gogo)
    2426                 :       3378 :     : Traverse(traverse_functions | traverse_blocks),
    2427                 :       3378 :       gogo_(gogo), function_(NULL)
    2428                 :            :   { }
    2429                 :            : 
    2430                 :            :   int
    2431                 :            :   function(Named_object*);
    2432                 :            : 
    2433                 :            :   int
    2434                 :            :   block(Block*);
    2435                 :            : 
    2436                 :            :  private:
    2437                 :            :   // General IR.
    2438                 :            :   Gogo* gogo_;
    2439                 :            :   // The function we are traversing.
    2440                 :            :   Named_object* function_;
    2441                 :            : };
    2442                 :            : 
    2443                 :            : // Keep track of the current function while looking for thunks.
    2444                 :            : 
    2445                 :            : int
    2446                 :     173654 : Simplify_thunk_traverse::function(Named_object* no)
    2447                 :            : {
    2448                 :     173654 :   go_assert(this->function_ == NULL);
    2449                 :     173654 :   this->function_ = no;
    2450                 :     173654 :   int t = no->func_value()->traverse(this);
    2451                 :     173654 :   this->function_ = NULL;
    2452                 :     173654 :   if (t == TRAVERSE_EXIT)
    2453                 :          0 :     return t;
    2454                 :            :   return TRAVERSE_SKIP_COMPONENTS;
    2455                 :            : }
    2456                 :            : 
    2457                 :            : // Look for thunks in a block.
    2458                 :            : 
    2459                 :            : int
    2460                 :    1460609 : Simplify_thunk_traverse::block(Block* b)
    2461                 :            : {
    2462                 :            :   // The parser ensures that thunk statements always appear at the end
    2463                 :            :   // of a block.
    2464                 :    1460609 :   if (b->statements()->size() < 1)
    2465                 :            :     return TRAVERSE_CONTINUE;
    2466                 :    1456688 :   Thunk_statement* stat = b->statements()->back()->thunk_statement();
    2467                 :    1456688 :   if (stat == NULL)
    2468                 :            :     return TRAVERSE_CONTINUE;
    2469                 :      12152 :   if (stat->simplify_statement(this->gogo_, this->function_, b))
    2470                 :      12021 :     return TRAVERSE_SKIP_COMPONENTS;
    2471                 :            :   return TRAVERSE_CONTINUE;
    2472                 :            : }
    2473                 :            : 
    2474                 :            : // Simplify all thunk statements.
    2475                 :            : 
    2476                 :            : void
    2477                 :       3378 : Gogo::simplify_thunk_statements()
    2478                 :            : {
    2479                 :       3378 :   Simplify_thunk_traverse thunk_traverse(this);
    2480                 :       3378 :   this->traverse(&thunk_traverse);
    2481                 :       3378 : }
    2482                 :            : 
    2483                 :            : // Return true if the thunk function is a constant, which means that
    2484                 :            : // it does not need to be passed to the thunk routine.
    2485                 :            : 
    2486                 :            : bool
    2487                 :      45929 : Thunk_statement::is_constant_function() const
    2488                 :            : {
    2489                 :      45929 :   Call_expression* ce = this->call_->call_expression();
    2490                 :      45929 :   Function_type* fntype = ce->get_function_type();
    2491                 :      45929 :   if (fntype == NULL)
    2492                 :            :     {
    2493                 :          0 :       go_assert(saw_errors());
    2494                 :            :       return false;
    2495                 :            :     }
    2496                 :      45929 :   if (fntype->is_builtin())
    2497                 :            :     return true;
    2498                 :      45218 :   Expression* fn = ce->fn();
    2499                 :      45218 :   if (fn->func_expression() != NULL)
    2500                 :      40866 :     return fn->func_expression()->closure() == NULL;
    2501                 :       4352 :   if (fn->interface_field_reference_expression() != NULL)
    2502                 :       2535 :     return true;
    2503                 :            :   return false;
    2504                 :            : }
    2505                 :            : 
    2506                 :            : // Simplify complex thunk statements into simple ones.  A complicated
    2507                 :            : // thunk statement is one which takes anything other than zero
    2508                 :            : // parameters or a single pointer parameter.  We rewrite it into code
    2509                 :            : // which allocates a struct, stores the parameter values into the
    2510                 :            : // struct, and does a simple go or defer statement which passes the
    2511                 :            : // struct to a thunk.  The thunk does the real call.
    2512                 :            : 
    2513                 :            : bool
    2514                 :      12152 : Thunk_statement::simplify_statement(Gogo* gogo, Named_object* function,
    2515                 :            :                                     Block* block)
    2516                 :            : {
    2517                 :      12152 :   if (this->classification() == STATEMENT_ERROR)
    2518                 :            :     return false;
    2519                 :      12152 :   if (this->call_->is_error_expression())
    2520                 :            :     return false;
    2521                 :            : 
    2522                 :      12108 :   if (this->classification() == STATEMENT_DEFER)
    2523                 :            :     {
    2524                 :            :       // Make sure that the defer stack exists for the function.  We
    2525                 :            :       // will use when converting this statement to the backend
    2526                 :            :       // representation, but we want it to exist when we start
    2527                 :            :       // converting the function.
    2528                 :       9791 :       function->func_value()->defer_stack(this->location());
    2529                 :            :     }
    2530                 :            : 
    2531                 :      12108 :   Call_expression* ce = this->call_->call_expression();
    2532                 :      12108 :   Function_type* fntype = ce->get_function_type();
    2533                 :      12108 :   if (fntype == NULL)
    2534                 :            :     {
    2535                 :          0 :       go_assert(saw_errors());
    2536                 :          0 :       this->set_is_error();
    2537                 :          0 :       return false;
    2538                 :            :     }
    2539                 :      12108 :   if (this->is_simple(fntype))
    2540                 :            :     return false;
    2541                 :            : 
    2542                 :      12021 :   Expression* fn = ce->fn();
    2543                 :      12021 :   Interface_field_reference_expression* interface_method =
    2544                 :      12021 :     fn->interface_field_reference_expression();
    2545                 :            : 
    2546                 :      12021 :   Location location = this->location();
    2547                 :            : 
    2548                 :      12021 :   bool is_constant_function = this->is_constant_function();
    2549                 :      12021 :   Temporary_statement* fn_temp = NULL;
    2550                 :      12021 :   if (!is_constant_function)
    2551                 :            :     {
    2552                 :       3178 :       fn_temp = Statement::make_temporary(NULL, fn, location);
    2553                 :       3178 :       block->insert_statement_before(block->statements()->size() - 1, fn_temp);
    2554                 :       3178 :       fn = Expression::make_temporary_reference(fn_temp, location);
    2555                 :            :     }
    2556                 :            : 
    2557                 :      12021 :   std::string thunk_name = gogo->thunk_name();
    2558                 :            : 
    2559                 :            :   // Build the thunk.
    2560                 :      12021 :   this->build_thunk(gogo, thunk_name);
    2561                 :            : 
    2562                 :            :   // Generate code to call the thunk.
    2563                 :            : 
    2564                 :            :   // Get the values to store into the struct which is the single
    2565                 :            :   // argument to the thunk.
    2566                 :            : 
    2567                 :      12021 :   Expression_list* vals = new Expression_list();
    2568                 :      12021 :   if (!is_constant_function)
    2569                 :       3178 :     vals->push_back(fn);
    2570                 :            : 
    2571                 :      12021 :   if (interface_method != NULL)
    2572                 :        845 :     vals->push_back(interface_method->expr());
    2573                 :            : 
    2574                 :      12021 :   if (ce->args() != NULL)
    2575                 :            :     {
    2576                 :      17436 :       for (Expression_list::const_iterator p = ce->args()->begin();
    2577                 :      17436 :            p != ce->args()->end();
    2578                 :      17436 :            ++p)
    2579                 :            :         {
    2580                 :       9551 :           if ((*p)->is_constant())
    2581                 :        812 :             continue;
    2582                 :       8739 :           vals->push_back(*p);
    2583                 :            :         }
    2584                 :            :     }
    2585                 :            : 
    2586                 :            :   // Build the struct.
    2587                 :      12021 :   Expression* constructor =
    2588                 :      12021 :     Expression::make_struct_composite_literal(this->struct_type_, vals,
    2589                 :            :                                               location);
    2590                 :            : 
    2591                 :            :   // Allocate the initialized struct on the heap.
    2592                 :      12021 :   constructor = Expression::make_heap_expression(constructor, location);
    2593                 :      12021 :   if ((Node::make_node(this)->encoding() & ESCAPE_MASK) == Node::ESCAPE_NONE)
    2594                 :       9459 :     constructor->heap_expression()->set_allocate_on_stack();
    2595                 :            : 
    2596                 :            :   // Throw an error if the function is nil.  This is so that for `go
    2597                 :            :   // nil` we get a backtrace from the go statement, rather than a
    2598                 :            :   // useless backtrace from the brand new goroutine.
    2599                 :      12021 :   Expression* param = constructor;
    2600                 :      12021 :   if (!is_constant_function && this->classification() == STATEMENT_GO)
    2601                 :            :     {
    2602                 :       1618 :       fn = Expression::make_temporary_reference(fn_temp, location);
    2603                 :       1618 :       Expression* nil = Expression::make_nil(location);
    2604                 :       1618 :       Expression* isnil = Expression::make_binary(OPERATOR_EQEQ, fn, nil,
    2605                 :            :                                                   location);
    2606                 :       1618 :       Expression* crash = Runtime::make_call(Runtime::PANIC_GO_NIL,
    2607                 :            :                                              location, 0);
    2608                 :       1618 :       crash = Expression::make_conditional(isnil, crash,
    2609                 :            :                                            Expression::make_nil(location),
    2610                 :            :                                            location);
    2611                 :       1618 :       param = Expression::make_compound(crash, constructor, location);
    2612                 :            :     }
    2613                 :            : 
    2614                 :            :   // Look up the thunk.
    2615                 :      12021 :   Named_object* named_thunk = gogo->lookup(thunk_name, NULL);
    2616                 :      12021 :   go_assert(named_thunk != NULL && named_thunk->is_function());
    2617                 :            : 
    2618                 :            :   // Build the call.
    2619                 :      12021 :   Expression* func = Expression::make_func_reference(named_thunk, NULL,
    2620                 :            :                                                      location);
    2621                 :      12021 :   Expression_list* params = new Expression_list();
    2622                 :      12021 :   params->push_back(param);
    2623                 :      12021 :   Call_expression* call = Expression::make_call(func, params, false, location);
    2624                 :            : 
    2625                 :            :   // Build the simple go or defer statement.
    2626                 :      12021 :   Statement* s;
    2627                 :      12021 :   if (this->classification() == STATEMENT_GO)
    2628                 :       2230 :     s = Statement::make_go_statement(call, location);
    2629                 :       9791 :   else if (this->classification() == STATEMENT_DEFER)
    2630                 :            :     {
    2631                 :       9791 :       s = Statement::make_defer_statement(call, location);
    2632                 :       9791 :       if ((Node::make_node(this)->encoding() & ESCAPE_MASK) == Node::ESCAPE_NONE)
    2633                 :       9459 :         s->defer_statement()->set_on_stack();
    2634                 :            :     }
    2635                 :            :   else
    2636                 :          0 :     go_unreachable();
    2637                 :            : 
    2638                 :            :   // The current block should end with the go statement.
    2639                 :      12021 :   go_assert(block->statements()->size() >= 1);
    2640                 :      12021 :   go_assert(block->statements()->back() == this);
    2641                 :      12021 :   block->replace_statement(block->statements()->size() - 1, s);
    2642                 :            : 
    2643                 :            :   // We already ran the determine_types pass, so we need to run it now
    2644                 :            :   // for the new statement.
    2645                 :      12021 :   s->determine_types();
    2646                 :            : 
    2647                 :            :   // Sanity check.
    2648                 :      12021 :   gogo->check_types_in_block(block);
    2649                 :            : 
    2650                 :            :   // Return true to tell the block not to keep looking at statements.
    2651                 :      12021 :   return true;
    2652                 :            : }
    2653                 :            : 
    2654                 :            : // Set the name to use for thunk parameter N.
    2655                 :            : 
    2656                 :            : void
    2657                 :      18547 : Thunk_statement::thunk_field_param(int n, char* buf, size_t buflen)
    2658                 :            : {
    2659                 :      18547 :   snprintf(buf, buflen, "a%d", n);
    2660                 :      18547 : }
    2661                 :            : 
    2662                 :            : // Build a new struct type to hold the parameters for a complicated
    2663                 :            : // thunk statement.  FNTYPE is the type of the function call.
    2664                 :            : 
    2665                 :            : Struct_type*
    2666                 :      21887 : Thunk_statement::build_struct(Function_type* fntype)
    2667                 :            : {
    2668                 :      21887 :   Location location = this->location();
    2669                 :            : 
    2670                 :      21887 :   Struct_field_list* fields = new Struct_field_list();
    2671                 :            : 
    2672                 :      21887 :   Call_expression* ce = this->call_->call_expression();
    2673                 :      21887 :   Expression* fn = ce->fn();
    2674                 :            : 
    2675                 :      21887 :   if (!this->is_constant_function())
    2676                 :            :     {
    2677                 :            :       // The function to call.
    2678                 :       6456 :       fields->push_back(Struct_field(Typed_identifier("fn", fntype,
    2679                 :       6456 :                                                       location)));
    2680                 :            :     }
    2681                 :            : 
    2682                 :            :   // If this thunk statement calls a method on an interface, we pass
    2683                 :            :   // the interface object to the thunk.
    2684                 :      21887 :   Interface_field_reference_expression* interface_method =
    2685                 :      22732 :     fn->interface_field_reference_expression();
    2686                 :        845 :   if (interface_method != NULL)
    2687                 :            :     {
    2688                 :        845 :       Typed_identifier tid("object", interface_method->expr()->type(),
    2689                 :       1690 :                            location);
    2690                 :        845 :       fields->push_back(Struct_field(tid));
    2691                 :            :     }
    2692                 :            : 
    2693                 :            :   // The predeclared recover function has no argument.  However, we
    2694                 :            :   // add an argument when building recover thunks.  Handle that here.
    2695                 :      21887 :   if (ce->is_recover_call())
    2696                 :            :     {
    2697                 :          8 :       fields->push_back(Struct_field(Typed_identifier("can_recover",
    2698                 :          8 :                                                       Type::lookup_bool_type(),
    2699                 :         16 :                                                       location)));
    2700                 :            :     }
    2701                 :            : 
    2702                 :      21887 :   const Expression_list* args = ce->args();
    2703                 :      21887 :   if (args != NULL)
    2704                 :            :     {
    2705                 :      17693 :       int i = 0;
    2706                 :      37062 :       for (Expression_list::const_iterator p = args->begin();
    2707                 :      37062 :            p != args->end();
    2708                 :      19369 :            ++p, ++i)
    2709                 :            :         {
    2710                 :      19369 :           if ((*p)->is_constant())
    2711                 :        822 :             continue;
    2712                 :            : 
    2713                 :      18547 :           char buf[50];
    2714                 :      18547 :           this->thunk_field_param(i, buf, sizeof buf);
    2715                 :      37094 :           fields->push_back(Struct_field(Typed_identifier(buf, (*p)->type(),
    2716                 :      37094 :                                                           location)));
    2717                 :            :         }
    2718                 :            :     }
    2719                 :            : 
    2720                 :      21887 :   Struct_type *st = Type::make_struct_type(fields, location);
    2721                 :      21887 :   st->set_is_struct_incomparable();
    2722                 :      21887 :   return st;
    2723                 :            : }
    2724                 :            : 
    2725                 :            : // Build the thunk we are going to call.  This is a brand new, albeit
    2726                 :            : // artificial, function.
    2727                 :            : 
    2728                 :            : void
    2729                 :      12021 : Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name)
    2730                 :            : {
    2731                 :      12021 :   Location location = this->location();
    2732                 :            : 
    2733                 :      12021 :   Call_expression* ce = this->call_->call_expression();
    2734                 :            : 
    2735                 :      12021 :   bool may_call_recover = false;
    2736                 :      12021 :   if (this->classification() == STATEMENT_DEFER)
    2737                 :            :     {
    2738                 :       9791 :       Func_expression* fn = ce->fn()->func_expression();
    2739                 :       8474 :       if (fn == NULL)
    2740                 :            :         may_call_recover = true;
    2741                 :            :       else
    2742                 :            :         {
    2743                 :       8474 :           const Named_object* no = fn->named_object();
    2744                 :       8474 :           if (!no->is_function())
    2745                 :            :             may_call_recover = true;
    2746                 :            :           else
    2747                 :       4422 :             may_call_recover = no->func_value()->calls_recover();
    2748                 :            :         }
    2749                 :            :     }
    2750                 :            : 
    2751                 :            :   // Build the type of the thunk.  The thunk takes a single parameter,
    2752                 :            :   // which is a pointer to the special structure we build.
    2753                 :      12021 :   const char* const parameter_name = "__go_thunk_parameter";
    2754                 :      12021 :   Typed_identifier_list* thunk_parameters = new Typed_identifier_list();
    2755                 :      12021 :   Type* pointer_to_struct_type = Type::make_pointer_type(this->struct_type_);
    2756                 :      24042 :   thunk_parameters->push_back(Typed_identifier(parameter_name,
    2757                 :            :                                                pointer_to_struct_type,
    2758                 :      24042 :                                                location));
    2759                 :            : 
    2760                 :      12021 :   Typed_identifier_list* thunk_results = NULL;
    2761                 :      12021 :   if (may_call_recover)
    2762                 :            :     {
    2763                 :            :       // When deferring a function which may call recover, add a
    2764                 :            :       // return value, to disable tail call optimizations which will
    2765                 :            :       // break the way we check whether recover is permitted.
    2766                 :       6262 :       thunk_results = new Typed_identifier_list();
    2767                 :      12524 :       thunk_results->push_back(Typed_identifier("", Type::lookup_bool_type(),
    2768                 :      12524 :                                                 location));
    2769                 :            :     }
    2770                 :            : 
    2771                 :      12021 :   Function_type* thunk_type = Type::make_function_type(NULL, thunk_parameters,
    2772                 :            :                                                        thunk_results,
    2773                 :            :                                                        location);
    2774                 :            : 
    2775                 :            :   // Start building the thunk.
    2776                 :      12021 :   Named_object* function = gogo->start_function(thunk_name, thunk_type, true,
    2777                 :            :                                                 location);
    2778                 :            : 
    2779                 :      12021 :   gogo->start_block(location);
    2780                 :            : 
    2781                 :            :   // For a defer statement, start with a call to
    2782                 :            :   // __go_set_defer_retaddr.  */
    2783                 :      12021 :   Label* retaddr_label = NULL;
    2784                 :      12021 :   if (may_call_recover)
    2785                 :            :     {
    2786                 :       6262 :       retaddr_label = gogo->add_label_reference("retaddr", location, false);
    2787                 :       6262 :       Expression* arg = Expression::make_label_addr(retaddr_label, location);
    2788                 :       6262 :       Expression* call = Runtime::make_call(Runtime::SETDEFERRETADDR,
    2789                 :            :                                             location, 1, arg);
    2790                 :            : 
    2791                 :            :       // This is a hack to prevent the middle-end from deleting the
    2792                 :            :       // label.
    2793                 :       6262 :       gogo->start_block(location);
    2794                 :       6262 :       gogo->add_statement(Statement::make_goto_statement(retaddr_label,
    2795                 :            :                                                          location));
    2796                 :       6262 :       Block* then_block = gogo->finish_block(location);
    2797                 :       6262 :       then_block->determine_types();
    2798                 :            : 
    2799                 :       6262 :       Statement* s = Statement::make_if_statement(call, then_block, NULL,
    2800                 :            :                                                   location);
    2801                 :       6262 :       s->determine_types();
    2802                 :       6262 :       gogo->add_statement(s);
    2803                 :            : 
    2804                 :       6262 :       function->func_value()->set_calls_defer_retaddr();
    2805                 :            :     }
    2806                 :            : 
    2807                 :            :   // Get a reference to the parameter.
    2808                 :      12021 :   Named_object* named_parameter = gogo->lookup(parameter_name, NULL);
    2809                 :      12021 :   go_assert(named_parameter != NULL && named_parameter->is_variable());
    2810                 :            : 
    2811                 :            :   // Build the call.  Note that the field names are the same as the
    2812                 :            :   // ones used in build_struct.
    2813                 :      12021 :   Expression* thunk_parameter = Expression::make_var_reference(named_parameter,
    2814                 :            :                                                                location);
    2815                 :      12021 :   thunk_parameter =
    2816                 :      12021 :       Expression::make_dereference(thunk_parameter,
    2817                 :            :                                    Expression::NIL_CHECK_NOT_NEEDED,
    2818                 :            :                                    location);
    2819                 :            : 
    2820                 :      12021 :   Interface_field_reference_expression* interface_method =
    2821                 :      12021 :     ce->fn()->interface_field_reference_expression();
    2822                 :            : 
    2823                 :      12021 :   Expression* func_to_call;
    2824                 :      12021 :   unsigned int next_index;
    2825                 :      12021 :   if (this->is_constant_function())
    2826                 :            :     {
    2827                 :       8843 :       func_to_call = ce->fn();
    2828                 :       8843 :       next_index = 0;
    2829                 :            :     }
    2830                 :            :   else
    2831                 :            :     {
    2832                 :       3178 :       func_to_call = Expression::make_field_reference(thunk_parameter,
    2833                 :            :                                                       0, location);
    2834                 :       3178 :       next_index = 1;
    2835                 :            :     }
    2836                 :            : 
    2837                 :      12021 :   if (interface_method != NULL)
    2838                 :            :     {
    2839                 :            :       // The main program passes the interface object.
    2840                 :        845 :       go_assert(next_index == 0);
    2841                 :        845 :       Expression* r = Expression::make_field_reference(thunk_parameter, 0,
    2842                 :            :                                                        location);
    2843                 :        845 :       const std::string& name(interface_method->name());
    2844                 :        845 :       func_to_call = Expression::make_interface_field_reference(r, name,
    2845                 :            :                                                                 location);
    2846                 :        845 :       next_index = 1;
    2847                 :            :     }
    2848                 :            : 
    2849                 :      12021 :   Expression_list* call_params = new Expression_list();
    2850                 :      12021 :   const Struct_field_list* fields = this->struct_type_->fields();
    2851                 :      12021 :   Struct_field_list::const_iterator p = fields->begin();
    2852                 :      12021 :   for (unsigned int i = 0; i < next_index; ++i)
    2853                 :            :     ++p;
    2854                 :      12021 :   bool is_recover_call = ce->is_recover_call();
    2855                 :      12021 :   Expression* recover_arg = NULL;
    2856                 :            : 
    2857                 :      12021 :   const Expression_list* args = ce->args();
    2858                 :      12021 :   if (args != NULL)
    2859                 :            :     {
    2860                 :      17436 :       for (Expression_list::const_iterator arg = args->begin();
    2861                 :      17436 :            arg != args->end();
    2862                 :      17436 :            ++arg)
    2863                 :            :         {
    2864                 :       9551 :           Expression* param;
    2865                 :       9551 :           if ((*arg)->is_constant())
    2866                 :        812 :             param = *arg;
    2867                 :            :           else
    2868                 :            :             {
    2869                 :       8739 :               Expression* thunk_param =
    2870                 :       8739 :                 Expression::make_var_reference(named_parameter, location);
    2871                 :       8739 :              thunk_param =
    2872                 :       8739 :                  Expression::make_dereference(thunk_param,
    2873                 :            :                                               Expression::NIL_CHECK_NOT_NEEDED,
    2874                 :            :                                               location);
    2875                 :       8739 :               param = Expression::make_field_reference(thunk_param,
    2876                 :            :                                                        next_index,
    2877                 :            :                                                        location);
    2878                 :       8739 :               ++next_index;
    2879                 :            :             }
    2880                 :            : 
    2881                 :       9551 :           if (!is_recover_call)
    2882                 :       9543 :             call_params->push_back(param);
    2883                 :            :           else
    2884                 :            :             {
    2885                 :          8 :               go_assert(call_params->empty());
    2886                 :            :               recover_arg = param;
    2887                 :            :             }
    2888                 :            :         }
    2889                 :            :     }
    2890                 :            : 
    2891                 :      12021 :   if (call_params->empty())
    2892                 :            :     {
    2893                 :       4144 :       delete call_params;
    2894                 :       4144 :       call_params = NULL;
    2895                 :            :     }
    2896                 :            : 
    2897                 :      12021 :   Call_expression* call = Expression::make_call(func_to_call, call_params,
    2898                 :            :                                                 false, location);
    2899                 :            : 
    2900                 :            :   // This call expression was already lowered before entering the
    2901                 :            :   // thunk statement.  Don't try to lower varargs again, as that will
    2902                 :            :   // cause confusion for, e.g., method calls which already have a
    2903                 :            :   // receiver parameter.
    2904                 :      12021 :   call->set_varargs_are_lowered();
    2905                 :            : 
    2906                 :      12021 :   Statement* call_statement = Statement::make_statement(call, true);
    2907                 :            : 
    2908                 :      12021 :   gogo->add_statement(call_statement);
    2909                 :            : 
    2910                 :            :   // If this is a defer statement, the label comes immediately after
    2911                 :            :   // the call.
    2912                 :      12021 :   if (may_call_recover)
    2913                 :            :     {
    2914                 :       6262 :       gogo->add_label_definition("retaddr", location);
    2915                 :            : 
    2916                 :       6262 :       Expression_list* vals = new Expression_list();
    2917                 :       6262 :       vals->push_back(Expression::make_boolean(false, location));
    2918                 :       6262 :       gogo->add_statement(Statement::make_return_statement(vals, location));
    2919                 :            :     }
    2920                 :            : 
    2921                 :      12021 :   Block* b = gogo->finish_block(location);
    2922                 :            : 
    2923                 :      12021 :   gogo->add_block(b, location);
    2924                 :            : 
    2925                 :      12021 :   gogo->lower_block(function, b);
    2926                 :            : 
    2927                 :            :   // We already ran the determine_types pass, so we need to run it
    2928                 :            :   // just for the call statement now.  The other types are known.
    2929                 :      12021 :   call_statement->determine_types();
    2930                 :            : 
    2931                 :      12021 :   gogo->add_conversions_in_block(b);
    2932                 :            : 
    2933                 :      12021 :   if (may_call_recover
    2934                 :      12021 :       || recover_arg != NULL
    2935                 :      12021 :       || this->classification() == STATEMENT_GO)
    2936                 :            :     {
    2937                 :            :       // Dig up the call expression, which may have been changed
    2938                 :            :       // during lowering.
    2939                 :       8492 :       go_assert(call_statement->classification() == STATEMENT_EXPRESSION);
    2940                 :       8492 :       Expression_statement* es =
    2941                 :            :         static_cast<Expression_statement*>(call_statement);
    2942                 :       8492 :       ce = es->expr()->call_expression();
    2943                 :       8492 :       if (ce == NULL)
    2944                 :          0 :         go_assert(saw_errors());
    2945                 :            :       else
    2946                 :            :         {
    2947                 :       8492 :           if (may_call_recover)
    2948                 :       6262 :             ce->set_is_deferred();
    2949                 :       8492 :           if (this->classification() == STATEMENT_GO)
    2950                 :       2230 :             ce->set_is_concurrent();
    2951                 :       8492 :           if (recover_arg != NULL)
    2952                 :          8 :             ce->set_recover_arg(recover_arg);
    2953                 :            :         }
    2954                 :            :     }
    2955                 :            : 
    2956                 :      12021 :   gogo->flatten_block(function, b);
    2957                 :            : 
    2958                 :            :   // That is all the thunk has to do.
    2959                 :      12021 :   gogo->finish_function(location);
    2960                 :      12021 : }
    2961                 :            : 
    2962                 :            : // Get the function and argument expressions.
    2963                 :            : 
    2964                 :            : bool
    2965                 :      12152 : Thunk_statement::get_fn_and_arg(Expression** pfn, Expression** parg)
    2966                 :            : {
    2967                 :      12152 :   if (this->call_->is_error_expression())
    2968                 :            :     return false;
    2969                 :            : 
    2970                 :      12108 :   Call_expression* ce = this->call_->call_expression();
    2971                 :            : 
    2972                 :      12108 :   Expression* fn = ce->fn();
    2973                 :      12108 :   Func_expression* fe = fn->func_expression();
    2974                 :          0 :   go_assert(fe != NULL);
    2975                 :      12108 :   *pfn = Expression::make_func_code_reference(fe->named_object(),
    2976                 :            :                                               fe->location());
    2977                 :            : 
    2978                 :      12108 :   const Expression_list* args = ce->args();
    2979                 :      12108 :   if (args == NULL || args->empty())
    2980                 :         60 :     *parg = Expression::make_nil(this->location());
    2981                 :            :   else
    2982                 :            :     {
    2983                 :      12048 :       go_assert(args->size() == 1);
    2984                 :      12048 :       *parg = args->front();
    2985                 :            :     }
    2986                 :            : 
    2987                 :            :   return true;
    2988                 :            : }
    2989                 :            : 
    2990                 :            : // Class Go_statement.
    2991                 :            : 
    2992                 :            : Bstatement*
    2993                 :       2330 : Go_statement::do_get_backend(Translate_context* context)
    2994                 :            : {
    2995                 :       2330 :   Expression* fn;
    2996                 :       2330 :   Expression* arg;
    2997                 :       2330 :   if (!this->get_fn_and_arg(&fn, &arg))
    2998                 :         13 :     return context->backend()->error_statement();
    2999                 :            : 
    3000                 :       2317 :   Expression* call = Runtime::make_call(Runtime::GO, this->location(), 2,
    3001                 :            :                                         fn, arg);
    3002                 :       2317 :   Bexpression* bcall = call->get_backend(context);
    3003                 :       2317 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
    3004                 :       2317 :   return context->backend()->expression_statement(bfunction, bcall);
    3005                 :            : }
    3006                 :            : 
    3007                 :            : // Dump the AST representation for go statement.
    3008                 :            : 
    3009                 :            : void
    3010                 :          0 : Go_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    3011                 :            : {
    3012                 :          0 :   ast_dump_context->print_indent();
    3013                 :          0 :   ast_dump_context->ostream() << "go ";
    3014                 :          0 :   ast_dump_context->dump_expression(this->call());
    3015                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    3016                 :          0 : }
    3017                 :            : 
    3018                 :            : // Make a go statement.
    3019                 :            : 
    3020                 :            : Statement*
    3021                 :       4564 : Statement::make_go_statement(Call_expression* call, Location location)
    3022                 :            : {
    3023                 :       4564 :   return new Go_statement(call, location);
    3024                 :            : }
    3025                 :            : 
    3026                 :            : // Class Defer_statement.
    3027                 :            : 
    3028                 :            : Bstatement*
    3029                 :       9822 : Defer_statement::do_get_backend(Translate_context* context)
    3030                 :            : {
    3031                 :       9822 :   Expression* fn;
    3032                 :       9822 :   Expression* arg;
    3033                 :       9822 :   if (!this->get_fn_and_arg(&fn, &arg))
    3034                 :         31 :     return context->backend()->error_statement();
    3035                 :            : 
    3036                 :       9791 :   Location loc = this->location();
    3037                 :       9791 :   Expression* ds = context->function()->func_value()->defer_stack(loc);
    3038                 :            : 
    3039                 :       9791 :   Expression* call;
    3040                 :       9791 :   if (this->on_stack_)
    3041                 :            :     {
    3042                 :       9459 :       if (context->gogo()->debug_optimization())
    3043                 :          0 :         go_debug(loc, "stack allocated defer");
    3044                 :            : 
    3045                 :       9459 :       Type* defer_type = Defer_statement::defer_struct_type();
    3046                 :       9459 :       Expression* defer = Expression::make_allocation(defer_type, loc);
    3047                 :       9459 :       defer->allocation_expression()->set_allocate_on_stack();
    3048                 :       9459 :       defer->allocation_expression()->set_no_zero();
    3049                 :       9459 :       call = Runtime::make_call(Runtime::DEFERPROCSTACK, loc, 4,
    3050                 :            :                                 defer, ds, fn, arg);
    3051                 :            :     }
    3052                 :            :   else
    3053                 :        332 :     call = Runtime::make_call(Runtime::DEFERPROC, loc, 3,
    3054                 :            :                               ds, fn, arg);
    3055                 :       9791 :   Bexpression* bcall = call->get_backend(context);
    3056                 :       9791 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
    3057                 :       9791 :   return context->backend()->expression_statement(bfunction, bcall);
    3058                 :            : }
    3059                 :            : 
    3060                 :            : Type*
    3061                 :       9459 : Defer_statement::defer_struct_type()
    3062                 :            : {
    3063                 :       9459 :   Type* ptr_type = Type::make_pointer_type(Type::make_void_type());
    3064                 :       9459 :   Type* uintptr_type = Type::lookup_integer_type("uintptr");
    3065                 :       9459 :   Type* bool_type = Type::make_boolean_type();
    3066                 :       9459 :   return Type::make_builtin_struct_type(9,
    3067                 :            :                                         "link", ptr_type,
    3068                 :            :                                         "frame", ptr_type,
    3069                 :            :                                         "panicStack", ptr_type,
    3070                 :            :                                         "_panic", ptr_type,
    3071                 :            :                                         "pfn", uintptr_type,
    3072                 :            :                                         "arg", ptr_type,
    3073                 :            :                                         "retaddr", uintptr_type,
    3074                 :            :                                         "makefunccanrecover", bool_type,
    3075                 :       9459 :                                         "heap", bool_type);
    3076                 :            : }
    3077                 :            : 
    3078                 :            : // Dump the AST representation for defer statement.
    3079                 :            : 
    3080                 :            : void
    3081                 :          0 : Defer_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    3082                 :            : {
    3083                 :          0 :   ast_dump_context->print_indent();
    3084                 :          0 :   ast_dump_context->ostream() << "defer ";
    3085                 :          0 :   ast_dump_context->dump_expression(this->call());
    3086                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    3087                 :          0 : }
    3088                 :            : 
    3089                 :            : // Make a defer statement.
    3090                 :            : 
    3091                 :            : Statement*
    3092                 :      19672 : Statement::make_defer_statement(Call_expression* call,
    3093                 :            :                                 Location location)
    3094                 :            : {
    3095                 :      19672 :   return new Defer_statement(call, location);
    3096                 :            : }
    3097                 :            : 
    3098                 :            : // Class Return_statement.
    3099                 :            : 
    3100                 :            : // Traverse assignments.  We treat each return value as a top level
    3101                 :            : // RHS in an expression.
    3102                 :            : 
    3103                 :            : bool
    3104                 :          0 : Return_statement::do_traverse_assignments(Traverse_assignments* tassign)
    3105                 :            : {
    3106                 :          0 :   Expression_list* vals = this->vals_;
    3107                 :          0 :   if (vals != NULL)
    3108                 :            :     {
    3109                 :          0 :       for (Expression_list::iterator p = vals->begin();
    3110                 :          0 :            p != vals->end();
    3111                 :          0 :            ++p)
    3112                 :          0 :         tassign->value(&*p, true, true);
    3113                 :            :     }
    3114                 :          0 :   return true;
    3115                 :            : }
    3116                 :            : 
    3117                 :            : // Lower a return statement.  If we are returning a function call
    3118                 :            : // which returns multiple values which match the current function,
    3119                 :            : // split up the call's results.  If the return statement lists
    3120                 :            : // explicit values, implement this statement by assigning the values
    3121                 :            : // to the result variables and change this statement to a naked
    3122                 :            : // return.  This lets panic/recover work correctly.
    3123                 :            : 
    3124                 :            : Statement*
    3125                 :     660818 : Return_statement::do_lower(Gogo*, Named_object* function, Block* enclosing,
    3126                 :            :                            Statement_inserter*)
    3127                 :            : {
    3128                 :     660818 :   if (this->is_lowered_)
    3129                 :     348206 :     return this;
    3130                 :            : 
    3131                 :     312612 :   Expression_list* vals = this->vals_;
    3132                 :     312612 :   this->vals_ = NULL;
    3133                 :     312612 :   this->is_lowered_ = true;
    3134                 :            : 
    3135                 :     312612 :   Location loc = this->location();
    3136                 :            : 
    3137                 :     312612 :   size_t vals_count = vals == NULL ? 0 : vals->size();
    3138                 :     312612 :   Function::Results* results = function->func_value()->result_variables();
    3139                 :     312612 :   size_t results_count = results == NULL ? 0 : results->size();
    3140                 :            : 
    3141                 :     312612 :   if (vals_count == 0)
    3142                 :            :     {
    3143                 :      28253 :       if (results_count > 0 && !function->func_value()->results_are_named())
    3144                 :            :         {
    3145                 :          1 :           this->report_error(_("not enough arguments to return"));
    3146                 :          1 :           return this;
    3147                 :            :         }
    3148                 :      28252 :       return this;
    3149                 :            :     }
    3150                 :            : 
    3151                 :     284359 :   if (results_count == 0)
    3152                 :            :     {
    3153                 :          1 :       this->report_error(_("return with value in function "
    3154                 :            :                            "with no return type"));
    3155                 :          1 :       return this;
    3156                 :            :     }
    3157                 :            : 
    3158                 :            :   // If the current function has multiple return values, and we are
    3159                 :            :   // returning a single call expression, split up the call expression.
    3160                 :     284358 :   if (results_count > 1
    3161                 :      45734 :       && vals->size() == 1
    3162                 :     288723 :       && vals->front()->call_expression() != NULL)
    3163                 :            :     {
    3164                 :       4365 :       Call_expression* call = vals->front()->call_expression();
    3165                 :       4365 :       call->set_expected_result_count(results_count);
    3166                 :       4365 :       delete vals;
    3167                 :       4365 :       vals = new Expression_list;
    3168                 :      13411 :       for (size_t i = 0; i < results_count; ++i)
    3169                 :       9046 :         vals->push_back(Expression::make_call_result(call, i));
    3170                 :            :       vals_count = results_count;
    3171                 :            :     }
    3172                 :            : 
    3173                 :     284358 :   if (vals_count < results_count)
    3174                 :            :     {
    3175                 :          1 :       this->report_error(_("not enough arguments to return"));
    3176                 :          1 :       return this;
    3177                 :            :     }
    3178                 :            : 
    3179                 :     284357 :   if (vals_count > results_count)
    3180                 :            :     {
    3181                 :          0 :       this->report_error(_("too many values in return statement"));
    3182                 :          0 :       return this;
    3183                 :            :     }
    3184                 :            : 
    3185                 :     284357 :   Block* b = new Block(enclosing, loc);
    3186                 :            : 
    3187                 :     284357 :   Expression_list* lhs = new Expression_list();
    3188                 :     284357 :   Expression_list* rhs = new Expression_list();
    3189                 :            : 
    3190                 :     284357 :   Expression_list::const_iterator pe = vals->begin();
    3191                 :     284357 :   int i = 1;
    3192                 :     284357 :   for (Function::Results::const_iterator pr = results->begin();
    3193                 :     621461 :        pr != results->end();
    3194                 :     337104 :        ++pr, ++pe, ++i)
    3195                 :            :     {
    3196                 :     337104 :       Named_object* rv = *pr;
    3197                 :     337104 :       Expression* e = *pe;
    3198                 :            : 
    3199                 :            :       // Check types now so that we give a good error message.  The
    3200                 :            :       // result type is known.  We determine the expression type
    3201                 :            :       // early.
    3202                 :            : 
    3203                 :     337104 :       Type *rvtype = rv->result_var_value()->type();
    3204                 :     337104 :       Type_context type_context(rvtype, false);
    3205                 :     337104 :       e->determine_type(&type_context);
    3206                 :            : 
    3207                 :     674208 :       std::string reason;
    3208                 :     337104 :       if (Type::are_assignable(rvtype, e->type(), &reason))
    3209                 :            :         {
    3210                 :     337099 :           Expression* ve = Expression::make_var_reference(rv, e->location());
    3211                 :     337099 :           lhs->push_back(ve);
    3212                 :     337099 :           rhs->push_back(e);
    3213                 :            :         }
    3214                 :            :       else
    3215                 :            :         {
    3216                 :          5 :           if (reason.empty())
    3217                 :          0 :             go_error_at(e->location(),
    3218                 :            :                         "incompatible type for return value %d", i);
    3219                 :            :           else
    3220                 :          5 :             go_error_at(e->location(),
    3221                 :            :                         "incompatible type for return value %d (%s)",
    3222                 :            :                         i, reason.c_str());
    3223                 :            :         }
    3224                 :            :     }
    3225                 :     284357 :   go_assert(lhs->size() == rhs->size());
    3226                 :            : 
    3227                 :     284357 :   if (lhs->empty())
    3228                 :            :     ;
    3229                 :     284354 :   else if (lhs->size() == 1)
    3230                 :            :     {
    3231                 :     238623 :       b->add_statement(Statement::make_assignment(lhs->front(), rhs->front(),
    3232                 :            :                                                   loc));
    3233                 :     238623 :       delete lhs;
    3234                 :     238623 :       delete rhs;
    3235                 :            :     }
    3236                 :            :   else
    3237                 :      45731 :     b->add_statement(Statement::make_tuple_assignment(lhs, rhs, loc));
    3238                 :            : 
    3239                 :     284357 :   b->add_statement(this);
    3240                 :            : 
    3241                 :     284357 :   delete vals;
    3242                 :            : 
    3243                 :     284357 :   return Statement::make_block_statement(b, loc);
    3244                 :            : }
    3245                 :            : 
    3246                 :            : // Convert a return statement to the backend representation.
    3247                 :            : 
    3248                 :            : Bstatement*
    3249                 :     312127 : Return_statement::do_get_backend(Translate_context* context)
    3250                 :            : {
    3251                 :     312127 :   Location loc = this->location();
    3252                 :            : 
    3253                 :     312127 :   Function* function = context->function()->func_value();
    3254                 :     312127 :   Function::Results* results = function->result_variables();
    3255                 :     312127 :   std::vector<Bexpression*> retvals;
    3256                 :     312127 :   if (results != NULL && !results->empty())
    3257                 :            :     {
    3258                 :     302697 :       retvals.reserve(results->size());
    3259                 :     302697 :       for (Function::Results::const_iterator p = results->begin();
    3260                 :     666602 :            p != results->end();
    3261                 :     666602 :            p++)
    3262                 :            :         {
    3263                 :     363905 :           Expression* vr = Expression::make_var_reference(*p, loc);
    3264                 :     363905 :           retvals.push_back(vr->get_backend(context));
    3265                 :            :         }
    3266                 :            :     }
    3267                 :            : 
    3268                 :     312127 :   return context->backend()->return_statement(function->get_decl(),
    3269                 :     312127 :                                               retvals, loc);
    3270                 :            : }
    3271                 :            : 
    3272                 :            : // Export a return statement.  At this point all the expressions have
    3273                 :            : // been converted to assignments to the result variables, so this is
    3274                 :            : // simple.
    3275                 :            : 
    3276                 :            : void
    3277                 :      12652 : Return_statement::do_export_statement(Export_function_body* efb)
    3278                 :            : {
    3279                 :      12652 :   efb->write_c_string("return");
    3280                 :      12652 : }
    3281                 :            : 
    3282                 :            : // Dump the AST representation for a return statement.
    3283                 :            : 
    3284                 :            : void
    3285                 :          0 : Return_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    3286                 :            : {
    3287                 :          0 :   ast_dump_context->print_indent();
    3288                 :          0 :   ast_dump_context->ostream() << "return " ;
    3289                 :          0 :   ast_dump_context->dump_expression_list(this->vals_);
    3290                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    3291                 :          0 : }
    3292                 :            : 
    3293                 :            : // Make a return statement.
    3294                 :            : 
    3295                 :            : Return_statement*
    3296                 :     312612 : Statement::make_return_statement(Expression_list* vals,
    3297                 :            :                                  Location location)
    3298                 :            : {
    3299                 :     312612 :   return new Return_statement(vals, location);
    3300                 :            : }
    3301                 :            : 
    3302                 :            : // Make a statement that returns the result of a call expression.
    3303                 :            : 
    3304                 :            : Statement*
    3305                 :      21636 : Statement::make_return_from_call(Call_expression* call, Location location)
    3306                 :            : {
    3307                 :      21636 :   size_t rc = call->result_count();
    3308                 :      21636 :   if (rc == 0)
    3309                 :       6999 :     return Statement::make_statement(call, true);
    3310                 :            :   else
    3311                 :            :     {
    3312                 :      14637 :       Expression_list* vals = new Expression_list();
    3313                 :      14637 :       if (rc == 1)
    3314                 :      11964 :         vals->push_back(call);
    3315                 :            :       else
    3316                 :            :         {
    3317                 :       8301 :           for (size_t i = 0; i < rc; ++i)
    3318                 :       5628 :             vals->push_back(Expression::make_call_result(call, i));
    3319                 :            :         }
    3320                 :      14637 :       return Statement::make_return_statement(vals, location);
    3321                 :            :     }
    3322                 :            : }
    3323                 :            : 
    3324                 :            : // A break or continue statement.
    3325                 :            : 
    3326                 :            : class Bc_statement : public Statement
    3327                 :            : {
    3328                 :            :  public:
    3329                 :      16539 :   Bc_statement(bool is_break, Unnamed_label* label, Location location)
    3330                 :      16539 :     : Statement(STATEMENT_BREAK_OR_CONTINUE, location),
    3331                 :      33078 :       label_(label), is_break_(is_break)
    3332                 :            :   { }
    3333                 :            : 
    3334                 :            :   bool
    3335                 :            :   is_break() const
    3336                 :            :   { return this->is_break_; }
    3337                 :            : 
    3338                 :            :  protected:
    3339                 :            :   int
    3340                 :     399100 :   do_traverse(Traverse*)
    3341                 :     399100 :   { return TRAVERSE_CONTINUE; }
    3342                 :            : 
    3343                 :            :   bool
    3344                 :          0 :   do_may_fall_through() const
    3345                 :          0 :   { return false; }
    3346                 :            : 
    3347                 :            :   Bstatement*
    3348                 :      16393 :   do_get_backend(Translate_context* context)
    3349                 :      16393 :   { return this->label_->get_goto(context, this->location()); }
    3350                 :            : 
    3351                 :            :   void
    3352                 :            :   do_dump_statement(Ast_dump_context*) const;
    3353                 :            : 
    3354                 :            :  private:
    3355                 :            :   // The label that this branches to.
    3356                 :            :   Unnamed_label* label_;
    3357                 :            :   // True if this is "break", false if it is "continue".
    3358                 :            :   bool is_break_;
    3359                 :            : };
    3360                 :            : 
    3361                 :            : // Dump the AST representation for a break/continue statement
    3362                 :            : 
    3363                 :            : void
    3364                 :          0 : Bc_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    3365                 :            : {
    3366                 :          0 :   ast_dump_context->print_indent();
    3367                 :          0 :   ast_dump_context->ostream() << (this->is_break_ ? "break" : "continue");
    3368                 :          0 :   if (this->label_ != NULL)
    3369                 :            :     {
    3370                 :          0 :       ast_dump_context->ostream() << " ";
    3371                 :          0 :       ast_dump_context->dump_label_name(this->label_);
    3372                 :            :     }
    3373                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    3374                 :          0 : }
    3375                 :            : 
    3376                 :            : // Make a break statement.
    3377                 :            : 
    3378                 :            : Statement*
    3379                 :       7308 : Statement::make_break_statement(Unnamed_label* label, Location location)
    3380                 :            : {
    3381                 :       7308 :   return new Bc_statement(true, label, location);
    3382                 :            : }
    3383                 :            : 
    3384                 :            : // Make a continue statement.
    3385                 :            : 
    3386                 :            : Statement*
    3387                 :       9231 : Statement::make_continue_statement(Unnamed_label* label,
    3388                 :            :                                    Location location)
    3389                 :            : {
    3390                 :       9231 :   return new Bc_statement(false, label, location);
    3391                 :            : }
    3392                 :            : 
    3393                 :            : // Class Goto_statement.
    3394                 :            : 
    3395                 :            : int
    3396                 :     104235 : Goto_statement::do_traverse(Traverse*)
    3397                 :            : {
    3398                 :     104235 :   return TRAVERSE_CONTINUE;
    3399                 :            : }
    3400                 :            : 
    3401                 :            : // Check types for a label.  There aren't any types per se, but we use
    3402                 :            : // this to give an error if the label was never defined.
    3403                 :            : 
    3404                 :            : void
    3405                 :       2059 : Goto_statement::do_check_types(Gogo*)
    3406                 :            : {
    3407                 :       2059 :   if (!this->label_->is_defined())
    3408                 :            :     {
    3409                 :          1 :       go_error_at(this->location(), "reference to undefined label %qs",
    3410                 :          1 :                   Gogo::message_name(this->label_->name()).c_str());
    3411                 :          1 :       this->set_is_error();
    3412                 :            :     }
    3413                 :       2059 : }
    3414                 :            : 
    3415                 :            : // Convert the goto statement to the backend representation.
    3416                 :            : 
    3417                 :            : Bstatement*
    3418                 :       8233 : Goto_statement::do_get_backend(Translate_context* context)
    3419                 :            : {
    3420                 :       8233 :   Blabel* blabel = this->label_->get_backend_label(context);
    3421                 :       8233 :   return context->backend()->goto_statement(blabel, this->location());
    3422                 :            : }
    3423                 :            : 
    3424                 :            : // Export a goto statement.
    3425                 :            : 
    3426                 :            : void
    3427                 :          1 : Goto_statement::do_export_statement(Export_function_body *efb)
    3428                 :            : {
    3429                 :          1 :   efb->write_c_string("goto ");
    3430                 :          1 :   efb->write_string(this->label_->name());
    3431                 :          1 : }
    3432                 :            : 
    3433                 :            : // Import a goto or goto unnamed statement.
    3434                 :            : 
    3435                 :            : Statement*
    3436                 :       1163 : Goto_statement::do_import(Import_function_body* ifb, Location loc)
    3437                 :            : {
    3438                 :       1163 :   ifb->require_c_string("goto ");
    3439                 :       1163 :   std::string id = ifb->read_identifier();
    3440                 :       1163 :   if (id[0] != '$')
    3441                 :            :     {
    3442                 :          0 :       Function* fn = ifb->function()->func_value();
    3443                 :          0 :       Label* label = fn->add_label_reference(ifb->gogo(), id, loc, false);
    3444                 :          0 :       return Statement::make_goto_statement(label, loc);
    3445                 :            :     }
    3446                 :            :   else
    3447                 :            :     {
    3448                 :       1163 :       if (id[1] != 'l')
    3449                 :            :         {
    3450                 :          0 :           if (!ifb->saw_error())
    3451                 :          0 :             go_error_at(loc,
    3452                 :            :                         ("invalid export data for %qs: "
    3453                 :            :                          "bad unnamed label at %lu"),
    3454                 :          0 :                         ifb->name().c_str(),
    3455                 :          0 :                         static_cast<unsigned long>(ifb->off()));
    3456                 :          0 :           ifb->set_saw_error();
    3457                 :          0 :           return Statement::make_error_statement(loc);
    3458                 :            :         }
    3459                 :       1163 :       const char* p = id.c_str();
    3460                 :       1163 :       char* end;
    3461                 :       1163 :       long idx = strtol(p + 2, &end, 10);
    3462                 :       1163 :       if (*end != '\0' || idx > 0x7fffffff)
    3463                 :            :         {
    3464                 :          0 :           if (!ifb->saw_error())
    3465                 :          0 :             go_error_at(loc,
    3466                 :            :                         ("invalid export data for %qs: "
    3467                 :            :                          "bad unnamed label index at %lu"),
    3468                 :          0 :                         ifb->name().c_str(),
    3469                 :          0 :                         static_cast<unsigned long>(ifb->off()));
    3470                 :          0 :           ifb->set_saw_error();
    3471                 :          0 :           return Statement::make_error_statement(loc);
    3472                 :            :         }
    3473                 :            : 
    3474                 :       1163 :       Unnamed_label* label = ifb->unnamed_label(idx, loc);
    3475                 :       1163 :       return Statement::make_goto_unnamed_statement(label, loc);
    3476                 :            :     }
    3477                 :            : }
    3478                 :            : 
    3479                 :            : // Dump the AST representation for a goto statement.
    3480                 :            : 
    3481                 :            : void
    3482                 :          0 : Goto_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    3483                 :            : {
    3484                 :          0 :   ast_dump_context->print_indent();
    3485                 :          0 :   ast_dump_context->ostream() << "goto " << this->label_->name() << dsuffix(location()) << std::endl;
    3486                 :          0 : }
    3487                 :            : 
    3488                 :            : // Make a goto statement.
    3489                 :            : 
    3490                 :            : Statement*
    3491                 :       8321 : Statement::make_goto_statement(Label* label, Location location)
    3492                 :            : {
    3493                 :       8321 :   return new Goto_statement(label, location);
    3494                 :            : }
    3495                 :            : 
    3496                 :            : // Class Goto_unnamed_statement.
    3497                 :            : 
    3498                 :            : int
    3499                 :    3171164 : Goto_unnamed_statement::do_traverse(Traverse*)
    3500                 :            : {
    3501                 :    3171164 :   return TRAVERSE_CONTINUE;
    3502                 :            : }
    3503                 :            : 
    3504                 :            : // Convert the goto unnamed statement to the backend representation.
    3505                 :            : 
    3506                 :            : Bstatement*
    3507                 :     149810 : Goto_unnamed_statement::do_get_backend(Translate_context* context)
    3508                 :            : {
    3509                 :     149810 :   return this->label_->get_goto(context, this->location());
    3510                 :            : }
    3511                 :            : 
    3512                 :            : // Export a goto unnamed statement.
    3513                 :            : 
    3514                 :            : void
    3515                 :       1410 : Goto_unnamed_statement::do_export_statement(Export_function_body *efb)
    3516                 :            : {
    3517                 :       1410 :   unsigned int index = efb->unnamed_label_index(this->label_);
    3518                 :       1410 :   char buf[100];
    3519                 :       1410 :   snprintf(buf, sizeof buf, "goto $l%u", index);
    3520                 :       1410 :   efb->write_c_string(buf);
    3521                 :       1410 : }
    3522                 :            : 
    3523                 :            : // Dump the AST representation for an unnamed goto statement
    3524                 :            : 
    3525                 :            : void
    3526                 :          0 : Goto_unnamed_statement::do_dump_statement(
    3527                 :            :     Ast_dump_context* ast_dump_context) const
    3528                 :            : {
    3529                 :          0 :   ast_dump_context->print_indent();
    3530                 :          0 :   ast_dump_context->ostream() << "goto ";
    3531                 :          0 :   ast_dump_context->dump_label_name(this->label_);
    3532                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    3533                 :          0 : }
    3534                 :            : 
    3535                 :            : // Make a goto statement to an unnamed label.
    3536                 :            : 
    3537                 :            : Statement*
    3538                 :     150443 : Statement::make_goto_unnamed_statement(Unnamed_label* label,
    3539                 :            :                                        Location location)
    3540                 :            : {
    3541                 :     150443 :   return new Goto_unnamed_statement(label, location);
    3542                 :            : }
    3543                 :            : 
    3544                 :            : // Class Label_statement.
    3545                 :            : 
    3546                 :            : // Traversal.
    3547                 :            : 
    3548                 :            : int
    3549                 :      93652 : Label_statement::do_traverse(Traverse*)
    3550                 :            : {
    3551                 :      93652 :   return TRAVERSE_CONTINUE;
    3552                 :            : }
    3553                 :            : 
    3554                 :            : // Return the backend representation of the statement defining this
    3555                 :            : // label.
    3556                 :            : 
    3557                 :            : Bstatement*
    3558                 :       7769 : Label_statement::do_get_backend(Translate_context* context)
    3559                 :            : {
    3560                 :       7769 :   if (this->label_->is_dummy_label())
    3561                 :            :     {
    3562                 :          0 :       Bexpression* bce = context->backend()->boolean_constant_expression(false);
    3563                 :          0 :       Bfunction* bfunction = context->function()->func_value()->get_decl();
    3564                 :          0 :       return context->backend()->expression_statement(bfunction, bce);
    3565                 :            :     }
    3566                 :       7769 :   Blabel* blabel = this->label_->get_backend_label(context);
    3567                 :       7769 :   return context->backend()->label_definition_statement(blabel);
    3568                 :            : }
    3569                 :            : 
    3570                 :            : // Export a label.
    3571                 :            : 
    3572                 :            : void
    3573                 :          1 : Label_statement::do_export_statement(Export_function_body* efb)
    3574                 :            : {
    3575                 :          1 :   if (this->label_->is_dummy_label())
    3576                 :            :     return;
    3577                 :            :   // We use a leading colon, not a trailing one, to simplify import.
    3578                 :          1 :   efb->write_c_string(":");
    3579                 :          1 :   efb->write_string(this->label_->name());
    3580                 :            : }
    3581                 :            : 
    3582                 :            : // Import a label or an unnamed label.
    3583                 :            : 
    3584                 :            : Statement*
    3585                 :       1108 : Label_statement::do_import(Import_function_body* ifb, Location loc)
    3586                 :            : {
    3587                 :       1108 :   ifb->require_c_string(":");
    3588                 :       1108 :   std::string id = ifb->read_identifier();
    3589                 :       1108 :   if (id[0] != '$')
    3590                 :            :     {
    3591                 :          0 :       Function* fn = ifb->function()->func_value();
    3592                 :          0 :       Label* label = fn->add_label_definition(ifb->gogo(), id, loc);
    3593                 :          0 :       return Statement::make_label_statement(label, loc);
    3594                 :            :     }
    3595                 :            :   else
    3596                 :            :     {
    3597                 :       1108 :       if (id[1] != 'l')
    3598                 :            :         {
    3599                 :          0 :           if (!ifb->saw_error())
    3600                 :          0 :             go_error_at(loc,
    3601                 :            :                         ("invalid export data for %qs: "
    3602                 :            :                          "bad unnamed label at %lu"),
    3603                 :          0 :                         ifb->name().c_str(),
    3604                 :          0 :                         static_cast<unsigned long>(ifb->off()));
    3605                 :          0 :           ifb->set_saw_error();
    3606                 :          0 :           return Statement::make_error_statement(loc);
    3607                 :            :         }
    3608                 :       1108 :       const char* p = id.c_str();
    3609                 :       1108 :       char* end;
    3610                 :       1108 :       long idx = strtol(p + 2, &end, 10);
    3611                 :       1108 :       if (*end != '\0' || idx > 0x7fffffff)
    3612                 :            :         {
    3613                 :          0 :           if (!ifb->saw_error())
    3614                 :          0 :             go_error_at(loc,
    3615                 :            :                         ("invalid export data for %qs: "
    3616                 :            :                          "bad unnamed label index at %lu"),
    3617                 :          0 :                         ifb->name().c_str(),
    3618                 :          0 :                         static_cast<unsigned long>(ifb->off()));
    3619                 :          0 :           ifb->set_saw_error();
    3620                 :          0 :           return Statement::make_error_statement(loc);
    3621                 :            :         }
    3622                 :            : 
    3623                 :       1108 :       Unnamed_label* label = ifb->unnamed_label(idx, loc);
    3624                 :       1108 :       return Statement::make_unnamed_label_statement(label);
    3625                 :            :     }
    3626                 :            : }
    3627                 :            : 
    3628                 :            : // Dump the AST for a label definition statement.
    3629                 :            : 
    3630                 :            : void
    3631                 :          0 : Label_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    3632                 :            : {
    3633                 :          0 :   ast_dump_context->print_indent();
    3634                 :          0 :   ast_dump_context->ostream() << this->label_->name() << ":" << dsuffix(location()) << std::endl;
    3635                 :          0 : }
    3636                 :            : 
    3637                 :            : // Make a label statement.
    3638                 :            : 
    3639                 :            : Statement*
    3640                 :       7871 : Statement::make_label_statement(Label* label, Location location)
    3641                 :            : {
    3642                 :       7871 :   return new Label_statement(label, location);
    3643                 :            : }
    3644                 :            : 
    3645                 :            : // Class Unnamed_label_statement.
    3646                 :            : 
    3647                 :     143821 : Unnamed_label_statement::Unnamed_label_statement(Unnamed_label* label)
    3648                 :            :   : Statement(STATEMENT_UNNAMED_LABEL, label->location()),
    3649                 :     143821 :     label_(label)
    3650                 :     143821 : { }
    3651                 :            : 
    3652                 :            : int
    3653                 :    3010132 : Unnamed_label_statement::do_traverse(Traverse*)
    3654                 :            : {
    3655                 :    3010132 :   return TRAVERSE_CONTINUE;
    3656                 :            : }
    3657                 :            : 
    3658                 :            : // Get the backend definition for this unnamed label statement.
    3659                 :            : 
    3660                 :            : Bstatement*
    3661                 :     143165 : Unnamed_label_statement::do_get_backend(Translate_context* context)
    3662                 :            : {
    3663                 :     143165 :   return this->label_->get_definition(context);
    3664                 :            : }
    3665                 :            : 
    3666                 :            : // Export an unnamed label.
    3667                 :            : 
    3668                 :            : void
    3669                 :       1369 : Unnamed_label_statement::do_export_statement(Export_function_body* efb)
    3670                 :            : {
    3671                 :       1369 :   unsigned int index = efb->unnamed_label_index(this->label_);
    3672                 :       1369 :   char buf[50];
    3673                 :            :   // We use a leading colon, not a trailing one, to simplify import.
    3674                 :       1369 :   snprintf(buf, sizeof buf, ":$l%u", index);
    3675                 :       1369 :   efb->write_c_string(buf);
    3676                 :       1369 : }
    3677                 :            : 
    3678                 :            : // Dump the AST representation for an unnamed label definition statement.
    3679                 :            : 
    3680                 :            : void
    3681                 :          0 : Unnamed_label_statement::do_dump_statement(Ast_dump_context* ast_dump_context)
    3682                 :            :     const
    3683                 :            : {
    3684                 :          0 :   ast_dump_context->print_indent();
    3685                 :          0 :   ast_dump_context->dump_label_name(this->label_);
    3686                 :          0 :   ast_dump_context->ostream() << ":" << dsuffix(location()) << std::endl;
    3687                 :          0 : }
    3688                 :            : 
    3689                 :            : // Make an unnamed label statement.
    3690                 :            : 
    3691                 :            : Statement*
    3692                 :     143821 : Statement::make_unnamed_label_statement(Unnamed_label* label)
    3693                 :            : {
    3694                 :     143821 :   return new Unnamed_label_statement(label);
    3695                 :            : }
    3696                 :            : 
    3697                 :            : // Class If_statement.
    3698                 :            : 
    3699                 :            : // Traversal.
    3700                 :            : 
    3701                 :            : int
    3702                 :    8240657 : If_statement::do_traverse(Traverse* traverse)
    3703                 :            : {
    3704                 :    8240657 :   if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT
    3705                 :    8240657 :       || this->then_block_->traverse(traverse) == TRAVERSE_EXIT)
    3706                 :     282545 :     return TRAVERSE_EXIT;
    3707                 :    7958112 :   if (this->else_block_ != NULL)
    3708                 :            :     {
    3709                 :     582224 :       if (this->else_block_->traverse(traverse) == TRAVERSE_EXIT)
    3710                 :       1804 :         return TRAVERSE_EXIT;
    3711                 :            :     }
    3712                 :            :   return TRAVERSE_CONTINUE;
    3713                 :            : }
    3714                 :            : 
    3715                 :            : void
    3716                 :     291247 : If_statement::do_determine_types()
    3717                 :            : {
    3718                 :     291247 :   Type_context context(Type::lookup_bool_type(), false);
    3719                 :     291247 :   this->cond_->determine_type(&context);
    3720                 :     291247 :   this->then_block_->determine_types();
    3721                 :     291247 :   if (this->else_block_ != NULL)
    3722                 :      18076 :     this->else_block_->determine_types();
    3723                 :     291247 : }
    3724                 :            : 
    3725                 :            : // Check types.
    3726                 :            : 
    3727                 :            : void
    3728                 :     284985 : If_statement::do_check_types(Gogo*)
    3729                 :            : {
    3730                 :     284985 :   Type* type = this->cond_->type();
    3731                 :     284985 :   if (type->is_error())
    3732                 :          6 :     this->set_is_error();
    3733                 :     284979 :   else if (!type->is_boolean_type())
    3734                 :          4 :     this->report_error(_("expected boolean expression"));
    3735                 :     284985 : }
    3736                 :            : 
    3737                 :            : // Whether the overall statement may fall through.
    3738                 :            : 
    3739                 :            : bool
    3740                 :        309 : If_statement::do_may_fall_through() const
    3741                 :            : {
    3742                 :        309 :   return (this->else_block_ == NULL
    3743                 :        296 :           || this->then_block_->may_fall_through()
    3744                 :        605 :           || this->else_block_->may_fall_through());
    3745                 :            : }
    3746                 :            : 
    3747                 :            : // Get the backend representation.
    3748                 :            : 
    3749                 :            : Bstatement*
    3750                 :     591613 : If_statement::do_get_backend(Translate_context* context)
    3751                 :            : {
    3752                 :     591613 :   go_assert(this->cond_->type()->is_boolean_type()
    3753                 :            :              || this->cond_->type()->is_error());
    3754                 :     591613 :   Bexpression* cond = this->cond_->get_backend(context);
    3755                 :     591613 :   Bblock* then_block = this->then_block_->get_backend(context);
    3756                 :     591613 :   Bblock* else_block = (this->else_block_ == NULL
    3757                 :     591613 :                         ? NULL
    3758                 :     203338 :                         : this->else_block_->get_backend(context));
    3759                 :     591613 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
    3760                 :     591613 :   return context->backend()->if_statement(bfunction,
    3761                 :            :                                           cond, then_block, else_block,
    3762                 :     591613 :                                           this->location());
    3763                 :            : }
    3764                 :            : 
    3765                 :            : // Export an if statement.
    3766                 :            : 
    3767                 :            : void
    3768                 :       4030 : If_statement::do_export_statement(Export_function_body* efb)
    3769                 :            : {
    3770                 :       4030 :   efb->write_c_string("if ");
    3771                 :       4030 :   this->cond_->export_expression(efb);
    3772                 :       4030 :   efb->write_c_string(" ");
    3773                 :       4030 :   Block_statement::export_block(efb, this->then_block_, false);
    3774                 :       4030 :   if (this->else_block_ != NULL)
    3775                 :            :     {
    3776                 :         69 :       efb->write_c_string(" else ");
    3777                 :         69 :       Block_statement::export_block(efb, this->else_block_, false);
    3778                 :            :     }
    3779                 :       4030 : }
    3780                 :            : 
    3781                 :            : // Import an if statement.
    3782                 :            : 
    3783                 :            : Statement*
    3784                 :       3999 : If_statement::do_import(Import_function_body* ifb, Location loc)
    3785                 :            : {
    3786                 :       3999 :   ifb->require_c_string("if ");
    3787                 :            : 
    3788                 :       3999 :   Expression* cond = Expression::import_expression(ifb, loc);
    3789                 :       3999 :   ifb->require_c_string(" ");
    3790                 :            : 
    3791                 :       3999 :   if (!ifb->match_c_string("{"))
    3792                 :            :     {
    3793                 :          0 :       if (!ifb->saw_error())
    3794                 :          0 :         go_error_at(ifb->location(),
    3795                 :            :                     "import error for %qs: no block for if statement at %lu",
    3796                 :          0 :                     ifb->name().c_str(),
    3797                 :          0 :                     static_cast<unsigned long>(ifb->off()));
    3798                 :          0 :       ifb->set_saw_error();
    3799                 :          0 :       return Statement::make_error_statement(loc);
    3800                 :            :     }
    3801                 :            : 
    3802                 :       3999 :   bool is_lowered_for_statement;
    3803                 :       3999 :   Block* then_block = Block_statement::do_import(ifb, loc,
    3804                 :            :                                                  &is_lowered_for_statement);
    3805                 :       3999 :   if (then_block == NULL)
    3806                 :          0 :     return Statement::make_error_statement(loc);
    3807                 :       3999 :   if (is_lowered_for_statement)
    3808                 :            :     {
    3809                 :          0 :       if (!ifb->saw_error())
    3810                 :          0 :         go_error_at(ifb->location(),
    3811                 :            :                     ("import error for %qs: "
    3812                 :            :                      "unexpected lowered for in if statement at %lu"),
    3813                 :          0 :                     ifb->name().c_str(),
    3814                 :          0 :                     static_cast<unsigned long>(ifb->off()));
    3815                 :          0 :       ifb->set_saw_error();
    3816                 :          0 :       return Statement::make_error_statement(loc);
    3817                 :            :     }
    3818                 :            : 
    3819                 :       3999 :   Block* else_block = NULL;
    3820                 :       3999 :   if (ifb->match_c_string(" else "))
    3821                 :            :     {
    3822                 :        123 :       ifb->advance(6);
    3823                 :        123 :       if (!ifb->match_c_string("{"))
    3824                 :            :         {
    3825                 :          0 :           if (!ifb->saw_error())
    3826                 :          0 :             go_error_at(ifb->location(),
    3827                 :            :                         ("import error for %qs: no else block "
    3828                 :            :                          "for if statement at %lu"),
    3829                 :          0 :                         ifb->name().c_str(),
    3830                 :          0 :                         static_cast<unsigned long>(ifb->off()));
    3831                 :          0 :           ifb->set_saw_error();
    3832                 :          0 :           return Statement::make_error_statement(loc);
    3833                 :            :         }
    3834                 :            : 
    3835                 :        123 :       else_block = Block_statement::do_import(ifb, loc,
    3836                 :            :                                               &is_lowered_for_statement);
    3837                 :        123 :       if (else_block == NULL)
    3838                 :          0 :         return Statement::make_error_statement(loc);
    3839                 :        123 :       if (is_lowered_for_statement)
    3840                 :            :         {
    3841                 :          0 :           if (!ifb->saw_error())
    3842                 :          0 :             go_error_at(ifb->location(),
    3843                 :            :                         ("import error for %qs: "
    3844                 :            :                          "unexpected lowered for in if statement at %lu"),
    3845                 :          0 :                         ifb->name().c_str(),
    3846                 :          0 :                         static_cast<unsigned long>(ifb->off()));
    3847                 :          0 :           ifb->set_saw_error();
    3848                 :          0 :           return Statement::make_error_statement(loc);
    3849                 :            :         }
    3850                 :            :     }
    3851                 :            : 
    3852                 :       3999 :   return Statement::make_if_statement(cond, then_block, else_block, loc);
    3853                 :            : }
    3854                 :            : 
    3855                 :            : // Dump the AST representation for an if statement
    3856                 :            : 
    3857                 :            : void
    3858                 :          0 : If_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    3859                 :            : {
    3860                 :          0 :   ast_dump_context->print_indent();
    3861                 :          0 :   ast_dump_context->ostream() << "if ";
    3862                 :          0 :   ast_dump_context->dump_expression(this->cond_);
    3863                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    3864                 :          0 :   if (ast_dump_context->dump_subblocks())
    3865                 :            :     {
    3866                 :          0 :       ast_dump_context->dump_block(this->then_block_);
    3867                 :          0 :       if (this->else_block_ != NULL)
    3868                 :            :         {
    3869                 :          0 :           ast_dump_context->print_indent();
    3870                 :          0 :           ast_dump_context->ostream() << "else" << std::endl;
    3871                 :          0 :           ast_dump_context->dump_block(this->else_block_);
    3872                 :            :         }
    3873                 :            :     }
    3874                 :          0 : }
    3875                 :            : 
    3876                 :            : // Make an if statement.
    3877                 :            : 
    3878                 :            : Statement*
    3879                 :     596015 : Statement::make_if_statement(Expression* cond, Block* then_block,
    3880                 :            :                              Block* else_block, Location location)
    3881                 :            : {
    3882                 :     596015 :   return new If_statement(cond, then_block, else_block, location);
    3883                 :            : }
    3884                 :            : 
    3885                 :            : // Class Case_clauses::Hash_integer_value.
    3886                 :            : 
    3887                 :            : class Case_clauses::Hash_integer_value
    3888                 :            : {
    3889                 :            :  public:
    3890                 :            :   size_t
    3891                 :            :   operator()(Expression*) const;
    3892                 :            : };
    3893                 :            : 
    3894                 :            : size_t
    3895                 :      31352 : Case_clauses::Hash_integer_value::operator()(Expression* pe) const
    3896                 :            : {
    3897                 :      31352 :   Numeric_constant nc;
    3898                 :      31352 :   mpz_t ival;
    3899                 :      31352 :   if (!pe->numeric_constant_value(&nc) || !nc.to_int(&ival))
    3900                 :          0 :     go_unreachable();
    3901                 :      31352 :   size_t ret = mpz_get_ui(ival);
    3902                 :      31352 :   mpz_clear(ival);
    3903                 :      31352 :   return ret;
    3904                 :            : }
    3905                 :            : 
    3906                 :            : // Class Case_clauses::Eq_integer_value.
    3907                 :            : 
    3908                 :            : class Case_clauses::Eq_integer_value
    3909                 :            : {
    3910                 :            :  public:
    3911                 :            :   bool
    3912                 :            :   operator()(Expression*, Expression*) const;
    3913                 :            : };
    3914                 :            : 
    3915                 :            : bool
    3916                 :         42 : Case_clauses::Eq_integer_value::operator()(Expression* a, Expression* b) const
    3917                 :            : {
    3918                 :         84 :   Numeric_constant anc;
    3919                 :         42 :   mpz_t aval;
    3920                 :         84 :   Numeric_constant bnc;
    3921                 :         42 :   mpz_t bval;
    3922                 :         42 :   if (!a->numeric_constant_value(&anc)
    3923                 :         42 :       || !anc.to_int(&aval)
    3924                 :         42 :       || !b->numeric_constant_value(&bnc)
    3925                 :         84 :       || !bnc.to_int(&bval))
    3926                 :          0 :     go_unreachable();
    3927                 :         42 :   bool ret = mpz_cmp(aval, bval) == 0;
    3928                 :         42 :   mpz_clear(aval);
    3929                 :         42 :   mpz_clear(bval);
    3930                 :         42 :   return ret;
    3931                 :            : }
    3932                 :            : 
    3933                 :            : // Class Case_clauses::Case_clause.
    3934                 :            : 
    3935                 :            : // Traversal.
    3936                 :            : 
    3937                 :            : int
    3938                 :     556603 : Case_clauses::Case_clause::traverse(Traverse* traverse)
    3939                 :            : {
    3940                 :     556603 :   if (this->cases_ != NULL
    3941                 :     556603 :       && (traverse->traverse_mask()
    3942                 :     490906 :           & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
    3943                 :            :     {
    3944                 :     373734 :       if (this->cases_->traverse(traverse) == TRAVERSE_EXIT)
    3945                 :            :         return TRAVERSE_EXIT;
    3946                 :            :     }
    3947                 :     556603 :   if (this->statements_ != NULL)
    3948                 :            :     {
    3949                 :     543424 :       if (this->statements_->traverse(traverse) == TRAVERSE_EXIT)
    3950                 :          0 :         return TRAVERSE_EXIT;
    3951                 :            :     }
    3952                 :            :   return TRAVERSE_CONTINUE;
    3953                 :            : }
    3954                 :            : 
    3955                 :            : // Check whether all the case expressions are integer constants.
    3956                 :            : 
    3957                 :            : bool
    3958                 :      22153 : Case_clauses::Case_clause::is_constant() const
    3959                 :            : {
    3960                 :      22153 :   if (this->cases_ != NULL)
    3961                 :            :     {
    3962                 :      19593 :       for (Expression_list::const_iterator p = this->cases_->begin();
    3963                 :      51054 :            p != this->cases_->end();
    3964                 :      51054 :            ++p)
    3965                 :      62978 :         if (!(*p)->is_constant() || (*p)->type()->integer_type() == NULL)
    3966                 :         56 :           return false;
    3967                 :            :     }
    3968                 :            :   return true;
    3969                 :            : }
    3970                 :            : 
    3971                 :            : // Lower a case clause for a nonconstant switch.  VAL_TEMP is the
    3972                 :            : // value we are switching on; it may be NULL.  If START_LABEL is not
    3973                 :            : // NULL, it goes at the start of the statements, after the condition
    3974                 :            : // test.  We branch to FINISH_LABEL at the end of the statements.
    3975                 :            : 
    3976                 :            : void
    3977                 :      14189 : Case_clauses::Case_clause::lower(Block* b, Temporary_statement* val_temp,
    3978                 :            :                                  Unnamed_label* start_label,
    3979                 :            :                                  Unnamed_label* finish_label) const
    3980                 :            : {
    3981                 :      14189 :   Location loc = this->location_;
    3982                 :      14189 :   Unnamed_label* next_case_label;
    3983                 :      14189 :   if (this->cases_ == NULL || this->cases_->empty())
    3984                 :            :     {
    3985                 :       2241 :       go_assert(this->is_default_);
    3986                 :            :       next_case_label = NULL;
    3987                 :            :     }
    3988                 :            :   else
    3989                 :            :     {
    3990                 :            :       Expression* cond = NULL;
    3991                 :            : 
    3992                 :      27298 :       for (Expression_list::const_iterator p = this->cases_->begin();
    3993                 :      27298 :            p != this->cases_->end();
    3994                 :      27298 :            ++p)
    3995                 :            :         {
    3996                 :      15350 :           Expression* ref = Expression::make_temporary_reference(val_temp,
    3997                 :            :                                                                  loc);
    3998                 :      15350 :           Expression* this_cond = Expression::make_binary(OPERATOR_EQEQ, ref,
    3999                 :      15350 :                                                           *p, loc);
    4000                 :      15350 :           if (cond == NULL)
    4001                 :            :             cond = this_cond;
    4002                 :            :           else
    4003                 :       3402 :             cond = Expression::make_binary(OPERATOR_OROR, cond, this_cond, loc);
    4004                 :            :         }
    4005                 :            : 
    4006                 :      11948 :       Block* then_block = new Block(b, loc);
    4007                 :      11948 :       next_case_label = new Unnamed_label(Linemap::unknown_location());
    4008                 :      11948 :       Statement* s = Statement::make_goto_unnamed_statement(next_case_label,
    4009                 :            :                                                             loc);
    4010                 :      11948 :       then_block->add_statement(s);
    4011                 :            : 
    4012                 :            :       // if !COND { goto NEXT_CASE_LABEL }
    4013                 :      11948 :       cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
    4014                 :      11948 :       s = Statement::make_if_statement(cond, then_block, NULL, loc);
    4015                 :      11948 :       b->add_statement(s);
    4016                 :            :     }
    4017                 :            : 
    4018                 :      14189 :   if (start_label != NULL)
    4019                 :         97 :     b->add_statement(Statement::make_unnamed_label_statement(start_label));
    4020                 :            : 
    4021                 :      14189 :   if (this->statements_ != NULL)
    4022                 :      13550 :     b->add_statement(Statement::make_block_statement(this->statements_, loc));
    4023                 :            : 
    4024                 :      14189 :   Statement* s = Statement::make_goto_unnamed_statement(finish_label, loc);
    4025                 :      14189 :   b->add_statement(s);
    4026                 :            : 
    4027                 :      14189 :   if (next_case_label != NULL)
    4028                 :      11948 :     b->add_statement(Statement::make_unnamed_label_statement(next_case_label));
    4029                 :      14189 : }
    4030                 :            : 
    4031                 :            : // Determine types.
    4032                 :            : 
    4033                 :            : void
    4034                 :      22096 : Case_clauses::Case_clause::determine_types(Type* type)
    4035                 :            : {
    4036                 :      22096 :   if (this->cases_ != NULL)
    4037                 :            :     {
    4038                 :      19536 :       Type_context case_context(type, false);
    4039                 :      50898 :       for (Expression_list::iterator p = this->cases_->begin();
    4040                 :      50898 :            p != this->cases_->end();
    4041                 :      50898 :            ++p)
    4042                 :      31362 :         (*p)->determine_type(&case_context);
    4043                 :            :     }
    4044                 :      22096 :   if (this->statements_ != NULL)
    4045                 :      21594 :     this->statements_->determine_types();
    4046                 :      22096 : }
    4047                 :            : 
    4048                 :            : // Check types.  Returns false if there was an error.
    4049                 :            : 
    4050                 :            : bool
    4051                 :      22096 : Case_clauses::Case_clause::check_types(Type* type)
    4052                 :            : {
    4053                 :      22096 :   if (this->cases_ != NULL)
    4054                 :            :     {
    4055                 :      50898 :       for (Expression_list::iterator p = this->cases_->begin();
    4056                 :      50898 :            p != this->cases_->end();
    4057                 :      50898 :            ++p)
    4058                 :            :         {
    4059                 :      31362 :           if (!Type::are_assignable(type, (*p)->type(), NULL)
    4060                 :      31362 :               && !Type::are_assignable((*p)->type(), type, NULL))
    4061                 :            :             {
    4062                 :          0 :               go_error_at((*p)->location(),
    4063                 :            :                           "type mismatch between switch value and case clause");
    4064                 :          0 :               return false;
    4065                 :            :             }
    4066                 :            :         }
    4067                 :            :     }
    4068                 :            :   return true;
    4069                 :            : }
    4070                 :            : 
    4071                 :            : // Return true if this clause may fall through to the following
    4072                 :            : // statements.  Note that this is not the same as whether the case
    4073                 :            : // uses the "fallthrough" keyword.
    4074                 :            : 
    4075                 :            : bool
    4076                 :       3477 : Case_clauses::Case_clause::may_fall_through() const
    4077                 :            : {
    4078                 :       3477 :   if (this->statements_ == NULL)
    4079                 :            :     return true;
    4080                 :       3468 :   return this->statements_->may_fall_through();
    4081                 :            : }
    4082                 :            : 
    4083                 :            : // Convert the case values and statements to the backend
    4084                 :            : // representation.  BREAK_LABEL is the label which break statements
    4085                 :            : // should branch to.  CASE_CONSTANTS is used to detect duplicate
    4086                 :            : // constants.  *CASES should be passed as an empty vector; the values
    4087                 :            : // for this case will be added to it.  If this is the default case,
    4088                 :            : // *CASES will remain empty.  This returns the statement to execute if
    4089                 :            : // one of these cases is selected.
    4090                 :            : 
    4091                 :            : Bstatement*
    4092                 :      22078 : Case_clauses::Case_clause::get_backend(Translate_context* context,
    4093                 :            :                                        Unnamed_label* break_label,
    4094                 :            :                                        Case_constants* case_constants,
    4095                 :            :                                        std::vector<Bexpression*>* cases) const
    4096                 :            : {
    4097                 :      22078 :   if (this->cases_ != NULL)
    4098                 :            :     {
    4099                 :      19526 :       go_assert(!this->is_default_);
    4100                 :      50878 :       for (Expression_list::const_iterator p = this->cases_->begin();
    4101                 :      50878 :            p != this->cases_->end();
    4102                 :      50878 :            ++p)
    4103                 :            :         {
    4104                 :      31352 :           Expression* e = *p;
    4105                 :      31352 :           if (e->classification() != Expression::EXPRESSION_INTEGER)
    4106                 :            :             {
    4107                 :      45454 :               Numeric_constant nc;
    4108                 :      22727 :               mpz_t ival;
    4109                 :      22727 :               if (!(*p)->numeric_constant_value(&nc) || !nc.to_int(&ival))
    4110                 :            :                 {
    4111                 :            :                   // Something went wrong.  This can happen with a
    4112                 :            :                   // negative constant and an unsigned switch value.
    4113                 :          0 :                   go_assert(saw_errors());
    4114                 :          0 :                   continue;
    4115                 :            :                 }
    4116                 :      22727 :               go_assert(nc.type() != NULL);
    4117                 :      22727 :               e = Expression::make_integer_z(&ival, nc.type(), e->location());
    4118                 :      22727 :               mpz_clear(ival);
    4119                 :            :             }
    4120                 :            : 
    4121                 :      31352 :           std::pair<Case_constants::iterator, bool> ins =
    4122                 :      31352 :             case_constants->insert(e);
    4123                 :      31352 :           if (!ins.second)
    4124                 :            :             {
    4125                 :            :               // Value was already present.
    4126                 :          0 :               go_error_at(this->location_, "duplicate case in switch");
    4127                 :          0 :               e = Expression::make_error(this->location_);
    4128                 :            :             }
    4129                 :      31352 :           cases->push_back(e->get_backend(context));
    4130                 :            :         }
    4131                 :            :     }
    4132                 :            : 
    4133                 :      22078 :   Bstatement* statements;
    4134                 :      22078 :   if (this->statements_ == NULL)
    4135                 :            :     statements = NULL;
    4136                 :            :   else
    4137                 :            :     {
    4138                 :      21582 :       Bblock* bblock = this->statements_->get_backend(context);
    4139                 :      21582 :       statements = context->backend()->block_statement(bblock);
    4140                 :            :     }
    4141                 :            : 
    4142                 :      22078 :   Bstatement* break_stat;
    4143                 :      22078 :   if (this->is_fallthrough_)
    4144                 :            :     break_stat = NULL;
    4145                 :            :   else
    4146                 :      21756 :     break_stat = break_label->get_goto(context, this->location_);
    4147                 :            : 
    4148                 :      22078 :   if (statements == NULL)
    4149                 :            :     return break_stat;
    4150                 :      21582 :   else if (break_stat == NULL)
    4151                 :            :     return statements;
    4152                 :            :   else
    4153                 :      21276 :     return context->backend()->compound_statement(statements, break_stat);
    4154                 :            : }
    4155                 :            : 
    4156                 :            : // Dump the AST representation for a case clause
    4157                 :            : 
    4158                 :            : void
    4159                 :          0 : Case_clauses::Case_clause::dump_clause(Ast_dump_context* ast_dump_context)
    4160                 :            :     const
    4161                 :            : {
    4162                 :          0 :   ast_dump_context->print_indent();
    4163                 :          0 :   if (this->is_default_)
    4164                 :            :     {
    4165                 :          0 :       ast_dump_context->ostream() << "default:";
    4166                 :            :     }
    4167                 :            :   else
    4168                 :            :     {
    4169                 :          0 :       ast_dump_context->ostream() << "case ";
    4170                 :          0 :       ast_dump_context->dump_expression_list(this->cases_);
    4171                 :          0 :       ast_dump_context->ostream() << ":" ;
    4172                 :            :     }
    4173                 :          0 :   ast_dump_context->dump_block(this->statements_);
    4174                 :          0 :   if (this->is_fallthrough_)
    4175                 :            :     {
    4176                 :          0 :       ast_dump_context->print_indent();
    4177                 :          0 :       ast_dump_context->ostream() <<  " (fallthrough)" << dsuffix(location()) << std::endl;
    4178                 :            :     }
    4179                 :          0 : }
    4180                 :            : 
    4181                 :            : // Class Case_clauses.
    4182                 :            : 
    4183                 :            : // Traversal.
    4184                 :            : 
    4185                 :            : int
    4186                 :     139176 : Case_clauses::traverse(Traverse* traverse)
    4187                 :            : {
    4188                 :     695779 :   for (Clauses::iterator p = this->clauses_.begin();
    4189                 :     695779 :        p != this->clauses_.end();
    4190                 :     695779 :        ++p)
    4191                 :            :     {
    4192                 :     556603 :       if (p->traverse(traverse) == TRAVERSE_EXIT)
    4193                 :     139176 :         return TRAVERSE_EXIT;
    4194                 :            :     }
    4195                 :            :   return TRAVERSE_CONTINUE;
    4196                 :            : }
    4197                 :            : 
    4198                 :            : // Check whether all the case expressions are constant.
    4199                 :            : 
    4200                 :            : bool
    4201                 :       5504 : Case_clauses::is_constant() const
    4202                 :            : {
    4203                 :      27601 :   for (Clauses::const_iterator p = this->clauses_.begin();
    4204                 :      27601 :        p != this->clauses_.end();
    4205                 :      27601 :        ++p)
    4206                 :      22153 :     if (!p->is_constant())
    4207                 :       5504 :       return false;
    4208                 :            :   return true;
    4209                 :            : }
    4210                 :            : 
    4211                 :            : // Lower case clauses for a nonconstant switch.
    4212                 :            : 
    4213                 :            : void
    4214                 :       4524 : Case_clauses::lower(Block* b, Temporary_statement* val_temp,
    4215                 :            :                     Unnamed_label* break_label) const
    4216                 :            : {
    4217                 :            :   // The default case.
    4218                 :       4524 :   const Case_clause* default_case = NULL;
    4219                 :            : 
    4220                 :            :   // The label for the fallthrough of the previous case.
    4221                 :       4524 :   Unnamed_label* last_fallthrough_label = NULL;
    4222                 :            : 
    4223                 :            :   // The label for the start of the default case.  This is used if the
    4224                 :            :   // case before the default case falls through.
    4225                 :       4524 :   Unnamed_label* default_start_label = NULL;
    4226                 :            : 
    4227                 :            :   // The label for the end of the default case.  This normally winds
    4228                 :            :   // up as BREAK_LABEL, but it will be different if the default case
    4229                 :            :   // falls through.
    4230                 :       4524 :   Unnamed_label* default_finish_label = NULL;
    4231                 :            : 
    4232                 :       4524 :   for (Clauses::const_iterator p = this->clauses_.begin();
    4233                 :      18713 :        p != this->clauses_.end();
    4234                 :      18713 :        ++p)
    4235                 :            :     {
    4236                 :            :       // The label to use for the start of the statements for this
    4237                 :            :       // case.  This is NULL unless the previous case falls through.
    4238                 :      14189 :       Unnamed_label* start_label = last_fallthrough_label;
    4239                 :            : 
    4240                 :            :       // The label to jump to after the end of the statements for this
    4241                 :            :       // case.
    4242                 :      14189 :       Unnamed_label* finish_label = break_label;
    4243                 :            : 
    4244                 :      14189 :       last_fallthrough_label = NULL;
    4245                 :      14189 :       if (p->is_fallthrough() && p + 1 != this->clauses_.end())
    4246                 :            :         {
    4247                 :         97 :           finish_label = new Unnamed_label(p->location());
    4248                 :         97 :           last_fallthrough_label = finish_label;
    4249                 :            :         }
    4250                 :            : 
    4251                 :      14189 :       if (!p->is_default())
    4252                 :      11948 :         p->lower(b, val_temp, start_label, finish_label);
    4253                 :            :       else
    4254                 :            :         {
    4255                 :            :           // We have to move the default case to the end, so that we
    4256                 :            :           // only use it if all the other tests fail.
    4257                 :      14189 :           default_case = &*p;
    4258                 :            :           default_start_label = start_label;
    4259                 :            :           default_finish_label = finish_label;
    4260                 :            :         }
    4261                 :            :     }
    4262                 :            : 
    4263                 :       4524 :   if (default_case != NULL)
    4264                 :       2241 :     default_case->lower(b, val_temp, default_start_label,
    4265                 :            :                         default_finish_label);
    4266                 :       4524 : }
    4267                 :            : 
    4268                 :            : // Determine types.
    4269                 :            : 
    4270                 :            : void
    4271                 :       5448 : Case_clauses::determine_types(Type* type)
    4272                 :            : {
    4273                 :      27544 :   for (Clauses::iterator p = this->clauses_.begin();
    4274                 :      27544 :        p != this->clauses_.end();
    4275                 :      27544 :        ++p)
    4276                 :      22096 :     p->determine_types(type);
    4277                 :       5448 : }
    4278                 :            : 
    4279                 :            : // Check types.  Returns false if there was an error.
    4280                 :            : 
    4281                 :            : bool
    4282                 :       5448 : Case_clauses::check_types(Type* type)
    4283                 :            : {
    4284                 :       5448 :   bool ret = true;
    4285                 :      27544 :   for (Clauses::iterator p = this->clauses_.begin();
    4286                 :      27544 :        p != this->clauses_.end();
    4287                 :      27544 :        ++p)
    4288                 :            :     {
    4289                 :      22096 :       if (!p->check_types(type))
    4290                 :          0 :         ret = false;
    4291                 :            :     }
    4292                 :       5448 :   return ret;
    4293                 :            : }
    4294                 :            : 
    4295                 :            : // Return true if these clauses may fall through to the statements
    4296                 :            : // following the switch statement.
    4297                 :            : 
    4298                 :            : bool
    4299                 :        776 : Case_clauses::may_fall_through() const
    4300                 :            : {
    4301                 :        776 :   bool found_default = false;
    4302                 :       4253 :   for (Clauses::const_iterator p = this->clauses_.begin();
    4303                 :       4253 :        p != this->clauses_.end();
    4304                 :       4253 :        ++p)
    4305                 :            :     {
    4306                 :       3477 :       if (p->may_fall_through() && !p->is_fallthrough())
    4307                 :        776 :         return true;
    4308                 :       3477 :       if (p->is_default())
    4309                 :        752 :         found_default = true;
    4310                 :            :     }
    4311                 :        776 :   return !found_default;
    4312                 :            : }
    4313                 :            : 
    4314                 :            : // Convert the cases to the backend representation.  This sets
    4315                 :            : // *ALL_CASES and *ALL_STATEMENTS.
    4316                 :            : 
    4317                 :            : void
    4318                 :       5438 : Case_clauses::get_backend(Translate_context* context,
    4319                 :            :                           Unnamed_label* break_label,
    4320                 :            :                           std::vector<std::vector<Bexpression*> >* all_cases,
    4321                 :            :                           std::vector<Bstatement*>* all_statements) const
    4322                 :            : {
    4323                 :       5438 :   Case_constants case_constants;
    4324                 :            : 
    4325                 :       5438 :   size_t c = this->clauses_.size();
    4326                 :       5438 :   all_cases->resize(c);
    4327                 :       5438 :   all_statements->resize(c);
    4328                 :            : 
    4329                 :       5438 :   size_t i = 0;
    4330                 :       5438 :   for (Clauses::const_iterator p = this->clauses_.begin();
    4331                 :      27516 :        p != this->clauses_.end();
    4332                 :      22078 :        ++p, ++i)
    4333                 :            :     {
    4334                 :      44156 :       std::vector<Bexpression*> cases;
    4335                 :      22078 :       Bstatement* stat = p->get_backend(context, break_label, &case_constants,
    4336                 :            :                                         &cases);
    4337                 :            :       // The final clause can't fall through.
    4338                 :      22078 :       if (i == c - 1 && p->is_fallthrough())
    4339                 :            :         {
    4340                 :          1 :           go_assert(saw_errors());
    4341                 :          1 :           stat = context->backend()->error_statement();
    4342                 :            :         }
    4343                 :      22078 :       (*all_cases)[i].swap(cases);
    4344                 :      22078 :       (*all_statements)[i] = stat;
    4345                 :            :     }
    4346                 :       5438 : }
    4347                 :            : 
    4348                 :            : // Dump the AST representation for case clauses (from a switch statement)
    4349                 :            : 
    4350                 :            : void
    4351                 :          0 : Case_clauses::dump_clauses(Ast_dump_context* ast_dump_context) const
    4352                 :            : {
    4353                 :          0 :   for (Clauses::const_iterator p = this->clauses_.begin();
    4354                 :          0 :        p != this->clauses_.end();
    4355                 :          0 :        ++p)
    4356                 :          0 :     p->dump_clause(ast_dump_context);
    4357                 :          0 : }
    4358                 :            : 
    4359                 :            : // A constant switch statement.  A Switch_statement is lowered to this
    4360                 :            : // when all the cases are constants.
    4361                 :            : 
    4362                 :            : class Constant_switch_statement : public Statement
    4363                 :            : {
    4364                 :            :  public:
    4365                 :       5448 :   Constant_switch_statement(Expression* val, Case_clauses* clauses,
    4366                 :            :                             Unnamed_label* break_label,
    4367                 :            :                             Location location)
    4368                 :       5448 :     : Statement(STATEMENT_CONSTANT_SWITCH, location),
    4369                 :      10896 :       val_(val), clauses_(clauses), break_label_(break_label)
    4370                 :            :   { }
    4371                 :            : 
    4372                 :            :  protected:
    4373                 :            :   int
    4374                 :            :   do_traverse(Traverse*);
    4375                 :            : 
    4376                 :            :   void
    4377                 :            :   do_determine_types();
    4378                 :            : 
    4379                 :            :   void
    4380                 :            :   do_check_types(Gogo*);
    4381                 :            : 
    4382                 :            :   Bstatement*
    4383                 :            :   do_get_backend(Translate_context*);
    4384                 :            : 
    4385                 :            :   void
    4386                 :            :   do_dump_statement(Ast_dump_context*) const;
    4387                 :            : 
    4388                 :            :  private:
    4389                 :            :   // The value to switch on.
    4390                 :            :   Expression* val_;
    4391                 :            :   // The case clauses.
    4392                 :            :   Case_clauses* clauses_;
    4393                 :            :   // The break label, if needed.
    4394                 :            :   Unnamed_label* break_label_;
    4395                 :            : };
    4396                 :            : 
    4397                 :            : // Traversal.
    4398                 :            : 
    4399                 :            : int
    4400                 :     136248 : Constant_switch_statement::do_traverse(Traverse* traverse)
    4401                 :            : {
    4402                 :     136248 :   if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
    4403                 :            :     return TRAVERSE_EXIT;
    4404                 :     119200 :   return this->clauses_->traverse(traverse);
    4405                 :            : }
    4406                 :            : 
    4407                 :            : // Determine types.
    4408                 :            : 
    4409                 :            : void
    4410                 :       5448 : Constant_switch_statement::do_determine_types()
    4411                 :            : {
    4412                 :       5448 :   this->val_->determine_type_no_context();
    4413                 :       5448 :   this->clauses_->determine_types(this->val_->type());
    4414                 :       5448 : }
    4415                 :            : 
    4416                 :            : // Check types.
    4417                 :            : 
    4418                 :            : void
    4419                 :       5448 : Constant_switch_statement::do_check_types(Gogo*)
    4420                 :            : {
    4421                 :       5448 :   if (!this->clauses_->check_types(this->val_->type()))
    4422                 :          0 :     this->set_is_error();
    4423                 :       5448 : }
    4424                 :            : 
    4425                 :            : // Convert to GENERIC.
    4426                 :            : 
    4427                 :            : Bstatement*
    4428                 :       5438 : Constant_switch_statement::do_get_backend(Translate_context* context)
    4429                 :            : {
    4430                 :       5438 :   Bexpression* switch_val_expr = this->val_->get_backend(context);
    4431                 :            : 
    4432                 :       5438 :   Unnamed_label* break_label = this->break_label_;
    4433                 :       5438 :   if (break_label == NULL)
    4434                 :       5122 :     break_label = new Unnamed_label(this->location());
    4435                 :            : 
    4436                 :       5438 :   std::vector<std::vector<Bexpression*> > all_cases;
    4437                 :       5438 :   std::vector<Bstatement*> all_statements;
    4438                 :       5438 :   this->clauses_->get_backend(context, break_label, &all_cases,
    4439                 :            :                               &all_statements);
    4440                 :            : 
    4441                 :       5438 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
    4442                 :       5438 :   Bstatement* switch_statement;
    4443                 :       5438 :   switch_statement = context->backend()->switch_statement(bfunction,
    4444                 :            :                                                           switch_val_expr,
    4445                 :            :                                                           all_cases,
    4446                 :            :                                                           all_statements,
    4447                 :       5438 :                                                           this->location());
    4448                 :       5438 :   Bstatement* ldef = break_label->get_definition(context);
    4449                 :       5438 :   return context->backend()->compound_statement(switch_statement, ldef);
    4450                 :            : }
    4451                 :            : 
    4452                 :            : // Dump the AST representation for a constant switch statement.
    4453                 :            : 
    4454                 :            : void
    4455                 :          0 : Constant_switch_statement::do_dump_statement(Ast_dump_context* ast_dump_context)
    4456                 :            :     const
    4457                 :            : {
    4458                 :          0 :   ast_dump_context->print_indent();
    4459                 :          0 :   ast_dump_context->ostream() << "switch ";
    4460                 :          0 :   ast_dump_context->dump_expression(this->val_);
    4461                 :            : 
    4462                 :          0 :   if (ast_dump_context->dump_subblocks())
    4463                 :            :     {
    4464                 :          0 :       ast_dump_context->ostream() << " {" << std::endl;
    4465                 :          0 :       this->clauses_->dump_clauses(ast_dump_context);
    4466                 :          0 :       ast_dump_context->ostream() << "}";
    4467                 :            :     }
    4468                 :            : 
    4469                 :          0 :    ast_dump_context->ostream() << std::endl;
    4470                 :          0 : }
    4471                 :            : 
    4472                 :            : // Class Switch_statement.
    4473                 :            : 
    4474                 :            : // Traversal.
    4475                 :            : 
    4476                 :            : int
    4477                 :      19976 : Switch_statement::do_traverse(Traverse* traverse)
    4478                 :            : {
    4479                 :      19976 :   if (this->val_ != NULL)
    4480                 :            :     {
    4481                 :      14924 :       if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
    4482                 :            :         return TRAVERSE_EXIT;
    4483                 :            :     }
    4484                 :      19976 :   return this->clauses_->traverse(traverse);
    4485                 :            : }
    4486                 :            : 
    4487                 :            : // Lower a Switch_statement to a Constant_switch_statement or a series
    4488                 :            : // of if statements.
    4489                 :            : 
    4490                 :            : Statement*
    4491                 :       9988 : Switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
    4492                 :            :                            Statement_inserter*)
    4493                 :            : {
    4494                 :       9988 :   Location loc = this->location();
    4495                 :            : 
    4496                 :       9988 :   if (this->val_ != NULL
    4497                 :       9988 :       && (this->val_->is_error_expression()
    4498                 :       7462 :           || this->val_->type()->is_error()))
    4499                 :            :     {
    4500                 :          1 :       go_assert(saw_errors());
    4501                 :          1 :       return Statement::make_error_statement(loc);
    4502                 :            :     }
    4503                 :            : 
    4504                 :       9987 :   if (this->val_ != NULL
    4505                 :       7461 :       && this->val_->type()->integer_type() != NULL
    4506                 :       5505 :       && !this->clauses_->empty()
    4507                 :      15491 :       && this->clauses_->is_constant())
    4508                 :       5448 :     return new Constant_switch_statement(this->val_, this->clauses_,
    4509                 :       5448 :                                          this->break_label_, loc);
    4510                 :            : 
    4511                 :       4539 :   if (this->val_ != NULL
    4512                 :       2013 :       && !this->val_->type()->is_comparable()
    4513                 :       4547 :       && !Type::are_compatible_for_comparison(true, this->val_->type(),
    4514                 :          8 :                                               Type::make_nil_type(), NULL))
    4515                 :            :     {
    4516                 :          2 :       go_error_at(this->val_->location(),
    4517                 :            :                   "cannot switch on value whose type that may not be compared");
    4518                 :          2 :       return Statement::make_error_statement(loc);
    4519                 :            :     }
    4520                 :            : 
    4521                 :       4537 :   Block* b = new Block(enclosing, loc);
    4522                 :            : 
    4523                 :       4537 :   if (this->clauses_->empty())
    4524                 :            :     {
    4525                 :         13 :       Expression* val = this->val_;
    4526                 :         13 :       if (val == NULL)
    4527                 :         12 :         val = Expression::make_boolean(true, loc);
    4528                 :         13 :       return Statement::make_statement(val, true);
    4529                 :            :     }
    4530                 :            : 
    4531                 :            :   // var val_temp VAL_TYPE = VAL
    4532                 :       4524 :   Expression* val = this->val_;
    4533                 :       4524 :   if (val == NULL)
    4534                 :       2514 :     val = Expression::make_boolean(true, loc);
    4535                 :            : 
    4536                 :       4524 :   Type* type = val->type();
    4537                 :       4524 :   if (type->is_abstract())
    4538                 :       2529 :     type = type->make_non_abstract_type();
    4539                 :       4524 :   Temporary_statement* val_temp = Statement::make_temporary(type, val, loc);
    4540                 :       4524 :   b->add_statement(val_temp);
    4541                 :            : 
    4542                 :       4524 :   this->clauses_->lower(b, val_temp, this->break_label());
    4543                 :            : 
    4544                 :       4524 :   Statement* s = Statement::make_unnamed_label_statement(this->break_label_);
    4545                 :       4524 :   b->add_statement(s);
    4546                 :            : 
    4547                 :       4524 :   return Statement::make_block_statement(b, loc);
    4548                 :            : }
    4549                 :            : 
    4550                 :            : // Return the break label for this switch statement, creating it if
    4551                 :            : // necessary.
    4552                 :            : 
    4553                 :            : Unnamed_label*
    4554                 :       5420 : Switch_statement::break_label()
    4555                 :            : {
    4556                 :       5420 :   if (this->break_label_ == NULL)
    4557                 :       4840 :     this->break_label_ = new Unnamed_label(this->location());
    4558                 :       5420 :   return this->break_label_;
    4559                 :            : }
    4560                 :            : 
    4561                 :            : // Dump the AST representation for a switch statement.
    4562                 :            : 
    4563                 :            : void
    4564                 :          0 : Switch_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    4565                 :            : {
    4566                 :          0 :   ast_dump_context->print_indent();
    4567                 :          0 :   ast_dump_context->ostream() << "switch ";
    4568                 :          0 :   if (this->val_ != NULL)
    4569                 :            :     {
    4570                 :          0 :       ast_dump_context->dump_expression(this->val_);
    4571                 :            :     }
    4572                 :          0 :   if (ast_dump_context->dump_subblocks())
    4573                 :            :     {
    4574                 :          0 :       ast_dump_context->ostream() << " {" << dsuffix(location()) << std::endl;
    4575                 :          0 :       this->clauses_->dump_clauses(ast_dump_context);
    4576                 :          0 :       ast_dump_context->print_indent();
    4577                 :          0 :       ast_dump_context->ostream() << "}";
    4578                 :            :     }
    4579                 :          0 :   ast_dump_context->ostream() << std::endl;
    4580                 :          0 : }
    4581                 :            : 
    4582                 :            : // Return whether this switch may fall through.
    4583                 :            : 
    4584                 :            : bool
    4585                 :        788 : Switch_statement::do_may_fall_through() const
    4586                 :            : {
    4587                 :        788 :   if (this->clauses_ == NULL)
    4588                 :            :     return true;
    4589                 :            : 
    4590                 :            :   // If we have a break label, then some case needed it.  That implies
    4591                 :            :   // that the switch statement as a whole can fall through.
    4592                 :        788 :   if (this->break_label_ != NULL)
    4593                 :            :     return true;
    4594                 :            : 
    4595                 :        776 :   return this->clauses_->may_fall_through();
    4596                 :            : }
    4597                 :            : 
    4598                 :            : // Make a switch statement.
    4599                 :            : 
    4600                 :            : Switch_statement*
    4601                 :       9989 : Statement::make_switch_statement(Expression* val, Location location)
    4602                 :            : {
    4603                 :       9989 :   return new Switch_statement(val, location);
    4604                 :            : }
    4605                 :            : 
    4606                 :            : // Class Type_case_clauses::Type_case_clause.
    4607                 :            : 
    4608                 :            : // Traversal.
    4609                 :            : 
    4610                 :            : int
    4611                 :      20998 : Type_case_clauses::Type_case_clause::traverse(Traverse* traverse)
    4612                 :            : {
    4613                 :      20998 :   if (!this->is_default_
    4614                 :      19286 :       && ((traverse->traverse_mask()
    4615                 :      19286 :            & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
    4616                 :      40284 :       && Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
    4617                 :            :     return TRAVERSE_EXIT;
    4618                 :      20998 :   if (this->statements_ != NULL)
    4619                 :      18122 :     return this->statements_->traverse(traverse);
    4620                 :            :   return TRAVERSE_CONTINUE;
    4621                 :            : }
    4622                 :            : 
    4623                 :            : // Lower one clause in a type switch.  Add statements to the block B.
    4624                 :            : // The type descriptor we are switching on is in DESCRIPTOR_TEMP.
    4625                 :            : // BREAK_LABEL is the label at the end of the type switch.
    4626                 :            : // *STMTS_LABEL, if not NULL, is a label to put at the start of the
    4627                 :            : // statements.
    4628                 :            : 
    4629                 :            : void
    4630                 :      10498 : Type_case_clauses::Type_case_clause::lower(Type* switch_val_type,
    4631                 :            :                                            Block* b,
    4632                 :            :                                            Temporary_statement* descriptor_temp,
    4633                 :            :                                            Unnamed_label* break_label,
    4634                 :            :                                            Unnamed_label** stmts_label) const
    4635                 :            : {
    4636                 :      10498 :   Location loc = this->location_;
    4637                 :            : 
    4638                 :      10498 :   Unnamed_label* next_case_label = NULL;
    4639                 :      10498 :   if (!this->is_default_)
    4640                 :            :     {
    4641                 :       9643 :       Type* type = this->type_;
    4642                 :            : 
    4643                 :      19286 :       std::string reason;
    4644                 :       9643 :       if (switch_val_type->interface_type() != NULL
    4645                 :       9643 :           && !type->is_nil_constant_as_type()
    4646                 :       9245 :           && type->interface_type() == NULL
    4647                 :       9245 :           && !switch_val_type->interface_type()->implements_interface(type,
    4648                 :            :                                                                       &reason))
    4649                 :            :         {
    4650                 :          1 :           if (reason.empty())
    4651                 :          0 :             go_error_at(this->location_, "impossible type switch case");
    4652                 :            :           else
    4653                 :          1 :             go_error_at(this->location_, "impossible type switch case (%s)",
    4654                 :            :                         reason.c_str());
    4655                 :            :         }
    4656                 :            : 
    4657                 :       9643 :       Expression* ref = Expression::make_temporary_reference(descriptor_temp,
    4658                 :            :                                                              loc);
    4659                 :            : 
    4660                 :       9643 :       Expression* cond;
    4661                 :            :       // The language permits case nil, which is of course a constant
    4662                 :            :       // rather than a type.  It will appear here as an invalid
    4663                 :            :       // forwarding type.
    4664                 :       9643 :       if (type->is_nil_constant_as_type())
    4665                 :        135 :         cond = Expression::make_binary(OPERATOR_EQEQ, ref,
    4666                 :            :                                        Expression::make_nil(loc),
    4667                 :            :                                        loc);
    4668                 :       9508 :       else if (type->interface_type() == NULL)
    4669                 :       9245 :         cond = Expression::make_binary(OPERATOR_EQEQ, ref,
    4670                 :            :                                        Expression::make_type_descriptor(type, loc),
    4671                 :            :                                        loc);
    4672                 :            :       else
    4673                 :        263 :         cond = Runtime::make_call(Runtime::IFACET2IP, loc, 2,
    4674                 :            :                                   Expression::make_type_descriptor(type, loc),
    4675                 :            :                                   ref);
    4676                 :            : 
    4677                 :       9643 :       Unnamed_label* dest;
    4678                 :       9643 :       if (!this->is_fallthrough_)
    4679                 :            :         {
    4680                 :            :           // if !COND { goto NEXT_CASE_LABEL }
    4681                 :       8637 :           next_case_label = new Unnamed_label(Linemap::unknown_location());
    4682                 :       8637 :           dest = next_case_label;
    4683                 :       8637 :           cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
    4684                 :            :         }
    4685                 :            :       else
    4686                 :            :         {
    4687                 :            :           // if COND { goto STMTS_LABEL }
    4688                 :       1006 :           go_assert(stmts_label != NULL);
    4689                 :       1006 :           if (*stmts_label == NULL)
    4690                 :        374 :             *stmts_label = new Unnamed_label(Linemap::unknown_location());
    4691                 :       1006 :           dest = *stmts_label;
    4692                 :            :         }
    4693                 :       9643 :       Block* then_block = new Block(b, loc);
    4694                 :       9643 :       Statement* s = Statement::make_goto_unnamed_statement(dest, loc);
    4695                 :       9643 :       then_block->add_statement(s);
    4696                 :       9643 :       s = Statement::make_if_statement(cond, then_block, NULL, loc);
    4697                 :       9643 :       b->add_statement(s);
    4698                 :            :     }
    4699                 :            : 
    4700                 :      10498 :   if (this->statements_ != NULL
    4701                 :       1437 :       || (!this->is_fallthrough_
    4702                 :        431 :           && stmts_label != NULL
    4703                 :        425 :           && *stmts_label != NULL))
    4704                 :            :     {
    4705                 :       9126 :       go_assert(!this->is_fallthrough_);
    4706                 :       9126 :       if (stmts_label != NULL && *stmts_label != NULL)
    4707                 :            :         {
    4708                 :        374 :           go_assert(!this->is_default_);
    4709                 :        374 :           if (this->statements_ != NULL)
    4710                 :        309 :             (*stmts_label)->set_location(this->statements_->start_location());
    4711                 :        374 :           Statement* s = Statement::make_unnamed_label_statement(*stmts_label);
    4712                 :        374 :           b->add_statement(s);
    4713                 :        374 :           *stmts_label = NULL;
    4714                 :            :         }
    4715                 :       9126 :       if (this->statements_ != NULL)
    4716                 :       9061 :         b->add_statement(Statement::make_block_statement(this->statements_,
    4717                 :            :                                                          loc));
    4718                 :            :     }
    4719                 :            : 
    4720                 :      10498 :   if (this->is_fallthrough_)
    4721                 :       1006 :     go_assert(next_case_label == NULL);
    4722                 :            :   else
    4723                 :            :     {
    4724                 :       9492 :       Location gloc = (this->statements_ == NULL
    4725                 :            :                               ? loc
    4726                 :       9492 :                               : this->statements_->end_location());
    4727                 :       9492 :       b->add_statement(Statement::make_goto_unnamed_statement(break_label,
    4728                 :            :                                                               gloc));
    4729                 :       9492 :       if (next_case_label != NULL)
    4730                 :            :         {
    4731                 :       8637 :           Statement* s =
    4732                 :       8637 :             Statement::make_unnamed_label_statement(next_case_label);
    4733                 :       8637 :           b->add_statement(s);
    4734                 :            :         }
    4735                 :            :     }
    4736                 :      10498 : }
    4737                 :            : 
    4738                 :            : // Return true if this type clause may fall through to the statements
    4739                 :            : // following the switch.
    4740                 :            : 
    4741                 :            : bool
    4742                 :        846 : Type_case_clauses::Type_case_clause::may_fall_through() const
    4743                 :            : {
    4744                 :        846 :   if (this->is_fallthrough_)
    4745                 :            :     {
    4746                 :            :       // This case means that we automatically fall through to the
    4747                 :            :       // next case (it's used for T1 in case T1, T2:).  It does not
    4748                 :            :       // mean that we fall through to the end of the type switch as a
    4749                 :            :       // whole.  There is sure to be a next case and that next case
    4750                 :            :       // will determine whether we fall through to the statements
    4751                 :            :       // after the type switch.
    4752                 :            :       return false;
    4753                 :            :     }
    4754                 :        763 :   if (this->statements_ == NULL)
    4755                 :            :     return true;
    4756                 :        763 :   return this->statements_->may_fall_through();
    4757                 :            : }
    4758                 :            : 
    4759                 :            : // Dump the AST representation for a type case clause
    4760                 :            : 
    4761                 :            : void
    4762                 :          0 : Type_case_clauses::Type_case_clause::dump_clause(
    4763                 :            :     Ast_dump_context* ast_dump_context) const
    4764                 :            : {
    4765                 :          0 :   ast_dump_context->print_indent();
    4766                 :          0 :   if (this->is_default_)
    4767                 :            :     {
    4768                 :          0 :       ast_dump_context->ostream() << "default:";
    4769                 :            :     }
    4770                 :            :   else
    4771                 :            :     {
    4772                 :          0 :       ast_dump_context->ostream() << "case ";
    4773                 :          0 :       ast_dump_context->dump_type(this->type_);
    4774                 :          0 :       ast_dump_context->ostream() << ":" ;
    4775                 :            :     }
    4776                 :          0 :   ast_dump_context->dump_block(this->statements_);
    4777                 :          0 :   if (this->is_fallthrough_)
    4778                 :            :     {
    4779                 :          0 :       ast_dump_context->print_indent();
    4780                 :          0 :       ast_dump_context->ostream() <<  " (fallthrough)" << std::endl;
    4781                 :            :     }
    4782                 :          0 : }
    4783                 :            : 
    4784                 :            : // Class Type_case_clauses.
    4785                 :            : 
    4786                 :            : // Traversal.
    4787                 :            : 
    4788                 :            : int
    4789                 :       4008 : Type_case_clauses::traverse(Traverse* traverse)
    4790                 :            : {
    4791                 :      25006 :   for (Type_clauses::iterator p = this->clauses_.begin();
    4792                 :      25006 :        p != this->clauses_.end();
    4793                 :      25006 :        ++p)
    4794                 :            :     {
    4795                 :      20998 :       if (p->traverse(traverse) == TRAVERSE_EXIT)
    4796                 :       4008 :         return TRAVERSE_EXIT;
    4797                 :            :     }
    4798                 :            :   return TRAVERSE_CONTINUE;
    4799                 :            : }
    4800                 :            : 
    4801                 :            : // Check for duplicate types.
    4802                 :            : 
    4803                 :            : void
    4804                 :       2004 : Type_case_clauses::check_duplicates() const
    4805                 :            : {
    4806                 :       2004 :   typedef Unordered_set_hash(const Type*, Type_hash_identical,
    4807                 :            :                              Type_identical) Types_seen;
    4808                 :       2004 :   Types_seen types_seen;
    4809                 :      12503 :   for (Type_clauses::const_iterator p = this->clauses_.begin();
    4810                 :      12503 :        p != this->clauses_.end();
    4811                 :      12503 :        ++p)
    4812                 :            :     {
    4813                 :      10499 :       Type* t = p->type();
    4814                 :      10499 :       if (t == NULL)
    4815                 :        856 :         continue;
    4816                 :       9643 :       if (t->is_nil_constant_as_type())
    4817                 :        135 :         t = Type::make_nil_type();
    4818                 :       9643 :       std::pair<Types_seen::iterator, bool> ins = types_seen.insert(t);
    4819                 :       9643 :       if (!ins.second)
    4820                 :          4 :         go_error_at(p->location(), "duplicate type in switch");
    4821                 :            :     }
    4822                 :       2004 : }
    4823                 :            : 
    4824                 :            : // Lower the clauses in a type switch.  Add statements to the block B.
    4825                 :            : // The type descriptor we are switching on is in DESCRIPTOR_TEMP.
    4826                 :            : // BREAK_LABEL is the label at the end of the type switch.
    4827                 :            : 
    4828                 :            : void
    4829                 :       2003 : Type_case_clauses::lower(Type* switch_val_type, Block* b,
    4830                 :            :                          Temporary_statement* descriptor_temp,
    4831                 :            :                          Unnamed_label* break_label) const
    4832                 :            : {
    4833                 :       2003 :   const Type_case_clause* default_case = NULL;
    4834                 :            : 
    4835                 :       2003 :   Unnamed_label* stmts_label = NULL;
    4836                 :       2003 :   for (Type_clauses::const_iterator p = this->clauses_.begin();
    4837                 :      12501 :        p != this->clauses_.end();
    4838                 :      12501 :        ++p)
    4839                 :            :     {
    4840                 :      10498 :       if (!p->is_default())
    4841                 :       9643 :         p->lower(switch_val_type, b, descriptor_temp, break_label,
    4842                 :            :                  &stmts_label);
    4843                 :            :       else
    4844                 :            :         {
    4845                 :            :           // We are generating a series of tests, which means that we
    4846                 :            :           // need to move the default case to the end.
    4847                 :      10498 :           default_case = &*p;
    4848                 :            :         }
    4849                 :            :     }
    4850                 :       2003 :   go_assert(stmts_label == NULL);
    4851                 :            : 
    4852                 :       2003 :   if (default_case != NULL)
    4853                 :        855 :     default_case->lower(switch_val_type, b, descriptor_temp, break_label,
    4854                 :            :                         NULL);
    4855                 :       2003 : }
    4856                 :            : 
    4857                 :            : // Return true if these clauses may fall through to the statements
    4858                 :            : // following the switch statement.
    4859                 :            : 
    4860                 :            : bool
    4861                 :        182 : Type_case_clauses::may_fall_through() const
    4862                 :            : {
    4863                 :        182 :   bool found_default = false;
    4864                 :       1028 :   for (Type_clauses::const_iterator p = this->clauses_.begin();
    4865                 :       1028 :        p != this->clauses_.end();
    4866                 :       1028 :        ++p)
    4867                 :            :     {
    4868                 :        846 :       if (p->may_fall_through())
    4869                 :        182 :         return true;
    4870                 :        846 :       if (p->is_default())
    4871                 :        170 :         found_default = true;
    4872                 :            :     }
    4873                 :        182 :   return !found_default;
    4874                 :            : }
    4875                 :            : 
    4876                 :            : // Dump the AST representation for case clauses (from a switch statement)
    4877                 :            : 
    4878                 :            : void
    4879                 :          0 : Type_case_clauses::dump_clauses(Ast_dump_context* ast_dump_context) const
    4880                 :            : {
    4881                 :          0 :   for (Type_clauses::const_iterator p = this->clauses_.begin();
    4882                 :          0 :        p != this->clauses_.end();
    4883                 :          0 :        ++p)
    4884                 :          0 :     p->dump_clause(ast_dump_context);
    4885                 :          0 : }
    4886                 :            : 
    4887                 :            : // Class Type_switch_statement.
    4888                 :            : 
    4889                 :            : // Traversal.
    4890                 :            : 
    4891                 :            : int
    4892                 :       4008 : Type_switch_statement::do_traverse(Traverse* traverse)
    4893                 :            : {
    4894                 :       4008 :   if (this->traverse_expression(traverse, &this->expr_) == TRAVERSE_EXIT)
    4895                 :            :     return TRAVERSE_EXIT;
    4896                 :       4008 :   if (this->clauses_ != NULL)
    4897                 :       4008 :     return this->clauses_->traverse(traverse);
    4898                 :            :   return TRAVERSE_CONTINUE;
    4899                 :            : }
    4900                 :            : 
    4901                 :            : // Lower a type switch statement to a series of if statements.  The gc
    4902                 :            : // compiler is able to generate a table in some cases.  However, that
    4903                 :            : // does not work for us because we may have type descriptors in
    4904                 :            : // different shared libraries, so we can't compare them with simple
    4905                 :            : // equality testing.
    4906                 :            : 
    4907                 :            : Statement*
    4908                 :       2004 : Type_switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
    4909                 :            :                                 Statement_inserter*)
    4910                 :            : {
    4911                 :       2004 :   const Location loc = this->location();
    4912                 :            : 
    4913                 :       2004 :   if (this->clauses_ != NULL)
    4914                 :       2004 :     this->clauses_->check_duplicates();
    4915                 :            : 
    4916                 :       2004 :   Block* b = new Block(enclosing, loc);
    4917                 :            : 
    4918                 :       2004 :   Type* val_type = this->expr_->type();
    4919                 :       2004 :   if (val_type->interface_type() == NULL)
    4920                 :            :     {
    4921                 :          1 :       if (!val_type->is_error())
    4922                 :          0 :         this->report_error(_("cannot type switch on non-interface value"));
    4923                 :          1 :       return Statement::make_error_statement(loc);
    4924                 :            :     }
    4925                 :            : 
    4926                 :       2003 :   Temporary_statement* val_temp =
    4927                 :       2003 :     Statement::make_temporary(NULL, this->expr_, loc);
    4928                 :       2003 :   b->add_statement(val_temp);
    4929                 :            : 
    4930                 :            :   // var descriptor_temp DESCRIPTOR_TYPE
    4931                 :       2003 :   Type* descriptor_type = Type::make_type_descriptor_ptr_type();
    4932                 :       2003 :   Temporary_statement* descriptor_temp =
    4933                 :       2003 :     Statement::make_temporary(descriptor_type, NULL, loc);
    4934                 :       2003 :   b->add_statement(descriptor_temp);
    4935                 :            : 
    4936                 :            :   // descriptor_temp = ifacetype(val_temp)
    4937                 :       2003 :   Expression* ref = Expression::make_temporary_reference(val_temp, loc);
    4938                 :       2003 :   Expression* td = Expression::get_interface_type_descriptor(ref);
    4939                 :       2003 :   Temporary_reference_expression* lhs =
    4940                 :       2003 :     Expression::make_temporary_reference(descriptor_temp, loc);
    4941                 :       2003 :   lhs->set_is_lvalue();
    4942                 :       2003 :   Statement* s = Statement::make_assignment(lhs, td, loc);
    4943                 :       2003 :   b->add_statement(s);
    4944                 :            : 
    4945                 :       2003 :   if (this->clauses_ != NULL)
    4946                 :       2003 :     this->clauses_->lower(val_type, b, descriptor_temp, this->break_label());
    4947                 :            : 
    4948                 :       2003 :   s = Statement::make_unnamed_label_statement(this->break_label_);
    4949                 :       2003 :   b->add_statement(s);
    4950                 :            : 
    4951                 :       2003 :   return Statement::make_block_statement(b, loc);
    4952                 :            : }
    4953                 :            : 
    4954                 :            : // Return whether this switch may fall through.
    4955                 :            : 
    4956                 :            : bool
    4957                 :        194 : Type_switch_statement::do_may_fall_through() const
    4958                 :            : {
    4959                 :        194 :   if (this->clauses_ == NULL)
    4960                 :            :     return true;
    4961                 :            : 
    4962                 :            :   // If we have a break label, then some case needed it.  That implies
    4963                 :            :   // that the switch statement as a whole can fall through.
    4964                 :        194 :   if (this->break_label_ != NULL)
    4965                 :            :     return true;
    4966                 :            : 
    4967                 :        182 :   return this->clauses_->may_fall_through();
    4968                 :            : }
    4969                 :            : 
    4970                 :            : // Return the break label for this type switch statement, creating it
    4971                 :            : // if necessary.
    4972                 :            : 
    4973                 :            : Unnamed_label*
    4974                 :       2110 : Type_switch_statement::break_label()
    4975                 :            : {
    4976                 :       2110 :   if (this->break_label_ == NULL)
    4977                 :       2003 :     this->break_label_ = new Unnamed_label(this->location());
    4978                 :       2110 :   return this->break_label_;
    4979                 :            : }
    4980                 :            : 
    4981                 :            : // Dump the AST representation for a type switch statement
    4982                 :            : 
    4983                 :            : void
    4984                 :          0 : Type_switch_statement::do_dump_statement(Ast_dump_context* ast_dump_context)
    4985                 :            :     const
    4986                 :            : {
    4987                 :          0 :   ast_dump_context->print_indent();
    4988                 :          0 :   ast_dump_context->ostream() << "switch ";
    4989                 :          0 :   if (!this->name_.empty())
    4990                 :          0 :     ast_dump_context->ostream() << this->name_ << " = ";
    4991                 :          0 :   ast_dump_context->dump_expression(this->expr_);
    4992                 :          0 :   ast_dump_context->ostream() << " .(type)";
    4993                 :          0 :   if (ast_dump_context->dump_subblocks())
    4994                 :            :     {
    4995                 :          0 :       ast_dump_context->ostream() << " {" << dsuffix(location()) << std::endl;
    4996                 :          0 :       this->clauses_->dump_clauses(ast_dump_context);
    4997                 :          0 :       ast_dump_context->ostream() << "}";
    4998                 :            :     }
    4999                 :          0 :   ast_dump_context->ostream() << std::endl;
    5000                 :          0 : }
    5001                 :            : 
    5002                 :            : // Make a type switch statement.
    5003                 :            : 
    5004                 :            : Type_switch_statement*
    5005                 :       2004 : Statement::make_type_switch_statement(const std::string& name, Expression* expr,
    5006                 :            :                                       Location location)
    5007                 :            : {
    5008                 :       2004 :   return new Type_switch_statement(name, expr, location);
    5009                 :            : }
    5010                 :            : 
    5011                 :            : // Class Send_statement.
    5012                 :            : 
    5013                 :            : // Traversal.
    5014                 :            : 
    5015                 :            : int
    5016                 :      53182 : Send_statement::do_traverse(Traverse* traverse)
    5017                 :            : {
    5018                 :      53182 :   if (this->traverse_expression(traverse, &this->channel_) == TRAVERSE_EXIT)
    5019                 :            :     return TRAVERSE_EXIT;
    5020                 :      52691 :   return this->traverse_expression(traverse, &this->val_);
    5021                 :            : }
    5022                 :            : 
    5023                 :            : // Determine types.
    5024                 :            : 
    5025                 :            : void
    5026                 :       2395 : Send_statement::do_determine_types()
    5027                 :            : {
    5028                 :       2395 :   this->channel_->determine_type_no_context();
    5029                 :       2395 :   Type* type = this->channel_->type();
    5030                 :       2395 :   Type_context context;
    5031                 :       2395 :   if (type->channel_type() != NULL)
    5032                 :       4790 :     context.type = type->channel_type()->element_type();
    5033                 :       2395 :   this->val_->determine_type(&context);
    5034                 :       2395 : }
    5035                 :            : 
    5036                 :            : // Check types.
    5037                 :            : 
    5038                 :            : void
    5039                 :       2395 : Send_statement::do_check_types(Gogo*)
    5040                 :            : {
    5041                 :       2395 :   Type* type = this->channel_->type();
    5042                 :       2395 :   if (type->is_error())
    5043                 :            :     {
    5044                 :          0 :       this->set_is_error();
    5045                 :          0 :       return;
    5046                 :            :     }
    5047                 :       2395 :   Channel_type* channel_type = type->channel_type();
    5048                 :       2395 :   if (channel_type == NULL)
    5049                 :            :     {
    5050                 :          0 :       go_error_at(this->location(), "left operand of %<<-%> must be channel");
    5051                 :          0 :       this->set_is_error();
    5052                 :          0 :       return;
    5053                 :            :     }
    5054                 :       2395 :   Type* element_type = channel_type->element_type();
    5055                 :       2395 :   if (!Type::are_assignable(element_type, this->val_->type(), NULL))
    5056                 :            :     {
    5057                 :          0 :       this->report_error(_("incompatible types in send"));
    5058                 :          0 :       return;
    5059                 :            :     }
    5060                 :       2395 :   if (!channel_type->may_send())
    5061                 :            :     {
    5062                 :          1 :       this->report_error(_("invalid send on receive-only channel"));
    5063                 :          1 :       return;
    5064                 :            :     }
    5065                 :            : }
    5066                 :            : 
    5067                 :            : // Flatten a send statement.  We may need a temporary for interface
    5068                 :            : // conversion.
    5069                 :            : 
    5070                 :            : Statement*
    5071                 :       2402 : Send_statement::do_flatten(Gogo*, Named_object*, Block*,
    5072                 :            :                            Statement_inserter* inserter)
    5073                 :            : {
    5074                 :       2402 :   if (this->channel_->is_error_expression()
    5075                 :       2402 :       || this->channel_->type()->is_error_type())
    5076                 :            :     {
    5077                 :          0 :       go_assert(saw_errors());
    5078                 :          0 :       return Statement::make_error_statement(this->location());
    5079                 :            :     }
    5080                 :            : 
    5081                 :       4804 :   Type* element_type = this->channel_->type()->channel_type()->element_type();
    5082                 :       2402 :   if (!Type::are_identical(element_type, this->val_->type(),
    5083                 :            :                            Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
    5084                 :            :                            NULL)
    5085                 :         15 :       && this->val_->type()->interface_type() != NULL
    5086                 :       2402 :       && !this->val_->is_variable())
    5087                 :            :     {
    5088                 :          0 :       Temporary_statement* temp =
    5089                 :          0 :         Statement::make_temporary(NULL, this->val_, this->location());
    5090                 :          0 :       inserter->insert(temp);
    5091                 :          0 :       this->val_ = Expression::make_temporary_reference(temp,
    5092                 :            :                                                         this->location());
    5093                 :            :     }
    5094                 :       2402 :   return this;
    5095                 :            : }
    5096                 :            : 
    5097                 :            : // Add explicit type conversions.
    5098                 :            : 
    5099                 :            : void
    5100                 :       2394 : Send_statement::do_add_conversions()
    5101                 :            : {
    5102                 :       4788 :   Type* lt = this->channel_->type()->channel_type()->element_type();
    5103                 :       2394 :   Type* rt = this->val_->type();
    5104                 :       2394 :   if (!Type::are_identical(lt, rt, 0, NULL)
    5105                 :       2394 :       && lt->interface_type() != NULL)
    5106                 :         95 :     this->val_ = Expression::make_cast(lt, this->val_, this->location());
    5107                 :       2394 : }
    5108                 :            : 
    5109                 :            : // Convert a send statement to the backend representation.
    5110                 :            : 
    5111                 :            : Bstatement*
    5112                 :       2393 : Send_statement::do_get_backend(Translate_context* context)
    5113                 :            : {
    5114                 :       2393 :   Location loc = this->location();
    5115                 :            : 
    5116                 :       2393 :   Channel_type* channel_type = this->channel_->type()->channel_type();
    5117                 :       2393 :   Type* element_type = channel_type->element_type();
    5118                 :       2393 :   Expression* val = Expression::convert_for_assignment(context->gogo(),
    5119                 :            :                                                        element_type,
    5120                 :            :                                                        this->val_, loc);
    5121                 :            : 
    5122                 :       2393 :   bool can_take_address;
    5123                 :       2393 :   switch (element_type->base()->classification())
    5124                 :            :     {
    5125                 :            :     case Type::TYPE_BOOLEAN:
    5126                 :            :     case Type::TYPE_INTEGER:
    5127                 :            :     case Type::TYPE_FUNCTION:
    5128                 :            :     case Type::TYPE_POINTER:
    5129                 :            :     case Type::TYPE_MAP:
    5130                 :            :     case Type::TYPE_CHANNEL:
    5131                 :            :     case Type::TYPE_FLOAT:
    5132                 :            :     case Type::TYPE_COMPLEX:
    5133                 :            :     case Type::TYPE_STRING:
    5134                 :            :     case Type::TYPE_INTERFACE:
    5135                 :            :       can_take_address = false;
    5136                 :            :       break;
    5137                 :            : 
    5138                 :            :     case Type::TYPE_STRUCT:
    5139                 :            :       can_take_address = true;
    5140                 :            :       break;
    5141                 :            : 
    5142                 :         13 :     case Type::TYPE_ARRAY:
    5143                 :         13 :       can_take_address = !element_type->is_slice_type();
    5144                 :         13 :       break;
    5145                 :            : 
    5146                 :          0 :     default:
    5147                 :          0 :     case Type::TYPE_ERROR:
    5148                 :          0 :     case Type::TYPE_VOID:
    5149                 :          0 :     case Type::TYPE_SINK:
    5150                 :          0 :     case Type::TYPE_NIL:
    5151                 :          0 :     case Type::TYPE_NAMED:
    5152                 :          0 :     case Type::TYPE_FORWARD:
    5153                 :          0 :       go_assert(saw_errors());
    5154                 :          0 :       return context->backend()->error_statement();
    5155                 :            :     }
    5156                 :            : 
    5157                 :            :   // Only try to take the address of a variable.  We have already
    5158                 :            :   // moved variables to the heap, so this should not cause that to
    5159                 :            :   // happen unnecessarily.
    5160                 :         13 :   if (can_take_address
    5161                 :        281 :       && val->var_expression() == NULL
    5162                 :       2114 :       && val->temporary_reference_expression() == NULL)
    5163                 :            :     can_take_address = false;
    5164                 :            : 
    5165                 :       4481 :   Bstatement* btemp = NULL;
    5166                 :       2114 :   if (can_take_address)
    5167                 :            :     {
    5168                 :            :       // The function doesn't change the value, so just take its
    5169                 :            :       // address directly.
    5170                 :         26 :       val = Expression::make_unary(OPERATOR_AND, val, loc);
    5171                 :            :     }
    5172                 :            :   else
    5173                 :            :     {
    5174                 :            :       // The value is not in a variable, or is small enough that it
    5175                 :            :       // might be in a register, and taking the address would push it
    5176                 :            :       // on the stack.  Copy it into a temporary variable to take the
    5177                 :            :       // address.
    5178                 :       2367 :       Temporary_statement* temp = Statement::make_temporary(element_type,
    5179                 :            :                                                             val, loc);
    5180                 :       2367 :       Expression* ref = Expression::make_temporary_reference(temp, loc);
    5181                 :       2367 :       val = Expression::make_unary(OPERATOR_AND, ref, loc);
    5182                 :       2367 :       btemp = temp->get_backend(context);
    5183                 :            :     }
    5184                 :            : 
    5185                 :       2393 :   Expression* call = Runtime::make_call(Runtime::CHANSEND, loc, 2,
    5186                 :       2393 :                                         this->channel_, val);
    5187                 :            : 
    5188                 :       2393 :   context->gogo()->lower_expression(context->function(), NULL, &call);
    5189                 :       2393 :   Bexpression* bcall = call->get_backend(context);
    5190                 :       2393 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
    5191                 :       2393 :   Bstatement* s = context->backend()->expression_statement(bfunction, bcall);
    5192                 :            : 
    5193                 :       2393 :   if (btemp == NULL)
    5194                 :            :     return s;
    5195                 :            :   else
    5196                 :       2367 :     return context->backend()->compound_statement(btemp, s);
    5197                 :            : }
    5198                 :            : 
    5199                 :            : // Dump the AST representation for a send statement
    5200                 :            : 
    5201                 :            : void
    5202                 :          0 : Send_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    5203                 :            : {
    5204                 :          0 :   ast_dump_context->print_indent();
    5205                 :          0 :   ast_dump_context->dump_expression(this->channel_);
    5206                 :          0 :   ast_dump_context->ostream() << " <- ";
    5207                 :          0 :   ast_dump_context->dump_expression(this->val_);
    5208                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    5209                 :          0 : }
    5210                 :            : 
    5211                 :            : // Make a send statement.
    5212                 :            : 
    5213                 :            : Send_statement*
    5214                 :       2395 : Statement::make_send_statement(Expression* channel, Expression* val,
    5215                 :            :                                Location location)
    5216                 :            : {
    5217                 :       2395 :   return new Send_statement(channel, val, location);
    5218                 :            : }
    5219                 :            : 
    5220                 :            : // Class Select_clauses::Select_clause.
    5221                 :            : 
    5222                 :            : // Traversal.
    5223                 :            : 
    5224                 :            : int
    5225                 :     145931 : Select_clauses::Select_clause::traverse(Traverse* traverse)
    5226                 :            : {
    5227                 :     145931 :   if (!this->is_lowered_
    5228                 :     145931 :       && (traverse->traverse_mask()
    5229                 :      15024 :           & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
    5230                 :            :     {
    5231                 :      15024 :       if (this->channel_ != NULL)
    5232                 :            :         {
    5233                 :      12254 :           if (Expression::traverse(&this->channel_, traverse) == TRAVERSE_EXIT)
    5234                 :            :             return TRAVERSE_EXIT;
    5235                 :            :         }
    5236                 :      15024 :       if (this->val_ != NULL)
    5237                 :            :         {
    5238                 :       5770 :           if (Expression::traverse(&this->val_, traverse) == TRAVERSE_EXIT)
    5239                 :            :             return TRAVERSE_EXIT;
    5240                 :            :         }
    5241                 :      15024 :       if (this->closed_ != NULL)
    5242                 :            :         {
    5243                 :          0 :           if (Expression::traverse(&this->closed_, traverse) == TRAVERSE_EXIT)
    5244                 :            :             return TRAVERSE_EXIT;
    5245                 :            :         }
    5246                 :            :     }
    5247                 :     145931 :   if (this->statements_ != NULL)
    5248                 :            :     {
    5249                 :     145931 :       if (this->statements_->traverse(traverse) == TRAVERSE_EXIT)
    5250                 :          0 :         return TRAVERSE_EXIT;
    5251                 :            :     }
    5252                 :            :   return TRAVERSE_CONTINUE;
    5253                 :            : }
    5254                 :            : 
    5255                 :            : // Lowering.  We call a function to register this clause, and arrange
    5256                 :            : // to set any variables in any receive clause.
    5257                 :            : 
    5258                 :            : void
    5259                 :       6405 : Select_clauses::Select_clause::lower(Gogo* gogo, Named_object* function,
    5260                 :            :                                      Block* b, Temporary_statement* scases,
    5261                 :            :                                      size_t index, Temporary_statement* recvok)
    5262                 :            : {
    5263                 :       6405 :   Location loc = this->location_;
    5264                 :            : 
    5265                 :       6405 :   Expression* scase = Expression::make_temporary_reference(scases, loc);
    5266                 :       6405 :   Expression* index_expr = Expression::make_integer_ul(index, NULL, loc);
    5267                 :       6405 :   scase = Expression::make_array_index(scase, index_expr, NULL, NULL, loc);
    5268                 :            : 
    5269                 :       6405 :   if (this->is_default_)
    5270                 :            :     {
    5271                 :        855 :       go_assert(this->channel_ == NULL && this->val_ == NULL);
    5272                 :        855 :       this->lower_default(b, scase);
    5273                 :        855 :       this->is_lowered_ = true;
    5274                 :        855 :       return;
    5275                 :            :     }
    5276                 :            : 
    5277                 :            :   // Evaluate the channel before the select statement.
    5278                 :       5550 :   Temporary_statement* channel_temp = Statement::make_temporary(NULL,
    5279                 :            :                                                                 this->channel_,
    5280                 :            :                                                                 loc);
    5281                 :       5550 :   b->add_statement(channel_temp);
    5282                 :       5550 :   Expression* chanref = Expression::make_temporary_reference(channel_temp,
    5283                 :            :                                                              loc);
    5284                 :            : 
    5285                 :       5550 :   if (this->is_send_)
    5286                 :       1320 :     this->lower_send(b, scase, chanref);
    5287                 :            :   else
    5288                 :       4230 :     this->lower_recv(gogo, function, b, scase, chanref, recvok);
    5289                 :            : 
    5290                 :            :   // Now all references should be handled through the statements, not
    5291                 :            :   // through here.
    5292                 :       5550 :   this->is_lowered_ = true;
    5293                 :       5550 :   this->val_ = NULL;
    5294                 :            : }
    5295                 :            : 
    5296                 :            : // Lower a default clause in a select statement.
    5297                 :            : 
    5298                 :            : void
    5299                 :        855 : Select_clauses::Select_clause::lower_default(Block* b, Expression* scase)
    5300                 :            : {
    5301                 :        855 :   Location loc = this->location_;
    5302                 :        855 :   this->set_case(b, scase, Expression::make_nil(loc), NULL, caseDefault);
    5303                 :        855 : }
    5304                 :            : 
    5305                 :            : // Lower a send clause in a select statement.
    5306                 :            : 
    5307                 :            : void
    5308                 :       1320 : Select_clauses::Select_clause::lower_send(Block* b, Expression* scase,
    5309                 :            :                                           Expression* chanref)
    5310                 :            : {
    5311                 :       1320 :   Location loc = this->location_;
    5312                 :            : 
    5313                 :       1320 :   Channel_type* ct = this->channel_->type()->channel_type();
    5314                 :       1320 :   if (ct == NULL)
    5315                 :          0 :     return;
    5316                 :            : 
    5317                 :       1320 :   Type* valtype = ct->element_type();
    5318                 :            : 
    5319                 :            :   // Note that copying the value to a temporary here means that we
    5320                 :            :   // evaluate the send values in the required order.
    5321                 :       1320 :   Temporary_statement* val = Statement::make_temporary(valtype, this->val_,
    5322                 :            :                                                        loc);
    5323                 :            :   // The value here escapes, because it might be sent on a channel.
    5324                 :            :   // We record that via the Temporary_statement, so that the escape
    5325                 :            :   // analysis pass can pick it up.  The gc compiler lowers select
    5326                 :            :   // statements after escape analysis, so it doesn't have to worry
    5327                 :            :   // about this.
    5328                 :       1320 :   val->set_value_escapes();
    5329                 :       1320 :   b->add_statement(val);
    5330                 :            : 
    5331                 :       1320 :   Expression* valref = Expression::make_temporary_reference(val, loc);
    5332                 :       1320 :   Expression* valaddr = Expression::make_unary(OPERATOR_AND, valref, loc);
    5333                 :       1320 :   Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
    5334                 :       1320 :   valaddr = Expression::make_cast(unsafe_pointer_type, valaddr, loc);
    5335                 :            : 
    5336                 :       1320 :   this->set_case(b, scase, chanref, valaddr, caseSend);
    5337                 :            : }
    5338                 :            : 
    5339                 :            : // Lower a receive clause in a select statement.
    5340                 :            : 
    5341                 :            : void
    5342                 :       4230 : Select_clauses::Select_clause::lower_recv(Gogo* gogo, Named_object* function,
    5343                 :            :                                           Block* b, Expression* scase,
    5344                 :            :                                           Expression* chanref,
    5345                 :            :                                           Temporary_statement* recvok)
    5346                 :            : {
    5347                 :       4230 :   Location loc = this->location_;
    5348                 :            : 
    5349                 :       4230 :   Channel_type* ct = this->channel_->type()->channel_type();
    5350                 :       4230 :   if (ct == NULL)
    5351                 :          0 :     return;
    5352                 :            : 
    5353                 :       4230 :   Type* valtype = ct->element_type();
    5354                 :       4230 :   Temporary_statement* val = Statement::make_temporary(valtype, NULL, loc);
    5355                 :       4230 :   b->add_statement(val);
    5356                 :            : 
    5357                 :       4230 :   Expression* valref = Expression::make_temporary_reference(val, loc);
    5358                 :       4230 :   Expression* valaddr = Expression::make_unary(OPERATOR_AND, valref, loc);
    5359                 :       4230 :   Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
    5360                 :       4230 :   valaddr = Expression::make_cast(unsafe_pointer_type, valaddr, loc);
    5361                 :            : 
    5362                 :       4230 :   this->set_case(b, scase, chanref, valaddr, caseRecv);
    5363                 :            : 
    5364                 :            :   // If the block of statements is executed, arrange for the received
    5365                 :            :   // value to move from VAL to the place where the statements expect
    5366                 :            :   // it.
    5367                 :            : 
    5368                 :       4230 :   Block* init = NULL;
    5369                 :            : 
    5370                 :       4230 :   if (this->var_ != NULL)
    5371                 :            :     {
    5372                 :        456 :       go_assert(this->val_ == NULL);
    5373                 :        456 :       valref = Expression::make_temporary_reference(val, loc);
    5374                 :        456 :       this->var_->var_value()->set_init(valref);
    5375                 :        456 :       this->var_->var_value()->clear_type_from_chan_element();
    5376                 :            :     }
    5377                 :       3774 :   else if (this->val_ != NULL && !this->val_->is_sink_expression())
    5378                 :            :     {
    5379                 :       1389 :       init = new Block(b, loc);
    5380                 :       1389 :       valref = Expression::make_temporary_reference(val, loc);
    5381                 :       1389 :       init->add_statement(Statement::make_assignment(this->val_, valref, loc));
    5382                 :            :     }
    5383                 :            : 
    5384                 :       4230 :   if (this->closedvar_ != NULL)
    5385                 :            :     {
    5386                 :         25 :       go_assert(this->closed_ == NULL);
    5387                 :         25 :       Expression* cref = Expression::make_temporary_reference(recvok, loc);
    5388                 :         25 :       this->closedvar_->var_value()->set_init(cref);
    5389                 :            :     }
    5390                 :       4205 :   else if (this->closed_ != NULL && !this->closed_->is_sink_expression())
    5391                 :            :     {
    5392                 :          0 :       if (init == NULL)
    5393                 :          0 :         init = new Block(b, loc);
    5394                 :          0 :       Expression* cref = Expression::make_temporary_reference(recvok, loc);
    5395                 :          0 :       init->add_statement(Statement::make_assignment(this->closed_, cref,
    5396                 :            :                                                      loc));
    5397                 :            :     }
    5398                 :            : 
    5399                 :       4230 :   if (init != NULL)
    5400                 :            :     {
    5401                 :       1389 :       gogo->lower_block(function, init);
    5402                 :            : 
    5403                 :       1389 :       if (this->statements_ != NULL)
    5404                 :       1389 :         init->add_statement(Statement::make_block_statement(this->statements_,
    5405                 :            :                                                             loc));
    5406                 :       1389 :       this->statements_ = init;
    5407                 :            :     }
    5408                 :            : }
    5409                 :            : 
    5410                 :            : // Set the fields of an scase struct, an element in the array that we
    5411                 :            : // pass to the runtime function selectgo.
    5412                 :            : 
    5413                 :            : void
    5414                 :       6405 : Select_clauses::Select_clause::set_case(Block* b,
    5415                 :            :                                         Expression* scase,
    5416                 :            :                                         Expression* chanref,
    5417                 :            :                                         Expression* elem,
    5418                 :            :                                         int kind)
    5419                 :            : {
    5420                 :       6405 :   Location loc = this->location_;
    5421                 :       6405 :   Struct_type* scase_type = scase->type()->struct_type();
    5422                 :            : 
    5423                 :       6405 :   int field_index = 0;
    5424                 :      12810 :   go_assert(scase_type->field(field_index)->is_field_name("c"));
    5425                 :       6405 :   Expression* ref = Expression::make_field_reference(scase, field_index, loc);
    5426                 :       6405 :   Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
    5427                 :       6405 :   chanref = Expression::make_unsafe_cast(unsafe_pointer_type, chanref, loc);
    5428                 :       6405 :   Statement* s = Statement::make_assignment(ref, chanref, loc);
    5429                 :       6405 :   b->add_statement(s);
    5430                 :            : 
    5431                 :       6405 :   if (elem != NULL)
    5432                 :            :     {
    5433                 :       5550 :       field_index = 1;
    5434                 :      11100 :       go_assert(scase_type->field(field_index)->is_field_name("elem"));
    5435                 :       5550 :       ref = Expression::make_field_reference(scase->copy(), field_index, loc);
    5436                 :       5550 :       s = Statement::make_assignment(ref, elem, loc);
    5437                 :       5550 :       b->add_statement(s);
    5438                 :            :     }
    5439                 :            : 
    5440                 :       6405 :   field_index = 2;
    5441                 :      12810 :   go_assert(scase_type->field(field_index)->is_field_name("kind"));
    5442                 :       6405 :   Type* uint16_type = Type::lookup_integer_type("uint16");
    5443                 :       6405 :   Expression* k = Expression::make_integer_ul(kind, uint16_type, loc);
    5444                 :       6405 :   ref = Expression::make_field_reference(scase->copy(), field_index, loc);
    5445                 :       6405 :   s = Statement::make_assignment(ref, k, loc);
    5446                 :       6405 :   b->add_statement(s);
    5447                 :       6405 : }
    5448                 :            : 
    5449                 :            : // Determine types.
    5450                 :            : 
    5451                 :            : void
    5452                 :       6405 : Select_clauses::Select_clause::determine_types()
    5453                 :            : {
    5454                 :       6405 :   go_assert(this->is_lowered_);
    5455                 :       6405 :   if (this->statements_ != NULL)
    5456                 :       6405 :     this->statements_->determine_types();
    5457                 :       6405 : }
    5458                 :            : 
    5459                 :            : // Check types.
    5460                 :            : 
    5461                 :            : void
    5462                 :       6405 : Select_clauses::Select_clause::check_types()
    5463                 :            : {
    5464                 :       6405 :   if (this->is_default_)
    5465                 :            :     return;
    5466                 :            : 
    5467                 :       5550 :   Channel_type* ct = this->channel_->type()->channel_type();
    5468                 :       5550 :   if (ct == NULL)
    5469                 :            :     {
    5470                 :          0 :       go_error_at(this->channel_->location(), "expected channel");
    5471                 :          0 :       return;
    5472                 :            :     }
    5473                 :            : 
    5474                 :       5550 :   if (this->is_send_ && !ct->may_send())
    5475                 :          1 :     go_error_at(this->location(), "invalid send on receive-only channel");
    5476                 :       5549 :   else if (!this->is_send_ && !ct->may_receive())
    5477                 :          1 :     go_error_at(this->location(), "invalid receive on send-only channel");
    5478                 :            : }
    5479                 :            : 
    5480                 :            : // Whether this clause may fall through to the statement which follows
    5481                 :            : // the overall select statement.
    5482                 :            : 
    5483                 :            : bool
    5484                 :        404 : Select_clauses::Select_clause::may_fall_through() const
    5485                 :            : {
    5486                 :        404 :   if (this->statements_ == NULL)
    5487                 :            :     return true;
    5488                 :        404 :   return this->statements_->may_fall_through();
    5489                 :            : }
    5490                 :            : 
    5491                 :            : // Return the backend representation for the statements to execute.
    5492                 :            : 
    5493                 :            : Bstatement*
    5494                 :       6393 : Select_clauses::Select_clause::get_statements_backend(
    5495                 :            :     Translate_context* context)
    5496                 :            : {
    5497                 :       6393 :   if (this->statements_ == NULL)
    5498                 :            :     return NULL;
    5499                 :       6393 :   Bblock* bblock = this->statements_->get_backend(context);
    5500                 :       6393 :   return context->backend()->block_statement(bblock);
    5501                 :            : }
    5502                 :            : 
    5503                 :            : // Dump the AST representation for a select case clause
    5504                 :            : 
    5505                 :            : void
    5506                 :          0 : Select_clauses::Select_clause::dump_clause(
    5507                 :            :     Ast_dump_context* ast_dump_context) const
    5508                 :            : {
    5509                 :          0 :   ast_dump_context->print_indent();
    5510                 :          0 :   if (this->is_default_)
    5511                 :            :     {
    5512                 :          0 :       ast_dump_context->ostream() << "default:";
    5513                 :            :     }
    5514                 :            :   else
    5515                 :            :     {
    5516                 :          0 :       ast_dump_context->ostream() << "case "  ;
    5517                 :          0 :       if (this->is_send_)
    5518                 :            :         {
    5519                 :          0 :           ast_dump_context->dump_expression(this->channel_);
    5520                 :          0 :           ast_dump_context->ostream() << " <- " ;
    5521                 :          0 :           if (this->val_ != NULL)
    5522                 :          0 :             ast_dump_context->dump_expression(this->val_);
    5523                 :            :         }
    5524                 :            :       else
    5525                 :            :         {
    5526                 :          0 :           if (this->val_ != NULL)
    5527                 :          0 :             ast_dump_context->dump_expression(this->val_);
    5528                 :          0 :           if (this->closed_ != NULL)
    5529                 :            :             {
    5530                 :            :               // FIXME: can val_ == NULL and closed_ ! = NULL?
    5531                 :          0 :               ast_dump_context->ostream() << " , " ;
    5532                 :          0 :               ast_dump_context->dump_expression(this->closed_);
    5533                 :            :             }
    5534                 :          0 :           if (this->closedvar_ != NULL || this->var_ != NULL)
    5535                 :          0 :             ast_dump_context->ostream() << " := " ;
    5536                 :            : 
    5537                 :          0 :           ast_dump_context->ostream() << " <- " ;
    5538                 :          0 :           ast_dump_context->dump_expression(this->channel_);
    5539                 :            :         }
    5540                 :          0 :       ast_dump_context->ostream() << ":" ;
    5541                 :            :     }
    5542                 :          0 :   ast_dump_context->dump_block(this->statements_);
    5543                 :          0 : }
    5544                 :            : 
    5545                 :            : // Class Select_clauses.
    5546                 :            : 
    5547                 :            : // Traversal.
    5548                 :            : 
    5549                 :            : int
    5550                 :      42921 : Select_clauses::traverse(Traverse* traverse)
    5551                 :            : {
    5552                 :     188852 :   for (Clauses::iterator p = this->clauses_.begin();
    5553                 :     188852 :        p != this->clauses_.end();
    5554                 :     188852 :        ++p)
    5555                 :            :     {
    5556                 :     145931 :       if (p->traverse(traverse) == TRAVERSE_EXIT)
    5557                 :      42921 :         return TRAVERSE_EXIT;
    5558                 :            :     }
    5559                 :            :   return TRAVERSE_CONTINUE;
    5560                 :            : }
    5561                 :            : 
    5562                 :            : // Lowering.  Here we pull out the channel and the send values, to
    5563                 :            : // enforce the order of evaluation.  We also add explicit send and
    5564                 :            : // receive statements to the clauses.
    5565                 :            : 
    5566                 :            : void
    5567                 :       1840 : Select_clauses::lower(Gogo* gogo, Named_object* function, Block* b,
    5568                 :            :                       Temporary_statement* scases, Temporary_statement* recvok)
    5569                 :            : {
    5570                 :       1840 :   size_t i = 0;
    5571                 :       8245 :   for (Clauses::iterator p = this->clauses_.begin();
    5572                 :       8245 :        p != this->clauses_.end();
    5573                 :       6405 :        ++p, ++i)
    5574                 :       6405 :     p->lower(gogo, function, b, scases, i, recvok);
    5575                 :       1840 : }
    5576                 :            : 
    5577                 :            : // Determine types.
    5578                 :            : 
    5579                 :            : void
    5580                 :       1840 : Select_clauses::determine_types()
    5581                 :            : {
    5582                 :       8245 :   for (Clauses::iterator p = this->clauses_.begin();
    5583                 :       8245 :        p != this->clauses_.end();
    5584                 :       8245 :        ++p)
    5585                 :       6405 :     p->determine_types();
    5586                 :       1840 : }
    5587                 :            : 
    5588                 :            : // Check types.
    5589                 :            : 
    5590                 :            : void
    5591                 :       1840 : Select_clauses::check_types()
    5592                 :            : {
    5593                 :       8245 :   for (Clauses::iterator p = this->clauses_.begin();
    5594                 :       8245 :        p != this->clauses_.end();
    5595                 :       8245 :        ++p)
    5596                 :       6405 :     p->check_types();
    5597                 :       1840 : }
    5598                 :            : 
    5599                 :            : // Return whether these select clauses fall through to the statement
    5600                 :            : // following the overall select statement.
    5601                 :            : 
    5602                 :            : bool
    5603                 :        193 : Select_clauses::may_fall_through() const
    5604                 :            : {
    5605                 :        585 :   for (Clauses::const_iterator p = this->clauses_.begin();
    5606                 :        585 :        p != this->clauses_.end();
    5607                 :        585 :        ++p)
    5608                 :        404 :     if (p->may_fall_through())
    5609                 :        193 :       return true;
    5610                 :            :   return false;
    5611                 :            : }
    5612                 :            : 
    5613                 :            : // Convert to the backend representation.  Assemble the clauses and
    5614                 :            : // build a switch statement on the index value returned by the call to
    5615                 :            : // selectgo.
    5616                 :            : 
    5617                 :            : Bstatement*
    5618                 :       1834 : Select_clauses::get_backend(Translate_context* context,
    5619                 :            :                             Temporary_statement* index,
    5620                 :            :                             Unnamed_label *break_label,
    5621                 :            :                             Location location)
    5622                 :            : {
    5623                 :       1834 :   size_t count = this->clauses_.size();
    5624                 :       1834 :   std::vector<std::vector<Bexpression*> > cases(count + 1);
    5625                 :       3668 :   std::vector<Bstatement*> clauses(count + 1);
    5626                 :            : 
    5627                 :       1834 :   Type* int_type = Type::lookup_integer_type("int");
    5628                 :            : 
    5629                 :       1834 :   int i = 0;
    5630                 :       8227 :   for (Clauses::iterator p = this->clauses_.begin();
    5631                 :       8227 :        p != this->clauses_.end();
    5632                 :       6393 :        ++p, ++i)
    5633                 :            :     {
    5634                 :       6393 :       Expression* index_expr = Expression::make_integer_ul(i, int_type,
    5635                 :            :                                                            location);
    5636                 :       6393 :       cases[i].push_back(index_expr->get_backend(context));
    5637                 :            : 
    5638                 :       6393 :       Bstatement* s = p->get_statements_backend(context);
    5639                 :       6393 :       Location gloc = (p->statements() == NULL
    5640                 :          0 :                        ? p->location()
    5641                 :       6393 :                        : p->statements()->end_location());
    5642                 :       6393 :       Bstatement* g = break_label->get_goto(context, gloc);
    5643                 :            : 
    5644                 :       6393 :       if (s == NULL)
    5645                 :          0 :         clauses[i] = g;
    5646                 :            :       else
    5647                 :       6393 :         clauses[i] = context->backend()->compound_statement(s, g);
    5648                 :            :     }
    5649                 :            : 
    5650                 :       1834 :   Expression* ref = Expression::make_temporary_reference(index, location);
    5651                 :       1834 :   Bexpression* bindex = ref->get_backend(context);
    5652                 :            : 
    5653                 :       1834 :   Bfunction* bfunction = context->function()->func_value()->get_decl();
    5654                 :            : 
    5655                 :       1834 :   if (count == 0)
    5656                 :          0 :     return context->backend()->expression_statement(bfunction, bindex);
    5657                 :            : 
    5658                 :       1834 :   Expression* crash = Runtime::make_call(Runtime::UNREACHABLE, location, 0);
    5659                 :       1834 :   Bexpression* bcrash = crash->get_backend(context);
    5660                 :       1834 :   clauses[count] = context->backend()->expression_statement(bfunction, bcrash);
    5661                 :            : 
    5662                 :       3668 :   std::vector<Bstatement*> statements;
    5663                 :       1834 :   statements.reserve(2);
    5664                 :            : 
    5665                 :       1834 :   Bstatement* switch_stmt = context->backend()->switch_statement(bfunction,
    5666                 :            :                                                                  bindex,
    5667                 :            :                                                                  cases,
    5668                 :            :                                                                  clauses,
    5669                 :       1834 :                                                                  location);
    5670                 :       1834 :   statements.push_back(switch_stmt);
    5671                 :            : 
    5672                 :       1834 :   Bstatement* ldef = break_label->get_definition(context);
    5673                 :       1834 :   statements.push_back(ldef);
    5674                 :            : 
    5675                 :       1834 :   return context->backend()->statement_list(statements);
    5676                 :            : }
    5677                 :            : 
    5678                 :            : // Dump the AST representation for select clauses.
    5679                 :            : 
    5680                 :            : void
    5681                 :          0 : Select_clauses::dump_clauses(Ast_dump_context* ast_dump_context) const
    5682                 :            : {
    5683                 :          0 :   for (Clauses::const_iterator p = this->clauses_.begin();
    5684                 :          0 :        p != this->clauses_.end();
    5685                 :          0 :        ++p)
    5686                 :          0 :     p->dump_clause(ast_dump_context);
    5687                 :          0 : }
    5688                 :            : 
    5689                 :            : // Class Select_statement.
    5690                 :            : 
    5691                 :            : // Return the break label for this switch statement, creating it if
    5692                 :            : // necessary.
    5693                 :            : 
    5694                 :            : Unnamed_label*
    5695                 :       2455 : Select_statement::break_label()
    5696                 :            : {
    5697                 :       2455 :   if (this->break_label_ == NULL)
    5698                 :       2423 :     this->break_label_ = new Unnamed_label(this->location());
    5699                 :       2455 :   return this->break_label_;
    5700                 :            : }
    5701                 :            : 
    5702                 :            : // Lower a select statement.  This will return a block containing this
    5703                 :            : // select statement.  The block will implement the order of evaluation
    5704                 :            : // rules, include the send and receive statements as explicit
    5705                 :            : // statements in the clauses, and call the runtime selectgo function.
    5706                 :            : 
    5707                 :            : Statement*
    5708                 :       4724 : Select_statement::do_lower(Gogo* gogo, Named_object* function,
    5709                 :            :                            Block* enclosing, Statement_inserter*)
    5710                 :            : {
    5711                 :       4724 :   if (this->is_lowered_)
    5712                 :       2249 :     return this;
    5713                 :            : 
    5714                 :       2475 :   Location loc = this->location();
    5715                 :            : 
    5716                 :       2475 :   Block* b = new Block(enclosing, loc);
    5717                 :            : 
    5718                 :       2475 :   int ncases = this->clauses_->size();
    5719                 :            : 
    5720                 :            :   // Zero-case select.  Just block the execution.
    5721                 :       2475 :   if (ncases == 0)
    5722                 :            :     {
    5723                 :         48 :       Expression* call = Runtime::make_call(Runtime::BLOCK, loc, 0);
    5724                 :         48 :       Statement *s = Statement::make_statement(call, false);
    5725                 :         48 :       b->add_statement(s);
    5726                 :         48 :       this->is_lowered_ = true;
    5727                 :         48 :       return Statement::make_block_statement(b, loc);
    5728                 :            :     }
    5729                 :            : 
    5730                 :            :   // One-case select.  It is mostly just to run the case.
    5731                 :       2427 :   if (ncases == 1)
    5732                 :         67 :     return this->lower_one_case(b);
    5733                 :            : 
    5734                 :            :   // Two-case select with one default case.  It is a non-blocking
    5735                 :            :   // send/receive.
    5736                 :       2360 :   if (ncases == 2
    5737                 :       2360 :       && (this->clauses_->at(0).is_default()
    5738                 :       1135 :           || this->clauses_->at(1).is_default()))
    5739                 :        520 :     return this->lower_two_case(b);
    5740                 :            : 
    5741                 :       1840 :   Type* scase_type = Channel_type::select_case_type();
    5742                 :       1840 :   Expression* ncases_expr =
    5743                 :       1840 :     Expression::make_integer_ul(ncases, NULL,
    5744                 :            :                                 Linemap::predeclared_location());
    5745                 :       1840 :   Array_type* scases_type = Type::make_array_type(scase_type, ncases_expr);
    5746                 :       1840 :   scases_type->set_is_array_incomparable();
    5747                 :            : 
    5748                 :       1840 :   Temporary_statement* scases = Statement::make_temporary(scases_type, NULL,
    5749                 :            :                                                           loc);
    5750                 :       1840 :   b->add_statement(scases);
    5751                 :            : 
    5752                 :       1840 :   Expression* ncases2_expr =
    5753                 :       1840 :     Expression::make_integer_ul(ncases * 2, NULL,
    5754                 :            :                                 Linemap::predeclared_location());
    5755                 :       1840 :   Type* uint16_type = Type::lookup_integer_type("uint16");
    5756                 :       1840 :   Array_type* order_type = Type::make_array_type(uint16_type, ncases2_expr);
    5757                 :       1840 :   order_type->set_is_array_incomparable();
    5758                 :            : 
    5759                 :       1840 :   Temporary_statement* order = Statement::make_temporary(order_type, NULL,
    5760                 :            :                                                          loc);
    5761                 :       1840 :   b->add_statement(order);
    5762                 :            : 
    5763                 :       1840 :   Type* int_type = Type::lookup_integer_type("int");
    5764                 :       1840 :   this->index_ = Statement::make_temporary(int_type, NULL, loc);
    5765                 :       1840 :   b->add_statement(this->index_);
    5766                 :            : 
    5767                 :       1840 :   Type* bool_type = Type::lookup_bool_type();
    5768                 :       1840 :   Temporary_statement* recvok = Statement::make_temporary(bool_type, NULL,
    5769                 :            :                                                           loc);
    5770                 :       1840 :   b->add_statement(recvok);
    5771                 :            : 
    5772                 :            :   // Initialize the scases array.
    5773                 :       1840 :   this->clauses_->lower(gogo, function, b, scases, recvok);
    5774                 :            : 
    5775                 :            :   // Build the call to selectgo.  Later, in do_get_backend, we will
    5776                 :            :   // build a switch on the result that branches to the various cases.
    5777                 :            : 
    5778                 :       1840 :   Expression* scases_ref = Expression::make_temporary_reference(scases, loc);
    5779                 :       1840 :   scases_ref = Expression::make_unary(OPERATOR_AND, scases_ref, loc);
    5780                 :       1840 :   Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
    5781                 :       1840 :   scases_ref = Expression::make_cast(unsafe_pointer_type, scases_ref, loc);
    5782                 :            : 
    5783                 :       1840 :   Expression* order_ref = Expression::make_temporary_reference(order, loc);
    5784                 :       1840 :   order_ref = Expression::make_unary(OPERATOR_AND, order_ref, loc);
    5785                 :       1840 :   order_ref = Expression::make_cast(unsafe_pointer_type, order_ref, loc);
    5786                 :            : 
    5787                 :       1840 :   Expression* count_expr = Expression::make_integer_ul(ncases, int_type, loc);
    5788                 :            : 
    5789                 :       1840 :   Call_expression* call = Runtime::make_call(Runtime::SELECTGO, loc, 3,
    5790                 :            :                                              scases_ref, order_ref,
    5791                 :            :                                              count_expr);
    5792                 :            : 
    5793                 :       1840 :   Expression* result = Expression::make_call_result(call, 0);
    5794                 :       1840 :   Expression* ref = Expression::make_temporary_reference(this->index_, loc);
    5795                 :       1840 :   Statement* s = Statement::make_assignment(ref, result, loc);
    5796                 :       1840 :   b->add_statement(s);
    5797                 :            : 
    5798                 :       1840 :   result = Expression::make_call_result(call, 1);
    5799                 :       1840 :   ref = Expression::make_temporary_reference(recvok, loc);
    5800                 :       1840 :   s = Statement::make_assignment(ref, result, loc);
    5801                 :       1840 :   b->add_statement(s);
    5802                 :            : 
    5803                 :       1840 :   this->is_lowered_ = true;
    5804                 :       1840 :   b->add_statement(this);
    5805                 :            : 
    5806                 :       1840 :   return Statement::make_block_statement(b, loc);
    5807                 :            : }
    5808                 :            : 
    5809                 :            : // Lower a one-case select statement.
    5810                 :            : 
    5811                 :            : Statement*
    5812                 :         67 : Select_statement::lower_one_case(Block* b)
    5813                 :            : {
    5814                 :         67 :   Select_clauses::Select_clause& scase = this->clauses_->at(0);
    5815                 :         67 :   Location loc = this->location();
    5816                 :         67 :   Expression* chan = scase.channel();
    5817                 :         67 :   if (chan != NULL)
    5818                 :            :     {
    5819                 :            :       // Lower this to
    5820                 :            :       //   if chan == nil { block() }; send/recv; body
    5821                 :         57 :       Temporary_statement* chantmp = Statement::make_temporary(NULL, chan, loc);
    5822                 :         57 :       b->add_statement(chantmp);
    5823                 :         57 :       Expression* chanref = Expression::make_temporary_reference(chantmp, loc);
    5824                 :            : 
    5825                 :         57 :       Expression* nil = Expression::make_nil(loc);
    5826                 :         57 :       Expression* cond = Expression::make_binary(OPERATOR_EQEQ, chanref, nil, loc);
    5827                 :         57 :       Block* bnil = new Block(b, loc);
    5828                 :         57 :       Expression* call = Runtime::make_call(Runtime::BLOCK, loc, 0);
    5829                 :         57 :       Statement* s = Statement::make_statement(call, false);
    5830                 :         57 :       bnil->add_statement(s);
    5831                 :         57 :       Statement* ifs = Statement::make_if_statement(cond, bnil, NULL, loc);
    5832                 :         57 :       b->add_statement(ifs);
    5833                 :            : 
    5834                 :         57 :       chanref = chanref->copy();
    5835                 :         57 :       Location cloc = scase.location();
    5836                 :         57 :       if (scase.is_send())
    5837                 :            :         {
    5838                 :          7 :           s = Statement::make_send_statement(chanref, scase.val(), cloc);
    5839                 :          7 :           b->add_statement(s);
    5840                 :            :         }
    5841                 :            :       else
    5842                 :            :         {
    5843                 :         50 :           if (scase.closed() == NULL && scase.closedvar() == NULL)
    5844                 :            :             {
    5845                 :            :               // Simple receive.
    5846                 :         48 :               Expression* recv = Expression::make_receive(chanref, cloc);
    5847                 :         48 :               if (scase.val() != NULL)
    5848                 :          8 :                 s = Statement::make_assignment(scase.val(), recv, cloc);
    5849                 :         40 :               else if (scase.var() != NULL)
    5850                 :            :                 {
    5851                 :          7 :                   Temporary_statement *ts =
    5852                 :          7 :                     Statement::make_temporary(NULL, recv, cloc);
    5853                 :          7 :                   Expression* ref =
    5854                 :          7 :                     Expression::make_temporary_reference(ts, cloc);
    5855                 :          7 :                   s = ts;
    5856                 :          7 :                   scase.var()->var_value()->set_init(ref);
    5857                 :          7 :                   scase.var()->var_value()->clear_type_from_chan_element();
    5858                 :            :                 }
    5859                 :            :               else
    5860                 :         33 :                 s = Statement::make_statement(recv, false);
    5861                 :         48 :               b->add_statement(s);
    5862                 :            :             }
    5863                 :            :           else
    5864                 :            :             {
    5865                 :            :               // Tuple receive.
    5866                 :          2 :               Expression* lhs;
    5867                 :          2 :               if (scase.val() != NULL)
    5868                 :          2 :                 lhs = scase.val();
    5869                 :            :               else
    5870                 :            :                 {
    5871                 :          4 :                   Type* valtype = chan->type()->channel_type()->element_type();
    5872                 :          2 :                   Temporary_statement *ts =
    5873                 :          2 :                     Statement::make_temporary(valtype, NULL, cloc);
    5874                 :          2 :                   lhs = Expression::make_temporary_reference(ts, cloc);
    5875                 :          2 :                   b->add_statement(ts);
    5876                 :            :                 }
    5877                 :            : 
    5878                 :          2 :               Expression* lhs2;
    5879                 :          2 :               if (scase.closed() != NULL)
    5880                 :          2 :                 lhs2 = scase.closed();
    5881                 :            :               else
    5882                 :            :                 {
    5883                 :          2 :                   Type* booltype = Type::make_boolean_type();
    5884                 :          2 :                   Temporary_statement *ts =
    5885                 :          2 :                     Statement::make_temporary(booltype, NULL, cloc);
    5886                 :          2 :                   lhs2 = Expression::make_temporary_reference(ts, cloc);
    5887                 :          2 :                   b->add_statement(ts);
    5888                 :            :                 }
    5889                 :            : 
    5890                 :          2 :               s = Statement::make_tuple_receive_assignment(lhs, lhs2, chanref, cloc);
    5891                 :          2 :               b->add_statement(s);
    5892                 :            : 
    5893                 :          2 :               if (scase.var() != NULL)
    5894                 :            :                 {
    5895                 :          2 :                   scase.var()->var_value()->set_init(lhs->copy());
    5896                 :          2 :                   scase.var()->var_value()->clear_type_from_chan_element();
    5897                 :            :                 }
    5898                 :            : 
    5899                 :          2 :               if (scase.closedvar() != NULL)
    5900                 :         57 :                 scase.closedvar()->var_value()->set_init(lhs2->copy());
    5901                 :            :             }
    5902                 :            :         }
    5903                 :            :     }
    5904                 :            : 
    5905                 :         67 :   Statement* bs =
    5906                 :         67 :     Statement::make_block_statement(scase.statements(), scase.location());
    5907                 :         67 :   b->add_statement(bs);
    5908                 :            : 
    5909                 :         67 :   Statement* label =
    5910                 :         67 :     Statement::make_unnamed_label_statement(this->break_label());
    5911                 :         67 :   b->add_statement(label);
    5912                 :            : 
    5913                 :         67 :   this->is_lowered_ = true;
    5914                 :         67 :   return Statement::make_block_statement(b, loc);
    5915                 :            : }
    5916                 :            : 
    5917                 :            : // Lower a two-case select statement with one default case.
    5918                 :            : 
    5919                 :            : Statement*
    5920                 :        520 : Select_statement::lower_two_case(Block* b)
    5921                 :            : {
    5922                 :        520 :   Select_clauses::Select_clause& chancase =
    5923                 :        520 :     (this->clauses_->at(0).is_default()
    5924                 :        520 :      ? this->clauses_->at(1)
    5925                 :        427 :      : this->clauses_->at(0));
    5926                 :        520 :   Select_clauses::Select_clause& defcase =
    5927                 :        520 :     (this->clauses_->at(0).is_default()
    5928                 :        520 :      ? this->clauses_->at(0)
    5929                 :        427 :      : this->clauses_->at(1));
    5930                 :        520 :   Location loc = this->location();
    5931                 :        520 :   Expression* chan = chancase.channel();
    5932                 :       1040 :   Type* valtype = chan->type()->channel_type()->element_type();
    5933                 :            : 
    5934                 :        520 :   Temporary_statement* chantmp = Statement::make_temporary(NULL, chan, loc);
    5935                 :        520 :   b->add_statement(chantmp);
    5936                 :        520 :   Expression* chanref = Expression::make_temporary_reference(chantmp, loc);
    5937                 :            : 
    5938                 :        520 :   Block* bchan;
    5939                 :        520 :   Expression* call;
    5940                 :        520 :   if (chancase.is_send())
    5941                 :            :     {
    5942                 :            :       // if selectnbsend(chan, &val) { body } else { default body }
    5943                 :            : 
    5944                 :        116 :       Temporary_statement* ts =
    5945                 :        116 :         Statement::make_temporary(valtype, chancase.val(), loc);
    5946                 :            :       // Tell the escape analysis that the value escapes, as it may be sent
    5947                 :            :       // to a channel.
    5948                 :        116 :       ts->set_value_escapes();
    5949                 :        116 :       b->add_statement(ts);
    5950                 :            : 
    5951                 :        116 :       Expression* ref = Expression::make_temporary_reference(ts, loc);
    5952                 :        116 :       Expression* addr = Expression::make_unary(OPERATOR_AND, ref, loc);
    5953                 :        116 :       call = Runtime::make_call(Runtime::SELECTNBSEND, loc, 2, chanref, addr);
    5954                 :        116 :       bchan = chancase.statements();
    5955                 :            :     }
    5956                 :            :   else
    5957                 :            :     {
    5958                 :        404 :       Temporary_statement* ts = Statement::make_temporary(valtype, NULL, loc);
    5959                 :        404 :       b->add_statement(ts);
    5960                 :            : 
    5961                 :        404 :       Expression* ref = Expression::make_temporary_reference(ts, loc);
    5962                 :        404 :       Expression* addr = Expression::make_unary(OPERATOR_AND, ref, loc);
    5963                 :        404 :       Expression* okref = NULL;
    5964                 :        404 :       if (chancase.closed() == NULL && chancase.closedvar() == NULL)
    5965                 :            :         {
    5966                 :            :           // Simple receive.
    5967                 :            :           // if selectnbrecv(&lhs, chan) { body } else { default body }
    5968                 :        396 :           call = Runtime::make_call(Runtime::SELECTNBRECV, loc, 2, addr, chanref);
    5969                 :            :         }
    5970                 :            :       else
    5971                 :            :         {
    5972                 :            :           // Tuple receive.
    5973                 :            :           // if selectnbrecv2(&lhs, &ok, chan) { body } else { default body }
    5974                 :            : 
    5975                 :          8 :           Type* booltype = Type::make_boolean_type();
    5976                 :          8 :           Temporary_statement* okts = Statement::make_temporary(booltype, NULL,
    5977                 :            :                                                                 loc);
    5978                 :          8 :           b->add_statement(okts);
    5979                 :            : 
    5980                 :          8 :           okref = Expression::make_temporary_reference(okts, loc);
    5981                 :          8 :           Expression* okaddr = Expression::make_unary(OPERATOR_AND, okref, loc);
    5982                 :          8 :           call = Runtime::make_call(Runtime::SELECTNBRECV2, loc, 3, addr, okaddr,
    5983                 :            :                                     chanref);
    5984                 :            :         }
    5985                 :            : 
    5986                 :        404 :       Location cloc = chancase.location();
    5987                 :        404 :       bchan = new Block(b, loc);
    5988                 :        404 :       if (chancase.val() != NULL && !chancase.val()->is_sink_expression())
    5989                 :            :         {
    5990                 :         42 :           Statement* as = Statement::make_assignment(chancase.val(), ref->copy(),
    5991                 :            :                                                      cloc);
    5992                 :         42 :           bchan->add_statement(as);
    5993                 :            :         }
    5994                 :        362 :       else if (chancase.var() != NULL)
    5995                 :            :         {
    5996                 :         64 :           chancase.var()->var_value()->set_init(ref->copy());
    5997                 :         64 :           chancase.var()->var_value()->clear_type_from_chan_element();
    5998                 :            :         }
    5999                 :            : 
    6000                 :        404 :       if (chancase.closed() != NULL && !chancase.closed()->is_sink_expression())
    6001                 :            :         {
    6002                 :          0 :           Statement* as = Statement::make_assignment(chancase.closed(),
    6003                 :            :                                                      okref->copy(), cloc);
    6004                 :          0 :           bchan->add_statement(as);
    6005                 :            :         }
    6006                 :        404 :       else if (chancase.closedvar() != NULL)
    6007                 :          8 :         chancase.closedvar()->var_value()->set_init(okref->copy());
    6008                 :            : 
    6009                 :        404 :       Statement* bs = Statement::make_block_statement(chancase.statements(),
    6010                 :            :                                                       cloc);
    6011                 :        404 :       bchan->add_statement(bs);
    6012                 :            :     }
    6013                 :            : 
    6014                 :        520 :   Statement* ifs =
    6015                 :        520 :     Statement::make_if_statement(call, bchan, defcase.statements(), loc);
    6016                 :        520 :   b->add_statement(ifs);
    6017                 :            : 
    6018                 :        520 :   Statement* label =
    6019                 :        520 :     Statement::make_unnamed_label_statement(this->break_label());
    6020                 :        520 :   b->add_statement(label);
    6021                 :            : 
    6022                 :        520 :   this->is_lowered_ = true;
    6023                 :        520 :   return Statement::make_block_statement(b, loc);
    6024                 :            : }
    6025                 :            : 
    6026                 :            : // Whether the select statement itself may fall through to the following
    6027                 :            : // statement.
    6028                 :            : 
    6029                 :            : bool
    6030                 :        213 : Select_statement::do_may_fall_through() const
    6031                 :            : {
    6032                 :            :   // A select statement is terminating if no break statement
    6033                 :            :   // refers to it and all of its clauses are terminating.
    6034                 :        213 :   if (this->break_label_ != NULL)
    6035                 :            :     return true;
    6036                 :        193 :   return this->clauses_->may_fall_through();
    6037                 :            : }
    6038                 :            : 
    6039                 :            : // Return the backend representation for a select statement.
    6040                 :            : 
    6041                 :            : Bstatement*
    6042                 :       1834 : Select_statement::do_get_backend(Translate_context* context)
    6043                 :            : {
    6044                 :       1834 :   return this->clauses_->get_backend(context, this->index_,
    6045                 :       1834 :                                      this->break_label(), this->location());
    6046                 :            : }
    6047                 :            : 
    6048                 :            : // Dump the AST representation for a select statement.
    6049                 :            : 
    6050                 :            : void
    6051                 :          0 : Select_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    6052                 :            : {
    6053                 :          0 :   ast_dump_context->print_indent();
    6054                 :          0 :   ast_dump_context->ostream() << "select";
    6055                 :          0 :   if (ast_dump_context->dump_subblocks())
    6056                 :            :     {
    6057                 :          0 :       ast_dump_context->ostream() << " {" << dsuffix(location()) << std::endl;
    6058                 :          0 :       this->clauses_->dump_clauses(ast_dump_context);
    6059                 :          0 :       ast_dump_context->print_indent();
    6060                 :          0 :       ast_dump_context->ostream() << "}";
    6061                 :            :     }
    6062                 :          0 :   ast_dump_context->ostream() << std::endl;
    6063                 :          0 : }
    6064                 :            : 
    6065                 :            : // Make a select statement.
    6066                 :            : 
    6067                 :            : Select_statement*
    6068                 :       2475 : Statement::make_select_statement(Location location)
    6069                 :            : {
    6070                 :       2475 :   return new Select_statement(location);
    6071                 :            : }
    6072                 :            : 
    6073                 :            : // Class For_statement.
    6074                 :            : 
    6075                 :            : // Traversal.
    6076                 :            : 
    6077                 :            : int
    6078                 :      79406 : For_statement::do_traverse(Traverse* traverse)
    6079                 :            : {
    6080                 :      79406 :   if (this->init_ != NULL)
    6081                 :            :     {
    6082                 :      27950 :       if (this->init_->traverse(traverse) == TRAVERSE_EXIT)
    6083                 :            :         return TRAVERSE_EXIT;
    6084                 :            :     }
    6085                 :      79406 :   if (this->cond_ != NULL)
    6086                 :            :     {
    6087                 :      72608 :       if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT)
    6088                 :            :         return TRAVERSE_EXIT;
    6089                 :            :     }
    6090                 :      79406 :   if (this->post_ != NULL)
    6091                 :            :     {
    6092                 :      61132 :       if (this->post_->traverse(traverse) == TRAVERSE_EXIT)
    6093                 :            :         return TRAVERSE_EXIT;
    6094                 :            :     }
    6095                 :      79406 :   return this->statements_->traverse(traverse);
    6096                 :            : }
    6097                 :            : 
    6098                 :            : // Lower a For_statement into if statements and gotos.  Getting rid of
    6099                 :            : // complex statements make it easier to handle garbage collection.
    6100                 :            : 
    6101                 :            : Statement*
    6102                 :      53729 : For_statement::do_lower(Gogo*, Named_object*, Block* enclosing,
    6103                 :            :                         Statement_inserter*)
    6104                 :            : {
    6105                 :      53729 :   Statement* s;
    6106                 :      53729 :   Location loc = this->location();
    6107                 :            : 
    6108                 :      53729 :   Block* b = new Block(enclosing, this->location());
    6109                 :      53729 :   if (this->init_ != NULL)
    6110                 :            :     {
    6111                 :      55900 :       s = Statement::make_block_statement(this->init_,
    6112                 :      27950 :                                           this->init_->start_location());
    6113                 :      27950 :       b->add_statement(s);
    6114                 :            :     }
    6115                 :            : 
    6116                 :      53729 :   Unnamed_label* entry = NULL;
    6117                 :      53729 :   if (this->cond_ != NULL)
    6118                 :            :     {
    6119                 :      50279 :       entry = new Unnamed_label(this->location());
    6120                 :      50279 :       b->add_statement(Statement::make_goto_unnamed_statement(entry, loc));
    6121                 :            :     }
    6122                 :            : 
    6123                 :      53729 :   Unnamed_label* top = new Unnamed_label(this->location());
    6124                 :      53729 :   top->set_derived_from(this);
    6125                 :      53729 :   b->add_statement(Statement::make_unnamed_label_statement(top));
    6126                 :            : 
    6127                 :     107458 :   s = Statement::make_block_statement(this->statements_,
    6128                 :      53729 :                                       this->statements_->start_location());
    6129                 :      53729 :   b->add_statement(s);
    6130                 :            : 
    6131                 :      53729 :   Location end_loc = this->statements_->end_location();
    6132                 :            : 
    6133                 :      53729 :   Unnamed_label* cont = this->continue_label_;
    6134                 :      53729 :   if (cont != NULL)
    6135                 :       5439 :     b->add_statement(Statement::make_unnamed_label_statement(cont));
    6136                 :            : 
    6137                 :      53729 :   if (this->post_ != NULL)
    6138                 :            :     {
    6139                 :      89082 :       s = Statement::make_block_statement(this->post_,
    6140                 :      44541 :                                           this->post_->start_location());
    6141                 :      44541 :       b->add_statement(s);
    6142                 :      44541 :       end_loc = this->post_->end_location();
    6143                 :            :     }
    6144                 :            : 
    6145                 :      53729 :   if (this->cond_ == NULL)
    6146                 :       3450 :     b->add_statement(Statement::make_goto_unnamed_statement(top, end_loc));
    6147                 :            :   else
    6148                 :            :     {
    6149                 :      50279 :       b->add_statement(Statement::make_unnamed_label_statement(entry));
    6150                 :            : 
    6151                 :      50279 :       Location cond_loc = this->cond_->location();
    6152                 :      50279 :       Block* then_block = new Block(b, cond_loc);
    6153                 :      50279 :       s = Statement::make_goto_unnamed_statement(top, cond_loc);
    6154                 :      50279 :       then_block->add_statement(s);
    6155                 :            : 
    6156                 :      50279 :       s = Statement::make_if_statement(this->cond_, then_block, NULL, cond_loc);
    6157                 :      50279 :       b->add_statement(s);
    6158                 :            :     }
    6159                 :            : 
    6160                 :      53729 :   Unnamed_label* brk = this->break_label_;
    6161                 :      53729 :   if (brk != NULL)
    6162                 :       5096 :     b->add_statement(Statement::make_unnamed_label_statement(brk));
    6163                 :            : 
    6164                 :      53729 :   b->set_end_location(end_loc);
    6165                 :            : 
    6166                 :      53729 :   Statement* bs = Statement::make_block_statement(b, loc);
    6167                 :      53729 :   bs->block_statement()->set_is_lowered_for_statement();
    6168                 :      53729 :   return bs;
    6169                 :            : }
    6170                 :            : 
    6171                 :            : // Return the break label, creating it if necessary.
    6172                 :            : 
    6173                 :            : Unnamed_label*
    6174                 :       4957 : For_statement::break_label()
    6175                 :            : {
    6176                 :       4957 :   if (this->break_label_ == NULL)
    6177                 :       3886 :     this->break_label_ = new Unnamed_label(this->location());
    6178                 :       4957 :   return this->break_label_;
    6179                 :            : }
    6180                 :            : 
    6181                 :            : // Return the continue LABEL_EXPR.
    6182                 :            : 
    6183                 :            : Unnamed_label*
    6184                 :       4236 : For_statement::continue_label()
    6185                 :            : {
    6186                 :       4236 :   if (this->continue_label_ == NULL)
    6187                 :       2504 :     this->continue_label_ = new Unnamed_label(this->location());
    6188                 :       4236 :   return this->continue_label_;
    6189                 :            : }
    6190                 :            : 
    6191                 :            : // Set the break and continue labels a for statement.  This is used
    6192                 :            : // when lowering a for range statement.
    6193                 :            : 
    6194                 :            : void
    6195                 :      28052 : For_statement::set_break_continue_labels(Unnamed_label* break_label,
    6196                 :            :                                          Unnamed_label* continue_label)
    6197                 :            : {
    6198                 :      28052 :   go_assert(this->break_label_ == NULL && this->continue_label_ == NULL);
    6199                 :      28052 :   this->break_label_ = break_label;
    6200                 :      28052 :   this->continue_label_ = continue_label;
    6201                 :      28052 : }
    6202                 :            : 
    6203                 :            : // Whether the overall statement may fall through.
    6204                 :            : 
    6205                 :            : bool
    6206                 :        851 : For_statement::do_may_fall_through() const
    6207                 :            : {
    6208                 :            :   // A for loop is terminating if it has no condition and
    6209                 :            :   // no break statement.
    6210                 :        851 :   if(this->cond_ != NULL)
    6211                 :            :     return true;
    6212                 :        827 :   if(this->break_label_ != NULL)
    6213                 :         12 :     return true;
    6214                 :            :   return false;
    6215                 :            : }
    6216                 :            : 
    6217                 :            : // Dump the AST representation for a for statement.
    6218                 :            : 
    6219                 :            : void
    6220                 :          0 : For_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    6221                 :            : {
    6222                 :          0 :   if (this->init_ != NULL && ast_dump_context->dump_subblocks())
    6223                 :            :     {
    6224                 :          0 :       ast_dump_context->print_indent();
    6225                 :          0 :       ast_dump_context->indent();
    6226                 :          0 :       ast_dump_context->ostream() << "// INIT  " << std::endl;
    6227                 :          0 :       ast_dump_context->dump_block(this->init_);
    6228                 :          0 :       ast_dump_context->unindent();
    6229                 :            :     }
    6230                 :          0 :   ast_dump_context->print_indent();
    6231                 :          0 :   ast_dump_context->ostream() << "for ";
    6232                 :          0 :   if (this->cond_ != NULL)
    6233                 :          0 :     ast_dump_context->dump_expression(this->cond_);
    6234                 :            : 
    6235                 :          0 :   if (ast_dump_context->dump_subblocks())
    6236                 :            :     {
    6237                 :          0 :       ast_dump_context->ostream() << " {" << std::endl;
    6238                 :          0 :       ast_dump_context->dump_block(this->statements_);
    6239                 :          0 :       if (this->init_ != NULL)
    6240                 :            :         {
    6241                 :          0 :           ast_dump_context->print_indent();
    6242                 :          0 :           ast_dump_context->ostream() << "// POST " << std::endl;
    6243                 :          0 :           ast_dump_context->dump_block(this->post_);
    6244                 :            :         }
    6245                 :          0 :       ast_dump_context->unindent();
    6246                 :            : 
    6247                 :          0 :       ast_dump_context->print_indent();
    6248                 :          0 :       ast_dump_context->ostream() << "}";
    6249                 :            :     }
    6250                 :            : 
    6251                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    6252                 :          0 : }
    6253                 :            : 
    6254                 :            : // Make a for statement.
    6255                 :            : 
    6256                 :            : For_statement*
    6257                 :      53729 : Statement::make_for_statement(Block* init, Expression* cond, Block* post,
    6258                 :            :                               Location location)
    6259                 :            : {
    6260                 :      53729 :   return new For_statement(init, cond, post, location);
    6261                 :            : }
    6262                 :            : 
    6263                 :            : // Class For_range_statement.
    6264                 :            : 
    6265                 :            : // Traversal.
    6266                 :            : 
    6267                 :            : int
    6268                 :      49801 : For_range_statement::do_traverse(Traverse* traverse)
    6269                 :            : {
    6270                 :      49801 :   if (this->index_var_ != NULL)
    6271                 :            :     {
    6272                 :      49647 :       if (this->traverse_expression(traverse, &this->index_var_)
    6273                 :            :           == TRAVERSE_EXIT)
    6274                 :            :         return TRAVERSE_EXIT;
    6275                 :            :     }
    6276                 :      49801 :   if (this->value_var_ != NULL)
    6277                 :            :     {
    6278                 :      37220 :       if (this->traverse_expression(traverse, &this->value_var_)
    6279                 :            :           == TRAVERSE_EXIT)
    6280                 :            :         return TRAVERSE_EXIT;
    6281                 :            :     }
    6282                 :      49801 :   if (this->traverse_expression(traverse, &this->range_) == TRAVERSE_EXIT)
    6283                 :            :     return TRAVERSE_EXIT;
    6284                 :      49801 :   return this->statements_->traverse(traverse);
    6285                 :            : }
    6286                 :            : 
    6287                 :            : // Lower a for range statement.  For simplicity we lower this into a
    6288                 :            : // for statement, which will then be lowered in turn to goto
    6289                 :            : // statements.
    6290                 :            : 
    6291                 :            : Statement*
    6292                 :      28336 : For_range_statement::do_lower(Gogo* gogo, Named_object*, Block* enclosing,
    6293                 :            :                               Statement_inserter*)
    6294                 :            : {
    6295                 :      28336 :   Type* range_type = this->range_->type();
    6296                 :      28336 :   if (range_type->points_to() != NULL
    6297                 :       7073 :       && range_type->points_to()->array_type() != NULL
    6298                 :      35409 :       && !range_type->points_to()->is_slice_type())
    6299                 :       7073 :     range_type = range_type->points_to();
    6300                 :            : 
    6301                 :      28336 :   Type* index_type;
    6302                 :      28336 :   Type* value_type = NULL;
    6303                 :      28336 :   if (range_type->array_type() != NULL)
    6304                 :            :     {
    6305                 :      25988 :       index_type = Type::lookup_integer_type("int");
    6306                 :      51976 :       value_type = range_type->array_type()->element_type();
    6307                 :            :     }
    6308                 :       2348 :   else if (range_type->is_string_type())
    6309                 :            :     {
    6310                 :        505 :       index_type = Type::lookup_integer_type("int");
    6311                 :        505 :       value_type = gogo->lookup_global("rune")->type_value();
    6312                 :            :     }
    6313                 :       1843 :   else if (range_type->map_type() != NULL)
    6314                 :            :     {
    6315                 :       3482 :       index_type = range_type->map_type()->key_type();
    6316                 :       3482 :       value_type = range_type->map_type()->val_type();
    6317                 :            :     }
    6318                 :        102 :   else if (range_type->channel_type() != NULL)
    6319                 :            :     {
    6320                 :        204 :       index_type = range_type->channel_type()->element_type();
    6321                 :        102 :       if (this->value_var_ != NULL)
    6322                 :            :         {
    6323                 :          0 :           if (!this->value_var_->type()->is_error())
    6324                 :          0 :             this->report_error(_("too many variables for range clause "
    6325                 :            :                                  "with channel"));
    6326                 :          0 :           return Statement::make_error_statement(this->location());
    6327                 :            :         }
    6328                 :            :     }
    6329                 :            :   else
    6330                 :            :     {
    6331                 :          0 :       this->report_error(_("range clause must have "
    6332                 :            :                            "array, slice, string, map, or channel type"));
    6333                 :          0 :       return Statement::make_error_statement(this->location());
    6334                 :            :     }
    6335                 :            : 
    6336                 :            :   // If there is only one iteration variable, and len(this->range_) is
    6337                 :            :   // constant, then we do not evaluate the range variable.  len(x) is
    6338                 :            :   // a contant if x is a string constant or if x is an array.  If x is
    6339                 :            :   // a constant then evaluating it won't make any difference, so the
    6340                 :            :   // only case to consider is when x is an array whose length is constant.
    6341                 :      28336 :   bool eval = true;
    6342                 :      18610 :   if ((this->value_var_ == NULL || this->value_var_->is_sink_expression())
    6343                 :      37427 :       && range_type->array_type() != NULL
    6344                 :       9091 :       && !range_type->is_slice_type()
    6345                 :      35739 :       && Builtin_call_expression::array_len_is_constant(this->range_))
    6346                 :            :     eval = false;
    6347                 :            : 
    6348                 :      28336 :   Location loc = this->location();
    6349                 :      28336 :   Block* temp_block = new Block(enclosing, loc);
    6350                 :            : 
    6351                 :      28336 :   Expression* orig_range_expr = this->range_;
    6352                 :      28336 :   Named_object* range_object = NULL;
    6353                 :      28336 :   Temporary_statement* range_temp = NULL;
    6354                 :      28336 :   if (eval)
    6355                 :            :     {
    6356                 :      20935 :       Var_expression* ve = this->range_->var_expression();
    6357                 :      12284 :       if (ve != NULL)
    6358                 :      12284 :         range_object = ve->named_object();
    6359                 :            :       else
    6360                 :            :         {
    6361                 :       8651 :           range_temp = Statement::make_temporary(NULL, this->range_, loc);
    6362                 :       8651 :           temp_block->add_statement(range_temp);
    6363                 :       8651 :           this->range_ = NULL;
    6364                 :            :         }
    6365                 :            :     }
    6366                 :            : 
    6367                 :            :   // Try to match "range clear" patterns and rewrite to simple runtime
    6368                 :            :   // calls.
    6369                 :      28336 :   if (range_type->map_type() != NULL)
    6370                 :            :     {
    6371                 :       1741 :       Statement* clear = this->lower_map_range_clear(range_type,
    6372                 :            :                                                      enclosing,
    6373                 :            :                                                      orig_range_expr,
    6374                 :            :                                                      range_object,
    6375                 :            :                                                      range_temp, loc);
    6376                 :       1741 :       if (clear != NULL)
    6377                 :            :         {
    6378                 :         25 :           if (gogo->debug_optimization())
    6379                 :          1 :             go_debug(loc, "map range clear");
    6380                 :         25 :           temp_block->add_statement(clear);
    6381                 :         25 :           return Statement::make_block_statement(temp_block, loc);
    6382                 :            :         }
    6383                 :            :     }
    6384                 :      26595 :   else if (range_type->array_type() != NULL)
    6385                 :            :     {
    6386                 :            :       // Slice or array.
    6387                 :      25988 :       Statement* clear = this->lower_array_range_clear(gogo,
    6388                 :            :                                                        range_type,
    6389                 :            :                                                        orig_range_expr,
    6390                 :            :                                                        temp_block,
    6391                 :            :                                                        range_object,
    6392                 :            :                                                        range_temp, loc);
    6393                 :      25988 :       if (clear != NULL)
    6394                 :            :         {
    6395                 :        259 :           if (gogo->debug_optimization())
    6396                 :          2 :             go_debug(loc, "array range clear");
    6397                 :        259 :           temp_block->add_statement(clear);
    6398                 :        259 :           return Statement::make_block_statement(temp_block, loc);
    6399                 :            :         }
    6400                 :            :     }
    6401                 :            : 
    6402                 :      28052 :   Temporary_statement* index_temp = Statement::make_temporary(index_type,
    6403                 :            :                                                               NULL, loc);
    6404                 :      28052 :   temp_block->add_statement(index_temp);
    6405                 :            : 
    6406                 :      28052 :   Temporary_statement* value_temp = NULL;
    6407                 :      28052 :   if (this->value_var_ != NULL && !this->value_var_->is_sink_expression())
    6408                 :            :     {
    6409                 :      18607 :       value_temp = Statement::make_temporary(value_type, NULL, loc);
    6410                 :      18607 :       temp_block->add_statement(value_temp);
    6411                 :            :     }
    6412                 :            : 
    6413                 :      28052 :   Block* body = new Block(temp_block, loc);
    6414                 :            : 
    6415                 :      28052 :   Block* init;
    6416                 :      28052 :   Expression* cond;
    6417                 :      28052 :   Block* iter_init;
    6418                 :      28052 :   Block* post;
    6419                 :            : 
    6420                 :            :   // Arrange to do a loop appropriate for the type.  We will produce
    6421                 :            :   //   for INIT ; COND ; POST {
    6422                 :            :   //           ITER_INIT
    6423                 :            :   //           INDEX = INDEX_TEMP
    6424                 :            :   //           VALUE = VALUE_TEMP // If there is a value
    6425                 :            :   //           original statements
    6426                 :            :   //   }
    6427                 :            : 
    6428                 :      28052 :   if (range_type->is_slice_type())
    6429                 :      17945 :     this->lower_range_slice(gogo, temp_block, body, range_object, range_temp,
    6430                 :            :                             index_temp, value_temp, &init, &cond, &iter_init,
    6431                 :            :                             &post);
    6432                 :      10107 :   else if (range_type->array_type() != NULL)
    6433                 :       7784 :     this->lower_range_array(gogo, temp_block, body, range_object, range_temp,
    6434                 :            :                             index_temp, value_temp, &init, &cond, &iter_init,
    6435                 :            :                             &post);
    6436                 :       2323 :   else if (range_type->is_string_type())
    6437                 :        505 :     this->lower_range_string(gogo, temp_block, body, range_object, range_temp,
    6438                 :            :                              index_temp, value_temp, &init, &cond, &iter_init,
    6439                 :            :                              &post);
    6440                 :       1818 :   else if (range_type->map_type() != NULL)
    6441                 :       3432 :     this->lower_range_map(gogo, range_type->map_type(), temp_block, body,
    6442                 :            :                           range_object, range_temp, index_temp, value_temp,
    6443                 :            :                           &init, &cond, &iter_init, &post);
    6444                 :        102 :   else if (range_type->channel_type() != NULL)
    6445                 :        102 :     this->lower_range_channel(gogo, temp_block, body, range_object, range_temp,
    6446                 :            :                               index_temp, value_temp, &init, &cond, &iter_init,
    6447                 :            :                               &post);
    6448                 :            :   else
    6449                 :          0 :     go_unreachable();
    6450                 :            : 
    6451                 :      28052 :   if (iter_init != NULL)
    6452                 :      19220 :     body->add_statement(Statement::make_block_statement(iter_init, loc));
    6453                 :            : 
    6454                 :      28052 :   if (this->index_var_ != NULL)
    6455                 :            :     {
    6456                 :      27975 :       Statement* assign;
    6457                 :      27975 :       Expression* index_ref =
    6458                 :      27975 :         Expression::make_temporary_reference(index_temp, loc);
    6459                 :      27975 :       if (this->value_var_ == NULL || this->value_var_->is_sink_expression())
    6460                 :       9368 :         assign = Statement::make_assignment(this->index_var_, index_ref, loc);
    6461                 :            :       else
    6462                 :            :         {
    6463                 :      18607 :           Expression_list* lhs = new Expression_list();
    6464                 :      18607 :           lhs->push_back(this->index_var_);
    6465                 :      18607 :           lhs->push_back(this->value_var_);
    6466                 :            : 
    6467                 :      18607 :           Expression_list* rhs = new Expression_list();
    6468                 :      18607 :           rhs->push_back(index_ref);
    6469                 :      18607 :           rhs->push_back(Expression::make_temporary_reference(value_temp, loc));
    6470                 :            : 
    6471                 :      18607 :           assign = Statement::make_tuple_assignment(lhs, rhs, loc);
    6472                 :            :         }
    6473                 :      27975 :       body->add_statement(assign);
    6474                 :            :     }
    6475                 :            : 
    6476                 :      28052 :   body->add_statement(Statement::make_block_statement(this->statements_, loc));
    6477                 :            : 
    6478                 :      28052 :   body->set_end_location(this->statements_->end_location());
    6479                 :            : 
    6480                 :      28052 :   For_statement* loop = Statement::make_for_statement(init, cond, post,
    6481                 :            :                                                       this->location());
    6482                 :      28052 :   loop->add_statements(body);
    6483                 :      28052 :   loop->set_break_continue_labels(this->break_label_, this->continue_label_);
    6484                 :            : 
    6485                 :      28052 :   temp_block->add_statement(loop);
    6486                 :            : 
    6487                 :      28052 :   return Statement::make_block_statement(temp_block, loc);
    6488                 :            : }
    6489                 :            : 
    6490                 :            : // Return a reference to the range, which may be in RANGE_OBJECT or in
    6491                 :            : // RANGE_TEMP.
    6492                 :            : 
    6493                 :            : Expression*
    6494                 :      21945 : For_range_statement::make_range_ref(Named_object* range_object,
    6495                 :            :                                     Temporary_statement* range_temp,
    6496                 :            :                                     Location loc)
    6497                 :            : {
    6498                 :      21945 :   if (range_object != NULL)
    6499                 :      13134 :     return Expression::make_var_reference(range_object, loc);
    6500                 :            :   else
    6501                 :       8811 :     return Expression::make_temporary_reference(range_temp, loc);
    6502                 :            : }
    6503                 :            : 
    6504                 :            : // Return a call to the predeclared function FUNCNAME passing a
    6505                 :            : // reference to the temporary variable ARG.
    6506                 :            : 
    6507                 :            : Call_expression*
    6508                 :      26493 : For_range_statement::call_builtin(Gogo* gogo, const char* funcname,
    6509                 :            :                                   Expression* arg,
    6510                 :            :                                   Location loc)
    6511                 :            : {
    6512                 :      26493 :   Named_object* no = gogo->lookup_global(funcname);
    6513                 :      26493 :   go_assert(no != NULL && no->is_function_declaration());
    6514                 :      26493 :   Expression* func = Expression::make_func_reference(no, NULL, loc);
    6515                 :      26493 :   Expression_list* params = new Expression_list();
    6516                 :      26493 :   params->push_back(arg);
    6517                 :      26493 :   return Expression::make_call(func, params, false, loc);
    6518                 :            : }
    6519                 :            : 
    6520                 :            : // Lower a for range over an array.
    6521                 :            : 
    6522                 :            : void
    6523                 :       7784 : For_range_statement::lower_range_array(Gogo* gogo,
    6524                 :            :                                        Block* enclosing,
    6525                 :            :                                        Block* body_block,
    6526                 :            :                                        Named_object* range_object,
    6527                 :            :                                        Temporary_statement* range_temp,
    6528                 :            :                                        Temporary_statement* index_temp,
    6529                 :            :                                        Temporary_statement* value_temp,
    6530                 :            :                                        Block** pinit,
    6531                 :            :                                        Expression** pcond,
    6532                 :            :                                        Block** piter_init,
    6533                 :            :                                        Block** ppost)
    6534                 :            : {
    6535                 :       7784 :   Location loc = this->location();
    6536                 :            : 
    6537                 :            :   // The loop we generate:
    6538                 :            :   //   len_temp := len(range)
    6539                 :            :   //   range_temp := range
    6540                 :            :   //   for index_temp = 0; index_temp < len_temp; index_temp++ {
    6541                 :            :   //           value_temp = range_temp[index_temp]
    6542                 :            :   //           index = index_temp
    6543                 :            :   //           value = value_temp
    6544                 :            :   //           original body
    6545                 :            :   //   }
    6546                 :            : 
    6547                 :            :   // Set *PINIT to
    6548                 :            :   //   var len_temp int
    6549                 :            :   //   len_temp = len(range)
    6550                 :            :   //   index_temp = 0
    6551                 :            : 
    6552                 :       7784 :   Block* init = new Block(enclosing, loc);
    6553                 :            : 
    6554                 :       7784 :   Expression* len_arg;
    6555                 :       7784 :   if (range_object == NULL && range_temp == NULL)
    6556                 :            :     {
    6557                 :            :       // Don't evaluate this->range_, just get its length.
    6558                 :       7311 :       len_arg = this->range_;
    6559                 :            :     }
    6560                 :            :   else
    6561                 :            :     {
    6562                 :        473 :       Expression* ref = this->make_range_ref(range_object, range_temp, loc);
    6563                 :        473 :       range_temp = Statement::make_temporary(NULL, ref, loc);
    6564                 :        473 :       init->add_statement(range_temp);
    6565                 :        473 :       len_arg = ref;
    6566                 :            :     }
    6567                 :       7784 :   Expression* len_call = this->call_builtin(gogo, "len", len_arg, loc);
    6568                 :       7784 :   Temporary_statement* len_temp = Statement::make_temporary(index_temp->type(),
    6569                 :            :                                                             len_call, loc);
    6570                 :       7784 :   init->add_statement(len_temp);
    6571                 :            : 
    6572                 :       7784 :   Expression* zexpr = Expression::make_integer_ul(0, NULL, loc);
    6573                 :            : 
    6574                 :       7784 :   Temporary_reference_expression* tref =
    6575                 :       7784 :     Expression::make_temporary_reference(index_temp, loc);
    6576                 :       7784 :   tref->set_is_lvalue();
    6577                 :       7784 :   Statement* s = Statement::make_assignment(tref, zexpr, loc);
    6578                 :       7784 :   init->add_statement(s);
    6579                 :            : 
    6580                 :       7784 :   *pinit = init;
    6581                 :            : 
    6582                 :            :   // Set *PCOND to
    6583                 :            :   //   index_temp < len_temp
    6584                 :            : 
    6585                 :       7784 :   Expression* ref = Expression::make_temporary_reference(index_temp, loc);
    6586                 :       7784 :   Expression* ref2 = Expression::make_temporary_reference(len_temp, loc);
    6587                 :       7784 :   Expression* lt = Expression::make_binary(OPERATOR_LT, ref, ref2, loc);
    6588                 :            : 
    6589                 :       7784 :   *pcond = lt;
    6590                 :            : 
    6591                 :            :   // Set *PITER_INIT to
    6592                 :            :   //   value_temp = range[index_temp]
    6593                 :            : 
    6594                 :       7784 :   Block* iter_init = NULL;
    6595                 :       7784 :   if (value_temp != NULL)
    6596                 :            :     {
    6597                 :        471 :       iter_init = new Block(body_block, loc);
    6598                 :            : 
    6599                 :        471 :       ref = Expression::make_temporary_reference(range_temp, loc);
    6600                 :        471 :       ref2 = Expression::make_temporary_reference(index_temp, loc);
    6601                 :        471 :       Expression* index = Expression::make_index(ref, ref2, NULL, NULL, loc);
    6602                 :            : 
    6603                 :        471 :       tref = Expression::make_temporary_reference(value_temp, loc);
    6604                 :        471 :       tref->set_is_lvalue();
    6605                 :        471 :       s = Statement::make_assignment(tref, index, loc);
    6606                 :            : 
    6607                 :        471 :       iter_init->add_statement(s);
    6608                 :            :     }
    6609                 :       7784 :   *piter_init = iter_init;
    6610                 :            : 
    6611                 :            :   // Set *PPOST to
    6612                 :            :   //   index_temp++
    6613                 :            : 
    6614                 :       7784 :   Block* post = new Block(enclosing, loc);
    6615                 :       7784 :   tref = Expression::make_temporary_reference(index_temp, loc);
    6616                 :       7784 :   tref->set_is_lvalue();
    6617                 :       7784 :   s = Statement::make_inc_statement(tref);
    6618                 :       7784 :   post->add_statement(s);
    6619                 :       7784 :   *ppost = post;
    6620                 :       7784 : }
    6621                 :            : 
    6622                 :            : // Lower a for range over a slice.
    6623                 :            : 
    6624                 :            : void
    6625                 :      17945 : For_range_statement::lower_range_slice(Gogo* gogo,
    6626                 :            :                                        Block* enclosing,
    6627                 :            :                                        Block* body_block,
    6628                 :            :                                        Named_object* range_object,
    6629                 :            :                                        Temporary_statement* range_temp,
    6630                 :            :                                        Temporary_statement* index_temp,
    6631                 :            :                                        Temporary_statement* value_temp,
    6632                 :            :                                        Block** pinit,
    6633                 :            :                                        Expression** pcond,
    6634                 :            :                                        Block** piter_init,
    6635                 :            :                                        Block** ppost)
    6636                 :            : {
    6637                 :      17945 :   Location loc = this->location();
    6638                 :            : 
    6639                 :            :   // The loop we generate:
    6640                 :            :   //   for_temp := range
    6641                 :            :   //   len_temp := len(for_temp)
    6642                 :            :   //   for index_temp = 0; index_temp < len_temp; index_temp++ {
    6643                 :            :   //           value_temp = for_temp[index_temp]
    6644                 :            :   //           index = index_temp
    6645                 :            :   //           value = value_temp
    6646                 :            :   //           original body
    6647                 :            :   //   }
    6648                 :            :   //
    6649                 :            :   // Using for_temp means that we don't need to check bounds when
    6650                 :            :   // fetching range_temp[index_temp].
    6651                 :            : 
    6652                 :            :   // Set *PINIT to
    6653                 :            :   //   range_temp := range
    6654                 :            :   //   var len_temp int
    6655                 :            :   //   len_temp = len(range_temp)
    6656                 :            :   //   index_temp = 0
    6657                 :            : 
    6658                 :      17945 :   Block* init = new Block(enclosing, loc);
    6659                 :            : 
    6660                 :      17945 :   Expression* ref = this->make_range_ref(range_object, range_temp, loc);
    6661                 :      17945 :   Temporary_statement* for_temp = Statement::make_temporary(NULL, ref, loc);
    6662                 :      17945 :   init->add_statement(for_temp);
    6663                 :            : 
    6664                 :      17945 :   ref = Expression::make_temporary_reference(for_temp, loc);
    6665                 :      17945 :   Expression* len_call = this->call_builtin(gogo, "len", ref, loc);
    6666                 :      17945 :   Temporary_statement* len_temp = Statement::make_temporary(index_temp->type(),
    6667                 :            :                                                             len_call, loc);
    6668                 :      17945 :   init->add_statement(len_temp);
    6669                 :            : 
    6670                 :      17945 :   Expression* zexpr = Expression::make_integer_ul(0, NULL, loc);
    6671                 :            : 
    6672                 :      17945 :   Temporary_reference_expression* tref =
    6673                 :      17945 :     Expression::make_temporary_reference(index_temp, loc);
    6674                 :      17945 :   tref->set_is_lvalue();
    6675                 :      17945 :   Statement* s = Statement::make_assignment(tref, zexpr, loc);
    6676                 :      17945 :   init->add_statement(s);
    6677                 :            : 
    6678                 :      17945 :   *pinit = init;
    6679                 :            : 
    6680                 :            :   // Set *PCOND to
    6681                 :            :   //   index_temp < len_temp
    6682                 :            : 
    6683                 :      17945 :   ref = Expression::make_temporary_reference(index_temp, loc);
    6684                 :      17945 :   Expression* ref2 = Expression::make_temporary_reference(len_temp, loc);
    6685                 :      17945 :   Expression* lt = Expression::make_binary(OPERATOR_LT, ref, ref2, loc);
    6686                 :            : 
    6687                 :      17945 :   *pcond = lt;
    6688                 :            : 
    6689                 :            :   // Set *PITER_INIT to
    6690                 :            :   //   value_temp = range[index_temp]
    6691                 :            : 
    6692                 :      17945 :   Block* iter_init = NULL;
    6693                 :      17945 :   if (value_temp != NULL)
    6694                 :            :     {
    6695                 :      16426 :       iter_init = new Block(body_block, loc);
    6696                 :            : 
    6697                 :      16426 :       ref = Expression::make_temporary_reference(for_temp, loc);
    6698                 :      16426 :       ref2 = Expression::make_temporary_reference(index_temp, loc);
    6699                 :      16426 :       Expression* index = Expression::make_index(ref, ref2, NULL, NULL, loc);
    6700                 :            : 
    6701                 :      16426 :       tref = Expression::make_temporary_reference(value_temp, loc);
    6702                 :      16426 :       tref->set_is_lvalue();
    6703                 :      16426 :       s = Statement::make_assignment(tref, index, loc);
    6704                 :            : 
    6705                 :      16426 :       iter_init->add_statement(s);
    6706                 :            :     }
    6707                 :      17945 :   *piter_init = iter_init;
    6708                 :            : 
    6709                 :            :   // Set *PPOST to
    6710                 :            :   //   index_temp++
    6711                 :            : 
    6712                 :      17945 :   Block* post = new Block(enclosing, loc);
    6713                 :      17945 :   tref = Expression::make_temporary_reference(index_temp, loc);
    6714                 :      17945 :   tref->set_is_lvalue();
    6715                 :      17945 :   s = Statement::make_inc_statement(tref);
    6716                 :      17945 :   post->add_statement(s);
    6717                 :      17945 :   *ppost = post;
    6718                 :      17945 : }
    6719                 :            : 
    6720                 :            : // Lower a for range over a string.
    6721                 :            : 
    6722                 :            : void
    6723                 :        505 : For_range_statement::lower_range_string(Gogo* gogo,
    6724                 :            :                                         Block* enclosing,
    6725                 :            :                                         Block* body_block,
    6726                 :            :                                         Named_object* range_object,
    6727                 :            :                                         Temporary_statement* range_temp,
    6728                 :            :                                         Temporary_statement* index_temp,
    6729                 :            :                                         Temporary_statement* value_temp,
    6730                 :            :                                         Block** pinit,
    6731                 :            :                                         Expression** pcond,
    6732                 :            :                                         Block** piter_init,
    6733                 :            :                                         Block** ppost)
    6734                 :            : {
    6735                 :        505 :   Location loc = this->location();
    6736                 :            : 
    6737                 :            :   // The loop we generate:
    6738                 :            :   //   len_temp := len(range)
    6739                 :            :   //   var next_index_temp int
    6740                 :            :   //   for index_temp = 0; index_temp < len_temp; index_temp = next_index_temp {
    6741                 :            :   //           value_temp = rune(range[index_temp])
    6742                 :            :   //           if value_temp < utf8.RuneSelf {
    6743                 :            :   //                   next_index_temp = index_temp + 1
    6744                 :            :   //           } else {
    6745                 :            :   //                   value_temp, next_index_temp = decoderune(range, index_temp)
    6746                 :            :   //           }
    6747                 :            :   //           index = index_temp
    6748                 :            :   //           value = value_temp
    6749                 :            :   //           // original body
    6750                 :            :   //   }
    6751                 :            : 
    6752                 :            :   // Set *PINIT to
    6753                 :            :   //   len_temp := len(range)
    6754                 :            :   //   var next_index_temp int
    6755                 :            :   //   index_temp = 0
    6756                 :            :   //   var value_temp rune // if value_temp not passed in
    6757                 :            : 
    6758                 :        505 :   Block* init = new Block(enclosing, loc);
    6759                 :            : 
    6760                 :        505 :   Expression* ref = this->make_range_ref(range_object, range_temp, loc);
    6761                 :        505 :   Call_expression* call = this->call_builtin(gogo, "len", ref, loc);
    6762                 :        505 :   Temporary_statement* len_temp =
    6763                 :        505 :     Statement::make_temporary(index_temp->type(), call, loc);
    6764                 :        505 :   init->add_statement(len_temp);
    6765                 :            : 
    6766                 :        505 :   Temporary_statement* next_index_temp =
    6767                 :        505 :     Statement::make_temporary(index_temp->type(), NULL, loc);
    6768                 :        505 :   init->add_statement(next_index_temp);
    6769                 :            : 
    6770                 :        505 :   Temporary_reference_expression* index_ref =
    6771                 :        505 :     Expression::make_temporary_reference(index_temp, loc);
    6772                 :        505 :   index_ref->set_is_lvalue();
    6773                 :        505 :   Expression* zexpr = Expression::make_integer_ul(0, index_temp->type(), loc);
    6774                 :        505 :   Statement* s = Statement::make_assignment(index_ref, zexpr, loc);
    6775                 :        505 :   init->add_statement(s);
    6776                 :            : 
    6777                 :        505 :   Type* rune_type;
    6778                 :        505 :   if (value_temp != NULL)
    6779                 :        469 :     rune_type = value_temp->type();
    6780                 :            :   else
    6781                 :            :     {
    6782                 :         36 :       rune_type = gogo->lookup_global("rune")->type_value();
    6783                 :         36 :       value_temp = Statement::make_temporary(rune_type, NULL, loc);
    6784                 :         36 :       init->add_statement(value_temp);
    6785                 :            :     }
    6786                 :            : 
    6787                 :        505 :   *pinit = init;
    6788                 :            : 
    6789                 :            :   // Set *PCOND to
    6790                 :            :   //   index_temp < len_temp
    6791                 :            : 
    6792                 :        505 :   index_ref = Expression::make_temporary_reference(index_temp, loc);
    6793                 :        505 :   Expression* len_ref =
    6794                 :        505 :     Expression::make_temporary_reference(len_temp, loc);
    6795                 :        505 :   *pcond = Expression::make_binary(OPERATOR_LT, index_ref, len_ref, loc);
    6796                 :            : 
    6797                 :            :   // Set *PITER_INIT to
    6798                 :            :   //   value_temp = rune(range[index_temp])
    6799                 :            :   //   if value_temp < utf8.RuneSelf {
    6800                 :            :   //           next_index_temp = index_temp + 1
    6801                 :            :   //   } else {
    6802                 :            :   //           value_temp, next_index_temp = decoderune(range, index_temp)
    6803                 :            :   //   }
    6804                 :            : 
    6805                 :        505 :   Block* iter_init = new Block(body_block, loc);
    6806                 :            : 
    6807                 :        505 :   ref = this->make_range_ref(range_object, range_temp, loc);
    6808                 :        505 :   index_ref = Expression::make_temporary_reference(index_temp, loc);
    6809                 :        505 :   ref = Expression::make_string_index(ref, index_ref, NULL, loc);
    6810                 :        505 :   ref = Expression::make_cast(rune_type, ref, loc);
    6811                 :        505 :   Temporary_reference_expression* value_ref =
    6812                 :        505 :     Expression::make_temporary_reference(value_temp, loc);
    6813                 :        505 :   value_ref->set_is_lvalue();
    6814                 :        505 :   s = Statement::make_assignment(value_ref, ref, loc);
    6815                 :        505 :   iter_init->add_statement(s);
    6816                 :            : 
    6817                 :        505 :   value_ref = Expression::make_temporary_reference(value_temp, loc);
    6818                 :        505 :   Expression* rune_self = Expression::make_integer_ul(0x80, rune_type, loc);
    6819                 :        505 :   Expression* cond = Expression::make_binary(OPERATOR_LT, value_ref, rune_self,
    6820                 :            :                                              loc);
    6821                 :            : 
    6822                 :        505 :   Block* then_block = new Block(iter_init, loc);
    6823                 :            : 
    6824                 :        505 :   Temporary_reference_expression* lhs =
    6825                 :        505 :     Expression::make_temporary_reference(next_index_temp, loc);
    6826                 :        505 :   lhs->set_is_lvalue();
    6827                 :        505 :   index_ref = Expression::make_temporary_reference(index_temp, loc);
    6828                 :        505 :   Expression* one = Expression::make_integer_ul(1, index_temp->type(), loc);
    6829                 :        505 :   Expression* sum = Expression::make_binary(OPERATOR_PLUS, index_ref, one,
    6830                 :            :                                             loc);
    6831                 :        505 :   s = Statement::make_assignment(lhs, sum, loc);
    6832                 :        505 :   then_block->add_statement(s);
    6833                 :            : 
    6834                 :        505 :   Block* else_block = new Block(iter_init, loc);
    6835                 :            : 
    6836                 :        505 :   ref = this->make_range_ref(range_object, range_temp, loc);
    6837                 :        505 :   index_ref = Expression::make_temporary_reference(index_temp, loc);
    6838                 :        505 :   call = Runtime::make_call(Runtime::DECODERUNE, loc, 2, ref, index_ref);
    6839                 :            : 
    6840                 :        505 :   value_ref = Expression::make_temporary_reference(value_temp, loc);
    6841                 :        505 :   value_ref->set_is_lvalue();
    6842                 :        505 :   Expression* res = Expression::make_call_result(call, 0);
    6843                 :        505 :   s = Statement::make_assignment(value_ref, res, loc);
    6844                 :        505 :   else_block->add_statement(s);
    6845                 :            : 
    6846                 :        505 :   lhs = Expression::make_temporary_reference(next_index_temp, loc);
    6847                 :        505 :   lhs->set_is_lvalue();
    6848                 :        505 :   res = Expression::make_call_result(call, 1);
    6849                 :        505 :   s = Statement::make_assignment(lhs, res, loc);
    6850                 :        505 :   else_block->add_statement(s);
    6851                 :            : 
    6852                 :        505 :   s = Statement::make_if_statement(cond, then_block, else_block, loc);
    6853                 :        505 :   iter_init->add_statement(s);
    6854                 :            : 
    6855                 :        505 :   *piter_init = iter_init;
    6856                 :            : 
    6857                 :            :   // Set *PPOST to
    6858                 :            :   //   index_temp = next_index_temp
    6859                 :            : 
    6860                 :        505 :   Block* post = new Block(enclosing, loc);
    6861                 :            : 
    6862                 :        505 :   index_ref = Expression::make_temporary_reference(index_temp, loc);
    6863                 :        505 :   index_ref->set_is_lvalue();
    6864                 :        505 :   ref = Expression::make_temporary_reference(next_index_temp, loc);
    6865                 :        505 :   s = Statement::make_assignment(index_ref, ref, loc);
    6866                 :            : 
    6867                 :        505 :   post->add_statement(s);
    6868                 :        505 :   *ppost = post;
    6869                 :        505 : }
    6870                 :            : 
    6871                 :            : // Lower a for range over a map.
    6872                 :            : 
    6873                 :            : void
    6874                 :       1716 : For_range_statement::lower_range_map(Gogo* gogo,
    6875                 :            :                                      Map_type* map_type,
    6876                 :            :                                      Block* enclosing,
    6877                 :            :                                      Block* body_block,
    6878                 :            :                                      Named_object* range_object,
    6879                 :            :                                      Temporary_statement* range_temp,
    6880                 :            :                                      Temporary_statement* index_temp,
    6881                 :            :                                      Temporary_statement* value_temp,
    6882                 :            :                                      Block** pinit,
    6883                 :            :                                      Expression** pcond,
    6884                 :            :                                      Block** piter_init,
    6885                 :            :                                      Block** ppost)
    6886                 :            : {
    6887                 :       1716 :   Location loc = this->location();
    6888                 :            : 
    6889                 :            :   // The runtime uses a struct to handle ranges over a map.  The
    6890                 :            :   // struct is built by Map_type::hiter_type for a specific map type.
    6891                 :            : 
    6892                 :            :   // The loop we generate:
    6893                 :            :   //   var hiter map_iteration_struct
    6894                 :            :   //   for mapiterinit(type, range, &hiter); hiter.key != nil; mapiternext(&hiter) {
    6895                 :            :   //           index_temp = *hiter.key
    6896                 :            :   //           value_temp = *hiter.val
    6897                 :            :   //           index = index_temp
    6898                 :            :   //           value = value_temp
    6899                 :            :   //           original body
    6900                 :            :   //   }
    6901                 :            : 
    6902                 :            :   // Set *PINIT to
    6903                 :            :   //   var hiter map_iteration_struct
    6904                 :            :   //   runtime.mapiterinit(type, range, &hiter)
    6905                 :            : 
    6906                 :       1716 :   Block* init = new Block(enclosing, loc);
    6907                 :            : 
    6908                 :       1716 :   Type* map_iteration_type = map_type->hiter_type(gogo);
    6909                 :       1716 :   Temporary_statement* hiter = Statement::make_temporary(map_iteration_type,
    6910                 :            :                                                          NULL, loc);
    6911                 :       1716 :   init->add_statement(hiter);
    6912                 :            : 
    6913                 :       1716 :   Expression* p1 = Expression::make_type_descriptor(map_type, loc);
    6914                 :       1716 :   Expression* p2 = this->make_range_ref(range_object, range_temp, loc);
    6915                 :       1716 :   Expression* ref = Expression::make_temporary_reference(hiter, loc);
    6916                 :       1716 :   Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc);
    6917                 :       1716 :   Expression* call = Runtime::make_call(Runtime::MAPITERINIT, loc, 3,
    6918                 :            :                                         p1, p2, p3);
    6919                 :       1716 :   init->add_statement(Statement::make_statement(call, true));
    6920                 :            : 
    6921                 :       1716 :   *pinit = init;
    6922                 :            : 
    6923                 :            :   // Set *PCOND to
    6924                 :            :   //   hiter.key != nil
    6925                 :            : 
    6926                 :       1716 :   ref = Expression::make_temporary_reference(hiter, loc);
    6927                 :       1716 :   ref = Expression::make_field_reference(ref, 0, loc);
    6928                 :       1716 :   Expression* ne = Expression::make_binary(OPERATOR_NOTEQ, ref,
    6929                 :            :                                            Expression::make_nil(loc),
    6930                 :            :                                            loc);
    6931                 :       1716 :   *pcond = ne;
    6932                 :            : 
    6933                 :            :   // Set *PITER_INIT to
    6934                 :            :   //   index_temp = *hiter.key
    6935                 :            :   //   value_temp = *hiter.val
    6936                 :            : 
    6937                 :       1716 :   Block* iter_init = new Block(body_block, loc);
    6938                 :            : 
    6939                 :       1716 :   Expression* lhs = Expression::make_temporary_reference(index_temp, loc);
    6940                 :       1716 :   Expression* rhs = Expression::make_temporary_reference(hiter, loc);
    6941                 :       1716 :   rhs = Expression::make_field_reference(ref, 0, loc);
    6942                 :       1716 :   rhs = Expression::make_dereference(ref, Expression::NIL_CHECK_NOT_NEEDED,
    6943                 :            :                                      loc);
    6944                 :       1716 :   Statement* set = Statement::make_assignment(lhs, rhs, loc);
    6945                 :       1716 :   iter_init->add_statement(set);
    6946                 :            : 
    6947                 :       1716 :   if (value_temp != NULL)
    6948                 :            :     {
    6949                 :       1241 :       lhs = Expression::make_temporary_reference(value_temp, loc);
    6950                 :       1241 :       rhs = Expression::make_temporary_reference(hiter, loc);
    6951                 :       1241 :       rhs = Expression::make_field_reference(rhs, 1, loc);
    6952                 :       1241 :       rhs = Expression::make_dereference(rhs, Expression::NIL_CHECK_NOT_NEEDED,
    6953                 :            :                                          loc);
    6954                 :       1241 :       set = Statement::make_assignment(lhs, rhs, loc);
    6955                 :       1241 :       iter_init->add_statement(set);
    6956                 :            :     }
    6957                 :            : 
    6958                 :       1716 :   *piter_init = iter_init;
    6959                 :            : 
    6960                 :            :   // Set *PPOST to
    6961                 :            :   //   mapiternext(&hiter)
    6962                 :            : 
    6963                 :       1716 :   Block* post = new Block(enclosing, loc);
    6964                 :            : 
    6965                 :       1716 :   ref = Expression::make_temporary_reference(hiter, loc);
    6966                 :       1716 :   p1 = Expression::make_unary(OPERATOR_AND, ref, loc);
    6967                 :       1716 :   call = Runtime::make_call(Runtime::MAPITERNEXT, loc, 1, p1);
    6968                 :       1716 :   post->add_statement(Statement::make_statement(call, true));
    6969                 :            : 
    6970                 :       1716 :   *ppost = post;
    6971                 :       1716 : }
    6972                 :            : 
    6973                 :            : // Lower a for range over a channel.
    6974                 :            : 
    6975                 :            : void
    6976                 :        102 : For_range_statement::lower_range_channel(Gogo*,
    6977                 :            :                                          Block*,
    6978                 :            :                                          Block* body_block,
    6979                 :            :                                          Named_object* range_object,
    6980                 :            :                                          Temporary_statement* range_temp,
    6981                 :            :                                          Temporary_statement* index_temp,
    6982                 :            :                                          Temporary_statement* value_temp,
    6983                 :            :                                          Block** pinit,
    6984                 :            :                                          Expression** pcond,
    6985                 :            :                                          Block** piter_init,
    6986                 :            :                                          Block** ppost)
    6987                 :            : {
    6988                 :        102 :   go_assert(value_temp == NULL);
    6989                 :            : 
    6990                 :        102 :   Location loc = this->location();
    6991                 :            : 
    6992                 :            :   // The loop we generate:
    6993                 :            :   //   for {
    6994                 :            :   //           index_temp, ok_temp = <-range
    6995                 :            :   //           if !ok_temp {
    6996                 :            :   //                   break
    6997                 :            :   //           }
    6998                 :            :   //           index = index_temp
    6999                 :            :   //           original body
    7000                 :            :   //   }
    7001                 :            : 
    7002                 :            :   // We have no initialization code, no condition, and no post code.
    7003                 :            : 
    7004                 :        102 :   *pinit = NULL;
    7005                 :        102 :   *pcond = NULL;
    7006                 :        102 :   *ppost = NULL;
    7007                 :            : 
    7008                 :            :   // Set *PITER_INIT to
    7009                 :            :   //   index_temp, ok_temp = <-range
    7010                 :            :   //   if !ok_temp {
    7011                 :            :   //           break
    7012                 :            :   //   }
    7013                 :            : 
    7014                 :        102 :   Block* iter_init = new Block(body_block, loc);
    7015                 :            : 
    7016                 :        102 :   Temporary_statement* ok_temp =
    7017                 :        102 :     Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
    7018                 :        102 :   iter_init->add_statement(ok_temp);
    7019                 :            : 
    7020                 :        102 :   Expression* cref = this->make_range_ref(range_object, range_temp, loc);
    7021                 :        102 :   Temporary_reference_expression* iref =
    7022                 :        102 :     Expression::make_temporary_reference(index_temp, loc);
    7023                 :        102 :   iref->set_is_lvalue();
    7024                 :        102 :   Temporary_reference_expression* oref =
    7025                 :        102 :     Expression::make_temporary_reference(ok_temp, loc);
    7026                 :        102 :   oref->set_is_lvalue();
    7027                 :        102 :   Statement* s = Statement::make_tuple_receive_assignment(iref, oref, cref,
    7028                 :            :                                                           loc);
    7029                 :        102 :   iter_init->add_statement(s);
    7030                 :            : 
    7031                 :        102 :   Block* then_block = new Block(iter_init, loc);
    7032                 :        102 :   s = Statement::make_break_statement(this->break_label(), loc);
    7033                 :        102 :   then_block->add_statement(s);
    7034                 :            : 
    7035                 :        102 :   oref = Expression::make_temporary_reference(ok_temp, loc);
    7036                 :        102 :   Expression* cond = Expression::make_unary(OPERATOR_NOT, oref, loc);
    7037                 :        102 :   s = Statement::make_if_statement(cond, then_block, NULL, loc);
    7038                 :        102 :   iter_init->add_statement(s);
    7039                 :            : 
    7040                 :        102 :   *piter_init = iter_init;
    7041                 :        102 : }
    7042                 :            : 
    7043                 :            : // Match
    7044                 :            : //
    7045                 :            : //   for k := range m { delete(m, k) }
    7046                 :            : //
    7047                 :            : // Lower it to runtime.mapclear(TYPE, m) on match, return the statement
    7048                 :            : // containing the call.  Return NULL otherwise.
    7049                 :            : 
    7050                 :            : Statement*
    7051                 :       1741 : For_range_statement::lower_map_range_clear(Type* map_type,
    7052                 :            :                                            Block* enclosing,
    7053                 :            :                                            Expression* orig_range_expr,
    7054                 :            :                                            Named_object* range_object,
    7055                 :            :                                            Temporary_statement* range_temp,
    7056                 :            :                                            Location loc)
    7057                 :            : {
    7058                 :       1741 :   if (this->value_var_ != NULL)
    7059                 :            :     return NULL;
    7060                 :        499 :   if (this->index_var_ == NULL)
    7061                 :            :     return NULL;
    7062                 :            : 
    7063                 :            :   // Require the loop index be a new variable.  We cannot rewrite
    7064                 :            :   // if it is used outside of the loop.
    7065                 :        486 :   Var_expression* index_ve = this->index_var_->var_expression();
    7066                 :        486 :   if (index_ve == NULL)
    7067                 :            :     return NULL;
    7068                 :        486 :   Named_object* index_no = index_ve->named_object();
    7069                 :        486 :   if (enclosing->bindings()->lookup_local(index_no->name()) != index_no)
    7070                 :            :     return NULL;
    7071                 :            : 
    7072                 :            :   // Match the body, a single call statement delete(m, k).
    7073                 :        485 :   const std::vector<Statement*>* statements = this->statements_->statements();
    7074                 :        485 :   if (statements->size() != 1)
    7075                 :            :     return NULL;
    7076                 :        327 :   Expression_statement* es = statements->at(0)->expression_statement();
    7077                 :         72 :   if (es == NULL)
    7078                 :            :     return NULL;
    7079                 :         72 :   Call_expression* call = es->expr()->call_expression();
    7080                 :         72 :   if (call == NULL || !call->is_builtin()
    7081                 :         26 :       || call->builtin_call_expression()->code()
    7082                 :            :          != Builtin_call_expression::BUILTIN_DELETE)
    7083                 :         46 :     return NULL;
    7084                 :         26 :   if (!Expression::is_same_variable(call->args()->at(0), orig_range_expr)
    7085                 :         26 :       || !Expression::is_same_variable(call->args()->at(1), this->index_var_))
    7086                 :          1 :     return NULL;
    7087                 :            : 
    7088                 :            :   // Everything matches. Rewrite to mapclear(TYPE, MAP).
    7089                 :         25 :   Expression* e1 = Expression::make_type_descriptor(map_type, loc);
    7090                 :         25 :   Expression* e2 = this->make_range_ref(range_object, range_temp, loc);
    7091                 :         25 :   call = Runtime::make_call(Runtime::MAPCLEAR, loc, 2, e1, e2);
    7092                 :         25 :   return Statement::make_statement(call, true);
    7093                 :            : }
    7094                 :            : 
    7095                 :            : // Match
    7096                 :            : //
    7097                 :            : //   for i := range a { a[i] = zero }
    7098                 :            : //
    7099                 :            : // Lower it to call memclr on match, and return the statement.  Return
    7100                 :            : // NULL otherwise.
    7101                 :            : 
    7102                 :            : Statement*
    7103                 :      25988 : For_range_statement::lower_array_range_clear(Gogo* gogo,
    7104                 :            :                                              Type* array_type,
    7105                 :            :                                              Expression* orig_range_expr,
    7106                 :            :                                              Block* temp_block,
    7107                 :            :                                              Named_object* range_object,
    7108                 :            :                                              Temporary_statement* range_temp,
    7109                 :            :                                              Location loc)
    7110                 :            : {
    7111                 :      25988 :   if (this->value_var_ != NULL)
    7112                 :            :     return NULL;
    7113                 :       9090 :   if (this->index_var_ == NULL)
    7114                 :            :     return NULL;
    7115                 :            : 
    7116                 :            :   // Match the body, a single assignment statement a[i] = zero.
    7117                 :       9070 :   const std::vector<Statement*>* statements = this->statements_->statements();
    7118                 :       9070 :   if (statements->size() != 1)
    7119                 :            :     return NULL;
    7120                 :       6248 :   Assignment_statement* as = statements->at(0)->assignment_statement();
    7121                 :        999 :   if (as == NULL || !as->rhs()->is_zero_value())
    7122                 :       5895 :     return NULL;
    7123                 :        355 :   if (as->lhs()->type()->interface_type() != NULL
    7124                 :          4 :       && as->rhs()->type()->interface_type() == NULL
    7125                 :          2 :       && !as->rhs()->type()->is_nil_type())
    7126                 :            :     // Implicit type conversion may change a zero value to non-zero, like
    7127                 :            :     // interface{}(0).
    7128                 :            :     return NULL;
    7129                 :        351 :   Array_index_expression* aie = as->lhs()->array_index_expression();
    7130                 :        336 :   if (aie == NULL || aie->end() != NULL
    7131                 :        336 :       || !Expression::is_same_variable(orig_range_expr, aie->array())
    7132                 :        259 :       || !Expression::is_same_variable(this->index_var_, aie->start()))
    7133                 :         92 :     return NULL;
    7134                 :            : 
    7135                 :            :   // Everything matches. Rewrite to
    7136                 :            :   //
    7137                 :            :   //   if len(a) != 0 {
    7138                 :            :   //     tmp1 = &a[0]
    7139                 :            :   //     tmp2 = len(a)*sizeof(elem(a))
    7140                 :            :   //     memclr{NoHeap,Has}Pointers(tmp1, tmp2)
    7141                 :            :   //     i = len(a) - 1
    7142                 :            :   //   }
    7143                 :            : 
    7144                 :        518 :   Type* elem_type = array_type->array_type()->element_type();
    7145                 :        259 :   int64_t elme_sz;
    7146                 :        259 :   bool ok = elem_type->backend_type_size(gogo, &elme_sz);
    7147                 :        259 :   if (!ok)
    7148                 :            :     return NULL;
    7149                 :            : 
    7150                 :        259 :   Block* b = new Block(temp_block, loc);
    7151                 :            : 
    7152                 :        259 :   Expression* ref;
    7153                 :        259 :   if (range_object == NULL && range_temp == NULL)
    7154                 :            :     // is_same_variable implies no side effect, so it is ok to copy.
    7155                 :         90 :     ref = orig_range_expr->copy();
    7156                 :            :   else
    7157                 :        169 :     ref = this->make_range_ref(range_object, range_temp, loc);
    7158                 :        259 :   Expression* len = this->call_builtin(gogo, "len", ref, loc);
    7159                 :        259 :   Temporary_statement* tslen = Statement::make_temporary(NULL, len, loc);
    7160                 :        259 :   temp_block->add_statement(tslen);
    7161                 :            : 
    7162                 :        259 :   Expression* zero = Expression::make_integer_ul(0, this->index_var_->type(), loc);
    7163                 :        259 :   ref = ref->copy();
    7164                 :        259 :   Expression* elem = Expression::make_array_index(ref, zero, NULL, NULL, loc);
    7165                 :        259 :   elem->array_index_expression()->set_needs_bounds_check(false);
    7166                 :        259 :   Expression* e1 = Expression::make_unary(OPERATOR_AND, elem, loc);
    7167                 :        259 :   Temporary_statement* ts1 = Statement::make_temporary(NULL, e1, loc);
    7168                 :        259 :   b->add_statement(ts1);
    7169                 :            : 
    7170                 :        259 :   len = Expression::make_temporary_reference(tslen, loc);
    7171                 :        259 :   Expression* sz = Expression::make_integer_int64(elme_sz, len->type(), loc);
    7172                 :        259 :   Expression* e2 = Expression::make_binary(OPERATOR_MULT, len, sz, loc);
    7173                 :        259 :   Temporary_statement* ts2 = Statement::make_temporary(NULL, e2, loc);
    7174                 :        259 :   b->add_statement(ts2);
    7175                 :            : 
    7176                 :        259 :   Expression* ptr_arg = Expression::make_temporary_reference(ts1, loc);
    7177                 :        259 :   Expression* sz_arg = Expression::make_temporary_reference(ts2, loc);
    7178                 :        259 :   Expression* call;
    7179                 :        259 :   if (elem_type->has_pointer())
    7180                 :         29 :     call = Runtime::make_call(Runtime::MEMCLRHASPTR, loc, 2, ptr_arg, sz_arg);
    7181                 :            :   else
    7182                 :            :     {
    7183                 :        230 :       Type* int32_type = Type::lookup_integer_type("int32");
    7184                 :        230 :       Expression* zero32 = Expression::make_integer_ul(0, int32_type, loc);
    7185                 :        230 :       call = Runtime::make_call(Runtime::BUILTIN_MEMSET, loc, 3, ptr_arg,
    7186                 :            :                                 zero32, sz_arg);
    7187                 :            :     }
    7188                 :        259 :   Statement* cs3 = Statement::make_statement(call, true);
    7189                 :        259 :   b->add_statement(cs3);
    7190                 :            : 
    7191                 :        259 :   len = Expression::make_temporary_reference(tslen, loc);
    7192                 :        259 :   Expression* one = Expression::make_integer_ul(1, len->type(), loc);
    7193                 :        259 :   Expression* rhs = Expression::make_binary(OPERATOR_MINUS, len, one, loc);
    7194                 :        259 :   Expression* lhs = this->index_var_->copy();
    7195                 :        259 :   Statement* as4 = Statement::make_assignment(lhs, rhs, loc);
    7196                 :        259 :   b->add_statement(as4);
    7197                 :            : 
    7198                 :        259 :   len = Expression::make_temporary_reference(tslen, loc);
    7199                 :        259 :   zero = zero->copy();
    7200                 :        259 :   Expression* cond = Expression::make_binary(OPERATOR_NOTEQ, len, zero, loc);
    7201                 :        259 :   return Statement::make_if_statement(cond, b, NULL, loc);
    7202                 :            : }
    7203                 :            : 
    7204                 :            : // Return the break LABEL_EXPR.
    7205                 :            : 
    7206                 :            : Unnamed_label*
    7207                 :       1314 : For_range_statement::break_label()
    7208                 :            : {
    7209                 :       1314 :   if (this->break_label_ == NULL)
    7210                 :       1210 :     this->break_label_ = new Unnamed_label(this->location());
    7211                 :       1314 :   return this->break_label_;
    7212                 :            : }
    7213                 :            : 
    7214                 :            : // Return the continue LABEL_EXPR.
    7215                 :            : 
    7216                 :            : Unnamed_label*
    7217                 :       4995 : For_range_statement::continue_label()
    7218                 :            : {
    7219                 :       4995 :   if (this->continue_label_ == NULL)
    7220                 :       2935 :     this->continue_label_ = new Unnamed_label(this->location());
    7221                 :       4995 :   return this->continue_label_;
    7222                 :            : }
    7223                 :            : 
    7224                 :            : // Dump the AST representation for a for range statement.
    7225                 :            : 
    7226                 :            : void
    7227                 :          0 : For_range_statement::do_dump_statement(Ast_dump_context* ast_dump_context) const
    7228                 :            : {
    7229                 :            : 
    7230                 :          0 :   ast_dump_context->print_indent();
    7231                 :          0 :   ast_dump_context->ostream() << "for ";
    7232                 :          0 :   ast_dump_context->dump_expression(this->index_var_);
    7233                 :          0 :   if (this->value_var_ != NULL)
    7234                 :            :     {
    7235                 :          0 :       ast_dump_context->ostream() << ", ";
    7236                 :          0 :       ast_dump_context->dump_expression(this->value_var_);
    7237                 :            :     }
    7238                 :            : 
    7239                 :          0 :   ast_dump_context->ostream() << " = range ";
    7240                 :          0 :   ast_dump_context->dump_expression(this->range_);
    7241                 :          0 :   if (ast_dump_context->dump_subblocks())
    7242                 :            :     {
    7243                 :          0 :       ast_dump_context->ostream() << " {" << std::endl;
    7244                 :            : 
    7245                 :          0 :       ast_dump_context->indent();
    7246                 :            : 
    7247                 :          0 :       ast_dump_context->dump_block(this->statements_);
    7248                 :            : 
    7249                 :          0 :       ast_dump_context->unindent();
    7250                 :          0 :       ast_dump_context->print_indent();
    7251                 :          0 :       ast_dump_context->ostream() << "}";
    7252                 :            :     }
    7253                 :          0 :   ast_dump_context->ostream() << dsuffix(location()) << std::endl;
    7254                 :          0 : }
    7255                 :            : 
    7256                 :            : // Make a for statement with a range clause.
    7257                 :            : 
    7258                 :            : For_range_statement*
    7259                 :      28336 : Statement::make_for_range_statement(Expression* index_var,
    7260                 :            :                                     Expression* value_var,
    7261                 :            :                                     Expression* range,
    7262                 :            :                                     Location location)
    7263                 :            : {
    7264                 :      28336 :   return new For_range_statement(index_var, value_var, range, location);
    7265                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.