gcc/go/gofrontend/gogo.cc

   1 // gogo.cc -- Go frontend parsed representation.
   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-dump.h"
  11 #include "lex.h"
  12 #include "types.h"
  13 #include "statements.h"
  14 #include "expressions.h"
  15 #include "dataflow.h"
  16 #include "import.h"
  17 #include "export.h"
  18 #include "gogo.h"
  19
  20 // Class Gogo.
  21
  22 Gogo::Gogo(int int_type_size, int float_type_size, int pointer_size)
  23   : package_(NULL),
  24     functions_(),
  25     globals_(new Bindings(NULL)),
  26     imports_(),
  27     imported_unsafe_(false),
  28     packages_(),
  29     map_descriptors_(NULL),
  30     type_descriptor_decls_(NULL),
  31     init_functions_(),
  32     need_init_fn_(false),
  33     init_fn_name_(),
  34     imported_init_fns_(),
  35     unique_prefix_(),
  36     interface_types_()
  37 {
  38   const source_location loc = BUILTINS_LOCATION;
  39
  40   Named_type* uint8_type = Type::make_integer_type("uint8", true, 8,
  41                                                    RUNTIME_TYPE_KIND_UINT8);
  42   this->add_named_type(uint8_type);
  43   this->add_named_type(Type::make_integer_type("uint16", true,  16,
  44                                                RUNTIME_TYPE_KIND_UINT16));
  45   this->add_named_type(Type::make_integer_type("uint32", true,  32,
  46                                                RUNTIME_TYPE_KIND_UINT32));
  47   this->add_named_type(Type::make_integer_type("uint64", true,  64,
  48                                                RUNTIME_TYPE_KIND_UINT64));
  49
  50   this->add_named_type(Type::make_integer_type("int8",  false,   8,
  51                                                RUNTIME_TYPE_KIND_INT8));
  52   this->add_named_type(Type::make_integer_type("int16", false,  16,
  53                                                RUNTIME_TYPE_KIND_INT16));
  54   this->add_named_type(Type::make_integer_type("int32", false,  32,
  55                                                RUNTIME_TYPE_KIND_INT32));
  56   this->add_named_type(Type::make_integer_type("int64", false,  64,
  57                                                RUNTIME_TYPE_KIND_INT64));
  58
  59   this->add_named_type(Type::make_float_type("float32", 32,
  60                                              RUNTIME_TYPE_KIND_FLOAT32));
  61   this->add_named_type(Type::make_float_type("float64", 64,
  62                                              RUNTIME_TYPE_KIND_FLOAT64));
  63
  64   this->add_named_type(Type::make_complex_type("complex64", 64,
  65                                                RUNTIME_TYPE_KIND_COMPLEX64));
  66   this->add_named_type(Type::make_complex_type("complex128", 128,
  67                                                RUNTIME_TYPE_KIND_COMPLEX128));
  68
  69   if (int_type_size < 32)
  70     int_type_size = 32;
  71   this->add_named_type(Type::make_integer_type("uint", true,
  72                                                int_type_size,
  73                                                RUNTIME_TYPE_KIND_UINT));
  74   Named_type* int_type = Type::make_integer_type("int", false, int_type_size,
  75                                                  RUNTIME_TYPE_KIND_INT);
  76   this->add_named_type(int_type);
  77
  78   // "byte" is an alias for "uint8".  Construct a Named_object which
  79   // points to UINT8_TYPE.  Note that this breaks the normal pairing
  80   // in which a Named_object points to a Named_type which points back
  81   // to the same Named_object.
  82   Named_object* byte_type = this->declare_type("byte", loc);
  83   byte_type->set_type_value(uint8_type);
  84
  85   this->add_named_type(Type::make_integer_type("uintptr", true,
  86                                                pointer_size,
  87                                                RUNTIME_TYPE_KIND_UINTPTR));
  88
  89   this->add_named_type(Type::make_float_type("float", float_type_size,
  90                                              RUNTIME_TYPE_KIND_FLOAT));
  91
  92   this->add_named_type(Type::make_complex_type("complex", float_type_size * 2,
  93                                                RUNTIME_TYPE_KIND_COMPLEX));
  94
  95   this->add_named_type(Type::make_named_bool_type());
  96
  97   this->add_named_type(Type::make_named_string_type());
  98
  99   this->globals_->add_constant(Typed_identifier("true",
 100                                                 Type::make_boolean_type(),
 101                                                 loc),
 102                                NULL,
 103                                Expression::make_boolean(true, loc),
 104                                0);
 105   this->globals_->add_constant(Typed_identifier("false",
 106                                                 Type::make_boolean_type(),
 107                                                 loc),
 108                                NULL,
 109                                Expression::make_boolean(false, loc),
 110                                0);
 111
 112   this->globals_->add_constant(Typed_identifier("nil", Type::make_nil_type(),
 113                                                 loc),
 114                                NULL,
 115                                Expression::make_nil(loc),
 116                                0);
 117
 118   Type* abstract_int_type = Type::make_abstract_integer_type();
 119   this->globals_->add_constant(Typed_identifier("iota", abstract_int_type,
 120                                                 loc),
 121                                NULL,
 122                                Expression::make_iota(),
 123                                0);
 124
 125   Function_type* new_type = Type::make_function_type(NULL, NULL, NULL, loc);
 126   new_type->set_is_varargs();
 127   new_type->set_is_builtin();
 128   this->globals_->add_function_declaration("new", NULL, new_type, loc);
 129
 130   Function_type* make_type = Type::make_function_type(NULL, NULL, NULL, loc);
 131   make_type->set_is_varargs();
 132   make_type->set_is_builtin();
 133   this->globals_->add_function_declaration("make", NULL, make_type, loc);
 134
 135   Typed_identifier_list* len_result = new Typed_identifier_list();
 136   len_result->push_back(Typed_identifier("", int_type, loc));
 137   Function_type* len_type = Type::make_function_type(NULL, NULL, len_result,
 138                                                      loc);
 139   len_type->set_is_builtin();
 140   this->globals_->add_function_declaration("len", NULL, len_type, loc);
 141
 142   Typed_identifier_list* cap_result = new Typed_identifier_list();
 143   cap_result->push_back(Typed_identifier("", int_type, loc));
 144   Function_type* cap_type = Type::make_function_type(NULL, NULL, len_result,
 145                                                      loc);
 146   cap_type->set_is_builtin();
 147   this->globals_->add_function_declaration("cap", NULL, cap_type, loc);
 148
 149   Function_type* print_type = Type::make_function_type(NULL, NULL, NULL, loc);
 150   print_type->set_is_varargs();
 151   print_type->set_is_builtin();
 152   this->globals_->add_function_declaration("print", NULL, print_type, loc);
 153
 154   print_type = Type::make_function_type(NULL, NULL, NULL, loc);
 155   print_type->set_is_varargs();
 156   print_type->set_is_builtin();
 157   this->globals_->add_function_declaration("println", NULL, print_type, loc);
 158
 159   Type *empty = Type::make_interface_type(NULL, loc);
 160   Typed_identifier_list* panic_parms = new Typed_identifier_list();
 161   panic_parms->push_back(Typed_identifier("e", empty, loc));
 162   Function_type *panic_type = Type::make_function_type(NULL, panic_parms,
 163                                                        NULL, loc);
 164   panic_type->set_is_builtin();
 165   this->globals_->add_function_declaration("panic", NULL, panic_type, loc);
 166
 167   Typed_identifier_list* recover_result = new Typed_identifier_list();
 168   recover_result->push_back(Typed_identifier("", empty, loc));
 169   Function_type* recover_type = Type::make_function_type(NULL, NULL,
 170                                                          recover_result,
 171                                                          loc);
 172   recover_type->set_is_builtin();
 173   this->globals_->add_function_declaration("recover", NULL, recover_type, loc);
 174
 175   Function_type* close_type = Type::make_function_type(NULL, NULL, NULL, loc);
 176   close_type->set_is_varargs();
 177   close_type->set_is_builtin();
 178   this->globals_->add_function_declaration("close", NULL, close_type, loc);
 179
 180   Typed_identifier_list* closed_result = new Typed_identifier_list();
 181   closed_result->push_back(Typed_identifier("", Type::lookup_bool_type(),
 182                                             loc));
 183   Function_type* closed_type = Type::make_function_type(NULL, NULL,
 184                                                         closed_result, loc);
 185   closed_type->set_is_varargs();
 186   closed_type->set_is_builtin();
 187   this->globals_->add_function_declaration("closed", NULL, closed_type, loc);
 188
 189   Typed_identifier_list* copy_result = new Typed_identifier_list();
 190   copy_result->push_back(Typed_identifier("", int_type, loc));
 191   Function_type* copy_type = Type::make_function_type(NULL, NULL,
 192                                                       copy_result, loc);
 193   copy_type->set_is_varargs();
 194   copy_type->set_is_builtin();
 195   this->globals_->add_function_declaration("copy", NULL, copy_type, loc);
 196
 197   Function_type* append_type = Type::make_function_type(NULL, NULL, NULL, loc);
 198   append_type->set_is_varargs();
 199   append_type->set_is_builtin();
 200   this->globals_->add_function_declaration("append", NULL, append_type, loc);
 201
 202   Function_type* cmplx_type = Type::make_function_type(NULL, NULL, NULL, loc);
 203   cmplx_type->set_is_varargs();
 204   cmplx_type->set_is_builtin();
 205   this->globals_->add_function_declaration("cmplx", NULL, cmplx_type, loc);
 206
 207   Function_type* real_type = Type::make_function_type(NULL, NULL, NULL, loc);
 208   real_type->set_is_varargs();
 209   real_type->set_is_builtin();
 210   this->globals_->add_function_declaration("real", NULL, real_type, loc);
 211
 212   Function_type* imag_type = Type::make_function_type(NULL, NULL, NULL, loc);
 213   imag_type->set_is_varargs();
 214   imag_type->set_is_builtin();
 215   this->globals_->add_function_declaration("imag", NULL, cmplx_type, loc);
 216
 217   this->define_builtin_function_trees();
 218
 219   // Declare "init", to ensure that it is not defined with parameters
 220   // or return values.
 221   this->declare_function("init",
 222                          Type::make_function_type(NULL, NULL, NULL, loc),
 223                          loc);
 224 }
 225
 226 // Munge name for use in an error message.
 227
 228 std::string
 229 Gogo::message_name(const std::string& name)
 230 {
 231   return go_localize_identifier(Gogo::unpack_hidden_name(name).c_str());
 232 }
 233
 234 // Get the package name.
 235
 236 const std::string&
 237 Gogo::package_name() const
 238 {
 239   gcc_assert(this->package_ != NULL);
 240   return this->package_->name();
 241 }
 242
 243 // Set the package name.
 244
 245 void
 246 Gogo::set_package_name(const std::string& package_name,
 247                        source_location location)
 248 {
 249   if (this->package_ != NULL && this->package_->name() != package_name)
 250     {
 251       error_at(location, "expected package %<%s%>",
 252                Gogo::message_name(this->package_->name()).c_str());
 253       return;
 254     }
 255
 256   // If the user did not specify a unique prefix, we always use "go".
 257   // This in effect requires that the package name be unique.
 258   if (this->unique_prefix_.empty())
 259     this->unique_prefix_ = "go";
 260
 261   this->package_ = this->register_package(package_name, this->unique_prefix_,
 262                                           location);
 263
 264   // We used to permit people to qualify symbols with the current
 265   // package name (e.g., P.x), but we no longer do.
 266   // this->globals_->add_package(package_name, this->package_);
 267
 268   if (package_name == "main")
 269     {
 270       // Declare "main" as a function which takes no parameters and
 271       // returns no value.
 272       this->declare_function("main",
 273                              Type::make_function_type(NULL, NULL, NULL,
 274                                                       BUILTINS_LOCATION),
 275                              BUILTINS_LOCATION);
 276     }
 277 }
 278
 279 // Import a package.
 280
 281 void
 282 Gogo::import_package(const std::string& filename,
 283                      const std::string& local_name,
 284                      bool is_local_name_exported,
 285                      source_location location)
 286 {
 287   if (filename == "unsafe")
 288     {
 289       this->import_unsafe(local_name, is_local_name_exported, location);
 290       return;
 291     }
 292
 293   Imports::const_iterator p = this->imports_.find(filename);
 294   if (p != this->imports_.end())
 295     {
 296       Package* package = p->second;
 297       package->set_location(location);
 298       package->set_is_imported();
 299       std::string ln = local_name;
 300       bool is_ln_exported = is_local_name_exported;
 301       if (ln.empty())
 302         {
 303           ln = package->name();
 304           is_ln_exported = Lex::is_exported_name(ln);
 305         }
 306       if (ln != ".")
 307         {
 308           ln = this->pack_hidden_name(ln, is_ln_exported);
 309           this->package_->bindings()->add_package(ln, package);
 310         }
 311       else
 312         {
 313           Bindings* bindings = package->bindings();
 314           for (Bindings::const_declarations_iterator p =
 315                  bindings->begin_declarations();
 316                p != bindings->end_declarations();
 317                ++p)
 318             this->add_named_object(p->second);
 319         }
 320       return;
 321     }
 322
 323   Import::Stream* stream = Import::open_package(filename, location);
 324   if (stream == NULL)
 325     {
 326       error_at(location, "import file %qs not found", filename.c_str());
 327       return;
 328     }
 329
 330   Import imp(stream, location);
 331   imp.register_builtin_types(this);
 332   Package* package = imp.import(this, local_name, is_local_name_exported);
 333   this->imports_.insert(std::make_pair(filename, package));
 334   package->set_is_imported();
 335
 336   delete stream;
 337 }
 338
 339 // Add an import control function for an imported package to the list.
 340
 341 void
 342 Gogo::add_import_init_fn(const std::string& package_name,
 343                          const std::string& init_name, int prio)
 344 {
 345   for (std::set<Import_init>::const_iterator p =
 346          this->imported_init_fns_.begin();
 347        p != this->imported_init_fns_.end();
 348        ++p)
 349     {
 350       if (p->init_name() == init_name
 351           && (p->package_name() != package_name || p->priority() != prio))
 352         {
 353           error("duplicate package initialization name %qs",
 354                 Gogo::message_name(init_name).c_str());
 355           inform(UNKNOWN_LOCATION, "used by package %qs at priority %d",
 356                  Gogo::message_name(p->package_name()).c_str(),
 357                  p->priority());
 358           inform(UNKNOWN_LOCATION, " and by package %qs at priority %d",
 359                  Gogo::message_name(package_name).c_str(), prio);
 360           return;
 361         }
 362     }
 363
 364   this->imported_init_fns_.insert(Import_init(package_name, init_name,
 365                                               prio));
 366 }
 367
 368 // Return whether we are at the global binding level.
 369
 370 bool
 371 Gogo::in_global_scope() const
 372 {
 373   return this->functions_.empty();
 374 }
 375
 376 // Return the current binding contour.
 377
 378 Bindings*
 379 Gogo::current_bindings()
 380 {
 381   if (!this->functions_.empty())
 382     return this->functions_.back().blocks.back()->bindings();
 383   else if (this->package_ != NULL)
 384     return this->package_->bindings();
 385   else
 386     return this->globals_;
 387 }
 388
 389 const Bindings*
 390 Gogo::current_bindings() const
 391 {
 392   if (!this->functions_.empty())
 393     return this->functions_.back().blocks.back()->bindings();
 394   else if (this->package_ != NULL)
 395     return this->package_->bindings();
 396   else
 397     return this->globals_;
 398 }
 399
 400 // Return the current block.
 401
 402 Block*
 403 Gogo::current_block()
 404 {
 405   if (this->functions_.empty())
 406     return NULL;
 407   else
 408     return this->functions_.back().blocks.back();
 409 }
 410
 411 // Look up a name in the current binding contour.  If PFUNCTION is not
 412 // NULL, set it to the function in which the name is defined, or NULL
 413 // if the name is defined in global scope.
 414
 415 Named_object*
 416 Gogo::lookup(const std::string& name, Named_object** pfunction) const
 417 {
 418   if (pfunction != NULL)
 419     *pfunction = NULL;
 420
 421   if (Gogo::is_sink_name(name))
 422     return Named_object::make_sink();
 423
 424   for (Open_functions::const_reverse_iterator p = this->functions_.rbegin();
 425        p != this->functions_.rend();
 426        ++p)
 427     {
 428       Named_object* ret = p->blocks.back()->bindings()->lookup(name);
 429       if (ret != NULL)
 430         {
 431           if (pfunction != NULL)
 432             *pfunction = p->function;
 433           return ret;
 434         }
 435     }
 436
 437   if (this->package_ != NULL)
 438     {
 439       Named_object* ret = this->package_->bindings()->lookup(name);
 440       if (ret != NULL)
 441         {
 442           if (ret->package() != NULL)
 443             ret->package()->set_used();
 444           return ret;
 445         }
 446     }
 447
 448   // We do not look in the global namespace.  If we did, the global
 449   // namespace would effectively hide names which were defined in
 450   // package scope which we have not yet seen.  Instead,
 451   // define_global_names is called after parsing is over to connect
 452   // undefined names at package scope with names defined at global
 453   // scope.
 454
 455   return NULL;
 456 }
 457
 458 // Look up a name in the current block, without searching enclosing
 459 // blocks.
 460
 461 Named_object*
 462 Gogo::lookup_in_block(const std::string& name) const
 463 {
 464   gcc_assert(!this->functions_.empty());
 465   gcc_assert(!this->functions_.back().blocks.empty());
 466   return this->functions_.back().blocks.back()->bindings()->lookup_local(name);
 467 }
 468
 469 // Look up a name in the global namespace.
 470
 471 Named_object*
 472 Gogo::lookup_global(const char* name) const
 473 {
 474   return this->globals_->lookup(name);
 475 }
 476
 477 // Add an imported package.
 478
 479 Package*
 480 Gogo::add_imported_package(const std::string& real_name,
 481                            const std::string& alias_arg,
 482                            bool is_alias_exported,
 483                            const std::string& unique_prefix,
 484                            source_location location,
 485                            bool* padd_to_globals)
 486 {
 487   // FIXME: Now that we compile packages as a whole, should we permit
 488   // importing the current package?
 489   if (this->package_name() == real_name
 490       && this->unique_prefix() == unique_prefix)
 491     {
 492       *padd_to_globals = false;
 493       if (!alias_arg.empty() && alias_arg != ".")
 494         {
 495           std::string alias = this->pack_hidden_name(alias_arg,
 496                                                      is_alias_exported);
 497           this->package_->bindings()->add_package(alias, this->package_);
 498         }
 499       return this->package_;
 500     }
 501   else if (alias_arg == ".")
 502     {
 503       *padd_to_globals = true;
 504       return this->register_package(real_name, unique_prefix, location);
 505     }
 506   else if (alias_arg == "_")
 507     {
 508       Package* ret = this->register_package(real_name, unique_prefix, location);
 509       ret->set_uses_sink_alias();
 510       return ret;
 511     }
 512   else
 513     {
 514       *padd_to_globals = false;
 515       std::string alias = alias_arg;
 516       if (alias.empty())
 517         {
 518           alias = real_name;
 519           is_alias_exported = Lex::is_exported_name(alias);
 520         }
 521       alias = this->pack_hidden_name(alias, is_alias_exported);
 522       Named_object* no = this->add_package(real_name, alias, unique_prefix,
 523                                            location);
 524       if (!no->is_package())
 525         return NULL;
 526       return no->package_value();
 527     }
 528 }
 529
 530 // Add a package.
 531
 532 Named_object*
 533 Gogo::add_package(const std::string& real_name, const std::string& alias,
 534                   const std::string& unique_prefix, source_location location)
 535 {
 536   gcc_assert(this->in_global_scope());
 537
 538   // Register the package.  Note that we might have already seen it in
 539   // an earlier import.
 540   Package* package = this->register_package(real_name, unique_prefix, location);
 541
 542   return this->package_->bindings()->add_package(alias, package);
 543 }
 544
 545 // Register a package.  This package may or may not be imported.  This
 546 // returns the Package structure for the package, creating if it
 547 // necessary.
 548
 549 Package*
 550 Gogo::register_package(const std::string& package_name,
 551                        const std::string& unique_prefix,
 552                        source_location location)
 553 {
 554   gcc_assert(!unique_prefix.empty() && !package_name.empty());
 555   std::string name = unique_prefix + '.' + package_name;
 556   Package* package = NULL;
 557   std::pair<Packages::iterator, bool> ins =
 558     this->packages_.insert(std::make_pair(name, package));
 559   if (!ins.second)
 560     {
 561       // We have seen this package name before.
 562       package = ins.first->second;
 563       gcc_assert(package != NULL);
 564       gcc_assert(package->name() == package_name
 565                  && package->unique_prefix() == unique_prefix);
 566       if (package->location() == UNKNOWN_LOCATION)
 567         package->set_location(location);
 568     }
 569   else
 570     {
 571       // First time we have seen this package name.
 572       package = new Package(package_name, unique_prefix, location);
 573       gcc_assert(ins.first->second == NULL);
 574       ins.first->second = package;
 575     }
 576
 577   return package;
 578 }
 579
 580 // Start compiling a function.
 581
 582 Named_object*
 583 Gogo::start_function(const std::string& name, Function_type* type,
 584                      bool add_method_to_type, source_location location)
 585 {
 586   bool at_top_level = this->functions_.empty();
 587
 588   Block* block = new Block(NULL, location);
 589
 590   Function* enclosing = (at_top_level
 591                          ? NULL
 592                          : this->functions_.back().function->func_value());
 593
 594   Function* function = new Function(type, enclosing, block, location);
 595
 596   if (type->is_method())
 597     {
 598       const Typed_identifier* receiver = type->receiver();
 599       Variable* this_param = new Variable(receiver->type(), NULL, false,
 600                                           true, true, location);
 601       std::string name = receiver->name();
 602       if (name.empty())
 603         {
 604           // We need to give receivers a name since they wind up in
 605           // DECL_ARGUMENTS.  FIXME.
 606           static unsigned int count;
 607           char buf[50];
 608           snprintf(buf, sizeof buf, "r.%u", count);
 609           ++count;
 610           name = buf;
 611         }
 612       block->bindings()->add_variable(name, NULL, this_param);
 613     }
 614
 615   const Typed_identifier_list* parameters = type->parameters();
 616   bool is_varargs = type->is_varargs();
 617   if (parameters != NULL)
 618     {
 619       for (Typed_identifier_list::const_iterator p = parameters->begin();
 620            p != parameters->end();
 621            ++p)
 622         {
 623           Variable* param = new Variable(p->type(), NULL, false, true, false,
 624                                          location);
 625           if (is_varargs && p + 1 == parameters->end())
 626             param->set_is_varargs_parameter();
 627
 628           std::string name = p->name();
 629           if (name.empty() || Gogo::is_sink_name(name))
 630             {
 631               // We need to give parameters a name since they wind up
 632               // in DECL_ARGUMENTS.  FIXME.
 633               static unsigned int count;
 634               char buf[50];
 635               snprintf(buf, sizeof buf, "p.%u", count);
 636               ++count;
 637               name = buf;
 638             }
 639           block->bindings()->add_variable(name, NULL, param);
 640         }
 641     }
 642
 643   function->create_named_result_variables(this);
 644
 645   const std::string* pname;
 646   std::string nested_name;
 647   if (!name.empty())
 648     pname = &name;
 649   else
 650     {
 651       // Invent a name for a nested function.
 652       static int nested_count;
 653       char buf[30];
 654       snprintf(buf, sizeof buf, ".$nested%d", nested_count);
 655       ++nested_count;
 656       nested_name = buf;
 657       pname = &nested_name;
 658     }
 659
 660   Named_object* ret;
 661   if (Gogo::is_sink_name(*pname))
 662     {
 663       static int sink_count;
 664       char buf[30];
 665       snprintf(buf, sizeof buf, ".$sink%d", sink_count);
 666       ++sink_count;
 667       ret = Named_object::make_function(buf, NULL, function);
 668     }
 669   else if (!type->is_method())
 670     {
 671       ret = this->package_->bindings()->add_function(*pname, NULL, function);
 672       if (!ret->is_function())
 673         {
 674           // Redefinition error.
 675           ret = Named_object::make_function(name, NULL, function);
 676         }
 677     }
 678   else
 679     {
 680       if (!add_method_to_type)
 681         ret = Named_object::make_function(name, NULL, function);
 682       else
 683         {
 684           gcc_assert(at_top_level);
 685           Type* rtype = type->receiver()->type();
 686
 687           // We want to look through the pointer created by the
 688           // parser, without getting an error if the type is not yet
 689           // defined.
 690           if (rtype->classification() == Type::TYPE_POINTER)
 691             rtype = rtype->points_to();
 692
 693           if (rtype->is_error_type())
 694             ret = Named_object::make_function(name, NULL, function);
 695           else if (rtype->named_type() != NULL)
 696             {
 697               ret = rtype->named_type()->add_method(name, function);
 698               if (!ret->is_function())
 699                 {
 700                   // Redefinition error.
 701                   ret = Named_object::make_function(name, NULL, function);
 702                 }
 703             }
 704           else if (rtype->forward_declaration_type() != NULL)
 705             {
 706               Named_object* type_no =
 707                 rtype->forward_declaration_type()->named_object();
 708               if (type_no->is_unknown())
 709                 {
 710                   // If we are seeing methods it really must be a
 711                   // type.  Declare it as such.  An alternative would
 712                   // be to support lists of methods for unknown
 713                   // expressions.  Either way the error messages if
 714                   // this is not a type are going to get confusing.
 715                   Named_object* declared =
 716                     this->declare_package_type(type_no->name(),
 717                                                type_no->location());
 718                   gcc_assert(declared
 719                              == type_no->unknown_value()->real_named_object());
 720                 }
 721               ret = rtype->forward_declaration_type()->add_method(name,
 722                                                                   function);
 723             }
 724           else
 725             gcc_unreachable();
 726         }
 727       this->package_->bindings()->add_method(ret);
 728     }
 729
 730   this->functions_.resize(this->functions_.size() + 1);
 731   Open_function& of(this->functions_.back());
 732   of.function = ret;
 733   of.blocks.push_back(block);
 734
 735   if (!type->is_method() && Gogo::unpack_hidden_name(name) == "init")
 736     {
 737       this->init_functions_.push_back(ret);
 738       this->need_init_fn_ = true;
 739     }
 740
 741   return ret;
 742 }
 743
 744 // Finish compiling a function.
 745
 746 void
 747 Gogo::finish_function(source_location location)
 748 {
 749   this->finish_block(location);
 750   gcc_assert(this->functions_.back().blocks.empty());
 751   this->functions_.pop_back();
 752 }
 753
 754 // Return the current function.
 755
 756 Named_object*
 757 Gogo::current_function() const
 758 {
 759   gcc_assert(!this->functions_.empty());
 760   return this->functions_.back().function;
 761 }
 762
 763 // Start a new block.
 764
 765 void
 766 Gogo::start_block(source_location location)
 767 {
 768   gcc_assert(!this->functions_.empty());
 769   Block* block = new Block(this->current_block(), location);
 770   this->functions_.back().blocks.push_back(block);
 771 }
 772
 773 // Finish a block.
 774
 775 Block*
 776 Gogo::finish_block(source_location location)
 777 {
 778   gcc_assert(!this->functions_.empty());
 779   gcc_assert(!this->functions_.back().blocks.empty());
 780   Block* block = this->functions_.back().blocks.back();
 781   this->functions_.back().blocks.pop_back();
 782   block->set_end_location(location);
 783   return block;
 784 }
 785
 786 // Add an unknown name.
 787
 788 Named_object*
 789 Gogo::add_unknown_name(const std::string& name, source_location location)
 790 {
 791   return this->package_->bindings()->add_unknown_name(name, location);
 792 }
 793
 794 // Declare a function.
 795
 796 Named_object*
 797 Gogo::declare_function(const std::string& name, Function_type* type,
 798                        source_location location)
 799 {
 800   if (!type->is_method())
 801     return this->current_bindings()->add_function_declaration(name, NULL, type,
 802                                                               location);
 803   else
 804     {
 805       // We don't bother to add this to the list of global
 806       // declarations.
 807       Type* rtype = type->receiver()->type();
 808
 809       // We want to look through the pointer created by the
 810       // parser, without getting an error if the type is not yet
 811       // defined.
 812       if (rtype->classification() == Type::TYPE_POINTER)
 813         rtype = rtype->points_to();
 814
 815       if (rtype->is_error_type())
 816         return NULL;
 817       else if (rtype->named_type() != NULL)
 818         return rtype->named_type()->add_method_declaration(name, NULL, type,
 819                                                            location);
 820       else if (rtype->forward_declaration_type() != NULL)
 821         {
 822           Forward_declaration_type* ftype = rtype->forward_declaration_type();
 823           return ftype->add_method_declaration(name, type, location);
 824         }
 825       else
 826         gcc_unreachable();
 827     }
 828 }
 829
 830 // Add a label definition.
 831
 832 Label*
 833 Gogo::add_label_definition(const std::string& label_name,
 834                            source_location location)
 835 {
 836   gcc_assert(!this->functions_.empty());
 837   Function* func = this->functions_.back().function->func_value();
 838   Label* label = func->add_label_definition(label_name, location);
 839   this->add_statement(Statement::make_label_statement(label, location));
 840   return label;
 841 }
 842
 843 // Add a label reference.
 844
 845 Label*
 846 Gogo::add_label_reference(const std::string& label_name)
 847 {
 848   gcc_assert(!this->functions_.empty());
 849   Function* func = this->functions_.back().function->func_value();
 850   return func->add_label_reference(label_name);
 851 }
 852
 853 // Add a statement.
 854
 855 void
 856 Gogo::add_statement(Statement* statement)
 857 {
 858   gcc_assert(!this->functions_.empty()
 859              && !this->functions_.back().blocks.empty());
 860   this->functions_.back().blocks.back()->add_statement(statement);
 861 }
 862
 863 // Add a block.
 864
 865 void
 866 Gogo::add_block(Block* block, source_location location)
 867 {
 868   gcc_assert(!this->functions_.empty()
 869              && !this->functions_.back().blocks.empty());
 870   Statement* statement = Statement::make_block_statement(block, location);
 871   this->functions_.back().blocks.back()->add_statement(statement);
 872 }
 873
 874 // Add a constant.
 875
 876 Named_object*
 877 Gogo::add_constant(const Typed_identifier& tid, Expression* expr,
 878                    int iota_value)
 879 {
 880   return this->current_bindings()->add_constant(tid, NULL, expr, iota_value);
 881 }
 882
 883 // Add a type.
 884
 885 void
 886 Gogo::add_type(const std::string& name, Type* type, source_location location)
 887 {
 888   Named_object* no = this->current_bindings()->add_type(name, NULL, type,
 889                                                         location);
 890   if (!this->in_global_scope() && no->is_type())
 891     no->type_value()->set_in_function(this->functions_.back().function);
 892 }
 893
 894 // Add a named type.
 895
 896 void
 897 Gogo::add_named_type(Named_type* type)
 898 {
 899   gcc_assert(this->in_global_scope());
 900   this->current_bindings()->add_named_type(type);
 901 }
 902
 903 // Declare a type.
 904
 905 Named_object*
 906 Gogo::declare_type(const std::string& name, source_location location)
 907 {
 908   Bindings* bindings = this->current_bindings();
 909   Named_object* no = bindings->add_type_declaration(name, NULL, location);
 910   if (!this->in_global_scope() && no->is_type_declaration())
 911     {
 912       Named_object* f = this->functions_.back().function;
 913       no->type_declaration_value()->set_in_function(f);
 914     }
 915   return no;
 916 }
 917
 918 // Declare a type at the package level.
 919
 920 Named_object*
 921 Gogo::declare_package_type(const std::string& name, source_location location)
 922 {
 923   return this->package_->bindings()->add_type_declaration(name, NULL, location);
 924 }
 925
 926 // Define a type which was already declared.
 927
 928 void
 929 Gogo::define_type(Named_object* no, Named_type* type)
 930 {
 931   this->current_bindings()->define_type(no, type);
 932 }
 933
 934 // Add a variable.
 935
 936 Named_object*
 937 Gogo::add_variable(const std::string& name, Variable* variable)
 938 {
 939   Named_object* no = this->current_bindings()->add_variable(name, NULL,
 940                                                             variable);
 941
 942   // In a function the middle-end wants to see a DECL_EXPR node.
 943   if (no != NULL
 944       && no->is_variable()
 945       && !no->var_value()->is_parameter()
 946       && !this->functions_.empty())
 947     this->add_statement(Statement::make_variable_declaration(no));
 948
 949   return no;
 950 }
 951
 952 // Add a sink--a reference to the blank identifier _.
 953
 954 Named_object*
 955 Gogo::add_sink()
 956 {
 957   return Named_object::make_sink();
 958 }
 959
 960 // Add a named object.
 961
 962 void
 963 Gogo::add_named_object(Named_object* no)
 964 {
 965   this->current_bindings()->add_named_object(no);
 966 }
 967
 968 // Record that we've seen an interface type.
 969
 970 void
 971 Gogo::record_interface_type(Interface_type* itype)
 972 {
 973   this->interface_types_.push_back(itype);
 974 }
 975
 976 // Return a name for a thunk object.
 977
 978 std::string
 979 Gogo::thunk_name()
 980 {
 981   static int thunk_count;
 982   char thunk_name[50];
 983   snprintf(thunk_name, sizeof thunk_name, "$thunk%d", thunk_count);
 984   ++thunk_count;
 985   return thunk_name;
 986 }
 987
 988 // Return whether a function is a thunk.
 989
 990 bool
 991 Gogo::is_thunk(const Named_object* no)
 992 {
 993   return no->name().compare(0, 6, "$thunk") == 0;
 994 }
 995
 996 // Define the global names.  We do this only after parsing all the
 997 // input files, because the program might define the global names
 998 // itself.
 999
