contrib:

[pf3gnuchains/gcc-fork.git] / gcc / tree-mudflap.c

diff --git a/gcc/tree-mudflap.c b/gcc/tree-mudflap.c
index a65d393..59f4bec 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 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+   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,13 +17,11 @@ 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, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 
 #include "config.h"
 
 
 #include "config.h"

-#include "errors.h"

 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"


@@ -45,9 +44,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "langhooks.h"
 #include "ggc.h"
 #include "cgraph.h"
 #include "langhooks.h"
 #include "ggc.h"
 #include "cgraph.h"

+#include "toplev.h"

 
 /* Internal function decls */
 
 
 /* Internal function decls */
 

+
+/* Options.  */
+#define flag_mudflap_threads (flag_mudflap == 2)
+

 /* Helpers.  */
 static tree mf_build_string (const char *string);
 static tree mf_varname_tree (tree);
 /* Helpers.  */
 static tree mf_build_string (const char *string);
 static tree mf_varname_tree (tree);


@@ -57,13 +61,13 @@ static tree mf_file_function_line_tree (location_t);
 static void mf_decl_cache_locals (void);
 static void mf_decl_clear_locals (void);
 static void mf_xform_derefs (void);
 static void mf_decl_cache_locals (void);
 static void mf_decl_clear_locals (void);
 static void mf_xform_derefs (void);

-static void execute_mudflap_function_ops (void);
+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 *);
 
 /* 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 execute_mudflap_function_decls (void);
+static unsigned int execute_mudflap_function_decls (void);

 
 
 /* ------------------------------------------------------------------------ */
 
 
 /* ------------------------------------------------------------------------ */


@@ -117,9 +121,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);


@@ -163,18 +165,18 @@ mf_varname_tree (tree decl)
   {
     const char *declname = NULL;
 
   {
     const char *declname = NULL;
 

-    if (strcmp ("GNU C++", lang_hooks.name) == 0 &&
-        DECL_NAME (decl) != NULL)
+    if (DECL_NAME (decl) != NULL)

       {
       {

-        /* The gcc/cp decl_printable_name hook doesn't do as good a job as
-           the libiberty demangler.  */
-        declname = cplus_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)),
-                                   DMGL_AUTO | DMGL_VERBOSE);
+       if (strcmp ("GNU C++", lang_hooks.name) == 0)
+         {
+           /* The gcc/cp decl_printable_name hook doesn't do as good a job as
+              the libiberty demangler.  */
+           declname = cplus_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)),
+                                      DMGL_AUTO | DMGL_VERBOSE);
+         }
+       if (declname == NULL)
+         declname = lang_hooks.decl_printable_name (decl, 3);

       }
       }

-
-    if (declname == NULL)
-      declname = lang_hooks.decl_printable_name (decl, 3);
-

     if (declname == NULL)
       declname = "<unnamed variable>";
 
     if (declname == NULL)
       declname = "<unnamed variable>";
 


@@ -210,11 +212,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,6 +297,10 @@ mf_make_builtin (enum tree_code category, const char *name, tree 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;
 }
 


@@ -323,17 +327,23 @@ mf_make_mf_cache_struct_type (tree field_type)
   return struct_type;
 }
 
   return struct_type;
 }
 

-#define build_function_type_0(rtype)            \
+#define build_function_type_0(rtype)                                           \

   build_function_type (rtype, void_list_node)
   build_function_type (rtype, void_list_node)

-#define build_function_type_1(rtype, arg1)                 \
+#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, 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))))
+  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)            \
 #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)))))
+  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.  */
 
 /* Initialize the global tree nodes that correspond to mf-runtime.h
    declarations.  */


@@ -378,6 +388,11 @@ mudflap_init (void)
                                          unsigned_char_type_node);
   mf_cache_mask_decl = mf_make_builtin (VAR_DECL, "__mf_lc_mask",
                                         mf_uintptr_type);
                                          unsigned_char_type_node);
   mf_cache_mask_decl = mf_make_builtin (VAR_DECL, "__mf_lc_mask",
                                         mf_uintptr_type);

+  /* Don't process these in mudflap_enqueue_decl, should they come by
+     there for some reason.  */
+  mf_mark (mf_cache_array_decl);
+  mf_mark (mf_cache_shift_decl);
+  mf_mark (mf_cache_mask_decl);

   mf_check_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_check",
                                      mf_check_register_fntype);
   mf_register_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_register",
   mf_check_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_check",
                                      mf_check_register_fntype);
   mf_register_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_register",


@@ -404,14 +419,14 @@ mudflap_init (void)
    tree optimizations have been performed, but we have to preserve the CFG
    for expansion from trees to RTL.  */
 
    tree optimizations have been performed, but we have to preserve the CFG
    for expansion from trees to RTL.  */
 

