From: Iain Buclaw Date: Sat, 18 Jul 2020 15:14:54 +0000 (+0200) Subject: d: Fix associative array literals that don't have alignment holes filled X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=7508a7e958ea06eb311a4a106312634eaf6d40c3;p=gcc.git d: Fix associative array literals that don't have alignment holes filled Associative array literal keys with alignment holes are now filled using memset() prior to usage, with LTR evaluation of side-effects enforced. 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. --- 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 *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 *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 *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 *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]); +}