Lines Matching defs:plan
285 // Tell any plans on the plan stack that the thread is being destroyed since
288 for (auto plan : m_plan_stack)
289 plan->ThreadDestroyed();
296 // Push a ThreadPlanNull on the plan stack. That way we can continue assuming that the
297 // plan stack is never empty, but if somebody errantly asks questions of a destroyed thread
557 plan. Do this before
558 // telling the current plan it will resume, since we might change what the current
559 // plan is.
601 // At this point clear the completed plan stack.
629 // We distinguish between the plan on the top of the stack and the lower
630 // plans in case a plan needs to do any special business before it runs.
643 // If the WillResume for the plan says we are faking a resume, then it will have set an appropriate stop info.
703 // Based on the current thread plan and process stop info, check if this
705 // the plan is moved from the current plan stack to the completed plan
730 log->Printf ("Plan stack initial state:\n%s", s.GetData());
733 // The top most plan always gets to do the trace log...
754 // If the base plan doesn't understand why we stopped, then we have to find a plan that does.
755 // If that plan is still working, then we don't need to do any more work. If the plan that explains
770 // If the current plan doesn't explain the stop, then find one that
784 // We're going to pop the plans up to and including the plan that explains the stop.
794 // Now, if the responsible plan was not "Okay to discard" then we're done,
795 // otherwise we forward this to the next plan in the stack below.
816 log->Printf("Plan %s explains stop, auto-continue %i.", current_plan->GetName(), over_ride_stop);
818 // We're starting from the base plan, so just let it decide;
823 log->Printf("Base plan says should stop: %i.", should_stop);
827 // Otherwise, don't let the base plan override what the other plans say to do, since
836 log->Printf("Plan %s should stop: %d.", current_plan->GetName(), should_stop);
842 // If a Master Plan wants to stop, and wants to stick on the stack, we let it.
843 // Otherwise, see if the plan's parent wants to stop.
872 // One other potential problem is that we set up a master plan, then stop in before it is complete - for instance
874 // past the end point condition of the initial plan. We don't want to strand the original plan on the stack,
889 log->Printf("Plan %s being discarded in cleanup, it says it is already done.", examined_plan->GetName());
902 log->Printf ("Plan stack final state:\n%s", s.GetData());
941 log->Printf ("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64 ": returning vote for complete stack's back plan", GetID());
961 log->Printf ("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64 ": returning vote %i for current plan", GetID(), thread_vote);
983 log->Printf ("Current Plan for thread %d(%p) (0x%4.4" PRIx64 ", %s): %s being asked whether we should report run.",
995 log->Printf ("Current Plan for thread %d(%p) (0x%4.4" PRIx64 ", %s): %s being asked whether we should report run.",
1020 // If the thread plan doesn't already have a tracer, give it its parent's tracer:
1049 ThreadPlanSP &plan = m_plan_stack.back();
1052 log->Printf("Popping plan: \"%s\", tid = 0x%4.4" PRIx64 ".", plan->GetName(), plan->GetThread().GetID());
1054 m_completed_plan_stack.push_back (plan);
1055 plan->WillPop();
1066 ThreadPlanSP &plan = m_plan_stack.back();
1068 log->Printf("Discarding plan: \"%s\", tid = 0x%4.4" PRIx64 ".", plan->GetName(), plan->GetThread().GetID());
1070 m_discarded_plan_stack.push_back (plan);
1071 plan->WillPop();
1079 // There will always be at least the base plan. If somebody is mucking with a
1080 // thread with an empty plan stack, we should assert right away.
1120 Thread::IsThreadPlanDone (ThreadPlan *plan)
1126 if (m_completed_plan_stack[i].get() == plan)
1134 Thread::WasThreadPlanDiscarded (ThreadPlan *plan)
1140 if (m_discarded_plan_stack[i].get() == plan)
1226 // If the input plan is NULL, discard all plans. Otherwise make sure this plan is in the
1281 // Find the first master plan, see if it wants discarding, and if yes discard up to it.
1298 // for the plan leaves it in a state that it is safe to pop the plan
1303 // Now discard the master plan itself.
1304 // The bottom-most plan never gets discarded. "OkayToDiscard" for it means
1313 // If the master plan doesn't want to get discarded, then we're done.
1337 // If the input plan is NULL, discard all plans. Otherwise make sure this plan is in the
1402 ThreadPlanStepInRange *plan = new ThreadPlanStepInRange (*this, range, addr_context, stop_other_threads);
1404 plan->GetFlags().Set (ThreadPlanShouldStopHere::eAvoidNoDebug);
1406 plan->GetFlags().Clear (ThreadPlanShouldStopHere::eAvoidNoDebug);
1408 plan->SetStepInTarget(step_in_target);
1409 thread_plan_sp.reset (plan);
1520 s->Printf ("Plan Stack for thread #%u: tid = 0x%4.4" PRIx64 ", stack_size = %d\n", GetIndexID(), GetID(), stack_size);
1535 s->Printf ("Completed Plan Stack: %d elements.\n", stack_size);
1551 s->Printf ("Discarded Plan Stack: %d elements.\n", stack_size);
1806 case eStopReasonPlanComplete: return "plan complete";
