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 this->named_types_are_converted_ = true;
2935 // Convert all names types in a set of bindings.
2938 Gogo::convert_named_types_in_bindings(Bindings* bindings)
2940 for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
2941 p != bindings->end_definitions();
2944 if ((*p)->is_type())
2945 (*p)->type_value()->convert(this);
2951 Function::Function(Function_type* type, Function* enclosing, Block* block,
2953 : type_(type), enclosing_(enclosing), results_(NULL),
2954 closure_var_(NULL), block_(block), location_(location), fndecl_(NULL),
2955 defer_stack_(NULL), results_are_named_(false), calls_recover_(false),
2956 is_recover_thunk_(false), has_recover_thunk_(false)
2960 // Create the named result variables.
2963 Function::create_result_variables(Gogo* gogo)
2965 const Typed_identifier_list* results = this->type_->results();
2966 if (results == NULL || results->empty())
2969 if (!results->front().name().empty())
2970 this->results_are_named_ = true;
2972 this->results_ = new Results();
2973 this->results_->reserve(results->size());
2975 Block* block = this->block_;
2977 for (Typed_identifier_list::const_iterator p = results->begin();
2978 p != results->end();
2981 std::string name = p->name();
2982 if (name.empty() || Gogo::is_sink_name(name))
2984 static int result_counter;
2986 snprintf(buf, sizeof buf, "$ret%d", result_counter);
2988 name = gogo->pack_hidden_name(buf, false);
2990 Result_variable* result = new Result_variable(p->type(), this, index,
2992 Named_object* no = block->bindings()->add_result_variable(name, result);
2993 if (no->is_result_variable())
2994 this->results_->push_back(no);
2997 static int dummy_result_count;
2999 snprintf(buf, sizeof buf, "$dret%d", dummy_result_count);
3000 ++dummy_result_count;
3001 name = gogo->pack_hidden_name(buf, false);
3002 no = block->bindings()->add_result_variable(name, result);
3003 go_assert(no->is_result_variable());
3004 this->results_->push_back(no);
3009 // Update the named result variables when cloning a function which
3013 Function::update_result_variables()
3015 if (this->results_ == NULL)
3018 for (Results::iterator p = this->results_->begin();
3019 p != this->results_->end();
3021 (*p)->result_var_value()->set_function(this);
3024 // Return the closure variable, creating it if necessary.
3027 Function::closure_var()
3029 if (this->closure_var_ == NULL)
3031 // We don't know the type of the variable yet. We add fields as
3033 Location loc = this->type_->location();
3034 Struct_field_list* sfl = new Struct_field_list;
3035 Type* struct_type = Type::make_struct_type(sfl, loc);
3036 Variable* var = new Variable(Type::make_pointer_type(struct_type),
3037 NULL, false, true, false, loc);
3039 this->closure_var_ = Named_object::make_variable("closure", NULL, var);
3040 // Note that the new variable is not in any binding contour.
3042 return this->closure_var_;
3045 // Set the type of the closure variable.
3048 Function::set_closure_type()
3050 if (this->closure_var_ == NULL)
3052 Named_object* closure = this->closure_var_;
3053 Struct_type* st = closure->var_value()->type()->deref()->struct_type();
3054 unsigned int index = 0;
3055 for (Closure_fields::const_iterator p = this->closure_fields_.begin();
3056 p != this->closure_fields_.end();
3059 Named_object* no = p->first;
3061 snprintf(buf, sizeof buf, "%u", index);
3062 std::string n = no->name() + buf;
3064 if (no->is_variable())
3065 var_type = no->var_value()->type();
3067 var_type = no->result_var_value()->type();
3068 Type* field_type = Type::make_pointer_type(var_type);
3069 st->push_field(Struct_field(Typed_identifier(n, field_type, p->second)));
3073 // Return whether this function is a method.
3076 Function::is_method() const
3078 return this->type_->is_method();
3081 // Add a label definition.
3084 Function::add_label_definition(Gogo* gogo, const std::string& label_name,
3087 Label* lnull = NULL;
3088 std::pair<Labels::iterator, bool> ins =
3089 this->labels_.insert(std::make_pair(label_name, lnull));
3093 // This is a new label.
3094 label = new Label(label_name);
3095 ins.first->second = label;
3099 // The label was already in the hash table.
3100 label = ins.first->second;
3101 if (label->is_defined())
3103 error_at(location, "label %qs already defined",
3104 Gogo::message_name(label_name).c_str());
3105 inform(label->location(), "previous definition of %qs was here",
3106 Gogo::message_name(label_name).c_str());
3107 return new Label(label_name);
3111 label->define(location, gogo->bindings_snapshot(location));
3113 // Issue any errors appropriate for any previous goto's to this
3115 const std::vector<Bindings_snapshot*>& refs(label->refs());
3116 for (std::vector<Bindings_snapshot*>::const_iterator p = refs.begin();
3119 (*p)->check_goto_to(gogo->current_block());
3120 label->clear_refs();
3125 // Add a reference to a label.
3128 Function::add_label_reference(Gogo* gogo, const std::string& label_name,
3129 Location location, bool issue_goto_errors)
3131 Label* lnull = NULL;
3132 std::pair<Labels::iterator, bool> ins =
3133 this->labels_.insert(std::make_pair(label_name, lnull));
3137 // The label was already in the hash table.
3138 label = ins.first->second;
3142 go_assert(ins.first->second == NULL);
3143 label = new Label(label_name);
3144 ins.first->second = label;
3147 label->set_is_used();
3149 if (issue_goto_errors)
3151 Bindings_snapshot* snapshot = label->snapshot();
3152 if (snapshot != NULL)
3153 snapshot->check_goto_from(gogo->current_block(), location);
3155 label->add_snapshot_ref(gogo->bindings_snapshot(location));
3161 // Warn about labels that are defined but not used.
3164 Function::check_labels() const
3166 for (Labels::const_iterator p = this->labels_.begin();
3167 p != this->labels_.end();
3170 Label* label = p->second;
3171 if (!label->is_used())
3172 error_at(label->location(), "label %qs defined and not used",
3173 Gogo::message_name(label->name()).c_str());
3177 // Swap one function with another. This is used when building the
3178 // thunk we use to call a function which calls recover. It may not
3179 // work for any other case.
3182 Function::swap_for_recover(Function *x)
3184 go_assert(this->enclosing_ == x->enclosing_);
3185 std::swap(this->results_, x->results_);
3186 std::swap(this->closure_var_, x->closure_var_);
3187 std::swap(this->block_, x->block_);
3188 go_assert(this->location_ == x->location_);
3189 go_assert(this->fndecl_ == NULL && x->fndecl_ == NULL);
3190 go_assert(this->defer_stack_ == NULL && x->defer_stack_ == NULL);
3193 // Traverse the tree.
3196 Function::traverse(Traverse* traverse)
3198 unsigned int traverse_mask = traverse->traverse_mask();
3201 & (Traverse::traverse_types | Traverse::traverse_expressions))
3204 if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
3205 return TRAVERSE_EXIT;
3208 // FIXME: We should check traverse_functions here if nested
3209 // functions are stored in block bindings.
3210 if (this->block_ != NULL
3212 & (Traverse::traverse_variables
3213 | Traverse::traverse_constants
3214 | Traverse::traverse_blocks
3215 | Traverse::traverse_statements
3216 | Traverse::traverse_expressions
3217 | Traverse::traverse_types)) != 0)
3219 if (this->block_->traverse(traverse) == TRAVERSE_EXIT)
3220 return TRAVERSE_EXIT;
3223 return TRAVERSE_CONTINUE;
3226 // Work out types for unspecified variables and constants.
3229 Function::determine_types()
3231 if (this->block_ != NULL)
3232 this->block_->determine_types();
3235 // Get a pointer to the variable representing the defer stack for this
3236 // function, making it if necessary. The value of the variable is set
3237 // by the runtime routines to true if the function is returning,
3238 // rather than panicing through. A pointer to this variable is used
3239 // as a marker for the functions on the defer stack associated with
3240 // this function. A function-specific variable permits inlining a
3241 // function which uses defer.
3244 Function::defer_stack(Location location)
3246 if (this->defer_stack_ == NULL)
3248 Type* t = Type::lookup_bool_type();
3249 Expression* n = Expression::make_boolean(false, location);
3250 this->defer_stack_ = Statement::make_temporary(t, n, location);
3251 this->defer_stack_->set_is_address_taken();
3253 Expression* ref = Expression::make_temporary_reference(this->defer_stack_,
3255 return Expression::make_unary(OPERATOR_AND, ref, location);
3258 // Export the function.
3261 Function::export_func(Export* exp, const std::string& name) const
3263 Function::export_func_with_type(exp, name, this->type_);
3266 // Export a function with a type.
3269 Function::export_func_with_type(Export* exp, const std::string& name,
3270 const Function_type* fntype)
3272 exp->write_c_string("func ");
3274 if (fntype->is_method())
3276 exp->write_c_string("(");
3277 exp->write_type(fntype->receiver()->type());
3278 exp->write_c_string(") ");
3281 exp->write_string(name);
3283 exp->write_c_string(" (");
3284 const Typed_identifier_list* parameters = fntype->parameters();
3285 if (parameters != NULL)
3287 bool is_varargs = fntype->is_varargs();
3289 for (Typed_identifier_list::const_iterator p = parameters->begin();
3290 p != parameters->end();
3296 exp->write_c_string(", ");
3297 if (!is_varargs || p + 1 != parameters->end())
3298 exp->write_type(p->type());
3301 exp->write_c_string("...");
3302 exp->write_type(p->type()->array_type()->element_type());
3306 exp->write_c_string(")");
3308 const Typed_identifier_list* results = fntype->results();
3309 if (results != NULL)
3311 if (results->size() == 1)
3313 exp->write_c_string(" ");
3314 exp->write_type(results->begin()->type());
3318 exp->write_c_string(" (");
3320 for (Typed_identifier_list::const_iterator p = results->begin();
3321 p != results->end();
3327 exp->write_c_string(", ");
3328 exp->write_type(p->type());
3330 exp->write_c_string(")");
3333 exp->write_c_string(";\n");
3336 // Import a function.
3339 Function::import_func(Import* imp, std::string* pname,
3340 Typed_identifier** preceiver,
3341 Typed_identifier_list** pparameters,
3342 Typed_identifier_list** presults,
3345 imp->require_c_string("func ");
3348 if (imp->peek_char() == '(')
3350 imp->require_c_string("(");
3351 Type* rtype = imp->read_type();
3352 *preceiver = new Typed_identifier(Import::import_marker, rtype,
3354 imp->require_c_string(") ");
3357 *pname = imp->read_identifier();
3359 Typed_identifier_list* parameters;
3360 *is_varargs = false;
3361 imp->require_c_string(" (");
3362 if (imp->peek_char() == ')')
3366 parameters = new Typed_identifier_list();
3369 if (imp->match_c_string("..."))
3375 Type* ptype = imp->read_type();
3377 ptype = Type::make_array_type(ptype, NULL);
3378 parameters->push_back(Typed_identifier(Import::import_marker,
3379 ptype, imp->location()));
3380 if (imp->peek_char() != ',')
3382 go_assert(!*is_varargs);
3383 imp->require_c_string(", ");
3386 imp->require_c_string(")");
3387 *pparameters = parameters;
3389 Typed_identifier_list* results;
3390 if (imp->peek_char() != ' ')
3394 results = new Typed_identifier_list();
3395 imp->require_c_string(" ");
3396 if (imp->peek_char() != '(')
3398 Type* rtype = imp->read_type();
3399 results->push_back(Typed_identifier(Import::import_marker, rtype,
3404 imp->require_c_string("(");
3407 Type* rtype = imp->read_type();
3408 results->push_back(Typed_identifier(Import::import_marker,
3409 rtype, imp->location()));
3410 if (imp->peek_char() != ',')
3412 imp->require_c_string(", ");
3414 imp->require_c_string(")");
3417 imp->require_c_string(";\n");
3418 *presults = results;
3423 Block::Block(Block* enclosing, Location location)
3424 : enclosing_(enclosing), statements_(),
3425 bindings_(new Bindings(enclosing == NULL
3427 : enclosing->bindings())),
3428 start_location_(location),
3429 end_location_(UNKNOWN_LOCATION)
3433 // Add a statement to a block.
3436 Block::add_statement(Statement* statement)
3438 this->statements_.push_back(statement);
3441 // Add a statement to the front of a block. This is slow but is only
3442 // used for reference counts of parameters.
3445 Block::add_statement_at_front(Statement* statement)
3447 this->statements_.insert(this->statements_.begin(), statement);
3450 // Replace a statement in a block.
3453 Block::replace_statement(size_t index, Statement* s)
3455 go_assert(index < this->statements_.size());
3456 this->statements_[index] = s;
3459 // Add a statement before another statement.
3462 Block::insert_statement_before(size_t index, Statement* s)
3464 go_assert(index < this->statements_.size());
3465 this->statements_.insert(this->statements_.begin() + index, s);
3468 // Add a statement after another statement.
3471 Block::insert_statement_after(size_t index, Statement* s)
3473 go_assert(index < this->statements_.size());
3474 this->statements_.insert(this->statements_.begin() + index + 1, s);
3477 // Traverse the tree.
3480 Block::traverse(Traverse* traverse)
3482 unsigned int traverse_mask = traverse->traverse_mask();
3484 if ((traverse_mask & Traverse::traverse_blocks) != 0)
3486 int t = traverse->block(this);
3487 if (t == TRAVERSE_EXIT)
3488 return TRAVERSE_EXIT;
3489 else if (t == TRAVERSE_SKIP_COMPONENTS)
3490 return TRAVERSE_CONTINUE;
3494 & (Traverse::traverse_variables
3495 | Traverse::traverse_constants
3496 | Traverse::traverse_expressions
3497 | Traverse::traverse_types)) != 0)
3499 const unsigned int e_or_t = (Traverse::traverse_expressions
3500 | Traverse::traverse_types);
3501 const unsigned int e_or_t_or_s = (e_or_t
3502 | Traverse::traverse_statements);
3503 for (Bindings::const_definitions_iterator pb =
3504 this->bindings_->begin_definitions();
3505 pb != this->bindings_->end_definitions();
3508 int t = TRAVERSE_CONTINUE;
3509 switch ((*pb)->classification())
3511 case Named_object::NAMED_OBJECT_CONST:
3512 if ((traverse_mask & Traverse::traverse_constants) != 0)
3513 t = traverse->constant(*pb, false);
3514 if (t == TRAVERSE_CONTINUE
3515 && (traverse_mask & e_or_t) != 0)
3517 Type* tc = (*pb)->const_value()->type();
3519 && Type::traverse(tc, traverse) == TRAVERSE_EXIT)
3520 return TRAVERSE_EXIT;
3521 t = (*pb)->const_value()->traverse_expression(traverse);
3525 case Named_object::NAMED_OBJECT_VAR:
3526 case Named_object::NAMED_OBJECT_RESULT_VAR:
3527 if ((traverse_mask & Traverse::traverse_variables) != 0)
3528 t = traverse->variable(*pb);
3529 if (t == TRAVERSE_CONTINUE
3530 && (traverse_mask & e_or_t) != 0)
3532 if ((*pb)->is_result_variable()
3533 || (*pb)->var_value()->has_type())
3535 Type* tv = ((*pb)->is_variable()
3536 ? (*pb)->var_value()->type()
3537 : (*pb)->result_var_value()->type());
3539 && Type::traverse(tv, traverse) == TRAVERSE_EXIT)
3540 return TRAVERSE_EXIT;
3543 if (t == TRAVERSE_CONTINUE
3544 && (traverse_mask & e_or_t_or_s) != 0
3545 && (*pb)->is_variable())
3546 t = (*pb)->var_value()->traverse_expression(traverse,
3550 case Named_object::NAMED_OBJECT_FUNC:
3551 case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
3554 case Named_object::NAMED_OBJECT_TYPE:
3555 if ((traverse_mask & e_or_t) != 0)
3556 t = Type::traverse((*pb)->type_value(), traverse);
3559 case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
3560 case Named_object::NAMED_OBJECT_UNKNOWN:
3561 case Named_object::NAMED_OBJECT_ERRONEOUS:
3564 case Named_object::NAMED_OBJECT_PACKAGE:
3565 case Named_object::NAMED_OBJECT_SINK:
3572 if (t == TRAVERSE_EXIT)
3573 return TRAVERSE_EXIT;
3577 // No point in checking traverse_mask here--if we got here we always
3578 // want to walk the statements. The traversal can insert new
3579 // statements before or after the current statement. Inserting
3580 // statements before the current statement requires updating I via
3581 // the pointer; those statements will not be traversed. Any new
3582 // statements inserted after the current statement will be traversed
3584 for (size_t i = 0; i < this->statements_.size(); ++i)
3586 if (this->statements_[i]->traverse(this, &i, traverse) == TRAVERSE_EXIT)
3587 return TRAVERSE_EXIT;
3590 return TRAVERSE_CONTINUE;
3593 // Work out types for unspecified variables and constants.
3596 Block::determine_types()
3598 for (Bindings::const_definitions_iterator pb =
3599 this->bindings_->begin_definitions();
3600 pb != this->bindings_->end_definitions();
3603 if ((*pb)->is_variable())
3604 (*pb)->var_value()->determine_type();
3605 else if ((*pb)->is_const())
3606 (*pb)->const_value()->determine_type();
3609 for (std::vector<Statement*>::const_iterator ps = this->statements_.begin();
3610 ps != this->statements_.end();
3612 (*ps)->determine_types();
3615 // Return true if the statements in this block may fall through.
3618 Block::may_fall_through() const
3620 if (this->statements_.empty())
3622 return this->statements_.back()->may_fall_through();
3625 // Convert a block to the backend representation.
3628 Block::get_backend(Translate_context* context)
3630 Gogo* gogo = context->gogo();
3631 Named_object* function = context->function();
3632 std::vector<Bvariable*> vars;
3633 vars.reserve(this->bindings_->size_definitions());
3634 for (Bindings::const_definitions_iterator pv =
3635 this->bindings_->begin_definitions();
3636 pv != this->bindings_->end_definitions();
3639 if ((*pv)->is_variable() && !(*pv)->var_value()->is_parameter())
3640 vars.push_back((*pv)->get_backend_variable(gogo, function));
3643 // FIXME: Permitting FUNCTION to be NULL here is a temporary measure
3644 // until we have a proper representation of the init function.
3645 Bfunction* bfunction;
3646 if (function == NULL)
3649 bfunction = tree_to_function(function->func_value()->get_decl());
3650 Bblock* ret = context->backend()->block(bfunction, context->bblock(),
3651 vars, this->start_location_,
3652 this->end_location_);
3654 Translate_context subcontext(gogo, function, this, ret);
3655 std::vector<Bstatement*> bstatements;
3656 bstatements.reserve(this->statements_.size());
3657 for (std::vector<Statement*>::const_iterator p = this->statements_.begin();
3658 p != this->statements_.end();
3660 bstatements.push_back((*p)->get_backend(&subcontext));
3662 context->backend()->block_add_statements(ret, bstatements);
3667 // Class Bindings_snapshot.
3669 Bindings_snapshot::Bindings_snapshot(const Block* b, Location location)
3670 : block_(b), counts_(), location_(location)
3674 this->counts_.push_back(b->bindings()->size_definitions());
3679 // Report errors appropriate for a goto from B to this.
3682 Bindings_snapshot::check_goto_from(const Block* b, Location loc)
3685 if (!this->check_goto_block(loc, b, this->block_, &dummy))
3687 this->check_goto_defs(loc, this->block_,
3688 this->block_->bindings()->size_definitions(),
3692 // Report errors appropriate for a goto from this to B.
3695 Bindings_snapshot::check_goto_to(const Block* b)
3698 if (!this->check_goto_block(this->location_, this->block_, b, &index))
3700 this->check_goto_defs(this->location_, b, this->counts_[index],
3701 b->bindings()->size_definitions());
3704 // Report errors appropriate for a goto at LOC from BFROM to BTO.
3705 // Return true if all is well, false if we reported an error. If this
3706 // returns true, it sets *PINDEX to the number of blocks BTO is above
3710 Bindings_snapshot::check_goto_block(Location loc, const Block* bfrom,
3711 const Block* bto, size_t* pindex)
3713 // It is an error if BTO is not either BFROM or above BFROM.
3715 for (const Block* pb = bfrom; pb != bto; pb = pb->enclosing(), ++index)
3719 error_at(loc, "goto jumps into block");
3720 inform(bto->start_location(), "goto target block starts here");
3728 // Report errors appropriate for a goto at LOC ending at BLOCK, where
3729 // CFROM is the number of names defined at the point of the goto and
3730 // CTO is the number of names defined at the point of the label.
3733 Bindings_snapshot::check_goto_defs(Location loc, const Block* block,
3734 size_t cfrom, size_t cto)
3738 Bindings::const_definitions_iterator p =
3739 block->bindings()->begin_definitions();
3740 for (size_t i = 0; i < cfrom; ++i)
3742 go_assert(p != block->bindings()->end_definitions());
3745 go_assert(p != block->bindings()->end_definitions());
3747 std::string n = (*p)->message_name();
3748 error_at(loc, "goto jumps over declaration of %qs", n.c_str());
3749 inform((*p)->location(), "%qs defined here", n.c_str());
3755 Variable::Variable(Type* type, Expression* init, bool is_global,
3756 bool is_parameter, bool is_receiver,
3758 : type_(type), init_(init), preinit_(NULL), location_(location),
3759 backend_(NULL), is_global_(is_global), is_parameter_(is_parameter),
3760 is_receiver_(is_receiver), is_varargs_parameter_(false), is_used_(false),
3761 is_address_taken_(false), is_non_escaping_address_taken_(false),
3762 seen_(false), init_is_lowered_(false), type_from_init_tuple_(false),
3763 type_from_range_index_(false), type_from_range_value_(false),
3764 type_from_chan_element_(false), is_type_switch_var_(false),
3765 determined_type_(false)
3767 go_assert(type != NULL || init != NULL);
3768 go_assert(!is_parameter || init == NULL);
3771 // Traverse the initializer expression.
3774 Variable::traverse_expression(Traverse* traverse, unsigned int traverse_mask)
3776 if (this->preinit_ != NULL)
3778 if (this->preinit_->traverse(traverse) == TRAVERSE_EXIT)
3779 return TRAVERSE_EXIT;
3781 if (this->init_ != NULL
3783 & (Traverse::traverse_expressions | Traverse::traverse_types))
3786 if (Expression::traverse(&this->init_, traverse) == TRAVERSE_EXIT)
3787 return TRAVERSE_EXIT;
3789 return TRAVERSE_CONTINUE;
3792 // Lower the initialization expression after parsing is complete.
3795 Variable::lower_init_expression(Gogo* gogo, Named_object* function,
3796 Statement_inserter* inserter)
3798 if (this->init_ != NULL && !this->init_is_lowered_)
3802 // We will give an error elsewhere, this is just to prevent
3803 // an infinite loop.
3808 Statement_inserter global_inserter;
3809 if (this->is_global_)
3811 global_inserter = Statement_inserter(gogo, this);
3812 inserter = &global_inserter;
3815 gogo->lower_expression(function, inserter, &this->init_);
3817 this->seen_ = false;
3819 this->init_is_lowered_ = true;
3823 // Get the preinit block.
3826 Variable::preinit_block(Gogo* gogo)
3828 go_assert(this->is_global_);
3829 if (this->preinit_ == NULL)
3830 this->preinit_ = new Block(NULL, this->location());
3832 // If a global variable has a preinitialization statement, then we
3833 // need to have an initialization function.
3834 gogo->set_need_init_fn();
3836 return this->preinit_;
3839 // Add a statement to be run before the initialization expression.
3842 Variable::add_preinit_statement(Gogo* gogo, Statement* s)
3844 Block* b = this->preinit_block(gogo);
3845 b->add_statement(s);
3846 b->set_end_location(s->location());
3849 // Whether this variable has a type.
3852 Variable::has_type() const
3854 if (this->type_ == NULL)
3857 // A variable created in a type switch case nil does not actually
3858 // have a type yet. It will be changed to use the initializer's
3859 // type in determine_type.
3860 if (this->is_type_switch_var_
3861 && this->type_->is_nil_constant_as_type())
3867 // In an assignment which sets a variable to a tuple of EXPR, return
3868 // the type of the first element of the tuple.
3871 Variable::type_from_tuple(Expression* expr, bool report_error) const
3873 if (expr->map_index_expression() != NULL)
3875 Map_type* mt = expr->map_index_expression()->get_map_type();
3877 return Type::make_error_type();
3878 return mt->val_type();
3880 else if (expr->receive_expression() != NULL)
3882 Expression* channel = expr->receive_expression()->channel();
3883 Type* channel_type = channel->type();
3884 if (channel_type->channel_type() == NULL)
3885 return Type::make_error_type();
3886 return channel_type->channel_type()->element_type();
3891 error_at(this->location(), "invalid tuple definition");
3892 return Type::make_error_type();
3896 // Given EXPR used in a range clause, return either the index type or
3897 // the value type of the range, depending upon GET_INDEX_TYPE.
3900 Variable::type_from_range(Expression* expr, bool get_index_type,
3901 bool report_error) const
3903 Type* t = expr->type();
3904 if (t->array_type() != NULL
3905 || (t->points_to() != NULL
3906 && t->points_to()->array_type() != NULL
3907 && !t->points_to()->is_slice_type()))
3910 return Type::lookup_integer_type("int");
3912 return t->deref()->array_type()->element_type();
3914 else if (t->is_string_type())
3917 return Type::lookup_integer_type("int");
3919 return Type::lookup_integer_type("int32");
3921 else if (t->map_type() != NULL)
3924 return t->map_type()->key_type();
3926 return t->map_type()->val_type();
3928 else if (t->channel_type() != NULL)
3931 return t->channel_type()->element_type();
3935 error_at(this->location(),
3936 "invalid definition of value variable for channel range");
3937 return Type::make_error_type();
3943 error_at(this->location(), "invalid type for range clause");
3944 return Type::make_error_type();
3948 // EXPR should be a channel. Return the channel's element type.
3951 Variable::type_from_chan_element(Expression* expr, bool report_error) const
3953 Type* t = expr->type();
3954 if (t->channel_type() != NULL)
3955 return t->channel_type()->element_type();
3959 error_at(this->location(), "expected channel");
3960 return Type::make_error_type();
3964 // Return the type of the Variable. This may be called before
3965 // Variable::determine_type is called, which means that we may need to
3966 // get the type from the initializer. FIXME: If we combine lowering
3967 // with type determination, then this should be unnecessary.
3972 // A variable in a type switch with a nil case will have the wrong
3973 // type here. This gets fixed up in determine_type, below.
3974 Type* type = this->type_;
3975 Expression* init = this->init_;
3976 if (this->is_type_switch_var_
3977 && this->type_->is_nil_constant_as_type())
3979 Type_guard_expression* tge = this->init_->type_guard_expression();
3980 go_assert(tge != NULL);
3987 if (this->type_ == NULL || !this->type_->is_error_type())
3989 error_at(this->location_, "variable initializer refers to itself");
3990 this->type_ = Type::make_error_type();
3999 else if (this->type_from_init_tuple_)
4000 type = this->type_from_tuple(init, false);
4001 else if (this->type_from_range_index_ || this->type_from_range_value_)
4002 type = this->type_from_range(init, this->type_from_range_index_, false);
4003 else if (this->type_from_chan_element_)
4004 type = this->type_from_chan_element(init, false);
4007 go_assert(init != NULL);
4008 type = init->type();
4009 go_assert(type != NULL);
4011 // Variables should not have abstract types.
4012 if (type->is_abstract())
4013 type = type->make_non_abstract_type();
4015 if (type->is_void_type())
4016 type = Type::make_error_type();
4019 this->seen_ = false;
4024 // Fetch the type from a const pointer, in which case it should have
4025 // been set already.
4028 Variable::type() const
4030 go_assert(this->type_ != NULL);
4034 // Set the type if necessary.
4037 Variable::determine_type()
4039 if (this->determined_type_)
4041 this->determined_type_ = true;
4043 if (this->preinit_ != NULL)
4044 this->preinit_->determine_types();
4046 // A variable in a type switch with a nil case will have the wrong
4047 // type here. It will have an initializer which is a type guard.
4048 // We want to initialize it to the value without the type guard, and
4049 // use the type of that value as well.
4050 if (this->is_type_switch_var_ && this->type_->is_nil_constant_as_type())
4052 Type_guard_expression* tge = this->init_->type_guard_expression();
4053 go_assert(tge != NULL);
4055 this->init_ = tge->expr();
4058 if (this->init_ == NULL)
4059 go_assert(this->type_ != NULL && !this->type_->is_abstract());
4060 else if (this->type_from_init_tuple_)
4062 Expression *init = this->init_;
4063 init->determine_type_no_context();
4064 this->type_ = this->type_from_tuple(init, true);
4067 else if (this->type_from_range_index_ || this->type_from_range_value_)
4069 Expression* init = this->init_;
4070 init->determine_type_no_context();
4071 this->type_ = this->type_from_range(init, this->type_from_range_index_,
4075 else if (this->type_from_chan_element_)
4077 Expression* init = this->init_;
4078 init->determine_type_no_context();
4079 this->type_ = this->type_from_chan_element(init, true);
4084 Type_context context(this->type_, false);
4085 this->init_->determine_type(&context);
4086 if (this->type_ == NULL)
4088 Type* type = this->init_->type();
4089 go_assert(type != NULL);
4090 if (type->is_abstract())
4091 type = type->make_non_abstract_type();
4093 if (type->is_void_type())
4095 error_at(this->location_, "variable has no type");
4096 type = Type::make_error_type();
4098 else if (type->is_nil_type())
4100 error_at(this->location_, "variable defined to nil type");
4101 type = Type::make_error_type();
4103 else if (type->is_call_multiple_result_type())
4105 error_at(this->location_,
4106 "single variable set to multiple value function call");
4107 type = Type::make_error_type();
4115 // Export the variable
4118 Variable::export_var(Export* exp, const std::string& name) const
4120 go_assert(this->is_global_);
4121 exp->write_c_string("var ");
4122 exp->write_string(name);
4123 exp->write_c_string(" ");
4124 exp->write_type(this->type());
4125 exp->write_c_string(";\n");
4128 // Import a variable.
4131 Variable::import_var(Import* imp, std::string* pname, Type** ptype)
4133 imp->require_c_string("var ");
4134 *pname = imp->read_identifier();
4135 imp->require_c_string(" ");
4136 *ptype = imp->read_type();
4137 imp->require_c_string(";\n");
4140 // Convert a variable to the backend representation.
4143 Variable::get_backend_variable(Gogo* gogo, Named_object* function,
4144 const Package* package, const std::string& name)
4146 if (this->backend_ == NULL)
4148 Backend* backend = gogo->backend();
4149 Type* type = this->type_;
4150 if (type->is_error_type()
4151 || (type->is_undefined()
4152 && (!this->is_global_ || package == NULL)))
4153 this->backend_ = backend->error_variable();
4156 bool is_parameter = this->is_parameter_;
4157 if (this->is_receiver_ && type->points_to() == NULL)
4158 is_parameter = false;
4159 if (this->is_in_heap())
4161 is_parameter = false;
4162 type = Type::make_pointer_type(type);
4165 std::string n = Gogo::unpack_hidden_name(name);
4166 Btype* btype = type->get_backend(gogo);
4169 if (this->is_global_)
4170 bvar = backend->global_variable((package == NULL
4171 ? gogo->package_name()
4174 ? gogo->unique_prefix()
4175 : package->unique_prefix()),
4179 Gogo::is_hidden_name(name),
4181 else if (function == NULL)
4183 go_assert(saw_errors());
4184 bvar = backend->error_variable();
4188 tree fndecl = function->func_value()->get_decl();
4189 Bfunction* bfunction = tree_to_function(fndecl);
4190 bool is_address_taken = (this->is_non_escaping_address_taken_
4191 && !this->is_in_heap());
4193 bvar = backend->parameter_variable(bfunction, n, btype,
4197 bvar = backend->local_variable(bfunction, n, btype,
4201 this->backend_ = bvar;
4204 return this->backend_;
4207 // Class Result_variable.
4209 // Convert a result variable to the backend representation.
4212 Result_variable::get_backend_variable(Gogo* gogo, Named_object* function,
4213 const std::string& name)
4215 if (this->backend_ == NULL)
4217 Backend* backend = gogo->backend();
4218 Type* type = this->type_;
4219 if (type->is_error())
4220 this->backend_ = backend->error_variable();
4223 if (this->is_in_heap())
4224 type = Type::make_pointer_type(type);
4225 Btype* btype = type->get_backend(gogo);
4226 tree fndecl = function->func_value()->get_decl();
4227 Bfunction* bfunction = tree_to_function(fndecl);
4228 std::string n = Gogo::unpack_hidden_name(name);
4229 bool is_address_taken = (this->is_non_escaping_address_taken_
4230 && !this->is_in_heap());
4231 this->backend_ = backend->local_variable(bfunction, n, btype,
4236 return this->backend_;
4239 // Class Named_constant.
4241 // Traverse the initializer expression.
4244 Named_constant::traverse_expression(Traverse* traverse)
4246 return Expression::traverse(&this->expr_, traverse);
4249 // Determine the type of the constant.
4252 Named_constant::determine_type()
4254 if (this->type_ != NULL)
4256 Type_context context(this->type_, false);
4257 this->expr_->determine_type(&context);
4261 // A constant may have an abstract type.
4262 Type_context context(NULL, true);
4263 this->expr_->determine_type(&context);
4264 this->type_ = this->expr_->type();
4265 go_assert(this->type_ != NULL);
4269 // Indicate that we found and reported an error for this constant.
4272 Named_constant::set_error()
4274 this->type_ = Type::make_error_type();
4275 this->expr_ = Expression::make_error(this->location_);
4278 // Export a constant.
4281 Named_constant::export_const(Export* exp, const std::string& name) const
4283 exp->write_c_string("const ");
4284 exp->write_string(name);
4285 exp->write_c_string(" ");
4286 if (!this->type_->is_abstract())
4288 exp->write_type(this->type_);
4289 exp->write_c_string(" ");
4291 exp->write_c_string("= ");
4292 this->expr()->export_expression(exp);
4293 exp->write_c_string(";\n");
4296 // Import a constant.
4299 Named_constant::import_const(Import* imp, std::string* pname, Type** ptype,
4302 imp->require_c_string("const ");
4303 *pname = imp->read_identifier();
4304 imp->require_c_string(" ");
4305 if (imp->peek_char() == '=')
4309 *ptype = imp->read_type();
4310 imp->require_c_string(" ");
4312 imp->require_c_string("= ");
4313 *pexpr = Expression::import_expression(imp);
4314 imp->require_c_string(";\n");
4320 Type_declaration::add_method(const std::string& name, Function* function)
4322 Named_object* ret = Named_object::make_function(name, NULL, function);
4323 this->methods_.push_back(ret);
4327 // Add a method declaration.
4330 Type_declaration::add_method_declaration(const std::string& name,
4332 Function_type* type,
4335 Named_object* ret = Named_object::make_function_declaration(name, package,
4337 this->methods_.push_back(ret);
4341 // Return whether any methods ere defined.
4344 Type_declaration::has_methods() const
4346 return !this->methods_.empty();
4349 // Define methods for the real type.
4352 Type_declaration::define_methods(Named_type* nt)
4354 for (Methods::const_iterator p = this->methods_.begin();
4355 p != this->methods_.end();
4357 nt->add_existing_method(*p);
4360 // We are using the type. Return true if we should issue a warning.
4363 Type_declaration::using_type()
4365 bool ret = !this->issued_warning_;
4366 this->issued_warning_ = true;
4370 // Class Unknown_name.
4372 // Set the real named object.
4375 Unknown_name::set_real_named_object(Named_object* no)
4377 go_assert(this->real_named_object_ == NULL);
4378 go_assert(!no->is_unknown());
4379 this->real_named_object_ = no;
4382 // Class Named_object.
4384 Named_object::Named_object(const std::string& name,
4385 const Package* package,
4386 Classification classification)
4387 : name_(name), package_(package), classification_(classification),
4390 if (Gogo::is_sink_name(name))
4391 go_assert(classification == NAMED_OBJECT_SINK);
4394 // Make an unknown name. This is used by the parser. The name must
4395 // be resolved later. Unknown names are only added in the current
4399 Named_object::make_unknown_name(const std::string& name,
4402 Named_object* named_object = new Named_object(name, NULL,
4403 NAMED_OBJECT_UNKNOWN);
4404 Unknown_name* value = new Unknown_name(location);
4405 named_object->u_.unknown_value = value;
4406 return named_object;
4412 Named_object::make_constant(const Typed_identifier& tid,
4413 const Package* package, Expression* expr,
4416 Named_object* named_object = new Named_object(tid.name(), package,
4417 NAMED_OBJECT_CONST);
4418 Named_constant* named_constant = new Named_constant(tid.type(), expr,
4421 named_object->u_.const_value = named_constant;
4422 return named_object;
4425 // Make a named type.
4428 Named_object::make_type(const std::string& name, const Package* package,
4429 Type* type, Location location)
4431 Named_object* named_object = new Named_object(name, package,
4433 Named_type* named_type = Type::make_named_type(named_object, type, location);
4434 named_object->u_.type_value = named_type;
4435 return named_object;
4438 // Make a type declaration.
4441 Named_object::make_type_declaration(const std::string& name,
4442 const Package* package,
4445 Named_object* named_object = new Named_object(name, package,
4446 NAMED_OBJECT_TYPE_DECLARATION);
4447 Type_declaration* type_declaration = new Type_declaration(location);
4448 named_object->u_.type_declaration = type_declaration;
4449 return named_object;
4455 Named_object::make_variable(const std::string& name, const Package* package,
4458 Named_object* named_object = new Named_object(name, package,
4460 named_object->u_.var_value = variable;
4461 return named_object;
4464 // Make a result variable.
4467 Named_object::make_result_variable(const std::string& name,
4468 Result_variable* result)
4470 Named_object* named_object = new Named_object(name, NULL,
4471 NAMED_OBJECT_RESULT_VAR);
4472 named_object->u_.result_var_value = result;
4473 return named_object;
4476 // Make a sink. This is used for the special blank identifier _.
4479 Named_object::make_sink()
4481 return new Named_object("_", NULL, NAMED_OBJECT_SINK);
4484 // Make a named function.
4487 Named_object::make_function(const std::string& name, const Package* package,
4490 Named_object* named_object = new Named_object(name, package,
4492 named_object->u_.func_value = function;
4493 return named_object;
4496 // Make a function declaration.
4499 Named_object::make_function_declaration(const std::string& name,
4500 const Package* package,
4501 Function_type* fntype,
4504 Named_object* named_object = new Named_object(name, package,
4505 NAMED_OBJECT_FUNC_DECLARATION);
4506 Function_declaration *func_decl = new Function_declaration(fntype, location);
4507 named_object->u_.func_declaration_value = func_decl;
4508 return named_object;
4514 Named_object::make_package(const std::string& alias, Package* package)
4516 Named_object* named_object = new Named_object(alias, NULL,
4517 NAMED_OBJECT_PACKAGE);
4518 named_object->u_.package_value = package;
4519 return named_object;
4522 // Return the name to use in an error message.
4525 Named_object::message_name() const
4527 if (this->package_ == NULL)
4528 return Gogo::message_name(this->name_);
4529 std::string ret = Gogo::message_name(this->package_->name());
4531 ret += Gogo::message_name(this->name_);
4535 // Set the type when a declaration is defined.
4538 Named_object::set_type_value(Named_type* named_type)
4540 go_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
4541 Type_declaration* td = this->u_.type_declaration;
4542 td->define_methods(named_type);
4543 Named_object* in_function = td->in_function();
4544 if (in_function != NULL)
4545 named_type->set_in_function(in_function);
4547 this->classification_ = NAMED_OBJECT_TYPE;
4548 this->u_.type_value = named_type;
4551 // Define a function which was previously declared.
4554 Named_object::set_function_value(Function* function)
4556 go_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
4557 this->classification_ = NAMED_OBJECT_FUNC;
4558 // FIXME: We should free the old value.
4559 this->u_.func_value = function;
4562 // Declare an unknown object as a type declaration.
4565 Named_object::declare_as_type()
4567 go_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
4568 Unknown_name* unk = this->u_.unknown_value;
4569 this->classification_ = NAMED_OBJECT_TYPE_DECLARATION;
4570 this->u_.type_declaration = new Type_declaration(unk->location());
4574 // Return the location of a named object.
4577 Named_object::location() const
4579 switch (this->classification_)
4582 case NAMED_OBJECT_UNINITIALIZED:
4585 case NAMED_OBJECT_ERRONEOUS:
4586 return Linemap::unknown_location();
4588 case NAMED_OBJECT_UNKNOWN:
4589 return this->unknown_value()->location();
4591 case NAMED_OBJECT_CONST:
4592 return this->const_value()->location();
4594 case NAMED_OBJECT_TYPE:
4595 return this->type_value()->location();
4597 case NAMED_OBJECT_TYPE_DECLARATION:
4598 return this->type_declaration_value()->location();
4600 case NAMED_OBJECT_VAR:
4601 return this->var_value()->location();
4603 case NAMED_OBJECT_RESULT_VAR:
4604 return this->result_var_value()->location();
4606 case NAMED_OBJECT_SINK:
4609 case NAMED_OBJECT_FUNC:
4610 return this->func_value()->location();
4612 case NAMED_OBJECT_FUNC_DECLARATION:
4613 return this->func_declaration_value()->location();
4615 case NAMED_OBJECT_PACKAGE:
4616 return this->package_value()->location();
4620 // Export a named object.
4623 Named_object::export_named_object(Export* exp) const
4625 switch (this->classification_)
4628 case NAMED_OBJECT_UNINITIALIZED:
4629 case NAMED_OBJECT_UNKNOWN:
4632 case NAMED_OBJECT_ERRONEOUS:
4635 case NAMED_OBJECT_CONST:
4636 this->const_value()->export_const(exp, this->name_);
4639 case NAMED_OBJECT_TYPE:
4640 this->type_value()->export_named_type(exp, this->name_);
4643 case NAMED_OBJECT_TYPE_DECLARATION:
4644 error_at(this->type_declaration_value()->location(),
4645 "attempt to export %<%s%> which was declared but not defined",
4646 this->message_name().c_str());
4649 case NAMED_OBJECT_FUNC_DECLARATION:
4650 this->func_declaration_value()->export_func(exp, this->name_);
4653 case NAMED_OBJECT_VAR:
4654 this->var_value()->export_var(exp, this->name_);
4657 case NAMED_OBJECT_RESULT_VAR:
4658 case NAMED_OBJECT_SINK:
4661 case NAMED_OBJECT_FUNC:
4662 this->func_value()->export_func(exp, this->name_);
4667 // Convert a variable to the backend representation.
4670 Named_object::get_backend_variable(Gogo* gogo, Named_object* function)
4672 if (this->classification_ == NAMED_OBJECT_VAR)
4673 return this->var_value()->get_backend_variable(gogo, function,
4674 this->package_, this->name_);
4675 else if (this->classification_ == NAMED_OBJECT_RESULT_VAR)
4676 return this->result_var_value()->get_backend_variable(gogo, function,
4684 Bindings::Bindings(Bindings* enclosing)
4685 : enclosing_(enclosing), named_objects_(), bindings_()
4692 Bindings::clear_file_scope()
4694 Contour::iterator p = this->bindings_.begin();
4695 while (p != this->bindings_.end())
4698 if (p->second->package() != NULL)
4700 else if (p->second->is_package())
4702 else if (p->second->is_function()
4703 && !p->second->func_value()->type()->is_method()
4704 && Gogo::unpack_hidden_name(p->second->name()) == "init")
4712 p = this->bindings_.erase(p);
4716 // Look up a symbol.
4719 Bindings::lookup(const std::string& name) const
4721 Contour::const_iterator p = this->bindings_.find(name);
4722 if (p != this->bindings_.end())
4723 return p->second->resolve();
4724 else if (this->enclosing_ != NULL)
4725 return this->enclosing_->lookup(name);
4730 // Look up a symbol locally.
4733 Bindings::lookup_local(const std::string& name) const
4735 Contour::const_iterator p = this->bindings_.find(name);
4736 if (p == this->bindings_.end())
4741 // Remove an object from a set of bindings. This is used for a
4742 // special case in thunks for functions which call recover.
4745 Bindings::remove_binding(Named_object* no)
4747 Contour::iterator pb = this->bindings_.find(no->name());
4748 go_assert(pb != this->bindings_.end());
4749 this->bindings_.erase(pb);
4750 for (std::vector<Named_object*>::iterator pn = this->named_objects_.begin();
4751 pn != this->named_objects_.end();
4756 this->named_objects_.erase(pn);
4763 // Add a method to the list of objects. This is not added to the
4764 // lookup table. This is so that we have a single list of objects
4765 // declared at the top level, which we walk through when it's time to
4766 // convert to trees.
4769 Bindings::add_method(Named_object* method)
4771 this->named_objects_.push_back(method);
4774 // Add a generic Named_object to a Contour.
4777 Bindings::add_named_object_to_contour(Contour* contour,
4778 Named_object* named_object)
4780 go_assert(named_object == named_object->resolve());
4781 const std::string& name(named_object->name());
4782 go_assert(!Gogo::is_sink_name(name));
4784 std::pair<Contour::iterator, bool> ins =
4785 contour->insert(std::make_pair(name, named_object));
4788 // The name was already there.
4789 if (named_object->package() != NULL
4790 && ins.first->second->package() == named_object->package()
4791 && (ins.first->second->classification()
4792 == named_object->classification()))
4794 // This is a second import of the same object.
4795 return ins.first->second;
4797 ins.first->second = this->new_definition(ins.first->second,
4799 return ins.first->second;
4803 // Don't push declarations on the list. We push them on when
4804 // and if we find the definitions. That way we genericize the
4805 // functions in order.
4806 if (!named_object->is_type_declaration()
4807 && !named_object->is_function_declaration()
4808 && !named_object->is_unknown())
4809 this->named_objects_.push_back(named_object);
4810 return named_object;
4814 // We had an existing named object OLD_OBJECT, and we've seen a new
4815 // one NEW_OBJECT with the same name. FIXME: This does not free the
4816 // new object when we don't need it.
4819 Bindings::new_definition(Named_object* old_object, Named_object* new_object)
4821 if (new_object->is_erroneous() && !old_object->is_erroneous())
4825 switch (old_object->classification())
4828 case Named_object::NAMED_OBJECT_UNINITIALIZED:
4831 case Named_object::NAMED_OBJECT_ERRONEOUS:
4834 case Named_object::NAMED_OBJECT_UNKNOWN:
4836 Named_object* real = old_object->unknown_value()->real_named_object();
4838 return this->new_definition(real, new_object);
4839 go_assert(!new_object->is_unknown());
4840 old_object->unknown_value()->set_real_named_object(new_object);
4841 if (!new_object->is_type_declaration()
4842 && !new_object->is_function_declaration())
4843 this->named_objects_.push_back(new_object);
4847 case Named_object::NAMED_OBJECT_CONST:
4850 case Named_object::NAMED_OBJECT_TYPE:
4851 if (new_object->is_type_declaration())
4855 case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
4856 if (new_object->is_type_declaration())
4858 if (new_object->is_type())
4860 old_object->set_type_value(new_object->type_value());
4861 new_object->type_value()->set_named_object(old_object);
4862 this->named_objects_.push_back(old_object);
4867 case Named_object::NAMED_OBJECT_VAR:
4868 case Named_object::NAMED_OBJECT_RESULT_VAR:
4869 // We have already given an error in the parser for cases where
4870 // one parameter or result variable redeclares another one.
4871 if ((new_object->is_variable()
4872 && new_object->var_value()->is_parameter())
4873 || new_object->is_result_variable())
4877 case Named_object::NAMED_OBJECT_SINK:
4880 case Named_object::NAMED_OBJECT_FUNC:
4881 if (new_object->is_function_declaration())
4883 if (!new_object->func_declaration_value()->asm_name().empty())
4884 sorry("__asm__ for function definitions");
4885 Function_type* old_type = old_object->func_value()->type();
4886 Function_type* new_type =
4887 new_object->func_declaration_value()->type();
4888 if (old_type->is_valid_redeclaration(new_type, &reason))
4893 case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
4895 Function_type* old_type = old_object->func_declaration_value()->type();
4896 if (new_object->is_function_declaration())
4898 Function_type* new_type =
4899 new_object->func_declaration_value()->type();
4900 if (old_type->is_valid_redeclaration(new_type, &reason))
4903 if (new_object->is_function())
4905 Function_type* new_type = new_object->func_value()->type();
4906 if (old_type->is_valid_redeclaration(new_type, &reason))
4908 if (!old_object->func_declaration_value()->asm_name().empty())
4909 sorry("__asm__ for function definitions");
4910 old_object->set_function_value(new_object->func_value());
4911 this->named_objects_.push_back(old_object);
4918 case Named_object::NAMED_OBJECT_PACKAGE:
4919 if (new_object->is_package()
4920 && (old_object->package_value()->name()
4921 == new_object->package_value()->name()))
4927 std::string n = old_object->message_name();
4929 error_at(new_object->location(), "redefinition of %qs", n.c_str());
4931 error_at(new_object->location(), "redefinition of %qs: %s", n.c_str(),
4934 inform(old_object->location(), "previous definition of %qs was here",
4940 // Add a named type.
4943 Bindings::add_named_type(Named_type* named_type)
4945 return this->add_named_object(named_type->named_object());
4951 Bindings::add_function(const std::string& name, const Package* package,
4954 return this->add_named_object(Named_object::make_function(name, package,
4958 // Add a function declaration.
4961 Bindings::add_function_declaration(const std::string& name,
4962 const Package* package,
4963 Function_type* type,
4966 Named_object* no = Named_object::make_function_declaration(name, package,
4968 return this->add_named_object(no);
4971 // Define a type which was previously declared.
4974 Bindings::define_type(Named_object* no, Named_type* type)
4976 no->set_type_value(type);
4977 this->named_objects_.push_back(no);
4980 // Mark all local variables as used. This is used for some types of
4984 Bindings::mark_locals_used()
4986 for (std::vector<Named_object*>::iterator p = this->named_objects_.begin();
4987 p != this->named_objects_.end();
4989 if ((*p)->is_variable())
4990 (*p)->var_value()->set_is_used();
4993 // Traverse bindings.
4996 Bindings::traverse(Traverse* traverse, bool is_global)
4998 unsigned int traverse_mask = traverse->traverse_mask();
5000 // We don't use an iterator because we permit the traversal to add
5001 // new global objects.
5002 const unsigned int e_or_t = (Traverse::traverse_expressions
5003 | Traverse::traverse_types);
5004 const unsigned int e_or_t_or_s = (e_or_t
5005 | Traverse::traverse_statements);
5006 for (size_t i = 0; i < this->named_objects_.size(); ++i)
5008 Named_object* p = this->named_objects_[i];
5009 int t = TRAVERSE_CONTINUE;
5010 switch (p->classification())
5012 case Named_object::NAMED_OBJECT_CONST:
5013 if ((traverse_mask & Traverse::traverse_constants) != 0)
5014 t = traverse->constant(p, is_global);
5015 if (t == TRAVERSE_CONTINUE
5016 && (traverse_mask & e_or_t) != 0)
5018 Type* tc = p->const_value()->type();
5020 && Type::traverse(tc, traverse) == TRAVERSE_EXIT)
5021 return TRAVERSE_EXIT;
5022 t = p->const_value()->traverse_expression(traverse);
5026 case Named_object::NAMED_OBJECT_VAR:
5027 case Named_object::NAMED_OBJECT_RESULT_VAR:
5028 if ((traverse_mask & Traverse::traverse_variables) != 0)
5029 t = traverse->variable(p);
5030 if (t == TRAVERSE_CONTINUE
5031 && (traverse_mask & e_or_t) != 0)
5033 if (p->is_result_variable()
5034 || p->var_value()->has_type())
5036 Type* tv = (p->is_variable()
5037 ? p->var_value()->type()
5038 : p->result_var_value()->type());
5040 && Type::traverse(tv, traverse) == TRAVERSE_EXIT)
5041 return TRAVERSE_EXIT;
5044 if (t == TRAVERSE_CONTINUE
5045 && (traverse_mask & e_or_t_or_s) != 0
5046 && p->is_variable())
5047 t = p->var_value()->traverse_expression(traverse, traverse_mask);
5050 case Named_object::NAMED_OBJECT_FUNC:
5051 if ((traverse_mask & Traverse::traverse_functions) != 0)
5052 t = traverse->function(p);
5054 if (t == TRAVERSE_CONTINUE
5056 & (Traverse::traverse_variables
5057 | Traverse::traverse_constants
5058 | Traverse::traverse_functions
5059 | Traverse::traverse_blocks
5060 | Traverse::traverse_statements
5061 | Traverse::traverse_expressions
5062 | Traverse::traverse_types)) != 0)
5063 t = p->func_value()->traverse(traverse);
5066 case Named_object::NAMED_OBJECT_PACKAGE:
5067 // These are traversed in Gogo::traverse.
5068 go_assert(is_global);
5071 case Named_object::NAMED_OBJECT_TYPE:
5072 if ((traverse_mask & e_or_t) != 0)
5073 t = Type::traverse(p->type_value(), traverse);
5076 case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
5077 case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
5078 case Named_object::NAMED_OBJECT_UNKNOWN:
5079 case Named_object::NAMED_OBJECT_ERRONEOUS:
5082 case Named_object::NAMED_OBJECT_SINK:
5087 if (t == TRAVERSE_EXIT)
5088 return TRAVERSE_EXIT;
5091 // If we need to traverse types, check the function declarations,
5092 // which have types. We don't need to check the type declarations,
5093 // as those are just names.
5094 if ((traverse_mask & e_or_t) != 0)
5096 for (Bindings::const_declarations_iterator p =
5097 this->begin_declarations();
5098 p != this->end_declarations();
5101 if (p->second->is_function_declaration())
5103 if (Type::traverse(p->second->func_declaration_value()->type(),
5106 return TRAVERSE_EXIT;
5111 return TRAVERSE_CONTINUE;
5116 // Clear any references to this label.
5121 for (std::vector<Bindings_snapshot*>::iterator p = this->refs_.begin();
5122 p != this->refs_.end();
5125 this->refs_.clear();
5128 // Get the backend representation for a label.
5131 Label::get_backend_label(Translate_context* context)
5133 if (this->blabel_ == NULL)
5135 Function* function = context->function()->func_value();
5136 tree fndecl = function->get_decl();
5137 Bfunction* bfunction = tree_to_function(fndecl);
5138 this->blabel_ = context->backend()->label(bfunction, this->name_,
5141 return this->blabel_;
5144 // Return an expression for the address of this label.
5147 Label::get_addr(Translate_context* context, Location location)
5149 Blabel* label = this->get_backend_label(context);
5150 return context->backend()->label_address(label, location);
5153 // Class Unnamed_label.
5155 // Get the backend representation for an unnamed label.
5158 Unnamed_label::get_blabel(Translate_context* context)
5160 if (this->blabel_ == NULL)
5162 Function* function = context->function()->func_value();
5163 tree fndecl = function->get_decl();
5164 Bfunction* bfunction = tree_to_function(fndecl);
5165 this->blabel_ = context->backend()->label(bfunction, "",
5168 return this->blabel_;
5171 // Return a statement which defines this unnamed label.
5174 Unnamed_label::get_definition(Translate_context* context)
5176 Blabel* blabel = this->get_blabel(context);
5177 return context->backend()->label_definition_statement(blabel);
5180 // Return a goto statement to this unnamed label.
5183 Unnamed_label::get_goto(Translate_context* context, Location location)
5185 Blabel* blabel = this->get_blabel(context);
5186 return context->backend()->goto_statement(blabel, location);
5191 Package::Package(const std::string& name, const std::string& unique_prefix,
5193 : name_(name), unique_prefix_(unique_prefix), bindings_(new Bindings(NULL)),
5194 priority_(0), location_(location), used_(false), is_imported_(false),
5195 uses_sink_alias_(false)
5197 go_assert(!name.empty() && !unique_prefix.empty());
5200 // Set the priority. We may see multiple priorities for an imported
5201 // package; we want to use the largest one.
5204 Package::set_priority(int priority)
5206 if (priority > this->priority_)
5207 this->priority_ = priority;
5210 // Determine types of constants. Everything else in a package
5211 // (variables, function declarations) should already have a fixed
5212 // type. Constants may have abstract types.
5215 Package::determine_types()
5217 Bindings* bindings = this->bindings_;
5218 for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
5219 p != bindings->end_definitions();
5222 if ((*p)->is_const())
5223 (*p)->const_value()->determine_type();
5231 Traverse::~Traverse()
5233 if (this->types_seen_ != NULL)
5234 delete this->types_seen_;
5235 if (this->expressions_seen_ != NULL)
5236 delete this->expressions_seen_;
5239 // Record that we are looking at a type, and return true if we have
5243 Traverse::remember_type(const Type* type)
5245 if (type->is_error_type())
5247 go_assert((this->traverse_mask() & traverse_types) != 0
5248 || (this->traverse_mask() & traverse_expressions) != 0);
5249 // We mostly only have to remember named types. But it turns out
5250 // that an interface type can refer to itself without using a name
5251 // by relying on interface inheritance, as in
5252 // type I interface { F() interface{I} }
5253 if (type->classification() != Type::TYPE_NAMED
5254 && type->classification() != Type::TYPE_INTERFACE)
5256 if (this->types_seen_ == NULL)
5257 this->types_seen_ = new Types_seen();
5258 std::pair<Types_seen::iterator, bool> ins = this->types_seen_->insert(type);
5262 // Record that we are looking at an expression, and return true if we
5263 // have already seen it.
5266 Traverse::remember_expression(const Expression* expression)
5268 go_assert((this->traverse_mask() & traverse_types) != 0
5269 || (this->traverse_mask() & traverse_expressions) != 0);
5270 if (this->expressions_seen_ == NULL)
5271 this->expressions_seen_ = new Expressions_seen();
5272 std::pair<Expressions_seen::iterator, bool> ins =
5273 this->expressions_seen_->insert(expression);
5277 // The default versions of these functions should never be called: the
5278 // traversal mask indicates which functions may be called.
5281 Traverse::variable(Named_object*)
5287 Traverse::constant(Named_object*, bool)
5293 Traverse::function(Named_object*)
5299 Traverse::block(Block*)
5305 Traverse::statement(Block*, size_t*, Statement*)
5311 Traverse::expression(Expression**)
5317 Traverse::type(Type*)
5322 // Class Statement_inserter.
5325 Statement_inserter::insert(Statement* s)
5327 if (this->block_ != NULL)
5329 go_assert(this->pindex_ != NULL);
5330 this->block_->insert_statement_before(*this->pindex_, s);
5333 else if (this->var_ != NULL)
5334 this->var_->add_preinit_statement(this->gogo_, s);