1//===-- SBModuleSpec.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 "lldb/API/SBModuleSpec.h"
10#include "SBReproducerPrivate.h"
11#include "Utils.h"
12#include "lldb/API/SBStream.h"
13#include "lldb/Core/Module.h"
14#include "lldb/Core/ModuleSpec.h"
15#include "lldb/Host/Host.h"
16#include "lldb/Symbol/ObjectFile.h"
17#include "lldb/Utility/Stream.h"
18
19using namespace lldb;
20using namespace lldb_private;
21
22SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {
23  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpec);
24}
25
26SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) : m_opaque_up() {
27  LLDB_RECORD_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs);
28
29  m_opaque_up = clone(rhs.m_opaque_up);
30}
31
32const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
33  LLDB_RECORD_METHOD(const lldb::SBModuleSpec &,
34                     SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs);
35
36  if (this != &rhs)
37    m_opaque_up = clone(rhs.m_opaque_up);
38  return LLDB_RECORD_RESULT(*this);
39}
40
41SBModuleSpec::~SBModuleSpec() {}
42
43bool SBModuleSpec::IsValid() const {
44  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid);
45  return this->operator bool();
46}
47SBModuleSpec::operator bool() const {
48  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool);
49
50  return m_opaque_up->operator bool();
51}
52
53void SBModuleSpec::Clear() {
54  LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear);
55
56  m_opaque_up->Clear();
57}
58
59SBFileSpec SBModuleSpec::GetFileSpec() {
60  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec);
61
62  SBFileSpec sb_spec(m_opaque_up->GetFileSpec());
63  return LLDB_RECORD_RESULT(sb_spec);
64}
65
66void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) {
67  LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec,
68                     (const lldb::SBFileSpec &), sb_spec);
69
70  m_opaque_up->GetFileSpec() = *sb_spec;
71}
72
73lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() {
74  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec,
75                             GetPlatformFileSpec);
76
77  return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetPlatformFileSpec()));
78}
79
80void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) {
81  LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
82                     (const lldb::SBFileSpec &), sb_spec);
83
84  m_opaque_up->GetPlatformFileSpec() = *sb_spec;
85}
86
87lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() {
88  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec);
89
90  return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetSymbolFileSpec()));
91}
92
93void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) {
94  LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
95                     (const lldb::SBFileSpec &), sb_spec);
96
97  m_opaque_up->GetSymbolFileSpec() = *sb_spec;
98}
99
100const char *SBModuleSpec::GetObjectName() {
101  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName);
102
103  return m_opaque_up->GetObjectName().GetCString();
104}
105
106void SBModuleSpec::SetObjectName(const char *name) {
107  LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name);
108
109  m_opaque_up->GetObjectName().SetCString(name);
110}
111
112const char *SBModuleSpec::GetTriple() {
113  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple);
114
115  std::string triple(m_opaque_up->GetArchitecture().GetTriple().str());
116  // Unique the string so we don't run into ownership issues since the const
117  // strings put the string into the string pool once and the strings never
118  // comes out
119  ConstString const_triple(triple.c_str());
120  return const_triple.GetCString();
121}
122
123void SBModuleSpec::SetTriple(const char *triple) {
124  LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
125
126  m_opaque_up->GetArchitecture().SetTriple(triple);
127}
128
129const uint8_t *SBModuleSpec::GetUUIDBytes() {
130  return m_opaque_up->GetUUID().GetBytes().data();
131}
132
133size_t SBModuleSpec::GetUUIDLength() {
134  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
135
136  return m_opaque_up->GetUUID().GetBytes().size();
137}
138
139bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) {
140  m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len);
141  return m_opaque_up->GetUUID().IsValid();
142}
143
144bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
145  LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
146                     description);
147
148  m_opaque_up->Dump(description.ref());
149  return true;
150}
151
152SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {
153  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpecList);
154}
155
156SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs)
157    : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {
158  LLDB_RECORD_CONSTRUCTOR(SBModuleSpecList, (const lldb::SBModuleSpecList &),
159                          rhs);
160}
161
162SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
163  LLDB_RECORD_METHOD(
164      lldb::SBModuleSpecList &,
165      SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs);
166
167  if (this != &rhs)
168    *m_opaque_up = *rhs.m_opaque_up;
169  return LLDB_RECORD_RESULT(*this);
170}
171
172SBModuleSpecList::~SBModuleSpecList() {}
173
174SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
175  LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
176                            GetModuleSpecifications, (const char *), path);
177
178  SBModuleSpecList specs;
179  FileSpec file_spec(path);
180  FileSystem::Instance().Resolve(file_spec);
181  Host::ResolveExecutableInBundle(file_spec);
182  ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_up);
183  return LLDB_RECORD_RESULT(specs);
184}
185
186void SBModuleSpecList::Append(const SBModuleSpec &spec) {
187  LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
188                     (const lldb::SBModuleSpec &), spec);
189
190  m_opaque_up->Append(*spec.m_opaque_up);
191}
192
193void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) {
194  LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
195                     (const lldb::SBModuleSpecList &), spec_list);
196
197  m_opaque_up->Append(*spec_list.m_opaque_up);
198}
199
200size_t SBModuleSpecList::GetSize() {
201  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize);
202
203  return m_opaque_up->GetSize();
204}
205
206SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
207  LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
208                     (size_t), i);
209
210  SBModuleSpec sb_module_spec;
211  m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up);
212  return LLDB_RECORD_RESULT(sb_module_spec);
213}
214
215SBModuleSpec
216SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
217  LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
218                     FindFirstMatchingSpec, (const lldb::SBModuleSpec &),
219                     match_spec);
220
221  SBModuleSpec sb_module_spec;
222  m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up,
223                                      *sb_module_spec.m_opaque_up);
224  return LLDB_RECORD_RESULT(sb_module_spec);
225}
226
227SBModuleSpecList
228SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
229  LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
230                     FindMatchingSpecs, (const lldb::SBModuleSpec &),
231                     match_spec);
232
233  SBModuleSpecList specs;
234  m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up,
235                                       *specs.m_opaque_up);
236  return LLDB_RECORD_RESULT(specs);
237}
238
239bool SBModuleSpecList::GetDescription(lldb::SBStream &description) {
240  LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &),
241                     description);
242
243  m_opaque_up->Dump(description.ref());
244  return true;
245}
246
247namespace lldb_private {
248namespace repro {
249
250template <>
251void RegisterMethods<SBModuleSpec>(Registry &R) {
252  LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ());
253  LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &));
254  LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &,
255                       SBModuleSpec, operator=,(const lldb::SBModuleSpec &));
256  LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ());
257  LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, operator bool, ());
258  LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ());
259  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ());
260  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec,
261                       (const lldb::SBFileSpec &));
262  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec,
263                       ());
264  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
265                       (const lldb::SBFileSpec &));
266  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ());
267  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
268                       (const lldb::SBFileSpec &));
269  LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ());
270  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *));
271  LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ());
272  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *));
273  LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ());
274  LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription,
275                       (lldb::SBStream &));
276  LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ());
277  LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList,
278                            (const lldb::SBModuleSpecList &));
279  LLDB_REGISTER_METHOD(
280      lldb::SBModuleSpecList &,
281      SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &));
282  LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
283                              GetModuleSpecifications, (const char *));
284  LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
285                       (const lldb::SBModuleSpec &));
286  LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
287                       (const lldb::SBModuleSpecList &));
288  LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ());
289  LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
290                       (size_t));
291  LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
292                       FindFirstMatchingSpec, (const lldb::SBModuleSpec &));
293  LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
294                       FindMatchingSpecs, (const lldb::SBModuleSpec &));
295  LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription,
296                       (lldb::SBStream &));
297}
298
299}
300}
301