-static void
+static unsigned int

 execute_mudflap_function_ops (void)
 {
   /* 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))
 execute_mudflap_function_ops (void)
 {
   /* 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))

-    return;
+    return 0;

 
   push_gimplify_context ();
 
 
   push_gimplify_context ();
 


@@ -425,6 +440,7 @@ execute_mudflap_function_ops (void)
     mf_decl_clear_locals ();
 
   pop_gimplify_context (NULL);
     mf_decl_clear_locals ();
 
   pop_gimplify_context (NULL);

+  return 0;

 }
 
 /* Create and initialize local shadow variables for the lookup cache
 }
 
 /* Create and initialize local shadow variables for the lookup cache


@@ -448,14 +464,12 @@ mf_decl_cache_locals (void)
 
   /* Build initialization nodes for the cache vars.  We just load the
      globals into the cache variables.  */
 
   /* Build initialization nodes for the cache vars.  We just load the
      globals into the cache variables.  */

-  t = build (MODIFY_EXPR, TREE_TYPE (mf_cache_shift_decl_l),
-             mf_cache_shift_decl_l, mf_cache_shift_decl);
+  t = build_gimple_modify_stmt (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;
 
   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
   gimplify_to_stmt_list (&t);
   shift_init_stmts = t;
 

-  t = build (MODIFY_EXPR, TREE_TYPE (mf_cache_mask_decl_l),
-             mf_cache_mask_decl_l, mf_cache_mask_decl);
+  t = build_gimple_modify_stmt (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;
   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
   gimplify_to_stmt_list (&t);
   mask_init_stmts = t;


@@ -471,7 +485,7 @@ mf_decl_cache_locals (void)
        ! tsi_end_p (tsi);
        tsi_next (&tsi))
     insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
        ! tsi_end_p (tsi);
        tsi_next (&tsi))
     insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);

-  bsi_commit_edge_inserts (NULL);
+  bsi_commit_edge_inserts ();

 }
 
 
 }
 
 


@@ -484,50 +498,33 @@ mf_decl_clear_locals (void)
 }
 
 static void
 }
 
 static void

-mf_build_check_statement_for (tree base, tree addr, tree limit,
+mf_build_check_statement_for (tree base, tree limit,

                               block_stmt_iterator *instr_bsi,
                               location_t *locus, tree dirflag)
 {
   tree_stmt_iterator head, tsi;
                               block_stmt_iterator *instr_bsi,
                               location_t *locus, tree dirflag)
 {
   tree_stmt_iterator head, tsi;

-  tree ptrtype = TREE_TYPE (addr);

   block_stmt_iterator bsi;
   basic_block cond_bb, then_bb, join_bb;
   edge e;
   block_stmt_iterator bsi;
   basic_block cond_bb, then_bb, join_bb;
   edge e;

-  tree cond, t, u, v, l1, l2;
-  tree mf_value;
+  tree cond, t, u, v;

   tree mf_base;
   tree mf_elem;
   tree mf_limit;
 
   /* 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
   tree mf_base;
   tree mf_elem;
   tree mf_limit;
 
   /* 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.  The label l1 is the label
-     of the block for the THEN clause of the conditional jump we're
-     about to construct, and l2 is the ELSE clause, which is just the
-     continuation of the old statement stream.  */
-  l1 = create_artificial_label ();
-  l2 = create_artificial_label ();
+     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))
   cond_bb = bb_for_stmt (bsi_stmt (*instr_bsi));
   bsi = *instr_bsi;
   bsi_prev (&bsi);
   if (! bsi_end_p (bsi))

-    {
-      /* We're processing a statement in the middle of the block, so
-         we need to split the block.  This creates a new block and a new
-         fallthrough edge.  */
-      e = split_block (cond_bb, bsi_stmt (bsi));
-      cond_bb = e->src;
-      join_bb = e->dest;
-    }
+    e = split_block (cond_bb, bsi_stmt (bsi));

   else
   else

-    {
-      /* We're processing the first statement in the block, so we need
-         to split the incoming edge.  This also creates a new block
-         and a new fallthrough edge.  */
-      join_bb = cond_bb;
-      cond_bb = split_edge (find_edge (join_bb->prev_bb, join_bb));
-    }
-  
+    e = split_block_after_labels (cond_bb);
+  cond_bb = e->src;
+  join_bb = e->dest;
+

   /* A recap at this point: join_bb is the basic block at whose head
      is the gimple statement for which this check expression is being
      built.  cond_bb is the (possibly new, synthetic) basic block the
   /* A recap at this point: join_bb is the basic block at whose head
      is the gimple statement for which this check expression is being
      built.  cond_bb is the (possibly new, synthetic) basic block the


@@ -540,14 +537,11 @@ mf_build_check_statement_for (tree base, tree addr, tree limit,
   make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
   make_single_succ_edge (then_bb, join_bb, EDGE_FALLTHRU);
 
   make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
   make_single_succ_edge (then_bb, join_bb, EDGE_FALLTHRU);
 

-  /* We expect that the conditional jump we will construct will not
-     be taken very often as it basically is an exception condition.  */
-  predict_edge_def (EDGE_PRED (then_bb, 0), PRED_MUDFLAP, NOT_TAKEN);
-

   /* Mark the pseudo-fallthrough edge from cond_bb to join_bb.  */
   e = find_edge (cond_bb, join_bb);
   e->flags = EDGE_FALSE_VALUE;
   /* Mark the pseudo-fallthrough edge from cond_bb to join_bb.  */
   e = find_edge (cond_bb, join_bb);
   e->flags = EDGE_FALSE_VALUE;

-  predict_edge_def (e, PRED_MUDFLAP, TAKEN);
+  e->count = cond_bb->count;
+  e->probability = REG_BR_PROB_BASE;

 
   /* Update dominance info.  Note that bb_join's data was
      updated by split_block.  */
 
   /* Update dominance info.  Note that bb_join's data was
      updated by split_block.  */


@@ -558,43 +552,40 @@ mf_build_check_statement_for (tree base, tree addr, tree limit,
     }
 
   /* Build our local variables.  */
     }
 
   /* Build our local variables.  */

-  mf_value = create_tmp_var (ptrtype, "__mf_value");

   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 = 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");
 

