From 63828598f16b978ef91ea80730b8c13a698bfbb0 Mon Sep 17 00:00:00 2001 From: Mingchuan Wu Date: Wed, 29 Nov 2023 20:20:05 +0800 Subject: [PATCH] [Sync] Sync patch from openeuler/gcc --- ...-compiler-error-with-fipa-struct-reo.patch | 52 ++++ ...c-Tweak-build_replicated_const-PR949.patch | 82 ++++++ ...eric-Fix-bitfield-widths-PR94980-3-3.patch | 82 ++++++ ...EC_COND_EXPR-into-internal-functions.patch | 88 ++++++ 0127-Add-missing-check-for-gassign.patch | 35 +++ ...syntax-with-force-simplified-results.patch | 116 ++++++++ ...ansform-failure-handling-more-consis.patch | 162 ++++++++++ 0130-VEC_COND_EXPR-optimizations.patch | 184 ++++++++++++ ...ch64-Remove-XFAILs-for-two-SVE-tests.patch | 48 +++ ...-pr99305.C-test-on-unsigned_char-tar.patch | 39 +++ 0133-match.pd-Fix-sve-vcond_3.c.patch | 43 +++ ...mit-some-a-CST1-CST2-optimizations-t.patch | 65 +++++ ...n-PR102622-wrong-code-due-to-signed-.patch | 94 ++++++ ...ation-103152-Still-one-more-signed1b.patch | 66 +++++ ...ed-struct-function-pointer-eliminati.patch | 117 ++++++++ ...transpose-test-cases-with-vector-ind.patch | 25 ++ ...on-testsuite-c-c-tests-and-505.mcf_r.patch | 276 ++++++++++++++++++ ...or-in-memory-allocation-deallocation.patch | 53 ++++ ...arnings-and-errors-with-debug-prints.patch | 153 ++++++++++ gcc.spec | 46 ++- 20 files changed, 1825 insertions(+), 1 deletion(-) create mode 100644 0123-DFE-Fix-internal-compiler-error-with-fipa-struct-reo.patch create mode 100644 0124-tree-vect-generic-Tweak-build_replicated_const-PR949.patch create mode 100644 0125-tree-vect-generic-Fix-bitfield-widths-PR94980-3-3.patch create mode 100644 0126-Lower-VEC_COND_EXPR-into-internal-functions.patch create mode 100644 0127-Add-missing-check-for-gassign.patch create mode 100644 0128-Amend-match.pd-syntax-with-force-simplified-results.patch create mode 100644 0129-Make-genmatch-transform-failure-handling-more-consis.patch create mode 100644 0130-VEC_COND_EXPR-optimizations.patch create mode 100644 0131-aarch64-Remove-XFAILs-for-two-SVE-tests.patch create mode 100644 0132-testsuite-Fix-up-pr99305.C-test-on-unsigned_char-tar.patch create mode 100644 0133-match.pd-Fix-sve-vcond_3.c.patch create mode 100644 0134-Fix-PR-100925-Limit-some-a-CST1-CST2-optimizations-t.patch create mode 100644 0135-tree-optimization-PR102622-wrong-code-due-to-signed-.patch create mode 100644 0136-Fix-tree-optimization-103152-Still-one-more-signed1b.patch create mode 100644 0137-DFE-Fix-unexpected-struct-function-pointer-eliminati.patch create mode 100644 0138-Fix-ICE-bugs-in-transpose-test-cases-with-vector-ind.patch create mode 100644 0139-Fix-errors-on-testsuite-c-c-tests-and-505.mcf_r.patch create mode 100644 0140-Fix-an-error-in-memory-allocation-deallocation.patch create mode 100644 0141-Fix-warnings-and-errors-with-debug-prints.patch diff --git a/0123-DFE-Fix-internal-compiler-error-with-fipa-struct-reo.patch b/0123-DFE-Fix-internal-compiler-error-with-fipa-struct-reo.patch new file mode 100644 index 0000000..34a9cd9 --- /dev/null +++ b/0123-DFE-Fix-internal-compiler-error-with-fipa-struct-reo.patch @@ -0,0 +1,52 @@ +From 41af6d361a6d85ef4fce8a8438113d765596afdd Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?=E9=83=91=E6=99=A8=E5=8D=89?= +Date: Thu, 12 Oct 2023 10:19:29 +0800 +Subject: [PATCH 08/26] [DFE]Fix internal compiler error with + -fipa-struct-reorg=3. + +--- + gcc/ipa-struct-reorg/ipa-struct-reorg.c | 14 +++++++++++--- + gcc/testsuite/gcc.dg/struct/struct-reorg.exp | 2 ++ + 2 files changed, 13 insertions(+), 3 deletions(-) + +diff --git a/gcc/ipa-struct-reorg/ipa-struct-reorg.c b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +index 367bcf210..53d026386 100644 +--- a/gcc/ipa-struct-reorg/ipa-struct-reorg.c ++++ b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +@@ -3991,9 +3991,17 @@ ipa_struct_reorg::maybe_mark_or_record_other_side (tree side, tree other, gimple + if (VOID_POINTER_P (TREE_TYPE (side)) + && TREE_CODE (side) == SSA_NAME) + { +- /* The type is other, the declaration is side. */ +- current_function->record_decl (type, side, -1, +- isptrptr (TREE_TYPE (other)) ? TREE_TYPE (other) : NULL); ++ tree inner = SSA_NAME_VAR (side); ++ if (inner) ++ { ++ srdecl *in = find_decl (inner); ++ if (in && !in->type->has_escaped ()) ++ { ++ /* The type is other, the declaration is side. */ ++ current_function->record_decl (type, side, -1, ++ isptrptr (TREE_TYPE (other)) ? TREE_TYPE (other) : NULL); ++ } ++ } + } + else + { +diff --git a/gcc/testsuite/gcc.dg/struct/struct-reorg.exp b/gcc/testsuite/gcc.dg/struct/struct-reorg.exp +index 281046b48..107f990f5 100644 +--- a/gcc/testsuite/gcc.dg/struct/struct-reorg.exp ++++ b/gcc/testsuite/gcc.dg/struct/struct-reorg.exp +@@ -84,6 +84,8 @@ gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/rf*.c]] \ + # -fipa-struct-reorg=3 + gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/dfe*.c]] \ + "" "-fipa-struct-reorg=3 -fdump-ipa-all -flto-partition=one -fwhole-program" ++gcc-dg-runtest $srcdir/$subdir/struct_reorg-7.c \ ++ "" "-fipa-struct-reorg=3 -fdump-ipa-all -flto-partition=one -fwhole-program" + + # -fipa-struct-reorg=4 + gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/pc*.c]] \ +-- +2.27.0 + diff --git a/0124-tree-vect-generic-Tweak-build_replicated_const-PR949.patch b/0124-tree-vect-generic-Tweak-build_replicated_const-PR949.patch new file mode 100644 index 0000000..539abd8 --- /dev/null +++ b/0124-tree-vect-generic-Tweak-build_replicated_const-PR949.patch @@ -0,0 +1,82 @@ +From 364cff1c26b9d1ef017e4bd2b080e1ca53f14694 Mon Sep 17 00:00:00 2001 +From: Richard Sandiford +Date: Tue, 12 May 2020 09:01:12 +0100 +Subject: [PATCH 09/26] tree-vect-generic: Tweak build_replicated_const + [PR94980 2/3] + +This patch makes build_replicated_const take the number of bits +in VALUE rather than calculating the width from the element type. +The callers can then use vector_element_bits to calculate the +correct element size from the vector type. + +2020-05-12 Richard Sandiford + +gcc/ + PR tree-optimization/94980 + * tree-vect-generic.c (build_replicated_const): Take the number + of bits as a parameter, instead of the type of the elements. + (do_plus_minus): Update accordingly, using vector_element_bits + to calculate the correct number of bits. + (do_negate): Likewise. + +Reference commit in GCC: 14605b6bd8c37fffd8065c5c3fe6b1b9d7b2a294 +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/tree-vect-generic.c | 15 ++++++++------- + 1 file changed, 8 insertions(+), 7 deletions(-) + +diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c +index 0ec4412bc..82fb0ae7c 100644 +--- a/gcc/tree-vect-generic.c ++++ b/gcc/tree-vect-generic.c +@@ -67,11 +67,10 @@ subparts_gt (tree type1, tree type2) + } + + /* Build a constant of type TYPE, made of VALUE's bits replicated +- every TYPE_SIZE (INNER_TYPE) bits to fit TYPE's precision. */ ++ every WIDTH bits to fit TYPE's precision. */ + static tree +-build_replicated_const (tree type, tree inner_type, HOST_WIDE_INT value) ++build_replicated_const (tree type, unsigned int width, HOST_WIDE_INT value) + { +- int width = tree_to_uhwi (TYPE_SIZE (inner_type)); + int n = (TYPE_PRECISION (type) + HOST_BITS_PER_WIDE_INT - 1) + / HOST_BITS_PER_WIDE_INT; + unsigned HOST_WIDE_INT low, mask; +@@ -214,13 +213,14 @@ do_plus_minus (gimple_stmt_iterator *gsi, tree word_type, tree a, tree b, + tree bitpos ATTRIBUTE_UNUSED, tree bitsize ATTRIBUTE_UNUSED, + enum tree_code code, tree type ATTRIBUTE_UNUSED) + { ++ unsigned int width = vector_element_bits (TREE_TYPE (a)); + tree inner_type = TREE_TYPE (TREE_TYPE (a)); + unsigned HOST_WIDE_INT max; + tree low_bits, high_bits, a_low, b_low, result_low, signs; + + max = GET_MODE_MASK (TYPE_MODE (inner_type)); +- low_bits = build_replicated_const (word_type, inner_type, max >> 1); +- high_bits = build_replicated_const (word_type, inner_type, max & ~(max >> 1)); ++ low_bits = build_replicated_const (word_type, width, max >> 1); ++ high_bits = build_replicated_const (word_type, width, max & ~(max >> 1)); + + a = tree_vec_extract (gsi, word_type, a, bitsize, bitpos); + b = tree_vec_extract (gsi, word_type, b, bitsize, bitpos); +@@ -247,13 +247,14 @@ do_negate (gimple_stmt_iterator *gsi, tree word_type, tree b, + enum tree_code code ATTRIBUTE_UNUSED, + tree type ATTRIBUTE_UNUSED) + { ++ unsigned int width = vector_element_bits (TREE_TYPE (b)); + tree inner_type = TREE_TYPE (TREE_TYPE (b)); + HOST_WIDE_INT max; + tree low_bits, high_bits, b_low, result_low, signs; + + max = GET_MODE_MASK (TYPE_MODE (inner_type)); +- low_bits = build_replicated_const (word_type, inner_type, max >> 1); +- high_bits = build_replicated_const (word_type, inner_type, max & ~(max >> 1)); ++ low_bits = build_replicated_const (word_type, width, max >> 1); ++ high_bits = build_replicated_const (word_type, width, max & ~(max >> 1)); + + b = tree_vec_extract (gsi, word_type, b, bitsize, bitpos); + +-- +2.27.0 + diff --git a/0125-tree-vect-generic-Fix-bitfield-widths-PR94980-3-3.patch b/0125-tree-vect-generic-Fix-bitfield-widths-PR94980-3-3.patch new file mode 100644 index 0000000..80fc0fe --- /dev/null +++ b/0125-tree-vect-generic-Fix-bitfield-widths-PR94980-3-3.patch @@ -0,0 +1,82 @@ +From fe61a1c365661a717220d0917e034899559aafbb Mon Sep 17 00:00:00 2001 +From: Richard Sandiford +Date: Tue, 12 May 2020 09:01:13 +0100 +Subject: [PATCH 10/26] tree-vect-generic: Fix bitfield widths [PR94980 3/3] + +This third patch of three actually fixes the PR. We were using +8-bit BIT_FIELD_REFs to access single-bit elements, and multiplying +the vector index by 8 bits rather than 1 bit. + +2020-05-12 Richard Sandiford + +gcc/ + PR tree-optimization/94980 + * tree-vect-generic.c (expand_vector_comparison): Use + vector_element_bits_tree to get the element size in bits, + rather than using TYPE_SIZE. + (expand_vector_condition, vector_element): Likewise. + +gcc/testsuite/ + PR tree-optimization/94980 + * gcc.target/i386/pr94980.c: New test. + +Reference commit in GCC: 4c0283b9ad75b128b79c507d78d678123fe9f471 +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/testsuite/gcc.target/i386/pr94980.c | 10 ++++++++++ + gcc/tree-vect-generic.c | 6 +++--- + 2 files changed, 13 insertions(+), 3 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/i386/pr94980.c + +diff --git a/gcc/testsuite/gcc.target/i386/pr94980.c b/gcc/testsuite/gcc.target/i386/pr94980.c +new file mode 100644 +index 000000000..488f94abe +--- /dev/null ++++ b/gcc/testsuite/gcc.target/i386/pr94980.c +@@ -0,0 +1,10 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mavx512vl" } */ ++ ++int __attribute__((__vector_size__(16))) v; ++ ++void ++foo(void) ++{ ++ 0 <= (0 != v) >= 0; ++} +diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c +index 82fb0ae7c..f0c28c97a 100644 +--- a/gcc/tree-vect-generic.c ++++ b/gcc/tree-vect-generic.c +@@ -390,7 +390,7 @@ expand_vector_comparison (gimple_stmt_iterator *gsi, tree type, tree op0, + (TREE_TYPE (type))))) + { + tree inner_type = TREE_TYPE (TREE_TYPE (op0)); +- tree part_width = TYPE_SIZE (inner_type); ++ tree part_width = vector_element_bits_tree (TREE_TYPE (op0)); + tree index = bitsize_int (0); + int nunits = nunits_for_known_piecewise_op (TREE_TYPE (op0)); + int prec = GET_MODE_PRECISION (SCALAR_TYPE_MODE (type)); +@@ -946,9 +946,9 @@ expand_vector_condition (gimple_stmt_iterator *gsi) + vec *v; + tree constr; + tree inner_type = TREE_TYPE (type); ++ tree width = vector_element_bits_tree (type); + tree cond_type = TREE_TYPE (TREE_TYPE (a)); + tree comp_inner_type = cond_type; +- tree width = TYPE_SIZE (inner_type); + tree index = bitsize_int (0); + tree comp_width = width; + tree comp_index = index; +@@ -1342,7 +1342,7 @@ vector_element (gimple_stmt_iterator *gsi, tree vect, tree idx, tree *ptmpvec) + } + else + { +- tree size = TYPE_SIZE (vect_elt_type); ++ tree size = vector_element_bits_tree (vect_type); + tree pos = fold_build2 (MULT_EXPR, bitsizetype, bitsize_int (index), + size); + return fold_build3 (BIT_FIELD_REF, vect_elt_type, vect, size, pos); +-- +2.27.0 + diff --git a/0126-Lower-VEC_COND_EXPR-into-internal-functions.patch b/0126-Lower-VEC_COND_EXPR-into-internal-functions.patch new file mode 100644 index 0000000..c278759 --- /dev/null +++ b/0126-Lower-VEC_COND_EXPR-into-internal-functions.patch @@ -0,0 +1,88 @@ +From 189fe23d846e3e701d1fba7605b96ee3b07799a3 Mon Sep 17 00:00:00 2001 +From: Martin Liska +Date: Mon, 9 Mar 2020 13:23:03 +0100 +Subject: [PATCH 11/26] Lower VEC_COND_EXPR into internal functions. + +gcc/ChangeLog: + + * Makefile.in: Add new file. + * expr.c (expand_expr_real_2): Add gcc_unreachable as we should + not meet this condition. + (do_store_flag): Likewise. + * gimplify.c (gimplify_expr): Gimplify first argument of + VEC_COND_EXPR to be a SSA name. + * internal-fn.c (vec_cond_mask_direct): New. + (vec_cond_direct): Likewise. + (vec_condu_direct): Likewise. + (vec_condeq_direct): Likewise. + (expand_vect_cond_optab_fn): New. + (expand_vec_cond_optab_fn): Likewise. + (expand_vec_condu_optab_fn): Likewise. + (expand_vec_condeq_optab_fn): Likewise. + (expand_vect_cond_mask_optab_fn): Likewise. + (expand_vec_cond_mask_optab_fn): Likewise. + (direct_vec_cond_mask_optab_supported_p): Likewise. + (direct_vec_cond_optab_supported_p): Likewise. + (direct_vec_condu_optab_supported_p): Likewise. + (direct_vec_condeq_optab_supported_p): Likewise. + * internal-fn.def (VCOND): New OPTAB. + (VCONDU): Likewise. + (VCONDEQ): Likewise. + (VCOND_MASK): Likewise. + * optabs.c (get_rtx_code): Make it global. + (expand_vec_cond_mask_expr): Removed. + (expand_vec_cond_expr): Removed. + * optabs.h (expand_vec_cond_expr): Likewise. + (vector_compare_rtx): Make it global. + * passes.def: Add new pass_gimple_isel pass. + * tree-cfg.c (verify_gimple_assign_ternary): Add check + for VEC_COND_EXPR about first argument. + * tree-pass.h (make_pass_gimple_isel): New. + * tree-ssa-forwprop.c (pass_forwprop::execute): Prevent + propagation of the first argument of a VEC_COND_EXPR. + * tree-ssa-reassoc.c (ovce_extract_ops): Support SSA_NAME as + first argument of a VEC_COND_EXPR. + (optimize_vec_cond_expr): Likewise. + * tree-vect-generic.c (expand_vector_divmod): Make SSA_NAME + for a first argument of created VEC_COND_EXPR. + (expand_vector_condition): Fix coding style. + * tree-vect-stmts.c (vectorizable_condition): Gimplify + first argument. + * gimple-isel.cc: New file. + +gcc/testsuite/ChangeLog: + + * g++.dg/vect/vec-cond-expr-eh.C: New test. + +Reference commit in GCC: 502d63b6d6141597bb18fd23c87736a1b384cf8f +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/tree-vect-stmts.c | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c +index 98b233718..0e1c86af6 100644 +--- a/gcc/tree-vect-stmts.c ++++ b/gcc/tree-vect-stmts.c +@@ -11281,12 +11281,12 @@ vectorizable_condition (stmt_vec_info stmt_info, gimple_stmt_iterator *gsi, + { + vec_cond_rhs = vec_oprnds1[i]; + if (bitop1 == NOP_EXPR) +- { +- gimple_seq stmts = NULL; +- vec_compare = gimple_build (&stmts, cond_code, vec_cmp_type, +- vec_cond_lhs, vec_cond_rhs); +- gsi_insert_before (gsi, stmts, GSI_SAME_STMT); +- } ++ { ++ gimple_seq stmts = NULL; ++ vec_compare = gimple_build (&stmts, cond_code, vec_cmp_type, ++ vec_cond_lhs, vec_cond_rhs); ++ gsi_insert_before (gsi, stmts, GSI_SAME_STMT); ++ } + else + { + new_temp = make_ssa_name (vec_cmp_type); +-- +2.27.0 + diff --git a/0127-Add-missing-check-for-gassign.patch b/0127-Add-missing-check-for-gassign.patch new file mode 100644 index 0000000..c15fd93 --- /dev/null +++ b/0127-Add-missing-check-for-gassign.patch @@ -0,0 +1,35 @@ +From fee3fcbaa008eef0efe59e1e9eff9cc4e4767423 Mon Sep 17 00:00:00 2001 +From: Martin Liska +Date: Thu, 18 Jun 2020 09:11:31 +0200 +Subject: [PATCH 12/26] Add missing check for gassign. + +gcc/ChangeLog: + + * tree-vect-generic.c (expand_vector_condition): Check + for gassign before inspecting RHS. + +Reference commit in GCC: d11c9841d54ed74978f8d0e0f352631f90504dd5 +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/tree-vect-generic.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c +index f0c28c97a..f6b8287e5 100644 +--- a/gcc/tree-vect-generic.c ++++ b/gcc/tree-vect-generic.c +@@ -957,8 +957,9 @@ expand_vector_condition (gimple_stmt_iterator *gsi) + + if (code == SSA_NAME) + { +- gimple *assign = SSA_NAME_DEF_STMT (a); +- if (TREE_CODE_CLASS (gimple_assign_rhs_code (assign)) == tcc_comparison) ++ gassign *assign = dyn_cast (SSA_NAME_DEF_STMT (a)); ++ if (assign != NULL ++ && TREE_CODE_CLASS (gimple_assign_rhs_code (assign)) == tcc_comparison) + { + a_is_comparison = true; + a1 = gimple_assign_rhs1 (assign); +-- +2.27.0 + diff --git a/0128-Amend-match.pd-syntax-with-force-simplified-results.patch b/0128-Amend-match.pd-syntax-with-force-simplified-results.patch new file mode 100644 index 0000000..8e8f171 --- /dev/null +++ b/0128-Amend-match.pd-syntax-with-force-simplified-results.patch @@ -0,0 +1,116 @@ +From 2500488013903f9960fab8b49606e5d380435662 Mon Sep 17 00:00:00 2001 +From: Richard Biener +Date: Fri, 31 Jul 2020 14:24:26 +0200 +Subject: [PATCH 13/26] Amend match.pd syntax with force-simplified results + +This adds a ! marker to result expressions that should simplify +(and if not fail the simplification). This can for example be +used like + +(simplify + (plus (vec_cond:s @0 @1 @2) @3) + (vec_cond @0 (plus! @1 @3) (plus! @2 @3))) + +to make the simplification only apply in case both plus operations +in the result end up simplified to a simple operand. + +2020-07-31 Richard Biener + + * genmatch.c (expr::force_leaf): Add and initialize. + (expr::gen_transform): Honor force_leaf by passing + NULL as sequence argument to maybe_push_res_to_seq. + (parser::parse_expr): Allow ! marker on result expression + operations. + * doc/match-and-simplify.texi: Amend. + +Reference commit in GCC: 14c35be3bf493859b92c3c6ca7893075212169ab +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/doc/match-and-simplify.texi | 15 +++++++++++++++ + gcc/genmatch.c | 19 ++++++++++++++++--- + 2 files changed, 31 insertions(+), 3 deletions(-) + +diff --git a/gcc/doc/match-and-simplify.texi b/gcc/doc/match-and-simplify.texi +index 1df8b90e7..41980acbf 100644 +--- a/gcc/doc/match-and-simplify.texi ++++ b/gcc/doc/match-and-simplify.texi +@@ -361,6 +361,21 @@ Usually the types of the generated result expressions are + determined from the context, but sometimes like in the above case + it is required that you specify them explicitely. + ++Another modifier for generated expressions is @code{!} which ++tells the machinery to only consider the simplification in case ++the marked expression simplified to a simple operand. Consider ++for example ++ ++@smallexample ++(simplify ++ (plus (vec_cond:s @@0 @@1 @@2) @@3) ++ (vec_cond @@0 (plus! @@1 @@3) (plus! @@2 @@3))) ++@end smallexample ++ ++which moves the outer @code{plus} operation to the inner arms ++of the @code{vec_cond} expression but only if the actual plus ++operations both simplify. ++ + As intermediate conversions are often optional there is a way to + avoid the need to repeat patterns both with and without such + conversions. Namely you can mark a conversion as being optional +diff --git a/gcc/genmatch.c b/gcc/genmatch.c +index 0a8cba62e..88459d968 100644 +--- a/gcc/genmatch.c ++++ b/gcc/genmatch.c +@@ -697,12 +697,13 @@ public: + expr (id_base *operation_, location_t loc, bool is_commutative_ = false) + : operand (OP_EXPR, loc), operation (operation_), + ops (vNULL), expr_type (NULL), is_commutative (is_commutative_), +- is_generic (false), force_single_use (false), opt_grp (0) {} ++ is_generic (false), force_single_use (false), force_leaf (false), ++ opt_grp (0) {} + expr (expr *e) + : operand (OP_EXPR, e->location), operation (e->operation), + ops (vNULL), expr_type (e->expr_type), is_commutative (e->is_commutative), + is_generic (e->is_generic), force_single_use (e->force_single_use), +- opt_grp (e->opt_grp) {} ++ force_leaf (e->force_leaf), opt_grp (e->opt_grp) {} + void append_op (operand *op) { ops.safe_push (op); } + /* The operator and its operands. */ + id_base *operation; +@@ -717,6 +718,9 @@ public: + /* Whether pushing any stmt to the sequence should be conditional + on this expression having a single-use. */ + bool force_single_use; ++ /* Whether in the result expression this should be a leaf node ++ with any children simplified down to simple operands. */ ++ bool force_leaf; + /* If non-zero, the group for optional handling. */ + unsigned char opt_grp; + virtual void gen_transform (FILE *f, int, const char *, bool, int, +@@ -2520,7 +2524,8 @@ expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple, + fprintf (f, ");\n"); + fprintf_indent (f, indent, "tem_op.resimplify (lseq, valueize);\n"); + fprintf_indent (f, indent, +- "_r%d = maybe_push_res_to_seq (&tem_op, lseq);\n", depth); ++ "_r%d = maybe_push_res_to_seq (&tem_op, %s);\n", depth, ++ !force_leaf ? "lseq" : "NULL"); + fprintf_indent (f, indent, + "if (!_r%d) return false;\n", + depth); +@@ -4240,6 +4245,14 @@ parser::parse_expr () + bool force_capture = false; + const char *expr_type = NULL; + ++ if (!parsing_match_operand ++ && token->type == CPP_NOT ++ && !(token->flags & PREV_WHITE)) ++ { ++ eat_token (CPP_NOT); ++ e->force_leaf = true; ++ } ++ + if (token->type == CPP_COLON + && !(token->flags & PREV_WHITE)) + { +-- +2.27.0 + diff --git a/0129-Make-genmatch-transform-failure-handling-more-consis.patch b/0129-Make-genmatch-transform-failure-handling-more-consis.patch new file mode 100644 index 0000000..880ef75 --- /dev/null +++ b/0129-Make-genmatch-transform-failure-handling-more-consis.patch @@ -0,0 +1,162 @@ +From 907f5fa8e2611ff947b7471bca22328b053637b1 Mon Sep 17 00:00:00 2001 +From: Richard Biener +Date: Wed, 5 Aug 2020 12:00:07 +0200 +Subject: [PATCH 14/26] Make genmatch transform failure handling more + consistent + +Currently whether a fail during the transform stage is fatal or +whether following patterns are still considers is a bit random +depending on whether the pattern is wrapped in a for for example. +The follwing makes it consistent by replacing early returns with +gotos to the end of the pattern processing. + +2020-08-05 Richard Biener + + * genmatch.c (fail_label): New global. + (expr::gen_transform): Branch to fail_label instead of + returning. Fix indent of call argument checking. + (dt_simplify::gen_1): Compute and emit fail_label, branch + to it instead of returning early. + +Reference commit in GCC: f0699540f37e2550974f9049778a42a634062c0b +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/genmatch.c | 44 +++++++++++++++++++++++++++++--------------- + 1 file changed, 29 insertions(+), 15 deletions(-) + +diff --git a/gcc/genmatch.c b/gcc/genmatch.c +index 88459d968..e49fd0a2e 100644 +--- a/gcc/genmatch.c ++++ b/gcc/genmatch.c +@@ -2352,6 +2352,10 @@ capture_info::walk_c_expr (c_expr *e) + } + + ++/* The current label failing the current matched pattern during ++ code generation. */ ++static char *fail_label; ++ + /* Code generation off the decision tree and the refered AST nodes. */ + + bool +@@ -2527,8 +2531,8 @@ expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple, + "_r%d = maybe_push_res_to_seq (&tem_op, %s);\n", depth, + !force_leaf ? "lseq" : "NULL"); + fprintf_indent (f, indent, +- "if (!_r%d) return false;\n", +- depth); ++ "if (!_r%d) goto %s;\n", ++ depth, fail_label); + if (*opr == CONVERT_EXPR) + { + indent -= 4; +@@ -2560,7 +2564,7 @@ expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple, + if (opr->kind != id_base::CODE) + { + fprintf_indent (f, indent, " if (!_r%d)\n", depth); +- fprintf_indent (f, indent, " return NULL_TREE;\n"); ++ fprintf_indent (f, indent, " goto %s;\n", fail_label); + fprintf_indent (f, indent, "}\n"); + } + if (*opr == CONVERT_EXPR) +@@ -3068,12 +3072,12 @@ dt_node::gen_kids_1 (FILE *f, int indent, bool gimple, int depth, + /* We need to be defensive against bogus prototypes allowing + calls with not enough arguments. */ + fprintf_indent (f, indent, +- " if (gimple_call_num_args (_c%d) == %d)\n" +- " {\n", depth, e->ops.length ()); ++ " if (gimple_call_num_args (_c%d) == %d)\n", ++ depth, e->ops.length ()); ++ fprintf_indent (f, indent, " {\n"); + fns[i]->gen (f, indent + 6, true, depth); +- fprintf_indent (f, indent, +- " }\n" +- " break;\n"); ++ fprintf_indent (f, indent, " }\n"); ++ fprintf_indent (f, indent, " break;\n"); + } + + fprintf_indent (f, indent, "default:;\n"); +@@ -3278,6 +3282,11 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) + } + } + ++ static unsigned fail_label_cnt; ++ char local_fail_label[256]; ++ snprintf (local_fail_label, 256, "next_after_fail%u", ++fail_label_cnt); ++ fail_label = local_fail_label; ++ + /* Analyze captures and perform early-outs on the incoming arguments + that cover cases we cannot handle. */ + capture_info cinfo (s, result, gimple); +@@ -3289,8 +3298,8 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) + if (cinfo.force_no_side_effects & (1 << i)) + { + fprintf_indent (f, indent, +- "if (TREE_SIDE_EFFECTS (_p%d)) return NULL_TREE;\n", +- i); ++ "if (TREE_SIDE_EFFECTS (_p%d)) goto %s;\n", ++ i, fail_label); + if (verbose >= 1) + warning_at (as_a (s->match)->ops[i]->location, + "forcing toplevel operand to have no " +@@ -3305,7 +3314,7 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) + { + fprintf_indent (f, indent, + "if (TREE_SIDE_EFFECTS (captures[%d])) " +- "return NULL_TREE;\n", i); ++ "goto %s;\n", i, fail_label); + if (verbose >= 1) + warning_at (cinfo.info[i].c->location, + "forcing captured operand to have no " +@@ -3348,8 +3357,7 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) + } + + if (s->kind == simplify::SIMPLIFY) +- fprintf_indent (f, indent, "if (__builtin_expect (!dbg_cnt (match), 0)) return %s;\n", +- gimple ? "false" : "NULL_TREE"); ++ fprintf_indent (f, indent, "if (__builtin_expect (!dbg_cnt (match), 0)) goto %s;\n", fail_label); + + fprintf_indent (f, indent, "if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) " + "fprintf (dump_file, \"%s ", +@@ -3361,6 +3369,8 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) + true); + fprintf (f, ", __FILE__, __LINE__);\n"); + ++ fprintf_indent (f, indent, "{\n"); ++ indent += 2; + if (!result) + { + /* If there is no result then this is a predicate implementation. */ +@@ -3474,7 +3484,7 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) + > cinfo.info[i].match_use_count) + fprintf_indent (f, indent, + "if (! tree_invariant_p (captures[%d])) " +- "return NULL_TREE;\n", i); ++ "goto %s;\n", i, fail_label); + } + for (unsigned j = 0; j < e->ops.length (); ++j) + { +@@ -3524,7 +3534,7 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) + if (!is_a (opr)) + { + fprintf_indent (f, indent, "if (!_r)\n"); +- fprintf_indent (f, indent, " return NULL_TREE;\n"); ++ fprintf_indent (f, indent, " goto %s;\n", fail_label); + } + } + } +@@ -3563,6 +3573,10 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) + fprintf_indent (f, indent, "return _r;\n"); + } + } ++ indent -= 2; ++ fprintf_indent (f, indent, "}\n"); ++ fprintf (f, "%s:;\n", fail_label); ++ fail_label = NULL; + } + + /* Generate code for the '(if ...)', '(with ..)' and actual transform +-- +2.27.0 + diff --git a/0130-VEC_COND_EXPR-optimizations.patch b/0130-VEC_COND_EXPR-optimizations.patch new file mode 100644 index 0000000..2352754 --- /dev/null +++ b/0130-VEC_COND_EXPR-optimizations.patch @@ -0,0 +1,184 @@ +From 6975b6e27ea6231d41c24afc51c77e0576b28b14 Mon Sep 17 00:00:00 2001 +From: Marc Glisse +Date: Wed, 5 Aug 2020 16:45:33 +0200 +Subject: [PATCH 15/26] VEC_COND_EXPR optimizations + +When vector comparisons were forced to use vec_cond_expr, we lost a number of optimizations (my fault for not adding enough testcases to +prevent that). This patch tries to unwrap vec_cond_expr a bit so some optimizations can still happen. + +I wasn't planning to add all those transformations together, but adding one caused a regression, whose fix introduced a second regression, +etc. + +Restricting to constant folding would not be sufficient, we also need at least things like X|0 or X&X. The transformations are quite +conservative with :s and folding only if everything simplifies, we may want to relax this later. And of course we are going to miss things +like a?b:c + a?c:b -> b+c. + +In terms of number of operations, some transformations turning 2 VEC_COND_EXPR into VEC_COND_EXPR + BIT_IOR_EXPR + BIT_NOT_EXPR might not look +like a gain... I expect the bit_not disappears in most cases, and VEC_COND_EXPR looks more costly than a simpler BIT_IOR_EXPR. + +2020-08-05 Marc Glisse + + PR tree-optimization/95906 + PR target/70314 + * match.pd ((c ? a : b) op d, (c ? a : b) op (c ? d : e), + (v ? w : 0) ? a : b, c1 ? c2 ? a : b : b): New transformations. + (op (c ? a : b)): Update to match the new transformations. + + * gcc.dg/tree-ssa/andnot-2.c: New file. + * gcc.dg/tree-ssa/pr95906.c: Likewise. + * gcc.target/i386/pr70314.c: Likewise. + +Reference commit in GCC: 229752afe3156a3990dacaedb94c76846cebf132 +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/match.pd | 70 ++++++++++++++++++++---- + gcc/testsuite/gcc.dg/tree-ssa/andnot-2.c | 10 ++++ + gcc/testsuite/gcc.dg/tree-ssa/pr95906.c | 13 +++++ + gcc/testsuite/gcc.target/i386/pr70314.c | 15 +++++ + 4 files changed, 96 insertions(+), 12 deletions(-) + create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/andnot-2.c + create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr95906.c + create mode 100644 gcc/testsuite/gcc.target/i386/pr70314.c + +diff --git a/gcc/match.pd b/gcc/match.pd +index 01f81b063..25575af21 100644 +--- a/gcc/match.pd ++++ b/gcc/match.pd +@@ -3319,20 +3319,66 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) + (if (integer_zerop (@0)) + @2))) + +-/* Sink unary operations to constant branches, but only if we do fold it to +- constants. */ ++#if GIMPLE ++/* Sink unary operations to branches, but only if we do fold both. */ + (for op (negate bit_not abs absu) + (simplify +- (op (vec_cond @0 VECTOR_CST@1 VECTOR_CST@2)) +- (with +- { +- tree cst1, cst2; +- cst1 = const_unop (op, type, @1); +- if (cst1) +- cst2 = const_unop (op, type, @2); +- } +- (if (cst1 && cst2) +- (vec_cond @0 { cst1; } { cst2; }))))) ++ (op (vec_cond:s @0 @1 @2)) ++ (vec_cond @0 (op! @1) (op! @2)))) ++ ++/* Sink binary operation to branches, but only if we can fold it. */ ++(for op (tcc_comparison plus minus mult bit_and bit_ior bit_xor ++ rdiv trunc_div ceil_div floor_div round_div ++ trunc_mod ceil_mod floor_mod round_mod min max) ++/* (c ? a : b) op (c ? d : e) --> c ? (a op d) : (b op e) */ ++ (simplify ++ (op (vec_cond:s @0 @1 @2) (vec_cond:s @0 @3 @4)) ++ (vec_cond @0 (op! @1 @3) (op! @2 @4))) ++ ++/* (c ? a : b) op d --> c ? (a op d) : (b op d) */ ++ (simplify ++ (op (vec_cond:s @0 @1 @2) @3) ++ (vec_cond @0 (op! @1 @3) (op! @2 @3))) ++ (simplify ++ (op @3 (vec_cond:s @0 @1 @2)) ++ (vec_cond @0 (op! @3 @1) (op! @3 @2)))) ++#endif ++ ++/* (v ? w : 0) ? a : b is just (v & w) ? a : b */ ++(simplify ++ (vec_cond (vec_cond:s @0 @3 integer_zerop) @1 @2) ++ (if (types_match (@0, @3)) ++ (vec_cond (bit_and @0 @3) @1 @2))) ++(simplify ++ (vec_cond (vec_cond:s @0 integer_all_onesp @3) @1 @2) ++ (if (types_match (@0, @3)) ++ (vec_cond (bit_ior @0 @3) @1 @2))) ++(simplify ++ (vec_cond (vec_cond:s @0 integer_zerop @3) @1 @2) ++ (if (types_match (@0, @3)) ++ (vec_cond (bit_ior @0 (bit_not @3)) @2 @1))) ++(simplify ++ (vec_cond (vec_cond:s @0 @3 integer_all_onesp) @1 @2) ++ (if (types_match (@0, @3)) ++ (vec_cond (bit_and @0 (bit_not @3)) @2 @1))) ++ ++/* c1 ? c2 ? a : b : b --> (c1 & c2) ? a : b */ ++(simplify ++ (vec_cond @0 (vec_cond:s @1 @2 @3) @3) ++ (if (types_match (@0, @1)) ++ (vec_cond (bit_and @0 @1) @2 @3))) ++(simplify ++ (vec_cond @0 @2 (vec_cond:s @1 @2 @3)) ++ (if (types_match (@0, @1)) ++ (vec_cond (bit_ior @0 @1) @2 @3))) ++(simplify ++ (vec_cond @0 (vec_cond:s @1 @2 @3) @2) ++ (if (types_match (@0, @1)) ++ (vec_cond (bit_ior (bit_not @0) @1) @2 @3))) ++(simplify ++ (vec_cond @0 @3 (vec_cond:s @1 @2 @3)) ++ (if (types_match (@0, @1)) ++ (vec_cond (bit_and (bit_not @0) @1) @2 @3))) + + /* A few simplifications of "a ? CST1 : CST2". */ + /* NOTE: Only do this on gimple as the if-chain-to-switch +diff --git a/gcc/testsuite/gcc.dg/tree-ssa/andnot-2.c b/gcc/testsuite/gcc.dg/tree-ssa/andnot-2.c +new file mode 100644 +index 000000000..e0955ce3f +--- /dev/null ++++ b/gcc/testsuite/gcc.dg/tree-ssa/andnot-2.c +@@ -0,0 +1,10 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fdump-tree-forwprop3-raw -w -Wno-psabi" } */ ++ ++typedef long vec __attribute__((vector_size(16))); ++vec f(vec x){ ++ vec y = x < 10; ++ return y & (y == 0); ++} ++ ++/* { dg-final { scan-tree-dump-not "_expr" "forwprop3" } } */ +diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr95906.c b/gcc/testsuite/gcc.dg/tree-ssa/pr95906.c +new file mode 100644 +index 000000000..3d820a58e +--- /dev/null ++++ b/gcc/testsuite/gcc.dg/tree-ssa/pr95906.c +@@ -0,0 +1,13 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fdump-tree-forwprop3-raw -w -Wno-psabi" } */ ++ ++// FIXME: this should further optimize to a MAX_EXPR ++typedef signed char v16i8 __attribute__((vector_size(16))); ++v16i8 f(v16i8 a, v16i8 b) ++{ ++ v16i8 cmp = (a > b); ++ return (cmp & a) | (~cmp & b); ++} ++ ++/* { dg-final { scan-tree-dump-not "bit_(and|ior)_expr" "forwprop3" } } */ ++/* { dg-final { scan-tree-dump-times "vec_cond_expr" 1 "forwprop3" } } */ +diff --git a/gcc/testsuite/gcc.target/i386/pr70314.c b/gcc/testsuite/gcc.target/i386/pr70314.c +new file mode 100644 +index 000000000..aad8dd9b5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/i386/pr70314.c +@@ -0,0 +1,15 @@ ++/* { dg-do compile } */ ++/* { dg-options "-march=skylake-avx512 -O2" } */ ++/* { dg-final { scan-assembler-times "cmp" 2 } } */ ++/* { dg-final { scan-assembler-not "and" } } */ ++ ++typedef long vec __attribute__((vector_size(16))); ++vec f(vec x, vec y){ ++ return (x < 5) & (y < 8); ++} ++ ++/* On x86_64, currently ++ vpcmpq $2, .LC1(%rip), %xmm1, %k1 ++ vpcmpq $2, .LC0(%rip), %xmm0, %k0{%k1} ++ vpmovm2q %k0, %xmm0 ++*/ +-- +2.27.0 + diff --git a/0131-aarch64-Remove-XFAILs-for-two-SVE-tests.patch b/0131-aarch64-Remove-XFAILs-for-two-SVE-tests.patch new file mode 100644 index 0000000..4632f87 --- /dev/null +++ b/0131-aarch64-Remove-XFAILs-for-two-SVE-tests.patch @@ -0,0 +1,48 @@ +From 77d1b4bd1b72be3769b2544f7f1e4a390fbf8e60 Mon Sep 17 00:00:00 2001 +From: Richard Sandiford +Date: Tue, 17 Nov 2020 12:02:50 +0000 +Subject: [PATCH 16/26] aarch64: Remove XFAILs for two SVE tests + +These tests started passing a while ago, so remove the XFAILs. + +gcc/testsuite/ + * gcc.target/aarch64/sve/cond_cnot_1.c: Remove XFAIL. + * gcc.target/aarch64/sve/cond_unary_1.c: Likewise. + +Reference commit in GCC: 0f6759240f1df4240483d0ac3744ac60e82e702f +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_1.c | 5 ++--- + gcc/testsuite/gcc.target/aarch64/sve/cond_unary_1.c | 6 ++---- + 2 files changed, 4 insertions(+), 7 deletions(-) + +diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_1.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_1.c +index f587da1fb..49f0b18a5 100644 +--- a/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_1.c ++++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_1.c +@@ -30,6 +30,5 @@ TEST_ALL (DEF_LOOP) + /* { dg-final { scan-assembler-times {\tcnot\tz[0-9]+\.d, p[0-7]/m,} 2 } } */ + + /* { dg-final { scan-assembler-not {\tmov\tz} } } */ +-/* { dg-final { scan-assembler-not {\tmovprfx\t} { xfail *-*-* } } } */ +-/* Currently we canonicalize the ?: so that !b[i] is the "false" value. */ +-/* { dg-final { scan-assembler-not {\tsel\t} { xfail *-*-* } } } */ ++/* { dg-final { scan-assembler-not {\tmovprfx\t} } } */ ++/* { dg-final { scan-assembler-not {\tsel\t} } } */ +diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_1.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_1.c +index addedfa28..049247671 100644 +--- a/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_1.c ++++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_1.c +@@ -53,7 +53,5 @@ TEST_ALL (DEF_LOOP) + /* { dg-final { scan-assembler-times {\tfneg\tz[0-9]+\.d, p[0-7]/m,} 1 } } */ + + /* { dg-final { scan-assembler-not {\tmov\tz} } } */ +-/* { dg-final { scan-assembler-not {\tmovprfx\t} { xfail *-*-* } } } */ +-/* XFAILed because the ?: gets canonicalized so that the operation is in +- the false arm. */ +-/* { dg-final { scan-assembler-not {\tsel\t} { xfail *-*-* } } } */ ++/* { dg-final { scan-assembler-not {\tmovprfx\t} } } */ ++/* { dg-final { scan-assembler-not {\tsel\t} } } */ +-- +2.27.0 + diff --git a/0132-testsuite-Fix-up-pr99305.C-test-on-unsigned_char-tar.patch b/0132-testsuite-Fix-up-pr99305.C-test-on-unsigned_char-tar.patch new file mode 100644 index 0000000..4ce464a --- /dev/null +++ b/0132-testsuite-Fix-up-pr99305.C-test-on-unsigned_char-tar.patch @@ -0,0 +1,39 @@ +From a5f67f524a04353cc67d52c4b333a8e58ebcdd54 Mon Sep 17 00:00:00 2001 +From: Jakub Jelinek +Date: Wed, 10 Mar 2021 17:40:25 +0100 +Subject: [PATCH 17/26] testsuite: Fix up pr99305.C test on unsigned_char + targets [PR99498] + +On unsigned_char targets, the cast stmt to unsigned char is obviously +not needed (and shouldn't be there). But it doesn't hurt to test +the rest also on targets where char is unsigned. + +2021-03-10 Jakub Jelinek + + PR tree-optimization/99305 + PR testsuite/99498 + * g++.dg/opt/pr99305.C: Don't expect cast to unsigned char on + unsigned_char effective targets. + +Reference commit in GCC: 5bf998275aff311b9804c1de944a88c219f35db6 +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/testsuite/g++.dg/opt/pr99305.C | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/gcc/testsuite/g++.dg/opt/pr99305.C b/gcc/testsuite/g++.dg/opt/pr99305.C +index 8a91277e7..6fcdef391 100644 +--- a/gcc/testsuite/g++.dg/opt/pr99305.C ++++ b/gcc/testsuite/g++.dg/opt/pr99305.C +@@ -1,7 +1,7 @@ + // PR tree-optimization/99305 + // { dg-do compile } + // { dg-options "-O3 -fno-ipa-icf -fdump-tree-optimized" } +-// { dg-final { scan-tree-dump-times " = \\\(unsigned char\\\) c_\[0-9]*\\\(D\\\);" 3 "optimized" } } ++// { dg-final { scan-tree-dump-times " = \\\(unsigned char\\\) c_\[0-9]*\\\(D\\\);" 3 "optimized" { target { ! unsigned_char } } } } + // { dg-final { scan-tree-dump-times " = \[^\n\r]* \\+ \[0-9]*;" 3 "optimized" } } + // { dg-final { scan-tree-dump-times " = \[^\n\r]* <= 9;" 3 "optimized" } } + // { dg-final { scan-tree-dump-not "if \\\(c_\[0-9]*\\\(D\\\) \[!=]= 0\\\)" "optimized" } } +-- +2.27.0 + diff --git a/0133-match.pd-Fix-sve-vcond_3.c.patch b/0133-match.pd-Fix-sve-vcond_3.c.patch new file mode 100644 index 0000000..c06a8e3 --- /dev/null +++ b/0133-match.pd-Fix-sve-vcond_3.c.patch @@ -0,0 +1,43 @@ +From b00022c926d5de1f2e3c67e9e80232b1a9399abe Mon Sep 17 00:00:00 2001 +From: Richard Sandiford +Date: Thu, 8 Apr 2021 17:39:11 +0100 +Subject: [PATCH 18/26] match.pd: Fix sve/vcond_3.c + +The sve/vcond_3.c tests had started to fail after PR97690/99305, +because we were generating: + + a = VEC_COND_EXPR ; + b = a << 15; + +instead of: + + a = VEC_COND_EXPR ; + +We already have a match.pd rule to handle this kind of thing, +but it didn't handle shifts. + +gcc/ + * match.pd: Extend vec_cond folds to handle shifts. + +Reference commit in GCC: 5240c5ca2e2b1f362670791df233c4103d87cf5b +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/match.pd | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/gcc/match.pd b/gcc/match.pd +index 25575af21..9d9627fe7 100644 +--- a/gcc/match.pd ++++ b/gcc/match.pd +@@ -3328,7 +3328,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) + + /* Sink binary operation to branches, but only if we can fold it. */ + (for op (tcc_comparison plus minus mult bit_and bit_ior bit_xor +- rdiv trunc_div ceil_div floor_div round_div ++ lshift rshift rdiv trunc_div ceil_div floor_div round_div + trunc_mod ceil_mod floor_mod round_mod min max) + /* (c ? a : b) op (c ? d : e) --> c ? (a op d) : (b op e) */ + (simplify +-- +2.27.0 + diff --git a/0134-Fix-PR-100925-Limit-some-a-CST1-CST2-optimizations-t.patch b/0134-Fix-PR-100925-Limit-some-a-CST1-CST2-optimizations-t.patch new file mode 100644 index 0000000..cc77607 --- /dev/null +++ b/0134-Fix-PR-100925-Limit-some-a-CST1-CST2-optimizations-t.patch @@ -0,0 +1,65 @@ +From 6995a2f35d0f866068beddae33a8a0e9187861fd Mon Sep 17 00:00:00 2001 +From: Andrew Pinski +Date: Sat, 5 Jun 2021 21:25:58 -0700 +Subject: [PATCH 19/26] Fix PR 100925: Limit some a?CST1:CST2 optimizations to + intergal types only + +The problem here is with offset (and pointer) types is we produce +a negative expression when this optimization hits. +It is easier to disable this optimization for all non-integeral types +instead of finding an integer type which is the same precission as the +type to do the negative expression on it. + +OK? Bootstrapped and tested on x86_64-linux-gnu with no regressions. + +gcc/ChangeLog: + + PR tree-optimization/100925 + * match.pd (a ? CST1 : CST2): Limit transformations + that would produce a negative to integeral types only. + Change !POINTER_TYPE_P to INTEGRAL_TYPE_P also. + +gcc/testsuite/ChangeLog: + + * g++.dg/torture/pr100925.C: New test. + +Reference commit in GCC: d4faa36e7540c573c5dc17850bcd938d0900b2e9 +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/testsuite/g++.dg/torture/pr100925.C | 24 ++++++++++++++++++++++++ + 1 file changed, 24 insertions(+) + create mode 100644 gcc/testsuite/g++.dg/torture/pr100925.C + +diff --git a/gcc/testsuite/g++.dg/torture/pr100925.C b/gcc/testsuite/g++.dg/torture/pr100925.C +new file mode 100644 +index 000000000..de13950dc +--- /dev/null ++++ b/gcc/testsuite/g++.dg/torture/pr100925.C +@@ -0,0 +1,24 @@ ++// { dg-do compile } ++ ++struct QScopedPointerDeleter { ++ static void cleanup(int *); ++}; ++class QScopedPointer { ++ typedef int *QScopedPointer::*RestrictedBool; ++ ++public: ++ operator RestrictedBool() { return d ? nullptr : &QScopedPointer::d; } ++ void reset() { ++ if (d) ++ QScopedPointerDeleter::cleanup(d); ++ } ++ int *d; ++}; ++class DOpenGLPaintDevicePrivate { ++public: ++ QScopedPointer fbo; ++} DOpenGLPaintDeviceresize_d; ++void DOpenGLPaintDeviceresize() { ++ if (DOpenGLPaintDeviceresize_d.fbo) ++ DOpenGLPaintDeviceresize_d.fbo.reset(); ++} +-- +2.27.0 + diff --git a/0135-tree-optimization-PR102622-wrong-code-due-to-signed-.patch b/0135-tree-optimization-PR102622-wrong-code-due-to-signed-.patch new file mode 100644 index 0000000..c387319 --- /dev/null +++ b/0135-tree-optimization-PR102622-wrong-code-due-to-signed-.patch @@ -0,0 +1,94 @@ +From 9c3b4e0b5690df62ca5e0c65a73bbccad017be24 Mon Sep 17 00:00:00 2001 +From: Andrew Pinski +Date: Sun, 10 Oct 2021 01:28:59 +0000 +Subject: [PATCH 20/26] tree-optimization: [PR102622]: wrong code due to signed + one bit integer and "a?-1:0" + +So it turns out this is kinda of a latent bug but not really latent. +In GCC 9 and 10, phi-opt would transform a?-1:0 (even for signed 1-bit integer) +to -(type)a but the type is an one bit integer which means the negation is +undefined. GCC 11 fixed the problem by checking for a?pow2cst:0 transformation +before a?-1:0 transformation. + +When I added the transformations to match.pd, I had swapped the order not paying +attention and I didn't expect anything of it. Because there was no testcase failing +due to this. +Anyways this fixes the problem on the trunk by swapping the order in match.pd and +adding a comment of why the order is this way. + +I will try to come up with a patch for GCC 9 and 10 series later on which fixes +the problem there too. + +Note I didn't include the original testcase which requires the vectorizer and AVX-512f +as I can't figure out the right dg options to restrict it to avx-512f but I did come up +with a testcase which shows the problem and even more shows the problem with the 9/10 +series as mentioned. + +OK? Bootstrapped and tested on x86_64-linux-gnu. + + PR tree-optimization/102622 + +gcc/ChangeLog: + + * match.pd: Swap the order of a?pow2cst:0 and a?-1:0 transformations. + Swap the order of a?0:pow2cst and a?0:-1 transformations. + +gcc/testsuite/ChangeLog: + + * gcc.c-torture/execute/bitfld-10.c: New test. + +Reference commit in GCC: 882d806c1a8f9d2d2ade1133de88d63e5d4fe40c +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/match.pd | 3 ++- + .../gcc.c-torture/execute/bitfld-10.c | 24 +++++++++++++++++++ + 2 files changed, 26 insertions(+), 1 deletion(-) + create mode 100644 gcc/testsuite/gcc.c-torture/execute/bitfld-10.c + +diff --git a/gcc/match.pd b/gcc/match.pd +index 9d9627fe7..d7d0dd0f7 100644 +--- a/gcc/match.pd ++++ b/gcc/match.pd +@@ -3412,7 +3412,8 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) + (if (integer_onep (@2)) + (convert (bit_xor (convert:boolean_type_node @0) { booltrue; } ))) + /* a ? powerof2cst : 0 -> (!a) << (log2(powerof2cst)) */ +- (if (INTEGRAL_TYPE_P (type) && integer_pow2p (@2)) ++ (if (INTEGRAL_TYPE_P (type) && integer_pow2p (@2) ++ && TYPE_PRECISION (type) != 1) + (with { + tree shift = build_int_cst (integer_type_node, tree_log2 (@2)); + } +diff --git a/gcc/testsuite/gcc.c-torture/execute/bitfld-10.c b/gcc/testsuite/gcc.c-torture/execute/bitfld-10.c +new file mode 100644 +index 000000000..bdbf5733c +--- /dev/null ++++ b/gcc/testsuite/gcc.c-torture/execute/bitfld-10.c +@@ -0,0 +1,24 @@ ++/* PR tree-optimization/102622 */ ++/* Wrong code introduced due to phi-opt ++ introducing undefined signed interger overflow ++ with one bit signed integer negation. */ ++ ++struct f{signed t:1;}; ++int g(struct f *a, int t) __attribute__((noipa)); ++int g(struct f *a, int t) ++{ ++ if (t) ++ a->t = -1; ++ else ++ a->t = 0; ++ int t1 = a->t; ++ if (t1) return 1; ++ return t1; ++} ++ ++int main(void) ++{ ++ struct f a; ++ if (!g(&a, 1)) __builtin_abort(); ++ return 0; ++} +-- +2.27.0 + diff --git a/0136-Fix-tree-optimization-103152-Still-one-more-signed1b.patch b/0136-Fix-tree-optimization-103152-Still-one-more-signed1b.patch new file mode 100644 index 0000000..8c7063b --- /dev/null +++ b/0136-Fix-tree-optimization-103152-Still-one-more-signed1b.patch @@ -0,0 +1,66 @@ +From 3293cd744508b1d6d5079294858289676680b178 Mon Sep 17 00:00:00 2001 +From: Andrew Pinski +Date: Tue, 9 Nov 2021 09:56:10 +0000 +Subject: [PATCH 21/26] Fix tree-optimization/103152: Still one more + -signed1bit issue + +When I fixed PR 102622, I accidently left behind a TYPE_PRECISION +check which I had there for checking before hand. This check +is not needed as the code will handle it correctly anyways. + +Committed as obvious after a bootstrap/test on x86_64-linux-gnu. + + PR tree-optimization/10352 + +gcc/ChangeLog: + + * match.pd: Remove check of TYPE_PRECISION for + the a?0:pow2 case. + +gcc/testsuite/ChangeLog: + + * gcc.c-torture/execute/pr10352-1.c: New test. + +Reference commit in GCC: f7844b6a777cb47fec7208d7bd594f6ce66f1daa +Signed-off-by: Pronin Alexander 00812787 +--- + gcc/match.pd | 3 +-- + gcc/testsuite/gcc.c-torture/execute/pr10352-1.c | 12 ++++++++++++ + 2 files changed, 13 insertions(+), 2 deletions(-) + create mode 100644 gcc/testsuite/gcc.c-torture/execute/pr10352-1.c + +diff --git a/gcc/match.pd b/gcc/match.pd +index d7d0dd0f7..9d9627fe7 100644 +--- a/gcc/match.pd ++++ b/gcc/match.pd +@@ -3412,8 +3412,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) + (if (integer_onep (@2)) + (convert (bit_xor (convert:boolean_type_node @0) { booltrue; } ))) + /* a ? powerof2cst : 0 -> (!a) << (log2(powerof2cst)) */ +- (if (INTEGRAL_TYPE_P (type) && integer_pow2p (@2) +- && TYPE_PRECISION (type) != 1) ++ (if (INTEGRAL_TYPE_P (type) && integer_pow2p (@2)) + (with { + tree shift = build_int_cst (integer_type_node, tree_log2 (@2)); + } +diff --git a/gcc/testsuite/gcc.c-torture/execute/pr10352-1.c b/gcc/testsuite/gcc.c-torture/execute/pr10352-1.c +new file mode 100644 +index 000000000..babb9d45a +--- /dev/null ++++ b/gcc/testsuite/gcc.c-torture/execute/pr10352-1.c +@@ -0,0 +1,12 @@ ++/* this is another case where phiopt ++ would create -signed1bit which is undefined. */ ++struct { ++ int a:1; ++} b; ++int *c = (int *)&b, d; ++int main() { ++ d = c && (b.a = (d < 0) ^ 3); ++ if (d != 1) ++ __builtin_abort(); ++ return 0; ++} +-- +2.27.0 + diff --git a/0137-DFE-Fix-unexpected-struct-function-pointer-eliminati.patch b/0137-DFE-Fix-unexpected-struct-function-pointer-eliminati.patch new file mode 100644 index 0000000..660e23d --- /dev/null +++ b/0137-DFE-Fix-unexpected-struct-function-pointer-eliminati.patch @@ -0,0 +1,117 @@ +From 25d74b98caeaae881e374924886ee664aa1af5bc Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?=E9=83=91=E6=99=A8=E5=8D=89?= +Date: Mon, 9 Oct 2023 14:41:01 +0800 +Subject: [PATCH 22/26] [DFE]Fix unexpected struct function pointer elimination + bug. + +--- + gcc/ipa-struct-reorg/ipa-struct-reorg.c | 9 ++- + gcc/testsuite/gcc.dg/struct/dfe_func_ptr.c | 69 ++++++++++++++++++++++ + 2 files changed, 76 insertions(+), 2 deletions(-) + create mode 100644 gcc/testsuite/gcc.dg/struct/dfe_func_ptr.c + +diff --git a/gcc/ipa-struct-reorg/ipa-struct-reorg.c b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +index 367bcf210..fe99e8733 100644 +--- a/gcc/ipa-struct-reorg/ipa-struct-reorg.c ++++ b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +@@ -438,7 +438,11 @@ srtype::has_dead_field (void) + unsigned i; + FOR_EACH_VEC_ELT (fields, i, this_field) + { +- if (!(this_field->field_access & READ_FIELD)) ++ /* Function pointer members are not processed, because DFE ++ does not currently support accurate analysis of function ++ pointers, and we have not identified specific use cases. */ ++ if (!(this_field->field_access & READ_FIELD) ++ && !FUNCTION_POINTER_TYPE_P (this_field->fieldtype)) + { + may_dfe = true; + break; +@@ -1024,7 +1028,8 @@ srtype::create_new_type (void) + { + srfield *f = fields[i]; + if (current_layout_opt_level & DEAD_FIELD_ELIMINATION +- && !(f->field_access & READ_FIELD)) ++ && !(f->field_access & READ_FIELD) ++ && !FUNCTION_POINTER_TYPE_P (f->fieldtype)) + continue; + f->create_new_fields (newtype, newfields, newlast); + } +diff --git a/gcc/testsuite/gcc.dg/struct/dfe_func_ptr.c b/gcc/testsuite/gcc.dg/struct/dfe_func_ptr.c +new file mode 100644 +index 000000000..74ea93bbc +--- /dev/null ++++ b/gcc/testsuite/gcc.dg/struct/dfe_func_ptr.c +@@ -0,0 +1,69 @@ ++/* { dg-do compile } */ ++/* { dg-do run } */ ++ ++#include ++#include ++ ++#ifdef STACK_SIZE ++#if STACK_SIZE > 16000 ++#define N 1000 ++#else ++#define N (STACK_SIZE/16) ++#endif ++#else ++#define N 1000 ++#endif ++ ++int num; ++ ++int (*foo)(int d); ++int f (int t); ++ ++typedef struct str_t str_t1; ++struct str_t ++{ ++ int a; ++ float b; ++ int (*foo)(int d); ++}; ++ ++int main () ++{ ++ int i, r; ++ r = rand (); ++ num = r > N ? N : r; ++ str_t1 * p1 = calloc (num, sizeof (str_t1)); ++ if (p1 == NULL) ++ return 0; ++ for (i = 0; i < num; i++) ++ { ++ p1[i].foo = malloc (1 * sizeof (f)); ++ p1[i].foo = f; ++ p1[i].foo (i); ++ } ++ ++ for (i = 0; i < num; i++) ++ p1[i].a = 1; ++ ++ for (i = 0; i < num; i++) ++ p1[i].b = 2; ++ ++ for (i = 0; i < num; i++) ++ if (p1[i].a != 1) ++ abort (); ++ ++ for (i = 0; i < num; i++) ++ if (abs (p1[i].b - 2) > 0.0001) ++ abort (); ++ ++ return 0; ++} ++ ++int f (int t) ++{ ++ if ( t < 0) ++ abort (); ++ return 0; ++} ++ ++/* { dg-final { scan-ipa-dump-times "Dead field elimination" 0 "struct_reorg" } } */ +-- +2.27.0 + diff --git a/0138-Fix-ICE-bugs-in-transpose-test-cases-with-vector-ind.patch b/0138-Fix-ICE-bugs-in-transpose-test-cases-with-vector-ind.patch new file mode 100644 index 0000000..a2c9296 --- /dev/null +++ b/0138-Fix-ICE-bugs-in-transpose-test-cases-with-vector-ind.patch @@ -0,0 +1,25 @@ +From bba233a851a49928f55deeb5e00cf5905abb79c0 Mon Sep 17 00:00:00 2001 +From: Yarovoy Danil WX1195294 +Date: Fri, 11 Nov 2022 17:48:39 +0300 +Subject: [PATCH 23/26] Fix ICE bugs in transpose test cases with vector + indexing. Expand the result_chain size to fix the out of bounds issue. + +--- + gcc/tree-vect-data-refs.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c +index e4466a4f3..b20e12513 100644 +--- a/gcc/tree-vect-data-refs.c ++++ b/gcc/tree-vect-data-refs.c +@@ -5623,6 +5623,7 @@ vect_transpose_store_chain (vec dr_chain, unsigned int length, + ...}> */ + vect_indices_encoding (vectype, array_num, perm_mask_high, perm_mask_low); + ++ result_chain->quick_grow (length); + for (unsigned int perm_time = 0; perm_time < log_length; perm_time++) + { + for (unsigned int index = 0; index < length / 2; index++) +-- +2.27.0 + diff --git a/0139-Fix-errors-on-testsuite-c-c-tests-and-505.mcf_r.patch b/0139-Fix-errors-on-testsuite-c-c-tests-and-505.mcf_r.patch new file mode 100644 index 0000000..b707fb2 --- /dev/null +++ b/0139-Fix-errors-on-testsuite-c-c-tests-and-505.mcf_r.patch @@ -0,0 +1,276 @@ +From 0d3d9196da03be8e30ec799ee9ed8d577a2cf86e Mon Sep 17 00:00:00 2001 +From: Diachkov Ilia WX1215920 +Date: Sat, 26 Nov 2022 02:25:24 +0300 +Subject: [PATCH 24/26] Fix errors on testsuite c/c++ tests and 505.mcf_r + +- add missed stmt check in decompress_candidate_without_check, +- generate missed converts and do not emit duplicate assignments, +- fix code indentation and line length. +--- + gcc/ipa-struct-reorg/ipa-struct-reorg.c | 130 +++++++++++++++--------- + 1 file changed, 81 insertions(+), 49 deletions(-) + +diff --git a/gcc/ipa-struct-reorg/ipa-struct-reorg.c b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +index 367bcf210..068678b15 100644 +--- a/gcc/ipa-struct-reorg/ipa-struct-reorg.c ++++ b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +@@ -1543,7 +1543,7 @@ public: + bool check_sr_copy (gimple *); + void relayout_field_copy (gimple_stmt_iterator *, gimple *, tree, tree, + tree&, tree &); +- void do_semi_relayout (gimple_stmt_iterator *, gimple *, tree &, tree &); ++ bool do_semi_relayout (gimple_stmt_iterator *, gimple *, tree &, tree &); + }; + + struct ipa_struct_relayout +@@ -6481,7 +6481,10 @@ ipa_struct_reorg::pc_type_conversion_candidate_p (tree xhs) + + if (TREE_CODE (xhs) == COMPONENT_REF) + { +- srtype *base_type = find_type (TREE_TYPE (TREE_OPERAND (xhs, 0))); ++ tree mem = TREE_OPERAND (xhs, 0); ++ if (TREE_CODE (mem) != MEM_REF) ++ return false; ++ srtype *base_type = find_type (TREE_TYPE (mem)); + if (base_type != NULL && base_type->has_escaped ()) + return pc_candidate_st_type_p (TREE_TYPE (xhs)); + +@@ -6795,7 +6798,8 @@ ipa_struct_reorg::decompress_candidate_without_check (gimple_stmt_iterator *gsi, + { + gsi_next (gsi); + gimple *next_stmt = gsi_stmt (*gsi); +- if (gimple_assign_rhs_class (next_stmt) == GIMPLE_SINGLE_RHS) ++ if (gimple_code (next_stmt) == GIMPLE_ASSIGN ++ && gimple_assign_rhs_class (next_stmt) == GIMPLE_SINGLE_RHS) + { + tree next_rhs = gimple_assign_rhs1 (next_stmt); + /* If current lhs is used as rhs in the next stmt: +@@ -6977,14 +6981,23 @@ ipa_struct_reorg::try_rewrite_with_pointer_compression (gassign *stmt, + if (pc_type_conversion_candidate_p (lhs)) + { + /* Transfer MEM[(struct *)_1].files = _4; +- to MEM[(struct *)_1].files = (struct *)_4; */ +- new_rhs = fold_convert (TREE_TYPE (lhs), tmp_rhs); ++ to _tmp = (struct *)_4; ++ MEM[(struct *)_1].files = _tmp; */ ++ tree tmp_reg = create_tmp_reg(TREE_TYPE(lhs)); ++ tree tmp_rhs_cvt = fold_convert (TREE_TYPE (lhs), tmp_rhs); ++ gimple *copy_stmt = gimple_build_assign (tmp_reg, tmp_rhs_cvt); ++ gsi_insert_before (gsi, copy_stmt, GSI_SAME_STMT); ++ new_rhs = tmp_reg; + } + else if (pc_type_conversion_candidate_p (rhs)) + { + /* Transfer _4 = MEM[(struct *)_1].nodes; +- to _4 = (new_struct *) MEM[(struct *)_1].nodes; */ +- new_rhs = fold_convert (TREE_TYPE (new_lhs), tmp_rhs); ++ to _tmp = MEM[(struct *)_1].nodes; ++ _4 = (new_struct *) _tmp; */ ++ tree tmp_reg = create_tmp_reg(TREE_TYPE(new_lhs)); ++ gimple *copy_stmt = gimple_build_assign (tmp_reg, tmp_rhs); ++ gsi_insert_before (gsi, copy_stmt, GSI_SAME_STMT); ++ new_rhs = fold_convert (TREE_TYPE (new_lhs), tmp_reg); + } + } + else if (l && r) +@@ -7007,46 +7020,45 @@ ipa_struct_reorg::rewrite_pointer_diff (gimple_stmt_iterator *gsi, tree ptr1, + { + tree shifts = build_int_cst (long_integer_type_node, semi_relayout_align); + tree pointer_type = build_pointer_type (unsigned_char_type_node); ++ tree intptr_type = signed_type_for (pointer_type); ++ + /* addr_high_1 = (intptr_t)ptr1 >> shifts */ +- tree ptr1_cvt = fold_convert (pointer_type, ptr1); +- tree addr_high_1 = gimplify_build2 (gsi, RSHIFT_EXPR, pointer_type, ++ tree ptr1_cvt = fold_convert (intptr_type, ptr1); ++ tree addr_high_1 = gimplify_build2 (gsi, RSHIFT_EXPR, intptr_type, + ptr1_cvt, shifts); + /* addr_high_2 = (intptr_t)ptr2 >> shifts */ +- tree ptr2_cvt = fold_convert (pointer_type, ptr2); +- tree addr_high_2 = gimplify_build2 (gsi, RSHIFT_EXPR, pointer_type, ++ tree ptr2_cvt = fold_convert (intptr_type, ptr2); ++ tree addr_high_2 = gimplify_build2 (gsi, RSHIFT_EXPR, intptr_type, + ptr2_cvt, shifts); + /* off1 = (intptr_t)ptr1 - (addr_high_1 << shifts) */ +- tree bucket_start_1 = gimplify_build2 (gsi, LSHIFT_EXPR, pointer_type, ++ tree bucket_start_1 = gimplify_build2 (gsi, LSHIFT_EXPR, intptr_type, + addr_high_1, shifts); +- tree off1 = gimplify_build2 (gsi, MINUS_EXPR, long_integer_type_node, ++ tree off1 = gimplify_build2 (gsi, MINUS_EXPR, intptr_type, + ptr1_cvt, bucket_start_1); + /* off2 = (intptr_t)ptr2 - (addr_high_2 << shifts) */ +- tree bucket_start_2 = gimplify_build2 (gsi, LSHIFT_EXPR, pointer_type, ++ tree bucket_start_2 = gimplify_build2 (gsi, LSHIFT_EXPR, intptr_type, + addr_high_2, shifts); +- tree off2 = gimplify_build2 (gsi, MINUS_EXPR, long_integer_type_node, ++ tree off2 = gimplify_build2 (gsi, MINUS_EXPR, intptr_type, + ptr2_cvt, bucket_start_2); + /* group_diff = (addr_high_1 - addr_high_2) / bucket_parts */ +- tree bucket_sub = gimplify_build2 (gsi, MINUS_EXPR, long_integer_type_node, ++ tree bucket_sub = gimplify_build2 (gsi, MINUS_EXPR, intptr_type, + addr_high_1, addr_high_2); +- tree bucket_parts = build_int_cst (long_integer_type_node, +- type->bucket_parts); +- tree group_diff = gimplify_build2 (gsi, TRUNC_DIV_EXPR, +- long_integer_type_node, ++ tree bucket_parts = build_int_cst (intptr_type, type->bucket_parts); ++ tree group_diff = gimplify_build2 (gsi, TRUNC_DIV_EXPR, intptr_type, + bucket_sub, bucket_parts); + /* off_addr_diff = off1 - off2 */ +- tree off_addr_diff = gimplify_build2 (gsi, MINUS_EXPR, long_integer_type_node, ++ tree off_addr_diff = gimplify_build2 (gsi, MINUS_EXPR, intptr_type, + off1, off2); + /* res = group_diff * bucket_capacity + off_diff / 8 */ ++ /* TODO: add info about magic numbers relayout_part_size/8 and 8. */ + tree capacity = build_int_cst (long_integer_type_node, + relayout_part_size / 8); + tree unit_size = build_int_cst (long_integer_type_node, 8); +- tree bucket_index_diff = gimplify_build2 (gsi, MULT_EXPR, +- long_integer_type_node, ++ tree bucket_index_diff = gimplify_build2 (gsi, MULT_EXPR, intptr_type, + group_diff, capacity); +- tree off_index = gimplify_build2 (gsi, TRUNC_DIV_EXPR, +- long_integer_type_node, ++ tree off_index = gimplify_build2 (gsi, TRUNC_DIV_EXPR, intptr_type, + off_addr_diff, unit_size); +- tree res = gimplify_build2 (gsi, PLUS_EXPR, long_unsigned_type_node, ++ tree res = gimplify_build2 (gsi, PLUS_EXPR, intptr_type, + bucket_index_diff, off_index); + return res; + } +@@ -7071,31 +7083,34 @@ basic_block + create_bb_for_group_diff_ne_0 (basic_block new_bb, tree &phi, tree ptr, + tree group_diff, tree off_times_8, srtype *type) + { +- tree shifts = build_int_cst (long_unsigned_type_node, semi_relayout_align); ++ tree intptr_type = signed_type_for (long_unsigned_type_node); ++ tree shifts = build_int_cst (intptr_type, semi_relayout_align); + gimple_stmt_iterator gsi = gsi_last_bb (new_bb); + gsi_insert_after (&gsi, gimple_build_nop (), GSI_NEW_STMT); +- /* curr_group_start = (ptr >> shifts) << shifts; */ +- tree ptr_r_1 = gimplify_build2 (&gsi, RSHIFT_EXPR, long_integer_type_node, +- ptr, shifts); +- tree curr_group_start = gimplify_build2 (&gsi, LSHIFT_EXPR, long_integer_type_node, ++ tree ptr_cvt = fold_convert (intptr_type, ptr); ++ /* intptr_t curr_group_start = ((intptr_t) ptr >> shifts) << shifts; */ ++ tree ptr_r_1 = gimplify_build2 (&gsi, RSHIFT_EXPR, intptr_type, ++ ptr_cvt, shifts); ++ tree curr_group_start = gimplify_build2 (&gsi, LSHIFT_EXPR, intptr_type, + ptr_r_1, shifts); +- /* curr_off_from_group = ptr - curr_group_start; */ +- tree curr_off_from_group = gimplify_build2 (&gsi, MINUS_EXPR, +- long_integer_type_node, +- ptr, curr_group_start); ++ /* intptr_t curr_off_from_group = (intptr_t)ptr - curr_group_start; */ ++ tree curr_off_from_group = gimplify_build2 (&gsi, MINUS_EXPR, intptr_type, ++ ptr_cvt, curr_group_start); + /* res = curr_group_start + ((group_diff * parts) << shifts) + + ((curr_off_from_group + off_times_8) % shifts); */ + tree step1 = gimplify_build2 (&gsi, MULT_EXPR, long_integer_type_node, + group_diff, build_int_cst ( + long_integer_type_node, type->bucket_parts)); +- tree step2 = gimplify_build2 (&gsi, LSHIFT_EXPR, long_integer_type_node, +- step1, shifts); +- tree step3 = gimplify_build2 (&gsi, PLUS_EXPR, long_integer_type_node, +- curr_off_from_group, off_times_8); +- tree step4 = gimplify_build2 (&gsi, TRUNC_MOD_EXPR, long_integer_type_node, +- step3, build_int_cst ( +- long_integer_type_node, relayout_part_size)); +- tree step5 = gimplify_build2 (&gsi, PLUS_EXPR, long_integer_type_node, ++ tree step1_cvt = fold_convert (intptr_type, step1); ++ tree step2 = gimplify_build2 (&gsi, LSHIFT_EXPR, intptr_type, ++ step1_cvt, shifts); ++ tree off_times_8_cvt = fold_convert (intptr_type, off_times_8); ++ tree step3 = gimplify_build2 (&gsi, PLUS_EXPR, intptr_type, ++ curr_off_from_group, off_times_8_cvt); ++ tree step4 = gimplify_build2 (&gsi, TRUNC_MOD_EXPR, intptr_type, ++ step3, build_int_cst (intptr_type, ++ relayout_part_size)); ++ tree step5 = gimplify_build2 (&gsi, PLUS_EXPR, intptr_type, + step2, step4); + tree res_phi1 = gimplify_build2 (&gsi, PLUS_EXPR, long_integer_type_node, + curr_group_start, step5); +@@ -7350,14 +7365,22 @@ ipa_struct_reorg::relayout_field_copy (gimple_stmt_iterator *gsi, gimple *stmt, + continue; + new_l_mem_ref = rewrite_address (lhs_base_pointer, field, type, gsi); + new_r_mem_ref = rewrite_address (rhs_base_pointer, field, type, gsi); ++ if (!is_gimple_reg (new_l_mem_ref)) ++ { ++ tree tmp_reg = create_tmp_reg(TREE_TYPE(new_l_mem_ref)); ++ gimple *copy_stmt = gimple_build_assign (tmp_reg, new_r_mem_ref); ++ gsi_insert_before (gsi, copy_stmt, GSI_SAME_STMT); ++ new_r_mem_ref = tmp_reg; ++ } + gimple *new_stmt = gimple_build_assign (new_l_mem_ref, new_r_mem_ref); + gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT); + } ++ gcc_assert (new_l_mem_ref != NULL_TREE && new_r_mem_ref != NULL_TREE); + newlhs = new_l_mem_ref; + newrhs = new_r_mem_ref; + } + +-void ++bool + ipa_struct_reorg::do_semi_relayout (gimple_stmt_iterator *gsi, gimple *stmt, + tree &newlhs, tree &newrhs) + { +@@ -7374,7 +7397,10 @@ ipa_struct_reorg::do_semi_relayout (gimple_stmt_iterator *gsi, gimple *stmt, + if (!l && !r) + { + if (check_sr_copy (stmt)) +- relayout_field_copy (gsi, stmt, lhs, rhs, newlhs, newrhs); ++ { ++ relayout_field_copy (gsi, stmt, lhs, rhs, newlhs, newrhs); ++ return true; ++ } + } + else if (l) + { +@@ -7396,6 +7422,7 @@ ipa_struct_reorg::do_semi_relayout (gimple_stmt_iterator *gsi, gimple *stmt, + gsi, TREE_OPERAND (newrhs, 0), type); + newrhs = rewrite_address (pointer_base, new_field, type, gsi); + } ++ return false; + } + + bool +@@ -7628,7 +7655,7 @@ ipa_struct_reorg::rewrite_assign (gassign *stmt, gimple_stmt_iterator *gsi) + + if (dump_file && (dump_flags & TDF_DETAILS)) + { +- fprintf (dump_file, "\nrewriting stamtenet:\n"); ++ fprintf (dump_file, "\nrewriting statement:\n"); + print_gimple_stmt (dump_file, stmt, 0); + } + tree newlhs[max_split]; +@@ -7644,19 +7671,24 @@ ipa_struct_reorg::rewrite_assign (gassign *stmt, gimple_stmt_iterator *gsi) + fprintf (dump_file, "replaced with:\n"); + for (unsigned i = 0; i < max_split && (newlhs[i] || newrhs[i]); i++) + { ++ bool fields_copied = false; + if (current_layout_opt_level & SEMI_RELAYOUT) +- do_semi_relayout (gsi, stmt, newlhs[i], newrhs[i]); ++ fields_copied = do_semi_relayout (gsi, stmt, newlhs[i], newrhs[i]); + if (current_layout_opt_level >= POINTER_COMPRESSION_SAFE) + try_rewrite_with_pointer_compression (stmt, gsi, lhs, rhs, + newlhs[i], newrhs[i]); +- gimple *newstmt = gimple_build_assign (newlhs[i] ? newlhs[i] : lhs, newrhs[i] ? newrhs[i] : rhs); ++ remove = true; ++ if (fields_copied) ++ continue; ++ tree lhs_expr = newlhs[i] ? newlhs[i] : lhs; ++ tree rhs_expr = newrhs[i] ? newrhs[i] : rhs; ++ gimple *newstmt = gimple_build_assign (lhs_expr, rhs_expr); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + print_gimple_stmt (dump_file, newstmt, 0); + fprintf (dump_file, "\n"); + } + gsi_insert_before (gsi, newstmt, GSI_SAME_STMT); +- remove = true; + } + return remove; + } +-- +2.27.0 + diff --git a/0140-Fix-an-error-in-memory-allocation-deallocation.patch b/0140-Fix-an-error-in-memory-allocation-deallocation.patch new file mode 100644 index 0000000..8ee94a5 --- /dev/null +++ b/0140-Fix-an-error-in-memory-allocation-deallocation.patch @@ -0,0 +1,53 @@ +From 0f6bfc8b3b95065927fc26fb1bb20afb9672e744 Mon Sep 17 00:00:00 2001 +From: Diachkov Ilia +Date: Thu, 8 Dec 2022 04:36:01 +0800 +Subject: [PATCH 25/26] Fix an error in memory allocation/deallocation + +--- + gcc/symbol-summary.h | 21 ++++++++------------- + 1 file changed, 8 insertions(+), 13 deletions(-) + +diff --git a/gcc/symbol-summary.h b/gcc/symbol-summary.h +index 1e7341b24..2f7b1a348 100644 +--- a/gcc/symbol-summary.h ++++ b/gcc/symbol-summary.h +@@ -59,15 +59,15 @@ protected: + /* Allocates new data that are stored within map. */ + T* allocate_new () + { +- /* In structure optimizatons, we call new to ensure that +- the allocated memory is initialized to 0. */ +- if (flag_ipa_struct_reorg) +- return is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T () +- : new T (); + /* Call gcc_internal_because we do not want to call finalizer for + a type T. We call dtor explicitly. */ +- return is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T () +- : m_allocator.allocate () ; ++ T* allocated = is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T () ++ : m_allocator.allocate (); ++ /* In structure optimizatons, we call memset to ensure that ++ the allocated memory is initialized to 0. */ ++ if (flag_ipa_struct_layout || flag_ipa_struct_reorg) ++ memset (allocated, 0, sizeof (T)); ++ return allocated; + } + + /* Release an item that is stored within map. */ +@@ -76,12 +76,7 @@ protected: + if (is_ggc ()) + ggc_delete (item); + else +- { +- if (flag_ipa_struct_reorg) +- delete item; +- else +- m_allocator.remove (item); +- } ++ m_allocator.remove (item); + } + + /* Unregister all call-graph hooks. */ +-- +2.27.0 + diff --git a/0141-Fix-warnings-and-errors-with-debug-prints.patch b/0141-Fix-warnings-and-errors-with-debug-prints.patch new file mode 100644 index 0000000..a363e5a --- /dev/null +++ b/0141-Fix-warnings-and-errors-with-debug-prints.patch @@ -0,0 +1,153 @@ +From b5a3bfe92f96cd0d2224d80ac4eaa80dab1bd6bf Mon Sep 17 00:00:00 2001 +From: Diachkov Ilia +Date: Thu, 22 Dec 2022 16:10:46 +0800 +Subject: [PATCH 26/26] Fix warnings and errors with debug prints + +--- + gcc/ipa-struct-reorg/ipa-struct-reorg.c | 37 +++++++++++++++---------- + gcc/symbol-summary.h | 2 +- + 2 files changed, 24 insertions(+), 15 deletions(-) + +diff --git a/gcc/ipa-struct-reorg/ipa-struct-reorg.c b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +index 068678b15..d87024df0 100644 +--- a/gcc/ipa-struct-reorg/ipa-struct-reorg.c ++++ b/gcc/ipa-struct-reorg/ipa-struct-reorg.c +@@ -1203,7 +1203,7 @@ srfunction::create_new_decls (void) + else if (TREE_CODE (decls[i]->decl) == PARM_DECL) + ; + else +- internal_error ("Unhandled decl type stored"); ++ internal_error ("Unhandled declaration type stored"); + + if (dump_file && (dump_flags & TDF_DETAILS)) + { +@@ -1759,7 +1759,8 @@ ipa_struct_relayout::rewrite (void) + } + + bool +-ipa_struct_relayout::rewrite_debug (gimple *stmt, gimple_stmt_iterator *gsi) ++ipa_struct_relayout::rewrite_debug (gimple *stmt ATTRIBUTE_UNUSED, ++ gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED) + { + /* Delete debug gimple now. */ + return true; +@@ -2079,7 +2080,6 @@ bool + ipa_struct_relayout::maybe_rewrite_cst (tree cst, gimple_stmt_iterator *gsi, + HOST_WIDE_INT ×) + { +- bool ret = false; + gcc_assert (TREE_CODE (cst) == INTEGER_CST); + + gimple *stmt = gsi_stmt (*gsi); +@@ -7166,7 +7166,7 @@ create_bb_for_group_diff_ne_0 (basic_block new_bb, tree &phi, tree ptr, + } + + tree +-ipa_struct_reorg::rewrite_pointer_plus_integer (gimple *stmt, ++ipa_struct_reorg::rewrite_pointer_plus_integer (gimple *stmt ATTRIBUTE_UNUSED, + gimple_stmt_iterator *gsi, + tree ptr, tree offset, + srtype *type) +@@ -7348,8 +7348,9 @@ ipa_struct_reorg::check_sr_copy (gimple *stmt) + } + + void +-ipa_struct_reorg::relayout_field_copy (gimple_stmt_iterator *gsi, gimple *stmt, +- tree lhs, tree rhs, ++ipa_struct_reorg::relayout_field_copy (gimple_stmt_iterator *gsi, ++ gimple *stmt ATTRIBUTE_UNUSED, ++ tree lhs, tree rhs ATTRIBUTE_UNUSED, + tree &newlhs, tree &newrhs) + { + srtype *type = get_relayout_candidate_type (TREE_TYPE (lhs)); +@@ -7724,8 +7725,6 @@ void + ipa_struct_reorg::record_allocated_size (tree ptr, gimple_stmt_iterator *gsi, + tree size) + { +- tree to_type = build_pointer_type (long_unsigned_type_node); +- tree type_cast = fold_convert (to_type, ptr); + tree lhs = fold_build2 (MEM_REF, long_unsigned_type_node, ptr, + build_int_cst (build_pointer_type (long_unsigned_type_node), 0)); + gimple *stmt = gimple_build_assign (lhs, size); +@@ -8084,7 +8083,8 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi) + old statement is to be removed. */ + + bool +-ipa_struct_reorg::rewrite_cond (gcond *stmt, gimple_stmt_iterator *gsi) ++ipa_struct_reorg::rewrite_cond (gcond *stmt, ++ gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED) + { + tree_code rhs_code = gimple_cond_code (stmt); + +@@ -8328,6 +8328,8 @@ ipa_struct_reorg::rewrite_functions (void) + if (current_function_decl) + dump_function_to_file (current_function_decl, dump_file, + dump_flags | TDF_VOPS); ++ else ++ fprintf (dump_file, " no declaration\n"); + } + pop_cfun (); + } +@@ -8360,11 +8362,13 @@ ipa_struct_reorg::rewrite_functions (void) + push_cfun (DECL_STRUCT_FUNCTION (node->decl)); + if (dump_file && (dump_flags & TDF_DETAILS)) + { +- fprintf (dump_file, "==== Before create decls: %dth_%s ====\n\n", ++ fprintf (dump_file, "==== Before create decls: %dth %s ====\n\n", + i, f->node->name ()); + if (current_function_decl) + dump_function_to_file (current_function_decl, dump_file, + dump_flags | TDF_VOPS); ++ else ++ fprintf (dump_file, " no declaration\n"); + } + pop_cfun (); + } +@@ -8396,11 +8400,13 @@ ipa_struct_reorg::rewrite_functions (void) + + if (dump_file && (dump_flags & TDF_DETAILS)) + { +- fprintf (dump_file, "\nBefore rewrite: %dth_%s\n", ++ fprintf (dump_file, "\nBefore rewrite: %dth %s\n", + i, f->node->name ()); + if (current_function_decl) + dump_function_to_file (current_function_decl, dump_file, + dump_flags | TDF_VOPS); ++ else ++ fprintf (dump_file, " no declaration\n"); + fprintf (dump_file, "\n======== Start to rewrite: %dth_%s ========\n", + i, f->node->name ()); + } +@@ -8475,10 +8481,13 @@ ipa_struct_reorg::rewrite_functions (void) + + if (dump_file) + { +- fprintf (dump_file, "\nAfter rewrite: %dth_%s\n", ++ fprintf (dump_file, "\nAfter rewrite: %dth %s\n", + i, f->node->name ()); +- dump_function_to_file (current_function_decl, dump_file, +- dump_flags | TDF_VOPS); ++ if (current_function_decl) ++ dump_function_to_file (current_function_decl, dump_file, ++ dump_flags | TDF_VOPS); ++ else ++ fprintf (dump_file, " no declaration\n"); + } + + pop_cfun (); +diff --git a/gcc/symbol-summary.h b/gcc/symbol-summary.h +index 2f7b1a348..ce13eb340 100644 +--- a/gcc/symbol-summary.h ++++ b/gcc/symbol-summary.h +@@ -65,7 +65,7 @@ protected: + : m_allocator.allocate (); + /* In structure optimizatons, we call memset to ensure that + the allocated memory is initialized to 0. */ +- if (flag_ipa_struct_layout || flag_ipa_struct_reorg) ++ if (flag_ipa_struct_reorg) + memset (allocated, 0, sizeof (T)); + return allocated; + } +-- +2.27.0 + diff --git a/gcc.spec b/gcc.spec index 2d6831d..f1cd95e 100644 --- a/gcc.spec +++ b/gcc.spec @@ -61,7 +61,7 @@ Summary: Various compilers (C, C++, Objective-C, ...) Name: gcc Version: %{gcc_version} -Release: 38 +Release: 39 License: GPLv3+ and GPLv3+ with exceptions and GPLv2+ with exceptions and LGPLv2+ and BSD URL: https://gcc.gnu.org @@ -230,6 +230,25 @@ Patch119: 0119-aarch64-Simplif-yprobe-of-final-frame-allocation.patch Patch120: 0120-aarch64-Explicitly-record-probe-registers-in-frame-info.patch Patch121: 0121-aarch64-Remove-below_hard_fp_saved_regs_size.patch Patch122: 0122-aarch64-Make-stack-smash-canary-protect-saved-registers.patch +Patch123: 0123-DFE-Fix-internal-compiler-error-with-fipa-struct-reo.patch +Patch124: 0124-tree-vect-generic-Tweak-build_replicated_const-PR949.patch +Patch125: 0125-tree-vect-generic-Fix-bitfield-widths-PR94980-3-3.patch +Patch126: 0126-Lower-VEC_COND_EXPR-into-internal-functions.patch +Patch127: 0127-Add-missing-check-for-gassign.patch +Patch128: 0128-Amend-match.pd-syntax-with-force-simplified-results.patch +Patch129: 0129-Make-genmatch-transform-failure-handling-more-consis.patch +Patch130: 0130-VEC_COND_EXPR-optimizations.patch +Patch131: 0131-aarch64-Remove-XFAILs-for-two-SVE-tests.patch +Patch132: 0132-testsuite-Fix-up-pr99305.C-test-on-unsigned_char-tar.patch +Patch133: 0133-match.pd-Fix-sve-vcond_3.c.patch +Patch134: 0134-Fix-PR-100925-Limit-some-a-CST1-CST2-optimizations-t.patch +Patch135: 0135-tree-optimization-PR102622-wrong-code-due-to-signed-.patch +Patch136: 0136-Fix-tree-optimization-103152-Still-one-more-signed1b.patch +Patch137: 0137-DFE-Fix-unexpected-struct-function-pointer-eliminati.patch +Patch138: 0138-Fix-ICE-bugs-in-transpose-test-cases-with-vector-ind.patch +Patch139: 0139-Fix-errors-on-testsuite-c-c-tests-and-505.mcf_r.patch +Patch140: 0140-Fix-an-error-in-memory-allocation-deallocation.patch +Patch141: 0141-Fix-warnings-and-errors-with-debug-prints.patch %global gcc_target_platform %{_arch}-linux-gnu @@ -805,6 +824,25 @@ not stable, so plugins must be rebuilt any time GCC is updated. %patch120 -p1 %patch121 -p1 %patch122 -p1 +%patch123 -p1 +%patch124 -p1 +%patch125 -p1 +%patch126 -p1 +%patch127 -p1 +%patch128 -p1 +%patch129 -p1 +%patch130 -p1 +%patch131 -p1 +%patch132 -p1 +%patch133 -p1 +%patch134 -p1 +%patch135 -p1 +%patch136 -p1 +%patch137 -p1 +%patch138 -p1 +%patch139 -p1 +%patch140 -p1 +%patch141 -p1 %build @@ -2829,6 +2867,12 @@ end %doc rpm.doc/changelogs/libcc1/ChangeLog* %changelog +* Wed Nov 29 2023 Mingchuan Wu - 10.3.1-39 +- Type:Spec +- ID:NA +- SUG:NA +- DESC: Sync patch from openeuler/gcc + * Tue Oct 10 2023 Xiong Zhou - 10.3.1-38 - Type:Backport - ID:NA -- Gitee