1 //===-- CommandObjectThreadUtil.cpp -----------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "CommandObjectThreadUtil.h"
10 
11 #include "lldb/Interpreter/CommandReturnObject.h"
12 #include "lldb/Target/Process.h"
13 #include "lldb/Target/Thread.h"
14 
15 using namespace lldb;
16 using namespace lldb_private;
17 using namespace llvm;
18 
19 CommandObjectIterateOverThreads::CommandObjectIterateOverThreads(
20     CommandInterpreter &interpreter, const char *name, const char *help,
21     const char *syntax, uint32_t flags)
22     : CommandObjectParsed(interpreter, name, help, syntax, flags) {}
23 
24 bool CommandObjectIterateOverThreads::DoExecute(Args &command,
25                                                 CommandReturnObject &result) {
26   result.SetStatus(m_success_return);
27 
28   bool all_threads = false;
29   if (command.GetArgumentCount() == 0) {
30     Thread *thread = m_exe_ctx.GetThreadPtr();
31     if (!thread || !HandleOneThread(thread->GetID(), result))
32       return false;
33     return result.Succeeded();
34   } else if (command.GetArgumentCount() == 1) {
35     all_threads = ::strcmp(command.GetArgumentAtIndex(0), "all") == 0;
36     m_unique_stacks = ::strcmp(command.GetArgumentAtIndex(0), "unique") == 0;
37   }
38 
39   // Use tids instead of ThreadSPs to prevent deadlocking problems which
40   // result from JIT-ing code while iterating over the (locked) ThreadSP
41   // list.
42   std::vector<lldb::tid_t> tids;
43 
44   if (all_threads || m_unique_stacks) {
45     Process *process = m_exe_ctx.GetProcessPtr();
46 
47     for (ThreadSP thread_sp : process->Threads())
48       tids.push_back(thread_sp->GetID());
49   } else {
50     const size_t num_args = command.GetArgumentCount();
51     Process *process = m_exe_ctx.GetProcessPtr();
52 
53     std::lock_guard<std::recursive_mutex> guard(
54         process->GetThreadList().GetMutex());
55 
56     for (size_t i = 0; i < num_args; i++) {
57       uint32_t thread_idx;
58       if (!llvm::to_integer(command.GetArgumentAtIndex(i), thread_idx)) {
59         result.AppendErrorWithFormat("invalid thread specification: \"%s\"\n",
60                                      command.GetArgumentAtIndex(i));
61         return false;
62       }
63 
64       ThreadSP thread =
65           process->GetThreadList().FindThreadByIndexID(thread_idx);
66 
67       if (!thread) {
68         result.AppendErrorWithFormat("no thread with index: \"%s\"\n",
69                                      command.GetArgumentAtIndex(i));
70         return false;
71       }
72 
73       tids.push_back(thread->GetID());
74     }
75   }
76 
77   if (m_unique_stacks) {
78     // Iterate over threads, finding unique stack buckets.
79     std::set<UniqueStack> unique_stacks;
80     for (const lldb::tid_t &tid : tids) {
81       if (!BucketThread(tid, unique_stacks, result)) {
82         return false;
83       }
84     }
85 
86     // Write the thread id's and unique call stacks to the output stream
87     Stream &strm = result.GetOutputStream();
88     Process *process = m_exe_ctx.GetProcessPtr();
89     for (const UniqueStack &stack : unique_stacks) {
90       // List the common thread ID's
91       const std::vector<uint32_t> &thread_index_ids =
92           stack.GetUniqueThreadIndexIDs();
93       strm.Format("{0} thread(s) ", thread_index_ids.size());
94       for (const uint32_t &thread_index_id : thread_index_ids) {
95         strm.Format("#{0} ", thread_index_id);
96       }
97       strm.EOL();
98 
99       // List the shared call stack for this set of threads
100       uint32_t representative_thread_id = stack.GetRepresentativeThread();
101       ThreadSP thread = process->GetThreadList().FindThreadByIndexID(
102           representative_thread_id);
103       if (!HandleOneThread(thread->GetID(), result)) {
104         return false;
105       }
106     }
107   } else {
108     uint32_t idx = 0;
109     for (const lldb::tid_t &tid : tids) {
110       if (idx != 0 && m_add_return)
111         result.AppendMessage("");
112 
113       if (!HandleOneThread(tid, result))
114         return false;
115 
116       ++idx;
117     }
118   }
119   return result.Succeeded();
120 }
121 
122 bool CommandObjectIterateOverThreads::BucketThread(
123     lldb::tid_t tid, std::set<UniqueStack> &unique_stacks,
124     CommandReturnObject &result) {
125   // Grab the corresponding thread for the given thread id.
126   Process *process = m_exe_ctx.GetProcessPtr();
127   Thread *thread = process->GetThreadList().FindThreadByID(tid).get();
128   if (thread == nullptr) {
129     result.AppendErrorWithFormatv("Failed to process thread #{0}.\n", tid);
130     return false;
131   }
132 
133   // Collect the each frame's address for this call-stack
134   std::stack<lldb::addr_t> stack_frames;
135   const uint32_t frame_count = thread->GetStackFrameCount();
136   for (uint32_t frame_index = 0; frame_index < frame_count; frame_index++) {
137     const lldb::StackFrameSP frame_sp =
138         thread->GetStackFrameAtIndex(frame_index);
139     const lldb::addr_t pc = frame_sp->GetStackID().GetPC();
140     stack_frames.push(pc);
141   }
142 
143   uint32_t thread_index_id = thread->GetIndexID();
144   UniqueStack new_unique_stack(stack_frames, thread_index_id);
145 
146   // Try to match the threads stack to and existing entry.
147   std::set<UniqueStack>::iterator matching_stack =
148       unique_stacks.find(new_unique_stack);
149   if (matching_stack != unique_stacks.end()) {
150     matching_stack->AddThread(thread_index_id);
151   } else {
152     unique_stacks.insert(new_unique_stack);
153   }
154   return true;
155 }
156 
157 bool CommandObjectMultipleThreads::DoExecute(Args &command,
158                                              CommandReturnObject &result) {
159   Process &process = m_exe_ctx.GetProcessRef();
160 
161   std::vector<lldb::tid_t> tids;
162   const size_t num_args = command.GetArgumentCount();
163 
164   std::lock_guard<std::recursive_mutex> guard(
165       process.GetThreadList().GetMutex());
166 
167   if (num_args > 0 && ::strcmp(command.GetArgumentAtIndex(0), "all") == 0) {
168     for (ThreadSP thread_sp : process.Threads())
169       tids.push_back(thread_sp->GetID());
170   } else {
171     if (num_args == 0) {
172       Thread &thread = m_exe_ctx.GetThreadRef();
173       tids.push_back(thread.GetID());
174     }
175 
176     for (size_t i = 0; i < num_args; i++) {
177       uint32_t thread_idx;
178       if (!llvm::to_integer(command.GetArgumentAtIndex(i), thread_idx)) {
179         result.AppendErrorWithFormat("invalid thread specification: \"%s\"\n",
180                                      command.GetArgumentAtIndex(i));
181         return false;
182       }
183 
184       ThreadSP thread = process.GetThreadList().FindThreadByIndexID(thread_idx);
185 
186       if (!thread) {
187         result.AppendErrorWithFormat("no thread with index: \"%s\"\n",
188                                      command.GetArgumentAtIndex(i));
189         return false;
190       }
191 
192       tids.push_back(thread->GetID());
193     }
194   }
195 
196   return DoExecuteOnThreads(command, result, tids);
197 }
198