OSDN Git Service

(root) / pf3gnuchains / gcc-fork.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Daily bump.
[pf3gnuchains/gcc-fork.git] / gcc / tree-mudflap.c
diff --git a/gcc/tree-mudflap.c b/gcc/tree-mudflap.c
index 4d80c19..e4f6ec0 100644 (file)
--- a/gcc/tree-mudflap.c
+++ b/gcc/tree-mudflap.c
@@ -1,5 +1,6 @@
 /* Mudflap: narrow-pointer bounds-checking by tree rewriting.
 /* Mudflap: narrow-pointer bounds-checking by tree rewriting.
-   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012
+   Free Software Foundation, Inc.
    Contributed by Frank Ch. Eigler <fche@redhat.com>
    and Graydon Hoare <graydon@redhat.com>
 
    Contributed by Frank Ch. Eigler <fche@redhat.com>
    and Graydon Hoare <graydon@redhat.com>
 
@@ -7,7 +8,7 @@ This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
@@ -16,35 +17,33 @@ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
 
 
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
-#include "hard-reg-set.h"
-#include "rtl.h"
 #include "tree.h"
 #include "tm_p.h"
 #include "basic-block.h"
 #include "flags.h"
 #include "function.h"
 #include "tree-inline.h"
 #include "tree.h"
 #include "tm_p.h"
 #include "basic-block.h"
 #include "flags.h"
 #include "function.h"
 #include "tree-inline.h"
-#include "tree-gimple.h"
+#include "gimple.h"
+#include "tree-iterator.h"
 #include "tree-flow.h"
 #include "tree-mudflap.h"
 #include "tree-dump.h"
 #include "tree-pass.h"
 #include "hashtab.h"
 #include "diagnostic.h"
 #include "tree-flow.h"
 #include "tree-mudflap.h"
 #include "tree-dump.h"
 #include "tree-pass.h"
 #include "hashtab.h"
 #include "diagnostic.h"
-#include <demangle.h>
+#include "demangle.h"
 #include "langhooks.h"
 #include "ggc.h"
 #include "cgraph.h"
 #include "langhooks.h"
 #include "ggc.h"
 #include "cgraph.h"
-#include "toplev.h"
+#include "gimple.h"
 
 /* Internal function decls */
 
 
 /* Internal function decls */
 
@@ -60,15 +59,23 @@ static tree mf_file_function_line_tree (location_t);
 /* Indirection-related instrumentation.  */
 static void mf_decl_cache_locals (void);
 static void mf_decl_clear_locals (void);
 /* Indirection-related instrumentation.  */
 static void mf_decl_cache_locals (void);
 static void mf_decl_clear_locals (void);
-static void mf_xform_derefs (void);
+static void mf_xform_statements (void);
 static unsigned int execute_mudflap_function_ops (void);
 
 /* Addressable variables instrumentation.  */
 static unsigned int execute_mudflap_function_ops (void);
 
 /* Addressable variables instrumentation.  */
-static void mf_xform_decls (tree, tree);
-static tree mx_xfn_xform_decls (tree *, int *, void *);
-static void mx_register_decls (tree, tree *);
+static void mf_xform_decls (gimple_seq, tree);
+static tree mx_xfn_xform_decls (gimple_stmt_iterator *, bool *,
+                               struct walk_stmt_info *);
+static gimple_seq mx_register_decls (tree, gimple_seq, location_t);
 static unsigned int execute_mudflap_function_decls (void);
 
 static unsigned int execute_mudflap_function_decls (void);
 
+/* Return true if DECL is artificial stub that shouldn't be instrumented by
+   mf.  We should instrument clones of non-artificial functions.  */
+static inline bool
+mf_artificial (const_tree decl)
+{
+  return DECL_ARTIFICIAL (DECL_ORIGIN (decl));
+}
 
 /* ------------------------------------------------------------------------ */
 /* Some generally helpful functions for mudflap instrumentation.  */
 
 /* ------------------------------------------------------------------------ */
 /* Some generally helpful functions for mudflap instrumentation.  */
@@ -81,9 +88,8 @@ mf_build_string (const char *string)
   tree result = mf_mark (build_string (len + 1, string));
 
   TREE_TYPE (result) = build_array_type
   tree result = mf_mark (build_string (len + 1, string));
 
   TREE_TYPE (result) = build_array_type
-    (char_type_node, build_index_type (build_int_cst (NULL_TREE, len)));
+    (char_type_node, build_index_type (size_int (len)));
   TREE_CONSTANT (result) = 1;
   TREE_CONSTANT (result) = 1;
-  TREE_INVARIANT (result) = 1;
   TREE_READONLY (result) = 1;
   TREE_STATIC (result) = 1;
 
   TREE_READONLY (result) = 1;
   TREE_STATIC (result) = 1;
 
@@ -121,9 +127,7 @@ mf_varname_tree (tree decl)
     const char *sourcefile;
     unsigned sourceline = xloc.line;
     unsigned sourcecolumn = 0;
     const char *sourcefile;
     unsigned sourceline = xloc.line;
     unsigned sourcecolumn = 0;
-#ifdef USE_MAPPED_LOCATION
     sourcecolumn = xloc.column;
     sourcecolumn = xloc.column;
-#endif
     sourcefile = xloc.file;
     if (sourcefile == NULL && current_function_decl != NULL_TREE)
       sourcefile = DECL_SOURCE_FILE (current_function_decl);
     sourcefile = xloc.file;
     if (sourcefile == NULL && current_function_decl != NULL_TREE)
       sourcefile = DECL_SOURCE_FILE (current_function_decl);
@@ -214,11 +218,9 @@ mf_file_function_line_tree (location_t location)
 
   if (xloc.line > 0)
     {
 
   if (xloc.line > 0)
     {
-#ifdef USE_MAPPED_LOCATION
       if (xloc.column > 0)
         sprintf (linecolbuf, "%d:%d", xloc.line, xloc.column);
       else
       if (xloc.column > 0)
         sprintf (linecolbuf, "%d:%d", xloc.line, xloc.column);
       else
-#endif
         sprintf (linecolbuf, "%d", xloc.line);
       colon = ":";
       line = linecolbuf;
         sprintf (linecolbuf, "%d", xloc.line);
       colon = ":";
       line = linecolbuf;
@@ -297,10 +299,15 @@ static GTY (()) tree mf_set_options_fndecl;
 static inline tree
 mf_make_builtin (enum tree_code category, const char *name, tree type)
 {
 static inline tree
 mf_make_builtin (enum tree_code category, const char *name, tree type)
 {
-  tree decl = mf_mark (build_decl (category, get_identifier (name), type));
+  tree decl = mf_mark (build_decl (UNKNOWN_LOCATION,
+                                  category, get_identifier (name), type));
   TREE_PUBLIC (decl) = 1;
   DECL_EXTERNAL (decl) = 1;
   lang_hooks.decls.pushdecl (decl);
   TREE_PUBLIC (decl) = 1;
   DECL_EXTERNAL (decl) = 1;
   lang_hooks.decls.pushdecl (decl);
+  /* The decl was declared by the compiler.  */
+  DECL_ARTIFICIAL (decl) = 1;
+  /* And we don't want debug info for it.  */
+  DECL_IGNORED_P (decl) = 1;
   return decl;
 }
 
   return decl;
 }
 
@@ -313,13 +320,15 @@ mf_make_mf_cache_struct_type (tree field_type)
   /* There is, abominably, no language-independent way to construct a
      RECORD_TYPE.  So we have to call the basic type construction
      primitives by hand.  */
   /* There is, abominably, no language-independent way to construct a
      RECORD_TYPE.  So we have to call the basic type construction
      primitives by hand.  */
-  tree fieldlo = build_decl (FIELD_DECL, get_identifier ("low"), field_type);
-  tree fieldhi = build_decl (FIELD_DECL, get_identifier ("high"), field_type);
+  tree fieldlo = build_decl (UNKNOWN_LOCATION,
+                            FIELD_DECL, get_identifier ("low"), field_type);
+  tree fieldhi = build_decl (UNKNOWN_LOCATION,
+                            FIELD_DECL, get_identifier ("high"), field_type);
 
   tree struct_type = make_node (RECORD_TYPE);
   DECL_CONTEXT (fieldlo) = struct_type;
   DECL_CONTEXT (fieldhi) = struct_type;
 
   tree struct_type = make_node (RECORD_TYPE);
   DECL_CONTEXT (fieldlo) = struct_type;
   DECL_CONTEXT (fieldhi) = struct_type;
-  TREE_CHAIN (fieldlo) = fieldhi;
+  DECL_CHAIN (fieldlo) = fieldhi;
   TYPE_FIELDS (struct_type) = fieldlo;
   TYPE_NAME (struct_type) = get_identifier ("__mf_cache");
   layout_type (struct_type);
   TYPE_FIELDS (struct_type) = fieldlo;
   TYPE_NAME (struct_type) = get_identifier ("__mf_cache");
   layout_type (struct_type);
@@ -327,18 +336,6 @@ mf_make_mf_cache_struct_type (tree field_type)
   return struct_type;
 }
 
   return struct_type;
 }
 
