File _service:tar_scm:0018-StructReorderFields-Struc... of Package gcc

File _service:tar_scm:0018-StructReorderFields-Structure-reorder-fields.patch of Package gcc (Revision b944475d462b415bcfdac94829a5265f)

Currently displaying revision b944475d462b415bcfdac94829a5265f , Show latest

From bc86209da93f71d9fd48cb65ad3200b6c88cf75b Mon Sep 17 00:00:00 2001
From: huangxiaoquan <huangxiaoquan1@huawei.com>
Date: Tue, 20 Jul 2021 10:09:08 +0800
Subject: [PATCH 18/22] [StructReorderFields] Structure reorder fields

Introduce structure fields reordering optimization, that change
fields ordering of C-like structures in order to better utilize spatial
locality.

diff --git a/gcc/common.opt b/gcc/common.opt
index d096ff9c314..73c24f28d22 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -1865,6 +1865,10 @@ fipa-matrix-reorg
 Common Ignore
 Does nothing. Preserved for backward compatibility.
 
+fipa-reorder-fields
+Common Report Var(flag_ipa_reorder_fields) Init(0) Optimization
+Perform structure fields reorder optimizations.
+
 fipa-struct-reorg
 Common Report Var(flag_ipa_struct_reorg) Init(0) Optimization
 Perform structure layout optimizations.
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 7b4578e3e44..4b0fd2ffb38 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -478,6 +478,7 @@ Objective-C and Objective-C++ Dialects}.
 -finline-functions  -finline-functions-called-once  -finline-limit=@var{n} @gol
 -finline-small-functions  -fipa-cp  -fipa-cp-clone @gol
 -fipa-bit-cp  -fipa-vrp  -fipa-pta  -fipa-profile  -fipa-pure-const @gol
+-fipa-reorder-fields @gol
 -fipa-struct-reorg @gol
 -fipa-reference  -fipa-reference-addressable @gol
 -fipa-stack-alignment  -fipa-icf  -fira-algorithm=@var{algorithm} @gol
@@ -10224,6 +10225,14 @@ Enabled by default at @option{-O} and higher.
 Reduce stack alignment on call sites if possible.
 Enabled by default.
 
+@item -fipa-reorder-fields
+@opindex fipa-reorder-fields
+Introduce structure fields reordering optimization, that change fields
+ordering of C-like structures in order to better utilize spatial locality.
+This transformation is affective for programs containing arrays of structures.
+It works only in whole program mode, so it requires @option{-fwhole-program}
+to be enabled.
+
 @item -fipa-struct-reorg
 @opindex fipa-struct-reorg
 Perform structure reorganization optimization, that change C-like structures
diff --git a/gcc/ipa-struct-reorg/escapes.def b/gcc/ipa-struct-reorg/escapes.def
index 9020cc48952..03adc30811a 100644
--- a/gcc/ipa-struct-reorg/escapes.def
+++ b/gcc/ipa-struct-reorg/escapes.def
@@ -58,5 +58,8 @@ DEF_ESCAPE (escape_ptr_ptr, "Type is used in a pointer to a pointer [not handled
 DEF_ESCAPE (escape_return, "Type escapes via a return [not handled yet]")
 DEF_ESCAPE (escape_separate_instance, "Type escapes via a separate instance")
 DEF_ESCAPE (escape_unhandled_rewrite, "Type escapes via a unhandled rewrite stmt")
+DEF_ESCAPE (escape_via_orig_escape, "Type escapes via a original escape type")
+DEF_ESCAPE (escape_instance_field, "Type escapes via a field of instance")
+DEF_ESCAPE (escape_via_empty_no_orig, "Type escapes via empty and no original")
 
 #undef DEF_ESCAPE
diff --git a/gcc/ipa-struct-reorg/ipa-struct-reorg.c b/gcc/ipa-struct-reorg/ipa-struct-reorg.c
index 1cb544ec3b0..384aa81583c 100644
--- a/gcc/ipa-struct-reorg/ipa-struct-reorg.c
+++ b/gcc/ipa-struct-reorg/ipa-struct-reorg.c
@@ -198,27 +198,66 @@ lang_c_p (void)
     }
 
   return false;
+
+/* Get the number of pointer layers.  */
+
+int
+get_ptr_layers (tree expr)
+{
+  int layers = 0;
+  while (POINTER_TYPE_P (expr) || TREE_CODE (expr) == ARRAY_TYPE)
+    {
+      layers++;
+      expr = TREE_TYPE (expr);
+    }
+  return layers;
+}
+
+/* Comparison pointer layers.  */
+
+bool
+cmp_ptr_layers (tree a, tree b)
+{
+  return get_ptr_layers (a) == get_ptr_layers (b);
+}
+
+/*  Return true if the ssa_name comes from the void* parameter.  */
+
+bool
+is_from_void_ptr_parm (tree ssa_name)
+{
+  gcc_assert (TREE_CODE (ssa_name) == SSA_NAME);
+  tree var = SSA_NAME_VAR (ssa_name);
+  return (var && TREE_CODE (var) == PARM_DECL
+	  && VOID_POINTER_P (TREE_TYPE (ssa_name)));
 }
 
 enum srmode
 {
   NORMAL = 0,
-  COMPLETE_STRUCT_RELAYOUT
+  COMPLETE_STRUCT_RELAYOUT,
+  STRUCT_REORDER_FIELDS
 };
 
 static bool is_result_of_mult (tree arg, tree *num, tree struct_size);
+bool isptrptr (tree type);
+
+srmode current_mode;
 
 } // anon namespace
 
 namespace struct_reorg {
 
+hash_map <tree, auto_vec <tree> > fields_to_finish;
+
 /* Constructor of srfunction. */
 
 srfunction::srfunction (cgraph_node *n)
   : node (n),
     old (NULL),
     newnode (NULL),
-    newf (NULL)
+    newf (NULL),
+    is_safe_func (false)
 {
 }
 
@@ -370,12 +409,13 @@ srtype::add_field_site (srfield *field)
 
 /* Constructor of DECL. */
 
-srdecl::srdecl (srtype *tp, tree decl, int argnum)
+srdecl::srdecl (srtype *tp, tree decl, int argnum, tree orig_type)
   : type (tp),
     decl (decl),
     func (NULL_TREE),
     argumentnum (argnum),
-    visited (false)
+    visited (false),
+    orig_type (orig_type)
 {
   if (TREE_CODE (decl) == SSA_NAME)
     func = current_function_decl;
@@ -399,17 +439,25 @@ srfunction::find_decl (tree decl)
 /* Record DECL of the TYPE with argument num ARG. */
 
 srdecl *
-srfunction::record_decl (srtype *type, tree decl, int arg)
+srfunction::record_decl (srtype *type, tree decl, int arg, tree orig_type)
 {
-  // Search for the decl to see if it is already there.
+  /* Search for the decl to see if it is already there.  */
   srdecl *decl1 = find_decl (decl);
 
   if (decl1)
-    return decl1;
+    {
+      /* Added the orig_type information.  */
+      if (!decl1->orig_type && orig_type && isptrptr (orig_type))
+	{
+	  decl1->orig_type = orig_type;
+	}
+      return decl1;
+    }
 
   gcc_assert (type);
 
-  decl1 = new srdecl (type, decl, arg);
+  orig_type = isptrptr (TREE_TYPE (decl)) ? TREE_TYPE (decl) : orig_type;
+  decl1 = new srdecl (type, decl, arg, isptrptr (orig_type)? orig_type : NULL);
   decls.safe_push(decl1);
   return decl1;
 }
@@ -473,31 +521,29 @@ srtype::dump (FILE *f)
   print_generic_expr (f, type);
   fprintf (f, "(%d) { ", TYPE_UID (type));
   if (escapes != does_not_escape)
-    fprintf (f, " escapes = \"%s\"\n", escape_reason ());
-  fprintf (f, " fields = { ");
+    {
+      fprintf (f, "escapes = \"%s\"", escape_reason ());
+    }
+  fprintf (f, "\nfields = {\n");
   FOR_EACH_VEC_ELT (fields, i, field)
     {
-      if (i == 0)
-	fprintf (f, "\n  ");
-      else
-	fprintf (f, "\n,  ");
       field->dump (f);
     }
-  fprintf (f, " }\n ");
-  fprintf (f, "\n accesses = {");
+  fprintf (f, "}\n ");
+
+  fprintf (f, "\naccesses = {\n");
   FOR_EACH_VEC_ELT (accesses, i, access)
     {
-      fprintf (f, "\n");
       access->dump (f);
     }
-  fprintf (f, " }\n ");
-  fprintf (f, "\n functions = {");
+  fprintf (f, "}\n ");
+
+  fprintf (f, "\nfunctions = {\n");
   FOR_EACH_VEC_ELT (functions, i, fn)
     {
-      fprintf (f, "  \n");
       fn->simple_dump (f);
     }
-  fprintf (f, "\n }\n");
+  fprintf (f, "}\n");
   fprintf (f, "}\n");
 }
 
@@ -507,6 +553,10 @@ void
 srtype::simple_dump (FILE *f)
 {
   print_generic_expr (f, type);
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      fprintf (f, "(%d)", TYPE_UID (type));
+    }
 }
 
 /* Analyze the type and decide what to be done with it. */
@@ -544,6 +594,12 @@ srfield::create_new_fields (tree newtype[max_split],
 			    tree newfields[max_split],
 			    tree newlast[max_split])
 {
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      create_new_reorder_fields (newtype, newfields, newlast);
+      return;
+    }
+
   tree nt[max_split];
 
   for (unsigned i = 0; i < max_split; i++)
@@ -592,6 +648,117 @@ srfield::create_new_fields (tree newtype[max_split],
 
 }
 
+/* Reorder fields.  */
+
+void
+srfield::reorder_fields (tree newfields[max_split], tree newlast[max_split],
+			 tree &field)
+{
+  /* Reorder fields in descending.
+     newfields: always stores the first member of the chain
+		and with the largest size.
+     field: indicates the node to be inserted.  */
+  if (newfields[clusternum] == NULL)
+    {
+      newfields[clusternum] = field;
+      newlast[clusternum] = field;
+    }
+  else
+    {
+      tree tmp = newfields[clusternum];
+      if (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field)))
+	  > tree_to_uhwi (TYPE_SIZE (TREE_TYPE (tmp))))
+	{
+	  DECL_CHAIN (field) = tmp;
+	  newfields[clusternum] = field;
+	}
+      else
+	{
+	  while (DECL_CHAIN (tmp)
+		 && (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field)))
+		     <= tree_to_uhwi (
+				TYPE_SIZE (TREE_TYPE (DECL_CHAIN (tmp))))))
+	    {
+	      tmp = DECL_CHAIN (tmp);
+	    }
+
+	  /* now tmp size > field size
+	     insert field: tmp -> xx ==> tmp -> field -> xx.  */
+	  DECL_CHAIN (field) = DECL_CHAIN (tmp); // field -> xx
+	  DECL_CHAIN (tmp) = field; // tmp -> field
+	}
+    }
+}
+
+/* Create the new reorder fields for this field.
+   newtype[max_split]: srtype's member variable,
+   newfields[max_split]: created by create_new_type func,
+   newlast[max_split]: created by create_new_type func.  */
+
+void
+srfield::create_new_reorder_fields (tree newtype[max_split],
+				    tree newfields[max_split],
+				    tree newlast[max_split])
+{
+  /* newtype, corresponding to newtype[max_split] in srtype.  */
+  tree nt = NULL_TREE;
+  if (type == NULL)
+    {
+      /* Common var.  */
+      nt = fieldtype;
+    }
+  else
+    {
+      /* RECORD_TYPE var.  */
+      if (type->has_escaped ())
+	{
+	  nt = type->type;
+	}
+      else
+	{
+	  nt = type->newtype[0];
+	}
+    }
+  tree field = make_node (FIELD_DECL);
+
+  /* Used for recursive types.
+     fields_to_finish: hase_map in the format of "type: {fieldA, fieldB}",
+     key : indicates the original type,
+     vaule: filed that need to be updated to newtype.  */
+  if (nt == NULL)
+    {
+      nt = make_node (RECORD_TYPE);
+      auto_vec <tree> &fields
+	= fields_to_finish.get_or_insert (inner_type (type->type));
+      fields.safe_push (field);
+    }
+
+  DECL_NAME (field) = DECL_NAME (fielddecl);
+  if (type == NULL)
+    {
+      /* Common members do not need to reconstruct.
+	 Otherwise, int* -> int** or void* -> void**.  */
+      TREE_TYPE (field) = nt;
+    }
+  else
+    {
+      TREE_TYPE (field)
+	      = reconstruct_complex_type (TREE_TYPE (fielddecl), nt);
+    }
+  DECL_SOURCE_LOCATION (field) = DECL_SOURCE_LOCATION (fielddecl);
+  SET_DECL_ALIGN (field, DECL_ALIGN (fielddecl));
+  DECL_USER_ALIGN (field) = DECL_USER_ALIGN (fielddecl);
+  TREE_ADDRESSABLE (field) = TREE_ADDRESSABLE (fielddecl);
+  DECL_NONADDRESSABLE_P (field) = !TREE_ADDRESSABLE (fielddecl);
+  TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (fielddecl);
+  DECL_CONTEXT (field) = newtype[clusternum];
+
+  reorder_fields (newfields, newlast, field);
+
+  /* srfield member variable, which stores the new field decl.  */
+  newfield[0] = field;
+}
+
 /* Create the new TYPE corresponding to THIS type. */
 
 bool
@@ -627,7 +794,8 @@ srtype::create_new_type (void)
   /* If the fields' types did have a change or
      we are not splitting the struct into two clusters,
      then just return false and don't change the type. */
-  if (!createnewtype && maxclusters == 0)
+  if (!createnewtype && maxclusters == 0
+      && current_mode != STRUCT_REORDER_FIELDS)
     {
       newtype[0] = type;
       return false;
@@ -636,6 +804,7 @@ srtype::create_new_type (void)
   /* Should have at most max_split clusters.  */
   gcc_assert (maxclusters < max_split);
 
+  /* Record the first member of the field chain.  */
   tree newfields[max_split];
   tree newlast[max_split];
 
@@ -654,7 +823,8 @@ srtype::create_new_type (void)
       sprintf(id, "%d", i);
       if (tname) 
 	{
-          name = concat (tname, ".reorg.", id, NULL);
+	  name = concat (tname, current_mode == STRUCT_REORDER_FIELDS
+			 ? ".reorder." : ".reorg.", id, NULL);
 	  TYPE_NAME (newtype[i]) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
 				   get_identifier (name), newtype[i]);
           free (name);
@@ -691,6 +861,7 @@ srtype::create_new_type (void)
       for (unsigned i = 0; i < maxclusters; i++)
 	{
 	  print_generic_expr (dump_file, newtype[i]);
+	  fprintf (dump_file, "(%d)", TYPE_UID (newtype[i]));
 	  fprintf (dump_file, "\n");
 	}
     }
@@ -749,7 +920,12 @@ srfunction::create_new_decls (void)
 	  tree newinner[max_split];
 	  memset (newinner, 0, sizeof(newinner));
 	  for (unsigned j = 0; j < max_split && type->newtype[j]; j++)
-	    newtype1[j] = reconstruct_complex_type (TREE_TYPE (decls[i]->decl), type->newtype[j]);
+	    {
+	      newtype1[j] = reconstruct_complex_type (
+		      isptrptr (decls[i]->orig_type) ? decls[i]->orig_type
+		      : TREE_TYPE (decls[i]->decl),
+		      type->newtype[j]);
+	    }
 	  if (inner)
 	    {
 	      srdecl *in = find_decl (inner);
@@ -794,7 +970,8 @@ srfunction::create_new_decls (void)
 	      sprintf(id, "%d", j);
 	      if (tname)
 	        {
-	          name = concat (tname, ".reorg.", id, NULL);
+		  name = concat (tname, current_mode == STRUCT_REORDER_FIELDS
+					? ".reorder." : ".reorg.", id, NULL);
 		  new_name = get_identifier (name);
 		  free (name);
 		}
@@ -818,7 +995,6 @@ srfunction::create_new_decls (void)
       if (dump_file && (dump_flags & TDF_DETAILS))
 	{
 	  fprintf (dump_file, "Created New decls for decl:\n");
-	  fprintf (dump_file, "\n");
 	  decls[i]->dump (dump_file);
 	  fprintf (dump_file, "\n");
 	  for (unsigned j = 0; j < max_split && decls[i]->newdecl[j]; j++)
@@ -845,7 +1021,7 @@ srfield::dump (FILE *f)
   fprintf (f, ", offset = " HOST_WIDE_INT_PRINT_DEC, offset);
   fprintf (f, ", type = ");
   print_generic_expr (f, fieldtype);
-  fprintf (f, "\n}\n");
+  fprintf (f, "}\n");
 }
 
 
@@ -880,7 +1056,7 @@ sraccess::dump (FILE *f)
   fprintf (f, " in function: %s/%d", node->name (), node->order);
   fprintf (f, ", stmt:\n");
   print_gimple_stmt (f, stmt, 0);
-  fprintf (f, "\n }\n");
+  fprintf (f, "}\n");
   
 }
 
@@ -1010,8 +1186,7 @@ public:
   // Constructors
   ipa_struct_reorg(void)
     : current_function (NULL),
-      done_recording (false),
-      current_mode (NORMAL)
+      done_recording (false)
   {
   }
 
@@ -1023,11 +1198,12 @@ public:
   auto_vec_del<srfunction> functions;
   srglobal globals;
   srfunction *current_function;
+  hash_set <cgraph_node *> safe_functions;
 
   bool done_recording;
-  srmode current_mode;
 
   void dump_types (FILE *f);
+  void dump_newtypes (FILE *f);
   void dump_types_escaped (FILE *f);
   void dump_functions (FILE *f);
   void record_accesses (void);
@@ -1035,6 +1211,8 @@ public:
   bool walk_field_for_cycles (srtype*);
   void prune_escaped_types (void);
   void propagate_escape (void);
+  void propagate_escape_via_original (void);
+  void propagate_escape_via_empty_with_no_original (void);
   void analyze_types (void);
   void clear_visited (void);
   bool create_new_types (void);
@@ -1044,8 +1222,11 @@ public:
   void create_new_args (cgraph_node *new_node);
   unsigned rewrite_functions (void);
   srdecl *record_var (tree decl, escape_type escapes = does_not_escape, int arg = -1);
+  void record_safe_func_with_void_ptr_parm (void);
   srfunction *record_function (cgraph_node *node);
   srfunction *find_function (cgraph_node *node);
+  void record_field_type (tree field, srtype *base_srtype);
+  void record_struct_field_types (tree base_type, srtype *base_srtype);
   srtype *record_type (tree type);
   void process_union (tree type);
   srtype *find_type (tree type);
@@ -1056,7 +1237,7 @@ public:
   void record_stmt_expr (tree expr, cgraph_node *node, gimple *stmt);
   void mark_expr_escape(tree, escape_type, gimple *stmt);
   bool handled_allocation_stmt (gimple *stmt);
-  tree allocate_size (srtype *t, gimple *stmt);
+  tree allocate_size (srtype *t, srdecl *decl, gimple *stmt);
 
   void mark_decls_in_as_not_needed (tree fn);
 
@@ -1068,15 +1249,22 @@ public:
   bool rewrite_phi (gphi *);
   bool rewrite_expr (tree expr, tree newexpr[max_split], bool ignore_missing_decl = false);
   bool rewrite_lhs_rhs (tree lhs, tree rhs, tree newlhs[max_split], tree newrhs[max_split]);
-  bool get_type_field (tree expr, tree &base, bool &indirect, srtype *&type, srfield *&field, bool &realpart, bool &imagpart, bool &address, bool should_create = false, bool can_escape = false);
+  bool get_type_field (tree expr, tree &base, bool &indirect, srtype *&type,
+		       srfield *&field, bool &realpart, bool &imagpart,
+		       bool &address, bool& escape_from_base,
+		       bool should_create = false, bool can_escape = false);
   bool wholeaccess (tree expr, tree base, tree accesstype, srtype *t);
 
   void check_alloc_num (gimple *stmt, srtype *type);
+  void check_definition_assign (srdecl *decl, vec<srdecl*> &worklist);
+  void check_definition_call (srdecl *decl, vec<srdecl*> &worklist);
   void check_definition (srdecl *decl, vec<srdecl*>&);
   void check_uses (srdecl *decl, vec<srdecl*>&);
   void check_use (srdecl *decl, gimple *stmt, vec<srdecl*>&);
-  void check_type_and_push (tree newdecl, srtype *type, vec<srdecl*> &worklist, gimple *stmt);
+  void check_type_and_push (tree newdecl, srdecl *decl,
+  			    vec<srdecl*> &worklist, gimple *stmt);
   void check_other_side (srdecl *decl, tree other, gimple *stmt, vec<srdecl*> &worklist);
+  void check_ptr_layers (tree a_expr, tree b_expr, gimple* stmt);
 
   void find_vars (gimple *stmt);
   void find_var (tree expr, gimple *stmt);
