1 files changed, 181 insertions, 186 deletions

diff --git a/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp b/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp
index 1e8e040fd47..b48de2e591e 100644
--- a/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp
+++ b/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp
@@ -34,204 +34,199 @@ using namespace lldb_private;
 using namespace llvm;
 using namespace llvm::pdb;
 
-namespace
-{
-int
-TranslateUdtKind(PDB_UdtType pdb_kind)
-{
-    switch (pdb_kind)
-    {
-        case PDB_UdtType::Class:
-            return clang::TTK_Class;
-        case PDB_UdtType::Struct:
-            return clang::TTK_Struct;
-        case PDB_UdtType::Union:
-            return clang::TTK_Union;
-        case PDB_UdtType::Interface:
-            return clang::TTK_Interface;
-    }
+namespace {
+int TranslateUdtKind(PDB_UdtType pdb_kind) {
+  switch (pdb_kind) {
+  case PDB_UdtType::Class:
     return clang::TTK_Class;
+  case PDB_UdtType::Struct:
+    return clang::TTK_Struct;
+  case PDB_UdtType::Union:
+    return clang::TTK_Union;
+  case PDB_UdtType::Interface:
+    return clang::TTK_Interface;
+  }
+  return clang::TTK_Class;
 }
 
-lldb::Encoding
-TranslateBuiltinEncoding(PDB_BuiltinType type)
-{
-    switch (type)
-    {
-        case PDB_BuiltinType::Float:
-            return lldb::eEncodingIEEE754;
-        case PDB_BuiltinType::Int:
-        case PDB_BuiltinType::Long:
-        case PDB_BuiltinType::Char:
-            return lldb::eEncodingSint;
-        case PDB_BuiltinType::Bool:
-        case PDB_BuiltinType::UInt:
-        case PDB_BuiltinType::ULong:
-        case PDB_BuiltinType::HResult:
-            return lldb::eEncodingUint;
-        default:
-            return lldb::eEncodingInvalid;
-    }
+lldb::Encoding TranslateBuiltinEncoding(PDB_BuiltinType type) {
+  switch (type) {
+  case PDB_BuiltinType::Float:
+    return lldb::eEncodingIEEE754;
+  case PDB_BuiltinType::Int:
+  case PDB_BuiltinType::Long:
+  case PDB_BuiltinType::Char:
+    return lldb::eEncodingSint;
+  case PDB_BuiltinType::Bool:
+  case PDB_BuiltinType::UInt:
+  case PDB_BuiltinType::ULong:
+  case PDB_BuiltinType::HResult:
+    return lldb::eEncodingUint;
+  default:
+    return lldb::eEncodingInvalid;
+  }
 }
 }
 
-PDBASTParser::PDBASTParser(lldb_private::ClangASTContext &ast) : m_ast(ast)
-{
-}
+PDBASTParser::PDBASTParser(lldb_private::ClangASTContext &ast) : m_ast(ast) {}
 
-PDBASTParser::~PDBASTParser()
-{
-}
+PDBASTParser::~PDBASTParser() {}
 
 // DebugInfoASTParser interface
 
-lldb::TypeSP
-PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type)
-{
-    // PDB doesn't maintain enough information to robustly rebuild the entire
-    // tree, and this is most problematic when it comes to figure out the
-    // right DeclContext to put a type in.  So for now, everything goes in
-    // the translation unit decl as a fully qualified type.
-    clang::DeclContext *tu_decl_ctx = m_ast.GetTranslationUnitDecl();
-    Declaration decl;
-
-    if (auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&type))
-    {
-        AccessType access = lldb::eAccessPublic;
-        PDB_UdtType udt_kind = udt->getUdtKind();
-
-        if (udt_kind == PDB_UdtType::Class)
-            access = lldb::eAccessPrivate;
-
-        CompilerType clang_type =
-            m_ast.CreateRecordType(tu_decl_ctx, access, udt->getName().c_str(), TranslateUdtKind(udt_kind),
-                                   lldb::eLanguageTypeC_plus_plus, nullptr);
-
-        m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), true);
-
-        return std::make_shared<Type>(type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(udt->getName()),
-                                      udt->getLength(), nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
-                                      clang_type, Type::eResolveStateForward);
-    }
-    else if (auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(&type))
-    {
-        std::string name = enum_type->getName();
-        lldb::Encoding encoding = TranslateBuiltinEncoding(enum_type->getBuiltinType());
-        uint64_t bytes = enum_type->getLength();
-        CompilerType builtin_type = m_ast.GetBuiltinTypeForEncodingAndBitSize(encoding, bytes * 8);
-
-        CompilerType ast_enum = m_ast.CreateEnumerationType(name.c_str(), tu_decl_ctx, decl, builtin_type);
-        auto enum_values = enum_type->findAllChildren<PDBSymbolData>();
-        while (auto enum_value = enum_values->getNext())
-        {
-            if (enum_value->getDataKind() != PDB_DataKind::Constant)
-                continue;
-            AddEnumValue(ast_enum, *enum_value);
-        }
-
-        return std::make_shared<Type>(type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name), bytes, nullptr,
-                                      LLDB_INVALID_UID, Type::eEncodingIsUID, decl, ast_enum, Type::eResolveStateFull);
+lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
+  // PDB doesn't maintain enough information to robustly rebuild the entire
+  // tree, and this is most problematic when it comes to figure out the
+  // right DeclContext to put a type in.  So for now, everything goes in
+  // the translation unit decl as a fully qualified type.
+  clang::DeclContext *tu_decl_ctx = m_ast.GetTranslationUnitDecl();
+  Declaration decl;
+
+  if (auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&type)) {
+    AccessType access = lldb::eAccessPublic;
+    PDB_UdtType udt_kind = udt->getUdtKind();
+
+    if (udt_kind == PDB_UdtType::Class)
+      access = lldb::eAccessPrivate;
+
+    CompilerType clang_type = m_ast.CreateRecordType(
+        tu_decl_ctx, access, udt->getName().c_str(), TranslateUdtKind(udt_kind),
+        lldb::eLanguageTypeC_plus_plus, nullptr);
+
+    m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), true);
+
+    return std::make_shared<Type>(type.getSymIndexId(), m_ast.GetSymbolFile(),
+                                  ConstString(udt->getName()), udt->getLength(),
+                                  nullptr, LLDB_INVALID_UID,
+                                  Type::eEncodingIsUID, decl, clang_type,
+                                  Type::eResolveStateForward);
+  } else if (auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(&type)) {
+    std::string name = enum_type->getName();
+    lldb::Encoding encoding =
+        TranslateBuiltinEncoding(enum_type->getBuiltinType());
+    uint64_t bytes = enum_type->getLength();
+    CompilerType builtin_type =
+        m_ast.GetBuiltinTypeForEncodingAndBitSize(encoding, bytes * 8);
+
+    CompilerType ast_enum = m_ast.CreateEnumerationType(
+        name.c_str(), tu_decl_ctx, decl, builtin_type);
+    auto enum_values = enum_type->findAllChildren<PDBSymbolData>();
+    while (auto enum_value = enum_values->getNext()) {
+      if (enum_value->getDataKind() != PDB_DataKind::Constant)
+        continue;
+      AddEnumValue(ast_enum, *enum_value);
     }
-    else if (auto type_def = llvm::dyn_cast<PDBSymbolTypeTypedef>(&type))
-    {
-        Type *target_type = m_ast.GetSymbolFile()->ResolveTypeUID(type_def->getTypeId());
-        std::string name = type_def->getName();
-        uint64_t bytes = type_def->getLength();
-        if (!target_type)
-            return nullptr;
-        CompilerType target_ast_type = target_type->GetFullCompilerType();
-        CompilerDeclContext target_decl_ctx = m_ast.GetSymbolFile()->GetDeclContextForUID(target_type->GetID());
-        CompilerType ast_typedef = m_ast.CreateTypedefType(target_ast_type, name.c_str(), target_decl_ctx);
-        return std::make_shared<Type>(type_def->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name), bytes,
-                                      nullptr, target_type->GetID(), Type::eEncodingIsTypedefUID, decl, ast_typedef,
-                                      Type::eResolveStateFull);
-    }
-    else if (auto func_sig = llvm::dyn_cast<PDBSymbolTypeFunctionSig>(&type))
-    {
-        auto arg_enum = func_sig->getArguments();
-        uint32_t num_args = arg_enum->getChildCount();
-        std::vector<CompilerType> arg_list(num_args);
-        while (auto arg = arg_enum->getNext())
-        {
-            Type *arg_type = m_ast.GetSymbolFile()->ResolveTypeUID(arg->getSymIndexId());
-            // If there's some error looking up one of the dependent types of this function signature, bail.
-            if (!arg_type)
-                return nullptr;
-            CompilerType arg_ast_type = arg_type->GetFullCompilerType();
-            arg_list.push_back(arg_ast_type);
-        }
-        auto pdb_return_type = func_sig->getReturnType();
-        Type *return_type = m_ast.GetSymbolFile()->ResolveTypeUID(pdb_return_type->getSymIndexId());
-        // If there's some error looking up one of the dependent types of this function signature, bail.
-        if (!return_type)
-            return nullptr;
-        CompilerType return_ast_type = return_type->GetFullCompilerType();
-        uint32_t type_quals = 0;
-        if (func_sig->isConstType())
-            type_quals |= clang::Qualifiers::Const;
-        if (func_sig->isVolatileType())
-            type_quals |= clang::Qualifiers::Volatile;
-        CompilerType func_sig_ast_type =
-            m_ast.CreateFunctionType(return_ast_type, &arg_list[0], num_args, false, type_quals);
-
-        return std::make_shared<Type>(func_sig->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(), 0, nullptr,
-                                      LLDB_INVALID_UID, Type::eEncodingIsUID, decl, func_sig_ast_type,
-                                      Type::eResolveStateFull);
-    }
-    else if (auto array_type = llvm::dyn_cast<PDBSymbolTypeArray>(&type))
-    {
-        uint32_t num_elements = array_type->getCount();
-        uint32_t element_uid = array_type->getElementType()->getSymIndexId();
-        uint32_t bytes = array_type->getLength();
-
-        Type *element_type = m_ast.GetSymbolFile()->ResolveTypeUID(element_uid);
-        CompilerType element_ast_type = element_type->GetFullCompilerType();
-        CompilerType array_ast_type = m_ast.CreateArrayType(element_ast_type, num_elements, false);
-        return std::make_shared<Type>(array_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(), bytes, nullptr,
-                                      LLDB_INVALID_UID, Type::eEncodingIsUID, decl, array_ast_type,
-                                      Type::eResolveStateFull);
+
+    return std::make_shared<Type>(type.getSymIndexId(), m_ast.GetSymbolFile(),
+                                  ConstString(name), bytes, nullptr,
+                                  LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
+                                  ast_enum, Type::eResolveStateFull);
+  } else if (auto type_def = llvm::dyn_cast<PDBSymbolTypeTypedef>(&type)) {
+    Type *target_type =
+        m_ast.GetSymbolFile()->ResolveTypeUID(type_def->getTypeId());
+    std::string name = type_def->getName();
+    uint64_t bytes = type_def->getLength();
+    if (!target_type)
+      return nullptr;
+    CompilerType target_ast_type = target_type->GetFullCompilerType();
+    CompilerDeclContext target_decl_ctx =
+        m_ast.GetSymbolFile()->GetDeclContextForUID(target_type->GetID());
+    CompilerType ast_typedef =
+        m_ast.CreateTypedefType(target_ast_type, name.c_str(), target_decl_ctx);
+    return std::make_shared<Type>(
+        type_def->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name),
+        bytes, nullptr, target_type->GetID(), Type::eEncodingIsTypedefUID, decl,
+        ast_typedef, Type::eResolveStateFull);
+  } else if (auto func_sig = llvm::dyn_cast<PDBSymbolTypeFunctionSig>(&type)) {
+    auto arg_enum = func_sig->getArguments();
+    uint32_t num_args = arg_enum->getChildCount();
+    std::vector<CompilerType> arg_list(num_args);
+    while (auto arg = arg_enum->getNext()) {
+      Type *arg_type =
+          m_ast.GetSymbolFile()->ResolveTypeUID(arg->getSymIndexId());
+      // If there's some error looking up one of the dependent types of this
+      // function signature, bail.
+      if (!arg_type)
+        return nullptr;
+      CompilerType arg_ast_type = arg_type->GetFullCompilerType();
+      arg_list.push_back(arg_ast_type);
     }
-    return nullptr;
+    auto pdb_return_type = func_sig->getReturnType();
+    Type *return_type =
+        m_ast.GetSymbolFile()->ResolveTypeUID(pdb_return_type->getSymIndexId());
+    // If there's some error looking up one of the dependent types of this
+    // function signature, bail.
+    if (!return_type)
+      return nullptr;
+    CompilerType return_ast_type = return_type->GetFullCompilerType();
+    uint32_t type_quals = 0;
+    if (func_sig->isConstType())
+      type_quals |= clang::Qualifiers::Const;
+    if (func_sig->isVolatileType())
+      type_quals |= clang::Qualifiers::Volatile;
+    CompilerType func_sig_ast_type = m_ast.CreateFunctionType(
+        return_ast_type, &arg_list[0], num_args, false, type_quals);
+
+    return std::make_shared<Type>(
+        func_sig->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(), 0,
+        nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
+        func_sig_ast_type, Type::eResolveStateFull);
+  } else if (auto array_type = llvm::dyn_cast<PDBSymbolTypeArray>(&type)) {
+    uint32_t num_elements = array_type->getCount();
+    uint32_t element_uid = array_type->getElementType()->getSymIndexId();
+    uint32_t bytes = array_type->getLength();
+
+    Type *element_type = m_ast.GetSymbolFile()->ResolveTypeUID(element_uid);
+    CompilerType element_ast_type = element_type->GetFullCompilerType();
+    CompilerType array_ast_type =
+        m_ast.CreateArrayType(element_ast_type, num_elements, false);
+    return std::make_shared<Type>(
+        array_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
+        bytes, nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
+        array_ast_type, Type::eResolveStateFull);
+  }
+  return nullptr;
 }
 