-#define build_function_type_0(rtype)            \
-  build_function_type (rtype, void_list_node)
-#define build_function_type_1(rtype, arg1)                 \
-  build_function_type (rtype, tree_cons (0, arg1, void_list_node))
-#define build_function_type_3(rtype, arg1, arg2, arg3)                  \
-  build_function_type (rtype, tree_cons (0, arg1, tree_cons (0, arg2,   \
-                                                             tree_cons (0, arg3, void_list_node))))
-#define build_function_type_4(rtype, arg1, arg2, arg3, arg4)            \
-  build_function_type (rtype, tree_cons (0, arg1, tree_cons (0, arg2,   \
-                                                             tree_cons (0, arg3, tree_cons (0, arg4, \
-                                                                                            void_list_node)))))
-
 /* Initialize the global tree nodes that correspond to mf-runtime.h
    declarations.  */
 void
 /* Initialize the global tree nodes that correspond to mf-runtime.h
    declarations.  */
 void
@@ -366,15 +363,15 @@ mudflap_init (void)
   mf_cache_structptr_type = build_pointer_type (mf_cache_struct_type);
   mf_cache_array_type = build_array_type (mf_cache_struct_type, 0);
   mf_check_register_fntype =
   mf_cache_structptr_type = build_pointer_type (mf_cache_struct_type);
   mf_cache_array_type = build_array_type (mf_cache_struct_type, 0);
   mf_check_register_fntype =
-    build_function_type_4 (void_type_node, ptr_type_node, size_type_node,
-                           integer_type_node, mf_const_string_type);
+    build_function_type_list (void_type_node, ptr_type_node, size_type_node,
+                             integer_type_node, mf_const_string_type, NULL_TREE);
   mf_unregister_fntype =
   mf_unregister_fntype =
-    build_function_type_3 (void_type_node, ptr_type_node, size_type_node,
-                           integer_type_node);
+    build_function_type_list (void_type_node, ptr_type_node, size_type_node,
+                             integer_type_node, NULL_TREE);
   mf_init_fntype =
   mf_init_fntype =
-    build_function_type_0 (void_type_node);
+    build_function_type_list (void_type_node, NULL_TREE);
   mf_set_options_fntype =
   mf_set_options_fntype =
-    build_function_type_1 (integer_type_node, mf_const_string_type);
+    build_function_type_list (integer_type_node, mf_const_string_type, NULL_TREE);
 
   mf_cache_array_decl = mf_make_builtin (VAR_DECL, "__mf_lookup_cache",
                                          mf_cache_array_type);
 
   mf_cache_array_decl = mf_make_builtin (VAR_DECL, "__mf_lookup_cache",
                                          mf_cache_array_type);
@@ -398,37 +395,45 @@ mudflap_init (void)
   mf_set_options_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_set_options",
                                            mf_set_options_fntype);
 }
   mf_set_options_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_set_options",
                                            mf_set_options_fntype);
 }
-#undef build_function_type_4
-#undef build_function_type_3
-#undef build_function_type_1
-#undef build_function_type_0
 
 
 /* ------------------------------------------------------------------------ */
 
 
 /* ------------------------------------------------------------------------ */
-/* Memory reference transforms. Perform the mudflap indirection-related
-   tree transforms on the current function.
-
-   This is the second part of the mudflap instrumentation.  It works on
+/* This is the second part of the mudflap instrumentation.  It works on
    low-level GIMPLE using the CFG, because we want to run this pass after
    tree optimizations have been performed, but we have to preserve the CFG
    low-level GIMPLE using the CFG, because we want to run this pass after
    tree optimizations have been performed, but we have to preserve the CFG
-   for expansion from trees to RTL.  */
+   for expansion from trees to RTL.
+   Below is the list of transformations performed on statements in the
+   current function.
+
+ 1)  Memory reference transforms: Perform the mudflap indirection-related
+    tree transforms on memory references.
+
+ 2) Mark BUILTIN_ALLOCA calls not inlineable.
+
+ */
 
 static unsigned int
 execute_mudflap_function_ops (void)
 {
 
 static unsigned int
 execute_mudflap_function_ops (void)
 {
+  struct gimplify_ctx gctx;
+
   /* Don't instrument functions such as the synthetic constructor
      built during mudflap_finish_file.  */
   /* Don't instrument functions such as the synthetic constructor
      built during mudflap_finish_file.  */
-  if (mf_marked_p (current_function_decl) ||
-      DECL_ARTIFICIAL (current_function_decl))
+  if (mf_marked_p (current_function_decl)
+      || mf_artificial (current_function_decl))
     return 0;
 
     return 0;
 
-  push_gimplify_context ();
+  push_gimplify_context (&gctx);
+
+  add_referenced_var (mf_cache_array_decl);
+  add_referenced_var (mf_cache_shift_decl);
+  add_referenced_var (mf_cache_mask_decl);
 
   /* In multithreaded mode, don't cache the lookup cache parameters.  */
   if (! flag_mudflap_threads)
     mf_decl_cache_locals ();
 
 
   /* In multithreaded mode, don't cache the lookup cache parameters.  */
   if (! flag_mudflap_threads)
     mf_decl_cache_locals ();
 
-  mf_xform_derefs ();
+  mf_xform_statements ();
 
   if (! flag_mudflap_threads)
     mf_decl_clear_locals ();
 
   if (! flag_mudflap_threads)
     mf_decl_clear_locals ();
@@ -437,6 +442,26 @@ execute_mudflap_function_ops (void)
   return 0;
 }
 
   return 0;
 }
 
+/* Insert a gimple_seq SEQ on all the outgoing edges out of BB.  Note that
+   if BB has more than one edge, STMT will be replicated for each edge.
+   Also, abnormal edges will be ignored.  */
+
+static void
+insert_edge_copies_seq (gimple_seq seq, basic_block bb)
+{
+  edge e;
+  edge_iterator ei;
+  unsigned n_copies = -1;
+
+  FOR_EACH_EDGE (e, ei, bb->succs)
+    if (!(e->flags & EDGE_ABNORMAL))
+      n_copies++;
+
+  FOR_EACH_EDGE (e, ei, bb->succs)
+    if (!(e->flags & EDGE_ABNORMAL))
+      gsi_insert_seq_on_edge (e, n_copies-- > 0 ? gimple_seq_copy (seq) : seq);
+}
+
 /* Create and initialize local shadow variables for the lookup cache
    globals.  Put their decls in the *_l globals for use by
    mf_build_check_statement_for.  */
 /* Create and initialize local shadow variables for the lookup cache
    globals.  Put their decls in the *_l globals for use by
    mf_build_check_statement_for.  */
