[NFC] Have ThreadPlans hold onto the Process & TID, rather than the Thread

[jingham]

Summary

This is the first part of a multi-part commit. This change makes the ThreadPlans use the process & TID to specify which thread they belong to, rather than holding onto the Thread * directly. It doesn't change any behavior, it just means ThreadPlans have to get their thread from the ThreadPlan::GetThread() API, and OTOH can access their process and TID directly.

This point of this multi-part commit will be to make it possible to preserve the stepping intentions for a thread in the target, even if the target doesn't report all threads on every stop. This is particularly a problem for targets that provide their threads using an OSPlugin thread provider. The Darwin kernel uses this extensively, and they found that if they reported all the current threads on every stop, it made stepping unusably slow. So they only report the "on core" threads when they stop.

That made stepping perform acceptably, but caused stepping to behave badly. For instance, suppose you were next-ing Thread A, and the code had stepped into a function and so needed to step out. So lldb would set a breakpoint at the return address of the function, then continue. If you are unlucky, Thread B might hit a breakpoint before thread A completed its step out, and furthermore when Thread B stopped, Thread A didn't happen to be on another core. Then lldb would think Thread A has exited, and would remove the step out breakpoint. That meant when you continued again, your step-over would have turned into a continue.

To fix this problem, I am going to move the ThreadPlan stacks into a separate class, and then have the Process hold onto the map of TID -> ThreadPlanStacks. Then if a thread goes away, we can leave its entry in the map, and if the thread comes back to life, we will know what we were doing with it.

Couple of other random observations:

• I tried preserving the whole Thread object for a while, but the logic for merging the old & new thread lists is pretty tricky and intervening at that point made this tricky code even harder to understand. Plus this was preserving a lot of unneeded information. Just keeping the ThreadPlanStack off to one side was much cleaner.

• Leaving actually obsolete thread plan stacks around does have a cost. For instance, if the thread in the example above had really gone away, then we would leave a step-out breakpoint stranded. It wouldn't do any harm, since it is thread specific for a non-existent thread. But it would slow down execution.

In the patches in this sequence, I will only preserve vanished thread's ThreadPlanStacks if there is an OperatingSystem plugin. So it won't affect the current ProcessGDBRemote clients, since ProcessGDBRemote always gets all "real" threads on every stop at present.

In the future, we could change ProcessGDBRemote to NOT gather all threads on stop, but just read the threads that stopped "for a reason". We would have to encode that in the stop packet somehow.

That could make stepping more efficient. If lldb was going to continue immediately (it was in the middle of stepping or whatever) it would be great to only have to reconstruct one or two threads. In the case of ProcessGDBRemote, we could even refine this by asking about the existence of all the threads that had non-trivial thread plans in flight, along with the stopped-for-a-reason threads. That would allow us to reap any of the ThreadPlanStacks that had any effect on the process (setting breakpoints, etc...) without having to enumerate all threads.

Future:

The sequence of patches should be:

1. This patch deals with how ThreadPlans know what thread they belong to.
2. Do the same change to ThreadPlanTracers
3. Introduce the ThreadPlanStacks, and move the plans there, but keep them in the Thread
4. Move the ThreadPlanStacks into the Process, and manage detaching & reattaching them from Threads as they come and go.

[jingham]

Another point to make clear here. You might wonder whether ThreadPlan::GetThread should return an Optional<Thread> or something like that, since there might not be a Thread associated with the ThreadPlan.

I tried that out but it made the code really ugly. When I thought about it a little more, I realized that besides the destructor, and Description methods all the other methods are only callable when the ThreadPlanStack is attached to a thread, since they are all only called as part of the "ShouldStop" and "WillResume" negotiation, which always work on Thread objects in the ThreadList. So nobody has any business calling any of these other methods when detached from a Thread. And conversely, it's pointless to check whether you have a thread in these methods, you always will...

It doesn't cause practical problems that you can't assume anything about the state of your Thread in these two methods. When you are being destroyed you can't assume anything about the state of the underlying thread, it's target side may very well have gone away, so the destructors don't actually use the thread. And actually all the Description methods really wanted the TID, or were using the thread to get to the process. So I didn't have to change either's behavior.

In the patch that detaches the ThreadPlanStacks from the Thread, I'll assert if you call GetThread and there isn't one. But that won't 100% prevent the problem, since in most scenarios there will always be a thread in these situations.

I was planning on adding the assert and then documenting this restriction, and leave it at that. That's in part because I don't know how to say ThreadPlan::GetThread can be called from anywhere in ThreadPlan BUT ThreadPlan::GetDescription and it's descendants, and ThreadPlan::~ThreadPlan or its descendants. But if anyone knows a clever way to do this, I'd happily use that.

[jingham]

Attempt to appease clang-format.

[labath]

I am somewhat worried about the direction this is taking. Maybe vanishing threads are fine for os-level debugging (because there the "real" threads are the cpu cores, and the os threads are somewhat imaginary), but I definitely wouldn't want to do it for regular debugging. If my process has 1000 threads (not completely uncommon) then I don't think my debugger would be doing me a service showing me just the three it thinks are interesting and completely disregarding the others. Having a mode (it could even be default) which only highlights the interesting ones -- yes, that would definitely be useful. Making sure it doesn't touch the other threads when it doesn't need to -- absolutely. But I don't think it should pretend the other threads don't exist at all, because I may still have a reason to inspect those threads (or just to know that they're there). In fact, I wouldn't be surprised if this happened to the said kernel folks too, and they end up adding a custom command, which would enumerate all "threads".

What was actually the slow part here? Was it the os plugin reading the thread lists from the kernel memory? Or the fact that lldb is slow when it is confronted with them?

If it is the latter, then maybe we should fix that. For example, I think I remember lldb likes to check the PC of every thread before it does any kind of a resume -- I am not convinced that is really needed.

If fetching the threads is slow, then perhaps we could have an api, where the os threads are produced incrementally, and we ensure that lldb does not query for os threads needlessly during the hot paths (e.g. internal stops for servicing thread plans).

[jingham]

In D75711#1909055, @labath wrote:

I am somewhat worried about the direction this is taking. Maybe vanishing threads are fine for os-level debugging (because there the "real" threads are the cpu cores, and the os threads are somewhat imaginary), but I definitely wouldn't want to do it for regular debugging. If my process has 1000 threads (not completely uncommon) then I don't think my debugger would be doing me a service showing me just the three it thinks are interesting and completely disregarding the others. Having a mode (it could even be default) which only highlights the interesting ones -- yes, that would definitely be useful. Making sure it doesn't touch the other threads when it doesn't need to -- absolutely. But I don't think it should pretend the other threads don't exist at all, because I may still have a reason to inspect those threads (or just to know that they're there). In fact, I wouldn't be surprised if this happened to the said kernel folks too, and they end up adding a custom command, which would enumerate all "threads".

First off, I also think that hiding some threads from users, or forcing people to say "thread list --force" or something like that to see them all would not be a user-friendly design. I'm not suggesting imposing that on general debugging. But if an OS plugin, for instance, decides it is too expensive to do this except as an explicit gesture, we need to support that decision.

But lldb stops many times during the course of a step where it doesn't return control to the user - all the step into code with no debug info, step out again, step across dynamic linker stubs or step through ObjC message dispatch dances we do involve many private stops per public spot... If a thread has not stopped "for a reason" at one of those stops, it takes no part in the "should stop" and "will resume" negotiations and reconstructing it for that stop really does serve no purpose. There's no way that the user will get a chance to see it.

So if we could avoid reading them in, that might make stepping go faster in the presence of lots of threads. BTW, with the accelerated stop packets where we get all the threads and their stop reasons on stop, I'm not sure this would really save all that much time. But talking to less capable stubs, it really can make a difference. Greg did a bunch of work to make sure stepping stopped as few times as possible because the Facebook gdb-remote stub didn't support these accelerated packets and getting all the thread info on each private stop was making stepping go really slowly. I didn't understand the motivation at first because for debugserver the changes didn't really make any difference.

Also, I don't think these two desires: not fetching threads when we don't need them (e.g. private stops) and showing them all to the user whenever they ask, are contradictory. After all we still have the gate of UpdateThreadListIfNeeded. All the commands that touch the thread list go through this. So even if we don't gather all the threads when we stop, we already have a mechanism in place whereby any command that actually touches the thread list can fetch them on demand.

What was actually the slow part here? Was it the os plugin reading the thread lists from the kernel memory? Or the fact that lldb is slow when it is confronted with them?

If it is the latter, then maybe we should fix that. For example, I think I remember lldb likes to check the PC of every thread before it does any kind of a resume -- I am not convinced that is really needed.

If fetching the threads is slow, then perhaps we could have an api, where the os threads are produced incrementally, and we ensure that lldb does not query for os threads needlessly during the hot paths (e.g. internal stops for servicing thread plans).

The thing that is slow is gathering all the threads. On Darwin, there's a kernel activation per user space thread and then a whole bunch of kernel threads. On a busy system, that ends up being a whole lot of threads. Producing them through the OS plugin interface involves a bunch of memory reads to fetch the thread data, and following pointers around to get the register state for the threads, etc.

Note also, the way the OS Plugins currently work, when the process stops the OS Plugin just gets asked to produce the threads backing the "on core" threads. That's all UpdateThreadListIfNeeded will fetch, and there's no lldb way to get the OS Plugin to fetch all the threads it can produce. The only way to do that with the Darwin kernel is to run other commands in the set of Python commands provided by the kernel team that either fetches a non-current thread by ID or forces fetching all the threads.

So the current state when working with OS Plugins violates your principle given above, but I think it fits the kernel folks workflow, since the actual number of threads in the kernel is overwhelming and not terribly useful. But you are right, if we wanted to delay getting threads on private stops, but make UpdateThreadListIfNeeded force a fetch, then we would have to add some API to allow us to fetch only the "on core" threads along the code path that handles internal stops.

In any case, in order to support having internal stops not fetch all threads - which we are currently doing with OS Plugins - we need to be able to persist the stateful data lldb holds for that thread across stops where we don't realize the Thread object. That is the sole ambition of this set of patches.

[clayborg]

As long as the keeping thread plans around for threads that aren't there is only enabled when OS plug-in is around, I am fine with this direction. One questions: do we currently only allow stepping on real threads or OS threads that are backed by real threads right now? And if an OS thread is backed by a real thread, do we associate the step plan with the OS thread ID or the real thread ID (the core)? If we use the OS thread ID, another way to potentially fix this is to know in a thread plan that we are stepping an OS thread, and avoid fetching the complete OS list of threads for non public stops, but only fetch the thread list for any OS threads that have active thread plans and any OS threads for threads that are active on a core. Then we don't end up fetching all OS threads all the time for stepping, but it does allow us to maintain and track our OS thread correctly. This would require changes to the OS plug-ins where getting the thread list needs to be able to grab only the OS threads that are on core, and we can manually fetch the OS thread info for any thread plans, and the plug-in would still need to be able to fetch the complete list on public stop events.

Stepping on Android could really benefit from some of the plans you mention where we might not end up fetching all of the thread IDs on a stop from the GDB remote. One idea is, when we do a continue where we specify only one thread to run, or only a few threads get to run, then the stop reply would only need to mention these threads and any new threads that showed up during the last resume. We can safely assume any other threads were suspended and have the exact same state. This will take some careful tracking in the Process class, but it could be done. For some reason Android has 150 threads running a lot of times which causes stepping to take a while on many cases. A lot of these issues were fixed with my patches submitted a while back where when we are stepping over stuff, we don't always stop at all branches, but only stop at branches that are not function calls, but stepping can still be quite slow.

[jingham]

In D75711#1910156, @clayborg wrote:

As long as the keeping thread plans around for threads that aren't there is only enabled when OS plug-in is around, I am fine with this direction. One questions: do we currently only allow stepping on real threads or OS threads that are backed by real threads right now? And if an OS thread is backed by a real thread, do we associate the step plan with the OS thread ID or the real thread ID (the core)? If we use the OS thread ID, another way to potentially fix this is to know in a thread plan that we are stepping an OS thread, and avoid fetching the complete OS list of threads for non public stops, but only fetch the thread list for any OS threads that have active thread plans and any OS threads for threads that are active on a core. Then we don't end up fetching all OS threads all the time for stepping, but it does allow us to maintain and track our OS thread correctly. This would require changes to the OS plug-ins where getting the thread list needs to be able to grab only the OS threads that are on core, and we can manually fetch the OS thread info for any thread plans, and the plug-in would still need to be able to fetch the complete list on public stop events.

The way I have it in another patch in the series is when UpdateThreadList decides a thread is not present, I ask whether there is an OS Plugin, if there is I preserve the ThreadPlanStack while deleting the Thread, and if there isn't I ditch the ThreadPlanStack along with the Thread. We could do other things if we want to get cleverer, but that's what I do at present.

Core threads are really the fiction in the case of the xnu OS Plugin. They are just the activations that happen to be on a processor when something stops. You can't do anything persistent with them because an activation could move from one core to another, be off core at a stop, etc. lldb_private::Threads are tricky, they can be an OS Plugin Thread, a Core Thread with a backing OS Plugin thread, an Core thread with no OS Plugin thread... And the same TID can be change modes across stops.

The thing that isn't a fiction is the TID for the thread. That's why it makes more sense to me that the persistent part of the thread data in lldb be linked to the TID and not the Thread object we happen to have made for it this time. Pulling the persistent part out and having it just depend on the TID, not on the details of how we produced the lldb_private::Thread representing that TID, makes all the updating logic easier to manage.

Stepping on Android could really benefit from some of the plans you mention where we might not end up fetching all of the thread IDs on a stop from the GDB remote. One idea is, when we do a continue where we specify only one thread to run, or only a few threads get to run, then the stop reply would only need to mention these threads and any new threads that showed up during the last resume. We can safely assume any other threads were suspended and have the exact same state. This will take some careful tracking in the Process class, but it could be done. For some reason Android has 150 threads running a lot of times which causes stepping to take a while on many cases. A lot of these issues were fixed with my patches submitted a while back where when we are stepping over stuff, we don't always stop at all branches, but only stop at branches that are not function calls, but stepping can still be quite slow.

Right, I think this is an enabling step for that sort of optimization.

[labath]

Thanks for the detailed response. I'll try to be equally understandable.

In D75711#1910155, @jingham wrote:

In D75711#1909055, @labath wrote:

I am somewhat worried about the direction this is taking. Maybe vanishing threads are fine for os-level debugging (because there the "real" threads are the cpu cores, and the os threads are somewhat imaginary), but I definitely wouldn't want to do it for regular debugging. If my process has 1000 threads (not completely uncommon) then I don't think my debugger would be doing me a service showing me just the three it thinks are interesting and completely disregarding the others. Having a mode (it could even be default) which only highlights the interesting ones -- yes, that would definitely be useful. Making sure it doesn't touch the other threads when it doesn't need to -- absolutely. But I don't think it should pretend the other threads don't exist at all, because I may still have a reason to inspect those threads (or just to know that they're there). In fact, I wouldn't be surprised if this happened to the said kernel folks too, and they end up adding a custom command, which would enumerate all "threads".

First off, I also think that hiding some threads from users, or forcing people to say "thread list --force" or something like that to see them all would not be a user-friendly design. I'm not suggesting imposing that on general debugging. But if an OS plugin, for instance, decides it is too expensive to do this except as an explicit gesture, we need to support that decision.

But lldb stops many times during the course of a step where it doesn't return control to the user - all the step into code with no debug info, step out again, step across dynamic linker stubs or step through ObjC message dispatch dances we do involve many private stops per public spot... If a thread has not stopped "for a reason" at one of those stops, it takes no part in the "should stop" and "will resume" negotiations and reconstructing it for that stop really does serve no purpose. There's no way that the user will get a chance to see it.

So if we could avoid reading them in, that might make stepping go faster in the presence of lots of threads. BTW, with the accelerated stop packets where we get all the threads and their stop reasons on stop, I'm not sure this would really save all that much time. But talking to less capable stubs, it really can make a difference. Greg did a bunch of work to make sure stepping stopped as few times as possible because the Facebook gdb-remote stub didn't support these accelerated packets and getting all the thread info on each private stop was making stepping go really slowly. I didn't understand the motivation at first because for debugserver the changes didn't really make any difference.

Also, I don't think these two desires: not fetching threads when we don't need them (e.g. private stops) and showing them all to the user whenever they ask, are contradictory. After all we still have the gate of UpdateThreadListIfNeeded. All the commands that touch the thread list go through this. So even if we don't gather all the threads when we stop, we already have a mechanism in place whereby any command that actually touches the thread list can fetch them on demand.

Yes, I agree with everything above. If lldb does not need information about all threads in order to service a internal stop, then it shouldn't read it in, and the os plugin (or the remote stub) should not need to provide it. In fact I would even go so far as to say that we shouldn't need to read in this information for a public stop until a user performs an operation (e.g. thread list) that requires information about all threads.

What was actually the slow part here? Was it the os plugin reading the thread lists from the kernel memory? Or the fact that lldb is slow when it is confronted with them?

If it is the latter, then maybe we should fix that. For example, I think I remember lldb likes to check the PC of every thread before it does any kind of a resume -- I am not convinced that is really needed.

If fetching the threads is slow, then perhaps we could have an api, where the os threads are produced incrementally, and we ensure that lldb does not query for os threads needlessly during the hot paths (e.g. internal stops for servicing thread plans).

The thing that is slow is gathering all the threads. On Darwin, there's a kernel activation per user space thread and then a whole bunch of kernel threads. On a busy system, that ends up being a whole lot of threads. Producing them through the OS plugin interface involves a bunch of memory reads to fetch the thread data, and following pointers around to get the register state for the threads, etc.

Note also, the way the OS Plugins currently work, when the process stops the OS Plugin just gets asked to produce the threads backing the "on core" threads. That's all UpdateThreadListIfNeeded will fetch, and there's no lldb way to get the OS Plugin to fetch all the threads it can produce. The only way to do that with the Darwin kernel is to run other commands in the set of Python commands provided by the kernel team that either fetches a non-current thread by ID or forces fetching all the threads.

So the current state when working with OS Plugins violates your principle given above,

IIUC, this principle is only violated for this particular os plugin, which violates the plugin contract and does not return all threads through the get_thread_info interface. I don't know whether this contract is spelled out anywhere, but it seems like at least the code in lldb behaves that way.

So this is technically not "our" fault. The plugin is doing something unsupported and gets weird behavior as a result. Now, I am not saying we should throw this plugin (maybe the only actually used os plugin) overboard. However, I was hoping that the process of supporting it would involve some improvements to the os plugin interface (so that it can do what it wants in a supported way), rather than declaring support for whatever it is the plugin is doing, even though we know it to be problematic (like, not being able to tell when we can throw thread plans away).

That said, I don't really use or care about the os plugins, so if using it results in leaking thread plans, then whatever. The thing I want to understand is what kind of requirements does this place on the rest of lldb. Which leads me to my next comment..

but I think it fits the kernel folks workflow, since the actual number of threads in the kernel is overwhelming and not terribly useful. But you are right, if we wanted to delay getting threads on private stops, but make UpdateThreadListIfNeeded force a fetch, then we would have to add some API to allow us to fetch only the "on core" threads along the code path that handles internal stops.

In any case, in order to support having internal stops not fetch all threads - which we are currently doing with OS Plugins - we need to be able to persist the stateful data lldb holds for that thread across stops where we don't realize the Thread object. That is the sole ambition of this set of patches.

We've agreed that we would like to avoid gathering the thread data for internals stops that don't need it. Avoiding creating (updating) lldb_private::Thread objects, and having the not-(yet)-realized threads live as a tid_t is one way to achieve this goal, but I am not sure if it is the right one. I am not really against the idea -- since threads can come and go between stops pretty much arbitrarily (even without os plugins), it may make sense to have everything hold onto them as simple handles, and force a fetch through some Process api when one needs to access them may simplify some things (for one, the lifetime of Threads could become much stricter).

I can certainly believe that changing thread plans to use a tid_t instead of a Thread& is simpler than making Thread object management lazy, but I am not sure that is a fair comparison. Thread plans are only a single component which juggles Thread objects. There are many other pieces of code, which assume that the lifetime of a Thread object matches that of the entity it describes. SBThread is one such thing. If SBThread keeps referring to the actual thread as a pointer, then it will lose track of it when the actual thread goes away and reappears. Same goes for ValueObjects and SBValues -- if lldb_private::Thread is meant to be transient, then those should also be updated to use a tid_t(*), but then the changes required to do that become much larger, and it's not clear to me whether that is really worth it, since this is just kind of reinventing weak_ptr<Thread> (but with the downside mentioned in (*)).

(*) I don't believe tid_t is actually a good way to keep track of the identity of a thread across time. It does uniquely identify a thread at any given point in time, but thread ids can be recycled (sometimes very quickly -- running the lldb test suite just once causes linux to wrap its pid space), which means you can't guarantee it will always refer to the same physical thread. If we're going to be using numbers to identify threads I think it should be some other kind of an identifier -- but that is sort of what a Thread* already is.

[jingham]

In D75711#1912230, @labath wrote:

Thanks for the detailed response. I'll try to be equally understandable.

In D75711#1910155, @jingham wrote:

In D75711#1909055, @labath wrote:

I am somewhat worried about the direction this is taking. Maybe vanishing threads are fine for os-level debugging (because there the "real" threads are the cpu cores, and the os threads are somewhat imaginary), but I definitely wouldn't want to do it for regular debugging. If my process has 1000 threads (not completely uncommon) then I don't think my debugger would be doing me a service showing me just the three it thinks are interesting and completely disregarding the others. Having a mode (it could even be default) which only highlights the interesting ones -- yes, that would definitely be useful. Making sure it doesn't touch the other threads when it doesn't need to -- absolutely. But I don't think it should pretend the other threads don't exist at all, because I may still have a reason to inspect those threads (or just to know that they're there). In fact, I wouldn't be surprised if this happened to the said kernel folks too, and they end up adding a custom command, which would enumerate all "threads".

First off, I also think that hiding some threads from users, or forcing people to say "thread list --force" or something like that to see them all would not be a user-friendly design. I'm not suggesting imposing that on general debugging. But if an OS plugin, for instance, decides it is too expensive to do this except as an explicit gesture, we need to support that decision.

But lldb stops many times during the course of a step where it doesn't return control to the user - all the step into code with no debug info, step out again, step across dynamic linker stubs or step through ObjC message dispatch dances we do involve many private stops per public spot... If a thread has not stopped "for a reason" at one of those stops, it takes no part in the "should stop" and "will resume" negotiations and reconstructing it for that stop really does serve no purpose. There's no way that the user will get a chance to see it.

So if we could avoid reading them in, that might make stepping go faster in the presence of lots of threads. BTW, with the accelerated stop packets where we get all the threads and their stop reasons on stop, I'm not sure this would really save all that much time. But talking to less capable stubs, it really can make a difference. Greg did a bunch of work to make sure stepping stopped as few times as possible because the Facebook gdb-remote stub didn't support these accelerated packets and getting all the thread info on each private stop was making stepping go really slowly. I didn't understand the motivation at first because for debugserver the changes didn't really make any difference.

Also, I don't think these two desires: not fetching threads when we don't need them (e.g. private stops) and showing them all to the user whenever they ask, are contradictory. After all we still have the gate of UpdateThreadListIfNeeded. All the commands that touch the thread list go through this. So even if we don't gather all the threads when we stop, we already have a mechanism in place whereby any command that actually touches the thread list can fetch them on demand.

Yes, I agree with everything above. If lldb does not need information about all threads in order to service a internal stop, then it shouldn't read it in, and the os plugin (or the remote stub) should not need to provide it. In fact I would even go so far as to say that we shouldn't need to read in this information for a public stop until a user performs an operation (e.g. thread list) that requires information about all threads.

What was actually the slow part here? Was it the os plugin reading the thread lists from the kernel memory? Or the fact that lldb is slow when it is confronted with them?

If it is the latter, then maybe we should fix that. For example, I think I remember lldb likes to check the PC of every thread before it does any kind of a resume -- I am not convinced that is really needed.

If fetching the threads is slow, then perhaps we could have an api, where the os threads are produced incrementally, and we ensure that lldb does not query for os threads needlessly during the hot paths (e.g. internal stops for servicing thread plans).

The thing that is slow is gathering all the threads. On Darwin, there's a kernel activation per user space thread and then a whole bunch of kernel threads. On a busy system, that ends up being a whole lot of threads. Producing them through the OS plugin interface involves a bunch of memory reads to fetch the thread data, and following pointers around to get the register state for the threads, etc.

Note also, the way the OS Plugins currently work, when the process stops the OS Plugin just gets asked to produce the threads backing the "on core" threads. That's all UpdateThreadListIfNeeded will fetch, and there's no lldb way to get the OS Plugin to fetch all the threads it can produce. The only way to do that with the Darwin kernel is to run other commands in the set of Python commands provided by the kernel team that either fetches a non-current thread by ID or forces fetching all the threads.

So the current state when working with OS Plugins violates your principle given above,

IIUC, this principle is only violated for this particular os plugin, which violates the plugin contract and does not return all threads through the get_thread_info interface. I don't know whether this contract is spelled out anywhere, but it seems like at least the code in lldb behaves that way.

So this is technically not "our" fault. The plugin is doing something unsupported and gets weird behavior as a result. Now, I am not saying we should throw this plugin (maybe the only actually used os plugin) overboard. However, I was hoping that the process of supporting it would involve some improvements to the os plugin interface (so that it can do what it wants in a supported way), rather than declaring support for whatever it is the plugin is doing, even though we know it to be problematic (like, not being able to tell when we can throw thread plans away).

I think when presenting an OS's threads through the funnel of a monitor stub that only knows about cores and not about the OS's concept of threads, you will very likely run into the problem where reconstructing all the threads at every stop is expensive and not particularly desirable. Two of the three instances of OS plugins that I know about do it this way. The other is for wrapping a cooperative multi-threading library, where fetching all the threads was pretty easy and there weren't too many. But for instance if getting all the threads really is slow, for the OS plugin to be useful we need to allow it to do partial reporting to be useful.

Anyway, I don't know that we need anything more added to the OS interface. There's a "make a thread for a TID" interface, which we can use to reap the persistent part of the thread, for instance when we make a public stop. If that's fast enough (I haven't gotten to that point with the xnu plugin) we can us that. We can add an API to query whether the plugin returns all threads, and gate our behavior on that rather than on "Has OS Plugin". But that's about all I can think of. I also have to support all the OS plugins in all the xnu dSYM's that are currently in the wild, too. So whatever we do has to work without requiring added behaviors.

That said, I don't really use or care about the os plugins, so if using it results in leaking thread plans, then whatever. The thing I want to understand is what kind of requirements does this place on the rest of lldb. Which leads me to my next comment..

but I think it fits the kernel folks workflow, since the actual number of threads in the kernel is overwhelming and not terribly useful. But you are right, if we wanted to delay getting threads on private stops, but make UpdateThreadListIfNeeded force a fetch, then we would have to add some API to allow us to fetch only the "on core" threads along the code path that handles internal stops.

In any case, in order to support having internal stops not fetch all threads - which we are currently doing with OS Plugins - we need to be able to persist the stateful data lldb holds for that thread across stops where we don't realize the Thread object. That is the sole ambition of this set of patches.

We've agreed that we would like to avoid gathering the thread data for internals stops that don't need it. Avoiding creating (updating) lldb_private::Thread objects, and having the not-(yet)-realized threads live as a tid_t is one way to achieve this goal, but I am not sure if it is the right one. I am not really against the idea -- since threads can come and go between stops pretty much arbitrarily (even without os plugins), it may make sense to have everything hold onto them as simple handles, and force a fetch through some Process api when one needs to access them may simplify some things (for one, the lifetime of Threads could become much stricter).

I can certainly believe that changing thread plans to use a tid_t instead of a Thread& is simpler than making Thread object management lazy, but I am not sure that is a fair comparison. Thread plans are only a single component which juggles Thread objects. There are many other pieces of code, which assume that the lifetime of a Thread object matches that of the entity it describes. SBThread is one such thing. If SBThread keeps referring to the actual thread as a pointer, then it will lose track of it when the actual thread goes away and reappears. Same goes for ValueObjects and SBValues -- if lldb_private::Thread is meant to be transient, then those should also be updated to use a tid_t(*), but then the changes required to do that become much larger, and it's not clear to me whether that is really worth it, since this is just kind of reinventing weak_ptr<Thread> (but with the downside mentioned in (*)).

Everything that holds onto its state using an ExecutionContextRef already holds onto the m_tid as the real entity, and the Thread is only a cache (see ExecutionContextRef::GetThreadSP). That probably hasn't been pushed hard, and I've only written a few tests with actually vanishing threads so far. But if it doesn't work properly then that's a bug to fix not a design to change.

ValueObjects (and therefore SBValues) use an ExecutionContextRef in their UpdatePoint, they don't hold onto a thread. SBThread's also hold ExecutionContextRef's not ThreadWP's to get back to their actual thread. In general, anything that wants to know "where am I in the state space of the process" is supposed to use an ExecutionContextRef to store its state not individual target/process/thread/etc. So I'm not sure this is so far off, but we would have to write some more tests with threads coming and going to make sure this is used consistently.

(*) I don't believe tid_t is actually a good way to keep track of the identity of a thread across time. It does uniquely identify a thread at any given point in time, but thread ids can be recycled (sometimes very quickly -- running the lldb test suite just once causes linux to wrap its pid space), which means you can't guarantee it will always refer to the same physical thread. If we're going to be using numbers to identify threads I think it should be some other kind of an identifier -- but that is sort of what a Thread* already is.

Not sure I understand this. If I run the process and a real thread exits and another one is created with the same TID, all before stopping, when I go to merge the thread lists on stop I'm going to think this different thread was the same thread because it had the same TID. I don't see how using Thread pointers rather than TID's helps with this. I still have to trust the TID I got from the monitor. We are always going to have a problem merging up Threads when TID's can be reused. I don't see how our Thread *'s - which don't represent anything in the target, and thus don't help with reasoning about persistence, help this at all.

For instance, on MacOS user space the TID we use is the "globally unique thread ID" so it never recurs. The xnu OS plugin has a unique identifier as well. Similarly, if this becomes a problem on Linux, IIRC you observe thread creation and deletion so you can do pruning at that point. But this reasoning is all about TID's not about Thread *'s. So I still think that TID's are a better identifier for our representation of threads than the Thread * that we happen to wrap them in. Note also, when OS Plugin's are around, the mapping from Thread * to TID is not quite so straightforward, and one of the things I like about moving the persistent parts of the Thread (which for now are only the ThreadPlanStack and the TID) out of the whole thread production logic is that it gets us out of knowing anything about this representation, and in the end we can ask the question we really care about: "Is the TID still here".

[labath]

Everything that holds onto its state using an ExecutionContextRef already holds onto the m_tid as the real entity, and the Thread is only a cache (see ExecutionContextRef::GetThreadSP).

I'm sorry I missed that part. (I saw the ThreadWP, but didn't look further into how it is used).

I'm going to respond in more detail tomorrow, but for now I am just wanted to let you know that my main concern about this has been addressed.

[labath]

In D75711#1912902, @jingham wrote:

In D75711#1912230, @labath wrote:

So this is technically not "our" fault. The plugin is doing something unsupported and gets weird behavior as a result. Now, I am not saying we should throw this plugin (maybe the only actually used os plugin) overboard. However, I was hoping that the process of supporting it would involve some improvements to the os plugin interface (so that it can do what it wants in a supported way), rather than declaring support for whatever it is the plugin is doing, even though we know it to be problematic (like, not being able to tell when we can throw thread plans away).

I think when presenting an OS's threads through the funnel of a monitor stub that only knows about cores and not about the OS's concept of threads, you will very likely run into the problem where reconstructing all the threads at every stop is expensive and not particularly desirable. Two of the three instances of OS plugins that I know about do it this way. The other is for wrapping a cooperative multi-threading library, where fetching all the threads was pretty easy and there weren't too many. But for instance if getting all the threads really is slow, for the OS plugin to be useful we need to allow it to do partial reporting to be useful.

Anyway, I don't know that we need anything more added to the OS interface. There's a "make a thread for a TID" interface, which we can use to reap the persistent part of the thread, for instance when we make a public stop. If that's fast enough (I haven't gotten to that point with the xnu plugin) we can us that. We can add an API to query whether the plugin returns all threads, and gate our behavior on that rather than on "Has OS Plugin". But that's about all I can think of.

Yes, that's sort of what I was expecting. Another idea I had was to have a way to avoid reading the register context initially, and only have it be fetched on demand.

I also have to support all the OS plugins in all the xnu dSYM's that are currently in the wild, too. So whatever we do has to work without requiring added behaviors.

Yep, anything we do shouldn't break existing plugins, but I think its fair to require some modification to an existing plugin in order to enable a new feature (such as stepping across thread reschedules).

That said, I don't really use or care about the os plugins, so if using it results in leaking thread plans, then whatever. The thing I want to understand is what kind of requirements does this place on the rest of lldb. Which leads me to my next comment..

but I think it fits the kernel folks workflow, since the actual number of threads in the kernel is overwhelming and not terribly useful. But you are right, if we wanted to delay getting threads on private stops, but make UpdateThreadListIfNeeded force a fetch, then we would have to add some API to allow us to fetch only the "on core" threads along the code path that handles internal stops.

In any case, in order to support having internal stops not fetch all threads - which we are currently doing with OS Plugins - we need to be able to persist the stateful data lldb holds for that thread across stops where we don't realize the Thread object. That is the sole ambition of this set of patches.

We've agreed that we would like to avoid gathering the thread data for internals stops that don't need it. Avoiding creating (updating) lldb_private::Thread objects, and having the not-(yet)-realized threads live as a tid_t is one way to achieve this goal, but I am not sure if it is the right one. I am not really against the idea -- since threads can come and go between stops pretty much arbitrarily (even without os plugins), it may make sense to have everything hold onto them as simple handles, and force a fetch through some Process api when one needs to access them may simplify some things (for one, the lifetime of Threads could become much stricter).

I can certainly believe that changing thread plans to use a tid_t instead of a Thread& is simpler than making Thread object management lazy, but I am not sure that is a fair comparison. Thread plans are only a single component which juggles Thread objects. There are many other pieces of code, which assume that the lifetime of a Thread object matches that of the entity it describes. SBThread is one such thing. If SBThread keeps referring to the actual thread as a pointer, then it will lose track of it when the actual thread goes away and reappears. Same goes for ValueObjects and SBValues -- if lldb_private::Thread is meant to be transient, then those should also be updated to use a tid_t(*), but then the changes required to do that become much larger, and it's not clear to me whether that is really worth it, since this is just kind of reinventing weak_ptr<Thread> (but with the downside mentioned in (*)).

Everything that holds onto its state using an ExecutionContextRef already holds onto the m_tid as the real entity, and the Thread is only a cache (see ExecutionContextRef::GetThreadSP). That probably hasn't been pushed hard, and I've only written a few tests with actually vanishing threads so far. But if it doesn't work properly then that's a bug to fix not a design to change.

ValueObjects (and therefore SBValues) use an ExecutionContextRef in their UpdatePoint, they don't hold onto a thread. SBThread's also hold ExecutionContextRef's not ThreadWP's to get back to their actual thread. In general, anything that wants to know "where am I in the state space of the process" is supposed to use an ExecutionContextRef to store its state not individual target/process/thread/etc. So I'm not sure this is so far off, but we would have to write some more tests with threads coming and going to make sure this is used consistently.

This sounds very convincing to me. I was under the impression that this is kind of inventing something new, but as there already is a notion of floating Thread objects, then I don't have a problem with that. I'd say the existing ExecutionContextRef mechanism is working fairly well, as I haven't yet noticed how it re-fetches threads.

(*) I don't believe tid_t is actually a good way to keep track of the identity of a thread across time. It does uniquely identify a thread at any given point in time, but thread ids can be recycled (sometimes very quickly -- running the lldb test suite just once causes linux to wrap its pid space), which means you can't guarantee it will always refer to the same physical thread. If we're going to be using numbers to identify threads I think it should be some other kind of an identifier -- but that is sort of what a Thread* already is.

Not sure I understand this. If I run the process and a real thread exits and another one is created with the same TID, all before stopping, when I go to merge the thread lists on stop I'm going to think this different thread was the same thread because it had the same TID. I don't see how using Thread pointers rather than TID's helps with this. I still have to trust the TID I got from the monitor. We are always going to have a problem merging up Threads when TID's can be reused. I don't see how our Thread *'s - which don't represent anything in the target, and thus don't help with reasoning about persistence, help this at all.

a Thread* helps precisely because it "doesn't represent anything in the target". Since tid_ts are supposed to match what the OS notion of a thread identifier is, and these are not unique across time on all systems, we'd need to come up with some surrogate identifier to be able to tell them apart. A pointer one kind of a unique identifier.

However, you are right that this alone would not help us maintain accurate thread identity because the tid could come and go without us noticing (though it would help if we do observe the thread to disappear). Further changes would be needed to make that work (and it's not clear whether they are actually worth it). I was mainly trying to ensure that any new concept we come up with does not get in the way if that becomes necessary. But as we are not inventing a new concept here, this point is moot.

[jingham]

In D75711#1914001, @labath wrote:

In D75711#1912902, @jingham wrote:

In D75711#1912230, @labath wrote:

So this is technically not "our" fault. The plugin is doing something unsupported and gets weird behavior as a result. Now, I am not saying we should throw this plugin (maybe the only actually used os plugin) overboard. However, I was hoping that the process of supporting it would involve some improvements to the os plugin interface (so that it can do what it wants in a supported way), rather than declaring support for whatever it is the plugin is doing, even though we know it to be problematic (like, not being able to tell when we can throw thread plans away).

I think when presenting an OS's threads through the funnel of a monitor stub that only knows about cores and not about the OS's concept of threads, you will very likely run into the problem where reconstructing all the threads at every stop is expensive and not particularly desirable. Two of the three instances of OS plugins that I know about do it this way. The other is for wrapping a cooperative multi-threading library, where fetching all the threads was pretty easy and there weren't too many. But for instance if getting all the threads really is slow, for the OS plugin to be useful we need to allow it to do partial reporting to be useful.

Anyway, I don't know that we need anything more added to the OS interface. There's a "make a thread for a TID" interface, which we can use to reap the persistent part of the thread, for instance when we make a public stop. If that's fast enough (I haven't gotten to that point with the xnu plugin) we can us that. We can add an API to query whether the plugin returns all threads, and gate our behavior on that rather than on "Has OS Plugin". But that's about all I can think of.

Yes, that's sort of what I was expecting. Another idea I had was to have a way to avoid reading the register context initially, and only have it be fetched on demand.

I also have to support all the OS plugins in all the xnu dSYM's that are currently in the wild, too. So whatever we do has to work without requiring added behaviors.

Yep, anything we do shouldn't break existing plugins, but I think its fair to require some modification to an existing plugin in order to enable a new feature (such as stepping across thread reschedules).

That said, I don't really use or care about the os plugins, so if using it results in leaking thread plans, then whatever. The thing I want to understand is what kind of requirements does this place on the rest of lldb. Which leads me to my next comment..

but I think it fits the kernel folks workflow, since the actual number of threads in the kernel is overwhelming and not terribly useful. But you are right, if we wanted to delay getting threads on private stops, but make UpdateThreadListIfNeeded force a fetch, then we would have to add some API to allow us to fetch only the "on core" threads along the code path that handles internal stops.

In any case, in order to support having internal stops not fetch all threads - which we are currently doing with OS Plugins - we need to be able to persist the stateful data lldb holds for that thread across stops where we don't realize the Thread object. That is the sole ambition of this set of patches.

We've agreed that we would like to avoid gathering the thread data for internals stops that don't need it. Avoiding creating (updating) lldb_private::Thread objects, and having the not-(yet)-realized threads live as a tid_t is one way to achieve this goal, but I am not sure if it is the right one. I am not really against the idea -- since threads can come and go between stops pretty much arbitrarily (even without os plugins), it may make sense to have everything hold onto them as simple handles, and force a fetch through some Process api when one needs to access them may simplify some things (for one, the lifetime of Threads could become much stricter).

I can certainly believe that changing thread plans to use a tid_t instead of a Thread& is simpler than making Thread object management lazy, but I am not sure that is a fair comparison. Thread plans are only a single component which juggles Thread objects. There are many other pieces of code, which assume that the lifetime of a Thread object matches that of the entity it describes. SBThread is one such thing. If SBThread keeps referring to the actual thread as a pointer, then it will lose track of it when the actual thread goes away and reappears. Same goes for ValueObjects and SBValues -- if lldb_private::Thread is meant to be transient, then those should also be updated to use a tid_t(*), but then the changes required to do that become much larger, and it's not clear to me whether that is really worth it, since this is just kind of reinventing weak_ptr<Thread> (but with the downside mentioned in (*)).

Everything that holds onto its state using an ExecutionContextRef already holds onto the m_tid as the real entity, and the Thread is only a cache (see ExecutionContextRef::GetThreadSP). That probably hasn't been pushed hard, and I've only written a few tests with actually vanishing threads so far. But if it doesn't work properly then that's a bug to fix not a design to change.

ValueObjects (and therefore SBValues) use an ExecutionContextRef in their UpdatePoint, they don't hold onto a thread. SBThread's also hold ExecutionContextRef's not ThreadWP's to get back to their actual thread. In general, anything that wants to know "where am I in the state space of the process" is supposed to use an ExecutionContextRef to store its state not individual target/process/thread/etc. So I'm not sure this is so far off, but we would have to write some more tests with threads coming and going to make sure this is used consistently.

This sounds very convincing to me. I was under the impression that this is kind of inventing something new, but as there already is a notion of floating Thread objects, then I don't have a problem with that. I'd say the existing ExecutionContextRef mechanism is working fairly well, as I haven't yet noticed how it re-fetches threads.

To be fair, I think in the current state of things, this code is probably seldom used, since we track threads accurately and you would very seldom have a TID the process knows about that doesn't have a backing thread by the time you get to the level where people were using ExecutionContextRef's. So it's possible this doesn't work perfectly when threads do vanish - though I haven't seen this in any of my hand-testing. But it shows that when we were thinking about how to specify threads we made the same choice we did with frames, and specify them by PC/CFA for frames and TID for threads rather than the native lldb objects.

(*) I don't believe tid_t is actually a good way to keep track of the identity of a thread across time. It does uniquely identify a thread at any given point in time, but thread ids can be recycled (sometimes very quickly -- running the lldb test suite just once causes linux to wrap its pid space), which means you can't guarantee it will always refer to the same physical thread. If we're going to be using numbers to identify threads I think it should be some other kind of an identifier -- but that is sort of what a Thread* already is.

Not sure I understand this. If I run the process and a real thread exits and another one is created with the same TID, all before stopping, when I go to merge the thread lists on stop I'm going to think this different thread was the same thread because it had the same TID. I don't see how using Thread pointers rather than TID's helps with this. I still have to trust the TID I got from the monitor. We are always going to have a problem merging up Threads when TID's can be reused. I don't see how our Thread *'s - which don't represent anything in the target, and thus don't help with reasoning about persistence, help this at all.

a Thread* helps precisely because it "doesn't represent anything in the target". Since tid_ts are supposed to match what the OS notion of a thread identifier is, and these are not unique across time on all systems, we'd need to come up with some surrogate identifier to be able to tell them apart. A pointer one kind of a unique identifier.

However, you are right that this alone would not help us maintain accurate thread identity because the tid could come and go without us noticing (though it would help if we do observe the thread to disappear). Further changes would be needed to make that work (and it's not clear whether they are actually worth it). I was mainly trying to ensure that any new concept we come up with does not get in the way if that becomes necessary. But as we are not inventing a new concept here, this point is moot.

Yes, I think we're okay there.

Even if we get don't notice that a TID has changed its underlying Thread object, the thread plans all get asked "Are you stale" as part of the should-stop mechanism. For instance a "step-out" plan knows that it is stepping out to some Frame, and if that frame isn't on the stack it ditches itself. Similarly step plans expect to see the current stepping frame.. So if you did get it wrong and attach the Thread Plans from one underlying thread to another one which adopted its TID, they would all get discarded when applied to a thread that didn't make sense.

[jingham]

Is this one okay as well?

[clayborg]

Everything looks good, just a question in inlined comment about having a thread plan hold onto a pointer to a thread. Seems dangerous

lldb/include/lldb/Target/ThreadPlan.h

601

This seems dangerous to hold onto? It can go stale if the thread goes away right? If we have the m_tid, why do we need this? If we want a thread pointer in this class, should it be a std::weak_ptr? It also seems that if we make a ThreadRef class that is something like:

struct ThreadRef {
  std::weak_ptr<lldb_private::Thread> m_thread_wp;
  lldb::tid_t m_tid;
};

We could re-use this in this class and ExecutionContextRef.

[jingham]

In D75711#1920642, @clayborg wrote:

Everything looks good, just a question in inlined comment about having a thread plan hold onto a pointer to a thread. Seems dangerous

The way the ThreadPlanStacks will get used, every time a process stops, lldb will build up a new thread list like it does already, then we update the collection of thread plan stacks, passing in the new thread list. That will grab the TID for each new thread and look it up in the map of stacks (which is indexed by TID). Each time we find a TID from the new thread list that's already in the map, we set the Thread * in the stack map to the one we got the TID from. Then for all the TID's that aren't in the new thread list we either discard it (if we're not holding onto plans for vanished threads) or we set its Thread * to nullptr. So the Thread * is just acting as a cache so you don't need to keep looking up the TID every time you need to get the Thread * for a ThreadPlan between one stop and another.

Unless there's some way that a thread that we saw when we stopped can go away before the next resume without the ThreadList being notified so it can re-sync, this mechanism is safe, and I can't think of any mechanism of that sort in lldb.

If you're still worried about this, I think the safe solution is to remove the Thread * and look up the TID in the Process every time you need the Thread *. Using a ThreadWP doesn't really express what you want here, because the Thread may have been discarded but it's SP is still alive because it's in some list we haven't gotten rid of or something like that. So WP.lock() working doesn't really mean the thread is still alive in the process, but TID in ThreadList does.

[labath]

In D75711#1920425, @jingham wrote:

Is this one okay as well?

All my concerns have been addressed.

lldb/include/lldb/Target/ThreadPlan.h

public:
   /// \return
   ///   A const char * pointer to the thread plan's name.
   const char *GetName() const { return m_name.c_str(); }
 
   /// Returns the Thread that is using this thread plan.
   ///
   /// \return
   ///   A  pointer to the thread plan's owning thread.
-  Thread &GetThread() { return m_thread; }
+  Thread &GetThread();
 
-  const Thread &GetThread() const { return m_thread; }
+  Target &GetTarget() { return m_process.GetTarget(); }
 
-  Target &GetTarget() { return m_thread.GetProcess()->GetTarget(); }
-
-  const Target &GetTarget() const { return m_thread.GetProcess()->GetTarget(); }
+  const Target &GetTarget() const { return m_process.GetTarget(); }
 
   /// Print a description of this thread to the stream \a s.
   /// \a thread.
   ///
   /// \param[in] s
   ///    The stream to which to print the description.
   ///
   /// \param[in] level
public:
   virtual void DidPush();
 
   virtual void WillPop();
 
   // This pushes a plan onto the plan stack of the current plan's thread.
   // Also sets the plans to private and not master plans.  A plan pushed by 
   // another thread plan is never either of the above.
   void PushPlan(lldb::ThreadPlanSP &thread_plan_sp) {
-    m_thread.PushPlan(thread_plan_sp);
+    GetThread().PushPlan(thread_plan_sp);
     thread_plan_sp->SetPrivate(false);
     thread_plan_sp->SetIsMasterPlan(false);
   }
 
   ThreadPlanKind GetKind() const { return m_kind; }
 
   bool IsPlanComplete();
 
if (m_tracer_sp && m_tracer_sp->TracingEnabled())
       m_tracer_sp->Log();
   }
 
   // Some thread plans hide away the actual stop info which caused any
   // particular stop.  For instance the ThreadPlanCallFunction restores the
   // original stop reason so that stopping and calling a few functions won't
   // lose the history of the run. This call can be implemented to get you back
   // to the real stop info.
