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