Centralize libc++ test skipping logic

[labath]

Summary

This aims to replace the different decorators we've had on each libc++
test with a single solution. Each libc++ will be assigned to the
"libc++" category and a single central piece of code will decide whether
we are actually able to run libc++ test in the given configuration by
enabling or disabling the category (while giving the user the
opportunity to override this).

I started this effort because I wanted to get libc++ tests running on
android, and none of the existing decorators worked for this use case:

• skipIfGcc - incorrect, we can build libc++ executables on android with gcc (in fact, after this, we can now do it on linux as well)
• lldbutil.skip_if_library_missing - this checks whether libc++.so is loaded in the proces, which fails in case of a statically linked libc++ (this makes copying executables to the remote target easier to manage).

To make this work I needed to split out the pseudo_barrier code from the
force-included file, as libc++'s atomic does not play well with gcc on
linux, and this made every test fail, even though we need the code only
in the threading tests.

So far, I am only annotating one of the tests with this category. If
this does not break anything, I'll proceed to update the rest.

[labath]

Does anyone object to me landing this? I am going to be careful and wait for the change to trickle through CI before submitting any followup changes.

[EricWF]

I don't see anything wrong with this, but I only know libc++ and not LLDB.

libc++'s atomic does not play well with gcc on linux

It should... Can you elaborate on this issue? I suspect this may be a libc++ bug.

[labath]

In D30984#711806, @EricWF wrote:

I don't see anything wrong with this, but I only know libc++ and not LLDB.

I'm not sure why you ended up here. I think you have too wide phabricator filter somewhere. :)

libc++'s atomic does not play well with gcc on linux

It should... Can you elaborate on this issue? I suspect this may be a libc++ bug.

It checks for #if __has_feature(cxx_atomic) and then aborts if it is not found. However, this is in the system libc++ on ubuntu (lldb uses system libc++ for reasons which are too long to go into right now), which is quite old. I don't see a similar check in the current trunk, so it's possible that has been fixed since then.

[EricWF]

In D30984#713490, @labath wrote:

In D30984#711806, @EricWF wrote:

I don't see anything wrong with this, but I only know libc++ and not LLDB.

I'm not sure why you ended up here. I think you have too wide phabricator filter somewhere. :)

libc++'s atomic does not play well with gcc on linux

It should... Can you elaborate on this issue? I suspect this may be a libc++ bug.

It checks for #if __has_feature(cxx_atomic) and then aborts if it is not found. However, this is in the system libc++ on ubuntu (lldb uses system libc++ for reasons which are too long to go into right now), which is quite old. I don't see a similar check in the current trunk, so it's possible that has been fixed since then.

GCC <atomic> support has been present since ~2015, so I suspect the issue has since been fixed. And the libc++ version on <ubuntu> is unbelievable old.

packages/Python/lldbsuite/test/dotest.py

