Add optimizer barrier to benchmark calls of void-returning functions

The goal is to do the equivalent of clobbering memory, which forces
the compiler to keep side effects that are external to the benchmarked
function, while allowing it to optimize inside the benchmarked function.

E.g. this cannot be optimized away:
```cpp
BENCHMARK("foo") {
    global_count += 1;
};
```

while this can:
```cpp
BENCHMARK("bar") {
    size_t local_count = 0;
    for (size_t i = 0; i < 100; ++i) {
        local_count += 1;
    }
};
```

src/catch2/benchmark/catch_optimizer.hpp

@@ -34,7 +34,7 @@ namespace Catch {
         } // namespace Detail
 #elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
 
-#if defined(_MSVC_VER)
+#if defined(_MSC_VER)
 #pragma optimize("", off)
 #elif defined(__IAR_SYSTEMS_ICC__)
 // For IAR the pragma only affects the following function
@@ -71,6 +71,13 @@ namespace Catch {
         template <typename Fn, typename... Args>
         inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
             CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...);
+            // In the non-void case, we pass the result through `deoptimize_value`
+            // to force the compiler to keep it. We have no return value here,
+            // but add an optimizer barrier (ideally a memory clobber) to force
+            // the _side effects_ of the loop be visible (e.g. writes to globals).
+            // Note that writes to benchmark-locals can be optimized away, as
+            // we would expect in normal code.
+            Detail::optimizer_barrier();
         }
     } // namespace Benchmark
 } // namespace Catch

tests/CMakeLists.txt

@@ -486,19 +486,6 @@ set_tests_properties("Benchmarking::SkipBenchmarkMacros"
     FAIL_REGULAR_EXPRESSION "benchmark name"
 )
 
-add_test(NAME "Benchmarking::FailureReporting::OptimizedOut"
-  COMMAND
-    $<TARGET_FILE:SelfTest> "Failing benchmarks" -c "empty" -r xml
-  # This test only makes sense with the optimizer being enabled when
-  # the tests are being compiled.
-  CONFIGURATIONS Release
-)
-set_tests_properties("Benchmarking::FailureReporting::OptimizedOut"
-  PROPERTIES
-    PASS_REGULAR_EXPRESSION "could not measure benchmark\, maybe it was optimized away"
-    FAIL_REGULAR_EXPRESSION "successes=\"1\""
-)
-
 add_test(NAME "Benchmarking::FailureReporting::ThrowingBenchmark"
   COMMAND
     $<TARGET_FILE:SelfTest> "Failing benchmarks" -c "throw" -r xml

tests/SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp

@@ -429,9 +429,6 @@ TEST_CASE("run benchmark", "[benchmark][approvals]") {
 }
 
 TEST_CASE("Failing benchmarks", "[!benchmark][.approvals]") {
-    SECTION("empty", "Benchmark that has been optimized away (because it is empty)") {
-        BENCHMARK("Empty benchmark") {};
-    }
     SECTION("throw", "Benchmark that throws an exception") {
         BENCHMARK("Throwing benchmark") {
             throw "just a plain literal, bleh";