Add libc++ data formatter for std::variant

[shafik]

Summary

Adding data formatter for libc++ std::variant and appropriate tests

[vsk]

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/variant/TestDataFormatterLibcxxVariant.py

71

Could you add a test which inspects a reference to a variant (to cover the "(( )?&)?" bit you're matching)?

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/variant/main.cpp

30

Does a std::variant containing a std::variant work?

[jingham]

A bunch of little comments and two more substantial bits.

1. Can you add a test where we do "frame variable" on a one of these variants when it has one value, and then continue to a point where it has a different value and make sure we pick up the change. I think that's just a matter doing some "frame var"'s at your first breakpoint, and then again when you stop the second time. "frame var" maintains some state in the target (because the underlying objects need to support "value has changed") and it's always worthwhile to make sure that that doesn't interfere with picking up changes in value.

2. See the embedded comment around line 100 in LibCxxVariant.cpp. You can't assume that "unsigned int" on the target and the lldb host are the same size.

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/variant/TestDataFormatterLibcxxVariant.py

30–42

Lines 29-41 can all be done with:

(self.target, self.process, _, bkpt) = lldbutils.run_to_source_breakpoint(self, "break here", SBFileSpec("main.c"))

source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp

28

I don't think you want the trailing "and" here.

66

obtain

85

to -> two?

93

Sadly this needs to be wrapped to 80 characters somewhere.

98–106

I don't think this comparison is a safe thing to do. For instance, you are comparing the unsigned value that you get from the target (index_value) with lldb's host "unsigned int" value. If the target has a 32 bit unsigned int, but the host has a 64 bit unsigned int (or vice versa) then the two values won't be the same.

274

Do you need the "formatv" here? Looks like you are just making a ConstString from "Value"? Maybe something got lost?

[shafik]

Address comments on std::variant formatter

• Adding tests for reference to variant and variant of variant
• Refactoring test to be more efficient
• Refactoring unsafe code that assumed sizes of types between local machine and target machine were the same
  • Used to check to variant_npos which is max unsigned or -1

[shafik]

@vsk @jingham I believe I have addressed your comments, please review again.

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/variant/main.cpp

30

Yes, adding test.

source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp

98–106

I believe I applied the change as we discussed earlier, let me know if not.

[jingham]

Yes, that's a good way to do it.

[vsk]

Please clang-format your diffs.

[shafik]

@vsk Interesting I ran git clang-format before generating the diff and it made changes, so I am not sure what happened

[shafik]

Applying clang-format

[teemperor]

LibCxx.h/.cpp are still not clang-formatted. I ran clang-format over the patch and pushed it here that this patch doesn't get stuck on this minor detail: https://github.com/Teemperor/lldb/commit/1c5c2f8f5d5af00420559dee52c9155e5bc72518.diff

[shafik]

Applying clang-format to files I missed earlier

[shafik]

@teemperor Thanks for the catch!

[teemperor]

LGTM now, thanks for the patch!

[shafik]

Updating LibcxxVariantGetIndexValidity() to no longer do type check of __index. It was left over from the old method of checking for an empty variant and was also breaking clang 5.

lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     AFC67B151FBBB03600860ECB /* LibCxxBitset.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AFC67B141FBBB03500860ECB /* LibCxxBitset.cpp */; };
     945261C11B9A11FC00BF138D /* LibCxxInitializerList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 945261B71B9A11E800BF138D /* LibCxxInitializerList.cpp */; };
     945261C21B9A11FC00BF138D /* LibCxxList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 945261B81B9A11E800BF138D /* LibCxxList.cpp */; };
     945261C31B9A11FC00BF138D /* LibCxxMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 945261B91B9A11E800BF138D /* LibCxxMap.cpp */; };
     E4A63A9120F55D28000D9548 /* LibCxxOptional.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4A63A9020F55D27000D9548 /* LibCxxOptional.cpp */; };
     AF9FF1F71FAA79FE00474976 /* LibCxxQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AF9FF1F61FAA79FE00474976 /* LibCxxQueue.cpp */; };
     AF9FF1F51FAA79A400474976 /* LibCxxTuple.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AF9FF1F41FAA79A400474976 /* LibCxxTuple.cpp */; };
     945261C41B9A11FC00BF138D /* LibCxxUnorderedMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 945261BA1B9A11E800BF138D /* LibCxxUnorderedMap.cpp */; };