@@ -1731,9 +1919,45 @@ ipa_struct_reorg::dump_types (FILE *f)
   srtype *type;
   FOR_EACH_VEC_ELT (types, i, type)
     {
+      fprintf (f, "======= the %dth type: ======\n", i);
       type->dump(f);
+      fprintf (f, "\n");
+    }
+}
+
+/* Dump all of the created newtypes to file F.  */
+
+void
+ipa_struct_reorg::dump_newtypes (FILE *f)
+{
+    unsigned i = 0;
+    srtype *type = NULL;
+    FOR_EACH_VEC_ELT (types, i, type)
+    {
+	if (type->has_escaped ())
+	  {
+	    continue;
+	  }
+	fprintf (f, "======= the %dth newtype: ======\n", i);
+	fprintf (f, "type : ");
+	print_generic_expr (f, type->newtype[0]);
+	fprintf (f, "(%d) ", TYPE_UID (type->newtype[0]));
+	fprintf (f, "{ ");
+	fprintf (f, "\nfields = {\n");
+
+	for (tree field = TYPE_FIELDS (TYPE_MAIN_VARIANT (type->newtype[0]));
+				       field; field = DECL_CHAIN (field))
+	  {
+	    fprintf (f, "field (%d) ", DECL_UID (field));
+	    fprintf (f, "{");
+	    fprintf (f, "type = ");
+	    print_generic_expr (f, TREE_TYPE (field));
+	    fprintf (f, "}\n");
+	  }
+	fprintf (f, "}\n ");
+
+	fprintf (f, "\n");
     }
-  fprintf (f, "\n");
 }
 
 /* Dump all of the recorded types to file F. */
@@ -1763,7 +1987,6 @@ ipa_struct_reorg::dump_functions (FILE *f)
   unsigned i;
   srfunction *fn;
 
-  fprintf (f, "\n\n");
   globals.dump (f);
   fprintf (f, "\n\n");
   FOR_EACH_VEC_ELT (functions, i, fn)
@@ -1829,6 +2052,10 @@ bool isarraytype (tree type)
 
 bool isptrptr (tree type)
 {
+  if (type == NULL)
+    {
+      return false;
+    }
   bool firstptr = false;
   while (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
     {
@@ -1843,129 +2070,808 @@ bool isptrptr (tree type)
   return false;
 }
 
-/* Return the escape type which corresponds to if
-   this is an volatile type, an array type or a pointer
-   to a pointer type.  */
+/* Adding node to map and stack.  */
 
-escape_type escape_type_volatile_array_or_ptrptr (tree type)
+bool
+add_node (tree node, int layers, hash_map <tree, int> &map,
+	  auto_vec <tree> &stack)
 {
-  if (isvolatile_type (type))
-    return escape_volatile;
-  if (isarraytype (type))
-    return escape_array;
-  if (isptrptr (type))
-    return escape_ptr_ptr;
-  return does_not_escape;
+  if (TREE_CODE (node) != SSA_NAME)
+    {
+      return false;
+    }
+  if (map.get (node) == NULL)
+    {
+       if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "	");
+	  fprintf (dump_file, "add node: \t\t");
+	  print_generic_expr (dump_file, node);
+	  fprintf (dump_file, ",\t\tptr layers: %d: \n", layers);
+	}
+      map.put (node, layers);
+      stack.safe_push (node);
+    }
+  else if (*map.get (node) != layers)
+    {
+      return false;
+    }
+  return true;
 }
 
-/* Record TYPE if not already recorded. */
+/* Check the number of pointer layers of the gimple phi in definition.  */
 
-srtype *
-ipa_struct_reorg::record_type (tree type)
+bool
+check_def_phi (tree def_node, hash_map <tree, int> &ptr_layers)
 {
-  unsigned typeuid;
-
-  /* Get the main variant as we are going
-     to record that type only. */
-  type = TYPE_MAIN_VARIANT (type);
-  typeuid = TYPE_UID (type);
+  bool res = true;
+  gimple *def_stmt = SSA_NAME_DEF_STMT (def_node);
+  for (unsigned j = 0; j < gimple_phi_num_args (def_stmt); j++)
+  {
+    tree phi_node = gimple_phi_arg_def (def_stmt, j);
+    if (integer_zerop (phi_node))
+      {
+	continue;
+      }
+    if (ptr_layers.get (phi_node) == NULL)
+      {
+	return false;
+      }
+    res &= *ptr_layers.get (def_node) == *ptr_layers.get (phi_node);
+  }
+  return res;
+}
 
-  srtype *type1;
+/* Check the number of pointer layers of the gimple assign in definition.  */
 
-  type1 = find_type (type);
-  if (type1)
-    return type1;
+bool
+check_def_assign (tree def_node, hash_map <tree, int> &ptr_layers)
+{
+  bool res = true;
+  gimple *def_stmt = SSA_NAME_DEF_STMT (def_node);
+  gimple_rhs_class rhs_class = gimple_assign_rhs_class (def_stmt);
+  tree_code rhs_code = gimple_assign_rhs_code (def_stmt);
+  tree rhs1 = gimple_assign_rhs1 (def_stmt);
+  tree rhs1_base = TREE_CODE (rhs1) == MEM_REF ? TREE_OPERAND (rhs1, 0) : rhs1;
+  if (ptr_layers.get (rhs1_base) == NULL)
+    {
+      return false;
+    }
+  if (rhs_class == GIMPLE_SINGLE_RHS || rhs_class == GIMPLE_UNARY_RHS)
+    {
+      if (TREE_CODE (rhs1) == SSA_NAME)
+	{
+	  res = *ptr_layers.get (def_node) == *ptr_layers.get (rhs1);
+	}
+      else if (TREE_CODE (rhs1) == MEM_REF)
+	{
+	  res = *ptr_layers.get (def_node)
+		== *ptr_layers.get (TREE_OPERAND (rhs1, 0));
+	}
+      else
+	{
+	  return false;
+	}
+    }
+  else if (rhs_class == GIMPLE_BINARY_RHS)
+    {
+      if (rhs_code == POINTER_PLUS_EXPR)
+	{
+	  res = *ptr_layers.get (def_node) == *ptr_layers.get (rhs1);
+	}
+      else if (rhs_code == BIT_AND_EXPR)
+	{
+	  res = *ptr_layers.get (def_node) == *ptr_layers.get (rhs1);
+	}
+      else
+	{
+	  return false;
+	}
+    }
+  else
+    {
+      return false;
+    }
+  return res;
+}
 
-  /* If already done recording just return NULL. */
-  if (done_recording)
-    return NULL;
+/* Check node definition.  */
 
+bool
+check_node_def (hash_map <tree, int> &ptr_layers)
+{
+  bool res = true;
   if (dump_file && (dump_flags & TDF_DETAILS))
-    fprintf (dump_file, "Recording new type: %u.\n", typeuid);
-
-  type1 = new srtype (type);
-  types.safe_push(type1);
-
-  /* If the type has an user alignment set,
-     that means the user most likely already setup the type. */
-  if (TYPE_USER_ALIGN (type))
-    type1->mark_escape (escape_user_alignment, NULL);
-
-  for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
     {
-      if (TREE_CODE (field) == FIELD_DECL)
-        {
-	  tree t = TREE_TYPE (field);
-	  process_union (t);
-	  if (TREE_CODE (inner_type (t)) == UNION_TYPE
-	      || TREE_CODE (inner_type (t)) == QUAL_UNION_TYPE)
+      fprintf (dump_file, "\n======== check node definition ========\n");
+    }
+  for (unsigned i = 1; i < num_ssa_names; ++i)
+    {
+      tree name = ssa_name (i);
+      if (name && ptr_layers.get (name) != NULL)
+	{
+	  gimple *def_stmt = SSA_NAME_DEF_STMT (name);
+	  if (dump_file && (dump_flags & TDF_DETAILS)
+	      && gimple_code (def_stmt) != GIMPLE_DEBUG)
+	    {
+	      print_gimple_stmt (dump_file, def_stmt, 0);
+	    }
+
+	  if (gimple_code (def_stmt) == GIMPLE_PHI)
 	    {
-	      type1->mark_escape (escape_union, NULL);
+	      res = check_def_phi (name, ptr_layers);
 	    }
-	  if (isvolatile_type (t))
-	    type1->mark_escape (escape_volatile, NULL);
-	  escape_type e = escape_type_volatile_array_or_ptrptr (t);
-	  if (e != does_not_escape)
-	    type1->mark_escape (e, NULL);
-	  if (handled_type (t))
+	  else if (gimple_code (def_stmt) == GIMPLE_ASSIGN)
 	    {
-	      srtype *t1 = record_type (inner_type (t));
-	      srfield *f = type1->find_field (int_byte_position (field));
-	      /* We might have an variable sized type which we don't set the handle. */
-	      if (f)
-		{
-		  f->type = t1;
-		  t1->add_field_site (f);
-		}
-	      if (t1 == type1 && current_mode != COMPLETE_STRUCT_RELAYOUT)
-		{
-		  type1->mark_escape (escape_rescusive_type, NULL);
-		}
+	      res = check_def_assign (name, ptr_layers);
 	    }
-        }
+	  else if (gimple_code (def_stmt) == GIMPLE_NOP)
+	    {
+	      continue;
+	    }
+	  else
+	    {
+	      return false;
+	    }
+	}
     }
-
-  return type1;
+  return res;
 }
 
-/* Mark TYPE as escaping with ESCAPES as the reason.  */
+/* Check pointer usage.  */
 
-void
-ipa_struct_reorg::mark_type_as_escape (tree type, escape_type escapes, gimple *stmt)
+bool
+check_record_ptr_usage (gimple *use_stmt, tree &current_node,
+			hash_map <tree, int> &ptr_layers,
+			auto_vec <tree> &ssa_name_stack)
 {
-  if (handled_type (type))
+  gimple_rhs_class rhs_class = gimple_assign_rhs_class (use_stmt);
+  tree rhs1 = gimple_assign_rhs1 (use_stmt);
+  tree lhs = gimple_assign_lhs (use_stmt);
+  if (rhs_class != GIMPLE_SINGLE_RHS
+      || (TREE_CODE (rhs1) != COMPONENT_REF && TREE_CODE (rhs1) != SSA_NAME)
+      || (TREE_CODE (lhs) != MEM_REF && TREE_CODE (lhs) != SSA_NAME))
     {
-      srtype *stype = record_type (inner_type (type));
-
-      if (!stype)
-	return;
+      return false;
+    }
 
-      stype->mark_escape (escapes, stmt);
+  bool res = true;
+  /* MEM[(long int *)a_1] = _57; (record).
+     If lhs is ssa_name, lhs cannot be the current node.
+     _283 = _282->flow; (No record).  */
+  if (TREE_CODE (rhs1) == SSA_NAME)
+    {
+      tree tmp = (rhs1 != current_node) ? rhs1 : lhs;
+      if (TREE_CODE (tmp) == MEM_REF)
+	{
+	  res = add_node (TREE_OPERAND (tmp, 0),
+			  *ptr_layers.get (current_node) + 1,
+			  ptr_layers, ssa_name_stack);
+	}
+      else
+	{
+	  res = add_node (tmp, *ptr_layers.get (current_node),
+			  ptr_layers, ssa_name_stack);
+	}
+    }
+  else if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs1) == COMPONENT_REF)
+    {
+      res = !(POINTER_TYPE_P (TREE_TYPE (rhs1)));
     }
+  else
+    {
+      res = false;
+    }
+  return res;
 }
 
-/* Maybe process the union of type TYPE, such that marking all of the fields'
-   types as being escaping. */
+/* Check and record a single node.  */
 
