* Move irregexp backtrack stack to external memory area, instead of the system stack.

test/cctest/test-regexp.cc

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 580 matching lines @@
   byte codes[1024];
   RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024));
   // ^f(o)o.
   Label fail, fail2, start;
   uc16 foo_chars[3];
   foo_chars[0] = 'f';
   foo_chars[1] = 'o';
   foo_chars[2] = 'o';
   Vector<const uc16> foo(foo_chars, 3);
   m.SetRegister(4, 42);
-  m.PushRegister(4);
+  m.PushRegister(4, RegExpMacroAssembler::kNoStackLimitCheck);
   m.AdvanceRegister(4, 42);
   m.GoTo(&start);
   m.Fail();
   m.Bind(&start);
-  m.PushBacktrack(&fail2);
+  m.PushBacktrack(&fail2, RegExpMacroAssembler::kCheckStackLimit);
   m.CheckCharacters(foo, 0, &fail, true);
   m.WriteCurrentPositionToRegister(0, 0);
-  m.PushCurrentPosition();
+  m.PushCurrentPosition(RegExpMacroAssembler::kCheckStackLimit);
   m.AdvanceCurrentPosition(3);
   m.WriteCurrentPositionToRegister(1, 0);
   m.PopCurrentPosition();
   m.AdvanceCurrentPosition(1);
   m.WriteCurrentPositionToRegister(2, 0);
   m.AdvanceCurrentPosition(1);
   m.WriteCurrentPositionToRegister(3, 0);
   m.Succeed();
 
   m.Bind(&fail);
@@ skipping 39 matching lines @@
   ~ContextInitializer() {
     env_->Exit();
     env_.Dispose();
   }
  private:
   v8::Persistent<v8::Context> env_;
   v8::HandleScope scope_;
   v8::internal::StackGuard stack_guard_;
 };
 
+// Helper functions for calling the Execute method.
+template <typename T>
+static RegExpMacroAssemblerIA32::Result ExecuteIA32(Code* code,
+                                                    const T** input,
+                                                    int start_offset,
+                                                    int end_offset,
+                                                    int* captures,
+                                                    bool at_start) {
+  return RegExpMacroAssemblerIA32::Execute(
+      code,
+      reinterpret_cast<Address*>(
+          reinterpret_cast<void*>(const_cast<T**>(input))),
+      start_offset,
+      end_offset,
+      captures,
+      at_start);
+}
+
+template <typename T>
+static RegExpMacroAssemblerIA32::Result ExecuteIA32(Code* code,
+                                                    T** input,
+                                                    int start_offset,
+                                                    int end_offset,
+                                                    int* captures,
+                                                    bool at_start) {
+  return RegExpMacroAssemblerIA32::Execute(
+      code,
+      reinterpret_cast<Address*>(reinterpret_cast<void*>(input)),
+      start_offset,
+      end_offset,
+      captures,
+      at_start);
+}
+
 
 TEST(MacroAssemblerIA32Success) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 4);
 
   m.Succeed();
 
   Handle<String> source = Factory::NewStringFromAscii(CStrVector(""));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   int captures[4] = {42, 37, 87, 117};
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        captures,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  captures,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(-1, captures[0]);
   CHECK_EQ(-1, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 }
 
 
 TEST(MacroAssemblerIA32Simple) {
@@ skipping 19 matching lines @@
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   int captures[4] = {42, 37, 87, 117};
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        captures,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  captures,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(3, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 
   input = Factory::NewStringFromAscii(CStrVector("barbarbar"));
   seq_input = Handle<SeqAsciiString>::cast(input);
   start_adr = seq_input->GetCharsAddress();
   start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   end_offset = start_offset + seq_input->length();
 
-  result = RegExpMacroAssemblerIA32::Execute(*code,
-                                             seq_input.location(),
-                                             start_offset,
-                                             end_offset,
-                                             captures,
-                                             true);
+  result = ExecuteIA32(*code,
+                       seq_input.location(),
+                       start_offset,
+                       end_offset,
+                       captures,
+                       true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32SimpleUC16) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::UC16, 4);
@@ skipping 17 matching lines @@
   int captures[4] = {42, 37, 87, 117};
   const uc16 input_data[6] = {'f', 'o', 'o', 'f', 'o', '\xa0'};
   Handle<String> input =
       Factory::NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
   Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length() * sizeof(uc16);
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        captures,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  captures,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(3, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 
   const uc16 input_data2[9] = {'b', 'a', 'r', 'b', 'a', 'r', 'b', 'a', '\xa0'};
   input = Factory::NewStringFromTwoByte(Vector<const uc16>(input_data2, 9));
   seq_input = Handle<SeqTwoByteString>::cast(input);
   start_adr = seq_input->GetCharsAddress();
   start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   end_offset = start_offset + seq_input->length() * sizeof(uc16);
 
-  result = RegExpMacroAssemblerIA32::Execute(*code,
-                                             seq_input.location(),
-                                             start_offset,
-                                             end_offset,
-                                             captures,
-                                             true);
+  result = ExecuteIA32(*code,
+                       seq_input.location(),
+                       start_offset,
+                       end_offset,
+                       captures,
+                       true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32Backtrack) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 0);
 
   Label fail;
   Label backtrack;
   m.LoadCurrentCharacter(10, &fail);
   m.Succeed();
   m.Bind(&fail);
-  m.PushBacktrack(&backtrack);
+  m.PushBacktrack(&backtrack, RegExpMacroAssembler::kNoStackLimitCheck);
   m.LoadCurrentCharacter(10, NULL);
   m.Succeed();
   m.Bind(&backtrack);
   m.Fail();
 
   Handle<String> source = Factory::NewStringFromAscii(CStrVector(".........."));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        NULL,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  NULL,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32BackReferenceASCII) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 3);
