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_X64_REGEXP_MACRO_ASSEMBLER_X64_H_
6 #define V8_REGEXP_X64_REGEXP_MACRO_ASSEMBLER_X64_H_
8 #include "src/macro-assembler.h"
9 #include "src/regexp/regexp-macro-assembler.h"
10 #include "src/x64/assembler-x64.h"
15 #ifndef V8_INTERPRETED_REGEXP
17 class RegExpMacroAssemblerX64: public NativeRegExpMacroAssembler {
19 RegExpMacroAssemblerX64(Isolate* isolate, Zone* zone, Mode mode,
20 int registers_to_save);
21 virtual ~RegExpMacroAssemblerX64();
22 virtual int stack_limit_slack();
23 virtual void AdvanceCurrentPosition(int by);
24 virtual void AdvanceRegister(int reg, int by);
25 virtual void Backtrack();
26 virtual void Bind(Label* label);
27 virtual void CheckAtStart(Label* on_at_start);
28 virtual void CheckCharacter(uint32_t c, Label* on_equal);
29 virtual void CheckCharacterAfterAnd(uint32_t c,
32 virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
33 virtual void CheckCharacterLT(uc16 limit, Label* on_less);
34 // A "greedy loop" is a loop that is both greedy and with a simple
35 // body. It has a particularly simple implementation.
36 virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
37 virtual void CheckNotAtStart(Label* on_not_at_start);
38 virtual void CheckNotBackReference(int start_reg, Label* on_no_match);
39 virtual void CheckNotBackReferenceIgnoreCase(int start_reg,
41 virtual void CheckNotCharacter(uint32_t c, Label* on_not_equal);
42 virtual void CheckNotCharacterAfterAnd(uint32_t c,
45 virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
49 virtual void CheckCharacterInRange(uc16 from,
52 virtual void CheckCharacterNotInRange(uc16 from,
54 Label* on_not_in_range);
55 virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
57 // Checks whether the given offset from the current position is before
58 // the end of the string.
59 virtual void CheckPosition(int cp_offset, Label* on_outside_input);
60 virtual bool CheckSpecialCharacterClass(uc16 type,
63 virtual Handle<HeapObject> GetCode(Handle<String> source);
64 virtual void GoTo(Label* label);
65 virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
66 virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
67 virtual void IfRegisterEqPos(int reg, Label* if_eq);
68 virtual IrregexpImplementation Implementation();
69 virtual void LoadCurrentCharacter(int cp_offset,
70 Label* on_end_of_input,
71 bool check_bounds = true,
73 virtual void PopCurrentPosition();
74 virtual void PopRegister(int register_index);
75 virtual void PushBacktrack(Label* label);
76 virtual void PushCurrentPosition();
77 virtual void PushRegister(int register_index,
78 StackCheckFlag check_stack_limit);
79 virtual void ReadCurrentPositionFromRegister(int reg);
80 virtual void ReadStackPointerFromRegister(int reg);
81 virtual void SetCurrentPositionFromEnd(int by);
82 virtual void SetRegister(int register_index, int to);
83 virtual bool Succeed();
84 virtual void WriteCurrentPositionToRegister(int reg, int cp_offset);
85 virtual void ClearRegisters(int reg_from, int reg_to);
86 virtual void WriteStackPointerToRegister(int reg);
88 static Result Match(Handle<Code> regexp,
89 Handle<String> subject,
91 int offsets_vector_length,
95 static Result Execute(Code* code,
98 const byte* input_start,
99 const byte* input_end,
103 // Called from RegExp if the stack-guard is triggered.
104 // If the code object is relocated, the return address is fixed before
106 static int CheckStackGuardState(Address* return_address,
111 // Offsets from rbp of function parameters and stored registers.
112 static const int kFramePointer = 0;
113 // Above the frame pointer - function parameters and return address.
114 static const int kReturn_eip = kFramePointer + kRegisterSize;
115 static const int kFrameAlign = kReturn_eip + kRegisterSize;
118 // Parameters (first four passed as registers, but with room on stack).
119 // In Microsoft 64-bit Calling Convention, there is room on the callers
120 // stack (before the return address) to spill parameter registers. We
121 // use this space to store the register passed parameters.
122 static const int kInputString = kFrameAlign;
123 // StartIndex is passed as 32 bit int.
124 static const int kStartIndex = kInputString + kRegisterSize;
125 static const int kInputStart = kStartIndex + kRegisterSize;
126 static const int kInputEnd = kInputStart + kRegisterSize;
127 static const int kRegisterOutput = kInputEnd + kRegisterSize;
128 // For the case of global regular expression, we have room to store at least
129 // one set of capture results. For the case of non-global regexp, we ignore
130 // this value. NumOutputRegisters is passed as 32-bit value. The upper
131 // 32 bit of this 64-bit stack slot may contain garbage.
132 static const int kNumOutputRegisters = kRegisterOutput + kRegisterSize;
133 static const int kStackHighEnd = kNumOutputRegisters + kRegisterSize;
134 // DirectCall is passed as 32 bit int (values 0 or 1).
135 static const int kDirectCall = kStackHighEnd + kRegisterSize;
136 static const int kIsolate = kDirectCall + kRegisterSize;
138 // In AMD64 ABI Calling Convention, the first six integer parameters
139 // are passed as registers, and caller must allocate space on the stack
140 // if it wants them stored. We push the parameters after the frame pointer.
141 static const int kInputString = kFramePointer - kRegisterSize;
142 static const int kStartIndex = kInputString - kRegisterSize;
143 static const int kInputStart = kStartIndex - kRegisterSize;
144 static const int kInputEnd = kInputStart - kRegisterSize;
145 static const int kRegisterOutput = kInputEnd - kRegisterSize;
147 // For the case of global regular expression, we have room to store at least
148 // one set of capture results. For the case of non-global regexp, we ignore
150 static const int kNumOutputRegisters = kRegisterOutput - kRegisterSize;
151 static const int kStackHighEnd = kFrameAlign;
152 static const int kDirectCall = kStackHighEnd + kRegisterSize;
153 static const int kIsolate = kDirectCall + kRegisterSize;
157 // Microsoft calling convention has three callee-saved registers
158 // (that we are using). We push these after the frame pointer.
159 static const int kBackup_rsi = kFramePointer - kRegisterSize;
160 static const int kBackup_rdi = kBackup_rsi - kRegisterSize;
161 static const int kBackup_rbx = kBackup_rdi - kRegisterSize;
162 static const int kLastCalleeSaveRegister = kBackup_rbx;
164 // AMD64 Calling Convention has only one callee-save register that
165 // we use. We push this after the frame pointer (and after the
167 static const int kBackup_rbx = kNumOutputRegisters - kRegisterSize;
168 static const int kLastCalleeSaveRegister = kBackup_rbx;
171 static const int kSuccessfulCaptures = kLastCalleeSaveRegister - kPointerSize;
172 // When adding local variables remember to push space for them in
173 // the frame in GetCode.
174 static const int kInputStartMinusOne = kSuccessfulCaptures - kPointerSize;
176 // First register address. Following registers are below it on the stack.
177 static const int kRegisterZero = kInputStartMinusOne - kPointerSize;
179 // Initial size of code buffer.
180 static const size_t kRegExpCodeSize = 1024;
182 // Load a number of characters at the given offset from the
183 // current position, into the current-character register.
184 void LoadCurrentCharacterUnchecked(int cp_offset, int character_count);
186 // Check whether preemption has been requested.
187 void CheckPreemption();
189 // Check whether we are exceeding the stack limit on the backtrack stack.
190 void CheckStackLimit();
192 // Generate a call to CheckStackGuardState.
193 void CallCheckStackGuardState();
195 // The rbp-relative location of a regexp register.
196 Operand register_location(int register_index);
198 // The register containing the current character after LoadCurrentCharacter.
199 inline Register current_character() { return rdx; }
201 // The register containing the backtrack stack top. Provides a meaningful
202 // name to the register.
203 inline Register backtrack_stackpointer() { return rcx; }
205 // The registers containing a self pointer to this code's Code object.
206 inline Register code_object_pointer() { return r8; }
208 // Byte size of chars in the string to match (decided by the Mode argument)
209 inline int char_size() { return static_cast<int>(mode_); }
211 // Equivalent to a conditional branch to the label, unless the label
212 // is NULL, in which case it is a conditional Backtrack.
213 void BranchOrBacktrack(Condition condition, Label* to);
215 void MarkPositionForCodeRelativeFixup() {
216 code_relative_fixup_positions_.Add(masm_.pc_offset(), zone());
219 void FixupCodeRelativePositions();
221 // Call and return internally in the generated code in a way that
222 // is GC-safe (i.e., doesn't leave absolute code addresses on the stack)
223 inline void SafeCall(Label* to);
224 inline void SafeCallTarget(Label* label);
225 inline void SafeReturn();
227 // Pushes the value of a register on the backtrack stack. Decrements the
228 // stack pointer (rcx) by a word size and stores the register's value there.
229 inline void Push(Register source);
231 // Pushes a value on the backtrack stack. Decrements the stack pointer (rcx)
232 // by a word size and stores the value there.
233 inline void Push(Immediate value);
235 // Pushes the Code object relative offset of a label on the backtrack stack
236 // (i.e., a backtrack target). Decrements the stack pointer (rcx)
237 // by a word size and stores the value there.
238 inline void Push(Label* label);
240 // Pops a value from the backtrack stack. Reads the word at the stack pointer
241 // (rcx) and increments it by a word size.
242 inline void Pop(Register target);
244 // Drops the top value from the backtrack stack without reading it.
245 // Increments the stack pointer (rcx) by a word size.
248 inline void ReadPositionFromRegister(Register dst, int reg);
250 Isolate* isolate() const { return masm_.isolate(); }
252 MacroAssembler masm_;
253 MacroAssembler::NoRootArrayScope no_root_array_scope_;
255 ZoneList<int> code_relative_fixup_positions_;
257 // Which mode to generate code for (LATIN1 or UC16).
260 // One greater than maximal register index actually used.
263 // Number of registers to output at the end (the saved registers
264 // are always 0..num_saved_registers_-1)
265 int num_saved_registers_;
267 // Labels used internally.
270 Label success_label_;
271 Label backtrack_label_;
273 Label check_preempt_label_;
274 Label stack_overflow_label_;
277 #endif // V8_INTERPRETED_REGEXP
279 } // namespace internal
282 #endif // V8_REGEXP_X64_REGEXP_MACRO_ASSEMBLER_X64_H_