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);
         }
