1 //===-- SBCompileUnit.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/SBCompileUnit.h" 10 #include "SBReproducerPrivate.h" 11 #include "lldb/API/SBLineEntry.h" 12 #include "lldb/API/SBStream.h" 13 #include "lldb/Core/Module.h" 14 #include "lldb/Symbol/CompileUnit.h" 15 #include "lldb/Symbol/LineEntry.h" 16 #include "lldb/Symbol/LineTable.h" 17 #include "lldb/Symbol/SymbolFile.h" 18 #include "lldb/Symbol/Type.h" 19 #include "lldb/Symbol/TypeList.h" 20 21 using namespace lldb; 22 using namespace lldb_private; 23 24 SBCompileUnit::SBCompileUnit() { 25 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit); 26 } 27 28 SBCompileUnit::SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr) 29 : m_opaque_ptr(lldb_object_ptr) {} 30 31 SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs) 32 : m_opaque_ptr(rhs.m_opaque_ptr) { 33 LLDB_RECORD_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), rhs); 34 } 35 36 const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) { 37 LLDB_RECORD_METHOD(const lldb::SBCompileUnit &, 38 SBCompileUnit, operator=,(const lldb::SBCompileUnit &), 39 rhs); 40 41 m_opaque_ptr = rhs.m_opaque_ptr; 42 return LLDB_RECORD_RESULT(*this); 43 } 44 45 SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; } 46 47 SBFileSpec SBCompileUnit::GetFileSpec() const { 48 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit, 49 GetFileSpec); 50 51 SBFileSpec file_spec; 52 if (m_opaque_ptr) 53 file_spec.SetFileSpec(m_opaque_ptr->GetPrimaryFile()); 54 return LLDB_RECORD_RESULT(file_spec); 55 } 56 57 uint32_t SBCompileUnit::GetNumLineEntries() const { 58 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries); 59 60 if (m_opaque_ptr) { 61 LineTable *line_table = m_opaque_ptr->GetLineTable(); 62 if (line_table) { 63 return line_table->GetSize(); 64 } 65 } 66 return 0; 67 } 68 69 SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const { 70 LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, 71 GetLineEntryAtIndex, (uint32_t), idx); 72 73 SBLineEntry sb_line_entry; 74 if (m_opaque_ptr) { 75 LineTable *line_table = m_opaque_ptr->GetLineTable(); 76 if (line_table) { 77 LineEntry line_entry; 78 if (line_table->GetLineEntryAtIndex(idx, line_entry)) 79 sb_line_entry.SetLineEntry(line_entry); 80 } 81 } 82 83 return LLDB_RECORD_RESULT(sb_line_entry); 84 } 85 86 uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, 87 SBFileSpec *inline_file_spec) const { 88 LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, 89 (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx, 90 line, inline_file_spec); 91 92 const bool exact = true; 93 return FindLineEntryIndex(start_idx, line, inline_file_spec, exact); 94 } 95 96 uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, 97 SBFileSpec *inline_file_spec, 98 bool exact) const { 99 LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, 100 (uint32_t, uint32_t, lldb::SBFileSpec *, bool), 101 start_idx, line, inline_file_spec, exact); 102 103 uint32_t index = UINT32_MAX; 104 if (m_opaque_ptr) { 105 FileSpec file_spec; 106 if (inline_file_spec && inline_file_spec->IsValid()) 107 file_spec = inline_file_spec->ref(); 108 else 109 file_spec = m_opaque_ptr->GetPrimaryFile(); 110 111 LineEntry line_entry; 112 index = m_opaque_ptr->FindLineEntry( 113 start_idx, line, inline_file_spec ? inline_file_spec->get() : nullptr, 114 exact, &line_entry); 115 } 116 117 return index; 118 } 119 120 uint32_t SBCompileUnit::GetNumSupportFiles() const { 121 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles); 122 123 if (m_opaque_ptr) 124 return m_opaque_ptr->GetSupportFiles().GetSize(); 125 126 return 0; 127 } 128 129 lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) { 130 LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t), 131 type_mask); 132 133 SBTypeList sb_type_list; 134 135 if (!m_opaque_ptr) 136 return LLDB_RECORD_RESULT(sb_type_list); 137 138 ModuleSP module_sp(m_opaque_ptr->GetModule()); 139 if (!module_sp) 140 return LLDB_RECORD_RESULT(sb_type_list); 141 142 SymbolFile *symfile = module_sp->GetSymbolFile(); 143 if (!symfile) 144 return LLDB_RECORD_RESULT(sb_type_list); 145 146 TypeClass type_class = static_cast<TypeClass>(type_mask); 147 TypeList type_list; 148 symfile->GetTypes(m_opaque_ptr, type_class, type_list); 149 sb_type_list.m_opaque_up->Append(type_list); 150 return LLDB_RECORD_RESULT(sb_type_list); 151 } 152 153 SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const { 154 LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, 155 GetSupportFileAtIndex, (uint32_t), idx); 156 157 SBFileSpec sb_file_spec; 158 if (m_opaque_ptr) { 159 FileSpec spec = m_opaque_ptr->GetSupportFiles().GetFileSpecAtIndex(idx); 160 sb_file_spec.SetFileSpec(spec); 161 } 162 163 164 return LLDB_RECORD_RESULT(sb_file_spec); 165 } 166 167 uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx, 168 const SBFileSpec &sb_file, 169 bool full) { 170 LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex, 171 (uint32_t, const lldb::SBFileSpec &, bool), start_idx, 172 sb_file, full); 173 174 if (m_opaque_ptr) { 175 const FileSpecList &support_files = m_opaque_ptr->GetSupportFiles(); 176 return support_files.FindFileIndex(start_idx, sb_file.ref(), full); 177 } 178 return 0; 179 } 180 181 lldb::LanguageType SBCompileUnit::GetLanguage() { 182 LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage); 183 184 if (m_opaque_ptr) 185 return m_opaque_ptr->GetLanguage(); 186 return lldb::eLanguageTypeUnknown; 187 } 188 189 bool SBCompileUnit::IsValid() const { 190 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid); 191 return this->operator bool(); 192 } 193 SBCompileUnit::operator bool() const { 194 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool); 195 196 return m_opaque_ptr != nullptr; 197 } 198 199 bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const { 200 LLDB_RECORD_METHOD_CONST( 201 bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs); 202 203 return m_opaque_ptr == rhs.m_opaque_ptr; 204 } 205 206 bool SBCompileUnit::operator!=(const SBCompileUnit &rhs) const { 207 LLDB_RECORD_METHOD_CONST( 208 bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &), rhs); 209 210 return m_opaque_ptr != rhs.m_opaque_ptr; 211 } 212 213 const lldb_private::CompileUnit *SBCompileUnit::operator->() const { 214 return m_opaque_ptr; 215 } 216 217 const lldb_private::CompileUnit &SBCompileUnit::operator*() const { 218 return *m_opaque_ptr; 219 } 220 221 lldb_private::CompileUnit *SBCompileUnit::get() { return m_opaque_ptr; } 222 223 void SBCompileUnit::reset(lldb_private::CompileUnit *lldb_object_ptr) { 224 m_opaque_ptr = lldb_object_ptr; 225 } 226 227 bool SBCompileUnit::GetDescription(SBStream &description) { 228 LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &), 229 description); 230 231 Stream &strm = description.ref(); 232 233 if (m_opaque_ptr) { 234 m_opaque_ptr->Dump(&strm, false); 235 } else 236 strm.PutCString("No value"); 237 238 return true; 239 } 240 241 namespace lldb_private { 242 namespace repro { 243 244 template <> 245 void RegisterMethods<SBCompileUnit>(Registry &R) { 246 LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ()); 247 LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &)); 248 LLDB_REGISTER_METHOD( 249 const lldb::SBCompileUnit &, 250 SBCompileUnit, operator=,(const lldb::SBCompileUnit &)); 251 LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec, 252 ()); 253 LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ()); 254 LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, 255 GetLineEntryAtIndex, (uint32_t)); 256 LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, 257 (uint32_t, uint32_t, lldb::SBFileSpec *)); 258 LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, 259 (uint32_t, uint32_t, lldb::SBFileSpec *, bool)); 260 LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ()); 261 LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t)); 262 LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, 263 GetSupportFileAtIndex, (uint32_t)); 264 LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex, 265 (uint32_t, const lldb::SBFileSpec &, bool)); 266 LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ()); 267 LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ()); 268 LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ()); 269 LLDB_REGISTER_METHOD_CONST( 270 bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &)); 271 LLDB_REGISTER_METHOD_CONST( 272 bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &)); 273 LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription, 274 (lldb::SBStream &)); 275 } 276 277 } 278 } 279