+    E414F6F121388F6C00C50BC6 /* LibCxxVariant.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E414F6F021388F6B00C50BC6 /* LibCxxVariant.cpp */; };
+    E414F6EE21388F0300C50BC6 /* LibCxxVariant.h in Headers */ = {isa = PBXBuildFile; fileRef = E414F6ED21388F0200C50BC6 /* LibCxxVariant.h */; };
     945261C51B9A11FC00BF138D /* LibCxxVector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 945261BB1B9A11E800BF138D /* LibCxxVector.cpp */; };
     945261C61B9A11FC00BF138D /* LibStdcpp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 945261BC1B9A11E800BF138D /* LibStdcpp.cpp */; };
     4CDB8D6E1DBA91B6006C5B13 /* LibStdcppTuple.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4CDB8D681DBA91A6006C5B13 /* LibStdcppTuple.cpp */; };
     4CDB8D6D1DBA91B6006C5B13 /* LibStdcppUniquePointer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4CDB8D671DBA91A6006C5B13 /* LibStdcppUniquePointer.cpp */; };
     268900DA13353E6F00698AC0 /* LineEntry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26BC7F1910F1B8EC00F91463 /* LineEntry.cpp */; };
     268900DB13353E6F00698AC0 /* LineTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26BC7F1A10F1B8EC00F91463 /* LineTable.cpp */; };
     23059A0719532B96007B8189 /* LinuxSignals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23059A0519532B96007B8189 /* LinuxSignals.cpp */; };
     2689004113353E0400698AC0 /* Listener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26BC7E7E10F1B85900F91463 /* Listener.cpp */; };
