VM(RegExp): Allow OSR optimization of RegExp :matcher functions.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 1066 matching lines @@
   for (ForwardInstructionIterator it(this); !it.Done(); it.Advance()) {
     last = it.Current();
   }
   set_last_instruction(last);
   if (last->IsGoto()) last->AsGoto()->set_block(this);
 
   return true;
 }
 
 
+void GraphEntryInstr::PruneUnreachableForOSR(Zone* zone,
+                                             intptr_t max_block_id) {
+  ASSERT(osr_id_ != Compiler::kNoOSRDeoptId);
+  BitVector* block_marks = new (zone) BitVector(zone, max_block_id + 1);
+  bool found = PruneUnreachable(this, /*parent=*/NULL, block_marks);
+  ASSERT(found);
+}
+
+
 bool BlockEntryInstr::PruneUnreachable(GraphEntryInstr* graph_entry,
                                        Instruction* parent,
-                                       intptr_t osr_id,
                                        BitVector* block_marks) {
+  const intptr_t osr_id = graph_entry->osr_id();
+
   // Search for the instruction with the OSR id.  Use a depth first search
   // because basic blocks have not been discovered yet.  Prune unreachable
   // blocks by replacing the normal entry with a jump to the block
   // containing the OSR entry point.
 
   // Do not visit blocks more than once.
   if (block_marks->Contains(block_id())) return false;
   block_marks->Add(block_id());
 
   // Search this block for the OSR id.
@@ skipping 13 matching lines @@
       GotoInstr* goto_join =
           new GotoInstr(AsJoinEntry(), Thread::Current()->GetNextDeoptId());
       goto_join->CopyDeoptIdFrom(*parent);
       graph_entry->normal_entry()->LinkTo(goto_join);
       return true;
     }
   }
 
   // Recursively search the successors.
   for (intptr_t i = instr->SuccessorCount() - 1; i >= 0; --i) {
-    if (instr->SuccessorAt(i)->PruneUnreachable(graph_entry, instr, osr_id,
+    if (instr->SuccessorAt(i)->PruneUnreachable(graph_entry, instr,
                                                 block_marks)) {
       return true;
     }
   }
   return false;
 }
 
 
 bool BlockEntryInstr::Dominates(BlockEntryInstr* other) const {
   // TODO(fschneider): Make this faster by e.g. storing dominators for each
@@ skipping 924 matching lines @@
     return NULL;
   }
   if ((constrained_type() != NULL) &&
       Type()->IsEqualTo(value()->definition()->Type())) {
     return value()->definition();
   }
   return this;
 }
 
 
+Instruction* CheckStackOverflowInstr::Canonicalize(FlowGraph* flow_graph) {
+  switch (kind_) {
+    case kOsrAndPreemption:
+      return this;
+    case kOsrOnly:
+      // Don't need OSR entries in the optimized code.
+      return NULL;
+  }
+
+  // Switch above exhausts all possibilities but some compilers can't figure
+  // it out.
+  UNREACHABLE();
+  return this;
+}
+
+
 bool LoadFieldInstr::IsImmutableLengthLoad() const {
   switch (recognized_kind()) {
     case MethodRecognizer::kObjectArrayLength:
     case MethodRecognizer::kImmutableArrayLength:
     case MethodRecognizer::kTypedDataLength:
     case MethodRecognizer::kStringBaseLength:
       return true;
     default:
       return false;
   }
@@ skipping 2280 matching lines @@
                      "native function '%s' (%" Pd " arguments) cannot be found",
                      native_name().ToCString(), function().NumParameters());
   }
   set_is_auto_scope(auto_setup_scope);
   set_native_c_function(native_function);
 }
 
 #undef __
 
 }  // namespace dart