1 // gogo.h -- Go frontend parsed representation. -*- C++ -*-
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.
12 class Type_hash_identical
;
15 class Typed_identifier
;
16 class Typed_identifier_list
;
28 class Struct_field_list
;
34 class Forward_declaration_type
;
39 class Translate_context
;
43 // This file declares the basic classes used to hold the internal
44 // representation of Go which is built by the parser.
46 // An initialization function for an imported package. This is a
47 // magic function which initializes variables and runs the "init"
53 Import_init(const std::string
& package_name
, const std::string
& init_name
,
55 : package_name_(package_name
), init_name_(init_name
), priority_(priority
)
58 // The name of the package being imported.
61 { return this->package_name_
; }
63 // The name of the package's init function.
66 { return this->init_name_
; }
68 // The priority of the initialization function. Functions with a
69 // lower priority number must be run first.
72 { return this->priority_
; }
75 // The name of the package being imported.
76 std::string package_name_
;
77 // The name of the package's init function.
78 std::string init_name_
;
83 // For sorting purposes.
86 operator<(const Import_init
& i1
, const Import_init
& i2
)
88 if (i1
.priority() < i2
.priority())
90 if (i1
.priority() > i2
.priority())
92 if (i1
.package_name() != i2
.package_name())
93 return i1
.package_name() < i2
.package_name();
94 return i1
.init_name() < i2
.init_name();
97 // The holder for the internal representation of the entire
103 // Create the IR, passing in the sizes of the types "int" and
104 // "uintptr" in bits.
105 Gogo(int int_type_size
, int pointer_size
);
107 // Get the package name.
109 package_name() const;
111 // Set the package name.
113 set_package_name(const std::string
&, source_location
);
115 // Return whether this is the "main" package.
117 is_main_package() const;
119 // If necessary, adjust the name to use for a hidden symbol. We add
120 // a prefix of the package name, so that hidden symbols in different
121 // packages do not collide.
123 pack_hidden_name(const std::string
& name
, bool is_exported
) const
127 : ('.' + this->unique_prefix()
128 + '.' + this->package_name()
132 // Unpack a name which may have been hidden. Returns the
133 // user-visible name of the object.
135 unpack_hidden_name(const std::string
& name
)
136 { return name
[0] != '.' ? name
: name
.substr(name
.rfind('.') + 1); }
138 // Return whether a possibly packed name is hidden.
140 is_hidden_name(const std::string
& name
)
141 { return name
[0] == '.'; }
143 // Return the package prefix of a hidden name.
145 hidden_name_prefix(const std::string
& name
)
147 gcc_assert(Gogo::is_hidden_name(name
));
148 return name
.substr(1, name
.rfind('.') - 1);
151 // Given a name which may or may not have been hidden, return the
152 // name to use in an error message.
154 message_name(const std::string
& name
);
156 // Return whether a name is the blank identifier _.
158 is_sink_name(const std::string
& name
)
160 return (name
[0] == '.'
161 && name
[name
.length() - 1] == '_'
162 && name
[name
.length() - 2] == '.');
165 // Return the unique prefix to use for all exported symbols.
167 unique_prefix() const;
169 // Set the unique prefix.
171 set_unique_prefix(const std::string
&);
173 // Return the priority to use for the package we are compiling.
174 // This is two more than the largest priority of any package we
177 package_priority() const;
179 // Import a package. FILENAME is the file name argument, LOCAL_NAME
180 // is the local name to give to the package. If LOCAL_NAME is empty
181 // the declarations are added to the global scope.
183 import_package(const std::string
& filename
, const std::string
& local_name
,
184 bool is_local_name_exported
, source_location
);
186 // Whether we are the global binding level.
188 in_global_scope() const;
190 // Look up a name in the current binding contours.
192 lookup(const std::string
&, Named_object
** pfunction
) const;
194 // Look up a name in the current block.
196 lookup_in_block(const std::string
&) const;
198 // Look up a name in the global namespace--the universal scope.
200 lookup_global(const char*) const;
202 // Add a new imported package. REAL_NAME is the real name of the
203 // package. ALIAS is the alias of the package; this may be the same
204 // as REAL_NAME. This sets *PADD_TO_GLOBALS if symbols added to
205 // this package should be added to the global namespace; this is
206 // true if the alias is ".". LOCATION is the location of the import
207 // statement. This returns the new package, or NULL on error.
209 add_imported_package(const std::string
& real_name
, const std::string
& alias
,
210 bool is_alias_exported
,
211 const std::string
& unique_prefix
,
212 source_location location
,
213 bool* padd_to_globals
);
215 // Register a package. This package may or may not be imported.
216 // This returns the Package structure for the package, creating if
219 register_package(const std::string
& name
, const std::string
& unique_prefix
,
222 // Start compiling a function. ADD_METHOD_TO_TYPE is true if a
223 // method function should be added to the type of its receiver.
225 start_function(const std::string
& name
, Function_type
* type
,
226 bool add_method_to_type
, source_location
);
228 // Finish compiling a function.
230 finish_function(source_location
);
232 // Return the current function.
234 current_function() const;
236 // Start a new block. This is not initially associated with a
239 start_block(source_location
);
241 // Finish the current block and return it.
243 finish_block(source_location
);
245 // Declare an unknown name. This is used while parsing. The name
246 // must be resolved by the end of the parse. Unknown names are
247 // always added at the package level.
249 add_unknown_name(const std::string
& name
, source_location
);
251 // Declare a function.
253 declare_function(const std::string
&, Function_type
*, source_location
);
257 add_label_definition(const std::string
&, source_location
);
259 // Add a label reference.
261 add_label_reference(const std::string
&);
263 // Add a statement to the current block.
265 add_statement(Statement
*);
267 // Add a block to the current block.
269 add_block(Block
*, source_location
);
273 add_constant(const Typed_identifier
&, Expression
*, int iota_value
);
277 add_type(const std::string
&, Type
*, source_location
);
279 // Add a named type. This is used for builtin types, and to add an
280 // imported type to the global scope.
282 add_named_type(Named_type
*);
286 declare_type(const std::string
&, source_location
);
288 // Declare a type at the package level. This is used when the
289 // parser sees an unknown name where a type name is required.
291 declare_package_type(const std::string
&, source_location
);
293 // Define a type which was already declared.
295 define_type(Named_object
*, Named_type
*);
299 add_variable(const std::string
&, Variable
*);
301 // Add a sink--a reference to the blank identifier _.
305 // Add a named object to the current namespace. This is used for
306 // import . "package".
308 add_named_object(Named_object
*);
310 // Return a name to use for a thunk function. A thunk function is
311 // one we create during the compilation, for a go statement or a
312 // defer statement or a method expression.
316 // Return whether an object is a thunk.
318 is_thunk(const Named_object
*);
320 // Note that we've seen an interface type. This is used to build
321 // all required interface method tables.
323 record_interface_type(Interface_type
*);
325 // Note that we need an initialization function.
328 { this->need_init_fn_
= true; }
330 // Clear out all names in file scope. This is called when we start
331 // parsing a new file.
335 // Traverse the tree. See the Traverse class.
339 // Define the predeclared global names.
341 define_global_names();
343 // Verify and complete all types.
347 // Lower the parse tree.
351 // Lower an expression.
353 lower_expression(Named_object
* function
, Expression
**);
357 lower_constant(Named_object
*);
359 // Finalize the method lists and build stub methods for named types.
363 // Work out the types to use for unspecified variables and
368 // Type check the program.
372 // Check the types in a single block. This is used for complicated
375 check_types_in_block(Block
*);
377 // Check for return statements.
379 check_return_statements();
385 // Add an import control function for an imported package to the
388 add_import_init_fn(const std::string
& package_name
,
389 const std::string
& init_name
, int prio
);
391 // Turn short-cut operators (&&, ||) into explicit if statements.
395 // Use temporary variables to force order of evaluation.
399 // Build thunks for functions which call recover.
401 build_recover_thunks();
403 // Simplify statements which might use thunks: go and defer
406 simplify_thunk_statements();
408 // Write out the global values.
412 // Build a call to a builtin function. PDECL should point to a NULL
413 // initialized static pointer which will hold the fndecl. NAME is
414 // the name of the function. NARGS is the number of arguments.
415 // RETTYPE is the return type. It is followed by NARGS pairs of
416 // type and argument (both trees).
418 call_builtin(tree
* pdecl
, source_location
, const char* name
, int nargs
,
421 // Build a call to the runtime error function.
423 runtime_error(int code
, source_location
);
425 // Build a builtin struct with a list of fields.
427 builtin_struct(tree
* ptype
, const char* struct_name
, tree struct_type
,
430 // Mark a function declaration as a builtin library function.
432 mark_fndecl_as_builtin_library(tree fndecl
);
434 // Build the type of the struct that holds a slice for the given
437 slice_type_tree(tree element_type_tree
);
439 // Given a tree for a slice type, return the tree for the element
442 slice_element_type_tree(tree slice_type_tree
);
444 // Build a constructor for a slice. SLICE_TYPE_TREE is the type of
445 // the slice. VALUES points to the values. COUNT is the size,
446 // CAPACITY is the capacity. If CAPACITY is NULL, it is set to
449 slice_constructor(tree slice_type_tree
, tree values
, tree count
,
452 // Build a constructor for an empty slice. SLICE_TYPE_TREE is the
453 // type of the slice.
455 empty_slice_constructor(tree slice_type_tree
);
457 // Build a map descriptor.
459 map_descriptor(Map_type
*);
461 // Return a tree for the type of a map descriptor. This is struct
462 // __go_map_descriptor in libgo/runtime/map.h. This is the same for
465 map_descriptor_type();
467 // Build a type descriptor for TYPE using INITIALIZER as the type
468 // descriptor. This builds a new decl stored in *PDECL.
470 build_type_descriptor_decl(const Type
*, Expression
* initializer
,
473 // Build required interface method tables.
475 build_interface_method_tables();
477 // Build an interface method table for a type: a list of function
478 // pointers, one for each interface method. This returns a decl.
480 interface_method_table_for_type(const Interface_type
*, Named_type
*,
483 // Return a tree which allocate SIZE bytes to hold values of type
486 allocate_memory(Type
*type
, tree size
, source_location
);
488 // Return a type to use for pointer to const char.
490 const_char_pointer_type_tree();
492 // Build a string constant with the right type.
494 string_constant_tree(const std::string
&);
496 // Build a Go string constant. This returns a pointer to the
499 go_string_constant_tree(const std::string
&);
501 // Send a value on a channel.
503 send_on_channel(tree channel
, tree val
, bool blocking
, bool for_select
,
506 // Receive a value from a channel.
508 receive_from_channel(tree type_tree
, tree channel
, bool for_select
,
511 // Return a tree for receiving an integer on a channel.
513 receive_as_64bit_integer(tree type
, tree channel
, bool blocking
,
517 // Make a trampoline which calls FNADDR passing CLOSURE.
519 make_trampoline(tree fnaddr
, tree closure
, source_location
);
522 // During parsing, we keep a stack of functions. Each function on
523 // the stack is one that we are currently parsing. For each
524 // function, we keep track of the current stack of blocks.
528 Named_object
* function
;
529 // The stack of active blocks in the function.
530 std::vector
<Block
*> blocks
;
533 // The stack of functions.
534 typedef std::vector
<Open_function
> Open_functions
;
536 // Create trees for implicit builtin functions.
538 define_builtin_function_trees();
540 // Set up the built-in unsafe package.
542 import_unsafe(const std::string
&, bool is_exported
, source_location
);
544 // Add a new imported package.
546 add_package(const std::string
& real_name
, const std::string
& alias
,
547 const std::string
& unique_prefix
, source_location location
);
549 // Return the current binding contour.
554 current_bindings() const;
556 // Return the current block.
560 // Get the name of the magic initialization function.
564 // Get the decl for the magic initialization function.
566 initialization_function_decl();
568 // Write the magic initialization function.
570 write_initialization_function(tree fndecl
, tree init_stmt_list
);
572 // Initialize imported packages.
576 // Register variables with the garbage collector.
578 register_gc_vars(const std::vector
<Named_object
*>&, tree
*);
580 // Build a pointer to a Go string constant. This returns a pointer
583 ptr_go_string_constant_tree(const std::string
&);
585 // Return the name to use for a type descriptor decl for an unnamed
588 unnamed_type_descriptor_decl_name(const Type
* type
);
590 // Return the name to use for a type descriptor decl for a type
591 // named NO, defined in IN_FUNCTION.
593 type_descriptor_decl_name(const Named_object
* no
,
594 const Named_object
* in_function
);
596 // Where a type descriptor should be defined.
597 enum Type_descriptor_location
599 // Defined in this file.
600 TYPE_DESCRIPTOR_DEFINED
,
601 // Defined in some other file.
602 TYPE_DESCRIPTOR_UNDEFINED
,
603 // Common definition which may occur in multiple files.
604 TYPE_DESCRIPTOR_COMMON
607 // Return where the decl for TYPE should be defined.
608 Type_descriptor_location
609 type_descriptor_location(const Type
* type
);
611 // Return the type of a trampoline.
613 trampoline_type_tree();
615 // Type used to map import names to packages.
616 typedef std::map
<std::string
, Package
*> Imports
;
618 // Type used to map package names to packages.
619 typedef std::map
<std::string
, Package
*> Packages
;
621 // Type used to map special names in the sys package.
622 typedef std::map
<std::string
, std::string
> Sys_names
;
624 // Hash table mapping map types to map descriptor decls.
625 typedef Unordered_map_hash(const Map_type
*, tree
, Type_hash_identical
,
626 Type_identical
) Map_descriptors
;
628 // Map unnamed types to type descriptor decls.
629 typedef Unordered_map_hash(const Type
*, tree
, Type_hash_identical
,
630 Type_identical
) Type_descriptor_decls
;
632 // The package we are compiling.
634 // The list of currently open functions during parsing.
635 Open_functions functions_
;
636 // The global binding contour. This includes the builtin functions
637 // and the package we are compiling.
639 // Mapping from import file names to packages.
641 // Whether the magic unsafe package was imported.
642 bool imported_unsafe_
;
643 // Mapping from package names we have seen to packages. This does
644 // not include the package we are compiling.
646 // Mapping from map types to map descriptors.
647 Map_descriptors
* map_descriptors_
;
648 // Mapping from unnamed types to type descriptor decls.
649 Type_descriptor_decls
* type_descriptor_decls_
;
650 // The functions named "init", if there are any.
651 std::vector
<Named_object
*> init_functions_
;
652 // Whether we need a magic initialization function.
654 // The name of the magic initialization function.
655 std::string init_fn_name_
;
656 // A list of import control variables for packages that we import.
657 std::set
<Import_init
> imported_init_fns_
;
658 // The unique prefix used for all global symbols.
659 std::string unique_prefix_
;
660 // Whether an explicit unique prefix was set by -fgo-prefix.
661 bool unique_prefix_specified_
;
662 // A list of interface types defined while parsing.
663 std::vector
<Interface_type
*> interface_types_
;
666 // A block of statements.
671 Block(Block
* enclosing
, source_location
);
673 // Return the enclosing block.
676 { return this->enclosing_
; }
678 // Return the bindings of the block.
681 { return this->bindings_
; }
685 { return this->bindings_
; }
687 // Look at the block's statements.
688 const std::vector
<Statement
*>*
690 { return &this->statements_
; }
692 // Return the start location. This is normally the location of the
693 // left curly brace which starts the block.
695 start_location() const
696 { return this->start_location_
; }
698 // Return the end location. This is normally the location of the
699 // right curly brace which ends the block.
702 { return this->end_location_
; }
704 // Add a statement to the block.
706 add_statement(Statement
*);
708 // Add a statement to the front of the block.
710 add_statement_at_front(Statement
*);
712 // Replace a statement in a block.
714 replace_statement(size_t index
, Statement
*);
716 // Add a Statement before statement number INDEX.
718 insert_statement_before(size_t index
, Statement
*);
720 // Add a Statement after statement number INDEX.
722 insert_statement_after(size_t index
, Statement
*);
724 // Set the end location of the block.
726 set_end_location(source_location location
)
727 { this->end_location_
= location
; }
729 // Traverse the tree.
733 // Set final types for unspecified variables and constants.
737 // Return true if execution of this block may fall through to the
740 may_fall_through() const;
742 // Return a tree of the code in this block.
744 get_tree(Translate_context
*);
746 // Iterate over statements.
748 typedef std::vector
<Statement
*>::iterator iterator
;
752 { return this->statements_
.begin(); }
756 { return this->statements_
.end(); }
761 // Statements in the block.
762 std::vector
<Statement
*> statements_
;
765 // Location of start of block.
766 source_location start_location_
;
767 // Location of end of block.
768 source_location end_location_
;
776 Function(Function_type
* type
, Function
*, Block
*, source_location
);
778 // Return the function's type.
781 { return this->type_
; }
783 // Return the enclosing function if there is one.
786 { return this->enclosing_
; }
788 // Set the enclosing function. This is used when building thunks
789 // for functions which call recover.
791 set_enclosing(Function
* enclosing
)
793 gcc_assert(this->enclosing_
== NULL
);
794 this->enclosing_
= enclosing
;
797 // Create the named result variables in the outer block.
799 create_named_result_variables(Gogo
*);
801 // Update the named result variables when cloning a function which
804 update_named_result_variables();
806 // Add a new field to the closure variable.
808 add_closure_field(Named_object
* var
, source_location loc
)
809 { this->closure_fields_
.push_back(std::make_pair(var
, loc
)); }
811 // Whether this function needs a closure.
813 needs_closure() const
814 { return !this->closure_fields_
.empty(); }
816 // Return the closure variable, creating it if necessary. This is
817 // passed to the function as a static chain parameter.
821 // Set the closure variable. This is used when building thunks for
822 // functions which call recover.
824 set_closure_var(Named_object
* v
)
826 gcc_assert(this->closure_var_
== NULL
);
827 this->closure_var_
= v
;
830 // Return the variable for a reference to field INDEX in the closure
833 enclosing_var(unsigned int index
)
835 gcc_assert(index
< this->closure_fields_
.size());
836 return closure_fields_
[index
].first
;
839 // Set the type of the closure variable if there is one.
843 // Get the block of statements associated with the function.
846 { return this->block_
; }
848 // Get the location of the start of the function.
851 { return this->location_
; }
853 // Return whether this function is actually a method.
857 // Add a label definition to the function.
859 add_label_definition(const std::string
& label_name
, source_location
);
861 // Add a label reference to a function.
863 add_label_reference(const std::string
& label_name
);
865 // Whether this function calls the predeclared recover function.
867 calls_recover() const
868 { return this->calls_recover_
; }
870 // Record that this function calls the predeclared recover function.
871 // This is set during the lowering pass.
874 { this->calls_recover_
= true; }
876 // Whether this is a recover thunk function.
878 is_recover_thunk() const
879 { return this->is_recover_thunk_
; }
881 // Record that this is a thunk built for a function which calls
884 set_is_recover_thunk()
885 { this->is_recover_thunk_
= true; }
887 // Whether this function already has a recover thunk.
889 has_recover_thunk() const
890 { return this->has_recover_thunk_
; }
892 // Record that this function already has a recover thunk.
894 set_has_recover_thunk()
895 { this->has_recover_thunk_
= true; }
897 // Swap with another function. Used only for the thunk which calls
900 swap_for_recover(Function
*);
902 // Traverse the tree.
906 // Determine types in the function.
910 // Return the function's decl given an identifier.
912 get_or_make_decl(Gogo
*, Named_object
*, tree id
);
914 // Return the function's decl after it has been built.
918 gcc_assert(this->fndecl_
!= NULL
);
919 return this->fndecl_
;
922 // Set the function decl to hold a tree of the function code.
924 build_tree(Gogo
*, Named_object
*);
926 // Get the value to return when not explicitly specified. May also
927 // add statements to execute first to STMT_LIST.
929 return_value(Gogo
*, Named_object
*, source_location
, tree
* stmt_list
) const;
931 // Get a tree for the variable holding the defer stack.
933 defer_stack(source_location
);
935 // Export the function.
937 export_func(Export
*, const std::string
& name
) const;
939 // Export a function with a type.
941 export_func_with_type(Export
*, const std::string
& name
,
942 const Function_type
*);
944 // Import a function.
946 import_func(Import
*, std::string
* pname
, Typed_identifier
** receiver
,
947 Typed_identifier_list
** pparameters
,
948 Typed_identifier_list
** presults
, bool* is_varargs
);
951 // Type for mapping from label names to Label objects.
952 typedef Unordered_map(std::string
, Label
*) Labels
;
955 make_receiver_parm_decl(Gogo
*, Named_object
*, tree
);
958 copy_parm_to_heap(Gogo
*, Named_object
*, tree
);
961 build_defer_wrapper(Gogo
*, Named_object
*, tree
*, tree
*);
963 typedef std::vector
<Named_object
*> Named_results
;
965 typedef std::vector
<std::pair
<Named_object
*,
966 source_location
> > Closure_fields
;
968 // The function's type.
969 Function_type
* type_
;
970 // The enclosing function. This is NULL when there isn't one, which
971 // is the normal case.
972 Function
* enclosing_
;
973 // The named result variables, if any.
974 Named_results
* named_results_
;
975 // If there is a closure, this is the list of variables which appear
976 // in the closure. This is created by the parser, and then resolved
977 // to a real type when we lower parse trees.
978 Closure_fields closure_fields_
;
979 // The closure variable, passed as a parameter using the static
980 // chain parameter. Normally NULL.
981 Named_object
* closure_var_
;
982 // The outer block of statements in the function.
984 // The source location of the start of the function.
985 source_location location_
;
986 // Labels defined or referenced in the function.
988 // The function decl.
990 // A variable holding the defer stack variable. This is NULL unless
991 // we actually need a defer stack.
993 // True if this function calls the predeclared recover function.
995 // True if this a thunk built for a function which calls recover.
996 bool is_recover_thunk_
;
997 // True if this function already has a recover thunk.
998 bool has_recover_thunk_
;
1001 // A function declaration.
1003 class Function_declaration
1006 Function_declaration(Function_type
* fntype
, source_location location
)
1007 : fntype_(fntype
), location_(location
), asm_name_(), fndecl_(NULL
)
1012 { return this->fntype_
; }
1016 { return this->location_
; }
1020 { return this->asm_name_
; }
1022 // Set the assembler name.
1024 set_asm_name(const std::string
& asm_name
)
1025 { this->asm_name_
= asm_name
; }
1027 // Return a decl for the function given an identifier.
1029 get_or_make_decl(Gogo
*, Named_object
*, tree id
);
1031 // Export a function declaration.
1033 export_func(Export
* exp
, const std::string
& name
) const
1034 { Function::export_func_with_type(exp
, name
, this->fntype_
); }
1037 // The type of the function.
1038 Function_type
* fntype_
;
1039 // The location of the declaration.
1040 source_location location_
;
1041 // The assembler name: this is the name to use in references to the
1042 // function. This is normally empty.
1043 std::string asm_name_
;
1044 // The function decl if needed.
1053 Variable(Type
*, Expression
*, bool is_global
, bool is_parameter
,
1054 bool is_receiver
, source_location
);
1056 // Get the type of the variable.
1063 // Return whether the type is defined yet.
1066 { return this->type_
!= NULL
; }
1068 // Get the initial value.
1071 { return this->init_
; }
1073 // Return whether there are any preinit statements.
1075 has_pre_init() const
1076 { return this->preinit_
!= NULL
; }
1078 // Return the preinit statements if any.
1081 { return this->preinit_
; }
1083 // Return whether this is a global variable.
1086 { return this->is_global_
; }
1088 // Return whether this is a function parameter.
1090 is_parameter() const
1091 { return this->is_parameter_
; }
1093 // Return whether this is the receiver parameter of a method.
1096 { return this->is_receiver_
; }
1098 // Change this parameter to be a receiver. This is used when
1099 // creating the thunks created for functions which call recover.
1103 gcc_assert(this->is_parameter_
);
1104 this->is_receiver_
= true;
1107 // Change this parameter to not be a receiver. This is used when
1108 // creating the thunks created for functions which call recover.
1110 set_is_not_receiver()
1112 gcc_assert(this->is_parameter_
);
1113 this->is_receiver_
= false;
1116 // Return whether this is the varargs parameter of a function.
1118 is_varargs_parameter() const
1119 { return this->is_varargs_parameter_
; }
1121 // Whether this variable's address is taken.
1123 is_address_taken() const
1124 { return this->is_address_taken_
; }
1126 // Whether this variable should live in the heap.
1129 { return this->is_address_taken_
&& !this->is_global_
; }
1131 // Get the source location of the variable's declaration.
1134 { return this->location_
; }
1136 // Record that this is the varargs parameter of a function.
1138 set_is_varargs_parameter()
1140 gcc_assert(this->is_parameter_
);
1141 this->is_varargs_parameter_
= true;
1144 // Clear the initial value; used for error handling.
1147 { this->init_
= NULL
; }
1149 // Set the initial value; used for converting shortcuts.
1151 set_init(Expression
* init
)
1152 { this->init_
= init
; }
1154 // Get the preinit block, a block of statements to be run before the
1155 // initialization expression.
1157 preinit_block(Gogo
*);
1159 // Add a statement to be run before the initialization expression.
1160 // This is only used for global variables.
1162 add_preinit_statement(Gogo
*, Statement
*);
1164 // Lower the initialization expression after parsing is complete.
1166 lower_init_expression(Gogo
*, Named_object
*);
1168 // A special case: the init value is used only to determine the
1169 // type. This is used if the variable is defined using := with the
1170 // comma-ok form of a map index or a receive expression. The init
1171 // value is actually the map index expression or receive expression.
1172 // We use this because we may not know the right type at parse time.
1174 set_type_from_init_tuple()
1175 { this->type_from_init_tuple_
= true; }
1177 // Another special case: the init value is used only to determine
1178 // the type. This is used if the variable is defined using := with
1179 // a range clause. The init value is the range expression. The
1180 // type of the variable is the index type of the range expression
1181 // (i.e., the first value returned by a range).
1183 set_type_from_range_index()
1184 { this->type_from_range_index_
= true; }
1186 // Another special case: like set_type_from_range_index, but the
1187 // type is the value type of the range expression (i.e., the second
1188 // value returned by a range).
1190 set_type_from_range_value()
1191 { this->type_from_range_value_
= true; }
1193 // Another special case: the init value is used only to determine
1194 // the type. This is used if the variable is defined using := with
1195 // a case in a select statement. The init value is the channel.
1196 // The type of the variable is the channel's element type.
1198 set_type_from_chan_element()
1199 { this->type_from_chan_element_
= true; }
1201 // After we lower the select statement, we once again set the type
1202 // from the initialization expression.
1204 clear_type_from_chan_element()
1206 gcc_assert(this->type_from_chan_element_
);
1207 this->type_from_chan_element_
= false;
1210 // Note that this variable was created for a type switch clause.
1212 set_is_type_switch_var()
1213 { this->is_type_switch_var_
= true; }
1215 // Traverse the initializer expression.
1217 traverse_expression(Traverse
*);
1219 // Determine the type of the variable if necessary.
1223 // Note that something takes the address of this variable.
1226 { this->is_address_taken_
= true; }
1228 // Get the initial value of the variable as a tree. This may only
1229 // be called if has_pre_init() returns false.
1231 get_init_tree(Gogo
*, Named_object
* function
);
1233 // Return a series of statements which sets the value of the
1234 // variable in DECL. This should only be called is has_pre_init()
1235 // returns true. DECL may be NULL for a sink variable.
1237 get_init_block(Gogo
*, Named_object
* function
, tree decl
);
1239 // Export the variable.
1241 export_var(Export
*, const std::string
& name
) const;
1243 // Import a variable.
1245 import_var(Import
*, std::string
* pname
, Type
** ptype
);
1248 // The type of a tuple.
1250 type_from_tuple(Expression
*, bool) const;
1252 // The type of a range.
1254 type_from_range(Expression
*, bool, bool) const;
1256 // The element type of a channel.
1258 type_from_chan_element(Expression
*, bool) const;
1260 // The variable's type. This may be NULL if the type is set from
1263 // The initial value. This may be NULL if the variable should be
1264 // initialized to the default value for the type.
1266 // Statements to run before the init statement.
1268 // Location of variable definition.
1269 source_location location_
;
1270 // Whether this is a global variable.
1271 bool is_global_
: 1;
1272 // Whether this is a function parameter.
1273 bool is_parameter_
: 1;
1274 // Whether this is the receiver parameter of a method.
1275 bool is_receiver_
: 1;
1276 // Whether this is the varargs parameter of a function.
1277 bool is_varargs_parameter_
: 1;
1278 // Whether something takes the address of this variable.
1279 bool is_address_taken_
: 1;
1280 // True if we have seen this variable in a traversal.
1282 // True if we have lowered the initialization expression.
1283 bool init_is_lowered_
: 1;
1284 // True if init is a tuple used to set the type.
1285 bool type_from_init_tuple_
: 1;
1286 // True if init is a range clause and the type is the index type.
1287 bool type_from_range_index_
: 1;
1288 // True if init is a range clause and the type is the value type.
1289 bool type_from_range_value_
: 1;
1290 // True if init is a channel and the type is the channel's element type.
1291 bool type_from_chan_element_
: 1;
1292 // True if this is a variable created for a type switch case.
1293 bool is_type_switch_var_
: 1;
1296 // A variable which is really the name for a function return value, or
1299 class Result_variable
1302 Result_variable(Type
* type
, Function
* function
, int index
)
1303 : type_(type
), function_(function
), index_(index
),
1304 is_address_taken_(false)
1307 // Get the type of the result variable.
1310 { return this->type_
; }
1312 // Get the function that this is associated with.
1315 { return this->function_
; }
1317 // Index in the list of function results.
1320 { return this->index_
; }
1322 // Whether this variable's address is taken.
1324 is_address_taken() const
1325 { return this->is_address_taken_
; }
1327 // Note that something takes the address of this variable.
1330 { this->is_address_taken_
= true; }
1332 // Whether this variable should live in the heap.
1335 { return this->is_address_taken_
; }
1337 // Set the function. This is used when cloning functions which call
1340 set_function(Function
* function
)
1341 { this->function_
= function
; }
1344 // Type of result variable.
1346 // Function with which this is associated.
1347 Function
* function_
;
1348 // Index in list of results.
1350 // Whether something takes the address of this variable.
1351 bool is_address_taken_
;
1354 // The value we keep for a named constant. This lets us hold a type
1355 // and an expression.
1357 class Named_constant
1360 Named_constant(Type
* type
, Expression
* expr
, int iota_value
,
1361 source_location location
)
1362 : type_(type
), expr_(expr
), iota_value_(iota_value
), location_(location
),
1368 { return this->type_
; }
1372 { return this->expr_
; }
1376 { return this->iota_value_
; }
1380 { return this->location_
; }
1382 // Whether we are lowering.
1385 { return this->lowering_
; }
1387 // Set that we are lowering.
1390 { this->lowering_
= true; }
1392 // We are no longer lowering.
1395 { this->lowering_
= false; }
1397 // Traverse the expression.
1399 traverse_expression(Traverse
*);
1401 // Determine the type of the constant if necessary.
1405 // Indicate that we found and reported an error for this constant.
1409 // Export the constant.
1411 export_const(Export
*, const std::string
& name
) const;
1413 // Import a constant.
1415 import_const(Import
*, std::string
*, Type
**, Expression
**);
1418 // The type of the constant.
1420 // The expression for the constant.
1422 // If the predeclared constant iota is used in EXPR_, this is the
1423 // value it will have. We do this because at parse time we don't
1424 // know whether the name "iota" will refer to the predeclared
1425 // constant or to something else. We put in the right value in when
1428 // The location of the definition.
1429 source_location location_
;
1430 // Whether we are currently lowering this constant.
1434 // A type declaration.
1436 class Type_declaration
1439 Type_declaration(source_location location
)
1440 : location_(location
), in_function_(NULL
), methods_(),
1441 issued_warning_(false)
1444 // Return the location.
1447 { return this->location_
; }
1449 // Return the function in which this type is declared. This will
1450 // return NULL for a type declared in global scope.
1453 { return this->in_function_
; }
1455 // Set the function in which this type is declared.
1457 set_in_function(Named_object
* f
)
1458 { this->in_function_
= f
; }
1460 // Add a method to this type. This is used when methods are defined
1463 add_method(const std::string
& name
, Function
* function
);
1465 // Add a method declaration to this type.
1467 add_method_declaration(const std::string
& name
, Function_type
* type
,
1468 source_location location
);
1470 // Return whether any methods were defined.
1472 has_methods() const;
1474 // Define methods when the real type is known.
1476 define_methods(Named_type
*);
1478 // This is called if we are trying to use this type. It returns
1479 // true if we should issue a warning.
1484 typedef std::vector
<Named_object
*> Methods
;
1486 // The location of the type declaration.
1487 source_location location_
;
1488 // If this type is declared in a function, a pointer back to the
1489 // function in which it is defined.
1490 Named_object
* in_function_
;
1491 // Methods defined before the type is defined.
1493 // True if we have issued a warning about a use of this type
1494 // declaration when it is undefined.
1495 bool issued_warning_
;
1498 // An unknown object. These are created by the parser for forward
1499 // references to names which have not been seen before. In a correct
1500 // program, these will always point to a real definition by the end of
1501 // the parse. Because they point to another Named_object, these may
1502 // only be referenced by Unknown_expression objects.
1507 Unknown_name(source_location location
)
1508 : location_(location
), real_named_object_(NULL
)
1511 // Return the location where this name was first seen.
1514 { return this->location_
; }
1516 // Return the real named object that this points to, or NULL if it
1517 // was never resolved.
1519 real_named_object() const
1520 { return this->real_named_object_
; }
1522 // Set the real named object that this points to.
1524 set_real_named_object(Named_object
* no
);
1527 // The location where this name was first seen.
1528 source_location location_
;
1529 // The real named object when it is known.
1534 // A named object named. This is the result of a declaration. We
1535 // don't use a superclass because they all have to be handled
1543 // An uninitialized Named_object. We should never see this.
1544 NAMED_OBJECT_UNINITIALIZED
,
1545 // An unknown name. This is used for forward references. In a
1546 // correct program, these will all be resolved by the end of the
1548 NAMED_OBJECT_UNKNOWN
,
1553 // A forward type declaration.
1554 NAMED_OBJECT_TYPE_DECLARATION
,
1557 // A result variable in a function.
1558 NAMED_OBJECT_RESULT_VAR
,
1559 // The blank identifier--the special variable named _.
1563 // A forward func declaration.
1564 NAMED_OBJECT_FUNC_DECLARATION
,
1566 NAMED_OBJECT_PACKAGE
1569 // Return the classification.
1571 classification() const
1572 { return this->classification_
; }
1578 { return this->classification_
== NAMED_OBJECT_UNKNOWN
; }
1582 { return this->classification_
== NAMED_OBJECT_CONST
; }
1586 { return this->classification_
== NAMED_OBJECT_TYPE
; }
1589 is_type_declaration() const
1590 { return this->classification_
== NAMED_OBJECT_TYPE_DECLARATION
; }
1594 { return this->classification_
== NAMED_OBJECT_VAR
; }
1597 is_result_variable() const
1598 { return this->classification_
== NAMED_OBJECT_RESULT_VAR
; }
1602 { return this->classification_
== NAMED_OBJECT_SINK
; }
1606 { return this->classification_
== NAMED_OBJECT_FUNC
; }
1609 is_function_declaration() const
1610 { return this->classification_
== NAMED_OBJECT_FUNC_DECLARATION
; }
1614 { return this->classification_
== NAMED_OBJECT_PACKAGE
; }
1618 static Named_object
*
1619 make_unknown_name(const std::string
& name
, source_location
);
1621 static Named_object
*
1622 make_constant(const Typed_identifier
&, const Package
*, Expression
*,
1625 static Named_object
*
1626 make_type(const std::string
&, const Package
*, Type
*, source_location
);
1628 static Named_object
*
1629 make_type_declaration(const std::string
&, const Package
*, source_location
);
1631 static Named_object
*
1632 make_variable(const std::string
&, const Package
*, Variable
*);
1634 static Named_object
*
1635 make_result_variable(const std::string
&, Result_variable
*);
1637 static Named_object
*
1640 static Named_object
*
1641 make_function(const std::string
&, const Package
*, Function
*);
1643 static Named_object
*
1644 make_function_declaration(const std::string
&, const Package
*, Function_type
*,
1647 static Named_object
*
1648 make_package(const std::string
& alias
, Package
* package
);
1655 gcc_assert(this->classification_
== NAMED_OBJECT_UNKNOWN
);
1656 return this->u_
.unknown_value
;
1660 unknown_value() const
1662 gcc_assert(this->classification_
== NAMED_OBJECT_UNKNOWN
);
1663 return this->u_
.unknown_value
;
1669 gcc_assert(this->classification_
== NAMED_OBJECT_CONST
);
1670 return this->u_
.const_value
;
1673 const Named_constant
*
1676 gcc_assert(this->classification_
== NAMED_OBJECT_CONST
);
1677 return this->u_
.const_value
;
1683 gcc_assert(this->classification_
== NAMED_OBJECT_TYPE
);
1684 return this->u_
.type_value
;
1690 gcc_assert(this->classification_
== NAMED_OBJECT_TYPE
);
1691 return this->u_
.type_value
;
1695 type_declaration_value()
1697 gcc_assert(this->classification_
== NAMED_OBJECT_TYPE_DECLARATION
);
1698 return this->u_
.type_declaration
;
1701 const Type_declaration
*
1702 type_declaration_value() const
1704 gcc_assert(this->classification_
== NAMED_OBJECT_TYPE_DECLARATION
);
1705 return this->u_
.type_declaration
;
1711 gcc_assert(this->classification_
== NAMED_OBJECT_VAR
);
1712 return this->u_
.var_value
;
1718 gcc_assert(this->classification_
== NAMED_OBJECT_VAR
);
1719 return this->u_
.var_value
;
1725 gcc_assert(this->classification_
== NAMED_OBJECT_RESULT_VAR
);
1726 return this->u_
.result_var_value
;
1729 const Result_variable
*
1730 result_var_value() const
1732 gcc_assert(this->classification_
== NAMED_OBJECT_RESULT_VAR
);
1733 return this->u_
.result_var_value
;
1739 gcc_assert(this->classification_
== NAMED_OBJECT_FUNC
);
1740 return this->u_
.func_value
;
1746 gcc_assert(this->classification_
== NAMED_OBJECT_FUNC
);
1747 return this->u_
.func_value
;
1750 Function_declaration
*
1751 func_declaration_value()
1753 gcc_assert(this->classification_
== NAMED_OBJECT_FUNC_DECLARATION
);
1754 return this->u_
.func_declaration_value
;
1757 const Function_declaration
*
1758 func_declaration_value() const
1760 gcc_assert(this->classification_
== NAMED_OBJECT_FUNC_DECLARATION
);
1761 return this->u_
.func_declaration_value
;
1767 gcc_assert(this->classification_
== NAMED_OBJECT_PACKAGE
);
1768 return this->u_
.package_value
;
1772 package_value() const
1774 gcc_assert(this->classification_
== NAMED_OBJECT_PACKAGE
);
1775 return this->u_
.package_value
;
1780 { return this->name_
; }
1782 // Return the name to use in an error message. The difference is
1783 // that if this Named_object is defined in a different package, this
1784 // will return PACKAGE.NAME.
1786 message_name() const;
1790 { return this->package_
; }
1792 // Resolve an unknown value if possible. This returns the same
1793 // Named_object or a new one.
1797 Named_object
* ret
= this;
1798 if (this->is_unknown())
1800 Named_object
* r
= this->unknown_value()->real_named_object();
1810 const Named_object
* ret
= this;
1811 if (this->is_unknown())
1813 const Named_object
* r
= this->unknown_value()->real_named_object();
1820 // The location where this object was defined or referenced.
1824 // Return a tree for the external identifier for this object.
1828 // Return a tree representing this object.
1830 get_tree(Gogo
*, Named_object
* function
);
1832 // Define a type declaration.
1834 set_type_value(Named_type
*);
1836 // Define a function declaration.
1838 set_function_value(Function
*);
1840 // Declare an unknown name as a type declaration.
1844 // Export this object.
1846 export_named_object(Export
*) const;
1849 Named_object(const std::string
&, const Package
*, Classification
);
1851 // The name of the object.
1853 // The package that this object is in. This is NULL if it is in the
1854 // file we are compiling.
1855 const Package
* package_
;
1856 // The type of object this is.
1857 Classification classification_
;
1861 Unknown_name
* unknown_value
;
1862 Named_constant
* const_value
;
1863 Named_type
* type_value
;
1864 Type_declaration
* type_declaration
;
1865 Variable
* var_value
;
1866 Result_variable
* result_var_value
;
1867 Function
* func_value
;
1868 Function_declaration
* func_declaration_value
;
1869 Package
* package_value
;
1871 // The DECL tree for this object if we have already converted it.
1875 // A binding contour. This binds names to objects.
1880 // Type for mapping from names to objects.
1881 typedef Unordered_map(std::string
, Named_object
*) Contour
;
1883 Bindings(Bindings
* enclosing
);
1885 // Add an unknown name.
1887 add_unknown_name(const std::string
& name
, source_location location
)
1889 return this->add_named_object(Named_object::make_unknown_name(name
,
1895 add_constant(const Typed_identifier
& tid
, const Package
* package
,
1896 Expression
* expr
, int iota_value
)
1898 return this->add_named_object(Named_object::make_constant(tid
, package
,
1905 add_type(const std::string
& name
, const Package
* package
, Type
* type
,
1906 source_location location
)
1908 return this->add_named_object(Named_object::make_type(name
, package
, type
,
1912 // Add a named type. This is used for builtin types, and to add an
1913 // imported type to the global scope.
1915 add_named_type(Named_type
* named_type
);
1917 // Add a type declaration.
1919 add_type_declaration(const std::string
& name
, const Package
* package
,
1920 source_location location
)
1922 Named_object
* no
= Named_object::make_type_declaration(name
, package
,
1924 return this->add_named_object(no
);
1929 add_variable(const std::string
& name
, const Package
* package
,
1932 return this->add_named_object(Named_object::make_variable(name
, package
,
1936 // Add a result variable.
1938 add_result_variable(const std::string
& name
, Result_variable
* result
)
1940 return this->add_named_object(Named_object::make_result_variable(name
,
1946 add_function(const std::string
& name
, const Package
*, Function
* function
);
1948 // Add a function declaration.
1950 add_function_declaration(const std::string
& name
, const Package
* package
,
1951 Function_type
* type
, source_location location
);
1953 // Add a package. The location is the location of the import
1956 add_package(const std::string
& alias
, Package
* package
)
1958 Named_object
* no
= Named_object::make_package(alias
, package
);
1959 return this->add_named_object(no
);
1962 // Define a type which was already declared.
1964 define_type(Named_object
*, Named_type
*);
1966 // Add a method to the list of objects. This is not added to the
1969 add_method(Named_object
*);
1971 // Add a named object to this binding.
1973 add_named_object(Named_object
* no
)
1974 { return this->add_named_object_to_contour(&this->bindings_
, no
); }
1976 // Clear all names in file scope from the bindings.
1980 // Look up a name in this binding contour and in any enclosing
1981 // binding contours. This returns NULL if the name is not found.
1983 lookup(const std::string
&) const;
1985 // Look up a name in this binding contour without looking in any
1986 // enclosing binding contours. Returns NULL if the name is not found.
1988 lookup_local(const std::string
&) const;
1992 remove_binding(Named_object
*);
1994 // Traverse the tree. See the Traverse class.
1996 traverse(Traverse
*, bool is_global
);
1998 // Iterate over definitions. This does not include things which
1999 // were only declared.
2001 typedef std::vector
<Named_object
*>::const_iterator
2002 const_definitions_iterator
;
2004 const_definitions_iterator
2005 begin_definitions() const
2006 { return this->named_objects_
.begin(); }
2008 const_definitions_iterator
2009 end_definitions() const
2010 { return this->named_objects_
.end(); }
2012 // Return the number of definitions.
2014 size_definitions() const
2015 { return this->named_objects_
.size(); }
2017 // Return whether there are no definitions.
2019 empty_definitions() const
2020 { return this->named_objects_
.empty(); }
2022 // Iterate over declarations. This is everything that has been
2023 // declared, which includes everything which has been defined.
2025 typedef Contour::const_iterator const_declarations_iterator
;
2027 const_declarations_iterator
2028 begin_declarations() const
2029 { return this->bindings_
.begin(); }
2031 const_declarations_iterator
2032 end_declarations() const
2033 { return this->bindings_
.end(); }
2035 // Return the number of declarations.
2037 size_declarations() const
2038 { return this->bindings_
.size(); }
2040 // Return whether there are no declarations.
2042 empty_declarations() const
2043 { return this->bindings_
.empty(); }
2045 // Return the first declaration.
2048 { return this->bindings_
.empty() ? NULL
: this->bindings_
.begin()->second
; }
2052 add_named_object_to_contour(Contour
*, Named_object
*);
2055 new_definition(Named_object
*, Named_object
*);
2057 // Enclosing bindings.
2058 Bindings
* enclosing_
;
2059 // The list of objects.
2060 std::vector
<Named_object
*> named_objects_
;
2061 // The mapping from names to objects.
2070 Label(const std::string
& name
)
2071 : name_(name
), location_(0), decl_(NULL
)
2074 // Return the label's name.
2077 { return this->name_
; }
2079 // Return whether the label has been defined.
2082 { return this->location_
!= 0; }
2084 // Return the location of the definition.
2087 { return this->location_
; }
2089 // Define the label at LOCATION.
2091 define(source_location location
)
2093 gcc_assert(this->location_
== 0);
2094 this->location_
= location
;
2097 // Return the LABEL_DECL for this decl.
2101 // Return an expression for the address of this label.
2103 get_addr(source_location location
);
2106 // The name of the label.
2108 // The location of the definition. This is 0 if the label has not
2109 // yet been defined.
2110 source_location location_
;
2115 // An unnamed label. These are used when lowering loops.
2120 Unnamed_label(source_location location
)
2121 : location_(location
), decl_(NULL
)
2124 // Get the location where the label is defined.
2127 { return this->location_
; }
2129 // Set the location where the label is defined.
2131 set_location(source_location location
)
2132 { this->location_
= location
; }
2134 // Return a statement which defines this label.
2138 // Return a goto to this label from LOCATION.
2140 get_goto(source_location location
);
2143 // Return the LABEL_DECL to use with GOTO_EXPR.
2147 // The location where the label is defined.
2148 source_location location_
;
2153 // An imported package.
2158 Package(const std::string
& name
, const std::string
& unique_prefix
,
2159 source_location location
);
2161 // The real name of this package. This may be different from the
2162 // name in the associated Named_object if the import statement used
2166 { return this->name_
; }
2168 // Return the location of the import statement.
2171 { return this->location_
; }
2173 // Get the unique prefix used for all symbols exported from this
2176 unique_prefix() const
2178 gcc_assert(!this->unique_prefix_
.empty());
2179 return this->unique_prefix_
;
2182 // The priority of this package. The init function of packages with
2183 // lower priority must be run before the init function of packages
2184 // with higher priority.
2187 { return this->priority_
; }
2189 // Set the priority.
2191 set_priority(int priority
);
2193 // Return the bindings.
2196 { return this->bindings_
; }
2198 // Whether some symbol from the package was used.
2201 { return this->used_
; }
2203 // Note that some symbol from this package was used.
2206 { this->used_
= true; }
2208 // Clear the used field for the next file.
2211 { this->used_
= false; }
2213 // Whether this package was imported in the current file.
2216 { return this->is_imported_
; }
2218 // Note that this package was imported in the current file.
2221 { this->is_imported_
= true; }
2223 // Clear the imported field for the next file.
2226 { this->is_imported_
= false; }
2228 // Whether this package was imported with a name of "_".
2230 uses_sink_alias() const
2231 { return this->uses_sink_alias_
; }
2233 // Note that this package was imported with a name of "_".
2235 set_uses_sink_alias()
2236 { this->uses_sink_alias_
= true; }
2238 // Clear the sink alias field for the next file.
2240 clear_uses_sink_alias()
2241 { this->uses_sink_alias_
= false; }
2243 // Look up a name in the package. Returns NULL if the name is not
2246 lookup(const std::string
& name
) const
2247 { return this->bindings_
->lookup(name
); }
2249 // Set the location of the package. This is used if it is seen in a
2250 // different import before it is really imported.
2252 set_location(source_location location
)
2253 { this->location_
= location
; }
2255 // Add a constant to the package.
2257 add_constant(const Typed_identifier
& tid
, Expression
* expr
)
2258 { return this->bindings_
->add_constant(tid
, this, expr
, 0); }
2260 // Add a type to the package.
2262 add_type(const std::string
& name
, Type
* type
, source_location location
)
2263 { return this->bindings_
->add_type(name
, this, type
, location
); }
2265 // Add a type declaration to the package.
2267 add_type_declaration(const std::string
& name
, source_location location
)
2268 { return this->bindings_
->add_type_declaration(name
, this, location
); }
2270 // Add a variable to the package.
2272 add_variable(const std::string
& name
, Variable
* variable
)
2273 { return this->bindings_
->add_variable(name
, this, variable
); }
2275 // Add a function declaration to the package.
2277 add_function_declaration(const std::string
& name
, Function_type
* type
,
2278 source_location loc
)
2279 { return this->bindings_
->add_function_declaration(name
, this, type
, loc
); }
2281 // Determine types of constants.
2286 // The real name of this package.
2288 // The unique prefix for all exported global symbols.
2289 std::string unique_prefix_
;
2290 // The names in this package.
2291 Bindings
* bindings_
;
2292 // The priority of this package. A package has a priority higher
2293 // than the priority of all of the packages that it imports. This
2294 // is used to run init functions in the right order.
2296 // The location of the import statement.
2297 source_location location_
;
2298 // True if some name from this package was used. This is mutable
2299 // because we can use a package even if we have a const pointer to
2302 // True if this package was imported in the current file.
2304 // True if this package was imported with a name of "_".
2305 bool uses_sink_alias_
;
2308 // Return codes for the traversal functions. This is not an enum
2309 // because we want to be able to declare traversal functions in other
2310 // header files without including this one.
2312 // Continue traversal as usual.
2313 const int TRAVERSE_CONTINUE
= -1;
2316 const int TRAVERSE_EXIT
= 0;
2318 // Continue traversal, but skip components of the current object.
2319 // E.g., if this is returned by Traverse::statement, we do not
2320 // traverse the expressions in the statement even if
2321 // traverse_expressions is set in the traverse_mask.
2322 const int TRAVERSE_SKIP_COMPONENTS
= 1;
2324 // This class is used when traversing the parse tree. The caller uses
2325 // a subclass which overrides functions as desired.
2330 // These bitmasks say what to traverse.
2331 static const unsigned int traverse_variables
= 0x1;
2332 static const unsigned int traverse_constants
= 0x2;
2333 static const unsigned int traverse_functions
= 0x4;
2334 static const unsigned int traverse_blocks
= 0x8;
2335 static const unsigned int traverse_statements
= 0x10;
2336 static const unsigned int traverse_expressions
= 0x20;
2337 static const unsigned int traverse_types
= 0x40;
2339 Traverse(unsigned int traverse_mask
)
2340 : traverse_mask_(traverse_mask
), types_seen_(NULL
), expressions_seen_(NULL
)
2343 virtual ~Traverse();
2345 // The bitmask of what to traverse.
2347 traverse_mask() const
2348 { return this->traverse_mask_
; }
2350 // Record that we are going to traverse a type. This returns true
2351 // if the type has already been seen in this traversal. This is
2352 // required because types, unlike expressions, can form a circular
2355 remember_type(const Type
*);
2357 // Record that we are going to see an expression. This returns true
2358 // if the expression has already been seen in this traversal. This
2359 // is only needed for cases where multiple expressions can point to
2362 remember_expression(const Expression
*);
2364 // These functions return one of the TRAVERSE codes defined above.
2366 // If traverse_variables is set in the mask, this is called for
2367 // every variable in the tree.
2369 variable(Named_object
*);
2371 // If traverse_constants is set in the mask, this is called for
2372 // every named constant in the tree. The bool parameter is true for
2373 // a global constant.
2375 constant(Named_object
*, bool);
2377 // If traverse_functions is set in the mask, this is called for
2378 // every function in the tree.
2380 function(Named_object
*);
2382 // If traverse_blocks is set in the mask, this is called for every
2383 // block in the tree.
2387 // If traverse_statements is set in the mask, this is called for
2388 // every statement in the tree.
2390 statement(Block
*, size_t* index
, Statement
*);
2392 // If traverse_expressions is set in the mask, this is called for
2393 // every expression in the tree.
2395 expression(Expression
**);
2397 // If traverse_types is set in the mask, this is called for every
2398 // type in the tree.
2403 typedef Unordered_set_hash(const Type
*, Type_hash_identical
,
2404 Type_identical
) Types_seen
;
2406 typedef Unordered_set(const Expression
*) Expressions_seen
;
2408 // Bitmask of what sort of objects to traverse.
2409 unsigned int traverse_mask_
;
2410 // Types which have been seen in this traversal.
2411 Types_seen
* types_seen_
;
2412 // Expressions which have been seen in this traversal.
2413 Expressions_seen
* expressions_seen_
;
2416 // When translating the gogo IR into trees, this is the context we
2417 // pass down the blocks and statements.
2419 class Translate_context
2422 Translate_context(Gogo
* gogo
, Named_object
* function
, Block
* block
,
2424 : gogo_(gogo
), function_(function
), block_(block
), block_tree_(block_tree
),
2432 { return this->gogo_
; }
2436 { return this->function_
; }
2440 { return this->block_
; }
2444 { return this->block_tree_
; }
2448 { return this->is_const_
; }
2450 // Make a constant context.
2453 { this->is_const_
= true; }
2456 // The IR for the entire compilation unit.
2458 // The function we are currently translating.
2459 Named_object
* function_
;
2460 // The block we are currently translating.
2462 // The BLOCK node for the current block.
2464 // Whether this is being evaluated in a constant context. This is
2465 // used for type descriptor initializers.
2469 // Runtime error codes. These must match the values in
2470 // libgo/runtime/go-runtime-error.c.
2472 // Slice index out of bounds: negative or larger than the length of
2474 static const int RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS
= 0;
2476 // Array index out of bounds.
2477 static const int RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS
= 1;
2479 // String index out of bounds.
2480 static const int RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS
= 2;
2482 // Slice slice out of bounds: negative or larger than the length of
2483 // the slice or high bound less than low bound.
2484 static const int RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS
= 3;
2486 // Array slice out of bounds.
2487 static const int RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS
= 4;
2489 // String slice out of bounds.
2490 static const int RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS
= 5;
2492 // Dereference of nil pointer. This is used when there is a
2493 // dereference of a pointer to a very large struct or array, to ensure
2494 // that a gigantic array is not used a proxy to access random memory
2496 static const int RUNTIME_ERROR_NIL_DEREFERENCE
= 6;
2498 // Slice length or capacity out of bounds in make: negative or
2499 // overflow or length greater than capacity.
2500 static const int RUNTIME_ERROR_MAKE_SLICE_OUT_OF_BOUNDS
= 7;
2502 // Map capacity out of bounds in make: negative or overflow.
2503 static const int RUNTIME_ERROR_MAKE_MAP_OUT_OF_BOUNDS
= 8;
2505 // Channel capacity out of bounds in make: negative or overflow.
2506 static const int RUNTIME_ERROR_MAKE_CHAN_OUT_OF_BOUNDS
= 9;
2508 // This is used by some of the langhooks.
2509 extern Gogo
* go_get_gogo();
2511 // Whether we have seen any errors. FIXME: Replace with a backend
2513 extern bool saw_errors();
2515 #endif // !defined(GO_GOGO_H)