Reland "VM: Handle null-comparisons in the flow graph type propagation"

runtime/vm/intrinsifier.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.
 // Class for intrinsifying functions.
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/cpu.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 267 matching lines @@
 
 
 // Notes about the graph intrinsics:
 //
 // IR instructions which would jump to a deoptimization sequence on failure
 // instead branch to the intrinsic slow path.
 //
 class BlockBuilder : public ValueObject {
  public:
   BlockBuilder(FlowGraph* flow_graph, TargetEntryInstr* entry)
-      : flow_graph_(flow_graph), entry_(entry), current_(entry) {}
+      : flow_graph_(flow_graph),
+        entry_(entry),
+        current_(entry),
+        empty_env_(new Environment(0,
+                                   0,
+                                   Thread::kNoDeoptId,
+                                   flow_graph->parsed_function(),
+                                   NULL)) {}
 
   Definition* AddToInitialDefinitions(Definition* def) {
     def->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
     flow_graph_->AddToInitialDefinitions(def);
     return def;
   }
 
   Definition* AddDefinition(Definition* def) {
     def->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
-    current_ = current_->AppendInstruction(def);
+    AddInstruction(def);
     return def;
   }
 
   Instruction* AddInstruction(Instruction* instr) {
+    if (instr->ComputeCanDeoptimize()) {
+      // Since we use the presence of an environment to determine if an
+      // instructions can deoptimize, we need an empty enviroment for
+      // instructions that "deoptimize" to the intrinsic fall-through code.
+      instr->SetEnvironment(empty_env_);
+    }
     current_ = current_->AppendInstruction(instr);
     return instr;
   }
 
   void AddIntrinsicReturn(Value* value) {
     ReturnInstr* instr = new ReturnInstr(TokenPos(), value);
     AddInstruction(instr);
     entry_->set_last_instruction(instr);
   }
 
@@ skipping 40 matching lines @@
         new InvokeMathCFunctionInstr(args, Thread::kNoDeoptId, recognized_kind,
                                      TokenPos());
     AddDefinition(invoke_math_c_function);
     return invoke_math_c_function;
   }
 
 
   FlowGraph* flow_graph_;
   BlockEntryInstr* entry_;
   Instruction* current_;
+  Environment* empty_env_;
 };
 
 
 static void PrepareIndexedOp(BlockBuilder* builder,
                              Definition* array,
                              Definition* index,
                              intptr_t length_offset) {
   Definition* length = builder->AddDefinition(new LoadFieldInstr(
       new Value(array), length_offset, Type::ZoneHandle(Type::SmiType()),
       TokenPosition::kNoSource));
@@ skipping 794 matching lines @@
 }
 
 
 void Intrinsifier::RegExp_ExecuteMatchSticky(Assembler* assembler) {
   IntrinsifyRegExpExecuteMatch(assembler, /*sticky=*/true);
 }
 #endif  // !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart