Run the integration tests against the Clang instrumented DLL.

syzygy/integration_tests/instrument_integration_test.cc

 // Copyright 2013 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 1295 matching lines @@
 // Class created to enable parametrization of the tests with Clang.
 // Currently only Syzygy is supported but will be extended to work with CLANG.
 // Right now it just forwards the calls to the parent class.
 class ParametrizedLenientInstrumentAppIntegrationTest
     : public LenientInstrumentAppIntegrationTest,
       public ::testing::WithParamInterface<InstrumentationMode> {
  public:
   void EndToEndTest(const std::string& mode) override {
     if (GetParam() == SYZYGY) {
       LenientInstrumentAppIntegrationTest::EndToEndTest(mode);
+    } else if (GetParam() == CLANG) {
+      test_dll_path_ =
+          testing::GetExeRelativePath(testing::kIntegrationTestsClangDllName);
+      // Validates that the test dll loads post instrumentation.
+      ASSERT_NO_FATAL_FAILURE(LoadTestDll(test_dll_path_, &module_));
     }
   }
 
   void EndToEndCheckTestDll() override {
     if (GetParam() == SYZYGY) {
       LenientInstrumentAppIntegrationTest::EndToEndCheckTestDll();
     }
   }
 };
 
@@ skipping 126 matching lines @@
   // Disable the heap checking as this is implies touching all the shadow bytes
   // and this make those tests really slow.
   AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
                        "--no_check_heap_on_failure");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(CheckTestDllImportsRedirected());
 }
 
-TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanEndToEndNoLiveness) {
-  // Disable the heap checking as this is implies touching all the shadow bytes
-  // and this make those tests really slow.
-  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
-                       "--no_check_heap_on_failure");
-  cmd_line_.AppendSwitch("no-liveness-analysis");
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
-  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
-}
-
-TEST_P(ParametrizedInstrumentAppIntegrationTest,
-       AsanEndToEndNoRedundancyAnalysis) {
-  // Disable the heap checking as this is implies touching all the shadow bytes
-  // and this make those tests really slow.
-  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
-                       "--no_check_heap_on_failure");
-  cmd_line_.AppendSwitch("no-redundancy-analysis");
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
-  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
-}
-
-TEST_P(ParametrizedInstrumentAppIntegrationTest,
-       AsanEndToEndNoFunctionInterceptors) {
-  // Disable the heap checking as this is implies touching all the shadow bytes
-  // and this make those tests really slow.
-  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
-                       "--no_check_heap_on_failure");
-  cmd_line_.AppendSwitch("no-interceptors");
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
-  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
-}
-
 TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanEndToEndWithRtlOptions) {
-  cmd_line_.AppendSwitchASCII(
-      common::kAsanRtlOptions,
+  AddEnvironmentChange(
+      ::common::kSyzyAsanOptionsEnvVar,
       "--quarantine_size=20000000 --quarantine_block_size=1000000 "
       "--no_check_heap_on_failure");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
 
   // Get the active runtime and validate its parameters.
   agent::asan::AsanRuntime* runtime = GetActiveAsanRuntime();
   ASSERT_TRUE(runtime != NULL);
   ASSERT_EQ(20000000u, runtime->params().quarantine_size);
   ASSERT_EQ(1000000u, runtime->params().quarantine_block_size);
 }
 
 TEST_P(ParametrizedInstrumentAppIntegrationTest,
-       AsanEndToEndWithRtlOptionsOverrideWithEnvironment) {
-  std::unique_ptr<base::Environment> env(base::Environment::Create());
-  ASSERT_NE(env.get(), nullptr);
-  env->SetVar(::common::kSyzyAsanOptionsEnvVar,
-              "--quarantine_block_size=800000 --ignored_stack_ids=0x1 "
-              "--no_check_heap_on_failure");
-  cmd_line_.AppendSwitchASCII(
-      common::kAsanRtlOptions,
-      "--quarantine_size=20000000 --quarantine_block_size=1000000 "
-      "--ignored_stack_ids=0x2");
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
-  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
-
-  // Get the active runtime and validate its parameters.
-  agent::asan::AsanRuntime* runtime = GetActiveAsanRuntime();
-  ASSERT_TRUE(runtime != NULL);
-  ASSERT_EQ(20000000u, runtime->params().quarantine_size);
-  ASSERT_EQ(800000u, runtime->params().quarantine_block_size);
-  ASSERT_THAT(runtime->params().ignored_stack_ids_set,
-              testing::ElementsAre(0x1, 0x2));
-
-  env->UnSetVar(::common::kSyzyAsanOptionsEnvVar);
-}
-
-TEST_P(ParametrizedInstrumentAppIntegrationTest, FullOptimizedAsanEndToEnd) {
-  // Disable the heap checking as this implies touching all the shadow bytes
-  // and this make these tests really slow.
-  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
-                       "--no_check_heap_on_failure");
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
-  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
-  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckInterceptedFunctions());
-}
-
-TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanInvalidAccessWithCorruptAllocatedBlockHeader) {
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanInvalidAccessWithCorruptAllocatedBlockHeader, true,
       kAsanCorruptHeap, NULL);
 }
 
 TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanOverflowCallsCrashForException) {
   // Asan-detected violations go through CrashForException if it is available.
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
@@ skipping 25 matching lines @@
        AsanCorruptBlockWithPageProtections) {
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanCorruptBlockWithPageProtections, true,
       kAsanHeapUseAfterFree, kAsanCorruptHeap);
 }
 
 TEST_P(ParametrizedInstrumentAppIntegrationTest,
        SampledAllocationsAsanEndToEnd) {
-  cmd_line_.AppendSwitchASCII("asan-rtl-options",
-                              "--allocation_guard_rate=0.5 "
-                              "--no_check_heap_on_failure");
+  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
+                       "--allocation_guard_rate=0.5 "
+                       "--no_check_heap_on_failure");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckSampledAllocations());
 }
 
 TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanLargeBlockHeapEnabledTest) {
-  cmd_line_.AppendSwitchASCII("asan-rtl-options",
-                              "--no_check_heap_on_failure "
-                              "--quarantine_size=4000000 "
-                              "--quarantine_block_size=2000000");
+  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
+                       "--no_check_heap_on_failure "
+                       "--quarantine_size=4000000 "
+                       "--quarantine_block_size=2000000");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanLargeBlockHeapTests(true));
 }
 
 TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanLargeBlockHeapDisabledTest) {
-  cmd_line_.AppendSwitchASCII("asan-rtl-options",
-                              "--no_check_heap_on_failure "
-                              "--disable_large_block_heap");
+  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
+                       "--no_check_heap_on_failure "
+                       "--disable_large_block_heap");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanLargeBlockHeapTests(false));
 }
 
-TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanZebraHeapDisabledTest) {
-  AsanZebraHeapTest(false);
-}
-
-TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanZebraHeapEnabledTest) {
-  AsanZebraHeapTest(true);
-}
-
 TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanSymbolizerTestAsanBufferOverflow) {
   AsanSymbolizerTest(testing::kAsanRead8BufferOverflow,
                      STRINGIFY(HEAP_BUFFER_OVERFLOW),
                      STRINGIFY(ASAN_READ_ACCESS),
                      1,
                      false);
 }
 
 TEST_P(ParametrizedInstrumentAppIntegrationTest,
@@ skipping 16 matching lines @@
 
 TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanSymbolizerTestAsanCorruptBlock) {
   AsanSymbolizerTest(testing::kAsanCorruptBlock,
                      STRINGIFY(CORRUPT_BLOCK),
                      STRINGIFY(ASAN_UNKNOWN_ACCESS),
                      0,
                      false);
 }
 
-TEST_P(ParametrizedInstrumentAppIntegrationTest,
-       AsanSymbolizerTestAsanCorruptBlockInQuarantine) {
-  AsanSymbolizerTest(testing::kAsanCorruptBlockInQuarantine,
-                     STRINGIFY(CORRUPT_BLOCK),
-                     STRINGIFY(ASAN_UNKNOWN_ACCESS),
-                     0,
-                     true);
-}
-
 // These tests require corrupt heap checking to be enabled.
 TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanNearNullptrAccess) {
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
 
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNearNullptrAccessHeapCorruptionInstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessHeapCorruption);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNearNullptrAccessHeapCorruptionUninstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessHeapCorruption);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNearNullptrAccessNoHeapCorruptionInstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessNoHeapCorruption);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNearNullptrAccessNoHeapCorruptionUninstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessNoHeapCorruption);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNullptrAccessNoHeapCorruptionUninstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessNoHeapCorruption);
 }
 
