Update prebuilt Clang to r416183b from Android.
https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef
clang 12.0.5 (based on r416183b) from build 7284624.
Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/llvm/IR/PassInstrumentation.h b/linux-x64/clang/include/llvm/IR/PassInstrumentation.h
index f8a1196..291f324 100644
--- a/linux-x64/clang/include/llvm/IR/PassInstrumentation.h
+++ b/linux-x64/clang/include/llvm/IR/PassInstrumentation.h
@@ -44,10 +44,6 @@
/// of a pass. For those callbacks returning false means pass will not be
/// executed.
///
-/// TODO: currently there is no way for a pass to opt-out of execution control
-/// (e.g. become unskippable). PassManager is the only entity that determines
-/// how pass instrumentation affects pass execution.
-///
//===----------------------------------------------------------------------===//
#ifndef LLVM_IR_PASSINSTRUMENTATION_H
@@ -56,12 +52,13 @@
#include "llvm/ADT/Any.h"
#include "llvm/ADT/FunctionExtras.h"
#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/TypeName.h"
+#include "llvm/ADT/StringMap.h"
#include <type_traits>
namespace llvm {
class PreservedAnalyses;
+class StringRef;
/// This class manages callbacks registration, as well as provides a way for
/// PassInstrumentation to pass control to the registered callbacks.
@@ -71,13 +68,17 @@
// to take them as constant pointers, wrapped with llvm::Any.
// For the case when IRUnit has been invalidated there is a different
// callback to use - AfterPassInvalidated.
+ // We call all BeforePassFuncs to determine if a pass should run or not.
+ // BeforeNonSkippedPassFuncs are called only if the pass should run.
// TODO: currently AfterPassInvalidated does not accept IRUnit, since passing
- // already invalidated IRUnit is unsafe. There are ways to handle invalidated IRUnits
- // in a safe way, and we might pursue that as soon as there is a useful instrumentation
- // that needs it.
+ // already invalidated IRUnit is unsafe. There are ways to handle invalidated
+ // IRUnits in a safe way, and we might pursue that as soon as there is a
+ // useful instrumentation that needs it.
using BeforePassFunc = bool(StringRef, Any);
- using AfterPassFunc = void(StringRef, Any);
- using AfterPassInvalidatedFunc = void(StringRef);
+ using BeforeSkippedPassFunc = void(StringRef, Any);
+ using BeforeNonSkippedPassFunc = void(StringRef, Any);
+ using AfterPassFunc = void(StringRef, Any, const PreservedAnalyses &);
+ using AfterPassInvalidatedFunc = void(StringRef, const PreservedAnalyses &);
using BeforeAnalysisFunc = void(StringRef, Any);
using AfterAnalysisFunc = void(StringRef, Any);
@@ -88,8 +89,19 @@
PassInstrumentationCallbacks(const PassInstrumentationCallbacks &) = delete;
void operator=(const PassInstrumentationCallbacks &) = delete;
- template <typename CallableT> void registerBeforePassCallback(CallableT C) {
- BeforePassCallbacks.emplace_back(std::move(C));
+ template <typename CallableT>
+ void registerShouldRunOptionalPassCallback(CallableT C) {
+ ShouldRunOptionalPassCallbacks.emplace_back(std::move(C));
+ }
+
+ template <typename CallableT>
+ void registerBeforeSkippedPassCallback(CallableT C) {
+ BeforeSkippedPassCallbacks.emplace_back(std::move(C));
+ }
+
+ template <typename CallableT>
+ void registerBeforeNonSkippedPassCallback(CallableT C) {
+ BeforeNonSkippedPassCallbacks.emplace_back(std::move(C));
}
template <typename CallableT> void registerAfterPassCallback(CallableT C) {
@@ -111,17 +123,37 @@
AfterAnalysisCallbacks.emplace_back(std::move(C));
}
+ /// Add a class name to pass name mapping for use by pass instrumentation.
+ void addClassToPassName(StringRef ClassName, StringRef PassName);
+ /// Get the pass name for a given pass class name.
+ StringRef getPassNameForClassName(StringRef ClassName);
+
private:
friend class PassInstrumentation;
- SmallVector<llvm::unique_function<BeforePassFunc>, 4> BeforePassCallbacks;
+ /// These are only run on passes that are not required. They return false when
+ /// an optional pass should be skipped.
+ SmallVector<llvm::unique_function<BeforePassFunc>, 4>
+ ShouldRunOptionalPassCallbacks;
+ /// These are run on passes that are skipped.
+ SmallVector<llvm::unique_function<BeforeSkippedPassFunc>, 4>
+ BeforeSkippedPassCallbacks;
+ /// These are run on passes that are about to be run.
+ SmallVector<llvm::unique_function<BeforeNonSkippedPassFunc>, 4>
+ BeforeNonSkippedPassCallbacks;
+ /// These are run on passes that have just run.
SmallVector<llvm::unique_function<AfterPassFunc>, 4> AfterPassCallbacks;
+ /// These are run passes that have just run on invalidated IR.
SmallVector<llvm::unique_function<AfterPassInvalidatedFunc>, 4>
AfterPassInvalidatedCallbacks;
+ /// These are run on analyses that are about to be run.
SmallVector<llvm::unique_function<BeforeAnalysisFunc>, 4>
BeforeAnalysisCallbacks;
+ /// These are run on analyses that have been run.
SmallVector<llvm::unique_function<AfterAnalysisFunc>, 4>
AfterAnalysisCallbacks;
+
+ StringMap<std::string> ClassToPassName;
};
/// This class provides instrumentation entry points for the Pass Manager,
@@ -129,6 +161,26 @@
class PassInstrumentation {
PassInstrumentationCallbacks *Callbacks;
+ // Template argument PassT of PassInstrumentation::runBeforePass could be two
+ // kinds: (1) a regular pass inherited from PassInfoMixin (happen when
+ // creating a adaptor pass for a regular pass); (2) a type-erased PassConcept
+ // created from (1). Here we want to make case (1) skippable unconditionally
+ // since they are regular passes. We call PassConcept::isRequired to decide
+ // for case (2).
+ template <typename PassT>
+ using has_required_t = decltype(std::declval<PassT &>().isRequired());
+
+ template <typename PassT>
+ static std::enable_if_t<is_detected<has_required_t, PassT>::value, bool>
+ isRequired(const PassT &Pass) {
+ return Pass.isRequired();
+ }
+ template <typename PassT>
+ static std::enable_if_t<!is_detected<has_required_t, PassT>::value, bool>
+ isRequired(const PassT &Pass) {
+ return false;
+ }
+
public:
/// Callbacks object is not owned by PassInstrumentation, its life-time
/// should at least match the life-time of corresponding
@@ -139,15 +191,28 @@
/// BeforePass instrumentation point - takes \p Pass instance to be executed
/// and constant reference to IR it operates on. \Returns true if pass is
- /// allowed to be executed.
+ /// allowed to be executed. These are only run on optional pass since required
+ /// passes must always be run. This allows these callbacks to print info when
+ /// they want to skip a pass.
template <typename IRUnitT, typename PassT>
bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const {
if (!Callbacks)
return true;
bool ShouldRun = true;
- for (auto &C : Callbacks->BeforePassCallbacks)
- ShouldRun &= C(Pass.name(), llvm::Any(&IR));
+ if (!isRequired(Pass)) {
+ for (auto &C : Callbacks->ShouldRunOptionalPassCallbacks)
+ ShouldRun &= C(Pass.name(), llvm::Any(&IR));
+ }
+
+ if (ShouldRun) {
+ for (auto &C : Callbacks->BeforeNonSkippedPassCallbacks)
+ C(Pass.name(), llvm::Any(&IR));
+ } else {
+ for (auto &C : Callbacks->BeforeSkippedPassCallbacks)
+ C(Pass.name(), llvm::Any(&IR));
+ }
+
return ShouldRun;
}
@@ -155,20 +220,22 @@
/// just been executed and constant reference to \p IR it operates on.
/// \p IR is guaranteed to be valid at this point.
template <typename IRUnitT, typename PassT>
- void runAfterPass(const PassT &Pass, const IRUnitT &IR) const {
+ void runAfterPass(const PassT &Pass, const IRUnitT &IR,
+ const PreservedAnalyses &PA) const {
if (Callbacks)
for (auto &C : Callbacks->AfterPassCallbacks)
- C(Pass.name(), llvm::Any(&IR));
+ C(Pass.name(), llvm::Any(&IR), PA);
}
/// AfterPassInvalidated instrumentation point - takes \p Pass instance
/// that has just been executed. For use when IR has been invalidated
/// by \p Pass execution.
template <typename IRUnitT, typename PassT>
- void runAfterPassInvalidated(const PassT &Pass) const {
+ void runAfterPassInvalidated(const PassT &Pass,
+ const PreservedAnalyses &PA) const {
if (Callbacks)
for (auto &C : Callbacks->AfterPassInvalidatedCallbacks)
- C(Pass.name());
+ C(Pass.name(), PA);
}
/// BeforeAnalysis instrumentation point - takes \p Analysis instance
@@ -199,8 +266,20 @@
ExtraArgsT...) {
return false;
}
+
+ template <typename CallableT>
+ void pushBeforeNonSkippedPassCallback(CallableT C) {
+ if (Callbacks)
+ Callbacks->BeforeNonSkippedPassCallbacks.emplace_back(std::move(C));
+ }
+ void popBeforeNonSkippedPassCallback() {
+ if (Callbacks)
+ Callbacks->BeforeNonSkippedPassCallbacks.pop_back();
+ }
};
+bool isSpecialPass(StringRef PassID, const std::vector<StringRef> &Specials);
+
} // namespace llvm
#endif