-  /* Build: __mf_value = <address expression>.  */
-  t = build (MODIFY_EXPR, void_type_node, mf_value, unshare_expr (addr));
+  /* Build: __mf_base = (uintptr_t) <base address expression>.  */
+  t = build_gimple_modify_stmt (mf_base,
+                               fold_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);
 
   SET_EXPR_LOCUS (t, locus);
   gimplify_to_stmt_list (&t);
   head = tsi_start (t);
   tsi = tsi_last (t);
 

-  /* Build: __mf_base = (uintptr_t) <base address expression>.  */
-  t = build (MODIFY_EXPR, void_type_node, mf_base,
-             convert (mf_uintptr_type, unshare_expr (base)));
-  SET_EXPR_LOCUS (t, locus);
-  gimplify_to_stmt_list (&t);
-  tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
-

   /* Build: __mf_limit = (uintptr_t) <limit address expression>.  */
   /* Build: __mf_limit = (uintptr_t) <limit address expression>.  */

-  t = build (MODIFY_EXPR, void_type_node, mf_limit,
-             convert (mf_uintptr_type, unshare_expr (limit)));
+  t = build_gimple_modify_stmt (mf_limit,
+                               fold_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);
 
   /* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
                                             & __mf_mask].  */
   SET_EXPR_LOCUS (t, locus);
   gimplify_to_stmt_list (&t);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 
   /* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
                                             & __mf_mask].  */

-  t = build (RSHIFT_EXPR, mf_uintptr_type, mf_base,
-             (flag_mudflap_threads ? mf_cache_shift_decl : mf_cache_shift_decl_l));
-  t = build (BIT_AND_EXPR, mf_uintptr_type, t,
-             (flag_mudflap_threads ? mf_cache_mask_decl : mf_cache_mask_decl_l));
-  t = build (ARRAY_REF,
-             TREE_TYPE (TREE_TYPE (mf_cache_array_decl)),
-             mf_cache_array_decl, t, NULL_TREE, NULL_TREE);
+  t = build2 (RSHIFT_EXPR, mf_uintptr_type, mf_base,
+              flag_mudflap_threads ? mf_cache_shift_decl
+              : mf_cache_shift_decl_l);
+  t = build2 (BIT_AND_EXPR, mf_uintptr_type, t,
+              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 = build1 (ADDR_EXPR, mf_cache_structptr_type, t);

-  t = build (MODIFY_EXPR, void_type_node, mf_elem, t);
+  t = build_gimple_modify_stmt (mf_elem, t);

   SET_EXPR_LOCUS (t, locus);
   gimplify_to_stmt_list (&t);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
   SET_EXPR_LOCUS (t, locus);
   gimplify_to_stmt_list (&t);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);


@@ -614,10 +605,10 @@ mf_build_check_statement_for (tree base, tree addr, tree limit,
      the edge to the THEN clause of the conditional jump as unlikely.  */
 
   /* Construct t <-- '__mf_elem->low  > __mf_base'.  */
      the edge to the THEN clause of the conditional jump as unlikely.  */
 
   /* Construct t <-- '__mf_elem->low  > __mf_base'.  */

-  t = build (COMPONENT_REF, mf_uintptr_type,
-             build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
-             TYPE_FIELDS (mf_cache_struct_type), NULL_TREE);
-  t = build (GT_EXPR, boolean_type_node, t, mf_base);
+  t = build3 (COMPONENT_REF, mf_uintptr_type,
+              build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
+              TYPE_FIELDS (mf_cache_struct_type), NULL_TREE);
+  t = build2 (GT_EXPR, boolean_type_node, t, mf_base);

 
   /* Construct '__mf_elem->high < __mf_limit'.
 
 
   /* Construct '__mf_elem->high < __mf_limit'.
 


@@ -627,28 +618,26 @@ mf_build_check_statement_for (tree base, tree addr, tree limit,
 
      Then build 'u <-- (u < v).  */
 
 
      Then build 'u <-- (u < v).  */
 

-  u = build (COMPONENT_REF, mf_uintptr_type,
-             build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
-             TREE_CHAIN (TYPE_FIELDS (mf_cache_struct_type)), NULL_TREE);
+  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);

 
   v = mf_limit;
 
 
   v = mf_limit;
 

-  u = build (LT_EXPR, boolean_type_node, u, v);
+  u = build2 (LT_EXPR, boolean_type_node, u, v);

 
   /* Build the composed conditional: t <-- 't || u'.  Then store the
      result of the evaluation of 't' in a temporary variable which we
      can use as the condition for the conditional jump.  */
 
   /* Build the composed conditional: t <-- 't || u'.  Then store the
      result of the evaluation of 't' in a temporary variable which we
      can use as the condition for the conditional jump.  */

-  t = build (TRUTH_OR_EXPR, boolean_type_node, t, u);
+  t = build2 (TRUTH_OR_EXPR, boolean_type_node, t, u);

   cond = create_tmp_var (boolean_type_node, "__mf_unlikely_cond");
   cond = create_tmp_var (boolean_type_node, "__mf_unlikely_cond");

