1 // gogo.cc -- Go frontend parsed representation.
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.
13 #include "statements.h"
14 #include "expressions.h"
24 Gogo::Gogo(Backend
* backend
, Linemap
* linemap
, int int_type_size
,
30 globals_(new Bindings(NULL
)),
32 imported_unsafe_(false),
39 unique_prefix_specified_(false),
42 specific_type_functions_(),
43 specific_type_functions_are_written_(false),
44 named_types_are_converted_(false)
46 const Location loc
= Linemap::predeclared_location();
48 Named_type
* uint8_type
= Type::make_integer_type("uint8", true, 8,
49 RUNTIME_TYPE_KIND_UINT8
);
50 this->add_named_type(uint8_type
);
51 this->add_named_type(Type::make_integer_type("uint16", true, 16,
52 RUNTIME_TYPE_KIND_UINT16
));
53 this->add_named_type(Type::make_integer_type("uint32", true, 32,
54 RUNTIME_TYPE_KIND_UINT32
));
55 this->add_named_type(Type::make_integer_type("uint64", true, 64,
56 RUNTIME_TYPE_KIND_UINT64
));
58 this->add_named_type(Type::make_integer_type("int8", false, 8,
59 RUNTIME_TYPE_KIND_INT8
));
60 this->add_named_type(Type::make_integer_type("int16", false, 16,
61 RUNTIME_TYPE_KIND_INT16
));
62 Named_type
* int32_type
= Type::make_integer_type("int32", false, 32,
63 RUNTIME_TYPE_KIND_INT32
);
64 this->add_named_type(int32_type
);
65 this->add_named_type(Type::make_integer_type("int64", false, 64,
66 RUNTIME_TYPE_KIND_INT64
));
68 this->add_named_type(Type::make_float_type("float32", 32,
69 RUNTIME_TYPE_KIND_FLOAT32
));
70 this->add_named_type(Type::make_float_type("float64", 64,
71 RUNTIME_TYPE_KIND_FLOAT64
));
73 this->add_named_type(Type::make_complex_type("complex64", 64,
74 RUNTIME_TYPE_KIND_COMPLEX64
));
75 this->add_named_type(Type::make_complex_type("complex128", 128,
76 RUNTIME_TYPE_KIND_COMPLEX128
));
78 if (int_type_size
< 32)
80 this->add_named_type(Type::make_integer_type("uint", true,
82 RUNTIME_TYPE_KIND_UINT
));
83 Named_type
* int_type
= Type::make_integer_type("int", false, int_type_size
,
84 RUNTIME_TYPE_KIND_INT
);
85 this->add_named_type(int_type
);
87 this->add_named_type(Type::make_integer_type("uintptr", true,
89 RUNTIME_TYPE_KIND_UINTPTR
));
91 // "byte" is an alias for "uint8".
92 uint8_type
->integer_type()->set_is_byte();
93 Named_object
* byte_type
= Named_object::make_type("byte", NULL
, uint8_type
,
95 this->add_named_type(byte_type
->type_value());
97 // "rune" is an alias for "int32".
98 int32_type
->integer_type()->set_is_rune();
99 Named_object
* rune_type
= Named_object::make_type("rune", NULL
, int32_type
,
101 this->add_named_type(rune_type
->type_value());
103 this->add_named_type(Type::make_named_bool_type());
105 this->add_named_type(Type::make_named_string_type());
107 // "error" is interface { Error() string }.
109 Typed_identifier_list
*methods
= new Typed_identifier_list
;
110 Typed_identifier_list
*results
= new Typed_identifier_list
;
111 results
->push_back(Typed_identifier("", Type::lookup_string_type(), loc
));
112 Type
*method_type
= Type::make_function_type(NULL
, NULL
, results
, loc
);
113 methods
->push_back(Typed_identifier("Error", method_type
, loc
));
114 Interface_type
*error_iface
= Type::make_interface_type(methods
, loc
);
115 error_iface
->finalize_methods();
116 Named_type
*error_type
= Named_object::make_type("error", NULL
, error_iface
, loc
)->type_value();
117 this->add_named_type(error_type
);
120 this->globals_
->add_constant(Typed_identifier("true",
121 Type::make_boolean_type(),
124 Expression::make_boolean(true, loc
),
126 this->globals_
->add_constant(Typed_identifier("false",
127 Type::make_boolean_type(),
130 Expression::make_boolean(false, loc
),
133 this->globals_
->add_constant(Typed_identifier("nil", Type::make_nil_type(),
136 Expression::make_nil(loc
),
139 Type
* abstract_int_type
= Type::make_abstract_integer_type();
140 this->globals_
->add_constant(Typed_identifier("iota", abstract_int_type
,
143 Expression::make_iota(),
146 Function_type
* new_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
147 new_type
->set_is_varargs();
148 new_type
->set_is_builtin();
149 this->globals_
->add_function_declaration("new", NULL
, new_type
, loc
);
151 Function_type
* make_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
152 make_type
->set_is_varargs();
153 make_type
->set_is_builtin();
154 this->globals_
->add_function_declaration("make", NULL
, make_type
, loc
);
156 Typed_identifier_list
* len_result
= new Typed_identifier_list();
157 len_result
->push_back(Typed_identifier("", int_type
, loc
));
158 Function_type
* len_type
= Type::make_function_type(NULL
, NULL
, len_result
,
160 len_type
->set_is_builtin();
161 this->globals_
->add_function_declaration("len", NULL
, len_type
, loc
);
163 Typed_identifier_list
* cap_result
= new Typed_identifier_list();
164 cap_result
->push_back(Typed_identifier("", int_type
, loc
));
165 Function_type
* cap_type
= Type::make_function_type(NULL
, NULL
, len_result
,
167 cap_type
->set_is_builtin();
168 this->globals_
->add_function_declaration("cap", NULL
, cap_type
, loc
);
170 Function_type
* print_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
171 print_type
->set_is_varargs();
172 print_type
->set_is_builtin();
173 this->globals_
->add_function_declaration("print", NULL
, print_type
, loc
);
175 print_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
176 print_type
->set_is_varargs();
177 print_type
->set_is_builtin();
178 this->globals_
->add_function_declaration("println", NULL
, print_type
, loc
);
180 Type
*empty
= Type::make_empty_interface_type(loc
);
181 Typed_identifier_list
* panic_parms
= new Typed_identifier_list();
182 panic_parms
->push_back(Typed_identifier("e", empty
, loc
));
183 Function_type
*panic_type
= Type::make_function_type(NULL
, panic_parms
,
185 panic_type
->set_is_builtin();
186 this->globals_
->add_function_declaration("panic", NULL
, panic_type
, loc
);
188 Typed_identifier_list
* recover_result
= new Typed_identifier_list();
189 recover_result
->push_back(Typed_identifier("", empty
, loc
));
190 Function_type
* recover_type
= Type::make_function_type(NULL
, NULL
,
193 recover_type
->set_is_builtin();
194 this->globals_
->add_function_declaration("recover", NULL
, recover_type
, loc
);
196 Function_type
* close_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
197 close_type
->set_is_varargs();
198 close_type
->set_is_builtin();
199 this->globals_
->add_function_declaration("close", NULL
, close_type
, loc
);
201 Typed_identifier_list
* copy_result
= new Typed_identifier_list();
202 copy_result
->push_back(Typed_identifier("", int_type
, loc
));
203 Function_type
* copy_type
= Type::make_function_type(NULL
, NULL
,
205 copy_type
->set_is_varargs();
206 copy_type
->set_is_builtin();
207 this->globals_
->add_function_declaration("copy", NULL
, copy_type
, loc
);
209 Function_type
* append_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
210 append_type
->set_is_varargs();
211 append_type
->set_is_builtin();
212 this->globals_
->add_function_declaration("append", NULL
, append_type
, loc
);
214 Function_type
* complex_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
215 complex_type
->set_is_varargs();
216 complex_type
->set_is_builtin();
217 this->globals_
->add_function_declaration("complex", NULL
, complex_type
, loc
);
219 Function_type
* real_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
220 real_type
->set_is_varargs();
221 real_type
->set_is_builtin();
222 this->globals_
->add_function_declaration("real", NULL
, real_type
, loc
);
224 Function_type
* imag_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
225 imag_type
->set_is_varargs();
226 imag_type
->set_is_builtin();
227 this->globals_
->add_function_declaration("imag", NULL
, imag_type
, loc
);
229 Function_type
* delete_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
230 delete_type
->set_is_varargs();
231 delete_type
->set_is_builtin();
232 this->globals_
->add_function_declaration("delete", NULL
, delete_type
, loc
);
235 // Munge name for use in an error message.
238 Gogo::message_name(const std::string
& name
)
240 return go_localize_identifier(Gogo::unpack_hidden_name(name
).c_str());
243 // Get the package name.
246 Gogo::package_name() const
248 go_assert(this->package_
!= NULL
);
249 return this->package_
->name();
252 // Set the package name.
255 Gogo::set_package_name(const std::string
& package_name
,
258 if (this->package_
!= NULL
&& this->package_
->name() != package_name
)
260 error_at(location
, "expected package %<%s%>",
261 Gogo::message_name(this->package_
->name()).c_str());
265 // If the user did not specify a unique prefix, we always use "go".
266 // This in effect requires that the package name be unique.
267 if (this->unique_prefix_
.empty())
268 this->unique_prefix_
= "go";
270 this->package_
= this->register_package(package_name
, this->unique_prefix_
,
273 // We used to permit people to qualify symbols with the current
274 // package name (e.g., P.x), but we no longer do.
275 // this->globals_->add_package(package_name, this->package_);
277 if (this->is_main_package())
279 // Declare "main" as a function which takes no parameters and
281 Location uloc
= Linemap::unknown_location();
282 this->declare_function("main",
283 Type::make_function_type (NULL
, NULL
, NULL
, uloc
),
288 // Return whether this is the "main" package. This is not true if
289 // -fgo-prefix was used.
292 Gogo::is_main_package() const
294 return this->package_name() == "main" && !this->unique_prefix_specified_
;
300 Gogo::import_package(const std::string
& filename
,
301 const std::string
& local_name
,
302 bool is_local_name_exported
,
305 if (filename
== "unsafe")
307 this->import_unsafe(local_name
, is_local_name_exported
, location
);
311 Imports::const_iterator p
= this->imports_
.find(filename
);
312 if (p
!= this->imports_
.end())
314 Package
* package
= p
->second
;
315 package
->set_location(location
);
316 package
->set_is_imported();
317 std::string ln
= local_name
;
318 bool is_ln_exported
= is_local_name_exported
;
321 ln
= package
->name();
322 is_ln_exported
= Lex::is_exported_name(ln
);
326 Bindings
* bindings
= package
->bindings();
327 for (Bindings::const_declarations_iterator p
=
328 bindings
->begin_declarations();
329 p
!= bindings
->end_declarations();
331 this->add_named_object(p
->second
);
334 package
->set_uses_sink_alias();
337 ln
= this->pack_hidden_name(ln
, is_ln_exported
);
338 this->package_
->bindings()->add_package(ln
, package
);
343 Import::Stream
* stream
= Import::open_package(filename
, location
);
346 error_at(location
, "import file %qs not found", filename
.c_str());
350 Import
imp(stream
, location
);
351 imp
.register_builtin_types(this);
352 Package
* package
= imp
.import(this, local_name
, is_local_name_exported
);
355 if (package
->name() == this->package_name()
356 && package
->unique_prefix() == this->unique_prefix())
358 ("imported package uses same package name and prefix "
359 "as package being compiled (see -fgo-prefix option)"));
361 this->imports_
.insert(std::make_pair(filename
, package
));
362 package
->set_is_imported();
368 // Add an import control function for an imported package to the list.
371 Gogo::add_import_init_fn(const std::string
& package_name
,
372 const std::string
& init_name
, int prio
)
374 for (std::set
<Import_init
>::const_iterator p
=
375 this->imported_init_fns_
.begin();
376 p
!= this->imported_init_fns_
.end();
379 if (p
->init_name() == init_name
380 && (p
->package_name() != package_name
|| p
->priority() != prio
))
382 error("duplicate package initialization name %qs",
383 Gogo::message_name(init_name
).c_str());
384 inform(UNKNOWN_LOCATION
, "used by package %qs at priority %d",
385 Gogo::message_name(p
->package_name()).c_str(),
387 inform(UNKNOWN_LOCATION
, " and by package %qs at priority %d",
388 Gogo::message_name(package_name
).c_str(), prio
);
393 this->imported_init_fns_
.insert(Import_init(package_name
, init_name
,
397 // Return whether we are at the global binding level.
400 Gogo::in_global_scope() const
402 return this->functions_
.empty();
405 // Return the current binding contour.
408 Gogo::current_bindings()
410 if (!this->functions_
.empty())
411 return this->functions_
.back().blocks
.back()->bindings();
412 else if (this->package_
!= NULL
)
413 return this->package_
->bindings();
415 return this->globals_
;
419 Gogo::current_bindings() const
421 if (!this->functions_
.empty())
422 return this->functions_
.back().blocks
.back()->bindings();
423 else if (this->package_
!= NULL
)
424 return this->package_
->bindings();
426 return this->globals_
;
429 // Return the current block.
432 Gogo::current_block()
434 if (this->functions_
.empty())
437 return this->functions_
.back().blocks
.back();
440 // Look up a name in the current binding contour. If PFUNCTION is not
441 // NULL, set it to the function in which the name is defined, or NULL
442 // if the name is defined in global scope.
445 Gogo::lookup(const std::string
& name
, Named_object
** pfunction
) const
447 if (pfunction
!= NULL
)
450 if (Gogo::is_sink_name(name
))
451 return Named_object::make_sink();
453 for (Open_functions::const_reverse_iterator p
= this->functions_
.rbegin();
454 p
!= this->functions_
.rend();
457 Named_object
* ret
= p
->blocks
.back()->bindings()->lookup(name
);
460 if (pfunction
!= NULL
)
461 *pfunction
= p
->function
;
466 if (this->package_
!= NULL
)
468 Named_object
* ret
= this->package_
->bindings()->lookup(name
);
471 if (ret
->package() != NULL
)
472 ret
->package()->set_used();
477 // We do not look in the global namespace. If we did, the global
478 // namespace would effectively hide names which were defined in
479 // package scope which we have not yet seen. Instead,
480 // define_global_names is called after parsing is over to connect
481 // undefined names at package scope with names defined at global
487 // Look up a name in the current block, without searching enclosing
491 Gogo::lookup_in_block(const std::string
& name
) const
493 go_assert(!this->functions_
.empty());
494 go_assert(!this->functions_
.back().blocks
.empty());
495 return this->functions_
.back().blocks
.back()->bindings()->lookup_local(name
);
498 // Look up a name in the global namespace.
501 Gogo::lookup_global(const char* name
) const
503 return this->globals_
->lookup(name
);
506 // Add an imported package.
509 Gogo::add_imported_package(const std::string
& real_name
,
510 const std::string
& alias_arg
,
511 bool is_alias_exported
,
512 const std::string
& unique_prefix
,
514 bool* padd_to_globals
)
516 // FIXME: Now that we compile packages as a whole, should we permit
517 // importing the current package?
518 if (this->package_name() == real_name
519 && this->unique_prefix() == unique_prefix
)
521 *padd_to_globals
= false;
522 if (!alias_arg
.empty() && alias_arg
!= ".")
524 std::string alias
= this->pack_hidden_name(alias_arg
,
526 this->package_
->bindings()->add_package(alias
, this->package_
);
528 return this->package_
;
530 else if (alias_arg
== ".")
532 *padd_to_globals
= true;
533 return this->register_package(real_name
, unique_prefix
, location
);
535 else if (alias_arg
== "_")
537 Package
* ret
= this->register_package(real_name
, unique_prefix
, location
);
538 ret
->set_uses_sink_alias();
543 *padd_to_globals
= false;
544 std::string alias
= alias_arg
;
548 is_alias_exported
= Lex::is_exported_name(alias
);
550 alias
= this->pack_hidden_name(alias
, is_alias_exported
);
551 Named_object
* no
= this->add_package(real_name
, alias
, unique_prefix
,
553 if (!no
->is_package())
555 return no
->package_value();
562 Gogo::add_package(const std::string
& real_name
, const std::string
& alias
,
563 const std::string
& unique_prefix
, Location location
)
565 go_assert(this->in_global_scope());
567 // Register the package. Note that we might have already seen it in
568 // an earlier import.
569 Package
* package
= this->register_package(real_name
, unique_prefix
, location
);
571 return this->package_
->bindings()->add_package(alias
, package
);
574 // Register a package. This package may or may not be imported. This
575 // returns the Package structure for the package, creating if it
579 Gogo::register_package(const std::string
& package_name
,
580 const std::string
& unique_prefix
,
583 go_assert(!unique_prefix
.empty() && !package_name
.empty());
584 std::string name
= unique_prefix
+ '.' + package_name
;
585 Package
* package
= NULL
;
586 std::pair
<Packages::iterator
, bool> ins
=
587 this->packages_
.insert(std::make_pair(name
, package
));
590 // We have seen this package name before.
591 package
= ins
.first
->second
;
592 go_assert(package
!= NULL
);
593 go_assert(package
->name() == package_name
594 && package
->unique_prefix() == unique_prefix
);
595 if (Linemap::is_unknown_location(package
->location()))
596 package
->set_location(location
);
600 // First time we have seen this package name.
601 package
= new Package(package_name
, unique_prefix
, location
);
602 go_assert(ins
.first
->second
== NULL
);
603 ins
.first
->second
= package
;
609 // Start compiling a function.
612 Gogo::start_function(const std::string
& name
, Function_type
* type
,
613 bool add_method_to_type
, Location location
)
615 bool at_top_level
= this->functions_
.empty();
617 Block
* block
= new Block(NULL
, location
);
619 Function
* enclosing
= (at_top_level
621 : this->functions_
.back().function
->func_value());
623 Function
* function
= new Function(type
, enclosing
, block
, location
);
625 if (type
->is_method())
627 const Typed_identifier
* receiver
= type
->receiver();
628 Variable
* this_param
= new Variable(receiver
->type(), NULL
, false,
629 true, true, location
);
630 std::string rname
= receiver
->name();
633 // We need to give receivers a name since they wind up in
634 // DECL_ARGUMENTS. FIXME.
635 static unsigned int count
;
637 snprintf(buf
, sizeof buf
, "r.%u", count
);
641 if (!Gogo::is_sink_name(rname
))
642 block
->bindings()->add_variable(rname
, NULL
, this_param
);
645 const Typed_identifier_list
* parameters
= type
->parameters();
646 bool is_varargs
= type
->is_varargs();
647 if (parameters
!= NULL
)
649 for (Typed_identifier_list::const_iterator p
= parameters
->begin();
650 p
!= parameters
->end();
653 Variable
* param
= new Variable(p
->type(), NULL
, false, true, false,
655 if (is_varargs
&& p
+ 1 == parameters
->end())
656 param
->set_is_varargs_parameter();
658 std::string pname
= p
->name();
659 if (pname
.empty() || Gogo::is_sink_name(pname
))
661 // We need to give parameters a name since they wind up
662 // in DECL_ARGUMENTS. FIXME.
663 static unsigned int count
;
665 snprintf(buf
, sizeof buf
, "p.%u", count
);
669 block
->bindings()->add_variable(pname
, NULL
, param
);
673 function
->create_result_variables(this);
675 const std::string
* pname
;
676 std::string nested_name
;
677 bool is_init
= false;
678 if (Gogo::unpack_hidden_name(name
) == "init" && !type
->is_method())
680 if ((type
->parameters() != NULL
&& !type
->parameters()->empty())
681 || (type
->results() != NULL
&& !type
->results()->empty()))
683 "func init must have no arguments and no return values");
684 // There can be multiple "init" functions, so give them each a
686 static int init_count
;
688 snprintf(buf
, sizeof buf
, ".$init%d", init_count
);
691 pname
= &nested_name
;
694 else if (!name
.empty())
698 // Invent a name for a nested function.
699 static int nested_count
;
701 snprintf(buf
, sizeof buf
, ".$nested%d", nested_count
);
704 pname
= &nested_name
;
708 if (Gogo::is_sink_name(*pname
))
710 static int sink_count
;
712 snprintf(buf
, sizeof buf
, ".$sink%d", sink_count
);
714 ret
= Named_object::make_function(buf
, NULL
, function
);
716 else if (!type
->is_method())
718 ret
= this->package_
->bindings()->add_function(*pname
, NULL
, function
);
719 if (!ret
->is_function() || ret
->func_value() != function
)
721 // Redefinition error. Invent a name to avoid knockon
723 static int redefinition_count
;
725 snprintf(buf
, sizeof buf
, ".$redefined%d", redefinition_count
);
726 ++redefinition_count
;
727 ret
= this->package_
->bindings()->add_function(buf
, NULL
, function
);
732 if (!add_method_to_type
)
733 ret
= Named_object::make_function(name
, NULL
, function
);
736 go_assert(at_top_level
);
737 Type
* rtype
= type
->receiver()->type();
739 // We want to look through the pointer created by the
740 // parser, without getting an error if the type is not yet
742 if (rtype
->classification() == Type::TYPE_POINTER
)
743 rtype
= rtype
->points_to();
745 if (rtype
->is_error_type())
746 ret
= Named_object::make_function(name
, NULL
, function
);
747 else if (rtype
->named_type() != NULL
)
749 ret
= rtype
->named_type()->add_method(name
, function
);
750 if (!ret
->is_function())
752 // Redefinition error.
753 ret
= Named_object::make_function(name
, NULL
, function
);
756 else if (rtype
->forward_declaration_type() != NULL
)
758 Named_object
* type_no
=
759 rtype
->forward_declaration_type()->named_object();
760 if (type_no
->is_unknown())
762 // If we are seeing methods it really must be a
763 // type. Declare it as such. An alternative would
764 // be to support lists of methods for unknown
765 // expressions. Either way the error messages if
766 // this is not a type are going to get confusing.
767 Named_object
* declared
=
768 this->declare_package_type(type_no
->name(),
769 type_no
->location());
771 == type_no
->unknown_value()->real_named_object());
773 ret
= rtype
->forward_declaration_type()->add_method(name
,
779 this->package_
->bindings()->add_method(ret
);
782 this->functions_
.resize(this->functions_
.size() + 1);
783 Open_function
& of(this->functions_
.back());
785 of
.blocks
.push_back(block
);
789 this->init_functions_
.push_back(ret
);
790 this->need_init_fn_
= true;
796 // Finish compiling a function.
799 Gogo::finish_function(Location location
)
801 this->finish_block(location
);
802 go_assert(this->functions_
.back().blocks
.empty());
803 this->functions_
.pop_back();
806 // Return the current function.
809 Gogo::current_function() const
811 go_assert(!this->functions_
.empty());
812 return this->functions_
.back().function
;
815 // Start a new block.
818 Gogo::start_block(Location location
)
820 go_assert(!this->functions_
.empty());
821 Block
* block
= new Block(this->current_block(), location
);
822 this->functions_
.back().blocks
.push_back(block
);
828 Gogo::finish_block(Location location
)
830 go_assert(!this->functions_
.empty());
831 go_assert(!this->functions_
.back().blocks
.empty());
832 Block
* block
= this->functions_
.back().blocks
.back();
833 this->functions_
.back().blocks
.pop_back();
834 block
->set_end_location(location
);
838 // Add an erroneous name.
841 Gogo::add_erroneous_name(const std::string
& name
)
843 return this->package_
->bindings()->add_erroneous_name(name
);
846 // Add an unknown name.
849 Gogo::add_unknown_name(const std::string
& name
, Location location
)
851 return this->package_
->bindings()->add_unknown_name(name
, location
);
854 // Declare a function.
857 Gogo::declare_function(const std::string
& name
, Function_type
* type
,
860 if (!type
->is_method())
861 return this->current_bindings()->add_function_declaration(name
, NULL
, type
,
865 // We don't bother to add this to the list of global
867 Type
* rtype
= type
->receiver()->type();
869 // We want to look through the pointer created by the
870 // parser, without getting an error if the type is not yet
872 if (rtype
->classification() == Type::TYPE_POINTER
)
873 rtype
= rtype
->points_to();
875 if (rtype
->is_error_type())
877 else if (rtype
->named_type() != NULL
)
878 return rtype
->named_type()->add_method_declaration(name
, NULL
, type
,
880 else if (rtype
->forward_declaration_type() != NULL
)
882 Forward_declaration_type
* ftype
= rtype
->forward_declaration_type();
883 return ftype
->add_method_declaration(name
, NULL
, type
, location
);
890 // Add a label definition.
893 Gogo::add_label_definition(const std::string
& label_name
,
896 go_assert(!this->functions_
.empty());
897 Function
* func
= this->functions_
.back().function
->func_value();
898 Label
* label
= func
->add_label_definition(this, label_name
, location
);
899 this->add_statement(Statement::make_label_statement(label
, location
));
903 // Add a label reference.
906 Gogo::add_label_reference(const std::string
& label_name
,
907 Location location
, bool issue_goto_errors
)
909 go_assert(!this->functions_
.empty());
910 Function
* func
= this->functions_
.back().function
->func_value();
911 return func
->add_label_reference(this, label_name
, location
,
915 // Return the current binding state.
918 Gogo::bindings_snapshot(Location location
)
920 return new Bindings_snapshot(this->current_block(), location
);
926 Gogo::add_statement(Statement
* statement
)
928 go_assert(!this->functions_
.empty()
929 && !this->functions_
.back().blocks
.empty());
930 this->functions_
.back().blocks
.back()->add_statement(statement
);
936 Gogo::add_block(Block
* block
, Location location
)
938 go_assert(!this->functions_
.empty()
939 && !this->functions_
.back().blocks
.empty());
940 Statement
* statement
= Statement::make_block_statement(block
, location
);
941 this->functions_
.back().blocks
.back()->add_statement(statement
);
947 Gogo::add_constant(const Typed_identifier
& tid
, Expression
* expr
,
950 return this->current_bindings()->add_constant(tid
, NULL
, expr
, iota_value
);
956 Gogo::add_type(const std::string
& name
, Type
* type
, Location location
)
958 Named_object
* no
= this->current_bindings()->add_type(name
, NULL
, type
,
960 if (!this->in_global_scope() && no
->is_type())
961 no
->type_value()->set_in_function(this->functions_
.back().function
);
967 Gogo::add_named_type(Named_type
* type
)
969 go_assert(this->in_global_scope());
970 this->current_bindings()->add_named_type(type
);
976 Gogo::declare_type(const std::string
& name
, Location location
)
978 Bindings
* bindings
= this->current_bindings();
979 Named_object
* no
= bindings
->add_type_declaration(name
, NULL
, location
);
980 if (!this->in_global_scope() && no
->is_type_declaration())
982 Named_object
* f
= this->functions_
.back().function
;
983 no
->type_declaration_value()->set_in_function(f
);
988 // Declare a type at the package level.
991 Gogo::declare_package_type(const std::string
& name
, Location location
)
993 return this->package_
->bindings()->add_type_declaration(name
, NULL
, location
);
996 // Declare a function at the package level.
999 Gogo::declare_package_function(const std::string
& name
, Function_type
* type
,
1002 return this->package_
->bindings()->add_function_declaration(name
, NULL
, type
,
1006 // Define a type which was already declared.
1009 Gogo::define_type(Named_object
* no
, Named_type
* type
)
1011 this->current_bindings()->define_type(no
, type
);
1017 Gogo::add_variable(const std::string
& name
, Variable
* variable
)
1019 Named_object
* no
= this->current_bindings()->add_variable(name
, NULL
,
1022 // In a function the middle-end wants to see a DECL_EXPR node.
1024 && no
->is_variable()
1025 && !no
->var_value()->is_parameter()
1026 && !this->functions_
.empty())
1027 this->add_statement(Statement::make_variable_declaration(no
));
1032 // Add a sink--a reference to the blank identifier _.
1037 return Named_object::make_sink();
1040 // Add a named object.
1043 Gogo::add_named_object(Named_object
* no
)
1045 this->current_bindings()->add_named_object(no
);
1048 // Mark all local variables used. This is used when some types of
1049 // parse error occur.
1052 Gogo::mark_locals_used()
1054 for (Open_functions::iterator pf
= this->functions_
.begin();
1055 pf
!= this->functions_
.end();
1058 for (std::vector
<Block
*>::iterator pb
= pf
->blocks
.begin();
1059 pb
!= pf
->blocks
.end();
1061 (*pb
)->bindings()->mark_locals_used();
1065 // Record that we've seen an interface type.
1068 Gogo::record_interface_type(Interface_type
* itype
)
1070 this->interface_types_
.push_back(itype
);
1073 // Return a name for a thunk object.
1078 static int thunk_count
;
1079 char thunk_name
[50];
1080 snprintf(thunk_name
, sizeof thunk_name
, "$thunk%d", thunk_count
);
1085 // Return whether a function is a thunk.
1088 Gogo::is_thunk(const Named_object
* no
)
1090 return no
->name().compare(0, 6, "$thunk") == 0;
1093 // Define the global names. We do this only after parsing all the
1094 // input files, because the program might define the global names
1098 Gogo::define_global_names()
1100 for (Bindings::const_declarations_iterator p
=
1101 this->globals_
->begin_declarations();
1102 p
!= this->globals_
->end_declarations();
1105 Named_object
* global_no
= p
->second
;
1106 std::string
name(Gogo::pack_hidden_name(global_no
->name(), false));
1107 Named_object
* no
= this->package_
->bindings()->lookup(name
);
1111 if (no
->is_type_declaration())
1113 if (global_no
->is_type())
1115 if (no
->type_declaration_value()->has_methods())
1116 error_at(no
->location(),
1117 "may not define methods for global type");
1118 no
->set_type_value(global_no
->type_value());
1122 error_at(no
->location(), "expected type");
1123 Type
* errtype
= Type::make_error_type();
1125 Named_object::make_type("erroneous_type", NULL
, errtype
,
1126 Linemap::predeclared_location());
1127 no
->set_type_value(err
->type_value());
1130 else if (no
->is_unknown())
1131 no
->unknown_value()->set_real_named_object(global_no
);
1135 // Clear out names in file scope.
1138 Gogo::clear_file_scope()
1140 this->package_
->bindings()->clear_file_scope();
1142 // Warn about packages which were imported but not used.
1143 for (Packages::iterator p
= this->packages_
.begin();
1144 p
!= this->packages_
.end();
1147 Package
* package
= p
->second
;
1148 if (package
!= this->package_
1149 && package
->is_imported()
1151 && !package
->uses_sink_alias()
1153 error_at(package
->location(), "imported and not used: %s",
1154 Gogo::message_name(package
->name()).c_str());
1155 package
->clear_is_imported();
1156 package
->clear_uses_sink_alias();
1157 package
->clear_used();
1161 // Queue up a type specific function for later writing. These are
1162 // written out in write_specific_type_functions, called after the
1163 // parse tree is lowered.
1166 Gogo::queue_specific_type_function(Type
* type
, Named_type
* name
,
1167 const std::string
& hash_name
,
1168 Function_type
* hash_fntype
,
1169 const std::string
& equal_name
,
1170 Function_type
* equal_fntype
)
1172 go_assert(!this->specific_type_functions_are_written_
);
1173 go_assert(!this->in_global_scope());
1174 Specific_type_function
* tsf
= new Specific_type_function(type
, name
,
1179 this->specific_type_functions_
.push_back(tsf
);
1182 // Look for types which need specific hash or equality functions.
1184 class Specific_type_functions
: public Traverse
1187 Specific_type_functions(Gogo
* gogo
)
1188 : Traverse(traverse_types
),
1200 Specific_type_functions::type(Type
* t
)
1202 Named_object
* hash_fn
;
1203 Named_object
* equal_fn
;
1204 switch (t
->classification())
1206 case Type::TYPE_NAMED
:
1208 Named_type
* nt
= t
->named_type();
1209 if (!t
->compare_is_identity(this->gogo_
) && t
->is_comparable())
1210 t
->type_functions(this->gogo_
, nt
, NULL
, NULL
, &hash_fn
, &equal_fn
);
1212 // If this is a struct type, we don't want to make functions
1213 // for the unnamed struct.
1214 Type
* rt
= nt
->real_type();
1215 if (rt
->struct_type() == NULL
)
1217 if (Type::traverse(rt
, this) == TRAVERSE_EXIT
)
1218 return TRAVERSE_EXIT
;
1222 // If this type is defined in another package, then we don't
1223 // need to worry about the unexported fields.
1224 bool is_defined_elsewhere
= nt
->named_object()->package() != NULL
;
1225 const Struct_field_list
* fields
= rt
->struct_type()->fields();
1226 for (Struct_field_list::const_iterator p
= fields
->begin();
1230 if (is_defined_elsewhere
1231 && Gogo::is_hidden_name(p
->field_name()))
1233 if (Type::traverse(p
->type(), this) == TRAVERSE_EXIT
)
1234 return TRAVERSE_EXIT
;
1238 return TRAVERSE_SKIP_COMPONENTS
;
1241 case Type::TYPE_STRUCT
:
1242 case Type::TYPE_ARRAY
:
1243 if (!t
->compare_is_identity(this->gogo_
) && t
->is_comparable())
1244 t
->type_functions(this->gogo_
, NULL
, NULL
, NULL
, &hash_fn
, &equal_fn
);
1251 return TRAVERSE_CONTINUE
;
1254 // Write out type specific functions.
1257 Gogo::write_specific_type_functions()
1259 Specific_type_functions
stf(this);
1260 this->traverse(&stf
);
1262 while (!this->specific_type_functions_
.empty())
1264 Specific_type_function
* tsf
= this->specific_type_functions_
.back();
1265 this->specific_type_functions_
.pop_back();
1266 tsf
->type
->write_specific_type_functions(this, tsf
->name
,
1273 this->specific_type_functions_are_written_
= true;
1276 // Traverse the tree.
1279 Gogo::traverse(Traverse
* traverse
)
1281 // Traverse the current package first for consistency. The other
1282 // packages will only contain imported types, constants, and
1284 if (this->package_
->bindings()->traverse(traverse
, true) == TRAVERSE_EXIT
)
1286 for (Packages::const_iterator p
= this->packages_
.begin();
1287 p
!= this->packages_
.end();
1290 if (p
->second
!= this->package_
)
1292 if (p
->second
->bindings()->traverse(traverse
, true) == TRAVERSE_EXIT
)
1298 // Add a type to verify. This is used for types of sink variables, in
1299 // order to give appropriate error messages.
1302 Gogo::add_type_to_verify(Type
* type
)
1304 this->verify_types_
.push_back(type
);
1307 // Traversal class used to verify types.
1309 class Verify_types
: public Traverse
1313 : Traverse(traverse_types
)
1320 // Verify that a type is correct.
1323 Verify_types::type(Type
* t
)
1326 return TRAVERSE_SKIP_COMPONENTS
;
1327 return TRAVERSE_CONTINUE
;
1330 // Verify that all types are correct.
1333 Gogo::verify_types()
1335 Verify_types traverse
;
1336 this->traverse(&traverse
);
1338 for (std::vector
<Type
*>::iterator p
= this->verify_types_
.begin();
1339 p
!= this->verify_types_
.end();
1342 this->verify_types_
.clear();
1345 // Traversal class used to lower parse tree.
1347 class Lower_parse_tree
: public Traverse
1350 Lower_parse_tree(Gogo
* gogo
, Named_object
* function
)
1351 : Traverse(traverse_variables
1352 | traverse_constants
1353 | traverse_functions
1354 | traverse_statements
1355 | traverse_expressions
),
1356 gogo_(gogo
), function_(function
), iota_value_(-1), inserter_()
1360 set_inserter(const Statement_inserter
* inserter
)
1361 { this->inserter_
= *inserter
; }
1364 variable(Named_object
*);
1367 constant(Named_object
*, bool);
1370 function(Named_object
*);
1373 statement(Block
*, size_t* pindex
, Statement
*);
1376 expression(Expression
**);
1381 // The function we are traversing.
1382 Named_object
* function_
;
1383 // Value to use for the predeclared constant iota.
1385 // Current statement inserter for use by expressions.
1386 Statement_inserter inserter_
;
1392 Lower_parse_tree::variable(Named_object
* no
)
1394 if (!no
->is_variable())
1395 return TRAVERSE_CONTINUE
;
1397 if (no
->is_variable() && no
->var_value()->is_global())
1399 // Global variables can have loops in their initialization
1400 // expressions. This is handled in lower_init_expression.
1401 no
->var_value()->lower_init_expression(this->gogo_
, this->function_
,
1403 return TRAVERSE_CONTINUE
;
1406 // This is a local variable. We are going to return
1407 // TRAVERSE_SKIP_COMPONENTS here because we want to traverse the
1408 // initialization expression when we reach the variable declaration
1409 // statement. However, that means that we need to traverse the type
1411 if (no
->var_value()->has_type())
1413 Type
* type
= no
->var_value()->type();
1416 if (Type::traverse(type
, this) == TRAVERSE_EXIT
)
1417 return TRAVERSE_EXIT
;
1420 go_assert(!no
->var_value()->has_pre_init());
1422 return TRAVERSE_SKIP_COMPONENTS
;
1425 // Lower constants. We handle constants specially so that we can set
1426 // the right value for the predeclared constant iota. This works in
1427 // conjunction with the way we lower Const_expression objects.
1430 Lower_parse_tree::constant(Named_object
* no
, bool)
1432 Named_constant
* nc
= no
->const_value();
1434 // Don't get into trouble if the constant's initializer expression
1435 // refers to the constant itself.
1437 return TRAVERSE_CONTINUE
;
1440 go_assert(this->iota_value_
== -1);
1441 this->iota_value_
= nc
->iota_value();
1442 nc
->traverse_expression(this);
1443 this->iota_value_
= -1;
1445 nc
->clear_lowering();
1447 // We will traverse the expression a second time, but that will be
1450 return TRAVERSE_CONTINUE
;
1453 // Lower function closure types. Record the function while lowering
1454 // it, so that we can pass it down when lowering an expression.
1457 Lower_parse_tree::function(Named_object
* no
)
1459 no
->func_value()->set_closure_type();
1461 go_assert(this->function_
== NULL
);
1462 this->function_
= no
;
1463 int t
= no
->func_value()->traverse(this);
1464 this->function_
= NULL
;
1466 if (t
== TRAVERSE_EXIT
)
1468 return TRAVERSE_SKIP_COMPONENTS
;
1471 // Lower statement parse trees.
1474 Lower_parse_tree::statement(Block
* block
, size_t* pindex
, Statement
* sorig
)
1476 // Because we explicitly traverse the statement's contents
1477 // ourselves, we want to skip block statements here. There is
1478 // nothing to lower in a block statement.
1479 if (sorig
->is_block_statement())
1480 return TRAVERSE_CONTINUE
;
1482 Statement_inserter
hold_inserter(this->inserter_
);
1483 this->inserter_
= Statement_inserter(block
, pindex
);
1485 // Lower the expressions first.
1486 int t
= sorig
->traverse_contents(this);
1487 if (t
== TRAVERSE_EXIT
)
1489 this->inserter_
= hold_inserter
;
1493 // Keep lowering until nothing changes.
1494 Statement
* s
= sorig
;
1497 Statement
* snew
= s
->lower(this->gogo_
, this->function_
, block
,
1502 t
= s
->traverse_contents(this);
1503 if (t
== TRAVERSE_EXIT
)
1505 this->inserter_
= hold_inserter
;
1511 block
->replace_statement(*pindex
, s
);
1513 this->inserter_
= hold_inserter
;
1514 return TRAVERSE_SKIP_COMPONENTS
;
1517 // Lower expression parse trees.
1520 Lower_parse_tree::expression(Expression
** pexpr
)
1522 // We have to lower all subexpressions first, so that we can get
1523 // their type if necessary. This is awkward, because we don't have
1524 // a postorder traversal pass.
1525 if ((*pexpr
)->traverse_subexpressions(this) == TRAVERSE_EXIT
)
1526 return TRAVERSE_EXIT
;
1527 // Keep lowering until nothing changes.
1530 Expression
* e
= *pexpr
;
1531 Expression
* enew
= e
->lower(this->gogo_
, this->function_
,
1532 &this->inserter_
, this->iota_value_
);
1535 if (enew
->traverse_subexpressions(this) == TRAVERSE_EXIT
)
1536 return TRAVERSE_EXIT
;
1539 return TRAVERSE_SKIP_COMPONENTS
;
1542 // Lower the parse tree. This is called after the parse is complete,
1543 // when all names should be resolved.
1546 Gogo::lower_parse_tree()
1548 Lower_parse_tree
lower_parse_tree(this, NULL
);
1549 this->traverse(&lower_parse_tree
);
1555 Gogo::lower_block(Named_object
* function
, Block
* block
)
1557 Lower_parse_tree
lower_parse_tree(this, function
);
1558 block
->traverse(&lower_parse_tree
);
1561 // Lower an expression. INSERTER may be NULL, in which case the
1562 // expression had better not need to create any temporaries.
1565 Gogo::lower_expression(Named_object
* function
, Statement_inserter
* inserter
,
1568 Lower_parse_tree
lower_parse_tree(this, function
);
1569 if (inserter
!= NULL
)
1570 lower_parse_tree
.set_inserter(inserter
);
1571 lower_parse_tree
.expression(pexpr
);
1574 // Lower a constant. This is called when lowering a reference to a
1575 // constant. We have to make sure that the constant has already been
1579 Gogo::lower_constant(Named_object
* no
)
1581 go_assert(no
->is_const());
1582 Lower_parse_tree
lower(this, NULL
);
1583 lower
.constant(no
, false);
1586 // Look for interface types to finalize methods of inherited
1589 class Finalize_methods
: public Traverse
1592 Finalize_methods(Gogo
* gogo
)
1593 : Traverse(traverse_types
),
1604 // Finalize the methods of an interface type.
1607 Finalize_methods::type(Type
* t
)
1609 // Check the classification so that we don't finalize the methods
1610 // twice for a named interface type.
1611 switch (t
->classification())
1613 case Type::TYPE_INTERFACE
:
1614 t
->interface_type()->finalize_methods();
1617 case Type::TYPE_NAMED
:
1619 // We have to finalize the methods of the real type first.
1620 // But if the real type is a struct type, then we only want to
1621 // finalize the methods of the field types, not of the struct
1622 // type itself. We don't want to add methods to the struct,
1623 // since it has a name.
1624 Named_type
* nt
= t
->named_type();
1625 Type
* rt
= nt
->real_type();
1626 if (rt
->classification() != Type::TYPE_STRUCT
)
1628 if (Type::traverse(rt
, this) == TRAVERSE_EXIT
)
1629 return TRAVERSE_EXIT
;
1633 if (rt
->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT
)
1634 return TRAVERSE_EXIT
;
1637 nt
->finalize_methods(this->gogo_
);
1639 // If this type is defined in a different package, then finalize the
1640 // types of all the methods, since we won't see them otherwise.
1641 if (nt
->named_object()->package() != NULL
&& nt
->has_any_methods())
1643 const Methods
* methods
= nt
->methods();
1644 for (Methods::const_iterator p
= methods
->begin();
1645 p
!= methods
->end();
1648 if (Type::traverse(p
->second
->type(), this) == TRAVERSE_EXIT
)
1649 return TRAVERSE_EXIT
;
1653 return TRAVERSE_SKIP_COMPONENTS
;
1656 case Type::TYPE_STRUCT
:
1657 t
->struct_type()->finalize_methods(this->gogo_
);
1664 return TRAVERSE_CONTINUE
;
1667 // Finalize method lists and build stub methods for types.
1670 Gogo::finalize_methods()
1672 Finalize_methods
finalize(this);
1673 this->traverse(&finalize
);
1676 // Set types for unspecified variables and constants.
1679 Gogo::determine_types()
1681 Bindings
* bindings
= this->current_bindings();
1682 for (Bindings::const_definitions_iterator p
= bindings
->begin_definitions();
1683 p
!= bindings
->end_definitions();
1686 if ((*p
)->is_function())
1687 (*p
)->func_value()->determine_types();
1688 else if ((*p
)->is_variable())
1689 (*p
)->var_value()->determine_type();
1690 else if ((*p
)->is_const())
1691 (*p
)->const_value()->determine_type();
1693 // See if a variable requires us to build an initialization
1694 // function. We know that we will see all global variables
1696 if (!this->need_init_fn_
&& (*p
)->is_variable())
1698 Variable
* variable
= (*p
)->var_value();
1700 // If this is a global variable which requires runtime
1701 // initialization, we need an initialization function.
1702 if (!variable
->is_global())
1704 else if (variable
->init() == NULL
)
1706 else if (variable
->type()->interface_type() != NULL
)
1707 this->need_init_fn_
= true;
1708 else if (variable
->init()->is_constant())
1710 else if (!variable
->init()->is_composite_literal())
1711 this->need_init_fn_
= true;
1712 else if (variable
->init()->is_nonconstant_composite_literal())
1713 this->need_init_fn_
= true;
1715 // If this is a global variable which holds a pointer value,
1716 // then we need an initialization function to register it as a
1718 if (variable
->is_global() && variable
->type()->has_pointer())
1719 this->need_init_fn_
= true;
1723 // Determine the types of constants in packages.
1724 for (Packages::const_iterator p
= this->packages_
.begin();
1725 p
!= this->packages_
.end();
1727 p
->second
->determine_types();
1730 // Traversal class used for type checking.
1732 class Check_types_traverse
: public Traverse
1735 Check_types_traverse(Gogo
* gogo
)
1736 : Traverse(traverse_variables
1737 | traverse_constants
1738 | traverse_functions
1739 | traverse_statements
1740 | traverse_expressions
),
1745 variable(Named_object
*);
1748 constant(Named_object
*, bool);
1751 function(Named_object
*);
1754 statement(Block
*, size_t* pindex
, Statement
*);
1757 expression(Expression
**);
1764 // Check that a variable initializer has the right type.
1767 Check_types_traverse::variable(Named_object
* named_object
)
1769 if (named_object
->is_variable())
1771 Variable
* var
= named_object
->var_value();
1773 // Give error if variable type is not defined.
1774 var
->type()->base();
1776 Expression
* init
= var
->init();
1779 && !Type::are_assignable(var
->type(), init
->type(), &reason
))
1782 error_at(var
->location(), "incompatible type in initialization");
1784 error_at(var
->location(),
1785 "incompatible type in initialization (%s)",
1789 else if (!var
->is_used()
1790 && !var
->is_global()
1791 && !var
->is_parameter()
1792 && !var
->is_receiver()
1793 && !var
->type()->is_error()
1794 && (init
== NULL
|| !init
->is_error_expression())
1795 && !Lex::is_invalid_identifier(named_object
->name()))
1796 error_at(var
->location(), "%qs declared and not used",
1797 named_object
->message_name().c_str());
1799 return TRAVERSE_CONTINUE
;
1802 // Check that a constant initializer has the right type.
1805 Check_types_traverse::constant(Named_object
* named_object
, bool)
1807 Named_constant
* constant
= named_object
->const_value();
1808 Type
* ctype
= constant
->type();
1809 if (ctype
->integer_type() == NULL
1810 && ctype
->float_type() == NULL
1811 && ctype
->complex_type() == NULL
1812 && !ctype
->is_boolean_type()
1813 && !ctype
->is_string_type())
1815 if (ctype
->is_nil_type())
1816 error_at(constant
->location(), "const initializer cannot be nil");
1817 else if (!ctype
->is_error())
1818 error_at(constant
->location(), "invalid constant type");
1819 constant
->set_error();
1821 else if (!constant
->expr()->is_constant())
1823 error_at(constant
->expr()->location(), "expression is not constant");
1824 constant
->set_error();
1826 else if (!Type::are_assignable(constant
->type(), constant
->expr()->type(),
1829 error_at(constant
->location(),
1830 "initialization expression has wrong type");
1831 constant
->set_error();
1833 return TRAVERSE_CONTINUE
;
1836 // There are no types to check in a function, but this is where we
1837 // issue warnings about labels which are defined but not referenced.
1840 Check_types_traverse::function(Named_object
* no
)
1842 no
->func_value()->check_labels();
1843 return TRAVERSE_CONTINUE
;
1846 // Check that types are valid in a statement.
1849 Check_types_traverse::statement(Block
*, size_t*, Statement
* s
)
1851 s
->check_types(this->gogo_
);
1852 return TRAVERSE_CONTINUE
;
1855 // Check that types are valid in an expression.
1858 Check_types_traverse::expression(Expression
** expr
)
1860 (*expr
)->check_types(this->gogo_
);
1861 return TRAVERSE_CONTINUE
;
1864 // Check that types are valid.
1869 Check_types_traverse
traverse(this);
1870 this->traverse(&traverse
);
1873 // Check the types in a single block.
1876 Gogo::check_types_in_block(Block
* block
)
1878 Check_types_traverse
traverse(this);
1879 block
->traverse(&traverse
);
1882 // A traversal class used to find a single shortcut operator within an
1885 class Find_shortcut
: public Traverse
1889 : Traverse(traverse_blocks
1890 | traverse_statements
1891 | traverse_expressions
),
1895 // A pointer to the expression which was found, or NULL if none was
1899 { return this->found_
; }
1904 { return TRAVERSE_SKIP_COMPONENTS
; }
1907 statement(Block
*, size_t*, Statement
*)
1908 { return TRAVERSE_SKIP_COMPONENTS
; }
1911 expression(Expression
**);
1914 Expression
** found_
;
1917 // Find a shortcut expression.
1920 Find_shortcut::expression(Expression
** pexpr
)
1922 Expression
* expr
= *pexpr
;
1923 Binary_expression
* be
= expr
->binary_expression();
1925 return TRAVERSE_CONTINUE
;
1926 Operator op
= be
->op();
1927 if (op
!= OPERATOR_OROR
&& op
!= OPERATOR_ANDAND
)
1928 return TRAVERSE_CONTINUE
;
1929 go_assert(this->found_
== NULL
);
1930 this->found_
= pexpr
;
1931 return TRAVERSE_EXIT
;
1934 // A traversal class used to turn shortcut operators into explicit if
1937 class Shortcuts
: public Traverse
1940 Shortcuts(Gogo
* gogo
)
1941 : Traverse(traverse_variables
1942 | traverse_statements
),
1948 variable(Named_object
*);
1951 statement(Block
*, size_t*, Statement
*);
1954 // Convert a shortcut operator.
1956 convert_shortcut(Block
* enclosing
, Expression
** pshortcut
);
1962 // Remove shortcut operators in a single statement.
1965 Shortcuts::statement(Block
* block
, size_t* pindex
, Statement
* s
)
1967 // FIXME: This approach doesn't work for switch statements, because
1968 // we add the new statements before the whole switch when we need to
1969 // instead add them just before the switch expression. The right
1970 // fix is probably to lower switch statements with nonconstant cases
1971 // to a series of conditionals.
1972 if (s
->switch_statement() != NULL
)
1973 return TRAVERSE_CONTINUE
;
1977 Find_shortcut find_shortcut
;
1979 // If S is a variable declaration, then ordinary traversal won't
1980 // do anything. We want to explicitly traverse the
1981 // initialization expression if there is one.
1982 Variable_declaration_statement
* vds
= s
->variable_declaration_statement();
1983 Expression
* init
= NULL
;
1985 s
->traverse_contents(&find_shortcut
);
1988 init
= vds
->var()->var_value()->init();
1990 return TRAVERSE_CONTINUE
;
1991 init
->traverse(&init
, &find_shortcut
);
1993 Expression
** pshortcut
= find_shortcut
.found();
1994 if (pshortcut
== NULL
)
1995 return TRAVERSE_CONTINUE
;
1997 Statement
* snew
= this->convert_shortcut(block
, pshortcut
);
1998 block
->insert_statement_before(*pindex
, snew
);
2001 if (pshortcut
== &init
)
2002 vds
->var()->var_value()->set_init(init
);
2006 // Remove shortcut operators in the initializer of a global variable.
2009 Shortcuts::variable(Named_object
* no
)
2011 if (no
->is_result_variable())
2012 return TRAVERSE_CONTINUE
;
2013 Variable
* var
= no
->var_value();
2014 Expression
* init
= var
->init();
2015 if (!var
->is_global() || init
== NULL
)
2016 return TRAVERSE_CONTINUE
;
2020 Find_shortcut find_shortcut
;
2021 init
->traverse(&init
, &find_shortcut
);
2022 Expression
** pshortcut
= find_shortcut
.found();
2023 if (pshortcut
== NULL
)
2024 return TRAVERSE_CONTINUE
;
2026 Statement
* snew
= this->convert_shortcut(NULL
, pshortcut
);
2027 var
->add_preinit_statement(this->gogo_
, snew
);
2028 if (pshortcut
== &init
)
2029 var
->set_init(init
);
2033 // Given an expression which uses a shortcut operator, return a
2034 // statement which implements it, and update *PSHORTCUT accordingly.
2037 Shortcuts::convert_shortcut(Block
* enclosing
, Expression
** pshortcut
)
2039 Binary_expression
* shortcut
= (*pshortcut
)->binary_expression();
2040 Expression
* left
= shortcut
->left();
2041 Expression
* right
= shortcut
->right();
2042 Location loc
= shortcut
->location();
2044 Block
* retblock
= new Block(enclosing
, loc
);
2045 retblock
->set_end_location(loc
);
2047 Temporary_statement
* ts
= Statement::make_temporary(Type::lookup_bool_type(),
2049 retblock
->add_statement(ts
);
2051 Block
* block
= new Block(retblock
, loc
);
2052 block
->set_end_location(loc
);
2053 Expression
* tmpref
= Expression::make_temporary_reference(ts
, loc
);
2054 Statement
* assign
= Statement::make_assignment(tmpref
, right
, loc
);
2055 block
->add_statement(assign
);
2057 Expression
* cond
= Expression::make_temporary_reference(ts
, loc
);
2058 if (shortcut
->binary_expression()->op() == OPERATOR_OROR
)
2059 cond
= Expression::make_unary(OPERATOR_NOT
, cond
, loc
);
2061 Statement
* if_statement
= Statement::make_if_statement(cond
, block
, NULL
,
2063 retblock
->add_statement(if_statement
);
2065 *pshortcut
= Expression::make_temporary_reference(ts
, loc
);
2069 // Now convert any shortcut operators in LEFT and RIGHT.
2070 Shortcuts
shortcuts(this->gogo_
);
2071 retblock
->traverse(&shortcuts
);
2073 return Statement::make_block_statement(retblock
, loc
);
2076 // Turn shortcut operators into explicit if statements. Doing this
2077 // considerably simplifies the order of evaluation rules.
2080 Gogo::remove_shortcuts()
2082 Shortcuts
shortcuts(this);
2083 this->traverse(&shortcuts
);
2086 // A traversal class which finds all the expressions which must be
2087 // evaluated in order within a statement or larger expression. This
2088 // is used to implement the rules about order of evaluation.
2090 class Find_eval_ordering
: public Traverse
2093 typedef std::vector
<Expression
**> Expression_pointers
;
2096 Find_eval_ordering()
2097 : Traverse(traverse_blocks
2098 | traverse_statements
2099 | traverse_expressions
),
2105 { return this->exprs_
.size(); }
2107 typedef Expression_pointers::const_iterator const_iterator
;
2111 { return this->exprs_
.begin(); }
2115 { return this->exprs_
.end(); }
2120 { return TRAVERSE_SKIP_COMPONENTS
; }
2123 statement(Block
*, size_t*, Statement
*)
2124 { return TRAVERSE_SKIP_COMPONENTS
; }
2127 expression(Expression
**);
2130 // A list of pointers to expressions with side-effects.
2131 Expression_pointers exprs_
;
2134 // If an expression must be evaluated in order, put it on the list.
2137 Find_eval_ordering::expression(Expression
** expression_pointer
)
2139 // We have to look at subexpressions before this one.
2140 if ((*expression_pointer
)->traverse_subexpressions(this) == TRAVERSE_EXIT
)
2141 return TRAVERSE_EXIT
;
2142 if ((*expression_pointer
)->must_eval_in_order())
2143 this->exprs_
.push_back(expression_pointer
);
2144 return TRAVERSE_SKIP_COMPONENTS
;
2147 // A traversal class for ordering evaluations.
2149 class Order_eval
: public Traverse
2152 Order_eval(Gogo
* gogo
)
2153 : Traverse(traverse_variables
2154 | traverse_statements
),
2159 variable(Named_object
*);
2162 statement(Block
*, size_t*, Statement
*);
2169 // Implement the order of evaluation rules for a statement.
2172 Order_eval::statement(Block
* block
, size_t* pindex
, Statement
* s
)
2174 // FIXME: This approach doesn't work for switch statements, because
2175 // we add the new statements before the whole switch when we need to
2176 // instead add them just before the switch expression. The right
2177 // fix is probably to lower switch statements with nonconstant cases
2178 // to a series of conditionals.
2179 if (s
->switch_statement() != NULL
)
2180 return TRAVERSE_CONTINUE
;
2182 Find_eval_ordering find_eval_ordering
;
2184 // If S is a variable declaration, then ordinary traversal won't do
2185 // anything. We want to explicitly traverse the initialization
2186 // expression if there is one.
2187 Variable_declaration_statement
* vds
= s
->variable_declaration_statement();
2188 Expression
* init
= NULL
;
2189 Expression
* orig_init
= NULL
;
2191 s
->traverse_contents(&find_eval_ordering
);
2194 init
= vds
->var()->var_value()->init();
2196 return TRAVERSE_CONTINUE
;
2199 // It might seem that this could be
2200 // init->traverse_subexpressions. Unfortunately that can fail
2203 // newvar, err := call(arg())
2204 // Here newvar will have an init of call result 0 of
2205 // call(arg()). If we only traverse subexpressions, we will
2206 // only find arg(), and we won't bother to move anything out.
2207 // Then we get to the assignment to err, we will traverse the
2208 // whole statement, and this time we will find both call() and
2209 // arg(), and so we will move them out. This will cause them to
2210 // be put into temporary variables before the assignment to err
2211 // but after the declaration of newvar. To avoid that problem,
2212 // we traverse the entire expression here.
2213 Expression::traverse(&init
, &find_eval_ordering
);
2216 if (find_eval_ordering
.size() <= 1)
2218 // If there is only one expression with a side-effect, we can
2219 // leave it in place.
2220 return TRAVERSE_CONTINUE
;
2223 bool is_thunk
= s
->thunk_statement() != NULL
;
2224 for (Find_eval_ordering::const_iterator p
= find_eval_ordering
.begin();
2225 p
!= find_eval_ordering
.end();
2228 Expression
** pexpr
= *p
;
2230 // The last expression in a thunk will be the call passed to go
2231 // or defer, which we must not evaluate early.
2232 if (is_thunk
&& p
+ 1 == find_eval_ordering
.end())
2235 Location loc
= (*pexpr
)->location();
2237 if ((*pexpr
)->call_expression() == NULL
2238 || (*pexpr
)->call_expression()->result_count() < 2)
2240 Temporary_statement
* ts
= Statement::make_temporary(NULL
, *pexpr
,
2243 *pexpr
= Expression::make_temporary_reference(ts
, loc
);
2247 // A call expression which returns multiple results needs to
2248 // be handled specially. We can't create a temporary
2249 // because there is no type to give it. Any actual uses of
2250 // the values will be done via Call_result_expressions.
2251 s
= Statement::make_statement(*pexpr
, true);
2254 block
->insert_statement_before(*pindex
, s
);
2258 if (init
!= orig_init
)
2259 vds
->var()->var_value()->set_init(init
);
2261 return TRAVERSE_CONTINUE
;
2264 // Implement the order of evaluation rules for the initializer of a
2268 Order_eval::variable(Named_object
* no
)
2270 if (no
->is_result_variable())
2271 return TRAVERSE_CONTINUE
;
2272 Variable
* var
= no
->var_value();
2273 Expression
* init
= var
->init();
2274 if (!var
->is_global() || init
== NULL
)
2275 return TRAVERSE_CONTINUE
;
2277 Find_eval_ordering find_eval_ordering
;
2278 Expression::traverse(&init
, &find_eval_ordering
);
2280 if (find_eval_ordering
.size() <= 1)
2282 // If there is only one expression with a side-effect, we can
2283 // leave it in place.
2284 return TRAVERSE_SKIP_COMPONENTS
;
2287 Expression
* orig_init
= init
;
2289 for (Find_eval_ordering::const_iterator p
= find_eval_ordering
.begin();
2290 p
!= find_eval_ordering
.end();
2293 Expression
** pexpr
= *p
;
2294 Location loc
= (*pexpr
)->location();
2296 if ((*pexpr
)->call_expression() == NULL
2297 || (*pexpr
)->call_expression()->result_count() < 2)
2299 Temporary_statement
* ts
= Statement::make_temporary(NULL
, *pexpr
,
2302 *pexpr
= Expression::make_temporary_reference(ts
, loc
);
2306 // A call expression which returns multiple results needs to
2307 // be handled specially.
2308 s
= Statement::make_statement(*pexpr
, true);
2310 var
->add_preinit_statement(this->gogo_
, s
);
2313 if (init
!= orig_init
)
2314 var
->set_init(init
);
2316 return TRAVERSE_SKIP_COMPONENTS
;
2319 // Use temporary variables to implement the order of evaluation rules.
2322 Gogo::order_evaluations()
2324 Order_eval
order_eval(this);
2325 this->traverse(&order_eval
);
2328 // Traversal to convert calls to the predeclared recover function to
2329 // pass in an argument indicating whether it can recover from a panic
2332 class Convert_recover
: public Traverse
2335 Convert_recover(Named_object
* arg
)
2336 : Traverse(traverse_expressions
),
2342 expression(Expression
**);
2345 // The argument to pass to the function.
2349 // Convert calls to recover.
2352 Convert_recover::expression(Expression
** pp
)
2354 Call_expression
* ce
= (*pp
)->call_expression();
2355 if (ce
!= NULL
&& ce
->is_recover_call())
2356 ce
->set_recover_arg(Expression::make_var_reference(this->arg_
,
2358 return TRAVERSE_CONTINUE
;
2361 // Traversal for build_recover_thunks.
2363 class Build_recover_thunks
: public Traverse
2366 Build_recover_thunks(Gogo
* gogo
)
2367 : Traverse(traverse_functions
),
2372 function(Named_object
*);
2376 can_recover_arg(Location
);
2382 // If this function calls recover, turn it into a thunk.
2385 Build_recover_thunks::function(Named_object
* orig_no
)
2387 Function
* orig_func
= orig_no
->func_value();
2388 if (!orig_func
->calls_recover()
2389 || orig_func
->is_recover_thunk()
2390 || orig_func
->has_recover_thunk())
2391 return TRAVERSE_CONTINUE
;
2393 Gogo
* gogo
= this->gogo_
;
2394 Location location
= orig_func
->location();
2399 Function_type
* orig_fntype
= orig_func
->type();
2400 Typed_identifier_list
* new_params
= new Typed_identifier_list();
2401 std::string receiver_name
;
2402 if (orig_fntype
->is_method())
2404 const Typed_identifier
* receiver
= orig_fntype
->receiver();
2405 snprintf(buf
, sizeof buf
, "rt.%u", count
);
2407 receiver_name
= buf
;
2408 new_params
->push_back(Typed_identifier(receiver_name
, receiver
->type(),
2409 receiver
->location()));
2411 const Typed_identifier_list
* orig_params
= orig_fntype
->parameters();
2412 if (orig_params
!= NULL
&& !orig_params
->empty())
2414 for (Typed_identifier_list::const_iterator p
= orig_params
->begin();
2415 p
!= orig_params
->end();
2418 snprintf(buf
, sizeof buf
, "pt.%u", count
);
2420 new_params
->push_back(Typed_identifier(buf
, p
->type(),
2424 snprintf(buf
, sizeof buf
, "pr.%u", count
);
2426 std::string can_recover_name
= buf
;
2427 new_params
->push_back(Typed_identifier(can_recover_name
,
2428 Type::lookup_bool_type(),
2429 orig_fntype
->location()));
2431 const Typed_identifier_list
* orig_results
= orig_fntype
->results();
2432 Typed_identifier_list
* new_results
;
2433 if (orig_results
== NULL
|| orig_results
->empty())
2437 new_results
= new Typed_identifier_list();
2438 for (Typed_identifier_list::const_iterator p
= orig_results
->begin();
2439 p
!= orig_results
->end();
2441 new_results
->push_back(Typed_identifier("", p
->type(), p
->location()));
2444 Function_type
*new_fntype
= Type::make_function_type(NULL
, new_params
,
2446 orig_fntype
->location());
2447 if (orig_fntype
->is_varargs())
2448 new_fntype
->set_is_varargs();
2450 std::string name
= orig_no
->name() + "$recover";
2451 Named_object
*new_no
= gogo
->start_function(name
, new_fntype
, false,
2453 Function
*new_func
= new_no
->func_value();
2454 if (orig_func
->enclosing() != NULL
)
2455 new_func
->set_enclosing(orig_func
->enclosing());
2457 // We build the code for the original function attached to the new
2458 // function, and then swap the original and new function bodies.
2459 // This means that existing references to the original function will
2460 // then refer to the new function. That makes this code a little
2461 // confusing, in that the reference to NEW_NO really refers to the
2462 // other function, not the one we are building.
2464 Expression
* closure
= NULL
;
2465 if (orig_func
->needs_closure())
2467 Named_object
* orig_closure_no
= orig_func
->closure_var();
2468 Variable
* orig_closure_var
= orig_closure_no
->var_value();
2469 Variable
* new_var
= new Variable(orig_closure_var
->type(), NULL
, false,
2470 true, false, location
);
2471 snprintf(buf
, sizeof buf
, "closure.%u", count
);
2473 Named_object
* new_closure_no
= Named_object::make_variable(buf
, NULL
,
2475 new_func
->set_closure_var(new_closure_no
);
2476 closure
= Expression::make_var_reference(new_closure_no
, location
);
2479 Expression
* fn
= Expression::make_func_reference(new_no
, closure
, location
);
2481 Expression_list
* args
= new Expression_list();
2482 if (new_params
!= NULL
)
2484 // Note that we skip the last parameter, which is the boolean
2485 // indicating whether recover can succed.
2486 for (Typed_identifier_list::const_iterator p
= new_params
->begin();
2487 p
+ 1 != new_params
->end();
2490 Named_object
* p_no
= gogo
->lookup(p
->name(), NULL
);
2491 go_assert(p_no
!= NULL
2492 && p_no
->is_variable()
2493 && p_no
->var_value()->is_parameter());
2494 args
->push_back(Expression::make_var_reference(p_no
, location
));
2497 args
->push_back(this->can_recover_arg(location
));
2499 gogo
->start_block(location
);
2501 Call_expression
* call
= Expression::make_call(fn
, args
, false, location
);
2504 if (orig_fntype
->results() == NULL
|| orig_fntype
->results()->empty())
2505 s
= Statement::make_statement(call
, true);
2508 Expression_list
* vals
= new Expression_list();
2509 size_t rc
= orig_fntype
->results()->size();
2511 vals
->push_back(call
);
2514 for (size_t i
= 0; i
< rc
; ++i
)
2515 vals
->push_back(Expression::make_call_result(call
, i
));
2517 s
= Statement::make_return_statement(vals
, location
);
2519 s
->determine_types();
2520 gogo
->add_statement(s
);
2522 Block
* b
= gogo
->finish_block(location
);
2524 gogo
->add_block(b
, location
);
2526 // Lower the call in case it returns multiple results.
2527 gogo
->lower_block(new_no
, b
);
2529 gogo
->finish_function(location
);
2531 // Swap the function bodies and types.
2532 new_func
->swap_for_recover(orig_func
);
2533 orig_func
->set_is_recover_thunk();
2534 new_func
->set_calls_recover();
2535 new_func
->set_has_recover_thunk();
2537 Bindings
* orig_bindings
= orig_func
->block()->bindings();
2538 Bindings
* new_bindings
= new_func
->block()->bindings();
2539 if (orig_fntype
->is_method())
2541 // We changed the receiver to be a regular parameter. We have
2542 // to update the binding accordingly in both functions.
2543 Named_object
* orig_rec_no
= orig_bindings
->lookup_local(receiver_name
);
2544 go_assert(orig_rec_no
!= NULL
2545 && orig_rec_no
->is_variable()
2546 && !orig_rec_no
->var_value()->is_receiver());
2547 orig_rec_no
->var_value()->set_is_receiver();
2549 const std::string
& new_receiver_name(orig_fntype
->receiver()->name());
2550 Named_object
* new_rec_no
= new_bindings
->lookup_local(new_receiver_name
);
2551 if (new_rec_no
== NULL
)
2552 go_assert(saw_errors());
2555 go_assert(new_rec_no
->is_variable()
2556 && new_rec_no
->var_value()->is_receiver());
2557 new_rec_no
->var_value()->set_is_not_receiver();
2561 // Because we flipped blocks but not types, the can_recover
2562 // parameter appears in the (now) old bindings as a parameter.
2563 // Change it to a local variable, whereupon it will be discarded.
2564 Named_object
* can_recover_no
= orig_bindings
->lookup_local(can_recover_name
);
2565 go_assert(can_recover_no
!= NULL
2566 && can_recover_no
->is_variable()
2567 && can_recover_no
->var_value()->is_parameter());
2568 orig_bindings
->remove_binding(can_recover_no
);
2570 // Add the can_recover argument to the (now) new bindings, and
2571 // attach it to any recover statements.
2572 Variable
* can_recover_var
= new Variable(Type::lookup_bool_type(), NULL
,
2573 false, true, false, location
);
2574 can_recover_no
= new_bindings
->add_variable(can_recover_name
, NULL
,
2576 Convert_recover
convert_recover(can_recover_no
);
2577 new_func
->traverse(&convert_recover
);
2579 // Update the function pointers in any named results.
2580 new_func
->update_result_variables();
2581 orig_func
->update_result_variables();
2583 return TRAVERSE_CONTINUE
;
2586 // Return the expression to pass for the .can_recover parameter to the
2587 // new function. This indicates whether a call to recover may return
2588 // non-nil. The expression is
2589 // __go_can_recover(__builtin_return_address()).
2592 Build_recover_thunks::can_recover_arg(Location location
)
2594 static Named_object
* builtin_return_address
;
2595 if (builtin_return_address
== NULL
)
2597 const Location bloc
= Linemap::predeclared_location();
2599 Typed_identifier_list
* param_types
= new Typed_identifier_list();
2600 Type
* uint_type
= Type::lookup_integer_type("uint");
2601 param_types
->push_back(Typed_identifier("l", uint_type
, bloc
));
2603 Typed_identifier_list
* return_types
= new Typed_identifier_list();
2604 Type
* voidptr_type
= Type::make_pointer_type(Type::make_void_type());
2605 return_types
->push_back(Typed_identifier("", voidptr_type
, bloc
));
2607 Function_type
* fntype
= Type::make_function_type(NULL
, param_types
,
2608 return_types
, bloc
);
2609 builtin_return_address
=
2610 Named_object::make_function_declaration("__builtin_return_address",
2611 NULL
, fntype
, bloc
);
2612 const char* n
= "__builtin_return_address";
2613 builtin_return_address
->func_declaration_value()->set_asm_name(n
);
2616 static Named_object
* can_recover
;
2617 if (can_recover
== NULL
)
2619 const Location bloc
= Linemap::predeclared_location();
2620 Typed_identifier_list
* param_types
= new Typed_identifier_list();
2621 Type
* voidptr_type
= Type::make_pointer_type(Type::make_void_type());
2622 param_types
->push_back(Typed_identifier("a", voidptr_type
, bloc
));
2623 Type
* boolean_type
= Type::lookup_bool_type();
2624 Typed_identifier_list
* results
= new Typed_identifier_list();
2625 results
->push_back(Typed_identifier("", boolean_type
, bloc
));
2626 Function_type
* fntype
= Type::make_function_type(NULL
, param_types
,
2628 can_recover
= Named_object::make_function_declaration("__go_can_recover",
2631 can_recover
->func_declaration_value()->set_asm_name("__go_can_recover");
2634 Expression
* fn
= Expression::make_func_reference(builtin_return_address
,
2638 mpz_init_set_ui(zval
, 0UL);
2639 Expression
* zexpr
= Expression::make_integer(&zval
, NULL
, location
);
2641 Expression_list
*args
= new Expression_list();
2642 args
->push_back(zexpr
);
2644 Expression
* call
= Expression::make_call(fn
, args
, false, location
);
2646 args
= new Expression_list();
2647 args
->push_back(call
);
2649 fn
= Expression::make_func_reference(can_recover
, NULL
, location
);
2650 return Expression::make_call(fn
, args
, false, location
);
2653 // Build thunks for functions which call recover. We build a new
2654 // function with an extra parameter, which is whether a call to
2655 // recover can succeed. We then move the body of this function to
2656 // that one. We then turn this function into a thunk which calls the
2657 // new one, passing the value of
2658 // __go_can_recover(__builtin_return_address()). The function will be
2659 // marked as not splitting the stack. This will cooperate with the
2660 // implementation of defer to make recover do the right thing.
2663 Gogo::build_recover_thunks()
2665 Build_recover_thunks
build_recover_thunks(this);
2666 this->traverse(&build_recover_thunks
);
2669 // Look for named types to see whether we need to create an interface
2672 class Build_method_tables
: public Traverse
2675 Build_method_tables(Gogo
* gogo
,
2676 const std::vector
<Interface_type
*>& interfaces
)
2677 : Traverse(traverse_types
),
2678 gogo_(gogo
), interfaces_(interfaces
)
2687 // A list of locally defined interfaces which have hidden methods.
2688 const std::vector
<Interface_type
*>& interfaces_
;
2691 // Build all required interface method tables for types. We need to
2692 // ensure that we have an interface method table for every interface
2693 // which has a hidden method, for every named type which implements
2694 // that interface. Normally we can just build interface method tables
2695 // as we need them. However, in some cases we can require an
2696 // interface method table for an interface defined in a different
2697 // package for a type defined in that package. If that interface and
2698 // type both use a hidden method, that is OK. However, we will not be
2699 // able to build that interface method table when we need it, because
2700 // the type's hidden method will be static. So we have to build it
2701 // here, and just refer it from other packages as needed.
2704 Gogo::build_interface_method_tables()
2709 std::vector
<Interface_type
*> hidden_interfaces
;
2710 hidden_interfaces
.reserve(this->interface_types_
.size());
2711 for (std::vector
<Interface_type
*>::const_iterator pi
=
2712 this->interface_types_
.begin();
2713 pi
!= this->interface_types_
.end();
2716 const Typed_identifier_list
* methods
= (*pi
)->methods();
2717 if (methods
== NULL
)
2719 for (Typed_identifier_list::const_iterator pm
= methods
->begin();
2720 pm
!= methods
->end();
2723 if (Gogo::is_hidden_name(pm
->name()))
2725 hidden_interfaces
.push_back(*pi
);
2731 if (!hidden_interfaces
.empty())
2733 // Now traverse the tree looking for all named types.
2734 Build_method_tables
bmt(this, hidden_interfaces
);
2735 this->traverse(&bmt
);
2738 // We no longer need the list of interfaces.
2740 this->interface_types_
.clear();
2743 // This is called for each type. For a named type, for each of the
2744 // interfaces with hidden methods that it implements, create the
2748 Build_method_tables::type(Type
* type
)
2750 Named_type
* nt
= type
->named_type();
2753 for (std::vector
<Interface_type
*>::const_iterator p
=
2754 this->interfaces_
.begin();
2755 p
!= this->interfaces_
.end();
2758 // We ask whether a pointer to the named type implements the
2759 // interface, because a pointer can implement more methods
2761 if ((*p
)->implements_interface(Type::make_pointer_type(nt
), NULL
))
2763 nt
->interface_method_table(this->gogo_
, *p
, false);
2764 nt
->interface_method_table(this->gogo_
, *p
, true);
2768 return TRAVERSE_CONTINUE
;
2771 // Traversal class used to check for return statements.
2773 class Check_return_statements_traverse
: public Traverse
2776 Check_return_statements_traverse()
2777 : Traverse(traverse_functions
)
2781 function(Named_object
*);
2784 // Check that a function has a return statement if it needs one.
2787 Check_return_statements_traverse::function(Named_object
* no
)
2789 Function
* func
= no
->func_value();
2790 const Function_type
* fntype
= func
->type();
2791 const Typed_identifier_list
* results
= fntype
->results();
2793 // We only need a return statement if there is a return value.
2794 if (results
== NULL
|| results
->empty())
2795 return TRAVERSE_CONTINUE
;
2797 if (func
->block()->may_fall_through())
2798 error_at(func
->location(), "control reaches end of non-void function");
2800 return TRAVERSE_CONTINUE
;
2803 // Check return statements.
2806 Gogo::check_return_statements()
2808 Check_return_statements_traverse traverse
;
2809 this->traverse(&traverse
);
2812 // Get the unique prefix to use before all exported symbols. This
2813 // must be unique across the entire link.
2816 Gogo::unique_prefix() const
2818 go_assert(!this->unique_prefix_
.empty());
2819 return this->unique_prefix_
;
2822 // Set the unique prefix to use before all exported symbols. This
2823 // comes from the command line option -fgo-prefix=XXX.
2826 Gogo::set_unique_prefix(const std::string
& arg
)
2828 go_assert(this->unique_prefix_
.empty());
2829 this->unique_prefix_
= arg
;
2830 this->unique_prefix_specified_
= true;
2833 // Work out the package priority. It is one more than the maximum
2834 // priority of an imported package.
2837 Gogo::package_priority() const
2840 for (Packages::const_iterator p
= this->packages_
.begin();
2841 p
!= this->packages_
.end();
2843 if (p
->second
->priority() > priority
)
2844 priority
= p
->second
->priority();
2845 return priority
+ 1;
2848 // Export identifiers as requested.
2853 // For now we always stream to a section. Later we may want to
2854 // support streaming to a separate file.
2855 Stream_to_section stream
;
2857 Export
exp(&stream
);
2858 exp
.register_builtin_types(this);
2859 exp
.export_globals(this->package_name(),
2860 this->unique_prefix(),
2861 this->package_priority(),
2862 (this->need_init_fn_
&& !this->is_main_package()
2863 ? this->get_init_fn_name()
2865 this->imported_init_fns_
,
2866 this->package_
->bindings());
2869 // Find the blocks in order to convert named types defined in blocks.
2871 class Convert_named_types
: public Traverse
2874 Convert_named_types(Gogo
* gogo
)
2875 : Traverse(traverse_blocks
),
2881 block(Block
* block
);
2888 Convert_named_types::block(Block
* block
)
2890 this->gogo_
->convert_named_types_in_bindings(block
->bindings());
2891 return TRAVERSE_CONTINUE
;
2894 // Convert all named types to the backend representation. Since named
2895 // types can refer to other types, this needs to be done in the right
2896 // sequence, which is handled by Named_type::convert. Here we arrange
2897 // to call that for each named type.
2900 Gogo::convert_named_types()
2902 this->convert_named_types_in_bindings(this->globals_
);
2903 for (Packages::iterator p
= this->packages_
.begin();
2904 p
!= this->packages_
.end();
2907 Package
* package
= p
->second
;
2908 this->convert_named_types_in_bindings(package
->bindings());
2911 Convert_named_types
cnt(this);
2912 this->traverse(&cnt
);
2914 // Make all the builtin named types used for type descriptors, and
2915 // then convert them. They will only be written out if they are
2917 Type::make_type_descriptor_type();
2918 Type::make_type_descriptor_ptr_type();
2919 Function_type::make_function_type_descriptor_type();
2920 Pointer_type::make_pointer_type_descriptor_type();
2921 Struct_type::make_struct_type_descriptor_type();
2922 Array_type::make_array_type_descriptor_type();
2923 Array_type::make_slice_type_descriptor_type();
2924 Map_type::make_map_type_descriptor_type();
2925 Map_type::make_map_descriptor_type();
2926 Channel_type::make_chan_type_descriptor_type();
2927 Interface_type::make_interface_type_descriptor_type();
2928 Type::convert_builtin_named_types(this);
2930 Runtime::convert_types(this);
2932 Function_type::convert_types(this);
2934 this->named_types_are_converted_
= true;
2937 // Convert all names types in a set of bindings.
2940 Gogo::convert_named_types_in_bindings(Bindings
* bindings
)
2942 for (Bindings::const_definitions_iterator p
= bindings
->begin_definitions();
2943 p
!= bindings
->end_definitions();
2946 if ((*p
)->is_type())
2947 (*p
)->type_value()->convert(this);
2953 Function::Function(Function_type
* type
, Function
* enclosing
, Block
* block
,
2955 : type_(type
), enclosing_(enclosing
), results_(NULL
),
2956 closure_var_(NULL
), block_(block
), location_(location
), fndecl_(NULL
),
2957 defer_stack_(NULL
), results_are_named_(false), calls_recover_(false),
2958 is_recover_thunk_(false), has_recover_thunk_(false)
2962 // Create the named result variables.
2965 Function::create_result_variables(Gogo
* gogo
)
2967 const Typed_identifier_list
* results
= this->type_
->results();
2968 if (results
== NULL
|| results
->empty())
2971 if (!results
->front().name().empty())
2972 this->results_are_named_
= true;
2974 this->results_
= new Results();
2975 this->results_
->reserve(results
->size());
2977 Block
* block
= this->block_
;
2979 for (Typed_identifier_list::const_iterator p
= results
->begin();
2980 p
!= results
->end();
2983 std::string name
= p
->name();
2984 if (name
.empty() || Gogo::is_sink_name(name
))
2986 static int result_counter
;
2988 snprintf(buf
, sizeof buf
, "$ret%d", result_counter
);
2990 name
= gogo
->pack_hidden_name(buf
, false);
2992 Result_variable
* result
= new Result_variable(p
->type(), this, index
,
2994 Named_object
* no
= block
->bindings()->add_result_variable(name
, result
);
2995 if (no
->is_result_variable())
2996 this->results_
->push_back(no
);
2999 static int dummy_result_count
;
3001 snprintf(buf
, sizeof buf
, "$dret%d", dummy_result_count
);
3002 ++dummy_result_count
;
3003 name
= gogo
->pack_hidden_name(buf
, false);
3004 no
= block
->bindings()->add_result_variable(name
, result
);
3005 go_assert(no
->is_result_variable());
3006 this->results_
->push_back(no
);
3011 // Update the named result variables when cloning a function which
3015 Function::update_result_variables()
3017 if (this->results_
== NULL
)
3020 for (Results::iterator p
= this->results_
->begin();
3021 p
!= this->results_
->end();
3023 (*p
)->result_var_value()->set_function(this);
3026 // Return the closure variable, creating it if necessary.
3029 Function::closure_var()
3031 if (this->closure_var_
== NULL
)
3033 // We don't know the type of the variable yet. We add fields as
3035 Location loc
= this->type_
->location();
3036 Struct_field_list
* sfl
= new Struct_field_list
;
3037 Type
* struct_type
= Type::make_struct_type(sfl
, loc
);
3038 Variable
* var
= new Variable(Type::make_pointer_type(struct_type
),
3039 NULL
, false, true, false, loc
);
3041 this->closure_var_
= Named_object::make_variable("closure", NULL
, var
);
3042 // Note that the new variable is not in any binding contour.
3044 return this->closure_var_
;
3047 // Set the type of the closure variable.
3050 Function::set_closure_type()
3052 if (this->closure_var_
== NULL
)
3054 Named_object
* closure
= this->closure_var_
;
3055 Struct_type
* st
= closure
->var_value()->type()->deref()->struct_type();
3056 unsigned int index
= 0;
3057 for (Closure_fields::const_iterator p
= this->closure_fields_
.begin();
3058 p
!= this->closure_fields_
.end();
3061 Named_object
* no
= p
->first
;
3063 snprintf(buf
, sizeof buf
, "%u", index
);
3064 std::string n
= no
->name() + buf
;
3066 if (no
->is_variable())
3067 var_type
= no
->var_value()->type();
3069 var_type
= no
->result_var_value()->type();
3070 Type
* field_type
= Type::make_pointer_type(var_type
);
3071 st
->push_field(Struct_field(Typed_identifier(n
, field_type
, p
->second
)));
3075 // Return whether this function is a method.
3078 Function::is_method() const
3080 return this->type_
->is_method();
3083 // Add a label definition.
3086 Function::add_label_definition(Gogo
* gogo
, const std::string
& label_name
,
3089 Label
* lnull
= NULL
;
3090 std::pair
<Labels::iterator
, bool> ins
=
3091 this->labels_
.insert(std::make_pair(label_name
, lnull
));
3095 // This is a new label.
3096 label
= new Label(label_name
);
3097 ins
.first
->second
= label
;
3101 // The label was already in the hash table.
3102 label
= ins
.first
->second
;
3103 if (label
->is_defined())
3105 error_at(location
, "label %qs already defined",
3106 Gogo::message_name(label_name
).c_str());
3107 inform(label
->location(), "previous definition of %qs was here",
3108 Gogo::message_name(label_name
).c_str());
3109 return new Label(label_name
);
3113 label
->define(location
, gogo
->bindings_snapshot(location
));
3115 // Issue any errors appropriate for any previous goto's to this
3117 const std::vector
<Bindings_snapshot
*>& refs(label
->refs());
3118 for (std::vector
<Bindings_snapshot
*>::const_iterator p
= refs
.begin();
3121 (*p
)->check_goto_to(gogo
->current_block());
3122 label
->clear_refs();
3127 // Add a reference to a label.
3130 Function::add_label_reference(Gogo
* gogo
, const std::string
& label_name
,
3131 Location location
, bool issue_goto_errors
)
3133 Label
* lnull
= NULL
;
3134 std::pair
<Labels::iterator
, bool> ins
=
3135 this->labels_
.insert(std::make_pair(label_name
, lnull
));
3139 // The label was already in the hash table.
3140 label
= ins
.first
->second
;
3144 go_assert(ins
.first
->second
== NULL
);
3145 label
= new Label(label_name
);
3146 ins
.first
->second
= label
;
3149 label
->set_is_used();
3151 if (issue_goto_errors
)
3153 Bindings_snapshot
* snapshot
= label
->snapshot();
3154 if (snapshot
!= NULL
)
3155 snapshot
->check_goto_from(gogo
->current_block(), location
);
3157 label
->add_snapshot_ref(gogo
->bindings_snapshot(location
));
3163 // Warn about labels that are defined but not used.
3166 Function::check_labels() const
3168 for (Labels::const_iterator p
= this->labels_
.begin();
3169 p
!= this->labels_
.end();
3172 Label
* label
= p
->second
;
3173 if (!label
->is_used())
3174 error_at(label
->location(), "label %qs defined and not used",
3175 Gogo::message_name(label
->name()).c_str());
3179 // Swap one function with another. This is used when building the
3180 // thunk we use to call a function which calls recover. It may not
3181 // work for any other case.
3184 Function::swap_for_recover(Function
*x
)
3186 go_assert(this->enclosing_
== x
->enclosing_
);
3187 std::swap(this->results_
, x
->results_
);
3188 std::swap(this->closure_var_
, x
->closure_var_
);
3189 std::swap(this->block_
, x
->block_
);
3190 go_assert(this->location_
== x
->location_
);
3191 go_assert(this->fndecl_
== NULL
&& x
->fndecl_
== NULL
);
3192 go_assert(this->defer_stack_
== NULL
&& x
->defer_stack_
== NULL
);
3195 // Traverse the tree.
3198 Function::traverse(Traverse
* traverse
)
3200 unsigned int traverse_mask
= traverse
->traverse_mask();
3203 & (Traverse::traverse_types
| Traverse::traverse_expressions
))
3206 if (Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
3207 return TRAVERSE_EXIT
;
3210 // FIXME: We should check traverse_functions here if nested
3211 // functions are stored in block bindings.
3212 if (this->block_
!= NULL
3214 & (Traverse::traverse_variables
3215 | Traverse::traverse_constants
3216 | Traverse::traverse_blocks
3217 | Traverse::traverse_statements
3218 | Traverse::traverse_expressions
3219 | Traverse::traverse_types
)) != 0)
3221 if (this->block_
->traverse(traverse
) == TRAVERSE_EXIT
)
3222 return TRAVERSE_EXIT
;
3225 return TRAVERSE_CONTINUE
;
3228 // Work out types for unspecified variables and constants.
3231 Function::determine_types()
3233 if (this->block_
!= NULL
)
3234 this->block_
->determine_types();
3237 // Get a pointer to the variable representing the defer stack for this
3238 // function, making it if necessary. The value of the variable is set
3239 // by the runtime routines to true if the function is returning,
3240 // rather than panicing through. A pointer to this variable is used
3241 // as a marker for the functions on the defer stack associated with
3242 // this function. A function-specific variable permits inlining a
3243 // function which uses defer.
3246 Function::defer_stack(Location location
)
3248 if (this->defer_stack_
== NULL
)
3250 Type
* t
= Type::lookup_bool_type();
3251 Expression
* n
= Expression::make_boolean(false, location
);
3252 this->defer_stack_
= Statement::make_temporary(t
, n
, location
);
3253 this->defer_stack_
->set_is_address_taken();
3255 Expression
* ref
= Expression::make_temporary_reference(this->defer_stack_
,
3257 return Expression::make_unary(OPERATOR_AND
, ref
, location
);
3260 // Export the function.
3263 Function::export_func(Export
* exp
, const std::string
& name
) const
3265 Function::export_func_with_type(exp
, name
, this->type_
);
3268 // Export a function with a type.
3271 Function::export_func_with_type(Export
* exp
, const std::string
& name
,
3272 const Function_type
* fntype
)
3274 exp
->write_c_string("func ");
3276 if (fntype
->is_method())
3278 exp
->write_c_string("(");
3279 exp
->write_type(fntype
->receiver()->type());
3280 exp
->write_c_string(") ");
3283 exp
->write_string(name
);
3285 exp
->write_c_string(" (");
3286 const Typed_identifier_list
* parameters
= fntype
->parameters();
3287 if (parameters
!= NULL
)
3289 bool is_varargs
= fntype
->is_varargs();
3291 for (Typed_identifier_list::const_iterator p
= parameters
->begin();
3292 p
!= parameters
->end();
3298 exp
->write_c_string(", ");
3299 if (!is_varargs
|| p
+ 1 != parameters
->end())
3300 exp
->write_type(p
->type());
3303 exp
->write_c_string("...");
3304 exp
->write_type(p
->type()->array_type()->element_type());
3308 exp
->write_c_string(")");
3310 const Typed_identifier_list
* results
= fntype
->results();
3311 if (results
!= NULL
)
3313 if (results
->size() == 1)
3315 exp
->write_c_string(" ");
3316 exp
->write_type(results
->begin()->type());
3320 exp
->write_c_string(" (");
3322 for (Typed_identifier_list::const_iterator p
= results
->begin();
3323 p
!= results
->end();
3329 exp
->write_c_string(", ");
3330 exp
->write_type(p
->type());
3332 exp
->write_c_string(")");
3335 exp
->write_c_string(";\n");
3338 // Import a function.
3341 Function::import_func(Import
* imp
, std::string
* pname
,
3342 Typed_identifier
** preceiver
,
3343 Typed_identifier_list
** pparameters
,
3344 Typed_identifier_list
** presults
,
3347 imp
->require_c_string("func ");
3350 if (imp
->peek_char() == '(')
3352 imp
->require_c_string("(");
3353 Type
* rtype
= imp
->read_type();
3354 *preceiver
= new Typed_identifier(Import::import_marker
, rtype
,
3356 imp
->require_c_string(") ");
3359 *pname
= imp
->read_identifier();
3361 Typed_identifier_list
* parameters
;
3362 *is_varargs
= false;
3363 imp
->require_c_string(" (");
3364 if (imp
->peek_char() == ')')
3368 parameters
= new Typed_identifier_list();
3371 if (imp
->match_c_string("..."))
3377 Type
* ptype
= imp
->read_type();
3379 ptype
= Type::make_array_type(ptype
, NULL
);
3380 parameters
->push_back(Typed_identifier(Import::import_marker
,
3381 ptype
, imp
->location()));
3382 if (imp
->peek_char() != ',')
3384 go_assert(!*is_varargs
);
3385 imp
->require_c_string(", ");
3388 imp
->require_c_string(")");
3389 *pparameters
= parameters
;
3391 Typed_identifier_list
* results
;
3392 if (imp
->peek_char() != ' ')
3396 results
= new Typed_identifier_list();
3397 imp
->require_c_string(" ");
3398 if (imp
->peek_char() != '(')
3400 Type
* rtype
= imp
->read_type();
3401 results
->push_back(Typed_identifier(Import::import_marker
, rtype
,
3406 imp
->require_c_string("(");
3409 Type
* rtype
= imp
->read_type();
3410 results
->push_back(Typed_identifier(Import::import_marker
,
3411 rtype
, imp
->location()));
3412 if (imp
->peek_char() != ',')
3414 imp
->require_c_string(", ");
3416 imp
->require_c_string(")");
3419 imp
->require_c_string(";\n");
3420 *presults
= results
;
3425 Block::Block(Block
* enclosing
, Location location
)
3426 : enclosing_(enclosing
), statements_(),
3427 bindings_(new Bindings(enclosing
== NULL
3429 : enclosing
->bindings())),
3430 start_location_(location
),
3431 end_location_(UNKNOWN_LOCATION
)
3435 // Add a statement to a block.
3438 Block::add_statement(Statement
* statement
)
3440 this->statements_
.push_back(statement
);
3443 // Add a statement to the front of a block. This is slow but is only
3444 // used for reference counts of parameters.
3447 Block::add_statement_at_front(Statement
* statement
)
3449 this->statements_
.insert(this->statements_
.begin(), statement
);
3452 // Replace a statement in a block.
3455 Block::replace_statement(size_t index
, Statement
* s
)
3457 go_assert(index
< this->statements_
.size());
3458 this->statements_
[index
] = s
;
3461 // Add a statement before another statement.
3464 Block::insert_statement_before(size_t index
, Statement
* s
)
3466 go_assert(index
< this->statements_
.size());
3467 this->statements_
.insert(this->statements_
.begin() + index
, s
);
3470 // Add a statement after another statement.
3473 Block::insert_statement_after(size_t index
, Statement
* s
)
3475 go_assert(index
< this->statements_
.size());
3476 this->statements_
.insert(this->statements_
.begin() + index
+ 1, s
);
3479 // Traverse the tree.
3482 Block::traverse(Traverse
* traverse
)
3484 unsigned int traverse_mask
= traverse
->traverse_mask();
3486 if ((traverse_mask
& Traverse::traverse_blocks
) != 0)
3488 int t
= traverse
->block(this);
3489 if (t
== TRAVERSE_EXIT
)
3490 return TRAVERSE_EXIT
;
3491 else if (t
== TRAVERSE_SKIP_COMPONENTS
)
3492 return TRAVERSE_CONTINUE
;
3496 & (Traverse::traverse_variables
3497 | Traverse::traverse_constants
3498 | Traverse::traverse_expressions
3499 | Traverse::traverse_types
)) != 0)
3501 const unsigned int e_or_t
= (Traverse::traverse_expressions
3502 | Traverse::traverse_types
);
3503 const unsigned int e_or_t_or_s
= (e_or_t
3504 | Traverse::traverse_statements
);
3505 for (Bindings::const_definitions_iterator pb
=
3506 this->bindings_
->begin_definitions();
3507 pb
!= this->bindings_
->end_definitions();
3510 int t
= TRAVERSE_CONTINUE
;
3511 switch ((*pb
)->classification())
3513 case Named_object::NAMED_OBJECT_CONST
:
3514 if ((traverse_mask
& Traverse::traverse_constants
) != 0)
3515 t
= traverse
->constant(*pb
, false);
3516 if (t
== TRAVERSE_CONTINUE
3517 && (traverse_mask
& e_or_t
) != 0)
3519 Type
* tc
= (*pb
)->const_value()->type();
3521 && Type::traverse(tc
, traverse
) == TRAVERSE_EXIT
)
3522 return TRAVERSE_EXIT
;
3523 t
= (*pb
)->const_value()->traverse_expression(traverse
);
3527 case Named_object::NAMED_OBJECT_VAR
:
3528 case Named_object::NAMED_OBJECT_RESULT_VAR
:
3529 if ((traverse_mask
& Traverse::traverse_variables
) != 0)
3530 t
= traverse
->variable(*pb
);
3531 if (t
== TRAVERSE_CONTINUE
3532 && (traverse_mask
& e_or_t
) != 0)
3534 if ((*pb
)->is_result_variable()
3535 || (*pb
)->var_value()->has_type())
3537 Type
* tv
= ((*pb
)->is_variable()
3538 ? (*pb
)->var_value()->type()
3539 : (*pb
)->result_var_value()->type());
3541 && Type::traverse(tv
, traverse
) == TRAVERSE_EXIT
)
3542 return TRAVERSE_EXIT
;
3545 if (t
== TRAVERSE_CONTINUE
3546 && (traverse_mask
& e_or_t_or_s
) != 0
3547 && (*pb
)->is_variable())
3548 t
= (*pb
)->var_value()->traverse_expression(traverse
,
3552 case Named_object::NAMED_OBJECT_FUNC
:
3553 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
3556 case Named_object::NAMED_OBJECT_TYPE
:
3557 if ((traverse_mask
& e_or_t
) != 0)
3558 t
= Type::traverse((*pb
)->type_value(), traverse
);
3561 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
3562 case Named_object::NAMED_OBJECT_UNKNOWN
:
3563 case Named_object::NAMED_OBJECT_ERRONEOUS
:
3566 case Named_object::NAMED_OBJECT_PACKAGE
:
3567 case Named_object::NAMED_OBJECT_SINK
:
3574 if (t
== TRAVERSE_EXIT
)
3575 return TRAVERSE_EXIT
;
3579 // No point in checking traverse_mask here--if we got here we always
3580 // want to walk the statements. The traversal can insert new
3581 // statements before or after the current statement. Inserting
3582 // statements before the current statement requires updating I via
3583 // the pointer; those statements will not be traversed. Any new
3584 // statements inserted after the current statement will be traversed
3586 for (size_t i
= 0; i
< this->statements_
.size(); ++i
)
3588 if (this->statements_
[i
]->traverse(this, &i
, traverse
) == TRAVERSE_EXIT
)
3589 return TRAVERSE_EXIT
;
3592 return TRAVERSE_CONTINUE
;
3595 // Work out types for unspecified variables and constants.
3598 Block::determine_types()
3600 for (Bindings::const_definitions_iterator pb
=
3601 this->bindings_
->begin_definitions();
3602 pb
!= this->bindings_
->end_definitions();
3605 if ((*pb
)->is_variable())
3606 (*pb
)->var_value()->determine_type();
3607 else if ((*pb
)->is_const())
3608 (*pb
)->const_value()->determine_type();
3611 for (std::vector
<Statement
*>::const_iterator ps
= this->statements_
.begin();
3612 ps
!= this->statements_
.end();
3614 (*ps
)->determine_types();
3617 // Return true if the statements in this block may fall through.
3620 Block::may_fall_through() const
3622 if (this->statements_
.empty())
3624 return this->statements_
.back()->may_fall_through();
3627 // Convert a block to the backend representation.
3630 Block::get_backend(Translate_context
* context
)
3632 Gogo
* gogo
= context
->gogo();
3633 Named_object
* function
= context
->function();
3634 std::vector
<Bvariable
*> vars
;
3635 vars
.reserve(this->bindings_
->size_definitions());
3636 for (Bindings::const_definitions_iterator pv
=
3637 this->bindings_
->begin_definitions();
3638 pv
!= this->bindings_
->end_definitions();
3641 if ((*pv
)->is_variable() && !(*pv
)->var_value()->is_parameter())
3642 vars
.push_back((*pv
)->get_backend_variable(gogo
, function
));
3645 // FIXME: Permitting FUNCTION to be NULL here is a temporary measure
3646 // until we have a proper representation of the init function.
3647 Bfunction
* bfunction
;
3648 if (function
== NULL
)
3651 bfunction
= tree_to_function(function
->func_value()->get_decl());
3652 Bblock
* ret
= context
->backend()->block(bfunction
, context
->bblock(),
3653 vars
, this->start_location_
,
3654 this->end_location_
);
3656 Translate_context
subcontext(gogo
, function
, this, ret
);
3657 std::vector
<Bstatement
*> bstatements
;
3658 bstatements
.reserve(this->statements_
.size());
3659 for (std::vector
<Statement
*>::const_iterator p
= this->statements_
.begin();
3660 p
!= this->statements_
.end();
3662 bstatements
.push_back((*p
)->get_backend(&subcontext
));
3664 context
->backend()->block_add_statements(ret
, bstatements
);
3669 // Class Bindings_snapshot.
3671 Bindings_snapshot::Bindings_snapshot(const Block
* b
, Location location
)
3672 : block_(b
), counts_(), location_(location
)
3676 this->counts_
.push_back(b
->bindings()->size_definitions());
3681 // Report errors appropriate for a goto from B to this.
3684 Bindings_snapshot::check_goto_from(const Block
* b
, Location loc
)
3687 if (!this->check_goto_block(loc
, b
, this->block_
, &dummy
))
3689 this->check_goto_defs(loc
, this->block_
,
3690 this->block_
->bindings()->size_definitions(),
3694 // Report errors appropriate for a goto from this to B.
3697 Bindings_snapshot::check_goto_to(const Block
* b
)
3700 if (!this->check_goto_block(this->location_
, this->block_
, b
, &index
))
3702 this->check_goto_defs(this->location_
, b
, this->counts_
[index
],
3703 b
->bindings()->size_definitions());
3706 // Report errors appropriate for a goto at LOC from BFROM to BTO.
3707 // Return true if all is well, false if we reported an error. If this
3708 // returns true, it sets *PINDEX to the number of blocks BTO is above
3712 Bindings_snapshot::check_goto_block(Location loc
, const Block
* bfrom
,
3713 const Block
* bto
, size_t* pindex
)
3715 // It is an error if BTO is not either BFROM or above BFROM.
3717 for (const Block
* pb
= bfrom
; pb
!= bto
; pb
= pb
->enclosing(), ++index
)
3721 error_at(loc
, "goto jumps into block");
3722 inform(bto
->start_location(), "goto target block starts here");
3730 // Report errors appropriate for a goto at LOC ending at BLOCK, where
3731 // CFROM is the number of names defined at the point of the goto and
3732 // CTO is the number of names defined at the point of the label.
3735 Bindings_snapshot::check_goto_defs(Location loc
, const Block
* block
,
3736 size_t cfrom
, size_t cto
)
3740 Bindings::const_definitions_iterator p
=
3741 block
->bindings()->begin_definitions();
3742 for (size_t i
= 0; i
< cfrom
; ++i
)
3744 go_assert(p
!= block
->bindings()->end_definitions());
3747 go_assert(p
!= block
->bindings()->end_definitions());
3749 std::string n
= (*p
)->message_name();
3750 error_at(loc
, "goto jumps over declaration of %qs", n
.c_str());
3751 inform((*p
)->location(), "%qs defined here", n
.c_str());
3757 Variable::Variable(Type
* type
, Expression
* init
, bool is_global
,
3758 bool is_parameter
, bool is_receiver
,
3760 : type_(type
), init_(init
), preinit_(NULL
), location_(location
),
3761 backend_(NULL
), is_global_(is_global
), is_parameter_(is_parameter
),
3762 is_receiver_(is_receiver
), is_varargs_parameter_(false), is_used_(false),
3763 is_address_taken_(false), is_non_escaping_address_taken_(false),
3764 seen_(false), init_is_lowered_(false), type_from_init_tuple_(false),
3765 type_from_range_index_(false), type_from_range_value_(false),
3766 type_from_chan_element_(false), is_type_switch_var_(false),
3767 determined_type_(false)
3769 go_assert(type
!= NULL
|| init
!= NULL
);
3770 go_assert(!is_parameter
|| init
== NULL
);
3773 // Traverse the initializer expression.
3776 Variable::traverse_expression(Traverse
* traverse
, unsigned int traverse_mask
)
3778 if (this->preinit_
!= NULL
)
3780 if (this->preinit_
->traverse(traverse
) == TRAVERSE_EXIT
)
3781 return TRAVERSE_EXIT
;
3783 if (this->init_
!= NULL
3785 & (Traverse::traverse_expressions
| Traverse::traverse_types
))
3788 if (Expression::traverse(&this->init_
, traverse
) == TRAVERSE_EXIT
)
3789 return TRAVERSE_EXIT
;
3791 return TRAVERSE_CONTINUE
;
3794 // Lower the initialization expression after parsing is complete.
3797 Variable::lower_init_expression(Gogo
* gogo
, Named_object
* function
,
3798 Statement_inserter
* inserter
)
3800 if (this->init_
!= NULL
&& !this->init_is_lowered_
)
3804 // We will give an error elsewhere, this is just to prevent
3805 // an infinite loop.
3810 Statement_inserter global_inserter
;
3811 if (this->is_global_
)
3813 global_inserter
= Statement_inserter(gogo
, this);
3814 inserter
= &global_inserter
;
3817 gogo
->lower_expression(function
, inserter
, &this->init_
);
3819 this->seen_
= false;
3821 this->init_is_lowered_
= true;
3825 // Get the preinit block.
3828 Variable::preinit_block(Gogo
* gogo
)
3830 go_assert(this->is_global_
);
3831 if (this->preinit_
== NULL
)
3832 this->preinit_
= new Block(NULL
, this->location());
3834 // If a global variable has a preinitialization statement, then we
3835 // need to have an initialization function.
3836 gogo
->set_need_init_fn();
3838 return this->preinit_
;
3841 // Add a statement to be run before the initialization expression.
3844 Variable::add_preinit_statement(Gogo
* gogo
, Statement
* s
)
3846 Block
* b
= this->preinit_block(gogo
);
3847 b
->add_statement(s
);
3848 b
->set_end_location(s
->location());
3851 // Whether this variable has a type.
3854 Variable::has_type() const
3856 if (this->type_
== NULL
)
3859 // A variable created in a type switch case nil does not actually
3860 // have a type yet. It will be changed to use the initializer's
3861 // type in determine_type.
3862 if (this->is_type_switch_var_
3863 && this->type_
->is_nil_constant_as_type())
3869 // In an assignment which sets a variable to a tuple of EXPR, return
3870 // the type of the first element of the tuple.
3873 Variable::type_from_tuple(Expression
* expr
, bool report_error
) const
3875 if (expr
->map_index_expression() != NULL
)
3877 Map_type
* mt
= expr
->map_index_expression()->get_map_type();
3879 return Type::make_error_type();
3880 return mt
->val_type();
3882 else if (expr
->receive_expression() != NULL
)
3884 Expression
* channel
= expr
->receive_expression()->channel();
3885 Type
* channel_type
= channel
->type();
3886 if (channel_type
->channel_type() == NULL
)
3887 return Type::make_error_type();
3888 return channel_type
->channel_type()->element_type();
3893 error_at(this->location(), "invalid tuple definition");
3894 return Type::make_error_type();
3898 // Given EXPR used in a range clause, return either the index type or
3899 // the value type of the range, depending upon GET_INDEX_TYPE.
3902 Variable::type_from_range(Expression
* expr
, bool get_index_type
,
3903 bool report_error
) const
3905 Type
* t
= expr
->type();
3906 if (t
->array_type() != NULL
3907 || (t
->points_to() != NULL
3908 && t
->points_to()->array_type() != NULL
3909 && !t
->points_to()->is_slice_type()))
3912 return Type::lookup_integer_type("int");
3914 return t
->deref()->array_type()->element_type();
3916 else if (t
->is_string_type())
3919 return Type::lookup_integer_type("int");
3921 return Type::lookup_integer_type("int32");
3923 else if (t
->map_type() != NULL
)
3926 return t
->map_type()->key_type();
3928 return t
->map_type()->val_type();
3930 else if (t
->channel_type() != NULL
)
3933 return t
->channel_type()->element_type();
3937 error_at(this->location(),
3938 "invalid definition of value variable for channel range");
3939 return Type::make_error_type();
3945 error_at(this->location(), "invalid type for range clause");
3946 return Type::make_error_type();
3950 // EXPR should be a channel. Return the channel's element type.
3953 Variable::type_from_chan_element(Expression
* expr
, bool report_error
) const
3955 Type
* t
= expr
->type();
3956 if (t
->channel_type() != NULL
)
3957 return t
->channel_type()->element_type();
3961 error_at(this->location(), "expected channel");
3962 return Type::make_error_type();
3966 // Return the type of the Variable. This may be called before
3967 // Variable::determine_type is called, which means that we may need to
3968 // get the type from the initializer. FIXME: If we combine lowering
3969 // with type determination, then this should be unnecessary.
3974 // A variable in a type switch with a nil case will have the wrong
3975 // type here. This gets fixed up in determine_type, below.
3976 Type
* type
= this->type_
;
3977 Expression
* init
= this->init_
;
3978 if (this->is_type_switch_var_
3979 && this->type_
->is_nil_constant_as_type())
3981 Type_guard_expression
* tge
= this->init_
->type_guard_expression();
3982 go_assert(tge
!= NULL
);
3989 if (this->type_
== NULL
|| !this->type_
->is_error_type())
3991 error_at(this->location_
, "variable initializer refers to itself");
3992 this->type_
= Type::make_error_type();
4001 else if (this->type_from_init_tuple_
)
4002 type
= this->type_from_tuple(init
, false);
4003 else if (this->type_from_range_index_
|| this->type_from_range_value_
)
4004 type
= this->type_from_range(init
, this->type_from_range_index_
, false);
4005 else if (this->type_from_chan_element_
)
4006 type
= this->type_from_chan_element(init
, false);
4009 go_assert(init
!= NULL
);
4010 type
= init
->type();
4011 go_assert(type
!= NULL
);
4013 // Variables should not have abstract types.
4014 if (type
->is_abstract())
4015 type
= type
->make_non_abstract_type();
4017 if (type
->is_void_type())
4018 type
= Type::make_error_type();
4021 this->seen_
= false;
4026 // Fetch the type from a const pointer, in which case it should have
4027 // been set already.
4030 Variable::type() const
4032 go_assert(this->type_
!= NULL
);
4036 // Set the type if necessary.
4039 Variable::determine_type()
4041 if (this->determined_type_
)
4043 this->determined_type_
= true;
4045 if (this->preinit_
!= NULL
)
4046 this->preinit_
->determine_types();
4048 // A variable in a type switch with a nil case will have the wrong
4049 // type here. It will have an initializer which is a type guard.
4050 // We want to initialize it to the value without the type guard, and
4051 // use the type of that value as well.
4052 if (this->is_type_switch_var_
&& this->type_
->is_nil_constant_as_type())
4054 Type_guard_expression
* tge
= this->init_
->type_guard_expression();
4055 go_assert(tge
!= NULL
);
4057 this->init_
= tge
->expr();
4060 if (this->init_
== NULL
)
4061 go_assert(this->type_
!= NULL
&& !this->type_
->is_abstract());
4062 else if (this->type_from_init_tuple_
)
4064 Expression
*init
= this->init_
;
4065 init
->determine_type_no_context();
4066 this->type_
= this->type_from_tuple(init
, true);
4069 else if (this->type_from_range_index_
|| this->type_from_range_value_
)
4071 Expression
* init
= this->init_
;
4072 init
->determine_type_no_context();
4073 this->type_
= this->type_from_range(init
, this->type_from_range_index_
,
4077 else if (this->type_from_chan_element_
)
4079 Expression
* init
= this->init_
;
4080 init
->determine_type_no_context();
4081 this->type_
= this->type_from_chan_element(init
, true);
4086 Type_context
context(this->type_
, false);
4087 this->init_
->determine_type(&context
);
4088 if (this->type_
== NULL
)
4090 Type
* type
= this->init_
->type();
4091 go_assert(type
!= NULL
);
4092 if (type
->is_abstract())
4093 type
= type
->make_non_abstract_type();
4095 if (type
->is_void_type())
4097 error_at(this->location_
, "variable has no type");
4098 type
= Type::make_error_type();
4100 else if (type
->is_nil_type())
4102 error_at(this->location_
, "variable defined to nil type");
4103 type
= Type::make_error_type();
4105 else if (type
->is_call_multiple_result_type())
4107 error_at(this->location_
,
4108 "single variable set to multiple value function call");
4109 type
= Type::make_error_type();
4117 // Export the variable
4120 Variable::export_var(Export
* exp
, const std::string
& name
) const
4122 go_assert(this->is_global_
);
4123 exp
->write_c_string("var ");
4124 exp
->write_string(name
);
4125 exp
->write_c_string(" ");
4126 exp
->write_type(this->type());
4127 exp
->write_c_string(";\n");
4130 // Import a variable.
4133 Variable::import_var(Import
* imp
, std::string
* pname
, Type
** ptype
)
4135 imp
->require_c_string("var ");
4136 *pname
= imp
->read_identifier();
4137 imp
->require_c_string(" ");
4138 *ptype
= imp
->read_type();
4139 imp
->require_c_string(";\n");
4142 // Convert a variable to the backend representation.
4145 Variable::get_backend_variable(Gogo
* gogo
, Named_object
* function
,
4146 const Package
* package
, const std::string
& name
)
4148 if (this->backend_
== NULL
)
4150 Backend
* backend
= gogo
->backend();
4151 Type
* type
= this->type_
;
4152 if (type
->is_error_type()
4153 || (type
->is_undefined()
4154 && (!this->is_global_
|| package
== NULL
)))
4155 this->backend_
= backend
->error_variable();
4158 bool is_parameter
= this->is_parameter_
;
4159 if (this->is_receiver_
&& type
->points_to() == NULL
)
4160 is_parameter
= false;
4161 if (this->is_in_heap())
4163 is_parameter
= false;
4164 type
= Type::make_pointer_type(type
);
4167 std::string n
= Gogo::unpack_hidden_name(name
);
4168 Btype
* btype
= type
->get_backend(gogo
);
4171 if (this->is_global_
)
4172 bvar
= backend
->global_variable((package
== NULL
4173 ? gogo
->package_name()
4176 ? gogo
->unique_prefix()
4177 : package
->unique_prefix()),
4181 Gogo::is_hidden_name(name
),
4185 tree fndecl
= function
->func_value()->get_decl();
4186 Bfunction
* bfunction
= tree_to_function(fndecl
);
4187 bool is_address_taken
= (this->is_non_escaping_address_taken_
4188 && !this->is_in_heap());
4190 bvar
= backend
->parameter_variable(bfunction
, n
, btype
,
4194 bvar
= backend
->local_variable(bfunction
, n
, btype
,
4198 this->backend_
= bvar
;
4201 return this->backend_
;
4204 // Class Result_variable.
4206 // Convert a result variable to the backend representation.
4209 Result_variable::get_backend_variable(Gogo
* gogo
, Named_object
* function
,
4210 const std::string
& name
)
4212 if (this->backend_
== NULL
)
4214 Backend
* backend
= gogo
->backend();
4215 Type
* type
= this->type_
;
4216 if (type
->is_error())
4217 this->backend_
= backend
->error_variable();
4220 if (this->is_in_heap())
4221 type
= Type::make_pointer_type(type
);
4222 Btype
* btype
= type
->get_backend(gogo
);
4223 tree fndecl
= function
->func_value()->get_decl();
4224 Bfunction
* bfunction
= tree_to_function(fndecl
);
4225 std::string n
= Gogo::unpack_hidden_name(name
);
4226 bool is_address_taken
= (this->is_non_escaping_address_taken_
4227 && !this->is_in_heap());
4228 this->backend_
= backend
->local_variable(bfunction
, n
, btype
,
4233 return this->backend_
;
4236 // Class Named_constant.
4238 // Traverse the initializer expression.
4241 Named_constant::traverse_expression(Traverse
* traverse
)
4243 return Expression::traverse(&this->expr_
, traverse
);
4246 // Determine the type of the constant.
4249 Named_constant::determine_type()
4251 if (this->type_
!= NULL
)
4253 Type_context
context(this->type_
, false);
4254 this->expr_
->determine_type(&context
);
4258 // A constant may have an abstract type.
4259 Type_context
context(NULL
, true);
4260 this->expr_
->determine_type(&context
);
4261 this->type_
= this->expr_
->type();
4262 go_assert(this->type_
!= NULL
);
4266 // Indicate that we found and reported an error for this constant.
4269 Named_constant::set_error()
4271 this->type_
= Type::make_error_type();
4272 this->expr_
= Expression::make_error(this->location_
);
4275 // Export a constant.
4278 Named_constant::export_const(Export
* exp
, const std::string
& name
) const
4280 exp
->write_c_string("const ");
4281 exp
->write_string(name
);
4282 exp
->write_c_string(" ");
4283 if (!this->type_
->is_abstract())
4285 exp
->write_type(this->type_
);
4286 exp
->write_c_string(" ");
4288 exp
->write_c_string("= ");
4289 this->expr()->export_expression(exp
);
4290 exp
->write_c_string(";\n");
4293 // Import a constant.
4296 Named_constant::import_const(Import
* imp
, std::string
* pname
, Type
** ptype
,
4299 imp
->require_c_string("const ");
4300 *pname
= imp
->read_identifier();
4301 imp
->require_c_string(" ");
4302 if (imp
->peek_char() == '=')
4306 *ptype
= imp
->read_type();
4307 imp
->require_c_string(" ");
4309 imp
->require_c_string("= ");
4310 *pexpr
= Expression::import_expression(imp
);
4311 imp
->require_c_string(";\n");
4317 Type_declaration::add_method(const std::string
& name
, Function
* function
)
4319 Named_object
* ret
= Named_object::make_function(name
, NULL
, function
);
4320 this->methods_
.push_back(ret
);
4324 // Add a method declaration.
4327 Type_declaration::add_method_declaration(const std::string
& name
,
4329 Function_type
* type
,
4332 Named_object
* ret
= Named_object::make_function_declaration(name
, package
,
4334 this->methods_
.push_back(ret
);
4338 // Return whether any methods ere defined.
4341 Type_declaration::has_methods() const
4343 return !this->methods_
.empty();
4346 // Define methods for the real type.
4349 Type_declaration::define_methods(Named_type
* nt
)
4351 for (Methods::const_iterator p
= this->methods_
.begin();
4352 p
!= this->methods_
.end();
4354 nt
->add_existing_method(*p
);
4357 // We are using the type. Return true if we should issue a warning.
4360 Type_declaration::using_type()
4362 bool ret
= !this->issued_warning_
;
4363 this->issued_warning_
= true;
4367 // Class Unknown_name.
4369 // Set the real named object.
4372 Unknown_name::set_real_named_object(Named_object
* no
)
4374 go_assert(this->real_named_object_
== NULL
);
4375 go_assert(!no
->is_unknown());
4376 this->real_named_object_
= no
;
4379 // Class Named_object.
4381 Named_object::Named_object(const std::string
& name
,
4382 const Package
* package
,
4383 Classification classification
)
4384 : name_(name
), package_(package
), classification_(classification
),
4387 if (Gogo::is_sink_name(name
))
4388 go_assert(classification
== NAMED_OBJECT_SINK
);
4391 // Make an unknown name. This is used by the parser. The name must
4392 // be resolved later. Unknown names are only added in the current
4396 Named_object::make_unknown_name(const std::string
& name
,
4399 Named_object
* named_object
= new Named_object(name
, NULL
,
4400 NAMED_OBJECT_UNKNOWN
);
4401 Unknown_name
* value
= new Unknown_name(location
);
4402 named_object
->u_
.unknown_value
= value
;
4403 return named_object
;
4409 Named_object::make_constant(const Typed_identifier
& tid
,
4410 const Package
* package
, Expression
* expr
,
4413 Named_object
* named_object
= new Named_object(tid
.name(), package
,
4414 NAMED_OBJECT_CONST
);
4415 Named_constant
* named_constant
= new Named_constant(tid
.type(), expr
,
4418 named_object
->u_
.const_value
= named_constant
;
4419 return named_object
;
4422 // Make a named type.
4425 Named_object::make_type(const std::string
& name
, const Package
* package
,
4426 Type
* type
, Location location
)
4428 Named_object
* named_object
= new Named_object(name
, package
,
4430 Named_type
* named_type
= Type::make_named_type(named_object
, type
, location
);
4431 named_object
->u_
.type_value
= named_type
;
4432 return named_object
;
4435 // Make a type declaration.
4438 Named_object::make_type_declaration(const std::string
& name
,
4439 const Package
* package
,
4442 Named_object
* named_object
= new Named_object(name
, package
,
4443 NAMED_OBJECT_TYPE_DECLARATION
);
4444 Type_declaration
* type_declaration
= new Type_declaration(location
);
4445 named_object
->u_
.type_declaration
= type_declaration
;
4446 return named_object
;
4452 Named_object::make_variable(const std::string
& name
, const Package
* package
,
4455 Named_object
* named_object
= new Named_object(name
, package
,
4457 named_object
->u_
.var_value
= variable
;
4458 return named_object
;
4461 // Make a result variable.
4464 Named_object::make_result_variable(const std::string
& name
,
4465 Result_variable
* result
)
4467 Named_object
* named_object
= new Named_object(name
, NULL
,
4468 NAMED_OBJECT_RESULT_VAR
);
4469 named_object
->u_
.result_var_value
= result
;
4470 return named_object
;
4473 // Make a sink. This is used for the special blank identifier _.
4476 Named_object::make_sink()
4478 return new Named_object("_", NULL
, NAMED_OBJECT_SINK
);
4481 // Make a named function.
4484 Named_object::make_function(const std::string
& name
, const Package
* package
,
4487 Named_object
* named_object
= new Named_object(name
, package
,
4489 named_object
->u_
.func_value
= function
;
4490 return named_object
;
4493 // Make a function declaration.
4496 Named_object::make_function_declaration(const std::string
& name
,
4497 const Package
* package
,
4498 Function_type
* fntype
,
4501 Named_object
* named_object
= new Named_object(name
, package
,
4502 NAMED_OBJECT_FUNC_DECLARATION
);
4503 Function_declaration
*func_decl
= new Function_declaration(fntype
, location
);
4504 named_object
->u_
.func_declaration_value
= func_decl
;
4505 return named_object
;
4511 Named_object::make_package(const std::string
& alias
, Package
* package
)
4513 Named_object
* named_object
= new Named_object(alias
, NULL
,
4514 NAMED_OBJECT_PACKAGE
);
4515 named_object
->u_
.package_value
= package
;
4516 return named_object
;
4519 // Return the name to use in an error message.
4522 Named_object::message_name() const
4524 if (this->package_
== NULL
)
4525 return Gogo::message_name(this->name_
);
4526 std::string ret
= Gogo::message_name(this->package_
->name());
4528 ret
+= Gogo::message_name(this->name_
);
4532 // Set the type when a declaration is defined.
4535 Named_object::set_type_value(Named_type
* named_type
)
4537 go_assert(this->classification_
== NAMED_OBJECT_TYPE_DECLARATION
);
4538 Type_declaration
* td
= this->u_
.type_declaration
;
4539 td
->define_methods(named_type
);
4540 Named_object
* in_function
= td
->in_function();
4541 if (in_function
!= NULL
)
4542 named_type
->set_in_function(in_function
);
4544 this->classification_
= NAMED_OBJECT_TYPE
;
4545 this->u_
.type_value
= named_type
;
4548 // Define a function which was previously declared.
4551 Named_object::set_function_value(Function
* function
)
4553 go_assert(this->classification_
== NAMED_OBJECT_FUNC_DECLARATION
);
4554 this->classification_
= NAMED_OBJECT_FUNC
;
4555 // FIXME: We should free the old value.
4556 this->u_
.func_value
= function
;
4559 // Declare an unknown object as a type declaration.
4562 Named_object::declare_as_type()
4564 go_assert(this->classification_
== NAMED_OBJECT_UNKNOWN
);
4565 Unknown_name
* unk
= this->u_
.unknown_value
;
4566 this->classification_
= NAMED_OBJECT_TYPE_DECLARATION
;
4567 this->u_
.type_declaration
= new Type_declaration(unk
->location());
4571 // Return the location of a named object.
4574 Named_object::location() const
4576 switch (this->classification_
)
4579 case NAMED_OBJECT_UNINITIALIZED
:
4582 case NAMED_OBJECT_ERRONEOUS
:
4583 return Linemap::unknown_location();
4585 case NAMED_OBJECT_UNKNOWN
:
4586 return this->unknown_value()->location();
4588 case NAMED_OBJECT_CONST
:
4589 return this->const_value()->location();
4591 case NAMED_OBJECT_TYPE
:
4592 return this->type_value()->location();
4594 case NAMED_OBJECT_TYPE_DECLARATION
:
4595 return this->type_declaration_value()->location();
4597 case NAMED_OBJECT_VAR
:
4598 return this->var_value()->location();
4600 case NAMED_OBJECT_RESULT_VAR
:
4601 return this->result_var_value()->location();
4603 case NAMED_OBJECT_SINK
:
4606 case NAMED_OBJECT_FUNC
:
4607 return this->func_value()->location();
4609 case NAMED_OBJECT_FUNC_DECLARATION
:
4610 return this->func_declaration_value()->location();
4612 case NAMED_OBJECT_PACKAGE
:
4613 return this->package_value()->location();
4617 // Export a named object.
4620 Named_object::export_named_object(Export
* exp
) const
4622 switch (this->classification_
)
4625 case NAMED_OBJECT_UNINITIALIZED
:
4626 case NAMED_OBJECT_UNKNOWN
:
4629 case NAMED_OBJECT_ERRONEOUS
:
4632 case NAMED_OBJECT_CONST
:
4633 this->const_value()->export_const(exp
, this->name_
);
4636 case NAMED_OBJECT_TYPE
:
4637 this->type_value()->export_named_type(exp
, this->name_
);
4640 case NAMED_OBJECT_TYPE_DECLARATION
:
4641 error_at(this->type_declaration_value()->location(),
4642 "attempt to export %<%s%> which was declared but not defined",
4643 this->message_name().c_str());
4646 case NAMED_OBJECT_FUNC_DECLARATION
:
4647 this->func_declaration_value()->export_func(exp
, this->name_
);
4650 case NAMED_OBJECT_VAR
:
4651 this->var_value()->export_var(exp
, this->name_
);
4654 case NAMED_OBJECT_RESULT_VAR
:
4655 case NAMED_OBJECT_SINK
:
4658 case NAMED_OBJECT_FUNC
:
4659 this->func_value()->export_func(exp
, this->name_
);
4664 // Convert a variable to the backend representation.
4667 Named_object::get_backend_variable(Gogo
* gogo
, Named_object
* function
)
4669 if (this->classification_
== NAMED_OBJECT_VAR
)
4670 return this->var_value()->get_backend_variable(gogo
, function
,
4671 this->package_
, this->name_
);
4672 else if (this->classification_
== NAMED_OBJECT_RESULT_VAR
)
4673 return this->result_var_value()->get_backend_variable(gogo
, function
,
4681 Bindings::Bindings(Bindings
* enclosing
)
4682 : enclosing_(enclosing
), named_objects_(), bindings_()
4689 Bindings::clear_file_scope()
4691 Contour::iterator p
= this->bindings_
.begin();
4692 while (p
!= this->bindings_
.end())
4695 if (p
->second
->package() != NULL
)
4697 else if (p
->second
->is_package())
4699 else if (p
->second
->is_function()
4700 && !p
->second
->func_value()->type()->is_method()
4701 && Gogo::unpack_hidden_name(p
->second
->name()) == "init")
4709 p
= this->bindings_
.erase(p
);
4713 // Look up a symbol.
4716 Bindings::lookup(const std::string
& name
) const
4718 Contour::const_iterator p
= this->bindings_
.find(name
);
4719 if (p
!= this->bindings_
.end())
4720 return p
->second
->resolve();
4721 else if (this->enclosing_
!= NULL
)
4722 return this->enclosing_
->lookup(name
);
4727 // Look up a symbol locally.
4730 Bindings::lookup_local(const std::string
& name
) const
4732 Contour::const_iterator p
= this->bindings_
.find(name
);
4733 if (p
== this->bindings_
.end())
4738 // Remove an object from a set of bindings. This is used for a
4739 // special case in thunks for functions which call recover.
4742 Bindings::remove_binding(Named_object
* no
)
4744 Contour::iterator pb
= this->bindings_
.find(no
->name());
4745 go_assert(pb
!= this->bindings_
.end());
4746 this->bindings_
.erase(pb
);
4747 for (std::vector
<Named_object
*>::iterator pn
= this->named_objects_
.begin();
4748 pn
!= this->named_objects_
.end();
4753 this->named_objects_
.erase(pn
);
4760 // Add a method to the list of objects. This is not added to the
4761 // lookup table. This is so that we have a single list of objects
4762 // declared at the top level, which we walk through when it's time to
4763 // convert to trees.
4766 Bindings::add_method(Named_object
* method
)
4768 this->named_objects_
.push_back(method
);
4771 // Add a generic Named_object to a Contour.
4774 Bindings::add_named_object_to_contour(Contour
* contour
,
4775 Named_object
* named_object
)
4777 go_assert(named_object
== named_object
->resolve());
4778 const std::string
& name(named_object
->name());
4779 go_assert(!Gogo::is_sink_name(name
));
4781 std::pair
<Contour::iterator
, bool> ins
=
4782 contour
->insert(std::make_pair(name
, named_object
));
4785 // The name was already there.
4786 if (named_object
->package() != NULL
4787 && ins
.first
->second
->package() == named_object
->package()
4788 && (ins
.first
->second
->classification()
4789 == named_object
->classification()))
4791 // This is a second import of the same object.
4792 return ins
.first
->second
;
4794 ins
.first
->second
= this->new_definition(ins
.first
->second
,
4796 return ins
.first
->second
;
4800 // Don't push declarations on the list. We push them on when
4801 // and if we find the definitions. That way we genericize the
4802 // functions in order.
4803 if (!named_object
->is_type_declaration()
4804 && !named_object
->is_function_declaration()
4805 && !named_object
->is_unknown())
4806 this->named_objects_
.push_back(named_object
);
4807 return named_object
;
4811 // We had an existing named object OLD_OBJECT, and we've seen a new
4812 // one NEW_OBJECT with the same name. FIXME: This does not free the
4813 // new object when we don't need it.
4816 Bindings::new_definition(Named_object
* old_object
, Named_object
* new_object
)
4818 if (new_object
->is_erroneous() && !old_object
->is_erroneous())
4822 switch (old_object
->classification())
4825 case Named_object::NAMED_OBJECT_UNINITIALIZED
:
4828 case Named_object::NAMED_OBJECT_ERRONEOUS
:
4831 case Named_object::NAMED_OBJECT_UNKNOWN
:
4833 Named_object
* real
= old_object
->unknown_value()->real_named_object();
4835 return this->new_definition(real
, new_object
);
4836 go_assert(!new_object
->is_unknown());
4837 old_object
->unknown_value()->set_real_named_object(new_object
);
4838 if (!new_object
->is_type_declaration()
4839 && !new_object
->is_function_declaration())
4840 this->named_objects_
.push_back(new_object
);
4844 case Named_object::NAMED_OBJECT_CONST
:
4847 case Named_object::NAMED_OBJECT_TYPE
:
4848 if (new_object
->is_type_declaration())
4852 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
4853 if (new_object
->is_type_declaration())
4855 if (new_object
->is_type())
4857 old_object
->set_type_value(new_object
->type_value());
4858 new_object
->type_value()->set_named_object(old_object
);
4859 this->named_objects_
.push_back(old_object
);
4864 case Named_object::NAMED_OBJECT_VAR
:
4865 case Named_object::NAMED_OBJECT_RESULT_VAR
:
4866 // We have already given an error in the parser for cases where
4867 // one parameter or result variable redeclares another one.
4868 if ((new_object
->is_variable()
4869 && new_object
->var_value()->is_parameter())
4870 || new_object
->is_result_variable())
4874 case Named_object::NAMED_OBJECT_SINK
:
4877 case Named_object::NAMED_OBJECT_FUNC
:
4878 if (new_object
->is_function_declaration())
4880 if (!new_object
->func_declaration_value()->asm_name().empty())
4881 sorry("__asm__ for function definitions");
4882 Function_type
* old_type
= old_object
->func_value()->type();
4883 Function_type
* new_type
=
4884 new_object
->func_declaration_value()->type();
4885 if (old_type
->is_valid_redeclaration(new_type
, &reason
))
4890 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
4892 Function_type
* old_type
= old_object
->func_declaration_value()->type();
4893 if (new_object
->is_function_declaration())
4895 Function_type
* new_type
=
4896 new_object
->func_declaration_value()->type();
4897 if (old_type
->is_valid_redeclaration(new_type
, &reason
))
4900 if (new_object
->is_function())
4902 Function_type
* new_type
= new_object
->func_value()->type();
4903 if (old_type
->is_valid_redeclaration(new_type
, &reason
))
4905 if (!old_object
->func_declaration_value()->asm_name().empty())
4906 sorry("__asm__ for function definitions");
4907 old_object
->set_function_value(new_object
->func_value());
4908 this->named_objects_
.push_back(old_object
);
4915 case Named_object::NAMED_OBJECT_PACKAGE
:
4916 if (new_object
->is_package()
4917 && (old_object
->package_value()->name()
4918 == new_object
->package_value()->name()))
4924 std::string n
= old_object
->message_name();
4926 error_at(new_object
->location(), "redefinition of %qs", n
.c_str());
4928 error_at(new_object
->location(), "redefinition of %qs: %s", n
.c_str(),
4931 inform(old_object
->location(), "previous definition of %qs was here",
4937 // Add a named type.
4940 Bindings::add_named_type(Named_type
* named_type
)
4942 return this->add_named_object(named_type
->named_object());
4948 Bindings::add_function(const std::string
& name
, const Package
* package
,
4951 return this->add_named_object(Named_object::make_function(name
, package
,
4955 // Add a function declaration.
4958 Bindings::add_function_declaration(const std::string
& name
,
4959 const Package
* package
,
4960 Function_type
* type
,
4963 Named_object
* no
= Named_object::make_function_declaration(name
, package
,
4965 return this->add_named_object(no
);
4968 // Define a type which was previously declared.
4971 Bindings::define_type(Named_object
* no
, Named_type
* type
)
4973 no
->set_type_value(type
);
4974 this->named_objects_
.push_back(no
);
4977 // Mark all local variables as used. This is used for some types of
4981 Bindings::mark_locals_used()
4983 for (std::vector
<Named_object
*>::iterator p
= this->named_objects_
.begin();
4984 p
!= this->named_objects_
.end();
4986 if ((*p
)->is_variable())
4987 (*p
)->var_value()->set_is_used();
4990 // Traverse bindings.
4993 Bindings::traverse(Traverse
* traverse
, bool is_global
)
4995 unsigned int traverse_mask
= traverse
->traverse_mask();
4997 // We don't use an iterator because we permit the traversal to add
4998 // new global objects.
4999 const unsigned int e_or_t
= (Traverse::traverse_expressions
5000 | Traverse::traverse_types
);
5001 const unsigned int e_or_t_or_s
= (e_or_t
5002 | Traverse::traverse_statements
);
5003 for (size_t i
= 0; i
< this->named_objects_
.size(); ++i
)
5005 Named_object
* p
= this->named_objects_
[i
];
5006 int t
= TRAVERSE_CONTINUE
;
5007 switch (p
->classification())
5009 case Named_object::NAMED_OBJECT_CONST
:
5010 if ((traverse_mask
& Traverse::traverse_constants
) != 0)
5011 t
= traverse
->constant(p
, is_global
);
5012 if (t
== TRAVERSE_CONTINUE
5013 && (traverse_mask
& e_or_t
) != 0)
5015 Type
* tc
= p
->const_value()->type();
5017 && Type::traverse(tc
, traverse
) == TRAVERSE_EXIT
)
5018 return TRAVERSE_EXIT
;
5019 t
= p
->const_value()->traverse_expression(traverse
);
5023 case Named_object::NAMED_OBJECT_VAR
:
5024 case Named_object::NAMED_OBJECT_RESULT_VAR
:
5025 if ((traverse_mask
& Traverse::traverse_variables
) != 0)
5026 t
= traverse
->variable(p
);
5027 if (t
== TRAVERSE_CONTINUE
5028 && (traverse_mask
& e_or_t
) != 0)
5030 if (p
->is_result_variable()
5031 || p
->var_value()->has_type())
5033 Type
* tv
= (p
->is_variable()
5034 ? p
->var_value()->type()
5035 : p
->result_var_value()->type());
5037 && Type::traverse(tv
, traverse
) == TRAVERSE_EXIT
)
5038 return TRAVERSE_EXIT
;
5041 if (t
== TRAVERSE_CONTINUE
5042 && (traverse_mask
& e_or_t_or_s
) != 0
5043 && p
->is_variable())
5044 t
= p
->var_value()->traverse_expression(traverse
, traverse_mask
);
5047 case Named_object::NAMED_OBJECT_FUNC
:
5048 if ((traverse_mask
& Traverse::traverse_functions
) != 0)
5049 t
= traverse
->function(p
);
5051 if (t
== TRAVERSE_CONTINUE
5053 & (Traverse::traverse_variables
5054 | Traverse::traverse_constants
5055 | Traverse::traverse_functions
5056 | Traverse::traverse_blocks
5057 | Traverse::traverse_statements
5058 | Traverse::traverse_expressions
5059 | Traverse::traverse_types
)) != 0)
5060 t
= p
->func_value()->traverse(traverse
);
5063 case Named_object::NAMED_OBJECT_PACKAGE
:
5064 // These are traversed in Gogo::traverse.
5065 go_assert(is_global
);
5068 case Named_object::NAMED_OBJECT_TYPE
:
5069 if ((traverse_mask
& e_or_t
) != 0)
5070 t
= Type::traverse(p
->type_value(), traverse
);
5073 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
5074 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
5075 case Named_object::NAMED_OBJECT_UNKNOWN
:
5076 case Named_object::NAMED_OBJECT_ERRONEOUS
:
5079 case Named_object::NAMED_OBJECT_SINK
:
5084 if (t
== TRAVERSE_EXIT
)
5085 return TRAVERSE_EXIT
;
5088 // If we need to traverse types, check the function declarations,
5089 // which have types. We don't need to check the type declarations,
5090 // as those are just names.
5091 if ((traverse_mask
& e_or_t
) != 0)
5093 for (Bindings::const_declarations_iterator p
=
5094 this->begin_declarations();
5095 p
!= this->end_declarations();
5098 if (p
->second
->is_function_declaration())
5100 if (Type::traverse(p
->second
->func_declaration_value()->type(),
5103 return TRAVERSE_EXIT
;
5108 return TRAVERSE_CONTINUE
;
5113 // Clear any references to this label.
5118 for (std::vector
<Bindings_snapshot
*>::iterator p
= this->refs_
.begin();
5119 p
!= this->refs_
.end();
5122 this->refs_
.clear();
5125 // Get the backend representation for a label.
5128 Label::get_backend_label(Translate_context
* context
)
5130 if (this->blabel_
== NULL
)
5132 Function
* function
= context
->function()->func_value();
5133 tree fndecl
= function
->get_decl();
5134 Bfunction
* bfunction
= tree_to_function(fndecl
);
5135 this->blabel_
= context
->backend()->label(bfunction
, this->name_
,
5138 return this->blabel_
;
5141 // Return an expression for the address of this label.
5144 Label::get_addr(Translate_context
* context
, Location location
)
5146 Blabel
* label
= this->get_backend_label(context
);
5147 return context
->backend()->label_address(label
, location
);
5150 // Class Unnamed_label.
5152 // Get the backend representation for an unnamed label.
5155 Unnamed_label::get_blabel(Translate_context
* context
)
5157 if (this->blabel_
== NULL
)
5159 Function
* function
= context
->function()->func_value();
5160 tree fndecl
= function
->get_decl();
5161 Bfunction
* bfunction
= tree_to_function(fndecl
);
5162 this->blabel_
= context
->backend()->label(bfunction
, "",
5165 return this->blabel_
;
5168 // Return a statement which defines this unnamed label.
5171 Unnamed_label::get_definition(Translate_context
* context
)
5173 Blabel
* blabel
= this->get_blabel(context
);
5174 return context
->backend()->label_definition_statement(blabel
);
5177 // Return a goto statement to this unnamed label.
5180 Unnamed_label::get_goto(Translate_context
* context
, Location location
)
5182 Blabel
* blabel
= this->get_blabel(context
);
5183 return context
->backend()->goto_statement(blabel
, location
);
5188 Package::Package(const std::string
& name
, const std::string
& unique_prefix
,
5190 : name_(name
), unique_prefix_(unique_prefix
), bindings_(new Bindings(NULL
)),
5191 priority_(0), location_(location
), used_(false), is_imported_(false),
5192 uses_sink_alias_(false)
5194 go_assert(!name
.empty() && !unique_prefix
.empty());
5197 // Set the priority. We may see multiple priorities for an imported
5198 // package; we want to use the largest one.
5201 Package::set_priority(int priority
)
5203 if (priority
> this->priority_
)
5204 this->priority_
= priority
;
5207 // Determine types of constants. Everything else in a package
5208 // (variables, function declarations) should already have a fixed
5209 // type. Constants may have abstract types.
5212 Package::determine_types()
5214 Bindings
* bindings
= this->bindings_
;
5215 for (Bindings::const_definitions_iterator p
= bindings
->begin_definitions();
5216 p
!= bindings
->end_definitions();
5219 if ((*p
)->is_const())
5220 (*p
)->const_value()->determine_type();
5228 Traverse::~Traverse()
5230 if (this->types_seen_
!= NULL
)
5231 delete this->types_seen_
;
5232 if (this->expressions_seen_
!= NULL
)
5233 delete this->expressions_seen_
;
5236 // Record that we are looking at a type, and return true if we have
5240 Traverse::remember_type(const Type
* type
)
5242 if (type
->is_error_type())
5244 go_assert((this->traverse_mask() & traverse_types
) != 0
5245 || (this->traverse_mask() & traverse_expressions
) != 0);
5246 // We mostly only have to remember named types. But it turns out
5247 // that an interface type can refer to itself without using a name
5248 // by relying on interface inheritance, as in
5249 // type I interface { F() interface{I} }
5250 if (type
->classification() != Type::TYPE_NAMED
5251 && type
->classification() != Type::TYPE_INTERFACE
)
5253 if (this->types_seen_
== NULL
)
5254 this->types_seen_
= new Types_seen();
5255 std::pair
<Types_seen::iterator
, bool> ins
= this->types_seen_
->insert(type
);
5259 // Record that we are looking at an expression, and return true if we
5260 // have already seen it.
5263 Traverse::remember_expression(const Expression
* expression
)
5265 go_assert((this->traverse_mask() & traverse_types
) != 0
5266 || (this->traverse_mask() & traverse_expressions
) != 0);
5267 if (this->expressions_seen_
== NULL
)
5268 this->expressions_seen_
= new Expressions_seen();
5269 std::pair
<Expressions_seen::iterator
, bool> ins
=
5270 this->expressions_seen_
->insert(expression
);
5274 // The default versions of these functions should never be called: the
5275 // traversal mask indicates which functions may be called.
5278 Traverse::variable(Named_object
*)
5284 Traverse::constant(Named_object
*, bool)
5290 Traverse::function(Named_object
*)
5296 Traverse::block(Block
*)
5302 Traverse::statement(Block
*, size_t*, Statement
*)
5308 Traverse::expression(Expression
**)
5314 Traverse::type(Type
*)
5319 // Class Statement_inserter.
5322 Statement_inserter::insert(Statement
* s
)
5324 if (this->block_
!= NULL
)
5326 go_assert(this->pindex_
!= NULL
);
5327 this->block_
->insert_statement_before(*this->pindex_
, s
);
5330 else if (this->var_
!= NULL
)
5331 this->var_
->add_preinit_statement(this->gogo_
, s
);