[committed] d: Fix associative array literals that don't have alignment holes filled (PR96152)
Iain Buclaw
ibuclaw@gdcproject.org
Thu Jul 30 21:46:01 GMT 2020
Hi,
This patch fixes an assert that is triggered at run-time due to the hash
of an associative array literal not matching a non-literal with the same
contents. Associative array literals are now filled using memset()
prior to usage, with LTR evalution of side-effects enforced.
Bootstrapped and regression tested on x86_64-linux-gnu, committed to
mainline.
Regards
Iain.
---
gcc/d/ChangeLog:
PR d/96152
* d-codegen.cc (build_array_from_exprs): New function.
* d-tree.h (build_array_from_exprs): Declare.
* expr.cc (ExprVisitor::visit (AssocArrayLiteralExp *)): Use
build_array_from_exprs to generate key and value arrays.
gcc/testsuite/ChangeLog:
PR d/96152
* gdc.dg/pr96152.d: New test.
---
gcc/d/d-codegen.cc | 36 ++++++++++++++++++++++++++++++++++
gcc/d/d-tree.h | 1 +
gcc/d/expr.cc | 33 +++++++++----------------------
gcc/testsuite/gdc.dg/pr96152.d | 32 ++++++++++++++++++++++++++++++
4 files changed, 78 insertions(+), 24 deletions(-)
create mode 100644 gcc/testsuite/gdc.dg/pr96152.d
diff --git a/gcc/d/d-codegen.cc b/gcc/d/d-codegen.cc
index a38aa6c55e0..2dce09d7187 100644
--- a/gcc/d/d-codegen.cc
+++ b/gcc/d/d-codegen.cc
@@ -1722,6 +1722,42 @@ build_array_from_val (Type *type, tree val)
return build_constructor (build_ctype (type), elms);
}
+/* Build a static array of type TYPE from an array of EXPS.
+ If CONST_P is true, then all elements in EXPS are constants. */
+
+tree
+build_array_from_exprs (Type *type, Expressions *exps, bool const_p)
+{
+ /* Build a CONSTRUCTOR from all expressions. */
+ vec <constructor_elt, va_gc> *elms = NULL;
+ vec_safe_reserve (elms, exps->length);
+
+ Type *etype = type->nextOf ();
+ tree satype = make_array_type (etype, exps->length);
+
+ for (size_t i = 0; i < exps->length; i++)
+ {
+ Expression *expr = (*exps)[i];
+ tree t = build_expr (expr, const_p);
+ CONSTRUCTOR_APPEND_ELT (elms, size_int (i),
+ convert_expr (t, expr->type, etype));
+ }
+
+ /* Create a new temporary to store the array. */
+ tree var = build_local_temp (satype);
+
+ /* Fill any alignment holes with zeroes. */
+ TypeStruct *ts = etype->baseElemOf ()->isTypeStruct ();
+ tree init = NULL;
+ if (ts && (!identity_compare_p (ts->sym) || ts->sym->isUnionDeclaration ()))
+ init = build_memset_call (var);
+
+ /* Initialize the temporary. */
+ tree assign = modify_expr (var, build_constructor (satype, elms));
+ return compound_expr (compound_expr (init, assign), var);
+}
+
+
/* Implicitly converts void* T to byte* as D allows { void[] a; &a[3]; } */
tree
diff --git a/gcc/d/d-tree.h b/gcc/d/d-tree.h
index 48c8ef09dd1..df317d557eb 100644
--- a/gcc/d/d-tree.h
+++ b/gcc/d/d-tree.h
@@ -562,6 +562,7 @@ extern tree build_offset (tree, tree);
extern tree build_memref (tree, tree, tree);
extern tree build_array_set (tree, tree, tree);
extern tree build_array_from_val (Type *, tree);
+extern tree build_array_from_exprs (Type *, Expressions *, bool);
extern tree void_okay_p (tree);
extern tree build_array_bounds_call (const Loc &);
extern tree build_bounds_condition (const Loc &, tree, tree, bool);
diff --git a/gcc/d/expr.cc b/gcc/d/expr.cc
index 355561a481e..20ab49d7b8c 100644
--- a/gcc/d/expr.cc
+++ b/gcc/d/expr.cc
@@ -2799,30 +2799,14 @@ public:
/* Build an expression that assigns all expressions in KEYS
to a constructor. */
- vec <constructor_elt, va_gc> *kelts = NULL;
- vec_safe_reserve (kelts, e->keys->length);
- for (size_t i = 0; i < e->keys->length; i++)
- {
- Expression *key = (*e->keys)[i];
- tree t = build_expr (key);
- CONSTRUCTOR_APPEND_ELT (kelts, size_int (i),
- convert_expr (t, key->type, ta->index));
- }
- tree tkeys = make_array_type (ta->index, e->keys->length);
- tree akeys = build_constructor (tkeys, kelts);
+ tree akeys = build_array_from_exprs (ta->index->sarrayOf (e->keys->length),
+ e->keys, this->constp_);
+ tree init = stabilize_expr (&akeys);
/* Do the same with all expressions in VALUES. */
- vec <constructor_elt, va_gc> *velts = NULL;
- vec_safe_reserve (velts, e->values->length);
- for (size_t i = 0; i < e->values->length; i++)
- {
- Expression *value = (*e->values)[i];
- tree t = build_expr (value);
- CONSTRUCTOR_APPEND_ELT (velts, size_int (i),
- convert_expr (t, value->type, ta->next));
- }
- tree tvals = make_array_type (ta->next, e->values->length);
- tree avals = build_constructor (tvals, velts);
+ tree avals = build_array_from_exprs (ta->next->sarrayOf (e->values->length),
+ e->values, this->constp_);
+ init = compound_expr (init, stabilize_expr (&avals));
/* Generate: _d_assocarrayliteralTX (ti, keys, vals); */
tree keys = d_array_value (build_ctype (ta->index->arrayOf ()),
@@ -2840,8 +2824,9 @@ public:
vec <constructor_elt, va_gc> *ce = NULL;
CONSTRUCTOR_APPEND_ELT (ce, TYPE_FIELDS (aatype), mem);
- this->result_ = build_nop (build_ctype (e->type),
- build_constructor (aatype, ce));
+ tree result = build_nop (build_ctype (e->type),
+ build_constructor (aatype, ce));
+ this->result_ = compound_expr (init, result);
}
/* Build a struct literal. */
diff --git a/gcc/testsuite/gdc.dg/pr96152.d b/gcc/testsuite/gdc.dg/pr96152.d
new file mode 100644
index 00000000000..3551614654b
--- /dev/null
+++ b/gcc/testsuite/gdc.dg/pr96152.d
@@ -0,0 +1,32 @@
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96152
+// { dg-additional-options "-fmain -funittest" }
+// { dg-do run { target hw } }
+// { dg-skip-if "needs gcc/config.d" { ! d_runtime } }
+auto assocArray(Keys, Values)(Keys keys, Values values)
+{
+ void* aa;
+ {
+ if (values.length > keys.length)
+ values = values[0 .. keys.length];
+ else if (keys.length > values.length)
+ keys = keys[0 .. values.length];
+ aa = aaLiteral(keys, values);
+ }
+ alias Key = typeof(keys[0]);
+ alias Value = typeof(values[0]);
+ return (() @trusted => cast(Value[Key]) aa)();
+}
+
+@safe unittest
+{
+ struct ThrowingElement
+ {
+ int i;
+ static bool b;
+ ~this(){
+ if (b)
+ throw new Exception("");
+ }
+ }
+ assert(assocArray([ThrowingElement()], [0]) == [ThrowingElement(): 0]);
+}
--
2.25.1
More information about the Gcc-patches
mailing list