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

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 482 matching lines @@
   M(Float64x2OneArg)                                                           \
   M(ExtractNthOutput)                                                          \
   M(BinaryUint32Op)                                                            \
   M(ShiftUint32Op)                                                             \
   M(UnaryUint32Op)                                                             \
   M(BoxUint32)                                                                 \
   M(UnboxUint32)                                                               \
   M(BoxInt32)                                                                  \
   M(UnboxInt32)                                                                \
   M(UnboxedIntConverter)                                                       \
-  M(GrowRegExpStack)                                                           \
   M(Deoptimize)
 
 #define FOR_EACH_ABSTRACT_INSTRUCTION(M)                                       \
   M(BlockEntry)                                                                \
   M(BoxInteger)                                                                \
   M(UnboxInteger)                                                              \
   M(Comparison)                                                                \
   M(UnaryIntegerOp)                                                            \
   M(BinaryIntegerOp)
 
@@ skipping 708 matching lines @@
   // number of the block's spanning-tree parent.  As a side effect of this
   // function, the set of basic block predecessors (e.g., block entry
   // instructions of predecessor blocks) and also the last instruction in the
   // block is recorded in each entry instruction.  Returns true when called the
   // first time on this particular block within one graph traversal, and false
   // on all successive calls.
   bool DiscoverBlock(BlockEntryInstr* predecessor,
                      GrowableArray<BlockEntryInstr*>* preorder,
                      GrowableArray<intptr_t>* parent);
 
-  // Perform a depth first search to prune code not reachable from an OSR
-  // entry point.
-  bool PruneUnreachable(GraphEntryInstr* graph_entry,
-                        Instruction* parent,
-                        intptr_t osr_id,
-                        BitVector* block_marks);
-
   virtual intptr_t InputCount() const { return 0; }
   virtual Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // BlockEntry environment is copied to Goto and Branch instructions
@@ skipping 48 matching lines @@
         try_index_(try_index),
         preorder_number_(-1),
         postorder_number_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL),
         offset_(-1),
         parallel_move_(NULL),
         loop_info_(NULL) {}
 
+  // Perform a depth first search to prune code not reachable from an OSR
+  // entry point.

[erikcorry, 2017/06/22 13:08:06]

Perform a depth first search to find the OSR entry point. Later we will prune
code not findable from this point.

[Vyacheslav Egorov (Google), 2017/06/22 14:58:48]

Done.

+  bool PruneUnreachable(GraphEntryInstr* graph_entry,
+                        Instruction* parent,
+                        BitVector* block_marks);
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual void ClearPredecessors() = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
 
   void set_dominator(BlockEntryInstr* instr) { dominator_ = instr; }
 
   intptr_t block_id_;
   intptr_t try_index_;
@@ skipping 93 matching lines @@
 
   void AddIndirectEntry(IndirectEntryInstr* entry) {
     indirect_entries_.Add(entry);
   }
 
   GrowableArray<Definition*>* initial_definitions() {
     return &initial_definitions_;
   }
   ConstantInstr* constant_null();
 
+  void PruneUnreachableForOSR(Zone* zone, intptr_t max_block_id);
   bool IsCompiledForOsr() const;
+  intptr_t osr_id() const { return osr_id_; }
 
   intptr_t entry_count() const { return entry_count_; }
   void set_entry_count(intptr_t count) { entry_count_ = count; }
 
   intptr_t spill_slot_count() const { return spill_slot_count_; }
   void set_spill_slot_count(intptr_t count) {
     ASSERT(count >= 0);
     spill_slot_count_ = count;
   }
 
@@ skipping 5849 matching lines @@
 
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryDoubleOpInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateInstruction<0, NoThrow> {
  public:
+  enum Kind {
+    // kOsrAndPreemption stack overflow checks are emitted in both unoptimized
+    // and optimized versions of the code and they serve as both preemption and
+    // OSR entry points.
+    kOsrAndPreemption,
+
+    // kOsrOnly stack overflow checks are only needed in the unoptimized code
+    // because we can't OSR optimized code.
+    kOsrOnly,
+  };
+
   CheckStackOverflowInstr(TokenPosition token_pos,
                           intptr_t loop_depth,
-                          intptr_t deopt_id)
+                          intptr_t deopt_id,
+                          Kind kind = kOsrAndPreemption)
       : TemplateInstruction(deopt_id),
         token_pos_(token_pos),
-        loop_depth_(loop_depth) {}
+        loop_depth_(loop_depth),
+        kind_(kind) {
+    ASSERT(kind != kOsrOnly || loop_depth > 0);
+  }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   bool in_loop() const { return loop_depth_ > 0; }
   intptr_t loop_depth() const { return loop_depth_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
+  virtual Instruction* Canonicalize(FlowGraph* flow_graph);
+
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const intptr_t loop_depth_;
+  const Kind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 // TODO(vegorov): remove this instruction in favor of Int32ToDouble.
 class SmiToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   SmiToDoubleInstr(Value* value, TokenPosition token_pos)
       : token_pos_(token_pos) {
@@ skipping 648 matching lines @@
 
  private:
   const Representation from_representation_;
   const Representation to_representation_;
   bool is_truncating_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboxedIntConverterInstr);
 };
 
 
-class GrowRegExpStackInstr : public TemplateDefinition<1, Throws> {
- public:
-  explicit GrowRegExpStackInstr(Value* typed_data_cell) {
-    SetInputAt(0, typed_data_cell);
-  }
-
-  Value* typed_data_cell() const { return inputs_[0]; }
-
-  virtual bool ComputeCanDeoptimize() const { return MayThrow(); }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
-
-  DECLARE_INSTRUCTION(GrowRegExpStack);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(GrowRegExpStackInstr);
-};
-
-
 #undef DECLARE_INSTRUCTION
 
 class Environment : public ZoneAllocated {
  public:
   // Iterate the non-NULL values in the innermost level of an environment.
   class ShallowIterator : public ValueObject {
    public:
     explicit ShallowIterator(Environment* environment)
         : environment_(environment), index_(0) {}
 
@@ skipping 248 matching lines @@
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {     \
     UNIMPLEMENTED();                                                           \
     return NULL;                                                               \
   }                                                                            \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_