regexp-macro-assembler-tracer.cc 12.9 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-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

24 25 26
RegExpMacroAssemblerTracer::~RegExpMacroAssemblerTracer() {
}

27

28 29 30 31 32 33
void RegExpMacroAssemblerTracer::AbortedCodeGeneration() {
  PrintF(" AbortedCodeGeneration\n");
  assembler_->AbortedCodeGeneration();
}


34 35 36 37 38 39 40
// 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));
}


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

46

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

52

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


59 60 61 62 63
void RegExpMacroAssemblerTracer::PopCurrentPosition() {
  PrintF(" PopCurrentPosition();\n");
  assembler_->PopCurrentPosition();
}

64

65 66 67 68 69
void RegExpMacroAssemblerTracer::PushCurrentPosition() {
  PrintF(" PushCurrentPosition();\n");
  assembler_->PushCurrentPosition();
}

70

71 72 73 74 75
void RegExpMacroAssemblerTracer::Backtrack() {
  PrintF(" Backtrack();\n");
  assembler_->Backtrack();
}

76

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

82

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

88

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

95

96
void RegExpMacroAssemblerTracer::Fail() {
97
  PrintF(" Fail();");
98 99 100
  assembler_->Fail();
}

101

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

107

108 109 110 111 112 113 114
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);
115 116
}

117

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

123

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


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

135

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

144

145 146 147
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);
148 149 150
}


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

156

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

162

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

168

169
void RegExpMacroAssemblerTracer::LoadCurrentCharacter(int cp_offset,
170 171 172 173 174
                                                      Label* on_end_of_input,
                                                      bool check_bounds,
                                                      int characters) {
  const char* check_msg = check_bounds ? "" : " (unchecked)";
  PrintF(" LoadCurrentCharacter(cp_offset=%d, label[%08x]%s (%d chars));\n",
erik.corry@gmail.com's avatar
erik.corry@gmail.com committed
175
         cp_offset,
176
         LabelToInt(on_end_of_input),
177 178 179 180 181 182
         check_msg,
         characters);
  assembler_->LoadCurrentCharacter(cp_offset,
                                   on_end_of_input,
                                   check_bounds,
                                   characters);
erik.corry@gmail.com's avatar
erik.corry@gmail.com committed
183 184 185
}


186 187 188 189 190 191 192
class PrintablePrinter {
 public:
  explicit PrintablePrinter(uc16 character) : character_(character) { }

  const char* operator*() {
    if (character_ >= ' ' && character_ <= '~') {
      buffer_[0] = '(';
193
      buffer_[1] = static_cast<char>(character_);
194 195 196 197 198 199
      buffer_[2] = ')';
      buffer_[3] = '\0';
    } else {
      buffer_[0] = '\0';
    }
    return &buffer_[0];
200
  }
201 202 203 204 205 206 207

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


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

217

218 219
void RegExpMacroAssemblerTracer::CheckCharacterGT(uc16 limit,
                                                  Label* on_greater) {
220 221 222 223 224
  PrintablePrinter printable(limit);
  PrintF(" CheckCharacterGT(c=0x%04x%s, label[%08x]);\n",
         limit,
         *printable,
         LabelToInt(on_greater));
225 226 227
  assembler_->CheckCharacterGT(limit, on_greater);
}

228

229
void RegExpMacroAssemblerTracer::CheckCharacter(unsigned c, Label* on_equal) {
230 231 232 233 234
  PrintablePrinter printable(c);
  PrintF(" CheckCharacter(c=0x%04x%s, label[%08x]);\n",
         c,
         *printable,
         LabelToInt(on_equal));
235 236 237
  assembler_->CheckCharacter(c, on_equal);
}

238

239
void RegExpMacroAssemblerTracer::CheckAtStart(Label* on_at_start) {
240
  PrintF(" CheckAtStart(label[%08x]);\n", LabelToInt(on_at_start));
241 242 243 244
  assembler_->CheckAtStart(on_at_start);
}


245 246 247 248 249
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);
250 251 252
}


253
void RegExpMacroAssemblerTracer::CheckNotCharacter(unsigned c,
254
                                                   Label* on_not_equal) {
255 256 257 258 259
  PrintablePrinter printable(c);
  PrintF(" CheckNotCharacter(c=0x%04x%s, label[%08x]);\n",
         c,
         *printable,
         LabelToInt(on_not_equal));
260 261 262
  assembler_->CheckNotCharacter(c, on_not_equal);
}

