OSDN Git Service

compiler: Add -fgo-relative-import-path.
[pf3gnuchains/gcc-fork.git] / gcc / go / gofrontend / gogo.h
1 // gogo.h -- Go frontend parsed representation.     -*- C++ -*-
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 #ifndef GO_GOGO_H
8 #define GO_GOGO_H
9
10 #include "go-linemap.h"
11
12 class Traverse;
13 class Statement_inserter;
14 class Type;
15 class Type_hash_identical;
16 class Type_equal;
17 class Type_identical;
18 class Typed_identifier;
19 class Typed_identifier_list;
20 class Function_type;
21 class Expression;
22 class Statement;
23 class Temporary_statement;
24 class Block;
25 class Function;
26 class Bindings;
27 class Bindings_snapshot;
28 class Package;
29 class Variable;
30 class Pointer_type;
31 class Struct_type;
32 class Struct_field;
33 class Struct_field_list;
34 class Array_type;
35 class Map_type;
36 class Channel_type;
37 class Interface_type;
38 class Named_type;
39 class Forward_declaration_type;
40 class Method;
41 class Methods;
42 class Named_object;
43 class Label;
44 class Translate_context;
45 class Backend;
46 class Export;
47 class Import;
48 class Bexpression;
49 class Bstatement;
50 class Bblock;
51 class Bvariable;
52 class Blabel;
53
54 // This file declares the basic classes used to hold the internal
55 // representation of Go which is built by the parser.
56
57 // An initialization function for an imported package.  This is a
58 // magic function which initializes variables and runs the "init"
59 // function.
60
61 class Import_init
62 {
63  public:
64   Import_init(const std::string& package_name, const std::string& init_name,
65               int priority)
66     : package_name_(package_name), init_name_(init_name), priority_(priority)
67   { }
68
69   // The name of the package being imported.
70   const std::string&
71   package_name() const
72   { return this->package_name_; }
73
74   // The name of the package's init function.
75   const std::string&
76   init_name() const
77   { return this->init_name_; }
78
79   // The priority of the initialization function.  Functions with a
80   // lower priority number must be run first.
81   int
82   priority() const
83   { return this->priority_; }
84
85  private:
86   // The name of the package being imported.
87   std::string package_name_;
88   // The name of the package's init function.
89   std::string init_name_;
90   // The priority.
91   int priority_;
92 };
93
94 // For sorting purposes.
95
96 inline bool
97 operator<(const Import_init& i1, const Import_init& i2)
98 {
99   if (i1.priority() < i2.priority())
100     return true;
101   if (i1.priority() > i2.priority())
102     return false;
103   if (i1.package_name() != i2.package_name())
104     return i1.package_name() < i2.package_name();
105   return i1.init_name() < i2.init_name();
106 }
107
108 // The holder for the internal representation of the entire
109 // compilation unit.
110
111 class Gogo
112 {
113  public:
114   // Create the IR, passing in the sizes of the types "int" and
115   // "uintptr" in bits.
116   Gogo(Backend* backend, Linemap *linemap, int int_type_size, int pointer_size);
117
118   // Get the backend generator.
119   Backend*
120   backend()
121   { return this->backend_; }
122
123   // Get the Location generator.
124   Linemap*
125   linemap()
126   { return this->linemap_; }
127
128   // Get the package name.
129   const std::string&
130   package_name() const;
131
132   // Set the package name.
133   void
134   set_package_name(const std::string&, Location);
135
136   // Return whether this is the "main" package.
137   bool
138   is_main_package() const;
139
140   // If necessary, adjust the name to use for a hidden symbol.  We add
141   // the package name, so that hidden symbols in different packages do
142   // not collide.
143   std::string
144   pack_hidden_name(const std::string& name, bool is_exported) const
145   {
146     return (is_exported
147             ? name
148             : '.' + this->pkgpath() + '.' + name);
149   }
150
151   // Unpack a name which may have been hidden.  Returns the
152   // user-visible name of the object.
153   static std::string
154   unpack_hidden_name(const std::string& name)
155   { return name[0] != '.' ? name : name.substr(name.rfind('.') + 1); }
156
157   // Return whether a possibly packed name is hidden.
158   static bool
159   is_hidden_name(const std::string& name)
160   { return name[0] == '.'; }
161
162   // Return the package path of a hidden name.
163   static std::string
164   hidden_name_pkgpath(const std::string& name)
165   {
166     go_assert(Gogo::is_hidden_name(name));
167     return name.substr(1, name.rfind('.') - 1);
168   }
169
170   // Given a name which may or may not have been hidden, return the
171   // name to use in an error message.
172   static std::string
173   message_name(const std::string& name);
174
175   // Return whether a name is the blank identifier _.
176   static bool
177   is_sink_name(const std::string& name)
178   {
179     return (name[0] == '.'
180             && name[name.length() - 1] == '_'
181             && name[name.length() - 2] == '.');
182   }
183
184   // Convert a pkgpath into a string suitable for a symbol
185   static std::string
186   pkgpath_for_symbol(const std::string& pkgpath);
187
188   // Return the package path to use for reflect.Type.PkgPath.
189   const std::string&
190   pkgpath() const;
191
192   // Return the package path to use for a symbol name.
193   const std::string&
194   pkgpath_symbol() const;
195
196   // Set the package path from a command line option.
197   void
198   set_pkgpath(const std::string&);
199
200   // Set the prefix from a command line option.
201   void
202   set_prefix(const std::string&);
203
204   // Return whether pkgpath was set from a command line option.
205   bool
206   pkgpath_from_option() const
207   { return this->pkgpath_from_option_; }
208
209   // Return the relative import path as set from the command line.
210   // Returns an empty string if it was not set.
211   const std::string&
212   relative_import_path() const
213   { return this->relative_import_path_; }
214
215   // Set the relative import path from a command line option.
216   void
217   set_relative_import_path(const std::string& s)
218   {this->relative_import_path_ = s; }
219
220   // Return the priority to use for the package we are compiling.
221   // This is two more than the largest priority of any package we
222   // import.
223   int
224   package_priority() const;
225
226   // Import a package.  FILENAME is the file name argument, LOCAL_NAME
227   // is the local name to give to the package.  If LOCAL_NAME is empty
228   // the declarations are added to the global scope.
229   void
230   import_package(const std::string& filename, const std::string& local_name,
231                  bool is_local_name_exported, Location);
232
233   // Whether we are the global binding level.
234   bool
235   in_global_scope() const;
236
237   // Look up a name in the current binding contours.
238   Named_object*
239   lookup(const std::string&, Named_object** pfunction) const;
240
241   // Look up a name in the current block.
242   Named_object*
243   lookup_in_block(const std::string&) const;
244
245   // Look up a name in the global namespace--the universal scope.
246   Named_object*
247   lookup_global(const char*) const;
248
249   // Add a new imported package.  REAL_NAME is the real name of the
250   // package.  ALIAS is the alias of the package; this may be the same
251   // as REAL_NAME.  This sets *PADD_TO_GLOBALS if symbols added to
252   // this package should be added to the global namespace; this is
253   // true if the alias is ".".  LOCATION is the location of the import
254   // statement.  This returns the new package, or NULL on error.
255   Package*
256   add_imported_package(const std::string& real_name, const std::string& alias,
257                        bool is_alias_exported,
258                        const std::string& pkgpath,
259                        Location location,
260                        bool* padd_to_globals);
261
262   // Register a package.  This package may or may not be imported.
263   // This returns the Package structure for the package, creating if
264   // it necessary.
265   Package*
266   register_package(const std::string& pkgpath, Location);
267
268   // Start compiling a function.  ADD_METHOD_TO_TYPE is true if a
269   // method function should be added to the type of its receiver.
270   Named_object*
271   start_function(const std::string& name, Function_type* type,
272                  bool add_method_to_type, Location);
273
274   // Finish compiling a function.
275   void
276   finish_function(Location);
277
278   // Return the current function.
279   Named_object*
280   current_function() const;
281
282   // Return the current block.
283   Block*
284   current_block();
285
286   // Start a new block.  This is not initially associated with a
287   // function.
288   void
289   start_block(Location);
290
291   // Finish the current block and return it.
292   Block*
293   finish_block(Location);
294
295   // Declare an erroneous name.  This is used to avoid knock-on errors
296   // after a parsing error.
297   Named_object*
298   add_erroneous_name(const std::string& name);
299
300   // Declare an unknown name.  This is used while parsing.  The name
301   // must be resolved by the end of the parse.  Unknown names are
302   // always added at the package level.
303   Named_object*
304   add_unknown_name(const std::string& name, Location);
305
306   // Declare a function.
307   Named_object*
308   declare_function(const std::string&, Function_type*, Location);
309
310   // Declare a function at the package level.  This is used for
311   // functions generated for a type.
312   Named_object*
313   declare_package_function(const std::string&, Function_type*, Location);
314
315   // Add a label.
316   Label*
317   add_label_definition(const std::string&, Location);
318
319   // Add a label reference.  ISSUE_GOTO_ERRORS is true if we should
320   // report errors for a goto from the current location to the label
321   // location.
322   Label*
323   add_label_reference(const std::string&, Location,
324                       bool issue_goto_errors);
325
326   // Return a snapshot of the current binding state.
327   Bindings_snapshot*
328   bindings_snapshot(Location);
329
330   // Add a statement to the current block.
331   void
332   add_statement(Statement*);
333
334   // Add a block to the current block.
335   void
336   add_block(Block*, Location);
337
338   // Add a constant.
339   Named_object*
340   add_constant(const Typed_identifier&, Expression*, int iota_value);
341
342   // Add a type.
343   void
344   add_type(const std::string&, Type*, Location);
345
346   // Add a named type.  This is used for builtin types, and to add an
347   // imported type to the global scope.
348   void
349   add_named_type(Named_type*);
350
351   // Declare a type.
352   Named_object*
353   declare_type(const std::string&, Location);
354
355   // Declare a type at the package level.  This is used when the
356   // parser sees an unknown name where a type name is required.
357   Named_object*
358   declare_package_type(const std::string&, Location);
359
360   // Define a type which was already declared.
361   void
362   define_type(Named_object*, Named_type*);
363
364   // Add a variable.
365   Named_object*
366   add_variable(const std::string&, Variable*);
367
368   // Add a sink--a reference to the blank identifier _.
369   Named_object*
370   add_sink();
371
372   // Add a type which needs to be verified.  This is used for sink
373   // types, just to give appropriate error messages.
374   void
375   add_type_to_verify(Type* type);
376
377   // Add a named object to the current namespace.  This is used for
378   // import . "package".
379   void
380   add_named_object(Named_object*);
381
382   // Mark all local variables in current bindings as used.  This is
383   // used when there is a parse error to avoid useless errors.
384   void
385   mark_locals_used();
386
387   // Return a name to use for a thunk function.  A thunk function is
388   // one we create during the compilation, for a go statement or a
389   // defer statement or a method expression.
390   static std::string
391   thunk_name();
392
393   // Return whether an object is a thunk.
394   static bool
395   is_thunk(const Named_object*);
396
397   // Note that we've seen an interface type.  This is used to build
398   // all required interface method tables.
399   void
400   record_interface_type(Interface_type*);
401
402   // Note that we need an initialization function.
403   void
404   set_need_init_fn()
405   { this->need_init_fn_ = true; }
406
407   // Clear out all names in file scope.  This is called when we start
408   // parsing a new file.
409   void
410   clear_file_scope();
411
412   // Record that VAR1 must be initialized after VAR2.  This is used
413   // when VAR2 does not appear in VAR1's INIT or PREINIT.
414   void
415   record_var_depends_on(Variable* var1, Named_object* var2)
416   {
417     go_assert(this->var_deps_.find(var1) == this->var_deps_.end());
418     this->var_deps_[var1] = var2;
419   }
420
421   // Return the variable that VAR depends on, or NULL if none.
422   Named_object*
423   var_depends_on(Variable* var) const
424   {
425     Var_deps::const_iterator p = this->var_deps_.find(var);
426     return p != this->var_deps_.end() ? p->second : NULL;
427   }
428
429   // Queue up a type-specific function to be written out.  This is
430   // used when a type-specific function is needed when not at the top
431   // level.
432   void
433   queue_specific_type_function(Type* type, Named_type* name,
434                                const std::string& hash_name,
435                                Function_type* hash_fntype,
436                                const std::string& equal_name,
437                                Function_type* equal_fntype);
438
439   // Write out queued specific type functions.
440   void
441   write_specific_type_functions();
442
443   // Whether we are done writing out specific type functions.
444   bool
445   specific_type_functions_are_written() const
446   { return this->specific_type_functions_are_written_; }
447
448   // Traverse the tree.  See the Traverse class.
449   void
450   traverse(Traverse*);
451
452   // Define the predeclared global names.
453   void
454   define_global_names();
455
456   // Verify and complete all types.
457   void
458   verify_types();
459
460   // Lower the parse tree.
461   void
462   lower_parse_tree();
463
464   // Lower all the statements in a block.
465   void
466   lower_block(Named_object* function, Block*);
467
468   // Lower an expression.
469   void
470   lower_expression(Named_object* function, Statement_inserter*, Expression**);
471
472   // Lower a constant.
473   void
474   lower_constant(Named_object*);
475
476   // Finalize the method lists and build stub methods for named types.
477   void
478   finalize_methods();
479
480   // Work out the types to use for unspecified variables and
481   // constants.
482   void
483   determine_types();
484
485   // Type check the program.
486   void
487   check_types();
488
489   // Check the types in a single block.  This is used for complicated
490   // go statements.
491   void
492   check_types_in_block(Block*);
493
494   // Check for return statements.
495   void
496   check_return_statements();
497
498   // Do all exports.
499   void
500   do_exports();
501
502   // Add an import control function for an imported package to the
503   // list.
504   void
505   add_import_init_fn(const std::string& package_name,
506                      const std::string& init_name, int prio);
507
508   // Turn short-cut operators (&&, ||) into explicit if statements.
509   void
510   remove_shortcuts();
511
512   // Use temporary variables to force order of evaluation.
513   void
514   order_evaluations();
515
516   // Build thunks for functions which call recover.
517   void
518   build_recover_thunks();
519
520   // Simplify statements which might use thunks: go and defer
521   // statements.
522   void
523   simplify_thunk_statements();
524
525   // Dump AST if -fgo-dump-ast is set 
526   void
527   dump_ast(const char* basename);
528
529   // Convert named types to the backend representation.
530   void
531   convert_named_types();
532
533   // Convert named types in a list of bindings.
534   void
535   convert_named_types_in_bindings(Bindings*);
536
537   // True if named types have been converted to the backend
538   // representation.
539   bool
540   named_types_are_converted() const
541   { return this->named_types_are_converted_; }
542
543   // Write out the global values.
544   void
545   write_globals();
546
547   // Create trees for implicit builtin functions.
548   void
549   define_builtin_function_trees();
550
551   // Build a call to a builtin function.  PDECL should point to a NULL
552   // initialized static pointer which will hold the fndecl.  NAME is
553   // the name of the function.  NARGS is the number of arguments.
554   // RETTYPE is the return type.  It is followed by NARGS pairs of
555   // type and argument (both trees).
556   static tree
557   call_builtin(tree* pdecl, Location, const char* name, int nargs,
558                tree rettype, ...);
559
560   // Build a call to the runtime error function.
561   static tree
562   runtime_error(int code, Location);
563
564   // Build a builtin struct with a list of fields.
565   static tree
566   builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
567                  int nfields, ...);
568
569   // Mark a function declaration as a builtin library function.
570   static void
571   mark_fndecl_as_builtin_library(tree fndecl);
572
573   // Build a constructor for a slice.  SLICE_TYPE_TREE is the type of
574   // the slice.  VALUES points to the values.  COUNT is the size,
575   // CAPACITY is the capacity.  If CAPACITY is NULL, it is set to
576   // COUNT.
577   static tree
578   slice_constructor(tree slice_type_tree, tree values, tree count,
579                     tree capacity);
580
581   // Build required interface method tables.
582   void
583   build_interface_method_tables();
584
585   // Build an interface method table for a type: a list of function
586   // pointers, one for each interface method.  This returns a decl.
587   tree
588   interface_method_table_for_type(const Interface_type*, Type*,
589                                   bool is_pointer);
590
591   // Return a tree which allocate SIZE bytes to hold values of type
592   // TYPE.
593   tree
594   allocate_memory(Type *type, tree size, Location);
595
596   // Return a type to use for pointer to const char.
597   static tree
598   const_char_pointer_type_tree();
599
600   // Build a string constant with the right type.
601   static tree
602   string_constant_tree(const std::string&);
603
604   // Build a Go string constant.  This returns a pointer to the
605   // constant.
606   tree
607   go_string_constant_tree(const std::string&);
608
609   // Receive a value from a channel.
610   static tree
611   receive_from_channel(tree type_tree, tree type_descriptor_tree, tree channel,
612                        Location);
613
614   // Make a trampoline which calls FNADDR passing CLOSURE.
615   tree
616   make_trampoline(tree fnaddr, tree closure, Location);
617
618  private:
619   // During parsing, we keep a stack of functions.  Each function on
620   // the stack is one that we are currently parsing.  For each
621   // function, we keep track of the current stack of blocks.
622   struct Open_function
623   {
624     // The function.
625     Named_object* function;
626     // The stack of active blocks in the function.
627     std::vector<Block*> blocks;
628   };
629
630   // The stack of functions.
631   typedef std::vector<Open_function> Open_functions;
632
633   // Set up the built-in unsafe package.
634   void
635   import_unsafe(const std::string&, bool is_exported, Location);
636
637   // Return the current binding contour.
638   Bindings*
639   current_bindings();
640
641   const Bindings*
642   current_bindings() const;
643
644   // Get the name of the magic initialization function.
645   const std::string&
646   get_init_fn_name();
647
648   // Get the decl for the magic initialization function.
649   tree
650   initialization_function_decl();
651
652   // Write the magic initialization function.
653   void
654   write_initialization_function(tree fndecl, tree init_stmt_list);
655
656   // Initialize imported packages.
657   void
658   init_imports(tree*);
659
660   // Register variables with the garbage collector.
661   void
662   register_gc_vars(const std::vector<Named_object*>&, tree*);
663
664   // Build a pointer to a Go string constant.  This returns a pointer
665   // to the pointer.
666   tree
667   ptr_go_string_constant_tree(const std::string&);
668
669   // Return the type of a trampoline.
670   static tree
671   trampoline_type_tree();
672
673   // Type used to map import names to packages.
674   typedef std::map<std::string, Package*> Imports;
675
676   // Type used to map package names to packages.
677   typedef std::map<std::string, Package*> Packages;
678
679   // Type used to map variables to the function calls that set them.
680   // This is used for initialization dependency analysis.
681   typedef std::map<Variable*, Named_object*> Var_deps;
682
683   // Type used to queue writing a type specific function.
684   struct Specific_type_function
685   {
686     Type* type;
687     Named_type* name;
688     std::string hash_name;
689     Function_type* hash_fntype;
690     std::string equal_name;
691     Function_type* equal_fntype;
692
693     Specific_type_function(Type* atype, Named_type* aname,
694                            const std::string& ahash_name,
695                            Function_type* ahash_fntype,
696                            const std::string& aequal_name,
697                            Function_type* aequal_fntype)
698       : type(atype), name(aname), hash_name(ahash_name),
699         hash_fntype(ahash_fntype), equal_name(aequal_name),
700         equal_fntype(aequal_fntype)
701     { }
702   };
703
704   // The backend generator.
705   Backend* backend_;
706   // The object used to keep track of file names and line numbers.
707   Linemap* linemap_;
708   // The package we are compiling.
709   Package* package_;
710   // The list of currently open functions during parsing.
711   Open_functions functions_;
712   // The global binding contour.  This includes the builtin functions
713   // and the package we are compiling.
714   Bindings* globals_;
715   // Mapping from import file names to packages.
716   Imports imports_;
717   // Whether the magic unsafe package was imported.
718   bool imported_unsafe_;
719   // Mapping from package names we have seen to packages.  This does
720   // not include the package we are compiling.
721   Packages packages_;
722   // The functions named "init", if there are any.
723   std::vector<Named_object*> init_functions_;
724   // A mapping from variables to the function calls that initialize
725   // them, if it is not stored in the variable's init or preinit.
726   // This is used for dependency analysis.
727   Var_deps var_deps_;
728   // Whether we need a magic initialization function.
729   bool need_init_fn_;
730   // The name of the magic initialization function.
731   std::string init_fn_name_;
732   // A list of import control variables for packages that we import.
733   std::set<Import_init> imported_init_fns_;
734   // The package path used for reflection data.
735   std::string pkgpath_;
736   // The package path to use for a symbol name.
737   std::string pkgpath_symbol_;
738   // The prefix to use for symbols, from the -fgo-prefix option.
739   std::string prefix_;
740   // Whether pkgpath_ has been set.
741   bool pkgpath_set_;
742   // Whether an explicit package path was set by -fgo-pkgpath.
743   bool pkgpath_from_option_;
744   // Whether an explicit prefix was set by -fgo-prefix.
745   bool prefix_from_option_;
746   // The relative import path, from the -fgo-relative-import-path
747   // option.
748   std::string relative_import_path_;
749   // A list of types to verify.
750   std::vector<Type*> verify_types_;
751   // A list of interface types defined while parsing.
752   std::vector<Interface_type*> interface_types_;
753   // Type specific functions to write out.
754   std::vector<Specific_type_function*> specific_type_functions_;
755   // Whether we are done writing out specific type functions.
756   bool specific_type_functions_are_written_;
757   // Whether named types have been converted.
758   bool named_types_are_converted_;
759 };
760
761 // A block of statements.
762
763 class Block
764 {
765  public:
766   Block(Block* enclosing, Location);
767
768   // Return the enclosing block.
769   const Block*
770   enclosing() const
771   { return this->enclosing_; }
772
773   // Return the bindings of the block.
774   Bindings*
775   bindings()
776   { return this->bindings_; }
777
778   const Bindings*
779   bindings() const
780   { return this->bindings_; }
781
782   // Look at the block's statements.
783   const std::vector<Statement*>*
784   statements() const
785   { return &this->statements_; }
786
787   // Return the start location.  This is normally the location of the
788   // left curly brace which starts the block.
789   Location
790   start_location() const
791   { return this->start_location_; }
792
793   // Return the end location.  This is normally the location of the
794   // right curly brace which ends the block.
795   Location
796   end_location() const
797   { return this->end_location_; }
798
799   // Add a statement to the block.
800   void
801   add_statement(Statement*);
802
803   // Add a statement to the front of the block.
804   void
805   add_statement_at_front(Statement*);
806
807   // Replace a statement in a block.
808   void
809   replace_statement(size_t index, Statement*);
810
811   // Add a Statement before statement number INDEX.
812   void
813   insert_statement_before(size_t index, Statement*);
814
815   // Add a Statement after statement number INDEX.
816   void
817   insert_statement_after(size_t index, Statement*);
818
819   // Set the end location of the block.
820   void
821   set_end_location(Location location)
822   { this->end_location_ = location; }
823
824   // Traverse the tree.
825   int
826   traverse(Traverse*);
827
828   // Set final types for unspecified variables and constants.
829   void
830   determine_types();
831
832   // Return true if execution of this block may fall through to the
833   // next block.
834   bool
835   may_fall_through() const;
836
837   // Convert the block to the backend representation.
838   Bblock*
839   get_backend(Translate_context*);
840
841   // Iterate over statements.
842
843   typedef std::vector<Statement*>::iterator iterator;
844
845   iterator
846   begin()
847   { return this->statements_.begin(); }
848
849   iterator
850   end()
851   { return this->statements_.end(); }
852
853  private:
854   // Enclosing block.
855   Block* enclosing_;
856   // Statements in the block.
857   std::vector<Statement*> statements_;
858   // Binding contour.
859   Bindings* bindings_;
860   // Location of start of block.
861   Location start_location_;
862   // Location of end of block.
863   Location end_location_;
864 };
865
866 // A function.
867
868 class Function
869 {
870  public:
871   Function(Function_type* type, Function*, Block*, Location);
872
873   // Return the function's type.
874   Function_type*
875   type() const
876   { return this->type_; }
877
878   // Return the enclosing function if there is one.
879   Function*
880   enclosing()
881   { return this->enclosing_; }
882
883   // Set the enclosing function.  This is used when building thunks
884   // for functions which call recover.
885   void
886   set_enclosing(Function* enclosing)
887   {
888     go_assert(this->enclosing_ == NULL);
889     this->enclosing_ = enclosing;
890   }
891
892   // The result variables.
893   typedef std::vector<Named_object*> Results;
894
895   // Create the result variables in the outer block.
896   void
897   create_result_variables(Gogo*);
898
899   // Update the named result variables when cloning a function which
900   // calls recover.
901   void
902   update_result_variables();
903
904   // Return the result variables.
905   Results*
906   result_variables()
907   { return this->results_; }
908
909   // Whether the result variables have names.
910   bool
911   results_are_named() const
912   { return this->results_are_named_; }
913
914   // Add a new field to the closure variable.
915   void
916   add_closure_field(Named_object* var, Location loc)
917   { this->closure_fields_.push_back(std::make_pair(var, loc)); }
918
919   // Whether this function needs a closure.
920   bool
921   needs_closure() const
922   { return !this->closure_fields_.empty(); }
923
924   // Return the closure variable, creating it if necessary.  This is
925   // passed to the function as a static chain parameter.
926   Named_object*
927   closure_var();
928
929   // Set the closure variable.  This is used when building thunks for
930   // functions which call recover.
931   void
932   set_closure_var(Named_object* v)
933   {
934     go_assert(this->closure_var_ == NULL);
935     this->closure_var_ = v;
936   }
937
938   // Return the variable for a reference to field INDEX in the closure
939   // variable.
940   Named_object*
941   enclosing_var(unsigned int index)
942   {
943     go_assert(index < this->closure_fields_.size());
944     return closure_fields_[index].first;
945   }
946
947   // Set the type of the closure variable if there is one.
948   void
949   set_closure_type();
950
951   // Get the block of statements associated with the function.
952   Block*
953   block() const
954   { return this->block_; }
955
956   // Get the location of the start of the function.
957   Location
958   location() const
959   { return this->location_; }
960
961   // Return whether this function is actually a method.
962   bool
963   is_method() const;
964
965   // Add a label definition to the function.
966   Label*
967   add_label_definition(Gogo*, const std::string& label_name, Location);
968
969   // Add a label reference to a function.  ISSUE_GOTO_ERRORS is true
970   // if we should report errors for a goto from the current location
971   // to the label location.
972   Label*
973   add_label_reference(Gogo*, const std::string& label_name,
974                       Location, bool issue_goto_errors);
975
976   // Warn about labels that are defined but not used.
977   void
978   check_labels() const;
979
980   // Note that a new local type has been added.  Return its index.
981   unsigned int
982   new_local_type_index()
983   { return this->local_type_count_++; }
984
985   // Whether this function calls the predeclared recover function.
986   bool
987   calls_recover() const
988   { return this->calls_recover_; }
989
990   // Record that this function calls the predeclared recover function.
991   // This is set during the lowering pass.
992   void
993   set_calls_recover()
994   { this->calls_recover_ = true; }
995
996   // Whether this is a recover thunk function.
997   bool
998   is_recover_thunk() const
999   { return this->is_recover_thunk_; }
1000
1001   // Record that this is a thunk built for a function which calls
1002   // recover.
1003   void
1004   set_is_recover_thunk()
1005   { this->is_recover_thunk_ = true; }
1006
1007   // Whether this function already has a recover thunk.
1008   bool
1009   has_recover_thunk() const
1010   { return this->has_recover_thunk_; }
1011
1012   // Record that this function already has a recover thunk.
1013   void
1014   set_has_recover_thunk()
1015   { this->has_recover_thunk_ = true; }
1016
1017   // Swap with another function.  Used only for the thunk which calls
1018   // recover.
1019   void
1020   swap_for_recover(Function *);
1021
1022   // Traverse the tree.
1023   int
1024   traverse(Traverse*);
1025
1026   // Determine types in the function.
1027   void
1028   determine_types();
1029
1030   // Return the function's decl given an identifier.
1031   tree
1032   get_or_make_decl(Gogo*, Named_object*, tree id);
1033
1034   // Return the function's decl after it has been built.
1035   tree
1036   get_decl() const
1037   {
1038     go_assert(this->fndecl_ != NULL);
1039     return this->fndecl_;
1040   }
1041
1042   // Set the function decl to hold a tree of the function code.
1043   void
1044   build_tree(Gogo*, Named_object*);
1045
1046   // Get the value to return when not explicitly specified.  May also
1047   // add statements to execute first to STMT_LIST.
1048   tree
1049   return_value(Gogo*, Named_object*, Location, tree* stmt_list) const;
1050
1051   // Get a tree for the variable holding the defer stack.
1052   Expression*
1053   defer_stack(Location);
1054
1055   // Export the function.
1056   void
1057   export_func(Export*, const std::string& name) const;
1058
1059   // Export a function with a type.
1060   static void
1061   export_func_with_type(Export*, const std::string& name,
1062                         const Function_type*);
1063
1064   // Import a function.
1065   static void
1066   import_func(Import*, std::string* pname, Typed_identifier** receiver,
1067               Typed_identifier_list** pparameters,
1068               Typed_identifier_list** presults, bool* is_varargs);
1069
1070  private:
1071   // Type for mapping from label names to Label objects.
1072   typedef Unordered_map(std::string, Label*) Labels;
1073
1074   tree
1075   make_receiver_parm_decl(Gogo*, Named_object*, tree);
1076
1077   tree
1078   copy_parm_to_heap(Gogo*, Named_object*, tree);
1079
1080   void
1081   build_defer_wrapper(Gogo*, Named_object*, tree*, tree*);
1082
1083   typedef std::vector<std::pair<Named_object*,
1084                                 Location> > Closure_fields;
1085
1086   // The function's type.
1087   Function_type* type_;
1088   // The enclosing function.  This is NULL when there isn't one, which
1089   // is the normal case.
1090   Function* enclosing_;
1091   // The result variables, if any.
1092   Results* results_;
1093   // If there is a closure, this is the list of variables which appear
1094   // in the closure.  This is created by the parser, and then resolved
1095   // to a real type when we lower parse trees.
1096   Closure_fields closure_fields_;
1097   // The closure variable, passed as a parameter using the static
1098   // chain parameter.  Normally NULL.
1099   Named_object* closure_var_;
1100   // The outer block of statements in the function.
1101   Block* block_;
1102   // The source location of the start of the function.
1103   Location location_;
1104   // Labels defined or referenced in the function.
1105   Labels labels_;
1106   // The number of local types defined in this function.
1107   unsigned int local_type_count_;
1108   // The function decl.
1109   tree fndecl_;
1110   // The defer stack variable.  A pointer to this variable is used to
1111   // distinguish the defer stack for one function from another.  This
1112   // is NULL unless we actually need a defer stack.
1113   Temporary_statement* defer_stack_;
1114   // True if the result variables are named.
1115   bool results_are_named_;
1116   // True if this function calls the predeclared recover function.
1117   bool calls_recover_;
1118   // True if this a thunk built for a function which calls recover.
1119   bool is_recover_thunk_;
1120   // True if this function already has a recover thunk.
1121   bool has_recover_thunk_;
1122 };
1123
1124 // A snapshot of the current binding state.
1125
1126 class Bindings_snapshot
1127 {
1128  public:
1129   Bindings_snapshot(const Block*, Location);
1130
1131   // Report any errors appropriate for a goto from the current binding
1132   // state of B to this one.
1133   void
1134   check_goto_from(const Block* b, Location);
1135
1136   // Report any errors appropriate for a goto from this binding state
1137   // to the current state of B.
1138   void
1139   check_goto_to(const Block* b);
1140
1141  private:
1142   bool
1143   check_goto_block(Location, const Block*, const Block*, size_t*);
1144
1145   void
1146   check_goto_defs(Location, const Block*, size_t, size_t);
1147
1148   // The current block.
1149   const Block* block_;
1150   // The number of names currently defined in each open block.
1151   // Element 0 is this->block_, element 1 is
1152   // this->block_->enclosing(), etc.
1153   std::vector<size_t> counts_;
1154   // The location where this snapshot was taken.
1155   Location location_;
1156 };
1157
1158 // A function declaration.
1159
1160 class Function_declaration
1161 {
1162  public:
1163   Function_declaration(Function_type* fntype, Location location)
1164     : fntype_(fntype), location_(location), asm_name_(), fndecl_(NULL)
1165   { }
1166
1167   Function_type*
1168   type() const
1169   { return this->fntype_; }
1170
1171   Location
1172   location() const
1173   { return this->location_; }
1174
1175   const std::string&
1176   asm_name() const
1177   { return this->asm_name_; }
1178
1179   // Set the assembler name.
1180   void
1181   set_asm_name(const std::string& asm_name)
1182   { this->asm_name_ = asm_name; }
1183
1184   // Return a decl for the function given an identifier.
1185   tree
1186   get_or_make_decl(Gogo*, Named_object*, tree id);
1187
1188   // Export a function declaration.
1189   void
1190   export_func(Export* exp, const std::string& name) const
1191   { Function::export_func_with_type(exp, name, this->fntype_); }
1192
1193  private:
1194   // The type of the function.
1195   Function_type* fntype_;
1196   // The location of the declaration.
1197   Location location_;
1198   // The assembler name: this is the name to use in references to the
1199   // function.  This is normally empty.
1200   std::string asm_name_;
1201   // The function decl if needed.
1202   tree fndecl_;
1203 };
1204
1205 // A variable.
1206
1207 class Variable
1208 {
1209  public:
1210   Variable(Type*, Expression*, bool is_global, bool is_parameter,
1211            bool is_receiver, Location);
1212
1213   // Get the type of the variable.
1214   Type*
1215   type();
1216
1217   Type*
1218   type() const;
1219
1220   // Return whether the type is defined yet.
1221   bool
1222   has_type() const;
1223
1224   // Get the initial value.
1225   Expression*
1226   init() const
1227   { return this->init_; }
1228
1229   // Return whether there are any preinit statements.
1230   bool
1231   has_pre_init() const
1232   { return this->preinit_ != NULL; }
1233
1234   // Return the preinit statements if any.
1235   Block*
1236   preinit() const
1237   { return this->preinit_; }
1238
1239   // Return whether this is a global variable.
1240   bool
1241   is_global() const
1242   { return this->is_global_; }
1243
1244   // Return whether this is a function parameter.
1245   bool
1246   is_parameter() const
1247   { return this->is_parameter_; }
1248
1249   // Return whether this is the receiver parameter of a method.
1250   bool
1251   is_receiver() const
1252   { return this->is_receiver_; }
1253
1254   // Change this parameter to be a receiver.  This is used when
1255   // creating the thunks created for functions which call recover.
1256   void
1257   set_is_receiver()
1258   {
1259     go_assert(this->is_parameter_);
1260     this->is_receiver_ = true;
1261   }
1262
1263   // Change this parameter to not be a receiver.  This is used when
1264   // creating the thunks created for functions which call recover.
1265   void
1266   set_is_not_receiver()
1267   {
1268     go_assert(this->is_parameter_);
1269     this->is_receiver_ = false;
1270   }
1271
1272   // Return whether this is the varargs parameter of a function.
1273   bool
1274   is_varargs_parameter() const
1275   { return this->is_varargs_parameter_; }
1276
1277   // Whether this variable's address is taken.
1278   bool
1279   is_address_taken() const
1280   { return this->is_address_taken_; }
1281
1282   // Whether this variable should live in the heap.
1283   bool
1284   is_in_heap() const
1285   { return this->is_address_taken_ && !this->is_global_; }
1286
1287   // Note that something takes the address of this variable.
1288   void
1289   set_address_taken()
1290   { this->is_address_taken_ = true; }
1291
1292   // Return whether the address is taken but does not escape.
1293   bool
1294   is_non_escaping_address_taken() const
1295   { return this->is_non_escaping_address_taken_; }
1296
1297   // Note that something takes the address of this variable such that
1298   // the address does not escape the function.
1299   void
1300   set_non_escaping_address_taken()
1301   { this->is_non_escaping_address_taken_ = true; }
1302
1303   // Get the source location of the variable's declaration.
1304   Location
1305   location() const
1306   { return this->location_; }
1307
1308   // Record that this is the varargs parameter of a function.
1309   void
1310   set_is_varargs_parameter()
1311   {
1312     go_assert(this->is_parameter_);
1313     this->is_varargs_parameter_ = true;
1314   }
1315
1316   // Return whether the variable has been used.
1317   bool
1318   is_used() const
1319   { return this->is_used_; }
1320
1321   // Mark that the variable has been used.
1322   void
1323   set_is_used()
1324   { this->is_used_ = true; }
1325
1326   // Clear the initial value; used for error handling.
1327   void
1328   clear_init()
1329   { this->init_ = NULL; }
1330
1331   // Set the initial value; used for converting shortcuts.
1332   void
1333   set_init(Expression* init)
1334   { this->init_ = init; }
1335
1336   // Get the preinit block, a block of statements to be run before the
1337   // initialization expression.
1338   Block*
1339   preinit_block(Gogo*);
1340
1341   // Add a statement to be run before the initialization expression.
1342   // This is only used for global variables.
1343   void
1344   add_preinit_statement(Gogo*, Statement*);
1345
1346   // Lower the initialization expression after parsing is complete.
1347   void
1348   lower_init_expression(Gogo*, Named_object*, Statement_inserter*);
1349
1350   // A special case: the init value is used only to determine the
1351   // type.  This is used if the variable is defined using := with the
1352   // comma-ok form of a map index or a receive expression.  The init
1353   // value is actually the map index expression or receive expression.
1354   // We use this because we may not know the right type at parse time.
1355   void
1356   set_type_from_init_tuple()
1357   { this->type_from_init_tuple_ = true; }
1358
1359   // Another special case: the init value is used only to determine
1360   // the type.  This is used if the variable is defined using := with
1361   // a range clause.  The init value is the range expression.  The
1362   // type of the variable is the index type of the range expression
1363   // (i.e., the first value returned by a range).
1364   void
1365   set_type_from_range_index()
1366   { this->type_from_range_index_ = true; }
1367
1368   // Another special case: like set_type_from_range_index, but the
1369   // type is the value type of the range expression (i.e., the second
1370   // value returned by a range).
1371   void
1372   set_type_from_range_value()
1373   { this->type_from_range_value_ = true; }
1374
1375   // Another special case: the init value is used only to determine
1376   // the type.  This is used if the variable is defined using := with
1377   // a case in a select statement.  The init value is the channel.
1378   // The type of the variable is the channel's element type.
1379   void
1380   set_type_from_chan_element()
1381   { this->type_from_chan_element_ = true; }
1382
1383   // After we lower the select statement, we once again set the type
1384   // from the initialization expression.
1385   void
1386   clear_type_from_chan_element()
1387   {
1388     go_assert(this->type_from_chan_element_);
1389     this->type_from_chan_element_ = false;
1390   }
1391
1392   // Note that this variable was created for a type switch clause.
1393   void
1394   set_is_type_switch_var()
1395   { this->is_type_switch_var_ = true; }
1396
1397   // Traverse the initializer expression.
1398   int
1399   traverse_expression(Traverse*, unsigned int traverse_mask);
1400
1401   // Determine the type of the variable if necessary.
1402   void
1403   determine_type();
1404
1405   // Get the backend representation of the variable.
1406   Bvariable*
1407   get_backend_variable(Gogo*, Named_object*, const Package*,
1408                        const std::string&);
1409
1410   // Get the initial value of the variable as a tree.  This may only
1411   // be called if has_pre_init() returns false.
1412   tree
1413   get_init_tree(Gogo*, Named_object* function);
1414
1415   // Return a series of statements which sets the value of the
1416   // variable in DECL.  This should only be called is has_pre_init()
1417   // returns true.  DECL may be NULL for a sink variable.
1418   tree
1419   get_init_block(Gogo*, Named_object* function, tree decl);
1420
1421   // Export the variable.
1422   void
1423   export_var(Export*, const std::string& name) const;
1424
1425   // Import a variable.
1426   static void
1427   import_var(Import*, std::string* pname, Type** ptype);
1428
1429  private:
1430   // The type of a tuple.
1431   Type*
1432   type_from_tuple(Expression*, bool) const;
1433
1434   // The type of a range.
1435   Type*
1436   type_from_range(Expression*, bool, bool) const;
1437
1438   // The element type of a channel.
1439   Type*
1440   type_from_chan_element(Expression*, bool) const;
1441
1442   // The variable's type.  This may be NULL if the type is set from
1443   // the expression.
1444   Type* type_;
1445   // The initial value.  This may be NULL if the variable should be
1446   // initialized to the default value for the type.
1447   Expression* init_;
1448   // Statements to run before the init statement.
1449   Block* preinit_;
1450   // Location of variable definition.
1451   Location location_;
1452   // Backend representation.
1453   Bvariable* backend_;
1454   // Whether this is a global variable.
1455   bool is_global_ : 1;
1456   // Whether this is a function parameter.
1457   bool is_parameter_ : 1;
1458   // Whether this is the receiver parameter of a method.
1459   bool is_receiver_ : 1;
1460   // Whether this is the varargs parameter of a function.
1461   bool is_varargs_parameter_ : 1;
1462   // Whether this variable is ever referenced.
1463   bool is_used_ : 1;
1464   // Whether something takes the address of this variable.  For a
1465   // local variable this implies that the variable has to be on the
1466   // heap.
1467   bool is_address_taken_ : 1;
1468   // Whether something takes the address of this variable such that
1469   // the address does not escape the function.
1470   bool is_non_escaping_address_taken_ : 1;
1471   // True if we have seen this variable in a traversal.
1472   bool seen_ : 1;
1473   // True if we have lowered the initialization expression.
1474   bool init_is_lowered_ : 1;
1475   // True if init is a tuple used to set the type.
1476   bool type_from_init_tuple_ : 1;
1477   // True if init is a range clause and the type is the index type.
1478   bool type_from_range_index_ : 1;
1479   // True if init is a range clause and the type is the value type.
1480   bool type_from_range_value_ : 1;
1481   // True if init is a channel and the type is the channel's element type.
1482   bool type_from_chan_element_ : 1;
1483   // True if this is a variable created for a type switch case.
1484   bool is_type_switch_var_ : 1;
1485   // True if we have determined types.
1486   bool determined_type_ : 1;
1487 };
1488
1489 // A variable which is really the name for a function return value, or
1490 // part of one.
1491
1492 class Result_variable
1493 {
1494  public:
1495   Result_variable(Type* type, Function* function, int index,
1496                   Location location)
1497     : type_(type), function_(function), index_(index), location_(location),
1498       backend_(NULL), is_address_taken_(false),
1499       is_non_escaping_address_taken_(false)
1500   { }
1501
1502   // Get the type of the result variable.
1503   Type*
1504   type() const
1505   { return this->type_; }
1506
1507   // Get the function that this is associated with.
1508   Function*
1509   function() const
1510   { return this->function_; }
1511
1512   // Index in the list of function results.
1513   int
1514   index() const
1515   { return this->index_; }
1516
1517   // The location of the variable definition.
1518   Location
1519   location() const
1520   { return this->location_; }
1521
1522   // Whether this variable's address is taken.
1523   bool
1524   is_address_taken() const
1525   { return this->is_address_taken_; }
1526
1527   // Note that something takes the address of this variable.
1528   void
1529   set_address_taken()
1530   { this->is_address_taken_ = true; }
1531
1532   // Return whether the address is taken but does not escape.
1533   bool
1534   is_non_escaping_address_taken() const
1535   { return this->is_non_escaping_address_taken_; }
1536
1537   // Note that something takes the address of this variable such that
1538   // the address does not escape the function.
1539   void
1540   set_non_escaping_address_taken()
1541   { this->is_non_escaping_address_taken_ = true; }
1542
1543   // Whether this variable should live in the heap.
1544   bool
1545   is_in_heap() const
1546   { return this->is_address_taken_; }
1547
1548   // Set the function.  This is used when cloning functions which call
1549   // recover.
1550   void
1551   set_function(Function* function)
1552   { this->function_ = function; }
1553
1554   // Get the backend representation of the variable.
1555   Bvariable*
1556   get_backend_variable(Gogo*, Named_object*, const std::string&);
1557
1558  private:
1559   // Type of result variable.
1560   Type* type_;
1561   // Function with which this is associated.
1562   Function* function_;
1563   // Index in list of results.
1564   int index_;
1565   // Where the result variable is defined.
1566   Location location_;
1567   // Backend representation.
1568   Bvariable* backend_;
1569   // Whether something takes the address of this variable.
1570   bool is_address_taken_;
1571   // Whether something takes the address of this variable such that
1572   // the address does not escape the function.
1573   bool is_non_escaping_address_taken_;
1574 };
1575
1576 // The value we keep for a named constant.  This lets us hold a type
1577 // and an expression.
1578
1579 class Named_constant
1580 {
1581  public:
1582   Named_constant(Type* type, Expression* expr, int iota_value,
1583                  Location location)
1584     : type_(type), expr_(expr), iota_value_(iota_value), location_(location),
1585       lowering_(false)
1586   { }
1587
1588   Type*
1589   type() const
1590   { return this->type_; }
1591
1592   Expression*
1593   expr() const
1594   { return this->expr_; }
1595
1596   int
1597   iota_value() const
1598   { return this->iota_value_; }
1599
1600   Location
1601   location() const
1602   { return this->location_; }
1603
1604   // Whether we are lowering.
1605   bool
1606   lowering() const
1607   { return this->lowering_; }
1608
1609   // Set that we are lowering.
1610   void
1611   set_lowering()
1612   { this->lowering_ = true; }
1613
1614   // We are no longer lowering.
1615   void
1616   clear_lowering()
1617   { this->lowering_ = false; }
1618
1619   // Traverse the expression.
1620   int
1621   traverse_expression(Traverse*);
1622
1623   // Determine the type of the constant if necessary.
1624   void
1625   determine_type();
1626
1627   // Indicate that we found and reported an error for this constant.
1628   void
1629   set_error();
1630
1631   // Export the constant.
1632   void
1633   export_const(Export*, const std::string& name) const;
1634
1635   // Import a constant.
1636   static void
1637   import_const(Import*, std::string*, Type**, Expression**);
1638
1639  private:
1640   // The type of the constant.
1641   Type* type_;
1642   // The expression for the constant.
1643   Expression* expr_;
1644   // If the predeclared constant iota is used in EXPR_, this is the
1645   // value it will have.  We do this because at parse time we don't
1646   // know whether the name "iota" will refer to the predeclared
1647   // constant or to something else.  We put in the right value in when
1648   // we lower.
1649   int iota_value_;
1650   // The location of the definition.
1651   Location location_;
1652   // Whether we are currently lowering this constant.
1653   bool lowering_;
1654 };
1655
1656 // A type declaration.
1657
1658 class Type_declaration
1659 {
1660  public:
1661   Type_declaration(Location location)
1662     : location_(location), in_function_(NULL), in_function_index_(0),
1663       methods_(), issued_warning_(false)
1664   { }
1665
1666   // Return the location.
1667   Location
1668   location() const
1669   { return this->location_; }
1670
1671   // Return the function in which this type is declared.  This will
1672   // return NULL for a type declared in global scope.
1673   Named_object*
1674   in_function(unsigned int* pindex)
1675   {
1676     *pindex = this->in_function_index_;
1677     return this->in_function_;
1678   }
1679
1680   // Set the function in which this type is declared.
1681   void
1682   set_in_function(Named_object* f, unsigned int index)
1683   {
1684     this->in_function_ = f;
1685     this->in_function_index_ = index;
1686   }
1687
1688   // Add a method to this type.  This is used when methods are defined
1689   // before the type.
1690   Named_object*
1691   add_method(const std::string& name, Function* function);
1692
1693   // Add a method declaration to this type.
1694   Named_object*
1695   add_method_declaration(const std::string& name, Package*,
1696                          Function_type* type, Location location);
1697
1698   // Return whether any methods were defined.
1699   bool
1700   has_methods() const;
1701
1702   // Define methods when the real type is known.
1703   void
1704   define_methods(Named_type*);
1705
1706   // This is called if we are trying to use this type.  It returns
1707   // true if we should issue a warning.
1708   bool
1709   using_type();
1710
1711  private:
1712   typedef std::vector<Named_object*> Methods;
1713
1714   // The location of the type declaration.
1715   Location location_;
1716   // If this type is declared in a function, a pointer back to the
1717   // function in which it is defined.
1718   Named_object* in_function_;
1719   // The index of this type in IN_FUNCTION_.
1720   unsigned int in_function_index_;
1721   // Methods defined before the type is defined.
1722   Methods methods_;
1723   // True if we have issued a warning about a use of this type
1724   // declaration when it is undefined.
1725   bool issued_warning_;
1726 };
1727
1728 // An unknown object.  These are created by the parser for forward
1729 // references to names which have not been seen before.  In a correct
1730 // program, these will always point to a real definition by the end of
1731 // the parse.  Because they point to another Named_object, these may
1732 // only be referenced by Unknown_expression objects.
1733
1734 class Unknown_name
1735 {
1736  public:
1737   Unknown_name(Location location)
1738     : location_(location), real_named_object_(NULL)
1739   { }
1740
1741   // Return the location where this name was first seen.
1742   Location
1743   location() const
1744   { return this->location_; }
1745
1746   // Return the real named object that this points to, or NULL if it
1747   // was never resolved.
1748   Named_object*
1749   real_named_object() const
1750   { return this->real_named_object_; }
1751
1752   // Set the real named object that this points to.
1753   void
1754   set_real_named_object(Named_object* no);
1755
1756  private:
1757   // The location where this name was first seen.
1758   Location location_;
1759   // The real named object when it is known.
1760   Named_object*
1761   real_named_object_;
1762 };
1763
1764 // A named object named.  This is the result of a declaration.  We
1765 // don't use a superclass because they all have to be handled
1766 // differently.
1767
1768 class Named_object
1769 {
1770  public:
1771   enum Classification
1772   {
1773     // An uninitialized Named_object.  We should never see this.
1774     NAMED_OBJECT_UNINITIALIZED,
1775     // An erroneous name.  This indicates a parse error, to avoid
1776     // later errors about undefined references.
1777     NAMED_OBJECT_ERRONEOUS,
1778     // An unknown name.  This is used for forward references.  In a
1779     // correct program, these will all be resolved by the end of the
1780     // parse.
1781     NAMED_OBJECT_UNKNOWN,
1782     // A const.
1783     NAMED_OBJECT_CONST,
1784     // A type.
1785     NAMED_OBJECT_TYPE,
1786     // A forward type declaration.
1787     NAMED_OBJECT_TYPE_DECLARATION,
1788     // A var.
1789     NAMED_OBJECT_VAR,
1790     // A result variable in a function.
1791     NAMED_OBJECT_RESULT_VAR,
1792     // The blank identifier--the special variable named _.
1793     NAMED_OBJECT_SINK,
1794     // A func.
1795     NAMED_OBJECT_FUNC,
1796     // A forward func declaration.
1797     NAMED_OBJECT_FUNC_DECLARATION,
1798     // A package.
1799     NAMED_OBJECT_PACKAGE
1800   };
1801
1802   // Return the classification.
1803   Classification
1804   classification() const
1805   { return this->classification_; }
1806
1807   // Classifiers.
1808
1809   bool
1810   is_erroneous() const
1811   { return this->classification_ == NAMED_OBJECT_ERRONEOUS; }
1812
1813   bool
1814   is_unknown() const
1815   { return this->classification_ == NAMED_OBJECT_UNKNOWN; }
1816
1817   bool
1818   is_const() const
1819   { return this->classification_ == NAMED_OBJECT_CONST; }
1820
1821   bool
1822   is_type() const
1823   { return this->classification_ == NAMED_OBJECT_TYPE; }
1824
1825   bool
1826   is_type_declaration() const
1827   { return this->classification_ == NAMED_OBJECT_TYPE_DECLARATION; }
1828
1829   bool
1830   is_variable() const
1831   { return this->classification_ == NAMED_OBJECT_VAR; }
1832
1833   bool
1834   is_result_variable() const
1835   { return this->classification_ == NAMED_OBJECT_RESULT_VAR; }
1836
1837   bool
1838   is_sink() const
1839   { return this->classification_ == NAMED_OBJECT_SINK; }
1840
1841   bool
1842   is_function() const
1843   { return this->classification_ == NAMED_OBJECT_FUNC; }
1844
1845   bool
1846   is_function_declaration() const
1847   { return this->classification_ == NAMED_OBJECT_FUNC_DECLARATION; }
1848
1849   bool
1850   is_package() const
1851   { return this->classification_ == NAMED_OBJECT_PACKAGE; }
1852
1853   // Creators.
1854
1855   static Named_object*
1856   make_erroneous_name(const std::string& name)
1857   { return new Named_object(name, NULL, NAMED_OBJECT_ERRONEOUS); }
1858
1859   static Named_object*
1860   make_unknown_name(const std::string& name, Location);
1861
1862   static Named_object*
1863   make_constant(const Typed_identifier&, const Package*, Expression*,
1864                 int iota_value);
1865
1866   static Named_object*
1867   make_type(const std::string&, const Package*, Type*, Location);
1868
1869   static Named_object*
1870   make_type_declaration(const std::string&, const Package*, Location);
1871
1872   static Named_object*
1873   make_variable(const std::string&, const Package*, Variable*);
1874
1875   static Named_object*
1876   make_result_variable(const std::string&, Result_variable*);
1877
1878   static Named_object*
1879   make_sink();
1880
1881   static Named_object*
1882   make_function(const std::string&, const Package*, Function*);
1883
1884   static Named_object*
1885   make_function_declaration(const std::string&, const Package*, Function_type*,
1886                             Location);
1887
1888   static Named_object*
1889   make_package(const std::string& alias, Package* package);
1890
1891   // Getters.
1892
1893   Unknown_name*
1894   unknown_value()
1895   {
1896     go_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
1897     return this->u_.unknown_value;
1898   }
1899
1900   const Unknown_name*
1901   unknown_value() const
1902   {
1903     go_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
1904     return this->u_.unknown_value;
1905   }
1906
1907   Named_constant*
1908   const_value()
1909   {
1910     go_assert(this->classification_ == NAMED_OBJECT_CONST);
1911     return this->u_.const_value;
1912   }
1913
1914   const Named_constant*
1915   const_value() const
1916   {
1917     go_assert(this->classification_ == NAMED_OBJECT_CONST);
1918     return this->u_.const_value;
1919   }
1920
1921   Named_type*
1922   type_value()
1923   {
1924     go_assert(this->classification_ == NAMED_OBJECT_TYPE);
1925     return this->u_.type_value;
1926   }
1927
1928   const Named_type*
1929   type_value() const
1930   {
1931     go_assert(this->classification_ == NAMED_OBJECT_TYPE);
1932     return this->u_.type_value;
1933   }
1934
1935   Type_declaration*
1936   type_declaration_value()
1937   {
1938     go_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
1939     return this->u_.type_declaration;
1940   }
1941
1942   const Type_declaration*
1943   type_declaration_value() const
1944   {
1945     go_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
1946     return this->u_.type_declaration;
1947   }
1948
1949   Variable*
1950   var_value()
1951   {
1952     go_assert(this->classification_ == NAMED_OBJECT_VAR);
1953     return this->u_.var_value;
1954   }
1955
1956   const Variable*
1957   var_value() const
1958   {
1959     go_assert(this->classification_ == NAMED_OBJECT_VAR);
1960     return this->u_.var_value;
1961   }
1962
1963   Result_variable*
1964   result_var_value()
1965   {
1966     go_assert(this->classification_ == NAMED_OBJECT_RESULT_VAR);
1967     return this->u_.result_var_value;
1968   }
1969
1970   const Result_variable*
1971   result_var_value() const
1972   {
1973     go_assert(this->classification_ == NAMED_OBJECT_RESULT_VAR);
1974     return this->u_.result_var_value;
1975   }
1976
1977   Function*
1978   func_value()
1979   {
1980     go_assert(this->classification_ == NAMED_OBJECT_FUNC);
1981     return this->u_.func_value;
1982   }
1983
1984   const Function*
1985   func_value() const
1986   {
1987     go_assert(this->classification_ == NAMED_OBJECT_FUNC);
1988     return this->u_.func_value;
1989   }
1990
1991   Function_declaration*
1992   func_declaration_value()
1993   {
1994     go_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
1995     return this->u_.func_declaration_value;
1996   }
1997
1998   const Function_declaration*
1999   func_declaration_value() const
2000   {
2001     go_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
2002     return this->u_.func_declaration_value;
2003   }
2004
2005   Package*
2006   package_value()
2007   {
2008     go_assert(this->classification_ == NAMED_OBJECT_PACKAGE);
2009     return this->u_.package_value;
2010   }
2011
2012   const Package*
2013   package_value() const
2014   {
2015     go_assert(this->classification_ == NAMED_OBJECT_PACKAGE);
2016     return this->u_.package_value;
2017   }
2018
2019   const std::string&
2020   name() const
2021   { return this->name_; }
2022
2023   // Return the name to use in an error message.  The difference is
2024   // that if this Named_object is defined in a different package, this
2025   // will return PACKAGE.NAME.
2026   std::string
2027   message_name() const;
2028
2029   const Package*
2030   package() const
2031   { return this->package_; }
2032
2033   // Resolve an unknown value if possible.  This returns the same
2034   // Named_object or a new one.
2035   Named_object*
2036   resolve()
2037   {
2038     Named_object* ret = this;
2039     if (this->is_unknown())
2040       {
2041         Named_object* r = this->unknown_value()->real_named_object();
2042         if (r != NULL)
2043           ret = r;
2044       }
2045     return ret;
2046   }
2047
2048   const Named_object*
2049   resolve() const
2050   {
2051     const Named_object* ret = this;
2052     if (this->is_unknown())
2053       {
2054         const Named_object* r = this->unknown_value()->real_named_object();
2055         if (r != NULL)
2056           ret = r;
2057       }
2058     return ret;
2059   }
2060
2061   // The location where this object was defined or referenced.
2062   Location
2063   location() const;
2064
2065   // Convert a variable to the backend representation.
2066   Bvariable*
2067   get_backend_variable(Gogo*, Named_object* function);
2068
2069   // Return a tree for the external identifier for this object.
2070   tree
2071   get_id(Gogo*);
2072
2073   // Return a tree representing this object.
2074   tree
2075   get_tree(Gogo*, Named_object* function);
2076
2077   // Define a type declaration.
2078   void
2079   set_type_value(Named_type*);
2080
2081   // Define a function declaration.
2082   void
2083   set_function_value(Function*);
2084
2085   // Declare an unknown name as a type declaration.
2086   void
2087   declare_as_type();
2088
2089   // Export this object.
2090   void
2091   export_named_object(Export*) const;
2092
2093  private:
2094   Named_object(const std::string&, const Package*, Classification);
2095
2096   // The name of the object.
2097   std::string name_;
2098   // The package that this object is in.  This is NULL if it is in the
2099   // file we are compiling.
2100   const Package* package_;
2101   // The type of object this is.
2102   Classification classification_;
2103   // The real data.
2104   union
2105   {
2106     Unknown_name* unknown_value;
2107     Named_constant* const_value;
2108     Named_type* type_value;
2109     Type_declaration* type_declaration;
2110     Variable* var_value;
2111     Result_variable* result_var_value;
2112     Function* func_value;
2113     Function_declaration* func_declaration_value;
2114     Package* package_value;
2115   } u_;
2116   // The DECL tree for this object if we have already converted it.
2117   tree tree_;
2118 };
2119
2120 // A binding contour.  This binds names to objects.
2121
2122 class Bindings
2123 {
2124  public:
2125   // Type for mapping from names to objects.
2126   typedef Unordered_map(std::string, Named_object*) Contour;
2127
2128   Bindings(Bindings* enclosing);
2129
2130   // Add an erroneous name.
2131   Named_object*
2132   add_erroneous_name(const std::string& name)
2133   { return this->add_named_object(Named_object::make_erroneous_name(name)); }
2134
2135   // Add an unknown name.
2136   Named_object*
2137   add_unknown_name(const std::string& name, Location location)
2138   {
2139     return this->add_named_object(Named_object::make_unknown_name(name,
2140                                                                   location));
2141   }
2142
2143   // Add a constant.
2144   Named_object*
2145   add_constant(const Typed_identifier& tid, const Package* package,
2146                Expression* expr, int iota_value)
2147   {
2148     return this->add_named_object(Named_object::make_constant(tid, package,
2149                                                               expr,
2150                                                               iota_value));
2151   }
2152
2153   // Add a type.
2154   Named_object*
2155   add_type(const std::string& name, const Package* package, Type* type,
2156            Location location)
2157   {
2158     return this->add_named_object(Named_object::make_type(name, package, type,
2159                                                           location));
2160   }
2161
2162   // Add a named type.  This is used for builtin types, and to add an
2163   // imported type to the global scope.
2164   Named_object*
2165   add_named_type(Named_type* named_type);
2166
2167   // Add a type declaration.
2168   Named_object*
2169   add_type_declaration(const std::string& name, const Package* package,
2170                        Location location)
2171   {
2172     Named_object* no = Named_object::make_type_declaration(name, package,
2173                                                            location);
2174     return this->add_named_object(no);
2175   }
2176
2177   // Add a variable.
2178   Named_object*
2179   add_variable(const std::string& name, const Package* package,
2180                Variable* variable)
2181   {
2182     return this->add_named_object(Named_object::make_variable(name, package,
2183                                                               variable));
2184   }
2185
2186   // Add a result variable.
2187   Named_object*
2188   add_result_variable(const std::string& name, Result_variable* result)
2189   {
2190     return this->add_named_object(Named_object::make_result_variable(name,
2191                                                                      result));
2192   }
2193
2194   // Add a function.
2195   Named_object*
2196   add_function(const std::string& name, const Package*, Function* function);
2197
2198   // Add a function declaration.
2199   Named_object*
2200   add_function_declaration(const std::string& name, const Package* package,
2201                            Function_type* type, Location location);
2202
2203   // Add a package.  The location is the location of the import
2204   // statement.
2205   Named_object*
2206   add_package(const std::string& alias, Package* package)
2207   {
2208     Named_object* no = Named_object::make_package(alias, package);
2209     return this->add_named_object(no);
2210   }
2211
2212   // Define a type which was already declared.
2213   void
2214   define_type(Named_object*, Named_type*);
2215
2216   // Add a method to the list of objects.  This is not added to the
2217   // lookup table.
2218   void
2219   add_method(Named_object*);
2220
2221   // Add a named object to this binding.
2222   Named_object*
2223   add_named_object(Named_object* no)
2224   { return this->add_named_object_to_contour(&this->bindings_, no); }
2225
2226   // Clear all names in file scope from the bindings.
2227   void
2228   clear_file_scope();
2229
2230   // Look up a name in this binding contour and in any enclosing
2231   // binding contours.  This returns NULL if the name is not found.
2232   Named_object*
2233   lookup(const std::string&) const;
2234
2235   // Look up a name in this binding contour without looking in any
2236   // enclosing binding contours.  Returns NULL if the name is not found.
2237   Named_object*
2238   lookup_local(const std::string&) const;
2239
2240   // Remove a name.
2241   void
2242   remove_binding(Named_object*);
2243
2244   // Mark all variables as used.  This is used for some types of parse
2245   // error.
2246   void
2247   mark_locals_used();
2248
2249   // Traverse the tree.  See the Traverse class.
2250   int
2251   traverse(Traverse*, bool is_global);
2252
2253   // Iterate over definitions.  This does not include things which
2254   // were only declared.
2255
2256   typedef std::vector<Named_object*>::const_iterator
2257     const_definitions_iterator;
2258
2259   const_definitions_iterator
2260   begin_definitions() const
2261   { return this->named_objects_.begin(); }
2262
2263   const_definitions_iterator
2264   end_definitions() const
2265   { return this->named_objects_.end(); }
2266
2267   // Return the number of definitions.
2268   size_t
2269   size_definitions() const
2270   { return this->named_objects_.size(); }
2271
2272   // Return whether there are no definitions.
2273   bool
2274   empty_definitions() const
2275   { return this->named_objects_.empty(); }
2276
2277   // Iterate over declarations.  This is everything that has been
2278   // declared, which includes everything which has been defined.
2279
2280   typedef Contour::const_iterator const_declarations_iterator;
2281
2282   const_declarations_iterator
2283   begin_declarations() const
2284   { return this->bindings_.begin(); }
2285
2286   const_declarations_iterator
2287   end_declarations() const
2288   { return this->bindings_.end(); }
2289
2290   // Return the number of declarations.
2291   size_t
2292   size_declarations() const
2293   { return this->bindings_.size(); }
2294
2295   // Return whether there are no declarations.
2296   bool
2297   empty_declarations() const
2298   { return this->bindings_.empty(); }
2299
2300   // Return the first declaration.
2301   Named_object*
2302   first_declaration()
2303   { return this->bindings_.empty() ? NULL : this->bindings_.begin()->second; }
2304
2305  private:
2306   Named_object*
2307   add_named_object_to_contour(Contour*, Named_object*);
2308
2309   Named_object*
2310   new_definition(Named_object*, Named_object*);
2311
2312   // Enclosing bindings.
2313   Bindings* enclosing_;
2314   // The list of objects.
2315   std::vector<Named_object*> named_objects_;
2316   // The mapping from names to objects.
2317   Contour bindings_;
2318 };
2319
2320 // A label.
2321
2322 class Label
2323 {
2324  public:
2325   Label(const std::string& name)
2326     : name_(name), location_(Linemap::unknown_location()), snapshot_(NULL),
2327       refs_(), is_used_(false), blabel_(NULL)
2328   { }
2329
2330   // Return the label's name.
2331   const std::string&
2332   name() const
2333   { return this->name_; }
2334
2335   // Return whether the label has been defined.
2336   bool
2337   is_defined() const
2338   { return !Linemap::is_unknown_location(this->location_); }
2339
2340   // Return whether the label has been used.
2341   bool
2342   is_used() const
2343   { return this->is_used_; }
2344
2345   // Record that the label is used.
2346   void
2347   set_is_used()
2348   { this->is_used_ = true; }
2349
2350   // Return the location of the definition.
2351   Location
2352   location() const
2353   { return this->location_; }
2354
2355   // Return the bindings snapshot.
2356   Bindings_snapshot*
2357   snapshot() const
2358   { return this->snapshot_; }
2359
2360   // Add a snapshot of a goto which refers to this label.
2361   void
2362   add_snapshot_ref(Bindings_snapshot* snapshot)
2363   {
2364     go_assert(Linemap::is_unknown_location(this->location_));
2365     this->refs_.push_back(snapshot);
2366   }
2367
2368   // Return the list of snapshots of goto statements which refer to
2369   // this label.
2370   const std::vector<Bindings_snapshot*>&
2371   refs() const
2372   { return this->refs_; }
2373
2374   // Clear the references.
2375   void
2376   clear_refs();
2377
2378   // Define the label at LOCATION with the given bindings snapshot.
2379   void
2380   define(Location location, Bindings_snapshot* snapshot)
2381   {
2382     go_assert(Linemap::is_unknown_location(this->location_)
2383               && this->snapshot_ == NULL);
2384     this->location_ = location;
2385     this->snapshot_ = snapshot;
2386   }
2387
2388   // Return the backend representation for this label.
2389   Blabel*
2390   get_backend_label(Translate_context*);
2391
2392   // Return an expression for the address of this label.  This is used
2393   // to get the return address of a deferred function to see whether
2394   // the function may call recover.
2395   Bexpression*
2396   get_addr(Translate_context*, Location location);
2397
2398  private:
2399   // The name of the label.
2400   std::string name_;
2401   // The location of the definition.  This is 0 if the label has not
2402   // yet been defined.
2403   Location location_;
2404   // A snapshot of the set of bindings defined at this label, used to
2405   // issue errors about invalid goto statements.
2406   Bindings_snapshot* snapshot_;
2407   // A list of snapshots of goto statements which refer to this label.
2408   std::vector<Bindings_snapshot*> refs_;
2409   // Whether the label has been used.
2410   bool is_used_;
2411   // The backend representation.
2412   Blabel* blabel_;
2413 };
2414
2415 // An unnamed label.  These are used when lowering loops.
2416
2417 class Unnamed_label
2418 {
2419  public:
2420   Unnamed_label(Location location)
2421     : location_(location), blabel_(NULL)
2422   { }
2423
2424   // Get the location where the label is defined.
2425   Location
2426   location() const
2427   { return this->location_; }
2428
2429   // Set the location where the label is defined.
2430   void
2431   set_location(Location location)
2432   { this->location_ = location; }
2433
2434   // Return a statement which defines this label.
2435   Bstatement*
2436   get_definition(Translate_context*);
2437
2438   // Return a goto to this label from LOCATION.
2439   Bstatement*
2440   get_goto(Translate_context*, Location location);
2441
2442  private:
2443   // Return the backend representation.
2444   Blabel*
2445   get_blabel(Translate_context*);
2446
2447   // The location where the label is defined.
2448   Location location_;
2449   // The backend representation of this label.
2450   Blabel* blabel_;
2451 };
2452
2453 // An imported package.
2454
2455 class Package
2456 {
2457  public:
2458   Package(const std::string& pkgpath, Location location);
2459
2460   // Get the package path used for all symbols exported from this
2461   // package.
2462   const std::string&
2463   pkgpath() const
2464   { return this->pkgpath_; }
2465
2466   // Return the package path to use for a symbol name.
2467   const std::string&
2468   pkgpath_symbol() const
2469   { return this->pkgpath_symbol_; }
2470
2471   // Return the location of the import statement.
2472   Location
2473   location() const
2474   { return this->location_; }
2475
2476   // Return whether we know the name of this package yet.
2477   bool
2478   has_package_name() const
2479   { return !this->package_name_.empty(); }
2480
2481   // The name that this package uses in its package clause.  This may
2482   // be different from the name in the associated Named_object if the
2483   // import statement used an alias.
2484   const std::string&
2485   package_name() const
2486   {
2487     go_assert(!this->package_name_.empty());
2488     return this->package_name_;
2489   }
2490
2491   // The priority of this package.  The init function of packages with
2492   // lower priority must be run before the init function of packages
2493   // with higher priority.
2494   int
2495   priority() const
2496   { return this->priority_; }
2497
2498   // Set the priority.
2499   void
2500   set_priority(int priority);
2501
2502   // Return the bindings.
2503   Bindings*
2504   bindings()
2505   { return this->bindings_; }
2506
2507   // Whether some symbol from the package was used.
2508   bool
2509   used() const
2510   { return this->used_; }
2511
2512   // Note that some symbol from this package was used.
2513   void
2514   set_used() const
2515   { this->used_ = true; }
2516
2517   // Clear the used field for the next file.
2518   void
2519   clear_used()
2520   { this->used_ = false; }
2521
2522   // Whether this package was imported in the current file.
2523   bool
2524   is_imported() const
2525   { return this->is_imported_; }
2526
2527   // Note that this package was imported in the current file.
2528   void
2529   set_is_imported()
2530   { this->is_imported_ = true; }
2531
2532   // Clear the imported field for the next file.
2533   void
2534   clear_is_imported()
2535   { this->is_imported_ = false; }
2536
2537   // Whether this package was imported with a name of "_".
2538   bool
2539   uses_sink_alias() const
2540   { return this->uses_sink_alias_; }
2541
2542   // Note that this package was imported with a name of "_".
2543   void
2544   set_uses_sink_alias()
2545   { this->uses_sink_alias_ = true; }
2546
2547   // Clear the sink alias field for the next file.
2548   void
2549   clear_uses_sink_alias()
2550   { this->uses_sink_alias_ = false; }
2551
2552   // Look up a name in the package.  Returns NULL if the name is not
2553   // found.
2554   Named_object*
2555   lookup(const std::string& name) const
2556   { return this->bindings_->lookup(name); }
2557
2558   // Set the name of the package.
2559   void
2560   set_package_name(const std::string& name, Location);
2561
2562   // Set the location of the package.  This is used to record the most
2563   // recent import location.
2564   void
2565   set_location(Location location)
2566   { this->location_ = location; }
2567
2568   // Add a constant to the package.
2569   Named_object*
2570   add_constant(const Typed_identifier& tid, Expression* expr)
2571   { return this->bindings_->add_constant(tid, this, expr, 0); }
2572
2573   // Add a type to the package.
2574   Named_object*
2575   add_type(const std::string& name, Type* type, Location location)
2576   { return this->bindings_->add_type(name, this, type, location); }
2577
2578   // Add a type declaration to the package.
2579   Named_object*
2580   add_type_declaration(const std::string& name, Location location)
2581   { return this->bindings_->add_type_declaration(name, this, location); }
2582
2583   // Add a variable to the package.
2584   Named_object*
2585   add_variable(const std::string& name, Variable* variable)
2586   { return this->bindings_->add_variable(name, this, variable); }
2587
2588   // Add a function declaration to the package.
2589   Named_object*
2590   add_function_declaration(const std::string& name, Function_type* type,
2591                            Location loc)
2592   { return this->bindings_->add_function_declaration(name, this, type, loc); }
2593
2594   // Determine types of constants.
2595   void
2596   determine_types();
2597
2598  private:
2599   // The package path for type reflection data.
2600   std::string pkgpath_;
2601   // The package path for symbol names.
2602   std::string pkgpath_symbol_;
2603   // The name that this package uses in the package clause.  This may
2604   // be the empty string if it is not yet known.
2605   std::string package_name_;
2606   // The names in this package.
2607   Bindings* bindings_;
2608   // The priority of this package.  A package has a priority higher
2609   // than the priority of all of the packages that it imports.  This
2610   // is used to run init functions in the right order.
2611   int priority_;
2612   // The location of the import statement.
2613   Location location_;
2614   // True if some name from this package was used.  This is mutable
2615   // because we can use a package even if we have a const pointer to
2616   // it.
2617   mutable bool used_;
2618   // True if this package was imported in the current file.
2619   bool is_imported_;
2620   // True if this package was imported with a name of "_".
2621   bool uses_sink_alias_;
2622 };
2623
2624 // Return codes for the traversal functions.  This is not an enum
2625 // because we want to be able to declare traversal functions in other
2626 // header files without including this one.
2627
2628 // Continue traversal as usual.
2629 const int TRAVERSE_CONTINUE = -1;
2630
2631 // Exit traversal.
2632 const int TRAVERSE_EXIT = 0;
2633
2634 // Continue traversal, but skip components of the current object.
2635 // E.g., if this is returned by Traverse::statement, we do not
2636 // traverse the expressions in the statement even if
2637 // traverse_expressions is set in the traverse_mask.
2638 const int TRAVERSE_SKIP_COMPONENTS = 1;
2639
2640 // This class is used when traversing the parse tree.  The caller uses
2641 // a subclass which overrides functions as desired.
2642
2643 class Traverse
2644 {
2645  public:
2646   // These bitmasks say what to traverse.
2647   static const unsigned int traverse_variables =    0x1;
2648   static const unsigned int traverse_constants =    0x2;
2649   static const unsigned int traverse_functions =    0x4;
2650   static const unsigned int traverse_blocks =       0x8;
2651   static const unsigned int traverse_statements =  0x10;
2652   static const unsigned int traverse_expressions = 0x20;
2653   static const unsigned int traverse_types =       0x40;
2654
2655   Traverse(unsigned int traverse_mask)
2656     : traverse_mask_(traverse_mask), types_seen_(NULL), expressions_seen_(NULL)
2657   { }
2658
2659   virtual ~Traverse();
2660
2661   // The bitmask of what to traverse.
2662   unsigned int
2663   traverse_mask() const
2664   { return this->traverse_mask_; }
2665
2666   // Record that we are going to traverse a type.  This returns true
2667   // if the type has already been seen in this traversal.  This is
2668   // required because types, unlike expressions, can form a circular
2669   // graph.
2670   bool
2671   remember_type(const Type*);
2672
2673   // Record that we are going to see an expression.  This returns true
2674   // if the expression has already been seen in this traversal.  This
2675   // is only needed for cases where multiple expressions can point to
2676   // a single one.
2677   bool
2678   remember_expression(const Expression*);
2679
2680   // These functions return one of the TRAVERSE codes defined above.
2681
2682   // If traverse_variables is set in the mask, this is called for
2683   // every variable in the tree.
2684   virtual int
2685   variable(Named_object*);
2686
2687   // If traverse_constants is set in the mask, this is called for
2688   // every named constant in the tree.  The bool parameter is true for
2689   // a global constant.
2690   virtual int
2691   constant(Named_object*, bool);
2692
2693   // If traverse_functions is set in the mask, this is called for
2694   // every function in the tree.
2695   virtual int
2696   function(Named_object*);
2697
2698   // If traverse_blocks is set in the mask, this is called for every
2699   // block in the tree.
2700   virtual int
2701   block(Block*);
2702
2703   // If traverse_statements is set in the mask, this is called for
2704   // every statement in the tree.
2705   virtual int
2706   statement(Block*, size_t* index, Statement*);
2707
2708   // If traverse_expressions is set in the mask, this is called for
2709   // every expression in the tree.
2710   virtual int
2711   expression(Expression**);
2712
2713   // If traverse_types is set in the mask, this is called for every
2714   // type in the tree.
2715   virtual int
2716   type(Type*);
2717
2718  private:
2719   // A hash table for types we have seen during this traversal.  Note
2720   // that this uses the default hash functions for pointers rather
2721   // than Type_hash_identical and Type_identical.  This is because for
2722   // traversal we care about seeing a specific type structure.  If
2723   // there are two separate instances of identical types, we want to
2724   // traverse both.
2725   typedef Unordered_set(const Type*) Types_seen;
2726
2727   typedef Unordered_set(const Expression*) Expressions_seen;
2728
2729   // Bitmask of what sort of objects to traverse.
2730   unsigned int traverse_mask_;
2731   // Types which have been seen in this traversal.
2732   Types_seen* types_seen_;
2733   // Expressions which have been seen in this traversal.
2734   Expressions_seen* expressions_seen_;
2735 };
2736
2737 // A class which makes it easier to insert new statements before the
2738 // current statement during a traversal.
2739
2740 class Statement_inserter
2741 {
2742  public:
2743   // Empty constructor.
2744   Statement_inserter()
2745     : block_(NULL), pindex_(NULL), gogo_(NULL), var_(NULL)
2746   { }
2747
2748   // Constructor for a statement in a block.
2749   Statement_inserter(Block* block, size_t *pindex)
2750     : block_(block), pindex_(pindex), gogo_(NULL), var_(NULL)
2751   { }
2752
2753   // Constructor for a global variable.
2754   Statement_inserter(Gogo* gogo, Variable* var)
2755     : block_(NULL), pindex_(NULL), gogo_(gogo), var_(var)
2756   { go_assert(var->is_global()); }
2757
2758   // We use the default copy constructor and assignment operator.
2759
2760   // Insert S before the statement we are traversing, or before the
2761   // initialization expression of a global variable.
2762   void
2763   insert(Statement* s);
2764
2765  private:
2766   // The block that the statement is in.
2767   Block* block_;
2768   // The index of the statement that we are traversing.
2769   size_t* pindex_;
2770   // The IR, needed when looking at an initializer expression for a
2771   // global variable.
2772   Gogo* gogo_;
2773   // The global variable, when looking at an initializer expression.
2774   Variable* var_;
2775 };
2776
2777 // When translating the gogo IR into the backend data structure, this
2778 // is the context we pass down the blocks and statements.
2779
2780 class Translate_context
2781 {
2782  public:
2783   Translate_context(Gogo* gogo, Named_object* function, Block* block,
2784                     Bblock* bblock)
2785     : gogo_(gogo), backend_(gogo->backend()), function_(function),
2786       block_(block), bblock_(bblock), is_const_(false)
2787   { }
2788
2789   // Accessors.
2790
2791   Gogo*
2792   gogo()
2793   { return this->gogo_; }
2794
2795   Backend*
2796   backend()
2797   { return this->backend_; }
2798
2799   Named_object*
2800   function()
2801   { return this->function_; }
2802
2803   Block*
2804   block()
2805   { return this->block_; }
2806
2807   Bblock*
2808   bblock()
2809   { return this->bblock_; }
2810
2811   bool
2812   is_const()
2813   { return this->is_const_; }
2814
2815   // Make a constant context.
2816   void
2817   set_is_const()
2818   { this->is_const_ = true; }
2819
2820  private:
2821   // The IR for the entire compilation unit.
2822   Gogo* gogo_;
2823   // The generator for the backend data structures.
2824   Backend* backend_;
2825   // The function we are currently translating.  NULL if not in a
2826   // function, e.g., the initializer of a global variable.
2827   Named_object* function_;
2828   // The block we are currently translating.  NULL if not in a
2829   // function.
2830   Block *block_;
2831   // The backend representation of the current block.  NULL if block_
2832   // is NULL.
2833   Bblock* bblock_;
2834   // Whether this is being evaluated in a constant context.  This is
2835   // used for type descriptor initializers.
2836   bool is_const_;
2837 };
2838
2839 // Runtime error codes.  These must match the values in
2840 // libgo/runtime/go-runtime-error.c.
2841
2842 // Slice index out of bounds: negative or larger than the length of
2843 // the slice.
2844 static const int RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS = 0;
2845
2846 // Array index out of bounds.
2847 static const int RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS = 1;
2848
2849 // String index out of bounds.
2850 static const int RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS = 2;
2851
2852 // Slice slice out of bounds: negative or larger than the length of
2853 // the slice or high bound less than low bound.
2854 static const int RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS = 3;
2855
2856 // Array slice out of bounds.
2857 static const int RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS = 4;
2858
2859 // String slice out of bounds.
2860 static const int RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS = 5;
2861
2862 // Dereference of nil pointer.  This is used when there is a
2863 // dereference of a pointer to a very large struct or array, to ensure
2864 // that a gigantic array is not used a proxy to access random memory
2865 // locations.
2866 static const int RUNTIME_ERROR_NIL_DEREFERENCE = 6;
2867
2868 // Slice length or capacity out of bounds in make: negative or
2869 // overflow or length greater than capacity.
2870 static const int RUNTIME_ERROR_MAKE_SLICE_OUT_OF_BOUNDS = 7;
2871
2872 // Map capacity out of bounds in make: negative or overflow.
2873 static const int RUNTIME_ERROR_MAKE_MAP_OUT_OF_BOUNDS = 8;
2874
2875 // Channel capacity out of bounds in make: negative or overflow.
2876 static const int RUNTIME_ERROR_MAKE_CHAN_OUT_OF_BOUNDS = 9;
2877
2878 // Division by zero.
2879 static const int RUNTIME_ERROR_DIVISION_BY_ZERO = 10;
2880
2881 // This is used by some of the langhooks.
2882 extern Gogo* go_get_gogo();
2883
2884 // Whether we have seen any errors.  FIXME: Replace with a backend
2885 // interface.
2886 extern bool saw_errors();
2887
2888 #endif // !defined(GO_GOGO_H)