-bool
-PDBASTParser::AddEnumValue(CompilerType enum_type, const PDBSymbolData &enum_value) const
-{
-    Declaration decl;
-    Variant v = enum_value.getValue();
-    std::string name = enum_value.getName();
-    int64_t raw_value;
-    switch (v.Type)
-    {
-        case PDB_VariantType::Int8:
-            raw_value = v.Value.Int8;
-            break;
-        case PDB_VariantType::Int16:
-            raw_value = v.Value.Int16;
-            break;
-        case PDB_VariantType::Int32:
-            raw_value = v.Value.Int32;
-            break;
-        case PDB_VariantType::Int64:
-            raw_value = v.Value.Int64;
-            break;
-        case PDB_VariantType::UInt8:
-            raw_value = v.Value.UInt8;
-            break;
-        case PDB_VariantType::UInt16:
-            raw_value = v.Value.UInt16;
-            break;
-        case PDB_VariantType::UInt32:
-            raw_value = v.Value.UInt32;
-            break;
-        case PDB_VariantType::UInt64:
-            raw_value = v.Value.UInt64;
-            break;
-        default:
-            return false;
-    }
-    CompilerType underlying_type = m_ast.GetEnumerationIntegerType(enum_type.GetOpaqueQualType());
-    uint32_t byte_size = m_ast.getASTContext()->getTypeSize(ClangUtil::GetQualType(underlying_type));
-    return m_ast.AddEnumerationValueToEnumerationType(enum_type.GetOpaqueQualType(), underlying_type, decl,
-                                                      name.c_str(), raw_value, byte_size * 8);
+bool PDBASTParser::AddEnumValue(CompilerType enum_type,
+                                const PDBSymbolData &enum_value) const {
+  Declaration decl;
+  Variant v = enum_value.getValue();
+  std::string name = enum_value.getName();
+  int64_t raw_value;
+  switch (v.Type) {
+  case PDB_VariantType::Int8:
+    raw_value = v.Value.Int8;
+    break;
+  case PDB_VariantType::Int16:
+    raw_value = v.Value.Int16;
+    break;
+  case PDB_VariantType::Int32:
+    raw_value = v.Value.Int32;
+    break;
+  case PDB_VariantType::Int64:
+    raw_value = v.Value.Int64;
+    break;
+  case PDB_VariantType::UInt8:
+    raw_value = v.Value.UInt8;
+    break;
+  case PDB_VariantType::UInt16:
+    raw_value = v.Value.UInt16;
+    break;
+  case PDB_VariantType::UInt32:
+    raw_value = v.Value.UInt32;
+    break;
+  case PDB_VariantType::UInt64:
+    raw_value = v.Value.UInt64;
+    break;
+  default:
+    return false;
+  }
+  CompilerType underlying_type =
+      m_ast.GetEnumerationIntegerType(enum_type.GetOpaqueQualType());
+  uint32_t byte_size = m_ast.getASTContext()->getTypeSize(
+      ClangUtil::GetQualType(underlying_type));
+  return m_ast.AddEnumerationValueToEnumerationType(
+      enum_type.GetOpaqueQualType(), underlying_type, decl, name.c_str(),
+      raw_value, byte_size * 8);
 }