-void
-ipa_struct_reorg::process_union (tree type)
+bool
+check_record_single_node (gimple *use_stmt, tree &current_node,
+			  hash_map <tree, int> &ptr_layers,
+			  auto_vec <tree> &ssa_name_stack)
 {
-  static hash_set<tree> unions_recorded;
-
-  type = inner_type (type);
-  if (TREE_CODE (type) != UNION_TYPE
-      && TREE_CODE (type) != QUAL_UNION_TYPE)
-    return;
-
-  type = TYPE_MAIN_VARIANT (type);
-
-  /* We already processed this type. */
-  if (unions_recorded.add (type))
-    return;
+  gimple_rhs_class rhs_class = gimple_assign_rhs_class (use_stmt);
+  tree rhs1 = gimple_assign_rhs1 (use_stmt);
+  tree lhs = gimple_assign_lhs (use_stmt);
+  gcc_assert (rhs_class == GIMPLE_SINGLE_RHS || rhs_class == GIMPLE_UNARY_RHS);
 
-  for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+  if ((TREE_CODE (rhs1) != SSA_NAME && TREE_CODE (rhs1) != MEM_REF)
+      || (TREE_CODE (lhs) != SSA_NAME && TREE_CODE (lhs) != MEM_REF))
     {
-      if (TREE_CODE (field) == FIELD_DECL)
+      return false;
+    }
+
+  bool res = true;
+  if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs1) == MEM_REF)
+    {
+      /* _257 = MEM[(struct arc_t * *)_17].  */
+      res = add_node (lhs, *ptr_layers.get (current_node) - 1,
+		      ptr_layers, ssa_name_stack);
+    }
+  else if (TREE_CODE (lhs) == MEM_REF && TREE_CODE (rhs1) == SSA_NAME)
+    {
+      /* MEM[(long int *)a_1] = _57.  */
+      if (rhs1 == current_node)
+	{
+	  res = add_node (TREE_OPERAND (lhs, 0),
+			  *ptr_layers.get (current_node) + 1,
+			  ptr_layers, ssa_name_stack);
+	}
+      else
+	{
+	  res = add_node (rhs1, *ptr_layers.get (current_node) - 1,
+			  ptr_layers, ssa_name_stack);
+	}
+    }
+  else if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs1) == SSA_NAME)
+    {
+      res = add_node (lhs, *ptr_layers.get (current_node),
+		      ptr_layers, ssa_name_stack);
+    }
+  else
+    {
+      res = false;
+    }
+
+  return res;
+}
+
+/* Check and record multiple nodes.  */
+
+bool
+check_record_mult_node (gimple *use_stmt, tree &current_node,
+			hash_map <tree, int> &ptr_layers,
+			auto_vec <tree> &ssa_name_stack)
+{
+  gimple_rhs_class rhs_class = gimple_assign_rhs_class (use_stmt);
+  tree_code rhs_code = gimple_assign_rhs_code (use_stmt);
+  tree rhs1 = gimple_assign_rhs1 (use_stmt);
+  tree lhs = gimple_assign_lhs (use_stmt);
+  tree rhs2 = gimple_assign_rhs2 (use_stmt);
+  gcc_assert (rhs_class == GIMPLE_BINARY_RHS);
+
+  if ((rhs_code != POINTER_PLUS_EXPR && rhs_code != POINTER_DIFF_EXPR
+       && rhs_code != BIT_AND_EXPR)
+      || (TREE_CODE (lhs) != SSA_NAME && TREE_CODE (rhs1) != SSA_NAME))
+    {
+      return false;
+    }
+
+  bool res = true;
+  if (rhs_code == POINTER_PLUS_EXPR)
+    {
+      res = add_node (lhs == current_node ? rhs1 : lhs,
+		      *ptr_layers.get (current_node),
+		      ptr_layers, ssa_name_stack);
+    }
+  else if (rhs_code == POINTER_DIFF_EXPR)
+    {
+      res = add_node (rhs1 != current_node ? rhs1 : rhs2,
+		      *ptr_layers.get (current_node),
+		      ptr_layers, ssa_name_stack);
+    }
+  else if (rhs_code == BIT_AND_EXPR)
+    {
+      if (TREE_CODE (rhs2) != INTEGER_CST)
+	{
+	  return false;
+	}
+      res = add_node (lhs == current_node ? rhs1 : lhs,
+			*ptr_layers.get (current_node),
+			ptr_layers, ssa_name_stack);
+    }
+  return res;
+}
+
+/* Check whether gimple assign is correctly used and record node.  */
+
+bool
+check_record_assign (tree &current_node, gimple *use_stmt,
+		     hash_map <tree, int> &ptr_layers,
+		     auto_vec <tree> &ssa_name_stack)
+{
+  gimple_rhs_class rhs_class = gimple_assign_rhs_class (use_stmt);
+  if (*ptr_layers.get (current_node) == 1)
+    {
+      return check_record_ptr_usage (use_stmt, current_node,
+				     ptr_layers, ssa_name_stack);
+    }
+  else if (*ptr_layers.get (current_node) > 1)
+    {
+      if (rhs_class != GIMPLE_BINARY_RHS
+	  && rhs_class != GIMPLE_UNARY_RHS
+	  && rhs_class != GIMPLE_SINGLE_RHS)
+	{
+	  return false;
+	}
+
+      if (rhs_class == GIMPLE_SINGLE_RHS || rhs_class == GIMPLE_UNARY_RHS)
+	{
+	  return check_record_single_node (use_stmt, current_node,
+					   ptr_layers, ssa_name_stack);
+	}
+      else if (rhs_class == GIMPLE_BINARY_RHS)
+	{
+	  return check_record_mult_node (use_stmt, current_node,
+					 ptr_layers, ssa_name_stack);
+	}
+    }
+  else
+    return false;
+
+  return true;
+}
+
+/* Check whether gimple phi is correctly used and record node.  */
+
+bool
+check_record_phi (tree &current_node, gimple *use_stmt,
+		  hash_map <tree, int> &ptr_layers,
+		  auto_vec <tree> &ssa_name_stack)
+{
+  bool res = true;
+  res &= add_node (gimple_phi_result (use_stmt), *ptr_layers.get (current_node),
+		   ptr_layers, ssa_name_stack);
+
+  for (unsigned i = 0; i < gimple_phi_num_args (use_stmt); i++)
+    {
+      if (integer_zerop (gimple_phi_arg_def (use_stmt, i)))
+	{
+	  continue;
+	}
+      res &= add_node (gimple_phi_arg_def (use_stmt, i),
+		       *ptr_layers.get (current_node),
+		       ptr_layers, ssa_name_stack);
+    }
+  return res;
+}
+
+/* Check the use of callee.  */
+
+bool
+check_callee (cgraph_node *node, gimple *stmt,
+	      hash_map <tree, int> &ptr_layers, int input_layers)
+{
+  /* caller main ()
+	    { spec_qsort.constprop (_649, _651); }
+     def    spec_qsort.constprop (void * a, size_t n)
+	    { spec_qsort.constprop (a_1, _139); }  */
+  /* In safe functions, only call itself is allowed.  */
+  if (node->get_edge (stmt)->callee != node)
+    {
+      return false;
+    }
+  tree input_node = gimple_call_arg (stmt, 0);
+  if (ptr_layers.get (input_node) == NULL
+      || *ptr_layers.get (input_node) != input_layers)
+    {
+      return false;
+    }
+  if (SSA_NAME_VAR (input_node) != DECL_ARGUMENTS (node->decl))
+    {
+      return false;
+    }
+
+  for (unsigned i = 1; i < gimple_call_num_args (stmt); i++)
+    {
+      if (ptr_layers.get (gimple_call_arg (stmt, i)) != NULL)
+	{
+	  return false;
+	}
+    }
+  return true;
+}
+
+/* Check the usage of input nodes and related nodes.  */
+
+bool
+check_node_use (cgraph_node *node, tree current_node,
+		hash_map <tree, int> &ptr_layers,
+		auto_vec <tree> &ssa_name_stack,
+		int input_layers)
+{
+  imm_use_iterator imm_iter;
+  gimple *use_stmt = NULL;
+  bool res = true;
+  /* Use FOR_EACH_IMM_USE_STMT as an indirect edge
+     to search for possible related nodes and push to stack.  */
+  FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, current_node)
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS)
+	  && gimple_code (use_stmt) != GIMPLE_DEBUG)
+	{
+	  fprintf (dump_file, "%*s", 4, "");
+	  print_gimple_stmt (dump_file, use_stmt, 0);
+	}
+      /* For other types of gimple, do not record the node.  */
+      if (res)
+	{
+	  if (gimple_code (use_stmt) == GIMPLE_PHI)
+	    {
+	      res = check_record_phi (current_node, use_stmt,
+				      ptr_layers, ssa_name_stack);
+	    }
+	  else if (gimple_code (use_stmt) == GIMPLE_ASSIGN)
+	    {
+	      res = check_record_assign (current_node, use_stmt,
+					 ptr_layers, ssa_name_stack);
+	    }
+	  else if (gimple_code (use_stmt) == GIMPLE_CALL)
+	    {
+	      res = check_callee (node, use_stmt, ptr_layers, input_layers);
+	    }
+	  else if (gimple_code (use_stmt) == GIMPLE_RETURN)
+	    {
+	      res = false;
+	    }
+	}
+    }
+  return res;
+}
+
+/* Preparing the First Node for DFS.  */
+
+bool
+set_init_node (cgraph_node *node, cgraph_edge *caller,
+		hash_map <tree, int> &ptr_layers,
+		auto_vec <tree> &ssa_name_stack, int &input_layers)
+{
+   /* set input_layer
+      caller spec_qsort.constprop (_649, _651)
+				     |-- Obtains the actual ptr layer
+					 from the input node.  */
+  if (caller->call_stmt == NULL
+      || gimple_call_num_args (caller->call_stmt) == 0)
+    {
+      return false;
+    }
+  tree input = gimple_call_arg (caller->call_stmt, 0);
+  if (!(POINTER_TYPE_P (TREE_TYPE (input))
+      || TREE_CODE (TREE_TYPE (input)) == ARRAY_TYPE)
+      || !handled_type (TREE_TYPE (input)))
+    {
+      return false;
+    }
+  input_layers = get_ptr_layers (TREE_TYPE (input));
+
+  /* set initial node
+     def spec_qsort.constprop (void * a, size_t n)
+				      |-- Find the initial ssa_name
+					  from the parameter node.  */
+  tree parm = DECL_ARGUMENTS (node->decl);
+  for (unsigned j = 1; j < num_ssa_names; ++j)
+    {
+      tree name = ssa_name (j);
+      if (!name || has_zero_uses (name) || virtual_operand_p (name))
+	{
+	  continue;
+	}
+      if (SSA_NAME_VAR (name) == parm
+	  && gimple_code (SSA_NAME_DEF_STMT (name)) == GIMPLE_NOP)
+	{
+	  if (!add_node (name, input_layers, ptr_layers, ssa_name_stack))
+	    {
+	      return false;
+	    }
+	}
+    }
+  return !ssa_name_stack.is_empty ();
+}
+
+/* Check the usage of each call.  */
+
+bool
+check_each_call (cgraph_node *node, cgraph_edge *caller)
+{
+  hash_map <tree, int> ptr_layers;
+  auto_vec <tree> ssa_name_stack;
+  int input_layers = 0;
+  if (dump_file && (dump_flags & TDF_DETAILS))
+    {
+      fprintf (dump_file, "======== check each call : %s/%u ========\n",
+	       node->name (), node->order);
+    }
+  if (!set_init_node (node, caller, ptr_layers, ssa_name_stack, input_layers))
+    {
+      return false;
+    }
+  int i = 0;
+  while (!ssa_name_stack.is_empty ())
+    {
+      tree current_node = ssa_name_stack.pop ();
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "\ncur node %d: \t", i++);
+	  print_generic_expr (dump_file, current_node);
+	  fprintf (dump_file, ",\t\tptr layers: %d: \n",
+		   *ptr_layers.get (current_node));
+	}
+      if (get_ptr_layers (TREE_TYPE (current_node))
+	  > *ptr_layers.get (current_node))
+	{
+	  return false;
+	}
+      if (!check_node_use (node, current_node, ptr_layers, ssa_name_stack,
+			   input_layers))
+	{
+	  return false;
+	}
+    }
+
+  if (!check_node_def (ptr_layers))
+    {
+      return false;
+    }
+  return true;
+}
+
+/* Filter out function: void func (void*, int n),
+   and the function has no static variable, no structure-related variable,
+   and no global variable is used.  */
+
+bool
+filter_func (cgraph_node *node)
+{
+  tree parm = DECL_ARGUMENTS (node->decl);
+  if (!(parm && VOID_POINTER_P (TREE_TYPE (parm))
+	&& VOID_TYPE_P (TREE_TYPE (TREE_TYPE (node->decl)))))
+    {
+      return false;
+    }
+
+  for (parm = DECL_CHAIN (parm); parm; parm = DECL_CHAIN (parm))
+    {
+      if (TREE_CODE (TREE_TYPE (parm)) != INTEGER_TYPE)
+	{
+	  return false;
+	}
+    }
+
+  if (DECL_STRUCT_FUNCTION (node->decl)->static_chain_decl)
+    {
+      return false;
+    }
+
+  tree var = NULL_TREE;
+  unsigned int i = 0;
+  bool res = true;
+  FOR_EACH_LOCAL_DECL (cfun, i, var)
+    {
+      if (TREE_CODE (var) == VAR_DECL && handled_type (TREE_TYPE (var)))
+	{
+	  res = false;
+	}
+    }
+  if (!res)
+    {
+      return false;
+    }
+
+  for (unsigned j = 1; j < num_ssa_names; ++j)
+    {
+      tree name = ssa_name (j);
+      if (!name || has_zero_uses (name) || virtual_operand_p (name))
+	{
+	  continue;
+	}
+      tree var = SSA_NAME_VAR (name);
+      if (var && TREE_CODE (var) == VAR_DECL && is_global_var (var))
+	{
+	  return false;
+	}
+    }
+  return true;
+}
+
+/* Check whether the function with the void* parameter and uses the input node
+   safely.
+   In these functions only component_ref can be used to dereference the last
+   layer of the input structure pointer.  The hack operation pointer offset
+   after type cast cannot be used.
+*/
+
+bool
+is_safe_func_with_void_ptr_parm (cgraph_node *node)
+{
+  if (!filter_func (node))
+    {
+      return false;
+    }
+
+  /* Distinguish Recursive Callers
+     normal_callers:    main ()
+			{ spec_qsort.constprop (_649, _651); }
+     definition:	spec_qsort.constprop (void * a, size_t n)
+     recursive_callers: { spec_qsort.constprop (a_1, _139); }  */
+  vec <cgraph_edge *> callers = node->collect_callers ();
+  auto_vec <cgraph_edge *> normal_callers;
+  for (unsigned i = 0; i < callers.length (); i++)
+    {
+      if (callers[i]->caller != node)
+	{
+	  normal_callers.safe_push (callers[i]);
+	}
+    }
+  if (normal_callers.length () == 0)
+    {
+      return false;
+    }
+
+  for (unsigned i = 0; i < normal_callers.length (); i++)
+    {
+      if (!check_each_call (node, normal_callers[i]))
+	{
+	  return false;
+	}
+    }
+  return true;
+}
+
+/* Return the escape type which corresponds to if
+   this is an volatile type, an array type or a pointer
+   to a pointer type.  */
+
+escape_type escape_type_volatile_array_or_ptrptr (tree type)
+{
+  if (isvolatile_type (type))
+    return escape_volatile;
+  if (isarraytype (type))
+    return escape_array;
+  if (isptrptr (type) && (current_mode != STRUCT_REORDER_FIELDS))
+    return escape_ptr_ptr;
+  return does_not_escape;
+}
+
+/* Record field type.  */
+
+void
+ipa_struct_reorg::record_field_type (tree field, srtype *base_srtype)
+{
+  tree field_type = TREE_TYPE (field);
+  /* The uid of the type in the structure is different
+     from that outside the structure.  */
+  srtype *field_srtype = record_type (inner_type (field_type));
+  srfield *field_srfield = base_srtype->find_field (int_byte_position (field));
+  /* We might have an variable sized type which we don't set the handle.  */
+  if (field_srfield)
+    {
+      field_srfield->type = field_srtype;
+      field_srtype->add_field_site (field_srfield);
+    }
+  if (field_srtype == base_srtype && current_mode != COMPLETE_STRUCT_RELAYOUT
+      && current_mode != STRUCT_REORDER_FIELDS)
+    {
+      base_srtype->mark_escape (escape_rescusive_type, NULL);
+    }
+  /* Types of non-pointer field are difficult to track the correctness
+     of the rewrite when it used by the escaped type.  */
+  if (current_mode == STRUCT_REORDER_FIELDS
+      && TREE_CODE (field_type) == RECORD_TYPE)
+    {
+      field_srtype->mark_escape (escape_instance_field, NULL);
+    }
+}
+
+/* Record structure all field types.  */
+
+void
+ipa_struct_reorg::record_struct_field_types (tree base_type,
+					     srtype *base_srtype)
+{
+  for (tree field = TYPE_FIELDS (base_type); field; field = DECL_CHAIN (field))
+    {
+      if (TREE_CODE (field) == FIELD_DECL)
+      {
+	tree field_type = TREE_TYPE (field);
+	process_union (field_type);
+	if (TREE_CODE (inner_type (field_type)) == UNION_TYPE
+	    || TREE_CODE (inner_type (field_type)) == QUAL_UNION_TYPE)
+	  {
+	    base_srtype->mark_escape (escape_union, NULL);
+	  }
+	if (isvolatile_type (field_type))
+	  {
+	    base_srtype->mark_escape (escape_volatile, NULL);
+	  }
+	escape_type e = escape_type_volatile_array_or_ptrptr (field_type);
+	if (e != does_not_escape)
+	  {
+	    base_srtype->mark_escape (e, NULL);
+	  }
+	/* Types of non-pointer field are difficult to track the correctness
+	   of the rewrite when it used by the escaped type.  */
+	if (current_mode == STRUCT_REORDER_FIELDS
+	    && TREE_CODE (field_type) == RECORD_TYPE)
+	  {
+	    base_srtype->mark_escape (escape_instance_field, NULL);
+	  }
+	if (handled_type (field_type))
+	  {
+	    record_field_type (field, base_srtype);
+	  }
+      }
+    }
+}
+
+/* Record TYPE if not already recorded.  */
+
+srtype *
+ipa_struct_reorg::record_type (tree type)
+{
+  unsigned typeuid;
+
+  /* Get the main variant as we are going
+     to record that type only.  */
+  type = TYPE_MAIN_VARIANT (type);
+  typeuid = TYPE_UID (type);
+
+  srtype *type1;
+
+  type1 = find_type (type);
+  if (type1)
+    return type1;
+
+  /* If already done recording just return NULL.  */
+  if (done_recording)
+    return NULL;
+
+  if (dump_file && (dump_flags & TDF_DETAILS))
+    fprintf (dump_file, "Recording new type: %u.\n", typeuid);
+
+  type1 = new srtype (type);
+  types.safe_push (type1);
+
+  /* If the type has an user alignment set,
+     that means the user most likely already setup the type.  */
+  if (TYPE_USER_ALIGN (type))
+    type1->mark_escape (escape_user_alignment, NULL);
+
+  record_struct_field_types (type, type1);
+
+  return type1;
+}
+
+/* Mark TYPE as escaping with ESCAPES as the reason.  */
+
+void
+ipa_struct_reorg::mark_type_as_escape (tree type, escape_type escapes,
+				       gimple *stmt)
+{
+  if (handled_type (type))
+    {
+      srtype *stype = record_type (inner_type (type));
+
+      if (!stype)
+	return;
+
+      stype->mark_escape (escapes, stmt);
+    }
+}
+
+/* Maybe process the union of type TYPE, such that marking all of the fields'
+   types as being escaping.  */
+
+void
+ipa_struct_reorg::process_union (tree type)
+{
+  static hash_set<tree> unions_recorded;
+
+  type = inner_type (type);
+  if (TREE_CODE (type) != UNION_TYPE
+      && TREE_CODE (type) != QUAL_UNION_TYPE)
+    return;
+
+  type = TYPE_MAIN_VARIANT (type);
+
+  /* We already processed this type.  */
+  if (unions_recorded.add (type))
+    return;
+
+  for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+    {
+      if (TREE_CODE (field) == FIELD_DECL)
 	{
 	  mark_type_as_escape (TREE_TYPE (field), escape_union);
 	  process_union (TREE_TYPE (field));
@@ -2022,7 +2928,8 @@ ipa_struct_reorg::record_var (tree decl, escape_type escapes, int arg)
 
   process_union (TREE_TYPE (decl));
 
-  /* */
+  /* Only the structure type RECORD_TYPE is recorded.
+     Therefore, the void* type is filtered out.  */
   if (handled_type (TREE_TYPE (decl)))
     {
       type = record_type (inner_type (TREE_TYPE (decl)));
@@ -2059,7 +2966,8 @@ ipa_struct_reorg::record_var (tree decl, escape_type escapes, int arg)
 
       /* Separate instance is hard to trace in complete struct
 	 relayout optimization.  */
-      if (current_mode == COMPLETE_STRUCT_RELAYOUT
+      if ((current_mode == COMPLETE_STRUCT_RELAYOUT
+	   || current_mode == STRUCT_REORDER_FIELDS)
 	  && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
 	{
 	  e = escape_separate_instance;
@@ -2138,8 +3046,10 @@ ipa_struct_reorg::find_var (tree expr, gimple *stmt)
   srtype *type;
   srfield *field;
   bool realpart, imagpart, address;
+  bool escape_from_base = false;
+  /* The should_create flag is true, the declaration can be recorded.  */
   get_type_field (expr, base, indirect, type, field,
-		  realpart, imagpart, address, true, true);
+		  realpart, imagpart, address, escape_from_base, true, true);
 }
 
 
@@ -2157,10 +3067,26 @@ ipa_struct_reorg::find_vars (gimple *stmt)
 	  tree lhs = gimple_assign_lhs (stmt);
 	  tree rhs = gimple_assign_rhs1 (stmt);
 	  find_var (gimple_assign_lhs (stmt), stmt);
+	  /* _2 = MEM[(struct arc_t * *)_1];
+	     records the right value _1 declaration.  */
 	  find_var (gimple_assign_rhs1 (stmt), stmt);
-	  if (TREE_CODE (lhs) == SSA_NAME
+
+	  /* Add a safe func mechanism.  */
+	  bool l_find = true;
+	  bool r_find = true;
+	  if (current_mode == STRUCT_REORDER_FIELDS)
+	    {
+	      l_find = !(current_function->is_safe_func
+			 && TREE_CODE (lhs) == SSA_NAME
+			 && is_from_void_ptr_parm (lhs));
+	      r_find = !(current_function->is_safe_func
+			 && TREE_CODE (rhs) == SSA_NAME
+			 && is_from_void_ptr_parm (rhs));
+	    }
+
+	  if ((TREE_CODE (lhs) == SSA_NAME)
 	      && VOID_POINTER_P (TREE_TYPE (lhs))
-	      && handled_type (TREE_TYPE (rhs)))
+	      && handled_type (TREE_TYPE (rhs)) && l_find)
 	    {
 	      srtype *t = find_type (inner_type (TREE_TYPE (rhs)));
 	      srdecl *d = find_decl (lhs);
@@ -2172,9 +3098,11 @@ ipa_struct_reorg::find_vars (gimple *stmt)
 		    current_function->record_decl (t, var, -1);
 		}
 	    }
+	  /* void * _1; struct arc * _2;
+	     _2 = _1 + _3; _1 = calloc (100, 40).  */
 	  if (TREE_CODE (rhs) == SSA_NAME
 	      && VOID_POINTER_P (TREE_TYPE (rhs))
-	      && handled_type (TREE_TYPE (lhs)))
+	      && handled_type (TREE_TYPE (lhs)) && r_find)
 	    {
 	      srtype *t = find_type (inner_type (TREE_TYPE (lhs)));
 	      srdecl *d = find_decl (rhs);
@@ -2187,6 +3115,26 @@ ipa_struct_reorg::find_vars (gimple *stmt)
 		}
 	    }
 	}
+      else if ((current_mode == STRUCT_REORDER_FIELDS)
+	       && (gimple_assign_rhs_code (stmt) == LE_EXPR
+		   || gimple_assign_rhs_code (stmt) == LT_EXPR
+		   || gimple_assign_rhs_code (stmt) == GE_EXPR
+		   || gimple_assign_rhs_code (stmt) == GT_EXPR))
+	{
+	  find_var (gimple_assign_lhs (stmt), stmt);
+	  find_var (gimple_assign_rhs1 (stmt), stmt);
+	  find_var (gimple_assign_rhs2 (stmt), stmt);
+	}
+      /* _23 = _21 - old_arcs_12.  */
+      else if ((current_mode == STRUCT_REORDER_FIELDS)
+	       && gimple_assign_rhs_code (stmt) == POINTER_DIFF_EXPR
+	       && types_compatible_p (
+		  TYPE_MAIN_VARIANT (TREE_TYPE (gimple_assign_rhs1 (stmt))),
+		  TYPE_MAIN_VARIANT (TREE_TYPE (gimple_assign_rhs2 (stmt)))))
+	{
+	  find_var (gimple_assign_rhs1 (stmt), stmt);
+	  find_var (gimple_assign_rhs2 (stmt), stmt);
+	}
       else
 	{
 	  /* Because we won't handle these stmts in rewrite phase,
@@ -2279,8 +3227,122 @@ ipa_struct_reorg::maybe_record_stmt (cgraph_node *node, gimple *stmt)
     }
 }
 
+/* Calculate the multiplier.  */
+
+static bool
+calculate_mult_num (tree arg, tree *num, tree struct_size)
+{
+  gcc_assert (TREE_CODE (arg) == INTEGER_CST);
+  bool sign = false;
+  HOST_WIDE_INT size = TREE_INT_CST_LOW (arg);
+  if (size < 0)
+    {
+      size = -size;
+      sign = true;
+    }
+  tree arg2 = build_int_cst (TREE_TYPE (arg), size);
+  if (integer_zerop (size_binop (FLOOR_MOD_EXPR, arg2, struct_size)))
+    {
+      tree number = size_binop (FLOOR_DIV_EXPR, arg2, struct_size);
+      if (sign)
+	{
+	  number = build_int_cst (TREE_TYPE (number), -tree_to_shwi (number));
+	}
+      *num = number;
+      return true;
+    }
+  return false;
+}
+
+/* Trace and calculate the multiplier of PLUS_EXPR.  */
+
+static bool
+trace_calculate_plus (gimple *size_def_stmt, tree *num, tree struct_size)
+{
+  gcc_assert (gimple_assign_rhs_code (size_def_stmt) == PLUS_EXPR);
+
+  tree num1 = NULL_TREE;
+  tree num2 = NULL_TREE;
+  tree arg0 = gimple_assign_rhs1 (size_def_stmt);
+  tree arg1 = gimple_assign_rhs2 (size_def_stmt);
+  if (!is_result_of_mult (arg0, &num1, struct_size) || num1 == NULL_TREE)
+    {
+      return false;
+    }
+  if (!is_result_of_mult (arg1, &num2, struct_size) || num2 == NULL_TREE)
+    {
+      return false;
+    }
+  *num = size_binop (PLUS_EXPR, num1, num2);
+  return true;
+}
+
+/* Trace and calculate the multiplier of MULT_EXPR.  */
+
+static bool
+trace_calculate_mult (gimple *size_def_stmt, tree *num, tree struct_size)
+{
+  gcc_assert (gimple_assign_rhs_code (size_def_stmt) == MULT_EXPR);
+
+  tree arg0 = gimple_assign_rhs1 (size_def_stmt);
+  tree arg1 = gimple_assign_rhs2 (size_def_stmt);
+  tree num1 = NULL_TREE;
+
+  if (is_result_of_mult (arg0, &num1, struct_size) && num1 != NULL_TREE)
+    {
+      *num = size_binop (MULT_EXPR, arg1, num1);
+      return true;
+    }
+  if (is_result_of_mult (arg1, &num1, struct_size) && num1 != NULL_TREE)
+    {
+      *num = size_binop (MULT_EXPR, arg0, num1);
+      return true;
+    }
+  *num = NULL_TREE;
+  return false;
+}
+
+/* Trace and calculate the multiplier of NEGATE_EXPR.  */
+
+static bool
+trace_calculate_negate (gimple *size_def_stmt, tree *num, tree struct_size)
+{
+  gcc_assert (gimple_assign_rhs_code (size_def_stmt) == NEGATE_EXPR);
+
+  /* _480 = -_479; _479 = _478 * 72.  */
+  tree num1 = NULL_TREE;
+  tree arg0 = gimple_assign_rhs1 (size_def_stmt);
+  if (!is_result_of_mult (arg0, &num1, struct_size) || num1 == NULL_TREE)
+    {
+      return false;
+    }
+  tree num0 = build_int_cst (TREE_TYPE (num1), -1);
+  *num = size_binop (MULT_EXPR, num0, num1);
+  return true;
+}
+
+/* Trace and calculate the multiplier of POINTER_DIFF_EXPR.  */
+
+static bool
+trace_calculate_diff (gimple *size_def_stmt, tree *num)
+{
+  gcc_assert (gimple_assign_rhs_code (size_def_stmt) == NOP_EXPR);
+
+  /* _25 = (long unsigned int) _23; _23 = _21 - old_arcs_12.  */
+  tree arg = gimple_assign_rhs1 (size_def_stmt);
+  size_def_stmt = SSA_NAME_DEF_STMT (arg);
+  if (size_def_stmt && is_gimple_assign (size_def_stmt)
+      && gimple_assign_rhs_code (size_def_stmt) == POINTER_DIFF_EXPR)
+    {
+      *num = NULL_TREE;
+      return true;
+    }
+  *num = NULL_TREE;
+  return false;
+}
+
 /* This function checks whether ARG is a result of multiplication
-   of some number by STRUCT_SIZE. If yes, the function returns true
+   of some number by STRUCT_SIZE.  If yes, the function returns true
    and this number is filled into NUM.  */
 
 static bool
@@ -2291,30 +3353,12 @@ is_result_of_mult (tree arg, tree *num, tree struct_size)
       || integer_zerop (struct_size))
     return false;
 
-  /* If we have a integer, just check if it is a multiply of STRUCT_SIZE. */
+  /* If we have a integer, just check if it is a multiply of STRUCT_SIZE.  */
   if (TREE_CODE (arg) == INTEGER_CST)
     {
-      bool sign = false;
-      HOST_WIDE_INT size = TREE_INT_CST_LOW (arg);
-      if (size < 0)
-	{
-	  size = -size;
-	  sign = true;
-	}
-      tree arg2 = build_int_cst (TREE_TYPE (arg), size);
-      if (integer_zerop (size_binop (FLOOR_MOD_EXPR, arg2, struct_size)))
-	{
-	  tree number = size_binop (FLOOR_DIV_EXPR, arg2, struct_size);
-	  if (sign)
-	    {
-	      number = build_int_cst (TREE_TYPE (number),
-				      -tree_to_shwi (number));
-	    }
-	  *num = number;
-	  return true;
-	}
-      return false;
+      return calculate_mult_num (arg, num, struct_size);
     }
+
   gimple *size_def_stmt = SSA_NAME_DEF_STMT (arg);
 
   /* If the allocation statement was of the form
@@ -2330,43 +3374,28 @@ is_result_of_mult (tree arg, tree *num, tree struct_size)
 	return false;
 
       // FIXME: this should handle SHIFT also.
-      if (gimple_assign_rhs_code (size_def_stmt) == PLUS_EXPR)
-	{
-	  tree num1, num2;
-	  tree arg0 = gimple_assign_rhs1 (size_def_stmt);
-	  tree arg1 = gimple_assign_rhs2 (size_def_stmt);
-	  if (!is_result_of_mult (arg0, &num1, struct_size))
-	    return false;
-	  if (!is_result_of_mult (arg1, &num2, struct_size))
-	    return false;
-	  *num = size_binop (PLUS_EXPR, num1, num2);
-	  return true;
+      tree_code rhs_code = gimple_assign_rhs_code (size_def_stmt);
+      if (rhs_code == PLUS_EXPR)
+	{
+	  return trace_calculate_plus (size_def_stmt, num, struct_size);
 	}
-      if (gimple_assign_rhs_code (size_def_stmt) == MULT_EXPR)
+      else if (rhs_code == MULT_EXPR)
 	{
-	  tree arg0 = gimple_assign_rhs1 (size_def_stmt);
-	  tree arg1 = gimple_assign_rhs2 (size_def_stmt);
-	  tree num1;
-
-	  if (is_result_of_mult (arg0, &num1, struct_size))
-	    {
-	      *num = size_binop (MULT_EXPR, arg1, num1);
-	      return true;
-	    }
-	  if (is_result_of_mult (arg1, &num1, struct_size))
-	    {
-	      *num = size_binop (MULT_EXPR, arg0, num1);
-	      return true;
-	    }
-
-	  *num = NULL_TREE;
-	  return false;
+	  return trace_calculate_mult (size_def_stmt, num, struct_size);
 	}
-      else if (gimple_assign_rhs_code (size_def_stmt) == SSA_NAME)
+      else if (rhs_code == SSA_NAME)
 	{
 	  arg = gimple_assign_rhs1 (size_def_stmt);
 	  size_def_stmt = SSA_NAME_DEF_STMT (arg);
 	}
+      else if (rhs_code == NEGATE_EXPR && current_mode == STRUCT_REORDER_FIELDS)
+	{
+	  return trace_calculate_negate (size_def_stmt, num, struct_size);
+	}
+      else if (rhs_code == NOP_EXPR && current_mode == STRUCT_REORDER_FIELDS)
+	{
+	  return trace_calculate_diff (size_def_stmt, num);
+	}
       else
 	{
 	  *num = NULL_TREE;
@@ -2383,10 +3412,17 @@ is_result_of_mult (tree arg, tree *num, tree struct_size)
 bool
 ipa_struct_reorg::handled_allocation_stmt (gimple *stmt)
 {
-  if (current_mode == COMPLETE_STRUCT_RELAYOUT
+  if ((current_mode == STRUCT_REORDER_FIELDS)
+      && (gimple_call_builtin_p (stmt, BUILT_IN_REALLOC)
+	  || gimple_call_builtin_p (stmt, BUILT_IN_MALLOC)
+	  || gimple_call_builtin_p (stmt, BUILT_IN_CALLOC)))
+    {
+      return true;
+    }
+  if ((current_mode == COMPLETE_STRUCT_RELAYOUT)
       && gimple_call_builtin_p (stmt, BUILT_IN_CALLOC))
     return true;
-  if (current_mode != COMPLETE_STRUCT_RELAYOUT
+  if ((current_mode == NORMAL)
       && (gimple_call_builtin_p (stmt, BUILT_IN_REALLOC)
 	  || gimple_call_builtin_p (stmt, BUILT_IN_MALLOC)
 	  || gimple_call_builtin_p (stmt, BUILT_IN_CALLOC)
@@ -2402,7 +3438,7 @@ ipa_struct_reorg::handled_allocation_stmt (gimple *stmt)
    elements in the array allocated.   */
 
 tree
-ipa_struct_reorg::allocate_size (srtype *type, gimple *stmt)
+ipa_struct_reorg::allocate_size (srtype *type, srdecl *decl, gimple *stmt)
 {
   if (!stmt
       || gimple_code (stmt) != GIMPLE_CALL
@@ -2422,6 +3458,12 @@ ipa_struct_reorg::allocate_size (srtype *type, gimple *stmt)
 
   tree struct_size = TYPE_SIZE_UNIT (type->type);
 
+  /* Specify the correct size to relax multi-layer pointer.  */
+  if (TREE_CODE (decl->decl) == SSA_NAME && isptrptr (decl->orig_type))
+    {
+      struct_size = TYPE_SIZE_UNIT (decl->orig_type);
+    }
+
   tree size = gimple_call_arg (stmt, 0);
 
   if (gimple_call_builtin_p (stmt, BUILT_IN_REALLOC)
@@ -2435,7 +3477,9 @@ ipa_struct_reorg::allocate_size (srtype *type, gimple *stmt)
       if (operand_equal_p (arg1, struct_size, 0))
 	return size;
       /* ??? Check that first argument is a constant
-	 equal to the size of structure.  */
+      equal to the size of structure.  */
+      /* If the allocated number is equal to the value of struct_size,
+	 the value of arg1 is changed to the allocated number.  */
       if (operand_equal_p (size, struct_size, 0))
 	return arg1;
       if (dump_file && (dump_flags & TDF_DETAILS))
@@ -2479,17 +3523,38 @@ ipa_struct_reorg::maybe_mark_or_record_other_side (tree side, tree other, gimple
 
   if (!d)
     {
+      /* MEM[(struct arc *)_1].head = _2; _2 = calloc (100, 104).  */
       if (VOID_POINTER_P (TREE_TYPE (side))
 	  && TREE_CODE (side) == SSA_NAME)
-	current_function->record_decl (type, side, -1);
+	{
+	  /* The type is other, the declaration is side.  */
+	  current_function->record_decl (type, side, -1,
+		find_decl (other) ? find_decl (other)->orig_type : NULL);
+	}
       else
-	type->mark_escape (escape_cast_another_ptr, stmt);
+	{
+	  /* *_1 = &MEM[(void *)&x + 8B].  */
+	  type->mark_escape (escape_cast_another_ptr, stmt);
+	}
     }
   else if (type != d->type)
     {
       type->mark_escape (escape_cast_another_ptr, stmt);
       d->type->mark_escape (escape_cast_another_ptr, stmt);
     }
+  /* x_1 = y.x_nodes; void *x;
+     Directly mark the structure pointer type assigned
+     to the void* variable as escape.  */
+  else if (current_mode == STRUCT_REORDER_FIELDS
+	   && TREE_CODE (side) == SSA_NAME
+	   && VOID_POINTER_P (TREE_TYPE (side))
+	   && SSA_NAME_VAR (side)
+	   && VOID_POINTER_P (TREE_TYPE (SSA_NAME_VAR (side))))
+    {
+      mark_type_as_escape (TREE_TYPE (other), escape_cast_void, stmt);
+    }
+
+  check_ptr_layers (side, other, stmt);
 }
 
 /* Record accesses in an assignment statement STMT.  */
@@ -2515,7 +3580,11 @@ ipa_struct_reorg::maybe_record_assign (cgraph_node *node, gassign *stmt)
       if (!handled_type (TREE_TYPE (lhs)))
 	return;
       /* Check if rhs2 is a multiplication of the size of the type. */
-      if (is_result_of_mult (rhs2, &num, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (lhs)))))
+      /* The size adjustment and judgment of multi-layer pointers
+	 are added.  */
+      if (is_result_of_mult (rhs2, &num, isptrptr (TREE_TYPE (lhs))
+			     ? TYPE_SIZE_UNIT (TREE_TYPE (lhs))
+			     : TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (lhs)))))
 	{
 	  record_stmt_expr (lhs, node, stmt);
 	  record_stmt_expr (rhs1, node, stmt);
@@ -2553,9 +3622,8 @@ ipa_struct_reorg::maybe_record_assign (cgraph_node *node, gassign *stmt)
 }
 
 bool
