regexp-macro-assembler-tracer.cc | Explore in Territory

// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/regexp/regexp-macro-assembler-tracer.h"

#include "src/objects/fixed-array-inl.h"
#include "src/objects/string.h"

namespace v8 {
namespace internal {

RegExpMacroAssemblerTracer::RegExpMacroAssemblerTracer(
    Isolate* isolate, RegExpMacroAssembler* assembler)
    : … { … }

RegExpMacroAssemblerTracer::~RegExpMacroAssemblerTracer() = default;

void RegExpMacroAssemblerTracer::AbortedCodeGeneration() { … }


// 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) { … }


void RegExpMacroAssemblerTracer::Bind(Label* label) { … }


void RegExpMacroAssemblerTracer::AdvanceCurrentPosition(int by) { … }


void RegExpMacroAssemblerTracer::CheckGreedyLoop(Label* label) { … }


void RegExpMacroAssemblerTracer::PopCurrentPosition() { … }


void RegExpMacroAssemblerTracer::PushCurrentPosition() { … }


void RegExpMacroAssemblerTracer::Backtrack() { … }


void RegExpMacroAssemblerTracer::GoTo(Label* label) { … }


void RegExpMacroAssemblerTracer::PushBacktrack(Label* label) { … }


bool RegExpMacroAssemblerTracer::Succeed() { … }


void RegExpMacroAssemblerTracer::Fail() { … }


void RegExpMacroAssemblerTracer::PopRegister(int register_index) { … }


void RegExpMacroAssemblerTracer::PushRegister(
    int register_index,
    StackCheckFlag check_stack_limit) { … }


void RegExpMacroAssemblerTracer::AdvanceRegister(int reg, int by) { … }


void RegExpMacroAssemblerTracer::SetCurrentPositionFromEnd(int by) { … }


void RegExpMacroAssemblerTracer::SetRegister(int register_index, int to) { … }


void RegExpMacroAssemblerTracer::WriteCurrentPositionToRegister(int reg,
                                                                int cp_offset) { … }


void RegExpMacroAssemblerTracer::ClearRegisters(int reg_from, int reg_to) { … }


void RegExpMacroAssemblerTracer::ReadCurrentPositionFromRegister(int reg) { … }


void RegExpMacroAssemblerTracer::WriteStackPointerToRegister(int reg) { … }


void RegExpMacroAssemblerTracer::ReadStackPointerFromRegister(int reg) { … }

void RegExpMacroAssemblerTracer::LoadCurrentCharacterImpl(
    int cp_offset, Label* on_end_of_input, bool check_bounds, int characters,
    int eats_at_least) { … }

namespace {

class PrintablePrinter { … };

}  // namespace

void RegExpMacroAssemblerTracer::CheckCharacterLT(base::uc16 limit,
                                                  Label* on_less) { … }

void RegExpMacroAssemblerTracer::CheckCharacterGT(base::uc16 limit,
                                                  Label* on_greater) { … }

void RegExpMacroAssemblerTracer::CheckCharacter(unsigned c, Label* on_equal) { … }

void RegExpMacroAssemblerTracer::CheckAtStart(int cp_offset,
                                              Label* on_at_start) { … }

void RegExpMacroAssemblerTracer::CheckNotAtStart(int cp_offset,
                                                 Label* on_not_at_start) { … }


void RegExpMacroAssemblerTracer::CheckNotCharacter(unsigned c,
                                                   Label* on_not_equal) { … }


void RegExpMacroAssemblerTracer::CheckCharacterAfterAnd(
    unsigned c,
    unsigned mask,
    Label* on_equal) { … }


void RegExpMacroAssemblerTracer::CheckNotCharacterAfterAnd(
    unsigned c,
    unsigned mask,
    Label* on_not_equal) { … }

void RegExpMacroAssemblerTracer::CheckNotCharacterAfterMinusAnd(
    base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) { … }

void RegExpMacroAssemblerTracer::CheckCharacterInRange(base::uc16 from,
                                                       base::uc16 to,
                                                       Label* on_not_in_range) { … }

void RegExpMacroAssemblerTracer::CheckCharacterNotInRange(base::uc16 from,
                                                          base::uc16 to,
                                                          Label* on_in_range) { … }

namespace {

void PrintRangeArray(const ZoneList<CharacterRange>* ranges) { … }

}  // namespace

bool RegExpMacroAssemblerTracer::CheckCharacterInRangeArray(
    const ZoneList<CharacterRange>* ranges, Label* on_in_range) { … }

bool RegExpMacroAssemblerTracer::CheckCharacterNotInRangeArray(
    const ZoneList<CharacterRange>* ranges, Label* on_not_in_range) { … }

void RegExpMacroAssemblerTracer::CheckBitInTable(
    Handle<ByteArray> table, Label* on_bit_set) { … }


void RegExpMacroAssemblerTracer::CheckNotBackReference(int start_reg,
                                                       bool read_backward,
                                                       Label* on_no_match) { … }

void RegExpMacroAssemblerTracer::CheckNotBackReferenceIgnoreCase(
    int start_reg, bool read_backward, bool unicode, Label* on_no_match) { … }

void RegExpMacroAssemblerTracer::CheckPosition(int cp_offset,
                                               Label* on_outside_input) { … }

bool RegExpMacroAssemblerTracer::CheckSpecialClassRanges(
    StandardCharacterSet type, Label* on_no_match) { … }

void RegExpMacroAssemblerTracer::IfRegisterLT(int register_index,
                                              int comparand, Label* if_lt) { … }


void RegExpMacroAssemblerTracer::IfRegisterEqPos(int register_index,
                                                 Label* if_eq) { … }


void RegExpMacroAssemblerTracer::IfRegisterGE(int register_index,
                                              int comparand, Label* if_ge) { … }


RegExpMacroAssembler::IrregexpImplementation
    RegExpMacroAssemblerTracer::Implementation() { … }


Handle<HeapObject> RegExpMacroAssemblerTracer::GetCode(Handle<String> source) { … }

}  // namespace internal
}  // namespace v8
chromium/v8/src/regexp/regexp-macro-assembler-tracer.cc
