regexp-macro-assembler-tracer.cc 12.8 KB
Newer Older
1
// Copyright 2012 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// 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/objects-inl.h"
9

10 11
namespace v8 {
namespace internal {
12 13

RegExpMacroAssemblerTracer::RegExpMacroAssemblerTracer(
14 15
    Isolate* isolate, RegExpMacroAssembler* assembler)
    : RegExpMacroAssembler(isolate, assembler->zone()), assembler_(assembler) {
16 17 18
  IrregexpImplementation type = assembler->Implementation();
  DCHECK_LT(type, 9);
  const char* impl_names[] = {"IA32", "ARM", "ARM64", "MIPS",    "S390",
19
                              "PPC",  "X64", "X87",   "Bytecode"};
20 21 22
  PrintF("RegExpMacroAssembler%s();\n", impl_names[type]);
}

23
RegExpMacroAssemblerTracer::~RegExpMacroAssemblerTracer() = default;
24

25 26 27 28 29 30
void RegExpMacroAssemblerTracer::AbortedCodeGeneration() {
  PrintF(" AbortedCodeGeneration\n");
  assembler_->AbortedCodeGeneration();
}


31 32 33 34 35 36 37
// This is used for printing out debugging information.  It makes an integer
// that is closely related to the address of an object.
static int LabelToInt(Label* label) {
  return static_cast<int>(reinterpret_cast<intptr_t>(label));
}


38
void RegExpMacroAssemblerTracer::Bind(Label* label) {
39
  PrintF("label[%08x]: (Bind)\n", LabelToInt(label));
40 41 42
  assembler_->Bind(label);
}

43

44 45 46 47 48
void RegExpMacroAssemblerTracer::AdvanceCurrentPosition(int by) {
  PrintF(" AdvanceCurrentPosition(by=%d);\n", by);
  assembler_->AdvanceCurrentPosition(by);
}

49

erik.corry@gmail.com's avatar
erik.corry@gmail.com committed
50
void RegExpMacroAssemblerTracer::CheckGreedyLoop(Label* label) {
51
  PrintF(" CheckGreedyLoop(label[%08x]);\n\n", LabelToInt(label));
erik.corry@gmail.com's avatar
erik.corry@gmail.com committed
52 53 54 55
  assembler_->CheckGreedyLoop(label);
}


56 57 58 59 60
void RegExpMacroAssemblerTracer::PopCurrentPosition() {
  PrintF(" PopCurrentPosition();\n");
  assembler_->PopCurrentPosition();
}

61

62 63 64 65 66
void RegExpMacroAssemblerTracer::PushCurrentPosition() {
  PrintF(" PushCurrentPosition();\n");
  assembler_->PushCurrentPosition();
}

67

68 69 70 71 72
void RegExpMacroAssemblerTracer::Backtrack() {
  PrintF(" Backtrack();\n");
  assembler_->Backtrack();
}

73

74
void RegExpMacroAssemblerTracer::GoTo(Label* label) {
75
  PrintF(" GoTo(label[%08x]);\n\n", LabelToInt(label));
76 77 78
  assembler_->GoTo(label);
}

79

80
void RegExpMacroAssemblerTracer::PushBacktrack(Label* label) {
81
  PrintF(" PushBacktrack(label[%08x]);\n", LabelToInt(label));
82 83 84
  assembler_->PushBacktrack(label);
}

85

86 87 88 89
bool RegExpMacroAssemblerTracer::Succeed() {
  bool restart = assembler_->Succeed();
  PrintF(" Succeed();%s\n", restart ? " [restart for global match]" : "");
  return restart;
90 91
}

92

93
void RegExpMacroAssemblerTracer::Fail() {
94
  PrintF(" Fail();");
95 96 97
  assembler_->Fail();
}

98

99 100 101 102 103
void RegExpMacroAssemblerTracer::PopRegister(int register_index) {
  PrintF(" PopRegister(register=%d);\n", register_index);
  assembler_->PopRegister(register_index);
}

104

105 106 107 108 109 110 111
void RegExpMacroAssemblerTracer::PushRegister(
    int register_index,
    StackCheckFlag check_stack_limit) {
  PrintF(" PushRegister(register=%d, %s);\n",
         register_index,
         check_stack_limit ? "check stack limit" : "");
  assembler_->PushRegister(register_index, check_stack_limit);
112 113
}

114

115 116 117 118 119
void RegExpMacroAssemblerTracer::AdvanceRegister(int reg, int by) {
  PrintF(" AdvanceRegister(register=%d, by=%d);\n", reg, by);
  assembler_->AdvanceRegister(reg, by);
}

120

121 122 123 124 125 126
void RegExpMacroAssemblerTracer::SetCurrentPositionFromEnd(int by) {
  PrintF(" SetCurrentPositionFromEnd(by=%d);\n", by);
  assembler_->SetCurrentPositionFromEnd(by);
}


127 128 129 130 131
void RegExpMacroAssemblerTracer::SetRegister(int register_index, int to) {
  PrintF(" SetRegister(register=%d, to=%d);\n", register_index, to);
  assembler_->SetRegister(register_index, to);
}

132

erik.corry@gmail.com's avatar
erik.corry@gmail.com committed
133 134 135 136 137 138
void RegExpMacroAssemblerTracer::WriteCurrentPositionToRegister(int reg,
                                                                int cp_offset) {
  PrintF(" WriteCurrentPositionToRegister(register=%d,cp_offset=%d);\n",
         reg,
         cp_offset);
  assembler_->WriteCurrentPositionToRegister(reg, cp_offset);
139 140
}

141

142 143 144
void RegExpMacroAssemblerTracer::ClearRegisters(int reg_from, int reg_to) {
  PrintF(" ClearRegister(from=%d, to=%d);\n", reg_from, reg_to);
  assembler_->ClearRegisters(reg_from, reg_to);
145 146 147
}


148 149 150 151 152
void RegExpMacroAssemblerTracer::ReadCurrentPositionFromRegister(int reg) {
  PrintF(" ReadCurrentPositionFromRegister(register=%d);\n", reg);
  assembler_->ReadCurrentPositionFromRegister(reg);
}

153

154 155 156 157 158
void RegExpMacroAssemblerTracer::WriteStackPointerToRegister(int reg) {
  PrintF(" WriteStackPointerToRegister(register=%d);\n", reg);
  assembler_->WriteStackPointerToRegister(reg);
}

159

160 161 162 163 164
void RegExpMacroAssemblerTracer::ReadStackPointerFromRegister(int reg) {
  PrintF(" ReadStackPointerFromRegister(register=%d);\n", reg);
  assembler_->ReadStackPointerFromRegister(reg);
}

165 166 167
void RegExpMacroAssemblerTracer::LoadCurrentCharacterImpl(
    int cp_offset, Label* on_end_of_input, bool check_bounds, int characters,
    int eats_at_least) {
168
  const char* check_msg = check_bounds ? "" : " (unchecked)";
169 170 171 172 173 174 175
  PrintF(
      " LoadCurrentCharacter(cp_offset=%d, label[%08x]%s (%d chars) (eats at "
      "least %d));\n",
      cp_offset, LabelToInt(on_end_of_input), check_msg, characters,
      eats_at_least);
  assembler_->LoadCurrentCharacter(cp_offset, on_end_of_input, check_bounds,
                                   characters, eats_at_least);
erik.corry@gmail.com's avatar
erik.corry@gmail.com committed
176 177
}

178 179 180 181 182 183 184
class PrintablePrinter {
 public:
  explicit PrintablePrinter(uc16 character) : character_(character) { }