-  t = build (MODIFY_EXPR, boolean_type_node, cond, t);
+  t = build_gimple_modify_stmt (cond, t);

   gimplify_to_stmt_list (&t);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 
   /* 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.  */
   gimplify_to_stmt_list (&t);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 
   /* 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 = build (COND_EXPR, void_type_node, cond,
-             build (GOTO_EXPR, void_type_node, tree_block_label (then_bb)),
-             build (GOTO_EXPR, void_type_node, tree_block_label (join_bb)));
+  t = build3 (COND_EXPR, void_type_node, cond, NULL_TREE, NULL_TREE);

   SET_EXPR_LOCUS (t, locus);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 
   SET_EXPR_LOCUS (t, locus);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 


@@ -673,33 +662,25 @@ mf_build_check_statement_for (tree base, tree addr, 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);
-  /* NB: we pass the overall [base..limit] range to mf_check,
-     not the [mf_value..mf_value+size-1] range.  */
-  u = tree_cons (NULL_TREE, 
-                 fold (build (PLUS_EXPR, integer_type_node,
-                              fold (build (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);
+
+  u = mf_file_function_line_tree (locus == NULL ? UNKNOWN_LOCATION : *locus);
+  /* NB: we pass the overall [base..limit] range to mf_check.  */
+  v = fold_build2 (PLUS_EXPR, integer_type_node,
+                  fold_build2 (MINUS_EXPR, mf_uintptr_type, mf_limit, mf_base),
+                  integer_one_node);
+  t = build_call_expr (mf_check_fndecl, 4, mf_base, v, dirflag, u);

   gimplify_to_stmt_list (&t);
   head = tsi_start (t);
   tsi = tsi_last (t);
 
   if (! flag_mudflap_threads)
     {
   gimplify_to_stmt_list (&t);
   head = tsi_start (t);
   tsi = tsi_last (t);
 
   if (! flag_mudflap_threads)
     {

-      t = build (MODIFY_EXPR, void_type_node,
-                 mf_cache_shift_decl_l, mf_cache_shift_decl);
+      t = build_gimple_modify_stmt (mf_cache_shift_decl_l,
+                                   mf_cache_shift_decl);

       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 
       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 

-      t = build (MODIFY_EXPR, void_type_node,
-                 mf_cache_mask_decl_l, mf_cache_mask_decl);
+      t = build_gimple_modify_stmt (mf_cache_mask_decl_l,
+                                   mf_cache_mask_decl);

       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
     }
 
       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
     }
 


@@ -709,14 +690,36 @@ mf_build_check_statement_for (tree base, tree addr, tree limit,
     bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
 
   *instr_bsi = bsi_start (join_bb);
     bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
 
   *instr_bsi = bsi_start (join_bb);

-  bsi_next (instr_bsi);

 }
 
 }
 

+
+/* Check whether the given decl, generally a VAR_DECL or PARM_DECL, is
+   eligible for instrumentation.  For the mudflap1 pass, this implies
+   that it should be registered with the libmudflap runtime.  For the
+   mudflap2 pass this means instrumenting an indirection operation with
+   respect to the object.
+*/
+static int
+mf_decl_eligible_p (tree decl)
+{
+  return ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_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.  */
+         /* 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.  */
+         && !DECL_HAS_VALUE_EXPR_P (decl));
+}
+
+

 static void
 mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
                    location_t *locus, tree dirflag)
 {
 static void
 mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
                    location_t *locus, tree dirflag)
 {

-  tree type, ptr_type, addr, base, size, limit, t;
+  tree type, base, limit, addr, size, t;

 
   /* Don't instrument read operations.  */
   if (dirflag == integer_zero_node && flag_mudflap_ignore_reads)
 
   /* Don't instrument read operations.  */
   if (dirflag == integer_zero_node && flag_mudflap_ignore_reads)


@@ -728,109 +731,138 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
 
   t = *tp;
   type = TREE_TYPE (t);
 
   t = *tp;
   type = TREE_TYPE (t);

+
+  if (type == error_mark_node)
+    return;
+

   size = TYPE_SIZE_UNIT (type);
 
   switch (TREE_CODE (t))
     {
     case ARRAY_REF:
   size = TYPE_SIZE_UNIT (type);
 
   switch (TREE_CODE (t))
     {
     case ARRAY_REF:

+    case COMPONENT_REF:

       {
       {

-        /* Omit checking if we can statically determine that the access is
-           valid.  For non-addressable local arrays this is not optional,
-           since we won't have called __mf_register for the object.  */
-        tree op0, op1;
-
-        op0 = TREE_OPERAND (t, 0);
-        op1 = TREE_OPERAND (t, 1);
-        while (TREE_CODE (op1) == INTEGER_CST)
+        /* This is trickier than it may first appear.  The reason is
+           that we are looking at expressions from the "inside out" at
+           this point.  We may have a complex nested aggregate/array
+           expression (e.g. "a.b[i].c"), maybe with an indirection as
+           the leftmost operator ("p->a.b.d"), where instrumentation
+           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.  */          
+        tree var;
+        int component_ref_only = (TREE_CODE (t) == COMPONENT_REF);
+       /* If we have a bitfield component reference, we must note the
+          innermost addressable object in ELT, from which we will
+          construct the byte-addressable bounds of the bitfield.  */
+       tree elt = NULL_TREE;
+       int bitfield_ref_p = (TREE_CODE (t) == COMPONENT_REF
+                             && DECL_BIT_FIELD_TYPE (TREE_OPERAND (t, 1)));
+
+        /* Iterate to the top of the ARRAY_REF/COMPONENT_REF
+           containment hierarchy to find the outermost VAR_DECL.  */
+        var = TREE_OPERAND (t, 0);
+        while (1)

           {
           {

-            tree dom = TYPE_DOMAIN (TREE_TYPE (op0));
-
-            /* Test for index in range.  Break if not.  */
-            if (!dom
-                || (! TYPE_MIN_VALUE (dom)
-                    || ! really_constant_p (TYPE_MIN_VALUE (dom)))
-                || (! TYPE_MAX_VALUE (dom)
-                    || ! really_constant_p (TYPE_MAX_VALUE (dom)))
-                || (tree_int_cst_lt (op1, TYPE_MIN_VALUE (dom))
-                    || tree_int_cst_lt (TYPE_MAX_VALUE (dom), op1)))
-              break;
+           if (bitfield_ref_p && elt == NULL_TREE
+               && (TREE_CODE (var) == ARRAY_REF
+                   || TREE_CODE (var) == COMPONENT_REF))
+             elt = var;
+       
+            if (TREE_CODE (var) == ARRAY_REF)
+              {
+                component_ref_only = 0;
+                var = TREE_OPERAND (var, 0);
+              }
+            else if (TREE_CODE (var) == COMPONENT_REF)
+              var = TREE_OPERAND (var, 0);
+            else if (INDIRECT_REF_P (var))
+              {
+               base = TREE_OPERAND (var, 0);
+                break;
+              }
+            else 
+              {
+                gcc_assert (TREE_CODE (var) == VAR_DECL 
+                            || TREE_CODE (var) == PARM_DECL
+                            || TREE_CODE (var) == RESULT_DECL
+                            || TREE_CODE (var) == STRING_CST);
+                /* Don't instrument this access if the underlying
+                   variable is not "eligible".  This test matches
+                   those arrays that have only known-valid indexes,
+                   and thus are not labeled TREE_ADDRESSABLE.  */
+                if (! mf_decl_eligible_p (var) || component_ref_only)
+                  return;
+                else
+                 {
+                   base = build1 (ADDR_EXPR,
+                                  build_pointer_type (TREE_TYPE (var)), var);
+                   break;
+                 }
+              }
+          }

 
 

-            /* If we're looking at a non-external VAR_DECL, then the 
-               access must be ok.  */
-            if (TREE_CODE (op0) == VAR_DECL && !DECL_EXTERNAL (op0))
-              return;
+        /* Handle the case of ordinary non-indirection structure
+           accesses.  These have only nested COMPONENT_REF nodes (no
+           INDIRECT_REF), but pass through the above filter loop.
+           Note that it's possible for such a struct variable to match
+           the eligible_p test because someone else might take its
+           address sometime.  */

 
 

-            /* Only continue if we're still looking at an array.  */
-            if (TREE_CODE (op0) != ARRAY_REF)
-              break;
+        /* We need special processing for bitfield components, because
+           their addresses cannot be taken.  */
+        if (bitfield_ref_p)
+          {
+            tree field = TREE_OPERAND (t, 1);

 
 

-            op1 = TREE_OPERAND (op0, 1);
-            op0 = TREE_OPERAND (op0, 0);
+            if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST)
+              size = DECL_SIZE_UNIT (field);
+            
+           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 (POINTER_PLUS_EXPR, ptr_type_node,
+                               addr, fold_convert (sizetype,
+                                                   byte_position (field)));

           }
           }

-      
-        /* If we got here, we couldn't statically the check.  */
-        ptr_type = build_pointer_type (type);
-        addr = build1 (ADDR_EXPR, ptr_type, t);
-        base = build1 (ADDR_EXPR, ptr_type, op0);
-        limit = fold (build (MINUS_EXPR, mf_uintptr_type,
-                             fold (build2 (PLUS_EXPR, mf_uintptr_type, addr, size)),
-                             integer_one_node));
+        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),
+                                         size),
+                             integer_one_node);

       }
       break;
 
     case INDIRECT_REF:
       addr = TREE_OPERAND (t, 0);
       }
       break;
 
     case INDIRECT_REF:
       addr = TREE_OPERAND (t, 0);

