Go patch committed: Use backend interface for array length

[Ian Lance Taylor <iant at google dot com>]

This patch by Chris Manghane changes the Go frontend to use the backend
interface for the length of an array.  Bootstrapped and ran Go testsuite
on x86_64-unknown-linux-gnu.  Committed to mainline.

Ian

diff -r f4135c695c00 go/types.cc
--- a/go/types.cc	Mon May 05 20:10:20 2014 -0400
+++ b/go/types.cc	Mon May 05 21:00:16 2014 -0400
@@ -245,7 +245,7 @@
   return ptype == NULL ? NULL : ptype->points_to();
 }
 
-// Return whether this is an open array type.
+// Return whether this is a slice type.
 
 bool
 Type::is_slice_type() const
@@ -5839,14 +5839,85 @@
   gogo->add_statement(s);
 }
 
-// Get a tree for the length of a fixed array.  The length may be
+// Get the backend representation of the fields of a slice.  This is
+// not declared in types.h so that types.h doesn't have to #include
+// backend.h.
+//
+// We use int for the count and capacity fields.  This matches 6g.
+// The language more or less assumes that we can't allocate space of a
+// size which does not fit in int.
+
+static void
+get_backend_slice_fields(Gogo* gogo, Array_type* type, bool use_placeholder,
+			 std::vector<Backend::Btyped_identifier>* bfields)
+{
+  bfields->resize(3);
+
+  Type* pet = Type::make_pointer_type(type->element_type());
+  Btype* pbet = (use_placeholder
+		 ? pet->get_backend_placeholder(gogo)
+		 : pet->get_backend(gogo));
+  Location ploc = Linemap::predeclared_location();
+
+  Backend::Btyped_identifier* p = &(*bfields)[0];
+  p->name = "__values";
+  p->btype = pbet;
+  p->location = ploc;
+
+  Type* int_type = Type::lookup_integer_type("int");
+
+  p = &(*bfields)[1];
+  p->name = "__count";
+  p->btype = int_type->get_backend(gogo);
+  p->location = ploc;
+
+  p = &(*bfields)[2];
+  p->name = "__capacity";
+  p->btype = int_type->get_backend(gogo);
+  p->location = ploc;
+}
+
+// Get a tree for the type of this array.  A fixed array is simply
+// represented as ARRAY_TYPE with the appropriate index--i.e., it is
+// just like an array in C.  A slice is a struct with three
+// fields: a data pointer, the length, and the capacity.
+
+Btype*
+Array_type::do_get_backend(Gogo* gogo)
+{
+  if (this->length_ == NULL)
+    {
+      std::vector<Backend::Btyped_identifier> bfields;
+      get_backend_slice_fields(gogo, this, false, &bfields);
+      return gogo->backend()->struct_type(bfields);
+    }
+  else
+    {
+      Btype* element = this->get_backend_element(gogo, false);
+      Bexpression* len = this->get_backend_length(gogo);
+      return gogo->backend()->array_type(element, len);
+    }
+}
+
+// Return the backend representation of the element type.
+
+Btype*
+Array_type::get_backend_element(Gogo* gogo, bool use_placeholder)
+{
+  if (use_placeholder)
+    return this->element_type_->get_backend_placeholder(gogo);
+  else
+    return this->element_type_->get_backend(gogo);
+}
+
+// Return the backend representation of the length. The length may be
 // computed using a function call, so we must only evaluate it once.
 
