Fork PDBASTParser to a base class and create PDBASTParserClang

[lanza]

Summary

Work is in progress to get swiftc generating PDBs on Windows and lldb
debugging it. Thus, there is need for a PDBASTParserSwift. So we need
to abstract away a base class from PDBASTParser and fork the Clang
specific implementation to a seperate class.

[lanza]

Fixed some missing =0s

[zturner]

Is the nature of the PDB different enough that it warrants an entirely new implementation? There's a efw places where we parse decorated / undecorated names, but in general I would imagine most of the stuff is language agnostic no?

[lanza]

Is the nature of the PDB different enough that it warrants an entirely new implementation? There's a few places where we parse decorated / undecorated names, but in general I would imagine most of the stuff is language agnostic no?

PDBASTParser holds a ClangASTContext and does all it's work through it. We need to work through the Swift AST. If either XYZASTContexts were just implemented to the TypeSystem interface this could be doable without subclassing but both rely heavily on pretty specific functionality from their respective {swift,clang}::ASTContexts.

include/lldb/Symbol/ClangASTContext.h

 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-enumerations.h"
 
 class DWARFASTParserClang;
+class PDBASTParserClang;
 class PDBASTParser;
 
 namespace lldb_private {
 
 class Declaration;
 
 class ClangASTContext : public TypeSystem {
 public:
// clang-format off
     std::unique_ptr<clang::DiagnosticsEngine>       m_diagnostics_engine_up;
     std::unique_ptr<clang::DiagnosticConsumer>      m_diagnostic_consumer_up;
     std::shared_ptr<clang::TargetOptions>           m_target_options_rp;
     std::unique_ptr<clang::TargetInfo>              m_target_info_up;
     std::unique_ptr<clang::IdentifierTable>         m_identifier_table_up;
     std::unique_ptr<clang::SelectorTable>           m_selector_table_up;
     std::unique_ptr<clang::Builtin::Context>        m_builtins_up;
     std::unique_ptr<DWARFASTParserClang>            m_dwarf_ast_parser_up;
-    std::unique_ptr<PDBASTParser>                   m_pdb_ast_parser_up;
+    std::unique_ptr<PDBASTParserClang>              m_pdb_ast_parser_up;
     std::unique_ptr<ClangASTSource>                 m_scratch_ast_source_up;
     std::unique_ptr<clang::MangleContext>           m_mangle_ctx_up;
     CompleteTagDeclCallback                         m_callback_tag_decl;
     CompleteObjCInterfaceDeclCallback               m_callback_objc_decl;
     void *                                          m_callback_baton;
     clang::ExternalASTMerger::OriginMap             m_origins;
     uint32_t                                        m_pointer_byte_size;
     bool                                            m_ast_owned;

source/Plugins/SymbolFile/PDB/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFilePDB PLUGIN
-  PDBASTParser.cpp
+  PDBASTParserClang.cpp
   PDBLocationToDWARFExpression.cpp
   SymbolFilePDB.cpp
 
   LINK_LIBS
     clangAST
     clangLex
     lldbCore
     lldbSymbol
     lldbUtility
   lldbPluginSymbolFileNativePDB
   LINK_COMPONENTS
     DebugInfoPDB
     Support
   )

source/Plugins/SymbolFile/PDB/PDBASTParser.h

 class PDBSymbolTypeBaseClass;
 class PDBSymbolTypeBuiltin;
 class PDBSymbolTypeUDT;
 } // namespace pdb
 } // namespace llvm
 
 class PDBASTParser {
 public:
-  PDBASTParser(lldb_private::ClangASTContext &ast);
-  ~PDBASTParser();
+  virtual ~PDBASTParser(){};
 
-  lldb::TypeSP CreateLLDBTypeFromPDBType(const llvm::pdb::PDBSymbol &type);
-  bool CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type);
+  virtual lldb::TypeSP
+  CreateLLDBTypeFromPDBType(const llvm::pdb::PDBSymbol &type) = 0;
+  virtual bool
+  CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type) = 0;
 
-  clang::Decl *GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol);
+  virtual clang::Decl *GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) = 0;
 
