Use backend interface for zero initialization.

	* go-gcc.cc (Gcc_backend::zero_expression): New function.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@174863 138bc75d-0d04-0410-961f-82ee72b054a4

8 files changed, 72 insertions, 390 deletions

diff --git a/gcc/go/ChangeLog b/gcc/go/ChangeLog
index edaadec3c47..aac428bfa8b 100644
--- a/gcc/go/ChangeLog
+++ b/gcc/go/ChangeLog
@@ -1,3 +1,7 @@
+2011-06-09  Ian Lance Taylor  <iant@google.com>
+
+	* go-gcc.cc (Gcc_backend::zero_expression): New function.
+
 2011-06-07  Richard Guenther  <rguenther@suse.de>
 
 	* go-lang.c (go_langhook_init): Do not set
diff --git a/gcc/go/go-gcc.cc b/gcc/go/go-gcc.cc
index a024e197132..1299e9b53be 100644
--- a/gcc/go/go-gcc.cc
+++ b/gcc/go/go-gcc.cc
@@ -194,6 +194,11 @@ class Gcc_backend : public Backend
   bool
   is_circular_pointer_type(Btype*);
 
+  // Expressions.
+
+  Bexpression*
+  zero_expression(Btype*);
+
   // Statements.
 
   Bstatement*
@@ -700,6 +705,20 @@ Gcc_backend::is_circular_pointer_type(Btype* btype)
   return btype->get_tree() == ptr_type_node;
 }
 
+// Return the zero value for a type.
+
+Bexpression*
+Gcc_backend::zero_expression(Btype* btype)
+{
+  tree t = btype->get_tree();
+  tree ret;
+  if (t == error_mark_node)
+    ret = error_mark_node;
+  else
+    ret = build_zero_cst(t);
+  return tree_to_expr(ret);
+}
+
 // An expression as a statement.
 
 Bstatement*
diff --git a/gcc/go/gofrontend/backend.h b/gcc/go/gofrontend/backend.h
index e2dde9a08e6..5ece2e698fb 100644
--- a/gcc/go/gofrontend/backend.h
+++ b/gcc/go/gofrontend/backend.h
@@ -198,6 +198,14 @@ class Backend
   virtual bool
   is_circular_pointer_type(Btype*) = 0;
 
+  // Expressions.
+
+  // Return an expression for a zero value of the given type.  This is
+  // used for cases such as local variable initialization and
+  // converting nil to other types.
+  virtual Bexpression*
+  zero_expression(Btype*) = 0;
+
   // Statements.
 
   // Create an error statement.  This is used for cases which should
diff --git a/gcc/go/gofrontend/expressions.cc b/gcc/go/gofrontend/expressions.cc
index 5dda7916196..f656acb90ff 100644
--- a/gcc/go/gofrontend/expressions.cc
+++ b/gcc/go/gofrontend/expressions.cc
@@ -318,7 +318,10 @@ Expression::convert_type_to_interface(Translate_context* context,
   // When setting an interface to nil, we just set both fields to
   // NULL.
   if (rhs_type->is_nil_type())
-    return lhs_type->get_init_tree(gogo, false);
+    {
+      Btype* lhs_btype = lhs_type->get_backend(gogo);
+      return expr_to_tree(gogo->backend()->zero_expression(lhs_btype));
+    }
 
   // This should have been checked already.
   go_assert(lhs_interface_type->implements_interface(rhs_type, NULL));
@@ -10046,12 +10049,14 @@ Map_index_expression::do_get_tree(Translate_context* context)
     }
   else
     {
+      Gogo* gogo = context->gogo();
+      Btype* val_btype = type->val_type()->get_backend(gogo);
+      Bexpression* val_zero = gogo->backend()->zero_expression(val_btype);
       return fold_build3(COND_EXPR, val_type_tree,
 			 fold_build2(EQ_EXPR, boolean_type_node, valptr,
 				     fold_convert(TREE_TYPE(valptr),
 						  null_pointer_node)),
-			 type->val_type()->get_init_tree(context->gogo(),
-							 false),
+			 expr_to_tree(val_zero),
 			 build_fold_indirect_ref(valptr));
     }
 }