-tree
-Array_type::get_length_tree(Gogo* gogo)
+Bexpression*
+Array_type::get_backend_length(Gogo* gogo)
 {
   go_assert(this->length_ != NULL);
-  if (this->length_tree_ == NULL_TREE)
+  if (this->blength_ == NULL)
     {
       Numeric_constant nc;
       mpz_t val;
@@ -5854,8 +5925,8 @@
 	{
 	  if (mpz_sgn(val) < 0)
 	    {
-	      this->length_tree_ = error_mark_node;
-	      return this->length_tree_;
+	      this->blength_ = gogo->backend()->error_expression();
+	      return this->blength_;
 	    }
 	  Type* t = nc.type();
 	  if (t == NULL)
@@ -5863,9 +5934,8 @@
 	  else if (t->is_abstract())
 	    t = t->make_non_abstract_type();
           Btype* btype = t->get_backend(gogo);
-          Bexpression* iexpr =
-              gogo->backend()->integer_constant_expression(btype, val);
-	  this->length_tree_ = expr_to_tree(iexpr);
+          this->blength_ =
+	    gogo->backend()->integer_constant_expression(btype, val);
 	  mpz_clear(val);
 	}
       else
@@ -5873,97 +5943,15 @@
 	  // Make up a translation context for the array length
 	  // expression.  FIXME: This won't work in general.
 	  Translate_context context(gogo, NULL, NULL, NULL);
-	  tree len = this->length_->get_tree(&context);
-	  if (len != error_mark_node)
-	    {
-	      Type* int_type = Type::lookup_integer_type("int");
-	      tree int_type_tree = type_to_tree(int_type->get_backend(gogo));
-	      len = convert_to_integer(int_type_tree, len);
-	      len = save_expr(len);
-	    }
-	  this->length_tree_ = len;
-	}
-    }
-  return this->length_tree_;
-}
-
-// Get the backend representation of the fields of a slice.  This is
-// not declared in types.h so that types.h doesn't have to #include
-// backend.h.
-//
-// We use int for the count and capacity fields.  This matches 6g.
-// The language more or less assumes that we can't allocate space of a
-// size which does not fit in int.
-
-static void
-get_backend_slice_fields(Gogo* gogo, Array_type* type, bool use_placeholder,
-			 std::vector<Backend::Btyped_identifier>* bfields)
-{
-  bfields->resize(3);
-
-  Type* pet = Type::make_pointer_type(type->element_type());
-  Btype* pbet = (use_placeholder
-		 ? pet->get_backend_placeholder(gogo)
-		 : pet->get_backend(gogo));
-  Location ploc = Linemap::predeclared_location();
-
-  Backend::Btyped_identifier* p = &(*bfields)[0];
-  p->name = "__values";
-  p->btype = pbet;
-  p->location = ploc;
-
-  Type* int_type = Type::lookup_integer_type("int");
-
-  p = &(*bfields)[1];
-  p->name = "__count";
-  p->btype = int_type->get_backend(gogo);
-  p->location = ploc;
-
-  p = &(*bfields)[2];
-  p->name = "__capacity";
-  p->btype = int_type->get_backend(gogo);
-  p->location = ploc;
-}
-
-// Get a tree for the type of this array.  A fixed array is simply
-// represented as ARRAY_TYPE with the appropriate index--i.e., it is
-// just like an array in C.  An open array is a struct with three
-// fields: a data pointer, the length, and the capacity.
-
-Btype*
-Array_type::do_get_backend(Gogo* gogo)
-{
-  if (this->length_ == NULL)
-    {
-      std::vector<Backend::Btyped_identifier> bfields;
-      get_backend_slice_fields(gogo, this, false, &bfields);
-      return gogo->backend()->struct_type(bfields);
-    }
-  else
-    {
-      Btype* element = this->get_backend_element(gogo, false);
-      Bexpression* len = this->get_backend_length(gogo);
-      return gogo->backend()->array_type(element, len);
-    }
-}
-
-// Return the backend representation of the element type.
-
-Btype*
-Array_type::get_backend_element(Gogo* gogo, bool use_placeholder)
-{
-  if (use_placeholder)
-    return this->element_type_->get_backend_placeholder(gogo);
-  else
-    return this->element_type_->get_backend(gogo);
-}
-
-// Return the backend representation of the length.
-
-Bexpression*
-Array_type::get_backend_length(Gogo* gogo)
-{
-  return tree_to_expr(this->get_length_tree(gogo));
+	  this->blength_ = tree_to_expr(this->length_->get_tree(&context));
+
+	  Btype* ibtype = Type::lookup_integer_type("int")->get_backend(gogo);
+	  this->blength_ =
+	    gogo->backend()->convert_expression(ibtype, this->blength_,
+						this->length_->location());
+	}
+    }
+  return this->blength_;
 }
 
 // Finish backend representation of the array.
@@ -5997,7 +5985,7 @@
                                    array->location());
     }
 
-  // Open array.
+  // Slice.
   return Expression::make_slice_info(array,
                                      Expression::SLICE_INFO_VALUE_POINTER,
                                      array->location());
@@ -6012,7 +6000,7 @@
   if (this->length_ != NULL)
     return this->length_;
 
-  // This is an open array.  We need to read the length field.
+  // This is a slice.  We need to read the length field.
   return Expression::make_slice_info(array, Expression::SLICE_INFO_LENGTH,
                                      array->location());
 }
@@ -6026,7 +6014,7 @@
   if (this->length_ != NULL)
     return this->length_;
 
-  // This is an open array.  We need to read the capacity field.
+  // This is a slice.  We need to read the capacity field.
   return Expression::make_slice_info(array, Expression::SLICE_INFO_CAPACITY,
                                      array->location());
 }
diff -r f4135c695c00 go/types.h
--- a/go/types.h	Mon May 05 20:10:20 2014 -0400
+++ b/go/types.h	Mon May 05 21:00:16 2014 -0400
@@ -2305,7 +2305,7 @@
  public:
   Array_type(Type* element_type, Expression* length)
     : Type(TYPE_ARRAY),
-      element_type_(element_type), length_(length), length_tree_(NULL)
+      element_type_(element_type), length_(length), blength_(NULL)
   { }
 
   // Return the element type.
@@ -2313,7 +2313,7 @@
   element_type() const
   { return this->element_type_; }
 
-  // Return the length.  This will return NULL for an open array.
+  // Return the length.  This will return NULL for a slice.
   Expression*
   length() const
   { return this->length_; }
@@ -2407,9 +2407,6 @@
   bool
   verify_length();
 
-  tree
-  get_length_tree(Gogo*);
-
   Expression*
   array_type_descriptor(Gogo*, Named_type*);
 
@@ -2420,8 +2417,9 @@
   Type* element_type_;
   // The number of elements.  This may be NULL.
   Expression* length_;
-  // The length as a tree.  We only want to compute this once.
-  tree length_tree_;
+  // The backend representation of the length.
+  // We only want to compute this once.
+  Bexpression* blength_;
 };
 
 // The type of a map.