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