1 //===-- SBModuleSpec.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/SBModuleSpec.h" 10 #include "Utils.h" 11 #include "lldb/API/SBStream.h" 12 #include "lldb/Core/Module.h" 13 #include "lldb/Core/ModuleSpec.h" 14 #include "lldb/Host/Host.h" 15 #include "lldb/Symbol/ObjectFile.h" 16 #include "lldb/Utility/Instrumentation.h" 17 #include "lldb/Utility/Stream.h" 18 19 using namespace lldb; 20 using namespace lldb_private; 21 22 SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) { 23 LLDB_INSTRUMENT_VA(this); 24 } 25 26 SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) { 27 LLDB_INSTRUMENT_VA(this, rhs); 28 29 m_opaque_up = clone(rhs.m_opaque_up); 30 } 31 32 SBModuleSpec::SBModuleSpec(const lldb_private::ModuleSpec &module_spec) 33 : m_opaque_up(new lldb_private::ModuleSpec(module_spec)) { 34 LLDB_INSTRUMENT_VA(this, module_spec); 35 } 36 37 const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) { 38 LLDB_INSTRUMENT_VA(this, rhs); 39 40 if (this != &rhs) 41 m_opaque_up = clone(rhs.m_opaque_up); 42 return *this; 43 } 44 45 SBModuleSpec::~SBModuleSpec() = default; 46 47 bool SBModuleSpec::IsValid() const { 48 LLDB_INSTRUMENT_VA(this); 49 return this->operator bool(); 50 } 51 SBModuleSpec::operator bool() const { 52 LLDB_INSTRUMENT_VA(this); 53 54 return m_opaque_up->operator bool(); 55 } 56 57 void SBModuleSpec::Clear() { 58 LLDB_INSTRUMENT_VA(this); 59 60 m_opaque_up->Clear(); 61 } 62 63 SBFileSpec SBModuleSpec::GetFileSpec() { 64 LLDB_INSTRUMENT_VA(this); 65 66 SBFileSpec sb_spec(m_opaque_up->GetFileSpec()); 67 return sb_spec; 68 } 69 70 void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) { 71 LLDB_INSTRUMENT_VA(this, sb_spec); 72 73 m_opaque_up->GetFileSpec() = *sb_spec; 74 } 75 76 lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() { 77 LLDB_INSTRUMENT_VA(this); 78 79 return SBFileSpec(m_opaque_up->GetPlatformFileSpec()); 80 } 81 82 void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) { 83 LLDB_INSTRUMENT_VA(this, sb_spec); 84 85 m_opaque_up->GetPlatformFileSpec() = *sb_spec; 86 } 87 88 lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() { 89 LLDB_INSTRUMENT_VA(this); 90 91 return SBFileSpec(m_opaque_up->GetSymbolFileSpec()); 92 } 93 94 void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) { 95 LLDB_INSTRUMENT_VA(this, sb_spec); 96 97 m_opaque_up->GetSymbolFileSpec() = *sb_spec; 98 } 99 100 const char *SBModuleSpec::GetObjectName() { 101 LLDB_INSTRUMENT_VA(this); 102 103 return m_opaque_up->GetObjectName().GetCString(); 104 } 105 106 void SBModuleSpec::SetObjectName(const char *name) { 107 LLDB_INSTRUMENT_VA(this, name); 108 109 m_opaque_up->GetObjectName().SetCString(name); 110 } 111 112 const char *SBModuleSpec::GetTriple() { 113 LLDB_INSTRUMENT_VA(this); 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 123 void SBModuleSpec::SetTriple(const char *triple) { 124 LLDB_INSTRUMENT_VA(this, triple); 125 126 m_opaque_up->GetArchitecture().SetTriple(triple); 127 } 128 129 const uint8_t *SBModuleSpec::GetUUIDBytes() { 130 LLDB_INSTRUMENT_VA(this) 131 return m_opaque_up->GetUUID().GetBytes().data(); 132 } 133 134 size_t SBModuleSpec::GetUUIDLength() { 135 LLDB_INSTRUMENT_VA(this); 136 137 return m_opaque_up->GetUUID().GetBytes().size(); 138 } 139 140 bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) { 141 LLDB_INSTRUMENT_VA(this, uuid, uuid_len) 142 m_opaque_up->GetUUID() = UUID(uuid, uuid_len); 143 return m_opaque_up->GetUUID().IsValid(); 144 } 145 146 bool SBModuleSpec::GetDescription(lldb::SBStream &description) { 147 LLDB_INSTRUMENT_VA(this, description); 148 149 m_opaque_up->Dump(description.ref()); 150 return true; 151 } 152 153 uint64_t SBModuleSpec::GetObjectOffset() { 154 LLDB_INSTRUMENT_VA(this); 155 156 return m_opaque_up->GetObjectOffset(); 157 } 158 159 void SBModuleSpec::SetObjectOffset(uint64_t object_offset) { 160 LLDB_INSTRUMENT_VA(this, object_offset); 161 162 m_opaque_up->SetObjectOffset(object_offset); 163 } 164 165 uint64_t SBModuleSpec::GetObjectSize() { 166 LLDB_INSTRUMENT_VA(this); 167 168 return m_opaque_up->GetObjectSize(); 169 } 170 171 void SBModuleSpec::SetObjectSize(uint64_t object_size) { 172 LLDB_INSTRUMENT_VA(this, object_size); 173 174 m_opaque_up->SetObjectSize(object_size); 175 } 176 177 SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) { 178 LLDB_INSTRUMENT_VA(this); 179 } 180 181 SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs) 182 : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) { 183 LLDB_INSTRUMENT_VA(this, rhs); 184 } 185 186 SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) { 187 LLDB_INSTRUMENT_VA(this, rhs); 188 189 if (this != &rhs) 190 *m_opaque_up = *rhs.m_opaque_up; 191 return *this; 192 } 193 194 SBModuleSpecList::~SBModuleSpecList() = default; 195 196 SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) { 197 LLDB_INSTRUMENT_VA(path); 198 199 SBModuleSpecList specs; 200 FileSpec file_spec(path); 201 FileSystem::Instance().Resolve(file_spec); 202 Host::ResolveExecutableInBundle(file_spec); 203 ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_up); 204 return specs; 205 } 206 207 void SBModuleSpecList::Append(const SBModuleSpec &spec) { 208 LLDB_INSTRUMENT_VA(this, spec); 209 210 m_opaque_up->Append(*spec.m_opaque_up); 211 } 212 213 void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) { 214 LLDB_INSTRUMENT_VA(this, spec_list); 215 216 m_opaque_up->Append(*spec_list.m_opaque_up); 217 } 218 219 size_t SBModuleSpecList::GetSize() { 220 LLDB_INSTRUMENT_VA(this); 221 222 return m_opaque_up->GetSize(); 223 } 224 225 SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) { 226 LLDB_INSTRUMENT_VA(this, i); 227 228 SBModuleSpec sb_module_spec; 229 m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up); 230 return sb_module_spec; 231 } 232 233 SBModuleSpec 234 SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) { 235 LLDB_INSTRUMENT_VA(this, match_spec); 236 237 SBModuleSpec sb_module_spec; 238 m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up, 239 *sb_module_spec.m_opaque_up); 240 return sb_module_spec; 241 } 242 243 SBModuleSpecList 244 SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) { 245 LLDB_INSTRUMENT_VA(this, match_spec); 246 247 SBModuleSpecList specs; 248 m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up, 249 *specs.m_opaque_up); 250 return specs; 251 } 252 253 bool SBModuleSpecList::GetDescription(lldb::SBStream &description) { 254 LLDB_INSTRUMENT_VA(this, description); 255 256 m_opaque_up->Dump(description.ref()); 257 return true; 258 } 259