File _service:tar_scm:0046-ArrayWidenCompare-Add-a-n... of Package gcc

File _service:tar_scm:0046-ArrayWidenCompare-Add-a-new-optimization-for-array-c.patch of Package gcc (Revision b944475d462b415bcfdac94829a5265f)

Currently displaying revision b944475d462b415bcfdac94829a5265f , Show latest

From 8072fe107c04778de78db90bf6fdb7baf474e24a Mon Sep 17 00:00:00 2001
From: dingguangya <dingguangya1@huawei.com>
Date: Thu, 2 Jun 2022 12:48:17 +0800
Subject: [PATCH 12/12] [ArrayWidenCompare] Add a new optimization for array
 comparison scenarios

Add option farray-widen-compare.
For an array pointer whose element is a single-byte type,
by changing the pointer type to a long-byte type, the elements
can be combined and compared after loading.
---
 gcc/Makefile.in                               |    1 +
 gcc/common.opt                                |    5 +
 gcc/doc/invoke.texi                           |   13 +-
 gcc/passes.def                                |    1 +
 .../gcc.dg/tree-ssa/awiden-compare-1.c        |   19 +
 .../gcc.dg/tree-ssa/awiden-compare-2.c        |   90 +
 .../gcc.dg/tree-ssa/awiden-compare-3.c        |   22 +
 .../gcc.dg/tree-ssa/awiden-compare-4.c        |   22 +
 .../gcc.dg/tree-ssa/awiden-compare-5.c        |   19 +
 .../gcc.dg/tree-ssa/awiden-compare-6.c        |   19 +
 .../gcc.dg/tree-ssa/awiden-compare-7.c        |   22 +
 .../gcc.dg/tree-ssa/awiden-compare-8.c        |   24 +
 gcc/timevar.def                               |    1 +
 gcc/tree-pass.h                               |    1 +
 gcc/tree-ssa-loop-array-widen-compare.c       | 1555 +++++++++++++++++
 15 files changed, 1813 insertions(+), 1 deletion(-)
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-1.c
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-2.c
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-3.c
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-4.c
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-5.c
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-6.c
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-7.c
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-8.c
 create mode 100644 gcc/tree-ssa-loop-array-widen-compare.c

diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 23394c64b..2b2bf474a 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1591,6 +1591,7 @@ OBJS = \
 	tree-ssa-loop-ivopts.o \
 	tree-ssa-loop-manip.o \
 	tree-ssa-loop-niter.o \
+	tree-ssa-loop-array-widen-compare.o \
 	tree-ssa-loop-prefetch.o \
 	tree-ssa-loop-split.o \
 	tree-ssa-loop-unswitch.o \
diff --git a/gcc/common.opt b/gcc/common.opt
index 24834cf60..2985a5791 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -1060,6 +1060,11 @@ fasynchronous-unwind-tables
 Common Report Var(flag_asynchronous_unwind_tables) Optimization
 Generate unwind tables that are exact at each instruction boundary.
 
+farray-widen-compare
+Common Report Var(flag_array_widen_compare) Optimization
+Extends types for pointers to arrays to improve array comparsion performance.
+In some extreme situations this may result in unsafe behavior.
+
 fauto-inc-dec
 Common Report Var(flag_auto_inc_dec) Init(1) Optimization
 Generate auto-inc/dec instructions.
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 4b0fd2ffb..44f1f8a2e 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -459,7 +459,7 @@ Objective-C and Objective-C++ Dialects}.
 -falign-loops[=@var{n}[:@var{m}:[@var{n2}[:@var{m2}]]]] @gol
 -fno-allocation-dce -fallow-store-data-races @gol
 -fassociative-math  -fauto-profile  -fauto-profile[=@var{path}] @gol
--fauto-inc-dec  -fbranch-probabilities @gol
+-farray-widen-compare -fauto-inc-dec  -fbranch-probabilities @gol
 -fcaller-saves @gol
 -fcombine-stack-adjustments  -fconserve-stack @gol
 -fcompare-elim  -fcprop-registers  -fcrossjumping @gol
@@ -9710,6 +9710,17 @@ This pass is always skipped on architectures that do not have
 instructions to support this.  Enabled by default at @option{-O} and
 higher on architectures that support this.
 
+@item -farray-widen-compare
+@opindex farray-widen-compare
+In the narrow-byte array comparison scenario, the types of pointers
+pointing to array are extended so that elements of multiple bytes can
+be loaded at a time when a wide type is used to dereference an array,
+thereby improving the performance of this comparison scenario.  In some
+extreme situations this may result in unsafe behavior.
+
+This option may generate better or worse code; results are highly dependent
+on the structure of loops within the source code.
+
 @item -fdce
 @opindex fdce
 Perform dead code elimination (DCE) on RTL@.
diff --git a/gcc/passes.def b/gcc/passes.def
index e9c91d26e..797b803ca 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -91,6 +91,7 @@ along with GCC; see the file COPYING3.  If not see
           NEXT_PASS (pass_dse);
 	  NEXT_PASS (pass_cd_dce);
 	  NEXT_PASS (pass_phiopt, true /* early_p */);