/* Begin PBXFileReference section */
     AFC67B141FBBB03500860ECB /* LibCxxBitset.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxBitset.cpp; path = Language/CPlusPlus/LibCxxBitset.cpp; sourceTree = "<group>"; };
     945261B71B9A11E800BF138D /* LibCxxInitializerList.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxInitializerList.cpp; path = Language/CPlusPlus/LibCxxInitializerList.cpp; sourceTree = "<group>"; };
     945261B81B9A11E800BF138D /* LibCxxList.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxList.cpp; path = Language/CPlusPlus/LibCxxList.cpp; sourceTree = "<group>"; };
     945261B91B9A11E800BF138D /* LibCxxMap.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxMap.cpp; path = Language/CPlusPlus/LibCxxMap.cpp; sourceTree = "<group>"; };
     E4A63A9020F55D27000D9548 /* LibCxxOptional.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxOptional.cpp; path = Language/CPlusPlus/LibCxxOptional.cpp; sourceTree = "<group>"; };
     AF9FF1F61FAA79FE00474976 /* LibCxxQueue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxQueue.cpp; path = Language/CPlusPlus/LibCxxQueue.cpp; sourceTree = "<group>"; };
     AF9FF1F41FAA79A400474976 /* LibCxxTuple.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxTuple.cpp; path = Language/CPlusPlus/LibCxxTuple.cpp; sourceTree = "<group>"; };
     945261BA1B9A11E800BF138D /* LibCxxUnorderedMap.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxUnorderedMap.cpp; path = Language/CPlusPlus/LibCxxUnorderedMap.cpp; sourceTree = "<group>"; };
+    E414F6F021388F6B00C50BC6 /* LibCxxVariant.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxVariant.cpp; path = Language/CPlusPlus/LibCxxVariant.cpp; sourceTree = "<group>"; };
+    E414F6ED21388F0200C50BC6 /* LibCxxVariant.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LibCxxVariant.h; path = Language/CPlusPlus/LibCxxVariant.h; sourceTree = "<group>"; };
     945261BB1B9A11E800BF138D /* LibCxxVector.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = LibCxxVector.cpp; path = Language/CPlusPlus/LibCxxVector.cpp; sourceTree = "<group>"; };
     945261BC1B9A11E800BF138D /* LibStdcpp.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = LibStdcpp.cpp; path = Language/CPlusPlus/LibStdcpp.cpp; sourceTree = "<group>"; };
     945261BD1B9A11E800BF138D /* LibStdcpp.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = LibStdcpp.h; path = Language/CPlusPlus/LibStdcpp.h; sourceTree = "<group>"; };
     4CDB8D681DBA91A6006C5B13 /* LibStdcppTuple.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LibStdcppTuple.cpp; path = Language/CPlusPlus/LibStdcppTuple.cpp; sourceTree = "<group>"; };
     4CDB8D671DBA91A6006C5B13 /* LibStdcppUniquePointer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LibStdcppUniquePointer.cpp; path = Language/CPlusPlus/LibStdcppUniquePointer.cpp; sourceTree = "<group>"; };
     26BC7F1910F1B8EC00F91463 /* LineEntry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LineEntry.cpp; path = source/Symbol/LineEntry.cpp; sourceTree = "<group>"; };
     26BC7C5B10F1B6E900F91463 /* LineEntry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LineEntry.h; path = include/lldb/Symbol/LineEntry.h; sourceTree = "<group>"; };
     26BC7F1A10F1B8EC00F91463 /* LineTable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LineTable.cpp; path = source/Symbol/LineTable.cpp; sourceTree = "<group>"; };
945261B01B9A11BE00BF138D /* Formatters */ = {
         AFC67B141FBBB03500860ECB /* LibCxxBitset.cpp */,
         945261B71B9A11E800BF138D /* LibCxxInitializerList.cpp */,
         945261B81B9A11E800BF138D /* LibCxxList.cpp */,
         945261B91B9A11E800BF138D /* LibCxxMap.cpp */,
         E4A63A9020F55D27000D9548 /* LibCxxOptional.cpp */,
         AF9FF1F61FAA79FE00474976 /* LibCxxQueue.cpp */,
         AF9FF1F41FAA79A400474976 /* LibCxxTuple.cpp */,
         945261BA1B9A11E800BF138D /* LibCxxUnorderedMap.cpp */,
+        E414F6ED21388F0200C50BC6 /* LibCxxVariant.h */,
+        E414F6F021388F6B00C50BC6 /* LibCxxVariant.cpp */,
         945261BB1B9A11E800BF138D /* LibCxxVector.cpp */,
         945261BD1B9A11E800BF138D /* LibStdcpp.h */,
         945261BC1B9A11E800BF138D /* LibStdcpp.cpp */,
       );
       name = Formatters;
       sourceTree = "<group>";
     };
     9457596415349416005A9070 /* POSIX */ = {
2689FFC813353D7A00698AC0 /* Headers */ = {
         AF8AD63A1BEC28C400150209 /* PlatformRemoteAppleWatch.h in Headers */,
         257906651BD5AFD000178368 /* Acceptor.h in Headers */,
         238F2BA21D2C835A001FF92A /* SystemRuntime.h in Headers */,
         260A63171861008E00FECF8E /* IOHandler.h in Headers */,
         267F68581CC02EAE0086832B /* RegisterContextPOSIX_s390x.h in Headers */,
         6D0F614F1C80AB0C00A4ECEE /* JavaLanguageRuntime.h in Headers */,
         AF27AD561D3603EA00CF2833 /* DynamicLoaderDarwin.h in Headers */,
         AFCB2BBE1BF577F40018B553 /* PythonExceptionState.h in Headers */,
+        E414F6EE21388F0300C50BC6 /* LibCxxVariant.h in Headers */,
         267F684B1CC02DED0086832B /* ABISysV_s390x.h in Headers */,
         AF8AD6311BEC28A400150209 /* PlatformAppleWatchSimulator.h in Headers */,
       );
       runOnlyForDeploymentPostprocessing = 0;
     };
 /* End PBXHeadersBuildPhase section */
 
 /* Begin PBXLegacyTarget section */