-  virtual lldb::StopInfoSP GetRealStopInfo() { return m_thread.GetStopInfo(); }
+  virtual lldb::StopInfoSP GetRealStopInfo() { 
+    return GetThread().GetStopInfo();
+  }
 
   // If the completion of the thread plan stepped out of a function, the return
   // value of the function might have been captured by the thread plan
   // (currently only ThreadPlanStepOut does this.) If so, the ReturnValueObject
   // can be retrieved from here.
 
   virtual lldb::ValueObjectSP GetReturnValueObject() {
     return lldb::ValueObjectSP();
protected:
   }
 
   virtual bool DoPlanExplainsStop(Event *event_ptr) = 0;
 
   // This gets the previous plan to the current plan (for forwarding requests).
   // This is mostly a formal requirement, it allows us to make the Thread's
   // GetPreviousPlan protected, but only friend ThreadPlan to thread.
 
-  ThreadPlan *GetPreviousPlan() { return m_thread.GetPreviousPlan(this); }
+  ThreadPlan *GetPreviousPlan() { return GetThread().GetPreviousPlan(this); }
 
   // This forwards the private Thread::GetPrivateStopInfo which is generally
   // what ThreadPlan's need to know.
 
   lldb::StopInfoSP GetPrivateStopInfo() {
-    return m_thread.GetPrivateStopInfo();
+    return GetThread().GetPrivateStopInfo();
   }
 
   void SetStopInfo(lldb::StopInfoSP stop_reason_sp) {
-    m_thread.SetStopInfo(stop_reason_sp);
+    GetThread().SetStopInfo(stop_reason_sp);
   }
 
   void CachePlanExplainsStop(bool does_explain) {
     m_cached_plan_explains_stop = does_explain ? eLazyBoolYes : eLazyBoolNo;
   }
 
   LazyBool GetCachedPlanExplainsStop() const {
     return m_cached_plan_explains_stop;
   }
 
   virtual lldb::StateType GetPlanRunState() = 0;
 
   bool IsUsuallyUnexplainedStopReason(lldb::StopReason);
 
   Status m_status;
-  Thread &m_thread;
+  Process &m_process;
+  lldb::tid_t m_tid;
   Vote m_stop_vote;
   Vote m_run_vote;
   bool m_takes_iteration_count;
   bool m_could_not_resolve_hw_bp;
   int32_t m_iteration_count = 1;
 
 private:
   // For ThreadPlan only
   static lldb::user_id_t GetNextID();
 
+  Thread *m_thread;
   ThreadPlanKind m_kind;
   std::string m_name;
   std::recursive_mutex m_plan_complete_mutex;
   LazyBool m_cached_plan_explains_stop;
   bool m_plan_complete;
   bool m_plan_private;
   bool m_okay_to_discard;
   bool m_is_master_plan;

lldb/include/lldb/Target/ThreadPlanPython.h

public:
   void DidPush() override;
 
   bool IsPlanStale() override;
 
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   lldb::StateType GetPlanRunState() override;
   
+  ScriptInterpreter *GetScriptInterpreter();
+
 private:
   std::string m_class_name;
   StructuredDataImpl *m_args_data; // We own this, but the implementation
                                    // has to manage the UP (since that is
                                    // how it gets stored in the
                                    // SBStructuredData).
   std::string m_error_str;
   StructuredData::ObjectSP m_implementation_sp;
   bool m_did_push;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanPython);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANPYTHON_H

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

 // Destructor
 AppleThreadPlanStepThroughObjCTrampoline::
     ~AppleThreadPlanStepThroughObjCTrampoline() {}
 
 void AppleThreadPlanStepThroughObjCTrampoline::DidPush() {
   // Setting up the memory space for the called function text might require
   // allocations, i.e. a nested function call.  This needs to be done as a
   // PreResumeAction.
-  m_thread.GetProcess()->AddPreResumeAction(PreResumeInitializeFunctionCaller,
-                                            (void *)this);
+  m_process.AddPreResumeAction(PreResumeInitializeFunctionCaller, (void *)this);
 }
 
 bool AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller() {
   if (!m_func_sp) {
     DiagnosticManager diagnostics;
     m_args_addr =
-        m_trampoline_handler.SetupDispatchFunction(m_thread, m_input_values);
+        m_trampoline_handler.SetupDispatchFunction(GetThread(), m_input_values);
 
     if (m_args_addr == LLDB_INVALID_ADDRESS) {
       return false;
     }
     m_impl_function =
         m_trampoline_handler.GetLookupImplementationFunctionCaller();
     ExecutionContext exc_ctx;
     EvaluateExpressionOptions options;
     options.SetUnwindOnError(true);
     options.SetIgnoreBreakpoints(true);
     options.SetStopOthers(m_stop_others);
-    m_thread.CalculateExecutionContext(exc_ctx);
+    GetThread().CalculateExecutionContext(exc_ctx);
     m_func_sp = m_impl_function->GetThreadPlanToCallFunction(
         exc_ctx, m_args_addr, options, diagnostics);
     m_func_sp->SetOkayToDiscard(true);
     PushPlan(m_func_sp);
   }
   return true;
 }
 
if (m_func_sp) {
     }
   }
 
   // Second stage, if all went well with the function calling, then fetch the
   // target address, and queue up a "run to that address" plan.
   if (!m_run_to_sp) {
     Value target_addr_value;
     ExecutionContext exc_ctx;
-    m_thread.CalculateExecutionContext(exc_ctx);
+    GetThread().CalculateExecutionContext(exc_ctx);
     m_impl_function->FetchFunctionResults(exc_ctx, m_args_addr,
                                           target_addr_value);
     m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr);
     lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong();
     Address target_so_addr;
     target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     if (target_addr == 0) {
       LLDB_LOGF(log, "Got target implementation of 0x0, stopping.");
       SetPlanComplete();
       return true;
     }
     if (m_trampoline_handler.AddrIsMsgForward(target_addr)) {
       LLDB_LOGF(log,
                 "Implementation lookup returned msgForward function: 0x%" PRIx64
                 ", stopping.",
                 target_addr);
 
-      SymbolContext sc = m_thread.GetStackFrameAtIndex(0)->GetSymbolContext(
+      SymbolContext sc = GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(
           eSymbolContextEverything);
       Status status;
       const bool abort_other_plans = false;
       const bool first_insn = true;
       const uint32_t frame_idx = 0;
-      m_run_to_sp = m_thread.QueueThreadPlanForStepOutNoShouldStop(
+      m_run_to_sp = GetThread().QueueThreadPlanForStepOutNoShouldStop(
           abort_other_plans, &sc, first_insn, m_stop_others, eVoteNoOpinion,
           eVoteNoOpinion, frame_idx, status);
       if (m_run_to_sp && status.Success())
         m_run_to_sp->SetPrivate(true);
       return false;
     }
 
     LLDB_LOGF(log, "Running to ObjC method implementation: 0x%" PRIx64,
               target_addr);
 
     ObjCLanguageRuntime *objc_runtime =
         ObjCLanguageRuntime::Get(*GetThread().GetProcess());
     assert(objc_runtime != nullptr);
     objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr);
     LLDB_LOGF(log,
               "Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64
               "} = addr=0x%" PRIx64 " to cache.",
               m_isa_addr, m_sel_addr, target_addr);
 
     // Extract the target address from the value:
 
     m_run_to_sp = std::make_shared<ThreadPlanRunToAddress>(
-        m_thread, target_so_addr, m_stop_others);
+        GetThread(), target_so_addr, m_stop_others);
     PushPlan(m_run_to_sp);
     return false;
-  } else if (m_thread.IsThreadPlanDone(m_run_to_sp.get())) {
+  } else if (GetThread().IsThreadPlanDone(m_run_to_sp.get())) {
     // Third stage, work the run to target plan.
     SetPlanComplete();
     return true;
   }
   return false;
 }
 
 // The base class MischiefManaged does some cleanup - so you have to call it in

lldb/source/Target/ThreadPlan.cpp

 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ThreadPlan constructor
 ThreadPlan::ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,
                        Vote stop_vote, Vote run_vote)
-    : m_thread(thread), m_stop_vote(stop_vote), m_run_vote(run_vote),
+    : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()), 
+      m_stop_vote(stop_vote), m_run_vote(run_vote),
       m_takes_iteration_count(false), m_could_not_resolve_hw_bp(false),
-      m_kind(kind), m_name(name), m_plan_complete_mutex(),
+      m_kind(kind), m_thread(&thread), m_name(name), m_plan_complete_mutex(),
       m_cached_plan_explains_stop(eLazyBoolCalculate), m_plan_complete(false),
       m_plan_private(false), m_okay_to_discard(true), m_is_master_plan(false),
       m_plan_succeeded(true) {
   SetID(GetNextID());
 }
 
 // Destructor
 ThreadPlan::~ThreadPlan() = default;
 
