Hi,
This patch changes the D front-end code generation of index expressions
to use an ARRAY_REF when the array expression is a ARRAY_TYPE.
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.
Bootstrapped and regression tested on x86_64-linux-gnu/-m32/-mx32, and
committed to mainline.
Regards,
Iain.
---
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.
---
gcc/d/d-codegen.cc | 2 +-
gcc/d/d-tree.h | 2 +-
gcc/d/expr.cc | 38 +++++++++++++++++++++++++++++++-------
gcc/d/intrinsics.cc | 4 ++--
4 files changed, 35 insertions(+), 11 deletions(-)
diff --git a/gcc/d/d-codegen.cc b/gcc/d/d-codegen.cc
index 0e14654e56b..3a201149d74 100644
--- 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 751746395e6..a6c38119458 100644
--- 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 fba397bed35..bf750924594 100644
--- 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 4222b8a0290..0f96284473f 100644
--- 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); */
--
2.34.1
