Port and integrate the irregexp engine from V8

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 1625 matching lines @@
   bool HasInstantiatedSignature() const;
 
   // Build a string of the form 'T, {b: B, c: C} representing the user
   // visible formal parameters of the function.
   RawString* UserVisibleFormalParameters() const;
 
   RawClass* Owner() const;
   RawClass* origin() const;
   RawScript* script() const;
 
+  void set_regexp(const JSRegExp& value) const;
+  RawJSRegExp* regexp() const { return raw_ptr()->regexp_; }
+
+  void set_regexp_specialization(intptr_t cid) {
+    raw_ptr()->regexp_specialization_ = cid;

[Florian Schneider, 2014/10/01 17:04:15]

I think you can use the kind-specific data_ field for storing the
specialization-cid.


Maybe add _cid to the name to make it clearer what it is.

[jgruber1, 2014/10/03 18:59:54]

data_ now stores the RawJSRegExp pointer, and I renamed this to regexp_cid_.

+  }
+  intptr_t regexp_specialization() const {
+    return raw_ptr()->regexp_specialization_;
+  }
+
   RawAbstractType* result_type() const { return raw_ptr()->result_type_; }
   void set_result_type(const AbstractType& value) const;
 
   RawAbstractType* ParameterTypeAt(intptr_t index) const;
   void SetParameterTypeAt(intptr_t index, const AbstractType& value) const;
   RawArray* parameter_types() const { return raw_ptr()->parameter_types_; }
   void set_parameter_types(const Array& value) const;
 
   // Parameter names are valid for all valid parameter indices, and are not
   // limited to named optional parameters.
@@ skipping 108 matching lines @@
     }
     switch (kind()) {
       case RawFunction::kRegularFunction:
       case RawFunction::kGetterFunction:
       case RawFunction::kSetterFunction:
       case RawFunction::kImplicitGetter:
       case RawFunction::kImplicitSetter:
       case RawFunction::kMethodExtractor:
       case RawFunction::kNoSuchMethodDispatcher:
       case RawFunction::kInvokeFieldDispatcher:
+      case RawFunction::kIrregexpFunction:
         return true;
       case RawFunction::kClosureFunction:
       case RawFunction::kConstructor:
       case RawFunction::kImplicitStaticFinalGetter:
         return false;
       default:
         UNREACHABLE();
         return false;
     }
   }
   bool IsStaticFunction() const {
     if (!is_static()) {
       return false;
     }
     switch (kind()) {
       case RawFunction::kRegularFunction:
       case RawFunction::kGetterFunction:
       case RawFunction::kSetterFunction:
       case RawFunction::kImplicitGetter:
       case RawFunction::kImplicitSetter:
       case RawFunction::kImplicitStaticFinalGetter:
+      case RawFunction::kIrregexpFunction:
         return true;
       case RawFunction::kClosureFunction:
       case RawFunction::kConstructor:
         return false;
       default:
         UNREACHABLE();
         return false;
     }
   }
   bool IsInFactoryScope() const;
@@ skipping 219 matching lines @@
   bool IsImplicitSetterFunction() const {
     return kind() == RawFunction::kImplicitSetter;
   }
 
   // Returns true if this function represents a (possibly implicit) closure
   // function.
   bool IsClosureFunction() const {
     return kind() == RawFunction::kClosureFunction;
   }
 
+  // Returns true if this function represents a generated irregexp function.
+  bool IsIrregexpFunction() const {
+    return kind() == RawFunction::kIrregexpFunction;
+  }
+
   // Returns true if this function represents an implicit closure function.
   bool IsImplicitClosureFunction() const;
 
   // Returns true if this function represents a non implicit closure function.
   bool IsNonImplicitClosureFunction() const {
     return IsClosureFunction() && !IsImplicitClosureFunction();
   }
 
   // Returns true if this function represents an implicit static closure
   // function.
@@ skipping 1456 matching lines @@
     V(UnaryOp)                                                                 \
     V(UnboxInteger)                                                            \
     V(CheckClass)                                                              \
     V(HoistedCheckClass)                                                       \
     V(CheckSmi)                                                                \
     V(CheckArrayBound)                                                         \
     V(AtCall)                                                                  \
     V(DoubleToSmi)                                                             \
     V(Int32Load)                                                               \
     V(Uint32Load)                                                              \
