mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 19:52:54 +01:00
d7aa55c96c
CALL_ONCE_... macro in the legacy pass manager with the new llvm::call_once facility. Nothing changed sicne the last attempt in r271781 which I reverted in r271788. At least one of the failures I saw was spurious, and I want to make sure the other failures are real before I work around them -- they appeared to only effect ppc64le and ppc64be. Original commit message of r271781: ---- [LPM] Reinstate r271652 to replace the CALL_ONCE_... macro in the legacy pass manager with the new llvm::call_once facility. This reverts commit r271657 and re-applies r271652 with a fix to actually work with arguments. In the original version, we just ended up directly calling std::call_once via ADL because of the std::once_flag argument. The llvm::call_once never worked with arguments. Now, llvm::call_once is a variadic template that perfectly forwards everything. As a part of this it had to move to the header and we use a generic functor rather than an explict function pointer. It would be nice to use std::invoke here but we don't have it yet. That means pointer to members won't work here, but that seems a tolerable compromise. I've also tested this by forcing the fallback path, so hopefully it sticks this time. ---- Original commit message of r271652: ---- [LPM] Replace the CALL_ONCE_... macro in the legacy pass manager with the new llvm::call_once facility. This facility matches the standard APIs and when the platform supports it actually directly uses the standard provided functionality. This is both more efficient on some platforms and much more TSan friendly. The only remaining user of the cas_flag and home-rolled atomics is the fallback implementation of call_once. I have a patch that removes them entirely, but it needs a Windows patch to land first. This alone substantially cleans up the macros for the legacy pass manager, and should subsume some of the work Mehdi was doing to clear the path for TSan testing of ThinLTO, a really important step to have reliable upstream testing of ThinLTO in all forms. ---- llvm-svn: 271800
233 lines
12 KiB
C++
233 lines
12 KiB
C++
//===- llvm/PassSupport.h - Pass Support code -------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines stuff that is used to define and "use" Passes. This file
|
|
// is automatically #included by Pass.h, so:
|
|
//
|
|
// NO .CPP FILES SHOULD INCLUDE THIS FILE DIRECTLY
|
|
//
|
|
// Instead, #include Pass.h.
|
|
//
|
|
// This file defines Pass registration code and classes used for it.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_PASSSUPPORT_H
|
|
#define LLVM_PASSSUPPORT_H
|
|
|
|
#include "Pass.h"
|
|
#include "llvm/InitializePasses.h"
|
|
#include "llvm/PassInfo.h"
|
|
#include "llvm/PassRegistry.h"
|
|
#include "llvm/Support/Atomic.h"
|
|
#include "llvm/Support/Threading.h"
|
|
#include <functional>
|
|
|
|
namespace llvm {
|
|
|
|
class TargetMachine;
|
|
|
|
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis) \
|
|
static void *initialize##passName##PassOnce(PassRegistry &Registry) { \
|
|
PassInfo *PI = new PassInfo( \
|
|
name, arg, &passName::ID, \
|
|
PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis); \
|
|
Registry.registerPass(*PI, true); \
|
|
return PI; \
|
|
} \
|
|
LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag); \
|
|
void llvm::initialize##passName##Pass(PassRegistry &Registry) { \
|
|
llvm::call_once(Initialize##passName##PassFlag, \
|
|
initialize##passName##PassOnce, std::ref(Registry)); \
|
|
}
|
|
|
|
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis) \
|
|
static void *initialize##passName##PassOnce(PassRegistry &Registry) {
|
|
|
|
#define INITIALIZE_PASS_DEPENDENCY(depName) initialize##depName##Pass(Registry);
|
|
#define INITIALIZE_AG_DEPENDENCY(depName) \
|
|
initialize##depName##AnalysisGroup(Registry);
|
|
|
|
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis) \
|
|
PassInfo *PI = new PassInfo( \
|
|
name, arg, &passName::ID, \
|
|
PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis); \
|
|
Registry.registerPass(*PI, true); \
|
|
return PI; \
|
|
} \
|
|
LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag); \
|
|
void llvm::initialize##passName##Pass(PassRegistry &Registry) { \
|
|
llvm::call_once(Initialize##passName##PassFlag, \
|
|
initialize##passName##PassOnce, std::ref(Registry)); \
|
|
}
|
|
|
|
#define INITIALIZE_PASS_WITH_OPTIONS(PassName, Arg, Name, Cfg, Analysis) \
|
|
INITIALIZE_PASS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \
|
|
PassName::registerOptions(); \
|
|
INITIALIZE_PASS_END(PassName, Arg, Name, Cfg, Analysis)
|
|
|
|
#define INITIALIZE_PASS_WITH_OPTIONS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \
|
|
INITIALIZE_PASS_BEGIN(PassName, Arg, Name, Cfg, Analysis) \
|
|
PassName::registerOptions();
|
|
|
|
template <typename PassName> Pass *callDefaultCtor() { return new PassName(); }
|
|
|
|
template <typename PassName> Pass *callTargetMachineCtor(TargetMachine *TM) {
|
|
return new PassName(TM);
|
|
}
|
|
|
|
//===---------------------------------------------------------------------------
|
|
/// RegisterPass<t> template - This template class is used to notify the system
|
|
/// that a Pass is available for use, and registers it into the internal
|
|
/// database maintained by the PassManager. Unless this template is used, opt,
|
|
/// for example will not be able to see the pass and attempts to create the pass
|
|
/// will fail. This template is used in the follow manner (at global scope, in
|
|
/// your .cpp file):
|
|
///
|
|
/// static RegisterPass<YourPassClassName> tmp("passopt", "My Pass Name");
|
|
///
|
|
/// This statement will cause your pass to be created by calling the default
|
|
/// constructor exposed by the pass. If you have a different constructor that
|
|
/// must be called, create a global constructor function (which takes the
|
|
/// arguments you need and returns a Pass*) and register your pass like this:
|
|
///
|
|
/// static RegisterPass<PassClassName> tmp("passopt", "My Name");
|
|
///
|
|
template <typename passName> struct RegisterPass : public PassInfo {
|
|
// Register Pass using default constructor...
|
|
RegisterPass(const char *PassArg, const char *Name, bool CFGOnly = false,
|
|
bool is_analysis = false)
|
|
: PassInfo(Name, PassArg, &passName::ID,
|
|
PassInfo::NormalCtor_t(callDefaultCtor<passName>), CFGOnly,
|
|
is_analysis) {
|
|
PassRegistry::getPassRegistry()->registerPass(*this);
|
|
}
|
|
};
|
|
|
|
/// RegisterAnalysisGroup - Register a Pass as a member of an analysis _group_.
|
|
/// Analysis groups are used to define an interface (which need not derive from
|
|
/// Pass) that is required by passes to do their job. Analysis Groups differ
|
|
/// from normal analyses because any available implementation of the group will
|
|
/// be used if it is available.
|
|
///
|
|
/// If no analysis implementing the interface is available, a default
|
|
/// implementation is created and added. A pass registers itself as the default
|
|
/// implementation by specifying 'true' as the second template argument of this
|
|
/// class.
|
|
///
|
|
/// In addition to registering itself as an analysis group member, a pass must
|
|
/// register itself normally as well. Passes may be members of multiple groups
|
|
/// and may still be "required" specifically by name.
|
|
///
|
|
/// The actual interface may also be registered as well (by not specifying the
|
|
/// second template argument). The interface should be registered to associate
|
|
/// a nice name with the interface.
|
|
///
|
|
class RegisterAGBase : public PassInfo {
|
|
public:
|
|
RegisterAGBase(const char *Name, const void *InterfaceID,
|
|
const void *PassID = nullptr, bool isDefault = false);
|
|
};
|
|
|
|
template <typename Interface, bool Default = false>
|
|
struct RegisterAnalysisGroup : public RegisterAGBase {
|
|
explicit RegisterAnalysisGroup(PassInfo &RPB)
|
|
: RegisterAGBase(RPB.getPassName(), &Interface::ID, RPB.getTypeInfo(),
|
|
Default) {}
|
|
|
|
explicit RegisterAnalysisGroup(const char *Name)
|
|
: RegisterAGBase(Name, &Interface::ID) {}
|
|
};
|
|
|
|
#define INITIALIZE_ANALYSIS_GROUP(agName, name, defaultPass) \
|
|
static void *initialize##agName##AnalysisGroupOnce(PassRegistry &Registry) { \
|
|
initialize##defaultPass##Pass(Registry); \
|
|
PassInfo *AI = new PassInfo(name, &agName::ID); \
|
|
Registry.registerAnalysisGroup(&agName::ID, 0, *AI, false, true); \
|
|
return AI; \
|
|
} \
|
|
LLVM_DEFINE_ONCE_FLAG(Initialize##agName##AnalysisGroupFlag); \
|
|
void llvm::initialize##agName##AnalysisGroup(PassRegistry &Registry) { \
|
|
llvm::call_once(Initialize##agName##AnalysisGroupFlag, \
|
|
initialize##agName##AnalysisGroupOnce, \
|
|
std::ref(Registry)); \
|
|
}
|
|
|
|
#define INITIALIZE_AG_PASS(passName, agName, arg, name, cfg, analysis, def) \
|
|
static void *initialize##passName##PassOnce(PassRegistry &Registry) { \
|
|
if (!def) \
|
|
initialize##agName##AnalysisGroup(Registry); \
|
|
PassInfo *PI = new PassInfo( \
|
|
name, arg, &passName::ID, \
|
|
PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis); \
|
|
Registry.registerPass(*PI, true); \
|
|
\
|
|
PassInfo *AI = new PassInfo(name, &agName::ID); \
|
|
Registry.registerAnalysisGroup(&agName::ID, &passName::ID, *AI, def, \
|
|
true); \
|
|
return AI; \
|
|
} \
|
|
LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag); \
|
|
void llvm::initialize##passName##Pass(PassRegistry &Registry) { \
|
|
llvm::call_once(Initialize##passName##PassFlag, \
|
|
initialize##passName##PassOnce, std::ref(Registry)); \
|
|
}
|
|
|
|
#define INITIALIZE_AG_PASS_BEGIN(passName, agName, arg, n, cfg, analysis, def) \
|
|
static void *initialize##passName##PassOnce(PassRegistry &Registry) { \
|
|
if (!def) \
|
|
initialize##agName##AnalysisGroup(Registry);
|
|
|
|
#define INITIALIZE_AG_PASS_END(passName, agName, arg, n, cfg, analysis, def) \
|
|
PassInfo *PI = new PassInfo( \
|
|
n, arg, &passName::ID, \
|
|
PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis); \
|
|
Registry.registerPass(*PI, true); \
|
|
\
|
|
PassInfo *AI = new PassInfo(n, &agName::ID); \
|
|
Registry.registerAnalysisGroup(&agName::ID, &passName::ID, *AI, def, true); \
|
|
return AI; \
|
|
} \
|
|
LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag); \
|
|
void llvm::initialize##passName##Pass(PassRegistry &Registry) { \
|
|
llvm::call_once(Initialize##passName##PassFlag, \
|
|
initialize##passName##PassOnce, std::ref(Registry)); \
|
|
}
|
|
|
|
//===---------------------------------------------------------------------------
|
|
/// PassRegistrationListener class - This class is meant to be derived from by
|
|
/// clients that are interested in which passes get registered and unregistered
|
|
/// at runtime (which can be because of the RegisterPass constructors being run
|
|
/// as the program starts up, or may be because a shared object just got
|
|
/// loaded).
|
|
///
|
|
struct PassRegistrationListener {
|
|
PassRegistrationListener() {}
|
|
virtual ~PassRegistrationListener() {}
|
|
|
|
/// Callback functions - These functions are invoked whenever a pass is loaded
|
|
/// or removed from the current executable.
|
|
///
|
|
virtual void passRegistered(const PassInfo *) {}
|
|
|
|
/// enumeratePasses - Iterate over the registered passes, calling the
|
|
/// passEnumerate callback on each PassInfo object.
|
|
///
|
|
void enumeratePasses();
|
|
|
|
/// passEnumerate - Callback function invoked when someone calls
|
|
/// enumeratePasses on this PassRegistrationListener object.
|
|
///
|
|
virtual void passEnumerate(const PassInfo *) {}
|
|
};
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|