-      ptr_type = TREE_TYPE (addr);

       base = addr;
       base = addr;

-      limit = fold (build (MINUS_EXPR, ptr_type_node,
-                           fold (build (PLUS_EXPR, ptr_type_node, base, size)),
-                           integer_one_node));
+      limit = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
+                          fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, base,
+                                       size),
+                          size_int (-1));
+      break;
+
+    case TARGET_MEM_REF:
+      addr = tree_mem_ref_addr (ptr_type_node, t);
+      base = addr;
+      limit = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
+                          fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, base,
+                                       size),
+                          size_int (-1));

       break;
 
     case ARRAY_RANGE_REF:
       break;
 
     case ARRAY_RANGE_REF:

-      warning ("mudflap checking not yet implemented for ARRAY_RANGE_REF");
+      warning (OPT_Wmudflap,
+              "mudflap checking not yet implemented for ARRAY_RANGE_REF");

       return;
 
       return;
 

-    case COMPONENT_REF:
-      {
-        tree field;
-
-        /* If we're not dereferencing something, then the access
-           must be ok.  */
-        if (TREE_CODE (TREE_OPERAND (t, 0)) != INDIRECT_REF)
-          return;
-
-        field = TREE_OPERAND (t, 1);
-
-        /* If we're looking at a bit field, then we can't take its address
-           with ADDR_EXPR -- lang_hooks.mark_addressable will error.  Do
-           things the hard way with PLUS.  */
-        if (DECL_BIT_FIELD_TYPE (field))
-          {
-            if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST)
-              size = DECL_SIZE_UNIT (field);
-
-            addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
-            addr = fold_convert (ptr_type_node, addr);
-            addr = fold (build (PLUS_EXPR, ptr_type_node,
-                                addr, fold_convert (ptr_type_node,
-                                                    byte_position (field))));
-          }
-        else
-          {
-            ptr_type = build_pointer_type (type);
-            addr = build1 (ADDR_EXPR, ptr_type, t);
-          }
-
-        /* XXXXXX */
-        base = addr;
-        limit = fold (build (MINUS_EXPR, ptr_type_node,
-                             fold (build (PLUS_EXPR, ptr_type_node, base, size)),
-                             integer_one_node));
-      }
-      break;
-

     case BIT_FIELD_REF:
     case BIT_FIELD_REF:

