1 //===-- Type.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 <cstdio>
10 #include <optional>
11 
12 #include "lldb/Core/Module.h"
13 #include "lldb/Utility/DataBufferHeap.h"
14 #include "lldb/Utility/DataExtractor.h"
15 #include "lldb/Utility/LLDBLog.h"
16 #include "lldb/Utility/Log.h"
17 #include "lldb/Utility/Scalar.h"
18 #include "lldb/Utility/StreamString.h"
19 
20 #include "lldb/Symbol/CompilerType.h"
21 #include "lldb/Symbol/ObjectFile.h"
22 #include "lldb/Symbol/SymbolContextScope.h"
23 #include "lldb/Symbol/SymbolFile.h"
24 #include "lldb/Symbol/SymbolVendor.h"
25 #include "lldb/Symbol/Type.h"
26 #include "lldb/Symbol/TypeList.h"
27 #include "lldb/Symbol/TypeSystem.h"
28 
29 #include "lldb/Target/ExecutionContext.h"
30 #include "lldb/Target/Process.h"
31 #include "lldb/Target/Target.h"
32 
33 #include "llvm/ADT/StringRef.h"
34 
35 using namespace lldb;
36 using namespace lldb_private;
37 
contextMatches(llvm::ArrayRef<CompilerContext> context_chain,llvm::ArrayRef<CompilerContext> pattern)38 bool lldb_private::contextMatches(llvm::ArrayRef<CompilerContext> context_chain,
39                                   llvm::ArrayRef<CompilerContext> pattern) {
40   auto ctx = context_chain.begin();
41   auto ctx_end = context_chain.end();
42   for (const CompilerContext &pat : pattern) {
43     // Early exit if the pattern is too long.
44     if (ctx == ctx_end)
45       return false;
46     if (*ctx != pat) {
47       // Skip any number of module matches.
48       if (pat.kind == CompilerContextKind::AnyModule) {
49         // Greedily match 0..n modules.
50         ctx = std::find_if(ctx, ctx_end, [](const CompilerContext &ctx) {
51           return ctx.kind != CompilerContextKind::Module;
52         });
53         continue;
54       }
55       // See if there is a kind mismatch; they should have 1 bit in common.
56       if (((uint16_t)ctx->kind & (uint16_t)pat.kind) == 0)
57         return false;
58       // The name is ignored for AnyModule, but not for AnyType.
59       if (pat.kind != CompilerContextKind::AnyModule && ctx->name != pat.name)
60         return false;
61     }
62     ++ctx;
63   }
64   return true;
65 }
66 
ConvertTypeClass(lldb::TypeClass type_class)67 static CompilerContextKind ConvertTypeClass(lldb::TypeClass type_class) {
68   if (type_class == eTypeClassAny)
69     return CompilerContextKind::AnyType;
70   uint16_t result = 0;
71   if (type_class & lldb::eTypeClassClass)
72     result |= (uint16_t)CompilerContextKind::Class;
73   if (type_class & lldb::eTypeClassStruct)
74     result |= (uint16_t)CompilerContextKind::Struct;
75   if (type_class & lldb::eTypeClassUnion)
76     result |= (uint16_t)CompilerContextKind::Union;
77   if (type_class & lldb::eTypeClassEnumeration)
78     result |= (uint16_t)CompilerContextKind::Enum;
79   if (type_class & lldb::eTypeClassFunction)
80     result |= (uint16_t)CompilerContextKind::Function;
81   if (type_class & lldb::eTypeClassTypedef)
82     result |= (uint16_t)CompilerContextKind::Typedef;
83   return (CompilerContextKind)result;
84 }
85 
TypeQuery(llvm::StringRef name,TypeQueryOptions options)86 TypeQuery::TypeQuery(llvm::StringRef name, TypeQueryOptions options)
87     : m_options(options) {
88   llvm::StringRef scope, basename;
89   lldb::TypeClass type_class = lldb::eTypeClassAny;
90   if (Type::GetTypeScopeAndBasename(name, scope, basename, type_class)) {
91     if (scope.consume_front("::"))
92       m_options |= e_exact_match;
93     if (!scope.empty()) {
94       std::pair<llvm::StringRef, llvm::StringRef> scope_pair =
95           scope.split("::");
96       while (!scope_pair.second.empty()) {
97         m_context.push_back({CompilerContextKind::AnyDeclContext,
98                              ConstString(scope_pair.first.str())});
99         scope_pair = scope_pair.second.split("::");
100       }
101       m_context.push_back({CompilerContextKind::AnyDeclContext,
102                            ConstString(scope_pair.first.str())});
103     }
104     m_context.push_back(
105         {ConvertTypeClass(type_class), ConstString(basename.str())});
106   } else {
107     m_context.push_back(
108         {CompilerContextKind::AnyType, ConstString(name.str())});
109   }
110 }
111 
TypeQuery(const CompilerDeclContext & decl_ctx,ConstString type_basename,TypeQueryOptions options)112 TypeQuery::TypeQuery(const CompilerDeclContext &decl_ctx,
113                      ConstString type_basename, TypeQueryOptions options)
114     : m_options(options) {
115   // Always use an exact match if we are looking for a type in compiler context.
116   m_options |= e_exact_match;
117   m_context = decl_ctx.GetCompilerContext();
118   m_context.push_back({CompilerContextKind::AnyType, type_basename});
119 }
120 
TypeQuery(const llvm::ArrayRef<lldb_private::CompilerContext> & context,TypeQueryOptions options)121 TypeQuery::TypeQuery(
122     const llvm::ArrayRef<lldb_private::CompilerContext> &context,
123     TypeQueryOptions options)
124     : m_context(context), m_options(options) {
125   // Always use an exact match if we are looking for a type in compiler context.
126   m_options |= e_exact_match;
127 }
128 
TypeQuery(const CompilerDecl & decl,TypeQueryOptions options)129 TypeQuery::TypeQuery(const CompilerDecl &decl, TypeQueryOptions options)
130     : m_options(options) {
131   // Always for an exact match if we are looking for a type using a declaration.
132   m_options |= e_exact_match;
133   m_context = decl.GetCompilerContext();
134 }
135 
GetTypeBasename() const136 ConstString TypeQuery::GetTypeBasename() const {
137   if (m_context.empty())
138     return ConstString();
139   return m_context.back().name;
140 }
141 
AddLanguage(LanguageType language)142 void TypeQuery::AddLanguage(LanguageType language) {
143   if (!m_languages)
144     m_languages = LanguageSet();
145   m_languages->Insert(language);
146 }
147 
SetLanguages(LanguageSet languages)148 void TypeQuery::SetLanguages(LanguageSet languages) {
149   m_languages = std::move(languages);
150 }
151 
ContextMatches(llvm::ArrayRef<CompilerContext> context_chain) const152 bool TypeQuery::ContextMatches(
153     llvm::ArrayRef<CompilerContext> context_chain) const {
154   if (GetExactMatch() || context_chain.size() == m_context.size())
155     return ::contextMatches(context_chain, m_context);
156 
157   // We don't have an exact match, we need to bottom m_context.size() items to
158   // match for a successful lookup.
159   if (context_chain.size() < m_context.size())
160     return false; // Not enough items in context_chain to allow for a match.
161 
162   size_t compare_count = context_chain.size() - m_context.size();
163   return ::contextMatches(
164       llvm::ArrayRef<CompilerContext>(context_chain.data() + compare_count,
165                                       m_context.size()),
166       m_context);
167 }
168 
LanguageMatches(lldb::LanguageType language) const169 bool TypeQuery::LanguageMatches(lldb::LanguageType language) const {
170   // If we have no language filterm language always matches.
171   if (!m_languages.has_value())
172     return true;
173   return (*m_languages)[language];
174 }
175 
AlreadySearched(lldb_private::SymbolFile * sym_file)176 bool TypeResults::AlreadySearched(lldb_private::SymbolFile *sym_file) {
177   return !m_searched_symbol_files.insert(sym_file).second;
178 }
179 
InsertUnique(const lldb::TypeSP & type_sp)180 bool TypeResults::InsertUnique(const lldb::TypeSP &type_sp) {
181   if (type_sp)
182     return m_type_map.InsertUnique(type_sp);
183   return false;
184 }
185 
Done(const TypeQuery & query) const186 bool TypeResults::Done(const TypeQuery &query) const {
187   if (query.GetFindOne())
188     return !m_type_map.Empty();
189   return false;
190 }
191 
Dump(Stream & s) const192 void CompilerContext::Dump(Stream &s) const {
193   switch (kind) {
194   default:
195     s << "Invalid";
196     break;
197   case CompilerContextKind::TranslationUnit:
198     s << "TranslationUnit";
199     break;
200   case CompilerContextKind::Module:
201     s << "Module";
202     break;
203   case CompilerContextKind::Namespace:
204     s << "Namespace";
205     break;
206   case CompilerContextKind::Class:
207     s << "Class";
208     break;
209   case CompilerContextKind::Struct:
210     s << "Structure";
211     break;
212   case CompilerContextKind::Union:
213     s << "Union";
214     break;
215   case CompilerContextKind::Function:
216     s << "Function";
217     break;
218   case CompilerContextKind::Variable:
219     s << "Variable";
220     break;
221   case CompilerContextKind::Enum:
222     s << "Enumeration";
223     break;
224   case CompilerContextKind::Typedef:
225     s << "Typedef";
226     break;
227   case CompilerContextKind::AnyModule:
228     s << "AnyModule";
229     break;
230   case CompilerContextKind::AnyType:
231     s << "AnyType";
232     break;
233   }
234   s << "(" << name << ")";
235 }
236 
237 class TypeAppendVisitor {
238 public:
TypeAppendVisitor(TypeListImpl & type_list)239   TypeAppendVisitor(TypeListImpl &type_list) : m_type_list(type_list) {}
240 
operator ()(const lldb::TypeSP & type)241   bool operator()(const lldb::TypeSP &type) {
242     m_type_list.Append(TypeImplSP(new TypeImpl(type)));
243     return true;
244   }
245 
246 private:
247   TypeListImpl &m_type_list;
248 };
249 
Append(const lldb_private::TypeList & type_list)250 void TypeListImpl::Append(const lldb_private::TypeList &type_list) {
251   TypeAppendVisitor cb(*this);
252   type_list.ForEach(cb);
253 }
254 
SymbolFileType(SymbolFile & symbol_file,const lldb::TypeSP & type_sp)255 SymbolFileType::SymbolFileType(SymbolFile &symbol_file,
256                                const lldb::TypeSP &type_sp)
257     : UserID(type_sp ? type_sp->GetID() : LLDB_INVALID_UID),
258       m_symbol_file(symbol_file), m_type_sp(type_sp) {}
259 
GetType()260 Type *SymbolFileType::GetType() {
261   if (!m_type_sp) {
262     Type *resolved_type = m_symbol_file.ResolveTypeUID(GetID());
263     if (resolved_type)
264       m_type_sp = resolved_type->shared_from_this();
265   }
266   return m_type_sp.get();
267 }
268 
Type(lldb::user_id_t uid,SymbolFile * symbol_file,ConstString name,std::optional<uint64_t> byte_size,SymbolContextScope * context,user_id_t encoding_uid,EncodingDataType encoding_uid_type,const Declaration & decl,const CompilerType & compiler_type,ResolveState compiler_type_resolve_state,uint32_t opaque_payload)269 Type::Type(lldb::user_id_t uid, SymbolFile *symbol_file, ConstString name,
270            std::optional<uint64_t> byte_size, SymbolContextScope *context,
271            user_id_t encoding_uid, EncodingDataType encoding_uid_type,
272            const Declaration &decl, const CompilerType &compiler_type,
273            ResolveState compiler_type_resolve_state, uint32_t opaque_payload)
274     : std::enable_shared_from_this<Type>(), UserID(uid), m_name(name),
275       m_symbol_file(symbol_file), m_context(context),
276       m_encoding_uid(encoding_uid), m_encoding_uid_type(encoding_uid_type),
277       m_decl(decl), m_compiler_type(compiler_type),
278       m_compiler_type_resolve_state(compiler_type ? compiler_type_resolve_state
279                                                   : ResolveState::Unresolved),
280       m_payload(opaque_payload) {
281   if (byte_size) {
282     m_byte_size = *byte_size;
283     m_byte_size_has_value = true;
284   } else {
285     m_byte_size = 0;
286     m_byte_size_has_value = false;
287   }
288 }
289 
Type()290 Type::Type()
291     : std::enable_shared_from_this<Type>(), UserID(0), m_name("<INVALID TYPE>"),
292       m_payload(0) {
293   m_byte_size = 0;
294   m_byte_size_has_value = false;
295 }
296 
GetDescription(Stream * s,lldb::DescriptionLevel level,bool show_name,ExecutionContextScope * exe_scope)297 void Type::GetDescription(Stream *s, lldb::DescriptionLevel level,
298                           bool show_name, ExecutionContextScope *exe_scope) {
299   *s << "id = " << (const UserID &)*this;
300 
301   // Call the name accessor to make sure we resolve the type name
302   if (show_name) {
303     ConstString type_name = GetName();
304     if (type_name) {
305       *s << ", name = \"" << type_name << '"';
306       ConstString qualified_type_name(GetQualifiedName());
307       if (qualified_type_name != type_name) {
308         *s << ", qualified = \"" << qualified_type_name << '"';
309       }
310     }
311   }
312 
313   // Call the get byte size accessor so we resolve our byte size
314   if (GetByteSize(exe_scope))
315     s->Printf(", byte-size = %" PRIu64, m_byte_size);
316   bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose);
317   m_decl.Dump(s, show_fullpaths);
318 
319   if (m_compiler_type.IsValid()) {
320     *s << ", compiler_type = \"";
321     GetForwardCompilerType().DumpTypeDescription(s);
322     *s << '"';
323   } else if (m_encoding_uid != LLDB_INVALID_UID) {
324     s->Printf(", type_uid = 0x%8.8" PRIx64, m_encoding_uid);
325     switch (m_encoding_uid_type) {
326     case eEncodingInvalid:
327       break;
328     case eEncodingIsUID:
329       s->PutCString(" (unresolved type)");
330       break;
331     case eEncodingIsConstUID:
332       s->PutCString(" (unresolved const type)");
333       break;
334     case eEncodingIsRestrictUID:
335       s->PutCString(" (unresolved restrict type)");
336       break;
337     case eEncodingIsVolatileUID:
338       s->PutCString(" (unresolved volatile type)");
339       break;
340     case eEncodingIsAtomicUID:
341       s->PutCString(" (unresolved atomic type)");
342       break;
343     case eEncodingIsTypedefUID:
344       s->PutCString(" (unresolved typedef)");
345       break;
346     case eEncodingIsPointerUID:
347       s->PutCString(" (unresolved pointer)");
348       break;
349     case eEncodingIsLValueReferenceUID:
350       s->PutCString(" (unresolved L value reference)");
351       break;
352     case eEncodingIsRValueReferenceUID:
353       s->PutCString(" (unresolved R value reference)");
354       break;
355     case eEncodingIsSyntheticUID:
356       s->PutCString(" (synthetic type)");
357       break;
358     }
359   }
360 }
361 
Dump(Stream * s,bool show_context,lldb::DescriptionLevel level)362 void Type::Dump(Stream *s, bool show_context, lldb::DescriptionLevel level) {
363   s->Printf("%p: ", static_cast<void *>(this));
364   s->Indent();
365   *s << "Type" << static_cast<const UserID &>(*this) << ' ';
366   if (m_name)
367     *s << ", name = \"" << m_name << "\"";
368 
369   if (m_byte_size_has_value)
370     s->Printf(", size = %" PRIu64, m_byte_size);
371 
372   if (show_context && m_context != nullptr) {
373     s->PutCString(", context = ( ");
374     m_context->DumpSymbolContext(s);
375     s->PutCString(" )");
376   }
377 
378   bool show_fullpaths = false;
379   m_decl.Dump(s, show_fullpaths);
380 
381   if (m_compiler_type.IsValid()) {
382     *s << ", compiler_type = " << m_compiler_type.GetOpaqueQualType() << ' ';
383     GetForwardCompilerType().DumpTypeDescription(s, level);
384   } else if (m_encoding_uid != LLDB_INVALID_UID) {
385     s->Format(", type_data = {0:x-16}", m_encoding_uid);
386     switch (m_encoding_uid_type) {
387     case eEncodingInvalid:
388       break;
389     case eEncodingIsUID:
390       s->PutCString(" (unresolved type)");
391       break;
392     case eEncodingIsConstUID:
393       s->PutCString(" (unresolved const type)");
394       break;
395     case eEncodingIsRestrictUID:
396       s->PutCString(" (unresolved restrict type)");
397       break;
398     case eEncodingIsVolatileUID:
399       s->PutCString(" (unresolved volatile type)");
400       break;
401     case eEncodingIsAtomicUID:
402       s->PutCString(" (unresolved atomic type)");
403       break;
404     case eEncodingIsTypedefUID:
405       s->PutCString(" (unresolved typedef)");
406       break;
407     case eEncodingIsPointerUID:
408       s->PutCString(" (unresolved pointer)");
409       break;
410     case eEncodingIsLValueReferenceUID:
411       s->PutCString(" (unresolved L value reference)");
412       break;
413     case eEncodingIsRValueReferenceUID:
414       s->PutCString(" (unresolved R value reference)");
415       break;
416     case eEncodingIsSyntheticUID:
417       s->PutCString(" (synthetic type)");
418       break;
419     }
420   }
421 
422   //
423   //  if (m_access)
424   //      s->Printf(", access = %u", m_access);
425   s->EOL();
426 }
427 
GetName()428 ConstString Type::GetName() {
429   if (!m_name)
430     m_name = GetForwardCompilerType().GetTypeName();
431   return m_name;
432 }
433 
GetBaseName()434 ConstString Type::GetBaseName() {
435   return GetForwardCompilerType().GetTypeName(/*BaseOnly*/ true);
436 }
437 
DumpTypeName(Stream * s)438 void Type::DumpTypeName(Stream *s) { GetName().Dump(s, "<invalid-type-name>"); }
439 
GetEncodingType()440 Type *Type::GetEncodingType() {
441   if (m_encoding_type == nullptr && m_encoding_uid != LLDB_INVALID_UID)
442     m_encoding_type = m_symbol_file->ResolveTypeUID(m_encoding_uid);
443   return m_encoding_type;
444 }
445 
GetByteSize(ExecutionContextScope * exe_scope)446 std::optional<uint64_t> Type::GetByteSize(ExecutionContextScope *exe_scope) {
447   if (m_byte_size_has_value)
448     return static_cast<uint64_t>(m_byte_size);
449 
450   switch (m_encoding_uid_type) {
451   case eEncodingInvalid:
452   case eEncodingIsSyntheticUID:
453     break;
454   case eEncodingIsUID:
455   case eEncodingIsConstUID:
456   case eEncodingIsRestrictUID:
457   case eEncodingIsVolatileUID:
458   case eEncodingIsAtomicUID:
459   case eEncodingIsTypedefUID: {
460     Type *encoding_type = GetEncodingType();
461     if (encoding_type)
462       if (std::optional<uint64_t> size =
463               encoding_type->GetByteSize(exe_scope)) {
464         m_byte_size = *size;
465         m_byte_size_has_value = true;
466         return static_cast<uint64_t>(m_byte_size);
467       }
468 
469     if (std::optional<uint64_t> size =
470             GetLayoutCompilerType().GetByteSize(exe_scope)) {
471       m_byte_size = *size;
472       m_byte_size_has_value = true;
473       return static_cast<uint64_t>(m_byte_size);
474     }
475   } break;
476 
477     // If we are a pointer or reference, then this is just a pointer size;
478     case eEncodingIsPointerUID:
479     case eEncodingIsLValueReferenceUID:
480     case eEncodingIsRValueReferenceUID: {
481       if (ArchSpec arch = m_symbol_file->GetObjectFile()->GetArchitecture()) {
482         m_byte_size = arch.GetAddressByteSize();
483         m_byte_size_has_value = true;
484         return static_cast<uint64_t>(m_byte_size);
485       }
486     } break;
487   }
488   return {};
489 }
490 
GetNumChildren(bool omit_empty_base_classes)491 uint32_t Type::GetNumChildren(bool omit_empty_base_classes) {
492   return GetForwardCompilerType().GetNumChildren(omit_empty_base_classes, nullptr);
493 }
494 
IsAggregateType()495 bool Type::IsAggregateType() {
496   return GetForwardCompilerType().IsAggregateType();
497 }
498 
IsTemplateType()499 bool Type::IsTemplateType() {
500   return GetForwardCompilerType().IsTemplateType();
501 }
502 
GetTypedefType()503 lldb::TypeSP Type::GetTypedefType() {
504   lldb::TypeSP type_sp;
505   if (IsTypedef()) {
506     Type *typedef_type = m_symbol_file->ResolveTypeUID(m_encoding_uid);
507     if (typedef_type)
508       type_sp = typedef_type->shared_from_this();
509   }
510   return type_sp;
511 }
512 
GetFormat()513 lldb::Format Type::GetFormat() { return GetForwardCompilerType().GetFormat(); }
514 
GetEncoding(uint64_t & count)515 lldb::Encoding Type::GetEncoding(uint64_t &count) {
516   // Make sure we resolve our type if it already hasn't been.
517   return GetForwardCompilerType().GetEncoding(count);
518 }
519 
ReadFromMemory(ExecutionContext * exe_ctx,lldb::addr_t addr,AddressType address_type,DataExtractor & data)520 bool Type::ReadFromMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
521                           AddressType address_type, DataExtractor &data) {
522   if (address_type == eAddressTypeFile) {
523     // Can't convert a file address to anything valid without more context
524     // (which Module it came from)
525     return false;
526   }
527 
528   const uint64_t byte_size =
529       GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr)
530           .value_or(0);
531   if (data.GetByteSize() < byte_size) {
532     lldb::DataBufferSP data_sp(new DataBufferHeap(byte_size, '\0'));
533     data.SetData(data_sp);
534   }
535 
536   uint8_t *dst = const_cast<uint8_t *>(data.PeekData(0, byte_size));
537   if (dst != nullptr) {
538     if (address_type == eAddressTypeHost) {
539       // The address is an address in this process, so just copy it
540       if (addr == 0)
541         return false;
542       memcpy(dst, reinterpret_cast<uint8_t *>(addr), byte_size);
543       return true;
544     } else {
545       if (exe_ctx) {
546         Process *process = exe_ctx->GetProcessPtr();
547         if (process) {
548           Status error;
549           return exe_ctx->GetProcessPtr()->ReadMemory(addr, dst, byte_size,
550                                                       error) == byte_size;
551         }
552       }
553     }
554   }
555   return false;
556 }
557 
WriteToMemory(ExecutionContext * exe_ctx,lldb::addr_t addr,AddressType address_type,DataExtractor & data)558 bool Type::WriteToMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
559                          AddressType address_type, DataExtractor &data) {
560   return false;
561 }
562 
GetDeclaration() const563 const Declaration &Type::GetDeclaration() const { return m_decl; }
564 
ResolveCompilerType(ResolveState compiler_type_resolve_state)565 bool Type::ResolveCompilerType(ResolveState compiler_type_resolve_state) {
566   // TODO: This needs to consider the correct type system to use.
567   Type *encoding_type = nullptr;
568   if (!m_compiler_type.IsValid()) {
569     encoding_type = GetEncodingType();
570     if (encoding_type) {
571       switch (m_encoding_uid_type) {
572       case eEncodingIsUID: {
573         CompilerType encoding_compiler_type =
574             encoding_type->GetForwardCompilerType();
575         if (encoding_compiler_type.IsValid()) {
576           m_compiler_type = encoding_compiler_type;
577           m_compiler_type_resolve_state =
578               encoding_type->m_compiler_type_resolve_state;
579         }
580       } break;
581 
582       case eEncodingIsConstUID:
583         m_compiler_type =
584             encoding_type->GetForwardCompilerType().AddConstModifier();
585         break;
586 
587       case eEncodingIsRestrictUID:
588         m_compiler_type =
589             encoding_type->GetForwardCompilerType().AddRestrictModifier();
590         break;
591 
592       case eEncodingIsVolatileUID:
593         m_compiler_type =
594             encoding_type->GetForwardCompilerType().AddVolatileModifier();
595         break;
596 
597       case eEncodingIsAtomicUID:
598         m_compiler_type =
599             encoding_type->GetForwardCompilerType().GetAtomicType();
600         break;
601 
602       case eEncodingIsTypedefUID:
603         m_compiler_type = encoding_type->GetForwardCompilerType().CreateTypedef(
604             m_name.AsCString("__lldb_invalid_typedef_name"),
605             GetSymbolFile()->GetDeclContextContainingUID(GetID()), m_payload);
606         m_name.Clear();
607         break;
608 
609       case eEncodingIsPointerUID:
610         m_compiler_type =
611             encoding_type->GetForwardCompilerType().GetPointerType();
612         break;
613 
614       case eEncodingIsLValueReferenceUID:
615         m_compiler_type =
616             encoding_type->GetForwardCompilerType().GetLValueReferenceType();
617         break;
618 
619       case eEncodingIsRValueReferenceUID:
620         m_compiler_type =
621             encoding_type->GetForwardCompilerType().GetRValueReferenceType();
622         break;
623 
624       default:
625         llvm_unreachable("Unhandled encoding_data_type.");
626       }
627     } else {
628       // We have no encoding type, return void?
629       auto type_system_or_err =
630           m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC);
631       if (auto err = type_system_or_err.takeError()) {
632         LLDB_LOG_ERROR(
633             GetLog(LLDBLog::Symbols), std::move(err),
634             "Unable to construct void type from TypeSystemClang: {0}");
635       } else {
636         CompilerType void_compiler_type;
637         auto ts = *type_system_or_err;
638         if (ts)
639           void_compiler_type = ts->GetBasicTypeFromAST(eBasicTypeVoid);
640         switch (m_encoding_uid_type) {
641         case eEncodingIsUID:
642           m_compiler_type = void_compiler_type;
643           break;
644 
645         case eEncodingIsConstUID:
646           m_compiler_type = void_compiler_type.AddConstModifier();
647           break;
648 
649         case eEncodingIsRestrictUID:
650           m_compiler_type = void_compiler_type.AddRestrictModifier();
651           break;
652 
653         case eEncodingIsVolatileUID:
654           m_compiler_type = void_compiler_type.AddVolatileModifier();
655           break;
656 
657         case eEncodingIsAtomicUID:
658           m_compiler_type = void_compiler_type.GetAtomicType();
659           break;
660 
661         case eEncodingIsTypedefUID:
662           m_compiler_type = void_compiler_type.CreateTypedef(
663               m_name.AsCString("__lldb_invalid_typedef_name"),
664               GetSymbolFile()->GetDeclContextContainingUID(GetID()), m_payload);
665           break;
666 
667         case eEncodingIsPointerUID:
668           m_compiler_type = void_compiler_type.GetPointerType();
669           break;
670 
671         case eEncodingIsLValueReferenceUID:
672           m_compiler_type = void_compiler_type.GetLValueReferenceType();
673           break;
674 
675         case eEncodingIsRValueReferenceUID:
676           m_compiler_type = void_compiler_type.GetRValueReferenceType();
677           break;
678 
679         default:
680           llvm_unreachable("Unhandled encoding_data_type.");
681         }
682       }
683     }
684 
685     // When we have a EncodingUID, our "m_flags.compiler_type_resolve_state" is
686     // set to eResolveStateUnresolved so we need to update it to say that we
687     // now have a forward declaration since that is what we created above.
688     if (m_compiler_type.IsValid())
689       m_compiler_type_resolve_state = ResolveState::Forward;
690   }
691 
692   // Check if we have a forward reference to a class/struct/union/enum?
693   if (compiler_type_resolve_state == ResolveState::Layout ||
694       compiler_type_resolve_state == ResolveState::Full) {
695     // Check if we have a forward reference to a class/struct/union/enum?
696     if (m_compiler_type.IsValid() &&
697         m_compiler_type_resolve_state < compiler_type_resolve_state) {
698       m_compiler_type_resolve_state = ResolveState::Full;
699       if (!m_compiler_type.IsDefined()) {
700         // We have a forward declaration, we need to resolve it to a complete
701         // definition.
702         m_symbol_file->CompleteType(m_compiler_type);
703       }
704     }
705   }
706 
707   // If we have an encoding type, then we need to make sure it is resolved
708   // appropriately.
709   if (m_encoding_uid != LLDB_INVALID_UID) {
710     if (encoding_type == nullptr)
711       encoding_type = GetEncodingType();
712     if (encoding_type) {
713       ResolveState encoding_compiler_type_resolve_state =
714           compiler_type_resolve_state;
715 
716       if (compiler_type_resolve_state == ResolveState::Layout) {
717         switch (m_encoding_uid_type) {
718         case eEncodingIsPointerUID:
719         case eEncodingIsLValueReferenceUID:
720         case eEncodingIsRValueReferenceUID:
721           encoding_compiler_type_resolve_state = ResolveState::Forward;
722           break;
723         default:
724           break;
725         }
726       }
727       encoding_type->ResolveCompilerType(encoding_compiler_type_resolve_state);
728     }
729   }
730   return m_compiler_type.IsValid();
731 }
GetEncodingMask()732 uint32_t Type::GetEncodingMask() {
733   uint32_t encoding_mask = 1u << m_encoding_uid_type;
734   Type *encoding_type = GetEncodingType();
735   assert(encoding_type != this);
736   if (encoding_type)
737     encoding_mask |= encoding_type->GetEncodingMask();
738   return encoding_mask;
739 }
740 
GetFullCompilerType()741 CompilerType Type::GetFullCompilerType() {
742   ResolveCompilerType(ResolveState::Full);
743   return m_compiler_type;
744 }
745 
GetLayoutCompilerType()746 CompilerType Type::GetLayoutCompilerType() {
747   ResolveCompilerType(ResolveState::Layout);
748   return m_compiler_type;
749 }
750 
GetForwardCompilerType()751 CompilerType Type::GetForwardCompilerType() {
752   ResolveCompilerType(ResolveState::Forward);
753   return m_compiler_type;
754 }
755 
GetQualifiedName()756 ConstString Type::GetQualifiedName() {
757   return GetForwardCompilerType().GetTypeName();
758 }
759 
GetTypeScopeAndBasename(llvm::StringRef name,llvm::StringRef & scope,llvm::StringRef & basename,TypeClass & type_class)760 bool Type::GetTypeScopeAndBasename(llvm::StringRef name,
761                                    llvm::StringRef &scope,
762                                    llvm::StringRef &basename,
763                                    TypeClass &type_class) {
764   type_class = eTypeClassAny;
765 
766   if (name.empty())
767     return false;
768 
769   // Clear the scope in case we have just a type class and a basename.
770   scope = llvm::StringRef();
771   basename = name;
772   if (basename.consume_front("struct "))
773     type_class = eTypeClassStruct;
774   else if (basename.consume_front("class "))
775     type_class = eTypeClassClass;
776   else if (basename.consume_front("union "))
777     type_class = eTypeClassUnion;
778   else if (basename.consume_front("enum "))
779     type_class = eTypeClassEnumeration;
780   else if (basename.consume_front("typedef "))
781     type_class = eTypeClassTypedef;
782 
783   size_t namespace_separator = basename.find("::");
784   if (namespace_separator == llvm::StringRef::npos) {
785     // If "name" started a type class we need to return true with no scope.
786     return type_class != eTypeClassAny;
787   }
788 
789   size_t template_begin = basename.find('<');
790   while (namespace_separator != llvm::StringRef::npos) {
791     if (template_begin != llvm::StringRef::npos &&
792         namespace_separator > template_begin) {
793       size_t template_depth = 1;
794       llvm::StringRef template_arg =
795           basename.drop_front(template_begin + 1);
796       while (template_depth > 0 && !template_arg.empty()) {
797         if (template_arg.front() == '<')
798           template_depth++;
799         else if (template_arg.front() == '>')
800           template_depth--;
801         template_arg = template_arg.drop_front(1);
802       }
803       if (template_depth != 0)
804         return false; // We have an invalid type name. Bail out.
805       if (template_arg.empty())
806         break; // The template ends at the end of the full name.
807       basename = template_arg;
808     } else {
809       basename = basename.drop_front(namespace_separator + 2);
810     }
811     template_begin = basename.find('<');
812     namespace_separator = basename.find("::");
813   }
814   if (basename.size() < name.size()) {
815     scope = name.take_front(name.size() - basename.size());
816     return true;
817   }
818   return false;
819 }
820 
GetModule()821 ModuleSP Type::GetModule() {
822   if (m_symbol_file)
823     return m_symbol_file->GetObjectFile()->GetModule();
824   return ModuleSP();
825 }
826 
GetExeModule()827 ModuleSP Type::GetExeModule() {
828   if (m_compiler_type) {
829     auto ts = m_compiler_type.GetTypeSystem();
830     if (!ts)
831       return {};
832     SymbolFile *symbol_file = ts->GetSymbolFile();
833     if (symbol_file)
834       return symbol_file->GetObjectFile()->GetModule();
835   }
836   return {};
837 }
838 
TypeAndOrName(TypeSP & in_type_sp)839 TypeAndOrName::TypeAndOrName(TypeSP &in_type_sp) {
840   if (in_type_sp) {
841     m_compiler_type = in_type_sp->GetForwardCompilerType();
842     m_type_name = in_type_sp->GetName();
843   }
844 }
845 
TypeAndOrName(const char * in_type_str)846 TypeAndOrName::TypeAndOrName(const char *in_type_str)
847     : m_type_name(in_type_str) {}
848 
TypeAndOrName(ConstString & in_type_const_string)849 TypeAndOrName::TypeAndOrName(ConstString &in_type_const_string)
850     : m_type_name(in_type_const_string) {}
851 
operator ==(const TypeAndOrName & other) const852 bool TypeAndOrName::operator==(const TypeAndOrName &other) const {
853   if (m_compiler_type != other.m_compiler_type)
854     return false;
855   if (m_type_name != other.m_type_name)
856     return false;
857   return true;
858 }
859 
operator !=(const TypeAndOrName & other) const860 bool TypeAndOrName::operator!=(const TypeAndOrName &other) const {
861   return !(*this == other);
862 }
863 
GetName() const864 ConstString TypeAndOrName::GetName() const {
865   if (m_type_name)
866     return m_type_name;
867   if (m_compiler_type)
868     return m_compiler_type.GetTypeName();
869   return ConstString("<invalid>");
870 }
871 
SetName(ConstString type_name)872 void TypeAndOrName::SetName(ConstString type_name) {
873   m_type_name = type_name;
874 }
875 
SetName(const char * type_name_cstr)876 void TypeAndOrName::SetName(const char *type_name_cstr) {
877   m_type_name.SetCString(type_name_cstr);
878 }
879 
SetName(llvm::StringRef type_name)880 void TypeAndOrName::SetName(llvm::StringRef type_name) {
881   m_type_name.SetString(type_name);
882 }
883 
SetTypeSP(lldb::TypeSP type_sp)884 void TypeAndOrName::SetTypeSP(lldb::TypeSP type_sp) {
885   if (type_sp) {
886     m_compiler_type = type_sp->GetForwardCompilerType();
887     m_type_name = type_sp->GetName();
888   } else
889     Clear();
890 }
891 
SetCompilerType(CompilerType compiler_type)892 void TypeAndOrName::SetCompilerType(CompilerType compiler_type) {
893   m_compiler_type = compiler_type;
894   if (m_compiler_type)
895     m_type_name = m_compiler_type.GetTypeName();
896 }
897 
IsEmpty() const898 bool TypeAndOrName::IsEmpty() const {
899   return !((bool)m_type_name || (bool)m_compiler_type);
900 }
901 
Clear()902 void TypeAndOrName::Clear() {
903   m_type_name.Clear();
904   m_compiler_type.Clear();
905 }
906 
HasName() const907 bool TypeAndOrName::HasName() const { return (bool)m_type_name; }
908 
HasCompilerType() const909 bool TypeAndOrName::HasCompilerType() const {
910   return m_compiler_type.IsValid();
911 }
912 
TypeImpl(const lldb::TypeSP & type_sp)913 TypeImpl::TypeImpl(const lldb::TypeSP &type_sp)
914     : m_module_wp(), m_static_type(), m_dynamic_type() {
915   SetType(type_sp);
916 }
917 
TypeImpl(const CompilerType & compiler_type)918 TypeImpl::TypeImpl(const CompilerType &compiler_type)
919     : m_module_wp(), m_static_type(), m_dynamic_type() {
920   SetType(compiler_type);
921 }
922 
TypeImpl(const lldb::TypeSP & type_sp,const CompilerType & dynamic)923 TypeImpl::TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic)
924     : m_module_wp(), m_static_type(), m_dynamic_type(dynamic) {
925   SetType(type_sp, dynamic);
926 }
927 
TypeImpl(const CompilerType & static_type,const CompilerType & dynamic_type)928 TypeImpl::TypeImpl(const CompilerType &static_type,
929                    const CompilerType &dynamic_type)
930     : m_module_wp(), m_static_type(), m_dynamic_type() {
931   SetType(static_type, dynamic_type);
932 }
933 
SetType(const lldb::TypeSP & type_sp)934 void TypeImpl::SetType(const lldb::TypeSP &type_sp) {
935   if (type_sp) {
936     m_static_type = type_sp->GetForwardCompilerType();
937     m_exe_module_wp = type_sp->GetExeModule();
938     m_module_wp = type_sp->GetModule();
939   } else {
940     m_static_type.Clear();
941     m_module_wp = lldb::ModuleWP();
942   }
943 }
944 
SetType(const CompilerType & compiler_type)945 void TypeImpl::SetType(const CompilerType &compiler_type) {
946   m_module_wp = lldb::ModuleWP();
947   m_static_type = compiler_type;
948 }
949 
SetType(const lldb::TypeSP & type_sp,const CompilerType & dynamic)950 void TypeImpl::SetType(const lldb::TypeSP &type_sp,
951                        const CompilerType &dynamic) {
952   SetType(type_sp);
953   m_dynamic_type = dynamic;
954 }
955 
SetType(const CompilerType & compiler_type,const CompilerType & dynamic)956 void TypeImpl::SetType(const CompilerType &compiler_type,
957                        const CompilerType &dynamic) {
958   m_module_wp = lldb::ModuleWP();
959   m_static_type = compiler_type;
960   m_dynamic_type = dynamic;
961 }
962 
CheckModule(lldb::ModuleSP & module_sp) const963 bool TypeImpl::CheckModule(lldb::ModuleSP &module_sp) const {
964   return CheckModuleCommon(m_module_wp, module_sp);
965 }
966 
CheckExeModule(lldb::ModuleSP & module_sp) const967 bool TypeImpl::CheckExeModule(lldb::ModuleSP &module_sp) const {
968   return CheckModuleCommon(m_exe_module_wp, module_sp);
969 }
970 
CheckModuleCommon(const lldb::ModuleWP & input_module_wp,lldb::ModuleSP & module_sp) const971 bool TypeImpl::CheckModuleCommon(const lldb::ModuleWP &input_module_wp,
972                                  lldb::ModuleSP &module_sp) const {
973   // Check if we have a module for this type. If we do and the shared pointer
974   // is can be successfully initialized with m_module_wp, return true. Else
975   // return false if we didn't have a module, or if we had a module and it has
976   // been deleted. Any functions doing anything with a TypeSP in this TypeImpl
977   // class should call this function and only do anything with the ivars if
978   // this function returns true. If we have a module, the "module_sp" will be
979   // filled in with a strong reference to the module so that the module will at
980   // least stay around long enough for the type query to succeed.
981   module_sp = input_module_wp.lock();
982   if (!module_sp) {
983     lldb::ModuleWP empty_module_wp;
984     // If either call to "std::weak_ptr::owner_before(...) value returns true,
985     // this indicates that m_module_wp once contained (possibly still does) a
986     // reference to a valid shared pointer. This helps us know if we had a
987     // valid reference to a section which is now invalid because the module it
988     // was in was deleted
989     if (empty_module_wp.owner_before(input_module_wp) ||
990         input_module_wp.owner_before(empty_module_wp)) {
991       // input_module_wp had a valid reference to a module, but all strong
992       // references have been released and the module has been deleted
993       return false;
994     }
995   }
996   // We either successfully locked the module, or didn't have one to begin with
997   return true;
998 }
999 
operator ==(const TypeImpl & rhs) const1000 bool TypeImpl::operator==(const TypeImpl &rhs) const {
1001   return m_static_type == rhs.m_static_type &&
1002          m_dynamic_type == rhs.m_dynamic_type;
1003 }
1004 
operator !=(const TypeImpl & rhs) const1005 bool TypeImpl::operator!=(const TypeImpl &rhs) const {
1006   return !(*this == rhs);
1007 }
1008 
IsValid() const1009 bool TypeImpl::IsValid() const {
1010   // just a name is not valid
1011   ModuleSP module_sp;
1012   if (CheckModule(module_sp))
1013     return m_static_type.IsValid() || m_dynamic_type.IsValid();
1014   return false;
1015 }
1016 
operator bool() const1017 TypeImpl::operator bool() const { return IsValid(); }
1018 
Clear()1019 void TypeImpl::Clear() {
1020   m_module_wp = lldb::ModuleWP();
1021   m_static_type.Clear();
1022   m_dynamic_type.Clear();
1023 }
1024 
GetModule() const1025 ModuleSP TypeImpl::GetModule() const {
1026   lldb::ModuleSP module_sp;
1027   if (CheckExeModule(module_sp))
1028     return module_sp;
1029   return nullptr;
1030 }
1031 
GetName() const1032 ConstString TypeImpl::GetName() const {
1033   ModuleSP module_sp;
1034   if (CheckModule(module_sp)) {
1035     if (m_dynamic_type)
1036       return m_dynamic_type.GetTypeName();
1037     return m_static_type.GetTypeName();
1038   }
1039   return ConstString();
1040 }
1041 
GetDisplayTypeName() const1042 ConstString TypeImpl::GetDisplayTypeName() const {
1043   ModuleSP module_sp;
1044   if (CheckModule(module_sp)) {
1045     if (m_dynamic_type)
1046       return m_dynamic_type.GetDisplayTypeName();
1047     return m_static_type.GetDisplayTypeName();
1048   }
1049   return ConstString();
1050 }
1051 
GetPointerType() const1052 TypeImpl TypeImpl::GetPointerType() const {
1053   ModuleSP module_sp;
1054   if (CheckModule(module_sp)) {
1055     if (m_dynamic_type.IsValid()) {
1056       return TypeImpl(m_static_type.GetPointerType(),
1057                       m_dynamic_type.GetPointerType());
1058     }
1059     return TypeImpl(m_static_type.GetPointerType());
1060   }
1061   return TypeImpl();
1062 }
1063 
GetPointeeType() const1064 TypeImpl TypeImpl::GetPointeeType() const {
1065   ModuleSP module_sp;
1066   if (CheckModule(module_sp)) {
1067     if (m_dynamic_type.IsValid()) {
1068       return TypeImpl(m_static_type.GetPointeeType(),
1069                       m_dynamic_type.GetPointeeType());
1070     }
1071     return TypeImpl(m_static_type.GetPointeeType());
1072   }
1073   return TypeImpl();
1074 }
1075 
GetReferenceType() const1076 TypeImpl TypeImpl::GetReferenceType() const {
1077   ModuleSP module_sp;
1078   if (CheckModule(module_sp)) {
1079     if (m_dynamic_type.IsValid()) {
1080       return TypeImpl(m_static_type.GetLValueReferenceType(),
1081                       m_dynamic_type.GetLValueReferenceType());
1082     }
1083     return TypeImpl(m_static_type.GetLValueReferenceType());
1084   }
1085   return TypeImpl();
1086 }
1087 
GetTypedefedType() const1088 TypeImpl TypeImpl::GetTypedefedType() const {
1089   ModuleSP module_sp;
1090   if (CheckModule(module_sp)) {
1091     if (m_dynamic_type.IsValid()) {
1092       return TypeImpl(m_static_type.GetTypedefedType(),
1093                       m_dynamic_type.GetTypedefedType());
1094     }
1095     return TypeImpl(m_static_type.GetTypedefedType());
1096   }
1097   return TypeImpl();
1098 }
1099 
GetDereferencedType() const1100 TypeImpl TypeImpl::GetDereferencedType() const {
1101   ModuleSP module_sp;
1102   if (CheckModule(module_sp)) {
1103     if (m_dynamic_type.IsValid()) {
1104       return TypeImpl(m_static_type.GetNonReferenceType(),
1105                       m_dynamic_type.GetNonReferenceType());
1106     }
1107     return TypeImpl(m_static_type.GetNonReferenceType());
1108   }
1109   return TypeImpl();
1110 }
1111 
GetUnqualifiedType() const1112 TypeImpl TypeImpl::GetUnqualifiedType() const {
1113   ModuleSP module_sp;
1114   if (CheckModule(module_sp)) {
1115     if (m_dynamic_type.IsValid()) {
1116       return TypeImpl(m_static_type.GetFullyUnqualifiedType(),
1117                       m_dynamic_type.GetFullyUnqualifiedType());
1118     }
1119     return TypeImpl(m_static_type.GetFullyUnqualifiedType());
1120   }
1121   return TypeImpl();
1122 }
1123 
GetCanonicalType() const1124 TypeImpl TypeImpl::GetCanonicalType() const {
1125   ModuleSP module_sp;
1126   if (CheckModule(module_sp)) {
1127     if (m_dynamic_type.IsValid()) {
1128       return TypeImpl(m_static_type.GetCanonicalType(),
1129                       m_dynamic_type.GetCanonicalType());
1130     }
1131     return TypeImpl(m_static_type.GetCanonicalType());
1132   }
1133   return TypeImpl();
1134 }
1135 
GetCompilerType(bool prefer_dynamic)1136 CompilerType TypeImpl::GetCompilerType(bool prefer_dynamic) {
1137   ModuleSP module_sp;
1138   if (CheckModule(module_sp)) {
1139     if (prefer_dynamic) {
1140       if (m_dynamic_type.IsValid())
1141         return m_dynamic_type;
1142     }
1143     return m_static_type;
1144   }
1145   return CompilerType();
1146 }
1147 
GetTypeSystem(bool prefer_dynamic)1148 CompilerType::TypeSystemSPWrapper TypeImpl::GetTypeSystem(bool prefer_dynamic) {
1149   ModuleSP module_sp;
1150   if (CheckModule(module_sp)) {
1151     if (prefer_dynamic) {
1152       if (m_dynamic_type.IsValid())
1153         return m_dynamic_type.GetTypeSystem();
1154     }
1155     return m_static_type.GetTypeSystem();
1156   }
1157   return {};
1158 }
1159 
GetDescription(lldb_private::Stream & strm,lldb::DescriptionLevel description_level)1160 bool TypeImpl::GetDescription(lldb_private::Stream &strm,
1161                               lldb::DescriptionLevel description_level) {
1162   ModuleSP module_sp;
1163   if (CheckModule(module_sp)) {
1164     if (m_dynamic_type.IsValid()) {
1165       strm.Printf("Dynamic:\n");
1166       m_dynamic_type.DumpTypeDescription(&strm);
1167       strm.Printf("\nStatic:\n");
1168     }
1169     m_static_type.DumpTypeDescription(&strm);
1170   } else {
1171     strm.PutCString("Invalid TypeImpl module for type has been deleted\n");
1172   }
1173   return true;
1174 }
1175 
FindDirectNestedType(llvm::StringRef name)1176 CompilerType TypeImpl::FindDirectNestedType(llvm::StringRef name) {
1177   if (name.empty())
1178     return CompilerType();
1179   auto type_system = GetTypeSystem(/*prefer_dynamic*/ false);
1180   auto *symbol_file = type_system->GetSymbolFile();
1181   if (!symbol_file)
1182     return CompilerType();
1183   auto decl_context = type_system->GetCompilerDeclContextForType(m_static_type);
1184   if (!decl_context.IsValid())
1185     return CompilerType();
1186   TypeQuery query(decl_context, ConstString(name),
1187                   TypeQueryOptions::e_find_one);
1188   TypeResults results;
1189   symbol_file->FindTypes(query, results);
1190   TypeSP type_sp = results.GetFirstType();
1191   if (type_sp)
1192     return type_sp->GetFullCompilerType();
1193   return CompilerType();
1194 }
1195 
IsValid()1196 bool TypeMemberFunctionImpl::IsValid() {
1197   return m_type.IsValid() && m_kind != lldb::eMemberFunctionKindUnknown;
1198 }
1199 
GetName() const1200 ConstString TypeMemberFunctionImpl::GetName() const { return m_name; }
1201 
GetMangledName() const1202 ConstString TypeMemberFunctionImpl::GetMangledName() const {
1203   return m_decl.GetMangledName();
1204 }
1205 
GetType() const1206 CompilerType TypeMemberFunctionImpl::GetType() const { return m_type; }
1207 
GetKind() const1208 lldb::MemberFunctionKind TypeMemberFunctionImpl::GetKind() const {
1209   return m_kind;
1210 }
1211 
GetDescription(Stream & stream)1212 bool TypeMemberFunctionImpl::GetDescription(Stream &stream) {
1213   switch (m_kind) {
1214   case lldb::eMemberFunctionKindUnknown:
1215     return false;
1216   case lldb::eMemberFunctionKindConstructor:
1217     stream.Printf("constructor for %s",
1218                   m_type.GetTypeName().AsCString("<unknown>"));
1219     break;
1220   case lldb::eMemberFunctionKindDestructor:
1221     stream.Printf("destructor for %s",
1222                   m_type.GetTypeName().AsCString("<unknown>"));
1223     break;
1224   case lldb::eMemberFunctionKindInstanceMethod:
1225     stream.Printf("instance method %s of type %s", m_name.AsCString(),
1226                   m_decl.GetDeclContext().GetName().AsCString());
1227     break;
1228   case lldb::eMemberFunctionKindStaticMethod:
1229     stream.Printf("static method %s of type %s", m_name.AsCString(),
1230                   m_decl.GetDeclContext().GetName().AsCString());
1231     break;
1232   }
1233   return true;
1234 }
1235 
GetReturnType() const1236 CompilerType TypeMemberFunctionImpl::GetReturnType() const {
1237   if (m_type)
1238     return m_type.GetFunctionReturnType();
1239   return m_decl.GetFunctionReturnType();
1240 }
1241 
GetNumArguments() const1242 size_t TypeMemberFunctionImpl::GetNumArguments() const {
1243   if (m_type)
1244     return m_type.GetNumberOfFunctionArguments();
1245   else
1246     return m_decl.GetNumFunctionArguments();
1247 }
1248 
GetArgumentAtIndex(size_t idx) const1249 CompilerType TypeMemberFunctionImpl::GetArgumentAtIndex(size_t idx) const {
1250   if (m_type)
1251     return m_type.GetFunctionArgumentAtIndex(idx);
1252   else
1253     return m_decl.GetFunctionArgumentType(idx);
1254 }
1255 
TypeEnumMemberImpl(const lldb::TypeImplSP & integer_type_sp,ConstString name,const llvm::APSInt & value)1256 TypeEnumMemberImpl::TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
1257                                        ConstString name,
1258                                        const llvm::APSInt &value)
1259     : m_integer_type_sp(integer_type_sp), m_name(name), m_value(value),
1260       m_valid((bool)name && (bool)integer_type_sp)
1261 
1262 {}
1263