-check_mem_ref_offset (tree expr)
+check_mem_ref_offset (tree expr, tree *num)
 {
-  tree num = NULL;
   bool ret = false;
 
   if (TREE_CODE (expr) != MEM_REF)
@@ -2570,13 +3638,18 @@ check_mem_ref_offset (tree expr)
     {
       tmp = TREE_OPERAND (tmp, 0);
     }
-  tree size = TYPE_SIZE_UNIT (inner_type (TREE_TYPE (tmp)));
-  ret = is_result_of_mult (field_off, &num, size);
+  /* Specify the correct size for the multi-layer pointer.  */
+  tree size = isptrptr (TREE_TYPE (tmp))
+			? TYPE_SIZE_UNIT (TREE_TYPE (tmp))
+			: TYPE_SIZE_UNIT (inner_type (TREE_TYPE (tmp)));
+  ret = is_result_of_mult (field_off, num, size);
   return ret;
 }
 
 tree
-get_ref_base_and_offset (tree &e, HOST_WIDE_INT &offset, bool &realpart, bool &imagpart, tree &accesstype)
+get_ref_base_and_offset (tree &e, HOST_WIDE_INT &offset,
+			 bool &realpart, bool &imagpart,
+			 tree &accesstype, tree *num)
 {
   offset = 0;
   realpart = false;
@@ -2599,22 +3672,29 @@ get_ref_base_and_offset (tree &e, HOST_WIDE_INT &offset, bool &realpart, bool &i
 	{
 	  case COMPONENT_REF:
 	  {
+	    /* x.a = _1; If expr is the lvalue of stmt,
+	       then field type is FIELD_DECL - POINTER_TYPE - RECORD_TYPE.  */
 	    tree field = TREE_OPERAND (expr, 1);
 	    tree field_off = byte_position (field);
 	    if (TREE_CODE (field_off) != INTEGER_CST)
 	      return NULL;
 	    offset += tree_to_shwi (field_off);
+	    /* x.a = _1; If expr is the lvalue of stmt,
+	       then expr type is VAR_DECL - RECORD_TYPE (fetch x) */
 	    expr = TREE_OPERAND (expr, 0);
 	    accesstype = NULL;
 	    break;
 	  }
 	  case MEM_REF:
 	  {
+	    /* _2 = MEM[(struct s * *)_1];
+	       If expr is the right value of stmt，then field_off type is
+	       INTEGER_CST - POINTER_TYPE - POINTER_TYPE - RECORD_TYPE.  */
 	    tree field_off = TREE_OPERAND (expr, 1);
 	    gcc_assert (TREE_CODE (field_off) == INTEGER_CST);
 	    /* So we can mark the types as escaping if different. */
 	    accesstype = TREE_TYPE (field_off);
-	    if (!check_mem_ref_offset (expr))
+	    if (!check_mem_ref_offset (expr, num))
 	      {
 		offset += tree_to_uhwi (field_off);
 	      }
@@ -2655,8 +3735,13 @@ ipa_struct_reorg::wholeaccess (tree expr, tree base, tree accesstype, srtype *t)
 }
 
 bool
-ipa_struct_reorg::get_type_field (tree expr, tree &base, bool &indirect, srtype *&type, srfield *&field, bool &realpart, bool &imagpart, bool &address, bool should_create, bool can_escape)
+ipa_struct_reorg::get_type_field (tree expr, tree &base, bool &indirect,
+				  srtype *&type, srfield *&field,
+				  bool &realpart, bool &imagpart, bool &address,
+				  bool& escape_from_base, bool should_create,
+				  bool can_escape)
 {
+  tree num = NULL_TREE;
   HOST_WIDE_INT offset;
   tree accesstype;
   address = false;
@@ -2668,7 +3753,9 @@ ipa_struct_reorg::get_type_field (tree expr, tree &base, bool &indirect, srtype
       mark_as_bit_field = true;
     }
 
-  base = get_ref_base_and_offset (expr, offset, realpart, imagpart, accesstype);
+  /* ref is classified into two types: COMPONENT_REF or MER_REF.  */
+  base = get_ref_base_and_offset (expr, offset, realpart, imagpart,
+				  accesstype, &num);
 
   /* Variable access, unkown type. */
   if (base == NULL)
@@ -2706,6 +3793,8 @@ ipa_struct_reorg::get_type_field (tree expr, tree &base, bool &indirect, srtype
       if (!t)
 	return false;
     }
+  /* If no such decl is finded
+     or orig_type is not added to this decl, then add it.  */
   else if (!d && accesstype)
     {
       if (!should_create)
@@ -2717,15 +3806,54 @@ ipa_struct_reorg::get_type_field (tree expr, tree &base, bool &indirect, srtype
 	t = record_type (inner_type (accesstype));
       if (!t || t->has_escaped ())
 	return false;
-      /* If base is not void* mark the type as escaping. */
-      if (!VOID_POINTER_P (TREE_TYPE (base)))
+      /* If base is not void* mark the type as escaping.
+	 release INTEGER_TYPE cast to struct pointer.
+	 (If t has escpaed above, then directly returns
+	 and doesn't mark escape follow.). */
+      /* _607 = MEM[(struct arc_t * *)pl_100].
+	 then base pl_100：ssa_name  - pointer_type - integer_type.  */
+      if (current_mode == STRUCT_REORDER_FIELDS)
+	{
+	  bool is_int_ptr = POINTER_TYPE_P (TREE_TYPE (base))
+			    && (TREE_CODE (inner_type (TREE_TYPE (base)))
+				== INTEGER_TYPE);
+	  if (!(VOID_POINTER_P (TREE_TYPE (base))
+		|| (current_function->is_safe_func && is_int_ptr)))
+	    {
+	      gcc_assert (can_escape);
+	      t->mark_escape (escape_cast_another_ptr, NULL);
+	      return false;
+	    }
+	  if (TREE_CODE (base) == SSA_NAME
+	      && !(current_function->is_safe_func && is_int_ptr))
+	    {
+	      /* Add a safe func mechanism.  */
+	      if (!(current_function->is_safe_func
+		    && is_from_void_ptr_parm (base)))
+		{
+		  /* Add auxiliary information of the multi-layer pointer
+		     type.  */
+		  current_function->record_decl (t, base, -1,
+				isptrptr (accesstype) ? accesstype : NULL);
+		}
+	    }
+	}
+      else
 	{
-          gcc_assert (can_escape);
-	  t->mark_escape (escape_cast_another_ptr, NULL);
-	  return false;
+	  if (!(VOID_POINTER_P (TREE_TYPE (base))))
+	    {
+	      gcc_assert (can_escape);
+	      t->mark_escape (escape_cast_another_ptr, NULL);
+	      return false;
+	    }
+	  if (TREE_CODE (base) == SSA_NAME)
+	    {
+	      /* Add auxiliary information of the multi-layer pointer
+		 type.  */
+	      current_function->record_decl (t, base, -1,
+			isptrptr (accesstype) ? accesstype : NULL);
+	    }
 	}
-      if (TREE_CODE (base) == SSA_NAME)
-	current_function->record_decl (t, base, -1);
     }
   else if (!d)
     return false;
@@ -2733,7 +3861,10 @@ ipa_struct_reorg::get_type_field (tree expr, tree &base, bool &indirect, srtype
     t = d->type;
 
   if (t->has_escaped ())
+  {
+    escape_from_base = true;
     return false;
+  }
 
   if (mark_as_bit_field)
     {
@@ -2759,7 +3890,6 @@ ipa_struct_reorg::get_type_field (tree expr, tree &base, bool &indirect, srtype
 	  print_generic_expr (dump_file, expr);
 	  fprintf (dump_file, "\n");
 	  print_generic_expr (dump_file, base);
-	  fprintf (dump_file, "\n");
 	}
       gcc_assert (can_escape);
       t->mark_escape (escape_unkown_field, NULL);
@@ -2773,9 +3903,8 @@ ipa_struct_reorg::get_type_field (tree expr, tree &base, bool &indirect, srtype
 	  print_generic_expr (dump_file, f->fieldtype);
 	  fprintf (dump_file, "\naccess type = ");
 	  print_generic_expr (dump_file, TREE_TYPE (expr));
-	  fprintf (dump_file, "original expr = ");
+	  fprintf (dump_file, "\noriginal expr = ");
 	  print_generic_expr (dump_file, expr);
-	  fprintf (dump_file, "\n");
 	}
       gcc_assert (can_escape);
       t->mark_escape (escape_unkown_field, NULL);
@@ -2797,7 +3926,9 @@ ipa_struct_reorg::mark_expr_escape (tree expr, escape_type escapes, gimple *stmt
   srtype *type;
   srfield *field;
   bool realpart, imagpart, address;
-  if (!get_type_field (expr, base, indirect, type, field, realpart, imagpart, address))
+  bool escape_from_base = false;
+  if (!get_type_field (expr, base, indirect, type, field,
+		       realpart, imagpart, address, escape_from_base))
     return;
 
   type->mark_escape (escapes, stmt);
@@ -2875,6 +4006,7 @@ ipa_struct_reorg::maybe_record_call (cgraph_node *node, gcall *stmt)
       return;
     }
 
+  /* get func param it's tree_list.  */
   argtype = TYPE_ARG_TYPES (gimple_call_fntype (stmt));
   for (unsigned i = 0; i < gimple_call_num_args (stmt); i++)
     {
@@ -2882,9 +4014,16 @@ ipa_struct_reorg::maybe_record_call (cgraph_node *node, gcall *stmt)
       if (argtype)
 	{
 	  tree argtypet = TREE_VALUE (argtype);
-	  if (!free_or_realloc
+	  /* callee_func (_1, _2);
+	     Check the callee func, instead of current func.  */
+	  if (!(free_or_realloc
+		|| (current_mode == STRUCT_REORDER_FIELDS
+		    && safe_functions.contains (
+		       node->get_edge (stmt)->callee)))
 	      && VOID_POINTER_P (argtypet))
-	    mark_type_as_escape (TREE_TYPE (arg), escape_cast_void);
+	    {
+	      mark_type_as_escape (TREE_TYPE (arg), escape_cast_void, stmt);
+	    }
 	  else
 	    record_stmt_expr (arg, node, stmt);
 	}
@@ -2905,11 +4044,26 @@ ipa_struct_reorg::record_stmt_expr (tree expr, cgraph_node *node, gimple *stmt)
   srtype *type;
   srfield *field;
   bool realpart, imagpart, address;
-  if (!get_type_field (expr, base, indirect, type, field, realpart, imagpart, address))
+  bool escape_from_base = false;
+  if (!get_type_field (expr, base, indirect, type, field,
+		       realpart, imagpart, address, escape_from_base))
     return;
 
-  if (!opt_for_fn (current_function_decl, flag_ipa_struct_reorg))
-    type->mark_escape (escape_non_optimize, stmt);
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      if (!opt_for_fn (current_function_decl, flag_ipa_reorder_fields))
+	{
+	  type->mark_escape (escape_non_optimize, stmt);
+	}
+    }
+  else
+    {
+      if (!opt_for_fn (current_function_decl, flag_ipa_struct_reorg))
+	{
+	  type->mark_escape (escape_non_optimize, stmt);
+	}
+    }
+
 
   /* Record it. */
   type->add_access (new sraccess (stmt, node, type, field));
@@ -2927,8 +4081,10 @@ ipa_struct_reorg::find_function (cgraph_node *node)
 }
 
 void
-ipa_struct_reorg::check_type_and_push (tree newdecl, srtype *type, vec<srdecl*> &worklist, gimple *stmt)
+ipa_struct_reorg::check_type_and_push (tree newdecl, srdecl *decl,
+				       vec<srdecl*> &worklist, gimple *stmt)
 {
+  srtype *type = decl->type;
   if (integer_zerop (newdecl))
     return;
 
@@ -2940,8 +4096,9 @@ ipa_struct_reorg::check_type_and_push (tree newdecl, srtype *type, vec<srdecl*>
           type->mark_escape (escape_cast_another_ptr, stmt);
 	  return;
 	}
-      if (d->type == type)
-        return;
+      if (d->type == type
+	  && cmp_ptr_layers (TREE_TYPE (newdecl), TREE_TYPE (decl->decl)))
+	return;
 
       srtype *type1 = d->type;
       type->mark_escape (escape_cast_another_ptr, stmt);
@@ -2991,7 +4148,9 @@ ipa_struct_reorg::check_type_and_push (tree newdecl, srtype *type, vec<srdecl*>
   /* Only add to the worklist if the decl is a SSA_NAME.  */
   if (TREE_CODE (newdecl) == SSA_NAME)
     worklist.safe_push (d);
-  if (d->type == type)
+  tree a_decl = d->orig_type ? d->orig_type : TREE_TYPE (newdecl);
+  tree b_decl = decl->orig_type ? decl->orig_type : TREE_TYPE (decl->decl);
+  if (d->type == type && cmp_ptr_layers (a_decl, b_decl))
     return;
 
   srtype *type1 = d->type;
@@ -3033,6 +4192,111 @@ ipa_struct_reorg::check_alloc_num (gimple *stmt, srtype *type)
     }
 }
 
+/* Check the definition of gimple assign.  */
+
+void
+ipa_struct_reorg::check_definition_assign (srdecl *decl, vec<srdecl*> &worklist)
+{
+  tree ssa_name = decl->decl;
+  srtype *type = decl->type;
+  gimple *stmt = SSA_NAME_DEF_STMT (ssa_name);
+  gcc_assert (gimple_code (stmt) == GIMPLE_ASSIGN);
+  /* a) if the SSA_NAME is sourced from a pointer plus, record the pointer and
+	check to make sure the addition was a multiple of the size.
+	check the pointer type too.  */
+  tree rhs = gimple_assign_rhs1 (stmt);
+  if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
+    {
+      tree rhs2 = gimple_assign_rhs2 (stmt);
+      tree num = NULL_TREE;
+      /* Specify the correct size for the multi-layer pointer.  */
+      if (!is_result_of_mult (rhs2, &num, isptrptr (decl->orig_type)
+					  ? TYPE_SIZE_UNIT (decl->orig_type)
+					  : TYPE_SIZE_UNIT (type->type)))
+	{
+	  type->mark_escape (escape_non_multiply_size, stmt);
+	}
+
+      if (TREE_CODE (rhs) == SSA_NAME)
+	{
+	  check_type_and_push (rhs, decl, worklist, stmt);
+	}
+      return;
+    }
+
+  if (gimple_assign_rhs_code (stmt) == MAX_EXPR
+      || gimple_assign_rhs_code (stmt) == MIN_EXPR
+      || gimple_assign_rhs_code (stmt) == BIT_IOR_EXPR
+      || gimple_assign_rhs_code (stmt) == BIT_XOR_EXPR
+      || gimple_assign_rhs_code (stmt) == BIT_AND_EXPR)
+    {
+      tree rhs2 = gimple_assign_rhs2 (stmt);
+      if (TREE_CODE (rhs) == SSA_NAME)
+	{
+	  check_type_and_push (rhs, decl, worklist, stmt);
+	}
+      if (TREE_CODE (rhs2) == SSA_NAME)
+	{
+	  check_type_and_push (rhs2, decl, worklist, stmt);
+	}
+      return;
+    }
+
+  /* Casts between pointers and integer are escaping.  */
+  if (gimple_assign_cast_p (stmt))
+    {
+      type->mark_escape (escape_cast_int, stmt);
+      return;
+    }
+
+  /* d) if the name is from a cast/assignment, make sure it is used as
+	that type or void*
+	i) If void* then push the ssa_name into worklist.  */
+  gcc_assert (gimple_assign_single_p (stmt));
+  check_other_side (decl, rhs, stmt, worklist);
+  check_ptr_layers (decl->decl, rhs, stmt);
+}
+
+/* Check the definition of gimple call.  */
+
+void
+ipa_struct_reorg::check_definition_call (srdecl *decl, vec<srdecl*> &worklist)
+{
+  tree ssa_name = decl->decl;
+  srtype *type = decl->type;
+  gimple *stmt = SSA_NAME_DEF_STMT (ssa_name);
+  gcc_assert (gimple_code (stmt) == GIMPLE_CALL);
+
+  /* For realloc, check the type of the argument.  */
+  if (gimple_call_builtin_p (stmt, BUILT_IN_REALLOC))
+    {
+      check_type_and_push (gimple_call_arg (stmt, 0), decl, worklist, stmt);
+    }
+
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      if (!handled_allocation_stmt (stmt))
+	{
+	  type->mark_escape (escape_return, stmt);
+	}
+      if (!allocate_size (type, decl, stmt))
+	{
+	  type->mark_escape (escape_non_multiply_size, stmt);
+	}
+    }
+  else
+    {
+      if (!handled_allocation_stmt (stmt)
+	  || !allocate_size (type, decl, stmt))
+	{
+	  type->mark_escape (escape_return, stmt);
+	}
+    }
+
+  check_alloc_num (stmt, type);
+  return;
+}
+
 /*
   2) Check SSA_NAMEs for non type usages (source or use) (worlist of srdecl)
      a) if the SSA_NAME is sourced from a pointer plus, record the pointer and
@@ -3058,9 +4322,16 @@ ipa_struct_reorg::check_definition (srdecl *decl, vec<srdecl*> &worklist)
       if (var
 	  && TREE_CODE (var) == PARM_DECL
 	  && VOID_POINTER_P (TREE_TYPE (ssa_name)))
-        type->mark_escape (escape_cast_void, NULL);
+	{
+	  type->mark_escape (escape_cast_void, SSA_NAME_DEF_STMT (ssa_name));
+	}
       return;
     }
+  if (current_mode == STRUCT_REORDER_FIELDS && SSA_NAME_VAR (ssa_name)
+      && VOID_POINTER_P (TREE_TYPE (SSA_NAME_VAR (ssa_name))))
+    {
+      type->mark_escape (escape_cast_void, SSA_NAME_DEF_STMT (ssa_name));
+    }
   gimple *stmt = SSA_NAME_DEF_STMT (ssa_name);
 
   /*
@@ -3069,15 +4340,7 @@ ipa_struct_reorg::check_definition (srdecl *decl, vec<srdecl*> &worklist)
   */
   if (gimple_code (stmt) == GIMPLE_CALL)
     {
-      /* For realloc, check the type of the argument. */
-      if (gimple_call_builtin_p (stmt, BUILT_IN_REALLOC))
-        check_type_and_push (gimple_call_arg (stmt, 0), type, worklist, stmt);
-
-      if (!handled_allocation_stmt (stmt)
-          || !allocate_size (type, stmt))
-        type->mark_escape (escape_return, stmt);
-      check_alloc_num (stmt, type);
-      return;
+      check_definition_call (decl, worklist);
     }
   /* If the SSA_NAME is sourced from an inline-asm, just mark the type as escaping.  */
   if (gimple_code (stmt) == GIMPLE_ASM)
@@ -3091,61 +4354,16 @@ ipa_struct_reorg::check_definition (srdecl *decl, vec<srdecl*> &worklist)
   if (gimple_code (stmt) == GIMPLE_PHI)
     {
       for (unsigned i = 0; i < gimple_phi_num_args (stmt); i++)
-	check_type_and_push (gimple_phi_arg_def (stmt, i), type, worklist, stmt);
-      return;
-    }
-
-  gcc_assert (gimple_code (stmt) == GIMPLE_ASSIGN);
-  /*
-     a) if the SSA_NAME is sourced from a pointer plus, record the pointer and
-	check to make sure the addition was a multiple of the size.
-	check the pointer type too.
-  */
-
-  tree rhs = gimple_assign_rhs1 (stmt);
-  if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
-    {
-      tree rhs2 = gimple_assign_rhs2 (stmt);
-      tree num;
-      if (!is_result_of_mult (rhs2, &num, TYPE_SIZE_UNIT (type->type)))
-        type->mark_escape (escape_non_multiply_size, stmt);
-
-      if (TREE_CODE (rhs) == SSA_NAME)
-        check_type_and_push (rhs, type, worklist, stmt);
-      return;
-    }
-
-  if (gimple_assign_rhs_code (stmt) == MAX_EXPR
-      || gimple_assign_rhs_code (stmt) == MIN_EXPR
-      || gimple_assign_rhs_code (stmt) == BIT_IOR_EXPR
-      || gimple_assign_rhs_code (stmt) == BIT_XOR_EXPR
-      || gimple_assign_rhs_code (stmt) == BIT_AND_EXPR)
-    {
-      tree rhs2 = gimple_assign_rhs2 (stmt);
-      if (TREE_CODE (rhs) == SSA_NAME)
-	{
-	  check_type_and_push (rhs, type, worklist, stmt);
-	}
-      if (TREE_CODE (rhs2) == SSA_NAME)
 	{
-	  check_type_and_push (rhs2, type, worklist, stmt);
+	  check_type_and_push (gimple_phi_arg_def (stmt, i),
+			       decl, worklist, stmt);
 	}
       return;
     }
-
-  /* Casts between pointers and integer are escaping.  */
-  if (gimple_assign_cast_p (stmt))
+  if (gimple_code (stmt) == GIMPLE_ASSIGN)
     {
-      type->mark_escape (escape_cast_int, stmt);
-      return;
+      check_definition_assign (decl, worklist);
     }
-
-  /*
-     d) if the name is from a cast/assignment, make sure it is used as that type or void*
-	i) If void* then push the ssa_name into worklist
-  */
-  gcc_assert (gimple_assign_single_p (stmt));
-  check_other_side (decl, rhs, stmt, worklist);
 }
 
 /* Mark the types used by the inline-asm as escaping.  It is unkown what happens inside
@@ -3177,11 +4395,10 @@ ipa_struct_reorg::check_other_side (srdecl *decl, tree other, gimple *stmt, vec<
 {
   srtype *type = decl->type;
 
-  if (TREE_CODE (other) == SSA_NAME
-      || DECL_P (other)
+  if (TREE_CODE (other) == SSA_NAME || DECL_P (other)
       || TREE_CODE (other) == INTEGER_CST)
     {
-      check_type_and_push (other, type, worklist, stmt);
+      check_type_and_push (other, decl, worklist, stmt);
       return;
     }
 
@@ -3207,8 +4424,29 @@ ipa_struct_reorg::check_other_side (srdecl *decl, tree other, gimple *stmt, vec<
       srtype *type1;
       srfield *field;
       bool realpart, imagpart, address;
-      if (!get_type_field (other, base, indirect, type1, field, realpart, imagpart, address))
-        type->mark_escape (escape_cast_another_ptr, stmt);
+      bool escape_from_base = false;
+      if (!get_type_field (other, base, indirect, type1, field,
+			   realpart, imagpart, address, escape_from_base))
+	{
+	  if (current_mode == STRUCT_REORDER_FIELDS)
+	    {
+	      /* release INTEGER_TYPE cast to struct pointer.  */
+	      bool cast_from_int_ptr = current_function->is_safe_func && base
+		&& find_decl (base) == NULL && POINTER_TYPE_P (TREE_TYPE (base))
+		&& (TREE_CODE (inner_type (TREE_TYPE (base))) == INTEGER_TYPE);
+
+	      /* Add a safe func mechanism.  */
+	      bool from_void_ptr_parm = current_function->is_safe_func
+		&& TREE_CODE (base) == SSA_NAME && is_from_void_ptr_parm (base);
+
+	      /* release type is used by a type which escapes.  */
+	      if (escape_from_base || cast_from_int_ptr || from_void_ptr_parm)
+		{
+		  return;
+		}
+	    }
+	  type->mark_escape (escape_cast_another_ptr, stmt);
+	}
 
       return;
     }
@@ -3220,6 +4458,71 @@ ipa_struct_reorg::check_other_side (srdecl *decl, tree other, gimple *stmt, vec<
 }
 
 
+/* Get the expr base.  */
+
+void
+get_base (tree &base, tree expr)
+{
+  if (TREE_CODE (expr) == MEM_REF)
+    {
+      base = TREE_OPERAND (expr, 0);
+    }
+  else if (TREE_CODE (expr) == COMPONENT_REF)
+    {
+      base = TREE_OPERAND (expr, 0);
+      base = (TREE_CODE (base) == MEM_REF) ? TREE_OPERAND (base, 0) : base;
+    }
+  else if (TREE_CODE (expr) == ADDR_EXPR)
+    {
+      base = TREE_OPERAND (expr, 0);
+    }
+}
+
+/* Check whether the number of pointer layers of exprs is equal,
+   marking unequals as escape.  */
+
+void
+ipa_struct_reorg::check_ptr_layers (tree a_expr, tree b_expr, gimple* stmt)
+{
+  if (current_mode != STRUCT_REORDER_FIELDS || current_function->is_safe_func
+      || !(POINTER_TYPE_P (TREE_TYPE (a_expr)))
+      || !(POINTER_TYPE_P (TREE_TYPE (b_expr)))
+      || !handled_type (TREE_TYPE (a_expr))
+      || !handled_type (TREE_TYPE (b_expr)))
+    {
+      return;
+    }
+
+  tree a_base = a_expr;
+  tree b_base = b_expr;
+  get_base (a_base, a_expr);
+  get_base (b_base, b_expr);
+
+  srdecl *a = find_decl (a_base);
+  srdecl *b = find_decl (b_base);
+  if (a && b == NULL && TREE_CODE (b_expr) != INTEGER_CST)
+    {
+      a->type->mark_escape (escape_cast_another_ptr, stmt);
+      return;
+    }
+  else if (b && a == NULL && TREE_CODE (a_expr) != INTEGER_CST)
+    {
+      b->type->mark_escape (escape_cast_another_ptr, stmt);
+      return;
+    }
+  else if (a == NULL && b == NULL)
+    {
+      return;
+    }
+
+  if (cmp_ptr_layers (TREE_TYPE (a_expr), TREE_TYPE (b_expr)))
+    {
+      return;
+    }
+  a->type->mark_escape (escape_cast_another_ptr, stmt);
+  b->type->mark_escape (escape_cast_another_ptr, stmt);
+}
+
 void
 ipa_struct_reorg::check_use (srdecl *decl, gimple *stmt, vec<srdecl*> &worklist)
 {
@@ -3234,7 +4537,7 @@ ipa_struct_reorg::check_use (srdecl *decl, gimple *stmt, vec<srdecl*> &worklist)
      check to make sure they are used correctly.  */
   if (gimple_code (stmt) == GIMPLE_PHI)
     {
-      check_type_and_push (gimple_phi_result (stmt), type, worklist, stmt);
+      check_type_and_push (gimple_phi_result (stmt), decl, worklist, stmt);
       return;
     }
 
@@ -3250,10 +4553,15 @@ ipa_struct_reorg::check_use (srdecl *decl, gimple *stmt, vec<srdecl*> &worklist)
       tree rhs2 = gimple_cond_rhs (stmt);
       tree orhs = rhs1;
       enum tree_code code = gimple_cond_code (stmt);
-      if (code != EQ_EXPR && code != NE_EXPR
-	  && (current_mode != COMPLETE_STRUCT_RELAYOUT
-	      || (code != LT_EXPR && code != LE_EXPR
-		  && code != GT_EXPR && code != GE_EXPR)))
+      if ((current_mode == NORMAL && (code != EQ_EXPR && code != NE_EXPR))
+	   || (current_mode == COMPLETE_STRUCT_RELAYOUT
+	       && (code != EQ_EXPR && code != NE_EXPR
+		   && code != LT_EXPR && code != LE_EXPR
+		   && code != GT_EXPR && code != GE_EXPR))
+	   || (current_mode == STRUCT_REORDER_FIELDS
+	       && (code != EQ_EXPR && code != NE_EXPR
+		   && code != LT_EXPR && code != LE_EXPR
+		   && code != GT_EXPR && code != GE_EXPR)))
 	{
 	  mark_expr_escape (rhs1, escape_non_eq, stmt);
 	  mark_expr_escape (rhs2, escape_non_eq, stmt);
@@ -3264,7 +4572,7 @@ ipa_struct_reorg::check_use (srdecl *decl, gimple *stmt, vec<srdecl*> &worklist)
 	return;
       if (TREE_CODE (orhs) != SSA_NAME)
 	mark_expr_escape (rhs1, escape_non_eq, stmt);
-      check_type_and_push (orhs, type, worklist, stmt);
+      check_type_and_push (orhs, decl, worklist, stmt);
       return;
     }
 
@@ -3284,9 +4592,14 @@ ipa_struct_reorg::check_use (srdecl *decl, gimple *stmt, vec<srdecl*> &worklist)
       tree rhs2 = gimple_assign_rhs2 (stmt);
       tree orhs = rhs1;
       enum tree_code code = gimple_assign_rhs_code (stmt);
-      if (code != EQ_EXPR && code != NE_EXPR
-	  && (current_mode != COMPLETE_STRUCT_RELAYOUT
-	      || (code != LT_EXPR && code != LE_EXPR
+      if ((current_mode == NORMAL && (code != EQ_EXPR && code != NE_EXPR))
+	   || (current_mode == COMPLETE_STRUCT_RELAYOUT
+	       && (code != EQ_EXPR && code != NE_EXPR
+		   && code != LT_EXPR && code != LE_EXPR
+		   && code != GT_EXPR && code != GE_EXPR))
+	   || (current_mode == STRUCT_REORDER_FIELDS
+	       && (code != EQ_EXPR && code != NE_EXPR
+		   && code != LT_EXPR && code != LE_EXPR
 		  && code != GT_EXPR && code != GE_EXPR)))
 	{
 	  mark_expr_escape (rhs1, escape_non_eq, stmt);
@@ -3298,7 +4611,7 @@ ipa_struct_reorg::check_use (srdecl *decl, gimple *stmt, vec<srdecl*> &worklist)
 	return;
       if (TREE_CODE (orhs) != SSA_NAME)
 	mark_expr_escape (rhs1, escape_non_eq, stmt);
-      check_type_and_push (orhs, type, worklist, stmt);
+      check_type_and_push (orhs, decl, worklist, stmt);
       return;
     }
 
@@ -3312,6 +4625,7 @@ ipa_struct_reorg::check_use (srdecl *decl, gimple *stmt, vec<srdecl*> &worklist)
 	  check_other_side (decl, lhs, stmt, worklist);
 	  return;
 	}
+      check_ptr_layers (lhs, rhs, stmt);
     }
 
   if (is_gimple_assign (stmt)
@@ -3321,10 +4635,26 @@ ipa_struct_reorg::check_use (srdecl *decl, gimple *stmt, vec<srdecl*> &worklist)
       tree lhs = gimple_assign_lhs (stmt);
       tree num;
       check_other_side (decl, lhs, stmt, worklist);
-      if (!is_result_of_mult (rhs2, &num, TYPE_SIZE_UNIT (type->type)))
+      check_ptr_layers (lhs, decl->decl, stmt);
+      /* Specify the correct size for the multi-layer pointer.  */
+      if (!is_result_of_mult (rhs2, &num, isptrptr (decl->orig_type)
+					  ? TYPE_SIZE_UNIT (decl->orig_type)
+					  : TYPE_SIZE_UNIT (type->type)))
         type->mark_escape (escape_non_multiply_size, stmt);
     }
 
+  if (is_gimple_assign (stmt)
+      && gimple_assign_rhs_code (stmt) == POINTER_DIFF_EXPR)
+    {
+      tree rhs1 = gimple_assign_rhs1 (stmt);
+      tree rhs2 = gimple_assign_rhs2 (stmt);
+      tree other = rhs1 == decl->decl ? rhs2 : rhs1;
+
+      check_other_side (decl, other, stmt, worklist);
+      check_ptr_layers (decl->decl, other, stmt);
+      return;
+    }
+
 }
 
 /*
@@ -3388,17 +4718,51 @@ ipa_struct_reorg::record_function (cgraph_node *node)
   if (DECL_PRESERVE_P (node->decl))
     escapes = escape_marked_as_used;
   else if (!node->local)
-    escapes = escape_visible_function;
+    {
+      if (current_mode != STRUCT_REORDER_FIELDS)
+	{
+	  escapes = escape_visible_function;
+	}
+      if (current_mode == STRUCT_REORDER_FIELDS && node->externally_visible)
+	{
+	  escapes = escape_visible_function;
+	}
+    }
   else if (!node->can_change_signature)
     escapes = escape_cannot_change_signature;
   else if (!tree_versionable_function_p (node->decl))
     escapes = escape_noclonable_function;
-  else if (!opt_for_fn (node->decl, flag_ipa_struct_reorg))
-    escapes = escape_non_optimize;
+
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      if (!opt_for_fn (node->decl, flag_ipa_reorder_fields))
+	{
+	  escapes = escape_non_optimize;
+	}
+    }
+  else if (current_mode == NORMAL || current_mode == COMPLETE_STRUCT_RELAYOUT)
+    {
+      if (!opt_for_fn (node->decl, flag_ipa_struct_reorg))
+	{
+	  escapes = escape_non_optimize;
+	}
+    }
 
   basic_block bb;
   gimple_stmt_iterator si;
 
+  /* Add a safe func mechanism.  */
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      current_function->is_safe_func = safe_functions.contains (node);
+      if (dump_file)
+	{
+	  fprintf (dump_file, "\nfunction %s/%u: is_safe_func = %d\n",
+		   node->name (), node->order,
+		   current_function->is_safe_func);
+	}
+    }
+
   /* Record the static chain decl.  */
   if (fn->static_chain_decl)
    {
@@ -3529,6 +4893,49 @@ ipa_struct_reorg::record_function (cgraph_node *node)
 }
 
 
+/* For a function that contains the void* parameter and passes the structure
+   pointer, check whether the function uses the input node safely.
+   For these functions, the void* parameter and related ssa_name are not
+   recorded in record_function (), and the input structure type is not escaped.
+*/
+
+void
+ipa_struct_reorg::record_safe_func_with_void_ptr_parm ()
+{
+  cgraph_node *node = NULL;
+  FOR_EACH_FUNCTION (node)
+    {
+      if (!node->real_symbol_p ())
+	{
+	  continue;
+	}
+      if (node->definition)
+	{
+	  if (!node->has_gimple_body_p () || node->inlined_to)
+	    {
+	      continue;
+	    }
+	  node->get_body ();
+	  function *fn = DECL_STRUCT_FUNCTION (node->decl);
+	  if (!fn)
+	    {
+	      continue;
+	    }
+	  push_cfun (fn);
+	  if (is_safe_func_with_void_ptr_parm (node))
+	    {
+	      safe_functions.add (node);
+	      if (dump_file && (dump_flags & TDF_DETAILS))
+		{
+		  fprintf (dump_file, "\nfunction %s/%u is safe function.\n",
+			   node->name (), node->order);
+		}
+	    }
+	  pop_cfun ();
+	}
+    }
+}
+
 /* Record all accesses for all types including global variables. */
 
 void
@@ -3560,6 +4967,12 @@ ipa_struct_reorg::record_accesses (void)
       record_var (var->decl, escapes);
     }
 
+  /* Add a safe func mechanism.  */
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      record_safe_func_with_void_ptr_parm ();
+    }
+
   FOR_EACH_FUNCTION (cnode)
     {
       if (!cnode->real_symbol_p ())
@@ -3578,11 +4991,14 @@ ipa_struct_reorg::record_accesses (void)
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
-      fprintf (dump_file, "all types (before pruning):\n");
+      fprintf (dump_file, "\n");
+      fprintf (dump_file, "==============================================\n\n");
+      fprintf (dump_file, "======== all types (before pruning): ========\n\n");
       dump_types (dump_file);
-      fprintf (dump_file, "all functions (before pruning):\n");
+      fprintf (dump_file, "======= all functions (before pruning): =======\n");
       dump_functions (dump_file);
     }
