This Go frontend patches passes the Gogo IR pointer to
Runtime::make_call. This is a boilerplate change that doesn't affect
compiler output. It's not currently used but will be used by later
CLs in this series. Bootstrapped and ran Go testsuite on
x86_64-pc-linux-gnu. Committed to mainline.
Ian
45a5ab0503569e57883dca4d8e76d83dc3a60ff6
diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index d4095637cea..d962c4f5770 100644
--- a/gcc/go/gofrontend/MERGE
+++ b/gcc/go/gofrontend/MERGE
@@ -1,4 +1,4 @@
-1c0a7c9338801d15afba7e39109554ed3406654e
+806217827fe30553d535f876f182a9e92f5f648e
The first line of this file holds the git revision number of the last
merge done from the gofrontend repository.
diff --git a/gcc/go/gofrontend/expressions.cc b/gcc/go/gofrontend/expressions.cc
index 5bea6238def..c7b442d3a03 100644
--- a/gcc/go/gofrontend/expressions.cc
+++ b/gcc/go/gofrontend/expressions.cc
@@ -305,8 +305,8 @@ Expression::convert_for_assignment(Gogo* gogo, Type*
lhs_type,
{
// Type to interface conversions have been made explicit early.
go_assert(rhs_type->interface_type() != NULL);
- return Expression::convert_interface_to_interface(lhs_type, rhs, false,
- location);
+ return Expression::convert_interface_to_interface(gogo, lhs_type, rhs,
+ false, location);
}
else if (!are_identical && rhs_type->interface_type() != NULL)
return Expression::convert_interface_to_type(gogo, lhs_type, rhs,
location);
@@ -525,7 +525,8 @@ Expression::get_interface_type_descriptor(Expression* rhs)
// interface type.
Expression*
-Expression::convert_interface_to_interface(Type *lhs_type, Expression* rhs,
+Expression::convert_interface_to_interface(Gogo* gogo, Type *lhs_type,
+ Expression* rhs,
bool for_type_guard,
Location location)
{
@@ -558,7 +559,7 @@ Expression::convert_interface_to_interface(Type *lhs_type,
Expression* rhs,
if (for_type_guard)
{
// A type assertion fails when converting a nil interface.
- first_field = Runtime::make_call(Runtime::ASSERTITAB, location, 2,
+ first_field = Runtime::make_call(gogo, Runtime::ASSERTITAB, location, 2,
lhs_type_expr, rhs_type_expr);
}
else if (lhs_is_empty)
@@ -571,7 +572,7 @@ Expression::convert_interface_to_interface(Type *lhs_type,
Expression* rhs,
{
// A conversion to a non-empty interface may fail, but unlike a
// type assertion converting nil will always succeed.
- first_field = Runtime::make_call(Runtime::REQUIREITAB, location, 2,
+ first_field = Runtime::make_call(gogo, Runtime::REQUIREITAB, location, 2,
lhs_type_expr, rhs_type_expr);
}
@@ -610,7 +611,7 @@ Expression::convert_interface_to_type(Gogo* gogo, Type
*lhs_type, Expression* rh
Expression* cond;
if (gogo->need_eqtype()) {
- cond = Runtime::make_call(Runtime::EQTYPE, location,
+ cond = Runtime::make_call(gogo, Runtime::EQTYPE, location,
2, lhs_type_expr,
rhs_descriptor);
} else {
@@ -619,7 +620,7 @@ Expression::convert_interface_to_type(Gogo* gogo, Type
*lhs_type, Expression* rh
}
rhs_descriptor = Expression::get_interface_type_descriptor(rhs);
- Expression* panic = Runtime::make_call(Runtime::PANICDOTTYPE, location,
+ Expression* panic = Runtime::make_call(gogo, Runtime::PANICDOTTYPE, location,
3, lhs_type_expr->copy(),
rhs_descriptor,
rhs_inter_expr);
@@ -719,7 +720,8 @@
Expression::backend_numeric_constant_expression(Translate_context* context,
// functions, which will panic.
void
-Expression::check_bounds(Expression* val, Operator op, Expression* bound,
+Expression::check_bounds(Gogo* gogo, Expression* val, Operator op,
+ Expression* bound,
Runtime::Function code,
Runtime::Function code_u,
Runtime::Function code_extend,
@@ -813,7 +815,7 @@ Expression::check_bounds(Expression* val, Operator op,
Expression* bound,
}
Expression* ignore = Expression::make_boolean(true, loc);
- Expression* crash = Runtime::make_call(c, loc, 2,
+ Expression* crash = Runtime::make_call(gogo, c, loc, 2,
val->copy(), bound->copy());
Expression* cond = Expression::make_conditional(check, ignore, crash, loc);
inserter->insert(Statement::make_statement(cond, true));
@@ -3916,7 +3918,7 @@ Type_conversion_expression::do_traverse(Traverse*
traverse)
// from slice to pointer-to-array, as they can panic.
Expression*
-Type_conversion_expression::do_lower(Gogo*, Named_object*,
+Type_conversion_expression::do_lower(Gogo* gogo, Named_object*,
Statement_inserter* inserter, int)
{
Type* type = this->type_;
@@ -4037,7 +4039,7 @@ Type_conversion_expression::do_lower(Gogo*, Named_object*,
location);
vallen = Expression::make_temporary_reference(vallen_temp, location);
- Expression* panic = Runtime::make_call(Runtime::PANIC_SLICE_CONVERT,
+ Expression* panic = Runtime::make_call(gogo,
Runtime::PANIC_SLICE_CONVERT,
location, 2, arrlen, vallen);
Expression* nil = Expression::make_nil(location);
@@ -4358,7 +4360,7 @@
Type_conversion_expression::do_get_backend(Translate_context* context)
else
buf = Expression::make_nil(loc);
Expression* i2s_expr =
- Runtime::make_call(Runtime::INTSTRING, loc, 2, buf, this->expr_);
+ Runtime::make_call(gogo, Runtime::INTSTRING, loc, 2, buf, this->expr_);
return Expression::make_cast(type, i2s_expr, loc)->get_backend(context);
}
else if (type->is_string_type() && expr_type->is_slice_type())
@@ -4396,14 +4398,14 @@
Type_conversion_expression::do_get_backend(Translate_context* context)
Expression* str = Expression::make_string_value(ptr, len, loc);
return str->get_backend(context);
}
- return Runtime::make_call(Runtime::SLICEBYTETOSTRING, loc, 3, buf,
- ptr, len)->get_backend(context);
+ return Runtime::make_call(gogo, Runtime::SLICEBYTETOSTRING, loc, 3,
+ buf, ptr, len)->get_backend(context);
}
else
{
go_assert(e->integer_type()->is_rune());
- return Runtime::make_call(Runtime::SLICERUNETOSTRING, loc, 2, buf,
- this->expr_)->get_backend(context);
+ return Runtime::make_call(gogo, Runtime::SLICERUNETOSTRING, loc, 2,
+ buf, this->expr_)->get_backend(context);
}
}
else if (type->is_slice_type() && expr_type->is_string_type())
@@ -4432,7 +4434,8 @@
Type_conversion_expression::do_get_backend(Translate_context* context)
}
else
buf = Expression::make_nil(loc);
- Expression* s2a = Runtime::make_call(code, loc, 2, buf, this->expr_);
+ Expression* s2a = Runtime::make_call(gogo, code, loc, 2, buf,
+ this->expr_);
return Expression::make_unsafe_cast(type, s2a,
loc)->get_backend(context);
}
else if (type->is_numeric_type())
@@ -5480,7 +5483,7 @@ Unary_expression::do_get_backend(Translate_context*
context)
Bexpression* compare =
gogo->backend()->binary_expression(OPERATOR_EQEQ, tbexpr,
nil, loc);
- Expression* crash = Runtime::make_call(Runtime::PANIC_MEM,
+ Expression* crash = Runtime::make_call(gogo, Runtime::PANIC_MEM,
loc, 0);
Bexpression* bcrash = crash->get_backend(context);
Bfunction* bfn = context->function()->func_value()->get_decl();
@@ -6626,7 +6629,8 @@ Binary_expression::lower_interface_value_comparison(Gogo*,
// Lower a struct or array comparison to a call to memcmp.
Expression*
-Binary_expression::lower_compare_to_memcmp(Gogo*, Statement_inserter* inserter)
+Binary_expression::lower_compare_to_memcmp(Gogo* gogo,
+ Statement_inserter* inserter)
{
Location loc = this->location();
@@ -6635,7 +6639,8 @@ Binary_expression::lower_compare_to_memcmp(Gogo*,
Statement_inserter* inserter)
Expression* len = Expression::make_type_info(this->left_->type(),
TYPE_INFO_SIZE);
- Expression* call = Runtime::make_call(Runtime::MEMCMP, loc, 3, a1, a2, len);
+ Expression* call = Runtime::make_call(gogo, Runtime::MEMCMP, loc, 3,
+ a1, a2, len);
Type* int32_type = Type::lookup_integer_type("int32");
Expression* zero = Expression::make_integer_ul(0, int32_type, loc);
return Expression::make_binary(this->op_, call, zero, loc);
@@ -7337,7 +7342,7 @@ Binary_expression::do_get_backend(Translate_context*
context)
Bexpression* compare =
gogo->backend()->binary_expression(OPERATOR_LT, right, zero_expr,
loc);
- Expression* crash = Runtime::make_call(Runtime::PANIC_SHIFT,
+ Expression* crash = Runtime::make_call(gogo, Runtime::PANIC_SHIFT,
loc, 0);
Bexpression* bcrash = crash->get_backend(context);
Bfunction* bfn = context->function()->func_value()->get_decl();
@@ -7358,7 +7363,7 @@ Binary_expression::do_get_backend(Translate_context*
context)
gogo->backend()->binary_expression(OPERATOR_EQEQ,
right, zero_expr, loc);
- Expression* crash = Runtime::make_call(Runtime::PANIC_DIVIDE,
+ Expression* crash = Runtime::make_call(gogo, Runtime::PANIC_DIVIDE,
loc, 0);
Bexpression* bcrash = crash->get_backend(context);
@@ -7661,6 +7666,7 @@ Expression::comparison(Translate_context* context, Type*
result_type,
Operator op, Expression* left, Expression* right,
Location location)
{
+ Gogo* gogo = context->gogo();
Type* left_type = left->type();
Type* right_type = right->type();
@@ -7693,7 +7699,8 @@ Expression::comparison(Translate_context* context, Type*
result_type,
Expression* ptreq = Expression::make_binary(OPERATOR_EQEQ, lptr,
rptr,
location);
Expression* btrue = Expression::make_boolean(true, location);
- Expression* call = Runtime::make_call(Runtime::MEMCMP, location, 3,
+ Expression* call = Runtime::make_call(gogo, Runtime::MEMCMP,
+ location, 3,
lptr->copy(), rptr->copy(),
rlen->copy());
Type* int32_type = Type::lookup_integer_type("int32");
@@ -7708,7 +7715,7 @@ Expression::comparison(Translate_context* context, Type*
result_type,
}
else
{
- left = Runtime::make_call(Runtime::CMPSTRING, location, 2,
+ left = Runtime::make_call(gogo, Runtime::CMPSTRING, location, 2,
left, right);
right = zexpr;
}
@@ -7742,9 +7749,10 @@ Expression::comparison(Translate_context* context, Type*
result_type,
Expression* descriptor =
Expression::make_type_descriptor(right_type, location);
left =
- Runtime::make_call((left_type->interface_type()->is_empty()
- ? Runtime::EFACEVALEQ
- : Runtime::IFACEVALEQ),
+ Runtime::make_call(gogo,
+ (left_type->interface_type()->is_empty()
+ ? Runtime::EFACEVALEQ
+ : Runtime::IFACEVALEQ),
location, 3, left, descriptor,
pointer_arg);
go_assert(op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ);
@@ -7772,7 +7780,8 @@ Expression::comparison(Translate_context* context, Type*
result_type,
compare_function = Runtime::IFACEEFACEEQ;
}
- left = Runtime::make_call(compare_function, location, 2, left, right);
+ left = Runtime::make_call(gogo, compare_function, location, 2,
+ left, right);
go_assert(op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ);
right = Expression::make_boolean(true, location);
}
@@ -7803,7 +7812,6 @@ Expression::comparison(Translate_context* context, Type*
result_type,
Bexpression* left_bexpr = left->get_backend(context);
Bexpression* right_bexpr = right->get_backend(context);
- Gogo* gogo = context->gogo();
Bexpression* ret = gogo->backend()->binary_expression(op, left_bexpr,
right_bexpr, location);
if (result_type != NULL)
@@ -7941,7 +7949,7 @@ String_concat_expression::do_check_types(Gogo*)
}
Expression*
-String_concat_expression::do_flatten(Gogo*, Named_object*,
+String_concat_expression::do_flatten(Gogo* gogo, Named_object*,
Statement_inserter* inserter)
{
if (this->is_error_expression())
@@ -8011,8 +8019,8 @@ String_concat_expression::do_flatten(Gogo*, Named_object*,
Expression* ref = Expression::make_temporary_reference(ts, loc);
ref = Expression::make_unary(OPERATOR_AND, ref, loc);
Expression* call =
- Runtime::make_call(Runtime::CONCATSTRINGS, loc, 3, buf,
- ref, len->copy());
+ Runtime::make_call(gogo, Runtime::CONCATSTRINGS, loc, 3,
+ buf, ref, len->copy());
return Expression::make_cast(type, call, loc);
}
@@ -8377,7 +8385,7 @@ Bound_method_expression::do_flatten(Gogo* gogo,
Named_object*,
if (nil_check != NULL)
{
- Expression* crash = Runtime::make_call(Runtime::PANIC_MEM, loc, 0);
+ Expression* crash = Runtime::make_call(gogo, Runtime::PANIC_MEM, loc, 0);
// Fix the type of the conditional expression by pretending to
// evaluate to RET either way through the conditional.
crash = Expression::make_compound(crash, ret, loc);
@@ -8730,7 +8738,7 @@ Builtin_call_expression::do_flatten(Gogo* gogo,
Named_object* function,
Expression::make_slice_info(arg2, SLICE_INFO_VALUE_POINTER, loc);
Expression* ls =
Expression::make_slice_info(arg2, SLICE_INFO_LENGTH, loc);
- ret = Runtime::make_call(Runtime::TYPEDSLICECOPY, loc,
+ ret = Runtime::make_call(gogo, Runtime::TYPEDSLICECOPY, loc,
5, td, pd, ld, ps, ls);
}
else
@@ -8786,7 +8794,9 @@ Builtin_call_expression::do_flatten(Gogo* gogo,
Named_object* function,
: Expression::make_slice_info(arg2,
SLICE_INFO_VALUE_POINTER,
loc));
- Expression* call = Runtime::make_call(Runtime::BUILTIN_MEMMOVE,
loc, 3,
+ Expression* call = Runtime::make_call(gogo,
+ Runtime::BUILTIN_MEMMOVE,
+ loc, 3,
p1, p2, sz);
// n is the return value of copy
@@ -8916,7 +8926,7 @@ Builtin_call_expression::do_flatten(Gogo* gogo,
Named_object* function,
}
}
- return Runtime::make_call(code, loc, 3, e1, e2, e3);
+ return Runtime::make_call(gogo, code, loc, 3, e1, e2, e3);
}
case BUILTIN_ADD:
@@ -8980,7 +8990,7 @@ Builtin_call_expression::do_flatten(Gogo* gogo,
Named_object* function,
: Runtime::UNSAFESLICE64);
Expression* td =
Expression::make_type_descriptor(ptr->type()->points_to(), loc);
- Expression* check = Runtime::make_call(code, loc, 3,
+ Expression* check = Runtime::make_call(gogo, code, loc, 3,
td, ptr, len);
if (ptr_temp == NULL)
@@ -9181,8 +9191,8 @@ Builtin_call_expression::lower_make(Gogo* gogo,
Statement_inserter* inserter)
Runtime::Function code = Runtime::MAKESLICE;
if (!len_small || !cap_small)
code = Runtime::MAKESLICE64;
- Expression* mem = Runtime::make_call(code, loc, 3, type_arg, len_arg,
- cap_arg);
+ Expression* mem = Runtime::make_call(gogo, code, loc, 3,
+ type_arg, len_arg, cap_arg);
mem = Expression::make_unsafe_cast(Type::make_pointer_type(et), mem,
loc);
Type* int_type = Type::lookup_integer_type("int");
@@ -9194,7 +9204,7 @@ Builtin_call_expression::lower_make(Gogo* gogo,
Statement_inserter* inserter)
{
Expression* type_arg = Expression::make_type_descriptor(type, type_loc);
if (!len_small)
- call = Runtime::make_call(Runtime::MAKEMAP64, loc, 3, type_arg,
+ call = Runtime::make_call(gogo, Runtime::MAKEMAP64, loc, 3, type_arg,
len_arg,
Expression::make_nil(loc));
else
@@ -9202,9 +9212,9 @@ Builtin_call_expression::lower_make(Gogo* gogo,
Statement_inserter* inserter)
if (len_arg->numeric_constant_value(&nclen)
&& nclen.to_unsigned_long(&vlen) == Numeric_constant::NC_UL_VALID
&& vlen <= Map_type::bucket_size)
- call = Runtime::make_call(Runtime::MAKEMAP_SMALL, loc, 0);
+ call = Runtime::make_call(gogo, Runtime::MAKEMAP_SMALL, loc, 0);
else
- call = Runtime::make_call(Runtime::MAKEMAP, loc, 3, type_arg,
+ call = Runtime::make_call(gogo, Runtime::MAKEMAP, loc, 3, type_arg,
len_arg,
Expression::make_nil(loc));
}
@@ -9215,7 +9225,7 @@ Builtin_call_expression::lower_make(Gogo* gogo,
Statement_inserter* inserter)
Runtime::Function code = Runtime::MAKECHAN;
if (!len_small)
code = Runtime::MAKECHAN64;
- call = Runtime::make_call(code, loc, 2, type_arg, len_arg);
+ call = Runtime::make_call(gogo, code, loc, 2, type_arg, len_arg);
}
else
go_unreachable();
@@ -9325,7 +9335,8 @@ Builtin_call_expression::flatten_append(Gogo* gogo,
Named_object* function,
loc);
len2 = Expression::make_temporary_reference(l2tmp, loc);
Expression* cap2 = Expression::make_temporary_reference(c2tmp, loc);
- Expression* check = Runtime::make_call(Runtime::CHECK_MAKE_SLICE,
+ Expression* check = Runtime::make_call(gogo,
+ Runtime::CHECK_MAKE_SLICE,
loc, 3, elem, len2, cap2);
gogo->lower_expression(function, inserter, &check);
gogo->flatten_expression(function, inserter, &check);
@@ -9421,7 +9432,7 @@ Builtin_call_expression::flatten_append(Gogo* gogo,
Named_object* function,
Expression* a3 = Expression::make_temporary_reference(l1tmp, loc);
Expression* a4 = Expression::make_temporary_reference(c1tmp, loc);
Expression* a5 = Expression::make_temporary_reference(ntmp, loc);
- Expression* call = Runtime::make_call(Runtime::GROWSLICE, loc, 5,
+ Expression* call = Runtime::make_call(gogo, Runtime::GROWSLICE, loc, 5,
a1, a2, a3, a4, a5);
call = Expression::make_unsafe_cast(slice_type, call, loc);
@@ -9491,13 +9502,14 @@ Builtin_call_expression::flatten_append(Gogo* gogo,
Named_object* function,
a2 = Expression::make_binary(OPERATOR_MULT, a2, ref, loc);
if (element_type->has_pointer())
- call = Runtime::make_call(Runtime::MEMCLRHASPTR, loc, 2, a1, a2);
+ call = Runtime::make_call(gogo, Runtime::MEMCLRHASPTR, loc, 2,
+ a1, a2);
else
{
Type* int32_type = Type::lookup_integer_type("int32");
zero = Expression::make_integer_ul(0, int32_type, loc);
- call = Runtime::make_call(Runtime::BUILTIN_MEMSET, loc, 3, a1,
- zero, a2);
+ call = Runtime::make_call(gogo, Runtime::BUILTIN_MEMSET, loc, 3,
+ a1, zero, a2);
}
if (element_type->has_pointer())
@@ -9557,7 +9569,7 @@ Builtin_call_expression::flatten_append(Gogo* gogo,
Named_object* function,
a3 = Expression::make_type_info(element_type, TYPE_INFO_SIZE);
a3 = Expression::make_binary(OPERATOR_MULT, a3, ref, loc);
- call = Runtime::make_call(Runtime::BUILTIN_MEMMOVE, loc, 3,
+ call = Runtime::make_call(gogo, Runtime::BUILTIN_MEMMOVE, loc, 3,
a1, a2, a3);
}
}
@@ -11001,7 +11013,7 @@
Builtin_call_expression::do_get_backend(Translate_context* context)
{
const bool is_ln = this->code_ == BUILTIN_PRINTLN;
- Expression* print_stmts = Runtime::make_call(Runtime::PRINTLOCK,
+ Expression* print_stmts = Runtime::make_call(gogo, Runtime::PRINTLOCK,
location, 0);
const Expression_list* call_args = this->args();
@@ -11014,7 +11026,7 @@
Builtin_call_expression::do_get_backend(Translate_context* context)
if (is_ln && p != call_args->begin())
{
Expression* print_space =
- Runtime::make_call(Runtime::PRINTSP, location, 0);
+ Runtime::make_call(gogo, Runtime::PRINTSP, location, 0);
print_stmts =
Expression::make_compound(print_stmts, print_space,
@@ -11082,7 +11094,8 @@
Builtin_call_expression::do_get_backend(Translate_context* context)
return context->backend()->error_expression();
}
- Expression* call = Runtime::make_call(code, location, 1, arg);
+ Expression* call = Runtime::make_call(gogo, code, location, 1,
+ arg);
print_stmts = Expression::make_compound(print_stmts, call,
location);
}
@@ -11091,12 +11104,12 @@
Builtin_call_expression::do_get_backend(Translate_context* context)
if (is_ln)
{
Expression* print_nl =
- Runtime::make_call(Runtime::PRINTNL, location, 0);
+ Runtime::make_call(gogo, Runtime::PRINTNL, location, 0);
print_stmts = Expression::make_compound(print_stmts, print_nl,
location);
}
- Expression* unlock = Runtime::make_call(Runtime::PRINTUNLOCK,
+ Expression* unlock = Runtime::make_call(gogo, Runtime::PRINTUNLOCK,
location, 0);
print_stmts = Expression::make_compound(print_stmts, unlock, location);
@@ -11113,7 +11126,7 @@
Builtin_call_expression::do_get_backend(Translate_context* context)
arg = Expression::convert_for_assignment(gogo, empty, arg, location);
Expression* panic =
- Runtime::make_call(Runtime::GOPANIC, location, 1, arg);
+ Runtime::make_call(gogo, Runtime::GOPANIC, location, 1, arg);
return panic->get_backend(context);
}
@@ -11133,7 +11146,8 @@
Builtin_call_expression::do_get_backend(Translate_context* context)
// We need to handle a deferred call to recover specially,
// because it changes whether it can recover a panic or not.
// See test7 in test/recover1.go.
- Expression* recover = Runtime::make_call((this->is_deferred()
+ Expression* recover = Runtime::make_call(gogo,
+ (this->is_deferred()
? Runtime::DEFERREDRECOVER
: Runtime::GORECOVER),
location, 0);
@@ -11147,7 +11161,7 @@
Builtin_call_expression::do_get_backend(Translate_context* context)
const Expression_list* args = this->args();
go_assert(args != NULL && args->size() == 1);
Expression* arg = args->front();
- Expression* close = Runtime::make_call(Runtime::CLOSE, location,
+ Expression* close = Runtime::make_call(gogo, Runtime::CLOSE, location,
1, arg);
return close->get_backend(context);
}
@@ -11925,7 +11939,7 @@ Call_expression::intrinsify(Gogo* gogo,
{
Expression* arg = Expression::make_integer_ul(0, uint32_type, loc);
Expression* call =
- Runtime::make_call(Runtime::BUILTIN_RETURN_ADDRESS, loc,
+ Runtime::make_call(gogo, Runtime::BUILTIN_RETURN_ADDRESS, loc,
1, arg);
// The builtin functions return void*, but the Go functions return
uintptr.
return Expression::make_cast(uintptr_type, call, loc);
@@ -11935,7 +11949,7 @@ Call_expression::intrinsify(Gogo* gogo,
{
Expression* call =
- Runtime::make_call(Runtime::BUILTIN_DWARF_CFA, loc, 0);
+ Runtime::make_call(gogo, Runtime::BUILTIN_DWARF_CFA, loc, 0);
// The builtin functions return void*, but the Go functions return
uintptr.
return Expression::make_cast(uintptr_type, call, loc);
}
@@ -11961,7 +11975,7 @@ Call_expression::intrinsify(Gogo* gogo,
else
go_unreachable();
Expression* arg = this->args_->front();
- Expression* call = Runtime::make_call(code, loc, 1, arg);
+ Expression* call = Runtime::make_call(gogo, code, loc, 1, arg);
if (name == "ReverseBytes")
return Expression::make_cast(uint_type, call, loc);
return call;
@@ -11976,7 +11990,8 @@ Call_expression::intrinsify(Gogo* gogo,
unsigned long mask = (name == "TrailingZeros8" ? 0x100 : 0x10000);
Expression* c = Expression::make_integer_ul(mask, uint32_type, loc);
arg = Expression::make_binary(OPERATOR_OR, arg, c, loc);
- Expression* call = Runtime::make_call(Runtime::BUILTIN_CTZ, loc, 1,
arg);
+ Expression* call = Runtime::make_call(gogo, Runtime::BUILTIN_CTZ,
+ loc, 1, arg);
return Expression::make_cast(int_type, call, loc);
}
else if ((name == "TrailingZeros32"
@@ -11994,7 +12009,8 @@ Call_expression::intrinsify(Gogo* gogo,
Expression* zero = Expression::make_integer_ul(0, uint32_type, loc);
Expression* cmp = Expression::make_binary(OPERATOR_EQEQ, arg, zero,
loc);
Expression* c32 = Expression::make_integer_ul(32, int_type, loc);
- Expression* call = Runtime::make_call(Runtime::BUILTIN_CTZ, loc, 1,
arg->copy());
+ Expression* call = Runtime::make_call(gogo, Runtime::BUILTIN_CTZ,
+ loc, 1, arg->copy());
call = Expression::make_cast(int_type, call, loc);
return Expression::make_conditional(cmp, c32, call, loc);
}
@@ -12013,7 +12029,8 @@ Call_expression::intrinsify(Gogo* gogo,
Expression* zero = Expression::make_integer_ul(0, uint64_type, loc);
Expression* cmp = Expression::make_binary(OPERATOR_EQEQ, arg, zero,
loc);
Expression* c64 = Expression::make_integer_ul(64, int_type, loc);
- Expression* call = Runtime::make_call(Runtime::BUILTIN_CTZLL, loc,
1, arg->copy());
+ Expression* call = Runtime::make_call(gogo, Runtime::BUILTIN_CTZLL,
+ loc, 1, arg->copy());
call = Expression::make_cast(int_type, call, loc);
return Expression::make_conditional(cmp, c64, call, loc);
}
@@ -12033,7 +12050,8 @@ Call_expression::intrinsify(Gogo* gogo,
((name == "LeadingZeros8" || name == "Len8") ? 0xffffff : 0xffff);
c = Expression::make_integer_ul(mask, uint32_type, loc);
arg = Expression::make_binary(OPERATOR_OR, arg, c, loc);
- Expression* call = Runtime::make_call(Runtime::BUILTIN_CLZ, loc, 1,
arg);
+ Expression* call = Runtime::make_call(gogo, Runtime::BUILTIN_CLZ,
+ loc, 1, arg);
call = Expression::make_cast(int_type, call, loc);
// len = width - clz
if (name == "Len8")
@@ -12063,7 +12081,8 @@ Call_expression::intrinsify(Gogo* gogo,
Expression* zero = Expression::make_integer_ul(0, uint32_type, loc);
Expression* cmp = Expression::make_binary(OPERATOR_EQEQ, arg, zero,
loc);
Expression* c32 = Expression::make_integer_ul(32, int_type, loc);
- Expression* call = Runtime::make_call(Runtime::BUILTIN_CLZ, loc, 1,
arg->copy());
+ Expression* call = Runtime::make_call(gogo, Runtime::BUILTIN_CLZ,
+ loc, 1, arg->copy());
call = Expression::make_cast(int_type, call, loc);
Expression* cond = Expression::make_conditional(cmp, c32, call, loc);
// len = 32 - clz
@@ -12086,7 +12105,8 @@ Call_expression::intrinsify(Gogo* gogo,
Expression* zero = Expression::make_integer_ul(0, uint64_type, loc);
Expression* cmp = Expression::make_binary(OPERATOR_EQEQ, arg, zero,
loc);
Expression* c64 = Expression::make_integer_ul(64, int_type, loc);
- Expression* call = Runtime::make_call(Runtime::BUILTIN_CLZLL, loc,
1, arg->copy());
+ Expression* call = Runtime::make_call(gogo, Runtime::BUILTIN_CLZLL,
+ loc, 1, arg->copy());
call = Expression::make_cast(int_type, call, loc);
Expression* cond = Expression::make_conditional(cmp, c64, call, loc);
// len = 64 - clz
@@ -12107,7 +12127,7 @@ Call_expression::intrinsify(Gogo* gogo,
else
code = Runtime::BUILTIN_POPCOUNT;
Expression* arg = this->args_->front();
- Expression* call = Runtime::make_call(code, loc, 1, arg);
+ Expression* call = Runtime::make_call(gogo, code, loc, 1, arg);
return Expression::make_cast(int_type, call, loc);
}
}
@@ -12311,7 +12331,7 @@ Call_expression::intrinsify(Gogo* gogo,
go_unreachable();
Expression* a1 = this->args_->front();
Expression* a2 = Expression::make_integer_ul(memorder, int32_type,
loc);
- Expression* call = Runtime::make_call(code, loc, 2, a1, a2);
+ Expression* call = Runtime::make_call(gogo, code, loc, 2, a1, a2);
return Expression::make_unsafe_cast(res_type, call, loc);
}
@@ -12352,7 +12372,7 @@ Call_expression::intrinsify(Gogo* gogo,
else
go_unreachable();
Expression* a3 = Expression::make_integer_ul(memorder, int32_type,
loc);
- return Runtime::make_call(code, loc, 3, a1, a2, a3);
+ return Runtime::make_call(gogo, code, loc, 3, a1, a2, a3);
}
if ((name == "Xchg" || name == "Xchg64" || name == "Xchguintptr"
@@ -12396,7 +12416,7 @@ Call_expression::intrinsify(Gogo* gogo,
Expression* a1 = this->args_->at(0);
Expression* a2 = this->args_->at(1);
Expression* a3 = Expression::make_integer_ul(memorder, int32_type,
loc);
- Expression* call = Runtime::make_call(code, loc, 3, a1, a2, a3);
+ Expression* call = Runtime::make_call(gogo, code, loc, 3, a1, a2,
a3);
return Expression::make_cast(res_type, call, loc);
}
@@ -12450,7 +12470,7 @@ Call_expression::intrinsify(Gogo* gogo,
Expression* a4 = Expression::make_boolean(false, loc);
Expression* a5 = Expression::make_integer_ul(memorder, int32_type,
loc);
Expression* a6 = Expression::make_integer_ul(__ATOMIC_RELAXED,
int32_type, loc);
- return Runtime::make_call(code, loc, 6, a1, a2, a3, a4, a5, a6);
+ return Runtime::make_call(gogo, code, loc, 6, a1, a2, a3, a4, a5,
a6);
}
if ((name == "Xadd" || name == "Xadd64" || name == "Xaddint64"
@@ -12494,7 +12514,7 @@ Call_expression::intrinsify(Gogo* gogo,
Expression* a1 = this->args_->at(0);
Expression* a2 = this->args_->at(1);
Expression* a3 = Expression::make_integer_ul(memorder, int32_type,
loc);
- Expression* call = Runtime::make_call(code, loc, 3, a1, a2, a3);
+ Expression* call = Runtime::make_call(gogo, code, loc, 3, a1, a2,
a3);
return Expression::make_cast(res_type, call, loc);
}
@@ -12511,7 +12531,7 @@ Call_expression::intrinsify(Gogo* gogo,
Expression* a1 = this->args_->at(0);
Expression* a2 = this->args_->at(1);
Expression* a3 = Expression::make_integer_ul(memorder, int32_type,
loc);
- return Runtime::make_call(code, loc, 3, a1, a2, a3);
+ return Runtime::make_call(gogo, code, loc, 3, a1, a2, a3);
}
}
else if (package == "internal/abi"
@@ -13861,14 +13881,14 @@ Array_index_expression::do_flatten(Gogo* gogo,
Named_object*,
if (cap != NULL)
{
if (array_type->is_slice_type())
- Expression::check_bounds(cap, OPERATOR_LE, scap,
+ Expression::check_bounds(gogo, cap, OPERATOR_LE, scap,
Runtime::PANIC_SLICE3_ACAP,
Runtime::PANIC_SLICE3_ACAP_U,
Runtime::PANIC_EXTEND_SLICE3_ACAP,
Runtime::PANIC_EXTEND_SLICE3_ACAP_U,
inserter, loc);
else
- Expression::check_bounds(cap, OPERATOR_LE, len,
+ Expression::check_bounds(gogo, cap, OPERATOR_LE, len,
Runtime::PANIC_SLICE3_ALEN,
Runtime::PANIC_SLICE3_ALEN_U,
Runtime::PANIC_EXTEND_SLICE3_ALEN,
@@ -13878,7 +13898,7 @@ Array_index_expression::do_flatten(Gogo* gogo,
Named_object*,
Expression* start_bound = cap;
if (end != NULL && !end->is_nil_expression())
{
- Expression::check_bounds(end, OPERATOR_LE, cap,
+ Expression::check_bounds(gogo, end, OPERATOR_LE, cap,
Runtime::PANIC_SLICE3_B,
Runtime::PANIC_SLICE3_B_U,
Runtime::PANIC_EXTEND_SLICE3_B,
@@ -13887,7 +13907,7 @@ Array_index_expression::do_flatten(Gogo* gogo,
Named_object*,
start_bound = end;
}
- Expression::check_bounds(start, OPERATOR_LE, start_bound,
+ Expression::check_bounds(gogo, start, OPERATOR_LE, start_bound,
Runtime::PANIC_SLICE3_C,
Runtime::PANIC_SLICE3_C_U,
Runtime::PANIC_EXTEND_SLICE3_C,
@@ -13897,21 +13917,21 @@ Array_index_expression::do_flatten(Gogo* gogo,
Named_object*,
else if (end != NULL && !end->is_nil_expression())
{
if (array_type->is_slice_type())
- Expression::check_bounds(end, OPERATOR_LE, scap,
+ Expression::check_bounds(gogo, end, OPERATOR_LE, scap,
Runtime::PANIC_SLICE_ACAP,
Runtime::PANIC_SLICE_ACAP_U,
Runtime::PANIC_EXTEND_SLICE_ACAP,
Runtime::PANIC_EXTEND_SLICE_ACAP_U,
inserter, loc);
else
- Expression::check_bounds(end, OPERATOR_LE, len,
+ Expression::check_bounds(gogo, end, OPERATOR_LE, len,
Runtime::PANIC_SLICE_ALEN,
Runtime::PANIC_SLICE_ALEN_U,
Runtime::PANIC_EXTEND_SLICE_ALEN,
Runtime::PANIC_EXTEND_SLICE_ALEN_U,
inserter, loc);
- Expression::check_bounds(start, OPERATOR_LE, end,
+ Expression::check_bounds(gogo, start, OPERATOR_LE, end,
Runtime::PANIC_SLICE_B,
Runtime::PANIC_SLICE_B_U,
Runtime::PANIC_EXTEND_SLICE_B,
@@ -13925,7 +13945,7 @@ Array_index_expression::do_flatten(Gogo* gogo,
Named_object*,
start_bound = scap;
else
start_bound = len;
- Expression::check_bounds(start, OPERATOR_LE, start_bound,
+ Expression::check_bounds(gogo, start, OPERATOR_LE, start_bound,
Runtime::PANIC_SLICE_B,
Runtime::PANIC_SLICE_B_U,
Runtime::PANIC_EXTEND_SLICE_B,
@@ -13933,7 +13953,7 @@ Array_index_expression::do_flatten(Gogo* gogo,
Named_object*,
inserter, loc);
}
else
- Expression::check_bounds(start, OPERATOR_LT, len,
+ Expression::check_bounds(gogo, start, OPERATOR_LT, len,
Runtime::PANIC_INDEX,
Runtime::PANIC_INDEX_U,
Runtime::PANIC_EXTEND_INDEX,
@@ -14166,7 +14186,7 @@ String_index_expression::do_traverse(Traverse* traverse)
}
Expression*
-String_index_expression::do_flatten(Gogo*, Named_object*,
+String_index_expression::do_flatten(Gogo* gogo, Named_object*,
Statement_inserter* inserter)
{
if (this->is_flattened_)
@@ -14228,13 +14248,13 @@ String_index_expression::do_flatten(Gogo*,
Named_object*,
if (end != NULL && !end->is_nil_expression())
{
- Expression::check_bounds(end, OPERATOR_LE, len,
+ Expression::check_bounds(gogo, end, OPERATOR_LE, len,
Runtime::PANIC_SLICE_ALEN,
Runtime::PANIC_SLICE_ALEN_U,
Runtime::PANIC_EXTEND_SLICE_ALEN,
Runtime::PANIC_EXTEND_SLICE_ALEN_U,
inserter, loc);
- Expression::check_bounds(start, OPERATOR_LE, end,
+ Expression::check_bounds(gogo, start, OPERATOR_LE, end,
Runtime::PANIC_SLICE_B,
Runtime::PANIC_SLICE_B_U,
Runtime::PANIC_EXTEND_SLICE_B,
@@ -14242,14 +14262,14 @@ String_index_expression::do_flatten(Gogo*,
Named_object*,
inserter, loc);
}
else if (end != NULL)
- Expression::check_bounds(start, OPERATOR_LE, len,
+ Expression::check_bounds(gogo, start, OPERATOR_LE, len,
Runtime::PANIC_SLICE_B,
Runtime::PANIC_SLICE_B_U,
Runtime::PANIC_EXTEND_SLICE_B,
Runtime::PANIC_EXTEND_SLICE_B_U,
inserter, loc);
else
- Expression::check_bounds(start, OPERATOR_LT, len,
+ Expression::check_bounds(gogo, start, OPERATOR_LT, len,
Runtime::PANIC_INDEX,
Runtime::PANIC_INDEX_U,
Runtime::PANIC_EXTEND_INDEX,
@@ -14705,11 +14725,11 @@ Map_index_expression::get_value_pointer(Gogo* gogo)
code = Runtime::MAPACCESS1;
break;
}
- map_index = Runtime::make_call(code, loc, 3,
+ map_index = Runtime::make_call(gogo, code, loc, 3,
type_expr, map_ref, key);
}
else
- map_index = Runtime::make_call(Runtime::MAPACCESS1_FAT, loc, 4,
+ map_index = Runtime::make_call(gogo, Runtime::MAPACCESS1_FAT, loc, 4,
type_expr, map_ref, index_ptr, zero);
Type* val_type = type->val_type();
@@ -14843,7 +14863,7 @@ Field_reference_expression::do_lower(Gogo* gogo,
Named_object* function,
e = Expression::make_var_reference(no, loc);
e = Expression::make_unary(OPERATOR_AND, e, loc);
- Expression* call = Runtime::make_call(Runtime::FIELDTRACK, loc, 1, e);
+ Expression* call = Runtime::make_call(gogo, Runtime::FIELDTRACK, loc, 1, e);
gogo->lower_expression(function, inserter, &call);
inserter->insert(Statement::make_statement(call, false));
@@ -15242,7 +15262,7 @@
Interface_field_reference_expression::do_get_backend(Translate_context* context)
Expression::make_nil(loc), loc);
Bexpression* bnil_check = nil_check->get_backend(context);
- Expression* crash = Runtime::make_call(Runtime::PANIC_MEM, loc, 0);
+ Expression* crash = Runtime::make_call(gogo, Runtime::PANIC_MEM, loc, 0);
Bexpression* bcrash = crash->get_backend(context);
Bfunction* bfn = context->function()->func_value()->get_decl();
@@ -16763,8 +16783,8 @@
Map_construction_expression::do_get_backend(Translate_context* context)
Expression::make_struct_field_offset(this->element_type_, valfield);
Expression* map_ctor =
- Runtime::make_call(Runtime::CONSTRUCT_MAP, loc, 5, descriptor, count,
- entry_size, val_offset, ventries);
+ Runtime::make_call(context->gogo(), Runtime::CONSTRUCT_MAP, loc, 5,
+ descriptor, count, entry_size, val_offset, ventries);
return map_ctor->get_backend(context);
}
@@ -17841,13 +17861,16 @@
Type_guard_expression::do_get_backend(Translate_context* context)
{
Expression* conversion;
if (this->type_->interface_type() != NULL)
- conversion =
- Expression::convert_interface_to_interface(this->type_, this->expr_,
- true, this->location());
+ conversion = Expression::convert_interface_to_interface(context->gogo(),
+ this->type_,
+ this->expr_,
+ true,
+ this->location());
else
- conversion =
- Expression::convert_for_assignment(context->gogo(), this->type_,
- this->expr_, this->location());
+ conversion = Expression::convert_for_assignment(context->gogo(),
+ this->type_,
+ this->expr_,
+ this->location());
Gogo* gogo = context->gogo();
Btype* bt = this->type_->get_backend(gogo);
@@ -17947,7 +17970,7 @@ Heap_expression::do_get_backend(Translate_context*
context)
erhs = Expression::make_backend(btempref, etype, loc);
erhs = Expression::unpack_direct_iface(erhs, loc);
erhs = Expression::make_unsafe_cast(uintptr_type, erhs, loc);
- call = Runtime::make_call(Runtime::GCWRITEBARRIER, loc, 2,
+ call = Runtime::make_call(gogo, Runtime::GCWRITEBARRIER, loc, 2,
elhs, erhs);
}
else
@@ -17956,7 +17979,7 @@ Heap_expression::do_get_backend(Translate_context*
context)
Bexpression* addr =
gogo->backend()->address_expression(btempref, loc);
erhs = Expression::make_backend(addr, etype_ptr, loc);
- call = Runtime::make_call(Runtime::TYPEDMEMMOVE, loc, 3,
+ call = Runtime::make_call(gogo, Runtime::TYPEDMEMMOVE, loc, 3,
td, elhs, erhs);
}
Statement* cs = Statement::make_statement(call, false);
@@ -18085,12 +18108,13 @@ Receive_expression::do_get_backend(Translate_context*
context)
return context->backend()->error_expression();
}
+ Gogo* gogo = context->gogo();
Expression* recv_ref =
Expression::make_temporary_reference(this->temp_receiver_, loc);
Expression* recv_addr =
Expression::make_temporary_reference(this->temp_receiver_, loc);
recv_addr = Expression::make_unary(OPERATOR_AND, recv_addr, loc);
- Expression* recv = Runtime::make_call(Runtime::CHANRECV1, loc, 2,
+ Expression* recv = Runtime::make_call(gogo, Runtime::CHANRECV1, loc, 2,
this->channel_, recv_addr);
return Expression::make_compound(recv, recv_ref, loc)->get_backend(context);
}
diff --git a/gcc/go/gofrontend/expressions.h b/gcc/go/gofrontend/expressions.h
index 49140d100a4..3b8ae68f500 100644
--- a/gcc/go/gofrontend/expressions.h
+++ b/gcc/go/gofrontend/expressions.h
@@ -1090,7 +1090,7 @@ class Expression
// interface type. If FOR_TYPE_GUARD is true this is for a type
// assertion.
static Expression*
- convert_interface_to_interface(Type* lhs_type,
+ convert_interface_to_interface(Gogo*, Type* lhs_type,
Expression* rhs, bool for_type_guard,
Location);
@@ -1125,9 +1125,9 @@ class Expression
// Insert bounds checks for an index expression.
static void
- check_bounds(Expression* val, Operator, Expression* bound, Runtime::Function,
+ check_bounds(Gogo*, Expression* val, Operator, Expression* bound,
Runtime::Function, Runtime::Function, Runtime::Function,
- Statement_inserter*, Location);
+ Runtime::Function, Statement_inserter*, Location);
// Return an expression for constructing a direct interface type from a
// pointer.
diff --git a/gcc/go/gofrontend/gogo.cc b/gcc/go/gofrontend/gogo.cc
index 499459b5366..3c021b985b9 100644
--- a/gcc/go/gofrontend/gogo.cc
+++ b/gcc/go/gofrontend/gogo.cc
@@ -898,7 +898,8 @@ Gogo::register_gc_vars(const std::vector<Named_object*>&
var_gc,
Expression* root_addr = Expression::make_unary(OPERATOR_AND, root_list_ctor,
builtin_loc);
root_addr->unary_expression()->set_is_gc_root();
- Expression* register_roots = Runtime::make_call(Runtime::REGISTER_GC_ROOTS,
+ Expression* register_roots = Runtime::make_call(this,
+ Runtime::REGISTER_GC_ROOTS,
builtin_loc, 1, root_addr);
Translate_context context(this, NULL, NULL, NULL);
@@ -1039,7 +1040,7 @@ Gogo::register_type_descriptors(std::vector<Bstatement*>&
init_stmts,
Type* array_ptr_type = Type::make_pointer_type(list_array_type);
Expression* expr = Expression::make_backend(bexpr, array_ptr_type,
builtin_loc);
- expr = Runtime::make_call(Runtime::REGISTER_TYPE_DESCRIPTORS,
+ expr = Runtime::make_call(this, Runtime::REGISTER_TYPE_DESCRIPTORS,
builtin_loc, 2, len_expr->copy(), expr);
Bexpression* bcall = expr->get_backend(&context);
init_stmts.push_back(this->backend()->expression_statement(init_bfn,
@@ -4928,7 +4929,8 @@ Build_recover_thunks::can_recover_arg(Location location)
}
Expression* zexpr = Expression::make_integer_ul(0, NULL, location);
- Expression* call = Runtime::make_call(Runtime::BUILTIN_RETURN_ADDRESS,
+ Expression* call = Runtime::make_call(this->gogo_,
+ Runtime::BUILTIN_RETURN_ADDRESS,
location, 1, zexpr);
call = Expression::make_unsafe_cast(uintptr_type, call, location);
@@ -5078,7 +5080,7 @@ Expression*
Gogo::allocate_memory(Type* type, Location location)
{
Expression* td = Expression::make_type_descriptor(type, location);
- return Runtime::make_call(Runtime::NEW, location, 1, td);
+ return Runtime::make_call(this, Runtime::NEW, location, 1, td);
}
// Traversal class used to check for return statements.
@@ -6778,7 +6780,7 @@ Function::build_defer_wrapper(Gogo* gogo, Named_object*
named_function,
// libgo/runtime/go-unwind.c.
std::vector<Bstatement*> stmts;
- Expression* call = Runtime::make_call(Runtime::CHECKDEFER, end_loc, 1,
+ Expression* call = Runtime::make_call(gogo, Runtime::CHECKDEFER, end_loc, 1,
this->defer_stack(end_loc));
Translate_context context(gogo, named_function, NULL, NULL);
Bexpression* defer = call->get_backend(&context);
@@ -6791,11 +6793,11 @@ Function::build_defer_wrapper(Gogo* gogo, Named_object*
named_function,
go_assert(*except == NULL);
*except = gogo->backend()->statement_list(stmts);
- call = Runtime::make_call(Runtime::CHECKDEFER, end_loc, 1,
+ call = Runtime::make_call(gogo, Runtime::CHECKDEFER, end_loc, 1,
this->defer_stack(end_loc));
defer = call->get_backend(&context);
- call = Runtime::make_call(Runtime::DEFERRETURN, end_loc, 1,
+ call = Runtime::make_call(gogo, Runtime::DEFERRETURN, end_loc, 1,
this->defer_stack(end_loc));
Bexpression* undefer = call->get_backend(&context);
Bstatement* function_defer =
diff --git a/gcc/go/gofrontend/runtime.cc b/gcc/go/gofrontend/runtime.cc
index e113a1adfc9..274aa4a7c1e 100644
--- a/gcc/go/gofrontend/runtime.cc
+++ b/gcc/go/gofrontend/runtime.cc
@@ -414,7 +414,7 @@ Runtime::runtime_declaration(Function code)
// Make a call to a runtime function.
Call_expression*
-Runtime::make_call(Runtime::Function code, Location loc,
+Runtime::make_call(Gogo*, Runtime::Function code, Location loc,
int param_count, ...)
{
go_assert(code < Runtime::NUMBER_OF_FUNCTIONS);
diff --git a/gcc/go/gofrontend/runtime.h b/gcc/go/gofrontend/runtime.h
index e92510b33db..bea2dbe33a5 100644
--- a/gcc/go/gofrontend/runtime.h
+++ b/gcc/go/gofrontend/runtime.h
@@ -32,7 +32,7 @@ class Runtime
// Make a call to a runtime function.
static Call_expression*
- make_call(Function, Location, int, ...);
+ make_call(Gogo*, Function, Location, int, ...);
// Convert all the types used by runtime functions to the backend
// representation.
diff --git a/gcc/go/gofrontend/statements.cc b/gcc/go/gofrontend/statements.cc
index 91c7627a0e3..5d652a1119d 100644
--- a/gcc/go/gofrontend/statements.cc
+++ b/gcc/go/gofrontend/statements.cc
@@ -961,7 +961,7 @@ Assignment_statement::do_lower(Gogo* gogo, Named_object*,
Block* enclosing,
code = Runtime::MAPASSIGN;
break;
}
- Expression* call = Runtime::make_call(code, loc, 3,
+ Expression* call = Runtime::make_call(gogo, code, loc, 3,
a1, a2, a3);
Type* ptrval_type = Type::make_pointer_type(mt->val_type());
call = Expression::make_cast(ptrval_type, call, loc);
@@ -1597,10 +1597,11 @@ Tuple_map_assignment_statement::do_lower(Gogo* gogo,
Named_object*,
code = Runtime::MAPACCESS2;
break;
}
- call = Runtime::make_call(code, loc, 3, a1, a2, a3);
+ call = Runtime::make_call(gogo, code, loc, 3, a1, a2, a3);
}
else
- call = Runtime::make_call(Runtime::MAPACCESS2_FAT, loc, 4, a1, a2, a3, a4);
+ call = Runtime::make_call(gogo, Runtime::MAPACCESS2_FAT, loc, 4,
+ a1, a2, a3, a4);
ref = Expression::make_temporary_reference(val_ptr_temp, loc);
ref->set_is_lvalue();
Expression* res = Expression::make_call_result(call, 0);
@@ -1701,7 +1702,7 @@ Tuple_receive_assignment_statement::do_traverse(Traverse*
traverse)
// Lower to a function call.
Statement*
-Tuple_receive_assignment_statement::do_lower(Gogo*, Named_object*,
+Tuple_receive_assignment_statement::do_lower(Gogo* gogo, Named_object*,
Block* enclosing,
Statement_inserter*)
{
@@ -1744,7 +1745,7 @@ Tuple_receive_assignment_statement::do_lower(Gogo*,
Named_object*,
Temporary_reference_expression* ref =
Expression::make_temporary_reference(val_temp, loc);
Expression* p2 = Expression::make_unary(OPERATOR_AND, ref, loc);
- Expression* call = Runtime::make_call(Runtime::CHANRECV2,
+ Expression* call = Runtime::make_call(gogo, Runtime::CHANRECV2,
loc, 2, this->channel_, p2);
ref = Expression::make_temporary_reference(closed_temp, loc);
ref->set_is_lvalue();
@@ -1819,10 +1820,10 @@ class Tuple_type_guard_assignment_statement : public
Statement
private:
Call_expression*
- lower_to_type(Runtime::Function);
+ lower_to_type(Gogo*, Runtime::Function);
void
- lower_to_object_type(Block*, Runtime::Function);
+ lower_to_object_type(Gogo*, Block*, Runtime::Function);
// The variable which recieves the converted value.
Expression* val_;
@@ -1849,7 +1850,7 @@
Tuple_type_guard_assignment_statement::do_traverse(Traverse* traverse)
// Lower to a function call.
Statement*
-Tuple_type_guard_assignment_statement::do_lower(Gogo*, Named_object*,
+Tuple_type_guard_assignment_statement::do_lower(Gogo* gogo, Named_object*,
Block* enclosing,
Statement_inserter*)
{
@@ -1876,22 +1877,25 @@ Tuple_type_guard_assignment_statement::do_lower(Gogo*,
Named_object*,
if (this->type_->interface_type() != NULL)
{
if (this->type_->interface_type()->is_empty())
- call = Runtime::make_call((expr_is_empty
+ call = Runtime::make_call(gogo,
+ (expr_is_empty
? Runtime::IFACEE2E2
: Runtime::IFACEI2E2),
loc, 1, this->expr_);
else
- call = this->lower_to_type(expr_is_empty
- ? Runtime::IFACEE2I2
- : Runtime::IFACEI2I2);
+ call = this->lower_to_type(gogo,
+ (expr_is_empty
+ ? Runtime::IFACEE2I2
+ : Runtime::IFACEI2I2));
}
else if (this->type_->points_to() != NULL)
- call = this->lower_to_type(expr_is_empty
- ? Runtime::IFACEE2T2P
- : Runtime::IFACEI2T2P);
+ call = this->lower_to_type(gogo,
+ (expr_is_empty
+ ? Runtime::IFACEE2T2P
+ : Runtime::IFACEI2T2P));
else
{
- this->lower_to_object_type(b,
+ this->lower_to_object_type(gogo, b,
(expr_is_empty
? Runtime::IFACEE2T2
: Runtime::IFACEI2T2));
@@ -1918,10 +1922,11 @@ Tuple_type_guard_assignment_statement::do_lower(Gogo*,
Named_object*,
// Lower a conversion to a non-empty interface type or a pointer type.
Call_expression*
-Tuple_type_guard_assignment_statement::lower_to_type(Runtime::Function code)
+Tuple_type_guard_assignment_statement::lower_to_type(Gogo* gogo,
+ Runtime::Function code)
{
Location loc = this->location();
- return Runtime::make_call(code, loc, 2,
+ return Runtime::make_call(gogo, code, loc, 2,
Expression::make_type_descriptor(this->type_, loc),
this->expr_);
}
@@ -1930,6 +1935,7 @@
Tuple_type_guard_assignment_statement::lower_to_type(Runtime::Function code)
void
Tuple_type_guard_assignment_statement::lower_to_object_type(
+ Gogo* gogo,
Block* b,
Runtime::Function code)
{
@@ -1955,7 +1961,8 @@
Tuple_type_guard_assignment_statement::lower_to_object_type(
Expression* p1 = Expression::make_type_descriptor(this->type_, loc);
Expression* ref = Expression::make_temporary_reference(val_temp, loc);
Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc);
- Expression* call = Runtime::make_call(code, loc, 3, p1, this->expr_, p3);
+ Expression* call = Runtime::make_call(gogo, code, loc, 3,
+ p1, this->expr_, p3);
Statement* s;
if (ok_temp == NULL)
s = Statement::make_statement(call, true);
@@ -2565,7 +2572,7 @@ Thunk_statement::simplify_statement(Gogo* gogo,
Named_object* function,
Expression* nil = Expression::make_nil(location);
Expression* isnil = Expression::make_binary(OPERATOR_EQEQ, fn, nil,
location);
- Expression* crash = Runtime::make_call(Runtime::PANIC_GO_NIL,
+ Expression* crash = Runtime::make_call(gogo, Runtime::PANIC_GO_NIL,
location, 0);
crash = Expression::make_conditional(isnil, crash,
Expression::make_nil(location),
@@ -2749,7 +2756,7 @@ Thunk_statement::build_thunk(Gogo* gogo, const
std::string& thunk_name,
{
retaddr_label = gogo->add_label_reference("retaddr", location, false);
Expression* arg = Expression::make_label_addr(retaddr_label, location);
- Expression* call = Runtime::make_call(Runtime::SETDEFERRETADDR,
+ Expression* call = Runtime::make_call(gogo, Runtime::SETDEFERRETADDR,
location, 1, arg);
// This is a hack to prevent the middle-end from deleting the
@@ -2973,7 +2980,8 @@ Go_statement::do_get_backend(Translate_context* context)
if (!this->get_fn_and_arg(&fn, &arg))
return context->backend()->error_statement();
- Expression* call = Runtime::make_call(Runtime::GO, this->location(), 2,
+ Gogo* gogo = context->gogo();
+ Expression* call = Runtime::make_call(gogo, Runtime::GO, this->location(), 2,
fn, arg);
Bexpression* bcall = call->get_backend(context);
Bfunction* bfunction = context->function()->func_value()->get_decl();
@@ -3009,6 +3017,7 @@ Defer_statement::do_get_backend(Translate_context*
context)
if (!this->get_fn_and_arg(&fn, &arg))
return context->backend()->error_statement();
+ Gogo* gogo = context->gogo();
Location loc = this->location();
Expression* ds = context->function()->func_value()->defer_stack(loc);
@@ -3022,11 +3031,11 @@ Defer_statement::do_get_backend(Translate_context*
context)
Expression* defer = Expression::make_allocation(defer_type, loc);
defer->allocation_expression()->set_allocate_on_stack();
defer->allocation_expression()->set_no_zero();
- call = Runtime::make_call(Runtime::DEFERPROCSTACK, loc, 4,
+ call = Runtime::make_call(gogo, Runtime::DEFERPROCSTACK, loc, 4,
defer, ds, fn, arg);
}
else
- call = Runtime::make_call(Runtime::DEFERPROC, loc, 3,
+ call = Runtime::make_call(gogo, Runtime::DEFERPROC, loc, 3,
ds, fn, arg);
Bexpression* bcall = call->get_backend(context);
Bfunction* bfunction = context->function()->func_value()->get_decl();
@@ -4632,12 +4641,12 @@ Type_case_clauses::Type_case_clause::lower(Gogo* gogo,
Expression::make_type_descriptor(type, loc),
loc);
else
- cond = Runtime::make_call(Runtime::EQTYPE, loc, 2,
+ cond = Runtime::make_call(gogo, Runtime::EQTYPE, loc, 2,
Expression::make_type_descriptor(type,
loc),
ref);
}
else
- cond = Runtime::make_call(Runtime::IFACET2IP, loc, 2,
+ cond = Runtime::make_call(gogo, Runtime::IFACET2IP, loc, 2,
Expression::make_type_descriptor(type, loc),
ref);
@@ -5076,6 +5085,7 @@ Send_statement::do_add_conversions()
Bstatement*
Send_statement::do_get_backend(Translate_context* context)
{
+ Gogo* gogo = context->gogo();
Location loc = this->location();
Channel_type* channel_type = this->channel_->type()->channel_type();
@@ -5147,7 +5157,7 @@ Send_statement::do_get_backend(Translate_context* context)
btemp = temp->get_backend(context);
}
- Expression* call = Runtime::make_call(Runtime::CHANSEND, loc, 2,
+ Expression* call = Runtime::make_call(gogo, Runtime::CHANSEND, loc, 2,
this->channel_, val);
context->gogo()->lower_expression(context->function(), NULL, &call);
@@ -5660,7 +5670,9 @@ Select_clauses::get_backend(Translate_context* context,
if (count == 0)
return context->backend()->expression_statement(bfunction, bindex);
- Expression* crash = Runtime::make_call(Runtime::UNREACHABLE, location, 0);
+ Gogo* gogo = context->gogo();
+ Expression* crash = Runtime::make_call(gogo, Runtime::UNREACHABLE,
+ location, 0);
Bexpression* bcrash = crash->get_backend(context);
clauses[count] = context->backend()->expression_statement(bfunction, bcrash);
@@ -5726,7 +5738,7 @@ Select_statement::do_lower(Gogo* gogo, Named_object*
function,
// Zero-case select. Just block the execution.
if (ncases == 0)
{
- Expression* call = Runtime::make_call(Runtime::BLOCK, loc, 0);
+ Expression* call = Runtime::make_call(gogo, Runtime::BLOCK, loc, 0);
Statement *s = Statement::make_statement(call, false);
b->add_statement(s);
this->is_lowered_ = true;
@@ -5735,12 +5747,12 @@ Select_statement::do_lower(Gogo* gogo, Named_object*
function,
// One-case select. It is mostly just to run the case.
if (ncases == 1)
- return this->lower_one_case(b);
+ return this->lower_one_case(gogo, b);
// Two-case select with one default case. It is a non-blocking
// send/receive.
if (ncases == 2 && has_default)
- return this->lower_two_case(b);
+ return this->lower_two_case(gogo, b);
// We don't allocate an entry in scases for the default case.
if (has_default)
@@ -5803,7 +5815,7 @@ Select_statement::do_lower(Gogo* gogo, Named_object*
function,
loc);
Expression* block_expr = Expression::make_boolean(!has_default, loc);
- Call_expression* call = Runtime::make_call(Runtime::SELECTGO, loc, 5,
+ Call_expression* call = Runtime::make_call(gogo, Runtime::SELECTGO, loc, 5,
scases_ref, order_ref,
send_count_expr, recv_count_expr,
block_expr);
@@ -5827,7 +5839,7 @@ Select_statement::do_lower(Gogo* gogo, Named_object*
function,
// Lower a one-case select statement.
Statement*
-Select_statement::lower_one_case(Block* b)
+Select_statement::lower_one_case(Gogo* gogo, Block* b)
{
Select_clauses::Select_clause& scase = this->clauses_->at(0);
Location loc = this->location();
@@ -5843,7 +5855,7 @@ Select_statement::lower_one_case(Block* b)
Expression* nil = Expression::make_nil(loc);
Expression* cond = Expression::make_binary(OPERATOR_EQEQ, chanref, nil,
loc);
Block* bnil = new Block(b, loc);
- Expression* call = Runtime::make_call(Runtime::BLOCK, loc, 0);
+ Expression* call = Runtime::make_call(gogo, Runtime::BLOCK, loc, 0);
Statement* s = Statement::make_statement(call, false);
bnil->add_statement(s);
Statement* ifs = Statement::make_if_statement(cond, bnil, NULL, loc);
@@ -5935,7 +5947,7 @@ Select_statement::lower_one_case(Block* b)
// Lower a two-case select statement with one default case.
Statement*
-Select_statement::lower_two_case(Block* b)
+Select_statement::lower_two_case(Gogo* gogo, Block* b)
{
Select_clauses::Select_clause& chancase =
(this->clauses_->at(0).is_default()
@@ -5968,7 +5980,8 @@ Select_statement::lower_two_case(Block* b)
Expression* ref = Expression::make_temporary_reference(ts, loc);
Expression* addr = Expression::make_unary(OPERATOR_AND, ref, loc);
- cond = Runtime::make_call(Runtime::SELECTNBSEND, loc, 2, chanref, addr);
+ cond = Runtime::make_call(gogo, Runtime::SELECTNBSEND, loc, 2,
+ chanref, addr);
bchan = chancase.statements();
}
else
@@ -5980,8 +5993,8 @@ Select_statement::lower_two_case(Block* b)
Expression* addr = Expression::make_unary(OPERATOR_AND, ref, loc);
// selected, ok = selectnbrecv(&lhs, chan)
- Call_expression* call = Runtime::make_call(Runtime::SELECTNBRECV, loc, 2,
- addr, chanref);
+ Call_expression* call = Runtime::make_call(gogo, Runtime::SELECTNBRECV,
+ loc, 2, addr, chanref);
Temporary_statement* selected_temp =
Statement::make_temporary(Type::make_boolean_type(),
@@ -6389,7 +6402,8 @@ For_range_statement::do_lower(Gogo* gogo, Named_object*,
Block* enclosing,
// calls.
if (range_type->map_type() != NULL)
{
- Statement* clear = this->lower_map_range_clear(range_type,
+ Statement* clear = this->lower_map_range_clear(gogo,
+ range_type,
enclosing,
orig_range_expr,
range_object,
@@ -6856,7 +6870,7 @@ For_range_statement::lower_range_string(Gogo* gogo,
ref = this->make_range_ref(range_object, range_temp, loc);
index_ref = Expression::make_temporary_reference(index_temp, loc);
- call = Runtime::make_call(Runtime::DECODERUNE, loc, 2, ref, index_ref);
+ call = Runtime::make_call(gogo, Runtime::DECODERUNE, loc, 2, ref, index_ref);
value_ref = Expression::make_temporary_reference(value_temp, loc);
value_ref->set_is_lvalue();
@@ -6935,7 +6949,7 @@ For_range_statement::lower_range_map(Gogo* gogo,
Expression* p2 = this->make_range_ref(range_object, range_temp, loc);
Expression* ref = Expression::make_temporary_reference(hiter, loc);
Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc);
- Expression* call = Runtime::make_call(Runtime::MAPITERINIT, loc, 3,
+ Expression* call = Runtime::make_call(gogo, Runtime::MAPITERINIT, loc, 3,
p1, p2, p3);
init->add_statement(Statement::make_statement(call, true));
@@ -6985,7 +6999,7 @@ For_range_statement::lower_range_map(Gogo* gogo,
ref = Expression::make_temporary_reference(hiter, loc);
p1 = Expression::make_unary(OPERATOR_AND, ref, loc);
- call = Runtime::make_call(Runtime::MAPITERNEXT, loc, 1, p1);
+ call = Runtime::make_call(gogo, Runtime::MAPITERNEXT, loc, 1, p1);
post->add_statement(Statement::make_statement(call, true));
*ppost = post;
@@ -7069,7 +7083,8 @@ For_range_statement::lower_range_channel(Gogo*,
// containing the call. Return NULL otherwise.
Statement*
-For_range_statement::lower_map_range_clear(Type* map_type,
+For_range_statement::lower_map_range_clear(Gogo* gogo,
+ Type* map_type,
Block* enclosing,
Expression* orig_range_expr,
Named_object* range_object,
@@ -7109,7 +7124,7 @@ For_range_statement::lower_map_range_clear(Type* map_type,
// Everything matches. Rewrite to mapclear(TYPE, MAP).
Expression* e1 = Expression::make_type_descriptor(map_type, loc);
Expression* e2 = this->make_range_ref(range_object, range_temp, loc);
- call = Runtime::make_call(Runtime::MAPCLEAR, loc, 2, e1, e2);
+ call = Runtime::make_call(gogo, Runtime::MAPCLEAR, loc, 2, e1, e2);
return Statement::make_statement(call, true);
}
@@ -7198,12 +7213,13 @@ For_range_statement::lower_array_range_clear(Gogo* gogo,
Expression* sz_arg = Expression::make_temporary_reference(ts2, loc);
Expression* call;
if (elem_type->has_pointer())
- call = Runtime::make_call(Runtime::MEMCLRHASPTR, loc, 2, ptr_arg, sz_arg);
+ call = Runtime::make_call(gogo, Runtime::MEMCLRHASPTR, loc, 2,
+ ptr_arg, sz_arg);
else
{
Type* int32_type = Type::lookup_integer_type("int32");
Expression* zero32 = Expression::make_integer_ul(0, int32_type, loc);
- call = Runtime::make_call(Runtime::BUILTIN_MEMSET, loc, 3, ptr_arg,
+ call = Runtime::make_call(gogo, Runtime::BUILTIN_MEMSET, loc, 3, ptr_arg,
zero32, sz_arg);
}
Statement* cs3 = Statement::make_statement(call, true);
diff --git a/gcc/go/gofrontend/statements.h b/gcc/go/gofrontend/statements.h
index 5fac01b916e..9a920ba6970 100644
--- a/gcc/go/gofrontend/statements.h
+++ b/gcc/go/gofrontend/statements.h
@@ -1284,11 +1284,11 @@ class Select_statement : public Statement
private:
// Lower a one-case select statement.
Statement*
- lower_one_case(Block*);
+ lower_one_case(Gogo*, Block*);
// Lower a two-case select statement with one defualt case.
Statement*
- lower_two_case(Block*);
+ lower_two_case(Gogo*, Block*);
// The select clauses.
Select_clauses* clauses_;
@@ -1760,7 +1760,7 @@ class For_range_statement : public Statement
Block**);
Statement*
- lower_map_range_clear(Type*, Block*, Expression*, Named_object*,
+ lower_map_range_clear(Gogo*, Type*, Block*, Expression*, Named_object*,
Temporary_statement*, Location);
Statement*
diff --git a/gcc/go/gofrontend/wb.cc b/gcc/go/gofrontend/wb.cc
index e039c668847..062101432b9 100644
--- a/gcc/go/gofrontend/wb.cc
+++ b/gcc/go/gofrontend/wb.cc
@@ -923,7 +923,8 @@ Gogo::assign_with_write_barrier(Function* function, Block*
enclosing,
{
// These types are all represented by a single pointer.
rhs = Expression::make_unsafe_cast(uintptr_type, rhs, loc);
- call = Runtime::make_call(Runtime::GCWRITEBARRIER, loc, 2, lhs, rhs);
+ call = Runtime::make_call(this, Runtime::GCWRITEBARRIER, loc, 2,
+ lhs, rhs);
}
break;
@@ -953,7 +954,8 @@ Gogo::assign_with_write_barrier(Function* function, Block*
enclosing,
assign = Statement::make_assignment(lhs, rhs, loc);
lhs = Expression::make_unary(OPERATOR_AND, lhs, loc);
rhs = Expression::make_unsafe_cast(uintptr_type, rhs, loc);
- call = Runtime::make_call(Runtime::GCWRITEBARRIER, loc, 2, lhs, rhs);
+ call = Runtime::make_call(this, Runtime::GCWRITEBARRIER, loc, 2,
+ lhs, rhs);
}
break;
@@ -990,7 +992,8 @@ Gogo::assign_with_write_barrier(Function* function, Block*
enclosing,
assign = Statement::make_assignment(lhs, rhs, loc);
lhs = Expression::make_unary(OPERATOR_AND, lhs, loc);
rhs = Expression::make_unsafe_cast(uintptr_type, rhs, loc);
- call = Runtime::make_call(Runtime::GCWRITEBARRIER, loc, 2, lhs, rhs);
+ call = Runtime::make_call(this, Runtime::GCWRITEBARRIER, loc, 2,
+ lhs, rhs);
}
break;
@@ -1033,7 +1036,8 @@ Gogo::assign_with_write_barrier(Function* function,
Block* enclosing,
assign = Statement::make_assignment(lhs, rhs, loc);
lhs = Expression::make_unary(OPERATOR_AND, lhs, loc);
rhs = Expression::make_unsafe_cast(uintptr_type, rhs, loc);
- call = Runtime::make_call(Runtime::GCWRITEBARRIER, loc, 2, lhs, rhs);
+ call = Runtime::make_call(this, Runtime::GCWRITEBARRIER, loc, 2,
+ lhs, rhs);
break;
}
// fallthrough
@@ -1043,14 +1047,15 @@ Gogo::assign_with_write_barrier(Function* function,
Block* enclosing,
{
rhs = Expression::unpack_direct_iface(rhs, loc);
rhs = Expression::make_unsafe_cast(uintptr_type, rhs, loc);
- call = Runtime::make_call(Runtime::GCWRITEBARRIER, loc, 2, lhs, rhs);
+ call = Runtime::make_call(this, Runtime::GCWRITEBARRIER, loc, 2,
+ lhs, rhs);
}
else
{
// TODO: split assignments for small struct/array?
rhs = Expression::make_unary(OPERATOR_AND, rhs, loc);
rhs->unary_expression()->set_does_not_escape();
- call = Runtime::make_call(Runtime::TYPEDMEMMOVE, loc, 3,
+ call = Runtime::make_call(this, Runtime::TYPEDMEMMOVE, loc, 3,
Expression::make_type_descriptor(type,
loc),
lhs, rhs);
}
