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"
36 // Whether we have seen any errors.
41 return errorcount
!= 0 || sorrycount
!= 0;
47 get_identifier_from_string(const std::string
& str
)
49 return get_identifier_with_length(str
.data(), str
.length());
54 static std::map
<std::string
, tree
> builtin_functions
;
56 // Define a builtin function. BCODE is the builtin function code
57 // defined by builtins.def. NAME is the name of the builtin function.
58 // LIBNAME is the name of the corresponding library function, and is
59 // NULL if there isn't one. FNTYPE is the type of the function.
60 // CONST_P is true if the function has the const attribute.
63 define_builtin(built_in_function bcode
, const char* name
, const char* libname
,
64 tree fntype
, bool const_p
)
66 tree decl
= add_builtin_function(name
, fntype
, bcode
, BUILT_IN_NORMAL
,
69 TREE_READONLY(decl
) = 1;
70 built_in_decls
[bcode
] = decl
;
71 implicit_built_in_decls
[bcode
] = decl
;
72 builtin_functions
[name
] = decl
;
75 decl
= add_builtin_function(libname
, fntype
, bcode
, BUILT_IN_NORMAL
,
78 TREE_READONLY(decl
) = 1;
79 builtin_functions
[libname
] = decl
;
83 // Create trees for implicit builtin functions.
86 Gogo::define_builtin_function_trees()
88 /* We need to define the fetch_and_add functions, since we use them
90 tree t
= go_type_for_size(BITS_PER_UNIT
, 1);
91 tree p
= build_pointer_type(build_qualified_type(t
, TYPE_QUAL_VOLATILE
));
92 define_builtin(BUILT_IN_ADD_AND_FETCH_1
, "__sync_fetch_and_add_1", NULL
,
93 build_function_type_list(t
, p
, t
, NULL_TREE
), false);
95 t
= go_type_for_size(BITS_PER_UNIT
* 2, 1);
96 p
= build_pointer_type(build_qualified_type(t
, TYPE_QUAL_VOLATILE
));
97 define_builtin (BUILT_IN_ADD_AND_FETCH_2
, "__sync_fetch_and_add_2", NULL
,
98 build_function_type_list(t
, p
, t
, NULL_TREE
), false);
100 t
= go_type_for_size(BITS_PER_UNIT
* 4, 1);
101 p
= build_pointer_type(build_qualified_type(t
, TYPE_QUAL_VOLATILE
));
102 define_builtin(BUILT_IN_ADD_AND_FETCH_4
, "__sync_fetch_and_add_4", NULL
,
103 build_function_type_list(t
, p
, t
, NULL_TREE
), false);
105 t
= go_type_for_size(BITS_PER_UNIT
* 8, 1);
106 p
= build_pointer_type(build_qualified_type(t
, TYPE_QUAL_VOLATILE
));
107 define_builtin(BUILT_IN_ADD_AND_FETCH_8
, "__sync_fetch_and_add_8", NULL
,
108 build_function_type_list(t
, p
, t
, NULL_TREE
), false);
110 // We use __builtin_expect for magic import functions.
111 define_builtin(BUILT_IN_EXPECT
, "__builtin_expect", NULL
,
112 build_function_type_list(long_integer_type_node
,
113 long_integer_type_node
,
114 long_integer_type_node
,
118 // We use __builtin_memmove for the predeclared copy function.
119 define_builtin(BUILT_IN_MEMMOVE
, "__builtin_memmove", "memmove",
120 build_function_type_list(ptr_type_node
,
127 // We provide sqrt for the math library.
128 define_builtin(BUILT_IN_SQRT
, "__builtin_sqrt", "sqrt",
129 build_function_type_list(double_type_node
,
133 define_builtin(BUILT_IN_SQRTL
, "__builtin_sqrtl", "sqrtl",
134 build_function_type_list(long_double_type_node
,
135 long_double_type_node
,
139 // We use __builtin_return_address in the thunk we build for
140 // functions which call recover.
141 define_builtin(BUILT_IN_RETURN_ADDRESS
, "__builtin_return_address", NULL
,
142 build_function_type_list(ptr_type_node
,
147 // The compiler uses __builtin_trap for some exception handling
149 define_builtin(BUILT_IN_TRAP
, "__builtin_trap", NULL
,
150 build_function_type(void_type_node
, void_list_node
),
154 // Get the name to use for the import control function. If there is a
155 // global function or variable, then we know that that name must be
156 // unique in the link, and we use it as the basis for our name.
159 Gogo::get_init_fn_name()
161 if (this->init_fn_name_
.empty())
163 gcc_assert(this->package_
!= NULL
);
164 if (this->package_name() == "main")
166 // Use a name which the runtime knows.
167 this->init_fn_name_
= "__go_init_main";
171 std::string s
= this->unique_prefix();
173 s
.append(this->package_name());
174 s
.append("..import");
175 this->init_fn_name_
= s
;
179 return this->init_fn_name_
;
182 // Add statements to INIT_STMT_LIST which run the initialization
183 // functions for imported packages. This is only used for the "main"
187 Gogo::init_imports(tree
* init_stmt_list
)
189 gcc_assert(this->package_name() == "main");
191 if (this->imported_init_fns_
.empty())
194 tree fntype
= build_function_type(void_type_node
, void_list_node
);
196 // We must call them in increasing priority order.
197 std::vector
<Import_init
> v
;
198 for (std::set
<Import_init
>::const_iterator p
=
199 this->imported_init_fns_
.begin();
200 p
!= this->imported_init_fns_
.end();
203 std::sort(v
.begin(), v
.end());
205 for (std::vector
<Import_init
>::const_iterator p
= v
.begin();
209 std::string user_name
= p
->package_name() + ".init";
210 tree decl
= build_decl(UNKNOWN_LOCATION
, FUNCTION_DECL
,
211 get_identifier_from_string(user_name
),
213 const std::string
& init_name(p
->init_name());
214 SET_DECL_ASSEMBLER_NAME(decl
, get_identifier_from_string(init_name
));
215 TREE_PUBLIC(decl
) = 1;
216 DECL_EXTERNAL(decl
) = 1;
217 append_to_statement_list(build_call_expr(decl
, 0), init_stmt_list
);
221 // Register global variables with the garbage collector. We need to
222 // register all variables which can hold a pointer value. They become
223 // roots during the mark phase. We build a struct that is easy to
224 // hook into a list of roots.
226 // struct __go_gc_root_list
228 // struct __go_gc_root_list* __next;
229 // struct __go_gc_root
236 // The last entry in the roots array has a NULL decl field.
239 Gogo::register_gc_vars(const std::vector
<Named_object
*>& var_gc
,
240 tree
* init_stmt_list
)
245 size_t count
= var_gc
.size();
247 tree root_type
= Gogo::builtin_struct(NULL
, "__go_gc_root", NULL_TREE
, 2,
253 tree index_type
= build_index_type(size_int(count
));
254 tree array_type
= build_array_type(root_type
, index_type
);
256 tree root_list_type
= make_node(RECORD_TYPE
);
257 root_list_type
= Gogo::builtin_struct(NULL
, "__go_gc_root_list",
260 build_pointer_type(root_list_type
),
264 // Build an initialier for the __roots array.
266 VEC(constructor_elt
,gc
)* roots_init
= VEC_alloc(constructor_elt
, gc
,
270 for (std::vector
<Named_object
*>::const_iterator p
= var_gc
.begin();
274 VEC(constructor_elt
,gc
)* init
= VEC_alloc(constructor_elt
, gc
, 2);
276 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
277 tree field
= TYPE_FIELDS(root_type
);
279 tree decl
= (*p
)->get_tree(this, NULL
);
280 gcc_assert(TREE_CODE(decl
) == VAR_DECL
);
281 elt
->value
= build_fold_addr_expr(decl
);
283 elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
284 field
= DECL_CHAIN(field
);
286 elt
->value
= DECL_SIZE_UNIT(decl
);
288 elt
= VEC_quick_push(constructor_elt
, roots_init
, NULL
);
289 elt
->index
= size_int(i
);
290 elt
->value
= build_constructor(root_type
, init
);
293 // The list ends with a NULL entry.
295 VEC(constructor_elt
,gc
)* init
= VEC_alloc(constructor_elt
, gc
, 2);
297 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
298 tree field
= TYPE_FIELDS(root_type
);
300 elt
->value
= fold_convert(TREE_TYPE(field
), null_pointer_node
);
302 elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
303 field
= DECL_CHAIN(field
);
305 elt
->value
= size_zero_node
;
307 elt
= VEC_quick_push(constructor_elt
, roots_init
, NULL
);
308 elt
->index
= size_int(i
);
309 elt
->value
= build_constructor(root_type
, init
);
311 // Build a constructor for the struct.
313 VEC(constructor_elt
,gc
*) root_list_init
= VEC_alloc(constructor_elt
, gc
, 2);
315 elt
= VEC_quick_push(constructor_elt
, root_list_init
, NULL
);
316 field
= TYPE_FIELDS(root_list_type
);
318 elt
->value
= fold_convert(TREE_TYPE(field
), null_pointer_node
);
320 elt
= VEC_quick_push(constructor_elt
, root_list_init
, NULL
);
321 field
= DECL_CHAIN(field
);
323 elt
->value
= build_constructor(array_type
, roots_init
);
325 // Build a decl to register.
327 tree decl
= build_decl(BUILTINS_LOCATION
, VAR_DECL
,
328 create_tmp_var_name("gc"), root_list_type
);
329 DECL_EXTERNAL(decl
) = 0;
330 TREE_PUBLIC(decl
) = 0;
331 TREE_STATIC(decl
) = 1;
332 DECL_ARTIFICIAL(decl
) = 1;
333 DECL_INITIAL(decl
) = build_constructor(root_list_type
, root_list_init
);
334 rest_of_decl_compilation(decl
, 1, 0);
336 static tree register_gc_fndecl
;
337 tree call
= Gogo::call_builtin(®ister_gc_fndecl
, BUILTINS_LOCATION
,
338 "__go_register_gc_roots",
341 build_pointer_type(root_list_type
),
342 build_fold_addr_expr(decl
));
343 if (call
!= error_mark_node
)
344 append_to_statement_list(call
, init_stmt_list
);
347 // Build the decl for the initialization function.
350 Gogo::initialization_function_decl()
352 // The tedious details of building your own function. There doesn't
353 // seem to be a helper function for this.
354 std::string name
= this->package_name() + ".init";
355 tree fndecl
= build_decl(BUILTINS_LOCATION
, FUNCTION_DECL
,
356 get_identifier_from_string(name
),
357 build_function_type(void_type_node
,
359 const std::string
& asm_name(this->get_init_fn_name());
360 SET_DECL_ASSEMBLER_NAME(fndecl
, get_identifier_from_string(asm_name
));
362 tree resdecl
= build_decl(BUILTINS_LOCATION
, RESULT_DECL
, NULL_TREE
,
364 DECL_ARTIFICIAL(resdecl
) = 1;
365 DECL_CONTEXT(resdecl
) = fndecl
;
366 DECL_RESULT(fndecl
) = resdecl
;
368 TREE_STATIC(fndecl
) = 1;
369 TREE_USED(fndecl
) = 1;
370 DECL_ARTIFICIAL(fndecl
) = 1;
371 TREE_PUBLIC(fndecl
) = 1;
373 DECL_INITIAL(fndecl
) = make_node(BLOCK
);
374 TREE_USED(DECL_INITIAL(fndecl
)) = 1;
379 // Create the magic initialization function. INIT_STMT_LIST is the
380 // code that it needs to run.
383 Gogo::write_initialization_function(tree fndecl
, tree init_stmt_list
)
385 // Make sure that we thought we needed an initialization function,
386 // as otherwise we will not have reported it in the export data.
387 gcc_assert(this->package_name() == "main" || this->need_init_fn_
);
389 if (fndecl
== NULL_TREE
)
390 fndecl
= this->initialization_function_decl();
392 DECL_SAVED_TREE(fndecl
) = init_stmt_list
;
394 current_function_decl
= fndecl
;
395 if (DECL_STRUCT_FUNCTION(fndecl
) == NULL
)
396 push_struct_function(fndecl
);
398 push_cfun(DECL_STRUCT_FUNCTION(fndecl
));
399 cfun
->function_end_locus
= BUILTINS_LOCATION
;
401 gimplify_function_tree(fndecl
);
403 cgraph_add_new_function(fndecl
, false);
404 cgraph_mark_needed_node(cgraph_node(fndecl
));
406 current_function_decl
= NULL_TREE
;
410 // Search for references to VAR in any statements or called functions.
412 class Find_var
: public Traverse
415 // A hash table we use to avoid looping. The index is the name of a
416 // named object. We only look through objects defined in this
418 typedef Unordered_set(std::string
) Seen_objects
;
420 Find_var(Named_object
* var
, Seen_objects
* seen_objects
)
421 : Traverse(traverse_expressions
),
422 var_(var
), seen_objects_(seen_objects
), found_(false)
425 // Whether the variable was found.
428 { return this->found_
; }
431 expression(Expression
**);
434 // The variable we are looking for.
436 // Names of objects we have already seen.
437 Seen_objects
* seen_objects_
;
438 // True if the variable was found.
442 // See if EXPR refers to VAR, looking through function calls and
443 // variable initializations.
446 Find_var::expression(Expression
** pexpr
)
448 Expression
* e
= *pexpr
;
450 Var_expression
* ve
= e
->var_expression();
453 Named_object
* v
= ve
->named_object();
457 return TRAVERSE_EXIT
;
460 if (v
->is_variable() && v
->package() == NULL
)
462 Expression
* init
= v
->var_value()->init();
465 std::pair
<Seen_objects::iterator
, bool> ins
=
466 this->seen_objects_
->insert(v
->name());
469 // This is the first time we have seen this name.
470 if (Expression::traverse(&init
, this) == TRAVERSE_EXIT
)
471 return TRAVERSE_EXIT
;
477 // We traverse the code of any function we see. Note that this
478 // means that we will traverse the code of a function whose address
479 // is taken even if it is not called.
480 Func_expression
* fe
= e
->func_expression();
483 const Named_object
* f
= fe
->named_object();
484 if (f
->is_function() && f
->package() == NULL
)
486 std::pair
<Seen_objects::iterator
, bool> ins
=
487 this->seen_objects_
->insert(f
->name());
490 // This is the first time we have seen this name.
491 if (f
->func_value()->block()->traverse(this) == TRAVERSE_EXIT
)
492 return TRAVERSE_EXIT
;
497 return TRAVERSE_CONTINUE
;
500 // Return true if EXPR refers to VAR.
503 expression_requires(Expression
* expr
, Block
* preinit
, Named_object
* var
)
505 Find_var::Seen_objects seen_objects
;
506 Find_var
find_var(var
, &seen_objects
);
508 Expression::traverse(&expr
, &find_var
);
510 preinit
->traverse(&find_var
);
512 return find_var
.found();
515 // Sort variable initializations. If the initialization expression
516 // for variable A refers directly or indirectly to the initialization
517 // expression for variable B, then we must initialize B before A.
523 : var_(NULL
), init_(NULL_TREE
), waiting_(0)
526 Var_init(Named_object
* var
, tree init
)
527 : var_(var
), init_(init
), waiting_(0)
530 // Return the variable.
533 { return this->var_
; }
535 // Return the initialization expression.
538 { return this->init_
; }
540 // Return the number of variables waiting for this one to be
544 { return this->waiting_
; }
546 // Increment the number waiting.
549 { ++this->waiting_
; }
552 // The variable being initialized.
554 // The initialization expression to run.
556 // The number of variables which are waiting for this one.
560 typedef std::list
<Var_init
> Var_inits
;
562 // Sort the variable initializations. The rule we follow is that we
563 // emit them in the order they appear in the array, except that if the
564 // initialization expression for a variable V1 depends upon another
565 // variable V2 then we initialize V1 after V2.
568 sort_var_inits(Var_inits
* var_inits
)
571 while (!var_inits
->empty())
573 Var_inits::iterator p1
= var_inits
->begin();
574 Named_object
* var
= p1
->var();
575 Expression
* init
= var
->var_value()->init();
576 Block
* preinit
= var
->var_value()->preinit();
578 // Start walking through the list to see which variables VAR
579 // needs to wait for. We can skip P1->WAITING variables--that
580 // is the number we've already checked.
581 Var_inits::iterator p2
= p1
;
583 for (size_t i
= p1
->waiting(); i
> 0; --i
)
586 for (; p2
!= var_inits
->end(); ++p2
)
588 if (expression_requires(init
, preinit
, p2
->var()))
591 if (expression_requires(p2
->var()->var_value()->init(),
592 p2
->var()->var_value()->preinit(),
595 error_at(var
->location(),
596 ("initialization expressions for %qs and "
597 "%qs depend upon each other"),
598 var
->message_name().c_str(),
599 p2
->var()->message_name().c_str());
600 inform(p2
->var()->location(), "%qs defined here",
601 p2
->var()->message_name().c_str());
602 p2
= var_inits
->end();
606 // We can't emit P1 until P2 is emitted. Move P1.
607 // Note that the WAITING loop always executes at
608 // least once, which is what we want.
609 p2
->increment_waiting();
610 Var_inits::iterator p3
= p2
;
611 for (size_t i
= p2
->waiting(); i
> 0; --i
)
613 var_inits
->splice(p3
, *var_inits
, p1
);
619 if (p2
== var_inits
->end())
621 // VAR does not depends upon any other initialization expressions.
623 // Check for a loop of VAR on itself. We only do this if
624 // INIT is not NULL; when INIT is NULL, it means that
625 // PREINIT sets VAR, which we will interpret as a loop.
626 if (init
!= NULL
&& expression_requires(init
, preinit
, var
))
627 error_at(var
->location(),
628 "initialization expression for %qs depends upon itself",
629 var
->message_name().c_str());
630 ready
.splice(ready
.end(), *var_inits
, p1
);
634 // Now READY is the list in the desired initialization order.
635 var_inits
->swap(ready
);
638 // Write out the global definitions.
641 Gogo::write_globals()
643 Bindings
* bindings
= this->current_bindings();
644 size_t count
= bindings
->size_definitions();
646 tree
* vec
= new tree
[count
];
648 tree init_fndecl
= NULL_TREE
;
649 tree init_stmt_list
= NULL_TREE
;
651 if (this->package_name() == "main")
652 this->init_imports(&init_stmt_list
);
654 // A list of variable initializations.
657 // A list of variables which need to be registered with the garbage
659 std::vector
<Named_object
*> var_gc
;
660 var_gc
.reserve(count
);
662 tree var_init_stmt_list
= NULL_TREE
;
664 for (Bindings::const_definitions_iterator p
= bindings
->begin_definitions();
665 p
!= bindings
->end_definitions();
668 Named_object
* no
= *p
;
670 gcc_assert(!no
->is_type_declaration() && !no
->is_function_declaration());
671 // There is nothing to do for a package.
672 if (no
->is_package())
679 // There is nothing to do for an object which was imported from
680 // a different package into the global scope.
681 if (no
->package() != NULL
)
688 // There is nothing useful we can output for constants which
689 // have ideal or non-integeral type.
692 Type
* type
= no
->const_value()->type();
694 type
= no
->const_value()->expr()->type();
695 if (type
->is_abstract() || type
->integer_type() == NULL
)
703 vec
[i
] = no
->get_tree(this, NULL
);
705 if (vec
[i
] == error_mark_node
)
707 gcc_assert(saw_errors());
713 // If a variable is initialized to a non-constant value, do the
714 // initialization in an initialization function.
715 if (TREE_CODE(vec
[i
]) == VAR_DECL
)
717 gcc_assert(no
->is_variable());
719 // Check for a sink variable, which may be used to run
720 // an initializer purely for its side effects.
721 bool is_sink
= no
->name()[0] == '_' && no
->name()[1] == '.';
723 tree var_init_tree
= NULL_TREE
;
724 if (!no
->var_value()->has_pre_init())
726 tree init
= no
->var_value()->get_init_tree(this, NULL
);
727 if (init
== error_mark_node
)
728 gcc_assert(saw_errors());
729 else if (init
== NULL_TREE
)
731 else if (TREE_CONSTANT(init
))
732 DECL_INITIAL(vec
[i
]) = init
;
734 var_init_tree
= init
;
736 var_init_tree
= fold_build2_loc(no
->location(), MODIFY_EXPR
,
737 void_type_node
, vec
[i
], init
);
741 // We are going to create temporary variables which
742 // means that we need an fndecl.
743 if (init_fndecl
== NULL_TREE
)
744 init_fndecl
= this->initialization_function_decl();
745 current_function_decl
= init_fndecl
;
746 if (DECL_STRUCT_FUNCTION(init_fndecl
) == NULL
)
747 push_struct_function(init_fndecl
);
749 push_cfun(DECL_STRUCT_FUNCTION(init_fndecl
));
751 tree var_decl
= is_sink
? NULL_TREE
: vec
[i
];
752 var_init_tree
= no
->var_value()->get_init_block(this, NULL
,
755 current_function_decl
= NULL_TREE
;
759 if (var_init_tree
!= NULL_TREE
&& var_init_tree
!= error_mark_node
)
761 if (no
->var_value()->init() == NULL
762 && !no
->var_value()->has_pre_init())
763 append_to_statement_list(var_init_tree
, &var_init_stmt_list
);
765 var_inits
.push_back(Var_init(no
, var_init_tree
));
768 if (!is_sink
&& no
->var_value()->type()->has_pointer())
769 var_gc
.push_back(no
);
773 // Register global variables with the garbage collector.
774 this->register_gc_vars(var_gc
, &init_stmt_list
);
776 // Simple variable initializations, after all variables are
778 append_to_statement_list(var_init_stmt_list
, &init_stmt_list
);
780 // Complex variable initializations, first sorting them into a
782 if (!var_inits
.empty())
784 sort_var_inits(&var_inits
);
785 for (Var_inits::const_iterator p
= var_inits
.begin();
786 p
!= var_inits
.end();
788 append_to_statement_list(p
->init(), &init_stmt_list
);
791 // After all the variables are initialized, call the "init"
792 // functions if there are any.
793 for (std::vector
<Named_object
*>::const_iterator p
=
794 this->init_functions_
.begin();
795 p
!= this->init_functions_
.end();
798 tree decl
= (*p
)->get_tree(this, NULL
);
799 tree call
= build_call_expr(decl
, 0);
800 append_to_statement_list(call
, &init_stmt_list
);
803 // Set up a magic function to do all the initialization actions.
804 // This will be called if this package is imported.
805 if (init_stmt_list
!= NULL_TREE
806 || this->need_init_fn_
807 || this->package_name() == "main")
808 this->write_initialization_function(init_fndecl
, init_stmt_list
);
810 // Pass everything back to the middle-end.
812 wrapup_global_declarations(vec
, count
);
814 cgraph_finalize_compilation_unit();
816 check_global_declarations(vec
, count
);
817 emit_debug_global_declarations(vec
, count
);
822 // Get a tree for the identifier for a named object.
825 Named_object::get_id(Gogo
* gogo
)
827 std::string decl_name
;
828 if (this->is_function_declaration()
829 && !this->func_declaration_value()->asm_name().empty())
830 decl_name
= this->func_declaration_value()->asm_name();
831 else if ((this->is_variable() && !this->var_value()->is_global())
833 && this->type_value()->location() == BUILTINS_LOCATION
))
835 // We don't need the package name for local variables or builtin
837 decl_name
= Gogo::unpack_hidden_name(this->name_
);
839 else if (this->is_function()
840 && !this->func_value()->is_method()
841 && this->package_
== NULL
842 && Gogo::unpack_hidden_name(this->name_
) == "init")
844 // A single package can have multiple "init" functions, which
845 // means that we need to give them different names.
846 static int init_index
;
848 snprintf(buf
, sizeof buf
, "%d", init_index
);
850 decl_name
= gogo
->package_name() + ".init." + buf
;
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
)
891 // If this is a variable whose address is taken, we must rebuild
892 // the INDIRECT_REF each time to avoid invalid sharing.
893 tree ret
= this->tree_
;
894 if (((this->classification_
== NAMED_OBJECT_VAR
895 && this->var_value()->is_in_heap())
896 || (this->classification_
== NAMED_OBJECT_RESULT_VAR
897 && this->result_var_value()->is_in_heap()))
898 && ret
!= error_mark_node
)
900 gcc_assert(TREE_CODE(ret
) == INDIRECT_REF
);
901 ret
= build_fold_indirect_ref(TREE_OPERAND(ret
, 0));
902 TREE_THIS_NOTRAP(ret
) = 1;
908 if (this->classification_
== NAMED_OBJECT_TYPE
)
911 name
= this->get_id(gogo
);
913 switch (this->classification_
)
915 case NAMED_OBJECT_CONST
:
917 Named_constant
* named_constant
= this->u_
.const_value
;
918 Translate_context
subcontext(gogo
, function
, NULL
, NULL_TREE
);
919 tree expr_tree
= named_constant
->expr()->get_tree(&subcontext
);
920 if (expr_tree
== error_mark_node
)
921 decl
= error_mark_node
;
924 Type
* type
= named_constant
->type();
925 if (type
!= NULL
&& !type
->is_abstract())
926 expr_tree
= fold_convert(type
->get_tree(gogo
), expr_tree
);
927 if (expr_tree
== error_mark_node
)
928 decl
= error_mark_node
;
929 else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree
)))
931 decl
= build_decl(named_constant
->location(), CONST_DECL
,
932 name
, TREE_TYPE(expr_tree
));
933 DECL_INITIAL(decl
) = expr_tree
;
934 TREE_CONSTANT(decl
) = 1;
935 TREE_READONLY(decl
) = 1;
939 // A CONST_DECL is only for an enum constant, so we
940 // shouldn't use for non-integral types. Instead we
941 // just return the constant itself, rather than a
949 case NAMED_OBJECT_TYPE
:
951 Named_type
* named_type
= this->u_
.type_value
;
952 tree type_tree
= named_type
->get_tree(gogo
);
953 if (type_tree
== error_mark_node
)
954 decl
= error_mark_node
;
957 decl
= TYPE_NAME(type_tree
);
958 gcc_assert(decl
!= NULL_TREE
);
960 // We need to produce a type descriptor for every named
961 // type, and for a pointer to every named type, since
962 // other files or packages might refer to them. We need
963 // to do this even for hidden types, because they might
964 // still be returned by some function. Simply calling the
965 // type_descriptor method is enough to create the type
966 // descriptor, even though we don't do anything with it.
967 if (this->package_
== NULL
)
969 named_type
->type_descriptor_pointer(gogo
);
970 Type
* pn
= Type::make_pointer_type(named_type
);
971 pn
->type_descriptor_pointer(gogo
);
977 case NAMED_OBJECT_TYPE_DECLARATION
:
978 error("reference to undefined type %qs",
979 this->message_name().c_str());
980 return error_mark_node
;
982 case NAMED_OBJECT_VAR
:
984 Variable
* var
= this->u_
.var_value
;
985 Type
* type
= var
->type();
986 if (type
->is_error_type()
987 || (type
->is_undefined()
988 && (!var
->is_global() || this->package() == NULL
)))
990 // Force the error for an undefined type, just in case.
992 decl
= error_mark_node
;
996 tree var_type
= type
->get_tree(gogo
);
997 bool is_parameter
= var
->is_parameter();
998 if (var
->is_receiver() && type
->points_to() == NULL
)
999 is_parameter
= false;
1000 if (var
->is_in_heap())
1002 is_parameter
= false;
1003 var_type
= build_pointer_type(var_type
);
1005 decl
= build_decl(var
->location(),
1006 is_parameter
? PARM_DECL
: VAR_DECL
,
1008 if (!var
->is_global())
1010 tree fnid
= function
->get_id(gogo
);
1011 tree fndecl
= function
->func_value()->get_or_make_decl(gogo
,
1014 DECL_CONTEXT(decl
) = fndecl
;
1017 DECL_ARG_TYPE(decl
) = TREE_TYPE(decl
);
1019 if (var
->is_global())
1021 const Package
* package
= this->package();
1022 if (package
== NULL
)
1023 TREE_STATIC(decl
) = 1;
1025 DECL_EXTERNAL(decl
) = 1;
1026 if (!Gogo::is_hidden_name(this->name_
))
1028 TREE_PUBLIC(decl
) = 1;
1029 std::string asm_name
= (package
== NULL
1030 ? gogo
->unique_prefix()
1031 : package
->unique_prefix());
1032 asm_name
.append(1, '.');
1033 asm_name
.append(IDENTIFIER_POINTER(name
),
1034 IDENTIFIER_LENGTH(name
));
1035 tree asm_id
= get_identifier_from_string(asm_name
);
1036 SET_DECL_ASSEMBLER_NAME(decl
, asm_id
);
1040 // FIXME: We should only set this for variables which are
1041 // actually used somewhere.
1042 TREE_USED(decl
) = 1;
1047 case NAMED_OBJECT_RESULT_VAR
:
1049 Result_variable
* result
= this->u_
.result_var_value
;
1050 Type
* type
= result
->type();
1051 if (type
->is_error_type() || type
->is_undefined())
1055 decl
= error_mark_node
;
1059 gcc_assert(result
->function() == function
->func_value());
1060 source_location loc
= function
->location();
1061 tree result_type
= type
->get_tree(gogo
);
1063 if (!result
->is_in_heap())
1064 init
= type
->get_init_tree(gogo
, false);
1067 tree space
= gogo
->allocate_memory(type
,
1068 TYPE_SIZE_UNIT(result_type
),
1070 result_type
= build_pointer_type(result_type
);
1071 tree subinit
= type
->get_init_tree(gogo
, true);
1072 if (subinit
== NULL_TREE
)
1073 init
= fold_convert_loc(loc
, result_type
, space
);
1076 space
= save_expr(space
);
1077 space
= fold_convert_loc(loc
, result_type
, space
);
1078 tree spaceref
= build_fold_indirect_ref_loc(loc
, space
);
1079 TREE_THIS_NOTRAP(spaceref
) = 1;
1080 tree set
= fold_build2_loc(loc
, MODIFY_EXPR
, void_type_node
,
1082 init
= fold_build2_loc(loc
, COMPOUND_EXPR
, TREE_TYPE(space
),
1086 decl
= build_decl(loc
, VAR_DECL
, name
, result_type
);
1087 tree fnid
= function
->get_id(gogo
);
1088 tree fndecl
= function
->func_value()->get_or_make_decl(gogo
,
1091 DECL_CONTEXT(decl
) = fndecl
;
1092 DECL_INITIAL(decl
) = init
;
1093 TREE_USED(decl
) = 1;
1098 case NAMED_OBJECT_SINK
:
1101 case NAMED_OBJECT_FUNC
:
1103 Function
* func
= this->u_
.func_value
;
1104 decl
= func
->get_or_make_decl(gogo
, this, name
);
1105 if (decl
!= error_mark_node
)
1107 if (func
->block() != NULL
)
1109 if (DECL_STRUCT_FUNCTION(decl
) == NULL
)
1110 push_struct_function(decl
);
1112 push_cfun(DECL_STRUCT_FUNCTION(decl
));
1114 cfun
->function_end_locus
= func
->block()->end_location();
1116 current_function_decl
= decl
;
1118 func
->build_tree(gogo
, this);
1120 gimplify_function_tree(decl
);
1122 cgraph_finalize_function(decl
, true);
1124 current_function_decl
= NULL_TREE
;
1135 if (TREE_TYPE(decl
) == error_mark_node
)
1136 decl
= error_mark_node
;
1140 // If this is a local variable whose address is taken, then we
1141 // actually store it in the heap. For uses of the variable we need
1142 // to return a reference to that heap location.
1143 if (((this->classification_
== NAMED_OBJECT_VAR
1144 && this->var_value()->is_in_heap())
1145 || (this->classification_
== NAMED_OBJECT_RESULT_VAR
1146 && this->result_var_value()->is_in_heap()))
1147 && ret
!= error_mark_node
)
1149 gcc_assert(POINTER_TYPE_P(TREE_TYPE(ret
)));
1150 ret
= build_fold_indirect_ref(ret
);
1151 TREE_THIS_NOTRAP(ret
) = 1;
1156 if (ret
!= error_mark_node
)
1157 go_preserve_from_gc(ret
);
1162 // Get the initial value of a variable as a tree. This does not
1163 // consider whether the variable is in the heap--it returns the
1164 // initial value as though it were always stored in the stack.
1167 Variable::get_init_tree(Gogo
* gogo
, Named_object
* function
)
1169 gcc_assert(this->preinit_
== NULL
);
1170 if (this->init_
== NULL
)
1172 gcc_assert(!this->is_parameter_
);
1173 return this->type_
->get_init_tree(gogo
, this->is_global_
);
1177 Translate_context
context(gogo
, function
, NULL
, NULL_TREE
);
1178 tree rhs_tree
= this->init_
->get_tree(&context
);
1179 return Expression::convert_for_assignment(&context
, this->type(),
1180 this->init_
->type(),
1181 rhs_tree
, this->location());
1185 // Get the initial value of a variable when a block is required.
1186 // VAR_DECL is the decl to set; it may be NULL for a sink variable.
1189 Variable::get_init_block(Gogo
* gogo
, Named_object
* function
, tree var_decl
)
1191 gcc_assert(this->preinit_
!= NULL
);
1193 // We want to add the variable assignment to the end of the preinit
1194 // block. The preinit block may have a TRY_FINALLY_EXPR and a
1195 // TRY_CATCH_EXPR; if it does, we want to add to the end of the
1196 // regular statements.
1198 Translate_context
context(gogo
, function
, NULL
, NULL_TREE
);
1199 tree block_tree
= this->preinit_
->get_tree(&context
);
1200 if (block_tree
== error_mark_node
)
1201 return error_mark_node
;
1202 gcc_assert(TREE_CODE(block_tree
) == BIND_EXPR
);
1203 tree statements
= BIND_EXPR_BODY(block_tree
);
1204 while (statements
!= NULL_TREE
1205 && (TREE_CODE(statements
) == TRY_FINALLY_EXPR
1206 || TREE_CODE(statements
) == TRY_CATCH_EXPR
))
1207 statements
= TREE_OPERAND(statements
, 0);
1209 // It's possible to have pre-init statements without an initializer
1210 // if the pre-init statements set the variable.
1211 if (this->init_
!= NULL
)
1213 tree rhs_tree
= this->init_
->get_tree(&context
);
1214 if (rhs_tree
== error_mark_node
)
1215 return error_mark_node
;
1216 if (var_decl
== NULL_TREE
)
1217 append_to_statement_list(rhs_tree
, &statements
);
1220 tree val
= Expression::convert_for_assignment(&context
, this->type(),
1221 this->init_
->type(),
1224 if (val
== error_mark_node
)
1225 return error_mark_node
;
1226 tree set
= fold_build2_loc(this->location(), MODIFY_EXPR
,
1227 void_type_node
, var_decl
, val
);
1228 append_to_statement_list(set
, &statements
);
1235 // Get a tree for a function decl.
1238 Function::get_or_make_decl(Gogo
* gogo
, Named_object
* no
, tree id
)
1240 if (this->fndecl_
== NULL_TREE
)
1242 tree functype
= this->type_
->get_tree(gogo
);
1243 if (functype
== error_mark_node
)
1244 this->fndecl_
= error_mark_node
;
1247 // The type of a function comes back as a pointer, but we
1248 // want the real function type for a function declaration.
1249 gcc_assert(POINTER_TYPE_P(functype
));
1250 functype
= TREE_TYPE(functype
);
1251 tree decl
= build_decl(this->location(), FUNCTION_DECL
, id
, functype
);
1253 this->fndecl_
= decl
;
1255 gcc_assert(no
->package() == NULL
);
1256 if (this->enclosing_
!= NULL
|| Gogo::is_thunk(no
))
1258 else if (Gogo::unpack_hidden_name(no
->name()) == "init"
1259 && !this->type_
->is_method())
1261 else if (Gogo::unpack_hidden_name(no
->name()) == "main"
1262 && gogo
->package_name() == "main")
1263 TREE_PUBLIC(decl
) = 1;
1264 // Methods have to be public even if they are hidden because
1265 // they can be pulled into type descriptors when using
1266 // anonymous fields.
1267 else if (!Gogo::is_hidden_name(no
->name())
1268 || this->type_
->is_method())
1270 TREE_PUBLIC(decl
) = 1;
1271 std::string asm_name
= gogo
->unique_prefix();
1272 asm_name
.append(1, '.');
1273 asm_name
.append(IDENTIFIER_POINTER(id
), IDENTIFIER_LENGTH(id
));
1274 SET_DECL_ASSEMBLER_NAME(decl
,
1275 get_identifier_from_string(asm_name
));
1278 // Why do we have to do this in the frontend?
1279 tree restype
= TREE_TYPE(functype
);
1280 tree resdecl
= build_decl(this->location(), RESULT_DECL
, NULL_TREE
,
1282 DECL_ARTIFICIAL(resdecl
) = 1;
1283 DECL_IGNORED_P(resdecl
) = 1;
1284 DECL_CONTEXT(resdecl
) = decl
;
1285 DECL_RESULT(decl
) = resdecl
;
1287 if (this->enclosing_
!= NULL
)
1288 DECL_STATIC_CHAIN(decl
) = 1;
1290 // If a function calls the predeclared recover function, we
1291 // can't inline it, because recover behaves differently in a
1292 // function passed directly to defer.
1293 if (this->calls_recover_
&& !this->is_recover_thunk_
)
1294 DECL_UNINLINABLE(decl
) = 1;
1296 // If this is a thunk created to call a function which calls
1297 // the predeclared recover function, we need to disable
1298 // stack splitting for the thunk.
1299 if (this->is_recover_thunk_
)
1301 tree attr
= get_identifier("__no_split_stack__");
1302 DECL_ATTRIBUTES(decl
) = tree_cons(attr
, NULL_TREE
, NULL_TREE
);
1305 go_preserve_from_gc(decl
);
1307 if (this->closure_var_
!= NULL
)
1309 push_struct_function(decl
);
1311 tree closure_decl
= this->closure_var_
->get_tree(gogo
, no
);
1312 if (closure_decl
== error_mark_node
)
1313 this->fndecl_
= error_mark_node
;
1316 DECL_ARTIFICIAL(closure_decl
) = 1;
1317 DECL_IGNORED_P(closure_decl
) = 1;
1318 TREE_USED(closure_decl
) = 1;
1319 DECL_ARG_TYPE(closure_decl
) = TREE_TYPE(closure_decl
);
1320 TREE_READONLY(closure_decl
) = 1;
1322 DECL_STRUCT_FUNCTION(decl
)->static_chain_decl
= closure_decl
;
1329 return this->fndecl_
;
1332 // Get a tree for a function declaration.
1335 Function_declaration::get_or_make_decl(Gogo
* gogo
, Named_object
* no
, tree id
)
1337 if (this->fndecl_
== NULL_TREE
)
1339 // Let Go code use an asm declaration to pick up a builtin
1341 if (!this->asm_name_
.empty())
1343 std::map
<std::string
, tree
>::const_iterator p
=
1344 builtin_functions
.find(this->asm_name_
);
1345 if (p
!= builtin_functions
.end())
1347 this->fndecl_
= p
->second
;
1348 return this->fndecl_
;
1352 tree functype
= this->fntype_
->get_tree(gogo
);
1354 if (functype
== error_mark_node
)
1355 decl
= error_mark_node
;
1358 // The type of a function comes back as a pointer, but we
1359 // want the real function type for a function declaration.
1360 gcc_assert(POINTER_TYPE_P(functype
));
1361 functype
= TREE_TYPE(functype
);
1362 decl
= build_decl(this->location(), FUNCTION_DECL
, id
, functype
);
1363 TREE_PUBLIC(decl
) = 1;
1364 DECL_EXTERNAL(decl
) = 1;
1366 if (this->asm_name_
.empty())
1368 std::string asm_name
= (no
->package() == NULL
1369 ? gogo
->unique_prefix()
1370 : no
->package()->unique_prefix());
1371 asm_name
.append(1, '.');
1372 asm_name
.append(IDENTIFIER_POINTER(id
), IDENTIFIER_LENGTH(id
));
1373 SET_DECL_ASSEMBLER_NAME(decl
,
1374 get_identifier_from_string(asm_name
));
1377 this->fndecl_
= decl
;
1378 go_preserve_from_gc(decl
);
1380 return this->fndecl_
;
1383 // We always pass the receiver to a method as a pointer. If the
1384 // receiver is actually declared as a non-pointer type, then we copy
1385 // the value into a local variable, so that it has the right type. In
1386 // this function we create the real PARM_DECL to use, and set
1387 // DEC_INITIAL of the var_decl to be the value passed in.
1390 Function::make_receiver_parm_decl(Gogo
* gogo
, Named_object
* no
, tree var_decl
)
1392 if (var_decl
== error_mark_node
)
1393 return error_mark_node
;
1394 // If the function takes the address of a receiver which is passed
1395 // by value, then we will have an INDIRECT_REF here. We need to get
1396 // the real variable.
1397 bool is_in_heap
= no
->var_value()->is_in_heap();
1399 if (TREE_CODE(var_decl
) != INDIRECT_REF
)
1401 gcc_assert(!is_in_heap
);
1402 val_type
= TREE_TYPE(var_decl
);
1406 gcc_assert(is_in_heap
);
1407 var_decl
= TREE_OPERAND(var_decl
, 0);
1408 if (var_decl
== error_mark_node
)
1409 return error_mark_node
;
1410 gcc_assert(POINTER_TYPE_P(TREE_TYPE(var_decl
)));
1411 val_type
= TREE_TYPE(TREE_TYPE(var_decl
));
1413 gcc_assert(TREE_CODE(var_decl
) == VAR_DECL
);
1414 source_location loc
= DECL_SOURCE_LOCATION(var_decl
);
1415 std::string name
= IDENTIFIER_POINTER(DECL_NAME(var_decl
));
1417 tree id
= get_identifier_from_string(name
);
1418 tree parm_decl
= build_decl(loc
, PARM_DECL
, id
, build_pointer_type(val_type
));
1419 DECL_CONTEXT(parm_decl
) = current_function_decl
;
1420 DECL_ARG_TYPE(parm_decl
) = TREE_TYPE(parm_decl
);
1422 gcc_assert(DECL_INITIAL(var_decl
) == NULL_TREE
);
1423 // The receiver might be passed as a null pointer.
1424 tree check
= fold_build2_loc(loc
, NE_EXPR
, boolean_type_node
, parm_decl
,
1425 fold_convert_loc(loc
, TREE_TYPE(parm_decl
),
1426 null_pointer_node
));
1427 tree ind
= build_fold_indirect_ref_loc(loc
, parm_decl
);
1428 TREE_THIS_NOTRAP(ind
) = 1;
1429 tree zero_init
= no
->var_value()->type()->get_init_tree(gogo
, false);
1430 tree init
= fold_build3_loc(loc
, COND_EXPR
, TREE_TYPE(ind
),
1431 check
, ind
, zero_init
);
1435 tree size
= TYPE_SIZE_UNIT(val_type
);
1436 tree space
= gogo
->allocate_memory(no
->var_value()->type(), size
,
1438 space
= save_expr(space
);
1439 space
= fold_convert(build_pointer_type(val_type
), space
);
1440 tree spaceref
= build_fold_indirect_ref_loc(no
->location(), space
);
1441 TREE_THIS_NOTRAP(spaceref
) = 1;
1442 tree check
= fold_build2_loc(loc
, NE_EXPR
, boolean_type_node
,
1444 fold_convert_loc(loc
, TREE_TYPE(parm_decl
),
1445 null_pointer_node
));
1446 tree parmref
= build_fold_indirect_ref_loc(no
->location(), parm_decl
);
1447 TREE_THIS_NOTRAP(parmref
) = 1;
1448 tree set
= fold_build2_loc(loc
, MODIFY_EXPR
, void_type_node
,
1450 init
= fold_build2_loc(loc
, COMPOUND_EXPR
, TREE_TYPE(space
),
1451 build3(COND_EXPR
, void_type_node
,
1452 check
, set
, NULL_TREE
),
1456 DECL_INITIAL(var_decl
) = init
;
1461 // If we take the address of a parameter, then we need to copy it into
1462 // the heap. We will access it as a local variable via an
1466 Function::copy_parm_to_heap(Gogo
* gogo
, Named_object
* no
, tree ref
)
1468 if (ref
== error_mark_node
)
1469 return error_mark_node
;
1471 gcc_assert(TREE_CODE(ref
) == INDIRECT_REF
);
1473 tree var_decl
= TREE_OPERAND(ref
, 0);
1474 if (var_decl
== error_mark_node
)
1475 return error_mark_node
;
1476 gcc_assert(TREE_CODE(var_decl
) == VAR_DECL
);
1477 source_location loc
= DECL_SOURCE_LOCATION(var_decl
);
1479 std::string name
= IDENTIFIER_POINTER(DECL_NAME(var_decl
));
1481 tree id
= get_identifier_from_string(name
);
1483 tree type
= TREE_TYPE(var_decl
);
1484 gcc_assert(POINTER_TYPE_P(type
));
1485 type
= TREE_TYPE(type
);
1487 tree parm_decl
= build_decl(loc
, PARM_DECL
, id
, type
);
1488 DECL_CONTEXT(parm_decl
) = current_function_decl
;
1489 DECL_ARG_TYPE(parm_decl
) = type
;
1491 tree size
= TYPE_SIZE_UNIT(type
);
1492 tree space
= gogo
->allocate_memory(no
->var_value()->type(), size
, loc
);
1493 space
= save_expr(space
);
1494 space
= fold_convert(TREE_TYPE(var_decl
), space
);
1495 tree spaceref
= build_fold_indirect_ref_loc(loc
, space
);
1496 TREE_THIS_NOTRAP(spaceref
) = 1;
1497 tree init
= build2(COMPOUND_EXPR
, TREE_TYPE(space
),
1498 build2(MODIFY_EXPR
, void_type_node
, spaceref
, parm_decl
),
1500 DECL_INITIAL(var_decl
) = init
;
1505 // Get a tree for function code.
1508 Function::build_tree(Gogo
* gogo
, Named_object
* named_function
)
1510 tree fndecl
= this->fndecl_
;
1511 gcc_assert(fndecl
!= NULL_TREE
);
1513 tree params
= NULL_TREE
;
1516 tree declare_vars
= NULL_TREE
;
1517 for (Bindings::const_definitions_iterator p
=
1518 this->block_
->bindings()->begin_definitions();
1519 p
!= this->block_
->bindings()->end_definitions();
1522 if ((*p
)->is_variable() && (*p
)->var_value()->is_parameter())
1524 *pp
= (*p
)->get_tree(gogo
, named_function
);
1526 // We always pass the receiver to a method as a pointer. If
1527 // the receiver is declared as a non-pointer type, then we
1528 // copy the value into a local variable.
1529 if ((*p
)->var_value()->is_receiver()
1530 && (*p
)->var_value()->type()->points_to() == NULL
)
1532 tree parm_decl
= this->make_receiver_parm_decl(gogo
, *p
, *pp
);
1534 if (TREE_CODE(var
) == INDIRECT_REF
)
1535 var
= TREE_OPERAND(var
, 0);
1536 if (var
!= error_mark_node
)
1538 gcc_assert(TREE_CODE(var
) == VAR_DECL
);
1539 DECL_CHAIN(var
) = declare_vars
;
1544 else if ((*p
)->var_value()->is_in_heap())
1546 // If we take the address of a parameter, then we need
1547 // to copy it into the heap.
1548 tree parm_decl
= this->copy_parm_to_heap(gogo
, *p
, *pp
);
1549 if (*pp
!= error_mark_node
)
1551 gcc_assert(TREE_CODE(*pp
) == INDIRECT_REF
);
1552 tree var_decl
= TREE_OPERAND(*pp
, 0);
1553 if (var_decl
!= error_mark_node
)
1555 gcc_assert(TREE_CODE(var_decl
) == VAR_DECL
);
1556 DECL_CHAIN(var_decl
) = declare_vars
;
1557 declare_vars
= var_decl
;
1563 if (*pp
!= error_mark_node
)
1565 gcc_assert(TREE_CODE(*pp
) == PARM_DECL
);
1566 pp
= &DECL_CHAIN(*pp
);
1569 else if ((*p
)->is_result_variable())
1571 tree var_decl
= (*p
)->get_tree(gogo
, named_function
);
1572 if (var_decl
!= error_mark_node
1573 && (*p
)->result_var_value()->is_in_heap())
1575 gcc_assert(TREE_CODE(var_decl
) == INDIRECT_REF
);
1576 var_decl
= TREE_OPERAND(var_decl
, 0);
1578 if (var_decl
!= error_mark_node
)
1580 gcc_assert(TREE_CODE(var_decl
) == VAR_DECL
);
1581 DECL_CHAIN(var_decl
) = declare_vars
;
1582 declare_vars
= var_decl
;
1588 DECL_ARGUMENTS(fndecl
) = params
;
1590 if (this->block_
!= NULL
)
1592 gcc_assert(DECL_INITIAL(fndecl
) == NULL_TREE
);
1594 // Declare variables if necessary.
1595 tree bind
= NULL_TREE
;
1596 if (declare_vars
!= NULL_TREE
)
1598 tree block
= make_node(BLOCK
);
1599 BLOCK_SUPERCONTEXT(block
) = fndecl
;
1600 DECL_INITIAL(fndecl
) = block
;
1601 BLOCK_VARS(block
) = declare_vars
;
1602 TREE_USED(block
) = 1;
1603 bind
= build3(BIND_EXPR
, void_type_node
, BLOCK_VARS(block
),
1605 TREE_SIDE_EFFECTS(bind
) = 1;
1608 // Build the trees for all the statements in the function.
1609 Translate_context
context(gogo
, named_function
, NULL
, NULL_TREE
);
1610 tree code
= this->block_
->get_tree(&context
);
1612 tree init
= NULL_TREE
;
1613 tree except
= NULL_TREE
;
1614 tree fini
= NULL_TREE
;
1616 // Initialize variables if necessary.
1617 for (tree v
= declare_vars
; v
!= NULL_TREE
; v
= DECL_CHAIN(v
))
1619 tree dv
= build1(DECL_EXPR
, void_type_node
, v
);
1620 SET_EXPR_LOCATION(dv
, DECL_SOURCE_LOCATION(v
));
1621 append_to_statement_list(dv
, &init
);
1624 // If we have a defer stack, initialize it at the start of a
1626 if (this->defer_stack_
!= NULL_TREE
)
1628 tree defer_init
= build1(DECL_EXPR
, void_type_node
,
1629 this->defer_stack_
);
1630 SET_EXPR_LOCATION(defer_init
, this->block_
->start_location());
1631 append_to_statement_list(defer_init
, &init
);
1633 // Clean up the defer stack when we leave the function.
1634 this->build_defer_wrapper(gogo
, named_function
, &except
, &fini
);
1637 if (code
!= NULL_TREE
&& code
!= error_mark_node
)
1639 if (init
!= NULL_TREE
)
1640 code
= build2(COMPOUND_EXPR
, void_type_node
, init
, code
);
1641 if (except
!= NULL_TREE
)
1642 code
= build2(TRY_CATCH_EXPR
, void_type_node
, code
,
1643 build2(CATCH_EXPR
, void_type_node
, NULL
, except
));
1644 if (fini
!= NULL_TREE
)
1645 code
= build2(TRY_FINALLY_EXPR
, void_type_node
, code
, fini
);
1648 // Stick the code into the block we built for the receiver, if
1650 if (bind
!= NULL_TREE
&& code
!= NULL_TREE
&& code
!= error_mark_node
)
1652 BIND_EXPR_BODY(bind
) = code
;
1656 DECL_SAVED_TREE(fndecl
) = code
;
1660 // Build the wrappers around function code needed if the function has
1661 // any defer statements. This sets *EXCEPT to an exception handler
1662 // and *FINI to a finally handler.
1665 Function::build_defer_wrapper(Gogo
* gogo
, Named_object
* named_function
,
1666 tree
*except
, tree
*fini
)
1668 source_location end_loc
= this->block_
->end_location();
1670 // Add an exception handler. This is used if a panic occurs. Its
1671 // purpose is to stop the stack unwinding if a deferred function
1672 // calls recover. There are more details in
1673 // libgo/runtime/go-unwind.c.
1674 tree stmt_list
= NULL_TREE
;
1675 static tree check_fndecl
;
1676 tree call
= Gogo::call_builtin(&check_fndecl
,
1682 this->defer_stack(end_loc
));
1683 if (call
!= error_mark_node
)
1684 append_to_statement_list(call
, &stmt_list
);
1686 tree retval
= this->return_value(gogo
, named_function
, end_loc
, &stmt_list
);
1688 if (retval
== NULL_TREE
)
1691 set
= fold_build2_loc(end_loc
, MODIFY_EXPR
, void_type_node
,
1692 DECL_RESULT(this->fndecl_
), retval
);
1693 tree ret_stmt
= fold_build1_loc(end_loc
, RETURN_EXPR
, void_type_node
, set
);
1694 append_to_statement_list(ret_stmt
, &stmt_list
);
1696 gcc_assert(*except
== NULL_TREE
);
1697 *except
= stmt_list
;
1699 // Add some finally code to run the defer functions. This is used
1700 // both in the normal case, when no panic occurs, and also if a
1701 // panic occurs to run any further defer functions. Of course, it
1702 // is possible for a defer function to call panic which should be
1703 // caught by another defer function. To handle that we use a loop.
1705 // try { __go_undefer(); } catch { __go_check_defer(); goto finish; }
1706 // if (return values are named) return named_vals;
1710 tree label
= create_artificial_label(end_loc
);
1711 tree define_label
= fold_build1_loc(end_loc
, LABEL_EXPR
, void_type_node
,
1713 append_to_statement_list(define_label
, &stmt_list
);
1715 static tree undefer_fndecl
;
1716 tree undefer
= Gogo::call_builtin(&undefer_fndecl
,
1722 this->defer_stack(end_loc
));
1723 if (undefer_fndecl
!= NULL_TREE
)
1724 TREE_NOTHROW(undefer_fndecl
) = 0;
1726 tree defer
= Gogo::call_builtin(&check_fndecl
,
1732 this->defer_stack(end_loc
));
1733 tree jump
= fold_build1_loc(end_loc
, GOTO_EXPR
, void_type_node
, label
);
1734 tree catch_body
= build2(COMPOUND_EXPR
, void_type_node
, defer
, jump
);
1735 catch_body
= build2(CATCH_EXPR
, void_type_node
, NULL
, catch_body
);
1736 tree try_catch
= build2(TRY_CATCH_EXPR
, void_type_node
, undefer
, catch_body
);
1738 append_to_statement_list(try_catch
, &stmt_list
);
1740 if (this->type_
->results() != NULL
1741 && !this->type_
->results()->empty()
1742 && !this->type_
->results()->front().name().empty())
1744 // If the result variables are named, we need to return them
1745 // again, because they might have been changed by a defer
1747 retval
= this->return_value(gogo
, named_function
, end_loc
,
1749 set
= fold_build2_loc(end_loc
, MODIFY_EXPR
, void_type_node
,
1750 DECL_RESULT(this->fndecl_
), retval
);
1751 ret_stmt
= fold_build1_loc(end_loc
, RETURN_EXPR
, void_type_node
, set
);
1752 append_to_statement_list(ret_stmt
, &stmt_list
);
1755 gcc_assert(*fini
== NULL_TREE
);
1759 // Return the value to assign to DECL_RESULT(this->fndecl_). This may
1760 // also add statements to STMT_LIST, which need to be executed before
1761 // the assignment. This is used for a return statement with no
1765 Function::return_value(Gogo
* gogo
, Named_object
* named_function
,
1766 source_location location
, tree
* stmt_list
) const
1768 const Typed_identifier_list
* results
= this->type_
->results();
1769 if (results
== NULL
|| results
->empty())
1772 // In the case of an exception handler created for functions with
1773 // defer statements, the result variables may be unnamed.
1774 bool is_named
= !results
->front().name().empty();
1776 gcc_assert(this->named_results_
!= NULL
1777 && this->named_results_
->size() == results
->size());
1780 if (results
->size() == 1)
1783 return this->named_results_
->front()->get_tree(gogo
, named_function
);
1785 return results
->front().type()->get_init_tree(gogo
, false);
1789 tree rettype
= TREE_TYPE(DECL_RESULT(this->fndecl_
));
1790 retval
= create_tmp_var(rettype
, "RESULT");
1791 tree field
= TYPE_FIELDS(rettype
);
1793 for (Typed_identifier_list::const_iterator pr
= results
->begin();
1794 pr
!= results
->end();
1795 ++pr
, ++index
, field
= DECL_CHAIN(field
))
1797 gcc_assert(field
!= NULL
);
1800 val
= (*this->named_results_
)[index
]->get_tree(gogo
,
1803 val
= pr
->type()->get_init_tree(gogo
, false);
1804 tree set
= fold_build2_loc(location
, MODIFY_EXPR
, void_type_node
,
1805 build3(COMPONENT_REF
, TREE_TYPE(field
),
1806 retval
, field
, NULL_TREE
),
1808 append_to_statement_list(set
, stmt_list
);
1814 // Get the tree for the variable holding the defer stack for this
1815 // function. At least at present, the value of this variable is not
1816 // used. However, a pointer to this variable is used as a marker for
1817 // the functions on the defer stack associated with this function.
1818 // Doing things this way permits inlining a function which uses defer.
1821 Function::defer_stack(source_location location
)
1823 if (this->defer_stack_
== NULL_TREE
)
1825 tree var
= create_tmp_var(ptr_type_node
, "DEFER");
1826 DECL_INITIAL(var
) = null_pointer_node
;
1827 DECL_SOURCE_LOCATION(var
) = location
;
1828 TREE_ADDRESSABLE(var
) = 1;
1829 this->defer_stack_
= var
;
1831 return fold_convert_loc(location
, ptr_type_node
,
1832 build_fold_addr_expr_loc(location
,
1833 this->defer_stack_
));
1836 // Get a tree for the statements in a block.
1839 Block::get_tree(Translate_context
* context
)
1841 Gogo
* gogo
= context
->gogo();
1843 tree block
= make_node(BLOCK
);
1845 // Put the new block into the block tree.
1847 if (context
->block() == NULL
)
1850 if (context
->function() != NULL
)
1851 fndecl
= context
->function()->func_value()->get_decl();
1853 fndecl
= current_function_decl
;
1854 gcc_assert(fndecl
!= NULL_TREE
);
1856 // We may have already created a block for the receiver.
1857 if (DECL_INITIAL(fndecl
) == NULL_TREE
)
1859 BLOCK_SUPERCONTEXT(block
) = fndecl
;
1860 DECL_INITIAL(fndecl
) = block
;
1864 tree superblock_tree
= DECL_INITIAL(fndecl
);
1865 BLOCK_SUPERCONTEXT(block
) = superblock_tree
;
1866 gcc_assert(BLOCK_CHAIN(block
) == NULL_TREE
);
1867 BLOCK_CHAIN(block
) = block
;
1872 tree superblock_tree
= context
->block_tree();
1873 BLOCK_SUPERCONTEXT(block
) = superblock_tree
;
1875 for (pp
= &BLOCK_SUBBLOCKS(superblock_tree
);
1877 pp
= &BLOCK_CHAIN(*pp
))
1882 // Expand local variables in the block.
1884 tree
* pp
= &BLOCK_VARS(block
);
1885 for (Bindings::const_definitions_iterator pv
=
1886 this->bindings_
->begin_definitions();
1887 pv
!= this->bindings_
->end_definitions();
1890 if ((!(*pv
)->is_variable() || !(*pv
)->var_value()->is_parameter())
1891 && !(*pv
)->is_result_variable()
1892 && !(*pv
)->is_const())
1894 tree var
= (*pv
)->get_tree(gogo
, context
->function());
1895 if (var
!= error_mark_node
&& TREE_TYPE(var
) != error_mark_node
)
1897 if ((*pv
)->is_variable() && (*pv
)->var_value()->is_in_heap())
1899 gcc_assert(TREE_CODE(var
) == INDIRECT_REF
);
1900 var
= TREE_OPERAND(var
, 0);
1901 gcc_assert(TREE_CODE(var
) == VAR_DECL
);
1904 pp
= &DECL_CHAIN(*pp
);
1910 Translate_context
subcontext(context
->gogo(), context
->function(),
1913 tree statements
= NULL_TREE
;
1915 // Expand the statements.
1917 for (std::vector
<Statement
*>::const_iterator p
= this->statements_
.begin();
1918 p
!= this->statements_
.end();
1921 tree statement
= (*p
)->get_tree(&subcontext
);
1922 if (statement
!= error_mark_node
)
1923 append_to_statement_list(statement
, &statements
);
1926 TREE_USED(block
) = 1;
1928 tree bind
= build3(BIND_EXPR
, void_type_node
, BLOCK_VARS(block
), statements
,
1930 TREE_SIDE_EFFECTS(bind
) = 1;
1935 // Get the LABEL_DECL for a label.
1940 if (this->decl_
== NULL
)
1942 tree id
= get_identifier_from_string(this->name_
);
1943 this->decl_
= build_decl(this->location_
, LABEL_DECL
, id
, void_type_node
);
1944 DECL_CONTEXT(this->decl_
) = current_function_decl
;
1949 // Return an expression for the address of this label.
1952 Label::get_addr(source_location location
)
1954 tree decl
= this->get_decl();
1955 TREE_USED(decl
) = 1;
1956 TREE_ADDRESSABLE(decl
) = 1;
1957 return fold_convert_loc(location
, ptr_type_node
,
1958 build_fold_addr_expr_loc(location
, decl
));
1961 // Get the LABEL_DECL for an unnamed label.
1964 Unnamed_label::get_decl()
1966 if (this->decl_
== NULL
)
1967 this->decl_
= create_artificial_label(this->location_
);
1971 // Get the LABEL_EXPR for an unnamed label.
1974 Unnamed_label::get_definition()
1976 tree t
= build1(LABEL_EXPR
, void_type_node
, this->get_decl());
1977 SET_EXPR_LOCATION(t
, this->location_
);
1981 // Return a goto to this label.
1984 Unnamed_label::get_goto(source_location location
)
1986 tree t
= build1(GOTO_EXPR
, void_type_node
, this->get_decl());
1987 SET_EXPR_LOCATION(t
, location
);
1991 // Return the integer type to use for a size.
1995 go_type_for_size(unsigned int bits
, int unsignedp
)
2001 name
= unsignedp
? "uint8" : "int8";
2004 name
= unsignedp
? "uint16" : "int16";
2007 name
= unsignedp
? "uint32" : "int32";
2010 name
= unsignedp
? "uint64" : "int64";
2013 if (bits
== POINTER_SIZE
&& unsignedp
)
2018 Type
* type
= Type::lookup_integer_type(name
);
2019 return type
->get_tree(go_get_gogo());
2022 // Return the type to use for a mode.
2026 go_type_for_mode(enum machine_mode mode
, int unsignedp
)
2028 // FIXME: This static_cast should be in machmode.h.
2029 enum mode_class mc
= static_cast<enum mode_class
>(GET_MODE_CLASS(mode
));
2031 return go_type_for_size(GET_MODE_BITSIZE(mode
), unsignedp
);
2032 else if (mc
== MODE_FLOAT
)
2035 switch (GET_MODE_BITSIZE (mode
))
2038 type
= Type::lookup_float_type("float32");
2041 type
= Type::lookup_float_type("float64");
2044 // We have to check for long double in order to support
2045 // i386 excess precision.
2046 if (mode
== TYPE_MODE(long_double_type_node
))
2047 return long_double_type_node
;
2050 return type
->float_type()->type_tree();
2052 else if (mc
== MODE_COMPLEX_FLOAT
)
2055 switch (GET_MODE_BITSIZE (mode
))
2058 type
= Type::lookup_complex_type("complex64");
2061 type
= Type::lookup_complex_type("complex128");
2064 // We have to check for long double in order to support
2065 // i386 excess precision.
2066 if (mode
== TYPE_MODE(complex_long_double_type_node
))
2067 return complex_long_double_type_node
;
2070 return type
->complex_type()->type_tree();
2076 // Return a tree which allocates SIZE bytes which will holds value of
2080 Gogo::allocate_memory(Type
* type
, tree size
, source_location location
)
2082 // If the package imports unsafe, then it may play games with
2083 // pointers that look like integers.
2084 if (this->imported_unsafe_
|| type
->has_pointer())
2086 static tree new_fndecl
;
2087 return Gogo::call_builtin(&new_fndecl
,
2097 static tree new_nopointers_fndecl
;
2098 return Gogo::call_builtin(&new_nopointers_fndecl
,
2100 "__go_new_nopointers",
2108 // Build a builtin struct with a list of fields. The name is
2109 // STRUCT_NAME. STRUCT_TYPE is NULL_TREE or an empty RECORD_TYPE
2110 // node; this exists so that the struct can have fields which point to
2111 // itself. If PTYPE is not NULL, store the result in *PTYPE. There
2112 // are NFIELDS fields. Each field is a name (a const char*) followed
2113 // by a type (a tree).
2116 Gogo::builtin_struct(tree
* ptype
, const char* struct_name
, tree struct_type
,
2119 if (ptype
!= NULL
&& *ptype
!= NULL_TREE
)
2123 va_start(ap
, nfields
);
2125 tree fields
= NULL_TREE
;
2126 for (int i
= 0; i
< nfields
; ++i
)
2128 const char* field_name
= va_arg(ap
, const char*);
2129 tree type
= va_arg(ap
, tree
);
2130 if (type
== error_mark_node
)
2133 *ptype
= error_mark_node
;
2134 return error_mark_node
;
2136 tree field
= build_decl(BUILTINS_LOCATION
, FIELD_DECL
,
2137 get_identifier(field_name
), type
);
2138 DECL_CHAIN(field
) = fields
;
2144 if (struct_type
== NULL_TREE
)
2145 struct_type
= make_node(RECORD_TYPE
);
2146 finish_builtin_struct(struct_type
, struct_name
, fields
, NULL_TREE
);
2150 go_preserve_from_gc(struct_type
);
2151 *ptype
= struct_type
;
2157 // Return a type to use for pointer to const char for a string.
2160 Gogo::const_char_pointer_type_tree()
2163 if (type
== NULL_TREE
)
2165 tree const_char_type
= build_qualified_type(unsigned_char_type_node
,
2167 type
= build_pointer_type(const_char_type
);
2168 go_preserve_from_gc(type
);
2173 // Return a tree for a string constant.
2176 Gogo::string_constant_tree(const std::string
& val
)
2178 tree index_type
= build_index_type(size_int(val
.length()));
2179 tree const_char_type
= build_qualified_type(unsigned_char_type_node
,
2181 tree string_type
= build_array_type(const_char_type
, index_type
);
2182 string_type
= build_variant_type_copy(string_type
);
2183 TYPE_STRING_FLAG(string_type
) = 1;
2184 tree string_val
= build_string(val
.length(), val
.data());
2185 TREE_TYPE(string_val
) = string_type
;
2189 // Return a tree for a Go string constant.
2192 Gogo::go_string_constant_tree(const std::string
& val
)
2194 tree string_type
= Type::make_string_type()->get_tree(this);
2196 VEC(constructor_elt
, gc
)* init
= VEC_alloc(constructor_elt
, gc
, 2);
2198 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
2199 tree field
= TYPE_FIELDS(string_type
);
2200 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__data") == 0);
2202 tree str
= Gogo::string_constant_tree(val
);
2203 elt
->value
= fold_convert(TREE_TYPE(field
),
2204 build_fold_addr_expr(str
));
2206 elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
2207 field
= DECL_CHAIN(field
);
2208 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__length") == 0);
2210 elt
->value
= build_int_cst_type(TREE_TYPE(field
), val
.length());
2212 tree constructor
= build_constructor(string_type
, init
);
2213 TREE_READONLY(constructor
) = 1;
2214 TREE_CONSTANT(constructor
) = 1;
2219 // Return a tree for a pointer to a Go string constant. This is only
2220 // used for type descriptors, so we return a pointer to a constant
2224 Gogo::ptr_go_string_constant_tree(const std::string
& val
)
2226 tree pval
= this->go_string_constant_tree(val
);
2228 tree decl
= build_decl(UNKNOWN_LOCATION
, VAR_DECL
,
2229 create_tmp_var_name("SP"), TREE_TYPE(pval
));
2230 DECL_EXTERNAL(decl
) = 0;
2231 TREE_PUBLIC(decl
) = 0;
2232 TREE_USED(decl
) = 1;
2233 TREE_READONLY(decl
) = 1;
2234 TREE_CONSTANT(decl
) = 1;
2235 TREE_STATIC(decl
) = 1;
2236 DECL_ARTIFICIAL(decl
) = 1;
2237 DECL_INITIAL(decl
) = pval
;
2238 rest_of_decl_compilation(decl
, 1, 0);
2240 return build_fold_addr_expr(decl
);
2243 // Build the type of the struct that holds a slice for the given
2247 Gogo::slice_type_tree(tree element_type_tree
)
2249 // We use int for the count and capacity fields in a slice header.
2250 // This matches 6g. The language definition guarantees that we
2251 // can't allocate space of a size which does not fit in int
2252 // anyhow. FIXME: integer_type_node is the the C type "int" but is
2253 // not necessarily the Go type "int". They will differ when the C
2254 // type "int" has fewer than 32 bits.
2255 return Gogo::builtin_struct(NULL
, "__go_slice", NULL_TREE
, 3,
2257 build_pointer_type(element_type_tree
),
2264 // Given the tree for a slice type, return the tree for the type of
2265 // the elements of the slice.
2268 Gogo::slice_element_type_tree(tree slice_type_tree
)
2270 gcc_assert(TREE_CODE(slice_type_tree
) == RECORD_TYPE
2271 && POINTER_TYPE_P(TREE_TYPE(TYPE_FIELDS(slice_type_tree
))));
2272 return TREE_TYPE(TREE_TYPE(TYPE_FIELDS(slice_type_tree
)));
2275 // Build a constructor for a slice. SLICE_TYPE_TREE is the type of
2276 // the slice. VALUES is the value pointer and COUNT is the number of
2277 // entries. If CAPACITY is not NULL, it is the capacity; otherwise
2278 // the capacity and the count are the same.
2281 Gogo::slice_constructor(tree slice_type_tree
, tree values
, tree count
,
2284 gcc_assert(TREE_CODE(slice_type_tree
) == RECORD_TYPE
);
2286 VEC(constructor_elt
,gc
)* init
= VEC_alloc(constructor_elt
, gc
, 3);
2288 tree field
= TYPE_FIELDS(slice_type_tree
);
2289 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__values") == 0);
2290 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
2292 gcc_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field
))
2293 == TYPE_MAIN_VARIANT(TREE_TYPE(values
)));
2294 elt
->value
= values
;
2296 count
= fold_convert(sizetype
, count
);
2297 if (capacity
== NULL_TREE
)
2299 count
= save_expr(count
);
2303 field
= DECL_CHAIN(field
);
2304 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__count") == 0);
2305 elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
2307 elt
->value
= fold_convert(TREE_TYPE(field
), count
);
2309 field
= DECL_CHAIN(field
);
2310 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field
)), "__capacity") == 0);
2311 elt
= VEC_quick_push(constructor_elt
, init
, NULL
);
2313 elt
->value
= fold_convert(TREE_TYPE(field
), capacity
);
2315 return build_constructor(slice_type_tree
, init
);
2318 // Build a constructor for an empty slice.
2321 Gogo::empty_slice_constructor(tree slice_type_tree
)
2323 tree element_field
= TYPE_FIELDS(slice_type_tree
);
2324 tree ret
= Gogo::slice_constructor(slice_type_tree
,
2325 fold_convert(TREE_TYPE(element_field
),
2329 TREE_CONSTANT(ret
) = 1;
2333 // Build a map descriptor for a map of type MAPTYPE.
2336 Gogo::map_descriptor(Map_type
* maptype
)
2338 if (this->map_descriptors_
== NULL
)
2339 this->map_descriptors_
= new Map_descriptors(10);
2341 std::pair
<const Map_type
*, tree
> val(maptype
, NULL
);
2342 std::pair
<Map_descriptors::iterator
, bool> ins
=
2343 this->map_descriptors_
->insert(val
);
2344 Map_descriptors::iterator p
= ins
.first
;
2347 if (p
->second
== error_mark_node
)
2348 return error_mark_node
;
2349 gcc_assert(p
->second
!= NULL_TREE
&& DECL_P(p
->second
));
2350 return build_fold_addr_expr(p
->second
);
2353 Type
* keytype
= maptype
->key_type();
2354 Type
* valtype
= maptype
->val_type();
2356 std::string mangled_name
= ("__go_map_" + maptype
->mangled_name(this));
2358 tree id
= get_identifier_from_string(mangled_name
);
2360 // Get the type of the map descriptor. This is __go_map_descriptor
2363 tree struct_type
= this->map_descriptor_type();
2365 // The map entry type is a struct with three fields. This struct is
2366 // specific to MAPTYPE. Build it.
2368 tree map_entry_type
= make_node(RECORD_TYPE
);
2370 map_entry_type
= Gogo::builtin_struct(NULL
, "__map", map_entry_type
, 3,
2372 build_pointer_type(map_entry_type
),
2374 keytype
->get_tree(this),
2376 valtype
->get_tree(this));
2377 if (map_entry_type
== error_mark_node
)
2379 p
->second
= error_mark_node
;
2380 return error_mark_node
;
2383 tree map_entry_key_field
= DECL_CHAIN(TYPE_FIELDS(map_entry_type
));
2384 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_key_field
)),
2387 tree map_entry_val_field
= DECL_CHAIN(map_entry_key_field
);
2388 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_val_field
)),
2391 // Initialize the entries.
2393 tree map_descriptor_field
= TYPE_FIELDS(struct_type
);
2394 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_descriptor_field
)),
2395 "__map_descriptor") == 0);
2396 tree entry_size_field
= DECL_CHAIN(map_descriptor_field
);
2397 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(entry_size_field
)),
2398 "__entry_size") == 0);
2399 tree key_offset_field
= DECL_CHAIN(entry_size_field
);
2400 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(key_offset_field
)),
2401 "__key_offset") == 0);
2402 tree val_offset_field
= DECL_CHAIN(key_offset_field
);
2403 gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(val_offset_field
)),
2404 "__val_offset") == 0);
2406 VEC(constructor_elt
, gc
)* descriptor
= VEC_alloc(constructor_elt
, gc
, 6);
2408 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, descriptor
, NULL
);
2409 elt
->index
= map_descriptor_field
;
2410 elt
->value
= maptype
->type_descriptor_pointer(this);
2412 elt
= VEC_quick_push(constructor_elt
, descriptor
, NULL
);
2413 elt
->index
= entry_size_field
;
2414 elt
->value
= TYPE_SIZE_UNIT(map_entry_type
);
2416 elt
= VEC_quick_push(constructor_elt
, descriptor
, NULL
);
2417 elt
->index
= key_offset_field
;
2418 elt
->value
= byte_position(map_entry_key_field
);
2420 elt
= VEC_quick_push(constructor_elt
, descriptor
, NULL
);
2421 elt
->index
= val_offset_field
;
2422 elt
->value
= byte_position(map_entry_val_field
);
2424 tree constructor
= build_constructor(struct_type
, descriptor
);
2426 tree decl
= build_decl(BUILTINS_LOCATION
, VAR_DECL
, id
, struct_type
);
2427 TREE_STATIC(decl
) = 1;
2428 TREE_USED(decl
) = 1;
2429 TREE_READONLY(decl
) = 1;
2430 TREE_CONSTANT(decl
) = 1;
2431 DECL_INITIAL(decl
) = constructor
;
2432 make_decl_one_only(decl
, DECL_ASSEMBLER_NAME(decl
));
2433 resolve_unique_section(decl
, 1, 0);
2435 rest_of_decl_compilation(decl
, 1, 0);
2437 go_preserve_from_gc(decl
);
2440 return build_fold_addr_expr(decl
);
2443 // Return a tree for the type of a map descriptor. This is struct
2444 // __go_map_descriptor in libgo/runtime/map.h. This is the same for
2448 Gogo::map_descriptor_type()
2450 static tree struct_type
;
2451 tree dtype
= Type::make_type_descriptor_type()->get_tree(this);
2452 dtype
= build_qualified_type(dtype
, TYPE_QUAL_CONST
);
2453 return Gogo::builtin_struct(&struct_type
, "__go_map_descriptor", NULL_TREE
,
2456 build_pointer_type(dtype
),
2465 // Return the name to use for a type descriptor decl for TYPE. This
2466 // is used when TYPE does not have a name.
2469 Gogo::unnamed_type_descriptor_decl_name(const Type
* type
)
2471 return "__go_td_" + type
->mangled_name(this);
2474 // Return the name to use for a type descriptor decl for a type named
2475 // NAME, defined in the function IN_FUNCTION. IN_FUNCTION will
2476 // normally be NULL.
2479 Gogo::type_descriptor_decl_name(const Named_object
* no
,
2480 const Named_object
* in_function
)
2482 std::string ret
= "__go_tdn_";
2483 if (no
->type_value()->is_builtin())
2484 gcc_assert(in_function
== NULL
);
2487 const std::string
& unique_prefix(no
->package() == NULL
2488 ? this->unique_prefix()
2489 : no
->package()->unique_prefix());
2490 const std::string
& package_name(no
->package() == NULL
2491 ? this->package_name()
2492 : no
->package()->name());
2493 ret
.append(unique_prefix
);
2495 ret
.append(package_name
);
2497 if (in_function
!= NULL
)
2499 ret
.append(Gogo::unpack_hidden_name(in_function
->name()));
2503 ret
.append(no
->name());
2507 // Where a type descriptor decl should be defined.
2509 Gogo::Type_descriptor_location
2510 Gogo::type_descriptor_location(const Type
* type
)
2512 const Named_type
* name
= type
->named_type();
2515 if (name
->named_object()->package() != NULL
)
2517 // This is a named type defined in a different package. The
2518 // descriptor should be defined in that package.
2519 return TYPE_DESCRIPTOR_UNDEFINED
;
2521 else if (name
->is_builtin())
2523 // We create the descriptor for a builtin type whenever we
2525 return TYPE_DESCRIPTOR_COMMON
;
2529 // This is a named type defined in this package. The
2530 // descriptor should be defined here.
2531 return TYPE_DESCRIPTOR_DEFINED
;
2536 if (type
->points_to() != NULL
2537 && type
->points_to()->named_type() != NULL
2538 && type
->points_to()->named_type()->named_object()->package() != NULL
)
2540 // This is an unnamed pointer to a named type defined in a
2541 // different package. The descriptor should be defined in
2543 return TYPE_DESCRIPTOR_UNDEFINED
;
2547 // This is an unnamed type. The descriptor could be defined
2548 // in any package where it is needed, and the linker will
2549 // pick one descriptor to keep.
2550 return TYPE_DESCRIPTOR_COMMON
;
2555 // Build a type descriptor decl for TYPE. INITIALIZER is a struct
2556 // composite literal which initializers the type descriptor.
2559 Gogo::build_type_descriptor_decl(const Type
* type
, Expression
* initializer
,
2562 const Named_type
* name
= type
->named_type();
2564 // We can have multiple instances of unnamed types, but we only want
2565 // to emit the type descriptor once. We use a hash table to handle
2566 // this. This is not necessary for named types, as they are unique,
2567 // and we store the type descriptor decl in the type itself.
2571 if (this->type_descriptor_decls_
== NULL
)
2572 this->type_descriptor_decls_
= new Type_descriptor_decls(10);
2574 std::pair
<Type_descriptor_decls::iterator
, bool> ins
=
2575 this->type_descriptor_decls_
->insert(std::make_pair(type
, NULL_TREE
));
2578 // We've already built a type descriptor for this type.
2579 *pdecl
= ins
.first
->second
;
2582 phash
= &ins
.first
->second
;
2585 std::string decl_name
;
2587 decl_name
= this->unnamed_type_descriptor_decl_name(type
);
2589 decl_name
= this->type_descriptor_decl_name(name
->named_object(),
2590 name
->in_function());
2591 tree id
= get_identifier_from_string(decl_name
);
2592 tree descriptor_type_tree
= initializer
->type()->get_tree(this);
2593 if (descriptor_type_tree
== error_mark_node
)
2595 *pdecl
= error_mark_node
;
2598 tree decl
= build_decl(name
== NULL
? BUILTINS_LOCATION
: name
->location(),
2600 build_qualified_type(descriptor_type_tree
,
2602 TREE_READONLY(decl
) = 1;
2603 TREE_CONSTANT(decl
) = 1;
2604 DECL_ARTIFICIAL(decl
) = 1;
2606 go_preserve_from_gc(decl
);
2610 // We store the new DECL now because we may need to refer to it when
2611 // expanding INITIALIZER.
2614 // If appropriate, just refer to the exported type identifier.
2615 Gogo::Type_descriptor_location type_descriptor_location
=
2616 this->type_descriptor_location(type
);
2617 if (type_descriptor_location
== TYPE_DESCRIPTOR_UNDEFINED
)
2619 TREE_PUBLIC(decl
) = 1;
2620 DECL_EXTERNAL(decl
) = 1;
2624 TREE_STATIC(decl
) = 1;
2625 TREE_USED(decl
) = 1;
2627 Translate_context
context(this, NULL
, NULL
, NULL
);
2628 context
.set_is_const();
2629 tree constructor
= initializer
->get_tree(&context
);
2631 if (constructor
== error_mark_node
)
2632 gcc_assert(saw_errors());
2634 DECL_INITIAL(decl
) = constructor
;
2636 if (type_descriptor_location
== TYPE_DESCRIPTOR_COMMON
)
2638 make_decl_one_only(decl
, DECL_ASSEMBLER_NAME(decl
));
2639 resolve_unique_section(decl
, 1, 0);
2643 #ifdef OBJECT_FORMAT_ELF
2644 // Give the decl protected visibility. This avoids out-of-range
2645 // references with shared libraries with the x86_64 small model
2646 // when the type descriptor gets a COPY reloc into the main
2647 // executable. There is no need to have unique pointers to type
2648 // descriptors, as the runtime code compares reflection strings
2650 DECL_VISIBILITY(decl
) = VISIBILITY_PROTECTED
;
2651 DECL_VISIBILITY_SPECIFIED(decl
) = 1;
2654 TREE_PUBLIC(decl
) = 1;
2657 rest_of_decl_compilation(decl
, 1, 0);
2660 // Build an interface method table for a type: a list of function
2661 // pointers, one for each interface method. This is used for
2665 Gogo::interface_method_table_for_type(const Interface_type
* interface
,
2669 const Typed_identifier_list
* interface_methods
= interface
->methods();
2670 gcc_assert(!interface_methods
->empty());
2672 std::string mangled_name
= ((is_pointer
? "__go_pimt__" : "__go_imt_")
2673 + interface
->mangled_name(this)
2675 + type
->mangled_name(this));
2677 tree id
= get_identifier_from_string(mangled_name
);
2679 // See whether this interface has any hidden methods.
2680 bool has_hidden_methods
= false;
2681 for (Typed_identifier_list::const_iterator p
= interface_methods
->begin();
2682 p
!= interface_methods
->end();
2685 if (Gogo::is_hidden_name(p
->name()))
2687 has_hidden_methods
= true;
2692 // We already know that the named type is convertible to the
2693 // interface. If the interface has hidden methods, and the named
2694 // type is defined in a different package, then the interface
2695 // conversion table will be defined by that other package.
2696 if (has_hidden_methods
&& type
->named_object()->package() != NULL
)
2698 tree array_type
= build_array_type(const_ptr_type_node
, NULL
);
2699 tree decl
= build_decl(BUILTINS_LOCATION
, VAR_DECL
, id
, array_type
);
2700 TREE_READONLY(decl
) = 1;
2701 TREE_CONSTANT(decl
) = 1;
2702 TREE_PUBLIC(decl
) = 1;
2703 DECL_EXTERNAL(decl
) = 1;
2704 go_preserve_from_gc(decl
);
2708 size_t count
= interface_methods
->size();
2709 VEC(constructor_elt
, gc
)* pointers
= VEC_alloc(constructor_elt
, gc
,
2712 // The first element is the type descriptor.
2713 constructor_elt
* elt
= VEC_quick_push(constructor_elt
, pointers
, NULL
);
2714 elt
->index
= size_zero_node
;
2719 td_type
= Type::make_pointer_type(type
);
2720 elt
->value
= fold_convert(const_ptr_type_node
,
2721 td_type
->type_descriptor_pointer(this));
2724 for (Typed_identifier_list::const_iterator p
= interface_methods
->begin();
2725 p
!= interface_methods
->end();
2729 Method
* m
= type
->method_function(p
->name(), &is_ambiguous
);
2730 gcc_assert(m
!= NULL
);
2732 Named_object
* no
= m
->named_object();
2734 tree fnid
= no
->get_id(this);
2737 if (no
->is_function())
2738 fndecl
= no
->func_value()->get_or_make_decl(this, no
, fnid
);
2739 else if (no
->is_function_declaration())
2740 fndecl
= no
->func_declaration_value()->get_or_make_decl(this, no
,
2744 fndecl
= build_fold_addr_expr(fndecl
);
2746 elt
= VEC_quick_push(constructor_elt
, pointers
, NULL
);
2747 elt
->index
= size_int(i
);
2748 elt
->value
= fold_convert(const_ptr_type_node
, fndecl
);
2750 gcc_assert(i
== count
+ 1);
2752 tree array_type
= build_array_type(const_ptr_type_node
,
2753 build_index_type(size_int(count
)));
2754 tree constructor
= build_constructor(array_type
, pointers
);
2756 tree decl
= build_decl(BUILTINS_LOCATION
, VAR_DECL
, id
, array_type
);
2757 TREE_STATIC(decl
) = 1;
2758 TREE_USED(decl
) = 1;
2759 TREE_READONLY(decl
) = 1;
2760 TREE_CONSTANT(decl
) = 1;
2761 DECL_INITIAL(decl
) = constructor
;
2763 // If the interface type has hidden methods, then this is the only
2764 // definition of the table. Otherwise it is a comdat table which
2765 // may be defined in multiple packages.
2766 if (has_hidden_methods
)
2768 #ifdef OBJECT_FORMAT_ELF
2769 // Give the decl protected visibility. This avoids out-of-range
2770 // references with shared libraries with the x86_64 small model
2771 // when the table gets a COPY reloc into the main executable.
2772 DECL_VISIBILITY(decl
) = VISIBILITY_PROTECTED
;
2773 DECL_VISIBILITY_SPECIFIED(decl
) = 1;
2776 TREE_PUBLIC(decl
) = 1;
2780 make_decl_one_only(decl
, DECL_ASSEMBLER_NAME(decl
));
2781 resolve_unique_section(decl
, 1, 0);
2784 rest_of_decl_compilation(decl
, 1, 0);
2786 go_preserve_from_gc(decl
);
2791 // Mark a function as a builtin library function.
2794 Gogo::mark_fndecl_as_builtin_library(tree fndecl
)
2796 DECL_EXTERNAL(fndecl
) = 1;
2797 TREE_PUBLIC(fndecl
) = 1;
2798 DECL_ARTIFICIAL(fndecl
) = 1;
2799 TREE_NOTHROW(fndecl
) = 1;
2800 DECL_VISIBILITY(fndecl
) = VISIBILITY_DEFAULT
;
2801 DECL_VISIBILITY_SPECIFIED(fndecl
) = 1;
2804 // Build a call to a builtin function.
2807 Gogo::call_builtin(tree
* pdecl
, source_location location
, const char* name
,
2808 int nargs
, tree rettype
, ...)
2810 if (rettype
== error_mark_node
)
2811 return error_mark_node
;
2813 tree
* types
= new tree
[nargs
];
2814 tree
* args
= new tree
[nargs
];
2817 va_start(ap
, rettype
);
2818 for (int i
= 0; i
< nargs
; ++i
)
2820 types
[i
] = va_arg(ap
, tree
);
2821 args
[i
] = va_arg(ap
, tree
);
2822 if (types
[i
] == error_mark_node
|| args
[i
] == error_mark_node
)
2826 return error_mark_node
;
2831 if (*pdecl
== NULL_TREE
)
2833 tree fnid
= get_identifier(name
);
2835 tree argtypes
= NULL_TREE
;
2836 tree
* pp
= &argtypes
;
2837 for (int i
= 0; i
< nargs
; ++i
)
2839 *pp
= tree_cons(NULL_TREE
, types
[i
], NULL_TREE
);
2840 pp
= &TREE_CHAIN(*pp
);
2842 *pp
= void_list_node
;
2844 tree fntype
= build_function_type(rettype
, argtypes
);
2846 *pdecl
= build_decl(BUILTINS_LOCATION
, FUNCTION_DECL
, fnid
, fntype
);
2847 Gogo::mark_fndecl_as_builtin_library(*pdecl
);
2848 go_preserve_from_gc(*pdecl
);
2851 tree fnptr
= build_fold_addr_expr(*pdecl
);
2852 if (CAN_HAVE_LOCATION_P(fnptr
))
2853 SET_EXPR_LOCATION(fnptr
, location
);
2855 tree ret
= build_call_array(rettype
, fnptr
, nargs
, args
);
2856 SET_EXPR_LOCATION(ret
, location
);
2864 // Build a call to the runtime error function.
2867 Gogo::runtime_error(int code
, source_location location
)
2869 static tree runtime_error_fndecl
;
2870 tree ret
= Gogo::call_builtin(&runtime_error_fndecl
,
2872 "__go_runtime_error",
2876 build_int_cst(integer_type_node
, code
));
2877 if (ret
== error_mark_node
)
2878 return error_mark_node
;
2879 // The runtime error function panics and does not return.
2880 TREE_NOTHROW(runtime_error_fndecl
) = 0;
2881 TREE_THIS_VOLATILE(runtime_error_fndecl
) = 1;
2885 // Send VAL on CHANNEL. If BLOCKING is true, the resulting tree has a
2886 // void type. If BLOCKING is false, the resulting tree has a boolean
2887 // type, and it will evaluate as true if the value was sent. If
2888 // FOR_SELECT is true, this is being done because it was chosen in a
2889 // select statement.
2892 Gogo::send_on_channel(tree channel
, tree val
, bool blocking
, bool for_select
,
2893 source_location location
)
2895 if (channel
== error_mark_node
|| val
== error_mark_node
)
2896 return error_mark_node
;
2898 if (int_size_in_bytes(TREE_TYPE(val
)) <= 8
2899 && !AGGREGATE_TYPE_P(TREE_TYPE(val
))
2900 && !FLOAT_TYPE_P(TREE_TYPE(val
)))
2902 val
= convert_to_integer(uint64_type_node
, val
);
2905 static tree send_small_fndecl
;
2906 tree ret
= Gogo::call_builtin(&send_small_fndecl
,
2918 : boolean_false_node
));
2919 if (ret
== error_mark_node
)
2920 return error_mark_node
;
2921 // This can panic if there are too many operations on a
2923 TREE_NOTHROW(send_small_fndecl
) = 0;
2928 gcc_assert(!for_select
);
2929 static tree send_nonblocking_small_fndecl
;
2930 tree ret
= Gogo::call_builtin(&send_nonblocking_small_fndecl
,
2932 "__go_send_nonblocking_small",
2939 if (ret
== error_mark_node
)
2940 return error_mark_node
;
2941 // This can panic if there are too many operations on a
2943 TREE_NOTHROW(send_nonblocking_small_fndecl
) = 0;
2950 if (TREE_ADDRESSABLE(TREE_TYPE(val
)) || TREE_CODE(val
) == VAR_DECL
)
2952 make_tmp
= NULL_TREE
;
2953 val
= build_fold_addr_expr(val
);
2955 TREE_ADDRESSABLE(val
) = 1;
2959 tree tmp
= create_tmp_var(TREE_TYPE(val
), get_name(val
));
2960 DECL_IGNORED_P(tmp
) = 0;
2961 DECL_INITIAL(tmp
) = val
;
2962 TREE_ADDRESSABLE(tmp
) = 1;
2963 make_tmp
= build1(DECL_EXPR
, void_type_node
, tmp
);
2964 SET_EXPR_LOCATION(make_tmp
, location
);
2965 val
= build_fold_addr_expr(tmp
);
2967 val
= fold_convert(ptr_type_node
, val
);
2972 static tree send_big_fndecl
;
2973 call
= Gogo::call_builtin(&send_big_fndecl
,
2985 : boolean_false_node
));
2986 if (call
== error_mark_node
)
2987 return error_mark_node
;
2988 // This can panic if there are too many operations on a
2990 TREE_NOTHROW(send_big_fndecl
) = 0;
2994 gcc_assert(!for_select
);
2995 static tree send_nonblocking_big_fndecl
;
2996 call
= Gogo::call_builtin(&send_nonblocking_big_fndecl
,
2998 "__go_send_nonblocking_big",
3005 if (call
== error_mark_node
)
3006 return error_mark_node
;
3007 // This can panic if there are too many operations on a
3009 TREE_NOTHROW(send_nonblocking_big_fndecl
) = 0;
3012 if (make_tmp
== NULL_TREE
)
3016 tree ret
= build2(COMPOUND_EXPR
, TREE_TYPE(call
), make_tmp
, call
);
3017 SET_EXPR_LOCATION(ret
, location
);
3023 // Return a tree for receiving a value of type TYPE_TREE on CHANNEL.
3024 // This does a blocking receive and returns the value read from the
3025 // channel. If FOR_SELECT is true, this is being done because it was
3026 // chosen in a select statement.
3029 Gogo::receive_from_channel(tree type_tree
, tree channel
, bool for_select
,
3030 source_location location
)
3032 if (type_tree
== error_mark_node
|| channel
== error_mark_node
)
3033 return error_mark_node
;
3035 if (int_size_in_bytes(type_tree
) <= 8
3036 && !AGGREGATE_TYPE_P(type_tree
)
3037 && !FLOAT_TYPE_P(type_tree
))
3039 static tree receive_small_fndecl
;
3040 tree call
= Gogo::call_builtin(&receive_small_fndecl
,
3042 "__go_receive_small",
3050 : boolean_false_node
));
3051 if (call
== error_mark_node
)
3052 return error_mark_node
;
3053 // This can panic if there are too many operations on a closed
3055 TREE_NOTHROW(receive_small_fndecl
) = 0;
3056 int bitsize
= GET_MODE_BITSIZE(TYPE_MODE(type_tree
));
3057 tree int_type_tree
= go_type_for_size(bitsize
, 1);
3058 return fold_convert_loc(location
, type_tree
,
3059 fold_convert_loc(location
, int_type_tree
,
3064 tree tmp
= create_tmp_var(type_tree
, get_name(type_tree
));
3065 DECL_IGNORED_P(tmp
) = 0;
3066 TREE_ADDRESSABLE(tmp
) = 1;
3067 tree make_tmp
= build1(DECL_EXPR
, void_type_node
, tmp
);
3068 SET_EXPR_LOCATION(make_tmp
, location
);
3069 tree tmpaddr
= build_fold_addr_expr(tmp
);
3070 tmpaddr
= fold_convert(ptr_type_node
, tmpaddr
);
3071 static tree receive_big_fndecl
;
3072 tree call
= Gogo::call_builtin(&receive_big_fndecl
,
3084 : boolean_false_node
));
3085 if (call
== error_mark_node
)
3086 return error_mark_node
;
3087 // This can panic if there are too many operations on a closed
3089 TREE_NOTHROW(receive_big_fndecl
) = 0;
3090 return build2(COMPOUND_EXPR
, type_tree
, make_tmp
,
3091 build2(COMPOUND_EXPR
, type_tree
, call
, tmp
));
3095 // Return the type of a function trampoline. This is like
3096 // get_trampoline_type in tree-nested.c.
3099 Gogo::trampoline_type_tree()
3101 static tree type_tree
;
3102 if (type_tree
== NULL_TREE
)
3106 go_trampoline_info(&size
, &align
);
3107 tree t
= build_index_type(build_int_cst(integer_type_node
, size
- 1));
3108 t
= build_array_type(char_type_node
, t
);
3110 type_tree
= Gogo::builtin_struct(NULL
, "__go_trampoline", NULL_TREE
, 1,
3112 t
= TYPE_FIELDS(type_tree
);
3113 DECL_ALIGN(t
) = align
;
3114 DECL_USER_ALIGN(t
) = 1;
3116 go_preserve_from_gc(type_tree
);
3121 // Make a trampoline which calls FNADDR passing CLOSURE.
3124 Gogo::make_trampoline(tree fnaddr
, tree closure
, source_location location
)
3126 tree trampoline_type
= Gogo::trampoline_type_tree();
3127 tree trampoline_size
= TYPE_SIZE_UNIT(trampoline_type
);
3129 closure
= save_expr(closure
);
3131 // We allocate the trampoline using a special function which will
3132 // mark it as executable.
3133 static tree trampoline_fndecl
;
3134 tree x
= Gogo::call_builtin(&trampoline_fndecl
,
3136 "__go_allocate_trampoline",
3142 fold_convert_loc(location
, ptr_type_node
,
3144 if (x
== error_mark_node
)
3145 return error_mark_node
;
3149 // Initialize the trampoline.
3150 tree ini
= build_call_expr(implicit_built_in_decls
[BUILT_IN_INIT_TRAMPOLINE
],
3151 3, x
, fnaddr
, closure
);
3153 // On some targets the trampoline address needs to be adjusted. For
3154 // example, when compiling in Thumb mode on the ARM, the address
3155 // needs to have the low bit set.
3156 x
= build_call_expr(implicit_built_in_decls
[BUILT_IN_ADJUST_TRAMPOLINE
],
3158 x
= fold_convert(TREE_TYPE(fnaddr
), x
);
3160 return build2(COMPOUND_EXPR
, TREE_TYPE(x
), ini
, x
);