+      /* ??? merge with COMPONENT_REF code above? */

       {
         tree ofs, rem, bpu;
 
       {
         tree ofs, rem, bpu;
 


@@ -842,7 +874,7 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
         bpu = bitsize_int (BITS_PER_UNIT);
         ofs = convert (bitsizetype, TREE_OPERAND (t, 2));
         rem = size_binop (TRUNC_MOD_EXPR, ofs, bpu);
         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 (sizetype, size_binop (TRUNC_DIV_EXPR, ofs, bpu));

 
         size = convert (bitsizetype, TREE_OPERAND (t, 1));
         size = size_binop (PLUS_EXPR, size, rem);
 
         size = convert (bitsizetype, TREE_OPERAND (t, 1));
         size = size_binop (PLUS_EXPR, size, rem);


@@ -851,12 +883,13 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
 
         addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
         addr = convert (ptr_type_node, addr);
 
         addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
         addr = convert (ptr_type_node, addr);

-        addr = fold (build (PLUS_EXPR, ptr_type_node, addr, ofs));
+        addr = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, addr, ofs);

 
         base = addr;
 
         base = addr;

-        limit = fold (build (MINUS_EXPR, ptr_type_node,
-                             fold (build (PLUS_EXPR, ptr_type_node, base, size)),
-                             integer_one_node));
+        limit = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
+                             fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
+                                          base, size),
+                             size_int (-1));

       }
       break;
 
       }
       break;
 


@@ -864,7 +897,7 @@ mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
       return;
     }
 
       return;
     }
 

-  mf_build_check_statement_for (base, addr, limit, iter, locus, dirflag);
+  mf_build_check_statement_for (base, limit, iter, locus, dirflag);

 }
 
 static void
 }
 
 static void


@@ -885,18 +918,19 @@ mf_xform_derefs (void)
           /* Only a few GIMPLE statements can reference memory.  */
           switch (TREE_CODE (s))
             {
           /* Only a few GIMPLE statements can reference memory.  */
           switch (TREE_CODE (s))
             {

-            case MODIFY_EXPR:
-              mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s),
-                                 integer_one_node);
-              mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 1), EXPR_LOCUS (s),
-                                 integer_zero_node);
+            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);

               break;
 
             case RETURN_EXPR:
               if (TREE_OPERAND (s, 0) != NULL_TREE)
                 {
               break;
 
             case RETURN_EXPR:
               if (TREE_OPERAND (s, 0) != NULL_TREE)
                 {

-                  if (TREE_CODE (TREE_OPERAND (s, 0)) == MODIFY_EXPR)
-                    mf_xform_derefs_1 (&i, &TREE_OPERAND (TREE_OPERAND (s, 0), 1),
+                  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),
                                        EXPR_LOCUS (s), integer_zero_node);
                   else
                     mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s),


@@ -922,14 +956,14 @@ mf_xform_derefs (void)
    of their BIND_EXPR binding context, and we lose liveness information
    for the declarations we wish to instrument.  */
 
    of their BIND_EXPR binding context, and we lose liveness information
    for the declarations we wish to instrument.  */
 

