ubsan: Unbreak ubsan_cxx runtime library on Windows.

[pcc]

Summary

This was originally broken by r258744 which introduced a weak reference
from ubsan to ubsan_cxx, which of course does not work directly on
Windows. The fix is to use /alternatename to create a weak external
reference to ubsan_cxx.

Also fix the definition (and the name, so that we drop cached values)
of the cmake flag that controls whether to build ubsan_cxx. Now the
user-controllable flag is always on, and we turn it off internally
depending on whether we support building it.

[rnk]

compiler-rt/CMakeLists.txt

94

Is it correct to add OR MSVC to this list, so that the tests requiring cxxabi won't run on Windows?

compiler-rt/lib/ubsan/ubsan_handlers.cc

667–669

Weak functions strike again.

[pcc]

compiler-rt/CMakeLists.txt

94

The whole point of this change is to make it so that the cxxabi tests do run on Windows :)

Some of the tests use -fsanitize=vptr, which is disabled on Windows because it depends on a working implementation of __ubsan::checkDynamicType, which is not implemented on Windows. However -fsanitize=cfi only uses __ubsan::getDynamicTypeInfoFromVtable which has a Windows implementation.

[rnk]

lgtm

compiler-rt/CMakeLists.txt

94

I think I misread this: "ubsan_cxx, which of course does not work directly on
Windows" as saying that ubsan_cxx doesn't work on Windows. That's my mistake, the whole point of this change is to make it work better.

[pcc]

compiler-rt/CMakeLists.txt

94

Yeah, sorry, I'll reword the commit message.

[fjricci]

Looks like this change changes the user-visible configuration option for cxxabi from SANITIZER_CAN_USE_CXXABI to SANITIZER_ALLOW_CXXABI. Was this intentional/useful? It's not necessarily problematic, but it does cause some annoyances related to maintaining separate build options across compiler-rt branches (5.0 requires SANITIZER_CAN_USE_CXXABI and will not respect SANITIZER_ALLOW_CXXABI, and vice-versa for master/6.0).

compiler-rt/CMakeLists.txt

 option(COMPILER_RT_EXTERNALIZE_DEBUGINFO
   "Generate dSYM files and strip executables and libraries (Darwin Only)" OFF)
 # COMPILER_RT_DEBUG_PYBOOL is used by lit.common.configured.in.
 pythonize_bool(COMPILER_RT_DEBUG)
 
 include(HandleCompilerRT)
 include(config-ix)
 
 if(APPLE AND SANITIZER_MIN_OSX_VERSION AND SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.9")
   # Mac OS X prior to 10.9 had problems with exporting symbols from
   # libc++/libc++abi.
-  set(use_cxxabi_default OFF)
-elseif(MSVC)
-  set(use_cxxabi_default OFF)
+  set(cxxabi_supported OFF)
 else()
-  set(use_cxxabi_default ON)
+  set(cxxabi_supported ON)
 endif()
 
-option(SANITIZER_CAN_USE_CXXABI "Sanitizers can use cxxabi" ${use_cxxabi_default})
+option(SANITIZER_ALLOW_CXXABI "Allow use of C++ ABI details in ubsan" ON)
+
+set(SANITIZE_CAN_USE_CXXABI OFF)
+if (cxxabi_supported AND SANITIZER_ALLOW_CXXABI)
+  set(SANITIZER_CAN_USE_CXXABI ON)
+endif()
 pythonize_bool(SANITIZER_CAN_USE_CXXABI)
 
 set(SANITIZER_CXX_ABI "default" CACHE STRING
     "Specify C++ ABI library to use.")
 set(CXXABIS none default libcxxabi libstdc++ libc++)
 set_property(CACHE SANITIZER_CXX_ABI PROPERTY STRINGS ;${CXXABIS})
 
 if (SANITIZER_CXX_ABI STREQUAL "default")

compiler-rt/lib/ubsan/ubsan_handlers.h

struct CFICheckFailData {
   CFITypeCheckKind CheckKind;
   SourceLocation Loc;
   const TypeDescriptor &Type;
 };
 
 /// \brief Handle control flow integrity failures.
 RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function,
             uptr VtableIsValid)
+
+struct ReportOptions;
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __ubsan_handle_cfi_bad_type(
+    CFICheckFailData *Data, ValueHandle Vtable, bool ValidVtable,
+    ReportOptions Opts);
+
 }
 
 #endif // UBSAN_HANDLERS_H

compiler-rt/lib/ubsan/ubsan_handlers.cc

