From ba60d5c3d56f2561188e02eb2e33314714781c2f Mon Sep 17 00:00:00 2001 From: Alan Lawrence Date: Fri, 28 Aug 2015 15:04:17 +0000 Subject: [PATCH] Revert: completely_scalarize arrays as well as records gcc/: Revert: 2015-08-27 Alan Lawrence PR tree-optimization/67283 * tree-sra.c (type_consists_of_records_p): Rename to... (scalarizable_type_p): ...this, add case for ARRAY_TYPE. (completely_scalarize_record): Rename to... (completely_scalarize): ...this, add ARRAY_TYPE case, move some code to: (scalarize_elem): New. gcc/testsuite/: Revert: 2015-08-27 Alan Lawrence * gcc.dg/tree-ssa/sra-15.c: New. From-SVN: r227303 --- gcc/ChangeLog | 13 +++ gcc/testsuite/ChangeLog | 6 + gcc/testsuite/gcc.dg/tree-ssa/sra-15.c | 37 ------ gcc/tree-sra.c | 149 ++++++++----------------- 4 files changed, 67 insertions(+), 138 deletions(-) delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/sra-15.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 4419675e78e..09d4a6d96fb 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2015-08-28 Alan Lawrence + + Revert: + 2015-08-27 Alan Lawrence + PR tree-optimization/67283 + * tree-sra.c (type_consists_of_records_p): Rename to... + (scalarizable_type_p): ...this, add case for ARRAY_TYPE. + + (completely_scalarize_record): Rename to... + (completely_scalarize): ...this, add ARRAY_TYPE case, move some + code to: + (scalarize_elem): New. + 2015-08-28 Jiong Wang * config/aarch64/aarch64-protos.h (aarch64_symbol_context): Rename diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index a6f1ce8984e..388417a0d6f 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,9 @@ +2015-08-28 Alan Lawrence + Revert: + 2015-08-27 Alan Lawrence + + * gcc.dg/tree-ssa/sra-15.c: New. + 2015-08-28 Andrew Bennett * gcc.target/mips/madd-8.c: Add lo register to clobber list. diff --git a/gcc/testsuite/gcc.dg/tree-ssa/sra-15.c b/gcc/testsuite/gcc.dg/tree-ssa/sra-15.c deleted file mode 100644 index a22062e32d1..00000000000 --- a/gcc/testsuite/gcc.dg/tree-ssa/sra-15.c +++ /dev/null @@ -1,37 +0,0 @@ -/* Verify that SRA total scalarization works on records containing arrays. */ -/* { dg-do run } */ -/* { dg-options "-O1 -fdump-tree-release_ssa --param sra-max-scalarization-size-Ospeed=32" } */ - -extern void abort (void); - -struct S -{ - char c; - unsigned short f[2][2]; - int i; - unsigned short f3, f4; -}; - - -int __attribute__ ((noinline)) -foo (struct S *p) -{ - struct S l; - - l = *p; - l.i++; - l.f[1][0] += 3; - *p = l; -} - -int -main (int argc, char **argv) -{ - struct S a = {0, { {5, 7}, {9, 11} }, 4, 0, 0}; - foo (&a); - if (a.i != 5 || a.f[1][0] != 12) - abort (); - return 0; -} - -/* { dg-final { scan-tree-dump-times "l;" 0 "release_ssa" } } */ diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 3caf84ae36c..8b3a0adf7cc 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -915,126 +915,73 @@ create_access (tree expr, gimple stmt, bool write) } -/* Return true iff TYPE is scalarizable - i.e. a RECORD_TYPE or ARRAY_TYPE with - fields that are either of gimple register types (excluding bit-fields) - or (recursively) scalarizable types. */ +/* Return true iff TYPE is a RECORD_TYPE with fields that are either of gimple + register types or (recursively) records with only these two kinds of fields. + It also returns false if any of these records contains a bit-field. */ static bool -scalarizable_type_p (tree type) +type_consists_of_records_p (tree type) { - gcc_assert (!is_gimple_reg_type (type)); + tree fld; - switch (TREE_CODE (type)) - { - case RECORD_TYPE: - for (tree fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld)) - if (TREE_CODE (fld) == FIELD_DECL) - { - tree ft = TREE_TYPE (fld); + if (TREE_CODE (type) != RECORD_TYPE) + return false; - if (DECL_BIT_FIELD (fld)) - return false; + for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld)) + if (TREE_CODE (fld) == FIELD_DECL) + { + tree ft = TREE_TYPE (fld); - if (!is_gimple_reg_type (ft) - && !scalarizable_type_p (ft)) - return false; - } + if (DECL_BIT_FIELD (fld)) + return false; - return true; + if (!is_gimple_reg_type (ft) + && !type_consists_of_records_p (ft)) + return false; + } - case ARRAY_TYPE: - { - tree elem = TREE_TYPE (type); - if (DECL_P (elem) && DECL_BIT_FIELD (elem)) - return false; - if (!is_gimple_reg_type (elem) - && !scalarizable_type_p (elem)) - return false; - return true; - } - default: - return false; - } + return true; } -static void scalarize_elem (tree, HOST_WIDE_INT, HOST_WIDE_INT, tree, tree); - -/* Create total_scalarization accesses for all scalar fields of a member - of type DECL_TYPE conforming to scalarizable_type_p. BASE - must be the top-most VAR_DECL representing the variable; within that, - OFFSET locates the member and REF must be the memory reference expression for - the member. */ +/* Create total_scalarization accesses for all scalar type fields in DECL that + must be of a RECORD_TYPE conforming to type_consists_of_records_p. BASE + must be the top-most VAR_DECL representing the variable, OFFSET must be the + offset of DECL within BASE. REF must be the memory reference expression for + the given decl. */ static void -completely_scalarize (tree base, tree decl_type, HOST_WIDE_INT offset, tree ref) +completely_scalarize_record (tree base, tree decl, HOST_WIDE_INT offset, + tree ref) { - switch (TREE_CODE (decl_type)) - { - case RECORD_TYPE: - for (tree fld = TYPE_FIELDS (decl_type); fld; fld = DECL_CHAIN (fld)) - if (TREE_CODE (fld) == FIELD_DECL) - { - HOST_WIDE_INT pos = offset + int_bit_position (fld); - tree ft = TREE_TYPE (fld); - tree nref = build3 (COMPONENT_REF, ft, ref, fld, NULL_TREE); + tree fld, decl_type = TREE_TYPE (decl); - scalarize_elem (base, pos, tree_to_uhwi (DECL_SIZE (fld)), nref, - ft); - } - break; - case ARRAY_TYPE: + for (fld = TYPE_FIELDS (decl_type); fld; fld = DECL_CHAIN (fld)) + if (TREE_CODE (fld) == FIELD_DECL) { - tree elemtype = TREE_TYPE (decl_type); - tree elem_size = TYPE_SIZE (elemtype); - gcc_assert (elem_size && tree_fits_uhwi_p (elem_size)); - int el_size = tree_to_uhwi (elem_size); - gcc_assert (el_size); - - tree minidx = TYPE_MIN_VALUE (TYPE_DOMAIN (decl_type)); - tree maxidx = TYPE_MAX_VALUE (TYPE_DOMAIN (decl_type)); - gcc_assert (TREE_CODE (minidx) == INTEGER_CST - && TREE_CODE (maxidx) == INTEGER_CST); - unsigned HOST_WIDE_INT len = tree_to_uhwi (maxidx) - + 1 - tree_to_uhwi (minidx); - /* 4th operand to ARRAY_REF is size in units of the type alignment. */ - for (unsigned HOST_WIDE_INT idx = 0; idx < len; idx++) + HOST_WIDE_INT pos = offset + int_bit_position (fld); + tree ft = TREE_TYPE (fld); + tree nref = build3 (COMPONENT_REF, TREE_TYPE (fld), ref, fld, + NULL_TREE); + + if (is_gimple_reg_type (ft)) { - tree t_idx = build_int_cst (TYPE_DOMAIN (decl_type), idx); - tree nref = build4 (ARRAY_REF, elemtype, ref, t_idx, NULL_TREE, - NULL_TREE); - int el_off = offset + idx * el_size; - scalarize_elem (base, el_off, el_size, nref, elemtype); + struct access *access; + HOST_WIDE_INT size; + + size = tree_to_uhwi (DECL_SIZE (fld)); + access = create_access_1 (base, pos, size); + access->expr = nref; + access->type = ft; + access->grp_total_scalarization = 1; + /* Accesses for intraprocedural SRA can have their stmt NULL. */ } + else + completely_scalarize_record (base, fld, pos, nref); } - break; - default: - gcc_unreachable (); - } -} - -/* Create total_scalarization accesses for a member of type TYPE, which must - satisfy either is_gimple_reg_type or scalarizable_type_p. BASE must be the - top-most VAR_DECL representing the variable; within that, POS and SIZE locate - the member and REF must be the reference expression for it. */ - -static void -scalarize_elem (tree base, HOST_WIDE_INT pos, HOST_WIDE_INT size, - tree ref, tree type) -{ - if (is_gimple_reg_type (type)) - { - struct access *access = create_access_1 (base, pos, size); - access->expr = ref; - access->type = type; - access->grp_total_scalarization = 1; - /* Accesses for intraprocedural SRA can have their stmt NULL. */ - } - else - completely_scalarize (base, type, pos, ref); } /* Create a total_scalarization access for VAR as a whole. VAR must be of a - RECORD_TYPE or ARRAY_TYPE conforming to scalarizable_type_p. */ + RECORD_TYPE conforming to type_consists_of_records_p. */ static void create_total_scalarization_access (tree var) @@ -2574,13 +2521,13 @@ analyze_all_variable_accesses (void) tree var = candidate (i); if (TREE_CODE (var) == VAR_DECL - && scalarizable_type_p (TREE_TYPE (var))) + && type_consists_of_records_p (TREE_TYPE (var))) { if (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (var))) <= max_scalarization_size) { create_total_scalarization_access (var); - completely_scalarize (var, TREE_TYPE (var), 0, var); + completely_scalarize_record (var, var, 0, var); if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Will attempt to totally scalarize "); -- 2.30.2