2689FFC613353D7A00698AC0 /* Sources */ = {
         26764C9E1E48F51E008D3573 /* Stream.cpp in Sources */,
         2689004613353E0400698AC0 /* ModuleList.cpp in Sources */,
         2689004713353E0400698AC0 /* PluginManager.cpp in Sources */,
         AE44FB3E1BB485960033EB62 /* GoLanguageRuntime.cpp in Sources */,
         AFF81FAF20D1CC400010F95E /* HostThreadMacOSX.mm in Sources */,
         AF0C112818580CD800C4C45B /* QueueItem.cpp in Sources */,
         AF254E31170CCC33007AE5C9 /* PlatformDarwinKernel.cpp in Sources */,
         2689004913353E0400698AC0 /* Scalar.cpp in Sources */,
+        E414F6F121388F6C00C50BC6 /* LibCxxVariant.cpp in Sources */,
         263FDE601A79A01500E68013 /* FormatEntity.cpp in Sources */,
         AF8AD62E1BEC28A400150209 /* PlatformAppleTVSimulator.cpp in Sources */,
         2689004A13353E0400698AC0 /* SearchFilter.cpp in Sources */,
         AFF81FAE20D1CC400010F95E /* HostInfoMacOSX.mm in Sources */,
         2689004B13353E0400698AC0 /* Section.cpp in Sources */,
         4984BA161B979973008658D4 /* ExpressionVariable.cpp in Sources */,
         2689004C13353E0400698AC0 /* SourceManager.cpp in Sources */,
         2689004D13353E0400698AC0 /* State.cpp in Sources */,

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/variant/Makefile

+LEVEL = ../../../../../make
+
+CXX_SOURCES := main.cpp
+
+USE_LIBCPP := 1
+include $(LEVEL)/Makefile.rules
+CXXFLAGS += -std=c++17

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/variant/TestDataFormatterLibcxxVariant.py

+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+import os
+import time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class LibcxxOptionalDataFormatterTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @add_test_categories(["libc++"])
+    ## We are skipping clang version less that 5.0 since this test requires -std=c++17
+    @skipIf(oslist=no_match(["macosx"]), compiler="clang", compiler_version=['<', '5.0'])
+    ## We are skipping gcc version less that 5.1 since this test requires -std=c++17
+    @skipIf(compiler="gcc", compiler_version=['<', '5.1'])
+
+    def test_with_run_command(self):
+        """Test that that file and class static variables display correctly."""
+        self.build()
+
+        (self.target, self.process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here',
+                lldb.SBFileSpec("main.cpp", False))
+
+        self.runCmd( "frame variable has_variant" )
+
+        output = self.res.GetOutput()
+
+        ## The variable has_variant tells us if the test program
+        ## detected we have a sufficient libc++ version to support variant
+        ## false means we do not and therefore should skip the test
+        if output.find("(bool) has_variant = false") != -1 :
+            self.skipTest( "std::variant not supported" )
+
+        lldbutil.continue_to_breakpoint(self.process, bkpt)
+
+        self.expect("frame variable v1",
+                substrs=['v1 =  Active Type = int  {',
+                               'Value = 12',
+                               '}'])
+
+        self.expect("frame variable v1_ref",
+                substrs=['v1_ref =  Active Type = int : {',
+                               'Value = 12',
+                               '}'])
+
+        self.expect("frame variable v_v1",
+                substrs=['v_v1 =  Active Type = std::__1::variant<int, double, char>  {',
+                                 'Value =  Active Type = int  {',
+                                   'Value = 12',
+                                 '}',
+                               '}'])
+
+        lldbutil.continue_to_breakpoint(self.process, bkpt)
+
+        self.expect("frame variable v1",
+                substrs=['v1 =  Active Type = double  {',
+                               'Value = 2',
+                               '}'])
+
+        lldbutil.continue_to_breakpoint(self.process, bkpt)
+
+        self.expect("frame variable v2",
+                substrs=['v2 =  Active Type = double  {',
+                               'Value = 2',
+                               '}'])
+
+        self.expect("frame variable v3",
+                substrs=['v3 =  Active Type = char  {',
+                               'Value = \'A\'',
+                               '}'])
+
+        self.expect("frame variable v_no_value",
+                    substrs=['v_no_value =  No Value'])

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/variant/main.cpp

+#include <cstdio>
+#include <string>
+#include <vector>
+
+// If we have libc++ 4.0 or greater we should have <variant>
+// According to libc++ C++1z status page https://libcxx.llvm.org/cxx1z_status.html
+#if _LIBCPP_VERSION >= 4000
+#include <variant>
+#define HAVE_VARIANT 1
+#else
+#define HAVE_VARIANT 0
+#endif
+
+struct S {
+  operator int() { throw 42; }
+} ;
+
+
+int main()
+{
+    bool has_variant = HAVE_VARIANT ;
+
+    printf( "%d\n", has_variant ) ; // break here
+
+#if HAVE_VARIANT == 1
+    std::variant<int, double, char> v1;
+    std::variant<int, double, char> &v1_ref = v1;
+    std::variant<int, double, char> v2;
+    std::variant<int, double, char> v3;
+    std::variant<std::variant<int,double,char>> v_v1 ;
+    std::variant<int, double, char> v_no_value;
+
+    v1 = 12; // v contains int
+    v_v1 = v1 ;
+    int i = std::get<int>(v1);
+    printf( "%d\n", i ); // break here
+
+    v2 = 2.0 ;
+    double d = std::get<double>(v2) ;
+    printf( "%f\n", d );
+
+    v3 = 'A' ;
+    char c = std::get<char>(v3) ;
+    printf( "%d\n", c );
+
+    // Checking v1 above and here to make sure we done maintain the incorrect
+    // state when we change its value.
+    v1 = 2.0;
+    d = std::get<double>(v1) ;
+    printf( "%f\n", d ); // break here
+
+     try {
+       v_no_value.emplace<0>(S());
+     } catch( ... ) {}
+
+     printf( "%zu\n", v_no_value.index() ) ;
+#endif
+
+    return 0; // break here
+}

source/Plugins/Language/CPlusPlus/CMakeLists.txt

 add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
   BlockPointer.cpp
   CPlusPlusLanguage.cpp
   CPlusPlusNameParser.cpp
   CxxStringTypes.cpp
   LibCxx.cpp
   LibCxxAtomic.cpp
   LibCxxBitset.cpp
   LibCxxInitializerList.cpp
   LibCxxList.cpp
   LibCxxMap.cpp
   LibCxxOptional.cpp
   LibCxxQueue.cpp
   LibCxxTuple.cpp
   LibCxxUnorderedMap.cpp
+  LibCxxVariant.cpp
   LibCxxVector.cpp
   LibStdcpp.cpp
   LibStdcppTuple.cpp
   LibStdcppUniquePointer.cpp
 
   LINK_LIBS
     lldbCore
     lldbDataFormatters

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "BlockPointer.h"
 #include "CPlusPlusNameParser.h"
 #include "CxxStringTypes.h"
 #include "LibCxx.h"
 #include "LibCxxAtomic.h"
+#include "LibCxxVariant.h"
 #include "LibStdcpp.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 void CPlusPlusLanguage::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language",
#ifndef LLDB_DISABLE_PYTHON
   AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator,
                   "libc++ std::tuple synthetic children",
                   ConstString("^std::__(ndk)?1::tuple<.*>(( )?&)?$"), stl_synth_flags,
                   true);
   AddCXXSynthetic(cpp_category_sp, LibcxxOptionalFrontEndCreator,
                   "libc++ std::optional synthetic children",
                   ConstString("^std::__(ndk)?1::optional<.+>(( )?&)?$"),
                   stl_synth_flags, true);