@@ skipping 18 matching lines @@
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("fooofo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   int output[3];
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        output,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  output,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(2, output[1]);
   CHECK_EQ(6, output[2]);
 }
 
 
 TEST(MacroAssemblerIA32BackReferenceUC16) {
   v8::V8::Initialize();
@@ skipping 24 matching lines @@
   Handle<String> input =
       Factory::NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
   Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
 
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length() * sizeof(input_data[0]);
 
   int output[3];
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        output,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  output,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(2, output[1]);
   CHECK_EQ(6, output[2]);
 }
 
 
 
 TEST(MacroAssemblerIA32AtStart) {
@@ skipping 27 matching lines @@
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foobar"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        NULL,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  NULL,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
 
   start_offset += 3;
-  result = RegExpMacroAssemblerIA32::Execute(*code,
-                                              seq_input.location(),
-                                              start_offset,
-                                              end_offset,
-                                              NULL,
-                                              false);
+  result = ExecuteIA32(*code,
+                       seq_input.location(),
+                       start_offset,
+                       end_offset,
+                       NULL,
+                       false);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
 }
 
 
 
 
 TEST(MacroAssemblerIA32BackRefNoCase) {
   v8::V8::Initialize();
   ContextInitializer initializer;
@@ skipping 29 matching lines @@
 
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("aBcAbCABCxYzab"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   int output[4];
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        output,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  output,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(12, output[1]);
   CHECK_EQ(0, output[2]);
   CHECK_EQ(3, output[3]);
 }
 
 
 
 TEST(MacroAssemblerIA32Registers) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 5);
 
   uc16 foo_chars[3] = {'f', 'o', 'o'};
   Vector<const uc16> foo(foo_chars, 3);
 
   enum registers { out1, out2, out3, out4, out5, sp, loop_cnt };
   Label fail;
   Label backtrack;
   m.WriteCurrentPositionToRegister(out1, 0);  // Output: [0]
-  m.PushRegister(out1);
-  m.PushBacktrack(&backtrack);
+  m.PushRegister(out1, RegExpMacroAssembler::kNoStackLimitCheck);
+  m.PushBacktrack(&backtrack, RegExpMacroAssembler::kCheckStackLimit);
   m.WriteStackPointerToRegister(sp);
   // Fill stack and registers
   m.AdvanceCurrentPosition(2);
   m.WriteCurrentPositionToRegister(out1, 0);