@@ -10958,7 +10963,10 @@ Struct_construction_expression::do_get_tree(Translate_context* context)
   Gogo* gogo = context->gogo();
 
   if (this->vals_ == NULL)
-    return this->type_->get_init_tree(gogo, false);
+    {
+      Btype* btype = this->type_->get_backend(gogo);
+      return expr_to_tree(gogo->backend()->zero_expression(btype));
+    }
 
   tree type_tree = type_to_tree(this->type_->get_backend(gogo));
   if (type_tree == error_mark_node)
@@ -10977,12 +10985,14 @@ Struct_construction_expression::do_get_tree(Translate_context* context)
     {
       go_assert(pf != fields->end());
 
+      Btype* fbtype = pf->type()->get_backend(gogo);
+
       tree val;
       if (pv == this->vals_->end())
-	val = pf->type()->get_init_tree(gogo, false);
+	val = expr_to_tree(gogo->backend()->zero_expression(fbtype));
       else if (*pv == NULL)
 	{
-	  val = pf->type()->get_init_tree(gogo, false);
+	  val = expr_to_tree(gogo->backend()->zero_expression(fbtype));
 	  ++pv;
 	}
       else
@@ -11217,7 +11227,12 @@ Array_construction_expression::get_constructor_tree(Translate_context* context,
 	  constructor_elt* elt = VEC_quick_push(constructor_elt, values, NULL);
 	  elt->index = size_int(i);
 	  if (*pv == NULL)
-	    elt->value = element_type->get_init_tree(context->gogo(), false);
+	    {
+	      Gogo* gogo = context->gogo();
+	      Btype* ebtype = element_type->get_backend(gogo);
+	      Bexpression *zv = gogo->backend()->zero_expression(ebtype);
+	      elt->value = expr_to_tree(zv);
+	    }
 	  else
 	    {
 	      tree value_tree = (*pv)->get_tree(context);
@@ -11363,7 +11378,9 @@ Open_array_construction_expression::do_get_tree(Translate_context* context)
       VEC(constructor_elt,gc)* vec = VEC_alloc(constructor_elt, gc, 1);
       constructor_elt* elt = VEC_quick_push(constructor_elt, vec, NULL);
       elt->index = size_int(0);
-      elt->value = element_type->get_init_tree(context->gogo(), false);
+      Gogo* gogo = context->gogo();
+      Btype* btype = element_type->get_backend(gogo);
+      elt->value = expr_to_tree(gogo->backend()->zero_expression(btype));
       values = build_constructor(constructor_type, vec);
       if (TREE_CONSTANT(elt->value))
 	TREE_CONSTANT(values) = 1;
diff --git a/gcc/go/gofrontend/gogo-tree.cc b/gcc/go/gofrontend/gogo-tree.cc
index 7cd75111e36..8c41f7462e6 100644
--- a/gcc/go/gofrontend/gogo-tree.cc
+++ b/gcc/go/gofrontend/gogo-tree.cc
@@ -1035,9 +1035,10 @@ Variable::get_init_tree(Gogo* gogo, Named_object* function)
   if (this->init_ == NULL)
     {
       go_assert(!this->is_parameter_);
-      return this->type_->get_init_tree(gogo,
-					(this->is_global_
-					 || this->is_in_heap()));
+      if (this->is_global_ || this->is_in_heap())
+	return NULL;
+      Btype* btype = this->type_->get_backend(gogo);
+      return expr_to_tree(gogo->backend()->zero_expression(btype));
     }
   else
     {
@@ -1286,7 +1287,8 @@ Function::make_receiver_parm_decl(Gogo* gogo, Named_object* no, tree var_decl)
 						null_pointer_node));
   tree ind = build_fold_indirect_ref_loc(loc, parm_decl);
   TREE_THIS_NOTRAP(ind) = 1;
-  tree zero_init = no->var_value()->type()->get_init_tree(gogo, false);
+  Btype* btype = no->var_value()->type()->get_backend(gogo);
+  tree zero_init = expr_to_tree(gogo->backend()->zero_expression(btype));
   tree init = fold_build3_loc(loc, COND_EXPR, TREE_TYPE(ind),
 			      check, ind, zero_init);
 
@@ -1423,7 +1425,10 @@ Function::build_tree(Gogo* gogo, Named_object* named_function)
 	  Type* type = (*p)->result_var_value()->type();
 	  tree init;
 	  if (!(*p)->result_var_value()->is_in_heap())
-	    init = type->get_init_tree(gogo, false);
+	    {
+	      Btype* btype = type->get_backend(gogo);
+	      init = expr_to_tree(gogo->backend()->zero_expression(btype));
+	    }
 	  else
 	    {
 	      source_location loc = (*p)->location();
@@ -1432,20 +1437,7 @@ Function::build_tree(Gogo* gogo, Named_object* named_function)
 						 TYPE_SIZE_UNIT(type_tree),
 						 loc);
 	      tree ptr_type_tree = build_pointer_type(type_tree);
-	      tree subinit = type->get_init_tree(gogo, true);
-	      if (subinit == NULL_TREE)
-		init = fold_convert_loc(loc, ptr_type_tree, space);
-	      else
-		{
-		  space = save_expr(space);
-		  space = fold_convert_loc(loc, ptr_type_tree, space);
-		  tree spaceref = build_fold_indirect_ref_loc(loc, space);
-		  TREE_THIS_NOTRAP(spaceref) = 1;
-		  tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
-					     spaceref, subinit);
-		  init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
-					 set, space);
-		}
+	      init = fold_convert_loc(loc, ptr_type_tree, space);
 	    }
 
 	  if (var_decl != error_mark_node)