pipe = subprocess.Popen(
         ['xcrun', '-find', c], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
     cmd_output = pipe.stdout.read()
     if not cmd_output or "not found" in cmd_output:
         raise Exception(c + " is not a valid compiler")
 
     configuration.compiler = cmd_output.split('\n')[0]
     print("'xcrun -find %s' returning %s" % (c, configuration.compiler))
 
+def canRunLibcxxTests():
+    from lldbsuite.test import lldbplatformutil
+
+    platform = lldbplatformutil.getPlatform()
+
+    if lldbplatformutil.target_is_android() or lldbplatformutil.platformIsDarwin():
+        return True, "libc++ always present"
+
+    if platform == "linux":
+        if not os.path.isdir("/usr/include/c++/v1"):
+            return False, "Unable to find libc++ installation"
+        return True, "Headers found, let's hope they work"
+
+    return False, "Don't know how to build with libc++ on %s" % platform
+
+def checkLibcxxSupport():
+    result, reason = canRunLibcxxTests()
+    if result:
+        return # libc++ supported
+    if "libc++" in configuration.categoriesList:
+        return # libc++ category explicitly requested, let it run.
+    print("Libc++ tests will not be run because: " + reason)
+    configuration.skipCategories.append("libc++")
 
 def run_suite():
     # On MacOS X, check to make sure that domain for com.apple.DebugSymbols defaults
     # does not exist before proceeding to running the test suite.
     if sys.platform.startswith("darwin"):
         checkDsymForUUIDIsNotOn()
 
     #
if configuration.lldb_platform_working_dir:
         lldb.DBG.SetSelectedPlatform(lldb.remote_platform)
     else:
         lldb.remote_platform = None
         configuration.lldb_platform_working_dir = None
         configuration.lldb_platform_url = None
 
     target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
 
+    checkLibcxxSupport()
+
     # Don't do debugserver tests on everything except OS X.
     configuration.dont_do_debugserver_test = "linux" in target_platform or "freebsd" in target_platform or "windows" in target_platform
 
     # Don't do lldb-server (llgs) tests on anything except Linux.
     configuration.dont_do_llgs_test = not ("linux" in target_platform)
 
     #
     # Walk through the testdirs while collecting tests.

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py

class LibcxxStringDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
+        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
+        self.namespace = 'std::__' + ns + '1'
 
-    @skipIf(compiler="gcc")
-    @skipIfWindows  # libc++ not ported to Windows yet
+    @add_test_categories(["libc++"])
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=-1)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
-        lldbutil.skip_if_library_missing(
-            self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
-
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('type format clear', check=False)
             self.runCmd('type summary clear', check=False)
             self.runCmd('type filter clear', check=False)
             self.runCmd('type synth clear', check=False)
             self.runCmd(
                 "settings set target.max-children-count 256",
                 check=False)
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
+        ns = self.namespace
         self.expect(
             "frame variable",
             substrs=[
-                '(std::__1::wstring) s = L"hello world! מזל טוב!"',
-                '(std::__1::wstring) S = L"!!!!"',
+                '(%s::wstring) s = L"hello world! מזל טוב!"'%ns,
+                '(%s::wstring) S = L"!!!!"'%ns,
                 '(const wchar_t *) mazeltov = 0x',
                 'L"מזל טוב"',
-                '(std::__1::string) q = "hello world"',
-                '(std::__1::string) Q = "quite a long std::strin with lots of info inside it"',
-                '(std::__1::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"',
-                '(std::__1::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'])
+                '(%s::string) q = "hello world"'%ns,
+                '(%s::string) Q = "quite a long std::strin with lots of info inside it"'%ns,
+                '(%s::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"'%ns,
+                '(%s::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'%ns])
 
         self.runCmd("n")
 
         TheVeryLongOne = self.frame().FindVariable("TheVeryLongOne")
         summaryOptions = lldb.SBTypeSummaryOptions()
         summaryOptions.SetCapping(lldb.eTypeSummaryUncapped)
         uncappedSummaryStream = lldb.SBStream()
         TheVeryLongOne.GetSummary(uncappedSummaryStream, summaryOptions)
         uncappedSummary = uncappedSummaryStream.GetData()
         self.assertTrue(uncappedSummary.find("someText") > 0,
                         "uncappedSummary does not include the full string")
         summaryOptions.SetCapping(lldb.eTypeSummaryCapped)
         cappedSummaryStream = lldb.SBStream()
         TheVeryLongOne.GetSummary(cappedSummaryStream, summaryOptions)
         cappedSummary = cappedSummaryStream.GetData()
         self.assertTrue(
             cappedSummary.find("someText") <= 0,
             "cappedSummary includes the full string")
 
         self.expect(
             "frame variable",
             substrs=[
-                '(std::__1::wstring) s = L"hello world! מזל טוב!"',
-                '(std::__1::wstring) S = L"!!!!!"',
+                '(%s::wstring) s = L"hello world! מזל טוב!"'%ns,
+                '(%s::wstring) S = L"!!!!!"'%ns,
                 '(const wchar_t *) mazeltov = 0x',
                 'L"מזל טוב"',
-                '(std::__1::string) q = "hello world"',
-                '(std::__1::string) Q = "quite a long std::strin with lots of info inside it"',
-                '(std::__1::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"',
-                '(std::__1::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'])
+                '(%s::string) q = "hello world"'%ns,
+                '(%s::string) Q = "quite a long std::strin with lots of info inside it"'%ns,
+                '(%s::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"'%ns,
+                '(%s::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'%ns])

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/gcore/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test verifies the correct handling of child thread exits.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <thread>
 #include <csignal>
 
 pseudo_barrier_t g_barrier1;
 pseudo_barrier_t g_barrier2;
 
 void *
 thread1 ()