-static void
+static unsigned int

 execute_mudflap_function_decls (void)
 {
   /* 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))
 execute_mudflap_function_decls (void)
 {
   /* 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))

-    return;
+    return 0;

 
   push_gimplify_context ();
 
 
   push_gimplify_context ();
 


@@ -937,6 +971,7 @@ execute_mudflap_function_decls (void)
                   DECL_ARGUMENTS (current_function_decl));
 
   pop_gimplify_context (NULL);
                   DECL_ARGUMENTS (current_function_decl));
 
   pop_gimplify_context (NULL);

+  return 0;

 }
 
 /* This struct is passed between mf_xform_decls to store state needed
 }
 
 /* This struct is passed between mf_xform_decls to store state needed


@@ -959,63 +994,46 @@ mx_register_decls (tree decl, tree *stmt_list)
 
   while (decl != NULL_TREE)
     {
 
   while (decl != NULL_TREE)
     {

-      /* Eligible decl?  */
-      if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
-          /* It must be a non-external, automatic variable.  */
+      if (mf_decl_eligible_p (decl) 
+          /* Not already processed.  */
+          && ! mf_marked_p (decl)
+          /* Automatic variable.  */

           && ! DECL_EXTERNAL (decl)
           && ! DECL_EXTERNAL (decl)

-          && ! TREE_STATIC (decl)
-          /* The decl must have its address taken.  */
-          && 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.  */
-         && DECL_VALUE_EXPR (decl) == NULL
-          /* Don't process the same decl twice.  */
-          && ! mf_marked_p (decl))
+          && ! TREE_STATIC (decl))

         {
           tree size = NULL_TREE, variable_name;
         {
           tree size = NULL_TREE, variable_name;

-          tree unregister_fncall, unregister_fncall_params;
-          tree register_fncall, register_fncall_params;
+          tree unregister_fncall, unregister_fncall_param;
+          tree register_fncall, register_fncall_param;

 
          size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
 
 
          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") */
+
+          unregister_fncall_param =
+           convert (ptr_type_node,
+                    mf_mark (build1 (ADDR_EXPR,
+                                     build_pointer_type (TREE_TYPE (decl)),
+                                     decl)));
+          /* __mf_unregister (&VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
+          unregister_fncall = build_call_expr (mf_unregister_fndecl, 3,
+                                              unregister_fncall_param,
+                                              size,
+                                              build_int_cst (NULL_TREE, 3));
+
+

           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 =
+           convert (ptr_type_node,
+                    mf_mark (build1 (ADDR_EXPR,
+                                     build_pointer_type (TREE_TYPE (decl)),
+                                     decl)));
+          /* __mf_register (&VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK,
+                           "name") */
+         register_fncall = build_call_expr (mf_register_fndecl, 4,
+                                            register_fncall_param,
+                                            size,
+                                            build_int_cst (NULL_TREE, 3),
+                                            variable_name);
+

 
           /* Accumulate the two calls.  */
           /* ??? Set EXPR_LOCATION.  */
 
           /* Accumulate the two calls.  */
           /* ??? Set EXPR_LOCATION.  */


@@ -1024,12 +1042,20 @@ mx_register_decls (tree decl, tree *stmt_list)
 
           /* Add the __mf_register call at the current appending point.  */
           if (tsi_end_p (initially_stmts))
 
           /* Add the __mf_register call at the current appending point.  */
           if (tsi_end_p (initially_stmts))

-            internal_error ("mudflap ran off end of BIND_EXPR body");
-          tsi_link_before (&initially_stmts, register_fncall, TSI_SAME_STMT);
-
-          /* Accumulate the FINALLY piece.  */
-          append_to_statement_list (unregister_fncall, &finally_stmts);
-
+           {
+             if (!DECL_ARTIFICIAL (decl))
+               warning (OPT_Wmudflap,
+                        "mudflap cannot track %qs in stub function",
+                        IDENTIFIER_POINTER (DECL_NAME (decl)));
+           }
+         else
+           {
+             tsi_link_before (&initially_stmts, register_fncall,
+                              TSI_SAME_STMT);
+
+             /* Accumulate the FINALLY piece.  */
+             append_to_statement_list (unregister_fncall, &finally_stmts);
+           }

           mf_mark (decl);
         }
 
           mf_mark (decl);
         }
 


@@ -1039,8 +1065,8 @@ mx_register_decls (tree decl, tree *stmt_list)
   /* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
   if (finally_stmts != NULL_TREE)
     {
   /* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
   if (finally_stmts != NULL_TREE)
     {

-      tree t = build (TRY_FINALLY_EXPR, void_type_node,
-                      *stmt_list, finally_stmts);
+      tree t = build2 (TRY_FINALLY_EXPR, void_type_node,
+                       *stmt_list, finally_stmts);

       *stmt_list = NULL;
       append_to_statement_list (t, stmt_list);
     }
       *stmt_list = NULL;
       append_to_statement_list (t, stmt_list);
     }


@@ -1077,7 +1103,7 @@ mx_xfn_xform_decls (tree *t, int *continue_p, void *data)
       break;
     }
 
       break;
     }
 

-  return NULL;
+  return NULL_TREE;

 }
 
 /* Perform the object lifetime tracking mudflap transform on the given function
 }
 
 /* Perform the object lifetime tracking mudflap transform on the given function


@@ -1111,7 +1137,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;


@@ -1139,7 +1166,7 @@ mf_marked_p (tree t)
    delayed until program finish time.  If they're still incomplete by
    then, warnings are emitted.  */
 
    delayed until program finish time.  If they're still incomplete by
    then, warnings are emitted.  */
 

-static GTY (()) varray_type deferred_static_decls;
+static GTY (()) VEC(tree,gc) *deferred_static_decls;

 
 /* A list of statements for calling __mf_register() at startup time.  */
 static GTY (()) tree enqueued_call_stmt_chain;
 
 /* A list of statements for calling __mf_register() at startup time.  */
 static GTY (()) tree enqueued_call_stmt_chain;


@@ -1147,21 +1174,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 = convert (ptr_type_node, arg);
 
   arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (obj)), obj);
   arg = convert (ptr_type_node, arg);

-  args = tree_cons (NULL_TREE, arg, args);

 
 

-  call_stmt = build_function_call_expr (mf_register_fndecl, args);
+  call_stmt = build_call_expr (mf_register_fndecl, 4,
+                              arg,
+                              convert (size_type_node, object_size),
+                              /* __MF_TYPE_STATIC */
+                              build_int_cst (NULL_TREE, 4), 
+                              varname);

 
   append_to_statement_list (call_stmt, &enqueued_call_stmt_chain);
 }
 
   append_to_statement_list (call_stmt, &enqueued_call_stmt_chain);
 }


@@ -1180,50 +1203,10 @@ mudflap_enqueue_decl (tree obj)
   if (DECL_P (obj) && DECL_EXTERNAL (obj) && DECL_ARTIFICIAL (obj))
     return;
 
   if (DECL_P (obj) && DECL_EXTERNAL (obj) && DECL_ARTIFICIAL (obj))
     return;
 

