1 files changed, 25 insertions, 8 deletions

diff --git a/JavaScriptCore/yarr/RegexInterpreter.cpp b/JavaScriptCore/yarr/RegexInterpreter.cpp
index 4fb5f92..d50c6c8 100644
--- a/JavaScriptCore/yarr/RegexInterpreter.cpp
+++ b/JavaScriptCore/yarr/RegexInterpreter.cpp
@@ -28,6 +28,7 @@
 
 #include "RegexCompiler.h"
 #include "RegexPattern.h"
+#include <wtf/BumpPointerAllocator.h>
 
 #ifndef NDEBUG
 #include <stdio.h>
@@ -104,12 +105,16 @@ public:
 
     DisjunctionContext* allocDisjunctionContext(ByteDisjunction* disjunction)
     {
-        return new(malloc(sizeof(DisjunctionContext) + (disjunction->m_frameSize - 1) * sizeof(uintptr_t))) DisjunctionContext();
+        size_t size = sizeof(DisjunctionContext) - sizeof(uintptr_t) + disjunction->m_frameSize * sizeof(uintptr_t);
+        allocatorPool = allocatorPool->ensureCapacity(size);
+        if (!allocatorPool)
+            CRASH();
+        return new(allocatorPool->alloc(size)) DisjunctionContext();
     }
 
     void freeDisjunctionContext(DisjunctionContext* context)
     {
-        free(context);
+        allocatorPool = allocatorPool->dealloc(context);
     }
 
     struct ParenthesesDisjunctionContext
@@ -150,12 +155,16 @@ public:
 
     ParenthesesDisjunctionContext* allocParenthesesDisjunctionContext(ByteDisjunction* disjunction, int* output, ByteTerm& term)
     {
-        return new(malloc(sizeof(ParenthesesDisjunctionContext) + (((term.atom.parenthesesDisjunction->m_numSubpatterns << 1) - 1) * sizeof(int)) + sizeof(DisjunctionContext) + (disjunction->m_frameSize - 1) * sizeof(uintptr_t))) ParenthesesDisjunctionContext(output, term);
+        size_t size = sizeof(ParenthesesDisjunctionContext) - sizeof(int) + (term.atom.parenthesesDisjunction->m_numSubpatterns << 1) * sizeof(int) + sizeof(DisjunctionContext) - sizeof(uintptr_t) + disjunction->m_frameSize * sizeof(uintptr_t);
+        allocatorPool = allocatorPool->ensureCapacity(size);
+        if (!allocatorPool)
+            CRASH();
+        return new(allocatorPool->alloc(size)) ParenthesesDisjunctionContext(output, term);
     }
 
     void freeParenthesesDisjunctionContext(ParenthesesDisjunctionContext* context)
     {
-        free(context);
+        allocatorPool = allocatorPool->dealloc(context);
     }
 
     class InputStream {
@@ -1190,6 +1199,10 @@ public:
 
     int interpret()
     {
+        allocatorPool = pattern->m_allocator->startAllocator();
+        if (!allocatorPool)
+            CRASH();
+
         for (unsigned i = 0; i < ((pattern->m_body->m_numSubpatterns + 1) << 1); ++i)
             output[i] = -1;
 
@@ -1202,6 +1215,8 @@ public:
 
         freeDisjunctionContext(context);
 
+        pattern->m_allocator->stopAllocator();
+
         return output[0];
     }
 
@@ -1209,6 +1224,7 @@ public:
         : pattern(pattern)
         , output(output)
         , input(inputChar, start, length)
+        , allocatorPool(0)
     {
     }
 
@@ -1216,6 +1232,7 @@ private:
     BytecodePattern *pattern;
     int* output;
     InputStream input;
+    BumpPointerPool* allocatorPool;
 };
 
 
@@ -1238,13 +1255,13 @@ public:
         m_currentAlternativeIndex = 0;
     }
 
-    PassOwnPtr<BytecodePattern> compile()
+    PassOwnPtr<BytecodePattern> compile(BumpPointerAllocator* allocator)
     {
         regexBegin(m_pattern.m_numSubpatterns, m_pattern.m_body->m_callFrameSize);
         emitDisjunction(m_pattern.m_body);
         regexEnd();
 
-        return adoptPtr(new BytecodePattern(m_bodyDisjunction.release(), m_allParenthesesInfo, m_pattern));
+        return adoptPtr(new BytecodePattern(m_bodyDisjunction.release(), m_allParenthesesInfo, m_pattern, allocator));
     }
 
     void checkInput(unsigned count)
@@ -1574,7 +1591,7 @@ private:
 };
 
 
-PassOwnPtr<BytecodePattern> byteCompileRegex(const UString& patternString, unsigned& numSubpatterns, const char*& error, bool ignoreCase, bool multiline)
+PassOwnPtr<BytecodePattern> byteCompileRegex(const UString& patternString, unsigned& numSubpatterns, const char*& error, BumpPointerAllocator* allocator, bool ignoreCase, bool multiline)
 {
     RegexPattern pattern(ignoreCase, multiline);
 
@@ -1583,7 +1600,7 @@ PassOwnPtr<BytecodePattern> byteCompileRegex(const UString& patternString, unsig
 
     numSubpatterns = pattern.m_numSubpatterns;
 
-    return ByteCompiler(pattern).compile();
+    return ByteCompiler(pattern).compile(allocator);
 }
 
 int interpretRegex(BytecodePattern* regex, const UChar* input, unsigned start, unsigned length, int* output)