[llvm] r226981 - [PM] Rework how the TargetLibraryInfo pass integrates with the new pass
David Blaikie
dblaikie at gmail.com
Sat Jan 24 13:23:35 PST 2015
On Fri, Jan 23, 2015 at 6:06 PM, Chandler Carruth <chandlerc at gmail.com>
wrote:
> Author: chandlerc
> Date: Fri Jan 23 20:06:09 2015
> New Revision: 226981
>
> URL: http://llvm.org/viewvc/llvm-project?rev=226981&view=rev
> Log:
> [PM] Rework how the TargetLibraryInfo pass integrates with the new pass
> manager to support the actual uses of it. =]
>
> When I ported instcombine to the new pass manager I discover that it
> didn't work because TLI wasn't available in the right places. This is
> a somewhat surprising and/or subtle aspect of the new pass manager
> design that came up before but I think is useful to be reminded of:
>
> While the new pass manager *allows* a function pass to query a module
> analysis, it requires that the module analysis is already run and cached
> prior to the function pass manager starting up, possibly with
> a 'require<foo>' style utility in the pass pipeline. This is an
> intentional hurdle because using a module analysis from a function pass
> *requires* that the module analysis is run prior to entering the
> function pass manager. Otherwise the other functions in the module could
> be in who-knows-what state, etc.
>
> A somewhat surprising consequence of this design decision (at least to
> me) is that you have to design a function pass that leverages
> a module analysis to do so as an optional feature.
What's the harm in having the function pass assert the module analysis is
available? It sounds like making it conservatively correct could result in
some function passes becoming no-ops in certain pass pipelines, which would
seem annoying to debug compared to a hard assertion failure?
Anyway - curious to chat with you about this at some point, no doubt.
> Even if that means
> your function pass does no work in the absence of the module analysis,
> you have to handle that possibility and remain conservatively correct.
> This is a natural consequence of things being able to invalidate the
> module analysis and us being unable to re-run it. And it's a generally
> good thing because it lets us reorder passes arbitrarily without
> breaking correctness, etc.
>
> This ends up causing problems in one case. What if we have a module
> analysis that is *definitionally* impossible to invalidate. In the
> places this might come up, the analysis is usually also definitionally
> trivial to run even while other transformation passes run on the module,
> regardless of the state of anything. And so, it follows that it is
> natural to have a hard requirement on such analyses from a function
> pass.
>
> It turns out, that TargetLibraryInfo is just such an analysis, and
> InstCombine has a hard requirement on it.
>
> The approach I've taken here is to produce an analysis that models this
> flexibility by making it both a module and a function analysis. This
> exposes the fact that it is in fact safe to compute at any point. We can
> even make it a valid CGSCC analysis at some point if that is useful.
> However, we don't want to have a copy of the actual target library info
> state for each function! This state is specific to the triple. The
> somewhat direct and blunt approach here is to turn TLI into a pimpl,
> with the state and mutators in the implementation class and the query
> routines primarily in the wrapper. Then the analysis can lazily
> construct and cache the implementations, keyed on the triple, and
> on-demand produce wrappers of them for each function.
>
> One minor annoyance is that we will end up with a wrapper for each
> function in the module. While this is a bit wasteful (one pointer per
> function) it seems tolerable. And it has the advantage of ensuring that
> we pay the absolute minimum synchronization cost to access this
> information should we end up with a nice parallel function pass manager
> in the future. We could look into trying to mark when analysis results
> are especially cheap to recompute and more eagerly GC-ing the cached
> results, or we could look at supporting a variant of analyses whose
> results are specifically *not* cached and expected to just be used and
> discarded by the consumer. Either way, these seem like incremental
> enhancements that should happen when we start profiling the memory and
> CPU usage of the new pass manager and not before.
>
> The other minor annoyance is that if we end up using the TLI in both
> a module pass and a function pass, those will be produced by two
> separate analyses, and thus will point to separate copies of the
> implementation state. While a minor issue, I dislike this and would like
> to find a way to cleanly allow a single analysis instance to be used
> across multiple IR unit managers. But I don't have a good solution to
> this today, and I don't want to hold up all of the work waiting to come
> up with one. This too seems like a reasonable thing to incrementally
> improve later.
>
> Modified:
> llvm/trunk/include/llvm/ADT/Triple.h
> llvm/trunk/include/llvm/Analysis/TargetLibraryInfo.h
> llvm/trunk/include/llvm/Transforms/IPO/PassManagerBuilder.h
> llvm/trunk/lib/Analysis/TargetLibraryInfo.cpp
> llvm/trunk/lib/LTO/LTOCodeGenerator.cpp
> llvm/trunk/lib/Target/Target.cpp
> llvm/trunk/tools/llc/llc.cpp
> llvm/trunk/tools/opt/PassRegistry.def
> llvm/trunk/tools/opt/opt.cpp
>
> Modified: llvm/trunk/include/llvm/ADT/Triple.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/Triple.h?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/Triple.h (original)
> +++ llvm/trunk/include/llvm/ADT/Triple.h Fri Jan 23 20:06:09 2015
> @@ -210,6 +210,9 @@ public:
> /// common case in which otherwise valid components are in the wrong
> order.
> static std::string normalize(StringRef Str);
>
> + /// \brief Return the normalized form of this triple's string.
> + std::string normalize() const { return normalize(Data); }
> +
> /// @}
> /// @name Typed Component Access
> /// @{
>
> Modified: llvm/trunk/include/llvm/Analysis/TargetLibraryInfo.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/TargetLibraryInfo.h?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/TargetLibraryInfo.h (original)
> +++ llvm/trunk/include/llvm/Analysis/TargetLibraryInfo.h Fri Jan 23
> 20:06:09 2015
> @@ -13,7 +13,7 @@
> #include "llvm/ADT/DenseMap.h"
> #include "llvm/ADT/Optional.h"
> #include "llvm/ADT/Triple.h"
> -#include "llvm/IR/Module.h"
> +#include "llvm/IR/Function.h"
> #include "llvm/IR/Module.h"
> #include "llvm/Pass.h"
>
> @@ -696,12 +696,15 @@ class PreservedAnalyses;
> };
> }
>
> -/// \brief Provides information about what library functions are
> available for
> -/// the current target.
> +/// \brief Implementation of the target library information.
> ///
> -/// This both allows optimizations to handle them specially and frontends
> to
> -/// disable such optimizations through -fno-builtin etc.
> -class TargetLibraryInfo {
> +/// This class constructs tables that hold the target library information
> and
> +/// make it available. However, it is somewhat expensive to compute and
> only
> +/// depends on the triple. So users typicaly interact with the \c
> +/// TargetLibraryInfo wrapper below.
> +class TargetLibraryInfoImpl {
> + friend class TargetLibraryInfo;
> +
> unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4];
> llvm::DenseMap<unsigned, std::string> CustomNames;
> static const char* StandardNames[LibFunc::NumLibFuncs];
> @@ -720,14 +723,14 @@ class TargetLibraryInfo {
> }
>
> public:
> - TargetLibraryInfo();
> - explicit TargetLibraryInfo(const Triple &T);
> + TargetLibraryInfoImpl();
> + explicit TargetLibraryInfoImpl(const Triple &T);
>
> // Provide value semantics.
> - TargetLibraryInfo(const TargetLibraryInfo &TLI);
> - TargetLibraryInfo(TargetLibraryInfo &&TLI);
> - TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI);
> - TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI);
> + TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI);
> + TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI);
> + TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI);
> + TargetLibraryInfoImpl &operator=(TargetLibraryInfoImpl &&TLI);
>
> /// \brief Searches for a particular function name.
> ///
> @@ -735,15 +738,77 @@ public:
> /// corresponding value.
> bool getLibFunc(StringRef funcName, LibFunc::Func &F) const;
>
> + /// \brief Forces a function to be marked as unavailable.
> + void setUnavailable(LibFunc::Func F) {
> + setState(F, Unavailable);
> + }
> +
> + /// \brief Forces a function to be marked as available.
> + void setAvailable(LibFunc::Func F) {
> + setState(F, StandardName);
> + }
> +
> + /// \brief Forces a function to be marked as available and provide an
> + /// alternate name that must be used.
> + void setAvailableWithName(LibFunc::Func F, StringRef Name) {
> + if (StandardNames[F] != Name) {
> + setState(F, CustomName);
> + CustomNames[F] = Name;
> + assert(CustomNames.find(F) != CustomNames.end());
> + } else {
> + setState(F, StandardName);
> + }
> + }
> +
> + /// \brief Disables all builtins.
> + ///
> + /// This can be used for options like -fno-builtin.
> + void disableAllFunctions();
> +};
> +
> +/// \brief Provides information about what library functions are
> available for
> +/// the current target.
> +///
> +/// This both allows optimizations to handle them specially and frontends
> to
> +/// disable such optimizations through -fno-builtin etc.
> +class TargetLibraryInfo {
> + friend class TargetLibraryAnalysis;
> + friend class TargetLibraryInfoWrapperPass;
> +
> + const TargetLibraryInfoImpl *Impl;
> +
> +public:
> + explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) :
> Impl(&Impl) {}
> +
> + // Provide value semantics.
> + TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {}
> + TargetLibraryInfo(TargetLibraryInfo &&TLI) : Impl(TLI.Impl) {}
> + TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) {
> + Impl = TLI.Impl;
> + return *this;
> + }
> + TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
> + Impl = TLI.Impl;
> + return *this;
> + }
> +
> + /// \brief Searches for a particular function name.
> + ///
> + /// If it is one of the known library functions, return true and set F
> to the
> + /// corresponding value.
> + bool getLibFunc(StringRef funcName, LibFunc::Func &F) const {
> + return Impl->getLibFunc(funcName, F);
> + }
> +
> /// \brief Tests wether a library function is available.
> bool has(LibFunc::Func F) const {
> - return getState(F) != Unavailable;
> + return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
> }
>
> /// \brief Tests if the function is both available and a candidate for
> /// optimized code generation.
> bool hasOptimizedCodeGen(LibFunc::Func F) const {
> - if (getState(F) == Unavailable)
> + if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
> return false;
> switch (F) {
> default: break;
> @@ -773,42 +838,15 @@ public:
> }
>
> StringRef getName(LibFunc::Func F) const {
> - AvailabilityState State = getState(F);
> - if (State == Unavailable)
> + auto State = Impl->getState(F);
> + if (State == TargetLibraryInfoImpl::Unavailable)
> return StringRef();
> - if (State == StandardName)
> - return StandardNames[F];
> - assert(State == CustomName);
> - return CustomNames.find(F)->second;
> + if (State == TargetLibraryInfoImpl::StandardName)
> + return Impl->StandardNames[F];
> + assert(State == TargetLibraryInfoImpl::CustomName);
> + return Impl->CustomNames.find(F)->second;
> }
>
> - /// \brief Forces a function to be marked as unavailable.
> - void setUnavailable(LibFunc::Func F) {
> - setState(F, Unavailable);
> - }
> -
> - /// \brief Forces a function to be marked as available.
> - void setAvailable(LibFunc::Func F) {
> - setState(F, StandardName);
> - }
> -
> - /// \brief Forces a function to be marked as available and provide an
> - /// alternate name that must be used.
> - void setAvailableWithName(LibFunc::Func F, StringRef Name) {
> - if (StandardNames[F] != Name) {
> - setState(F, CustomName);
> - CustomNames[F] = Name;
> - assert(CustomNames.find(F) != CustomNames.end());
> - } else {
> - setState(F, StandardName);
> - }
> - }
> -
> - /// \brief Disables all builtins.
> - ///
> - /// This can be used for options like -fno-builtin.
> - void disableAllFunctions();
> -
> /// \brief Handle invalidation from the pass manager.
> ///
> /// If we try to invalidate this info, just return false. It cannot
> become
> @@ -837,29 +875,20 @@ public:
> ///
> /// This will directly copy the preset info into the result without
> /// consulting the module's triple.
> - TargetLibraryAnalysis(TargetLibraryInfo PresetInfo)
> - : PresetInfo(std::move(PresetInfo)) {}
> + TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl)
> + : PresetInfoImpl(std::move(PresetInfoImpl)) {}
>
> - // Value semantics. We spell out the constructors for MSVC.
> - TargetLibraryAnalysis(const TargetLibraryAnalysis &Arg)
> - : PresetInfo(Arg.PresetInfo) {}
> + // Move semantics. We spell out the constructors for MSVC.
> TargetLibraryAnalysis(TargetLibraryAnalysis &&Arg)
> - : PresetInfo(std::move(Arg.PresetInfo)) {}
> - TargetLibraryAnalysis &operator=(const TargetLibraryAnalysis &RHS) {
> - PresetInfo = RHS.PresetInfo;
> - return *this;
> - }
> + : PresetInfoImpl(std::move(Arg.PresetInfoImpl)),
> Impls(std::move(Arg.Impls)) {}
> TargetLibraryAnalysis &operator=(TargetLibraryAnalysis &&RHS) {
> - PresetInfo = std::move(RHS.PresetInfo);
> + PresetInfoImpl = std::move(RHS.PresetInfoImpl);
> + Impls = std::move(RHS.Impls);
> return *this;
> }
>
> - TargetLibraryInfo run(Module &M) {
> - if (PresetInfo)
> - return *PresetInfo;
> -
> - return TargetLibraryInfo(Triple(M.getTargetTriple()));
> - }
> + TargetLibraryInfo run(Module &M);
> + TargetLibraryInfo run(Function &F);
>
> /// \brief Provide access to a name for this pass for debugging
> purposes.
> static StringRef name() { return "TargetLibraryAnalysis"; }
> @@ -867,10 +896,15 @@ public:
> private:
> static char PassID;
>
> - Optional<TargetLibraryInfo> PresetInfo;
> + Optional<TargetLibraryInfoImpl> PresetInfoImpl;
> +
> + StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls;
> +
> + TargetLibraryInfoImpl &lookupInfoImpl(Triple T);
> };
>
> class TargetLibraryInfoWrapperPass : public ImmutablePass {
> + TargetLibraryInfoImpl TLIImpl;
> TargetLibraryInfo TLI;
>
> virtual void anchor();
> @@ -879,7 +913,7 @@ public:
> static char ID;
> TargetLibraryInfoWrapperPass();
> explicit TargetLibraryInfoWrapperPass(const Triple &T);
> - explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfo &TLI);
> + explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI);
>
> TargetLibraryInfo &getTLI() { return TLI; }
> const TargetLibraryInfo &getTLI() const { return TLI; }
>
> Modified: llvm/trunk/include/llvm/Transforms/IPO/PassManagerBuilder.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/IPO/PassManagerBuilder.h?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/Transforms/IPO/PassManagerBuilder.h (original)
> +++ llvm/trunk/include/llvm/Transforms/IPO/PassManagerBuilder.h Fri Jan 23
> 20:06:09 2015
> @@ -19,7 +19,7 @@
>
> namespace llvm {
> class Pass;
> -class TargetLibraryInfo;
> +class TargetLibraryInfoImpl;
> class TargetMachine;
>
> // The old pass manager infrastructure is hidden in a legacy namespace
> now.
> @@ -105,7 +105,7 @@ public:
> /// LibraryInfo - Specifies information about the runtime library for
> the
> /// optimizer. If this is non-null, it is added to both the function
> and
> /// per-module pass pipeline.
> - TargetLibraryInfo *LibraryInfo;
> + TargetLibraryInfoImpl *LibraryInfo;
>
> /// Inliner - Specifies the inliner to use. If this is non-null, it is
> /// added to the per-module passes.
>
> Modified: llvm/trunk/lib/Analysis/TargetLibraryInfo.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/TargetLibraryInfo.cpp?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Analysis/TargetLibraryInfo.cpp (original)
> +++ llvm/trunk/lib/Analysis/TargetLibraryInfo.cpp Fri Jan 23 20:06:09 2015
> @@ -15,7 +15,7 @@
> #include "llvm/ADT/Triple.h"
> using namespace llvm;
>
> -const char* TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
> +const char* TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
> {
> "_IO_getc",
> "_IO_putc",
> @@ -370,13 +370,13 @@ static bool hasSinCosPiStret(const Tripl
> /// initialize - Initialize the set of available library functions based
> on the
> /// specified target triple. This should be carefully written so that a
> missing
> /// target triple gets a sane set of defaults.
> -static void initialize(TargetLibraryInfo &TLI, const Triple &T,
> +static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
> const char **StandardNames) {
> #ifndef NDEBUG
> // Verify that the StandardNames array is in alphabetical order.
> for (unsigned F = 1; F < LibFunc::NumLibFuncs; ++F) {
> if (strcmp(StandardNames[F-1], StandardNames[F]) >= 0)
> - llvm_unreachable("TargetLibraryInfo function names must be sorted");
> + llvm_unreachable("TargetLibraryInfoImpl function names must be
> sorted");
> }
> #endif // !NDEBUG
>
> @@ -676,38 +676,38 @@ static void initialize(TargetLibraryInfo
> }
> }
>
> -TargetLibraryInfo::TargetLibraryInfo() {
> +TargetLibraryInfoImpl::TargetLibraryInfoImpl() {
> // Default to everything being available.
> memset(AvailableArray, -1, sizeof(AvailableArray));
>
> initialize(*this, Triple(), StandardNames);
> }
>
> -TargetLibraryInfo::TargetLibraryInfo(const Triple &T) {
> +TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) {
> // Default to everything being available.
> memset(AvailableArray, -1, sizeof(AvailableArray));
>
> initialize(*this, T, StandardNames);
> }
>
> -TargetLibraryInfo::TargetLibraryInfo(const TargetLibraryInfo &TLI)
> +TargetLibraryInfoImpl::TargetLibraryInfoImpl(const TargetLibraryInfoImpl
> &TLI)
> : CustomNames(TLI.CustomNames) {
> memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
> }
>
> -TargetLibraryInfo::TargetLibraryInfo(TargetLibraryInfo &&TLI)
> +TargetLibraryInfoImpl::TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI)
> : CustomNames(std::move(TLI.CustomNames)) {
> std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
> AvailableArray);
> }
>
> -TargetLibraryInfo &TargetLibraryInfo::operator=(const TargetLibraryInfo
> &TLI) {
> +TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(const
> TargetLibraryInfoImpl &TLI) {
> CustomNames = TLI.CustomNames;
> memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
> return *this;
> }
>
> -TargetLibraryInfo &TargetLibraryInfo::operator=(TargetLibraryInfo &&TLI) {
> +TargetLibraryInfoImpl
> &TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl &&TLI) {
> CustomNames = std::move(TLI.CustomNames);
> std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
> AvailableArray);
> @@ -733,7 +733,7 @@ struct StringComparator {
> };
> }
>
> -bool TargetLibraryInfo::getLibFunc(StringRef funcName,
> +bool TargetLibraryInfoImpl::getLibFunc(StringRef funcName,
> LibFunc::Func &F) const {
> const char **Start = &StandardNames[0];
> const char **End = &StandardNames[LibFunc::NumLibFuncs];
> @@ -755,23 +755,48 @@ bool TargetLibraryInfo::getLibFunc(Strin
> return false;
> }
>
> -void TargetLibraryInfo::disableAllFunctions() {
> +void TargetLibraryInfoImpl::disableAllFunctions() {
> memset(AvailableArray, 0, sizeof(AvailableArray));
> }
>
> +TargetLibraryInfo TargetLibraryAnalysis::run(Module &M) {
> + if (PresetInfoImpl)
> + return TargetLibraryInfo(*PresetInfoImpl);
> +
> + return TargetLibraryInfo(lookupInfoImpl(Triple(M.getTargetTriple())));
> +}
> +
> +TargetLibraryInfo TargetLibraryAnalysis::run(Function &F) {
> + if (PresetInfoImpl)
> + return TargetLibraryInfo(*PresetInfoImpl);
> +
> + return TargetLibraryInfo(
> + lookupInfoImpl(Triple(F.getParent()->getTargetTriple())));
> +}
> +
> +TargetLibraryInfoImpl &TargetLibraryAnalysis::lookupInfoImpl(Triple T) {
> + std::unique_ptr<TargetLibraryInfoImpl> &Impl =
> + Impls[T.normalize()];
> + if (!Impl)
> + Impl.reset(new TargetLibraryInfoImpl(T));
> +
> + return *Impl;
> +}
> +
> +
> TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass()
> - : ImmutablePass(ID), TLI() {
> + : ImmutablePass(ID), TLIImpl(), TLI(TLIImpl) {
>
> initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
> }
>
> TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(const Triple
> &T)
> - : ImmutablePass(ID), TLI(T) {
> + : ImmutablePass(ID), TLIImpl(T), TLI(TLIImpl) {
>
> initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
> }
>
> TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(
> - const TargetLibraryInfo &TLI)
> - : ImmutablePass(ID), TLI(TLI) {
> + const TargetLibraryInfoImpl &TLIImpl)
> + : ImmutablePass(ID), TLIImpl(TLIImpl), TLI(this->TLIImpl) {
>
> initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
> }
>
>
> Modified: llvm/trunk/lib/LTO/LTOCodeGenerator.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/LTO/LTOCodeGenerator.cpp?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/LTO/LTOCodeGenerator.cpp (original)
> +++ llvm/trunk/lib/LTO/LTOCodeGenerator.cpp Fri Jan 23 20:06:09 2015
> @@ -410,7 +410,8 @@ void LTOCodeGenerator::applyScopeRestric
> std::vector<const char*> MustPreserveList;
> SmallPtrSet<GlobalValue*, 8> AsmUsed;
> std::vector<StringRef> Libcalls;
> - TargetLibraryInfo TLI(Triple(TargetMach->getTargetTriple()));
> + TargetLibraryInfoImpl TLII(Triple(TargetMach->getTargetTriple()));
> + TargetLibraryInfo TLI(TLII);
> accumulateAndSortLibcalls(
> Libcalls, TLI, TargetMach->getSubtargetImpl()->getTargetLowering());
>
> @@ -484,7 +485,7 @@ bool LTOCodeGenerator::generateObjectFil
> PMB.SLPVectorize = !DisableVectorization;
> if (!DisableInline)
> PMB.Inliner = createFunctionInliningPass();
> - PMB.LibraryInfo = new TargetLibraryInfo(TargetTriple);
> + PMB.LibraryInfo = new TargetLibraryInfoImpl(TargetTriple);
> if (DisableOpt)
> PMB.OptLevel = 0;
> PMB.VerifyInput = true;
>
> Modified: llvm/trunk/lib/Target/Target.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/Target.cpp?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Target/Target.cpp (original)
> +++ llvm/trunk/lib/Target/Target.cpp Fri Jan 23 20:06:09 2015
> @@ -24,12 +24,12 @@
>
> using namespace llvm;
>
> -inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
> - return reinterpret_cast<TargetLibraryInfo*>(P);
> +inline TargetLibraryInfoImpl *unwrap(LLVMTargetLibraryInfoRef P) {
> + return reinterpret_cast<TargetLibraryInfoImpl*>(P);
> }
>
> -inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
> - TargetLibraryInfo *X = const_cast<TargetLibraryInfo*>(P);
> +inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfoImpl *P) {
> + TargetLibraryInfoImpl *X = const_cast<TargetLibraryInfoImpl*>(P);
> return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
> }
>
>
> Modified: llvm/trunk/tools/llc/llc.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llc/llc.cpp?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/tools/llc/llc.cpp (original)
> +++ llvm/trunk/tools/llc/llc.cpp Fri Jan 23 20:06:09 2015
> @@ -296,12 +296,12 @@ static int compileModule(char **argv, LL
> PassManager PM;
>
> // Add an appropriate TargetLibraryInfo pass for the module's triple.
> - TargetLibraryInfo TLI(Triple(M->getTargetTriple()));
> + TargetLibraryInfoImpl TLII(Triple(M->getTargetTriple()));
>
> // The -disable-simplify-libcalls flag actually disables all builtin
> optzns.
> if (DisableSimplifyLibCalls)
> - TLI.disableAllFunctions();
> - PM.add(new TargetLibraryInfoWrapperPass(TLI));
> + TLII.disableAllFunctions();
> + PM.add(new TargetLibraryInfoWrapperPass(TLII));
>
> // Add the target data from the target machine, if it exists, or the
> module.
> if (const DataLayout *DL = Target->getSubtargetImpl()->getDataLayout())
>
> Modified: llvm/trunk/tools/opt/PassRegistry.def
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/opt/PassRegistry.def?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/tools/opt/PassRegistry.def (original)
> +++ llvm/trunk/tools/opt/PassRegistry.def Fri Jan 23 20:06:09 2015
> @@ -54,6 +54,7 @@ FUNCTION_ANALYSIS("assumptions", Assumpt
> FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis())
> FUNCTION_ANALYSIS("loops", LoopAnalysis())
> FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis())
> +FUNCTION_ANALYSIS("targetlibinfo", TargetLibraryAnalysis())
> #undef FUNCTION_ANALYSIS
>
> #ifndef FUNCTION_PASS
>
> Modified: llvm/trunk/tools/opt/opt.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/opt/opt.cpp?rev=226981&r1=226980&r2=226981&view=diff
>
> ==============================================================================
> --- llvm/trunk/tools/opt/opt.cpp (original)
> +++ llvm/trunk/tools/opt/opt.cpp Fri Jan 23 20:06:09 2015
> @@ -401,12 +401,12 @@ int main(int argc, char **argv) {
> PassManager Passes;
>
> // Add an appropriate TargetLibraryInfo pass for the module's triple.
> - TargetLibraryInfo TLI(Triple(M->getTargetTriple()));
> + TargetLibraryInfoImpl TLII(Triple(M->getTargetTriple()));
>
> // The -disable-simplify-libcalls flag actually disables all builtin
> optzns.
> if (DisableSimplifyLibCalls)
> - TLI.disableAllFunctions();
> - Passes.add(new TargetLibraryInfoWrapperPass(TLI));
> + TLII.disableAllFunctions();
> + Passes.add(new TargetLibraryInfoWrapperPass(TLII));
>
> // Add an appropriate DataLayout instance for this module.
> const DataLayout *DL = M->getDataLayout();
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20150124/66296191/attachment.html>
More information about the llvm-commits
mailing list