-  clang::DeclContext *
-  GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol);
-  clang::DeclContext *
-  GetDeclContextContainingSymbol(const llvm::pdb::PDBSymbol &symbol);
-
-  void ParseDeclsForDeclContext(const clang::DeclContext *decl_context);
-
-  clang::NamespaceDecl *FindNamespaceDecl(const clang::DeclContext *parent,
-                                          llvm::StringRef name);
-
-  lldb_private::ClangASTImporter &GetClangASTImporter() {
-    return m_ast_importer;
-  }
-
-private:
-  typedef llvm::DenseMap<clang::CXXRecordDecl *, lldb::user_id_t>
-      CXXRecordDeclToUidMap;
-  typedef llvm::DenseMap<lldb::user_id_t, clang::Decl *> UidToDeclMap;
-  typedef std::set<clang::NamespaceDecl *> NamespacesSet;
-  typedef llvm::DenseMap<clang::DeclContext *, NamespacesSet>
-      ParentToNamespacesMap;
-  typedef llvm::DenseMap<clang::DeclContext *, lldb::user_id_t>
-      DeclContextToUidMap;
-  typedef llvm::pdb::ConcreteSymbolEnumerator<llvm::pdb::PDBSymbolData>
-      PDBDataSymbolEnumerator;
-  typedef llvm::pdb::ConcreteSymbolEnumerator<llvm::pdb::PDBSymbolTypeBaseClass>
-      PDBBaseClassSymbolEnumerator;
-  typedef llvm::pdb::ConcreteSymbolEnumerator<llvm::pdb::PDBSymbolFunc>
-      PDBFuncSymbolEnumerator;
-
-  bool AddEnumValue(lldb_private::CompilerType enum_type,
-                    const llvm::pdb::PDBSymbolData &data);
-  bool CompleteTypeFromUDT(lldb_private::SymbolFile &symbol_file,
-                           lldb_private::CompilerType &compiler_type,
-                           llvm::pdb::PDBSymbolTypeUDT &udt);
-  void
-  AddRecordMembers(lldb_private::SymbolFile &symbol_file,
-                   lldb_private::CompilerType &record_type,
-                   PDBDataSymbolEnumerator &members_enum,
-                   lldb_private::ClangASTImporter::LayoutInfo &layout_info);
-  void
-  AddRecordBases(lldb_private::SymbolFile &symbol_file,
-                 lldb_private::CompilerType &record_type, int record_kind,
-                 PDBBaseClassSymbolEnumerator &bases_enum,
-                 lldb_private::ClangASTImporter::LayoutInfo &layout_info) const;
-  void AddRecordMethods(lldb_private::SymbolFile &symbol_file,
-                        lldb_private::CompilerType &record_type,
-                        PDBFuncSymbolEnumerator &methods_enum);
-  clang::CXXMethodDecl *
-  AddRecordMethod(lldb_private::SymbolFile &symbol_file,
-                  lldb_private::CompilerType &record_type,
-                  const llvm::pdb::PDBSymbolFunc &method) const;
-
-  lldb_private::ClangASTContext &m_ast;
-  lldb_private::ClangASTImporter m_ast_importer;
-
-  CXXRecordDeclToUidMap m_forward_decl_to_uid;
-  UidToDeclMap m_uid_to_decl;
-  ParentToNamespacesMap m_parent_to_namespaces;
-  NamespacesSet m_namespaces;
-  DeclContextToUidMap m_decl_context_to_uid;
+  virtual clang::DeclContext *
+  GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) = 0;
+  virtual clang::DeclContext *
+  GetDeclContextContainingSymbol(const llvm::pdb::PDBSymbol &symbol) = 0;
+
+  virtual void
+  ParseDeclsForDeclContext(const clang::DeclContext *decl_context) = 0;
+
+  virtual clang::NamespaceDecl *
+  FindNamespaceDecl(const clang::DeclContext *parent, llvm::StringRef name) = 0;
 };
 
 #endif // LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSER_H

source/Plugins/SymbolFile/PDB/PDBASTParserClang.h

-//===-- PDBASTParser.h ------------------------------------------*- C++ -*-===//
+//===-- PDBASTParserClang.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSER_H
-#define LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSER_H
+#ifndef LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSERCLANG_H
+#define LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSERCLANG_H
 
 #include "lldb/lldb-forward.h"
 
 #include "lldb/Symbol/ClangASTImporter.h"
+#include "PDBASTParser.h"
 
 class SymbolFilePDB;
 
 namespace clang {
 class CharUnits;
 class CXXRecordDecl;
 class FieldDecl;
 class RecordDecl;

 class PDBSymbolData;
 class PDBSymbolFunc;
 class PDBSymbolTypeBaseClass;
 class PDBSymbolTypeBuiltin;
 class PDBSymbolTypeUDT;
 } // namespace pdb
 } // namespace llvm
 