+  AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator,
+                  "libc++ std::variant synthetic children",
+                  ConstString("^std::__(ndk)?1::variant<.+>(( )?&)?$"),
+                  stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
       "libc++ std::atomic synthetic children",
       ConstString("^std::__(ndk)?1::atomic<.+>$"), stl_synth_flags, true);
 
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpressionSP(new RegularExpression(
AddCXXSummary(
       cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider,
       "libc++ std::atomic summary provider",
       ConstString("^std::__(ndk)?1::atomic<.+>$"), stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxOptionalSummaryProvider,
                 "libc++ std::optional summary provider",
                 ConstString("^std::__(ndk)?1::optional<.+>(( )?&)?$"),
                 stl_summary_flags, true);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::LibcxxVariantSummaryProvider,
+                "libc++ std::variant summary provider",
+                ConstString("^std::__(ndk)?1::variant<.+>(( )?&)?$"),
+                stl_summary_flags, true);
 
   stl_summary_flags.SetSkipPointers(true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
                 "libc++ std::shared_ptr summary provider",
                 ConstString("^std::__(ndk)?1::shared_ptr<.+>(( )?&)?$"),
                 stl_summary_flags, true);

source/Plugins/Language/CPlusPlus/LibCxx.h

 
 SyntheticChildrenFrontEnd *LibcxxTupleFrontEndCreator(CXXSyntheticChildren *,
                                                       lldb::ValueObjectSP);
 
 SyntheticChildrenFrontEnd *
 LibcxxOptionalFrontEndCreator(CXXSyntheticChildren *,
                               lldb::ValueObjectSP valobj_sp);
 
+SyntheticChildrenFrontEnd *
+LibcxxVariantFrontEndCreator(CXXSyntheticChildren *,
+                             lldb::ValueObjectSP valobj_sp);
+
 } // namespace formatters
 } // namespace lldb_private
 
 #endif // liblldb_LibCxx_h_

