mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 19:23:23 +01:00
b0d2e62867
First, use the old style of linker initialization for MSVC 2019 in addition to 2017. MSVC 2019 emits a dynamic initializer for ManagedStatic when compiled in debug mode, and according to zturner, also sometimes in release mode. I wasn't able to reproduce that, but it seems best to stick with the old code that works. When clang is using the MSVC STL, we have to give ManagedStatic a constexpr constructor that fully zero initializes all fields, otherwise it emits a dynamic initializer. The MSVC STL implementation of std::atomic has a non-trivial (but constexpr) default constructor that zero initializes the atomic value. Because one of the fields has a non-trivial constructor, ManagedStatic ends up with a non-trivial ctor. The ctor is not constexpr, so clang ends up emitting a dynamic initializer, even though it simply does zero initialization. To make it constexpr, we must initialize all fields of the ManagedStatic. However, while the constructor that takes a pointer is marked constexpr, clang says it does not evaluate to a constant because it contains a cast from a pointer to an integer. I filed this as: https://developercommunity.visualstudio.com/content/problem/545566/stdatomic-value-constructor-is-not-actually-conste.html Once we do that, we can add back the LLVM_REQUIRE_CONSTANT_INITIALIZATION marker, and so far as I'm aware it compiles successfully on all supported targets. llvm-svn: 359135
120 lines
3.9 KiB
C++
120 lines
3.9 KiB
C++
//===-- llvm/Support/ManagedStatic.h - Static Global wrapper ----*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the ManagedStatic class and the llvm_shutdown() function.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_SUPPORT_MANAGEDSTATIC_H
|
|
#define LLVM_SUPPORT_MANAGEDSTATIC_H
|
|
|
|
#include <atomic>
|
|
#include <cstddef>
|
|
|
|
namespace llvm {
|
|
|
|
/// object_creator - Helper method for ManagedStatic.
|
|
template <class C> struct object_creator {
|
|
static void *call() { return new C(); }
|
|
};
|
|
|
|
/// object_deleter - Helper method for ManagedStatic.
|
|
///
|
|
template <typename T> struct object_deleter {
|
|
static void call(void *Ptr) { delete (T *)Ptr; }
|
|
};
|
|
template <typename T, size_t N> struct object_deleter<T[N]> {
|
|
static void call(void *Ptr) { delete[](T *)Ptr; }
|
|
};
|
|
|
|
// ManagedStatic must be initialized to zero, and it must *not* have a dynamic
|
|
// initializer because managed statics are often created while running other
|
|
// dynamic initializers. In standard C++11, the best way to accomplish this is
|
|
// with a constexpr default constructor. However, different versions of the
|
|
// Visual C++ compiler have had bugs where, even though the constructor may be
|
|
// constexpr, a dynamic initializer may be emitted depending on optimization
|
|
// settings. For the affected versions of MSVC, use the old linker
|
|
// initialization pattern of not providing a constructor and leaving the fields
|
|
// uninitialized.
|
|
#if !defined(_MSC_VER) || defined(__clang__)
|
|
#define LLVM_USE_CONSTEXPR_CTOR
|
|
#endif
|
|
|
|
/// ManagedStaticBase - Common base class for ManagedStatic instances.
|
|
class ManagedStaticBase {
|
|
protected:
|
|
#ifdef LLVM_USE_CONSTEXPR_CTOR
|
|
mutable std::atomic<void *> Ptr{};
|
|
mutable void (*DeleterFn)(void *) = nullptr;
|
|
mutable const ManagedStaticBase *Next = nullptr;
|
|
#else
|
|
// This should only be used as a static variable, which guarantees that this
|
|
// will be zero initialized.
|
|
mutable std::atomic<void *> Ptr;
|
|
mutable void (*DeleterFn)(void *);
|
|
mutable const ManagedStaticBase *Next;
|
|
#endif
|
|
|
|
void RegisterManagedStatic(void *(*creator)(), void (*deleter)(void*)) const;
|
|
|
|
public:
|
|
#ifdef LLVM_USE_CONSTEXPR_CTOR
|
|
constexpr ManagedStaticBase() = default;
|
|
#endif
|
|
|
|
/// isConstructed - Return true if this object has not been created yet.
|
|
bool isConstructed() const { return Ptr != nullptr; }
|
|
|
|
void destroy() const;
|
|
};
|
|
|
|
/// ManagedStatic - This transparently changes the behavior of global statics to
|
|
/// be lazily constructed on demand (good for reducing startup times of dynamic
|
|
/// libraries that link in LLVM components) and for making destruction be
|
|
/// explicit through the llvm_shutdown() function call.
|
|
///
|
|
template <class C, class Creator = object_creator<C>,
|
|
class Deleter = object_deleter<C>>
|
|
class ManagedStatic : public ManagedStaticBase {
|
|
public:
|
|
// Accessors.
|
|
C &operator*() {
|
|
void *Tmp = Ptr.load(std::memory_order_acquire);
|
|
if (!Tmp)
|
|
RegisterManagedStatic(Creator::call, Deleter::call);
|
|
|
|
return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
|
|
}
|
|
|
|
C *operator->() { return &**this; }
|
|
|
|
const C &operator*() const {
|
|
void *Tmp = Ptr.load(std::memory_order_acquire);
|
|
if (!Tmp)
|
|
RegisterManagedStatic(Creator::call, Deleter::call);
|
|
|
|
return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
|
|
}
|
|
|
|
const C *operator->() const { return &**this; }
|
|
};
|
|
|
|
/// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
|
|
void llvm_shutdown();
|
|
|
|
/// llvm_shutdown_obj - This is a simple helper class that calls
|
|
/// llvm_shutdown() when it is destroyed.
|
|
struct llvm_shutdown_obj {
|
|
llvm_shutdown_obj() = default;
|
|
~llvm_shutdown_obj() { llvm_shutdown(); }
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif // LLVM_SUPPORT_MANAGEDSTATIC_H
|