Subversion Repositories openrisc

/* Mudflap: narrow-pointer bounds-checking by tree rewriting.

   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>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "tm_p.h"

#include "basic-block.h"

#include "flags.h"

#include "function.h"

#include "tree-inline.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 "demangle.h"

#include "langhooks.h"

#include "ggc.h"

#include "cgraph.h"

#include "gimple.h"

/* 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);

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

static void mf_xform_statements (void);

static unsigned int execute_mudflap_function_ops (void);

/* Addressable variables instrumentation.  */

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

/* 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.  */

/* Build a reference to a literal string.  */

static tree

mf_build_string (const char *string)

{

  size_t len = strlen (string);

  tree result = mf_mark (build_string (len + 1, string));

  TREE_TYPE (result) = build_array_type

    (char_type_node, build_index_type (size_int (len)));

  TREE_CONSTANT (result) = 1;

  TREE_READONLY (result) = 1;

  TREE_STATIC (result) = 1;

  result = build1 (ADDR_EXPR, build_pointer_type (char_type_node), result);

  return mf_mark (result);

}

/* Create a properly typed STRING_CST node that describes the given

   declaration.  It will be used as an argument for __mf_register().

   Try to construct a helpful string, including file/function/variable

   name.  */

static tree

mf_varname_tree (tree decl)

{

  static pretty_printer buf_rec;

  static int initialized = 0;

  pretty_printer *buf = & buf_rec;

  const char *buf_contents;

  tree result;

  gcc_assert (decl);

  if (!initialized)

    {

      pp_construct (buf, /* prefix */ NULL, /* line-width */ 0);

      initialized = 1;

    }

  pp_clear_output_area (buf);

  /* Add FILENAME[:LINENUMBER[:COLUMNNUMBER]].  */

  {

    expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (decl));

    const char *sourcefile;

    unsigned sourceline = xloc.line;

    unsigned sourcecolumn = 0;

    sourcecolumn = xloc.column;

    sourcefile = xloc.file;

    if (sourcefile == NULL && current_function_decl != NULL_TREE)

      sourcefile = DECL_SOURCE_FILE (current_function_decl);

    if (sourcefile == NULL)

      sourcefile = "<unknown file>";

    pp_string (buf, sourcefile);

    if (sourceline != 0)

      {

        pp_string (buf, ":");

        pp_decimal_int (buf, sourceline);

        if (sourcecolumn != 0)

          {

            pp_string (buf, ":");

            pp_decimal_int (buf, sourcecolumn);

          }

      }

  }

  if (current_function_decl != NULL_TREE)

    {

      /* Add (FUNCTION) */

      pp_string (buf, " (");

      {

        const char *funcname = NULL;

        if (DECL_NAME (current_function_decl))

          funcname = lang_hooks.decl_printable_name (current_function_decl, 1);

        if (funcname == NULL)

          funcname = "anonymous fn";

        pp_string (buf, funcname);

      }

      pp_string (buf, ") ");

    }

  else

    pp_string (buf, " ");

  /* Add <variable-declaration>, possibly demangled.  */

  {

    const char *declname = NULL;

    if (DECL_NAME (decl) != NULL)

      {

        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 = "<unnamed variable>";

    pp_string (buf, declname);

  }

  /* Return the lot as a new STRING_CST.  */

  buf_contents = pp_base_formatted_text (buf);

  result = mf_build_string (buf_contents);

  pp_clear_output_area (buf);

  return result;

}

/* And another friend, for producing a simpler message.  */

static tree

mf_file_function_line_tree (location_t location)