diff --git a/gcc/go/gofrontend/gogo.cc b/gcc/go/gofrontend/gogo.cc
index ba3e9df0c2a..c3c014e5962 100644
--- a/gcc/go/gofrontend/gogo.cc
+++ b/gcc/go/gofrontend/gogo.cc
@@ -1498,6 +1498,10 @@ Check_types_traverse::variable(Named_object* named_object)
   if (named_object->is_variable())
     {
       Variable* var = named_object->var_value();
+
+      // Give error if variable type is not defined.
+      var->type()->base();
+
       Expression* init = var->init();
       std::string reason;
       if (init != NULL
diff --git a/gcc/go/gofrontend/types.cc b/gcc/go/gofrontend/types.cc
index bf1921610c1..37cca8370e5 100644
--- a/gcc/go/gofrontend/types.cc
+++ b/gcc/go/gofrontend/types.cc
@@ -913,17 +913,6 @@ Type::get_btype_without_hash(Gogo* gogo)
   return this->btype_;
 }
 
-// Return a tree representing a zero initialization for this type.
-
-tree
-Type::get_init_tree(Gogo* gogo, bool is_clear)
-{
-  tree type_tree = type_to_tree(this->get_backend(gogo));
-  if (type_tree == error_mark_node)
-    return error_mark_node;
-  return this->do_get_init_tree(gogo, type_tree, is_clear);
-}
-
 // Any type which supports the builtin make function must implement
 // this.
 
@@ -1609,10 +1598,6 @@ class Error_type : public Type
   do_get_backend(Gogo* gogo)
   { return gogo->backend()->error_type(); }
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool)
-  { return error_mark_node; }
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*)
   { return Expression::make_error(BUILTINS_LOCATION); }
@@ -1647,10 +1632,6 @@ class Void_type : public Type
   do_get_backend(Gogo* gogo)
   { return gogo->backend()->void_type(); }
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool)
-  { go_unreachable(); }
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*)
   { go_unreachable(); }
@@ -1685,10 +1666,6 @@ class Boolean_type : public Type
   do_get_backend(Gogo* gogo)
   { return gogo->backend()->bool_type(); }
 