source/Plugins/Language/CPlusPlus/LibCxxVariant.h

+//===-- LibCxxVariant.h -------------------------------------------*- C++
+//-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_LibCxxVariant_h_
+#define liblldb_LibCxxVariant_h_
+
+#include "lldb/Core/ValueObject.h"
+#include "lldb/DataFormatters/TypeSummary.h"
+#include "lldb/DataFormatters/TypeSynthetic.h"
+#include "lldb/Utility/Stream.h"
+
+namespace lldb_private {
+namespace formatters {
+bool LibcxxVariantSummaryProvider(
+    ValueObject &valobj, Stream &stream,
+    const TypeSummaryOptions &options); // libc++ std::variant<>
+
+SyntheticChildrenFrontEnd *LibcxxVariantFrontEndCreator(CXXSyntheticChildren *,
+                                                        lldb::ValueObjectSP);
+
+} // namespace formatters
+} // namespace lldb_private
+
+#endif // liblldb_LibCxxVariant_h_

source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp

+//===-- LibCxxVariant.cpp --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LibCxxVariant.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/ScopeExit.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+// libc++ variant implementation contains two members that we care about both
+// are contained in the __impl member.
+// - __index which tells us which of the variadic template types is the active
+//   type for the variant
+// - __data is a variadic union which recursively contains itself as member
+//   which refers to the tailing variadic types.
+//   - __head which refers to the leading non pack type
+//     - __value refers to the actual value contained
+//   - __tail which refers to the remaining pack types
+//
+// e.g. given std::variant<int,double,char> v1
+//
+// (lldb) frame var -R v1.__impl.__data
+//(... __union<... 0, int, double, char>) v1.__impl.__data = {
+// ...
+//  __head = {
+//    __value = ...
+//  }
+//  __tail = {
+//  ...
+//    __head = {
+//      __value = ...
+//    }
+//    __tail = {
+//    ...
+//      __head = {
+//        __value = ...
+//  ...
+//
+// So given
+// - __index equal to 0 the active value is contained in
+//
+//     __data.__head.__value
+//
+// - __index equal to 1 the active value is contained in
+//
+//     __data.__tail.__head.__value
+//
+// - __index equal to 2 the active value is contained in
+//
+//      __data.__tail.__tail.__head.__value
+//
+
+namespace {
+// libc++ std::variant index could have one of three states
+// 1) VALID, we can obtain it and its not variant_npos
+// 2) INVALID, we can't obtain it or it is not a type we expect
+// 3) NPOS, its value is variant_npos which means the variant has no value
+enum class LibcxxVariantIndexValidity { VALID, INVALID, NPOS };
+
+LibcxxVariantIndexValidity
+LibcxxVariantGetIndexValidity(ValueObjectSP &impl_sp) {
+  ValueObjectSP index_sp(
+      impl_sp->GetChildMemberWithName(ConstString("__index"), true));
+
+  if (!index_sp)
+    return LibcxxVariantIndexValidity::INVALID;
+
+  int64_t index_value = index_sp->GetValueAsSigned(0);
+
+  if (index_value == -1)
+    return LibcxxVariantIndexValidity::NPOS;
+
+  return LibcxxVariantIndexValidity::VALID;
+}
+
+llvm::Optional<uint64_t> LibcxxVariantIndexValue(ValueObjectSP &impl_sp) {
+  ValueObjectSP index_sp(
+      impl_sp->GetChildMemberWithName(ConstString("__index"), true));
+
+  if (!index_sp)
+    return {};
+
+  return {index_sp->GetValueAsUnsigned(0)};
+}
+
+ValueObjectSP LibcxxVariantGetNthHead(ValueObjectSP &impl_sp, uint64_t index) {
+  ValueObjectSP data_sp(
+      impl_sp->GetChildMemberWithName(ConstString("__data"), true));
+
+  if (!data_sp)
+    return ValueObjectSP{};
+
+  ValueObjectSP current_level = data_sp;
+  for (uint64_t n = index; n != 0; --n) {
+    ValueObjectSP tail_sp(
+        current_level->GetChildMemberWithName(ConstString("__tail"), true));
+
+    if (!tail_sp)
+      return ValueObjectSP{};
+
+    current_level = tail_sp;
+  }
+
+  return current_level->GetChildMemberWithName(ConstString("__head"), true);
+};
+} // namespace
+
+namespace lldb_private {
+namespace formatters {
+bool LibcxxVariantSummaryProvider(ValueObject &valobj, Stream &stream,
+                                  const TypeSummaryOptions &options) {
+  ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
+  if (!valobj_sp)
+    return false;
+
+  ValueObjectSP impl_sp(
+      valobj_sp->GetChildMemberWithName(ConstString("__impl"), true));
+
+  if (!impl_sp)
+    return false;
+
+  LibcxxVariantIndexValidity validity = LibcxxVariantGetIndexValidity(impl_sp);
+
+  if (validity == LibcxxVariantIndexValidity::INVALID)
+    return false;
+
+  if (validity == LibcxxVariantIndexValidity::NPOS) {
+    stream.Printf(" No Value");
+    return true;
+  }
+
+  auto optional_index_value = LibcxxVariantIndexValue(impl_sp);
+
+  if (!optional_index_value)
+    return false;
+
+  uint64_t index_value = *optional_index_value;
+
+  ValueObjectSP nth_head = LibcxxVariantGetNthHead(impl_sp, index_value);
+
+  if (!nth_head)
+    return false;
+
+  CompilerType head_type = nth_head->GetCompilerType();
+
+  if (!head_type)
+    return false;
+
+  CompilerType template_type = head_type.GetTypeTemplateArgument(1);
+
+  if (!template_type)
+    return false;
+
+  stream.Printf(" Active Type = %s ", template_type.GetTypeName().GetCString());
+
+  return true;
+}
+} // namespace formatters
+} // namespace lldb_private
+
+namespace {
+class VariantFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+  VariantFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) {
+    Update();
+  }
+
+  size_t GetIndexOfChildWithName(const ConstString &name) override {
+    return formatters::ExtractIndexFromString(name.GetCString());
+  }
+
+  bool MightHaveChildren() override { return true; }
+  bool Update() override;
+  size_t CalculateNumChildren() override { return m_size; }
+  ValueObjectSP GetChildAtIndex(size_t idx) override;
+
+private:
+  size_t m_size = 0;
+  ValueObjectSP m_base_sp;
+};
+} // namespace
+
+bool VariantFrontEnd::Update() {
+  m_size = 0;
+  ValueObjectSP impl_sp(
+      m_backend.GetChildMemberWithName(ConstString("__impl"), true));
+  if (!impl_sp)
+    return false;
+
+  LibcxxVariantIndexValidity validity = LibcxxVariantGetIndexValidity(impl_sp);
+
+  if (validity == LibcxxVariantIndexValidity::INVALID)
+    return false;
+
+  if (validity == LibcxxVariantIndexValidity::NPOS)
+    return true;
+
+  m_size = 1;
+
+  return false;
+}
+
+ValueObjectSP VariantFrontEnd::GetChildAtIndex(size_t idx) {
+  if (idx >= m_size)
+    return ValueObjectSP();
+
+  ValueObjectSP impl_sp(
+      m_backend.GetChildMemberWithName(ConstString("__impl"), true));
+
+  auto optional_index_value = LibcxxVariantIndexValue(impl_sp);
+
+  if (!optional_index_value)
+    return ValueObjectSP();
+
+  uint64_t index_value = *optional_index_value;
+
+  ValueObjectSP nth_head = LibcxxVariantGetNthHead(impl_sp, index_value);
+
+  if (!nth_head)
+    return ValueObjectSP();
+
+  CompilerType head_type = nth_head->GetCompilerType();
+
+  if (!head_type)
+    return ValueObjectSP();
+
+  CompilerType template_type = head_type.GetTypeTemplateArgument(1);
+
+  if (!template_type)
+    return ValueObjectSP();
+
+  ValueObjectSP head_value(
+      nth_head->GetChildMemberWithName(ConstString("__value"), true));
+
+  if (!head_value)
+    return ValueObjectSP();
+
+  return head_value->Clone(ConstString(ConstString("Value").AsCString()));
+}
+
+SyntheticChildrenFrontEnd *
+formatters::LibcxxVariantFrontEndCreator(CXXSyntheticChildren *,
+                                         lldb::ValueObjectSP valobj_sp) {
+  if (valobj_sp)
+    return new VariantFrontEnd(*valobj_sp);
+  return nullptr;
+}