-  if (COMPLETE_TYPE_P (TREE_TYPE (obj)))
-    {
-      tree object_size;
-
-      mf_mark (obj);
-
-      object_size = size_in_bytes (TREE_TYPE (obj));
-
-      if (dump_file)
-        {
-          fprintf (dump_file, "enqueue_decl obj=`");
-          print_generic_expr (dump_file, obj, dump_flags);
-          fprintf (dump_file, "' size=");
-          print_generic_expr (dump_file, object_size, dump_flags);
-          fprintf (dump_file, "\n");
-        }
-
-      /* NB: the above condition doesn't require TREE_USED or
-         TREE_ADDRESSABLE.  That's because this object may be a global
-         only used from other compilation units.  XXX: Maybe static
-         objects could require those attributes being set.  */
-
-      mudflap_register_call (obj, object_size, mf_varname_tree (obj));
-    }
-  else
-    {
-      size_t i;
-
-      if (! deferred_static_decls)
-        VARRAY_TREE_INIT (deferred_static_decls, 10, "deferred static list");
-
-      /* Ugh, linear search... */
-      for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_static_decls); i++)
-        if (VARRAY_TREE (deferred_static_decls, i) == obj)
-          {
-            warning ("mudflap cannot track unknown size extern %qs",
-                     IDENTIFIER_POINTER (DECL_NAME (obj)));
-            return;
-          }
-
-      VARRAY_PUSH_TREE (deferred_static_decls, obj);
-    }
+  VEC_safe_push (tree, gc, deferred_static_decls, obj);

 }
 
 }
 

+

 void
 mudflap_enqueue_constant (tree obj)
 {
 void
 mudflap_enqueue_constant (tree obj)
 {


@@ -1237,15 +1220,6 @@ mudflap_enqueue_constant (tree obj)
   else
     object_size = size_in_bytes (TREE_TYPE (obj));
 
   else
     object_size = size_in_bytes (TREE_TYPE (obj));
 

-  if (dump_file)
-    {
-      fprintf (dump_file, "enqueue_constant obj=`");
-      print_generic_expr (dump_file, obj, dump_flags);
-      fprintf (dump_file, "' size=");
-      print_generic_expr (dump_file, object_size, dump_flags);
-      fprintf (dump_file, "\n");
-    }
-

   if (TREE_CODE (obj) == STRING_CST)
     varname = mf_build_string ("string literal");
   else
   if (TREE_CODE (obj) == STRING_CST)
     varname = mf_build_string ("string literal");
   else


@@ -1261,39 +1235,59 @@ mudflap_finish_file (void)
 {
   tree ctor_statements = NULL_TREE;
 
 {
   tree ctor_statements = NULL_TREE;
 

-  /* Try to give the deferred objects one final try.  */
-  if (deferred_static_decls)
-    {
-      size_t i;
-
-      for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_static_decls); i++)
-        {
-          tree obj = VARRAY_TREE (deferred_static_decls, i);
-
-          /* Call enqueue_decl again on the same object it has previously
-             put into the table.  (It won't modify the table this time, so
-             infinite iteration is not a problem.)  */
-          mudflap_enqueue_decl (obj);
-        }
-
-      VARRAY_CLEAR (deferred_static_decls);
-    }
+  /* No need to continue when there were errors.  */
+  if (errorcount != 0 || sorrycount != 0)
+    return;

 
   /* Insert a call to __mf_init.  */
   {
 
   /* 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);
   }
   
   /* If appropriate, call __mf_set_options to pass along read-ignore mode.  */
   if (flag_mudflap_ignore_reads)
     {
     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)
     {

-      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);
     }
 

+  /* Process all enqueued object decls.  */
+  if (deferred_static_decls)
+    {
+      size_t i;
+      tree obj;
+      for (i = 0; VEC_iterate (tree, deferred_static_decls, i, obj); i++)
+        {
+          gcc_assert (DECL_P (obj));
+
+          if (mf_marked_p (obj))
+            continue;
+
+          /* Omit registration for static unaddressed objects.  NB:
+             Perform registration for non-static objects regardless of
+             TREE_USED or TREE_ADDRESSABLE, because they may be used
+             from other compilation units.  */
+          if (! TREE_PUBLIC (obj) && ! TREE_ADDRESSABLE (obj))
+            continue;
+
+          if (! COMPLETE_TYPE_P (TREE_TYPE (obj)))
+            {
+              warning (OPT_Wmudflap,
+                      "mudflap cannot track unknown size extern %qs",
+                       IDENTIFIER_POINTER (DECL_NAME (obj)));
+              continue;
+            }
+          
+          mudflap_register_call (obj, 
+                                 size_in_bytes (TREE_TYPE (obj)),
+                                 mf_varname_tree (obj));
+        }
+
+      VEC_truncate (tree, deferred_static_decls, 0);
+    }
+

   /* Append all the enqueued registration calls.  */
   if (enqueued_call_stmt_chain)
     {
   /* Append all the enqueued registration calls.  */
   if (enqueued_call_stmt_chain)
     {


@@ -1312,8 +1306,10 @@ 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 */
   "mudflap1",                           /* name */
   gate_mudflap,                         /* gate */
   execute_mudflap_function_decls,       /* execute */


@@ -1325,12 +1321,14 @@ struct tree_opt_pass pass_mudflap_1 =
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */

-  TODO_dump_func,                       /* todo_flags_finish */
-  0                                    /* letter */
+  TODO_dump_func                        /* 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 */
   "mudflap2",                           /* name */
   gate_mudflap,                         /* gate */
   execute_mudflap_function_ops,         /* execute */


@@ -1343,8 +1341,8 @@ struct tree_opt_pass pass_mudflap_2 =
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   TODO_verify_flow | TODO_verify_stmts
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   TODO_verify_flow | TODO_verify_stmts

-  | TODO_dump_func,                     /* todo_flags_finish */
-  0                                    /* letter */
+  | TODO_dump_func                      /* todo_flags_finish */
+ }

 };
 
 #include "gt-tree-mudflap.h"
 };
 
 #include "gt-tree-mudflap.h"