-  tree
-  do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-  { return is_clear ? NULL : fold_convert(type_tree, boolean_false_node); }
-
   Expression*
   do_type_descriptor(Gogo*, Named_type* name);
 
@@ -1830,12 +1807,6 @@ Integer_type::do_get_backend(Gogo* gogo)
   return gogo->backend()->integer_type(this->is_unsigned_, this->bits_);
 }
 
-tree
-Integer_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  return is_clear ? NULL : build_int_cst(type_tree, 0);
-}
-
 // The type descriptor for an integer type.  Integer types are always
 // named.
 
@@ -1963,16 +1934,6 @@ Float_type::do_get_backend(Gogo* gogo)
   return gogo->backend()->float_type(this->bits_);
 }
 
-tree
-Float_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  if (is_clear)
-    return NULL;
-  REAL_VALUE_TYPE r;
-  real_from_integer(&r, TYPE_MODE(type_tree), 0, 0, 0);
-  return build_real(type_tree, r);
-}
-
 // The type descriptor for a float type.  Float types are always named.
 
 Expression*
@@ -2099,19 +2060,6 @@ Complex_type::do_get_backend(Gogo* gogo)
   return gogo->backend()->complex_type(this->bits_);
 }
 
-// Zero initializer.
-
-tree
-Complex_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  if (is_clear)
-    return NULL;
-  REAL_VALUE_TYPE r;
-  real_from_integer(&r, TYPE_MODE(TREE_TYPE(type_tree)), 0, 0, 0);
-  return build_complex(type_tree, build_real(TREE_TYPE(type_tree), r),
-		       build_real(TREE_TYPE(type_tree), r));
-}
-
 // The type descriptor for a complex type.  Complex types are always
 // named.
 
@@ -2223,32 +2171,6 @@ String_type::bytes_tree(Gogo*, tree string)
 		     bytes_field, NULL_TREE);
 }
 
-// We initialize a string to { NULL, 0 }.
-
-tree
-String_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  if (is_clear)
-    return NULL_TREE;
-
-  go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
-
-  VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
-
-  for (tree field = TYPE_FIELDS(type_tree);
-       field != NULL_TREE;
-       field = DECL_CHAIN(field))
-    {
-      constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
-      elt->index = field;
-      elt->value = fold_convert(TREE_TYPE(field), size_zero_node);
-    }
-
-  tree ret = build_constructor(type_tree, init);
-  TREE_CONSTANT(ret) = 1;
-  return ret;
-}
-
 // The type descriptor for the string type.
 
 Expression*
@@ -2330,10 +2252,6 @@ class Sink_type : public Type
   do_get_backend(Gogo*)
   { go_unreachable(); }
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool)
-  { go_unreachable(); }
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*)
   { go_unreachable(); }
@@ -2704,16 +2622,6 @@ Function_type::convert_types(Gogo* gogo)
     }
 }
 
-// Functions are initialized to NULL.
-
-tree
-Function_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  if (is_clear)
-    return NULL;
-  return fold_convert(type_tree, null_pointer_node);
-}
-
 // The type of a function type descriptor.
 
 Type*
@@ -3109,16 +3017,6 @@ Pointer_type::do_get_backend(Gogo* gogo)
   return gogo->backend()->pointer_type(to_btype);
 }
 
-// Initialize a pointer type.
-
-tree
-Pointer_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  if (is_clear)
-    return NULL;
-  return fold_convert(type_tree, null_pointer_node);
-}
-
 // The type of a pointer type descriptor.
 
 Type*
@@ -3262,10 +3160,6 @@ class Nil_type : public Type
   do_get_backend(Gogo* gogo)
   { return gogo->backend()->pointer_type(gogo->backend()->void_type()); }
 
-  tree
-  do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-  { return is_clear ? NULL : fold_convert(type_tree, null_pointer_node); }
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*)
   { go_unreachable(); }