+  /* If record_var () is called later, new types will not be recorded.  */
   done_recording = true;
 }
 
@@ -3606,6 +5022,7 @@ ipa_struct_reorg::walk_field_for_cycles (srtype *type)
     {
       if (!field->type)
 	;
+      /* If there are two members of the same structure pointer type? */
       else if (field->type->visited
 	       || walk_field_for_cycles (field->type))
 	{
@@ -3685,22 +5102,99 @@ ipa_struct_reorg::propagate_escape (void)
     } while (changed);
 }
 
+/* If the original type (with members) has escaped, corresponding to the
+   struct pointer type (empty member) in the structure fields
+   should also marked as escape.  */
+
+void
+ipa_struct_reorg::propagate_escape_via_original (void)
+{
+  for (unsigned i = 0; i < types.length (); i++)
+    {
+      for (unsigned j = 0; j < types[i]->fields.length (); j++)
+	{
+	  srfield *field = types[i]->fields[j];
+	  if (handled_type (field->fieldtype) && field->type)
+	    {
+	      for (unsigned k = 0; k < types.length (); k++)
+		{
+		  const char *type1 = get_type_name (field->type->type);
+		  const char *type2 = get_type_name (types[k]->type);
+		  if (type1 == NULL || type2 == NULL)
+		    {
+		      continue;
+		    }
+		  if (type1 == type2 && types[k]->has_escaped ())
+		    {
+		      if (!field->type->has_escaped ())
+			{
+			  field->type->mark_escape (
+				       escape_via_orig_escape, NULL);
+			}
+		      break;
+		    }
+		}
+	    }
+	}
+    }
+}
+
+/* Marks the fileds as empty and does not have the original structure type
+   is escape.  */
+
+void
+ipa_struct_reorg::propagate_escape_via_empty_with_no_original (void)
+{
+  for (unsigned i = 0; i < types.length (); i++)
+    {
+      if (types[i]->fields.length () == 0)
+	{
+	  for (unsigned j = 0; j < types.length (); j++)
+	    {
+	      if (i != j && types[j]->fields.length ())
+		{
+		  const char *type1 = get_type_name (types[i]->type);
+		  const char *type2 = get_type_name (types[j]->type);
+		  if (type1 != NULL && type2 != NULL && type1 == type2)
+		    {
+		      break;
+		    }
+		}
+	      if (j == types.length () - 1)
+		{
+		  types[i]->mark_escape (escape_via_empty_no_orig, NULL);
+		}
+	    }
+	}
+    }
+}
+
 /* Prune the escaped types and their decls from what was recorded.  */
 
 void
 ipa_struct_reorg::prune_escaped_types (void)
 {
-  if (current_mode != COMPLETE_STRUCT_RELAYOUT)
+  if (current_mode != COMPLETE_STRUCT_RELAYOUT
+      && current_mode != STRUCT_REORDER_FIELDS)
     {
+      /* Detect recusive types and mark them as escaping.  */
       detect_cycles ();
+      /* If contains or is contained by the escape type,
+	 mark them as escaping.  */
       propagate_escape ();
     }
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      propagate_escape_via_original ();
+      propagate_escape_via_empty_with_no_original ();
+    }
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
-      fprintf (dump_file, "all types (after prop but before pruning):\n");
+      fprintf (dump_file, "==============================================\n\n");
+      fprintf (dump_file, "all types (after prop but before pruning): \n\n");
       dump_types (dump_file);