-class PDBASTParser {
+class PDBASTParserClang : public PDBASTParser {
 public:
-  PDBASTParser(lldb_private::ClangASTContext &ast);
-  ~PDBASTParser();
+  PDBASTParserClang(lldb_private::ClangASTContext &ast);
+  ~PDBASTParserClang() override;
 
-  lldb::TypeSP CreateLLDBTypeFromPDBType(const llvm::pdb::PDBSymbol &type);
-  bool CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type);
+  lldb::TypeSP CreateLLDBTypeFromPDBType(const llvm::pdb::PDBSymbol &type) override;
+  bool CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type) override;
 
-  clang::Decl *GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol);
+  clang::Decl *GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) override;
 
   clang::DeclContext *
-  GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol);
+  GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) override;
   clang::DeclContext *
-  GetDeclContextContainingSymbol(const llvm::pdb::PDBSymbol &symbol);
+  GetDeclContextContainingSymbol(const llvm::pdb::PDBSymbol &symbol) override;
 
-  void ParseDeclsForDeclContext(const clang::DeclContext *decl_context);
+  void ParseDeclsForDeclContext(const clang::DeclContext *decl_context) override;
 
   clang::NamespaceDecl *FindNamespaceDecl(const clang::DeclContext *parent,
-                                          llvm::StringRef name);
+                                          llvm::StringRef name) override;
 
   lldb_private::ClangASTImporter &GetClangASTImporter() {
     return m_ast_importer;
   }
 
 private:
   typedef llvm::DenseMap<clang::CXXRecordDecl *, lldb::user_id_t>
       CXXRecordDeclToUidMap;
private:
 
   CXXRecordDeclToUidMap m_forward_decl_to_uid;
   UidToDeclMap m_uid_to_decl;
   ParentToNamespacesMap m_parent_to_namespaces;
   NamespacesSet m_namespaces;
   DeclContextToUidMap m_decl_context_to_uid;
 };
 
-#endif // LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSER_H
+#endif // LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSERCLANG_H

source/Plugins/SymbolFile/PDB/PDBASTParserClang.cpp

-//===-- PDBASTParser.cpp ----------------------------------------*- C++ -*-===//
+//===-- PDBASTParserClang.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "PDBASTParser.h"
+#include "PDBASTParserClang.h"
 
 #include "SymbolFilePDB.h"
 
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 
 #include "lldb/Core/Module.h"
static clang::CallingConv TranslateCallingConvention(PDB_CallingConv pdb_cc) {
   case llvm::codeview::CallingConvention::NearPascal:
     return clang::CC_X86Pascal;
   default:
     assert(false && "Unknown calling convention");
     return clang::CC_C;
   }
 }
 
-PDBASTParser::PDBASTParser(lldb_private::ClangASTContext &ast) : m_ast(ast) {}
+PDBASTParserClang::PDBASTParserClang(lldb_private::ClangASTContext &ast) : m_ast(ast) {}
 
-PDBASTParser::~PDBASTParser() {}
+PDBASTParserClang::~PDBASTParserClang() {}
 
 // DebugInfoASTParser interface
 
-lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
+lldb::TypeSP PDBASTParserClang::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
   Declaration decl;
   switch (type.getSymTag()) {
   case PDB_SymType::BaseClass: {
     auto symbol_file = m_ast.GetSymbolFile();
     if (!symbol_file)
       return nullptr;
 
     auto ty = symbol_file->ResolveTypeUID(type.getRawSymbol().getTypeId());
return std::make_shared<lldb_private::Type>(
         lldb_private::Type::eResolveStateFull);
   } break;
   default:
     break;
   }
   return nullptr;
 }
 
-bool PDBASTParser::CompleteTypeFromPDB(
+bool PDBASTParserClang::CompleteTypeFromPDB(
     lldb_private::CompilerType &compiler_type) {
   if (GetClangASTImporter().CanImport(compiler_type))
     return GetClangASTImporter().CompleteType(compiler_type);
 
   // Remove the type from the forward declarations to avoid
   // an endless recursion for types like a linked list.
   clang::CXXRecordDecl *record_decl =
       m_ast.GetAsCXXRecordDecl(compiler_type.GetOpaqueQualType());
case PDB_SymType::UDT: {
     return CompleteTypeFromUDT(*symbol_file, compiler_type, *udt);
   }
   default:
     llvm_unreachable("not a forward clang type decl!");
   }
 }
 
 clang::Decl *
