Lines Matching full:trace
704 // manipulation in an object called the Trace. The Trace object can record a
707 // to be emitted it can flush the Trace or update it. Flushing the Trace
716 // The virtual state found in the Trace affects code generation. For example
720 // string. Therefore code generated for a non-trivial trace is specialized
721 // to that trace. The code generator therefore has the ability to generate
725 // trace is flushed and a generic version of the code for a node is emitted.
727 // trace is not recorded in the node and so it cannot currently be reused in
728 // the event that code generation is requested for an identical trace.
902 Trace new_trace;
926 bool Trace::DeferredAction::Mentions(int that) {
936 bool Trace::mentions_reg(int reg) {
947 bool Trace::GetStoredPosition(int reg, int* cp_offset) {
965 int Trace::FindAffectedRegisters(OutSet* affected_registers) {
984 void Trace::RestoreAffectedRegisters(RegExpMacroAssembler* assembler,
1001 void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
1017 // The chronologically first deferred action in the trace
1035 Trace::DeferredSetRegister* psr =
1036 static_cast<Trace::DeferredSetRegister*>(action);
1060 Trace::DeferredCapture* pc =
1061 static_cast<Trace::DeferredCapture*>(action);
1133 void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {
1144 Trace new_state;
1174 Trace new_state;
1192 void NegativeSubmatchSuccess::Emit(RegExpCompiler* compiler, Trace* trace) {
1195 // Omit flushing the trace. We discard the entire stack frame anyway.
1198 // We are completely independent of the trace, since we ignore it,
1219 void EndNode::Emit(RegExpCompiler* compiler, Trace* trace) {
1220 if (!trace->is_trivial()) {
1221 trace->Flush(compiler, this);
1233 assembler->GoTo(trace->backtrack());
1341 Trace* trace) {
1344 ASSERT(!trace->mentions_reg(guard->reg()));
1347 trace->backtrack());
1350 ASSERT(!trace->mentions_reg(guard->reg()));
1353 trace->backtrack());
1666 Trace* trace) {
1668 if (trace->stop_node() != NULL) {
1673 if (trace->is_trivial()) {
1704 trace->Flush(compiler, this);
1857 Trace* trace,
1863 GetQuickCheckDetails(details, compiler, 0, trace->at_start() == Trace::FALSE);
1873 if (trace->characters_preloaded() != details->characters()) {
1874 assembler->LoadCurrentCharacter(trace->cp_offset(),
1875 trace->backtrack(),
1914 assembler->CheckNotCharacterAfterAnd(value, mask, trace->backtrack());
1916 assembler->CheckNotCharacter(value, trace->backtrack());
2220 Trace* trace) {
2224 Trace new_trace(*trace);
2257 Trace* trace) {
2261 Trace new_trace(*trace);
2268 switch (trace->at_start()) {
2269 case Trace::TRUE:
2274 case Trace::UNKNOWN:
2275 ASSERT_EQ(0, trace->cp_offset());
2278 case Trace::FALSE:
2279 int prev_char_offset = trace->cp_offset() - 1;
2296 Trace* trace) {
2300 if (trace->characters_preloaded() != 1) {
2301 assembler->LoadCurrentCharacter(trace->cp_offset(), &before_non_word);
2308 Trace new_trace(*trace);
2374 void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2379 assembler->CheckPosition(trace->cp_offset(), &ok);
2380 assembler->GoTo(trace->backtrack());
2385 if (trace->at_start() == Trace::FALSE) {
2386 assembler->GoTo(trace->backtrack());
2389 if (trace->at_start() == Trace::UNKNOWN) {
2390 assembler->CheckNotAtStart(trace->backtrack());
2391 Trace at_start_trace = *trace;
2399 EmitHat(compiler, on_success(), trace);
2403 EmitBoundaryCheck(type_, compiler, on_success(), trace);
2408 EmitHalfBoundaryCheck(type_, compiler, on_success(), trace);
2411 on_success()->Emit(compiler, trace);
2450 // In addition to all this we are passed a Trace, which can
2461 Trace* trace,
2467 Label* backtrack = trace->backtrack();
2468 QuickCheckDetails* quick_check = trace->quick_check_performed();
2472 int cp_offset = trace->cp_offset() + elm.cp_offset;
2557 void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2558 LimitResult limit_result = LimitVersions(compiler, trace);
2562 if (trace->cp_offset() + Length() > RegExpMacroAssembler::kMaxCPOffset) {
2569 TextEmitPass(compiler, NON_ASCII_MATCH, false, trace, false, &dummy);
2573 int bound_checked_to = trace->cp_offset() - 1;
2574 bound_checked_to += trace->bound_checked_up_to();
2578 if (trace->characters_preloaded() == 1) {
2584 trace,
2597 trace,
2603 Trace successor_trace(*trace);
2611 void Trace::InvalidateCurrentCharacter() {
2616 void Trace::AdvanceCurrentPositionInTrace(int by, RegExpCompiler* compiler) {
2705 void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2707 if (trace->stop_node() == this) {
2713 ASSERT(trace->cp_offset() == text_length);
2715 macro_assembler->GoTo(trace->loop_label());
2718 ASSERT(trace->stop_node() == NULL);
2719 if (!trace->is_trivial()) {
2720 trace->Flush(compiler, this);
2723 ChoiceNode::Emit(compiler, trace);
2874 void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2883 ASSERT(!trace->mentions_reg(guards->at(j)->reg()));
2888 LimitResult limit_result = LimitVersions(compiler, trace);
2892 int new_flush_budget = trace->flush_budget() / choice_count;
2893 if (trace->flush_budget() == 0 && trace->actions() != NULL) {
2894 trace->Flush(compiler, this);
2900 Trace* current_trace = trace;
2905 Trace counter_backtrack_trace;
2918 ASSERT(trace->stop_node() == NULL);
2922 Trace greedy_match_trace;
2940 current_trace->at_start() == Trace::FALSE);
2955 Trace new_trace(*current_trace);
2963 if (not_at_start_) new_trace.set_at_start(Trace::FALSE);
2989 macro_assembler->GoTo(trace->backtrack());
3022 macro_assembler->CheckGreedyLoop(trace->backtrack());
3033 Trace new_trace(*current_trace);
3035 // they are flushed. Take the budget of the parent trace and distribute
3051 Trace* trace,
3060 Trace out_of_line_trace(*trace);
3063 if (not_at_start_) out_of_line_trace.set_at_start(Trace::FALSE);
3077 macro_assembler->LoadCurrentCharacter(trace->cp_offset(),
3092 void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3094 LimitResult limit_result = LimitVersions(compiler, trace);
3102 Trace::DeferredCapture
3105 trace);
3106 Trace new_trace = *trace;
3112 Trace::DeferredIncrementRegister
3114 Trace new_trace = *trace;
3120 Trace::DeferredSetRegister
3122 Trace new_trace = *trace;
3128 Trace::DeferredClearCaptures
3131 Trace new_trace = *trace;
3137 if (!trace->is_trivial()) {
3138 trace->Flush(compiler, this);
3144 on_success()->Emit(compiler, trace);
3152 bool know_dist = trace->GetStoredPosition(start_pos_reg, &stored_pos);
3153 if (know_dist && !has_minimum && stored_pos == trace->cp_offset()) {
3156 assembler->GoTo(trace->backtrack());
3157 } else if (know_dist && stored_pos < trace->cp_offset()) {
3160 on_success()->Emit(compiler, trace);
3161 } else if (!trace->is_trivial()) {
3162 trace->Flush(compiler, this);
3174 trace->backtrack());
3176 on_success()->Emit(compiler, trace);
3181 if (!trace->is_trivial()) {
3182 trace->Flush(compiler, this);
3191 on_success()->Emit(compiler, trace);
3196 Trace new_trace = *trace;
3204 ASSERT(trace->backtrack() == NULL);
3214 void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3216 if (!trace->is_trivial()) {
3217 trace->Flush(compiler, this);
3221 LimitResult limit_result = LimitVersions(compiler, trace);
3230 trace->backtrack());
3232 assembler->CheckNotBackReference(start_reg_, trace->backtrack());
3234 on_success()->Emit(compiler, trace);