{

  expanded_location xloc = expand_location (location);

  const char *file = NULL, *colon, *line, *op, *name, *cp;

  char linecolbuf[30]; /* Enough for two decimal numbers plus a colon.  */

  char *string;

  tree result;

  /* Add FILENAME[:LINENUMBER[:COLUMNNUMBER]].  */

  file = xloc.file;

  if (file == NULL && current_function_decl != NULL_TREE)

    file = DECL_SOURCE_FILE (current_function_decl);

  if (file == NULL)

    file = "<unknown file>";

  if (xloc.line > 0)

    {

      if (xloc.column > 0)

        sprintf (linecolbuf, "%d:%d", xloc.line, xloc.column);

      else

        sprintf (linecolbuf, "%d", xloc.line);

      colon = ":";

      line = linecolbuf;

    }

  else

    colon = line = "";

  /* Add (FUNCTION).  */

  name = lang_hooks.decl_printable_name (current_function_decl, 1);

  if (name)

    {

      op = " (";

      cp = ")";

    }

  else

    op = name = cp = "";

  string = concat (file, colon, line, op, name, cp, NULL);

  result = mf_build_string (string);

  free (string);

  return result;

}

/* global tree nodes */

/* Global tree objects for global variables and functions exported by

   mudflap runtime library.  mf_init_extern_trees must be called

   before using these.  */

/* uintptr_t (usually "unsigned long") */

static GTY (()) tree mf_uintptr_type;

/* struct __mf_cache { uintptr_t low; uintptr_t high; }; */

static GTY (()) tree mf_cache_struct_type;

/* struct __mf_cache * const */

static GTY (()) tree mf_cache_structptr_type;

/* extern struct __mf_cache __mf_lookup_cache []; */

static GTY (()) tree mf_cache_array_decl;

/* extern unsigned char __mf_lc_shift; */

static GTY (()) tree mf_cache_shift_decl;

/* extern uintptr_t __mf_lc_mask; */

static GTY (()) tree mf_cache_mask_decl;

/* Their function-scope local shadows, used in single-threaded mode only.  */

/* auto const unsigned char __mf_lc_shift_l; */

static GTY (()) tree mf_cache_shift_decl_l;

/* auto const uintptr_t __mf_lc_mask_l; */

static GTY (()) tree mf_cache_mask_decl_l;

/* extern void __mf_check (void *ptr, size_t sz, int type, const char *); */

static GTY (()) tree mf_check_fndecl;

/* extern void __mf_register (void *ptr, size_t sz, int type, const char *); */

static GTY (()) tree mf_register_fndecl;

/* extern void __mf_unregister (void *ptr, size_t sz, int type); */

static GTY (()) tree mf_unregister_fndecl;

/* extern void __mf_init (); */

static GTY (()) tree mf_init_fndecl;

/* extern int __mf_set_options (const char*); */

static GTY (()) tree mf_set_options_fndecl;

/* Helper for mudflap_init: construct a decl with the given category,

   name, and type, mark it an external reference, and pushdecl it.  */

static inline tree

mf_make_builtin (enum tree_code category, const char *name, tree 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);

  /* 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;

}

/* Helper for mudflap_init: construct a tree corresponding to the type

     struct __mf_cache { uintptr_t low; uintptr_t high; };

     where uintptr_t is the FIELD_TYPE argument.  */

static inline tree

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.  */

  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;

  DECL_CHAIN (fieldlo) = fieldhi;

  TYPE_FIELDS (struct_type) = fieldlo;

  TYPE_NAME (struct_type) = get_identifier ("__mf_cache");

  layout_type (struct_type);

  return struct_type;

}

/* Initialize the global tree nodes that correspond to mf-runtime.h

   declarations.  */

void

mudflap_init (void)

{

  static bool done = false;

  tree mf_const_string_type;

  tree mf_cache_array_type;

  tree mf_check_register_fntype;

  tree mf_unregister_fntype;

  tree mf_init_fntype;

  tree mf_set_options_fntype;

  if (done)

    return;

  done = true;

  mf_uintptr_type = lang_hooks.types.type_for_mode (ptr_mode,

                                                    /*unsignedp=*/true);

  mf_const_string_type

    = build_pointer_type (build_qualified_type

                          (char_type_node, TYPE_QUAL_CONST));

  mf_cache_struct_type = mf_make_mf_cache_struct_type (mf_uintptr_type);

  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_list (void_type_node, ptr_type_node, size_type_node,

                              integer_type_node, mf_const_string_type, NULL_TREE);

  mf_unregister_fntype =

    build_function_type_list (void_type_node, ptr_type_node, size_type_node,

                              integer_type_node, NULL_TREE);

  mf_init_fntype =

    build_function_type_list (void_type_node, NULL_TREE);

  mf_set_options_fntype =

    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_shift_decl = mf_make_builtin (VAR_DECL, "__mf_lc_shift",

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

  mf_unregister_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_unregister",

                                          mf_unregister_fntype);

  mf_init_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_init",

                                    mf_init_fntype);

  mf_set_options_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_set_options",

                                           mf_set_options_fntype);

}

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

