Run the integration tests against the Clang instrumented DLL.

syzygy/integration_tests/asan_interceptors_tests.h

 // 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 13 matching lines @@
 namespace testing {
 
 // Disable the intrinsic versions of the intercepted functions.
 #pragma function(memset, memcpy, strlen, strcmp)
 
 // Helper function to make sure that a memory read access doesn't get
 // instrumented.
 // @tparam type The type of the value to be read.
 // @param location The location where to read from.
 // @returns the value at |location|
-template<typename type>
+template <typename type>
+#if defined(__clang__)
+type __attribute__((no_sanitize_address)) NonInterceptedRead(type* location) {
+#else
 type NonInterceptedRead(type* location) {
+#endif
   // The try-except statement prevents the function from being instrumented.
   __try {
     return *location;

[chrisha, 2017/08/30 16:55:32]

You don't need the try/except for the Clang version. The body of the function
could be simpler in this case. (Like you did with the NonInterceptedWrite
function.)

   } __except(EXCEPTION_CONTINUE_SEARCH) {
     // Nothing to do here.
   }
   return static_cast<type>(0);
 }
 
 // Helper function to do non instrumented reads from an array.
 // @tparam type The type of the values to be read.
 // @param src The array where to read from.
 // @param size The size of the array.
 // @param dst The destination array.
 template<typename type>
 void NonInterceptedReads(type* src, size_t size, type* dst) {
   for (size_t i = 0; i < size; ++i)
     *dst++ = NonInterceptedRead(src + i);
 }
 
 // Helper function to make sure that a memory write access didn't get
 // instrumented.
 // @tparam type The type of the value to be written.
 // @param location The location where to write to.
 // @param val The value to write.
-template<typename type>
+template <typename type>
+#if defined(__clang__)
+void __attribute__((no_sanitize_address))
+NonInterceptedWrite(type* location, type val) {
+  *location = val;
+}
+#else
 void NonInterceptedWrite(type* location, type val) {
   // The try-except statement prevents the function from being instrumented.
   __try {
     *location = val;
   } __except(EXCEPTION_CONTINUE_SEARCH) {
     // Nothing to do here.
   }
 }
+#endif
 
 // Helper function to do non instrumented writes from an array.
 // @tparam type The type of the values to be written.
 // @param src The array where to read from.
 // @param size The size of the array.
 // @param dst The address where to write to.
 template<typename type>
 void NonInterceptedWrites(type* src, size_t size, type* dst) {
   for (size_t i = 0; i < size; ++i)
     NonInterceptedWrite(dst++, src[i]);
@@ skipping 380 matching lines @@
 // "uninstrumented" tests will cause an access violation exception to be thrown.
 size_t AsanNearNullptrAccessHeapCorruptionInstrumented();
 size_t AsanNearNullptrAccessHeapCorruptionUninstrumented();
 size_t AsanNearNullptrAccessNoHeapCorruptionInstrumented();
 size_t AsanNearNullptrAccessNoHeapCorruptionUninstrumented();
 size_t AsanNullptrAccessNoHeapCorruptionUninstrumented();
 
 }  // namespace testing
 
 #endif  // SYZYGY_INTEGRATION_TESTS_ASAN_INTERCEPTORS_TESTS_H_