1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef V8_REGEXP_IA32_REGEXP_MACRO_ASSEMBLER_IA32_H_
6 #define V8_REGEXP_IA32_REGEXP_MACRO_ASSEMBLER_IA32_H_
8 #include "src/ia32/assembler-ia32.h"
9 #include "src/macro-assembler.h"
10 #include "src/regexp/regexp-macro-assembler.h"
15 #ifndef V8_INTERPRETED_REGEXP
16 class RegExpMacroAssemblerIA32: public NativeRegExpMacroAssembler {
18 RegExpMacroAssemblerIA32(Isolate* isolate, Zone* zone, Mode mode,
19 int registers_to_save);
20 virtual ~RegExpMacroAssemblerIA32();
21 virtual int stack_limit_slack();
22 virtual void AdvanceCurrentPosition(int by);
23 virtual void AdvanceRegister(int reg, int by);
24 virtual void Backtrack();
25 virtual void Bind(Label* label);
26 virtual void CheckAtStart(Label* on_at_start);
27 virtual void CheckCharacter(uint32_t c, Label* on_equal);
28 virtual void CheckCharacterAfterAnd(uint32_t c,
31 virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
32 virtual void CheckCharacterLT(uc16 limit, Label* on_less);
33 // A "greedy loop" is a loop that is both greedy and with a simple
34 // body. It has a particularly simple implementation.
35 virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
36 virtual void CheckNotAtStart(Label* on_not_at_start);
37 virtual void CheckNotBackReference(int start_reg, Label* on_no_match);
38 virtual void CheckNotBackReferenceIgnoreCase(int start_reg,
40 virtual void CheckNotCharacter(uint32_t c, Label* on_not_equal);
41 virtual void CheckNotCharacterAfterAnd(uint32_t c,
44 virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
48 virtual void CheckCharacterInRange(uc16 from,
51 virtual void CheckCharacterNotInRange(uc16 from,
53 Label* on_not_in_range);
54 virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
56 // Checks whether the given offset from the current position is before
57 // the end of the string.
58 virtual void CheckPosition(int cp_offset, Label* on_outside_input);
59 virtual bool CheckSpecialCharacterClass(uc16 type, Label* on_no_match);
61 virtual Handle<HeapObject> GetCode(Handle<String> source);
62 virtual void GoTo(Label* label);
63 virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
64 virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
65 virtual void IfRegisterEqPos(int reg, Label* if_eq);
66 virtual IrregexpImplementation Implementation();
67 virtual void LoadCurrentCharacter(int cp_offset,
68 Label* on_end_of_input,
69 bool check_bounds = true,
71 virtual void PopCurrentPosition();
72 virtual void PopRegister(int register_index);
73 virtual void PushBacktrack(Label* label);
74 virtual void PushCurrentPosition();
75 virtual void PushRegister(int register_index,
76 StackCheckFlag check_stack_limit);
77 virtual void ReadCurrentPositionFromRegister(int reg);
78 virtual void ReadStackPointerFromRegister(int reg);
79 virtual void SetCurrentPositionFromEnd(int by);
80 virtual void SetRegister(int register_index, int to);
81 virtual bool Succeed();
82 virtual void WriteCurrentPositionToRegister(int reg, int cp_offset);
83 virtual void ClearRegisters(int reg_from, int reg_to);
84 virtual void WriteStackPointerToRegister(int reg);
86 // Called from RegExp if the stack-guard is triggered.
87 // If the code object is relocated, the return address is fixed before
89 static int CheckStackGuardState(Address* return_address,
94 // Offsets from ebp of function parameters and stored registers.
95 static const int kFramePointer = 0;
96 // Above the frame pointer - function parameters and return address.
97 static const int kReturn_eip = kFramePointer + kPointerSize;
98 static const int kFrameAlign = kReturn_eip + kPointerSize;
100 static const int kInputString = kFrameAlign;
101 static const int kStartIndex = kInputString + kPointerSize;
102 static const int kInputStart = kStartIndex + kPointerSize;
103 static const int kInputEnd = kInputStart + kPointerSize;
104 static const int kRegisterOutput = kInputEnd + kPointerSize;
105 // For the case of global regular expression, we have room to store at least
106 // one set of capture results. For the case of non-global regexp, we ignore
108 static const int kNumOutputRegisters = kRegisterOutput + kPointerSize;
109 static const int kStackHighEnd = kNumOutputRegisters + kPointerSize;
110 static const int kDirectCall = kStackHighEnd + kPointerSize;
111 static const int kIsolate = kDirectCall + kPointerSize;
112 // Below the frame pointer - local stack variables.
113 // When adding local variables remember to push space for them in
114 // the frame in GetCode.
115 static const int kBackup_esi = kFramePointer - kPointerSize;
116 static const int kBackup_edi = kBackup_esi - kPointerSize;
117 static const int kBackup_ebx = kBackup_edi - kPointerSize;
118 static const int kSuccessfulCaptures = kBackup_ebx - kPointerSize;
119 static const int kInputStartMinusOne = kSuccessfulCaptures - kPointerSize;
120 // First register address. Following registers are below it on the stack.
121 static const int kRegisterZero = kInputStartMinusOne - kPointerSize;
123 // Initial size of code buffer.
124 static const size_t kRegExpCodeSize = 1024;
126 // Load a number of characters at the given offset from the
127 // current position, into the current-character register.
128 void LoadCurrentCharacterUnchecked(int cp_offset, int character_count);
130 // Check whether preemption has been requested.
131 void CheckPreemption();
133 // Check whether we are exceeding the stack limit on the backtrack stack.
134 void CheckStackLimit();
136 // Generate a call to CheckStackGuardState.
137 void CallCheckStackGuardState(Register scratch);
139 // The ebp-relative location of a regexp register.
140 Operand register_location(int register_index);
142 // The register containing the current character after LoadCurrentCharacter.
143 inline Register current_character() { return edx; }
145 // The register containing the backtrack stack top. Provides a meaningful
146 // name to the register.
147 inline Register backtrack_stackpointer() { return ecx; }
149 // Byte size of chars in the string to match (decided by the Mode argument)
150 inline int char_size() { return static_cast<int>(mode_); }
152 // Equivalent to a conditional branch to the label, unless the label
153 // is NULL, in which case it is a conditional Backtrack.
154 void BranchOrBacktrack(Condition condition, Label* to);
156 // Call and return internally in the generated code in a way that
157 // is GC-safe (i.e., doesn't leave absolute code addresses on the stack)
158 inline void SafeCall(Label* to);
159 inline void SafeReturn();
160 inline void SafeCallTarget(Label* name);
162 // Pushes the value of a register on the backtrack stack. Decrements the
163 // stack pointer (ecx) by a word size and stores the register's value there.
164 inline void Push(Register source);
166 // Pushes a value on the backtrack stack. Decrements the stack pointer (ecx)
167 // by a word size and stores the value there.
168 inline void Push(Immediate value);
170 // Pops a value from the backtrack stack. Reads the word at the stack pointer
171 // (ecx) and increments it by a word size.
172 inline void Pop(Register target);
174 Isolate* isolate() const { return masm_->isolate(); }
176 MacroAssembler* masm_;
178 // Which mode to generate code for (LATIN1 or UC16).
181 // One greater than maximal register index actually used.
184 // Number of registers to output at the end (the saved registers
185 // are always 0..num_saved_registers_-1)
186 int num_saved_registers_;
188 // Labels used internally.
191 Label success_label_;
192 Label backtrack_label_;
194 Label check_preempt_label_;
195 Label stack_overflow_label_;
197 #endif // V8_INTERPRETED_REGEXP
199 }} // namespace v8::internal
201 #endif // V8_REGEXP_IA32_REGEXP_MACRO_ASSEMBLER_IA32_H_