[ADT] Align unique_function::CallImpl when using clang on Windows

[chandlerc]

Summary

This is a follow-up to r336178.

This would be one way of working around the alignment problem.

Actually, it would be enough to just check for clang here, because even at -Os we will not emit functions with less than 4-byte alignment.

It's not very pretty though. Is this class performance sensitive enough that it's worth the complexity of packing flags into the function pointer, or could we trade size for simplicity and just store the flags in another byte?

[hans]

Trying not to get the #ifdefs backwards..

[chandlerc]

Sorry I didn't update this, but went with just completely nuking this as it didn't seem that reliable even with Clang.

include/llvm/ADT/FunctionExtras.h

class unique_function<ReturnT(ParamTs...)> {
   size_t getOutOfLineStorageAlignment() const {
     return StorageUnion.OutOfLineStorage.Alignment;
   }
 
   void setOutOfLineStorage(void *Ptr, size_t Size, size_t Alignment) {
     StorageUnion.OutOfLineStorage = {Ptr, Size, Alignment};
   }
 
+#if defined(_MSC_VER) && defined(__clang__)
+  // The MS ABI does not align functions, but clang can do it.
+#define ALIGNED __attribute__((aligned(16)))
+#else
+#define ALIGNED
+#endif
   template <typename CallableT>
   static ReturnT CallImpl(void *CallableAddr,
-                          AdjustedParamT<ParamTs>... Params) {
+                          AdjustedParamT<ParamTs>... Params) ALIGNED {
     return (*reinterpret_cast<CallableT *>(CallableAddr))(
         std::forward<ParamTs>(Params)...);
   }
+#undef ALIGNED
 
   template <typename CallableT>
   static void MoveImpl(void *LHSCallableAddr, void *RHSCallableAddr) noexcept {
     new (LHSCallableAddr)
         CallableT(std::move(*reinterpret_cast<CallableT *>(RHSCallableAddr)));
   }
 
   template <typename CallableT>
if (sizeof(CallableT) > InlineStorageSize ||
       auto Alignment = alignof(CallableT);
       CallableAddr = allocate_buffer(Size, Alignment);
       setOutOfLineStorage(CallableAddr, Size, Alignment);
     }
 
     // Now move into the storage.
     new (CallableAddr) CallableT(std::move(Callable));
 
-#ifndef _MSC_VER
+#if !defined(_MSC_VER) || defined(__clang__)
     // See if we can create a trivial callback.
     //
     // This requires two things. First, we need to put a function pointer into
     // a `PointerIntPair` and a `PointerUnion`. We assume that function
     // pointers on almost every platform have at least 4-byte alignment which
     // allows this to work, but on some platforms this appears to not hold, and
     // so we need to disable this optimization on those platforms.
     //
-    // FIXME: Currently, Windows appears to fail the asserts that check this.
-    // We should investigate why, and if fixed removed the #ifndef above.
-    //
     // Second, we need the callable to be trivially moved and trivially
     // destroyed so that we don't have to store type erased callbacks for those
     // operations.
     //
     // FIXME: We should use constexpr if here and below to avoid instantiating
     // the non-trivial static objects when unnecessary. While the linker should
     // remove them, it is still wasteful.
     if (llvm::is_trivially_move_constructible<CallableT>::value &&