[PDB] Treat `char`, `signed char` and `unsigned char` as three different types

[aleksandr.urakov]

Summary

char, signed char and unsigned char are three different types, and they are mangled differently:

void __declspec(dllexport) /* ?foo@@YAXD@Z */ foo(char c) { } 
void __declspec(dllexport) /* ?foo@@YAXE@Z */ foo(unsigned char c) { }
void __declspec(dllexport) /* ?foo@@YAXC@Z */ foo(signed char c) { }

[asmith]

LGTM

[zturner]

Can you change the description of the patch before submitting it? It's hard to understand why the change does what the description says it does, because the description mentions 3 types of chars but the patch only handles 1. I would just make the description say "handle char as a builtin type" or something

[aleksandr.urakov]

Yes, sure! Thanks all!

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 signed char SCharTypedef;
+SCharTypedef SCVar;
+
 typedef char16_t WChar16Typedef;
 WChar16Typedef WC16Var;
 
 typedef char32_t WChar32Typedef;
 WChar32Typedef WC32Var;
 
 typedef wchar_t WCharTypedef;
 WCharTypedef WCVar;
 
 int main() {
   return 0;
 }

lldb/trunk/lit/SymbolFile/PDB/ast-restore.test

 CLASS:     }
 CLASS: }
 
 INNER: Module: {{.*}}
 INNER: namespace N0 {
 INNER:     namespace N1 {
 INNER:         class Class : public N0::N1::Base {
 INNER:             struct Inner {
-INNER:                 signed char x;
+INNER:                 char x;
 INNER:                 short y;
 INNER:                 int z;
 INNER:             };
 INNER:         };
 INNER:     }
 INNER: }
 
 FOO: Module: {{.*}}
 FOO: namespace N0 {
 FOO:     namespace N1 {
 FOO:         void foo();
 FOO:     }
 FOO: }
 
 MAIN: Module: {{.*}}
 MAIN: int main();

lldb/trunk/lit/SymbolFile/PDB/func-symbols.test

 REQUIRES: windows
 RUN: clang-cl -m32 /Z7 /c /GS- %S/Inputs/FuncSymbolsTestMain.cpp /o %T/FuncSymbolsTestMain.cpp.obj
 RUN: clang-cl -m32 /Z7 /c /GS- %S/Inputs/FuncSymbols.cpp /o %T/FuncSymbols.cpp.obj
 RUN: link %T/FuncSymbolsTestMain.cpp.obj %T/FuncSymbols.cpp.obj /DEBUG /nodefaultlib /Entry:main /OUT:%T/FuncSymbolsTest.exe
 RUN: lldb-test symbols %T/FuncSymbolsTest.exe | FileCheck --check-prefix=CHECK-ONE %s
 RUN: lldb-test symbols %T/FuncSymbolsTest.exe | FileCheck --check-prefix=CHECK-TWO %s
 
 ; Link multiple objects
 ; In this test, We don't check demangled name of a mangled function.
 
 CHECK-ONE: Module [[MD:.*]]
 CHECK-ONE-DAG: {{.*}}: SymbolVendor ([[MD]])
 CHECK-ONE-DAG: [[TY0:.*]]:   Type{[[UID0:.*]]} , name = "Func_arg_array", decl = FuncSymbolsTestMain.cpp:3, compiler_type = {{.*}} int (int *)
 CHECK-ONE-DAG: [[TY1:.*]]:   Type{[[UID1:.*]]} , name = "Func_arg_void", decl = FuncSymbolsTestMain.cpp:4, compiler_type = {{.*}} void (void)
 CHECK-ONE-DAG: [[TY2:.*]]:   Type{[[UID2:.*]]} , name = "Func_arg_none", decl = FuncSymbolsTestMain.cpp:5, compiler_type = {{.*}} void (void)
 CHECK-ONE-DAG: [[TY3:.*]]:   Type{[[UID3:.*]]} , name = "Func_varargs", decl = FuncSymbolsTestMain.cpp:6, compiler_type = {{.*}} void (...)
