Line data Source code
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.
4 :
5 : #include "src/regexp/regexp-macro-assembler-tracer.h"
6 :
7 : #include "src/ast/ast.h"
8 : #include "src/objects-inl.h"
9 :
10 : namespace v8 {
11 : namespace internal {
12 :
13 0 : RegExpMacroAssemblerTracer::RegExpMacroAssemblerTracer(
14 0 : Isolate* isolate, RegExpMacroAssembler* assembler)
15 0 : : RegExpMacroAssembler(isolate, assembler->zone()), assembler_(assembler) {
16 0 : IrregexpImplementation type = assembler->Implementation();
17 : DCHECK_LT(type, 9);
18 : const char* impl_names[] = {"IA32", "ARM", "ARM64", "MIPS", "S390",
19 0 : "PPC", "X64", "X87", "Bytecode"};
20 0 : PrintF("RegExpMacroAssembler%s();\n", impl_names[type]);
21 0 : }
22 :
23 :
24 0 : RegExpMacroAssemblerTracer::~RegExpMacroAssemblerTracer() {
25 0 : }
26 :
27 :
28 0 : void RegExpMacroAssemblerTracer::AbortedCodeGeneration() {
29 0 : PrintF(" AbortedCodeGeneration\n");
30 0 : assembler_->AbortedCodeGeneration();
31 0 : }
32 :
33 :
34 : // This is used for printing out debugging information. It makes an integer
35 : // that is closely related to the address of an object.
36 : static int LabelToInt(Label* label) {
37 0 : return static_cast<int>(reinterpret_cast<intptr_t>(label));
38 : }
39 :
40 :
41 0 : void RegExpMacroAssemblerTracer::Bind(Label* label) {
42 0 : PrintF("label[%08x]: (Bind)\n", LabelToInt(label));
43 0 : assembler_->Bind(label);
44 0 : }
45 :
46 :
47 0 : void RegExpMacroAssemblerTracer::AdvanceCurrentPosition(int by) {
48 0 : PrintF(" AdvanceCurrentPosition(by=%d);\n", by);
49 0 : assembler_->AdvanceCurrentPosition(by);
50 0 : }
51 :
52 :
53 0 : void RegExpMacroAssemblerTracer::CheckGreedyLoop(Label* label) {
54 0 : PrintF(" CheckGreedyLoop(label[%08x]);\n\n", LabelToInt(label));
55 0 : assembler_->CheckGreedyLoop(label);
56 0 : }
57 :
58 :
59 0 : void RegExpMacroAssemblerTracer::PopCurrentPosition() {
60 0 : PrintF(" PopCurrentPosition();\n");
61 0 : assembler_->PopCurrentPosition();
62 0 : }
63 :
64 :
65 0 : void RegExpMacroAssemblerTracer::PushCurrentPosition() {
66 0 : PrintF(" PushCurrentPosition();\n");
67 0 : assembler_->PushCurrentPosition();
68 0 : }
69 :
70 :
71 0 : void RegExpMacroAssemblerTracer::Backtrack() {
72 0 : PrintF(" Backtrack();\n");
73 0 : assembler_->Backtrack();
74 0 : }
75 :
76 :
77 0 : void RegExpMacroAssemblerTracer::GoTo(Label* label) {
78 0 : PrintF(" GoTo(label[%08x]);\n\n", LabelToInt(label));
79 0 : assembler_->GoTo(label);
80 0 : }
81 :
82 :
83 0 : void RegExpMacroAssemblerTracer::PushBacktrack(Label* label) {
84 0 : PrintF(" PushBacktrack(label[%08x]);\n", LabelToInt(label));
85 0 : assembler_->PushBacktrack(label);
86 0 : }
87 :
88 :
89 0 : bool RegExpMacroAssemblerTracer::Succeed() {
90 0 : bool restart = assembler_->Succeed();
91 0 : PrintF(" Succeed();%s\n", restart ? " [restart for global match]" : "");
92 0 : return restart;
93 : }
94 :
95 :
96 0 : void RegExpMacroAssemblerTracer::Fail() {
97 0 : PrintF(" Fail();");
98 0 : assembler_->Fail();
99 0 : }
100 :
101 :
102 0 : void RegExpMacroAssemblerTracer::PopRegister(int register_index) {
103 0 : PrintF(" PopRegister(register=%d);\n", register_index);
104 0 : assembler_->PopRegister(register_index);
105 0 : }
106 :
107 :
108 0 : void RegExpMacroAssemblerTracer::PushRegister(
109 : int register_index,
110 : StackCheckFlag check_stack_limit) {
111 : PrintF(" PushRegister(register=%d, %s);\n",
112 : register_index,
113 0 : check_stack_limit ? "check stack limit" : "");
114 0 : assembler_->PushRegister(register_index, check_stack_limit);
115 0 : }
116 :
117 :
118 0 : void RegExpMacroAssemblerTracer::AdvanceRegister(int reg, int by) {
119 0 : PrintF(" AdvanceRegister(register=%d, by=%d);\n", reg, by);
120 0 : assembler_->AdvanceRegister(reg, by);
121 0 : }
122 :
123 :
124 0 : void RegExpMacroAssemblerTracer::SetCurrentPositionFromEnd(int by) {
125 0 : PrintF(" SetCurrentPositionFromEnd(by=%d);\n", by);
126 0 : assembler_->SetCurrentPositionFromEnd(by);
127 0 : }
128 :
129 :
130 0 : void RegExpMacroAssemblerTracer::SetRegister(int register_index, int to) {
131 0 : PrintF(" SetRegister(register=%d, to=%d);\n", register_index, to);
132 0 : assembler_->SetRegister(register_index, to);
133 0 : }
134 :
135 :
136 0 : void RegExpMacroAssemblerTracer::WriteCurrentPositionToRegister(int reg,
137 : int cp_offset) {
138 : PrintF(" WriteCurrentPositionToRegister(register=%d,cp_offset=%d);\n",
139 : reg,
140 0 : cp_offset);
141 0 : assembler_->WriteCurrentPositionToRegister(reg, cp_offset);
142 0 : }
143 :
144 :
145 0 : void RegExpMacroAssemblerTracer::ClearRegisters(int reg_from, int reg_to) {
146 0 : PrintF(" ClearRegister(from=%d, to=%d);\n", reg_from, reg_to);
147 0 : assembler_->ClearRegisters(reg_from, reg_to);
148 0 : }
149 :
150 :
151 0 : void RegExpMacroAssemblerTracer::ReadCurrentPositionFromRegister(int reg) {
152 0 : PrintF(" ReadCurrentPositionFromRegister(register=%d);\n", reg);
153 0 : assembler_->ReadCurrentPositionFromRegister(reg);
154 0 : }
155 :
156 :
157 0 : void RegExpMacroAssemblerTracer::WriteStackPointerToRegister(int reg) {
158 0 : PrintF(" WriteStackPointerToRegister(register=%d);\n", reg);
159 0 : assembler_->WriteStackPointerToRegister(reg);
160 0 : }
161 :
162 :
163 0 : void RegExpMacroAssemblerTracer::ReadStackPointerFromRegister(int reg) {
164 0 : PrintF(" ReadStackPointerFromRegister(register=%d);\n", reg);
165 0 : assembler_->ReadStackPointerFromRegister(reg);
166 0 : }
167 :
168 :
169 0 : void RegExpMacroAssemblerTracer::LoadCurrentCharacter(int cp_offset,
170 : Label* on_end_of_input,
171 : bool check_bounds,
172 : int characters) {
173 0 : const char* check_msg = check_bounds ? "" : " (unchecked)";
174 : PrintF(" LoadCurrentCharacter(cp_offset=%d, label[%08x]%s (%d chars));\n",
175 : cp_offset,
176 : LabelToInt(on_end_of_input),
177 : check_msg,
178 0 : characters);
179 : assembler_->LoadCurrentCharacter(cp_offset,
180 : on_end_of_input,
181 : check_bounds,
182 0 : characters);
183 0 : }
184 :
185 :
186 : class PrintablePrinter {
187 : public:
188 0 : explicit PrintablePrinter(uc16 character) : character_(character) { }
189 :
190 : const char* operator*() {
191 0 : if (character_ >= ' ' && character_ <= '~') {
192 0 : buffer_[0] = '(';
193 0 : buffer_[1] = static_cast<char>(character_);
194 0 : buffer_[2] = ')';
195 0 : buffer_[3] = '\0';
196 : } else {
197 0 : buffer_[0] = '\0';
198 : }
199 : return &buffer_[0];
200 : }
201 :
202 : private:
203 : uc16 character_;
204 : char buffer_[4];
205 : };
206 :
207 :
208 0 : void RegExpMacroAssemblerTracer::CheckCharacterLT(uc16 limit, Label* on_less) {
209 : PrintablePrinter printable(limit);
210 : PrintF(" CheckCharacterLT(c=0x%04x%s, label[%08x]);\n",
211 : limit,
212 : *printable,
213 0 : LabelToInt(on_less));
214 0 : assembler_->CheckCharacterLT(limit, on_less);
215 0 : }
216 :
217 :
218 0 : void RegExpMacroAssemblerTracer::CheckCharacterGT(uc16 limit,
219 : Label* on_greater) {
220 : PrintablePrinter printable(limit);
221 : PrintF(" CheckCharacterGT(c=0x%04x%s, label[%08x]);\n",
222 : limit,
223 : *printable,
224 0 : LabelToInt(on_greater));
225 0 : assembler_->CheckCharacterGT(limit, on_greater);
226 0 : }
227 :
228 :
229 0 : void RegExpMacroAssemblerTracer::CheckCharacter(unsigned c, Label* on_equal) {
230 : PrintablePrinter printable(c);
231 : PrintF(" CheckCharacter(c=0x%04x%s, label[%08x]);\n",
232 : c,
233 : *printable,
234 0 : LabelToInt(on_equal));
235 0 : assembler_->CheckCharacter(c, on_equal);
236 0 : }
237 :
238 :
239 0 : void RegExpMacroAssemblerTracer::CheckAtStart(Label* on_at_start) {
240 0 : PrintF(" CheckAtStart(label[%08x]);\n", LabelToInt(on_at_start));
241 0 : assembler_->CheckAtStart(on_at_start);
242 0 : }
243 :
244 :
245 0 : void RegExpMacroAssemblerTracer::CheckNotAtStart(int cp_offset,
246 : Label* on_not_at_start) {
247 : PrintF(" CheckNotAtStart(cp_offset=%d, label[%08x]);\n", cp_offset,
248 0 : LabelToInt(on_not_at_start));
249 0 : assembler_->CheckNotAtStart(cp_offset, on_not_at_start);
250 0 : }
251 :
252 :
253 0 : void RegExpMacroAssemblerTracer::CheckNotCharacter(unsigned c,
254 : Label* on_not_equal) {
255 : PrintablePrinter printable(c);
256 : PrintF(" CheckNotCharacter(c=0x%04x%s, label[%08x]);\n",
257 : c,
258 : *printable,
259 0 : LabelToInt(on_not_equal));
260 0 : assembler_->CheckNotCharacter(c, on_not_equal);
261 0 : }
262 :
263 :
264 0 : void RegExpMacroAssemblerTracer::CheckCharacterAfterAnd(
265 : unsigned c,
266 : unsigned mask,
267 : Label* on_equal) {
268 : PrintablePrinter printable(c);
269 : PrintF(" CheckCharacterAfterAnd(c=0x%04x%s, mask=0x%04x, label[%08x]);\n",
270 : c,
271 : *printable,
272 : mask,
273 0 : LabelToInt(on_equal));
274 0 : assembler_->CheckCharacterAfterAnd(c, mask, on_equal);
275 0 : }
276 :
277 :
278 0 : void RegExpMacroAssemblerTracer::CheckNotCharacterAfterAnd(
279 : unsigned c,
280 : unsigned mask,
281 : Label* on_not_equal) {
282 : PrintablePrinter printable(c);
283 : PrintF(" CheckNotCharacterAfterAnd(c=0x%04x%s, mask=0x%04x, label[%08x]);\n",
284 : c,
285 : *printable,
286 : mask,
287 0 : LabelToInt(on_not_equal));
288 0 : assembler_->CheckNotCharacterAfterAnd(c, mask, on_not_equal);
289 0 : }
290 :
291 :
292 0 : void RegExpMacroAssemblerTracer::CheckNotCharacterAfterMinusAnd(
293 : uc16 c,
294 : uc16 minus,
295 : uc16 mask,
296 : Label* on_not_equal) {
297 : PrintF(" CheckNotCharacterAfterMinusAnd(c=0x%04x, minus=%04x, mask=0x%04x, "
298 : "label[%08x]);\n",
299 : c,
300 : minus,
301 : mask,
302 0 : LabelToInt(on_not_equal));
303 0 : assembler_->CheckNotCharacterAfterMinusAnd(c, minus, mask, on_not_equal);
304 0 : }
305 :
306 :
307 0 : void RegExpMacroAssemblerTracer::CheckCharacterInRange(
308 : uc16 from,
309 : uc16 to,
310 : Label* on_not_in_range) {
311 : PrintablePrinter printable_from(from);
312 : PrintablePrinter printable_to(to);
313 : PrintF(" CheckCharacterInRange(from=0x%04x%s, to=0x%04x%s, label[%08x]);\n",
314 : from,
315 : *printable_from,
316 : to,
317 : *printable_to,
318 0 : LabelToInt(on_not_in_range));
319 0 : assembler_->CheckCharacterInRange(from, to, on_not_in_range);
320 0 : }
321 :
322 :
323 0 : void RegExpMacroAssemblerTracer::CheckCharacterNotInRange(
324 : uc16 from,
325 : uc16 to,
326 : Label* on_in_range) {
327 : PrintablePrinter printable_from(from);
328 : PrintablePrinter printable_to(to);
329 : PrintF(
330 : " CheckCharacterNotInRange(from=0x%04x%s," " to=%04x%s, label[%08x]);\n",
331 : from,
332 : *printable_from,
333 : to,
334 : *printable_to,
335 0 : LabelToInt(on_in_range));
336 0 : assembler_->CheckCharacterNotInRange(from, to, on_in_range);
337 0 : }
338 :
339 :
340 0 : void RegExpMacroAssemblerTracer::CheckBitInTable(
341 : Handle<ByteArray> table, Label* on_bit_set) {
342 0 : PrintF(" CheckBitInTable(label[%08x] ", LabelToInt(on_bit_set));
343 0 : for (int i = 0; i < kTableSize; i++) {
344 0 : PrintF("%c", table->get(i) != 0 ? 'X' : '.');
345 0 : if (i % 32 == 31 && i != kTableMask) {
346 0 : PrintF("\n ");
347 : }
348 : }
349 0 : PrintF(");\n");
350 0 : assembler_->CheckBitInTable(table, on_bit_set);
351 0 : }
352 :
353 :
354 0 : void RegExpMacroAssemblerTracer::CheckNotBackReference(int start_reg,
355 : bool read_backward,
356 : Label* on_no_match) {
357 : PrintF(" CheckNotBackReference(register=%d, %s, label[%08x]);\n", start_reg,
358 0 : read_backward ? "backward" : "forward", LabelToInt(on_no_match));
359 0 : assembler_->CheckNotBackReference(start_reg, read_backward, on_no_match);
360 0 : }
361 :
362 :
363 0 : void RegExpMacroAssemblerTracer::CheckNotBackReferenceIgnoreCase(
364 : int start_reg, bool read_backward, bool unicode, Label* on_no_match) {
365 : PrintF(" CheckNotBackReferenceIgnoreCase(register=%d, %s %s, label[%08x]);\n",
366 : start_reg, read_backward ? "backward" : "forward",
367 0 : unicode ? "unicode" : "non-unicode", LabelToInt(on_no_match));
368 : assembler_->CheckNotBackReferenceIgnoreCase(start_reg, read_backward, unicode,
369 0 : on_no_match);
370 0 : }
371 :
372 :
373 0 : void RegExpMacroAssemblerTracer::CheckPosition(int cp_offset,
374 : Label* on_outside_input) {
375 : PrintF(" CheckPosition(cp_offset=%d, label[%08x]);\n", cp_offset,
376 0 : LabelToInt(on_outside_input));
377 0 : assembler_->CheckPosition(cp_offset, on_outside_input);
378 0 : }
379 :
380 :
381 0 : bool RegExpMacroAssemblerTracer::CheckSpecialCharacterClass(
382 : uc16 type,
383 : Label* on_no_match) {
384 : bool supported = assembler_->CheckSpecialCharacterClass(type,
385 0 : on_no_match);
386 : PrintF(" CheckSpecialCharacterClass(type='%c', label[%08x]): %s;\n",
387 : type,
388 : LabelToInt(on_no_match),
389 0 : supported ? "true" : "false");
390 0 : return supported;
391 : }
392 :
393 :
394 0 : void RegExpMacroAssemblerTracer::IfRegisterLT(int register_index,
395 : int comparand, Label* if_lt) {
396 : PrintF(" IfRegisterLT(register=%d, number=%d, label[%08x]);\n",
397 0 : register_index, comparand, LabelToInt(if_lt));
398 0 : assembler_->IfRegisterLT(register_index, comparand, if_lt);
399 0 : }
400 :
401 :
402 0 : void RegExpMacroAssemblerTracer::IfRegisterEqPos(int register_index,
403 : Label* if_eq) {
404 : PrintF(" IfRegisterEqPos(register=%d, label[%08x]);\n",
405 0 : register_index, LabelToInt(if_eq));
406 0 : assembler_->IfRegisterEqPos(register_index, if_eq);
407 0 : }
408 :
409 :
410 0 : void RegExpMacroAssemblerTracer::IfRegisterGE(int register_index,
411 : int comparand, Label* if_ge) {
412 : PrintF(" IfRegisterGE(register=%d, number=%d, label[%08x]);\n",
413 0 : register_index, comparand, LabelToInt(if_ge));
414 0 : assembler_->IfRegisterGE(register_index, comparand, if_ge);
415 0 : }
416 :
417 :
418 : RegExpMacroAssembler::IrregexpImplementation
419 0 : RegExpMacroAssemblerTracer::Implementation() {
420 0 : return assembler_->Implementation();
421 : }
422 :
423 :
424 0 : Handle<HeapObject> RegExpMacroAssemblerTracer::GetCode(Handle<String> source) {
425 0 : PrintF(" GetCode(%s);\n", source->ToCString().get());
426 0 : return assembler_->GetCode(source);
427 : }
428 :
429 : } // namespace internal
430 : } // namespace v8
|
