1 // gogo-tree.cc -- convert Go frontend Gogo IR to gcc trees.
3 // Copyright 2009 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
11 #ifndef ENABLE_BUILD_WITH_CXX
19 #include "tree-iterator.h"
21 #include "langhooks.h"
24 #include "diagnostic.h"
26 #ifndef ENABLE_BUILD_WITH_CXX
32 #include "expressions.h"
33 #include "statements.h"
38 // Whether we have seen any errors.
43 return errorcount != 0 || sorrycount != 0;
49 get_identifier_from_string(const std::string& str)
51 return get_identifier_with_length(str.data(), str.length());
56 static std::map<std::string, tree> builtin_functions;
58 // Define a builtin function. BCODE is the builtin function code
59 // defined by builtins.def. NAME is the name of the builtin function.
60 // LIBNAME is the name of the corresponding library function, and is
61 // NULL if there isn't one. FNTYPE is the type of the function.
62 // CONST_P is true if the function has the const attribute.
65 define_builtin(built_in_function bcode, const char* name, const char* libname,
66 tree fntype, bool const_p)
68 tree decl = add_builtin_function(name, fntype, bcode, BUILT_IN_NORMAL,
71 TREE_READONLY(decl) = 1;
72 built_in_decls[bcode] = decl;
73 implicit_built_in_decls[bcode] = decl;
74 builtin_functions[name] = decl;
77 decl = add_builtin_function(libname, fntype, bcode, BUILT_IN_NORMAL,
80 TREE_READONLY(decl) = 1;
81 builtin_functions[libname] = decl;
85 // Create trees for implicit builtin functions.
88 Gogo::define_builtin_function_trees()
90 /* We need to define the fetch_and_add functions, since we use them
92 tree t = go_type_for_size(BITS_PER_UNIT, 1);
93 tree p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
94 define_builtin(BUILT_IN_ADD_AND_FETCH_1, "__sync_fetch_and_add_1", NULL,
95 build_function_type_list(t, p, t, NULL_TREE), false);
97 t = go_type_for_size(BITS_PER_UNIT * 2, 1);
98 p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
99 define_builtin (BUILT_IN_ADD_AND_FETCH_2, "__sync_fetch_and_add_2", NULL,
100 build_function_type_list(t, p, t, NULL_TREE), false);
102 t = go_type_for_size(BITS_PER_UNIT * 4, 1);
103 p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
104 define_builtin(BUILT_IN_ADD_AND_FETCH_4, "__sync_fetch_and_add_4", NULL,
105 build_function_type_list(t, p, t, NULL_TREE), false);
107 t = go_type_for_size(BITS_PER_UNIT * 8, 1);
108 p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
109 define_builtin(BUILT_IN_ADD_AND_FETCH_8, "__sync_fetch_and_add_8", NULL,
110 build_function_type_list(t, p, t, NULL_TREE), false);
112 // We use __builtin_expect for magic import functions.
113 define_builtin(BUILT_IN_EXPECT, "__builtin_expect", NULL,
114 build_function_type_list(long_integer_type_node,
115 long_integer_type_node,
116 long_integer_type_node,
120 // We use __builtin_memmove for the predeclared copy function.
121 define_builtin(BUILT_IN_MEMMOVE, "__builtin_memmove", "memmove",
122 build_function_type_list(ptr_type_node,
129 // We provide sqrt for the math library.
130 define_builtin(BUILT_IN_SQRT, "__builtin_sqrt", "sqrt",
131 build_function_type_list(double_type_node,
135 define_builtin(BUILT_IN_SQRTL, "__builtin_sqrtl", "sqrtl",
136 build_function_type_list(long_double_type_node,
137 long_double_type_node,
141 // We use __builtin_return_address in the thunk we build for
142 // functions which call recover.
143 define_builtin(BUILT_IN_RETURN_ADDRESS, "__builtin_return_address", NULL,
144 build_function_type_list(ptr_type_node,
149 // The compiler uses __builtin_trap for some exception handling
151 define_builtin(BUILT_IN_TRAP, "__builtin_trap", NULL,
152 build_function_type(void_type_node, void_list_node),
156 // Get the name to use for the import control function. If there is a
157 // global function or variable, then we know that that name must be
158 // unique in the link, and we use it as the basis for our name.
161 Gogo::get_init_fn_name()
163 if (this->init_fn_name_.empty())
165 gcc_assert(this->package_ != NULL);
166 if (this->is_main_package())
168 // Use a name which the runtime knows.
169 this->init_fn_name_ = "__go_init_main";
173 std::string s = this->unique_prefix();
175 s.append(this->package_name());
176 s.append("..import");
177 this->init_fn_name_ = s;
181 return this->init_fn_name_;
184 // Add statements to INIT_STMT_LIST which run the initialization
185 // functions for imported packages. This is only used for the "main"
189 Gogo::init_imports(tree* init_stmt_list)
191 gcc_assert(this->is_main_package());
193 if (this->imported_init_fns_.empty())
196 tree fntype = build_function_type(void_type_node, void_list_node);
198 // We must call them in increasing priority order.
199 std::vector<Import_init> v;
200 for (std::set<Import_init>::const_iterator p =
201 this->imported_init_fns_.begin();
202 p != this->imported_init_fns_.end();
205 std::sort(v.begin(), v.end());
207 for (std::vector<Import_init>::const_iterator p = v.begin();
211 std::string user_name = p->package_name() + ".init";
212 tree decl = build_decl(UNKNOWN_LOCATION, FUNCTION_DECL,
213 get_identifier_from_string(user_name),
215 const std::string& init_name(p->init_name());
216 SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(init_name));
217 TREE_PUBLIC(decl) = 1;
218 DECL_EXTERNAL(decl) = 1;
219 append_to_statement_list(build_call_expr(decl, 0), init_stmt_list);
223 // Register global variables with the garbage collector. We need to
224 // register all variables which can hold a pointer value. They become
225 // roots during the mark phase. We build a struct that is easy to
226 // hook into a list of roots.
228 // struct __go_gc_root_list
230 // struct __go_gc_root_list* __next;
231 // struct __go_gc_root
238 // The last entry in the roots array has a NULL decl field.
241 Gogo::register_gc_vars(const std::vector<Named_object*>& var_gc,
242 tree* init_stmt_list)
247 size_t count = var_gc.size();
249 tree root_type = Gogo::builtin_struct(NULL, "__go_gc_root", NULL_TREE, 2,
255 tree index_type = build_index_type(size_int(count));
256 tree array_type = build_array_type(root_type, index_type);
258 tree root_list_type = make_node(RECORD_TYPE);
259 root_list_type = Gogo::builtin_struct(NULL, "__go_gc_root_list",
262 build_pointer_type(root_list_type),
266 // Build an initialier for the __roots array.
268 VEC(constructor_elt,gc)* roots_init = VEC_alloc(constructor_elt, gc,
272 for (std::vector<Named_object*>::const_iterator p = var_gc.begin();
276 VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
278 constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
279 tree field = TYPE_FIELDS(root_type);
281 Bvariable* bvar = (*p)->get_backend_variable(this, NULL);
282 tree decl = var_to_tree(bvar);
283 gcc_assert(TREE_CODE(decl) == VAR_DECL);
284 elt->value = build_fold_addr_expr(decl);
286 elt = VEC_quick_push(constructor_elt, init, NULL);
287 field = DECL_CHAIN(field);
289 elt->value = DECL_SIZE_UNIT(decl);
291 elt = VEC_quick_push(constructor_elt, roots_init, NULL);
292 elt->index = size_int(i);
293 elt->value = build_constructor(root_type, init);
296 // The list ends with a NULL entry.
298 VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
300 constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
301 tree field = TYPE_FIELDS(root_type);
303 elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
305 elt = VEC_quick_push(constructor_elt, init, NULL);
306 field = DECL_CHAIN(field);
308 elt->value = size_zero_node;
310 elt = VEC_quick_push(constructor_elt, roots_init, NULL);
311 elt->index = size_int(i);
312 elt->value = build_constructor(root_type, init);
314 // Build a constructor for the struct.
316 VEC(constructor_elt,gc*) root_list_init = VEC_alloc(constructor_elt, gc, 2);
318 elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
319 field = TYPE_FIELDS(root_list_type);
321 elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
323 elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
324 field = DECL_CHAIN(field);
326 elt->value = build_constructor(array_type, roots_init);
328 // Build a decl to register.
330 tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL,
331 create_tmp_var_name("gc"), root_list_type);
332 DECL_EXTERNAL(decl) = 0;
333 TREE_PUBLIC(decl) = 0;
334 TREE_STATIC(decl) = 1;
335 DECL_ARTIFICIAL(decl) = 1;
336 DECL_INITIAL(decl) = build_constructor(root_list_type, root_list_init);
337 rest_of_decl_compilation(decl, 1, 0);
339 static tree register_gc_fndecl;
340 tree call = Gogo::call_builtin(®ister_gc_fndecl, BUILTINS_LOCATION,
341 "__go_register_gc_roots",
344 build_pointer_type(root_list_type),
345 build_fold_addr_expr(decl));
346 if (call != error_mark_node)
347 append_to_statement_list(call, init_stmt_list);
350 // Build the decl for the initialization function.
353 Gogo::initialization_function_decl()
355 // The tedious details of building your own function. There doesn't
356 // seem to be a helper function for this.
357 std::string name = this->package_name() + ".init";
358 tree fndecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL,
359 get_identifier_from_string(name),
360 build_function_type(void_type_node,
362 const std::string& asm_name(this->get_init_fn_name());
363 SET_DECL_ASSEMBLER_NAME(fndecl, get_identifier_from_string(asm_name));
365 tree resdecl = build_decl(BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
367 DECL_ARTIFICIAL(resdecl) = 1;
368 DECL_CONTEXT(resdecl) = fndecl;
369 DECL_RESULT(fndecl) = resdecl;
371 TREE_STATIC(fndecl) = 1;
372 TREE_USED(fndecl) = 1;
373 DECL_ARTIFICIAL(fndecl) = 1;
374 TREE_PUBLIC(fndecl) = 1;
376 DECL_INITIAL(fndecl) = make_node(BLOCK);
377 TREE_USED(DECL_INITIAL(fndecl)) = 1;
382 // Create the magic initialization function. INIT_STMT_LIST is the
383 // code that it needs to run.
386 Gogo::write_initialization_function(tree fndecl, tree init_stmt_list)
388 // Make sure that we thought we needed an initialization function,
389 // as otherwise we will not have reported it in the export data.
390 gcc_assert(this->is_main_package() || this->need_init_fn_);
392 if (fndecl == NULL_TREE)
393 fndecl = this->initialization_function_decl();
395 DECL_SAVED_TREE(fndecl) = init_stmt_list;
397 current_function_decl = fndecl;
398 if (DECL_STRUCT_FUNCTION(fndecl) == NULL)
399 push_struct_function(fndecl);
401 push_cfun(DECL_STRUCT_FUNCTION(fndecl));
402 cfun->function_end_locus = BUILTINS_LOCATION;
404 gimplify_function_tree(fndecl);
406 cgraph_add_new_function(fndecl, false);
407 cgraph_mark_needed_node(cgraph_get_node(fndecl));
409 current_function_decl = NULL_TREE;
413 // Search for references to VAR in any statements or called functions.
415 class Find_var : public Traverse
418 // A hash table we use to avoid looping. The index is the name of a
419 // named object. We only look through objects defined in this
421 typedef Unordered_set(std::string) Seen_objects;
423 Find_var(Named_object* var, Seen_objects* seen_objects)
424 : Traverse(traverse_expressions),
425 var_(var), seen_objects_(seen_objects), found_(false)
428 // Whether the variable was found.
431 { return this->found_; }
434 expression(Expression**);
437 // The variable we are looking for.
439 // Names of objects we have already seen.
440 Seen_objects* seen_objects_;
441 // True if the variable was found.
445 // See if EXPR refers to VAR, looking through function calls and
446 // variable initializations.
449 Find_var::expression(Expression** pexpr)
451 Expression* e = *pexpr;
453 Var_expression* ve = e->var_expression();
456 Named_object* v = ve->named_object();
460 return TRAVERSE_EXIT;
463 if (v->is_variable() && v->package() == NULL)
465 Expression* init = v->var_value()->init();
468 std::pair<Seen_objects::iterator, bool> ins =
469 this->seen_objects_->insert(v->name());
472 // This is the first time we have seen this name.
473 if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
474 return TRAVERSE_EXIT;
480 // We traverse the code of any function we see. Note that this
481 // means that we will traverse the code of a function whose address
482 // is taken even if it is not called.
483 Func_expression* fe = e->func_expression();
486 const Named_object* f = fe->named_object();
487 if (f->is_function() && f->package() == NULL)
489 std::pair<Seen_objects::iterator, bool> ins =
490 this->seen_objects_->insert(f->name());
493 // This is the first time we have seen this name.
494 if (f->func_value()->block()->traverse(this) == TRAVERSE_EXIT)
495 return TRAVERSE_EXIT;
500 return TRAVERSE_CONTINUE;
503 // Return true if EXPR refers to VAR.
506 expression_requires(Expression* expr, Block* preinit, Named_object* var)
508 Find_var::Seen_objects seen_objects;
509 Find_var find_var(var, &seen_objects);
511 Expression::traverse(&expr, &find_var);
513 preinit->traverse(&find_var);
515 return find_var.found();
518 // Sort variable initializations. If the initialization expression
519 // for variable A refers directly or indirectly to the initialization
520 // expression for variable B, then we must initialize B before A.
526 : var_(NULL), init_(NULL_TREE), waiting_(0)
529 Var_init(Named_object* var, tree init)
530 : var_(var), init_(init), waiting_(0)
533 // Return the variable.
536 { return this->var_; }
538 // Return the initialization expression.
541 { return this->init_; }
543 // Return the number of variables waiting for this one to be
547 { return this->waiting_; }
549 // Increment the number waiting.
552 { ++this->waiting_; }
555 // The variable being initialized.
557 // The initialization expression to run.
559 // The number of variables which are waiting for this one.
563 typedef std::list<Var_init> Var_inits;
565 // Sort the variable initializations. The rule we follow is that we
566 // emit them in the order they appear in the array, except that if the
567 // initialization expression for a variable V1 depends upon another
568 // variable V2 then we initialize V1 after V2.
571 sort_var_inits(Var_inits* var_inits)
574 while (!var_inits->empty())
576 Var_inits::iterator p1 = var_inits->begin();
577 Named_object* var = p1->var();
578 Expression* init = var->var_value()->init();
579 Block* preinit = var->var_value()->preinit();
581 // Start walking through the list to see which variables VAR
582 // needs to wait for. We can skip P1->WAITING variables--that
583 // is the number we've already checked.
584 Var_inits::iterator p2 = p1;
586 for (size_t i = p1->waiting(); i > 0; --i)
589 for (; p2 != var_inits->end(); ++p2)
591 if (expression_requires(init, preinit, p2->var()))
594 if (expression_requires(p2->var()->var_value()->init(),
595 p2->var()->var_value()->preinit(),
598 error_at(var->location(),
599 ("initialization expressions for %qs and "
600 "%qs depend upon each other"),
601 var->message_name().c_str(),
602 p2->var()->message_name().c_str());
603 inform(p2->var()->location(), "%qs defined here",
604 p2->var()->message_name().c_str());
605 p2 = var_inits->end();
609 // We can't emit P1 until P2 is emitted. Move P1.
610 // Note that the WAITING loop always executes at
611 // least once, which is what we want.
612 p2->increment_waiting();
613 Var_inits::iterator p3 = p2;
614 for (size_t i = p2->waiting(); i > 0; --i)
616 var_inits->splice(p3, *var_inits, p1);
622 if (p2 == var_inits->end())
624 // VAR does not depends upon any other initialization expressions.
626 // Check for a loop of VAR on itself. We only do this if
627 // INIT is not NULL; when INIT is NULL, it means that
628 // PREINIT sets VAR, which we will interpret as a loop.
629 if (init != NULL && expression_requires(init, preinit, var))
630 error_at(var->location(),
631 "initialization expression for %qs depends upon itself",
632 var->message_name().c_str());
633 ready.splice(ready.end(), *var_inits, p1);
637 // Now READY is the list in the desired initialization order.
638 var_inits->swap(ready);
641 // Write out the global definitions.
644 Gogo::write_globals()
646 this->convert_named_types();
647 this->build_interface_method_tables();
649 Bindings* bindings = this->current_bindings();
650 size_t count = bindings->size_definitions();
652 tree* vec = new tree[count];
654 tree init_fndecl = NULL_TREE;
655 tree init_stmt_list = NULL_TREE;
657 if (this->is_main_package())
658 this->init_imports(&init_stmt_list);
660 // A list of variable initializations.
663 // A list of variables which need to be registered with the garbage
665 std::vector<Named_object*> var_gc;
666 var_gc.reserve(count);
668 tree var_init_stmt_list = NULL_TREE;
670 for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
671 p != bindings->end_definitions();
674 Named_object* no = *p;
676 gcc_assert(!no->is_type_declaration() && !no->is_function_declaration());
677 // There is nothing to do for a package.
678 if (no->is_package())
685 // There is nothing to do for an object which was imported from
686 // a different package into the global scope.
687 if (no->package() != NULL)
694 // There is nothing useful we can output for constants which
695 // have ideal or non-integeral type.
698 Type* type = no->const_value()->type();
700 type = no->const_value()->expr()->type();
701 if (type->is_abstract() || type->integer_type() == NULL)
709 if (!no->is_variable())
711 vec[i] = no->get_tree(this, NULL);
712 if (vec[i] == error_mark_node)
714 gcc_assert(saw_errors());
722 Bvariable* var = no->get_backend_variable(this, NULL);
723 vec[i] = var_to_tree(var);
724 if (vec[i] == error_mark_node)
726 gcc_assert(saw_errors());
732 // Check for a sink variable, which may be used to run an
733 // initializer purely for its side effects.
734 bool is_sink = no->name()[0] == '_' && no->name()[1] == '.';
736 tree var_init_tree = NULL_TREE;
737 if (!no->var_value()->has_pre_init())
739 tree init = no->var_value()->get_init_tree(this, NULL);
740 if (init == error_mark_node)
741 gcc_assert(saw_errors());
742 else if (init == NULL_TREE)
744 else if (TREE_CONSTANT(init))
745 this->backend()->global_variable_set_init(var,
748 var_init_tree = init;
750 var_init_tree = fold_build2_loc(no->location(), MODIFY_EXPR,
751 void_type_node, vec[i], init);
755 // We are going to create temporary variables which
756 // means that we need an fndecl.
757 if (init_fndecl == NULL_TREE)
758 init_fndecl = this->initialization_function_decl();
759 current_function_decl = init_fndecl;
760 if (DECL_STRUCT_FUNCTION(init_fndecl) == NULL)
761 push_struct_function(init_fndecl);
763 push_cfun(DECL_STRUCT_FUNCTION(init_fndecl));
765 tree var_decl = is_sink ? NULL_TREE : vec[i];
766 var_init_tree = no->var_value()->get_init_block(this, NULL,
769 current_function_decl = NULL_TREE;
773 if (var_init_tree != NULL_TREE && var_init_tree != error_mark_node)
775 if (no->var_value()->init() == NULL
776 && !no->var_value()->has_pre_init())
777 append_to_statement_list(var_init_tree, &var_init_stmt_list);
779 var_inits.push_back(Var_init(no, var_init_tree));
782 if (!is_sink && no->var_value()->type()->has_pointer())
783 var_gc.push_back(no);
787 // Register global variables with the garbage collector.
788 this->register_gc_vars(var_gc, &init_stmt_list);
790 // Simple variable initializations, after all variables are
792 append_to_statement_list(var_init_stmt_list, &init_stmt_list);
794 // Complex variable initializations, first sorting them into a
796 if (!var_inits.empty())
798 sort_var_inits(&var_inits);
799 for (Var_inits::const_iterator p = var_inits.begin();
800 p != var_inits.end();
802 append_to_statement_list(p->init(), &init_stmt_list);
805 // After all the variables are initialized, call the "init"
806 // functions if there are any.
807 for (std::vector<Named_object*>::const_iterator p =
808 this->init_functions_.begin();
809 p != this->init_functions_.end();
812 tree decl = (*p)->get_tree(this, NULL);
813 tree call = build_call_expr(decl, 0);
814 append_to_statement_list(call, &init_stmt_list);
817 // Set up a magic function to do all the initialization actions.
818 // This will be called if this package is imported.
819 if (init_stmt_list != NULL_TREE
820 || this->need_init_fn_
821 || this->is_main_package())
822 this->write_initialization_function(init_fndecl, init_stmt_list);
824 // Pass everything back to the middle-end.
826 wrapup_global_declarations(vec, count);
828 cgraph_finalize_compilation_unit();
830 check_global_declarations(vec, count);
831 emit_debug_global_declarations(vec, count);
836 // Get a tree for the identifier for a named object.
839 Named_object::get_id(Gogo* gogo)
841 gcc_assert(!this->is_variable() && !this->is_result_variable());
842 std::string decl_name;
843 if (this->is_function_declaration()
844 && !this->func_declaration_value()->asm_name().empty())
845 decl_name = this->func_declaration_value()->asm_name();
846 else if (this->is_type()
847 && this->type_value()->location() == BUILTINS_LOCATION)
849 // We don't need the package name for builtin types.
850 decl_name = Gogo::unpack_hidden_name(this->name_);
854 std::string package_name;
855 if (this->package_ == NULL)
856 package_name = gogo->package_name();
858 package_name = this->package_->name();
860 decl_name = package_name + '.' + Gogo::unpack_hidden_name(this->name_);
862 Function_type* fntype;
863 if (this->is_function())
864 fntype = this->func_value()->type();
865 else if (this->is_function_declaration())
866 fntype = this->func_declaration_value()->type();
869 if (fntype != NULL && fntype->is_method())
871 decl_name.push_back('.');
872 decl_name.append(fntype->receiver()->type()->mangled_name(gogo));
877 const Named_object* in_function = this->type_value()->in_function();
878 if (in_function != NULL)
879 decl_name += '$' + in_function->name();
881 return get_identifier_from_string(decl_name);
884 // Get a tree for a named object.
887 Named_object::get_tree(Gogo* gogo, Named_object* function)
889 if (this->tree_ != NULL_TREE)
893 if (this->classification_ == NAMED_OBJECT_TYPE)
896 name = this->get_id(gogo);
898 switch (this->classification_)
900 case NAMED_OBJECT_CONST:
902 Named_constant* named_constant = this->u_.const_value;
903 Translate_context subcontext(gogo, function, NULL, NULL);
904 tree expr_tree = named_constant->expr()->get_tree(&subcontext);
905 if (expr_tree == error_mark_node)
906 decl = error_mark_node;
909 Type* type = named_constant->type();
910 if (type != NULL && !type->is_abstract())
912 if (!type->is_error())
913 expr_tree = fold_convert(type->get_tree(gogo), expr_tree);
915 expr_tree = error_mark_node;
917 if (expr_tree == error_mark_node)
918 decl = error_mark_node;
919 else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
921 decl = build_decl(named_constant->location(), CONST_DECL,
922 name, TREE_TYPE(expr_tree));
923 DECL_INITIAL(decl) = expr_tree;
924 TREE_CONSTANT(decl) = 1;
925 TREE_READONLY(decl) = 1;
929 // A CONST_DECL is only for an enum constant, so we
930 // shouldn't use for non-integral types. Instead we
931 // just return the constant itself, rather than a
939 case NAMED_OBJECT_TYPE:
941 Named_type* named_type = this->u_.type_value;
942 tree type_tree = named_type->get_tree(gogo);
943 if (type_tree == error_mark_node)
944 decl = error_mark_node;
947 decl = TYPE_NAME(type_tree);
948 gcc_assert(decl != NULL_TREE);
950 // We need to produce a type descriptor for every named
951 // type, and for a pointer to every named type, since
952 // other files or packages might refer to them. We need
953 // to do this even for hidden types, because they might
954 // still be returned by some function. Simply calling the
955 // type_descriptor method is enough to create the type
956 // descriptor, even though we don't do anything with it.
957 if (this->package_ == NULL)
959 named_type->type_descriptor_pointer(gogo);
960 Type* pn = Type::make_pointer_type(named_type);
961 pn->type_descriptor_pointer(gogo);
967 case NAMED_OBJECT_TYPE_DECLARATION:
968 error("reference to undefined type %qs",
969 this->message_name().c_str());
970 return error_mark_node;
972 case NAMED_OBJECT_VAR:
973 case NAMED_OBJECT_RESULT_VAR:
974 case NAMED_OBJECT_SINK:
977 case NAMED_OBJECT_FUNC:
979 Function* func = this->u_.func_value;
980 decl = func->get_or_make_decl(gogo, this, name);
981 if (decl != error_mark_node)
983 if (func->block() != NULL)
985 if (DECL_STRUCT_FUNCTION(decl) == NULL)
986 push_struct_function(decl);
988 push_cfun(DECL_STRUCT_FUNCTION(decl));
990 cfun->function_end_locus = func->block()->end_location();
992 current_function_decl = decl;
994 func->build_tree(gogo, this);
996 gimplify_function_tree(decl);
998 cgraph_finalize_function(decl, true);
1000 current_function_decl = NULL_TREE;
1011 if (TREE_TYPE(decl) == error_mark_node)
1012 decl = error_mark_node;
1018 if (ret != error_mark_node)
1019 go_preserve_from_gc(ret);
1024 // Get the initial value of a variable as a tree. This does not
1025 // consider whether the variable is in the heap--it returns the
1026 // initial value as though it were always stored in the stack.
1029 Variable::get_init_tree(Gogo* gogo, Named_object* function)
1031 gcc_assert(this->preinit_ == NULL);
1032 if (this->init_ == NULL)
1034 gcc_assert(!this->is_parameter_);
1035 return this->type_->get_init_tree(gogo,
1037 || this->is_in_heap()));
1041 Translate_context context(gogo, function, NULL, NULL);
1042 tree rhs_tree = this->init_->get_tree(&context);
1043 return Expression::convert_for_assignment(&context, this->type(),
1044 this->init_->type(),
1045 rhs_tree, this->location());
1049 // Get the initial value of a variable when a block is required.
1050 // VAR_DECL is the decl to set; it may be NULL for a sink variable.
1053 Variable::get_init_block(Gogo* gogo, Named_object* function, tree var_decl)
1055 gcc_assert(this->preinit_ != NULL);
1057 // We want to add the variable assignment to the end of the preinit
1058 // block. The preinit block may have a TRY_FINALLY_EXPR and a
1059 // TRY_CATCH_EXPR; if it does, we want to add to the end of the
1060 // regular statements.
1062 Translate_context context(gogo, function, NULL, NULL);
1063 Bblock* bblock = this->preinit_->get_backend(&context);
1064 tree block_tree = block_to_tree(bblock);
1065 if (block_tree == error_mark_node)
1066 return error_mark_node;
1067 gcc_assert(TREE_CODE(block_tree) == BIND_EXPR);
1068 tree statements = BIND_EXPR_BODY(block_tree);
1069 while (statements != NULL_TREE
1070 && (TREE_CODE(statements) == TRY_FINALLY_EXPR
1071 || TREE_CODE(statements) == TRY_CATCH_EXPR))
1072 statements = TREE_OPERAND(statements, 0);
1074 // It's possible to have pre-init statements without an initializer
1075 // if the pre-init statements set the variable.
1076 if (this->init_ != NULL)
1078 tree rhs_tree = this->init_->get_tree(&context);
1079 if (rhs_tree == error_mark_node)
1080 return error_mark_node;
1081 if (var_decl == NULL_TREE)
1082 append_to_statement_list(rhs_tree, &statements);
1085 tree val = Expression::convert_for_assignment(&context, this->type(),
1086 this->init_->type(),
1089 if (val == error_mark_node)
1090 return error_mark_node;
1091 tree set = fold_build2_loc(this->location(), MODIFY_EXPR,
1092 void_type_node, var_decl, val);
1093 append_to_statement_list(set, &statements);
1100 // Get a tree for a function decl.
1103 Function::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
1105 if (this->fndecl_ == NULL_TREE)
1107 tree functype = this->type_->get_tree(gogo);
1108 if (functype == error_mark_node)
1109 this->fndecl_ = error_mark_node;
1112 // The type of a function comes back as a pointer, but we
1113 // want the real function type for a function declaration.
1114 gcc_assert(POINTER_TYPE_P(functype));
1115 functype = TREE_TYPE(functype);
1116 tree decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
1118 this->fndecl_ = decl;
1120 if (no->package() != NULL)
1122 else if (this->enclosing_ != NULL || Gogo::is_thunk(no))
1124 else if (Gogo::unpack_hidden_name(no->name()) == "init"
1125 && !this->type_->is_method())
1127 else if (Gogo::unpack_hidden_name(no->name()) == "main"
1128 && gogo->is_main_package())
1129 TREE_PUBLIC(decl) = 1;
1130 // Methods have to be public even if they are hidden because
1131 // they can be pulled into type descriptors when using
1132 // anonymous fields.
1133 else if (!Gogo::is_hidden_name(no->name())
1134 || this->type_->is_method())
1136 TREE_PUBLIC(decl) = 1;
1137 std::string asm_name = gogo->unique_prefix();
1138 asm_name.append(1, '.');
1139 asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
1140 SET_DECL_ASSEMBLER_NAME(decl,
1141 get_identifier_from_string(asm_name));
1144 // Why do we have to do this in the frontend?
1145 tree restype = TREE_TYPE(functype);
1146 tree resdecl = build_decl(this->location(), RESULT_DECL, NULL_TREE,
1148 DECL_ARTIFICIAL(resdecl) = 1;
1149 DECL_IGNORED_P(resdecl) = 1;
1150 DECL_CONTEXT(resdecl) = decl;
1151 DECL_RESULT(decl) = resdecl;
1153 if (this->enclosing_ != NULL)
1154 DECL_STATIC_CHAIN(decl) = 1;
1156 // If a function calls the predeclared recover function, we
1157 // can't inline it, because recover behaves differently in a
1158 // function passed directly to defer.
1159 if (this->calls_recover_ && !this->is_recover_thunk_)
1160 DECL_UNINLINABLE(decl) = 1;
1162 // If this is a thunk created to call a function which calls
1163 // the predeclared recover function, we need to disable
1164 // stack splitting for the thunk.
1165 if (this->is_recover_thunk_)
1167 tree attr = get_identifier("__no_split_stack__");
1168 DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
1171 go_preserve_from_gc(decl);
1173 if (this->closure_var_ != NULL)
1175 push_struct_function(decl);
1177 Bvariable* bvar = this->closure_var_->get_backend_variable(gogo,
1179 tree closure_decl = var_to_tree(bvar);
1180 if (closure_decl == error_mark_node)
1181 this->fndecl_ = error_mark_node;
1184 DECL_ARTIFICIAL(closure_decl) = 1;
1185 DECL_IGNORED_P(closure_decl) = 1;
1186 TREE_USED(closure_decl) = 1;
1187 DECL_ARG_TYPE(closure_decl) = TREE_TYPE(closure_decl);
1188 TREE_READONLY(closure_decl) = 1;
1190 DECL_STRUCT_FUNCTION(decl)->static_chain_decl = closure_decl;
1197 return this->fndecl_;
1200 // Get a tree for a function declaration.
1203 Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
1205 if (this->fndecl_ == NULL_TREE)
1207 // Let Go code use an asm declaration to pick up a builtin
1209 if (!this->asm_name_.empty())
1211 std::map<std::string, tree>::const_iterator p =
1212 builtin_functions.find(this->asm_name_);
1213 if (p != builtin_functions.end())
1215 this->fndecl_ = p->second;
1216 return this->fndecl_;
1220 tree functype = this->fntype_->get_tree(gogo);
1222 if (functype == error_mark_node)
1223 decl = error_mark_node;
1226 // The type of a function comes back as a pointer, but we
1227 // want the real function type for a function declaration.
1228 gcc_assert(POINTER_TYPE_P(functype));
1229 functype = TREE_TYPE(functype);
1230 decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
1231 TREE_PUBLIC(decl) = 1;
1232 DECL_EXTERNAL(decl) = 1;
1234 if (this->asm_name_.empty())
1236 std::string asm_name = (no->package() == NULL
1237 ? gogo->unique_prefix()
1238 : no->package()->unique_prefix());
1239 asm_name.append(1, '.');
1240 asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
1241 SET_DECL_ASSEMBLER_NAME(decl,
1242 get_identifier_from_string(asm_name));
1245 this->fndecl_ = decl;
1246 go_preserve_from_gc(decl);
1248 return this->fndecl_;
1251 // We always pass the receiver to a method as a pointer. If the
1252 // receiver is actually declared as a non-pointer type, then we copy
1253 // the value into a local variable, so that it has the right type. In
1254 // this function we create the real PARM_DECL to use, and set
1255 // DEC_INITIAL of the var_decl to be the value passed in.
1258 Function::make_receiver_parm_decl(Gogo* gogo, Named_object* no, tree var_decl)
1260 if (var_decl == error_mark_node)
1261 return error_mark_node;
1262 gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
1263 tree val_type = TREE_TYPE(var_decl);
1264 bool is_in_heap = no->var_value()->is_in_heap();
1267 gcc_assert(POINTER_TYPE_P(val_type));
1268 val_type = TREE_TYPE(val_type);
1271 source_location loc = DECL_SOURCE_LOCATION(var_decl);
1272 std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
1274 tree id = get_identifier_from_string(name);
1275 tree parm_decl = build_decl(loc, PARM_DECL, id, build_pointer_type(val_type));
1276 DECL_CONTEXT(parm_decl) = current_function_decl;
1277 DECL_ARG_TYPE(parm_decl) = TREE_TYPE(parm_decl);
1279 gcc_assert(DECL_INITIAL(var_decl) == NULL_TREE);
1280 // The receiver might be passed as a null pointer.
1281 tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node, parm_decl,
1282 fold_convert_loc(loc, TREE_TYPE(parm_decl),
1283 null_pointer_node));
1284 tree ind = build_fold_indirect_ref_loc(loc, parm_decl);
1285 TREE_THIS_NOTRAP(ind) = 1;
1286 tree zero_init = no->var_value()->type()->get_init_tree(gogo, false);
1287 tree init = fold_build3_loc(loc, COND_EXPR, TREE_TYPE(ind),
1288 check, ind, zero_init);
1292 tree size = TYPE_SIZE_UNIT(val_type);
1293 tree space = gogo->allocate_memory(no->var_value()->type(), size,
1295 space = save_expr(space);
1296 space = fold_convert(build_pointer_type(val_type), space);
1297 tree spaceref = build_fold_indirect_ref_loc(no->location(), space);
1298 TREE_THIS_NOTRAP(spaceref) = 1;
1299 tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node,
1301 fold_convert_loc(loc, TREE_TYPE(parm_decl),
1302 null_pointer_node));
1303 tree parmref = build_fold_indirect_ref_loc(no->location(), parm_decl);
1304 TREE_THIS_NOTRAP(parmref) = 1;
1305 tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
1307 init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
1308 build3(COND_EXPR, void_type_node,
1309 check, set, NULL_TREE),
1313 DECL_INITIAL(var_decl) = init;
1318 // If we take the address of a parameter, then we need to copy it into
1319 // the heap. We will access it as a local variable via an
1323 Function::copy_parm_to_heap(Gogo* gogo, Named_object* no, tree var_decl)
1325 if (var_decl == error_mark_node)
1326 return error_mark_node;
1327 gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
1328 source_location loc = DECL_SOURCE_LOCATION(var_decl);
1330 std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
1332 tree id = get_identifier_from_string(name);
1334 tree type = TREE_TYPE(var_decl);
1335 gcc_assert(POINTER_TYPE_P(type));
1336 type = TREE_TYPE(type);
1338 tree parm_decl = build_decl(loc, PARM_DECL, id, type);
1339 DECL_CONTEXT(parm_decl) = current_function_decl;
1340 DECL_ARG_TYPE(parm_decl) = type;
1342 tree size = TYPE_SIZE_UNIT(type);
1343 tree space = gogo->allocate_memory(no->var_value()->type(), size, loc);
1344 space = save_expr(space);
1345 space = fold_convert(TREE_TYPE(var_decl), space);
1346 tree spaceref = build_fold_indirect_ref_loc(loc, space);
1347 TREE_THIS_NOTRAP(spaceref) = 1;
1348 tree init = build2(COMPOUND_EXPR, TREE_TYPE(space),
1349 build2(MODIFY_EXPR, void_type_node, spaceref, parm_decl),
1351 DECL_INITIAL(var_decl) = init;
1356 // Get a tree for function code.
1359 Function::build_tree(Gogo* gogo, Named_object* named_function)
1361 tree fndecl = this->fndecl_;
1362 gcc_assert(fndecl != NULL_TREE);
1364 tree params = NULL_TREE;
1367 tree declare_vars = NULL_TREE;
1368 for (Bindings::const_definitions_iterator p =
1369 this->block_->bindings()->begin_definitions();
1370 p != this->block_->bindings()->end_definitions();
1373 if ((*p)->is_variable() && (*p)->var_value()->is_parameter())
1375 Bvariable* bvar = (*p)->get_backend_variable(gogo, named_function);
1376 *pp = var_to_tree(bvar);
1378 // We always pass the receiver to a method as a pointer. If
1379 // the receiver is declared as a non-pointer type, then we
1380 // copy the value into a local variable.
1381 if ((*p)->var_value()->is_receiver()
1382 && (*p)->var_value()->type()->points_to() == NULL)
1384 tree parm_decl = this->make_receiver_parm_decl(gogo, *p, *pp);
1386 if (var != error_mark_node)
1388 gcc_assert(TREE_CODE(var) == VAR_DECL);
1389 DECL_CHAIN(var) = declare_vars;
1394 else if ((*p)->var_value()->is_in_heap())
1396 // If we take the address of a parameter, then we need
1397 // to copy it into the heap.
1398 tree parm_decl = this->copy_parm_to_heap(gogo, *p, *pp);
1400 if (var != error_mark_node)
1402 gcc_assert(TREE_CODE(var) == VAR_DECL);
1403 DECL_CHAIN(var) = declare_vars;
1409 if (*pp != error_mark_node)
1411 gcc_assert(TREE_CODE(*pp) == PARM_DECL);
1412 pp = &DECL_CHAIN(*pp);
1415 else if ((*p)->is_result_variable())
1417 Bvariable* bvar = (*p)->get_backend_variable(gogo, named_function);
1418 tree var_decl = var_to_tree(bvar);
1420 Type* type = (*p)->result_var_value()->type();
1422 if (!(*p)->result_var_value()->is_in_heap())
1423 init = type->get_init_tree(gogo, false);
1426 source_location loc = (*p)->location();
1427 tree type_tree = type->get_tree(gogo);
1428 tree space = gogo->allocate_memory(type,
1429 TYPE_SIZE_UNIT(type_tree),
1431 tree ptr_type_tree = build_pointer_type(type_tree);
1432 tree subinit = type->get_init_tree(gogo, true);
1433 if (subinit == NULL_TREE)
1434 init = fold_convert_loc(loc, ptr_type_tree, space);
1437 space = save_expr(space);
1438 space = fold_convert_loc(loc, ptr_type_tree, space);
1439 tree spaceref = build_fold_indirect_ref_loc(loc, space);
1440 TREE_THIS_NOTRAP(spaceref) = 1;
1441 tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
1443 init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
1448 if (var_decl != error_mark_node)
1450 gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
1451 DECL_INITIAL(var_decl) = init;
1452 DECL_CHAIN(var_decl) = declare_vars;
1453 declare_vars = var_decl;
1459 DECL_ARGUMENTS(fndecl) = params;
1461 if (this->block_ != NULL)
1463 gcc_assert(DECL_INITIAL(fndecl) == NULL_TREE);
1465 // Declare variables if necessary.
1466 tree bind = NULL_TREE;
1467 tree defer_init = NULL_TREE;
1468 if (declare_vars != NULL_TREE || this->defer_stack_ != NULL)
1470 tree block = make_node(BLOCK);
1471 BLOCK_SUPERCONTEXT(block) = fndecl;
1472 DECL_INITIAL(fndecl) = block;
1473 BLOCK_VARS(block) = declare_vars;
1474 TREE_USED(block) = 1;
1476 bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block),
1478 TREE_SIDE_EFFECTS(bind) = 1;
1480 if (this->defer_stack_ != NULL)
1482 Translate_context dcontext(gogo, named_function, this->block_,
1483 tree_to_block(bind));
1484 Bstatement* bdi = this->defer_stack_->get_backend(&dcontext);
1485 defer_init = stat_to_tree(bdi);
1489 // Build the trees for all the statements in the function.
1490 Translate_context context(gogo, named_function, NULL, NULL);
1491 Bblock* bblock = this->block_->get_backend(&context);
1492 tree code = block_to_tree(bblock);
1494 tree init = NULL_TREE;
1495 tree except = NULL_TREE;
1496 tree fini = NULL_TREE;
1498 // Initialize variables if necessary.
1499 for (tree v = declare_vars; v != NULL_TREE; v = DECL_CHAIN(v))
1501 tree dv = build1(DECL_EXPR, void_type_node, v);
1502 SET_EXPR_LOCATION(dv, DECL_SOURCE_LOCATION(v));
1503 append_to_statement_list(dv, &init);
1506 // If we have a defer stack, initialize it at the start of a
1508 if (defer_init != NULL_TREE && defer_init != error_mark_node)
1510 SET_EXPR_LOCATION(defer_init, this->block_->start_location());
1511 append_to_statement_list(defer_init, &init);
1513 // Clean up the defer stack when we leave the function.
1514 this->build_defer_wrapper(gogo, named_function, &except, &fini);
1517 if (code != NULL_TREE && code != error_mark_node)
1519 if (init != NULL_TREE)
1520 code = build2(COMPOUND_EXPR, void_type_node, init, code);
1521 if (except != NULL_TREE)
1522 code = build2(TRY_CATCH_EXPR, void_type_node, code,
1523 build2(CATCH_EXPR, void_type_node, NULL, except));
1524 if (fini != NULL_TREE)
1525 code = build2(TRY_FINALLY_EXPR, void_type_node, code, fini);
1528 // Stick the code into the block we built for the receiver, if
1530 if (bind != NULL_TREE && code != NULL_TREE && code != error_mark_node)
1532 BIND_EXPR_BODY(bind) = code;
1536 DECL_SAVED_TREE(fndecl) = code;
1540 // Build the wrappers around function code needed if the function has
1541 // any defer statements. This sets *EXCEPT to an exception handler
1542 // and *FINI to a finally handler.
1545 Function::build_defer_wrapper(Gogo* gogo, Named_object* named_function,
1546 tree *except, tree *fini)
1548 source_location end_loc = this->block_->end_location();
1550 // Add an exception handler. This is used if a panic occurs. Its
1551 // purpose is to stop the stack unwinding if a deferred function
1552 // calls recover. There are more details in
1553 // libgo/runtime/go-unwind.c.
1555 tree stmt_list = NULL_TREE;
1557 Expression* call = Runtime::make_call(Runtime::CHECK_DEFER, end_loc, 1,
1558 this->defer_stack(end_loc));
1559 Translate_context context(gogo, named_function, NULL, NULL);
1560 tree call_tree = call->get_tree(&context);
1561 if (call_tree != error_mark_node)
1562 append_to_statement_list(call_tree, &stmt_list);
1564 tree retval = this->return_value(gogo, named_function, end_loc, &stmt_list);
1566 if (retval == NULL_TREE)
1569 set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
1570 DECL_RESULT(this->fndecl_), retval);
1571 tree ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
1572 append_to_statement_list(ret_stmt, &stmt_list);
1574 gcc_assert(*except == NULL_TREE);
1575 *except = stmt_list;
1577 // Add some finally code to run the defer functions. This is used
1578 // both in the normal case, when no panic occurs, and also if a
1579 // panic occurs to run any further defer functions. Of course, it
1580 // is possible for a defer function to call panic which should be
1581 // caught by another defer function. To handle that we use a loop.
1583 // try { __go_undefer(); } catch { __go_check_defer(); goto finish; }
1584 // if (return values are named) return named_vals;
1588 tree label = create_artificial_label(end_loc);
1589 tree define_label = fold_build1_loc(end_loc, LABEL_EXPR, void_type_node,
1591 append_to_statement_list(define_label, &stmt_list);
1593 call = Runtime::make_call(Runtime::UNDEFER, end_loc, 1,
1594 this->defer_stack(end_loc));
1595 tree undefer = call->get_tree(&context);
1597 call = Runtime::make_call(Runtime::CHECK_DEFER, end_loc, 1,
1598 this->defer_stack(end_loc));
1599 tree defer = call->get_tree(&context);
1601 if (undefer == error_mark_node || defer == error_mark_node)
1604 tree jump = fold_build1_loc(end_loc, GOTO_EXPR, void_type_node, label);
1605 tree catch_body = build2(COMPOUND_EXPR, void_type_node, defer, jump);
1606 catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
1607 tree try_catch = build2(TRY_CATCH_EXPR, void_type_node, undefer, catch_body);
1609 append_to_statement_list(try_catch, &stmt_list);
1611 if (this->type_->results() != NULL
1612 && !this->type_->results()->empty()
1613 && !this->type_->results()->front().name().empty())
1615 // If the result variables are named, we need to return them
1616 // again, because they might have been changed by a defer
1618 retval = this->return_value(gogo, named_function, end_loc,
1620 set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
1621 DECL_RESULT(this->fndecl_), retval);
1622 ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
1623 append_to_statement_list(ret_stmt, &stmt_list);
1626 gcc_assert(*fini == NULL_TREE);
1630 // Return the value to assign to DECL_RESULT(this->fndecl_). This may
1631 // also add statements to STMT_LIST, which need to be executed before
1632 // the assignment. This is used for a return statement with no
1636 Function::return_value(Gogo* gogo, Named_object* named_function,
1637 source_location location, tree* stmt_list) const
1639 const Typed_identifier_list* results = this->type_->results();
1640 if (results == NULL || results->empty())
1643 gcc_assert(this->results_ != NULL);
1644 if (this->results_->size() != results->size())
1646 gcc_assert(saw_errors());
1647 return error_mark_node;
1651 if (results->size() == 1)
1654 this->results_->front()->get_backend_variable(gogo,
1656 tree ret = var_to_tree(bvar);
1657 if (this->results_->front()->result_var_value()->is_in_heap())
1658 ret = build_fold_indirect_ref_loc(location, ret);
1663 tree rettype = TREE_TYPE(DECL_RESULT(this->fndecl_));
1664 retval = create_tmp_var(rettype, "RESULT");
1665 tree field = TYPE_FIELDS(rettype);
1667 for (Typed_identifier_list::const_iterator pr = results->begin();
1668 pr != results->end();
1669 ++pr, ++index, field = DECL_CHAIN(field))
1671 gcc_assert(field != NULL);
1672 Named_object* no = (*this->results_)[index];
1673 Bvariable* bvar = no->get_backend_variable(gogo, named_function);
1674 tree val = var_to_tree(bvar);
1675 if (no->result_var_value()->is_in_heap())
1676 val = build_fold_indirect_ref_loc(location, val);
1677 tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
1678 build3(COMPONENT_REF, TREE_TYPE(field),
1679 retval, field, NULL_TREE),
1681 append_to_statement_list(set, stmt_list);
1687 // Return the integer type to use for a size.
1691 go_type_for_size(unsigned int bits, int unsignedp)
1697 name = unsignedp ? "uint8" : "int8";
1700 name = unsignedp ? "uint16" : "int16";
1703 name = unsignedp ? "uint32" : "int32";
1706 name = unsignedp ? "uint64" : "int64";
1709 if (bits == POINTER_SIZE && unsignedp)
1714 Type* type = Type::lookup_integer_type(name);
1715 return type->get_tree(go_get_gogo());
1718 // Return the type to use for a mode.
1722 go_type_for_mode(enum machine_mode mode, int unsignedp)
1724 // FIXME: This static_cast should be in machmode.h.
1725 enum mode_class mc = static_cast<enum mode_class>(GET_MODE_CLASS(mode));
1727 return go_type_for_size(GET_MODE_BITSIZE(mode), unsignedp);
1728 else if (mc == MODE_FLOAT)
1731 switch (GET_MODE_BITSIZE (mode))
1734 type = Type::lookup_float_type("float32");
1737 type = Type::lookup_float_type("float64");
1740 // We have to check for long double in order to support
1741 // i386 excess precision.
1742 if (mode == TYPE_MODE(long_double_type_node))
1743 return long_double_type_node;
1746 return type->float_type()->type_tree();
1748 else if (mc == MODE_COMPLEX_FLOAT)
1751 switch (GET_MODE_BITSIZE (mode))
1754 type = Type::lookup_complex_type("complex64");
1757 type = Type::lookup_complex_type("complex128");
1760 // We have to check for long double in order to support
1761 // i386 excess precision.
1762 if (mode == TYPE_MODE(complex_long_double_type_node))
1763 return complex_long_double_type_node;
1766 return type->complex_type()->type_tree();
1772 // Return a tree which allocates SIZE bytes which will holds value of
1776 Gogo::allocate_memory(Type* type, tree size, source_location location)
1778 // If the package imports unsafe, then it may play games with
1779 // pointers that look like integers.
1780 if (this->imported_unsafe_ || type->has_pointer())
1782 static tree new_fndecl;
1783 return Gogo::call_builtin(&new_fndecl,
1793 static tree new_nopointers_fndecl;
1794 return Gogo::call_builtin(&new_nopointers_fndecl,
1796 "__go_new_nopointers",
1804 // Build a builtin struct with a list of fields. The name is
1805 // STRUCT_NAME. STRUCT_TYPE is NULL_TREE or an empty RECORD_TYPE
1806 // node; this exists so that the struct can have fields which point to
1807 // itself. If PTYPE is not NULL, store the result in *PTYPE. There
1808 // are NFIELDS fields. Each field is a name (a const char*) followed
1809 // by a type (a tree).
1812 Gogo::builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
1815 if (ptype != NULL && *ptype != NULL_TREE)
1819 va_start(ap, nfields);
1821 tree fields = NULL_TREE;
1822 for (int i = 0; i < nfields; ++i)
1824 const char* field_name = va_arg(ap, const char*);
1825 tree type = va_arg(ap, tree);
1826 if (type == error_mark_node)
1829 *ptype = error_mark_node;
1830 return error_mark_node;
1832 tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL,
1833 get_identifier(field_name), type);
1834 DECL_CHAIN(field) = fields;
1840 if (struct_type == NULL_TREE)
1841 struct_type = make_node(RECORD_TYPE);
1842 finish_builtin_struct(struct_type, struct_name, fields, NULL_TREE);
1846 go_preserve_from_gc(struct_type);
1847 *ptype = struct_type;
1853 // Return a type to use for pointer to const char for a string.
1856 Gogo::const_char_pointer_type_tree()
1859 if (type == NULL_TREE)
1861 tree const_char_type = build_qualified_type(unsigned_char_type_node,
1863 type = build_pointer_type(const_char_type);
1864 go_preserve_from_gc(type);
1869 // Return a tree for a string constant.
1872 Gogo::string_constant_tree(const std::string& val)
1874 tree index_type = build_index_type(size_int(val.length()));
1875 tree const_char_type = build_qualified_type(unsigned_char_type_node,
1877 tree string_type = build_array_type(const_char_type, index_type);
1878 string_type = build_variant_type_copy(string_type);
1879 TYPE_STRING_FLAG(string_type) = 1;
1880 tree string_val = build_string(val.length(), val.data());
1881 TREE_TYPE(string_val) = string_type;
1885 // Return a tree for a Go string constant.
1888 Gogo::go_string_constant_tree(const std::string& val)
1890 tree string_type = Type::make_string_type()->get_tree(this);
1892 VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
1894 constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
1895 tree field = TYPE_FIELDS(string_type);
1896 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__data") == 0);
1898 tree str = Gogo::string_constant_tree(val);
1899 elt->value = fold_convert(TREE_TYPE(field),
1900 build_fold_addr_expr(str));
1902 elt = VEC_quick_push(constructor_elt, init, NULL);
1903 field = DECL_CHAIN(field);
1904 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__length") == 0);
1906 elt->value = build_int_cst_type(TREE_TYPE(field), val.length());
1908 tree constructor = build_constructor(string_type, init);
1909 TREE_READONLY(constructor) = 1;
1910 TREE_CONSTANT(constructor) = 1;
1915 // Return a tree for a pointer to a Go string constant. This is only
1916 // used for type descriptors, so we return a pointer to a constant
1920 Gogo::ptr_go_string_constant_tree(const std::string& val)
1922 tree pval = this->go_string_constant_tree(val);
1924 tree decl = build_decl(UNKNOWN_LOCATION, VAR_DECL,
1925 create_tmp_var_name("SP"), TREE_TYPE(pval));
1926 DECL_EXTERNAL(decl) = 0;
1927 TREE_PUBLIC(decl) = 0;
1928 TREE_USED(decl) = 1;
1929 TREE_READONLY(decl) = 1;
1930 TREE_CONSTANT(decl) = 1;
1931 TREE_STATIC(decl) = 1;
1932 DECL_ARTIFICIAL(decl) = 1;
1933 DECL_INITIAL(decl) = pval;
1934 rest_of_decl_compilation(decl, 1, 0);
1936 return build_fold_addr_expr(decl);
1939 // Build the type of the struct that holds a slice for the given
1943 Gogo::slice_type_tree(tree element_type_tree)
1945 // We use int for the count and capacity fields in a slice header.
1946 // This matches 6g. The language definition guarantees that we
1947 // can't allocate space of a size which does not fit in int
1948 // anyhow. FIXME: integer_type_node is the the C type "int" but is
1949 // not necessarily the Go type "int". They will differ when the C
1950 // type "int" has fewer than 32 bits.
1951 return Gogo::builtin_struct(NULL, "__go_slice", NULL_TREE, 3,
1953 build_pointer_type(element_type_tree),
1960 // Given the tree for a slice type, return the tree for the type of
1961 // the elements of the slice.
1964 Gogo::slice_element_type_tree(tree slice_type_tree)
1966 gcc_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE
1967 && POINTER_TYPE_P(TREE_TYPE(TYPE_FIELDS(slice_type_tree))));
1968 return TREE_TYPE(TREE_TYPE(TYPE_FIELDS(slice_type_tree)));
1971 // Build a constructor for a slice. SLICE_TYPE_TREE is the type of
1972 // the slice. VALUES is the value pointer and COUNT is the number of
1973 // entries. If CAPACITY is not NULL, it is the capacity; otherwise
1974 // the capacity and the count are the same.
1977 Gogo::slice_constructor(tree slice_type_tree, tree values, tree count,
1980 gcc_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE);
1982 VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
1984 tree field = TYPE_FIELDS(slice_type_tree);
1985 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
1986 constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
1988 gcc_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field))
1989 == TYPE_MAIN_VARIANT(TREE_TYPE(values)));
1990 elt->value = values;
1992 count = fold_convert(sizetype, count);
1993 if (capacity == NULL_TREE)
1995 count = save_expr(count);
1999 field = DECL_CHAIN(field);
2000 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
2001 elt = VEC_quick_push(constructor_elt, init, NULL);
2003 elt->value = fold_convert(TREE_TYPE(field), count);
2005 field = DECL_CHAIN(field);
2006 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
2007 elt = VEC_quick_push(constructor_elt, init, NULL);
2009 elt->value = fold_convert(TREE_TYPE(field), capacity);
2011 return build_constructor(slice_type_tree, init);
2014 // Build a constructor for an empty slice.
2017 Gogo::empty_slice_constructor(tree slice_type_tree)
2019 tree element_field = TYPE_FIELDS(slice_type_tree);
2020 tree ret = Gogo::slice_constructor(slice_type_tree,
2021 fold_convert(TREE_TYPE(element_field),
2025 TREE_CONSTANT(ret) = 1;
2029 // Build a map descriptor for a map of type MAPTYPE.
2032 Gogo::map_descriptor(Map_type* maptype)
2034 if (this->map_descriptors_ == NULL)
2035 this->map_descriptors_ = new Map_descriptors(10);
2037 std::pair<const Map_type*, tree> val(maptype, NULL);
2038 std::pair<Map_descriptors::iterator, bool> ins =
2039 this->map_descriptors_->insert(val);
2040 Map_descriptors::iterator p = ins.first;
2043 if (p->second == error_mark_node)
2044 return error_mark_node;
2045 gcc_assert(p->second != NULL_TREE && DECL_P(p->second));
2046 return build_fold_addr_expr(p->second);
2049 Type* keytype = maptype->key_type();
2050 Type* valtype = maptype->val_type();
2052 std::string mangled_name = ("__go_map_" + maptype->mangled_name(this));
2054 tree id = get_identifier_from_string(mangled_name);
2056 // Get the type of the map descriptor. This is __go_map_descriptor
2059 tree struct_type = this->map_descriptor_type();
2061 // The map entry type is a struct with three fields. This struct is
2062 // specific to MAPTYPE. Build it.
2064 tree map_entry_type = make_node(RECORD_TYPE);
2066 map_entry_type = Gogo::builtin_struct(NULL, "__map", map_entry_type, 3,
2068 build_pointer_type(map_entry_type),
2070 keytype->get_tree(this),
2072 valtype->get_tree(this));
2073 if (map_entry_type == error_mark_node)
2075 p->second = error_mark_node;
2076 return error_mark_node;
2079 tree map_entry_key_field = DECL_CHAIN(TYPE_FIELDS(map_entry_type));
2080 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_key_field)),
2083 tree map_entry_val_field = DECL_CHAIN(map_entry_key_field);
2084 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_val_field)),
2087 // Initialize the entries.
2089 tree map_descriptor_field = TYPE_FIELDS(struct_type);
2090 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_descriptor_field)),
2091 "__map_descriptor") == 0);
2092 tree entry_size_field = DECL_CHAIN(map_descriptor_field);
2093 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(entry_size_field)),
2094 "__entry_size") == 0);
2095 tree key_offset_field = DECL_CHAIN(entry_size_field);
2096 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(key_offset_field)),
2097 "__key_offset") == 0);
2098 tree val_offset_field = DECL_CHAIN(key_offset_field);
2099 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(val_offset_field)),
2100 "__val_offset") == 0);
2102 VEC(constructor_elt, gc)* descriptor = VEC_alloc(constructor_elt, gc, 6);
2104 constructor_elt* elt = VEC_quick_push(constructor_elt, descriptor, NULL);
2105 elt->index = map_descriptor_field;
2106 elt->value = maptype->type_descriptor_pointer(this);
2108 elt = VEC_quick_push(constructor_elt, descriptor, NULL);
2109 elt->index = entry_size_field;
2110 elt->value = TYPE_SIZE_UNIT(map_entry_type);
2112 elt = VEC_quick_push(constructor_elt, descriptor, NULL);
2113 elt->index = key_offset_field;
2114 elt->value = byte_position(map_entry_key_field);
2116 elt = VEC_quick_push(constructor_elt, descriptor, NULL);
2117 elt->index = val_offset_field;
2118 elt->value = byte_position(map_entry_val_field);
2120 tree constructor = build_constructor(struct_type, descriptor);
2122 tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, struct_type);
2123 TREE_STATIC(decl) = 1;
2124 TREE_USED(decl) = 1;
2125 TREE_READONLY(decl) = 1;
2126 TREE_CONSTANT(decl) = 1;
2127 DECL_INITIAL(decl) = constructor;
2128 make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
2129 resolve_unique_section(decl, 1, 0);
2131 rest_of_decl_compilation(decl, 1, 0);
2133 go_preserve_from_gc(decl);
2136 return build_fold_addr_expr(decl);
2139 // Return a tree for the type of a map descriptor. This is struct
2140 // __go_map_descriptor in libgo/runtime/map.h. This is the same for
2144 Gogo::map_descriptor_type()
2146 static tree struct_type;
2147 tree dtype = Type::make_type_descriptor_type()->get_tree(this);
2148 dtype = build_qualified_type(dtype, TYPE_QUAL_CONST);
2149 return Gogo::builtin_struct(&struct_type, "__go_map_descriptor", NULL_TREE,
2152 build_pointer_type(dtype),
2161 // Return the name to use for a type descriptor decl for TYPE. This
2162 // is used when TYPE does not have a name.
2165 Gogo::unnamed_type_descriptor_decl_name(const Type* type)
2167 return "__go_td_" + type->mangled_name(this);
2170 // Return the name to use for a type descriptor decl for a type named
2171 // NAME, defined in the function IN_FUNCTION. IN_FUNCTION will
2172 // normally be NULL.
2175 Gogo::type_descriptor_decl_name(const Named_object* no,
2176 const Named_object* in_function)
2178 std::string ret = "__go_tdn_";
2179 if (no->type_value()->is_builtin())
2180 gcc_assert(in_function == NULL);
2183 const std::string& unique_prefix(no->package() == NULL
2184 ? this->unique_prefix()
2185 : no->package()->unique_prefix());
2186 const std::string& package_name(no->package() == NULL
2187 ? this->package_name()
2188 : no->package()->name());
2189 ret.append(unique_prefix);
2191 ret.append(package_name);
2193 if (in_function != NULL)
2195 ret.append(Gogo::unpack_hidden_name(in_function->name()));
2199 ret.append(no->name());
2203 // Where a type descriptor decl should be defined.
2205 Gogo::Type_descriptor_location
2206 Gogo::type_descriptor_location(const Type* type)
2208 const Named_type* name = type->named_type();
2211 if (name->named_object()->package() != NULL)
2213 // This is a named type defined in a different package. The
2214 // descriptor should be defined in that package.
2215 return TYPE_DESCRIPTOR_UNDEFINED;
2217 else if (name->is_builtin())
2219 // We create the descriptor for a builtin type whenever we
2221 return TYPE_DESCRIPTOR_COMMON;
2225 // This is a named type defined in this package. The
2226 // descriptor should be defined here.
2227 return TYPE_DESCRIPTOR_DEFINED;
2232 if (type->points_to() != NULL
2233 && type->points_to()->named_type() != NULL
2234 && type->points_to()->named_type()->named_object()->package() != NULL)
2236 // This is an unnamed pointer to a named type defined in a
2237 // different package. The descriptor should be defined in
2239 return TYPE_DESCRIPTOR_UNDEFINED;
2243 // This is an unnamed type. The descriptor could be defined
2244 // in any package where it is needed, and the linker will
2245 // pick one descriptor to keep.
2246 return TYPE_DESCRIPTOR_COMMON;
2251 // Build a type descriptor decl for TYPE. INITIALIZER is a struct
2252 // composite literal which initializers the type descriptor.
2255 Gogo::build_type_descriptor_decl(const Type* type, Expression* initializer,
2258 const Named_type* name = type->named_type();
2260 // We can have multiple instances of unnamed types, but we only want
2261 // to emit the type descriptor once. We use a hash table to handle
2262 // this. This is not necessary for named types, as they are unique,
2263 // and we store the type descriptor decl in the type itself.
2267 if (this->type_descriptor_decls_ == NULL)
2268 this->type_descriptor_decls_ = new Type_descriptor_decls(10);
2270 std::pair<Type_descriptor_decls::iterator, bool> ins =
2271 this->type_descriptor_decls_->insert(std::make_pair(type, NULL_TREE));
2274 // We've already built a type descriptor for this type.
2275 *pdecl = ins.first->second;
2278 phash = &ins.first->second;
2281 std::string decl_name;
2283 decl_name = this->unnamed_type_descriptor_decl_name(type);
2285 decl_name = this->type_descriptor_decl_name(name->named_object(),
2286 name->in_function());
2287 tree id = get_identifier_from_string(decl_name);
2288 tree descriptor_type_tree = initializer->type()->get_tree(this);
2289 if (descriptor_type_tree == error_mark_node)
2291 *pdecl = error_mark_node;
2294 tree decl = build_decl(name == NULL ? BUILTINS_LOCATION : name->location(),
2296 build_qualified_type(descriptor_type_tree,
2298 TREE_READONLY(decl) = 1;
2299 TREE_CONSTANT(decl) = 1;
2300 DECL_ARTIFICIAL(decl) = 1;
2302 go_preserve_from_gc(decl);
2306 // We store the new DECL now because we may need to refer to it when
2307 // expanding INITIALIZER.
2310 // If appropriate, just refer to the exported type identifier.
2311 Gogo::Type_descriptor_location type_descriptor_location =
2312 this->type_descriptor_location(type);
2313 if (type_descriptor_location == TYPE_DESCRIPTOR_UNDEFINED)
2315 TREE_PUBLIC(decl) = 1;
2316 DECL_EXTERNAL(decl) = 1;
2320 TREE_STATIC(decl) = 1;
2321 TREE_USED(decl) = 1;
2323 Translate_context context(this, NULL, NULL, NULL);
2324 context.set_is_const();
2325 tree constructor = initializer->get_tree(&context);
2327 if (constructor == error_mark_node)
2328 gcc_assert(saw_errors());
2330 DECL_INITIAL(decl) = constructor;
2332 if (type_descriptor_location == TYPE_DESCRIPTOR_DEFINED)
2333 TREE_PUBLIC(decl) = 1;
2336 gcc_assert(type_descriptor_location == TYPE_DESCRIPTOR_COMMON);
2337 make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
2338 resolve_unique_section(decl, 1, 0);
2341 rest_of_decl_compilation(decl, 1, 0);
2344 // Build an interface method table for a type: a list of function
2345 // pointers, one for each interface method. This is used for
2349 Gogo::interface_method_table_for_type(const Interface_type* interface,
2353 const Typed_identifier_list* interface_methods = interface->methods();
2354 gcc_assert(!interface_methods->empty());
2356 std::string mangled_name = ((is_pointer ? "__go_pimt__" : "__go_imt_")
2357 + interface->mangled_name(this)
2359 + type->mangled_name(this));
2361 tree id = get_identifier_from_string(mangled_name);
2363 // See whether this interface has any hidden methods.
2364 bool has_hidden_methods = false;
2365 for (Typed_identifier_list::const_iterator p = interface_methods->begin();
2366 p != interface_methods->end();
2369 if (Gogo::is_hidden_name(p->name()))
2371 has_hidden_methods = true;
2376 // We already know that the named type is convertible to the
2377 // interface. If the interface has hidden methods, and the named
2378 // type is defined in a different package, then the interface
2379 // conversion table will be defined by that other package.
2380 if (has_hidden_methods && type->named_object()->package() != NULL)
2382 tree array_type = build_array_type(const_ptr_type_node, NULL);
2383 tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
2384 TREE_READONLY(decl) = 1;
2385 TREE_CONSTANT(decl) = 1;
2386 TREE_PUBLIC(decl) = 1;
2387 DECL_EXTERNAL(decl) = 1;
2388 go_preserve_from_gc(decl);
2392 size_t count = interface_methods->size();
2393 VEC(constructor_elt, gc)* pointers = VEC_alloc(constructor_elt, gc,
2396 // The first element is the type descriptor.
2397 constructor_elt* elt = VEC_quick_push(constructor_elt, pointers, NULL);
2398 elt->index = size_zero_node;
2403 td_type = Type::make_pointer_type(type);
2404 elt->value = fold_convert(const_ptr_type_node,
2405 td_type->type_descriptor_pointer(this));
2408 for (Typed_identifier_list::const_iterator p = interface_methods->begin();
2409 p != interface_methods->end();
2413 Method* m = type->method_function(p->name(), &is_ambiguous);
2414 gcc_assert(m != NULL);
2416 Named_object* no = m->named_object();
2418 tree fnid = no->get_id(this);
2421 if (no->is_function())
2422 fndecl = no->func_value()->get_or_make_decl(this, no, fnid);
2423 else if (no->is_function_declaration())
2424 fndecl = no->func_declaration_value()->get_or_make_decl(this, no,
2428 fndecl = build_fold_addr_expr(fndecl);
2430 elt = VEC_quick_push(constructor_elt, pointers, NULL);
2431 elt->index = size_int(i);
2432 elt->value = fold_convert(const_ptr_type_node, fndecl);
2434 gcc_assert(i == count + 1);
2436 tree array_type = build_array_type(const_ptr_type_node,
2437 build_index_type(size_int(count)));
2438 tree constructor = build_constructor(array_type, pointers);
2440 tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
2441 TREE_STATIC(decl) = 1;
2442 TREE_USED(decl) = 1;
2443 TREE_READONLY(decl) = 1;
2444 TREE_CONSTANT(decl) = 1;
2445 DECL_INITIAL(decl) = constructor;
2447 // If the interface type has hidden methods, then this is the only
2448 // definition of the table. Otherwise it is a comdat table which
2449 // may be defined in multiple packages.
2450 if (has_hidden_methods)
2451 TREE_PUBLIC(decl) = 1;
2454 make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
2455 resolve_unique_section(decl, 1, 0);
2458 rest_of_decl_compilation(decl, 1, 0);
2460 go_preserve_from_gc(decl);
2465 // Mark a function as a builtin library function.
2468 Gogo::mark_fndecl_as_builtin_library(tree fndecl)
2470 DECL_EXTERNAL(fndecl) = 1;
2471 TREE_PUBLIC(fndecl) = 1;
2472 DECL_ARTIFICIAL(fndecl) = 1;
2473 TREE_NOTHROW(fndecl) = 1;
2474 DECL_VISIBILITY(fndecl) = VISIBILITY_DEFAULT;
2475 DECL_VISIBILITY_SPECIFIED(fndecl) = 1;
2478 // Build a call to a builtin function.
2481 Gogo::call_builtin(tree* pdecl, source_location location, const char* name,
2482 int nargs, tree rettype, ...)
2484 if (rettype == error_mark_node)
2485 return error_mark_node;
2487 tree* types = new tree[nargs];
2488 tree* args = new tree[nargs];
2491 va_start(ap, rettype);
2492 for (int i = 0; i < nargs; ++i)
2494 types[i] = va_arg(ap, tree);
2495 args[i] = va_arg(ap, tree);
2496 if (types[i] == error_mark_node || args[i] == error_mark_node)
2500 return error_mark_node;
2505 if (*pdecl == NULL_TREE)
2507 tree fnid = get_identifier(name);
2509 tree argtypes = NULL_TREE;
2510 tree* pp = &argtypes;
2511 for (int i = 0; i < nargs; ++i)
2513 *pp = tree_cons(NULL_TREE, types[i], NULL_TREE);
2514 pp = &TREE_CHAIN(*pp);
2516 *pp = void_list_node;
2518 tree fntype = build_function_type(rettype, argtypes);
2520 *pdecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL, fnid, fntype);
2521 Gogo::mark_fndecl_as_builtin_library(*pdecl);
2522 go_preserve_from_gc(*pdecl);
2525 tree fnptr = build_fold_addr_expr(*pdecl);
2526 if (CAN_HAVE_LOCATION_P(fnptr))
2527 SET_EXPR_LOCATION(fnptr, location);
2529 tree ret = build_call_array(rettype, fnptr, nargs, args);
2530 SET_EXPR_LOCATION(ret, location);
2538 // Build a call to the runtime error function.
2541 Gogo::runtime_error(int code, source_location location)
2543 static tree runtime_error_fndecl;
2544 tree ret = Gogo::call_builtin(&runtime_error_fndecl,
2546 "__go_runtime_error",
2550 build_int_cst(integer_type_node, code));
2551 if (ret == error_mark_node)
2552 return error_mark_node;
2553 // The runtime error function panics and does not return.
2554 TREE_NOTHROW(runtime_error_fndecl) = 0;
2555 TREE_THIS_VOLATILE(runtime_error_fndecl) = 1;
2559 // Return a tree for receiving a value of type TYPE_TREE on CHANNEL.
2560 // This does a blocking receive and returns the value read from the
2561 // channel. If FOR_SELECT is true, this is being done because it was
2562 // chosen in a select statement.
2565 Gogo::receive_from_channel(tree type_tree, tree channel, bool for_select,
2566 source_location location)
2568 if (type_tree == error_mark_node || channel == error_mark_node)
2569 return error_mark_node;
2571 if (int_size_in_bytes(type_tree) <= 8
2572 && !AGGREGATE_TYPE_P(type_tree)
2573 && !FLOAT_TYPE_P(type_tree))
2575 static tree receive_small_fndecl;
2576 tree call = Gogo::call_builtin(&receive_small_fndecl,
2578 "__go_receive_small",
2586 : boolean_false_node));
2587 if (call == error_mark_node)
2588 return error_mark_node;
2589 // This can panic if there are too many operations on a closed
2591 TREE_NOTHROW(receive_small_fndecl) = 0;
2592 int bitsize = GET_MODE_BITSIZE(TYPE_MODE(type_tree));
2593 tree int_type_tree = go_type_for_size(bitsize, 1);
2594 return fold_convert_loc(location, type_tree,
2595 fold_convert_loc(location, int_type_tree,
2600 tree tmp = create_tmp_var(type_tree, get_name(type_tree));
2601 DECL_IGNORED_P(tmp) = 0;
2602 TREE_ADDRESSABLE(tmp) = 1;
2603 tree make_tmp = build1(DECL_EXPR, void_type_node, tmp);
2604 SET_EXPR_LOCATION(make_tmp, location);
2605 tree tmpaddr = build_fold_addr_expr(tmp);
2606 tmpaddr = fold_convert(ptr_type_node, tmpaddr);
2607 static tree receive_big_fndecl;
2608 tree call = Gogo::call_builtin(&receive_big_fndecl,
2620 : boolean_false_node));
2621 if (call == error_mark_node)
2622 return error_mark_node;
2623 // This can panic if there are too many operations on a closed
2625 TREE_NOTHROW(receive_big_fndecl) = 0;
2626 return build2(COMPOUND_EXPR, type_tree, make_tmp,
2627 build2(COMPOUND_EXPR, type_tree, call, tmp));
2631 // Return the type of a function trampoline. This is like
2632 // get_trampoline_type in tree-nested.c.
2635 Gogo::trampoline_type_tree()
2637 static tree type_tree;
2638 if (type_tree == NULL_TREE)
2642 go_trampoline_info(&size, &align);
2643 tree t = build_index_type(build_int_cst(integer_type_node, size - 1));
2644 t = build_array_type(char_type_node, t);
2646 type_tree = Gogo::builtin_struct(NULL, "__go_trampoline", NULL_TREE, 1,
2648 t = TYPE_FIELDS(type_tree);
2649 DECL_ALIGN(t) = align;
2650 DECL_USER_ALIGN(t) = 1;
2652 go_preserve_from_gc(type_tree);
2657 // Make a trampoline which calls FNADDR passing CLOSURE.
2660 Gogo::make_trampoline(tree fnaddr, tree closure, source_location location)
2662 tree trampoline_type = Gogo::trampoline_type_tree();
2663 tree trampoline_size = TYPE_SIZE_UNIT(trampoline_type);
2665 closure = save_expr(closure);
2667 // We allocate the trampoline using a special function which will
2668 // mark it as executable.
2669 static tree trampoline_fndecl;
2670 tree x = Gogo::call_builtin(&trampoline_fndecl,
2672 "__go_allocate_trampoline",
2678 fold_convert_loc(location, ptr_type_node,
2680 if (x == error_mark_node)
2681 return error_mark_node;
2685 // Initialize the trampoline.
2686 tree ini = build_call_expr(implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE],
2687 3, x, fnaddr, closure);
2689 // On some targets the trampoline address needs to be adjusted. For
2690 // example, when compiling in Thumb mode on the ARM, the address
2691 // needs to have the low bit set.
2692 x = build_call_expr(implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE],
2694 x = fold_convert(TREE_TYPE(fnaddr), x);
2696 return build2(COMPOUND_EXPR, TREE_TYPE(x), ini, x);