static void handleCFIBadIcall(CFICheckFailData *Data, ValueHandle Function,
   SymbolizedStackHolder FLoc(getSymbolizedLocation(Function));
   const char *FName = FLoc.get()->info.function;
   if (!FName)
     FName = "(unknown)";
   Diag(FLoc, DL_Note, "%0 defined here") << FName;
 }
 
 namespace __ubsan {
+
 #ifdef UBSAN_CAN_USE_CXXABI
+
+#ifdef _WIN32
+
+extern "C" void __ubsan_handle_cfi_bad_type_default(CFICheckFailData *Data,
+                                                    ValueHandle Vtable,
+                                                    bool ValidVtable,
+                                                    ReportOptions Opts) {
+  Die();
+}
+
+WIN_WEAK_ALIAS(__ubsan_handle_cfi_bad_type, __ubsan_handle_cfi_bad_type_default)
+#else
 SANITIZER_WEAK_ATTRIBUTE
-void HandleCFIBadType(CFICheckFailData *Data, ValueHandle Vtable,
+#endif
+void __ubsan_handle_cfi_bad_type(CFICheckFailData *Data, ValueHandle Vtable,
                                  bool ValidVtable, ReportOptions Opts);
+
 #else
-static void HandleCFIBadType(CFICheckFailData *Data, ValueHandle Vtable,
+static void __ubsan_handle_cfi_bad_type(CFICheckFailData *Data,
+                                        ValueHandle Vtable,
                                         bool ValidVtable, ReportOptions Opts) {
   Die();
 }
 #endif
+
 }  // namespace __ubsan
 
 void __ubsan::__ubsan_handle_cfi_check_fail(CFICheckFailData *Data,
                                             ValueHandle Value,
                                             uptr ValidVtable) {
   GET_REPORT_OPTIONS(false);
   if (Data->CheckKind == CFITCK_ICall)
     handleCFIBadIcall(Data, Value, Opts);
   else
-    HandleCFIBadType(Data, Value, ValidVtable, Opts);
+    __ubsan_handle_cfi_bad_type(Data, Value, ValidVtable, Opts);
 }
 
 void __ubsan::__ubsan_handle_cfi_check_fail_abort(CFICheckFailData *Data,
                                                   ValueHandle Value,
                                                   uptr ValidVtable) {
   GET_REPORT_OPTIONS(true);
   if (Data->CheckKind == CFITCK_ICall)
     handleCFIBadIcall(Data, Value, Opts);
   else
-    HandleCFIBadType(Data, Value, ValidVtable, Opts);
+    __ubsan_handle_cfi_bad_type(Data, Value, ValidVtable, Opts);
   Die();
 }
 
 #endif  // CAN_SANITIZE_UB

compiler-rt/lib/ubsan/ubsan_handlers_cxx.cc

void __ubsan::__ubsan_handle_dynamic_type_cache_miss_abort(
     DynamicTypeCacheMissData *Data, ValueHandle Pointer, ValueHandle Hash) {
   // Note: -fsanitize=vptr is always recoverable.
   GET_REPORT_OPTIONS(false);
   if (HandleDynamicTypeCacheMiss(Data, Pointer, Hash, Opts))
     Die();
 }
 
 namespace __ubsan {
-void HandleCFIBadType(CFICheckFailData *Data, ValueHandle Vtable,
+void __ubsan_handle_cfi_bad_type(CFICheckFailData *Data, ValueHandle Vtable,
                                  bool ValidVtable, ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   ErrorType ET = ErrorType::CFIBadType;
 
   if (ignoreReport(Loc, Opts, ET))
     return;
 
   ScopedReport R(Opts, Loc, ET);
   DynamicTypeInfo DTI = ValidVtable

compiler-rt/test/cfi/target_uninstrumented.cpp

 // RUN: %clangxx -g -DSHARED_LIB %s -fPIC -shared -o %T/target_uninstrumented-so.so
 // RUN: %clangxx_cfi_diag -g %s -o %t %T/target_uninstrumented-so.so
 // RUN: %t 2>&1 | FileCheck %s
 
 // REQUIRES: cxxabi
+// UNSUPPORTED: win32
 
 #include <stdio.h>
 #include <string.h>
 
 struct A {
   virtual void f();
 };
 

compiler-rt/test/ubsan/TestCases/TypeCheck/PR33221.cpp

 // RUN: %clangxx -frtti -fsanitize=null,vptr -g %s -O3 -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: cxxabi
+// UNSUPPORTED: win32
 
 #include <string.h>
 
 class Base {
 public:
   int i;
   virtual void print() {}
 };

compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-non-unique-typeinfo.cpp

 // RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr -I%p/Helpers -g %s -fPIC -shared -o %t-lib.so -DBUILD_SO
 // RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr -I%p/Helpers -g %s -O3 -o %t %t-lib.so
 // RUN: %run %t
 //
 // REQUIRES: cxxabi
+// UNSUPPORTED: win32
 
 struct X {
   virtual ~X() {}
 };
 X *libCall();
 
 #ifdef BUILD_SO
 

compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base-construction.cpp

 // RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr %s -o %t
 // RUN: %run %t
 
 // REQUIRES: cxxabi
+// UNSUPPORTED: win32
 
 int volatile n;
 
 struct A { virtual ~A() {} };
 struct B: virtual A {};
 struct C: virtual A { ~C() { n = 0; } };
 struct D: virtual B, virtual C {};
 
 int main() { delete new D; }

compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base.cpp

 // RUN: %clangxx -frtti -fsanitize=null,vptr -fno-sanitize-recover=vptr -g %s -O3 -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: cxxabi
+// UNSUPPORTED: win32
 
 struct S { virtual int f() { return 0; } };
 struct T : virtual S {};
 
 struct Foo { virtual int f() { return 0; } };
 
 int main(int argc, char **argv) {
   Foo foo;
   T *t = (T*)&foo;
   S *s = t;
   // CHECK: vptr-virtual-base.cpp:[[@LINE-1]]:10: runtime error: cast to virtual base of address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'T'
   // CHECK-NEXT: [[PTR]]: note: object is of type 'Foo'
   return s->f();
 }

compiler-rt/test/ubsan/TestCases/TypeCheck/vptr.cpp

 // RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t fV
 // RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t cV
 // RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t oU
 
 // RUN: echo "vptr_check:S" > %t.loc-supp
 // RUN: %env_ubsan_opts=suppressions='"%t.loc-supp"' not %run %t x- 2>&1 | FileCheck %s --check-prefix=CHECK-LOC-SUPPRESS
 
 // REQUIRES: stable-runtime, cxxabi
+// UNSUPPORTED: win32
 #include <new>
 #include <assert.h>
 #include <stdio.h>
 
 struct S {
   S() : a(0) {}
   ~S() {}
   int a;