Lines Matching refs:trace
165 // string. Therefore code generated for a non-trivial trace is specialized
166 // to that trace. The code generator therefore has the ability to generate
170 // trace is flushed and a generic version of the code for a node is emitted.
172 // trace is not recorded in the node and so it cannot currently be reused in
173 // the event that code generation is requested for an identical trace.
411 // The chronologically first deferred action in the trace
585 void NegativeSubmatchSuccess::Emit(RegExpCompiler* compiler, Trace* trace) {
588 // Omit flushing the trace. We discard the entire stack frame anyway.
591 // We are completely independent of the trace, since we ignore it,
611 void EndNode::Emit(RegExpCompiler* compiler, Trace* trace) {
612 if (!trace->is_trivial()) {
613 trace->Flush(compiler, this);
625 assembler->GoTo(trace->backtrack());
724 Guard* guard, Trace* trace) {
727 DCHECK(!trace->mentions_reg(guard->reg()));
729 trace->backtrack());
732 DCHECK(!trace->mentions_reg(guard->reg()));
734 trace->backtrack());
1321 Trace* trace) {
1323 if (trace->stop_node() != nullptr) {
1328 if (trace->is_trivial()) {
1356 trace->Flush(compiler, this);
1504 Trace* bounds_check_trace, Trace* trace,
1513 trace->at_start() == Trace::FALSE_VALUE);
1523 if (trace->characters_preloaded() != details->characters()) {
1524 DCHECK(trace->cp_offset() == bounds_check_trace->cp_offset());
1534 trace->cp_offset(), bounds_check_trace->backtrack(),
1568 assembler->CheckNotCharacterAfterAnd(value, mask, trace->backtrack());
1570 assembler->CheckNotCharacter(value, trace->backtrack());
2116 void EmitHat(RegExpCompiler* compiler, RegExpNode* on_success, Trace* trace) {
2120 Trace new_trace(*trace);
2158 void AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, Trace* trace) {
2162 bool not_at_start = (trace->at_start() == Trace::FALSE_VALUE);
2183 if (trace->characters_preloaded() != 1) {
2184 assembler->LoadCurrentCharacter(trace->cp_offset(), &before_non_word);
2191 BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
2195 BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
2198 BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
2201 BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
2206 RegExpCompiler* compiler, Trace* trace,
2209 Trace new_trace(*trace);
2253 void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2258 assembler->CheckPosition(trace->cp_offset(), &ok);
2259 assembler->GoTo(trace->backtrack());
2264 if (trace->at_start() == Trace::FALSE_VALUE) {
2265 assembler->GoTo(trace->backtrack());
2268 if (trace->at_start() == Trace::UNKNOWN) {
2269 assembler->CheckNotAtStart(trace->cp_offset(), trace->backtrack());
2270 Trace at_start_trace = *trace;
2277 EmitHat(compiler, on_success(), trace);
2281 EmitBoundaryCheck(compiler, trace);
2285 on_success()->Emit(compiler, trace);
2334 bool preloaded, Trace* trace,
2339 Label* backtrack = trace->backtrack();
2340 QuickCheckDetails* quick_check = trace->quick_check_performed();
2345 int cp_offset = trace->cp_offset() + elm.cp_offset() + backward_offset;
2464 void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2465 LimitResult limit_result = LimitVersions(compiler, trace);
2469 if (trace->cp_offset() + Length() > RegExpMacroAssembler::kMaxCPOffset) {
2476 TextEmitPass(compiler, NON_LATIN1_MATCH, false, trace, false, &dummy);
2480 int bound_checked_to = trace->cp_offset() - 1;
2481 bound_checked_to += trace->bound_checked_up_to();
2485 if (trace->characters_preloaded() == 1) {
2487 TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), true, trace,
2494 TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), false, trace,
2498 Trace successor_trace(*trace);
2614 void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2616 if (trace->stop_node() == this) {
2623 DCHECK(trace->cp_offset() == text_length);
2625 macro_assembler->GoTo(trace->loop_label());
2628 DCHECK_NULL(trace->stop_node());
2629 if (!trace->is_trivial()) {
2630 trace->Flush(compiler, this);
2633 ChoiceNode::Emit(compiler, trace);
3043 void ChoiceNode::AssertGuardsMentionRegisters(Trace* trace) {
3051 DCHECK(!trace->mentions_reg(guards->at(j)->reg()));
3072 void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3076 alternatives_->at(0).node()->Emit(compiler, trace);
3080 AssertGuardsMentionRegisters(trace);
3082 LimitResult limit_result = LimitVersions(compiler, trace);
3088 if (trace->flush_budget() == 0 && trace->actions() != nullptr) {
3089 trace->Flush(compiler, this);
3103 trace = EmitGreedyLoop(compiler, trace, &alt_gens, &preload,
3111 preload.eats_at_least_ = EmitOptimizedUnanchoredSearch(compiler, trace);
3113 EmitChoices(compiler, &alt_gens, 0, trace, &preload);
3119 int new_flush_budget = trace->flush_budget() / choice_count;
3122 Trace new_trace(*trace);
3124 // they are flushed. Take the budget of the parent trace and distribute
3137 Trace* ChoiceNode::EmitGreedyLoop(RegExpCompiler* compiler, Trace* trace,
3150 DCHECK(trace->stop_node() == nullptr);
3172 macro_assembler->CheckGreedyLoop(trace->backtrack());
3180 Trace* trace) {
3193 // Really we should be creating a new trace when we execute this function,
3195 // we always arrive here with a trivial trace (since it's the entry to a
3199 DCHECK(trace->is_trivial());
3227 int first_choice, Trace* trace,
3230 SetUpPreLoad(compiler, trace, preload);
3236 int new_flush_budget = trace->flush_budget() / choice_count;
3246 Trace new_trace(*trace);
3262 compiler, trace, &new_trace, preload->preload_has_checked_bounds_,
3279 macro_assembler->GoTo(trace->backtrack());
3309 Trace* trace,
3318 Trace out_of_line_trace(*trace);
3335 macro_assembler->LoadCurrentCharacter(trace->cp_offset(), nullptr, false,
3347 void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3349 LimitResult limit_result = LimitVersions(compiler, trace);
3359 trace);
3360 Trace new_trace = *trace;
3368 Trace new_trace = *trace;
3376 Trace new_trace = *trace;
3384 Trace new_trace = *trace;
3391 if (!trace->is_trivial()) {
3392 trace->Flush(compiler, this);
3398 on_success()->Emit(compiler, trace);
3406 bool know_dist = trace->GetStoredPosition(start_pos_reg, &stored_pos);
3407 if (know_dist && !has_minimum && stored_pos == trace->cp_offset()) {
3410 assembler->GoTo(trace->backtrack());
3411 } else if (know_dist && stored_pos < trace->cp_offset()) {
3414 on_success()->Emit(compiler, trace);
3415 } else if (!trace->is_trivial()) {
3416 trace->Flush(compiler, this);
3428 trace->backtrack());
3430 on_success()->Emit(compiler, trace);
3435 if (!trace->is_trivial()) {
3436 trace->Flush(compiler, this);
3445 on_success()->Emit(compiler, trace);
3450 Trace new_trace = *trace;
3458 DCHECK(trace->backtrack() == nullptr);
3467 void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3469 if (!trace->is_trivial()) {
3470 trace->Flush(compiler, this);
3474 LimitResult limit_result = LimitVersions(compiler, trace);
3484 unicode, trace->backtrack());
3487 trace->backtrack());
3490 if (read_backward()) trace->set_at_start(Trace::UNKNOWN);
3494 assembler->CheckNotInSurrogatePair(trace->cp_offset(), trace->backtrack());
3496 on_success()->Emit(compiler, trace);