-PDBASTParser::GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) {
+PDBASTParserClang::GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) {
   uint32_t sym_id = symbol.getSymIndexId();
   auto it = m_uid_to_decl.find(sym_id);
   if (it != m_uid_to_decl.end())
     return it->second;
 
   auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
   if (!symbol_file)
     return nullptr;
if (!type)
       return nullptr;
 
     return m_uid_to_decl.lookup(sym_id);
   }
   }
 }
 
 clang::DeclContext *
-PDBASTParser::GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) {
+PDBASTParserClang::GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) {
   if (symbol.getSymTag() == PDB_SymType::Function) {
     clang::DeclContext *result =
         llvm::dyn_cast_or_null<clang::FunctionDecl>(GetDeclForSymbol(symbol));
 
     if (result)
       m_decl_context_to_uid[result] = symbol.getSymIndexId();
 
     return result;
clang::DeclContext *result =
       m_ast.GetDeclContextForType(type->GetForwardCompilerType());
 
   if (result)
     m_decl_context_to_uid[result] = symbol.getSymIndexId();
 
   return result;
 }
 
-clang::DeclContext *PDBASTParser::GetDeclContextContainingSymbol(
+clang::DeclContext *PDBASTParserClang::GetDeclContextContainingSymbol(
     const llvm::pdb::PDBSymbol &symbol) {
   auto parent = GetClassOrFunctionParent(symbol);
   while (parent) {
     if (auto parent_context = GetDeclContextForSymbol(*parent))
       return parent_context;
 
     parent = GetClassOrFunctionParent(*parent);
   }
if (!has_type_or_function_parent) {
 
       curr_context = namespace_decl;
     }
   }
 
   return curr_context;
 }
 
-void PDBASTParser::ParseDeclsForDeclContext(
+void PDBASTParserClang::ParseDeclsForDeclContext(
     const clang::DeclContext *decl_context) {
   auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
   if (!symbol_file)
     return;
 
   IPDBSession &session = symbol_file->GetPDBSession();
   auto symbol_up =
       session.getSymbolById(m_decl_context_to_uid.lookup(decl_context));
   auto global_up = session.getGlobalScope();
 
   PDBSymbol *symbol;
   if (symbol_up)
     symbol = symbol_up.get();
   else if (global_up)
     symbol = global_up.get();
   else
     return;
 
   if (auto children = symbol->findAllChildren())
     while (auto child = children->getNext())
       GetDeclForSymbol(*child);
 }
 
 clang::NamespaceDecl *
-PDBASTParser::FindNamespaceDecl(const clang::DeclContext *parent,
+PDBASTParserClang::FindNamespaceDecl(const clang::DeclContext *parent,
                                 llvm::StringRef name) {
   NamespacesSet *set;
   if (parent) {
     auto pit = m_parent_to_namespaces.find(parent);
     if (pit == m_parent_to_namespaces.end())
       return nullptr;
 
     set = &pit->second;
   } else {
     set = &m_namespaces;
   }
   assert(set);
 
   for (clang::NamespaceDecl *namespace_decl : *set)
     if (namespace_decl->getName().equals(name))
       return namespace_decl;
 
   for (clang::NamespaceDecl *namespace_decl : *set)
     if (namespace_decl->isAnonymousNamespace())
       return FindNamespaceDecl(namespace_decl, name);
 
   return nullptr;
 }
 
-bool PDBASTParser::AddEnumValue(CompilerType enum_type,
+bool PDBASTParserClang::AddEnumValue(CompilerType enum_type,
                                 const PDBSymbolData &enum_value) {
   Declaration decl;
   Variant v = enum_value.getValue();
   std::string name = MSVCUndecoratedNameParser::DropScope(enum_value.getName());
   int64_t raw_value;
   switch (v.Type) {
   case PDB_VariantType::Int8:
     raw_value = v.Value.Int8;
bool PDBASTParserClang::AddEnumValue(CompilerType enum_type,
   if (!enum_constant_decl)
     return false;
 
   m_uid_to_decl[enum_value.getSymIndexId()] = enum_constant_decl;
 
   return true;
 }
 
-bool PDBASTParser::CompleteTypeFromUDT(
+bool PDBASTParserClang::CompleteTypeFromUDT(
     lldb_private::SymbolFile &symbol_file,
     lldb_private::CompilerType &compiler_type,
     llvm::pdb::PDBSymbolTypeUDT &udt) {
   ClangASTImporter::LayoutInfo layout_info;
   layout_info.bit_size = udt.getLength() * 8;
 
   auto nested_enums = udt.findAllChildren<PDBSymbolTypeUDT>();
   if (nested_enums)
bool PDBASTParserClang::CompleteTypeFromUDT(
   if (!record_decl)
     return static_cast<bool>(compiler_type);
 
   GetClangASTImporter().InsertRecordDecl(record_decl, layout_info);
 
   return static_cast<bool>(compiler_type);
 }
 
-void PDBASTParser::AddRecordMembers(
+void PDBASTParserClang::AddRecordMembers(
     lldb_private::SymbolFile &symbol_file,
     lldb_private::CompilerType &record_type,
     PDBDataSymbolEnumerator &members_enum,
     lldb_private::ClangASTImporter::LayoutInfo &layout_info) {
   while (auto member = members_enum.getNext()) {
     if (member->isCompilerGenerated())
       continue;
 
case PDB_DataKind::StaticMember: {
       break;
     }
     default:
       llvm_unreachable("unsupported PDB data kind");
     }
   }
 }
 
-void PDBASTParser::AddRecordBases(
+void PDBASTParserClang::AddRecordBases(
     lldb_private::SymbolFile &symbol_file,
     lldb_private::CompilerType &record_type, int record_kind,
     PDBBaseClassSymbolEnumerator &bases_enum,
     lldb_private::ClangASTImporter::LayoutInfo &layout_info) const {
   std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> base_classes;
 
   while (auto base = bases_enum.getNext()) {
     auto base_type = symbol_file.ResolveTypeUID(base->getTypeId());
while (auto base = bases_enum.getNext()) {
     auto offset = clang::CharUnits::fromQuantity(base->getOffset());
     layout_info.base_offsets.insert(std::make_pair(decl, offset));
   }
 
   m_ast.TransferBaseClasses(record_type.GetOpaqueQualType(),
                             std::move(base_classes));
 }
 
-void PDBASTParser::AddRecordMethods(lldb_private::SymbolFile &symbol_file,
+void PDBASTParserClang::AddRecordMethods(lldb_private::SymbolFile &symbol_file,
                                     lldb_private::CompilerType &record_type,
                                     PDBFuncSymbolEnumerator &methods_enum) {
   while (std::unique_ptr<PDBSymbolFunc> method = methods_enum.getNext())
     if (clang::CXXMethodDecl *decl =
             AddRecordMethod(symbol_file, record_type, *method))
       m_uid_to_decl[method->getSymIndexId()] = decl;
 }
 
 clang::CXXMethodDecl *
-PDBASTParser::AddRecordMethod(lldb_private::SymbolFile &symbol_file,
+PDBASTParserClang::AddRecordMethod(lldb_private::SymbolFile &symbol_file,
                               lldb_private::CompilerType &record_type,
                               const llvm::pdb::PDBSymbolFunc &method) const {
   std::string name = MSVCUndecoratedNameParser::DropScope(method.getName());
 
   Type *method_type = symbol_file.ResolveTypeUID(method.getSymIndexId());
   // MSVC specific __vecDelDtor.
   if (!method_type)
     return nullptr;

source/Symbol/ClangASTContext.cpp

 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Scalar.h"
 
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
-#include "Plugins/SymbolFile/PDB/PDBASTParser.h"
+#include "Plugins/SymbolFile/PDB/PDBASTParserClang.h"
 
 #include <stdio.h>
 
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;

 DWARFASTParser *ClangASTContext::GetDWARFParser() {
   if (!m_dwarf_ast_parser_up)
     m_dwarf_ast_parser_up.reset(new DWARFASTParserClang(*this));
   return m_dwarf_ast_parser_up.get();
 }
 
 PDBASTParser *ClangASTContext::GetPDBParser() {
   if (!m_pdb_ast_parser_up)
-    m_pdb_ast_parser_up.reset(new PDBASTParser(*this));
+    m_pdb_ast_parser_up.reset(new PDBASTParserClang(*this));
   return m_pdb_ast_parser_up.get();
 }
 
 bool ClangASTContext::LayoutRecordType(
     void *baton, const clang::RecordDecl *record_decl, uint64_t &bit_size,
     uint64_t &alignment,
     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>