OSDN Git Service

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