-      fprintf (dump_file, "all functions (after prop but before pruning):\n");
+      fprintf (dump_file, "all functions (after prop but before pruning): \n");
       dump_functions (dump_file);
     }
 
@@ -3748,7 +5242,8 @@ ipa_struct_reorg::prune_escaped_types (void)
       /* Prune functions which don't refer to any variables any more.  */
       if (function->args.is_empty ()
 	  && function->decls.is_empty ()
-	  && function->globals.is_empty ())
+	  && function->globals.is_empty ()
+	  && current_mode != STRUCT_REORDER_FIELDS)
 	{
 	  delete function;
 	  functions.ordered_remove (i);
@@ -3773,24 +5268,33 @@ ipa_struct_reorg::prune_escaped_types (void)
 
   /* Prune types that escape, all references to those types
      will have been removed in the above loops.  */
-  for (unsigned i = 0; i < types.length (); )
+  /* The escape type is not deleted in STRUCT_REORDER_FIELDS,
+     Then the type that contains the escaped type fields
+     can find complete information.  */
+  if (current_mode != STRUCT_REORDER_FIELDS)
     {
-      srtype *type = types[i];
-      if (type->has_escaped ())
+      for (unsigned i = 0; i < types.length ();)
 	{
-	  /* All references to this type should have been removed now. */
-	  delete type;
-	  types.ordered_remove (i);
+	  srtype *type = types[i];
+	  if (type->has_escaped ())
+	    {
+	      /* All references to this type should have been removed now.  */
+	      delete type;
+	      types.ordered_remove (i);
+	    }
+	  else
+	    {
+	      i++;
+	    }
 	}
-      else
-	i++;
     }
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
-      fprintf (dump_file, "all types (after pruning):\n");
+      fprintf (dump_file, "==============================================\n\n");
+      fprintf (dump_file, "========= all types (after pruning): =========\n\n");
       dump_types (dump_file);
-      fprintf (dump_file, "all functions (after pruning):\n");
+      fprintf (dump_file, "======== all functions (after pruning): ========\n");
       dump_functions (dump_file);
     }
 }
@@ -3817,6 +5321,28 @@ ipa_struct_reorg::create_new_types (void)
   for (unsigned i = 0; i < types.length (); i++)
     newtypes += types[i]->create_new_type ();
 
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      for (unsigned i = 0; i < types.length (); i++)
+	{
+	  auto_vec <tree> *fields = fields_to_finish.get (types[i]->type);
+	  if (fields)
+	    {
+	      for (unsigned j = 0; j < fields->length (); j++)
+		{
+		  tree field = (*fields)[j];
+		  TREE_TYPE (field)
+		  = reconstruct_complex_type (TREE_TYPE (field),
+					      types[i]->newtype[0]);
+		}
+	    }
+	}
+      for (unsigned i = 0; i < types.length (); i++)
+	{
+	  layout_type (types[i]->newtype[0]);
+	}
+    }
+
   if (dump_file)
     {
       if (newtypes)
@@ -3919,7 +5445,8 @@ ipa_struct_reorg::create_new_args (cgraph_node *new_node)
   char *name = NULL;
   if (tname)
     {
-      name = concat (tname, ".reorg.0", NULL);
+      name = concat (tname, current_mode == STRUCT_REORDER_FIELDS
+			    ? ".reorder.0" : ".reorg.0", NULL);
       new_name = get_identifier (name);
       free (name);
     }
@@ -4005,9 +5532,10 @@ ipa_struct_reorg::create_new_functions (void)
 	  fprintf (dump_file, "\n");
 	}
       statistics_counter_event (NULL, "Create new function", 1);
-      new_node = node->create_version_clone_with_body (vNULL, NULL,
-						       NULL, NULL, NULL,
-						      "struct_reorg");
+      new_node = node->create_version_clone_with_body (
+				vNULL, NULL, NULL, NULL, NULL,
+				current_mode == STRUCT_REORDER_FIELDS
+				? "struct_reorder" : "struct_reorg");
       new_node->can_change_signature = node->can_change_signature;
       new_node->make_local ();
       f->newnode = new_node;
@@ -4047,6 +5575,7 @@ ipa_struct_reorg::rewrite_expr (tree expr, tree newexpr[max_split], bool ignore_
   srfield *f;
   bool realpart, imagpart;
   bool address;
+  bool escape_from_base = false;
 
   tree newbase[max_split];
   memset (newexpr, 0, sizeof(tree[max_split]));
@@ -4064,7 +5593,8 @@ ipa_struct_reorg::rewrite_expr (tree expr, tree newexpr[max_split], bool ignore_
       return true;
     }
 
-  if (!get_type_field (expr, base, indirect, t, f, realpart, imagpart, address))
+  if (!get_type_field (expr, base, indirect, t, f, realpart, imagpart,
+		       address, escape_from_base))
     return false;
 
   /* If the type is not changed, then just return false. */
@@ -4122,7 +5652,40 @@ ipa_struct_reorg::rewrite_expr (tree expr, tree newexpr[max_split], bool ignore_
       if (address)
         newbase1 = build_fold_addr_expr (newbase1);
       if (indirect)
-        newbase1 = build_simple_mem_ref (newbase1);
+	{
+	  if (current_mode == STRUCT_REORDER_FIELDS)
+	    {
+	      /* Supports the MEM_REF offset.
+		 _1 = MEM[(struct arc *)ap_4 + 72B].flow;
+		 Old rewrite：_1 = ap.reorder.0_8->flow;
+		 New rewrite：_1
+		  = MEM[(struct arc.reorder.0 *)ap.reorder.0_8 + 64B].flow;
+	      */
+	      HOST_WIDE_INT offset_tmp = 0;
+	      HOST_WIDE_INT mem_offset = 0;
+	      bool realpart_tmp = false;
+	      bool imagpart_tmp = false;
+	      tree accesstype_tmp = NULL_TREE;
+	      tree num = NULL_TREE;
+	      get_ref_base_and_offset (expr, offset_tmp,
+				       realpart_tmp, imagpart_tmp,
+				       accesstype_tmp, &num);
+
+	      tree ptype = TREE_TYPE (newbase1);
+	      /* Specify the correct size for the multi-layer pointer.  */
+	      tree size = isptrptr (ptype) ? TYPE_SIZE_UNIT (ptype) :
+			  TYPE_SIZE_UNIT (inner_type (ptype));
+	      mem_offset = (num != NULL)
+			     ? TREE_INT_CST_LOW (num) * tree_to_shwi (size)
+			     : 0;
+	      newbase1 = build2 (MEM_REF, TREE_TYPE (ptype), newbase1,
+				 build_int_cst (ptype, mem_offset));
+	    }
+	  else
+	    {
+	      newbase1 = build_simple_mem_ref (newbase1);
+	    }
+	}
       newexpr[i] = build3 (COMPONENT_REF, TREE_TYPE (f->newfield[i]),
 			   newbase1, f->newfield[i], NULL_TREE);
       if (imagpart)
@@ -4162,8 +5725,12 @@ ipa_struct_reorg::rewrite_assign (gassign *stmt, gimple_stmt_iterator *gsi)
       return remove;
     }
 
-  if (gimple_assign_rhs_code (stmt) == EQ_EXPR
-      || gimple_assign_rhs_code (stmt) == NE_EXPR)
+  if ((current_mode != STRUCT_REORDER_FIELDS
+       && (gimple_assign_rhs_code (stmt) == EQ_EXPR
+	   || gimple_assign_rhs_code (stmt) == NE_EXPR))
+      || (current_mode == STRUCT_REORDER_FIELDS
+	  && (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt))
+	      == tcc_comparison)))
     {
       tree rhs1 = gimple_assign_rhs1 (stmt);
       tree rhs2 = gimple_assign_rhs2 (stmt);
@@ -4171,6 +5738,12 @@ ipa_struct_reorg::rewrite_assign (gassign *stmt, gimple_stmt_iterator *gsi)
       tree newrhs2[max_split];
       tree_code rhs_code = gimple_assign_rhs_code (stmt);
       tree_code code = rhs_code == EQ_EXPR ? BIT_AND_EXPR : BIT_IOR_EXPR;
+      if (current_mode == STRUCT_REORDER_FIELDS
+	  && rhs_code != EQ_EXPR && rhs_code != NE_EXPR)
+	{
+	  code = rhs_code;
+	}
+
       if (!rewrite_lhs_rhs (rhs1, rhs2, newrhs1, newrhs2))
 	return false;
       tree newexpr = NULL_TREE;
@@ -4208,19 +5781,88 @@ ipa_struct_reorg::rewrite_assign (gassign *stmt, gimple_stmt_iterator *gsi)
       if (!is_result_of_mult (rhs2, &num, size))
 	internal_error ("the rhs of pointer was not a multiplicate and it slipped through.");
 
-      num = gimplify_build1 (gsi, NOP_EXPR, sizetype, num);
+      /* Add the judgment of num, support for POINTER_DIFF_EXPR.
+	 _6 = _4 + _5;
+	 _5 = (long unsigned int) _3;
+	 _3 = _1 - old_2.  */
+      if (current_mode != STRUCT_REORDER_FIELDS
+	  || (current_mode == STRUCT_REORDER_FIELDS && (num != NULL)))
+	{
+	  num = gimplify_build1 (gsi, NOP_EXPR, sizetype, num);
+	}
       for (unsigned i = 0; i < max_split && newlhs[i]; i++)
 	{
 	  gimple *new_stmt;
 
-          tree newsize = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (newlhs[i])));
-	  newsize = gimplify_build2 (gsi, MULT_EXPR, sizetype, num, newsize);
-	  new_stmt = gimple_build_assign (newlhs[i], POINTER_PLUS_EXPR, newrhs[i], newsize);
+	  if (num != NULL)
+	    {
+	      tree newsize = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (newlhs[i])));
+	      newsize = gimplify_build2 (gsi, MULT_EXPR, sizetype, num,
+					 newsize);
+	      new_stmt = gimple_build_assign (newlhs[i], POINTER_PLUS_EXPR,
+					      newrhs[i], newsize);
+	    }
+	  else
+	    {
+	      new_stmt = gimple_build_assign (newlhs[i], POINTER_PLUS_EXPR,
+					      newrhs[i], rhs2);
+	    }
 	  gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
 	  remove = true;
 	}
       return remove;
     }
+
+  /* Support POINTER_DIFF_EXPR rewriting.  */
+  if (current_mode == STRUCT_REORDER_FIELDS
+      && gimple_assign_rhs_code (stmt) == POINTER_DIFF_EXPR)
+    {
+      tree rhs1 = gimple_assign_rhs1 (stmt);
+      tree rhs2 = gimple_assign_rhs2 (stmt);
+      tree newrhs1[max_split];
+      tree newrhs2[max_split];
+
+      bool r1 = rewrite_expr (rhs1, newrhs1);
+      bool r2 = rewrite_expr (rhs2, newrhs2);
+
+      if (r1 != r2)
+	{
+	  /* Handle NULL pointer specially.  */
+	  if (r1 && !r2 && integer_zerop (rhs2))
+	    {
+	      r2 = true;
+	      for (unsigned i = 0; i < max_split && newrhs1[i]; i++)
+		{
+		  newrhs2[i] = fold_convert (TREE_TYPE (newrhs1[i]), rhs2);
+		}
+	    }
+	  else if (r2 && !r1 && integer_zerop (rhs1))
+	    {
+	      r1 = true;
+	      for (unsigned i = 0; i < max_split && newrhs2[i]; i++)
+		{
+		  newrhs1[i] = fold_convert (TREE_TYPE (newrhs2[i]), rhs1);
+		}
+	    }
+	  else
+	    {
+	      return false;
+	    }
+	}
+      else if (!r1 && !r2)
+	return false;
+
+      /* The two operands always have pointer/reference type.  */
+      for (unsigned i = 0; i < max_split && newrhs1[i] && newrhs2[i]; i++)
+	{
+	  gimple_assign_set_rhs1 (stmt, newrhs1[i]);
+	  gimple_assign_set_rhs2 (stmt, newrhs2[i]);
+	  update_stmt (stmt);
+	}
+      remove = false;
+      return remove;
+    }
+
   if (gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
     {
       tree lhs = gimple_assign_lhs (stmt);
@@ -4228,21 +5870,20 @@ ipa_struct_reorg::rewrite_assign (gassign *stmt, gimple_stmt_iterator *gsi)
 
       if (dump_file && (dump_flags & TDF_DETAILS))
 	{
-	  fprintf (dump_file, "rewriting stamtenet:\n");
+	  fprintf (dump_file, "\nrewriting stamtenet:\n");
 	  print_gimple_stmt (dump_file, stmt, 0);
-	  fprintf (dump_file, "\n");
 	}
       tree newlhs[max_split];
       tree newrhs[max_split];
       if (!rewrite_lhs_rhs (lhs, rhs, newlhs, newrhs))
 	{
 	  if (dump_file && (dump_flags & TDF_DETAILS))
-	    fprintf (dump_file, "\nDid nothing to statement.\n");
+	    fprintf (dump_file, "Did nothing to statement.\n");
 	  return false;
 	}
 
       if (dump_file && (dump_flags & TDF_DETAILS))
-	fprintf (dump_file, "\nreplaced with:\n");
+	fprintf (dump_file, "replaced with:\n");
       for (unsigned i = 0; i < max_split && (newlhs[i] || newrhs[i]); i++)
 	{
 	  gimple *newstmt = gimple_build_assign (newlhs[i] ? newlhs[i] : lhs, newrhs[i] ? newrhs[i] : rhs);
@@ -4276,7 +5917,7 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi)
       if (!decl || !decl->type)
 	return false;
       srtype *type = decl->type;
-      tree num = allocate_size (type, stmt);
+      tree num = allocate_size (type, decl, stmt);
       gcc_assert (num);
       memset (newrhs1, 0, sizeof(newrhs1));
 
@@ -4296,7 +5937,10 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi)
       /* Go through each new lhs.  */
       for (unsigned i = 0; i < max_split && decl->newdecl[i]; i++)
 	{
-	  tree newsize = TYPE_SIZE_UNIT (type->type);
+	  /* Specify the correct size for the multi-layer pointer.  */
+	  tree newsize = isptrptr (decl->orig_type)
+			 ? TYPE_SIZE_UNIT (decl->orig_type)
+			 : TYPE_SIZE_UNIT (type->newtype[i]);
 	  gimple *g;
 	  /* Every allocation except for calloc needs the size multiplied out. */
 	  if (!gimple_call_builtin_p (stmt, BUILT_IN_CALLOC))
@@ -4356,6 +6000,25 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi)
   gcc_assert (node);
   srfunction *f = find_function (node);
 
+  /* Add a safe func mechanism.  */
+  if (current_mode == STRUCT_REORDER_FIELDS && f && f->is_safe_func)
+    {
+      tree expr = gimple_call_arg (stmt, 0);
+      tree newexpr[max_split];
+      if (!rewrite_expr (expr, newexpr))
+	{
+	  return false;
+	}
+
+      if (newexpr[1] == NULL)
+	{
+	  gimple_call_set_arg (stmt, 0, newexpr[0]);
+	  update_stmt (stmt);
+	  return false;
+	}
+      return false;
+    }
+
   /* Did not find the function or had not cloned it return saying don't
      change the function call. */
   if (!f || !f->newf)
@@ -4440,7 +6103,7 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi)
       && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
     SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
 
