- Specialized jscre on the type of the string involved.

- Specialized jscre on the type of the string involved.


git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@476 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/heap.cc

@@ -223,7 +223,6 @@ void Heap::ReportStatisticsAfterGC() {
 
 
 void Heap::GarbageCollectionPrologue() {
-  RegExpImpl::NewSpaceCollectionPrologue();
   gc_count_++;
 #ifdef DEBUG
   ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
@@ -424,7 +423,6 @@ void Heap::MarkCompact(GCTracer* tracer) {
 
 void Heap::MarkCompactPrologue() {
   CompilationCache::MarkCompactPrologue();
-  RegExpImpl::OldSpaceCollectionPrologue();
   Top::MarkCompactPrologue();
   ThreadManager::MarkCompactPrologue();
 }

src/jsregexp.h

@@ -79,32 +79,24 @@ class RegExpImpl {
                                  Handle<String> subject,
                                  Handle<Object> index);
 
+  template <typename T>
   static Handle<Object> JsreExecGlobal(Handle<JSRegExp> regexp,
-                                       Handle<String> subject);
-
-  static void NewSpaceCollectionPrologue();
-  static void OldSpaceCollectionPrologue();
+                                       Handle<String> subject,
+                                       Vector<const T> contents);
 
  private:
-  // Converts a source string to a 16 bit flat string.  The string
-  // will be either sequential or it will be a SlicedString backed
-  // by a flat string.
-  static Handle<String> StringToTwoByte(Handle<String> pattern);
-  static Handle<String> CachedStringToTwoByte(Handle<String> pattern);
-
-  static String* last_ascii_string_;
-  static String* two_byte_cached_string_;
 
   // Returns the caputure from the re.
   static int JsreCapture(Handle<JSRegExp> re);
   static ByteArray* JsreInternal(Handle<JSRegExp> re);
 
   // Call jsRegExpExecute once
+  template <typename T>
   static Handle<Object> JsreExecOnce(Handle<JSRegExp> regexp,
                                      int num_captures,
                                      Handle<String> subject,
                                      int previous_index,
-                                     const uc16* utf8_subject,
+                                     Vector<const T> contents,
                                      int* ovector,
                                      int ovector_length);
 

src/objects.h

@@ -1303,26 +1303,9 @@ class JSObject: public HeapObject {
                                       JSFunction* function,
                                       PropertyAttributes attributes);
 
-  Object* ReplaceSlowProperty(String* name,
-                              Object* value,
-                              PropertyAttributes attributes);
-
-  // Converts a descriptor of any other type to a real field,
-  // backed by the properties array.  Descriptors of visible
-  // types, such as CONSTANT_FUNCTION, keep their enumeration order.
-  // Converts the descriptor on the original object's map to a
-  // map transition, and the the new field is on the object's new map.
-  Object* ConvertDescriptorToFieldAndMapTransition(
-      String* name,
-      Object* new_value,
-      PropertyAttributes attributes);
-
-  // Converts a descriptor of any other type to a real field,
-  // backed by the properties array.  Descriptors of visible
-  // types, such as CONSTANT_FUNCTION, keep their enumeration order.
-  Object* ConvertDescriptorToField(String* name,
-                                   Object* new_value,
-                                   PropertyAttributes attributes);
+  // Replace a constant function property on a fast-case object.
+  Object* ReplaceConstantFunctionProperty(String* name,
+                                          Object* value);
 
   // Add a property to a fast-case object.
   Object* AddFastProperty(String* name,
@@ -1394,10 +1377,6 @@ class JSObject: public HeapObject {
   static const uint32_t kMaxGap = 1024;
   static const int kMaxFastElementsLength = 5000;
   static const int kMaxFastProperties = 8;
-  // When extending the backing storage for property values, we increase
-  // its size by more than the 1 entry necessary, so sequentially adding fields
-  // to the same object requires fewer allocations and copies.
-  static const int kFieldsAdded = 3;
 
   // Layout description.
   static const int kPropertiesOffset = HeapObject::kHeaderSize;
@@ -1583,6 +1562,7 @@ class DescriptorArray: public FixedArray {
   inline void Get(int descriptor_number, Descriptor* desc);
   inline void Set(int descriptor_number, Descriptor* desc);
 
+  void ReplaceConstantFunction(int descriptor_number, JSFunction* value);
 
   // Copy the descriptor array, insert a new descriptor and optionally
   // remove map transitions.  If the descriptor is already present, it is
@@ -1592,6 +1572,20 @@ class DescriptorArray: public FixedArray {
   // a transition, they must not be removed.  All null descriptors are removed.
   Object* CopyInsert(Descriptor* descriptor, TransitionFlag transition_flag);
 
+  // Makes a copy of the descriptor array with the descriptor with key name
+  // removed.  If name is the empty string, the descriptor array is copied.
+  // Transitions are removed if TransitionFlag is REMOVE_TRANSITIONS.
+  // All null descriptors are removed.
+  Object* CopyRemove(TransitionFlag remove_transitions, String* name);
+
+  // Copy the descriptor array, replace the property index and attributes
+  // of the named property, but preserve its enumeration index.
+  Object* CopyReplace(String* name, int index, PropertyAttributes attributes);
+
+  // Copy the descriptor array, removing the property index and attributes
+  // of the named property.
+  Object* CopyRemove(String* name);
+
   // Remove all transitions.  Return  a copy of the array with all transitions
   // removed, or a Failure object if the new array could not be allocated.
   Object* RemoveTransitions();

src/third_party/jscre/pcre.h

@@ -66,13 +66,15 @@ const int JSRegExpErrorInternal = -4;
 typedef void* malloc_t(size_t size);
 typedef void free_t(void* address);
 
-JSRegExp* jsRegExpCompile(const UChar* pattern, int patternLength,
+template <typename Char>
+JSRegExp* jsRegExpCompile(const Char* pattern, int patternLength,
     JSRegExpIgnoreCaseOption, JSRegExpMultilineOption,
     unsigned* numSubpatterns, const char** errorMessage,
     malloc_t* allocate_function, free_t* free_function);
 
+template <typename Char>
 int jsRegExpExecute(const JSRegExp*,
-    const UChar* subject, int subjectLength, int startOffset,
+    const Char* subject, int subjectLength, int startOffset,
     int* offsetsVector, int offsetsVectorLength);
 
 void jsRegExpFree(JSRegExp*);