Lines Matching full:trace
887 // manipulation in an object called the Trace. The Trace object can record a
890 // to be emitted it can flush the Trace or update it. Flushing the Trace
899 // The virtual state found in the Trace affects code generation. For example
903 // string. Therefore code generated for a non-trivial trace is specialized
904 // to that trace. The code generator therefore has the ability to generate
908 // trace is flushed and a generic version of the code for a node is emitted.
910 // trace is not recorded in the node and so it cannot currently be reused in
911 // the event that code generation is requested for an identical trace.
1139 Trace new_trace;
1165 bool Trace::DeferredAction::Mentions(int that) {
1175 bool Trace::mentions_reg(int reg) {
1186 bool Trace::GetStoredPosition(int reg, int* cp_offset) {
1204 int Trace::FindAffectedRegisters(OutSet* affected_registers,
1224 void Trace::RestoreAffectedRegisters(RegExpMacroAssembler* assembler,
1241 void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
1258 // The chronologically first deferred action in the trace
1276 Trace::DeferredSetRegister* psr =
1277 static_cast<Trace::DeferredSetRegister*>(action);
1301 Trace::DeferredCapture* pc =
1302 static_cast<Trace::DeferredCapture*>(action);
1374 void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {
1385 Trace new_state;
1417 Trace new_state;
1435 void NegativeSubmatchSuccess::Emit(RegExpCompiler* compiler, Trace* trace) {
1438 // Omit flushing the trace. We discard the entire stack frame anyway.
1441 // We are completely independent of the trace, since we ignore it,
1462 void EndNode::Emit(RegExpCompiler* compiler, Trace* trace) {
1463 if (!trace->is_trivial()) {
1464 trace->Flush(compiler, this);
1476 assembler->GoTo(trace->backtrack());
1591 Trace* trace) {
1594 ASSERT(!trace->mentions_reg(guard->reg()));
1597 trace->backtrack());
1600 ASSERT(!trace->mentions_reg(guard->reg()));
1603 trace->backtrack());
2258 Trace* trace) {
2260 if (trace->stop_node() != NULL) {
2265 if (trace->is_trivial()) {
2296 trace->Flush(compiler, this);
2474 Trace* trace,
2481 details, compiler, 0, trace->at_start() == Trace::FALSE_VALUE);
2491 if (trace->characters_preloaded() != details->characters()) {
2492 assembler->LoadCurrentCharacter(trace->cp_offset(),
2493 trace->backtrack(),
2532 assembler->CheckNotCharacterAfterAnd(value, mask, trace->backtrack());
2534 assembler->CheckNotCharacter(value, trace->backtrack());
3034 Trace* trace) {
3038 Trace new_trace(*trace);
3067 void AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, Trace* trace) {
3069 Trace::TriBool next_is_word_character = Trace::UNKNOWN;
3070 bool not_at_start = (trace->at_start() == Trace::FALSE_VALUE);
3082 next_is_word_character = Trace::FALSE_VALUE;
3083 if (bm->at(0)->is_word()) next_is_word_character = Trace::TRUE_VALUE;
3087 next_is_word_character = Trace::FALSE_VALUE;
3089 next_is_word_character = Trace::TRUE_VALUE;
3092 if (next_is_word_character == Trace::UNKNOWN) {
3095 if (trace->characters_preloaded() != 1) {
3096 assembler->LoadCurrentCharacter(trace->cp_offset(), &before_non_word);
3103 BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
3107 BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
3109 } else if (next_is_word_character == Trace::TRUE_VALUE) {
3110 BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
3112 ASSERT(next_is_word_character == Trace::FALSE_VALUE);
3113 BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
3120 Trace* trace,
3123 Trace new_trace(*trace);
3165 void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3170 assembler->CheckPosition(trace->cp_offset(), &ok);
3171 assembler->GoTo(trace->backtrack());
3176 if (trace->at_start() == Trace::FALSE_VALUE) {
3177 assembler->GoTo(trace->backtrack());
3180 if (trace->at_start() == Trace::UNKNOWN) {
3181 assembler->CheckNotAtStart(trace->backtrack());
3182 Trace at_start_trace = *trace;
3190 EmitHat(compiler, on_success(), trace);
3194 EmitBoundaryCheck(compiler, trace);
3198 on_success()->Emit(compiler, trace);
3237 // In addition to all this we are passed a Trace, which can
3248 Trace* trace,
3254 Label* backtrack = trace->backtrack();
3255 QuickCheckDetails* quick_check = trace->quick_check_performed();
3259 int cp_offset = trace->cp_offset() + elm.cp_offset();
3341 void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3342 LimitResult limit_result = LimitVersions(compiler, trace);
3346 if (trace->cp_offset() + Length() > RegExpMacroAssembler::kMaxCPOffset) {
3353 TextEmitPass(compiler, NON_ASCII_MATCH, false, trace, false, &dummy);
3357 int bound_checked_to = trace->cp_offset() - 1;
3358 bound_checked_to += trace->bound_checked_up_to();
3362 if (trace->characters_preloaded() == 1) {
3368 trace,
3381 trace,
3387 Trace successor_trace(*trace);
3395 void Trace::InvalidateCurrentCharacter() {
3400 void Trace::AdvanceCurrentPositionInTrace(int by, RegExpCompiler* compiler) {
3509 void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3511 if (trace->stop_node() == this) {
3517 ASSERT(trace->cp_offset() == text_length);
3519 macro_assembler->GoTo(trace->loop_label());
3522 ASSERT(trace->stop_node() == NULL);
3523 if (!trace->is_trivial()) {
3524 trace->Flush(compiler, this);
3527 ChoiceNode::Emit(compiler, trace);
3921 void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3930 ASSERT(!trace->mentions_reg(guards->at(j)->reg()));
3935 LimitResult limit_result = LimitVersions(compiler, trace);
3939 int new_flush_budget = trace->flush_budget() / choice_count;
3940 if (trace->flush_budget() == 0 && trace->actions() != NULL) {
3941 trace->Flush(compiler, this);
3947 Trace* current_trace = trace;
3952 Trace counter_backtrack_trace;
3965 ASSERT(trace->stop_node() == NULL);
3969 Trace greedy_match_trace;
3985 bool not_at_start = current_trace->at_start() == Trace::FALSE_VALUE;
4004 ASSERT(trace->is_trivial()); // This is the case on LoopChoiceNodes.
4048 Trace new_trace(*current_trace);
4056 if (not_at_start_) new_trace.set_at_start(Trace::FALSE_VALUE);
4082 macro_assembler->GoTo(trace->backtrack());
4115 macro_assembler->CheckGreedyLoop(trace->backtrack());
4126 Trace new_trace(*current_trace);
4128 // they are flushed. Take the budget of the parent trace and distribute
4144 Trace* trace,
4153 Trace out_of_line_trace(*trace);
4156 if (not_at_start_) out_of_line_trace.set_at_start(Trace::FALSE_VALUE);
4170 macro_assembler->LoadCurrentCharacter(trace->cp_offset(),
4185 void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
4187 LimitResult limit_result = LimitVersions(compiler, trace);
4195 Trace::DeferredCapture
4198 trace);
4199 Trace new_trace = *trace;
4205 Trace::DeferredIncrementRegister
4207 Trace new_trace = *trace;
4213 Trace::DeferredSetRegister
4215 Trace new_trace = *trace;
4221 Trace::DeferredClearCaptures
4224 Trace new_trace = *trace;
4230 if (!trace->is_trivial()) {
4231 trace->Flush(compiler, this);
4237 on_success()->Emit(compiler, trace);
4245 bool know_dist = trace->GetStoredPosition(start_pos_reg, &stored_pos);
4246 if (know_dist && !has_minimum && stored_pos == trace->cp_offset()) {
4249 assembler->GoTo(trace->backtrack());
4250 } else if (know_dist && stored_pos < trace->cp_offset()) {
4253 on_success()->Emit(compiler, trace);
4254 } else if (!trace->is_trivial()) {
4255 trace->Flush(compiler, this);
4267 trace->backtrack());
4269 on_success()->Emit(compiler, trace);
4274 if (!trace->is_trivial()) {
4275 trace->Flush(compiler, this);
4284 on_success()->Emit(compiler, trace);
4289 Trace new_trace = *trace;
4297 ASSERT(trace->backtrack() == NULL);
4307 void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
4309 if (!trace->is_trivial()) {
4310 trace->Flush(compiler, this);
4314 LimitResult limit_result = LimitVersions(compiler, trace);
4323 trace->backtrack());
4325 assembler->CheckNotBackReference(start_reg_, trace->backtrack());
4327 on_success()->Emit(compiler, trace);