  const char* operator*() {
    if (character_ >= ' ' && character_ <= '~') {
      buffer_[0] = '(';
185
      buffer_[1] = static_cast<char>(character_);
186 187 188 189 190 191
      buffer_[2] = ')';
      buffer_[3] = '\0';
    } else {
      buffer_[0] = '\0';
    }
    return &buffer_[0];
192
  }
193 194 195 196 197 198 199

 private:
  uc16 character_;
  char buffer_[4];
};


200
void RegExpMacroAssemblerTracer::CheckCharacterLT(uc16 limit, Label* on_less) {
201 202 203 204 205
  PrintablePrinter printable(limit);
  PrintF(" CheckCharacterLT(c=0x%04x%s, label[%08x]);\n",
         limit,
         *printable,
         LabelToInt(on_less));
206 207 208
  assembler_->CheckCharacterLT(limit, on_less);
}

209

210 211
void RegExpMacroAssemblerTracer::CheckCharacterGT(uc16 limit,
                                                  Label* on_greater) {
212 213 214 215 216
  PrintablePrinter printable(limit);
  PrintF(" CheckCharacterGT(c=0x%04x%s, label[%08x]);\n",
         limit,
         *printable,
         LabelToInt(on_greater));
217 218 219
  assembler_->CheckCharacterGT(limit, on_greater);
}

220

221
void RegExpMacroAssemblerTracer::CheckCharacter(unsigned c, Label* on_equal) {
222 223 224 225 226
  PrintablePrinter printable(c);
  PrintF(" CheckCharacter(c=0x%04x%s, label[%08x]);\n",
         c,
         *printable,
         LabelToInt(on_equal));
227 228 229
  assembler_->CheckCharacter(c, on_equal);
}

230

231
void RegExpMacroAssemblerTracer::CheckAtStart(Label* on_at_start) {
232
  PrintF(" CheckAtStart(label[%08x]);\n", LabelToInt(on_at_start));
233 234 235 236
  assembler_->CheckAtStart(on_at_start);
}


237 238 239 240 241
void RegExpMacroAssemblerTracer::CheckNotAtStart(int cp_offset,
                                                 Label* on_not_at_start) {
  PrintF(" CheckNotAtStart(cp_offset=%d, label[%08x]);\n", cp_offset,
         LabelToInt(on_not_at_start));
  assembler_->CheckNotAtStart(cp_offset, on_not_at_start);
242 243 244
}


245
void RegExpMacroAssemblerTracer::CheckNotCharacter(unsigned c,
246
                                                   Label* on_not_equal) {
247 248 249 250 251
  PrintablePrinter printable(c);
  PrintF(" CheckNotCharacter(c=0x%04x%s, label[%08x]);\n",
         c,
         *printable,
         LabelToInt(on_not_equal));
252 253 254
  assembler_->CheckNotCharacter(c, on_not_equal);
}

255

256
void RegExpMacroAssemblerTracer::CheckCharacterAfterAnd(
257 258
    unsigned c,
    unsigned mask,
259
    Label* on_equal) {
260 261
  PrintablePrinter printable(c);
  PrintF(" CheckCharacterAfterAnd(c=0x%04x%s, mask=0x%04x, label[%08x]);\n",
262
         c,
263
         *printable,
264
         mask,
265
         LabelToInt(on_equal));
266 267 268 269 270
  assembler_->CheckCharacterAfterAnd(c, mask, on_equal);
}


void RegExpMacroAssemblerTracer::CheckNotCharacterAfterAnd(
271 272
    unsigned c,
    unsigned mask,
273
    Label* on_not_equal) {
274 275
  PrintablePrinter printable(c);
  PrintF(" CheckNotCharacterAfterAnd(c=0x%04x%s, mask=0x%04x, label[%08x]);\n",
276
         c,
277
         *printable,
278
         mask,
279
         LabelToInt(on_not_equal));
280
  assembler_->CheckNotCharacterAfterAnd(c, mask, on_not_equal);
281 282
}

283

284
void RegExpMacroAssemblerTracer::CheckNotCharacterAfterMinusAnd(
285
    uc16 c,
286
    uc16 minus,
287 288
    uc16 mask,
    Label* on_not_equal) {
289
  PrintF(" CheckNotCharacterAfterMinusAnd(c=0x%04x, minus=%04x, mask=0x%04x, "
290 291 292 293
             "label[%08x]);\n",
         c,
         minus,
         mask,
294
         LabelToInt(on_not_equal));
295
  assembler_->CheckNotCharacterAfterMinusAnd(c, minus, mask, on_not_equal);
296 297
}

298

299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
void RegExpMacroAssemblerTracer::CheckCharacterInRange(
    uc16 from,
    uc16 to,
    Label* on_not_in_range) {
  PrintablePrinter printable_from(from);
  PrintablePrinter printable_to(to);
  PrintF(" CheckCharacterInRange(from=0x%04x%s, to=0x%04x%s, label[%08x]);\n",
         from,
         *printable_from,
         to,
         *printable_to,
         LabelToInt(on_not_in_range));
  assembler_->CheckCharacterInRange(from, to, on_not_in_range);
}


void RegExpMacroAssemblerTracer::CheckCharacterNotInRange(
    uc16 from,
    uc16 to,
    Label* on_in_range) {
  PrintablePrinter printable_from(from);
  PrintablePrinter printable_to(to);
  PrintF(
      " CheckCharacterNotInRange(from=0x%04x%s," " to=%04x%s, label[%08x]);\n",
      from,
      *printable_from,
      to,
      *printable_to,
      LabelToInt(on_in_range));
  assembler_->CheckCharacterNotInRange(from, to, on_in_range);
}


void RegExpMacroAssemblerTracer::CheckBitInTable(
    Handle<ByteArray> table, Label* on_bit_set) {
  PrintF(" CheckBitInTable(label[%08x] ", LabelToInt(on_bit_set));
  for (int i = 0; i < kTableSize; i++) {
    PrintF("%c", table->get(i) != 0 ? 'X' : '.');
    if (i % 32 == 31 && i != kTableMask) {
      PrintF("\n                                 ");
    }
  }
  PrintF(");\n");
  assembler_->CheckBitInTable(table, on_bit_set);
}


346
void RegExpMacroAssemblerTracer::CheckNotBackReference(int start_reg,
347
                                                       bool read_backward,
348
                                                       Label* on_no_match) {
349 350 351
  PrintF(" CheckNotBackReference(register=%d, %s, label[%08x]);\n", start_reg,
         read_backward ? "backward" : "forward", LabelToInt(on_no_match));
  assembler_->CheckNotBackReference(start_reg, read_backward, on_no_match);
352 353
}

354

355
void RegExpMacroAssemblerTracer::CheckNotBackReferenceIgnoreCase(
356 357
    int start_reg, bool read_backward, bool unicode, Label* on_no_match) {
  PrintF(" CheckNotBackReferenceIgnoreCase(register=%d, %s %s, label[%08x]);\n",
358
         start_reg, read_backward ? "backward" : "forward",
359 360
         unicode ? "unicode" : "non-unicode", LabelToInt(on_no_match));
  assembler_->CheckNotBackReferenceIgnoreCase(start_reg, read_backward, unicode,
361
                                              on_no_match);
362 363
}

364

365 366 367 368 369 370 371 372
void RegExpMacroAssemblerTracer::CheckPosition(int cp_offset,
                                               Label* on_outside_input) {
  PrintF(" CheckPosition(cp_offset=%d, label[%08x]);\n", cp_offset,
         LabelToInt(on_outside_input));
  assembler_->CheckPosition(cp_offset, on_outside_input);
}


373 374 375 376 377
bool RegExpMacroAssemblerTracer::CheckSpecialCharacterClass(
    uc16 type,
    Label* on_no_match) {
  bool supported = assembler_->CheckSpecialCharacterClass(type,
                                                          on_no_match);
378
  PrintF(" CheckSpecialCharacterClass(type='%c', label[%08x]): %s;\n",
379
         type,
380
         LabelToInt(on_no_match),
381 382 383 384 385
         supported ? "true" : "false");
  return supported;
}


386 387 388
void RegExpMacroAssemblerTracer::IfRegisterLT(int register_index,
                                              int comparand, Label* if_lt) {
  PrintF(" IfRegisterLT(register=%d, number=%d, label[%08x]);\n",
389
         register_index, comparand, LabelToInt(if_lt));
390 391 392
  assembler_->IfRegisterLT(register_index, comparand, if_lt);
}

393

394 395 396
void RegExpMacroAssemblerTracer::IfRegisterEqPos(int register_index,
                                                 Label* if_eq) {
  PrintF(" IfRegisterEqPos(register=%d, label[%08x]);\n",
397
         register_index, LabelToInt(if_eq));
398 399 400 401
  assembler_->IfRegisterEqPos(register_index, if_eq);
}


402 403 404
void RegExpMacroAssemblerTracer::IfRegisterGE(int register_index,
                                              int comparand, Label* if_ge) {
  PrintF(" IfRegisterGE(register=%d, number=%d, label[%08x]);\n",
405
         register_index, comparand, LabelToInt(if_ge));
406 407 408
  assembler_->IfRegisterGE(register_index, comparand, if_ge);
}

409

410 411 412 413 414
RegExpMacroAssembler::IrregexpImplementation
    RegExpMacroAssemblerTracer::Implementation() {
  return assembler_->Implementation();
}

415

416
Handle<HeapObject> RegExpMacroAssemblerTracer::GetCode(Handle<String> source) {
417
  PrintF(" GetCode(%s);\n", source->ToCString().get());
erik.corry@gmail.com's avatar
erik.corry@gmail.com committed
418
  return assembler_->GetCode(source);
419 420
}

421 422
}  // namespace internal
}  // namespace v8