[lldb] Update the PDB tests to pass with the VS2019 toolset

[stella.stamenova]

Summary

The pdb lldb tests do not work correctly with both the VS2019 and VS2017 toolsets at the moment. This change updates several of the tests to work with both toolsets. Unfortunately, this makes the tests suboptimal for both toolsets, but we can update them to be better for VS2019 once we officially drop VS2017. This change is meant to bridge the gap until the update happens, so that the buildbots can work with either toolset.

[stella.stamenova]

lldb/test/Shell/SymbolFile/PDB/enums-layout.test

13

This is particularly absurd. VS2017 toolset does not capitalize the name of the file, but VS2019 toolset does.

lldb/test/Shell/SymbolFile/PDB/ast-restore.test

 CLASS-DAG:             static const int ClassStaticConstexpr = 9;
 CLASS-DAG:             static constexpr float ClassStaticConstexprFloat = 10.F;
 CLASS-DAG:             static constexpr double ClassStaticConstexprDouble = 11.;
 CLASS-DAG:             static constexpr double ClassStaticConstexprLongDouble = 12.;
 CLASS-DAG:             static const N0::N1::(anonymous namespace)::Enum ClassStaticConstEnum = 8;
 CLASS-DAG:             static const N0::N1::(anonymous namespace)::ScopedEnum ClassStaticConstScopedEnum = 4;
 CLASS-DAG:             N0::N1::Class::Inner m_inner;
 CLASS-DAG:             {{(inline )?}}Class(N0::N1::(anonymous namespace)::Enum);
-CLASS-DAG:             static {{(inline )?}}int StaticFunc(const N0::N1::Class &);
+CLASS-DAG:             {{(static )?}}{{(inline )?}}int StaticFunc(const N0::N1::Class &);
 CLASS-DAG:             {{(inline )?}}int PrivateFunc(const N0::N1::Class::Inner &);
 CLASS:         };
 CLASS:     }
 CLASS: }
 
 INNER: Module: {{.*}}
 INNER: namespace N0 {
 INNER:     namespace N1 {

lldb/test/Shell/SymbolFile/PDB/class-layout.test

 CLASS:    int m_public;
 CLASS:    Struct m_struct;
 CLASS:    Union m_union;
 CLASS:    int m_private;
 CLASS:    int m_protected;
 CLASS:    Class();
 CLASS:    Class(int);
 CLASS:    ~Class();
-CLASS:    static int {{.*}}StaticMemberFunc(int, ...);
+CLASS:    {{(static )?}}int {{.*}}StaticMemberFunc(int, ...);
 CLASS:    int Get();
 CLASS:    int f(MemberTest::Friend);
 CLASS:    bool operator==(const MemberTest::Class &)
 CLASS:}

lldb/test/Shell/SymbolFile/PDB/enums-layout.test

 REQUIRES: system-windows, msvc
 RUN: %build --compiler=msvc --arch=32 --nodefaultlib --output=%T/SimpleTypesTest.cpp.enums.exe %S/Inputs/SimpleTypesTest.cpp
 RUN: lldb-test symbols %T/SimpleTypesTest.cpp.enums.exe | FileCheck --check-prefix=ENUM %s
 RUN: lldb-test symbols %T/SimpleTypesTest.cpp.enums.exe | FileCheck --check-prefix=ENUM_CONST %s
 RUN: lldb-test symbols %T/SimpleTypesTest.cpp.enums.exe | FileCheck --check-prefix=ENUM_EMPTY %s
 RUN: lldb-test symbols %T/SimpleTypesTest.cpp.enums.exe | FileCheck --check-prefix=ENUM_UCHAR %s
 RUN: lldb-test symbols %T/SimpleTypesTest.cpp.enums.exe | FileCheck --check-prefix=ENUM_CLASS %s
 RUN: lldb-test symbols %T/SimpleTypesTest.cpp.enums.exe | FileCheck --check-prefix=ENUM_STRUCT %s
 
 ; FIXME: PDB does not have information about scoped enumeration (Enum class) so the  
 ; compiler type used is the same as the one for unscoped enumeration.
 
-ENUM:      Type{{.*}} , name = "Enum", size = 4, decl = simpletypestest.cpp:19, compiler_type = {{.*}} enum Enum {
+ENUM:      Type{{.*}} , name = "Enum", size = 4, decl = {{[Ss]}}imple{{[Tt]}}ypes{{[Tt]}}est.cpp:19, compiler_type = {{.*}} enum Enum {
 ENUM_NEXT:    RED,
 ENUM_NEXT:    GREEN,
 ENUM_NEXT:    BLUE
 ENUM_NEXT:}
 
-ENUM_CONST:      Type{{.*}} , name = "EnumConst", size = 4,  decl = simpletypestest.cpp:22, compiler_type = {{.*}} enum EnumConst {
+ENUM_CONST:      Type{{.*}} , name = "EnumConst", size = 4,  decl = {{[Ss]}}imple{{[Tt]}}ypes{{[Tt]}}est.cpp:22, compiler_type = {{.*}} enum EnumConst {
 ENUM_CONST-NEXT:    LOW,
 ENUM_CONST-NEXT:    NORMAL,
 ENUM_CONST-NEXT:    HIGH
 ENUM_CONST-NEXT:}
 
-ENUM_EMPTY:      Type{{.*}} , name = "EnumEmpty", size = 4,  decl = simpletypestest.cpp:25, compiler_type = {{.*}} enum EnumEmpty {
+ENUM_EMPTY:      Type{{.*}} , name = "EnumEmpty", size = 4,  decl = {{[Ss]}}imple{{[Tt]}}ypes{{[Tt]}}est.cpp:25, compiler_type = {{.*}} enum EnumEmpty {
 ENUM_EMPTY-NEXT:}
 
-ENUM_UCHAR:      Type{{.*}} , name = "EnumUChar", size = 1,  decl = simpletypestest.cpp:28, compiler_type = {{.*}} enum EnumUChar {
+ENUM_UCHAR:      Type{{.*}} , name = "EnumUChar", size = 1,  decl = {{[Ss]}}imple{{[Tt]}}ypes{{[Tt]}}est.cpp:28, compiler_type = {{.*}} enum EnumUChar {
 ENUM_UCHAR-NEXT:    ON,
 ENUM_UCHAR-NEXT:    OFF,
 ENUM_UCHAR-NEXT:    AUTO
 ENUM_UCHAR-NEXT:}
 
 ; Note that `enum EnumClass` is tested instead of `enum class EnumClass`
-ENUM_CLASS:      Type{{.*}} , name = "EnumClass", size = 4,  decl = simpletypestest.cpp:32, compiler_type = {{.*}} enum EnumClass {
+ENUM_CLASS:      Type{{.*}} , name = "EnumClass", size = 4,  decl = {{[Ss]}}imple{{[Tt]}}ypes{{[Tt]}}est.cpp:32, compiler_type = {{.*}} enum EnumClass {
 ENUM_CLASS-NEXT:    YES,
 ENUM_CLASS-NEXT:    NO,
 ENUM_CLASS-NEXT:    DEFAULT
 ENUM_CLASS-NEXT:}
 
-ENUM_STRUCT:      Type{{.*}} , name = "EnumStruct", size = 4,  decl = simpletypestest.cpp:35, compiler_type = {{.*}} enum EnumStruct {
+ENUM_STRUCT:      Type{{.*}} , name = "EnumStruct", size = 4,  decl = {{[Ss]}}imple{{[Tt]}}ypes{{[Tt]}}est.cpp:35, compiler_type = {{.*}} enum EnumStruct {
 ENUM_STRUCT-NEXT:    red,
 ENUM_STRUCT-NEXT:    blue,
 ENUM_STRUCT-NEXT:    black
 ENUM_STRUCT-NEXT:}

lldb/test/Shell/SymbolFile/PDB/typedefs.test

 ; both of them is the same.
 
 CHECK: Module [[MOD:.*]]
 CHECK: SymbolFile pdb ([[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 *&
 CHECK-DAG: Type{{.*}} , name = "RefTypedef", compiler_type = {{.*}} typedef RefTypedef
 
 CHECK-DAG: Type{{.*}} , name = "wchar_t", size = 2, compiler_type = {{.*}} wchar_t

lldb/test/Shell/SymbolFile/PDB/variables.test

 FUNC-MAIN-SAME:                     scope = local
 FUNC-MAIN-NEXT:     Variable{{.*}}, name = "local_CString"
 FUNC-MAIN-SAME:                     scope = local
 FUNC-MAIN-NEXT:     Variable{{.*}}, name = "local_pCString"
 FUNC-MAIN-SAME:                     scope = local
 FUNC-MAIN-NEXT:     Variable{{.*}}, name = "a"
 FUNC-MAIN-SAME:                     scope = local
 
-FUNC-CONSTRUCTOR:      Function{{.*}}, mangled = ??0Class@@QEAA@H@Z
+FUNC-CONSTRUCTOR:      Function{{.*}}, {{(de)?}}mangled = {{.*}}{{(Class::)?}}Class{{.*}}
 FUNC-CONSTRUCTOR-NEXT:   Block
 FUNC-CONSTRUCTOR-NEXT:     Variable{{.*}}, name = "this"
 FUNC-CONSTRUCTOR-SAME:                     scope = parameter
 FUNC-CONSTRUCTOR-SAME:                     artificial
 FUNC-CONSTRUCTOR-NEXT:     Variable{{.*}}, name = "a"
 FUNC-CONSTRUCTOR-SAME:                     scope = parameter
 
-FUNC-MEMBER:      Function{{.*}}, mangled = ?Func@Class@@QEAAXXZ
+FUNC-MEMBER:      Function{{.*}}, {{(de)?}}mangled = {{.*}}{{(Class::)?}}Func{{.*}}
 FUNC-MEMBER-NEXT:   Block
 FUNC-MEMBER-NEXT:     Variable{{.*}}, name = "this"
 FUNC-MEMBER-SAME:                     scope = parameter
 FUNC-MEMBER-SAME:                     artificial