@@ -444,44 +469,31 @@ execute_mudflap_function_ops (void)
 static void
 mf_decl_cache_locals (void)
 {
 static void
 mf_decl_cache_locals (void)
 {
-  tree t, shift_init_stmts, mask_init_stmts;
-  tree_stmt_iterator tsi;
+  gimple g;
+  gimple_seq seq = gimple_seq_alloc ();
 
   /* Build the cache vars.  */
   mf_cache_shift_decl_l
 
   /* Build the cache vars.  */
   mf_cache_shift_decl_l
-    = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_shift_decl),
+    = mf_mark (make_rename_temp (TREE_TYPE (mf_cache_shift_decl),
                                "__mf_lookup_shift_l"));
 
   mf_cache_mask_decl_l
                                "__mf_lookup_shift_l"));
 
   mf_cache_mask_decl_l
-    = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_mask_decl),
+    = mf_mark (make_rename_temp (TREE_TYPE (mf_cache_mask_decl),
                                "__mf_lookup_mask_l"));
 
   /* Build initialization nodes for the cache vars.  We just load the
      globals into the cache variables.  */
                                "__mf_lookup_mask_l"));
 
   /* Build initialization nodes for the cache vars.  We just load the
      globals into the cache variables.  */
-  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (mf_cache_shift_decl_l),
-              mf_cache_shift_decl_l, mf_cache_shift_decl);
-  SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
-  gimplify_to_stmt_list (&t);
-  shift_init_stmts = t;
-
-  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (mf_cache_mask_decl_l),
-              mf_cache_mask_decl_l, mf_cache_mask_decl);
-  SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
-  gimplify_to_stmt_list (&t);
-  mask_init_stmts = t;
-
-  /* Anticipating multiple entry points, we insert the cache vars
-     initializers in each successor of the ENTRY_BLOCK_PTR.  */
-  for (tsi = tsi_start (shift_init_stmts);
-       ! tsi_end_p (tsi);
-       tsi_next (&tsi))
-    insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
-
-  for (tsi = tsi_start (mask_init_stmts);
-       ! tsi_end_p (tsi);
-       tsi_next (&tsi))
-    insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
-  bsi_commit_edge_inserts ();
+  g = gimple_build_assign (mf_cache_shift_decl_l, mf_cache_shift_decl);
+  gimple_set_location (g, DECL_SOURCE_LOCATION (current_function_decl));
+  gimple_seq_add_stmt (&seq, g);
+
+  g = gimple_build_assign (mf_cache_mask_decl_l, mf_cache_mask_decl);
+  gimple_set_location (g, DECL_SOURCE_LOCATION (current_function_decl));
+  gimple_seq_add_stmt (&seq, g);
+
+  insert_edge_copies_seq (seq, ENTRY_BLOCK_PTR);
+
+  gsi_commit_edge_inserts ();
 }
 
 
 }
 
 
@@ -495,27 +507,28 @@ mf_decl_clear_locals (void)
 
 static void
 mf_build_check_statement_for (tree base, tree limit,
 
 static void
 mf_build_check_statement_for (tree base, tree limit,
-                              block_stmt_iterator *instr_bsi,
-                              location_t *locus, tree dirflag)
+                              gimple_stmt_iterator *instr_gsi,
+                              location_t location, tree dirflag)
 {
 {
-  tree_stmt_iterator head, tsi;
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator gsi;
   basic_block cond_bb, then_bb, join_bb;
   edge e;
   tree cond, t, u, v;
   tree mf_base;
   tree mf_elem;
   tree mf_limit;
   basic_block cond_bb, then_bb, join_bb;
   edge e;
   tree cond, t, u, v;
   tree mf_base;
   tree mf_elem;
   tree mf_limit;
+  gimple g;
+  gimple_seq seq, stmts;
 
   /* We first need to split the current basic block, and start altering
      the CFG.  This allows us to insert the statements we're about to
      construct into the right basic blocks.  */
 
 
   /* We first need to split the current basic block, and start altering
      the CFG.  This allows us to insert the statements we're about to
      construct into the right basic blocks.  */
 
-  cond_bb = bb_for_stmt (bsi_stmt (*instr_bsi));
-  bsi = *instr_bsi;
-  bsi_prev (&bsi);
-  if (! bsi_end_p (bsi))
-    e = split_block (cond_bb, bsi_stmt (bsi));
+  cond_bb = gimple_bb (gsi_stmt (*instr_gsi));
+  gsi = *instr_gsi;
+  gsi_prev (&gsi);
+  if (! gsi_end_p (gsi))
+    e = split_block (cond_bb, gsi_stmt (gsi));
   else
     e = split_block_after_labels (cond_bb);
   cond_bb = e->src;
   else
     e = split_block_after_labels (cond_bb);
   cond_bb = e->src;
@@ -548,39 +561,46 @@ mf_build_check_statement_for (tree base, tree limit,
     }
 
   /* Build our local variables.  */
     }
 
   /* Build our local variables.  */
-  mf_elem = create_tmp_var (mf_cache_structptr_type, "__mf_elem");
-  mf_base = create_tmp_var (mf_uintptr_type, "__mf_base");
-  mf_limit = create_tmp_var (mf_uintptr_type, "__mf_limit");
+  mf_elem = make_rename_temp (mf_cache_structptr_type, "__mf_elem");
+  mf_base = make_rename_temp (mf_uintptr_type, "__mf_base");
+  mf_limit = make_rename_temp (mf_uintptr_type, "__mf_limit");
 
   /* Build: __mf_base = (uintptr_t) <base address expression>.  */
 
   /* Build: __mf_base = (uintptr_t) <base address expression>.  */
-  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, mf_base,
-              convert (mf_uintptr_type, unshare_expr (base)));
-  SET_EXPR_LOCUS (t, locus);
-  gimplify_to_stmt_list (&t);
-  head = tsi_start (t);
-  tsi = tsi_last (t);
+  seq = gimple_seq_alloc ();
+  t = fold_convert_loc (location, mf_uintptr_type,
+                       unshare_expr (base));
+  t = force_gimple_operand (t, &stmts, false, NULL_TREE);
+  gimple_seq_add_seq (&seq, stmts);
+  g = gimple_build_assign (mf_base, t);
+  gimple_set_location (g, location);
+  gimple_seq_add_stmt (&seq, g);
 
   /* Build: __mf_limit = (uintptr_t) <limit address expression>.  */
 
   /* Build: __mf_limit = (uintptr_t) <limit address expression>.  */
-  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, mf_limit,
-              convert (mf_uintptr_type, unshare_expr (limit)));
-  SET_EXPR_LOCUS (t, locus);
-  gimplify_to_stmt_list (&t);
-  tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
+  t = fold_convert_loc (location, mf_uintptr_type,
+                       unshare_expr (limit));
+  t = force_gimple_operand (t, &stmts, false, NULL_TREE);
+  gimple_seq_add_seq (&seq, stmts);
+  g = gimple_build_assign (mf_limit, t);
+  gimple_set_location (g, location);
+  gimple_seq_add_stmt (&seq, g);
 
   /* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
                                             & __mf_mask].  */
   t = build2 (RSHIFT_EXPR, mf_uintptr_type, mf_base,
 
   /* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
                                             & __mf_mask].  */
   t = build2 (RSHIFT_EXPR, mf_uintptr_type, mf_base,
-              (flag_mudflap_threads ? mf_cache_shift_decl : mf_cache_shift_decl_l));
+              flag_mudflap_threads ? mf_cache_shift_decl
+              : mf_cache_shift_decl_l);
   t = build2 (BIT_AND_EXPR, mf_uintptr_type, t,
   t = build2 (BIT_AND_EXPR, mf_uintptr_type, t,
-              (flag_mudflap_threads ? mf_cache_mask_decl : mf_cache_mask_decl_l));
+              flag_mudflap_threads ? mf_cache_mask_decl
+              : mf_cache_mask_decl_l);
   t = build4 (ARRAY_REF,
               TREE_TYPE (TREE_TYPE (mf_cache_array_decl)),
               mf_cache_array_decl, t, NULL_TREE, NULL_TREE);
   t = build1 (ADDR_EXPR, mf_cache_structptr_type, t);
   t = build4 (ARRAY_REF,
               TREE_TYPE (TREE_TYPE (mf_cache_array_decl)),
               mf_cache_array_decl, t, NULL_TREE, NULL_TREE);
   t = build1 (ADDR_EXPR, mf_cache_structptr_type, t);
-  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, mf_elem, t);
-  SET_EXPR_LOCUS (t, locus);
-  gimplify_to_stmt_list (&t);
-  tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
+  t = force_gimple_operand (t, &stmts, false, NULL_TREE);
+  gimple_seq_add_seq (&seq, stmts);
+  g = gimple_build_assign (mf_elem, t);
+  gimple_set_location (g, location);
+  gimple_seq_add_stmt (&seq, g);
 
   /* Quick validity check.
 
 
   /* Quick validity check.
 
@@ -612,7 +632,7 @@ mf_build_check_statement_for (tree base, tree limit,
 
   u = build3 (COMPONENT_REF, mf_uintptr_type,
               build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
 
   u = build3 (COMPONENT_REF, mf_uintptr_type,
               build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
-              TREE_CHAIN (TYPE_FIELDS (mf_cache_struct_type)), NULL_TREE);
+              DECL_CHAIN (TYPE_FIELDS (mf_cache_struct_type)), NULL_TREE);
 
   v = mf_limit;
 
 
   v = mf_limit;
 
@@ -622,18 +642,19 @@ mf_build_check_statement_for (tree base, tree limit,
      result of the evaluation of 't' in a temporary variable which we
      can use as the condition for the conditional jump.  */
   t = build2 (TRUTH_OR_EXPR, boolean_type_node, t, u);
      result of the evaluation of 't' in a temporary variable which we
      can use as the condition for the conditional jump.  */
   t = build2 (TRUTH_OR_EXPR, boolean_type_node, t, u);
-  cond = create_tmp_var (boolean_type_node, "__mf_unlikely_cond");
-  t = build2 (GIMPLE_MODIFY_STMT, boolean_type_node, cond, t);
-  gimplify_to_stmt_list (&t);
-  tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
+  t = force_gimple_operand (t, &stmts, false, NULL_TREE);
+  gimple_seq_add_seq (&seq, stmts);
+  cond = make_rename_temp (boolean_type_node, "__mf_unlikely_cond");
+  g = gimple_build_assign  (cond, t);
+  gimple_set_location (g, location);
+  gimple_seq_add_stmt (&seq, g);
 
   /* Build the conditional jump.  'cond' is just a temporary so we can
      simply build a void COND_EXPR.  We do need labels in both arms though.  */
 
   /* Build the conditional jump.  'cond' is just a temporary so we can
      simply build a void COND_EXPR.  We do need labels in both arms though.  */
-  t = build3 (COND_EXPR, void_type_node, cond,
-              build1 (GOTO_EXPR, void_type_node, tree_block_label (then_bb)),
-              build1 (GOTO_EXPR, void_type_node, tree_block_label (join_bb)));
-  SET_EXPR_LOCUS (t, locus);
-  tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
+  g = gimple_build_cond (NE_EXPR, cond, boolean_false_node, NULL_TREE,
+                        NULL_TREE);
+  gimple_set_location (g, location);
+  gimple_seq_add_stmt (&seq, g);
 
   /* At this point, after so much hard work, we have only constructed
      the conditional jump,
 
   /* At this point, after so much hard work, we have only constructed
      the conditional jump,
@@ -646,9 +667,8 @@ mf_build_check_statement_for (tree base, tree limit,
 
      We can insert this now in the current basic block, i.e. the one that
      the statement we're instrumenting was originally in.  */
 
      We can insert this now in the current basic block, i.e. the one that
      the statement we're instrumenting was originally in.  */
-  bsi = bsi_last (cond_bb);
-  for (tsi = head; ! tsi_end_p (tsi); tsi_next (&tsi))
-    bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
+  gsi = gsi_last_bb (cond_bb);
+  gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
 
   /*  Now build up the body of the cache-miss handling:
 
 
   /*  Now build up the body of the cache-miss handling:
 
@@ -656,42 +676,43 @@ mf_build_check_statement_for (tree base, tree limit,
      refresh *_l vars.
 
      This is the body of the conditional.  */
      refresh *_l vars.
 
      This is the body of the conditional.  */
-  
-  u = tree_cons (NULL_TREE,
-                 mf_file_function_line_tree (locus == NULL ? UNKNOWN_LOCATION
-                                             : *locus),
-                 NULL_TREE);
-  u = tree_cons (NULL_TREE, dirflag, u);
+
+  seq = gimple_seq_alloc ();
+  /* u is a string, so it is already a gimple value.  */
+  u = mf_file_function_line_tree (location);
   /* NB: we pass the overall [base..limit] range to mf_check.  */
   /* NB: we pass the overall [base..limit] range to mf_check.  */
-  u = tree_cons (NULL_TREE, 
-                 fold_build2 (PLUS_EXPR, integer_type_node,
-                             fold_build2 (MINUS_EXPR, mf_uintptr_type, mf_limit, mf_base),
-                             integer_one_node),
-                 u);
-  u = tree_cons (NULL_TREE, mf_base, u);
-  t = build_function_call_expr (mf_check_fndecl, u);
-  gimplify_to_stmt_list (&t);
-  head = tsi_start (t);
-  tsi = tsi_last (t);
+  v = fold_build2_loc (location, PLUS_EXPR, mf_uintptr_type,
+                  fold_build2_loc (location,
+                               MINUS_EXPR, mf_uintptr_type, mf_limit, mf_base),
+                  build_int_cst (mf_uintptr_type, 1));
+  v = force_gimple_operand (v, &stmts, true, NULL_TREE);
+  gimple_seq_add_seq (&seq, stmts);
+  g = gimple_build_call (mf_check_fndecl, 4, mf_base, v, dirflag, u);
+  gimple_seq_add_stmt (&seq, g);
 
   if (! flag_mudflap_threads)
     {
 
   if (! flag_mudflap_threads)
     {
-      t = build2 (GIMPLE_MODIFY_STMT, void_type_node,
-                  mf_cache_shift_decl_l, mf_cache_shift_decl);
-      tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
-
-      t = build2 (GIMPLE_MODIFY_STMT, void_type_node,
-                  mf_cache_mask_decl_l, mf_cache_mask_decl);
-      tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
+      if (stmt_ends_bb_p (g))
+       {
+         gsi = gsi_start_bb (then_bb);
+         gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
+         e = split_block (then_bb, g);
+         then_bb = e->dest;
+         seq = gimple_seq_alloc ();
+       }
+
+      g = gimple_build_assign (mf_cache_shift_decl_l, mf_cache_shift_decl);
+      gimple_seq_add_stmt (&seq, g);
+
+      g = gimple_build_assign (mf_cache_mask_decl_l, mf_cache_mask_decl);
+      gimple_seq_add_stmt (&seq, g);
     }
 
   /* Insert the check code in the THEN block.  */
     }
 
   /* Insert the check code in the THEN block.  */
-  bsi = bsi_start (then_bb);
-  for (tsi = head; ! tsi_end_p (tsi); tsi_next (&tsi))
-    bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
+  gsi = gsi_start_bb (then_bb);
+  gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
 
 
-  *instr_bsi = bsi_start (join_bb);
-  bsi_next (instr_bsi);
+  *instr_gsi = gsi_start_bb (join_bb);
 }
 
 
 }
 
 
@@ -708,7 +729,8 @@ mf_decl_eligible_p (tree decl)
           /* The decl must have its address taken.  In the case of
              arrays, this flag is also set if the indexes are not
              compile-time known valid constants.  */
           /* The decl must have its address taken.  In the case of
              arrays, this flag is also set if the indexes are not
              compile-time known valid constants.  */
-          && TREE_ADDRESSABLE (decl)    /* XXX: not sufficient: return-by-value structs! */
+         /* XXX: not sufficient: return-by-value structs! */
+          && TREE_ADDRESSABLE (decl)
           /* The type of the variable must be complete.  */
           && COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (decl))
          /* The decl hasn't been decomposed somehow.  */
           /* The type of the variable must be complete.  */
           && COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (decl))
          /* The decl hasn't been decomposed somehow.  */
@@ -717,8 +739,8 @@ mf_decl_eligible_p (tree decl)
 
 
 static void
 
 
 static void
-mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
-                   location_t *locus, tree dirflag)
+mf_xform_derefs_1 (gimple_stmt_iterator *iter, tree *tp,
+                   location_t location, tree dirflag)
 {
   tree type, base, limit, addr, size, t;
 
 {
   tree type, base, limit, addr, size, t;
 
@@ -751,7 +773,7 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
            is necessary.  Or we may have an innocent "a.b.c"
            expression that must not be instrumented.  We need to
            recurse all the way down the nesting structure to figure it
            is necessary.  Or we may have an innocent "a.b.c"
            expression that must not be instrumented.  We need to
            recurse all the way down the nesting structure to figure it
-           out: looking just at the outer node is not enough.  */          
+           out: looking just at the outer node is not enough.  */
         tree var;
         int component_ref_only = (TREE_CODE (t) == COMPONENT_REF);
        /* If we have a bitfield component reference, we must note the
         tree var;
         int component_ref_only = (TREE_CODE (t) == COMPONENT_REF);
        /* If we have a bitfield component reference, we must note the
@@ -767,9 +789,10 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
         while (1)
           {
            if (bitfield_ref_p && elt == NULL_TREE
         while (1)
           {
            if (bitfield_ref_p && elt == NULL_TREE
-               && (TREE_CODE (var) == ARRAY_REF || TREE_CODE (var) == COMPONENT_REF))
+               && (TREE_CODE (var) == ARRAY_REF
+                   || TREE_CODE (var) == COMPONENT_REF))
              elt = var;
              elt = var;
-       
+
             if (TREE_CODE (var) == ARRAY_REF)
               {
                 component_ref_only = 0;
             if (TREE_CODE (var) == ARRAY_REF)
               {
                 component_ref_only = 0;
@@ -777,14 +800,22 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
               }
             else if (TREE_CODE (var) == COMPONENT_REF)
               var = TREE_OPERAND (var, 0);
               }
             else if (TREE_CODE (var) == COMPONENT_REF)
               var = TREE_OPERAND (var, 0);
-            else if (INDIRECT_REF_P (var))
+            else if (INDIRECT_REF_P (var)
+                    || TREE_CODE (var) == MEM_REF)
               {
                base = TREE_OPERAND (var, 0);
                 break;
               }
               {
                base = TREE_OPERAND (var, 0);
                 break;
               }
-            else 
+            else if (TREE_CODE (var) == VIEW_CONVERT_EXPR)
+             {
+               var = TREE_OPERAND (var, 0);
+               if (CONSTANT_CLASS_P (var)
+                   && TREE_CODE (var) != STRING_CST)
+                 return;
+             }
+            else
               {
               {
-                gcc_assert (TREE_CODE (var) == VAR_DECL 
+                gcc_assert (TREE_CODE (var) == VAR_DECL
                             || TREE_CODE (var) == PARM_DECL
                             || TREE_CODE (var) == RESULT_DECL
                             || TREE_CODE (var) == STRING_CST);
                             || TREE_CODE (var) == PARM_DECL
                             || TREE_CODE (var) == RESULT_DECL
                             || TREE_CODE (var) == STRING_CST);
@@ -796,7 +827,8 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
                   return;
                 else
                  {
                   return;
                 else
                  {
-                   base = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (var)), var);
+                   base = build1 (ADDR_EXPR,
+                                  build_pointer_type (TREE_TYPE (var)), var);
                    break;
                  }
               }
                    break;
                  }
               }
@@ -817,20 +849,20 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
 
             if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST)
               size = DECL_SIZE_UNIT (field);
 
             if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST)
               size = DECL_SIZE_UNIT (field);
-            
+
            if (elt)
            if (elt)
-             elt = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (elt)), elt);
-            addr = fold_convert (ptr_type_node, elt ? elt : base);
-            addr = fold_build2 (PLUS_EXPR, ptr_type_node,
-                               addr, fold_convert (ptr_type_node,
-                                                   byte_position (field)));
+             elt = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (elt)),
+                           elt);
+            addr = fold_convert_loc (location, ptr_type_node, elt ? elt : base);
+            addr = fold_build_pointer_plus_loc (location,
+                                               addr, byte_position (field));
           }
         else
           addr = build1 (ADDR_EXPR, build_pointer_type (type), t);
 
           }
         else
           addr = build1 (ADDR_EXPR, build_pointer_type (type), t);
 
-        limit = fold_build2 (MINUS_EXPR, mf_uintptr_type,
-                             fold_build2 (PLUS_EXPR, mf_uintptr_type,
-                                         convert (mf_uintptr_type, addr),
+        limit = fold_build2_loc (location, MINUS_EXPR, mf_uintptr_type,
+                             fold_build2_loc (location, PLUS_EXPR, mf_uintptr_type,
+                                         fold_convert (mf_uintptr_type, addr),
                                          size),
                              integer_one_node);
       }
                                          size),
                              integer_one_node);
       }
@@ -839,21 +871,30 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
     case INDIRECT_REF:
       addr = TREE_OPERAND (t, 0);
       base = addr;
     case INDIRECT_REF:
       addr = TREE_OPERAND (t, 0);
       base = addr;
-      limit = fold_build2 (MINUS_EXPR, ptr_type_node,
-                           fold_build2 (PLUS_EXPR, ptr_type_node, base, size),
-                           integer_one_node);
+      limit = fold_build_pointer_plus_hwi_loc
+       (location, fold_build_pointer_plus_loc (location, base, size), -1);
+      break;
+
+    case MEM_REF:
+      addr = fold_build_pointer_plus_loc (location, TREE_OPERAND (t, 0),
+                                         TREE_OPERAND (t, 1));
+      base = addr;
+      limit = fold_build_pointer_plus_hwi_loc (location,
+                          fold_build_pointer_plus_loc (location,
+                                                       base, size), -1);
       break;
 
     case TARGET_MEM_REF:
       addr = tree_mem_ref_addr (ptr_type_node, t);
       base = addr;
       break;
 
     case TARGET_MEM_REF:
       addr = tree_mem_ref_addr (ptr_type_node, t);
       base = addr;
-      limit = fold_build2 (MINUS_EXPR, ptr_type_node,
-                          fold_build2 (PLUS_EXPR, ptr_type_node, base, size),
-                          build_int_cst (ptr_type_node, 1));
+      limit = fold_build_pointer_plus_hwi_loc (location,
+                          fold_build_pointer_plus_loc (location,
+                                                       base, size), -1);
       break;
 
     case ARRAY_RANGE_REF:
       break;
 
     case ARRAY_RANGE_REF:
-      warning (0, "mudflap checking not yet implemented for ARRAY_RANGE_REF");
+      warning (OPT_Wmudflap,
+              "mudflap checking not yet implemented for ARRAY_RANGE_REF");
       return;
 
     case BIT_FIELD_REF:
       return;
 
     case BIT_FIELD_REF:
@@ -867,23 +908,23 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
           return;
 
         bpu = bitsize_int (BITS_PER_UNIT);
           return;
 
         bpu = bitsize_int (BITS_PER_UNIT);
-        ofs = convert (bitsizetype, TREE_OPERAND (t, 2));
-        rem = size_binop (TRUNC_MOD_EXPR, ofs, bpu);
-        ofs = size_binop (TRUNC_DIV_EXPR, ofs, bpu);
+        ofs = fold_convert (bitsizetype, TREE_OPERAND (t, 2));
+        rem = size_binop_loc (location, TRUNC_MOD_EXPR, ofs, bpu);
+        ofs = size_binop_loc (location, TRUNC_DIV_EXPR, ofs, bpu);
 
 
-        size = convert (bitsizetype, TREE_OPERAND (t, 1));
-        size = size_binop (PLUS_EXPR, size, rem);
-        size = size_binop (CEIL_DIV_EXPR, size, bpu);
-        size = convert (sizetype, size);
+        size = fold_convert (bitsizetype, TREE_OPERAND (t, 1));
+        size = size_binop_loc (location, PLUS_EXPR, size, rem);
+        size = size_binop_loc (location, CEIL_DIV_EXPR, size, bpu);
+        size = fold_convert (sizetype, size);
 
         addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
 
         addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
-        addr = convert (ptr_type_node, addr);
-        addr = fold_build2 (PLUS_EXPR, ptr_type_node, addr, ofs);
+        addr = fold_convert (ptr_type_node, addr);
+        addr = fold_build_pointer_plus_loc (location, addr, ofs);
 
         base = addr;
 
         base = addr;
-        limit = fold_build2 (MINUS_EXPR, ptr_type_node,
-                             fold_build2 (PLUS_EXPR, ptr_type_node, base, size),
-                             integer_one_node);
+        limit = fold_build_pointer_plus_hwi_loc (location,
+                             fold_build_pointer_plus_loc (location,
+                                                         base, size), -1);
       }
       break;
 
       }
       break;
 
@@ -891,44 +932,47 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
       return;
     }
 
       return;
     }
 
-  mf_build_check_statement_for (base, limit, iter, locus, dirflag);
+  mf_build_check_statement_for (base, limit, iter, location, dirflag);
 }
 }
-
+/* Transform
+   1) Memory references.
+*/
 static void
 static void
-mf_xform_derefs (void)
+mf_xform_statements (void)
 {
   basic_block bb, next;
 {
   basic_block bb, next;
-  block_stmt_iterator i;
+  gimple_stmt_iterator i;
   int saved_last_basic_block = last_basic_block;
   int saved_last_basic_block = last_basic_block;
+  enum gimple_rhs_class grhs_class;
 
   bb = ENTRY_BLOCK_PTR ->next_bb;
   do
     {
       next = bb->next_bb;
 
   bb = ENTRY_BLOCK_PTR ->next_bb;
   do
     {
       next = bb->next_bb;
-      for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
+      for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
         {
         {
-          tree s = bsi_stmt (i);
+          gimple s = gsi_stmt (i);
 
           /* Only a few GIMPLE statements can reference memory.  */
 
           /* Only a few GIMPLE statements can reference memory.  */
-          switch (TREE_CODE (s))
+          switch (gimple_code (s))
             {
             {
-            case GIMPLE_MODIFY_STMT:
-              mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND (s, 0),
-                                EXPR_LOCUS (s), integer_one_node);
-              mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND (s, 1),
-                                EXPR_LOCUS (s), integer_zero_node);
+            case GIMPLE_ASSIGN:
+             mf_xform_derefs_1 (&i, gimple_assign_lhs_ptr (s),
+                                gimple_location (s), integer_one_node);
+             mf_xform_derefs_1 (&i, gimple_assign_rhs1_ptr (s),
+                                gimple_location (s), integer_zero_node);
+             grhs_class = get_gimple_rhs_class (gimple_assign_rhs_code (s));
+             if (grhs_class == GIMPLE_BINARY_RHS)
+               mf_xform_derefs_1 (&i, gimple_assign_rhs2_ptr (s),
+                                  gimple_location (s), integer_zero_node);
               break;
 
               break;
 
-            case RETURN_EXPR:
-              if (TREE_OPERAND (s, 0) != NULL_TREE)
+            case GIMPLE_RETURN:
+              if (gimple_return_retval (s) != NULL_TREE)
                 {
                 {
-                  if (TREE_CODE (TREE_OPERAND (s, 0)) == GIMPLE_MODIFY_STMT)
-                    mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND
-                                            (TREE_OPERAND (s, 0), 1),
-                                       EXPR_LOCUS (s), integer_zero_node);
-                  else
-                    mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s),
-                                       integer_zero_node);
+                  mf_xform_derefs_1 (&i, gimple_return_retval_ptr (s),
+                                    gimple_location (s),
+                                    integer_zero_node);
                 }
               break;
 
                 }
               break;
 
@@ -953,15 +997,17 @@ mf_xform_derefs (void)
 static unsigned int
 execute_mudflap_function_decls (void)
 {
 static unsigned int
 execute_mudflap_function_decls (void)
 {
+  struct gimplify_ctx gctx;
+
   /* Don't instrument functions such as the synthetic constructor
      built during mudflap_finish_file.  */
   /* Don't instrument functions such as the synthetic constructor
      built during mudflap_finish_file.  */
-  if (mf_marked_p (current_function_decl) ||
-      DECL_ARTIFICIAL (current_function_decl))
+  if (mf_marked_p (current_function_decl)
+      || mf_artificial (current_function_decl))
     return 0;
 
     return 0;
 
-  push_gimplify_context ();
+  push_gimplify_context (&gctx);
 
 
-  mf_xform_decls (DECL_SAVED_TREE (current_function_decl),
+  mf_xform_decls (gimple_body (current_function_decl),
                   DECL_ARGUMENTS (current_function_decl));
 
   pop_gimplify_context (NULL);
                   DECL_ARGUMENTS (current_function_decl));
 
   pop_gimplify_context (NULL);
@@ -979,16 +1025,17 @@ struct mf_xform_decls_data
 
 /* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
    _DECLs if appropriate.  Arrange to call the __mf_register function
 
 /* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
    _DECLs if appropriate.  Arrange to call the __mf_register function
-   now, and the __mf_unregister function later for each.  */
-static void
-mx_register_decls (tree decl, tree *stmt_list)
+   now, and the __mf_unregister function later for each.  Return the
+   gimple sequence after synthesis.  */
+gimple_seq
+mx_register_decls (tree decl, gimple_seq seq, location_t location)
 {
 {
-  tree finally_stmts = NULL_TREE;
-  tree_stmt_iterator initially_stmts = tsi_start (*stmt_list);
+  gimple_seq finally_stmts = NULL;
+  gimple_stmt_iterator initially_stmts = gsi_start (seq);
 
   while (decl != NULL_TREE)
     {
 
   while (decl != NULL_TREE)
     {
-      if (mf_decl_eligible_p (decl) 
+      if (mf_decl_eligible_p (decl)
           /* Not already processed.  */
           && ! mf_marked_p (decl)
           /* Automatic variable.  */
           /* Not already processed.  */
           && ! mf_marked_p (decl)
           /* Automatic variable.  */
@@ -996,105 +1043,108 @@ mx_register_decls (tree decl, tree *stmt_list)
           && ! TREE_STATIC (decl))
         {
           tree size = NULL_TREE, variable_name;
           && ! TREE_STATIC (decl))
         {
           tree size = NULL_TREE, variable_name;
-          tree unregister_fncall, unregister_fncall_params;
-          tree register_fncall, register_fncall_params;
-
-         size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
-
-          /* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
-          unregister_fncall_params =
-            tree_cons (NULL_TREE,
-                       convert (ptr_type_node,
-                                mf_mark (build1 (ADDR_EXPR,
-                                                 build_pointer_type (TREE_TYPE (decl)),
-                                                 decl))),
-                       tree_cons (NULL_TREE, 
-                                  size,
-                                  tree_cons (NULL_TREE,
-                                            /* __MF_TYPE_STACK */
-                                             build_int_cst (NULL_TREE, 3),
-                                             NULL_TREE)));
-          /* __mf_unregister (...) */
-          unregister_fncall = build_function_call_expr (mf_unregister_fndecl,
-                                                        unregister_fncall_params);
-
-          /* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK, "name") */
+          gimple unregister_fncall, register_fncall;
+         tree unregister_fncall_param, register_fncall_param;
+
+         /* Variable-sized objects should have sizes already been
+            gimplified when we got here. */
+         size = fold_convert (size_type_node,
+                              TYPE_SIZE_UNIT (TREE_TYPE (decl)));
+         gcc_assert (is_gimple_val (size));
+
+
+          unregister_fncall_param =
+           mf_mark (build1 (ADDR_EXPR,
+                            build_pointer_type (TREE_TYPE (decl)),
+                            decl));
+          /* __mf_unregister (&VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
+          unregister_fncall = gimple_build_call (mf_unregister_fndecl, 3,
+                                                unregister_fncall_param,
+                                                size,
+                                                integer_three_node);
+
+
           variable_name = mf_varname_tree (decl);
           variable_name = mf_varname_tree (decl);
-          register_fncall_params =
-            tree_cons (NULL_TREE,
-                   convert (ptr_type_node,
-                            mf_mark (build1 (ADDR_EXPR,
-                                             build_pointer_type (TREE_TYPE (decl)),
-                                             decl))),
-                       tree_cons (NULL_TREE,
-                                  size,
-                                  tree_cons (NULL_TREE,
-                                            /* __MF_TYPE_STACK */
-                                             build_int_cst (NULL_TREE, 3),
-                                             tree_cons (NULL_TREE,
-                                                        variable_name,
-                                                        NULL_TREE))));
-
-          /* __mf_register (...) */
-          register_fncall = build_function_call_expr (mf_register_fndecl,
-                                                      register_fncall_params);
+          register_fncall_param =
+           mf_mark (build1 (ADDR_EXPR,
+                            build_pointer_type (TREE_TYPE (decl)),
+                            decl));
+          /* __mf_register (&VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK,
+                           "name") */
+         register_fncall = gimple_build_call (mf_register_fndecl, 4,
+                                              register_fncall_param,
+                                              size,
+                                              integer_three_node,
+                                              variable_name);
+
 
           /* Accumulate the two calls.  */
 
           /* Accumulate the two calls.  */
-          /* ??? Set EXPR_LOCATION.  */
-          gimplify_stmt (&register_fncall);
-          gimplify_stmt (&unregister_fncall);
+         gimple_set_location (register_fncall, location);
+         gimple_set_location (unregister_fncall, location);
 
           /* Add the __mf_register call at the current appending point.  */
 
           /* Add the __mf_register call at the current appending point.  */
-          if (tsi_end_p (initially_stmts))
-           warning (0, "mudflap cannot track %qs in stub function",
-                    IDENTIFIER_POINTER (DECL_NAME (decl)));
+          if (gsi_end_p (initially_stmts))
+           {
+             if (!mf_artificial (decl))
+               warning (OPT_Wmudflap,
+                        "mudflap cannot track %qE in stub function",
+                        DECL_NAME (decl));
+           }
          else
            {
          else
            {
-             tsi_link_before (&initially_stmts, register_fncall, TSI_SAME_STMT);
+             gsi_insert_before (&initially_stmts, register_fncall,
+                                GSI_SAME_STMT);
 
              /* Accumulate the FINALLY piece.  */
 
              /* Accumulate the FINALLY piece.  */
-             append_to_statement_list (unregister_fncall, &finally_stmts);
+             gimple_seq_add_stmt (&finally_stmts, unregister_fncall);
            }
           mf_mark (decl);
         }
 
            }
           mf_mark (decl);
         }
 
-      decl = TREE_CHAIN (decl);
+      decl = DECL_CHAIN (decl);
     }
 
   /* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
     }
 
   /* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
-  if (finally_stmts != NULL_TREE)
+  if (finally_stmts != NULL)
     {
     {
-      tree t = build2 (TRY_FINALLY_EXPR, void_type_node,
-                       *stmt_list, finally_stmts);
-      *stmt_list = NULL;
-      append_to_statement_list (t, stmt_list);
+      gimple stmt = gimple_build_try (seq, finally_stmts, GIMPLE_TRY_FINALLY);
+      gimple_seq new_seq = gimple_seq_alloc ();
+
+      gimple_seq_add_stmt (&new_seq, stmt);
+      return new_seq;
     }
     }
+   else
+    return seq;
 }
 
 
 /* Process every variable mentioned in BIND_EXPRs.  */
 static tree
 }
 
 
 /* Process every variable mentioned in BIND_EXPRs.  */
 static tree
-mx_xfn_xform_decls (tree *t, int *continue_p, void *data)
+mx_xfn_xform_decls (gimple_stmt_iterator *gsi,
+                   bool *handled_operands_p ATTRIBUTE_UNUSED,
+                   struct walk_stmt_info *wi)
 {
 {
-  struct mf_xform_decls_data* d = (struct mf_xform_decls_data*) data;
+  struct mf_xform_decls_data *d = (struct mf_xform_decls_data *) wi->info;
+  gimple stmt = gsi_stmt (*gsi);
 
 
-  if (*t == NULL_TREE || *t == error_mark_node)
+  switch (gimple_code (stmt))
     {
     {
-      *continue_p = 0;
-      return NULL_TREE;
-    }
-
-  *continue_p = 1;
-
-  switch (TREE_CODE (*t))
-    {
-    case BIND_EXPR:
+    case GIMPLE_BIND:
       {
         /* Process function parameters now (but only once).  */
       {
         /* Process function parameters now (but only once).  */
-        mx_register_decls (d->param_decls, &BIND_EXPR_BODY (*t));
-        d->param_decls = NULL_TREE;
+       if (d->param_decls)
+         {
+           gimple_bind_set_body (stmt,
+                                 mx_register_decls (d->param_decls,
+                                                    gimple_bind_body (stmt),
+                                                    gimple_location (stmt)));
+           d->param_decls = NULL_TREE;
+         }
 
 
-        mx_register_decls (BIND_EXPR_VARS (*t), &BIND_EXPR_BODY (*t));
+       gimple_bind_set_body (stmt,
+                             mx_register_decls (gimple_bind_vars (stmt),
+                                                gimple_bind_body (stmt),
+                                                gimple_location (stmt)));
       }
       break;
 
       }
       break;
 
@@ -1114,11 +1164,18 @@ mx_xfn_xform_decls (tree *t, int *continue_p, void *data)
 */
 
 static void
 */
 
 static void
-mf_xform_decls (tree fnbody, tree fnparams)
+mf_xform_decls (gimple_seq fnbody, tree fnparams)
 {
   struct mf_xform_decls_data d;
 {
   struct mf_xform_decls_data d;
+  struct walk_stmt_info wi;
+  struct pointer_set_t *pset = pointer_set_create ();
+
   d.param_decls = fnparams;
   d.param_decls = fnparams;
-  walk_tree_without_duplicates (&fnbody, mx_xfn_xform_decls, &d);
+  memset (&wi, 0, sizeof (wi));
+  wi.info = (void*) &d;
+  wi.pset = pset;
+  walk_gimple_seq (fnbody, mx_xfn_xform_decls, NULL, &wi);
+  pointer_set_destroy (pset);
 }
 
 
 }
 
 
@@ -1136,7 +1193,8 @@ mf_mark (tree t)
   void **slot;
 
   if (marked_trees == NULL)
   void **slot;
 
   if (marked_trees == NULL)
-    marked_trees = htab_create_ggc (31, htab_hash_pointer, htab_eq_pointer, NULL);
+    marked_trees = htab_create_ggc (31, htab_hash_pointer, htab_eq_pointer,
+                                   NULL);
 
   slot = htab_find_slot (marked_trees, t, INSERT);
   *slot = t;
 
   slot = htab_find_slot (marked_trees, t, INSERT);
   *slot = t;
@@ -1172,21 +1230,17 @@ static GTY (()) tree enqueued_call_stmt_chain;
 static void
 mudflap_register_call (tree obj, tree object_size, tree varname)
 {
 static void
 mudflap_register_call (tree obj, tree object_size, tree varname)
 {
-  tree arg, args, call_stmt;
-
-  args = tree_cons (NULL_TREE, varname, NULL_TREE);
-
-  arg = build_int_cst (NULL_TREE, 4); /* __MF_TYPE_STATIC */
-  args = tree_cons (NULL_TREE, arg, args);
-
-  arg = convert (size_type_node, object_size);
-  args = tree_cons (NULL_TREE, arg, args);
+  tree arg, call_stmt;
 
   arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (obj)), obj);
 
   arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (obj)), obj);
-  arg = convert (ptr_type_node, arg);
-  args = tree_cons (NULL_TREE, arg, args);
+  arg = fold_convert (ptr_type_node, arg);
 
 
-  call_stmt = build_function_call_expr (mf_register_fndecl, args);
+  call_stmt = build_call_expr (mf_register_fndecl, 4,
+                              arg,
+                              fold_convert (size_type_node, object_size),
+                              /* __MF_TYPE_STATIC */
+                              build_int_cst (integer_type_node, 4),
+                              varname);
 
   append_to_statement_list (call_stmt, &enqueued_call_stmt_chain);
 }
 
   append_to_statement_list (call_stmt, &enqueued_call_stmt_chain);
 }
@@ -1202,7 +1256,7 @@ mudflap_enqueue_decl (tree obj)
      during mudflap_finish_file ().  That would confuse the user,
      since the text would refer to variables that don't show up in the
      user's source code.  */
      during mudflap_finish_file ().  That would confuse the user,
      since the text would refer to variables that don't show up in the
      user's source code.  */
-  if (DECL_P (obj) && DECL_EXTERNAL (obj) && DECL_ARTIFICIAL (obj))
+  if (DECL_P (obj) && DECL_EXTERNAL (obj) && mf_artificial (obj))
     return;
 
   VEC_safe_push (tree, gc, deferred_static_decls, obj);
     return;
 
   VEC_safe_push (tree, gc, deferred_static_decls, obj);
@@ -1218,7 +1272,7 @@ mudflap_enqueue_constant (tree obj)
     return;
 
   if (TREE_CODE (obj) == STRING_CST)
     return;
 
   if (TREE_CODE (obj) == STRING_CST)
-    object_size = build_int_cst (NULL_TREE, TREE_STRING_LENGTH (obj));
+    object_size = size_int (TREE_STRING_LENGTH (obj));
   else
     object_size = size_in_bytes (TREE_TYPE (obj));
 
   else
     object_size = size_in_bytes (TREE_TYPE (obj));
 
@@ -1238,21 +1292,20 @@ mudflap_finish_file (void)
   tree ctor_statements = NULL_TREE;
 
   /* No need to continue when there were errors.  */
   tree ctor_statements = NULL_TREE;
 
   /* No need to continue when there were errors.  */
-  if (errorcount != 0 || sorrycount != 0)
+  if (seen_error ())
     return;
 
   /* Insert a call to __mf_init.  */
   {
     return;
 
   /* Insert a call to __mf_init.  */
   {
-    tree call2_stmt = build_function_call_expr (mf_init_fndecl, NULL_TREE);
+    tree call2_stmt = build_call_expr (mf_init_fndecl, 0);
     append_to_statement_list (call2_stmt, &ctor_statements);
   }
     append_to_statement_list (call2_stmt, &ctor_statements);
   }
-  
+
   /* If appropriate, call __mf_set_options to pass along read-ignore mode.  */
   if (flag_mudflap_ignore_reads)
     {
   /* If appropriate, call __mf_set_options to pass along read-ignore mode.  */
   if (flag_mudflap_ignore_reads)
     {
-      tree arg = tree_cons (NULL_TREE, 
-                            mf_build_string ("-ignore-reads"), NULL_TREE);
-      tree call_stmt = build_function_call_expr (mf_set_options_fndecl, arg);
+      tree arg = mf_build_string ("-ignore-reads");
+      tree call_stmt = build_call_expr (mf_set_options_fndecl, 1, arg);
       append_to_statement_list (call_stmt, &ctor_statements);
     }
 
       append_to_statement_list (call_stmt, &ctor_statements);
     }
 
@@ -1261,7 +1314,7 @@ mudflap_finish_file (void)
     {
       size_t i;
       tree obj;
     {
       size_t i;
       tree obj;
-      for (i = 0; VEC_iterate (tree, deferred_static_decls, i, obj); i++)
+      FOR_EACH_VEC_ELT (tree, deferred_static_decls, i, obj)
         {
           gcc_assert (DECL_P (obj));
 
         {
           gcc_assert (DECL_P (obj));
 
@@ -1277,12 +1330,13 @@ mudflap_finish_file (void)
 
           if (! COMPLETE_TYPE_P (TREE_TYPE (obj)))
             {
 
           if (! COMPLETE_TYPE_P (TREE_TYPE (obj)))
             {
-              warning (0, "mudflap cannot track unknown size extern %qs",
-                       IDENTIFIER_POINTER (DECL_NAME (obj)));
+              warning (OPT_Wmudflap,
+                      "mudflap cannot track unknown size extern %qE",
+                       DECL_NAME (obj));
               continue;
             }
               continue;
             }
-          
-          mudflap_register_call (obj, 
+
+          mudflap_register_call (obj,
                                  size_in_bytes (TREE_TYPE (obj)),
                                  mf_varname_tree (obj));
         }
                                  size_in_bytes (TREE_TYPE (obj)),
                                  mf_varname_tree (obj));
         }
@@ -1297,7 +1351,7 @@ mudflap_finish_file (void)
       enqueued_call_stmt_chain = NULL_TREE;
     }
 
       enqueued_call_stmt_chain = NULL_TREE;
     }
 
-  cgraph_build_static_cdtor ('I', ctor_statements, 
+  cgraph_build_static_cdtor ('I', ctor_statements,
                              MAX_RESERVED_INIT_PRIORITY-1);
 }
 
                              MAX_RESERVED_INIT_PRIORITY-1);
 }
 
@@ -1308,39 +1362,43 @@ gate_mudflap (void)
   return flag_mudflap != 0;
 }
 
   return flag_mudflap != 0;
 }
 