packages/Python/lldbsuite/test/functionalities/postmortem/elf-core/thread_crash/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test verifies the correct handling of child thread exits.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <thread>
 #include <csignal>
 
 pseudo_barrier_t g_barrier1;
 pseudo_barrier_t g_barrier2;
 
 void *
 thread1 ()

packages/Python/lldbsuite/test/functionalities/thread/break_after_join/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test is intended to create a situation in which one thread will exit
 // while a breakpoint is being handled in another thread.  This may not always
 // happen because it's possible that the exiting thread will exit before the
 // breakpoint is hit.  The test case should be flexible enough to treat that
 // as success.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <chrono>
 #include <thread>
 
 volatile int g_test = 0;
 
 // A barrier to synchronize all the threads.
 pseudo_barrier_t g_barrier1;
 

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test is intended to create a situation in which multiple events
 // (breakpoints, watchpoints, crashes, and signal generation/delivery) happen
 // from multiple threads. The test expects the debugger to set a breakpoint on
 // the main thread (before any worker threads are spawned) and modify variables
 // which control the number of threads that are spawned for each action.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <vector>
 using namespace std;
 
 #include <pthread.h>
 
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>

packages/Python/lldbsuite/test/functionalities/thread/create_during_step/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test is intended to create a situation in which one thread will be
 // created while the debugger is stepping in another thread.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <thread>
 
 #define do_nothing()
 
 pseudo_barrier_t g_barrier;
 
 volatile int g_thread_created = 0;
 volatile int g_test = 0;

packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test is intended to create a situation in which one thread will exit
 // while a breakpoint is being handled in another thread.  This may not always
 // happen because it's possible that the exiting thread will exit before the
 // breakpoint is hit.  The test case should be flexible enough to treat that
 // as success.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <chrono>
 #include <thread>
 
 volatile int g_test = 0;
 
 // A barrier to synchronize all the threads except the one that will exit.
 pseudo_barrier_t g_barrier1;
 

packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test is intended to create a situation in which one thread will exit
 // while the debugger is stepping in another thread.
 
+#include "pseudo_barrier.h"
 #include <thread>
 
 #define do_nothing()
 
 // A barrier to synchronize thread start.
 pseudo_barrier_t g_barrier;
 
 volatile int g_thread_exited = 0;

packages/Python/lldbsuite/test/functionalities/thread/multi_break/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test is intended to create a situation in which a breakpoint will be
 // hit in two threads at nearly the same moment.  The expected result is that
 // the breakpoint in the second thread will be hit while the breakpoint handler
 // in the first thread is trying to stop all threads.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <thread>
 
 pseudo_barrier_t g_barrier;
 
 volatile int g_test = 0;
 
 void *
 thread_func ()