-  m.PushRegister(out1);
-  m.PushBacktrack(&fail);
+  m.PushRegister(out1, RegExpMacroAssembler::kNoStackLimitCheck);
+  m.PushBacktrack(&fail, RegExpMacroAssembler::kCheckStackLimit);
   // Drop backtrack stack frames.
   m.ReadStackPointerFromRegister(sp);
   // And take the first backtrack (to &backtrack)
   m.Backtrack();
 
-  m.PushCurrentPosition();
+  m.PushCurrentPosition(RegExpMacroAssembler::kNoStackLimitCheck);
   m.AdvanceCurrentPosition(2);
   m.PopCurrentPosition();
 
   m.Bind(&backtrack);
   m.PopRegister(out1);
   m.ReadCurrentPositionFromRegister(out1);
   m.AdvanceCurrentPosition(3);
   m.WriteCurrentPositionToRegister(out2, 0);  // [0,3]
 
   Label loop;
   m.SetRegister(loop_cnt, 0);  // loop counter
   m.Bind(&loop);
   m.AdvanceRegister(loop_cnt, 1);
   m.AdvanceCurrentPosition(1);
   m.IfRegisterLT(loop_cnt, 3, &loop);
   m.WriteCurrentPositionToRegister(out3, 0);  // [0,3,6]
 
   Label loop2;
   m.SetRegister(loop_cnt, 2);  // loop counter
   m.Bind(&loop2);
   m.AdvanceRegister(loop_cnt, -1);
   m.AdvanceCurrentPosition(1);
   m.IfRegisterGE(loop_cnt, 0, &loop2);
   m.WriteCurrentPositionToRegister(out4, 0);  // [0,3,6,9]
 
   Label loop3;
   Label exit_loop3;
-  m.PushRegister(out4);
-  m.PushRegister(out4);
+  m.PushRegister(out4, RegExpMacroAssembler::kNoStackLimitCheck);
+  m.PushRegister(out4, RegExpMacroAssembler::kNoStackLimitCheck);
   m.ReadCurrentPositionFromRegister(out3);
   m.Bind(&loop3);
   m.AdvanceCurrentPosition(1);
   m.CheckGreedyLoop(&exit_loop3);
   m.GoTo(&loop3);
   m.Bind(&exit_loop3);
   m.PopCurrentPosition();
   m.WriteCurrentPositionToRegister(out5, 0);  // [0,3,6,9,9]
 
   m.Succeed();
 
   m.Bind(&fail);
   m.Fail();
 
   Handle<String> source =
       Factory::NewStringFromAscii(CStrVector("<loop test>"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   // String long enough for test (content doesn't matter).
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("foofoofoofoofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   int output[5];
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        output,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  output,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(3, output[1]);
   CHECK_EQ(6, output[2]);
   CHECK_EQ(9, output[3]);
   CHECK_EQ(9, output[4]);
 }
 
 
 TEST(MacroAssemblerIA32StackOverflow) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 0);
 
   Label loop;
   m.Bind(&loop);
-  m.PushBacktrack(&loop);
+  m.PushBacktrack(&loop, RegExpMacroAssembler::kCheckStackLimit);
   m.GoTo(&loop);
 
   Handle<String> source =
       Factory::NewStringFromAscii(CStrVector("<stack overflow test>"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   // String long enough for test (content doesn't matter).
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("dummy"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        NULL,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  NULL,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::EXCEPTION, result);
   CHECK(Top::has_pending_exception());
   Top::clear_pending_exception();
 }
 
 
 #endif  // !defined ARM
 
 TEST(AddInverseToTable) {
@@ skipping 235 matching lines @@
       CHECK(!InClass(i, excluded));
     }
   }
 }
 
 
 TEST(Graph) {
   V8::Initialize(NULL);
   Execute("(?:a|)*", false, true, true);
 }