263

264
void RegExpMacroAssemblerTracer::CheckCharacterAfterAnd(
265 266
    unsigned c,
    unsigned mask,
267
    Label* on_equal) {
268 269
  PrintablePrinter printable(c);
  PrintF(" CheckCharacterAfterAnd(c=0x%04x%s, mask=0x%04x, label[%08x]);\n",
270
         c,
271
         *printable,
272
         mask,
273
         LabelToInt(on_equal));
274 275 276 277 278
  assembler_->CheckCharacterAfterAnd(c, mask, on_equal);
}


void RegExpMacroAssemblerTracer::CheckNotCharacterAfterAnd(
279 280
    unsigned c,
    unsigned mask,
281
    Label* on_not_equal) {
282 283
  PrintablePrinter printable(c);
  PrintF(" CheckNotCharacterAfterAnd(c=0x%04x%s, mask=0x%04x, label[%08x]);\n",
284
         c,
285
         *printable,
286
         mask,
287
         LabelToInt(on_not_equal));
288
  assembler_->CheckNotCharacterAfterAnd(c, mask, on_not_equal);
289 290
}

291

292
void RegExpMacroAssemblerTracer::CheckNotCharacterAfterMinusAnd(
293
    uc16 c,
294
    uc16 minus,
295 296
    uc16 mask,
    Label* on_not_equal) {
297
  PrintF(" CheckNotCharacterAfterMinusAnd(c=0x%04x, minus=%04x, mask=0x%04x, "
298 299 300 301
             "label[%08x]);\n",
         c,
         minus,
         mask,
302
         LabelToInt(on_not_equal));
303
  assembler_->CheckNotCharacterAfterMinusAnd(c, minus, mask, on_not_equal);
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 346 347 348 349 350 351 352 353
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);
}


354
void RegExpMacroAssemblerTracer::CheckNotBackReference(int start_reg,
355
                                                       bool read_backward,
356
                                                       Label* on_no_match) {
357 358 359
  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);
360 361
}

362

363
void RegExpMacroAssemblerTracer::CheckNotBackReferenceIgnoreCase(
364 365
    int start_reg, bool read_backward, bool unicode, Label* on_no_match) {
  PrintF(" CheckNotBackReferenceIgnoreCase(register=%d, %s %s, label[%08x]);\n",
366
         start_reg, read_backward ? "backward" : "forward",
367 368
         unicode ? "unicode" : "non-unicode", LabelToInt(on_no_match));
  assembler_->CheckNotBackReferenceIgnoreCase(start_reg, read_backward, unicode,
369
                                              on_no_match);
370 371
}

372

373 374 375 376 377 378 379 380
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);
}


381 382 383 384 385
bool RegExpMacroAssemblerTracer::CheckSpecialCharacterClass(
    uc16 type,
    Label* on_no_match) {
  bool supported = assembler_->CheckSpecialCharacterClass(type,
                                                          on_no_match);
386
  PrintF(" CheckSpecialCharacterClass(type='%c', label[%08x]): %s;\n",
387
         type,
388
         LabelToInt(on_no_match),
389 390 391 392 393
         supported ? "true" : "false");
  return supported;
}


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

401

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


410 411 412
void RegExpMacroAssemblerTracer::IfRegisterGE(int register_index,
                                              int comparand, Label* if_ge) {
  PrintF(" IfRegisterGE(register=%d, number=%d, label[%08x]);\n",
413
         register_index, comparand, LabelToInt(if_ge));
414 415 416
  assembler_->IfRegisterGE(register_index, comparand, if_ge);
}

417

418 419 420 421 422
RegExpMacroAssembler::IrregexpImplementation
    RegExpMacroAssemblerTracer::Implementation() {
  return assembler_->Implementation();
}

423

424
Handle<HeapObject> RegExpMacroAssemblerTracer::GetCode(Handle<String> source) {
425
  PrintF(" GetCode(%s);\n", source->ToCString().get());
erik.corry@gmail.com's avatar
erik.corry@gmail.com committed
426
  return assembler_->GetCode(source);
427 428
}

429 430
}  // namespace internal
}  // namespace v8