@@ -3316,13 +3210,6 @@ class Call_multiple_result_type : public Type
     return gogo->backend()->error_type();
   }
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool)
-  {
-    go_assert(saw_errors());
-    return error_mark_node;
-  }
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*)
   {
@@ -3823,63 +3710,6 @@ Struct_type::do_get_backend(Gogo* gogo)
   return gogo->backend()->struct_type(bfields);
 }
 
-// Initialize struct fields.
-
-tree
-Struct_type::do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
-{
-  if (this->fields_ == NULL || this->fields_->empty())
-    {
-      if (is_clear)
-	return NULL;
-      else
-	{
-	  tree ret = build_constructor(type_tree,
-				       VEC_alloc(constructor_elt, gc, 0));
-	  TREE_CONSTANT(ret) = 1;
-	  return ret;
-	}
-    }
-
-  bool is_constant = true;
-  bool any_fields_set = false;
-  VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc,
-					    this->fields_->size());
-
-  tree field = TYPE_FIELDS(type_tree);
-  for (Struct_field_list::const_iterator p = this->fields_->begin();
-       p != this->fields_->end();
-       ++p, field = DECL_CHAIN(field))
-    {
-      tree value = p->type()->get_init_tree(gogo, is_clear);
-      if (value == error_mark_node)
-	return error_mark_node;
-      go_assert(field != NULL_TREE);
-      if (value != NULL)
-	{
-	  constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
-	  elt->index = field;
-	  elt->value = value;
-	  any_fields_set = true;
-	  if (!TREE_CONSTANT(value))
-	    is_constant = false;
-	}
-    }
-  go_assert(field == NULL_TREE);
-
-  if (!any_fields_set)
-    {
-      go_assert(is_clear);
-      VEC_free(constructor_elt, gc, init);
-      return NULL;
-    }
-
-  tree ret = build_constructor(type_tree, init);
-  if (is_constant)
-    TREE_CONSTANT(ret) = 1;
-  return ret;
-}
-
 // The type of a struct type descriptor.
 
 Type*
@@ -4503,61 +4333,6 @@ Array_type::get_backend_length(Gogo* gogo)
   return tree_to_expr(this->get_length_tree(gogo));
 }
 
-// Return an initializer for an array type.
-
-tree
-Array_type::do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
-{
-  if (this->length_ == NULL)
-    {
-      // Open array.
-
-      if (is_clear)
-	return NULL;
-
-      go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
-
-      VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
-
-      for (tree field = TYPE_FIELDS(type_tree);
-	   field != NULL_TREE;
-	   field = DECL_CHAIN(field))
-	{
-	  constructor_elt* elt = VEC_quick_push(constructor_elt, init,
-						NULL);
-	  elt->index = field;
-	  elt->value = fold_convert(TREE_TYPE(field), size_zero_node);
-	}
-
-      tree ret = build_constructor(type_tree, init);
-      TREE_CONSTANT(ret) = 1;
-      return ret;
-    }
-  else
-    {
-      // Fixed array.
-
-      tree value = this->element_type_->get_init_tree(gogo, is_clear);
-      if (value == NULL)
-	return NULL;
-      if (value == error_mark_node)
-	return error_mark_node;
-
-      tree length_tree = this->get_length_tree(gogo);
-      if (length_tree == error_mark_node)
-	return error_mark_node;
-
-      length_tree = fold_convert(sizetype, length_tree);
-      tree range = build2(RANGE_EXPR, sizetype, size_zero_node,
-			  fold_build2(MINUS_EXPR, sizetype,
-				      length_tree, size_one_node));
-      tree ret = build_constructor_single(type_tree, range, value);
-      if (TREE_CONSTANT(value))
-	TREE_CONSTANT(ret) = 1;
-      return ret;
-    }
-}
-
 // Handle the builtin make function for a slice.
 
 tree
