gcc/gimple-ssa-isolate-paths.c

   1 /* Detect paths through the CFG which can never be executed in a conforming
   2    program and isolate them.
   3
   4    Copyright (C) 2013
   5    Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tree.h"
  27 #include "flags.h"
  28 #include "basic-block.h"
  29 #include "gimple.h"
  30 #include "gimple-iterator.h"
  31 #include "gimple-walk.h"
  32 #include "tree-ssa.h"
  33 #include "tree-ssanames.h"
  34 #include "gimple-ssa.h"
  35 #include "tree-ssa-operands.h"
  36 #include "tree-phinodes.h"
  37 #include "ssa-iterators.h"
  38 #include "cfgloop.h"
  39 #include "tree-pass.h"
  40
  41
  42 static bool cfg_altered;
  43
  44 /* Callback for walk_stmt_load_store_ops.
  45
  46    Return TRUE if OP will dereference the tree stored in DATA, FALSE
  47    otherwise.
  48
  49    This routine only makes a superficial check for a dereference.  Thus,
  50    it must only be used if it is safe to return a false negative.  */
  51 static bool
  52 check_loadstore (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
  53 {
  54   if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
  55       && operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0))
  56     {
  57       TREE_THIS_VOLATILE (op) = 1;
  58       TREE_SIDE_EFFECTS (op) = 1;
  59       update_stmt (stmt);
  60       return true;
  61     }
  62   return false;
  63 }
  64
  65 /* Insert a trap after SI and remove SI and all statements after the trap.  */
  66
  67 static void
  68 insert_trap_and_remove_trailing_statements (gimple_stmt_iterator *si_p, tree op)
  69 {
  70   /* We want the NULL pointer dereference to actually occur so that
  71      code that wishes to catch the signal can do so.
  72
  73      If the dereference is a load, then there's nothing to do as the
  74      LHS will be a throw-away SSA_NAME and the RHS is the NULL dereference.
  75
  76      If the dereference is a store and we can easily transform the RHS,
  77      then simplify the RHS to enable more DCE.   Note that we require the
  78      statement to be a GIMPLE_ASSIGN which filters out calls on the RHS.  */
  79   gimple stmt = gsi_stmt (*si_p);
  80   if (walk_stmt_load_store_ops (stmt, (void *)op, NULL, check_loadstore)
  81       && is_gimple_assign (stmt)
  82       && INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
  83     {
  84       /* We just need to turn the RHS into zero converted to the proper
  85          type.  */
  86       tree type = TREE_TYPE (gimple_assign_lhs (stmt));
  87       gimple_assign_set_rhs_code (stmt, INTEGER_CST);
  88       gimple_assign_set_rhs1 (stmt, fold_convert (type, integer_zero_node));
  89       update_stmt (stmt);
  90     }
  91
  92   gimple new_stmt
  93     = gimple_build_call (builtin_decl_explicit (BUILT_IN_TRAP), 0);
  94   gimple_seq seq = NULL;
  95   gimple_seq_add_stmt (&seq, new_stmt);
  96
  97   /* If we had a NULL pointer dereference, then we want to insert the
  98      __builtin_trap after the statement, for the other cases we want
  99      to insert before the statement.  */
 100   if (walk_stmt_load_store_ops (stmt, (void *)op,
 101                                 check_loadstore,
 102                                 check_loadstore))
 103     gsi_insert_after (si_p, seq, GSI_NEW_STMT);
 104   else
 105     gsi_insert_before (si_p, seq, GSI_NEW_STMT);
 106
 107   /* We must remove statements from the end of the block so that we
 108      never reference a released SSA_NAME.  */
 109   basic_block bb = gimple_bb (gsi_stmt (*si_p));
 110   for (gimple_stmt_iterator si = gsi_last_bb (bb);
 111        gsi_stmt (si) != gsi_stmt (*si_p);
 112        si = gsi_last_bb (bb))
 113     {
 114       stmt = gsi_stmt (si);
 115       unlink_stmt_vdef (stmt);
 116       gsi_remove (&si, true);
 117       release_defs (stmt);
 118     }
 119 }
 120
 121 /* BB when reached via incoming edge E will exhibit undefined behaviour
 122    at STMT.  Isolate and optimize the path which exhibits undefined
 123    behaviour.
 124
 125    Isolation is simple.  Duplicate BB and redirect E to BB'.
 126
 127    Optimization is simple as well.  Replace STMT in BB' with an
 128    unconditional trap and remove all outgoing edges from BB'.
 129
 130    DUPLICATE is a pre-existing duplicate, use it as BB' if it exists.
 131
 132    Return BB'.  */
 133
 134 basic_block
 135 isolate_path (basic_block bb, basic_block duplicate,
 136               edge e, gimple stmt, tree op)
 137 {
 138   gimple_stmt_iterator si, si2;
 139   edge_iterator ei;
 140   edge e2;
 141
 142
 143   /* First duplicate BB if we have not done so already and remove all
 144      the duplicate's outgoing edges as duplicate is going to unconditionally
 145      trap.  Removing the outgoing edges is both an optimization and ensures
 146      we don't need to do any PHI node updates.  */
 147   if (!duplicate)
 148     {
 149       duplicate = duplicate_block (bb, NULL, NULL);
 150       for (ei = ei_start (duplicate->succs); (e2 = ei_safe_edge (ei)); )
 151         remove_edge (e2);
 152     }
 153
 154   /* Complete the isolation step by redirecting E to reach DUPLICATE.  */
 155   e2 = redirect_edge_and_branch (e, duplicate);
 156   if (e2)
 157     flush_pending_stmts (e2);
 158
 159
 160   /* There may be more than one statement in DUPLICATE which exhibits
 161      undefined behaviour.  Ultimately we want the first such statement in
 162      DUPLCIATE so that we're able to delete as much code as possible.
 163
 164      So each time we discover undefined behaviour in DUPLICATE, search for
 165      the statement which triggers undefined behaviour.  If found, then
 166      transform the statement into a trap and delete everything after the
 167      statement.  If not found, then this particular instance was subsumed by
 168      an earlier instance of undefined behaviour and there's nothing to do.
 169
 170      This is made more complicated by the fact that we have STMT, which is in
 171      BB rather than in DUPLICATE.  So we set up two iterators, one for each
 172      block and walk forward looking for STMT in BB, advancing each iterator at
 173      each step.
 174
 175      When we find STMT the second iterator should point to STMT's equivalent in
 176      duplicate.  If DUPLICATE ends before STMT is found in BB, then there's
 177      nothing to do.
 178
 179      Ignore labels and debug statements.  */
 180   si = gsi_start_nondebug_after_labels_bb (bb);
 181   si2 = gsi_start_nondebug_after_labels_bb (duplicate);
 182   while (!gsi_end_p (si) && !gsi_end_p (si2) && gsi_stmt (si) != stmt)
 183     {
 184       gsi_next_nondebug (&si);
 185       gsi_next_nondebug (&si2);
 186     }
 187
 188   /* This would be an indicator that we never found STMT in BB, which should
 189      never happen.  */
 190   gcc_assert (!gsi_end_p (si));
 191
 192   /* If we did not run to the end of DUPLICATE, then SI points to STMT and
 193      SI2 points to the duplicate of STMT in DUPLICATE.  Insert a trap
 194      before SI2 and remove SI2 and all trailing statements.  */
 195   if (!gsi_end_p (si2))
 196     insert_trap_and_remove_trailing_statements (&si2, op);
 197
 198   return duplicate;
 199 }
 200
 201 /* Look for PHI nodes which feed statements in the same block where
 202    the value of the PHI node implies the statement is erroneous.
 203
 204    For example, a NULL PHI arg value which then feeds a pointer
 205    dereference.
 206
 207    When found isolate and optimize the path associated with the PHI
 208    argument feeding the erroneous statement.  */
 209 static void
 210 find_implicit_erroneous_behaviour (void)
 211 {
 212   basic_block bb;
 213
 214   FOR_EACH_BB (bb)
 215     {
 216       gimple_stmt_iterator si;
 217
 218       /* First look for a PHI which sets a pointer to NULL and which
 219          is then dereferenced within BB.  This is somewhat overly
 220          conservative, but probably catches most of the interesting
 221          cases.   */
 222       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 223         {
 224           gimple phi = gsi_stmt (si);
 225           tree lhs = gimple_phi_result (phi);
 226
 227           /* If the result is not a pointer, then there is no need to
 228              examine the arguments.  */
 229           if (!POINTER_TYPE_P (TREE_TYPE (lhs)))
 230             continue;
 231
 232           /* PHI produces a pointer result.  See if any of the PHI's
 233              arguments are NULL.
 234
 235              When we remove an edge, we want to reprocess the current
 236              index, hence the ugly way we update I for each iteration.  */
 237           basic_block duplicate = NULL;
 238           for (unsigned i = 0, next_i = 0;
 239                i < gimple_phi_num_args (phi);
 240                i = next_i)
 241             {
 242               tree op = gimple_phi_arg_def (phi, i);
 243
 244               next_i = i + 1;
 245
 246               if (!integer_zerop (op))
 247                 continue;
 248
 249               edge e = gimple_phi_arg_edge (phi, i);
 250               imm_use_iterator iter;
 251               gimple use_stmt;
 252
 253               /* We've got a NULL PHI argument.  Now see if the
 254                  PHI's result is dereferenced within BB.  */
 255               FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
 256                 {
 257                   /* We only care about uses in BB.  Catching cases in
 258                      in other blocks would require more complex path
 259                      isolation code.  */
 260                   if (gimple_bb (use_stmt) != bb)
 261                     continue;
 262
 263                   if (infer_nonnull_range (use_stmt, lhs))
 264                     {
 265                       duplicate = isolate_path (bb, duplicate,
 266                                                 e, use_stmt, lhs);
 267
 268                       /* When we remove an incoming edge, we need to
 269                          reprocess the Ith element.  */
 270                       next_i = i;
 271                       cfg_altered = true;
 272                     }
 273                 }
 274             }
 275         }
 276     }
 277 }
 278
 279 /* Look for statements which exhibit erroneous behaviour.  For example
 280    a NULL pointer dereference.
 281
 282    When found, optimize the block containing the erroneous behaviour.  */
 283 static void
 284 find_explicit_erroneous_behaviour (void)
 285 {
 286   basic_block bb;
 287
 288   FOR_EACH_BB (bb)
 289     {
 290       gimple_stmt_iterator si;
 291
 292       /* Now look at the statements in the block and see if any of
 293          them explicitly dereference a NULL pointer.  This happens
 294          because of jump threading and constant propagation.  */
 295       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 296         {
 297           gimple stmt = gsi_stmt (si);
 298
 299           /* By passing null_pointer_node, we can use infer_nonnull_range
 300              to detect explicit NULL pointer dereferences and other uses
 301              where a non-NULL value is required.  */
 302           if (infer_nonnull_range (stmt, null_pointer_node))
 303             {
 304               insert_trap_and_remove_trailing_statements (&si,
 305                                                           null_pointer_node);
 306
 307               /* And finally, remove all outgoing edges from BB.  */
 308               edge e;
 309               for (edge_iterator ei = ei_start (bb->succs);
 310                    (e = ei_safe_edge (ei)); )
 311                 remove_edge (e);
 312
 313               /* Ignore any more operands on this statement and
 314                  continue the statement iterator (which should
 315                  terminate its loop immediately.  */
 316               cfg_altered = true;
 317               break;
 318             }
 319         }
 320     }
 321 }
 322 /* Search the function for statements which, if executed, would cause
 323    the program to fault such as a dereference of a NULL pointer.
 324
 325    Such a program can't be valid if such a statement was to execute
 326    according to ISO standards.
 327
 328    We detect explicit NULL pointer dereferences as well as those implied
 329    by a PHI argument having a NULL value which unconditionally flows into
 330    a dereference in the same block as the PHI.
 331
 332    In the former case we replace the offending statement with an
 333    unconditional trap and eliminate the outgoing edges from the statement's
 334    basic block.  This may expose secondary optimization opportunities.
 335
 336    In the latter case, we isolate the path(s) with the NULL PHI
 337    feeding the dereference.  We can then replace the offending statement
 338    and eliminate the outgoing edges in the duplicate.  Again, this may
 339    expose secondary optimization opportunities.
 340
 341    A warning for both cases may be advisable as well.
 342
 343    Other statically detectable violations of the ISO standard could be
 344    handled in a similar way, such as out-of-bounds array indexing.  */
 345
 346 static unsigned int
 347 gimple_ssa_isolate_erroneous_paths (void)
 348 {
 349   initialize_original_copy_tables ();
 350
 351   /* Search all the blocks for edges which, if traversed, will
 352      result in undefined behaviour.  */
 353   cfg_altered = false;
 354
 355   /* First handle cases where traversal of a particular edge
 356      triggers undefined behaviour.  These cases require creating
 357      duplicate blocks and thus new SSA_NAMEs.
 358
 359      We want that process complete prior to the phase where we start
 360      removing edges from the CFG.  Edge removal may ultimately result in
 361      removal of PHI nodes and thus releasing SSA_NAMEs back to the
 362      name manager.
 363
 364      If the two processes run in parallel we could release an SSA_NAME
 365      back to the manager but we could still have dangling references
 366      to the released SSA_NAME in unreachable blocks.
 367      that any released names not have dangling references in the IL.  */
 368   find_implicit_erroneous_behaviour ();
 369   find_explicit_erroneous_behaviour ();
 370
 371   free_original_copy_tables ();
 372
 373   /* We scramble the CFG and loop structures a bit, clean up
 374      appropriately.  We really should incrementally update the
 375      loop structures, in theory it shouldn't be that hard.  */
 376   if (cfg_altered)
 377     {
 378       free_dominance_info (CDI_DOMINATORS);
 379       free_dominance_info (CDI_POST_DOMINATORS);
 380       loops_state_set (LOOPS_NEED_FIXUP);
 381       return TODO_cleanup_cfg | TODO_update_ssa;
 382     }
 383   return 0;
 384 }
 385
 386 static bool
 387 gate_isolate_erroneous_paths (void)
 388 {
 389   /* If we do not have a suitable builtin function for the trap statement,
 390      then do not perform the optimization.  */
 391   return (flag_isolate_erroneous_paths != 0);
 392 }
 393
 394 namespace {
 395 const pass_data pass_data_isolate_erroneous_paths =
 396 {
 397   GIMPLE_PASS, /* type */
 398   "isolate-paths", /* name */
 399   OPTGROUP_NONE, /* optinfo_flags */
 400   true, /* has_gate */
 401   true, /* has_execute */
 402   TV_ISOLATE_ERRONEOUS_PATHS, /* tv_id */
 403   ( PROP_cfg | PROP_ssa ), /* properties_required */
 404   0, /* properties_provided */
 405   0, /* properties_destroyed */
 406   0, /* todo_flags_start */
 407   TODO_verify_ssa, /* todo_flags_finish */
 408 };
 409
 410 class pass_isolate_erroneous_paths : public gimple_opt_pass
 411 {
 412 public:
 413   pass_isolate_erroneous_paths (gcc::context *ctxt)
 414     : gimple_opt_pass (pass_data_isolate_erroneous_paths, ctxt)
 415   {}
 416
 417   /* opt_pass methods: */
 418   opt_pass * clone () { return new pass_isolate_erroneous_paths (m_ctxt); }
 419   bool gate () { return gate_isolate_erroneous_paths (); }
 420   unsigned int execute () { return gimple_ssa_isolate_erroneous_paths (); }
 421
 422 }; // class pass_isolate_erroneous_paths
 423 }
 424
 425 gimple_opt_pass *
 426 make_pass_isolate_erroneous_paths (gcc::context *ctxt)
 427 {
 428   return new pass_isolate_erroneous_paths (ctxt);
 429 }