Index: lldb/trunk/lit/SymbolFile/NativePDB/Inputs/globals-fundamental.lldbinit =================================================================== --- lldb/trunk/lit/SymbolFile/NativePDB/Inputs/globals-fundamental.lldbinit +++ lldb/trunk/lit/SymbolFile/NativePDB/Inputs/globals-fundamental.lldbinit @@ -0,0 +1,220 @@ +target variable BFalse +target variable BTrue +target variable CA +target variable CZ +target variable SCa +target variable SCz +target variable UC24 +target variable UC42 +target variable C16_24 +target variable C32_42 +target variable WC1 +target variable WCP +target variable SMax +target variable SMin +target variable USMax +target variable USMin +target variable IMax +target variable IMin +target variable UIMax +target variable UIMin +target variable LMax +target variable LMin +target variable ULMax +target variable ULMin +target variable LLMax +target variable LLMin +target variable ULLMax +target variable ULLMin +target variable F +target variable D + +target variable CBFalse +target variable CBTrue +target variable CCA +target variable CCZ +target variable CSCa +target variable CSCz +target variable CUC24 +target variable CUC42 +target variable CC16_24 +target variable CC32_42 +target variable CWC1 +target variable CWCP +target variable CSMax +target variable CSMin +target variable CUSMax +target variable CUSMin +target variable CIMax +target variable CIMin +target variable CUIMax +target variable CUIMin +target variable CLMax +target variable CLMin +target variable CULMax +target variable CULMin +target variable CLLMax +target variable CLLMin +target variable CULLMax +target variable CULLMin +target variable CF +target variable CD + +target variable ConstexprBFalse +target variable ConstexprBTrue +target variable ConstexprCA +target variable ConstexprCZ +target variable ConstexprSCa +target variable ConstexprSCz +target variable ConstexprUC24 +target variable ConstexprUC42 +target variable ConstexprC16_24 +target variable ConstexprC32_42 +target variable ConstexprWC1 +target variable ConstexprWCP +target variable ConstexprSMax +target variable ConstexprSMin +target variable ConstexprUSMax +target variable ConstexprUSMin +target variable ConstexprIMax +target variable ConstexprIMin +target variable ConstexprUIMax +target variable ConstexprUIMin +target variable ConstexprLMax +target variable ConstexprLMin +target variable ConstexprULMax +target variable ConstexprULMin +target variable ConstexprLLMax +target variable ConstexprLLMin +target variable ConstexprULLMax +target variable ConstexprULLMin +target variable ConstexprF +target variable ConstexprD + +target variable PBFalse +target variable PBTrue +target variable PCA +target variable PCZ +target variable PSCa +target variable PSCz +target variable PUC24 +target variable PUC42 +target variable PC16_24 +target variable PC32_42 +target variable PWC1 +target variable PWCP +target variable PSMax +target variable PSMin +target variable PUSMax +target variable PUSMin +target variable PIMax +target variable PIMin +target variable PUIMax +target variable PUIMin +target variable PLMax +target variable PLMin +target variable PULMax +target variable PULMin +target variable PLLMax +target variable PLLMin +target variable PULLMax +target variable PULLMin +target variable PF +target variable PD + +target variable CPBFalse +target variable CPBTrue +target variable CPCA +target variable CPCZ +target variable CPSCa +target variable CPSCz +target variable CPUC24 +target variable CPUC42 +target variable CPC16_24 +target variable CPC32_42 +target variable CPWC1 +target variable CPWCP +target variable CPSMax +target variable CPSMin +target variable CPUSMax +target variable CPUSMin +target variable CPIMax +target variable CPIMin +target variable CPUIMax +target variable CPUIMin +target variable CPLMax +target variable CPLMin +target variable CPULMax +target variable CPULMin +target variable CPLLMax +target variable CPLLMin +target variable CPULLMax +target variable CPULLMin +target variable CPF +target variable CPD + +target variable RBFalse +target variable RBTrue +target variable RCA +target variable RCZ +target variable RSCa +target variable RSCz +target variable RUC24 +target variable RUC42 +target variable RSMax +target variable RSMin +target variable RUSMax +target variable RUSMin +target variable RIMax +target variable RIMin +target variable RUIMax +target variable RUIMin +target variable RLMax +target variable RLMin +target variable RULMax +target variable RULMin +target variable RLLMax +target variable RLLMin +target variable RULLMax +target variable RULLMin +target variable RF +target variable RD + +target variable CRBFalse +target variable CRBTrue +target variable CRCA +target variable CRCZ +target variable CRSCa +target variable CRSCz +target variable CRUC24 +target variable CRUC42 +target variable CRSMax +target variable CRSMin +target variable CRUSMax +target variable CRUSMin +target variable CRIMax +target variable CRIMin +target variable CRUIMax +target variable CRUIMin +target variable CRLMax +target variable CRLMin +target variable CRULMax +target variable CRULMin +target variable CRLLMax +target variable CRLLMin +target variable CRULLMax +target variable CRULLMin +target variable CRF +target variable CRD + +target variable RC16_24 +target variable RC32_42 +target variable RWC1 +target variable RWCP +target variable CRC16_24 +target variable CRC32_42 +target variable CRWC1 +target variable CRWCP + + +quit \ No newline at end of file Index: lldb/trunk/lit/SymbolFile/NativePDB/globals-fundamental.cpp =================================================================== --- lldb/trunk/lit/SymbolFile/NativePDB/globals-fundamental.cpp +++ lldb/trunk/lit/SymbolFile/NativePDB/globals-fundamental.cpp @@ -0,0 +1,668 @@ +// clang-format off +// REQUIRES: lld + +// Test that we can display tag types. +// RUN: clang-cl /Z7 /GS- /GR- /c -Xclang -fkeep-static-consts /Fo%t.obj -- %s +// RUN: lld-link /DEBUG /nodefaultlib /entry:main /OUT:%t.exe /PDB:%t.pdb -- %t.obj +// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \ +// RUN: %p/Inputs/globals-fundamental.lldbinit | FileCheck %s + + +// Fundamental data types +bool BFalse = false; +// CHECK: (lldb) target variable BFalse +// CHECK-NEXT: (bool) BFalse = false +bool BTrue = true; +// CHECK-NEXT: (lldb) target variable BTrue +// CHECK-NEXT: (bool) BTrue = true +char CA = 'A'; +// CHECK-NEXT: (lldb) target variable CA +// CHECK-NEXT: (char) CA = 'A' +char CZ = 'Z'; +// CHECK-NEXT: (lldb) target variable CZ +// CHECK-NEXT: (char) CZ = 'Z' +signed char SCa = 'a'; +// CHECK-NEXT: (lldb) target variable SCa +// CHECK-NEXT: (signed char) SCa = 'a' +signed char SCz = 'z'; +// CHECK-NEXT: (lldb) target variable SCz +// CHECK-NEXT: (signed char) SCz = 'z' +unsigned char UC24 = 24; +// CHECK-NEXT: (lldb) target variable UC24 +// CHECK-NEXT: (unsigned char) UC24 = '\x18' +unsigned char UC42 = 42; +// CHECK-NEXT: (lldb) target variable UC42 +// CHECK-NEXT: (unsigned char) UC42 = '*' +char16_t C16_24 = u'\24'; +// CHECK-NEXT: (lldb) target variable C16_24 +// CHECK-NEXT: (char16_t) C16_24 = U+0014 +char32_t C32_42 = U'\42'; +// CHECK-NEXT: (lldb) target variable C32_42 +// CHECK-NEXT: (char32_t) C32_42 = U+0x00000022 +wchar_t WC1 = L'1'; +// CHECK-NEXT: (lldb) target variable WC1 +// CHECK-NEXT: (wchar_t) WC1 = L'1' +wchar_t WCP = L'P'; +// CHECK-NEXT: (lldb) target variable WCP +// CHECK-NEXT: (wchar_t) WCP = L'P' +short SMax = 32767; +// CHECK-NEXT: (lldb) target variable SMax +// CHECK-NEXT: (short) SMax = 32767 +short SMin = -32768; +// CHECK-NEXT: (lldb) target variable SMin +// CHECK-NEXT: (short) SMin = -32768 +unsigned short USMax = 65535; +// CHECK-NEXT: (lldb) target variable USMax +// CHECK-NEXT: (unsigned short) USMax = 65535 +unsigned short USMin = 0; +// CHECK-NEXT: (lldb) target variable USMin +// CHECK-NEXT: (unsigned short) USMin = 0 +int IMax = 2147483647; +// CHECK-NEXT: (lldb) target variable IMax +// CHECK-NEXT: (int) IMax = 2147483647 +int IMin = -2147483648; +// CHECK-NEXT: (lldb) target variable IMin +// CHECK-NEXT: (int) IMin = -2147483648 +unsigned int UIMax = 4294967295; +// CHECK-NEXT: (lldb) target variable UIMax +// CHECK-NEXT: (unsigned int) UIMax = 4294967295 +unsigned int UIMin = 0; +// CHECK-NEXT: (lldb) target variable UIMin +// CHECK-NEXT: (unsigned int) UIMin = 0 +long LMax = 2147483647; +// CHECK-NEXT: (lldb) target variable LMax +// CHECK-NEXT: (long) LMax = 2147483647 +long LMin = -2147483648; +// CHECK-NEXT: (lldb) target variable LMin +// CHECK-NEXT: (long) LMin = -2147483648 +unsigned long ULMax = 4294967295; +// CHECK-NEXT: (lldb) target variable ULMax +// CHECK-NEXT: (unsigned long) ULMax = 4294967295 +unsigned long ULMin = 0; +// CHECK-NEXT: (lldb) target variable ULMin +// CHECK-NEXT: (unsigned long) ULMin = 0 +long long LLMax = 9223372036854775807LL; +// CHECK-NEXT: (lldb) target variable LLMax +// CHECK-NEXT: (long long) LLMax = 9223372036854775807 +long long LLMin = -9223372036854775807i64 - 1; +// CHECK-NEXT: (lldb) target variable LLMin +// CHECK-NEXT: (long long) LLMin = -9223372036854775808 +unsigned long long ULLMax = 18446744073709551615ULL; +// CHECK-NEXT: (lldb) target variable ULLMax +// CHECK-NEXT: (unsigned long long) ULLMax = 18446744073709551615 +unsigned long long ULLMin = 0; +// CHECK-NEXT: (lldb) target variable ULLMin +// CHECK-NEXT: (unsigned long long) ULLMin = 0 +float F = 3.1415f; +// CHECK-NEXT: (lldb) target variable F +// CHECK-NEXT: (float) F = 3.1415 +double D = 3.1415; +// CHECK-NEXT: (lldb) target variable D +// CHECK-NEXT: (double) D = 3.1415 + +const bool CBFalse = false; +// CHECK-NEXT: (lldb) target variable CBFalse +// CHECK-NEXT: (const bool) CBFalse = false +const bool CBTrue = true; +// CHECK-NEXT: (lldb) target variable CBTrue +// CHECK-NEXT: (const bool) CBTrue = true +const char CCA = 'A'; +// CHECK-NEXT: (lldb) target variable CCA +// CHECK-NEXT: (const char) CCA = 'A' +const char CCZ = 'Z'; +// CHECK-NEXT: (lldb) target variable CCZ +// CHECK-NEXT: (const char) CCZ = 'Z' +const signed char CSCa = 'a'; +// CHECK-NEXT: (lldb) target variable CSCa +// CHECK-NEXT: (const signed char) CSCa = 'a' +const signed char CSCz = 'z'; +// CHECK-NEXT: (lldb) target variable CSCz +// CHECK-NEXT: (const signed char) CSCz = 'z' +const unsigned char CUC24 = 24; +// CHECK-NEXT: (lldb) target variable CUC24 +// CHECK-NEXT: (const unsigned char) CUC24 = '\x18' +const unsigned char CUC42 = 42; +// CHECK-NEXT: (lldb) target variable CUC42 +// CHECK-NEXT: (const unsigned char) CUC42 = '*' +const char16_t CC16_24 = u'\24'; +// CHECK-NEXT: (lldb) target variable CC16_24 +// CHECK-NEXT: (const char16_t) CC16_24 = U+0014 +const char32_t CC32_42 = U'\42'; +// CHECK-NEXT: (lldb) target variable CC32_42 +// CHECK-NEXT: (const char32_t) CC32_42 = U+0x00000022 +const wchar_t CWC1 = L'1'; +// CHECK-NEXT: (lldb) target variable CWC1 +// CHECK-NEXT: (const wchar_t) CWC1 = L'1' +const wchar_t CWCP = L'P'; +// CHECK-NEXT: (lldb) target variable CWCP +// CHECK-NEXT: (const wchar_t) CWCP = L'P' +const short CSMax = 32767; +// CHECK-NEXT: (lldb) target variable CSMax +// CHECK-NEXT: (const short) CSMax = 32767 +const short CSMin = -32768; +// CHECK-NEXT: (lldb) target variable CSMin +// CHECK-NEXT: (const short) CSMin = -32768 +const unsigned short CUSMax = 65535; +// CHECK-NEXT: (lldb) target variable CUSMax +// CHECK-NEXT: (const unsigned short) CUSMax = 65535 +const unsigned short CUSMin = 0; +// CHECK-NEXT: (lldb) target variable CUSMin +// CHECK-NEXT: (const unsigned short) CUSMin = 0 +const int CIMax = 2147483647; +// CHECK-NEXT: (lldb) target variable CIMax +// CHECK-NEXT: (const int) CIMax = 2147483647 +const int CIMin = -2147483648; +// CHECK-NEXT: (lldb) target variable CIMin +// CHECK-NEXT: (const int) CIMin = -2147483648 +const unsigned int CUIMax = 4294967295; +// CHECK-NEXT: (lldb) target variable CUIMax +// CHECK-NEXT: (const unsigned int) CUIMax = 4294967295 +const unsigned int CUIMin = 0; +// CHECK-NEXT: (lldb) target variable CUIMin +// CHECK-NEXT: (const unsigned int) CUIMin = 0 +const long CLMax = 2147483647; +// CHECK-NEXT: (lldb) target variable CLMax +// CHECK-NEXT: (const long) CLMax = 2147483647 +const long CLMin = -2147483648; +// CHECK-NEXT: (lldb) target variable CLMin +// CHECK-NEXT: (const long) CLMin = -2147483648 +const unsigned long CULMax = 4294967295; +// CHECK-NEXT: (lldb) target variable CULMax +// CHECK-NEXT: (const unsigned long) CULMax = 4294967295 +const unsigned long CULMin = 0; +// CHECK-NEXT: (lldb) target variable CULMin +// CHECK-NEXT: (const unsigned long) CULMin = 0 +const long long CLLMax = 9223372036854775807i64; +// CHECK-NEXT: (lldb) target variable CLLMax +// CHECK-NEXT: (const long long) CLLMax = 9223372036854775807 +const long long CLLMin = -9223372036854775807i64 - 1; +// CHECK-NEXT: (lldb) target variable CLLMin +// CHECK-NEXT: (const long long) CLLMin = -9223372036854775808 +const unsigned long long CULLMax = 18446744073709551615ULL; +// CHECK-NEXT: (lldb) target variable CULLMax +// CHECK-NEXT: (const unsigned long long) CULLMax = 18446744073709551615 +const unsigned long long CULLMin = 0; +// CHECK-NEXT: (lldb) target variable CULLMin +// CHECK-NEXT: (const unsigned long long) CULLMin = 0 +const float CF = 3.1415f; +// CHECK-NEXT: (lldb) target variable CF +// CHECK-NEXT: (const float) CF = 3.1415 +const double CD = 3.1415; +// CHECK-NEXT: (lldb) target variable CD +// CHECK-NEXT: (const double) CD = 3.1415 + +// constexpr fundamental data types. +constexpr bool ConstexprBFalse = false; +// CHECK-NEXT: (lldb) target variable ConstexprBFalse +// CHECK-NEXT: (const bool) ConstexprBFalse = false +constexpr bool ConstexprBTrue = true; +// CHECK-NEXT: (lldb) target variable ConstexprBTrue +// CHECK-NEXT: (const bool) ConstexprBTrue = true +constexpr char ConstexprCA = 'A'; +// CHECK-NEXT: (lldb) target variable ConstexprCA +// CHECK-NEXT: (const char) ConstexprCA = 'A' +constexpr char ConstexprCZ = 'Z'; +// CHECK-NEXT: (lldb) target variable ConstexprCZ +// CHECK-NEXT: (const char) ConstexprCZ = 'Z' +constexpr signed char ConstexprSCa = 'a'; +// CHECK-NEXT: (lldb) target variable ConstexprSCa +// CHECK-NEXT: (const signed char) ConstexprSCa = 'a' +constexpr signed char ConstexprSCz = 'z'; +// CHECK-NEXT: (lldb) target variable ConstexprSCz +// CHECK-NEXT: (const signed char) ConstexprSCz = 'z' +constexpr unsigned char ConstexprUC24 = 24; +// CHECK-NEXT: (lldb) target variable ConstexprUC24 +// CHECK-NEXT: (const unsigned char) ConstexprUC24 = '\x18' +constexpr unsigned char ConstexprUC42 = 42; +// CHECK-NEXT: (lldb) target variable ConstexprUC42 +// CHECK-NEXT: (const unsigned char) ConstexprUC42 = '*' +constexpr char16_t ConstexprC16_24 = u'\24'; +// CHECK-NEXT: (lldb) target variable ConstexprC16_24 +// CHECK-NEXT: (const char16_t) ConstexprC16_24 = U+0014 +constexpr char32_t ConstexprC32_42 = U'\42'; +// CHECK-NEXT: (lldb) target variable ConstexprC32_42 +// CHECK-NEXT: (const char32_t) ConstexprC32_42 = U+0x00000022 +constexpr wchar_t ConstexprWC1 = L'1'; +// CHECK-NEXT: (lldb) target variable ConstexprWC1 +// CHECK-NEXT: (const wchar_t) ConstexprWC1 = L'1' +constexpr wchar_t ConstexprWCP = L'P'; +// CHECK-NEXT: (lldb) target variable ConstexprWCP +// CHECK-NEXT: (const wchar_t) ConstexprWCP = L'P' +constexpr short ConstexprSMax = 32767; +// CHECK-NEXT: (lldb) target variable ConstexprSMax +// CHECK-NEXT: (const short) ConstexprSMax = 32767 +constexpr short ConstexprSMin = -32768; +// CHECK-NEXT: (lldb) target variable ConstexprSMin +// CHECK-NEXT: (const short) ConstexprSMin = -32768 +constexpr unsigned short ConstexprUSMax = 65535; +// CHECK-NEXT: (lldb) target variable ConstexprUSMax +// CHECK-NEXT: (const unsigned short) ConstexprUSMax = 65535 +constexpr unsigned short ConstexprUSMin = 0; +// CHECK-NEXT: (lldb) target variable ConstexprUSMin +// CHECK-NEXT: (const unsigned short) ConstexprUSMin = 0 +constexpr int ConstexprIMax = 2147483647; +// CHECK-NEXT: (lldb) target variable ConstexprIMax +// CHECK-NEXT: (const int) ConstexprIMax = 2147483647 +constexpr int ConstexprIMin = -2147483648; +// CHECK-NEXT: (lldb) target variable ConstexprIMin +// CHECK-NEXT: (const int) ConstexprIMin = -2147483648 +constexpr unsigned int ConstexprUIMax = 4294967295; +// CHECK-NEXT: (lldb) target variable ConstexprUIMax +// CHECK-NEXT: (const unsigned int) ConstexprUIMax = 4294967295 +constexpr unsigned int ConstexprUIMin = 0; +// CHECK-NEXT: (lldb) target variable ConstexprUIMin +// CHECK-NEXT: (const unsigned int) ConstexprUIMin = 0 +constexpr long ConstexprLMax = 2147483647; +// CHECK-NEXT: (lldb) target variable ConstexprLMax +// CHECK-NEXT: (const long) ConstexprLMax = 2147483647 +constexpr long ConstexprLMin = -2147483648; +// CHECK-NEXT: (lldb) target variable ConstexprLMin +// CHECK-NEXT: (const long) ConstexprLMin = -2147483648 +constexpr unsigned long ConstexprULMax = 4294967295; +// CHECK-NEXT: (lldb) target variable ConstexprULMax +// CHECK-NEXT: (const unsigned long) ConstexprULMax = 4294967295 +constexpr unsigned long ConstexprULMin = 0; +// CHECK-NEXT: (lldb) target variable ConstexprULMin +// CHECK-NEXT: (const unsigned long) ConstexprULMin = 0 +constexpr long long ConstexprLLMax = 9223372036854775807i64; +// CHECK-NEXT: (lldb) target variable ConstexprLLMax +// CHECK-NEXT: (const long long) ConstexprLLMax = 9223372036854775807 +constexpr long long ConstexprLLMin = -9223372036854775807i64 - 1; +// CHECK-NEXT: (lldb) target variable ConstexprLLMin +// CHECK-NEXT: (const long long) ConstexprLLMin = -9223372036854775808 +constexpr unsigned long long ConstexprULLMax = 18446744073709551615ULL; +// CHECK-NEXT: (lldb) target variable ConstexprULLMax +// CHECK-NEXT: (const unsigned long long) ConstexprULLMax = 18446744073709551615 +constexpr unsigned long long ConstexprULLMin = 0; +// CHECK-NEXT: (lldb) target variable ConstexprULLMin +// CHECK-NEXT: (const unsigned long long) ConstexprULLMin = 0 +constexpr float ConstexprF = 3.1415f; +// CHECK-NEXT: (lldb) target variable ConstexprF +// CHECK-NEXT: (const float) ConstexprF = 3.1415 +constexpr double ConstexprD = 3.1415; +// CHECK-NEXT: (lldb) target variable ConstexprD +// CHECK-NEXT: (const double) ConstexprD = 3.1415 + + +// FIXME: LLDB currently doesn't resolve pointers within the target without a +// running process (I haven't checked whether or not it can with a running +// process). So currently it will just print an address, which is unstable and +// should not be relied upon for testing. So for now we're just checking that +// the variable name and type is correct. We should fix this in LLDB and then +// update the tests. +bool *PBFalse = &BFalse; +// CHECK-NEXT: (lldb) target variable PBFalse +// CHECK-NEXT: (bool *) PBFalse = {{.*}} +bool *PBTrue = &BTrue; +// CHECK-NEXT: (lldb) target variable PBTrue +// CHECK-NEXT: (bool *) PBTrue = {{.*}} +char *PCA = &CA; +// CHECK-NEXT: (lldb) target variable PCA +// CHECK-NEXT: (char *) PCA = {{.*}} +char *PCZ = &CZ; +// CHECK-NEXT: (lldb) target variable PCZ +// CHECK-NEXT: (char *) PCZ = {{.*}} +signed char *PSCa = &SCa; +// CHECK-NEXT: (lldb) target variable PSCa +// CHECK-NEXT: (signed char *) PSCa = {{.*}} +signed char *PSCz = &SCz; +// CHECK-NEXT: (lldb) target variable PSCz +// CHECK-NEXT: (signed char *) PSCz = {{.*}} +unsigned char *PUC24 = &UC24; +// CHECK-NEXT: (lldb) target variable PUC24 +// CHECK-NEXT: (unsigned char *) PUC24 = {{.*}} +unsigned char *PUC42 = &UC42; +// CHECK-NEXT: (lldb) target variable PUC42 +// CHECK-NEXT: (unsigned char *) PUC42 = {{.*}} +char16_t *PC16_24 = &C16_24; +// CHECK-NEXT: (lldb) target variable PC16_24 +// CHECK-NEXT: (char16_t *) PC16_24 = {{.*}} +char32_t *PC32_42 = &C32_42; +// CHECK-NEXT: (lldb) target variable PC32_42 +// CHECK-NEXT: (char32_t *) PC32_42 = {{.*}} +wchar_t *PWC1 = &WC1; +// CHECK-NEXT: (lldb) target variable PWC1 +// CHECK-NEXT: (wchar_t *) PWC1 = {{.*}} +wchar_t *PWCP = &WCP; +// CHECK-NEXT: (lldb) target variable PWCP +// CHECK-NEXT: (wchar_t *) PWCP = {{.*}} +short *PSMax = &SMax; +// CHECK-NEXT: (lldb) target variable PSMax +// CHECK-NEXT: (short *) PSMax = {{.*}} +short *PSMin = &SMin; +// CHECK-NEXT: (lldb) target variable PSMin +// CHECK-NEXT: (short *) PSMin = {{.*}} +unsigned short *PUSMax = &USMax; +// CHECK-NEXT: (lldb) target variable PUSMax +// CHECK-NEXT: (unsigned short *) PUSMax = {{.*}} +unsigned short *PUSMin = &USMin; +// CHECK-NEXT: (lldb) target variable PUSMin +// CHECK-NEXT: (unsigned short *) PUSMin = {{.*}} +int *PIMax = &IMax; +// CHECK-NEXT: (lldb) target variable PIMax +// CHECK-NEXT: (int *) PIMax = {{.*}} +int *PIMin = &IMin; +// CHECK-NEXT: (lldb) target variable PIMin +// CHECK-NEXT: (int *) PIMin = {{.*}} +unsigned int *PUIMax = &UIMax; +// CHECK-NEXT: (lldb) target variable PUIMax +// CHECK-NEXT: (unsigned int *) PUIMax = {{.*}} +unsigned int *PUIMin = &UIMin; +// CHECK-NEXT: (lldb) target variable PUIMin +// CHECK-NEXT: (unsigned int *) PUIMin = {{.*}} +long *PLMax = &LMax; +// CHECK-NEXT: (lldb) target variable PLMax +// CHECK-NEXT: (long *) PLMax = {{.*}} +long *PLMin = &LMin; +// CHECK-NEXT: (lldb) target variable PLMin +// CHECK-NEXT: (long *) PLMin = {{.*}} +unsigned long *PULMax = &ULMax; +// CHECK-NEXT: (lldb) target variable PULMax +// CHECK-NEXT: (unsigned long *) PULMax = {{.*}} +unsigned long *PULMin = &ULMin; +// CHECK-NEXT: (lldb) target variable PULMin +// CHECK-NEXT: (unsigned long *) PULMin = {{.*}} +long long *PLLMax = &LLMax; +// CHECK-NEXT: (lldb) target variable PLLMax +// CHECK-NEXT: (long long *) PLLMax = {{.*}} +long long *PLLMin = &LLMin; +// CHECK-NEXT: (lldb) target variable PLLMin +// CHECK-NEXT: (long long *) PLLMin = {{.*}} +unsigned long long *PULLMax = &ULLMax; +// CHECK-NEXT: (lldb) target variable PULLMax +// CHECK-NEXT: (unsigned long long *) PULLMax = {{.*}} +unsigned long long *PULLMin = &ULLMin; +// CHECK-NEXT: (lldb) target variable PULLMin +// CHECK-NEXT: (unsigned long long *) PULLMin = {{.*}} +float *PF = &F; +// CHECK-NEXT: (lldb) target variable PF +// CHECK-NEXT: (float *) PF = {{.*}} +double *PD = &D; +// CHECK-NEXT: (lldb) target variable PD +// CHECK-NEXT: (double *) PD = {{.*}} + +// Const pointers to fundamental data types +const bool *CPBFalse = &BFalse; +// CHECK-NEXT: (lldb) target variable CPBFalse +// CHECK-NEXT: (const bool *) CPBFalse = {{.*}} +const bool *CPBTrue = &BTrue; +// CHECK-NEXT: (lldb) target variable CPBTrue +// CHECK-NEXT: (const bool *) CPBTrue = {{.*}} +const char *CPCA = &CA; +// CHECK-NEXT: (lldb) target variable CPCA +// CHECK-NEXT: (const char *) CPCA = {{.*}} +const char *CPCZ = &CZ; +// CHECK-NEXT: (lldb) target variable CPCZ +// CHECK-NEXT: (const char *) CPCZ = {{.*}} +const signed char *CPSCa = &SCa; +// CHECK-NEXT: (lldb) target variable CPSCa +// CHECK-NEXT: (const signed char *) CPSCa = {{.*}} +const signed char *CPSCz = &SCz; +// CHECK-NEXT: (lldb) target variable CPSCz +// CHECK-NEXT: (const signed char *) CPSCz = {{.*}} +const unsigned char *CPUC24 = &UC24; +// CHECK-NEXT: (lldb) target variable CPUC24 +// CHECK-NEXT: (const unsigned char *) CPUC24 = {{.*}} +const unsigned char *CPUC42 = &UC42; +// CHECK-NEXT: (lldb) target variable CPUC42 +// CHECK-NEXT: (const unsigned char *) CPUC42 = {{.*}} +const char16_t *CPC16_24 = &C16_24; +// CHECK-NEXT: (lldb) target variable CPC16_24 +// CHECK-NEXT: (const char16_t *) CPC16_24 = {{.*}} +const char32_t *CPC32_42 = &C32_42; +// CHECK-NEXT: (lldb) target variable CPC32_42 +// CHECK-NEXT: (const char32_t *) CPC32_42 = {{.*}} +const wchar_t *CPWC1 = &WC1; +// CHECK-NEXT: (lldb) target variable CPWC1 +// CHECK-NEXT: (const wchar_t *) CPWC1 = {{.*}} +const wchar_t *CPWCP = &WCP; +// CHECK-NEXT: (lldb) target variable CPWCP +// CHECK-NEXT: (const wchar_t *) CPWCP = {{.*}} +const short *CPSMax = &SMax; +// CHECK-NEXT: (lldb) target variable CPSMax +// CHECK-NEXT: (const short *) CPSMax = {{.*}} +const short *CPSMin = &SMin; +// CHECK-NEXT: (lldb) target variable CPSMin +// CHECK-NEXT: (const short *) CPSMin = {{.*}} +const unsigned short *CPUSMax = &USMax; +// CHECK-NEXT: (lldb) target variable CPUSMax +// CHECK-NEXT: (const unsigned short *) CPUSMax = {{.*}} +const unsigned short *CPUSMin = &USMin; +// CHECK-NEXT: (lldb) target variable CPUSMin +// CHECK-NEXT: (const unsigned short *) CPUSMin = {{.*}} +const int *CPIMax = &IMax; +// CHECK-NEXT: (lldb) target variable CPIMax +// CHECK-NEXT: (const int *) CPIMax = {{.*}} +const int *CPIMin = &IMin; +// CHECK-NEXT: (lldb) target variable CPIMin +// CHECK-NEXT: (const int *) CPIMin = {{.*}} +const unsigned int *CPUIMax = &UIMax; +// CHECK-NEXT: (lldb) target variable CPUIMax +// CHECK-NEXT: (const unsigned int *) CPUIMax = {{.*}} +const unsigned int *CPUIMin = &UIMin; +// CHECK-NEXT: (lldb) target variable CPUIMin +// CHECK-NEXT: (const unsigned int *) CPUIMin = {{.*}} +const long *CPLMax = &LMax; +// CHECK-NEXT: (lldb) target variable CPLMax +// CHECK-NEXT: (const long *) CPLMax = {{.*}} +const long *CPLMin = &LMin; +// CHECK-NEXT: (lldb) target variable CPLMin +// CHECK-NEXT: (const long *) CPLMin = {{.*}} +const unsigned long *CPULMax = &ULMax; +// CHECK-NEXT: (lldb) target variable CPULMax +// CHECK-NEXT: (const unsigned long *) CPULMax = {{.*}} +const unsigned long *CPULMin = &ULMin; +// CHECK-NEXT: (lldb) target variable CPULMin +// CHECK-NEXT: (const unsigned long *) CPULMin = {{.*}} +const long long *CPLLMax = &LLMax; +// CHECK-NEXT: (lldb) target variable CPLLMax +// CHECK-NEXT: (const long long *) CPLLMax = {{.*}} +const long long *CPLLMin = &LLMin; +// CHECK-NEXT: (lldb) target variable CPLLMin +// CHECK-NEXT: (const long long *) CPLLMin = {{.*}} +const unsigned long long *CPULLMax = &ULLMax; +// CHECK-NEXT: (lldb) target variable CPULLMax +// CHECK-NEXT: (const unsigned long long *) CPULLMax = {{.*}} +const unsigned long long *CPULLMin = &ULLMin; +// CHECK-NEXT: (lldb) target variable CPULLMin +// CHECK-NEXT: (const unsigned long long *) CPULLMin = {{.*}} +const float *CPF = &F; +// CHECK-NEXT: (lldb) target variable CPF +// CHECK-NEXT: (const float *) CPF = {{.*}} +const double *CPD = &D; +// CHECK-NEXT: (lldb) target variable CPD +// CHECK-NEXT: (const double *) CPD = {{.*}} + + +// References to fundamental data types + +bool &RBFalse = BFalse; +// CHECK-NEXT: (lldb) target variable RBFalse +// CHECK-NEXT: (bool &) RBFalse = {{.*}} (&::RBFalse = false) +bool &RBTrue = BTrue; +// CHECK-NEXT: (lldb) target variable RBTrue +// CHECK-NEXT: (bool &) RBTrue = {{.*}} (&::RBTrue = true) +char &RCA = CA; +// CHECK-NEXT: (lldb) target variable RCA +// CHECK-NEXT: (char &) RCA = {{.*}} (&::RCA = 'A') +char &RCZ = CZ; +// CHECK-NEXT: (lldb) target variable RCZ +// CHECK-NEXT: (char &) RCZ = {{.*}} (&::RCZ = 'Z') +signed char &RSCa = SCa; +// CHECK-NEXT: (lldb) target variable RSCa +// CHECK-NEXT: (signed char &) RSCa = {{.*}} (&::RSCa = 'a') +signed char &RSCz = SCz; +// CHECK-NEXT: (lldb) target variable RSCz +// CHECK-NEXT: (signed char &) RSCz = {{.*}} (&::RSCz = 'z') +unsigned char &RUC24 = UC24; +// CHECK-NEXT: (lldb) target variable RUC24 +// CHECK-NEXT: (unsigned char &) RUC24 = {{.*}} (&::RUC24 = '\x18') +unsigned char &RUC42 = UC42; +// CHECK-NEXT: (lldb) target variable RUC42 +// CHECK-NEXT: (unsigned char &) RUC42 = {{.*}} (&::RUC42 = '*') +short &RSMax = SMax; +// CHECK-NEXT: (lldb) target variable RSMax +// CHECK-NEXT: (short &) RSMax = {{.*}} (&::RSMax = 32767) +short &RSMin = SMin; +// CHECK-NEXT: (lldb) target variable RSMin +// CHECK-NEXT: (short &) RSMin = {{.*}} (&::RSMin = -32768) +unsigned short &RUSMax = USMax; +// CHECK-NEXT: (lldb) target variable RUSMax +// CHECK-NEXT: (unsigned short &) RUSMax = {{.*}} (&::RUSMax = 65535) +unsigned short &RUSMin = USMin; +// CHECK-NEXT: (lldb) target variable RUSMin +// CHECK-NEXT: (unsigned short &) RUSMin = {{.*}} (&::RUSMin = 0) +int &RIMax = IMax; +// CHECK-NEXT: (lldb) target variable RIMax +// CHECK-NEXT: (int &) RIMax = {{.*}} (&::RIMax = 2147483647) +int &RIMin = IMin; +// CHECK-NEXT: (lldb) target variable RIMin +// CHECK-NEXT: (int &) RIMin = {{.*}} (&::RIMin = -2147483648) +unsigned int &RUIMax = UIMax; +// CHECK-NEXT: (lldb) target variable RUIMax +// CHECK-NEXT: (unsigned int &) RUIMax = {{.*}} (&::RUIMax = 4294967295) +unsigned int &RUIMin = UIMin; +// CHECK-NEXT: (lldb) target variable RUIMin +// CHECK-NEXT: (unsigned int &) RUIMin = {{.*}} (&::RUIMin = 0) +long &RLMax = LMax; +// CHECK-NEXT: (lldb) target variable RLMax +// CHECK-NEXT: (long &) RLMax = {{.*}} (&::RLMax = 2147483647) +long &RLMin = LMin; +// CHECK-NEXT: (lldb) target variable RLMin +// CHECK-NEXT: (long &) RLMin = {{.*}} (&::RLMin = -2147483648) +unsigned long &RULMax = ULMax; +// CHECK-NEXT: (lldb) target variable RULMax +// CHECK-NEXT: (unsigned long &) RULMax = {{.*}} (&::RULMax = 4294967295) +unsigned long &RULMin = ULMin; +// CHECK-NEXT: (lldb) target variable RULMin +// CHECK-NEXT: (unsigned long &) RULMin = {{.*}} (&::RULMin = 0) +long long &RLLMax = LLMax; +// CHECK-NEXT: (lldb) target variable RLLMax +// CHECK-NEXT: (long long &) RLLMax = {{.*}} (&::RLLMax = 9223372036854775807) +long long &RLLMin = LLMin; +// CHECK-NEXT: (lldb) target variable RLLMin +// CHECK-NEXT: (long long &) RLLMin = {{.*}} (&::RLLMin = -9223372036854775808) +unsigned long long &RULLMax = ULLMax; +// CHECK-NEXT: (lldb) target variable RULLMax +// CHECK-NEXT: (unsigned long long &) RULLMax = {{.*}} (&::RULLMax = 18446744073709551615) +unsigned long long &RULLMin = ULLMin; +// CHECK-NEXT: (lldb) target variable RULLMin +// CHECK-NEXT: (unsigned long long &) RULLMin = {{.*}} (&::RULLMin = 0) +float &RF = F; +// CHECK-NEXT: (lldb) target variable RF +// CHECK-NEXT: (float &) RF = {{.*}} (&::RF = 3.1415) +double &RD = D; +// CHECK-NEXT: (lldb) target variable RD +// CHECK-NEXT: (double &) RD = {{.*}} (&::RD = 3.1415000000000002) + +// const references to fundamental data types +const bool &CRBFalse = BFalse; +// CHECK-NEXT: (lldb) target variable CRBFalse +// CHECK-NEXT: (const bool &) CRBFalse = {{.*}} (&::CRBFalse = false) +const bool &CRBTrue = BTrue; +// CHECK-NEXT: (lldb) target variable CRBTrue +// CHECK-NEXT: (const bool &) CRBTrue = {{.*}} (&::CRBTrue = true) +const char &CRCA = CA; +// CHECK-NEXT: (lldb) target variable CRCA +// CHECK-NEXT: (const char &) CRCA = {{.*}} (&::CRCA = 'A') +const char &CRCZ = CZ; +// CHECK-NEXT: (lldb) target variable CRCZ +// CHECK-NEXT: (const char &) CRCZ = {{.*}} (&::CRCZ = 'Z') +const signed char &CRSCa = SCa; +// CHECK-NEXT: (lldb) target variable CRSCa +// CHECK-NEXT: (const signed char &) CRSCa = {{.*}} (&::CRSCa = 'a') +const signed char &CRSCz = SCz; +// CHECK-NEXT: (lldb) target variable CRSCz +// CHECK-NEXT: (const signed char &) CRSCz = {{.*}} (&::CRSCz = 'z') +const unsigned char &CRUC24 = UC24; +// CHECK-NEXT: (lldb) target variable CRUC24 +// CHECK-NEXT: (const unsigned char &) CRUC24 = {{.*}} (&::CRUC24 = '\x18') +const unsigned char &CRUC42 = UC42; +// CHECK-NEXT: (lldb) target variable CRUC42 +// CHECK-NEXT: (const unsigned char &) CRUC42 = {{.*}} (&::CRUC42 = '*') +const short &CRSMax = SMax; +// CHECK-NEXT: (lldb) target variable CRSMax +// CHECK-NEXT: (const short &) CRSMax = {{.*}} (&::CRSMax = 32767) +const short &CRSMin = SMin; +// CHECK-NEXT: (lldb) target variable CRSMin +// CHECK-NEXT: (const short &) CRSMin = {{.*}} (&::CRSMin = -32768) +const unsigned short &CRUSMax = USMax; +// CHECK-NEXT: (lldb) target variable CRUSMax +// CHECK-NEXT: (const unsigned short &) CRUSMax = {{.*}} (&::CRUSMax = 65535) +const unsigned short &CRUSMin = USMin; +// CHECK-NEXT: (lldb) target variable CRUSMin +// CHECK-NEXT: (const unsigned short &) CRUSMin = {{.*}} (&::CRUSMin = 0) +const int &CRIMax = IMax; +// CHECK-NEXT: (lldb) target variable CRIMax +// CHECK-NEXT: (const int &) CRIMax = {{.*}} (&::CRIMax = 2147483647) +const int &CRIMin = IMin; +// CHECK-NEXT: (lldb) target variable CRIMin +// CHECK-NEXT: (const int &) CRIMin = {{.*}} (&::CRIMin = -2147483648) +const unsigned int &CRUIMax = UIMax; +// CHECK-NEXT: (lldb) target variable CRUIMax +// CHECK-NEXT: (const unsigned int &) CRUIMax = {{.*}} (&::CRUIMax = 4294967295) +const unsigned int &CRUIMin = UIMin; +// CHECK-NEXT: (lldb) target variable CRUIMin +// CHECK-NEXT: (const unsigned int &) CRUIMin = {{.*}} (&::CRUIMin = 0) +const long &CRLMax = LMax; +// CHECK-NEXT: (lldb) target variable CRLMax +// CHECK-NEXT: (const long &) CRLMax = {{.*}} (&::CRLMax = 2147483647) +const long &CRLMin = LMin; +// CHECK-NEXT: (lldb) target variable CRLMin +// CHECK-NEXT: (const long &) CRLMin = {{.*}} (&::CRLMin = -2147483648) +const unsigned long &CRULMax = ULMax; +// CHECK-NEXT: (lldb) target variable CRULMax +// CHECK-NEXT: (const unsigned long &) CRULMax = {{.*}} (&::CRULMax = 4294967295) +const unsigned long &CRULMin = ULMin; +// CHECK-NEXT: (lldb) target variable CRULMin +// CHECK-NEXT: (const unsigned long &) CRULMin = {{.*}} (&::CRULMin = 0) +const long long &CRLLMax = LLMax; +// CHECK-NEXT: (lldb) target variable CRLLMax +// CHECK-NEXT: (const long long &) CRLLMax = {{.*}} (&::CRLLMax = 9223372036854775807) +const long long &CRLLMin = LLMin; +// CHECK-NEXT: (lldb) target variable CRLLMin +// CHECK-NEXT: (const long long &) CRLLMin = {{.*}} (&::CRLLMin = -9223372036854775808) +const unsigned long long &CRULLMax = ULLMax; +// CHECK-NEXT: (lldb) target variable CRULLMax +// CHECK-NEXT: (const unsigned long long &) CRULLMax = {{.*}} (&::CRULLMax = 18446744073709551615) +const unsigned long long &CRULLMin = ULLMin; +// CHECK-NEXT: (lldb) target variable CRULLMin +// CHECK-NEXT: (const unsigned long long &) CRULLMin = {{.*}} (&::CRULLMin = 0) +const float &CRF = F; +// CHECK-NEXT: (lldb) target variable CRF +// CHECK-NEXT: (const float &) CRF = {{.*}} (&::CRF = 3.1415) +const double &CRD = D; +// CHECK-NEXT: (lldb) target variable CRD +// CHECK-NEXT: (const double &) CRD = {{.*}} (&::CRD = 3.1415000000000002) + +char16_t &RC16_24 = C16_24; +// CHECK: (lldb) target variable RC16_24 +// FIXME: (char16_t &) RC16_24 = {{.*}} (&::RC16_24 = U+0014) +char32_t &RC32_42 = C32_42; +// CHECK: (lldb) target variable RC32_42 +// FIXME: (char32_t &) RC32_42 = {{.*}} (&::RC32_42 = U+0x00000022) +wchar_t &RWC1 = WC1; +// CHECK: (lldb) target variable RWC1 +// FIXME: (wchar_t &) RWC1 = {{.*}} (&::RWC1 = L'1') +wchar_t &RWCP = WCP; +// CHECK: (lldb) target variable RWCP +// FIXME: (wchar_t &) RWCP = {{.*}} (&::RWCP = L'P') +const char16_t &CRC16_24 = C16_24; +// CHECK: (lldb) target variable CRC16_24 +// FIXME: (const char16_t &) CRC16_24 = {{.*}} (&::CRC16_24 = U+0014) +const char32_t &CRC32_42 = C32_42; +// CHECK: (lldb) target variable CRC32_42 +// FIXME: (const char32_t &) CRC32_42 = {{.*}} (&::CRC32_42 = U+0x00000022) +const wchar_t &CRWC1 = WC1; +// CHECK: (lldb) target variable CRWC1 +// FIXME: (const wchar_t &) CRWC1 = {{.*}} (&::CRWC1 = L'1') +const wchar_t &CRWCP = WCP; +// CHECK: (lldb) target variable CRWCP +// FIXME: (const wchar_t &) CRWCP = {{.*}} (&::CRWCP = L'P') + + +// CHECK: (lldb) quit + +int main(int argc, char **argv) { + return CIMax; +} \ No newline at end of file Index: lldb/trunk/source/Plugins/SymbolFile/NativePDB/PdbSymUid.h =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/NativePDB/PdbSymUid.h +++ lldb/trunk/source/Plugins/SymbolFile/NativePDB/PdbSymUid.h @@ -32,7 +32,6 @@ // the beginning so that the types are all layout-compatible with each // other, which is necessary in order to be able to safely access the tag // member through any union member. - struct PdbCompilandId { uint64_t tag : 8; // PDB_SymType::Compiland uint64_t modi : 16; // 0-based index of module in PDB @@ -41,11 +40,14 @@ struct PdbCuSymId { uint64_t tag : 8; // PDB_SymType::Data, Function, Block, etc. uint64_t - offset : 32; // Offset of symbol's record in module stream. This is - // offset by 4 from the CVSymbolArray's notion of offset - // due to the debug magic at the beginning of the stream. - uint64_t modi : 16; // 0-based index of module in PDB + offset : 30; // Offset of symbol's record in module stream. This is + // offset by 4 from the CVSymbolArray's notion of offset + // due to the debug magic at the beginning of the stream. + uint64_t global : 1; // True if this is from the globals stream. + uint64_t unused : 1; + uint64_t modi : 16; // For non-global, this is the 0-based index of module. }; + struct PdbTypeSymId { uint64_t tag : 8; // PDB_SymType::FunctionSig, Enum, PointerType, etc. uint64_t is_ipi : 8; // 1 if this value is from the IPI stream, 0 for TPI. @@ -125,10 +127,21 @@ PdbSymUid uid; uid.m_uid.cu_sym.modi = modi; uid.m_uid.cu_sym.offset = offset; + uid.m_uid.cu_sym.global = false; uid.m_uid.cu_sym.tag = static_cast(type); return uid; } + static PdbSymUid makeGlobalVariableUid(uint32_t offset) { + PdbSymUid uid = {}; + uid.m_uid.cu_sym.modi = 0; + uid.m_uid.cu_sym.offset = offset; + uid.m_uid.cu_sym.global = 1; + uid.m_uid.cu_sym.unused = 0; + uid.m_uid.cu_sym.tag = static_cast(llvm::pdb::PDB_SymType::Data); + return uid; + } + static PdbSymUid makeCompilandId(llvm::codeview::ProcRefSym sym) { // S_PROCREF symbols are 1-based lldbassert(sym.Module > 0); @@ -172,6 +185,11 @@ bool isCompiland() const { return tag() == llvm::pdb::PDB_SymType::Compiland; } + bool isGlobalVariable() const { + if (tag() != llvm::pdb::PDB_SymType::Data) + return false; + return static_cast(asCuSym().global); + } llvm::pdb::PDB_SymType tag() const { return static_cast(m_uid.comp_id.tag); Index: lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h +++ lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h @@ -103,6 +103,11 @@ size_t ParseFunctionBlocks(const SymbolContext &sc) override; + uint32_t FindGlobalVariables(const ConstString &name, + const CompilerDeclContext *parent_decl_ctx, + uint32_t max_matches, + VariableList &variables) override; + size_t ParseTypes(const SymbolContext &sc) override; size_t ParseVariablesForContext(const SymbolContext &sc) override { return 0; @@ -175,11 +180,13 @@ lldb::CompUnitSP GetOrCreateCompileUnit(const CompilandIndexItem &cci); lldb::TypeSP GetOrCreateType(PdbSymUid type_uid); lldb::TypeSP GetOrCreateType(llvm::codeview::TypeIndex ti); + lldb::VariableSP GetOrCreateGlobalVariable(PdbSymUid var_uid); lldb::FunctionSP CreateFunction(PdbSymUid func_uid, const SymbolContext &sc); lldb::CompUnitSP CreateCompileUnit(const CompilandIndexItem &cci); lldb::TypeSP CreateType(PdbSymUid type_uid); lldb::TypeSP CreateAndCacheType(PdbSymUid type_uid); + lldb::VariableSP CreateGlobalVariable(PdbSymUid var_uid); llvm::BumpPtrAllocator m_allocator; @@ -193,6 +200,7 @@ llvm::DenseMap m_uid_to_decl; + llvm::DenseMap m_global_vars; llvm::DenseMap m_functions; llvm::DenseMap m_compilands; llvm::DenseMap m_types; Index: lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp +++ lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp @@ -16,6 +16,7 @@ #include "lldb/Core/Module.h" #include "lldb/Core/PluginManager.h" +#include "lldb/Core/StreamBuffer.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTImporter.h" #include "lldb/Symbol/ClangExternalASTSourceCommon.h" @@ -24,6 +25,8 @@ #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/SymbolVendor.h" +#include "lldb/Symbol/Variable.h" +#include "lldb/Symbol/VariableList.h" #include "llvm/DebugInfo/CodeView/CVRecord.h" #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h" @@ -887,6 +890,131 @@ return CreateAndCacheType(type_uid); } +static DWARFExpression MakeGlobalLocationExpression(uint16_t section, + uint32_t offset, + ModuleSP module) { + assert(section > 0); + assert(module); + + const ArchSpec &architecture = module->GetArchitecture(); + ByteOrder byte_order = architecture.GetByteOrder(); + uint32_t address_size = architecture.GetAddressByteSize(); + uint32_t byte_size = architecture.GetDataByteSize(); + assert(byte_order != eByteOrderInvalid && address_size != 0); + + RegisterKind register_kind = eRegisterKindDWARF; + StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order); + stream.PutHex8(DW_OP_addr); + + SectionList *section_list = module->GetSectionList(); + assert(section_list); + + // Section indices in PDB are 1-based, but in DWARF they are 0-based, so we + // need to subtract 1. + uint32_t section_idx = section - 1; + if (section_idx >= section_list->GetSize()) + return DWARFExpression(nullptr); + + auto section_ptr = section_list->GetSectionAtIndex(section_idx); + if (!section_ptr) + return DWARFExpression(nullptr); + + stream.PutMaxHex64(section_ptr->GetFileAddress() + offset, address_size, + byte_order); + DataBufferSP buffer = + std::make_shared(stream.GetData(), stream.GetSize()); + DataExtractor extractor(buffer, byte_order, address_size, byte_size); + DWARFExpression result(module, extractor, nullptr, 0, buffer->GetByteSize()); + result.SetRegisterKind(register_kind); + return result; +} + +VariableSP SymbolFileNativePDB::CreateGlobalVariable(PdbSymUid var_uid) { + const PdbCuSymId &cu_sym = var_uid.asCuSym(); + lldbassert(cu_sym.global); + CVSymbol sym = m_index->symrecords().readRecord(cu_sym.offset); + lldb::ValueType scope = eValueTypeInvalid; + TypeIndex ti; + llvm::StringRef name; + lldb::addr_t addr = 0; + uint16_t section = 0; + uint32_t offset = 0; + bool is_external = false; + switch (sym.kind()) { + case S_GDATA32: + is_external = true; + LLVM_FALLTHROUGH; + case S_LDATA32: { + DataSym ds(sym.kind()); + llvm::cantFail(SymbolDeserializer::deserializeAs(sym, ds)); + ti = ds.Type; + scope = (sym.kind() == S_GDATA32) ? eValueTypeVariableGlobal + : eValueTypeVariableStatic; + name = ds.Name; + section = ds.Segment; + offset = ds.DataOffset; + addr = m_index->MakeVirtualAddress(ds.Segment, ds.DataOffset); + break; + } + case S_GTHREAD32: + is_external = true; + LLVM_FALLTHROUGH; + case S_LTHREAD32: { + ThreadLocalDataSym tlds(sym.kind()); + llvm::cantFail( + SymbolDeserializer::deserializeAs(sym, tlds)); + ti = tlds.Type; + name = tlds.Name; + section = tlds.Segment; + offset = tlds.DataOffset; + addr = m_index->MakeVirtualAddress(tlds.Segment, tlds.DataOffset); + scope = eValueTypeVariableThreadLocal; + break; + } + default: + llvm_unreachable("unreachable!"); + } + + CompUnitSP comp_unit; + llvm::Optional modi = m_index->GetModuleIndexForVa(addr); + if (modi) { + PdbSymUid cuid = PdbSymUid::makeCompilandId(*modi); + CompilandIndexItem &cci = m_index->compilands().GetOrCreateCompiland(cuid); + comp_unit = GetOrCreateCompileUnit(cci); + } + + Declaration decl; + PDB_SymType pdbst = GetPdbSymType(m_index->tpi(), ti); + PdbSymUid tuid = PdbSymUid::makeTypeSymId(pdbst, ti, false); + SymbolFileTypeSP type_sp = + std::make_shared(*this, tuid.toOpaqueId()); + Variable::RangeList ranges; + + DWARFExpression location = MakeGlobalLocationExpression( + section, offset, GetObjectFile()->GetModule()); + + std::string global_name("::"); + global_name += name; + VariableSP var_sp = std::make_shared( + var_uid.toOpaqueId(), name.str().c_str(), global_name.c_str(), type_sp, + scope, comp_unit.get(), ranges, &decl, location, is_external, false, + false); + var_sp->SetLocationIsConstantValueData(false); + + return var_sp; +} + +VariableSP SymbolFileNativePDB::GetOrCreateGlobalVariable(PdbSymUid var_uid) { + lldbassert(var_uid.isGlobalVariable()); + + auto emplace_result = + m_global_vars.try_emplace(var_uid.toOpaqueId(), nullptr); + if (emplace_result.second) + emplace_result.first->second = CreateGlobalVariable(var_uid); + + return emplace_result.first->second; +} + lldb::TypeSP SymbolFileNativePDB::GetOrCreateType(llvm::codeview::TypeIndex ti) { PDB_SymType pdbst = GetPdbSymType(m_index->tpi(), ti); @@ -1146,6 +1274,32 @@ return 0; } +uint32_t SymbolFileNativePDB::FindGlobalVariables( + const ConstString &name, const CompilerDeclContext *parent_decl_ctx, + uint32_t max_matches, VariableList &variables) { + using SymbolAndOffset = std::pair; + + std::vector results = m_index->globals().findRecordsByName( + name.GetStringRef(), m_index->symrecords()); + for (const SymbolAndOffset &result : results) { + VariableSP var; + switch (result.second.kind()) { + case SymbolKind::S_GDATA32: + case SymbolKind::S_LDATA32: + case SymbolKind::S_GTHREAD32: + case SymbolKind::S_LTHREAD32: { + PdbSymUid uid = PdbSymUid::makeGlobalVariableUid(result.first); + var = GetOrCreateGlobalVariable(uid); + variables.AddVariable(var); + break; + } + default: + continue; + } + } + return variables.GetSize(); +} + uint32_t SymbolFileNativePDB::FindFunctions( const ConstString &name, const CompilerDeclContext *parent_decl_ctx, FunctionNameType name_type_mask, bool include_inlines, bool append, @@ -1239,19 +1393,21 @@ auto iter = m_types.find(type_uid); // lldb should not be passing us non-sensical type uids. the only way it // could have a type uid in the first place is if we handed it out, in which - // case we should know about the type. So this is not a get-or-create type - // operation, it is strictly a get, and the type is guaranteed to exist. - // - // However, since the implementation is not yet complete, we don't currently - // support all possible use cases. For example, we currently create all - // functions with indices of 0 for the signature type simply because this is - // not yet implemented. At the time the function object is created we should - // be creating an lldb::TypeSP for this, adding it to the m_types, and - // returning a valid Type object for it and putting it in this map. Once all - // cases like this are handled, we can promote this to an assert. - if (iter == m_types.end()) + // case we should know about the type. However, that doesn't mean we've + // instantiated it yet. We can vend out a UID for a future type. So if the + // type doesn't exist, let's instantiate it now. + if (iter != m_types.end()) + return &*iter->second; + + PdbSymUid uid = PdbSymUid::fromOpaqueId(type_uid); + lldbassert(uid.isTypeSym(uid.tag())); + const PdbTypeSymId &type_id = uid.asTypeSym(); + TypeIndex ti(type_id.index); + if (ti.isNoneType()) return nullptr; - return &*iter->second; + + TypeSP type_sp = CreateAndCacheType(uid); + return &*type_sp; } bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {