1 //===-- SBProcessInfo.cpp -------------------------------------------------===//
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 "lldb/API/SBProcessInfo.h"
10 #include "SBReproducerPrivate.h"
11 #include "Utils.h"
12 #include "lldb/API/SBEnvironment.h"
13 #include "lldb/API/SBFileSpec.h"
14 #include "lldb/Utility/ProcessInfo.h"
15 
16 using namespace lldb;
17 using namespace lldb_private;
18 
19 SBProcessInfo::SBProcessInfo() : m_opaque_up() {
20   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
21 }
22 
23 SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() {
24   LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs);
25 
26   m_opaque_up = clone(rhs.m_opaque_up);
27 }
28 
29 SBProcessInfo::~SBProcessInfo() = default;
30 
31 SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
32   LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
33                      SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
34                      rhs);
35 
36   if (this != &rhs)
37     m_opaque_up = clone(rhs.m_opaque_up);
38   return LLDB_RECORD_RESULT(*this);
39 }
40 
41 ProcessInstanceInfo &SBProcessInfo::ref() {
42   if (m_opaque_up == nullptr) {
43     m_opaque_up = std::make_unique<ProcessInstanceInfo>();
44   }
45   return *m_opaque_up;
46 }
47 
48 void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
49   ref() = proc_info_ref;
50 }
51 
52 bool SBProcessInfo::IsValid() const {
53   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
54   return this->operator bool();
55 }
56 SBProcessInfo::operator bool() const {
57   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool);
58 
59   return m_opaque_up != nullptr;
60 }
61 
62 const char *SBProcessInfo::GetName() {
63   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
64 
65   const char *name = nullptr;
66   if (m_opaque_up) {
67     name = m_opaque_up->GetName();
68   }
69   return name;
70 }
71 
72 SBFileSpec SBProcessInfo::GetExecutableFile() {
73   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
74                              GetExecutableFile);
75 
76   SBFileSpec file_spec;
77   if (m_opaque_up) {
78     file_spec.SetFileSpec(m_opaque_up->GetExecutableFile());
79   }
80   return LLDB_RECORD_RESULT(file_spec);
81 }
82 
83 lldb::pid_t SBProcessInfo::GetProcessID() {
84   LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID);
85 
86   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
87   if (m_opaque_up) {
88     proc_id = m_opaque_up->GetProcessID();
89   }
90   return proc_id;
91 }
92 
93 uint32_t SBProcessInfo::GetUserID() {
94   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
95 
96   uint32_t user_id = UINT32_MAX;
97   if (m_opaque_up) {
98     user_id = m_opaque_up->GetUserID();
99   }
100   return user_id;
101 }
102 
103 uint32_t SBProcessInfo::GetGroupID() {
104   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
105 
106   uint32_t group_id = UINT32_MAX;
107   if (m_opaque_up) {
108     group_id = m_opaque_up->GetGroupID();
109   }
110   return group_id;
111 }
112 
113 bool SBProcessInfo::UserIDIsValid() {
114   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
115 
116   bool is_valid = false;
117   if (m_opaque_up) {
118     is_valid = m_opaque_up->UserIDIsValid();
119   }
120   return is_valid;
121 }
122 
123 bool SBProcessInfo::GroupIDIsValid() {
124   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
125 
126   bool is_valid = false;
127   if (m_opaque_up) {
128     is_valid = m_opaque_up->GroupIDIsValid();
129   }
130   return is_valid;
131 }
132 
133 uint32_t SBProcessInfo::GetEffectiveUserID() {
134   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
135 
136   uint32_t user_id = UINT32_MAX;
137   if (m_opaque_up) {
138     user_id = m_opaque_up->GetEffectiveUserID();
139   }
140   return user_id;
141 }
142 
143 uint32_t SBProcessInfo::GetEffectiveGroupID() {
144   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
145 
146   uint32_t group_id = UINT32_MAX;
147   if (m_opaque_up) {
148     group_id = m_opaque_up->GetEffectiveGroupID();
149   }
150   return group_id;
151 }
152 
153 bool SBProcessInfo::EffectiveUserIDIsValid() {
154   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
155 
156   bool is_valid = false;
157   if (m_opaque_up) {
158     is_valid = m_opaque_up->EffectiveUserIDIsValid();
159   }
160   return is_valid;
161 }
162 
163 bool SBProcessInfo::EffectiveGroupIDIsValid() {
164   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
165 
166   bool is_valid = false;
167   if (m_opaque_up) {
168     is_valid = m_opaque_up->EffectiveGroupIDIsValid();
169   }
170   return is_valid;
171 }
172 
173 lldb::pid_t SBProcessInfo::GetParentProcessID() {
174   LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID);
175 
176   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
177   if (m_opaque_up) {
178     proc_id = m_opaque_up->GetParentProcessID();
179   }
180   return proc_id;
181 }
182 
183 const char *SBProcessInfo::GetTriple() {
184   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple);
185 
186   const char *triple = nullptr;
187   if (m_opaque_up) {
188     const auto &arch = m_opaque_up->GetArchitecture();
189     if (arch.IsValid()) {
190       // Const-ify the string so we don't need to worry about the lifetime of
191       // the string
192       triple = ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
193     }
194   }
195   return triple;
196 }
197 
198 uint32_t SBProcessInfo::GetNumArguments() {
199   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetNumArguments);
200 
201   uint32_t num = 0;
202   if (m_opaque_up) {
203     num = m_opaque_up->GetArguments().size();
204   }
205   return num;
206 }
207 
208 const char *SBProcessInfo::GetArgumentAtIndex(uint32_t index) {
209   LLDB_RECORD_METHOD(const char *, SBProcessInfo, GetArgumentAtIndex,
210                      (uint32_t), index);
211 
212   const char *argument = nullptr;
213   if (m_opaque_up) {
214     argument = m_opaque_up->GetArguments().GetArgumentAtIndex(index);
215   }
216   return argument;
217 }
218 
219 SBEnvironment SBProcessInfo::GetEnvironment() {
220   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBProcessInfo,
221                              GetEnvironment);
222 
223   if (m_opaque_up) {
224     return LLDB_RECORD_RESULT(SBEnvironment(m_opaque_up->GetEnvironment()));
225   }
226 
227   return LLDB_RECORD_RESULT(SBEnvironment());
228 }
229 
230 namespace lldb_private {
231 namespace repro {
232 
233 template <>
234 void RegisterMethods<SBProcessInfo>(Registry &R) {
235   LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
236   LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
237   LLDB_REGISTER_METHOD(
238       lldb::SBProcessInfo &,
239       SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
240   LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
241   LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
242   LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
243   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
244                        ());
245   LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
246   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
247   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
248   LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
249   LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
250   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
251   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
252   LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
253   LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
254   LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
255   LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetTriple, ());
256   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetNumArguments, ());
257   LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetArgumentAtIndex,
258                        (uint32_t));
259   LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBProcessInfo, GetEnvironment, ());
260 }
261 
262 }
263 }
264