1#include "UdtRecordCompleter.h"
2
3#include "PdbAstBuilder.h"
4#include "PdbIndex.h"
5#include "PdbSymUid.h"
6#include "PdbUtil.h"
7
8#include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
9#include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h"
10#include "Plugins/ExpressionParser/Clang/ClangUtil.h"
11#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
12#include "SymbolFileNativePDB.h"
13#include "lldb/Core/Address.h"
14#include "lldb/Symbol/Type.h"
15#include "lldb/Utility/LLDBAssert.h"
16#include "lldb/Utility/LLDBLog.h"
17#include "lldb/lldb-enumerations.h"
18#include "lldb/lldb-forward.h"
19
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
22#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
23#include "llvm/DebugInfo/CodeView/TypeIndex.h"
24#include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
25#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
26#include "llvm/DebugInfo/PDB/PDBTypes.h"
27#include <optional>
28
29using namespace llvm::codeview;
30using namespace llvm::pdb;
31using namespace lldb;
32using namespace lldb_private;
33using namespace lldb_private::npdb;
34
35using Error = llvm::Error;
36
37UdtRecordCompleter::UdtRecordCompleter(
38    PdbTypeSymId id, CompilerType &derived_ct, clang::TagDecl &tag_decl,
39    PdbAstBuilder &ast_builder, PdbIndex &index,
40    llvm::DenseMap<clang::Decl *, DeclStatus> &decl_to_status,
41    llvm::DenseMap<lldb::opaque_compiler_type_t,
42                   llvm::SmallSet<std::pair<llvm::StringRef, CompilerType>, 8>>
43        &cxx_record_map)
44    : m_id(id), m_derived_ct(derived_ct), m_tag_decl(tag_decl),
45      m_ast_builder(ast_builder), m_index(index),
46      m_decl_to_status(decl_to_status), m_cxx_record_map(cxx_record_map) {
47  CVType cvt = m_index.tpi().getType(m_id.index);
48  switch (cvt.kind()) {
49  case LF_ENUM:
50    llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, m_cvr.er));
51    break;
52  case LF_UNION:
53    llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, m_cvr.ur));
54    m_layout.bit_size = m_cvr.ur.getSize() * 8;
55    m_record.record.kind = Member::Union;
56    break;
57  case LF_CLASS:
58  case LF_STRUCTURE:
59    llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, m_cvr.cr));
60    m_layout.bit_size = m_cvr.cr.getSize() * 8;
61    m_record.record.kind = Member::Struct;
62    break;
63  default:
64    llvm_unreachable("unreachable!");
65  }
66}
67
68clang::QualType UdtRecordCompleter::AddBaseClassForTypeIndex(
69    llvm::codeview::TypeIndex ti, llvm::codeview::MemberAccess access,
70    std::optional<uint64_t> vtable_idx) {
71  PdbTypeSymId type_id(ti);
72  clang::QualType qt = m_ast_builder.GetOrCreateType(type_id);
73
74  CVType udt_cvt = m_index.tpi().getType(ti);
75
76  std::unique_ptr<clang::CXXBaseSpecifier> base_spec =
77      m_ast_builder.clang().CreateBaseClassSpecifier(
78          qt.getAsOpaquePtr(), TranslateMemberAccess(access),
79          vtable_idx.has_value(), udt_cvt.kind() == LF_CLASS);
80  if (!base_spec)
81    return {};
82
83  m_bases.push_back(
84      std::make_pair(vtable_idx.value_or(0), std::move(base_spec)));
85
86  return qt;
87}
88
89void UdtRecordCompleter::AddMethod(llvm::StringRef name, TypeIndex type_idx,
90                                   MemberAccess access, MethodOptions options,
91                                   MemberAttributes attrs) {
92  clang::QualType method_qt =
93      m_ast_builder.GetOrCreateType(PdbTypeSymId(type_idx));
94  if (method_qt.isNull())
95    return;
96  CompilerType method_ct = m_ast_builder.ToCompilerType(method_qt);
97  TypeSystemClang::RequireCompleteType(method_ct);
98  lldb::opaque_compiler_type_t derived_opaque_ty =
99      m_derived_ct.GetOpaqueQualType();
100  auto iter = m_cxx_record_map.find(derived_opaque_ty);
101  if (iter != m_cxx_record_map.end()) {
102    if (iter->getSecond().contains({name, method_ct})) {
103      return;
104    }
105  }
106
107  lldb::AccessType access_type = TranslateMemberAccess(access);
108  bool is_artificial = (options & MethodOptions::CompilerGenerated) ==
109                       MethodOptions::CompilerGenerated;
110  m_ast_builder.clang().AddMethodToCXXRecordType(
111      derived_opaque_ty, name.data(), nullptr, method_ct,
112      access_type, attrs.isVirtual(), attrs.isStatic(), false, false, false,
113      is_artificial);
114
115  m_cxx_record_map[derived_opaque_ty].insert({name, method_ct});
116}
117
118Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
119                                           BaseClassRecord &base) {
120  clang::QualType base_qt =
121      AddBaseClassForTypeIndex(base.Type, base.getAccess());
122
123  if (base_qt.isNull())
124    return llvm::Error::success();
125  auto decl =
126      m_ast_builder.clang().GetAsCXXRecordDecl(base_qt.getAsOpaquePtr());
127  lldbassert(decl);
128
129  auto offset = clang::CharUnits::fromQuantity(base.getBaseOffset());
130  m_layout.base_offsets.insert(std::make_pair(decl, offset));
131
132  return llvm::Error::success();
133}
134
135Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
136                                           VirtualBaseClassRecord &base) {
137  AddBaseClassForTypeIndex(base.BaseType, base.getAccess(), base.VTableIndex);
138
139  return Error::success();
140}
141
142Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
143                                           ListContinuationRecord &cont) {
144  return Error::success();
145}
146
147Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
148                                           VFPtrRecord &vfptr) {
149  return Error::success();
150}
151
152Error UdtRecordCompleter::visitKnownMember(
153    CVMemberRecord &cvr, StaticDataMemberRecord &static_data_member) {
154  clang::QualType member_type =
155      m_ast_builder.GetOrCreateType(PdbTypeSymId(static_data_member.Type));
156  if (member_type.isNull())
157    return llvm::Error::success();
158
159  CompilerType member_ct = m_ast_builder.ToCompilerType(member_type);
160
161  lldb::AccessType access =
162      TranslateMemberAccess(static_data_member.getAccess());
163  auto decl = TypeSystemClang::AddVariableToRecordType(
164      m_derived_ct, static_data_member.Name, member_ct, access);
165
166  // Static constant members may be a const[expr] declaration.
167  // Query the symbol's value as the variable initializer if valid.
168  if (member_ct.IsConst() && member_ct.IsCompleteType()) {
169    std::string qual_name = decl->getQualifiedNameAsString();
170
171    auto results =
172        m_index.globals().findRecordsByName(qual_name, m_index.symrecords());
173
174    for (const auto &result : results) {
175      if (result.second.kind() == SymbolKind::S_CONSTANT) {
176        ConstantSym constant(SymbolRecordKind::ConstantSym);
177        cantFail(SymbolDeserializer::deserializeAs<ConstantSym>(result.second,
178                                                                constant));
179
180        clang::QualType qual_type = decl->getType();
181        unsigned type_width = decl->getASTContext().getIntWidth(qual_type);
182        unsigned constant_width = constant.Value.getBitWidth();
183
184        if (qual_type->isIntegralOrEnumerationType()) {
185          if (type_width >= constant_width) {
186            TypeSystemClang::SetIntegerInitializerForVariable(
187                decl, constant.Value.extOrTrunc(type_width));
188          } else {
189            LLDB_LOG(GetLog(LLDBLog::AST),
190                     "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) "
191                     "which resolves to a wider constant value ({4} bits). "
192                     "Ignoring constant.",
193                     m_derived_ct.GetTypeName(), static_data_member.Name,
194                     member_ct.GetTypeName(), type_width, constant_width);
195          }
196        } else {
197          lldb::BasicType basic_type_enum = member_ct.GetBasicTypeEnumeration();
198          switch (basic_type_enum) {
199          case lldb::eBasicTypeFloat:
200          case lldb::eBasicTypeDouble:
201          case lldb::eBasicTypeLongDouble:
202            if (type_width == constant_width) {
203              TypeSystemClang::SetFloatingInitializerForVariable(
204                  decl, basic_type_enum == lldb::eBasicTypeFloat
205                            ? llvm::APFloat(constant.Value.bitsToFloat())
206                            : llvm::APFloat(constant.Value.bitsToDouble()));
207              decl->setConstexpr(true);
208            } else {
209              LLDB_LOG(
210                  GetLog(LLDBLog::AST),
211                  "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) "
212                  "which resolves to a constant value of mismatched width "
213                  "({4} bits). Ignoring constant.",
214                  m_derived_ct.GetTypeName(), static_data_member.Name,
215                  member_ct.GetTypeName(), type_width, constant_width);
216            }
217            break;
218          default:
219            break;
220          }
221        }
222        break;
223      }
224    }
225  }
226
227  // FIXME: Add a PdbSymUid namespace for field list members and update
228  // the m_uid_to_decl map with this decl.
229  return Error::success();
230}
231
232Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
233                                           NestedTypeRecord &nested) {
234  return Error::success();
235}
236
237Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
238                                           DataMemberRecord &data_member) {
239
240  uint64_t offset = data_member.FieldOffset * 8;
241  uint32_t bitfield_width = 0;
242
243  TypeIndex ti(data_member.Type);
244  if (!ti.isSimple()) {
245    CVType cvt = m_index.tpi().getType(ti);
246    if (cvt.kind() == LF_BITFIELD) {
247      BitFieldRecord bfr;
248      llvm::cantFail(TypeDeserializer::deserializeAs<BitFieldRecord>(cvt, bfr));
249      offset += bfr.BitOffset;
250      bitfield_width = bfr.BitSize;
251      ti = bfr.Type;
252    }
253  }
254
255  clang::QualType member_qt = m_ast_builder.GetOrCreateType(PdbTypeSymId(ti));
256  if (member_qt.isNull())
257    return Error::success();
258  TypeSystemClang::RequireCompleteType(m_ast_builder.ToCompilerType(member_qt));
259  lldb::AccessType access = TranslateMemberAccess(data_member.getAccess());
260  size_t field_size =
261      bitfield_width ? bitfield_width : GetSizeOfType(ti, m_index.tpi()) * 8;
262  if (field_size == 0)
263    return Error::success();
264  m_record.CollectMember(data_member.Name, offset, field_size, member_qt, access,
265                bitfield_width);
266  return Error::success();
267}
268
269Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
270                                           OneMethodRecord &one_method) {
271  AddMethod(one_method.Name, one_method.Type, one_method.getAccess(),
272            one_method.getOptions(), one_method.Attrs);
273
274  return Error::success();
275}
276
277Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
278                                           OverloadedMethodRecord &overloaded) {
279  TypeIndex method_list_idx = overloaded.MethodList;
280
281  CVType method_list_type = m_index.tpi().getType(method_list_idx);
282  assert(method_list_type.kind() == LF_METHODLIST);
283
284  MethodOverloadListRecord method_list;
285  llvm::cantFail(TypeDeserializer::deserializeAs<MethodOverloadListRecord>(
286      method_list_type, method_list));
287
288  for (const OneMethodRecord &method : method_list.Methods)
289    AddMethod(overloaded.Name, method.Type, method.getAccess(),
290              method.getOptions(), method.Attrs);
291
292  return Error::success();
293}
294
295Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
296                                           EnumeratorRecord &enumerator) {
297  Declaration decl;
298  llvm::StringRef name = DropNameScope(enumerator.getName());
299
300  m_ast_builder.clang().AddEnumerationValueToEnumerationType(
301      m_derived_ct, decl, name.str().c_str(), enumerator.Value);
302  return Error::success();
303}
304
305void UdtRecordCompleter::complete() {
306  // Ensure the correct order for virtual bases.
307  llvm::stable_sort(m_bases, llvm::less_first());
308
309  std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
310  bases.reserve(m_bases.size());
311  for (auto &ib : m_bases)
312    bases.push_back(std::move(ib.second));
313
314  TypeSystemClang &clang = m_ast_builder.clang();
315  // Make sure all base classes refer to complete types and not forward
316  // declarations. If we don't do this, clang will crash with an
317  // assertion in the call to clang_type.TransferBaseClasses()
318  for (const auto &base_class : bases) {
319    clang::TypeSourceInfo *type_source_info =
320        base_class->getTypeSourceInfo();
321    if (type_source_info) {
322      TypeSystemClang::RequireCompleteType(
323          clang.GetType(type_source_info->getType()));
324    }
325  }
326
327  clang.TransferBaseClasses(m_derived_ct.GetOpaqueQualType(), std::move(bases));
328
329  clang.AddMethodOverridesForCXXRecordType(m_derived_ct.GetOpaqueQualType());
330  FinishRecord();
331  TypeSystemClang::BuildIndirectFields(m_derived_ct);
332  TypeSystemClang::CompleteTagDeclarationDefinition(m_derived_ct);
333
334  if (auto *record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(&m_tag_decl)) {
335    m_ast_builder.GetClangASTImporter().SetRecordLayout(record_decl, m_layout);
336  }
337}
338
339uint64_t
340UdtRecordCompleter::AddMember(TypeSystemClang &clang, Member *field,
341                              uint64_t bit_offset, CompilerType parent_ct,
342                              ClangASTImporter::LayoutInfo &parent_layout,
343                              clang::DeclContext *parent_decl_ctx) {
344  SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
345      clang.GetSymbolFile()->GetBackingSymbolFile());
346  clang::FieldDecl *field_decl = nullptr;
347  uint64_t bit_size = 0;
348  switch (field->kind) {
349  case Member::Field: {
350    field_decl = TypeSystemClang::AddFieldToRecordType(
351        parent_ct, field->name, m_ast_builder.ToCompilerType(field->qt),
352        field->access, field->bitfield_width);
353    bit_size = field->bit_size;
354    break;
355  };
356  case Member::Struct:
357  case Member::Union: {
358    clang::TagTypeKind kind = field->kind == Member::Struct
359                                  ? clang::TagTypeKind::Struct
360                                  : clang::TagTypeKind::Union;
361    ClangASTMetadata metadata;
362    metadata.SetUserID(pdb->anonymous_id);
363    metadata.SetIsDynamicCXXType(false);
364    CompilerType record_ct = clang.CreateRecordType(
365        parent_decl_ctx, OptionalClangModuleID(), lldb::eAccessPublic, "",
366        llvm::to_underlying(kind), lldb::eLanguageTypeC_plus_plus, &metadata);
367    TypeSystemClang::StartTagDeclarationDefinition(record_ct);
368    ClangASTImporter::LayoutInfo layout;
369    clang::DeclContext *decl_ctx = clang.GetDeclContextForType(record_ct);
370    for (const auto &member : field->fields) {
371      uint64_t member_offset = field->kind == Member::Struct
372                                   ? member->bit_offset - field->base_offset
373                                   : 0;
374      uint64_t member_bit_size = AddMember(clang, member.get(), member_offset,
375                                          record_ct, layout, decl_ctx);
376      if (field->kind == Member::Struct)
377        bit_size = std::max(bit_size, member_offset + member_bit_size);
378      else
379        bit_size = std::max(bit_size, member_bit_size);
380    }
381    layout.bit_size = bit_size;
382    TypeSystemClang::CompleteTagDeclarationDefinition(record_ct);
383    clang::RecordDecl *record_decl = clang.GetAsRecordDecl(record_ct);
384    m_ast_builder.GetClangASTImporter().SetRecordLayout(record_decl, layout);
385    field_decl = TypeSystemClang::AddFieldToRecordType(
386        parent_ct, "", record_ct, lldb::eAccessPublic, 0);
387    // Mark this record decl as completed.
388    DeclStatus status;
389    status.resolved = true;
390    status.uid = pdb->anonymous_id--;
391    m_decl_to_status.insert({record_decl, status});
392    break;
393  };
394  }
395  // FIXME: Add a PdbSymUid namespace for field list members and update
396  // the m_uid_to_decl map with this decl.
397  parent_layout.field_offsets.insert({field_decl, bit_offset});
398  return bit_size;
399}
400
401void UdtRecordCompleter::FinishRecord() {
402  TypeSystemClang &clang = m_ast_builder.clang();
403  clang::DeclContext *decl_ctx =
404      m_ast_builder.GetOrCreateDeclContextForUid(m_id);
405  m_record.ConstructRecord();
406  // Maybe we should check the construsted record size with the size in pdb. If
407  // they mismatch, it might be pdb has fields info missing.
408  for (const auto &field : m_record.record.fields) {
409    AddMember(clang, field.get(), field->bit_offset, m_derived_ct, m_layout,
410             decl_ctx);
411  }
412}
413
414void UdtRecordCompleter::Record::CollectMember(
415    llvm::StringRef name, uint64_t offset, uint64_t field_size,
416    clang::QualType qt, lldb::AccessType access, uint64_t bitfield_width) {
417  fields_map[offset].push_back(std::make_unique<Member>(
418      name, offset, field_size, qt, access, bitfield_width));
419  if (start_offset > offset)
420    start_offset = offset;
421}
422
423void UdtRecordCompleter::Record::ConstructRecord() {
424  // For anonymous unions in a struct, msvc generated pdb doesn't have the
425  // entity for that union. So, we need to construct anonymous union and struct
426  // based on field offsets. The final AST is likely not matching the exact
427  // original AST, but the memory layout is preseved.
428  // After we collecting all fields in visitKnownMember, we have all fields in
429  // increasing offset order in m_fields. Since we are iterating in increase
430  // offset order, if the current offset is equal to m_start_offset, we insert
431  // it as direct field of top level record. If the current offset is greater
432  // than m_start_offset, we should be able to find a field in end_offset_map
433  // whose end offset is less than or equal to current offset. (if not, it might
434  // be missing field info. We will ignore the field in this case. e.g. Field A
435  // starts at 0 with size 4 bytes, and Field B starts at 2 with size 4 bytes.
436  // Normally, there must be something which ends at/before 2.) Then we will
437  // append current field to the end of parent record. If parent is struct, we
438  // can just grow it. If parent is a field, it's a field inside an union. We
439  // convert it into an anonymous struct containing old field and new field.
440
441  // The end offset to a vector of field/struct that ends at the offset.
442  std::map<uint64_t, std::vector<Member *>> end_offset_map;
443  for (auto &pair : fields_map) {
444    uint64_t offset = pair.first;
445    auto &fields = pair.second;
446    lldbassert(offset >= start_offset);
447    Member *parent = &record;
448    if (offset > start_offset) {
449      // Find the field with largest end offset that is <= offset. If it's less
450      // than offset, it indicates there are padding bytes between end offset
451      // and offset.
452      lldbassert(!end_offset_map.empty());
453      auto iter = end_offset_map.lower_bound(offset);
454      if (iter == end_offset_map.end())
455        --iter;
456      else if (iter->first > offset) {
457        if (iter == end_offset_map.begin())
458          continue;
459        --iter;
460      }
461      if (iter->second.empty())
462        continue;
463      parent = iter->second.back();
464      iter->second.pop_back();
465    }
466    // If it's a field, then the field is inside a union, so we can safely
467    // increase its size by converting it to a struct to hold multiple fields.
468    if (parent->kind == Member::Field)
469      parent->ConvertToStruct();
470
471    if (fields.size() == 1) {
472      uint64_t end_offset = offset + fields.back()->bit_size;
473      parent->fields.push_back(std::move(fields.back()));
474      if (parent->kind == Member::Struct) {
475        end_offset_map[end_offset].push_back(parent);
476      } else {
477        lldbassert(parent == &record &&
478                   "If parent is union, it must be the top level record.");
479        end_offset_map[end_offset].push_back(parent->fields.back().get());
480      }
481    } else {
482      if (parent->kind == Member::Struct) {
483        parent->fields.push_back(std::make_unique<Member>(Member::Union));
484        parent = parent->fields.back().get();
485        parent->bit_offset = offset;
486      } else {
487        lldbassert(parent == &record &&
488                   "If parent is union, it must be the top level record.");
489      }
490      for (auto &field : fields) {
491        int64_t bit_size = field->bit_size;
492        parent->fields.push_back(std::move(field));
493        end_offset_map[offset + bit_size].push_back(
494            parent->fields.back().get());
495      }
496    }
497  }
498}
499