Integrate the Irregexp Regular Expression Engine.

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"
 #include "vm/json_stream.h"
 #include "vm/bitmap.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/method_recognizer.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/report.h"
 #include "vm/scanner.h"
 #include "vm/tags.h"
 #include "vm/verified_memory.h"
 
 namespace dart {
 
+DECLARE_FLAG(bool, use_jscre);
+
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class ArgumentsDescriptor;
 class Assembler;
 class Closure;
 class Code;
@@ skipping 1680 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;
+
+  // Get and set the class id this function is specialized for. Only set for
+  // irregexp functions.
+  intptr_t regexp_cid() const { return raw_ptr()->regexp_cid_; }
+  void set_regexp_cid(intptr_t regexp_cid) const;
+
   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 109 matching lines @@
       case RawFunction::kSetterFunction:
       case RawFunction::kImplicitGetter:
       case RawFunction::kImplicitSetter:
       case RawFunction::kMethodExtractor:
       case RawFunction::kNoSuchMethodDispatcher:
       case RawFunction::kInvokeFieldDispatcher:
         return true;
       case RawFunction::kClosureFunction:
       case RawFunction::kConstructor:
       case RawFunction::kImplicitStaticFinalGetter:
+      case RawFunction::kIrregexpFunction:
         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 174 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 2463 matching lines @@
   static intptr_t NextFieldOffset() {
     return sizeof(RawInstance);
   }
 
   // TODO(iposva): Determine if this gets in the way of Smi.
   HEAP_OBJECT_IMPLEMENTATION(Instance, Object);
   friend class ByteBuffer;
   friend class Class;
   friend class Closure;
   friend class DeferredObject;
+  friend class JSRegExp;
   friend class SnapshotWriter;
   friend class StubCode;
   friend class TypedDataView;
 };
 
 
 class LibraryPrefix : public Instance {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   virtual RawString* DictionaryName() const { return name(); }
@@ skipping 2657 matching lines @@
 
   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_; }
   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** FunctionAddr(intptr_t cid) const {
+    return reinterpret_cast<RawFunction**>(
+          FieldAddrAtOffset(function_offset(cid)));
+  }
+
+  RawFunction* function(intptr_t cid) const {
+    return *FunctionAddr(cid);
+  }
+
   void set_pattern(const String& pattern) const;
+  void set_function(intptr_t cid, const Function& 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;
 
   virtual bool CanonicalizeEquals(const Instance& other) const;
 
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawJSRegExp) == OFFSET_OF_RETURNED_VALUE(RawJSRegExp, data));
-    return 0;
+    if (FLAG_use_jscre) {
+      return 0;
+    }
+    return RoundedAllocationSize(sizeof(RawJSRegExp));
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawJSRegExp) + (len * kBytesPerElement));
   }
 
   static RawJSRegExp* New(intptr_t length, Heap::Space space = Heap::kNew);
 
@@ skipping 276 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_