+Thread &ThreadPlan::GetThread() {
+  if (m_thread)
+    return *m_thread;
+    
+  ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(m_tid);
+  m_thread = thread_sp.get();
+  return *m_thread;
+}
+
 bool ThreadPlan::PlanExplainsStop(Event *event_ptr) {
   if (m_cached_plan_explains_stop == eLazyBoolCalculate) {
     bool actual_value = DoPlanExplainsStop(event_ptr);
     m_cached_plan_explains_stop = actual_value ? eLazyBoolYes : eLazyBoolNo;
     return actual_value;
   } else {
     return m_cached_plan_explains_stop == eLazyBoolYes;
   }

 
 bool ThreadPlan::WillResume(StateType resume_state, bool current_plan) {
   m_cached_plan_explains_stop = eLazyBoolCalculate;
 
   if (current_plan) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
     if (log) {
-      RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
+      RegisterContext *reg_ctx = GetThread().GetRegisterContext().get();
       assert(reg_ctx);
       addr_t pc = reg_ctx->GetPC();
       addr_t sp = reg_ctx->GetSP();
       addr_t fp = reg_ctx->GetFP();
       LLDB_LOGF(
           log,
           "%s Thread #%u (0x%p): tid = 0x%4.4" PRIx64 ", pc = 0x%8.8" PRIx64
           ", sp = 0x%8.8" PRIx64 ", fp = 0x%8.8" PRIx64 ", "
           "plan = '%s', state = %s, stop others = %d",
-          __FUNCTION__, m_thread.GetIndexID(), static_cast<void *>(&m_thread),
-          m_thread.GetID(), static_cast<uint64_t>(pc),
+          __FUNCTION__, GetThread().GetIndexID(), 
+          static_cast<void *>(&GetThread()), m_tid, static_cast<uint64_t>(pc),
           static_cast<uint64_t>(sp), static_cast<uint64_t>(fp), m_name.c_str(),
           StateAsCString(resume_state), StopOthers());
     }
   }
   return DoWillResume(resume_state, current_plan);
 }
 
 lldb::user_id_t ThreadPlan::GetNextID() {
void ThreadPlanNull::GetDescription(Stream *s, lldb::DescriptionLevel level) {
   s->PutCString("Null thread plan - thread has been destroyed.");
 }
 
 bool ThreadPlanNull::ValidatePlan(Stream *error) {
 #ifdef LLDB_CONFIGURATION_DEBUG
   fprintf(stderr,
           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
           ", ptid = 0x%" PRIx64 ")",
-          LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
+          LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #else
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
                ", ptid = 0x%" PRIx64 ")",
-               LLVM_PRETTY_FUNCTION, m_thread.GetID(),
-               m_thread.GetProtocolID());
+               LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #endif
   return true;
 }
 
 bool ThreadPlanNull::ShouldStop(Event *event_ptr) {
 #ifdef LLDB_CONFIGURATION_DEBUG
   fprintf(stderr,
           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
           ", ptid = 0x%" PRIx64 ")",
-          LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
+          LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #else
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
                ", ptid = 0x%" PRIx64 ")",
-               LLVM_PRETTY_FUNCTION, m_thread.GetID(),
-               m_thread.GetProtocolID());
+               LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #endif
   return true;
 }
 
 bool ThreadPlanNull::WillStop() {
 #ifdef LLDB_CONFIGURATION_DEBUG
   fprintf(stderr,
           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
           ", ptid = 0x%" PRIx64 ")",
-          LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
+          LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #else
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
                ", ptid = 0x%" PRIx64 ")",
-               LLVM_PRETTY_FUNCTION, m_thread.GetID(),
-               m_thread.GetProtocolID());
+               LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #endif
   return true;
 }
 
 bool ThreadPlanNull::DoPlanExplainsStop(Event *event_ptr) {
 #ifdef LLDB_CONFIGURATION_DEBUG
   fprintf(stderr,
           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
           ", ptid = 0x%" PRIx64 ")",
           LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
 #else
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
                ", ptid = 0x%" PRIx64 ")",
-               LLVM_PRETTY_FUNCTION, m_thread.GetID(),
-               m_thread.GetProtocolID());
+               LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #endif
   return true;
 }
 
 // The null plan is never done.
 bool ThreadPlanNull::MischiefManaged() {
 // The null plan is never done.
 #ifdef LLDB_CONFIGURATION_DEBUG
   fprintf(stderr,
           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
           ", ptid = 0x%" PRIx64 ")",
-          LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
+          LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #else
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
                ", ptid = 0x%" PRIx64 ")",
-               LLVM_PRETTY_FUNCTION, m_thread.GetID(),
-               m_thread.GetProtocolID());
+               LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #endif
   return false;
 }
 
 lldb::StateType ThreadPlanNull::GetPlanRunState() {
 // Not sure what to return here.  This is a dead thread.
 #ifdef LLDB_CONFIGURATION_DEBUG
   fprintf(stderr,
           "error: %s called on thread that has been destroyed (tid = 0x%" PRIx64
           ", ptid = 0x%" PRIx64 ")",
-          LLVM_PRETTY_FUNCTION, m_thread.GetID(), m_thread.GetProtocolID());
+          LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #else
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   if (log)
     log->Error("%s called on thread that has been destroyed (tid = 0x%" PRIx64
                ", ptid = 0x%" PRIx64 ")",
-               LLVM_PRETTY_FUNCTION, m_thread.GetID(),
-               m_thread.GetProtocolID());
+               LLVM_PRETTY_FUNCTION, m_tid, GetThread().GetProtocolID());
 #endif
   return eStateRunning;
 }

lldb/source/Target/ThreadPlanBase.cpp

 ThreadPlanBase::ThreadPlanBase(Thread &thread)
     : ThreadPlan(ThreadPlan::eKindBase, "base plan", thread, eVoteYes,
                  eVoteNoOpinion) {
 // Set the tracer to a default tracer.
 // FIXME: need to add a thread settings variable to pix various tracers...
 #define THREAD_PLAN_USE_ASSEMBLY_TRACER 1
 
 #ifdef THREAD_PLAN_USE_ASSEMBLY_TRACER
-  ThreadPlanTracerSP new_tracer_sp(new ThreadPlanAssemblyTracer(m_thread));
+  ThreadPlanTracerSP new_tracer_sp(new ThreadPlanAssemblyTracer(thread));
 #else
   ThreadPlanTracerSP new_tracer_sp(new ThreadPlanTracer(m_thread));
 #endif
-  new_tracer_sp->EnableTracing(m_thread.GetTraceEnabledState());
+  new_tracer_sp->EnableTracing(thread.GetTraceEnabledState());
   SetThreadPlanTracer(new_tracer_sp);
   SetIsMasterPlan(true);
 }
 
 ThreadPlanBase::~ThreadPlanBase() {}
 
 void ThreadPlanBase::GetDescription(Stream *s, lldb::DescriptionLevel level) {
   s->Printf("Base thread plan.");
 }
 
 bool ThreadPlanBase::ValidatePlan(Stream *error) { return true; }
 
 bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) {
   // The base plan should defer to its tracer, since by default it always
   // handles the stop.
   return !TracerExplainsStop();
 }
 
 Vote ThreadPlanBase::ShouldReportStop(Event *event_ptr) {
-  StopInfoSP stop_info_sp = m_thread.GetStopInfo();
+  StopInfoSP stop_info_sp = GetThread().GetStopInfo();
   if (stop_info_sp) {
     bool should_notify = stop_info_sp->ShouldNotify(event_ptr);
     if (should_notify)
       return eVoteYes;
     else
       return eVoteNoOpinion;
   } else
     return eVoteNoOpinion;
case eStopReasonWatchpoint:
       if (stop_info_sp->ShouldStopSynchronous(event_ptr)) {
         // If we are going to stop for a breakpoint, then unship the other
         // plans at this point.  Don't force the discard, however, so Master
         // plans can stay in place if they want to.
         LLDB_LOGF(
             log,
             "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
             " (breakpoint hit.)",
-            m_thread.GetID());
-        m_thread.DiscardThreadPlans(false);
+            m_tid);
+        GetThread().DiscardThreadPlans(false);
         return true;
       }
       // If we aren't going to stop at this breakpoint, and it is internal,
       // don't report this stop or the subsequent running event. Otherwise we
       // will post the stopped & running, but the stopped event will get marked
       // with "restarted" so the UI will know to wait and expect the consequent
       // "running".
       if (stop_info_sp->ShouldNotify(event_ptr)) {
if (stop_info_sp) {
 
     case eStopReasonException:
       // If we crashed, discard thread plans and stop.  Don't force the
       // discard, however, since on rerun the target may clean up this
       // exception and continue normally from there.
       LLDB_LOGF(
           log,
           "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
-          " (exception: %s)",
-          m_thread.GetID(), stop_info_sp->GetDescription());
-      m_thread.DiscardThreadPlans(false);
+          " (exception: %s)", 
+          m_tid, stop_info_sp->GetDescription());
+      GetThread().DiscardThreadPlans(false);
       return true;
 
     case eStopReasonExec:
       // If we crashed, discard thread plans and stop.  Don't force the
       // discard, however, since on rerun the target may clean up this
       // exception and continue normally from there.
       LLDB_LOGF(
           log,
           "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
           " (exec.)",
-          m_thread.GetID());
-      m_thread.DiscardThreadPlans(false);
+          m_tid);
+      GetThread().DiscardThreadPlans(false);
       return true;
 
     case eStopReasonThreadExiting:
     case eStopReasonSignal:
       if (stop_info_sp->ShouldStop(event_ptr)) {
         LLDB_LOGF(
             log,
             "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
-            " (signal: %s)",
-            m_thread.GetID(), stop_info_sp->GetDescription());
-        m_thread.DiscardThreadPlans(false);
+            " (signal: %s)", 
+            m_tid, stop_info_sp->GetDescription());
+        GetThread().DiscardThreadPlans(false);
         return true;
       } else {
         // We're not going to stop, but while we are here, let's figure out
         // whether to report this.
         if (stop_info_sp->ShouldNotify(event_ptr))
           m_stop_vote = eVoteYes;
         else
           m_stop_vote = eVoteNo;

lldb/source/Target/ThreadPlanCallFunction.cpp

 ThreadPlanCallFunction::~ThreadPlanCallFunction() {
   DoTakedown(PlanSucceeded());
 }
 
 void ThreadPlanCallFunction::ReportRegisterState(const char *message) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   if (log && log->GetVerbose()) {
     StreamString strm;
-    RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
+    RegisterContext *reg_ctx = GetThread().GetRegisterContext().get();
 
     log->PutCString(message);
 
     RegisterValue reg_value;
 
     for (uint32_t reg_idx = 0, num_registers = reg_ctx->GetRegisterCount();
          reg_idx < num_registers; ++reg_idx) {
       const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_idx);
if (!m_valid) {
     LLDB_LOGF(log,
               "ThreadPlanCallFunction(%p): Log called on "
               "ThreadPlanCallFunction that was never valid.",
               static_cast<void *>(this));
     return;
   }
 
   if (!m_takedown_done) {
+    Thread &thread = GetThread();
     if (success) {
       SetReturnValue();
     }
     LLDB_LOGF(log,
               "ThreadPlanCallFunction(%p): DoTakedown called for thread "
               "0x%4.4" PRIx64 ", m_valid: %d complete: %d.\n",
-              static_cast<void *>(this), m_thread.GetID(), m_valid,
-              IsPlanComplete());
+              static_cast<void *>(this), m_tid, m_valid, IsPlanComplete());
     m_takedown_done = true;
     m_stop_address =
-        m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
+        thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
     m_real_stop_info_sp = GetPrivateStopInfo();
-    if (!m_thread.RestoreRegisterStateFromCheckpoint(m_stored_thread_state)) {
+    if (!thread.RestoreRegisterStateFromCheckpoint(m_stored_thread_state)) {
       LLDB_LOGF(log,
                 "ThreadPlanCallFunction(%p): DoTakedown failed to restore "
                 "register state",
                 static_cast<void *>(this));
     }
     SetPlanComplete(success);
     ClearBreakpoints();
     if (log && log->GetVerbose())
       ReportRegisterState("Restoring thread state after function call.  "
                           "Restored register state:");
   } else {
     LLDB_LOGF(log,
               "ThreadPlanCallFunction(%p): DoTakedown called as no-op for "
               "thread 0x%4.4" PRIx64 ", m_valid: %d complete: %d.\n",
-              static_cast<void *>(this), m_thread.GetID(), m_valid,
-              IsPlanComplete());
+              static_cast<void *>(this), m_tid, m_valid, IsPlanComplete());
   }
 }
 
 void ThreadPlanCallFunction::WillPop() { DoTakedown(PlanSucceeded()); }
 
 void ThreadPlanCallFunction::GetDescription(Stream *s, DescriptionLevel level) {
   if (level == eDescriptionLevelBrief) {
     s->Printf("Function call thread plan");
   } else {
-    TargetSP target_sp(m_thread.CalculateTarget());
     s->Printf("Thread plan to call 0x%" PRIx64,
-              m_function_addr.GetLoadAddress(target_sp.get()));
+              m_function_addr.GetLoadAddress(&GetTarget()));
   }
 }
 
 bool ThreadPlanCallFunction::ValidatePlan(Stream *error) {
   if (!m_valid) {
     if (error) {
       if (m_constructor_errors.GetSize() > 0)
         error->PutCString(m_constructor_errors.GetString());
if (Process::ProcessEventData::GetInterruptedFromEvent(event_ptr)) {
     return true;
   }
   // We control breakpoints separately from other "stop reasons."  So first,
   // check the case where we stopped for an internal breakpoint, in that case,
   // continue on. If it is not an internal breakpoint, consult
   // m_ignore_breakpoints.
 
   if (stop_reason == eStopReasonBreakpoint) {
-    ProcessSP process_sp(m_thread.CalculateProcess());
     uint64_t break_site_id = m_real_stop_info_sp->GetValue();
     BreakpointSiteSP bp_site_sp;
-    if (process_sp)
-      bp_site_sp = process_sp->GetBreakpointSiteList().FindByID(break_site_id);
+    bp_site_sp = m_process.GetBreakpointSiteList().FindByID(break_site_id);
     if (bp_site_sp) {
       uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
       bool is_internal = true;
       for (uint32_t i = 0; i < num_owners; i++) {
         Breakpoint &bp = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
         LLDB_LOGF(log,
                   "ThreadPlanCallFunction::PlanExplainsStop: hit "
                   "breakpoint %d while calling function",
void ThreadPlanCallFunction::DidPush() {
 
   // Now set the thread state to "no reason" so we don't run with whatever
   // signal was outstanding... Wait till the plan is pushed so we aren't
   // changing the stop info till we're about to run.
 
   GetThread().SetStopInfoToNothing();
 
 #ifndef SINGLE_STEP_EXPRESSIONS
-  m_subplan_sp = std::make_shared<ThreadPlanRunToAddress>(
-      m_thread, m_start_addr, m_stop_other_threads);
+  Thread &thread = GetThread();
+  m_subplan_sp = std::make_shared<ThreadPlanRunToAddress>(thread, m_start_addr, 
+                                                          m_stop_other_threads);
 
-  m_thread.QueueThreadPlan(m_subplan_sp, false);
+  thread.QueueThreadPlan(m_subplan_sp, false);
   m_subplan_sp->SetPrivate(true);
 #endif
 }
 
 bool ThreadPlanCallFunction::WillStop() { return true; }
 
 bool ThreadPlanCallFunction::MischiefManaged() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (IsPlanComplete()) {
     LLDB_LOGF(log, "ThreadPlanCallFunction(%p): Completed call function plan.",
               static_cast<void *>(this));
 
     ThreadPlan::MischiefManaged();
     return true;
   } else {
     return false;
   }
 }
 
 void ThreadPlanCallFunction::SetBreakpoints() {
-  ProcessSP process_sp(m_thread.CalculateProcess());
-  if (m_trap_exceptions && process_sp) {
+  if (m_trap_exceptions) {
     m_cxx_language_runtime =
-        process_sp->GetLanguageRuntime(eLanguageTypeC_plus_plus);
-    m_objc_language_runtime = process_sp->GetLanguageRuntime(eLanguageTypeObjC);
+        m_process.GetLanguageRuntime(eLanguageTypeC_plus_plus);
+    m_objc_language_runtime = m_process.GetLanguageRuntime(eLanguageTypeObjC);
 
     if (m_cxx_language_runtime) {
       m_should_clear_cxx_exception_bp =
           !m_cxx_language_runtime->ExceptionBreakpointsAreSet();
       m_cxx_language_runtime->SetExceptionBreakpoints();
     }
     if (m_objc_language_runtime) {
       m_should_clear_objc_exception_bp =
void ThreadPlanCallFunction::SetStopOthers(bool new_value) {
   m_subplan_sp->SetStopOthers(new_value);
 }
 
 bool ThreadPlanCallFunction::RestoreThreadState() {
   return GetThread().RestoreThreadStateFromCheckpoint(m_stored_thread_state);
 }
 
 void ThreadPlanCallFunction::SetReturnValue() {
-  ProcessSP process_sp(m_thread.GetProcess());
-  const ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
+  const ABI *abi = m_process.GetABI().get();
   if (abi && m_return_type.IsValid()) {
     const bool persistent = false;
     m_return_valobj_sp =
-        abi->GetReturnValueObject(m_thread, m_return_type, persistent);
+        abi->GetReturnValueObject(GetThread(), m_return_type, persistent);
   }
 }

lldb/source/Target/ThreadPlanCallFunctionUsingABI.cpp

 
 ThreadPlanCallFunctionUsingABI::~ThreadPlanCallFunctionUsingABI() = default;
 
 void ThreadPlanCallFunctionUsingABI::GetDescription(Stream *s,
                                                     DescriptionLevel level) {
   if (level == eDescriptionLevelBrief) {
     s->Printf("Function call thread plan using ABI instead of JIT");
   } else {
-    TargetSP target_sp(m_thread.CalculateTarget());
     s->Printf("Thread plan to call 0x%" PRIx64 " using ABI instead of JIT",
-              m_function_addr.GetLoadAddress(target_sp.get()));
+              m_function_addr.GetLoadAddress(&GetTarget()));
   }
 }
 
 void ThreadPlanCallFunctionUsingABI::SetReturnValue() {
-  ProcessSP process_sp(m_thread.GetProcess());
-  const ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
+  const ABI *abi = m_process.GetABI().get();
 
   // Ask the abi for the return value
   if (abi) {
     const bool persistent = false;
     m_return_valobj_sp =
-        abi->GetReturnValueObject(m_thread, m_return_type, persistent);
+        abi->GetReturnValueObject(GetThread(), m_return_type, persistent);
   }
 }

lldb/source/Target/ThreadPlanCallUserExpression.cpp

bool ThreadPlanCallUserExpression::MischiefManaged() {
   }
 }
 
 StopInfoSP ThreadPlanCallUserExpression::GetRealStopInfo() {
   StopInfoSP stop_info_sp = ThreadPlanCallFunction::GetRealStopInfo();
 
   if (stop_info_sp) {
     lldb::addr_t addr = GetStopAddress();
-    DynamicCheckerFunctions *checkers =
-        m_thread.GetProcess()->GetDynamicCheckers();
+    DynamicCheckerFunctions *checkers = m_process.GetDynamicCheckers();
     StreamString s;
 
     if (checkers && checkers->DoCheckersExplainStop(addr, s))
       stop_info_sp->SetDescription(s.GetData());
   }
 
   return stop_info_sp;
 }
 
 void ThreadPlanCallUserExpression::DoTakedown(bool success) {
   ThreadPlanCallFunction::DoTakedown(success);
   m_user_expression_sp->DidFinishExecuting();
 }

lldb/source/Target/ThreadPlanPython.cpp

if (error)
           m_error_str.empty() ? "<unknown error>"
                                 : m_error_str.c_str());
     return false;
   }
 
   return true;
 }
 
+ScriptInterpreter *ThreadPlanPython::GetScriptInterpreter() {
+  return m_process.GetTarget().GetDebugger().GetScriptInterpreter();
+}
+
 void ThreadPlanPython::DidPush() {
   // We set up the script side in DidPush, so that it can push other plans in
   // the constructor, and doesn't have to care about the details of DidPush.
   m_did_push = true;
   if (!m_class_name.empty()) {
-    ScriptInterpreter *script_interp = m_thread.GetProcess()
-                                           ->GetTarget()
-                                           .GetDebugger()
-                                           .GetScriptInterpreter();
+    ScriptInterpreter *script_interp = GetScriptInterpreter();
     if (script_interp) {
       m_implementation_sp = script_interp->CreateScriptedThreadPlan(
           m_class_name.c_str(), m_args_data, m_error_str, 
           this->shared_from_this());
     }
   }
 }
 
 bool ThreadPlanPython::ShouldStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
             m_class_name.c_str());
 
   bool should_stop = true;
   if (m_implementation_sp) {
-    ScriptInterpreter *script_interp = m_thread.GetProcess()
-                                           ->GetTarget()
-                                           .GetDebugger()
-                                           .GetScriptInterpreter();
+    ScriptInterpreter *script_interp = GetScriptInterpreter();
     if (script_interp) {
       bool script_error;
       should_stop = script_interp->ScriptedThreadPlanShouldStop(
           m_implementation_sp, event_ptr, script_error);
       if (script_error)
         SetPlanComplete(false);
     }
   }
   return should_stop;
 }
 
 bool ThreadPlanPython::IsPlanStale() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
             m_class_name.c_str());
 
   bool is_stale = true;
   if (m_implementation_sp) {
-    ScriptInterpreter *script_interp = m_thread.GetProcess()
-                                           ->GetTarget()
-                                           .GetDebugger()
-                                           .GetScriptInterpreter();
+    ScriptInterpreter *script_interp = GetScriptInterpreter();
     if (script_interp) {
       bool script_error;
       is_stale = script_interp->ScriptedThreadPlanIsStale(m_implementation_sp,
                                                           script_error);
       if (script_error)
         SetPlanComplete(false);
     }
   }
   return is_stale;
 }
 
 bool ThreadPlanPython::DoPlanExplainsStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
             m_class_name.c_str());
 
   bool explains_stop = true;
   if (m_implementation_sp) {
-    ScriptInterpreter *script_interp = m_thread.GetProcess()
-                                           ->GetTarget()
-                                           .GetDebugger()
-                                           .GetScriptInterpreter();
+    ScriptInterpreter *script_interp = GetScriptInterpreter();
     if (script_interp) {
       bool script_error;
       explains_stop = script_interp->ScriptedThreadPlanExplainsStop(
           m_implementation_sp, event_ptr, script_error);
       if (script_error)
         SetPlanComplete(false);
     }
   }

 }
 
 lldb::StateType ThreadPlanPython::GetPlanRunState() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
             m_class_name.c_str());
   lldb::StateType run_state = eStateRunning;
   if (m_implementation_sp) {
-    ScriptInterpreter *script_interp = m_thread.GetProcess()
-                                           ->GetTarget()
-                                           .GetDebugger()
-                                           .GetScriptInterpreter();
+    ScriptInterpreter *script_interp = GetScriptInterpreter();
     if (script_interp) {
       bool script_error;
       run_state = script_interp->ScriptedThreadPlanGetRunState(
           m_implementation_sp, script_error);
     }
   }
   return run_state;
 }