@@ -4585,10 +4360,6 @@ Array_type::do_make_expression_tree(Translate_context* context,
     return error_mark_node;
   tree element_size_tree = TYPE_SIZE_UNIT(element_type_tree);
 
-  tree value = this->element_type_->get_init_tree(gogo, true);
-  if (value == error_mark_node)
-    return error_mark_node;
-
   // The first argument is the number of elements, the optional second
   // argument is the capacity.
   go_assert(args != NULL && args->size() >= 1 && args->size() <= 2);
@@ -4670,9 +4441,6 @@ Array_type::do_make_expression_tree(Translate_context* context,
   tree space = context->gogo()->allocate_memory(this->element_type_,
 						size_tree, location);
 
-  if (value != NULL_TREE)
-    space = save_expr(space);
-
   space = fold_convert(TREE_TYPE(values_field), space);
 
   if (bad_index != NULL_TREE && bad_index != boolean_false_node)
@@ -4685,37 +4453,7 @@ Array_type::do_make_expression_tree(Translate_context* context,
 		     space);
     }
 
-  tree constructor = gogo->slice_constructor(type_tree, space, length_tree,
-					     capacity_tree);
-
-  if (value == NULL_TREE)
-    {
-      // The array contents are zero initialized.
-      return constructor;
-    }
-
-  // The elements must be initialized.
-
-  tree max = fold_build2_loc(location, MINUS_EXPR, TREE_TYPE(count_field),
-			     capacity_tree,
-			     fold_convert_loc(location, TREE_TYPE(count_field),
-					      integer_one_node));
-
-  tree array_type = build_array_type(element_type_tree,
-				     build_index_type(max));
-
-  tree value_pointer = fold_convert_loc(location,
-					build_pointer_type(array_type),
-					space);
-
-  tree range = build2(RANGE_EXPR, sizetype, size_zero_node, max);
-  tree space_init = build_constructor_single(array_type, range, value);
-
-  return build2(COMPOUND_EXPR, TREE_TYPE(constructor),
-		build2(MODIFY_EXPR, void_type_node,
-		       build_fold_indirect_ref(value_pointer),
-		       space_init),
-		constructor);
+  return gogo->slice_constructor(type_tree, space, length_tree, capacity_tree);
 }
 
 // Return a tree for a pointer to the values in ARRAY.
@@ -5128,16 +4866,6 @@ Map_type::do_get_backend(Gogo* gogo)
   return backend_map_type;
 }
 
-// Initialize a map.
-
-tree
-Map_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  if (is_clear)
-    return NULL;
-  return fold_convert(type_tree, null_pointer_node);
-}
-
 // Return an expression for a newly allocated map.
 
 tree
@@ -5374,16 +5102,6 @@ Channel_type::do_get_backend(Gogo* gogo)
   return backend_channel_type;
 }
 
-// Initialize a channel variable.
-
-tree
-Channel_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  if (is_clear)
-    return NULL;
-  return fold_convert(type_tree, null_pointer_node);
-}
-
 // Handle the builtin function make for a channel.
 
 tree
@@ -6113,29 +5831,6 @@ Interface_type::do_get_backend(Gogo* gogo)
     }
 }
 
-// Initialization value.
-
-tree
-Interface_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
-{
-  if (is_clear)
-    return NULL;
-
-  VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
-  for (tree field = TYPE_FIELDS(type_tree);
-       field != NULL_TREE;
-       field = DECL_CHAIN(field))
-    {
-      constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
-      elt->index = field;
-      elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
-    }
-
-  tree ret = build_constructor(type_tree, init);
-  TREE_CONSTANT(ret) = 1;
-  return ret;
-}
-
 // The type of an interface type descriptor.
 
 Type*
diff --git a/gcc/go/gofrontend/types.h b/gcc/go/gofrontend/types.h
index 3ada1b1f0f8..23e29dc7522 100644
--- a/gcc/go/gofrontend/types.h
+++ b/gcc/go/gofrontend/types.h
@@ -825,19 +825,6 @@ class Type
   Btype*
   get_backend(Gogo*);
 