packages/Python/lldbsuite/test/functionalities/thread/step_out/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test is intended to create a situation in which two threads are stopped
 // at a breakpoint and the debugger issues a step-out command.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <thread>
 
 pseudo_barrier_t g_barrier;
 
 volatile int g_test = 0;
 
 void step_out_of_here() {
   g_test += 5; // Set breakpoint here

packages/Python/lldbsuite/test/functionalities/thread/thread_exit/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This test verifies the correct handling of child thread exits.
 
-#include <atomic>
+#include "pseudo_barrier.h"
 #include <thread>
 
 pseudo_barrier_t g_barrier1;
 pseudo_barrier_t g_barrier2;
 pseudo_barrier_t g_barrier3;
 
 void *
 thread1 ()

packages/Python/lldbsuite/test/lldbplatformutil.py

def _run_adb_command(cmd, device_id):
     p = subprocess.Popen(
         full_cmd,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE)
     stdout, stderr = p.communicate()
     return p.returncode, stdout, stderr
 
 
-def _target_is_android():
-    if not hasattr(_target_is_android, 'result'):
+def target_is_android():
+    if not hasattr(target_is_android, 'result'):
         triple = lldb.DBG.GetSelectedPlatform().GetTriple()
         match = re.match(".*-.*-.*-android", triple)
-        _target_is_android.result = match is not None
-    return _target_is_android.result
+        target_is_android.result = match is not None
+    return target_is_android.result
 
 
 def android_device_api():
     if not hasattr(android_device_api, 'result'):
         assert configuration.lldb_platform_url is not None
         device_id = None
         parsed_url = urlparse.urlparse(configuration.lldb_platform_url)
         host_name = parsed_url.netloc.split(":")[0]
if not hasattr(android_device_api, 'result'):
                 ">>> Unable to determine the API level of the Android device.\n"
                 ">>> stdout:\n%s\n"
                 ">>> stderr:\n%s\n" %
                 (stdout, stderr))
     return android_device_api.result
 
 
 def match_android_device(device_arch, valid_archs=None, valid_api_levels=None):
-    if not _target_is_android():
+    if not target_is_android():
         return False
     if valid_archs is not None and device_arch not in valid_archs:
         return False
     if valid_api_levels is not None and android_device_api() not in valid_api_levels:
         return False
 
     return True
 
 
 def finalize_build_dictionary(dictionary):
-    if _target_is_android():
+    if target_is_android():
         if dictionary is None:
             dictionary = {}
         dictionary["OS"] = "Android"
         if android_device_api() >= 16:
             dictionary["PIE"] = 1
     return dictionary
 
 

packages/Python/lldbsuite/test/make/Makefile.rules

 
 CFLAGS ?= $(DEBUG_INFO_FLAG) -O0 -fno-builtin
 ifeq "$(OS)" "Darwin"
   CFLAGS += $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) -I$(LLDB_BASE_DIR)include
 else
   CFLAGS += $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) -I$(LLDB_BASE_DIR)include
 endif
 
-CFLAGS += -include $(THIS_FILE_DIR)test_common.h $(ARCH_CFLAGS)
+CFLAGS += -include $(THIS_FILE_DIR)test_common.h -I$(THIS_FILE_DIR) $(ARCH_CFLAGS)
 
 # Use this one if you want to build one part of the result without debug information:
 ifeq "$(OS)" "Darwin"
   CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) $(ARCH_CFLAGS)
 else
   CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) $(ARCH_CFLAGS)
 endif
 
ifeq (1,$(USE_LIBSTDCPP))
   # Clang requires an extra flag: -stdlib=libstdc++
   ifneq (,$(findstring clang,$(CC)))
     CXXFLAGS += -stdlib=libstdc++ -DLLDB_USING_LIBSTDCPP
     LDFLAGS += -stdlib=libstdc++
   endif
 endif
 
 ifeq (1,$(USE_LIBCPP))