lldb/source/Target/ThreadPlanRunToAddress.cpp

 // ThreadPlanRunToAddress: Continue plan
 
 ThreadPlanRunToAddress::ThreadPlanRunToAddress(Thread &thread, Address &address,
                                                bool stop_others)
     : ThreadPlan(ThreadPlan::eKindRunToAddress, "Run to address plan", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_stop_others(stop_others), m_addresses(), m_break_ids() {
   m_addresses.push_back(
-      address.GetOpcodeLoadAddress(m_thread.CalculateTarget().get()));
+      address.GetOpcodeLoadAddress(thread.CalculateTarget().get()));
   SetInitialBreakpoints();
 }
 
 ThreadPlanRunToAddress::ThreadPlanRunToAddress(Thread &thread,
                                                lldb::addr_t address,
                                                bool stop_others)
     : ThreadPlan(ThreadPlan::eKindRunToAddress, "Run to address plan", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_stop_others(stop_others), m_addresses(), m_break_ids() {
   m_addresses.push_back(
-      m_thread.CalculateTarget()->GetOpcodeLoadAddress(address));
+      thread.CalculateTarget()->GetOpcodeLoadAddress(address));
   SetInitialBreakpoints();
 }
 
 ThreadPlanRunToAddress::ThreadPlanRunToAddress(
     Thread &thread, const std::vector<lldb::addr_t> &addresses,
     bool stop_others)
     : ThreadPlan(ThreadPlan::eKindRunToAddress, "Run to address plan", thread,
                  eVoteNoOpinion, eVoteNoOpinion),

 }
 
 void ThreadPlanRunToAddress::SetInitialBreakpoints() {
   size_t num_addresses = m_addresses.size();
   m_break_ids.resize(num_addresses);
 
   for (size_t i = 0; i < num_addresses; i++) {
     Breakpoint *breakpoint;
-    breakpoint = m_thread.CalculateTarget()
-                     ->CreateBreakpoint(m_addresses[i], true, false)
-                     .get();
+    breakpoint =
+        GetTarget().CreateBreakpoint(m_addresses[i], true, false).get();
     if (breakpoint != nullptr) {
       if (breakpoint->IsHardware() && !breakpoint->HasResolvedLocations())
         m_could_not_resolve_hw_bp = true;
       m_break_ids[i] = breakpoint->GetID();
-      breakpoint->SetThreadID(m_thread.GetID());
+      breakpoint->SetThreadID(m_tid);
       breakpoint->SetBreakpointKind("run-to-address");
     }
   }
 }
 
 ThreadPlanRunToAddress::~ThreadPlanRunToAddress() {
   size_t num_break_ids = m_break_ids.size();
   for (size_t i = 0; i < num_break_ids; i++) {
-    m_thread.CalculateTarget()->RemoveBreakpointByID(m_break_ids[i]);
+    GetTarget().RemoveBreakpointByID(m_break_ids[i]);
   }
   m_could_not_resolve_hw_bp = false;
 }
 
 void ThreadPlanRunToAddress::GetDescription(Stream *s,
                                             lldb::DescriptionLevel level) {
   size_t num_addresses = m_addresses.size();
 
for (size_t i = 0; i < num_addresses; i++) {
       if (num_addresses > 1) {
         s->Printf("\n");
         s->Indent();
       }
 
       DumpAddress(s->AsRawOstream(), m_addresses[i], sizeof(addr_t));
       s->Printf(" using breakpoint: %d - ", m_break_ids[i]);
       Breakpoint *breakpoint =
-          m_thread.CalculateTarget()->GetBreakpointByID(m_break_ids[i]).get();
+          GetTarget().GetBreakpointByID(m_break_ids[i]).get();
       if (breakpoint)
         breakpoint->Dump(s);
       else
         s->Printf("but the breakpoint has been deleted.");
     }
   }
 }
 
bool ThreadPlanRunToAddress::MischiefManaged() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (AtOurAddress()) {
     // Remove the breakpoint
     size_t num_break_ids = m_break_ids.size();
 
     for (size_t i = 0; i < num_break_ids; i++) {
       if (m_break_ids[i] != LLDB_INVALID_BREAK_ID) {
-        m_thread.CalculateTarget()->RemoveBreakpointByID(m_break_ids[i]);
+        GetTarget().RemoveBreakpointByID(m_break_ids[i]);
         m_break_ids[i] = LLDB_INVALID_BREAK_ID;
       }
     }
     LLDB_LOGF(log, "Completed run to address plan.");
     ThreadPlan::MischiefManaged();
     return true;
   } else
     return false;
 }
 
 bool ThreadPlanRunToAddress::AtOurAddress() {
-  lldb::addr_t current_address = m_thread.GetRegisterContext()->GetPC();
+  lldb::addr_t current_address = GetThread().GetRegisterContext()->GetPC();
   bool found_it = false;
   size_t num_addresses = m_addresses.size();
   for (size_t i = 0; i < num_addresses; i++) {
     if (m_addresses[i] == current_address) {
       found_it = true;
       break;
     }
   }
   return found_it;
 }

