d: Construct indexes of ARRAY_TYPE using ARRAY_REF.

This is a small simplification over `((T *)&array)[index]', which also
allows eliding an unneccesary marking of TREE_ADDRESSABLE when the array
expression is a parameter or variable declaration.

gcc/d/ChangeLog:

	* d-codegen.cc (build_array_index): Rename to...
	(build_pointer_index): ...this.
	* d-tree.h (build_array_index): Rename declaration to...
	(build_pointer_index): ...this.
	* expr.cc (ExprVisitor::visit (IndexExp *)): Construct indexes of
	ARRAY_TYPE using ARRAY_REF.
	(ExprVisitor::visit (SliceExp *)): Update.
	* intrinsics.cc (expand_intrinsic_bt): Update.

diff --git a/gcc/d/d-codegen.cc b/gcc/d/d-codegen.cc
index 0e14654e56b8af8b89d1b83f49747a529ff046a0..3a201149d7464e4f3e98c3ca069c85ca619cd2cd 100644 (file)
--- a/gcc/d/d-codegen.cc
+++ b/gcc/d/d-codegen.cc
@@ -1626,7 +1626,7 @@ build_deref (tree exp)
 /* Builds pointer offset expression PTR[INDEX].  */
 
 tree
-build_array_index (tree ptr, tree index)
+build_pointer_index (tree ptr, tree index)
 {
   if (error_operand_p (ptr) || error_operand_p (index))
     return error_mark_node;

diff --git a/gcc/d/d-tree.h b/gcc/d/d-tree.h
index 751746395e6cfc1fa13914d85a107fa651b8dc1f..a6c381194589e77507ad0a3ad6e578013787b067 100644 (file)
--- a/gcc/d/d-tree.h
+++ b/gcc/d/d-tree.h
@@ -578,7 +578,7 @@ extern tree imaginary_part (tree);
 extern tree complex_expr (tree, tree, tree);
 extern tree indirect_ref (tree, tree);
 extern tree build_deref (tree);
-extern tree build_array_index (tree, tree);
+extern tree build_pointer_index (tree, tree);
 extern tree build_offset_op (tree_code, tree, tree);
 extern tree build_offset (tree, tree);
 extern tree build_memref (tree, tree, tree);

diff --git a/gcc/d/expr.cc b/gcc/d/expr.cc
index fba397bed35a92ed1b82e62ff84738ef2edef3ac..bf750924594509b541c2002953fc027b7564c162 100644 (file)
--- a/gcc/d/expr.cc
+++ b/gcc/d/expr.cc
@@ -1222,9 +1222,8 @@ public:
       }
     else
       {
-       /* Get the data pointer and length for static and dynamic arrays.  */
+       /* Get the array and length for static and dynamic arrays.  */
        tree array = d_save_expr (build_expr (e->e1));
-       tree ptr = convert_expr (array, tb1, tb1->nextOf ()->pointerTo ());
 
        tree length = NULL_TREE;
        if (tb1->ty != TY::Tpointer)
@@ -1245,10 +1244,35 @@ public:
        if (tb1->ty != TY::Tpointer)
          index = build_bounds_index_condition (e, index, length);
 
-       /* Index the .ptr.  */
-       ptr = void_okay_p (ptr);
-       this->result_ = indirect_ref (TREE_TYPE (TREE_TYPE (ptr)),
-                                     build_array_index (ptr, index));
+       /* Convert vectors to their underlying array type.  */
+       if (VECTOR_TYPE_P (TREE_TYPE (array)))
+         {
+           tree array_type =
+             build_array_type_nelts (TREE_TYPE (TREE_TYPE (array)),
+                                     TYPE_VECTOR_SUBPARTS (TREE_TYPE (array)));
+           d_mark_addressable (array);
+           array = build1 (VIEW_CONVERT_EXPR, array_type, array);
+         }
+
+       if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
+         {
+           /* Generate `array[index]'.  When the index is non-constant, we must
+              mark the array as addressable because we'll need to do pointer
+              arithmetic on its address.  */
+           if (TREE_CODE (index) != INTEGER_CST)
+             d_mark_addressable (array);
+
+           this->result_ = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (array)),
+                                   array, index, NULL_TREE, NULL_TREE);
+         }
+       else
+         {
+           /* Generate `array.ptr[index]'.  */
+           tree ptr = convert_expr (array, tb1, tb1->nextOf ()->pointerTo ());
+           ptr = void_okay_p (ptr);
+           this->result_ = indirect_ref (TREE_TYPE (TREE_TYPE (ptr)),
+                                         build_pointer_index (ptr, index));
+         }
       }
   }
 
@@ -1347,7 +1371,7 @@ public:
     if (!integer_zerop (lwr_tree))
       {
        tree ptrtype = TREE_TYPE (ptr);
-       ptr = build_array_index (void_okay_p (ptr), lwr_tree);
+       ptr = build_pointer_index (void_okay_p (ptr), lwr_tree);
        ptr = build_nop (ptrtype, ptr);
       }
 

diff --git a/gcc/d/intrinsics.cc b/gcc/d/intrinsics.cc
index 4222b8a0290ded4feb9ada013200832bee6187e9..0f96284473fcf8a08fc6e768048b090c840acce0 100644 (file)
--- a/gcc/d/intrinsics.cc
+++ b/gcc/d/intrinsics.cc
@@ -306,8 +306,8 @@ expand_intrinsic_bt (intrinsic_code intrinsic, tree callexp)
   tree bitsize = fold_convert (type, TYPE_SIZE (TREE_TYPE (ptr)));
 
   /* ptr[bitnum / bitsize]  */
-  ptr = build_array_index (ptr, fold_build2 (TRUNC_DIV_EXPR, type,
-                                            bitnum, bitsize));
+  ptr = build_pointer_index (ptr, fold_build2 (TRUNC_DIV_EXPR, type,
+                                              bitnum, bitsize));
   ptr = indirect_ref (type, ptr);
 
   /* mask = 1 << (bitnum % bitsize);  */