-struct tree_opt_pass pass_mudflap_1 = 
+struct gimple_opt_pass pass_mudflap_1 =
 {
 {
+ {
+  GIMPLE_PASS,
   "mudflap1",                           /* name */
   gate_mudflap,                         /* gate */
   execute_mudflap_function_decls,       /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
   "mudflap1",                           /* name */
   gate_mudflap,                         /* gate */
   execute_mudflap_function_decls,       /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
-  0,                                    /* tv_id */
+  TV_NONE,                              /* tv_id */
   PROP_gimple_any,                      /* properties_required */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   PROP_gimple_any,                      /* properties_required */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
-  TODO_dump_func,                       /* todo_flags_finish */
-  0                                    /* letter */
+  0                                     /* todo_flags_finish */
+ }
 };
 
 };
 
-struct tree_opt_pass pass_mudflap_2 = 
+struct gimple_opt_pass pass_mudflap_2 =
 {
 {
+ {
+  GIMPLE_PASS,
   "mudflap2",                           /* name */
   gate_mudflap,                         /* gate */
   execute_mudflap_function_ops,         /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
   "mudflap2",                           /* name */
   gate_mudflap,                         /* gate */
   execute_mudflap_function_ops,         /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
-  0,                                    /* tv_id */
-  PROP_gimple_leh,                      /* properties_required */
+  TV_NONE,                              /* tv_id */
+  PROP_ssa | PROP_cfg | PROP_gimple_leh,/* properties_required */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   TODO_verify_flow | TODO_verify_stmts
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   TODO_verify_flow | TODO_verify_stmts
-  | TODO_dump_func,                     /* todo_flags_finish */
-  0                                    /* letter */
+  | TODO_update_ssa                     /* todo_flags_finish */
+ }
 };
 
 #include "gt-tree-mudflap.h"
 };
 
 #include "gt-tree-mudflap.h"
About OSDN
Find Software
Develop Software
Help