-// Instantiate the test cases only with SYZYGY until some problems are fixed.
 INSTANTIATE_TEST_CASE_P(InstantiationName,
                         ParametrizedInstrumentAppIntegrationTest,
-                        testing::Values(SYZYGY));
+                        testing::Values(SYZYGY, CLANG));
+
+TEST_F(InstrumentAppIntegrationTest, AsanEndToEndNoLiveness) {
+  // Disable the heap checking as this is implies touching all the shadow bytes
+  // and this make those tests really slow.
+  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
+                       "--no_check_heap_on_failure");
+  cmd_line_.AppendSwitch("no-liveness-analysis");
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
+}
+
+TEST_F(InstrumentAppIntegrationTest, AsanEndToEndNoRedundancyAnalysis) {
+  // Disable the heap checking as this is implies touching all the shadow bytes
+  // and this make those tests really slow.
+  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
+                       "--no_check_heap_on_failure");
+  cmd_line_.AppendSwitch("no-redundancy-analysis");
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
+}
+
+TEST_F(InstrumentAppIntegrationTest, AsanEndToEndNoFunctionInterceptors) {
+  // Disable the heap checking as this is implies touching all the shadow bytes
+  // and this make those tests really slow.
+  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
+                       "--no_check_heap_on_failure");
+  cmd_line_.AppendSwitch("no-interceptors");
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
+}
+
+TEST_F(InstrumentAppIntegrationTest,
+       AsanEndToEndWithRtlOptionsOverrideWithEnvironment) {
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
+  ASSERT_NE(env.get(), nullptr);
+  env->SetVar(::common::kSyzyAsanOptionsEnvVar,
+              "--quarantine_block_size=800000 --ignored_stack_ids=0x1 "
+              "--no_check_heap_on_failure");
+  cmd_line_.AppendSwitchASCII(
+      common::kAsanRtlOptions,
+      "--quarantine_size=20000000 --quarantine_block_size=1000000 "
+      "--ignored_stack_ids=0x2");
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
+
+  // Get the active runtime and validate its parameters.
+  agent::asan::AsanRuntime* runtime = GetActiveAsanRuntime();
+  ASSERT_TRUE(runtime != NULL);
+  ASSERT_EQ(20000000u, runtime->params().quarantine_size);
+  ASSERT_EQ(800000u, runtime->params().quarantine_block_size);
+  ASSERT_THAT(runtime->params().ignored_stack_ids_set,
+              testing::ElementsAre(0x1, 0x2));
+
+  env->UnSetVar(::common::kSyzyAsanOptionsEnvVar);
+}
+
+TEST_F(InstrumentAppIntegrationTest, FullOptimizedAsanEndToEnd) {
+  // Disable the heap checking as this implies touching all the shadow bytes
+  // and this make these tests really slow.
+  AddEnvironmentChange(::common::kSyzyAsanOptionsEnvVar,
+                       "--no_check_heap_on_failure");
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(AsanErrorCheckInterceptedFunctions());
+}
+
+TEST_F(InstrumentAppIntegrationTest,
+       AsanSymbolizerTestAsanCorruptBlockInQuarantine) {
+  // This test requires the HeapCreate/HeapDestroy functions to be intercepted
+  // and thus doesn't work on a Clang instrumented binary.
+  AsanSymbolizerTest(testing::kAsanCorruptBlockInQuarantine,
+                     STRINGIFY(CORRUPT_BLOCK), STRINGIFY(ASAN_UNKNOWN_ACCESS),
+                     0, true);
+}
+
+TEST_F(InstrumentAppIntegrationTest, AsanZebraHeapDisabledTest) {
+  AsanZebraHeapTest(false);
+}
+
+TEST_F(InstrumentAppIntegrationTest, AsanZebraHeapEnabledTest) {
+  AsanZebraHeapTest(true);
+}
 
 TEST_F(InstrumentAppIntegrationTest, BBEntryEndToEnd) {
   ASSERT_NO_FATAL_FAILURE(StartService());
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("bbentry"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(BBEntryInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(BBEntryCheckTestDll());
 }
 
@@ skipping 89 matching lines @@
 
 TEST_F(InstrumentAppIntegrationTest, DeferredFreeTLS) {
   ASSERT_NO_FATAL_FAILURE(StartService());
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_EQ(0, InvokeTestDllFunction(testing::kAsanDeferredFreeTLS));
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
 }
 
 }  // namespace integration_tests