Branch data Line data Source code
1 : : // gogo.cc -- Go frontend parsed representation.
2 : :
3 : : // Copyright 2009 The Go Authors. All rights reserved.
4 : : // Use of this source code is governed by a BSD-style
5 : : // license that can be found in the LICENSE file.
6 : :
7 : : #include "go-system.h"
8 : :
9 : : #include <fstream>
10 : :
11 : : #include "filenames.h"
12 : :
13 : : #include "go-c.h"
14 : : #include "go-diagnostics.h"
15 : : #include "go-encode-id.h"
16 : : #include "go-dump.h"
17 : : #include "go-optimize.h"
18 : : #include "lex.h"
19 : : #include "types.h"
20 : : #include "statements.h"
21 : : #include "expressions.h"
22 : : #include "runtime.h"
23 : : #include "import.h"
24 : : #include "export.h"
25 : : #include "backend.h"
26 : : #include "gogo.h"
27 : :
28 : : // Class Gogo.
29 : :
30 : 4646 : Gogo::Gogo(Backend* backend, Linemap* linemap, int, int pointer_size)
31 : 4646 : : backend_(backend),
32 : 4646 : linemap_(linemap),
33 : 4646 : package_(NULL),
34 : 4646 : functions_(),
35 : 4646 : globals_(new Bindings(NULL)),
36 : 4646 : file_block_names_(),
37 : 4646 : imports_(),
38 : 4646 : imported_unsafe_(false),
39 : 4646 : current_file_imported_unsafe_(false),
40 : 4646 : current_file_imported_embed_(false),
41 : 4646 : packages_(),
42 : 4646 : init_functions_(),
43 : 4646 : var_deps_(),
44 : 4646 : need_init_fn_(false),
45 : 4646 : init_fn_name_(),
46 : 4646 : imported_init_fns_(),
47 : 4646 : pkgpath_(),
48 : 4646 : pkgpath_symbol_(),
49 : 4646 : prefix_(),
50 : 4646 : pkgpath_set_(false),
51 : 4646 : pkgpath_from_option_(false),
52 : 4646 : prefix_from_option_(false),
53 : 4646 : relative_import_path_(),
54 : 4646 : c_header_(),
55 : 4646 : import_map_(),
56 : 4646 : package_file_(),
57 : 4646 : embed_patterns_(),
58 : 4646 : embed_files_(),
59 : 4646 : check_divide_by_zero_(true),
60 : 4646 : check_divide_overflow_(true),
61 : 4646 : compiling_runtime_(false),
62 : 4646 : debug_escape_level_(0),
63 : 4646 : debug_optimization_(false),
64 : 4646 : nil_check_size_threshold_(4096),
65 : 4646 : need_eqtype_(false),
66 : 4646 : verify_types_(),
67 : 4646 : interface_types_(),
68 : 4646 : specific_type_functions_(),
69 : 4646 : specific_type_functions_are_written_(false),
70 : 4646 : named_types_are_converted_(false),
71 : 4646 : analysis_sets_(),
72 : 4646 : gc_roots_(),
73 : 4646 : type_descriptors_(),
74 : 4646 : imported_inlinable_functions_(),
75 : 4646 : imported_inline_functions_()
76 : : {
77 : 4646 : const Location loc = Linemap::predeclared_location();
78 : :
79 : 4646 : Named_type* uint8_type = Type::make_integer_type("uint8", true, 8,
80 : : RUNTIME_TYPE_KIND_UINT8);
81 : 4646 : this->add_named_type(uint8_type);
82 : 4646 : this->add_named_type(Type::make_integer_type("uint16", true, 16,
83 : : RUNTIME_TYPE_KIND_UINT16));
84 : 4646 : this->add_named_type(Type::make_integer_type("uint32", true, 32,
85 : : RUNTIME_TYPE_KIND_UINT32));
86 : 4646 : this->add_named_type(Type::make_integer_type("uint64", true, 64,
87 : : RUNTIME_TYPE_KIND_UINT64));
88 : :
89 : 4646 : this->add_named_type(Type::make_integer_type("int8", false, 8,
90 : : RUNTIME_TYPE_KIND_INT8));
91 : 4646 : this->add_named_type(Type::make_integer_type("int16", false, 16,
92 : : RUNTIME_TYPE_KIND_INT16));
93 : 4646 : Named_type* int32_type = Type::make_integer_type("int32", false, 32,
94 : : RUNTIME_TYPE_KIND_INT32);
95 : 4646 : this->add_named_type(int32_type);
96 : 4646 : this->add_named_type(Type::make_integer_type("int64", false, 64,
97 : : RUNTIME_TYPE_KIND_INT64));
98 : :
99 : 4646 : this->add_named_type(Type::make_float_type("float32", 32,
100 : : RUNTIME_TYPE_KIND_FLOAT32));
101 : 4646 : this->add_named_type(Type::make_float_type("float64", 64,
102 : : RUNTIME_TYPE_KIND_FLOAT64));
103 : :
104 : 4646 : this->add_named_type(Type::make_complex_type("complex64", 64,
105 : : RUNTIME_TYPE_KIND_COMPLEX64));
106 : 4646 : this->add_named_type(Type::make_complex_type("complex128", 128,
107 : : RUNTIME_TYPE_KIND_COMPLEX128));
108 : :
109 : 4646 : int int_type_size = pointer_size;
110 : 4646 : if (int_type_size < 32)
111 : : int_type_size = 32;
112 : 4646 : this->add_named_type(Type::make_integer_type("uint", true,
113 : : int_type_size,
114 : : RUNTIME_TYPE_KIND_UINT));
115 : 4646 : Named_type* int_type = Type::make_integer_type("int", false, int_type_size,
116 : : RUNTIME_TYPE_KIND_INT);
117 : 4646 : this->add_named_type(int_type);
118 : :
119 : 4646 : this->add_named_type(Type::make_integer_type("uintptr", true,
120 : : pointer_size,
121 : : RUNTIME_TYPE_KIND_UINTPTR));
122 : :
123 : : // "byte" is an alias for "uint8".
124 : 9292 : uint8_type->integer_type()->set_is_byte();
125 : 4646 : this->add_named_type(Type::make_integer_type_alias("byte", uint8_type));
126 : :
127 : : // "rune" is an alias for "int32".
128 : 9292 : int32_type->integer_type()->set_is_rune();
129 : 4646 : this->add_named_type(Type::make_integer_type_alias("rune", int32_type));
130 : :
131 : 4646 : this->add_named_type(Type::make_named_bool_type());
132 : :
133 : 4646 : this->add_named_type(Type::make_named_string_type());
134 : :
135 : : // "error" is interface { Error() string }.
136 : 4646 : {
137 : 4646 : Typed_identifier_list *methods = new Typed_identifier_list;
138 : 4646 : Typed_identifier_list *results = new Typed_identifier_list;
139 : 9292 : results->push_back(Typed_identifier("", Type::lookup_string_type(), loc));
140 : 4646 : Type *method_type = Type::make_function_type(NULL, NULL, results, loc);
141 : 9292 : methods->push_back(Typed_identifier("Error", method_type, loc));
142 : 4646 : Interface_type *error_iface = Type::make_interface_type(methods, loc);
143 : 4646 : error_iface->finalize_methods();
144 : 4646 : Named_type *error_type = Named_object::make_type("error", NULL, error_iface, loc)->type_value();
145 : 4646 : this->add_named_type(error_type);
146 : : }
147 : :
148 : : // "any" is an alias for the empty interface type.
149 : 4646 : {
150 : 4646 : Type* empty = Type::make_empty_interface_type(loc);
151 : 4646 : Named_object* no = Named_object::make_type("any", NULL, empty, loc);
152 : 4646 : Named_type* nt = no->type_value();
153 : 4646 : nt->set_is_alias();
154 : 4646 : this->add_named_type(nt);
155 : : }
156 : :
157 : 13938 : this->globals_->add_constant(Typed_identifier("true",
158 : : Type::make_boolean_type(),
159 : 9292 : loc),
160 : : NULL,
161 : : Expression::make_boolean(true, loc),
162 : : 0);
163 : 13938 : this->globals_->add_constant(Typed_identifier("false",
164 : : Type::make_boolean_type(),
165 : 9292 : loc),
166 : : NULL,
167 : : Expression::make_boolean(false, loc),
168 : : 0);
169 : :
170 : 13938 : this->globals_->add_constant(Typed_identifier("nil", Type::make_nil_type(),
171 : 9292 : loc),
172 : : NULL,
173 : : Expression::make_nil(loc),
174 : : 0);
175 : :
176 : 4646 : Type* abstract_int_type = Type::make_abstract_integer_type();
177 : 9292 : this->globals_->add_constant(Typed_identifier("iota", abstract_int_type,
178 : 4646 : loc),
179 : : NULL,
180 : : Expression::make_iota(),
181 : : 0);
182 : :
183 : 4646 : Function_type* new_type = Type::make_function_type(NULL, NULL, NULL, loc);
184 : 4646 : new_type->set_is_varargs();
185 : 4646 : new_type->set_is_builtin();
186 : 4646 : this->globals_->add_function_declaration("new", NULL, new_type, loc);
187 : :
188 : 4646 : Function_type* make_type = Type::make_function_type(NULL, NULL, NULL, loc);
189 : 4646 : make_type->set_is_varargs();
190 : 4646 : make_type->set_is_builtin();
191 : 4646 : this->globals_->add_function_declaration("make", NULL, make_type, loc);
192 : :
193 : 4646 : Typed_identifier_list* len_result = new Typed_identifier_list();
194 : 9292 : len_result->push_back(Typed_identifier("", int_type, loc));
195 : 4646 : Function_type* len_type = Type::make_function_type(NULL, NULL, len_result,
196 : : loc);
197 : 4646 : len_type->set_is_builtin();
198 : 4646 : this->globals_->add_function_declaration("len", NULL, len_type, loc);
199 : :
200 : 4646 : Typed_identifier_list* cap_result = new Typed_identifier_list();
201 : 9292 : cap_result->push_back(Typed_identifier("", int_type, loc));
202 : 4646 : Function_type* cap_type = Type::make_function_type(NULL, NULL, len_result,
203 : : loc);
204 : 4646 : cap_type->set_is_builtin();
205 : 4646 : this->globals_->add_function_declaration("cap", NULL, cap_type, loc);
206 : :
207 : 4646 : Function_type* print_type = Type::make_function_type(NULL, NULL, NULL, loc);
208 : 4646 : print_type->set_is_varargs();
209 : 4646 : print_type->set_is_builtin();
210 : 4646 : this->globals_->add_function_declaration("print", NULL, print_type, loc);
211 : :
212 : 4646 : print_type = Type::make_function_type(NULL, NULL, NULL, loc);
213 : 4646 : print_type->set_is_varargs();
214 : 4646 : print_type->set_is_builtin();
215 : 4646 : this->globals_->add_function_declaration("println", NULL, print_type, loc);
216 : :
217 : 4646 : Type *empty = Type::make_empty_interface_type(loc);
218 : 4646 : Typed_identifier_list* panic_parms = new Typed_identifier_list();
219 : 9292 : panic_parms->push_back(Typed_identifier("e", empty, loc));
220 : 4646 : Function_type *panic_type = Type::make_function_type(NULL, panic_parms,
221 : : NULL, loc);
222 : 4646 : panic_type->set_is_builtin();
223 : 4646 : this->globals_->add_function_declaration("panic", NULL, panic_type, loc);
224 : :
225 : 4646 : Typed_identifier_list* recover_result = new Typed_identifier_list();
226 : 9292 : recover_result->push_back(Typed_identifier("", empty, loc));
227 : 4646 : Function_type* recover_type = Type::make_function_type(NULL, NULL,
228 : : recover_result,
229 : : loc);
230 : 4646 : recover_type->set_is_builtin();
231 : 4646 : this->globals_->add_function_declaration("recover", NULL, recover_type, loc);
232 : :
233 : 4646 : Function_type* close_type = Type::make_function_type(NULL, NULL, NULL, loc);
234 : 4646 : close_type->set_is_varargs();
235 : 4646 : close_type->set_is_builtin();
236 : 4646 : this->globals_->add_function_declaration("close", NULL, close_type, loc);
237 : :
238 : 4646 : Typed_identifier_list* copy_result = new Typed_identifier_list();
239 : 9292 : copy_result->push_back(Typed_identifier("", int_type, loc));
240 : 4646 : Function_type* copy_type = Type::make_function_type(NULL, NULL,
241 : : copy_result, loc);
242 : 4646 : copy_type->set_is_varargs();
243 : 4646 : copy_type->set_is_builtin();
244 : 4646 : this->globals_->add_function_declaration("copy", NULL, copy_type, loc);
245 : :
246 : 4646 : Function_type* append_type = Type::make_function_type(NULL, NULL, NULL, loc);
247 : 4646 : append_type->set_is_varargs();
248 : 4646 : append_type->set_is_builtin();
249 : 4646 : this->globals_->add_function_declaration("append", NULL, append_type, loc);
250 : :
251 : 4646 : Function_type* complex_type = Type::make_function_type(NULL, NULL, NULL, loc);
252 : 4646 : complex_type->set_is_varargs();
253 : 4646 : complex_type->set_is_builtin();
254 : 4646 : this->globals_->add_function_declaration("complex", NULL, complex_type, loc);
255 : :
256 : 4646 : Function_type* real_type = Type::make_function_type(NULL, NULL, NULL, loc);
257 : 4646 : real_type->set_is_varargs();
258 : 4646 : real_type->set_is_builtin();
259 : 4646 : this->globals_->add_function_declaration("real", NULL, real_type, loc);
260 : :
261 : 4646 : Function_type* imag_type = Type::make_function_type(NULL, NULL, NULL, loc);
262 : 4646 : imag_type->set_is_varargs();
263 : 4646 : imag_type->set_is_builtin();
264 : 4646 : this->globals_->add_function_declaration("imag", NULL, imag_type, loc);
265 : :
266 : 4646 : Function_type* delete_type = Type::make_function_type(NULL, NULL, NULL, loc);
267 : 4646 : delete_type->set_is_varargs();
268 : 4646 : delete_type->set_is_builtin();
269 : 4646 : this->globals_->add_function_declaration("delete", NULL, delete_type, loc);
270 : 4646 : }
271 : :
272 : : std::string
273 : 241607 : Gogo::pkgpath_for_symbol(const std::string& pkgpath)
274 : : {
275 : 241607 : go_assert(!pkgpath.empty());
276 : 241607 : return go_encode_id(pkgpath);
277 : : }
278 : :
279 : : // Return a hash code for a string, given a starting hash.
280 : :
281 : : unsigned int
282 : 13119353 : Gogo::hash_string(const std::string& s, unsigned int h)
283 : : {
284 : 13119353 : const char* p = s.data();
285 : 13119353 : size_t len = s.length();
286 : 116448895 : for (; len > 0; --len)
287 : : {
288 : 103329542 : h ^= *p++;
289 : 103329542 : h*= 16777619;
290 : : }
291 : 13119353 : return h;
292 : : }
293 : :
294 : : // Get the package path to use for type reflection data. This should
295 : : // ideally be unique across the entire link.
296 : :
297 : : const std::string&
298 : 7559219 : Gogo::pkgpath() const
299 : : {
300 : 7559219 : go_assert(this->pkgpath_set_);
301 : 7559219 : return this->pkgpath_;
302 : : }
303 : :
304 : : // Set the package path from the -fgo-pkgpath command line option.
305 : :
306 : : void
307 : 2014 : Gogo::set_pkgpath(const std::string& arg)
308 : : {
309 : 2014 : go_assert(!this->pkgpath_set_);
310 : 2014 : this->pkgpath_ = arg;
311 : 2014 : this->pkgpath_set_ = true;
312 : 2014 : this->pkgpath_from_option_ = true;
313 : 2014 : }
314 : :
315 : : // Get the package path to use for symbol names.
316 : :
317 : : const std::string&
318 : 199256 : Gogo::pkgpath_symbol() const
319 : : {
320 : 199256 : go_assert(this->pkgpath_set_);
321 : 199256 : return this->pkgpath_symbol_;
322 : : }
323 : :
324 : : // Set the unique prefix to use to determine the package path, from
325 : : // the -fgo-prefix command line option.
326 : :
327 : : void
328 : 0 : Gogo::set_prefix(const std::string& arg)
329 : : {
330 : 0 : go_assert(!this->prefix_from_option_);
331 : 0 : this->prefix_ = arg;
332 : 0 : this->prefix_from_option_ = true;
333 : 0 : }
334 : :
335 : : // Munge name for use in an error message.
336 : :
337 : : std::string
338 : 275656 : Gogo::message_name(const std::string& name)
339 : : {
340 : 275656 : return go_localize_identifier(Gogo::unpack_hidden_name(name).c_str());
341 : : }
342 : :
343 : : // Get the package name.
344 : :
345 : : const std::string&
346 : 349540 : Gogo::package_name() const
347 : : {
348 : 349540 : go_assert(this->package_ != NULL);
349 : 349540 : return this->package_->package_name();
350 : : }
351 : :
352 : : // Set the package name.
353 : :
354 : : void
355 : 12707 : Gogo::set_package_name(const std::string& package_name,
356 : : Location location)
357 : : {
358 : 12707 : if (this->package_ != NULL)
359 : : {
360 : 8061 : if (this->package_->package_name() != package_name)
361 : 0 : go_error_at(location, "expected package %qs",
362 : 0 : Gogo::message_name(this->package_->package_name()).c_str());
363 : 8061 : return;
364 : : }
365 : :
366 : : // Now that we know the name of the package we are compiling, set
367 : : // the package path to use for reflect.Type.PkgPath and global
368 : : // symbol names.
369 : 4646 : if (this->pkgpath_set_)
370 : 2014 : this->pkgpath_symbol_ = Gogo::pkgpath_for_symbol(this->pkgpath_);
371 : : else
372 : : {
373 : 2632 : if (!this->prefix_from_option_ && package_name == "main")
374 : : {
375 : 1889 : this->pkgpath_ = package_name;
376 : 1889 : this->pkgpath_symbol_ = Gogo::pkgpath_for_symbol(package_name);
377 : : }
378 : : else
379 : : {
380 : 743 : if (!this->prefix_from_option_)
381 : 743 : this->prefix_ = "go";
382 : 743 : this->pkgpath_ = this->prefix_ + '.' + package_name;
383 : 1486 : this->pkgpath_symbol_ = (Gogo::pkgpath_for_symbol(this->prefix_) + '.'
384 : 2229 : + Gogo::pkgpath_for_symbol(package_name));
385 : : }
386 : 2632 : this->pkgpath_set_ = true;
387 : : }
388 : :
389 : 9292 : this->package_ = this->register_package(this->pkgpath_,
390 : 4646 : this->pkgpath_symbol_, location);
391 : 4646 : this->package_->set_package_name(package_name, location);
392 : :
393 : 4646 : if (this->is_main_package())
394 : : {
395 : : // Declare "main" as a function which takes no parameters and
396 : : // returns no value.
397 : 1889 : Location uloc = Linemap::unknown_location();
398 : 1889 : this->declare_function(Gogo::pack_hidden_name("main", false),
399 : : Type::make_function_type (NULL, NULL, NULL, uloc),
400 : : uloc);
401 : : }
402 : : }
403 : :
404 : : // Return whether this is the "main" package. This is not true if
405 : : // -fgo-pkgpath or -fgo-prefix was used.
406 : :
407 : : bool
408 : 39039 : Gogo::is_main_package() const
409 : : {
410 : 39039 : return (this->package_name() == "main"
411 : 19480 : && !this->pkgpath_from_option_
412 : 58467 : && !this->prefix_from_option_);
413 : : }
414 : :
415 : : // Import a package.
416 : :
417 : : void
418 : 42242 : Gogo::import_package(const std::string& filename,
419 : : const std::string& local_name,
420 : : bool is_local_name_exported,
421 : : bool must_exist,
422 : : Location location)
423 : : {
424 : 42242 : if (filename.empty())
425 : : {
426 : 1 : go_error_at(location, "import path is empty");
427 : 20435 : return;
428 : : }
429 : :
430 : 42241 : const char *pf = filename.data();
431 : 42241 : const char *pend = pf + filename.length();
432 : 406477 : while (pf < pend)
433 : : {
434 : 364237 : unsigned int c;
435 : 364237 : int adv = Lex::fetch_char(pf, &c);
436 : 364237 : if (adv == 0)
437 : : {
438 : 0 : go_error_at(location, "import path contains invalid UTF-8 sequence");
439 : 1 : return;
440 : : }
441 : 364237 : if (c == '\0')
442 : : {
443 : 0 : go_error_at(location, "import path contains NUL");
444 : 0 : return;
445 : : }
446 : 364237 : if (c < 0x20 || c == 0x7f)
447 : : {
448 : 1 : go_error_at(location, "import path contains control character");
449 : 1 : return;
450 : : }
451 : 364236 : if (c == '\\')
452 : : {
453 : 0 : go_error_at(location, "import path contains backslash; use slash");
454 : 0 : return;
455 : : }
456 : 364236 : if (Lex::is_unicode_space(c))
457 : : {
458 : 0 : go_error_at(location, "import path contains space character");
459 : 0 : return;
460 : : }
461 : 364236 : if (c < 0x7f && strchr("!\"#$%&'()*,:;<=>?[]^`{|}", c) != NULL)
462 : : {
463 : 0 : go_error_at(location,
464 : : "import path contains invalid character '%c'", c);
465 : 0 : return;
466 : : }
467 : 364236 : pf += adv;
468 : : }
469 : :
470 : 42240 : if (IS_ABSOLUTE_PATH(filename.c_str()))
471 : : {
472 : 0 : go_error_at(location, "import path cannot be absolute path");
473 : 0 : return;
474 : : }
475 : :
476 : 42240 : if (local_name == "init")
477 : 1 : go_error_at(location, "cannot import package as init");
478 : :
479 : 42240 : if (filename == "unsafe")
480 : : {
481 : 1471 : this->import_unsafe(local_name, is_local_name_exported, location);
482 : 1471 : this->current_file_imported_unsafe_ = true;
483 : 1471 : return;
484 : : }
485 : :
486 : 40769 : if (filename == "embed")
487 : 8 : this->current_file_imported_embed_ = true;
488 : :
489 : 40769 : Imports::const_iterator p = this->imports_.find(filename);
490 : 40769 : if (p != this->imports_.end())
491 : : {
492 : 18951 : Package* package = p->second;
493 : 18951 : package->set_location(location);
494 : 18951 : std::string ln = local_name;
495 : 18951 : bool is_ln_exported = is_local_name_exported;
496 : 18951 : if (ln.empty())
497 : : {
498 : 18415 : ln = package->package_name();
499 : 18415 : go_assert(!ln.empty());
500 : 18415 : is_ln_exported = Lex::is_exported_name(ln);
501 : : }
502 : 18951 : if (ln == "_")
503 : : ;
504 : 18842 : else if (ln == ".")
505 : : {
506 : 329 : Bindings* bindings = package->bindings();
507 : 62651 : for (Bindings::const_declarations_iterator pd =
508 : 329 : bindings->begin_declarations();
509 : 62651 : pd != bindings->end_declarations();
510 : 62322 : ++pd)
511 : 62322 : this->add_dot_import_object(pd->second);
512 : 329 : std::string dot_alias = "." + package->package_name();
513 : 329 : package->add_alias(dot_alias, location);
514 : 329 : }
515 : : else
516 : : {
517 : 18513 : package->add_alias(ln, location);
518 : 18513 : ln = this->pack_hidden_name(ln, is_ln_exported);
519 : 18513 : this->package_->bindings()->add_package(ln, package);
520 : : }
521 : 18951 : return;
522 : 18951 : }
523 : :
524 : : // If we are using an importcfg file we have to check two mappings.
525 : : // IMPORT_MAP_ is a mapping from package path to real package path,
526 : : // for vendoring. PACKAGE_FILE_ is a mapping from package path to
527 : : // file name, to find the file in the build cache.
528 : 21818 : std::string path = filename;
529 : 21818 : Unordered_map(std::string, std::string)::const_iterator pi;
530 : 21818 : pi = this->import_map_.find(filename);
531 : 21818 : if (pi != this->import_map_.end())
532 : 19 : path = pi->second;
533 : 21818 : pi = this->package_file_.find(path);
534 : 21818 : if (pi != this->package_file_.end())
535 : 702 : path = pi->second;
536 : :
537 : 43636 : Import::Stream* stream = Import::open_package(path, location,
538 : 21818 : this->relative_import_path_);
539 : 21818 : if (stream == NULL)
540 : : {
541 : 10 : if (must_exist)
542 : 0 : go_error_at(location, "import file %qs not found", filename.c_str());
543 : 10 : return;
544 : : }
545 : :
546 : 21808 : Import* imp = new Import(stream, location);
547 : 21808 : imp->register_builtin_types(this);
548 : 21808 : Package* package = imp->import(this, local_name, is_local_name_exported);
549 : 21808 : if (package != NULL)
550 : : {
551 : 21808 : if (package->pkgpath() == this->pkgpath())
552 : 0 : go_error_at(location,
553 : : ("imported package uses same package path as package "
554 : : "being compiled (see %<-fgo-pkgpath%> option)"));
555 : :
556 : 43616 : this->imports_.insert(std::make_pair(filename, package));
557 : : }
558 : :
559 : 21808 : imp->clear_stream();
560 : 21808 : delete stream;
561 : :
562 : : // FIXME: we never delete imp; we may need it for inlinable functions.
563 : 21818 : }
564 : :
565 : : Import_init *
566 : 1549811 : Gogo::lookup_init(const std::string& init_name)
567 : : {
568 : 1549811 : Import_init tmp("", init_name, -1);
569 : 1549811 : Import_init_set::iterator it = this->imported_init_fns_.find(&tmp);
570 : 1549811 : return (it != this->imported_init_fns_.end()) ? *it : NULL;
571 : 1549811 : }
572 : :
573 : : // Add an import control function for an imported package to the list.
574 : :
575 : : void
576 : 660202 : Gogo::add_import_init_fn(const std::string& package_name,
577 : : const std::string& init_name, int prio)
578 : : {
579 : 30250330 : for (Import_init_set::iterator p =
580 : 660202 : this->imported_init_fns_.begin();
581 : 30910532 : p != this->imported_init_fns_.end();
582 : 30250330 : ++p)
583 : : {
584 : 30748345 : Import_init *ii = (*p);
585 : 30748345 : if (ii->init_name() == init_name)
586 : : {
587 : : // If a test of package P1, built as part of package P1,
588 : : // imports package P2, and P2 imports P1 (perhaps
589 : : // indirectly), then we will see the same import name with
590 : : // different import priorities. That is OK, so don't give
591 : : // an error about it.
592 : 498015 : if (ii->package_name() != package_name)
593 : : {
594 : 0 : go_error_at(Linemap::unknown_location(),
595 : : "duplicate package initialization name %qs",
596 : 0 : Gogo::message_name(init_name).c_str());
597 : 0 : go_inform(Linemap::unknown_location(), "used by package %qs",
598 : 0 : Gogo::message_name(ii->package_name()).c_str());
599 : 0 : go_inform(Linemap::unknown_location(), " and by package %qs",
600 : 0 : Gogo::message_name(package_name).c_str());
601 : : }
602 : 498015 : ii->set_priority(prio);
603 : 498015 : return;
604 : : }
605 : : }
606 : :
607 : 162187 : Import_init* nii = new Import_init(package_name, init_name, prio);
608 : 162187 : this->imported_init_fns_.insert(nii);
609 : : }
610 : :
611 : : // Return whether we are at the global binding level.
612 : :
613 : : bool
614 : 711022 : Gogo::in_global_scope() const
615 : : {
616 : 711022 : return this->functions_.empty();
617 : : }
618 : :
619 : : // Return the current binding contour.
620 : :
621 : : Bindings*
622 : 808761 : Gogo::current_bindings()
623 : : {
624 : 808761 : if (!this->functions_.empty())
625 : 388528 : return this->functions_.back().blocks.back()->bindings();
626 : 420233 : else if (this->package_ != NULL)
627 : 322667 : return this->package_->bindings();
628 : : else
629 : 97566 : return this->globals_;
630 : : }
631 : :
632 : : const Bindings*
633 : 0 : Gogo::current_bindings() const
634 : : {
635 : 0 : if (!this->functions_.empty())
636 : 0 : return this->functions_.back().blocks.back()->bindings();
637 : 0 : else if (this->package_ != NULL)
638 : 0 : return this->package_->bindings();
639 : : else
640 : 0 : return this->globals_;
641 : : }
642 : :
643 : : void
644 : 62428 : Gogo::update_init_priority(Import_init* ii,
645 : : std::set<const Import_init *>* visited)
646 : : {
647 : 62428 : visited->insert(ii);
648 : 62428 : int succ_prior = -1;
649 : :
650 : 445578 : for (std::set<std::string>::const_iterator pci =
651 : 62428 : ii->precursors().begin();
652 : 508006 : pci != ii->precursors().end();
653 : 445578 : ++pci)
654 : : {
655 : 445578 : Import_init* succ = this->lookup_init(*pci);
656 : 445578 : if (visited->find(succ) == visited->end())
657 : 32671 : update_init_priority(succ, visited);
658 : 445578 : succ_prior = std::max(succ_prior, succ->priority());
659 : : }
660 : 62428 : if (ii->priority() <= succ_prior)
661 : 62428 : ii->set_priority(succ_prior + 1);
662 : 62428 : }
663 : :
664 : : void
665 : 1879 : Gogo::recompute_init_priorities()
666 : : {
667 : 1879 : std::set<Import_init *> nonroots;
668 : :
669 : 62428 : for (Import_init_set::const_iterator p =
670 : 1879 : this->imported_init_fns_.begin();
671 : 64307 : p != this->imported_init_fns_.end();
672 : 62428 : ++p)
673 : : {
674 : 62428 : const Import_init *ii = *p;
675 : 508006 : for (std::set<std::string>::const_iterator pci =
676 : 62428 : ii->precursors().begin();
677 : 508006 : pci != ii->precursors().end();
678 : 445578 : ++pci)
679 : : {
680 : 445578 : Import_init* ii_init = this->lookup_init(*pci);
681 : 445578 : nonroots.insert(ii_init);
682 : : }
683 : : }
684 : :
685 : : // Recursively update priorities starting at roots.
686 : 1879 : std::set<const Import_init*> visited;
687 : 62428 : for (Import_init_set::iterator p =
688 : 1879 : this->imported_init_fns_.begin();
689 : 64307 : p != this->imported_init_fns_.end();
690 : 62428 : ++p)
691 : : {
692 : 62428 : Import_init* ii = *p;
693 : 62428 : if (nonroots.find(ii) != nonroots.end())
694 : 32671 : continue;
695 : 29757 : update_init_priority(ii, &visited);
696 : : }
697 : 1879 : }
698 : :
699 : : // Add statements to INIT_STMTS which run the initialization
700 : : // functions for imported packages. This is only used for the "main"
701 : : // package.
702 : :
703 : : void
704 : 1889 : Gogo::init_imports(std::vector<Bstatement*>& init_stmts, Bfunction *bfunction)
705 : : {
706 : 1889 : go_assert(this->is_main_package());
707 : :
708 : 1889 : if (this->imported_init_fns_.empty())
709 : 10 : return;
710 : :
711 : 1879 : Location unknown_loc = Linemap::unknown_location();
712 : 1879 : Function_type* func_type =
713 : 1879 : Type::make_function_type(NULL, NULL, NULL, unknown_loc);
714 : 1879 : Btype* fntype = func_type->get_backend_fntype(this);
715 : :
716 : : // Recompute init priorities based on a walk of the init graph.
717 : 1879 : recompute_init_priorities();
718 : :
719 : : // We must call them in increasing priority order.
720 : 1879 : std::vector<const Import_init*> v;
721 : 62428 : for (Import_init_set::const_iterator p =
722 : 1879 : this->imported_init_fns_.begin();
723 : 64307 : p != this->imported_init_fns_.end();
724 : 62428 : ++p)
725 : : {
726 : : // Don't include dummy inits. They are not real functions.
727 : 62428 : if ((*p)->is_dummy())
728 : 27184 : continue;
729 : 35244 : if ((*p)->priority() < 0)
730 : 0 : go_error_at(Linemap::unknown_location(),
731 : : "internal error: failed to set init priority for %s",
732 : 0 : (*p)->package_name().c_str());
733 : 35244 : v.push_back(*p);
734 : : }
735 : 1879 : std::sort(v.begin(), v.end(), priority_compare);
736 : :
737 : : // We build calls to the init functions, which take no arguments.
738 : 1879 : std::vector<Bexpression*> empty_args;
739 : 1879 : for (std::vector<const Import_init*>::const_iterator p = v.begin();
740 : 37123 : p != v.end();
741 : 35244 : ++p)
742 : : {
743 : 35244 : const Import_init* ii = *p;
744 : 35244 : std::string user_name = ii->package_name() + ".init";
745 : 35244 : const std::string& init_name(ii->init_name());
746 : 35244 : const unsigned int flags =
747 : : (Backend::function_is_visible
748 : : | Backend::function_is_declaration
749 : : | Backend::function_is_inlinable);
750 : 35244 : Bfunction* pfunc = this->backend()->function(fntype, user_name, init_name,
751 : : flags, unknown_loc);
752 : 35244 : Bexpression* pfunc_code =
753 : 35244 : this->backend()->function_code_expression(pfunc, unknown_loc);
754 : 35244 : Bexpression* pfunc_call =
755 : 35244 : this->backend()->call_expression(bfunction, pfunc_code, empty_args,
756 : : NULL, unknown_loc);
757 : 35244 : init_stmts.push_back(this->backend()->expression_statement(bfunction,
758 : : pfunc_call));
759 : 35244 : }
760 : 1879 : }
761 : :
762 : : // Register global variables with the garbage collector. We need to
763 : : // register all variables which can hold a pointer value. They become
764 : : // roots during the mark phase. We build a struct that is easy to
765 : : // hook into a list of roots.
766 : :
767 : : // type gcRoot struct {
768 : : // decl unsafe.Pointer // Pointer to variable.
769 : : // size uintptr // Total size of variable.
770 : : // ptrdata uintptr // Length of variable's gcdata.
771 : : // gcdata *byte // Pointer mask.
772 : : // }
773 : : //
774 : : // type gcRootList struct {
775 : : // next *gcRootList
776 : : // count int
777 : : // roots [...]gcRoot
778 : : // }
779 : :
780 : : // The last entry in the roots array has a NULL decl field.
781 : :
782 : : void
783 : 4646 : Gogo::register_gc_vars(const std::vector<Named_object*>& var_gc,
784 : : std::vector<Bstatement*>& init_stmts,
785 : : Bfunction* init_bfn)
786 : : {
787 : 4646 : if (var_gc.empty() && this->gc_roots_.empty())
788 : 2535 : return;
789 : :
790 : 2111 : Type* pvt = Type::make_pointer_type(Type::make_void_type());
791 : 2111 : Type* uintptr_type = Type::lookup_integer_type("uintptr");
792 : 2111 : Type* byte_type = Type::lookup_integer_type("byte");
793 : 2111 : Type* pointer_byte_type = Type::make_pointer_type(byte_type);
794 : 2111 : Struct_type* root_type =
795 : 2111 : Type::make_builtin_struct_type(4,
796 : : "decl", pvt,
797 : : "size", uintptr_type,
798 : : "ptrdata", uintptr_type,
799 : : "gcdata", pointer_byte_type);
800 : :
801 : 2111 : Location builtin_loc = Linemap::predeclared_location();
802 : 2111 : unsigned long roots_len = var_gc.size() + this->gc_roots_.size();
803 : 2111 : Expression* length = Expression::make_integer_ul(roots_len, NULL,
804 : : builtin_loc);
805 : 2111 : Array_type* root_array_type = Type::make_array_type(root_type, length);
806 : 2111 : root_array_type->set_is_array_incomparable();
807 : :
808 : 2111 : Type* int_type = Type::lookup_integer_type("int");
809 : 2111 : Struct_type* root_list_type =
810 : 2111 : Type::make_builtin_struct_type(3,
811 : : "next", pvt,
812 : : "count", int_type,
813 : : "roots", root_array_type);
814 : :
815 : : // Build an initializer for the roots array.
816 : :
817 : 2111 : Expression_list* roots_init = new Expression_list();
818 : :
819 : 2111 : for (std::vector<Named_object*>::const_iterator p = var_gc.begin();
820 : 21500 : p != var_gc.end();
821 : 19389 : ++p)
822 : : {
823 : 19389 : Expression_list* init = new Expression_list();
824 : :
825 : 19389 : Location no_loc = (*p)->location();
826 : 19389 : Expression* decl = Expression::make_var_reference(*p, no_loc);
827 : 19389 : Expression* decl_addr =
828 : 19389 : Expression::make_unary(OPERATOR_AND, decl, no_loc);
829 : 19389 : decl_addr->unary_expression()->set_does_not_escape();
830 : 19389 : decl_addr = Expression::make_cast(pvt, decl_addr, no_loc);
831 : 19389 : init->push_back(decl_addr);
832 : :
833 : 19389 : Expression* size =
834 : 19389 : Expression::make_type_info(decl->type(),
835 : : Expression::TYPE_INFO_SIZE);
836 : 19389 : init->push_back(size);
837 : :
838 : 19389 : Expression* ptrdata =
839 : 19389 : Expression::make_type_info(decl->type(),
840 : : Expression::TYPE_INFO_BACKEND_PTRDATA);
841 : 19389 : init->push_back(ptrdata);
842 : :
843 : 19389 : Expression* gcdata = Expression::make_ptrmask_symbol(decl->type());
844 : 19389 : init->push_back(gcdata);
845 : :
846 : 19389 : Expression* root_ctor =
847 : 19389 : Expression::make_struct_composite_literal(root_type, init, no_loc);
848 : 19389 : roots_init->push_back(root_ctor);
849 : : }
850 : :
851 : 2111 : for (std::vector<Expression*>::const_iterator p = this->gc_roots_.begin();
852 : 4771 : p != this->gc_roots_.end();
853 : 2660 : ++p)
854 : : {
855 : 2660 : Expression_list *init = new Expression_list();
856 : :
857 : 2660 : Expression* expr = *p;
858 : 2660 : Location eloc = expr->location();
859 : 2660 : init->push_back(Expression::make_cast(pvt, expr, eloc));
860 : :
861 : 2660 : Type* type = expr->type()->points_to();
862 : 2660 : go_assert(type != NULL);
863 : :
864 : 2660 : Expression* size =
865 : 2660 : Expression::make_type_info(type,
866 : : Expression::TYPE_INFO_SIZE);
867 : 2660 : init->push_back(size);
868 : :
869 : 2660 : Expression* ptrdata =
870 : 2660 : Expression::make_type_info(type,
871 : : Expression::TYPE_INFO_BACKEND_PTRDATA);
872 : 2660 : init->push_back(ptrdata);
873 : :
874 : 2660 : Expression* gcdata = Expression::make_ptrmask_symbol(type);
875 : 2660 : init->push_back(gcdata);
876 : :
877 : 2660 : Expression* root_ctor =
878 : 2660 : Expression::make_struct_composite_literal(root_type, init, eloc);
879 : 2660 : roots_init->push_back(root_ctor);
880 : : }
881 : :
882 : : // Build a constructor for the struct.
883 : :
884 : 2111 : Expression_list* root_list_init = new Expression_list();
885 : 2111 : root_list_init->push_back(Expression::make_nil(builtin_loc));
886 : 2111 : root_list_init->push_back(Expression::make_integer_ul(roots_len, int_type,
887 : : builtin_loc));
888 : :
889 : 2111 : Expression* roots_ctor =
890 : 2111 : Expression::make_array_composite_literal(root_array_type, roots_init,
891 : : builtin_loc);
892 : 2111 : root_list_init->push_back(roots_ctor);
893 : :
894 : 2111 : Expression* root_list_ctor =
895 : 2111 : Expression::make_struct_composite_literal(root_list_type, root_list_init,
896 : : builtin_loc);
897 : :
898 : 2111 : Expression* root_addr = Expression::make_unary(OPERATOR_AND, root_list_ctor,
899 : : builtin_loc);
900 : 2111 : root_addr->unary_expression()->set_is_gc_root();
901 : 2111 : Expression* register_roots = Runtime::make_call(this,
902 : : Runtime::REGISTER_GC_ROOTS,
903 : : builtin_loc, 1, root_addr);
904 : :
905 : 2111 : Translate_context context(this, NULL, NULL, NULL);
906 : 2111 : Bexpression* bcall = register_roots->get_backend(&context);
907 : 2111 : init_stmts.push_back(this->backend()->expression_statement(init_bfn, bcall));
908 : : }
909 : :
910 : : // Build the list of type descriptors defined in this package. This is to help
911 : : // the reflect package to find compiler-generated types.
912 : :
913 : : // type typeDescriptorList struct {
914 : : // count int
915 : : // types [...]unsafe.Pointer
916 : : // }
917 : :
918 : : static Struct_type*
919 : 6535 : type_descriptor_list_type(unsigned long len)
920 : : {
921 : 6535 : Location builtin_loc = Linemap::predeclared_location();
922 : 6535 : Type* int_type = Type::lookup_integer_type("int");
923 : 6535 : Type* ptr_type = Type::make_pointer_type(Type::make_void_type());
924 : : // Avoid creating zero-length type.
925 : 6535 : unsigned long nelems = (len != 0 ? len : 1);
926 : 6535 : Expression* len_expr = Expression::make_integer_ul(nelems, NULL,
927 : : builtin_loc);
928 : 6535 : Array_type* array_type = Type::make_array_type(ptr_type, len_expr);
929 : 6535 : array_type->set_is_array_incomparable();
930 : 6535 : Struct_type* list_type =
931 : 6535 : Type::make_builtin_struct_type(2, "count", int_type,
932 : : "types", array_type);
933 : 6535 : return list_type;
934 : : }
935 : :
936 : : void
937 : 4646 : Gogo::build_type_descriptor_list()
938 : : {
939 : : // Create the list type
940 : 4646 : Location builtin_loc = Linemap::predeclared_location();
941 : 4646 : unsigned long len = this->type_descriptors_.size();
942 : 4646 : Struct_type* list_type = type_descriptor_list_type(len);
943 : 4646 : Btype* bt = list_type->get_backend(this);
944 : 4646 : Btype* bat = list_type->field(1)->type()->get_backend(this);
945 : :
946 : : // Create the variable
947 : 4646 : std::string name = this->type_descriptor_list_symbol(this->pkgpath_symbol());
948 : 4646 : unsigned int flags = Backend::variable_is_constant;
949 : 4646 : Bvariable* bv = this->backend()->implicit_variable(name, name, bt, flags, 0);
950 : :
951 : : // Build the initializer
952 : 4646 : std::vector<unsigned long> indexes;
953 : 4646 : std::vector<Bexpression*> vals;
954 : 4646 : std::vector<Type*>::iterator p = this->type_descriptors_.begin();
955 : 180909 : for (unsigned long i = 0; i < len; ++i, ++p)
956 : : {
957 : 176263 : Bexpression* bexpr = (*p)->type_descriptor_pointer(this,
958 : 176263 : builtin_loc);
959 : 176263 : indexes.push_back(i);
960 : 176263 : vals.push_back(bexpr);
961 : : }
962 : 4646 : Bexpression* barray =
963 : 4646 : this->backend()->array_constructor_expression(bat, indexes, vals,
964 : 4646 : builtin_loc);
965 : :
966 : 4646 : Translate_context context(this, NULL, NULL, NULL);
967 : 4646 : std::vector<Bexpression*> fields;
968 : 4646 : Expression* len_expr = Expression::make_integer_ul(len, NULL,
969 : : builtin_loc);
970 : 4646 : fields.push_back(len_expr->get_backend(&context));
971 : 4646 : fields.push_back(barray);
972 : 4646 : Bexpression* binit =
973 : 4646 : this->backend()->constructor_expression(bt, fields, builtin_loc);
974 : :
975 : 4646 : this->backend()->implicit_variable_set_init(bv, name, bt, flags, binit);
976 : 4646 : }
977 : :
978 : : // Register the type descriptors with the runtime. This is to help
979 : : // the reflect package to find compiler-generated types.
980 : :
981 : : void
982 : 1889 : Gogo::register_type_descriptors(std::vector<Bstatement*>& init_stmts,
983 : : Bfunction* init_bfn)
984 : : {
985 : : // Create the list type
986 : 1889 : Location builtin_loc = Linemap::predeclared_location();
987 : 1889 : Struct_type* list_type = type_descriptor_list_type(1);
988 : 1889 : Btype* bt = list_type->get_backend(this);
989 : :
990 : : // Collect type lists from transitive imports.
991 : 1889 : std::vector<std::string> list_names;
992 : 1889 : for (Import_init_set::iterator it = this->imported_init_fns_.begin();
993 : 64317 : it != this->imported_init_fns_.end();
994 : 62428 : ++it)
995 : : {
996 : 62428 : std::string pkgpath_symbol =
997 : 124856 : this->pkgpath_symbol_from_init_fn_name((*it)->init_name());
998 : 62428 : list_names.push_back(this->type_descriptor_list_symbol(pkgpath_symbol));
999 : 62428 : }
1000 : : // Add the main package itself.
1001 : 1889 : list_names.push_back(this->type_descriptor_list_symbol("main"));
1002 : :
1003 : : // Build a list of lists.
1004 : 1889 : std::vector<unsigned long> indexes;
1005 : 1889 : std::vector<Bexpression*> vals;
1006 : 1889 : unsigned long i = 0;
1007 : 1889 : for (std::vector<std::string>::iterator p = list_names.begin();
1008 : 66206 : p != list_names.end();
1009 : 64317 : ++p)
1010 : : {
1011 : 64317 : Bvariable* bv =
1012 : 64317 : this->backend()->implicit_variable_reference(*p, *p, bt);
1013 : 64317 : Bexpression* bexpr = this->backend()->var_expression(bv, builtin_loc);
1014 : 64317 : bexpr = this->backend()->address_expression(bexpr, builtin_loc);
1015 : :
1016 : 64317 : indexes.push_back(i);
1017 : 64317 : vals.push_back(bexpr);
1018 : 64317 : i++;
1019 : : }
1020 : 1889 : Expression* len_expr = Expression::make_integer_ul(i, NULL, builtin_loc);
1021 : 1889 : Type* list_ptr_type = Type::make_pointer_type(list_type);
1022 : 1889 : Type* list_array_type = Type::make_array_type(list_ptr_type, len_expr);
1023 : 1889 : Btype* bat = list_array_type->get_backend(this);
1024 : 1889 : Bexpression* barray =
1025 : 1889 : this->backend()->array_constructor_expression(bat, indexes, vals,
1026 : : builtin_loc);
1027 : :
1028 : : // Create a variable holding the list.
1029 : 1889 : std::string name = this->typelists_symbol();
1030 : 1889 : unsigned int flags = (Backend::variable_is_hidden
1031 : : | Backend::variable_is_constant);
1032 : 1889 : Bvariable* bv = this->backend()->implicit_variable(name, name, bat, flags,
1033 : : 0);
1034 : 1889 : this->backend()->implicit_variable_set_init(bv, name, bat, flags, barray);
1035 : :
1036 : : // Build the call in main package's init function.
1037 : 1889 : Translate_context context(this, NULL, NULL, NULL);
1038 : 1889 : Bexpression* bexpr = this->backend()->var_expression(bv, builtin_loc);
1039 : 1889 : bexpr = this->backend()->address_expression(bexpr, builtin_loc);
1040 : 1889 : Type* array_ptr_type = Type::make_pointer_type(list_array_type);
1041 : 1889 : Expression* expr = Expression::make_backend(bexpr, array_ptr_type,
1042 : : builtin_loc);
1043 : 1889 : expr = Runtime::make_call(this, Runtime::REGISTER_TYPE_DESCRIPTORS,
1044 : : builtin_loc, 2, len_expr->copy(), expr);
1045 : 1889 : Bexpression* bcall = expr->get_backend(&context);
1046 : 1889 : init_stmts.push_back(this->backend()->expression_statement(init_bfn,
1047 : : bcall));
1048 : 1889 : }
1049 : :
1050 : : // Build the decl for the initialization function.
1051 : :
1052 : : Named_object*
1053 : 3453 : Gogo::initialization_function_decl()
1054 : : {
1055 : 3453 : std::string name = this->get_init_fn_name();
1056 : 3453 : Location loc = this->package_->location();
1057 : :
1058 : 3453 : Function_type* fntype = Type::make_function_type(NULL, NULL, NULL, loc);
1059 : 3453 : Function* initfn = new Function(fntype, NULL, NULL, loc);
1060 : 3453 : return Named_object::make_function(name, NULL, initfn);
1061 : 3453 : }
1062 : :
1063 : : // Create the magic initialization function. CODE_STMT is the
1064 : : // code that it needs to run.
1065 : :
1066 : : Named_object*
1067 : 3449 : Gogo::create_initialization_function(Named_object* initfn,
1068 : : Bstatement* code_stmt)
1069 : : {
1070 : : // Make sure that we thought we needed an initialization function,
1071 : : // as otherwise we will not have reported it in the export data.
1072 : 3449 : go_assert(this->is_main_package() || this->need_init_fn_);
1073 : :
1074 : 3449 : if (initfn == NULL)
1075 : 278 : initfn = this->initialization_function_decl();
1076 : :
1077 : : // Bind the initialization function code to a block.
1078 : 3449 : Bfunction* fndecl = initfn->func_value()->get_or_make_decl(this, initfn);
1079 : 3449 : Location pkg_loc = this->package_->location();
1080 : 3449 : std::vector<Bvariable*> vars;
1081 : 3449 : this->backend()->block(fndecl, NULL, vars, pkg_loc, pkg_loc);
1082 : :
1083 : 3449 : if (!this->backend()->function_set_body(fndecl, code_stmt))
1084 : : {
1085 : 41 : go_assert(saw_errors());
1086 : : return NULL;
1087 : : }
1088 : : return initfn;
1089 : 3449 : }
1090 : :
1091 : : // Given an expression, collect all the global variables defined in
1092 : : // this package that it references.
1093 : :
1094 : : class Find_vars : public Traverse
1095 : : {
1096 : : private:
1097 : : // The list of variables we accumulate.
1098 : : typedef Unordered_set(Named_object*) Vars;
1099 : :
1100 : : // A hash table we use to avoid looping. The index is a
1101 : : // Named_object* or a Temporary_statement*. We only look through
1102 : : // objects defined in this package.
1103 : : typedef Unordered_set(const void*) Seen_objects;
1104 : :
1105 : : public:
1106 : 55915 : Find_vars()
1107 : 55915 : : Traverse(traverse_expressions | traverse_statements),
1108 : 55915 : vars_(), seen_objects_(), lhs_is_ref_(false)
1109 : 55915 : { }
1110 : :
1111 : : // An iterator through the variables found, after the traversal.
1112 : : typedef Vars::const_iterator const_iterator;
1113 : :
1114 : : const_iterator
1115 : 55915 : begin() const
1116 : 55915 : { return this->vars_.begin(); }
1117 : :
1118 : : const_iterator
1119 : 77447 : end() const
1120 : 77447 : { return this->vars_.end(); }
1121 : :
1122 : : int
1123 : : expression(Expression**);
1124 : :
1125 : : int
1126 : : statement(Block*, size_t* index, Statement*);
1127 : :
1128 : : private:
1129 : : // Accumulated variables.
1130 : : Vars vars_;
1131 : : // Objects we have already seen.
1132 : : Seen_objects seen_objects_;
1133 : : // Whether an assignment to a variable counts as a reference.
1134 : : bool lhs_is_ref_;
1135 : : };
1136 : :
1137 : : // Collect global variables referenced by EXPR. Look through function
1138 : : // calls and variable initializations.
1139 : :
1140 : : int
1141 : 7219006 : Find_vars::expression(Expression** pexpr)
1142 : : {
1143 : 7219006 : Expression* e = *pexpr;
1144 : :
1145 : 7219006 : Var_expression* ve = e->var_expression();
1146 : 824867 : if (ve != NULL)
1147 : : {
1148 : 824867 : Named_object* v = ve->named_object();
1149 : 824867 : if (!v->is_variable() || v->package() != NULL)
1150 : : {
1151 : : // This is a result parameter or a variable defined in a
1152 : : // different package. Either way we don't care about it.
1153 : 636338 : return TRAVERSE_CONTINUE;
1154 : : }
1155 : :
1156 : 734392 : std::pair<Seen_objects::iterator, bool> ins =
1157 : 734392 : this->seen_objects_.insert(v);
1158 : 734392 : if (!ins.second)
1159 : : {
1160 : : // We've seen this variable before.
1161 : : return TRAVERSE_CONTINUE;
1162 : : }
1163 : :
1164 : 188529 : if (v->var_value()->is_global())
1165 : 21549 : this->vars_.insert(v);
1166 : :
1167 : 188529 : Expression* init = v->var_value()->init();
1168 : 188529 : if (init != NULL)
1169 : : {
1170 : 82447 : if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
1171 : : return TRAVERSE_EXIT;
1172 : : }
1173 : : }
1174 : :
1175 : : // We traverse the code of any function or bound method we see. Note that
1176 : : // this means that we will traverse the code of a function or bound method
1177 : : // whose address is taken even if it is not called.
1178 : 6582668 : Func_expression* fe = e->func_expression();
1179 : 6582668 : Bound_method_expression* bme = e->bound_method_expression();
1180 : 6582668 : if (fe != NULL || bme != NULL)
1181 : : {
1182 : 335257 : const Named_object* f = fe != NULL ? fe->named_object() : bme->function();
1183 : 335257 : if (f->is_function() && f->package() == NULL)
1184 : : {
1185 : 129265 : std::pair<Seen_objects::iterator, bool> ins =
1186 : 129265 : this->seen_objects_.insert(f);
1187 : 129265 : if (ins.second)
1188 : : {
1189 : : // This is the first time we have seen this name.
1190 : 41342 : bool hold = this->lhs_is_ref_;
1191 : 41342 : this->lhs_is_ref_ = true;
1192 : 41342 : int r = f->func_value()->block()->traverse(this);
1193 : 41342 : this->lhs_is_ref_ = hold;
1194 : 41342 : if (r == TRAVERSE_EXIT)
1195 : 0 : return TRAVERSE_EXIT;
1196 : : }
1197 : : }
1198 : : }
1199 : :
1200 : 6582668 : Temporary_reference_expression* tre = e->temporary_reference_expression();
1201 : 310565 : if (tre != NULL)
1202 : : {
1203 : 310565 : Temporary_statement* ts = tre->statement();
1204 : 310565 : Expression* init = ts->init();
1205 : 310565 : if (init != NULL)
1206 : : {
1207 : 260150 : std::pair<Seen_objects::iterator, bool> ins =
1208 : 260150 : this->seen_objects_.insert(ts);
1209 : 260150 : if (ins.second)
1210 : : {
1211 : : // This is the first time we have seen this temporary
1212 : : // statement.
1213 : 167876 : if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
1214 : 0 : return TRAVERSE_EXIT;
1215 : : }
1216 : : }
1217 : : }
1218 : :
1219 : : return TRAVERSE_CONTINUE;
1220 : : }
1221 : :
1222 : : // Check a statement while searching for variables. This is where we
1223 : : // skip variables on the left hand side of assigments if appropriate.
1224 : :
1225 : : int
1226 : 1047161 : Find_vars::statement(Block*, size_t*, Statement* s)
1227 : : {
1228 : 1047161 : if (this->lhs_is_ref_)
1229 : : return TRAVERSE_CONTINUE;
1230 : 9126 : Assignment_statement* as = s->assignment_statement();
1231 : 28 : if (as == NULL)
1232 : : return TRAVERSE_CONTINUE;
1233 : :
1234 : : // Only traverse subexpressions of the LHS.
1235 : 28 : if (as->lhs()->traverse_subexpressions(this) == TRAVERSE_EXIT)
1236 : : return TRAVERSE_EXIT;
1237 : :
1238 : 28 : Expression* rhs = as->rhs();
1239 : 28 : if (Expression::traverse(&rhs, this) == TRAVERSE_EXIT)
1240 : : return TRAVERSE_EXIT;
1241 : :
1242 : : return TRAVERSE_SKIP_COMPONENTS;
1243 : : }
1244 : :
1245 : : // Return true if EXPR, PREINIT, or DEP refers to VAR.
1246 : :
1247 : : static bool
1248 : 19214 : expression_requires(Expression* expr, Block* preinit, Named_object* dep,
1249 : : Named_object* var)
1250 : : {
1251 : 19214 : Find_vars find_vars;
1252 : 19214 : if (expr != NULL)
1253 : 19214 : Expression::traverse(&expr, &find_vars);
1254 : 19214 : if (preinit != NULL)
1255 : 909 : preinit->traverse(&find_vars);
1256 : 19214 : if (dep != NULL)
1257 : : {
1258 : 0 : Expression* init = dep->var_value()->init();
1259 : 0 : if (init != NULL)
1260 : 0 : Expression::traverse(&init, &find_vars);
1261 : 0 : if (dep->var_value()->has_pre_init())
1262 : 0 : dep->var_value()->preinit()->traverse(&find_vars);
1263 : : }
1264 : :
1265 : 29096 : for (Find_vars::const_iterator p = find_vars.begin();
1266 : 29096 : p != find_vars.end();
1267 : 9882 : ++p)
1268 : : {
1269 : 9899 : if (*p == var)
1270 : 19214 : return true;
1271 : : }
1272 : : return false;
1273 : 19214 : }
1274 : :
1275 : : // Sort variable initializations. If the initialization expression
1276 : : // for variable A refers directly or indirectly to the initialization
1277 : : // expression for variable B, then we must initialize B before A.
1278 : :
1279 : : class Var_init
1280 : : {
1281 : : public:
1282 : : Var_init()
1283 : : : var_(NULL), init_(NULL), dep_count_(0)
1284 : : { }
1285 : :
1286 : 13014 : Var_init(Named_object* var, Bstatement* init)
1287 : 13014 : : var_(var), init_(init), dep_count_(0)
1288 : : { }
1289 : :
1290 : : // Return the variable.
1291 : : Named_object*
1292 : 121834 : var() const
1293 : 121834 : { return this->var_; }
1294 : :
1295 : : // Return the initialization expression.
1296 : : Bstatement*
1297 : 13014 : init() const
1298 : 13014 : { return this->init_; }
1299 : :
1300 : : // Return the number of remaining dependencies.
1301 : : size_t
1302 : 17340 : dep_count() const
1303 : 17340 : { return this->dep_count_; }
1304 : :
1305 : : // Increment the number of dependencies.
1306 : : void
1307 : 7044 : add_dependency()
1308 : 7044 : { ++this->dep_count_; }
1309 : :
1310 : : // Decrement the number of dependencies.
1311 : : void
1312 : 7040 : remove_dependency()
1313 : 7040 : { --this->dep_count_; }
1314 : :
1315 : : private:
1316 : : // The variable being initialized.
1317 : : Named_object* var_;
1318 : : // The backend initialization statement.
1319 : : Bstatement* init_;
1320 : : // The number of initializations this is dependent on. A variable
1321 : : // initialization should not be emitted if any of its dependencies
1322 : : // have not yet been resolved.
1323 : : size_t dep_count_;
1324 : : };
1325 : :
1326 : : // For comparing Var_init keys in a map.
1327 : :
1328 : : inline bool
1329 : 88762 : operator<(const Var_init& v1, const Var_init& v2)
1330 : 88762 : { return v1.var()->name() < v2.var()->name(); }
1331 : :
1332 : : typedef std::list<Var_init> Var_inits;
1333 : :
1334 : : // Sort the variable initializations. The rule we follow is that we
1335 : : // emit them in the order they appear in the array, except that if the
1336 : : // initialization expression for a variable V1 depends upon another
1337 : : // variable V2 then we initialize V1 after V2.
1338 : :
1339 : : static void
1340 : 1857 : sort_var_inits(Var_inits* var_inits)
1341 : : {
1342 : 1857 : if (var_inits->empty())
1343 : 0 : return;
1344 : :
1345 : 1857 : std::map<Named_object*, Var_init*> var_to_init;
1346 : :
1347 : : // A mapping from a variable initialization to a set of
1348 : : // variable initializations that depend on it.
1349 : 1857 : typedef std::map<Var_init, std::set<Var_init*> > Init_deps;
1350 : 1857 : Init_deps init_deps;
1351 : 1857 : bool init_loop = false;
1352 : :
1353 : : // Map from variable to Var_init.
1354 : 1857 : for (Var_inits::iterator pvar = var_inits->begin();
1355 : 14871 : pvar != var_inits->end();
1356 : 13014 : ++pvar)
1357 : : {
1358 : 13014 : Named_object* var = pvar->var();
1359 : 13014 : var_to_init[var] = &*pvar;
1360 : : }
1361 : :
1362 : : // Add dependencies to init_deps, and check for cycles.
1363 : 14871 : for (Var_inits::iterator pvar = var_inits->begin();
1364 : 14871 : pvar != var_inits->end();
1365 : 13014 : ++pvar)
1366 : : {
1367 : 13014 : Named_object* var = pvar->var();
1368 : :
1369 : 13014 : const std::vector<Named_object*>* refs =
1370 : 13014 : pvar->var()->var_value()->init_refs();
1371 : 13014 : if (refs == NULL)
1372 : 9502 : continue;
1373 : 14985 : for (std::vector<Named_object*>::const_iterator pdep = refs->begin();
1374 : 14985 : pdep != refs->end();
1375 : 11473 : ++pdep)
1376 : : {
1377 : 11473 : Named_object* dep = *pdep;
1378 : 11473 : if (var == dep)
1379 : : {
1380 : : // This is a reference from a variable to itself.
1381 : 33 : go_error_at(var->location(),
1382 : : ("initialization expression for %qs "
1383 : : "depends upon itself"),
1384 : 33 : var->message_name().c_str());
1385 : 9584 : continue;
1386 : : }
1387 : :
1388 : 11440 : Var_init* dep_init = var_to_init[dep];
1389 : 11440 : if (dep_init == NULL)
1390 : : {
1391 : : // This is a dependency on some variable that doesn't
1392 : : // have an initializer, so for purposes of
1393 : : // initialization ordering this is irrelevant.
1394 : 4396 : continue;
1395 : : }
1396 : :
1397 : 7044 : init_deps[*dep_init].insert(&(*pvar));
1398 : 7044 : pvar->add_dependency();
1399 : :
1400 : : // Check for cycles.
1401 : 7044 : const std::vector<Named_object*>* deprefs =
1402 : 7044 : dep_init->var()->var_value()->init_refs();
1403 : 7044 : if (deprefs == NULL)
1404 : 5155 : continue;
1405 : 5108 : for (std::vector<Named_object*>::const_iterator pdepdep =
1406 : 1889 : deprefs->begin();
1407 : 5108 : pdepdep != deprefs->end();
1408 : 3219 : ++pdepdep)
1409 : : {
1410 : 3221 : if (*pdepdep == var)
1411 : : {
1412 : 2 : go_error_at(var->location(),
1413 : : ("initialization expressions for %qs and "
1414 : : "%qs depend upon each other"),
1415 : 4 : var->message_name().c_str(),
1416 : 2 : dep->message_name().c_str());
1417 : 2 : go_inform(dep->location(), "%qs defined here",
1418 : 2 : dep->message_name().c_str());
1419 : 2 : init_loop = true;
1420 : 2 : break;
1421 : : }
1422 : : }
1423 : : }
1424 : : }
1425 : :
1426 : 1857 : var_to_init.clear();
1427 : :
1428 : : // If there are no dependencies then the declaration order is sorted.
1429 : 1857 : if (!init_deps.empty() && !init_loop)
1430 : : {
1431 : : // Otherwise, sort variable initializations by emitting all variables with
1432 : : // no dependencies in declaration order. VAR_INITS is already in
1433 : : // declaration order.
1434 : 329 : Var_inits ready;
1435 : 8713 : while (!var_inits->empty())
1436 : : {
1437 : : Var_inits::iterator v1;;
1438 : 17340 : for (v1 = var_inits->begin(); v1 != var_inits->end(); ++v1)
1439 : : {
1440 : 17340 : if (v1->dep_count() == 0)
1441 : : break;
1442 : : }
1443 : 8055 : go_assert(v1 != var_inits->end());
1444 : :
1445 : : // V1 either has no dependencies or its dependencies have already
1446 : : // been emitted, add it to READY next. When V1 is emitted, remove
1447 : : // a dependency from each V that depends on V1.
1448 : 8055 : ready.splice(ready.end(), *var_inits, v1);
1449 : :
1450 : 8055 : Init_deps::iterator p1 = init_deps.find(*v1);
1451 : 8055 : if (p1 != init_deps.end())
1452 : : {
1453 : 3945 : std::set<Var_init*> resolved = p1->second;
1454 : 10985 : for (std::set<Var_init*>::iterator pv = resolved.begin();
1455 : 10985 : pv != resolved.end();
1456 : 7040 : ++pv)
1457 : 7040 : (*pv)->remove_dependency();
1458 : 3945 : init_deps.erase(p1);
1459 : 3945 : }
1460 : : }
1461 : 329 : var_inits->swap(ready);
1462 : 329 : go_assert(init_deps.empty());
1463 : 329 : }
1464 : 1857 : }
1465 : :
1466 : : // Give an error if the initialization expression for VAR depends on
1467 : : // itself. We only check if INIT is not NULL and there is no
1468 : : // dependency; when INIT is NULL, it means that PREINIT sets VAR,
1469 : : // which we will interpret as a loop.
1470 : :
1471 : : void
1472 : 11992 : Gogo::check_self_dep(Named_object* var)
1473 : : {
1474 : 11992 : Expression* init = var->var_value()->init();
1475 : 11992 : Block* preinit = var->var_value()->preinit();
1476 : 11992 : Named_object* dep = this->var_depends_on(var->var_value());
1477 : 11992 : if (init != NULL
1478 : 11992 : && dep == NULL
1479 : 11992 : && expression_requires(init, preinit, NULL, var))
1480 : 17 : go_error_at(var->location(),
1481 : : "initialization expression for %qs depends upon itself",
1482 : 34 : var->message_name().c_str());
1483 : 11992 : }
1484 : :
1485 : : // Write out the global definitions.
1486 : :
1487 : : void
1488 : 4646 : Gogo::write_globals()
1489 : : {
1490 : 4646 : this->build_interface_method_tables();
1491 : :
1492 : 4646 : Bindings* bindings = this->current_bindings();
1493 : :
1494 : 449760 : for (Bindings::const_declarations_iterator p = bindings->begin_declarations();
1495 : 449760 : p != bindings->end_declarations();
1496 : 445114 : ++p)
1497 : : {
1498 : : // If any function declarations needed a descriptor, make sure
1499 : : // we build it.
1500 : 445114 : Named_object* no = p->second;
1501 : 445114 : if (no->is_function_declaration())
1502 : 3904 : no->func_declaration_value()->build_backend_descriptor(this);
1503 : : }
1504 : :
1505 : : // Lists of globally declared types, variables, constants, and functions
1506 : : // that must be defined.
1507 : 4646 : std::vector<Btype*> type_decls;
1508 : 4646 : std::vector<Bvariable*> var_decls;
1509 : 4646 : std::vector<Bexpression*> const_decls;
1510 : 4646 : std::vector<Bfunction*> func_decls;
1511 : :
1512 : : // The init function declaration and associated Bfunction, if necessary.
1513 : 4646 : Named_object* init_fndecl = NULL;
1514 : 4646 : Bfunction* init_bfn = NULL;
1515 : :
1516 : 4646 : std::vector<Bstatement*> init_stmts;
1517 : 4646 : std::vector<Bstatement*> var_init_stmts;
1518 : :
1519 : 4646 : if (this->is_main_package())
1520 : : {
1521 : 1889 : init_fndecl = this->initialization_function_decl();
1522 : 1889 : init_bfn = init_fndecl->func_value()->get_or_make_decl(this, init_fndecl);
1523 : : }
1524 : :
1525 : : // A list of variable initializations.
1526 : 4646 : Var_inits var_inits;
1527 : :
1528 : : // A list of variables which need to be registered with the garbage
1529 : : // collector.
1530 : 4646 : size_t count_definitions = bindings->size_definitions();
1531 : 4646 : std::vector<Named_object*> var_gc;
1532 : 4646 : var_gc.reserve(count_definitions);
1533 : :
1534 : 565636 : for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
1535 : 565636 : p != bindings->end_definitions();
1536 : 560990 : ++p)
1537 : : {
1538 : 560990 : Named_object* no = *p;
1539 : 560990 : go_assert(!no->is_type_declaration() && !no->is_function_declaration());
1540 : :
1541 : : // There is nothing to do for a package.
1542 : 560990 : if (no->is_package())
1543 : 198219 : continue;
1544 : :
1545 : : // There is nothing to do for an object which was imported from
1546 : : // a different package into the global scope.
1547 : 521575 : if (no->package() != NULL)
1548 : 32785 : continue;
1549 : :
1550 : : // Skip blank named functions and constants.
1551 : 283565 : if ((no->is_function() && no->func_value()->is_sink())
1552 : 772055 : || (no->is_const() && no->const_value()->is_sink()))
1553 : 1477 : continue;
1554 : :
1555 : : // Skip global sink variables with static initializers. With
1556 : : // non-static initializers we have to evaluate for side effects,
1557 : : // and we wind up initializing a dummy variable. That is not
1558 : : // ideal but it works and it's a rare case.
1559 : 487385 : if (no->is_variable()
1560 : 25471 : && no->var_value()->is_global_sink()
1561 : 1114 : && !no->var_value()->has_pre_init()
1562 : 487742 : && (no->var_value()->init() == NULL
1563 : 417 : || no->var_value()->init()->is_static_initializer()))
1564 : 72 : continue;
1565 : :
1566 : : // There is nothing useful we can output for constants which
1567 : : // have ideal or non-integral type.
1568 : 487241 : if (no->is_const())
1569 : : {
1570 : 147869 : Type* type = no->const_value()->type();
1571 : 147869 : if (type == NULL)
1572 : 0 : type = no->const_value()->expr()->type();
1573 : 171477 : if (type->is_abstract() || !type->is_numeric_type())
1574 : 124470 : continue;
1575 : : }
1576 : :
1577 : 362771 : if (!no->is_variable())
1578 : 337372 : no->get_backend(this, const_decls, type_decls, func_decls);
1579 : : else
1580 : : {
1581 : 25399 : Variable* var = no->var_value();
1582 : 25399 : Bvariable* bvar = no->get_backend_variable(this, NULL);
1583 : 25399 : var_decls.push_back(bvar);
1584 : :
1585 : : // Check for a sink variable, which may be used to run an
1586 : : // initializer purely for its side effects.
1587 : 25399 : bool is_sink = no->name()[0] == '_' && no->name()[1] == '.';
1588 : :
1589 : 25399 : Bstatement* var_init_stmt = NULL;
1590 : 25399 : if (!var->has_pre_init())
1591 : : {
1592 : : // If the backend representation of the variable initializer is
1593 : : // constant, we can just set the initial value using
1594 : : // global_var_set_init instead of during the init() function.
1595 : : // The initializer is constant if it is the zero-value of the
1596 : : // variable's type or if the initial value is an immutable value
1597 : : // that is not copied to the heap.
1598 : 13191 : bool is_static_initializer = false;
1599 : 13191 : if (var->init() == NULL)
1600 : : is_static_initializer = true;
1601 : : else
1602 : : {
1603 : 8092 : Type* var_type = var->type();
1604 : 8092 : Expression* init = var->init();
1605 : 8092 : Expression* init_cast =
1606 : 8092 : Expression::make_cast(var_type, init, var->location());
1607 : 8092 : is_static_initializer = init_cast->is_static_initializer();
1608 : : }
1609 : :
1610 : : // Non-constant variable initializations might need to create
1611 : : // temporary variables, which will need the initialization
1612 : : // function as context.
1613 : 8092 : Named_object* var_init_fn;
1614 : 8092 : if (is_static_initializer)
1615 : : var_init_fn = NULL;
1616 : : else
1617 : : {
1618 : 802 : if (init_fndecl == NULL)
1619 : : {
1620 : 51 : init_fndecl = this->initialization_function_decl();
1621 : 51 : Function* func = init_fndecl->func_value();
1622 : 51 : init_bfn = func->get_or_make_decl(this, init_fndecl);
1623 : : }
1624 : : var_init_fn = init_fndecl;
1625 : : }
1626 : 13191 : Bexpression* var_binit = var->get_init(this, var_init_fn);
1627 : :
1628 : 13191 : if (var_binit == NULL)
1629 : : ;
1630 : 8092 : else if (is_static_initializer)
1631 : : {
1632 : 7290 : if (expression_requires(var->init(), NULL,
1633 : : this->var_depends_on(var), no))
1634 : 0 : go_error_at(no->location(),
1635 : : "initialization expression for %qs depends "
1636 : : "upon itself",
1637 : 0 : no->message_name().c_str());
1638 : 7290 : this->backend()->global_variable_set_init(bvar, var_binit);
1639 : : }
1640 : 802 : else if (is_sink)
1641 : 357 : var_init_stmt =
1642 : 357 : this->backend()->expression_statement(init_bfn, var_binit);
1643 : : else
1644 : : {
1645 : 445 : Location loc = var->location();
1646 : 445 : Bexpression* var_expr =
1647 : 445 : this->backend()->var_expression(bvar, loc);
1648 : 445 : var_init_stmt =
1649 : 445 : this->backend()->assignment_statement(init_bfn, var_expr,
1650 : : var_binit, loc);
1651 : : }
1652 : : }
1653 : : else
1654 : : {
1655 : : // We are going to create temporary variables which
1656 : : // means that we need an fndecl.
1657 : 12208 : if (init_fndecl == NULL)
1658 : 1235 : init_fndecl = this->initialization_function_decl();
1659 : :
1660 : 12208 : Bvariable* var_decl = is_sink ? NULL : bvar;
1661 : 12208 : var_init_stmt = var->get_init_block(this, init_fndecl, var_decl);
1662 : : }
1663 : :
1664 : 25399 : if (var_init_stmt != NULL)
1665 : : {
1666 : 13010 : if (var->init() == NULL && !var->has_pre_init())
1667 : 0 : var_init_stmts.push_back(var_init_stmt);
1668 : : else
1669 : 13010 : var_inits.push_back(Var_init(no, var_init_stmt));
1670 : : }
1671 : 12389 : else if (this->var_depends_on(var) != NULL)
1672 : : {
1673 : : // This variable is initialized from something that is
1674 : : // not in its init or preinit. This variable needs to
1675 : : // participate in dependency analysis sorting, in case
1676 : : // some other variable depends on this one.
1677 : 4 : Btype* btype = no->var_value()->type()->get_backend(this);
1678 : 4 : Bexpression* zero = this->backend()->zero_expression(btype);
1679 : 4 : Bstatement* zero_stmt =
1680 : 4 : this->backend()->expression_statement(init_bfn, zero);
1681 : 4 : var_inits.push_back(Var_init(no, zero_stmt));
1682 : : }
1683 : :
1684 : : // Collect a list of all global variables with pointers,
1685 : : // to register them for the garbage collector.
1686 : 25399 : if (!is_sink && var->type()->has_pointer())
1687 : : {
1688 : : // Avoid putting runtime.gcRoots itself on the list.
1689 : 38792 : if (this->compiling_runtime()
1690 : 832 : && this->package_name() == "runtime"
1691 : 39435 : && (Gogo::unpack_hidden_name(no->name()) == "gcRoots"
1692 : 19396 : || Gogo::unpack_hidden_name(no->name()) == "gcRootsIndex"))
1693 : : ;
1694 : : else
1695 : 19389 : var_gc.push_back(no);
1696 : : }
1697 : : }
1698 : : }
1699 : :
1700 : : // Output inline functions, which are in different packages.
1701 : 12247 : for (std::vector<Named_object*>::const_iterator p =
1702 : 4646 : this->imported_inline_functions_.begin();
1703 : 16893 : p != this->imported_inline_functions_.end();
1704 : 12247 : ++p)
1705 : 12247 : (*p)->get_backend(this, const_decls, type_decls, func_decls);
1706 : :
1707 : : // Build the list of type descriptors.
1708 : 4646 : this->build_type_descriptor_list();
1709 : :
1710 : 4646 : if (this->is_main_package())
1711 : : {
1712 : : // Register the type descriptor lists, so that at run time
1713 : : // the reflect package can find compiler-created types, and
1714 : : // deduplicate if the same type is created with reflection.
1715 : : // This needs to be done before calling any package's init
1716 : : // function, as it may create type through reflection.
1717 : 1889 : this->register_type_descriptors(init_stmts, init_bfn);
1718 : :
1719 : : // Initialize imported packages.
1720 : 1889 : this->init_imports(init_stmts, init_bfn);
1721 : : }
1722 : :
1723 : : // Register global variables with the garbage collector.
1724 : 4646 : this->register_gc_vars(var_gc, init_stmts, init_bfn);
1725 : :
1726 : : // Simple variable initializations, after all variables are
1727 : : // registered.
1728 : 4646 : init_stmts.push_back(this->backend()->statement_list(var_init_stmts));
1729 : :
1730 : : // Complete variable initializations, first sorting them into a
1731 : : // workable order.
1732 : 4646 : if (!var_inits.empty())
1733 : : {
1734 : 1857 : sort_var_inits(&var_inits);
1735 : 1857 : for (Var_inits::const_iterator p = var_inits.begin();
1736 : 14871 : p != var_inits.end();
1737 : 13014 : ++p)
1738 : 13014 : init_stmts.push_back(p->init());
1739 : : }
1740 : :
1741 : : // After all the variables are initialized, call the init
1742 : : // functions if there are any. Init functions take no arguments, so
1743 : : // we pass in EMPTY_ARGS to call them.
1744 : 4646 : std::vector<Bexpression*> empty_args;
1745 : 1884 : for (std::vector<Named_object*>::const_iterator p =
1746 : 4646 : this->init_functions_.begin();
1747 : 6530 : p != this->init_functions_.end();
1748 : 1884 : ++p)
1749 : : {
1750 : 1884 : Location func_loc = (*p)->location();
1751 : 1884 : Function* func = (*p)->func_value();
1752 : 1884 : Bfunction* initfn = func->get_or_make_decl(this, *p);
1753 : 1884 : Bexpression* func_code =
1754 : 1884 : this->backend()->function_code_expression(initfn, func_loc);
1755 : 1884 : Bexpression* call = this->backend()->call_expression(init_bfn, func_code,
1756 : : empty_args,
1757 : : NULL, func_loc);
1758 : 1884 : Bstatement* ist = this->backend()->expression_statement(init_bfn, call);
1759 : 1884 : init_stmts.push_back(ist);
1760 : : }
1761 : :
1762 : : // Set up a magic function to do all the initialization actions.
1763 : : // This will be called if this package is imported.
1764 : 4646 : Bstatement* init_fncode = this->backend()->statement_list(init_stmts);
1765 : 4646 : if (this->need_init_fn_ || this->is_main_package())
1766 : : {
1767 : 3449 : init_fndecl =
1768 : 3449 : this->create_initialization_function(init_fndecl, init_fncode);
1769 : 3449 : if (init_fndecl != NULL)
1770 : 3408 : func_decls.push_back(init_fndecl->func_value()->get_decl());
1771 : : }
1772 : :
1773 : : // We should not have seen any new bindings created during the conversion.
1774 : 4646 : go_assert(count_definitions == this->current_bindings()->size_definitions());
1775 : :
1776 : : // Define all globally declared values.
1777 : 4646 : if (!saw_errors())
1778 : 4217 : this->backend()->write_global_definitions(type_decls, const_decls,
1779 : : func_decls, var_decls);
1780 : 4646 : }
1781 : :
1782 : : // Return the current block.
1783 : :
1784 : : Block*
1785 : 927284 : Gogo::current_block()
1786 : : {
1787 : 927284 : if (this->functions_.empty())
1788 : : return NULL;
1789 : : else
1790 : 927283 : return this->functions_.back().blocks.back();
1791 : : }
1792 : :
1793 : : // Look up a name in the current binding contour. If PFUNCTION is not
1794 : : // NULL, set it to the function in which the name is defined, or NULL
1795 : : // if the name is defined in global scope.
1796 : :
1797 : : Named_object*
1798 : 4072513 : Gogo::lookup(const std::string& name, Named_object** pfunction) const
1799 : : {
1800 : 4072513 : if (pfunction != NULL)
1801 : 3214428 : *pfunction = NULL;
1802 : :
1803 : 4072513 : if (Gogo::is_sink_name(name))
1804 : 8421 : return Named_object::make_sink();
1805 : :
1806 : 5432045 : for (Open_functions::const_reverse_iterator p = this->functions_.rbegin();
1807 : 5432045 : p != this->functions_.rend();
1808 : 1367953 : ++p)
1809 : : {
1810 : 3485807 : Named_object* ret = p->blocks.back()->bindings()->lookup(name);
1811 : 3485807 : if (ret != NULL)
1812 : : {
1813 : 2117854 : if (pfunction != NULL)
1814 : 1860217 : *pfunction = p->function;
1815 : 2117854 : return ret;
1816 : : }
1817 : : }
1818 : :
1819 : 1946238 : if (this->package_ != NULL)
1820 : : {
1821 : 1946238 : Named_object* ret = this->package_->bindings()->lookup(name);
1822 : 1946238 : if (ret != NULL)
1823 : : {
1824 : 1745100 : if (ret->package() != NULL)
1825 : : {
1826 : 26027 : std::string dot_alias = "." + ret->package()->package_name();
1827 : 26027 : ret->package()->note_usage(dot_alias);
1828 : 26027 : }
1829 : 1745100 : return ret;
1830 : : }
1831 : : }
1832 : :
1833 : : // We do not look in the global namespace. If we did, the global
1834 : : // namespace would effectively hide names which were defined in
1835 : : // package scope which we have not yet seen. Instead,
1836 : : // define_global_names is called after parsing is over to connect
1837 : : // undefined names at package scope with names defined at global
1838 : : // scope.
1839 : :
1840 : : return NULL;
1841 : : }
1842 : :
1843 : : // Look up a name in the current block, without searching enclosing
1844 : : // blocks.
1845 : :
1846 : : Named_object*
1847 : 306705 : Gogo::lookup_in_block(const std::string& name) const
1848 : : {
1849 : 306705 : go_assert(!this->functions_.empty());
1850 : 306705 : go_assert(!this->functions_.back().blocks.empty());
1851 : 306705 : return this->functions_.back().blocks.back()->bindings()->lookup_local(name);
1852 : : }
1853 : :
1854 : : // Look up a name in the global namespace.
1855 : :
1856 : : Named_object*
1857 : 639622 : Gogo::lookup_global(const char* name) const
1858 : : {
1859 : 639622 : return this->globals_->lookup(name);
1860 : : }
1861 : :
1862 : : // Add an imported package.
1863 : :
1864 : : Package*
1865 : 25881 : Gogo::add_imported_package(const std::string& real_name,
1866 : : const std::string& alias_arg,
1867 : : bool is_alias_exported,
1868 : : const std::string& pkgpath,
1869 : : const std::string& pkgpath_symbol,
1870 : : Location location,
1871 : : bool* padd_to_globals)
1872 : : {
1873 : 25881 : Package* ret = this->register_package(pkgpath, pkgpath_symbol, location);
1874 : 25881 : ret->set_package_name(real_name, location);
1875 : :
1876 : 25881 : *padd_to_globals = false;
1877 : :
1878 : 25881 : if (alias_arg == "_")
1879 : : ;
1880 : 20914 : else if (alias_arg == ".")
1881 : : {
1882 : 10 : *padd_to_globals = true;
1883 : 10 : std::string dot_alias = "." + real_name;
1884 : 10 : ret->add_alias(dot_alias, location);
1885 : 10 : }
1886 : : else
1887 : : {
1888 : 20904 : std::string alias = alias_arg;
1889 : 20904 : if (alias.empty())
1890 : : {
1891 : 20308 : alias = real_name;
1892 : 20308 : is_alias_exported = Lex::is_exported_name(alias);
1893 : : }
1894 : 20904 : ret->add_alias(alias, location);
1895 : 20904 : alias = this->pack_hidden_name(alias, is_alias_exported);
1896 : 20904 : Named_object* no = this->package_->bindings()->add_package(alias, ret);
1897 : 20904 : if (!no->is_package())
1898 : 0 : return NULL;
1899 : 20904 : }
1900 : :
1901 : : return ret;
1902 : : }
1903 : :
1904 : : // Register a package. This package may or may not be imported. This
1905 : : // returns the Package structure for the package, creating if it
1906 : : // necessary. LOCATION is the location of the import statement that
1907 : : // led us to see this package. PKGPATH_SYMBOL is the symbol to use
1908 : : // for names in the package; it may be the empty string, in which case
1909 : : // we either get it later or make a guess when we need it.
1910 : :
1911 : : Package*
1912 : 734293 : Gogo::register_package(const std::string& pkgpath,
1913 : : const std::string& pkgpath_symbol, Location location)
1914 : : {
1915 : 734293 : Package* package = NULL;
1916 : 734293 : std::pair<Packages::iterator, bool> ins =
1917 : 1468586 : this->packages_.insert(std::make_pair(pkgpath, package));
1918 : 734293 : if (!ins.second)
1919 : : {
1920 : : // We have seen this package name before.
1921 : 617651 : package = ins.first->second;
1922 : 617651 : go_assert(package != NULL && package->pkgpath() == pkgpath);
1923 : 617651 : if (!pkgpath_symbol.empty())
1924 : 14338 : package->set_pkgpath_symbol(pkgpath_symbol);
1925 : 617651 : if (Linemap::is_unknown_location(package->location()))
1926 : 318737 : package->set_location(location);
1927 : : }
1928 : : else
1929 : : {
1930 : : // First time we have seen this package name.
1931 : 116642 : package = new Package(pkgpath, pkgpath_symbol, location);
1932 : 116642 : go_assert(ins.first->second == NULL);
1933 : 116642 : ins.first->second = package;
1934 : : }
1935 : :
1936 : 734293 : return package;
1937 : : }
1938 : :
1939 : : // Return the pkgpath symbol for a package, given the pkgpath.
1940 : :
1941 : : std::string
1942 : 0 : Gogo::pkgpath_symbol_for_package(const std::string& pkgpath)
1943 : : {
1944 : 0 : Packages::iterator p = this->packages_.find(pkgpath);
1945 : 0 : go_assert(p != this->packages_.end());
1946 : 0 : return p->second->pkgpath_symbol();
1947 : : }
1948 : :
1949 : : // Start compiling a function.
1950 : :
1951 : : Named_object*
1952 : 283570 : Gogo::start_function(const std::string& name, Function_type* type,
1953 : : bool add_method_to_type, Location location)
1954 : : {
1955 : 283570 : bool at_top_level = this->functions_.empty();
1956 : :
1957 : 283570 : Block* block = new Block(NULL, location);
1958 : :
1959 : 283570 : Named_object* enclosing = (at_top_level
1960 : 283570 : ? NULL
1961 : 24308 : : this->functions_.back().function);
1962 : :
1963 : 283570 : Function* function = new Function(type, enclosing, block, location);
1964 : :
1965 : 283570 : if (type->is_method())
1966 : : {
1967 : 77457 : const Typed_identifier* receiver = type->receiver();
1968 : 77457 : Variable* this_param = new Variable(receiver->type(), NULL, false,
1969 : 77457 : true, true, location);
1970 : 77457 : std::string rname = receiver->name();
1971 : 77457 : unsigned rcounter = 0;
1972 : :
1973 : : // We need to give a nameless receiver parameter a synthesized name to
1974 : : // avoid having it clash with some other nameless param. FIXME.
1975 : 77457 : Gogo::rename_if_empty(&rname, "r", &rcounter);
1976 : :
1977 : 77457 : block->bindings()->add_variable(rname, NULL, this_param);
1978 : 77457 : }
1979 : :
1980 : 283570 : const Typed_identifier_list* parameters = type->parameters();
1981 : 283570 : bool is_varargs = type->is_varargs();
1982 : 283570 : unsigned pcounter = 0;
1983 : 283570 : if (parameters != NULL)
1984 : : {
1985 : 218169 : for (Typed_identifier_list::const_iterator p = parameters->begin();
1986 : 597335 : p != parameters->end();
1987 : 379166 : ++p)
1988 : : {
1989 : 379166 : Variable* param = new Variable(p->type(), NULL, false, true, false,
1990 : 379166 : p->location());
1991 : 379166 : if (is_varargs && p + 1 == parameters->end())
1992 : 2018 : param->set_is_varargs_parameter();
1993 : :
1994 : 379166 : std::string pname = p->name();
1995 : :
1996 : : // We need to give each nameless parameter a non-empty name to avoid
1997 : : // having it clash with some other nameless param. FIXME.
1998 : 379166 : Gogo::rename_if_empty(&pname, "p", &pcounter);
1999 : :
2000 : 379166 : block->bindings()->add_variable(pname, NULL, param);
2001 : 379166 : }
2002 : : }
2003 : :
2004 : 283570 : function->create_result_variables(this);
2005 : :
2006 : 283570 : const std::string* pname;
2007 : 283570 : std::string nested_name;
2008 : 283570 : bool is_init = false;
2009 : 567140 : if (Gogo::unpack_hidden_name(name) == "init" && !type->is_method())
2010 : : {
2011 : 1884 : if ((type->parameters() != NULL && !type->parameters()->empty())
2012 : 1884 : || (type->results() != NULL && !type->results()->empty()))
2013 : 0 : go_error_at(location,
2014 : : "func init must have no arguments and no return values");
2015 : : // There can be multiple "init" functions, so give them each a
2016 : : // different name.
2017 : 1884 : nested_name = this->init_function_name();
2018 : 1884 : pname = &nested_name;
2019 : 1884 : is_init = true;
2020 : : }
2021 : 281686 : else if (!name.empty())
2022 : : pname = &name;
2023 : : else
2024 : : {
2025 : : // Invent a name for a nested function.
2026 : 25609 : nested_name = this->nested_function_name(enclosing);
2027 : 25609 : pname = &nested_name;
2028 : : }
2029 : :
2030 : 283570 : Named_object* ret;
2031 : 283570 : if (Gogo::is_sink_name(*pname))
2032 : : {
2033 : 305 : std::string sname(this->sink_function_name());
2034 : 305 : ret = Named_object::make_function(sname, NULL, function);
2035 : 305 : ret->func_value()->set_is_sink();
2036 : :
2037 : 305 : if (!type->is_method())
2038 : 300 : ret = this->package_->bindings()->add_named_object(ret);
2039 : 5 : else if (add_method_to_type)
2040 : : {
2041 : : // We should report errors even for sink methods.
2042 : 5 : Type* rtype = type->receiver()->type();
2043 : : // Avoid points_to and deref to avoid getting an error if
2044 : : // the type is not yet defined.
2045 : 5 : if (rtype->classification() == Type::TYPE_POINTER)
2046 : 2 : rtype = rtype->points_to();
2047 : 5 : while (rtype->named_type() != NULL
2048 : 5 : && rtype->named_type()->is_alias())
2049 : 0 : rtype = rtype->named_type()->real_type()->forwarded();
2050 : 5 : if (rtype->is_error_type())
2051 : : ;
2052 : 5 : else if (rtype->named_type() != NULL)
2053 : : {
2054 : 4 : if (rtype->named_type()->named_object()->package() != NULL)
2055 : 0 : go_error_at(type->receiver()->location(),
2056 : : "may not define methods on non-local type");
2057 : : }
2058 : 1 : else if (rtype->forward_declaration_type() != NULL)
2059 : : {
2060 : : // Go ahead and add the method in case we need to report
2061 : : // an error when we see the definition.
2062 : 1 : rtype->forward_declaration_type()->add_existing_method(ret);
2063 : : }
2064 : : else
2065 : 0 : go_error_at(type->receiver()->location(),
2066 : : ("invalid receiver type "
2067 : : "(receiver must be a named type)"));
2068 : : }
2069 : 305 : }
2070 : 283265 : else if (!type->is_method())
2071 : : {
2072 : 205813 : ret = this->package_->bindings()->add_function(*pname, NULL, function);
2073 : 205813 : if (!ret->is_function() || ret->func_value() != function)
2074 : : {
2075 : : // Redefinition error. Invent a name to avoid knockon
2076 : : // errors.
2077 : 2 : std::string rname(this->redefined_function_name());
2078 : 2 : ret = this->package_->bindings()->add_function(rname, NULL, function);
2079 : 2 : }
2080 : : }
2081 : : else
2082 : : {
2083 : 77452 : if (!add_method_to_type)
2084 : 24262 : ret = Named_object::make_function(name, NULL, function);
2085 : : else
2086 : : {
2087 : 53190 : go_assert(at_top_level);
2088 : 53190 : Type* rtype = type->receiver()->type();
2089 : :
2090 : 53190 : while (rtype->named_type() != NULL
2091 : 53202 : && rtype->named_type()->is_alias())
2092 : 12 : rtype = rtype->named_type()->real_type()->forwarded();
2093 : :
2094 : : // We want to look through the pointer created by the
2095 : : // parser, without getting an error if the type is not yet
2096 : : // defined.
2097 : 53190 : if (rtype->classification() == Type::TYPE_POINTER)
2098 : 43456 : rtype = rtype->points_to();
2099 : :
2100 : 53192 : while (rtype->named_type() != NULL
2101 : 53192 : && rtype->named_type()->is_alias())
2102 : 2 : rtype = rtype->named_type()->real_type()->forwarded();
2103 : :
2104 : 53190 : if (rtype->is_error_type())
2105 : 0 : ret = Named_object::make_function(name, NULL, function);
2106 : 53190 : else if (rtype->named_type() != NULL)
2107 : : {
2108 : 50650 : if (rtype->named_type()->named_object()->package() != NULL)
2109 : : {
2110 : 3 : go_error_at(type->receiver()->location(),
2111 : : "may not define methods on non-local type");
2112 : 3 : ret = Named_object::make_function(name, NULL, function);
2113 : : }
2114 : : else
2115 : : {
2116 : 50647 : ret = rtype->named_type()->add_method(name, function);
2117 : 50647 : if (!ret->is_function())
2118 : : {
2119 : : // Redefinition error.
2120 : 2 : ret = Named_object::make_function(name, NULL, function);
2121 : : }
2122 : : }
2123 : : }
2124 : 2540 : else if (rtype->forward_declaration_type() != NULL)
2125 : : {
2126 : 2538 : Named_object* type_no =
2127 : 2538 : rtype->forward_declaration_type()->named_object();
2128 : 2538 : if (type_no->is_unknown())
2129 : : {
2130 : : // If we are seeing methods it really must be a
2131 : : // type. Declare it as such. An alternative would
2132 : : // be to support lists of methods for unknown
2133 : : // expressions. Either way the error messages if
2134 : : // this is not a type are going to get confusing.
2135 : 519 : Named_object* declared =
2136 : 519 : this->declare_package_type(type_no->name(),
2137 : : type_no->location());
2138 : 519 : go_assert(declared
2139 : : == type_no->unknown_value()->real_named_object());
2140 : : }
2141 : 2538 : ret = rtype->forward_declaration_type()->add_method(name,
2142 : : function);
2143 : : }
2144 : : else
2145 : : {
2146 : 2 : go_error_at(type->receiver()->location(),
2147 : : ("invalid receiver type (receiver must "
2148 : : "be a named type)"));
2149 : 2 : ret = Named_object::make_function(name, NULL, function);
2150 : : }
2151 : : }
2152 : 77452 : this->package_->bindings()->add_method(ret);
2153 : : }
2154 : :
2155 : 283570 : this->functions_.resize(this->functions_.size() + 1);
2156 : 283570 : Open_function& of(this->functions_.back());
2157 : 283570 : of.function = ret;
2158 : 283570 : of.blocks.push_back(block);
2159 : :
2160 : 283570 : if (is_init)
2161 : : {
2162 : 1884 : this->init_functions_.push_back(ret);
2163 : 1884 : this->need_init_fn_ = true;
2164 : : }
2165 : :
2166 : 283570 : return ret;
2167 : 283570 : }
2168 : :
2169 : : // Finish compiling a function.
2170 : :
2171 : : void
2172 : 283570 : Gogo::finish_function(Location location)
2173 : : {
2174 : 283570 : this->finish_block(location);
2175 : 283570 : go_assert(this->functions_.back().blocks.empty());
2176 : 283570 : this->functions_.pop_back();
2177 : 283570 : }
2178 : :
2179 : : // Return the current function.
2180 : :
2181 : : Named_object*
2182 : 2109334 : Gogo::current_function() const
2183 : : {
2184 : 2109334 : go_assert(!this->functions_.empty());
2185 : 2109334 : return this->functions_.back().function;
2186 : : }
2187 : :
2188 : : // Start a new block.
2189 : :
2190 : : void
2191 : 913094 : Gogo::start_block(Location location)
2192 : : {
2193 : 913094 : go_assert(!this->functions_.empty());
2194 : 913094 : Block* block = new Block(this->current_block(), location);
2195 : 913094 : this->functions_.back().blocks.push_back(block);
2196 : 913094 : }
2197 : :
2198 : : // Finish a block.
2199 : :
2200 : : Block*
2201 : 1196664 : Gogo::finish_block(Location location)
2202 : : {
2203 : 1196664 : go_assert(!this->functions_.empty());
2204 : 1196664 : go_assert(!this->functions_.back().blocks.empty());
2205 : 1196664 : Block* block = this->functions_.back().blocks.back();
2206 : 1196664 : this->functions_.back().blocks.pop_back();
2207 : 1196664 : block->set_end_location(location);
2208 : 1196664 : return block;
2209 : : }
2210 : :
2211 : : // Add an erroneous name.
2212 : :
2213 : : Named_object*
2214 : 14 : Gogo::add_erroneous_name(const std::string& name)
2215 : : {
2216 : 14 : return this->package_->bindings()->add_erroneous_name(name);
2217 : : }
2218 : :
2219 : : // Add an unknown name.
2220 : :
2221 : : Named_object*
2222 : 85587 : Gogo::add_unknown_name(const std::string& name, Location location)
2223 : : {
2224 : 85587 : return this->package_->bindings()->add_unknown_name(name, location);
2225 : : }
2226 : :
2227 : : // Declare a function.
2228 : :
2229 : : Named_object*
2230 : 5732 : Gogo::declare_function(const std::string& name, Function_type* type,
2231 : : Location location)
2232 : : {
2233 : 5732 : if (!type->is_method())
2234 : 5669 : return this->current_bindings()->add_function_declaration(name, NULL, type,
2235 : 5669 : location);
2236 : : else
2237 : : {
2238 : : // We don't bother to add this to the list of global
2239 : : // declarations.
2240 : 63 : Type* rtype = type->receiver()->type();
2241 : :
2242 : 63 : while (rtype->named_type() != NULL
2243 : 63 : && rtype->named_type()->is_alias())
2244 : 0 : rtype = rtype->named_type()->real_type()->forwarded();
2245 : :
2246 : : // We want to look through the pointer created by the
2247 : : // parser, without getting an error if the type is not yet
2248 : : // defined.
2249 : 63 : if (rtype->classification() == Type::TYPE_POINTER)
2250 : 5 : rtype = rtype->points_to();
2251 : :
2252 : 63 : while (rtype->named_type() != NULL
2253 : 63 : && rtype->named_type()->is_alias())
2254 : 0 : rtype = rtype->named_type()->real_type()->forwarded();
2255 : :
2256 : 63 : if (rtype->is_error_type())
2257 : : return NULL;
2258 : 63 : else if (rtype->named_type() != NULL)
2259 : 63 : return rtype->named_type()->add_method_declaration(name, NULL, type,
2260 : 63 : location);
2261 : 0 : else if (rtype->forward_declaration_type() != NULL)
2262 : : {
2263 : 0 : Forward_declaration_type* ftype = rtype->forward_declaration_type();
2264 : 0 : return ftype->add_method_declaration(name, NULL, type, location);
2265 : : }
2266 : : else
2267 : : {
2268 : 0 : go_error_at(type->receiver()->location(),
2269 : : "invalid receiver type (receiver must be a named type)");
2270 : 0 : return Named_object::make_erroneous_name(name);
2271 : : }
2272 : : }
2273 : : }
2274 : :
2275 : : // Add a label definition.
2276 : :
2277 : : Label*
2278 : 10525 : Gogo::add_label_definition(const std::string& label_name,
2279 : : Location location)
2280 : : {
2281 : 10525 : go_assert(!this->functions_.empty());
2282 : 10525 : Function* func = this->functions_.back().function->func_value();
2283 : 10525 : Label* label = func->add_label_definition(this, label_name, location);
2284 : 10525 : this->add_statement(Statement::make_label_statement(label, location));
2285 : 10525 : return label;
2286 : : }
2287 : :
2288 : : // Add a label reference.
2289 : :
2290 : : Label*
2291 : 10958 : Gogo::add_label_reference(const std::string& label_name,
2292 : : Location location, bool issue_goto_errors)
2293 : : {
2294 : 10958 : go_assert(!this->functions_.empty());
2295 : 10958 : Function* func = this->functions_.back().function->func_value();
2296 : 10958 : return func->add_label_reference(this, label_name, location,
2297 : 10958 : issue_goto_errors);
2298 : : }
2299 : :
2300 : : // Return the current binding state.
2301 : :
2302 : : Bindings_snapshot*
2303 : 12092 : Gogo::bindings_snapshot(Location location)
2304 : : {
2305 : 12092 : return new Bindings_snapshot(this->current_block(), location);
2306 : : }
2307 : :
2308 : : // Add a statement.
2309 : :
2310 : : void
2311 : 1798489 : Gogo::add_statement(Statement* statement)
2312 : : {
2313 : 1798489 : go_assert(!this->functions_.empty()
2314 : : && !this->functions_.back().blocks.empty());
2315 : 1798489 : this->functions_.back().blocks.back()->add_statement(statement);
2316 : 1798489 : }
2317 : :
2318 : : // Add a block.
2319 : :
2320 : : void
2321 : 444343 : Gogo::add_block(Block* block, Location location)
2322 : : {
2323 : 444343 : go_assert(!this->functions_.empty()
2324 : : && !this->functions_.back().blocks.empty());
2325 : 444343 : Statement* statement = Statement::make_block_statement(block, location);
2326 : 444343 : this->functions_.back().blocks.back()->add_statement(statement);
2327 : 444343 : }
2328 : :
2329 : : // Add a constant.
2330 : :
2331 : : Named_object*
2332 : 154509 : Gogo::add_constant(const Typed_identifier& tid, Expression* expr,
2333 : : int iota_value)
2334 : : {
2335 : 154509 : return this->current_bindings()->add_constant(tid, NULL, expr, iota_value);
2336 : : }
2337 : :
2338 : : // Add a type.
2339 : :
2340 : : void
2341 : 0 : Gogo::add_type(const std::string& name, Type* type, Location location)
2342 : : {
2343 : 0 : Named_object* no = this->current_bindings()->add_type(name, NULL, type,
2344 : : location);
2345 : 0 : if (!this->in_global_scope() && no->is_type())
2346 : : {
2347 : 0 : Named_object* f = this->functions_.back().function;
2348 : 0 : unsigned int index;
2349 : 0 : if (f->is_function())
2350 : 0 : index = f->func_value()->new_local_type_index();
2351 : : else
2352 : : index = 0;
2353 : 0 : no->type_value()->set_in_function(f, index);
2354 : : }
2355 : 0 : }
2356 : :
2357 : : // Add a named type.
2358 : :
2359 : : void
2360 : 97599 : Gogo::add_named_type(Named_type* type)
2361 : : {
2362 : 97599 : go_assert(this->in_global_scope());
2363 : 97599 : this->current_bindings()->add_named_type(type);
2364 : 97599 : }
2365 : :
2366 : : // Declare a type.
2367 : :
2368 : : Named_object*
2369 : 31990 : Gogo::declare_type(const std::string& name, Location location)
2370 : : {
2371 : 31990 : Bindings* bindings = this->current_bindings();
2372 : 31990 : Named_object* no = bindings->add_type_declaration(name, NULL, location);
2373 : 31990 : if (!this->in_global_scope() && no->is_type_declaration())
2374 : : {
2375 : 1295 : Named_object* f = this->functions_.back().function;
2376 : 1295 : unsigned int index;
2377 : 1295 : if (f->is_function())
2378 : 1295 : index = f->func_value()->new_local_type_index();
2379 : : else
2380 : : index = 0;
2381 : 1295 : no->type_declaration_value()->set_in_function(f, index);
2382 : : }
2383 : 31990 : return no;
2384 : : }
2385 : :
2386 : : // Declare a type at the package level.
2387 : :
2388 : : Named_object*
2389 : 519 : Gogo::declare_package_type(const std::string& name, Location location)
2390 : : {
2391 : 519 : return this->package_->bindings()->add_type_declaration(name, NULL, location);
2392 : : }
2393 : :
2394 : : // Declare a function at the package level.
2395 : :
2396 : : Named_object*
2397 : 92810 : Gogo::declare_package_function(const std::string& name, Function_type* type,
2398 : : Location location)
2399 : : {
2400 : 92810 : return this->package_->bindings()->add_function_declaration(name, NULL, type,
2401 : 92810 : location);
2402 : : }
2403 : :
2404 : : // Add a function declaration to the list of functions we may want to
2405 : : // inline.
2406 : :
2407 : : void
2408 : 82289 : Gogo::add_imported_inlinable_function(Named_object* no)
2409 : : {
2410 : 82289 : go_assert(no->is_function_declaration());
2411 : 82289 : Function_declaration* fd = no->func_declaration_value();
2412 : 82289 : if (fd->is_on_inlinable_list())
2413 : : return;
2414 : 12247 : this->imported_inlinable_functions_.push_back(no);
2415 : 12247 : fd->set_is_on_inlinable_list();
2416 : : }
2417 : :
2418 : : // Define a type which was already declared.
2419 : :
2420 : : void
2421 : 31990 : Gogo::define_type(Named_object* no, Named_type* type)
2422 : : {
2423 : 31990 : this->current_bindings()->define_type(no, type);
2424 : 31990 : }
2425 : :
2426 : : // Add a variable.
2427 : :
2428 : : Named_object*
2429 : 405952 : Gogo::add_variable(const std::string& name, Variable* variable)
2430 : : {
2431 : 405952 : Named_object* no = this->current_bindings()->add_variable(name, NULL,
2432 : : variable);
2433 : :
2434 : : // In a function the middle-end wants to see a DECL_EXPR node.
2435 : 405952 : if (no != NULL
2436 : 405952 : && no->is_variable()
2437 : 405950 : && !no->var_value()->is_parameter()
2438 : 811901 : && !this->functions_.empty())
2439 : 380475 : this->add_statement(Statement::make_variable_declaration(no));
2440 : :
2441 : 405952 : return no;
2442 : : }
2443 : :
2444 : : void
2445 : 474197 : Gogo::rename_if_empty(std::string* pname, const char* tag, unsigned* count)
2446 : : {
2447 : 474197 : if (pname->empty() || Gogo::is_sink_name(*pname))
2448 : : {
2449 : 3395 : char buf[50];
2450 : 3395 : go_assert(strlen(tag) < 10);
2451 : 3395 : snprintf(buf, sizeof buf, "%s.%u", tag, *count);
2452 : 3395 : ++(*count);
2453 : 3395 : *pname = buf;
2454 : : }
2455 : 474197 : }
2456 : :
2457 : :
2458 : : // Add a sink--a reference to the blank identifier _.
2459 : :
2460 : : Named_object*
2461 : 19303 : Gogo::add_sink()
2462 : : {
2463 : 19303 : return Named_object::make_sink();
2464 : : }
2465 : :
2466 : : // Add a named object for a dot import.
2467 : :
2468 : : void
2469 : 62469 : Gogo::add_dot_import_object(Named_object* no)
2470 : : {
2471 : : // If the name already exists, then it was defined in some file seen
2472 : : // earlier. If the earlier name is just a declaration, don't add
2473 : : // this name, because that will cause the previous declaration to
2474 : : // merge to this imported name, which should not happen. Just add
2475 : : // this name to the list of file block names to get appropriate
2476 : : // errors if we see a later definition.
2477 : 62469 : Named_object* e = this->package_->bindings()->lookup(no->name());
2478 : 62469 : if (e != NULL && e->package() == NULL)
2479 : : {
2480 : 1 : if (e->is_unknown())
2481 : 1 : e = e->resolve();
2482 : 1 : if (e->package() == NULL
2483 : 1 : && (e->is_type_declaration()
2484 : : || e->is_function_declaration()
2485 : : || e->is_unknown()))
2486 : : {
2487 : 1 : this->add_file_block_name(no->name(), no->location());
2488 : 1 : return;
2489 : : }
2490 : : }
2491 : :
2492 : 62468 : this->current_bindings()->add_named_object(no);
2493 : : }
2494 : :
2495 : : // Add a linkname. This implements the go:linkname compiler directive.
2496 : : // We only support this for functions and function declarations.
2497 : :
2498 : : void
2499 : 3913 : Gogo::add_linkname(const std::string& go_name, bool is_exported,
2500 : : const std::string& ext_name, Location loc)
2501 : : {
2502 : 3913 : Named_object* no =
2503 : 3913 : this->package_->bindings()->lookup(this->pack_hidden_name(go_name,
2504 : : is_exported));
2505 : 3913 : if (no == NULL)
2506 : 0 : go_error_at(loc, "%s is not defined", go_name.c_str());
2507 : 3913 : else if (no->is_function())
2508 : : {
2509 : 2641 : if (ext_name.empty())
2510 : 1673 : no->func_value()->set_is_exported_by_linkname();
2511 : : else
2512 : 968 : no->func_value()->set_asm_name(ext_name);
2513 : : }
2514 : 1272 : else if (no->is_function_declaration())
2515 : : {
2516 : 1272 : if (ext_name.empty())
2517 : 0 : go_error_at(loc,
2518 : : ("%<//go:linkname%> missing external name "
2519 : : "for declaration of %s"),
2520 : : go_name.c_str());
2521 : : else
2522 : 1272 : no->func_declaration_value()->set_asm_name(ext_name);
2523 : : }
2524 : : else
2525 : 0 : go_error_at(loc,
2526 : : ("%s is not a function; "
2527 : : "%<//go:linkname%> is only supported for functions"),
2528 : : go_name.c_str());
2529 : 3913 : }
2530 : :
2531 : : // Mark all local variables used. This is used when some types of
2532 : : // parse error occur.
2533 : :
2534 : : void
2535 : 79 : Gogo::mark_locals_used()
2536 : : {
2537 : 119 : for (Open_functions::iterator pf = this->functions_.begin();
2538 : 119 : pf != this->functions_.end();
2539 : 40 : ++pf)
2540 : : {
2541 : 96 : for (std::vector<Block*>::iterator pb = pf->blocks.begin();
2542 : 96 : pb != pf->blocks.end();
2543 : 56 : ++pb)
2544 : 56 : (*pb)->bindings()->mark_locals_used();
2545 : : }
2546 : 79 : }
2547 : :
2548 : : // Record that we've seen an interface type.
2549 : :
2550 : : void
2551 : 71624 : Gogo::record_interface_type(Interface_type* itype)
2552 : : {
2553 : 71624 : this->interface_types_.push_back(itype);
2554 : 71624 : }
2555 : :
2556 : : // Define the global names. We do this only after parsing all the
2557 : : // input files, because the program might define the global names
2558 : : // itself.
2559 : :
2560 : : void
2561 : 4646 : Gogo::define_global_names()
2562 : : {
2563 : 4646 : if (this->is_main_package())
2564 : : {
2565 : : // Every Go program has to import the runtime package, so that
2566 : : // it is properly initialized. We can't use
2567 : : // predeclared_location here as it will cause runtime functions
2568 : : // to appear to be builtin functions.
2569 : 1889 : this->import_package("runtime", "_", false, false,
2570 : 1889 : this->package_->location());
2571 : : }
2572 : :
2573 : 185840 : for (Bindings::const_declarations_iterator p =
2574 : 4646 : this->globals_->begin_declarations();
2575 : 190486 : p != this->globals_->end_declarations();
2576 : 185840 : ++p)
2577 : : {
2578 : 185840 : Named_object* global_no = p->second;
2579 : 185840 : std::string name(Gogo::pack_hidden_name(global_no->name(), false));
2580 : 185840 : Named_object* no = this->package_->bindings()->lookup(name);
2581 : 185840 : if (no == NULL)
2582 : 155926 : continue;
2583 : 29914 : no = no->resolve();
2584 : 29914 : if (no->is_type_declaration())
2585 : : {
2586 : 2 : if (global_no->is_type())
2587 : : {
2588 : 2 : if (no->type_declaration_value()->has_methods())
2589 : : {
2590 : 4 : for (std::vector<Named_object*>::const_iterator pm =
2591 : 2 : no->type_declaration_value()->methods()->begin();
2592 : 4 : pm != no->type_declaration_value()->methods()->end();
2593 : 2 : pm++)
2594 : 2 : go_error_at((*pm)->location(),
2595 : : "may not define methods on non-local type");
2596 : : }
2597 : 2 : no->set_type_value(global_no->type_value());
2598 : : }
2599 : : else
2600 : : {
2601 : 0 : go_error_at(no->location(), "expected type");
2602 : 0 : Type* errtype = Type::make_error_type();
2603 : 0 : Named_object* err =
2604 : 0 : Named_object::make_type("erroneous_type", NULL, errtype,
2605 : : Linemap::predeclared_location());
2606 : 0 : no->set_type_value(err->type_value());
2607 : : }
2608 : : }
2609 : 29912 : else if (no->is_unknown())
2610 : 29815 : no->unknown_value()->set_real_named_object(global_no);
2611 : 185840 : }
2612 : :
2613 : : // Give an error if any name is defined in both the package block
2614 : : // and the file block. For example, this can happen if one file
2615 : : // imports "fmt" and another file defines a global variable fmt.
2616 : 336526 : for (Bindings::const_declarations_iterator p =
2617 : 4646 : this->package_->bindings()->begin_declarations();
2618 : 341172 : p != this->package_->bindings()->end_declarations();
2619 : 336526 : ++p)
2620 : : {
2621 : 336526 : if (p->second->is_unknown()
2622 : 336526 : && p->second->unknown_value()->real_named_object() == NULL)
2623 : : {
2624 : : // No point in warning about an undefined name, as we will
2625 : : // get other errors later anyhow.
2626 : 53 : continue;
2627 : : }
2628 : 336473 : File_block_names::const_iterator pf =
2629 : 336473 : this->file_block_names_.find(p->second->name());
2630 : 336473 : if (pf != this->file_block_names_.end())
2631 : : {
2632 : 1 : std::string n = p->second->message_name();
2633 : 1 : go_error_at(p->second->location(),
2634 : : "%qs defined as both imported name and global name",
2635 : : n.c_str());
2636 : 1 : go_inform(pf->second, "%qs imported here", n.c_str());
2637 : 1 : }
2638 : :
2639 : : // No package scope identifier may be named "init".
2640 : 672946 : if (!p->second->is_function()
2641 : 336473 : && Gogo::unpack_hidden_name(p->second->name()) == "init")
2642 : : {
2643 : 4 : go_error_at(p->second->location(),
2644 : : "cannot declare init - must be func");
2645 : : }
2646 : : }
2647 : 4646 : }
2648 : :
2649 : : // Clear out names in file scope.
2650 : :
2651 : : void
2652 : 12707 : Gogo::clear_file_scope()
2653 : : {
2654 : 12707 : this->package_->bindings()->clear_file_scope(this);
2655 : :
2656 : : // Warn about packages which were imported but not used.
2657 : 12707 : bool quiet = saw_errors();
2658 : 375205 : for (Packages::iterator p = this->packages_.begin();
2659 : 375205 : p != this->packages_.end();
2660 : 362498 : ++p)
2661 : : {
2662 : 362498 : Package* package = p->second;
2663 : 362498 : if (package != this->package_ && !quiet)
2664 : : {
2665 : 389161 : for (Package::Aliases::const_iterator p1 = package->aliases().begin();
2666 : 389161 : p1 != package->aliases().end();
2667 : 39719 : ++p1)
2668 : : {
2669 : 39719 : if (!p1->second->used())
2670 : : {
2671 : : // Give a more refined error message if the alias name is known.
2672 : 13 : std::string pkg_name = package->package_name();
2673 : 13 : if (p1->first != pkg_name && p1->first[0] != '.')
2674 : : {
2675 : 8 : go_error_at(p1->second->location(),
2676 : : "imported and not used: %s as %s",
2677 : 8 : Gogo::message_name(pkg_name).c_str(),
2678 : 8 : Gogo::message_name(p1->first).c_str());
2679 : : }
2680 : : else
2681 : 9 : go_error_at(p1->second->location(),
2682 : : "imported and not used: %s",
2683 : 18 : Gogo::message_name(pkg_name).c_str());
2684 : 13 : }
2685 : : }
2686 : : }
2687 : 362498 : package->clear_used();
2688 : : }
2689 : :
2690 : 12707 : this->current_file_imported_unsafe_ = false;
2691 : 12707 : this->current_file_imported_embed_ = false;
2692 : 12707 : }
2693 : :
2694 : : // Queue up a type-specific hash function for later writing. These
2695 : : // are written out in write_specific_type_functions, called after the
2696 : : // parse tree is lowered.
2697 : :
2698 : : void
2699 : 1 : Gogo::queue_hash_function(Type* type, int64_t size, Backend_name* bname,
2700 : : Function_type* hash_fntype)
2701 : : {
2702 : 1 : go_assert(!this->specific_type_functions_are_written_);
2703 : 1 : go_assert(!this->in_global_scope());
2704 : 1 : Specific_type_function::Specific_type_function_kind kind =
2705 : : Specific_type_function::SPECIFIC_HASH;
2706 : 1 : Specific_type_function* tsf = new Specific_type_function(type, NULL, size,
2707 : : kind, bname,
2708 : 1 : hash_fntype);
2709 : 1 : this->specific_type_functions_.push_back(tsf);
2710 : 1 : }
2711 : :
2712 : : // Queue up a type-specific equal function for later writing. These
2713 : : // are written out in write_specific_type_functions, called after the
2714 : : // parse tree is lowered.
2715 : :
2716 : : void
2717 : 75 : Gogo::queue_equal_function(Type* type, Named_type* name, int64_t size,
2718 : : Backend_name* bname, Function_type* equal_fntype)
2719 : : {
2720 : 75 : go_assert(!this->specific_type_functions_are_written_);
2721 : 75 : go_assert(!this->in_global_scope());
2722 : 75 : Specific_type_function::Specific_type_function_kind kind =
2723 : : Specific_type_function::SPECIFIC_EQUAL;
2724 : 75 : Specific_type_function* tsf = new Specific_type_function(type, name, size,
2725 : : kind, bname,
2726 : 75 : equal_fntype);
2727 : 75 : this->specific_type_functions_.push_back(tsf);
2728 : 75 : }
2729 : :
2730 : : // Look for types which need specific hash or equality functions.
2731 : :
2732 : 9292 : class Specific_type_functions : public Traverse
2733 : : {
2734 : : public:
2735 : 4646 : Specific_type_functions(Gogo* gogo)
2736 : 4646 : : Traverse(traverse_types),
2737 : 4646 : gogo_(gogo)
2738 : : { }
2739 : :
2740 : : int
2741 : : type(Type*);
2742 : :
2743 : : private:
2744 : : Gogo* gogo_;
2745 : : };
2746 : :
2747 : : int
2748 : 11347705 : Specific_type_functions::type(Type* t)
2749 : : {
2750 : 11347705 : switch (t->classification())
2751 : : {
2752 : 688700 : case Type::TYPE_NAMED:
2753 : 688700 : {
2754 : 688700 : Named_type* nt = t->named_type();
2755 : 688700 : if (nt->is_alias())
2756 : : return TRAVERSE_CONTINUE;
2757 : 665511 : if (t->needs_specific_type_functions(this->gogo_))
2758 : 360328 : t->equal_function(this->gogo_, nt, NULL);
2759 : :
2760 : : // If this is a struct type, we don't want to make functions
2761 : : // for the unnamed struct.
2762 : 665511 : Type* rt = nt->real_type();
2763 : 665511 : if (rt->struct_type() == NULL)
2764 : : {
2765 : 256727 : if (Type::traverse(rt, this) == TRAVERSE_EXIT)
2766 : : return TRAVERSE_EXIT;
2767 : : }
2768 : : else
2769 : : {
2770 : : // If this type is defined in another package, then we don't
2771 : : // need to worry about the unexported fields.
2772 : 408784 : bool is_defined_elsewhere = nt->named_object()->package() != NULL;
2773 : 817568 : const Struct_field_list* fields = rt->struct_type()->fields();
2774 : 2687947 : for (Struct_field_list::const_iterator p = fields->begin();
2775 : 2687947 : p != fields->end();
2776 : 2279163 : ++p)
2777 : : {
2778 : 3850234 : if (is_defined_elsewhere
2779 : 2279163 : && Gogo::is_hidden_name(p->field_name()))
2780 : 1571071 : continue;
2781 : 708092 : if (Type::traverse(p->type(), this) == TRAVERSE_EXIT)
2782 : 0 : return TRAVERSE_EXIT;
2783 : : }
2784 : : }
2785 : :
2786 : : return TRAVERSE_SKIP_COMPONENTS;
2787 : : }
2788 : :
2789 : 680219 : case Type::TYPE_STRUCT:
2790 : 680219 : case Type::TYPE_ARRAY:
2791 : 680219 : if (t->needs_specific_type_functions(this->gogo_))
2792 : 165530 : t->equal_function(this->gogo_, NULL, NULL);
2793 : : break;
2794 : :
2795 : 77572 : case Type::TYPE_MAP:
2796 : 77572 : {
2797 : 155144 : Type* key_type = t->map_type()->key_type()->unalias();
2798 : 77572 : if (key_type->needs_specific_type_functions(this->gogo_))
2799 : 37920 : key_type->hash_function(this->gogo_, NULL);
2800 : : }
2801 : : break;
2802 : :
2803 : : default:
2804 : : break;
2805 : : }
2806 : :
2807 : : return TRAVERSE_CONTINUE;
2808 : : }
2809 : :
2810 : : // Write out type specific functions.
2811 : :
2812 : : void
2813 : 4646 : Gogo::write_specific_type_functions()
2814 : : {
2815 : 4646 : Specific_type_functions stf(this);
2816 : 4646 : this->traverse(&stf);
2817 : :
2818 : 9368 : while (!this->specific_type_functions_.empty())
2819 : : {
2820 : 76 : Specific_type_function* tsf = this->specific_type_functions_.back();
2821 : 76 : this->specific_type_functions_.pop_back();
2822 : 76 : if (tsf->kind == Specific_type_function::SPECIFIC_HASH)
2823 : 1 : tsf->type->write_hash_function(this, tsf->size, &tsf->bname,
2824 : : tsf->fntype);
2825 : : else
2826 : 75 : tsf->type->write_equal_function(this, tsf->name, tsf->size,
2827 : 75 : &tsf->bname, tsf->fntype);
2828 : 152 : delete tsf;
2829 : : }
2830 : 4646 : this->specific_type_functions_are_written_ = true;
2831 : 4646 : }
2832 : :
2833 : : // Traverse the tree.
2834 : :
2835 : : void
2836 : 93447 : Gogo::traverse(Traverse* traverse)
2837 : : {
2838 : : // Traverse the current package first for consistency. The other
2839 : : // packages will only contain imported types, constants, and
2840 : : // declarations.
2841 : 93447 : if (this->package_->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
2842 : : return;
2843 : 2497779 : for (Packages::const_iterator p = this->packages_.begin();
2844 : 2497779 : p != this->packages_.end();
2845 : 2404332 : ++p)
2846 : : {
2847 : 2404332 : if (p->second != this->package_)
2848 : : {
2849 : 2310885 : if (p->second->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
2850 : : break;
2851 : : }
2852 : : }
2853 : : }
2854 : :
2855 : : // Add a type to verify. This is used for types of sink variables, in
2856 : : // order to give appropriate error messages.
2857 : :
2858 : : void
2859 : 2352 : Gogo::add_type_to_verify(Type* type)
2860 : : {
2861 : 2352 : this->verify_types_.push_back(type);
2862 : 2352 : }
2863 : :
2864 : : // Traversal class used to verify types.
2865 : :
2866 : 9292 : class Verify_types : public Traverse
2867 : : {
2868 : : public:
2869 : 4646 : Verify_types(Gogo* gogo)
2870 : 4646 : : Traverse(traverse_types),
2871 : 4646 : gogo_(gogo)
2872 : : { }
2873 : :
2874 : : int
2875 : : type(Type*);
2876 : :
2877 : : private:
2878 : : Gogo* gogo_;
2879 : : };
2880 : :
2881 : : // Verify that a type is correct.
2882 : :
2883 : : int
2884 : 9986724 : Verify_types::type(Type* t)
2885 : : {
2886 : 9986724 : if (!t->verify(this->gogo_))
2887 : 46 : return TRAVERSE_SKIP_COMPONENTS;
2888 : : return TRAVERSE_CONTINUE;
2889 : : }
2890 : :
2891 : : // Verify that all types are correct.
2892 : :
2893 : : void
2894 : 4646 : Gogo::verify_types()
2895 : : {
2896 : 4646 : Verify_types traverse(this);
2897 : 4646 : this->traverse(&traverse);
2898 : :
2899 : 4646 : for (std::vector<Type*>::iterator p = this->verify_types_.begin();
2900 : 6998 : p != this->verify_types_.end();
2901 : 2352 : ++p)
2902 : 2352 : (*p)->verify(this);
2903 : 5046 : this->verify_types_.clear();
2904 : 4646 : }
2905 : :
2906 : : // Traversal class used to lower parse tree.
2907 : :
2908 : 4646 : class Lower_parse_tree : public Traverse
2909 : : {
2910 : : public:
2911 : 1845617 : Lower_parse_tree(Gogo* gogo, Named_object* function)
2912 : : : Traverse(traverse_variables
2913 : : | traverse_constants
2914 : : | traverse_functions
2915 : : | traverse_statements
2916 : : | traverse_expressions),
2917 : 1845617 : gogo_(gogo), function_(function), inserter_()
2918 : : { }
2919 : :
2920 : : void
2921 : 509729 : set_inserter(const Statement_inserter* inserter)
2922 : 509729 : { this->inserter_ = *inserter; }
2923 : :
2924 : : int
2925 : : variable(Named_object*);
2926 : :
2927 : : int
2928 : : constant(Named_object*, bool);
2929 : :
2930 : : int
2931 : : function(Named_object*);
2932 : :
2933 : : int
2934 : : statement(Block*, size_t* pindex, Statement*);
2935 : :
2936 : : int
2937 : : expression(Expression**);
2938 : :
2939 : : private:
2940 : : // General IR.
2941 : : Gogo* gogo_;
2942 : : // The function we are traversing.
2943 : : Named_object* function_;
2944 : : // Current statement inserter for use by expressions.
2945 : : Statement_inserter inserter_;
2946 : : };
2947 : :
2948 : : // Lower variables.
2949 : :
2950 : : int
2951 : 1303459 : Lower_parse_tree::variable(Named_object* no)
2952 : : {
2953 : 1303459 : if (!no->is_variable())
2954 : : return TRAVERSE_CONTINUE;
2955 : :
2956 : 1160523 : if (no->is_variable() && no->var_value()->is_global())
2957 : : {
2958 : : // Global variables can have loops in their initialization
2959 : : // expressions. This is handled in lower_init_expression.
2960 : 348764 : no->var_value()->lower_init_expression(this->gogo_, this->function_,
2961 : : &this->inserter_);
2962 : 348764 : return TRAVERSE_CONTINUE;
2963 : : }
2964 : :
2965 : : // This is a local variable. We are going to return
2966 : : // TRAVERSE_SKIP_COMPONENTS here because we want to traverse the
2967 : : // initialization expression when we reach the variable declaration
2968 : : // statement. However, that means that we need to traverse the type
2969 : : // ourselves.
2970 : 811759 : if (no->var_value()->has_type())
2971 : : {
2972 : 811759 : Type* type = no->var_value()->type();
2973 : 811759 : if (type != NULL)
2974 : : {
2975 : 811759 : if (Type::traverse(type, this) == TRAVERSE_EXIT)
2976 : : return TRAVERSE_EXIT;
2977 : : }
2978 : : }
2979 : 811759 : go_assert(!no->var_value()->has_pre_init());
2980 : :
2981 : : return TRAVERSE_SKIP_COMPONENTS;
2982 : : }
2983 : :
2984 : : // Lower constants. We handle constants specially so that we can set
2985 : : // the right value for the predeclared constant iota. This works in
2986 : : // conjunction with the way we lower Const_expression objects.
2987 : :
2988 : : int
2989 : 2205307 : Lower_parse_tree::constant(Named_object* no, bool)
2990 : : {
2991 : 2205307 : Named_constant* nc = no->const_value();
2992 : :
2993 : : // Don't get into trouble if the constant's initializer expression
2994 : : // refers to the constant itself.
2995 : 2205307 : if (nc->lowering())
2996 : : return TRAVERSE_CONTINUE;
2997 : 2205307 : nc->set_lowering();
2998 : :
2999 : 2205307 : nc->traverse_expression(this);
3000 : :
3001 : 2205307 : nc->clear_lowering();
3002 : :
3003 : : // We will traverse the expression a second time, but that will be
3004 : : // fast.
3005 : :
3006 : 2205307 : return TRAVERSE_CONTINUE;
3007 : : }
3008 : :
3009 : : // Lower the body of a function, and set the closure type. Record the
3010 : : // function while lowering it, so that we can pass it down when
3011 : : // lowering an expression.
3012 : :
3013 : : int
3014 : 175648 : Lower_parse_tree::function(Named_object* no)
3015 : : {
3016 : 175648 : go_assert(this->function_ == NULL);
3017 : 175648 : this->function_ = no;
3018 : 175648 : int t = no->func_value()->traverse(this);
3019 : 175648 : this->function_ = NULL;
3020 : :
3021 : 175648 : if (t == TRAVERSE_EXIT)
3022 : 0 : return t;
3023 : : return TRAVERSE_SKIP_COMPONENTS;
3024 : : }
3025 : :
3026 : : // Lower statement parse trees.
3027 : :
3028 : : int
3029 : 6344381 : Lower_parse_tree::statement(Block* block, size_t* pindex, Statement* sorig)
3030 : : {
3031 : : // Because we explicitly traverse the statement's contents
3032 : : // ourselves, we want to skip block statements here. There is
3033 : : // nothing to lower in a block statement.
3034 : 6344381 : if (sorig->is_block_statement())
3035 : : return TRAVERSE_CONTINUE;
3036 : :
3037 : 5282412 : Statement_inserter hold_inserter(this->inserter_);
3038 : 5282412 : this->inserter_ = Statement_inserter(block, pindex);
3039 : :
3040 : : // Lower the expressions first.
3041 : 5282412 : int t = sorig->traverse_contents(this);
3042 : 5282412 : if (t == TRAVERSE_EXIT)
3043 : : {
3044 : 0 : this->inserter_ = hold_inserter;
3045 : 0 : return t;
3046 : : }
3047 : :
3048 : : // Keep lowering until nothing changes.
3049 : : Statement* s = sorig;
3050 : 5998487 : while (true)
3051 : : {
3052 : 5998487 : Statement* snew = s->lower(this->gogo_, this->function_, block,
3053 : : &this->inserter_);
3054 : 5998487 : if (snew == s)
3055 : : break;
3056 : 716075 : s = snew;
3057 : 716075 : t = s->traverse_contents(this);
3058 : 716075 : if (t == TRAVERSE_EXIT)
3059 : : {
3060 : 0 : this->inserter_ = hold_inserter;
3061 : 0 : return t;
3062 : : }
3063 : : }
3064 : :
3065 : 5282412 : if (s != sorig)
3066 : 657256 : block->replace_statement(*pindex, s);
3067 : :
3068 : 5282412 : this->inserter_ = hold_inserter;
3069 : 5282412 : return TRAVERSE_SKIP_COMPONENTS;
3070 : : }
3071 : :
3072 : : // Lower expression parse trees.
3073 : :
3074 : : int
3075 : 29684106 : Lower_parse_tree::expression(Expression** pexpr)
3076 : : {
3077 : : // We have to lower all subexpressions first, so that we can get
3078 : : // their type if necessary. This is awkward, because we don't have
3079 : : // a postorder traversal pass.
3080 : 29684106 : if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
3081 : : return TRAVERSE_EXIT;
3082 : : // Keep lowering until nothing changes.
3083 : 33713870 : while (true)
3084 : : {
3085 : 31698988 : Expression* e = *pexpr;
3086 : 31698988 : Expression* enew = e->lower(this->gogo_, this->function_,
3087 : : &this->inserter_);
3088 : 31698988 : if (enew == e)
3089 : : break;
3090 : 2014882 : if (enew->traverse_subexpressions(this) == TRAVERSE_EXIT)
3091 : : return TRAVERSE_EXIT;
3092 : 2014882 : *pexpr = enew;
3093 : 2014882 : }
3094 : :
3095 : : // Lower the type of this expression before the parent looks at it,
3096 : : // in case the type contains an array that has expressions in its
3097 : : // length. Skip an Unknown_expression, as at this point that means
3098 : : // a composite literal key that does not have a type.
3099 : 29684106 : if ((*pexpr)->unknown_expression() == NULL)
3100 : 29684106 : Type::traverse((*pexpr)->type(), this);
3101 : :
3102 : : return TRAVERSE_SKIP_COMPONENTS;
3103 : : }
3104 : :
3105 : : // Lower the parse tree. This is called after the parse is complete,
3106 : : // when all names should be resolved.
3107 : :
3108 : : void
3109 : 4646 : Gogo::lower_parse_tree()
3110 : : {
3111 : 4646 : Lower_parse_tree lower_parse_tree(this, NULL);
3112 : 4646 : this->traverse(&lower_parse_tree);
3113 : :
3114 : : // If we found any functions defined in other packages that are
3115 : : // inlinables, import their bodies and turn them into functions.
3116 : : //
3117 : : // Note that as we import inlinable functions we may find more
3118 : : // inlinable functions, so don't use an iterator.
3119 : 16893 : for (size_t i = 0; i < this->imported_inlinable_functions_.size(); i++)
3120 : : {
3121 : 12247 : Named_object* no = this->imported_inlinable_functions_[i];
3122 : 12247 : no->func_declaration_value()->import_function_body(this, no);
3123 : : }
3124 : :
3125 : : // There might be type definitions that involve expressions such as the
3126 : : // array length. Make sure to lower these expressions as well. Otherwise,
3127 : : // errors hidden within a type can introduce unexpected errors into later
3128 : : // passes.
3129 : 4646 : for (std::vector<Type*>::iterator p = this->verify_types_.begin();
3130 : 4646 : p != this->verify_types_.end();
3131 : 0 : ++p)
3132 : 0 : Type::traverse(*p, &lower_parse_tree);
3133 : 4646 : }
3134 : :
3135 : : // Lower a block.
3136 : :
3137 : : void
3138 : 121652 : Gogo::lower_block(Named_object* function, Block* block)
3139 : : {
3140 : 121652 : Lower_parse_tree lower_parse_tree(this, function);
3141 : 121652 : block->traverse(&lower_parse_tree);
3142 : 121652 : }
3143 : :
3144 : : // Lower an expression. INSERTER may be NULL, in which case the
3145 : : // expression had better not need to create any temporaries.
3146 : :
3147 : : void
3148 : 526274 : Gogo::lower_expression(Named_object* function, Statement_inserter* inserter,
3149 : : Expression** pexpr)
3150 : : {
3151 : 526274 : Lower_parse_tree lower_parse_tree(this, function);
3152 : 526274 : if (inserter != NULL)
3153 : 509729 : lower_parse_tree.set_inserter(inserter);
3154 : 526274 : lower_parse_tree.expression(pexpr);
3155 : 526274 : }
3156 : :
3157 : : // Lower a constant. This is called when lowering a reference to a
3158 : : // constant. We have to make sure that the constant has already been
3159 : : // lowered.
3160 : :
3161 : : void
3162 : 1193045 : Gogo::lower_constant(Named_object* no)
3163 : : {
3164 : 1193045 : go_assert(no->is_const());
3165 : 1193045 : Lower_parse_tree lower(this, NULL);
3166 : 1193045 : lower.constant(no, false);
3167 : 1193045 : }
3168 : :
3169 : : // Make implicit type conversions explicit. Currently only does for
3170 : : // interface conversions, so the escape analysis can see them and
3171 : : // optimize.
3172 : :
3173 : 36574 : class Add_conversions : public Traverse
3174 : : {
3175 : : public:
3176 : 18287 : Add_conversions()
3177 : : : Traverse(traverse_statements
3178 : 18287 : | traverse_expressions)
3179 : : { }
3180 : :
3181 : : int
3182 : : statement(Block*, size_t* pindex, Statement*);
3183 : :
3184 : : int
3185 : : expression(Expression**);
3186 : : };
3187 : :
3188 : : // Add explicit conversions in a statement.
3189 : :
3190 : : int
3191 : 3845075 : Add_conversions::statement(Block*, size_t*, Statement* sorig)
3192 : : {
3193 : 3845075 : sorig->add_conversions();
3194 : 3845075 : return TRAVERSE_CONTINUE;
3195 : : }
3196 : :
3197 : : // Add explicit conversions in an expression.
3198 : :
3199 : : int
3200 : 11383814 : Add_conversions::expression(Expression** pexpr)
3201 : : {
3202 : 11383814 : (*pexpr)->add_conversions();
3203 : 11383814 : return TRAVERSE_CONTINUE;
3204 : : }
3205 : :
3206 : : void
3207 : 4646 : Gogo::add_conversions()
3208 : : {
3209 : 4646 : Add_conversions add_conversions;
3210 : 4646 : this->traverse(&add_conversions);
3211 : 4646 : }
3212 : :
3213 : : void
3214 : 13641 : Gogo::add_conversions_in_block(Block *b)
3215 : : {
3216 : 13641 : Add_conversions add_conversions;
3217 : 13641 : b->traverse(&add_conversions);
3218 : 13641 : }
3219 : :
3220 : : // Traversal class for simple deadcode elimination.
3221 : :
3222 : 9292 : class Remove_deadcode : public Traverse
3223 : : {
3224 : : public:
3225 : 4646 : Remove_deadcode(Gogo* gogo)
3226 : 4646 : : Traverse(traverse_statements
3227 : : | traverse_expressions),
3228 : 4646 : gogo_(gogo)
3229 : : { }
3230 : :
3231 : : int
3232 : : statement(Block*, size_t* pindex, Statement*);
3233 : :
3234 : : int
3235 : : expression(Expression**);
3236 : :
3237 : : private:
3238 : : Gogo* gogo_;
3239 : : };
3240 : :
3241 : : // Remove deadcode in a statement.
3242 : :
3243 : : int
3244 : 3792796 : Remove_deadcode::statement(Block* block, size_t* pindex, Statement* sorig)
3245 : : {
3246 : 3792796 : Location loc = sorig->location();
3247 : 3792796 : If_statement* ifs = sorig->if_statement();
3248 : 336470 : if (ifs != NULL)
3249 : : {
3250 : : // Remove the dead branch of an if statement.
3251 : 336470 : bool bval;
3252 : 336470 : if (ifs->condition()->boolean_constant_value(&bval))
3253 : : {
3254 : 4381 : Statement* s;
3255 : 4381 : if (bval)
3256 : 861 : s = Statement::make_block_statement(ifs->then_block(),
3257 : : loc);
3258 : : else
3259 : 3520 : if (ifs->else_block() != NULL)
3260 : 273 : s = Statement::make_block_statement(ifs->else_block(),
3261 : : loc);
3262 : : else
3263 : : // Make a dummy statement.
3264 : 3247 : s = Statement::make_statement(Expression::make_boolean(false, loc),
3265 : : true);
3266 : :
3267 : 4381 : block->replace_statement(*pindex, s);
3268 : : }
3269 : : }
3270 : 3792796 : return TRAVERSE_CONTINUE;
3271 : : }
3272 : :
3273 : : // Remove deadcode in an expression.
3274 : :
3275 : : int
3276 : 11082102 : Remove_deadcode::expression(Expression** pexpr)
3277 : : {
3278 : : // Discard the right arm of a shortcut expression of constant value.
3279 : 11082102 : Binary_expression* be = (*pexpr)->binary_expression();
3280 : 651226 : bool bval;
3281 : 651226 : if (be != NULL
3282 : 651226 : && be->boolean_constant_value(&bval)
3283 : 1310 : && (be->op() == OPERATOR_ANDAND
3284 : 385 : || be->op() == OPERATOR_OROR))
3285 : : {
3286 : 1308 : *pexpr = Expression::make_boolean(bval, be->location());
3287 : 1308 : Type_context context(NULL, false);
3288 : 1308 : (*pexpr)->determine_type(this->gogo_, &context);
3289 : : }
3290 : 11082102 : return TRAVERSE_CONTINUE;
3291 : : }
3292 : :
3293 : : // Remove deadcode.
3294 : :
3295 : : void
3296 : 4646 : Gogo::remove_deadcode()
3297 : : {
3298 : 4646 : Remove_deadcode remove_deadcode(this);
3299 : 4646 : this->traverse(&remove_deadcode);
3300 : 4646 : }
3301 : :
3302 : : // Traverse the tree to create function descriptors as needed.
3303 : :
3304 : 9292 : class Create_function_descriptors : public Traverse
3305 : : {
3306 : : public:
3307 : 4646 : Create_function_descriptors(Gogo* gogo)
3308 : 4646 : : Traverse(traverse_functions | traverse_expressions),
3309 : 4646 : gogo_(gogo)
3310 : : { }
3311 : :
3312 : : int
3313 : : function(Named_object*);
3314 : :
3315 : : int
3316 : : expression(Expression**);
3317 : :
3318 : : static bool
3319 : : skip_descriptor(Gogo* gogo, const Named_object*);
3320 : :
3321 : : private:
3322 : : Gogo* gogo_;
3323 : : };
3324 : :
3325 : : // Create a descriptor for every top-level exported function and every
3326 : : // function referenced by an inline function.
3327 : :
3328 : : int
3329 : 188603 : Create_function_descriptors::function(Named_object* no)
3330 : : {
3331 : 188603 : if (Create_function_descriptors::skip_descriptor(this->gogo_, no))
3332 : : return TRAVERSE_CONTINUE;
3333 : :
3334 : 188603 : if (no->is_function()
3335 : 188603 : && no->func_value()->enclosing() == NULL
3336 : 164295 : && !no->func_value()->is_method()
3337 : 274853 : && ((!Gogo::is_hidden_name(no->name())
3338 : 44009 : && !Gogo::is_thunk(no))
3339 : 43547 : || no->func_value()->is_referenced_by_inline()))
3340 : 42703 : no->func_value()->descriptor(this->gogo_, no);
3341 : :
3342 : : return TRAVERSE_CONTINUE;
3343 : : }
3344 : :
3345 : : // If we see a function referenced in any way other than calling it,
3346 : : // create a descriptor for it.
3347 : :
3348 : : int
3349 : 10284657 : Create_function_descriptors::expression(Expression** pexpr)
3350 : : {
3351 : 10284657 : Expression* expr = *pexpr;
3352 : :
3353 : 10284657 : Func_expression* fe = expr->func_expression();
3354 : 10284657 : if (fe != NULL)
3355 : : {
3356 : : // We would not get here for a call to this function, so this is
3357 : : // a reference to a function other than calling it. We need a
3358 : : // descriptor.
3359 : 46977 : if (fe->closure() != NULL)
3360 : : return TRAVERSE_CONTINUE;
3361 : 37237 : Named_object* no = fe->named_object();
3362 : 37237 : if (no->is_function() && !no->func_value()->is_method())
3363 : 21527 : no->func_value()->descriptor(this->gogo_, no);
3364 : 15710 : else if (no->is_function_declaration()
3365 : 15710 : && !no->func_declaration_value()->type()->is_method()
3366 : 31420 : && !Linemap::is_predeclared_location(no->location()))
3367 : 14737 : no->func_declaration_value()->descriptor(this->gogo_, no);
3368 : 37237 : return TRAVERSE_CONTINUE;
3369 : : }
3370 : :
3371 : 10237680 : Bound_method_expression* bme = expr->bound_method_expression();
3372 : 10237680 : if (bme != NULL)
3373 : : {
3374 : : // We would not get here for a call to this method, so this is a
3375 : : // method value. We need to create a thunk.
3376 : 934 : Bound_method_expression::create_thunk(this->gogo_, bme->method(),
3377 : : bme->function());
3378 : 934 : return TRAVERSE_CONTINUE;
3379 : : }
3380 : :
3381 : 10236746 : Interface_field_reference_expression* ifre =
3382 : 10236746 : expr->interface_field_reference_expression();
3383 : 10236746 : if (ifre != NULL)
3384 : : {
3385 : : // We would not get here for a call to this interface method, so
3386 : : // this is a method value. We need to create a thunk.
3387 : 105 : Interface_type* type = ifre->expr()->type()->interface_type();
3388 : 105 : if (type != NULL)
3389 : 105 : Interface_field_reference_expression::create_thunk(this->gogo_, type,
3390 : : ifre->name());
3391 : 105 : return TRAVERSE_CONTINUE;
3392 : : }
3393 : :
3394 : 10236641 : Call_expression* ce = expr->call_expression();
3395 : 816921 : if (ce != NULL)
3396 : : {
3397 : 816921 : Expression* fn = ce->fn();
3398 : 816921 : if (fn->func_expression() != NULL
3399 : : || fn->bound_method_expression() != NULL
3400 : : || fn->interface_field_reference_expression() != NULL)
3401 : : {
3402 : : // Traverse the arguments but not the function.
3403 : 797443 : Expression_list* args = ce->args();
3404 : 797443 : if (args != NULL)
3405 : : {
3406 : 740673 : if (args->traverse(this) == TRAVERSE_EXIT)
3407 : : return TRAVERSE_EXIT;
3408 : : }
3409 : :
3410 : : // Traverse the subexpressions of the function, if any.
3411 : 797443 : if (fn->traverse_subexpressions(this) == TRAVERSE_EXIT)
3412 : : return TRAVERSE_EXIT;
3413 : :
3414 : : return TRAVERSE_SKIP_COMPONENTS;
3415 : : }
3416 : : }
3417 : :
3418 : : return TRAVERSE_CONTINUE;
3419 : : }
3420 : :
3421 : : // The gc compiler has some special cases that it always compiles as
3422 : : // intrinsics. For those we don't want to generate a function
3423 : : // descriptor, as there will be no code for it to refer to.
3424 : :
3425 : : bool
3426 : 189200 : Create_function_descriptors::skip_descriptor(Gogo* gogo,
3427 : : const Named_object* no)
3428 : : {
3429 : 189200 : const std::string& pkgpath(no->package() == NULL
3430 : 189200 : ? gogo->pkgpath()
3431 : 12247 : : no->package()->pkgpath());
3432 : :
3433 : : // internal/abi is the standard library package,
3434 : : // bootstrap/internal/abi is the name used when bootstrapping the gc
3435 : : // compiler.
3436 : :
3437 : 189200 : return ((pkgpath == "internal/abi"
3438 : 189192 : || pkgpath == "bootstrap/internal/abi")
3439 : 189200 : && (no->name() == "FuncPCABI0"
3440 : 4 : || no->name() == "FuncPCABIInternal"));
3441 : : }
3442 : :
3443 : : // Create function descriptors as needed. We need a function
3444 : : // descriptor for all exported functions and for all functions that
3445 : : // are referenced without being called.
3446 : :
3447 : : void
3448 : 4646 : Gogo::create_function_descriptors()
3449 : : {
3450 : : // Create a function descriptor for any exported function that is
3451 : : // declared in this package. This is so that we have a descriptor
3452 : : // for functions written in assembly. Gather the descriptors first
3453 : : // so that we don't add declarations while looping over them.
3454 : 4646 : std::vector<Named_object*> fndecls;
3455 : 4646 : Bindings* b = this->package_->bindings();
3456 : 341843 : for (Bindings::const_declarations_iterator p = b->begin_declarations();
3457 : 341843 : p != b->end_declarations();
3458 : 337197 : ++p)
3459 : : {
3460 : 337197 : Named_object* no = p->second;
3461 : 337197 : if (no->is_function_declaration()
3462 : 3904 : && !no->func_declaration_value()->type()->is_method()
3463 : 3904 : && !Linemap::is_predeclared_location(no->location())
3464 : 3904 : && !Gogo::is_hidden_name(no->name())
3465 : 337794 : && !Create_function_descriptors::skip_descriptor(this, no))
3466 : 589 : fndecls.push_back(no);
3467 : : }
3468 : 5235 : for (std::vector<Named_object*>::const_iterator p = fndecls.begin();
3469 : 5235 : p != fndecls.end();
3470 : 589 : ++p)
3471 : 589 : (*p)->func_declaration_value()->descriptor(this, *p);
3472 : 4646 : fndecls.clear();
3473 : :
3474 : 4646 : Create_function_descriptors cfd(this);
3475 : 4646 : this->traverse(&cfd);
3476 : 4646 : }
3477 : :
3478 : : // Lower calls to builtin functions. We need to do this early because
3479 : : // some builtin calls are constant expressions. In particular we need
3480 : : // to do this before finalize_methods, because finalize_methods calls
3481 : : // is_direct_iface_type, which needs to know whether something like
3482 : : // [unsafe.Sizeof(byte(0))]*byte is a direct-iface type.
3483 : :
3484 : 9292 : class Lower_builtin_calls : public Traverse
3485 : : {
3486 : : public:
3487 : 4646 : Lower_builtin_calls(Gogo* gogo)
3488 : 4646 : : Traverse(traverse_expressions),
3489 : 4646 : gogo_(gogo)
3490 : : { }
3491 : :
3492 : : int
3493 : : expression(Expression**);
3494 : :
3495 : : private:
3496 : : Gogo* gogo_;
3497 : : };
3498 : :
3499 : : int
3500 : 9007564 : Lower_builtin_calls::expression(Expression** pexpr)
3501 : : {
3502 : 9007564 : Call_expression* ce = (*pexpr)->call_expression();
3503 : 836475 : if (ce != NULL)
3504 : 836475 : *pexpr = ce->lower_builtin(this->gogo_);
3505 : 9007564 : return TRAVERSE_CONTINUE;
3506 : : }
3507 : :
3508 : : void
3509 : 4646 : Gogo::lower_builtin_calls()
3510 : : {
3511 : 4646 : Lower_builtin_calls lbc(this);
3512 : 4646 : this->traverse(&lbc);
3513 : 4646 : }
3514 : :
3515 : : // Finalize the methods of an interface type.
3516 : :
3517 : : int
3518 : 25418891 : Finalize_methods::type(Type* t)
3519 : : {
3520 : : // Check the classification so that we don't finalize the methods
3521 : : // twice for a named interface type.
3522 : 25418891 : switch (t->classification())
3523 : : {
3524 : 272376 : case Type::TYPE_INTERFACE:
3525 : 272376 : t->interface_type()->finalize_methods();
3526 : 272376 : break;
3527 : :
3528 : 2286587 : case Type::TYPE_NAMED:
3529 : 2286587 : {
3530 : 2286587 : Named_type* nt = t->named_type();
3531 : :
3532 : 2286587 : if (nt->is_alias())
3533 : : return TRAVERSE_CONTINUE;
3534 : :
3535 : 2192698 : Type* rt = nt->real_type();
3536 : 2192698 : if (rt->classification() != Type::TYPE_STRUCT)
3537 : : {
3538 : : // Finalize the methods of the real type first.
3539 : 930790 : if (Type::traverse(rt, this) == TRAVERSE_EXIT)
3540 : : return TRAVERSE_EXIT;
3541 : :
3542 : : // Finalize the methods of this type.
3543 : 930790 : nt->finalize_methods(this->gogo_);
3544 : : }
3545 : : else
3546 : : {
3547 : : // We don't want to finalize the methods of a named struct
3548 : : // type, as the methods should be attached to the named
3549 : : // type, not the struct type. We just want to finalize
3550 : : // the field types.
3551 : : //
3552 : : // It is possible that a field type refers indirectly to
3553 : : // this type, such as via a field with function type with
3554 : : // an argument or result whose type is this type. To
3555 : : // avoid the cycle, first finalize the methods of any
3556 : : // embedded types, which are the only types we need to
3557 : : // know to finalize the methods of this type.
3558 : 2523816 : const Struct_field_list* fields = rt->struct_type()->fields();
3559 : 1261908 : if (fields != NULL)
3560 : : {
3561 : 8240766 : for (Struct_field_list::const_iterator pf = fields->begin();
3562 : 8240766 : pf != fields->end();
3563 : 6978858 : ++pf)
3564 : : {
3565 : 6978858 : if (pf->is_anonymous())
3566 : : {
3567 : 124573 : if (Type::traverse(pf->type(), this) == TRAVERSE_EXIT)
3568 : 0 : return TRAVERSE_EXIT;
3569 : : }
3570 : : }
3571 : : }
3572 : :
3573 : : // Finalize the methods of this type.
3574 : 1261908 : nt->finalize_methods(this->gogo_);
3575 : :
3576 : : // Finalize all the struct fields.
3577 : 2523816 : if (rt->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT)
3578 : : return TRAVERSE_EXIT;
3579 : : }
3580 : :
3581 : : // If this type is defined in a different package, then finalize the
3582 : : // types of all the methods, since we won't see them otherwise.
3583 : 2192698 : if (nt->named_object()->package() != NULL && nt->has_any_methods())
3584 : : {
3585 : 1041198 : const Methods* methods = nt->methods();
3586 : 8545555 : for (Methods::const_iterator p = methods->begin();
3587 : 8545555 : p != methods->end();
3588 : 7504357 : ++p)
3589 : : {
3590 : 7504357 : if (Type::traverse(p->second->type(), this) == TRAVERSE_EXIT)
3591 : 0 : return TRAVERSE_EXIT;
3592 : : }
3593 : : }
3594 : :
3595 : : return TRAVERSE_SKIP_COMPONENTS;
3596 : : }
3597 : :
3598 : 119380 : case Type::TYPE_STRUCT:
3599 : : // Traverse the field types first in case there is an embedded
3600 : : // field with methods that the struct should inherit.
3601 : 238760 : if (t->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT)
3602 : : return TRAVERSE_EXIT;
3603 : 119380 : t->struct_type()->finalize_methods(this->gogo_);
3604 : 119380 : return TRAVERSE_SKIP_COMPONENTS;
3605 : :
3606 : : default:
3607 : : break;
3608 : : }
3609 : :
3610 : : return TRAVERSE_CONTINUE;
3611 : : }
3612 : :
3613 : : // Finalize method lists and build stub methods for types.
3614 : :
3615 : : void
3616 : 4646 : Gogo::finalize_methods()
3617 : : {
3618 : 4646 : Finalize_methods finalize(this);
3619 : 4646 : this->traverse(&finalize);
3620 : 4646 : }
3621 : :
3622 : : // Finalize the method list for a type. This is called when a type is
3623 : : // parsed for an inlined function body, which happens after the
3624 : : // finalize_methods pass.
3625 : :
3626 : : void
3627 : 563 : Gogo::finalize_methods_for_type(Type* type)
3628 : : {
3629 : 563 : Finalize_methods finalize(this);
3630 : 563 : Type::traverse(type, &finalize);
3631 : 563 : }
3632 : :
3633 : : // Set types for unspecified variables and constants.
3634 : :
3635 : : void
3636 : 4646 : Gogo::determine_types()
3637 : : {
3638 : 4646 : this->current_bindings()->determine_types(this);
3639 : :
3640 : : // Determine the types of constants in packages.
3641 : 120891 : for (Packages::const_iterator p = this->packages_.begin();
3642 : 120891 : p != this->packages_.end();
3643 : 116245 : ++p)
3644 : 116245 : p->second->determine_types(this);
3645 : 4646 : }
3646 : :
3647 : : // Traversal class used for type checking.
3648 : :
3649 : 4646 : class Check_types_traverse : public Traverse
3650 : : {
3651 : : public:
3652 : 18287 : Check_types_traverse(Gogo* gogo)
3653 : 18287 : : Traverse(traverse_variables
3654 : : | traverse_constants
3655 : : | traverse_functions
3656 : : | traverse_statements
3657 : : | traverse_expressions),
3658 : 18287 : gogo_(gogo)
3659 : : { }
3660 : :
3661 : : int
3662 : : variable(Named_object*);
3663 : :
3664 : : int
3665 : : constant(Named_object*, bool);
3666 : :
3667 : : int
3668 : : function(Named_object*);
3669 : :
3670 : : int
3671 : : statement(Block*, size_t* pindex, Statement*);
3672 : :
3673 : : int
3674 : : expression(Expression**);
3675 : :
3676 : : private:
3677 : : // General IR.
3678 : : Gogo* gogo_;
3679 : : };
3680 : :
3681 : : // Check that a variable initializer has the right type.
3682 : :
3683 : : int
3684 : 1116170 : Check_types_traverse::variable(Named_object* named_object)
3685 : : {
3686 : 1116170 : if (named_object->is_variable())
3687 : : {
3688 : 984741 : Variable* var = named_object->var_value();
3689 : :
3690 : : // Give error if variable type is not defined.
3691 : 984741 : var->type()->base();
3692 : :
3693 : 984741 : Expression* init = var->init();
3694 : 984741 : std::string reason;
3695 : 984741 : if (init != NULL
3696 : 1283553 : && !Type::are_assignable(var->type(), init->type(), &reason))
3697 : : {
3698 : 45 : if (reason.empty())
3699 : 0 : go_error_at(var->location(), "incompatible type in initialization");
3700 : : else
3701 : 45 : go_error_at(var->location(),
3702 : : "incompatible type in initialization (%s)",
3703 : : reason.c_str());
3704 : 45 : init = Expression::make_error(named_object->location());
3705 : 45 : var->clear_init();
3706 : : }
3707 : 984696 : else if (init != NULL
3708 : 984696 : && init->func_expression() != NULL)
3709 : : {
3710 : 3219 : Named_object* no = init->func_expression()->named_object();
3711 : 3219 : Function_type* fntype;
3712 : 3219 : if (no->is_function())
3713 : 3047 : fntype = no->func_value()->type();
3714 : 172 : else if (no->is_function_declaration())
3715 : 172 : fntype = no->func_declaration_value()->type();
3716 : : else
3717 : 0 : go_unreachable();
3718 : :
3719 : : // Builtin functions cannot be used as function values for variable
3720 : : // initialization.
3721 : 3219 : if (fntype->is_builtin())
3722 : : {
3723 : 1 : go_error_at(init->location(),
3724 : : "invalid use of special built-in function %qs; "
3725 : : "must be called",
3726 : 2 : no->message_name().c_str());
3727 : : }
3728 : : }
3729 : :
3730 : 984741 : if (!var->is_used()
3731 : 368942 : && !var->is_global()
3732 : 51096 : && !var->is_parameter()
3733 : 35 : && !var->is_receiver()
3734 : 35 : && !var->type()->is_error()
3735 : 13 : && (init == NULL || !init->is_error_expression())
3736 : 984749 : && !Lex::is_invalid_identifier(named_object->name()))
3737 : : {
3738 : : // Avoid giving an error if the initializer is invalid.
3739 : 7 : if (init != NULL)
3740 : 6 : init->check_types(this->gogo_);
3741 : :
3742 : 6 : if (init == NULL || !init->is_error_expression())
3743 : 6 : go_error_at(var->location(), "%qs declared but not used",
3744 : 12 : named_object->message_name().c_str());
3745 : : }
3746 : 984741 : }
3747 : 1116170 : return TRAVERSE_CONTINUE;
3748 : : }
3749 : :
3750 : : // Check that a constant initializer has the right type.
3751 : :
3752 : : int
3753 : 1011758 : Check_types_traverse::constant(Named_object* named_object, bool)
3754 : : {
3755 : 1011758 : Named_constant* constant = named_object->const_value();
3756 : 1011758 : Type* ctype = constant->type();
3757 : 1045381 : if (ctype->integer_type() == NULL
3758 : 1038954 : && ctype->float_type() == NULL
3759 : 1038910 : && ctype->complex_type() == NULL
3760 : 27177 : && !ctype->is_boolean_type()
3761 : 25650 : && !ctype->is_string_type())
3762 : : {
3763 : 25 : if (ctype->is_nil_type())
3764 : 1 : go_error_at(constant->location(), "const initializer cannot be nil");
3765 : 24 : else if (!ctype->is_error())
3766 : 15 : go_error_at(constant->location(), "invalid constant type");
3767 : 25 : constant->set_error();
3768 : : }
3769 : 1011733 : else if (constant->expr()->is_error_expression())
3770 : : {
3771 : 3 : go_assert(saw_errors());
3772 : 3 : constant->set_error();
3773 : : }
3774 : 1011730 : else if (!constant->expr()->is_constant())
3775 : : {
3776 : 12 : go_error_at(constant->expr()->location(), "expression is not constant");
3777 : 12 : constant->set_error();
3778 : : }
3779 : 1011718 : else if (!Type::are_assignable(constant->type(), constant->expr()->type(),
3780 : : NULL))
3781 : : {
3782 : 1 : go_error_at(constant->location(),
3783 : : "initialization expression has wrong type");
3784 : 1 : constant->set_error();
3785 : : }
3786 : 1011758 : return TRAVERSE_CONTINUE;
3787 : : }
3788 : :
3789 : : // There are no types to check in a function, but this is where we
3790 : : // issue warnings about labels which are defined but not referenced.
3791 : :
3792 : : int
3793 : 175575 : Check_types_traverse::function(Named_object* no)
3794 : : {
3795 : 175575 : no->func_value()->check_labels();
3796 : 175575 : return TRAVERSE_CONTINUE;
3797 : : }
3798 : :
3799 : : // Check that types are valid in a statement.
3800 : :
3801 : : int
3802 : 1852286 : Check_types_traverse::statement(Block*, size_t*, Statement* s)
3803 : : {
3804 : 1852286 : s->check_types(this->gogo_);
3805 : 1852286 : return TRAVERSE_CONTINUE;
3806 : : }
3807 : :
3808 : : // Check that types are valid in an expression.
3809 : :
3810 : : int
3811 : 9638978 : Check_types_traverse::expression(Expression** expr)
3812 : : {
3813 : 9638978 : (*expr)->check_types(this->gogo_);
3814 : 9638978 : return TRAVERSE_CONTINUE;
3815 : : }
3816 : :
3817 : : // Check that types are valid.
3818 : :
3819 : : void
3820 : 4646 : Gogo::check_types()
3821 : : {
3822 : 4646 : Check_types_traverse traverse(this);
3823 : 4646 : this->traverse(&traverse);
3824 : :
3825 : 4646 : Bindings* bindings = this->current_bindings();
3826 : 341770 : for (Bindings::const_declarations_iterator p = bindings->begin_declarations();
3827 : 341770 : p != bindings->end_declarations();
3828 : 337124 : ++p)
3829 : : {
3830 : : // Also check the types in a function declaration's signature.
3831 : 337124 : Named_object* no = p->second;
3832 : 337124 : if (no->is_function_declaration())
3833 : 3904 : no->func_declaration_value()->check_types();
3834 : : }
3835 : 4646 : }
3836 : :
3837 : : // Check the types in a single block.
3838 : :
3839 : : void
3840 : 13641 : Gogo::check_types_in_block(Block* block)
3841 : : {
3842 : 13641 : Check_types_traverse traverse(this);
3843 : 13641 : block->traverse(&traverse);
3844 : 13641 : }
3845 : :
3846 : : // For each global variable defined in the current package, record the
3847 : : // set of variables that its initializer depends on. We do this after
3848 : : // lowering so that all unknown names are resolved to their final
3849 : : // locations. We do this before write barrier insertion because that
3850 : : // makes it harder to distinguish references from assignments in
3851 : : // preinit blocks.
3852 : :
3853 : : void
3854 : 4646 : Gogo::record_global_init_refs()
3855 : : {
3856 : 4646 : Bindings* bindings = this->package_->bindings();
3857 : 458427 : for (Bindings::const_definitions_iterator pb = bindings->begin_definitions();
3858 : 458427 : pb != bindings->end_definitions();
3859 : 453781 : pb++)
3860 : : {
3861 : 453781 : Named_object* no = *pb;
3862 : 453781 : if (!no->is_variable())
3863 : 417080 : continue;
3864 : :
3865 : 36701 : Variable* var = no->var_value();
3866 : 36701 : go_assert(var->is_global());
3867 : :
3868 : 36701 : Find_vars find_vars;
3869 : 36701 : Expression* init = var->init();
3870 : 36701 : if (init != NULL)
3871 : 20356 : Expression::traverse(&init, &find_vars);
3872 : 36701 : if (var->has_pre_init())
3873 : 121 : var->preinit()->traverse(&find_vars);
3874 : 36701 : Named_object* dep = this->var_depends_on(var);
3875 : 36701 : if (dep != NULL)
3876 : : {
3877 : 99 : Expression* dinit = dep->var_value()->init();
3878 : 99 : if (dinit != NULL)
3879 : 95 : Expression::traverse(&dinit, &find_vars);
3880 : 99 : if (dep->var_value()->has_pre_init())
3881 : 99 : dep->var_value()->preinit()->traverse(&find_vars);
3882 : : }
3883 : :
3884 : 48351 : for (Find_vars::const_iterator pv = find_vars.begin();
3885 : 48351 : pv != find_vars.end();
3886 : 11650 : ++pv)
3887 : 11650 : var->add_init_ref(*pv);
3888 : 36701 : }
3889 : 4646 : }
3890 : :
3891 : : // A traversal class which finds all the expressions which must be
3892 : : // evaluated in order within a statement or larger expression. This
3893 : : // is used to implement the rules about order of evaluation.
3894 : :
3895 : : class Find_eval_ordering : public Traverse
3896 : : {
3897 : : private:
3898 : : typedef std::vector<Expression**> Expression_pointers;
3899 : :
3900 : : public:
3901 : 4734399 : Find_eval_ordering()
3902 : : : Traverse(traverse_blocks
3903 : : | traverse_statements
3904 : : | traverse_expressions),
3905 : 4734399 : exprs_()
3906 : : { }
3907 : :
3908 : : size_t
3909 : 4632515 : size() const
3910 : 9265030 : { return this->exprs_.size(); }
3911 : :
3912 : : typedef Expression_pointers::const_iterator const_iterator;
3913 : :
3914 : : const_iterator
3915 : 427177 : begin() const
3916 : 427177 : { return this->exprs_.begin(); }
3917 : :
3918 : : const_iterator
3919 : 1102848 : end() const
3920 : 711 : { return this->exprs_.end(); }
3921 : :
3922 : : protected:
3923 : : int
3924 : 1683357 : block(Block*)
3925 : 1683357 : { return TRAVERSE_SKIP_COMPONENTS; }
3926 : :
3927 : : int
3928 : 0 : statement(Block*, size_t*, Statement*)
3929 : 0 : { return TRAVERSE_SKIP_COMPONENTS; }
3930 : :
3931 : : int
3932 : : expression(Expression**);
3933 : :
3934 : : private:
3935 : : // A list of pointers to expressions with side-effects.
3936 : : Expression_pointers exprs_;
3937 : : };
3938 : :
3939 : : // If an expression must be evaluated in order, put it on the list.
3940 : :
3941 : : int
3942 : 12441152 : Find_eval_ordering::expression(Expression** expression_pointer)
3943 : : {
3944 : 12441152 : Binary_expression* binexp = (*expression_pointer)->binary_expression();
3945 : 740142 : if (binexp != NULL
3946 : 740142 : && (binexp->op() == OPERATOR_ANDAND || binexp->op() == OPERATOR_OROR))
3947 : : {
3948 : : // Shortcut expressions may potentially have side effects which need
3949 : : // to be ordered, so add them to the list.
3950 : : // We don't order its subexpressions here since they may be evaluated
3951 : : // conditionally. This is handled in remove_shortcuts.
3952 : 86545 : this->exprs_.push_back(expression_pointer);
3953 : 86545 : return TRAVERSE_SKIP_COMPONENTS;
3954 : : }
3955 : :
3956 : : // We have to look at subexpressions before this one.
3957 : 12354607 : if ((*expression_pointer)->traverse_subexpressions(this) == TRAVERSE_EXIT)
3958 : : return TRAVERSE_EXIT;
3959 : 12354607 : if ((*expression_pointer)->must_eval_in_order())
3960 : 899159 : this->exprs_.push_back(expression_pointer);
3961 : : return TRAVERSE_SKIP_COMPONENTS;
3962 : : }
3963 : :
3964 : : // A traversal class for ordering evaluations.
3965 : :
3966 : 368002 : class Order_eval : public Traverse
3967 : : {
3968 : : public:
3969 : 184001 : Order_eval(Gogo* gogo)
3970 : 184001 : : Traverse(traverse_variables
3971 : : | traverse_statements),
3972 : 184001 : gogo_(gogo)
3973 : : { }
3974 : :
3975 : : int
3976 : : variable(Named_object*);
3977 : :
3978 : : int
3979 : : statement(Block*, size_t*, Statement*);
3980 : :
3981 : : private:
3982 : : // The IR.
3983 : : Gogo* gogo_;
3984 : : };
3985 : :
3986 : : // Implement the order of evaluation rules for a statement.
3987 : :
3988 : : int
3989 : 4714043 : Order_eval::statement(Block* block, size_t* pindex, Statement* stmt)
3990 : : {
3991 : : // FIXME: This approach doesn't work for switch statements, because
3992 : : // we add the new statements before the whole switch when we need to
3993 : : // instead add them just before the switch expression. The right
3994 : : // fix is probably to lower switch statements with nonconstant cases
3995 : : // to a series of conditionals.
3996 : 4714043 : if (stmt->switch_statement() != NULL)
3997 : : return TRAVERSE_CONTINUE;
3998 : :
3999 : 4714043 : Find_eval_ordering find_eval_ordering;
4000 : :
4001 : : // If S is a variable declaration, then ordinary traversal won't do
4002 : : // anything. We want to explicitly traverse the initialization
4003 : : // expression if there is one.
4004 : 4714043 : Variable_declaration_statement* vds = stmt->variable_declaration_statement();
4005 : 4714043 : Expression* init = NULL;
4006 : 4714043 : Expression* orig_init = NULL;
4007 : 4714043 : if (vds == NULL)
4008 : 4331413 : stmt->traverse_contents(&find_eval_ordering);
4009 : : else
4010 : : {
4011 : 382630 : init = vds->var()->var_value()->init();
4012 : 382630 : if (init == NULL)
4013 : : return TRAVERSE_CONTINUE;
4014 : 280746 : orig_init = init;
4015 : :
4016 : : // It might seem that this could be
4017 : : // init->traverse_subexpressions. Unfortunately that can fail
4018 : : // in a case like
4019 : : // var err os.Error
4020 : : // newvar, err := call(arg())
4021 : : // Here newvar will have an init of call result 0 of
4022 : : // call(arg()). If we only traverse subexpressions, we will
4023 : : // only find arg(), and we won't bother to move anything out.
4024 : : // Then we get to the assignment to err, we will traverse the
4025 : : // whole statement, and this time we will find both call() and
4026 : : // arg(), and so we will move them out. This will cause them to
4027 : : // be put into temporary variables before the assignment to err
4028 : : // but after the declaration of newvar. To avoid that problem,
4029 : : // we traverse the entire expression here.
4030 : 280746 : Expression::traverse(&init, &find_eval_ordering);
4031 : : }
4032 : :
4033 : 4612159 : size_t c = find_eval_ordering.size();
4034 : 4612159 : if (c == 0)
4035 : : return TRAVERSE_CONTINUE;
4036 : :
4037 : : // If there is only one expression with a side-effect, we can
4038 : : // usually leave it in place.
4039 : 732622 : if (c == 1)
4040 : : {
4041 : 516834 : switch (stmt->classification())
4042 : : {
4043 : : case Statement::STATEMENT_ASSIGNMENT:
4044 : : // For an assignment statement, we need to evaluate an
4045 : : // expression on the right hand side before we evaluate any
4046 : : // index expression on the left hand side, so for that case
4047 : : // we always move the expression. Otherwise we mishandle
4048 : : // m[0] = len(m) where m is a map.
4049 : : break;
4050 : :
4051 : 49625 : case Statement::STATEMENT_EXPRESSION:
4052 : 49625 : {
4053 : : // If this is a call statement that doesn't return any
4054 : : // values, it will not have been counted as a value to
4055 : : // move. We need to move any subexpressions in case they
4056 : : // are themselves call statements that require passing a
4057 : : // closure.
4058 : 49625 : Expression* expr = stmt->expression_statement()->expr();
4059 : 49625 : if (expr->call_expression() != NULL
4060 : 48371 : && expr->call_expression()->result_count() == 0)
4061 : : break;
4062 : 37239 : return TRAVERSE_CONTINUE;
4063 : : }
4064 : :
4065 : : default:
4066 : : // We can leave the expression in place.
4067 : : return TRAVERSE_CONTINUE;
4068 : : }
4069 : : }
4070 : :
4071 : 426116 : bool is_thunk = stmt->thunk_statement() != NULL;
4072 : 426116 : Expression_statement* es = stmt->expression_statement();
4073 : 1091959 : for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
4074 : 1091959 : p != find_eval_ordering.end();
4075 : 665843 : ++p)
4076 : : {
4077 : 666177 : Expression** pexpr = *p;
4078 : :
4079 : : // The last expression in a thunk will be the call passed to go
4080 : : // or defer, which we must not evaluate early.
4081 : 666177 : if (is_thunk && p + 1 == find_eval_ordering.end())
4082 : : break;
4083 : :
4084 : 665843 : Location loc = (*pexpr)->location();
4085 : 665843 : Statement* s;
4086 : 665843 : if ((*pexpr)->call_expression() == NULL
4087 : 470782 : || (*pexpr)->call_expression()->result_count() < 2)
4088 : : {
4089 : 495596 : Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr,
4090 : : loc);
4091 : 495596 : s = ts;
4092 : 495596 : *pexpr = Expression::make_temporary_reference(ts, loc);
4093 : : }
4094 : : else
4095 : : {
4096 : : // A call expression which returns multiple results needs to
4097 : : // be handled specially. We can't create a temporary
4098 : : // because there is no type to give it. Any actual uses of
4099 : : // the values will be done via Call_result_expressions.
4100 : : //
4101 : : // Since a given call expression can be shared by multiple
4102 : : // Call_result_expressions, avoid hoisting the call the
4103 : : // second time we see it here. In addition, don't try to
4104 : : // hoist the top-level multi-return call in the statement,
4105 : : // since doing this would result a tree with more than one copy
4106 : : // of the call.
4107 : 170247 : if (this->remember_expression(*pexpr))
4108 : : s = NULL;
4109 : 81997 : else if (es != NULL && *pexpr == es->expr())
4110 : : s = NULL;
4111 : : else
4112 : 78880 : s = Statement::make_statement(*pexpr, true);
4113 : : }
4114 : :
4115 : 574476 : if (s != NULL)
4116 : : {
4117 : 574476 : block->insert_statement_before(*pindex, s);
4118 : 574476 : ++*pindex;
4119 : : }
4120 : : }
4121 : :
4122 : 426116 : if (init != orig_init)
4123 : 81272 : vds->var()->var_value()->set_init(init);
4124 : :
4125 : : return TRAVERSE_CONTINUE;
4126 : 4714043 : }
4127 : :
4128 : : // Implement the order of evaluation rules for the initializer of a
4129 : : // global variable.
4130 : :
4131 : : int
4132 : 1148735 : Order_eval::variable(Named_object* no)
4133 : : {
4134 : 1148735 : if (no->is_result_variable())
4135 : : return TRAVERSE_CONTINUE;
4136 : 1005419 : Variable* var = no->var_value();
4137 : 1005419 : Expression* init = var->init();
4138 : 1005419 : if (!var->is_global() || init == NULL)
4139 : : return TRAVERSE_CONTINUE;
4140 : :
4141 : 20356 : Find_eval_ordering find_eval_ordering;
4142 : 20356 : Expression::traverse(&init, &find_eval_ordering);
4143 : :
4144 : 20356 : if (find_eval_ordering.size() <= 1)
4145 : : {
4146 : : // If there is only one expression with a side-effect, we can
4147 : : // leave it in place.
4148 : : return TRAVERSE_SKIP_COMPONENTS;
4149 : : }
4150 : :
4151 : 1061 : Expression* orig_init = init;
4152 : :
4153 : 10178 : for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
4154 : 10178 : p != find_eval_ordering.end();
4155 : 9117 : ++p)
4156 : : {
4157 : 9117 : Expression** pexpr = *p;
4158 : 9117 : Location loc = (*pexpr)->location();
4159 : 9117 : Statement* s;
4160 : 9117 : if ((*pexpr)->call_expression() == NULL
4161 : 8906 : || (*pexpr)->call_expression()->result_count() < 2)
4162 : : {
4163 : 8923 : Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr,
4164 : : loc);
4165 : 8923 : s = ts;
4166 : 8923 : *pexpr = Expression::make_temporary_reference(ts, loc);
4167 : : }
4168 : : else
4169 : : {
4170 : : // A call expression which returns multiple results needs to
4171 : : // be handled specially.
4172 : 194 : s = Statement::make_statement(*pexpr, true);
4173 : : }
4174 : 9117 : var->add_preinit_statement(this->gogo_, s);
4175 : : }
4176 : :
4177 : 1061 : if (init != orig_init)
4178 : 448 : var->set_init(init);
4179 : :
4180 : : return TRAVERSE_SKIP_COMPONENTS;
4181 : 20356 : }
4182 : :
4183 : : // Use temporary variables to implement the order of evaluation rules.
4184 : :
4185 : : void
4186 : 4646 : Gogo::order_evaluations()
4187 : : {
4188 : 4646 : Order_eval order_eval(this);
4189 : 4646 : this->traverse(&order_eval);
4190 : 4646 : }
4191 : :
4192 : : // Order evaluations in a block.
4193 : :
4194 : : void
4195 : 92810 : Gogo::order_block(Block* block)
4196 : : {
4197 : 92810 : Order_eval order_eval(this);
4198 : 92810 : block->traverse(&order_eval);
4199 : 92810 : }
4200 : :
4201 : : // A traversal class used to find a single shortcut operator within an
4202 : : // expression.
4203 : :
4204 : 5384618 : class Find_shortcut : public Traverse
4205 : : {
4206 : : public:
4207 : 5404974 : Find_shortcut()
4208 : 5404974 : : Traverse(traverse_blocks
4209 : : | traverse_statements
4210 : : | traverse_expressions),
4211 : 5404974 : found_(NULL)
4212 : : { }
4213 : :
4214 : : // A pointer to the expression which was found, or NULL if none was
4215 : : // found.
4216 : : Expression**
4217 : 5303090 : found() const
4218 : 5303090 : { return this->found_; }
4219 : :
4220 : : protected:
4221 : : int
4222 : 1683503 : block(Block*)
4223 : 1683503 : { return TRAVERSE_SKIP_COMPONENTS; }
4224 : :
4225 : : int
4226 : 0 : statement(Block*, size_t*, Statement*)
4227 : 0 : { return TRAVERSE_SKIP_COMPONENTS; }
4228 : :
4229 : : int
4230 : : expression(Expression**);
4231 : :
4232 : : private:
4233 : : Expression** found_;
4234 : : };
4235 : :
4236 : : // Find a shortcut expression.
4237 : :
4238 : : int
4239 : 13602502 : Find_shortcut::expression(Expression** pexpr)
4240 : : {
4241 : 13602502 : Expression* expr = *pexpr;
4242 : 13602502 : Binary_expression* be = expr->binary_expression();
4243 : 744759 : if (be == NULL)
4244 : : return TRAVERSE_CONTINUE;
4245 : 744759 : Operator op = be->op();
4246 : 744759 : if (op != OPERATOR_OROR && op != OPERATOR_ANDAND)
4247 : : return TRAVERSE_CONTINUE;
4248 : 86545 : go_assert(this->found_ == NULL);
4249 : 86545 : this->found_ = pexpr;
4250 : 86545 : return TRAVERSE_EXIT;
4251 : : }
4252 : :
4253 : : // A traversal class used to turn shortcut operators into explicit if
4254 : : // statements.
4255 : :
4256 : 368002 : class Shortcuts : public Traverse
4257 : : {
4258 : : public:
4259 : 184001 : Shortcuts(Gogo* gogo)
4260 : 184001 : : Traverse(traverse_variables
4261 : : | traverse_statements),
4262 : 184001 : gogo_(gogo)
4263 : : { }
4264 : :
4265 : : protected:
4266 : : int
4267 : : variable(Named_object*);
4268 : :
4269 : : int
4270 : : statement(Block*, size_t*, Statement*);
4271 : :
4272 : : private:
4273 : : // Convert a shortcut operator.
4274 : : Statement*
4275 : : convert_shortcut(Block* enclosing, Expression** pshortcut);
4276 : :
4277 : : // The IR.
4278 : : Gogo* gogo_;
4279 : : };
4280 : :
4281 : : // Remove shortcut operators in a single statement.
4282 : :
4283 : : int
4284 : 5298073 : Shortcuts::statement(Block* block, size_t* pindex, Statement* s)
4285 : : {
4286 : : // FIXME: This approach doesn't work for switch statements, because
4287 : : // we add the new statements before the whole switch when we need to
4288 : : // instead add them just before the switch expression. The right
4289 : : // fix is probably to lower switch statements with nonconstant cases
4290 : : // to a series of conditionals.
4291 : 5298073 : if (s->switch_statement() != NULL)
4292 : : return TRAVERSE_CONTINUE;
4293 : :
4294 : 5471065 : while (true)
4295 : : {
4296 : 5384569 : Find_shortcut find_shortcut;
4297 : :
4298 : : // If S is a variable declaration, then ordinary traversal won't
4299 : : // do anything. We want to explicitly traverse the
4300 : : // initialization expression if there is one.
4301 : 5384569 : Variable_declaration_statement* vds = s->variable_declaration_statement();
4302 : 5384569 : Expression* init = NULL;
4303 : 5384569 : if (vds == NULL)
4304 : 5001306 : s->traverse_contents(&find_shortcut);
4305 : : else
4306 : : {
4307 : 383263 : init = vds->var()->var_value()->init();
4308 : 383263 : if (init == NULL)
4309 : : return TRAVERSE_CONTINUE;
4310 : 281379 : init->traverse(&init, &find_shortcut);
4311 : : }
4312 : 5282685 : Expression** pshortcut = find_shortcut.found();
4313 : 5282685 : if (pshortcut == NULL)
4314 : : return TRAVERSE_CONTINUE;
4315 : :
4316 : 86496 : Statement* snew = this->convert_shortcut(block, pshortcut);
4317 : 86496 : block->insert_statement_before(*pindex, snew);
4318 : 86496 : ++*pindex;
4319 : :
4320 : 86496 : if (pshortcut == &init)
4321 : 612 : vds->var()->var_value()->set_init(init);
4322 : 5384569 : }
4323 : : }
4324 : :
4325 : : // Remove shortcut operators in the initializer of a global variable.
4326 : :
4327 : : int
4328 : 1148735 : Shortcuts::variable(Named_object* no)
4329 : : {
4330 : 1148735 : if (no->is_result_variable())
4331 : : return TRAVERSE_CONTINUE;
4332 : 1005419 : Variable* var = no->var_value();
4333 : 1005419 : Expression* init = var->init();
4334 : 1005419 : if (!var->is_global() || init == NULL)
4335 : : return TRAVERSE_CONTINUE;
4336 : :
4337 : 20454 : while (true)
4338 : : {
4339 : 20405 : Find_shortcut find_shortcut;
4340 : 20405 : init->traverse(&init, &find_shortcut);
4341 : 20405 : Expression** pshortcut = find_shortcut.found();
4342 : 20405 : if (pshortcut == NULL)
4343 : 20356 : return TRAVERSE_CONTINUE;
4344 : :
4345 : 49 : Statement* snew = this->convert_shortcut(NULL, pshortcut);
4346 : 49 : var->add_preinit_statement(this->gogo_, snew);
4347 : 49 : if (pshortcut == &init)
4348 : 49 : var->set_init(init);
4349 : 20405 : }
4350 : : }
4351 : :
4352 : : // Given an expression which uses a shortcut operator, return a
4353 : : // statement which implements it, and update *PSHORTCUT accordingly.
4354 : :
4355 : : Statement*
4356 : 86545 : Shortcuts::convert_shortcut(Block* enclosing, Expression** pshortcut)
4357 : : {
4358 : 86545 : Binary_expression* shortcut = (*pshortcut)->binary_expression();
4359 : 86545 : Expression* left = shortcut->left();
4360 : 86545 : Expression* right = shortcut->right();
4361 : 86545 : Location loc = shortcut->location();
4362 : :
4363 : 86545 : Block* retblock = new Block(enclosing, loc);
4364 : 86545 : retblock->set_end_location(loc);
4365 : :
4366 : 86545 : Temporary_statement* ts = Statement::make_temporary(shortcut->type(),
4367 : : left, loc);
4368 : 86545 : retblock->add_statement(ts);
4369 : :
4370 : 86545 : Block* block = new Block(retblock, loc);
4371 : 86545 : block->set_end_location(loc);
4372 : 86545 : Expression* tmpref = Expression::make_temporary_reference(ts, loc);
4373 : 86545 : Statement* assign = Statement::make_assignment(tmpref, right, loc);
4374 : 86545 : block->add_statement(assign);
4375 : :
4376 : 86545 : Expression* cond = Expression::make_temporary_reference(ts, loc);
4377 : 86545 : if (shortcut->binary_expression()->op() == OPERATOR_OROR)
4378 : 30643 : cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
4379 : :
4380 : 86545 : Statement* if_statement = Statement::make_if_statement(cond, block, NULL,
4381 : : loc);
4382 : 86545 : if_statement->determine_types(this->gogo_);
4383 : 86545 : retblock->add_statement(if_statement);
4384 : :
4385 : 86545 : *pshortcut = Expression::make_temporary_reference(ts, loc);
4386 : :
4387 : 86545 : delete shortcut;
4388 : :
4389 : : // Now convert any shortcut operators in LEFT and RIGHT.
4390 : : // LEFT and RIGHT were skipped in the top level
4391 : : // Gogo::order_evaluations. We need to order their
4392 : : // components first.
4393 : 86545 : Order_eval order_eval(this->gogo_);
4394 : 86545 : retblock->traverse(&order_eval);
4395 : 86545 : Shortcuts shortcuts(this->gogo_);
4396 : 86545 : retblock->traverse(&shortcuts);
4397 : :
4398 : 86545 : return Statement::make_block_statement(retblock, loc);
4399 : 86545 : }
4400 : :
4401 : : // Turn shortcut operators into explicit if statements. Doing this
4402 : : // considerably simplifies the order of evaluation rules.
4403 : :
4404 : : void
4405 : 4646 : Gogo::remove_shortcuts()
4406 : : {
4407 : 4646 : Shortcuts shortcuts(this);
4408 : 4646 : this->traverse(&shortcuts);
4409 : 4646 : }
4410 : :
4411 : : // Turn shortcut operators into explicit if statements in a block.
4412 : :
4413 : : void
4414 : 92810 : Gogo::remove_shortcuts_in_block(Block* block)
4415 : : {
4416 : 92810 : Shortcuts shortcuts(this);
4417 : 92810 : block->traverse(&shortcuts);
4418 : 92810 : }
4419 : :
4420 : : // Traversal to flatten parse tree after order of evaluation rules are applied.
4421 : :
4422 : 927220 : class Flatten : public Traverse
4423 : : {
4424 : : public:
4425 : 463610 : Flatten(Gogo* gogo, Named_object* function)
4426 : : : Traverse(traverse_variables
4427 : : | traverse_functions
4428 : : | traverse_statements
4429 : : | traverse_expressions),
4430 : 463610 : gogo_(gogo), function_(function), inserter_()
4431 : : { }
4432 : :
4433 : : void
4434 : 445323 : set_inserter(const Statement_inserter* inserter)
4435 : 445323 : { this->inserter_ = *inserter; }
4436 : :
4437 : : int
4438 : : variable(Named_object*);
4439 : :
4440 : : int
4441 : : function(Named_object*);
4442 : :
4443 : : int
4444 : : statement(Block*, size_t* pindex, Statement*);
4445 : :
4446 : : int
4447 : : expression(Expression**);
4448 : :
4449 : : private:
4450 : : // General IR.
4451 : : Gogo* gogo_;
4452 : : // The function we are traversing.
4453 : : Named_object* function_;
4454 : : // Current statement inserter for use by expressions.
4455 : : Statement_inserter inserter_;
4456 : : };
4457 : :
4458 : : // Flatten variables.
4459 : :
4460 : : int
4461 : 1469839 : Flatten::variable(Named_object* no)
4462 : : {
4463 : 1469839 : if (!no->is_variable())
4464 : : return TRAVERSE_CONTINUE;
4465 : :
4466 : 1224943 : if (no->is_variable() && no->var_value()->is_global())
4467 : : {
4468 : : // Global variables can have loops in their initialization
4469 : : // expressions. This is handled in flatten_init_expression.
4470 : 348764 : no->var_value()->flatten_init_expression(this->gogo_, this->function_,
4471 : : &this->inserter_);
4472 : 348764 : return TRAVERSE_CONTINUE;
4473 : : }
4474 : :
4475 : 876179 : if (!no->var_value()->is_parameter()
4476 : 401990 : && !no->var_value()->is_receiver()
4477 : 401990 : && !no->var_value()->is_closure()
4478 : 401990 : && no->var_value()->is_non_escaping_address_taken()
4479 : 31910 : && !no->var_value()->is_in_heap()
4480 : 902882 : && no->var_value()->toplevel_decl() == NULL)
4481 : : {
4482 : : // Local variable that has address taken but not escape.
4483 : : // It needs to be live beyond its lexical scope. So we
4484 : : // create a top-level declaration for it.
4485 : : // No need to do it if it is already in the top level.
4486 : 21694 : Block* top_block = function_->func_value()->block();
4487 : 21694 : if (top_block->bindings()->lookup_local(no->name()) != no)
4488 : : {
4489 : 4935 : Variable* var = no->var_value();
4490 : 4935 : Temporary_statement* ts =
4491 : 4935 : Statement::make_temporary(var->type(), NULL, var->location());
4492 : 4935 : ts->set_is_address_taken();
4493 : 4935 : top_block->add_statement_at_front(ts);
4494 : 4935 : var->set_toplevel_decl(ts);
4495 : : }
4496 : : }
4497 : :
4498 : 876179 : go_assert(!no->var_value()->has_pre_init());
4499 : :
4500 : : return TRAVERSE_SKIP_COMPONENTS;
4501 : : }
4502 : :
4503 : : // Flatten the body of a function. Record the function while flattening it,
4504 : : // so that we can pass it down when flattening an expression.
4505 : :
4506 : : int
4507 : 295812 : Flatten::function(Named_object* no)
4508 : : {
4509 : 295812 : go_assert(this->function_ == NULL);
4510 : 295812 : this->function_ = no;
4511 : 295812 : int t = no->func_value()->traverse(this);
4512 : 295812 : this->function_ = NULL;
4513 : :
4514 : 295812 : if (t == TRAVERSE_EXIT)
4515 : 0 : return t;
4516 : : return TRAVERSE_SKIP_COMPONENTS;
4517 : : }
4518 : :
4519 : : // Flatten statement parse trees.
4520 : :
4521 : : int
4522 : 6383028 : Flatten::statement(Block* block, size_t* pindex, Statement* sorig)
4523 : : {
4524 : : // Because we explicitly traverse the statement's contents
4525 : : // ourselves, we want to skip block statements here. There is
4526 : : // nothing to flatten in a block statement.
4527 : 6383028 : if (sorig->is_block_statement())
4528 : : return TRAVERSE_CONTINUE;
4529 : :
4530 : 4958515 : Statement_inserter hold_inserter(this->inserter_);
4531 : 4958515 : this->inserter_ = Statement_inserter(block, pindex);
4532 : :
4533 : : // Flatten the expressions first.
4534 : 4958515 : int t = sorig->traverse_contents(this);
4535 : 4958515 : if (t == TRAVERSE_EXIT)
4536 : : {
4537 : 0 : this->inserter_ = hold_inserter;
4538 : 0 : return t;
4539 : : }
4540 : :
4541 : : // Keep flattening until nothing changes.
4542 : : Statement* s = sorig;
4543 : 4958876 : while (true)
4544 : : {
4545 : 4958876 : Statement* snew = s->flatten(this->gogo_, this->function_, block,
4546 : : &this->inserter_);
4547 : 4958876 : if (snew == s)
4548 : : break;
4549 : 361 : s = snew;
4550 : 361 : t = s->traverse_contents(this);
4551 : 361 : if (t == TRAVERSE_EXIT)
4552 : : {
4553 : 0 : this->inserter_ = hold_inserter;
4554 : 0 : return t;
4555 : : }
4556 : : }
4557 : :
4558 : 4958515 : if (s != sorig)
4559 : 361 : block->replace_statement(*pindex, s);
4560 : :
4561 : 4958515 : this->inserter_ = hold_inserter;
4562 : 4958515 : return TRAVERSE_SKIP_COMPONENTS;
4563 : : }
4564 : :
4565 : : // Flatten expression parse trees.
4566 : :
4567 : : int
4568 : 18316301 : Flatten::expression(Expression** pexpr)
4569 : : {
4570 : : // Keep flattening until nothing changes.
4571 : 18376801 : while (true)
4572 : : {
4573 : 18346551 : Expression* e = *pexpr;
4574 : 18346551 : if (e->traverse_subexpressions(this) == TRAVERSE_EXIT)
4575 : : return TRAVERSE_EXIT;
4576 : :
4577 : 18346551 : Expression* enew = e->flatten(this->gogo_, this->function_,
4578 : : &this->inserter_);
4579 : 18346551 : if (enew == e)
4580 : : break;
4581 : 30250 : *pexpr = enew;
4582 : 30250 : }
4583 : : return TRAVERSE_SKIP_COMPONENTS;
4584 : : }
4585 : :
4586 : : // Flatten a block.
4587 : :
4588 : : void
4589 : 13641 : Gogo::flatten_block(Named_object* function, Block* block)
4590 : : {
4591 : 13641 : Flatten flatten(this, function);
4592 : 13641 : block->traverse(&flatten);
4593 : 13641 : }
4594 : :
4595 : : // Flatten an expression. INSERTER may be NULL, in which case the
4596 : : // expression had better not need to create any temporaries.
4597 : :
4598 : : void
4599 : 445323 : Gogo::flatten_expression(Named_object* function, Statement_inserter* inserter,
4600 : : Expression** pexpr)
4601 : : {
4602 : 445323 : Flatten flatten(this, function);
4603 : 445323 : if (inserter != NULL)
4604 : 445323 : flatten.set_inserter(inserter);
4605 : 445323 : flatten.expression(pexpr);
4606 : 445323 : }
4607 : :
4608 : : void
4609 : 4646 : Gogo::flatten()
4610 : : {
4611 : 4646 : Flatten flatten(this, NULL);
4612 : 4646 : this->traverse(&flatten);
4613 : 4646 : }
4614 : :
4615 : : // Traversal to convert calls to the predeclared recover function to
4616 : : // pass in an argument indicating whether it can recover from a panic
4617 : : // or not.
4618 : :
4619 : 1662 : class Convert_recover : public Traverse
4620 : : {
4621 : : public:
4622 : 831 : Convert_recover(Named_object* arg)
4623 : 831 : : Traverse(traverse_expressions),
4624 : 831 : arg_(arg)
4625 : : { }
4626 : :
4627 : : protected:
4628 : : int
4629 : : expression(Expression**);
4630 : :
4631 : : private:
4632 : : // The argument to pass to the function.
4633 : : Named_object* arg_;
4634 : : };
4635 : :
4636 : : // Convert calls to recover.
4637 : :
4638 : : int
4639 : 22685 : Convert_recover::expression(Expression** pp)
4640 : : {
4641 : 22685 : Call_expression* ce = (*pp)->call_expression();
4642 : 2849 : if (ce != NULL && ce->is_recover_call())
4643 : 847 : ce->set_recover_arg(Expression::make_var_reference(this->arg_,
4644 : : ce->location()));
4645 : 22685 : return TRAVERSE_CONTINUE;
4646 : : }
4647 : :
4648 : : // Traversal for build_recover_thunks.
4649 : :
4650 : 9292 : class Build_recover_thunks : public Traverse
4651 : : {
4652 : : public:
4653 : 4646 : Build_recover_thunks(Gogo* gogo)
4654 : 4646 : : Traverse(traverse_functions),
4655 : 4646 : gogo_(gogo)
4656 : : { }
4657 : :
4658 : : int
4659 : : function(Named_object*);
4660 : :
4661 : : private:
4662 : : Expression*
4663 : : can_recover_arg(Location);
4664 : :
4665 : : // General IR.
4666 : : Gogo* gogo_;
4667 : : };
4668 : :
4669 : : // If this function calls recover, turn it into a thunk.
4670 : :
4671 : : int
4672 : 189434 : Build_recover_thunks::function(Named_object* orig_no)
4673 : : {
4674 : 189434 : Function* orig_func = orig_no->func_value();
4675 : 189434 : if (!orig_func->calls_recover()
4676 : 1662 : || orig_func->is_recover_thunk()
4677 : 191096 : || orig_func->has_recover_thunk())
4678 : : return TRAVERSE_CONTINUE;
4679 : :
4680 : 831 : Gogo* gogo = this->gogo_;
4681 : 831 : Location location = orig_func->location();
4682 : :
4683 : 831 : static int count;
4684 : 831 : char buf[50];
4685 : :
4686 : 831 : Function_type* orig_fntype = orig_func->type();
4687 : 831 : Typed_identifier_list* new_params = new Typed_identifier_list();
4688 : 831 : std::string receiver_name;
4689 : 831 : if (orig_fntype->is_method())
4690 : : {
4691 : 42 : const Typed_identifier* receiver = orig_fntype->receiver();
4692 : 42 : snprintf(buf, sizeof buf, "rt.%u", count);
4693 : 42 : ++count;
4694 : 42 : receiver_name = buf;
4695 : 84 : new_params->push_back(Typed_identifier(receiver_name, receiver->type(),
4696 : 84 : receiver->location()));
4697 : : }
4698 : 831 : const Typed_identifier_list* orig_params = orig_fntype->parameters();
4699 : 831 : if (orig_params != NULL && !orig_params->empty())
4700 : : {
4701 : 175 : for (Typed_identifier_list::const_iterator p = orig_params->begin();
4702 : 272 : p != orig_params->end();
4703 : 175 : ++p)
4704 : : {
4705 : 175 : snprintf(buf, sizeof buf, "pt.%u", count);
4706 : 175 : ++count;
4707 : 350 : new_params->push_back(Typed_identifier(buf, p->type(),
4708 : 350 : p->location()));
4709 : : }
4710 : : }
4711 : 831 : snprintf(buf, sizeof buf, "pr.%u", count);
4712 : 831 : ++count;
4713 : 831 : std::string can_recover_name = buf;
4714 : 1662 : new_params->push_back(Typed_identifier(can_recover_name,
4715 : 831 : Type::lookup_bool_type(),
4716 : 1662 : orig_fntype->location()));
4717 : :
4718 : 831 : const Typed_identifier_list* orig_results = orig_fntype->results();
4719 : 831 : Typed_identifier_list* new_results;
4720 : 831 : if (orig_results == NULL || orig_results->empty())
4721 : : new_results = NULL;
4722 : : else
4723 : : {
4724 : 3 : new_results = new Typed_identifier_list();
4725 : 3 : for (Typed_identifier_list::const_iterator p = orig_results->begin();
4726 : 6 : p != orig_results->end();
4727 : 3 : ++p)
4728 : 6 : new_results->push_back(Typed_identifier("", p->type(), p->location()));
4729 : : }
4730 : :
4731 : 831 : Function_type *new_fntype = Type::make_function_type(NULL, new_params,
4732 : : new_results,
4733 : : orig_fntype->location());
4734 : 831 : if (orig_fntype->is_varargs())
4735 : 1 : new_fntype->set_is_varargs();
4736 : :
4737 : 831 : Type* rtype = NULL;
4738 : 831 : if (orig_fntype->is_method())
4739 : 42 : rtype = orig_fntype->receiver()->type();
4740 : 831 : std::string name(gogo->recover_thunk_name(orig_no->name(), rtype));
4741 : 831 : Named_object *new_no = gogo->start_function(name, new_fntype, false,
4742 : : location);
4743 : 831 : Function *new_func = new_no->func_value();
4744 : 831 : if (orig_func->enclosing() != NULL)
4745 : 737 : new_func->set_enclosing(orig_func->enclosing());
4746 : :
4747 : : // We build the code for the original function attached to the new
4748 : : // function, and then swap the original and new function bodies.
4749 : : // This means that existing references to the original function will
4750 : : // then refer to the new function. That makes this code a little
4751 : : // confusing, in that the reference to NEW_NO really refers to the
4752 : : // other function, not the one we are building.
4753 : :
4754 : 831 : Expression* closure = NULL;
4755 : 831 : if (orig_func->needs_closure())
4756 : : {
4757 : : // For the new function we are creating, declare a new parameter
4758 : : // variable NEW_CLOSURE_NO and set it to be the closure variable
4759 : : // of the function. This will be set to the closure value
4760 : : // passed in by the caller. Then pass a reference to this
4761 : : // variable as the closure value when calling the original
4762 : : // function. In other words, simply pass the closure value
4763 : : // through the thunk we are creating.
4764 : 526 : Named_object* orig_closure_no = orig_func->closure_var();
4765 : 526 : Variable* orig_closure_var = orig_closure_no->var_value();
4766 : 526 : Variable* new_var = new Variable(orig_closure_var->type(), NULL, false,
4767 : 526 : false, false, location);
4768 : 526 : new_var->set_is_closure();
4769 : 526 : snprintf(buf, sizeof buf, "closure.%u", count);
4770 : 526 : ++count;
4771 : 526 : Named_object* new_closure_no = Named_object::make_variable(buf, NULL,
4772 : : new_var);
4773 : 526 : new_func->set_closure_var(new_closure_no);
4774 : 526 : closure = Expression::make_var_reference(new_closure_no, location);
4775 : : }
4776 : :
4777 : 831 : Expression* fn = Expression::make_func_reference(new_no, closure, location);
4778 : :
4779 : 831 : Expression_list* args = new Expression_list();
4780 : 831 : if (new_params != NULL)
4781 : : {
4782 : : // Note that we skip the last parameter, which is the boolean
4783 : : // indicating whether recover can succed.
4784 : 831 : for (Typed_identifier_list::const_iterator p = new_params->begin();
4785 : 1048 : p + 1 != new_params->end();
4786 : 217 : ++p)
4787 : : {
4788 : 217 : Named_object* p_no = gogo->lookup(p->name(), NULL);
4789 : 217 : go_assert(p_no != NULL
4790 : : && p_no->is_variable()
4791 : : && p_no->var_value()->is_parameter());
4792 : 217 : args->push_back(Expression::make_var_reference(p_no, location));
4793 : : }
4794 : : }
4795 : 831 : args->push_back(this->can_recover_arg(location));
4796 : :
4797 : 831 : gogo->start_block(location);
4798 : :
4799 : 831 : Call_expression* call = Expression::make_call(fn, args, false, location);
4800 : :
4801 : : // Any varargs call has already been lowered.
4802 : 831 : call->set_varargs_are_lowered();
4803 : :
4804 : 831 : Statement* s = Statement::make_return_from_call(new_no, call, location);
4805 : 831 : s->determine_types(this->gogo_);
4806 : 831 : gogo->add_statement(s);
4807 : :
4808 : 831 : Block* b = gogo->finish_block(location);
4809 : :
4810 : 831 : gogo->add_block(b, location);
4811 : :
4812 : : // Lower the call in case it returns multiple results.
4813 : 831 : gogo->lower_block(new_no, b);
4814 : :
4815 : 831 : gogo->finish_function(location);
4816 : :
4817 : : // Swap the function bodies and types.
4818 : 831 : new_func->swap_for_recover(orig_func);
4819 : 831 : orig_func->set_is_recover_thunk();
4820 : 831 : new_func->set_calls_recover();
4821 : 831 : new_func->set_has_recover_thunk();
4822 : :
4823 : 831 : Bindings* orig_bindings = orig_func->block()->bindings();
4824 : 831 : Bindings* new_bindings = new_func->block()->bindings();
4825 : 831 : if (orig_fntype->is_method())
4826 : : {
4827 : : // We changed the receiver to be a regular parameter. We have
4828 : : // to update the binding accordingly in both functions.
4829 : 42 : Named_object* orig_rec_no = orig_bindings->lookup_local(receiver_name);
4830 : 42 : go_assert(orig_rec_no != NULL
4831 : : && orig_rec_no->is_variable()
4832 : : && !orig_rec_no->var_value()->is_receiver());
4833 : 42 : orig_rec_no->var_value()->set_is_receiver();
4834 : :
4835 : 42 : std::string new_receiver_name(orig_fntype->receiver()->name());
4836 : 42 : if (new_receiver_name.empty())
4837 : : {
4838 : : // Find the receiver. It was named "r.NNN" in
4839 : : // Gogo::start_function.
4840 : 7 : for (Bindings::const_definitions_iterator p =
4841 : 7 : new_bindings->begin_definitions();
4842 : 7 : p != new_bindings->end_definitions();
4843 : 0 : ++p)
4844 : : {
4845 : 7 : const std::string& pname((*p)->name());
4846 : 7 : if (pname[0] == 'r' && pname[1] == '.')
4847 : : {
4848 : 7 : new_receiver_name = pname;
4849 : 7 : break;
4850 : : }
4851 : : }
4852 : 7 : go_assert(!new_receiver_name.empty());
4853 : : }
4854 : 42 : Named_object* new_rec_no = new_bindings->lookup_local(new_receiver_name);
4855 : 42 : if (new_rec_no == NULL)
4856 : 0 : go_assert(saw_errors());
4857 : : else
4858 : : {
4859 : 42 : go_assert(new_rec_no->is_variable()
4860 : : && new_rec_no->var_value()->is_receiver());
4861 : 42 : new_rec_no->var_value()->set_is_not_receiver();
4862 : : }
4863 : 42 : }
4864 : :
4865 : : // Because we flipped blocks but not types, the can_recover
4866 : : // parameter appears in the (now) old bindings as a parameter.
4867 : : // Change it to a local variable, whereupon it will be discarded.
4868 : 831 : Named_object* can_recover_no = orig_bindings->lookup_local(can_recover_name);
4869 : 831 : go_assert(can_recover_no != NULL
4870 : : && can_recover_no->is_variable()
4871 : : && can_recover_no->var_value()->is_parameter());
4872 : 831 : orig_bindings->remove_binding(can_recover_no);
4873 : :
4874 : : // Add the can_recover argument to the (now) new bindings, and
4875 : : // attach it to any recover statements.
4876 : 831 : Variable* can_recover_var = new Variable(Type::lookup_bool_type(), NULL,
4877 : 1662 : false, true, false, location);
4878 : 831 : can_recover_no = new_bindings->add_variable(can_recover_name, NULL,
4879 : : can_recover_var);
4880 : 831 : Convert_recover convert_recover(can_recover_no);
4881 : 831 : new_func->traverse(&convert_recover);
4882 : :
4883 : : // Update the function pointers in any named results.
4884 : 831 : new_func->update_result_variables();
4885 : 831 : orig_func->update_result_variables();
4886 : :
4887 : 831 : return TRAVERSE_CONTINUE;
4888 : 831 : }
4889 : :
4890 : : // Return the expression to pass for the .can_recover parameter to the
4891 : : // new function. This indicates whether a call to recover may return
4892 : : // non-nil. The expression is runtime.canrecover(__builtin_return_address()).
4893 : :
4894 : : Expression*
4895 : 831 : Build_recover_thunks::can_recover_arg(Location location)
4896 : : {
4897 : 831 : Type* uintptr_type = Type::lookup_integer_type("uintptr");
4898 : 831 : static Named_object* can_recover;
4899 : 831 : if (can_recover == NULL)
4900 : : {
4901 : 319 : const Location bloc = Linemap::predeclared_location();
4902 : 319 : Typed_identifier_list* param_types = new Typed_identifier_list();
4903 : 638 : param_types->push_back(Typed_identifier("a", uintptr_type, bloc));
4904 : 319 : Type* boolean_type = Type::lookup_bool_type();
4905 : 319 : Typed_identifier_list* results = new Typed_identifier_list();
4906 : 638 : results->push_back(Typed_identifier("", boolean_type, bloc));
4907 : 319 : Function_type* fntype = Type::make_function_type(NULL, param_types,
4908 : : results, bloc);
4909 : 638 : can_recover =
4910 : 319 : Named_object::make_function_declaration("runtime_canrecover",
4911 : : NULL, fntype, bloc);
4912 : 319 : can_recover->func_declaration_value()->set_asm_name("runtime.canrecover");
4913 : : }
4914 : :
4915 : 831 : Expression* zexpr = Expression::make_integer_ul(0, NULL, location);
4916 : 831 : Expression* call = Runtime::make_call(this->gogo_,
4917 : : Runtime::BUILTIN_RETURN_ADDRESS,
4918 : : location, 1, zexpr);
4919 : 831 : call = Expression::make_unsafe_cast(uintptr_type, call, location);
4920 : :
4921 : 831 : Expression_list* args = new Expression_list();
4922 : 831 : args->push_back(call);
4923 : :
4924 : 831 : Expression* fn = Expression::make_func_reference(can_recover, NULL, location);
4925 : 831 : return Expression::make_call(fn, args, false, location);
4926 : : }
4927 : :
4928 : : // Build thunks for functions which call recover. We build a new
4929 : : // function with an extra parameter, which is whether a call to
4930 : : // recover can succeed. We then move the body of this function to
4931 : : // that one. We then turn this function into a thunk which calls the
4932 : : // new one, passing the value of runtime.canrecover(__builtin_return_address()).
4933 : : // The function will be marked as not splitting the stack. This will
4934 : : // cooperate with the implementation of defer to make recover do the
4935 : : // right thing.
4936 : :
4937 : : void
4938 : 4646 : Gogo::build_recover_thunks()
4939 : : {
4940 : 4646 : Build_recover_thunks build_recover_thunks(this);
4941 : 4646 : this->traverse(&build_recover_thunks);
4942 : 4646 : }
4943 : :
4944 : : // Look for named types to see whether we need to create an interface
4945 : : // method table.
4946 : :
4947 : 4178 : class Build_method_tables : public Traverse
4948 : : {
4949 : : public:
4950 : 2089 : Build_method_tables(Gogo* gogo,
4951 : : const std::vector<Interface_type*>& interfaces)
4952 : 2089 : : Traverse(traverse_types),
4953 : 2089 : gogo_(gogo), interfaces_(interfaces)
4954 : : { }
4955 : :
4956 : : int
4957 : : type(Type*);
4958 : :
4959 : : private:
4960 : : // The IR.
4961 : : Gogo* gogo_;
4962 : : // A list of locally defined interfaces which have hidden methods.
4963 : : const std::vector<Interface_type*>& interfaces_;
4964 : : };
4965 : :
4966 : : // Build all required interface method tables for types. We need to
4967 : : // ensure that we have an interface method table for every interface
4968 : : // which has a hidden method, for every named type which implements
4969 : : // that interface. Normally we can just build interface method tables
4970 : : // as we need them. However, in some cases we can require an
4971 : : // interface method table for an interface defined in a different
4972 : : // package for a type defined in that package. If that interface and
4973 : : // type both use a hidden method, that is OK. However, we will not be
4974 : : // able to build that interface method table when we need it, because
4975 : : // the type's hidden method will be static. So we have to build it
4976 : : // here, and just refer it from other packages as needed.
4977 : :
4978 : : void
4979 : 4646 : Gogo::build_interface_method_tables()
4980 : : {
4981 : 4646 : if (saw_errors())
4982 : 411 : return;
4983 : :
4984 : 4235 : std::vector<Interface_type*> hidden_interfaces;
4985 : 4235 : hidden_interfaces.reserve(this->interface_types_.size());
4986 : 70825 : for (std::vector<Interface_type*>::const_iterator pi =
4987 : 4235 : this->interface_types_.begin();
4988 : 75060 : pi != this->interface_types_.end();
4989 : 70825 : ++pi)
4990 : : {
4991 : 70825 : const Typed_identifier_list* methods = (*pi)->methods();
4992 : 70825 : if (methods == NULL)
4993 : 1486 : continue;
4994 : 293117 : for (Typed_identifier_list::const_iterator pm = methods->begin();
4995 : 293117 : pm != methods->end();
4996 : 223778 : ++pm)
4997 : : {
4998 : 232173 : if (Gogo::is_hidden_name(pm->name()))
4999 : : {
5000 : 8395 : hidden_interfaces.push_back(*pi);
5001 : 8395 : break;
5002 : : }
5003 : : }
5004 : : }
5005 : :
5006 : 4235 : if (!hidden_interfaces.empty())
5007 : : {
5008 : : // Now traverse the tree looking for all named types.
5009 : 2089 : Build_method_tables bmt(this, hidden_interfaces);
5010 : 2089 : this->traverse(&bmt);
5011 : 2089 : }
5012 : :
5013 : : // We no longer need the list of interfaces.
5014 : :
5015 : 7749 : this->interface_types_.clear();
5016 : 4235 : }
5017 : :
5018 : : // This is called for each type. For a named type, for each of the
5019 : : // interfaces with hidden methods that it implements, create the
5020 : : // method table.
5021 : :
5022 : : int
5023 : 11453455 : Build_method_tables::type(Type* type)
5024 : : {
5025 : 11453455 : Named_type* nt = type->named_type();
5026 : 11453455 : Struct_type* st = type->struct_type();
5027 : 11453455 : if (nt != NULL || st != NULL)
5028 : : {
5029 : 3642914 : Translate_context context(this->gogo_, NULL, NULL, NULL);
5030 : 19163114 : for (std::vector<Interface_type*>::const_iterator p =
5031 : 3642914 : this->interfaces_.begin();
5032 : 22806028 : p != this->interfaces_.end();
5033 : 19163114 : ++p)
5034 : : {
5035 : : // We ask whether a pointer to the named type implements the
5036 : : // interface, because a pointer can implement more methods
5037 : : // than a value.
5038 : 19163114 : if (nt != NULL)
5039 : : {
5040 : 15767481 : if ((*p)->implements_interface(Type::make_pointer_type(nt),
5041 : : NULL))
5042 : : {
5043 : 69546 : nt->interface_method_table(*p, false)->get_backend(&context);
5044 : 69546 : nt->interface_method_table(*p, true)->get_backend(&context);
5045 : : }
5046 : : }
5047 : : else
5048 : : {
5049 : 3395633 : if ((*p)->implements_interface(Type::make_pointer_type(st),
5050 : : NULL))
5051 : : {
5052 : 249 : st->interface_method_table(*p, false)->get_backend(&context);
5053 : 249 : st->interface_method_table(*p, true)->get_backend(&context);
5054 : : }
5055 : : }
5056 : : }
5057 : : }
5058 : 11453455 : return TRAVERSE_CONTINUE;
5059 : : }
5060 : :
5061 : : // Return an expression which allocates memory to hold values of type TYPE.
5062 : :
5063 : : Expression*
5064 : 204381 : Gogo::allocate_memory(Type* type, Location location)
5065 : : {
5066 : 204381 : Expression* td = Expression::make_type_descriptor(type, location);
5067 : 204381 : return Runtime::make_call(this, Runtime::NEW, location, 1, td);
5068 : : }
5069 : :
5070 : : // Traversal class used to check for return statements.
5071 : :
5072 : 9292 : class Check_return_statements_traverse : public Traverse
5073 : : {
5074 : : public:
5075 : 4646 : Check_return_statements_traverse()
5076 : 4646 : : Traverse(traverse_functions)
5077 : : { }
5078 : :
5079 : : int
5080 : : function(Named_object*);
5081 : : };
5082 : :
5083 : : // Check that a function has a return statement if it needs one.
5084 : :
5085 : : int
5086 : 174977 : Check_return_statements_traverse::function(Named_object* no)
5087 : : {
5088 : 174977 : Function* func = no->func_value();
5089 : 174977 : const Function_type* fntype = func->type();
5090 : 174977 : const Typed_identifier_list* results = fntype->results();
5091 : :
5092 : : // We only need a return statement if there is a return value.
5093 : 174977 : if (results == NULL || results->empty())
5094 : : return TRAVERSE_CONTINUE;
5095 : :
5096 : 104631 : if (func->block()->may_fall_through())
5097 : 226 : go_error_at(func->block()->end_location(),
5098 : : "missing return at end of function");
5099 : :
5100 : : return TRAVERSE_CONTINUE;
5101 : : }
5102 : :
5103 : : // Check return statements.
5104 : :
5105 : : void
5106 : 4646 : Gogo::check_return_statements()
5107 : : {
5108 : 4646 : Check_return_statements_traverse traverse;
5109 : 4646 : this->traverse(&traverse);
5110 : 4646 : }
5111 : :
5112 : : // Traversal class to decide whether a function body is less than the
5113 : : // inlining budget. This adjusts *available as it goes, and stops the
5114 : : // traversal if it goes negative.
5115 : :
5116 : 1636631 : class Inline_within_budget : public Traverse
5117 : : {
5118 : : public:
5119 : 1822972 : Inline_within_budget(int* available)
5120 : 1822972 : : Traverse(traverse_statements
5121 : : | traverse_expressions),
5122 : 1822972 : available_(available)
5123 : : { }
5124 : :
5125 : : int
5126 : : statement(Block*, size_t*, Statement*);
5127 : :
5128 : : int
5129 : : expression(Expression**);
5130 : :
5131 : : private:
5132 : : // Pointer to remaining budget.
5133 : : int* available_;
5134 : : };
5135 : :
5136 : : // Adjust the budget for the inlining cost of a statement.
5137 : :
5138 : : int
5139 : 4945654 : Inline_within_budget::statement(Block*, size_t*, Statement* s)
5140 : : {
5141 : 4945654 : if (*this->available_ < 0)
5142 : : return TRAVERSE_EXIT;
5143 : 4926467 : *this->available_ -= s->inlining_cost();
5144 : 4926467 : return TRAVERSE_CONTINUE;
5145 : : }
5146 : :
5147 : : // Adjust the budget for the inlining cost of an expression.
5148 : :
5149 : : int
5150 : 10891690 : Inline_within_budget::expression(Expression** pexpr)
5151 : : {
5152 : 10891690 : if (*this->available_ < 0)
5153 : : return TRAVERSE_EXIT;
5154 : 9245900 : *this->available_ -= (*pexpr)->inlining_cost();
5155 : 9245900 : return TRAVERSE_CONTINUE;
5156 : : }
5157 : :
5158 : : // Traversal class to find functions whose body should be exported for
5159 : : // inlining by other packages.
5160 : :
5161 : 8504 : class Mark_inline_candidates : public Traverse
5162 : : {
5163 : : public:
5164 : 4252 : Mark_inline_candidates(Unordered_set(Named_object*)* marked)
5165 : 4252 : : Traverse(traverse_functions
5166 : : | traverse_types),
5167 : 4252 : marked_functions_(marked)
5168 : : { }
5169 : :
5170 : : int
5171 : : function(Named_object*);
5172 : :
5173 : : int
5174 : : type(Type*);
5175 : :
5176 : : private:
5177 : : // We traverse the function body trying to determine how expensive
5178 : : // it is for inlining. We start with a budget, and decrease that
5179 : : // budget for each statement and expression. If the budget goes
5180 : : // negative, we do not export the function body. The value of this
5181 : : // budget is a heuristic. In the usual GCC spirit, we could
5182 : : // consider setting this via a command line option.
5183 : : const int budget_heuristic = 80;
5184 : :
5185 : : // Set of named objects that are marked as inline candidates.
5186 : : Unordered_set(Named_object*)* marked_functions_;
5187 : : };
5188 : :
5189 : : // Mark a function if it is an inline candidate.
5190 : :
5191 : : int
5192 : 186701 : Mark_inline_candidates::function(Named_object* no)
5193 : : {
5194 : 186701 : Function* func = no->func_value();
5195 : 186701 : if ((func->pragmas() & GOPRAGMA_NOINLINE) != 0)
5196 : : return TRAVERSE_CONTINUE;
5197 : 186341 : int budget = budget_heuristic;
5198 : 186341 : Inline_within_budget iwb(&budget);
5199 : 186341 : func->block()->traverse(&iwb);
5200 : 186341 : if (budget >= 0)
5201 : : {
5202 : 41215 : func->set_export_for_inlining();
5203 : 41215 : this->marked_functions_->insert(no);
5204 : : }
5205 : 186341 : return TRAVERSE_CONTINUE;
5206 : 186341 : }
5207 : :
5208 : : // Mark methods if they are inline candidates.
5209 : :
5210 : : int
5211 : 11064467 : Mark_inline_candidates::type(Type* t)
5212 : : {
5213 : 11064467 : Named_type* nt = t->named_type();
5214 : 11064467 : if (nt == NULL || nt->is_alias())
5215 : : return TRAVERSE_CONTINUE;
5216 : 3156920 : const Bindings* methods = nt->local_methods();
5217 : 3156920 : if (methods == NULL)
5218 : : return TRAVERSE_CONTINUE;
5219 : 2115020 : for (Bindings::const_definitions_iterator p = methods->begin_definitions();
5220 : 2115020 : p != methods->end_definitions();
5221 : 1637896 : ++p)
5222 : : {
5223 : 1637896 : Named_object* no = *p;
5224 : 1637896 : go_assert(no->is_function());
5225 : 1637896 : Function *func = no->func_value();
5226 : 1637896 : if ((func->pragmas() & GOPRAGMA_NOINLINE) != 0)
5227 : 1265 : continue;
5228 : 1636631 : int budget = budget_heuristic;
5229 : 1636631 : Inline_within_budget iwb(&budget);
5230 : 1636631 : func->block()->traverse(&iwb);
5231 : 1636631 : if (budget >= 0)
5232 : : {
5233 : 116157 : func->set_export_for_inlining();
5234 : 116157 : this->marked_functions_->insert(no);
5235 : : }
5236 : 1636631 : }
5237 : : return TRAVERSE_CONTINUE;
5238 : : }
5239 : :
5240 : : // Export identifiers as requested.
5241 : :
5242 : : void
5243 : 4646 : Gogo::do_exports()
5244 : : {
5245 : 4646 : if (saw_errors())
5246 : 394 : return;
5247 : :
5248 : : // Mark any functions whose body should be exported for inlining by
5249 : : // other packages.
5250 : 4252 : Unordered_set(Named_object*) marked_functions;
5251 : 4252 : Mark_inline_candidates mic(&marked_functions);
5252 : 4252 : this->traverse(&mic);
5253 : :
5254 : : // For now we always stream to a section. Later we may want to
5255 : : // support streaming to a separate file.
5256 : 4252 : Stream_to_section stream(this->backend());
5257 : :
5258 : : // Write out either the prefix or pkgpath depending on how we were
5259 : : // invoked.
5260 : 4252 : std::string prefix;
5261 : 4252 : std::string pkgpath;
5262 : 4252 : if (this->pkgpath_from_option_)
5263 : 2006 : pkgpath = this->pkgpath_;
5264 : 2246 : else if (this->prefix_from_option_)
5265 : 0 : prefix = this->prefix_;
5266 : 2246 : else if (this->is_main_package())
5267 : 1636 : pkgpath = "main";
5268 : : else
5269 : 610 : prefix = "go";
5270 : :
5271 : 4252 : std::string init_fn_name;
5272 : 4252 : if (this->is_main_package())
5273 : 1636 : init_fn_name = "";
5274 : 2616 : else if (this->need_init_fn_)
5275 : 1525 : init_fn_name = this->get_init_fn_name();
5276 : : else
5277 : 1091 : init_fn_name = this->dummy_init_fn_name();
5278 : :
5279 : 4252 : Export exp(&stream);
5280 : 4252 : exp.register_builtin_types(this);
5281 : 4252 : exp.export_globals(this->package_name(),
5282 : : prefix,
5283 : : pkgpath,
5284 : 4252 : this->packages_,
5285 : 4252 : this->imports_,
5286 : : init_fn_name,
5287 : 4252 : this->imported_init_fns_,
5288 : 4252 : this->package_->bindings(),
5289 : : &marked_functions);
5290 : :
5291 : 4252 : if (!this->c_header_.empty() && !saw_errors())
5292 : 4 : this->write_c_header();
5293 : 4252 : }
5294 : :
5295 : : // Write the top level named struct types in C format to a C header
5296 : : // file. This is used when building the runtime package, to share
5297 : : // struct definitions between C and Go.
5298 : :
5299 : : void
5300 : 4 : Gogo::write_c_header()
5301 : : {
5302 : 4 : std::ofstream out;
5303 : 4 : out.open(this->c_header_.c_str());
5304 : 4 : if (out.fail())
5305 : : {
5306 : 0 : go_error_at(Linemap::unknown_location(),
5307 : : "cannot open %s: %m", this->c_header_.c_str());
5308 : 0 : return;
5309 : : }
5310 : :
5311 : 4 : std::list<Named_object*> types;
5312 : 4 : Bindings* top = this->package_->bindings();
5313 : 41080 : for (Bindings::const_definitions_iterator p = top->begin_definitions();
5314 : 41080 : p != top->end_definitions();
5315 : 41076 : ++p)
5316 : : {
5317 : 41076 : Named_object* no = *p;
5318 : :
5319 : : // Skip names that start with underscore followed by something
5320 : : // other than an uppercase letter, as when compiling the runtime
5321 : : // package they are mostly types defined by mkrsysinfo.sh based
5322 : : // on the C system header files. We don't need to translate
5323 : : // types to C and back to Go. But do accept the special cases
5324 : : // _defer, _panic, and _type.
5325 : 41076 : std::string name = Gogo::unpack_hidden_name(no->name());
5326 : 41076 : if (name[0] == '_'
5327 : 29446 : && (name[1] < 'A' || name[1] > 'Z')
5328 : 51136 : && (name != "_defer" && name != "_panic" && name != "_type"))
5329 : 10044 : continue;
5330 : :
5331 : 31032 : if (no->is_type() && no->type_value()->struct_type() != NULL)
5332 : 656 : types.push_back(no);
5333 : 31032 : if (no->is_const()
5334 : 52268 : && no->const_value()->type()->integer_type() != NULL
5335 : 51732 : && !no->const_value()->is_sink())
5336 : : {
5337 : 20696 : Numeric_constant nc;
5338 : 20696 : unsigned long val;
5339 : 20696 : if (no->const_value()->expr()->numeric_constant_value(&nc)
5340 : 20696 : && nc.to_unsigned_long(&val) == Numeric_constant::NC_UL_VALID)
5341 : : {
5342 : 81872 : out << "#define " << no->message_name() << ' ' << val
5343 : 40936 : << std::endl;
5344 : : }
5345 : 20696 : }
5346 : 41076 : }
5347 : :
5348 : 4 : std::vector<const Named_object*> written;
5349 : 4 : int loop = 0;
5350 : 772 : while (!types.empty())
5351 : : {
5352 : 768 : Named_object* no = types.front();
5353 : 768 : types.pop_front();
5354 : :
5355 : 768 : std::vector<const Named_object*> needs;
5356 : 768 : std::vector<const Named_object*> declare;
5357 : 1536 : if (!no->type_value()->struct_type()->can_write_to_c_header(&needs,
5358 : : &declare))
5359 : 60 : continue;
5360 : :
5361 : 708 : bool ok = true;
5362 : 1172 : for (std::vector<const Named_object*>::const_iterator pr
5363 : 708 : = needs.begin();
5364 : 1172 : pr != needs.end() && ok;
5365 : 464 : ++pr)
5366 : : {
5367 : 17612 : for (std::list<Named_object*>::const_iterator pt = types.begin();
5368 : 17612 : pt != types.end() && ok;
5369 : 17148 : ++pt)
5370 : 17148 : if (*pr == *pt)
5371 : 112 : ok = false;
5372 : : }
5373 : 708 : if (!ok)
5374 : : {
5375 : 112 : ++loop;
5376 : 112 : if (loop > 10000)
5377 : : {
5378 : : // This should be impossible since the code parsed and
5379 : : // type checked.
5380 : 0 : go_unreachable();
5381 : : }
5382 : :
5383 : 112 : types.push_back(no);
5384 : 112 : continue;
5385 : : }
5386 : :
5387 : 1136 : for (std::vector<const Named_object*>::const_iterator pd
5388 : 596 : = declare.begin();
5389 : 1136 : pd != declare.end();
5390 : 540 : ++pd)
5391 : : {
5392 : 540 : if (*pd == no)
5393 : 112 : continue;
5394 : :
5395 : 456 : std::vector<const Named_object*> dneeds;
5396 : 456 : std::vector<const Named_object*> ddeclare;
5397 : 912 : if (!(*pd)->type_value()->struct_type()->
5398 : 912 : can_write_to_c_header(&dneeds, &ddeclare))
5399 : 28 : continue;
5400 : :
5401 : 428 : bool done = false;
5402 : 18764 : for (std::vector<const Named_object*>::const_iterator pw
5403 : 428 : = written.begin();
5404 : 18764 : pw != written.end();
5405 : 18336 : ++pw)
5406 : : {
5407 : 18668 : if (*pw == *pd)
5408 : : {
5409 : : done = true;
5410 : : break;
5411 : : }
5412 : : }
5413 : 428 : if (!done)
5414 : : {
5415 : 96 : out << std::endl;
5416 : 192 : out << "struct " << (*pd)->message_name() << ";" << std::endl;
5417 : 96 : written.push_back(*pd);
5418 : : }
5419 : 456 : }
5420 : :
5421 : 596 : out << std::endl;
5422 : 1192 : out << "struct " << no->message_name() << " {" << std::endl;
5423 : 1192 : no->type_value()->struct_type()->write_to_c_header(out);
5424 : 596 : out << "};" << std::endl;
5425 : 596 : written.push_back(no);
5426 : 768 : }
5427 : :
5428 : 4 : out.close();
5429 : 4 : if (out.fail())
5430 : 0 : go_error_at(Linemap::unknown_location(),
5431 : : "error writing to %s: %m", this->c_header_.c_str());
5432 : 4 : }
5433 : :
5434 : : // Find the blocks in order to convert named types defined in blocks.
5435 : :
5436 : 9292 : class Convert_named_types : public Traverse
5437 : : {
5438 : : public:
5439 : 4646 : Convert_named_types(Gogo* gogo)
5440 : 4646 : : Traverse(traverse_blocks),
5441 : 4646 : gogo_(gogo)
5442 : : { }
5443 : :
5444 : : protected:
5445 : : int
5446 : : block(Block* block);
5447 : :
5448 : : private:
5449 : : Gogo* gogo_;
5450 : : };
5451 : :
5452 : : int
5453 : 1676057 : Convert_named_types::block(Block* block)
5454 : : {
5455 : 1676057 : this->gogo_->convert_named_types_in_bindings(block->bindings());
5456 : 1676057 : return TRAVERSE_CONTINUE;
5457 : : }
5458 : :
5459 : : // Convert all named types to the backend representation. Since named
5460 : : // types can refer to other types, this needs to be done in the right
5461 : : // sequence, which is handled by Named_type::convert. Here we arrange
5462 : : // to call that for each named type.
5463 : :
5464 : : void
5465 : 4646 : Gogo::convert_named_types()
5466 : : {
5467 : 4646 : this->convert_named_types_in_bindings(this->globals_);
5468 : 120891 : for (Packages::iterator p = this->packages_.begin();
5469 : 120891 : p != this->packages_.end();
5470 : 116245 : ++p)
5471 : : {
5472 : 116245 : Package* package = p->second;
5473 : 116245 : this->convert_named_types_in_bindings(package->bindings());
5474 : : }
5475 : :
5476 : 4646 : Convert_named_types cnt(this);
5477 : 4646 : this->traverse(&cnt);
5478 : :
5479 : : // Make all the builtin named types used for type descriptors, and
5480 : : // then convert them. They will only be written out if they are
5481 : : // needed.
5482 : 4646 : Type::make_type_descriptor_type();
5483 : 4646 : Type::make_type_descriptor_ptr_type();
5484 : 4646 : Function_type::make_function_type_descriptor_type();
5485 : 4646 : Pointer_type::make_pointer_type_descriptor_type();
5486 : 4646 : Struct_type::make_struct_type_descriptor_type();
5487 : 4646 : Array_type::make_array_type_descriptor_type();
5488 : 4646 : Array_type::make_slice_type_descriptor_type();
5489 : 4646 : Map_type::make_map_type_descriptor_type();
5490 : 4646 : Channel_type::make_chan_type_descriptor_type();
5491 : 4646 : Interface_type::make_interface_type_descriptor_type();
5492 : 4646 : Expression::make_func_descriptor_type();
5493 : 4646 : Type::convert_builtin_named_types(this);
5494 : :
5495 : 4646 : Runtime::convert_types(this);
5496 : :
5497 : 4646 : this->named_types_are_converted_ = true;
5498 : :
5499 : 4646 : Type::finish_pointer_types(this);
5500 : 4646 : }
5501 : :
5502 : : // Convert all names types in a set of bindings.
5503 : :
5504 : : void
5505 : 1796948 : Gogo::convert_named_types_in_bindings(Bindings* bindings)
5506 : : {
5507 : 4937344 : for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
5508 : 4937344 : p != bindings->end_definitions();
5509 : 3140396 : ++p)
5510 : : {
5511 : 3140396 : if ((*p)->is_type())
5512 : 733326 : (*p)->type_value()->convert(this);
5513 : : }
5514 : 1796948 : }
5515 : :
5516 : : void
5517 : 0 : debug_go_gogo(Gogo* gogo)
5518 : : {
5519 : 0 : if (gogo != NULL)
5520 : 0 : gogo->debug_dump();
5521 : 0 : }
5522 : :
5523 : : void
5524 : 0 : Gogo::debug_dump()
5525 : : {
5526 : 0 : std::cerr << "Packages:\n";
5527 : 0 : for (Packages::const_iterator p = this->packages_.begin();
5528 : 0 : p != this->packages_.end();
5529 : 0 : ++p)
5530 : : {
5531 : 0 : const char *tag = " ";
5532 : 0 : if (p->second == this->package_)
5533 : 0 : tag = "* ";
5534 : 0 : std::cerr << tag << "'" << p->first << "' "
5535 : 0 : << p->second->pkgpath() << " " << ((void*)p->second) << "\n";
5536 : : }
5537 : 0 : }
5538 : :
5539 : : // Class Function.
5540 : :
5541 : 299270 : Function::Function(Function_type* type, Named_object* enclosing, Block* block,
5542 : 299270 : Location location)
5543 : 299270 : : type_(type), enclosing_(enclosing), results_(NULL),
5544 : 299270 : closure_var_(NULL), block_(block), location_(location), labels_(),
5545 : 299270 : local_type_count_(0), descriptor_(NULL), fndecl_(NULL), defer_stack_(NULL),
5546 : 299270 : pragmas_(0), nested_functions_(0), is_sink_(false),
5547 : 299270 : results_are_named_(false), is_unnamed_type_stub_method_(false),
5548 : 299270 : calls_recover_(false), is_recover_thunk_(false), has_recover_thunk_(false),
5549 : 299270 : calls_defer_retaddr_(false), is_type_specific_function_(false),
5550 : 299270 : in_unique_section_(false), export_for_inlining_(false),
5551 : 299270 : is_inline_only_(false), is_referenced_by_inline_(false),
5552 : 299270 : is_exported_by_linkname_(false)
5553 : : {
5554 : 299270 : }
5555 : :
5556 : : // Create the named result variables.
5557 : :
5558 : : void
5559 : 295817 : Function::create_result_variables(Gogo* gogo)
5560 : : {
5561 : 295817 : const Typed_identifier_list* results = this->type_->results();
5562 : 295817 : if (results == NULL || results->empty())
5563 : : return;
5564 : :
5565 : 217670 : if (!results->front().name().empty())
5566 : 21590 : this->results_are_named_ = true;
5567 : :
5568 : 217670 : this->results_ = new Results();
5569 : 217670 : this->results_->reserve(results->size());
5570 : :
5571 : 217670 : Block* block = this->block_;
5572 : 217670 : int index = 0;
5573 : 217670 : for (Typed_identifier_list::const_iterator p = results->begin();
5574 : 462567 : p != results->end();
5575 : 244897 : ++p, ++index)
5576 : : {
5577 : 244897 : std::string name = p->name();
5578 : 244897 : if (name.empty() || Gogo::is_sink_name(name))
5579 : : {
5580 : 212090 : static int result_counter;
5581 : 212090 : char buf[100];
5582 : 212090 : snprintf(buf, sizeof buf, "$ret%d", result_counter);
5583 : 212090 : ++result_counter;
5584 : 212090 : name = gogo->pack_hidden_name(buf, false);
5585 : : }
5586 : 244897 : Result_variable* result = new Result_variable(p->type(), this, index,
5587 : 244897 : p->location());
5588 : 244897 : Named_object* no = block->bindings()->add_result_variable(name, result);
5589 : 244897 : if (no->is_result_variable())
5590 : 244893 : this->results_->push_back(no);
5591 : : else
5592 : : {
5593 : 4 : static int dummy_result_count;
5594 : 4 : char buf[100];
5595 : 4 : snprintf(buf, sizeof buf, "$dret%d", dummy_result_count);
5596 : 4 : ++dummy_result_count;
5597 : 4 : name = gogo->pack_hidden_name(buf, false);
5598 : 4 : no = block->bindings()->add_result_variable(name, result);
5599 : 4 : go_assert(no->is_result_variable());
5600 : 4 : this->results_->push_back(no);
5601 : : }
5602 : 244897 : }
5603 : : }
5604 : :
5605 : : // Update the named result variables when cloning a function which
5606 : : // calls recover.
5607 : :
5608 : : void
5609 : 1662 : Function::update_result_variables()
5610 : : {
5611 : 1662 : if (this->results_ == NULL)
5612 : : return;
5613 : :
5614 : 12 : for (Results::iterator p = this->results_->begin();
5615 : 12 : p != this->results_->end();
5616 : 6 : ++p)
5617 : 6 : (*p)->result_var_value()->set_function(this);
5618 : : }
5619 : :
5620 : : // Whether this method should not be included in the type descriptor.
5621 : :
5622 : : bool
5623 : 572082 : Function::nointerface() const
5624 : : {
5625 : 572082 : go_assert(this->is_method());
5626 : 572082 : return (this->pragmas_ & GOPRAGMA_NOINTERFACE) != 0;
5627 : : }
5628 : :
5629 : : // Record that this method should not be included in the type
5630 : : // descriptor.
5631 : :
5632 : : void
5633 : 2 : Function::set_nointerface()
5634 : : {
5635 : 2 : this->pragmas_ |= GOPRAGMA_NOINTERFACE;
5636 : 2 : }
5637 : :
5638 : : // Return the closure variable, creating it if necessary.
5639 : :
5640 : : Named_object*
5641 : 56715 : Function::closure_var()
5642 : : {
5643 : 56715 : if (this->closure_var_ == NULL)
5644 : : {
5645 : 13057 : go_assert(this->descriptor_ == NULL);
5646 : : // We don't know the type of the variable yet. We add fields as
5647 : : // we find them.
5648 : 13057 : Location loc = this->type_->location();
5649 : 13057 : Struct_field_list* sfl = new Struct_field_list;
5650 : 13057 : Struct_type* struct_type = Type::make_struct_type(sfl, loc);
5651 : 13057 : struct_type->set_is_struct_incomparable();
5652 : 13057 : Variable* var = new Variable(Type::make_pointer_type(struct_type),
5653 : 26114 : NULL, false, false, false, loc);
5654 : 13057 : var->set_is_used();
5655 : 13057 : var->set_is_closure();
5656 : 13057 : this->closure_var_ = Named_object::make_variable("$closure", NULL, var);
5657 : : // Note that the new variable is not in any binding contour.
5658 : : }
5659 : 56715 : return this->closure_var_;
5660 : : }
5661 : :
5662 : : // Set the type of the closure variable.
5663 : :
5664 : : void
5665 : 175575 : Function::set_closure_type()
5666 : : {
5667 : 175575 : if (this->closure_var_ == NULL)
5668 : : return;
5669 : 13057 : Named_object* closure = this->closure_var_;
5670 : 26114 : Struct_type* st = closure->var_value()->type()->deref()->struct_type();
5671 : :
5672 : : // The first field of a closure is always a pointer to the function
5673 : : // code.
5674 : 13057 : Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
5675 : 26114 : st->push_field(Struct_field(Typed_identifier(".f", voidptr_type,
5676 : 13057 : this->location_)));
5677 : :
5678 : 13057 : unsigned int index = 1;
5679 : 13057 : for (Closure_fields::const_iterator p = this->closure_fields_.begin();
5680 : 38530 : p != this->closure_fields_.end();
5681 : 25473 : ++p, ++index)
5682 : : {
5683 : 25473 : Named_object* no = p->first;
5684 : 25473 : char buf[20];
5685 : 25473 : snprintf(buf, sizeof buf, "%u", index);
5686 : 25473 : std::string n = no->name() + buf;
5687 : 25473 : Type* var_type;
5688 : 25473 : if (no->is_variable())
5689 : 24646 : var_type = no->var_value()->type();
5690 : : else
5691 : 827 : var_type = no->result_var_value()->type();
5692 : 25473 : Type* field_type = Type::make_pointer_type(var_type);
5693 : 50946 : st->push_field(Struct_field(Typed_identifier(n, field_type, p->second)));
5694 : 25473 : }
5695 : : }
5696 : :
5697 : : // Return whether this function is a method.
5698 : :
5699 : : bool
5700 : 1802988 : Function::is_method() const
5701 : : {
5702 : 1802988 : return this->type_->is_method();
5703 : : }
5704 : :
5705 : : // Add a label definition.
5706 : :
5707 : : Label*
5708 : 10526 : Function::add_label_definition(Gogo* gogo, const std::string& label_name,
5709 : : Location location)
5710 : : {
5711 : 10526 : Label* lnull = NULL;
5712 : 10526 : std::pair<Labels::iterator, bool> ins =
5713 : 21052 : this->labels_.insert(std::make_pair(label_name, lnull));
5714 : 10526 : Label* label;
5715 : 10526 : if (label_name == "_")
5716 : : {
5717 : 3 : label = Label::create_dummy_label();
5718 : 3 : if (ins.second)
5719 : 2 : ins.first->second = label;
5720 : : }
5721 : 10523 : else if (ins.second)
5722 : : {
5723 : : // This is a new label.
5724 : 1126 : label = new Label(label_name);
5725 : 1126 : ins.first->second = label;
5726 : : }
5727 : : else
5728 : : {
5729 : : // The label was already in the hash table.
5730 : 9397 : label = ins.first->second;
5731 : 9397 : if (label->is_defined())
5732 : : {
5733 : 2 : go_error_at(location, "label %qs already defined",
5734 : 2 : Gogo::message_name(label_name).c_str());
5735 : 2 : go_inform(label->location(), "previous definition of %qs was here",
5736 : 2 : Gogo::message_name(label_name).c_str());
5737 : 2 : return new Label(label_name);
5738 : : }
5739 : : }
5740 : :
5741 : 10524 : label->define(location, gogo->bindings_snapshot(location));
5742 : :
5743 : : // Issue any errors appropriate for any previous goto's to this
5744 : : // label.
5745 : 10524 : const std::vector<Bindings_snapshot*>& refs(label->refs());
5746 : 12089 : for (std::vector<Bindings_snapshot*>::const_iterator p = refs.begin();
5747 : 12089 : p != refs.end();
5748 : 1565 : ++p)
5749 : 1565 : (*p)->check_goto_to(gogo->current_block());
5750 : 10524 : label->clear_refs();
5751 : :
5752 : 10524 : return label;
5753 : : }
5754 : :
5755 : : // Add a reference to a label.
5756 : :
5757 : : Label*
5758 : 10959 : Function::add_label_reference(Gogo* gogo, const std::string& label_name,
5759 : : Location location, bool issue_goto_errors)
5760 : : {
5761 : 10959 : Label* lnull = NULL;
5762 : 10959 : std::pair<Labels::iterator, bool> ins =
5763 : 21918 : this->labels_.insert(std::make_pair(label_name, lnull));
5764 : 10959 : Label* label;
5765 : 10959 : if (!ins.second)
5766 : : {
5767 : : // The label was already in the hash table.
5768 : 1559 : label = ins.first->second;
5769 : : }
5770 : : else
5771 : : {
5772 : 9400 : go_assert(ins.first->second == NULL);
5773 : 9400 : label = new Label(label_name);
5774 : 9400 : ins.first->second = label;
5775 : : }
5776 : :
5777 : 10959 : label->set_is_used();
5778 : :
5779 : 10959 : if (issue_goto_errors)
5780 : : {
5781 : 2101 : Bindings_snapshot* snapshot = label->snapshot();
5782 : 2101 : if (snapshot != NULL)
5783 : 533 : snapshot->check_goto_from(gogo->current_block(), location);
5784 : : else
5785 : 1568 : label->add_snapshot_ref(gogo->bindings_snapshot(location));
5786 : : }
5787 : :
5788 : 10959 : return label;
5789 : : }
5790 : :
5791 : : // Warn about labels that are defined but not used.
5792 : :
5793 : : void
5794 : 175575 : Function::check_labels() const
5795 : : {
5796 : 177262 : for (Labels::const_iterator p = this->labels_.begin();
5797 : 177262 : p != this->labels_.end();
5798 : 1687 : p++)
5799 : : {
5800 : 1687 : Label* label = p->second;
5801 : 1687 : if (!label->is_used())
5802 : 7 : go_error_at(label->location(), "label %qs defined and not used",
5803 : 14 : Gogo::message_name(label->name()).c_str());
5804 : : }
5805 : 175575 : }
5806 : :
5807 : : // Set the receiver type. This is used to remove aliases.
5808 : :
5809 : : void
5810 : 2 : Function::set_receiver_type(Type* rtype)
5811 : : {
5812 : 2 : Function_type* oft = this->type_;
5813 : 2 : Typed_identifier* rec = new Typed_identifier(oft->receiver()->name(),
5814 : : rtype,
5815 : 2 : oft->receiver()->location());
5816 : 2 : Typed_identifier_list* parameters = NULL;
5817 : 2 : if (oft->parameters() != NULL)
5818 : 0 : parameters = oft->parameters()->copy();
5819 : 2 : Typed_identifier_list* results = NULL;
5820 : 2 : if (oft->results() != NULL)
5821 : 0 : results = oft->results()->copy();
5822 : 2 : Function_type* nft = Type::make_function_type(rec, parameters, results,
5823 : : oft->location());
5824 : 2 : this->type_ = nft;
5825 : 2 : }
5826 : :
5827 : : // Swap one function with another. This is used when building the
5828 : : // thunk we use to call a function which calls recover. It may not
5829 : : // work for any other case.
5830 : :
5831 : : void
5832 : 831 : Function::swap_for_recover(Function *x)
5833 : : {
5834 : 831 : go_assert(this->enclosing_ == x->enclosing_);
5835 : 831 : std::swap(this->results_, x->results_);
5836 : 831 : std::swap(this->closure_var_, x->closure_var_);
5837 : 831 : std::swap(this->block_, x->block_);
5838 : 831 : go_assert(this->location_ == x->location_);
5839 : 831 : go_assert(this->fndecl_ == NULL && x->fndecl_ == NULL);
5840 : 831 : go_assert(this->defer_stack_ == NULL && x->defer_stack_ == NULL);
5841 : 831 : }
5842 : :
5843 : : // Traverse the tree.
5844 : :
5845 : : int
5846 : 4843658 : Function::traverse(Traverse* traverse)
5847 : : {
5848 : 4843658 : unsigned int traverse_mask = traverse->traverse_mask();
5849 : :
5850 : 4843658 : if ((traverse_mask
5851 : 4843658 : & (Traverse::traverse_types | Traverse::traverse_expressions))
5852 : : != 0)
5853 : : {
5854 : 3032181 : if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
5855 : : return TRAVERSE_EXIT;
5856 : : }
5857 : :
5858 : : // FIXME: We should check traverse_functions here if nested
5859 : : // functions are stored in block bindings.
5860 : 4843658 : if (this->block_ != NULL
5861 : 4843658 : && (traverse_mask
5862 : 4843658 : & (Traverse::traverse_variables
5863 : : | Traverse::traverse_constants
5864 : : | Traverse::traverse_blocks
5865 : : | Traverse::traverse_statements
5866 : : | Traverse::traverse_expressions
5867 : : | Traverse::traverse_types)) != 0)
5868 : : {
5869 : 4275326 : if (this->block_->traverse(traverse) == TRAVERSE_EXIT)
5870 : : return TRAVERSE_EXIT;
5871 : : }
5872 : :
5873 : : return TRAVERSE_CONTINUE;
5874 : : }
5875 : :
5876 : : // Work out types for unspecified variables and constants.
5877 : :
5878 : : void
5879 : 175575 : Function::determine_types(Gogo* gogo)
5880 : : {
5881 : 175575 : this->set_closure_type();
5882 : 175575 : if (this->block_ != NULL)
5883 : 175575 : this->block_->determine_types(gogo);
5884 : 175575 : }
5885 : :
5886 : : // Return the function descriptor, the value you get when you refer to
5887 : : // the function in Go code without calling it.
5888 : :
5889 : : Expression*
5890 : 194963 : Function::descriptor(Gogo*, Named_object* no)
5891 : : {
5892 : 194963 : go_assert(!this->is_method());
5893 : 194963 : go_assert(this->closure_var_ == NULL);
5894 : 194963 : if (this->descriptor_ == NULL)
5895 : 154640 : this->descriptor_ = Expression::make_func_descriptor(no);
5896 : 194963 : return this->descriptor_;
5897 : : }
5898 : :
5899 : : // Get a pointer to the variable representing the defer stack for this
5900 : : // function, making it if necessary. The value of the variable is set
5901 : : // by the runtime routines to true if the function is returning,
5902 : : // rather than panicing through. A pointer to this variable is used
5903 : : // as a marker for the functions on the defer stack associated with
5904 : : // this function. A function-specific variable permits inlining a
5905 : : // function which uses defer.
5906 : :
5907 : : Expression*
5908 : 47518 : Function::defer_stack(Location location)
5909 : : {
5910 : 47518 : if (this->defer_stack_ == NULL)
5911 : : {
5912 : 8354 : Type* t = Type::lookup_bool_type();
5913 : 8354 : Expression* n = Expression::make_boolean(false, location);
5914 : 8354 : this->defer_stack_ = Statement::make_temporary(t, n, location);
5915 : 8354 : this->defer_stack_->set_is_address_taken();
5916 : : }
5917 : 47518 : Expression* ref = Expression::make_temporary_reference(this->defer_stack_,
5918 : : location);
5919 : 47518 : return Expression::make_unary(OPERATOR_AND, ref, location);
5920 : : }
5921 : :
5922 : : // Export the function.
5923 : :
5924 : : void
5925 : 79191 : Function::export_func(Export* exp, const Named_object* no) const
5926 : : {
5927 : 79191 : Block* block = NULL;
5928 : 79191 : if (this->export_for_inlining())
5929 : 16707 : block = this->block_;
5930 : 158382 : Function::export_func_with_type(exp, no, this->type_, this->results_,
5931 : 79191 : this->is_method() && this->nointerface(),
5932 : : this->asm_name(), block, this->location_);
5933 : 79191 : }
5934 : :
5935 : : // Export a function with a type.
5936 : :
5937 : : void
5938 : 380525 : Function::export_func_with_type(Export* exp, const Named_object* no,
5939 : : const Function_type* fntype,
5940 : : Function::Results* result_vars,
5941 : : bool nointerface, const std::string& asm_name,
5942 : : Block* block, Location loc)
5943 : : {
5944 : 380525 : exp->write_c_string("func ");
5945 : :
5946 : 380525 : if (nointerface)
5947 : : {
5948 : 2 : go_assert(fntype->is_method());
5949 : 2 : exp->write_c_string("/*nointerface*/ ");
5950 : : }
5951 : :
5952 : 380525 : if (!asm_name.empty())
5953 : : {
5954 : 1943 : exp->write_c_string("/*asm ");
5955 : 1943 : exp->write_string(asm_name);
5956 : 1943 : exp->write_c_string(" */ ");
5957 : : }
5958 : :
5959 : 380525 : if (fntype->is_method())
5960 : : {
5961 : 332259 : exp->write_c_string("(");
5962 : 332259 : const Typed_identifier* receiver = fntype->receiver();
5963 : 332259 : exp->write_name(receiver->name());
5964 : 332259 : exp->write_escape(receiver->note());
5965 : 332259 : exp->write_c_string(" ");
5966 : 332259 : exp->write_type(receiver->type()->unalias());
5967 : 332259 : exp->write_c_string(") ");
5968 : : }
5969 : :
5970 : 380525 : if (no->package() != NULL && !fntype->is_method())
5971 : : {
5972 : 12519 : char buf[50];
5973 : 12519 : snprintf(buf, sizeof buf, "<p%d>", exp->package_index(no->package()));
5974 : 12519 : exp->write_c_string(buf);
5975 : : }
5976 : :
5977 : 380525 : const std::string& name(no->name());
5978 : 380525 : if (!Gogo::is_hidden_name(name))
5979 : 266401 : exp->write_string(name);
5980 : : else
5981 : : {
5982 : 114124 : exp->write_c_string(".");
5983 : 114124 : exp->write_string(Gogo::unpack_hidden_name(name));
5984 : : }
5985 : :
5986 : 380525 : exp->write_c_string(" (");
5987 : 380525 : const Typed_identifier_list* parameters = fntype->parameters();
5988 : 380525 : if (parameters != NULL)
5989 : : {
5990 : 196976 : bool is_varargs = fntype->is_varargs();
5991 : 196976 : bool first = true;
5992 : 502780 : for (Typed_identifier_list::const_iterator p = parameters->begin();
5993 : 502780 : p != parameters->end();
5994 : 305804 : ++p)
5995 : : {
5996 : 305804 : if (first)
5997 : : first = false;
5998 : : else
5999 : 108828 : exp->write_c_string(", ");
6000 : 305804 : exp->write_name(p->name());
6001 : 305804 : exp->write_escape(p->note());
6002 : 305804 : exp->write_c_string(" ");
6003 : 305804 : if (!is_varargs || p + 1 != parameters->end())
6004 : 297156 : exp->write_type(p->type());
6005 : : else
6006 : : {
6007 : 8648 : exp->write_c_string("...");
6008 : 17296 : exp->write_type(p->type()->array_type()->element_type());
6009 : : }
6010 : : }
6011 : : }
6012 : 380525 : exp->write_c_string(")");
6013 : :
6014 : 380525 : const Typed_identifier_list* result_decls = fntype->results();
6015 : 380525 : if (result_decls != NULL)
6016 : : {
6017 : 285501 : if (result_decls->size() == 1
6018 : 238548 : && result_decls->begin()->name().empty()
6019 : 495866 : && block == NULL)
6020 : : {
6021 : 202162 : exp->write_c_string(" ");
6022 : 202162 : exp->write_type(result_decls->begin()->type());
6023 : : }
6024 : : else
6025 : : {
6026 : 83339 : exp->write_c_string(" (");
6027 : 83339 : bool first = true;
6028 : 83339 : Results::const_iterator pr;
6029 : 83339 : if (result_vars != NULL)
6030 : 23063 : pr = result_vars->begin();
6031 : 228546 : for (Typed_identifier_list::const_iterator pd = result_decls->begin();
6032 : 228546 : pd != result_decls->end();
6033 : 145207 : ++pd)
6034 : : {
6035 : 145207 : if (first)
6036 : : first = false;
6037 : : else
6038 : 61868 : exp->write_c_string(", ");
6039 : : // We only use pr->name, which may be artificial, if
6040 : : // need it for inlining.
6041 : 145207 : if (block == NULL || result_vars == NULL)
6042 : 131610 : exp->write_name(pd->name());
6043 : : else
6044 : 13597 : exp->write_name((*pr)->name());
6045 : 145207 : exp->write_escape(pd->note());
6046 : 145207 : exp->write_c_string(" ");
6047 : 145207 : exp->write_type(pd->type());
6048 : 145207 : if (result_vars != NULL)
6049 : 34890 : ++pr;
6050 : : }
6051 : 83339 : if (result_vars != NULL)
6052 : 23063 : go_assert(pr == result_vars->end());
6053 : 83339 : exp->write_c_string(")");
6054 : : }
6055 : : }
6056 : :
6057 : 380525 : if (block == NULL)
6058 : 363818 : exp->write_c_string("\n");
6059 : : else
6060 : : {
6061 : 16707 : int indent = 1;
6062 : 16707 : if (fntype->is_method())
6063 : 7254 : indent++;
6064 : :
6065 : 16707 : Export_function_body efb(exp, indent);
6066 : :
6067 : 16707 : efb.indent();
6068 : 16707 : efb.write_c_string("// ");
6069 : 33414 : efb.write_string(Linemap::location_to_file(block->start_location()));
6070 : 16707 : efb.write_char(':');
6071 : 16707 : char buf[100];
6072 : 16707 : snprintf(buf, sizeof buf, "%d", Linemap::location_to_line(loc));
6073 : 16707 : efb.write_c_string(buf);
6074 : 16707 : efb.write_char('\n');
6075 : 16707 : block->export_block(&efb);
6076 : :
6077 : 16707 : const std::string& body(efb.body());
6078 : :
6079 : 16707 : snprintf(buf, sizeof buf, " <inl:%lu>\n",
6080 : 16707 : static_cast<unsigned long>(body.length()));
6081 : 16707 : exp->write_c_string(buf);
6082 : :
6083 : 16707 : exp->write_string(body);
6084 : 16707 : }
6085 : 380525 : }
6086 : :
6087 : : // Import a function.
6088 : :
6089 : : bool
6090 : 3055849 : Function::import_func(Import* imp, std::string* pname,
6091 : : Package** ppkg, bool* pis_exported,
6092 : : Typed_identifier** preceiver,
6093 : : Typed_identifier_list** pparameters,
6094 : : Typed_identifier_list** presults,
6095 : : bool* is_varargs,
6096 : : bool* nointerface,
6097 : : std::string* asm_name,
6098 : : std::string* body)
6099 : : {
6100 : 3055849 : imp->require_c_string("func ");
6101 : :
6102 : 3055849 : *nointerface = false;
6103 : 3168045 : while (imp->match_c_string("/*"))
6104 : : {
6105 : 112196 : imp->advance(2);
6106 : 112196 : if (imp->match_c_string("nointerface"))
6107 : : {
6108 : 2 : imp->require_c_string("nointerface*/ ");
6109 : 2 : *nointerface = true;
6110 : : }
6111 : 112194 : else if (imp->match_c_string("asm"))
6112 : : {
6113 : 112194 : imp->require_c_string("asm ");
6114 : 112194 : *asm_name = imp->read_identifier();
6115 : 112194 : imp->require_c_string(" */ ");
6116 : : }
6117 : : else
6118 : : {
6119 : 0 : go_error_at(imp->location(),
6120 : : "import error at %d: unrecognized function comment",
6121 : : imp->pos());
6122 : 0 : return false;
6123 : : }
6124 : : }
6125 : :
6126 : 3055849 : if (*nointerface)
6127 : : {
6128 : : // Only a method can be nointerface.
6129 : 2 : go_assert(imp->peek_char() == '(');
6130 : : }
6131 : :
6132 : 3055849 : *preceiver = NULL;
6133 : 3055849 : if (imp->peek_char() == '(')
6134 : : {
6135 : 1784464 : imp->require_c_string("(");
6136 : 1784464 : std::string name = imp->read_name();
6137 : 1784464 : std::string escape_note = imp->read_escape();
6138 : 1784464 : imp->require_c_string(" ");
6139 : 1784464 : Type* rtype = imp->read_type();
6140 : 1784464 : *preceiver = new Typed_identifier(name, rtype, imp->location());
6141 : 1784464 : (*preceiver)->set_note(escape_note);
6142 : 1784464 : imp->require_c_string(") ");
6143 : 1784464 : }
6144 : :
6145 : 3055849 : if (!Import::read_qualified_identifier(imp, pname, ppkg, pis_exported))
6146 : : {
6147 : 0 : go_error_at(imp->location(),
6148 : : "import error at %d: bad function name in export data",
6149 : : imp->pos());
6150 : 0 : return false;
6151 : : }
6152 : :
6153 : 3055849 : Typed_identifier_list* parameters;
6154 : 3055849 : *is_varargs = false;
6155 : 3055849 : imp->require_c_string(" (");
6156 : 3055849 : if (imp->peek_char() == ')')
6157 : : parameters = NULL;
6158 : : else
6159 : : {
6160 : 1898752 : parameters = new Typed_identifier_list();
6161 : 4524174 : while (true)
6162 : : {
6163 : 3211463 : std::string name = imp->read_name();
6164 : 3211463 : std::string escape_note = imp->read_escape();
6165 : 3211463 : imp->require_c_string(" ");
6166 : :
6167 : 3211463 : if (imp->match_c_string("..."))
6168 : : {
6169 : 52697 : imp->advance(3);
6170 : 52697 : *is_varargs = true;
6171 : : }
6172 : :
6173 : 3211463 : Type* ptype = imp->read_type();
6174 : 3211463 : if (*is_varargs)
6175 : 52697 : ptype = Type::make_array_type(ptype, NULL);
6176 : 3211463 : Typed_identifier t = Typed_identifier(name, ptype, imp->location());
6177 : 3211463 : t.set_note(escape_note);
6178 : 3211463 : parameters->push_back(t);
6179 : 3211463 : if (imp->peek_char() != ',')
6180 : : break;
6181 : 1312711 : go_assert(!*is_varargs);
6182 : 1312711 : imp->require_c_string(", ");
6183 : 3211463 : }
6184 : : }
6185 : 3055849 : imp->require_c_string(")");
6186 : 3055849 : *pparameters = parameters;
6187 : :
6188 : 3055849 : Typed_identifier_list* results;
6189 : 3055849 : if (imp->peek_char() != ' ' || imp->match_c_string(" <inl"))
6190 : : results = NULL;
6191 : : else
6192 : : {
6193 : 2247984 : results = new Typed_identifier_list();
6194 : 2247984 : imp->require_c_string(" ");
6195 : 2247984 : if (imp->peek_char() != '(')
6196 : : {
6197 : 1422320 : Type* rtype = imp->read_type();
6198 : 2844640 : results->push_back(Typed_identifier("", rtype, imp->location()));
6199 : : }
6200 : : else
6201 : : {
6202 : 825664 : imp->require_c_string("(");
6203 : 1762970 : while (true)
6204 : : {
6205 : 1294317 : std::string name = imp->read_name();
6206 : 1294317 : std::string note = imp->read_escape();
6207 : 1294317 : imp->require_c_string(" ");
6208 : 1294317 : Type* rtype = imp->read_type();
6209 : 1294317 : Typed_identifier t = Typed_identifier(name, rtype,
6210 : 1294317 : imp->location());
6211 : 1294317 : t.set_note(note);
6212 : 1294317 : results->push_back(t);
6213 : 1294317 : if (imp->peek_char() != ',')
6214 : : break;
6215 : 468653 : imp->require_c_string(", ");
6216 : 1294317 : }
6217 : 825664 : imp->require_c_string(")");
6218 : : }
6219 : : }
6220 : 3055849 : *presults = results;
6221 : :
6222 : 3055849 : if (!imp->match_c_string(" <inl:"))
6223 : : {
6224 : 2549164 : imp->require_semicolon_if_old_version();
6225 : 2549164 : imp->require_c_string("\n");
6226 : 2549164 : body->clear();
6227 : : }
6228 : : else
6229 : : {
6230 : 506685 : imp->require_c_string(" <inl:");
6231 : 506685 : std::string lenstr;
6232 : 1989446 : int c;
6233 : 3472207 : while (true)
6234 : : {
6235 : 1989446 : c = imp->peek_char();
6236 : 1989446 : if (c < '0' || c > '9')
6237 : : break;
6238 : 1482761 : lenstr += c;
6239 : 1482761 : imp->get_char();
6240 : : }
6241 : 506685 : imp->require_c_string(">\n");
6242 : :
6243 : 506685 : errno = 0;
6244 : 506685 : char* end;
6245 : 506685 : long llen = strtol(lenstr.c_str(), &end, 10);
6246 : 506685 : if (*end != '\0'
6247 : 506685 : || llen < 0
6248 : 506685 : || (llen == LONG_MAX && errno == ERANGE))
6249 : : {
6250 : 0 : go_error_at(imp->location(), "invalid inline function length %s",
6251 : : lenstr.c_str());
6252 : 0 : return false;
6253 : : }
6254 : :
6255 : 506685 : imp->read(static_cast<size_t>(llen), body);
6256 : 506685 : }
6257 : :
6258 : : return true;
6259 : : }
6260 : :
6261 : : // Get the backend name.
6262 : :
6263 : : void
6264 : 453583 : Function::backend_name(Gogo* gogo, Named_object* no, Backend_name *bname)
6265 : : {
6266 : 453583 : if (!this->asm_name_.empty())
6267 : 186630 : bname->set_asm_name(this->asm_name_);
6268 : 266953 : else if (no->package() == NULL && no->name() == gogo->get_init_fn_name())
6269 : : {
6270 : : // These names appear in the export data and are used
6271 : : // directly in the assembler code. If we change this here
6272 : : // we need to change Gogo::init_imports.
6273 : 3453 : bname->set_asm_name(no->name());
6274 : : }
6275 : 263500 : else if (this->enclosing_ != NULL)
6276 : : {
6277 : : // Rewrite the nested name to use the enclosing function name.
6278 : : // We don't do this earlier because we just store simple names
6279 : : // in a Named_object, not Backend_names.
6280 : :
6281 : : // The name was set by nested_function_name, which always
6282 : : // appends ..funcNNN. We want that to be our suffix.
6283 : 35810 : size_t pos = no->name().find("..func");
6284 : 35810 : go_assert(pos != std::string::npos);
6285 : :
6286 : 35810 : Named_object* enclosing = this->enclosing_;
6287 : 39375 : while (true)
6288 : : {
6289 : 39375 : Named_object* parent = enclosing->func_value()->enclosing();
6290 : 39375 : if (parent == NULL)
6291 : : break;
6292 : : enclosing = parent;
6293 : : }
6294 : :
6295 : 35810 : Type* rtype = NULL;
6296 : 35810 : if (enclosing->func_value()->type()->is_method())
6297 : 4021 : rtype = enclosing->func_value()->type()->receiver()->type();
6298 : 35810 : gogo->function_backend_name(enclosing->name(), enclosing->package(),
6299 : : rtype, bname);
6300 : 35810 : bname->append_suffix(no->name().substr(pos));
6301 : : }
6302 : : else
6303 : : {
6304 : 227690 : Type* rtype = NULL;
6305 : 227690 : if (this->type_->is_method())
6306 : 78028 : rtype = this->type_->receiver()->type();
6307 : 227690 : gogo->function_backend_name(no->name(), no->package(), rtype, bname);
6308 : : }
6309 : 453583 : }
6310 : :
6311 : : // Get the backend representation.
6312 : :
6313 : : Bfunction*
6314 : 3815493 : Function::get_or_make_decl(Gogo* gogo, Named_object* no)
6315 : : {
6316 : 3815493 : if (this->fndecl_ == NULL)
6317 : : {
6318 : 298947 : unsigned int flags = 0;
6319 : 298947 : if (no->package() != NULL)
6320 : : {
6321 : : // Functions defined in other packages must be visible.
6322 : : flags |= Backend::function_is_visible;
6323 : : }
6324 : 286700 : else if (this->enclosing_ != NULL || Gogo::is_thunk(no))
6325 : : ;
6326 : 246708 : else if (Gogo::unpack_hidden_name(no->name()) == "init"
6327 : 246708 : && !this->type_->is_method())
6328 : : ;
6329 : 246708 : else if (no->name() == gogo->get_init_fn_name())
6330 : : flags |= Backend::function_is_visible;
6331 : 243255 : else if (Gogo::unpack_hidden_name(no->name()) == "main"
6332 : 243255 : && gogo->is_main_package())
6333 : : flags |= Backend::function_is_visible;
6334 : : // Methods have to be public even if they are hidden because
6335 : : // they can be pulled into type descriptors when using
6336 : : // anonymous fields.
6337 : 241491 : else if (!Gogo::is_hidden_name(no->name())
6338 : 241491 : || this->type_->is_method())
6339 : : {
6340 : 201716 : if (!this->is_unnamed_type_stub_method_)
6341 : 209116 : flags |= Backend::function_is_visible;
6342 : : }
6343 : :
6344 : 298947 : if (!this->asm_name_.empty())
6345 : : {
6346 : : // If an assembler name is explicitly specified, there must
6347 : : // be some reason to refer to the symbol from a different
6348 : : // object file.
6349 : 93778 : flags |= Backend::function_is_visible;
6350 : : }
6351 : :
6352 : : // If an inline body refers to this function, then it
6353 : : // needs to be visible in the symbol table.
6354 : 298947 : if (this->is_referenced_by_inline_)
6355 : 8157 : flags |= Backend::function_is_visible;
6356 : :
6357 : : // A go:linkname directive can be used to force a function to be
6358 : : // visible.
6359 : 298947 : if (this->is_exported_by_linkname_)
6360 : 1673 : flags |= Backend::function_is_visible;
6361 : :
6362 : : // If a function calls the predeclared recover function, we
6363 : : // can't inline it, because recover behaves differently in a
6364 : : // function passed directly to defer. If this is a recover
6365 : : // thunk that we built to test whether a function can be
6366 : : // recovered, we can't inline it, because that will mess up
6367 : : // our return address comparison.
6368 : 298947 : bool is_inlinable = !(this->calls_recover_ || this->is_recover_thunk_);
6369 : :
6370 : : // If a function calls __go_set_defer_retaddr, then mark it as
6371 : : // uninlinable. This prevents the GCC backend from splitting
6372 : : // the function; splitting the function is a bad idea because we
6373 : : // want the return address label to be in the same function as
6374 : : // the call.
6375 : 298947 : if (this->calls_defer_retaddr_)
6376 : 8840 : is_inlinable = false;
6377 : :
6378 : : // Check the //go:noinline compiler directive.
6379 : 298947 : if ((this->pragmas_ & GOPRAGMA_NOINLINE) != 0)
6380 : : is_inlinable = false;
6381 : :
6382 : 298587 : if (is_inlinable)
6383 : 288084 : flags |= Backend::function_is_inlinable;
6384 : :
6385 : : // If this is a thunk created to call a function which calls
6386 : : // the predeclared recover function, we need to disable
6387 : : // stack splitting for the thunk.
6388 : 298947 : bool disable_split_stack = this->is_recover_thunk_;
6389 : :
6390 : : // Check the //go:nosplit compiler directive.
6391 : 298947 : if ((this->pragmas_ & GOPRAGMA_NOSPLIT) != 0)
6392 : : disable_split_stack = true;
6393 : :
6394 : 297513 : if (disable_split_stack)
6395 : 2264 : flags |= Backend::function_no_split_stack;
6396 : :
6397 : : // This should go into a unique section if that has been
6398 : : // requested elsewhere, or if this is a nointerface function.
6399 : : // We want to put a nointerface function into a unique section
6400 : : // because there is a good chance that the linker garbage
6401 : : // collection can discard it.
6402 : 298947 : if (this->in_unique_section_
6403 : 298947 : || (this->is_method() && this->nointerface()))
6404 : 3 : flags |= Backend::function_in_unique_section;
6405 : :
6406 : 298947 : if (this->is_inline_only_)
6407 : 12247 : flags |= Backend::function_only_inline;
6408 : :
6409 : 298947 : Btype* functype = this->type_->get_backend_fntype(gogo);
6410 : :
6411 : 298947 : Backend_name bname;
6412 : 298947 : this->backend_name(gogo, no, &bname);
6413 : :
6414 : 597894 : this->fndecl_ = gogo->backend()->function(functype,
6415 : 597894 : bname.name(),
6416 : 298947 : bname.optional_asm_name(),
6417 : : flags,
6418 : : this->location());
6419 : 298947 : }
6420 : 3815493 : return this->fndecl_;
6421 : : }
6422 : :
6423 : : // Get the backend name.
6424 : :
6425 : : void
6426 : 382393 : Function_declaration::backend_name(Gogo* gogo, Named_object* no,
6427 : : Backend_name* bname)
6428 : : {
6429 : 382393 : if (!this->asm_name_.empty())
6430 : 214540 : bname->set_asm_name(this->asm_name_);
6431 : : else
6432 : : {
6433 : 167853 : Type* rtype = NULL;
6434 : 167853 : if (this->fntype_->is_method())
6435 : 120044 : rtype = this->fntype_->receiver()->type();
6436 : 167853 : gogo->function_backend_name(no->name(), no->package(), rtype, bname);
6437 : : }
6438 : 382393 : }
6439 : :
6440 : : // Get the backend representation.
6441 : :
6442 : : Bfunction*
6443 : 1525106 : Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no)
6444 : : {
6445 : 1525106 : if (this->fndecl_ == NULL)
6446 : : {
6447 : 283089 : unsigned int flags =
6448 : : (Backend::function_is_visible
6449 : : | Backend::function_is_declaration
6450 : : | Backend::function_is_inlinable);
6451 : :
6452 : : // Let Go code use an asm declaration to pick up a builtin
6453 : : // function.
6454 : 283089 : if (!this->asm_name_.empty())
6455 : : {
6456 : 130264 : Bfunction* builtin_decl =
6457 : 130264 : gogo->backend()->lookup_builtin(this->asm_name_);
6458 : 130264 : if (builtin_decl != NULL)
6459 : : {
6460 : 5835 : this->fndecl_ = builtin_decl;
6461 : 5835 : return this->fndecl_;
6462 : : }
6463 : :
6464 : 124429 : if (this->asm_name_ == "runtime.gopanic"
6465 : 122279 : || this->asm_name_.compare(0, 13, "runtime.panic") == 0
6466 : 117175 : || this->asm_name_.compare(0, 15, "runtime.goPanic") == 0
6467 : 232787 : || this->asm_name_ == "runtime.block")
6468 : : flags |= Backend::function_does_not_return;
6469 : : }
6470 : :
6471 : 277254 : Btype* functype = this->fntype_->get_backend_fntype(gogo);
6472 : :
6473 : 277254 : Backend_name bname;
6474 : 277254 : this->backend_name(gogo, no, &bname);
6475 : :
6476 : 554508 : this->fndecl_ = gogo->backend()->function(functype,
6477 : 554508 : bname.name(),
6478 : 277254 : bname.optional_asm_name(),
6479 : : flags,
6480 : : this->location());
6481 : 277254 : }
6482 : :
6483 : 1519271 : return this->fndecl_;
6484 : : }
6485 : :
6486 : : // Build the descriptor for a function declaration. This won't
6487 : : // necessarily happen if the package has just a declaration for the
6488 : : // function and no other reference to it, but we may still need the
6489 : : // descriptor for references from other packages.
6490 : : void
6491 : 3904 : Function_declaration::build_backend_descriptor(Gogo* gogo)
6492 : : {
6493 : 3904 : if (this->descriptor_ != NULL)
6494 : : {
6495 : 650 : Translate_context context(gogo, NULL, NULL, NULL);
6496 : 650 : this->descriptor_->get_backend(&context);
6497 : : }
6498 : 3904 : }
6499 : :
6500 : : // Check that the types used in this declaration's signature are defined.
6501 : : // Reports errors for any undefined type.
6502 : :
6503 : : void
6504 : 3904 : Function_declaration::check_types() const
6505 : : {
6506 : : // Calling Type::base will give errors for any undefined types.
6507 : 3904 : Function_type* fntype = this->type();
6508 : 3904 : if (fntype->receiver() != NULL)
6509 : 0 : fntype->receiver()->type()->base();
6510 : 3904 : if (fntype->parameters() != NULL)
6511 : : {
6512 : 3035 : const Typed_identifier_list* params = fntype->parameters();
6513 : 9609 : for (Typed_identifier_list::const_iterator p = params->begin();
6514 : 9609 : p != params->end();
6515 : 6574 : ++p)
6516 : 6574 : p->type()->base();
6517 : : }
6518 : 3904 : }
6519 : :
6520 : : // Return the function's decl after it has been built.
6521 : :
6522 : : Bfunction*
6523 : 9319223 : Function::get_decl() const
6524 : : {
6525 : 9319223 : go_assert(this->fndecl_ != NULL);
6526 : 9319223 : return this->fndecl_;
6527 : : }
6528 : :
6529 : : // Build the backend representation for the function code.
6530 : :
6531 : : void
6532 : 295494 : Function::build(Gogo* gogo, Named_object* named_function)
6533 : : {
6534 : 295494 : Translate_context context(gogo, named_function, NULL, NULL);
6535 : :
6536 : : // A list of parameter variables for this function.
6537 : 295494 : std::vector<Bvariable*> param_vars;
6538 : :
6539 : : // Variables that need to be declared for this function and their
6540 : : // initial values.
6541 : 295494 : std::vector<Bvariable*> vars;
6542 : 295494 : std::vector<Expression*> var_inits;
6543 : 295494 : std::vector<Statement*> var_decls_stmts;
6544 : 1216747 : for (Bindings::const_definitions_iterator p =
6545 : 295494 : this->block_->bindings()->begin_definitions();
6546 : 1216747 : p != this->block_->bindings()->end_definitions();
6547 : 921253 : ++p)
6548 : : {
6549 : 921253 : Location loc = (*p)->location();
6550 : 921253 : if ((*p)->is_variable() && (*p)->var_value()->is_parameter())
6551 : : {
6552 : 474166 : Bvariable* bvar = (*p)->get_backend_variable(gogo, named_function);
6553 : 474166 : Bvariable* parm_bvar = bvar;
6554 : :
6555 : : // We always pass the receiver to a method as a pointer. If
6556 : : // the receiver is declared as a non-pointer type, then we
6557 : : // copy the value into a local variable. For direct interface
6558 : : // type we pack the pointer into the type.
6559 : 474166 : if ((*p)->var_value()->is_receiver()
6560 : 474166 : && (*p)->var_value()->type()->points_to() == NULL)
6561 : : {
6562 : 15151 : std::string name = (*p)->name() + ".pointer";
6563 : 15151 : Type* var_type = (*p)->var_value()->type();
6564 : 15151 : Variable* parm_var =
6565 : 15151 : new Variable(Type::make_pointer_type(var_type), NULL, false,
6566 : 30302 : true, false, loc);
6567 : 15151 : Named_object* parm_no =
6568 : 15151 : Named_object::make_variable(name, NULL, parm_var);
6569 : 15151 : parm_bvar = parm_no->get_backend_variable(gogo, named_function);
6570 : :
6571 : 15151 : vars.push_back(bvar);
6572 : :
6573 : 15151 : Expression* parm_ref =
6574 : 15151 : Expression::make_var_reference(parm_no, loc);
6575 : 15151 : Type* recv_type = (*p)->var_value()->type();
6576 : 15151 : if (recv_type->is_direct_iface_type())
6577 : 2016 : parm_ref = Expression::pack_direct_iface(recv_type, parm_ref, loc);
6578 : : else
6579 : 13135 : parm_ref =
6580 : 13135 : Expression::make_dereference(parm_ref,
6581 : : Expression::NIL_CHECK_NEEDED,
6582 : : loc);
6583 : 15151 : if ((*p)->var_value()->is_in_heap())
6584 : 1222 : parm_ref = Expression::make_heap_expression(parm_ref, loc);
6585 : 15151 : var_inits.push_back(parm_ref);
6586 : 15151 : }
6587 : 459015 : else if ((*p)->var_value()->is_in_heap())
6588 : : {
6589 : : // If we take the address of a parameter, then we need
6590 : : // to copy it into the heap.
6591 : 3001 : std::string parm_name = (*p)->name() + ".param";
6592 : 6002 : Variable* parm_var = new Variable((*p)->var_value()->type(), NULL,
6593 : 3001 : false, true, false, loc);
6594 : 3001 : Named_object* parm_no =
6595 : 3001 : Named_object::make_variable(parm_name, NULL, parm_var);
6596 : 3001 : parm_bvar = parm_no->get_backend_variable(gogo, named_function);
6597 : :
6598 : 3001 : vars.push_back(bvar);
6599 : 3001 : Expression* var_ref =
6600 : 3001 : Expression::make_var_reference(parm_no, loc);
6601 : 3001 : var_ref = Expression::make_heap_expression(var_ref, loc);
6602 : 3001 : var_inits.push_back(var_ref);
6603 : 3001 : }
6604 : 474166 : param_vars.push_back(parm_bvar);
6605 : : }
6606 : 447087 : else if ((*p)->is_result_variable())
6607 : : {
6608 : 244740 : Bvariable* bvar = (*p)->get_backend_variable(gogo, named_function);
6609 : :
6610 : 244740 : Type* type = (*p)->result_var_value()->type();
6611 : 244740 : Expression* init;
6612 : 244740 : if (!(*p)->result_var_value()->is_in_heap())
6613 : : {
6614 : 244618 : Btype* btype = type->get_backend(gogo);
6615 : 244618 : Bexpression* binit = gogo->backend()->zero_expression(btype);
6616 : 244618 : init = Expression::make_backend(binit, type, loc);
6617 : : }
6618 : : else
6619 : 122 : init = Expression::make_allocation(type, loc);
6620 : :
6621 : 244740 : vars.push_back(bvar);
6622 : 244740 : var_inits.push_back(init);
6623 : : }
6624 : 202347 : else if (this->defer_stack_ != NULL
6625 : 23528 : && (*p)->is_variable()
6626 : 22838 : && (*p)->var_value()->is_non_escaping_address_taken()
6627 : 947277 : && !(*p)->var_value()->is_in_heap())
6628 : : {
6629 : : // Local variable captured by deferred closure needs to be live
6630 : : // until the end of the function. We create a top-level
6631 : : // declaration for it.
6632 : : // TODO: we don't need to do this if the variable is not captured
6633 : : // by the defer closure. There is no easy way to check it here,
6634 : : // so we do this for all address-taken variables for now.
6635 : 1585 : Variable* var = (*p)->var_value();
6636 : 1585 : Temporary_statement* ts =
6637 : 1585 : Statement::make_temporary(var->type(), NULL, var->location());
6638 : 1585 : ts->set_is_address_taken();
6639 : 1585 : var->set_toplevel_decl(ts);
6640 : 1585 : var_decls_stmts.push_back(ts);
6641 : : }
6642 : : }
6643 : 295494 : if (!gogo->backend()->function_set_parameters(this->fndecl_, param_vars))
6644 : : {
6645 : 14 : go_assert(saw_errors());
6646 : : return;
6647 : : }
6648 : :
6649 : : // If we need a closure variable, make sure to create it.
6650 : : // It gets installed in the function as a side effect of creation.
6651 : 295480 : if (this->closure_var_ != NULL)
6652 : : {
6653 : 14291 : go_assert(this->closure_var_->var_value()->is_closure());
6654 : 14291 : this->closure_var_->get_backend_variable(gogo, named_function);
6655 : : }
6656 : :
6657 : 295480 : if (this->block_ != NULL)
6658 : : {
6659 : : // Declare variables if necessary.
6660 : 295480 : Bblock* var_decls = NULL;
6661 : 295480 : std::vector<Bstatement*> var_decls_bstmt_list;
6662 : 295480 : Bstatement* defer_init = NULL;
6663 : 295480 : if (!vars.empty() || this->defer_stack_ != NULL)
6664 : : {
6665 : 224897 : var_decls =
6666 : 449794 : gogo->backend()->block(this->fndecl_, NULL, vars,
6667 : 224897 : this->block_->start_location(),
6668 : 224897 : this->block_->end_location());
6669 : :
6670 : 224897 : if (this->defer_stack_ != NULL)
6671 : : {
6672 : 8353 : Translate_context dcontext(gogo, named_function, this->block_,
6673 : 8353 : var_decls);
6674 : 8353 : defer_init = this->defer_stack_->get_backend(&dcontext);
6675 : 8353 : var_decls_bstmt_list.push_back(defer_init);
6676 : 9938 : for (std::vector<Statement*>::iterator p = var_decls_stmts.begin();
6677 : 9938 : p != var_decls_stmts.end();
6678 : 1585 : ++p)
6679 : : {
6680 : 1585 : Bstatement* bstmt = (*p)->get_backend(&dcontext);
6681 : 1585 : var_decls_bstmt_list.push_back(bstmt);
6682 : : }
6683 : : }
6684 : : }
6685 : :
6686 : : // Build the backend representation for all the statements in the
6687 : : // function.
6688 : 295480 : Translate_context bcontext(gogo, named_function, NULL, NULL);
6689 : 295480 : Bblock* code_block = this->block_->get_backend(&bcontext);
6690 : :
6691 : : // Initialize variables if necessary.
6692 : 295480 : Translate_context icontext(gogo, named_function, this->block_,
6693 : 295480 : var_decls);
6694 : 295480 : std::vector<Bstatement*> init;
6695 : 295480 : go_assert(vars.size() == var_inits.size());
6696 : 558362 : for (size_t i = 0; i < vars.size(); ++i)
6697 : : {
6698 : 262882 : Bexpression* binit = var_inits[i]->get_backend(&icontext);
6699 : 262882 : Bstatement* init_stmt =
6700 : 262882 : gogo->backend()->init_statement(this->fndecl_, vars[i],
6701 : 262882 : binit);
6702 : 262882 : init.push_back(init_stmt);
6703 : : }
6704 : 295480 : Bstatement* var_init = gogo->backend()->statement_list(init);
6705 : :
6706 : : // Initialize all variables before executing this code block.
6707 : 295480 : Bstatement* code_stmt = gogo->backend()->block_statement(code_block);
6708 : 295480 : code_stmt = gogo->backend()->compound_statement(var_init, code_stmt);
6709 : :
6710 : : // If we have a defer stack, initialize it at the start of a
6711 : : // function.
6712 : 295480 : Bstatement* except = NULL;
6713 : 295480 : Bstatement* fini = NULL;
6714 : 295480 : if (defer_init != NULL)
6715 : : {
6716 : : // Clean up the defer stack when we leave the function.
6717 : 8353 : this->build_defer_wrapper(gogo, named_function, &except, &fini);
6718 : :
6719 : : // Wrap the code for this function in an exception handler to handle
6720 : : // defer calls.
6721 : 8353 : code_stmt =
6722 : 8353 : gogo->backend()->exception_handler_statement(code_stmt,
6723 : : except, fini,
6724 : : this->location_);
6725 : : }
6726 : :
6727 : : // Stick the code into the block we built for the receiver, if
6728 : : // we built one.
6729 : 295480 : if (var_decls != NULL)
6730 : : {
6731 : 224897 : var_decls_bstmt_list.push_back(code_stmt);
6732 : 224897 : gogo->backend()->block_add_statements(var_decls, var_decls_bstmt_list);
6733 : 224897 : code_stmt = gogo->backend()->block_statement(var_decls);
6734 : : }
6735 : :
6736 : 295480 : if (!gogo->backend()->function_set_body(this->fndecl_, code_stmt))
6737 : : {
6738 : 0 : go_assert(saw_errors());
6739 : 0 : return;
6740 : : }
6741 : 295480 : }
6742 : :
6743 : : // If we created a descriptor for the function, make sure we emit it.
6744 : 295480 : if (this->descriptor_ != NULL)
6745 : : {
6746 : 154636 : Translate_context dcontext(gogo, NULL, NULL, NULL);
6747 : 154636 : this->descriptor_->get_backend(&dcontext);
6748 : : }
6749 : 295494 : }
6750 : :
6751 : : // Build the wrappers around function code needed if the function has
6752 : : // any defer statements. This sets *EXCEPT to an exception handler
6753 : : // and *FINI to a finally handler.
6754 : :
6755 : : void
6756 : 8353 : Function::build_defer_wrapper(Gogo* gogo, Named_object* named_function,
6757 : : Bstatement** except, Bstatement** fini)
6758 : : {
6759 : 8353 : Location end_loc = this->block_->end_location();
6760 : :
6761 : : // Add an exception handler. This is used if a panic occurs. Its
6762 : : // purpose is to stop the stack unwinding if a deferred function
6763 : : // calls recover. There are more details in
6764 : : // libgo/runtime/go-unwind.c.
6765 : :
6766 : 8353 : std::vector<Bstatement*> stmts;
6767 : 8353 : Expression* call = Runtime::make_call(gogo, Runtime::CHECKDEFER, end_loc, 1,
6768 : : this->defer_stack(end_loc));
6769 : 8353 : Translate_context context(gogo, named_function, NULL, NULL);
6770 : 8353 : Bexpression* defer = call->get_backend(&context);
6771 : 8353 : stmts.push_back(gogo->backend()->expression_statement(this->fndecl_, defer));
6772 : :
6773 : 8353 : Bstatement* ret_bstmt = this->return_value(gogo, named_function, end_loc);
6774 : 8353 : if (ret_bstmt != NULL)
6775 : 3600 : stmts.push_back(ret_bstmt);
6776 : :
6777 : 8353 : go_assert(*except == NULL);
6778 : 8353 : *except = gogo->backend()->statement_list(stmts);
6779 : :
6780 : 8353 : call = Runtime::make_call(gogo, Runtime::CHECKDEFER, end_loc, 1,
6781 : : this->defer_stack(end_loc));
6782 : 8353 : defer = call->get_backend(&context);
6783 : :
6784 : 8353 : call = Runtime::make_call(gogo, Runtime::DEFERRETURN, end_loc, 1,
6785 : : this->defer_stack(end_loc));
6786 : 8353 : Bexpression* undefer = call->get_backend(&context);
6787 : 8353 : Bstatement* function_defer =
6788 : 8353 : gogo->backend()->function_defer_statement(this->fndecl_, undefer, defer,
6789 : 8353 : end_loc);
6790 : 8353 : stmts = std::vector<Bstatement*>(1, function_defer);
6791 : 8353 : if (this->type_->results() != NULL
6792 : 3600 : && !this->type_->results()->empty()
6793 : 11953 : && !this->type_->results()->front().name().empty())
6794 : : {
6795 : : // If the result variables are named, and we are returning from
6796 : : // this function rather than panicing through it, we need to
6797 : : // return them again, because they might have been changed by a
6798 : : // defer function. The runtime routines set the defer_stack
6799 : : // variable to true if we are returning from this function.
6800 : :
6801 : 1020 : ret_bstmt = this->return_value(gogo, named_function, end_loc);
6802 : 1020 : Bexpression* nil = Expression::make_nil(end_loc)->get_backend(&context);
6803 : 1020 : Bexpression* ret =
6804 : 1020 : gogo->backend()->compound_expression(ret_bstmt, nil, end_loc);
6805 : 1020 : Expression* ref =
6806 : 1020 : Expression::make_temporary_reference(this->defer_stack_, end_loc);
6807 : 1020 : Bexpression* bref = ref->get_backend(&context);
6808 : 1020 : ret = gogo->backend()->conditional_expression(this->fndecl_,
6809 : : NULL, bref, ret, NULL,
6810 : : end_loc);
6811 : 1020 : stmts.push_back(gogo->backend()->expression_statement(this->fndecl_, ret));
6812 : : }
6813 : :
6814 : 8353 : go_assert(*fini == NULL);
6815 : 8353 : *fini = gogo->backend()->statement_list(stmts);
6816 : 8353 : }
6817 : :
6818 : : // Return the statement that assigns values to this function's result struct.
6819 : :
6820 : : Bstatement*
6821 : 9373 : Function::return_value(Gogo* gogo, Named_object* named_function,
6822 : : Location location) const
6823 : : {
6824 : 9373 : const Typed_identifier_list* results = this->type_->results();
6825 : 9373 : if (results == NULL || results->empty())
6826 : : return NULL;
6827 : :
6828 : 4620 : go_assert(this->results_ != NULL);
6829 : 4620 : if (this->results_->size() != results->size())
6830 : : {
6831 : 0 : go_assert(saw_errors());
6832 : 0 : return gogo->backend()->error_statement();
6833 : : }
6834 : :
6835 : 4620 : std::vector<Bexpression*> vals(results->size());
6836 : 11463 : for (size_t i = 0; i < vals.size(); ++i)
6837 : : {
6838 : 6843 : Named_object* no = (*this->results_)[i];
6839 : 6843 : Bvariable* bvar = no->get_backend_variable(gogo, named_function);
6840 : 6843 : Bexpression* val = gogo->backend()->var_expression(bvar, location);
6841 : 6843 : if (no->result_var_value()->is_in_heap())
6842 : : {
6843 : 112 : Btype* bt = no->result_var_value()->type()->get_backend(gogo);
6844 : 112 : val = gogo->backend()->indirect_expression(bt, val, true, location);
6845 : : }
6846 : 6843 : vals[i] = val;
6847 : : }
6848 : 4620 : return gogo->backend()->return_statement(this->fndecl_, vals, location);
6849 : 4620 : }
6850 : :
6851 : : // Class Block.
6852 : :
6853 : 2715775 : Block::Block(Block* enclosing, Location location)
6854 : 2715775 : : enclosing_(enclosing), statements_(),
6855 : 2715775 : bindings_(new Bindings(enclosing == NULL
6856 : : ? NULL
6857 : 2715775 : : enclosing->bindings())),
6858 : 2715775 : start_location_(location),
6859 : 2715775 : end_location_(Linemap::unknown_location())
6860 : : {
6861 : 2715775 : }
6862 : :
6863 : : // Add a statement to a block.
6864 : :
6865 : : void
6866 : 5240279 : Block::add_statement(Statement* statement)
6867 : : {
6868 : 5240279 : this->statements_.push_back(statement);
6869 : 5240279 : }
6870 : :
6871 : : // Add a statement to the front of a block. This is slow but is only
6872 : : // used for reference counts of parameters.
6873 : :
6874 : : void
6875 : 4935 : Block::add_statement_at_front(Statement* statement)
6876 : : {
6877 : 4935 : this->statements_.insert(this->statements_.begin(), statement);
6878 : 4935 : }
6879 : :
6880 : : // Replace a statement in a block.
6881 : :
6882 : : void
6883 : 747805 : Block::replace_statement(size_t index, Statement* s)
6884 : : {
6885 : 747805 : go_assert(index < this->statements_.size());
6886 : 747805 : this->statements_[index] = s;
6887 : 747805 : }
6888 : :
6889 : : // Add a statement before another statement.
6890 : :
6891 : : void
6892 : 1792861 : Block::insert_statement_before(size_t index, Statement* s)
6893 : : {
6894 : 1792861 : go_assert(index < this->statements_.size());
6895 : 1792861 : this->statements_.insert(this->statements_.begin() + index, s);
6896 : 1792861 : }
6897 : :
6898 : : // Add a statement after another statement.
6899 : :
6900 : : void
6901 : 0 : Block::insert_statement_after(size_t index, Statement* s)
6902 : : {
6903 : 0 : go_assert(index < this->statements_.size());
6904 : 0 : this->statements_.insert(this->statements_.begin() + index + 1, s);
6905 : 0 : }
6906 : :
6907 : : // Traverse the tree.
6908 : :
6909 : : int
6910 : 43295454 : Block::traverse(Traverse* traverse)
6911 : : {
6912 : 43295454 : unsigned int traverse_mask = traverse->traverse_mask();
6913 : :
6914 : 43295454 : if ((traverse_mask & Traverse::traverse_blocks) != 0)
6915 : : {
6916 : 8958855 : int t = traverse->block(this);
6917 : 8958855 : if (t == TRAVERSE_EXIT)
6918 : : return TRAVERSE_EXIT;
6919 : 8958855 : else if (t == TRAVERSE_SKIP_COMPONENTS)
6920 : : return TRAVERSE_CONTINUE;
6921 : : }
6922 : :
6923 : 39914953 : if ((traverse_mask
6924 : 39914953 : & (Traverse::traverse_variables
6925 : : | Traverse::traverse_constants
6926 : : | Traverse::traverse_expressions
6927 : : | Traverse::traverse_types)) != 0)
6928 : : {
6929 : 22170262 : for (Bindings::const_definitions_iterator pb =
6930 : 34999445 : this->bindings_->begin_definitions();
6931 : 57169707 : pb != this->bindings_->end_definitions();
6932 : 22170262 : ++pb)
6933 : : {
6934 : 22770074 : if ((*pb)->traverse(traverse, false) == TRAVERSE_EXIT)
6935 : 3016289 : return TRAVERSE_EXIT;
6936 : : }
6937 : : }
6938 : :
6939 : : // No point in checking traverse_mask here--if we got here we always
6940 : : // want to walk the statements. The traversal can insert new
6941 : : // statements before or after the current statement. Inserting
6942 : : // statements before the current statement requires updating I via
6943 : : // the pointer; those statements will not be traversed. Any new
6944 : : // statements inserted after the current statement will be traversed
6945 : : // in their turn.
6946 : 130621692 : for (size_t i = 0; i < this->statements_.size(); ++i)
6947 : : {
6948 : 93723028 : if (this->statements_[i]->traverse(this, &i, traverse) == TRAVERSE_EXIT)
6949 : 2416477 : return TRAVERSE_EXIT;
6950 : : }
6951 : :
6952 : 36898664 : return TRAVERSE_CONTINUE;
6953 : : }
6954 : :
6955 : : // Work out types for unspecified variables and constants.
6956 : :
6957 : : void
6958 : 2102767 : Block::determine_types(Gogo* gogo)
6959 : : {
6960 : 842541 : for (Bindings::const_definitions_iterator pb =
6961 : 2102767 : this->bindings_->begin_definitions();
6962 : 2945308 : pb != this->bindings_->end_definitions();
6963 : 842541 : ++pb)
6964 : : {
6965 : 842541 : if ((*pb)->is_variable())
6966 : 692848 : (*pb)->var_value()->determine_type(gogo);
6967 : 149693 : else if ((*pb)->is_const())
6968 : 5531 : (*pb)->const_value()->determine_type(gogo);
6969 : : }
6970 : :
6971 : 5569777 : for (std::vector<Statement*>::const_iterator ps = this->statements_.begin();
6972 : 5569777 : ps != this->statements_.end();
6973 : 3467010 : ++ps)
6974 : 3467010 : (*ps)->determine_types(gogo);
6975 : 2102767 : }
6976 : :
6977 : : // Return true if the statements in this block may fall through.
6978 : :
6979 : : bool
6980 : 113775 : Block::may_fall_through() const
6981 : : {
6982 : 113775 : if (this->statements_.empty())
6983 : : return true;
6984 : 113732 : return this->statements_.back()->may_fall_through();
6985 : : }
6986 : :
6987 : : // Write export data for a block.
6988 : :
6989 : : void
6990 : 44123 : Block::export_block(Export_function_body* efb)
6991 : : {
6992 : 122751 : for (Block::iterator p = this->begin();
6993 : 122751 : p != this->end();
6994 : 78628 : ++p)
6995 : : {
6996 : 78628 : efb->indent();
6997 : :
6998 : 78628 : efb->increment_indent();
6999 : 78628 : (*p)->export_statement(efb);
7000 : 78628 : efb->decrement_indent();
7001 : :
7002 : 78628 : Location loc = (*p)->location();
7003 : 78628 : if ((*p)->is_block_statement())
7004 : : {
7005 : : // For a block we put the start location on the first brace
7006 : : // in Block_statement::do_export_statement. Here we put the
7007 : : // end location on the final brace.
7008 : 22817 : loc = (*p)->block_statement()->block()->end_location();
7009 : : }
7010 : 78628 : char buf[50];
7011 : 78628 : snprintf(buf, sizeof buf, " //%d\n", Linemap::location_to_line(loc));
7012 : 78628 : efb->write_c_string(buf);
7013 : : }
7014 : 44123 : }
7015 : :
7016 : : // Add exported block data to SET, reading from BODY starting at OFF.
7017 : : // Returns whether the import succeeded.
7018 : :
7019 : : bool
7020 : 38869 : Block::import_block(Block* set, Import_function_body *ifb, Location loc)
7021 : : {
7022 : 38869 : Location eloc = ifb->location();
7023 : 38869 : Location sloc = loc;
7024 : 38869 : const std::string& body(ifb->body());
7025 : 38869 : size_t off = ifb->off();
7026 : 108195 : while (off < body.length())
7027 : : {
7028 : 95948 : int indent = ifb->indent();
7029 : 95948 : if (off + indent >= body.length())
7030 : : {
7031 : 0 : go_error_at(eloc,
7032 : : "invalid export data for %qs: insufficient indentation",
7033 : 0 : ifb->name().c_str());
7034 : 0 : return false;
7035 : : }
7036 : 245244 : for (int i = 0; i < indent - 1; i++)
7037 : : {
7038 : 149296 : if (body[off + i] != ' ')
7039 : : {
7040 : 0 : go_error_at(eloc,
7041 : : "invalid export data for %qs: bad indentation",
7042 : 0 : ifb->name().c_str());
7043 : 0 : return false;
7044 : : }
7045 : : }
7046 : :
7047 : 95948 : bool at_end = false;
7048 : 95948 : if (body[off + indent - 1] == '}')
7049 : : at_end = true;
7050 : 69326 : else if (body[off + indent - 1] != ' ')
7051 : : {
7052 : 0 : go_error_at(eloc,
7053 : : "invalid export data for %qs: bad indentation",
7054 : 0 : ifb->name().c_str());
7055 : 0 : return false;
7056 : : }
7057 : :
7058 : 95948 : off += indent;
7059 : :
7060 : 95948 : size_t nl = body.find('\n', off);
7061 : 95948 : if (nl == std::string::npos)
7062 : : {
7063 : 0 : go_error_at(eloc, "invalid export data for %qs: missing newline",
7064 : 0 : ifb->name().c_str());
7065 : 0 : return false;
7066 : : }
7067 : :
7068 : 95948 : size_t lineno_pos = body.find(" //", off);
7069 : 95948 : if (lineno_pos == std::string::npos || lineno_pos >= nl)
7070 : : {
7071 : 0 : go_error_at(eloc, "invalid export data for %qs: missing line number",
7072 : 0 : ifb->name().c_str());
7073 : 0 : return false;
7074 : : }
7075 : :
7076 : 95948 : unsigned int lineno = 0;
7077 : 333045 : for (size_t i = lineno_pos + 3; i < nl; ++i)
7078 : : {
7079 : 237097 : char c = body[i];
7080 : 237097 : if (c < '0' || c > '9')
7081 : : {
7082 : 0 : go_error_at(loc,
7083 : : "invalid export data for %qs: invalid line number",
7084 : 0 : ifb->name().c_str());
7085 : 0 : return false;
7086 : : }
7087 : 237097 : lineno = lineno * 10 + c - '0';
7088 : : }
7089 : :
7090 : 95948 : ifb->gogo()->linemap()->start_line(lineno, 1);
7091 : 95948 : sloc = ifb->gogo()->linemap()->get_location(0);
7092 : :
7093 : 95948 : if (at_end)
7094 : : {
7095 : : // An if statement can have an "else" following the "}", in
7096 : : // which case we want to leave the offset where it is, just
7097 : : // after the "}". We don't get the block ending location
7098 : : // quite right for if statements.
7099 : 26622 : if (body.compare(off, 6, " else ") != 0)
7100 : 26486 : off = nl + 1;
7101 : : break;
7102 : : }
7103 : :
7104 : 69326 : ifb->set_off(off);
7105 : 69326 : Statement* s = Statement::import_statement(ifb, sloc);
7106 : 69326 : if (s == NULL)
7107 : : return false;
7108 : :
7109 : 69326 : set->add_statement(s);
7110 : :
7111 : 69326 : size_t at = ifb->off();
7112 : 69326 : if (at < nl + 1)
7113 : : off = nl + 1;
7114 : : else
7115 : : off = at;
7116 : : }
7117 : :
7118 : 38869 : ifb->set_off(off);
7119 : 38869 : set->set_end_location(sloc);
7120 : 38869 : return true;
7121 : : }
7122 : :
7123 : : // Convert a block to the backend representation.
7124 : :
7125 : : Bblock*
7126 : 2631804 : Block::get_backend(Translate_context* context)
7127 : : {
7128 : 2631804 : Gogo* gogo = context->gogo();
7129 : 2631804 : Named_object* function = context->function();
7130 : 2631804 : std::vector<Bvariable*> vars;
7131 : 2631804 : vars.reserve(this->bindings_->size_definitions());
7132 : 1108071 : for (Bindings::const_definitions_iterator pv =
7133 : 2631804 : this->bindings_->begin_definitions();
7134 : 3739875 : pv != this->bindings_->end_definitions();
7135 : 1108071 : ++pv)
7136 : : {
7137 : 1108071 : if ((*pv)->is_variable() && !(*pv)->var_value()->is_parameter())
7138 : 382504 : vars.push_back((*pv)->get_backend_variable(gogo, function));
7139 : : }
7140 : :
7141 : 2631804 : go_assert(function != NULL);
7142 : 2631804 : Bfunction* bfunction =
7143 : 2631804 : function->func_value()->get_or_make_decl(gogo, function);
7144 : 2631804 : Bblock* ret = context->backend()->block(bfunction, context->bblock(),
7145 : : vars, this->start_location_,
7146 : : this->end_location_);
7147 : :
7148 : 2631804 : Translate_context subcontext(gogo, function, this, ret);
7149 : 2631804 : std::vector<Bstatement*> bstatements;
7150 : 2631804 : bstatements.reserve(this->statements_.size());
7151 : 2631804 : for (std::vector<Statement*>::const_iterator p = this->statements_.begin();
7152 : 9648688 : p != this->statements_.end();
7153 : 7016884 : ++p)
7154 : 7016884 : bstatements.push_back((*p)->get_backend(&subcontext));
7155 : :
7156 : 2631804 : context->backend()->block_add_statements(ret, bstatements);
7157 : :
7158 : 2631804 : return ret;
7159 : 2631804 : }
7160 : :
7161 : : // Class Bindings_snapshot.
7162 : :
7163 : 12092 : Bindings_snapshot::Bindings_snapshot(const Block* b, Location location)
7164 : 12092 : : block_(b), counts_(), location_(location)
7165 : : {
7166 : 40730 : while (b != NULL)
7167 : : {
7168 : 28638 : this->counts_.push_back(b->bindings()->size_definitions());
7169 : 28638 : b = b->enclosing();
7170 : : }
7171 : 12092 : }
7172 : :
7173 : : // Report errors appropriate for a goto from B to this.
7174 : :
7175 : : void
7176 : 533 : Bindings_snapshot::check_goto_from(const Block* b, Location loc)
7177 : : {
7178 : 533 : size_t dummy;
7179 : 533 : if (!this->check_goto_block(loc, b, this->block_, &dummy))
7180 : 12 : return;
7181 : 521 : this->check_goto_defs(loc, this->block_,
7182 : 521 : this->block_->bindings()->size_definitions(),
7183 : 521 : this->counts_[0]);
7184 : : }
7185 : :
7186 : : // Report errors appropriate for a goto from this to B.
7187 : :
7188 : : void
7189 : 1565 : Bindings_snapshot::check_goto_to(const Block* b)
7190 : : {
7191 : 1565 : size_t index;
7192 : 1565 : if (!this->check_goto_block(this->location_, this->block_, b, &index))
7193 : 19 : return;
7194 : 1546 : this->check_goto_defs(this->location_, b, this->counts_[index],
7195 : : b->bindings()->size_definitions());
7196 : : }
7197 : :
7198 : : // Report errors appropriate for a goto at LOC from BFROM to BTO.
7199 : : // Return true if all is well, false if we reported an error. If this
7200 : : // returns true, it sets *PINDEX to the number of blocks BTO is above
7201 : : // BFROM.
7202 : :
7203 : : bool
7204 : 2098 : Bindings_snapshot::check_goto_block(Location loc, const Block* bfrom,
7205 : : const Block* bto, size_t* pindex)
7206 : : {
7207 : : // It is an error if BTO is not either BFROM or above BFROM.
7208 : 2098 : size_t index = 0;
7209 : 9845 : for (const Block* pb = bfrom; pb != bto; pb = pb->enclosing(), ++index)
7210 : : {
7211 : 7778 : if (pb == NULL)
7212 : : {
7213 : 31 : go_error_at(loc, "goto jumps into block");
7214 : 31 : go_inform(bto->start_location(), "goto target block starts here");
7215 : 31 : return false;
7216 : : }
7217 : : }
7218 : 2067 : *pindex = index;
7219 : 2067 : return true;
7220 : : }
7221 : :
7222 : : // Report errors appropriate for a goto at LOC ending at BLOCK, where
7223 : : // CFROM is the number of names defined at the point of the goto and
7224 : : // CTO is the number of names defined at the point of the label.
7225 : :
7226 : : void
7227 : 2067 : Bindings_snapshot::check_goto_defs(Location loc, const Block* block,
7228 : : size_t cfrom, size_t cto)
7229 : : {
7230 : 2067 : if (cfrom < cto)
7231 : : {
7232 : 14 : Bindings::const_definitions_iterator p =
7233 : 14 : block->bindings()->begin_definitions();
7234 : 31 : for (size_t i = 0; i < cfrom; ++i)
7235 : : {
7236 : 17 : go_assert(p != block->bindings()->end_definitions());
7237 : 17 : ++p;
7238 : : }
7239 : 14 : go_assert(p != block->bindings()->end_definitions());
7240 : :
7241 : 34 : for (; p != block->bindings()->end_definitions(); ++p)
7242 : : {
7243 : 20 : if ((*p)->is_variable())
7244 : : {
7245 : 6 : std::string n = (*p)->message_name();
7246 : 6 : go_error_at(loc, "goto jumps over declaration of %qs", n.c_str());
7247 : 6 : go_inform((*p)->location(), "%qs defined here", n.c_str());
7248 : 6 : }
7249 : : }
7250 : : }
7251 : 2067 : }
7252 : :
7253 : : // Class Function_declaration.
7254 : :
7255 : : // Whether this declares a method.
7256 : :
7257 : : bool
7258 : 2119468 : Function_declaration::is_method() const
7259 : : {
7260 : 2119468 : return this->fntype_->is_method();
7261 : : }
7262 : :
7263 : : // Whether this method should not be included in the type descriptor.
7264 : :
7265 : : bool
7266 : 1330920 : Function_declaration::nointerface() const
7267 : : {
7268 : 1330920 : go_assert(this->is_method());
7269 : 1330920 : return (this->pragmas_ & GOPRAGMA_NOINTERFACE) != 0;
7270 : : }
7271 : :
7272 : : // Record that this method should not be included in the type
7273 : : // descriptor.
7274 : :
7275 : : void
7276 : 2 : Function_declaration::set_nointerface()
7277 : : {
7278 : 2 : this->pragmas_ |= GOPRAGMA_NOINTERFACE;
7279 : 2 : }
7280 : :
7281 : : // Set the receiver type. This is used to remove aliases.
7282 : :
7283 : : void
7284 : 0 : Function_declaration::set_receiver_type(Type* rtype)
7285 : : {
7286 : 0 : Function_type* oft = this->fntype_;
7287 : 0 : Typed_identifier* rec = new Typed_identifier(oft->receiver()->name(),
7288 : : rtype,
7289 : 0 : oft->receiver()->location());
7290 : 0 : Typed_identifier_list* parameters = NULL;
7291 : 0 : if (oft->parameters() != NULL)
7292 : 0 : parameters = oft->parameters()->copy();
7293 : 0 : Typed_identifier_list* results = NULL;
7294 : 0 : if (oft->results() != NULL)
7295 : 0 : results = oft->results()->copy();
7296 : 0 : Function_type* nft = Type::make_function_type(rec, parameters, results,
7297 : : oft->location());
7298 : 0 : this->fntype_ = nft;
7299 : 0 : }
7300 : :
7301 : : // Import an inlinable function. This is used for an inlinable
7302 : : // function whose body is recorded in the export data. Parse the
7303 : : // export data into a Block and create a regular function using that
7304 : : // Block as its body. Redeclare this function declaration as the
7305 : : // function.
7306 : :
7307 : : void
7308 : 12247 : Function_declaration::import_function_body(Gogo* gogo, Named_object* no)
7309 : : {
7310 : 12247 : go_assert(no->func_declaration_value() == this);
7311 : 12247 : go_assert(no->package() != NULL);
7312 : 12247 : const std::string& body(this->imported_body_);
7313 : 12247 : go_assert(!body.empty());
7314 : :
7315 : : // Read the "//FILE:LINE" comment starts the export data.
7316 : :
7317 : 12247 : size_t indent = 1;
7318 : 12247 : if (this->is_method())
7319 : 593 : indent = 2;
7320 : 12247 : size_t i = 0;
7321 : 25087 : for (; i < indent; i++)
7322 : : {
7323 : 12840 : if (body.at(i) != ' ')
7324 : : {
7325 : 0 : go_error_at(this->location_,
7326 : : "invalid export body for %qs: bad initial indentation",
7327 : 0 : no->message_name().c_str());
7328 : 0 : return;
7329 : : }
7330 : : }
7331 : :
7332 : 12247 : if (body.substr(i, 2) != "//")
7333 : : {
7334 : 0 : go_error_at(this->location_,
7335 : : "invalid export body for %qs: missing file comment",
7336 : 0 : no->message_name().c_str());
7337 : 0 : return;
7338 : : }
7339 : :
7340 : 12247 : size_t colon = body.find(':', i + 2);
7341 : 12247 : size_t nl = body.find('\n', i + 2);
7342 : 12247 : if (nl == std::string::npos)
7343 : : {
7344 : 0 : go_error_at(this->location_,
7345 : : "invalid export body for %qs: missing file name",
7346 : 0 : no->message_name().c_str());
7347 : 0 : return;
7348 : : }
7349 : 12247 : if (colon == std::string::npos || nl < colon)
7350 : : {
7351 : 0 : go_error_at(this->location_,
7352 : : "invalid export body for %qs: missing initial line number",
7353 : 0 : no->message_name().c_str());
7354 : 0 : return;
7355 : : }
7356 : :
7357 : 12247 : std::string file = body.substr(i + 2, colon - (i + 2));
7358 : 12247 : std::string linestr = body.substr(colon + 1, nl - (colon + 1));
7359 : 12247 : char* end;
7360 : 12247 : long linenol = strtol(linestr.c_str(), &end, 10);
7361 : 12247 : if (*end != '\0')
7362 : : {
7363 : 0 : go_error_at(this->location_,
7364 : : "invalid export body for %qs: invalid initial line number",
7365 : 0 : no->message_name().c_str());
7366 : 0 : return;
7367 : : }
7368 : 12247 : unsigned int lineno = static_cast<unsigned int>(linenol);
7369 : :
7370 : : // Turn the file/line into a location.
7371 : :
7372 : 12247 : char* alc = new char[file.length() + 1];
7373 : 12247 : memcpy(alc, file.data(), file.length());
7374 : 12247 : alc[file.length()] = '\0';
7375 : 12247 : gogo->linemap()->start_file(alc, lineno);
7376 : 12247 : gogo->linemap()->start_line(lineno, 1);
7377 : 12247 : Location start_loc = gogo->linemap()->get_location(0);
7378 : :
7379 : : // Define the function with an outer block that declares the
7380 : : // parameters.
7381 : :
7382 : 12247 : Function_type* fntype = this->fntype_;
7383 : :
7384 : 12247 : Block* outer = new Block(NULL, start_loc);
7385 : :
7386 : 12247 : Function* fn = new Function(fntype, NULL, outer, start_loc);
7387 : 12247 : fn->set_is_inline_only();
7388 : :
7389 : 12247 : if (fntype->is_method())
7390 : : {
7391 : 593 : if (this->nointerface())
7392 : 1 : fn->set_nointerface();
7393 : 593 : const Typed_identifier* receiver = fntype->receiver();
7394 : 593 : Variable* recv_param = new Variable(receiver->type(), NULL, false,
7395 : 593 : true, true, start_loc);
7396 : :
7397 : 593 : std::string rname = receiver->name();
7398 : 593 : unsigned rcounter = 0;
7399 : :
7400 : : // We need to give a nameless receiver a name to avoid having it
7401 : : // clash with some other nameless param. FIXME.
7402 : 593 : Gogo::rename_if_empty(&rname, "r", &rcounter);
7403 : :
7404 : 593 : outer->bindings()->add_variable(rname, NULL, recv_param);
7405 : 593 : }
7406 : :
7407 : 12247 : const Typed_identifier_list* params = fntype->parameters();
7408 : 12247 : bool is_varargs = fntype->is_varargs();
7409 : 12247 : unsigned pcounter = 0;
7410 : 12247 : if (params != NULL)
7411 : : {
7412 : 10560 : for (Typed_identifier_list::const_iterator p = params->begin();
7413 : 27541 : p != params->end();
7414 : 16981 : ++p)
7415 : : {
7416 : 16981 : Variable* param = new Variable(p->type(), NULL, false, true, false,
7417 : 16981 : start_loc);
7418 : 16981 : if (is_varargs && p + 1 == params->end())
7419 : 581 : param->set_is_varargs_parameter();
7420 : :
7421 : 16981 : std::string pname = p->name();
7422 : :
7423 : : // We need to give each nameless parameter a non-empty name to avoid
7424 : : // having it clash with some other nameless param. FIXME.
7425 : 16981 : Gogo::rename_if_empty(&pname, "p", &pcounter);
7426 : :
7427 : 16981 : outer->bindings()->add_variable(pname, NULL, param);
7428 : 16981 : }
7429 : : }
7430 : :
7431 : 12247 : fn->create_result_variables(gogo);
7432 : :
7433 : 12247 : if (!fntype->is_method())
7434 : : {
7435 : 11654 : const Package* package = no->package();
7436 : 11654 : no = package->bindings()->add_function(no->name(), package, fn);
7437 : : }
7438 : : else
7439 : : {
7440 : 1186 : Named_type* rtype = fntype->receiver()->type()->deref()->named_type();
7441 : 593 : go_assert(rtype != NULL);
7442 : 593 : no = rtype->add_method(no->name(), fn);
7443 : 593 : const Package* package = rtype->named_object()->package();
7444 : 593 : package->bindings()->add_method(no);
7445 : : }
7446 : :
7447 : 12247 : Import_function_body ifb(gogo, this->imp_, no, body, nl + 1, outer, indent);
7448 : :
7449 : 12247 : if (!Block::import_block(outer, &ifb, start_loc))
7450 : 0 : return;
7451 : :
7452 : 12247 : outer->determine_types(gogo);
7453 : 12247 : gogo->lower_block(no, outer);
7454 : :
7455 : 12247 : gogo->add_imported_inline_function(no);
7456 : 12247 : }
7457 : :
7458 : : // Return the function descriptor.
7459 : :
7460 : : Expression*
7461 : 120120 : Function_declaration::descriptor(Gogo*, Named_object* no)
7462 : : {
7463 : 120120 : go_assert(!this->fntype_->is_method());
7464 : 120120 : if (this->descriptor_ == NULL)
7465 : 105144 : this->descriptor_ = Expression::make_func_descriptor(no);
7466 : 120120 : return this->descriptor_;
7467 : : }
7468 : :
7469 : : // Class Variable.
7470 : :
7471 : 1743043 : Variable::Variable(Type* type, Expression* init, bool is_global,
7472 : : bool is_parameter, bool is_receiver,
7473 : 1743043 : Location location)
7474 : 1743043 : : type_(type), init_(init), preinit_(NULL), location_(location),
7475 : 1743043 : toplevel_decl_(NULL), init_refs_(NULL), embeds_(NULL), backend_(NULL),
7476 : 1743043 : is_global_(is_global), is_parameter_(is_parameter), is_closure_(false),
7477 : 1743043 : is_receiver_(is_receiver), is_varargs_parameter_(false),
7478 : 1743043 : is_global_sink_(false), is_used_(false), is_address_taken_(false),
7479 : 1743043 : is_non_escaping_address_taken_(false), seen_(false),
7480 : 1743043 : init_is_lowered_(false), init_is_flattened_(false),
7481 : 1743043 : type_from_init_tuple_(false), type_from_range_index_(false),
7482 : 1743043 : type_from_range_value_(false), type_from_chan_element_(false),
7483 : 1743043 : is_type_switch_var_(false), determined_type_(false),
7484 : 1743043 : in_unique_section_(false), is_referenced_by_inline_(false)
7485 : : {
7486 : 1743043 : go_assert(type != NULL || init != NULL);
7487 : 1743043 : go_assert(!is_parameter || init == NULL);
7488 : 1743043 : }
7489 : :
7490 : : // Traverse the initializer expression.
7491 : :
7492 : : int
7493 : 21645010 : Variable::traverse_expression(Traverse* traverse, unsigned int traverse_mask)
7494 : : {
7495 : 21645010 : if (this->preinit_ != NULL)
7496 : : {
7497 : 36173 : if (this->preinit_->traverse(traverse) == TRAVERSE_EXIT)
7498 : : return TRAVERSE_EXIT;
7499 : : }
7500 : 21645010 : if (this->init_ != NULL
7501 : 5848926 : && ((traverse_mask
7502 : 5848926 : & (Traverse::traverse_expressions | Traverse::traverse_types))
7503 : : != 0))
7504 : : {
7505 : 4978871 : if (Expression::traverse(&this->init_, traverse) == TRAVERSE_EXIT)
7506 : : return TRAVERSE_EXIT;
7507 : : }
7508 : : return TRAVERSE_CONTINUE;
7509 : : }
7510 : :
7511 : : // Lower the initialization expression after parsing is complete.
7512 : :
7513 : : void
7514 : 6555653 : Variable::lower_init_expression(Gogo* gogo, Named_object* function,
7515 : : Statement_inserter* inserter)
7516 : : {
7517 : 6555653 : Named_object* dep = gogo->var_depends_on(this);
7518 : 6555653 : if (dep != NULL && dep->is_variable())
7519 : 194 : dep->var_value()->lower_init_expression(gogo, function, inserter);
7520 : :
7521 : 6555653 : if (this->embeds_ != NULL)
7522 : : {
7523 : : // Now that we have seen any possible type aliases, convert the
7524 : : // go:embed directives into an initializer.
7525 : 22 : go_assert(this->init_ == NULL && this->type_ != NULL);
7526 : 22 : this->init_ = gogo->initializer_for_embeds(this->type_, this->embeds_,
7527 : : this->location_);
7528 : 22 : delete this->embeds_;
7529 : 22 : this->embeds_ = NULL;
7530 : : }
7531 : :
7532 : 6555653 : if (this->init_ != NULL && !this->init_is_lowered_)
7533 : : {
7534 : 302033 : if (this->seen_)
7535 : : {
7536 : : // We will give an error elsewhere, this is just to prevent
7537 : : // an infinite loop.
7538 : 0 : return;
7539 : : }
7540 : 302033 : this->seen_ = true;
7541 : :
7542 : 302033 : Statement_inserter global_inserter;
7543 : 302033 : if (this->is_global_)
7544 : : {
7545 : 20356 : global_inserter = Statement_inserter(gogo, this);
7546 : 20356 : inserter = &global_inserter;
7547 : : }
7548 : :
7549 : 302033 : gogo->lower_expression(function, inserter, &this->init_);
7550 : :
7551 : 302033 : this->seen_ = false;
7552 : :
7553 : 302033 : this->init_is_lowered_ = true;
7554 : : }
7555 : : }
7556 : :
7557 : : // Flatten the initialization expression after ordering evaluations.
7558 : :
7559 : : void
7560 : 751215 : Variable::flatten_init_expression(Gogo* gogo, Named_object* function,
7561 : : Statement_inserter* inserter)
7562 : : {
7563 : 751215 : Named_object* dep = gogo->var_depends_on(this);
7564 : 751215 : if (dep != NULL && dep->is_variable())
7565 : 99 : dep->var_value()->flatten_init_expression(gogo, function, inserter);
7566 : :
7567 : 751215 : if (this->init_ != NULL && !this->init_is_flattened_)
7568 : : {
7569 : 282858 : if (this->seen_)
7570 : : {
7571 : : // We will give an error elsewhere, this is just to prevent
7572 : : // an infinite loop.
7573 : 0 : return;
7574 : : }
7575 : 282858 : this->seen_ = true;
7576 : :
7577 : 282858 : Statement_inserter global_inserter;
7578 : 282858 : if (this->is_global_)
7579 : : {
7580 : 8364 : global_inserter = Statement_inserter(gogo, this);
7581 : 8364 : inserter = &global_inserter;
7582 : : }
7583 : :
7584 : 282858 : gogo->flatten_expression(function, inserter, &this->init_);
7585 : :
7586 : : // If an interface conversion is needed, we need a temporary
7587 : : // variable.
7588 : 282858 : if (this->type_ != NULL
7589 : 282858 : && !Type::are_identical(this->type_, this->init_->type(),
7590 : : Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
7591 : : NULL)
7592 : 898 : && this->init_->type()->interface_type() != NULL
7593 : 282859 : && !this->init_->is_multi_eval_safe())
7594 : : {
7595 : 0 : Temporary_statement* temp =
7596 : 0 : Statement::make_temporary(NULL, this->init_, this->location_);
7597 : 0 : inserter->insert(temp);
7598 : 0 : this->init_ = Expression::make_temporary_reference(temp,
7599 : : this->location_);
7600 : : }
7601 : :
7602 : 282858 : this->seen_ = false;
7603 : 282858 : this->init_is_flattened_ = true;
7604 : : }
7605 : : }
7606 : :
7607 : : // Get the preinit block.
7608 : :
7609 : : Block*
7610 : 52980 : Variable::preinit_block(Gogo* gogo)
7611 : : {
7612 : 52980 : go_assert(this->is_global_);
7613 : 52980 : if (this->preinit_ == NULL)
7614 : 12208 : this->preinit_ = new Block(NULL, this->location());
7615 : :
7616 : : // If a global variable has a preinitialization statement, then we
7617 : : // need to have an initialization function.
7618 : 52980 : gogo->set_need_init_fn();
7619 : :
7620 : 52980 : return this->preinit_;
7621 : : }
7622 : :
7623 : : // Add a statement to be run before the initialization expression.
7624 : :
7625 : : void
7626 : 52980 : Variable::add_preinit_statement(Gogo* gogo, Statement* s)
7627 : : {
7628 : 52980 : Block* b = this->preinit_block(gogo);
7629 : 52980 : b->add_statement(s);
7630 : 52980 : b->set_end_location(s->location());
7631 : 52980 : }
7632 : :
7633 : : // Whether this variable has a type.
7634 : :
7635 : : bool
7636 : 19294975 : Variable::has_type() const
7637 : : {
7638 : 19294975 : if (this->type_ == NULL)
7639 : : return false;
7640 : :
7641 : : // A variable created in a type switch case nil does not actually
7642 : : // have a type yet. It will be changed to use the initializer's
7643 : : // type in determine_type.
7644 : 18653027 : if (this->is_type_switch_var_
7645 : 18653027 : && this->type_->is_nil_constant_as_type())
7646 : : return false;
7647 : :
7648 : : return true;
7649 : : }
7650 : :
7651 : : // In an assignment which sets a variable to a tuple of EXPR, return
7652 : : // the type of the first element of the tuple.
7653 : :
7654 : : Type*
7655 : 1594 : Variable::type_from_tuple(Expression* expr, bool report_error) const
7656 : : {
7657 : 1594 : if (Index_expression::is_map_index(expr))
7658 : : {
7659 : 1553 : Map_type* mt;
7660 : 1553 : if (expr->map_index_expression() != NULL)
7661 : 0 : mt = expr->map_index_expression()->get_map_type();
7662 : : else
7663 : 1553 : mt = expr->index_expression()->left()->type()->map_type();
7664 : 0 : if (mt == NULL)
7665 : 0 : return Type::make_error_type();
7666 : 1553 : return mt->val_type();
7667 : : }
7668 : 41 : else if (expr->receive_expression() != NULL)
7669 : : {
7670 : 41 : Expression* channel = expr->receive_expression()->channel();
7671 : 41 : Type* channel_type = channel->type();
7672 : 41 : if (channel_type->channel_type() == NULL)
7673 : 0 : return Type::make_error_type();
7674 : 82 : return channel_type->channel_type()->element_type();
7675 : : }
7676 : : else
7677 : : {
7678 : 0 : if (report_error)
7679 : 0 : go_error_at(this->location(), "invalid tuple definition");
7680 : 0 : return Type::make_error_type();
7681 : : }
7682 : : }
7683 : :
7684 : : // Given EXPR used in a range clause, return either the index type or
7685 : : // the value type of the range, depending upon GET_INDEX_TYPE.
7686 : :
7687 : : Type*
7688 : 31409 : Variable::type_from_range(Expression* expr, bool get_index_type,
7689 : : bool report_error) const
7690 : : {
7691 : 31409 : Type* t = expr->type();
7692 : 31409 : if (t->is_error_type())
7693 : : return t;
7694 : 31409 : else if (t->array_type() != NULL
7695 : 4113 : || (t->points_to() != NULL
7696 : 222 : && t->points_to()->array_type() != NULL
7697 : 222 : && !t->points_to()->is_slice_type()))
7698 : : {
7699 : 27518 : if (get_index_type)
7700 : 7286 : return Type::lookup_integer_type("int");
7701 : : else
7702 : 60696 : return t->deref()->array_type()->element_type();
7703 : : }
7704 : 3891 : else if (t->is_string_type())
7705 : : {
7706 : 732 : if (get_index_type)
7707 : 190 : return Type::lookup_integer_type("int");
7708 : : else
7709 : 542 : return Type::lookup_integer_type("int32");
7710 : : }
7711 : 3159 : else if (t->map_type() != NULL)
7712 : : {
7713 : 3084 : if (get_index_type)
7714 : 3378 : return t->map_type()->key_type();
7715 : : else
7716 : 2790 : return t->map_type()->val_type();
7717 : : }
7718 : 75 : else if (t->channel_type() != NULL)
7719 : : {
7720 : 75 : if (get_index_type)
7721 : 150 : return t->channel_type()->element_type();
7722 : : else
7723 : : {
7724 : 0 : if (report_error)
7725 : 0 : go_error_at(this->location(),
7726 : : ("invalid definition of value variable "
7727 : : "for channel range"));
7728 : 0 : return Type::make_error_type();
7729 : : }
7730 : : }
7731 : : else
7732 : : {
7733 : 0 : if (report_error)
7734 : 0 : go_error_at(this->location(), "invalid type for range clause");
7735 : 0 : return Type::make_error_type();
7736 : : }
7737 : : }
7738 : :
7739 : : // EXPR should be a channel. Return the channel's element type.
7740 : :
7741 : : Type*
7742 : 524 : Variable::type_from_chan_element(Expression* expr, bool report_error) const
7743 : : {
7744 : 524 : Type* t = expr->type();
7745 : 524 : if (t->channel_type() != NULL)
7746 : 1048 : return t->channel_type()->element_type();
7747 : : else
7748 : : {
7749 : 0 : if (report_error)
7750 : 0 : go_error_at(this->location(), "expected channel");
7751 : 0 : return Type::make_error_type();
7752 : : }
7753 : : }
7754 : :
7755 : : // Return the type of the Variable. This may be called before
7756 : : // Variable::determine_type is called, which means that we may need to
7757 : : // get the type from the initializer. FIXME: If we combine lowering
7758 : : // with type determination, then this should be unnecessary.
7759 : :
7760 : : Type*
7761 : 71411452 : Variable::type()
7762 : : {
7763 : : // A variable in a type switch with a nil case will have the wrong
7764 : : // type here. This gets fixed up in determine_type, below.
7765 : 71411452 : Type* type = this->type_;
7766 : 71411452 : Expression* init = this->init_;
7767 : 71411452 : if (this->is_type_switch_var_
7768 : 1010045 : && type != NULL
7769 : 72421497 : && this->type_->is_nil_constant_as_type())
7770 : : {
7771 : 0 : Type_guard_expression* tge = this->init_->type_guard_expression();
7772 : 0 : go_assert(tge != NULL);
7773 : 0 : init = tge->expr();
7774 : 0 : type = NULL;
7775 : : }
7776 : :
7777 : 71411452 : if (this->seen_)
7778 : : {
7779 : 0 : if (this->type_ == NULL || !this->type_->is_error_type())
7780 : : {
7781 : 0 : go_error_at(this->location_, "variable initializer refers to itself");
7782 : 0 : this->type_ = Type::make_error_type();
7783 : : }
7784 : 0 : return this->type_;
7785 : : }
7786 : :
7787 : 71411452 : this->seen_ = true;
7788 : :
7789 : 71411452 : if (type != NULL)
7790 : : ;
7791 : 0 : else if (this->type_from_init_tuple_)
7792 : 0 : type = this->type_from_tuple(init, false);
7793 : 0 : else if (this->type_from_range_index_ || this->type_from_range_value_)
7794 : 0 : type = this->type_from_range(init, this->type_from_range_index_, false);
7795 : 0 : else if (this->type_from_chan_element_)
7796 : 0 : type = this->type_from_chan_element(init, false);
7797 : : else
7798 : : {
7799 : 0 : go_assert(init != NULL);
7800 : 0 : type = init->type();
7801 : 0 : go_assert(type != NULL);
7802 : :
7803 : : // Variables should not have abstract types.
7804 : 0 : if (type->is_abstract())
7805 : 0 : type = type->make_non_abstract_type();
7806 : :
7807 : 0 : if (type->is_void_type())
7808 : 0 : type = Type::make_error_type();
7809 : : }
7810 : :
7811 : 71411452 : this->seen_ = false;
7812 : :
7813 : 71411452 : return type;
7814 : : }
7815 : :
7816 : : // Fetch the type from a const pointer, in which case it should have
7817 : : // been set already.
7818 : :
7819 : : Type*
7820 : 8440 : Variable::type() const
7821 : : {
7822 : 8440 : go_assert(this->type_ != NULL);
7823 : 8440 : return this->type_;
7824 : : }
7825 : :
7826 : : // Set the type if necessary.
7827 : :
7828 : : void
7829 : 6759215 : Variable::determine_type(Gogo* gogo)
7830 : : {
7831 : 6759215 : if (this->determined_type_)
7832 : : return;
7833 : 906794 : this->determined_type_ = true;
7834 : :
7835 : 906794 : if (this->preinit_ != NULL)
7836 : 4 : this->preinit_->determine_types(gogo);
7837 : :
7838 : : // A variable in a type switch with a nil case will have the wrong
7839 : : // type here. It will have an initializer which is a type guard.
7840 : : // We want to initialize it to the value without the type guard, and
7841 : : // use the type of that value as well.
7842 : 906794 : if (this->is_type_switch_var_
7843 : 9915 : && this->type_ != NULL
7844 : 915568 : && this->type_->is_nil_constant_as_type())
7845 : : {
7846 : 122 : Type_guard_expression* tge = this->init_->type_guard_expression();
7847 : 0 : go_assert(tge != NULL);
7848 : 122 : this->type_ = NULL;
7849 : 122 : this->init_ = tge->expr();
7850 : : }
7851 : :
7852 : 906794 : if (this->init_ == NULL)
7853 : 571773 : go_assert(this->type_ != NULL && !this->type_->is_abstract());
7854 : 335021 : else if (this->type_from_init_tuple_)
7855 : : {
7856 : 1594 : Expression *init = this->init_;
7857 : 1594 : init->determine_type_no_context(gogo);
7858 : 1594 : this->type_ = this->type_from_tuple(init, true);
7859 : 1594 : this->init_ = NULL;
7860 : : }
7861 : 333427 : else if (this->type_from_range_index_ || this->type_from_range_value_)
7862 : : {
7863 : 31409 : Expression* init = this->init_;
7864 : 31409 : init->determine_type_no_context(gogo);
7865 : 31409 : this->type_ = this->type_from_range(init, this->type_from_range_index_,
7866 : : true);
7867 : 31409 : this->init_ = NULL;
7868 : 31409 : }
7869 : 302018 : else if (this->type_from_chan_element_)
7870 : : {
7871 : 524 : Expression* init = this->init_;
7872 : 524 : init->determine_type_no_context(gogo);
7873 : 524 : this->type_ = this->type_from_chan_element(init, true);
7874 : 524 : this->init_ = NULL;
7875 : : }
7876 : : else
7877 : : {
7878 : 301494 : Type_context context(this->type_, false);
7879 : 301494 : this->init_->determine_type(gogo, &context);
7880 : 301494 : if (this->type_ == NULL)
7881 : : {
7882 : 287569 : Type* type = this->init_->type();
7883 : 287569 : go_assert(type != NULL);
7884 : 287569 : if (type->is_abstract())
7885 : 601 : type = type->make_non_abstract_type();
7886 : :
7887 : 287569 : if (type->is_void_type())
7888 : : {
7889 : 1 : go_error_at(this->location_, "variable has no type");
7890 : 1 : type = Type::make_error_type();
7891 : : }
7892 : 287568 : else if (type->is_nil_type())
7893 : : {
7894 : 2 : go_error_at(this->location_, "variable defined to nil type");
7895 : 2 : type = Type::make_error_type();
7896 : : }
7897 : 287566 : else if (type->is_call_multiple_result_type())
7898 : : {
7899 : 2 : go_error_at(this->location_,
7900 : : "single variable set to multiple-value function call");
7901 : 2 : type = Type::make_error_type();
7902 : : }
7903 : :
7904 : 287569 : this->type_ = type;
7905 : : }
7906 : : }
7907 : : }
7908 : :
7909 : : // Get the initial value of a variable. This does not
7910 : : // consider whether the variable is in the heap--it returns the
7911 : : // initial value as though it were always stored in the stack.
7912 : :
7913 : : Bexpression*
7914 : 395645 : Variable::get_init(Gogo* gogo, Named_object* function)
7915 : : {
7916 : 395645 : go_assert(this->preinit_ == NULL);
7917 : 395645 : Location loc = this->location();
7918 : 395645 : if (this->init_ == NULL)
7919 : : {
7920 : 113105 : go_assert(!this->is_parameter_);
7921 : 113105 : if (this->is_global_ || this->is_in_heap())
7922 : : return NULL;
7923 : 95247 : Btype* btype = this->type()->get_backend(gogo);
7924 : 95247 : return gogo->backend()->zero_expression(btype);
7925 : : }
7926 : : else
7927 : : {
7928 : 282540 : Translate_context context(gogo, function, NULL, NULL);
7929 : 282540 : Expression* init = Expression::make_cast(this->type(), this->init_, loc);
7930 : 282540 : return init->get_backend(&context);
7931 : : }
7932 : : }
7933 : :
7934 : : // Get the initial value of a variable when a block is required.
7935 : : // VAR_DECL is the decl to set; it may be NULL for a sink variable.
7936 : :
7937 : : Bstatement*
7938 : 12208 : Variable::get_init_block(Gogo* gogo, Named_object* function,
7939 : : Bvariable* var_decl)
7940 : : {
7941 : 12208 : go_assert(this->preinit_ != NULL);
7942 : :
7943 : : // We want to add the variable assignment to the end of the preinit
7944 : : // block.
7945 : :
7946 : 12208 : Translate_context context(gogo, function, NULL, NULL);
7947 : 12208 : Bblock* bblock = this->preinit_->get_backend(&context);
7948 : 12208 : Bfunction* bfunction =
7949 : 12208 : function->func_value()->get_or_make_decl(gogo, function);
7950 : :
7951 : : // It's possible to have pre-init statements without an initializer
7952 : : // if the pre-init statements set the variable.
7953 : 12208 : Bstatement* decl_init = NULL;
7954 : 12208 : if (this->init_ != NULL)
7955 : : {
7956 : 212 : if (var_decl == NULL)
7957 : : {
7958 : 29 : Bexpression* init_bexpr = this->init_->get_backend(&context);
7959 : 29 : decl_init = gogo->backend()->expression_statement(bfunction,
7960 : : init_bexpr);
7961 : : }
7962 : : else
7963 : : {
7964 : 183 : Location loc = this->location();
7965 : 183 : Expression* val_expr =
7966 : 183 : Expression::make_cast(this->type(), this->init_, loc);
7967 : 183 : Bexpression* val = val_expr->get_backend(&context);
7968 : 183 : Bexpression* var_ref =
7969 : 183 : gogo->backend()->var_expression(var_decl, loc);
7970 : 183 : decl_init = gogo->backend()->assignment_statement(bfunction, var_ref,
7971 : : val, loc);
7972 : : }
7973 : : }
7974 : 12208 : Bstatement* block_stmt = gogo->backend()->block_statement(bblock);
7975 : 12208 : if (decl_init != NULL)
7976 : 212 : block_stmt = gogo->backend()->compound_statement(block_stmt, decl_init);
7977 : 12208 : return block_stmt;
7978 : : }
7979 : :
7980 : : // Add an initializer reference.
7981 : :
7982 : : void
7983 : 11650 : Variable::add_init_ref(Named_object* var)
7984 : : {
7985 : 11650 : if (this->init_refs_ == NULL)
7986 : 3632 : this->init_refs_ = new std::vector<Named_object*>;
7987 : 11650 : this->init_refs_->push_back(var);
7988 : 11650 : }
7989 : :
7990 : : // Export the variable
7991 : :
7992 : : void
7993 : 8440 : Variable::export_var(Export* exp, const Named_object* no) const
7994 : : {
7995 : 8440 : go_assert(this->is_global_);
7996 : 8440 : exp->write_c_string("var ");
7997 : 8440 : if (no->package() != NULL)
7998 : : {
7999 : 2056 : char buf[50];
8000 : 2056 : snprintf(buf, sizeof buf, "<p%d>", exp->package_index(no->package()));
8001 : 2056 : exp->write_c_string(buf);
8002 : : }
8003 : :
8004 : 8440 : if (!Gogo::is_hidden_name(no->name()))
8005 : 5354 : exp->write_string(no->name());
8006 : : else
8007 : : {
8008 : 3086 : exp->write_c_string(".");
8009 : 3086 : exp->write_string(Gogo::unpack_hidden_name(no->name()));
8010 : : }
8011 : :
8012 : 8440 : exp->write_c_string(" ");
8013 : 8440 : exp->write_type(this->type());
8014 : 8440 : exp->write_c_string("\n");
8015 : 8440 : }
8016 : :
8017 : : // Import a variable.
8018 : :
8019 : : bool
8020 : 326311 : Variable::import_var(Import* imp, std::string* pname, Package** ppkg,
8021 : : bool* pis_exported, Type** ptype)
8022 : : {
8023 : 326311 : imp->require_c_string("var ");
8024 : 326311 : if (!Import::read_qualified_identifier(imp, pname, ppkg, pis_exported))
8025 : : {
8026 : 0 : go_error_at(imp->location(),
8027 : : "import error at %d: bad variable name in export data",
8028 : : imp->pos());
8029 : 0 : return false;
8030 : : }
8031 : 326311 : imp->require_c_string(" ");
8032 : 326311 : *ptype = imp->read_type();
8033 : 326311 : imp->require_semicolon_if_old_version();
8034 : 326311 : imp->require_c_string("\n");
8035 : 326311 : return true;
8036 : : }
8037 : :
8038 : : // Convert a variable to the backend representation.
8039 : :
8040 : : Bvariable*
8041 : 4441091 : Variable::get_backend_variable(Gogo* gogo, Named_object* function,
8042 : : const Package* package, const std::string& name)
8043 : : {
8044 : 4441091 : if (this->backend_ == NULL)
8045 : : {
8046 : 923560 : Backend* backend = gogo->backend();
8047 : 923560 : Type* type = this->type_;
8048 : 923560 : if (type->is_error_type()
8049 : 923560 : || (type->is_undefined()
8050 : 5 : && (!this->is_global_ || package == NULL)))
8051 : 149 : this->backend_ = backend->error_variable();
8052 : : else
8053 : : {
8054 : 923411 : bool is_parameter = this->is_parameter_;
8055 : 923411 : if (this->is_receiver_ && type->points_to() == NULL)
8056 : : is_parameter = false;
8057 : 923411 : if (this->is_in_heap())
8058 : : {
8059 : 18171 : is_parameter = false;
8060 : 18171 : type = Type::make_pointer_type(type);
8061 : : }
8062 : :
8063 : 923411 : Btype* btype = type->get_backend(gogo);
8064 : :
8065 : 923411 : Bvariable* bvar;
8066 : 923411 : if (Map_type::is_zero_value(this))
8067 : 3 : bvar = Map_type::backend_zero_value(gogo);
8068 : 923408 : else if (this->is_global_)
8069 : : {
8070 : 34342 : Backend_name bname;
8071 : 34342 : gogo->global_var_backend_name(name, package, &bname);
8072 : :
8073 : 34342 : bool is_hidden = Gogo::is_hidden_name(name);
8074 : : // Hack to export runtime.writeBarrier. FIXME.
8075 : : // This is because go:linkname doesn't work on variables.
8076 : 68684 : if (gogo->compiling_runtime()
8077 : 34342 : && bname.name() == "runtime.writeBarrier")
8078 : 20 : is_hidden = false;
8079 : :
8080 : : // If an inline body refers to this variable, then it
8081 : : // needs to be visible in the symbol table.
8082 : 34342 : if (this->is_referenced_by_inline_)
8083 : 4329 : is_hidden = false;
8084 : :
8085 : : // If this variable is in a different package, then it
8086 : : // can't be treated as a hidden symbol. This case can
8087 : : // arise when an inlined function refers to a
8088 : : // package-scope unexported variable.
8089 : 34342 : if (package != NULL)
8090 : 9045 : is_hidden = false;
8091 : :
8092 : 34342 : unsigned int flags = 0;
8093 : 34342 : if (this->is_address_taken_
8094 : 32083 : || this->is_non_escaping_address_taken_)
8095 : 3542 : flags |= Backend::variable_address_is_taken;
8096 : 34342 : if (package != NULL)
8097 : 9045 : flags |= Backend::variable_is_external;
8098 : 34342 : if (is_hidden)
8099 : 17925 : flags |= Backend::variable_is_hidden;
8100 : 34342 : if (this->in_unique_section_)
8101 : 0 : flags |= Backend::variable_in_unique_section;
8102 : :
8103 : : // For some reason asm_name can't be the empty string
8104 : : // for global_variable, so we call asm_name rather than
8105 : : // optional_asm_name here. FIXME.
8106 : :
8107 : 34342 : bvar = backend->global_variable(bname.name(),
8108 : 34342 : bname.asm_name(),
8109 : : btype, flags,
8110 : : this->location_);
8111 : 34342 : }
8112 : 889066 : else if (function == NULL)
8113 : : {
8114 : 0 : go_assert(saw_errors());
8115 : 0 : bvar = backend->error_variable();
8116 : : }
8117 : : else
8118 : : {
8119 : 889066 : const std::string n = Gogo::unpack_hidden_name(name);
8120 : 889066 : Bfunction* bfunction = function->func_value()->get_decl();
8121 : 889066 : unsigned int flags = 0;
8122 : 889066 : if (this->is_non_escaping_address_taken_
8123 : 889066 : && !this->is_in_heap())
8124 : : flags |= Backend::variable_address_is_taken;
8125 : 889066 : if (this->is_closure())
8126 : 14291 : bvar = backend->static_chain_variable(bfunction, n, btype,
8127 : : flags, this->location_);
8128 : 874775 : else if (is_parameter)
8129 : 474160 : bvar = backend->parameter_variable(bfunction, n, btype,
8130 : : flags, this->location_);
8131 : : else
8132 : : {
8133 : 400615 : Bvariable* bvar_decl = NULL;
8134 : 400615 : if (this->toplevel_decl_ != NULL)
8135 : : {
8136 : 6520 : Translate_context context(gogo, NULL, NULL, NULL);
8137 : 6520 : bvar_decl = this->toplevel_decl_->temporary_statement()
8138 : 6520 : ->get_backend_variable(&context);
8139 : : }
8140 : 400615 : bvar = backend->local_variable(bfunction, n, btype,
8141 : : bvar_decl, flags,
8142 : : this->location_);
8143 : : }
8144 : 889066 : }
8145 : 923411 : this->backend_ = bvar;
8146 : : }
8147 : : }
8148 : 4441091 : return this->backend_;
8149 : : }
8150 : :
8151 : : // Class Result_variable.
8152 : :
8153 : : // Convert a result variable to the backend representation.
8154 : :
8155 : : Bvariable*
8156 : 1161879 : Result_variable::get_backend_variable(Gogo* gogo, Named_object* function,
8157 : : const std::string& name)
8158 : : {
8159 : 1161879 : if (this->backend_ == NULL)
8160 : : {
8161 : 244740 : Backend* backend = gogo->backend();
8162 : 244740 : Type* type = this->type_;
8163 : 244740 : if (type->is_error())
8164 : 3 : this->backend_ = backend->error_variable();
8165 : : else
8166 : : {
8167 : 244737 : if (this->is_in_heap())
8168 : 122 : type = Type::make_pointer_type(type);
8169 : 244737 : Btype* btype = type->get_backend(gogo);
8170 : 244737 : Bfunction* bfunction = function->func_value()->get_decl();
8171 : 244737 : std::string n = Gogo::unpack_hidden_name(name);
8172 : 244737 : unsigned int flags = 0;
8173 : 244737 : if (this->is_non_escaping_address_taken_
8174 : 244737 : && !this->is_in_heap())
8175 : : flags |= Backend::variable_address_is_taken;
8176 : 244737 : this->backend_ = backend->local_variable(bfunction, n, btype,
8177 : : NULL, flags,
8178 : : this->location_);
8179 : 244737 : }
8180 : : }
8181 : 1161879 : return this->backend_;
8182 : : }
8183 : :
8184 : : // Class Named_constant.
8185 : :
8186 : : // Set the type of a named constant. This is only used to set the
8187 : : // type to an error type.
8188 : :
8189 : : void
8190 : 0 : Named_constant::set_type(Type* t)
8191 : : {
8192 : 0 : go_assert(this->type_ == NULL || t->is_error_type());
8193 : 0 : this->type_ = t;
8194 : 0 : }
8195 : :
8196 : : // Traverse the initializer expression.
8197 : :
8198 : : int
8199 : 16377563 : Named_constant::traverse_expression(Traverse* traverse)
8200 : : {
8201 : 16377563 : return Expression::traverse(&this->expr_, traverse);
8202 : : }
8203 : :
8204 : : // Set the iota value in a constant expression.
8205 : :
8206 : 1009271 : class Set_iota_value : public Traverse
8207 : : {
8208 : : public:
8209 : 1009271 : Set_iota_value(int iota_value)
8210 : 1009271 : : Traverse(traverse_expressions),
8211 : 1009271 : iota_value_(iota_value)
8212 : : { }
8213 : :
8214 : : int
8215 : : expression(Expression**);
8216 : :
8217 : : private:
8218 : : int iota_value_;
8219 : : };
8220 : :
8221 : : int
8222 : 1135059 : Set_iota_value::expression(Expression** pexpr)
8223 : : {
8224 : 1135059 : Expression* expr = *pexpr;
8225 : 1135059 : if (expr->const_expression() != NULL)
8226 : 46739 : expr->const_expression()->set_iota_value(this->iota_value_);
8227 : 1088320 : else if (expr->unknown_expression() != NULL)
8228 : : {
8229 : : // This case can happen for an array length that is not set in
8230 : : // the determine types pass.
8231 : 17219 : expr->unknown_expression()->set_iota_value(this->iota_value_);
8232 : : }
8233 : 1135059 : return TRAVERSE_CONTINUE;
8234 : : }
8235 : :
8236 : : // Determine the type of the constant.
8237 : :
8238 : : void
8239 : 1595992 : Named_constant::determine_type(Gogo* gogo)
8240 : : {
8241 : 1595992 : if (this->type_is_determined_)
8242 : 586721 : return;
8243 : 1009271 : this->type_is_determined_ = true;
8244 : :
8245 : 1009271 : if (this->type_ != NULL)
8246 : : {
8247 : 222604 : Type_context context(this->type_, this->type_->is_abstract());
8248 : 222604 : this->expr_->determine_type(gogo, &context);
8249 : : }
8250 : : else
8251 : : {
8252 : : // A constant may have an abstract type.
8253 : 786667 : Type_context context(NULL, true);
8254 : 786667 : this->expr_->determine_type(gogo, &context);
8255 : 786667 : this->type_ = this->expr_->type();
8256 : 786667 : go_assert(this->type_ != NULL);
8257 : : }
8258 : :
8259 : 1009271 : Set_iota_value siv(this->iota_value_);
8260 : 1009271 : this->traverse_expression(&siv);
8261 : 1009271 : }
8262 : :
8263 : : // Indicate that we found and reported an error for this constant.
8264 : :
8265 : : void
8266 : 41 : Named_constant::set_error()
8267 : : {
8268 : 41 : this->type_ = Type::make_error_type();
8269 : 41 : this->expr_ = Expression::make_error(this->location_);
8270 : 41 : }
8271 : :
8272 : : // Export a constant.
8273 : :
8274 : : void
8275 : 39918 : Named_constant::export_const(Export* exp, const std::string& name) const
8276 : : {
8277 : 39918 : exp->write_c_string("const ");
8278 : 39918 : exp->write_string(name);
8279 : 39918 : exp->write_c_string(" ");
8280 : 39918 : if (!this->type_->is_abstract())
8281 : : {
8282 : 15584 : exp->write_type(this->type_);
8283 : 15584 : exp->write_c_string(" ");
8284 : : }
8285 : 39918 : exp->write_c_string("= ");
8286 : :
8287 : 39918 : Export_function_body efb(exp, 0);
8288 : 39918 : if (!this->type_->is_abstract())
8289 : 15584 : efb.set_type_context(this->type_);
8290 : 39918 : this->expr()->export_expression(&efb);
8291 : 39918 : exp->write_string(efb.body());
8292 : :
8293 : 39918 : exp->write_c_string("\n");
8294 : 39918 : }
8295 : :
8296 : : // Import a constant.
8297 : :
8298 : : void
8299 : 849513 : Named_constant::import_const(Import* imp, std::string* pname, Type** ptype,
8300 : : Expression** pexpr)
8301 : : {
8302 : 849513 : imp->require_c_string("const ");
8303 : 849513 : *pname = imp->read_identifier();
8304 : 849513 : imp->require_c_string(" ");
8305 : 849513 : if (imp->peek_char() == '=')
8306 : 654166 : *ptype = NULL;
8307 : : else
8308 : : {
8309 : 195347 : *ptype = imp->read_type();
8310 : 195347 : imp->require_c_string(" ");
8311 : : }
8312 : 849513 : imp->require_c_string("= ");
8313 : 849513 : *pexpr = Expression::import_expression(imp, imp->location());
8314 : 849513 : imp->require_semicolon_if_old_version();
8315 : 849513 : imp->require_c_string("\n");
8316 : 849513 : }
8317 : :
8318 : : // Get the backend representation.
8319 : :
8320 : : Bexpression*
8321 : 23399 : Named_constant::get_backend(Gogo* gogo, Named_object* const_no)
8322 : : {
8323 : 23399 : if (this->bconst_ == NULL)
8324 : : {
8325 : 23399 : Translate_context subcontext(gogo, NULL, NULL, NULL);
8326 : 23399 : Type* type = this->type();
8327 : 23399 : Location loc = this->location();
8328 : :
8329 : 23399 : Expression* const_ref = Expression::make_const_reference(const_no, loc);
8330 : 23399 : Bexpression* const_decl = const_ref->get_backend(&subcontext);
8331 : 46798 : if (type != NULL && type->is_numeric_type())
8332 : : {
8333 : 23399 : Btype* btype = type->get_backend(gogo);
8334 : 23399 : std::string name;
8335 : 23399 : if (const_no->package() == NULL)
8336 : 23399 : name = gogo->pkgpath();
8337 : : else
8338 : 0 : name = const_no->package()->pkgpath();
8339 : 23399 : name.push_back('.');
8340 : 46798 : name.append(Gogo::unpack_hidden_name(const_no->name()));
8341 : 23399 : const_decl =
8342 : 23399 : gogo->backend()->named_constant_expression(btype, name,
8343 : : const_decl, loc);
8344 : 23399 : }
8345 : 23399 : this->bconst_ = const_decl;
8346 : : }
8347 : 23399 : return this->bconst_;
8348 : : }
8349 : :
8350 : : // Add a method.
8351 : :
8352 : : Named_object*
8353 : 2538 : Type_declaration::add_method(const std::string& name, Function* function)
8354 : : {
8355 : 2538 : Named_object* ret = Named_object::make_function(name, NULL, function);
8356 : 2538 : this->methods_.push_back(ret);
8357 : 2538 : return ret;
8358 : : }
8359 : :
8360 : : // Add a method declaration.
8361 : :
8362 : : Named_object*
8363 : 0 : Type_declaration::add_method_declaration(const std::string& name,
8364 : : Package* package,
8365 : : Function_type* type,
8366 : : Location location)
8367 : : {
8368 : 0 : Named_object* ret = Named_object::make_function_declaration(name, package,
8369 : 0 : type, location);
8370 : 0 : this->methods_.push_back(ret);
8371 : 0 : return ret;
8372 : : }
8373 : :
8374 : : // Return whether any methods are defined.
8375 : :
8376 : : bool
8377 : 2 : Type_declaration::has_methods() const
8378 : : {
8379 : 2 : return !this->methods_.empty();
8380 : : }
8381 : :
8382 : : // Define methods for the real type.
8383 : :
8384 : : void
8385 : 622967 : Type_declaration::define_methods(Named_type* nt)
8386 : : {
8387 : 622967 : if (this->methods_.empty())
8388 : : return;
8389 : :
8390 : 518 : while (nt->is_alias())
8391 : : {
8392 : 0 : Type *t = nt->real_type()->forwarded();
8393 : 0 : if (t->named_type() != NULL)
8394 : 0 : nt = t->named_type();
8395 : 0 : else if (t->forward_declaration_type() != NULL)
8396 : : {
8397 : 0 : Named_object* no = t->forward_declaration_type()->named_object();
8398 : 0 : Type_declaration* td = no->type_declaration_value();
8399 : 0 : td->methods_.insert(td->methods_.end(), this->methods_.begin(),
8400 : : this->methods_.end());
8401 : 0 : this->methods_.clear();
8402 : 0 : return;
8403 : : }
8404 : : else
8405 : : {
8406 : 0 : for (std::vector<Named_object*>::const_iterator p =
8407 : 0 : this->methods_.begin();
8408 : 0 : p != this->methods_.end();
8409 : 0 : ++p)
8410 : 0 : go_error_at((*p)->location(),
8411 : : ("invalid receiver type "
8412 : : "(receiver must be a named type)"));
8413 : : return;
8414 : : }
8415 : : }
8416 : :
8417 : 3055 : for (std::vector<Named_object*>::const_iterator p = this->methods_.begin();
8418 : 3055 : p != this->methods_.end();
8419 : 2537 : ++p)
8420 : : {
8421 : 2537 : if ((*p)->is_function_declaration()
8422 : 2537 : || !(*p)->func_value()->is_sink())
8423 : 2536 : nt->add_existing_method(*p);
8424 : : }
8425 : : }
8426 : :
8427 : : // We are using the type. Return true if we should issue a warning.
8428 : :
8429 : : bool
8430 : 8 : Type_declaration::using_type()
8431 : : {
8432 : 8 : bool ret = !this->issued_warning_;
8433 : 8 : this->issued_warning_ = true;
8434 : 8 : return ret;
8435 : : }
8436 : :
8437 : : // Class Unknown_name.
8438 : :
8439 : : // Set the real named object.
8440 : :
8441 : : void
8442 : 85533 : Unknown_name::set_real_named_object(Named_object* no)
8443 : : {
8444 : 85533 : go_assert(this->real_named_object_ == NULL);
8445 : 85533 : go_assert(!no->is_unknown());
8446 : 85533 : this->real_named_object_ = no;
8447 : 85533 : }
8448 : :
8449 : : // Class Named_object.
8450 : :
8451 : 10350470 : Named_object::Named_object(const std::string& name,
8452 : : const Package* package,
8453 : 10350470 : Classification classification)
8454 : 10350470 : : name_(name), package_(package), classification_(classification),
8455 : 10350470 : is_redefinition_(false)
8456 : : {
8457 : 10350470 : if (Gogo::is_sink_name(name))
8458 : 1385474 : go_assert(classification == NAMED_OBJECT_SINK);
8459 : 10350470 : }
8460 : :
8461 : : // Make an unknown name. This is used by the parser. The name must
8462 : : // be resolved later. Unknown names are only added in the current
8463 : : // package.
8464 : :
8465 : : Named_object*
8466 : 85587 : Named_object::make_unknown_name(const std::string& name,
8467 : : Location location)
8468 : : {
8469 : 85587 : Named_object* named_object = new Named_object(name, NULL,
8470 : 85587 : NAMED_OBJECT_UNKNOWN);
8471 : 85587 : Unknown_name* value = new Unknown_name(location);
8472 : 85587 : named_object->u_.unknown_value = value;
8473 : 85587 : return named_object;
8474 : : }
8475 : :
8476 : : // Make a constant.
8477 : :
8478 : : Named_object*
8479 : 1022606 : Named_object::make_constant(const Typed_identifier& tid,
8480 : : const Package* package, Expression* expr,
8481 : : int iota_value)
8482 : : {
8483 : 1022606 : Named_object* named_object = new Named_object(tid.name(), package,
8484 : 1022606 : NAMED_OBJECT_CONST);
8485 : 1022606 : Named_constant* named_constant = new Named_constant(tid.type(), expr,
8486 : : iota_value,
8487 : 1022606 : tid.location());
8488 : 1022606 : named_object->u_.const_value = named_constant;
8489 : 1022606 : return named_object;
8490 : : }
8491 : :
8492 : : // Make a named type.
8493 : :
8494 : : Named_object*
8495 : 752562 : Named_object::make_type(const std::string& name, const Package* package,
8496 : : Type* type, Location location)
8497 : : {
8498 : 752562 : Named_object* named_object = new Named_object(name, package,
8499 : 752562 : NAMED_OBJECT_TYPE);
8500 : 752562 : Named_type* named_type = Type::make_named_type(named_object, type, location);
8501 : 752562 : named_object->u_.type_value = named_type;
8502 : 752562 : return named_object;
8503 : : }
8504 : :
8505 : : // Make a type declaration.
8506 : :
8507 : : Named_object*
8508 : 623484 : Named_object::make_type_declaration(const std::string& name,
8509 : : const Package* package,
8510 : : Location location)
8511 : : {
8512 : 623484 : Named_object* named_object = new Named_object(name, package,
8513 : 623484 : NAMED_OBJECT_TYPE_DECLARATION);
8514 : 623484 : Type_declaration* type_declaration = new Type_declaration(location);
8515 : 623484 : named_object->u_.type_declaration = type_declaration;
8516 : 623484 : return named_object;
8517 : : }
8518 : :
8519 : : // Make a variable.
8520 : :
8521 : : Named_object*
8522 : 1743043 : Named_object::make_variable(const std::string& name, const Package* package,
8523 : : Variable* variable)
8524 : : {
8525 : 1743043 : Named_object* named_object = new Named_object(name, package,
8526 : 1743043 : NAMED_OBJECT_VAR);
8527 : 1743043 : named_object->u_.var_value = variable;
8528 : 1743043 : return named_object;
8529 : : }
8530 : :
8531 : : // Make a result variable.
8532 : :
8533 : : Named_object*
8534 : 244901 : Named_object::make_result_variable(const std::string& name,
8535 : : Result_variable* result)
8536 : : {
8537 : 244901 : Named_object* named_object = new Named_object(name, NULL,
8538 : 244901 : NAMED_OBJECT_RESULT_VAR);
8539 : 244901 : named_object->u_.result_var_value = result;
8540 : 244901 : return named_object;
8541 : : }
8542 : :
8543 : : // Make a sink. This is used for the special blank identifier _.
8544 : :
8545 : : Named_object*
8546 : 1385474 : Named_object::make_sink()
8547 : : {
8548 : 1385474 : return new Named_object("_", NULL, NAMED_OBJECT_SINK);
8549 : : }
8550 : :
8551 : : // Make a named function.
8552 : :
8553 : : Named_object*
8554 : 299274 : Named_object::make_function(const std::string& name, const Package* package,
8555 : : Function* function)
8556 : : {
8557 : 299274 : Named_object* named_object = new Named_object(name, package,
8558 : 299274 : NAMED_OBJECT_FUNC);
8559 : 299274 : named_object->u_.func_value = function;
8560 : 299274 : return named_object;
8561 : : }
8562 : :
8563 : : // Make a function declaration.
8564 : :
8565 : : Named_object*
8566 : 4154108 : Named_object::make_function_declaration(const std::string& name,
8567 : : const Package* package,
8568 : : Function_type* fntype,
8569 : : Location location)
8570 : : {
8571 : 4154108 : Named_object* named_object = new Named_object(name, package,
8572 : 4154108 : NAMED_OBJECT_FUNC_DECLARATION);
8573 : 4154108 : Function_declaration *func_decl = new Function_declaration(fntype, location);
8574 : 4154108 : named_object->u_.func_declaration_value = func_decl;
8575 : 4154108 : return named_object;
8576 : : }
8577 : :
8578 : : // Make a package.
8579 : :
8580 : : Named_object*
8581 : 39417 : Named_object::make_package(const std::string& alias, Package* package)
8582 : : {
8583 : 39417 : Named_object* named_object = new Named_object(alias, NULL,
8584 : 39417 : NAMED_OBJECT_PACKAGE);
8585 : 39417 : named_object->u_.package_value = package;
8586 : 39417 : return named_object;
8587 : : }
8588 : :
8589 : : // Return the name to use in an error message.
8590 : :
8591 : : std::string
8592 : 233463 : Named_object::message_name() const
8593 : : {
8594 : 233463 : if (this->package_ == NULL)
8595 : 215359 : return Gogo::message_name(this->name_);
8596 : 18104 : std::string ret;
8597 : 18104 : if (this->package_->has_package_name())
8598 : 18104 : ret = this->package_->package_name();
8599 : : else
8600 : 0 : ret = this->package_->pkgpath();
8601 : 18104 : ret = Gogo::message_name(ret);
8602 : 18104 : ret += '.';
8603 : 36208 : ret += Gogo::message_name(this->name_);
8604 : 18104 : return ret;
8605 : 18104 : }
8606 : :
8607 : : // Set the type when a declaration is defined.
8608 : :
8609 : : void
8610 : 622967 : Named_object::set_type_value(Named_type* named_type)
8611 : : {
8612 : 622967 : go_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
8613 : 622967 : Type_declaration* td = this->u_.type_declaration;
8614 : 622967 : td->define_methods(named_type);
8615 : 622967 : unsigned int index;
8616 : 622967 : Named_object* in_function = td->in_function(&index);
8617 : 622967 : if (in_function != NULL)
8618 : 1295 : named_type->set_in_function(in_function, index);
8619 : 624262 : delete td;
8620 : 622967 : this->classification_ = NAMED_OBJECT_TYPE;
8621 : 622967 : this->u_.type_value = named_type;
8622 : 622967 : }
8623 : :
8624 : : // Define a function which was previously declared.
8625 : :
8626 : : void
8627 : 106821 : Named_object::set_function_value(Function* function)
8628 : : {
8629 : 106821 : go_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
8630 : 106821 : if (this->func_declaration_value()->has_descriptor())
8631 : : {
8632 : 0 : Expression* descriptor =
8633 : 0 : this->func_declaration_value()->descriptor(NULL, NULL);
8634 : 0 : function->set_descriptor(descriptor);
8635 : : }
8636 : 106821 : this->classification_ = NAMED_OBJECT_FUNC;
8637 : : // FIXME: We should free the old value.
8638 : 106821 : this->u_.func_value = function;
8639 : 106821 : }
8640 : :
8641 : : // Declare an unknown object as a type declaration.
8642 : :
8643 : : void
8644 : 1 : Named_object::declare_as_type()
8645 : : {
8646 : 1 : go_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
8647 : 1 : Unknown_name* unk = this->u_.unknown_value;
8648 : 1 : this->classification_ = NAMED_OBJECT_TYPE_DECLARATION;
8649 : 1 : this->u_.type_declaration = new Type_declaration(unk->location());
8650 : 1 : delete unk;
8651 : 1 : }
8652 : :
8653 : : // Return the location of a named object.
8654 : :
8655 : : Location
8656 : 1914762 : Named_object::location() const
8657 : : {
8658 : 1914762 : switch (this->classification_)
8659 : : {
8660 : 0 : default:
8661 : 0 : case NAMED_OBJECT_UNINITIALIZED:
8662 : 0 : go_unreachable();
8663 : :
8664 : 0 : case NAMED_OBJECT_ERRONEOUS:
8665 : 0 : return Linemap::unknown_location();
8666 : :
8667 : 532 : case NAMED_OBJECT_UNKNOWN:
8668 : 532 : return this->unknown_value()->location();
8669 : :
8670 : 12553 : case NAMED_OBJECT_CONST:
8671 : 12553 : return this->const_value()->location();
8672 : :
8673 : 15018 : case NAMED_OBJECT_TYPE:
8674 : 15018 : return this->type_value()->location();
8675 : :
8676 : 0 : case NAMED_OBJECT_TYPE_DECLARATION:
8677 : 0 : return this->type_declaration_value()->location();
8678 : :
8679 : 701250 : case NAMED_OBJECT_VAR:
8680 : 701250 : return this->var_value()->location();
8681 : :
8682 : 244740 : case NAMED_OBJECT_RESULT_VAR:
8683 : 244740 : return this->result_var_value()->location();
8684 : :
8685 : 0 : case NAMED_OBJECT_SINK:
8686 : 0 : go_unreachable();
8687 : :
8688 : 442504 : case NAMED_OBJECT_FUNC:
8689 : 442504 : return this->func_value()->location();
8690 : :
8691 : 458739 : case NAMED_OBJECT_FUNC_DECLARATION:
8692 : 458739 : return this->func_declaration_value()->location();
8693 : :
8694 : 39426 : case NAMED_OBJECT_PACKAGE:
8695 : 39426 : return this->package_value()->location();
8696 : : }
8697 : : }
8698 : :
8699 : : // Traverse a Named_object.
8700 : :
8701 : : int
8702 : 69212582 : Named_object::traverse(Traverse* traverse, bool is_global)
8703 : : {
8704 : 69212582 : const unsigned int traverse_mask = traverse->traverse_mask();
8705 : 69212582 : const unsigned int e_or_t = (Traverse::traverse_expressions
8706 : : | Traverse::traverse_types);
8707 : 69212582 : const unsigned int e_or_t_or_s = (e_or_t
8708 : : | Traverse::traverse_statements);
8709 : :
8710 : 69212582 : int t = TRAVERSE_CONTINUE;
8711 : 69212582 : switch (this->classification_)
8712 : : {
8713 : 21268159 : case Named_object::NAMED_OBJECT_CONST:
8714 : 21268159 : if ((traverse_mask & Traverse::traverse_constants) != 0)
8715 : 2024020 : t = traverse->constant(this, is_global);
8716 : 2024020 : if (t == TRAVERSE_CONTINUE
8717 : 21268159 : && (traverse_mask & e_or_t) != 0)
8718 : : {
8719 : 13162985 : Type* tc = this->const_value()->type();
8720 : 13162985 : if (tc != NULL)
8721 : : {
8722 : 11583867 : if (Type::traverse(tc, traverse) == TRAVERSE_EXIT)
8723 : : return TRAVERSE_EXIT;
8724 : : }
8725 : 13162985 : t = this->const_value()->traverse_expression(traverse);
8726 : : }
8727 : : break;
8728 : :
8729 : 29747323 : case Named_object::NAMED_OBJECT_VAR:
8730 : 29747323 : case Named_object::NAMED_OBJECT_RESULT_VAR:
8731 : 29747323 : if ((traverse_mask & Traverse::traverse_variables) != 0)
8732 : 7660321 : t = traverse->variable(this);
8733 : 7660321 : if (t == TRAVERSE_CONTINUE
8734 : 28039029 : && (traverse_mask & e_or_t) != 0)
8735 : : {
8736 : 22626466 : if (this->is_result_variable() || this->var_value()->has_type())
8737 : : {
8738 : 21984274 : Type* tv = (this->is_variable()
8739 : 21984274 : ? this->var_value()->type()
8740 : 4143250 : : this->result_var_value()->type());
8741 : 21984274 : if (tv != NULL)
8742 : : {
8743 : 21984274 : if (Type::traverse(tv, traverse) == TRAVERSE_EXIT)
8744 : : return TRAVERSE_EXIT;
8745 : : }
8746 : : }
8747 : : }
8748 : 28038873 : if (t == TRAVERSE_CONTINUE
8749 : 28038873 : && (traverse_mask & e_or_t_or_s) != 0
8750 : 26312579 : && this->is_variable())
8751 : 21645010 : t = this->var_value()->traverse_expression(traverse,
8752 : : traverse_mask);
8753 : : break;
8754 : :
8755 : 4279462 : case Named_object::NAMED_OBJECT_FUNC:
8756 : 4279462 : if ((traverse_mask & Traverse::traverse_functions) != 0)
8757 : 2369044 : t = traverse->function(this);
8758 : 2369044 : if (t == TRAVERSE_CONTINUE
8759 : 3029629 : && (traverse_mask
8760 : 3029629 : & (Traverse::traverse_variables
8761 : : | Traverse::traverse_constants
8762 : : | Traverse::traverse_functions
8763 : : | Traverse::traverse_blocks
8764 : : | Traverse::traverse_statements
8765 : : | Traverse::traverse_expressions
8766 : : | Traverse::traverse_types)) != 0)
8767 : 3029629 : t = this->func_value()->traverse(traverse);
8768 : : break;
8769 : :
8770 : 13091317 : case Named_object::NAMED_OBJECT_TYPE:
8771 : 13091317 : if ((traverse_mask & e_or_t) != 0)
8772 : : {
8773 : 8062261 : t = Type::traverse(this->type_value(), traverse);
8774 : 8062261 : if (t == TRAVERSE_EXIT)
8775 : : return TRAVERSE_EXIT;
8776 : :
8777 : : // Traverse the types of any local methods that are declared
8778 : : // but not defined. We will see defined methods as
8779 : : // NAMED_OBJECT_FUNC, but we won't see methods that are only
8780 : : // declared.
8781 : 8062261 : if (this->package_ == NULL
8782 : 8062261 : && this->type_value()->named_type()->local_methods() != NULL)
8783 : : {
8784 : 151118 : const Bindings* methods =
8785 : 151118 : this->type_value()->named_type()->local_methods();
8786 : 844855 : for (Bindings::const_declarations_iterator p =
8787 : 151118 : methods->begin_declarations();
8788 : 844855 : p != methods->end_declarations();
8789 : 693737 : ++p)
8790 : : {
8791 : 693737 : if (p->second->is_function_declaration())
8792 : : {
8793 : 9224 : Type* mt = p->second->func_declaration_value()->type();
8794 : 9224 : if (Type::traverse(mt, traverse) == TRAVERSE_EXIT)
8795 : 156 : return TRAVERSE_EXIT;
8796 : : }
8797 : : }
8798 : : }
8799 : : }
8800 : :
8801 : : break;
8802 : :
8803 : : case Named_object::NAMED_OBJECT_PACKAGE:
8804 : : case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
8805 : : case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
8806 : : case Named_object::NAMED_OBJECT_UNKNOWN:
8807 : : case Named_object::NAMED_OBJECT_ERRONEOUS:
8808 : : break;
8809 : :
8810 : 0 : case Named_object::NAMED_OBJECT_SINK:
8811 : 0 : go_unreachable();
8812 : :
8813 : 0 : default:
8814 : 0 : go_unreachable();
8815 : : }
8816 : :
8817 : : return t;
8818 : : }
8819 : :
8820 : : // Export a named object.
8821 : :
8822 : : void
8823 : 428883 : Named_object::export_named_object(Export* exp) const
8824 : : {
8825 : 428883 : switch (this->classification_)
8826 : : {
8827 : 0 : default:
8828 : 0 : case NAMED_OBJECT_UNINITIALIZED:
8829 : 0 : case NAMED_OBJECT_UNKNOWN:
8830 : 0 : go_unreachable();
8831 : :
8832 : : case NAMED_OBJECT_ERRONEOUS:
8833 : : break;
8834 : :
8835 : 39918 : case NAMED_OBJECT_CONST:
8836 : 39918 : this->const_value()->export_const(exp, this->name_);
8837 : 39918 : break;
8838 : :
8839 : 0 : case NAMED_OBJECT_TYPE:
8840 : : // Types are handled by export::write_types.
8841 : 0 : go_unreachable();
8842 : :
8843 : 0 : case NAMED_OBJECT_TYPE_DECLARATION:
8844 : 0 : go_error_at(this->type_declaration_value()->location(),
8845 : : "attempt to export %qs which was declared but not defined",
8846 : 0 : this->message_name().c_str());
8847 : 0 : break;
8848 : :
8849 : 301334 : case NAMED_OBJECT_FUNC_DECLARATION:
8850 : 301334 : this->func_declaration_value()->export_func(exp, this);
8851 : 301334 : break;
8852 : :
8853 : 8440 : case NAMED_OBJECT_VAR:
8854 : 8440 : this->var_value()->export_var(exp, this);
8855 : 8440 : break;
8856 : :
8857 : 0 : case NAMED_OBJECT_RESULT_VAR:
8858 : 0 : case NAMED_OBJECT_SINK:
8859 : 0 : go_unreachable();
8860 : :
8861 : 79191 : case NAMED_OBJECT_FUNC:
8862 : 79191 : this->func_value()->export_func(exp, this);
8863 : 79191 : break;
8864 : : }
8865 : 428883 : }
8866 : :
8867 : : // Convert a variable to the backend representation.
8868 : :
8869 : : Bvariable*
8870 : 5602970 : Named_object::get_backend_variable(Gogo* gogo, Named_object* function)
8871 : : {
8872 : 5602970 : if (this->classification_ == NAMED_OBJECT_VAR)
8873 : 4441091 : return this->var_value()->get_backend_variable(gogo, function,
8874 : 4441091 : this->package_, this->name_);
8875 : 1161879 : else if (this->classification_ == NAMED_OBJECT_RESULT_VAR)
8876 : 1161879 : return this->result_var_value()->get_backend_variable(gogo, function,
8877 : 1161879 : this->name_);
8878 : : else
8879 : 0 : go_unreachable();
8880 : : }
8881 : :
8882 : : void
8883 : 0 : debug_go_named_object(Named_object* no)
8884 : : {
8885 : 0 : if (no == NULL)
8886 : : {
8887 : 0 : std::cerr << "<null>";
8888 : 0 : return;
8889 : : }
8890 : 0 : std::cerr << "'" << no->name() << "': ";
8891 : 0 : const char *tag;
8892 : 0 : switch (no->classification())
8893 : : {
8894 : : case Named_object::NAMED_OBJECT_UNINITIALIZED:
8895 : : tag = "uninitialized";
8896 : : break;
8897 : 0 : case Named_object::NAMED_OBJECT_ERRONEOUS:
8898 : 0 : tag = "<error>";
8899 : 0 : break;
8900 : 0 : case Named_object::NAMED_OBJECT_UNKNOWN:
8901 : 0 : tag = "<unknown>";
8902 : 0 : break;
8903 : 0 : case Named_object::NAMED_OBJECT_CONST:
8904 : 0 : tag = "constant";
8905 : 0 : break;
8906 : 0 : case Named_object::NAMED_OBJECT_TYPE:
8907 : 0 : tag = "type";
8908 : 0 : break;
8909 : 0 : case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
8910 : 0 : tag = "type_decl";
8911 : 0 : break;
8912 : 0 : case Named_object::NAMED_OBJECT_VAR:
8913 : 0 : tag = "var";
8914 : 0 : break;
8915 : 0 : case Named_object::NAMED_OBJECT_RESULT_VAR:
8916 : 0 : tag = "result_var";
8917 : 0 : break;
8918 : 0 : case Named_object::NAMED_OBJECT_SINK:
8919 : 0 : tag = "<sink>";
8920 : 0 : break;
8921 : 0 : case Named_object::NAMED_OBJECT_FUNC:
8922 : 0 : tag = "func";
8923 : 0 : break;
8924 : 0 : case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
8925 : 0 : tag = "func_decl";
8926 : 0 : break;
8927 : 0 : case Named_object::NAMED_OBJECT_PACKAGE:
8928 : 0 : tag = "package";
8929 : 0 : break;
8930 : 0 : default:
8931 : 0 : tag = "<unknown named object classification>";
8932 : 0 : break;
8933 : 0 : };
8934 : 0 : std::cerr << tag << "\n";
8935 : : }
8936 : :
8937 : : // Get the backend representation for this named object.
8938 : :
8939 : : void
8940 : 349619 : Named_object::get_backend(Gogo* gogo, std::vector<Bexpression*>& const_decls,
8941 : : std::vector<Btype*>& type_decls,
8942 : : std::vector<Bfunction*>& func_decls)
8943 : : {
8944 : : // If this is a definition, avoid trying to get the backend
8945 : : // representation, as that can crash.
8946 : 349619 : if (this->is_redefinition_)
8947 : : {
8948 : 18 : go_assert(saw_errors());
8949 : : return;
8950 : : }
8951 : :
8952 : 349601 : switch (this->classification_)
8953 : : {
8954 : 23399 : case NAMED_OBJECT_CONST:
8955 : 23399 : if (!Gogo::is_erroneous_name(this->name_))
8956 : 23399 : const_decls.push_back(this->u_.const_value->get_backend(gogo, this));
8957 : : break;
8958 : :
8959 : 30695 : case NAMED_OBJECT_TYPE:
8960 : 30695 : {
8961 : 30695 : Named_type* named_type = this->u_.type_value;
8962 : :
8963 : : // No need to do anything for aliases-- whatever has to be done
8964 : : // can be done for the alias target.
8965 : 30695 : if (named_type->is_alias())
8966 : : break;
8967 : :
8968 : 30401 : if (!Gogo::is_erroneous_name(this->name_))
8969 : 30401 : type_decls.push_back(named_type->get_backend(gogo));
8970 : :
8971 : : // We need to produce a type descriptor for every named
8972 : : // type, and for a pointer to every named type, since
8973 : : // other files or packages might refer to them. We need
8974 : : // to do this even for hidden types, because they might
8975 : : // still be returned by some function. Simply calling the
8976 : : // type_descriptor method is enough to create the type
8977 : : // descriptor, even though we don't do anything with it.
8978 : 30401 : if (this->package_ == NULL && !saw_errors())
8979 : : {
8980 : 29583 : named_type->
8981 : 29583 : type_descriptor_pointer(gogo, Linemap::predeclared_location());
8982 : 29583 : Type* pn = Type::make_pointer_type(named_type);
8983 : 29583 : pn->type_descriptor_pointer(gogo, Linemap::predeclared_location());
8984 : 29583 : if (named_type->in_heap())
8985 : : {
8986 : 29358 : named_type->gc_symbol_pointer(gogo);
8987 : 29358 : pn->gc_symbol_pointer(gogo);
8988 : : }
8989 : : }
8990 : : }
8991 : : break;
8992 : :
8993 : 0 : case NAMED_OBJECT_TYPE_DECLARATION:
8994 : 0 : go_error_at(Linemap::unknown_location(),
8995 : : "reference to undefined type %qs",
8996 : 0 : this->message_name().c_str());
8997 : 0 : return;
8998 : :
8999 : 0 : case NAMED_OBJECT_VAR:
9000 : 0 : case NAMED_OBJECT_RESULT_VAR:
9001 : 0 : case NAMED_OBJECT_SINK:
9002 : 0 : go_unreachable();
9003 : :
9004 : 295494 : case NAMED_OBJECT_FUNC:
9005 : 295494 : {
9006 : 295494 : Function* func = this->u_.func_value;
9007 : 295494 : if (!Gogo::is_erroneous_name(this->name_))
9008 : 295494 : func_decls.push_back(func->get_or_make_decl(gogo, this));
9009 : :
9010 : 295494 : if (func->block() != NULL)
9011 : 295494 : func->build(gogo, this);
9012 : : }
9013 : : break;
9014 : :
9015 : : case NAMED_OBJECT_ERRONEOUS:
9016 : : break;
9017 : :
9018 : 0 : default:
9019 : 0 : go_unreachable();
9020 : : }
9021 : : }
9022 : :
9023 : : // Class Bindings.
9024 : :
9025 : 3142387 : Bindings::Bindings(Bindings* enclosing)
9026 : 3142387 : : enclosing_(enclosing), named_objects_(), bindings_()
9027 : : {
9028 : 3142387 : }
9029 : :
9030 : : // Clear imports.
9031 : :
9032 : : void
9033 : 12707 : Bindings::clear_file_scope(Gogo* gogo)
9034 : : {
9035 : 12707 : Contour::iterator p = this->bindings_.begin();
9036 : 3426636 : while (p != this->bindings_.end())
9037 : : {
9038 : 3413929 : bool keep;
9039 : 3413929 : if (p->second->package() != NULL)
9040 : : keep = false;
9041 : 3351428 : else if (p->second->is_package())
9042 : : keep = false;
9043 : 6624026 : else if (p->second->is_function()
9044 : 1308250 : && !p->second->func_value()->type()->is_method()
9045 : 4620263 : && Gogo::unpack_hidden_name(p->second->name()) == "init")
9046 : : keep = false;
9047 : : else
9048 : 3312013 : keep = true;
9049 : :
9050 : 3312013 : if (keep)
9051 : 3312013 : ++p;
9052 : : else
9053 : : {
9054 : 101916 : gogo->add_file_block_name(p->second->name(), p->second->location());
9055 : 101916 : p = this->bindings_.erase(p);
9056 : : }
9057 : : }
9058 : 12707 : }
9059 : :
9060 : : // Look up a symbol.
9061 : :
9062 : : Named_object*
9063 : 8266761 : Bindings::lookup(const std::string& name) const
9064 : : {
9065 : 13217083 : Contour::const_iterator p = this->bindings_.find(name);
9066 : 13217083 : if (p != this->bindings_.end())
9067 : 5475767 : return p->second->resolve();
9068 : 7741316 : else if (this->enclosing_ != NULL)
9069 : : return this->enclosing_->lookup(name);
9070 : : else
9071 : : return NULL;
9072 : : }
9073 : :
9074 : : // Look up a symbol locally.
9075 : :
9076 : : Named_object*
9077 : 643809 : Bindings::lookup_local(const std::string& name) const
9078 : : {
9079 : 643809 : Contour::const_iterator p = this->bindings_.find(name);
9080 : 643809 : if (p == this->bindings_.end())
9081 : : return NULL;
9082 : 334424 : return p->second;
9083 : : }
9084 : :
9085 : : // Remove an object from a set of bindings. This is used for a
9086 : : // special case in thunks for functions which call recover.
9087 : :
9088 : : void
9089 : 831 : Bindings::remove_binding(Named_object* no)
9090 : : {
9091 : 831 : Contour::iterator pb = this->bindings_.find(no->name());
9092 : 831 : go_assert(pb != this->bindings_.end());
9093 : 831 : this->bindings_.erase(pb);
9094 : 1048 : for (std::vector<Named_object*>::iterator pn = this->named_objects_.begin();
9095 : 1048 : pn != this->named_objects_.end();
9096 : 217 : ++pn)
9097 : : {
9098 : 1048 : if (*pn == no)
9099 : : {
9100 : 831 : this->named_objects_.erase(pn);
9101 : 831 : return;
9102 : : }
9103 : : }
9104 : 0 : go_unreachable();
9105 : : }
9106 : :
9107 : : // Add a method to the list of objects. This is not added to the
9108 : : // lookup table. This is so that we have a single list of objects
9109 : : // declared at the top level, which we walk through when it's time to
9110 : : // convert to trees.
9111 : :
9112 : : void
9113 : 78045 : Bindings::add_method(Named_object* method)
9114 : : {
9115 : 78045 : this->named_objects_.push_back(method);
9116 : 78045 : }
9117 : :
9118 : : // Add a generic Named_object to a Contour.
9119 : :
9120 : : Named_object*
9121 : 7485694 : Bindings::add_named_object_to_contour(Contour* contour,
9122 : : Named_object* named_object)
9123 : : {
9124 : 7485694 : go_assert(named_object == named_object->resolve());
9125 : 7485694 : const std::string& name(named_object->name());
9126 : 7485694 : go_assert(!Gogo::is_sink_name(name));
9127 : :
9128 : 7485694 : std::pair<Contour::iterator, bool> ins =
9129 : 14971388 : contour->insert(std::make_pair(name, named_object));
9130 : 7485694 : if (!ins.second)
9131 : : {
9132 : : // The name was already there.
9133 : 825975 : if (named_object->package() != NULL
9134 : 675130 : && ins.first->second->package() == named_object->package()
9135 : 1501105 : && (ins.first->second->classification()
9136 : 675130 : == named_object->classification()))
9137 : : {
9138 : : // This is a second import of the same object.
9139 : : return ins.first->second;
9140 : : }
9141 : 749421 : ins.first->second = this->new_definition(ins.first->second,
9142 : : named_object);
9143 : 749421 : return ins.first->second;
9144 : : }
9145 : : else
9146 : : {
9147 : : // Don't push declarations on the list. We push them on when
9148 : : // and if we find the definitions. That way we genericize the
9149 : : // functions in order.
9150 : 6659719 : if (!named_object->is_type_declaration()
9151 : : && !named_object->is_function_declaration()
9152 : : && !named_object->is_unknown())
9153 : 2757539 : this->named_objects_.push_back(named_object);
9154 : 6659719 : return named_object;
9155 : : }
9156 : : }
9157 : :
9158 : : // We had an existing named object OLD_OBJECT, and we've seen a new
9159 : : // one NEW_OBJECT with the same name. FIXME: This does not free the
9160 : : // new object when we don't need it.
9161 : :
9162 : : Named_object*
9163 : 749421 : Bindings::new_definition(Named_object* old_object, Named_object* new_object)
9164 : : {
9165 : 749421 : if (new_object->is_erroneous() && !old_object->is_erroneous())
9166 : : return new_object;
9167 : :
9168 : 749421 : std::string reason;
9169 : 749421 : switch (old_object->classification())
9170 : : {
9171 : 0 : default:
9172 : 0 : case Named_object::NAMED_OBJECT_UNINITIALIZED:
9173 : 0 : go_unreachable();
9174 : :
9175 : : case Named_object::NAMED_OBJECT_ERRONEOUS:
9176 : : return old_object;
9177 : :
9178 : 55718 : case Named_object::NAMED_OBJECT_UNKNOWN:
9179 : 55718 : {
9180 : 55718 : Named_object* real = old_object->unknown_value()->real_named_object();
9181 : 55718 : if (real != NULL)
9182 : 0 : return this->new_definition(real, new_object);
9183 : 55718 : go_assert(!new_object->is_unknown());
9184 : 55718 : old_object->unknown_value()->set_real_named_object(new_object);
9185 : 55718 : if (!new_object->is_type_declaration()
9186 : 55718 : && !new_object->is_function_declaration())
9187 : 44384 : this->named_objects_.push_back(new_object);
9188 : : return new_object;
9189 : : }
9190 : :
9191 : : case Named_object::NAMED_OBJECT_CONST:
9192 : : break;
9193 : :
9194 : 0 : case Named_object::NAMED_OBJECT_TYPE:
9195 : 0 : if (new_object->is_type_declaration())
9196 : : return old_object;
9197 : : break;
9198 : :
9199 : 586845 : case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
9200 : 586845 : if (new_object->is_type_declaration())
9201 : : return old_object;
9202 : 586329 : if (new_object->is_type())
9203 : : {
9204 : 586329 : old_object->set_type_value(new_object->type_value());
9205 : 586329 : new_object->type_value()->set_named_object(old_object);
9206 : 586329 : this->named_objects_.push_back(old_object);
9207 : 586329 : return old_object;
9208 : : }
9209 : : break;
9210 : :
9211 : 13 : case Named_object::NAMED_OBJECT_VAR:
9212 : 13 : case Named_object::NAMED_OBJECT_RESULT_VAR:
9213 : : // We have already given an error in the parser for cases where
9214 : : // one parameter or result variable redeclares another one.
9215 : 13 : if ((new_object->is_variable()
9216 : 8 : && new_object->var_value()->is_parameter())
9217 : 18 : || new_object->is_result_variable())
9218 : : return old_object;
9219 : : break;
9220 : :
9221 : 0 : case Named_object::NAMED_OBJECT_SINK:
9222 : 0 : go_unreachable();
9223 : :
9224 : : case Named_object::NAMED_OBJECT_FUNC:
9225 : : break;
9226 : :
9227 : 106826 : case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
9228 : 106826 : {
9229 : : // We declare the hash and equality functions before defining
9230 : : // them, because we sometimes see that we need the declaration
9231 : : // while we are in the middle of a different function.
9232 : : //
9233 : : // We declare the main function before the user defines it, to
9234 : : // give better error messages.
9235 : : //
9236 : : // We declare inline functions before we define them, as we
9237 : : // only define them if we need them.
9238 : 213652 : if (new_object->is_function()
9239 : 106826 : && ((Linemap::is_predeclared_location(old_object->location())
9240 : 92810 : && Linemap::is_predeclared_location(new_object->location()))
9241 : 120840 : || (Gogo::unpack_hidden_name(old_object->name()) == "main"
9242 : 1764 : && Linemap::is_unknown_location(old_object->location()))
9243 : 12250 : || (new_object->package() != NULL
9244 : 12247 : && old_object->func_declaration_value()->has_imported_body()
9245 : 12247 : && new_object->func_value()->is_inline_only())))
9246 : : {
9247 : 106821 : Function_type* old_type =
9248 : 106821 : old_object->func_declaration_value()->type();
9249 : 106821 : Function_type* new_type = new_object->func_value()->type();
9250 : 106821 : if (old_type->is_valid_redeclaration(new_type, &reason))
9251 : : {
9252 : 106821 : Function_declaration* fd =
9253 : 106821 : old_object->func_declaration_value();
9254 : 106821 : go_assert(fd->asm_name().empty());
9255 : 106821 : old_object->set_function_value(new_object->func_value());
9256 : 106821 : this->named_objects_.push_back(old_object);
9257 : 106821 : return old_object;
9258 : : }
9259 : : }
9260 : : }
9261 : : break;
9262 : :
9263 : : case Named_object::NAMED_OBJECT_PACKAGE:
9264 : : break;
9265 : : }
9266 : :
9267 : 56 : std::string n = old_object->message_name();
9268 : 28 : if (reason.empty())
9269 : 28 : go_error_at(new_object->location(), "redefinition of %qs", n.c_str());
9270 : : else
9271 : 0 : go_error_at(new_object->location(), "redefinition of %qs: %s", n.c_str(),
9272 : : reason.c_str());
9273 : 28 : old_object->set_is_redefinition();
9274 : 28 : new_object->set_is_redefinition();
9275 : :
9276 : 28 : if (!Linemap::is_unknown_location(old_object->location())
9277 : 28 : && !Linemap::is_predeclared_location(old_object->location()))
9278 : 27 : go_inform(old_object->location(), "previous definition of %qs was here",
9279 : : n.c_str());
9280 : :
9281 : 28 : return old_object;
9282 : 749421 : }
9283 : :
9284 : : // Add a named type.
9285 : :
9286 : : Named_object*
9287 : 97599 : Bindings::add_named_type(Named_type* named_type)
9288 : : {
9289 : 97599 : return this->add_named_object(named_type->named_object());
9290 : : }
9291 : :
9292 : : // Add a function.
9293 : :
9294 : : Named_object*
9295 : 268709 : Bindings::add_function(const std::string& name, const Package* package,
9296 : : Function* function)
9297 : : {
9298 : 268709 : return this->add_named_object(Named_object::make_function(name, package,
9299 : 268709 : function));
9300 : : }
9301 : :
9302 : : // Add a function declaration.
9303 : :
9304 : : Named_object*
9305 : 3242196 : Bindings::add_function_declaration(const std::string& name,
9306 : : const Package* package,
9307 : : Function_type* type,
9308 : : Location location)
9309 : : {
9310 : 3242196 : Named_object* no = Named_object::make_function_declaration(name, package,
9311 : : type, location);
9312 : 3242196 : return this->add_named_object(no);
9313 : : }
9314 : :
9315 : : // Define a type which was previously declared.
9316 : :
9317 : : void
9318 : 31990 : Bindings::define_type(Named_object* no, Named_type* type)
9319 : : {
9320 : 31990 : no->set_type_value(type);
9321 : 31990 : this->named_objects_.push_back(no);
9322 : 31990 : }
9323 : :
9324 : : // Mark all local variables as used. This is used for some types of
9325 : : // parse error.
9326 : :
9327 : : void
9328 : 56 : Bindings::mark_locals_used()
9329 : : {
9330 : 72 : for (std::vector<Named_object*>::iterator p = this->named_objects_.begin();
9331 : 72 : p != this->named_objects_.end();
9332 : 16 : ++p)
9333 : 16 : if ((*p)->is_variable())
9334 : 12 : (*p)->var_value()->set_is_used();
9335 : 56 : }
9336 : :
9337 : : // Traverse bindings.
9338 : :
9339 : : int
9340 : 2404332 : Bindings::traverse(Traverse* traverse, bool is_global)
9341 : : {
9342 : 2404332 : unsigned int traverse_mask = traverse->traverse_mask();
9343 : :
9344 : : // We don't use an iterator because we permit the traversal to add
9345 : : // new global objects.
9346 : 2404332 : const unsigned int e_or_t = (Traverse::traverse_expressions
9347 : : | Traverse::traverse_types);
9348 : 48846840 : for (size_t i = 0; i < this->named_objects_.size(); ++i)
9349 : : {
9350 : 46442508 : Named_object* p = this->named_objects_[i];
9351 : 46442508 : if (p->traverse(traverse, is_global) == TRAVERSE_EXIT)
9352 : : return TRAVERSE_EXIT;
9353 : : }
9354 : :
9355 : : // If we need to traverse types, check the function declarations,
9356 : : // which have types. Also check any methods of a type declaration.
9357 : 2404332 : if ((traverse_mask & e_or_t) != 0)
9358 : : {
9359 : 43961651 : for (Bindings::const_declarations_iterator p =
9360 : 1481305 : this->begin_declarations();
9361 : 43961651 : p != this->end_declarations();
9362 : 42480346 : ++p)
9363 : : {
9364 : 42480346 : if (p->second->is_function_declaration())
9365 : : {
9366 : 15386027 : if (Type::traverse(p->second->func_declaration_value()->type(),
9367 : : traverse)
9368 : : == TRAVERSE_EXIT)
9369 : 2404332 : return TRAVERSE_EXIT;
9370 : : }
9371 : 27094319 : else if (p->second->is_type_declaration())
9372 : : {
9373 : 20 : const std::vector<Named_object*>* methods =
9374 : 20 : p->second->type_declaration_value()->methods();
9375 : 40 : for (std::vector<Named_object*>::const_iterator pm =
9376 : 20 : methods->begin();
9377 : 40 : pm != methods->end();
9378 : 20 : pm++)
9379 : : {
9380 : 20 : Named_object* no = *pm;
9381 : 20 : Type *t;
9382 : 20 : if (no->is_function())
9383 : 20 : t = no->func_value()->type();
9384 : 0 : else if (no->is_function_declaration())
9385 : 0 : t = no->func_declaration_value()->type();
9386 : : else
9387 : 0 : continue;
9388 : 20 : if (Type::traverse(t, traverse) == TRAVERSE_EXIT)
9389 : 0 : return TRAVERSE_EXIT;
9390 : : }
9391 : : }
9392 : : }
9393 : : }
9394 : :
9395 : : // Traverse function declarations when needed.
9396 : 2404332 : if ((traverse_mask & Traverse::traverse_func_declarations) != 0)
9397 : : {
9398 : 3303559 : for (Bindings::const_declarations_iterator p = this->begin_declarations();
9399 : 3303559 : p != this->end_declarations();
9400 : 3190996 : ++p)
9401 : : {
9402 : 3190996 : if (p->second->is_function_declaration())
9403 : : {
9404 : 1149080 : if (traverse->function_declaration(p->second) == TRAVERSE_EXIT)
9405 : 0 : return TRAVERSE_EXIT;
9406 : : }
9407 : : }
9408 : : }
9409 : :
9410 : : return TRAVERSE_CONTINUE;
9411 : : }
9412 : :
9413 : : // Determine types for the objects.
9414 : :
9415 : : void
9416 : 4646 : Bindings::determine_types(Gogo* gogo)
9417 : : {
9418 : : // We don't use an iterator because the traversal can add new
9419 : : // bindings.
9420 : 457646 : for (size_t i = 0; i < this->named_objects_.size(); ++i)
9421 : : {
9422 : 453000 : Named_object* no = this->named_objects_[i];
9423 : 453000 : if (no->is_function())
9424 : 175575 : no->func_value()->determine_types(gogo);
9425 : 277425 : else if (no->is_variable())
9426 : 36701 : no->var_value()->determine_type(gogo);
9427 : 240724 : else if (no->is_const())
9428 : 156783 : no->const_value()->determine_type(gogo);
9429 : :
9430 : : // See if a variable requires us to build an initialization
9431 : : // function. We know that we will see all global variables
9432 : : // here.
9433 : 453000 : if (!gogo->need_init_fn() && no->is_variable())
9434 : : {
9435 : 2937 : Variable* variable = no->var_value();
9436 : :
9437 : : // If this is a global variable which requires runtime
9438 : : // initialization, we need an initialization function.
9439 : :
9440 : 2937 : if (!variable->is_global())
9441 : 0 : continue;
9442 : :
9443 : 2937 : if (variable->init() == NULL)
9444 : : ;
9445 : 2258 : else if (variable->type()->interface_type() != NULL)
9446 : 253 : gogo->set_need_init_fn();
9447 : 2005 : else if (variable->init()->is_constant())
9448 : : ;
9449 : 1573 : else if (!variable->init()->is_composite_literal())
9450 : 494 : gogo->set_need_init_fn();
9451 : 1079 : else if (variable->init()->is_nonconstant_composite_literal())
9452 : 0 : gogo->set_need_init_fn();
9453 : :
9454 : : // If this global variable holds a pointer value, we need an
9455 : : // initialization function to register it as a GC root.
9456 : 2937 : if (variable->type()->has_pointer())
9457 : 1716 : gogo->set_need_init_fn();
9458 : : }
9459 : : }
9460 : 4646 : }
9461 : :
9462 : : void
9463 : 0 : Bindings::debug_dump()
9464 : : {
9465 : 0 : std::set<Named_object*> defs;
9466 : 0 : for (size_t i = 0; i < this->named_objects_.size(); ++i)
9467 : 0 : defs.insert(this->named_objects_[i]);
9468 : 0 : for (Contour::iterator p = this->bindings_.begin();
9469 : 0 : p != this->bindings_.end();
9470 : 0 : ++p)
9471 : : {
9472 : 0 : const char* tag = " ";
9473 : 0 : if (defs.find(p->second) != defs.end())
9474 : 0 : tag = "* ";
9475 : 0 : std::cerr << tag;
9476 : 0 : debug_go_named_object(p->second);
9477 : : }
9478 : 0 : }
9479 : :
9480 : : void
9481 : 0 : debug_go_bindings(Bindings* bindings)
9482 : : {
9483 : 0 : if (bindings != NULL)
9484 : 0 : bindings->debug_dump();
9485 : 0 : }
9486 : :
9487 : : // Class Label.
9488 : :
9489 : : // Clear any references to this label.
9490 : :
9491 : : void
9492 : 10524 : Label::clear_refs()
9493 : : {
9494 : 12089 : for (std::vector<Bindings_snapshot*>::iterator p = this->refs_.begin();
9495 : 12089 : p != this->refs_.end();
9496 : 1565 : ++p)
9497 : 3130 : delete *p;
9498 : 10524 : this->refs_.clear();
9499 : 10524 : }
9500 : :
9501 : : // Get the backend representation for a label.
9502 : :
9503 : : Blabel*
9504 : 30094 : Label::get_backend_label(Translate_context* context)
9505 : : {
9506 : 30094 : if (this->blabel_ == NULL)
9507 : : {
9508 : 10412 : Function* function = context->function()->func_value();
9509 : 10412 : Bfunction* bfunction = function->get_decl();
9510 : 10412 : this->blabel_ = context->backend()->label(bfunction, this->name_,
9511 : : this->location_);
9512 : : }
9513 : 30094 : return this->blabel_;
9514 : : }
9515 : :
9516 : : // Return an expression for the address of this label.
9517 : :
9518 : : Bexpression*
9519 : 8840 : Label::get_addr(Translate_context* context, Location location)
9520 : : {
9521 : 8840 : Blabel* label = this->get_backend_label(context);
9522 : 8840 : return context->backend()->label_address(label, location);
9523 : : }
9524 : :
9525 : : // Return the dummy label that represents any instance of the blank label.
9526 : :
9527 : : Label*
9528 : 3 : Label::create_dummy_label()
9529 : : {
9530 : 3 : static Label* dummy_label;
9531 : 3 : if (dummy_label == NULL)
9532 : : {
9533 : 2 : dummy_label = new Label("_");
9534 : 2 : dummy_label->set_is_used();
9535 : : }
9536 : 3 : return dummy_label;
9537 : : }
9538 : :
9539 : : // Class Unnamed_label.
9540 : :
9541 : : // Get the backend representation for an unnamed label.
9542 : :
9543 : : Blabel*
9544 : 398195 : Unnamed_label::get_blabel(Translate_context* context)
9545 : : {
9546 : 398195 : if (this->blabel_ == NULL)
9547 : : {
9548 : 174399 : Function* function = context->function()->func_value();
9549 : 174399 : Bfunction* bfunction = function->get_decl();
9550 : 174399 : this->blabel_ = context->backend()->label(bfunction, "",
9551 : : this->location_);
9552 : : }
9553 : 398195 : return this->blabel_;
9554 : : }
9555 : :
9556 : : // Return a statement which defines this unnamed label.
9557 : :
9558 : : Bstatement*
9559 : 174399 : Unnamed_label::get_definition(Translate_context* context)
9560 : : {
9561 : 174399 : Blabel* blabel = this->get_blabel(context);
9562 : 174399 : return context->backend()->label_definition_statement(blabel);
9563 : : }
9564 : :
9565 : : // Return a goto statement to this unnamed label.
9566 : :
9567 : : Bstatement*
9568 : 223796 : Unnamed_label::get_goto(Translate_context* context, Location location)
9569 : : {
9570 : 223796 : Blabel* blabel = this->get_blabel(context);
9571 : 223796 : return context->backend()->goto_statement(blabel, location);
9572 : : }
9573 : :
9574 : : // Class Package.
9575 : :
9576 : 116642 : Package::Package(const std::string& pkgpath,
9577 : 116642 : const std::string& pkgpath_symbol, Location location)
9578 : 233284 : : pkgpath_(pkgpath), pkgpath_symbol_(pkgpath_symbol),
9579 : 116642 : package_name_(), bindings_(new Bindings(NULL)),
9580 : 116642 : location_(location)
9581 : : {
9582 : 116642 : go_assert(!pkgpath.empty());
9583 : 116642 : }
9584 : :
9585 : : // Set the package name.
9586 : :
9587 : : void
9588 : 244825 : Package::set_package_name(const std::string& package_name, Location location)
9589 : : {
9590 : 244825 : go_assert(!package_name.empty());
9591 : 244825 : if (this->package_name_.empty())
9592 : 116642 : this->package_name_ = package_name;
9593 : 128183 : else if (this->package_name_ != package_name)
9594 : 0 : go_error_at(location,
9595 : : ("saw two different packages with "
9596 : : "the same package path %s: %s, %s"),
9597 : : this->pkgpath_.c_str(), this->package_name_.c_str(),
9598 : : package_name.c_str());
9599 : 244825 : }
9600 : :
9601 : : // Return the pkgpath symbol, which is a prefix for symbols defined in
9602 : : // this package.
9603 : :
9604 : : std::string
9605 : 194269 : Package::pkgpath_symbol() const
9606 : : {
9607 : 194269 : if (this->pkgpath_symbol_.empty())
9608 : 101672 : return Gogo::pkgpath_for_symbol(this->pkgpath_);
9609 : 92597 : return this->pkgpath_symbol_;
9610 : : }
9611 : :
9612 : : // Set the package path symbol.
9613 : :
9614 : : void
9615 : 14338 : Package::set_pkgpath_symbol(const std::string& pkgpath_symbol)
9616 : : {
9617 : 14338 : go_assert(!pkgpath_symbol.empty());
9618 : 14338 : if (this->pkgpath_symbol_.empty())
9619 : 11763 : this->pkgpath_symbol_ = pkgpath_symbol;
9620 : : else
9621 : 2575 : go_assert(this->pkgpath_symbol_ == pkgpath_symbol);
9622 : 14338 : }
9623 : :
9624 : : // Note that symbol from this package was and qualified by ALIAS.
9625 : :
9626 : : void
9627 : 322202 : Package::note_usage(const std::string& alias) const
9628 : : {
9629 : 322202 : Aliases::const_iterator p = this->aliases_.find(alias);
9630 : 322202 : go_assert(p != this->aliases_.end());
9631 : 322202 : p->second->note_usage();
9632 : 322202 : }
9633 : :
9634 : : // Forget a given usage. If forgetting this usage means this package becomes
9635 : : // unused, report that error.
9636 : :
9637 : : void
9638 : 39 : Package::forget_usage(Expression* usage) const
9639 : : {
9640 : 39 : if (this->fake_uses_.empty())
9641 : 39 : return;
9642 : :
9643 : 0 : std::set<Expression*>::iterator p = this->fake_uses_.find(usage);
9644 : 0 : go_assert(p != this->fake_uses_.end());
9645 : 0 : this->fake_uses_.erase(p);
9646 : :
9647 : 0 : if (this->fake_uses_.empty())
9648 : 0 : go_error_at(this->location(), "imported and not used: %s",
9649 : 0 : Gogo::message_name(this->package_name()).c_str());
9650 : : }
9651 : :
9652 : : // Clear the used field for the next file. If the only usages of this package
9653 : : // are possibly fake, keep the fake usages for lowering.
9654 : :
9655 : : void
9656 : 362498 : Package::clear_used()
9657 : : {
9658 : 362498 : std::string dot_alias = "." + this->package_name();
9659 : 362498 : Aliases::const_iterator p = this->aliases_.find(dot_alias);
9660 : 362498 : if (p != this->aliases_.end() && p->second->used() > this->fake_uses_.size())
9661 : 335 : this->fake_uses_.clear();
9662 : :
9663 : 362498 : this->aliases_.clear();
9664 : 362498 : }
9665 : :
9666 : : Package_alias*
9667 : 39756 : Package::add_alias(const std::string& alias, Location location)
9668 : : {
9669 : 39756 : Aliases::const_iterator p = this->aliases_.find(alias);
9670 : 39756 : if (p == this->aliases_.end())
9671 : : {
9672 : 39756 : std::pair<Aliases::iterator, bool> ret;
9673 : 39756 : ret = this->aliases_.insert(std::make_pair(alias,
9674 : 79512 : new Package_alias(location)));
9675 : 39756 : p = ret.first;
9676 : : }
9677 : 39756 : return p->second;
9678 : : }
9679 : :
9680 : : // Determine types of constants. Everything else in a package
9681 : : // (variables, function declarations) should already have a fixed
9682 : : // type. Constants may have abstract types.
9683 : :
9684 : : void
9685 : 116245 : Package::determine_types(Gogo* gogo)
9686 : : {
9687 : 116245 : Bindings* bindings = this->bindings_;
9688 : 2320655 : for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
9689 : 2320655 : p != bindings->end_definitions();
9690 : 2204410 : ++p)
9691 : : {
9692 : 2204410 : if ((*p)->is_const())
9693 : 1006296 : (*p)->const_value()->determine_type(gogo);
9694 : : }
9695 : 116245 : }
9696 : :
9697 : : // Class Traverse.
9698 : :
9699 : : // Destructor.
9700 : :
9701 : 17885955 : Traverse::~Traverse()
9702 : : {
9703 : 17885955 : if (this->types_seen_ != NULL)
9704 : 8403557 : delete this->types_seen_;
9705 : 17885955 : if (this->expressions_seen_ != NULL)
9706 : 671165 : delete this->expressions_seen_;
9707 : 17885955 : }
9708 : :
9709 : : // Record that we are looking at a type, and return true if we have
9710 : : // already seen it.
9711 : :
9712 : : bool
9713 : 1186448044 : Traverse::remember_type(const Type* type)
9714 : : {
9715 : 1186448044 : if (type->is_error_type())
9716 : : return true;
9717 : 1186437933 : go_assert((this->traverse_mask() & traverse_types) != 0
9718 : : || (this->traverse_mask() & traverse_expressions) != 0);
9719 : : // We mostly only have to remember named types. But it turns out
9720 : : // that an interface type can refer to itself without using a name
9721 : : // by relying on interface inheritance, as in
9722 : : //
9723 : : // type I interface { F() interface{I} }
9724 : : //
9725 : : // Similarly it is possible for array types to refer to themselves
9726 : : // without a name, e.g.
9727 : : //
9728 : : // var x [uintptr(unsafe.Sizeof(&x))]byte
9729 : : //
9730 : 1186437933 : if (type->classification() != Type::TYPE_NAMED
9731 : 602208859 : && type->classification() != Type::TYPE_ARRAY
9732 : 1708901778 : && type->classification() != Type::TYPE_INTERFACE)
9733 : : return false;
9734 : 677826989 : if (this->types_seen_ == NULL)
9735 : 8403557 : this->types_seen_ = new Types_seen();
9736 : 677826989 : std::pair<Types_seen::iterator, bool> ins = this->types_seen_->insert(type);
9737 : 677826989 : return !ins.second;
9738 : : }
9739 : :
9740 : : // Record that we are looking at an expression, and return true if we
9741 : : // have already seen it. NB: this routine used to assert if the traverse
9742 : : // mask did not include expressions/types -- this is no longer the case,
9743 : : // since it can be useful to remember specific expressions during
9744 : : // walks that only cover statements.
9745 : :
9746 : : bool
9747 : 3237533 : Traverse::remember_expression(const Expression* expression)
9748 : : {
9749 : 3237533 : if (this->expressions_seen_ == NULL)
9750 : 671165 : this->expressions_seen_ = new Expressions_seen();
9751 : 3237533 : std::pair<Expressions_seen::iterator, bool> ins =
9752 : 3237533 : this->expressions_seen_->insert(expression);
9753 : 3237533 : return !ins.second;
9754 : : }
9755 : :
9756 : : // The default versions of these functions should never be called: the
9757 : : // traversal mask indicates which functions may be called.
9758 : :
9759 : : int
9760 : 0 : Traverse::variable(Named_object*)
9761 : : {
9762 : 0 : go_unreachable();
9763 : : }
9764 : :
9765 : : int
9766 : 0 : Traverse::constant(Named_object*, bool)
9767 : : {
9768 : 0 : go_unreachable();
9769 : : }
9770 : :
9771 : : int
9772 : 0 : Traverse::function(Named_object*)
9773 : : {
9774 : 0 : go_unreachable();
9775 : : }
9776 : :
9777 : : int
9778 : 0 : Traverse::block(Block*)
9779 : : {
9780 : 0 : go_unreachable();
9781 : : }
9782 : :
9783 : : int
9784 : 0 : Traverse::statement(Block*, size_t*, Statement*)
9785 : : {
9786 : 0 : go_unreachable();
9787 : : }
9788 : :
9789 : : int
9790 : 0 : Traverse::expression(Expression**)
9791 : : {
9792 : 0 : go_unreachable();
9793 : : }
9794 : :
9795 : : int
9796 : 0 : Traverse::type(Type*)
9797 : : {
9798 : 0 : go_unreachable();
9799 : : }
9800 : :
9801 : : int
9802 : 0 : Traverse::function_declaration(Named_object*)
9803 : : {
9804 : 0 : go_unreachable();
9805 : : }
9806 : :
9807 : : // Class Statement_inserter.
9808 : :
9809 : : void
9810 : 1159926 : Statement_inserter::insert(Statement* s)
9811 : : {
9812 : 1159926 : if (this->statements_added_ != NULL)
9813 : 177892 : this->statements_added_->insert(s);
9814 : :
9815 : 1159926 : if (this->block_ != NULL)
9816 : : {
9817 : 1128108 : go_assert(this->pindex_ != NULL);
9818 : 1128108 : this->block_->insert_statement_before(*this->pindex_, s);
9819 : 1128108 : ++*this->pindex_;
9820 : : }
9821 : 31818 : else if (this->var_ != NULL)
9822 : 31818 : this->var_->add_preinit_statement(this->gogo_, s);
9823 : : else
9824 : 0 : go_assert(saw_errors());
9825 : 1159926 : }
|
