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