v8  3.14.5(node0.10.28)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
regexp-stack.h
Go to the documentation of this file.
1 // Copyright 2009 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 #ifndef V8_REGEXP_STACK_H_
29 #define V8_REGEXP_STACK_H_
30 
31 namespace v8 {
32 namespace internal {
33 
34 class RegExpStack;
35 
36 // Maintains a per-v8thread stack area that can be used by irregexp
37 // implementation for its backtracking stack.
38 // Since there is only one stack area, the Irregexp implementation is not
39 // re-entrant. I.e., no regular expressions may be executed in the same thread
40 // during a preempted Irregexp execution.
42  public:
43  // Create and delete an instance to control the life-time of a growing stack.
44 
45  // Initializes the stack memory area if necessary.
46  explicit RegExpStackScope(Isolate* isolate);
47  ~RegExpStackScope(); // Releases the stack if it has grown.
48 
49  RegExpStack* stack() const { return regexp_stack_; }
50 
51  private:
52  RegExpStack* regexp_stack_;
53 
54  DISALLOW_COPY_AND_ASSIGN(RegExpStackScope);
55 };
56 
57 
58 class RegExpStack {
59  public:
60  // Number of allocated locations on the stack below the limit.
61  // No sequence of pushes must be longer that this without doing a stack-limit
62  // check.
63  static const int kStackLimitSlack = 32;
64 
65  // Gives the top of the memory used as stack.
67  ASSERT(thread_local_.memory_size_ != 0);
68  return thread_local_.memory_ + thread_local_.memory_size_;
69  }
70 
71  // The total size of the memory allocated for the stack.
72  size_t stack_capacity() { return thread_local_.memory_size_; }
73 
74  // If the stack pointer gets below the limit, we should react and
75  // either grow the stack or report an out-of-stack exception.
76  // There is only a limited number of locations below the stack limit,
77  // so users of the stack should check the stack limit during any
78  // sequence of pushes longer that this.
79  Address* limit_address() { return &(thread_local_.limit_); }
80 
81  // Ensures that there is a memory area with at least the specified size.
82  // If passing zero, the default/minimum size buffer is allocated.
83  Address EnsureCapacity(size_t size);
84 
85  // Thread local archiving.
86  static int ArchiveSpacePerThread() {
87  return static_cast<int>(sizeof(ThreadLocal));
88  }
89  char* ArchiveStack(char* to);
90  char* RestoreStack(char* from);
91  void FreeThreadResources() { thread_local_.Free(); }
92 
93  private:
94  RegExpStack();
95  ~RegExpStack();
96 
97  // Artificial limit used when no memory has been allocated.
98  static const uintptr_t kMemoryTop = static_cast<uintptr_t>(-1);
99 
100  // Minimal size of allocated stack area.
101  static const size_t kMinimumStackSize = 1 * KB;
102 
103  // Maximal size of allocated stack area.
104  static const size_t kMaximumStackSize = 64 * MB;
105 
106  // Structure holding the allocated memory, size and limit.
107  struct ThreadLocal {
108  ThreadLocal() { Clear(); }
109  // If memory_size_ > 0 then memory_ must be non-NULL.
110  Address memory_;
111  size_t memory_size_;
112  Address limit_;
113  void Clear() {
114  memory_ = NULL;
115  memory_size_ = 0;
116  limit_ = reinterpret_cast<Address>(kMemoryTop);
117  }
118  void Free();
119  };
120 
121  // Address of allocated memory.
122  Address memory_address() {
123  return reinterpret_cast<Address>(&thread_local_.memory_);
124  }
125 
126  // Address of size of allocated memory.
127  Address memory_size_address() {
128  return reinterpret_cast<Address>(&thread_local_.memory_size_);
129  }
130 
131  // Resets the buffer if it has grown beyond the default/minimum size.
132  // After this, the buffer is either the default size, or it is empty, so
133  // you have to call EnsureCapacity before using it again.
134  void Reset();
135 
136  ThreadLocal thread_local_;
137  Isolate* isolate_;
138 
139  friend class ExternalReference;
140  friend class Isolate;
141  friend class RegExpStackScope;
142 
144 };
145 
146 }} // namespace v8::internal
147 
148 #endif // V8_REGEXP_STACK_H_
byte * Address
Definition: globals.h:157
Address EnsureCapacity(size_t size)
Definition: regexp-stack.cc:90
const int KB
Definition: globals.h:207
static int ArchiveSpacePerThread()
Definition: regexp-stack.h:86
#define ASSERT(condition)
Definition: checks.h:270
RegExpStack * stack() const
Definition: regexp-stack.h:49
RegExpStackScope(Isolate *isolate)
Definition: regexp-stack.cc:34
friend class ExternalReference
Definition: regexp-stack.h:139
char * ArchiveStack(char *to)
Definition: regexp-stack.cc:57
char * RestoreStack(char *from)
Definition: regexp-stack.cc:67
#define DISALLOW_COPY_AND_ASSIGN(TypeName)
Definition: globals.h:307
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if NULL
Definition: flags.cc:301
static const int kStackLimitSlack
Definition: regexp-stack.h:63
const int MB
Definition: globals.h:208