lldb/source/Target/ThreadPlanStepInRange.cpp

 }
 
 ThreadPlanStepInRange::~ThreadPlanStepInRange() = default;
 
 void ThreadPlanStepInRange::SetupAvoidNoDebug(
     LazyBool step_in_avoids_code_without_debug_info,
     LazyBool step_out_avoids_code_without_debug_info) {
   bool avoid_nodebug = true;
-
+  Thread &thread = GetThread();
   switch (step_in_avoids_code_without_debug_info) {
   case eLazyBoolYes:
     avoid_nodebug = true;
     break;
   case eLazyBoolNo:
     avoid_nodebug = false;
     break;
   case eLazyBoolCalculate:
-    avoid_nodebug = m_thread.GetStepInAvoidsNoDebug();
+    avoid_nodebug = thread.GetStepInAvoidsNoDebug();
     break;
   }
   if (avoid_nodebug)
     GetFlags().Set(ThreadPlanShouldStopHere::eStepInAvoidNoDebug);
   else
     GetFlags().Clear(ThreadPlanShouldStopHere::eStepInAvoidNoDebug);
 
   switch (step_out_avoids_code_without_debug_info) {
   case eLazyBoolYes:
     avoid_nodebug = true;
     break;
   case eLazyBoolNo:
     avoid_nodebug = false;
     break;
   case eLazyBoolCalculate:
-    avoid_nodebug = m_thread.GetStepOutAvoidsNoDebug();
+    avoid_nodebug = thread.GetStepOutAvoidsNoDebug();
     break;
   }
   if (avoid_nodebug)
     GetFlags().Set(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
   else
     GetFlags().Clear(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
 }
 
void ThreadPlanStepInRange::GetDescription(Stream *s,
   s->PutChar('.');
 }
 
 bool ThreadPlanStepInRange::ShouldStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (log) {
     StreamString s;
-    DumpAddress(
-        s.AsRawOstream(), m_thread.GetRegisterContext()->GetPC(),
-        m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
+    DumpAddress(s.AsRawOstream(), GetThread().GetRegisterContext()->GetPC(),
+                GetTarget().GetArchitecture().GetAddressByteSize());
     LLDB_LOGF(log, "ThreadPlanStepInRange reached %s.", s.GetData());
   }
 
   if (IsPlanComplete())
     return true;
 
   m_no_more_plans = false;
   if (m_sub_plan_sp && m_sub_plan_sp->IsPlanComplete()) {
if (m_virtual_step) {
     // Stepping through should be done running other threads in general, since
     // we're setting a breakpoint and continuing.  So only stop others if we
     // are explicitly told to do so.
 
     bool stop_others = (m_stop_others == lldb::eOnlyThisThread);
 
     FrameComparison frame_order = CompareCurrentFrameToStartFrame();
 
+    Thread &thread = GetThread();
     if (frame_order == eFrameCompareOlder ||
         frame_order == eFrameCompareSameParent) {
       // If we're in an older frame then we should stop.
       //
       // A caveat to this is if we think the frame is older but we're actually
       // in a trampoline.
       // I'm going to make the assumption that you wouldn't RETURN to a
       // trampoline.  So if we are in a trampoline we think the frame is older
       // because the trampoline confused the backtracer.
-      m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough(
+      m_sub_plan_sp = thread.QueueThreadPlanForStepThrough(
           m_stack_id, false, stop_others, m_status);
       if (!m_sub_plan_sp) {
         // Otherwise check the ShouldStopHere for step out:
         m_sub_plan_sp =
             CheckShouldStopHereAndQueueStepOut(frame_order, m_status);
         if (log) {
           if (m_sub_plan_sp)
             LLDB_LOGF(log,
if (m_virtual_step) {
 
     // If we get to this point, we're not going to use a previously set "next
     // branch" breakpoint, so delete it:
     ClearNextBranchBreakpoint();
 
     // We may have set the plan up above in the FrameIsOlder section:
 
     if (!m_sub_plan_sp)
-      m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough(
+      m_sub_plan_sp = thread.QueueThreadPlanForStepThrough(
           m_stack_id, false, stop_others, m_status);
 
     if (log) {
       if (m_sub_plan_sp)
         LLDB_LOGF(log, "Found a step through plan: %s",
                   m_sub_plan_sp->GetName());
       else
         LLDB_LOGF(log, "No step through plan found.");
     }
 
     // If not, give the "should_stop" callback a chance to push a plan to get
     // us out of here. But only do that if we actually have stepped in.
     if (!m_sub_plan_sp && frame_order == eFrameCompareYounger)
       m_sub_plan_sp = CheckShouldStopHereAndQueueStepOut(frame_order, m_status);
 
     // If we've stepped in and we are going to stop here, check to see if we
     // were asked to run past the prologue, and if so do that.
 
     if (!m_sub_plan_sp && frame_order == eFrameCompareYounger &&
         m_step_past_prologue) {
-      lldb::StackFrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
+      lldb::StackFrameSP curr_frame = thread.GetStackFrameAtIndex(0);
       if (curr_frame) {
         size_t bytes_to_skip = 0;
-        lldb::addr_t curr_addr = m_thread.GetRegisterContext()->GetPC();
+        lldb::addr_t curr_addr = thread.GetRegisterContext()->GetPC();
         Address func_start_address;
 
         SymbolContext sc = curr_frame->GetSymbolContext(eSymbolContextFunction |
                                                         eSymbolContextSymbol);
 
         if (sc.function) {
           func_start_address = sc.function->GetAddressRange().GetBaseAddress();
-          if (curr_addr ==
-              func_start_address.GetLoadAddress(
-                  m_thread.CalculateTarget().get()))
+          if (curr_addr == func_start_address.GetLoadAddress(&GetTarget()))
             bytes_to_skip = sc.function->GetPrologueByteSize();
         } else if (sc.symbol) {
           func_start_address = sc.symbol->GetAddress();
-          if (curr_addr ==
-              func_start_address.GetLoadAddress(
-                  m_thread.CalculateTarget().get()))
+          if (curr_addr == func_start_address.GetLoadAddress(&GetTarget()))
             bytes_to_skip = sc.symbol->GetPrologueByteSize();
         }
 
         if (bytes_to_skip == 0 && sc.symbol) {
-          TargetSP target = m_thread.CalculateTarget();
-          const Architecture *arch = target->GetArchitecturePlugin();
+          const Architecture *arch = GetTarget().GetArchitecturePlugin();
           if (arch) {
             Address curr_sec_addr;
-            target->GetSectionLoadList().ResolveLoadAddress(curr_addr,
+            GetTarget().GetSectionLoadList().ResolveLoadAddress(curr_addr,
                                                                 curr_sec_addr);
             bytes_to_skip = arch->GetBytesToSkip(*sc.symbol, curr_sec_addr);
           }
         }
 
         if (bytes_to_skip != 0) {
           func_start_address.Slide(bytes_to_skip);
           log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP);
           LLDB_LOGF(log, "Pushing past prologue ");
 
-          m_sub_plan_sp = m_thread.QueueThreadPlanForRunToAddress(
+          m_sub_plan_sp = thread.QueueThreadPlanForRunToAddress(
               false, func_start_address, true, m_status);
         }
       }
     }
   }
 
   if (!m_sub_plan_sp) {
     m_no_more_plans = true;
bool ThreadPlanStepInRange::DoPlanExplainsStop(Event *event_ptr) {
 
   return return_value;
 }
 
 bool ThreadPlanStepInRange::DoWillResume(lldb::StateType resume_state,
                                          bool current_plan) {
   m_virtual_step = false;
   if (resume_state == eStateStepping && current_plan) {
+    Thread &thread = GetThread();
     // See if we are about to step over a virtual inlined call.
-    bool step_without_resume = m_thread.DecrementCurrentInlinedDepth();
+    bool step_without_resume = thread.DecrementCurrentInlinedDepth();
     if (step_without_resume) {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
       LLDB_LOGF(log,
                 "ThreadPlanStepInRange::DoWillResume: returning false, "
                 "inline_depth: %d",
-                m_thread.GetCurrentInlinedDepth());
-      SetStopInfo(StopInfo::CreateStopReasonToTrace(m_thread));
+                thread.GetCurrentInlinedDepth());
+      SetStopInfo(StopInfo::CreateStopReasonToTrace(thread));
 
       // FIXME: Maybe it would be better to create a InlineStep stop reason, but
       // then
       // the whole rest of the world would have to handle that stop reason.
       m_virtual_step = true;
     }
     return !step_without_resume;
   }
   return true;
 }
 
 bool ThreadPlanStepInRange::IsVirtualStep() { return m_virtual_step; }

lldb/source/Target/ThreadPlanStepInstruction.cpp

: ThreadPlan(ThreadPlan::eKindStepInstruction,
       m_step_over(step_over) {
   m_takes_iteration_count = true;
   SetUpState();
 }
 
 ThreadPlanStepInstruction::~ThreadPlanStepInstruction() = default;
 
 void ThreadPlanStepInstruction::SetUpState() {
-  m_instruction_addr = m_thread.GetRegisterContext()->GetPC(0);
-  StackFrameSP start_frame_sp(m_thread.GetStackFrameAtIndex(0));
+  Thread &thread = GetThread();
+  m_instruction_addr = thread.GetRegisterContext()->GetPC(0);
+  StackFrameSP start_frame_sp(thread.GetStackFrameAtIndex(0));
   m_stack_id = start_frame_sp->GetStackID();
 
   m_start_has_symbol =
       start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != nullptr;
 
-  StackFrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1);
+  StackFrameSP parent_frame_sp = thread.GetStackFrameAtIndex(1);
   if (parent_frame_sp)
     m_parent_frame_id = parent_frame_sp->GetStackID();
 }
 
 void ThreadPlanStepInstruction::GetDescription(Stream *s,
                                                lldb::DescriptionLevel level) {
   auto PrintFailureIfAny = [&]() {
     if (m_status.Success())
if (stop_info_sp) {
     StopReason reason = stop_info_sp->GetStopReason();
     return (reason == eStopReasonTrace || reason == eStopReasonNone);
   }
   return false;
 }
 
 bool ThreadPlanStepInstruction::IsPlanStale() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
-  StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
+  Thread &thread = GetThread();
+  StackID cur_frame_id = thread.GetStackFrameAtIndex(0)->GetStackID();
   if (cur_frame_id == m_stack_id) {
     // Set plan Complete when we reach next instruction
-    uint64_t pc = m_thread.GetRegisterContext()->GetPC(0);
-    uint32_t max_opcode_size = m_thread.CalculateTarget()
-        ->GetArchitecture().GetMaximumOpcodeByteSize();
+    uint64_t pc = thread.GetRegisterContext()->GetPC(0);
+    uint32_t max_opcode_size =
+        GetTarget().GetArchitecture().GetMaximumOpcodeByteSize();
     bool next_instruction_reached = (pc > m_instruction_addr) &&
         (pc <= m_instruction_addr + max_opcode_size);
     if (next_instruction_reached) {
       SetPlanComplete();
     }
-    return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
+    return (thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
   } else if (cur_frame_id < m_stack_id) {
     // If the current frame is younger than the start frame and we are stepping
     // over, then we need to continue, but if we are doing just one step, we're
     // done.
     return !m_step_over;
   } else {
     if (log) {
       LLDB_LOGF(log,
                 "ThreadPlanStepInstruction::IsPlanStale - Current frame is "
                 "older than start frame, plan is stale.");
     }
     return true;
   }
 }
 
 bool ThreadPlanStepInstruction::ShouldStop(Event *event_ptr) {
+  Thread &thread = GetThread();
   if (m_step_over) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
-
-    StackFrameSP cur_frame_sp = m_thread.GetStackFrameAtIndex(0);
+    StackFrameSP cur_frame_sp = thread.GetStackFrameAtIndex(0);
     if (!cur_frame_sp) {
       LLDB_LOGF(
           log,
           "ThreadPlanStepInstruction couldn't get the 0th frame, stopping.");
       SetPlanComplete();
       return true;
     }
 
     StackID cur_frame_zero_id = cur_frame_sp->GetStackID();
 
     if (cur_frame_zero_id == m_stack_id || m_stack_id < cur_frame_zero_id) {
-      if (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr) {
+      if (thread.GetRegisterContext()->GetPC(0) != m_instruction_addr) {
         if (--m_iteration_count <= 0) {
           SetPlanComplete();
           return true;
         } else {
           // We are still stepping, reset the start pc, and in case we've
           // stepped out, reset the current stack id.
           SetUpState();
           return false;
         }
       } else
         return false;
     } else {
       // We've stepped in, step back out again:
-      StackFrame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
+      StackFrame *return_frame = thread.GetStackFrameAtIndex(1).get();
       if (return_frame) {
         if (return_frame->GetStackID() != m_parent_frame_id ||
             m_start_has_symbol) {
           // next-instruction shouldn't step out of inlined functions.  But we
           // may have stepped into a real function that starts with an inlined
           // function, and we do want to step out of that...
 
           if (cur_frame_sp->IsInlined()) {
             StackFrameSP parent_frame_sp =
-                m_thread.GetFrameWithStackID(m_stack_id);
+                thread.GetFrameWithStackID(m_stack_id);
 
             if (parent_frame_sp &&
                 parent_frame_sp->GetConcreteFrameIndex() ==
                     cur_frame_sp->GetConcreteFrameIndex()) {
               SetPlanComplete();
               if (log) {
                 LLDB_LOGF(log,
                           "Frame we stepped into is inlined into the frame "
                           "we were stepping from, stopping.");
               }
               return true;
             }
           }
 
           if (log) {
             StreamString s;
             s.PutCString("Stepped in to: ");
             addr_t stop_addr =
-                m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
+                thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
             DumpAddress(s.AsRawOstream(), stop_addr,
-                        m_thread.CalculateTarget()
-                            ->GetArchitecture()
-                            .GetAddressByteSize());
+                        GetTarget().GetArchitecture().GetAddressByteSize());
             s.PutCString(" stepping out to: ");
             addr_t return_addr = return_frame->GetRegisterContext()->GetPC();
             DumpAddress(s.AsRawOstream(), return_addr,
-                        m_thread.CalculateTarget()
-                            ->GetArchitecture()
-                            .GetAddressByteSize());
+                        GetTarget().GetArchitecture().GetAddressByteSize());
             LLDB_LOGF(log, "%s.", s.GetData());
           }
 
           // StepInstruction should probably have the tri-state RunMode, but
           // for now it is safer to run others.
           const bool stop_others = false;
-          m_thread.QueueThreadPlanForStepOutNoShouldStop(
+          thread.QueueThreadPlanForStepOutNoShouldStop(
               false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,
               m_status);
           return false;
         } else {
           if (log) {
             log->PutCString(
                 "The stack id we are stepping in changed, but our parent frame "
                 "did not when stepping from code with no symbols.  "
                 "We are probably just confused about where we are, stopping.");
           }
           SetPlanComplete();
           return true;
         }
       } else {
         LLDB_LOGF(log, "Could not find previous frame, stopping.");
         SetPlanComplete();
         return true;
       }
     }
   } else {
-    lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC(0);
+    lldb::addr_t pc_addr = thread.GetRegisterContext()->GetPC(0);
     if (pc_addr != m_instruction_addr) {
       if (--m_iteration_count <= 0) {
         SetPlanComplete();
         return true;
       } else {
         // We are still stepping, reset the start pc, and in case we've stepped
         // in or out, reset the current stack id.
         SetUpState();

lldb/source/Target/ThreadPlanStepOut.cpp

: ThreadPlan(ThreadPlan::eKindStepOut, "Step out", thread, stop_vote,
       m_return_bp_id(LLDB_INVALID_BREAK_ID),
       m_return_addr(LLDB_INVALID_ADDRESS), m_stop_others(stop_others),
       m_immediate_step_from_function(nullptr),
       m_calculate_return_value(gather_return_value) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   SetFlagsToDefault();
   SetupAvoidNoDebug(step_out_avoids_code_without_debug_info);
 
-  m_step_from_insn = m_thread.GetRegisterContext()->GetPC(0);
+  m_step_from_insn = thread.GetRegisterContext()->GetPC(0);
 
   uint32_t return_frame_index = frame_idx + 1;
-  StackFrameSP return_frame_sp(
-      m_thread.GetStackFrameAtIndex(return_frame_index));
-  StackFrameSP immediate_return_from_sp(
-      m_thread.GetStackFrameAtIndex(frame_idx));
+  StackFrameSP return_frame_sp(thread.GetStackFrameAtIndex(return_frame_index));
+  StackFrameSP immediate_return_from_sp(thread.GetStackFrameAtIndex(frame_idx));
 
   if (!return_frame_sp || !immediate_return_from_sp)
     return; // we can't do anything here.  ValidatePlan() will return false.
 
   // While stepping out, behave as-if artificial frames are not present.
   while (return_frame_sp->IsArtificial()) {
     m_stepped_past_frames.push_back(return_frame_sp);
 
     ++return_frame_index;
-    return_frame_sp = m_thread.GetStackFrameAtIndex(return_frame_index);
+    return_frame_sp = thread.GetStackFrameAtIndex(return_frame_index);
 
     // We never expect to see an artificial frame without a regular ancestor.
     // If this happens, log the issue and defensively refuse to step out.
     if (!return_frame_sp) {
       LLDB_LOG(log, "Can't step out of frame with artificial ancestors");
       return;
     }
   }
 
   m_step_out_to_id = return_frame_sp->GetStackID();
   m_immediate_step_from_id = immediate_return_from_sp->GetStackID();
 
   // If the frame directly below the one we are returning to is inlined, we
   // have to be a little more careful.  It is non-trivial to determine the real
   // "return code address" for an inlined frame, so we have to work our way to
   // that frame and then step out.
   if (immediate_return_from_sp->IsInlined()) {
     if (frame_idx > 0) {
       // First queue a plan that gets us to this inlined frame, and when we get
       // there we'll queue a second plan that walks us out of this frame.
       m_step_out_to_inline_plan_sp = std::make_shared<ThreadPlanStepOut>(
-          m_thread, nullptr, false, stop_others, eVoteNoOpinion, eVoteNoOpinion,
+          thread, nullptr, false, stop_others, eVoteNoOpinion, eVoteNoOpinion,
           frame_idx - 1, eLazyBoolNo, continue_to_next_branch);
       static_cast<ThreadPlanStepOut *>(m_step_out_to_inline_plan_sp.get())
           ->SetShouldStopHereCallbacks(nullptr, nullptr);
       m_step_out_to_inline_plan_sp->SetPrivate(true);
     } else {
       // If we're already at the inlined frame we're stepping through, then
       // just do that now.
       QueueInlinedStepPlan(false);
if (continue_to_next_branch) {
 
       return_address_decr_pc.CalculateSymbolContext(
           &return_address_sc, lldb::eSymbolContextLineEntry);
       if (return_address_sc.line_entry.IsValid()) {
         const bool include_inlined_functions = false;
         range = return_address_sc.line_entry.GetSameLineContiguousAddressRange(
             include_inlined_functions);
         if (range.GetByteSize() > 0) {
-          return_address =
-              m_thread.GetProcess()->AdvanceAddressToNextBranchInstruction(
-                  return_address, range);
+          return_address = m_process.AdvanceAddressToNextBranchInstruction(
         }
       }
     }
-    m_return_addr =
-        return_address.GetLoadAddress(&m_thread.GetProcess()->GetTarget());
+    m_return_addr = return_address.GetLoadAddress(&m_process.GetTarget());
 
     if (m_return_addr == LLDB_INVALID_ADDRESS)
       return;
 
     // Perform some additional validation on the return address.
     uint32_t permissions = 0;
-    if (!m_thread.GetProcess()->GetLoadAddressPermissions(m_return_addr,
-                                                          permissions)) {
+    if (!m_process.GetLoadAddressPermissions(m_return_addr, permissions)) {
       LLDB_LOGF(log, "ThreadPlanStepOut(%p): Return address (0x%" PRIx64
                 ") permissions not found.", static_cast<void *>(this),
                 m_return_addr);
     } else if (!(permissions & ePermissionsExecutable)) {
       m_constructor_errors.Printf("Return address (0x%" PRIx64
                                   ") did not point to executable memory.",
                                   m_return_addr);
       LLDB_LOGF(log, "ThreadPlanStepOut(%p): %s", static_cast<void *>(this),
                 m_constructor_errors.GetData());
       return;
     }
 
-    Breakpoint *return_bp = m_thread.CalculateTarget()
-                                ->CreateBreakpoint(m_return_addr, true, false)
-                                .get();
+    Breakpoint *return_bp = 
+        GetTarget().CreateBreakpoint(m_return_addr, true, false).get();
 
     if (return_bp != nullptr) {
       if (return_bp->IsHardware() && !return_bp->HasResolvedLocations())
         m_could_not_resolve_hw_bp = true;
-      return_bp->SetThreadID(m_thread.GetID());
+      return_bp->SetThreadID(m_tid);
       m_return_bp_id = return_bp->GetID();
       return_bp->SetBreakpointKind("step-out");
     }
 
     if (immediate_return_from_sp) {
       const SymbolContext &sc =
           immediate_return_from_sp->GetSymbolContext(eSymbolContextFunction);
       if (sc.function) {
void ThreadPlanStepOut::SetupAvoidNoDebug(
   switch (step_out_avoids_code_without_debug_info) {
   case eLazyBoolYes:
     avoid_nodebug = true;
     break;
   case eLazyBoolNo:
     avoid_nodebug = false;
     break;
   case eLazyBoolCalculate:
-    avoid_nodebug = m_thread.GetStepOutAvoidsNoDebug();
+    avoid_nodebug = GetThread().GetStepOutAvoidsNoDebug();
     break;
   }
   if (avoid_nodebug)
     GetFlags().Set(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
   else
     GetFlags().Clear(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
 }
 
 void ThreadPlanStepOut::DidPush() {
+  Thread &thread = GetThread();
   if (m_step_out_to_inline_plan_sp)
-    m_thread.QueueThreadPlan(m_step_out_to_inline_plan_sp, false);
+    thread.QueueThreadPlan(m_step_out_to_inline_plan_sp, false);
   else if (m_step_through_inline_plan_sp)
-    m_thread.QueueThreadPlan(m_step_through_inline_plan_sp, false);
+    thread.QueueThreadPlan(m_step_through_inline_plan_sp, false);
 }
 
 ThreadPlanStepOut::~ThreadPlanStepOut() {
   if (m_return_bp_id != LLDB_INVALID_BREAK_ID)
-    m_thread.CalculateTarget()->RemoveBreakpointByID(m_return_bp_id);
+    GetThread().CalculateTarget()->RemoveBreakpointByID(m_return_bp_id);
 }
 
 void ThreadPlanStepOut::GetDescription(Stream *s,
                                        lldb::DescriptionLevel level) {
   if (level == lldb::eDescriptionLevelBrief)
     s->Printf("step out");
   else {
     if (m_step_out_to_inline_plan_sp)
bool ThreadPlanStepOut::DoPlanExplainsStop(Event *event_ptr) {
 
   StopInfoSP stop_info_sp = GetPrivateStopInfo();
   if (stop_info_sp) {
     StopReason reason = stop_info_sp->GetStopReason();
     if (reason == eStopReasonBreakpoint) {
       // If this is OUR breakpoint, we're fine, otherwise we don't know why
       // this happened...
       BreakpointSiteSP site_sp(
-          m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
-              stop_info_sp->GetValue()));
+          m_process.GetBreakpointSiteList().FindByID(stop_info_sp->GetValue()));
       if (site_sp && site_sp->IsBreakpointAtThisSite(m_return_bp_id)) {
         bool done;
 
-        StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
+        StackID frame_zero_id =
+            GetThread().GetStackFrameAtIndex(0)->GetStackID();
 
         if (m_step_out_to_id == frame_zero_id)
           done = true;
         else if (m_step_out_to_id < frame_zero_id) {
           // Either we stepped past the breakpoint, or the stack ID calculation
           // was incorrect and we should probably stop.
           done = true;
         } else {
bool ThreadPlanStepOut::ShouldStop(Event *event_ptr) {
   } else if (m_step_out_further_plan_sp) {
     if (m_step_out_further_plan_sp->MischiefManaged())
       m_step_out_further_plan_sp.reset();
     else
       return m_step_out_further_plan_sp->ShouldStop(event_ptr);
   }
 
   if (!done) {
-    StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
+    StackID frame_zero_id = GetThread().GetStackFrameAtIndex(0)->GetStackID();
     done = !(frame_zero_id < m_step_out_to_id);
   }
 
   // The normal step out computations think we are done, so all we need to do
   // is consult the ShouldStopHere, and we are done.
 
   if (done) {
     if (InvokeShouldStopHereCallback(eFrameCompareOlder, m_status)) {
bool ThreadPlanStepOut::DoWillResume(StateType resume_state,
                                      bool current_plan) {
   if (m_step_out_to_inline_plan_sp || m_step_through_inline_plan_sp)
     return true;
 
   if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
     return false;
 
   if (current_plan) {
-    Breakpoint *return_bp =
-        m_thread.CalculateTarget()->GetBreakpointByID(m_return_bp_id).get();
+    Breakpoint *return_bp = GetTarget().GetBreakpointByID(m_return_bp_id).get();
     if (return_bp != nullptr)
       return_bp->SetEnabled(true);
   }
   return true;
 }
 
 bool ThreadPlanStepOut::WillStop() {
   if (m_return_bp_id != LLDB_INVALID_BREAK_ID) {
-    Breakpoint *return_bp =
-        m_thread.CalculateTarget()->GetBreakpointByID(m_return_bp_id).get();
+    Breakpoint *return_bp = GetTarget().GetBreakpointByID(m_return_bp_id).get();
     if (return_bp != nullptr)
       return_bp->SetEnabled(false);
   }
 
   return true;
 }
 
 bool ThreadPlanStepOut::MischiefManaged() {
   if (IsPlanComplete()) {
     // Did I reach my breakpoint?  If so I'm done.
     //
     // I also check the stack depth, since if we've blown past the breakpoint
     // for some
     // reason and we're now stopping for some other reason altogether, then
     // we're done with this step out operation.
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     if (log)
       LLDB_LOGF(log, "Completed step out plan.");
     if (m_return_bp_id != LLDB_INVALID_BREAK_ID) {
-      m_thread.CalculateTarget()->RemoveBreakpointByID(m_return_bp_id);
+      GetTarget().RemoveBreakpointByID(m_return_bp_id);
       m_return_bp_id = LLDB_INVALID_BREAK_ID;
     }
 
     ThreadPlan::MischiefManaged();
     return true;
   } else {
     return false;
   }
 }
 
 bool ThreadPlanStepOut::QueueInlinedStepPlan(bool queue_now) {
   // Now figure out the range of this inlined block, and set up a "step through
   // range" plan for that.  If we've been provided with a context, then use the
   // block in that context.
-  StackFrameSP immediate_return_from_sp(m_thread.GetStackFrameAtIndex(0));
+  Thread &thread = GetThread();
+  StackFrameSP immediate_return_from_sp(thread.GetStackFrameAtIndex(0));
   if (!immediate_return_from_sp)
     return false;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   if (log) {
     StreamString s;
     immediate_return_from_sp->Dump(&s, true, false);
     LLDB_LOGF(log, "Queuing inlined frame to step past: %s.", s.GetData());
if (inlined_block) {
         inlined_block->CalculateSymbolContext(&inlined_sc);
         inlined_sc.target_sp = GetTarget().shared_from_this();
         RunMode run_mode =
             m_stop_others ? lldb::eOnlyThisThread : lldb::eAllThreads;
         const LazyBool avoid_no_debug = eLazyBoolNo;
 
         m_step_through_inline_plan_sp =
             std::make_shared<ThreadPlanStepOverRange>(
-                m_thread, inline_range, inlined_sc, run_mode, avoid_no_debug);
+                thread, inline_range, inlined_sc, run_mode, avoid_no_debug);
         ThreadPlanStepOverRange *step_through_inline_plan_ptr =
             static_cast<ThreadPlanStepOverRange *>(
                 m_step_through_inline_plan_sp.get());
         m_step_through_inline_plan_sp->SetPrivate(true);
 
         step_through_inline_plan_ptr->SetOkayToDiscard(true);
         StreamString errors;
         if (!step_through_inline_plan_ptr->ValidatePlan(&errors)) {
           // FIXME: Log this failure.
           delete step_through_inline_plan_ptr;
           return false;
         }
 
         for (size_t i = 1; i < num_ranges; i++) {
           if (inlined_block->GetRangeAtIndex(i, inline_range))
             step_through_inline_plan_ptr->AddRange(inline_range);
         }
 
         if (queue_now)
-          m_thread.QueueThreadPlan(m_step_through_inline_plan_sp, false);
+          thread.QueueThreadPlan(m_step_through_inline_plan_sp, false);
         return true;
       }
     }
   }
 
   return false;
 }
 
 void ThreadPlanStepOut::CalculateReturnValue() {
   if (m_return_valobj_sp)
     return;
 
   if (!m_calculate_return_value)
     return;
 
   if (m_immediate_step_from_function != nullptr) {
     CompilerType return_compiler_type =
         m_immediate_step_from_function->GetCompilerType()
             .GetFunctionReturnType();
     if (return_compiler_type) {
-      lldb::ABISP abi_sp = m_thread.GetProcess()->GetABI();
+      lldb::ABISP abi_sp = m_process.GetABI();
       if (abi_sp)
         m_return_valobj_sp =
-            abi_sp->GetReturnValueObject(m_thread, return_compiler_type);
+            abi_sp->GetReturnValueObject(GetThread(), return_compiler_type);
     }
   }
 }
 
 bool ThreadPlanStepOut::IsPlanStale() {
   // If we are still lower on the stack than the frame we are returning to,
   // then there's something for us to do.  Otherwise, we're stale.
 
-  StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
+  StackID frame_zero_id = GetThread().GetStackFrameAtIndex(0)->GetStackID();
   return !(frame_zero_id < m_step_out_to_id);
 }

lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp

: ThreadPlan(
           thread, eVoteNo,
           eVoteNoOpinion), // We need to report the run since this happens
                            // first in the thread plan stack when stepping over
                            // a breakpoint
       m_breakpoint_addr(LLDB_INVALID_ADDRESS),
       m_auto_continue(false), m_reenabled_breakpoint_site(false)
 
 {
-  m_breakpoint_addr = m_thread.GetRegisterContext()->GetPC();
+  m_breakpoint_addr = thread.GetRegisterContext()->GetPC();
   m_breakpoint_site_id =
-      m_thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
+      thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
           m_breakpoint_addr);
 }
 
 ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() {}
 
 void ThreadPlanStepOverBreakpoint::GetDescription(
     Stream *s, lldb::DescriptionLevel level) {
   s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64,
switch (reason) {
         // So our trace step COULD appear as a breakpoint hit if the next 
         // instruction also contained a breakpoint.  We don't want to handle 
         // that, since we really don't know what to do with breakpoint hits.  
         // But make sure we don't set ourselves to auto-continue or we'll wrench
         // control away from the plans that can deal with this.
         // Be careful, however, as we may have "seen a breakpoint under the PC
         // because we stopped without changing the PC, in which case we do want
         // to re-claim this stop so we'll try again.
-        lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
+        lldb::addr_t pc_addr = GetThread().GetRegisterContext()->GetPC();
 
         if (pc_addr == m_breakpoint_addr) {
           LLDB_LOGF(log,
                     "Got breakpoint stop reason but pc: 0x%" PRIx64
                     "hasn't changed.",
                     pc_addr);
           return true;
         }

 StateType ThreadPlanStepOverBreakpoint::GetPlanRunState() {
   return eStateStepping;
 }
 
 bool ThreadPlanStepOverBreakpoint::DoWillResume(StateType resume_state,
                                                 bool current_plan) {
   if (current_plan) {
     BreakpointSiteSP bp_site_sp(
-        m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
-            m_breakpoint_addr));
+        m_process.GetBreakpointSiteList().FindByAddress(m_breakpoint_addr));
     if (bp_site_sp && bp_site_sp->IsEnabled()) {
-      m_thread.GetProcess()->DisableBreakpointSite(bp_site_sp.get());
+      m_process.DisableBreakpointSite(bp_site_sp.get());
       m_reenabled_breakpoint_site = false;
     }
   }
   return true;
 }
 
 bool ThreadPlanStepOverBreakpoint::WillStop() {
   ReenableBreakpointSite();
   return true;
 }
 
 void ThreadPlanStepOverBreakpoint::WillPop() {
   ReenableBreakpointSite();
 }
 
 bool ThreadPlanStepOverBreakpoint::MischiefManaged() {
-  lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
+  lldb::addr_t pc_addr = GetThread().GetRegisterContext()->GetPC();
 
   if (pc_addr == m_breakpoint_addr) {
     // If we are still at the PC of our breakpoint, then for some reason we
     // didn't get a chance to run.
     return false;
   } else {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     LLDB_LOGF(log, "Completed step over breakpoint plan.");
     // Otherwise, re-enable the breakpoint we were stepping over, and we're
     // done.
     ReenableBreakpointSite();
     ThreadPlan::MischiefManaged();
     return true;
   }
 }
 
 void ThreadPlanStepOverBreakpoint::ReenableBreakpointSite() {
   if (!m_reenabled_breakpoint_site) {
     m_reenabled_breakpoint_site = true;
     BreakpointSiteSP bp_site_sp(
-        m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
-            m_breakpoint_addr));
+        m_process.GetBreakpointSiteList().FindByAddress(m_breakpoint_addr));
     if (bp_site_sp) {
-      m_thread.GetProcess()->EnableBreakpointSite(bp_site_sp.get());
+      m_process.EnableBreakpointSite(bp_site_sp.get());
     }
   }
 }
 void ThreadPlanStepOverBreakpoint::ThreadDestroyed() {
   ReenableBreakpointSite();
 }
 
 void ThreadPlanStepOverBreakpoint::SetAutoContinue(bool do_it) {
   m_auto_continue = do_it;
 }
 
 bool ThreadPlanStepOverBreakpoint::ShouldAutoContinue(Event *event_ptr) {
   return m_auto_continue;
 }
 
 bool ThreadPlanStepOverBreakpoint::IsPlanStale() {
-  return m_thread.GetRegisterContext()->GetPC() != m_breakpoint_addr;
+  return GetThread().GetRegisterContext()->GetPC() != m_breakpoint_addr;
 }

lldb/source/Target/ThreadPlanStepOverRange.cpp

void ThreadPlanStepOverRange::SetupAvoidNoDebug(
   switch (step_out_avoids_code_without_debug_info) {
   case eLazyBoolYes:
     avoid_nodebug = true;
     break;
   case eLazyBoolNo:
     avoid_nodebug = false;
     break;
   case eLazyBoolCalculate:
-    avoid_nodebug = m_thread.GetStepOutAvoidsNoDebug();
+    avoid_nodebug = GetThread().GetStepOutAvoidsNoDebug();
     break;
   }
   if (avoid_nodebug)
     GetFlags().Set(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
   else
     GetFlags().Clear(ThreadPlanShouldStopHere::eStepOutAvoidNoDebug);
   // Step Over plans should always avoid no-debug on step in.  Seems like you
   // shouldn't have to say this, but a tail call looks more like a step in that
if (m_addr_context.comp_unit) {
     }
   }
   // Fall back to symbol if we have no decision from comp_unit/function/block.
   return m_addr_context.symbol && m_addr_context.symbol == context.symbol;
 }
 
 bool ThreadPlanStepOverRange::ShouldStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
+  Thread &thread = GetThread();
 
   if (log) {
     StreamString s;
-    DumpAddress(
-        s.AsRawOstream(), m_thread.GetRegisterContext()->GetPC(),
-        m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
+    DumpAddress(s.AsRawOstream(), thread.GetRegisterContext()->GetPC(),
+                GetTarget().GetArchitecture().GetAddressByteSize());
     LLDB_LOGF(log, "ThreadPlanStepOverRange reached %s.", s.GetData());
   }
 
   // If we're out of the range but in the same frame or in our caller's frame
   // then we should stop. When stepping out we only stop others if we are
   // forcing running one thread.
   bool stop_others = (m_stop_others == lldb::eOnlyThisThread);
   ThreadPlanSP new_plan_sp;
   FrameComparison frame_order = CompareCurrentFrameToStartFrame();
 
   if (frame_order == eFrameCompareOlder) {
     // If we're in an older frame then we should stop.
     //
     // A caveat to this is if we think the frame is older but we're actually in
     // a trampoline.
     // I'm going to make the assumption that you wouldn't RETURN to a
     // trampoline.  So if we are in a trampoline we think the frame is older
     // because the trampoline confused the backtracer. As below, we step
     // through first, and then try to figure out how to get back out again.
 
-    new_plan_sp = m_thread.QueueThreadPlanForStepThrough(m_stack_id, false,
-                                                         stop_others, m_status);
+    new_plan_sp = thread.QueueThreadPlanForStepThrough(m_stack_id, false,
 
     if (new_plan_sp && log)
       LLDB_LOGF(log,
                 "Thought I stepped out, but in fact arrived at a trampoline.");
   } else if (frame_order == eFrameCompareYounger) {
     // Make sure we really are in a new frame.  Do that by unwinding and seeing
     // if the start function really is our start function...
     for (uint32_t i = 1;; ++i) {
-      StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(i);
+      StackFrameSP older_frame_sp = thread.GetStackFrameAtIndex(i);
       if (!older_frame_sp) {
         // We can't unwind the next frame we should just get out of here &
         // stop...
         break;
       }
 
       const SymbolContext &older_context =
           older_frame_sp->GetSymbolContext(eSymbolContextEverything);
       if (IsEquivalentContext(older_context)) {
         // If we have the  next-branch-breakpoint in the range, we can just
         // rely on that breakpoint to trigger once we return to the range.
         if (m_next_branch_bp_sp)
           return false;
-        new_plan_sp = m_thread.QueueThreadPlanForStepOutNoShouldStop(
+        new_plan_sp = thread.QueueThreadPlanForStepOutNoShouldStop(
             false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,
             m_status, true);
         break;
       } else {
-        new_plan_sp = m_thread.QueueThreadPlanForStepThrough(
+        new_plan_sp = thread.QueueThreadPlanForStepThrough(
             m_stack_id, false, stop_others, m_status);
         // If we found a way through, then we should stop recursing.
         if (new_plan_sp)
           break;
       }
     }
   } else {
     // If we're still in the range, keep going.
     if (InRange()) {
       SetNextBranchBreakpoint();
       return false;
     }
 
     if (!InSymbol()) {
       // This one is a little tricky.  Sometimes we may be in a stub or
       // something similar, in which case we need to get out of there.  But if
       // we are in a stub then it's likely going to be hard to get out from
       // here.  It is probably easiest to step into the stub, and then it will
       // be straight-forward to step out.
-      new_plan_sp = m_thread.QueueThreadPlanForStepThrough(
-          m_stack_id, false, stop_others, m_status);
+      new_plan_sp = thread.QueueThreadPlanForStepThrough(m_stack_id, false, 
+                                                         stop_others, m_status);
     } else {
       // The current clang (at least through 424) doesn't always get the
       // address range for the DW_TAG_inlined_subroutines right, so that when
       // you leave the inlined range the line table says you are still in the
       // source file of the inlining function.  This is bad, because now you
       // are missing the stack frame for the function containing the inlining,
       // and if you sensibly do "finish" to get out of this function you will
       // instead exit the containing function. To work around this, we check
       // whether we are still in the source file we started in, and if not
       // assume it is an error, and push a plan to get us out of this line and
       // back to the containing file.
 
       if (m_addr_context.line_entry.IsValid()) {
         SymbolContext sc;
-        StackFrameSP frame_sp = m_thread.GetStackFrameAtIndex(0);
+        StackFrameSP frame_sp = thread.GetStackFrameAtIndex(0);
         sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
         if (sc.line_entry.IsValid()) {
           if (sc.line_entry.original_file !=
                   m_addr_context.line_entry.original_file &&
               sc.comp_unit == m_addr_context.comp_unit &&
               sc.function == m_addr_context.function) {
             // Okay, find the next occurrence of this file in the line table:
             LineTable *line_table = m_addr_context.comp_unit->GetLineTable();
if (!InSymbol()) {
                         next_line_address.CalculateSymbolContextFunction();
                     if (next_line_function != m_addr_context.function)
                       break;
 
                     if (next_line_entry.original_file ==
                         m_addr_context.line_entry.original_file) {
                       const bool abort_other_plans = false;
                       const RunMode stop_other_threads = RunMode::eAllThreads;
-                      lldb::addr_t cur_pc = m_thread.GetStackFrameAtIndex(0)
+                      lldb::addr_t cur_pc = thread.GetStackFrameAtIndex(0)
                                                 ->GetRegisterContext()
                                                 ->GetPC();
                       AddressRange step_range(
                           cur_pc,
                           next_line_address.GetLoadAddress(&GetTarget()) -
                               cur_pc);
 
-                      new_plan_sp = m_thread.QueueThreadPlanForStepOverRange(
+                      new_plan_sp = thread.QueueThreadPlanForStepOverRange(
                           abort_other_plans, step_range, sc, stop_other_threads,
                           m_status);
                       break;
                     }
                     look_ahead_step++;
                   }
                 }
               }
bool ThreadPlanStepOverRange::DoPlanExplainsStop(Event *event_ptr) {
   return return_value;
 }
 
 bool ThreadPlanStepOverRange::DoWillResume(lldb::StateType resume_state,
                                            bool current_plan) {
   if (resume_state != eStateSuspended && m_first_resume) {
     m_first_resume = false;
     if (resume_state == eStateStepping && current_plan) {
+      Thread &thread = GetThread();
       // See if we are about to step over an inlined call in the middle of the
       // inlined stack, if so figure out its extents and reset our range to
       // step over that.
-      bool in_inlined_stack = m_thread.DecrementCurrentInlinedDepth();
+      bool in_inlined_stack = thread.DecrementCurrentInlinedDepth();
       if (in_inlined_stack) {
         Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
         LLDB_LOGF(log,
                   "ThreadPlanStepInRange::DoWillResume: adjusting range to "
                   "the frame at inlined depth %d.",
-                  m_thread.GetCurrentInlinedDepth());
-        StackFrameSP stack_sp = m_thread.GetStackFrameAtIndex(0);
+                  thread.GetCurrentInlinedDepth());
+        StackFrameSP stack_sp = thread.GetStackFrameAtIndex(0);
         if (stack_sp) {
           Block *frame_block = stack_sp->GetFrameBlock();
-          lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC();
+          lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
           AddressRange my_range;
           if (frame_block->GetRangeContainingLoadAddress(
-                  curr_pc, m_thread.GetProcess()->GetTarget(), my_range)) {
+                  curr_pc, m_process.GetTarget(), my_range)) {
             m_address_ranges.clear();
             m_address_ranges.push_back(my_range);
             if (log) {
               StreamString s;
               const InlineFunctionInfo *inline_info =
                   frame_block->GetInlinedFunctionInfo();
               const char *name;
               if (inline_info)

lldb/source/Target/ThreadPlanStepRange.cpp

ThreadPlanStepRange::ThreadPlanStepRange(ThreadPlanKind kind, const char *name,
                                          bool given_ranges_only)
     : ThreadPlan(kind, name, thread, eVoteNoOpinion, eVoteNoOpinion),
       m_addr_context(addr_context), m_address_ranges(),
       m_stop_others(stop_others), m_stack_id(), m_parent_stack_id(),
       m_no_more_plans(false), m_first_run_event(true), m_use_fast_step(false),
       m_given_ranges_only(given_ranges_only) {
   m_use_fast_step = GetTarget().GetUseFastStepping();
   AddRange(range);
-  m_stack_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
-  StackFrameSP parent_stack = m_thread.GetStackFrameAtIndex(1);
+  m_stack_id = thread.GetStackFrameAtIndex(0)->GetStackID();
+  StackFrameSP parent_stack = thread.GetStackFrameAtIndex(1);
   if (parent_stack)
     m_parent_stack_id = parent_stack->GetStackID();
 }
 
 ThreadPlanStepRange::~ThreadPlanStepRange() { ClearNextBranchBreakpoint(); }
 
 void ThreadPlanStepRange::DidPush() {
   // See if we can find a "next range" breakpoint:
void ThreadPlanStepRange::AddRange(const AddressRange &new_range) {
 
   // Fill the slot for this address range with an empty DisassemblerSP in the
   // instruction ranges. I want the indices to match, but I don't want to do
   // the work to disassemble this range if I don't step into it.
   m_instruction_ranges.push_back(DisassemblerSP());
 }
 
 void ThreadPlanStepRange::DumpRanges(Stream *s) {
+  Thread &thread = GetThread();
   size_t num_ranges = m_address_ranges.size();
   if (num_ranges == 1) {
-    m_address_ranges[0].Dump(s, m_thread.CalculateTarget().get(),
-                             Address::DumpStyleLoadAddress);
+    m_address_ranges[0].Dump(s, &GetTarget(), Address::DumpStyleLoadAddress);
   } else {
     for (size_t i = 0; i < num_ranges; i++) {
       s->Printf(" %" PRIu64 ": ", uint64_t(i));
-      m_address_ranges[i].Dump(s, m_thread.CalculateTarget().get(),
-                               Address::DumpStyleLoadAddress);
+      m_address_ranges[i].Dump(s, &GetTarget(), Address::DumpStyleLoadAddress);
     }
   }
 }
 
 bool ThreadPlanStepRange::InRange() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   bool ret_value = false;
-
-  lldb::addr_t pc_load_addr = m_thread.GetRegisterContext()->GetPC();
+  Thread &thread = GetThread();
+  lldb::addr_t pc_load_addr = thread.GetRegisterContext()->GetPC();
 
   size_t num_ranges = m_address_ranges.size();
   for (size_t i = 0; i < num_ranges; i++) {
-    ret_value = m_address_ranges[i].ContainsLoadAddress(
-        pc_load_addr, m_thread.CalculateTarget().get());
+    ret_value = 
+        m_address_ranges[i].ContainsLoadAddress(pc_load_addr, &GetTarget());
     if (ret_value)
       break;
   }
 
   if (!ret_value && !m_given_ranges_only) {
     // See if we've just stepped to another part of the same line number...
-    StackFrame *frame = m_thread.GetStackFrameAtIndex(0).get();
+    StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
 
     SymbolContext new_context(
         frame->GetSymbolContext(eSymbolContextEverything));
     if (m_addr_context.line_entry.IsValid() &&
         new_context.line_entry.IsValid()) {
       if (m_addr_context.line_entry.original_file ==
           new_context.line_entry.original_file) {
         if (m_addr_context.line_entry.line == new_context.line_entry.line) {
           m_addr_context = new_context;
           const bool include_inlined_functions =
               GetKind() == eKindStepOverRange;
           AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange(
               include_inlined_functions));
           ret_value = true;
           if (log) {
             StreamString s;
-            m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
-                                           true, Address::DumpStyleLoadAddress,
+            m_addr_context.line_entry.Dump(&s, &GetTarget(), true,
+                                           Address::DumpStyleLoadAddress,
                                            Address::DumpStyleLoadAddress, true);
 
             LLDB_LOGF(
                 log,
                 "Step range plan stepped to another range of same line: %s",
                 s.GetData());
           }
         } else if (new_context.line_entry.line == 0) {
           new_context.line_entry.line = m_addr_context.line_entry.line;
           m_addr_context = new_context;
           const bool include_inlined_functions =
               GetKind() == eKindStepOverRange;
           AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange(
               include_inlined_functions));
           ret_value = true;
           if (log) {
             StreamString s;
-            m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
-                                           true, Address::DumpStyleLoadAddress,
+            m_addr_context.line_entry.Dump(&s, &GetTarget(), true,
+                                           Address::DumpStyleLoadAddress,
                                            Address::DumpStyleLoadAddress, true);
 
             LLDB_LOGF(log,
                       "Step range plan stepped to a range at linenumber 0 "
                       "stepping through that range: %s",
                       s.GetData());
           }
         } else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress(
-                       m_thread.CalculateTarget().get()) != pc_load_addr) {
+                       &GetTarget()) != pc_load_addr) {
           // Another thing that sometimes happens here is that we step out of
           // one line into the MIDDLE of another line.  So far I mostly see
           // this due to bugs in the debug information. But we probably don't
           // want to be in the middle of a line range, so in that case reset
           // the stepping range to the line we've stepped into the middle of
           // and continue.
           m_addr_context = new_context;
           m_address_ranges.clear();
           AddRange(m_addr_context.line_entry.range);
           ret_value = true;
           if (log) {
             StreamString s;
-            m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
-                                           true, Address::DumpStyleLoadAddress,
+            m_addr_context.line_entry.Dump(&s, &GetTarget(), true,
+                                           Address::DumpStyleLoadAddress,
                                            Address::DumpStyleLoadAddress, true);
 
             LLDB_LOGF(log,
                       "Step range plan stepped to the middle of new "
                       "line(%d): %s, continuing to clear this line.",
                       new_context.line_entry.line, s.GetData());
           }
         }
       }
     }
   }
 
   if (!ret_value && log)
     LLDB_LOGF(log, "Step range plan out of range to 0x%" PRIx64, pc_load_addr);
 
   return ret_value;
 }
 
 bool ThreadPlanStepRange::InSymbol() {
-  lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
+  lldb::addr_t cur_pc = GetThread().GetRegisterContext()->GetPC();
   if (m_addr_context.function != nullptr) {
     return m_addr_context.function->GetAddressRange().ContainsLoadAddress(
-        cur_pc, m_thread.CalculateTarget().get());
+        cur_pc, &GetTarget());
   } else if (m_addr_context.symbol && m_addr_context.symbol->ValueIsAddress()) {
     AddressRange range(m_addr_context.symbol->GetAddressRef(),
                        m_addr_context.symbol->GetByteSize());
-    return range.ContainsLoadAddress(cur_pc, m_thread.CalculateTarget().get());
+    return range.ContainsLoadAddress(cur_pc, &GetTarget());
   }
   return false;
 }
 
 // FIXME: This should also handle inlining if we aren't going to do inlining in
 // the
 // main stack.
 //
 // Ideally we should remember the whole stack frame list, and then compare that
 // to the current list.
 
 lldb::FrameComparison ThreadPlanStepRange::CompareCurrentFrameToStartFrame() {
   FrameComparison frame_order;
-
-  StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
+  Thread &thread = GetThread();
+  StackID cur_frame_id = thread.GetStackFrameAtIndex(0)->GetStackID();
 
   if (cur_frame_id == m_stack_id) {
     frame_order = eFrameCompareEqual;
   } else if (cur_frame_id < m_stack_id) {
     frame_order = eFrameCompareYounger;
   } else {
-    StackFrameSP cur_parent_frame = m_thread.GetStackFrameAtIndex(1);
+    StackFrameSP cur_parent_frame = thread.GetStackFrameAtIndex(1);
     StackID cur_parent_id;
     if (cur_parent_frame)
       cur_parent_id = cur_parent_frame->GetStackID();
     if (m_parent_stack_id.IsValid() && cur_parent_id.IsValid() &&
         m_parent_stack_id == cur_parent_id)
       frame_order = eFrameCompareSameParent;
     else
       frame_order = eFrameCompareOlder;
if (run_to_address.IsValid()) {
             if (bp_site) {
               bp_site_id = bp_site->GetID();
             }
           }
           LLDB_LOGF(log,
                     "ThreadPlanStepRange::SetNextBranchBreakpoint - Setting "
                     "breakpoint %d (site %d) to run to address 0x%" PRIx64,
                     m_next_branch_bp_sp->GetID(), bp_site_id,
-                    run_to_address.GetLoadAddress(
-                        &m_thread.GetProcess()->GetTarget()));
+                    run_to_address.GetLoadAddress(&m_process.GetTarget()));
         }
 
-        m_next_branch_bp_sp->SetThreadID(m_thread.GetID());
+        m_next_branch_bp_sp->SetThreadID(m_tid);
         m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
 
         return true;
       } else
         return false;
     }
   }
   return false;
 }
 
 bool ThreadPlanStepRange::NextRangeBreakpointExplainsStop(
     lldb::StopInfoSP stop_info_sp) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   if (!m_next_branch_bp_sp)
     return false;
 
   break_id_t bp_site_id = stop_info_sp->GetValue();
   BreakpointSiteSP bp_site_sp =
-      m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id);
+      m_process.GetBreakpointSiteList().FindByID(bp_site_id);
   if (!bp_site_sp)
     return false;
   else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
     return false;
   else {
     // If we've hit the next branch breakpoint, then clear it.
     size_t num_owners = bp_site_sp->GetNumberOfOwners();
     bool explains_stop = true;
if (frame_order == eFrameCompareOlder) {
     }
     return true;
   } else if (frame_order == eFrameCompareEqual && InSymbol()) {
     // If we are not in a place we should step through, we've gotten stale. One
     // tricky bit here is that some stubs don't push a frame, so we should.
     // check that we are in the same symbol.
     if (!InRange()) {
       // Set plan Complete when we reach next instruction just after the range
-      lldb::addr_t addr = m_thread.GetRegisterContext()->GetPC() - 1;
+      lldb::addr_t addr = GetThread().GetRegisterContext()->GetPC() - 1;
       size_t num_ranges = m_address_ranges.size();
       for (size_t i = 0; i < num_ranges; i++) {
-        bool in_range = m_address_ranges[i].ContainsLoadAddress(
-            addr, m_thread.CalculateTarget().get());
+        bool in_range = 
+            m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget());
         if (in_range) {
           SetPlanComplete();
         }
       }
       return true;
     }
   }
   return false;
 }

lldb/source/Target/ThreadPlanStepThrough.cpp

ThreadPlanStepThrough::ThreadPlanStepThrough(Thread &thread,
   // backstop.
   if (m_sub_plan_sp) {
     m_start_address = GetThread().GetRegisterContext()->GetPC(0);
 
     // We are going to return back to the concrete frame 1, we might pass by
     // some inlined code that we're in the middle of by doing this, but it's
     // easier than trying to figure out where the inlined code might return to.
 
-    StackFrameSP return_frame_sp = m_thread.GetFrameWithStackID(m_stack_id);
+    StackFrameSP return_frame_sp = thread.GetFrameWithStackID(m_stack_id);
 
     if (return_frame_sp) {
       m_backstop_addr = return_frame_sp->GetFrameCodeAddress().GetLoadAddress(
-          m_thread.CalculateTarget().get());
+          thread.CalculateTarget().get());
       Breakpoint *return_bp =
-          m_thread.GetProcess()
-              ->GetTarget()
+          m_process.GetTarget()
               .CreateBreakpoint(m_backstop_addr, true, false)
               .get();
 
       if (return_bp != nullptr) {
         if (return_bp->IsHardware() && !return_bp->HasResolvedLocations())
           m_could_not_resolve_hw_bp = true;
-        return_bp->SetThreadID(m_thread.GetID());
+        return_bp->SetThreadID(m_tid);
         m_backstop_bkpt_id = return_bp->GetID();
         return_bp->SetBreakpointKind("step-through-backstop");
       }
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
       if (log) {
         LLDB_LOGF(log, "Setting backstop breakpoint %d at address: 0x%" PRIx64,
                   m_backstop_bkpt_id, m_backstop_addr);
       }
     }
   }
 }
 
 ThreadPlanStepThrough::~ThreadPlanStepThrough() { ClearBackstopBreakpoint(); }
 
 void ThreadPlanStepThrough::DidPush() {
   if (m_sub_plan_sp)
     PushPlan(m_sub_plan_sp);
 }
 
 void ThreadPlanStepThrough::LookForPlanToStepThroughFromCurrentPC() {
-  DynamicLoader *loader = m_thread.GetProcess()->GetDynamicLoader();
+  Thread &thread = GetThread();
+  DynamicLoader *loader = thread.GetProcess()->GetDynamicLoader();
   if (loader)
-    m_sub_plan_sp =
-        loader->GetStepThroughTrampolinePlan(m_thread, m_stop_others);
+    m_sub_plan_sp = loader->GetStepThroughTrampolinePlan(thread, m_stop_others);
 
   // If the DynamicLoader was unable to provide us with a ThreadPlan, then we
   // try the LanguageRuntimes.
   if (!m_sub_plan_sp) {
-    for (LanguageRuntime *runtime :
-         m_thread.GetProcess()->GetLanguageRuntimes()) {
+    for (LanguageRuntime *runtime : m_process.GetLanguageRuntimes()) {
       m_sub_plan_sp =
-          runtime->GetStepThroughTrampolinePlan(m_thread, m_stop_others);
+          runtime->GetStepThroughTrampolinePlan(thread, m_stop_others);
 
       if (m_sub_plan_sp)
         break;
     }
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   if (log) {
bool ThreadPlanStepThrough::DoWillResume(StateType resume_state,
                                          bool current_plan) {
   return true;
 }
 
 bool ThreadPlanStepThrough::WillStop() { return true; }
 
 void ThreadPlanStepThrough::ClearBackstopBreakpoint() {
   if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) {
-    m_thread.GetProcess()->GetTarget().RemoveBreakpointByID(m_backstop_bkpt_id);
+    m_process.GetTarget().RemoveBreakpointByID(m_backstop_bkpt_id);
     m_backstop_bkpt_id = LLDB_INVALID_BREAK_ID;
     m_could_not_resolve_hw_bp = false;
   }
 }
 
 bool ThreadPlanStepThrough::MischiefManaged() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (!IsPlanComplete()) {
     return false;
   } else {
     LLDB_LOGF(log, "Completed step through step plan.");
 
     ClearBackstopBreakpoint();
     ThreadPlan::MischiefManaged();
     return true;
   }
 }
 
 bool ThreadPlanStepThrough::HitOurBackstopBreakpoint() {
-  StopInfoSP stop_info_sp(m_thread.GetStopInfo());
+  Thread &thread = GetThread();
+  StopInfoSP stop_info_sp(thread.GetStopInfo());
   if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint) {
     break_id_t stop_value = (break_id_t)stop_info_sp->GetValue();
     BreakpointSiteSP cur_site_sp =
-        m_thread.GetProcess()->GetBreakpointSiteList().FindByID(stop_value);
+        m_process.GetBreakpointSiteList().FindByID(stop_value);
     if (cur_site_sp &&
         cur_site_sp->IsBreakpointAtThisSite(m_backstop_bkpt_id)) {
-      StackID cur_frame_zero_id =
-          m_thread.GetStackFrameAtIndex(0)->GetStackID();
+      StackID cur_frame_zero_id = thread.GetStackFrameAtIndex(0)->GetStackID();
 
       if (cur_frame_zero_id == m_return_stack_id) {
         Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
         if (log)
           log->PutCString("ThreadPlanStepThrough hit backstop breakpoint.");
         return true;
       }
     }
   }
   return false;
 }

lldb/source/Target/ThreadPlanStepUntil.cpp

ThreadPlanStepUntil::ThreadPlanStepUntil(Thread &thread,
     : ThreadPlan(ThreadPlan::eKindStepUntil, "Step until", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_step_from_insn(LLDB_INVALID_ADDRESS),
       m_return_bp_id(LLDB_INVALID_BREAK_ID),
       m_return_addr(LLDB_INVALID_ADDRESS), m_stepped_out(false),
       m_should_stop(false), m_ran_analyze(false), m_explains_stop(false),
       m_until_points(), m_stop_others(stop_others) {
   // Stash away our "until" addresses:
-  TargetSP target_sp(m_thread.CalculateTarget());
+  TargetSP target_sp(thread.CalculateTarget());
 
-  StackFrameSP frame_sp(m_thread.GetStackFrameAtIndex(frame_idx));
+  StackFrameSP frame_sp(thread.GetStackFrameAtIndex(frame_idx));
   if (frame_sp) {
     m_step_from_insn = frame_sp->GetStackID().GetPC();
-    lldb::user_id_t thread_id = m_thread.GetID();
 
     // Find the return address and set a breakpoint there:
     // FIXME - can we do this more securely if we know first_insn?
 
-    StackFrameSP return_frame_sp(m_thread.GetStackFrameAtIndex(frame_idx + 1));
+    StackFrameSP return_frame_sp(thread.GetStackFrameAtIndex(frame_idx + 1));
     if (return_frame_sp) {
       // TODO: add inline functionality
       m_return_addr = return_frame_sp->GetStackID().GetPC();
       Breakpoint *return_bp =
           target_sp->CreateBreakpoint(m_return_addr, true, false).get();
 
       if (return_bp != nullptr) {
         if (return_bp->IsHardware() && !return_bp->HasResolvedLocations())
           m_could_not_resolve_hw_bp = true;
-        return_bp->SetThreadID(thread_id);
+        return_bp->SetThreadID(m_tid);
         m_return_bp_id = return_bp->GetID();
         return_bp->SetBreakpointKind("until-return-backstop");
       }
     }
 
     m_stack_id = frame_sp->GetStackID();
 
     // Now set breakpoints on all our return addresses:
     for (size_t i = 0; i < num_addresses; i++) {
       Breakpoint *until_bp =
           target_sp->CreateBreakpoint(address_list[i], true, false).get();
       if (until_bp != nullptr) {
-        until_bp->SetThreadID(thread_id);
+        until_bp->SetThreadID(m_tid);
         m_until_points[address_list[i]] = until_bp->GetID();
         until_bp->SetBreakpointKind("until-target");
       } else {
         m_until_points[address_list[i]] = LLDB_INVALID_BREAK_ID;
       }
     }
   }
 }
 
 ThreadPlanStepUntil::~ThreadPlanStepUntil() { Clear(); }
 
 void ThreadPlanStepUntil::Clear() {
-  TargetSP target_sp(m_thread.CalculateTarget());
-  if (target_sp) {
-    if (m_return_bp_id != LLDB_INVALID_BREAK_ID) {
-      target_sp->RemoveBreakpointByID(m_return_bp_id);
-      m_return_bp_id = LLDB_INVALID_BREAK_ID;
-    }
+  Target &target = GetTarget();
+    target.RemoveBreakpointByID(m_return_bp_id);
 
-    until_collection::iterator pos, end = m_until_points.end();
-    for (pos = m_until_points.begin(); pos != end; pos++) {
-      target_sp->RemoveBreakpointByID((*pos).second);
-    }
+    target.RemoveBreakpointByID((*pos).second);
   }
   m_until_points.clear();
   m_could_not_resolve_hw_bp = false;
 }
 
 void ThreadPlanStepUntil::GetDescription(Stream *s,
                                          lldb::DescriptionLevel level) {
   if (level == lldb::eDescriptionLevelBrief) {
void ThreadPlanStepUntil::AnalyzeStop() {
 
   if (stop_info_sp) {
     StopReason reason = stop_info_sp->GetStopReason();
 
     if (reason == eStopReasonBreakpoint) {
       // If this is OUR breakpoint, we're fine, otherwise we don't know why
       // this happened...
       BreakpointSiteSP this_site =
-          m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
-              stop_info_sp->GetValue());
+          m_process.GetBreakpointSiteList().FindByID(stop_info_sp->GetValue());
       if (!this_site) {
         m_explains_stop = false;
         return;
       }
 
       if (this_site->IsBreakpointAtThisSite(m_return_bp_id)) {
         // If we are at our "step out" breakpoint, and the stack depth has
         // shrunk, then this is indeed our stop. If the stack depth has grown,
if (reason == eStopReasonBreakpoint) {
           m_explains_stop = false;
         return;
       } else {
         // Check if we've hit one of our "until" breakpoints.
         until_collection::iterator pos, end = m_until_points.end();
         for (pos = m_until_points.begin(); pos != end; pos++) {
           if (this_site->IsBreakpointAtThisSite((*pos).second)) {
             // If we're at the right stack depth, then we're done.
-
+            Thread &thread = GetThread();
             bool done;
             StackID frame_zero_id =
-                m_thread.GetStackFrameAtIndex(0)->GetStackID();
+                thread.GetStackFrameAtIndex(0)->GetStackID();
 
             if (frame_zero_id == m_stack_id)
               done = true;
             else if (frame_zero_id < m_stack_id)
               done = false;
             else {
-              StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1);
+              StackFrameSP older_frame_sp = thread.GetStackFrameAtIndex(1);
 
               // But if we can't even unwind one frame we should just get out
               // of here & stop...
               if (older_frame_sp) {
                 const SymbolContext &older_context =
                     older_frame_sp->GetSymbolContext(eSymbolContextEverything);
                 SymbolContext stack_context;
                 m_stack_id.GetSymbolContextScope()->CalculateSymbolContext(

 
 bool ThreadPlanStepUntil::StopOthers() { return m_stop_others; }
 
 StateType ThreadPlanStepUntil::GetPlanRunState() { return eStateRunning; }
 
 bool ThreadPlanStepUntil::DoWillResume(StateType resume_state,
                                        bool current_plan) {
   if (current_plan) {
-    TargetSP target_sp(m_thread.CalculateTarget());
-    if (target_sp) {
-      Breakpoint *return_bp =
-          target_sp->GetBreakpointByID(m_return_bp_id).get();
-      if (return_bp != nullptr)
-        return_bp->SetEnabled(true);
+    Target &target = GetTarget();
+    Breakpoint *return_bp = target.GetBreakpointByID(m_return_bp_id).get();
 
-      until_collection::iterator pos, end = m_until_points.end();
-      for (pos = m_until_points.begin(); pos != end; pos++) {
-        Breakpoint *until_bp =
-            target_sp->GetBreakpointByID((*pos).second).get();
-        if (until_bp != nullptr)
-          until_bp->SetEnabled(true);
-      }
-    }
-  }
+      Breakpoint *until_bp = target.GetBreakpointByID((*pos).second).get();
 
   m_should_stop = true;
   m_ran_analyze = false;
   m_explains_stop = false;
   return true;
 }
 
 bool ThreadPlanStepUntil::WillStop() {
-  TargetSP target_sp(m_thread.CalculateTarget());
-  if (target_sp) {
-    Breakpoint *return_bp = target_sp->GetBreakpointByID(m_return_bp_id).get();
-    if (return_bp != nullptr)
-      return_bp->SetEnabled(false);
+  Target &target = GetTarget();
+  Breakpoint *return_bp = target.GetBreakpointByID(m_return_bp_id).get();
 
-    until_collection::iterator pos, end = m_until_points.end();
-    for (pos = m_until_points.begin(); pos != end; pos++) {
-      Breakpoint *until_bp = target_sp->GetBreakpointByID((*pos).second).get();
-      if (until_bp != nullptr)
-        until_bp->SetEnabled(false);
-    }
-  }
+    Breakpoint *until_bp = target.GetBreakpointByID((*pos).second).get();
   return true;
 }
 
 bool ThreadPlanStepUntil::MischiefManaged() {
   // I'm letting "PlanExplainsStop" do all the work, and just reporting that
   // here.
   bool done = false;
   if (IsPlanComplete()) {