+    V(CodeUnitsLoad)                                                           \

[Florian Schneider, 2014/10/01 17:04:15]

No need, since I don't see any deoptimizations in LoadCodeUnitsAtInstr.

[jgruber1, 2014/10/03 18:59:54]

Done.

     V(GuardField)                                                              \
     V(TestCids)                                                                \
     V(NumReasons)                                                              \
 
   enum DeoptReasonId {
   #define DEFINE_ENUM_LIST(name) kDeopt##name,
   DEOPT_REASONS(DEFINE_ENUM_LIST)
   #undef DEFINE_ENUM_LIST
   };
 
@@ skipping 3641 matching lines @@
 
   bool is_initialized() const { return (type() != kUnitialized); }
   bool is_simple() const { return (type() == kSimple); }
   bool is_complex() const { return (type() == kComplex); }
 
   bool is_global() const { return (flags() & kGlobal); }
   bool is_ignore_case() const { return (flags() & kIgnoreCase); }
   bool is_multi_line() const { return (flags() & kMultiLine); }
 
   RawString* pattern() const { return raw_ptr()->pattern_; }
+
+  static intptr_t subject_offset(intptr_t cid) {
+    switch (cid) {
+      case kOneByteStringCid: return OFFSET_OF(RawJSRegExp, one_byte_subject_);
+      case kTwoByteStringCid: return OFFSET_OF(RawJSRegExp, two_byte_subject_);
+      case kExternalOneByteStringCid:
+         return OFFSET_OF(RawJSRegExp, external_one_byte_subject_);
+      case kExternalTwoByteStringCid:
+        return OFFSET_OF(RawJSRegExp, external_two_byte_subject_);
+    }
+
+    UNREACHABLE();
+    return -1;
+  }
+  RawString* sample_subject(intptr_t cid) const {
+    switch (cid) {
+      case kOneByteStringCid: return raw_ptr()->one_byte_subject_;
+      case kTwoByteStringCid: return raw_ptr()->two_byte_subject_;
+      case kExternalOneByteStringCid:
+         return raw_ptr()->external_one_byte_subject_;
+      case kExternalTwoByteStringCid:
+        return raw_ptr()->external_two_byte_subject_;
+    }
+
+    UNREACHABLE();
+    return String::null();
+  }
+
   RawSmi* num_bracket_expressions() const {
     return raw_ptr()->num_bracket_expressions_;
   }
 
+  static intptr_t function_offset(intptr_t cid) {
+    switch (cid) {
+      case kOneByteStringCid: return OFFSET_OF(RawJSRegExp, one_byte_function_);
+      case kTwoByteStringCid: return OFFSET_OF(RawJSRegExp, two_byte_function_);
+      case kExternalOneByteStringCid:
+         return OFFSET_OF(RawJSRegExp, external_one_byte_function_);
+      case kExternalTwoByteStringCid:
+        return OFFSET_OF(RawJSRegExp, external_two_byte_function_);
+    }
+
+    UNREACHABLE();
+    return -1;
+  }
+
+  RawFunction* function(intptr_t cid) const {
+    switch (cid) {
+      case kOneByteStringCid: return raw_ptr()->one_byte_function_;
+      case kTwoByteStringCid: return raw_ptr()->two_byte_function_;
+      case kExternalOneByteStringCid:
+        return raw_ptr()->external_one_byte_function_;
+      case kExternalTwoByteStringCid:
+        return raw_ptr()->external_two_byte_function_;
+    }
+
+    UNREACHABLE();
+    return Function::null();
+  }
+
   void set_pattern(const String& pattern) const;
+  void set_function(intptr_t cid, const Function& value);
+  void set_sample_subject(intptr_t cid, const String& value) const;
+
   void set_num_bracket_expressions(intptr_t value) const;
   void set_is_global() const { set_flags(flags() | kGlobal); }
   void set_is_ignore_case() const { set_flags(flags() | kIgnoreCase); }
   void set_is_multi_line() const { set_flags(flags() | kMultiLine); }
   void set_is_simple() const { set_type(kSimple); }
   void set_is_complex() const { set_type(kComplex); }
 
   void* GetDataStartAddress() const;
   static RawJSRegExp* FromDataStartAddress(void* data);
   const char* Flags() const;
@@ skipping 292 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_