From 9fc9573f9a5e9432e53c7de93985cfbd267f0309 Mon Sep 17 00:00:00 2001 From: Joel Hutton Date: Thu, 19 Nov 2020 10:39:38 +0000 Subject: [2/3] [vect] Add widening add, subtract patterns Add widening add, subtract patterns to tree-vect-patterns. Update the widened code of patterns that detect PLUS_EXPR to also detect WIDEN_PLUS_EXPR. These patterns take 2 vectors with N elements of size S and perform an add/subtract on the elements, storing the results as N elements of size 2*S (in 2 result vectors). This is implemented in the aarch64 backend as addl,addl2 and subl,subl2 respectively. Add aarch64 tests for patterns. gcc/ChangeLog: * doc/generic.texi: Document new widen_plus/minus_lo/hi tree codes. * doc/md.texi: Document new widenening add/subtract hi/lo optabs. * expr.c (expand_expr_real_2): Add widen_add, widen_subtract cases. * optabs-tree.c (optab_for_tree_code): Add case for widening optabs. * optabs.def (OPTAB_D): Define vectorized widen add, subtracts. * tree-cfg.c (verify_gimple_assign_binary): Add case for widening adds, subtracts. * tree-inline.c (estimate_operator_cost): Add case for widening adds, subtracts. * tree-vect-generic.c (expand_vector_operations_1): Add case for widening adds, subtracts * tree-vect-patterns.c (vect_recog_widen_add_pattern): New recog pattern. (vect_recog_widen_sub_pattern): New recog pattern. (vect_recog_average_pattern): Update widened add code. (vect_recog_average_pattern): Update widened add code. * tree-vect-stmts.c (vectorizable_conversion): Add case for widened add, subtract. (supportable_widening_operation): Add case for widened add, subtract. * tree.def (WIDEN_PLUS_EXPR): New tree code. (WIDEN_MINUS_EXPR): New tree code. (VEC_WIDEN_ADD_HI_EXPR): New tree code. (VEC_WIDEN_PLUS_LO_EXPR): New tree code. (VEC_WIDEN_MINUS_HI_EXPR): New tree code. (VEC_WIDEN_MINUS_LO_EXPR): New tree code. gcc/testsuite/ChangeLog: * gcc.target/aarch64/vect-widen-add.c: New test. * gcc.target/aarch64/vect-widen-sub.c: New test. --- gcc/expr.c | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'gcc/expr.c') diff --git a/gcc/expr.c b/gcc/expr.c index ae16f07..83aa63c 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -9034,6 +9034,8 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode, target, unsignedp); return target; + case WIDEN_PLUS_EXPR: + case WIDEN_MINUS_EXPR: case WIDEN_MULT_EXPR: /* If first operand is constant, swap them. Thus the following special case checks need only @@ -9754,6 +9756,10 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode, return temp; } + case VEC_WIDEN_PLUS_HI_EXPR: + case VEC_WIDEN_PLUS_LO_EXPR: + case VEC_WIDEN_MINUS_HI_EXPR: + case VEC_WIDEN_MINUS_LO_EXPR: case VEC_WIDEN_MULT_HI_EXPR: case VEC_WIDEN_MULT_LO_EXPR: case VEC_WIDEN_MULT_EVEN_EXPR: -- cgit v1.1 From 1e2d8575ace4e12dbe95ae2d4a49a4d89c6f67eb Mon Sep 17 00:00:00 2001 From: Aaron Sawdey Date: Tue, 17 Nov 2020 17:17:44 -0600 Subject: Additional small changes to support opaque modes After building some larger codes using opaque types and some c++ codes using opaque types it became clear I needed to go through and look for places where opaque types and modes needed to be handled. A whole pile of one-liners. gcc/ * typeclass.h: Add opaque_type_class. * builtins.c (type_to_class): Identify opaque type class. * dwarf2out.c (is_base_type): Handle opaque types. (gen_type_die_with_usage): Handle opaque types. * expr.c (count_type_elements): Opaque types should never have initializers. * ipa-devirt.c (odr_types_equivalent_p): No type-specific handling for opaque types is needed as it eventually checks the underlying mode which is what is important. * tree-streamer.c (record_common_node): Handle opaque types. * tree.c (type_contains_placeholder_1): Handle opaque types. (type_cache_hasher::equal): No additional comparison needed for opaque types. gcc/c-family * c-pretty-print.c (c_pretty_printer::simple_type_specifier): Treat opaque types like other types. (c_pretty_printer::direct_abstract_declarator): Opaque types are supported types. gcc/c * c-aux-info.c (gen_type): Support opaque types. gcc/cp * error.c (dump_type): Handle opaque types. (dump_type_prefix): Handle opaque types. (dump_type_suffix): Handle opaque types. (dump_expr): Handle opaque types. * pt.c (tsubst): Allow opaque types in templates. (unify): Allow opaque types in templates. * typeck.c (structural_comptypes): Handle comparison of opaque types. --- gcc/expr.c | 1 + 1 file changed, 1 insertion(+) (limited to 'gcc/expr.c') diff --git a/gcc/expr.c b/gcc/expr.c index 83aa63c..25e93b6 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -6171,6 +6171,7 @@ count_type_elements (const_tree type, bool for_ctor_p) return 0; case VOID_TYPE: + case OPAQUE_TYPE: case METHOD_TYPE: case FUNCTION_TYPE: case LANG_TYPE: -- cgit v1.1 From e34153b0e230bc0a8b9a3f5db1d46a67cbb51788 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Wed, 2 Dec 2020 11:33:33 +0100 Subject: expansion: Fix up infinite recursion due to double-word modulo optimization Jeff has reported that my earlier patch broke rl78-elf, e.g. with unsigned short foo (unsigned short x) { return x % 7; } when compiled with -O2 -mg14. The problem is that rl78 is a BITS_PER_WORD == 8 target which doesn't have 8-bit modulo or divmod optab, but has instead 16-bit divmod, so my patch attempted to optimize it, then called expand_divmod to do 8-bit modulo and that in turn tried to do 16-bit modulo again. The following patch fixes it in two ways. One is to not perform the optimization when we have {u,s}divmod_optab handler for the double-word mode, in that case it is IMHO better to just do whatever we used to do before. This alone should fix the infinite recursion. But I'd be afraid some other target might have similar problem and might not have a divmod pattern, but only say a library call. So the patch also introduces a methods argument to expand_divmod such that normally we allow everything that was allowed before (using libcalls and widening), but when called from these expand_doubleword*mod routines we restrict it to no widening and no libcalls. 2020-12-02 Jakub Jelinek * expmed.h (expand_divmod): Only declare if GCC_OPTABS_H is defined. Add enum optabs_method argument defaulted to OPTAB_LIB_WIDEN. * expmed.c: Include expmed.h after optabs.h. (expand_divmod): Add methods argument, if it is not OPTAB_{,LIB_}WIDEN, don't choose a wider mode, and pass it to other calls instead of hardcoded OPTAB_LIB_WIDEN. Avoid emitting libcalls if not OPTAB_LIB or OPTAB_LIB_WIDEN. * optabs.c: Include expmed.h after optabs.h. (expand_doubleword_mod, expand_doubleword_divmod): Pass OPTAB_DIRECT as last argument to expand_divmod. (expand_binop): Punt if {s,u}divmod_optab has handler for double-word int_mode. * expr.c: Include expmed.h after optabs.h. * explow.c: Include expmed.h after optabs.h. --- gcc/expr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'gcc/expr.c') diff --git a/gcc/expr.c b/gcc/expr.c index 25e93b6..798285e 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -29,8 +29,8 @@ along with GCC; see the file COPYING3. If not see #include "memmodel.h" #include "tm_p.h" #include "ssa.h" -#include "expmed.h" #include "optabs.h" +#include "expmed.h" #include "regs.h" #include "emit-rtl.h" #include "recog.h" -- cgit v1.1