From: Eric Christopher Date: Thu, 18 Sep 2014 00:34:14 +0000 (+0000) Subject: Add a new pass FunctionTargetTransformInfo. This pass serves as a X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=757c90dd00dc4902652b08e7d7f22ea2c0fbe3ac Add a new pass FunctionTargetTransformInfo. This pass serves as a shim between the TargetTransformInfo immutable pass and the Subtarget via the TargetMachine and Function. Migrate a single call from BasicTargetTransformInfo as an example and provide shims where TargetMachine begins taking a Function to determine the subtarget. No functional change. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218004 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Analysis/FunctionTargetTransformInfo.h b/include/llvm/Analysis/FunctionTargetTransformInfo.h new file mode 100644 index 00000000000..c1654cccf6c --- /dev/null +++ b/include/llvm/Analysis/FunctionTargetTransformInfo.h @@ -0,0 +1,49 @@ +//===- llvm/Analysis/FunctionTargetTransformInfo.h --------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This pass wraps a TargetTransformInfo in a FunctionPass so that it can +// forward along the current Function so that we can make target specific +// decisions based on the particular subtarget specified for each Function. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_ANALYSIS_FUNCTIONTARGETTRANSFORMINFO_H +#define LLVM_ANALYSIS_FUNCTIONTARGETTRANSFORMINFO_H + +#include "llvm/Pass.h" +#include "TargetTransformInfo.h" + +namespace llvm { +class FunctionTargetTransformInfo final : public FunctionPass { +private: + const Function *Fn; + const TargetTransformInfo *TTI; + + FunctionTargetTransformInfo(const FunctionTargetTransformInfo &) + LLVM_DELETED_FUNCTION; + void operator=(const FunctionTargetTransformInfo &) LLVM_DELETED_FUNCTION; + +public: + static char ID; + FunctionTargetTransformInfo(); + + // Implementation boilerplate. + void getAnalysisUsage(AnalysisUsage &AU) const override; + void releaseMemory() override; + bool runOnFunction(Function &F) override; + + // Shimmed functions from TargetTransformInfo. + void + getUnrollingPreferences(Loop *L, + TargetTransformInfo::UnrollingPreferences &UP) const { + TTI->getUnrollingPreferences(Fn, L, UP); + } +}; +} +#endif diff --git a/include/llvm/Analysis/TargetTransformInfo.h b/include/llvm/Analysis/TargetTransformInfo.h index 2e841092ec7..9acaaa6f2eb 100644 --- a/include/llvm/Analysis/TargetTransformInfo.h +++ b/include/llvm/Analysis/TargetTransformInfo.h @@ -28,6 +28,7 @@ namespace llvm { +class Function; class GlobalValue; class Loop; class Type; @@ -227,7 +228,8 @@ public: /// \brief Get target-customized preferences for the generic loop unrolling /// transformation. The caller will initialize UP with the current /// target-independent defaults. - virtual void getUnrollingPreferences(Loop *L, UnrollingPreferences &UP) const; + virtual void getUnrollingPreferences(const Function *F, Loop *L, + UnrollingPreferences &UP) const; /// @} diff --git a/include/llvm/InitializePasses.h b/include/llvm/InitializePasses.h index b0ec376267e..2964798e071 100644 --- a/include/llvm/InitializePasses.h +++ b/include/llvm/InitializePasses.h @@ -261,6 +261,7 @@ void initializeTailDuplicatePassPass(PassRegistry&); void initializeTargetPassConfigPass(PassRegistry&); void initializeDataLayoutPassPass(PassRegistry &); void initializeTargetTransformInfoAnalysisGroup(PassRegistry&); +void initializeFunctionTargetTransformInfoPass(PassRegistry &); void initializeNoTTIPass(PassRegistry&); void initializeTargetLibraryInfoPass(PassRegistry&); void initializeAssumptionTrackerPass(PassRegistry &); diff --git a/include/llvm/Target/TargetMachine.h b/include/llvm/Target/TargetMachine.h index f000abceda3..fc82dfa869f 100644 --- a/include/llvm/Target/TargetMachine.h +++ b/include/llvm/Target/TargetMachine.h @@ -99,6 +99,9 @@ public: virtual const TargetSubtargetInfo *getSubtargetImpl() const { return nullptr; } + virtual const TargetSubtargetInfo *getSubtargetImpl(const Function *) const { + return getSubtargetImpl(); + } /// getSubtarget - This method returns a pointer to the specified type of /// TargetSubtargetInfo. In debug builds, it verifies that the object being @@ -106,6 +109,9 @@ public: template const STC &getSubtarget() const { return *static_cast(getSubtargetImpl()); } + template const STC &getSubtarget(const Function *) const { + return *static_cast(getSubtargetImpl()); + } /// \brief Reset the target options based on the function's attributes. void resetTargetOptions(const MachineFunction *MF) const; diff --git a/lib/Analysis/FunctionTargetTransformInfo.cpp b/lib/Analysis/FunctionTargetTransformInfo.cpp new file mode 100644 index 00000000000..a686bec4e73 --- /dev/null +++ b/lib/Analysis/FunctionTargetTransformInfo.cpp @@ -0,0 +1,50 @@ +//===- llvm/Analysis/FunctionTargetTransformInfo.h --------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This pass wraps a TargetTransformInfo in a FunctionPass so that it can +// forward along the current Function so that we can make target specific +// decisions based on the particular subtarget specified for each Function. +// +//===----------------------------------------------------------------------===// + +#include "llvm/InitializePasses.h" +#include "llvm/Analysis/FunctionTargetTransformInfo.h" + +using namespace llvm; + +#define DEBUG_TYPE "function-tti" +static const char ftti_name[] = "Function TargetTransformInfo"; +INITIALIZE_PASS_BEGIN(FunctionTargetTransformInfo, "function_tti", ftti_name, false, true) +INITIALIZE_AG_DEPENDENCY(TargetTransformInfo) +INITIALIZE_PASS_END(FunctionTargetTransformInfo, "function_tti", ftti_name, false, true) +char FunctionTargetTransformInfo::ID = 0; + +namespace llvm { +FunctionPass *createFunctionTargetTransformInfoPass() { + return new FunctionTargetTransformInfo(); +} +} + +FunctionTargetTransformInfo::FunctionTargetTransformInfo() + : FunctionPass(ID), Fn(nullptr), TTI(nullptr) { + initializeFunctionTargetTransformInfoPass(*PassRegistry::getPassRegistry()); +} + +void FunctionTargetTransformInfo::getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + AU.addRequired(); +} + +void FunctionTargetTransformInfo::releaseMemory() {} + +bool FunctionTargetTransformInfo::runOnFunction(Function &F) { + Fn = &F; + TTI = &getAnalysis(); + return false; +} diff --git a/lib/Analysis/TargetTransformInfo.cpp b/lib/Analysis/TargetTransformInfo.cpp index 89713cef993..9a0133a6c2b 100644 --- a/lib/Analysis/TargetTransformInfo.cpp +++ b/lib/Analysis/TargetTransformInfo.cpp @@ -87,9 +87,10 @@ bool TargetTransformInfo::isLoweredToCall(const Function *F) const { return PrevTTI->isLoweredToCall(F); } -void TargetTransformInfo::getUnrollingPreferences(Loop *L, - UnrollingPreferences &UP) const { - PrevTTI->getUnrollingPreferences(L, UP); +void +TargetTransformInfo::getUnrollingPreferences(const Function *F, Loop *L, + UnrollingPreferences &UP) const { + PrevTTI->getUnrollingPreferences(F, L, UP); } bool TargetTransformInfo::isLegalAddImmediate(int64_t Imm) const { @@ -487,8 +488,8 @@ struct NoTTI final : ImmutablePass, TargetTransformInfo { return true; } - void getUnrollingPreferences(Loop *, UnrollingPreferences &) const override { - } + void getUnrollingPreferences(const Function *, Loop *, + UnrollingPreferences &) const override {} bool isLegalAddImmediate(int64_t Imm) const override { return false; diff --git a/lib/CodeGen/BasicTargetTransformInfo.cpp b/lib/CodeGen/BasicTargetTransformInfo.cpp index e79f458efbf..9a3e296c324 100644 --- a/lib/CodeGen/BasicTargetTransformInfo.cpp +++ b/lib/CodeGen/BasicTargetTransformInfo.cpp @@ -92,7 +92,7 @@ public: unsigned getJumpBufSize() const override; bool shouldBuildLookupTables() const override; bool haveFastSqrt(Type *Ty) const override; - void getUnrollingPreferences(Loop *L, + void getUnrollingPreferences(const Function *F, Loop *L, UnrollingPreferences &UP) const override; /// @} @@ -199,7 +199,7 @@ bool BasicTTI::haveFastSqrt(Type *Ty) const { return TLI->isTypeLegal(VT) && TLI->isOperationLegalOrCustom(ISD::FSQRT, VT); } -void BasicTTI::getUnrollingPreferences(Loop *L, +void BasicTTI::getUnrollingPreferences(const Function *F, Loop *L, UnrollingPreferences &UP) const { // This unrolling functionality is target independent, but to provide some // motivation for its intended use, for x86: @@ -225,7 +225,7 @@ void BasicTTI::getUnrollingPreferences(Loop *L, // until someone finds a case where it matters in practice. unsigned MaxOps; - const TargetSubtargetInfo *ST = &TM->getSubtarget(); + const TargetSubtargetInfo *ST = &TM->getSubtarget(F); if (PartialUnrollingThreshold.getNumOccurrences() > 0) MaxOps = PartialUnrollingThreshold; else if (ST->getSchedModel().LoopMicroOpBufferSize > 0) diff --git a/lib/Target/PowerPC/PPCTargetTransformInfo.cpp b/lib/Target/PowerPC/PPCTargetTransformInfo.cpp index 0cb88c111bf..37624ed93d3 100644 --- a/lib/Target/PowerPC/PPCTargetTransformInfo.cpp +++ b/lib/Target/PowerPC/PPCTargetTransformInfo.cpp @@ -38,6 +38,7 @@ void initializePPCTTIPass(PassRegistry &); namespace { class PPCTTI final : public ImmutablePass, public TargetTransformInfo { + const TargetMachine *TM; const PPCSubtarget *ST; const PPCTargetLowering *TLI; @@ -47,7 +48,7 @@ public: } PPCTTI(const PPCTargetMachine *TM) - : ImmutablePass(ID), ST(TM->getSubtargetImpl()), + : ImmutablePass(ID), TM(TM), ST(TM->getSubtargetImpl()), TLI(TM->getSubtargetImpl()->getTargetLowering()) { initializePPCTTIPass(*PassRegistry::getPassRegistry()); } @@ -80,8 +81,8 @@ public: Type *Ty) const override; PopcntSupportKind getPopcntSupport(unsigned TyWidth) const override; - void getUnrollingPreferences( - Loop *L, UnrollingPreferences &UP) const override; + void getUnrollingPreferences(const Function *F, Loop *L, + UnrollingPreferences &UP) const override; /// @} @@ -269,8 +270,9 @@ unsigned PPCTTI::getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, return PPCTTI::getIntImmCost(Imm, Ty); } -void PPCTTI::getUnrollingPreferences(Loop *L, UnrollingPreferences &UP) const { - if (ST->getDarwinDirective() == PPC::DIR_A2) { +void PPCTTI::getUnrollingPreferences(const Function *F, Loop *L, + UnrollingPreferences &UP) const { + if (TM->getSubtarget(F).getDarwinDirective() == PPC::DIR_A2) { // The A2 is in-order with a deep pipeline, and concatenation unrolling // helps expose latency-hiding opportunities to the instruction scheduler. UP.Partial = UP.Runtime = true; diff --git a/lib/Target/R600/AMDGPUTargetTransformInfo.cpp b/lib/Target/R600/AMDGPUTargetTransformInfo.cpp index 48fb5bf1151..eaba1537e01 100644 --- a/lib/Target/R600/AMDGPUTargetTransformInfo.cpp +++ b/lib/Target/R600/AMDGPUTargetTransformInfo.cpp @@ -74,7 +74,7 @@ public: bool hasBranchDivergence() const override; - void getUnrollingPreferences(Loop *L, + void getUnrollingPreferences(const Function *F, Loop *L, UnrollingPreferences &UP) const override; PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const override; @@ -99,7 +99,7 @@ llvm::createAMDGPUTargetTransformInfoPass(const AMDGPUTargetMachine *TM) { bool AMDGPUTTI::hasBranchDivergence() const { return true; } -void AMDGPUTTI::getUnrollingPreferences(Loop *L, +void AMDGPUTTI::getUnrollingPreferences(const Function *, Loop *L, UnrollingPreferences &UP) const { UP.Threshold = 300; // Twice the default. UP.Count = UINT_MAX; diff --git a/lib/Transforms/Scalar/LoopUnrollPass.cpp b/lib/Transforms/Scalar/LoopUnrollPass.cpp index 293386efe86..d83816a5a51 100644 --- a/lib/Transforms/Scalar/LoopUnrollPass.cpp +++ b/lib/Transforms/Scalar/LoopUnrollPass.cpp @@ -15,6 +15,7 @@ #include "llvm/Transforms/Scalar.h" #include "llvm/Analysis/AssumptionTracker.h" #include "llvm/Analysis/CodeMetrics.h" +#include "llvm/Analysis/FunctionTargetTransformInfo.h" #include "llvm/Analysis/LoopPass.h" #include "llvm/Analysis/ScalarEvolution.h" #include "llvm/Analysis/TargetTransformInfo.h" @@ -113,6 +114,7 @@ namespace { AU.addRequired(); AU.addPreserved(); AU.addRequired(); + AU.addRequired(); // FIXME: Loop unroll requires LCSSA. And LCSSA requires dom info. // If loop unroll does not preserve dom info then LCSSA pass on next // loop will receive invalid dom info. @@ -122,7 +124,7 @@ namespace { // Fill in the UnrollingPreferences parameter with values from the // TargetTransformationInfo. - void getUnrollingPreferences(Loop *L, const TargetTransformInfo &TTI, + void getUnrollingPreferences(Loop *L, const FunctionTargetTransformInfo &FTTI, TargetTransformInfo::UnrollingPreferences &UP) { UP.Threshold = CurrentThreshold; UP.OptSizeThreshold = OptSizeUnrollThreshold; @@ -132,7 +134,7 @@ namespace { UP.MaxCount = UINT_MAX; UP.Partial = CurrentAllowPartial; UP.Runtime = CurrentRuntime; - TTI.getUnrollingPreferences(L, UP); + FTTI.getUnrollingPreferences(L, UP); } // Select and return an unroll count based on parameters from @@ -185,6 +187,7 @@ char LoopUnroll::ID = 0; INITIALIZE_PASS_BEGIN(LoopUnroll, "loop-unroll", "Unroll loops", false, false) INITIALIZE_AG_DEPENDENCY(TargetTransformInfo) INITIALIZE_PASS_DEPENDENCY(AssumptionTracker) +INITIALIZE_PASS_DEPENDENCY(FunctionTargetTransformInfo) INITIALIZE_PASS_DEPENDENCY(LoopInfo) INITIALIZE_PASS_DEPENDENCY(LoopSimplify) INITIALIZE_PASS_DEPENDENCY(LCSSA) @@ -358,6 +361,8 @@ bool LoopUnroll::runOnLoop(Loop *L, LPPassManager &LPM) { LoopInfo *LI = &getAnalysis(); ScalarEvolution *SE = &getAnalysis(); const TargetTransformInfo &TTI = getAnalysis(); + const FunctionTargetTransformInfo &FTTI = + getAnalysis(); AssumptionTracker *AT = &getAnalysis(); BasicBlock *Header = L->getHeader(); @@ -372,7 +377,7 @@ bool LoopUnroll::runOnLoop(Loop *L, LPPassManager &LPM) { bool HasPragma = PragmaFullUnroll || PragmaCount > 0; TargetTransformInfo::UnrollingPreferences UP; - getUnrollingPreferences(L, TTI, UP); + getUnrollingPreferences(L, FTTI, UP); // Find trip count and trip multiple if count is not available unsigned TripCount = 0;