Check for a NULL value before passing it to a function that assumes non-NULL.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/hash_map.h"
@@ skipping 1442 matching lines @@
       return new Range(RangeBoundary::FromDefinition(boundary),
                        RangeBoundary::MaxSmi());
     default:
       UNREACHABLE();
       return Range::Unknown();
   }
 }
 
 
 ConstraintInstr* RangeAnalysis::InsertConstraintFor(Definition* defn,
-                                                Range* constraint_range,
-                                                Instruction* after) {
+                                                    Range* constraint_range,
+                                                    Instruction* after) {
   // No need to constrain constants.
   if (defn->IsConstant()) return NULL;
 
   ConstraintInstr* constraint =
       new ConstraintInstr(new Value(defn), constraint_range);
   constraint->InsertAfter(after);
   constraint->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
   RenameDominatedUses(defn, after, constraint);
   constraints_.Add(constraint);
   constraint->value()->set_instruction(constraint);
@@ skipping 22 matching lines @@
           ASSERT(use->use_index() == 1);  // Right operand.
           boundary = rel_op->InputAt(0)->definition();
           // InsertConstraintFor assumes that defn is left operand of a
           // comparison if it is right operand flip the comparison.
           op_kind = FlipComparison(rel_op->kind());
         }
 
         // Constrain definition at the true successor.
         ConstraintInstr* true_constraint =
             InsertConstraintFor(defn,
-                            ConstraintRange(op_kind, boundary),
-                            branch->true_successor());
+                                ConstraintRange(op_kind, boundary),
+                                branch->true_successor());
         // Mark true_constraint an artificial use of boundary. This ensures
         // that constraint's range is recalculated if boundary's range changes.
         if (true_constraint != NULL) true_constraint->AddDependency(boundary);
 
         // Constrain definition with a negated condition at the false successor.
         ConstraintInstr* false_constraint =
             InsertConstraintFor(
                 defn,
                 ConstraintRange(NegateComparison(op_kind), boundary),
                 branch->false_successor());
         // Mark false_constraint an artificial use of boundary. This ensures
         // that constraint's range is recalculated if boundary's range changes.
         if (false_constraint != NULL) false_constraint->AddDependency(boundary);
       }
     }
   }
 }
 
 
 void RangeAnalysis::InsertConstraints() {
   for (intptr_t i = 0; i < smi_checks_.length(); i++) {
     CheckSmiInstr* check = smi_checks_[i];
     ConstraintInstr* constraint =
         InsertConstraintFor(check->value()->definition(),
-                        Range::Unknown(),
-                        check);
-    InsertConstraintsFor(constraint);  // Constrain uses further.
+                            Range::Unknown(),
+                            check);
+    if (constraint != NULL) {
+      InsertConstraintsFor(constraint);  // Constrain uses further.
+    }
   }
 
   for (intptr_t i = 0; i < smi_values_.length(); i++) {
     InsertConstraintsFor(smi_values_[i]);
   }
 }
 
 
 void RangeAnalysis::InitializeRangesRecursive(BlockEntryInstr* block) {
   JoinEntryInstr* join = block->AsJoinEntry();
@@ skipping 1471 matching lines @@
   }
 
   graph_->DiscoverBlocks();
   GrowableArray<BitVector*> dominance_frontier;
   graph_->ComputeDominators(&dominance_frontier);
   graph_->ComputeUseLists();
 }
 
 
 }  // namespace dart