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 "tree-ssa.h"
  31 #include "tree-ssanames.h"
  32 #include "gimple-ssa.h"
  33 #include "tree-ssa-operands.h"
  34 #include "tree-phinodes.h"
  35 #include "ssa-iterators.h"
  36 #include "cfgloop.h"
  37 #include "tree-pass.h"
  38
  39
  40 static bool cfg_altered;
  41
  42 /* Callback for walk_stmt_load_store_ops.
  43
  44    Return TRUE if OP will dereference the tree stored in DATA, FALSE
  45    otherwise.
  46
  47    This routine only makes a superficial check for a dereference.  Thus,
  48    it must only be used if it is safe to return a false negative.  */
  49 static bool
  50 check_loadstore (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
  51 {
  52   if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
  53       && operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0))
  54     {
  55       TREE_THIS_VOLATILE (op) = 1;
  56       TREE_SIDE_EFFECTS (op) = 1;
  57       update_stmt (stmt);
  58       return true;
  59     }
  60   return false;
  61 }
  62
  63 /* Insert a trap after SI and remove SI and all statements after the trap.  */
  64
  65 static void
  66 insert_trap_and_remove_trailing_statements (gimple_stmt_iterator *si_p, tree op)
  67 {
  68   /* We want the NULL pointer dereference to actually occur so that
  69      code that wishes to catch the signal can do so.
  70
  71      If the dereference is a load, then there's nothing to do as the
  72      LHS will be a throw-away SSA_NAME and the RHS is the NULL dereference.
  73
  74      If the dereference is a store and we can easily transform the RHS,
  75      then simplify the RHS to enable more DCE.  */
  76   gimple stmt = gsi_stmt (*si_p);
  77   if (walk_stmt_load_store_ops (stmt, (void *)op, NULL, check_loadstore)
  78       && INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
  79     {
  80       /* We just need to turn the RHS into zero converted to the proper
  81          type.  */
  82       tree type = TREE_TYPE (gimple_assign_lhs (stmt));
  83       gimple_assign_set_rhs_code (stmt, INTEGER_CST);
  84       gimple_assign_set_rhs1 (stmt, fold_convert (type, integer_zero_node));
  85       update_stmt (stmt);
  86     }
  87
  88   gimple new_stmt
  89     = gimple_build_call (builtin_decl_explicit (BUILT_IN_TRAP), 0);
  90   gimple_seq seq = NULL;
  91   gimple_seq_add_stmt (&seq, new_stmt);
  92
  93   /* If we had a NULL pointer dereference, then we want to insert the
  94      __builtin_trap after the statement, for the other cases we want
  95      to insert before the statement.  */
  96   if (walk_stmt_load_store_ops (stmt, (void *)op,
  97                                 check_loadstore,
  98                                 check_loadstore))
  99     gsi_insert_after (si_p, seq, GSI_NEW_STMT);
 100   else
 101     gsi_insert_before (si_p, seq, GSI_NEW_STMT);
 102
 103   /* The iterator points to the __builtin_trap.  Advance the iterator
 104      and delete everything else in the block.  */
 105   gsi_next (si_p);
 106   for (; !gsi_end_p (*si_p);)
 107     {
 108       stmt = gsi_stmt (*si_p);
 109       unlink_stmt_vdef (stmt);
 110       gsi_remove (si_p, true);
 111       release_defs (stmt);
 112     }
 113 }
 114
 115 /* BB when reached via incoming edge E will exhibit undefined behaviour
 116    at STMT.  Isolate and optimize the path which exhibits undefined
 117    behaviour.
 118
 119    Isolation is simple.  Duplicate BB and redirect E to BB'.
 120
 121    Optimization is simple as well.  Replace STMT in BB' with an
 122    unconditional trap and remove all outgoing edges from BB'.
 123
 124    DUPLICATE is a pre-existing duplicate, use it as BB' if it exists.
 125
 126    Return BB'.  */
 127
 128 basic_block
 129 isolate_path (basic_block bb, basic_block duplicate,
 130               edge e, gimple stmt, tree op)
 131 {
 132   gimple_stmt_iterator si, si2;
 133   edge_iterator ei;
 134   edge e2;
 135
 136
 137   /* First duplicate BB if we have not done so already and remove all
 138      the duplicate's outgoing edges as duplicate is going to unconditionally
 139      trap.  Removing the outgoing edges is both an optimization and ensures
 140      we don't need to do any PHI node updates.  */
 141   if (!duplicate)
 142     {
 143       duplicate = duplicate_block (bb, NULL, NULL);
 144       for (ei = ei_start (duplicate->succs); (e2 = ei_safe_edge (ei)); )
 145         remove_edge (e2);
 146     }
 147
 148   /* Complete the isolation step by redirecting E to reach DUPLICATE.  */
 149   e2 = redirect_edge_and_branch (e, duplicate);
 150   if (e2)
 151     flush_pending_stmts (e2);
 152
 153
 154   /* There may be more than one statement in DUPLICATE which exhibits
 155      undefined behaviour.  Ultimately we want the first such statement in
 156      DUPLCIATE so that we're able to delete as much code as possible.
 157
 158      So each time we discover undefined behaviour in DUPLICATE, search for
 159      the statement which triggers undefined behaviour.  If found, then
 160      transform the statement into a trap and delete everything after the
 161      statement.  If not found, then this particular instance was subsumed by
 162      an earlier instance of undefined behaviour and there's nothing to do.
 163
 164      This is made more complicated by the fact that we have STMT, which is in
 165      BB rather than in DUPLICATE.  So we set up two iterators, one for each
 166      block and walk forward looking for STMT in BB, advancing each iterator at
 167      each step.
 168
 169      When we find STMT the second iterator should point to STMT's equivalent in
 170      duplicate.  If DUPLICATE ends before STMT is found in BB, then there's
 171      nothing to do.
 172
 173      Ignore labels and debug statements.  */
 174   si = gsi_start_nondebug_after_labels_bb (bb);
 175   si2 = gsi_start_nondebug_after_labels_bb (duplicate);
 176   while (!gsi_end_p (si) && !gsi_end_p (si2) && gsi_stmt (si) != stmt)
 177     {
 178       gsi_next_nondebug (&si);
 179       gsi_next_nondebug (&si2);
 180     }
 181
 182   /* This would be an indicator that we never found STMT in BB, which should
 183      never happen.  */
 184   gcc_assert (!gsi_end_p (si));
 185
 186   /* If we did not run to the end of DUPLICATE, then SI points to STMT and
 187      SI2 points to the duplicate of STMT in DUPLICATE.  Insert a trap
 188      before SI2 and remove SI2 and all trailing statements.  */
 189   if (!gsi_end_p (si2))
 190     insert_trap_and_remove_trailing_statements (&si2, op);
 191
 192   return duplicate;
 193 }
 194
 195 /* Search the function for statements which, if executed, would cause
 196    the program to fault such as a dereference of a NULL pointer.
 197
 198    Such a program can't be valid if such a statement was to execute
 199    according to ISO standards.
 200
 201    We detect explicit NULL pointer dereferences as well as those implied
 202    by a PHI argument having a NULL value which unconditionally flows into
 203    a dereference in the same block as the PHI.
 204
 205    In the former case we replace the offending statement with an
 206    unconditional trap and eliminate the outgoing edges from the statement's
 207    basic block.  This may expose secondary optimization opportunities.
 208
 209    In the latter case, we isolate the path(s) with the NULL PHI
 210    feeding the dereference.  We can then replace the offending statement
 211    and eliminate the outgoing edges in the duplicate.  Again, this may
 212    expose secondary optimization opportunities.
 213
 214    A warning for both cases may be advisable as well.
 215
 216    Other statically detectable violations of the ISO standard could be
 217    handled in a similar way, such as out-of-bounds array indexing.  */
 218
 219 static unsigned int
 220 gimple_ssa_isolate_erroneous_paths (void)
 221 {
 222   basic_block bb;
 223
 224   initialize_original_copy_tables ();
 225
 226   /* Search all the blocks for edges which, if traversed, will
 227      result in undefined behaviour.  */
 228   cfg_altered = false;
 229   FOR_EACH_BB (bb)
 230     {
 231       gimple_stmt_iterator si;
 232
 233       /* First look for a PHI which sets a pointer to NULL and which
 234          is then dereferenced within BB.  This is somewhat overly
 235          conservative, but probably catches most of the interesting
 236          cases.   */
 237       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 238         {
 239           gimple phi = gsi_stmt (si);
 240           tree lhs = gimple_phi_result (phi);
 241
 242           /* If the result is not a pointer, then there is no need to
 243              examine the arguments.  */
 244           if (!POINTER_TYPE_P (TREE_TYPE (lhs)))
 245             continue;
 246
 247           /* PHI produces a pointer result.  See if any of the PHI's
 248              arguments are NULL.
 249
 250              When we remove an edge, we want to reprocess the current
 251              index, hence the ugly way we update I for each iteration.  */
 252           basic_block duplicate = NULL;
 253           for (unsigned i = 0, next_i = 0;
 254                i < gimple_phi_num_args (phi);
 255                i = next_i)
 256             {
 257               tree op = gimple_phi_arg_def (phi, i);
 258
 259               next_i = i + 1;
 260
 261               if (!integer_zerop (op))
 262                 continue;
 263
 264               edge e = gimple_phi_arg_edge (phi, i);
 265               imm_use_iterator iter;
 266               gimple use_stmt;
 267
 268               /* We've got a NULL PHI argument.  Now see if the
 269                  PHI's result is dereferenced within BB.  */
 270               FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
 271                 {
 272                   /* We only care about uses in BB.  Catching cases in
 273                      in other blocks would require more complex path
 274                      isolation code.  */
 275                   if (gimple_bb (use_stmt) != bb)
 276                     continue;
 277
 278                   if (infer_nonnull_range (use_stmt, lhs))
 279                     {
 280                       duplicate = isolate_path (bb, duplicate,
 281                                                 e, use_stmt, lhs);
 282
 283                       /* When we remove an incoming edge, we need to
 284                          reprocess the Ith element.  */
 285                       next_i = i;
 286                       cfg_altered = true;
 287                     }
 288                 }
 289             }
 290         }
 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   free_original_copy_tables ();
 322
 323   /* We scramble the CFG and loop structures a bit, clean up
 324      appropriately.  We really should incrementally update the
 325      loop structures, in theory it shouldn't be that hard.  */
 326   if (cfg_altered)
 327     {
 328       free_dominance_info (CDI_DOMINATORS);
 329       free_dominance_info (CDI_POST_DOMINATORS);
 330       loops_state_set (LOOPS_NEED_FIXUP);
 331       return TODO_cleanup_cfg | TODO_update_ssa;
 332     }
 333   return 0;
 334 }
 335
 336 static bool
 337 gate_isolate_erroneous_paths (void)
 338 {
 339   /* If we do not have a suitable builtin function for the trap statement,
 340      then do not perform the optimization.  */
 341   return (flag_isolate_erroneous_paths != 0);
 342 }
 343
 344 namespace {
 345 const pass_data pass_data_isolate_erroneous_paths =
 346 {
 347   GIMPLE_PASS, /* type */
 348   "isolate-paths", /* name */
 349   OPTGROUP_NONE, /* optinfo_flags */
 350   true, /* has_gate */
 351   true, /* has_execute */
 352   TV_ISOLATE_ERRONEOUS_PATHS, /* tv_id */
 353   ( PROP_cfg | PROP_ssa ), /* properties_required */
 354   0, /* properties_provided */
 355   0, /* properties_destroyed */
 356   0, /* todo_flags_start */
 357   TODO_verify_ssa, /* todo_flags_finish */
 358 };
 359
 360 class pass_isolate_erroneous_paths : public gimple_opt_pass
 361 {
 362 public:
 363   pass_isolate_erroneous_paths (gcc::context *ctxt)
 364     : gimple_opt_pass (pass_data_isolate_erroneous_paths, ctxt)
 365   {}
 366
 367   /* opt_pass methods: */
 368   opt_pass * clone () { return new pass_isolate_erroneous_paths (m_ctxt); }
 369   bool gate () { return gate_isolate_erroneous_paths (); }
 370   unsigned int execute () { return gimple_ssa_isolate_erroneous_paths (); }
 371
 372 }; // class pass_uncprop
 373 }
 374
 375 gimple_opt_pass *
 376 make_pass_isolate_erroneous_paths (gcc::context *ctxt)
 377 {
 378   return new pass_isolate_erroneous_paths (ctxt);
 379 }