-CHECK-ONE-DAG: [[TY4:.*]]:   Type{[[UID4:.*]]} , name = "Func", decl = FuncSymbolsTestMain.cpp:28, compiler_type = {{.*}} void (signed char, int)
+CHECK-ONE-DAG: [[TY4:.*]]:   Type{[[UID4:.*]]} , name = "Func", decl = FuncSymbolsTestMain.cpp:28, compiler_type = {{.*}} void (char, int)
 CHECK-ONE-DAG: [[TY5:.*]]:   Type{[[UID5:.*]]} , name = "main", decl = FuncSymbolsTestMain.cpp:44, compiler_type = {{.*}} int (void)
 CHECK-ONE-DAG: [[TY6:.*]]:   Type{[[UID6:.*]]} , name = "Func", decl = FuncSymbolsTestMain.cpp:24, compiler_type = {{.*}} void (int, const long, volatile _Bool, ...)
 CHECK-ONE-DAG: [[TY7:.*]]:   Type{[[UID7:.*]]} , name = "StaticFunction", decl = FuncSymbolsTestMain.cpp:35, compiler_type = {{.*}} long (int)
 CHECK-ONE-DAG: [[TY8:.*]]:   Type{[[UID8:.*]]} , name = "Func", decl = FuncSymbolsTestMain.cpp:12, compiler_type = {{.*}} int (int, ...)
 CHECK-ONE-DAG: [[TY9:.*]]:   Type{[[UID9:.*]]} , name = "TemplateFunc<1,int>", decl = FuncSymbolsTestMain.cpp:18, compiler_type = {{.*}} void (int)
 CHECK-ONE-DAG: [[TY10:.*]]:   Type{[[UID10:.*]]} , name = "TemplateFunc<1,int,int,int>", decl = FuncSymbolsTestMain.cpp:18, compiler_type = {{.*}} void (int, int, int)
 CHECK-ONE-DAG: [[TY11:.*]]:   Type{[[UID11:.*]]} , name = "InlinedFunction", decl = FuncSymbolsTestMain.cpp:40, compiler_type = {{.*}} void (long)
 

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

 CHECK-DAG: Type{{.*}} , compiler_type = {{.*}} long long (int &, unsigned char **, short *, const double, volatile _Bool)
 CHECK-DAG: Type{{.*}} , name = "FuncPtrTypedef", compiler_type = {{.*}} typedef FuncPtrTypedef
 
 CHECK-DAG: Type{{.*}} , name = "void", compiler_type = {{.*}} void
 CHECK-DAG: Type{{.*}} , size = 4, compiler_type = {{.*}} void *
 CHECK-DAG: Type{{.*}} , name = "long", size = 4, compiler_type = {{.*}} long
 CHECK-DAG: Type{{.*}} , name = "unsigned short", size = 2, compiler_type = {{.*}} unsigned short
 CHECK-DAG: Type{{.*}} , name = "unsigned int", size = 4, compiler_type = {{.*}} unsigned int
+CHECK-DAG: Type{{.*}} , name = "char", size = 1, compiler_type = {{.*}} char
 CHECK-DAG: Type{{.*}} , name = "signed char", size = 1, compiler_type = {{.*}} signed char
-CHECK-DAG: Type{{.*}} , compiler_type = {{.*}} signed char (void *, long, unsigned short, unsigned int, ...)
-CHECK-DAG: Type{{.*}} , size = 4, compiler_type = {{.*}} signed char (*)(void *, long, unsigned short, unsigned int, ...)
+CHECK-DAG: Type{{.*}} , compiler_type = {{.*}} char (void *, long, unsigned short, unsigned int, ...)
+CHECK-DAG: Type{{.*}} , size = 4, compiler_type = {{.*}} char (*)(void *, long, unsigned short, unsigned int, ...)
 CHECK-DAG: Type{{.*}} , name = "VarArgsFuncTypedef", compiler_type = {{.*}} typedef VarArgsFuncTypedef
 
 CHECK-DAG: Type{{.*}} , name = "float", size = 4, compiler_type = {{.*}} float
 CHECK-DAG: Type{{.*}} , compiler_type = {{.*}} float (...)
 CHECK-DAG: Type{{.*}} , size = 4, compiler_type = {{.*}} float (*)(...)
 CHECK-DAG: Type{{.*}} , name = "VarArgsFuncTypedefA", compiler_type = {{.*}} typedef VarArgsFuncTypedefA
 
 CHECK-DAG: {{^[0-9A-F]+}}:   CompileUnit{{[{]0x[0-9a-f]+[}]}}, language = "c++", file = '{{.*}}\SimpleTypesTest.cpp'

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

GetBuiltinTypeForPDBEncodingAndBitSize(ClangASTContext &clang_ast,
 
   switch (pdb_type.getBuiltinType()) {
   default:
     break;
   case PDB_BuiltinType::None:
     return CompilerType();
   case PDB_BuiltinType::Void:
     return clang_ast.GetBasicType(eBasicTypeVoid);
+  case PDB_BuiltinType::Char:
+    return clang_ast.GetBasicType(eBasicTypeChar);
   case PDB_BuiltinType::Bool:
     return clang_ast.GetBasicType(eBasicTypeBool);
   case PDB_BuiltinType::Long:
     if (width == ast->getTypeSize(ast->LongTy))
       return CompilerType(ast, ast->LongTy);
     if (width == ast->getTypeSize(ast->LongLongTy))
       return CompilerType(ast, ast->LongLongTy);
     break;