[NativePDB] Add the ability to display global variables

[zturner]

Summary

LLDB has the ability to display global variables, even without a running process, via the target variable command. This is because global variables are linker initialized, so their values are embedded directly into the executables. This gives us great power for testing native PDB functionality in a cross-platform manner, because we don't actually need a running process. We can just create a target using an EXE file, and display global variables. And global variables can have arbitrarily complex types, so in theory we can fully exercise the type system, record layout, and data formatters for native PDB files and PE/COFF executables on any host platform, as long as our type does not require a dynamic initializer.

This patch adds basic support for finding variables by name, and adds an exhaustive test for fundamental data types and pointers / references to fundamental data types.

Subsequent patches will extend this to typedefs, classes, pointers to functions, and other cases.

[jingham]

Is there anything PDB specific about the test you've added? If not, it might be good to use this as a generic SymbolFile test.

[zturner]

which generic SymbolFile test do you mean? The lit ones are the only ones that are set up to run in this particular manner (run lines, check lines, etc), and currently we don't have a way to run different / multiple command line invocations. I came up with this test in order to test the new changes I introduced in SymbolFileNativePdb.cpp that are also in this patch, so I definitely want to make sure all of that code still gets exercised with whatever test strategy I end up using.

I guess the way I see it, there's two interesting things this test could exercise. 1) the debug info, and 2) the formatters. If we want to test the formatters, we could probably brainstorm a way to do it generically with 1 test (or set of tests) that omits the SymbolFile from the picture entirely and is generic enough that it should be applicable to any platform/compiler/host. If we want to test the SymbolFile plugin though, then it may need to be specific to the debug info type.

I think what you're getting at though is that we probably need some notion of "debug info variants" for these lit tests like we have in the dotest suite. I actually had an idea for something that might work like that a while back, which I described here: https://reviews.llvm.org/D52618#1252906

But the idea would basically be that instead of hardcoding a command line like I've done with clang-cl /Z7 etc etc we could write something more generic that would evaluate to different (or perhaps even multiple) things, so we could run it different ways.

[jingham]

Well, what's really going on is that I'm not familiar enough with lit to know that it doesn't have the ability to run different commands to produce the input file... But as you guessed, my point is that you have written a bunch of tests that would be valuable to test against any symfile format, so it is a shame to only run them against one format. OTOH, if that's not possible right now, I'm content to wait for some enhancements to lit that make it possible.

[zturner]

In D53731#1276633, @jingham wrote:

Well, what's really going on is that I'm not familiar enough with lit to know that it doesn't have the ability to run different commands to produce the input file... But as you guessed, my point is that you have written a bunch of tests that would be valuable to test against any symfile format, so it is a shame to only run them against one format. OTOH, if that's not possible right now, I'm content to wait for some enhancements to lit that make it possible.

I can maybe hardcode multiple runlines, one for each possible target triple. But what's really going on is that I'm not familiar enough with other platforms to know how to generate their binaries :)

But I'll actually give it a try. Just to explain what's going on here, I've got these two lines:

// RUN: clang-cl /Z7 /GS- /GR- /c /Fo%t.obj -- %s 
// RUN: lld-link /DEBUG /nodefaultlib /entry:main /OUT:%t.exe /PDB:%t.pdb -- %t.obj

Those two run the compiler and linker and write the output to a temporary file, but don't actually check anything yet. The next two lines (which are actually one command broken with a continuation character)

// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
// RUN:     %p/Inputs/globals-fundamental.lldbinit | FileCheck %s

runs lldb and pipes the result to FileCheck, using this file as the check file.

So what I could *try* doing is having multiple compiler / linker invocations. One that produces a Windows executable / PDB file. One that produces a Linux executable / DWARF. One that produces some kind of OSX binary (I think lld doesn't work with MachO yet, so I'm not sure about this one), writing the linker outputs to different files each time.

Then we could maybe run lldb 3 times, once against each input, but using the same check file each time. I'll give it a try and see what happens.

[jingham]

Could you also use Vedant's new FileCheck dotest test class? That should allow you to write the tests exactly as you are, but use the dotest mechanism to build and run the example.