-  // Return a tree representing a zero initialization for this type.
-  // This will be something like an INTEGER_CST or a CONSTRUCTOR.  If
-  // IS_CLEAR is true, then the memory is known to be zeroed; in that
-  // case, this will return NULL if there is nothing to be done.
-  tree
-  get_init_tree(Gogo*, bool is_clear);
-
-  // Like get_init_tree, but passing in the type to use for the
-  // initializer.
-  tree
-  get_typed_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
-  { return this->do_get_init_tree(gogo, type_tree, is_clear); }
-
   // Return a tree for a make expression applied to this type.
   tree
   make_expression_tree(Translate_context* context, Expression_list* args,
@@ -896,9 +883,6 @@ class Type
   do_get_backend(Gogo*) = 0;
 
   virtual tree
-  do_get_init_tree(Gogo*, tree, bool) = 0;
-
-  virtual tree
   do_make_expression_tree(Translate_context*, Expression_list*,
 			  source_location);
 
@@ -1334,9 +1318,6 @@ class Integer_type : public Type
   Btype*
   do_get_backend(Gogo*);
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool);
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*);
 
@@ -1406,9 +1387,6 @@ class Float_type : public Type
   Btype*
   do_get_backend(Gogo*);
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool);
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*);
 
@@ -1474,9 +1452,6 @@ class Complex_type : public Type
   Btype*
   do_get_backend(Gogo*);
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool);
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*);
 
@@ -1530,9 +1505,6 @@ class String_type : public Type
   Btype*
   do_get_backend(Gogo*);
 
-  tree
-  do_get_init_tree(Gogo* gogo, tree, bool);
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*);
 
@@ -1650,9 +1622,6 @@ class Function_type : public Type
   Btype*
   do_get_backend(Gogo*);
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool);
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*);
 
@@ -1734,9 +1703,6 @@ class Pointer_type : public Type
   Btype*
   do_get_backend(Gogo*);
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool);
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*);
 
@@ -1988,9 +1954,6 @@ class Struct_type : public Type
   Btype*
   do_get_backend(Gogo*);
 
-  tree
-  do_get_init_tree(Gogo*, tree, bool);
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*);
 
@@ -2106,9 +2069,6 @@ class Array_type : public Type
   do_get_backend(Gogo*);
 
   tree
-  do_get_init_tree(Gogo*, tree, bool);
-
-  tree
   do_make_expression_tree(Translate_context*, Expression_list*,
 			  source_location);
 
@@ -2197,9 +2157,6 @@ class Map_type : public Type
   do_get_backend(Gogo*);
 
   tree
-  do_get_init_tree(Gogo*, tree, bool);
-
-  tree
   do_make_expression_tree(Translate_context*, Expression_list*,
 			  source_location);
 
@@ -2281,9 +2238,6 @@ class Channel_type : public Type
   do_get_backend(Gogo*);
 
   tree
-  do_get_init_tree(Gogo*, tree, bool);
-
-  tree
   do_make_expression_tree(Translate_context*, Expression_list*,
 			  source_location);
 
@@ -2398,9 +2352,6 @@ class Interface_type : public Type
   Btype*
   do_get_backend(Gogo*);
 
-  tree
-  do_get_init_tree(Gogo* gogo, tree, bool);
-
   Expression*
   do_type_descriptor(Gogo*, Named_type*);
 
@@ -2630,10 +2581,6 @@ class Named_type : public Type
   do_get_backend(Gogo*);
 
   tree
-  do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
-  { return this->type_->get_typed_init_tree(gogo, type_tree, is_clear); }
-
-  tree
   do_make_expression_tree(Translate_context* context, Expression_list* args,
 			  source_location location)
   { return this->type_->make_expression_tree(context, args, location); }
@@ -2774,10 +2721,6 @@ class Forward_declaration_type : public Type
   do_get_backend(Gogo* gogo);
 
   tree
-  do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
-  { return this->base()->get_typed_init_tree(gogo, type_tree, is_clear); }
-
-  tree
   do_make_expression_tree(Translate_context* context, Expression_list* args,
 			  source_location location)
   { return this->base()->make_expression_tree(context, args, location); }