1000 void
1001 Gogo::define_global_names()
1002 {
1003   for (Bindings::const_declarations_iterator p =
1004          this->globals_->begin_declarations();
1005        p != this->globals_->end_declarations();
1006        ++p)
1007     {
1008       Named_object* global_no = p->second;
1009       std::string name(Gogo::pack_hidden_name(global_no->name(), false));
1010       Named_object* no = this->package_->bindings()->lookup(name);
1011       if (no == NULL)
1012         continue;
1013       no = no->resolve();
1014       if (no->is_type_declaration())
1015         {
1016           if (global_no->is_type())
1017             {
1018               if (no->type_declaration_value()->has_methods())
1019                 error_at(no->location(),
1020                          "may not define methods for global type");
1021               no->set_type_value(global_no->type_value());
1022             }
1023           else
1024             {
1025               error_at(no->location(), "expected type");
1026               Type* errtype = Type::make_error_type();
1027               Named_object* err = Named_object::make_type("error", NULL,
1028                                                           errtype,
1029                                                           BUILTINS_LOCATION);
1030               no->set_type_value(err->type_value());
1031             }
1032         }
1033       else if (no->is_unknown())
1034         no->unknown_value()->set_real_named_object(global_no);
1035     }
1036 }
1037
1038 // Clear out names in file scope.
1039
1040 void
1041 Gogo::clear_file_scope()
1042 {
1043   this->package_->bindings()->clear_file_scope();
1044
1045   // Warn about packages which were imported but not used.
1046   for (Packages::iterator p = this->packages_.begin();
1047        p != this->packages_.end();
1048        ++p)
1049     {
1050       Package* package = p->second;
1051       if (package != this->package_
1052           && package->is_imported()
1053           && !package->used()
1054           && !package->uses_sink_alias()
1055           && !saw_errors())
1056         error_at(package->location(), "imported and not used: %s",
1057                  Gogo::message_name(package->name()).c_str());
1058       package->clear_is_imported();
1059       package->clear_uses_sink_alias();
1060       package->clear_used();
1061     }
1062 }
1063
1064 // Traverse the tree.
1065
1066 void
1067 Gogo::traverse(Traverse* traverse)
1068 {
1069   // Traverse the current package first for consistency.  The other
1070   // packages will only contain imported types, constants, and
1071   // declarations.
1072   if (this->package_->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
1073     return;
1074   for (Packages::const_iterator p = this->packages_.begin();
1075        p != this->packages_.end();
1076        ++p)
1077     {
1078       if (p->second != this->package_)
1079         {
1080           if (p->second->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
1081             break;
1082         }
1083     }
1084 }
1085
1086 // Traversal class used to verify types.
1087
1088 class Verify_types : public Traverse
1089 {
1090  public:
1091   Verify_types()
1092     : Traverse(traverse_types)
1093   { }
1094
1095   int
1096   type(Type*);
1097 };
1098
1099 // Verify that a type is correct.
1100
1101 int
1102 Verify_types::type(Type* t)
1103 {
1104   // Don't verify types defined in other packages.
1105   Named_type* nt = t->named_type();
1106   if (nt != NULL && nt->named_object()->package() != NULL)
1107     return TRAVERSE_SKIP_COMPONENTS;
1108
1109   if (!t->verify())
1110     return TRAVERSE_SKIP_COMPONENTS;
1111   return TRAVERSE_CONTINUE;
1112 }
1113
1114 // Verify that all types are correct.
1115
1116 void
1117 Gogo::verify_types()
1118 {
1119   Verify_types traverse;
1120   this->traverse(&traverse);
1121 }
1122
1123 // Traversal class used to lower parse tree.
1124
1125 class Lower_parse_tree : public Traverse
1126 {
1127  public:
1128   Lower_parse_tree(Gogo* gogo, Named_object* function)
1129     : Traverse(traverse_constants
1130                | traverse_functions
1131                | traverse_statements
1132                | traverse_expressions),
1133       gogo_(gogo), function_(function), iota_value_(-1)
1134   { }
1135
1136   int
1137   constant(Named_object*, bool);
1138
1139   int
1140   function(Named_object*);
1141
1142   int
1143   statement(Block*, size_t* pindex, Statement*);
1144
1145   int
1146   expression(Expression**);
1147
1148  private:
1149   // General IR.
1150   Gogo* gogo_;
1151   // The function we are traversing.
1152   Named_object* function_;
1153   // Value to use for the predeclared constant iota.
1154   int iota_value_;
1155 };
1156
1157 // Lower constants.  We handle constants specially so that we can set
1158 // the right value for the predeclared constant iota.  This works in
1159 // conjunction with the way we lower Const_expression objects.
1160
1161 int
1162 Lower_parse_tree::constant(Named_object* no, bool)
1163 {
1164   Named_constant* nc = no->const_value();
1165
1166   // Don't get into trouble if the constant's initializer expression
1167   // refers to the constant itself.
1168   if (nc->lowering())
1169     return TRAVERSE_CONTINUE;
1170   nc->set_lowering();
1171
1172   gcc_assert(this->iota_value_ == -1);
1173   this->iota_value_ = nc->iota_value();
1174   nc->traverse_expression(this);
1175   this->iota_value_ = -1;
1176
1177   nc->clear_lowering();
1178
1179   // We will traverse the expression a second time, but that will be
1180   // fast.
1181
1182   return TRAVERSE_CONTINUE;
1183 }
1184
1185 // Lower function closure types.  Record the function while lowering
1186 // it, so that we can pass it down when lowering an expression.
1187
1188 int
1189 Lower_parse_tree::function(Named_object* no)
1190 {
1191   no->func_value()->set_closure_type();
1192
1193   gcc_assert(this->function_ == NULL);
1194   this->function_ = no;
1195   int t = no->func_value()->traverse(this);
1196   this->function_ = NULL;
1197
1198   if (t == TRAVERSE_EXIT)
1199     return t;
1200   return TRAVERSE_SKIP_COMPONENTS;
1201 }
1202
1203 // Lower statement parse trees.
1204
1205 int
1206 Lower_parse_tree::statement(Block* block, size_t* pindex, Statement* sorig)
1207 {
1208   // Lower the expressions first.
1209   int t = sorig->traverse_contents(this);
1210   if (t == TRAVERSE_EXIT)
1211     return t;
1212
1213   // Keep lowering until nothing changes.
1214   Statement* s = sorig;
1215   while (true)
1216     {
1217       Statement* snew = s->lower(this->gogo_, block);
1218       if (snew == s)
1219         break;
1220       s = snew;
1221       t = s->traverse_contents(this);
1222       if (t == TRAVERSE_EXIT)
1223         return t;
1224     }
1225
1226   if (s != sorig)
1227     block->replace_statement(*pindex, s);
1228
1229   return TRAVERSE_SKIP_COMPONENTS;
1230 }
1231
1232 // Lower expression parse trees.
1233
1234 int
1235 Lower_parse_tree::expression(Expression** pexpr)
1236 {
1237   // We have to lower all subexpressions first, so that we can get
1238   // their type if necessary.  This is awkward, because we don't have
1239   // a postorder traversal pass.
1240   if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
1241     return TRAVERSE_EXIT;
1242   // Keep lowering until nothing changes.
1243   while (true)
1244     {
1245       Expression* e = *pexpr;
1246       Expression* enew = e->lower(this->gogo_, this->function_,
1247                                   this->iota_value_);
1248       if (enew == e)
1249         break;
1250       *pexpr = enew;
1251     }
1252   return TRAVERSE_SKIP_COMPONENTS;
1253 }
1254
1255 // Lower the parse tree.  This is called after the parse is complete,
1256 // when all names should be resolved.
1257
1258 void
1259 Gogo::lower_parse_tree()
1260 {
1261   Lower_parse_tree lower_parse_tree(this, NULL);
1262   this->traverse(&lower_parse_tree);
1263 }
1264
1265 // Lower an expression.
1266
1267 void
1268 Gogo::lower_expression(Named_object* function, Expression** pexpr)
1269 {
1270   Lower_parse_tree lower_parse_tree(this, function);
1271   lower_parse_tree.expression(pexpr);
1272 }
1273
1274 // Lower a constant.  This is called when lowering a reference to a
1275 // constant.  We have to make sure that the constant has already been
1276 // lowered.
1277
1278 void
1279 Gogo::lower_constant(Named_object* no)
1280 {
1281   gcc_assert(no->is_const());
1282   Lower_parse_tree lower(this, NULL);
1283   lower.constant(no, false);
1284 }
1285
1286 // Look for interface types to finalize methods of inherited
1287 // interfaces.
1288
1289 class Finalize_methods : public Traverse
1290 {
1291  public:
1292   Finalize_methods(Gogo* gogo)
1293     : Traverse(traverse_types),
1294       gogo_(gogo)
1295   { }
1296
1297   int
1298   type(Type*);
1299
1300  private:
1301   Gogo* gogo_;
1302 };
1303
1304 // Finalize the methods of an interface type.
1305
1306 int
1307 Finalize_methods::type(Type* t)
1308 {
1309   // Check the classification so that we don't finalize the methods
1310   // twice for a named interface type.
1311   switch (t->classification())
1312     {
1313     case Type::TYPE_INTERFACE:
1314       t->interface_type()->finalize_methods();
1315       break;
1316
1317     case Type::TYPE_NAMED:
1318       {
1319         // We have to finalize the methods of the real type first.
1320         // But if the real type is a struct type, then we only want to
1321         // finalize the methods of the field types, not of the struct
1322         // type itself.  We don't want to add methods to the struct,
1323         // since it has a name.
1324         Type* rt = t->named_type()->real_type();
1325         if (rt->classification() != Type::TYPE_STRUCT)
1326           {
1327             if (Type::traverse(rt, this) == TRAVERSE_EXIT)
1328               return TRAVERSE_EXIT;
1329           }
1330         else
1331           {
1332             if (rt->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT)
1333               return TRAVERSE_EXIT;
1334           }
1335
1336         t->named_type()->finalize_methods(this->gogo_);
1337
1338         return TRAVERSE_SKIP_COMPONENTS;
1339       }
1340
1341     case Type::TYPE_STRUCT:
1342       t->struct_type()->finalize_methods(this->gogo_);
1343       break;
1344
1345     default:
1346       break;
1347     }
1348
1349   return TRAVERSE_CONTINUE;
1350 }
1351
1352 // Finalize method lists and build stub methods for types.
1353
1354 void
1355 Gogo::finalize_methods()
1356 {
1357   Finalize_methods finalize(this);
1358   this->traverse(&finalize);
1359 }
1360
1361 // Set types for unspecified variables and constants.
1362
1363 void
1364 Gogo::determine_types()
1365 {
1366   Bindings* bindings = this->current_bindings();
1367   for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
1368        p != bindings->end_definitions();
1369        ++p)
1370     {
1371       if ((*p)->is_function())
1372         (*p)->func_value()->determine_types();
1373       else if ((*p)->is_variable())
1374         (*p)->var_value()->determine_type();
1375       else if ((*p)->is_const())
1376         (*p)->const_value()->determine_type();
1377
1378       // See if a variable requires us to build an initialization
1379       // function.  We know that we will see all global variables
1380       // here.
1381       if (!this->need_init_fn_ && (*p)->is_variable())
1382         {
1383           Variable* variable = (*p)->var_value();
1384
1385           // If this is a global variable which requires runtime
1386           // initialization, we need an initialization function.
1387           if (!variable->is_global() || variable->init() == NULL)
1388             ;
1389           else if (variable->type()->interface_type() != NULL)
1390             this->need_init_fn_ = true;
1391           else if (variable->init()->is_constant())
1392             ;
1393           else if (!variable->init()->is_composite_literal())
1394             this->need_init_fn_ = true;
1395           else if (variable->init()->is_nonconstant_composite_literal())
1396             this->need_init_fn_ = true;
1397
1398           // If this is a global variable which holds a pointer value,
1399           // then we need an initialization function to register it as a
1400           // GC root.
1401           if (variable->is_global() && variable->type()->has_pointer())
1402             this->need_init_fn_ = true;
1403         }
1404     }
1405
1406   // Determine the types of constants in packages.
1407   for (Packages::const_iterator p = this->packages_.begin();
1408        p != this->packages_.end();
1409        ++p)
1410     p->second->determine_types();
1411 }
1412
1413 // Traversal class used for type checking.
1414
1415 class Check_types_traverse : public Traverse
1416 {
1417  public:
1418   Check_types_traverse(Gogo* gogo)
1419     : Traverse(traverse_variables
1420                | traverse_constants
1421                | traverse_statements
1422                | traverse_expressions),
1423       gogo_(gogo)
1424   { }
1425
1426   int
1427   variable(Named_object*);
1428
1429   int
1430   constant(Named_object*, bool);
1431
1432   int
1433   statement(Block*, size_t* pindex, Statement*);
1434
1435   int
1436   expression(Expression**);
1437
1438  private:
1439   // General IR.
1440   Gogo* gogo_;
1441 };
1442
1443 // Check that a variable initializer has the right type.
1444
1445 int
1446 Check_types_traverse::variable(Named_object* named_object)
1447 {
1448   if (named_object->is_variable())
1449     {
1450       Variable* var = named_object->var_value();
1451       Expression* init = var->init();
1452       std::string reason;
1453       if (init != NULL
1454           && !Type::are_assignable(var->type(), init->type(), &reason))
1455         {
1456           if (reason.empty())
1457             error_at(var->location(), "incompatible type in initialization");
1458           else
1459             error_at(var->location(),
1460                      "incompatible type in initialization (%s)",
1461                      reason.c_str());
1462           var->clear_init();
1463         }
1464     }
1465   return TRAVERSE_CONTINUE;
1466 }
1467
1468 // Check that a constant initializer has the right type.
1469
1470 int
1471 Check_types_traverse::constant(Named_object* named_object, bool)
1472 {
1473   Named_constant* constant = named_object->const_value();
1474   Type* ctype = constant->type();
1475   if (ctype->integer_type() == NULL
1476       && ctype->float_type() == NULL
1477       && ctype->complex_type() == NULL
1478       && !ctype->is_boolean_type()
1479       && !ctype->is_string_type())
1480     {
1481       if (!ctype->is_error_type())
1482         error_at(constant->location(), "invalid constant type");
1483       constant->set_error();
1484     }
1485   else if (!constant->expr()->is_constant())
1486     {
1487       error_at(constant->expr()->location(), "expression is not constant");
1488       constant->set_error();
1489     }
1490   else if (!Type::are_assignable(constant->type(), constant->expr()->type(),
1491                                  NULL))
1492     {
1493       error_at(constant->location(),
1494                "initialization expression has wrong type");
1495       constant->set_error();
1496     }
1497   return TRAVERSE_CONTINUE;
1498 }
1499
1500 // Check that types are valid in a statement.
1501
1502 int
1503 Check_types_traverse::statement(Block*, size_t*, Statement* s)
1504 {
1505   s->check_types(this->gogo_);
1506   return TRAVERSE_CONTINUE;
1507 }
1508
1509 // Check that types are valid in an expression.
1510
1511 int
1512 Check_types_traverse::expression(Expression** expr)
1513 {
1514   (*expr)->check_types(this->gogo_);
1515   return TRAVERSE_CONTINUE;
1516 }
1517
1518 // Check that types are valid.
1519
1520 void
1521 Gogo::check_types()
1522 {
1523   Check_types_traverse traverse(this);
1524   this->traverse(&traverse);
1525 }
1526
1527 // Check the types in a single block.
1528
1529 void
1530 Gogo::check_types_in_block(Block* block)
1531 {
1532   Check_types_traverse traverse(this);
1533   block->traverse(&traverse);
1534 }
1535
1536 // A traversal class used to find a single shortcut operator within an
1537 // expression.
1538
1539 class Find_shortcut : public Traverse
1540 {
1541  public:
1542   Find_shortcut()
1543     : Traverse(traverse_blocks
1544                | traverse_statements
1545                | traverse_expressions),
1546       found_(NULL)
1547   { }
1548
1549   // A pointer to the expression which was found, or NULL if none was
1550   // found.
1551   Expression**
1552   found() const
1553   { return this->found_; }
1554
1555  protected:
1556   int
1557   block(Block*)
1558   { return TRAVERSE_SKIP_COMPONENTS; }
1559
1560   int
1561   statement(Block*, size_t*, Statement*)
1562   { return TRAVERSE_SKIP_COMPONENTS; }
1563
1564   int
1565   expression(Expression**);
1566
1567  private:
1568   Expression** found_;
1569 };
1570
1571 // Find a shortcut expression.
1572
1573 int
1574 Find_shortcut::expression(Expression** pexpr)
1575 {
1576   Expression* expr = *pexpr;
1577   Binary_expression* be = expr->binary_expression();
1578   if (be == NULL)
1579     return TRAVERSE_CONTINUE;
1580   Operator op = be->op();
1581   if (op != OPERATOR_OROR && op != OPERATOR_ANDAND)
1582     return TRAVERSE_CONTINUE;
1583   gcc_assert(this->found_ == NULL);
1584   this->found_ = pexpr;
1585   return TRAVERSE_EXIT;
1586 }
1587
1588 // A traversal class used to turn shortcut operators into explicit if
1589 // statements.
1590
1591 class Shortcuts : public Traverse
1592 {
1593  public:
1594   Shortcuts()
1595     : Traverse(traverse_variables
1596                | traverse_statements)
1597   { }
1598
1599  protected:
1600   int
1601   variable(Named_object*);
1602
1603   int
1604   statement(Block*, size_t*, Statement*);
1605
1606  private:
1607   // Convert a shortcut operator.
1608   Statement*
1609   convert_shortcut(Block* enclosing, Expression** pshortcut);
1610 };
1611
1612 // Remove shortcut operators in a single statement.
1613
1614 int
1615 Shortcuts::statement(Block* block, size_t* pindex, Statement* s)
1616 {
1617   // FIXME: This approach doesn't work for switch statements, because
1618   // we add the new statements before the whole switch when we need to
1619   // instead add them just before the switch expression.  The right
1620   // fix is probably to lower switch statements with nonconstant cases
1621   // to a series of conditionals.
1622   if (s->switch_statement() != NULL)
1623     return TRAVERSE_CONTINUE;
1624
1625   while (true)
1626     {
1627       Find_shortcut find_shortcut;
1628
1629       // If S is a variable declaration, then ordinary traversal won't
1630       // do anything.  We want to explicitly traverse the
1631       // initialization expression if there is one.
1632       Variable_declaration_statement* vds = s->variable_declaration_statement();
1633       Expression* init = NULL;
1634       if (vds == NULL)
1635         s->traverse_contents(&find_shortcut);
1636       else
1637         {
1638           init = vds->var()->var_value()->init();
1639           if (init == NULL)
1640             return TRAVERSE_CONTINUE;
1641           init->traverse(&init, &find_shortcut);
1642         }
1643       Expression** pshortcut = find_shortcut.found();
1644       if (pshortcut == NULL)
1645         return TRAVERSE_CONTINUE;
1646
1647       Statement* snew = this->convert_shortcut(block, pshortcut);
1648       block->insert_statement_before(*pindex, snew);
1649       ++*pindex;
1650
1651       if (pshortcut == &init)
1652         vds->var()->var_value()->set_init(init);
1653     }
1654 }
1655
1656 // Remove shortcut operators in the initializer of a global variable.
1657
1658 int
1659 Shortcuts::variable(Named_object* no)
1660 {
1661   if (no->is_result_variable())
1662     return TRAVERSE_CONTINUE;
1663   Variable* var = no->var_value();
1664   Expression* init = var->init();
1665   if (!var->is_global() || init == NULL)
1666     return TRAVERSE_CONTINUE;
1667
1668   while (true)
1669     {
1670       Find_shortcut find_shortcut;
1671       init->traverse(&init, &find_shortcut);
1672       Expression** pshortcut = find_shortcut.found();
1673       if (pshortcut == NULL)
1674         return TRAVERSE_CONTINUE;
1675
1676       Statement* snew = this->convert_shortcut(NULL, pshortcut);
1677       var->add_preinit_statement(snew);
1678       if (pshortcut == &init)
1679         var->set_init(init);
1680     }
1681 }
1682
1683 // Given an expression which uses a shortcut operator, return a
1684 // statement which implements it, and update *PSHORTCUT accordingly.
1685
1686 Statement*
1687 Shortcuts::convert_shortcut(Block* enclosing, Expression** pshortcut)
1688 {
1689   Binary_expression* shortcut = (*pshortcut)->binary_expression();
1690   Expression* left = shortcut->left();
1691   Expression* right = shortcut->right();
1692   source_location loc = shortcut->location();
1693
1694   Block* retblock = new Block(enclosing, loc);
1695   retblock->set_end_location(loc);
1696
1697   Temporary_statement* ts = Statement::make_temporary(Type::make_boolean_type(),
1698                                                       left, loc);
1699   retblock->add_statement(ts);
1700
1701   Block* block = new Block(retblock, loc);
1702   block->set_end_location(loc);
1703   Expression* tmpref = Expression::make_temporary_reference(ts, loc);
1704   Statement* assign = Statement::make_assignment(tmpref, right, loc);
1705   block->add_statement(assign);
1706
1707   Expression* cond = Expression::make_temporary_reference(ts, loc);
1708   if (shortcut->binary_expression()->op() == OPERATOR_OROR)
1709     cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
1710
1711   Statement* if_statement = Statement::make_if_statement(cond, block, NULL,
1712                                                          loc);
1713   retblock->add_statement(if_statement);
1714
1715   *pshortcut = Expression::make_temporary_reference(ts, loc);
1716
1717   delete shortcut;
1718
1719   // Now convert any shortcut operators in LEFT and RIGHT.
1720   Shortcuts shortcuts;
1721   retblock->traverse(&shortcuts);
1722
1723   return Statement::make_block_statement(retblock, loc);
1724 }
1725
1726 // Turn shortcut operators into explicit if statements.  Doing this
1727 // considerably simplifies the order of evaluation rules.
1728
1729 void
1730 Gogo::remove_shortcuts()
1731 {
1732   Shortcuts shortcuts;
1733   this->traverse(&shortcuts);
1734 }
1735
1736 // A traversal class which finds all the expressions which must be
1737 // evaluated in order within a statement or larger expression.  This
1738 // is used to implement the rules about order of evaluation.
1739
1740 class Find_eval_ordering : public Traverse
1741 {
1742  private:
1743   typedef std::vector<Expression**> Expression_pointers;
1744
1745  public:
1746   Find_eval_ordering()
1747     : Traverse(traverse_blocks
1748                | traverse_statements
1749                | traverse_expressions),
1750       exprs_()
1751   { }
1752
1753   size_t
1754   size() const
1755   { return this->exprs_.size(); }
1756
1757   typedef Expression_pointers::const_iterator const_iterator;
1758
1759   const_iterator
1760   begin() const
1761   { return this->exprs_.begin(); }
1762
1763   const_iterator
1764   end() const
1765   { return this->exprs_.end(); }
1766
1767  protected:
1768   int
1769   block(Block*)
1770   { return TRAVERSE_SKIP_COMPONENTS; }
1771
1772   int
1773   statement(Block*, size_t*, Statement*)
1774   { return TRAVERSE_SKIP_COMPONENTS; }
1775
1776   int
1777   expression(Expression**);
1778
1779  private:
1780   // A list of pointers to expressions with side-effects.
1781   Expression_pointers exprs_;
1782 };
1783
1784 // If an expression must be evaluated in order, put it on the list.
1785
1786 int
1787 Find_eval_ordering::expression(Expression** expression_pointer)
1788 {
1789   // We have to look at subexpressions before this one.
1790   if ((*expression_pointer)->traverse_subexpressions(this) == TRAVERSE_EXIT)
1791     return TRAVERSE_EXIT;
1792   if ((*expression_pointer)->must_eval_in_order())
1793     this->exprs_.push_back(expression_pointer);
1794   return TRAVERSE_SKIP_COMPONENTS;
1795 }
1796
1797 // A traversal class for ordering evaluations.
1798
1799 class Order_eval : public Traverse
1800 {
1801  public:
1802   Order_eval()
1803     : Traverse(traverse_variables
1804                | traverse_statements)
1805   { }
1806
1807   int
1808   variable(Named_object*);
1809
1810   int
1811   statement(Block*, size_t*, Statement*);
1812 };
1813
1814 // Implement the order of evaluation rules for a statement.
1815
1816 int
1817 Order_eval::statement(Block* block, size_t* pindex, Statement* s)
1818 {
1819   // FIXME: This approach doesn't work for switch statements, because
1820   // we add the new statements before the whole switch when we need to
1821   // instead add them just before the switch expression.  The right
1822   // fix is probably to lower switch statements with nonconstant cases
1823   // to a series of conditionals.
1824   if (s->switch_statement() != NULL)
1825     return TRAVERSE_CONTINUE;
1826
1827   Find_eval_ordering find_eval_ordering;
1828
1829   // If S is a variable declaration, then ordinary traversal won't do
1830   // anything.  We want to explicitly traverse the initialization
1831   // expression if there is one.
1832   Variable_declaration_statement* vds = s->variable_declaration_statement();
1833   Expression* init = NULL;
1834   Expression* orig_init = NULL;
1835   if (vds == NULL)
1836     s->traverse_contents(&find_eval_ordering);
1837   else
1838     {
1839       init = vds->var()->var_value()->init();
1840       if (init == NULL)
1841         return TRAVERSE_CONTINUE;
1842       orig_init = init;
1843
1844       // It might seem that this could be
1845       // init->traverse_subexpressions.  Unfortunately that can fail
1846       // in a case like
1847       //   var err os.Error
1848       //   newvar, err := call(arg())
1849       // Here newvar will have an init of call result 0 of
1850       // call(arg()).  If we only traverse subexpressions, we will
1851       // only find arg(), and we won't bother to move anything out.
1852       // Then we get to the assignment to err, we will traverse the
1853       // whole statement, and this time we will find both call() and
1854       // arg(), and so we will move them out.  This will cause them to
1855       // be put into temporary variables before the assignment to err
1856       // but after the declaration of newvar.  To avoid that problem,
1857       // we traverse the entire expression here.
1858       Expression::traverse(&init, &find_eval_ordering);
1859     }
1860
1861   if (find_eval_ordering.size() <= 1)
1862     {
1863       // If there is only one expression with a side-effect, we can
1864       // leave it in place.
1865       return TRAVERSE_CONTINUE;
1866     }
1867
1868   bool is_thunk = s->thunk_statement() != NULL;
1869   for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
1870        p != find_eval_ordering.end();
1871        ++p)
1872     {
1873       Expression** pexpr = *p;
1874
1875       // If the last expression is a send or receive expression, we
1876       // may be ignoring the value; we don't want to evaluate it
1877       // early.
1878       if (p + 1 == find_eval_ordering.end()
1879           && ((*pexpr)->classification() == Expression::EXPRESSION_SEND
1880               || (*pexpr)->classification() == Expression::EXPRESSION_RECEIVE))
1881         break;
1882
1883       // The last expression in a thunk will be the call passed to go
1884       // or defer, which we must not evaluate early.
1885       if (is_thunk && p + 1 == find_eval_ordering.end())
1886         break;
1887
1888       source_location loc = (*pexpr)->location();
1889       Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
1890       block->insert_statement_before(*pindex, ts);
1891       ++*pindex;
1892
1893       *pexpr = Expression::make_temporary_reference(ts, loc);
1894     }
1895
1896   if (init != orig_init)
1897     vds->var()->var_value()->set_init(init);
1898
1899   return TRAVERSE_CONTINUE;
1900 }
1901
1902 // Implement the order of evaluation rules for the initializer of a
1903 // global variable.
1904
1905 int
1906 Order_eval::variable(Named_object* no)
1907 {
1908   if (no->is_result_variable())
1909     return TRAVERSE_CONTINUE;
1910   Variable* var = no->var_value();
1911   Expression* init = var->init();
1912   if (!var->is_global() || init == NULL)
1913     return TRAVERSE_CONTINUE;
1914
1915   Find_eval_ordering find_eval_ordering;
1916   init->traverse_subexpressions(&find_eval_ordering);
1917
1918   if (find_eval_ordering.size() <= 1)
1919     {
1920       // If there is only one expression with a side-effect, we can
1921       // leave it in place.
1922       return TRAVERSE_SKIP_COMPONENTS;
1923     }
1924
1925   for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
1926        p != find_eval_ordering.end();
1927        ++p)
1928     {
1929       Expression** pexpr = *p;
1930       source_location loc = (*pexpr)->location();
1931       Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
1932       var->add_preinit_statement(ts);
1933       *pexpr = Expression::make_temporary_reference(ts, loc);
1934     }
1935
1936   return TRAVERSE_SKIP_COMPONENTS;
1937 }
1938
1939 // Use temporary variables to implement the order of evaluation rules.
1940
1941 void
1942 Gogo::order_evaluations()
1943 {
1944   Order_eval order_eval;
1945   this->traverse(&order_eval);
1946 }
1947
1948 // Traversal to convert calls to the predeclared recover function to
1949 // pass in an argument indicating whether it can recover from a panic
1950 // or not.
1951
1952 class Convert_recover : public Traverse
1953 {
1954  public:
1955   Convert_recover(Named_object* arg)
1956     : Traverse(traverse_expressions),
1957       arg_(arg)
1958   { }
1959
1960  protected:
1961   int
1962   expression(Expression**);
1963
1964  private:
1965   // The argument to pass to the function.
1966   Named_object* arg_;
1967 };
1968
1969 // Convert calls to recover.
1970
1971 int
1972 Convert_recover::expression(Expression** pp)
1973 {
1974   Call_expression* ce = (*pp)->call_expression();
1975   if (ce != NULL && ce->is_recover_call())
1976     ce->set_recover_arg(Expression::make_var_reference(this->arg_,
1977                                                        ce->location()));
1978   return TRAVERSE_CONTINUE;
1979 }
1980
1981 // Traversal for build_recover_thunks.
1982
1983 class Build_recover_thunks : public Traverse
1984 {
1985  public:
1986   Build_recover_thunks(Gogo* gogo)
1987     : Traverse(traverse_functions),
1988       gogo_(gogo)
1989   { }
1990
1991   int
1992   function(Named_object*);
1993
1994  private:
1995   Expression*
1996   can_recover_arg(source_location);
1997
1998   // General IR.
1999   Gogo* gogo_;
2000 };
2001
2002 // If this function calls recover, turn it into a thunk.
2003
2004 int
2005 Build_recover_thunks::function(Named_object* orig_no)
2006 {
2007   Function* orig_func = orig_no->func_value();
2008   if (!orig_func->calls_recover()
2009       || orig_func->is_recover_thunk()
2010       || orig_func->has_recover_thunk())
2011     return TRAVERSE_CONTINUE;
2012
2013   Gogo* gogo = this->gogo_;
2014   source_location location = orig_func->location();
2015
2016   static int count;
2017   char buf[50];
2018
2019   Function_type* orig_fntype = orig_func->type();
2020   Typed_identifier_list* new_params = new Typed_identifier_list();
2021   std::string receiver_name;
2022   if (orig_fntype->is_method())
2023     {
2024       const Typed_identifier* receiver = orig_fntype->receiver();
2025       snprintf(buf, sizeof buf, "rt.%u", count);
2026       ++count;
2027       receiver_name = buf;
2028       new_params->push_back(Typed_identifier(receiver_name, receiver->type(),
2029                                              receiver->location()));
2030     }
2031   const Typed_identifier_list* orig_params = orig_fntype->parameters();
2032   if (orig_params != NULL && !orig_params->empty())
2033     {
2034       for (Typed_identifier_list::const_iterator p = orig_params->begin();
2035            p != orig_params->end();
2036            ++p)
2037         {
2038           snprintf(buf, sizeof buf, "pt.%u", count);
2039           ++count;
2040           new_params->push_back(Typed_identifier(buf, p->type(),
2041                                                  p->location()));
2042         }
2043     }
2044   snprintf(buf, sizeof buf, "pr.%u", count);
2045   ++count;
2046   std::string can_recover_name = buf;
2047   new_params->push_back(Typed_identifier(can_recover_name,
2048                                          Type::make_boolean_type(),
2049                                          orig_fntype->location()));
2050
2051   const Typed_identifier_list* orig_results = orig_fntype->results();
2052   Typed_identifier_list* new_results;
2053   if (orig_results == NULL || orig_results->empty())
2054     new_results = NULL;
2055   else
2056     {
2057       new_results = new Typed_identifier_list();
2058       for (Typed_identifier_list::const_iterator p = orig_results->begin();
2059            p != orig_results->end();
2060            ++p)
2061         new_results->push_back(*p);
2062     }
2063
2064   Function_type *new_fntype = Type::make_function_type(NULL, new_params,
2065                                                        new_results,
2066                                                        orig_fntype->location());
2067   if (orig_fntype->is_varargs())
2068     new_fntype->set_is_varargs();
2069
2070   std::string name = orig_no->name() + "$recover";
2071   Named_object *new_no = gogo->start_function(name, new_fntype, false,
2072                                               location);
2073   Function *new_func = new_no->func_value();
2074   if (orig_func->enclosing() != NULL)
2075     new_func->set_enclosing(orig_func->enclosing());
2076
2077   // We build the code for the original function attached to the new
2078   // function, and then swap the original and new function bodies.
2079   // This means that existing references to the original function will
2080   // then refer to the new function.  That makes this code a little
2081   // confusing, in that the reference to NEW_NO really refers to the
2082   // other function, not the one we are building.
2083
2084   Expression* closure = NULL;
2085   if (orig_func->needs_closure())
2086     {
2087       Named_object* orig_closure_no = orig_func->closure_var();
2088       Variable* orig_closure_var = orig_closure_no->var_value();
2089       Variable* new_var = new Variable(orig_closure_var->type(), NULL, false,
2090                                        true, false, location);
2091       snprintf(buf, sizeof buf, "closure.%u", count);
2092       ++count;
2093       Named_object* new_closure_no = Named_object::make_variable(buf, NULL,
2094                                                                  new_var);
2095       new_func->set_closure_var(new_closure_no);
2096       closure = Expression::make_var_reference(new_closure_no, location);
2097     }
2098
2099   Expression* fn = Expression::make_func_reference(new_no, closure, location);
2100
2101   Expression_list* args = new Expression_list();
2102   if (new_params != NULL)
2103     {
2104       // Note that we skip the last parameter, which is the boolean
2105       // indicating whether recover can succed.
2106       for (Typed_identifier_list::const_iterator p = new_params->begin();
2107            p + 1 != new_params->end();
2108            ++p)
2109         {
2110           Named_object* p_no = gogo->lookup(p->name(), NULL);
2111           gcc_assert(p_no != NULL
2112                      && p_no->is_variable()
2113                      && p_no->var_value()->is_parameter());
2114           args->push_back(Expression::make_var_reference(p_no, location));
2115         }
2116     }
2117   args->push_back(this->can_recover_arg(location));
2118
2119   Expression* call = Expression::make_call(fn, args, false, location);
2120
2121   Statement* s;
2122   if (orig_fntype->results() == NULL || orig_fntype->results()->empty())
2123     s = Statement::make_statement(call);
2124   else
2125     {
2126       Expression_list* vals = new Expression_list();
2127       vals->push_back(call);
2128       s = Statement::make_return_statement(new_func->type()->results(),
2129                                            vals, location);
2130     }
2131   s->determine_types();
2132   gogo->add_statement(s);
2133
2134   gogo->finish_function(location);
2135
2136   // Swap the function bodies and types.
2137   new_func->swap_for_recover(orig_func);
2138   orig_func->set_is_recover_thunk();
2139   new_func->set_calls_recover();
2140   new_func->set_has_recover_thunk();
2141
2142   Bindings* orig_bindings = orig_func->block()->bindings();
2143   Bindings* new_bindings = new_func->block()->bindings();
2144   if (orig_fntype->is_method())
2145     {
2146       // We changed the receiver to be a regular parameter.  We have
2147       // to update the binding accordingly in both functions.
2148       Named_object* orig_rec_no = orig_bindings->lookup_local(receiver_name);
2149       gcc_assert(orig_rec_no != NULL
2150                  && orig_rec_no->is_variable()
2151                  && !orig_rec_no->var_value()->is_receiver());
2152       orig_rec_no->var_value()->set_is_receiver();
2153
2154       const std::string& new_receiver_name(orig_fntype->receiver()->name());
2155       Named_object* new_rec_no = new_bindings->lookup_local(new_receiver_name);
2156       gcc_assert(new_rec_no != NULL
2157                  && new_rec_no->is_variable()
2158                  && new_rec_no->var_value()->is_receiver());
2159       new_rec_no->var_value()->set_is_not_receiver();
2160     }
2161
2162   // Because we flipped blocks but not types, the can_recover
2163   // parameter appears in the (now) old bindings as a parameter.
2164   // Change it to a local variable, whereupon it will be discarded.
2165   Named_object* can_recover_no = orig_bindings->lookup_local(can_recover_name);
2166   gcc_assert(can_recover_no != NULL
2167              && can_recover_no->is_variable()
2168              && can_recover_no->var_value()->is_parameter());
2169   orig_bindings->remove_binding(can_recover_no);
2170
2171   // Add the can_recover argument to the (now) new bindings, and
2172   // attach it to any recover statements.
2173   Variable* can_recover_var = new Variable(Type::make_boolean_type(), NULL,
2174                                            false, true, false, location);
2175   can_recover_no = new_bindings->add_variable(can_recover_name, NULL,
2176                                               can_recover_var);
2177   Convert_recover convert_recover(can_recover_no);
2178   new_func->traverse(&convert_recover);
2179
2180   return TRAVERSE_CONTINUE;
2181 }
2182
2183 // Return the expression to pass for the .can_recover parameter to the
2184 // new function.  This indicates whether a call to recover may return
2185 // non-nil.  The expression is
2186 // __go_can_recover(__builtin_return_address()).
2187
2188 Expression*
2189 Build_recover_thunks::can_recover_arg(source_location location)
2190 {
2191   static Named_object* builtin_return_address;
2192   if (builtin_return_address == NULL)
2193     {
2194       const source_location bloc = BUILTINS_LOCATION;
2195
2196       Typed_identifier_list* param_types = new Typed_identifier_list();
2197       Type* uint_type = Type::lookup_integer_type("uint");
2198       param_types->push_back(Typed_identifier("l", uint_type, bloc));
2199
2200       Typed_identifier_list* return_types = new Typed_identifier_list();
2201       Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
2202       return_types->push_back(Typed_identifier("", voidptr_type, bloc));
2203
2204       Function_type* fntype = Type::make_function_type(NULL, param_types,
2205                                                        return_types, bloc);
2206       builtin_return_address =
2207         Named_object::make_function_declaration("__builtin_return_address",
2208                                                 NULL, fntype, bloc);
2209       const char* n = "__builtin_return_address";
2210       builtin_return_address->func_declaration_value()->set_asm_name(n);
2211     }
2212
2213   static Named_object* can_recover;
2214   if (can_recover == NULL)
2215     {
2216       const source_location bloc = BUILTINS_LOCATION;
2217       Typed_identifier_list* param_types = new Typed_identifier_list();
2218       Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
2219       param_types->push_back(Typed_identifier("a", voidptr_type, bloc));
2220       Type* boolean_type = Type::make_boolean_type();
2221       Typed_identifier_list* results = new Typed_identifier_list();
2222       results->push_back(Typed_identifier("", boolean_type, bloc));
2223       Function_type* fntype = Type::make_function_type(NULL, param_types,
2224                                                        results, bloc);
2225       can_recover = Named_object::make_function_declaration("__go_can_recover",
2226                                                             NULL, fntype,
2227                                                             bloc);
2228       can_recover->func_declaration_value()->set_asm_name("__go_can_recover");
2229     }
2230
2231   Expression* fn = Expression::make_func_reference(builtin_return_address,
2232                                                    NULL, location);
2233
2234   mpz_t zval;
2235   mpz_init_set_ui(zval, 0UL);
2236   Expression* zexpr = Expression::make_integer(&zval, NULL, location);
2237   mpz_clear(zval);
2238   Expression_list *args = new Expression_list();
2239   args->push_back(zexpr);
2240
2241   Expression* call = Expression::make_call(fn, args, false, location);
2242
2243   args = new Expression_list();
2244   args->push_back(call);
2245
2246   fn = Expression::make_func_reference(can_recover, NULL, location);
2247   return Expression::make_call(fn, args, false, location);
2248 }
2249
2250 // Build thunks for functions which call recover.  We build a new
2251 // function with an extra parameter, which is whether a call to
2252 // recover can succeed.  We then move the body of this function to
2253 // that one.  We then turn this function into a thunk which calls the
2254 // new one, passing the value of
2255 // __go_can_recover(__builtin_return_address()).  The function will be
2256 // marked as not splitting the stack.  This will cooperate with the
2257 // implementation of defer to make recover do the right thing.
2258
2259 void
2260 Gogo::build_recover_thunks()
2261 {
2262   Build_recover_thunks build_recover_thunks(this);
2263   this->traverse(&build_recover_thunks);
2264 }
2265
2266 // Look for named types to see whether we need to create an interface
2267 // method table.
2268
2269 class Build_method_tables : public Traverse
2270 {
2271  public:
2272   Build_method_tables(Gogo* gogo,
2273                       const std::vector<Interface_type*>& interfaces)
2274     : Traverse(traverse_types),
2275       gogo_(gogo), interfaces_(interfaces)
2276   { }
2277
2278   int
2279   type(Type*);
2280
2281  private:
2282   // The IR.
2283   Gogo* gogo_;
2284   // A list of locally defined interfaces which have hidden methods.
2285   const std::vector<Interface_type*>& interfaces_;
2286 };
2287
2288 // Build all required interface method tables for types.  We need to
2289 // ensure that we have an interface method table for every interface
2290 // which has a hidden method, for every named type which implements
2291 // that interface.  Normally we can just build interface method tables
2292 // as we need them.  However, in some cases we can require an
2293 // interface method table for an interface defined in a different
2294 // package for a type defined in that package.  If that interface and
2295 // type both use a hidden method, that is OK.  However, we will not be
2296 // able to build that interface method table when we need it, because
2297 // the type's hidden method will be static.  So we have to build it
2298 // here, and just refer it from other packages as needed.
2299
2300 void
2301 Gogo::build_interface_method_tables()
2302 {
2303   std::vector<Interface_type*> hidden_interfaces;
2304   hidden_interfaces.reserve(this->interface_types_.size());
2305   for (std::vector<Interface_type*>::const_iterator pi =
2306          this->interface_types_.begin();
2307        pi != this->interface_types_.end();
2308        ++pi)
2309     {
2310       const Typed_identifier_list* methods = (*pi)->methods();
2311       if (methods == NULL)
2312         continue;
2313       for (Typed_identifier_list::const_iterator pm = methods->begin();
2314            pm != methods->end();
2315            ++pm)
2316         {
2317           if (Gogo::is_hidden_name(pm->name()))
2318             {
2319               hidden_interfaces.push_back(*pi);
2320               break;
2321             }
2322         }
2323     }
2324
2325   if (!hidden_interfaces.empty())
2326     {
2327       // Now traverse the tree looking for all named types.
2328       Build_method_tables bmt(this, hidden_interfaces);
2329       this->traverse(&bmt);
2330     }
2331
2332   // We no longer need the list of interfaces.
2333
2334   this->interface_types_.clear();
2335 }
2336
2337 // This is called for each type.  For a named type, for each of the
2338 // interfaces with hidden methods that it implements, create the
2339 // method table.
2340
2341 int
2342 Build_method_tables::type(Type* type)
2343 {
2344   Named_type* nt = type->named_type();
2345   if (nt != NULL)
2346     {
2347       for (std::vector<Interface_type*>::const_iterator p =
2348              this->interfaces_.begin();
2349            p != this->interfaces_.end();
2350            ++p)
2351         {
2352           // We ask whether a pointer to the named type implements the
2353           // interface, because a pointer can implement more methods
2354           // than a value.
2355           if ((*p)->implements_interface(Type::make_pointer_type(nt), NULL))
2356             {
2357               nt->interface_method_table(this->gogo_, *p, false);
2358               nt->interface_method_table(this->gogo_, *p, true);
2359             }
2360         }
2361     }
2362   return TRAVERSE_CONTINUE;
2363 }
2364
2365 // Traversal class used to check for return statements.
2366
2367 class Check_return_statements_traverse : public Traverse
2368 {
2369  public:
2370   Check_return_statements_traverse()
2371     : Traverse(traverse_functions)
2372   { }
2373
2374   int
2375   function(Named_object*);
2376 };
2377
2378 // Check that a function has a return statement if it needs one.
2379
2380 int
2381 Check_return_statements_traverse::function(Named_object* no)
2382 {
2383   Function* func = no->func_value();
2384   const Function_type* fntype = func->type();
2385   const Typed_identifier_list* results = fntype->results();
2386
2387   // We only need a return statement if there is a return value.
2388   if (results == NULL || results->empty())
2389     return TRAVERSE_CONTINUE;
2390
2391   if (func->block()->may_fall_through())
2392     error_at(func->location(), "control reaches end of non-void function");
2393
2394   return TRAVERSE_CONTINUE;
2395 }
2396
2397 // Check return statements.
2398
2399 void
2400 Gogo::check_return_statements()
2401 {
2402   Check_return_statements_traverse traverse;
2403   this->traverse(&traverse);
2404 }
2405
2406 // Get the unique prefix to use before all exported symbols.  This
2407 // must be unique across the entire link.
2408
2409 const std::string&
2410 Gogo::unique_prefix() const
2411 {
2412   gcc_assert(!this->unique_prefix_.empty());
2413   return this->unique_prefix_;
2414 }
2415
2416 // Set the unique prefix to use before all exported symbols.  This
2417 // comes from the command line option -fgo-prefix=XXX.
2418
2419 void
2420 Gogo::set_unique_prefix(const std::string& arg)
2421 {
2422   gcc_assert(this->unique_prefix_.empty());
2423   this->unique_prefix_ = arg;
2424 }
2425
2426 // Work out the package priority.  It is one more than the maximum
2427 // priority of an imported package.
2428
2429 int
2430 Gogo::package_priority() const
2431 {
2432   int priority = 0;
2433   for (Packages::const_iterator p = this->packages_.begin();
2434        p != this->packages_.end();
2435        ++p)
2436     if (p->second->priority() > priority)
2437       priority = p->second->priority();
2438   return priority + 1;
2439 }
2440
2441 // Export identifiers as requested.
2442
2443 void
2444 Gogo::do_exports()
2445 {
2446   // For now we always stream to a section.  Later we may want to
2447   // support streaming to a separate file.
2448   Stream_to_section stream;
2449
2450   Export exp(&stream);
2451   exp.register_builtin_types(this);
2452   exp.export_globals(this->package_name(),
2453                      this->unique_prefix(),
2454                      this->package_priority(),
2455                      (this->need_init_fn_ && this->package_name() != "main"
2456                       ? this->get_init_fn_name()
2457                       : ""),
2458                      this->imported_init_fns_,
2459                      this->package_->bindings());
2460 }
2461
2462 // Class Function.
2463
2464 Function::Function(Function_type* type, Function* enclosing, Block* block,
2465                    source_location location)
2466   : type_(type), enclosing_(enclosing), named_results_(NULL),
2467     closure_var_(NULL), block_(block), location_(location), fndecl_(NULL),
2468     defer_stack_(NULL), calls_recover_(false), is_recover_thunk_(false),
2469     has_recover_thunk_(false)
2470 {
2471 }
2472
2473 // Create the named result variables.
2474
2475 void
2476 Function::create_named_result_variables(Gogo* gogo)
2477 {
2478   const Typed_identifier_list* results = this->type_->results();
2479   if (results == NULL
2480       || results->empty()
2481       || results->front().name().empty())
2482     return;
2483
2484   this->named_results_ = new Named_results();
2485   this->named_results_->reserve(results->size());
2486
2487   Block* block = this->block_;
2488   int index = 0;
2489   for (Typed_identifier_list::const_iterator p = results->begin();
2490        p != results->end();
2491        ++p, ++index)
2492     {
2493       std::string name = p->name();
2494       if (Gogo::is_sink_name(name))
2495         {
2496           static int unnamed_result_counter;
2497           char buf[100];
2498           snprintf(buf, sizeof buf, "_$%d", unnamed_result_counter);
2499           ++unnamed_result_counter;
2500           name = gogo->pack_hidden_name(buf, false);
2501         }
2502       Result_variable* result = new Result_variable(p->type(), this, index);
2503       Named_object* no = block->bindings()->add_result_variable(name, result);
2504       this->named_results_->push_back(no);
2505     }
2506 }
2507
2508 // Return the closure variable, creating it if necessary.
2509
2510 Named_object*
2511 Function::closure_var()
2512 {
2513   if (this->closure_var_ == NULL)
2514     {
2515       // We don't know the type of the variable yet.  We add fields as
2516       // we find them.
2517       source_location loc = this->type_->location();
2518       Struct_field_list* sfl = new Struct_field_list;
2519       Type* struct_type = Type::make_struct_type(sfl, loc);
2520       Variable* var = new Variable(Type::make_pointer_type(struct_type),
2521                                    NULL, false, true, false, loc);
2522       this->closure_var_ = Named_object::make_variable("closure", NULL, var);
2523       // Note that the new variable is not in any binding contour.
2524     }
2525   return this->closure_var_;
2526 }
2527
2528 // Set the type of the closure variable.
2529
2530 void
2531 Function::set_closure_type()
2532 {
2533   if (this->closure_var_ == NULL)
2534     return;
2535   Named_object* closure = this->closure_var_;
2536   Struct_type* st = closure->var_value()->type()->deref()->struct_type();
2537   unsigned int index = 0;
2538   for (Closure_fields::const_iterator p = this->closure_fields_.begin();
2539        p != this->closure_fields_.end();
2540        ++p, ++index)
2541     {
2542       Named_object* no = p->first;
2543       char buf[20];
2544       snprintf(buf, sizeof buf, "%u", index);
2545       std::string n = no->name() + buf;
2546       Type* var_type;
2547       if (no->is_variable())
2548         var_type = no->var_value()->type();
2549       else
2550         var_type = no->result_var_value()->type();
2551       Type* field_type = Type::make_pointer_type(var_type);
2552       st->push_field(Struct_field(Typed_identifier(n, field_type, p->second)));
2553     }
2554 }
2555
2556 // Return whether this function is a method.
2557
2558 bool
2559 Function::is_method() const
2560 {
2561   return this->type_->is_method();
2562 }
2563
2564 // Add a label definition.
2565
2566 Label*
2567 Function::add_label_definition(const std::string& label_name,
2568                                source_location location)
2569 {
2570   Label* lnull = NULL;
2571   std::pair<Labels::iterator, bool> ins =
2572     this->labels_.insert(std::make_pair(label_name, lnull));
2573   if (ins.second)
2574     {
2575       // This is a new label.
2576       Label* label = new Label(label_name);
2577       label->define(location);
2578       ins.first->second = label;
2579       return label;
2580     }
2581   else
2582     {
2583       // The label was already in the hash table.
2584       Label* label = ins.first->second;
2585       if (!label->is_defined())
2586         {
2587           label->define(location);
2588           return label;
2589         }
2590       else
2591         {
2592           error_at(location, "redefinition of label %qs",
2593                    Gogo::message_name(label_name).c_str());
2594           inform(label->location(), "previous definition of %qs was here",
2595                  Gogo::message_name(label_name).c_str());
2596           return new Label(label_name);
2597         }
2598     }
2599 }
2600
2601 // Add a reference to a label.
2602
2603 Label*
2604 Function::add_label_reference(const std::string& label_name)
2605 {
2606   Label* lnull = NULL;
2607   std::pair<Labels::iterator, bool> ins =
2608     this->labels_.insert(std::make_pair(label_name, lnull));
2609   if (!ins.second)
2610     {
2611       // The label was already in the hash table.
2612       return ins.first->second;
2613     }
2614   else
2615     {
2616       gcc_assert(ins.first->second == NULL);
2617       Label* label = new Label(label_name);
2618       ins.first->second = label;
2619       return label;
2620     }
2621 }
2622
2623 // Swap one function with another.  This is used when building the
2624 // thunk we use to call a function which calls recover.  It may not
2625 // work for any other case.
2626
2627 void
2628 Function::swap_for_recover(Function *x)
2629 {
2630   gcc_assert(this->enclosing_ == x->enclosing_);
2631   std::swap(this->named_results_, x->named_results_);
2632   std::swap(this->closure_var_, x->closure_var_);
2633   std::swap(this->block_, x->block_);
2634   gcc_assert(this->location_ == x->location_);
2635   gcc_assert(this->fndecl_ == NULL && x->fndecl_ == NULL);
2636   gcc_assert(this->defer_stack_ == NULL && x->defer_stack_ == NULL);
2637 }
2638
2639 // Traverse the tree.
2640
2641 int
2642 Function::traverse(Traverse* traverse)
2643 {
2644   unsigned int traverse_mask = traverse->traverse_mask();
2645
2646   if ((traverse_mask
2647        & (Traverse::traverse_types | Traverse::traverse_expressions))
2648       != 0)
2649     {
2650       if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
2651         return TRAVERSE_EXIT;
2652     }
2653
2654   // FIXME: We should check traverse_functions here if nested
2655   // functions are stored in block bindings.
2656   if (this->block_ != NULL
2657       && (traverse_mask
2658           & (Traverse::traverse_variables
2659              | Traverse::traverse_constants
2660              | Traverse::traverse_blocks
2661              | Traverse::traverse_statements
2662              | Traverse::traverse_expressions
2663              | Traverse::traverse_types)) != 0)
2664     {
2665       if (this->block_->traverse(traverse) == TRAVERSE_EXIT)
2666         return TRAVERSE_EXIT;
2667     }
2668
2669   return TRAVERSE_CONTINUE;
2670 }
2671
2672 // Work out types for unspecified variables and constants.
2673
2674 void
2675 Function::determine_types()
2676 {
2677   if (this->block_ != NULL)
2678     this->block_->determine_types();
2679 }
2680
2681 // Export the function.
2682
2683 void
2684 Function::export_func(Export* exp, const std::string& name) const
2685 {
2686   Function::export_func_with_type(exp, name, this->type_);
2687 }
2688
2689 // Export a function with a type.
2690
2691 void
2692 Function::export_func_with_type(Export* exp, const std::string& name,
2693                                 const Function_type* fntype)
2694 {
2695   exp->write_c_string("func ");
2696
2697   if (fntype->is_method())
2698     {
2699       exp->write_c_string("(");
2700       exp->write_type(fntype->receiver()->type());
2701       exp->write_c_string(") ");
2702     }
2703
2704   exp->write_string(name);
2705
2706   exp->write_c_string(" (");
2707   const Typed_identifier_list* parameters = fntype->parameters();
2708   if (parameters != NULL)
2709     {
2710       bool is_varargs = fntype->is_varargs();
2711       bool first = true;
2712       for (Typed_identifier_list::const_iterator p = parameters->begin();
2713            p != parameters->end();
2714            ++p)
2715         {
2716           if (first)
2717             first = false;
2718           else
2719             exp->write_c_string(", ");
2720           if (!is_varargs || p + 1 != parameters->end())
2721             exp->write_type(p->type());
2722           else
2723             {
2724               exp->write_c_string("...");
2725               exp->write_type(p->type()->array_type()->element_type());
2726             }
2727         }
2728     }
2729   exp->write_c_string(")");
2730
2731   const Typed_identifier_list* results = fntype->results();
2732   if (results != NULL)
2733     {
2734       if (results->size() == 1)
2735         {
2736           exp->write_c_string(" ");
2737           exp->write_type(results->begin()->type());
2738         }
2739       else
2740         {
2741           exp->write_c_string(" (");
2742           bool first = true;
2743           for (Typed_identifier_list::const_iterator p = results->begin();
2744                p != results->end();
2745                ++p)
2746             {
2747               if (first)
2748                 first = false;
2749               else
2750                 exp->write_c_string(", ");
2751               exp->write_type(p->type());
2752             }
2753           exp->write_c_string(")");
2754         }
2755     }
2756   exp->write_c_string(";\n");
2757 }
2758
2759 // Import a function.
2760
2761 void
2762 Function::import_func(Import* imp, std::string* pname,
2763                       Typed_identifier** preceiver,
2764                       Typed_identifier_list** pparameters,
2765                       Typed_identifier_list** presults,
2766                       bool* is_varargs)
2767 {
2768   imp->require_c_string("func ");
2769
2770   *preceiver = NULL;
2771   if (imp->peek_char() == '(')
2772     {
2773       imp->require_c_string("(");
2774       Type* rtype = imp->read_type();
2775       *preceiver = new Typed_identifier(Import::import_marker, rtype,
2776                                         imp->location());
2777       imp->require_c_string(") ");
2778     }
2779
2780   *pname = imp->read_identifier();
2781
2782   Typed_identifier_list* parameters;
2783   *is_varargs = false;
2784   imp->require_c_string(" (");
2785   if (imp->peek_char() == ')')
2786     parameters = NULL;
2787   else
2788     {
2789       parameters = new Typed_identifier_list();
2790       while (true)
2791         {
2792           if (imp->match_c_string("..."))
2793             {
2794               imp->advance(3);
2795               *is_varargs = true;
2796             }
2797
2798           Type* ptype = imp->read_type();
2799           if (*is_varargs)
2800             ptype = Type::make_array_type(ptype, NULL);
2801           parameters->push_back(Typed_identifier(Import::import_marker,
2802                                                  ptype, imp->location()));
2803           if (imp->peek_char() != ',')
2804             break;
2805           gcc_assert(!*is_varargs);
2806           imp->require_c_string(", ");
2807         }
2808     }
2809   imp->require_c_string(")");
2810   *pparameters = parameters;
2811
2812   Typed_identifier_list* results;
2813   if (imp->peek_char() != ' ')
2814     results = NULL;
2815   else
2816     {
2817       results = new Typed_identifier_list();
2818       imp->require_c_string(" ");
2819       if (imp->peek_char() != '(')
2820         {
2821           Type* rtype = imp->read_type();
2822           results->push_back(Typed_identifier(Import::import_marker, rtype,
2823                                               imp->location()));
2824         }
2825       else
2826         {
2827           imp->require_c_string("(");
2828           while (true)
2829             {
2830               Type* rtype = imp->read_type();
2831               results->push_back(Typed_identifier(Import::import_marker,
2832                                                   rtype, imp->location()));
2833               if (imp->peek_char() != ',')
2834                 break;
2835               imp->require_c_string(", ");
2836             }
2837           imp->require_c_string(")");
2838         }
2839     }
2840   imp->require_c_string(";\n");
2841   *presults = results;
2842 }
2843
2844 // Class Block.
2845
2846 Block::Block(Block* enclosing, source_location location)
2847   : enclosing_(enclosing), statements_(),
2848     bindings_(new Bindings(enclosing == NULL
2849                            ? NULL
2850                            : enclosing->bindings())),
2851     start_location_(location),
2852     end_location_(UNKNOWN_LOCATION)
2853 {
2854 }
2855
2856 // Add a statement to a block.
2857
2858 void
2859 Block::add_statement(Statement* statement)
2860 {
2861   this->statements_.push_back(statement);
2862 }
2863
2864 // Add a statement to the front of a block.  This is slow but is only
2865 // used for reference counts of parameters.
2866
2867 void
2868 Block::add_statement_at_front(Statement* statement)
2869 {
2870   this->statements_.insert(this->statements_.begin(), statement);
2871 }
2872
2873 // Replace a statement in a block.
2874
2875 void
2876 Block::replace_statement(size_t index, Statement* s)
2877 {
2878   gcc_assert(index < this->statements_.size());
2879   this->statements_[index] = s;
2880 }
2881
2882 // Add a statement before another statement.
2883
2884 void
2885 Block::insert_statement_before(size_t index, Statement* s)
2886 {
2887   gcc_assert(index < this->statements_.size());
2888   this->statements_.insert(this->statements_.begin() + index, s);
2889 }
2890
2891 // Add a statement after another statement.
2892
2893 void
2894 Block::insert_statement_after(size_t index, Statement* s)
2895 {
2896   gcc_assert(index < this->statements_.size());
2897   this->statements_.insert(this->statements_.begin() + index + 1, s);
2898 }
2899
2900 // Traverse the tree.
2901
2902 int
2903 Block::traverse(Traverse* traverse)
2904 {
2905   unsigned int traverse_mask = traverse->traverse_mask();
2906
2907   if ((traverse_mask & Traverse::traverse_blocks) != 0)
2908     {
2909       int t = traverse->block(this);
2910       if (t == TRAVERSE_EXIT)
2911         return TRAVERSE_EXIT;
2912       else if (t == TRAVERSE_SKIP_COMPONENTS)
2913         return TRAVERSE_CONTINUE;
2914     }
2915
2916   if ((traverse_mask
2917        & (Traverse::traverse_variables
2918           | Traverse::traverse_constants
2919           | Traverse::traverse_expressions
2920           | Traverse::traverse_types)) != 0)
2921     {
2922       for (Bindings::const_definitions_iterator pb =
2923              this->bindings_->begin_definitions();
2924            pb != this->bindings_->end_definitions();
2925            ++pb)
2926         {
2927           switch ((*pb)->classification())
2928             {
2929             case Named_object::NAMED_OBJECT_CONST:
2930               if ((traverse_mask & Traverse::traverse_constants) != 0)
2931                 {
2932                   if (traverse->constant(*pb, false) == TRAVERSE_EXIT)
2933                     return TRAVERSE_EXIT;
2934                 }
2935               if ((traverse_mask & Traverse::traverse_types) != 0
2936                   || (traverse_mask & Traverse::traverse_expressions) != 0)
2937                 {
2938                   Type* t = (*pb)->const_value()->type();
2939                   if (t != NULL
2940                       && Type::traverse(t, traverse) == TRAVERSE_EXIT)
2941                     return TRAVERSE_EXIT;
2942                 }
2943               if ((traverse_mask & Traverse::traverse_expressions) != 0
2944                   || (traverse_mask & Traverse::traverse_types) != 0)
2945                 {
2946                   if ((*pb)->const_value()->traverse_expression(traverse)
2947                       == TRAVERSE_EXIT)
2948                     return TRAVERSE_EXIT;
2949                 }
2950               break;
2951
2952             case Named_object::NAMED_OBJECT_VAR:
2953             case Named_object::NAMED_OBJECT_RESULT_VAR:
2954               if ((traverse_mask & Traverse::traverse_variables) != 0)
2955                 {
2956                   if (traverse->variable(*pb) == TRAVERSE_EXIT)
2957                     return TRAVERSE_EXIT;
2958                 }
2959               if (((traverse_mask & Traverse::traverse_types) != 0
2960                    || (traverse_mask & Traverse::traverse_expressions) != 0)
2961                   && ((*pb)->is_result_variable()
2962                       || (*pb)->var_value()->has_type()))
2963                 {
2964                   Type* t = ((*pb)->is_variable()
2965                              ? (*pb)->var_value()->type()
2966                              : (*pb)->result_var_value()->type());
2967                   if (t != NULL
2968                       && Type::traverse(t, traverse) == TRAVERSE_EXIT)
2969                     return TRAVERSE_EXIT;
2970                 }
2971               if ((*pb)->is_variable()
2972                   && ((traverse_mask & Traverse::traverse_expressions) != 0
2973                       || (traverse_mask & Traverse::traverse_types) != 0))
2974                 {
2975                   if ((*pb)->var_value()->traverse_expression(traverse)
2976                       == TRAVERSE_EXIT)
2977                     return TRAVERSE_EXIT;
2978                 }
2979               break;
2980
2981             case Named_object::NAMED_OBJECT_FUNC:
2982             case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
2983               // FIXME: Where will nested functions be found?
2984               gcc_unreachable();
2985
2986             case Named_object::NAMED_OBJECT_TYPE:
2987               if ((traverse_mask & Traverse::traverse_types) != 0
2988                   || (traverse_mask & Traverse::traverse_expressions) != 0)
2989                 {
2990                   if (Type::traverse((*pb)->type_value(), traverse)
2991                       == TRAVERSE_EXIT)
2992                     return TRAVERSE_EXIT;
2993                 }
2994               break;
2995
2996             case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
2997             case Named_object::NAMED_OBJECT_UNKNOWN:
2998               break;
2999
3000             case Named_object::NAMED_OBJECT_PACKAGE:
3001             case Named_object::NAMED_OBJECT_SINK:
3002               gcc_unreachable();
3003
3004             default:
3005               gcc_unreachable();
3006             }
3007         }
3008     }
3009
3010   // No point in checking traverse_mask here--if we got here we always
3011   // want to walk the statements.  The traversal can insert new
3012   // statements before or after the current statement.  Inserting
3013   // statements before the current statement requires updating I via
3014   // the pointer; those statements will not be traversed.  Any new
3015   // statements inserted after the current statement will be traversed
3016   // in their turn.
3017   for (size_t i = 0; i < this->statements_.size(); ++i)
3018     {
3019       if (this->statements_[i]->traverse(this, &i, traverse) == TRAVERSE_EXIT)
3020         return TRAVERSE_EXIT;
3021     }
3022
3023   return TRAVERSE_CONTINUE;
3024 }
3025
3026 // Work out types for unspecified variables and constants.
3027
3028 void
3029 Block::determine_types()
3030 {
3031   for (Bindings::const_definitions_iterator pb =
3032          this->bindings_->begin_definitions();
3033        pb != this->bindings_->end_definitions();
3034        ++pb)
3035     {
3036       if ((*pb)->is_variable())
3037         (*pb)->var_value()->determine_type();
3038       else if ((*pb)->is_const())
3039         (*pb)->const_value()->determine_type();
3040     }
3041
3042   for (std::vector<Statement*>::const_iterator ps = this->statements_.begin();
3043        ps != this->statements_.end();
3044        ++ps)
3045     (*ps)->determine_types();
3046 }
3047
3048 // Return true if the statements in this block may fall through.
3049
3050 bool
3051 Block::may_fall_through() const
3052 {
3053   if (this->statements_.empty())
3054     return true;
3055   return this->statements_.back()->may_fall_through();
3056 }
3057
3058 // Class Variable.
3059
3060 Variable::Variable(Type* type, Expression* init, bool is_global,
3061                    bool is_parameter, bool is_receiver,
3062                    source_location location)
3063   : type_(type), init_(init), preinit_(NULL), location_(location),
3064     is_global_(is_global), is_parameter_(is_parameter),
3065     is_receiver_(is_receiver), is_varargs_parameter_(false),
3066     is_address_taken_(false), seen_(false), init_is_lowered_(false),
3067     type_from_init_tuple_(false), type_from_range_index_(false),
3068     type_from_range_value_(false), type_from_chan_element_(false),
3069     is_type_switch_var_(false)
3070 {
3071   gcc_assert(type != NULL || init != NULL);
3072   gcc_assert(!is_parameter || init == NULL);
3073 }
3074
3075 // Traverse the initializer expression.
3076
3077 int
3078 Variable::traverse_expression(Traverse* traverse)
3079 {
3080   if (this->preinit_ != NULL)
3081     {
3082       if (this->preinit_->traverse(traverse) == TRAVERSE_EXIT)
3083         return TRAVERSE_EXIT;
3084     }
3085   if (this->init_ != NULL)
3086     {
3087       if (Expression::traverse(&this->init_, traverse) == TRAVERSE_EXIT)
3088         return TRAVERSE_EXIT;
3089     }
3090   return TRAVERSE_CONTINUE;
3091 }
3092
3093 // Lower the initialization expression after parsing is complete.
3094
3095 void
3096 Variable::lower_init_expression(Gogo* gogo, Named_object* function)
3097 {
3098   if (this->init_ != NULL && !this->init_is_lowered_)
3099     {
3100       if (this->seen_)
3101         {
3102           // We will give an error elsewhere, this is just to prevent
3103           // an infinite loop.
3104           return;
3105         }
3106       this->seen_ = true;
3107
3108       gogo->lower_expression(function, &this->init_);
3109
3110       this->seen_ = false;
3111
3112       this->init_is_lowered_ = true;
3113     }
3114 }
3115
3116 // Get the preinit block.
3117
3118 Block*
3119 Variable::preinit_block()
3120 {
3121   gcc_assert(this->is_global_);
3122   if (this->preinit_ == NULL)
3123     this->preinit_ = new Block(NULL, this->location());
3124   return this->preinit_;
3125 }
3126
3127 // Add a statement to be run before the initialization expression.
3128
3129 void
3130 Variable::add_preinit_statement(Statement* s)
3131 {
3132   Block* b = this->preinit_block();
3133   b->add_statement(s);
3134   b->set_end_location(s->location());
3135 }
3136
3137 // In an assignment which sets a variable to a tuple of EXPR, return
3138 // the type of the first element of the tuple.
3139
3140 Type*
3141 Variable::type_from_tuple(Expression* expr, bool report_error) const
3142 {
3143   if (expr->map_index_expression() != NULL)
3144     return expr->map_index_expression()->get_map_type()->val_type();
3145   else if (expr->receive_expression() != NULL)
3146     {
3147       Expression* channel = expr->receive_expression()->channel();
3148       Type* channel_type = channel->type();
3149       if (channel_type->is_error_type())
3150         return Type::make_error_type();
3151       return channel_type->channel_type()->element_type();
3152     }
3153   else
3154     {
3155       if (report_error)
3156         error_at(this->location(), "invalid tuple definition");
3157       return Type::make_error_type();
3158     }
3159 }
3160
3161 // Given EXPR used in a range clause, return either the index type or
3162 // the value type of the range, depending upon GET_INDEX_TYPE.
3163
3164 Type*
3165 Variable::type_from_range(Expression* expr, bool get_index_type,
3166                           bool report_error) const
3167 {
3168   Type* t = expr->type();
3169   if (t->array_type() != NULL
3170       || (t->points_to() != NULL
3171           && t->points_to()->array_type() != NULL
3172           && !t->points_to()->is_open_array_type()))
3173     {
3174       if (get_index_type)
3175         return Type::lookup_integer_type("int");
3176       else
3177         return t->deref()->array_type()->element_type();
3178     }
3179   else if (t->is_string_type())
3180     return Type::lookup_integer_type("int");
3181   else if (t->map_type() != NULL)
3182     {
3183       if (get_index_type)
3184         return t->map_type()->key_type();
3185       else
3186         return t->map_type()->val_type();
3187     }
3188   else if (t->channel_type() != NULL)
3189     {
3190       if (get_index_type)
3191         return t->channel_type()->element_type();
3192       else
3193         {
3194           if (report_error)
3195             error_at(this->location(),
3196                      "invalid definition of value variable for channel range");
3197           return Type::make_error_type();
3198         }
3199     }
3200   else
3201     {
3202       if (report_error)
3203         error_at(this->location(), "invalid type for range clause");
3204       return Type::make_error_type();
3205     }
3206 }
3207
3208 // EXPR should be a channel.  Return the channel's element type.
3209
3210 Type*
3211 Variable::type_from_chan_element(Expression* expr, bool report_error) const
3212 {
3213   Type* t = expr->type();
3214   if (t->channel_type() != NULL)
3215     return t->channel_type()->element_type();
3216   else
3217     {
3218       if (report_error)
3219         error_at(this->location(), "expected channel");
3220       return Type::make_error_type();
3221     }
3222 }
3223
3224 // Return the type of the Variable.  This may be called before
3225 // Variable::determine_type is called, which means that we may need to
3226 // get the type from the initializer.  FIXME: If we combine lowering
3227 // with type determination, then this should be unnecessary.
3228
3229 Type*
3230 Variable::type()
3231 {
3232   // A variable in a type switch with a nil case will have the wrong
3233   // type here.  This gets fixed up in determine_type, below.
3234   Type* type = this->type_;
3235   Expression* init = this->init_;
3236   if (this->is_type_switch_var_
3237       && this->type_->is_nil_constant_as_type())
3238     {
3239       Type_guard_expression* tge = this->init_->type_guard_expression();
3240       gcc_assert(tge != NULL);
3241       init = tge->expr();
3242       type = NULL;
3243     }
3244
3245   if (this->seen_)
3246     {
3247       if (this->type_ == NULL || !this->type_->is_error_type())
3248         {
3249           error_at(this->location_, "variable initializer refers to itself");
3250           this->type_ = Type::make_error_type();
3251         }
3252       return this->type_;
3253     }
3254
3255   this->seen_ = true;
3256
3257   if (type != NULL)
3258     ;
3259   else if (this->type_from_init_tuple_)
3260     type = this->type_from_tuple(init, false);
3261   else if (this->type_from_range_index_ || this->type_from_range_value_)
3262     type = this->type_from_range(init, this->type_from_range_index_, false);
3263   else if (this->type_from_chan_element_)
3264     type = this->type_from_chan_element(init, false);
3265   else
3266     {
3267       gcc_assert(init != NULL);
3268       type = init->type();
3269       gcc_assert(type != NULL);
3270
3271       // Variables should not have abstract types.
3272       if (type->is_abstract())
3273         type = type->make_non_abstract_type();
3274
3275       if (type->is_void_type())
3276         type = Type::make_error_type();
3277     }
3278
3279   this->seen_ = false;
3280
3281   return type;
3282 }
3283
3284 // Fetch the type from a const pointer, in which case it should have
3285 // been set already.
3286
3287 Type*
3288 Variable::type() const
3289 {
3290   gcc_assert(this->type_ != NULL);
3291   return this->type_;
3292 }
3293
3294 // Set the type if necessary.
3295
3296 void
3297 Variable::determine_type()
3298 {
3299   // A variable in a type switch with a nil case will have the wrong
3300   // type here.  It will have an initializer which is a type guard.
3301   // We want to initialize it to the value without the type guard, and
3302   // use the type of that value as well.
3303   if (this->is_type_switch_var_ && this->type_->is_nil_constant_as_type())
3304     {
3305       Type_guard_expression* tge = this->init_->type_guard_expression();
3306       gcc_assert(tge != NULL);
3307       this->type_ = NULL;
3308       this->init_ = tge->expr();
3309     }
3310
3311   if (this->init_ == NULL)
3312     gcc_assert(this->type_ != NULL && !this->type_->is_abstract());
3313   else if (this->type_from_init_tuple_)
3314     {
3315       Expression *init = this->init_;
3316       init->determine_type_no_context();
3317       this->type_ = this->type_from_tuple(init, true);
3318       this->init_ = NULL;
3319     }
3320   else if (this->type_from_range_index_ || this->type_from_range_value_)
3321     {
3322       Expression* init = this->init_;
3323       init->determine_type_no_context();
3324       this->type_ = this->type_from_range(init, this->type_from_range_index_,
3325                                           true);
3326       this->init_ = NULL;
3327     }
3328   else
3329     {
3330       // type_from_chan_element_ should have been cleared during
3331       // lowering.
3332       gcc_assert(!this->type_from_chan_element_);
3333
3334       Type_context context(this->type_, false);
3335       this->init_->determine_type(&context);
3336       if (this->type_ == NULL)
3337         {
3338           Type* type = this->init_->type();
3339           gcc_assert(type != NULL);
3340           if (type->is_abstract())
3341             type = type->make_non_abstract_type();
3342
3343           if (type->is_void_type())
3344             {
3345               error_at(this->location_, "variable has no type");
3346               type = Type::make_error_type();
3347             }
3348           else if (type->is_nil_type())
3349             {
3350               error_at(this->location_, "variable defined to nil type");
3351               type = Type::make_error_type();
3352             }
3353           else if (type->is_call_multiple_result_type())
3354             {
3355               error_at(this->location_,
3356                        "single variable set to multiple value function call");
3357               type = Type::make_error_type();
3358             }
3359
3360           this->type_ = type;
3361         }
3362     }
3363 }
3364
3365 // Export the variable
3366
3367 void
3368 Variable::export_var(Export* exp, const std::string& name) const
3369 {
3370   gcc_assert(this->is_global_);
3371   exp->write_c_string("var ");
3372   exp->write_string(name);
3373   exp->write_c_string(" ");
3374   exp->write_type(this->type());
3375   exp->write_c_string(";\n");
3376 }
3377
3378 // Import a variable.
3379
3380 void
3381 Variable::import_var(Import* imp, std::string* pname, Type** ptype)
3382 {
3383   imp->require_c_string("var ");
3384   *pname = imp->read_identifier();
3385   imp->require_c_string(" ");
3386   *ptype = imp->read_type();
3387   imp->require_c_string(";\n");
3388 }
3389
3390 // Class Named_constant.
3391
3392 // Traverse the initializer expression.
3393
3394 int
3395 Named_constant::traverse_expression(Traverse* traverse)
3396 {
3397   return Expression::traverse(&this->expr_, traverse);
3398 }
3399
3400 // Determine the type of the constant.
3401
3402 void
3403 Named_constant::determine_type()
3404 {
3405   if (this->type_ != NULL)
3406     {
3407       Type_context context(this->type_, false);
3408       this->expr_->determine_type(&context);
3409     }
3410   else
3411     {
3412       // A constant may have an abstract type.
3413       Type_context context(NULL, true);
3414       this->expr_->determine_type(&context);
3415       this->type_ = this->expr_->type();
3416       gcc_assert(this->type_ != NULL);
3417     }
3418 }
3419
3420 // Indicate that we found and reported an error for this constant.
3421
3422 void
3423 Named_constant::set_error()
3424 {
3425   this->type_ = Type::make_error_type();
3426   this->expr_ = Expression::make_error(this->location_);
3427 }
3428
3429 // Export a constant.
3430
3431 void
3432 Named_constant::export_const(Export* exp, const std::string& name) const
3433 {
3434   exp->write_c_string("const ");
3435   exp->write_string(name);
3436   exp->write_c_string(" ");
3437   if (!this->type_->is_abstract())
3438     {
3439       exp->write_type(this->type_);
3440       exp->write_c_string(" ");
3441     }
3442   exp->write_c_string("= ");
3443   this->expr()->export_expression(exp);
3444   exp->write_c_string(";\n");
3445 }
3446
3447 // Import a constant.
3448
3449 void
3450 Named_constant::import_const(Import* imp, std::string* pname, Type** ptype,
3451                              Expression** pexpr)
3452 {
3453   imp->require_c_string("const ");
3454   *pname = imp->read_identifier();
3455   imp->require_c_string(" ");
3456   if (imp->peek_char() == '=')
3457     *ptype = NULL;
3458   else
3459     {
3460       *ptype = imp->read_type();
3461       imp->require_c_string(" ");
3462     }
3463   imp->require_c_string("= ");
3464   *pexpr = Expression::import_expression(imp);
3465   imp->require_c_string(";\n");
3466 }
3467
3468 // Add a method.
3469
3470 Named_object*
3471 Type_declaration::add_method(const std::string& name, Function* function)
3472 {
3473   Named_object* ret = Named_object::make_function(name, NULL, function);
3474   this->methods_.push_back(ret);
3475   return ret;
3476 }
3477
3478 // Add a method declaration.
3479
3480 Named_object*
3481 Type_declaration::add_method_declaration(const std::string&  name,
3482                                          Function_type* type,
3483                                          source_location location)
3484 {
3485   Named_object* ret = Named_object::make_function_declaration(name, NULL, type,
3486                                                               location);
3487   this->methods_.push_back(ret);
3488   return ret;
3489 }
3490
3491 // Return whether any methods ere defined.
3492
3493 bool
3494 Type_declaration::has_methods() const
3495 {
3496   return !this->methods_.empty();
3497 }
3498
3499 // Define methods for the real type.
3500
3501 void
3502 Type_declaration::define_methods(Named_type* nt)
3503 {
3504   for (Methods::const_iterator p = this->methods_.begin();
3505        p != this->methods_.end();
3506        ++p)
3507     nt->add_existing_method(*p);
3508 }
3509
3510 // We are using the type.  Return true if we should issue a warning.
3511
3512 bool
3513 Type_declaration::using_type()
3514 {
3515   bool ret = !this->issued_warning_;
3516   this->issued_warning_ = true;
3517   return ret;
3518 }
3519
3520 // Class Unknown_name.
3521
3522 // Set the real named object.
3523
3524 void
3525 Unknown_name::set_real_named_object(Named_object* no)
3526 {
3527   gcc_assert(this->real_named_object_ == NULL);
3528   gcc_assert(!no->is_unknown());
3529   this->real_named_object_ = no;
3530 }
3531
3532 // Class Named_object.
3533
3534 Named_object::Named_object(const std::string& name,
3535                            const Package* package,
3536                            Classification classification)
3537   : name_(name), package_(package), classification_(classification),
3538     tree_(NULL)
3539 {
3540   if (Gogo::is_sink_name(name))
3541     gcc_assert(classification == NAMED_OBJECT_SINK);
3542 }
3543
3544 // Make an unknown name.  This is used by the parser.  The name must
3545 // be resolved later.  Unknown names are only added in the current
3546 // package.
3547
3548 Named_object*
3549 Named_object::make_unknown_name(const std::string& name,
3550                                 source_location location)
3551 {
3552   Named_object* named_object = new Named_object(name, NULL,
3553                                                 NAMED_OBJECT_UNKNOWN);
3554   Unknown_name* value = new Unknown_name(location);
3555   named_object->u_.unknown_value = value;
3556   return named_object;
3557 }
3558
3559 // Make a constant.
3560
3561 Named_object*
3562 Named_object::make_constant(const Typed_identifier& tid,
3563                             const Package* package, Expression* expr,
3564                             int iota_value)
3565 {
3566   Named_object* named_object = new Named_object(tid.name(), package,
3567                                                 NAMED_OBJECT_CONST);
3568   Named_constant* named_constant = new Named_constant(tid.type(), expr,
3569                                                       iota_value,
3570                                                       tid.location());
3571   named_object->u_.const_value = named_constant;
3572   return named_object;
3573 }
3574
3575 // Make a named type.
3576
3577 Named_object*
3578 Named_object::make_type(const std::string& name, const Package* package,
3579                         Type* type, source_location location)
3580 {
3581   Named_object* named_object = new Named_object(name, package,
3582                                                 NAMED_OBJECT_TYPE);
3583   Named_type* named_type = Type::make_named_type(named_object, type, location);
3584   named_object->u_.type_value = named_type;
3585   return named_object;
3586 }
3587
3588 // Make a type declaration.
3589
3590 Named_object*
3591 Named_object::make_type_declaration(const std::string& name,
3592                                     const Package* package,
3593                                     source_location location)
3594 {
3595   Named_object* named_object = new Named_object(name, package,
3596                                                 NAMED_OBJECT_TYPE_DECLARATION);
3597   Type_declaration* type_declaration = new Type_declaration(location);
3598   named_object->u_.type_declaration = type_declaration;
3599   return named_object;
3600 }
3601
3602 // Make a variable.
3603
3604 Named_object*
3605 Named_object::make_variable(const std::string& name, const Package* package,
3606                             Variable* variable)
3607 {
3608   Named_object* named_object = new Named_object(name, package,
3609                                                 NAMED_OBJECT_VAR);
3610   named_object->u_.var_value = variable;
3611   return named_object;
3612 }
3613
3614 // Make a result variable.
3615
3616 Named_object*
3617 Named_object::make_result_variable(const std::string& name,
3618                                    Result_variable* result)
3619 {
3620   Named_object* named_object = new Named_object(name, NULL,
3621                                                 NAMED_OBJECT_RESULT_VAR);
3622   named_object->u_.result_var_value = result;
3623   return named_object;
3624 }
3625
3626 // Make a sink.  This is used for the special blank identifier _.
3627
3628 Named_object*
3629 Named_object::make_sink()
3630 {
3631   return new Named_object("_", NULL, NAMED_OBJECT_SINK);
3632 }
3633
3634 // Make a named function.
3635
3636 Named_object*
3637 Named_object::make_function(const std::string& name, const Package* package,
3638                             Function* function)
3639 {
3640   Named_object* named_object = new Named_object(name, package,
3641                                                 NAMED_OBJECT_FUNC);
3642   named_object->u_.func_value = function;
3643   return named_object;
3644 }
3645
3646 // Make a function declaration.
3647
3648 Named_object*
3649 Named_object::make_function_declaration(const std::string& name,
3650                                         const Package* package,
3651                                         Function_type* fntype,
3652                                         source_location location)
3653 {
3654   Named_object* named_object = new Named_object(name, package,
3655                                                 NAMED_OBJECT_FUNC_DECLARATION);
3656   Function_declaration *func_decl = new Function_declaration(fntype, location);
3657   named_object->u_.func_declaration_value = func_decl;
3658   return named_object;
3659 }
3660
3661 // Make a package.
3662
3663 Named_object*
3664 Named_object::make_package(const std::string& alias, Package* package)
3665 {
3666   Named_object* named_object = new Named_object(alias, NULL,
3667                                                 NAMED_OBJECT_PACKAGE);
3668   named_object->u_.package_value = package;
3669   return named_object;
3670 }
3671
3672 // Return the name to use in an error message.
3673
3674 std::string
3675 Named_object::message_name() const
3676 {
3677   if (this->package_ == NULL)
3678     return Gogo::message_name(this->name_);
3679   std::string ret = Gogo::message_name(this->package_->name());
3680   ret += '.';
3681   ret += Gogo::message_name(this->name_);
3682   return ret;
3683 }
3684
3685 // Set the type when a declaration is defined.
3686
3687 void
3688 Named_object::set_type_value(Named_type* named_type)
3689 {
3690   gcc_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
3691   Type_declaration* td = this->u_.type_declaration;
3692   td->define_methods(named_type);
3693   Named_object* in_function = td->in_function();
3694   if (in_function != NULL)
3695     named_type->set_in_function(in_function);
3696   delete td;
3697   this->classification_ = NAMED_OBJECT_TYPE;
3698   this->u_.type_value = named_type;
3699 }
3700
3701 // Define a function which was previously declared.
3702
3703 void
3704 Named_object::set_function_value(Function* function)
3705 {
3706   gcc_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
3707   this->classification_ = NAMED_OBJECT_FUNC;
3708   // FIXME: We should free the old value.
3709   this->u_.func_value = function;
3710 }
3711
3712 // Declare an unknown object as a type declaration.
3713
3714 void
3715 Named_object::declare_as_type()
3716 {
3717   gcc_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
3718   Unknown_name* unk = this->u_.unknown_value;
3719   this->classification_ = NAMED_OBJECT_TYPE_DECLARATION;
3720   this->u_.type_declaration = new Type_declaration(unk->location());
3721   delete unk;
3722 }
3723
3724 // Return the location of a named object.
3725
3726 source_location
3727 Named_object::location() const
3728 {
3729   switch (this->classification_)
3730     {
3731     default:
3732     case NAMED_OBJECT_UNINITIALIZED:
3733       gcc_unreachable();
3734
3735     case NAMED_OBJECT_UNKNOWN:
3736       return this->unknown_value()->location();
3737
3738     case NAMED_OBJECT_CONST:
3739       return this->const_value()->location();
3740
3741     case NAMED_OBJECT_TYPE:
3742       return this->type_value()->location();
3743
3744     case NAMED_OBJECT_TYPE_DECLARATION:
3745       return this->type_declaration_value()->location();
3746
3747     case NAMED_OBJECT_VAR:
3748       return this->var_value()->location();
3749
3750     case NAMED_OBJECT_RESULT_VAR:
3751       return this->result_var_value()->function()->location();
3752
3753     case NAMED_OBJECT_SINK:
3754       gcc_unreachable();
3755
3756     case NAMED_OBJECT_FUNC:
3757       return this->func_value()->location();
3758
3759     case NAMED_OBJECT_FUNC_DECLARATION:
3760       return this->func_declaration_value()->location();
3761
3762     case NAMED_OBJECT_PACKAGE:
3763       return this->package_value()->location();
3764     }
3765 }
3766
3767 // Export a named object.
3768
3769 void
3770 Named_object::export_named_object(Export* exp) const
3771 {
3772   switch (this->classification_)
3773     {
3774     default:
3775     case NAMED_OBJECT_UNINITIALIZED:
3776     case NAMED_OBJECT_UNKNOWN:
3777       gcc_unreachable();
3778
3779     case NAMED_OBJECT_CONST:
3780       this->const_value()->export_const(exp, this->name_);
3781       break;
3782
3783     case NAMED_OBJECT_TYPE:
3784       this->type_value()->export_named_type(exp, this->name_);
3785       break;
3786
3787     case NAMED_OBJECT_TYPE_DECLARATION:
3788       error_at(this->type_declaration_value()->location(),
3789                "attempt to export %<%s%> which was declared but not defined",
3790                this->message_name().c_str());
3791       break;
3792
3793     case NAMED_OBJECT_FUNC_DECLARATION:
3794       this->func_declaration_value()->export_func(exp, this->name_);
3795       break;
3796
3797     case NAMED_OBJECT_VAR:
3798       this->var_value()->export_var(exp, this->name_);
3799       break;
3800
3801     case NAMED_OBJECT_RESULT_VAR:
3802     case NAMED_OBJECT_SINK:
3803       gcc_unreachable();
3804
3805     case NAMED_OBJECT_FUNC:
3806       this->func_value()->export_func(exp, this->name_);
3807       break;
3808     }
3809 }
3810
3811 // Class Bindings.
3812
3813 Bindings::Bindings(Bindings* enclosing)
3814   : enclosing_(enclosing), named_objects_(), bindings_()
3815 {
3816 }
3817
3818 // Clear imports.
3819
3820 void
3821 Bindings::clear_file_scope()
3822 {
3823   Contour::iterator p = this->bindings_.begin();
3824   while (p != this->bindings_.end())
3825     {
3826       bool keep;
3827       if (p->second->package() != NULL)
3828         keep = false;
3829       else if (p->second->is_package())
3830         keep = false;
3831       else if (p->second->is_function()
3832                && !p->second->func_value()->type()->is_method()
3833                && Gogo::unpack_hidden_name(p->second->name()) == "init")
3834         keep = false;
3835       else
3836         keep = true;
3837
3838       if (keep)
3839         ++p;
3840       else
3841         p = this->bindings_.erase(p);
3842     }
3843 }
3844
3845 // Look up a symbol.
3846
3847 Named_object*
3848 Bindings::lookup(const std::string& name) const
3849 {
3850   Contour::const_iterator p = this->bindings_.find(name);
3851   if (p != this->bindings_.end())
3852     return p->second->resolve();
3853   else if (this->enclosing_ != NULL)
3854     return this->enclosing_->lookup(name);
3855   else
3856     return NULL;
3857 }
3858
3859 // Look up a symbol locally.
3860
3861 Named_object*
3862 Bindings::lookup_local(const std::string& name) const
3863 {
3864   Contour::const_iterator p = this->bindings_.find(name);
3865   if (p == this->bindings_.end())
3866     return NULL;
3867   return p->second;
3868 }
3869
3870 // Remove an object from a set of bindings.  This is used for a
3871 // special case in thunks for functions which call recover.
3872
3873 void
3874 Bindings::remove_binding(Named_object* no)
3875 {
3876   Contour::iterator pb = this->bindings_.find(no->name());
3877   gcc_assert(pb != this->bindings_.end());
3878   this->bindings_.erase(pb);
3879   for (std::vector<Named_object*>::iterator pn = this->named_objects_.begin();
3880        pn != this->named_objects_.end();
3881        ++pn)
3882     {
3883       if (*pn == no)
3884         {
3885           this->named_objects_.erase(pn);
3886           return;
3887         }
3888     }
3889   gcc_unreachable();
3890 }
3891
3892 // Add a method to the list of objects.  This is not added to the
3893 // lookup table.  This is so that we have a single list of objects
3894 // declared at the top level, which we walk through when it's time to
3895 // convert to trees.
3896
3897 void
3898 Bindings::add_method(Named_object* method)
3899 {
3900   this->named_objects_.push_back(method);
3901 }
3902
3903 // Add a generic Named_object to a Contour.
3904
3905 Named_object*
3906 Bindings::add_named_object_to_contour(Contour* contour,
3907                                       Named_object* named_object)
3908 {
3909   gcc_assert(named_object == named_object->resolve());
3910   const std::string& name(named_object->name());
3911   gcc_assert(!Gogo::is_sink_name(name));
3912
3913   std::pair<Contour::iterator, bool> ins =
3914     contour->insert(std::make_pair(name, named_object));
3915   if (!ins.second)
3916     {
3917       // The name was already there.
3918       if (named_object->package() != NULL
3919           && ins.first->second->package() == named_object->package()
3920           && (ins.first->second->classification()
3921               == named_object->classification()))
3922         {
3923           // This is a second import of the same object.
3924           return ins.first->second;
3925         }
3926       ins.first->second = this->new_definition(ins.first->second,
3927                                                named_object);
3928       return ins.first->second;
3929     }
3930   else
3931     {
3932       // Don't push declarations on the list.  We push them on when
3933       // and if we find the definitions.  That way we genericize the
3934       // functions in order.
3935       if (!named_object->is_type_declaration()
3936           && !named_object->is_function_declaration()
3937           && !named_object->is_unknown())
3938         this->named_objects_.push_back(named_object);
3939       return named_object;
3940     }
3941 }
3942
3943 // We had an existing named object OLD_OBJECT, and we've seen a new
3944 // one NEW_OBJECT with the same name.  FIXME: This does not free the
3945 // new object when we don't need it.
3946
3947 Named_object*
3948 Bindings::new_definition(Named_object* old_object, Named_object* new_object)
3949 {
3950   std::string reason;
3951   switch (old_object->classification())
3952     {
3953     default:
3954     case Named_object::NAMED_OBJECT_UNINITIALIZED:
3955       gcc_unreachable();
3956
3957     case Named_object::NAMED_OBJECT_UNKNOWN:
3958       {
3959         Named_object* real = old_object->unknown_value()->real_named_object();
3960         if (real != NULL)
3961           return this->new_definition(real, new_object);
3962         gcc_assert(!new_object->is_unknown());
3963         old_object->unknown_value()->set_real_named_object(new_object);
3964         if (!new_object->is_type_declaration()
3965             && !new_object->is_function_declaration())
3966           this->named_objects_.push_back(new_object);
3967         return new_object;
3968       }
3969
3970     case Named_object::NAMED_OBJECT_CONST:
3971       break;
3972
3973     case Named_object::NAMED_OBJECT_TYPE:
3974       if (new_object->is_type_declaration())
3975         return old_object;
3976       break;
3977
3978     case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
3979       if (new_object->is_type_declaration())
3980         return old_object;
3981       if (new_object->is_type())
3982         {
3983           old_object->set_type_value(new_object->type_value());
3984           new_object->type_value()->set_named_object(old_object);
3985           this->named_objects_.push_back(old_object);
3986           return old_object;
3987         }
3988       break;
3989
3990     case Named_object::NAMED_OBJECT_VAR:
3991     case Named_object::NAMED_OBJECT_RESULT_VAR:
3992       break;
3993
3994     case Named_object::NAMED_OBJECT_SINK:
3995       gcc_unreachable();
3996
3997     case Named_object::NAMED_OBJECT_FUNC:
3998       if (new_object->is_function_declaration())
3999         {
4000           if (!new_object->func_declaration_value()->asm_name().empty())
4001             sorry("__asm__ for function definitions");
4002           Function_type* old_type = old_object->func_value()->type();
4003           Function_type* new_type =
4004             new_object->func_declaration_value()->type();
4005           if (old_type->is_valid_redeclaration(new_type, &reason))
4006             return old_object;
4007         }
4008       break;
4009
4010     case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
4011       {
4012         Function_type* old_type = old_object->func_declaration_value()->type();
4013         if (new_object->is_function_declaration())
4014           {
4015             Function_type* new_type =
4016               new_object->func_declaration_value()->type();
4017             if (old_type->is_valid_redeclaration(new_type, &reason))
4018               return old_object;
4019           }
4020         if (new_object->is_function())
4021           {
4022             Function_type* new_type = new_object->func_value()->type();
4023             if (old_type->is_valid_redeclaration(new_type, &reason))
4024               {
4025                 if (!old_object->func_declaration_value()->asm_name().empty())
4026                   sorry("__asm__ for function definitions");
4027                 old_object->set_function_value(new_object->func_value());
4028                 this->named_objects_.push_back(old_object);
4029                 return old_object;
4030               }
4031           }
4032       }
4033       break;
4034
4035     case Named_object::NAMED_OBJECT_PACKAGE:
4036       if (new_object->is_package()
4037           && (old_object->package_value()->name()
4038               == new_object->package_value()->name()))
4039         return old_object;
4040
4041       break;
4042     }
4043
4044   std::string n = old_object->message_name();
4045   if (reason.empty())
4046     error_at(new_object->location(), "redefinition of %qs", n.c_str());
4047   else
4048     error_at(new_object->location(), "redefinition of %qs: %s", n.c_str(),
4049              reason.c_str());
4050
4051   inform(old_object->location(), "previous definition of %qs was here",
4052          n.c_str());
4053
4054   return old_object;
4055 }
4056
4057 // Add a named type.
4058
4059 Named_object*
4060 Bindings::add_named_type(Named_type* named_type)
4061 {
4062   return this->add_named_object(named_type->named_object());
4063 }
4064
4065 // Add a function.
4066
4067 Named_object*
4068 Bindings::add_function(const std::string& name, const Package* package,
4069                        Function* function)
4070 {
4071   return this->add_named_object(Named_object::make_function(name, package,
4072                                                             function));
4073 }
4074
4075 // Add a function declaration.
4076
4077 Named_object*
4078 Bindings::add_function_declaration(const std::string& name,
4079                                    const Package* package,
4080                                    Function_type* type,
4081                                    source_location location)
4082 {
4083   Named_object* no = Named_object::make_function_declaration(name, package,
4084                                                              type, location);
4085   return this->add_named_object(no);
4086 }
4087
4088 // Define a type which was previously declared.
4089
4090 void
4091 Bindings::define_type(Named_object* no, Named_type* type)
4092 {
4093   no->set_type_value(type);
4094   this->named_objects_.push_back(no);
4095 }
4096
4097 // Traverse bindings.
4098
4099 int
4100 Bindings::traverse(Traverse* traverse, bool is_global)
4101 {
4102   unsigned int traverse_mask = traverse->traverse_mask();
4103
4104   // We don't use an iterator because we permit the traversal to add
4105   // new global objects.
4106   for (size_t i = 0; i < this->named_objects_.size(); ++i)
4107     {
4108       Named_object* p = this->named_objects_[i];
4109       switch (p->classification())
4110         {
4111         case Named_object::NAMED_OBJECT_CONST:
4112           if ((traverse_mask & Traverse::traverse_constants) != 0)
4113             {
4114               if (traverse->constant(p, is_global) == TRAVERSE_EXIT)
4115                 return TRAVERSE_EXIT;
4116             }
4117           if ((traverse_mask & Traverse::traverse_types) != 0
4118               || (traverse_mask & Traverse::traverse_expressions) != 0)
4119             {
4120               Type* t = p->const_value()->type();
4121               if (t != NULL
4122                   && Type::traverse(t, traverse) == TRAVERSE_EXIT)
4123                 return TRAVERSE_EXIT;
4124             }
4125           if ((traverse_mask & Traverse::traverse_expressions) != 0)
4126             {
4127               if (p->const_value()->traverse_expression(traverse)
4128                   == TRAVERSE_EXIT)
4129                 return TRAVERSE_EXIT;
4130             }
4131           break;
4132
4133         case Named_object::NAMED_OBJECT_VAR:
4134         case Named_object::NAMED_OBJECT_RESULT_VAR:
4135           if ((traverse_mask & Traverse::traverse_variables) != 0)
4136             {
4137               if (traverse->variable(p) == TRAVERSE_EXIT)
4138                 return TRAVERSE_EXIT;
4139             }
4140           if (((traverse_mask & Traverse::traverse_types) != 0
4141                || (traverse_mask & Traverse::traverse_expressions) != 0)
4142               && (p->is_result_variable()
4143                   || p->var_value()->has_type()))
4144             {
4145               Type* t = (p->is_variable()
4146                          ? p->var_value()->type()
4147                          : p->result_var_value()->type());
4148               if (t != NULL
4149                   && Type::traverse(t, traverse) == TRAVERSE_EXIT)
4150                 return TRAVERSE_EXIT;
4151             }
4152           if (p->is_variable()
4153               && (traverse_mask & Traverse::traverse_expressions) != 0)
4154             {
4155               if (p->var_value()->traverse_expression(traverse)
4156                   == TRAVERSE_EXIT)
4157                 return TRAVERSE_EXIT;
4158             }
4159           break;
4160
4161         case Named_object::NAMED_OBJECT_FUNC:
4162           if ((traverse_mask & Traverse::traverse_functions) != 0)
4163             {
4164               int t = traverse->function(p);
4165               if (t == TRAVERSE_EXIT)
4166                 return TRAVERSE_EXIT;
4167               else if (t == TRAVERSE_SKIP_COMPONENTS)
4168                 break;
4169             }
4170
4171           if ((traverse_mask
4172                & (Traverse::traverse_variables
4173                   | Traverse::traverse_constants
4174                   | Traverse::traverse_functions
4175                   | Traverse::traverse_blocks
4176                   | Traverse::traverse_statements
4177                   | Traverse::traverse_expressions
4178                   | Traverse::traverse_types)) != 0)
4179             {
4180               if (p->func_value()->traverse(traverse) == TRAVERSE_EXIT)
4181                 return TRAVERSE_EXIT;
4182             }
4183           break;
4184
4185         case Named_object::NAMED_OBJECT_PACKAGE:
4186           // These are traversed in Gogo::traverse.
4187           gcc_assert(is_global);
4188           break;
4189
4190         case Named_object::NAMED_OBJECT_TYPE:
4191           if ((traverse_mask & Traverse::traverse_types) != 0
4192               || (traverse_mask & Traverse::traverse_expressions) != 0)
4193             {
4194               if (Type::traverse(p->type_value(), traverse) == TRAVERSE_EXIT)
4195                 return TRAVERSE_EXIT;
4196             }
4197           break;
4198
4199         case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
4200         case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
4201         case Named_object::NAMED_OBJECT_UNKNOWN:
4202           break;
4203
4204         case Named_object::NAMED_OBJECT_SINK:
4205         default:
4206           gcc_unreachable();
4207         }
4208     }
4209
4210   return TRAVERSE_CONTINUE;
4211 }
4212
4213 // Class Package.
4214
4215 Package::Package(const std::string& name, const std::string& unique_prefix,
4216                  source_location location)
4217   : name_(name), unique_prefix_(unique_prefix), bindings_(new Bindings(NULL)),
4218     priority_(0), location_(location), used_(false), is_imported_(false),
4219     uses_sink_alias_(false)
4220 {
4221   gcc_assert(!name.empty() && !unique_prefix.empty());
4222 }
4223
4224 // Set the priority.  We may see multiple priorities for an imported
4225 // package; we want to use the largest one.
4226
4227 void
4228 Package::set_priority(int priority)
4229 {
4230   if (priority > this->priority_)
4231     this->priority_ = priority;
4232 }
4233
4234 // Determine types of constants.  Everything else in a package
4235 // (variables, function declarations) should already have a fixed
4236 // type.  Constants may have abstract types.
4237
4238 void
4239 Package::determine_types()
4240 {
4241   Bindings* bindings = this->bindings_;
4242   for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
4243        p != bindings->end_definitions();
4244        ++p)
4245     {
4246       if ((*p)->is_const())
4247         (*p)->const_value()->determine_type();
4248     }
4249 }
4250
4251 // Class Traverse.
4252
4253 // Destructor.
4254
4255 Traverse::~Traverse()
4256 {
4257   if (this->types_seen_ != NULL)
4258     delete this->types_seen_;
4259   if (this->expressions_seen_ != NULL)
4260     delete this->expressions_seen_;
4261 }
4262
4263 // Record that we are looking at a type, and return true if we have
4264 // already seen it.
4265
4266 bool
4267 Traverse::remember_type(const Type* type)
4268 {
4269   if (type->is_error_type())
4270     return true;
4271   gcc_assert((this->traverse_mask() & traverse_types) != 0
4272              || (this->traverse_mask() & traverse_expressions) != 0);
4273   // We only have to remember named types, as they are the only ones
4274   // we can see multiple times in a traversal.
4275   if (type->classification() != Type::TYPE_NAMED)
4276     return false;
4277   if (this->types_seen_ == NULL)
4278     this->types_seen_ = new Types_seen();
4279   std::pair<Types_seen::iterator, bool> ins = this->types_seen_->insert(type);
4280   return !ins.second;
4281 }
4282
4283 // Record that we are looking at an expression, and return true if we
4284 // have already seen it.
4285
4286 bool
4287 Traverse::remember_expression(const Expression* expression)
4288 {
4289   gcc_assert((this->traverse_mask() & traverse_types) != 0
4290              || (this->traverse_mask() & traverse_expressions) != 0);
4291   if (this->expressions_seen_ == NULL)
4292     this->expressions_seen_ = new Expressions_seen();
4293   std::pair<Expressions_seen::iterator, bool> ins =
4294     this->expressions_seen_->insert(expression);
4295   return !ins.second;
4296 }
4297
4298 // The default versions of these functions should never be called: the
4299 // traversal mask indicates which functions may be called.
4300
4301 int
4302 Traverse::variable(Named_object*)
4303 {
4304   gcc_unreachable();
4305 }
4306
4307 int
4308 Traverse::constant(Named_object*, bool)
4309 {
4310   gcc_unreachable();
4311 }
4312
4313 int
4314 Traverse::function(Named_object*)
4315 {
4316   gcc_unreachable();
4317 }
4318
4319 int
4320 Traverse::block(Block*)
4321 {
4322   gcc_unreachable();
4323 }
4324
4325 int
4326 Traverse::statement(Block*, size_t*, Statement*)
4327 {
4328   gcc_unreachable();
4329 }
4330
4331 int
4332 Traverse::expression(Expression**)
4333 {
4334   gcc_unreachable();
4335 }
4336
4337 int
4338 Traverse::type(Type*)
4339 {
4340   gcc_unreachable();
4341 }