-  gsi_replace (gsi, new_stmt, false);
+  gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
 
   /* We need to defer cleaning EH info on the new statement to
      fixup-cfg.  We may not have dominator information at this point
@@ -4453,8 +6116,7 @@ ipa_struct_reorg::rewrite_call (gcall *stmt, gimple_stmt_iterator *gsi)
       add_stmt_to_eh_lp (new_stmt, lp_nr);
     }
 
-
-  return false;
+  return true;
 }
 
 /* Rewrite the conditional statement STMT.  Return TRUE if the
@@ -4466,48 +6128,58 @@ ipa_struct_reorg::rewrite_cond (gcond *stmt, gimple_stmt_iterator *gsi)
   tree_code rhs_code = gimple_cond_code (stmt);
 
   /* Handle only equals or not equals conditionals. */
-  if (rhs_code != EQ_EXPR
-      && rhs_code != NE_EXPR)
+  if ((current_mode != STRUCT_REORDER_FIELDS
+       && (rhs_code != EQ_EXPR && rhs_code != NE_EXPR))
+      || (current_mode == STRUCT_REORDER_FIELDS
+	  && TREE_CODE_CLASS (rhs_code) != tcc_comparison))
     return false;
-  tree rhs1 = gimple_cond_lhs (stmt);
-  tree rhs2 = gimple_cond_rhs (stmt);
+  tree lhs = gimple_cond_lhs (stmt);
+  tree rhs = gimple_cond_rhs (stmt);
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
-      fprintf (dump_file, "COND: Rewriting\n");
+      fprintf (dump_file, "\nCOND: Rewriting\n");
       print_gimple_stmt (dump_file, stmt, 0);
+      print_generic_expr (dump_file, lhs);
       fprintf (dump_file, "\n");
-      print_generic_expr (dump_file, rhs1);
-      fprintf (dump_file, "\n");
-      print_generic_expr (dump_file, rhs2);
+      print_generic_expr (dump_file, rhs);
       fprintf (dump_file, "\n");
     }
 
-  tree newrhs1[max_split];
-  tree newrhs2[max_split];
-  tree_code code = rhs_code == EQ_EXPR ? BIT_AND_EXPR : BIT_IOR_EXPR;
-  if (!rewrite_lhs_rhs (rhs1, rhs2, newrhs1, newrhs2))
+  tree newlhs[max_split] = {};
+  tree newrhs[max_split] = {};
+  if (!rewrite_lhs_rhs (lhs, rhs, newlhs, newrhs))
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
-        fprintf (dump_file, "\nDid nothing to statement.\n");
+	{
+	  fprintf (dump_file, "Did nothing to statement.\n");
+	}
       return false;
     }
 
-  tree newexpr = NULL_TREE;
-  for (unsigned i = 0; i < max_split && newrhs1[i]; i++)
-    {
-      tree expr = gimplify_build2 (gsi, rhs_code, boolean_type_node, newrhs1[i], newrhs2[i]);
-      if (!newexpr)
-	newexpr = expr;
-      else
-	newexpr = gimplify_build2 (gsi, code, boolean_type_node, newexpr, expr);
-     }
-
-  if (newexpr)
+  /*  Old rewrite：if (x_1 != 0B)
+		-> _1 = x.reorder.0_1 != 0B; if (_1 != 1)
+		   The logic is incorrect.
+      New rewrite：if (x_1 != 0B)
+		-> if (x.reorder.0_1 != 0B)；*/
+  for (unsigned i = 0; i < max_split && (newlhs[i] || newrhs[i]); i++)
     {
-      gimple_cond_set_lhs (stmt, newexpr);
-      gimple_cond_set_rhs (stmt, boolean_true_node);
+      if (newlhs[i])
+	{
+	  gimple_cond_set_lhs (stmt, newlhs[i]);
+	}
+      if (newrhs[i])
+	{
+	  gimple_cond_set_rhs (stmt, newrhs[i]);
+	}
       update_stmt (stmt);
+
+      if (dump_file && (dump_flags & TDF_DETAILS))
+      {
+	fprintf (dump_file, "replaced with:\n");
+	print_gimple_stmt (dump_file, stmt, 0);
+	fprintf (dump_file, "\n");
+      }
     }
   return false;
 }
@@ -4518,6 +6190,11 @@ ipa_struct_reorg::rewrite_cond (gcond *stmt, gimple_stmt_iterator *gsi)
 bool
 ipa_struct_reorg::rewrite_debug (gimple *stmt, gimple_stmt_iterator *)
 {
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      /* Delete debug gimple now.  */
+      return true;
+    }
   bool remove = false;
   if (gimple_debug_bind_p (stmt))
     {
@@ -4570,7 +6247,7 @@ ipa_struct_reorg::rewrite_phi (gphi *phi)
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
-      fprintf (dump_file, "\nrewriting PHI:");
+      fprintf (dump_file, "\nrewriting PHI:\n");
       print_gimple_stmt (dump_file, phi, 0);
     }
 
@@ -4581,7 +6258,17 @@ ipa_struct_reorg::rewrite_phi (gphi *phi)
     {
       tree newrhs[max_split];
       phi_arg_d rhs = *gimple_phi_arg (phi, i);
-      rewrite_expr (rhs.def, newrhs);
+
+      /* Handling the NULL phi Node.  */
+      bool r = rewrite_expr (rhs.def, newrhs);
+      if (!r && integer_zerop (rhs.def))
+	{
+	  for (unsigned i = 0; i < max_split && newlhs[i]; i++)
+	    {
+	      newrhs[i] = fold_convert (TREE_TYPE (newlhs[i]), rhs.def);
+	    }
+	}
+
       for (unsigned j = 0; j < max_split && newlhs[j]; j++)
 	{
 	  SET_PHI_ARG_DEF (newphi[j], i, newrhs[j]);
@@ -4592,7 +6279,7 @@ ipa_struct_reorg::rewrite_phi (gphi *phi)
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
-      fprintf (dump_file, "\ninto\n:");
+      fprintf (dump_file, "into:\n");
       for (unsigned i = 0; i < max_split && newlhs[i]; i++)
 	{
 	  print_gimple_stmt (dump_file, newphi[i], 0);
@@ -4666,12 +6353,58 @@ ipa_struct_reorg::rewrite_functions (void)
   /* Create new types, if we did not create any new types,
      then don't rewrite any accesses. */
   if (!create_new_types ())
-    return 0;
+    {
+      if (current_mode == STRUCT_REORDER_FIELDS)
+	{
+	  for (unsigned i = 0; i < functions.length (); i++)
+	    {
+	      srfunction *f = functions[i];
+	      cgraph_node *node = f->node;
+	      push_cfun (DECL_STRUCT_FUNCTION (node->decl));
+	      if (dump_file && (dump_flags & TDF_DETAILS))
+		{
+		  fprintf (dump_file, "\nNo rewrite:\n");
+		  dump_function_to_file (current_function_decl, dump_file,
+			dump_flags | TDF_VOPS);
+		}
+	      pop_cfun ();
+	    }
+	}
+      return 0;
+    }
+
+  if (current_mode == STRUCT_REORDER_FIELDS && dump_file)
+    {
+      fprintf (dump_file, "=========== all created newtypes: ===========\n\n");
+      dump_newtypes (dump_file);
+    }
 
   if (functions.length ())
     {
       retval = TODO_remove_functions;
       create_new_functions ();
+      if (current_mode == STRUCT_REORDER_FIELDS)
+	{
+	  prune_escaped_types ();
+	}
+    }
+
+  if (current_mode == STRUCT_REORDER_FIELDS)
+    {
+      for (unsigned i = 0; i < functions.length (); i++)
+	{
+	  srfunction *f = functions[i];
+	  cgraph_node *node = f->node;
+	  push_cfun (DECL_STRUCT_FUNCTION (node->decl));
+	  if (dump_file && (dump_flags & TDF_DETAILS))
+	    {
+	      fprintf (dump_file, "==== Before create decls: %dth_%s ====\n\n",
+		       i, f->node->name ());
+	      dump_function_to_file (current_function_decl, dump_file,
+				     dump_flags | TDF_VOPS);
+	    }
+	  pop_cfun ();
+	}
     }
 
   create_new_decls ();
@@ -4694,8 +6427,12 @@ ipa_struct_reorg::rewrite_functions (void)
 
       if (dump_file && (dump_flags & TDF_DETAILS))
 	{
-	  fprintf (dump_file, "\nBefore rewrite:\n");
-          dump_function_to_file (current_function_decl, dump_file, dump_flags | TDF_VOPS);
+	  fprintf (dump_file, "\nBefore rewrite: %dth_%s\n",
+		   i, f->node->name ());
+	  dump_function_to_file (current_function_decl, dump_file,
+				 dump_flags | TDF_VOPS);
+	  fprintf (dump_file, "\n======== Start to rewrite: %dth_%s ========\n",
+		   i, f->node->name ());
 	}
       FOR_EACH_BB_FN (bb, cfun)
 	{
@@ -4763,10 +6500,12 @@ ipa_struct_reorg::rewrite_functions (void)
 
       free_dominance_info (CDI_DOMINATORS);
 
-      if (dump_file && (dump_flags & TDF_DETAILS))
+      if (dump_file)
 	{
-	  fprintf (dump_file, "\nAfter rewrite:\n");
-          dump_function_to_file (current_function_decl, dump_file, dump_flags | TDF_VOPS);
+	  fprintf (dump_file, "\nAfter rewrite: %dth_%s\n",
+		   i, f->node->name ());
+	  dump_function_to_file (current_function_decl, dump_file,
+				 dump_flags | TDF_VOPS);
 	}
 
       pop_cfun ();
@@ -4820,9 +6559,9 @@ ipa_struct_reorg::execute (enum srmode mode)
 {
   unsigned int ret = 0;
 
-  if (mode == NORMAL)
+  if (mode == NORMAL || mode == STRUCT_REORDER_FIELDS)
     {
-      current_mode = NORMAL;
+      current_mode = mode;
       /* If there is a top-level inline-asm,
 	 the pass immediately returns.  */
       if (symtab->first_asm_symbol ())
@@ -4831,7 +6570,10 @@ ipa_struct_reorg::execute (enum srmode mode)
 	}
       record_accesses ();
       prune_escaped_types ();
-      analyze_types ();
+      if (current_mode == NORMAL)
+	{
+	  analyze_types ();
+	}
 
       ret = rewrite_functions ();
     }
@@ -4903,6 +6645,47 @@ pass_ipa_struct_reorg::gate (function *)
 	  && lang_c_p ());
 }
 
+const pass_data pass_data_ipa_reorder_fields =
+{
+  SIMPLE_IPA_PASS, // type
+  "reorder_fields", // name
+  OPTGROUP_NONE, // optinfo_flags
+  TV_IPA_REORDER_FIELDS, // tv_id
+  0, // properties_required
+  0, // properties_provided
+  0, // properties_destroyed
+  0, // todo_flags_start
+  0, // todo_flags_finish
+};
+
+class pass_ipa_reorder_fields : public simple_ipa_opt_pass
+{
+public:
+  pass_ipa_reorder_fields (gcc::context *ctxt)
+    : simple_ipa_opt_pass (pass_data_ipa_reorder_fields, ctxt)
+  {}
+
+  /* opt_pass methods: */
+  virtual bool gate (function *);
+  virtual unsigned int execute (function *)
+  {
+    unsigned int ret = 0;
+    ret = ipa_struct_reorg ().execute (STRUCT_REORDER_FIELDS);
+    return ret;
+  }
+
+}; // class pass_ipa_reorder_fields
+
+bool
+pass_ipa_reorder_fields::gate (function *)
+{
+  return (optimize >= 3
+	  && flag_ipa_reorder_fields
+	  /* Don't bother doing anything if the program has errors.  */
+	  && !seen_error ()
+	  && flag_lto_partition == LTO_PARTITION_ONE);
+}
+
 } // anon namespace
 
 simple_ipa_opt_pass *
@@ -4910,3 +6693,9 @@ make_pass_ipa_struct_reorg (gcc::context *ctxt)
 {
   return new pass_ipa_struct_reorg (ctxt);
 }
+
+simple_ipa_opt_pass *
+make_pass_ipa_reorder_fields (gcc::context *ctxt)
+{
+  return new pass_ipa_reorder_fields (ctxt);
+}
diff --git a/gcc/ipa-struct-reorg/ipa-struct-reorg.h b/gcc/ipa-struct-reorg/ipa-struct-reorg.h
index d8fe399bdf8..8fb6ce9c448 100644
--- a/gcc/ipa-struct-reorg/ipa-struct-reorg.h
+++ b/gcc/ipa-struct-reorg/ipa-struct-reorg.h
@@ -68,12 +68,14 @@ struct srfunction
   auto_vec<srdecl*> args;
   auto_vec<srdecl*> globals;
   auto_vec_del<srdecl> decls;
-  srdecl *record_decl (srtype *, tree, int arg);
+  srdecl *record_decl (srtype *, tree, int arg, tree orig_type = NULL);
 
   srfunction *old;
   cgraph_node *newnode;
   srfunction *newf;
 
+  bool is_safe_func;
+
   // Constructors
   srfunction (cgraph_node *n);
 
@@ -183,6 +185,11 @@ struct srfield
   void create_new_fields (tree newtype[max_split],
 			  tree newfields[max_split],
 			  tree newlast[max_split]);
+  void reorder_fields (tree newfields[max_split], tree newlast[max_split],
+		       tree &field);
+  void create_new_reorder_fields (tree newtype[max_split],
+				  tree newfields[max_split],
+				  tree newlast[max_split]);
 };
 
 struct sraccess
@@ -219,8 +226,11 @@ struct srdecl
 
   tree newdecl[max_split];
 
+  /* Auxiliary record complete original type information of the void* type.  */
+  tree orig_type;
+
   // Constructors
-  srdecl (srtype *type, tree decl, int argumentnum = -1);
+  srdecl (srtype *type, tree decl, int argumentnum = -1, tree orgtype = NULL);
 
   // Methods
   void dump (FILE *file);
diff --git a/gcc/passes.def b/gcc/passes.def
index fa744e25038..63303ab65bb 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -173,6 +173,7 @@ along with GCC; see the file COPYING3.  If not see
   INSERT_PASSES_AFTER (all_late_ipa_passes)
   NEXT_PASS (pass_materialize_all_clones);
   NEXT_PASS (pass_ipa_pta);
+  NEXT_PASS (pass_ipa_reorder_fields);
   /* FIXME: this should a normal IP pass */
   NEXT_PASS (pass_ipa_struct_reorg);
   NEXT_PASS (pass_omp_simd_clone);
