Lines Matching full:we
63 // This is a little tricky. We want to count "run and stopped again
65 // HasTargetRunSinceMe. But we don't want to include any running of the
66 // target done for expressions. So we track both resumes, and resumes
155 // Only check once if we should stop at a breakpoint
192 // If we have just hit an internal breakpoint, and it has a kind
284 // conditions, we should change the stop-info to none. Otherwise, if we
292 // site, then we won't be operating on a bad list.
299 actually_hit_any_locations = true; // We're going to stop, don't
302 // We go through each location, and test first its precondition -
303 // this overrides everything. Note, we only do this once per
305 // If the condition says to stop, then we run the callback for that
306 // location. If that callback says to stop as well, then we set
307 // m_should_stop to true; we are going to stop. But we still want to
308 // give all the breakpoints whose conditions say we are going to stop
311 // we're going to restart, without running the rest of the callbacks.
312 // And in this case we will end up not stopping even if another
313 // location said we should stop. But that's better than not running
316 // There's one other complication here. We may have run an async
317 // breakpoint callback that said we should stop. We only want to
318 // override that if another breakpoint action says we shouldn't
319 // stop. If nobody else has an opinion, then we should stop if the
320 // async callback says we should. An example of this is the async
323 // We'll keep the async value in async_should_stop, and track whether
324 // anyone said we should NOT stop in actually_said_continue.
332 // We don't select threads as we go through them testing breakpoint
333 // conditions and running commands. So we need to set the thread for
340 // If we are in the middle of evaluating an expression, don't run
344 // TODO: We can keep a list of the breakpoints we've seen while
348 // commands when we see the same breakpoint hit a second time.
355 // also there). We can't find an internal breakpoint in the loop
369 // Internal breakpoints should be allowed to do their job, we
389 // breakpoint constituents of the locations we're going to examine,
443 // Next run the condition for the breakpoint. If that says we
444 // should stop, then we'll run the callback for the breakpoint. If
445 // the callback says we shouldn't stop that will win.
455 // If the condition fails to evaluate, we are going to stop
482 // We don't want to increment the hit count of breakpoints if
483 // the condition fails. We've already bumped it by the time
484 // we get here, so undo the bump:
492 // We've done all the checks whose failure means "we consider lldb
493 // not to have hit the breakpoint". Now we're going to check for
513 // We want this stop reported, so you will know we auto-continued
523 // first time we restart we need
525 // When we figure out how to nest breakpoint hits then this will
548 // If we are going to stop for this breakpoint, then remove the
556 // it did, when we'll set m_should_start to false and get out of
564 // At this point if nobody actually told us to continue, we should
570 // We've figured out what this stop wants to do, so mark it as valid so
571 // we don't compute it again.
588 // Override should_stop decision when we have completed step plan
592 // We know we're stopping for a completed plan and we don't want to
597 // In the end, we didn't actually have any locations that passed their
598 // "was I hit" checks. So say we aren't stopped.
613 bool m_should_perform_action; // Since we are trying to preserve the "state"
614 // of the system even if we run functions
615 // etc. behind the users backs, we need to make sure we only REALLY perform
617 lldb::addr_t m_address; // We use this to capture the breakpoint site address
618 // when we create the StopInfo,
726 // so we might have not gotten to run, but still have a watchpoint stop
769 // If we are running our step-over the watchpoint plan, stop if it's done
774 // If we are running our step over plan, then stop here and let the regular
775 // ShouldStop figure out what we should do: Otherwise, give our plan
786 LLDB_LOG(log, "We didn't run but stopped with a StopInfoWatchpoint, we "
795 // If we can no longer find the watchpoint, we just have to stop:
812 // This won't happen at present because we only allow one watchpoint per
813 // watched range. So we won't stop at a watched address with a disabled
814 // watchpoint. If we start allowing overlapping watchpoints, then we
821 // If this is a system where we need to execute the watchpoint by hand
830 // We have to step over the watchpoint before we know what to do:
835 // When this plan is done we want to stop, so set this as a Controlling
842 // If we couldn't push the thread plan, just stop here:
851 // Otherwise, don't set m_should_stop, we don't know that yet. Just
852 // say we should continue, and tell the thread we really should do so:
858 // We didn't have to do anything special
876 // We're going to calculate if we should stop or not in some way during the
877 // course of this code. Also by default we're going to stop, so set that
890 // while performing watchpoint actions, and it is then enabled after we
910 // We need to make sure the user sees any parse errors in their
911 // condition, so we'll hook the constructor errors up to the
928 // The condition failed, which we consider "not having hit
960 // If the condition says to stop, we run the callback to further decide
964 // first time we restart we need
966 // When we figure out how to nest watchpoint hits then this will
978 // it did, when we'll set m_should_stop to false and get out of here.
983 // We have been vetoed by the callback mechanism.
995 // Finally, if we are going to stop, print out the new & old values:
1034 // by the gdb stub we're talking to).
1073 // If should stop returns false, check if we should notify of this event
1377 // LWP_TODO: We'll need a CreateStopReasonWithWatchpointResourceID akin