Lines Matching refs:Trace
592 // manipulation in an object called the Trace. The Trace object can record a
595 // to be emitted it can flush the Trace or update it. Flushing the Trace
604 // The virtual state found in the Trace affects code generation. For example
608 // string. Therefore code generated for a non-trivial trace is specialized
609 // to that trace. The code generator therefore has the ability to generate
613 // trace is flushed and a generic version of the code for a node is emitted.
615 // trace is not recorded in the node and so it cannot currently be reused in
616 // the event that code generation is requested for an identical trace.
769 Trace new_trace;
790 bool Trace::DeferredAction::Mentions(int that) {
800 bool Trace::mentions_reg(int reg) {
811 bool Trace::GetStoredPosition(int reg, int* cp_offset) {
829 int Trace::FindAffectedRegisters(OutSet* affected_registers) {
848 void Trace::RestoreAffectedRegisters(RegExpMacroAssembler* assembler,
865 void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
881 // The chronologically first deferred action in the trace
899 Trace::DeferredSetRegister* psr =
900 static_cast<Trace::DeferredSetRegister*>(action);
924 Trace::DeferredCapture* pc =
925 static_cast<Trace::DeferredCapture*>(action);
997 void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {
1008 Trace new_state;
1038 Trace new_state;
1056 void NegativeSubmatchSuccess::Emit(RegExpCompiler* compiler, Trace* trace) {
1059 // Omit flushing the trace. We discard the entire stack frame anyway.
1062 // We are completely independent of the trace, since we ignore it,
1083 void EndNode::Emit(RegExpCompiler* compiler, Trace* trace) {
1084 if (!trace->is_trivial()) {
1085 trace->Flush(compiler, this);
1097 assembler->GoTo(trace->backtrack());
1205 Trace* trace) {
1208 ASSERT(!trace->mentions_reg(guard->reg()));
1211 trace->backtrack());
1214 ASSERT(!trace->mentions_reg(guard->reg()));
1217 trace->backtrack());
1528 Trace* trace) {
1530 if (trace->stop_node() != NULL) {
1535 if (trace->is_trivial()) {
1566 trace->Flush(compiler, this);
1684 Trace* trace,
1690 GetQuickCheckDetails(details, compiler, 0, trace->at_start() == Trace::FALSE);
1700 if (trace->characters_preloaded() != details->characters()) {
1701 assembler->LoadCurrentCharacter(trace->cp_offset(),
1702 trace->backtrack(),
1739 assembler->CheckNotCharacterAfterAnd(value, mask, trace->backtrack());
1741 assembler->CheckNotCharacter(value, trace->backtrack());
2046 Trace* trace) {
2050 Trace new_trace(*trace);
2083 Trace* trace) {
2087 Trace new_trace(*trace);
2094 switch (trace->at_start()) {
2095 case Trace::TRUE:
2100 case Trace::UNKNOWN:
2101 ASSERT_EQ(0, trace->cp_offset());
2104 case Trace::FALSE:
2105 int prev_char_offset = trace->cp_offset() - 1;
2122 Trace* trace) {
2126 if (trace->characters_preloaded() != 1) {
2127 assembler->LoadCurrentCharacter(trace->cp_offset(), &before_non_word);
2134 Trace new_trace(*trace);
2200 void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2205 assembler->CheckPosition(trace->cp_offset(), &ok);
2206 assembler->GoTo(trace->backtrack());
2211 if (trace->at_start() == Trace::FALSE) {
2212 assembler->GoTo(trace->backtrack());
2215 if (trace->at_start() == Trace::UNKNOWN) {
2216 assembler->CheckNotAtStart(trace->backtrack());
2217 Trace at_start_trace = *trace;
2225 EmitHat(compiler, on_success(), trace);
2229 EmitBoundaryCheck(type_, compiler, on_success(), trace);
2234 EmitHalfBoundaryCheck(type_, compiler, on_success(), trace);
2237 on_success()->Emit(compiler, trace);
2276 // In addition to all this we are passed a Trace, which can
2287 Trace* trace,
2292 Label* backtrack = trace->backtrack();
2293 QuickCheckDetails* quick_check = trace->quick_check_performed();
2297 int cp_offset = trace->cp_offset() + elm.cp_offset;
2381 void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2382 LimitResult limit_result = LimitVersions(compiler, trace);
2386 if (trace->cp_offset() + Length() > RegExpMacroAssembler::kMaxCPOffset) {
2393 TextEmitPass(compiler, NON_ASCII_MATCH, false, trace, false, &dummy);
2397 int bound_checked_to = trace->cp_offset() - 1;
2398 bound_checked_to += trace->bound_checked_up_to();
2402 if (trace->characters_preloaded() == 1) {
2408 trace,
2421 trace,
2427 Trace successor_trace(*trace);
2435 void Trace::InvalidateCurrentCharacter() {
2440 void Trace::AdvanceCurrentPositionInTrace(int by, RegExpCompiler* compiler) {
2528 void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2530 if (trace->stop_node() == this) {
2535 ASSERT(trace->cp_offset() == text_length);
2537 macro_assembler->GoTo(trace->loop_label());
2540 ASSERT(trace->stop_node() == NULL);
2541 if (!trace->is_trivial()) {
2542 trace->Flush(compiler, this);
2545 ChoiceNode::Emit(compiler, trace);
2694 void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2703 ASSERT(!trace->mentions_reg(guards->at(j)->reg()));
2708 LimitResult limit_result = LimitVersions(compiler, trace);
2712 int new_flush_budget = trace->flush_budget() / choice_count;
2713 if (trace->flush_budget() == 0 && trace->actions() != NULL) {
2714 trace->Flush(compiler, this);
2720 Trace* current_trace = trace;
2725 Trace counter_backtrack_trace;
2738 ASSERT(trace->stop_node() == NULL);
2742 Trace greedy_match_trace;
2773 Trace new_trace(*current_trace);
2781 if (not_at_start_) new_trace.set_at_start(Trace::FALSE);
2807 macro_assembler->GoTo(trace->backtrack());
2840 macro_assembler->CheckGreedyLoop(trace->backtrack());
2851 Trace new_trace(*current_trace);
2853 // they are flushed. Take the budget of the parent trace and distribute
2869 Trace* trace,
2878 Trace out_of_line_trace(*trace);
2881 if (not_at_start_) out_of_line_trace.set_at_start(Trace::FALSE);
2895 macro_assembler->LoadCurrentCharacter(trace->cp_offset(),
2910 void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
2912 LimitResult limit_result = LimitVersions(compiler, trace);
2920 Trace::DeferredCapture
2923 trace);
2924 Trace new_trace = *trace;
2930 Trace::DeferredIncrementRegister
2932 Trace new_trace = *trace;
2938 Trace::DeferredSetRegister
2940 Trace new_trace = *trace;
2946 Trace::DeferredClearCaptures
2949 Trace new_trace = *trace;
2955 if (!trace->is_trivial()) {
2956 trace->Flush(compiler, this);
2962 on_success()->Emit(compiler, trace);
2970 bool know_dist = trace->GetStoredPosition(start_pos_reg, &stored_pos);
2971 if (know_dist && !has_minimum && stored_pos == trace->cp_offset()) {
2974 assembler->GoTo(trace->backtrack());
2975 } else if (know_dist && stored_pos < trace->cp_offset()) {
2978 on_success()->Emit(compiler, trace);
2979 } else if (!trace->is_trivial()) {
2980 trace->Flush(compiler, this);
2992 trace->backtrack());
2994 on_success()->Emit(compiler, trace);
2999 if (!trace->is_trivial()) {
3000 trace->Flush(compiler, this);
3009 on_success()->Emit(compiler, trace);
3014 Trace new_trace = *trace;
3022 ASSERT(trace->backtrack() == NULL);
3032 void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3034 if (!trace->is_trivial()) {
3035 trace->Flush(compiler, this);
3039 LimitResult limit_result = LimitVersions(compiler, trace);
3048 trace->backtrack());
3050 assembler->CheckNotBackReference(start_reg_, trace->backtrack());
3052 on_success()->Emit(compiler, trace);