-  # Clang requires an extra flag: -stdlib=libstdc++
-  ifneq (,$(findstring clang,$(CC)))
-    CXXFLAGS += -DLLDB_USING_LIBCPP
-    ifeq "$(OS)" "Linux"
-      # This is the default install location on Ubuntu 14.04
-      ifneq ($(wildcard /usr/include/c++/v1/.),)
-        CXXFLAGS += -stdlib=libc++
-        LDFLAGS += -stdlib=libc++
-        CXXFLAGS += -I/usr/include/c++/v1
-      endif
-    else ifeq "$(OS)" "Android"
-      # Nothing to do, this is already handled in
-      # Android.rules.
-    else
-      CXXFLAGS += -stdlib=libc++
-      LDFLAGS += -stdlib=libc++
-    endif
-  endif
-endif
+    ifneq (,$(findstring clang,$(CC)))
+    else
+      CXXFLAGS += -isystem /usr/include/c++/v1
+      LDFLAGS += -lc++
 
 #----------------------------------------------------------------------
 # dylib settings
 #----------------------------------------------------------------------
 ifneq "$(strip $(DYLIB_C_SOURCES))" ""
   DYLIB_OBJECTS +=$(strip $(DYLIB_C_SOURCES:.c=.o))
 endif
 

packages/Python/lldbsuite/test/make/pseudo_barrier.h

+#include <atomic>
+
+// Note that although hogging the CPU while waiting for a variable to change
+// would be terrible in production code, it's great for testing since it
+// avoids a lot of messy context switching to get multiple threads synchronized.
+
+typedef std::atomic<int> pseudo_barrier_t;
+#define pseudo_barrier_wait(barrier)        \
+    do                                      \
+    {                                       \
+        --(barrier);                        \
+        while ((barrier).load() > 0)        \
+            ;                               \
+    } while (0)
+
+#define pseudo_barrier_init(barrier, count) \
+    do                                      \
+    {                                       \
+        (barrier) = (count);                \
+    } while (0)

packages/Python/lldbsuite/test/make/test_common.h

do                                                                                \
         (void)prctl_result;                                                           \
     } while (0)
 
 #else // not linux
 
 #define lldb_enable_attach()
 
 #endif
-
-#if defined(__APPLE__) && defined(LLDB_USING_LIBSTDCPP)              
-
-// on Darwin, libstdc++ is missing <atomic>, so this would cause any test to fail building
-// since this header file is being included in every C-family test case, we need to not include it
-// on Darwin, most tests use libc++ by default, so this will only affect tests that explicitly require libstdc++
-
-#else
-#ifdef __cplusplus
-#include <atomic>
-
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
-
-typedef std::atomic<int> pseudo_barrier_t;
-#define pseudo_barrier_wait(barrier)        \
-    do                                      \
-    {                                       \
-        --(barrier);                        \
-        while ((barrier).load() > 0)        \
-            ;                               \
-    } while (0)
-
-#define pseudo_barrier_init(barrier, count) \
-    do                                      \
-    {                                       \
-        (barrier) = (count);                \
-    } while (0)
-#endif // __cplusplus
-#endif // defined(__APPLE__) && defined(LLDB_USING_LIBSTDCPP)

packages/Python/lldbsuite/test/test_categories.py

 
 all_categories = {
     'dataformatters': 'Tests related to the type command and the data formatters subsystem',
     'dwarf': 'Tests that can be run with DWARF debug information',
     'dwo': 'Tests that can be run with DWO debug information',
     'dsym': 'Tests that can be run with DSYM debug information',
     'gmodules': 'Tests that can be run with -gmodules debug information',
     'expression': 'Tests related to the expression parser',
+    'libc++': 'Test for libc++ data formatters',
     'objc': 'Tests related to the Objective-C programming language support',
     'pyapi': 'Tests related to the Python API',
     'basic_process': 'Basic process execution sniff tests.',
     'cmdline': 'Tests related to the LLDB command-line interface',
     'dyntype': 'Tests related to dynamic type support',
     'stresstest': 'Tests related to stressing lldb limits',
     'flakey': 'Flakey test cases, i.e. tests that do not reliably pass at each execution',
     'lldb-mi': 'lldb-mi tests'}