diff --git a/gcc/testsuite/gcc.dg/struct/rf_DTE_struct_instance_field.c b/gcc/testsuite/gcc.dg/struct/rf_DTE_struct_instance_field.c
new file mode 100644
index 00000000000..b95be2dabc2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_DTE_struct_instance_field.c
@@ -0,0 +1,75 @@
+// escape_instance_field, "Type escapes via a field of instance".
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+typedef struct network
+{
+  arc_p arcs;
+  arc_p sorted_arcs;
+  int x;
+  node_p nodes;
+  node_p stop_nodes;
+  node_t node;
+} network_t;
+
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+  network_t* net_add;
+  node_t node;
+};
+
+
+const int MAX = 100;
+
+/* let it escape_array, "Type is used in an array [not handled yet]".  */
+network_t* net[2];
+
+int
+main ()
+{
+  net[0] = (network_t*) calloc (1, sizeof(network_t));
+  net[0]->arcs = (arc_p) calloc (MAX, sizeof (arc_t));
+
+  /* Contains an escape type and has structure instance field.  */
+  net[0]->arcs->node = net[0]->node;
+
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "No structures to transform." "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_DTE_verify.c b/gcc/testsuite/gcc.dg/struct/rf_DTE_verify.c
new file mode 100644
index 00000000000..3d243313ba9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_DTE_verify.c
@@ -0,0 +1,94 @@
+// Verify in escape_dependent_type_escapes,
+// the multi-layer dereference is rewriting correctly,and the memory access
+// is correct.
+
+// release
+// escape_dependent_type_escapes,
+// "Type uses a type which escapes or is used by a type which escapes"
+// avoid escape_cast_another_ptr, "Type escapes a cast to a different pointer"
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+typedef struct network
+{    
+  arc_p arcs;
+  arc_p sorted_arcs;
+  int x;
+  node_p nodes;
+  node_p stop_nodes;
+} network_t;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+  network_t* net_add;
+};
+
+
+const int MAX = 100;
+
+/* let it escape_array, "Type is used in an array [not handled yet]".  */
+network_t* net[2];
+arc_p stop_arcs = NULL;
+
+int
+main ()
+{
+  net[0] = (network_t*) calloc (1, sizeof(network_t));
+  net[0]->arcs = (arc_p) calloc (MAX, sizeof (arc_t));
+  stop_arcs = (arc_p) calloc (MAX, sizeof (arc_t));
+
+  net[0]->arcs->id = 100;
+
+  for (unsigned i = 0; i < 3; i++)
+    {        
+      net[0]->arcs->id = net[0]->arcs->id + 2;
+      stop_arcs->cost = net[0]->arcs->id / 2;
+      stop_arcs->net_add = net[0];
+      printf("stop_arcs->cost = %ld\n", stop_arcs->cost);
+      net[0]->arcs++;
+      stop_arcs++;
+    }
+
+  if( net[1] != 0 && stop_arcs != 0)
+    {
+      return -1;
+    }
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_create_fields_bug.c b/gcc/testsuite/gcc.dg/struct/rf_create_fields_bug.c
new file mode 100644
index 00000000000..886706ae913
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_create_fields_bug.c
@@ -0,0 +1,82 @@
+// bugfix: 
+// Common members do not need to reconstruct. 
+// Otherwise, eg:int* -> int** and void* -> void**.
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t* cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t** org_cost;
+};
+
+struct a
+{
+  int t;
+  int t1;
+};
+
+__attribute__((noinline)) int
+f(int i, int j)
+{
+  struct a *t = NULL;
+  struct a t1 = {i, j};
+  t = &t1;
+  auto int g(void) __attribute__((noinline));
+  int g(void)
+    {
+      return t->t + t->t1;
+    }
+  return g();
+}
+
+arc_t **ap = NULL;
+const int MAX = 100;
+
+int
+main()
+{
+  if (f(1, 2) != 3)
+    {
+      abort ();
+    }
+  ap = (arc_t**) malloc(MAX * sizeof(arc_t*));
+  (*ap)[0].id = 300;
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_create_new_func_bug.c b/gcc/testsuite/gcc.dg/struct/rf_create_new_func_bug.c
new file mode 100644
index 00000000000..f3785f392e3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_create_new_func_bug.c
@@ -0,0 +1,56 @@
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MallocOrDie(x)     sre_malloc((x))
+
+struct gki_elem {
+  char            *key;
+  int              idx;
+  struct gki_elem *nxt;
+};
+
+typedef struct {
+  struct gki_elem **table;
+
+  int primelevel;
+  int nhash;
+  int nkeys;
+} GKI;
+
+void
+Die(char *format, ...)
+{
+  exit(1);
+}
+
+void *
+sre_malloc(size_t size)
+{
+  void *ptr;
+
+  if ((ptr = malloc (size)) == NULL)
+    {
+      Die("malloc of %ld bytes failed", size);
+    }
+  return ptr;
+}
+
+
+__attribute__((noinline)) int
+GKIStoreKey(GKI *hash, char *key)
+{
+  hash->table[0] = MallocOrDie(sizeof(struct gki_elem));
+}
+
+int
+main ()
+{
+  GKI *hash;
+  char *key;
+  GKIStoreKey(hash, key);
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_ele_minus_verify.c b/gcc/testsuite/gcc.dg/struct/rf_ele_minus_verify.c
new file mode 100644
index 00000000000..1415d759ad6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_ele_minus_verify.c
@@ -0,0 +1,60 @@
+// verify newarc[cmp-1].flow
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+const int MAX = 100;
+arc_p ap = NULL;
+
+int
+main ()
+{
+  ap = (arc_p) calloc(MAX, sizeof(arc_t));
+  printf("%d\n", ap[0].id);
+  for (int i = 1; i < MAX; i++)
+    {
+      ap[i-1].id = 500;
+    }
+  printf("%d\n", ap[0].id);
+  return 0; 
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_escape_by_base.c b/gcc/testsuite/gcc.dg/struct/rf_escape_by_base.c
new file mode 100644
index 00000000000..003da0b57bf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_escape_by_base.c
@@ -0,0 +1,83 @@
+// release type is used by a type which escapes.
+// avoid escape_cast_another_ptr, "Type escapes a cast to a different pointer"
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+typedef struct network
+{    
+  arc_p arcs;
+  arc_p sorted_arcs;
+  int x;
+  node_p nodes;
+  node_p stop_nodes;
+} network_t;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+const int MAX = 100;
+network_t* net = NULL;
+arc_p stop_arcs = NULL;
+int cnt = 0;
+
+int
+main ()
+{
+  net = (network_t*) calloc (1, 20);
+  net->arcs = (arc_p) calloc (MAX, sizeof (arc_t));
+  stop_arcs = (arc_p) calloc (MAX, sizeof (arc_t));
+  if(!(net->arcs))
+    {
+      return -1;
+    }
+
+  for( int i = 0; i < MAX; i++, net->arcs = stop_arcs)
+    {
+      cnt++;
+    }
+
+  net = (network_t*) calloc (1, 20); 
+  if( !(net->arcs) )
+    {
+      return -1;
+    }
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_int_cast_ptr.c b/gcc/testsuite/gcc.dg/struct/rf_int_cast_ptr.c
new file mode 100644
index 00000000000..10dcf098c3c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_int_cast_ptr.c
@@ -0,0 +1,72 @@
+// release escape_cast_another_ptr, "Type escapes a cast to a different pointer"
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+typedef int cmp_t(const void *, const void *);
+
+__attribute__((noinline)) void
+spec_qsort(void *a, cmp_t *cmp)
+{
+  char *pb = NULL;
+  while (cmp(pb, a))
+    {
+      pb += 1;
+    }
+}
+
+static int arc_compare( arc_t **a1, int a2 )
+{
+  if( (*a1)->id < a2 )
+    {
+      return -1;
+    }
+  return 1;
+}
+
+int
+main()
+{
+  spec_qsort(NULL, (int (*)(const void *, const void *))arc_compare);
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_mem_ref_offset.c b/gcc/testsuite/gcc.dg/struct/rf_mem_ref_offset.c
new file mode 100644
index 00000000000..8d1a9a114c1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_mem_ref_offset.c
@@ -0,0 +1,58 @@
+/* Supports the MEM_REF offset.
+   _1 = MEM[(struct arc *)ap_4 + 72B].flow;
+   Old rewrite：_1 = ap.reorder.0_8->flow;
+   New rewrite：_1 = MEM[(struct arc.reorder.0 *)ap.reorder.0_8 + 64B].flow.  */
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+int
+main ()
+{
+  const int MAX = 100;
+  /* A similar scenario can be reproduced only by using local variables.  */
+  arc_p ap = NULL;
+  ap = (arc_p) calloc(MAX, sizeof(arc_t));
+  printf("%d\n", ap[1].flow);
+  return 0; 
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_pass_conflict.c b/gcc/testsuite/gcc.dg/struct/rf_pass_conflict.c
new file mode 100644
index 00000000000..8d687c58b30
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_pass_conflict.c
@@ -0,0 +1,110 @@
+// 针对 
+/*
+Compile options: /home/hxq/hcc_gcc9.3.0_org_debug/bin/gcc -O3 -g 
+-flto -flto-partition=one -fipa-reorder-fields -fipa-struct-reorg 
+-v -save-temps -fdump-ipa-all-details test.c -o  test
+
+in COMPLETE_STRUCT_RELAYOUT pass：
+N type: struct node.reorder.0 new = "Type escapes a cast to a different pointer"
+copy$head_26 = test_arc.reorder.0_49->head;
+
+type : struct arc.reorder.0(1599) { 
+fields = {
+field (5382) {type = cost_t}
+field (5383) {type = struct node.reorder.0 *} // but node has escaped.
+field (5384) {type = struct node.reorder.0 *}
+field (5386) {type = struct arc.reorder.0 *}
+field (5387) {type = struct arc.reorder.0 *}
+field (5388) {type = flow_t}
+field (5389) {type = cost_t}
+field (5381) {type = int}
+field (5385) {type = short int}
+}
+
+// The types of the two types are inconsistent after the rewriting.
+newarc_2(D)->tail = tail_1(D);
+vs
+struct_reorder.0_61(D)->tail = tail_1(D); 
+*/
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+typedef struct network
+{    
+  arc_p arcs;
+  arc_p sorted_arcs;
+  int x;
+  node_p nodes;
+  node_p stop_nodes;
+} network_t;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+__attribute__((noinline)) void
+replace_weaker_arc( arc_t *newarc, node_t *tail, node_t *head)
+{
+    printf("test");
+}
+
+__attribute__((noinline)) int64_t
+switch_arcs(arc_t** deleted_arcs, arc_t* arcnew)
+{
+  int64_t count = 0;
+  arc_t *test_arc, copy;
+
+  if (!test_arc->ident)
+    {
+      copy = *test_arc;
+      count++;
+      *test_arc = arcnew[0];
+      replace_weaker_arc(arcnew, copy.tail, copy.head);
+    }
+  return count;
+}
+
+
+int
+main ()
+{
+  switch_arcs(NULL, NULL);
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_ptr2void_lto.c b/gcc/testsuite/gcc.dg/struct/rf_ptr2void_lto.c
new file mode 100644
index 00000000000..190b9418275
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_ptr2void_lto.c
@@ -0,0 +1,87 @@
+// escape_cast_void, "Type escapes a cast to/from void*"
+// stop_393 = net.stop_nodes; void *stop;
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+typedef struct network
+{    
+  arc_p arcs, sorted_arcs;
+  int x;
+  node_p nodes, stop_nodes;
+} network_t;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+const int MAX = 100;
+network_t* net = NULL;
+int cnt = 0;
+
+__attribute__((noinline)) int
+primal_feasible (network_t *net)
+{
+  void* stop;
+  node_t *node;
+
+  node = net->nodes;
+  stop = (void *)net->stop_nodes;
+  for( node++; node < (node_t *)stop; node++ )
+    {
+      printf( "PRIMAL NETWORK SIMPLEX: " );
+    }
+  return 0;
+}
+
+int
+main ()
+{
+  net = (network_t*) calloc (1, 20);
+  net->nodes = calloc (MAX, sizeof (node_t));
+  net->stop_nodes = calloc (MAX, sizeof (node_t));
+  cnt = primal_feasible( net ); 
+    
+  net = (network_t*) calloc (1, 20); 
+  if( !(net->arcs) )
+    {
+      return -1;
+    }
+  return cnt;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_ptr_diff.c b/gcc/testsuite/gcc.dg/struct/rf_ptr_diff.c
new file mode 100644
index 00000000000..3a3c10b70ba
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_ptr_diff.c
@@ -0,0 +1,71 @@
+// support POINTER_DIFF_EXPR & NOP_EXPR to avoid 
+// escape_unhandled_rewrite, "Type escapes via a unhandled rewrite stmt"
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+typedef struct network
+{    
+  arc_p arcs;
+  arc_p sorted_arcs;
+  int x;
+  node_p nodes;
+  node_p stop_nodes;
+} network_t;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+int
+main ()
+{
+  arc_t *old_arcs;
+  node_t *node;
+  node_t *stop;
+  size_t off;
+  network_t* net;
+
+  for( ; node->number < stop->number; node++ )
+    {
+      off = node->basic_arc - old_arcs;
+      node->basic_arc = (arc_t *)(net->arcs + off);
+    }
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 3" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_ptr_negate_expr.c b/gcc/testsuite/gcc.dg/struct/rf_ptr_negate_expr.c
new file mode 100644
index 00000000000..7b7d110df4c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_ptr_negate_expr.c
@@ -0,0 +1,55 @@
+// support NEGATE_EXPR rewriting
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+int
+main ()
+{
+  int64_t susp = 0;
+  const int MAX = 100;
+  arc_p ap = (arc_p) calloc(MAX, sizeof(arc_t));
+  ap -= susp;
+  printf("%d\n", ap[1].flow);
+  return 0; 
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_ptr_ptr.c b/gcc/testsuite/gcc.dg/struct/rf_ptr_ptr.c
new file mode 100644
index 00000000000..01a33f66962
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_ptr_ptr.c
@@ -0,0 +1,55 @@
+// release escape_ptr_ptr, "Type is used in a pointer to a pointer [not handled yet]";
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+const int MAX = 100;
+arc_t **ap = NULL;
+
+int
+main ()
+{
+  ap = (arc_t**) malloc(MAX * sizeof(arc_t*));
+  (*ap)[0].id = 300;
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_ptr_ptr_ptr.c b/gcc/testsuite/gcc.dg/struct/rf_ptr_ptr_ptr.c
new file mode 100644
index 00000000000..a38556533f1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_ptr_ptr_ptr.c
@@ -0,0 +1,58 @@
+// release escape_ptr_ptr, "Type is used in a pointer to a pointer [not handled yet]"
+
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+const int MAX = 100;
+arc_p **ap;
+
+
+int
+main ()
+{
+  ap = (arc_p**) calloc(MAX, sizeof(arc_p*));
+  (**ap)[0].id = 500;
+
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_rescusive_type.c b/gcc/testsuite/gcc.dg/struct/rf_rescusive_type.c
new file mode 100644
index 00000000000..5c17ee528c8
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_rescusive_type.c
@@ -0,0 +1,57 @@
+// release escape_rescusive_type, "Recusive type"
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+const int MAX = 100;
+arc_p ap = NULL;
+
+int
+main ()
+{
+  ap = (arc_p) calloc (MAX, sizeof (arc_t));
+  ap[0].id = 100;
+  ap[0].head = (node_p) calloc (MAX, sizeof (node_t));
+    
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_rewrite_assign_more_cmp.c b/gcc/testsuite/gcc.dg/struct/rf_rewrite_assign_more_cmp.c
new file mode 100644
index 00000000000..710517ee9e2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_rewrite_assign_more_cmp.c
@@ -0,0 +1,65 @@
+// support more gimple assign rhs code
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+__attribute__((noinline)) int
+compare(arc_p p1, arc_p p2)
+{
+  return p1 < p2;
+}
+
+int n = 0;
+int m = 0;
+
+int
+main ()
+{
+  scanf ("%d %d", &n, &m);
+  arc_p p = calloc (10, sizeof (struct arc));
+  if (compare (&p[n], &p[m]))
+    {
+      printf ("ss!");
+    }
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_rewrite_cond_bug.c b/gcc/testsuite/gcc.dg/struct/rf_rewrite_cond_bug.c
new file mode 100644
index 00000000000..6ed0a5d2d6b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_rewrite_cond_bug.c
@@ -0,0 +1,72 @@
+// rewrite_cond bugfix；
+/*
+if (iterator_600 != 0B)
+old rewrite: _1369 = iterator.reorder.0_1249 != 0B; if (_1369 != 1)
+new rewrite: if (iterator.reorder.0_1249 != 0B)
+*/
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+typedef struct list_elem
+{
+  arc_t* arc;
+  struct list_elem* next;
+}list_elem;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+int i = 0;
+
+int
+main ()
+{
+  register list_elem *first_list_elem;
+  register list_elem* iterator;
+  iterator = first_list_elem->next;
+  while (iterator)
+    {
+      iterator = iterator->next;
+      i++;
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 3" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_rewrite_cond_more_cmp.c b/gcc/testsuite/gcc.dg/struct/rf_rewrite_cond_more_cmp.c
new file mode 100644
index 00000000000..5a2dd964fc2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_rewrite_cond_more_cmp.c
@@ -0,0 +1,58 @@
+// support if (_150 >= _154)
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+int
+main()
+{
+  arc_p **ap = (arc_p**) malloc(1 * sizeof(arc_p*));
+  arc_p **arcs_pointer_sorted = (arc_p**) malloc(1 * sizeof(arc_p*));
+  arcs_pointer_sorted[0] = (arc_p*) calloc (1, sizeof(arc_p));
+
+  if (arcs_pointer_sorted >= ap)
+    {
+      return -1;
+    }
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_rewrite_phi_bug.c b/gcc/testsuite/gcc.dg/struct/rf_rewrite_phi_bug.c
new file mode 100644
index 00000000000..faa90b42ddc
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_rewrite_phi_bug.c
@@ -0,0 +1,81 @@
+/* 
+Exclude the rewriting error caused by 
+first_list_elem = (list_elem *)NULL;
+rewriting PHI:first_list_elem_700 = PHI <0B(144), 0B(146)>
+into:
+first_list_elem.reorder.0_55 = PHI <(144), (146)>
+*/
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+typedef struct list_elem
+{
+  arc_t* arc;
+  struct list_elem* next;
+}list_elem;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout, firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail, head;
+  short ident;
+  arc_p nextout, nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+const int MAX = 100;
+
+list_elem* new_list_elem;
+list_elem* first_list_elem;
+
+int
+main ()
+{
+  int i = 0;
+  list_elem *first_list_elem;
+  list_elem *new_list_elem;
+  arc_t *arcout;
+  for( ; i < MAX && arcout->ident == -1; i++);
+
+  first_list_elem = (list_elem *)NULL;
+  for( ; i < MAX; i++)
+    {
+      new_list_elem = (list_elem*) calloc(1, sizeof(list_elem));
+      new_list_elem->next = first_list_elem;
+      first_list_elem = new_list_elem;
+    }
+  if (first_list_elem != 0)
+    {
+      return -1;
+    }
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 3" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_shwi.c b/gcc/testsuite/gcc.dg/struct/rf_shwi.c
new file mode 100644
index 00000000000..2bb326ff200
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_shwi.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+struct foo {int dx; long dy; int dz; };
+struct goo {long offset; struct foo* pfoo; };
+
+void* func (long); 
+
+__attribute__((used)) static void
+test(struct goo* g)
+{
+  void* pvoid;
+  struct foo* f;
+
+  for (f = g->pfoo; f->dx; f++)
+    {
+      if (f->dy)
+	break;
+    }
+  f--;
+
+  pvoid = func(f->dz + g->offset);
+  return;
+}
diff --git a/gcc/testsuite/gcc.dg/struct/rf_visible_func.c b/gcc/testsuite/gcc.dg/struct/rf_visible_func.c
new file mode 100644
index 00000000000..8f2da99ccdf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_visible_func.c
@@ -0,0 +1,92 @@
+// release escape_visible_function, "Type escapes via expternally visible function call"
+// compile options: gcc -O3 -fno-inline -fwhole-program 
+// -flto-partition=one -fipa-struct-reorg arc_compare.c -fdump-ipa-all -S -v
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node node_t;
+typedef struct node *node_p;
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct node
+{
+  int64_t potential;
+  int orientation;
+  node_p child;
+  node_p pred;
+  node_p sibling;
+  node_p sibling_prev;
+  arc_p basic_arc;
+  arc_p firstout;
+  arc_p firstin;
+  arc_p arc_tmp;
+  int64_t flow;
+  int64_t depth;
+  int number;
+  int time;
+};
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  node_p tail;
+  node_p head;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+__attribute__((noinline)) static int
+arc_compare( arc_t **a1, arc_t **a2 )
+{
+  if( (*a1)->flow > (*a2)->flow )
+    {
+      return 1;
+    }
+  if( (*a1)->flow < (*a2)->flow )
+    {
+      return -1;
+    }
+  if( (*a1)->id < (*a2)->id )
+    {
+      return -1;
+    }
+
+    return 1;
+}
+
+__attribute__((noinline)) void
+spec_qsort(void *array, int nitems, int size,
+	   int (*cmp)(const void*,const void*))
+{
+  for (int i = 0; i < nitems - 1; i++)
+  {
+    if (cmp (array , array))
+      {
+        printf ("CMP 1\n");
+      }
+    else
+      {
+        printf ("CMP 2\n");
+      }
+  }
+}
+
+typedef int cmp_t(const void *, const void *);
+
+int
+main ()
+{
+  void *p = calloc (100, sizeof (arc_t **));
+  spec_qsort (p, 100, 0, (int (*)(const void *, const void *))arc_compare);
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/rf_void_ptr_param_func.c b/gcc/testsuite/gcc.dg/struct/rf_void_ptr_param_func.c
new file mode 100644
index 00000000000..723142c5975
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct/rf_void_ptr_param_func.c
@@ -0,0 +1,54 @@
+// Add a safe func mechanism.
+// avoid escape_unkown_field, "Type escapes via an unkown field accessed"
+// avoid escape_cast_void, "Type escapes a cast to/from void*" eg: GIMPLE_NOP
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct arc arc_t;
+typedef struct arc *arc_p;
+
+struct arc
+{
+  int id;
+  int64_t cost;
+  short ident;
+  arc_p nextout;
+  arc_p nextin;
+  int64_t flow;
+  int64_t org_cost;
+};
+
+void
+__attribute__((noinline)) spec_qsort (void *a, size_t es) 
+{
+  char *pa;
+  char *pb;
+  int cmp_result;
+
+  while ((*(arc_t **)a)->id < *((int *)a))
+    { 
+      if (cmp_result == 0)
+	{
+	  spec_qsort (a, es);
+	  pa = (char *)a - es;
+	  a += es;
+	  *(long *)pb = *(long *)pa;
+	}
+      else
+	{
+	  a -= pa - pb;
+	}
+    }  
+}
+
+int
+main()
+{
+  arc_p **arcs_pointer_sorted;
+  spec_qsort (arcs_pointer_sorted[0], sizeof (arc_p));
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "reorder_fields" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/struct/struct-reorg.exp b/gcc/testsuite/gcc.dg/struct/struct-reorg.exp
index 1bd0e18ea2e..c8db4675f11 100644
--- a/gcc/testsuite/gcc.dg/struct/struct-reorg.exp
+++ b/gcc/testsuite/gcc.dg/struct/struct-reorg.exp
@@ -27,8 +27,25 @@ set STRUCT_REORG_TORTURE_OPTIONS [list \
 
 set-torture-options $STRUCT_REORG_TORTURE_OPTIONS {{}}
 
-gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.c]] \
+# -fipa-struct-reorg
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/wo_prof_*.c]] \
+ 	"" "-fipa-struct-reorg -fdump-ipa-all -flto-partition=one -fwhole-program"
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/w_ratio_*.c]] \
 	"" "-fipa-struct-reorg -fdump-ipa-all -flto-partition=one -fwhole-program"
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/w_prof_*.c]] \
+	"" "-fipa-struct-reorg -fdump-ipa-all -flto-partition=one -fwhole-program"
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/struct_reorg*.c]] \
+	"" "-fipa-struct-reorg -fdump-ipa-all -flto-partition=one -fwhole-program"
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/sr_*.c]] \
+	"" "-fipa-struct-reorg -fdump-ipa-all -flto-partition=one -fwhole-program"
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/csr_*.c]] \
+	"" "-fipa-struct-reorg -fdump-ipa-all -flto-partition=one -fwhole-program"
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/complete_struct_relayout.c]] \
+	"" "-fipa-struct-reorg -fdump-ipa-all -flto-partition=one -fwhole-program"
+
+# -fipa-reorder-fields
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/rf*.c]] \
+	"" "-fipa-reorder-fields -fdump-ipa-all -flto-partition=one -fwhole-program"
 
 # All done.
 torture-finish
diff --git a/gcc/timevar.def b/gcc/timevar.def
index d6a05562c2f..ee25eccbb67 100644
--- a/gcc/timevar.def
+++ b/gcc/timevar.def
@@ -80,6 +80,7 @@ DEFTIMEVAR (TV_IPA_CONSTANT_PROP     , "ipa cp")
 DEFTIMEVAR (TV_IPA_INLINING          , "ipa inlining heuristics")
 DEFTIMEVAR (TV_IPA_FNSPLIT           , "ipa function splitting")
 DEFTIMEVAR (TV_IPA_COMDATS	     , "ipa comdats")
+DEFTIMEVAR (TV_IPA_REORDER_FIELDS    , "ipa struct reorder fields optimization")
 DEFTIMEVAR (TV_IPA_STRUCT_REORG	     , "ipa struct reorg optimization")
 DEFTIMEVAR (TV_IPA_OPT		     , "ipa various optimizations")
 DEFTIMEVAR (TV_IPA_LTO_DECOMPRESS    , "lto stream decompression")
diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
index d8355754ffa..eb32c5d441b 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -509,6 +509,7 @@ extern ipa_opt_pass_d *make_pass_ipa_odr (gcc::context *ctxt);
 extern ipa_opt_pass_d *make_pass_ipa_reference (gcc::context *ctxt);
 extern ipa_opt_pass_d *make_pass_ipa_hsa (gcc::context *ctxt);
 extern ipa_opt_pass_d *make_pass_ipa_pure_const (gcc::context *ctxt);
+extern simple_ipa_opt_pass *make_pass_ipa_reorder_fields (gcc::context *ctxt);
 extern simple_ipa_opt_pass *make_pass_ipa_struct_reorg (gcc::context *ctxt);
 extern simple_ipa_opt_pass *make_pass_ipa_pta (gcc::context *ctxt);
 extern simple_ipa_opt_pass *make_pass_ipa_tm (gcc::context *ctxt);
-- 
2.21.0.windows.1