Changeset 41842 in webkit for trunk/JavaScriptCore/pcre

Timestamp:

Mar 19, 2009, 1:32:49 PM (16 years ago)

Author:

[email protected]

Message:

JavaScriptCore:

2009-03-19 Geoffrey Garen <​[email protected]>

Reviewed by Sam Weinig.

Fixed <rdar://problem/6603562> REGRESSION (Safari 4): regular expression
pattern size limit lower than Safari 3.2, other browsers, breaks SAP (14873)

Bumped the pattern size limit to 1MB, and standardized it between PCRE
and WREC. (Empirical testing says that we can easily compile a 1MB regular
expression without risking a hang. Other browsers support bigger regular
expressions, but also hang.)

SunSpider reports no change.

I started with a patch posted to Bugzilla by Erik Corry (​[email protected]).

• pcre/pcre_internal.h: (put3ByteValue): (get3ByteValue): (put3ByteValueAndAdvance): (putLinkValueAllowZero): (getLinkValueAllowZero): Made PCRE's "LINK_SIZE" (the number of bytes used to record jumps between bytecodes) 3, to accomodate larger potential jumps. Bumped PCRE's "MAX_PATTERN_SIZE" to 1MB. (Technically, at this LINK_SIZE, we can support even larger patterns, but we risk a hang during compilation, and it's not clear that such large patterns are important on the web.)

• wrec/WREC.cpp: (JSC::WREC::Generator::compileRegExp): Match PCRE's maximum pattern size, to avoid quirks between platforms.

LayoutTests:

2009-03-19 Geoffrey Garen <​[email protected]>

Reviewed by Sam Weinig.

Made two layout tests less agressive, to accomodate a change I made
for <rdar://problem/6603562> REGRESSION (Safari 4): regular expression
pattern size limit lower than Safari 3.2, other browsers, breaks SAP (14873)

• fast/js/regexp-charclass-crash-expected.txt:
• fast/js/regexp-charclass-crash.html: Explicitly limit the number of iterations in the test loop. Otherwise, regular expression engines supporting very long patterns take a very very very long time to run this test.

• fast/js/resources/regexp-overflow.js: Made the "too big" regexp in this test even bigger, to match our new limit.

File:

• trunk/JavaScriptCore/pcre/pcre_internal.h (modified) (3 diffs)

trunk/JavaScriptCore/pcre/pcre_internal.h

@@ -86 +86 @@
 patterns up to 64K long. */
 
-#define LINK_SIZE   2
+#define LINK_SIZE   3
 
 /* Define DEBUG to get debugging output on stdout. */
@@ -125 +125 @@
 }
 
+static inline void put3ByteValue(unsigned char* opcodePtr, int value)
+{
+    ASSERT(value >= 0 && value <= 0xFFFFFF);
+    opcodePtr[0] = value >> 16;
+    opcodePtr[1] = value >> 8;
+    opcodePtr[2] = value;
+}
+
 static inline int get2ByteValue(const unsigned char* opcodePtr)
 {
     return (opcodePtr[0] << 8) | opcodePtr[1];
+}
+
+static inline int get3ByteValue(const unsigned char* opcodePtr)
+{
+    return (opcodePtr[0] << 16) | (opcodePtr[1] << 8) | opcodePtr[2];
 }
 
@@ -136 +149 @@
 }
 
+static inline void put3ByteValueAndAdvance(unsigned char*& opcodePtr, int value)
+{
+    put3ByteValue(opcodePtr, value);
+    opcodePtr += 3;
+}
+
 static inline void putLinkValueAllowZero(unsigned char* opcodePtr, int value)
 {
+#if LINK_SIZE == 3
+    put3ByteValue(opcodePtr, value);
+#elif LINK_SIZE == 2
     put2ByteValue(opcodePtr, value);
+#else
+#   error LINK_SIZE not supported.
+#endif
 }
 
 static inline int getLinkValueAllowZero(const unsigned char* opcodePtr)
 {
+#if LINK_SIZE == 3
+    return get3ByteValue(opcodePtr);
+#elif LINK_SIZE == 2
     return get2ByteValue(opcodePtr);
-}
-
-#define MAX_PATTERN_SIZE (1 << 16)
+#else
+#   error LINK_SIZE not supported.
+#endif
+}
+
+#define MAX_PATTERN_SIZE 1024 * 1024 // Derived by empirical testing of compile time in PCRE and WREC.
+COMPILE_ASSERT(MAX_PATTERN_SIZE < (1 << (8 * LINK_SIZE)), pcre_max_pattern_fits_in_bytecode);
 
 static inline void putLinkValue(unsigned char* opcodePtr, int value)