[lemo]

looks good. a few comments inline.

lldb/source/Plugins/SymbolFile/NativePDB/PdbSymUid.h

46 ↗

(On Diff #171189)

30 + 1 != 32 - what's going on?

135 ↗

(On Diff #171189)

= {}; ? (to avoid uninitialized bits)

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

892 ↗

(On Diff #171189)

assert that section > 0 ? (as precondition)

913 ↗

(On Diff #171189)

comment explaining the - 1 ?

936 ↗

(On Diff #171189)

pls explicitly initialize all the locals

1406 ↗

(On Diff #171189)

type_sp->get() seems cleaner / more readable

[zturner]

In D53731#1276660, @jingham wrote:

Could you also use Vedant's new FileCheck dotest test class? That should allow you to write the tests exactly as you are, but use the dotest mechanism to build and run the example.

Adding Vedant here. My understanding is that the work he did there is like the inverse of what I'm doing. It allows you to use FileCheck from inside of dotest tests, but I was trying to bypass dotest here. I don't necessarily think "dotest for all things" should be an explicit goal (i actually think long term we should move away from it, but that's for another day). Aside from that though, I don't think this particular test needs any of the functionality that dotest offers. It offers building in multiple configurations, but we can get that from this test by just specifying mulitple run lines (I'm testing this out locally and it seems like I can get it to work). Eventually, using some kind of configuration / builder type system like I brainstormed in the review thread I linked previously, I think we could have all the advantages of dotest's builder even with this style of test.

FWIW, I was also under the impression that Vedant's solution with FileCheck in dotest was only intended as sort of an immediate solution to a problem, but not necessary the long term desired end-state. (I could be wrong about this though).

[vsk]

In D53731#1276732, @zturner wrote:

In D53731#1276660, @jingham wrote:

Could you also use Vedant's new FileCheck dotest test class? That should allow you to write the tests exactly as you are, but use the dotest mechanism to build and run the example.

Adding Vedant here. My understanding is that the work he did there is like the inverse of what I'm doing. It allows you to use FileCheck from inside of dotest tests, but I was trying to bypass dotest here. I don't necessarily think "dotest for all things" should be an explicit goal (i actually think long term we should move away from it, but that's for another day). Aside from that though, I don't think this particular test needs any of the functionality that dotest offers. It offers building in multiple configurations, but we can get that from this test by just specifying mulitple run lines (I'm testing this out locally and it seems like I can get it to work). Eventually, using some kind of configuration / builder type system like I brainstormed in the review thread I linked previously, I think we could have all the advantages of dotest's builder even with this style of test.

FWIW, I was also under the impression that Vedant's solution with FileCheck in dotest was only intended as sort of an immediate solution to a problem, but not necessary the long term desired end-state. (I could be wrong about this though).

The tests as-written seem to exercise the new functionality. I think it'd be fine to use the FileCheck-in-{dotest,lldbinline} support if you need to set a breakpoint, run a command, and then validate its output (though it looks like you don't)

[zturner]

In D53731#1276743, @vsk wrote:

In D53731#1276732, @zturner wrote:

In D53731#1276660, @jingham wrote:

Could you also use Vedant's new FileCheck dotest test class? That should allow you to write the tests exactly as you are, but use the dotest mechanism to build and run the example.

Adding Vedant here. My understanding is that the work he did there is like the inverse of what I'm doing. It allows you to use FileCheck from inside of dotest tests, but I was trying to bypass dotest here. I don't necessarily think "dotest for all things" should be an explicit goal (i actually think long term we should move away from it, but that's for another day). Aside from that though, I don't think this particular test needs any of the functionality that dotest offers. It offers building in multiple configurations, but we can get that from this test by just specifying mulitple run lines (I'm testing this out locally and it seems like I can get it to work). Eventually, using some kind of configuration / builder type system like I brainstormed in the review thread I linked previously, I think we could have all the advantages of dotest's builder even with this style of test.

FWIW, I was also under the impression that Vedant's solution with FileCheck in dotest was only intended as sort of an immediate solution to a problem, but not necessary the long term desired end-state. (I could be wrong about this though).

The tests as-written seem to exercise the new functionality. I think it'd be fine to use the FileCheck-in-{dotest,lldbinline} support if you need to set a breakpoint, run a command, and then validate its output (though it looks like you don't)

Yea, once I need to actually run a process I expect I'll need to start using it. For the time being, I'm trying see how much ground I can cover without a process. The reasoning is two-fold.

First, it means the tests can run anywhere. If there's no process, my test coverage isn't limited to a specific host OS.

Second, from a layering perspective, if I know that there's a ton of test coverage for "everything that happens before a process is spawned", then once you get to the point that you are spawning process, it limits the scope of where you have to search when something does go wrong.

So that's my thinking.

[jingham]

dotest tests don't require a process. Presumably dotest knows how to build windows targeted PDB debug flavor files (to go along with dwarf/dsym/etc.). So it would be straightforward to make a test that had your input sources, built and made a target out of it and then poked at static variables and their types. That would straightaway run with all the different symbol file formats we support.

That was why using Vedant's FileCheck thing made sense to me. You would use that to specify the test cases, since you like that way of writing tests and anyway already have them written out in that form, but use the dotest machinery to build it for whatever symfile format and target architecture/s the person who was running the test dialed up. But if you are interesting in also getting this to work with the straight FileCheck style test, your time is your own...

BTW, I would use dotest tests specifically for the kind of thing you are doing here because then you can test against the SBType and SBTypeMembers from the debug info you've ingested, which would give you bit and byte offsets and sizes for free. But if your differing tastes end up getting you to add that info to "type lookup" - which we really should do - then I guess we win either way...

[zturner]

In D53731#1276818, @jingham wrote:

dotest tests don't require a process. Presumably dotest knows how to build windows targeted PDB debug flavor files (to go along with dwarf/dsym/etc.). So it would be straightforward to make a test that had your input sources, built and made a target out of it and then poked at static variables and their types. That would straightaway run with all the different symbol file formats we support.

That was why using Vedant's FileCheck thing made sense to me. You would use that to specify the test cases, since you like that way of writing tests and anyway already have them written out in that form, but use the dotest machinery to build it for whatever symfile format and target architecture/s the person who was running the test dialed up. But if you are interesting in also getting this to work with the straight FileCheck style test, your time is your own...

BTW, I would use dotest tests specifically for the kind of thing you are doing here because then you can test against the SBType and SBTypeMembers from the debug info you've ingested, which would give you bit and byte offsets and sizes for free. But if your differing tastes end up getting you to add that info to "type lookup" - which we really should do - then I guess we win either way...

Yea, so one of the commands I'm used to on the Windows command line debugger WinDbg is the dt (dump type) command. It's basically the equivalent of type lookup - more powerful in some ways, less in others . The output format looks like this:

0:000> dt _EXCEPTION_RECORD
ntdll!_EXCEPTION_RECORD
   +0x000 ExceptionCode    : Int4B
   +0x004 ExceptionFlags   : Uint4B
   +0x008 ExceptionRecord  : Ptr64 _EXCEPTION_RECORD
   +0x010 ExceptionAddress : Ptr64 Void
   +0x018 NumberParameters : Uint4B
   +0x020 ExceptionInformation : [15] Uint8B

So you can see the field offsets and such. (Less powerful because that's about it, no methods, for example).

But you can also pass it an address, which it then formats the block of memory as that type. e.g.

0:000> dt ntdll!_TEB32 00000000007ed000
   +0x000 NtTib            : _NT_TIB32
   +0x01c EnvironmentPointer : 0
   +0x020 ClientId         : _CLIENT_ID32
   +0x028 ActiveRpcHandle  : 0
   +0x02c ThreadLocalStoragePointer : 0
   +0x030 ProcessEnvironmentBlock : 0x7ed000
   +0x034 LastErrorValue   : 0
   +0x038 CountOfOwnedCriticalSections : 0
   +0x03c CsrClientThread  : 0
   +0x040 Win32ThreadInfo  : 0x4d18
   +0x044 User32Reserved   : [26] 0
   +0x0ac UserReserved     : [5] 0

So up on my list of things to implement is these two features.

[jingham]

The first of the commands you showed presents info we definitely should add to type lookup. I actually have a bug around to do that, but it hasn't risen to the top of my queue because it's trivial to do with the SB API's so every time I've needed that info I get it from script. Selfish me...

The second command is done in lldb with "memory read -t TYPE", and you can also use the "-c COUNT" argument to treat the memory as an array of COUNT elements of the TYPE:

(lldb) fr v myFoo
(foo *) myFoo = 0x0000000100400000
(lldb) memory read -t foo 0x0000000100400000
(foo) 0x100400000 = {
  First = 0
  Second = 0
}
(lldb) memory read -t foo 0x0000000100400000 -c 10
(foo) 0x100400000 = {
  First = 0
  Second = 0
}
(foo) 0x100400008 = {
  First = 1
  Second = 10
}
(foo) 0x100400010 = {
  First = 2
  Second = 20
}

if you want to also see the types of all the subelements add the -T flag, and if you want to see all the memory locations of the subelements, add the -L flag:

(lldb) memory read -t foo 0x0000000100400000 -c 10 -T -L
0x0000000100400000: (foo) 0x100400000 = {
0x0000000100400000:   (int) First = 0
0x0000000100400004:   (int) Second = 0
}
0x0000000100400008: (foo) 0x100400008 = {
0x0000000100400008:   (int) First = 1
0x000000010040000c:   (int) Second = 10
}

BTW, the latter two flags have the same meaning pretty much wherever we print values (expression, frame var...)

[zturner]

lldb/source/Plugins/SymbolFile/NativePDB/PdbSymUid.h

46 ↗

(On Diff #171189)

There's supposed to be a uint64_t unused : 1; here. Thanks for noticing.

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

913 ↗

(On Diff #171189)

I'm going to be totally honest here. I don't understand this code at all. I copied it from the SymbolFilePDB implementation. It seems to work :-/

936 ↗

(On Diff #171189)

TypeIndex has a constructor, but I should definitely initialize the lldb::addr_t

1406 ↗

(On Diff #171189)

You know, I kept trying to write that, and I was like "what silly person on the C++ standards committee forgot to put a get() method on std::shared_ptr<>. Did they really forget this or am I just going crazy?" Turns out it's a bug in MSVC intellisense where it doesn't show it for some reason. So I took that to mean it didn't exist. Shame on me.

[zturner]

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

913 ↗

(On Diff #171189)

Ok, I thought about this some, it's actually pretty simple. I'll add a comment.

lldb/trunk/lit/SymbolFile/NativePDB/Inputs/globals-fundamental.lldbinit

+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

lldb/trunk/lit/SymbolFile/NativePDB/globals-fundamental.cpp

+// 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

lldb/trunk/source/Plugins/SymbolFile/NativePDB/PdbSymUid.h

 
 namespace lldb_private {
 namespace npdb {
 
 // **important** - All concrete id types must have the 1-byte tag field at
 // 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
   uint64_t unused : 32;
 };
 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 : 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 modi : 16; // 0-based index of module in PDB
+  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.
   uint64_t unused : 16;
   uint64_t index : 32; // codeview::TypeIndex
 };
 
 static_assert(sizeof(PdbCompilandId) == 8, "invalid uid size");
public:
 
   static PdbSymUid makeCuSymId(llvm::pdb::PDB_SymType type, uint16_t modi,
                                uint32_t offset) {
     lldbassert(isCuSym(type));
 
     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<uint8_t>(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<uint8_t>(llvm::pdb::PDB_SymType::Data);
+    return uid;
+  }
+
   static PdbSymUid makeCompilandId(llvm::codeview::ProcRefSym sym) {
     // S_PROCREF symbols are 1-based
     lldbassert(sym.Module > 0);
     return makeCompilandId(sym.Module - 1);
   }
 
   static PdbSymUid makeCompilandId(uint16_t modi) {
     PdbSymUid uid;
public:
   }
 
   bool isPubSym() const {
     return tag() == llvm::pdb::PDB_SymType::PublicSymbol;
   }
   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<bool>(asCuSym().global);
+  }
 
   llvm::pdb::PDB_SymType tag() const {
     return static_cast<llvm::pdb::PDB_SymType>(m_uid.comp_id.tag);
   }
 
   const PdbCompilandId &asCompiland() const {
     lldbassert(tag() == llvm::pdb::PDB_SymType::Compiland);
     return m_uid.comp_id;

lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

bool ParseCompileUnitSupportFiles(const SymbolContext &sc,
                                     FileSpecList &support_files) override;
 
   bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<ConstString> &imported_modules) override;
 
   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;
   }
   Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   bool CompleteType(CompilerType &compiler_type) override;
   uint32_t ResolveSymbolContext(const Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
CreateClassStructUnion(PdbSymUid type_uid, llvm::StringRef name, size_t size,
                          clang::TagTypeKind ttk,
                          clang::MSInheritanceAttr::Spelling inheritance);
 
   lldb::FunctionSP GetOrCreateFunction(PdbSymUid func_uid,
                                        const SymbolContext &sc);
   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;
 
   lldb::addr_t m_obj_load_address = 0;
 
   std::unique_ptr<PdbIndex> m_index;
   std::unique_ptr<ClangASTImporter> m_importer;
   ClangASTContext *m_clang = nullptr;
 
   llvm::DenseMap<clang::TagDecl *, DeclStatus> m_decl_to_status;
 
   llvm::DenseMap<lldb::user_id_t, clang::TagDecl *> m_uid_to_decl;
 
+  llvm::DenseMap<lldb::user_id_t, lldb::VariableSP> m_global_vars;
   llvm::DenseMap<lldb::user_id_t, lldb::FunctionSP> m_functions;
   llvm::DenseMap<lldb::user_id_t, lldb::CompUnitSP> m_compilands;
   llvm::DenseMap<lldb::user_id_t, lldb::TypeSP> m_types;
 };
 
 } // namespace npdb
 } // namespace lldb_private
 
 #endif // lldb_Plugins_SymbolFile_PDB_SymbolFilePDB_h_

lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 
 #include "clang/AST/Attr.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 
 #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"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #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"
 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/RecordName.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
TypeSP SymbolFileNativePDB::GetOrCreateType(PdbSymUid type_uid) {
   // we have to do a 2-phase lookup / insert.
   auto iter = m_types.find(type_uid.toOpaqueId());
   if (iter != m_types.end())
     return iter->second;
 
   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<DataBufferHeap>(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<DataSym>(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<ThreadLocalDataSym>(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<uint16_t> 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<SymbolFileType>(*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<Variable>(
+      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);
   PdbSymUid tuid = PdbSymUid::makeTypeSymId(pdbst, ti, false);
   return GetOrCreateType(tuid);
 }
 
 FunctionSP SymbolFileNativePDB::GetOrCreateFunction(PdbSymUid func_uid,
bool SymbolFileNativePDB::ParseImportedModules(
   return false;
 }
 
 size_t SymbolFileNativePDB::ParseFunctionBlocks(const SymbolContext &sc) {
   lldbassert(sc.comp_unit && sc.function);
   return 0;
 }
 
+uint32_t SymbolFileNativePDB::FindGlobalVariables(
+    const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+    uint32_t max_matches, VariableList &variables) {
+  using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
+
+  std::vector<SymbolAndOffset> 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,
     SymbolContextList &sc_list) {
   // For now we only support lookup by method name.
   if (!(name_type_mask & eFunctionNameTypeMethod))
     return 0;
 

 }
 
 size_t SymbolFileNativePDB::ParseTypes(const SymbolContext &sc) { return 0; }
 
 Type *SymbolFileNativePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
   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())
-    return nullptr;
+  // 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;
+
+  TypeSP type_sp = CreateAndCacheType(uid);
+  return &*type_sp;
 }
 
 bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {
   // If this is not in our map, it's an error.
   clang::TagDecl *tag_decl = m_clang->GetAsTagDecl(compiler_type);
   lldbassert(tag_decl);
   auto status_iter = m_decl_to_status.find(tag_decl);
   lldbassert(status_iter != m_decl_to_status.end());