[SymbolFilePDB] Add missing Char16 and Char32 types in a few places

[clayborg]

Test?

[asmith]

Add test

[zturner]

Lgtm

lldb/trunk/lit/SymbolFile/PDB/Inputs/SimpleTypesTest.cpp

 
 // scoped enum
 enum class EnumClass { YES, NO, DEFAULT };
 EnumClass EnumClassVar;
 
 enum struct EnumStruct { red, blue, black };
 EnumStruct EnumStructVar;
 
+typedef char16_t WChar16Typedef;
+WChar16Typedef WC16Var;
+
+typedef char32_t WChar32Typedef;
+WChar32Typedef WC32Var;
+
 int main() {
   return 0;
 }

lldb/trunk/lit/SymbolFile/PDB/typedefs.test

 REQUIRES: windows
 RUN: clang-cl -m32 /Z7 /c /GS- %S/Inputs/SimpleTypesTest.cpp /o %T/SimpleTypesTest.cpp.typedefs.obj
 RUN: link %T/SimpleTypesTest.cpp.typedefs.obj /DEBUG /nodefaultlib /ENTRY:main /OUT:%T/SimpleTypesTest.cpp.typedefs.exe
 RUN: lldb-test symbols %T/SimpleTypesTest.cpp.typedefs.exe | FileCheck %s
 
 ; Generate 32-bit target
 
 ; FIXME: PDB does not have line information for typedef statements so source
 ; and line information for them is not tested.
 
 ; Note, types `long double` and `double` have same bit size in MSVC and there
 ; is no information in the PDB to distinguish them. So the compiler type for
 ; both of them is the same.
 
 CHECK: Module [[MOD:.*]]
 CHECK: {{^[0-9A-F]+}}: SymbolVendor ([[MOD]])
+CHECK-DAG: name = "char32_t", size = 4, compiler_type = {{.*}} char32_t
+CHECK-DAG: name = "char16_t", size = 2, compiler_type = {{.*}} char16_t
 CHECK-DAG: Type{{.*}} , name = "unsigned long", size = 4, compiler_type = {{.*}} unsigned long
 CHECK-DAG: Type{{.*}} , size = 40, compiler_type = {{.*}} unsigned long [10]
 CHECK-DAG: Type{{.*}} , name = "ULongArrayTypedef", compiler_type = {{.*}} typedef ULongArrayTypedef
 
 ; Note: compiler_type of `long double` is represented by the one for `double`
 CHECK-DAG: Type{{.*}} , name = "double", size = 8, compiler_type = {{.*}} double
 CHECK-DAG: Type{{.*}} , size = 4, compiler_type = {{.*}} double *
 CHECK-DAG: Type{{.*}} , size = 4, compiler_type = {{.*}} double *&

lldb/trunk/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

 
 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:
+  case PDB_BuiltinType::Char16:
+  case PDB_BuiltinType::Char32:
     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;
if (width == ast->getTypeSize(ast->UnsignedLongTy))
       return CompilerType(ast, ast->UnsignedLongTy);
     if (width == ast->getTypeSize(ast->UnsignedLongLongTy))
       return CompilerType(ast, ast->UnsignedLongLongTy);
     break;
   case PDB_BuiltinType::WCharT:
     if (width == ast->getTypeSize(ast->WCharTy))
       return CompilerType(ast, ast->WCharTy);
     break;
+  case PDB_BuiltinType::Char16:
+    return CompilerType(ast, ast->Char16Ty);
+  case PDB_BuiltinType::Char32:
+    return CompilerType(ast, ast->Char32Ty);
   case PDB_BuiltinType::Float:
     // Note: types `long double` and `double` have same bit size in MSVC and there
     // is no information in the PDB to distinguish them. So when falling back
     // to default search, the compiler type of `long double` will be represented by
     // the one generated for `double`.
     break;
   }
   // If there is no match on PDB_BuiltinType, fall back to default search
ConstString GetPDBBuiltinTypeName(const PDBSymbolTypeBuiltin *pdb_type,
   case PDB_BuiltinType::Bitfield:
     return ConstString("bitfield");
   case PDB_BuiltinType::BSTR:
     return ConstString("BSTR");
   case PDB_BuiltinType::HResult:
     return ConstString("HRESULT");
   case PDB_BuiltinType::BCD:
     return ConstString("BCD");
+  case PDB_BuiltinType::Char16:
+    return ConstString("char16_t");
+  case PDB_BuiltinType::Char32:
+    return ConstString("char32_t");
   case PDB_BuiltinType::None:
     return ConstString("...");
   }
   return compiler_type.GetTypeName();
 }
 
 bool GetDeclarationForSymbol(const PDBSymbol &symbol, Declaration &decl) {
   auto &raw_sym = symbol.getRawSymbol();