Projects
openEuler:24.03:SP1:Everything
gcc
_service:tar_scm:0102-Add-Crc32-Optimization-in...
Sign Up
Log In
Username
Password
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File _service:tar_scm:0102-Add-Crc32-Optimization-in-Gzip-For-crc32-algorithm-i.patch of Package gcc
From 8fa9788ac64a9ea5dc92c61c8f2ec11075cd17ec Mon Sep 17 00:00:00 2001 From: XingYushuai <xingyushuai@huawei.com> Date: Thu, 15 Dec 2022 14:34:16 +0800 Subject: [PATCH 003/157] Add Crc32 Optimization in Gzip For crc32 algorithm in APBC int_gzip. Match crc32 lookup table algorithm. An example for crc32 lookup table elg: ```c do { c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8); } while (--n); Usage: `gcc -O3 -march=armv8.1-a -floop-crc yourfile.c` Node: The cpu you use needs to support the crc32 instructions --- gcc/Makefile.in | 1 + gcc/common.opt | 4 + gcc/config/aarch64/aarch64-builtins.cc | 30 + gcc/config/aarch64/aarch64-protos.h | 1 + gcc/config/aarch64/aarch64.cc | 12 + gcc/doc/invoke.texi | 6 +- gcc/doc/tm.texi | 9 + gcc/doc/tm.texi.in | 2 + gcc/match.pd | 23 + gcc/passes.def | 1 + gcc/target.def | 14 + .../tree-ssa/loop-crc-loop-condition-fail.c | 85 ++ .../tree-ssa/loop-crc-loop-form-fail-2.c | 90 ++ .../gcc.dg/tree-ssa/loop-crc-loop-form-fail.c | 112 ++ .../gcc.dg/tree-ssa/loop-crc-sucess.c | 83 + .../tree-ssa/loop-crc-table-check-fail.c | 114 ++ gcc/timevar.def | 1 + gcc/tree-pass.h | 1 + gcc/tree-ssa-loop-crc.cc | 1333 +++++++++++++++++ 19 files changed, 1921 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-condition-fail.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-form-fail-2.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-form-fail.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-crc-sucess.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-crc-table-check-fail.c create mode 100644 gcc/tree-ssa-loop-crc.cc diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 5cd838270..2b9f025dc 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1649,6 +1649,7 @@ OBJS = \ tree-ssa-ifcombine.o \ tree-ssa-live.o \ tree-ssa-loop-ch.o \ + tree-ssa-loop-crc.o \ tree-ssa-loop-im.o \ tree-ssa-loop-ivcanon.o \ tree-ssa-loop-ivopts.o \ diff --git a/gcc/common.opt b/gcc/common.opt index b18f0b944..42fb2fc19 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -1119,6 +1119,10 @@ fcrypto-accel-aes Common Var(flag_crypto_accel_aes) Init(0) Optimization Perform crypto acceleration AES pattern matching. +floop-crc +Common Var(flag_loop_crc) Optimization +Do the loop crc conversion. + fauto-inc-dec Common Var(flag_auto_inc_dec) Init(1) Optimization Generate auto-inc/dec instructions. diff --git a/gcc/config/aarch64/aarch64-builtins.cc b/gcc/config/aarch64/aarch64-builtins.cc index 42276e7ca..3b952ef39 100644 --- a/gcc/config/aarch64/aarch64-builtins.cc +++ b/gcc/config/aarch64/aarch64-builtins.cc @@ -551,6 +551,12 @@ typedef struct #define VAR1(T, N, MAP, FLAG, A) \ AARCH64_SIMD_BUILTIN_##T##_##N##A, +enum aarch64_crc_builtins{ + AARCH64_BUILTIN_CRC32B, + AARCH64_BUILTIN_CRC32H, + AARCH64_BUILTIN_CRC32W, +}; + enum aarch64_builtins { AARCH64_BUILTIN_MIN, @@ -1812,6 +1818,30 @@ aarch64_general_builtin_decl (unsigned code, bool) return aarch64_builtin_decls[code]; } +/* Implement TARGET_GET_CRC_BUILTIN_CODE */ +unsigned +get_crc_builtin_code(unsigned code, bool) +{ + if (code > AARCH64_BUILTIN_CRC32W) + return AARCH64_BUILTIN_MIN; + + unsigned res = AARCH64_BUILTIN_MIN; + switch (code) { + case AARCH64_BUILTIN_CRC32B: + res = AARCH64_BUILTIN_crc32b; + break; + case AARCH64_BUILTIN_CRC32H: + res = AARCH64_BUILTIN_crc32h; + break; + case AARCH64_BUILTIN_CRC32W: + res = AARCH64_BUILTIN_crc32w; + break; + default: + break; + } + return res; +} + typedef enum { SIMD_ARG_COPY_TO_REG, diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h index 475d174dd..853197ee9 100644 --- a/gcc/config/aarch64/aarch64-protos.h +++ b/gcc/config/aarch64/aarch64-protos.h @@ -994,6 +994,7 @@ gimple *aarch64_general_gimple_fold_builtin (unsigned int, gcall *, gimple_stmt_iterator *); rtx aarch64_general_expand_builtin (unsigned int, tree, rtx, int); tree aarch64_general_builtin_decl (unsigned, bool); +unsigned get_crc_builtin_code(unsigned , bool); tree aarch64_general_builtin_rsqrt (unsigned int); tree aarch64_builtin_vectorized_function (unsigned int, tree, tree); void handle_arm_acle_h (void); diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 5537a537c..280e0b618 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -15210,6 +15210,15 @@ aarch64_builtin_decl (unsigned int code, bool initialize_p) gcc_unreachable (); } +/* Implement TARGET_GET_CRC_BUILTIN_CODE. */ +static unsigned +aarch64_get_crc_builtin_code(unsigned code, bool initialize_p) +{ + unsigned subcode = get_crc_builtin_code(code,initialize_p); + unsigned res = subcode << AARCH64_BUILTIN_SHIFT; + return res; +} + /* Return true if it is safe and beneficial to use the approximate rsqrt optabs to optimize 1.0/sqrt. */ @@ -27677,6 +27686,9 @@ aarch64_get_v16qi_mode () #undef TARGET_BUILTIN_DECL #define TARGET_BUILTIN_DECL aarch64_builtin_decl +#undef TARGET_GET_CRC_BUILTIN_CODE +#define TARGET_GET_CRC_BUILTIN_CODE aarch64_get_crc_builtin_code + #undef TARGET_BUILTIN_RECIPROCAL #define TARGET_BUILTIN_RECIPROCAL aarch64_builtin_reciprocal diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 7ca60dd64..c3ce148b0 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -537,7 +537,7 @@ Objective-C and Objective-C++ Dialects}. -fisolate-erroneous-paths-dereference -fisolate-erroneous-paths-attribute @gol -fivopts -fkeep-inline-functions -fkeep-static-functions @gol -fkeep-static-consts -flimit-function-alignment -flive-range-shrinkage @gol --floop-block -floop-interchange -floop-strip-mine @gol +-floop-block -floop-crc -floop-interchange -floop-strip-mine @gol -floop-unroll-and-jam -floop-nest-optimize @gol -floop-parallelize-all -flra-remat -flto -flto-compression-level @gol -flto-partition=@var{alg} -fmerge-all-constants @gol @@ -12159,6 +12159,10 @@ GIMPLE -> GRAPHITE -> GIMPLE transformation. Some minimal optimizations are also performed by the code generator isl, like index splitting and dead code elimination in loops. +@item -floop-crc +@opindex floop-crc +Do the loop crc conversion + @item -floop-nest-optimize @opindex floop-nest-optimize Enable the isl based loop nest optimizer. This is a generic loop nest diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 851d31c18..5a1e0fe43 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -11658,6 +11658,15 @@ If @var{code} is out of range the function should return @code{error_mark_node}. @end deftypefn +@deftypefn {Target Hook} unsigned TARGET_GET_CRC_BUILTIN_CODE (unsigned @var{code}, bool @var{initialize_p}) +Define this hook to get crc32 builtin code. It should be a function that +returns the crc32 builtin function code @var{code}. +If there is no such builtin and it cannot be initialized at this time +if @var{initialize_p} is true the function should return @code{NULL_TREE}. +If @var{code} is out of range the function should return +@code{error_mark_node}. +@end deftypefn + @deftypefn {Target Hook} rtx TARGET_EXPAND_BUILTIN (tree @var{exp}, rtx @var{target}, rtx @var{subtarget}, machine_mode @var{mode}, int @var{ignore}) Expand a call to a machine specific built-in function that was set up by diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index ac95cdf7a..6ff0eff66 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -7704,6 +7704,8 @@ to by @var{ce_info}. @hook TARGET_BUILTIN_DECL +@hook TARGET_GET_CRC_BUILTIN_CODE + @hook TARGET_EXPAND_BUILTIN @hook TARGET_RESOLVE_OVERLOADED_BUILTIN diff --git a/gcc/match.pd b/gcc/match.pd index aee58e47b..1f42090a2 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -4409,6 +4409,29 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) ) #endif +#if GIMPLE +/* Try to match + _4 = (int) _3; NOP_EXPR (SSA_NAME @2) + _5 = _4 ^ c_10; BIT_XOR_EXPR (SSA_NAME@1, SSA_NAME) + _6 = _5 & 255; BIT_AND_EXPR (SSA_NAME, INTEGER_CST@3) +*/ +(match (crc_match_index @1 @2 @3) + (bit_and (bit_xor (nop SSA_NAME@2) SSA_NAME@1) INTEGER_CST@3) + (if (INTEGRAL_TYPE_P (type) && tree_to_uhwi(@3) == 255)) +) +#endif + +#if GIMPLE +/* Try to match + _8 = c_12 >> 8; RSHIFT_EXPR (SSA_NAME @1, INTEGER_CST @2) + c_19 = _7 ^ _8; BIT_XOR_EXPR (SSA_NAME@3, SSA_NAME) +*/ +(match (crc_match_res @1 @2 @3) + (bit_xor SSA_NAME@3 (rshift SSA_NAME@1 INTEGER_CST@2)) + (if (INTEGRAL_TYPE_P (type) && tree_to_uhwi(@2) == 8)) +) +#endif + /* Simplification moved from fold_cond_expr_with_comparison. It may also be extended. */ /* This pattern implements two kinds simplification: diff --git a/gcc/passes.def b/gcc/passes.def index cdc600298..89d6889e5 100644 --- a/gcc/passes.def +++ b/gcc/passes.def @@ -95,6 +95,7 @@ along with GCC; see the file COPYING3. If not see NEXT_PASS (pass_cd_dce, false /* update_address_taken_p */); NEXT_PASS (pass_phiopt, true /* early_p */); NEXT_PASS (pass_array_widen_compare); + NEXT_PASS (pass_loop_crc); NEXT_PASS (pass_tail_recursion); NEXT_PASS (pass_if_to_switch); NEXT_PASS (pass_convert_switch); diff --git a/gcc/target.def b/gcc/target.def index c9bb2b4c2..8abf49f0a 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -2413,6 +2413,20 @@ If @var{code} is out of range the function should return\n\ @code{error_mark_node}.", tree, (unsigned code, bool initialize_p), NULL) +/* Initialize (if INITIALIZE_P is true) and return the real code of + target-specific built-in function. + Return NULL if that is not possible. Return error_mark_node if CODE + is outside of the range of valid crc32 codes. */ +DEFHOOK +(get_crc_builtin_code, + "Define this hook to get crc32 builtin code. It should be a function that\n\ +returns the crc32 builtin function code @var{code}.\n\ +If there is no such builtin and it cannot be initialized at this time\n\ +if @var{initialize_p} is true the function should return @code{NULL_TREE}.\n\ +If @var{code} is out of range the function should return\n\ +@code{error_mark_node}.", + unsigned , (unsigned code, bool initialize_p), NULL) + /* Expand a target-specific builtin. */ DEFHOOK (expand_builtin, diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-condition-fail.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-condition-fail.c new file mode 100644 index 000000000..3620e92f7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-condition-fail.c @@ -0,0 +1,85 @@ +/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */ +/* { dg-options "-O3 -march=armv8.1-a -mabi=lp64 -floop-crc -fdump-tree-loop_crc-details" } */ + +#include <stdint.h> +#include <stddef.h> +typedef unsigned long ulg; +typedef unsigned char uch; + +static const ulg crc_32_tab[] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; + +ulg updcrc (s, n) + uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + if (n) + if (n) do { + c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8); + } while (--n || c != 0) ; + } + crc = c; +exit1: + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} +/* { dg-final { scan-tree-dump-times "Wrong loop form for crc matching." 1 "loop_crc"} } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-form-fail-2.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-form-fail-2.c new file mode 100644 index 000000000..fac759c67 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-form-fail-2.c @@ -0,0 +1,90 @@ +/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */ +/* { dg-options "-O3 -march=armv8.1-a -mabi=lp64 -floop-crc -fdump-tree-loop_crc-details" } */ + +#include <stdint.h> +#include <stddef.h> +typedef unsigned long ulg; +typedef unsigned char uch; + +static const ulg crc_32_tab[] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; +int test[5] = {0}; + +ulg updcrc (s, n) + uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + if (n) + if (n) do { + c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8); + } while (--n) ; + } + do { + c = crc_32_tab[(c ^ (*s++)) & 0xff] ^ (c >> 8); + test[c%5] = c; + } while (--n) ; + crc = c; + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} +/* { dg-final { scan-tree-dump-times "Table check fail. not only single array is read." 1 "loop_crc"} } */ +/* { dg-final { scan-tree-dump-times "Wrong crc table for crc matching." 1 "loop_crc"} } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-form-fail.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-form-fail.c new file mode 100644 index 000000000..ba9e5bb95 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-loop-form-fail.c @@ -0,0 +1,112 @@ +/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */ +/* { dg-options "-O3 -march=armv8.1-a -mabi=lp64 -floop-crc -fdump-tree-loop_crc-details" } */ + +#include <stdint.h> +#include <stddef.h> +typedef unsigned long ulg; +typedef unsigned char uch; + +static const ulg crc_32_tab[] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; + +/* check when the loop have a innor loop, should fail. */ +ulg updcrc (s, n) + uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + if (n) + do { + c = crc_32_tab[(c ^ (*s++)) & 0xff] ^ (c >> 8); + for (int i = 0; i < 5; i++) { + c++; + } + + } while (--n); + } + crc = c; + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} + +/* check when the loop have a second backedge, should fail. */ +ulg updcrc1(s, n) + uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + if (n) + do { + c = crc_32_tab[(c ^ (*s++)) & 0xff] ^ (c >> 8); + } while (--n || c != 0) ; + } + crc = c; + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} +/* { dg-final { scan-tree-dump-times "Wrong crc table for crc matching." 1 "loop_crc"} } */ +/* { dg-final { scan-tree-dump-times "Table check fail. not only single array is read." 1 "loop_crc"} } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-sucess.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-sucess.c new file mode 100644 index 000000000..dad7bdbfc --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-sucess.c @@ -0,0 +1,83 @@ +/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */ +/* { dg-options "-O3 -march=armv8.1-a -mabi=lp64 -floop-crc -fdump-tree-loop_crc-details" } */ + +#include <stdint.h> +#include <stddef.h> +typedef unsigned long ulg; +typedef unsigned char uch; + +static const ulg crc_32_tab[] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; + +ulg updcrc (s, n) + uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + if (n) do { + c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8); + } while (--n); + } + crc = c; + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} +/* { dg-final { scan-tree-dump-times "The 1th loop form is success matched,and the loop can be optimized." 1 "loop_crc"} } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-table-check-fail.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-table-check-fail.c new file mode 100644 index 000000000..523a7740c --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-crc-table-check-fail.c @@ -0,0 +1,114 @@ +/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */ +/* { dg-options "-O3 -march=armv8.1-a -mabi=lp64 -floop-crc -fdump-tree-loop_crc-details" } */ + +#include <stdint.h> +#include <stddef.h> +typedef unsigned long ulg; +typedef unsigned char uch; + +static const ulg crc_32_tab[] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf1L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; +int test[5] = {0}; + +/* check when the loop is doing more then 1 array read or writing an array, both should fail. */ +ulg updcrc (s, n) + uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + if (n) + do { + c = crc_32_tab[(c ^ (*s++)) & 0xff] ^ (c >> 8) * test[c%5]; + } while (--n) ; + } + do { + c = crc_32_tab[(c ^ (*s++)) & 0xff] ^ (c >> 8); + test[c%5] = c; + } while (--n) ; + crc = c; + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} + +/* check when the loop is not working on a correct crc_table. should fail. */ +ulg updcrc1(s, n) + uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + if (n) + do { + c = crc_32_tab[(c ^ (*s++)) & 0xff] ^ (c >> 8); + } while (--n) ; + } + crc = c; + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} +/* { dg-final { scan-tree-dump-times "Table check fail. not only single array is read." 2 "loop_crc"} } */ +/* { dg-final { scan-tree-dump-times "Wrong crc table for crc matching." 3 "loop_crc"} } */ +/* { dg-final { scan-tree-dump-times "Table check fail. Table not matching." 1 "loop_crc"} } */ diff --git a/gcc/timevar.def b/gcc/timevar.def index 8e7510eb3..8341b9ffd 100644 --- a/gcc/timevar.def +++ b/gcc/timevar.def @@ -220,6 +220,7 @@ DEFTIMEVAR (TV_TREE_COPY_RENAME , "tree rename SSA copies") DEFTIMEVAR (TV_TREE_SSA_VERIFY , "tree SSA verifier") DEFTIMEVAR (TV_TREE_STMT_VERIFY , "tree STMT verifier") DEFTIMEVAR (TV_TREE_ARRAY_WIDEN_COMPARE, "tree array widen compare") +DEFTIMEVAR (TV_TREE_LOOP_CRC , "tree loop crc") DEFTIMEVAR (TV_TREE_SWITCH_CONVERSION, "tree switch conversion") DEFTIMEVAR (TV_TREE_SWITCH_LOWERING, "tree switch lowering") DEFTIMEVAR (TV_TREE_RECIP , "gimple CSE reciprocals") diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h index 34e60bc38..6cd679e10 100644 --- a/gcc/tree-pass.h +++ b/gcc/tree-pass.h @@ -454,6 +454,7 @@ extern gimple_opt_pass *make_pass_phiopt (gcc::context *ctxt); extern gimple_opt_pass *make_pass_forwprop (gcc::context *ctxt); extern gimple_opt_pass *make_pass_phiprop (gcc::context *ctxt); extern gimple_opt_pass *make_pass_array_widen_compare (gcc::context *ctxt); +extern gimple_opt_pass *make_pass_loop_crc (gcc::context *ctxt); extern gimple_opt_pass *make_pass_tree_ifcombine (gcc::context *ctxt); extern gimple_opt_pass *make_pass_dse (gcc::context *ctxt); extern gimple_opt_pass *make_pass_nrv (gcc::context *ctxt); diff --git a/gcc/tree-ssa-loop-crc.cc b/gcc/tree-ssa-loop-crc.cc new file mode 100644 index 000000000..b9c2f71ca --- /dev/null +++ b/gcc/tree-ssa-loop-crc.cc @@ -0,0 +1,1333 @@ +/* This pass converts special loops where do CRC algorithms to + simple CRC instructions in AArch64. + Copyright (C) 2023-2023 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 3, or (at your option) any +later version. + +GCC is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "backend.h" +#include "target.h" +#include "tree.h" +#include "gimple.h" +#include "tree-pass.h" +#include "gimple-ssa.h" +#include "tree-pretty-print.h" +#include "fold-const.h" +#include "gimplify.h" +#include "gimple-iterator.h" +#include "tree-ssa-loop-manip.h" +#include "tree-ssa-loop.h" +#include "ssa.h" +#include "tree-into-ssa.h" +#include "cfganal.h" +#include "cfgloop.h" +#include "gimple-pretty-print.h" +#include "tree-cfg.h" +#include "cgraph.h" +#include "print-tree.h" +#include "cfghooks.h" +#include "gimple-fold.h" +#include "diagnostic-core.h" + +/* This pass handles scenarios similar to the following: +ulg updcrc (s, n) + uch *s; + unsigned n; +{ + register ulg c; + + static ulg crc = (ulg)0xffffffffL; + + if (s == NULL) + { + c = 0xffffffffL; + } + else + { + c = crc; + if (n) + do + { + c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8); + } while (--n); + } + crc = c; + return c ^ 0xffffffffL; +} + +If the hardware supports the crc instruction, then the pass completes the +conversion of the above scenario into: + +#define SIZE_U32 sizeof(uint32_t) +unsigned long updcrc(s, n) + unsigned char *s; + unsigned n; +{ + register unsigned long c; + + static unsigned long crc = (unsigned long)0xffffffffL; + + if (s == NULL) + { + c = 0xffffffffL; + } + else + { + c = crc; + if (n) + { + uint32_t nn = n/SIZE_U32; + do + { + c = __crc32w (c,*((uint32_t *)s)); + s += SIZE_U32; + } while(--nn); + } + } + if (n & sizeof (uint16_t)) + { + c = __crc32h (c, *((uint16_t *)s)); + s += sizeof (uint16_t); + } + if (n & sizeof (uint8_t)) + c = __crc32b (c, *s); + crc = c; + return c ^ 0xffffffffL; +} + +This pass is to complete the conversion of such scenarios from +the internal perspective of the compiler: +1) match_crc_loop: The function completes the screening of such + scenarios; +2) convert_to_new_loop: The function completes the conversion of + origin_loop to new loops, and removes origin_loop; +3) origin_loop_info: The structure is used to record important + information of origin_loop: such as loop exit, initial value + of induction variable, etc; +4) create_new_loops: The function is used as the key content + of the pass to complete the creation of new loops. */ + +extern bool gimple_crc_match_index (tree, tree *, tree (*)(tree)); +extern bool gimple_crc_match_res (tree, tree *, tree (*)(tree)); + +static gimple *crc_table_read_stmt = NULL; + +static gphi *phi_s = NULL; +static gphi *phi_c = NULL; +static tree nn_tree = NULL; + +enum aarch64_crc_builtins +{ + AARCH64_BUILTIN_CRC32B, + AARCH64_BUILTIN_CRC32H, + AARCH64_BUILTIN_CRC32W, +}; + +/* The useful information of origin loop. */ +struct origin_loop_info +{ + tree limit; /* The limit index of the array in the old loop. */ + tree base_n; /* The initial value of the old loop. */ + tree base_s; /* The initial value of the old loop. */ + tree base_c; /* The initial value of the old loop. */ + edge entry_edge; /* The edge into the old loop. */ + edge exit_edge; /* The edge outto the old loop. */ + basic_block exit_bb; +}; + +typedef struct origin_loop_info origin_loop_info; + +static origin_loop_info origin_loop; +hash_map <basic_block, tree> n_map; +hash_map <basic_block, tree> nn_map; +hash_map <basic_block, tree> s_map; +hash_map <basic_block, tree> c_map; +hash_map <basic_block, tree> crc_map; + +/* Initialize the origin_loop structure. */ +static void +init_origin_loop_structure () +{ + origin_loop.entry_edge = NULL; + origin_loop.exit_edge = NULL; + origin_loop.exit_bb = NULL; + origin_loop.limit = NULL; + origin_loop.base_n = NULL; + origin_loop.base_s = NULL; + origin_loop.base_c = NULL; +} + +/* Get the edge that first entered the loop. */ +static edge +get_loop_preheader_edge (class loop *loop) +{ + edge e; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, loop->header->preds) + if (e->src != loop->latch) + break; + + return e; +} + +/* Returns true if t is SSA_NAME and user variable exists. */ + +static bool +ssa_name_var_p (tree t) +{ + if (!t || TREE_CODE (t) != SSA_NAME) + return false; + if (SSA_NAME_VAR (t)) + return true; + return false; +} + +/* Returns true if t1 and t2 are SSA_NAME and belong to the same variable. */ + +static bool +same_ssa_name_var_p (tree t1, tree t2) +{ + if (!ssa_name_var_p (t1) || !ssa_name_var_p (t2)) + return false; + if (SSA_NAME_VAR (t1) == SSA_NAME_VAR (t2)) + return true; + return false; +} + +/* Get origin loop induction variable upper bound. */ + +static bool +get_iv_upper_bound (gimple *stmt) +{ + if (origin_loop.limit != NULL || origin_loop.base_n != NULL) + return false; + + tree lhs = gimple_cond_lhs (stmt); + tree rhs = gimple_cond_rhs (stmt); + + if (TREE_CODE (TREE_TYPE (lhs)) != INTEGER_TYPE + || TREE_CODE (TREE_TYPE (rhs)) != INTEGER_TYPE) + return false; + + /* TODO: Currently, the input restrictions on lhs and rhs are implemented + through PARM_DECL. We may consider relax the restrictions later, and + we need to consider the overall adaptation scenario and adding test + cases. */ + if (ssa_name_var_p (lhs) && TREE_CODE (SSA_NAME_VAR (lhs)) == PARM_DECL) + { + origin_loop.limit = rhs; + origin_loop.base_n = lhs; + } + else + return false; + + if (origin_loop.limit != NULL && origin_loop.base_n != NULL) + return true; + + return false; +} + +/* Get origin loop info. */ +static bool +get_origin_loop_info (class loop *loop) +{ + auto_vec<edge> edges = get_loop_exit_edges (loop); + origin_loop.exit_edge = edges[0]; + origin_loop.exit_bb = origin_loop.exit_edge->dest; + origin_loop.entry_edge = get_loop_preheader_edge (loop); + origin_loop.base_s = PHI_ARG_DEF_FROM_EDGE (phi_s,origin_loop.entry_edge); + origin_loop.base_c = PHI_ARG_DEF_FROM_EDGE (phi_c,origin_loop.entry_edge); + + basic_block preheader_bb = origin_loop.entry_edge->src; + + if (preheader_bb->preds->length () != 1) + return false; + + edge entry_pre_bb_edge = EDGE_PRED (preheader_bb, 0); + + basic_block pre_preheader_bb = entry_pre_bb_edge->src; + + gimple_stmt_iterator gsi; + gimple *stmt; + bool get_upper_bound = false; + for (gsi = gsi_start_bb (pre_preheader_bb); !gsi_end_p (gsi); gsi_next (&gsi)) + { + stmt = gsi_stmt (gsi); + if (stmt && gimple_code (stmt) == GIMPLE_COND + && get_iv_upper_bound (stmt)) + { + get_upper_bound = true; + break; + } + } + + return get_upper_bound; +} + +/* The loop form check will check the entire loop control flow + It should be a loop that: + 1. a do-while loop with header and latch only with no other control flow + inside the loop + 2. have only one exiting edge + 3. have only one back edge and one entry edge +*/ +static bool +crc_loop_form_check (class loop *loop) +{ + if (loop->num_nodes > 2 || loop->inner) + return false; + // Should only have 1 exit edge + auto_vec<edge> edges = get_loop_exit_edges (loop); + if (edges.length() != 1) + return false; + + // The header should have only 2 incoming edges + // One of them is the preheader edge and the other is the backedge from the + // latch + if (EDGE_COUNT (loop->header->preds) != 2) + return false; + edge e1 = EDGE_PRED (loop->header, 0); + edge e2 = EDGE_PRED (loop->header, 1); + + if ((e1->src == loop->latch && e2->src->loop_father != loop) + || (e2->src == loop->latch && e1->src->loop_father != loop)) + return true; + + return false; +} + +/* Check there is only one array is read in the loop. + Return the only array as crc_table. */ +static bool +only_one_array_read (class loop *loop, tree &crc_table) +{ + gimple_stmt_iterator gsi; + gimple *stmt; + bool res = false; + for (gsi = gsi_start_bb (loop->header); !gsi_end_p (gsi); gsi_next (&gsi)) + { + stmt = gsi_stmt (gsi); + if (stmt == NULL) + return false; + + if (gimple_code (stmt) == GIMPLE_ASSIGN + && TREE_CODE (gimple_assign_lhs (stmt)) == ARRAY_REF) + return false; + + /* Only one-dimensional integer arrays meet the condition. */ + if (gimple_code (stmt) == GIMPLE_ASSIGN + && TREE_CODE (gimple_assign_rhs1 (stmt)) == ARRAY_REF + && TREE_CODE (TREE_OPERAND (gimple_assign_rhs1 (stmt), 0)) == VAR_DECL + && TREE_CODE (TREE_TYPE (gimple_assign_rhs1 (stmt))) == INTEGER_TYPE) + { + if (crc_table == NULL + && TREE_READONLY (gimple_assign_rhs1 (stmt))) + { + crc_table = gimple_assign_rhs1 (stmt); + crc_table_read_stmt = stmt; + res = true; + } + else + return false; + } + } + return res; +} + +static const unsigned HOST_WIDE_INT crc_32_tab[] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; + +/* Check the content of the array. */ +static bool +match_crc_table (tree crc_table) +{ + const unsigned LOW_BOUND = 0; + const unsigned UP_BOUND = 255; + const unsigned ELEMENT_SIZE = 8; + tree low_bound = array_ref_low_bound (crc_table); + tree up_bound = array_ref_up_bound (crc_table); + tree element_size = array_ref_element_size (crc_table); + if (!tree_fits_uhwi_p(low_bound) || !tree_fits_uhwi_p(up_bound) || + !tree_fits_uhwi_p(element_size)) + return false; + unsigned HOST_WIDE_INT lb = tree_to_uhwi (low_bound); + unsigned HOST_WIDE_INT ub = tree_to_uhwi (up_bound); + unsigned HOST_WIDE_INT es = tree_to_uhwi (element_size); + if (lb != LOW_BOUND || ub != UP_BOUND || es != ELEMENT_SIZE) + return false; + + tree decl = TREE_OPERAND (crc_table, 0); + tree ctor = ctor_for_folding(decl); + for (int i = lb; i <= ub; i++) + { + unsigned HOST_WIDE_INT val = tree_to_uhwi (CONSTRUCTOR_ELT (ctor, + i)->value); + if (crc_32_tab[i] != val) + return false; + } + return true; +} + +/* Check the crc table. The loop should have only one data reference. + And match the data reference with the predefined array. */ +static bool +crc_table_check (class loop *loop) +{ + tree crc_table = NULL; + if (!only_one_array_read (loop, crc_table)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\nTable check fail. not only single array " + "is read.\n"); + return false; + } + if (!match_crc_table (crc_table)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\nTable check fail. Table not matching.\n"); + return false; + } + return true; +} + +/* Check whether the evolution pattern of phi is phi = SSA_NAME + target*/ +static bool +evolution_pattern_plus_with_p (class loop *loop, gphi *phi, + unsigned HOST_WIDE_INT target) +{ + edge backedge = find_edge (loop->latch, loop->header); + if (backedge == NULL) + return false; + tree evolution_node = PHI_ARG_DEF_FROM_EDGE (phi, backedge); + gimple *evolution_expr = SSA_NAME_DEF_STMT (evolution_node); + + if (evolution_expr && (gimple_assign_rhs_code (evolution_expr) == PLUS_EXPR || + gimple_assign_rhs_code (evolution_expr) + == POINTER_PLUS_EXPR)) + { + tree rhs1 = gimple_assign_rhs1 (evolution_expr); + tree rhs2 = gimple_assign_rhs2 (evolution_expr); + if (TREE_CODE (rhs1) == SSA_NAME && TREE_CODE (rhs2) == INTEGER_CST + && tree_to_uhwi (rhs2) == target) + return true; + } + return false; +} + +/* Check whether there are only 3 phi nodes in the header block. + Return 3 phi nodes in the capture. */ +static bool +check_num_of_phi (basic_block header, gphi *capture[]) +{ + gphi *phi; + gphi_iterator gsi; + int num_of_phi = 0; + + for (gsi = gsi_start_phis (header); !gsi_end_p (gsi); gsi_next (&gsi)) + { + phi = gsi.phi (); + if (phi) + num_of_phi++; + if (num_of_phi > 3) + return false; + capture[num_of_phi - 1] = phi; + } + /* Phi node should be exactly 3. */ + return num_of_phi == 3; +} + +/* Check the evolution pattern of three phi nodes. + Should be one of the node +1 every time (s), one of the node -1 + every time (n), and a 3rd one neither (c). Return 3 phi nodes in + the capture with the order of s,n,c.*/ +static bool +check_evolution_pattern (class loop *loop, gphi *capture[]) +{ + gphi *s = NULL; + gphi *n = NULL; + gphi *c = NULL; + + for (int i = 0; i < 3; i++) + { + if (evolution_pattern_plus_with_p (loop, capture[i], 1)) + { + if (s != NULL) + return false; + s = capture[i]; + phi_s = s; + } + else if (evolution_pattern_plus_with_p (loop, capture[i], 4294967295)) + { + if (n != NULL) + return false; + n = capture[i]; + } + else + { + if (c != NULL) + return false; + c = capture[i]; + phi_c = c; + } + } + + // Some envolution pattern cannot find + if (!n || !s || !c) + return false; + + capture[0] = s; + capture[1] = n; + capture[2] = c; + return true; +} +/* Check the calculation pattern before and after the crc_table array read stmt. + _7 = crc_32_tab[_6]; + The caculation of index _6 should be the result of a sequency of calculation + by the s and c + The result of the array read _7 should be used to calculate the new c. */ +static bool +check_calculation_pattern (class loop *loop, gphi *capture[]) +{ + gphi *s = capture[0]; + gphi *c = capture[2]; + tree res_ops[3]; + tree index = TREE_OPERAND (gimple_assign_rhs1 (crc_table_read_stmt), 1); + + /* Try to match + _4 = (int) _3; //NOP_EXPR (SSA_NAME @2) + _5 = _4 ^ c_10; //BIT_XOR_EXPR (SSA_NAME, PHI @1) + _6 = _5 & 255; //BIT_XOR_EXPR (SSA_NAME, INTEGER_CST@3) + */ + if (!gimple_crc_match_index (index, res_ops, NULL)) + return false; + gimple *s_res_stmt = SSA_NAME_DEF_STMT (res_ops[0]); + if (!s_res_stmt) + return false; + gimple *s_def_stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (s_res_stmt)); + if (!s_def_stmt) + return false; + tree s_res = TREE_OPERAND (gimple_assign_rhs1 (s_def_stmt), 0); + if (res_ops[1] != gimple_phi_result (c) || s_res != gimple_phi_result (s)) + return false; + + /* Try to match + _8 = c_12 >> 8; // RSHIFT_EXPR (SSA_NAME @1, INTEGER_CST @2) + c_19 = _7 ^ _8; // BIT_XOR_EXPR (SSA_NAME@3, SSA_NAME) + */ + edge backedge = find_edge (loop->latch, loop->header); + tree updated_c = PHI_ARG_DEF_FROM_EDGE (c, backedge); + if (!gimple_crc_match_res (updated_c, res_ops, NULL)) + return false; + if (res_ops[0] != gimple_phi_result (c) + || res_ops[2] != gimple_assign_lhs (crc_table_read_stmt)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\n gimple_crc_match_res pattern check failed.\n"); + return false; + } + + return true; +} + +/* Check the exit condition is n != 0. */ +static bool +check_exit_condition (class loop *loop, gphi *n) +{ + edge backedge = find_edge (loop->latch, loop->header); + gimple *cond_stmt = gsi_stmt (gsi_last_bb (loop->header)); + if (!cond_stmt || gimple_code (cond_stmt) != GIMPLE_COND + || gimple_cond_code (cond_stmt) != NE_EXPR + || gimple_cond_lhs (cond_stmt) != PHI_ARG_DEF_FROM_EDGE (n, backedge) + || tree_to_uhwi (gimple_cond_rhs (cond_stmt)) != 0) + return false; + + return true; +} + +/* Check the loop body. The loop body we are trying to match is + +# s_10 = PHI <s_14(D)(6), s_18(7)> +# n_11 = PHI <n_17(D)(6), n_20(7)> +# c_12 = PHI <c_16(6), c_19(7)> +_1 = (int) c_12; +s_18 = s_10 + 1; +_3 = *s_10; +_4 = (int) _3; +_5 = _1 ^ _4; +_6 = _5 & 255; +_7 = crc_32_tab[_6]; +_8 = c_12 >> 8; +c_19 = _7 ^ _8; +n_20 = n_11 + 4294967295; +if (n_20 != 0) + goto <bb 7>; [INV] +else + goto <bb 5>; [INV] + +which is doing a very simple calculation +do { + c = crc_32_tab[(c ^ (*s++)) & 0xff] ^ (c >> 8); +} while (--n); + +In this case ,we don't want this loop to have any other operation inside. +so the matching condition is +1. There are only 3 loop variant during each itoration, namely s,c,n, + which is limited by the condition that the loop have exactly 3 phi nodes. +2. The 3 loop variants should have evolution pattern as 1 of the 3 nodes is + increased by 1 every itoration, 1 of the 3 nodes is decreased by 1 every itor + and the 3rd one is neither. These three tree node SSA value will be captured + for the later arithmatic pattern matching +3. Pattern matching for the index of crc_table +4. pattern matching for the result of c calcuation after read from crc_table +5. The exit condition matching. + */ +static bool +crc_loop_body_check (class loop *loop) +{ + basic_block header = loop->header; + gphi *capture[3]; + if (!check_num_of_phi(header, capture)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\n num of phi noeds check failed.\n"); + return false; + } + if (!check_evolution_pattern (loop, capture)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\n evolution pattern check failed.\n"); + return false; + } + if (!check_calculation_pattern (loop, capture)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\n calculation pattern check failed.\n"); + return false; + } + if (!check_exit_condition (loop, capture[1])) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\n exit condition check failed.\n"); + return false; + } + return true; +} + +static bool check_prev_bb (basic_block prev_bb, enum tree_code code) +{ + gimple_stmt_iterator gsi; + gimple *stmt; + for (gsi = gsi_start_bb (prev_bb); !gsi_end_p (gsi); + gsi_next (&gsi)) + { + stmt = gsi_stmt (gsi); + if (stmt == NULL) + return false; + + if (gimple_code (stmt) == GIMPLE_COND + && gimple_cond_code (stmt) == code + && TREE_CODE (gimple_cond_rhs (stmt)) == INTEGER_CST + && tree_int_cst_sgn (gimple_cond_rhs (stmt)) == 0) + return true; + } + return false; +} + +/* Check the prev_bb of prev_bb of loop header. The prev_bb we are trying to +match is + +c_15 = crc; +if (n_16 (D) != 0) + goto <bb 6>; [INV] +else + goto <bb 5>; [INV] + + In this case , we must be sure that the n is not zero. + so the match condition is + 1 the n is not zero. + + <bb 2> : +if (s_13 (D) == 0B) + goto <bb 5>; [INV] +else + goto <bb 3>; [INV] + + In this case, we must be sure the s is not NULL. + so the match condition is + 1 the s is not NULL. +*/ +static bool +crc_prev_bb_of_loop_header_check (class loop *loop) +{ + basic_block header = loop->header; + basic_block prev_header_bb = header->prev_bb; + if (NULL == prev_header_bb) + return false; + + basic_block prev_prev_header_bb = prev_header_bb->prev_bb; + if (NULL == prev_prev_header_bb) + return false; + + if (!check_prev_bb (prev_prev_header_bb, NE_EXPR)) + return false; + + basic_block first_bb = prev_prev_header_bb->prev_bb; + if (NULL == first_bb) + return false; + + if (!check_prev_bb (first_bb, EQ_EXPR)) + return false; + + return true; +} + +static bool +match_crc_loop (class loop *loop) +{ + if (!crc_loop_form_check (loop)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\nWrong loop form for crc matching.\n"); + return false; + } + if (!crc_table_check (loop)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\nWrong crc table for crc matching.\n"); + return false; + } + if (!crc_loop_body_check (loop)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\nWrong loop body for crc matching.\n"); + return false; + } + if (!crc_prev_bb_of_loop_header_check (loop)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "\nWrong prev basic_blocks of loop header for" + " crc matching.\n"); + return false; + } + + init_origin_loop_structure (); + if (!get_origin_loop_info (loop)) + return false; + + return true; +} + +static void +create_new_bb (basic_block &new_bb, basic_block after_bb, + basic_block dominator_bb, class loop *outer) +{ + new_bb = create_empty_bb (after_bb); + add_bb_to_loop (new_bb, outer); + set_immediate_dominator (CDI_DOMINATORS, new_bb, dominator_bb); +} + +static void +change_preheader_bb (edge entry_edge) +{ + gimple_seq stmts = NULL; + gimple_stmt_iterator gsi; + gimple *g; + tree lhs1; + + lhs1 = create_tmp_var (TREE_TYPE (origin_loop.base_n),"nn"); + lhs1 = make_ssa_name (lhs1); + gsi = gsi_last_bb (entry_edge->src); + g = gimple_build_assign (lhs1, RSHIFT_EXPR, origin_loop.base_n, + build_int_cst (TREE_TYPE (origin_loop.base_n), 2)); + gimple_seq_add_stmt (&stmts, g); + gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT); + nn_tree = lhs1; + set_current_def (nn_tree, lhs1); + nn_map.put (entry_edge->src, lhs1); +} + +static gphi * +create_phi_node_for_bb (tree old_name, basic_block bb) +{ + gphi *phi = create_phi_node (NULL_TREE, bb); + create_new_def_for (old_name, phi, gimple_phi_result_ptr (phi)); + return phi; +} + +static gimple * +call_builtin_fun (int code,tree &lhs, tree arg1, tree arg2) +{ + unsigned int builtin_code = targetm.get_crc_builtin_code (code, true); + // Get the decl of __builtin_aarch64_crc32w + tree fn = targetm.builtin_decl (builtin_code, true); + if (!fn || fn == error_mark_node) + fatal_error (input_location, + "target specific builtin not available"); + gimple *call_builtin = gimple_build_call (fn, 2, arg1, arg2); + lhs = make_ssa_name (unsigned_type_node); + gimple_call_set_lhs (call_builtin, lhs); + + return call_builtin; +} + +/* Create loop_header and loop_latch for new loop + <bb 5> : + # s_14 = PHI <s_23(D)(4), s_30(5)> + # c_16 = PHI <c_25(4), c_29(5)> + # nn_19 = PHI <nn_27(4), nn_31(5)> + _1 = (unsigned int) c_16; + _2 = MEM[(uint32_t *)s_14]; + _40 = __builtin_aarch64_crc32w (_1, _2); + c_29 = (long unsigned int) _40; + s_30 = s_14 + 4; + nn_31 = nn_19 + 4294967295; + if (nn_31 != 0) + The IR of bb is as above. */ +static void +create_loop_bb (basic_block &loop_bb, basic_block after_bb, + basic_block dominator_bb, class loop *outer, edge entry_edge) +{ + gimple_seq stmts = NULL; + gimple_stmt_iterator gsi; + gimple *g; + gphi *phi_s_loop; + gphi *phi_c_loop; + gphi *phi_nn_loop; + + create_new_bb (loop_bb, after_bb, dominator_bb, outer); + redirect_edge_and_branch (entry_edge, loop_bb); + gsi = gsi_last_bb (loop_bb); + tree entry_nn = get_current_def (nn_tree); + phi_s_loop = create_phi_node_for_bb (origin_loop.base_s, loop_bb); + phi_c_loop = create_phi_node_for_bb (origin_loop.base_c, loop_bb); + phi_nn_loop = create_phi_node_for_bb (entry_nn, loop_bb); + + tree res_s = gimple_phi_result (phi_s_loop); + tree res_nn = gimple_phi_result (phi_nn_loop); + tree lhs1 = gimple_build (&stmts, NOP_EXPR, unsigned_type_node, + gimple_phi_result (phi_c_loop)); + g = gimple_build_assign (make_ssa_name (unsigned_type_node), + fold_build2 (MEM_REF, unsigned_type_node, res_s, + build_int_cst ( + build_pointer_type ( + unsigned_type_node),0))); + gimple_seq_add_stmt (&stmts, g); + tree lhs2 = gimple_assign_lhs (g); // _2 = MEM[(uint32_t *)s_14]; + unsigned int code = AARCH64_BUILTIN_CRC32W; + tree lhs3; + gimple *build_crc32w = call_builtin_fun (code, lhs3, lhs1, lhs2); + crc_map.put (loop_bb, lhs3); + gimple_seq_add_stmt (&stmts, build_crc32w); + + tree lhs4 = copy_ssa_name (origin_loop.base_c); + g = gimple_build_assign (lhs4, NOP_EXPR, lhs3); + gimple_seq_add_stmt (&stmts, g); + c_map.put (loop_bb, lhs4); + + tree lhs5 = copy_ssa_name (origin_loop.base_s); + g = gimple_build_assign (lhs5, POINTER_PLUS_EXPR, res_s, + build_int_cst (sizetype, 4)); + gimple_seq_add_stmt (&stmts, g); + s_map.put (loop_bb, lhs5); + + tree lhs6 = copy_ssa_name (nn_tree); + g = gimple_build_assign (lhs6, PLUS_EXPR, res_nn, + build_int_cst (TREE_TYPE (res_nn), 4294967295)); + gimple_seq_add_stmt (&stmts,g); + nn_map.put (loop_bb, lhs6); + + gcond *cond_stmt = gimple_build_cond (NE_EXPR, lhs6, origin_loop.limit, + NULL_TREE, NULL_TREE); + gimple_seq_add_stmt (&stmts, cond_stmt); + gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT); +} + +/* <bb 6> : + # c_6 = PHI <c_29(5)> + # s_46 = PHI <s_30(5)> + _44 = n_26(D) & 2; + if (_44 != 0) + The IR of bb is as above. */ +static void +create_cond_bb (basic_block &cond_bb, basic_block after_bb, + basic_block dominator_bb, class loop *outer) +{ + gimple_seq stmts = NULL; + gimple_stmt_iterator gsi; + gphi *phi_s_loop; + gphi *phi_c_loop; + + create_new_bb (cond_bb, after_bb, dominator_bb, outer); + gsi = gsi_last_bb (cond_bb); + tree entry_nn = get_current_def (nn_tree); + phi_s_loop = create_phi_node_for_bb (origin_loop.base_s, cond_bb); + phi_c_loop = create_phi_node_for_bb (origin_loop.base_c, cond_bb); + tree res_s = gimple_phi_result (phi_s_loop); + set_current_def (origin_loop.base_s, res_s); + s_map.put (cond_bb, res_s); + tree res_c = gimple_phi_result (phi_c_loop); + set_current_def (origin_loop.base_c, res_c); + c_map.put (cond_bb, res_c); + + tree lhs1 = gimple_build (&stmts, BIT_AND_EXPR, + TREE_TYPE (origin_loop.base_n), origin_loop.base_n, + build_int_cst (TREE_TYPE (origin_loop.base_n), 2)); + gcond *cond_stmt = gimple_build_cond (NE_EXPR, lhs1, origin_loop.limit, + NULL_TREE, NULL_TREE); + gimple_seq_add_stmt (&stmts, cond_stmt); + gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT); +} + +/* <bb 7> : + _7 = MEM[(uint16_t *)s_46]; + _41 = __builtin_aarch64_crc32h (_8, _7); + c_33 = (long unsigned int) _41; + s_34 = s_30 + 2; + The IR of bb is as above. */ +static void +create_cond_true_bb (basic_block &cond_true_bb, basic_block after_bb, + basic_block dominator_bb, class loop *outer) +{ + gimple_seq stmts = NULL; + gimple *g; + gimple_stmt_iterator gsi; + + create_new_bb (cond_true_bb, after_bb, dominator_bb, outer); + gsi = gsi_last_bb (cond_true_bb); + tree s_46 = *(s_map.get (after_bb)); + tree type = build_pointer_type (short_unsigned_type_node); + g = gimple_build_assign (make_ssa_name (short_unsigned_type_node), + fold_build2 (MEM_REF, short_unsigned_type_node, s_46, + build_int_cst (type, 0))); + gimple_seq_add_stmt (&stmts,g); + tree lhs1 = gimple_assign_lhs (g); // _7 = MEM[(uint16_t *)s_46]; + unsigned int code = AARCH64_BUILTIN_CRC32H; + tree lhs2; + gimple *call_builtin = call_builtin_fun (code, lhs2, + *(crc_map.get ( + cond_true_bb->prev_bb->prev_bb)), lhs1); + crc_map.put (cond_true_bb,lhs2); + gimple_seq_add_stmt (&stmts, call_builtin); + + tree lhs3 = copy_ssa_name (origin_loop.base_c); + g = gimple_build_assign (lhs3, NOP_EXPR, lhs2); + gimple_seq_add_stmt (&stmts, g); + c_map.put (cond_true_bb, lhs3); + + tree lhs5 = copy_ssa_name (s_46); + g = gimple_build_assign (lhs5, POINTER_PLUS_EXPR, s_46, + build_int_cst (sizetype, 2)); // s_30 + 2; + gimple_seq_add_stmt (&stmts, g); + s_map.put (cond_true_bb, lhs5); + + gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT); + s_map.put (cond_true_bb, lhs5); +} + +/* <bb 8> : + # s_15 = PHI <s_46(6), s_34(7)> + # c_17 = PHI <c_6(6), c_33(7)> + _3 = n_26(D) & 1; + if (_3 != 0) + The IR of bb is as above. */ +static void +create_cond_false_bb (basic_block &cond_false_bb, basic_block after_bb, + basic_block dominator_bb, class loop *outer) +{ + gimple_seq stmts = NULL; + gimple_stmt_iterator gsi; + gphi *phi_s_cond_true_bb; + gphi *phi_c_cond_true_bb; + + create_new_bb (cond_false_bb, after_bb, dominator_bb, outer); + make_single_succ_edge (after_bb, cond_false_bb, EDGE_FALLTHRU); + + tree entry_s = get_current_def (origin_loop.base_s); + phi_s_cond_true_bb = create_phi_node_for_bb (entry_s, cond_false_bb); + tree entry_c = get_current_def (origin_loop.base_c); + phi_c_cond_true_bb = create_phi_node_for_bb (entry_c, cond_false_bb); + tree res_s = gimple_phi_result (phi_s_cond_true_bb); + set_current_def (origin_loop.base_s, res_s); + s_map.put (cond_false_bb, res_s); + tree res_c = gimple_phi_result (phi_c_cond_true_bb); + set_current_def (origin_loop.base_c, res_c); + c_map.put (cond_false_bb, res_c); + + gsi = gsi_last_bb (cond_false_bb); + tree lhs1 = gimple_build (&stmts, BIT_AND_EXPR, + TREE_TYPE (origin_loop.base_n), origin_loop.base_n, + build_int_cst (TREE_TYPE (origin_loop.base_n), 1)); + gcond *cond_stmt = gimple_build_cond (NE_EXPR, lhs1, origin_loop.limit, + NULL_TREE, NULL_TREE); + gimple_seq_add_stmt (&stmts, cond_stmt); + gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT); +} + +/* <bb 9> : + _11 = (unsigned int) c_17; + _12 = *s_15; + _42 = __builtin_aarch64_crc32b (_11, _12); + c_36 = (long unsigned int) _42; + The IR of bb is as above. */ +static void +create_lastcond_true_bb (basic_block &new_bb, basic_block after_bb, + basic_block dominator_bb, class loop *outer) +{ + gimple_seq stmts = NULL; + gimple_stmt_iterator gsi; + gimple *g; + + create_new_bb (new_bb, after_bb, dominator_bb, outer); + gsi = gsi_last_bb (new_bb); + + tree lhs1 = gimple_build (&stmts, NOP_EXPR, unsigned_type_node, + get_current_def (origin_loop.base_c)); + tree lhs2; + tree s_15 = get_current_def (origin_loop.base_s); + g = gimple_build_assign (make_ssa_name (unsigned_char_type_node), + fold_build2 (MEM_REF, unsigned_char_type_node, s_15, + build_int_cst (TREE_TYPE (s_15), 0))); + gimple_seq_add_stmt (&stmts, g); + lhs2 = gimple_assign_lhs (g); + + unsigned int code = AARCH64_BUILTIN_CRC32B; + tree lhs3; + gimple *call_builtin = call_builtin_fun (code, lhs3, lhs1, lhs2); + crc_map.put (new_bb,lhs3); + gimple_seq_add_stmt (&stmts,call_builtin); + + tree lhs4 = copy_ssa_name (origin_loop.base_c); + g = gimple_build_assign (lhs4, NOP_EXPR, lhs3); + gimple_seq_add_stmt (&stmts, g); + c_map.put (new_bb, lhs4); + + gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT); +} + +static bool +optional_add_phi_arg (gphi * phi, tree phi_res, tree phi_arg, edge e) +{ + location_t loc; + if (same_ssa_name_var_p (phi_arg, phi_res)) + { + if (virtual_operand_p (phi_arg)) + loc = UNKNOWN_LOCATION; + else + loc = gimple_location (SSA_NAME_DEF_STMT (phi_arg)); + add_phi_arg (phi, phi_arg, e, loc); + + return true; + } + + return false; +} + +/* Add phi_arg for bb with phi node. */ +static void +update_phi_nodes (basic_block bb) +{ + edge e; + edge_iterator ei; + gphi *phi; + gphi_iterator gsi; + tree res; + + for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) + { + phi = gsi.phi (); + res = gimple_phi_result (phi); + + FOR_EACH_EDGE (e, ei, bb->preds) + { + if (PHI_ARG_DEF_FROM_EDGE (phi, e)) + continue; + tree var_c; + tree *ptr_var_c = c_map.get (e->src); + if (ptr_var_c == NULL) + var_c = origin_loop.base_c; + else + var_c = *ptr_var_c; + if (optional_add_phi_arg (phi, res, var_c, e)) + continue; + + tree var_nn; + tree *ptr_var_nn = nn_map.get (e->src); + if (ptr_var_nn == NULL) + var_nn = nn_tree; + else + var_nn = *ptr_var_nn; + if (optional_add_phi_arg (phi, res, var_nn, e)) + continue; + + tree var_s; + tree *ptr_var_s = s_map.get (e->src); + if (ptr_var_s == NULL) + var_s = origin_loop.base_s; + else + var_s = *ptr_var_s; + if (optional_add_phi_arg (phi, res, var_s, e)) + continue; + } + } +} + +static void +create_new_loops (edge entry_edge) +{ + class loop *new_loop = NULL; + basic_block loop_bb, cond_bb, cond_true_bb, cond_false_bb, lastcond_true_bb; + class loop *outer = entry_edge->src->loop_father; + change_preheader_bb (entry_edge); + + create_loop_bb (loop_bb, entry_edge->src, entry_edge->src, outer, entry_edge); + create_cond_bb (cond_bb, loop_bb, loop_bb, outer); + make_edge (loop_bb, loop_bb, EDGE_TRUE_VALUE); + make_edge (loop_bb, cond_bb, EDGE_FALSE_VALUE); + update_phi_nodes (loop_bb); + + new_loop = alloc_loop (); + new_loop->header = loop_bb; + new_loop->latch = loop_bb; + add_loop (new_loop, outer); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "\nPrint byte new loop %d:\n", new_loop->num); + flow_loop_dump (new_loop, dump_file, NULL, 1); + fprintf (dump_file, "\n\n"); + } + + create_cond_true_bb (cond_true_bb, cond_bb, cond_bb, outer); + make_edge (cond_bb, cond_true_bb, EDGE_TRUE_VALUE); + create_cond_false_bb (cond_false_bb, cond_true_bb, cond_bb, outer); + make_edge (cond_bb, cond_false_bb, EDGE_FALSE_VALUE); + update_phi_nodes (cond_bb); + update_phi_nodes (cond_false_bb); + create_lastcond_true_bb (lastcond_true_bb, cond_false_bb, + cond_false_bb, outer); + make_edge (cond_false_bb, lastcond_true_bb, EDGE_TRUE_VALUE); + make_edge (cond_false_bb, origin_loop.exit_bb, EDGE_FALSE_VALUE); + make_single_succ_edge (lastcond_true_bb, origin_loop.exit_bb, EDGE_FALLTHRU); + + update_phi_nodes (origin_loop.exit_bb); + remove_edge (origin_loop.exit_edge); +} + +/* Clear information about the original loop. */ +static void +remove_origin_loop (class loop *loop) +{ + basic_block *body = get_loop_body_in_dom_order (loop); + unsigned n = loop->num_nodes; + for (int i = 0; i < n; ++i) + delete_basic_block (body[i]); + free (body); + delete_loop (loop); +} + +/* Make sure that the dominance relationship of the newly inserted cfg + is not missing. */ +static void +update_loop_dominator (cdi_direction dir) +{ + gcc_assert (dom_info_available_p (dir)); + + basic_block bb; + FOR_EACH_BB_FN (bb, cfun) + { + basic_block imm_bb = get_immediate_dominator (dir, bb); + if (!imm_bb || bb == origin_loop.exit_bb) + { + set_immediate_dominator (CDI_DOMINATORS, bb, + recompute_dominator (CDI_DOMINATORS, bb)); + continue; + } + } +} + +/* Perform the conversion of origin_loop to new_loop. */ +static void +convert_to_new_loop (class loop *loop) +{ + create_new_loops (origin_loop.entry_edge); + remove_origin_loop (loop); + update_loop_dominator (CDI_DOMINATORS); + update_ssa (TODO_update_ssa); +} + +/* The main entry of loop crc optimizes. */ +static unsigned int +tree_ssa_loop_crc () +{ + if (TARGET_CRC32 == false) + { + warning (OPT____,"The loop-crc optimization is not working." \ + "You should make sure that the specified architecture" \ + "supports crc:-march=armv8.1-a"); + return 0; + } + unsigned int todo = 0; + class loop *loop; + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + flow_loops_dump (dump_file, NULL, 1); + fprintf (dump_file, "\nStarting the loop_crc pass\n"); + } + + enum li_flags LI = LI_FROM_INNERMOST; + for (auto loop : loops_list (cfun, LI)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "======================================\n"); + fprintf (dump_file, "Processing loop %d:\n", loop->num); + fprintf (dump_file, "======================================\n"); + flow_loop_dump (loop, dump_file, NULL, 1); + fprintf (dump_file, "\n\n"); + } + + if (match_crc_loop (loop)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "The %dth loop form is success matched," + "and the loop can be optimized.\n", + loop->num); + } + + convert_to_new_loop (loop); + todo |= (TODO_update_ssa); + } + } + return todo; +} + +/* Loop crc. */ + +namespace { +const pass_data pass_data_tree_loop_crc = +{ + GIMPLE_PASS, + "loop_crc", + OPTGROUP_LOOP, + TV_TREE_LOOP_CRC, + (PROP_cfg | PROP_ssa), + 0, + 0, + 0, + (TODO_update_ssa | TODO_verify_all) +}; + +class pass_loop_crc : public gimple_opt_pass +{ +public: + pass_loop_crc (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tree_loop_crc, ctxt) + {} + + /* Opt_pass methods: */ + virtual bool gate (function *); + virtual unsigned int execute (function *); +}; // Class pass_loop_crc + +bool +pass_loop_crc::gate (function *) +{ + return (flag_loop_crc > 0 && optimize >= 3); +} + +unsigned int +pass_loop_crc::execute (function *fun) +{ + if (number_of_loops (fun) <= 1) + return 0; + + /* Only supports LP64 data mode. */ + if (TYPE_PRECISION (long_integer_type_node) != 64 + || POINTER_SIZE != 64 || TYPE_PRECISION (integer_type_node) != 32) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "The current data mode is not supported," + "only the LP64 date mode is supported.\n"); + return 0; + } + + return tree_ssa_loop_crc (); +} + +} // Anon namespace + +gimple_opt_pass * +make_pass_loop_crc (gcc::context *ctxt) +{ + return new pass_loop_crc (ctxt); +} -- 2.33.0
Locations
Projects
Search
Status Monitor
Help
Open Build Service
OBS Manuals
API Documentation
OBS Portal
Reporting a Bug
Contact
Mailing List
Forums
Chat (IRC)
Twitter
Open Build Service (OBS)
is an
openSUSE project
.
浙ICP备2022010568号-2