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/Analysis/TargetLibraryInfo.h b/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.h
index 4b5200f..34a8a1e 100644
--- a/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/TargetLibraryInfo.h
@@ -9,17 +9,18 @@
#ifndef LLVM_ANALYSIS_TARGETLIBRARYINFO_H
#define LLVM_ANALYSIS_TARGETLIBRARYINFO_H
+#include "llvm/ADT/BitVector.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/Triple.h"
-#include "llvm/IR/CallSite.h"
#include "llvm/IR/Function.h"
+#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Pass.h"
namespace llvm {
template <typename T> class ArrayRef;
+class Triple;
/// Describes a possible vectorization of a function.
/// Function 'VectorFnName' is equivalent to 'ScalarFnName' vectorized
@@ -30,11 +31,12 @@
unsigned VectorizationFactor;
};
- enum LibFunc {
+ enum LibFunc : unsigned {
#define TLI_DEFINE_ENUM
#include "llvm/Analysis/TargetLibraryInfo.def"
- NumLibFuncs
+ NumLibFuncs,
+ NotLibFunc
};
/// Implementation of the target library information.
@@ -48,7 +50,7 @@
unsigned char AvailableArray[(NumLibFuncs+3)/4];
llvm::DenseMap<unsigned, std::string> CustomNames;
- static StringRef const StandardNames[NumLibFuncs];
+ static StringLiteral const StandardNames[NumLibFuncs];
bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param;
enum AvailabilityState {
@@ -86,6 +88,7 @@
enum VectorLibrary {
NoLibrary, // Don't use any vector library.
Accelerate, // Use Accelerate framework.
+ LIBMVEC_X86,// GLIBC Vector Math library.
MASSV, // IBM MASS vector library.
SVML // Intel short vector math library.
};
@@ -127,7 +130,7 @@
void setAvailableWithName(LibFunc F, StringRef Name) {
if (StandardNames[F] != Name) {
setState(F, CustomName);
- CustomNames[F] = Name;
+ CustomNames[F] = std::string(Name);
assert(CustomNames.find(F) != CustomNames.end());
} else {
setState(F, StandardName);
@@ -196,6 +199,10 @@
/// Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
/// This queries the 'wchar_size' metadata.
unsigned getWCharSize(const Module &M) const;
+
+ /// Returns the largest vectorization factor used in the list of
+ /// vector functions.
+ unsigned getWidestVF(StringRef ScalarF) const;
};
/// Provides information about what library functions are available for
@@ -207,23 +214,68 @@
friend class TargetLibraryAnalysis;
friend class TargetLibraryInfoWrapperPass;
+ /// The global (module level) TLI info.
const TargetLibraryInfoImpl *Impl;
+ /// Support for -fno-builtin* options as function attributes, overrides
+ /// information in global TargetLibraryInfoImpl.
+ BitVector OverrideAsUnavailable;
+
public:
- explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) : Impl(&Impl) {}
+ explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl,
+ Optional<const Function *> F = None)
+ : Impl(&Impl), OverrideAsUnavailable(NumLibFuncs) {
+ if (!F)
+ return;
+ if ((*F)->hasFnAttribute("no-builtins"))
+ disableAllFunctions();
+ else {
+ // Disable individual libc/libm calls in TargetLibraryInfo.
+ LibFunc LF;
+ AttributeSet FnAttrs = (*F)->getAttributes().getFnAttributes();
+ for (const Attribute &Attr : FnAttrs) {
+ if (!Attr.isStringAttribute())
+ continue;
+ auto AttrStr = Attr.getKindAsString();
+ if (!AttrStr.consume_front("no-builtin-"))
+ continue;
+ if (getLibFunc(AttrStr, LF))
+ setUnavailable(LF);
+ }
+ }
+ }
// Provide value semantics.
- TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {}
- TargetLibraryInfo(TargetLibraryInfo &&TLI) : Impl(TLI.Impl) {}
+ TargetLibraryInfo(const TargetLibraryInfo &TLI)
+ : Impl(TLI.Impl), OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
+ TargetLibraryInfo(TargetLibraryInfo &&TLI)
+ : Impl(TLI.Impl), OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) {
Impl = TLI.Impl;
+ OverrideAsUnavailable = TLI.OverrideAsUnavailable;
return *this;
}
TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
Impl = TLI.Impl;
+ OverrideAsUnavailable = TLI.OverrideAsUnavailable;
return *this;
}
+ /// Determine whether a callee with the given TLI can be inlined into
+ /// caller with this TLI, based on 'nobuiltin' attributes. When requested,
+ /// allow inlining into a caller with a superset of the callee's nobuiltin
+ /// attributes, which is conservatively correct.
+ bool areInlineCompatible(const TargetLibraryInfo &CalleeTLI,
+ bool AllowCallerSuperset) const {
+ if (!AllowCallerSuperset)
+ return OverrideAsUnavailable == CalleeTLI.OverrideAsUnavailable;
+ BitVector B = OverrideAsUnavailable;
+ B |= CalleeTLI.OverrideAsUnavailable;
+ // We can inline if the union of the caller and callee's nobuiltin
+ // attributes is no stricter than the caller's nobuiltin attributes.
+ return B == OverrideAsUnavailable;
+ }
+
/// Searches for a particular function name.
///
/// If it is one of the known library functions, return true and set F to the
@@ -236,16 +288,34 @@
return Impl->getLibFunc(FDecl, F);
}
- /// If a callsite does not have the 'nobuiltin' attribute, return if the
+ /// If a callbase does not have the 'nobuiltin' attribute, return if the
/// called function is a known library function and set F to that function.
- bool getLibFunc(ImmutableCallSite CS, LibFunc &F) const {
- return !CS.isNoBuiltin() && CS.getCalledFunction() &&
- getLibFunc(*(CS.getCalledFunction()), F);
+ bool getLibFunc(const CallBase &CB, LibFunc &F) const {
+ return !CB.isNoBuiltin() && CB.getCalledFunction() &&
+ getLibFunc(*(CB.getCalledFunction()), F);
+ }
+
+ /// Disables all builtins.
+ ///
+ /// This can be used for options like -fno-builtin.
+ void disableAllFunctions() LLVM_ATTRIBUTE_UNUSED {
+ OverrideAsUnavailable.set();
+ }
+
+ /// Forces a function to be marked as unavailable.
+ void setUnavailable(LibFunc F) LLVM_ATTRIBUTE_UNUSED {
+ OverrideAsUnavailable.set(F);
+ }
+
+ TargetLibraryInfoImpl::AvailabilityState getState(LibFunc F) const {
+ if (OverrideAsUnavailable[F])
+ return TargetLibraryInfoImpl::Unavailable;
+ return Impl->getState(F);
}
/// Tests whether a library function is available.
bool has(LibFunc F) const {
- return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
+ return getState(F) != TargetLibraryInfoImpl::Unavailable;
}
bool isFunctionVectorizable(StringRef F, unsigned VF) const {
return Impl->isFunctionVectorizable(F, VF);
@@ -260,7 +330,7 @@
/// Tests if the function is both available and a candidate for optimized code
/// generation.
bool hasOptimizedCodeGen(LibFunc F) const {
- if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
+ if (getState(F) == TargetLibraryInfoImpl::Unavailable)
return false;
switch (F) {
default: break;
@@ -281,6 +351,7 @@
case LibFunc_trunc: case LibFunc_truncf: case LibFunc_truncl:
case LibFunc_log2: case LibFunc_log2f: case LibFunc_log2l:
case LibFunc_exp2: case LibFunc_exp2f: case LibFunc_exp2l:
+ case LibFunc_memcpy: case LibFunc_memset: case LibFunc_memmove:
case LibFunc_memcmp: case LibFunc_bcmp: case LibFunc_strcmp:
case LibFunc_strcpy: case LibFunc_stpcpy: case LibFunc_strlen:
case LibFunc_strnlen: case LibFunc_memchr: case LibFunc_mempcpy:
@@ -290,7 +361,7 @@
}
StringRef getName(LibFunc F) const {
- auto State = Impl->getState(F);
+ auto State = getState(F);
if (State == TargetLibraryInfoImpl::Unavailable)
return StringRef();
if (State == TargetLibraryInfoImpl::StandardName)
@@ -336,6 +407,16 @@
FunctionAnalysisManager::Invalidator &) {
return false;
}
+ /// Returns the largest vectorization factor used in the list of
+ /// vector functions.
+ unsigned getWidestVF(StringRef ScalarF) const {
+ return Impl->getWidestVF(ScalarF);
+ }
+
+ /// Check if the function "F" is listed in a library known to LLVM.
+ bool isKnownVectorFunctionInLibrary(StringRef F) const {
+ return this->isFunctionVectorizable(F);
+ }
};
/// Analysis pass providing the \c TargetLibraryInfo.
@@ -352,30 +433,24 @@
/// module.
TargetLibraryAnalysis() {}
- /// Construct a library analysis with preset info.
+ /// Construct a library analysis with baseline Module-level info.
///
- /// This will directly copy the preset info into the result without
- /// consulting the module's triple.
- TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl)
- : PresetInfoImpl(std::move(PresetInfoImpl)) {}
+ /// This will be supplemented with Function-specific info in the Result.
+ TargetLibraryAnalysis(TargetLibraryInfoImpl BaselineInfoImpl)
+ : BaselineInfoImpl(std::move(BaselineInfoImpl)) {}
- TargetLibraryInfo run(Module &M, ModuleAnalysisManager &);
- TargetLibraryInfo run(Function &F, FunctionAnalysisManager &);
+ TargetLibraryInfo run(const Function &F, FunctionAnalysisManager &);
private:
friend AnalysisInfoMixin<TargetLibraryAnalysis>;
static AnalysisKey Key;
- Optional<TargetLibraryInfoImpl> PresetInfoImpl;
-
- StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls;
-
- TargetLibraryInfoImpl &lookupInfoImpl(const Triple &T);
+ Optional<TargetLibraryInfoImpl> BaselineInfoImpl;
};
class TargetLibraryInfoWrapperPass : public ImmutablePass {
- TargetLibraryInfoImpl TLIImpl;
- TargetLibraryInfo TLI;
+ TargetLibraryAnalysis TLA;
+ Optional<TargetLibraryInfo> TLI;
virtual void anchor();
@@ -385,8 +460,11 @@
explicit TargetLibraryInfoWrapperPass(const Triple &T);
explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI);
- TargetLibraryInfo &getTLI() { return TLI; }
- const TargetLibraryInfo &getTLI() const { return TLI; }
+ TargetLibraryInfo &getTLI(const Function &F) {
+ FunctionAnalysisManager DummyFAM;
+ TLI = TLA.run(F, DummyFAM);
+ return *TLI;
+ }
};
} // end namespace llvm