+	  NEXT_PASS (pass_array_widen_compare);
 	  NEXT_PASS (pass_tail_recursion);
 	  NEXT_PASS (pass_convert_switch);
 	  NEXT_PASS (pass_cleanup_eh);
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-1.c b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-1.c
new file mode 100644
index 000000000..27b69b0e9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */
+/* { dg-options "-O3 -mabi=lp64 -farray-widen-compare -fdump-tree-awiden_compare-details" } */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+
+uint32_t
+func (uint32_t len0, uint32_t len1, const uint32_t len_limit, const uint8_t *const pb, const uint8_t *const cur)
+{
+   uint32_t len = my_min(len0, len1);
+    while (++len != len_limit)
+        if (pb[len] != cur[len])
+            break;
+    return len;
+}
+
+/* { dg-final { scan-tree-dump-times "loop form is success" 1 "awiden_compare"} } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-2.c b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-2.c
new file mode 100644
index 000000000..d102364f2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-2.c
@@ -0,0 +1,90 @@
+/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */
+/* { dg-options "-O3 -mabi=lp64 -farray-widen-compare -fdump-tree-awiden_compare-details" } */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#define EMPTY_HASH_VALUE 0
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+#define true 1
+
+typedef struct {
+    uint32_t len;
+    uint32_t dist;
+} lzma_match;
+
+
+lzma_match *
+func (
+        const uint32_t len_limit,
+        const uint32_t pos,
+        const uint8_t *const cur,
+        uint32_t cur_match,
+        uint32_t depth,
+        uint32_t *const son,
+        const uint32_t cyclic_pos,
+        const uint32_t cyclic_size,
+        lzma_match *matches,
+        uint32_t len_best)
+{
+    uint32_t *ptr0 = son + (cyclic_pos << 1) + 1;
+    uint32_t *ptr1 = son + (cyclic_pos << 1);
+
+    uint32_t len0 = 0;
+    uint32_t len1 = 0;
+
+    while (true)
+    {
+        const uint32_t delta = pos - cur_match;
+        if (depth-- == 0 || delta >= cyclic_size)
+        {
+            *ptr0 = EMPTY_HASH_VALUE;
+            *ptr1 = EMPTY_HASH_VALUE;
+            return matches;
+        }
+
+        uint32_t *const pair = son + ((cyclic_pos - delta + (delta > cyclic_pos ? cyclic_size : 0)) << 1);
+
+        const uint8_t *const pb = cur -delta;
+        uint32_t len = my_min(len0, len1);
+
+        if (pb[len] == cur[len])
+        {
+            while (++len != len_limit)
+                if (pb[len] != cur[len])
+                    break;
+
+            if (len_best < len)
+            {
+                len_best = len;
+                matches->len = len;
+                matches->dist = delta - 1;
+                ++matches;
+
+                if (len == len_limit)
+                {
+                    *ptr1 = pair[0];
+                    *ptr0 = pair[1];
+                    return matches;
+                }
+            }
+        }
+
+        if (pb[len] < cur[len])
+        {
+            *ptr1 = cur_match;
+            ptr1 = pair + 1;
+            cur_match = *ptr1;
+            len1 = len;
+        }
+        else
+        {
+            *ptr0 = cur_match;
+            ptr0 = pair;
+            cur_match = *ptr0;
+            len0 = len;
+        }
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "loop form is success" 1 "awiden_compare"} } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-3.c b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-3.c
new file mode 100644
index 000000000..52dd6b02b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-3.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */
+/* { dg-options "-O3 -mabi=lp64 -farray-widen-compare -fdump-tree-awiden_compare-details" } */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+
+uint32_t
+func (uint32_t len0, uint32_t len1, const uint32_t len_limit, const uint8_t *const pb, const uint8_t *const cur)
+{
+   uint32_t len = my_min(len0, len1);
+    while (len != len_limit)
+    {
+        if (pb[len] != cur[len])
+            break;
+        len = len + 1;
+    }
+    return len;
+}
+
+/* { dg-final { scan-tree-dump-times "loop form is success" 1 "awiden_compare"} } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-4.c b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-4.c
new file mode 100644
index 000000000..d3185d326
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-4.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */
+/* { dg-options "-O3 -mabi=lp64 -farray-widen-compare -fdump-tree-awiden_compare-details" } */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+
+uint32_t
+func (uint32_t len0, uint32_t len1, const uint32_t len_limit, const uint8_t *const pb, const uint8_t *const cur)
+{
+   uint32_t len = my_min(len0, len1);
+    while (len != len_limit)
+    {
+        if (pb[len] != cur[len])
+            break;
+        len = len + 2;
+    }
+    return len;
+}
+
+/* { dg-final { scan-tree-dump-times "loop form is success" 0 "awiden_compare"} } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-5.c b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-5.c
new file mode 100644
index 000000000..9743dc623
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-5.c
@@ -0,0 +1,19 @@
+/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */
+/* { dg-options "-O3 -mabi=lp64 -farray-widen-compare -fdump-tree-awiden_compare-details" } */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+
+uint32_t
+func (uint32_t len0, uint32_t len1, const uint32_t len_limit, const uint8_t *const pb, const uint8_t *const cur)
+{
+   uint32_t len = my_min(len0, len1);
+    while (++len != len_limit)
+        if (pb[len] != cur[len-1])
+            break;
+    return len;
+}
+
+/* { dg-final { scan-tree-dump-times "loop form is success" 0 "awiden_compare"} } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-6.c b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-6.c
new file mode 100644
index 000000000..2323d5bf7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-6.c
@@ -0,0 +1,19 @@
+/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */
+/* { dg-options "-O3 -mabi=lp64 -farray-widen-compare -fdump-tree-awiden_compare-details" } */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+
+uint32_t
+func (uint32_t len0, uint32_t len1, const uint32_t len_limit, const uint8_t *const pb, const uint8_t *const cur)
+{
+   uint32_t len = my_min(len0, len1);
+    while (len++ != len_limit)
+        if (pb[len] != cur[len])
+            break;
+    return len;
+}
+
+/* { dg-final { scan-tree-dump-times "loop form is success" 0 "awiden_compare"} } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-7.c b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-7.c
new file mode 100644
index 000000000..33db62fa4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-7.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */
+/* { dg-options "-O3 -mabi=lp64 -farray-widen-compare -fdump-tree-awiden_compare-details" } */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+
+uint32_t
+func (uint32_t len0, uint32_t len1, const uint32_t len_limit, const uint8_t *const pb, const uint8_t *const cur)
+{
+   uint32_t len = my_min(len0, len1);
+    while (len != len_limit)
+    {
+        len = len + 1;
+        if (pb[len] != cur[len])
+            break;
+    }
+    return len;
+}
+
+/* { dg-final { scan-tree-dump-times "loop form is success" 0 "awiden_compare"} } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-8.c b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-8.c
new file mode 100644
index 000000000..8c96d24a1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/awiden-compare-8.c
@@ -0,0 +1,24 @@
+/* { dg-do compile { target {{ aarch64*-*-linux* } && lp64 } } } */
+/* { dg-options "-O3 -mabi=lp64 -farray-widen-compare -fdump-tree-awiden_compare-details" } */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#define my_min(x, y) ((x) < (y) ? (x) : (y))
+
+uint32_t
+func (uint32_t len0, uint32_t len1, const uint32_t len_limit, const uint8_t *const pb, const uint8_t *const cur)
+{
+   uint32_t len = my_min(len0, len1);
+    while (++len != len_limit)
+    {
+        if (pb[len] != cur[len])
+        {
+            len = len - 1;
+            break;
+        }
+    }
+    return len;
+}
+
+/* { dg-final { scan-tree-dump-times "loop form is success" 0 "awiden_compare"} } */
diff --git a/gcc/timevar.def b/gcc/timevar.def
index e873747a8..6d90bb6e1 100644
--- a/gcc/timevar.def
+++ b/gcc/timevar.def
@@ -215,6 +215,7 @@ DEFTIMEVAR (TV_TREE_NRV		     , "tree NRV optimization")
 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_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 be6387768..aca0b83f2 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -436,6 +436,7 @@ extern gimple_opt_pass *make_pass_cselim (gcc::context *ctxt);
 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_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-array-widen-compare.c b/gcc/tree-ssa-loop-array-widen-compare.c