/* 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

   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)

{

  struct gimplify_ctx gctx;

  /* Don't instrument functions such as the synthetic constructor

     built during mudflap_finish_file.  */

  if (mf_marked_p (current_function_decl)

      || mf_artificial (current_function_decl))

    return 0;

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

  mf_xform_statements ();

  if (! flag_mudflap_threads)

    mf_decl_clear_locals ();

  pop_gimplify_context (NULL);

  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.  */

static void

mf_decl_cache_locals (void)

{

  gimple g;

  gimple_seq seq = gimple_seq_alloc ();

  /* Build the cache vars.  */

  mf_cache_shift_decl_l

    = mf_mark (make_rename_temp (TREE_TYPE (mf_cache_shift_decl),

                               "__mf_lookup_shift_l"));

  mf_cache_mask_decl_l

    = 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.  */

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

}

static void

mf_decl_clear_locals (void)

{

  /* Unset local shadows.  */

  mf_cache_shift_decl_l = NULL_TREE;

  mf_cache_mask_decl_l = NULL_TREE;

}

static void

mf_build_check_statement_for (tree base, tree limit,

                              gimple_stmt_iterator *instr_gsi,

                              location_t location, tree dirflag)

{

  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;

  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.  */

  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;

  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

     end of which will contain the cache-lookup code, and a

     conditional that jumps to the cache-miss code or, much more

     likely, over to join_bb.  */

  /* Create the bb that contains the cache-miss fallback block (mf_check).  */

  then_bb = create_empty_bb (cond_bb);

  make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);

  make_single_succ_edge (then_bb, join_bb, EDGE_FALLTHRU);

  /* Mark the pseudo-fallthrough edge from cond_bb to join_bb.  */

  e = find_edge (cond_bb, join_bb);

  e->flags = EDGE_FALSE_VALUE;

  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.  */

  if (dom_info_available_p (CDI_DOMINATORS))

    {

      set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);

      set_immediate_dominator (CDI_DOMINATORS, join_bb, cond_bb);

    }

  /* Build our local variables.  */

  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>.  */

  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>.  */

  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,

              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 = 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.

     if (__mf_elem->low > __mf_base

         || (__mf_elem_high < __mf_limit))

        {

          __mf_check ();

          ... and only if single-threaded:

          __mf_lookup_shift_1 = f...;

          __mf_lookup_mask_l = ...;

        }

     It is expected that this body of code is rarely executed so we mark

     the edge to the THEN clause of the conditional jump as unlikely.  */

  /* Construct t <-- '__mf_elem->low  > __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'.

     First build:

        1) u <--  '__mf_elem->high'

        2) v <--  '__mf_limit'.

     Then build 'u <-- (u < v).  */

  u = build3 (COMPONENT_REF, mf_uintptr_type,

              build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),

              DECL_CHAIN (TYPE_FIELDS (mf_cache_struct_type)), NULL_TREE);

  v = mf_limit;

  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.  */

  t = build2 (TRUTH_OR_EXPR, boolean_type_node, t, u);

  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.  */

  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,

     if (__mf_elem->low > __mf_base

         || (__mf_elem_high < __mf_limit))

     The lowered GIMPLE tree representing this code is in the statement

     list starting at 'head'.

     We can insert this now in the current basic block, i.e. the one that

     the statement we're instrumenting was originally in.  */

  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:

     __mf_check();

     refresh *_l vars.

     This is the body of the conditional.  */

  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.  */

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