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_SYNC_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_SYNC_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_SYNC_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_SYNC_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 go_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 go_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 go_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 go_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 go_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 go_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 go_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 go_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 go_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
= error_mark_node
;
916 Btype
* btype
= type
->get_backend(gogo
);
917 expr_tree
= fold_convert(type_to_tree(btype
), expr_tree
);
920 if (expr_tree
== error_mark_node
)
921 decl
= error_mark_node
;
922 else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree
)))
924 decl
= build_decl(named_constant
->location(), CONST_DECL
,
925 name
, TREE_TYPE(expr_tree
));
926 DECL_INITIAL(decl
) = expr_tree
;
927 TREE_CONSTANT(decl
) = 1;
928 TREE_READONLY(decl
) = 1;
932 // A CONST_DECL is only for an enum constant, so we
933 // shouldn't use for non-integral types. Instead we
934 // just return the constant itself, rather than a
942 case NAMED_OBJECT_TYPE
:
944 Named_type
* named_type
= this->u_
.type_value
;
945 tree type_tree
= type_to_tree(named_type
->get_backend(gogo
));
946 if (type_tree
== error_mark_node
)
947 decl
= error_mark_node
;
950 decl
= TYPE_NAME(type_tree
);
951 go_assert(decl
!= NULL_TREE
);
953 // We need to produce a type descriptor for every named
954 // type, and for a pointer to every named type, since
955 // other files or packages might refer to them. We need
956 // to do this even for hidden types, because they might
957 // still be returned by some function. Simply calling the
958 // type_descriptor method is enough to create the type
959 // descriptor, even though we don't do anything with it.
960 if (this->package_
== NULL
)
962 named_type
->type_descriptor_pointer(gogo
, BUILTINS_LOCATION
);
963 Type
* pn
= Type::make_pointer_type(named_type
);
964 pn
->type_descriptor_pointer(gogo
, BUILTINS_LOCATION
);
970 case NAMED_OBJECT_TYPE_DECLARATION
:
971 error("reference to undefined type %qs",
972 this->message_name().c_str());
973 return error_mark_node
;
975 case NAMED_OBJECT_VAR
:
976 case NAMED_OBJECT_RESULT_VAR
:
977 case NAMED_OBJECT_SINK
:
980 case NAMED_OBJECT_FUNC
:
982 Function
* func
= this->u_
.func_value
;
983 decl
= func
->get_or_make_decl(gogo
, this, name
);
984 if (decl
!= error_mark_node
)
986 if (func
->block() != NULL
)
988 if (DECL_STRUCT_FUNCTION(decl
) == NULL
)
989 push_struct_function(decl
);
991 push_cfun(DECL_STRUCT_FUNCTION(decl
));
993 cfun
->function_end_locus
= func
->block()->end_location();
995 current_function_decl
= decl
;
997 func
->build_tree(gogo
, this);
999 gimplify_function_tree(decl
);
1001 cgraph_finalize_function(decl
, true);
1003 current_function_decl
= NULL_TREE
;
1014 if (TREE_TYPE(decl
) == error_mark_node
)
1015 decl
= error_mark_node
;
1021 if (ret
!= error_mark_node
)
1022 go_preserve_from_gc(ret
);
1027 // Get the initial value of a variable as a tree. This does not
1028 // consider whether the variable is in the heap--it returns the
1029 // initial value as though it were always stored in the stack.
1032 Variable::get_init_tree(Gogo
* gogo
, Named_object
* function
)
1034 go_assert(this->preinit_
== NULL
);
1035 if (this->init_
== NULL
)
1037 go_assert(!this->is_parameter_
);
1038 if (this->is_global_
|| this->is_in_heap())
1040 Btype
* btype
= this->type_
->get_backend(gogo
);
1041 return expr_to_tree(gogo
->backend()->zero_expression(btype
));
1045 Translate_context
context(gogo
, function
, NULL
, NULL
);
1046 tree rhs_tree
= this->init_
->get_tree(&context
);
1047 return Expression::convert_for_assignment(&context
, this->type(),
1048 this->init_
->type(),
1049 rhs_tree
, this->location());
1053 // Get the initial value of a variable when a block is required.
1054 // VAR_DECL is the decl to set; it may be NULL for a sink variable.
1057 Variable::get_init_block(Gogo
* gogo
, Named_object
* function
, tree var_decl
)
1059 go_assert(this->preinit_
!= NULL
);
1061 // We want to add the variable assignment to the end of the preinit
1062 // block. The preinit block may have a TRY_FINALLY_EXPR and a
1063 // TRY_CATCH_EXPR; if it does, we want to add to the end of the
1064 // regular statements.
1066 Translate_context
context(gogo
, function
, NULL
, NULL
);
1067 Bblock
* bblock
= this->preinit_
->get_backend(&context
);
1068 tree block_tree
= block_to_tree(bblock
);
1069 if (block_tree
== error_mark_node
)
1070 return error_mark_node
;
1071 go_assert(TREE_CODE(block_tree
) == BIND_EXPR
);
1072 tree statements
= BIND_EXPR_BODY(block_tree
);
1073 while (statements
!= NULL_TREE
1074 && (TREE_CODE(statements
) == TRY_FINALLY_EXPR
1075 || TREE_CODE(statements
) == TRY_CATCH_EXPR
))
1076 statements
= TREE_OPERAND(statements
, 0);
1078 // It's possible to have pre-init statements without an initializer
1079 // if the pre-init statements set the variable.
1080 if (this->init_
!= NULL
)
1082 tree rhs_tree
= this->init_
->get_tree(&context
);
1083 if (rhs_tree
== error_mark_node
)
1084 return error_mark_node
;
1085 if (var_decl
== NULL_TREE
)
1086 append_to_statement_list(rhs_tree
, &statements
);
1089 tree val
= Expression::convert_for_assignment(&context
, this->type(),
1090 this->init_
->type(),
1093 if (val
== error_mark_node
)
1094 return error_mark_node
;
1095 tree set
= fold_build2_loc(this->location(), MODIFY_EXPR
,
1096 void_type_node
, var_decl
, val
);
1097 append_to_statement_list(set
, &statements
);
1104 // Get a tree for a function decl.
1107 Function::get_or_make_decl(Gogo
* gogo
, Named_object
* no
, tree id
)
1109 if (this->fndecl_
== NULL_TREE
)
1111 tree functype
= type_to_tree(this->type_
->get_backend(gogo
));
1112 if (functype
== error_mark_node
)
1113 this->fndecl_
= error_mark_node
;
1116 // The type of a function comes back as a pointer, but we
1117 // want the real function type for a function declaration.
1118 go_assert(POINTER_TYPE_P(functype
));
1119 functype
= TREE_TYPE(functype
);
1120 tree decl
= build_decl(this->location(), FUNCTION_DECL
, id
, functype
);
1122 this->fndecl_
= decl
;
1124 if (no
->package() != NULL
)
1126 else if (this->enclosing_
!= NULL
|| Gogo::is_thunk(no
))
1128 else if (Gogo::unpack_hidden_name(no
->name()) == "init"
1129 && !this->type_
->is_method())
1131 else if (Gogo::unpack_hidden_name(no
->name()) == "main"
1132 && gogo
->is_main_package())
1133 TREE_PUBLIC(decl
) = 1;
1134 // Methods have to be public even if they are hidden because
1135 // they can be pulled into type descriptors when using
1136 // anonymous fields.
1137 else if (!Gogo::is_hidden_name(no
->name())
1138 || this->type_
->is_method())
1140 TREE_PUBLIC(decl
) = 1;
1141 std::string asm_name
= gogo
->unique_prefix();
1142 asm_name
.append(1, '.');
1143 asm_name
.append(IDENTIFIER_POINTER(id
), IDENTIFIER_LENGTH(id
));
1144 SET_DECL_ASSEMBLER_NAME(decl
,
1145 get_identifier_from_string(asm_name
));
1148 // Why do we have to do this in the frontend?
1149 tree restype
= TREE_TYPE(functype
);
1150 tree resdecl
= build_decl(this->location(), RESULT_DECL
, NULL_TREE
,
1152 DECL_ARTIFICIAL(resdecl
) = 1;
1153 DECL_IGNORED_P(resdecl
) = 1;
1154 DECL_CONTEXT(resdecl
) = decl
;
1155 DECL_RESULT(decl
) = resdecl
;
1157 if (this->enclosing_
!= NULL
)
1158 DECL_STATIC_CHAIN(decl
) = 1;
1160 // If a function calls the predeclared recover function, we
1161 // can't inline it, because recover behaves differently in a
1162 // function passed directly to defer. If this is a recover
1163 // thunk that we built to test whether a function can be
1164 // recovered, we can't inline it, because that will mess up
1165 // our return address comparison.
1166 if (this->calls_recover_
|| this->is_recover_thunk_
)
1167 DECL_UNINLINABLE(decl
) = 1;
1169 // If this is a thunk created to call a function which calls
1170 // the predeclared recover function, we need to disable
1171 // stack splitting for the thunk.
1172 if (this->is_recover_thunk_
)
1174 tree attr
= get_identifier("__no_split_stack__");
1175 DECL_ATTRIBUTES(decl
) = tree_cons(attr
, NULL_TREE
, NULL_TREE
);
1178 go_preserve_from_gc(decl
);
1180 if (this->closure_var_
!= NULL
)
1182 push_struct_function(decl
);
1184 Bvariable
* bvar
= this->closure_var_
->get_backend_variable(gogo
,
1186 tree closure_decl
= var_to_tree(bvar
);
1187 if (closure_decl
== error_mark_node
)
1188 this->fndecl_
= error_mark_node
;
1191 DECL_ARTIFICIAL(closure_decl
) = 1;
1192 DECL_IGNORED_P(closure_decl
) = 1;
1193 TREE_USED(closure_decl
) = 1;
1194 DECL_ARG_TYPE(closure_decl
) = TREE_TYPE(closure_decl
);
1195 TREE_READONLY(closure_decl
) = 1;
1197 DECL_STRUCT_FUNCTION(decl
)->static_chain_decl
= closure_decl
;
1204 return this->fndecl_
;
1207 // Get a tree for a function declaration.
1210 Function_declaration::get_or_make_decl(Gogo
* gogo
, Named_object
* no
, tree id
)
1212 if (this->fndecl_
== NULL_TREE
)
1214 // Let Go code use an asm declaration to pick up a builtin
1216 if (!this->asm_name_
.empty())
1218 std::map
<std::string
, tree
>::const_iterator p
=
1219 builtin_functions
.find(this->asm_name_
);
1220 if (p
!= builtin_functions
.end())
1222 this->fndecl_
= p
->second
;
1223 return this->fndecl_
;
1227 tree functype
= type_to_tree(this->fntype_
->get_backend(gogo
));
1229 if (functype
== error_mark_node
)
1230 decl
= error_mark_node
;
1233 // The type of a function comes back as a pointer, but we
1234 // want the real function type for a function declaration.
1235 go_assert(POINTER_TYPE_P(functype
));
1236 functype
= TREE_TYPE(functype
);
1237 decl
= build_decl(this->location(), FUNCTION_DECL
, id
, functype
);
1238 TREE_PUBLIC(decl
) = 1;
1239 DECL_EXTERNAL(decl
) = 1;
1241 if (this->asm_name_
.empty())
1243 std::string asm_name
= (no
->package() == NULL
1244 ? gogo
->unique_prefix()
1245 : no
->package()->unique_prefix());
1246 asm_name
.append(1, '.');
1247 asm_name
.append(IDENTIFIER_POINTER(id
), IDENTIFIER_LENGTH(id
));
1248 SET_DECL_ASSEMBLER_NAME(decl
,
1249 get_identifier_from_string(asm_name
));
1252 this->fndecl_
= decl
;
1253 go_preserve_from_gc(decl
);
1255 return this->fndecl_
;
1258 // We always pass the receiver to a method as a pointer. If the
1259 // receiver is actually declared as a non-pointer type, then we copy
1260 // the value into a local variable, so that it has the right type. In
1261 // this function we create the real PARM_DECL to use, and set
1262 // DEC_INITIAL of the var_decl to be the value passed in.
1265 Function::make_receiver_parm_decl(Gogo
* gogo
, Named_object
* no
, tree var_decl
)
1267 if (var_decl
== error_mark_node
)
1268 return error_mark_node
;
1269 go_assert(TREE_CODE(var_decl
) == VAR_DECL
);
1270 tree val_type
= TREE_TYPE(var_decl
);
1271 bool is_in_heap
= no
->var_value()->is_in_heap();
1274 go_assert(POINTER_TYPE_P(val_type
));
1275 val_type
= TREE_TYPE(val_type
);
1278 source_location loc
= DECL_SOURCE_LOCATION(var_decl
);
1279 std::string name
= IDENTIFIER_POINTER(DECL_NAME(var_decl
));
1281 tree id
= get_identifier_from_string(name
);
1282 tree parm_decl
= build_decl(loc
, PARM_DECL
, id
, build_pointer_type(val_type
));
1283 DECL_CONTEXT(parm_decl
) = current_function_decl
;
1284 DECL_ARG_TYPE(parm_decl
) = TREE_TYPE(parm_decl
);
1286 go_assert(DECL_INITIAL(var_decl
) == NULL_TREE
);
1287 tree init
= build_fold_indirect_ref_loc(loc
, parm_decl
);
1291 tree size
= TYPE_SIZE_UNIT(val_type
);
1292 tree space
= gogo
->allocate_memory(no
->var_value()->type(), size
,
1294 space
= save_expr(space
);
1295 space
= fold_convert(build_pointer_type(val_type
), space
);
1296 tree spaceref
= build_fold_indirect_ref_loc(no
->location(), space
);
1297 TREE_THIS_NOTRAP(spaceref
) = 1;
1298 tree set
= fold_build2_loc(loc
, MODIFY_EXPR
, void_type_node
,
1300 init
= fold_build2_loc(loc
, COMPOUND_EXPR
, TREE_TYPE(space
), set
, space
);
1303 DECL_INITIAL(var_decl
) = init
;
1308 // If we take the address of a parameter, then we need to copy it into
1309 // the heap. We will access it as a local variable via an
1313 Function::copy_parm_to_heap(Gogo
* gogo
, Named_object
* no
, tree var_decl
)
1315 if (var_decl
== error_mark_node
)
1316 return error_mark_node
;
1317 go_assert(TREE_CODE(var_decl
) == VAR_DECL
);
1318 source_location loc
= DECL_SOURCE_LOCATION(var_decl
);
1320 std::string name
= IDENTIFIER_POINTER(DECL_NAME(var_decl
));
1322 tree id
= get_identifier_from_string(name
);
1324 tree type
= TREE_TYPE(var_decl
);
1325 go_assert(POINTER_TYPE_P(type
));
1326 type
= TREE_TYPE(type
);
1328 tree parm_decl
= build_decl(loc
, PARM_DECL
, id
, type
);
1329 DECL_CONTEXT(parm_decl
) = current_function_decl
;
1330 DECL_ARG_TYPE(parm_decl
) = type
;
1332 tree size
= TYPE_SIZE_UNIT(type
);
1333 tree space
= gogo
->allocate_memory(no
->var_value()->type(), size
, loc
);
1334 space
= save_expr(space
);
1335 space
= fold_convert(TREE_TYPE(var_decl
), space
);
1336 tree spaceref
= build_fold_indirect_ref_loc(loc
, space
);
1337 TREE_THIS_NOTRAP(spaceref
) = 1;
1338 tree init
= build2(COMPOUND_EXPR
, TREE_TYPE(space
),
1339 build2(MODIFY_EXPR
, void_type_node
, spaceref
, parm_decl
),
1341 DECL_INITIAL(var_decl
) = init
;
1346 // Get a tree for function code.
1349 Function::build_tree(Gogo
* gogo
, Named_object
* named_function
)
1351 tree fndecl
= this->fndecl_
;
1352 go_assert(fndecl
!= NULL_TREE
);
1354 tree params
= NULL_TREE
;
1357 tree declare_vars
= NULL_TREE
;
1358 for (Bindings::const_definitions_iterator p
=
1359 this->block_
->bindings()->begin_definitions();
1360 p
!= this->block_
->bindings()->end_definitions();
1363 if ((*p
)->is_variable() && (*p
)->var_value()->is_parameter())
1365 Bvariable
* bvar
= (*p
)->get_backend_variable(gogo
, named_function
);
1366 *pp
= var_to_tree(bvar
);
1368 // We always pass the receiver to a method as a pointer. If
1369 // the receiver is declared as a non-pointer type, then we
1370 // copy the value into a local variable.
1371 if ((*p
)->var_value()->is_receiver()
1372 && (*p
)->var_value()->type()->points_to() == NULL
)
1374 tree parm_decl
= this->make_receiver_parm_decl(gogo
, *p
, *pp
);
1376 if (var
!= error_mark_node
)
1378 go_assert(TREE_CODE(var
) == VAR_DECL
);
1379 DECL_CHAIN(var
) = declare_vars
;
1384 else if ((*p
)->var_value()->is_in_heap())
1386 // If we take the address of a parameter, then we need
1387 // to copy it into the heap.
1388 tree parm_decl
= this->copy_parm_to_heap(gogo
, *p
, *pp
);
1390 if (var
!= error_mark_node
)
1392 go_assert(TREE_CODE(var
) == VAR_DECL
);
1393 DECL_CHAIN(var
) = declare_vars
;
1399 if (*pp
!= error_mark_node
)
1401 go_assert(TREE_CODE(*pp
) == PARM_DECL
);
1402 pp
= &DECL_CHAIN(*pp
);
1405 else if ((*p
)->is_result_variable())
1407 Bvariable
* bvar
= (*p
)->get_backend_variable(gogo
, named_function
);
1408 tree var_decl
= var_to_tree(bvar
);
1410 Type
* type
= (*p
)->result_var_value()->type();
1412 if (!(*p
)->result_var_value()->is_in_heap())
1414 Btype
* btype
= type
->get_backend(gogo
);
1415 init
= expr_to_tree(gogo
->backend()->zero_expression(btype
));
1419 source_location loc
= (*p
)->location();
1420 tree type_tree
= type_to_tree(type
->get_backend(gogo
));
1421 tree space
= gogo
->allocate_memory(type
,
1422 TYPE_SIZE_UNIT(type_tree
),
1424 tree ptr_type_tree
= build_pointer_type(type_tree
);
1425 init
= fold_convert_loc(loc
, ptr_type_tree
, space
);
1428 if (var_decl
!= error_mark_node
)
1430 go_assert(TREE_CODE(var_decl
) == VAR_DECL
);
1431 DECL_INITIAL(var_decl
) = init
;
1432 DECL_CHAIN(var_decl
) = declare_vars
;
1433 declare_vars
= var_decl
;
1439 DECL_ARGUMENTS(fndecl
) = params
;
1441 if (this->block_
!= NULL
)
1443 go_assert(DECL_INITIAL(fndecl
) == NULL_TREE
);
1445 // Declare variables if necessary.
1446 tree bind
= NULL_TREE
;
1447 tree defer_init
= NULL_TREE
;
1448 if (declare_vars
!= NULL_TREE
|| this->defer_stack_
!= NULL
)
1450 tree block
= make_node(BLOCK
);
1451 BLOCK_SUPERCONTEXT(block
) = fndecl
;
1452 DECL_INITIAL(fndecl
) = block
;
1453 BLOCK_VARS(block
) = declare_vars
;
1454 TREE_USED(block
) = 1;
1456 bind
= build3(BIND_EXPR
, void_type_node
, BLOCK_VARS(block
),
1458 TREE_SIDE_EFFECTS(bind
) = 1;
1460 if (this->defer_stack_
!= NULL
)
1462 Translate_context
dcontext(gogo
, named_function
, this->block_
,
1463 tree_to_block(bind
));
1464 Bstatement
* bdi
= this->defer_stack_
->get_backend(&dcontext
);
1465 defer_init
= stat_to_tree(bdi
);
1469 // Build the trees for all the statements in the function.
1470 Translate_context
context(gogo
, named_function
, NULL
, NULL
);
1471 Bblock
* bblock
= this->block_
->get_backend(&context
);
1472 tree code
= block_to_tree(bblock
);
1474 tree init
= NULL_TREE
;
1475 tree except
= NULL_TREE
;
1476 tree fini
= NULL_TREE
;
1478 // Initialize variables if necessary.
1479 for (tree v
= declare_vars
; v
!= NULL_TREE
; v
= DECL_CHAIN(v
))
1481 tree dv
= build1(DECL_EXPR
, void_type_node
, v
);
1482 SET_EXPR_LOCATION(dv
, DECL_SOURCE_LOCATION(v
));
1483 append_to_statement_list(dv
, &init
);
1486 // If we have a defer stack, initialize it at the start of a
1488 if (defer_init
!= NULL_TREE
&& defer_init
!= error_mark_node
)
1490 SET_EXPR_LOCATION(defer_init
, this->block_
->start_location());
1491 append_to_statement_list(defer_init
, &init
);
1493 // Clean up the defer stack when we leave the function.
1494 this->build_defer_wrapper(gogo
, named_function
, &except
, &fini
);
1497 if (code
!= NULL_TREE
&& code
!= error_mark_node
)
1499 if (init
!= NULL_TREE
)
1500 code
= build2(COMPOUND_EXPR
, void_type_node
, init
, code
);
1501 if (except
!= NULL_TREE
)
1502 code
= build2(TRY_CATCH_EXPR
, void_type_node
, code
,
1503 build2(CATCH_EXPR
, void_type_node
, NULL
, except
));
1504 if (fini
!= NULL_TREE
)
1505 code
= build2(TRY_FINALLY_EXPR
, void_type_node
, code
, fini
);
1508 // Stick the code into the block we built for the receiver, if
1510 if (bind
!= NULL_TREE
&& code
!= NULL_TREE
&& code
!= error_mark_node
)
1512 BIND_EXPR_BODY(bind
) = code
;
1516 DECL_SAVED_TREE(fndecl
) = code
;
1520 // Build the wrappers around function code needed if the function has
1521 // any defer statements. This sets *EXCEPT to an exception handler
1522 // and *FINI to a finally handler.
1525 Function::build_defer_wrapper(Gogo
* gogo
, Named_object
* named_function
,
1526 tree
*except
, tree
*fini
)
1528 source_location end_loc
= this->block_
->end_location();
1530 // Add an exception handler. This is used if a panic occurs. Its
1531 // purpose is to stop the stack unwinding if a deferred function
1532 // calls recover. There are more details in
1533 // libgo/runtime/go-unwind.c.
1535 tree stmt_list
= NULL_TREE
;
1537 Expression
* call
= Runtime::make_call(Runtime::CHECK_DEFER
, end_loc
, 1,
1538 this->defer_stack(end_loc
));
1539 Translate_context
context(gogo
, named_function
, NULL
, NULL
);
1540 tree call_tree
= call
->get_tree(&context
);
1541 if (call_tree
!= error_mark_node
)
1542 append_to_statement_list(call_tree
, &stmt_list
);
1544 tree retval
= this->return_value(gogo
, named_function
, end_loc
, &stmt_list
);
1546 if (retval
== NULL_TREE
)
1549 set
= fold_build2_loc(end_loc
, MODIFY_EXPR
, void_type_node
,
1550 DECL_RESULT(this->fndecl_
), retval
);
1551 tree ret_stmt
= fold_build1_loc(end_loc
, RETURN_EXPR
, void_type_node
, set
);
1552 append_to_statement_list(ret_stmt
, &stmt_list
);
1554 go_assert(*except
== NULL_TREE
);
1555 *except
= stmt_list
;
1557 // Add some finally code to run the defer functions. This is used
1558 // both in the normal case, when no panic occurs, and also if a
1559 // panic occurs to run any further defer functions. Of course, it
1560 // is possible for a defer function to call panic which should be
1561 // caught by another defer function. To handle that we use a loop.
1563 // try { __go_undefer(); } catch { __go_check_defer(); goto finish; }
1564 // if (return values are named) return named_vals;
1568 tree label
= create_artificial_label(end_loc
);
1569 tree define_label
= fold_build1_loc(end_loc
, LABEL_EXPR
, void_type_node
,
1571 append_to_statement_list(define_label
, &stmt_list
);
1573 call
= Runtime::make_call(Runtime::UNDEFER
, end_loc
, 1,
1574 this->defer_stack(end_loc
));
1575 tree undefer
= call
->get_tree(&context
);
1577 call
= Runtime::make_call(Runtime::CHECK_DEFER
, end_loc
, 1,
1578 this->defer_stack(end_loc
));
1579 tree defer
= call
->get_tree(&context
);
1581 if (undefer
== error_mark_node
|| defer
== error_mark_node
)
1584 tree jump
= fold_build1_loc(end_loc
, GOTO_EXPR
, void_type_node
, label
);
1585 tree catch_body
= build2(COMPOUND_EXPR
, void_type_node
, defer
, jump
);
1586 catch_body
= build2(CATCH_EXPR
, void_type_node
, NULL
, catch_body
);
1587 tree try_catch
= build2(TRY_CATCH_EXPR
, void_type_node
, undefer
, catch_body
);
1589 append_to_statement_list(try_catch
, &stmt_list
);
1591 if (this->type_
->results() != NULL
1592 && !this->type_
->results()->empty()
1593 && !this->type_
->results()->front().name().empty())
1595 // If the result variables are named, we need to return them
1596 // again, because they might have been changed by a defer
1598 retval
= this->return_value(gogo
, named_function
, end_loc
,
1600 set
= fold_build2_loc(end_loc
, MODIFY_EXPR
, void_type_node
,
1601 DECL_RESULT(this->fndecl_
), retval
);
1602 ret_stmt
= fold_build1_loc(end_loc
, RETURN_EXPR
, void_type_node
, set
);
1603 append_to_statement_list(ret_stmt
, &stmt_list
);
1606 go_assert(*fini
== NULL_TREE
);
1610 // Return the value to assign to DECL_RESULT(this->fndecl_). This may
1611 // also add statements to STMT_LIST, which need to be executed before
1612 // the assignment. This is used for a return statement with no
1616 Function::return_value(Gogo
* gogo
, Named_object
* named_function
,
1617 source_location location
, tree
* stmt_list
) const
1619 const Typed_identifier_list
* results
= this->type_
->results();
1620 if (results
== NULL
|| results
->empty())
1623 go_assert(this->results_
!= NULL
);
1624 if (this->results_
->size() != results
->size())
1626 go_assert(saw_errors());
1627 return error_mark_node
;
1631 if (results
->size() == 1)
1634 this->results_
->front()->get_backend_variable(gogo
,
1636 tree ret
= var_to_tree(bvar
);
1637 if (this->results_
->front()->result_var_value()->is_in_heap())
1638 ret
= build_fold_indirect_ref_loc(location
, ret
);
1643 tree rettype
= TREE_TYPE(DECL_RESULT(this->fndecl_
));
1644 retval
= create_tmp_var(rettype
, "RESULT");
1645 tree field
= TYPE_FIELDS(rettype
);
1647 for (Typed_identifier_list::const_iterator pr
= results
->begin();
1648 pr
!= results
->end();
1649 ++pr
, ++index
, field
= DECL_CHAIN(field
))
1651 go_assert(field
!= NULL
);
1652 Named_object
* no
= (*this->results_
)[index
];
1653 Bvariable
* bvar
= no
->get_backend_variable(gogo
, named_function
);
1654 tree val
= var_to_tree(bvar
);
1655 if (no
->result_var_value()->is_in_heap())
1656 val
= build_fold_indirect_ref_loc(location
, val
);
1657 tree set
= fold_build2_loc(location
, MODIFY_EXPR
, void_type_node
,
1658 build3(COMPONENT_REF
, TREE_TYPE(field
),
1659 retval
, field
, NULL_TREE
),
1661 append_to_statement_list(set
, stmt_list
);
1667 // Return the integer type to use for a size.
1671 go_type_for_size(unsigned int bits
, int unsignedp
)
1677 name
= unsignedp
? "uint8" : "int8";
1680 name
= unsignedp
? "uint16" : "int16";
1683 name
= unsignedp
? "uint32" : "int32";
1686 name
= unsignedp
? "uint64" : "int64";
1689 if (bits
== POINTER_SIZE
&& unsignedp
)
1694 Type
* type
= Type::lookup_integer_type(name
);
1695 return type_to_tree(type
->get_backend(go_get_gogo()));
1698 // Return the type to use for a mode.
1702 go_type_for_mode(enum machine_mode mode
, int unsignedp
)
1704 // FIXME: This static_cast should be in machmode.h.
1705 enum mode_class mc
= static_cast<enum mode_class
>(GET_MODE_CLASS(mode
));
1707 return go_type_for_size(GET_MODE_BITSIZE(mode
), unsignedp
);
1708 else if (mc
== MODE_FLOAT
)
1711 switch (GET_MODE_BITSIZE (mode
))
1714 type
= Type::lookup_float_type("float32");
1717 type
= Type::lookup_float_type("float64");
1720 // We have to check for long double in order to support
1721 // i386 excess precision.
1722 if (mode
== TYPE_MODE(long_double_type_node
))
1723 return long_double_type_node
;
1726 return type_to_tree(type
->get_backend(go_get_gogo()));
1728 else if (mc
== MODE_COMPLEX_FLOAT
)
1731 switch (GET_MODE_BITSIZE (mode
))
1734 type
= Type::lookup_complex_type("complex64");
1737 type
= Type::lookup_complex_type("complex128");
1740 // We have to check for long double in order to support
1741 // i386 excess precision.
1742 if (mode
== TYPE_MODE(complex_long_double_type_node
))
1743 return complex_long_double_type_node
;
1746 return type_to_tree(type
->get_backend(go_get_gogo()));
1752 // Return a tree which allocates SIZE bytes which will holds value of
1756 Gogo::allocate_memory(Type
* type
, tree size
, source_location location
)
1758 // If the package imports unsafe, then it may play games with
1759 // pointers that look like integers.
1760 if (this->imported_unsafe_
|| type
->has_pointer())
1762 static tree new_fndecl
;
1763 return Gogo::call_builtin(&new_fndecl
,
1773 static tree new_nopointers_fndecl
;
1774 return Gogo::call_builtin(&new_nopointers_fndecl
,
1776 "__go_new_nopointers",
1784 // Build a builtin struct with a list of fields. The name is
1785 // STRUCT_NAME. STRUCT_TYPE is NULL_TREE or an empty RECORD_TYPE
1786 // node; this exists so that the struct can have fields which point to
1787 // itself. If PTYPE is not NULL, store the result in *PTYPE. There
1788 // are NFIELDS fields. Each field is a name (a const char*) followed
1789 // by a type (a tree).
1792 Gogo::builtin_struct(tree
* ptype
, const char* struct_name
, tree struct_type
,
1795 if (ptype
!= NULL
&& *ptype
!= NULL_TREE
)
1799 va_start(ap
, nfields
);
1801 tree fields
= NULL_TREE
;
1802 for (int i
= 0; i
< nfields
; ++i
)
1804 const char* field_name
= va_arg(ap
, const char*);
1805 tree type
= va_arg(ap
, tree
);
1806 if (type
== error_mark_node
)
1809 *ptype
= error_mark_node
;
1810 return error_mark_node
;
1812 tree field
= build_decl(BUILTINS_LOCATION
, FIELD_DECL
,
1813 get_identifier(field_name
), type
);
1814 DECL_CHAIN(field
) = fields
;
1820 if (struct_type
== NULL_TREE
)
1821 struct_type
= make_node(RECORD_TYPE
);
1822 finish_builtin_struct(struct_type
, struct_name
, fields
, NULL_TREE
);
1826 go_preserve_from_gc(struct_type
);
1827 *ptype
= struct_type
;
1833 // Return a type to use for pointer to const char for a string.
1836 Gogo::const_char_pointer_type_tree()
1839 if (type
== NULL_TREE
)
1841 tree const_char_type
= build_qualified_type(unsigned_char_type_node
,
1843 type
= build_pointer_type(const_char_type
);
1844 go_preserve_from_gc(type
);
1849 // Return a tree for a string constant.
1852 Gogo::string_constant_tree(const std::string
& val
)
1854 tree index_type
= build_index_type(size_int(val
.length()));
1855 tree const_char_type
= build_qualified_type(unsigned_char_type_node
,
1857 tree string_type
= build_array_type(const_char_type
, index_type
);
1858 string_type
= build_variant_type_copy(string_type
);
1859 TYPE_STRING_FLAG(string_type
) = 1;
1860 tree string_val
= build_string(val
.length(), val
.data());
1861 TREE_TYPE(string_val
) = string_type
;
1865 // Return a tree for a Go string constant.
1868 Gogo::go_string_constant_tree(const std::string
& val
)
1870 tree string_type
= type_to_tree(Type::make_string_type()->get_backend(this));
1872 VEC(constructor_elt
, gc
)* init
= VEC_alloc(constructor_elt
, gc
, 2);
1874 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
1875 tree field
= TYPE_FIELDS(string_type
);
1876 go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__data") == 0);
1878 tree str
= Gogo::string_constant_tree(val
);
1879 elt
->value
= fold_convert(TREE_TYPE(field
),
1880 build_fold_addr_expr(str
));
1882 elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
1883 field
= DECL_CHAIN(field
);
1884 go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__length") == 0);
1886 elt
->value
= build_int_cst_type(TREE_TYPE(field
), val
.length());
1888 tree constructor
= build_constructor(string_type
, init
);
1889 TREE_READONLY(constructor
) = 1;
1890 TREE_CONSTANT(constructor
) = 1;
1895 // Return a tree for a pointer to a Go string constant. This is only
1896 // used for type descriptors, so we return a pointer to a constant
1900 Gogo::ptr_go_string_constant_tree(const std::string
& val
)
1902 tree pval
= this->go_string_constant_tree(val
);
1904 tree decl
= build_decl(UNKNOWN_LOCATION
, VAR_DECL
,
1905 create_tmp_var_name("SP"), TREE_TYPE(pval
));
1906 DECL_EXTERNAL(decl
) = 0;
1907 TREE_PUBLIC(decl
) = 0;
1908 TREE_USED(decl
) = 1;
1909 TREE_READONLY(decl
) = 1;
1910 TREE_CONSTANT(decl
) = 1;
1911 TREE_STATIC(decl
) = 1;
1912 DECL_ARTIFICIAL(decl
) = 1;
1913 DECL_INITIAL(decl
) = pval
;
1914 rest_of_decl_compilation(decl
, 1, 0);
1916 return build_fold_addr_expr(decl
);
1919 // Build a constructor for a slice. SLICE_TYPE_TREE is the type of
1920 // the slice. VALUES is the value pointer and COUNT is the number of
1921 // entries. If CAPACITY is not NULL, it is the capacity; otherwise
1922 // the capacity and the count are the same.
1925 Gogo::slice_constructor(tree slice_type_tree
, tree values
, tree count
,
1928 go_assert(TREE_CODE(slice_type_tree
) == RECORD_TYPE
);
1930 VEC(constructor_elt
,gc
)* init
= VEC_alloc(constructor_elt
, gc
, 3);
1932 tree field
= TYPE_FIELDS(slice_type_tree
);
1933 go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__values") == 0);
1934 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
1936 go_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field
))
1937 == TYPE_MAIN_VARIANT(TREE_TYPE(values
)));
1938 elt
->value
= values
;
1940 count
= fold_convert(sizetype
, count
);
1941 if (capacity
== NULL_TREE
)
1943 count
= save_expr(count
);
1947 field
= DECL_CHAIN(field
);
1948 go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__count") == 0);
1949 elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
1951 elt
->value
= fold_convert(TREE_TYPE(field
), count
);
1953 field
= DECL_CHAIN(field
);
1954 go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__capacity") == 0);
1955 elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
1957 elt
->value
= fold_convert(TREE_TYPE(field
), capacity
);
1959 return build_constructor(slice_type_tree
, init
);
1962 // Build an interface method table for a type: a list of function
1963 // pointers, one for each interface method. This is used for
1967 Gogo::interface_method_table_for_type(const Interface_type
* interface
,
1971 const Typed_identifier_list
* interface_methods
= interface
->methods();
1972 go_assert(!interface_methods
->empty());
1974 std::string mangled_name
= ((is_pointer
? "__go_pimt__" : "__go_imt_")
1975 + interface
->mangled_name(this)
1977 + type
->mangled_name(this));
1979 tree id
= get_identifier_from_string(mangled_name
);
1981 // See whether this interface has any hidden methods.
1982 bool has_hidden_methods
= false;
1983 for (Typed_identifier_list::const_iterator p
= interface_methods
->begin();
1984 p
!= interface_methods
->end();
1987 if (Gogo::is_hidden_name(p
->name()))
1989 has_hidden_methods
= true;
1994 // We already know that the named type is convertible to the
1995 // interface. If the interface has hidden methods, and the named
1996 // type is defined in a different package, then the interface
1997 // conversion table will be defined by that other package.
1998 if (has_hidden_methods
&& type
->named_object()->package() != NULL
)
2000 tree array_type
= build_array_type(const_ptr_type_node
, NULL
);
2001 tree decl
= build_decl(BUILTINS_LOCATION
, VAR_DECL
, id
, array_type
);
2002 TREE_READONLY(decl
) = 1;
2003 TREE_CONSTANT(decl
) = 1;
2004 TREE_PUBLIC(decl
) = 1;
2005 DECL_EXTERNAL(decl
) = 1;
2006 go_preserve_from_gc(decl
);
2010 size_t count
= interface_methods
->size();
2011 VEC(constructor_elt
, gc
)* pointers
= VEC_alloc(constructor_elt
, gc
,
2014 // The first element is the type descriptor.
2015 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, pointers
, NULL
);
2016 elt
->index
= size_zero_node
;
2021 td_type
= Type::make_pointer_type(type
);
2022 tree tdp
= td_type
->type_descriptor_pointer(this, BUILTINS_LOCATION
);
2023 elt
->value
= fold_convert(const_ptr_type_node
, tdp
);
2026 for (Typed_identifier_list::const_iterator p
= interface_methods
->begin();
2027 p
!= interface_methods
->end();
2031 Method
* m
= type
->method_function(p
->name(), &is_ambiguous
);
2032 go_assert(m
!= NULL
);
2034 Named_object
* no
= m
->named_object();
2036 tree fnid
= no
->get_id(this);
2039 if (no
->is_function())
2040 fndecl
= no
->func_value()->get_or_make_decl(this, no
, fnid
);
2041 else if (no
->is_function_declaration())
2042 fndecl
= no
->func_declaration_value()->get_or_make_decl(this, no
,
2046 fndecl
= build_fold_addr_expr(fndecl
);
2048 elt
= VEC_quick_push(constructor_elt
, pointers
, NULL
);
2049 elt
->index
= size_int(i
);
2050 elt
->value
= fold_convert(const_ptr_type_node
, fndecl
);
2052 go_assert(i
== count
+ 1);
2054 tree array_type
= build_array_type(const_ptr_type_node
,
2055 build_index_type(size_int(count
)));
2056 tree constructor
= build_constructor(array_type
, pointers
);
2058 tree decl
= build_decl(BUILTINS_LOCATION
, VAR_DECL
, id
, array_type
);
2059 TREE_STATIC(decl
) = 1;
2060 TREE_USED(decl
) = 1;
2061 TREE_READONLY(decl
) = 1;
2062 TREE_CONSTANT(decl
) = 1;
2063 DECL_INITIAL(decl
) = constructor
;
2065 // If the interface type has hidden methods, then this is the only
2066 // definition of the table. Otherwise it is a comdat table which
2067 // may be defined in multiple packages.
2068 if (has_hidden_methods
)
2069 TREE_PUBLIC(decl
) = 1;
2072 make_decl_one_only(decl
, DECL_ASSEMBLER_NAME(decl
));
2073 resolve_unique_section(decl
, 1, 0);
2076 rest_of_decl_compilation(decl
, 1, 0);
2078 go_preserve_from_gc(decl
);
2083 // Mark a function as a builtin library function.
2086 Gogo::mark_fndecl_as_builtin_library(tree fndecl
)
2088 DECL_EXTERNAL(fndecl
) = 1;
2089 TREE_PUBLIC(fndecl
) = 1;
2090 DECL_ARTIFICIAL(fndecl
) = 1;
2091 TREE_NOTHROW(fndecl
) = 1;
2092 DECL_VISIBILITY(fndecl
) = VISIBILITY_DEFAULT
;
2093 DECL_VISIBILITY_SPECIFIED(fndecl
) = 1;
2096 // Build a call to a builtin function.
2099 Gogo::call_builtin(tree
* pdecl
, source_location location
, const char* name
,
2100 int nargs
, tree rettype
, ...)
2102 if (rettype
== error_mark_node
)
2103 return error_mark_node
;
2105 tree
* types
= new tree
[nargs
];
2106 tree
* args
= new tree
[nargs
];
2109 va_start(ap
, rettype
);
2110 for (int i
= 0; i
< nargs
; ++i
)
2112 types
[i
] = va_arg(ap
, tree
);
2113 args
[i
] = va_arg(ap
, tree
);
2114 if (types
[i
] == error_mark_node
|| args
[i
] == error_mark_node
)
2118 return error_mark_node
;
2123 if (*pdecl
== NULL_TREE
)
2125 tree fnid
= get_identifier(name
);
2127 tree argtypes
= NULL_TREE
;
2128 tree
* pp
= &argtypes
;
2129 for (int i
= 0; i
< nargs
; ++i
)
2131 *pp
= tree_cons(NULL_TREE
, types
[i
], NULL_TREE
);
2132 pp
= &TREE_CHAIN(*pp
);
2134 *pp
= void_list_node
;
2136 tree fntype
= build_function_type(rettype
, argtypes
);
2138 *pdecl
= build_decl(BUILTINS_LOCATION
, FUNCTION_DECL
, fnid
, fntype
);
2139 Gogo::mark_fndecl_as_builtin_library(*pdecl
);
2140 go_preserve_from_gc(*pdecl
);
2143 tree fnptr
= build_fold_addr_expr(*pdecl
);
2144 if (CAN_HAVE_LOCATION_P(fnptr
))
2145 SET_EXPR_LOCATION(fnptr
, location
);
2147 tree ret
= build_call_array(rettype
, fnptr
, nargs
, args
);
2148 SET_EXPR_LOCATION(ret
, location
);
2156 // Build a call to the runtime error function.
2159 Gogo::runtime_error(int code
, source_location location
)
2161 static tree runtime_error_fndecl
;
2162 tree ret
= Gogo::call_builtin(&runtime_error_fndecl
,
2164 "__go_runtime_error",
2168 build_int_cst(integer_type_node
, code
));
2169 if (ret
== error_mark_node
)
2170 return error_mark_node
;
2171 // The runtime error function panics and does not return.
2172 TREE_NOTHROW(runtime_error_fndecl
) = 0;
2173 TREE_THIS_VOLATILE(runtime_error_fndecl
) = 1;
2177 // Return a tree for receiving a value of type TYPE_TREE on CHANNEL.
2178 // This does a blocking receive and returns the value read from the
2179 // channel. If FOR_SELECT is true, this is being done because it was
2180 // chosen in a select statement.
2183 Gogo::receive_from_channel(tree type_tree
, tree channel
, bool for_select
,
2184 source_location location
)
2186 if (type_tree
== error_mark_node
|| channel
== error_mark_node
)
2187 return error_mark_node
;
2189 if (int_size_in_bytes(type_tree
) <= 8
2190 && !AGGREGATE_TYPE_P(type_tree
)
2191 && !FLOAT_TYPE_P(type_tree
))
2193 static tree receive_small_fndecl
;
2194 tree call
= Gogo::call_builtin(&receive_small_fndecl
,
2196 "__go_receive_small",
2204 : boolean_false_node
));
2205 if (call
== error_mark_node
)
2206 return error_mark_node
;
2207 // This can panic if there are too many operations on a closed
2209 TREE_NOTHROW(receive_small_fndecl
) = 0;
2210 int bitsize
= GET_MODE_BITSIZE(TYPE_MODE(type_tree
));
2211 tree int_type_tree
= go_type_for_size(bitsize
, 1);
2212 return fold_convert_loc(location
, type_tree
,
2213 fold_convert_loc(location
, int_type_tree
,
2218 tree tmp
= create_tmp_var(type_tree
, get_name(type_tree
));
2219 DECL_IGNORED_P(tmp
) = 0;
2220 TREE_ADDRESSABLE(tmp
) = 1;
2221 tree make_tmp
= build1(DECL_EXPR
, void_type_node
, tmp
);
2222 SET_EXPR_LOCATION(make_tmp
, location
);
2223 tree tmpaddr
= build_fold_addr_expr(tmp
);
2224 tmpaddr
= fold_convert(ptr_type_node
, tmpaddr
);
2225 static tree receive_big_fndecl
;
2226 tree call
= Gogo::call_builtin(&receive_big_fndecl
,
2238 : boolean_false_node
));
2239 if (call
== error_mark_node
)
2240 return error_mark_node
;
2241 // This can panic if there are too many operations on a closed
2243 TREE_NOTHROW(receive_big_fndecl
) = 0;
2244 return build2(COMPOUND_EXPR
, type_tree
, make_tmp
,
2245 build2(COMPOUND_EXPR
, type_tree
, call
, tmp
));
2249 // Return the type of a function trampoline. This is like
2250 // get_trampoline_type in tree-nested.c.
2253 Gogo::trampoline_type_tree()
2255 static tree type_tree
;
2256 if (type_tree
== NULL_TREE
)
2260 go_trampoline_info(&size
, &align
);
2261 tree t
= build_index_type(build_int_cst(integer_type_node
, size
- 1));
2262 t
= build_array_type(char_type_node
, t
);
2264 type_tree
= Gogo::builtin_struct(NULL
, "__go_trampoline", NULL_TREE
, 1,
2266 t
= TYPE_FIELDS(type_tree
);
2267 DECL_ALIGN(t
) = align
;
2268 DECL_USER_ALIGN(t
) = 1;
2270 go_preserve_from_gc(type_tree
);
2275 // Make a trampoline which calls FNADDR passing CLOSURE.
2278 Gogo::make_trampoline(tree fnaddr
, tree closure
, source_location location
)
2280 tree trampoline_type
= Gogo::trampoline_type_tree();
2281 tree trampoline_size
= TYPE_SIZE_UNIT(trampoline_type
);
2283 closure
= save_expr(closure
);
2285 // We allocate the trampoline using a special function which will
2286 // mark it as executable.
2287 static tree trampoline_fndecl
;
2288 tree x
= Gogo::call_builtin(&trampoline_fndecl
,
2290 "__go_allocate_trampoline",
2296 fold_convert_loc(location
, ptr_type_node
,
2298 if (x
== error_mark_node
)
2299 return error_mark_node
;
2303 // Initialize the trampoline.
2304 tree ini
= build_call_expr(implicit_built_in_decls
[BUILT_IN_INIT_TRAMPOLINE
],
2305 3, x
, fnaddr
, closure
);
2307 // On some targets the trampoline address needs to be adjusted. For
2308 // example, when compiling in Thumb mode on the ARM, the address
2309 // needs to have the low bit set.
2310 x
= build_call_expr(implicit_built_in_decls
[BUILT_IN_ADJUST_TRAMPOLINE
],
2312 x
= fold_convert(TREE_TYPE(fnaddr
), x
);
2314 return build2(COMPOUND_EXPR
, TREE_TYPE(x
), ini
, x
);