Google Git
Sign in
chromium / native_client / pnacl-gcc / pnacl / . / gcc / go / gofrontend / gogo-tree.cc
blob: 562a5afa9840ea632f3f7e17030f49e0445e910c [file] [log] [blame]
// gogo-tree.cc -- convert Go frontend Gogo IR to gcc trees.
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#include "go-system.h"
#include <gmp.h>
#ifndef ENABLE_BUILD_WITH_CXX
extern "C"
{
#endif
#include "toplev.h"
#include "tree.h"
#include "gimple.h"
#include "tree-iterator.h"
#include "cgraph.h"
#include "langhooks.h"
#include "convert.h"
#include "output.h"
#include "diagnostic.h"
#ifndef ENABLE_BUILD_WITH_CXX
}
#endif
#include "go-c.h"
#include "types.h"
#include "expressions.h"
#include "statements.h"
#include "gogo.h"
// Whether we have seen any errors.
bool
saw_errors()
{
return errorcount != 0 || sorrycount != 0;
}
// A helper function.
static inline tree
get_identifier_from_string(const std::string& str)
{
return get_identifier_with_length(str.data(), str.length());
}
// Builtin functions.
static std::map<std::string, tree> builtin_functions;
// Define a builtin function. BCODE is the builtin function code
// defined by builtins.def. NAME is the name of the builtin function.
// LIBNAME is the name of the corresponding library function, and is
// NULL if there isn't one. FNTYPE is the type of the function.
// CONST_P is true if the function has the const attribute.
static void
define_builtin(built_in_function bcode, const char* name, const char* libname,
tree fntype, bool const_p)
{
tree decl = add_builtin_function(name, fntype, bcode, BUILT_IN_NORMAL,
libname, NULL_TREE);
if (const_p)
TREE_READONLY(decl) = 1;
built_in_decls[bcode] = decl;
implicit_built_in_decls[bcode] = decl;
builtin_functions[name] = decl;
if (libname != NULL)
{
decl = add_builtin_function(libname, fntype, bcode, BUILT_IN_NORMAL,
NULL, NULL_TREE);
if (const_p)
TREE_READONLY(decl) = 1;
builtin_functions[libname] = decl;
}
}
// Create trees for implicit builtin functions.
void
Gogo::define_builtin_function_trees()
{
/* We need to define the fetch_and_add functions, since we use them
for ++ and --. */
tree t = go_type_for_size(BITS_PER_UNIT, 1);
tree p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
define_builtin(BUILT_IN_ADD_AND_FETCH_1, "__sync_fetch_and_add_1", NULL,
build_function_type_list(t, p, t, NULL_TREE), false);
t = go_type_for_size(BITS_PER_UNIT * 2, 1);
p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
define_builtin (BUILT_IN_ADD_AND_FETCH_2, "__sync_fetch_and_add_2", NULL,
build_function_type_list(t, p, t, NULL_TREE), false);
t = go_type_for_size(BITS_PER_UNIT * 4, 1);
p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
define_builtin(BUILT_IN_ADD_AND_FETCH_4, "__sync_fetch_and_add_4", NULL,
build_function_type_list(t, p, t, NULL_TREE), false);
t = go_type_for_size(BITS_PER_UNIT * 8, 1);
p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
define_builtin(BUILT_IN_ADD_AND_FETCH_8, "__sync_fetch_and_add_8", NULL,
build_function_type_list(t, p, t, NULL_TREE), false);
// We use __builtin_expect for magic import functions.
define_builtin(BUILT_IN_EXPECT, "__builtin_expect", NULL,
build_function_type_list(long_integer_type_node,
long_integer_type_node,
long_integer_type_node,
NULL_TREE),
true);
// We use __builtin_memmove for the predeclared copy function.
define_builtin(BUILT_IN_MEMMOVE, "__builtin_memmove", "memmove",
build_function_type_list(ptr_type_node,
ptr_type_node,
const_ptr_type_node,
size_type_node,
NULL_TREE),
false);
// We provide sqrt for the math library.
define_builtin(BUILT_IN_SQRT, "__builtin_sqrt", "sqrt",
build_function_type_list(double_type_node,
double_type_node,
NULL_TREE),
true);
define_builtin(BUILT_IN_SQRTL, "__builtin_sqrtl", "sqrtl",
build_function_type_list(long_double_type_node,
long_double_type_node,
NULL_TREE),
true);
// We use __builtin_return_address in the thunk we build for
// functions which call recover.
define_builtin(BUILT_IN_RETURN_ADDRESS, "__builtin_return_address", NULL,
build_function_type_list(ptr_type_node,
unsigned_type_node,
NULL_TREE),
false);
// The compiler uses __builtin_trap for some exception handling
// cases.
define_builtin(BUILT_IN_TRAP, "__builtin_trap", NULL,
build_function_type(void_type_node, void_list_node),
false);
}
// Get the name to use for the import control function. If there is a
// global function or variable, then we know that that name must be
// unique in the link, and we use it as the basis for our name.
const std::string&
Gogo::get_init_fn_name()
{
if (this->init_fn_name_.empty())
{
gcc_assert(this->package_ != NULL);
if (this->is_main_package())
{
// Use a name which the runtime knows.
this->init_fn_name_ = "__go_init_main";
}
else
{
std::string s = this->unique_prefix();
s.append(1, '.');
s.append(this->package_name());
s.append("..import");
this->init_fn_name_ = s;
}
}
return this->init_fn_name_;
}
// Add statements to INIT_STMT_LIST which run the initialization
// functions for imported packages. This is only used for the "main"
// package.
void
Gogo::init_imports(tree* init_stmt_list)
{
gcc_assert(this->is_main_package());
if (this->imported_init_fns_.empty())
return;
tree fntype = build_function_type(void_type_node, void_list_node);
// We must call them in increasing priority order.
std::vector<Import_init> v;
for (std::set<Import_init>::const_iterator p =
this->imported_init_fns_.begin();
p != this->imported_init_fns_.end();
++p)
v.push_back(*p);
std::sort(v.begin(), v.end());
for (std::vector<Import_init>::const_iterator p = v.begin();
p != v.end();
++p)
{
std::string user_name = p->package_name() + ".init";
tree decl = build_decl(UNKNOWN_LOCATION, FUNCTION_DECL,
get_identifier_from_string(user_name),
fntype);
const std::string& init_name(p->init_name());
SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(init_name));
TREE_PUBLIC(decl) = 1;
DECL_EXTERNAL(decl) = 1;
append_to_statement_list(build_call_expr(decl, 0), init_stmt_list);
}
}
// Register global variables with the garbage collector. We need to
// register all variables which can hold a pointer value. They become
// roots during the mark phase. We build a struct that is easy to
// hook into a list of roots.
// struct __go_gc_root_list
// {
// struct __go_gc_root_list* __next;
// struct __go_gc_root
// {
// void* __decl;
// size_t __size;
// } __roots[];
// };
// The last entry in the roots array has a NULL decl field.
void
Gogo::register_gc_vars(const std::vector<Named_object*>& var_gc,
tree* init_stmt_list)
{
if (var_gc.empty())
return;
size_t count = var_gc.size();
tree root_type = Gogo::builtin_struct(NULL, "__go_gc_root", NULL_TREE, 2,
"__next",
ptr_type_node,
"__size",
sizetype);
tree index_type = build_index_type(size_int(count));
tree array_type = build_array_type(root_type, index_type);
tree root_list_type = make_node(RECORD_TYPE);
root_list_type = Gogo::builtin_struct(NULL, "__go_gc_root_list",
root_list_type, 2,
"__next",
build_pointer_type(root_list_type),
"__roots",
array_type);
// Build an initialier for the __roots array.
VEC(constructor_elt,gc)* roots_init = VEC_alloc(constructor_elt, gc,
count + 1);
size_t i = 0;
for (std::vector<Named_object*>::const_iterator p = var_gc.begin();
p != var_gc.end();
++p, ++i)
{
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
tree field = TYPE_FIELDS(root_type);
elt->index = field;
tree decl = (*p)->get_tree(this, NULL);
gcc_assert(TREE_CODE(decl) == VAR_DECL);
elt->value = build_fold_addr_expr(decl);
elt = VEC_quick_push(constructor_elt, init, NULL);
field = DECL_CHAIN(field);
elt->index = field;
elt->value = DECL_SIZE_UNIT(decl);
elt = VEC_quick_push(constructor_elt, roots_init, NULL);
elt->index = size_int(i);
elt->value = build_constructor(root_type, init);
}
// The list ends with a NULL entry.
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
tree field = TYPE_FIELDS(root_type);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
elt = VEC_quick_push(constructor_elt, init, NULL);
field = DECL_CHAIN(field);
elt->index = field;
elt->value = size_zero_node;
elt = VEC_quick_push(constructor_elt, roots_init, NULL);
elt->index = size_int(i);
elt->value = build_constructor(root_type, init);
// Build a constructor for the struct.
VEC(constructor_elt,gc*) root_list_init = VEC_alloc(constructor_elt, gc, 2);
elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
field = TYPE_FIELDS(root_list_type);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
field = DECL_CHAIN(field);
elt->index = field;
elt->value = build_constructor(array_type, roots_init);
// Build a decl to register.
tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL,
create_tmp_var_name("gc"), root_list_type);
DECL_EXTERNAL(decl) = 0;
TREE_PUBLIC(decl) = 0;
TREE_STATIC(decl) = 1;
DECL_ARTIFICIAL(decl) = 1;
DECL_INITIAL(decl) = build_constructor(root_list_type, root_list_init);
rest_of_decl_compilation(decl, 1, 0);
static tree register_gc_fndecl;
tree call = Gogo::call_builtin(&register_gc_fndecl, BUILTINS_LOCATION,
"__go_register_gc_roots",
1,
void_type_node,
build_pointer_type(root_list_type),
build_fold_addr_expr(decl));
if (call != error_mark_node)
append_to_statement_list(call, init_stmt_list);
}
// Build the decl for the initialization function.
tree
Gogo::initialization_function_decl()
{
// The tedious details of building your own function. There doesn't
// seem to be a helper function for this.
std::string name = this->package_name() + ".init";
tree fndecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL,
get_identifier_from_string(name),
build_function_type(void_type_node,
void_list_node));
const std::string& asm_name(this->get_init_fn_name());
SET_DECL_ASSEMBLER_NAME(fndecl, get_identifier_from_string(asm_name));
tree resdecl = build_decl(BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
void_type_node);
DECL_ARTIFICIAL(resdecl) = 1;
DECL_CONTEXT(resdecl) = fndecl;
DECL_RESULT(fndecl) = resdecl;
TREE_STATIC(fndecl) = 1;
TREE_USED(fndecl) = 1;
DECL_ARTIFICIAL(fndecl) = 1;
TREE_PUBLIC(fndecl) = 1;
DECL_INITIAL(fndecl) = make_node(BLOCK);
TREE_USED(DECL_INITIAL(fndecl)) = 1;
return fndecl;
}
// Create the magic initialization function. INIT_STMT_LIST is the
// code that it needs to run.
void
Gogo::write_initialization_function(tree fndecl, tree init_stmt_list)
{
// Make sure that we thought we needed an initialization function,
// as otherwise we will not have reported it in the export data.
gcc_assert(this->is_main_package() || this->need_init_fn_);
if (fndecl == NULL_TREE)
fndecl = this->initialization_function_decl();
DECL_SAVED_TREE(fndecl) = init_stmt_list;
current_function_decl = fndecl;
if (DECL_STRUCT_FUNCTION(fndecl) == NULL)
push_struct_function(fndecl);
else
push_cfun(DECL_STRUCT_FUNCTION(fndecl));
cfun->function_end_locus = BUILTINS_LOCATION;
gimplify_function_tree(fndecl);
cgraph_add_new_function(fndecl, false);
cgraph_mark_needed_node(cgraph_node(fndecl));
current_function_decl = NULL_TREE;
pop_cfun();
}
// Search for references to VAR in any statements or called functions.
class Find_var : public Traverse
{
public:
// A hash table we use to avoid looping. The index is the name of a
// named object. We only look through objects defined in this
// package.
typedef Unordered_set(std::string) Seen_objects;
Find_var(Named_object* var, Seen_objects* seen_objects)
: Traverse(traverse_expressions),
var_(var), seen_objects_(seen_objects), found_(false)
{ }
// Whether the variable was found.
bool
found() const
{ return this->found_; }
int
expression(Expression**);
private:
// The variable we are looking for.
Named_object* var_;
// Names of objects we have already seen.
Seen_objects* seen_objects_;
// True if the variable was found.
bool found_;
};
// See if EXPR refers to VAR, looking through function calls and
// variable initializations.
int
Find_var::expression(Expression** pexpr)
{
Expression* e = *pexpr;
Var_expression* ve = e->var_expression();
if (ve != NULL)
{
Named_object* v = ve->named_object();
if (v == this->var_)
{
this->found_ = true;
return TRAVERSE_EXIT;
}
if (v->is_variable() && v->package() == NULL)
{
Expression* init = v->var_value()->init();
if (init != NULL)
{
std::pair<Seen_objects::iterator, bool> ins =
this->seen_objects_->insert(v->name());
if (ins.second)
{
// This is the first time we have seen this name.
if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
}
}
}
// We traverse the code of any function we see. Note that this
// means that we will traverse the code of a function whose address
// is taken even if it is not called.
Func_expression* fe = e->func_expression();
if (fe != NULL)
{
const Named_object* f = fe->named_object();
if (f->is_function() && f->package() == NULL)
{
std::pair<Seen_objects::iterator, bool> ins =
this->seen_objects_->insert(f->name());
if (ins.second)
{
// This is the first time we have seen this name.
if (f->func_value()->block()->traverse(this) == TRAVERSE_EXIT)
return TRAVERSE_EXIT;
}
}
}
return TRAVERSE_CONTINUE;
}
// Return true if EXPR refers to VAR.
static bool
expression_requires(Expression* expr, Block* preinit, Named_object* var)
{
Find_var::Seen_objects seen_objects;
Find_var find_var(var, &seen_objects);
if (expr != NULL)
Expression::traverse(&expr, &find_var);
if (preinit != NULL)
preinit->traverse(&find_var);
return find_var.found();
}
// Sort variable initializations. If the initialization expression
// for variable A refers directly or indirectly to the initialization
// expression for variable B, then we must initialize B before A.
class Var_init
{
public:
Var_init()
: var_(NULL), init_(NULL_TREE), waiting_(0)
{ }
Var_init(Named_object* var, tree init)
: var_(var), init_(init), waiting_(0)
{ }
// Return the variable.
Named_object*
var() const
{ return this->var_; }
// Return the initialization expression.
tree
init() const
{ return this->init_; }
// Return the number of variables waiting for this one to be
// initialized.
size_t
waiting() const
{ return this->waiting_; }
// Increment the number waiting.
void
increment_waiting()
{ ++this->waiting_; }
private:
// The variable being initialized.
Named_object* var_;
// The initialization expression to run.
tree init_;
// The number of variables which are waiting for this one.
size_t waiting_;
};
typedef std::list<Var_init> Var_inits;
// Sort the variable initializations. The rule we follow is that we
// emit them in the order they appear in the array, except that if the
// initialization expression for a variable V1 depends upon another
// variable V2 then we initialize V1 after V2.
static void
sort_var_inits(Var_inits* var_inits)
{
Var_inits ready;
while (!var_inits->empty())
{
Var_inits::iterator p1 = var_inits->begin();
Named_object* var = p1->var();
Expression* init = var->var_value()->init();
Block* preinit = var->var_value()->preinit();
// Start walking through the list to see which variables VAR
// needs to wait for. We can skip P1->WAITING variables--that
// is the number we've already checked.
Var_inits::iterator p2 = p1;
++p2;
for (size_t i = p1->waiting(); i > 0; --i)
++p2;
for (; p2 != var_inits->end(); ++p2)
{
if (expression_requires(init, preinit, p2->var()))
{
// Check for cycles.
if (expression_requires(p2->var()->var_value()->init(),
p2->var()->var_value()->preinit(),
var))
{
error_at(var->location(),
("initialization expressions for %qs and "
"%qs depend upon each other"),
var->message_name().c_str(),
p2->var()->message_name().c_str());
inform(p2->var()->location(), "%qs defined here",
p2->var()->message_name().c_str());
p2 = var_inits->end();
}
else
{
// We can't emit P1 until P2 is emitted. Move P1.
// Note that the WAITING loop always executes at
// least once, which is what we want.
p2->increment_waiting();
Var_inits::iterator p3 = p2;
for (size_t i = p2->waiting(); i > 0; --i)
++p3;
var_inits->splice(p3, *var_inits, p1);
}
break;
}
}
if (p2 == var_inits->end())
{
// VAR does not depends upon any other initialization expressions.
// Check for a loop of VAR on itself. We only do this if
// INIT is not NULL; when INIT is NULL, it means that
// PREINIT sets VAR, which we will interpret as a loop.
if (init != NULL && expression_requires(init, preinit, var))
error_at(var->location(),
"initialization expression for %qs depends upon itself",
var->message_name().c_str());
ready.splice(ready.end(), *var_inits, p1);
}
}
// Now READY is the list in the desired initialization order.
var_inits->swap(ready);
}
// Write out the global definitions.
void
Gogo::write_globals()
{
this->convert_named_types();
this->build_interface_method_tables();
Bindings* bindings = this->current_bindings();
size_t count = bindings->size_definitions();
tree* vec = new tree[count];
tree init_fndecl = NULL_TREE;
tree init_stmt_list = NULL_TREE;
if (this->is_main_package())
this->init_imports(&init_stmt_list);
// A list of variable initializations.
Var_inits var_inits;
// A list of variables which need to be registered with the garbage
// collector.
std::vector<Named_object*> var_gc;
var_gc.reserve(count);
tree var_init_stmt_list = NULL_TREE;
size_t i = 0;
for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
p != bindings->end_definitions();
++p, ++i)
{
Named_object* no = *p;
gcc_assert(!no->is_type_declaration() && !no->is_function_declaration());
// There is nothing to do for a package.
if (no->is_package())
{
--i;
--count;
continue;
}
// There is nothing to do for an object which was imported from
// a different package into the global scope.
if (no->package() != NULL)
{
--i;
--count;
continue;
}
// There is nothing useful we can output for constants which
// have ideal or non-integeral type.
if (no->is_const())
{
Type* type = no->const_value()->type();
if (type == NULL)
type = no->const_value()->expr()->type();
if (type->is_abstract() || type->integer_type() == NULL)
{
--i;
--count;
continue;
}
}
vec[i] = no->get_tree(this, NULL);
if (vec[i] == error_mark_node)
{
gcc_assert(saw_errors());
--i;
--count;
continue;
}
// If a variable is initialized to a non-constant value, do the
// initialization in an initialization function.
if (TREE_CODE(vec[i]) == VAR_DECL)
{
gcc_assert(no->is_variable());
// Check for a sink variable, which may be used to run
// an initializer purely for its side effects.
bool is_sink = no->name()[0] == '_' && no->name()[1] == '.';
tree var_init_tree = NULL_TREE;
if (!no->var_value()->has_pre_init())
{
tree init = no->var_value()->get_init_tree(this, NULL);
if (init == error_mark_node)
gcc_assert(saw_errors());
else if (init == NULL_TREE)
;
else if (TREE_CONSTANT(init))
DECL_INITIAL(vec[i]) = init;
else if (is_sink)
var_init_tree = init;
else
var_init_tree = fold_build2_loc(no->location(), MODIFY_EXPR,
void_type_node, vec[i], init);
}
else
{
// We are going to create temporary variables which
// means that we need an fndecl.
if (init_fndecl == NULL_TREE)
init_fndecl = this->initialization_function_decl();
current_function_decl = init_fndecl;
if (DECL_STRUCT_FUNCTION(init_fndecl) == NULL)
push_struct_function(init_fndecl);
else
push_cfun(DECL_STRUCT_FUNCTION(init_fndecl));
tree var_decl = is_sink ? NULL_TREE : vec[i];
var_init_tree = no->var_value()->get_init_block(this, NULL,
var_decl);
current_function_decl = NULL_TREE;
pop_cfun();
}
if (var_init_tree != NULL_TREE && var_init_tree != error_mark_node)
{
if (no->var_value()->init() == NULL
&& !no->var_value()->has_pre_init())
append_to_statement_list(var_init_tree, &var_init_stmt_list);
else
var_inits.push_back(Var_init(no, var_init_tree));
}
if (!is_sink && no->var_value()->type()->has_pointer())
var_gc.push_back(no);
}
}
// Register global variables with the garbage collector.
this->register_gc_vars(var_gc, &init_stmt_list);
// Simple variable initializations, after all variables are
// registered.
append_to_statement_list(var_init_stmt_list, &init_stmt_list);
// Complex variable initializations, first sorting them into a
// workable order.
if (!var_inits.empty())
{
sort_var_inits(&var_inits);
for (Var_inits::const_iterator p = var_inits.begin();
p != var_inits.end();
++p)
append_to_statement_list(p->init(), &init_stmt_list);
}
// After all the variables are initialized, call the "init"
// functions if there are any.
for (std::vector<Named_object*>::const_iterator p =
this->init_functions_.begin();
p != this->init_functions_.end();
++p)
{
tree decl = (*p)->get_tree(this, NULL);
tree call = build_call_expr(decl, 0);
append_to_statement_list(call, &init_stmt_list);
}
// Set up a magic function to do all the initialization actions.
// This will be called if this package is imported.
if (init_stmt_list != NULL_TREE
|| this->need_init_fn_
|| this->is_main_package())
this->write_initialization_function(init_fndecl, init_stmt_list);
// Pass everything back to the middle-end.
wrapup_global_declarations(vec, count);
cgraph_finalize_compilation_unit();
check_global_declarations(vec, count);
emit_debug_global_declarations(vec, count);
delete[] vec;
}
// Get a tree for the identifier for a named object.
tree
Named_object::get_id(Gogo* gogo)
{
std::string decl_name;
if (this->is_function_declaration()
&& !this->func_declaration_value()->asm_name().empty())
decl_name = this->func_declaration_value()->asm_name();
else if ((this->is_variable() && !this->var_value()->is_global())
|| (this->is_type()
&& this->type_value()->location() == BUILTINS_LOCATION))
{
// We don't need the package name for local variables or builtin
// types.
decl_name = Gogo::unpack_hidden_name(this->name_);
}
else
{
std::string package_name;
if (this->package_ == NULL)
package_name = gogo->package_name();
else
package_name = this->package_->name();
decl_name = package_name + '.' + Gogo::unpack_hidden_name(this->name_);
Function_type* fntype;
if (this->is_function())
fntype = this->func_value()->type();
else if (this->is_function_declaration())
fntype = this->func_declaration_value()->type();
else
fntype = NULL;
if (fntype != NULL && fntype->is_method())
{
decl_name.push_back('.');
decl_name.append(fntype->receiver()->type()->mangled_name(gogo));
}
}
if (this->is_type())
{
const Named_object* in_function = this->type_value()->in_function();
if (in_function != NULL)
decl_name += '$' + in_function->name();
}
return get_identifier_from_string(decl_name);
}
// Get a tree for a named object.
tree
Named_object::get_tree(Gogo* gogo, Named_object* function)
{
if (this->tree_ != NULL_TREE)
{
// If this is a variable whose address is taken, we must rebuild
// the INDIRECT_REF each time to avoid invalid sharing.
tree ret = this->tree_;
if (((this->classification_ == NAMED_OBJECT_VAR
&& this->var_value()->is_in_heap())
|| (this->classification_ == NAMED_OBJECT_RESULT_VAR
&& this->result_var_value()->is_in_heap()))
&& ret != error_mark_node)
{
gcc_assert(TREE_CODE(ret) == INDIRECT_REF);
ret = build_fold_indirect_ref(TREE_OPERAND(ret, 0));
TREE_THIS_NOTRAP(ret) = 1;
}
return ret;
}
tree name;
if (this->classification_ == NAMED_OBJECT_TYPE)
name = NULL_TREE;
else
name = this->get_id(gogo);
tree decl;
switch (this->classification_)
{
case NAMED_OBJECT_CONST:
{
Named_constant* named_constant = this->u_.const_value;
Translate_context subcontext(gogo, function, NULL, NULL_TREE);
tree expr_tree = named_constant->expr()->get_tree(&subcontext);
if (expr_tree == error_mark_node)
decl = error_mark_node;
else
{
Type* type = named_constant->type();
if (type != NULL && !type->is_abstract())
{
if (!type->is_undefined())
expr_tree = fold_convert(type->get_tree(gogo), expr_tree);
else
{
// Make sure we report the error.
type->base();
expr_tree = error_mark_node;
}
}
if (expr_tree == error_mark_node)
decl = error_mark_node;
else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
{
decl = build_decl(named_constant->location(), CONST_DECL,
name, TREE_TYPE(expr_tree));
DECL_INITIAL(decl) = expr_tree;
TREE_CONSTANT(decl) = 1;
TREE_READONLY(decl) = 1;
}
else
{
// A CONST_DECL is only for an enum constant, so we
// shouldn't use for non-integral types. Instead we
// just return the constant itself, rather than a
// decl.
decl = expr_tree;
}
}
}
break;
case NAMED_OBJECT_TYPE:
{
Named_type* named_type = this->u_.type_value;
tree type_tree = named_type->get_tree(gogo);
if (type_tree == error_mark_node)
decl = error_mark_node;
else
{
decl = TYPE_NAME(type_tree);
gcc_assert(decl != NULL_TREE);
// We need to produce a type descriptor for every named
// type, and for a pointer to every named type, since
// other files or packages might refer to them. We need
// to do this even for hidden types, because they might
// still be returned by some function. Simply calling the
// type_descriptor method is enough to create the type
// descriptor, even though we don't do anything with it.
if (this->package_ == NULL)
{
named_type->type_descriptor_pointer(gogo);
Type* pn = Type::make_pointer_type(named_type);
pn->type_descriptor_pointer(gogo);
}
}
}
break;
case NAMED_OBJECT_TYPE_DECLARATION:
error("reference to undefined type %qs",
this->message_name().c_str());
return error_mark_node;
case NAMED_OBJECT_VAR:
{
Variable* var = this->u_.var_value;
Type* type = var->type();
if (type->is_error_type()
|| (type->is_undefined()
&& (!var->is_global() || this->package() == NULL)))
{
// Force the error for an undefined type, just in case.
type->base();
decl = error_mark_node;
}
else
{
tree var_type = type->get_tree(gogo);
bool is_parameter = var->is_parameter();
if (var->is_receiver() && type->points_to() == NULL)
is_parameter = false;
if (var->is_in_heap())
{
is_parameter = false;
var_type = build_pointer_type(var_type);
}
decl = build_decl(var->location(),
is_parameter ? PARM_DECL : VAR_DECL,
name, var_type);
if (!var->is_global())
{
tree fnid = function->get_id(gogo);
tree fndecl = function->func_value()->get_or_make_decl(gogo,
function,
fnid);
DECL_CONTEXT(decl) = fndecl;
}
if (is_parameter)
DECL_ARG_TYPE(decl) = TREE_TYPE(decl);
if (var->is_global())
{
const Package* package = this->package();
if (package == NULL)
TREE_STATIC(decl) = 1;
else
DECL_EXTERNAL(decl) = 1;
if (!Gogo::is_hidden_name(this->name_))
{
TREE_PUBLIC(decl) = 1;
std::string asm_name = (package == NULL
? gogo->unique_prefix()
: package->unique_prefix());
asm_name.append(1, '.');
asm_name.append(IDENTIFIER_POINTER(name),
IDENTIFIER_LENGTH(name));
tree asm_id = get_identifier_from_string(asm_name);
SET_DECL_ASSEMBLER_NAME(decl, asm_id);
}
}
// FIXME: We should only set this for variables which are
// actually used somewhere.
TREE_USED(decl) = 1;
}
}
break;
case NAMED_OBJECT_RESULT_VAR:
{
Result_variable* result = this->u_.result_var_value;
Type* type = result->type();
if (type->is_error_type() || type->is_undefined())
{
// Force the error.
type->base();
decl = error_mark_node;
}
else
{
gcc_assert(result->function() == function->func_value());
source_location loc = function->location();
tree result_type = type->get_tree(gogo);
tree init;
if (!result->is_in_heap())
init = type->get_init_tree(gogo, false);
else
{
tree space = gogo->allocate_memory(type,
TYPE_SIZE_UNIT(result_type),
loc);
result_type = build_pointer_type(result_type);
tree subinit = type->get_init_tree(gogo, true);
if (subinit == NULL_TREE)
init = fold_convert_loc(loc, result_type, space);
else
{
space = save_expr(space);
space = fold_convert_loc(loc, result_type, space);
tree spaceref = build_fold_indirect_ref_loc(loc, space);
TREE_THIS_NOTRAP(spaceref) = 1;
tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
spaceref, subinit);
init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
set, space);
}
}
decl = build_decl(loc, VAR_DECL, name, result_type);
tree fnid = function->get_id(gogo);
tree fndecl = function->func_value()->get_or_make_decl(gogo,
function,
fnid);
DECL_CONTEXT(decl) = fndecl;
DECL_INITIAL(decl) = init;
TREE_USED(decl) = 1;
}
}
break;
case NAMED_OBJECT_SINK:
gcc_unreachable();
case NAMED_OBJECT_FUNC:
{
Function* func = this->u_.func_value;
decl = func->get_or_make_decl(gogo, this, name);
if (decl != error_mark_node)
{
if (func->block() != NULL)
{
if (DECL_STRUCT_FUNCTION(decl) == NULL)
push_struct_function(decl);
else
push_cfun(DECL_STRUCT_FUNCTION(decl));
cfun->function_end_locus = func->block()->end_location();
current_function_decl = decl;
func->build_tree(gogo, this);
gimplify_function_tree(decl);
cgraph_finalize_function(decl, true);
current_function_decl = NULL_TREE;
pop_cfun();
}
}
}
break;
default:
gcc_unreachable();
}
if (TREE_TYPE(decl) == error_mark_node)
decl = error_mark_node;
tree ret = decl;
// If this is a local variable whose address is taken, then we
// actually store it in the heap. For uses of the variable we need
// to return a reference to that heap location.
if (((this->classification_ == NAMED_OBJECT_VAR
&& this->var_value()->is_in_heap())
|| (this->classification_ == NAMED_OBJECT_RESULT_VAR
&& this->result_var_value()->is_in_heap()))
&& ret != error_mark_node)
{
gcc_assert(POINTER_TYPE_P(TREE_TYPE(ret)));
ret = build_fold_indirect_ref(ret);
TREE_THIS_NOTRAP(ret) = 1;
}
this->tree_ = ret;
if (ret != error_mark_node)
go_preserve_from_gc(ret);
return ret;
}
// Get the initial value of a variable as a tree. This does not
// consider whether the variable is in the heap--it returns the
// initial value as though it were always stored in the stack.
tree
Variable::get_init_tree(Gogo* gogo, Named_object* function)
{
gcc_assert(this->preinit_ == NULL);
if (this->init_ == NULL)
{
gcc_assert(!this->is_parameter_);
return this->type_->get_init_tree(gogo, this->is_global_);
}
else
{
Translate_context context(gogo, function, NULL, NULL_TREE);
tree rhs_tree = this->init_->get_tree(&context);
return Expression::convert_for_assignment(&context, this->type(),
this->init_->type(),
rhs_tree, this->location());
}
}
// Get the initial value of a variable when a block is required.
// VAR_DECL is the decl to set; it may be NULL for a sink variable.
tree
Variable::get_init_block(Gogo* gogo, Named_object* function, tree var_decl)
{
gcc_assert(this->preinit_ != NULL);
// We want to add the variable assignment to the end of the preinit
// block. The preinit block may have a TRY_FINALLY_EXPR and a
// TRY_CATCH_EXPR; if it does, we want to add to the end of the
// regular statements.
Translate_context context(gogo, function, NULL, NULL_TREE);
tree block_tree = this->preinit_->get_tree(&context);
if (block_tree == error_mark_node)
return error_mark_node;
gcc_assert(TREE_CODE(block_tree) == BIND_EXPR);
tree statements = BIND_EXPR_BODY(block_tree);
while (statements != NULL_TREE
&& (TREE_CODE(statements) == TRY_FINALLY_EXPR
|| TREE_CODE(statements) == TRY_CATCH_EXPR))
statements = TREE_OPERAND(statements, 0);
// It's possible to have pre-init statements without an initializer
// if the pre-init statements set the variable.
if (this->init_ != NULL)
{
tree rhs_tree = this->init_->get_tree(&context);
if (rhs_tree == error_mark_node)
return error_mark_node;
if (var_decl == NULL_TREE)
append_to_statement_list(rhs_tree, &statements);
else
{
tree val = Expression::convert_for_assignment(&context, this->type(),
this->init_->type(),
rhs_tree,
this->location());
if (val == error_mark_node)
return error_mark_node;
tree set = fold_build2_loc(this->location(), MODIFY_EXPR,
void_type_node, var_decl, val);
append_to_statement_list(set, &statements);
}
}
return block_tree;
}
// Get a tree for a function decl.
tree
Function::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
{
if (this->fndecl_ == NULL_TREE)
{
tree functype = this->type_->get_tree(gogo);
if (functype == error_mark_node)
this->fndecl_ = error_mark_node;
else
{
// The type of a function comes back as a pointer, but we
// want the real function type for a function declaration.
gcc_assert(POINTER_TYPE_P(functype));
functype = TREE_TYPE(functype);
tree decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
this->fndecl_ = decl;
if (no->package() != NULL)
;
else if (this->enclosing_ != NULL || Gogo::is_thunk(no))
;
else if (Gogo::unpack_hidden_name(no->name()) == "init"
&& !this->type_->is_method())
;
else if (Gogo::unpack_hidden_name(no->name()) == "main"
&& gogo->is_main_package())
TREE_PUBLIC(decl) = 1;
// Methods have to be public even if they are hidden because
// they can be pulled into type descriptors when using
// anonymous fields.
else if (!Gogo::is_hidden_name(no->name())
|| this->type_->is_method())
{
TREE_PUBLIC(decl) = 1;
std::string asm_name = gogo->unique_prefix();
asm_name.append(1, '.');
asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
SET_DECL_ASSEMBLER_NAME(decl,
get_identifier_from_string(asm_name));
}
// Why do we have to do this in the frontend?
tree restype = TREE_TYPE(functype);
tree resdecl = build_decl(this->location(), RESULT_DECL, NULL_TREE,
restype);
DECL_ARTIFICIAL(resdecl) = 1;
DECL_IGNORED_P(resdecl) = 1;
DECL_CONTEXT(resdecl) = decl;
DECL_RESULT(decl) = resdecl;
if (this->enclosing_ != NULL)
DECL_STATIC_CHAIN(decl) = 1;
// If a function calls the predeclared recover function, we
// can't inline it, because recover behaves differently in a
// function passed directly to defer.
if (this->calls_recover_ && !this->is_recover_thunk_)
DECL_UNINLINABLE(decl) = 1;
// If this is a thunk created to call a function which calls
// the predeclared recover function, we need to disable
// stack splitting for the thunk.
if (this->is_recover_thunk_)
{
tree attr = get_identifier("__no_split_stack__");
DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
}
go_preserve_from_gc(decl);
if (this->closure_var_ != NULL)
{
push_struct_function(decl);
tree closure_decl = this->closure_var_->get_tree(gogo, no);
if (closure_decl == error_mark_node)
this->fndecl_ = error_mark_node;
else
{
DECL_ARTIFICIAL(closure_decl) = 1;
DECL_IGNORED_P(closure_decl) = 1;
TREE_USED(closure_decl) = 1;
DECL_ARG_TYPE(closure_decl) = TREE_TYPE(closure_decl);
TREE_READONLY(closure_decl) = 1;
DECL_STRUCT_FUNCTION(decl)->static_chain_decl = closure_decl;
}
pop_cfun();
}
}
}
return this->fndecl_;
}
// Get a tree for a function declaration.
tree
Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
{
if (this->fndecl_ == NULL_TREE)
{
// Let Go code use an asm declaration to pick up a builtin
// function.
if (!this->asm_name_.empty())
{
std::map<std::string, tree>::const_iterator p =
builtin_functions.find(this->asm_name_);
if (p != builtin_functions.end())
{
this->fndecl_ = p->second;
return this->fndecl_;
}
}
tree functype = this->fntype_->get_tree(gogo);
tree decl;
if (functype == error_mark_node)
decl = error_mark_node;
else
{
// The type of a function comes back as a pointer, but we
// want the real function type for a function declaration.
gcc_assert(POINTER_TYPE_P(functype));
functype = TREE_TYPE(functype);
decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
TREE_PUBLIC(decl) = 1;
DECL_EXTERNAL(decl) = 1;
if (this->asm_name_.empty())
{
std::string asm_name = (no->package() == NULL
? gogo->unique_prefix()
: no->package()->unique_prefix());
asm_name.append(1, '.');
asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
SET_DECL_ASSEMBLER_NAME(decl,
get_identifier_from_string(asm_name));
}
}
this->fndecl_ = decl;
go_preserve_from_gc(decl);
}
return this->fndecl_;
}
// We always pass the receiver to a method as a pointer. If the
// receiver is actually declared as a non-pointer type, then we copy
// the value into a local variable, so that it has the right type. In
// this function we create the real PARM_DECL to use, and set
// DEC_INITIAL of the var_decl to be the value passed in.
tree
Function::make_receiver_parm_decl(Gogo* gogo, Named_object* no, tree var_decl)
{
if (var_decl == error_mark_node)
return error_mark_node;
// If the function takes the address of a receiver which is passed
// by value, then we will have an INDIRECT_REF here. We need to get
// the real variable.
bool is_in_heap = no->var_value()->is_in_heap();
tree val_type;
if (TREE_CODE(var_decl) != INDIRECT_REF)
{
gcc_assert(!is_in_heap);
val_type = TREE_TYPE(var_decl);
}
else
{
gcc_assert(is_in_heap);
var_decl = TREE_OPERAND(var_decl, 0);
if (var_decl == error_mark_node)
return error_mark_node;
gcc_assert(POINTER_TYPE_P(TREE_TYPE(var_decl)));
val_type = TREE_TYPE(TREE_TYPE(var_decl));
}
gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
source_location loc = DECL_SOURCE_LOCATION(var_decl);
std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
name += ".pointer";
tree id = get_identifier_from_string(name);
tree parm_decl = build_decl(loc, PARM_DECL, id, build_pointer_type(val_type));
DECL_CONTEXT(parm_decl) = current_function_decl;
DECL_ARG_TYPE(parm_decl) = TREE_TYPE(parm_decl);
gcc_assert(DECL_INITIAL(var_decl) == NULL_TREE);
// The receiver might be passed as a null pointer.
tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node, parm_decl,
fold_convert_loc(loc, TREE_TYPE(parm_decl),
null_pointer_node));
tree ind = build_fold_indirect_ref_loc(loc, parm_decl);
TREE_THIS_NOTRAP(ind) = 1;
tree zero_init = no->var_value()->type()->get_init_tree(gogo, false);
tree init = fold_build3_loc(loc, COND_EXPR, TREE_TYPE(ind),
check, ind, zero_init);
if (is_in_heap)
{
tree size = TYPE_SIZE_UNIT(val_type);
tree space = gogo->allocate_memory(no->var_value()->type(), size,
no->location());
space = save_expr(space);
space = fold_convert(build_pointer_type(val_type), space);
tree spaceref = build_fold_indirect_ref_loc(no->location(), space);
TREE_THIS_NOTRAP(spaceref) = 1;
tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node,
parm_decl,
fold_convert_loc(loc, TREE_TYPE(parm_decl),
null_pointer_node));
tree parmref = build_fold_indirect_ref_loc(no->location(), parm_decl);
TREE_THIS_NOTRAP(parmref) = 1;
tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
spaceref, parmref);
init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
build3(COND_EXPR, void_type_node,
check, set, NULL_TREE),
space);
}
DECL_INITIAL(var_decl) = init;
return parm_decl;
}
// If we take the address of a parameter, then we need to copy it into
// the heap. We will access it as a local variable via an
// indirection.
tree
Function::copy_parm_to_heap(Gogo* gogo, Named_object* no, tree ref)
{
if (ref == error_mark_node)
return error_mark_node;
gcc_assert(TREE_CODE(ref) == INDIRECT_REF);
tree var_decl = TREE_OPERAND(ref, 0);
if (var_decl == error_mark_node)
return error_mark_node;
gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
source_location loc = DECL_SOURCE_LOCATION(var_decl);
std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
name += ".param";
tree id = get_identifier_from_string(name);
tree type = TREE_TYPE(var_decl);
gcc_assert(POINTER_TYPE_P(type));
type = TREE_TYPE(type);
tree parm_decl = build_decl(loc, PARM_DECL, id, type);
DECL_CONTEXT(parm_decl) = current_function_decl;
DECL_ARG_TYPE(parm_decl) = type;
tree size = TYPE_SIZE_UNIT(type);
tree space = gogo->allocate_memory(no->var_value()->type(), size, loc);
space = save_expr(space);
space = fold_convert(TREE_TYPE(var_decl), space);
tree spaceref = build_fold_indirect_ref_loc(loc, space);
TREE_THIS_NOTRAP(spaceref) = 1;
tree init = build2(COMPOUND_EXPR, TREE_TYPE(space),
build2(MODIFY_EXPR, void_type_node, spaceref, parm_decl),
space);
DECL_INITIAL(var_decl) = init;
return parm_decl;
}
// Get a tree for function code.
void
Function::build_tree(Gogo* gogo, Named_object* named_function)
{
tree fndecl = this->fndecl_;
gcc_assert(fndecl != NULL_TREE);
tree params = NULL_TREE;
tree* pp = &params;
tree declare_vars = NULL_TREE;
for (Bindings::const_definitions_iterator p =
this->block_->bindings()->begin_definitions();
p != this->block_->bindings()->end_definitions();
++p)
{
if ((*p)->is_variable() && (*p)->var_value()->is_parameter())
{
*pp = (*p)->get_tree(gogo, named_function);
// We always pass the receiver to a method as a pointer. If
// the receiver is declared as a non-pointer type, then we
// copy the value into a local variable.
if ((*p)->var_value()->is_receiver()
&& (*p)->var_value()->type()->points_to() == NULL)
{
tree parm_decl = this->make_receiver_parm_decl(gogo, *p, *pp);
tree var = *pp;
if (TREE_CODE(var) == INDIRECT_REF)
var = TREE_OPERAND(var, 0);
if (var != error_mark_node)
{
gcc_assert(TREE_CODE(var) == VAR_DECL);
DECL_CHAIN(var) = declare_vars;
declare_vars = var;
}
*pp = parm_decl;
}
else if ((*p)->var_value()->is_in_heap())
{
// If we take the address of a parameter, then we need
// to copy it into the heap.
tree parm_decl = this->copy_parm_to_heap(gogo, *p, *pp);
if (*pp != error_mark_node)
{
gcc_assert(TREE_CODE(*pp) == INDIRECT_REF);
tree var_decl = TREE_OPERAND(*pp, 0);
if (var_decl != error_mark_node)
{
gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
DECL_CHAIN(var_decl) = declare_vars;
declare_vars = var_decl;
}
}
*pp = parm_decl;
}
if (*pp != error_mark_node)
{
gcc_assert(TREE_CODE(*pp) == PARM_DECL);
pp = &DECL_CHAIN(*pp);
}
}
else if ((*p)->is_result_variable())
{
tree var_decl = (*p)->get_tree(gogo, named_function);
if (var_decl != error_mark_node
&& (*p)->result_var_value()->is_in_heap())
{
gcc_assert(TREE_CODE(var_decl) == INDIRECT_REF);
var_decl = TREE_OPERAND(var_decl, 0);
}
if (var_decl != error_mark_node)
{
gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
DECL_CHAIN(var_decl) = declare_vars;
declare_vars = var_decl;
}
}
}
*pp = NULL_TREE;
DECL_ARGUMENTS(fndecl) = params;
if (this->block_ != NULL)
{
gcc_assert(DECL_INITIAL(fndecl) == NULL_TREE);
// Declare variables if necessary.
tree bind = NULL_TREE;
if (declare_vars != NULL_TREE)
{
tree block = make_node(BLOCK);
BLOCK_SUPERCONTEXT(block) = fndecl;
DECL_INITIAL(fndecl) = block;
BLOCK_VARS(block) = declare_vars;
TREE_USED(block) = 1;
bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block),
NULL_TREE, block);
TREE_SIDE_EFFECTS(bind) = 1;
}
// Build the trees for all the statements in the function.
Translate_context context(gogo, named_function, NULL, NULL_TREE);
tree code = this->block_->get_tree(&context);
tree init = NULL_TREE;
tree except = NULL_TREE;
tree fini = NULL_TREE;
// Initialize variables if necessary.
for (tree v = declare_vars; v != NULL_TREE; v = DECL_CHAIN(v))
{
tree dv = build1(DECL_EXPR, void_type_node, v);
SET_EXPR_LOCATION(dv, DECL_SOURCE_LOCATION(v));
append_to_statement_list(dv, &init);
}
// If we have a defer stack, initialize it at the start of a
// function.
if (this->defer_stack_ != NULL_TREE)
{
tree defer_init = build1(DECL_EXPR, void_type_node,
this->defer_stack_);
SET_EXPR_LOCATION(defer_init, this->block_->start_location());
append_to_statement_list(defer_init, &init);
// Clean up the defer stack when we leave the function.
this->build_defer_wrapper(gogo, named_function, &except, &fini);
}
if (code != NULL_TREE && code != error_mark_node)
{
if (init != NULL_TREE)
code = build2(COMPOUND_EXPR, void_type_node, init, code);
if (except != NULL_TREE)
code = build2(TRY_CATCH_EXPR, void_type_node, code,
build2(CATCH_EXPR, void_type_node, NULL, except));
if (fini != NULL_TREE)
code = build2(TRY_FINALLY_EXPR, void_type_node, code, fini);
}
// Stick the code into the block we built for the receiver, if
// we built on.
if (bind != NULL_TREE && code != NULL_TREE && code != error_mark_node)
{
BIND_EXPR_BODY(bind) = code;
code = bind;
}
DECL_SAVED_TREE(fndecl) = code;
}
}
// Build the wrappers around function code needed if the function has
// any defer statements. This sets *EXCEPT to an exception handler
// and *FINI to a finally handler.
void
Function::build_defer_wrapper(Gogo* gogo, Named_object* named_function,
tree *except, tree *fini)
{
source_location end_loc = this->block_->end_location();
// Add an exception handler. This is used if a panic occurs. Its
// purpose is to stop the stack unwinding if a deferred function
// calls recover. There are more details in
// libgo/runtime/go-unwind.c.
tree stmt_list = NULL_TREE;
static tree check_fndecl;
tree call = Gogo::call_builtin(&check_fndecl,
end_loc,
"__go_check_defer",
1,
void_type_node,
ptr_type_node,
this->defer_stack(end_loc));
if (call != error_mark_node)
append_to_statement_list(call, &stmt_list);
tree retval = this->return_value(gogo, named_function, end_loc, &stmt_list);
tree set;
if (retval == NULL_TREE)
set = NULL_TREE;
else
set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
DECL_RESULT(this->fndecl_), retval);
tree ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
append_to_statement_list(ret_stmt, &stmt_list);
gcc_assert(*except == NULL_TREE);
*except = stmt_list;
// Add some finally code to run the defer functions. This is used
// both in the normal case, when no panic occurs, and also if a
// panic occurs to run any further defer functions. Of course, it
// is possible for a defer function to call panic which should be
// caught by another defer function. To handle that we use a loop.
// finish:
// try { __go_undefer(); } catch { __go_check_defer(); goto finish; }
// if (return values are named) return named_vals;
stmt_list = NULL;
tree label = create_artificial_label(end_loc);
tree define_label = fold_build1_loc(end_loc, LABEL_EXPR, void_type_node,
label);
append_to_statement_list(define_label, &stmt_list);
static tree undefer_fndecl;
tree undefer = Gogo::call_builtin(&undefer_fndecl,
end_loc,
"__go_undefer",
1,
void_type_node,
ptr_type_node,
this->defer_stack(end_loc));
if (undefer_fndecl != NULL_TREE)
TREE_NOTHROW(undefer_fndecl) = 0;
tree defer = Gogo::call_builtin(&check_fndecl,
end_loc,
"__go_check_defer",
1,
void_type_node,
ptr_type_node,
this->defer_stack(end_loc));
tree jump = fold_build1_loc(end_loc, GOTO_EXPR, void_type_node, label);
tree catch_body = build2(COMPOUND_EXPR, void_type_node, defer, jump);
catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
tree try_catch = build2(TRY_CATCH_EXPR, void_type_node, undefer, catch_body);
append_to_statement_list(try_catch, &stmt_list);
if (this->type_->results() != NULL
&& !this->type_->results()->empty()
&& !this->type_->results()->front().name().empty())
{
// If the result variables are named, we need to return them
// again, because they might have been changed by a defer
// function.
retval = this->return_value(gogo, named_function, end_loc,
&stmt_list);
set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
DECL_RESULT(this->fndecl_), retval);
ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
append_to_statement_list(ret_stmt, &stmt_list);
}
gcc_assert(*fini == NULL_TREE);
*fini = stmt_list;
}
// Return the value to assign to DECL_RESULT(this->fndecl_). This may
// also add statements to STMT_LIST, which need to be executed before
// the assignment. This is used for a return statement with no
// explicit values.
tree
Function::return_value(Gogo* gogo, Named_object* named_function,
source_location location, tree* stmt_list) const
{
const Typed_identifier_list* results = this->type_->results();
if (results == NULL || results->empty())
return NULL_TREE;
// In the case of an exception handler created for functions with
// defer statements, the result variables may be unnamed.
bool is_named = !results->front().name().empty();
if (is_named)
{
gcc_assert(this->named_results_ != NULL);
if (this->named_results_->size() != results->size())
{
gcc_assert(saw_errors());
return error_mark_node;
}
}
tree retval;
if (results->size() == 1)
{
if (is_named)
return this->named_results_->front()->get_tree(gogo, named_function);
else
return results->front().type()->get_init_tree(gogo, false);
}
else
{
tree rettype = TREE_TYPE(DECL_RESULT(this->fndecl_));
retval = create_tmp_var(rettype, "RESULT");
tree field = TYPE_FIELDS(rettype);
int index = 0;
for (Typed_identifier_list::const_iterator pr = results->begin();
pr != results->end();
++pr, ++index, field = DECL_CHAIN(field))
{
gcc_assert(field != NULL);
tree val;
if (is_named)
val = (*this->named_results_)[index]->get_tree(gogo,
named_function);
else
val = pr->type()->get_init_tree(gogo, false);
tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
build3(COMPONENT_REF, TREE_TYPE(field),
retval, field, NULL_TREE),
val);
append_to_statement_list(set, stmt_list);
}
return retval;
}
}
// Get the tree for the variable holding the defer stack for this
// function. At least at present, the value of this variable is not
// used. However, a pointer to this variable is used as a marker for
// the functions on the defer stack associated with this function.
// Doing things this way permits inlining a function which uses defer.
tree
Function::defer_stack(source_location location)
{
if (this->defer_stack_ == NULL_TREE)
{
tree var = create_tmp_var(ptr_type_node, "DEFER");
DECL_INITIAL(var) = null_pointer_node;
DECL_SOURCE_LOCATION(var) = location;
TREE_ADDRESSABLE(var) = 1;
this->defer_stack_ = var;
}
return fold_convert_loc(location, ptr_type_node,
build_fold_addr_expr_loc(location,
this->defer_stack_));
}
// Get a tree for the statements in a block.
tree
Block::get_tree(Translate_context* context)
{
Gogo* gogo = context->gogo();
tree block = make_node(BLOCK);
// Put the new block into the block tree.
if (context->block() == NULL)
{
tree fndecl;
if (context->function() != NULL)
fndecl = context->function()->func_value()->get_decl();
else
fndecl = current_function_decl;
gcc_assert(fndecl != NULL_TREE);
// We may have already created a block for the receiver.
if (DECL_INITIAL(fndecl) == NULL_TREE)
{
BLOCK_SUPERCONTEXT(block) = fndecl;
DECL_INITIAL(fndecl) = block;
}
else
{
tree superblock_tree = DECL_INITIAL(fndecl);
BLOCK_SUPERCONTEXT(block) = superblock_tree;
gcc_assert(BLOCK_CHAIN(block) == NULL_TREE);
BLOCK_CHAIN(block) = block;
}
}
else
{
tree superblock_tree = context->block_tree();
BLOCK_SUPERCONTEXT(block) = superblock_tree;
tree* pp;
for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
*pp != NULL_TREE;
pp = &BLOCK_CHAIN(*pp))
;
*pp = block;
}
// Expand local variables in the block.
tree* pp = &BLOCK_VARS(block);
for (Bindings::const_definitions_iterator pv =
this->bindings_->begin_definitions();
pv != this->bindings_->end_definitions();
++pv)
{
if ((!(*pv)->is_variable() || !(*pv)->var_value()->is_parameter())
&& !(*pv)->is_result_variable()
&& !(*pv)->is_const())
{
tree var = (*pv)->get_tree(gogo, context->function());
if (var != error_mark_node && TREE_TYPE(var) != error_mark_node)
{
if ((*pv)->is_variable() && (*pv)->var_value()->is_in_heap())
{
gcc_assert(TREE_CODE(var) == INDIRECT_REF);
var = TREE_OPERAND(var, 0);
gcc_assert(TREE_CODE(var) == VAR_DECL);
}
*pp = var;
pp = &DECL_CHAIN(*pp);
}
}
}
*pp = NULL_TREE;
Translate_context subcontext(context->gogo(), context->function(),
this, block);
tree statements = NULL_TREE;
// Expand the statements.
for (std::vector<Statement*>::const_iterator p = this->statements_.begin();
p != this->statements_.end();
++p)
{
tree statement = (*p)->get_tree(&subcontext);
if (statement != error_mark_node)
append_to_statement_list(statement, &statements);
}
TREE_USED(block) = 1;
tree bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block), statements,
block);
TREE_SIDE_EFFECTS(bind) = 1;
return bind;
}
// Get the LABEL_DECL for a label.
tree
Label::get_decl()
{
if (this->decl_ == NULL)
{
tree id = get_identifier_from_string(this->name_);
this->decl_ = build_decl(this->location_, LABEL_DECL, id, void_type_node);
DECL_CONTEXT(this->decl_) = current_function_decl;
}
return this->decl_;
}
// Return an expression for the address of this label.
tree
Label::get_addr(source_location location)
{
tree decl = this->get_decl();
TREE_USED(decl) = 1;
TREE_ADDRESSABLE(decl) = 1;
return fold_convert_loc(location, ptr_type_node,
build_fold_addr_expr_loc(location, decl));
}
// Get the LABEL_DECL for an unnamed label.
tree
Unnamed_label::get_decl()
{
if (this->decl_ == NULL)
this->decl_ = create_artificial_label(this->location_);
return this->decl_;
}
// Get the LABEL_EXPR for an unnamed label.
tree
Unnamed_label::get_definition()
{
tree t = build1(LABEL_EXPR, void_type_node, this->get_decl());
SET_EXPR_LOCATION(t, this->location_);
return t;
}
// Return a goto to this label.
tree
Unnamed_label::get_goto(source_location location)
{
tree t = build1(GOTO_EXPR, void_type_node, this->get_decl());
SET_EXPR_LOCATION(t, location);
return t;
}
// Return the integer type to use for a size.
GO_EXTERN_C
tree
go_type_for_size(unsigned int bits, int unsignedp)
{
const char* name;
switch (bits)
{
case 8:
name = unsignedp ? "uint8" : "int8";
break;
case 16:
name = unsignedp ? "uint16" : "int16";
break;
case 32:
name = unsignedp ? "uint32" : "int32";
break;
case 64:
name = unsignedp ? "uint64" : "int64";
break;
default:
if (bits == POINTER_SIZE && unsignedp)
name = "uintptr";
else
return NULL_TREE;
}
Type* type = Type::lookup_integer_type(name);
return type->get_tree(go_get_gogo());
}
// Return the type to use for a mode.
GO_EXTERN_C
tree
go_type_for_mode(enum machine_mode mode, int unsignedp)
{
// FIXME: This static_cast should be in machmode.h.
enum mode_class mc = static_cast<enum mode_class>(GET_MODE_CLASS(mode));
if (mc == MODE_INT)
return go_type_for_size(GET_MODE_BITSIZE(mode), unsignedp);
else if (mc == MODE_FLOAT)
{
Type* type;
switch (GET_MODE_BITSIZE (mode))
{
case 32:
type = Type::lookup_float_type("float32");
break;
case 64:
type = Type::lookup_float_type("float64");
break;
default:
// We have to check for long double in order to support
// i386 excess precision.
if (mode == TYPE_MODE(long_double_type_node))
return long_double_type_node;
return NULL_TREE;
}
return type->float_type()->type_tree();
}
else if (mc == MODE_COMPLEX_FLOAT)
{
Type *type;
switch (GET_MODE_BITSIZE (mode))
{
case 64:
type = Type::lookup_complex_type("complex64");
break;
case 128:
type = Type::lookup_complex_type("complex128");
break;
default:
// We have to check for long double in order to support
// i386 excess precision.
if (mode == TYPE_MODE(complex_long_double_type_node))
return complex_long_double_type_node;
return NULL_TREE;
}
return type->complex_type()->type_tree();
}
else
return NULL_TREE;
}
// Return a tree which allocates SIZE bytes which will holds value of
// type TYPE.
tree
Gogo::allocate_memory(Type* type, tree size, source_location location)
{
// If the package imports unsafe, then it may play games with
// pointers that look like integers.
if (this->imported_unsafe_ || type->has_pointer())
{
static tree new_fndecl;
return Gogo::call_builtin(&new_fndecl,
location,
"__go_new",
1,
ptr_type_node,
sizetype,
size);
}
else
{
static tree new_nopointers_fndecl;
return Gogo::call_builtin(&new_nopointers_fndecl,
location,
"__go_new_nopointers",
1,
ptr_type_node,
sizetype,
size);
}
}
// Build a builtin struct with a list of fields. The name is
// STRUCT_NAME. STRUCT_TYPE is NULL_TREE or an empty RECORD_TYPE
// node; this exists so that the struct can have fields which point to
// itself. If PTYPE is not NULL, store the result in *PTYPE. There
// are NFIELDS fields. Each field is a name (a const char*) followed
// by a type (a tree).
tree
Gogo::builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
int nfields, ...)
{
if (ptype != NULL && *ptype != NULL_TREE)
return *ptype;
va_list ap;
va_start(ap, nfields);
tree fields = NULL_TREE;
for (int i = 0; i < nfields; ++i)
{
const char* field_name = va_arg(ap, const char*);
tree type = va_arg(ap, tree);
if (type == error_mark_node)
{
if (ptype != NULL)
*ptype = error_mark_node;
return error_mark_node;
}
tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL,
get_identifier(field_name), type);
DECL_CHAIN(field) = fields;
fields = field;
}
va_end(ap);
if (struct_type == NULL_TREE)
struct_type = make_node(RECORD_TYPE);
finish_builtin_struct(struct_type, struct_name, fields, NULL_TREE);
if (ptype != NULL)
{
go_preserve_from_gc(struct_type);
*ptype = struct_type;
}
return struct_type;
}
// Return a type to use for pointer to const char for a string.
tree
Gogo::const_char_pointer_type_tree()
{
static tree type;
if (type == NULL_TREE)
{
tree const_char_type = build_qualified_type(unsigned_char_type_node,
TYPE_QUAL_CONST);
type = build_pointer_type(const_char_type);
go_preserve_from_gc(type);
}
return type;
}
// Return a tree for a string constant.
tree
Gogo::string_constant_tree(const std::string& val)
{
tree index_type = build_index_type(size_int(val.length()));
tree const_char_type = build_qualified_type(unsigned_char_type_node,
TYPE_QUAL_CONST);
tree string_type = build_array_type(const_char_type, index_type);
string_type = build_variant_type_copy(string_type);
TYPE_STRING_FLAG(string_type) = 1;
tree string_val = build_string(val.length(), val.data());
TREE_TYPE(string_val) = string_type;
return string_val;
}
// Return a tree for a Go string constant.
tree
Gogo::go_string_constant_tree(const std::string& val)
{
tree string_type = Type::make_string_type()->get_tree(this);
VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
tree field = TYPE_FIELDS(string_type);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__data") == 0);
elt->index = field;
tree str = Gogo::string_constant_tree(val);
elt->value = fold_convert(TREE_TYPE(field),
build_fold_addr_expr(str));
elt = VEC_quick_push(constructor_elt, init, NULL);
field = DECL_CHAIN(field);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__length") == 0);
elt->index = field;
elt->value = build_int_cst_type(TREE_TYPE(field), val.length());
tree constructor = build_constructor(string_type, init);
TREE_READONLY(constructor) = 1;
TREE_CONSTANT(constructor) = 1;
return constructor;
}
// Return a tree for a pointer to a Go string constant. This is only
// used for type descriptors, so we return a pointer to a constant
// decl.
tree
Gogo::ptr_go_string_constant_tree(const std::string& val)
{
tree pval = this->go_string_constant_tree(val);
tree decl = build_decl(UNKNOWN_LOCATION, VAR_DECL,
create_tmp_var_name("SP"), TREE_TYPE(pval));
DECL_EXTERNAL(decl) = 0;
TREE_PUBLIC(decl) = 0;
TREE_USED(decl) = 1;
TREE_READONLY(decl) = 1;
TREE_CONSTANT(decl) = 1;
TREE_STATIC(decl) = 1;
DECL_ARTIFICIAL(decl) = 1;
DECL_INITIAL(decl) = pval;
rest_of_decl_compilation(decl, 1, 0);
return build_fold_addr_expr(decl);
}
// Build the type of the struct that holds a slice for the given
// element type.
tree
Gogo::slice_type_tree(tree element_type_tree)
{
// We use int for the count and capacity fields in a slice header.
// This matches 6g. The language definition guarantees that we
// can't allocate space of a size which does not fit in int
// anyhow. FIXME: integer_type_node is the the C type "int" but is
// not necessarily the Go type "int". They will differ when the C
// type "int" has fewer than 32 bits.
return Gogo::builtin_struct(NULL, "__go_slice", NULL_TREE, 3,
"__values",
build_pointer_type(element_type_tree),
"__count",
integer_type_node,
"__capacity",
integer_type_node);
}
// Given the tree for a slice type, return the tree for the type of
// the elements of the slice.
tree
Gogo::slice_element_type_tree(tree slice_type_tree)
{
gcc_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE
&& POINTER_TYPE_P(TREE_TYPE(TYPE_FIELDS(slice_type_tree))));
return TREE_TYPE(TREE_TYPE(TYPE_FIELDS(slice_type_tree)));
}
// Build a constructor for a slice. SLICE_TYPE_TREE is the type of
// the slice. VALUES is the value pointer and COUNT is the number of
// entries. If CAPACITY is not NULL, it is the capacity; otherwise
// the capacity and the count are the same.
tree
Gogo::slice_constructor(tree slice_type_tree, tree values, tree count,
tree capacity)
{
gcc_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE);
VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
tree field = TYPE_FIELDS(slice_type_tree);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
elt->index = field;
gcc_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field))
== TYPE_MAIN_VARIANT(TREE_TYPE(values)));
elt->value = values;
count = fold_convert(sizetype, count);
if (capacity == NULL_TREE)
{
count = save_expr(count);
capacity = count;
}
field = DECL_CHAIN(field);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
elt = VEC_quick_push(constructor_elt, init, NULL);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), count);
field = DECL_CHAIN(field);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
elt = VEC_quick_push(constructor_elt, init, NULL);
elt->index = field;
elt->value = fold_convert(TREE_TYPE(field), capacity);
return build_constructor(slice_type_tree, init);
}
// Build a constructor for an empty slice.
tree
Gogo::empty_slice_constructor(tree slice_type_tree)
{
tree element_field = TYPE_FIELDS(slice_type_tree);
tree ret = Gogo::slice_constructor(slice_type_tree,
fold_convert(TREE_TYPE(element_field),
null_pointer_node),
size_zero_node,
size_zero_node);
TREE_CONSTANT(ret) = 1;
return ret;
}
// Build a map descriptor for a map of type MAPTYPE.
tree
Gogo::map_descriptor(Map_type* maptype)
{
if (this->map_descriptors_ == NULL)
this->map_descriptors_ = new Map_descriptors(10);
std::pair<const Map_type*, tree> val(maptype, NULL);
std::pair<Map_descriptors::iterator, bool> ins =
this->map_descriptors_->insert(val);
Map_descriptors::iterator p = ins.first;
if (!ins.second)
{
if (p->second == error_mark_node)
return error_mark_node;
gcc_assert(p->second != NULL_TREE && DECL_P(p->second));
return build_fold_addr_expr(p->second);
}
Type* keytype = maptype->key_type();
Type* valtype = maptype->val_type();
std::string mangled_name = ("__go_map_" + maptype->mangled_name(this));
tree id = get_identifier_from_string(mangled_name);
// Get the type of the map descriptor. This is __go_map_descriptor
// in libgo/map.h.
tree struct_type = this->map_descriptor_type();
// The map entry type is a struct with three fields. This struct is
// specific to MAPTYPE. Build it.
tree map_entry_type = make_node(RECORD_TYPE);
map_entry_type = Gogo::builtin_struct(NULL, "__map", map_entry_type, 3,
"__next",
build_pointer_type(map_entry_type),
"__key",
keytype->get_tree(this),
"__val",
valtype->get_tree(this));
if (map_entry_type == error_mark_node)
{
p->second = error_mark_node;
return error_mark_node;
}
tree map_entry_key_field = DECL_CHAIN(TYPE_FIELDS(map_entry_type));
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_key_field)),
"__key") == 0);
tree map_entry_val_field = DECL_CHAIN(map_entry_key_field);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_val_field)),
"__val") == 0);
// Initialize the entries.
tree map_descriptor_field = TYPE_FIELDS(struct_type);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_descriptor_field)),
"__map_descriptor") == 0);
tree entry_size_field = DECL_CHAIN(map_descriptor_field);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(entry_size_field)),
"__entry_size") == 0);
tree key_offset_field = DECL_CHAIN(entry_size_field);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(key_offset_field)),
"__key_offset") == 0);
tree val_offset_field = DECL_CHAIN(key_offset_field);
gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(val_offset_field)),
"__val_offset") == 0);
VEC(constructor_elt, gc)* descriptor = VEC_alloc(constructor_elt, gc, 6);
constructor_elt* elt = VEC_quick_push(constructor_elt, descriptor, NULL);
elt->index = map_descriptor_field;
elt->value = maptype->type_descriptor_pointer(this);
elt = VEC_quick_push(constructor_elt, descriptor, NULL);
elt->index = entry_size_field;
elt->value = TYPE_SIZE_UNIT(map_entry_type);
elt = VEC_quick_push(constructor_elt, descriptor, NULL);
elt->index = key_offset_field;
elt->value = byte_position(map_entry_key_field);
elt = VEC_quick_push(constructor_elt, descriptor, NULL);
elt->index = val_offset_field;
elt->value = byte_position(map_entry_val_field);
tree constructor = build_constructor(struct_type, descriptor);
tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, struct_type);
TREE_STATIC(decl) = 1;
TREE_USED(decl) = 1;
TREE_READONLY(decl) = 1;
TREE_CONSTANT(decl) = 1;
DECL_INITIAL(decl) = constructor;
make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
resolve_unique_section(decl, 1, 0);
rest_of_decl_compilation(decl, 1, 0);
go_preserve_from_gc(decl);
p->second = decl;
return build_fold_addr_expr(decl);
}
// Return a tree for the type of a map descriptor. This is struct
// __go_map_descriptor in libgo/runtime/map.h. This is the same for
// all map types.
tree
Gogo::map_descriptor_type()
{
static tree struct_type;
tree dtype = Type::make_type_descriptor_type()->get_tree(this);
dtype = build_qualified_type(dtype, TYPE_QUAL_CONST);
return Gogo::builtin_struct(&struct_type, "__go_map_descriptor", NULL_TREE,
4,
"__map_descriptor",
build_pointer_type(dtype),
"__entry_size",
sizetype,
"__key_offset",
sizetype,
"__val_offset",
sizetype);
}
// Return the name to use for a type descriptor decl for TYPE. This
// is used when TYPE does not have a name.
std::string
Gogo::unnamed_type_descriptor_decl_name(const Type* type)
{
return "__go_td_" + type->mangled_name(this);
}
// Return the name to use for a type descriptor decl for a type named
// NAME, defined in the function IN_FUNCTION. IN_FUNCTION will
// normally be NULL.
std::string
Gogo::type_descriptor_decl_name(const Named_object* no,
const Named_object* in_function)
{
std::string ret = "__go_tdn_";
if (no->type_value()->is_builtin())
gcc_assert(in_function == NULL);
else
{
const std::string& unique_prefix(no->package() == NULL
? this->unique_prefix()
: no->package()->unique_prefix());
const std::string& package_name(no->package() == NULL
? this->package_name()
: no->package()->name());
ret.append(unique_prefix);
ret.append(1, '.');
ret.append(package_name);
ret.append(1, '.');
if (in_function != NULL)
{
ret.append(Gogo::unpack_hidden_name(in_function->name()));
ret.append(1, '.');
}
}
ret.append(no->name());
return ret;
}
// Where a type descriptor decl should be defined.
Gogo::Type_descriptor_location
Gogo::type_descriptor_location(const Type* type)
{
const Named_type* name = type->named_type();
if (name != NULL)
{
if (name->named_object()->package() != NULL)
{
// This is a named type defined in a different package. The
// descriptor should be defined in that package.
return TYPE_DESCRIPTOR_UNDEFINED;
}
else if (name->is_builtin())
{
// We create the descriptor for a builtin type whenever we
// need it.
return TYPE_DESCRIPTOR_COMMON;
}
else
{
// This is a named type defined in this package. The
// descriptor should be defined here.
return TYPE_DESCRIPTOR_DEFINED;
}
}
else
{
if (type->points_to() != NULL
&& type->points_to()->named_type() != NULL
&& type->points_to()->named_type()->named_object()->package() != NULL)
{
// This is an unnamed pointer to a named type defined in a
// different package. The descriptor should be defined in
// that package.
return TYPE_DESCRIPTOR_UNDEFINED;
}
else
{
// This is an unnamed type. The descriptor could be defined
// in any package where it is needed, and the linker will
// pick one descriptor to keep.
return TYPE_DESCRIPTOR_COMMON;
}
}
}
// Build a type descriptor decl for TYPE. INITIALIZER is a struct
// composite literal which initializers the type descriptor.
void
Gogo::build_type_descriptor_decl(const Type* type, Expression* initializer,
tree* pdecl)
{
const Named_type* name = type->named_type();
// We can have multiple instances of unnamed types, but we only want
// to emit the type descriptor once. We use a hash table to handle
// this. This is not necessary for named types, as they are unique,
// and we store the type descriptor decl in the type itself.
tree* phash = NULL;
if (name == NULL)
{
if (this->type_descriptor_decls_ == NULL)
this->type_descriptor_decls_ = new Type_descriptor_decls(10);
std::pair<Type_descriptor_decls::iterator, bool> ins =
this->type_descriptor_decls_->insert(std::make_pair(type, NULL_TREE));
if (!ins.second)
{
// We've already built a type descriptor for this type.
*pdecl = ins.first->second;
return;
}
phash = &ins.first->second;
}
std::string decl_name;
if (name == NULL)
decl_name = this->unnamed_type_descriptor_decl_name(type);
else
decl_name = this->type_descriptor_decl_name(name->named_object(),
name->in_function());
tree id = get_identifier_from_string(decl_name);
tree descriptor_type_tree = initializer->type()->get_tree(this);
if (descriptor_type_tree == error_mark_node)
{
*pdecl = error_mark_node;
return;
}
tree decl = build_decl(name == NULL ? BUILTINS_LOCATION : name->location(),
VAR_DECL, id,
build_qualified_type(descriptor_type_tree,
TYPE_QUAL_CONST));
TREE_READONLY(decl) = 1;
TREE_CONSTANT(decl) = 1;
DECL_ARTIFICIAL(decl) = 1;
go_preserve_from_gc(decl);
if (phash != NULL)
*phash = decl;
// We store the new DECL now because we may need to refer to it when
// expanding INITIALIZER.
*pdecl = decl;
// If appropriate, just refer to the exported type identifier.
Gogo::Type_descriptor_location type_descriptor_location =
this->type_descriptor_location(type);
if (type_descriptor_location == TYPE_DESCRIPTOR_UNDEFINED)
{
TREE_PUBLIC(decl) = 1;
DECL_EXTERNAL(decl) = 1;
return;
}
TREE_STATIC(decl) = 1;
TREE_USED(decl) = 1;
Translate_context context(this, NULL, NULL, NULL);
context.set_is_const();
tree constructor = initializer->get_tree(&context);
if (constructor == error_mark_node)
gcc_assert(saw_errors());
DECL_INITIAL(decl) = constructor;
if (type_descriptor_location == TYPE_DESCRIPTOR_DEFINED)
TREE_PUBLIC(decl) = 1;
else
{
gcc_assert(type_descriptor_location == TYPE_DESCRIPTOR_COMMON);
make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
resolve_unique_section(decl, 1, 0);
}
rest_of_decl_compilation(decl, 1, 0);
}
// Build an interface method table for a type: a list of function
// pointers, one for each interface method. This is used for
// interfaces.
tree
Gogo::interface_method_table_for_type(const Interface_type* interface,
Named_type* type,
bool is_pointer)
{
const Typed_identifier_list* interface_methods = interface->methods();
gcc_assert(!interface_methods->empty());
std::string mangled_name = ((is_pointer ? "__go_pimt__" : "__go_imt_")
+ interface->mangled_name(this)
+ "__"
+ type->mangled_name(this));
tree id = get_identifier_from_string(mangled_name);
// See whether this interface has any hidden methods.
bool has_hidden_methods = false;
for (Typed_identifier_list::const_iterator p = interface_methods->begin();
p != interface_methods->end();
++p)
{
if (Gogo::is_hidden_name(p->name()))
{
has_hidden_methods = true;
break;
}
}
// We already know that the named type is convertible to the
// interface. If the interface has hidden methods, and the named
// type is defined in a different package, then the interface
// conversion table will be defined by that other package.
if (has_hidden_methods && type->named_object()->package() != NULL)
{
tree array_type = build_array_type(const_ptr_type_node, NULL);
tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
TREE_READONLY(decl) = 1;
TREE_CONSTANT(decl) = 1;
TREE_PUBLIC(decl) = 1;
DECL_EXTERNAL(decl) = 1;
go_preserve_from_gc(decl);
return decl;
}
size_t count = interface_methods->size();
VEC(constructor_elt, gc)* pointers = VEC_alloc(constructor_elt, gc,
count + 1);
// The first element is the type descriptor.
constructor_elt* elt = VEC_quick_push(constructor_elt, pointers, NULL);
elt->index = size_zero_node;
Type* td_type;
if (!is_pointer)
td_type = type;
else
td_type = Type::make_pointer_type(type);
elt->value = fold_convert(const_ptr_type_node,
td_type->type_descriptor_pointer(this));
size_t i = 1;
for (Typed_identifier_list::const_iterator p = interface_methods->begin();
p != interface_methods->end();
++p, ++i)
{
bool is_ambiguous;
Method* m = type->method_function(p->name(), &is_ambiguous);
gcc_assert(m != NULL);
Named_object* no = m->named_object();
tree fnid = no->get_id(this);
tree fndecl;
if (no->is_function())
fndecl = no->func_value()->get_or_make_decl(this, no, fnid);
else if (no->is_function_declaration())
fndecl = no->func_declaration_value()->get_or_make_decl(this, no,
fnid);
else
gcc_unreachable();
fndecl = build_fold_addr_expr(fndecl);
elt = VEC_quick_push(constructor_elt, pointers, NULL);
elt->index = size_int(i);
elt->value = fold_convert(const_ptr_type_node, fndecl);
}
gcc_assert(i == count + 1);
tree array_type = build_array_type(const_ptr_type_node,
build_index_type(size_int(count)));
tree constructor = build_constructor(array_type, pointers);
tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
TREE_STATIC(decl) = 1;
TREE_USED(decl) = 1;
TREE_READONLY(decl) = 1;
TREE_CONSTANT(decl) = 1;
DECL_INITIAL(decl) = constructor;
// If the interface type has hidden methods, then this is the only
// definition of the table. Otherwise it is a comdat table which
// may be defined in multiple packages.
if (has_hidden_methods)
TREE_PUBLIC(decl) = 1;
else
{
make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
resolve_unique_section(decl, 1, 0);
}
rest_of_decl_compilation(decl, 1, 0);
go_preserve_from_gc(decl);
return decl;
}
// Mark a function as a builtin library function.
void
Gogo::mark_fndecl_as_builtin_library(tree fndecl)
{
DECL_EXTERNAL(fndecl) = 1;
TREE_PUBLIC(fndecl) = 1;
DECL_ARTIFICIAL(fndecl) = 1;
TREE_NOTHROW(fndecl) = 1;
DECL_VISIBILITY(fndecl) = VISIBILITY_DEFAULT;
DECL_VISIBILITY_SPECIFIED(fndecl) = 1;
}
// Build a call to a builtin function.
tree
Gogo::call_builtin(tree* pdecl, source_location location, const char* name,
int nargs, tree rettype, ...)
{
if (rettype == error_mark_node)
return error_mark_node;
tree* types = new tree[nargs];
tree* args = new tree[nargs];
va_list ap;
va_start(ap, rettype);
for (int i = 0; i < nargs; ++i)
{
types[i] = va_arg(ap, tree);
args[i] = va_arg(ap, tree);
if (types[i] == error_mark_node || args[i] == error_mark_node)
{
delete[] types;
delete[] args;
return error_mark_node;
}
}
va_end(ap);
if (*pdecl == NULL_TREE)
{
tree fnid = get_identifier(name);
tree argtypes = NULL_TREE;
tree* pp = &argtypes;
for (int i = 0; i < nargs; ++i)
{
*pp = tree_cons(NULL_TREE, types[i], NULL_TREE);
pp = &TREE_CHAIN(*pp);
}
*pp = void_list_node;
tree fntype = build_function_type(rettype, argtypes);
*pdecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL, fnid, fntype);
Gogo::mark_fndecl_as_builtin_library(*pdecl);
go_preserve_from_gc(*pdecl);
}
tree fnptr = build_fold_addr_expr(*pdecl);
if (CAN_HAVE_LOCATION_P(fnptr))
SET_EXPR_LOCATION(fnptr, location);
tree ret = build_call_array(rettype, fnptr, nargs, args);
SET_EXPR_LOCATION(ret, location);
delete[] types;
delete[] args;
return ret;
}
// Build a call to the runtime error function.
tree
Gogo::runtime_error(int code, source_location location)
{
static tree runtime_error_fndecl;
tree ret = Gogo::call_builtin(&runtime_error_fndecl,
location,
"__go_runtime_error",
1,
void_type_node,
integer_type_node,
build_int_cst(integer_type_node, code));
if (ret == error_mark_node)
return error_mark_node;
// The runtime error function panics and does not return.
TREE_NOTHROW(runtime_error_fndecl) = 0;
TREE_THIS_VOLATILE(runtime_error_fndecl) = 1;
return ret;
}
// Send VAL on CHANNEL. If BLOCKING is true, the resulting tree has a
// void type. If BLOCKING is false, the resulting tree has a boolean
// type, and it will evaluate as true if the value was sent. If
// FOR_SELECT is true, this is being done because it was chosen in a
// select statement.
tree
Gogo::send_on_channel(tree channel, tree val, bool blocking, bool for_select,
source_location location)
{
if (channel == error_mark_node || val == error_mark_node)
return error_mark_node;
if (int_size_in_bytes(TREE_TYPE(val)) <= 8
&& !AGGREGATE_TYPE_P(TREE_TYPE(val))
&& !FLOAT_TYPE_P(TREE_TYPE(val)))
{
val = convert_to_integer(uint64_type_node, val);
if (blocking)
{
static tree send_small_fndecl;
tree ret = Gogo::call_builtin(&send_small_fndecl,
location,
"__go_send_small",
3,
void_type_node,
ptr_type_node,
channel,
uint64_type_node,
val,
boolean_type_node,
(for_select
? boolean_true_node
: boolean_false_node));
if (ret == error_mark_node)
return error_mark_node;
// This can panic if there are too many operations on a
// closed channel.
TREE_NOTHROW(send_small_fndecl) = 0;
return ret;
}
else
{
gcc_assert(!for_select);
static tree send_nonblocking_small_fndecl;
tree ret = Gogo::call_builtin(&send_nonblocking_small_fndecl,
location,
"__go_send_nonblocking_small",
2,
boolean_type_node,
ptr_type_node,
channel,
uint64_type_node,
val);
if (ret == error_mark_node)
return error_mark_node;
// This can panic if there are too many operations on a
// closed channel.
TREE_NOTHROW(send_nonblocking_small_fndecl) = 0;
return ret;
}
}
else
{
tree make_tmp;
if (TREE_ADDRESSABLE(TREE_TYPE(val)) || TREE_CODE(val) == VAR_DECL)
{
make_tmp = NULL_TREE;
val = build_fold_addr_expr(val);
if (DECL_P(val))
TREE_ADDRESSABLE(val) = 1;
}
else
{
tree tmp = create_tmp_var(TREE_TYPE(val), get_name(val));
DECL_IGNORED_P(tmp) = 0;
DECL_INITIAL(tmp) = val;
TREE_ADDRESSABLE(tmp) = 1;
make_tmp = build1(DECL_EXPR, void_type_node, tmp);
SET_EXPR_LOCATION(make_tmp, location);
val = build_fold_addr_expr(tmp);
}
val = fold_convert(ptr_type_node, val);
tree call;
if (blocking)
{
static tree send_big_fndecl;
call = Gogo::call_builtin(&send_big_fndecl,
location,
"__go_send_big",
3,
void_type_node,
ptr_type_node,
channel,
ptr_type_node,
val,
boolean_type_node,
(for_select
? boolean_true_node
: boolean_false_node));
if (call == error_mark_node)
return error_mark_node;
// This can panic if there are too many operations on a
// closed channel.
TREE_NOTHROW(send_big_fndecl) = 0;
}
else
{
gcc_assert(!for_select);
static tree send_nonblocking_big_fndecl;
call = Gogo::call_builtin(&send_nonblocking_big_fndecl,
location,
"__go_send_nonblocking_big",
2,
boolean_type_node,
ptr_type_node,
channel,
ptr_type_node,
val);
if (call == error_mark_node)
return error_mark_node;
// This can panic if there are too many operations on a
// closed channel.
TREE_NOTHROW(send_nonblocking_big_fndecl) = 0;
}
if (make_tmp == NULL_TREE)
return call;
else
{
tree ret = build2(COMPOUND_EXPR, TREE_TYPE(call), make_tmp, call);
SET_EXPR_LOCATION(ret, location);
return ret;
}
}
}
// Return a tree for receiving a value of type TYPE_TREE on CHANNEL.
// This does a blocking receive and returns the value read from the
// channel. If FOR_SELECT is true, this is being done because it was
// chosen in a select statement.
tree
Gogo::receive_from_channel(tree type_tree, tree channel, bool for_select,
source_location location)
{
if (type_tree == error_mark_node || channel == error_mark_node)
return error_mark_node;
if (int_size_in_bytes(type_tree) <= 8
&& !AGGREGATE_TYPE_P(type_tree)
&& !FLOAT_TYPE_P(type_tree))
{
static tree receive_small_fndecl;
tree call = Gogo::call_builtin(&receive_small_fndecl,
location,
"__go_receive_small",
2,
uint64_type_node,
ptr_type_node,
channel,
boolean_type_node,
(for_select
? boolean_true_node
: boolean_false_node));
if (call == error_mark_node)
return error_mark_node;
// This can panic if there are too many operations on a closed
// channel.
TREE_NOTHROW(receive_small_fndecl) = 0;
int bitsize = GET_MODE_BITSIZE(TYPE_MODE(type_tree));
tree int_type_tree = go_type_for_size(bitsize, 1);
return fold_convert_loc(location, type_tree,
fold_convert_loc(location, int_type_tree,
call));
}
else
{
tree tmp = create_tmp_var(type_tree, get_name(type_tree));
DECL_IGNORED_P(tmp) = 0;
TREE_ADDRESSABLE(tmp) = 1;
tree make_tmp = build1(DECL_EXPR, void_type_node, tmp);
SET_EXPR_LOCATION(make_tmp, location);
tree tmpaddr = build_fold_addr_expr(tmp);
tmpaddr = fold_convert(ptr_type_node, tmpaddr);
static tree receive_big_fndecl;
tree call = Gogo::call_builtin(&receive_big_fndecl,
location,
"__go_receive_big",
3,
void_type_node,
ptr_type_node,
channel,
ptr_type_node,
tmpaddr,
boolean_type_node,
(for_select
? boolean_true_node
: boolean_false_node));
if (call == error_mark_node)
return error_mark_node;
// This can panic if there are too many operations on a closed
// channel.
TREE_NOTHROW(receive_big_fndecl) = 0;
return build2(COMPOUND_EXPR, type_tree, make_tmp,
build2(COMPOUND_EXPR, type_tree, call, tmp));
}
}
// Return the type of a function trampoline. This is like
// get_trampoline_type in tree-nested.c.
tree
Gogo::trampoline_type_tree()
{
static tree type_tree;
if (type_tree == NULL_TREE)
{
unsigned int size;
unsigned int align;
go_trampoline_info(&size, &align);
tree t = build_index_type(build_int_cst(integer_type_node, size - 1));
t = build_array_type(char_type_node, t);
type_tree = Gogo::builtin_struct(NULL, "__go_trampoline", NULL_TREE, 1,
"__data", t);
t = TYPE_FIELDS(type_tree);
DECL_ALIGN(t) = align;
DECL_USER_ALIGN(t) = 1;
go_preserve_from_gc(type_tree);
}
return type_tree;
}
// Make a trampoline which calls FNADDR passing CLOSURE.
tree
Gogo::make_trampoline(tree fnaddr, tree closure, source_location location)
{
tree trampoline_type = Gogo::trampoline_type_tree();
tree trampoline_size = TYPE_SIZE_UNIT(trampoline_type);
closure = save_expr(closure);
// We allocate the trampoline using a special function which will
// mark it as executable.
static tree trampoline_fndecl;
tree x = Gogo::call_builtin(&trampoline_fndecl,
location,
"__go_allocate_trampoline",
2,
ptr_type_node,
size_type_node,
trampoline_size,
ptr_type_node,
fold_convert_loc(location, ptr_type_node,
closure));
if (x == error_mark_node)
return error_mark_node;
x = save_expr(x);
// Initialize the trampoline.
tree ini = build_call_expr(implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE],
3, x, fnaddr, closure);
// On some targets the trampoline address needs to be adjusted. For
// example, when compiling in Thumb mode on the ARM, the address
// needs to have the low bit set.
x = build_call_expr(implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE],
1, x);
x = fold_convert(TREE_TYPE(fnaddr), x);
return build2(COMPOUND_EXPR, TREE_TYPE(x), ini, x);
}