new file mode 100644
index 000000000..ba51d785d
--- /dev/null
+++ b/gcc/tree-ssa-loop-array-widen-compare.c
@@ -0,0 +1,1555 @@
+/* Array widen compare.
+   Copyright (C) 2022-2022 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"
+
+/* This pass handles scenarios similar to the following:
+
+   uint32_t
+   func (uint32_t len0, uint32_t len1, const uint32_t len_limit,
+	 const uint8_t *const pb, const uint8_t *const cur)
+   {
+     uint32_t len = my_min (len0, len1);
+     while (++len != len_limit)
+       if (pb[len] != cur[len])
+	 break;
+     return len;
+   }
+
+   Features of this type of loop:
+     1) the loop has two exits;
+     2) One of the exits comes from the comparison result of the array;
+
+   From the source code point of view, the pass completes the conversion of the
+   above scenario into:
+
+   uint32_t
+   func (uint32_t len0, uint32_t len1, const uint32_t len_limit,
+	 const uint8_t *const pb, const uint8_t *const cur)
+   {
+     uint32_t len = my_min (len0, len1);
+     // align_loop
+     for(++len; len + sizeof(uint64_t) <= len_limit; len += sizeof (uint64_t))
+     {
+       uint64_t a = *((uint64_t*)(cur+len));
+       uint64_t b = *((uint64_t*)(pb+len));
+       if (a != b)
+       {
+	 int lz = __builtin_ctzll (a ^ b);
+	 len += lz / 8;
+	 return len;
+       }
+     }
+     // epilogue_loop
+     for (;len != len_limit; ++len)
+       if (pb[len] != cur[len])
+	 break;
+     return len;
+   }
+
+   This pass is to complete the conversion of such scenarios from the internal
+   perspective of the compiler:
+     1) determine_loop_form: 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, growth step size
+			  of loop induction variable, 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.  */
+
+/* The useful information of origin loop.  */
+
+struct origin_loop_info
+{
+  tree base;		/* The initial index of the array in the old loop.  */
+  tree limit;		/* The limit index of the array in the old loop.  */
+  tree arr1;		/* Array 1 in the old loop.  */
+  tree arr2;		/* Array 2 in the old loop.  */
+  edge entry_edge;	/* The edge into the old loop.  */
+  basic_block exit_bb1;
+  basic_block exit_bb2;
+  edge exit_e1;
+  edge exit_e2;
+  gimple *cond_stmt1;
+  gimple *cond_stmt2;
+  gimple *update_stmt;
+  bool exist_prolog_assgin;
+			/* Whether the marker has an initial value assigned
+			   to the array index.  */
+  unsigned HOST_WIDE_INT step;
+  			/* The growth step of the loop induction variable.  */
+};
+
+typedef struct origin_loop_info origin_loop_info;
+
+static origin_loop_info origin_loop;
+hash_map <basic_block, tree> defs_map;
+
+/* Dump the bb information in a loop.  */
+
+static void
+dump_loop_bb (struct loop *loop)
+{
+  basic_block *body = get_loop_body_in_dom_order (loop);
+  basic_block bb = NULL;
+
+  for (unsigned i = 0; i < loop->num_nodes; i++)
+    {
+      bb = body[i];
+      if (bb->loop_father != loop)
+	{
+	  continue;
+	}
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "===== the %dth bb of loop ==========:\n", i);
+	  gimple_dump_bb (dump_file, bb, 0, dump_flags);
+	  fprintf (dump_file, "\n");
+	}
+    }
+  free (body);
+}
+
+/* Return true if the loop has precisely one backedge.  */
+
+static bool
+loop_single_backedge_p (class loop *loop)
+{
+  basic_block latch = loop->latch;
+  if (!single_succ_p (latch))
+    return false;
+
+  edge e = single_succ_edge (latch);
+  edge backedge = find_edge (latch, loop->header);
+
+  if (e != backedge)
+    return false;
+
+  return true;
+}
+
+/* Return true if the loop has precisely one preheader BB.  */
+
+static bool
+loop_single_preheader_bb (class loop *loop)
+{
+  basic_block header = loop->header;
+  if (EDGE_COUNT (header->preds) != 2)
+    return false;
+
+  edge e1 = EDGE_PRED (header, 0);
+  edge e2 = EDGE_PRED (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;
+}
+
+/* Initialize the origin_loop structure.  */
+static void
+init_origin_loop_structure ()
+{
+  origin_loop.base = NULL;
+  origin_loop.limit = NULL;
+  origin_loop.arr1 = NULL;
+  origin_loop.arr2 = NULL;
+  origin_loop.exit_e1 = NULL;
+  origin_loop.exit_e2 = NULL;
+  origin_loop.exit_bb1 = NULL;
+  origin_loop.exit_bb2 =NULL;
+  origin_loop.entry_edge = NULL;
+  origin_loop.cond_stmt1 = NULL;
+  origin_loop.cond_stmt2 = NULL;
+  origin_loop.update_stmt = NULL;
+  origin_loop.exist_prolog_assgin = false;
+  origin_loop.step = 0;
+}
+
+/* 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;
+
+  if (!e)
+    {
+      gcc_assert (!loop_outer (loop));
+      return single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
+    }
+
+  return e;
+}
+
+/* Make sure the exit condition stmt satisfies a specific form.  */
+
+static bool
+check_cond_stmt (gimple *stmt)
+{
+  if (!stmt)
+    return false;
+  if (gimple_code (stmt) != GIMPLE_COND)
+    return false;
+
+  if (gimple_cond_code (stmt) != NE_EXPR && gimple_cond_code (stmt) != EQ_EXPR)
+    return false;
+
+  tree lhs = gimple_cond_lhs (stmt);
+  tree rhs = gimple_cond_rhs (stmt);
+
+  /* The parameter that does not support the cond statement is not SSA_NAME.
+     eg: if (len_1 != 100).  */
+  if (TREE_CODE (lhs) != SSA_NAME || TREE_CODE (rhs) != SSA_NAME)
+    return false;
+
+  return true;
+}
+
+/* Record the exit information in the original loop including exit edge,
+   exit bb block, exit condition stmt,
+   eg: exit_eX origin_exit_bbX cond_stmtX.  */
+
+static bool
+record_origin_loop_exit_info (class loop *loop)
+{
+  bool found = false;
+  edge e = NULL;
+  unsigned i = 0;
+  gimple *stmt;
+
+  if (origin_loop.exit_e1 != NULL || origin_loop.exit_bb1 != NULL
+      || origin_loop.exit_e2 != NULL || origin_loop.exit_bb2 != NULL
+      || origin_loop.cond_stmt1 != NULL || origin_loop.cond_stmt2 != NULL)
+    return false;
+
+  vec<edge> exit_edges = get_loop_exit_edges (loop);
+  if (exit_edges == vNULL)
+    return false;
+
+  if (exit_edges.length () != 2)
+    goto fail;
+
+  FOR_EACH_VEC_ELT (exit_edges, i, e)
+    {
+      if (e->src == loop->header)
+	{
+	  origin_loop.exit_e1 = e;
+	  origin_loop.exit_bb1 = e->dest;
+	  stmt = gsi_stmt (gsi_last_bb (e->src));
+	  if (check_cond_stmt (stmt))
+	    origin_loop.cond_stmt1 = stmt;
+	}
+      else
+	{
+	  origin_loop.exit_e2 = e;
+	  origin_loop.exit_bb2 = e->dest;
+	  stmt = gsi_stmt (gsi_last_bb (e->src));
+	  if (check_cond_stmt (stmt))
+	    origin_loop.cond_stmt2 = stmt;
+	}
+    }
+
+  if (origin_loop.exit_e1 != NULL && origin_loop.exit_bb1 != NULL
+      && origin_loop.exit_e2 != NULL && origin_loop.exit_bb2 != NULL
+      && origin_loop.cond_stmt1 != NULL && origin_loop.cond_stmt2 != NULL)
+    found = true;
+
+fail:
+  exit_edges.release ();
+  return found;
+}
+
+/* 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)
+    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;
+
+  gimple *g = SSA_NAME_DEF_STMT (rhs);
+
+  /* TODO: Currently, the input restrictions on lhs and rhs are implemented
+     through PARM_DECL. We may consider releasing the restrictions later, and
+     we need to consider the overall adaptation scenario and adding test
+     cases. */
+  if (ssa_name_var_p (rhs) && TREE_CODE (SSA_NAME_VAR (rhs)) == PARM_DECL
+      && g && gimple_code (g) == GIMPLE_NOP
+      && (ssa_name_var_p (lhs) && TREE_CODE (SSA_NAME_VAR (lhs)) != PARM_DECL))
+    {
+      origin_loop.limit = rhs;
+    }
+  else
+    return false;
+
+  if (origin_loop.limit != NULL)
+    return true;
+
+  return false;
+}
+
+/* Returns true only when the expression on the rhs code of stmt is PLUS_EXPR,
+   rhs1 is SSA_NAME with the same var as origin_loop base, and rhs2 is
+   INTEGER_CST.  */
+
+static bool
+check_update_stmt (gimple *stmt)
+{
+  if (!stmt)
+    return false;
+
+  if (gimple_assign_rhs_code (stmt) == PLUS_EXPR)
+    {
+      tree rhs1 = gimple_assign_rhs1 (stmt);
+      tree rhs2 = gimple_assign_rhs2 (stmt);
+      if (TREE_CODE (rhs1) == SSA_NAME && TREE_CODE (rhs2) == INTEGER_CST
+	  && same_ssa_name_var_p (rhs1, origin_loop.base))
+	{
+	  origin_loop.step = tree_to_uhwi (rhs2);
+	  if (origin_loop.step == 1)
+	    return true;
+	}
+    }
+  return false;
+}
+
+/* Get origin loop induction variable initial value.  */
+
+static bool
+get_iv_base (gimple *stmt)
+{
+  tree lhs = gimple_cond_lhs (stmt);
+  if (origin_loop.base != NULL || origin_loop.update_stmt != NULL)
+    return false;
+
+  basic_block header = gimple_bb (stmt);
+
+  gphi_iterator gsi;
+  edge e;
+  edge_iterator ei;
+  tree iv_after;
+
+  for (gsi = gsi_start_phis (header); !gsi_end_p (gsi); gsi_next (&gsi))
+    {
+      gphi *phi = gsi.phi ();
+      tree res = gimple_phi_result (phi);
+      if (!same_ssa_name_var_p (res, lhs))
+	continue;
+      tree base = PHI_ARG_DEF_FROM_EDGE (phi, origin_loop.entry_edge);
+      if (!same_ssa_name_var_p (base, lhs))
+	return false;
+      origin_loop.base = base;
+      FOR_EACH_EDGE (e, ei, header->preds)
+	{
+	  if (e != origin_loop.entry_edge)
+	    {
+	      iv_after = PHI_ARG_DEF_FROM_EDGE (phi, e);
+	      gimple *update = SSA_NAME_DEF_STMT (iv_after);
+	      if (!check_update_stmt (update))
+	        return false;
+	      origin_loop.update_stmt = update;
+	      if (gimple_bb (update) == header && iv_after == lhs)
+		origin_loop.exist_prolog_assgin = true;
+	    }
+	}
+    }
+
+  if (origin_loop.base != NULL && origin_loop.update_stmt != NULL)
+    return true;
+
+  return false;
+}
+
+/* Record the upper bound and initial value of the induction variable in the
+   original loop; When prolog_assign is present, make sure loop header is in
+   simple form; And the interpretation of prolog_assign is as follows:
+   eg: while (++len != limit)
+	......
+   For such a loop, ++len will be processed before entering header_bb, and the
+   assign is regarded as the prolog_assign of the loop.  */
+
+static bool
+record_origin_loop_header (class loop *loop)
+{
+  basic_block header = loop->header;
+
+  if (origin_loop.entry_edge != NULL || origin_loop.base != NULL
+      || origin_loop.update_stmt != NULL || origin_loop.limit != NULL)
+    return false;
+  origin_loop.entry_edge = get_loop_preheader_edge (loop);
+
+  gimple_stmt_iterator gsi;
+  gimple *stmt;
+
+  for (gsi = gsi_last_bb (header); !gsi_end_p (gsi); gsi_prev (&gsi))
+    {
+      stmt = gsi_stmt (gsi);
+      if (stmt && is_gimple_debug (stmt))
+        continue;
+      if (stmt && gimple_code (stmt) == GIMPLE_COND)
+	{
+	  if (!get_iv_upper_bound (stmt))
+	    return false;
+	  if (!get_iv_base (stmt))
+	    return false;
+	}
+      else if (stmt && gimple_code (stmt) == GIMPLE_ASSIGN)
+	{
+	  if (stmt != origin_loop.update_stmt || !origin_loop.exist_prolog_assgin)
+	    return false;
+	}
+      else
+	return false;
+    }
+
+  if (origin_loop.entry_edge != NULL && origin_loop.base != NULL
+      && origin_loop.update_stmt != NULL && origin_loop.limit != NULL)
+    return true;
+
+  return false;
+}
+
+/* When prolog_assign does not exist, make sure that update_stmt exists in the
+   loop latch, and its form is a specific form, eg:
+   len_2 = len_1 + 1.  */
+
+static bool
+record_origin_loop_latch (class loop *loop)
+{
+  basic_block latch = loop->latch;
+  gimple_stmt_iterator gsi;
+  gimple *stmt;
+
+  gsi = gsi_start_bb (latch);
+
+  if (origin_loop.exist_prolog_assgin)
+    {
+      if (gsi_end_p (gsi))
+	return true;
+    }
+  else
+    {
+      if (gsi_one_before_end_p (gsi))
+	{
+	  stmt = gsi_stmt (gsi);
+	  if (stmt == origin_loop.update_stmt)
+	    return true;
+	}
+    }
+  return false;
+}
+
+/* Returns true when the DEF_STMT corresponding to arg0 of the mem_ref tree
+   satisfies the POINTER_PLUS_EXPR type.  */
+
+static bool
+check_body_mem_ref (tree mem_ref)
+{
+  tree arg0 = TREE_OPERAND (mem_ref , 0);
+  tree arg1 = TREE_OPERAND (mem_ref , 1);
+
+  if (TREE_CODE (TREE_TYPE (arg0)) == POINTER_TYPE
+      && TREE_CODE (arg1) == INTEGER_CST
+      && tree_to_uhwi (arg1) == 0)
+    {
+      gimple *tmp_g = SSA_NAME_DEF_STMT (arg0);
+      if (tmp_g && gimple_assign_rhs_code (tmp_g) == POINTER_PLUS_EXPR)
+	return true;
+    }
+  return false;
+}
+
+/* Returns true if the rh2 of the current stmt comes from the base in the
+   original loop.  */
+
+static bool
+check_body_pointer_plus (gimple *stmt, tree &tmp_index)
+{
+  tree rhs1 = gimple_assign_rhs1 (stmt);
+  tree rhs2 = gimple_assign_rhs2 (stmt);
+  if (TREE_CODE (TREE_TYPE (rhs1)) == POINTER_TYPE)
+    {
+      gimple *g = SSA_NAME_DEF_STMT (rhs2);
+      if (g && gimple_assign_rhs_code (g) == NOP_EXPR)
+	{
+	  tree nop_rhs = gimple_assign_rhs1 (g);
+	  if (same_ssa_name_var_p (nop_rhs, origin_loop.base))
+	    {
+	      if (!origin_loop.arr1)
+		{
+		  origin_loop.arr1 = rhs1;
+		  tmp_index = rhs2;
+		}
+	      else if (!origin_loop.arr2)
+		{
+		  origin_loop.arr2 = rhs1;
+		  if (tmp_index != rhs2)
+		    return false;
+		}
+	      else
+		return false;
+	      return true;
+	    }
+	}
+    }
+  return false;
+}
+
+/* Record the array comparison information in the original loop, while ensuring
+   that there are only statements related to cont_stmt in the loop body.  */
+
+static bool
+record_origin_loop_body (class loop *loop)
+{
+  basic_block body = gimple_bb (origin_loop.cond_stmt2);
+
+  if (origin_loop.arr1 != NULL || origin_loop.arr2 != NULL)
+    return false;
+
+  gimple_stmt_iterator gsi;
+  for (gsi = gsi_start_bb (body); !gsi_end_p (gsi); gsi_next (&gsi))
+    {
+      gimple_set_visited (gsi_stmt (gsi), false);
+    }
+
+  tree cond_lhs = gimple_cond_lhs (origin_loop.cond_stmt2);
+  tree cond_rhs = gimple_cond_rhs (origin_loop.cond_stmt2);
+  if (TREE_CODE (TREE_TYPE (cond_lhs)) != INTEGER_TYPE
+      || TREE_CODE (TREE_TYPE (cond_rhs)) != INTEGER_TYPE)
+    return false;
+
+  auto_vec<tree> stack;
+  tree tmp_index = NULL;
+  stack.safe_push (cond_lhs);
+  stack.safe_push (cond_rhs);
+  gimple_set_visited (origin_loop.cond_stmt2, true);
+
+  while (!stack.is_empty ())
+    {
+      tree op = stack.pop ();
+      gimple *g = SSA_NAME_DEF_STMT (op);
+      if (!g || gimple_bb (g) != body || !is_gimple_assign (g))
+	continue;
+      gimple_set_visited (g, true);
+      if (gimple_assign_rhs_code (g) == MEM_REF)
+	{
+	  tree mem_ref = gimple_assign_rhs1 (g);
+	  if (!check_body_mem_ref (mem_ref))
+	    return false;
+	  stack.safe_push (TREE_OPERAND (mem_ref , 0));
+	}
+      else if (gimple_assign_rhs_code (g) == POINTER_PLUS_EXPR)
+	{
+	  tree rhs2 = gimple_assign_rhs2 (g);
+	  if (!check_body_pointer_plus (g, tmp_index))
+	    return false;
+	  stack.safe_push (rhs2);
+	}
+      else if (gimple_assign_rhs_code (g) == NOP_EXPR)
+	{
+	  tree rhs = gimple_assign_rhs1 (g);
+	  if (!same_ssa_name_var_p (rhs, origin_loop.base))
+	    return false;
+	  stack.safe_push (rhs);
+	}
+      else
+	return false;
+    }
+  bool allvisited = true;
+  for (gsi = gsi_start_bb (body); !gsi_end_p (gsi); gsi_next (&gsi))
+    {
+      if (!gimple_visited_p (gsi_stmt (gsi))
+	  && !is_gimple_debug (gsi_stmt (gsi)))
+	allvisited = false;
+    }
+  if (allvisited)
+    {
+      if (origin_loop.arr1 != NULL && origin_loop.arr2 != NULL)
+	return true;
+    }
+  return false;
+}
+
+/* Dump the original loop information to see if the origin loop
+   form matches.  */
+
+static void
+dump_origin_loop_info ()
+{
+  if (dump_file && (dump_flags & TDF_DETAILS))
+    {
+      fprintf (dump_file, "\nThe origin loop info:\n");
+      fprintf (dump_file, "\n    the origin_loop.limit is:\n");
+      print_node (dump_file, "", origin_loop.limit, 0);
+      fprintf (dump_file, "\n");
+      fprintf (dump_file, "\n    the origin_loop.base is:\n");
+      print_node (dump_file, "", origin_loop.base, 0);
+      fprintf (dump_file, "\n");
+      fprintf (dump_file, "\n    the origin_loop.arr1 is:\n");
+      print_node (dump_file, "", origin_loop.arr1, 0);
+      fprintf (dump_file, "\n");
+      fprintf (dump_file, "\n    the origin_loop.arr2 is:\n");
+      print_node (dump_file, "", origin_loop.arr2, 0);
+      fprintf (dump_file, "\n");
+      fprintf (dump_file, "\n    the origin_loop.cond_stmt1 is:\n");
+      print_gimple_stmt (dump_file, origin_loop.cond_stmt1, 0);
+      fprintf (dump_file, "\n");
+      fprintf (dump_file, "\n    the origin_loop.cond_stmt2 is:\n");
+      print_gimple_stmt (dump_file, origin_loop.cond_stmt2, 0);
+      fprintf (dump_file, "\n");
+      fprintf (dump_file, "\n    the origin_loop.update_stmt is:\n");
+      print_gimple_stmt (dump_file, origin_loop.update_stmt, 0);
+      fprintf (dump_file, "\n");
+    }
+}
+
+/* Returns true only if the exit bb of the original loop is unique and its phi
+   node parameter comes from the same variable.  */
+
+static bool
+check_exit_bb (class loop *loop)
+{
+  if (origin_loop.exit_bb1 != origin_loop.exit_bb2
+      || flow_bb_inside_loop_p (loop, origin_loop.exit_bb1))
+    return false;
+
+  gphi_iterator gsi;
+  for (gsi = gsi_start_phis (origin_loop.exit_bb1); !gsi_end_p (gsi);
+       gsi_next (&gsi))
+    {
+      gphi *phi = gsi.phi ();
+      tree res = gimple_phi_result (phi);
+      if (!same_ssa_name_var_p (res, origin_loop.base))
+	continue;
+      if (gimple_phi_num_args (phi) == 2)
+	{
+	  tree arg0 = gimple_phi_arg_def (phi, 0);
+	  tree arg1 = gimple_phi_arg_def (phi, 1);
+	  if (arg0 == arg1)
+	    return true;
+	}
+    }
+  return false;
+}
+
+/* Make sure that the recorded origin_loop information meets the
+   relative requirements.  */
+
+static bool
+check_origin_loop_info (class loop *loop)
+{
+  dump_origin_loop_info ();
+  tree arr1_elem_size, arr2_elem_size;
+
+  if (!check_exit_bb (loop))
+    return false;
+
+  if (TREE_CODE (origin_loop.base) != SSA_NAME)
+    return false;
+
+  if (!TYPE_READONLY (TREE_TYPE (origin_loop.limit)))
+    return false;
+
+  if (!TYPE_READONLY (TREE_TYPE (TREE_TYPE (origin_loop.arr1))))
+    return false;
+
+  if (!TYPE_READONLY (TREE_TYPE (TREE_TYPE (origin_loop.arr2))))
+    return false;
+
+  if (TREE_CODE (TREE_TYPE (origin_loop.arr1)) != POINTER_TYPE
+      || TREE_CODE (TREE_TYPE (origin_loop.arr2)) != POINTER_TYPE
+      || TREE_CODE (TREE_TYPE (TREE_TYPE (origin_loop.arr1))) != INTEGER_TYPE
+      || TREE_CODE (TREE_TYPE (TREE_TYPE (origin_loop.arr2))) != INTEGER_TYPE)
+    return false;
+
+  arr1_elem_size = TYPE_SIZE (TREE_TYPE (TREE_TYPE (origin_loop.arr1)));
+  arr2_elem_size = TYPE_SIZE (TREE_TYPE (TREE_TYPE (origin_loop.arr2)));
+
+  if (tree_to_uhwi (arr1_elem_size) != 8 || tree_to_uhwi (arr2_elem_size) != 8)
+    return false;
+
+  return true;
+}
+
+/* Record the useful information of the original loop and judge whether the
+   information meets the specified conditions.  */
+
+static bool
+check_record_loop_form (class loop *loop)
+{
+  if (!record_origin_loop_exit_info (loop))
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nFailed to record loop exit information.\n");
+	}
+      return false;
+    }
+
+  if (!record_origin_loop_header (loop))
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nFailed to record loop header information.\n");
+	}
+      return false;
+    }
+
+  if (!record_origin_loop_latch (loop))
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nFailed to record loop latch information.\n");
+	}
+      return false;
+    }
+
+  if (!record_origin_loop_body (loop))
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nFailed to record loop body information.\n");
+	}
+      return false;
+    }
+
+  if (!check_origin_loop_info (loop))
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nFailed to check origin loop information.\n");
+	}
+      return false;
+    }
+
+  return true;
+}
+
+/* The main entry for judging whether the loop meets some conditions.  */
+
+static bool
+determine_loop_form (class loop *loop)
+{
+  /* Currently only standard loops are processed, that is, only loop_header,
+     loop_latch, loop_body 3 bb blocks are included.  */
+  if (loop->inner || loop->num_nodes != 3)
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nWrong loop form, there is inner loop or"
+			      "redundant bb.\n");
+	}
+      return false;
+    }
+
+  if (single_exit (loop) || !loop->latch)
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nWrong loop form, only one exit or loop_latch"
+			      "does not exist.\n");
+	}
+      return false;
+    }
+
+  /* Support loop with only one backedge.  */
+  if (!loop_single_backedge_p (loop))
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nWrong loop form, loop back edges are not"
+			      "unique.\n");
+	}
+      return false;
+    }
+
+  /* Support loop with only one preheader BB.  */
+  if (!loop_single_preheader_bb (loop))
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\nWrong loop form, loop preheader bb are not"
+			      "unique.\n");
+	}
+      return false;
+    }
+
+  init_origin_loop_structure ();
+  if (!check_record_loop_form (loop))
+    return false;
+
+  return true;
+}
+
+/* Create prolog bb for newly constructed loop; When prolog_assign exists in
+   the original loop, the corresponding assign needs to be added to prolog_bb;
+   eg: <bb 7>
+       len_16 = len_10 + 1
+   Create simple copy statement when prolog_assign does not exist;
+   eg: <bb 7>
+       len_16 = len_10
+
+   The IR of bb is as above.  */
+
+static void
+create_prolog_bb (basic_block &prolog_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;
+  tree lhs1;
+
+  prolog_bb = create_empty_bb (after_bb);
+  add_bb_to_loop (prolog_bb, outer);
+  redirect_edge_and_branch (entry_edge, prolog_bb);
+  set_immediate_dominator (CDI_DOMINATORS, prolog_bb, dominator_bb);
+  gsi = gsi_last_bb (prolog_bb);
+  lhs1 = copy_ssa_name (origin_loop.base);
+
+  if (origin_loop.exist_prolog_assgin)
+    g = gimple_build_assign (lhs1, PLUS_EXPR, origin_loop.base,
+	  build_int_cst (TREE_TYPE (origin_loop.base), origin_loop.step));
+  else
+    g = gimple_build_assign (lhs1, NOP_EXPR, origin_loop.base);
+  gimple_seq_add_stmt (&stmts, g);
+  gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
+  set_current_def (origin_loop.base, lhs1);
+  defs_map.put (prolog_bb, lhs1);
+}
+
+/* Create preheader bb for new loop; In order to ensure the standard form of
+   the loop, add a preheader_bb before loop_header.  */
+
+static void
+create_loop_pred_bb (basic_block &loop_pred_bb, basic_block after_bb,
+		     basic_block dominator_bb, class loop *outer)
+{
+  loop_pred_bb = create_empty_bb (after_bb);
+  add_bb_to_loop (loop_pred_bb, outer);
+  set_immediate_dominator (CDI_DOMINATORS, loop_pred_bb, dominator_bb);
+  defs_map.put (loop_pred_bb, get_current_def (origin_loop.base));
+}
+
+/* Add phi_arg for bb with phi node.  */
+
+static void
+rewrite_add_phi_arg (basic_block bb)
+{
+  edge e;
+  edge_iterator ei;
+  gphi *phi;
+  gphi_iterator gsi;
+  tree res;
+  location_t loc;
+
+  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 = *(defs_map.get (e->src));
+	  if (!same_ssa_name_var_p (var, res))
+	    continue;
+	  if (virtual_operand_p (var))
+	    loc = UNKNOWN_LOCATION;
+	  else
+	    loc = gimple_location (SSA_NAME_DEF_STMT (var));
+	  add_phi_arg (phi, var, e, loc);
+	}
+    }
+}
+
+/* Create loop_header BB for align_loop.
+   eg: <bb 9>
+       _18 = (long unsigned int) len_17;
+       _19 = _18 + 8;
+       _20 = (long unsigned int) len_limit_12 (D);
+       if (_19 <= _20)
+
+   The IR of bb is as above.  */
+
+static void
+create_align_loop_header (basic_block &align_loop_header, basic_block after_bb,
+			  basic_block dominator_bb, class loop *outer)
+{
+  gimple_seq stmts = NULL;
+  gimple_stmt_iterator gsi;
+  gcond *cond_stmt;
+  gphi *phi;
+  tree res;
+
+  tree entry_node = get_current_def (origin_loop.base);
+  align_loop_header = create_empty_bb (after_bb);
+  add_bb_to_loop (align_loop_header, outer);
+  make_single_succ_edge (after_bb, align_loop_header, EDGE_FALLTHRU);
+  set_immediate_dominator (CDI_DOMINATORS, align_loop_header, dominator_bb);
+  gsi = gsi_last_bb (align_loop_header);
+  phi = create_phi_node (NULL_TREE, align_loop_header);
+  create_new_def_for (entry_node, phi, gimple_phi_result_ptr (phi));
+  res = gimple_phi_result (phi);
+
+  tree lhs1 = gimple_build (&stmts, NOP_EXPR, long_unsigned_type_node, res);
+  tree lhs2 = gimple_build (&stmts, PLUS_EXPR, TREE_TYPE (lhs1), lhs1,
+			    build_int_cst (TREE_TYPE (lhs1), 8));
+  tree lhs3 = gimple_build (&stmts, NOP_EXPR, long_unsigned_type_node,
+  				origin_loop.limit);
+  cond_stmt = gimple_build_cond (LE_EXPR, lhs2, lhs3, NULL_TREE, NULL_TREE);
+  gimple_seq_add_stmt (&stmts, cond_stmt);
+  gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
+
+  set_current_def (origin_loop.base, res);
+  defs_map.put (align_loop_header, res);
+}
+
+/* Create loop body BB for align_loop.
+   eg: <bb 10>
+       _21 = (sizetype) len_17;
+       _22 = cur_15 (D) + _21;
+       _23 = MEM[(long unsigned int *)_22];
+       _24 = pb_13 (D) + _21;
+       _25 = MEM[(long unsigned int *)_24];
+       if (_23 != _25)
+
+   The IR of bb is as above.  */
+
+static void
+create_align_loop_body_bb (basic_block &align_loop_body_bb,
+			   basic_block after_bb, basic_block dominator_bb,
+			   class loop *outer)
+{
+  gimple_seq stmts = NULL;
+  gimple_stmt_iterator gsi;
+  gimple *g;
+  gcond *cond_stmt;
+  tree lhs1, lhs2;
+
+  align_loop_body_bb = create_empty_bb (after_bb);
+  add_bb_to_loop (align_loop_body_bb, outer);
+  make_edge (after_bb, align_loop_body_bb, EDGE_TRUE_VALUE);
+  set_immediate_dominator (CDI_DOMINATORS, align_loop_body_bb, dominator_bb);
+  gsi = gsi_last_bb (align_loop_body_bb);
+
+  tree var = gimple_build (&stmts, NOP_EXPR, sizetype,
+			   get_current_def (origin_loop.base));
+  lhs1 = gimple_build (&stmts, POINTER_PLUS_EXPR, TREE_TYPE (origin_loop.arr2),
+  		       origin_loop.arr2, var);
+  g = gimple_build_assign (make_ssa_name (long_unsigned_type_node),
+	fold_build2 (MEM_REF, long_unsigned_type_node, lhs1,
+	  build_int_cst (build_pointer_type (long_unsigned_type_node), 0)));
+  gimple_seq_add_stmt (&stmts, g);
+  lhs1 = gimple_assign_lhs (g);
+  lhs2 = gimple_build (&stmts, POINTER_PLUS_EXPR, TREE_TYPE (origin_loop.arr1),
+  		       origin_loop.arr1, var);
+  g = gimple_build_assign (make_ssa_name (long_unsigned_type_node),
+	fold_build2 (MEM_REF, long_unsigned_type_node, lhs2,
+	  build_int_cst (build_pointer_type (long_unsigned_type_node), 0)));
+  gimple_seq_add_stmt (&stmts, g);
+  lhs2 = gimple_assign_lhs (g);
+  cond_stmt = gimple_build_cond (gimple_cond_code (origin_loop.cond_stmt2),
+  				 lhs1, lhs2, NULL_TREE, NULL_TREE);
+  gimple_seq_add_stmt (&stmts, cond_stmt);
+  gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
+}
+
+/* Create loop_latch BB for align_loop.
+   eg: <bb 11>
+       len_26 = len_17 + 8;
+
+   The IR of bb is as above.  */
+
+static void
+create_align_loop_latch (basic_block &align_loop_latch, basic_block after_bb,
+			 basic_block dominator_bb, class loop *outer)
+{
+  gimple_seq stmts = NULL;
+  gimple_stmt_iterator gsi;
+  gimple *g;
+  tree res;
+
+  tree entry_node = get_current_def (origin_loop.base);
+  align_loop_latch = create_empty_bb (after_bb);
+  add_bb_to_loop (align_loop_latch, outer);
+  make_edge (after_bb, align_loop_latch, EDGE_FALSE_VALUE);
+  set_immediate_dominator (CDI_DOMINATORS, align_loop_latch, dominator_bb);
+  gsi = gsi_last_bb (align_loop_latch);
+  res = copy_ssa_name (entry_node);
+  g = gimple_build_assign (res, PLUS_EXPR, entry_node,
+			   build_int_cst (TREE_TYPE (entry_node), 8));
+  gimple_seq_add_stmt (&stmts, g);
+  gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
+  defs_map.put (align_loop_latch, res);
+}
+
+/* Create a new loop and add it to outer_loop and return.  */
+
+static class loop *
+init_new_loop (class loop *outer_loop, basic_block header, basic_block latch)
+{
+  class loop *new_loop;
+  new_loop = alloc_loop ();
+  new_loop->header = header;
+  new_loop->latch = latch;
+  add_loop (new_loop, outer_loop);
+
+  return new_loop;
+}
+
+/* Create necessary exit BB for align_loop.
+   eg: <bb 12>
+       _27 = _23 ^ _25;
+       _28 = __builtin_ctzll (_27);
+       _29 = _28 >> 3;
+       len_30 = _29 + len_17;
+
+   The IR of bb is as above.  */
+
+static void
+create_align_loop_exit_bb (basic_block &align_loop_exit_bb,
+			   basic_block after_bb, basic_block dominator_bb,
+			   class loop *outer)
+{
+  gimple_seq stmts = NULL;
+  gimple_stmt_iterator gsi;
+  gimple *g;
+  gimple *cond_stmt;
+  tree lhs1, lhs2;
+  tree cond_lhs, cond_rhs;
+  gcall *build_ctzll;
+
+  tree entry_node = get_current_def (origin_loop.base);
+  align_loop_exit_bb = create_empty_bb (after_bb);
+  add_bb_to_loop (align_loop_exit_bb, outer);
+  make_edge (after_bb, align_loop_exit_bb, EDGE_TRUE_VALUE);
+  set_immediate_dominator (CDI_DOMINATORS, align_loop_exit_bb, dominator_bb);
+  gsi = gsi_last_bb (align_loop_exit_bb);
+
+  cond_stmt = gsi_stmt (gsi_last_bb (after_bb));
+  cond_lhs = gimple_cond_lhs (cond_stmt);
+  cond_rhs = gimple_cond_rhs (cond_stmt);
+
+  lhs1 = gimple_build (&stmts, BIT_XOR_EXPR, TREE_TYPE (cond_lhs), cond_lhs,
+  		       cond_rhs);
+  build_ctzll = gimple_build_call (builtin_decl_explicit (BUILT_IN_CTZLL), 1,
+  				   lhs1);
+  lhs1 = make_ssa_name (integer_type_node);
+  gimple_call_set_lhs (build_ctzll, lhs1);
+  gimple_seq_add_stmt (&stmts, build_ctzll);
+  lhs2 = copy_ssa_name (lhs1);
+  g = gimple_build_assign (lhs2, RSHIFT_EXPR, lhs1,
+  			   build_int_cst (TREE_TYPE (lhs1), 3));
+  gimple_seq_add_stmt (&stmts, g);
+  lhs1 = gimple_build (&stmts, NOP_EXPR, TREE_TYPE (entry_node), lhs2);
+  lhs2 = copy_ssa_name (entry_node);
+  g = gimple_build_assign (lhs2, PLUS_EXPR, lhs1, entry_node);
+  gimple_seq_add_stmt (&stmts, g);
+  gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
+  defs_map.put (align_loop_exit_bb, lhs2);
+}
+
+/* Create loop_header BB for epilogue_loop.
+   eg: <bb 14>
+       # len_31 = PHI <len_17 (13), len_37 (16)>
+       if (len_31 != len_limit_12 (D))
+
+   The IR of bb is as above.  */
+
+static void
+create_epilogue_loop_header (basic_block &epilogue_loop_header,
+			     basic_block after_bb, basic_block dominator_bb,
+			     class loop *outer)
+{
+  gimple_seq stmts = NULL;
+  gimple_stmt_iterator gsi;
+  gcond *cond_stmt;
+  tree res;
+  gphi *phi;
+
+  tree entry_node = get_current_def (origin_loop.base);
+  epilogue_loop_header = create_empty_bb (after_bb);
+  add_bb_to_loop (epilogue_loop_header, outer);
+  make_single_succ_edge (after_bb, epilogue_loop_header, EDGE_FALLTHRU);
+  set_immediate_dominator (CDI_DOMINATORS, epilogue_loop_header, dominator_bb);
+  gsi = gsi_last_bb (epilogue_loop_header);
+  phi = create_phi_node (NULL_TREE, epilogue_loop_header);
+  create_new_def_for (entry_node, phi, gimple_phi_result_ptr (phi));
+  res = gimple_phi_result (phi);
+  cond_stmt = gimple_build_cond (gimple_cond_code (origin_loop.cond_stmt1), res,
+  				 origin_loop.limit, NULL_TREE, NULL_TREE);
+  gimple_seq_add_stmt (&stmts, cond_stmt);
+  gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
+
+  set_current_def (origin_loop.base, res);
+  defs_map.put (epilogue_loop_header, res);
+}
+
+/* Create loop body BB for epilogue_loop.
+   eg: <bb 15>
+       _32 = (sizetype) len_31;
+       _33 = pb_13 (D) + _32;
+       _34 = *_33;
+       _35 = cur_15 (D) + _32;
+       _36 = *_35;
+       if (_34 != _36)
+
+   The IR of bb is as above.  */
+
+static void
+create_epilogue_loop_body_bb (basic_block &epilogue_loop_body_bb,
+			      basic_block after_bb, basic_block dominator_bb,
+			      class loop *outer)
+{
+  gimple_seq stmts = NULL;
+  gimple_stmt_iterator gsi;
+  gimple *g;
+  gcond *cond_stmt;
+  tree lhs1, lhs2, lhs3;
+
+  tree entry_node = get_current_def (origin_loop.base);
+  epilogue_loop_body_bb = create_empty_bb (after_bb);
+  add_bb_to_loop (epilogue_loop_body_bb, outer);
+  make_edge (after_bb, epilogue_loop_body_bb, EDGE_TRUE_VALUE);
+  set_immediate_dominator (CDI_DOMINATORS, epilogue_loop_body_bb, dominator_bb);
+  gsi = gsi_last_bb (epilogue_loop_body_bb);
+  lhs1 = gimple_build (&stmts, NOP_EXPR, sizetype, entry_node);
+  lhs2 = gimple_build (&stmts, POINTER_PLUS_EXPR, TREE_TYPE (origin_loop.arr1),
+  		       origin_loop.arr1, lhs1);
+  g = gimple_build_assign (make_ssa_name (unsigned_char_type_node),
+	fold_build2 (MEM_REF, unsigned_char_type_node, lhs2,
+		     build_int_cst (TREE_TYPE (lhs2), 0)));
+  gimple_seq_add_stmt (&stmts, g);
+  lhs2 = gimple_assign_lhs (g);
+  lhs3 = gimple_build (&stmts, POINTER_PLUS_EXPR, TREE_TYPE (origin_loop.arr2),
+  		       origin_loop.arr2, lhs1);
+  g = gimple_build_assign (make_ssa_name (unsigned_char_type_node),
+  	fold_build2 (MEM_REF, unsigned_char_type_node, lhs3,
+		     build_int_cst (TREE_TYPE (lhs3), 0)));
+  gimple_seq_add_stmt (&stmts, g);
+  lhs3 = gimple_assign_lhs (g);
+  cond_stmt = gimple_build_cond (gimple_cond_code (origin_loop.cond_stmt2), lhs2,
+  				 lhs3, NULL_TREE, NULL_TREE);
+  gimple_seq_add_stmt (&stmts, cond_stmt);
+  gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
+  defs_map.put (epilogue_loop_body_bb, get_current_def (origin_loop.base));
+}
+
+/* Create loop_latch BB for epilogue_loop.
+   eg: <bb 16>
+       len_37 = len_31 + 1;
+
+   The IR of bb is as above.  */
+
+static void
+create_epilogue_loop_latch (basic_block &epilogue_loop_latch,
+			    basic_block after_bb, basic_block dominator_bb,
+			    class loop *outer)
+{
+  gimple_seq stmts = NULL;
+  gimple_stmt_iterator gsi;
+  gimple *g;
+  tree res;
+
+  tree entry_node = get_current_def (origin_loop.base);
+  epilogue_loop_latch = create_empty_bb (after_bb);
+  add_bb_to_loop (epilogue_loop_latch, outer);
+  make_edge (after_bb, epilogue_loop_latch, EDGE_FALSE_VALUE);
+  set_immediate_dominator (CDI_DOMINATORS, epilogue_loop_latch, dominator_bb);
+  gsi = gsi_last_bb (epilogue_loop_latch);
+  res = copy_ssa_name (entry_node);
+  g = gimple_build_assign (res, PLUS_EXPR, entry_node,
+	build_int_cst (TREE_TYPE (entry_node), origin_loop.step));
+  gimple_seq_add_stmt (&stmts, g);
+  gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
+  defs_map.put (epilogue_loop_latch, res);
+}
+
+/* convert_to_new_loop
+   |               |
+   |               |
+   |               | entry_edge
+   |    ______     |
+   |  /       V    V
+   | |       -----origin_loop_header---
+   | |      |                          |
+   | |       -------------------------\
+   | |        |                        \
+   | |        V                         \___ ___ ___ ___ ___ ___ ___
+   | |       -----origin_loop_body-----                             |
+   | |      |                          |                            |
+   | |       -------------------------\                             |
+   | |        |                        \___ ___ ___ ___             |
+   | |        V                                        V            V
+   | |       -----origin_loop_latch----              -----exit_bb------
+   | |      |                          |            |                  |
+   | |      /--------------------------              ------------------
+   |  \ __ /
+   |
+   |                         |
+   |  ====>                  |entry_edge
+   |                         V
+   |                      -------prolog_bb-----
+   |                     |                     |
+   |                      ---------------------
+   |                         |
+   |                         V
+   |                      -----align_loop_header----
+   | /-----------------> |                          |
+   |/                     --------------------------
+   ||                        /                   \
+   ||                       V                     V
+   ||     ---align_loop_body---                ---epilogue_loop_header--
+   ||    |                     |       -------|                         |<---|
+   ||     --------------------\       /        -------------------------     |
+   ||              |           \____  |                   |                  |
+   ||              V                | |                   V                  |
+   ||     ---align_loop_latch---    | |        ---epilogue_loop_body----     |
+   ||    |                      |   | |   ----|                         |    |
+   ||     ----------------------    | |  /     -------------------------     |
+   ||              /     __________/  |  |                |                  |
+   ||             /     |             |  |                V                  |
+   | \ __________/      |             |  |     ---epilogue_loop_latch---     |
+   |                    |             |  |    |                         |    |
+   |                    |             |  |     -------------------------    /
+   |                    V             |  |                |                /
+   |        -align_loop_exit_bb-      |  |                 \______________/
+   |       |                    |     |  |
+   |        --------------------      |  |
+   |                |                 |  |
+   |                |                 V  V
+   |                |      -----exit_bb------
+   |                |---->|                  |
+   |                       ------------------
+
+   The origin_loop conversion process starts from entry_edge and ends at
+   exit_bb; The execution logic of origin_loop is completely replaced by
+   align_loop + epilogue_loop:
+     1) align_loop mainly implements the idea of using wide-type dereference
+	and comparison on array elements, so as to achieve the effect of
+	acceleration; For the corresponding source code understanding, please
+	refer to the description of the pass at the beginning;
+     2) epilogue_loop processes the previous loop remaining array element
+	comparison.  */
+
+static void
+create_new_loops (edge entry_edge)
+{
+  basic_block prolog_bb;
+  basic_block align_loop_header, align_loop_latch, align_loop_body_bb;
+  basic_block align_pred_bb, align_loop_exit_bb;
+  basic_block epilogue_loop_header, epilogue_loop_latch, epilogue_loop_body_bb;
+  basic_block epilogue_loop_pred_bb;
+  class loop *align_loop;
+  class loop *epilogue_loop;
+
+  class loop *outer = entry_edge->src->loop_father;
+
+  create_prolog_bb (prolog_bb, entry_edge->src, entry_edge->src, outer,
+  		    entry_edge);
+
+  create_loop_pred_bb (align_pred_bb, prolog_bb, prolog_bb, outer);
+  make_single_succ_edge (prolog_bb, align_pred_bb, EDGE_FALLTHRU);
+
+  create_align_loop_header (align_loop_header, align_pred_bb,
+  					align_pred_bb, outer);
+
+  create_align_loop_body_bb (align_loop_body_bb, align_loop_header,
+  			     align_loop_header, outer);
+
+  create_align_loop_latch (align_loop_latch, align_loop_body_bb,
+  			   align_loop_body_bb, outer);
+  make_edge (align_loop_latch, align_loop_header, EDGE_FALLTHRU);
+  rewrite_add_phi_arg (align_loop_header);
+
+  align_loop = init_new_loop (outer, align_loop_header, align_loop_latch);
+  if (dump_file && (dump_flags & TDF_DETAILS))
+    {
+      fprintf (dump_file, "\nPrint byte align loop %d:\n", align_loop->num);
+      flow_loop_dump (align_loop, dump_file, NULL, 1);
+      fprintf (dump_file, "\n\n");
+    }
+
+  create_align_loop_exit_bb (align_loop_exit_bb, align_loop_body_bb,
+  			     align_loop_body_bb, outer);
+
+  create_loop_pred_bb (epilogue_loop_pred_bb, align_loop_header,
+  		       align_loop_header, outer);
+  make_edge (align_loop_header, epilogue_loop_pred_bb, EDGE_FALSE_VALUE);
+
+  create_epilogue_loop_header (epilogue_loop_header, epilogue_loop_pred_bb,
+  			       epilogue_loop_pred_bb, outer);
+
+  create_epilogue_loop_body_bb (epilogue_loop_body_bb, epilogue_loop_header,
+  				epilogue_loop_header, outer);
+
+  create_epilogue_loop_latch (epilogue_loop_latch, epilogue_loop_body_bb,
+  			      epilogue_loop_body_bb, outer);
+  make_single_succ_edge (epilogue_loop_latch, epilogue_loop_header,
+  			 EDGE_FALLTHRU);
+  rewrite_add_phi_arg (epilogue_loop_header);
+
+  epilogue_loop = init_new_loop (outer, epilogue_loop_header,
+  				 epilogue_loop_latch);
+  if (dump_file && (dump_flags & TDF_DETAILS))
+    {
+      fprintf (dump_file, "\nPrint epilogue loop %d:\n", epilogue_loop->num);
+      flow_loop_dump (epilogue_loop, dump_file, NULL, 1);
+      fprintf (dump_file, "\n\n");
+    }
+  make_single_succ_edge (align_loop_exit_bb, origin_loop.exit_bb1,
+  			 EDGE_FALLTHRU);
+  set_immediate_dominator (CDI_DOMINATORS, origin_loop.exit_bb1,
+  			   entry_edge->src);
+  make_edge (epilogue_loop_body_bb, origin_loop.exit_bb1, EDGE_TRUE_VALUE);
+
+  make_edge (epilogue_loop_header, origin_loop.exit_bb2, EDGE_FALSE_VALUE);
+  set_immediate_dominator (CDI_DOMINATORS, origin_loop.exit_bb2,
+  			   entry_edge->src);
+
+  rewrite_add_phi_arg (origin_loop.exit_bb1);
+  rewrite_add_phi_arg (origin_loop.exit_bb2);
+
+  remove_edge (origin_loop.exit_e1);
+  remove_edge (origin_loop.exit_e2);
+}
+
+/* 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_bb1)
+	{
+	  set_immediate_dominator (CDI_DOMINATORS, bb,
+	  			   recompute_dominator (CDI_DOMINATORS, bb));
+	  continue;
+	}
+    }
+}
+
+/* Clear information about the original loop.  */
+
+static void
+remove_origin_loop (class loop *loop)
+{
+  basic_block *body;
+
+  body = get_loop_body_in_dom_order (loop);
+  unsigned n = loop->num_nodes;
+  for (unsigned i = 0; i < n; i++)
+    {
+	  delete_basic_block (body[i]);
+    }
+  free (body);
+  delete_loop (loop);
+}
+
+/* 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 array-widen-compare optimizes.  */
+
+static unsigned int
+tree_ssa_array_widen_compare ()
+{
+  unsigned int todo = 0;
+  class loop *loop;
+
+  if (dump_file && (dump_flags & TDF_DETAILS))
+    {
+      flow_loops_dump (dump_file, NULL, 1);
+      fprintf (dump_file, "\nConfirm which loop can be optimized using"
+			  " array-widen-compare\n");
+    }
+
+  enum li_flags LI = LI_FROM_INNERMOST;
+  FOR_EACH_LOOP (loop, 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 (determine_loop_form (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);
+	      dump_loop_bb (loop);
+	    }
+
+	  convert_to_new_loop (loop);
+	}
+    }
+
+  todo |= (TODO_update_ssa);
+  return todo;
+}
+
+/* Array widen compare.  */
+
+namespace {
+
+const pass_data pass_data_tree_array_widen_compare =
+{
+  GIMPLE_PASS,
+  "awiden_compare",
+  OPTGROUP_LOOP,
+  TV_TREE_ARRAY_WIDEN_COMPARE,
+  (PROP_cfg | PROP_ssa),
+  0,
+  0,
+  0,
+  (TODO_update_ssa | TODO_verify_all)
+};
+
+class pass_array_widen_compare : public gimple_opt_pass
+{
+public:
+  pass_array_widen_compare (gcc::context *ctxt)
+    : gimple_opt_pass (pass_data_tree_array_widen_compare, ctxt)
+  {}
+
+  /* opt_pass methods: */
+  virtual bool gate (function *);
+  virtual unsigned int execute (function *);
+
+}; // class pass_array_widen_compare
+
+bool
+pass_array_widen_compare::gate (function *)
+{
+  return (flag_array_widen_compare > 0 && optimize >= 3);
+}
+
+unsigned int
+pass_array_widen_compare::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_array_widen_compare ();
+}
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_array_widen_compare (gcc::context *ctxt)
+{
+  return new pass_array_widen_compare (ctxt);
+}
\ No newline at end of file
-- 
2.27.0.windows.1