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.
11 #include "filenames.h"
14 #include "go-diagnostics.h"
15 #include "go-encode-id.h"
17 #include "go-optimize.h"
20 #include "statements.h"
21 #include "expressions.h"
30 Gogo::Gogo(Backend
* backend
, Linemap
* linemap
, int, int pointer_size
)
35 globals_(new Bindings(NULL
)),
38 imported_unsafe_(false),
39 current_file_imported_unsafe_(false),
50 pkgpath_from_option_(false),
51 prefix_from_option_(false),
52 relative_import_path_(),
54 check_divide_by_zero_(true),
55 check_divide_overflow_(true),
56 compiling_runtime_(false),
57 debug_escape_level_(0),
58 nil_check_size_threshold_(4096),
61 specific_type_functions_(),
62 specific_type_functions_are_written_(false),
63 named_types_are_converted_(false),
67 const Location loc
= Linemap::predeclared_location();
69 Named_type
* uint8_type
= Type::make_integer_type("uint8", true, 8,
70 RUNTIME_TYPE_KIND_UINT8
);
71 this->add_named_type(uint8_type
);
72 this->add_named_type(Type::make_integer_type("uint16", true, 16,
73 RUNTIME_TYPE_KIND_UINT16
));
74 this->add_named_type(Type::make_integer_type("uint32", true, 32,
75 RUNTIME_TYPE_KIND_UINT32
));
76 this->add_named_type(Type::make_integer_type("uint64", true, 64,
77 RUNTIME_TYPE_KIND_UINT64
));
79 this->add_named_type(Type::make_integer_type("int8", false, 8,
80 RUNTIME_TYPE_KIND_INT8
));
81 this->add_named_type(Type::make_integer_type("int16", false, 16,
82 RUNTIME_TYPE_KIND_INT16
));
83 Named_type
* int32_type
= Type::make_integer_type("int32", false, 32,
84 RUNTIME_TYPE_KIND_INT32
);
85 this->add_named_type(int32_type
);
86 this->add_named_type(Type::make_integer_type("int64", false, 64,
87 RUNTIME_TYPE_KIND_INT64
));
89 this->add_named_type(Type::make_float_type("float32", 32,
90 RUNTIME_TYPE_KIND_FLOAT32
));
91 this->add_named_type(Type::make_float_type("float64", 64,
92 RUNTIME_TYPE_KIND_FLOAT64
));
94 this->add_named_type(Type::make_complex_type("complex64", 64,
95 RUNTIME_TYPE_KIND_COMPLEX64
));
96 this->add_named_type(Type::make_complex_type("complex128", 128,
97 RUNTIME_TYPE_KIND_COMPLEX128
));
99 int int_type_size
= pointer_size
;
100 if (int_type_size
< 32)
102 this->add_named_type(Type::make_integer_type("uint", true,
104 RUNTIME_TYPE_KIND_UINT
));
105 Named_type
* int_type
= Type::make_integer_type("int", false, int_type_size
,
106 RUNTIME_TYPE_KIND_INT
);
107 this->add_named_type(int_type
);
109 this->add_named_type(Type::make_integer_type("uintptr", true,
111 RUNTIME_TYPE_KIND_UINTPTR
));
113 // "byte" is an alias for "uint8".
114 uint8_type
->integer_type()->set_is_byte();
115 Named_object
* byte_type
= Named_object::make_type("byte", NULL
, uint8_type
,
117 byte_type
->type_value()->set_is_alias();
118 this->add_named_type(byte_type
->type_value());
120 // "rune" is an alias for "int32".
121 int32_type
->integer_type()->set_is_rune();
122 Named_object
* rune_type
= Named_object::make_type("rune", NULL
, int32_type
,
124 rune_type
->type_value()->set_is_alias();
125 this->add_named_type(rune_type
->type_value());
127 this->add_named_type(Type::make_named_bool_type());
129 this->add_named_type(Type::make_named_string_type());
131 // "error" is interface { Error() string }.
133 Typed_identifier_list
*methods
= new Typed_identifier_list
;
134 Typed_identifier_list
*results
= new Typed_identifier_list
;
135 results
->push_back(Typed_identifier("", Type::lookup_string_type(), loc
));
136 Type
*method_type
= Type::make_function_type(NULL
, NULL
, results
, loc
);
137 methods
->push_back(Typed_identifier("Error", method_type
, loc
));
138 Interface_type
*error_iface
= Type::make_interface_type(methods
, loc
);
139 error_iface
->finalize_methods();
140 Named_type
*error_type
= Named_object::make_type("error", NULL
, error_iface
, loc
)->type_value();
141 this->add_named_type(error_type
);
144 this->globals_
->add_constant(Typed_identifier("true",
145 Type::make_boolean_type(),
148 Expression::make_boolean(true, loc
),
150 this->globals_
->add_constant(Typed_identifier("false",
151 Type::make_boolean_type(),
154 Expression::make_boolean(false, loc
),
157 this->globals_
->add_constant(Typed_identifier("nil", Type::make_nil_type(),
160 Expression::make_nil(loc
),
163 Type
* abstract_int_type
= Type::make_abstract_integer_type();
164 this->globals_
->add_constant(Typed_identifier("iota", abstract_int_type
,
167 Expression::make_iota(),
170 Function_type
* new_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
171 new_type
->set_is_varargs();
172 new_type
->set_is_builtin();
173 this->globals_
->add_function_declaration("new", NULL
, new_type
, loc
);
175 Function_type
* make_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
176 make_type
->set_is_varargs();
177 make_type
->set_is_builtin();
178 this->globals_
->add_function_declaration("make", NULL
, make_type
, loc
);
180 Typed_identifier_list
* len_result
= new Typed_identifier_list();
181 len_result
->push_back(Typed_identifier("", int_type
, loc
));
182 Function_type
* len_type
= Type::make_function_type(NULL
, NULL
, len_result
,
184 len_type
->set_is_builtin();
185 this->globals_
->add_function_declaration("len", NULL
, len_type
, loc
);
187 Typed_identifier_list
* cap_result
= new Typed_identifier_list();
188 cap_result
->push_back(Typed_identifier("", int_type
, loc
));
189 Function_type
* cap_type
= Type::make_function_type(NULL
, NULL
, len_result
,
191 cap_type
->set_is_builtin();
192 this->globals_
->add_function_declaration("cap", NULL
, cap_type
, loc
);
194 Function_type
* print_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
195 print_type
->set_is_varargs();
196 print_type
->set_is_builtin();
197 this->globals_
->add_function_declaration("print", NULL
, print_type
, loc
);
199 print_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
200 print_type
->set_is_varargs();
201 print_type
->set_is_builtin();
202 this->globals_
->add_function_declaration("println", NULL
, print_type
, loc
);
204 Type
*empty
= Type::make_empty_interface_type(loc
);
205 Typed_identifier_list
* panic_parms
= new Typed_identifier_list();
206 panic_parms
->push_back(Typed_identifier("e", empty
, loc
));
207 Function_type
*panic_type
= Type::make_function_type(NULL
, panic_parms
,
209 panic_type
->set_is_builtin();
210 this->globals_
->add_function_declaration("panic", NULL
, panic_type
, loc
);
212 Typed_identifier_list
* recover_result
= new Typed_identifier_list();
213 recover_result
->push_back(Typed_identifier("", empty
, loc
));
214 Function_type
* recover_type
= Type::make_function_type(NULL
, NULL
,
217 recover_type
->set_is_builtin();
218 this->globals_
->add_function_declaration("recover", NULL
, recover_type
, loc
);
220 Function_type
* close_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
221 close_type
->set_is_varargs();
222 close_type
->set_is_builtin();
223 this->globals_
->add_function_declaration("close", NULL
, close_type
, loc
);
225 Typed_identifier_list
* copy_result
= new Typed_identifier_list();
226 copy_result
->push_back(Typed_identifier("", int_type
, loc
));
227 Function_type
* copy_type
= Type::make_function_type(NULL
, NULL
,
229 copy_type
->set_is_varargs();
230 copy_type
->set_is_builtin();
231 this->globals_
->add_function_declaration("copy", NULL
, copy_type
, loc
);
233 Function_type
* append_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
234 append_type
->set_is_varargs();
235 append_type
->set_is_builtin();
236 this->globals_
->add_function_declaration("append", NULL
, append_type
, loc
);
238 Function_type
* complex_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
239 complex_type
->set_is_varargs();
240 complex_type
->set_is_builtin();
241 this->globals_
->add_function_declaration("complex", NULL
, complex_type
, loc
);
243 Function_type
* real_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
244 real_type
->set_is_varargs();
245 real_type
->set_is_builtin();
246 this->globals_
->add_function_declaration("real", NULL
, real_type
, loc
);
248 Function_type
* imag_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
249 imag_type
->set_is_varargs();
250 imag_type
->set_is_builtin();
251 this->globals_
->add_function_declaration("imag", NULL
, imag_type
, loc
);
253 Function_type
* delete_type
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
254 delete_type
->set_is_varargs();
255 delete_type
->set_is_builtin();
256 this->globals_
->add_function_declaration("delete", NULL
, delete_type
, loc
);
259 // Convert a pkgpath into a string suitable for a symbol. Note that
260 // this transformation is convenient but imperfect. A -fgo-pkgpath
261 // option of a/b_c will conflict with a -fgo-pkgpath option of a_b/c,
262 // possibly leading to link time errors.
265 Gogo::pkgpath_for_symbol(const std::string
& pkgpath
)
267 std::string s
= pkgpath
;
268 for (size_t i
= 0; i
< s
.length(); ++i
)
271 if ((c
>= 'a' && c
<= 'z')
272 || (c
>= 'A' && c
<= 'Z')
273 || (c
>= '0' && c
<= '9'))
281 // Get the package path to use for type reflection data. This should
282 // ideally be unique across the entire link.
285 Gogo::pkgpath() const
287 go_assert(this->pkgpath_set_
);
288 return this->pkgpath_
;
291 // Set the package path from the -fgo-pkgpath command line option.
294 Gogo::set_pkgpath(const std::string
& arg
)
296 go_assert(!this->pkgpath_set_
);
297 this->pkgpath_
= arg
;
298 this->pkgpath_set_
= true;
299 this->pkgpath_from_option_
= true;
302 // Get the package path to use for symbol names.
305 Gogo::pkgpath_symbol() const
307 go_assert(this->pkgpath_set_
);
308 return this->pkgpath_symbol_
;
311 // Set the unique prefix to use to determine the package path, from
312 // the -fgo-prefix command line option.
315 Gogo::set_prefix(const std::string
& arg
)
317 go_assert(!this->prefix_from_option_
);
319 this->prefix_from_option_
= true;
322 // Munge name for use in an error message.
325 Gogo::message_name(const std::string
& name
)
327 return go_localize_identifier(Gogo::unpack_hidden_name(name
).c_str());
330 // Get the package name.
333 Gogo::package_name() const
335 go_assert(this->package_
!= NULL
);
336 return this->package_
->package_name();
339 // Set the package name.
342 Gogo::set_package_name(const std::string
& package_name
,
345 if (this->package_
!= NULL
)
347 if (this->package_
->package_name() != package_name
)
348 go_error_at(location
, "expected package %<%s%>",
349 Gogo::message_name(this->package_
->package_name()).c_str());
353 // Now that we know the name of the package we are compiling, set
354 // the package path to use for reflect.Type.PkgPath and global
356 if (this->pkgpath_set_
)
357 this->pkgpath_symbol_
= Gogo::pkgpath_for_symbol(this->pkgpath_
);
360 if (!this->prefix_from_option_
&& package_name
== "main")
362 this->pkgpath_
= package_name
;
363 this->pkgpath_symbol_
= Gogo::pkgpath_for_symbol(package_name
);
367 if (!this->prefix_from_option_
)
368 this->prefix_
= "go";
369 this->pkgpath_
= this->prefix_
+ '.' + package_name
;
370 this->pkgpath_symbol_
= (Gogo::pkgpath_for_symbol(this->prefix_
) + '.'
371 + Gogo::pkgpath_for_symbol(package_name
));
373 this->pkgpath_set_
= true;
376 this->package_
= this->register_package(this->pkgpath_
,
377 this->pkgpath_symbol_
, location
);
378 this->package_
->set_package_name(package_name
, location
);
380 if (this->is_main_package())
382 // Declare "main" as a function which takes no parameters and
384 Location uloc
= Linemap::unknown_location();
385 this->declare_function(Gogo::pack_hidden_name("main", false),
386 Type::make_function_type (NULL
, NULL
, NULL
, uloc
),
391 // Return whether this is the "main" package. This is not true if
392 // -fgo-pkgpath or -fgo-prefix was used.
395 Gogo::is_main_package() const
397 return (this->package_name() == "main"
398 && !this->pkgpath_from_option_
399 && !this->prefix_from_option_
);
405 Gogo::import_package(const std::string
& filename
,
406 const std::string
& local_name
,
407 bool is_local_name_exported
,
411 if (filename
.empty())
413 go_error_at(location
, "import path is empty");
417 const char *pf
= filename
.data();
418 const char *pend
= pf
+ filename
.length();
422 int adv
= Lex::fetch_char(pf
, &c
);
425 go_error_at(location
, "import path contains invalid UTF-8 sequence");
430 go_error_at(location
, "import path contains NUL");
433 if (c
< 0x20 || c
== 0x7f)
435 go_error_at(location
, "import path contains control character");
440 go_error_at(location
, "import path contains backslash; use slash");
443 if (Lex::is_unicode_space(c
))
445 go_error_at(location
, "import path contains space character");
448 if (c
< 0x7f && strchr("!\"#$%&'()*,:;<=>?[]^`{|}", c
) != NULL
)
450 go_error_at(location
,
451 "import path contains invalid character '%c'", c
);
457 if (IS_ABSOLUTE_PATH(filename
.c_str()))
459 go_error_at(location
, "import path cannot be absolute path");
463 if (local_name
== "init")
464 go_error_at(location
, "cannot import package as init");
466 if (filename
== "unsafe")
468 this->import_unsafe(local_name
, is_local_name_exported
, location
);
469 this->current_file_imported_unsafe_
= true;
473 Imports::const_iterator p
= this->imports_
.find(filename
);
474 if (p
!= this->imports_
.end())
476 Package
* package
= p
->second
;
477 package
->set_location(location
);
478 std::string ln
= local_name
;
479 bool is_ln_exported
= is_local_name_exported
;
482 ln
= package
->package_name();
483 go_assert(!ln
.empty());
484 is_ln_exported
= Lex::is_exported_name(ln
);
490 Bindings
* bindings
= package
->bindings();
491 for (Bindings::const_declarations_iterator p
=
492 bindings
->begin_declarations();
493 p
!= bindings
->end_declarations();
495 this->add_dot_import_object(p
->second
);
496 std::string dot_alias
= "." + package
->package_name();
497 package
->add_alias(dot_alias
, location
);
501 package
->add_alias(ln
, location
);
502 ln
= this->pack_hidden_name(ln
, is_ln_exported
);
503 this->package_
->bindings()->add_package(ln
, package
);
508 Import::Stream
* stream
= Import::open_package(filename
, location
,
509 this->relative_import_path_
);
513 go_error_at(location
, "import file %qs not found", filename
.c_str());
517 Import
imp(stream
, location
);
518 imp
.register_builtin_types(this);
519 Package
* package
= imp
.import(this, local_name
, is_local_name_exported
);
522 if (package
->pkgpath() == this->pkgpath())
523 go_error_at(location
,
524 ("imported package uses same package path as package "
525 "being compiled (see -fgo-pkgpath option)"));
527 this->imports_
.insert(std::make_pair(filename
, package
));
534 Gogo::lookup_init(const std::string
& init_name
)
536 Import_init
tmp("", init_name
, -1);
537 Import_init_set::iterator it
= this->imported_init_fns_
.find(&tmp
);
538 return (it
!= this->imported_init_fns_
.end()) ? *it
: NULL
;
541 // Add an import control function for an imported package to the list.
544 Gogo::add_import_init_fn(const std::string
& package_name
,
545 const std::string
& init_name
, int prio
)
547 for (Import_init_set::iterator p
=
548 this->imported_init_fns_
.begin();
549 p
!= this->imported_init_fns_
.end();
552 Import_init
*ii
= (*p
);
553 if (ii
->init_name() == init_name
)
555 // If a test of package P1, built as part of package P1,
556 // imports package P2, and P2 imports P1 (perhaps
557 // indirectly), then we will see the same import name with
558 // different import priorities. That is OK, so don't give
559 // an error about it.
560 if (ii
->package_name() != package_name
)
562 go_error_at(Linemap::unknown_location(),
563 "duplicate package initialization name %qs",
564 Gogo::message_name(init_name
).c_str());
565 go_inform(Linemap::unknown_location(), "used by package %qs",
566 Gogo::message_name(ii
->package_name()).c_str());
567 go_inform(Linemap::unknown_location(), " and by package %qs",
568 Gogo::message_name(package_name
).c_str());
570 ii
->set_priority(prio
);
575 Import_init
* nii
= new Import_init(package_name
, init_name
, prio
);
576 this->imported_init_fns_
.insert(nii
);
579 // Return whether we are at the global binding level.
582 Gogo::in_global_scope() const
584 return this->functions_
.empty();
587 // Return the current binding contour.
590 Gogo::current_bindings()
592 if (!this->functions_
.empty())
593 return this->functions_
.back().blocks
.back()->bindings();
594 else if (this->package_
!= NULL
)
595 return this->package_
->bindings();
597 return this->globals_
;
601 Gogo::current_bindings() const
603 if (!this->functions_
.empty())
604 return this->functions_
.back().blocks
.back()->bindings();
605 else if (this->package_
!= NULL
)
606 return this->package_
->bindings();
608 return this->globals_
;
612 Gogo::update_init_priority(Import_init
* ii
,
613 std::set
<const Import_init
*>* visited
)
618 for (std::set
<std::string
>::const_iterator pci
=
619 ii
->precursors().begin();
620 pci
!= ii
->precursors().end();
623 Import_init
* succ
= this->lookup_init(*pci
);
624 if (visited
->find(succ
) == visited
->end())
625 update_init_priority(succ
, visited
);
626 succ_prior
= std::max(succ_prior
, succ
->priority());
628 if (ii
->priority() <= succ_prior
)
629 ii
->set_priority(succ_prior
+ 1);
633 Gogo::recompute_init_priorities()
635 std::set
<Import_init
*> nonroots
;
637 for (Import_init_set::const_iterator p
=
638 this->imported_init_fns_
.begin();
639 p
!= this->imported_init_fns_
.end();
642 const Import_init
*ii
= *p
;
643 for (std::set
<std::string
>::const_iterator pci
=
644 ii
->precursors().begin();
645 pci
!= ii
->precursors().end();
648 Import_init
* ii
= this->lookup_init(*pci
);
653 // Recursively update priorities starting at roots.
654 std::set
<const Import_init
*> visited
;
655 for (Import_init_set::iterator p
=
656 this->imported_init_fns_
.begin();
657 p
!= this->imported_init_fns_
.end();
660 Import_init
* ii
= *p
;
661 if (nonroots
.find(ii
) != nonroots
.end())
663 update_init_priority(ii
, &visited
);
667 // Add statements to INIT_STMTS which run the initialization
668 // functions for imported packages. This is only used for the "main"
672 Gogo::init_imports(std::vector
<Bstatement
*>& init_stmts
, Bfunction
*bfunction
)
674 go_assert(this->is_main_package());
676 if (this->imported_init_fns_
.empty())
679 Location unknown_loc
= Linemap::unknown_location();
680 Function_type
* func_type
=
681 Type::make_function_type(NULL
, NULL
, NULL
, unknown_loc
);
682 Btype
* fntype
= func_type
->get_backend_fntype(this);
684 // Recompute init priorities based on a walk of the init graph.
685 recompute_init_priorities();
687 // We must call them in increasing priority order.
688 std::vector
<const Import_init
*> v
;
689 for (Import_init_set::const_iterator p
=
690 this->imported_init_fns_
.begin();
691 p
!= this->imported_init_fns_
.end();
694 if ((*p
)->priority() < 0)
695 go_error_at(Linemap::unknown_location(),
696 "internal error: failed to set init priority for %s",
697 (*p
)->package_name().c_str());
700 std::sort(v
.begin(), v
.end(), priority_compare
);
702 // We build calls to the init functions, which take no arguments.
703 std::vector
<Bexpression
*> empty_args
;
704 for (std::vector
<const Import_init
*>::const_iterator p
= v
.begin();
708 const Import_init
* ii
= *p
;
709 std::string user_name
= ii
->package_name() + ".init";
710 const std::string
& init_name(ii
->init_name());
712 Bfunction
* pfunc
= this->backend()->function(fntype
, user_name
, init_name
,
713 true, true, true, false,
714 false, false, unknown_loc
);
715 Bexpression
* pfunc_code
=
716 this->backend()->function_code_expression(pfunc
, unknown_loc
);
717 Bexpression
* pfunc_call
=
718 this->backend()->call_expression(bfunction
, pfunc_code
, empty_args
,
720 init_stmts
.push_back(this->backend()->expression_statement(bfunction
,
725 // Register global variables with the garbage collector. We need to
726 // register all variables which can hold a pointer value. They become
727 // roots during the mark phase. We build a struct that is easy to
728 // hook into a list of roots.
730 // type gcRoot struct {
731 // decl unsafe.Pointer // Pointer to variable.
732 // size uintptr // Total size of variable.
733 // ptrdata uintptr // Length of variable's gcdata.
734 // gcdata *byte // Pointer mask.
737 // type gcRootList struct {
743 // The last entry in the roots array has a NULL decl field.
746 Gogo::register_gc_vars(const std::vector
<Named_object
*>& var_gc
,
747 std::vector
<Bstatement
*>& init_stmts
,
750 if (var_gc
.empty() && this->gc_roots_
.empty())
753 Type
* pvt
= Type::make_pointer_type(Type::make_void_type());
754 Type
* uintptr_type
= Type::lookup_integer_type("uintptr");
755 Type
* byte_type
= this->lookup_global("byte")->type_value();
756 Type
* pointer_byte_type
= Type::make_pointer_type(byte_type
);
757 Struct_type
* root_type
=
758 Type::make_builtin_struct_type(4,
760 "size", uintptr_type
,
761 "ptrdata", uintptr_type
,
762 "gcdata", pointer_byte_type
);
764 Location builtin_loc
= Linemap::predeclared_location();
765 unsigned long roots_len
= var_gc
.size() + this->gc_roots_
.size();
766 Expression
* length
= Expression::make_integer_ul(roots_len
, NULL
,
768 Array_type
* root_array_type
= Type::make_array_type(root_type
, length
);
769 root_array_type
->set_is_array_incomparable();
771 Type
* int_type
= Type::lookup_integer_type("int");
772 Struct_type
* root_list_type
=
773 Type::make_builtin_struct_type(3,
776 "roots", root_array_type
);
778 // Build an initializer for the roots array.
780 Expression_list
* roots_init
= new Expression_list();
782 for (std::vector
<Named_object
*>::const_iterator p
= var_gc
.begin();
786 Expression_list
* init
= new Expression_list();
788 Location no_loc
= (*p
)->location();
789 Expression
* decl
= Expression::make_var_reference(*p
, no_loc
);
790 Expression
* decl_addr
=
791 Expression::make_unary(OPERATOR_AND
, decl
, no_loc
);
792 decl_addr
->unary_expression()->set_does_not_escape();
793 decl_addr
= Expression::make_cast(pvt
, decl_addr
, no_loc
);
794 init
->push_back(decl_addr
);
797 Expression::make_type_info(decl
->type(),
798 Expression::TYPE_INFO_SIZE
);
799 init
->push_back(size
);
801 Expression
* ptrdata
=
802 Expression::make_type_info(decl
->type(),
803 Expression::TYPE_INFO_BACKEND_PTRDATA
);
804 init
->push_back(ptrdata
);
806 Expression
* gcdata
= Expression::make_ptrmask_symbol(decl
->type());
807 init
->push_back(gcdata
);
809 Expression
* root_ctor
=
810 Expression::make_struct_composite_literal(root_type
, init
, no_loc
);
811 roots_init
->push_back(root_ctor
);
814 for (std::vector
<Expression
*>::const_iterator p
= this->gc_roots_
.begin();
815 p
!= this->gc_roots_
.end();
818 Expression_list
*init
= new Expression_list();
820 Expression
* expr
= *p
;
821 Location eloc
= expr
->location();
822 init
->push_back(Expression::make_cast(pvt
, expr
, eloc
));
824 Type
* type
= expr
->type()->points_to();
825 go_assert(type
!= NULL
);
828 Expression::make_type_info(type
,
829 Expression::TYPE_INFO_SIZE
);
830 init
->push_back(size
);
832 Expression
* ptrdata
=
833 Expression::make_type_info(type
,
834 Expression::TYPE_INFO_BACKEND_PTRDATA
);
835 init
->push_back(ptrdata
);
837 Expression
* gcdata
= Expression::make_ptrmask_symbol(type
);
838 init
->push_back(gcdata
);
840 Expression
* root_ctor
=
841 Expression::make_struct_composite_literal(root_type
, init
, eloc
);
842 roots_init
->push_back(root_ctor
);
845 // Build a constructor for the struct.
847 Expression_list
* root_list_init
= new Expression_list();
848 root_list_init
->push_back(Expression::make_nil(builtin_loc
));
849 root_list_init
->push_back(Expression::make_integer_ul(roots_len
, int_type
,
852 Expression
* roots_ctor
=
853 Expression::make_array_composite_literal(root_array_type
, roots_init
,
855 root_list_init
->push_back(roots_ctor
);
857 Expression
* root_list_ctor
=
858 Expression::make_struct_composite_literal(root_list_type
, root_list_init
,
861 Expression
* root_addr
= Expression::make_unary(OPERATOR_AND
, root_list_ctor
,
863 root_addr
->unary_expression()->set_is_gc_root();
864 Expression
* register_roots
= Runtime::make_call(Runtime::REGISTER_GC_ROOTS
,
865 builtin_loc
, 1, root_addr
);
867 Translate_context
context(this, NULL
, NULL
, NULL
);
868 Bexpression
* bcall
= register_roots
->get_backend(&context
);
869 init_stmts
.push_back(this->backend()->expression_statement(init_bfn
, bcall
));
872 // Build the decl for the initialization function.
875 Gogo::initialization_function_decl()
877 std::string name
= this->get_init_fn_name();
878 Location loc
= this->package_
->location();
880 Function_type
* fntype
= Type::make_function_type(NULL
, NULL
, NULL
, loc
);
881 Function
* initfn
= new Function(fntype
, NULL
, NULL
, loc
);
882 return Named_object::make_function(name
, NULL
, initfn
);
885 // Create the magic initialization function. CODE_STMT is the
886 // code that it needs to run.
889 Gogo::create_initialization_function(Named_object
* initfn
,
890 Bstatement
* code_stmt
)
892 // Make sure that we thought we needed an initialization function,
893 // as otherwise we will not have reported it in the export data.
894 go_assert(this->is_main_package() || this->need_init_fn_
);
897 initfn
= this->initialization_function_decl();
899 // Bind the initialization function code to a block.
900 Bfunction
* fndecl
= initfn
->func_value()->get_or_make_decl(this, initfn
);
901 Location pkg_loc
= this->package_
->location();
902 std::vector
<Bvariable
*> vars
;
903 this->backend()->block(fndecl
, NULL
, vars
, pkg_loc
, pkg_loc
);
905 if (!this->backend()->function_set_body(fndecl
, code_stmt
))
907 go_assert(saw_errors());
913 // Search for references to VAR in any statements or called functions.
915 class Find_var
: public Traverse
918 // A hash table we use to avoid looping. The index is the name of a
919 // named object. We only look through objects defined in this
921 typedef Unordered_set(const void*) Seen_objects
;
923 Find_var(Named_object
* var
, Seen_objects
* seen_objects
)
924 : Traverse(traverse_expressions
),
925 var_(var
), seen_objects_(seen_objects
), found_(false)
928 // Whether the variable was found.
931 { return this->found_
; }
934 expression(Expression
**);
937 // The variable we are looking for.
939 // Names of objects we have already seen.
940 Seen_objects
* seen_objects_
;
941 // True if the variable was found.
945 // See if EXPR refers to VAR, looking through function calls and
946 // variable initializations.
949 Find_var::expression(Expression
** pexpr
)
951 Expression
* e
= *pexpr
;
953 Var_expression
* ve
= e
->var_expression();
956 Named_object
* v
= ve
->named_object();
960 return TRAVERSE_EXIT
;
963 if (v
->is_variable() && v
->package() == NULL
)
965 Expression
* init
= v
->var_value()->init();
968 std::pair
<Seen_objects::iterator
, bool> ins
=
969 this->seen_objects_
->insert(v
);
972 // This is the first time we have seen this name.
973 if (Expression::traverse(&init
, this) == TRAVERSE_EXIT
)
974 return TRAVERSE_EXIT
;
980 // We traverse the code of any function or bound method we see. Note that
981 // this means that we will traverse the code of a function or bound method
982 // whose address is taken even if it is not called.
983 Func_expression
* fe
= e
->func_expression();
984 Bound_method_expression
* bme
= e
->bound_method_expression();
985 if (fe
!= NULL
|| bme
!= NULL
)
987 const Named_object
* f
= fe
!= NULL
? fe
->named_object() : bme
->function();
988 if (f
->is_function() && f
->package() == NULL
)
990 std::pair
<Seen_objects::iterator
, bool> ins
=
991 this->seen_objects_
->insert(f
);
994 // This is the first time we have seen this name.
995 if (f
->func_value()->block()->traverse(this) == TRAVERSE_EXIT
)
996 return TRAVERSE_EXIT
;
1001 Temporary_reference_expression
* tre
= e
->temporary_reference_expression();
1004 Temporary_statement
* ts
= tre
->statement();
1005 Expression
* init
= ts
->init();
1008 std::pair
<Seen_objects::iterator
, bool> ins
=
1009 this->seen_objects_
->insert(ts
);
1012 // This is the first time we have seen this temporary
1014 if (Expression::traverse(&init
, this) == TRAVERSE_EXIT
)
1015 return TRAVERSE_EXIT
;
1020 return TRAVERSE_CONTINUE
;
1023 // Return true if EXPR, PREINIT, or DEP refers to VAR.
1026 expression_requires(Expression
* expr
, Block
* preinit
, Named_object
* dep
,
1029 Find_var::Seen_objects seen_objects
;
1030 Find_var
find_var(var
, &seen_objects
);
1032 Expression::traverse(&expr
, &find_var
);
1033 if (preinit
!= NULL
)
1034 preinit
->traverse(&find_var
);
1037 Expression
* init
= dep
->var_value()->init();
1039 Expression::traverse(&init
, &find_var
);
1040 if (dep
->var_value()->has_pre_init())
1041 dep
->var_value()->preinit()->traverse(&find_var
);
1044 return find_var
.found();
1047 // Sort variable initializations. If the initialization expression
1048 // for variable A refers directly or indirectly to the initialization
1049 // expression for variable B, then we must initialize B before A.
1055 : var_(NULL
), init_(NULL
), dep_count_(0)
1058 Var_init(Named_object
* var
, Bstatement
* init
)
1059 : var_(var
), init_(init
), dep_count_(0)
1062 // Return the variable.
1065 { return this->var_
; }
1067 // Return the initialization expression.
1070 { return this->init_
; }
1072 // Return the number of remaining dependencies.
1075 { return this->dep_count_
; }
1077 // Increment the number of dependencies.
1080 { ++this->dep_count_
; }
1082 // Decrement the number of dependencies.
1085 { --this->dep_count_
; }
1088 // The variable being initialized.
1090 // The initialization statement.
1092 // The number of initializations this is dependent on. A variable
1093 // initialization should not be emitted if any of its dependencies
1094 // have not yet been resolved.
1098 // For comparing Var_init keys in a map.
1101 operator<(const Var_init
& v1
, const Var_init
& v2
)
1102 { return v1
.var()->name() < v2
.var()->name(); }
1104 typedef std::list
<Var_init
> Var_inits
;
1106 // Sort the variable initializations. The rule we follow is that we
1107 // emit them in the order they appear in the array, except that if the
1108 // initialization expression for a variable V1 depends upon another
1109 // variable V2 then we initialize V1 after V2.
1112 sort_var_inits(Gogo
* gogo
, Var_inits
* var_inits
)
1114 if (var_inits
->empty())
1117 typedef std::pair
<Named_object
*, Named_object
*> No_no
;
1118 typedef std::map
<No_no
, bool> Cache
;
1121 // A mapping from a variable initialization to a set of
1122 // variable initializations that depend on it.
1123 typedef std::map
<Var_init
, std::set
<Var_init
*> > Init_deps
;
1124 Init_deps init_deps
;
1125 bool init_loop
= false;
1126 for (Var_inits::iterator p1
= var_inits
->begin();
1127 p1
!= var_inits
->end();
1130 Named_object
* var
= p1
->var();
1131 Expression
* init
= var
->var_value()->init();
1132 Block
* preinit
= var
->var_value()->preinit();
1133 Named_object
* dep
= gogo
->var_depends_on(var
->var_value());
1135 // Start walking through the list to see which variables VAR
1136 // needs to wait for.
1137 for (Var_inits::iterator p2
= var_inits
->begin();
1138 p2
!= var_inits
->end();
1141 if (var
== p2
->var())
1144 Named_object
* p2var
= p2
->var();
1145 No_no
key(var
, p2var
);
1146 std::pair
<Cache::iterator
, bool> ins
=
1147 cache
.insert(std::make_pair(key
, false));
1149 ins
.first
->second
= expression_requires(init
, preinit
, dep
, p2var
);
1150 if (ins
.first
->second
)
1152 // VAR depends on P2VAR.
1153 init_deps
[*p2
].insert(&(*p1
));
1154 p1
->add_dependency();
1156 // Check for cycles.
1157 key
= std::make_pair(p2var
, var
);
1158 ins
= cache
.insert(std::make_pair(key
, false));
1161 expression_requires(p2var
->var_value()->init(),
1162 p2var
->var_value()->preinit(),
1163 gogo
->var_depends_on(p2var
->var_value()),
1165 if (ins
.first
->second
)
1167 go_error_at(var
->location(),
1168 ("initialization expressions for %qs and "
1169 "%qs depend upon each other"),
1170 var
->message_name().c_str(),
1171 p2var
->message_name().c_str());
1172 go_inform(p2
->var()->location(), "%qs defined here",
1173 p2var
->message_name().c_str());
1181 // If there are no dependencies then the declaration order is sorted.
1182 if (!init_deps
.empty() && !init_loop
)
1184 // Otherwise, sort variable initializations by emitting all variables with
1185 // no dependencies in declaration order. VAR_INITS is already in
1186 // declaration order.
1188 while (!var_inits
->empty())
1190 Var_inits::iterator v1
;;
1191 for (v1
= var_inits
->begin(); v1
!= var_inits
->end(); ++v1
)
1193 if (v1
->dep_count() == 0)
1196 go_assert(v1
!= var_inits
->end());
1198 // V1 either has no dependencies or its dependencies have already
1199 // been emitted, add it to READY next. When V1 is emitted, remove
1200 // a dependency from each V that depends on V1.
1201 ready
.splice(ready
.end(), *var_inits
, v1
);
1203 Init_deps::iterator p1
= init_deps
.find(*v1
);
1204 if (p1
!= init_deps
.end())
1206 std::set
<Var_init
*> resolved
= p1
->second
;
1207 for (std::set
<Var_init
*>::iterator pv
= resolved
.begin();
1208 pv
!= resolved
.end();
1210 (*pv
)->remove_dependency();
1211 init_deps
.erase(p1
);
1214 var_inits
->swap(ready
);
1215 go_assert(init_deps
.empty());
1218 // VAR_INITS is in the correct order. For each VAR in VAR_INITS,
1219 // check for a loop of VAR on itself.
1220 // interpret as a loop.
1221 for (Var_inits::const_iterator p
= var_inits
->begin();
1222 p
!= var_inits
->end();
1224 gogo
->check_self_dep(p
->var());
1227 // Give an error if the initialization expression for VAR depends on
1228 // itself. We only check if INIT is not NULL and there is no
1229 // dependency; when INIT is NULL, it means that PREINIT sets VAR,
1230 // which we will interpret as a loop.
1233 Gogo::check_self_dep(Named_object
* var
)
1235 Expression
* init
= var
->var_value()->init();
1236 Block
* preinit
= var
->var_value()->preinit();
1237 Named_object
* dep
= this->var_depends_on(var
->var_value());
1240 && expression_requires(init
, preinit
, NULL
, var
))
1241 go_error_at(var
->location(),
1242 "initialization expression for %qs depends upon itself",
1243 var
->message_name().c_str());
1246 // Write out the global definitions.
1249 Gogo::write_globals()
1251 this->build_interface_method_tables();
1253 Bindings
* bindings
= this->current_bindings();
1255 for (Bindings::const_declarations_iterator p
= bindings
->begin_declarations();
1256 p
!= bindings
->end_declarations();
1259 // If any function declarations needed a descriptor, make sure
1261 Named_object
* no
= p
->second
;
1262 if (no
->is_function_declaration())
1263 no
->func_declaration_value()->build_backend_descriptor(this);
1266 // Lists of globally declared types, variables, constants, and functions
1267 // that must be defined.
1268 std::vector
<Btype
*> type_decls
;
1269 std::vector
<Bvariable
*> var_decls
;
1270 std::vector
<Bexpression
*> const_decls
;
1271 std::vector
<Bfunction
*> func_decls
;
1273 // The init function declaration and associated Bfunction, if necessary.
1274 Named_object
* init_fndecl
= NULL
;
1275 Bfunction
* init_bfn
= NULL
;
1277 std::vector
<Bstatement
*> init_stmts
;
1278 std::vector
<Bstatement
*> var_init_stmts
;
1280 if (this->is_main_package())
1282 init_fndecl
= this->initialization_function_decl();
1283 init_bfn
= init_fndecl
->func_value()->get_or_make_decl(this, init_fndecl
);
1284 this->init_imports(init_stmts
, init_bfn
);
1287 // A list of variable initializations.
1288 Var_inits var_inits
;
1290 // A list of variables which need to be registered with the garbage
1292 size_t count_definitions
= bindings
->size_definitions();
1293 std::vector
<Named_object
*> var_gc
;
1294 var_gc
.reserve(count_definitions
);
1296 for (Bindings::const_definitions_iterator p
= bindings
->begin_definitions();
1297 p
!= bindings
->end_definitions();
1300 Named_object
* no
= *p
;
1301 go_assert(!no
->is_type_declaration() && !no
->is_function_declaration());
1303 // There is nothing to do for a package.
1304 if (no
->is_package())
1307 // There is nothing to do for an object which was imported from
1308 // a different package into the global scope.
1309 if (no
->package() != NULL
)
1312 // Skip blank named functions and constants.
1313 if ((no
->is_function() && no
->func_value()->is_sink())
1314 || (no
->is_const() && no
->const_value()->is_sink()))
1317 // There is nothing useful we can output for constants which
1318 // have ideal or non-integral type.
1321 Type
* type
= no
->const_value()->type();
1323 type
= no
->const_value()->expr()->type();
1324 if (type
->is_abstract() || !type
->is_numeric_type())
1328 if (!no
->is_variable())
1329 no
->get_backend(this, const_decls
, type_decls
, func_decls
);
1332 Variable
* var
= no
->var_value();
1333 Bvariable
* bvar
= no
->get_backend_variable(this, NULL
);
1334 var_decls
.push_back(bvar
);
1336 // Check for a sink variable, which may be used to run an
1337 // initializer purely for its side effects.
1338 bool is_sink
= no
->name()[0] == '_' && no
->name()[1] == '.';
1340 Bstatement
* var_init_stmt
= NULL
;
1341 if (!var
->has_pre_init())
1343 // If the backend representation of the variable initializer is
1344 // constant, we can just set the initial value using
1345 // global_var_set_init instead of during the init() function.
1346 // The initializer is constant if it is the zero-value of the
1347 // variable's type or if the initial value is an immutable value
1348 // that is not copied to the heap.
1349 bool is_static_initializer
= false;
1350 if (var
->init() == NULL
)
1351 is_static_initializer
= true;
1354 Type
* var_type
= var
->type();
1355 Expression
* init
= var
->init();
1356 Expression
* init_cast
=
1357 Expression::make_cast(var_type
, init
, var
->location());
1358 is_static_initializer
= init_cast
->is_static_initializer();
1361 // Non-constant variable initializations might need to create
1362 // temporary variables, which will need the initialization
1363 // function as context.
1364 Named_object
* var_init_fn
;
1365 if (is_static_initializer
)
1369 if (init_fndecl
== NULL
)
1371 init_fndecl
= this->initialization_function_decl();
1372 Function
* func
= init_fndecl
->func_value();
1373 init_bfn
= func
->get_or_make_decl(this, init_fndecl
);
1375 var_init_fn
= init_fndecl
;
1377 Bexpression
* var_binit
= var
->get_init(this, var_init_fn
);
1379 if (var_binit
== NULL
)
1381 else if (is_static_initializer
)
1383 if (expression_requires(var
->init(), NULL
,
1384 this->var_depends_on(var
), no
))
1385 go_error_at(no
->location(),
1386 "initialization expression for %qs depends "
1388 no
->message_name().c_str());
1389 this->backend()->global_variable_set_init(bvar
, var_binit
);
1393 this->backend()->expression_statement(init_bfn
, var_binit
);
1396 Location loc
= var
->location();
1397 Bexpression
* var_expr
=
1398 this->backend()->var_expression(bvar
, loc
);
1400 this->backend()->assignment_statement(init_bfn
, var_expr
,
1406 // We are going to create temporary variables which
1407 // means that we need an fndecl.
1408 if (init_fndecl
== NULL
)
1409 init_fndecl
= this->initialization_function_decl();
1411 Bvariable
* var_decl
= is_sink
? NULL
: bvar
;
1412 var_init_stmt
= var
->get_init_block(this, init_fndecl
, var_decl
);
1415 if (var_init_stmt
!= NULL
)
1417 if (var
->init() == NULL
&& !var
->has_pre_init())
1418 var_init_stmts
.push_back(var_init_stmt
);
1420 var_inits
.push_back(Var_init(no
, var_init_stmt
));
1422 else if (this->var_depends_on(var
) != NULL
)
1424 // This variable is initialized from something that is
1425 // not in its init or preinit. This variable needs to
1426 // participate in dependency analysis sorting, in case
1427 // some other variable depends on this one.
1428 Btype
* btype
= no
->var_value()->type()->get_backend(this);
1429 Bexpression
* zero
= this->backend()->zero_expression(btype
);
1430 Bstatement
* zero_stmt
=
1431 this->backend()->expression_statement(init_bfn
, zero
);
1432 var_inits
.push_back(Var_init(no
, zero_stmt
));
1435 // Collect a list of all global variables with pointers,
1436 // to register them for the garbage collector.
1437 if (!is_sink
&& var
->type()->has_pointer())
1439 // Avoid putting runtime.gcRoots itself on the list.
1440 if (this->compiling_runtime()
1441 && this->package_name() == "runtime"
1442 && Gogo::unpack_hidden_name(no
->name()) == "gcRoots")
1445 var_gc
.push_back(no
);
1450 // Register global variables with the garbage collector.
1451 this->register_gc_vars(var_gc
, init_stmts
, init_bfn
);
1453 // Simple variable initializations, after all variables are
1455 init_stmts
.push_back(this->backend()->statement_list(var_init_stmts
));
1457 // Complete variable initializations, first sorting them into a
1459 if (!var_inits
.empty())
1461 sort_var_inits(this, &var_inits
);
1462 for (Var_inits::const_iterator p
= var_inits
.begin();
1463 p
!= var_inits
.end();
1465 init_stmts
.push_back(p
->init());
1468 // After all the variables are initialized, call the init
1469 // functions if there are any. Init functions take no arguments, so
1470 // we pass in EMPTY_ARGS to call them.
1471 std::vector
<Bexpression
*> empty_args
;
1472 for (std::vector
<Named_object
*>::const_iterator p
=
1473 this->init_functions_
.begin();
1474 p
!= this->init_functions_
.end();
1477 Location func_loc
= (*p
)->location();
1478 Function
* func
= (*p
)->func_value();
1479 Bfunction
* initfn
= func
->get_or_make_decl(this, *p
);
1480 Bexpression
* func_code
=
1481 this->backend()->function_code_expression(initfn
, func_loc
);
1482 Bexpression
* call
= this->backend()->call_expression(init_bfn
, func_code
,
1485 Bstatement
* ist
= this->backend()->expression_statement(init_bfn
, call
);
1486 init_stmts
.push_back(ist
);
1489 // Set up a magic function to do all the initialization actions.
1490 // This will be called if this package is imported.
1491 Bstatement
* init_fncode
= this->backend()->statement_list(init_stmts
);
1492 if (this->need_init_fn_
|| this->is_main_package())
1495 this->create_initialization_function(init_fndecl
, init_fncode
);
1496 if (init_fndecl
!= NULL
)
1497 func_decls
.push_back(init_fndecl
->func_value()->get_decl());
1500 // We should not have seen any new bindings created during the conversion.
1501 go_assert(count_definitions
== this->current_bindings()->size_definitions());
1503 // Define all globally declared values.
1505 this->backend()->write_global_definitions(type_decls
, const_decls
,
1506 func_decls
, var_decls
);
1509 // Return the current block.
1512 Gogo::current_block()
1514 if (this->functions_
.empty())
1517 return this->functions_
.back().blocks
.back();
1520 // Look up a name in the current binding contour. If PFUNCTION is not
1521 // NULL, set it to the function in which the name is defined, or NULL
1522 // if the name is defined in global scope.
1525 Gogo::lookup(const std::string
& name
, Named_object
** pfunction
) const
1527 if (pfunction
!= NULL
)
1530 if (Gogo::is_sink_name(name
))
1531 return Named_object::make_sink();
1533 for (Open_functions::const_reverse_iterator p
= this->functions_
.rbegin();
1534 p
!= this->functions_
.rend();
1537 Named_object
* ret
= p
->blocks
.back()->bindings()->lookup(name
);
1540 if (pfunction
!= NULL
)
1541 *pfunction
= p
->function
;
1546 if (this->package_
!= NULL
)
1548 Named_object
* ret
= this->package_
->bindings()->lookup(name
);
1551 if (ret
->package() != NULL
)
1553 std::string dot_alias
= "." + ret
->package()->package_name();
1554 ret
->package()->note_usage(dot_alias
);
1560 // We do not look in the global namespace. If we did, the global
1561 // namespace would effectively hide names which were defined in
1562 // package scope which we have not yet seen. Instead,
1563 // define_global_names is called after parsing is over to connect
1564 // undefined names at package scope with names defined at global
1570 // Look up a name in the current block, without searching enclosing
1574 Gogo::lookup_in_block(const std::string
& name
) const
1576 go_assert(!this->functions_
.empty());
1577 go_assert(!this->functions_
.back().blocks
.empty());
1578 return this->functions_
.back().blocks
.back()->bindings()->lookup_local(name
);
1581 // Look up a name in the global namespace.
1584 Gogo::lookup_global(const char* name
) const
1586 return this->globals_
->lookup(name
);
1589 // Add an imported package.
1592 Gogo::add_imported_package(const std::string
& real_name
,
1593 const std::string
& alias_arg
,
1594 bool is_alias_exported
,
1595 const std::string
& pkgpath
,
1596 const std::string
& pkgpath_symbol
,
1598 bool* padd_to_globals
)
1600 Package
* ret
= this->register_package(pkgpath
, pkgpath_symbol
, location
);
1601 ret
->set_package_name(real_name
, location
);
1603 *padd_to_globals
= false;
1605 if (alias_arg
== "_")
1607 else if (alias_arg
== ".")
1609 *padd_to_globals
= true;
1610 std::string dot_alias
= "." + real_name
;
1611 ret
->add_alias(dot_alias
, location
);
1615 std::string alias
= alias_arg
;
1619 is_alias_exported
= Lex::is_exported_name(alias
);
1621 ret
->add_alias(alias
, location
);
1622 alias
= this->pack_hidden_name(alias
, is_alias_exported
);
1623 Named_object
* no
= this->package_
->bindings()->add_package(alias
, ret
);
1624 if (!no
->is_package())
1631 // Register a package. This package may or may not be imported. This
1632 // returns the Package structure for the package, creating if it
1633 // necessary. LOCATION is the location of the import statement that
1634 // led us to see this package. PKGPATH_SYMBOL is the symbol to use
1635 // for names in the package; it may be the empty string, in which case
1636 // we either get it later or make a guess when we need it.
1639 Gogo::register_package(const std::string
& pkgpath
,
1640 const std::string
& pkgpath_symbol
, Location location
)
1642 Package
* package
= NULL
;
1643 std::pair
<Packages::iterator
, bool> ins
=
1644 this->packages_
.insert(std::make_pair(pkgpath
, package
));
1647 // We have seen this package name before.
1648 package
= ins
.first
->second
;
1649 go_assert(package
!= NULL
&& package
->pkgpath() == pkgpath
);
1650 if (!pkgpath_symbol
.empty())
1651 package
->set_pkgpath_symbol(pkgpath_symbol
);
1652 if (Linemap::is_unknown_location(package
->location()))
1653 package
->set_location(location
);
1657 // First time we have seen this package name.
1658 package
= new Package(pkgpath
, pkgpath_symbol
, location
);
1659 go_assert(ins
.first
->second
== NULL
);
1660 ins
.first
->second
= package
;
1666 // Return the pkgpath symbol for a package, given the pkgpath.
1669 Gogo::pkgpath_symbol_for_package(const std::string
& pkgpath
)
1671 Packages::iterator p
= this->packages_
.find(pkgpath
);
1672 go_assert(p
!= this->packages_
.end());
1673 return p
->second
->pkgpath_symbol();
1676 // Start compiling a function.
1679 Gogo::start_function(const std::string
& name
, Function_type
* type
,
1680 bool add_method_to_type
, Location location
)
1682 bool at_top_level
= this->functions_
.empty();
1684 Block
* block
= new Block(NULL
, location
);
1686 Named_object
* enclosing
= (at_top_level
1688 : this->functions_
.back().function
);
1690 Function
* function
= new Function(type
, enclosing
, block
, location
);
1692 if (type
->is_method())
1694 const Typed_identifier
* receiver
= type
->receiver();
1695 Variable
* this_param
= new Variable(receiver
->type(), NULL
, false,
1696 true, true, location
);
1697 std::string rname
= receiver
->name();
1698 if (rname
.empty() || Gogo::is_sink_name(rname
))
1700 // We need to give receivers a name since they wind up in
1701 // DECL_ARGUMENTS. FIXME.
1702 static unsigned int count
;
1704 snprintf(buf
, sizeof buf
, "r.%u", count
);
1708 block
->bindings()->add_variable(rname
, NULL
, this_param
);
1711 const Typed_identifier_list
* parameters
= type
->parameters();
1712 bool is_varargs
= type
->is_varargs();
1713 if (parameters
!= NULL
)
1715 for (Typed_identifier_list::const_iterator p
= parameters
->begin();
1716 p
!= parameters
->end();
1719 Variable
* param
= new Variable(p
->type(), NULL
, false, true, false,
1721 if (is_varargs
&& p
+ 1 == parameters
->end())
1722 param
->set_is_varargs_parameter();
1724 std::string pname
= p
->name();
1725 if (pname
.empty() || Gogo::is_sink_name(pname
))
1727 // We need to give parameters a name since they wind up
1728 // in DECL_ARGUMENTS. FIXME.
1729 static unsigned int count
;
1731 snprintf(buf
, sizeof buf
, "p.%u", count
);
1735 block
->bindings()->add_variable(pname
, NULL
, param
);
1739 function
->create_result_variables(this);
1741 const std::string
* pname
;
1742 std::string nested_name
;
1743 bool is_init
= false;
1744 if (Gogo::unpack_hidden_name(name
) == "init" && !type
->is_method())
1746 if ((type
->parameters() != NULL
&& !type
->parameters()->empty())
1747 || (type
->results() != NULL
&& !type
->results()->empty()))
1748 go_error_at(location
,
1749 "func init must have no arguments and no return values");
1750 // There can be multiple "init" functions, so give them each a
1752 nested_name
= this->init_function_name();
1753 pname
= &nested_name
;
1756 else if (!name
.empty())
1760 // Invent a name for a nested function.
1761 nested_name
= this->nested_function_name(enclosing
);
1762 pname
= &nested_name
;
1766 if (Gogo::is_sink_name(*pname
))
1768 std::string
sname(this->sink_function_name());
1769 ret
= Named_object::make_function(sname
, NULL
, function
);
1770 ret
->func_value()->set_is_sink();
1772 if (!type
->is_method())
1773 ret
= this->package_
->bindings()->add_named_object(ret
);
1774 else if (add_method_to_type
)
1776 // We should report errors even for sink methods.
1777 Type
* rtype
= type
->receiver()->type();
1778 // Avoid points_to and deref to avoid getting an error if
1779 // the type is not yet defined.
1780 if (rtype
->classification() == Type::TYPE_POINTER
)
1781 rtype
= rtype
->points_to();
1782 while (rtype
->named_type() != NULL
1783 && rtype
->named_type()->is_alias())
1784 rtype
= rtype
->named_type()->real_type()->forwarded();
1785 if (rtype
->is_error_type())
1787 else if (rtype
->named_type() != NULL
)
1789 if (rtype
->named_type()->named_object()->package() != NULL
)
1790 go_error_at(type
->receiver()->location(),
1791 "may not define methods on non-local type");
1793 else if (rtype
->forward_declaration_type() != NULL
)
1795 // Go ahead and add the method in case we need to report
1796 // an error when we see the definition.
1797 rtype
->forward_declaration_type()->add_existing_method(ret
);
1800 go_error_at(type
->receiver()->location(),
1801 ("invalid receiver type "
1802 "(receiver must be a named type)"));
1805 else if (!type
->is_method())
1807 ret
= this->package_
->bindings()->add_function(*pname
, NULL
, function
);
1808 if (!ret
->is_function() || ret
->func_value() != function
)
1810 // Redefinition error. Invent a name to avoid knockon
1812 std::string
rname(this->redefined_function_name());
1813 ret
= this->package_
->bindings()->add_function(rname
, NULL
, function
);
1818 if (!add_method_to_type
)
1819 ret
= Named_object::make_function(name
, NULL
, function
);
1822 go_assert(at_top_level
);
1823 Type
* rtype
= type
->receiver()->type();
1825 // We want to look through the pointer created by the
1826 // parser, without getting an error if the type is not yet
1828 if (rtype
->classification() == Type::TYPE_POINTER
)
1829 rtype
= rtype
->points_to();
1831 while (rtype
->named_type() != NULL
1832 && rtype
->named_type()->is_alias())
1833 rtype
= rtype
->named_type()->real_type()->forwarded();
1835 if (rtype
->is_error_type())
1836 ret
= Named_object::make_function(name
, NULL
, function
);
1837 else if (rtype
->named_type() != NULL
)
1839 if (rtype
->named_type()->named_object()->package() != NULL
)
1841 go_error_at(type
->receiver()->location(),
1842 "may not define methods on non-local type");
1843 ret
= Named_object::make_function(name
, NULL
, function
);
1847 ret
= rtype
->named_type()->add_method(name
, function
);
1848 if (!ret
->is_function())
1850 // Redefinition error.
1851 ret
= Named_object::make_function(name
, NULL
, function
);
1855 else if (rtype
->forward_declaration_type() != NULL
)
1857 Named_object
* type_no
=
1858 rtype
->forward_declaration_type()->named_object();
1859 if (type_no
->is_unknown())
1861 // If we are seeing methods it really must be a
1862 // type. Declare it as such. An alternative would
1863 // be to support lists of methods for unknown
1864 // expressions. Either way the error messages if
1865 // this is not a type are going to get confusing.
1866 Named_object
* declared
=
1867 this->declare_package_type(type_no
->name(),
1868 type_no
->location());
1870 == type_no
->unknown_value()->real_named_object());
1872 ret
= rtype
->forward_declaration_type()->add_method(name
,
1877 go_error_at(type
->receiver()->location(),
1878 ("invalid receiver type (receiver must "
1879 "be a named type)"));
1880 ret
= Named_object::make_function(name
, NULL
, function
);
1883 this->package_
->bindings()->add_method(ret
);
1886 this->functions_
.resize(this->functions_
.size() + 1);
1887 Open_function
& of(this->functions_
.back());
1889 of
.blocks
.push_back(block
);
1893 this->init_functions_
.push_back(ret
);
1894 this->need_init_fn_
= true;
1900 // Finish compiling a function.
1903 Gogo::finish_function(Location location
)
1905 this->finish_block(location
);
1906 go_assert(this->functions_
.back().blocks
.empty());
1907 this->functions_
.pop_back();
1910 // Return the current function.
1913 Gogo::current_function() const
1915 go_assert(!this->functions_
.empty());
1916 return this->functions_
.back().function
;
1919 // Start a new block.
1922 Gogo::start_block(Location location
)
1924 go_assert(!this->functions_
.empty());
1925 Block
* block
= new Block(this->current_block(), location
);
1926 this->functions_
.back().blocks
.push_back(block
);
1932 Gogo::finish_block(Location location
)
1934 go_assert(!this->functions_
.empty());
1935 go_assert(!this->functions_
.back().blocks
.empty());
1936 Block
* block
= this->functions_
.back().blocks
.back();
1937 this->functions_
.back().blocks
.pop_back();
1938 block
->set_end_location(location
);
1942 // Add an erroneous name.
1945 Gogo::add_erroneous_name(const std::string
& name
)
1947 return this->package_
->bindings()->add_erroneous_name(name
);
1950 // Add an unknown name.
1953 Gogo::add_unknown_name(const std::string
& name
, Location location
)
1955 return this->package_
->bindings()->add_unknown_name(name
, location
);
1958 // Declare a function.
1961 Gogo::declare_function(const std::string
& name
, Function_type
* type
,
1964 if (!type
->is_method())
1965 return this->current_bindings()->add_function_declaration(name
, NULL
, type
,
1969 // We don't bother to add this to the list of global
1971 Type
* rtype
= type
->receiver()->type();
1973 // We want to look through the pointer created by the
1974 // parser, without getting an error if the type is not yet
1976 if (rtype
->classification() == Type::TYPE_POINTER
)
1977 rtype
= rtype
->points_to();
1979 if (rtype
->is_error_type())
1981 else if (rtype
->named_type() != NULL
)
1982 return rtype
->named_type()->add_method_declaration(name
, NULL
, type
,
1984 else if (rtype
->forward_declaration_type() != NULL
)
1986 Forward_declaration_type
* ftype
= rtype
->forward_declaration_type();
1987 return ftype
->add_method_declaration(name
, NULL
, type
, location
);
1991 go_error_at(type
->receiver()->location(),
1992 "invalid receiver type (receiver must be a named type)");
1993 return Named_object::make_erroneous_name(name
);
1998 // Add a label definition.
2001 Gogo::add_label_definition(const std::string
& label_name
,
2004 go_assert(!this->functions_
.empty());
2005 Function
* func
= this->functions_
.back().function
->func_value();
2006 Label
* label
= func
->add_label_definition(this, label_name
, location
);
2007 this->add_statement(Statement::make_label_statement(label
, location
));
2011 // Add a label reference.
2014 Gogo::add_label_reference(const std::string
& label_name
,
2015 Location location
, bool issue_goto_errors
)
2017 go_assert(!this->functions_
.empty());
2018 Function
* func
= this->functions_
.back().function
->func_value();
2019 return func
->add_label_reference(this, label_name
, location
,
2023 // Return the current binding state.
2026 Gogo::bindings_snapshot(Location location
)
2028 return new Bindings_snapshot(this->current_block(), location
);
2034 Gogo::add_statement(Statement
* statement
)
2036 go_assert(!this->functions_
.empty()
2037 && !this->functions_
.back().blocks
.empty());
2038 this->functions_
.back().blocks
.back()->add_statement(statement
);
2044 Gogo::add_block(Block
* block
, Location location
)
2046 go_assert(!this->functions_
.empty()
2047 && !this->functions_
.back().blocks
.empty());
2048 Statement
* statement
= Statement::make_block_statement(block
, location
);
2049 this->functions_
.back().blocks
.back()->add_statement(statement
);
2055 Gogo::add_constant(const Typed_identifier
& tid
, Expression
* expr
,
2058 return this->current_bindings()->add_constant(tid
, NULL
, expr
, iota_value
);
2064 Gogo::add_type(const std::string
& name
, Type
* type
, Location location
)
2066 Named_object
* no
= this->current_bindings()->add_type(name
, NULL
, type
,
2068 if (!this->in_global_scope() && no
->is_type())
2070 Named_object
* f
= this->functions_
.back().function
;
2072 if (f
->is_function())
2073 index
= f
->func_value()->new_local_type_index();
2076 no
->type_value()->set_in_function(f
, index
);
2080 // Add a named type.
2083 Gogo::add_named_type(Named_type
* type
)
2085 go_assert(this->in_global_scope());
2086 this->current_bindings()->add_named_type(type
);
2092 Gogo::declare_type(const std::string
& name
, Location location
)
2094 Bindings
* bindings
= this->current_bindings();
2095 Named_object
* no
= bindings
->add_type_declaration(name
, NULL
, location
);
2096 if (!this->in_global_scope() && no
->is_type_declaration())
2098 Named_object
* f
= this->functions_
.back().function
;
2100 if (f
->is_function())
2101 index
= f
->func_value()->new_local_type_index();
2104 no
->type_declaration_value()->set_in_function(f
, index
);
2109 // Declare a type at the package level.
2112 Gogo::declare_package_type(const std::string
& name
, Location location
)
2114 return this->package_
->bindings()->add_type_declaration(name
, NULL
, location
);
2117 // Declare a function at the package level.
2120 Gogo::declare_package_function(const std::string
& name
, Function_type
* type
,
2123 return this->package_
->bindings()->add_function_declaration(name
, NULL
, type
,
2127 // Define a type which was already declared.
2130 Gogo::define_type(Named_object
* no
, Named_type
* type
)
2132 this->current_bindings()->define_type(no
, type
);
2138 Gogo::add_variable(const std::string
& name
, Variable
* variable
)
2140 Named_object
* no
= this->current_bindings()->add_variable(name
, NULL
,
2143 // In a function the middle-end wants to see a DECL_EXPR node.
2145 && no
->is_variable()
2146 && !no
->var_value()->is_parameter()
2147 && !this->functions_
.empty())
2148 this->add_statement(Statement::make_variable_declaration(no
));
2153 // Add a sink--a reference to the blank identifier _.
2158 return Named_object::make_sink();
2161 // Add a named object for a dot import.
2164 Gogo::add_dot_import_object(Named_object
* no
)
2166 // If the name already exists, then it was defined in some file seen
2167 // earlier. If the earlier name is just a declaration, don't add
2168 // this name, because that will cause the previous declaration to
2169 // merge to this imported name, which should not happen. Just add
2170 // this name to the list of file block names to get appropriate
2171 // errors if we see a later definition.
2172 Named_object
* e
= this->package_
->bindings()->lookup(no
->name());
2173 if (e
!= NULL
&& e
->package() == NULL
)
2175 if (e
->is_unknown())
2177 if (e
->package() == NULL
2178 && (e
->is_type_declaration()
2179 || e
->is_function_declaration()
2180 || e
->is_unknown()))
2182 this->add_file_block_name(no
->name(), no
->location());
2187 this->current_bindings()->add_named_object(no
);
2190 // Add a linkname. This implements the go:linkname compiler directive.
2191 // We only support this for functions and function declarations.
2194 Gogo::add_linkname(const std::string
& go_name
, bool is_exported
,
2195 const std::string
& ext_name
, Location loc
)
2198 this->package_
->bindings()->lookup(this->pack_hidden_name(go_name
,
2201 go_error_at(loc
, "%s is not defined", go_name
.c_str());
2202 else if (no
->is_function())
2203 no
->func_value()->set_asm_name(ext_name
);
2204 else if (no
->is_function_declaration())
2205 no
->func_declaration_value()->set_asm_name(ext_name
);
2208 ("%s is not a function; "
2209 "//go:linkname is only supported for functions"),
2213 // Mark all local variables used. This is used when some types of
2214 // parse error occur.
2217 Gogo::mark_locals_used()
2219 for (Open_functions::iterator pf
= this->functions_
.begin();
2220 pf
!= this->functions_
.end();
2223 for (std::vector
<Block
*>::iterator pb
= pf
->blocks
.begin();
2224 pb
!= pf
->blocks
.end();
2226 (*pb
)->bindings()->mark_locals_used();
2230 // Record that we've seen an interface type.
2233 Gogo::record_interface_type(Interface_type
* itype
)
2235 this->interface_types_
.push_back(itype
);
2238 // Define the global names. We do this only after parsing all the
2239 // input files, because the program might define the global names
2243 Gogo::define_global_names()
2245 if (this->is_main_package())
2247 // Every Go program has to import the runtime package, so that
2248 // it is properly initialized.
2249 this->import_package("runtime", "_", false, false,
2250 Linemap::predeclared_location());
2253 for (Bindings::const_declarations_iterator p
=
2254 this->globals_
->begin_declarations();
2255 p
!= this->globals_
->end_declarations();
2258 Named_object
* global_no
= p
->second
;
2259 std::string
name(Gogo::pack_hidden_name(global_no
->name(), false));
2260 Named_object
* no
= this->package_
->bindings()->lookup(name
);
2264 if (no
->is_type_declaration())
2266 if (global_no
->is_type())
2268 if (no
->type_declaration_value()->has_methods())
2270 for (std::vector
<Named_object
*>::const_iterator p
=
2271 no
->type_declaration_value()->methods()->begin();
2272 p
!= no
->type_declaration_value()->methods()->end();
2274 go_error_at((*p
)->location(),
2275 "may not define methods on non-local type");
2277 no
->set_type_value(global_no
->type_value());
2281 go_error_at(no
->location(), "expected type");
2282 Type
* errtype
= Type::make_error_type();
2284 Named_object::make_type("erroneous_type", NULL
, errtype
,
2285 Linemap::predeclared_location());
2286 no
->set_type_value(err
->type_value());
2289 else if (no
->is_unknown())
2290 no
->unknown_value()->set_real_named_object(global_no
);
2293 // Give an error if any name is defined in both the package block
2294 // and the file block. For example, this can happen if one file
2295 // imports "fmt" and another file defines a global variable fmt.
2296 for (Bindings::const_declarations_iterator p
=
2297 this->package_
->bindings()->begin_declarations();
2298 p
!= this->package_
->bindings()->end_declarations();
2301 if (p
->second
->is_unknown()
2302 && p
->second
->unknown_value()->real_named_object() == NULL
)
2304 // No point in warning about an undefined name, as we will
2305 // get other errors later anyhow.
2308 File_block_names::const_iterator pf
=
2309 this->file_block_names_
.find(p
->second
->name());
2310 if (pf
!= this->file_block_names_
.end())
2312 std::string n
= p
->second
->message_name();
2313 go_error_at(p
->second
->location(),
2314 "%qs defined as both imported name and global name",
2316 go_inform(pf
->second
, "%qs imported here", n
.c_str());
2319 // No package scope identifier may be named "init".
2320 if (!p
->second
->is_function()
2321 && Gogo::unpack_hidden_name(p
->second
->name()) == "init")
2323 go_error_at(p
->second
->location(),
2324 "cannot declare init - must be func");
2329 // Clear out names in file scope.
2332 Gogo::clear_file_scope()
2334 this->package_
->bindings()->clear_file_scope(this);
2336 // Warn about packages which were imported but not used.
2337 bool quiet
= saw_errors();
2338 for (Packages::iterator p
= this->packages_
.begin();
2339 p
!= this->packages_
.end();
2342 Package
* package
= p
->second
;
2343 if (package
!= this->package_
&& !quiet
)
2345 for (Package::Aliases::const_iterator p1
= package
->aliases().begin();
2346 p1
!= package
->aliases().end();
2349 if (!p1
->second
->used())
2351 // Give a more refined error message if the alias name is known.
2352 std::string pkg_name
= package
->package_name();
2353 if (p1
->first
!= pkg_name
&& p1
->first
[0] != '.')
2355 go_error_at(p1
->second
->location(),
2356 "imported and not used: %s as %s",
2357 Gogo::message_name(pkg_name
).c_str(),
2358 Gogo::message_name(p1
->first
).c_str());
2361 go_error_at(p1
->second
->location(),
2362 "imported and not used: %s",
2363 Gogo::message_name(pkg_name
).c_str());
2367 package
->clear_used();
2370 this->current_file_imported_unsafe_
= false;
2373 // Queue up a type specific function for later writing. These are
2374 // written out in write_specific_type_functions, called after the
2375 // parse tree is lowered.
2378 Gogo::queue_specific_type_function(Type
* type
, Named_type
* name
, int64_t size
,
2379 const std::string
& hash_name
,
2380 Function_type
* hash_fntype
,
2381 const std::string
& equal_name
,
2382 Function_type
* equal_fntype
)
2384 go_assert(!this->specific_type_functions_are_written_
);
2385 go_assert(!this->in_global_scope());
2386 Specific_type_function
* tsf
= new Specific_type_function(type
, name
, size
,
2391 this->specific_type_functions_
.push_back(tsf
);
2394 // Look for types which need specific hash or equality functions.
2396 class Specific_type_functions
: public Traverse
2399 Specific_type_functions(Gogo
* gogo
)
2400 : Traverse(traverse_types
),
2412 Specific_type_functions::type(Type
* t
)
2414 Named_object
* hash_fn
;
2415 Named_object
* equal_fn
;
2416 switch (t
->classification())
2418 case Type::TYPE_NAMED
:
2420 Named_type
* nt
= t
->named_type();
2422 return TRAVERSE_CONTINUE
;
2423 if (t
->needs_specific_type_functions(this->gogo_
))
2424 t
->type_functions(this->gogo_
, nt
, NULL
, NULL
, &hash_fn
, &equal_fn
);
2426 // If this is a struct type, we don't want to make functions
2427 // for the unnamed struct.
2428 Type
* rt
= nt
->real_type();
2429 if (rt
->struct_type() == NULL
)
2431 if (Type::traverse(rt
, this) == TRAVERSE_EXIT
)
2432 return TRAVERSE_EXIT
;
2436 // If this type is defined in another package, then we don't
2437 // need to worry about the unexported fields.
2438 bool is_defined_elsewhere
= nt
->named_object()->package() != NULL
;
2439 const Struct_field_list
* fields
= rt
->struct_type()->fields();
2440 for (Struct_field_list::const_iterator p
= fields
->begin();
2444 if (is_defined_elsewhere
2445 && Gogo::is_hidden_name(p
->field_name()))
2447 if (Type::traverse(p
->type(), this) == TRAVERSE_EXIT
)
2448 return TRAVERSE_EXIT
;
2452 return TRAVERSE_SKIP_COMPONENTS
;
2455 case Type::TYPE_STRUCT
:
2456 case Type::TYPE_ARRAY
:
2457 if (t
->needs_specific_type_functions(this->gogo_
))
2458 t
->type_functions(this->gogo_
, NULL
, NULL
, NULL
, &hash_fn
, &equal_fn
);
2465 return TRAVERSE_CONTINUE
;
2468 // Write out type specific functions.
2471 Gogo::write_specific_type_functions()
2473 Specific_type_functions
stf(this);
2474 this->traverse(&stf
);
2476 while (!this->specific_type_functions_
.empty())
2478 Specific_type_function
* tsf
= this->specific_type_functions_
.back();
2479 this->specific_type_functions_
.pop_back();
2480 tsf
->type
->write_specific_type_functions(this, tsf
->name
, tsf
->size
,
2487 this->specific_type_functions_are_written_
= true;
2490 // Traverse the tree.
2493 Gogo::traverse(Traverse
* traverse
)
2495 // Traverse the current package first for consistency. The other
2496 // packages will only contain imported types, constants, and
2498 if (this->package_
->bindings()->traverse(traverse
, true) == TRAVERSE_EXIT
)
2500 for (Packages::const_iterator p
= this->packages_
.begin();
2501 p
!= this->packages_
.end();
2504 if (p
->second
!= this->package_
)
2506 if (p
->second
->bindings()->traverse(traverse
, true) == TRAVERSE_EXIT
)
2512 // Add a type to verify. This is used for types of sink variables, in
2513 // order to give appropriate error messages.
2516 Gogo::add_type_to_verify(Type
* type
)
2518 this->verify_types_
.push_back(type
);
2521 // Traversal class used to verify types.
2523 class Verify_types
: public Traverse
2527 : Traverse(traverse_types
)
2534 // Verify that a type is correct.
2537 Verify_types::type(Type
* t
)
2540 return TRAVERSE_SKIP_COMPONENTS
;
2541 return TRAVERSE_CONTINUE
;
2544 // Verify that all types are correct.
2547 Gogo::verify_types()
2549 Verify_types traverse
;
2550 this->traverse(&traverse
);
2552 for (std::vector
<Type
*>::iterator p
= this->verify_types_
.begin();
2553 p
!= this->verify_types_
.end();
2556 this->verify_types_
.clear();
2559 // Traversal class used to lower parse tree.
2561 class Lower_parse_tree
: public Traverse
2564 Lower_parse_tree(Gogo
* gogo
, Named_object
* function
)
2565 : Traverse(traverse_variables
2566 | traverse_constants
2567 | traverse_functions
2568 | traverse_statements
2569 | traverse_expressions
),
2570 gogo_(gogo
), function_(function
), iota_value_(-1), inserter_()
2574 set_inserter(const Statement_inserter
* inserter
)
2575 { this->inserter_
= *inserter
; }
2578 variable(Named_object
*);
2581 constant(Named_object
*, bool);
2584 function(Named_object
*);
2587 statement(Block
*, size_t* pindex
, Statement
*);
2590 expression(Expression
**);
2595 // The function we are traversing.
2596 Named_object
* function_
;
2597 // Value to use for the predeclared constant iota.
2599 // Current statement inserter for use by expressions.
2600 Statement_inserter inserter_
;
2606 Lower_parse_tree::variable(Named_object
* no
)
2608 if (!no
->is_variable())
2609 return TRAVERSE_CONTINUE
;
2611 if (no
->is_variable() && no
->var_value()->is_global())
2613 // Global variables can have loops in their initialization
2614 // expressions. This is handled in lower_init_expression.
2615 no
->var_value()->lower_init_expression(this->gogo_
, this->function_
,
2617 return TRAVERSE_CONTINUE
;
2620 // This is a local variable. We are going to return
2621 // TRAVERSE_SKIP_COMPONENTS here because we want to traverse the
2622 // initialization expression when we reach the variable declaration
2623 // statement. However, that means that we need to traverse the type
2625 if (no
->var_value()->has_type())
2627 Type
* type
= no
->var_value()->type();
2630 if (Type::traverse(type
, this) == TRAVERSE_EXIT
)
2631 return TRAVERSE_EXIT
;
2634 go_assert(!no
->var_value()->has_pre_init());
2636 return TRAVERSE_SKIP_COMPONENTS
;
2639 // Lower constants. We handle constants specially so that we can set
2640 // the right value for the predeclared constant iota. This works in
2641 // conjunction with the way we lower Const_expression objects.
2644 Lower_parse_tree::constant(Named_object
* no
, bool)
2646 Named_constant
* nc
= no
->const_value();
2648 // Don't get into trouble if the constant's initializer expression
2649 // refers to the constant itself.
2651 return TRAVERSE_CONTINUE
;
2654 go_assert(this->iota_value_
== -1);
2655 this->iota_value_
= nc
->iota_value();
2656 nc
->traverse_expression(this);
2657 this->iota_value_
= -1;
2659 nc
->clear_lowering();
2661 // We will traverse the expression a second time, but that will be
2664 return TRAVERSE_CONTINUE
;
2667 // Lower the body of a function, and set the closure type. Record the
2668 // function while lowering it, so that we can pass it down when
2669 // lowering an expression.
2672 Lower_parse_tree::function(Named_object
* no
)
2674 no
->func_value()->set_closure_type();
2676 go_assert(this->function_
== NULL
);
2677 this->function_
= no
;
2678 int t
= no
->func_value()->traverse(this);
2679 this->function_
= NULL
;
2681 if (t
== TRAVERSE_EXIT
)
2683 return TRAVERSE_SKIP_COMPONENTS
;
2686 // Lower statement parse trees.
2689 Lower_parse_tree::statement(Block
* block
, size_t* pindex
, Statement
* sorig
)
2691 // Because we explicitly traverse the statement's contents
2692 // ourselves, we want to skip block statements here. There is
2693 // nothing to lower in a block statement.
2694 if (sorig
->is_block_statement())
2695 return TRAVERSE_CONTINUE
;
2697 Statement_inserter
hold_inserter(this->inserter_
);
2698 this->inserter_
= Statement_inserter(block
, pindex
);
2700 // Lower the expressions first.
2701 int t
= sorig
->traverse_contents(this);
2702 if (t
== TRAVERSE_EXIT
)
2704 this->inserter_
= hold_inserter
;
2708 // Keep lowering until nothing changes.
2709 Statement
* s
= sorig
;
2712 Statement
* snew
= s
->lower(this->gogo_
, this->function_
, block
,
2717 t
= s
->traverse_contents(this);
2718 if (t
== TRAVERSE_EXIT
)
2720 this->inserter_
= hold_inserter
;
2726 block
->replace_statement(*pindex
, s
);
2728 this->inserter_
= hold_inserter
;
2729 return TRAVERSE_SKIP_COMPONENTS
;
2732 // Lower expression parse trees.
2735 Lower_parse_tree::expression(Expression
** pexpr
)
2737 // We have to lower all subexpressions first, so that we can get
2738 // their type if necessary. This is awkward, because we don't have
2739 // a postorder traversal pass.
2740 if ((*pexpr
)->traverse_subexpressions(this) == TRAVERSE_EXIT
)
2741 return TRAVERSE_EXIT
;
2742 // Keep lowering until nothing changes.
2745 Expression
* e
= *pexpr
;
2746 Expression
* enew
= e
->lower(this->gogo_
, this->function_
,
2747 &this->inserter_
, this->iota_value_
);
2750 if (enew
->traverse_subexpressions(this) == TRAVERSE_EXIT
)
2751 return TRAVERSE_EXIT
;
2755 // Lower the type of this expression before the parent looks at it,
2756 // in case the type contains an array that has expressions in its
2757 // length. Skip an Unknown_expression, as at this point that means
2758 // a composite literal key that does not have a type.
2759 if ((*pexpr
)->unknown_expression() == NULL
)
2760 Type::traverse((*pexpr
)->type(), this);
2762 return TRAVERSE_SKIP_COMPONENTS
;
2765 // Lower the parse tree. This is called after the parse is complete,
2766 // when all names should be resolved.
2769 Gogo::lower_parse_tree()
2771 Lower_parse_tree
lower_parse_tree(this, NULL
);
2772 this->traverse(&lower_parse_tree
);
2774 // There might be type definitions that involve expressions such as the
2775 // array length. Make sure to lower these expressions as well. Otherwise,
2776 // errors hidden within a type can introduce unexpected errors into later
2778 for (std::vector
<Type
*>::iterator p
= this->verify_types_
.begin();
2779 p
!= this->verify_types_
.end();
2781 Type::traverse(*p
, &lower_parse_tree
);
2787 Gogo::lower_block(Named_object
* function
, Block
* block
)
2789 Lower_parse_tree
lower_parse_tree(this, function
);
2790 block
->traverse(&lower_parse_tree
);
2793 // Lower an expression. INSERTER may be NULL, in which case the
2794 // expression had better not need to create any temporaries.
2797 Gogo::lower_expression(Named_object
* function
, Statement_inserter
* inserter
,
2800 Lower_parse_tree
lower_parse_tree(this, function
);
2801 if (inserter
!= NULL
)
2802 lower_parse_tree
.set_inserter(inserter
);
2803 lower_parse_tree
.expression(pexpr
);
2806 // Lower a constant. This is called when lowering a reference to a
2807 // constant. We have to make sure that the constant has already been
2811 Gogo::lower_constant(Named_object
* no
)
2813 go_assert(no
->is_const());
2814 Lower_parse_tree
lower(this, NULL
);
2815 lower
.constant(no
, false);
2818 // Traverse the tree to create function descriptors as needed.
2820 class Create_function_descriptors
: public Traverse
2823 Create_function_descriptors(Gogo
* gogo
)
2824 : Traverse(traverse_functions
| traverse_expressions
),
2829 function(Named_object
*);
2832 expression(Expression
**);
2838 // Create a descriptor for every top-level exported function.
2841 Create_function_descriptors::function(Named_object
* no
)
2843 if (no
->is_function()
2844 && no
->func_value()->enclosing() == NULL
2845 && !no
->func_value()->is_method()
2846 && !Gogo::is_hidden_name(no
->name())
2847 && !Gogo::is_thunk(no
))
2848 no
->func_value()->descriptor(this->gogo_
, no
);
2850 return TRAVERSE_CONTINUE
;
2853 // If we see a function referenced in any way other than calling it,
2854 // create a descriptor for it.
2857 Create_function_descriptors::expression(Expression
** pexpr
)
2859 Expression
* expr
= *pexpr
;
2861 Func_expression
* fe
= expr
->func_expression();
2864 // We would not get here for a call to this function, so this is
2865 // a reference to a function other than calling it. We need a
2867 if (fe
->closure() != NULL
)
2868 return TRAVERSE_CONTINUE
;
2869 Named_object
* no
= fe
->named_object();
2870 if (no
->is_function() && !no
->func_value()->is_method())
2871 no
->func_value()->descriptor(this->gogo_
, no
);
2872 else if (no
->is_function_declaration()
2873 && !no
->func_declaration_value()->type()->is_method()
2874 && !Linemap::is_predeclared_location(no
->location()))
2875 no
->func_declaration_value()->descriptor(this->gogo_
, no
);
2876 return TRAVERSE_CONTINUE
;
2879 Bound_method_expression
* bme
= expr
->bound_method_expression();
2882 // We would not get here for a call to this method, so this is a
2883 // method value. We need to create a thunk.
2884 Bound_method_expression::create_thunk(this->gogo_
, bme
->method(),
2886 return TRAVERSE_CONTINUE
;
2889 Interface_field_reference_expression
* ifre
=
2890 expr
->interface_field_reference_expression();
2893 // We would not get here for a call to this interface method, so
2894 // this is a method value. We need to create a thunk.
2895 Interface_type
* type
= ifre
->expr()->type()->interface_type();
2897 Interface_field_reference_expression::create_thunk(this->gogo_
, type
,
2899 return TRAVERSE_CONTINUE
;
2902 Call_expression
* ce
= expr
->call_expression();
2905 Expression
* fn
= ce
->fn();
2906 if (fn
->func_expression() != NULL
2907 || fn
->bound_method_expression() != NULL
2908 || fn
->interface_field_reference_expression() != NULL
)
2910 // Traverse the arguments but not the function.
2911 Expression_list
* args
= ce
->args();
2914 if (args
->traverse(this) == TRAVERSE_EXIT
)
2915 return TRAVERSE_EXIT
;
2917 return TRAVERSE_SKIP_COMPONENTS
;
2921 return TRAVERSE_CONTINUE
;
2924 // Create function descriptors as needed. We need a function
2925 // descriptor for all exported functions and for all functions that
2926 // are referenced without being called.
2929 Gogo::create_function_descriptors()
2931 // Create a function descriptor for any exported function that is
2932 // declared in this package. This is so that we have a descriptor
2933 // for functions written in assembly. Gather the descriptors first
2934 // so that we don't add declarations while looping over them.
2935 std::vector
<Named_object
*> fndecls
;
2936 Bindings
* b
= this->package_
->bindings();
2937 for (Bindings::const_declarations_iterator p
= b
->begin_declarations();
2938 p
!= b
->end_declarations();
2941 Named_object
* no
= p
->second
;
2942 if (no
->is_function_declaration()
2943 && !no
->func_declaration_value()->type()->is_method()
2944 && !Linemap::is_predeclared_location(no
->location())
2945 && !Gogo::is_hidden_name(no
->name()))
2946 fndecls
.push_back(no
);
2948 for (std::vector
<Named_object
*>::const_iterator p
= fndecls
.begin();
2951 (*p
)->func_declaration_value()->descriptor(this, *p
);
2954 Create_function_descriptors
cfd(this);
2955 this->traverse(&cfd
);
2958 // Look for interface types to finalize methods of inherited
2961 class Finalize_methods
: public Traverse
2964 Finalize_methods(Gogo
* gogo
)
2965 : Traverse(traverse_types
),
2976 // Finalize the methods of an interface type.
2979 Finalize_methods::type(Type
* t
)
2981 // Check the classification so that we don't finalize the methods
2982 // twice for a named interface type.
2983 switch (t
->classification())
2985 case Type::TYPE_INTERFACE
:
2986 t
->interface_type()->finalize_methods();
2989 case Type::TYPE_NAMED
:
2991 Named_type
* nt
= t
->named_type();
2992 Type
* rt
= nt
->real_type();
2993 if (rt
->classification() != Type::TYPE_STRUCT
)
2995 // Finalize the methods of the real type first.
2996 if (Type::traverse(rt
, this) == TRAVERSE_EXIT
)
2997 return TRAVERSE_EXIT
;
2999 // Finalize the methods of this type.
3000 nt
->finalize_methods(this->gogo_
);
3004 // We don't want to finalize the methods of a named struct
3005 // type, as the methods should be attached to the named
3006 // type, not the struct type. We just want to finalize
3009 // It is possible that a field type refers indirectly to
3010 // this type, such as via a field with function type with
3011 // an argument or result whose type is this type. To
3012 // avoid the cycle, first finalize the methods of any
3013 // embedded types, which are the only types we need to
3014 // know to finalize the methods of this type.
3015 const Struct_field_list
* fields
= rt
->struct_type()->fields();
3018 for (Struct_field_list::const_iterator pf
= fields
->begin();
3019 pf
!= fields
->end();
3022 if (pf
->is_anonymous())
3024 if (Type::traverse(pf
->type(), this) == TRAVERSE_EXIT
)
3025 return TRAVERSE_EXIT
;
3030 // Finalize the methods of this type.
3031 nt
->finalize_methods(this->gogo_
);
3033 // Finalize all the struct fields.
3034 if (rt
->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT
)
3035 return TRAVERSE_EXIT
;
3038 // If this type is defined in a different package, then finalize the
3039 // types of all the methods, since we won't see them otherwise.
3040 if (nt
->named_object()->package() != NULL
&& nt
->has_any_methods())
3042 const Methods
* methods
= nt
->methods();
3043 for (Methods::const_iterator p
= methods
->begin();
3044 p
!= methods
->end();
3047 if (Type::traverse(p
->second
->type(), this) == TRAVERSE_EXIT
)
3048 return TRAVERSE_EXIT
;
3052 // Finalize the types of all methods that are declared but not
3053 // defined, since we won't see the declarations otherwise.
3054 if (nt
->named_object()->package() == NULL
3055 && nt
->local_methods() != NULL
)
3057 const Bindings
* methods
= nt
->local_methods();
3058 for (Bindings::const_declarations_iterator p
=
3059 methods
->begin_declarations();
3060 p
!= methods
->end_declarations();
3063 if (p
->second
->is_function_declaration())
3065 Type
* mt
= p
->second
->func_declaration_value()->type();
3066 if (Type::traverse(mt
, this) == TRAVERSE_EXIT
)
3067 return TRAVERSE_EXIT
;
3072 return TRAVERSE_SKIP_COMPONENTS
;
3075 case Type::TYPE_STRUCT
:
3076 // Traverse the field types first in case there is an embedded
3077 // field with methods that the struct should inherit.
3078 if (t
->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT
)
3079 return TRAVERSE_EXIT
;
3080 t
->struct_type()->finalize_methods(this->gogo_
);
3081 return TRAVERSE_SKIP_COMPONENTS
;
3087 return TRAVERSE_CONTINUE
;
3090 // Finalize method lists and build stub methods for types.
3093 Gogo::finalize_methods()
3095 Finalize_methods
finalize(this);
3096 this->traverse(&finalize
);
3099 // Set types for unspecified variables and constants.
3102 Gogo::determine_types()
3104 Bindings
* bindings
= this->current_bindings();
3105 for (Bindings::const_definitions_iterator p
= bindings
->begin_definitions();
3106 p
!= bindings
->end_definitions();
3109 if ((*p
)->is_function())
3110 (*p
)->func_value()->determine_types();
3111 else if ((*p
)->is_variable())
3112 (*p
)->var_value()->determine_type();
3113 else if ((*p
)->is_const())
3114 (*p
)->const_value()->determine_type();
3116 // See if a variable requires us to build an initialization
3117 // function. We know that we will see all global variables
3119 if (!this->need_init_fn_
&& (*p
)->is_variable())
3121 Variable
* variable
= (*p
)->var_value();
3123 // If this is a global variable which requires runtime
3124 // initialization, we need an initialization function.
3125 if (!variable
->is_global())
3127 else if (variable
->init() == NULL
)
3129 else if (variable
->type()->interface_type() != NULL
)
3130 this->need_init_fn_
= true;
3131 else if (variable
->init()->is_constant())
3133 else if (!variable
->init()->is_composite_literal())
3134 this->need_init_fn_
= true;
3135 else if (variable
->init()->is_nonconstant_composite_literal())
3136 this->need_init_fn_
= true;
3138 // If this is a global variable which holds a pointer value,
3139 // then we need an initialization function to register it as a
3141 if (variable
->is_global() && variable
->type()->has_pointer())
3142 this->need_init_fn_
= true;
3146 // Determine the types of constants in packages.
3147 for (Packages::const_iterator p
= this->packages_
.begin();
3148 p
!= this->packages_
.end();
3150 p
->second
->determine_types();
3153 // Traversal class used for type checking.
3155 class Check_types_traverse
: public Traverse
3158 Check_types_traverse(Gogo
* gogo
)
3159 : Traverse(traverse_variables
3160 | traverse_constants
3161 | traverse_functions
3162 | traverse_statements
3163 | traverse_expressions
),
3168 variable(Named_object
*);
3171 constant(Named_object
*, bool);
3174 function(Named_object
*);
3177 statement(Block
*, size_t* pindex
, Statement
*);
3180 expression(Expression
**);
3187 // Check that a variable initializer has the right type.
3190 Check_types_traverse::variable(Named_object
* named_object
)
3192 if (named_object
->is_variable())
3194 Variable
* var
= named_object
->var_value();
3196 // Give error if variable type is not defined.
3197 var
->type()->base();
3199 Expression
* init
= var
->init();
3202 && !Type::are_assignable(var
->type(), init
->type(), &reason
))
3205 go_error_at(var
->location(), "incompatible type in initialization");
3207 go_error_at(var
->location(),
3208 "incompatible type in initialization (%s)",
3210 init
= Expression::make_error(named_object
->location());
3213 else if (init
!= NULL
3214 && init
->func_expression() != NULL
)
3216 Named_object
* no
= init
->func_expression()->named_object();
3217 Function_type
* fntype
;
3218 if (no
->is_function())
3219 fntype
= no
->func_value()->type();
3220 else if (no
->is_function_declaration())
3221 fntype
= no
->func_declaration_value()->type();
3225 // Builtin functions cannot be used as function values for variable
3227 if (fntype
->is_builtin())
3229 go_error_at(init
->location(),
3230 "invalid use of special builtin function %qs; "
3232 no
->message_name().c_str());
3236 && !var
->is_global()
3237 && !var
->is_parameter()
3238 && !var
->is_receiver()
3239 && !var
->type()->is_error()
3240 && (init
== NULL
|| !init
->is_error_expression())
3241 && !Lex::is_invalid_identifier(named_object
->name()))
3242 go_error_at(var
->location(), "%qs declared and not used",
3243 named_object
->message_name().c_str());
3245 return TRAVERSE_CONTINUE
;
3248 // Check that a constant initializer has the right type.
3251 Check_types_traverse::constant(Named_object
* named_object
, bool)
3253 Named_constant
* constant
= named_object
->const_value();
3254 Type
* ctype
= constant
->type();
3255 if (ctype
->integer_type() == NULL
3256 && ctype
->float_type() == NULL
3257 && ctype
->complex_type() == NULL
3258 && !ctype
->is_boolean_type()
3259 && !ctype
->is_string_type())
3261 if (ctype
->is_nil_type())
3262 go_error_at(constant
->location(), "const initializer cannot be nil");
3263 else if (!ctype
->is_error())
3264 go_error_at(constant
->location(), "invalid constant type");
3265 constant
->set_error();
3267 else if (!constant
->expr()->is_constant())
3269 go_error_at(constant
->expr()->location(), "expression is not constant");
3270 constant
->set_error();
3272 else if (!Type::are_assignable(constant
->type(), constant
->expr()->type(),
3275 go_error_at(constant
->location(),
3276 "initialization expression has wrong type");
3277 constant
->set_error();
3279 return TRAVERSE_CONTINUE
;
3282 // There are no types to check in a function, but this is where we
3283 // issue warnings about labels which are defined but not referenced.
3286 Check_types_traverse::function(Named_object
* no
)
3288 no
->func_value()->check_labels();
3289 return TRAVERSE_CONTINUE
;
3292 // Check that types are valid in a statement.
3295 Check_types_traverse::statement(Block
*, size_t*, Statement
* s
)
3297 s
->check_types(this->gogo_
);
3298 return TRAVERSE_CONTINUE
;
3301 // Check that types are valid in an expression.
3304 Check_types_traverse::expression(Expression
** expr
)
3306 (*expr
)->check_types(this->gogo_
);
3307 return TRAVERSE_CONTINUE
;
3310 // Check that types are valid.
3315 Check_types_traverse
traverse(this);
3316 this->traverse(&traverse
);
3318 Bindings
* bindings
= this->current_bindings();
3319 for (Bindings::const_declarations_iterator p
= bindings
->begin_declarations();
3320 p
!= bindings
->end_declarations();
3323 // Also check the types in a function declaration's signature.
3324 Named_object
* no
= p
->second
;
3325 if (no
->is_function_declaration())
3326 no
->func_declaration_value()->check_types();
3330 // Check the types in a single block.
3333 Gogo::check_types_in_block(Block
* block
)
3335 Check_types_traverse
traverse(this);
3336 block
->traverse(&traverse
);
3339 // A traversal class used to find a single shortcut operator within an
3342 class Find_shortcut
: public Traverse
3346 : Traverse(traverse_blocks
3347 | traverse_statements
3348 | traverse_expressions
),
3352 // A pointer to the expression which was found, or NULL if none was
3356 { return this->found_
; }
3361 { return TRAVERSE_SKIP_COMPONENTS
; }
3364 statement(Block
*, size_t*, Statement
*)
3365 { return TRAVERSE_SKIP_COMPONENTS
; }
3368 expression(Expression
**);
3371 Expression
** found_
;
3374 // Find a shortcut expression.
3377 Find_shortcut::expression(Expression
** pexpr
)
3379 Expression
* expr
= *pexpr
;
3380 Binary_expression
* be
= expr
->binary_expression();
3382 return TRAVERSE_CONTINUE
;
3383 Operator op
= be
->op();
3384 if (op
!= OPERATOR_OROR
&& op
!= OPERATOR_ANDAND
)
3385 return TRAVERSE_CONTINUE
;
3386 go_assert(this->found_
== NULL
);
3387 this->found_
= pexpr
;
3388 return TRAVERSE_EXIT
;
3391 // A traversal class used to turn shortcut operators into explicit if
3394 class Shortcuts
: public Traverse
3397 Shortcuts(Gogo
* gogo
)
3398 : Traverse(traverse_variables
3399 | traverse_statements
),
3405 variable(Named_object
*);
3408 statement(Block
*, size_t*, Statement
*);
3411 // Convert a shortcut operator.
3413 convert_shortcut(Block
* enclosing
, Expression
** pshortcut
);
3419 // Remove shortcut operators in a single statement.
3422 Shortcuts::statement(Block
* block
, size_t* pindex
, Statement
* s
)
3424 // FIXME: This approach doesn't work for switch statements, because
3425 // we add the new statements before the whole switch when we need to
3426 // instead add them just before the switch expression. The right
3427 // fix is probably to lower switch statements with nonconstant cases
3428 // to a series of conditionals.
3429 if (s
->switch_statement() != NULL
)
3430 return TRAVERSE_CONTINUE
;
3434 Find_shortcut find_shortcut
;
3436 // If S is a variable declaration, then ordinary traversal won't
3437 // do anything. We want to explicitly traverse the
3438 // initialization expression if there is one.
3439 Variable_declaration_statement
* vds
= s
->variable_declaration_statement();
3440 Expression
* init
= NULL
;
3442 s
->traverse_contents(&find_shortcut
);
3445 init
= vds
->var()->var_value()->init();
3447 return TRAVERSE_CONTINUE
;
3448 init
->traverse(&init
, &find_shortcut
);
3450 Expression
** pshortcut
= find_shortcut
.found();
3451 if (pshortcut
== NULL
)
3452 return TRAVERSE_CONTINUE
;
3454 Statement
* snew
= this->convert_shortcut(block
, pshortcut
);
3455 block
->insert_statement_before(*pindex
, snew
);
3458 if (pshortcut
== &init
)
3459 vds
->var()->var_value()->set_init(init
);
3463 // Remove shortcut operators in the initializer of a global variable.
3466 Shortcuts::variable(Named_object
* no
)
3468 if (no
->is_result_variable())
3469 return TRAVERSE_CONTINUE
;
3470 Variable
* var
= no
->var_value();
3471 Expression
* init
= var
->init();
3472 if (!var
->is_global() || init
== NULL
)
3473 return TRAVERSE_CONTINUE
;
3477 Find_shortcut find_shortcut
;
3478 init
->traverse(&init
, &find_shortcut
);
3479 Expression
** pshortcut
= find_shortcut
.found();
3480 if (pshortcut
== NULL
)
3481 return TRAVERSE_CONTINUE
;
3483 Statement
* snew
= this->convert_shortcut(NULL
, pshortcut
);
3484 var
->add_preinit_statement(this->gogo_
, snew
);
3485 if (pshortcut
== &init
)
3486 var
->set_init(init
);
3490 // Given an expression which uses a shortcut operator, return a
3491 // statement which implements it, and update *PSHORTCUT accordingly.
3494 Shortcuts::convert_shortcut(Block
* enclosing
, Expression
** pshortcut
)
3496 Binary_expression
* shortcut
= (*pshortcut
)->binary_expression();
3497 Expression
* left
= shortcut
->left();
3498 Expression
* right
= shortcut
->right();
3499 Location loc
= shortcut
->location();
3501 Block
* retblock
= new Block(enclosing
, loc
);
3502 retblock
->set_end_location(loc
);
3504 Temporary_statement
* ts
= Statement::make_temporary(shortcut
->type(),
3506 retblock
->add_statement(ts
);
3508 Block
* block
= new Block(retblock
, loc
);
3509 block
->set_end_location(loc
);
3510 Expression
* tmpref
= Expression::make_temporary_reference(ts
, loc
);
3511 Statement
* assign
= Statement::make_assignment(tmpref
, right
, loc
);
3512 block
->add_statement(assign
);
3514 Expression
* cond
= Expression::make_temporary_reference(ts
, loc
);
3515 if (shortcut
->binary_expression()->op() == OPERATOR_OROR
)
3516 cond
= Expression::make_unary(OPERATOR_NOT
, cond
, loc
);
3518 Statement
* if_statement
= Statement::make_if_statement(cond
, block
, NULL
,
3520 retblock
->add_statement(if_statement
);
3522 *pshortcut
= Expression::make_temporary_reference(ts
, loc
);
3526 // Now convert any shortcut operators in LEFT and RIGHT.
3527 Shortcuts
shortcuts(this->gogo_
);
3528 retblock
->traverse(&shortcuts
);
3530 return Statement::make_block_statement(retblock
, loc
);
3533 // Turn shortcut operators into explicit if statements. Doing this
3534 // considerably simplifies the order of evaluation rules.
3537 Gogo::remove_shortcuts()
3539 Shortcuts
shortcuts(this);
3540 this->traverse(&shortcuts
);
3543 // A traversal class which finds all the expressions which must be
3544 // evaluated in order within a statement or larger expression. This
3545 // is used to implement the rules about order of evaluation.
3547 class Find_eval_ordering
: public Traverse
3550 typedef std::vector
<Expression
**> Expression_pointers
;
3553 Find_eval_ordering()
3554 : Traverse(traverse_blocks
3555 | traverse_statements
3556 | traverse_expressions
),
3562 { return this->exprs_
.size(); }
3564 typedef Expression_pointers::const_iterator const_iterator
;
3568 { return this->exprs_
.begin(); }
3572 { return this->exprs_
.end(); }
3577 { return TRAVERSE_SKIP_COMPONENTS
; }
3580 statement(Block
*, size_t*, Statement
*)
3581 { return TRAVERSE_SKIP_COMPONENTS
; }
3584 expression(Expression
**);
3587 // A list of pointers to expressions with side-effects.
3588 Expression_pointers exprs_
;
3591 // If an expression must be evaluated in order, put it on the list.
3594 Find_eval_ordering::expression(Expression
** expression_pointer
)
3596 // We have to look at subexpressions before this one.
3597 if ((*expression_pointer
)->traverse_subexpressions(this) == TRAVERSE_EXIT
)
3598 return TRAVERSE_EXIT
;
3599 if ((*expression_pointer
)->must_eval_in_order())
3600 this->exprs_
.push_back(expression_pointer
);
3601 return TRAVERSE_SKIP_COMPONENTS
;
3604 // A traversal class for ordering evaluations.
3606 class Order_eval
: public Traverse
3609 Order_eval(Gogo
* gogo
)
3610 : Traverse(traverse_variables
3611 | traverse_statements
),
3616 variable(Named_object
*);
3619 statement(Block
*, size_t*, Statement
*);
3626 // Implement the order of evaluation rules for a statement.
3629 Order_eval::statement(Block
* block
, size_t* pindex
, Statement
* stmt
)
3631 // FIXME: This approach doesn't work for switch statements, because
3632 // we add the new statements before the whole switch when we need to
3633 // instead add them just before the switch expression. The right
3634 // fix is probably to lower switch statements with nonconstant cases
3635 // to a series of conditionals.
3636 if (stmt
->switch_statement() != NULL
)
3637 return TRAVERSE_CONTINUE
;
3639 Find_eval_ordering find_eval_ordering
;
3641 // If S is a variable declaration, then ordinary traversal won't do
3642 // anything. We want to explicitly traverse the initialization
3643 // expression if there is one.
3644 Variable_declaration_statement
* vds
= stmt
->variable_declaration_statement();
3645 Expression
* init
= NULL
;
3646 Expression
* orig_init
= NULL
;
3648 stmt
->traverse_contents(&find_eval_ordering
);
3651 init
= vds
->var()->var_value()->init();
3653 return TRAVERSE_CONTINUE
;
3656 // It might seem that this could be
3657 // init->traverse_subexpressions. Unfortunately that can fail
3660 // newvar, err := call(arg())
3661 // Here newvar will have an init of call result 0 of
3662 // call(arg()). If we only traverse subexpressions, we will
3663 // only find arg(), and we won't bother to move anything out.
3664 // Then we get to the assignment to err, we will traverse the
3665 // whole statement, and this time we will find both call() and
3666 // arg(), and so we will move them out. This will cause them to
3667 // be put into temporary variables before the assignment to err
3668 // but after the declaration of newvar. To avoid that problem,
3669 // we traverse the entire expression here.
3670 Expression::traverse(&init
, &find_eval_ordering
);
3673 size_t c
= find_eval_ordering
.size();
3675 return TRAVERSE_CONTINUE
;
3677 // If there is only one expression with a side-effect, we can
3678 // usually leave it in place.
3681 switch (stmt
->classification())
3683 case Statement::STATEMENT_ASSIGNMENT
:
3684 // For an assignment statement, we need to evaluate an
3685 // expression on the right hand side before we evaluate any
3686 // index expression on the left hand side, so for that case
3687 // we always move the expression. Otherwise we mishandle
3688 // m[0] = len(m) where m is a map.
3691 case Statement::STATEMENT_EXPRESSION
:
3693 // If this is a call statement that doesn't return any
3694 // values, it will not have been counted as a value to
3695 // move. We need to move any subexpressions in case they
3696 // are themselves call statements that require passing a
3698 Expression
* expr
= stmt
->expression_statement()->expr();
3699 if (expr
->call_expression() != NULL
3700 && expr
->call_expression()->result_count() == 0)
3702 return TRAVERSE_CONTINUE
;
3706 // We can leave the expression in place.
3707 return TRAVERSE_CONTINUE
;
3711 bool is_thunk
= stmt
->thunk_statement() != NULL
;
3712 Expression_statement
* es
= stmt
->expression_statement();
3713 for (Find_eval_ordering::const_iterator p
= find_eval_ordering
.begin();
3714 p
!= find_eval_ordering
.end();
3717 Expression
** pexpr
= *p
;
3719 // The last expression in a thunk will be the call passed to go
3720 // or defer, which we must not evaluate early.
3721 if (is_thunk
&& p
+ 1 == find_eval_ordering
.end())
3724 Location loc
= (*pexpr
)->location();
3726 if ((*pexpr
)->call_expression() == NULL
3727 || (*pexpr
)->call_expression()->result_count() < 2)
3729 Temporary_statement
* ts
= Statement::make_temporary(NULL
, *pexpr
,
3732 *pexpr
= Expression::make_temporary_reference(ts
, loc
);
3736 // A call expression which returns multiple results needs to
3737 // be handled specially. We can't create a temporary
3738 // because there is no type to give it. Any actual uses of
3739 // the values will be done via Call_result_expressions.
3741 // Since a given call expression can be shared by multiple
3742 // Call_result_expressions, avoid hoisting the call the
3743 // second time we see it here. In addition, don't try to
3744 // hoist the top-level multi-return call in the statement,
3745 // since doing this would result a tree with more than one copy
3747 if (this->remember_expression(*pexpr
))
3749 else if (es
!= NULL
&& *pexpr
== es
->expr())
3752 s
= Statement::make_statement(*pexpr
, true);
3757 block
->insert_statement_before(*pindex
, s
);
3762 if (init
!= orig_init
)
3763 vds
->var()->var_value()->set_init(init
);
3765 return TRAVERSE_CONTINUE
;
3768 // Implement the order of evaluation rules for the initializer of a
3772 Order_eval::variable(Named_object
* no
)
3774 if (no
->is_result_variable())
3775 return TRAVERSE_CONTINUE
;
3776 Variable
* var
= no
->var_value();
3777 Expression
* init
= var
->init();
3778 if (!var
->is_global() || init
== NULL
)
3779 return TRAVERSE_CONTINUE
;
3781 Find_eval_ordering find_eval_ordering
;
3782 Expression::traverse(&init
, &find_eval_ordering
);
3784 if (find_eval_ordering
.size() <= 1)
3786 // If there is only one expression with a side-effect, we can
3787 // leave it in place.
3788 return TRAVERSE_SKIP_COMPONENTS
;
3791 Expression
* orig_init
= init
;
3793 for (Find_eval_ordering::const_iterator p
= find_eval_ordering
.begin();
3794 p
!= find_eval_ordering
.end();
3797 Expression
** pexpr
= *p
;
3798 Location loc
= (*pexpr
)->location();
3800 if ((*pexpr
)->call_expression() == NULL
3801 || (*pexpr
)->call_expression()->result_count() < 2)
3803 Temporary_statement
* ts
= Statement::make_temporary(NULL
, *pexpr
,
3806 *pexpr
= Expression::make_temporary_reference(ts
, loc
);
3810 // A call expression which returns multiple results needs to
3811 // be handled specially.
3812 s
= Statement::make_statement(*pexpr
, true);
3814 var
->add_preinit_statement(this->gogo_
, s
);
3817 if (init
!= orig_init
)
3818 var
->set_init(init
);
3820 return TRAVERSE_SKIP_COMPONENTS
;
3823 // Use temporary variables to implement the order of evaluation rules.
3826 Gogo::order_evaluations()
3828 Order_eval
order_eval(this);
3829 this->traverse(&order_eval
);
3832 // Traversal to flatten parse tree after order of evaluation rules are applied.
3834 class Flatten
: public Traverse
3837 Flatten(Gogo
* gogo
, Named_object
* function
)
3838 : Traverse(traverse_variables
3839 | traverse_functions
3840 | traverse_statements
3841 | traverse_expressions
),
3842 gogo_(gogo
), function_(function
), inserter_()
3846 set_inserter(const Statement_inserter
* inserter
)
3847 { this->inserter_
= *inserter
; }
3850 variable(Named_object
*);
3853 function(Named_object
*);
3856 statement(Block
*, size_t* pindex
, Statement
*);
3859 expression(Expression
**);
3864 // The function we are traversing.
3865 Named_object
* function_
;
3866 // Current statement inserter for use by expressions.
3867 Statement_inserter inserter_
;
3870 // Flatten variables.
3873 Flatten::variable(Named_object
* no
)
3875 if (!no
->is_variable())
3876 return TRAVERSE_CONTINUE
;
3878 if (no
->is_variable() && no
->var_value()->is_global())
3880 // Global variables can have loops in their initialization
3881 // expressions. This is handled in flatten_init_expression.
3882 no
->var_value()->flatten_init_expression(this->gogo_
, this->function_
,
3884 return TRAVERSE_CONTINUE
;
3887 if (!no
->var_value()->is_parameter()
3888 && !no
->var_value()->is_receiver()
3889 && !no
->var_value()->is_closure()
3890 && no
->var_value()->is_non_escaping_address_taken()
3891 && !no
->var_value()->is_in_heap()
3892 && no
->var_value()->toplevel_decl() == NULL
)
3894 // Local variable that has address taken but not escape.
3895 // It needs to be live beyond its lexical scope. So we
3896 // create a top-level declaration for it.
3897 // No need to do it if it is already in the top level.
3898 Block
* top_block
= function_
->func_value()->block();
3899 if (top_block
->bindings()->lookup_local(no
->name()) != no
)
3901 Variable
* var
= no
->var_value();
3902 Temporary_statement
* ts
=
3903 Statement::make_temporary(var
->type(), NULL
, var
->location());
3904 ts
->set_is_address_taken();
3905 top_block
->add_statement_at_front(ts
);
3906 var
->set_toplevel_decl(ts
);
3910 go_assert(!no
->var_value()->has_pre_init());
3912 return TRAVERSE_SKIP_COMPONENTS
;
3915 // Flatten the body of a function. Record the function while flattening it,
3916 // so that we can pass it down when flattening an expression.
3919 Flatten::function(Named_object
* no
)
3921 go_assert(this->function_
== NULL
);
3922 this->function_
= no
;
3923 int t
= no
->func_value()->traverse(this);
3924 this->function_
= NULL
;
3926 if (t
== TRAVERSE_EXIT
)
3928 return TRAVERSE_SKIP_COMPONENTS
;
3931 // Flatten statement parse trees.
3934 Flatten::statement(Block
* block
, size_t* pindex
, Statement
* sorig
)
3936 // Because we explicitly traverse the statement's contents
3937 // ourselves, we want to skip block statements here. There is
3938 // nothing to flatten in a block statement.
3939 if (sorig
->is_block_statement())
3940 return TRAVERSE_CONTINUE
;
3942 Statement_inserter
hold_inserter(this->inserter_
);
3943 this->inserter_
= Statement_inserter(block
, pindex
);
3945 // Flatten the expressions first.
3946 int t
= sorig
->traverse_contents(this);
3947 if (t
== TRAVERSE_EXIT
)
3949 this->inserter_
= hold_inserter
;
3953 // Keep flattening until nothing changes.
3954 Statement
* s
= sorig
;
3957 Statement
* snew
= s
->flatten(this->gogo_
, this->function_
, block
,
3962 t
= s
->traverse_contents(this);
3963 if (t
== TRAVERSE_EXIT
)
3965 this->inserter_
= hold_inserter
;
3971 block
->replace_statement(*pindex
, s
);
3973 this->inserter_
= hold_inserter
;
3974 return TRAVERSE_SKIP_COMPONENTS
;
3977 // Flatten expression parse trees.
3980 Flatten::expression(Expression
** pexpr
)
3982 // Keep flattening until nothing changes.
3985 Expression
* e
= *pexpr
;
3986 if (e
->traverse_subexpressions(this) == TRAVERSE_EXIT
)
3987 return TRAVERSE_EXIT
;
3989 Expression
* enew
= e
->flatten(this->gogo_
, this->function_
,
3995 return TRAVERSE_SKIP_COMPONENTS
;
4001 Gogo::flatten_block(Named_object
* function
, Block
* block
)
4003 Flatten
flatten(this, function
);
4004 block
->traverse(&flatten
);
4007 // Flatten an expression. INSERTER may be NULL, in which case the
4008 // expression had better not need to create any temporaries.
4011 Gogo::flatten_expression(Named_object
* function
, Statement_inserter
* inserter
,
4014 Flatten
flatten(this, function
);
4015 if (inserter
!= NULL
)
4016 flatten
.set_inserter(inserter
);
4017 flatten
.expression(pexpr
);
4023 Flatten
flatten(this, NULL
);
4024 this->traverse(&flatten
);
4027 // Traversal to convert calls to the predeclared recover function to
4028 // pass in an argument indicating whether it can recover from a panic
4031 class Convert_recover
: public Traverse
4034 Convert_recover(Named_object
* arg
)
4035 : Traverse(traverse_expressions
),
4041 expression(Expression
**);
4044 // The argument to pass to the function.
4048 // Convert calls to recover.
4051 Convert_recover::expression(Expression
** pp
)
4053 Call_expression
* ce
= (*pp
)->call_expression();
4054 if (ce
!= NULL
&& ce
->is_recover_call())
4055 ce
->set_recover_arg(Expression::make_var_reference(this->arg_
,
4057 return TRAVERSE_CONTINUE
;
4060 // Traversal for build_recover_thunks.
4062 class Build_recover_thunks
: public Traverse
4065 Build_recover_thunks(Gogo
* gogo
)
4066 : Traverse(traverse_functions
),
4071 function(Named_object
*);
4075 can_recover_arg(Location
);
4081 // If this function calls recover, turn it into a thunk.
4084 Build_recover_thunks::function(Named_object
* orig_no
)
4086 Function
* orig_func
= orig_no
->func_value();
4087 if (!orig_func
->calls_recover()
4088 || orig_func
->is_recover_thunk()
4089 || orig_func
->has_recover_thunk())
4090 return TRAVERSE_CONTINUE
;
4092 Gogo
* gogo
= this->gogo_
;
4093 Location location
= orig_func
->location();
4098 Function_type
* orig_fntype
= orig_func
->type();
4099 Typed_identifier_list
* new_params
= new Typed_identifier_list();
4100 std::string receiver_name
;
4101 if (orig_fntype
->is_method())
4103 const Typed_identifier
* receiver
= orig_fntype
->receiver();
4104 snprintf(buf
, sizeof buf
, "rt.%u", count
);
4106 receiver_name
= buf
;
4107 new_params
->push_back(Typed_identifier(receiver_name
, receiver
->type(),
4108 receiver
->location()));
4110 const Typed_identifier_list
* orig_params
= orig_fntype
->parameters();
4111 if (orig_params
!= NULL
&& !orig_params
->empty())
4113 for (Typed_identifier_list::const_iterator p
= orig_params
->begin();
4114 p
!= orig_params
->end();
4117 snprintf(buf
, sizeof buf
, "pt.%u", count
);
4119 new_params
->push_back(Typed_identifier(buf
, p
->type(),
4123 snprintf(buf
, sizeof buf
, "pr.%u", count
);
4125 std::string can_recover_name
= buf
;
4126 new_params
->push_back(Typed_identifier(can_recover_name
,
4127 Type::lookup_bool_type(),
4128 orig_fntype
->location()));
4130 const Typed_identifier_list
* orig_results
= orig_fntype
->results();
4131 Typed_identifier_list
* new_results
;
4132 if (orig_results
== NULL
|| orig_results
->empty())
4136 new_results
= new Typed_identifier_list();
4137 for (Typed_identifier_list::const_iterator p
= orig_results
->begin();
4138 p
!= orig_results
->end();
4140 new_results
->push_back(Typed_identifier("", p
->type(), p
->location()));
4143 Function_type
*new_fntype
= Type::make_function_type(NULL
, new_params
,
4145 orig_fntype
->location());
4146 if (orig_fntype
->is_varargs())
4147 new_fntype
->set_is_varargs();
4150 if (orig_fntype
->is_method())
4151 rtype
= orig_fntype
->receiver()->type();
4152 std::string
name(gogo
->recover_thunk_name(orig_no
->name(), rtype
));
4153 Named_object
*new_no
= gogo
->start_function(name
, new_fntype
, false,
4155 Function
*new_func
= new_no
->func_value();
4156 if (orig_func
->enclosing() != NULL
)
4157 new_func
->set_enclosing(orig_func
->enclosing());
4159 // We build the code for the original function attached to the new
4160 // function, and then swap the original and new function bodies.
4161 // This means that existing references to the original function will
4162 // then refer to the new function. That makes this code a little
4163 // confusing, in that the reference to NEW_NO really refers to the
4164 // other function, not the one we are building.
4166 Expression
* closure
= NULL
;
4167 if (orig_func
->needs_closure())
4169 // For the new function we are creating, declare a new parameter
4170 // variable NEW_CLOSURE_NO and set it to be the closure variable
4171 // of the function. This will be set to the closure value
4172 // passed in by the caller. Then pass a reference to this
4173 // variable as the closure value when calling the original
4174 // function. In other words, simply pass the closure value
4175 // through the thunk we are creating.
4176 Named_object
* orig_closure_no
= orig_func
->closure_var();
4177 Variable
* orig_closure_var
= orig_closure_no
->var_value();
4178 Variable
* new_var
= new Variable(orig_closure_var
->type(), NULL
, false,
4179 false, false, location
);
4180 new_var
->set_is_closure();
4181 snprintf(buf
, sizeof buf
, "closure.%u", count
);
4183 Named_object
* new_closure_no
= Named_object::make_variable(buf
, NULL
,
4185 new_func
->set_closure_var(new_closure_no
);
4186 closure
= Expression::make_var_reference(new_closure_no
, location
);
4189 Expression
* fn
= Expression::make_func_reference(new_no
, closure
, location
);
4191 Expression_list
* args
= new Expression_list();
4192 if (new_params
!= NULL
)
4194 // Note that we skip the last parameter, which is the boolean
4195 // indicating whether recover can succed.
4196 for (Typed_identifier_list::const_iterator p
= new_params
->begin();
4197 p
+ 1 != new_params
->end();
4200 Named_object
* p_no
= gogo
->lookup(p
->name(), NULL
);
4201 go_assert(p_no
!= NULL
4202 && p_no
->is_variable()
4203 && p_no
->var_value()->is_parameter());
4204 args
->push_back(Expression::make_var_reference(p_no
, location
));
4207 args
->push_back(this->can_recover_arg(location
));
4209 gogo
->start_block(location
);
4211 Call_expression
* call
= Expression::make_call(fn
, args
, false, location
);
4213 // Any varargs call has already been lowered.
4214 call
->set_varargs_are_lowered();
4216 Statement
* s
= Statement::make_return_from_call(call
, location
);
4217 s
->determine_types();
4218 gogo
->add_statement(s
);
4220 Block
* b
= gogo
->finish_block(location
);
4222 gogo
->add_block(b
, location
);
4224 // Lower the call in case it returns multiple results.
4225 gogo
->lower_block(new_no
, b
);
4227 gogo
->finish_function(location
);
4229 // Swap the function bodies and types.
4230 new_func
->swap_for_recover(orig_func
);
4231 orig_func
->set_is_recover_thunk();
4232 new_func
->set_calls_recover();
4233 new_func
->set_has_recover_thunk();
4235 Bindings
* orig_bindings
= orig_func
->block()->bindings();
4236 Bindings
* new_bindings
= new_func
->block()->bindings();
4237 if (orig_fntype
->is_method())
4239 // We changed the receiver to be a regular parameter. We have
4240 // to update the binding accordingly in both functions.
4241 Named_object
* orig_rec_no
= orig_bindings
->lookup_local(receiver_name
);
4242 go_assert(orig_rec_no
!= NULL
4243 && orig_rec_no
->is_variable()
4244 && !orig_rec_no
->var_value()->is_receiver());
4245 orig_rec_no
->var_value()->set_is_receiver();
4247 std::string
new_receiver_name(orig_fntype
->receiver()->name());
4248 if (new_receiver_name
.empty())
4250 // Find the receiver. It was named "r.NNN" in
4251 // Gogo::start_function.
4252 for (Bindings::const_definitions_iterator p
=
4253 new_bindings
->begin_definitions();
4254 p
!= new_bindings
->end_definitions();
4257 const std::string
& pname((*p
)->name());
4258 if (pname
[0] == 'r' && pname
[1] == '.')
4260 new_receiver_name
= pname
;
4264 go_assert(!new_receiver_name
.empty());
4266 Named_object
* new_rec_no
= new_bindings
->lookup_local(new_receiver_name
);
4267 if (new_rec_no
== NULL
)
4268 go_assert(saw_errors());
4271 go_assert(new_rec_no
->is_variable()
4272 && new_rec_no
->var_value()->is_receiver());
4273 new_rec_no
->var_value()->set_is_not_receiver();
4277 // Because we flipped blocks but not types, the can_recover
4278 // parameter appears in the (now) old bindings as a parameter.
4279 // Change it to a local variable, whereupon it will be discarded.
4280 Named_object
* can_recover_no
= orig_bindings
->lookup_local(can_recover_name
);
4281 go_assert(can_recover_no
!= NULL
4282 && can_recover_no
->is_variable()
4283 && can_recover_no
->var_value()->is_parameter());
4284 orig_bindings
->remove_binding(can_recover_no
);
4286 // Add the can_recover argument to the (now) new bindings, and
4287 // attach it to any recover statements.
4288 Variable
* can_recover_var
= new Variable(Type::lookup_bool_type(), NULL
,
4289 false, true, false, location
);
4290 can_recover_no
= new_bindings
->add_variable(can_recover_name
, NULL
,
4292 Convert_recover
convert_recover(can_recover_no
);
4293 new_func
->traverse(&convert_recover
);
4295 // Update the function pointers in any named results.
4296 new_func
->update_result_variables();
4297 orig_func
->update_result_variables();
4299 return TRAVERSE_CONTINUE
;
4302 // Return the expression to pass for the .can_recover parameter to the
4303 // new function. This indicates whether a call to recover may return
4304 // non-nil. The expression is runtime.canrecover(__builtin_return_address()).
4307 Build_recover_thunks::can_recover_arg(Location location
)
4309 static Named_object
* builtin_return_address
;
4310 if (builtin_return_address
== NULL
)
4311 builtin_return_address
=
4312 Gogo::declare_builtin_rf_address("__builtin_return_address");
4314 static Named_object
* can_recover
;
4315 if (can_recover
== NULL
)
4317 const Location bloc
= Linemap::predeclared_location();
4318 Typed_identifier_list
* param_types
= new Typed_identifier_list();
4319 Type
* voidptr_type
= Type::make_pointer_type(Type::make_void_type());
4320 param_types
->push_back(Typed_identifier("a", voidptr_type
, bloc
));
4321 Type
* boolean_type
= Type::lookup_bool_type();
4322 Typed_identifier_list
* results
= new Typed_identifier_list();
4323 results
->push_back(Typed_identifier("", boolean_type
, bloc
));
4324 Function_type
* fntype
= Type::make_function_type(NULL
, param_types
,
4327 Named_object::make_function_declaration("runtime_canrecover",
4328 NULL
, fntype
, bloc
);
4329 can_recover
->func_declaration_value()->set_asm_name("runtime.canrecover");
4332 Expression
* fn
= Expression::make_func_reference(builtin_return_address
,
4335 Expression
* zexpr
= Expression::make_integer_ul(0, NULL
, location
);
4336 Expression_list
*args
= new Expression_list();
4337 args
->push_back(zexpr
);
4339 Expression
* call
= Expression::make_call(fn
, args
, false, location
);
4341 args
= new Expression_list();
4342 args
->push_back(call
);
4344 fn
= Expression::make_func_reference(can_recover
, NULL
, location
);
4345 return Expression::make_call(fn
, args
, false, location
);
4348 // Build thunks for functions which call recover. We build a new
4349 // function with an extra parameter, which is whether a call to
4350 // recover can succeed. We then move the body of this function to
4351 // that one. We then turn this function into a thunk which calls the
4352 // new one, passing the value of runtime.canrecover(__builtin_return_address()).
4353 // The function will be marked as not splitting the stack. This will
4354 // cooperate with the implementation of defer to make recover do the
4358 Gogo::build_recover_thunks()
4360 Build_recover_thunks
build_recover_thunks(this);
4361 this->traverse(&build_recover_thunks
);
4364 // Return a declaration for __builtin_return_address or
4365 // __builtin_frame_address.
4368 Gogo::declare_builtin_rf_address(const char* name
)
4370 const Location bloc
= Linemap::predeclared_location();
4372 Typed_identifier_list
* param_types
= new Typed_identifier_list();
4373 Type
* uint32_type
= Type::lookup_integer_type("uint32");
4374 param_types
->push_back(Typed_identifier("l", uint32_type
, bloc
));
4376 Typed_identifier_list
* return_types
= new Typed_identifier_list();
4377 Type
* voidptr_type
= Type::make_pointer_type(Type::make_void_type());
4378 return_types
->push_back(Typed_identifier("", voidptr_type
, bloc
));
4380 Function_type
* fntype
= Type::make_function_type(NULL
, param_types
,
4381 return_types
, bloc
);
4382 Named_object
* ret
= Named_object::make_function_declaration(name
, NULL
,
4384 ret
->func_declaration_value()->set_asm_name(name
);
4388 // Build a call to the runtime error function.
4391 Gogo::runtime_error(int code
, Location location
)
4393 Type
* int32_type
= Type::lookup_integer_type("int32");
4394 Expression
* code_expr
= Expression::make_integer_ul(code
, int32_type
,
4396 return Runtime::make_call(Runtime::RUNTIME_ERROR
, location
, 1, code_expr
);
4399 // Look for named types to see whether we need to create an interface
4402 class Build_method_tables
: public Traverse
4405 Build_method_tables(Gogo
* gogo
,
4406 const std::vector
<Interface_type
*>& interfaces
)
4407 : Traverse(traverse_types
),
4408 gogo_(gogo
), interfaces_(interfaces
)
4417 // A list of locally defined interfaces which have hidden methods.
4418 const std::vector
<Interface_type
*>& interfaces_
;
4421 // Build all required interface method tables for types. We need to
4422 // ensure that we have an interface method table for every interface
4423 // which has a hidden method, for every named type which implements
4424 // that interface. Normally we can just build interface method tables
4425 // as we need them. However, in some cases we can require an
4426 // interface method table for an interface defined in a different
4427 // package for a type defined in that package. If that interface and
4428 // type both use a hidden method, that is OK. However, we will not be
4429 // able to build that interface method table when we need it, because
4430 // the type's hidden method will be static. So we have to build it
4431 // here, and just refer it from other packages as needed.
4434 Gogo::build_interface_method_tables()
4439 std::vector
<Interface_type
*> hidden_interfaces
;
4440 hidden_interfaces
.reserve(this->interface_types_
.size());
4441 for (std::vector
<Interface_type
*>::const_iterator pi
=
4442 this->interface_types_
.begin();
4443 pi
!= this->interface_types_
.end();
4446 const Typed_identifier_list
* methods
= (*pi
)->methods();
4447 if (methods
== NULL
)
4449 for (Typed_identifier_list::const_iterator pm
= methods
->begin();
4450 pm
!= methods
->end();
4453 if (Gogo::is_hidden_name(pm
->name()))
4455 hidden_interfaces
.push_back(*pi
);
4461 if (!hidden_interfaces
.empty())
4463 // Now traverse the tree looking for all named types.
4464 Build_method_tables
bmt(this, hidden_interfaces
);
4465 this->traverse(&bmt
);
4468 // We no longer need the list of interfaces.
4470 this->interface_types_
.clear();
4473 // This is called for each type. For a named type, for each of the
4474 // interfaces with hidden methods that it implements, create the
4478 Build_method_tables::type(Type
* type
)
4480 Named_type
* nt
= type
->named_type();
4481 Struct_type
* st
= type
->struct_type();
4482 if (nt
!= NULL
|| st
!= NULL
)
4484 Translate_context
context(this->gogo_
, NULL
, NULL
, NULL
);
4485 for (std::vector
<Interface_type
*>::const_iterator p
=
4486 this->interfaces_
.begin();
4487 p
!= this->interfaces_
.end();
4490 // We ask whether a pointer to the named type implements the
4491 // interface, because a pointer can implement more methods
4495 if ((*p
)->implements_interface(Type::make_pointer_type(nt
),
4498 nt
->interface_method_table(*p
, false)->get_backend(&context
);
4499 nt
->interface_method_table(*p
, true)->get_backend(&context
);
4504 if ((*p
)->implements_interface(Type::make_pointer_type(st
),
4507 st
->interface_method_table(*p
, false)->get_backend(&context
);
4508 st
->interface_method_table(*p
, true)->get_backend(&context
);
4513 return TRAVERSE_CONTINUE
;
4516 // Return an expression which allocates memory to hold values of type TYPE.
4519 Gogo::allocate_memory(Type
* type
, Location location
)
4521 Expression
* td
= Expression::make_type_descriptor(type
, location
);
4522 return Runtime::make_call(Runtime::NEW
, location
, 1, td
);
4525 // Traversal class used to check for return statements.
4527 class Check_return_statements_traverse
: public Traverse
4530 Check_return_statements_traverse()
4531 : Traverse(traverse_functions
)
4535 function(Named_object
*);
4538 // Check that a function has a return statement if it needs one.
4541 Check_return_statements_traverse::function(Named_object
* no
)
4543 Function
* func
= no
->func_value();
4544 const Function_type
* fntype
= func
->type();
4545 const Typed_identifier_list
* results
= fntype
->results();
4547 // We only need a return statement if there is a return value.
4548 if (results
== NULL
|| results
->empty())
4549 return TRAVERSE_CONTINUE
;
4551 if (func
->block()->may_fall_through())
4552 go_error_at(func
->block()->end_location(),
4553 "missing return at end of function");
4555 return TRAVERSE_CONTINUE
;
4558 // Check return statements.
4561 Gogo::check_return_statements()
4563 Check_return_statements_traverse traverse
;
4564 this->traverse(&traverse
);
4567 // Export identifiers as requested.
4572 // For now we always stream to a section. Later we may want to
4573 // support streaming to a separate file.
4574 Stream_to_section
stream(this->backend());
4576 // Write out either the prefix or pkgpath depending on how we were
4579 std::string pkgpath
;
4580 if (this->pkgpath_from_option_
)
4581 pkgpath
= this->pkgpath_
;
4582 else if (this->prefix_from_option_
)
4583 prefix
= this->prefix_
;
4584 else if (this->is_main_package())
4589 Export
exp(&stream
);
4590 exp
.register_builtin_types(this);
4591 exp
.export_globals(this->package_name(),
4596 (this->need_init_fn_
&& !this->is_main_package()
4597 ? this->get_init_fn_name()
4599 this->imported_init_fns_
,
4600 this->package_
->bindings());
4602 if (!this->c_header_
.empty() && !saw_errors())
4603 this->write_c_header();
4606 // Write the top level named struct types in C format to a C header
4607 // file. This is used when building the runtime package, to share
4608 // struct definitions between C and Go.
4611 Gogo::write_c_header()
4614 out
.open(this->c_header_
.c_str());
4617 go_error_at(Linemap::unknown_location(),
4618 "cannot open %s: %m", this->c_header_
.c_str());
4622 std::list
<Named_object
*> types
;
4623 Bindings
* top
= this->package_
->bindings();
4624 for (Bindings::const_definitions_iterator p
= top
->begin_definitions();
4625 p
!= top
->end_definitions();
4628 Named_object
* no
= *p
;
4630 // Skip names that start with underscore followed by something
4631 // other than an uppercase letter, as when compiling the runtime
4632 // package they are mostly types defined by mkrsysinfo.sh based
4633 // on the C system header files. We don't need to translate
4634 // types to C and back to Go. But do accept the special cases
4635 // _defer and _panic.
4636 std::string name
= Gogo::unpack_hidden_name(no
->name());
4638 && (name
[1] < 'A' || name
[1] > 'Z')
4639 && (name
!= "_defer" && name
!= "_panic"))
4642 if (no
->is_type() && no
->type_value()->struct_type() != NULL
)
4643 types
.push_back(no
);
4645 && no
->const_value()->type()->integer_type() != NULL
4646 && !no
->const_value()->is_sink())
4648 Numeric_constant nc
;
4650 if (no
->const_value()->expr()->numeric_constant_value(&nc
)
4651 && nc
.to_unsigned_long(&val
) == Numeric_constant::NC_UL_VALID
)
4653 out
<< "#define " << no
->message_name() << ' ' << val
4659 std::vector
<const Named_object
*> written
;
4661 while (!types
.empty())
4663 Named_object
* no
= types
.front();
4666 std::vector
<const Named_object
*> requires
;
4667 std::vector
<const Named_object
*> declare
;
4668 if (!no
->type_value()->struct_type()->can_write_to_c_header(&requires
,
4673 for (std::vector
<const Named_object
*>::const_iterator pr
4675 pr
!= requires
.end() && ok
;
4678 for (std::list
<Named_object
*>::const_iterator pt
= types
.begin();
4679 pt
!= types
.end() && ok
;
4689 // This should be impossible since the code parsed and
4694 types
.push_back(no
);
4698 for (std::vector
<const Named_object
*>::const_iterator pd
4700 pd
!= declare
.end();
4706 std::vector
<const Named_object
*> drequires
;
4707 std::vector
<const Named_object
*> ddeclare
;
4708 if (!(*pd
)->type_value()->struct_type()->
4709 can_write_to_c_header(&drequires
, &ddeclare
))
4713 for (std::vector
<const Named_object
*>::const_iterator pw
4715 pw
!= written
.end();
4727 out
<< "struct " << (*pd
)->message_name() << ";" << std::endl
;
4728 written
.push_back(*pd
);
4733 out
<< "struct " << no
->message_name() << " {" << std::endl
;
4734 no
->type_value()->struct_type()->write_to_c_header(out
);
4735 out
<< "};" << std::endl
;
4736 written
.push_back(no
);
4741 go_error_at(Linemap::unknown_location(),
4742 "error writing to %s: %m", this->c_header_
.c_str());
4745 // Find the blocks in order to convert named types defined in blocks.
4747 class Convert_named_types
: public Traverse
4750 Convert_named_types(Gogo
* gogo
)
4751 : Traverse(traverse_blocks
),
4757 block(Block
* block
);
4764 Convert_named_types::block(Block
* block
)
4766 this->gogo_
->convert_named_types_in_bindings(block
->bindings());
4767 return TRAVERSE_CONTINUE
;
4770 // Convert all named types to the backend representation. Since named
4771 // types can refer to other types, this needs to be done in the right
4772 // sequence, which is handled by Named_type::convert. Here we arrange
4773 // to call that for each named type.
4776 Gogo::convert_named_types()
4778 this->convert_named_types_in_bindings(this->globals_
);
4779 for (Packages::iterator p
= this->packages_
.begin();
4780 p
!= this->packages_
.end();
4783 Package
* package
= p
->second
;
4784 this->convert_named_types_in_bindings(package
->bindings());
4787 Convert_named_types
cnt(this);
4788 this->traverse(&cnt
);
4790 // Make all the builtin named types used for type descriptors, and
4791 // then convert them. They will only be written out if they are
4793 Type::make_type_descriptor_type();
4794 Type::make_type_descriptor_ptr_type();
4795 Function_type::make_function_type_descriptor_type();
4796 Pointer_type::make_pointer_type_descriptor_type();
4797 Struct_type::make_struct_type_descriptor_type();
4798 Array_type::make_array_type_descriptor_type();
4799 Array_type::make_slice_type_descriptor_type();
4800 Map_type::make_map_type_descriptor_type();
4801 Channel_type::make_chan_type_descriptor_type();
4802 Interface_type::make_interface_type_descriptor_type();
4803 Expression::make_func_descriptor_type();
4804 Type::convert_builtin_named_types(this);
4806 Runtime::convert_types(this);
4808 this->named_types_are_converted_
= true;
4810 Type::finish_pointer_types(this);
4813 // Convert all names types in a set of bindings.
4816 Gogo::convert_named_types_in_bindings(Bindings
* bindings
)
4818 for (Bindings::const_definitions_iterator p
= bindings
->begin_definitions();
4819 p
!= bindings
->end_definitions();
4822 if ((*p
)->is_type())
4823 (*p
)->type_value()->convert(this);
4829 Function::Function(Function_type
* type
, Named_object
* enclosing
, Block
* block
,
4831 : type_(type
), enclosing_(enclosing
), results_(NULL
),
4832 closure_var_(NULL
), block_(block
), location_(location
), labels_(),
4833 local_type_count_(0), descriptor_(NULL
), fndecl_(NULL
), defer_stack_(NULL
),
4834 pragmas_(0), nested_functions_(0), is_sink_(false),
4835 results_are_named_(false), is_unnamed_type_stub_method_(false),
4836 calls_recover_(false), is_recover_thunk_(false), has_recover_thunk_(false),
4837 calls_defer_retaddr_(false), is_type_specific_function_(false),
4838 in_unique_section_(false)
4842 // Create the named result variables.
4845 Function::create_result_variables(Gogo
* gogo
)
4847 const Typed_identifier_list
* results
= this->type_
->results();
4848 if (results
== NULL
|| results
->empty())
4851 if (!results
->front().name().empty())
4852 this->results_are_named_
= true;
4854 this->results_
= new Results();
4855 this->results_
->reserve(results
->size());
4857 Block
* block
= this->block_
;
4859 for (Typed_identifier_list::const_iterator p
= results
->begin();
4860 p
!= results
->end();
4863 std::string name
= p
->name();
4864 if (name
.empty() || Gogo::is_sink_name(name
))
4866 static int result_counter
;
4868 snprintf(buf
, sizeof buf
, "$ret%d", result_counter
);
4870 name
= gogo
->pack_hidden_name(buf
, false);
4872 Result_variable
* result
= new Result_variable(p
->type(), this, index
,
4874 Named_object
* no
= block
->bindings()->add_result_variable(name
, result
);
4875 if (no
->is_result_variable())
4876 this->results_
->push_back(no
);
4879 static int dummy_result_count
;
4881 snprintf(buf
, sizeof buf
, "$dret%d", dummy_result_count
);
4882 ++dummy_result_count
;
4883 name
= gogo
->pack_hidden_name(buf
, false);
4884 no
= block
->bindings()->add_result_variable(name
, result
);
4885 go_assert(no
->is_result_variable());
4886 this->results_
->push_back(no
);
4891 // Update the named result variables when cloning a function which
4895 Function::update_result_variables()
4897 if (this->results_
== NULL
)
4900 for (Results::iterator p
= this->results_
->begin();
4901 p
!= this->results_
->end();
4903 (*p
)->result_var_value()->set_function(this);
4906 // Whether this method should not be included in the type descriptor.
4909 Function::nointerface() const
4911 go_assert(this->is_method());
4912 return (this->pragmas_
& GOPRAGMA_NOINTERFACE
) != 0;
4915 // Record that this method should not be included in the type
4919 Function::set_nointerface()
4921 this->pragmas_
|= GOPRAGMA_NOINTERFACE
;
4924 // Return the closure variable, creating it if necessary.
4927 Function::closure_var()
4929 if (this->closure_var_
== NULL
)
4931 go_assert(this->descriptor_
== NULL
);
4932 // We don't know the type of the variable yet. We add fields as
4934 Location loc
= this->type_
->location();
4935 Struct_field_list
* sfl
= new Struct_field_list
;
4936 Struct_type
* struct_type
= Type::make_struct_type(sfl
, loc
);
4937 struct_type
->set_is_struct_incomparable();
4938 Variable
* var
= new Variable(Type::make_pointer_type(struct_type
),
4939 NULL
, false, false, false, loc
);
4941 var
->set_is_closure();
4942 this->closure_var_
= Named_object::make_variable("$closure", NULL
, var
);
4943 // Note that the new variable is not in any binding contour.
4945 return this->closure_var_
;
4948 // Set the type of the closure variable.
4951 Function::set_closure_type()
4953 if (this->closure_var_
== NULL
)
4955 Named_object
* closure
= this->closure_var_
;
4956 Struct_type
* st
= closure
->var_value()->type()->deref()->struct_type();
4958 // The first field of a closure is always a pointer to the function
4960 Type
* voidptr_type
= Type::make_pointer_type(Type::make_void_type());
4961 st
->push_field(Struct_field(Typed_identifier(".f", voidptr_type
,
4964 unsigned int index
= 1;
4965 for (Closure_fields::const_iterator p
= this->closure_fields_
.begin();
4966 p
!= this->closure_fields_
.end();
4969 Named_object
* no
= p
->first
;
4971 snprintf(buf
, sizeof buf
, "%u", index
);
4972 std::string n
= no
->name() + buf
;
4974 if (no
->is_variable())
4975 var_type
= no
->var_value()->type();
4977 var_type
= no
->result_var_value()->type();
4978 Type
* field_type
= Type::make_pointer_type(var_type
);
4979 st
->push_field(Struct_field(Typed_identifier(n
, field_type
, p
->second
)));
4983 // Return whether this function is a method.
4986 Function::is_method() const
4988 return this->type_
->is_method();
4991 // Add a label definition.
4994 Function::add_label_definition(Gogo
* gogo
, const std::string
& label_name
,
4997 Label
* lnull
= NULL
;
4998 std::pair
<Labels::iterator
, bool> ins
=
4999 this->labels_
.insert(std::make_pair(label_name
, lnull
));
5001 if (label_name
== "_")
5003 label
= Label::create_dummy_label();
5005 ins
.first
->second
= label
;
5007 else if (ins
.second
)
5009 // This is a new label.
5010 label
= new Label(label_name
);
5011 ins
.first
->second
= label
;
5015 // The label was already in the hash table.
5016 label
= ins
.first
->second
;
5017 if (label
->is_defined())
5019 go_error_at(location
, "label %qs already defined",
5020 Gogo::message_name(label_name
).c_str());
5021 go_inform(label
->location(), "previous definition of %qs was here",
5022 Gogo::message_name(label_name
).c_str());
5023 return new Label(label_name
);
5027 label
->define(location
, gogo
->bindings_snapshot(location
));
5029 // Issue any errors appropriate for any previous goto's to this
5031 const std::vector
<Bindings_snapshot
*>& refs(label
->refs());
5032 for (std::vector
<Bindings_snapshot
*>::const_iterator p
= refs
.begin();
5035 (*p
)->check_goto_to(gogo
->current_block());
5036 label
->clear_refs();
5041 // Add a reference to a label.
5044 Function::add_label_reference(Gogo
* gogo
, const std::string
& label_name
,
5045 Location location
, bool issue_goto_errors
)
5047 Label
* lnull
= NULL
;
5048 std::pair
<Labels::iterator
, bool> ins
=
5049 this->labels_
.insert(std::make_pair(label_name
, lnull
));
5053 // The label was already in the hash table.
5054 label
= ins
.first
->second
;
5058 go_assert(ins
.first
->second
== NULL
);
5059 label
= new Label(label_name
);
5060 ins
.first
->second
= label
;
5063 label
->set_is_used();
5065 if (issue_goto_errors
)
5067 Bindings_snapshot
* snapshot
= label
->snapshot();
5068 if (snapshot
!= NULL
)
5069 snapshot
->check_goto_from(gogo
->current_block(), location
);
5071 label
->add_snapshot_ref(gogo
->bindings_snapshot(location
));
5077 // Warn about labels that are defined but not used.
5080 Function::check_labels() const
5082 for (Labels::const_iterator p
= this->labels_
.begin();
5083 p
!= this->labels_
.end();
5086 Label
* label
= p
->second
;
5087 if (!label
->is_used())
5088 go_error_at(label
->location(), "label %qs defined and not used",
5089 Gogo::message_name(label
->name()).c_str());
5093 // Swap one function with another. This is used when building the
5094 // thunk we use to call a function which calls recover. It may not
5095 // work for any other case.
5098 Function::swap_for_recover(Function
*x
)
5100 go_assert(this->enclosing_
== x
->enclosing_
);
5101 std::swap(this->results_
, x
->results_
);
5102 std::swap(this->closure_var_
, x
->closure_var_
);
5103 std::swap(this->block_
, x
->block_
);
5104 go_assert(this->location_
== x
->location_
);
5105 go_assert(this->fndecl_
== NULL
&& x
->fndecl_
== NULL
);
5106 go_assert(this->defer_stack_
== NULL
&& x
->defer_stack_
== NULL
);
5109 // Traverse the tree.
5112 Function::traverse(Traverse
* traverse
)
5114 unsigned int traverse_mask
= traverse
->traverse_mask();
5117 & (Traverse::traverse_types
| Traverse::traverse_expressions
))
5120 if (Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
5121 return TRAVERSE_EXIT
;
5124 // FIXME: We should check traverse_functions here if nested
5125 // functions are stored in block bindings.
5126 if (this->block_
!= NULL
5128 & (Traverse::traverse_variables
5129 | Traverse::traverse_constants
5130 | Traverse::traverse_blocks
5131 | Traverse::traverse_statements
5132 | Traverse::traverse_expressions
5133 | Traverse::traverse_types
)) != 0)
5135 if (this->block_
->traverse(traverse
) == TRAVERSE_EXIT
)
5136 return TRAVERSE_EXIT
;
5139 return TRAVERSE_CONTINUE
;
5142 // Work out types for unspecified variables and constants.
5145 Function::determine_types()
5147 if (this->block_
!= NULL
)
5148 this->block_
->determine_types();
5151 // Return the function descriptor, the value you get when you refer to
5152 // the function in Go code without calling it.
5155 Function::descriptor(Gogo
*, Named_object
* no
)
5157 go_assert(!this->is_method());
5158 go_assert(this->closure_var_
== NULL
);
5159 if (this->descriptor_
== NULL
)
5160 this->descriptor_
= Expression::make_func_descriptor(no
);
5161 return this->descriptor_
;
5164 // Get a pointer to the variable representing the defer stack for this
5165 // function, making it if necessary. The value of the variable is set
5166 // by the runtime routines to true if the function is returning,
5167 // rather than panicing through. A pointer to this variable is used
5168 // as a marker for the functions on the defer stack associated with
5169 // this function. A function-specific variable permits inlining a
5170 // function which uses defer.
5173 Function::defer_stack(Location location
)
5175 if (this->defer_stack_
== NULL
)
5177 Type
* t
= Type::lookup_bool_type();
5178 Expression
* n
= Expression::make_boolean(false, location
);
5179 this->defer_stack_
= Statement::make_temporary(t
, n
, location
);
5180 this->defer_stack_
->set_is_address_taken();
5182 Expression
* ref
= Expression::make_temporary_reference(this->defer_stack_
,
5184 return Expression::make_unary(OPERATOR_AND
, ref
, location
);
5187 // Export the function.
5190 Function::export_func(Export
* exp
, const std::string
& name
) const
5192 Function::export_func_with_type(exp
, name
, this->type_
,
5193 this->is_method() && this->nointerface());
5196 // Export a function with a type.
5199 Function::export_func_with_type(Export
* exp
, const std::string
& name
,
5200 const Function_type
* fntype
, bool nointerface
)
5202 exp
->write_c_string("func ");
5206 go_assert(fntype
->is_method());
5207 exp
->write_c_string("/*nointerface*/ ");
5210 if (fntype
->is_method())
5212 exp
->write_c_string("(");
5213 const Typed_identifier
* receiver
= fntype
->receiver();
5214 exp
->write_name(receiver
->name());
5215 exp
->write_escape(receiver
->note());
5216 exp
->write_c_string(" ");
5217 exp
->write_type(receiver
->type());
5218 exp
->write_c_string(") ");
5221 exp
->write_string(name
);
5223 exp
->write_c_string(" (");
5224 const Typed_identifier_list
* parameters
= fntype
->parameters();
5225 if (parameters
!= NULL
)
5228 bool is_varargs
= fntype
->is_varargs();
5230 for (Typed_identifier_list::const_iterator p
= parameters
->begin();
5231 p
!= parameters
->end();
5237 exp
->write_c_string(", ");
5238 exp
->write_name(p
->name());
5239 exp
->write_escape(p
->note());
5240 exp
->write_c_string(" ");
5241 if (!is_varargs
|| p
+ 1 != parameters
->end())
5242 exp
->write_type(p
->type());
5245 exp
->write_c_string("...");
5246 exp
->write_type(p
->type()->array_type()->element_type());
5250 exp
->write_c_string(")");
5252 const Typed_identifier_list
* results
= fntype
->results();
5253 if (results
!= NULL
)
5255 if (results
->size() == 1 && results
->begin()->name().empty())
5257 exp
->write_c_string(" ");
5258 exp
->write_type(results
->begin()->type());
5262 exp
->write_c_string(" (");
5264 for (Typed_identifier_list::const_iterator p
= results
->begin();
5265 p
!= results
->end();
5271 exp
->write_c_string(", ");
5272 exp
->write_name(p
->name());
5273 exp
->write_escape(p
->note());
5274 exp
->write_c_string(" ");
5275 exp
->write_type(p
->type());
5277 exp
->write_c_string(")");
5280 exp
->write_c_string(";\n");
5283 // Import a function.
5286 Function::import_func(Import
* imp
, std::string
* pname
,
5287 Typed_identifier
** preceiver
,
5288 Typed_identifier_list
** pparameters
,
5289 Typed_identifier_list
** presults
,
5293 imp
->require_c_string("func ");
5295 *nointerface
= false;
5296 if (imp
->match_c_string("/*"))
5298 imp
->require_c_string("/*nointerface*/ ");
5299 *nointerface
= true;
5301 // Only a method can be nointerface.
5302 go_assert(imp
->peek_char() == '(');
5306 if (imp
->peek_char() == '(')
5308 imp
->require_c_string("(");
5309 std::string name
= imp
->read_name();
5310 std::string escape_note
= imp
->read_escape();
5311 imp
->require_c_string(" ");
5312 Type
* rtype
= imp
->read_type();
5313 *preceiver
= new Typed_identifier(name
, rtype
, imp
->location());
5314 (*preceiver
)->set_note(escape_note
);
5315 imp
->require_c_string(") ");
5318 *pname
= imp
->read_identifier();
5320 Typed_identifier_list
* parameters
;
5321 *is_varargs
= false;
5322 imp
->require_c_string(" (");
5323 if (imp
->peek_char() == ')')
5327 parameters
= new Typed_identifier_list();
5330 std::string name
= imp
->read_name();
5331 std::string escape_note
= imp
->read_escape();
5332 imp
->require_c_string(" ");
5334 if (imp
->match_c_string("..."))
5340 Type
* ptype
= imp
->read_type();
5342 ptype
= Type::make_array_type(ptype
, NULL
);
5343 Typed_identifier t
= Typed_identifier(name
, ptype
, imp
->location());
5344 t
.set_note(escape_note
);
5345 parameters
->push_back(t
);
5346 if (imp
->peek_char() != ',')
5348 go_assert(!*is_varargs
);
5349 imp
->require_c_string(", ");
5352 imp
->require_c_string(")");
5353 *pparameters
= parameters
;
5355 Typed_identifier_list
* results
;
5356 if (imp
->peek_char() != ' ')
5360 results
= new Typed_identifier_list();
5361 imp
->require_c_string(" ");
5362 if (imp
->peek_char() != '(')
5364 Type
* rtype
= imp
->read_type();
5365 results
->push_back(Typed_identifier("", rtype
, imp
->location()));
5369 imp
->require_c_string("(");
5372 std::string name
= imp
->read_name();
5373 std::string note
= imp
->read_escape();
5374 imp
->require_c_string(" ");
5375 Type
* rtype
= imp
->read_type();
5376 Typed_identifier t
= Typed_identifier(name
, rtype
,
5379 results
->push_back(t
);
5380 if (imp
->peek_char() != ',')
5382 imp
->require_c_string(", ");
5384 imp
->require_c_string(")");
5387 imp
->require_c_string(";\n");
5388 *presults
= results
;
5391 // Get the backend representation.
5394 Function::get_or_make_decl(Gogo
* gogo
, Named_object
* no
)
5396 if (this->fndecl_
== NULL
)
5398 bool is_visible
= false;
5399 bool is_init_fn
= false;
5401 if (no
->package() != NULL
)
5403 else if (this->enclosing_
!= NULL
|| Gogo::is_thunk(no
))
5405 else if (Gogo::unpack_hidden_name(no
->name()) == "init"
5406 && !this->type_
->is_method())
5408 else if (no
->name() == gogo
->get_init_fn_name())
5413 else if (Gogo::unpack_hidden_name(no
->name()) == "main"
5414 && gogo
->is_main_package())
5416 // Methods have to be public even if they are hidden because
5417 // they can be pulled into type descriptors when using
5418 // anonymous fields.
5419 else if (!Gogo::is_hidden_name(no
->name())
5420 || this->type_
->is_method())
5422 if (!this->is_unnamed_type_stub_method_
)
5424 if (this->type_
->is_method())
5425 rtype
= this->type_
->receiver()->type();
5428 std::string asm_name
;
5429 if (!this->asm_name_
.empty())
5431 asm_name
= this->asm_name_
;
5433 // If an assembler name is explicitly specified, there must
5434 // be some reason to refer to the symbol from a different
5438 else if (is_init_fn
)
5440 // These names appear in the export data and are used
5441 // directly in the assembler code. If we change this here
5442 // we need to change Gogo::init_imports.
5443 asm_name
= no
->name();
5446 asm_name
= gogo
->function_asm_name(no
->name(), NULL
, rtype
);
5448 // If a function calls the predeclared recover function, we
5449 // can't inline it, because recover behaves differently in a
5450 // function passed directly to defer. If this is a recover
5451 // thunk that we built to test whether a function can be
5452 // recovered, we can't inline it, because that will mess up
5453 // our return address comparison.
5454 bool is_inlinable
= !(this->calls_recover_
|| this->is_recover_thunk_
);
5456 // If a function calls __go_set_defer_retaddr, then mark it as
5457 // uninlinable. This prevents the GCC backend from splitting
5458 // the function; splitting the function is a bad idea because we
5459 // want the return address label to be in the same function as
5461 if (this->calls_defer_retaddr_
)
5462 is_inlinable
= false;
5464 // Check the //go:noinline compiler directive.
5465 if ((this->pragmas_
& GOPRAGMA_NOINLINE
) != 0)
5466 is_inlinable
= false;
5468 // If this is a thunk created to call a function which calls
5469 // the predeclared recover function, we need to disable
5470 // stack splitting for the thunk.
5471 bool disable_split_stack
= this->is_recover_thunk_
;
5473 // Check the //go:nosplit compiler directive.
5474 if ((this->pragmas_
& GOPRAGMA_NOSPLIT
) != 0)
5475 disable_split_stack
= true;
5477 // This should go into a unique section if that has been
5478 // requested elsewhere, or if this is a nointerface function.
5479 // We want to put a nointerface function into a unique section
5480 // because there is a good chance that the linker garbage
5481 // collection can discard it.
5482 bool in_unique_section
= (this->in_unique_section_
5483 || (this->is_method() && this->nointerface()));
5485 Btype
* functype
= this->type_
->get_backend_fntype(gogo
);
5487 gogo
->backend()->function(functype
, no
->get_id(gogo
), asm_name
,
5488 is_visible
, false, is_inlinable
,
5489 disable_split_stack
, false,
5490 in_unique_section
, this->location());
5492 return this->fndecl_
;
5495 // Get the backend representation.
5498 Function_declaration::get_or_make_decl(Gogo
* gogo
, Named_object
* no
)
5500 if (this->fndecl_
== NULL
)
5502 bool does_not_return
= false;
5504 // Let Go code use an asm declaration to pick up a builtin
5506 if (!this->asm_name_
.empty())
5508 Bfunction
* builtin_decl
=
5509 gogo
->backend()->lookup_builtin(this->asm_name_
);
5510 if (builtin_decl
!= NULL
)
5512 this->fndecl_
= builtin_decl
;
5513 return this->fndecl_
;
5516 if (this->asm_name_
== "runtime.gopanic"
5517 || this->asm_name_
== "__go_runtime_error")
5518 does_not_return
= true;
5521 std::string asm_name
;
5522 if (this->asm_name_
.empty())
5525 if (this->fntype_
->is_method())
5526 rtype
= this->fntype_
->receiver()->type();
5527 asm_name
= gogo
->function_asm_name(no
->name(), no
->package(), rtype
);
5529 else if (go_id_needs_encoding(no
->get_id(gogo
)))
5530 asm_name
= go_encode_id(no
->get_id(gogo
));
5532 Btype
* functype
= this->fntype_
->get_backend_fntype(gogo
);
5534 gogo
->backend()->function(functype
, no
->get_id(gogo
), asm_name
,
5535 true, true, true, false, does_not_return
,
5536 false, this->location());
5539 return this->fndecl_
;
5542 // Build the descriptor for a function declaration. This won't
5543 // necessarily happen if the package has just a declaration for the
5544 // function and no other reference to it, but we may still need the
5545 // descriptor for references from other packages.
5547 Function_declaration::build_backend_descriptor(Gogo
* gogo
)
5549 if (this->descriptor_
!= NULL
)
5551 Translate_context
context(gogo
, NULL
, NULL
, NULL
);
5552 this->descriptor_
->get_backend(&context
);
5556 // Check that the types used in this declaration's signature are defined.
5557 // Reports errors for any undefined type.
5560 Function_declaration::check_types() const
5562 // Calling Type::base will give errors for any undefined types.
5563 Function_type
* fntype
= this->type();
5564 if (fntype
->receiver() != NULL
)
5565 fntype
->receiver()->type()->base();
5566 if (fntype
->parameters() != NULL
)
5568 const Typed_identifier_list
* params
= fntype
->parameters();
5569 for (Typed_identifier_list::const_iterator p
= params
->begin();
5576 // Return the function's decl after it has been built.
5579 Function::get_decl() const
5581 go_assert(this->fndecl_
!= NULL
);
5582 return this->fndecl_
;
5585 // Build the backend representation for the function code.
5588 Function::build(Gogo
* gogo
, Named_object
* named_function
)
5590 Translate_context
context(gogo
, named_function
, NULL
, NULL
);
5592 // A list of parameter variables for this function.
5593 std::vector
<Bvariable
*> param_vars
;
5595 // Variables that need to be declared for this function and their
5597 std::vector
<Bvariable
*> vars
;
5598 std::vector
<Bexpression
*> var_inits
;
5599 std::vector
<Statement
*> var_decls_stmts
;
5600 for (Bindings::const_definitions_iterator p
=
5601 this->block_
->bindings()->begin_definitions();
5602 p
!= this->block_
->bindings()->end_definitions();
5605 Location loc
= (*p
)->location();
5606 if ((*p
)->is_variable() && (*p
)->var_value()->is_parameter())
5608 Bvariable
* bvar
= (*p
)->get_backend_variable(gogo
, named_function
);
5609 Bvariable
* parm_bvar
= bvar
;
5611 // We always pass the receiver to a method as a pointer. If
5612 // the receiver is declared as a non-pointer type, then we
5613 // copy the value into a local variable.
5614 if ((*p
)->var_value()->is_receiver()
5615 && (*p
)->var_value()->type()->points_to() == NULL
)
5617 std::string name
= (*p
)->name() + ".pointer";
5618 Type
* var_type
= (*p
)->var_value()->type();
5619 Variable
* parm_var
=
5620 new Variable(Type::make_pointer_type(var_type
), NULL
, false,
5622 Named_object
* parm_no
=
5623 Named_object::make_variable(name
, NULL
, parm_var
);
5624 parm_bvar
= parm_no
->get_backend_variable(gogo
, named_function
);
5626 vars
.push_back(bvar
);
5627 Expression
* parm_ref
=
5628 Expression::make_var_reference(parm_no
, loc
);
5630 Expression::make_dereference(parm_ref
,
5631 Expression::NIL_CHECK_NEEDED
,
5633 if ((*p
)->var_value()->is_in_heap())
5634 parm_ref
= Expression::make_heap_expression(parm_ref
, loc
);
5635 var_inits
.push_back(parm_ref
->get_backend(&context
));
5637 else if ((*p
)->var_value()->is_in_heap())
5639 // If we take the address of a parameter, then we need
5640 // to copy it into the heap.
5641 std::string parm_name
= (*p
)->name() + ".param";
5642 Variable
* parm_var
= new Variable((*p
)->var_value()->type(), NULL
,
5643 false, true, false, loc
);
5644 Named_object
* parm_no
=
5645 Named_object::make_variable(parm_name
, NULL
, parm_var
);
5646 parm_bvar
= parm_no
->get_backend_variable(gogo
, named_function
);
5648 vars
.push_back(bvar
);
5649 Expression
* var_ref
=
5650 Expression::make_var_reference(parm_no
, loc
);
5651 var_ref
= Expression::make_heap_expression(var_ref
, loc
);
5652 var_inits
.push_back(var_ref
->get_backend(&context
));
5654 param_vars
.push_back(parm_bvar
);
5656 else if ((*p
)->is_result_variable())
5658 Bvariable
* bvar
= (*p
)->get_backend_variable(gogo
, named_function
);
5660 Type
* type
= (*p
)->result_var_value()->type();
5662 if (!(*p
)->result_var_value()->is_in_heap())
5664 Btype
* btype
= type
->get_backend(gogo
);
5665 init
= gogo
->backend()->zero_expression(btype
);
5668 init
= Expression::make_allocation(type
,
5669 loc
)->get_backend(&context
);
5671 vars
.push_back(bvar
);
5672 var_inits
.push_back(init
);
5674 else if (this->defer_stack_
!= NULL
5675 && (*p
)->is_variable()
5676 && (*p
)->var_value()->is_non_escaping_address_taken()
5677 && !(*p
)->var_value()->is_in_heap())
5679 // Local variable captured by deferred closure needs to be live
5680 // until the end of the function. We create a top-level
5681 // declaration for it.
5682 // TODO: we don't need to do this if the variable is not captured
5683 // by the defer closure. There is no easy way to check it here,
5684 // so we do this for all address-taken variables for now.
5685 Variable
* var
= (*p
)->var_value();
5686 Temporary_statement
* ts
=
5687 Statement::make_temporary(var
->type(), NULL
, var
->location());
5688 ts
->set_is_address_taken();
5689 var
->set_toplevel_decl(ts
);
5690 var_decls_stmts
.push_back(ts
);
5693 if (!gogo
->backend()->function_set_parameters(this->fndecl_
, param_vars
))
5695 go_assert(saw_errors());
5699 // If we need a closure variable, make sure to create it.
5700 // It gets installed in the function as a side effect of creation.
5701 if (this->closure_var_
!= NULL
)
5703 go_assert(this->closure_var_
->var_value()->is_closure());
5704 this->closure_var_
->get_backend_variable(gogo
, named_function
);
5707 if (this->block_
!= NULL
)
5709 // Declare variables if necessary.
5710 Bblock
* var_decls
= NULL
;
5711 std::vector
<Bstatement
*> var_decls_bstmt_list
;
5712 Bstatement
* defer_init
= NULL
;
5713 if (!vars
.empty() || this->defer_stack_
!= NULL
)
5716 gogo
->backend()->block(this->fndecl_
, NULL
, vars
,
5717 this->block_
->start_location(),
5718 this->block_
->end_location());
5720 if (this->defer_stack_
!= NULL
)
5722 Translate_context
dcontext(gogo
, named_function
, this->block_
,
5724 defer_init
= this->defer_stack_
->get_backend(&dcontext
);
5725 var_decls_bstmt_list
.push_back(defer_init
);
5726 for (std::vector
<Statement
*>::iterator p
= var_decls_stmts
.begin();
5727 p
!= var_decls_stmts
.end();
5730 Bstatement
* bstmt
= (*p
)->get_backend(&dcontext
);
5731 var_decls_bstmt_list
.push_back(bstmt
);
5736 // Build the backend representation for all the statements in the
5738 Translate_context
context(gogo
, named_function
, NULL
, NULL
);
5739 Bblock
* code_block
= this->block_
->get_backend(&context
);
5741 // Initialize variables if necessary.
5742 std::vector
<Bstatement
*> init
;
5743 go_assert(vars
.size() == var_inits
.size());
5744 for (size_t i
= 0; i
< vars
.size(); ++i
)
5746 Bstatement
* init_stmt
=
5747 gogo
->backend()->init_statement(this->fndecl_
, vars
[i
],
5749 init
.push_back(init_stmt
);
5751 Bstatement
* var_init
= gogo
->backend()->statement_list(init
);
5753 // Initialize all variables before executing this code block.
5754 Bstatement
* code_stmt
= gogo
->backend()->block_statement(code_block
);
5755 code_stmt
= gogo
->backend()->compound_statement(var_init
, code_stmt
);
5757 // If we have a defer stack, initialize it at the start of a
5759 Bstatement
* except
= NULL
;
5760 Bstatement
* fini
= NULL
;
5761 if (defer_init
!= NULL
)
5763 // Clean up the defer stack when we leave the function.
5764 this->build_defer_wrapper(gogo
, named_function
, &except
, &fini
);
5766 // Wrap the code for this function in an exception handler to handle
5769 gogo
->backend()->exception_handler_statement(code_stmt
,
5774 // Stick the code into the block we built for the receiver, if
5776 if (var_decls
!= NULL
)
5778 var_decls_bstmt_list
.push_back(code_stmt
);
5779 gogo
->backend()->block_add_statements(var_decls
, var_decls_bstmt_list
);
5780 code_stmt
= gogo
->backend()->block_statement(var_decls
);
5783 if (!gogo
->backend()->function_set_body(this->fndecl_
, code_stmt
))
5785 go_assert(saw_errors());
5790 // If we created a descriptor for the function, make sure we emit it.
5791 if (this->descriptor_
!= NULL
)
5793 Translate_context
context(gogo
, NULL
, NULL
, NULL
);
5794 this->descriptor_
->get_backend(&context
);
5798 // Build the wrappers around function code needed if the function has
5799 // any defer statements. This sets *EXCEPT to an exception handler
5800 // and *FINI to a finally handler.
5803 Function::build_defer_wrapper(Gogo
* gogo
, Named_object
* named_function
,
5804 Bstatement
** except
, Bstatement
** fini
)
5806 Location end_loc
= this->block_
->end_location();
5808 // Add an exception handler. This is used if a panic occurs. Its
5809 // purpose is to stop the stack unwinding if a deferred function
5810 // calls recover. There are more details in
5811 // libgo/runtime/go-unwind.c.
5813 std::vector
<Bstatement
*> stmts
;
5814 Expression
* call
= Runtime::make_call(Runtime::CHECKDEFER
, end_loc
, 1,
5815 this->defer_stack(end_loc
));
5816 Translate_context
context(gogo
, named_function
, NULL
, NULL
);
5817 Bexpression
* defer
= call
->get_backend(&context
);
5818 stmts
.push_back(gogo
->backend()->expression_statement(this->fndecl_
, defer
));
5820 Bstatement
* ret_bstmt
= this->return_value(gogo
, named_function
, end_loc
);
5821 if (ret_bstmt
!= NULL
)
5822 stmts
.push_back(ret_bstmt
);
5824 go_assert(*except
== NULL
);
5825 *except
= gogo
->backend()->statement_list(stmts
);
5827 call
= Runtime::make_call(Runtime::CHECKDEFER
, end_loc
, 1,
5828 this->defer_stack(end_loc
));
5829 defer
= call
->get_backend(&context
);
5831 call
= Runtime::make_call(Runtime::DEFERRETURN
, end_loc
, 1,
5832 this->defer_stack(end_loc
));
5833 Bexpression
* undefer
= call
->get_backend(&context
);
5834 Bstatement
* function_defer
=
5835 gogo
->backend()->function_defer_statement(this->fndecl_
, undefer
, defer
,
5837 stmts
= std::vector
<Bstatement
*>(1, function_defer
);
5838 if (this->type_
->results() != NULL
5839 && !this->type_
->results()->empty()
5840 && !this->type_
->results()->front().name().empty())
5842 // If the result variables are named, and we are returning from
5843 // this function rather than panicing through it, we need to
5844 // return them again, because they might have been changed by a
5845 // defer function. The runtime routines set the defer_stack
5846 // variable to true if we are returning from this function.
5848 ret_bstmt
= this->return_value(gogo
, named_function
, end_loc
);
5849 Bexpression
* nil
= Expression::make_nil(end_loc
)->get_backend(&context
);
5851 gogo
->backend()->compound_expression(ret_bstmt
, nil
, end_loc
);
5853 Expression::make_temporary_reference(this->defer_stack_
, end_loc
);
5854 Bexpression
* bref
= ref
->get_backend(&context
);
5855 ret
= gogo
->backend()->conditional_expression(this->fndecl_
,
5856 NULL
, bref
, ret
, NULL
,
5858 stmts
.push_back(gogo
->backend()->expression_statement(this->fndecl_
, ret
));
5861 go_assert(*fini
== NULL
);
5862 *fini
= gogo
->backend()->statement_list(stmts
);
5865 // Return the statement that assigns values to this function's result struct.
5868 Function::return_value(Gogo
* gogo
, Named_object
* named_function
,
5869 Location location
) const
5871 const Typed_identifier_list
* results
= this->type_
->results();
5872 if (results
== NULL
|| results
->empty())
5875 go_assert(this->results_
!= NULL
);
5876 if (this->results_
->size() != results
->size())
5878 go_assert(saw_errors());
5879 return gogo
->backend()->error_statement();
5882 std::vector
<Bexpression
*> vals(results
->size());
5883 for (size_t i
= 0; i
< vals
.size(); ++i
)
5885 Named_object
* no
= (*this->results_
)[i
];
5886 Bvariable
* bvar
= no
->get_backend_variable(gogo
, named_function
);
5887 Bexpression
* val
= gogo
->backend()->var_expression(bvar
, location
);
5888 if (no
->result_var_value()->is_in_heap())
5890 Btype
* bt
= no
->result_var_value()->type()->get_backend(gogo
);
5891 val
= gogo
->backend()->indirect_expression(bt
, val
, true, location
);
5895 return gogo
->backend()->return_statement(this->fndecl_
, vals
, location
);
5900 Block::Block(Block
* enclosing
, Location location
)
5901 : enclosing_(enclosing
), statements_(),
5902 bindings_(new Bindings(enclosing
== NULL
5904 : enclosing
->bindings())),
5905 start_location_(location
),
5906 end_location_(Linemap::unknown_location())
5910 // Add a statement to a block.
5913 Block::add_statement(Statement
* statement
)
5915 this->statements_
.push_back(statement
);
5918 // Add a statement to the front of a block. This is slow but is only
5919 // used for reference counts of parameters.
5922 Block::add_statement_at_front(Statement
* statement
)
5924 this->statements_
.insert(this->statements_
.begin(), statement
);
5927 // Replace a statement in a block.
5930 Block::replace_statement(size_t index
, Statement
* s
)
5932 go_assert(index
< this->statements_
.size());
5933 this->statements_
[index
] = s
;
5936 // Add a statement before another statement.
5939 Block::insert_statement_before(size_t index
, Statement
* s
)
5941 go_assert(index
< this->statements_
.size());
5942 this->statements_
.insert(this->statements_
.begin() + index
, s
);
5945 // Add a statement after another statement.
5948 Block::insert_statement_after(size_t index
, Statement
* s
)
5950 go_assert(index
< this->statements_
.size());
5951 this->statements_
.insert(this->statements_
.begin() + index
+ 1, s
);
5954 // Traverse the tree.
5957 Block::traverse(Traverse
* traverse
)
5959 unsigned int traverse_mask
= traverse
->traverse_mask();
5961 if ((traverse_mask
& Traverse::traverse_blocks
) != 0)
5963 int t
= traverse
->block(this);
5964 if (t
== TRAVERSE_EXIT
)
5965 return TRAVERSE_EXIT
;
5966 else if (t
== TRAVERSE_SKIP_COMPONENTS
)
5967 return TRAVERSE_CONTINUE
;
5971 & (Traverse::traverse_variables
5972 | Traverse::traverse_constants
5973 | Traverse::traverse_expressions
5974 | Traverse::traverse_types
)) != 0)
5976 const unsigned int e_or_t
= (Traverse::traverse_expressions
5977 | Traverse::traverse_types
);
5978 const unsigned int e_or_t_or_s
= (e_or_t
5979 | Traverse::traverse_statements
);
5980 for (Bindings::const_definitions_iterator pb
=
5981 this->bindings_
->begin_definitions();
5982 pb
!= this->bindings_
->end_definitions();
5985 int t
= TRAVERSE_CONTINUE
;
5986 switch ((*pb
)->classification())
5988 case Named_object::NAMED_OBJECT_CONST
:
5989 if ((traverse_mask
& Traverse::traverse_constants
) != 0)
5990 t
= traverse
->constant(*pb
, false);
5991 if (t
== TRAVERSE_CONTINUE
5992 && (traverse_mask
& e_or_t
) != 0)
5994 Type
* tc
= (*pb
)->const_value()->type();
5996 && Type::traverse(tc
, traverse
) == TRAVERSE_EXIT
)
5997 return TRAVERSE_EXIT
;
5998 t
= (*pb
)->const_value()->traverse_expression(traverse
);
6002 case Named_object::NAMED_OBJECT_VAR
:
6003 case Named_object::NAMED_OBJECT_RESULT_VAR
:
6004 if ((traverse_mask
& Traverse::traverse_variables
) != 0)
6005 t
= traverse
->variable(*pb
);
6006 if (t
== TRAVERSE_CONTINUE
6007 && (traverse_mask
& e_or_t
) != 0)
6009 if ((*pb
)->is_result_variable()
6010 || (*pb
)->var_value()->has_type())
6012 Type
* tv
= ((*pb
)->is_variable()
6013 ? (*pb
)->var_value()->type()
6014 : (*pb
)->result_var_value()->type());
6016 && Type::traverse(tv
, traverse
) == TRAVERSE_EXIT
)
6017 return TRAVERSE_EXIT
;
6020 if (t
== TRAVERSE_CONTINUE
6021 && (traverse_mask
& e_or_t_or_s
) != 0
6022 && (*pb
)->is_variable())
6023 t
= (*pb
)->var_value()->traverse_expression(traverse
,
6027 case Named_object::NAMED_OBJECT_FUNC
:
6028 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
6031 case Named_object::NAMED_OBJECT_TYPE
:
6032 if ((traverse_mask
& e_or_t
) != 0)
6033 t
= Type::traverse((*pb
)->type_value(), traverse
);
6036 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
6037 case Named_object::NAMED_OBJECT_UNKNOWN
:
6038 case Named_object::NAMED_OBJECT_ERRONEOUS
:
6041 case Named_object::NAMED_OBJECT_PACKAGE
:
6042 case Named_object::NAMED_OBJECT_SINK
:
6049 if (t
== TRAVERSE_EXIT
)
6050 return TRAVERSE_EXIT
;
6054 // No point in checking traverse_mask here--if we got here we always
6055 // want to walk the statements. The traversal can insert new
6056 // statements before or after the current statement. Inserting
6057 // statements before the current statement requires updating I via
6058 // the pointer; those statements will not be traversed. Any new
6059 // statements inserted after the current statement will be traversed
6061 for (size_t i
= 0; i
< this->statements_
.size(); ++i
)
6063 if (this->statements_
[i
]->traverse(this, &i
, traverse
) == TRAVERSE_EXIT
)
6064 return TRAVERSE_EXIT
;
6067 return TRAVERSE_CONTINUE
;
6070 // Work out types for unspecified variables and constants.
6073 Block::determine_types()
6075 for (Bindings::const_definitions_iterator pb
=
6076 this->bindings_
->begin_definitions();
6077 pb
!= this->bindings_
->end_definitions();
6080 if ((*pb
)->is_variable())
6081 (*pb
)->var_value()->determine_type();
6082 else if ((*pb
)->is_const())
6083 (*pb
)->const_value()->determine_type();
6086 for (std::vector
<Statement
*>::const_iterator ps
= this->statements_
.begin();
6087 ps
!= this->statements_
.end();
6089 (*ps
)->determine_types();
6092 // Return true if the statements in this block may fall through.
6095 Block::may_fall_through() const
6097 if (this->statements_
.empty())
6099 return this->statements_
.back()->may_fall_through();
6102 // Convert a block to the backend representation.
6105 Block::get_backend(Translate_context
* context
)
6107 Gogo
* gogo
= context
->gogo();
6108 Named_object
* function
= context
->function();
6109 std::vector
<Bvariable
*> vars
;
6110 vars
.reserve(this->bindings_
->size_definitions());
6111 for (Bindings::const_definitions_iterator pv
=
6112 this->bindings_
->begin_definitions();
6113 pv
!= this->bindings_
->end_definitions();
6116 if ((*pv
)->is_variable() && !(*pv
)->var_value()->is_parameter())
6117 vars
.push_back((*pv
)->get_backend_variable(gogo
, function
));
6120 go_assert(function
!= NULL
);
6121 Bfunction
* bfunction
=
6122 function
->func_value()->get_or_make_decl(gogo
, function
);
6123 Bblock
* ret
= context
->backend()->block(bfunction
, context
->bblock(),
6124 vars
, this->start_location_
,
6125 this->end_location_
);
6127 Translate_context
subcontext(gogo
, function
, this, ret
);
6128 std::vector
<Bstatement
*> bstatements
;
6129 bstatements
.reserve(this->statements_
.size());
6130 for (std::vector
<Statement
*>::const_iterator p
= this->statements_
.begin();
6131 p
!= this->statements_
.end();
6133 bstatements
.push_back((*p
)->get_backend(&subcontext
));
6135 context
->backend()->block_add_statements(ret
, bstatements
);
6140 // Class Bindings_snapshot.
6142 Bindings_snapshot::Bindings_snapshot(const Block
* b
, Location location
)
6143 : block_(b
), counts_(), location_(location
)
6147 this->counts_
.push_back(b
->bindings()->size_definitions());
6152 // Report errors appropriate for a goto from B to this.
6155 Bindings_snapshot::check_goto_from(const Block
* b
, Location loc
)
6158 if (!this->check_goto_block(loc
, b
, this->block_
, &dummy
))
6160 this->check_goto_defs(loc
, this->block_
,
6161 this->block_
->bindings()->size_definitions(),
6165 // Report errors appropriate for a goto from this to B.
6168 Bindings_snapshot::check_goto_to(const Block
* b
)
6171 if (!this->check_goto_block(this->location_
, this->block_
, b
, &index
))
6173 this->check_goto_defs(this->location_
, b
, this->counts_
[index
],
6174 b
->bindings()->size_definitions());
6177 // Report errors appropriate for a goto at LOC from BFROM to BTO.
6178 // Return true if all is well, false if we reported an error. If this
6179 // returns true, it sets *PINDEX to the number of blocks BTO is above
6183 Bindings_snapshot::check_goto_block(Location loc
, const Block
* bfrom
,
6184 const Block
* bto
, size_t* pindex
)
6186 // It is an error if BTO is not either BFROM or above BFROM.
6188 for (const Block
* pb
= bfrom
; pb
!= bto
; pb
= pb
->enclosing(), ++index
)
6192 go_error_at(loc
, "goto jumps into block");
6193 go_inform(bto
->start_location(), "goto target block starts here");
6201 // Report errors appropriate for a goto at LOC ending at BLOCK, where
6202 // CFROM is the number of names defined at the point of the goto and
6203 // CTO is the number of names defined at the point of the label.
6206 Bindings_snapshot::check_goto_defs(Location loc
, const Block
* block
,
6207 size_t cfrom
, size_t cto
)
6211 Bindings::const_definitions_iterator p
=
6212 block
->bindings()->begin_definitions();
6213 for (size_t i
= 0; i
< cfrom
; ++i
)
6215 go_assert(p
!= block
->bindings()->end_definitions());
6218 go_assert(p
!= block
->bindings()->end_definitions());
6220 for (; p
!= block
->bindings()->end_definitions(); ++p
)
6222 if ((*p
)->is_variable())
6224 std::string n
= (*p
)->message_name();
6225 go_error_at(loc
, "goto jumps over declaration of %qs", n
.c_str());
6226 go_inform((*p
)->location(), "%qs defined here", n
.c_str());
6232 // Class Function_declaration.
6234 // Whether this declares a method.
6237 Function_declaration::is_method() const
6239 return this->fntype_
->is_method();
6242 // Whether this method should not be included in the type descriptor.
6245 Function_declaration::nointerface() const
6247 go_assert(this->is_method());
6248 return (this->pragmas_
& GOPRAGMA_NOINTERFACE
) != 0;
6251 // Record that this method should not be included in the type
6255 Function_declaration::set_nointerface()
6257 this->pragmas_
|= GOPRAGMA_NOINTERFACE
;
6260 // Return the function descriptor.
6263 Function_declaration::descriptor(Gogo
*, Named_object
* no
)
6265 go_assert(!this->fntype_
->is_method());
6266 if (this->descriptor_
== NULL
)
6267 this->descriptor_
= Expression::make_func_descriptor(no
);
6268 return this->descriptor_
;
6273 Variable::Variable(Type
* type
, Expression
* init
, bool is_global
,
6274 bool is_parameter
, bool is_receiver
,
6276 : type_(type
), init_(init
), preinit_(NULL
), location_(location
),
6277 backend_(NULL
), is_global_(is_global
), is_parameter_(is_parameter
),
6278 is_closure_(false), is_receiver_(is_receiver
),
6279 is_varargs_parameter_(false), is_used_(false),
6280 is_address_taken_(false), is_non_escaping_address_taken_(false),
6281 seen_(false), init_is_lowered_(false), init_is_flattened_(false),
6282 type_from_init_tuple_(false), type_from_range_index_(false),
6283 type_from_range_value_(false), type_from_chan_element_(false),
6284 is_type_switch_var_(false), determined_type_(false),
6285 in_unique_section_(false), escapes_(true),
6286 toplevel_decl_(NULL
)
6288 go_assert(type
!= NULL
|| init
!= NULL
);
6289 go_assert(!is_parameter
|| init
== NULL
);
6292 // Traverse the initializer expression.
6295 Variable::traverse_expression(Traverse
* traverse
, unsigned int traverse_mask
)
6297 if (this->preinit_
!= NULL
)
6299 if (this->preinit_
->traverse(traverse
) == TRAVERSE_EXIT
)
6300 return TRAVERSE_EXIT
;
6302 if (this->init_
!= NULL
6304 & (Traverse::traverse_expressions
| Traverse::traverse_types
))
6307 if (Expression::traverse(&this->init_
, traverse
) == TRAVERSE_EXIT
)
6308 return TRAVERSE_EXIT
;
6310 return TRAVERSE_CONTINUE
;
6313 // Lower the initialization expression after parsing is complete.
6316 Variable::lower_init_expression(Gogo
* gogo
, Named_object
* function
,
6317 Statement_inserter
* inserter
)
6319 Named_object
* dep
= gogo
->var_depends_on(this);
6320 if (dep
!= NULL
&& dep
->is_variable())
6321 dep
->var_value()->lower_init_expression(gogo
, function
, inserter
);
6323 if (this->init_
!= NULL
&& !this->init_is_lowered_
)
6327 // We will give an error elsewhere, this is just to prevent
6328 // an infinite loop.
6333 Statement_inserter global_inserter
;
6334 if (this->is_global_
)
6336 global_inserter
= Statement_inserter(gogo
, this);
6337 inserter
= &global_inserter
;
6340 gogo
->lower_expression(function
, inserter
, &this->init_
);
6342 this->seen_
= false;
6344 this->init_is_lowered_
= true;
6348 // Flatten the initialization expression after ordering evaluations.
6351 Variable::flatten_init_expression(Gogo
* gogo
, Named_object
* function
,
6352 Statement_inserter
* inserter
)
6354 Named_object
* dep
= gogo
->var_depends_on(this);
6355 if (dep
!= NULL
&& dep
->is_variable())
6356 dep
->var_value()->flatten_init_expression(gogo
, function
, inserter
);
6358 if (this->init_
!= NULL
&& !this->init_is_flattened_
)
6362 // We will give an error elsewhere, this is just to prevent
6363 // an infinite loop.
6368 Statement_inserter global_inserter
;
6369 if (this->is_global_
)
6371 global_inserter
= Statement_inserter(gogo
, this);
6372 inserter
= &global_inserter
;
6375 gogo
->flatten_expression(function
, inserter
, &this->init_
);
6377 // If an interface conversion is needed, we need a temporary
6379 if (this->type_
!= NULL
6380 && !Type::are_identical(this->type_
, this->init_
->type(), false,
6382 && this->init_
->type()->interface_type() != NULL
6383 && !this->init_
->is_variable())
6385 Temporary_statement
* temp
=
6386 Statement::make_temporary(NULL
, this->init_
, this->location_
);
6387 inserter
->insert(temp
);
6388 this->init_
= Expression::make_temporary_reference(temp
,
6392 this->seen_
= false;
6393 this->init_is_flattened_
= true;
6397 // Get the preinit block.
6400 Variable::preinit_block(Gogo
* gogo
)
6402 go_assert(this->is_global_
);
6403 if (this->preinit_
== NULL
)
6404 this->preinit_
= new Block(NULL
, this->location());
6406 // If a global variable has a preinitialization statement, then we
6407 // need to have an initialization function.
6408 gogo
->set_need_init_fn();
6410 return this->preinit_
;
6413 // Add a statement to be run before the initialization expression.
6416 Variable::add_preinit_statement(Gogo
* gogo
, Statement
* s
)
6418 Block
* b
= this->preinit_block(gogo
);
6419 b
->add_statement(s
);
6420 b
->set_end_location(s
->location());
6423 // Whether this variable has a type.
6426 Variable::has_type() const
6428 if (this->type_
== NULL
)
6431 // A variable created in a type switch case nil does not actually
6432 // have a type yet. It will be changed to use the initializer's
6433 // type in determine_type.
6434 if (this->is_type_switch_var_
6435 && this->type_
->is_nil_constant_as_type())
6441 // In an assignment which sets a variable to a tuple of EXPR, return
6442 // the type of the first element of the tuple.
6445 Variable::type_from_tuple(Expression
* expr
, bool report_error
) const
6447 if (expr
->map_index_expression() != NULL
)
6449 Map_type
* mt
= expr
->map_index_expression()->get_map_type();
6451 return Type::make_error_type();
6452 return mt
->val_type();
6454 else if (expr
->receive_expression() != NULL
)
6456 Expression
* channel
= expr
->receive_expression()->channel();
6457 Type
* channel_type
= channel
->type();
6458 if (channel_type
->channel_type() == NULL
)
6459 return Type::make_error_type();
6460 return channel_type
->channel_type()->element_type();
6465 go_error_at(this->location(), "invalid tuple definition");
6466 return Type::make_error_type();
6470 // Given EXPR used in a range clause, return either the index type or
6471 // the value type of the range, depending upon GET_INDEX_TYPE.
6474 Variable::type_from_range(Expression
* expr
, bool get_index_type
,
6475 bool report_error
) const
6477 Type
* t
= expr
->type();
6478 if (t
->array_type() != NULL
6479 || (t
->points_to() != NULL
6480 && t
->points_to()->array_type() != NULL
6481 && !t
->points_to()->is_slice_type()))
6484 return Type::lookup_integer_type("int");
6486 return t
->deref()->array_type()->element_type();
6488 else if (t
->is_string_type())
6491 return Type::lookup_integer_type("int");
6493 return Type::lookup_integer_type("int32");
6495 else if (t
->map_type() != NULL
)
6498 return t
->map_type()->key_type();
6500 return t
->map_type()->val_type();
6502 else if (t
->channel_type() != NULL
)
6505 return t
->channel_type()->element_type();
6509 go_error_at(this->location(),
6510 ("invalid definition of value variable "
6511 "for channel range"));
6512 return Type::make_error_type();
6518 go_error_at(this->location(), "invalid type for range clause");
6519 return Type::make_error_type();
6523 // EXPR should be a channel. Return the channel's element type.
6526 Variable::type_from_chan_element(Expression
* expr
, bool report_error
) const
6528 Type
* t
= expr
->type();
6529 if (t
->channel_type() != NULL
)
6530 return t
->channel_type()->element_type();
6534 go_error_at(this->location(), "expected channel");
6535 return Type::make_error_type();
6539 // Return the type of the Variable. This may be called before
6540 // Variable::determine_type is called, which means that we may need to
6541 // get the type from the initializer. FIXME: If we combine lowering
6542 // with type determination, then this should be unnecessary.
6547 // A variable in a type switch with a nil case will have the wrong
6548 // type here. This gets fixed up in determine_type, below.
6549 Type
* type
= this->type_
;
6550 Expression
* init
= this->init_
;
6551 if (this->is_type_switch_var_
6553 && this->type_
->is_nil_constant_as_type())
6555 Type_guard_expression
* tge
= this->init_
->type_guard_expression();
6556 go_assert(tge
!= NULL
);
6563 if (this->type_
== NULL
|| !this->type_
->is_error_type())
6565 go_error_at(this->location_
, "variable initializer refers to itself");
6566 this->type_
= Type::make_error_type();
6575 else if (this->type_from_init_tuple_
)
6576 type
= this->type_from_tuple(init
, false);
6577 else if (this->type_from_range_index_
|| this->type_from_range_value_
)
6578 type
= this->type_from_range(init
, this->type_from_range_index_
, false);
6579 else if (this->type_from_chan_element_
)
6580 type
= this->type_from_chan_element(init
, false);
6583 go_assert(init
!= NULL
);
6584 type
= init
->type();
6585 go_assert(type
!= NULL
);
6587 // Variables should not have abstract types.
6588 if (type
->is_abstract())
6589 type
= type
->make_non_abstract_type();
6591 if (type
->is_void_type())
6592 type
= Type::make_error_type();
6595 this->seen_
= false;
6600 // Fetch the type from a const pointer, in which case it should have
6601 // been set already.
6604 Variable::type() const
6606 go_assert(this->type_
!= NULL
);
6610 // Set the type if necessary.
6613 Variable::determine_type()
6615 if (this->determined_type_
)
6617 this->determined_type_
= true;
6619 if (this->preinit_
!= NULL
)
6620 this->preinit_
->determine_types();
6622 // A variable in a type switch with a nil case will have the wrong
6623 // type here. It will have an initializer which is a type guard.
6624 // We want to initialize it to the value without the type guard, and
6625 // use the type of that value as well.
6626 if (this->is_type_switch_var_
6627 && this->type_
!= NULL
6628 && this->type_
->is_nil_constant_as_type())
6630 Type_guard_expression
* tge
= this->init_
->type_guard_expression();
6631 go_assert(tge
!= NULL
);
6633 this->init_
= tge
->expr();
6636 if (this->init_
== NULL
)
6637 go_assert(this->type_
!= NULL
&& !this->type_
->is_abstract());
6638 else if (this->type_from_init_tuple_
)
6640 Expression
*init
= this->init_
;
6641 init
->determine_type_no_context();
6642 this->type_
= this->type_from_tuple(init
, true);
6645 else if (this->type_from_range_index_
|| this->type_from_range_value_
)
6647 Expression
* init
= this->init_
;
6648 init
->determine_type_no_context();
6649 this->type_
= this->type_from_range(init
, this->type_from_range_index_
,
6653 else if (this->type_from_chan_element_
)
6655 Expression
* init
= this->init_
;
6656 init
->determine_type_no_context();
6657 this->type_
= this->type_from_chan_element(init
, true);
6662 Type_context
context(this->type_
, false);
6663 this->init_
->determine_type(&context
);
6664 if (this->type_
== NULL
)
6666 Type
* type
= this->init_
->type();
6667 go_assert(type
!= NULL
);
6668 if (type
->is_abstract())
6669 type
= type
->make_non_abstract_type();
6671 if (type
->is_void_type())
6673 go_error_at(this->location_
, "variable has no type");
6674 type
= Type::make_error_type();
6676 else if (type
->is_nil_type())
6678 go_error_at(this->location_
, "variable defined to nil type");
6679 type
= Type::make_error_type();
6681 else if (type
->is_call_multiple_result_type())
6683 go_error_at(this->location_
,
6684 "single variable set to multiple-value function call");
6685 type
= Type::make_error_type();
6693 // Get the initial value of a variable. This does not
6694 // consider whether the variable is in the heap--it returns the
6695 // initial value as though it were always stored in the stack.
6698 Variable::get_init(Gogo
* gogo
, Named_object
* function
)
6700 go_assert(this->preinit_
== NULL
);
6701 Location loc
= this->location();
6702 if (this->init_
== NULL
)
6704 go_assert(!this->is_parameter_
);
6705 if (this->is_global_
|| this->is_in_heap())
6707 Btype
* btype
= this->type()->get_backend(gogo
);
6708 return gogo
->backend()->zero_expression(btype
);
6712 Translate_context
context(gogo
, function
, NULL
, NULL
);
6713 Expression
* init
= Expression::make_cast(this->type(), this->init_
, loc
);
6714 return init
->get_backend(&context
);
6718 // Get the initial value of a variable when a block is required.
6719 // VAR_DECL is the decl to set; it may be NULL for a sink variable.
6722 Variable::get_init_block(Gogo
* gogo
, Named_object
* function
,
6723 Bvariable
* var_decl
)
6725 go_assert(this->preinit_
!= NULL
);
6727 // We want to add the variable assignment to the end of the preinit
6730 Translate_context
context(gogo
, function
, NULL
, NULL
);
6731 Bblock
* bblock
= this->preinit_
->get_backend(&context
);
6732 Bfunction
* bfunction
=
6733 function
->func_value()->get_or_make_decl(gogo
, function
);
6735 // It's possible to have pre-init statements without an initializer
6736 // if the pre-init statements set the variable.
6737 Bstatement
* decl_init
= NULL
;
6738 if (this->init_
!= NULL
)
6740 if (var_decl
== NULL
)
6742 Bexpression
* init_bexpr
= this->init_
->get_backend(&context
);
6743 decl_init
= gogo
->backend()->expression_statement(bfunction
,
6748 Location loc
= this->location();
6749 Expression
* val_expr
=
6750 Expression::make_cast(this->type(), this->init_
, loc
);
6751 Bexpression
* val
= val_expr
->get_backend(&context
);
6752 Bexpression
* var_ref
=
6753 gogo
->backend()->var_expression(var_decl
, loc
);
6754 decl_init
= gogo
->backend()->assignment_statement(bfunction
, var_ref
,
6758 Bstatement
* block_stmt
= gogo
->backend()->block_statement(bblock
);
6759 if (decl_init
!= NULL
)
6760 block_stmt
= gogo
->backend()->compound_statement(block_stmt
, decl_init
);
6764 // Export the variable
6767 Variable::export_var(Export
* exp
, const std::string
& name
) const
6769 go_assert(this->is_global_
);
6770 exp
->write_c_string("var ");
6771 exp
->write_string(name
);
6772 exp
->write_c_string(" ");
6773 exp
->write_type(this->type());
6774 exp
->write_c_string(";\n");
6777 // Import a variable.
6780 Variable::import_var(Import
* imp
, std::string
* pname
, Type
** ptype
)
6782 imp
->require_c_string("var ");
6783 *pname
= imp
->read_identifier();
6784 imp
->require_c_string(" ");
6785 *ptype
= imp
->read_type();
6786 imp
->require_c_string(";\n");
6789 // Convert a variable to the backend representation.
6792 Variable::get_backend_variable(Gogo
* gogo
, Named_object
* function
,
6793 const Package
* package
, const std::string
& name
)
6795 if (this->backend_
== NULL
)
6797 Backend
* backend
= gogo
->backend();
6798 Type
* type
= this->type_
;
6799 if (type
->is_error_type()
6800 || (type
->is_undefined()
6801 && (!this->is_global_
|| package
== NULL
)))
6802 this->backend_
= backend
->error_variable();
6805 bool is_parameter
= this->is_parameter_
;
6806 if (this->is_receiver_
&& type
->points_to() == NULL
)
6807 is_parameter
= false;
6808 if (this->is_in_heap())
6810 is_parameter
= false;
6811 type
= Type::make_pointer_type(type
);
6814 const std::string n
= Gogo::unpack_hidden_name(name
);
6815 Btype
* btype
= type
->get_backend(gogo
);
6818 if (Map_type::is_zero_value(this))
6819 bvar
= Map_type::backend_zero_value(gogo
);
6820 else if (this->is_global_
)
6822 std::string
var_name(package
!= NULL
6823 ? package
->package_name()
6824 : gogo
->package_name());
6825 var_name
.push_back('.');
6828 std::string
asm_name(gogo
->global_var_asm_name(name
, package
));
6830 bool is_hidden
= Gogo::is_hidden_name(name
);
6831 // Hack to export runtime.writeBarrier. FIXME.
6832 // This is because go:linkname doesn't work on variables.
6833 if (gogo
->compiling_runtime()
6834 && var_name
== "runtime.writeBarrier")
6837 bvar
= backend
->global_variable(var_name
,
6842 this->in_unique_section_
,
6845 else if (function
== NULL
)
6847 go_assert(saw_errors());
6848 bvar
= backend
->error_variable();
6852 Bfunction
* bfunction
= function
->func_value()->get_decl();
6853 bool is_address_taken
= (this->is_non_escaping_address_taken_
6854 && !this->is_in_heap());
6855 if (this->is_closure())
6856 bvar
= backend
->static_chain_variable(bfunction
, n
, btype
,
6858 else if (is_parameter
)
6859 bvar
= backend
->parameter_variable(bfunction
, n
, btype
,
6864 Bvariable
* bvar_decl
= NULL
;
6865 if (this->toplevel_decl_
!= NULL
)
6867 Translate_context
context(gogo
, NULL
, NULL
, NULL
);
6868 bvar_decl
= this->toplevel_decl_
->temporary_statement()
6869 ->get_backend_variable(&context
);
6871 bvar
= backend
->local_variable(bfunction
, n
, btype
,
6877 this->backend_
= bvar
;
6880 return this->backend_
;
6883 // Class Result_variable.
6885 // Convert a result variable to the backend representation.
6888 Result_variable::get_backend_variable(Gogo
* gogo
, Named_object
* function
,
6889 const std::string
& name
)
6891 if (this->backend_
== NULL
)
6893 Backend
* backend
= gogo
->backend();
6894 Type
* type
= this->type_
;
6895 if (type
->is_error())
6896 this->backend_
= backend
->error_variable();
6899 if (this->is_in_heap())
6900 type
= Type::make_pointer_type(type
);
6901 Btype
* btype
= type
->get_backend(gogo
);
6902 Bfunction
* bfunction
= function
->func_value()->get_decl();
6903 std::string n
= Gogo::unpack_hidden_name(name
);
6904 bool is_address_taken
= (this->is_non_escaping_address_taken_
6905 && !this->is_in_heap());
6906 this->backend_
= backend
->local_variable(bfunction
, n
, btype
,
6907 NULL
, is_address_taken
,
6911 return this->backend_
;
6914 // Class Named_constant.
6916 // Set the type of a named constant. This is only used to set the
6917 // type to an error type.
6920 Named_constant::set_type(Type
* t
)
6922 go_assert(this->type_
== NULL
|| t
->is_error_type());
6926 // Traverse the initializer expression.
6929 Named_constant::traverse_expression(Traverse
* traverse
)
6931 return Expression::traverse(&this->expr_
, traverse
);
6934 // Determine the type of the constant.
6937 Named_constant::determine_type()
6939 if (this->type_
!= NULL
)
6941 Type_context
context(this->type_
, false);
6942 this->expr_
->determine_type(&context
);
6946 // A constant may have an abstract type.
6947 Type_context
context(NULL
, true);
6948 this->expr_
->determine_type(&context
);
6949 this->type_
= this->expr_
->type();
6950 go_assert(this->type_
!= NULL
);
6954 // Indicate that we found and reported an error for this constant.
6957 Named_constant::set_error()
6959 this->type_
= Type::make_error_type();
6960 this->expr_
= Expression::make_error(this->location_
);
6963 // Export a constant.
6966 Named_constant::export_const(Export
* exp
, const std::string
& name
) const
6968 exp
->write_c_string("const ");
6969 exp
->write_string(name
);
6970 exp
->write_c_string(" ");
6971 if (!this->type_
->is_abstract())
6973 exp
->write_type(this->type_
);
6974 exp
->write_c_string(" ");
6976 exp
->write_c_string("= ");
6977 this->expr()->export_expression(exp
);
6978 exp
->write_c_string(";\n");
6981 // Import a constant.
6984 Named_constant::import_const(Import
* imp
, std::string
* pname
, Type
** ptype
,
6987 imp
->require_c_string("const ");
6988 *pname
= imp
->read_identifier();
6989 imp
->require_c_string(" ");
6990 if (imp
->peek_char() == '=')
6994 *ptype
= imp
->read_type();
6995 imp
->require_c_string(" ");
6997 imp
->require_c_string("= ");
6998 *pexpr
= Expression::import_expression(imp
);
6999 imp
->require_c_string(";\n");
7002 // Get the backend representation.
7005 Named_constant::get_backend(Gogo
* gogo
, Named_object
* const_no
)
7007 if (this->bconst_
== NULL
)
7009 Translate_context
subcontext(gogo
, NULL
, NULL
, NULL
);
7010 Type
* type
= this->type();
7011 Location loc
= this->location();
7013 Expression
* const_ref
= Expression::make_const_reference(const_no
, loc
);
7014 Bexpression
* const_decl
= const_ref
->get_backend(&subcontext
);
7015 if (type
!= NULL
&& type
->is_numeric_type())
7017 Btype
* btype
= type
->get_backend(gogo
);
7018 std::string name
= const_no
->get_id(gogo
);
7020 gogo
->backend()->named_constant_expression(btype
, name
,
7023 this->bconst_
= const_decl
;
7025 return this->bconst_
;
7031 Type_declaration::add_method(const std::string
& name
, Function
* function
)
7033 Named_object
* ret
= Named_object::make_function(name
, NULL
, function
);
7034 this->methods_
.push_back(ret
);
7038 // Add a method declaration.
7041 Type_declaration::add_method_declaration(const std::string
& name
,
7043 Function_type
* type
,
7046 Named_object
* ret
= Named_object::make_function_declaration(name
, package
,
7048 this->methods_
.push_back(ret
);
7052 // Return whether any methods are defined.
7055 Type_declaration::has_methods() const
7057 return !this->methods_
.empty();
7060 // Define methods for the real type.
7063 Type_declaration::define_methods(Named_type
* nt
)
7065 if (this->methods_
.empty())
7068 while (nt
->is_alias())
7070 Type
*t
= nt
->real_type()->forwarded();
7071 if (t
->named_type() != NULL
)
7072 nt
= t
->named_type();
7073 else if (t
->forward_declaration_type() != NULL
)
7075 Named_object
* no
= t
->forward_declaration_type()->named_object();
7076 Type_declaration
* td
= no
->type_declaration_value();
7077 td
->methods_
.insert(td
->methods_
.end(), this->methods_
.begin(),
7078 this->methods_
.end());
7079 this->methods_
.clear();
7084 for (std::vector
<Named_object
*>::const_iterator p
=
7085 this->methods_
.begin();
7086 p
!= this->methods_
.end();
7088 go_error_at((*p
)->location(),
7089 ("invalid receiver type "
7090 "(receiver must be a named type"));
7095 for (std::vector
<Named_object
*>::const_iterator p
= this->methods_
.begin();
7096 p
!= this->methods_
.end();
7099 if (!(*p
)->func_value()->is_sink())
7100 nt
->add_existing_method(*p
);
7104 // We are using the type. Return true if we should issue a warning.
7107 Type_declaration::using_type()
7109 bool ret
= !this->issued_warning_
;
7110 this->issued_warning_
= true;
7114 // Class Unknown_name.
7116 // Set the real named object.
7119 Unknown_name::set_real_named_object(Named_object
* no
)
7121 go_assert(this->real_named_object_
== NULL
);
7122 go_assert(!no
->is_unknown());
7123 this->real_named_object_
= no
;
7126 // Class Named_object.
7128 Named_object::Named_object(const std::string
& name
,
7129 const Package
* package
,
7130 Classification classification
)
7131 : name_(name
), package_(package
), classification_(classification
),
7132 is_redefinition_(false)
7134 if (Gogo::is_sink_name(name
))
7135 go_assert(classification
== NAMED_OBJECT_SINK
);
7138 // Make an unknown name. This is used by the parser. The name must
7139 // be resolved later. Unknown names are only added in the current
7143 Named_object::make_unknown_name(const std::string
& name
,
7146 Named_object
* named_object
= new Named_object(name
, NULL
,
7147 NAMED_OBJECT_UNKNOWN
);
7148 Unknown_name
* value
= new Unknown_name(location
);
7149 named_object
->u_
.unknown_value
= value
;
7150 return named_object
;
7156 Named_object::make_constant(const Typed_identifier
& tid
,
7157 const Package
* package
, Expression
* expr
,
7160 Named_object
* named_object
= new Named_object(tid
.name(), package
,
7161 NAMED_OBJECT_CONST
);
7162 Named_constant
* named_constant
= new Named_constant(tid
.type(), expr
,
7165 named_object
->u_
.const_value
= named_constant
;
7166 return named_object
;
7169 // Make a named type.
7172 Named_object::make_type(const std::string
& name
, const Package
* package
,
7173 Type
* type
, Location location
)
7175 Named_object
* named_object
= new Named_object(name
, package
,
7177 Named_type
* named_type
= Type::make_named_type(named_object
, type
, location
);
7178 named_object
->u_
.type_value
= named_type
;
7179 return named_object
;
7182 // Make a type declaration.
7185 Named_object::make_type_declaration(const std::string
& name
,
7186 const Package
* package
,
7189 Named_object
* named_object
= new Named_object(name
, package
,
7190 NAMED_OBJECT_TYPE_DECLARATION
);
7191 Type_declaration
* type_declaration
= new Type_declaration(location
);
7192 named_object
->u_
.type_declaration
= type_declaration
;
7193 return named_object
;
7199 Named_object::make_variable(const std::string
& name
, const Package
* package
,
7202 Named_object
* named_object
= new Named_object(name
, package
,
7204 named_object
->u_
.var_value
= variable
;
7205 return named_object
;
7208 // Make a result variable.
7211 Named_object::make_result_variable(const std::string
& name
,
7212 Result_variable
* result
)
7214 Named_object
* named_object
= new Named_object(name
, NULL
,
7215 NAMED_OBJECT_RESULT_VAR
);
7216 named_object
->u_
.result_var_value
= result
;
7217 return named_object
;
7220 // Make a sink. This is used for the special blank identifier _.
7223 Named_object::make_sink()
7225 return new Named_object("_", NULL
, NAMED_OBJECT_SINK
);
7228 // Make a named function.
7231 Named_object::make_function(const std::string
& name
, const Package
* package
,
7234 Named_object
* named_object
= new Named_object(name
, package
,
7236 named_object
->u_
.func_value
= function
;
7237 return named_object
;
7240 // Make a function declaration.
7243 Named_object::make_function_declaration(const std::string
& name
,
7244 const Package
* package
,
7245 Function_type
* fntype
,
7248 Named_object
* named_object
= new Named_object(name
, package
,
7249 NAMED_OBJECT_FUNC_DECLARATION
);
7250 Function_declaration
*func_decl
= new Function_declaration(fntype
, location
);
7251 named_object
->u_
.func_declaration_value
= func_decl
;
7252 return named_object
;
7258 Named_object::make_package(const std::string
& alias
, Package
* package
)
7260 Named_object
* named_object
= new Named_object(alias
, NULL
,
7261 NAMED_OBJECT_PACKAGE
);
7262 named_object
->u_
.package_value
= package
;
7263 return named_object
;
7266 // Return the name to use in an error message.
7269 Named_object::message_name() const
7271 if (this->package_
== NULL
)
7272 return Gogo::message_name(this->name_
);
7274 if (this->package_
->has_package_name())
7275 ret
= this->package_
->package_name();
7277 ret
= this->package_
->pkgpath();
7278 ret
= Gogo::message_name(ret
);
7280 ret
+= Gogo::message_name(this->name_
);
7284 // Set the type when a declaration is defined.
7287 Named_object::set_type_value(Named_type
* named_type
)
7289 go_assert(this->classification_
== NAMED_OBJECT_TYPE_DECLARATION
);
7290 Type_declaration
* td
= this->u_
.type_declaration
;
7291 td
->define_methods(named_type
);
7293 Named_object
* in_function
= td
->in_function(&index
);
7294 if (in_function
!= NULL
)
7295 named_type
->set_in_function(in_function
, index
);
7297 this->classification_
= NAMED_OBJECT_TYPE
;
7298 this->u_
.type_value
= named_type
;
7301 // Define a function which was previously declared.
7304 Named_object::set_function_value(Function
* function
)
7306 go_assert(this->classification_
== NAMED_OBJECT_FUNC_DECLARATION
);
7307 if (this->func_declaration_value()->has_descriptor())
7309 Expression
* descriptor
=
7310 this->func_declaration_value()->descriptor(NULL
, NULL
);
7311 function
->set_descriptor(descriptor
);
7313 this->classification_
= NAMED_OBJECT_FUNC
;
7314 // FIXME: We should free the old value.
7315 this->u_
.func_value
= function
;
7318 // Declare an unknown object as a type declaration.
7321 Named_object::declare_as_type()
7323 go_assert(this->classification_
== NAMED_OBJECT_UNKNOWN
);
7324 Unknown_name
* unk
= this->u_
.unknown_value
;
7325 this->classification_
= NAMED_OBJECT_TYPE_DECLARATION
;
7326 this->u_
.type_declaration
= new Type_declaration(unk
->location());
7330 // Return the location of a named object.
7333 Named_object::location() const
7335 switch (this->classification_
)
7338 case NAMED_OBJECT_UNINITIALIZED
:
7341 case NAMED_OBJECT_ERRONEOUS
:
7342 return Linemap::unknown_location();
7344 case NAMED_OBJECT_UNKNOWN
:
7345 return this->unknown_value()->location();
7347 case NAMED_OBJECT_CONST
:
7348 return this->const_value()->location();
7350 case NAMED_OBJECT_TYPE
:
7351 return this->type_value()->location();
7353 case NAMED_OBJECT_TYPE_DECLARATION
:
7354 return this->type_declaration_value()->location();
7356 case NAMED_OBJECT_VAR
:
7357 return this->var_value()->location();
7359 case NAMED_OBJECT_RESULT_VAR
:
7360 return this->result_var_value()->location();
7362 case NAMED_OBJECT_SINK
:
7365 case NAMED_OBJECT_FUNC
:
7366 return this->func_value()->location();
7368 case NAMED_OBJECT_FUNC_DECLARATION
:
7369 return this->func_declaration_value()->location();
7371 case NAMED_OBJECT_PACKAGE
:
7372 return this->package_value()->location();
7376 // Export a named object.
7379 Named_object::export_named_object(Export
* exp
) const
7381 switch (this->classification_
)
7384 case NAMED_OBJECT_UNINITIALIZED
:
7385 case NAMED_OBJECT_UNKNOWN
:
7388 case NAMED_OBJECT_ERRONEOUS
:
7391 case NAMED_OBJECT_CONST
:
7392 this->const_value()->export_const(exp
, this->name_
);
7395 case NAMED_OBJECT_TYPE
:
7396 this->type_value()->export_named_type(exp
, this->name_
);
7399 case NAMED_OBJECT_TYPE_DECLARATION
:
7400 go_error_at(this->type_declaration_value()->location(),
7401 "attempt to export %<%s%> which was declared but not defined",
7402 this->message_name().c_str());
7405 case NAMED_OBJECT_FUNC_DECLARATION
:
7406 this->func_declaration_value()->export_func(exp
, this->name_
);
7409 case NAMED_OBJECT_VAR
:
7410 this->var_value()->export_var(exp
, this->name_
);
7413 case NAMED_OBJECT_RESULT_VAR
:
7414 case NAMED_OBJECT_SINK
:
7417 case NAMED_OBJECT_FUNC
:
7418 this->func_value()->export_func(exp
, this->name_
);
7423 // Convert a variable to the backend representation.
7426 Named_object::get_backend_variable(Gogo
* gogo
, Named_object
* function
)
7428 if (this->classification_
== NAMED_OBJECT_VAR
)
7429 return this->var_value()->get_backend_variable(gogo
, function
,
7430 this->package_
, this->name_
);
7431 else if (this->classification_
== NAMED_OBJECT_RESULT_VAR
)
7432 return this->result_var_value()->get_backend_variable(gogo
, function
,
7438 // Return the external identifier for this object.
7441 Named_object::get_id(Gogo
* gogo
)
7443 go_assert(!this->is_variable()
7444 && !this->is_result_variable()
7445 && !this->is_type());
7446 std::string decl_name
;
7447 if (this->is_function_declaration()
7448 && !this->func_declaration_value()->asm_name().empty())
7449 decl_name
= this->func_declaration_value()->asm_name();
7452 std::string package_name
;
7453 if (this->package_
== NULL
)
7454 package_name
= gogo
->package_name();
7456 package_name
= this->package_
->package_name();
7458 // Note that this will be misleading if this is an unexported
7459 // method generated for an embedded imported type. In that case
7460 // the unexported method should have the package name of the
7461 // package from which it is imported, but we are going to give
7462 // it our package name. Fixing this would require knowing the
7463 // package name, but we only know the package path. It might be
7464 // better to use package paths here anyhow. This doesn't affect
7465 // the assembler code, because we always set that name in
7466 // Function::get_or_make_decl anyhow. FIXME.
7468 decl_name
= package_name
+ '.' + Gogo::unpack_hidden_name(this->name_
);
7470 Function_type
* fntype
;
7471 if (this->is_function())
7472 fntype
= this->func_value()->type();
7473 else if (this->is_function_declaration())
7474 fntype
= this->func_declaration_value()->type();
7477 if (fntype
!= NULL
&& fntype
->is_method())
7479 decl_name
.push_back('.');
7480 decl_name
.append(fntype
->receiver()->type()->mangled_name(gogo
));
7486 // Get the backend representation for this named object.
7489 Named_object::get_backend(Gogo
* gogo
, std::vector
<Bexpression
*>& const_decls
,
7490 std::vector
<Btype
*>& type_decls
,
7491 std::vector
<Bfunction
*>& func_decls
)
7493 // If this is a definition, avoid trying to get the backend
7494 // representation, as that can crash.
7495 if (this->is_redefinition_
)
7497 go_assert(saw_errors());
7501 switch (this->classification_
)
7503 case NAMED_OBJECT_CONST
:
7504 if (!Gogo::is_erroneous_name(this->name_
))
7505 const_decls
.push_back(this->u_
.const_value
->get_backend(gogo
, this));
7508 case NAMED_OBJECT_TYPE
:
7510 Named_type
* named_type
= this->u_
.type_value
;
7511 if (!Gogo::is_erroneous_name(this->name_
))
7512 type_decls
.push_back(named_type
->get_backend(gogo
));
7514 // We need to produce a type descriptor for every named
7515 // type, and for a pointer to every named type, since
7516 // other files or packages might refer to them. We need
7517 // to do this even for hidden types, because they might
7518 // still be returned by some function. Simply calling the
7519 // type_descriptor method is enough to create the type
7520 // descriptor, even though we don't do anything with it.
7521 if (this->package_
== NULL
&& !saw_errors())
7524 type_descriptor_pointer(gogo
, Linemap::predeclared_location());
7525 named_type
->gc_symbol_pointer(gogo
);
7526 Type
* pn
= Type::make_pointer_type(named_type
);
7527 pn
->type_descriptor_pointer(gogo
, Linemap::predeclared_location());
7528 pn
->gc_symbol_pointer(gogo
);
7533 case NAMED_OBJECT_TYPE_DECLARATION
:
7534 go_error_at(Linemap::unknown_location(),
7535 "reference to undefined type %qs",
7536 this->message_name().c_str());
7539 case NAMED_OBJECT_VAR
:
7540 case NAMED_OBJECT_RESULT_VAR
:
7541 case NAMED_OBJECT_SINK
:
7544 case NAMED_OBJECT_FUNC
:
7546 Function
* func
= this->u_
.func_value
;
7547 if (!Gogo::is_erroneous_name(this->name_
))
7548 func_decls
.push_back(func
->get_or_make_decl(gogo
, this));
7550 if (func
->block() != NULL
)
7551 func
->build(gogo
, this);
7555 case NAMED_OBJECT_ERRONEOUS
:
7565 Bindings::Bindings(Bindings
* enclosing
)
7566 : enclosing_(enclosing
), named_objects_(), bindings_()
7573 Bindings::clear_file_scope(Gogo
* gogo
)
7575 Contour::iterator p
= this->bindings_
.begin();
7576 while (p
!= this->bindings_
.end())
7579 if (p
->second
->package() != NULL
)
7581 else if (p
->second
->is_package())
7583 else if (p
->second
->is_function()
7584 && !p
->second
->func_value()->type()->is_method()
7585 && Gogo::unpack_hidden_name(p
->second
->name()) == "init")
7594 gogo
->add_file_block_name(p
->second
->name(), p
->second
->location());
7595 p
= this->bindings_
.erase(p
);
7600 // Look up a symbol.
7603 Bindings::lookup(const std::string
& name
) const
7605 Contour::const_iterator p
= this->bindings_
.find(name
);
7606 if (p
!= this->bindings_
.end())
7607 return p
->second
->resolve();
7608 else if (this->enclosing_
!= NULL
)
7609 return this->enclosing_
->lookup(name
);
7614 // Look up a symbol locally.
7617 Bindings::lookup_local(const std::string
& name
) const
7619 Contour::const_iterator p
= this->bindings_
.find(name
);
7620 if (p
== this->bindings_
.end())
7625 // Remove an object from a set of bindings. This is used for a
7626 // special case in thunks for functions which call recover.
7629 Bindings::remove_binding(Named_object
* no
)
7631 Contour::iterator pb
= this->bindings_
.find(no
->name());
7632 go_assert(pb
!= this->bindings_
.end());
7633 this->bindings_
.erase(pb
);
7634 for (std::vector
<Named_object
*>::iterator pn
= this->named_objects_
.begin();
7635 pn
!= this->named_objects_
.end();
7640 this->named_objects_
.erase(pn
);
7647 // Add a method to the list of objects. This is not added to the
7648 // lookup table. This is so that we have a single list of objects
7649 // declared at the top level, which we walk through when it's time to
7650 // convert to trees.
7653 Bindings::add_method(Named_object
* method
)
7655 this->named_objects_
.push_back(method
);
7658 // Add a generic Named_object to a Contour.
7661 Bindings::add_named_object_to_contour(Contour
* contour
,
7662 Named_object
* named_object
)
7664 go_assert(named_object
== named_object
->resolve());
7665 const std::string
& name(named_object
->name());
7666 go_assert(!Gogo::is_sink_name(name
));
7668 std::pair
<Contour::iterator
, bool> ins
=
7669 contour
->insert(std::make_pair(name
, named_object
));
7672 // The name was already there.
7673 if (named_object
->package() != NULL
7674 && ins
.first
->second
->package() == named_object
->package()
7675 && (ins
.first
->second
->classification()
7676 == named_object
->classification()))
7678 // This is a second import of the same object.
7679 return ins
.first
->second
;
7681 ins
.first
->second
= this->new_definition(ins
.first
->second
,
7683 return ins
.first
->second
;
7687 // Don't push declarations on the list. We push them on when
7688 // and if we find the definitions. That way we genericize the
7689 // functions in order.
7690 if (!named_object
->is_type_declaration()
7691 && !named_object
->is_function_declaration()
7692 && !named_object
->is_unknown())
7693 this->named_objects_
.push_back(named_object
);
7694 return named_object
;
7698 // We had an existing named object OLD_OBJECT, and we've seen a new
7699 // one NEW_OBJECT with the same name. FIXME: This does not free the
7700 // new object when we don't need it.
7703 Bindings::new_definition(Named_object
* old_object
, Named_object
* new_object
)
7705 if (new_object
->is_erroneous() && !old_object
->is_erroneous())
7709 switch (old_object
->classification())
7712 case Named_object::NAMED_OBJECT_UNINITIALIZED
:
7715 case Named_object::NAMED_OBJECT_ERRONEOUS
:
7718 case Named_object::NAMED_OBJECT_UNKNOWN
:
7720 Named_object
* real
= old_object
->unknown_value()->real_named_object();
7722 return this->new_definition(real
, new_object
);
7723 go_assert(!new_object
->is_unknown());
7724 old_object
->unknown_value()->set_real_named_object(new_object
);
7725 if (!new_object
->is_type_declaration()
7726 && !new_object
->is_function_declaration())
7727 this->named_objects_
.push_back(new_object
);
7731 case Named_object::NAMED_OBJECT_CONST
:
7734 case Named_object::NAMED_OBJECT_TYPE
:
7735 if (new_object
->is_type_declaration())
7739 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
7740 if (new_object
->is_type_declaration())
7742 if (new_object
->is_type())
7744 old_object
->set_type_value(new_object
->type_value());
7745 new_object
->type_value()->set_named_object(old_object
);
7746 this->named_objects_
.push_back(old_object
);
7751 case Named_object::NAMED_OBJECT_VAR
:
7752 case Named_object::NAMED_OBJECT_RESULT_VAR
:
7753 // We have already given an error in the parser for cases where
7754 // one parameter or result variable redeclares another one.
7755 if ((new_object
->is_variable()
7756 && new_object
->var_value()->is_parameter())
7757 || new_object
->is_result_variable())
7761 case Named_object::NAMED_OBJECT_SINK
:
7764 case Named_object::NAMED_OBJECT_FUNC
:
7765 if (new_object
->is_function_declaration())
7767 if (!new_object
->func_declaration_value()->asm_name().empty())
7768 go_error_at(Linemap::unknown_location(),
7769 ("sorry, not implemented: "
7770 "__asm__ for function definitions"));
7771 Function_type
* old_type
= old_object
->func_value()->type();
7772 Function_type
* new_type
=
7773 new_object
->func_declaration_value()->type();
7774 if (old_type
->is_valid_redeclaration(new_type
, &reason
))
7779 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
7781 if (new_object
->is_function())
7783 Function_type
* old_type
=
7784 old_object
->func_declaration_value()->type();
7785 Function_type
* new_type
= new_object
->func_value()->type();
7786 if (old_type
->is_valid_redeclaration(new_type
, &reason
))
7788 if (!old_object
->func_declaration_value()->asm_name().empty())
7789 go_error_at(Linemap::unknown_location(),
7790 ("sorry, not implemented: "
7791 "__asm__ for function definitions"));
7792 old_object
->set_function_value(new_object
->func_value());
7793 this->named_objects_
.push_back(old_object
);
7800 case Named_object::NAMED_OBJECT_PACKAGE
:
7804 std::string n
= old_object
->message_name();
7806 go_error_at(new_object
->location(), "redefinition of %qs", n
.c_str());
7808 go_error_at(new_object
->location(), "redefinition of %qs: %s", n
.c_str(),
7810 old_object
->set_is_redefinition();
7811 new_object
->set_is_redefinition();
7813 go_inform(old_object
->location(), "previous definition of %qs was here",
7819 // Add a named type.
7822 Bindings::add_named_type(Named_type
* named_type
)
7824 return this->add_named_object(named_type
->named_object());
7830 Bindings::add_function(const std::string
& name
, const Package
* package
,
7833 return this->add_named_object(Named_object::make_function(name
, package
,
7837 // Add a function declaration.
7840 Bindings::add_function_declaration(const std::string
& name
,
7841 const Package
* package
,
7842 Function_type
* type
,
7845 Named_object
* no
= Named_object::make_function_declaration(name
, package
,
7847 return this->add_named_object(no
);
7850 // Define a type which was previously declared.
7853 Bindings::define_type(Named_object
* no
, Named_type
* type
)
7855 no
->set_type_value(type
);
7856 this->named_objects_
.push_back(no
);
7859 // Mark all local variables as used. This is used for some types of
7863 Bindings::mark_locals_used()
7865 for (std::vector
<Named_object
*>::iterator p
= this->named_objects_
.begin();
7866 p
!= this->named_objects_
.end();
7868 if ((*p
)->is_variable())
7869 (*p
)->var_value()->set_is_used();
7872 // Traverse bindings.
7875 Bindings::traverse(Traverse
* traverse
, bool is_global
)
7877 unsigned int traverse_mask
= traverse
->traverse_mask();
7879 // We don't use an iterator because we permit the traversal to add
7880 // new global objects.
7881 const unsigned int e_or_t
= (Traverse::traverse_expressions
7882 | Traverse::traverse_types
);
7883 const unsigned int e_or_t_or_s
= (e_or_t
7884 | Traverse::traverse_statements
);
7885 for (size_t i
= 0; i
< this->named_objects_
.size(); ++i
)
7887 Named_object
* p
= this->named_objects_
[i
];
7888 int t
= TRAVERSE_CONTINUE
;
7889 switch (p
->classification())
7891 case Named_object::NAMED_OBJECT_CONST
:
7892 if ((traverse_mask
& Traverse::traverse_constants
) != 0)
7893 t
= traverse
->constant(p
, is_global
);
7894 if (t
== TRAVERSE_CONTINUE
7895 && (traverse_mask
& e_or_t
) != 0)
7897 Type
* tc
= p
->const_value()->type();
7899 && Type::traverse(tc
, traverse
) == TRAVERSE_EXIT
)
7900 return TRAVERSE_EXIT
;
7901 t
= p
->const_value()->traverse_expression(traverse
);
7905 case Named_object::NAMED_OBJECT_VAR
:
7906 case Named_object::NAMED_OBJECT_RESULT_VAR
:
7907 if ((traverse_mask
& Traverse::traverse_variables
) != 0)
7908 t
= traverse
->variable(p
);
7909 if (t
== TRAVERSE_CONTINUE
7910 && (traverse_mask
& e_or_t
) != 0)
7912 if (p
->is_result_variable()
7913 || p
->var_value()->has_type())
7915 Type
* tv
= (p
->is_variable()
7916 ? p
->var_value()->type()
7917 : p
->result_var_value()->type());
7919 && Type::traverse(tv
, traverse
) == TRAVERSE_EXIT
)
7920 return TRAVERSE_EXIT
;
7923 if (t
== TRAVERSE_CONTINUE
7924 && (traverse_mask
& e_or_t_or_s
) != 0
7925 && p
->is_variable())
7926 t
= p
->var_value()->traverse_expression(traverse
, traverse_mask
);
7929 case Named_object::NAMED_OBJECT_FUNC
:
7930 if ((traverse_mask
& Traverse::traverse_functions
) != 0)
7931 t
= traverse
->function(p
);
7933 if (t
== TRAVERSE_CONTINUE
7935 & (Traverse::traverse_variables
7936 | Traverse::traverse_constants
7937 | Traverse::traverse_functions
7938 | Traverse::traverse_blocks
7939 | Traverse::traverse_statements
7940 | Traverse::traverse_expressions
7941 | Traverse::traverse_types
)) != 0)
7942 t
= p
->func_value()->traverse(traverse
);
7945 case Named_object::NAMED_OBJECT_PACKAGE
:
7946 // These are traversed in Gogo::traverse.
7947 go_assert(is_global
);
7950 case Named_object::NAMED_OBJECT_TYPE
:
7951 if ((traverse_mask
& e_or_t
) != 0)
7952 t
= Type::traverse(p
->type_value(), traverse
);
7955 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
7956 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
7957 case Named_object::NAMED_OBJECT_UNKNOWN
:
7958 case Named_object::NAMED_OBJECT_ERRONEOUS
:
7961 case Named_object::NAMED_OBJECT_SINK
:
7966 if (t
== TRAVERSE_EXIT
)
7967 return TRAVERSE_EXIT
;
7970 // If we need to traverse types, check the function declarations,
7971 // which have types. Also check any methods of a type declaration.
7972 if ((traverse_mask
& e_or_t
) != 0)
7974 for (Bindings::const_declarations_iterator p
=
7975 this->begin_declarations();
7976 p
!= this->end_declarations();
7979 if (p
->second
->is_function_declaration())
7981 if (Type::traverse(p
->second
->func_declaration_value()->type(),
7984 return TRAVERSE_EXIT
;
7986 else if (p
->second
->is_type_declaration())
7988 const std::vector
<Named_object
*>* methods
=
7989 p
->second
->type_declaration_value()->methods();
7990 for (std::vector
<Named_object
*>::const_iterator pm
=
7992 pm
!= methods
->end();
7995 Named_object
* no
= *pm
;
7997 if (no
->is_function())
7998 t
= no
->func_value()->type();
7999 else if (no
->is_function_declaration())
8000 t
= no
->func_declaration_value()->type();
8003 if (Type::traverse(t
, traverse
) == TRAVERSE_EXIT
)
8004 return TRAVERSE_EXIT
;
8010 // Traverse function declarations when needed.
8011 if ((traverse_mask
& Traverse::traverse_func_declarations
) != 0)
8013 for (Bindings::const_declarations_iterator p
= this->begin_declarations();
8014 p
!= this->end_declarations();
8017 if (p
->second
->is_function_declaration())
8019 if (traverse
->function_declaration(p
->second
) == TRAVERSE_EXIT
)
8020 return TRAVERSE_EXIT
;
8025 return TRAVERSE_CONTINUE
;
8030 // Clear any references to this label.
8035 for (std::vector
<Bindings_snapshot
*>::iterator p
= this->refs_
.begin();
8036 p
!= this->refs_
.end();
8039 this->refs_
.clear();
8042 // Get the backend representation for a label.
8045 Label::get_backend_label(Translate_context
* context
)
8047 if (this->blabel_
== NULL
)
8049 Function
* function
= context
->function()->func_value();
8050 Bfunction
* bfunction
= function
->get_decl();
8051 this->blabel_
= context
->backend()->label(bfunction
, this->name_
,
8054 return this->blabel_
;
8057 // Return an expression for the address of this label.
8060 Label::get_addr(Translate_context
* context
, Location location
)
8062 Blabel
* label
= this->get_backend_label(context
);
8063 return context
->backend()->label_address(label
, location
);
8066 // Return the dummy label that represents any instance of the blank label.
8069 Label::create_dummy_label()
8071 static Label
* dummy_label
;
8072 if (dummy_label
== NULL
)
8074 dummy_label
= new Label("_");
8075 dummy_label
->set_is_used();
8080 // Class Unnamed_label.
8082 // Get the backend representation for an unnamed label.
8085 Unnamed_label::get_blabel(Translate_context
* context
)
8087 if (this->blabel_
== NULL
)
8089 Function
* function
= context
->function()->func_value();
8090 Bfunction
* bfunction
= function
->get_decl();
8091 this->blabel_
= context
->backend()->label(bfunction
, "",
8094 return this->blabel_
;
8097 // Return a statement which defines this unnamed label.
8100 Unnamed_label::get_definition(Translate_context
* context
)
8102 Blabel
* blabel
= this->get_blabel(context
);
8103 return context
->backend()->label_definition_statement(blabel
);
8106 // Return a goto statement to this unnamed label.
8109 Unnamed_label::get_goto(Translate_context
* context
, Location location
)
8111 Blabel
* blabel
= this->get_blabel(context
);
8112 return context
->backend()->goto_statement(blabel
, location
);
8117 Package::Package(const std::string
& pkgpath
,
8118 const std::string
& pkgpath_symbol
, Location location
)
8119 : pkgpath_(pkgpath
), pkgpath_symbol_(pkgpath_symbol
),
8120 package_name_(), bindings_(new Bindings(NULL
)),
8123 go_assert(!pkgpath
.empty());
8126 // Set the package name.
8129 Package::set_package_name(const std::string
& package_name
, Location location
)
8131 go_assert(!package_name
.empty());
8132 if (this->package_name_
.empty())
8133 this->package_name_
= package_name
;
8134 else if (this->package_name_
!= package_name
)
8135 go_error_at(location
,
8136 ("saw two different packages with "
8137 "the same package path %s: %s, %s"),
8138 this->pkgpath_
.c_str(), this->package_name_
.c_str(),
8139 package_name
.c_str());
8142 // Return the pkgpath symbol, which is a prefix for symbols defined in
8146 Package::pkgpath_symbol() const
8148 if (this->pkgpath_symbol_
.empty())
8149 return Gogo::pkgpath_for_symbol(this->pkgpath_
);
8150 return this->pkgpath_symbol_
;
8153 // Set the package path symbol.
8156 Package::set_pkgpath_symbol(const std::string
& pkgpath_symbol
)
8158 go_assert(!pkgpath_symbol
.empty());
8159 if (this->pkgpath_symbol_
.empty())
8160 this->pkgpath_symbol_
= pkgpath_symbol
;
8162 go_assert(this->pkgpath_symbol_
== pkgpath_symbol
);
8165 // Note that symbol from this package was and qualified by ALIAS.
8168 Package::note_usage(const std::string
& alias
) const
8170 Aliases::const_iterator p
= this->aliases_
.find(alias
);
8171 go_assert(p
!= this->aliases_
.end());
8172 p
->second
->note_usage();
8175 // Forget a given usage. If forgetting this usage means this package becomes
8176 // unused, report that error.
8179 Package::forget_usage(Expression
* usage
) const
8181 if (this->fake_uses_
.empty())
8184 std::set
<Expression
*>::iterator p
= this->fake_uses_
.find(usage
);
8185 go_assert(p
!= this->fake_uses_
.end());
8186 this->fake_uses_
.erase(p
);
8188 if (this->fake_uses_
.empty())
8189 go_error_at(this->location(), "imported and not used: %s",
8190 Gogo::message_name(this->package_name()).c_str());
8193 // Clear the used field for the next file. If the only usages of this package
8194 // are possibly fake, keep the fake usages for lowering.
8197 Package::clear_used()
8199 std::string dot_alias
= "." + this->package_name();
8200 Aliases::const_iterator p
= this->aliases_
.find(dot_alias
);
8201 if (p
!= this->aliases_
.end() && p
->second
->used() > this->fake_uses_
.size())
8202 this->fake_uses_
.clear();
8204 this->aliases_
.clear();
8208 Package::add_alias(const std::string
& alias
, Location location
)
8210 Aliases::const_iterator p
= this->aliases_
.find(alias
);
8211 if (p
== this->aliases_
.end())
8213 std::pair
<Aliases::iterator
, bool> ret
;
8214 ret
= this->aliases_
.insert(std::make_pair(alias
,
8215 new Package_alias(location
)));
8221 // Determine types of constants. Everything else in a package
8222 // (variables, function declarations) should already have a fixed
8223 // type. Constants may have abstract types.
8226 Package::determine_types()
8228 Bindings
* bindings
= this->bindings_
;
8229 for (Bindings::const_definitions_iterator p
= bindings
->begin_definitions();
8230 p
!= bindings
->end_definitions();
8233 if ((*p
)->is_const())
8234 (*p
)->const_value()->determine_type();
8242 Traverse::~Traverse()
8244 if (this->types_seen_
!= NULL
)
8245 delete this->types_seen_
;
8246 if (this->expressions_seen_
!= NULL
)
8247 delete this->expressions_seen_
;
8250 // Record that we are looking at a type, and return true if we have
8254 Traverse::remember_type(const Type
* type
)
8256 if (type
->is_error_type())
8258 go_assert((this->traverse_mask() & traverse_types
) != 0
8259 || (this->traverse_mask() & traverse_expressions
) != 0);
8260 // We mostly only have to remember named types. But it turns out
8261 // that an interface type can refer to itself without using a name
8262 // by relying on interface inheritance, as in
8263 // type I interface { F() interface{I} }
8264 if (type
->classification() != Type::TYPE_NAMED
8265 && type
->classification() != Type::TYPE_INTERFACE
)
8267 if (this->types_seen_
== NULL
)
8268 this->types_seen_
= new Types_seen();
8269 std::pair
<Types_seen::iterator
, bool> ins
= this->types_seen_
->insert(type
);
8273 // Record that we are looking at an expression, and return true if we
8274 // have already seen it. NB: this routine used to assert if the traverse
8275 // mask did not include expressions/types -- this is no longer the case,
8276 // since it can be useful to remember specific expressions during
8277 // walks that only cover statements.
8280 Traverse::remember_expression(const Expression
* expression
)
8282 if (this->expressions_seen_
== NULL
)
8283 this->expressions_seen_
= new Expressions_seen();
8284 std::pair
<Expressions_seen::iterator
, bool> ins
=
8285 this->expressions_seen_
->insert(expression
);
8289 // The default versions of these functions should never be called: the
8290 // traversal mask indicates which functions may be called.
8293 Traverse::variable(Named_object
*)
8299 Traverse::constant(Named_object
*, bool)
8305 Traverse::function(Named_object
*)
8311 Traverse::block(Block
*)
8317 Traverse::statement(Block
*, size_t*, Statement
*)
8323 Traverse::expression(Expression
**)
8329 Traverse::type(Type
*)
8335 Traverse::function_declaration(Named_object
*)
8340 // Class Statement_inserter.
8343 Statement_inserter::insert(Statement
* s
)
8345 if (this->block_
!= NULL
)
8347 go_assert(this->pindex_
!= NULL
);
8348 this->block_
->insert_statement_before(*this->pindex_
, s
);
8351 else if (this->var_
!= NULL
)
8352 this->var_
->add_preinit_statement(this->gogo_
, s
);
8354 go_assert(saw_errors());