This is an archive of the discontinued LLVM Phabricator instance.

Differential D28476

[Analysis] Add LF_ prefix to LibFunc enums in TargetLibraryInfo. (NFC)
ClosedPublic

Authored by dlj on Jan 9 2017, 12:44 PM.

Details

Reviewers
rsmith
efriedma
Commits
rGd21529fa0df7: [Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
rL292848: [Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary

The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).

Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.

The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LF_". (Unfortunately, a scoped enum is not sufficient to override macros.)

There are additional changes required in clang.

Diff Detail

Event Timeline

dlj updated this revision to Diff 83673.Jan 9 2017, 12:44 PM
dlj retitled this revision from to [Analysis] Add LF_ prefix to LibFunc enums in TargetLibraryInfo. (NFC).
dlj updated this object.
dlj added a reviewer: rsmith.
dlj added a subscriber: llvm-commits.
Herald added subscribers: nemanjai, mzolotukhin, mehdi_amini. · View Herald TranscriptJan 9 2017, 12:44 PM
dlj added a comment.Jan 20 2017, 12:19 PM

Ping?

efriedma added a subscriber: efriedma.Jan 20 2017, 1:27 PM

However, there are some "library"functions which are not part of the standard, and thus not subject to this rule (fopen64, for example). So, in order to be both portable and consistent, the enum should not use the bare function names.

Generally, our response to system headers which contain stupid #defines is just to #undef them. (See, for example, include/llvm/ADT/Triple.h.) Would that be practical in your situation?

dlj added a comment.Jan 20 2017, 3:04 PM

Not really... musl-libc is conforming, and the assumption that "memmove" is a valid token has different reasoning than that for "fopen64" (i.e., one is allowed by the C++ standard, the other is not).

(On a side note, I'm not sure #undef is a reasonable approach for any libc implementation, but in this particular case Clang is broken with a perfectly conformant libc. So that seems worthwhile to fix.)

dlj added a comment.Jan 20 2017, 3:08 PM

Actually, I spoke too soon: 17.6.4.3.1 specifically forbids #undef ing anything from a standard library header.

efriedma added a comment.Jan 20 2017, 4:00 PM

Appealing to the standard is not helpful here... fopen64 isn't defined by any standard, and therefore there isn't really any difference between using the token "fopen64" and the token "LF_fopen64". In practice, of course, the global namespace on most systems is polluted with a bunch of non-standard symbols, but we really don't want to rename stuff every time someone finds a system with an unusual #define, so therefore our usual solution is just to "#undef" the relevant symbol.

I guess you could argue that TargetLibraryInfo in particular is extremely likely to cause problems in the future, and therefore we should preemptively rename all the library functions to avoid problems.

dlj added a comment.Jan 20 2017, 5:23 PM
In D28476#652131, @efriedma wrote:

I guess you could argue that TargetLibraryInfo in particular is extremely likely to cause problems in the future, and therefore we should preemptively rename all the library functions to avoid problems.

Right... that's the impetus, so fopen64 may simply be a red herring. I called this out as "portability" in the summary, since the enumerators are names that could be macros on a conforming system. Do you have a specific suggestion for something that I could re-word?

rsmith edited edge metadata.Jan 23 2017, 11:16 AM

This makes sense to me; the current names seem pretty much optimally chosen to collide with C library functions (particularly ones that are not required to be #undef'd by a conforming implementation), as they are names we *know* that some C libraries provide as a non-conforming extension. Eli, can you make your peace with this, or do you still prefer that we #undef these names?

efriedma added a comment.Jan 23 2017, 12:23 PM

I guess it's okay.

I think I would prefer the prefix to spell out LibFunc; LF is a little confusing.

dlj updated this revision to Diff 85452.Jan 23 2017, 2:24 PM
  • Changed LF_ to LibFunc_.
Harbormaster completed remote builds in B3202: Diff 85452.Jan 23 2017, 2:24 PM
dlj updated this revision to Diff 85456.Jan 23 2017, 2:32 PM
  • Re-flowed/tweaked some references that make the diff ugly.
efriedma accepted this revision.Jan 23 2017, 3:21 PM

LGTM with a couple minor tweaks. (If you don't have commit access, upload an updated version and ping me.)

lib/Transforms/Scalar/DeadStoreElimination.cpp
147

Not sure why you're changing this.

lib/Transforms/Scalar/MemCpyOptimizer.cpp
1277

?

This revision is now accepted and ready to land.Jan 23 2017, 3:21 PM
dlj marked an inline comment as done.Jan 23 2017, 3:25 PM
dlj added inline comments.
lib/Transforms/Scalar/DeadStoreElimination.cpp
147

Looks like a clang-tidy fix to me. (Un-)fixed.

dlj updated this revision to Diff 85470.Jan 23 2017, 3:26 PM
  • Address review comments.
Closed by commit rL292848: [Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC) (authored by dlj). · Explain WhyJan 23 2017, 3:27 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
include/
llvm/
Analysis/
78 lines
2 lines
Transforms/
Utils/
4 lines
lib/
Analysis/
4 lines
176 lines
96 lines
4 lines
1138 lines
116 lines
CodeGen/
SelectionDAG/
2 lines
114 lines
LTO/
2 lines
Target/
PowerPC/
68 lines
Transforms/
IPO/
4 lines
Scalar/
12 lines
6 lines
4 lines
10 lines
Utils/
392 lines
182 lines
2 lines
316 lines
unittests/
Analysis/
8 lines

Diff 85456

include/llvm/Analysis/TargetLibraryInfo.h

Show All 24 Lines
/// Function 'VectorFnName' is equivalent to 'ScalarFnName' vectorized /// Function 'VectorFnName' is equivalent to 'ScalarFnName' vectorized
/// by a factor 'VectorizationFactor'. /// by a factor 'VectorizationFactor'.
struct VecDesc { struct VecDesc {
StringRef ScalarFnName; StringRef ScalarFnName;
StringRef VectorFnName; StringRef VectorFnName;
unsigned VectorizationFactor; unsigned VectorizationFactor;
}; };
namespace LibFunc { enum LibFunc {
enum Func {
#define TLI_DEFINE_ENUM #define TLI_DEFINE_ENUM
#include "llvm/Analysis/TargetLibraryInfo.def" #include "llvm/Analysis/TargetLibraryInfo.def"
NumLibFuncs NumLibFuncs
}; };
}
/// Implementation of the target library information. /// Implementation of the target library information.
/// ///
/// This class constructs tables that hold the target library information and /// This class constructs tables that hold the target library information and
/// make it available. However, it is somewhat expensive to compute and only /// make it available. However, it is somewhat expensive to compute and only
/// depends on the triple. So users typically interact with the \c /// depends on the triple. So users typically interact with the \c
/// TargetLibraryInfo wrapper below. /// TargetLibraryInfo wrapper below.
class TargetLibraryInfoImpl { class TargetLibraryInfoImpl {
friend class TargetLibraryInfo; friend class TargetLibraryInfo;
unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4]; unsigned char AvailableArray[(NumLibFuncs+3)/4];
llvm::DenseMap<unsigned, std::string> CustomNames; llvm::DenseMap<unsigned, std::string> CustomNames;
static StringRef const StandardNames[LibFunc::NumLibFuncs]; static StringRef const StandardNames[NumLibFuncs];
bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param; bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param;
enum AvailabilityState { enum AvailabilityState {
StandardName = 3, // (memset to all ones) StandardName = 3, // (memset to all ones)
CustomName = 1, CustomName = 1,
Unavailable = 0 // (memset to all zeros) Unavailable = 0 // (memset to all zeros)
}; };
void setState(LibFunc::Func F, AvailabilityState State) { void setState(LibFunc F, AvailabilityState State) {
AvailableArray[F/4] &= ~(3 << 2*(F&3)); AvailableArray[F/4] &= ~(3 << 2*(F&3));
AvailableArray[F/4] |= State << 2*(F&3); AvailableArray[F/4] |= State << 2*(F&3);
} }
AvailabilityState getState(LibFunc::Func F) const { AvailabilityState getState(LibFunc F) const {
return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3); return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
} }
/// Vectorization descriptors - sorted by ScalarFnName. /// Vectorization descriptors - sorted by ScalarFnName.
std::vector<VecDesc> VectorDescs; std::vector<VecDesc> VectorDescs;
/// Scalarization descriptors - same content as VectorDescs but sorted based /// Scalarization descriptors - same content as VectorDescs but sorted based
/// on VectorFnName rather than ScalarFnName. /// on VectorFnName rather than ScalarFnName.
std::vector<VecDesc> ScalarDescs; std::vector<VecDesc> ScalarDescs;
/// Return true if the function type FTy is valid for the library function /// Return true if the function type FTy is valid for the library function
/// F, regardless of whether the function is available. /// F, regardless of whether the function is available.
bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc::Func F, bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F,
const DataLayout *DL) const; const DataLayout *DL) const;
public: public:
/// List of known vector-functions libraries. /// List of known vector-functions libraries.
/// ///
/// The vector-functions library defines, which functions are vectorizable /// The vector-functions library defines, which functions are vectorizable
/// and with which factor. The library can be specified by either frontend, /// and with which factor. The library can be specified by either frontend,
/// or a commandline option, and then used by /// or a commandline option, and then used by
Show All 13 Linespublic:
TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI); TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI);
TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI); TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI);
TargetLibraryInfoImpl &operator=(TargetLibraryInfoImpl &&TLI); TargetLibraryInfoImpl &operator=(TargetLibraryInfoImpl &&TLI);
/// Searches for a particular function name. /// Searches for a particular function name.
/// ///
/// If it is one of the known library functions, return true and set F to the /// If it is one of the known library functions, return true and set F to the
/// corresponding value. /// corresponding value.
bool getLibFunc(StringRef funcName, LibFunc::Func &F) const; bool getLibFunc(StringRef funcName, LibFunc &F) const;
/// Searches for a particular function name, also checking that its type is /// Searches for a particular function name, also checking that its type is
/// valid for the library function matching that name. /// valid for the library function matching that name.
/// ///
/// If it is one of the known library functions, return true and set F to the /// If it is one of the known library functions, return true and set F to the
/// corresponding value. /// corresponding value.
bool getLibFunc(const Function &FDecl, LibFunc::Func &F) const; bool getLibFunc(const Function &FDecl, LibFunc &F) const;
/// Forces a function to be marked as unavailable. /// Forces a function to be marked as unavailable.
void setUnavailable(LibFunc::Func F) { void setUnavailable(LibFunc F) {
setState(F, Unavailable); setState(F, Unavailable);
} }
/// Forces a function to be marked as available. /// Forces a function to be marked as available.
void setAvailable(LibFunc::Func F) { void setAvailable(LibFunc F) {
setState(F, StandardName); setState(F, StandardName);
} }
/// Forces a function to be marked as available and provide an alternate name /// Forces a function to be marked as available and provide an alternate name
/// that must be used. /// that must be used.
void setAvailableWithName(LibFunc::Func F, StringRef Name) { void setAvailableWithName(LibFunc F, StringRef Name) {
if (StandardNames[F] != Name) { if (StandardNames[F] != Name) {
setState(F, CustomName); setState(F, CustomName);
CustomNames[F] = Name; CustomNames[F] = Name;
assert(CustomNames.find(F) != CustomNames.end()); assert(CustomNames.find(F) != CustomNames.end());
} else { } else {
setState(F, StandardName); setState(F, StandardName);
} }
} }
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
Impl = TLI.Impl; Impl = TLI.Impl;
return *this; return *this;
} }
/// Searches for a particular function name. /// Searches for a particular function name.
/// ///
/// If it is one of the known library functions, return true and set F to the /// If it is one of the known library functions, return true and set F to the
/// corresponding value. /// corresponding value.
bool getLibFunc(StringRef funcName, LibFunc::Func &F) const { bool getLibFunc(StringRef funcName, LibFunc &F) const {
return Impl->getLibFunc(funcName, F); return Impl->getLibFunc(funcName, F);
} }
bool getLibFunc(const Function &FDecl, LibFunc::Func &F) const { bool getLibFunc(const Function &FDecl, LibFunc &F) const {
return Impl->getLibFunc(FDecl, F); return Impl->getLibFunc(FDecl, F);
} }
/// Tests whether a library function is available. /// Tests whether a library function is available.
bool has(LibFunc::Func F) const { bool has(LibFunc F) const {
return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable; return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
} }
bool isFunctionVectorizable(StringRef F, unsigned VF) const { bool isFunctionVectorizable(StringRef F, unsigned VF) const {
return Impl->isFunctionVectorizable(F, VF); return Impl->isFunctionVectorizable(F, VF);
} }
bool isFunctionVectorizable(StringRef F) const { bool isFunctionVectorizable(StringRef F) const {
return Impl->isFunctionVectorizable(F); return Impl->isFunctionVectorizable(F);
} }
StringRef getVectorizedFunction(StringRef F, unsigned VF) const { StringRef getVectorizedFunction(StringRef F, unsigned VF) const {
return Impl->getVectorizedFunction(F, VF); return Impl->getVectorizedFunction(F, VF);
} }
/// Tests if the function is both available and a candidate for optimized code /// Tests if the function is both available and a candidate for optimized code
/// generation. /// generation.
bool hasOptimizedCodeGen(LibFunc::Func F) const { bool hasOptimizedCodeGen(LibFunc F) const {
if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable) if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
return false; return false;
switch (F) { switch (F) {
default: break; default: break;
case LibFunc::copysign: case LibFunc::copysignf: case LibFunc::copysignl: case LibFunc_copysign: case LibFunc_copysignf: case LibFunc_copysignl:
case LibFunc::fabs: case LibFunc::fabsf: case LibFunc::fabsl: case LibFunc_fabs: case LibFunc_fabsf: case LibFunc_fabsl:
case LibFunc::sin: case LibFunc::sinf: case LibFunc::sinl: case LibFunc_sin: case LibFunc_sinf: case LibFunc_sinl:
case LibFunc::cos: case LibFunc::cosf: case LibFunc::cosl: case LibFunc_cos: case LibFunc_cosf: case LibFunc_cosl:
case LibFunc::sqrt: case LibFunc::sqrtf: case LibFunc::sqrtl: case LibFunc_sqrt: case LibFunc_sqrtf: case LibFunc_sqrtl:
case LibFunc::sqrt_finite: case LibFunc::sqrtf_finite: case LibFunc_sqrt_finite: case LibFunc_sqrtf_finite:
case LibFunc::sqrtl_finite: case LibFunc_sqrtl_finite:
case LibFunc::fmax: case LibFunc::fmaxf: case LibFunc::fmaxl: case LibFunc_fmax: case LibFunc_fmaxf: case LibFunc_fmaxl:
case LibFunc::fmin: case LibFunc::fminf: case LibFunc::fminl: case LibFunc_fmin: case LibFunc_fminf: case LibFunc_fminl:
case LibFunc::floor: case LibFunc::floorf: case LibFunc::floorl: case LibFunc_floor: case LibFunc_floorf: case LibFunc_floorl:
case LibFunc::nearbyint: case LibFunc::nearbyintf: case LibFunc::nearbyintl: case LibFunc_nearbyint: case LibFunc_nearbyintf: case LibFunc_nearbyintl:
case LibFunc::ceil: case LibFunc::ceilf: case LibFunc::ceill: case LibFunc_ceil: case LibFunc_ceilf: case LibFunc_ceill:
case LibFunc::rint: case LibFunc::rintf: case LibFunc::rintl: case LibFunc_rint: case LibFunc_rintf: case LibFunc_rintl:
case LibFunc::round: case LibFunc::roundf: case LibFunc::roundl: case LibFunc_round: case LibFunc_roundf: case LibFunc_roundl:
case LibFunc::trunc: case LibFunc::truncf: case LibFunc::truncl: case LibFunc_trunc: case LibFunc_truncf: case LibFunc_truncl:
case LibFunc::log2: case LibFunc::log2f: case LibFunc::log2l: case LibFunc_log2: case LibFunc_log2f: case LibFunc_log2l:
case LibFunc::exp2: case LibFunc::exp2f: case LibFunc::exp2l: case LibFunc_exp2: case LibFunc_exp2f: case LibFunc_exp2l:
case LibFunc::memcmp: case LibFunc::strcmp: case LibFunc::strcpy: case LibFunc_memcmp: case LibFunc_strcmp: case LibFunc_strcpy:
case LibFunc::stpcpy: case LibFunc::strlen: case LibFunc::strnlen: case LibFunc_stpcpy: case LibFunc_strlen: case LibFunc_strnlen:
case LibFunc::memchr: case LibFunc::mempcpy: case LibFunc_memchr: case LibFunc_mempcpy:
return true; return true;
} }
return false; return false;
} }
StringRef getName(LibFunc::Func F) const { StringRef getName(LibFunc F) const {
auto State = Impl->getState(F); auto State = Impl->getState(F);
if (State == TargetLibraryInfoImpl::Unavailable) if (State == TargetLibraryInfoImpl::Unavailable)
return StringRef(); return StringRef();
if (State == TargetLibraryInfoImpl::StandardName) if (State == TargetLibraryInfoImpl::StandardName)
return Impl->StandardNames[F]; return Impl->StandardNames[F];
assert(State == TargetLibraryInfoImpl::CustomName); assert(State == TargetLibraryInfoImpl::CustomName);
return Impl->CustomNames.find(F)->second; return Impl->CustomNames.find(F)->second;
} }
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

include/llvm/Analysis/TargetLibraryInfo.def

Show All 14 Lines
#if !(defined(TLI_DEFINE_ENUM) || defined(TLI_DEFINE_STRING)) #if !(defined(TLI_DEFINE_ENUM) || defined(TLI_DEFINE_STRING))
#error "Must define TLI_DEFINE_ENUM or TLI_DEFINE_STRING for TLI .def." #error "Must define TLI_DEFINE_ENUM or TLI_DEFINE_STRING for TLI .def."
#elif defined(TLI_DEFINE_ENUM) && defined(TLI_DEFINE_STRING) #elif defined(TLI_DEFINE_ENUM) && defined(TLI_DEFINE_STRING)
#error "Can only define one of TLI_DEFINE_ENUM or TLI_DEFINE_STRING at a time." #error "Can only define one of TLI_DEFINE_ENUM or TLI_DEFINE_STRING at a time."
#else #else
// One of TLI_DEFINE_ENUM/STRING are defined. // One of TLI_DEFINE_ENUM/STRING are defined.
#if defined(TLI_DEFINE_ENUM) #if defined(TLI_DEFINE_ENUM)
#define TLI_DEFINE_ENUM_INTERNAL(enum_variant) enum_variant, #define TLI_DEFINE_ENUM_INTERNAL(enum_variant) LibFunc_##enum_variant,
#define TLI_DEFINE_STRING_INTERNAL(string_repr) #define TLI_DEFINE_STRING_INTERNAL(string_repr)
#else #else
#define TLI_DEFINE_ENUM_INTERNAL(enum_variant) #define TLI_DEFINE_ENUM_INTERNAL(enum_variant)
#define TLI_DEFINE_STRING_INTERNAL(string_repr) string_repr, #define TLI_DEFINE_STRING_INTERNAL(string_repr) string_repr,
#endif #endif
/// void *new(unsigned int); /// void *new(unsigned int);
TLI_DEFINE_ENUM_INTERNAL(msvc_new_int) TLI_DEFINE_ENUM_INTERNAL(msvc_new_int)
▲ Show 20 Lines • Show All 1,096 Lines • Show Last 20 Lines

include/llvm/Transforms/Utils/SimplifyLibCalls.h

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linespublic:
Value *optimizeCall(CallInst *CI); Value *optimizeCall(CallInst *CI);
private: private:
Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B); Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B);
Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B); Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B);
Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B); Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B);
// Str/Stp cpy are similar enough to be handled in the same functions. // Str/Stp cpy are similar enough to be handled in the same functions.
Value *optimizeStrpCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc::Func Func); Value *optimizeStrpCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc::Func Func); Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
/// \brief Checks whether the call \p CI to a fortified libcall is foldable /// \brief Checks whether the call \p CI to a fortified libcall is foldable
/// to the non-fortified version. /// to the non-fortified version.
bool isFortifiedCallFoldable(CallInst *CI, unsigned ObjSizeOp, bool isFortifiedCallFoldable(CallInst *CI, unsigned ObjSizeOp,
unsigned SizeOp, bool isString); unsigned SizeOp, bool isString);
}; };
/// LibCallSimplifier - This class implements a collection of optimizations /// LibCallSimplifier - This class implements a collection of optimizations
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

lib/Analysis/BasicAliasAnalysis.cpp

Show First 20 Lines • Show All 638 Lines • ▼ Show 20 Lines if (CS.paramHasAttr(ArgIdx + 1, Attribute::WriteOnly))
return true; return true;
// We can bound the aliasing properties of memset_pattern16 just as we can // We can bound the aliasing properties of memset_pattern16 just as we can
// for memcpy/memset. This is particularly important because the // for memcpy/memset. This is particularly important because the
// LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16 // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
// whenever possible. // whenever possible.
// FIXME Consider handling this in InferFunctionAttr.cpp together with other // FIXME Consider handling this in InferFunctionAttr.cpp together with other
// attributes. // attributes.
LibFunc::Func F; LibFunc F;
if (CS.getCalledFunction() && TLI.getLibFunc(*CS.getCalledFunction(), F) && if (CS.getCalledFunction() && TLI.getLibFunc(*CS.getCalledFunction(), F) &&
F == LibFunc::memset_pattern16 && TLI.has(F)) F == LibFunc_memset_pattern16 && TLI.has(F))
if (ArgIdx == 0) if (ArgIdx == 0)
return true; return true;
// TODO: memset_pattern4, memset_pattern8 // TODO: memset_pattern4, memset_pattern8
// TODO: _chk variants // TODO: _chk variants
// TODO: strcmp, strcpy // TODO: strcmp, strcpy
return false; return false;
▲ Show 20 Lines • Show All 1,156 Lines • Show Last 20 Lines

lib/Analysis/ConstantFolding.cpp

Show First 20 Lines • Show All 1,633 Lines • ▼ Show 20 Lines if (auto *Op = dyn_cast<ConstantFP>(Operands[0])) {
return ConstantFoldFP(sqrt, V, Ty); return ConstantFoldFP(sqrt, V, Ty);
} }
if (!TLI) if (!TLI)
return nullptr; return nullptr;
switch (Name[0]) { switch (Name[0]) {
case 'a': case 'a':
if ((Name == "acos" && TLI->has(LibFunc::acos)) || if ((Name == "acos" && TLI->has(LibFunc_acos)) ||
(Name == "acosf" && TLI->has(LibFunc::acosf))) (Name == "acosf" && TLI->has(LibFunc_acosf)))
return ConstantFoldFP(acos, V, Ty); return ConstantFoldFP(acos, V, Ty);
else if ((Name == "asin" && TLI->has(LibFunc::asin)) || else if ((Name == "asin" && TLI->has(LibFunc_asin)) ||
(Name == "asinf" && TLI->has(LibFunc::asinf))) (Name == "asinf" && TLI->has(LibFunc_asinf)))
return ConstantFoldFP(asin, V, Ty); return ConstantFoldFP(asin, V, Ty);
else if ((Name == "atan" && TLI->has(LibFunc::atan)) || else if ((Name == "atan" && TLI->has(LibFunc_atan)) ||
(Name == "atanf" && TLI->has(LibFunc::atanf))) (Name == "atanf" && TLI->has(LibFunc_atanf)))
return ConstantFoldFP(atan, V, Ty); return ConstantFoldFP(atan, V, Ty);
break; break;
case 'c': case 'c':
if ((Name == "ceil" && TLI->has(LibFunc::ceil)) || if ((Name == "ceil" && TLI->has(LibFunc_ceil)) ||
(Name == "ceilf" && TLI->has(LibFunc::ceilf))) (Name == "ceilf" && TLI->has(LibFunc_ceilf)))
return ConstantFoldFP(ceil, V, Ty); return ConstantFoldFP(ceil, V, Ty);
else if ((Name == "cos" && TLI->has(LibFunc::cos)) || else if ((Name == "cos" && TLI->has(LibFunc_cos)) ||
(Name == "cosf" && TLI->has(LibFunc::cosf))) (Name == "cosf" && TLI->has(LibFunc_cosf)))
return ConstantFoldFP(cos, V, Ty); return ConstantFoldFP(cos, V, Ty);
else if ((Name == "cosh" && TLI->has(LibFunc::cosh)) || else if ((Name == "cosh" && TLI->has(LibFunc_cosh)) ||
(Name == "coshf" && TLI->has(LibFunc::coshf))) (Name == "coshf" && TLI->has(LibFunc_coshf)))
return ConstantFoldFP(cosh, V, Ty); return ConstantFoldFP(cosh, V, Ty);
break; break;
case 'e': case 'e':
if ((Name == "exp" && TLI->has(LibFunc::exp)) || if ((Name == "exp" && TLI->has(LibFunc_exp)) ||
(Name == "expf" && TLI->has(LibFunc::expf))) (Name == "expf" && TLI->has(LibFunc_expf)))
return ConstantFoldFP(exp, V, Ty); return ConstantFoldFP(exp, V, Ty);
if ((Name == "exp2" && TLI->has(LibFunc::exp2)) || if ((Name == "exp2" && TLI->has(LibFunc_exp2)) ||
(Name == "exp2f" && TLI->has(LibFunc::exp2f))) (Name == "exp2f" && TLI->has(LibFunc_exp2f)))
// Constant fold exp2(x) as pow(2,x) in case the host doesn't have a // Constant fold exp2(x) as pow(2,x) in case the host doesn't have a
// C99 library. // C99 library.
return ConstantFoldBinaryFP(pow, 2.0, V, Ty); return ConstantFoldBinaryFP(pow, 2.0, V, Ty);
break; break;
case 'f': case 'f':
if ((Name == "fabs" && TLI->has(LibFunc::fabs)) || if ((Name == "fabs" && TLI->has(LibFunc_fabs)) ||
(Name == "fabsf" && TLI->has(LibFunc::fabsf))) (Name == "fabsf" && TLI->has(LibFunc_fabsf)))
return ConstantFoldFP(fabs, V, Ty); return ConstantFoldFP(fabs, V, Ty);
else if ((Name == "floor" && TLI->has(LibFunc::floor)) || else if ((Name == "floor" && TLI->has(LibFunc_floor)) ||
(Name == "floorf" && TLI->has(LibFunc::floorf))) (Name == "floorf" && TLI->has(LibFunc_floorf)))
return ConstantFoldFP(floor, V, Ty); return ConstantFoldFP(floor, V, Ty);
break; break;
case 'l': case 'l':
if ((Name == "log" && V > 0 && TLI->has(LibFunc::log)) || if ((Name == "log" && V > 0 && TLI->has(LibFunc_log)) ||
(Name == "logf" && V > 0 && TLI->has(LibFunc::logf))) (Name == "logf" && V > 0 && TLI->has(LibFunc_logf)))
return ConstantFoldFP(log, V, Ty); return ConstantFoldFP(log, V, Ty);
else if ((Name == "log10" && V > 0 && TLI->has(LibFunc::log10)) || else if ((Name == "log10" && V > 0 && TLI->has(LibFunc_log10)) ||
(Name == "log10f" && V > 0 && TLI->has(LibFunc::log10f))) (Name == "log10f" && V > 0 && TLI->has(LibFunc_log10f)))
return ConstantFoldFP(log10, V, Ty); return ConstantFoldFP(log10, V, Ty);
break; break;
case 'r': case 'r':
if ((Name == "round" && TLI->has(LibFunc::round)) || if ((Name == "round" && TLI->has(LibFunc_round)) ||
(Name == "roundf" && TLI->has(LibFunc::roundf))) (Name == "roundf" && TLI->has(LibFunc_roundf)))
return ConstantFoldFP(round, V, Ty); return ConstantFoldFP(round, V, Ty);
case 's': case 's':
if ((Name == "sin" && TLI->has(LibFunc::sin)) || if ((Name == "sin" && TLI->has(LibFunc_sin)) ||
(Name == "sinf" && TLI->has(LibFunc::sinf))) (Name == "sinf" && TLI->has(LibFunc_sinf)))
return ConstantFoldFP(sin, V, Ty); return ConstantFoldFP(sin, V, Ty);
else if ((Name == "sinh" && TLI->has(LibFunc::sinh)) || else if ((Name == "sinh" && TLI->has(LibFunc_sinh)) ||
(Name == "sinhf" && TLI->has(LibFunc::sinhf))) (Name == "sinhf" && TLI->has(LibFunc_sinhf)))
return ConstantFoldFP(sinh, V, Ty); return ConstantFoldFP(sinh, V, Ty);
else if ((Name == "sqrt" && V >= 0 && TLI->has(LibFunc::sqrt)) || else if ((Name == "sqrt" && V >= 0 && TLI->has(LibFunc_sqrt)) ||
(Name == "sqrtf" && V >= 0 && TLI->has(LibFunc::sqrtf))) (Name == "sqrtf" && V >= 0 && TLI->has(LibFunc_sqrtf)))
return ConstantFoldFP(sqrt, V, Ty); return ConstantFoldFP(sqrt, V, Ty);
break; break;
case 't': case 't':
if ((Name == "tan" && TLI->has(LibFunc::tan)) || if ((Name == "tan" && TLI->has(LibFunc_tan)) ||
(Name == "tanf" && TLI->has(LibFunc::tanf))) (Name == "tanf" && TLI->has(LibFunc_tanf)))
return ConstantFoldFP(tan, V, Ty); return ConstantFoldFP(tan, V, Ty);
else if ((Name == "tanh" && TLI->has(LibFunc::tanh)) || else if ((Name == "tanh" && TLI->has(LibFunc_tanh)) ||
(Name == "tanhf" && TLI->has(LibFunc::tanhf))) (Name == "tanhf" && TLI->has(LibFunc_tanhf)))
return ConstantFoldFP(tanh, V, Ty); return ConstantFoldFP(tanh, V, Ty);
break; break;
default: default:
break; break;
} }
return nullptr; return nullptr;
} }
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines if (auto *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
if (IntrinsicID == Intrinsic::maxnum) { if (IntrinsicID == Intrinsic::maxnum) {
const APFloat &C1 = Op1->getValueAPF(); const APFloat &C1 = Op1->getValueAPF();
const APFloat &C2 = Op2->getValueAPF(); const APFloat &C2 = Op2->getValueAPF();
return ConstantFP::get(Ty->getContext(), maxnum(C1, C2)); return ConstantFP::get(Ty->getContext(), maxnum(C1, C2));
} }
if (!TLI) if (!TLI)
return nullptr; return nullptr;
if ((Name == "pow" && TLI->has(LibFunc::pow)) || if ((Name == "pow" && TLI->has(LibFunc_pow)) ||
(Name == "powf" && TLI->has(LibFunc::powf))) (Name == "powf" && TLI->has(LibFunc_powf)))
return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty); return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
if ((Name == "fmod" && TLI->has(LibFunc::fmod)) || if ((Name == "fmod" && TLI->has(LibFunc_fmod)) ||
(Name == "fmodf" && TLI->has(LibFunc::fmodf))) (Name == "fmodf" && TLI->has(LibFunc_fmodf)))
return ConstantFoldBinaryFP(fmod, Op1V, Op2V, Ty); return ConstantFoldBinaryFP(fmod, Op1V, Op2V, Ty);
if ((Name == "atan2" && TLI->has(LibFunc::atan2)) || if ((Name == "atan2" && TLI->has(LibFunc_atan2)) ||
(Name == "atan2f" && TLI->has(LibFunc::atan2f))) (Name == "atan2f" && TLI->has(LibFunc_atan2f)))
return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty); return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
} else if (auto *Op2C = dyn_cast<ConstantInt>(Operands[1])) { } else if (auto *Op2C = dyn_cast<ConstantInt>(Operands[1])) {
if (IntrinsicID == Intrinsic::powi && Ty->isHalfTy()) if (IntrinsicID == Intrinsic::powi && Ty->isHalfTy())
return ConstantFP::get(Ty->getContext(), return ConstantFP::get(Ty->getContext(),
APFloat((float)std::pow((float)Op1V, APFloat((float)std::pow((float)Op1V,
(int)Op2C->getZExtValue()))); (int)Op2C->getZExtValue())));
if (IntrinsicID == Intrinsic::powi && Ty->isFloatTy()) if (IntrinsicID == Intrinsic::powi && Ty->isFloatTy())
return ConstantFP::get(Ty->getContext(), return ConstantFP::get(Ty->getContext(),
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Lines
bool llvm::isMathLibCallNoop(CallSite CS, const TargetLibraryInfo *TLI) { bool llvm::isMathLibCallNoop(CallSite CS, const TargetLibraryInfo *TLI) {
// FIXME: Refactor this code; this duplicates logic in LibCallsShrinkWrap // FIXME: Refactor this code; this duplicates logic in LibCallsShrinkWrap
// (and to some extent ConstantFoldScalarCall). // (and to some extent ConstantFoldScalarCall).
Function *F = CS.getCalledFunction(); Function *F = CS.getCalledFunction();
if (!F) if (!F)
return false; return false;
LibFunc::Func Func; LibFunc Func;
if (!TLI || !TLI->getLibFunc(*F, Func)) if (!TLI || !TLI->getLibFunc(*F, Func))
return false; return false;
if (CS.getNumArgOperands() == 1) { if (CS.getNumArgOperands() == 1) {
if (ConstantFP *OpC = dyn_cast<ConstantFP>(CS.getArgOperand(0))) { if (ConstantFP *OpC = dyn_cast<ConstantFP>(CS.getArgOperand(0))) {
const APFloat &Op = OpC->getValueAPF(); const APFloat &Op = OpC->getValueAPF();
switch (Func) { switch (Func) {
case LibFunc::logl: case LibFunc_logl:
case LibFunc::log: case LibFunc_log:
case LibFunc::logf: case LibFunc_logf:
case LibFunc::log2l: case LibFunc_log2l:
case LibFunc::log2: case LibFunc_log2:
case LibFunc::log2f: case LibFunc_log2f:
case LibFunc::log10l: case LibFunc_log10l:
case LibFunc::log10: case LibFunc_log10:
case LibFunc::log10f: case LibFunc_log10f:
return Op.isNaN() || (!Op.isZero() && !Op.isNegative()); return Op.isNaN() || (!Op.isZero() && !Op.isNegative());
case LibFunc::expl: case LibFunc_expl:
case LibFunc::exp: case LibFunc_exp:
case LibFunc::expf: case LibFunc_expf:
// FIXME: These boundaries are slightly conservative. // FIXME: These boundaries are slightly conservative.
if (OpC->getType()->isDoubleTy()) if (OpC->getType()->isDoubleTy())
return Op.compare(APFloat(-745.0)) != APFloat::cmpLessThan && return Op.compare(APFloat(-745.0)) != APFloat::cmpLessThan &&
Op.compare(APFloat(709.0)) != APFloat::cmpGreaterThan; Op.compare(APFloat(709.0)) != APFloat::cmpGreaterThan;
if (OpC->getType()->isFloatTy()) if (OpC->getType()->isFloatTy())
return Op.compare(APFloat(-103.0f)) != APFloat::cmpLessThan && return Op.compare(APFloat(-103.0f)) != APFloat::cmpLessThan &&
Op.compare(APFloat(88.0f)) != APFloat::cmpGreaterThan; Op.compare(APFloat(88.0f)) != APFloat::cmpGreaterThan;
break; break;
case LibFunc::exp2l: case LibFunc_exp2l:
case LibFunc::exp2: case LibFunc_exp2:
case LibFunc::exp2f: case LibFunc_exp2f:
// FIXME: These boundaries are slightly conservative. // FIXME: These boundaries are slightly conservative.
if (OpC->getType()->isDoubleTy()) if (OpC->getType()->isDoubleTy())
return Op.compare(APFloat(-1074.0)) != APFloat::cmpLessThan && return Op.compare(APFloat(-1074.0)) != APFloat::cmpLessThan &&
Op.compare(APFloat(1023.0)) != APFloat::cmpGreaterThan; Op.compare(APFloat(1023.0)) != APFloat::cmpGreaterThan;
if (OpC->getType()->isFloatTy()) if (OpC->getType()->isFloatTy())
return Op.compare(APFloat(-149.0f)) != APFloat::cmpLessThan && return Op.compare(APFloat(-149.0f)) != APFloat::cmpLessThan &&
Op.compare(APFloat(127.0f)) != APFloat::cmpGreaterThan; Op.compare(APFloat(127.0f)) != APFloat::cmpGreaterThan;
break; break;
case LibFunc::sinl: case LibFunc_sinl:
case LibFunc::sin: case LibFunc_sin:
case LibFunc::sinf: case LibFunc_sinf:
case LibFunc::cosl: case LibFunc_cosl:
case LibFunc::cos: case LibFunc_cos:
case LibFunc::cosf: case LibFunc_cosf:
return !Op.isInfinity(); return !Op.isInfinity();
case LibFunc::tanl: case LibFunc_tanl:
case LibFunc::tan: case LibFunc_tan:
case LibFunc::tanf: { case LibFunc_tanf: {
// FIXME: Stop using the host math library. // FIXME: Stop using the host math library.
// FIXME: The computation isn't done in the right precision. // FIXME: The computation isn't done in the right precision.
Type *Ty = OpC->getType(); Type *Ty = OpC->getType();
if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy()) { if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy()) {
double OpV = getValueAsDouble(OpC); double OpV = getValueAsDouble(OpC);
return ConstantFoldFP(tan, OpV, Ty) != nullptr; return ConstantFoldFP(tan, OpV, Ty) != nullptr;
} }
break; break;
} }
case LibFunc::asinl: case LibFunc_asinl:
case LibFunc::asin: case LibFunc_asin:
case LibFunc::asinf: case LibFunc_asinf:
case LibFunc::acosl: case LibFunc_acosl:
case LibFunc::acos: case LibFunc_acos:
case LibFunc::acosf: case LibFunc_acosf:
return Op.compare(APFloat(Op.getSemantics(), "-1")) != return Op.compare(APFloat(Op.getSemantics(), "-1")) !=
APFloat::cmpLessThan && APFloat::cmpLessThan &&
Op.compare(APFloat(Op.getSemantics(), "1")) != Op.compare(APFloat(Op.getSemantics(), "1")) !=
APFloat::cmpGreaterThan; APFloat::cmpGreaterThan;
case LibFunc::sinh: case LibFunc_sinh:
case LibFunc::cosh: case LibFunc_cosh:
case LibFunc::sinhf: case LibFunc_sinhf:
case LibFunc::coshf: case LibFunc_coshf:
case LibFunc::sinhl: case LibFunc_sinhl:
case LibFunc::coshl: case LibFunc_coshl:
// FIXME: These boundaries are slightly conservative. // FIXME: These boundaries are slightly conservative.
if (OpC->getType()->isDoubleTy()) if (OpC->getType()->isDoubleTy())
return Op.compare(APFloat(-710.0)) != APFloat::cmpLessThan && return Op.compare(APFloat(-710.0)) != APFloat::cmpLessThan &&
Op.compare(APFloat(710.0)) != APFloat::cmpGreaterThan; Op.compare(APFloat(710.0)) != APFloat::cmpGreaterThan;
if (OpC->getType()->isFloatTy()) if (OpC->getType()->isFloatTy())
return Op.compare(APFloat(-89.0f)) != APFloat::cmpLessThan && return Op.compare(APFloat(-89.0f)) != APFloat::cmpLessThan &&
Op.compare(APFloat(89.0f)) != APFloat::cmpGreaterThan; Op.compare(APFloat(89.0f)) != APFloat::cmpGreaterThan;
break; break;
case LibFunc::sqrtl: case LibFunc_sqrtl:
case LibFunc::sqrt: case LibFunc_sqrt:
case LibFunc::sqrtf: case LibFunc_sqrtf:
return Op.isNaN() || Op.isZero() || !Op.isNegative(); return Op.isNaN() || Op.isZero() || !Op.isNegative();
// FIXME: Add more functions: sqrt_finite, atanh, expm1, log1p, // FIXME: Add more functions: sqrt_finite, atanh, expm1, log1p,
// maybe others? // maybe others?
default: default:
break; break;
} }
} }
} }
if (CS.getNumArgOperands() == 2) { if (CS.getNumArgOperands() == 2) {
ConstantFP *Op0C = dyn_cast<ConstantFP>(CS.getArgOperand(0)); ConstantFP *Op0C = dyn_cast<ConstantFP>(CS.getArgOperand(0));
ConstantFP *Op1C = dyn_cast<ConstantFP>(CS.getArgOperand(1)); ConstantFP *Op1C = dyn_cast<ConstantFP>(CS.getArgOperand(1));
if (Op0C && Op1C) { if (Op0C && Op1C) {
const APFloat &Op0 = Op0C->getValueAPF(); const APFloat &Op0 = Op0C->getValueAPF();
const APFloat &Op1 = Op1C->getValueAPF(); const APFloat &Op1 = Op1C->getValueAPF();
switch (Func) { switch (Func) {
case LibFunc::powl: case LibFunc_powl:
case LibFunc::pow: case LibFunc_pow:
case LibFunc::powf: { case LibFunc_powf: {
// FIXME: Stop using the host math library. // FIXME: Stop using the host math library.
// FIXME: The computation isn't done in the right precision. // FIXME: The computation isn't done in the right precision.
Type *Ty = Op0C->getType(); Type *Ty = Op0C->getType();
if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy()) { if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy()) {
if (Ty == Op1C->getType()) { if (Ty == Op1C->getType()) {
double Op0V = getValueAsDouble(Op0C); double Op0V = getValueAsDouble(Op0C);
double Op1V = getValueAsDouble(Op1C); double Op1V = getValueAsDouble(Op1C);
return ConstantFoldBinaryFP(pow, Op0V, Op1V, Ty) != nullptr; return ConstantFoldBinaryFP(pow, Op0V, Op1V, Ty) != nullptr;
} }
} }
break; break;
} }
case LibFunc::fmodl: case LibFunc_fmodl:
case LibFunc::fmod: case LibFunc_fmod:
case LibFunc::fmodf: case LibFunc_fmodf:
return Op0.isNaN() || Op1.isNaN() || return Op0.isNaN() || Op1.isNaN() ||
(!Op0.isInfinity() && !Op1.isZero()); (!Op0.isInfinity() && !Op1.isZero());
default: default:
break; break;
} }
} }
} }
return false; return false;
} }

lib/Analysis/MemoryBuiltins.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesstruct AllocFnsTy {
AllocType AllocTy; AllocType AllocTy;
unsigned NumParams; unsigned NumParams;
// First and Second size parameters (or -1 if unused) // First and Second size parameters (or -1 if unused)
int FstParam, SndParam; int FstParam, SndParam;
}; };
// FIXME: certain users need more information. E.g., SimplifyLibCalls needs to // FIXME: certain users need more information. E.g., SimplifyLibCalls needs to
// know which functions are nounwind, noalias, nocapture parameters, etc. // know which functions are nounwind, noalias, nocapture parameters, etc.
static const std::pair<LibFunc::Func, AllocFnsTy> AllocationFnData[] = { static const std::pair<LibFunc, AllocFnsTy> AllocationFnData[] = {
{LibFunc::malloc, {MallocLike, 1, 0, -1}}, {LibFunc_malloc, {MallocLike, 1, 0, -1}},
{LibFunc::valloc, {MallocLike, 1, 0, -1}}, {LibFunc_valloc, {MallocLike, 1, 0, -1}},
{LibFunc::Znwj, {OpNewLike, 1, 0, -1}}, // new(unsigned int) {LibFunc_Znwj, {OpNewLike, 1, 0, -1}}, // new(unsigned int)
{LibFunc::ZnwjRKSt9nothrow_t, {MallocLike, 2, 0, -1}}, // new(unsigned int, nothrow) {LibFunc_ZnwjRKSt9nothrow_t, {MallocLike, 2, 0, -1}}, // new(unsigned int, nothrow)
{LibFunc::Znwm, {OpNewLike, 1, 0, -1}}, // new(unsigned long) {LibFunc_Znwm, {OpNewLike, 1, 0, -1}}, // new(unsigned long)
{LibFunc::ZnwmRKSt9nothrow_t, {MallocLike, 2, 0, -1}}, // new(unsigned long, nothrow) {LibFunc_ZnwmRKSt9nothrow_t, {MallocLike, 2, 0, -1}}, // new(unsigned long, nothrow)
{LibFunc::Znaj, {OpNewLike, 1, 0, -1}}, // new[](unsigned int) {LibFunc_Znaj, {OpNewLike, 1, 0, -1}}, // new[](unsigned int)
{LibFunc::ZnajRKSt9nothrow_t, {MallocLike, 2, 0, -1}}, // new[](unsigned int, nothrow) {LibFunc_ZnajRKSt9nothrow_t, {MallocLike, 2, 0, -1}}, // new[](unsigned int, nothrow)
{LibFunc::Znam, {OpNewLike, 1, 0, -1}}, // new[](unsigned long) {LibFunc_Znam, {OpNewLike, 1, 0, -1}}, // new[](unsigned long)
{LibFunc::ZnamRKSt9nothrow_t, {MallocLike, 2, 0, -1}}, // new[](unsigned long, nothrow) {LibFunc_ZnamRKSt9nothrow_t, {MallocLike, 2, 0, -1}}, // new[](unsigned long, nothrow)
{LibFunc::msvc_new_int, {OpNewLike, 1, 0, -1}}, // new(unsigned int) {LibFunc_msvc_new_int, {OpNewLike, 1, 0, -1}}, // new(unsigned int)
{LibFunc::msvc_new_int_nothrow, {MallocLike, 2, 0, -1}}, // new(unsigned int, nothrow) {LibFunc_msvc_new_int_nothrow, {MallocLike, 2, 0, -1}}, // new(unsigned int, nothrow)
{LibFunc::msvc_new_longlong, {OpNewLike, 1, 0, -1}}, // new(unsigned long long) {LibFunc_msvc_new_longlong, {OpNewLike, 1, 0, -1}}, // new(unsigned long long)
{LibFunc::msvc_new_longlong_nothrow, {MallocLike, 2, 0, -1}}, // new(unsigned long long, nothrow) {LibFunc_msvc_new_longlong_nothrow, {MallocLike, 2, 0, -1}}, // new(unsigned long long, nothrow)
{LibFunc::msvc_new_array_int, {OpNewLike, 1, 0, -1}}, // new[](unsigned int) {LibFunc_msvc_new_array_int, {OpNewLike, 1, 0, -1}}, // new[](unsigned int)
{LibFunc::msvc_new_array_int_nothrow, {MallocLike, 2, 0, -1}}, // new[](unsigned int, nothrow) {LibFunc_msvc_new_array_int_nothrow, {MallocLike, 2, 0, -1}}, // new[](unsigned int, nothrow)
{LibFunc::msvc_new_array_longlong, {OpNewLike, 1, 0, -1}}, // new[](unsigned long long) {LibFunc_msvc_new_array_longlong, {OpNewLike, 1, 0, -1}}, // new[](unsigned long long)
{LibFunc::msvc_new_array_longlong_nothrow, {MallocLike, 2, 0, -1}}, // new[](unsigned long long, nothrow) {LibFunc_msvc_new_array_longlong_nothrow, {MallocLike, 2, 0, -1}}, // new[](unsigned long long, nothrow)
{LibFunc::calloc, {CallocLike, 2, 0, 1}}, {LibFunc_calloc, {CallocLike, 2, 0, 1}},
{LibFunc::realloc, {ReallocLike, 2, 1, -1}}, {LibFunc_realloc, {ReallocLike, 2, 1, -1}},
{LibFunc::reallocf, {ReallocLike, 2, 1, -1}}, {LibFunc_reallocf, {ReallocLike, 2, 1, -1}},
{LibFunc::strdup, {StrDupLike, 1, -1, -1}}, {LibFunc_strdup, {StrDupLike, 1, -1, -1}},
{LibFunc::strndup, {StrDupLike, 2, 1, -1}} {LibFunc_strndup, {StrDupLike, 2, 1, -1}}
// TODO: Handle "int posix_memalign(void **, size_t, size_t)" // TODO: Handle "int posix_memalign(void **, size_t, size_t)"
}; };
static Function *getCalledFunction(const Value *V, bool LookThroughBitCast, static Function *getCalledFunction(const Value *V, bool LookThroughBitCast,
bool &IsNoBuiltin) { bool &IsNoBuiltin) {
// Don't care about intrinsics in this case. // Don't care about intrinsics in this case.
if (isa<IntrinsicInst>(V)) if (isa<IntrinsicInst>(V))
return nullptr; return nullptr;
Show All 16 Lines
/// Returns the allocation data for the given value if it's either a call to a /// Returns the allocation data for the given value if it's either a call to a
/// known allocation function, or a call to a function with the allocsize /// known allocation function, or a call to a function with the allocsize
/// attribute. /// attribute.
static Optional<AllocFnsTy> static Optional<AllocFnsTy>
getAllocationDataForFunction(const Function *Callee, AllocType AllocTy, getAllocationDataForFunction(const Function *Callee, AllocType AllocTy,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
// Make sure that the function is available. // Make sure that the function is available.
StringRef FnName = Callee->getName(); StringRef FnName = Callee->getName();
LibFunc::Func TLIFn; LibFunc TLIFn;
if (!TLI || !TLI->getLibFunc(FnName, TLIFn) || !TLI->has(TLIFn)) if (!TLI || !TLI->getLibFunc(FnName, TLIFn) || !TLI->has(TLIFn))
return None; return None;
const auto *Iter = find_if( const auto *Iter = find_if(
AllocationFnData, [TLIFn](const std::pair<LibFunc::Func, AllocFnsTy> &P) { AllocationFnData, [TLIFn](const std::pair<LibFunc, AllocFnsTy> &P) {
return P.first == TLIFn; return P.first == TLIFn;
}); });
if (Iter == std::end(AllocationFnData)) if (Iter == std::end(AllocationFnData))
return None; return None;
const AllocFnsTy *FnData = &Iter->second; const AllocFnsTy *FnData = &Iter->second;
if ((FnData->AllocTy & AllocTy) != FnData->AllocTy) if ((FnData->AllocTy & AllocTy) != FnData->AllocTy)
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Linesconst CallInst *llvm::isFreeCall(const Value *I, const TargetLibraryInfo *TLI) {
const CallInst *CI = dyn_cast<CallInst>(I); const CallInst *CI = dyn_cast<CallInst>(I);
if (!CI || isa<IntrinsicInst>(CI)) if (!CI || isa<IntrinsicInst>(CI))
return nullptr; return nullptr;
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
if (Callee == nullptr) if (Callee == nullptr)
return nullptr; return nullptr;
StringRef FnName = Callee->getName(); StringRef FnName = Callee->getName();
LibFunc::Func TLIFn; LibFunc TLIFn;
if (!TLI || !TLI->getLibFunc(FnName, TLIFn) || !TLI->has(TLIFn)) if (!TLI || !TLI->getLibFunc(FnName, TLIFn) || !TLI->has(TLIFn))
return nullptr; return nullptr;
unsigned ExpectedNumParams; unsigned ExpectedNumParams;
if (TLIFn == LibFunc::free || if (TLIFn == LibFunc_free ||
TLIFn == LibFunc::ZdlPv || // operator delete(void*) TLIFn == LibFunc_ZdlPv || // operator delete(void*)
TLIFn == LibFunc::ZdaPv || // operator delete[](void*) TLIFn == LibFunc_ZdaPv || // operator delete[](void*)
TLIFn == LibFunc::msvc_delete_ptr32 || // operator delete(void*) TLIFn == LibFunc_msvc_delete_ptr32 || // operator delete(void*)
TLIFn == LibFunc::msvc_delete_ptr64 || // operator delete(void*) TLIFn == LibFunc_msvc_delete_ptr64 || // operator delete(void*)
TLIFn == LibFunc::msvc_delete_array_ptr32 || // operator delete[](void*) TLIFn == LibFunc_msvc_delete_array_ptr32 || // operator delete[](void*)
TLIFn == LibFunc::msvc_delete_array_ptr64) // operator delete[](void*) TLIFn == LibFunc_msvc_delete_array_ptr64) // operator delete[](void*)
ExpectedNumParams = 1; ExpectedNumParams = 1;
else if (TLIFn == LibFunc::ZdlPvj || // delete(void*, uint) else if (TLIFn == LibFunc_ZdlPvj || // delete(void*, uint)
TLIFn == LibFunc::ZdlPvm || // delete(void*, ulong) TLIFn == LibFunc_ZdlPvm || // delete(void*, ulong)
TLIFn == LibFunc::ZdlPvRKSt9nothrow_t || // delete(void*, nothrow) TLIFn == LibFunc_ZdlPvRKSt9nothrow_t || // delete(void*, nothrow)
TLIFn == LibFunc::ZdaPvj || // delete[](void*, uint) TLIFn == LibFunc_ZdaPvj || // delete[](void*, uint)
TLIFn == LibFunc::ZdaPvm || // delete[](void*, ulong) TLIFn == LibFunc_ZdaPvm || // delete[](void*, ulong)
TLIFn == LibFunc::ZdaPvRKSt9nothrow_t || // delete[](void*, nothrow) TLIFn == LibFunc_ZdaPvRKSt9nothrow_t || // delete[](void*, nothrow)
TLIFn == LibFunc::msvc_delete_ptr32_int || // delete(void*, uint) TLIFn == LibFunc_msvc_delete_ptr32_int || // delete(void*, uint)
TLIFn == LibFunc::msvc_delete_ptr64_longlong || // delete(void*, ulonglong) TLIFn == LibFunc_msvc_delete_ptr64_longlong || // delete(void*, ulonglong)
TLIFn == LibFunc::msvc_delete_ptr32_nothrow || // delete(void*, nothrow) TLIFn == LibFunc_msvc_delete_ptr32_nothrow || // delete(void*, nothrow)
TLIFn == LibFunc::msvc_delete_ptr64_nothrow || // delete(void*, nothrow) TLIFn == LibFunc_msvc_delete_ptr64_nothrow || // delete(void*, nothrow)
TLIFn == LibFunc::msvc_delete_array_ptr32_int || // delete[](void*, uint) TLIFn == LibFunc_msvc_delete_array_ptr32_int || // delete[](void*, uint)
TLIFn == LibFunc::msvc_delete_array_ptr64_longlong || // delete[](void*, ulonglong) TLIFn == LibFunc_msvc_delete_array_ptr64_longlong || // delete[](void*, ulonglong)
TLIFn == LibFunc::msvc_delete_array_ptr32_nothrow || // delete[](void*, nothrow) TLIFn == LibFunc_msvc_delete_array_ptr32_nothrow || // delete[](void*, nothrow)
TLIFn == LibFunc::msvc_delete_array_ptr64_nothrow) // delete[](void*, nothrow) TLIFn == LibFunc_msvc_delete_array_ptr64_nothrow) // delete[](void*, nothrow)
ExpectedNumParams = 2; ExpectedNumParams = 2;
else else
return nullptr; return nullptr;
// Check free prototype. // Check free prototype.
// FIXME: workaround for PR5130, this will be obsolete when a nobuiltin // FIXME: workaround for PR5130, this will be obsolete when a nobuiltin
// attribute will exist. // attribute will exist.
FunctionType *FTy = Callee->getFunctionType(); FunctionType *FTy = Callee->getFunctionType();
▲ Show 20 Lines • Show All 531 Lines • Show Last 20 Lines

lib/Analysis/MemoryLocation.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines case Intrinsic::arm_neon_vst1:
Arg, DL.getTypeStoreSize(II->getArgOperand(1)->getType()), AATags); Arg, DL.getTypeStoreSize(II->getArgOperand(1)->getType()), AATags);
} }
} }
// We can bound the aliasing properties of memset_pattern16 just as we can // We can bound the aliasing properties of memset_pattern16 just as we can
// for memcpy/memset. This is particularly important because the // for memcpy/memset. This is particularly important because the
// LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16 // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
// whenever possible. // whenever possible.
LibFunc::Func F; LibFunc F;
if (CS.getCalledFunction() && TLI.getLibFunc(*CS.getCalledFunction(), F) && if (CS.getCalledFunction() && TLI.getLibFunc(*CS.getCalledFunction(), F) &&
F == LibFunc::memset_pattern16 && TLI.has(F)) { F == LibFunc_memset_pattern16 && TLI.has(F)) {
assert((ArgIdx == 0 || ArgIdx == 1) && assert((ArgIdx == 0 || ArgIdx == 1) &&
"Invalid argument index for memset_pattern16"); "Invalid argument index for memset_pattern16");
if (ArgIdx == 1) if (ArgIdx == 1)
return MemoryLocation(Arg, 16, AATags); return MemoryLocation(Arg, 16, AATags);
if (const ConstantInt *LenCI = dyn_cast<ConstantInt>(CS.getArgument(2))) if (const ConstantInt *LenCI = dyn_cast<ConstantInt>(CS.getArgument(2)))
return MemoryLocation(Arg, LenCI->getZExtValue(), AATags); return MemoryLocation(Arg, LenCI->getZExtValue(), AATags);
} }
// FIXME: Handle memset_pattern4 and memset_pattern8 also. // FIXME: Handle memset_pattern4 and memset_pattern8 also.
return MemoryLocation(CS.getArgument(ArgIdx), UnknownSize, AATags); return MemoryLocation(CS.getArgument(ArgIdx), UnknownSize, AATags);
} }

lib/Analysis/TargetLibraryInfo.cpp

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines if (T.getArch() == Triple::mips || T.getArch() == Triple::mipsel ||
ShouldSignExtI32Param = true; ShouldSignExtI32Param = true;
} }
TLI.setShouldExtI32Param(ShouldExtI32Param); TLI.setShouldExtI32Param(ShouldExtI32Param);
TLI.setShouldExtI32Return(ShouldExtI32Return); TLI.setShouldExtI32Return(ShouldExtI32Return);
TLI.setShouldSignExtI32Param(ShouldSignExtI32Param); TLI.setShouldSignExtI32Param(ShouldSignExtI32Param);
if (T.getArch() == Triple::r600 || if (T.getArch() == Triple::r600 ||
T.getArch() == Triple::amdgcn) { T.getArch() == Triple::amdgcn) {
TLI.setUnavailable(LibFunc::ldexp); TLI.setUnavailable(LibFunc_ldexp);
TLI.setUnavailable(LibFunc::ldexpf); TLI.setUnavailable(LibFunc_ldexpf);
TLI.setUnavailable(LibFunc::ldexpl); TLI.setUnavailable(LibFunc_ldexpl);
TLI.setUnavailable(LibFunc::exp10); TLI.setUnavailable(LibFunc_exp10);
TLI.setUnavailable(LibFunc::exp10f); TLI.setUnavailable(LibFunc_exp10f);
TLI.setUnavailable(LibFunc::exp10l); TLI.setUnavailable(LibFunc_exp10l);
TLI.setUnavailable(LibFunc::log10); TLI.setUnavailable(LibFunc_log10);
TLI.setUnavailable(LibFunc::log10f); TLI.setUnavailable(LibFunc_log10f);
TLI.setUnavailable(LibFunc::log10l); TLI.setUnavailable(LibFunc_log10l);
} }
// There are no library implementations of mempcy and memset for AMD gpus and // There are no library implementations of mempcy and memset for AMD gpus and
// these can be difficult to lower in the backend. // these can be difficult to lower in the backend.
if (T.getArch() == Triple::r600 || if (T.getArch() == Triple::r600 ||
T.getArch() == Triple::amdgcn) { T.getArch() == Triple::amdgcn) {
TLI.setUnavailable(LibFunc::memcpy); TLI.setUnavailable(LibFunc_memcpy);
TLI.setUnavailable(LibFunc::memset); TLI.setUnavailable(LibFunc_memset);
TLI.setUnavailable(LibFunc::memset_pattern16); TLI.setUnavailable(LibFunc_memset_pattern16);
return; return;
} }
// memset_pattern16 is only available on iOS 3.0 and Mac OS X 10.5 and later. // memset_pattern16 is only available on iOS 3.0 and Mac OS X 10.5 and later.
// All versions of watchOS support it. // All versions of watchOS support it.
if (T.isMacOSX()) { if (T.isMacOSX()) {
if (T.isMacOSXVersionLT(10, 5)) if (T.isMacOSXVersionLT(10, 5))
TLI.setUnavailable(LibFunc::memset_pattern16); TLI.setUnavailable(LibFunc_memset_pattern16);
} else if (T.isiOS()) { } else if (T.isiOS()) {
if (T.isOSVersionLT(3, 0)) if (T.isOSVersionLT(3, 0))
TLI.setUnavailable(LibFunc::memset_pattern16); TLI.setUnavailable(LibFunc_memset_pattern16);
} else if (!T.isWatchOS()) { } else if (!T.isWatchOS()) {
TLI.setUnavailable(LibFunc::memset_pattern16); TLI.setUnavailable(LibFunc_memset_pattern16);
} }
if (!hasSinCosPiStret(T)) { if (!hasSinCosPiStret(T)) {
TLI.setUnavailable(LibFunc::sinpi); TLI.setUnavailable(LibFunc_sinpi);
TLI.setUnavailable(LibFunc::sinpif); TLI.setUnavailable(LibFunc_sinpif);
TLI.setUnavailable(LibFunc::cospi); TLI.setUnavailable(LibFunc_cospi);
TLI.setUnavailable(LibFunc::cospif); TLI.setUnavailable(LibFunc_cospif);
TLI.setUnavailable(LibFunc::sincospi_stret); TLI.setUnavailable(LibFunc_sincospi_stret);
TLI.setUnavailable(LibFunc::sincospif_stret); TLI.setUnavailable(LibFunc_sincospif_stret);
} }
if (T.isMacOSX() && T.getArch() == Triple::x86 && if (T.isMacOSX() && T.getArch() == Triple::x86 &&
!T.isMacOSXVersionLT(10, 7)) { !T.isMacOSXVersionLT(10, 7)) {
// x86-32 OSX has a scheme where fwrite and fputs (and some other functions // x86-32 OSX has a scheme where fwrite and fputs (and some other functions
// we don't care about) have two versions; on recent OSX, the one we want // we don't care about) have two versions; on recent OSX, the one we want
// has a $UNIX2003 suffix. The two implementations are identical except // has a $UNIX2003 suffix. The two implementations are identical except
// for the return value in some edge cases. However, we don't want to // for the return value in some edge cases. However, we don't want to
// generate code that depends on the old symbols. // generate code that depends on the old symbols.
TLI.setAvailableWithName(LibFunc::fwrite, "fwrite$UNIX2003"); TLI.setAvailableWithName(LibFunc_fwrite, "fwrite$UNIX2003");
TLI.setAvailableWithName(LibFunc::fputs, "fputs$UNIX2003"); TLI.setAvailableWithName(LibFunc_fputs, "fputs$UNIX2003");
} }
// iprintf and friends are only available on XCore and TCE. // iprintf and friends are only available on XCore and TCE.
if (T.getArch() != Triple::xcore && T.getArch() != Triple::tce) { if (T.getArch() != Triple::xcore && T.getArch() != Triple::tce) {
TLI.setUnavailable(LibFunc::iprintf); TLI.setUnavailable(LibFunc_iprintf);
TLI.setUnavailable(LibFunc::siprintf); TLI.setUnavailable(LibFunc_siprintf);
TLI.setUnavailable(LibFunc::fiprintf); TLI.setUnavailable(LibFunc_fiprintf);
} }
if (T.isOSWindows() && !T.isOSCygMing()) { if (T.isOSWindows() && !T.isOSCygMing()) {
// Win32 does not support long double // Win32 does not support long double
TLI.setUnavailable(LibFunc::acosl); TLI.setUnavailable(LibFunc_acosl);
TLI.setUnavailable(LibFunc::asinl); TLI.setUnavailable(LibFunc_asinl);
TLI.setUnavailable(LibFunc::atanl); TLI.setUnavailable(LibFunc_atanl);
TLI.setUnavailable(LibFunc::atan2l); TLI.setUnavailable(LibFunc_atan2l);
TLI.setUnavailable(LibFunc::ceill); TLI.setUnavailable(LibFunc_ceill);
TLI.setUnavailable(LibFunc::copysignl); TLI.setUnavailable(LibFunc_copysignl);
TLI.setUnavailable(LibFunc::cosl); TLI.setUnavailable(LibFunc_cosl);
TLI.setUnavailable(LibFunc::coshl); TLI.setUnavailable(LibFunc_coshl);
TLI.setUnavailable(LibFunc::expl); TLI.setUnavailable(LibFunc_expl);
TLI.setUnavailable(LibFunc::fabsf); // Win32 and Win64 both lack fabsf TLI.setUnavailable(LibFunc_fabsf); // Win32 and Win64 both lack fabsf
TLI.setUnavailable(LibFunc::fabsl); TLI.setUnavailable(LibFunc_fabsl);
TLI.setUnavailable(LibFunc::floorl); TLI.setUnavailable(LibFunc_floorl);
TLI.setUnavailable(LibFunc::fmaxl); TLI.setUnavailable(LibFunc_fmaxl);
TLI.setUnavailable(LibFunc::fminl); TLI.setUnavailable(LibFunc_fminl);
TLI.setUnavailable(LibFunc::fmodl); TLI.setUnavailable(LibFunc_fmodl);
TLI.setUnavailable(LibFunc::frexpl); TLI.setUnavailable(LibFunc_frexpl);
TLI.setUnavailable(LibFunc::ldexpf); TLI.setUnavailable(LibFunc_ldexpf);
TLI.setUnavailable(LibFunc::ldexpl); TLI.setUnavailable(LibFunc_ldexpl);
TLI.setUnavailable(LibFunc::logl); TLI.setUnavailable(LibFunc_logl);
TLI.setUnavailable(LibFunc::modfl); TLI.setUnavailable(LibFunc_modfl);
TLI.setUnavailable(LibFunc::powl); TLI.setUnavailable(LibFunc_powl);
TLI.setUnavailable(LibFunc::sinl); TLI.setUnavailable(LibFunc_sinl);
TLI.setUnavailable(LibFunc::sinhl); TLI.setUnavailable(LibFunc_sinhl);
TLI.setUnavailable(LibFunc::sqrtl); TLI.setUnavailable(LibFunc_sqrtl);
TLI.setUnavailable(LibFunc::tanl); TLI.setUnavailable(LibFunc_tanl);
TLI.setUnavailable(LibFunc::tanhl); TLI.setUnavailable(LibFunc_tanhl);
// Win32 only has C89 math // Win32 only has C89 math
TLI.setUnavailable(LibFunc::acosh); TLI.setUnavailable(LibFunc_acosh);
TLI.setUnavailable(LibFunc::acoshf); TLI.setUnavailable(LibFunc_acoshf);
TLI.setUnavailable(LibFunc::acoshl); TLI.setUnavailable(LibFunc_acoshl);
TLI.setUnavailable(LibFunc::asinh); TLI.setUnavailable(LibFunc_asinh);
TLI.setUnavailable(LibFunc::asinhf); TLI.setUnavailable(LibFunc_asinhf);
TLI.setUnavailable(LibFunc::asinhl); TLI.setUnavailable(LibFunc_asinhl);
TLI.setUnavailable(LibFunc::atanh); TLI.setUnavailable(LibFunc_atanh);
TLI.setUnavailable(LibFunc::atanhf); TLI.setUnavailable(LibFunc_atanhf);
TLI.setUnavailable(LibFunc::atanhl); TLI.setUnavailable(LibFunc_atanhl);
TLI.setUnavailable(LibFunc::cbrt); TLI.setUnavailable(LibFunc_cbrt);
TLI.setUnavailable(LibFunc::cbrtf); TLI.setUnavailable(LibFunc_cbrtf);
TLI.setUnavailable(LibFunc::cbrtl); TLI.setUnavailable(LibFunc_cbrtl);
TLI.setUnavailable(LibFunc::exp2); TLI.setUnavailable(LibFunc_exp2);
TLI.setUnavailable(LibFunc::exp2f); TLI.setUnavailable(LibFunc_exp2f);
TLI.setUnavailable(LibFunc::exp2l); TLI.setUnavailable(LibFunc_exp2l);
TLI.setUnavailable(LibFunc::expm1); TLI.setUnavailable(LibFunc_expm1);
TLI.setUnavailable(LibFunc::expm1f); TLI.setUnavailable(LibFunc_expm1f);
TLI.setUnavailable(LibFunc::expm1l); TLI.setUnavailable(LibFunc_expm1l);
TLI.setUnavailable(LibFunc::log2); TLI.setUnavailable(LibFunc_log2);
TLI.setUnavailable(LibFunc::log2f); TLI.setUnavailable(LibFunc_log2f);
TLI.setUnavailable(LibFunc::log2l); TLI.setUnavailable(LibFunc_log2l);
TLI.setUnavailable(LibFunc::log1p); TLI.setUnavailable(LibFunc_log1p);
TLI.setUnavailable(LibFunc::log1pf); TLI.setUnavailable(LibFunc_log1pf);
TLI.setUnavailable(LibFunc::log1pl); TLI.setUnavailable(LibFunc_log1pl);
TLI.setUnavailable(LibFunc::logb); TLI.setUnavailable(LibFunc_logb);
TLI.setUnavailable(LibFunc::logbf); TLI.setUnavailable(LibFunc_logbf);
TLI.setUnavailable(LibFunc::logbl); TLI.setUnavailable(LibFunc_logbl);
TLI.setUnavailable(LibFunc::nearbyint); TLI.setUnavailable(LibFunc_nearbyint);
TLI.setUnavailable(LibFunc::nearbyintf); TLI.setUnavailable(LibFunc_nearbyintf);
TLI.setUnavailable(LibFunc::nearbyintl); TLI.setUnavailable(LibFunc_nearbyintl);
TLI.setUnavailable(LibFunc::rint); TLI.setUnavailable(LibFunc_rint);
TLI.setUnavailable(LibFunc::rintf); TLI.setUnavailable(LibFunc_rintf);
TLI.setUnavailable(LibFunc::rintl); TLI.setUnavailable(LibFunc_rintl);
TLI.setUnavailable(LibFunc::round); TLI.setUnavailable(LibFunc_round);
TLI.setUnavailable(LibFunc::roundf); TLI.setUnavailable(LibFunc_roundf);
TLI.setUnavailable(LibFunc::roundl); TLI.setUnavailable(LibFunc_roundl);
TLI.setUnavailable(LibFunc::trunc); TLI.setUnavailable(LibFunc_trunc);
TLI.setUnavailable(LibFunc::truncf); TLI.setUnavailable(LibFunc_truncf);
TLI.setUnavailable(LibFunc::truncl); TLI.setUnavailable(LibFunc_truncl);
// Win32 provides some C99 math with mangled names // Win32 provides some C99 math with mangled names
TLI.setAvailableWithName(LibFunc::copysign, "_copysign"); TLI.setAvailableWithName(LibFunc_copysign, "_copysign");
if (T.getArch() == Triple::x86) { if (T.getArch() == Triple::x86) {
// Win32 on x86 implements single-precision math functions as macros // Win32 on x86 implements single-precision math functions as macros
TLI.setUnavailable(LibFunc::acosf); TLI.setUnavailable(LibFunc_acosf);
TLI.setUnavailable(LibFunc::asinf); TLI.setUnavailable(LibFunc_asinf);
TLI.setUnavailable(LibFunc::atanf); TLI.setUnavailable(LibFunc_atanf);
TLI.setUnavailable(LibFunc::atan2f); TLI.setUnavailable(LibFunc_atan2f);
TLI.setUnavailable(LibFunc::ceilf); TLI.setUnavailable(LibFunc_ceilf);
TLI.setUnavailable(LibFunc::copysignf); TLI.setUnavailable(LibFunc_copysignf);
TLI.setUnavailable(LibFunc::cosf); TLI.setUnavailable(LibFunc_cosf);
TLI.setUnavailable(LibFunc::coshf); TLI.setUnavailable(LibFunc_coshf);
TLI.setUnavailable(LibFunc::expf); TLI.setUnavailable(LibFunc_expf);
TLI.setUnavailable(LibFunc::floorf); TLI.setUnavailable(LibFunc_floorf);
TLI.setUnavailable(LibFunc::fminf); TLI.setUnavailable(LibFunc_fminf);
TLI.setUnavailable(LibFunc::fmaxf); TLI.setUnavailable(LibFunc_fmaxf);
TLI.setUnavailable(LibFunc::fmodf); TLI.setUnavailable(LibFunc_fmodf);
TLI.setUnavailable(LibFunc::logf); TLI.setUnavailable(LibFunc_logf);
TLI.setUnavailable(LibFunc::log10f); TLI.setUnavailable(LibFunc_log10f);
TLI.setUnavailable(LibFunc::modff); TLI.setUnavailable(LibFunc_modff);
TLI.setUnavailable(LibFunc::powf); TLI.setUnavailable(LibFunc_powf);
TLI.setUnavailable(LibFunc::sinf); TLI.setUnavailable(LibFunc_sinf);
TLI.setUnavailable(LibFunc::sinhf); TLI.setUnavailable(LibFunc_sinhf);
TLI.setUnavailable(LibFunc::sqrtf); TLI.setUnavailable(LibFunc_sqrtf);
TLI.setUnavailable(LibFunc::tanf); TLI.setUnavailable(LibFunc_tanf);
TLI.setUnavailable(LibFunc::tanhf); TLI.setUnavailable(LibFunc_tanhf);
} }
// Win32 does *not* provide provide these functions, but they are // Win32 does *not* provide provide these functions, but they are
// generally available on POSIX-compliant systems: // generally available on POSIX-compliant systems:
TLI.setUnavailable(LibFunc::access); TLI.setUnavailable(LibFunc_access);
TLI.setUnavailable(LibFunc::bcmp); TLI.setUnavailable(LibFunc_bcmp);
TLI.setUnavailable(LibFunc::bcopy); TLI.setUnavailable(LibFunc_bcopy);
TLI.setUnavailable(LibFunc::bzero); TLI.setUnavailable(LibFunc_bzero);
TLI.setUnavailable(LibFunc::chmod); TLI.setUnavailable(LibFunc_chmod);
TLI.setUnavailable(LibFunc::chown); TLI.setUnavailable(LibFunc_chown);
TLI.setUnavailable(LibFunc::closedir); TLI.setUnavailable(LibFunc_closedir);
TLI.setUnavailable(LibFunc::ctermid); TLI.setUnavailable(LibFunc_ctermid);
TLI.setUnavailable(LibFunc::fdopen); TLI.setUnavailable(LibFunc_fdopen);
TLI.setUnavailable(LibFunc::ffs); TLI.setUnavailable(LibFunc_ffs);
TLI.setUnavailable(LibFunc::fileno); TLI.setUnavailable(LibFunc_fileno);
TLI.setUnavailable(LibFunc::flockfile); TLI.setUnavailable(LibFunc_flockfile);
TLI.setUnavailable(LibFunc::fseeko); TLI.setUnavailable(LibFunc_fseeko);
TLI.setUnavailable(LibFunc::fstat); TLI.setUnavailable(LibFunc_fstat);
TLI.setUnavailable(LibFunc::fstatvfs); TLI.setUnavailable(LibFunc_fstatvfs);
TLI.setUnavailable(LibFunc::ftello); TLI.setUnavailable(LibFunc_ftello);
TLI.setUnavailable(LibFunc::ftrylockfile); TLI.setUnavailable(LibFunc_ftrylockfile);
TLI.setUnavailable(LibFunc::funlockfile); TLI.setUnavailable(LibFunc_funlockfile);
TLI.setUnavailable(LibFunc::getc_unlocked); TLI.setUnavailable(LibFunc_getc_unlocked);
TLI.setUnavailable(LibFunc::getitimer); TLI.setUnavailable(LibFunc_getitimer);
TLI.setUnavailable(LibFunc::getlogin_r); TLI.setUnavailable(LibFunc_getlogin_r);
TLI.setUnavailable(LibFunc::getpwnam); TLI.setUnavailable(LibFunc_getpwnam);
TLI.setUnavailable(LibFunc::gettimeofday); TLI.setUnavailable(LibFunc_gettimeofday);
TLI.setUnavailable(LibFunc::htonl); TLI.setUnavailable(LibFunc_htonl);
TLI.setUnavailable(LibFunc::htons); TLI.setUnavailable(LibFunc_htons);
TLI.setUnavailable(LibFunc::lchown); TLI.setUnavailable(LibFunc_lchown);
TLI.setUnavailable(LibFunc::lstat); TLI.setUnavailable(LibFunc_lstat);
TLI.setUnavailable(LibFunc::memccpy); TLI.setUnavailable(LibFunc_memccpy);
TLI.setUnavailable(LibFunc::mkdir); TLI.setUnavailable(LibFunc_mkdir);
TLI.setUnavailable(LibFunc::ntohl); TLI.setUnavailable(LibFunc_ntohl);
TLI.setUnavailable(LibFunc::ntohs); TLI.setUnavailable(LibFunc_ntohs);
TLI.setUnavailable(LibFunc::open); TLI.setUnavailable(LibFunc_open);
TLI.setUnavailable(LibFunc::opendir); TLI.setUnavailable(LibFunc_opendir);
TLI.setUnavailable(LibFunc::pclose); TLI.setUnavailable(LibFunc_pclose);
TLI.setUnavailable(LibFunc::popen); TLI.setUnavailable(LibFunc_popen);
TLI.setUnavailable(LibFunc::pread); TLI.setUnavailable(LibFunc_pread);
TLI.setUnavailable(LibFunc::pwrite); TLI.setUnavailable(LibFunc_pwrite);
TLI.setUnavailable(LibFunc::read); TLI.setUnavailable(LibFunc_read);
TLI.setUnavailable(LibFunc::readlink); TLI.setUnavailable(LibFunc_readlink);
TLI.setUnavailable(LibFunc::realpath); TLI.setUnavailable(LibFunc_realpath);
TLI.setUnavailable(LibFunc::rmdir); TLI.setUnavailable(LibFunc_rmdir);
TLI.setUnavailable(LibFunc::setitimer); TLI.setUnavailable(LibFunc_setitimer);
TLI.setUnavailable(LibFunc::stat); TLI.setUnavailable(LibFunc_stat);
TLI.setUnavailable(LibFunc::statvfs); TLI.setUnavailable(LibFunc_statvfs);
TLI.setUnavailable(LibFunc::stpcpy); TLI.setUnavailable(LibFunc_stpcpy);
TLI.setUnavailable(LibFunc::stpncpy); TLI.setUnavailable(LibFunc_stpncpy);
TLI.setUnavailable(LibFunc::strcasecmp); TLI.setUnavailable(LibFunc_strcasecmp);
TLI.setUnavailable(LibFunc::strncasecmp); TLI.setUnavailable(LibFunc_strncasecmp);
TLI.setUnavailable(LibFunc::times); TLI.setUnavailable(LibFunc_times);
TLI.setUnavailable(LibFunc::uname); TLI.setUnavailable(LibFunc_uname);
TLI.setUnavailable(LibFunc::unlink); TLI.setUnavailable(LibFunc_unlink);
TLI.setUnavailable(LibFunc::unsetenv); TLI.setUnavailable(LibFunc_unsetenv);
TLI.setUnavailable(LibFunc::utime); TLI.setUnavailable(LibFunc_utime);
TLI.setUnavailable(LibFunc::utimes); TLI.setUnavailable(LibFunc_utimes);
TLI.setUnavailable(LibFunc::write); TLI.setUnavailable(LibFunc_write);
// Win32 does *not* provide provide these functions, but they are // Win32 does *not* provide provide these functions, but they are
// specified by C99: // specified by C99:
TLI.setUnavailable(LibFunc::atoll); TLI.setUnavailable(LibFunc_atoll);
TLI.setUnavailable(LibFunc::frexpf); TLI.setUnavailable(LibFunc_frexpf);
TLI.setUnavailable(LibFunc::llabs); TLI.setUnavailable(LibFunc_llabs);
} }
switch (T.getOS()) { switch (T.getOS()) {
case Triple::MacOSX: case Triple::MacOSX:
// exp10 and exp10f are not available on OS X until 10.9 and iOS until 7.0 // exp10 and exp10f are not available on OS X until 10.9 and iOS until 7.0
// and their names are __exp10 and __exp10f. exp10l is not available on // and their names are __exp10 and __exp10f. exp10l is not available on
// OS X or iOS. // OS X or iOS.
TLI.setUnavailable(LibFunc::exp10l); TLI.setUnavailable(LibFunc_exp10l);
if (T.isMacOSXVersionLT(10, 9)) { if (T.isMacOSXVersionLT(10, 9)) {
TLI.setUnavailable(LibFunc::exp10); TLI.setUnavailable(LibFunc_exp10);
TLI.setUnavailable(LibFunc::exp10f); TLI.setUnavailable(LibFunc_exp10f);
} else { } else {
TLI.setAvailableWithName(LibFunc::exp10, "__exp10"); TLI.setAvailableWithName(LibFunc_exp10, "__exp10");
TLI.setAvailableWithName(LibFunc::exp10f, "__exp10f"); TLI.setAvailableWithName(LibFunc_exp10f, "__exp10f");
} }
break; break;
case Triple::IOS: case Triple::IOS:
case Triple::TvOS: case Triple::TvOS:
case Triple::WatchOS: case Triple::WatchOS:
TLI.setUnavailable(LibFunc::exp10l); TLI.setUnavailable(LibFunc_exp10l);
if (!T.isWatchOS() && (T.isOSVersionLT(7, 0) || if (!T.isWatchOS() && (T.isOSVersionLT(7, 0) ||
(T.isOSVersionLT(9, 0) && (T.isOSVersionLT(9, 0) &&
(T.getArch() == Triple::x86 || (T.getArch() == Triple::x86 ||
T.getArch() == Triple::x86_64)))) { T.getArch() == Triple::x86_64)))) {
TLI.setUnavailable(LibFunc::exp10); TLI.setUnavailable(LibFunc_exp10);
TLI.setUnavailable(LibFunc::exp10f); TLI.setUnavailable(LibFunc_exp10f);
} else { } else {
TLI.setAvailableWithName(LibFunc::exp10, "__exp10"); TLI.setAvailableWithName(LibFunc_exp10, "__exp10");
TLI.setAvailableWithName(LibFunc::exp10f, "__exp10f"); TLI.setAvailableWithName(LibFunc_exp10f, "__exp10f");
} }
break; break;
case Triple::Linux: case Triple::Linux:
// exp10, exp10f, exp10l is available on Linux (GLIBC) but are extremely // exp10, exp10f, exp10l is available on Linux (GLIBC) but are extremely
// buggy prior to glibc version 2.18. Until this version is widely deployed // buggy prior to glibc version 2.18. Until this version is widely deployed
// or we have a reasonable detection strategy, we cannot use exp10 reliably // or we have a reasonable detection strategy, we cannot use exp10 reliably
// on Linux. // on Linux.
// //
// Fall through to disable all of them. // Fall through to disable all of them.
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
default: default:
TLI.setUnavailable(LibFunc::exp10); TLI.setUnavailable(LibFunc_exp10);
TLI.setUnavailable(LibFunc::exp10f); TLI.setUnavailable(LibFunc_exp10f);
TLI.setUnavailable(LibFunc::exp10l); TLI.setUnavailable(LibFunc_exp10l);
} }
// ffsl is available on at least Darwin, Mac OS X, iOS, FreeBSD, and // ffsl is available on at least Darwin, Mac OS X, iOS, FreeBSD, and
// Linux (GLIBC): // Linux (GLIBC):
// http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/ffsl.3.html // http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/ffsl.3.html
// http://svn.freebsd.org/base/head/lib/libc/string/ffsl.c // http://svn.freebsd.org/base/head/lib/libc/string/ffsl.c
// http://www.gnu.org/software/gnulib/manual/html_node/ffsl.html // http://www.gnu.org/software/gnulib/manual/html_node/ffsl.html
switch (T.getOS()) { switch (T.getOS()) {
case Triple::Darwin: case Triple::Darwin:
case Triple::MacOSX: case Triple::MacOSX:
case Triple::IOS: case Triple::IOS:
case Triple::TvOS: case Triple::TvOS:
case Triple::WatchOS: case Triple::WatchOS:
case Triple::FreeBSD: case Triple::FreeBSD:
case Triple::Linux: case Triple::Linux:
break; break;
default: default:
TLI.setUnavailable(LibFunc::ffsl); TLI.setUnavailable(LibFunc_ffsl);
} }
// ffsll is available on at least FreeBSD and Linux (GLIBC): // ffsll is available on at least FreeBSD and Linux (GLIBC):
// http://svn.freebsd.org/base/head/lib/libc/string/ffsll.c // http://svn.freebsd.org/base/head/lib/libc/string/ffsll.c
// http://www.gnu.org/software/gnulib/manual/html_node/ffsll.html // http://www.gnu.org/software/gnulib/manual/html_node/ffsll.html
switch (T.getOS()) { switch (T.getOS()) {
case Triple::Darwin: case Triple::Darwin:
case Triple::MacOSX: case Triple::MacOSX:
case Triple::IOS: case Triple::IOS:
case Triple::TvOS: case Triple::TvOS:
case Triple::WatchOS: case Triple::WatchOS:
case Triple::FreeBSD: case Triple::FreeBSD:
case Triple::Linux: case Triple::Linux:
break; break;
default: default:
TLI.setUnavailable(LibFunc::ffsll); TLI.setUnavailable(LibFunc_ffsll);
} }
// The following functions are available on at least FreeBSD: // The following functions are available on at least FreeBSD:
// http://svn.freebsd.org/base/head/lib/libc/string/fls.c // http://svn.freebsd.org/base/head/lib/libc/string/fls.c
// http://svn.freebsd.org/base/head/lib/libc/string/flsl.c // http://svn.freebsd.org/base/head/lib/libc/string/flsl.c
// http://svn.freebsd.org/base/head/lib/libc/string/flsll.c // http://svn.freebsd.org/base/head/lib/libc/string/flsll.c
if (!T.isOSFreeBSD()) { if (!T.isOSFreeBSD()) {
TLI.setUnavailable(LibFunc::fls); TLI.setUnavailable(LibFunc_fls);
TLI.setUnavailable(LibFunc::flsl); TLI.setUnavailable(LibFunc_flsl);
TLI.setUnavailable(LibFunc::flsll); TLI.setUnavailable(LibFunc_flsll);
} }
// The following functions are available on at least Linux: // The following functions are available on at least Linux:
if (!T.isOSLinux()) { if (!T.isOSLinux()) {
TLI.setUnavailable(LibFunc::dunder_strdup); TLI.setUnavailable(LibFunc_dunder_strdup);
TLI.setUnavailable(LibFunc::dunder_strtok_r); TLI.setUnavailable(LibFunc_dunder_strtok_r);
TLI.setUnavailable(LibFunc::dunder_isoc99_scanf); TLI.setUnavailable(LibFunc_dunder_isoc99_scanf);
TLI.setUnavailable(LibFunc::dunder_isoc99_sscanf); TLI.setUnavailable(LibFunc_dunder_isoc99_sscanf);
TLI.setUnavailable(LibFunc::under_IO_getc); TLI.setUnavailable(LibFunc_under_IO_getc);
TLI.setUnavailable(LibFunc::under_IO_putc); TLI.setUnavailable(LibFunc_under_IO_putc);
TLI.setUnavailable(LibFunc::memalign); TLI.setUnavailable(LibFunc_memalign);
TLI.setUnavailable(LibFunc::fopen64); TLI.setUnavailable(LibFunc_fopen64);
TLI.setUnavailable(LibFunc::fseeko64); TLI.setUnavailable(LibFunc_fseeko64);
TLI.setUnavailable(LibFunc::fstat64); TLI.setUnavailable(LibFunc_fstat64);
TLI.setUnavailable(LibFunc::fstatvfs64); TLI.setUnavailable(LibFunc_fstatvfs64);
TLI.setUnavailable(LibFunc::ftello64); TLI.setUnavailable(LibFunc_ftello64);
TLI.setUnavailable(LibFunc::lstat64); TLI.setUnavailable(LibFunc_lstat64);
TLI.setUnavailable(LibFunc::open64); TLI.setUnavailable(LibFunc_open64);
TLI.setUnavailable(LibFunc::stat64); TLI.setUnavailable(LibFunc_stat64);
TLI.setUnavailable(LibFunc::statvfs64); TLI.setUnavailable(LibFunc_statvfs64);
TLI.setUnavailable(LibFunc::tmpfile64); TLI.setUnavailable(LibFunc_tmpfile64);
} }
// As currently implemented in clang, NVPTX code has no standard library to // As currently implemented in clang, NVPTX code has no standard library to
// speak of. Headers provide a standard-ish library implementation, but many // speak of. Headers provide a standard-ish library implementation, but many
// of the signatures are wrong -- for example, many libm functions are not // of the signatures are wrong -- for example, many libm functions are not
// extern "C". // extern "C".
// //
// libdevice, an IR library provided by nvidia, is linked in by the front-end, // libdevice, an IR library provided by nvidia, is linked in by the front-end,
// but only used functions are provided to llvm. Moreover, most of the // but only used functions are provided to llvm. Moreover, most of the
// functions in libdevice don't map precisely to standard library functions. // functions in libdevice don't map precisely to standard library functions.
// //
// FIXME: Having no standard library prevents e.g. many fastmath // FIXME: Having no standard library prevents e.g. many fastmath
// optimizations, so this situation should be fixed. // optimizations, so this situation should be fixed.
if (T.isNVPTX()) { if (T.isNVPTX()) {
TLI.disableAllFunctions(); TLI.disableAllFunctions();
TLI.setAvailable(LibFunc::nvvm_reflect); TLI.setAvailable(LibFunc_nvvm_reflect);
} else { } else {
TLI.setUnavailable(LibFunc::nvvm_reflect); TLI.setUnavailable(LibFunc_nvvm_reflect);
} }
TLI.addVectorizableFunctionsFromVecLib(ClVectorLibrary); TLI.addVectorizableFunctionsFromVecLib(ClVectorLibrary);
} }
TargetLibraryInfoImpl::TargetLibraryInfoImpl() { TargetLibraryInfoImpl::TargetLibraryInfoImpl() {
// Default to everything being available. // Default to everything being available.
memset(AvailableArray, -1, sizeof(AvailableArray)); memset(AvailableArray, -1, sizeof(AvailableArray));
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines if (funcName.empty() || funcName.find('\0') != StringRef::npos)
return StringRef(); return StringRef();
// Check for \01 prefix that is used to mangle __asm declarations and // Check for \01 prefix that is used to mangle __asm declarations and
// strip it if present. // strip it if present.
return GlobalValue::getRealLinkageName(funcName); return GlobalValue::getRealLinkageName(funcName);
} }
bool TargetLibraryInfoImpl::getLibFunc(StringRef funcName, bool TargetLibraryInfoImpl::getLibFunc(StringRef funcName,
LibFunc::Func &F) const { LibFunc &F) const {
StringRef const *Start = &StandardNames[0]; StringRef const *Start = &StandardNames[0];
StringRef const *End = &StandardNames[LibFunc::NumLibFuncs]; StringRef const *End = &StandardNames[NumLibFuncs];
funcName = sanitizeFunctionName(funcName); funcName = sanitizeFunctionName(funcName);
if (funcName.empty()) if (funcName.empty())
return false; return false;
StringRef const *I = std::lower_bound( StringRef const *I = std::lower_bound(
Start, End, funcName, [](StringRef LHS, StringRef RHS) { Start, End, funcName, [](StringRef LHS, StringRef RHS) {
return LHS < RHS; return LHS < RHS;
}); });
if (I != End && *I == funcName) { if (I != End && *I == funcName) {
F = (LibFunc::Func)(I - Start); F = (LibFunc)(I - Start);
return true; return true;
} }
return false; return false;
} }
bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy, bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
LibFunc::Func F, LibFunc F,
const DataLayout *DL) const { const DataLayout *DL) const {
LLVMContext &Ctx = FTy.getContext(); LLVMContext &Ctx = FTy.getContext();
Type *PCharTy = Type::getInt8PtrTy(Ctx); Type *PCharTy = Type::getInt8PtrTy(Ctx);
Type *SizeTTy = DL ? DL->getIntPtrType(Ctx, /*AS=*/0) : nullptr; Type *SizeTTy = DL ? DL->getIntPtrType(Ctx, /*AS=*/0) : nullptr;
auto IsSizeTTy = [SizeTTy](Type *Ty) { auto IsSizeTTy = [SizeTTy](Type *Ty) {
return SizeTTy ? Ty == SizeTTy : Ty->isIntegerTy(); return SizeTTy ? Ty == SizeTTy : Ty->isIntegerTy();
}; };
unsigned NumParams = FTy.getNumParams(); unsigned NumParams = FTy.getNumParams();
switch (F) { switch (F) {
case LibFunc::strlen: case LibFunc_strlen:
return (NumParams == 1 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 1 && FTy.getParamType(0)->isPointerTy() &&
FTy.getReturnType()->isIntegerTy()); FTy.getReturnType()->isIntegerTy());
case LibFunc::strchr: case LibFunc_strchr:
case LibFunc::strrchr: case LibFunc_strrchr:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy() && return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0) == FTy.getReturnType() && FTy.getParamType(0) == FTy.getReturnType() &&
FTy.getParamType(1)->isIntegerTy()); FTy.getParamType(1)->isIntegerTy());
case LibFunc::strtol: case LibFunc_strtol:
case LibFunc::strtod: case LibFunc_strtod:
case LibFunc::strtof: case LibFunc_strtof:
case LibFunc::strtoul: case LibFunc_strtoul:
case LibFunc::strtoll: case LibFunc_strtoll:
case LibFunc::strtold: case LibFunc_strtold:
case LibFunc::strtoull: case LibFunc_strtoull:
return ((NumParams == 2 || NumParams == 3) && return ((NumParams == 2 || NumParams == 3) &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::strcat: case LibFunc_strcat:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy() && return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0) == FTy.getReturnType() && FTy.getParamType(0) == FTy.getReturnType() &&
FTy.getParamType(1) == FTy.getReturnType()); FTy.getParamType(1) == FTy.getReturnType());
case LibFunc::strncat: case LibFunc_strncat:
return (NumParams == 3 && FTy.getReturnType()->isPointerTy() && return (NumParams == 3 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0) == FTy.getReturnType() && FTy.getParamType(0) == FTy.getReturnType() &&
FTy.getParamType(1) == FTy.getReturnType() && FTy.getParamType(1) == FTy.getReturnType() &&
FTy.getParamType(2)->isIntegerTy()); FTy.getParamType(2)->isIntegerTy());
case LibFunc::strcpy_chk: case LibFunc_strcpy_chk:
case LibFunc::stpcpy_chk: case LibFunc_stpcpy_chk:
--NumParams; --NumParams;
if (!IsSizeTTy(FTy.getParamType(NumParams))) if (!IsSizeTTy(FTy.getParamType(NumParams)))
return false; return false;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case LibFunc::strcpy: case LibFunc_strcpy:
case LibFunc::stpcpy: case LibFunc_stpcpy:
return (NumParams == 2 && FTy.getReturnType() == FTy.getParamType(0) && return (NumParams == 2 && FTy.getReturnType() == FTy.getParamType(0) &&
FTy.getParamType(0) == FTy.getParamType(1) && FTy.getParamType(0) == FTy.getParamType(1) &&
FTy.getParamType(0) == PCharTy); FTy.getParamType(0) == PCharTy);
case LibFunc::strncpy_chk: case LibFunc_strncpy_chk:
case LibFunc::stpncpy_chk: case LibFunc_stpncpy_chk:
--NumParams; --NumParams;
if (!IsSizeTTy(FTy.getParamType(NumParams))) if (!IsSizeTTy(FTy.getParamType(NumParams)))
return false; return false;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case LibFunc::strncpy: case LibFunc_strncpy:
case LibFunc::stpncpy: case LibFunc_stpncpy:
return (NumParams == 3 && FTy.getReturnType() == FTy.getParamType(0) && return (NumParams == 3 && FTy.getReturnType() == FTy.getParamType(0) &&
FTy.getParamType(0) == FTy.getParamType(1) && FTy.getParamType(0) == FTy.getParamType(1) &&
FTy.getParamType(0) == PCharTy && FTy.getParamType(0) == PCharTy &&
FTy.getParamType(2)->isIntegerTy()); FTy.getParamType(2)->isIntegerTy());
case LibFunc::strxfrm: case LibFunc_strxfrm:
return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::strcmp: case LibFunc_strcmp:
return (NumParams == 2 && FTy.getReturnType()->isIntegerTy(32) && return (NumParams == 2 && FTy.getReturnType()->isIntegerTy(32) &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(0) == FTy.getParamType(1)); FTy.getParamType(0) == FTy.getParamType(1));
case LibFunc::strncmp: case LibFunc_strncmp:
return (NumParams == 3 && FTy.getReturnType()->isIntegerTy(32) && return (NumParams == 3 && FTy.getReturnType()->isIntegerTy(32) &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(0) == FTy.getParamType(1) && FTy.getParamType(0) == FTy.getParamType(1) &&
FTy.getParamType(2)->isIntegerTy()); FTy.getParamType(2)->isIntegerTy());
case LibFunc::strspn: case LibFunc_strspn:
case LibFunc::strcspn: case LibFunc_strcspn:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(0) == FTy.getParamType(1) && FTy.getParamType(0) == FTy.getParamType(1) &&
FTy.getReturnType()->isIntegerTy()); FTy.getReturnType()->isIntegerTy());
case LibFunc::strcoll: case LibFunc_strcoll:
case LibFunc::strcasecmp: case LibFunc_strcasecmp:
case LibFunc::strncasecmp: case LibFunc_strncasecmp:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::strstr: case LibFunc_strstr:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy() && return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::strpbrk: case LibFunc_strpbrk:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getReturnType() == FTy.getParamType(0) && FTy.getReturnType() == FTy.getParamType(0) &&
FTy.getParamType(0) == FTy.getParamType(1)); FTy.getParamType(0) == FTy.getParamType(1));
case LibFunc::strtok: case LibFunc_strtok:
case LibFunc::strtok_r: case LibFunc_strtok_r:
return (NumParams >= 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams >= 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::scanf: case LibFunc_scanf:
case LibFunc::setbuf: case LibFunc_setbuf:
case LibFunc::setvbuf: case LibFunc_setvbuf:
return (NumParams >= 1 && FTy.getParamType(0)->isPointerTy()); return (NumParams >= 1 && FTy.getParamType(0)->isPointerTy());
case LibFunc::strdup: case LibFunc_strdup:
case LibFunc::strndup: case LibFunc_strndup:
return (NumParams >= 1 && FTy.getReturnType()->isPointerTy() && return (NumParams >= 1 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0)->isPointerTy()); FTy.getParamType(0)->isPointerTy());
case LibFunc::sscanf: case LibFunc_sscanf:
case LibFunc::stat: case LibFunc_stat:
case LibFunc::statvfs: case LibFunc_statvfs:
case LibFunc::siprintf: case LibFunc_siprintf:
case LibFunc::sprintf: case LibFunc_sprintf:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::snprintf: case LibFunc_snprintf:
return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(2)->isPointerTy()); FTy.getParamType(2)->isPointerTy());
case LibFunc::setitimer: case LibFunc_setitimer:
return (NumParams == 3 && FTy.getParamType(1)->isPointerTy() && return (NumParams == 3 && FTy.getParamType(1)->isPointerTy() &&
FTy.getParamType(2)->isPointerTy()); FTy.getParamType(2)->isPointerTy());
case LibFunc::system: case LibFunc_system:
return (NumParams == 1 && FTy.getParamType(0)->isPointerTy()); return (NumParams == 1 && FTy.getParamType(0)->isPointerTy());
case LibFunc::malloc: case LibFunc_malloc:
return (NumParams == 1 && FTy.getReturnType()->isPointerTy()); return (NumParams == 1 && FTy.getReturnType()->isPointerTy());
case LibFunc::memcmp: case LibFunc_memcmp:
return (NumParams == 3 && FTy.getReturnType()->isIntegerTy(32) && return (NumParams == 3 && FTy.getReturnType()->isIntegerTy(32) &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::memchr: case LibFunc_memchr:
case LibFunc::memrchr: case LibFunc_memrchr:
return (NumParams == 3 && FTy.getReturnType()->isPointerTy() && return (NumParams == 3 && FTy.getReturnType()->isPointerTy() &&
FTy.getReturnType() == FTy.getParamType(0) && FTy.getReturnType() == FTy.getParamType(0) &&
FTy.getParamType(1)->isIntegerTy(32) && FTy.getParamType(1)->isIntegerTy(32) &&
IsSizeTTy(FTy.getParamType(2))); IsSizeTTy(FTy.getParamType(2)));
case LibFunc::modf: case LibFunc_modf:
case LibFunc::modff: case LibFunc_modff:
case LibFunc::modfl: case LibFunc_modfl:
return (NumParams >= 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams >= 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::memcpy_chk: case LibFunc_memcpy_chk:
case LibFunc::memmove_chk: case LibFunc_memmove_chk:
--NumParams; --NumParams;
if (!IsSizeTTy(FTy.getParamType(NumParams))) if (!IsSizeTTy(FTy.getParamType(NumParams)))
return false; return false;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case LibFunc::memcpy: case LibFunc_memcpy:
case LibFunc::mempcpy: case LibFunc_mempcpy:
case LibFunc::memmove: case LibFunc_memmove:
return (NumParams == 3 && FTy.getReturnType() == FTy.getParamType(0) && return (NumParams == 3 && FTy.getReturnType() == FTy.getParamType(0) &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy() && FTy.getParamType(1)->isPointerTy() &&
IsSizeTTy(FTy.getParamType(2))); IsSizeTTy(FTy.getParamType(2)));
case LibFunc::memset_chk: case LibFunc_memset_chk:
--NumParams; --NumParams;
if (!IsSizeTTy(FTy.getParamType(NumParams))) if (!IsSizeTTy(FTy.getParamType(NumParams)))
return false; return false;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case LibFunc::memset: case LibFunc_memset:
return (NumParams == 3 && FTy.getReturnType() == FTy.getParamType(0) && return (NumParams == 3 && FTy.getReturnType() == FTy.getParamType(0) &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isIntegerTy() && FTy.getParamType(1)->isIntegerTy() &&
IsSizeTTy(FTy.getParamType(2))); IsSizeTTy(FTy.getParamType(2)));
case LibFunc::memccpy: case LibFunc_memccpy:
return (NumParams >= 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams >= 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::memalign: case LibFunc_memalign:
return (FTy.getReturnType()->isPointerTy()); return (FTy.getReturnType()->isPointerTy());
case LibFunc::realloc: case LibFunc_realloc:
case LibFunc::reallocf: case LibFunc_reallocf:
return (NumParams == 2 && FTy.getReturnType() == PCharTy && return (NumParams == 2 && FTy.getReturnType() == PCharTy &&
FTy.getParamType(0) == FTy.getReturnType() && FTy.getParamType(0) == FTy.getReturnType() &&
IsSizeTTy(FTy.getParamType(1))); IsSizeTTy(FTy.getParamType(1)));
case LibFunc::read: case LibFunc_read:
return (NumParams == 3 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 3 && FTy.getParamType(1)->isPointerTy());
case LibFunc::rewind: case LibFunc_rewind:
case LibFunc::rmdir: case LibFunc_rmdir:
case LibFunc::remove: case LibFunc_remove:
case LibFunc::realpath: case LibFunc_realpath:
return (NumParams >= 1 && FTy.getParamType(0)->isPointerTy()); return (NumParams >= 1 && FTy.getParamType(0)->isPointerTy());
case LibFunc::rename: case LibFunc_rename:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::readlink: case LibFunc_readlink:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::write: case LibFunc_write:
return (NumParams == 3 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 3 && FTy.getParamType(1)->isPointerTy());
case LibFunc::bcopy: case LibFunc_bcopy:
case LibFunc::bcmp: case LibFunc_bcmp:
return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::bzero: case LibFunc_bzero:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(0)->isPointerTy());
case LibFunc::calloc: case LibFunc_calloc:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy()); return (NumParams == 2 && FTy.getReturnType()->isPointerTy());
case LibFunc::atof: case LibFunc_atof:
case LibFunc::atoi: case LibFunc_atoi:
case LibFunc::atol: case LibFunc_atol:
case LibFunc::atoll: case LibFunc_atoll:
case LibFunc::ferror: case LibFunc_ferror:
case LibFunc::getenv: case LibFunc_getenv:
case LibFunc::getpwnam: case LibFunc_getpwnam:
case LibFunc::iprintf: case LibFunc_iprintf:
case LibFunc::pclose: case LibFunc_pclose:
case LibFunc::perror: case LibFunc_perror:
case LibFunc::printf: case LibFunc_printf:
case LibFunc::puts: case LibFunc_puts:
case LibFunc::uname: case LibFunc_uname:
case LibFunc::under_IO_getc: case LibFunc_under_IO_getc:
case LibFunc::unlink: case LibFunc_unlink:
case LibFunc::unsetenv: case LibFunc_unsetenv:
return (NumParams == 1 && FTy.getParamType(0)->isPointerTy()); return (NumParams == 1 && FTy.getParamType(0)->isPointerTy());
case LibFunc::access: case LibFunc_access:
case LibFunc::chmod: case LibFunc_chmod:
case LibFunc::chown: case LibFunc_chown:
case LibFunc::clearerr: case LibFunc_clearerr:
case LibFunc::closedir: case LibFunc_closedir:
case LibFunc::ctermid: case LibFunc_ctermid:
case LibFunc::fclose: case LibFunc_fclose:
case LibFunc::feof: case LibFunc_feof:
case LibFunc::fflush: case LibFunc_fflush:
case LibFunc::fgetc: case LibFunc_fgetc:
case LibFunc::fileno: case LibFunc_fileno:
case LibFunc::flockfile: case LibFunc_flockfile:
case LibFunc::free: case LibFunc_free:
case LibFunc::fseek: case LibFunc_fseek:
case LibFunc::fseeko64: case LibFunc_fseeko64:
case LibFunc::fseeko: case LibFunc_fseeko:
case LibFunc::fsetpos: case LibFunc_fsetpos:
case LibFunc::ftell: case LibFunc_ftell:
case LibFunc::ftello64: case LibFunc_ftello64:
case LibFunc::ftello: case LibFunc_ftello:
case LibFunc::ftrylockfile: case LibFunc_ftrylockfile:
case LibFunc::funlockfile: case LibFunc_funlockfile:
case LibFunc::getc: case LibFunc_getc:
case LibFunc::getc_unlocked: case LibFunc_getc_unlocked:
case LibFunc::getlogin_r: case LibFunc_getlogin_r:
case LibFunc::mkdir: case LibFunc_mkdir:
case LibFunc::mktime: case LibFunc_mktime:
case LibFunc::times: case LibFunc_times:
return (NumParams != 0 && FTy.getParamType(0)->isPointerTy()); return (NumParams != 0 && FTy.getParamType(0)->isPointerTy());
case LibFunc::fopen: case LibFunc_fopen:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy() && return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::fdopen: case LibFunc_fdopen:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy() && return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::fputc: case LibFunc_fputc:
case LibFunc::fstat: case LibFunc_fstat:
case LibFunc::frexp: case LibFunc_frexp:
case LibFunc::frexpf: case LibFunc_frexpf:
case LibFunc::frexpl: case LibFunc_frexpl:
case LibFunc::fstatvfs: case LibFunc_fstatvfs:
return (NumParams == 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::fgets: case LibFunc_fgets:
return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(2)->isPointerTy()); FTy.getParamType(2)->isPointerTy());
case LibFunc::fread: case LibFunc_fread:
return (NumParams == 4 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 4 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(3)->isPointerTy()); FTy.getParamType(3)->isPointerTy());
case LibFunc::fwrite: case LibFunc_fwrite:
return (NumParams == 4 && FTy.getReturnType()->isIntegerTy() && return (NumParams == 4 && FTy.getReturnType()->isIntegerTy() &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isIntegerTy() && FTy.getParamType(1)->isIntegerTy() &&
FTy.getParamType(2)->isIntegerTy() && FTy.getParamType(2)->isIntegerTy() &&
FTy.getParamType(3)->isPointerTy()); FTy.getParamType(3)->isPointerTy());
case LibFunc::fputs: case LibFunc_fputs:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::fscanf: case LibFunc_fscanf:
case LibFunc::fiprintf: case LibFunc_fiprintf:
case LibFunc::fprintf: case LibFunc_fprintf:
return (NumParams >= 2 && FTy.getReturnType()->isIntegerTy() && return (NumParams >= 2 && FTy.getReturnType()->isIntegerTy() &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::fgetpos: case LibFunc_fgetpos:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::getchar: case LibFunc_getchar:
return (NumParams == 0 && FTy.getReturnType()->isIntegerTy()); return (NumParams == 0 && FTy.getReturnType()->isIntegerTy());
case LibFunc::gets: case LibFunc_gets:
return (NumParams == 1 && FTy.getParamType(0) == PCharTy); return (NumParams == 1 && FTy.getParamType(0) == PCharTy);
case LibFunc::getitimer: case LibFunc_getitimer:
return (NumParams == 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::ungetc: case LibFunc_ungetc:
return (NumParams == 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::utime: case LibFunc_utime:
case LibFunc::utimes: case LibFunc_utimes:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::putc: case LibFunc_putc:
return (NumParams == 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::pread: case LibFunc_pread:
case LibFunc::pwrite: case LibFunc_pwrite:
return (NumParams == 4 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 4 && FTy.getParamType(1)->isPointerTy());
case LibFunc::popen: case LibFunc_popen:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy() && return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::vscanf: case LibFunc_vscanf:
return (NumParams == 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::vsscanf: case LibFunc_vsscanf:
return (NumParams == 3 && FTy.getParamType(1)->isPointerTy() && return (NumParams == 3 && FTy.getParamType(1)->isPointerTy() &&
FTy.getParamType(2)->isPointerTy()); FTy.getParamType(2)->isPointerTy());
case LibFunc::vfscanf: case LibFunc_vfscanf:
return (NumParams == 3 && FTy.getParamType(1)->isPointerTy() && return (NumParams == 3 && FTy.getParamType(1)->isPointerTy() &&
FTy.getParamType(2)->isPointerTy()); FTy.getParamType(2)->isPointerTy());
case LibFunc::valloc: case LibFunc_valloc:
return (FTy.getReturnType()->isPointerTy()); return (FTy.getReturnType()->isPointerTy());
case LibFunc::vprintf: case LibFunc_vprintf:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(0)->isPointerTy());
case LibFunc::vfprintf: case LibFunc_vfprintf:
case LibFunc::vsprintf: case LibFunc_vsprintf:
return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::vsnprintf: case LibFunc_vsnprintf:
return (NumParams == 4 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 4 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(2)->isPointerTy()); FTy.getParamType(2)->isPointerTy());
case LibFunc::open: case LibFunc_open:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy()); return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy());
case LibFunc::opendir: case LibFunc_opendir:
return (NumParams == 1 && FTy.getReturnType()->isPointerTy() && return (NumParams == 1 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0)->isPointerTy()); FTy.getParamType(0)->isPointerTy());
case LibFunc::tmpfile: case LibFunc_tmpfile:
return (FTy.getReturnType()->isPointerTy()); return (FTy.getReturnType()->isPointerTy());
case LibFunc::htonl: case LibFunc_htonl:
case LibFunc::ntohl: case LibFunc_ntohl:
return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(32) && return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(32) &&
FTy.getReturnType() == FTy.getParamType(0)); FTy.getReturnType() == FTy.getParamType(0));
case LibFunc::htons: case LibFunc_htons:
case LibFunc::ntohs: case LibFunc_ntohs:
return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(16) && return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(16) &&
FTy.getReturnType() == FTy.getParamType(0)); FTy.getReturnType() == FTy.getParamType(0));
case LibFunc::lstat: case LibFunc_lstat:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::lchown: case LibFunc_lchown:
return (NumParams == 3 && FTy.getParamType(0)->isPointerTy()); return (NumParams == 3 && FTy.getParamType(0)->isPointerTy());
case LibFunc::qsort: case LibFunc_qsort:
return (NumParams == 4 && FTy.getParamType(3)->isPointerTy()); return (NumParams == 4 && FTy.getParamType(3)->isPointerTy());
case LibFunc::dunder_strdup: case LibFunc_dunder_strdup:
case LibFunc::dunder_strndup: case LibFunc_dunder_strndup:
return (NumParams >= 1 && FTy.getReturnType()->isPointerTy() && return (NumParams >= 1 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0)->isPointerTy()); FTy.getParamType(0)->isPointerTy());
case LibFunc::dunder_strtok_r: case LibFunc_dunder_strtok_r:
return (NumParams == 3 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 3 && FTy.getParamType(1)->isPointerTy());
case LibFunc::under_IO_putc: case LibFunc_under_IO_putc:
return (NumParams == 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::dunder_isoc99_scanf: case LibFunc_dunder_isoc99_scanf:
return (NumParams >= 1 && FTy.getParamType(0)->isPointerTy()); return (NumParams >= 1 && FTy.getParamType(0)->isPointerTy());
case LibFunc::stat64: case LibFunc_stat64:
case LibFunc::lstat64: case LibFunc_lstat64:
case LibFunc::statvfs64: case LibFunc_statvfs64:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::dunder_isoc99_sscanf: case LibFunc_dunder_isoc99_sscanf:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::fopen64: case LibFunc_fopen64:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy() && return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
case LibFunc::tmpfile64: case LibFunc_tmpfile64:
return (FTy.getReturnType()->isPointerTy()); return (FTy.getReturnType()->isPointerTy());
case LibFunc::fstat64: case LibFunc_fstat64:
case LibFunc::fstatvfs64: case LibFunc_fstatvfs64:
return (NumParams == 2 && FTy.getParamType(1)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
case LibFunc::open64: case LibFunc_open64:
return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy()); return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy());
case LibFunc::gettimeofday: case LibFunc_gettimeofday:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() && return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy()); FTy.getParamType(1)->isPointerTy());
// new(unsigned int); // new(unsigned int);
case LibFunc::Znwj: case LibFunc_Znwj:
// new(unsigned long); // new(unsigned long);
case LibFunc::Znwm: case LibFunc_Znwm:
// new[](unsigned int); // new[](unsigned int);
case LibFunc::Znaj: case LibFunc_Znaj:
// new[](unsigned long); // new[](unsigned long);
case LibFunc::Znam: case LibFunc_Znam:
// new(unsigned int); // new(unsigned int);
case LibFunc::msvc_new_int: case LibFunc_msvc_new_int:
// new(unsigned long long); // new(unsigned long long);
case LibFunc::msvc_new_longlong: case LibFunc_msvc_new_longlong:
// new[](unsigned int); // new[](unsigned int);
case LibFunc::msvc_new_array_int: case LibFunc_msvc_new_array_int:
// new[](unsigned long long); // new[](unsigned long long);
case LibFunc::msvc_new_array_longlong: case LibFunc_msvc_new_array_longlong:
return (NumParams == 1 && FTy.getReturnType()->isPointerTy()); return (NumParams == 1 && FTy.getReturnType()->isPointerTy());
// new(unsigned int, nothrow); // new(unsigned int, nothrow);
case LibFunc::ZnwjRKSt9nothrow_t: case LibFunc_ZnwjRKSt9nothrow_t:
// new(unsigned long, nothrow); // new(unsigned long, nothrow);
case LibFunc::ZnwmRKSt9nothrow_t: case LibFunc_ZnwmRKSt9nothrow_t:
// new[](unsigned int, nothrow); // new[](unsigned int, nothrow);
case LibFunc::ZnajRKSt9nothrow_t: case LibFunc_ZnajRKSt9nothrow_t:
// new[](unsigned long, nothrow); // new[](unsigned long, nothrow);
case LibFunc::ZnamRKSt9nothrow_t: case LibFunc_ZnamRKSt9nothrow_t:
// new(unsigned int, nothrow); // new(unsigned int, nothrow);
case LibFunc::msvc_new_int_nothrow: case LibFunc_msvc_new_int_nothrow:
// new(unsigned long long, nothrow); // new(unsigned long long, nothrow);
case LibFunc::msvc_new_longlong_nothrow: case LibFunc_msvc_new_longlong_nothrow:
// new[](unsigned int, nothrow); // new[](unsigned int, nothrow);
case LibFunc::msvc_new_array_int_nothrow: case LibFunc_msvc_new_array_int_nothrow:
// new[](unsigned long long, nothrow); // new[](unsigned long long, nothrow);
case LibFunc::msvc_new_array_longlong_nothrow: case LibFunc_msvc_new_array_longlong_nothrow:
return (NumParams == 2 && FTy.getReturnType()->isPointerTy()); return (NumParams == 2 && FTy.getReturnType()->isPointerTy());
// void operator delete[](void*); // void operator delete[](void*);
case LibFunc::ZdaPv: case LibFunc_ZdaPv:
// void operator delete(void*); // void operator delete(void*);
case LibFunc::ZdlPv: case LibFunc_ZdlPv:
// void operator delete[](void*); // void operator delete[](void*);
case LibFunc::msvc_delete_array_ptr32: case LibFunc_msvc_delete_array_ptr32:
// void operator delete[](void*); // void operator delete[](void*);
case LibFunc::msvc_delete_array_ptr64: case LibFunc_msvc_delete_array_ptr64:
// void operator delete(void*); // void operator delete(void*);
case LibFunc::msvc_delete_ptr32: case LibFunc_msvc_delete_ptr32:
// void operator delete(void*); // void operator delete(void*);
case LibFunc::msvc_delete_ptr64: case LibFunc_msvc_delete_ptr64:
return (NumParams == 1 && FTy.getParamType(0)->isPointerTy()); return (NumParams == 1 && FTy.getParamType(0)->isPointerTy());
// void operator delete[](void*, nothrow); // void operator delete[](void*, nothrow);
case LibFunc::ZdaPvRKSt9nothrow_t: case LibFunc_ZdaPvRKSt9nothrow_t:
// void operator delete[](void*, unsigned int); // void operator delete[](void*, unsigned int);
case LibFunc::ZdaPvj: case LibFunc_ZdaPvj:
// void operator delete[](void*, unsigned long); // void operator delete[](void*, unsigned long);
case LibFunc::ZdaPvm: case LibFunc_ZdaPvm:
// void operator delete(void*, nothrow); // void operator delete(void*, nothrow);
case LibFunc::ZdlPvRKSt9nothrow_t: case LibFunc_ZdlPvRKSt9nothrow_t:
// void operator delete(void*, unsigned int); // void operator delete(void*, unsigned int);
case LibFunc::ZdlPvj: case LibFunc_ZdlPvj:
// void operator delete(void*, unsigned long); // void operator delete(void*, unsigned long);
case LibFunc::ZdlPvm: case LibFunc_ZdlPvm:
// void operator delete[](void*, unsigned int); // void operator delete[](void*, unsigned int);
case LibFunc::msvc_delete_array_ptr32_int: case LibFunc_msvc_delete_array_ptr32_int:
// void operator delete[](void*, nothrow); // void operator delete[](void*, nothrow);
case LibFunc::msvc_delete_array_ptr32_nothrow: case LibFunc_msvc_delete_array_ptr32_nothrow:
// void operator delete[](void*, unsigned long long); // void operator delete[](void*, unsigned long long);
case LibFunc::msvc_delete_array_ptr64_longlong: case LibFunc_msvc_delete_array_ptr64_longlong:
// void operator delete[](void*, nothrow); // void operator delete[](void*, nothrow);
case LibFunc::msvc_delete_array_ptr64_nothrow: case LibFunc_msvc_delete_array_ptr64_nothrow:
// void operator delete(void*, unsigned int); // void operator delete(void*, unsigned int);
case LibFunc::msvc_delete_ptr32_int: case LibFunc_msvc_delete_ptr32_int:
// void operator delete(void*, nothrow); // void operator delete(void*, nothrow);
case LibFunc::msvc_delete_ptr32_nothrow: case LibFunc_msvc_delete_ptr32_nothrow:
// void operator delete(void*, unsigned long long); // void operator delete(void*, unsigned long long);
case LibFunc::msvc_delete_ptr64_longlong: case LibFunc_msvc_delete_ptr64_longlong:
// void operator delete(void*, nothrow); // void operator delete(void*, nothrow);
case LibFunc::msvc_delete_ptr64_nothrow: case LibFunc_msvc_delete_ptr64_nothrow:
return (NumParams == 2 && FTy.getParamType(0)->isPointerTy()); return (NumParams == 2 && FTy.getParamType(0)->isPointerTy());
case LibFunc::memset_pattern16: case LibFunc_memset_pattern16:
return (!FTy.isVarArg() && NumParams == 3 && return (!FTy.isVarArg() && NumParams == 3 &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy() && FTy.getParamType(1)->isPointerTy() &&
FTy.getParamType(2)->isIntegerTy()); FTy.getParamType(2)->isIntegerTy());
case LibFunc::cxa_guard_abort: case LibFunc_cxa_guard_abort:
case LibFunc::cxa_guard_acquire: case LibFunc_cxa_guard_acquire:
case LibFunc::cxa_guard_release: case LibFunc_cxa_guard_release:
case LibFunc::nvvm_reflect: case LibFunc_nvvm_reflect:
return (NumParams == 1 && FTy.getParamType(0)->isPointerTy()); return (NumParams == 1 && FTy.getParamType(0)->isPointerTy());
case LibFunc::sincospi_stret: case LibFunc_sincospi_stret:
case LibFunc::sincospif_stret: case LibFunc_sincospif_stret:
return (NumParams == 1 && FTy.getParamType(0)->isFloatingPointTy()); return (NumParams == 1 && FTy.getParamType(0)->isFloatingPointTy());
case LibFunc::acos: case LibFunc_acos:
case LibFunc::acosf: case LibFunc_acosf:
case LibFunc::acosh: case LibFunc_acosh:
case LibFunc::acoshf: case LibFunc_acoshf:
case LibFunc::acoshl: case LibFunc_acoshl:
case LibFunc::acosl: case LibFunc_acosl:
case LibFunc::asin: case LibFunc_asin:
case LibFunc::asinf: case LibFunc_asinf:
case LibFunc::asinh: case LibFunc_asinh:
case LibFunc::asinhf: case LibFunc_asinhf:
case LibFunc::asinhl: case LibFunc_asinhl:
case LibFunc::asinl: case LibFunc_asinl:
case LibFunc::atan: case LibFunc_atan:
case LibFunc::atanf: case LibFunc_atanf:
case LibFunc::atanh: case LibFunc_atanh:
case LibFunc::atanhf: case LibFunc_atanhf:
case LibFunc::atanhl: case LibFunc_atanhl:
case LibFunc::atanl: case LibFunc_atanl:
case LibFunc::cbrt: case LibFunc_cbrt:
case LibFunc::cbrtf: case LibFunc_cbrtf:
case LibFunc::cbrtl: case LibFunc_cbrtl:
case LibFunc::ceil: case LibFunc_ceil:
case LibFunc::ceilf: case LibFunc_ceilf:
case LibFunc::ceill: case LibFunc_ceill:
case LibFunc::cos: case LibFunc_cos:
case LibFunc::cosf: case LibFunc_cosf:
case LibFunc::cosh: case LibFunc_cosh:
case LibFunc::coshf: case LibFunc_coshf:
case LibFunc::coshl: case LibFunc_coshl:
case LibFunc::cosl: case LibFunc_cosl:
case LibFunc::exp10: case LibFunc_exp10:
case LibFunc::exp10f: case LibFunc_exp10f:
case LibFunc::exp10l: case LibFunc_exp10l:
case LibFunc::exp2: case LibFunc_exp2:
case LibFunc::exp2f: case LibFunc_exp2f:
case LibFunc::exp2l: case LibFunc_exp2l:
case LibFunc::exp: case LibFunc_exp:
case LibFunc::expf: case LibFunc_expf:
case LibFunc::expl: case LibFunc_expl:
case LibFunc::expm1: case LibFunc_expm1:
case LibFunc::expm1f: case LibFunc_expm1f:
case LibFunc::expm1l: case LibFunc_expm1l:
case LibFunc::fabs: case LibFunc_fabs:
case LibFunc::fabsf: case LibFunc_fabsf:
case LibFunc::fabsl: case LibFunc_fabsl:
case LibFunc::floor: case LibFunc_floor:
case LibFunc::floorf: case LibFunc_floorf:
case LibFunc::floorl: case LibFunc_floorl:
case LibFunc::log10: case LibFunc_log10:
case LibFunc::log10f: case LibFunc_log10f:
case LibFunc::log10l: case LibFunc_log10l:
case LibFunc::log1p: case LibFunc_log1p:
case LibFunc::log1pf: case LibFunc_log1pf:
case LibFunc::log1pl: case LibFunc_log1pl:
case LibFunc::log2: case LibFunc_log2:
case LibFunc::log2f: case LibFunc_log2f:
case LibFunc::log2l: case LibFunc_log2l:
case LibFunc::log: case LibFunc_log:
case LibFunc::logb: case LibFunc_logb:
case LibFunc::logbf: case LibFunc_logbf:
case LibFunc::logbl: case LibFunc_logbl:
case LibFunc::logf: case LibFunc_logf:
case LibFunc::logl: case LibFunc_logl:
case LibFunc::nearbyint: case LibFunc_nearbyint:
case LibFunc::nearbyintf: case LibFunc_nearbyintf:
case LibFunc::nearbyintl: case LibFunc_nearbyintl:
case LibFunc::rint: case LibFunc_rint:
case LibFunc::rintf: case LibFunc_rintf:
case LibFunc::rintl: case LibFunc_rintl:
case LibFunc::round: case LibFunc_round:
case LibFunc::roundf: case LibFunc_roundf:
case LibFunc::roundl: case LibFunc_roundl:
case LibFunc::sin: case LibFunc_sin:
case LibFunc::sinf: case LibFunc_sinf:
case LibFunc::sinh: case LibFunc_sinh:
case LibFunc::sinhf: case LibFunc_sinhf:
case LibFunc::sinhl: case LibFunc_sinhl:
case LibFunc::sinl: case LibFunc_sinl:
case LibFunc::sqrt: case LibFunc_sqrt:
case LibFunc::sqrt_finite: case LibFunc_sqrt_finite:
case LibFunc::sqrtf: case LibFunc_sqrtf:
case LibFunc::sqrtf_finite: case LibFunc_sqrtf_finite:
case LibFunc::sqrtl: case LibFunc_sqrtl:
case LibFunc::sqrtl_finite: case LibFunc_sqrtl_finite:
case LibFunc::tan: case LibFunc_tan:
case LibFunc::tanf: case LibFunc_tanf:
case LibFunc::tanh: case LibFunc_tanh:
case LibFunc::tanhf: case LibFunc_tanhf:
case LibFunc::tanhl: case LibFunc_tanhl:
case LibFunc::tanl: case LibFunc_tanl:
case LibFunc::trunc: case LibFunc_trunc:
case LibFunc::truncf: case LibFunc_truncf:
case LibFunc::truncl: case LibFunc_truncl:
return (NumParams == 1 && FTy.getReturnType()->isFloatingPointTy() && return (NumParams == 1 && FTy.getReturnType()->isFloatingPointTy() &&
FTy.getReturnType() == FTy.getParamType(0)); FTy.getReturnType() == FTy.getParamType(0));
case LibFunc::atan2: case LibFunc_atan2:
case LibFunc::atan2f: case LibFunc_atan2f:
case LibFunc::atan2l: case LibFunc_atan2l:
case LibFunc::fmin: case LibFunc_fmin:
case LibFunc::fminf: case LibFunc_fminf:
case LibFunc::fminl: case LibFunc_fminl:
case LibFunc::fmax: case LibFunc_fmax:
case LibFunc::fmaxf: case LibFunc_fmaxf:
case LibFunc::fmaxl: case LibFunc_fmaxl:
case LibFunc::fmod: case LibFunc_fmod:
case LibFunc::fmodf: case LibFunc_fmodf:
case LibFunc::fmodl: case LibFunc_fmodl:
case LibFunc::copysign: case LibFunc_copysign:
case LibFunc::copysignf: case LibFunc_copysignf:
case LibFunc::copysignl: case LibFunc_copysignl:
case LibFunc::pow: case LibFunc_pow:
case LibFunc::powf: case LibFunc_powf:
case LibFunc::powl: case LibFunc_powl:
return (NumParams == 2 && FTy.getReturnType()->isFloatingPointTy() && return (NumParams == 2 && FTy.getReturnType()->isFloatingPointTy() &&
FTy.getReturnType() == FTy.getParamType(0) && FTy.getReturnType() == FTy.getParamType(0) &&
FTy.getReturnType() == FTy.getParamType(1)); FTy.getReturnType() == FTy.getParamType(1));
case LibFunc::ldexp: case LibFunc_ldexp:
case LibFunc::ldexpf: case LibFunc_ldexpf:
case LibFunc::ldexpl: case LibFunc_ldexpl:
return (NumParams == 2 && FTy.getReturnType()->isFloatingPointTy() && return (NumParams == 2 && FTy.getReturnType()->isFloatingPointTy() &&
FTy.getReturnType() == FTy.getParamType(0) && FTy.getReturnType() == FTy.getParamType(0) &&
FTy.getParamType(1)->isIntegerTy(32)); FTy.getParamType(1)->isIntegerTy(32));
case LibFunc::ffs: case LibFunc_ffs:
case LibFunc::ffsl: case LibFunc_ffsl:
case LibFunc::ffsll: case LibFunc_ffsll:
case LibFunc::fls: case LibFunc_fls:
case LibFunc::flsl: case LibFunc_flsl:
case LibFunc::flsll: case LibFunc_flsll:
return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(32) && return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(32) &&
FTy.getParamType(0)->isIntegerTy()); FTy.getParamType(0)->isIntegerTy());
case LibFunc::isdigit: case LibFunc_isdigit:
case LibFunc::isascii: case LibFunc_isascii:
case LibFunc::toascii: case LibFunc_toascii:
case LibFunc::putchar: case LibFunc_putchar:
return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(32) && return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(32) &&
FTy.getReturnType() == FTy.getParamType(0)); FTy.getReturnType() == FTy.getParamType(0));
case LibFunc::abs: case LibFunc_abs:
case LibFunc::labs: case LibFunc_labs:
case LibFunc::llabs: case LibFunc_llabs:
return (NumParams == 1 && FTy.getReturnType()->isIntegerTy() && return (NumParams == 1 && FTy.getReturnType()->isIntegerTy() &&
FTy.getReturnType() == FTy.getParamType(0)); FTy.getReturnType() == FTy.getParamType(0));
case LibFunc::cxa_atexit: case LibFunc_cxa_atexit:
return (NumParams == 3 && FTy.getReturnType()->isIntegerTy() && return (NumParams == 3 && FTy.getReturnType()->isIntegerTy() &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1)->isPointerTy() && FTy.getParamType(1)->isPointerTy() &&
FTy.getParamType(2)->isPointerTy()); FTy.getParamType(2)->isPointerTy());
case LibFunc::sinpi: case LibFunc_sinpi:
case LibFunc::cospi: case LibFunc_cospi:
return (NumParams == 1 && FTy.getReturnType()->isDoubleTy() && return (NumParams == 1 && FTy.getReturnType()->isDoubleTy() &&
FTy.getReturnType() == FTy.getParamType(0)); FTy.getReturnType() == FTy.getParamType(0));
case LibFunc::sinpif: case LibFunc_sinpif:
case LibFunc::cospif: case LibFunc_cospif:
return (NumParams == 1 && FTy.getReturnType()->isFloatTy() && return (NumParams == 1 && FTy.getReturnType()->isFloatTy() &&
FTy.getReturnType() == FTy.getParamType(0)); FTy.getReturnType() == FTy.getParamType(0));
case LibFunc::strnlen: case LibFunc_strnlen:
return (NumParams == 2 && FTy.getReturnType() == FTy.getParamType(1) && return (NumParams == 2 && FTy.getReturnType() == FTy.getParamType(1) &&
FTy.getParamType(0) == PCharTy && FTy.getParamType(0) == PCharTy &&
FTy.getParamType(1) == SizeTTy); FTy.getParamType(1) == SizeTTy);
case LibFunc::posix_memalign: case LibFunc_posix_memalign:
return (NumParams == 3 && FTy.getReturnType()->isIntegerTy(32) && return (NumParams == 3 && FTy.getReturnType()->isIntegerTy(32) &&
FTy.getParamType(0)->isPointerTy() && FTy.getParamType(0)->isPointerTy() &&
FTy.getParamType(1) == SizeTTy && FTy.getParamType(2) == SizeTTy); FTy.getParamType(1) == SizeTTy && FTy.getParamType(2) == SizeTTy);
case LibFunc::NumLibFuncs: case LibFunc::NumLibFuncs:
break; break;
} }
llvm_unreachable("Invalid libfunc"); llvm_unreachable("Invalid libfunc");
} }
bool TargetLibraryInfoImpl::getLibFunc(const Function &FDecl, bool TargetLibraryInfoImpl::getLibFunc(const Function &FDecl,
LibFunc::Func &F) const { LibFunc &F) const {
const DataLayout *DL = const DataLayout *DL =
FDecl.getParent() ? &FDecl.getParent()->getDataLayout() : nullptr; FDecl.getParent() ? &FDecl.getParent()->getDataLayout() : nullptr;
return getLibFunc(FDecl.getName(), F) && return getLibFunc(FDecl.getName(), F) &&
isValidProtoForLibFunc(*FDecl.getFunctionType(), F, DL); isValidProtoForLibFunc(*FDecl.getFunctionType(), F, DL);
} }
void TargetLibraryInfoImpl::disableAllFunctions() { void TargetLibraryInfoImpl::disableAllFunctions() {
memset(AvailableArray, 0, sizeof(AvailableArray)); memset(AvailableArray, 0, sizeof(AvailableArray));
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

lib/Analysis/ValueTracking.cpp

Show First 20 Lines • Show All 2,442 Lines • ▼ Show 20 Lines if (!F)
return Intrinsic::not_intrinsic; return Intrinsic::not_intrinsic;
if (F->isIntrinsic()) if (F->isIntrinsic())
return F->getIntrinsicID(); return F->getIntrinsicID();
if (!TLI) if (!TLI)
return Intrinsic::not_intrinsic; return Intrinsic::not_intrinsic;
LibFunc::Func Func; LibFunc Func;
// We're going to make assumptions on the semantics of the functions, check // We're going to make assumptions on the semantics of the functions, check
// that the target knows that it's available in this environment and it does // that the target knows that it's available in this environment and it does
// not have local linkage. // not have local linkage.
if (!F || F->hasLocalLinkage() || !TLI->getLibFunc(*F, Func)) if (!F || F->hasLocalLinkage() || !TLI->getLibFunc(*F, Func))
return Intrinsic::not_intrinsic; return Intrinsic::not_intrinsic;
if (!ICS.onlyReadsMemory()) if (!ICS.onlyReadsMemory())
return Intrinsic::not_intrinsic; return Intrinsic::not_intrinsic;
// Otherwise check if we have a call to a function that can be turned into a // Otherwise check if we have a call to a function that can be turned into a
// vector intrinsic. // vector intrinsic.
switch (Func) { switch (Func) {
default: default:
break; break;
case LibFunc::sin: case LibFunc_sin:
case LibFunc::sinf: case LibFunc_sinf:
case LibFunc::sinl: case LibFunc_sinl:
return Intrinsic::sin; return Intrinsic::sin;
case LibFunc::cos: case LibFunc_cos:
case LibFunc::cosf: case LibFunc_cosf:
case LibFunc::cosl: case LibFunc_cosl:
return Intrinsic::cos; return Intrinsic::cos;
case LibFunc::exp: case LibFunc_exp:
case LibFunc::expf: case LibFunc_expf:
case LibFunc::expl: case LibFunc_expl:
return Intrinsic::exp; return Intrinsic::exp;
case LibFunc::exp2: case LibFunc_exp2:
case LibFunc::exp2f: case LibFunc_exp2f:
case LibFunc::exp2l: case LibFunc_exp2l:
return Intrinsic::exp2; return Intrinsic::exp2;
case LibFunc::log: case LibFunc_log:
case LibFunc::logf: case LibFunc_logf:
case LibFunc::logl: case LibFunc_logl:
return Intrinsic::log; return Intrinsic::log;
case LibFunc::log10: case LibFunc_log10:
case LibFunc::log10f: case LibFunc_log10f:
case LibFunc::log10l: case LibFunc_log10l:
return Intrinsic::log10; return Intrinsic::log10;
case LibFunc::log2: case LibFunc_log2:
case LibFunc::log2f: case LibFunc_log2f:
case LibFunc::log2l: case LibFunc_log2l:
return Intrinsic::log2; return Intrinsic::log2;
case LibFunc::fabs: case LibFunc_fabs:
case LibFunc::fabsf: case LibFunc_fabsf:
case LibFunc::fabsl: case LibFunc_fabsl:
return Intrinsic::fabs; return Intrinsic::fabs;
case LibFunc::fmin: case LibFunc_fmin:
case LibFunc::fminf: case LibFunc_fminf:
case LibFunc::fminl: case LibFunc_fminl:
return Intrinsic::minnum; return Intrinsic::minnum;
case LibFunc::fmax: case LibFunc_fmax:
case LibFunc::fmaxf: case LibFunc_fmaxf:
case LibFunc::fmaxl: case LibFunc_fmaxl:
return Intrinsic::maxnum; return Intrinsic::maxnum;
case LibFunc::copysign: case LibFunc_copysign:
case LibFunc::copysignf: case LibFunc_copysignf:
case LibFunc::copysignl: case LibFunc_copysignl:
return Intrinsic::copysign; return Intrinsic::copysign;
case LibFunc::floor: case LibFunc_floor:
case LibFunc::floorf: case LibFunc_floorf:
case LibFunc::floorl: case LibFunc_floorl:
return Intrinsic::floor; return Intrinsic::floor;
case LibFunc::ceil: case LibFunc_ceil:
case LibFunc::ceilf: case LibFunc_ceilf:
case LibFunc::ceill: case LibFunc_ceill:
return Intrinsic::ceil; return Intrinsic::ceil;
case LibFunc::trunc: case LibFunc_trunc:
case LibFunc::truncf: case LibFunc_truncf:
case LibFunc::truncl: case LibFunc_truncl:
return Intrinsic::trunc; return Intrinsic::trunc;
case LibFunc::rint: case LibFunc_rint:
case LibFunc::rintf: case LibFunc_rintf:
case LibFunc::rintl: case LibFunc_rintl:
return Intrinsic::rint; return Intrinsic::rint;
case LibFunc::nearbyint: case LibFunc_nearbyint:
case LibFunc::nearbyintf: case LibFunc_nearbyintf:
case LibFunc::nearbyintl: case LibFunc_nearbyintl:
return Intrinsic::nearbyint; return Intrinsic::nearbyint;
case LibFunc::round: case LibFunc_round:
case LibFunc::roundf: case LibFunc_roundf:
case LibFunc::roundl: case LibFunc_roundl:
return Intrinsic::round; return Intrinsic::round;
case LibFunc::pow: case LibFunc_pow:
case LibFunc::powf: case LibFunc_powf:
case LibFunc::powl: case LibFunc_powl:
return Intrinsic::pow; return Intrinsic::pow;
case LibFunc::sqrt: case LibFunc_sqrt:
case LibFunc::sqrtf: case LibFunc_sqrtf:
case LibFunc::sqrtl: case LibFunc_sqrtl:
if (ICS->hasNoNaNs()) if (ICS->hasNoNaNs())
return Intrinsic::sqrt; return Intrinsic::sqrt;
return Intrinsic::not_intrinsic; return Intrinsic::not_intrinsic;
} }
return Intrinsic::not_intrinsic; return Intrinsic::not_intrinsic;
} }
▲ Show 20 Lines • Show All 1,882 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/FastISel.cpp

Show First 20 Lines • Show All 1,356 Lines • ▼ Show 20 Lines for (unsigned i = 0, e = CS.getNumOperandBundles(); i != e; ++i)
return false; return false;
DbgLoc = I->getDebugLoc(); DbgLoc = I->getDebugLoc();
SavedInsertPt = FuncInfo.InsertPt; SavedInsertPt = FuncInfo.InsertPt;
if (const auto *Call = dyn_cast<CallInst>(I)) { if (const auto *Call = dyn_cast<CallInst>(I)) {
const Function *F = Call->getCalledFunction(); const Function *F = Call->getCalledFunction();
LibFunc::Func Func; LibFunc Func;
// As a special case, don't handle calls to builtin library functions that // As a special case, don't handle calls to builtin library functions that
// may be translated directly to target instructions. // may be translated directly to target instructions.
if (F && !F->hasLocalLinkage() && F->hasName() && if (F && !F->hasLocalLinkage() && F->hasName() &&
LibInfo->getLibFunc(F->getName(), Func) && LibInfo->getLibFunc(F->getName(), Func) &&
LibInfo->hasOptimizedCodeGen(Func)) LibInfo->hasOptimizedCodeGen(Func))
return false; return false;
▲ Show 20 Lines • Show All 841 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,323 Lines • ▼ Show 20 Lines if (F->isDeclaration()) {
if (!RenameFn) if (!RenameFn)
return; return;
} }
} }
// Check for well-known libc/libm calls. If the function is internal, it // Check for well-known libc/libm calls. If the function is internal, it
// can't be a library call. Don't do the check if marked as nobuiltin for // can't be a library call. Don't do the check if marked as nobuiltin for
// some reason. // some reason.
LibFunc::Func Func; LibFunc Func;
if (!I.isNoBuiltin() && !F->hasLocalLinkage() && F->hasName() && if (!I.isNoBuiltin() && !F->hasLocalLinkage() && F->hasName() &&
LibInfo->getLibFunc(F->getName(), Func) && LibInfo->getLibFunc(F->getName(), Func) &&
LibInfo->hasOptimizedCodeGen(Func)) { LibInfo->hasOptimizedCodeGen(Func)) {
switch (Func) { switch (Func) {
default: break; default: break;
case LibFunc::copysign: case LibFunc_copysign:
case LibFunc::copysignf: case LibFunc_copysignf:
case LibFunc::copysignl: case LibFunc_copysignl:
if (I.getNumArgOperands() == 2 && // Basic sanity checks. if (I.getNumArgOperands() == 2 && // Basic sanity checks.
I.getArgOperand(0)->getType()->isFloatingPointTy() && I.getArgOperand(0)->getType()->isFloatingPointTy() &&
I.getType() == I.getArgOperand(0)->getType() && I.getType() == I.getArgOperand(0)->getType() &&
I.getType() == I.getArgOperand(1)->getType() && I.getType() == I.getArgOperand(1)->getType() &&
I.onlyReadsMemory()) { I.onlyReadsMemory()) {
SDValue LHS = getValue(I.getArgOperand(0)); SDValue LHS = getValue(I.getArgOperand(0));
SDValue RHS = getValue(I.getArgOperand(1)); SDValue RHS = getValue(I.getArgOperand(1));
setValue(&I, DAG.getNode(ISD::FCOPYSIGN, getCurSDLoc(), setValue(&I, DAG.getNode(ISD::FCOPYSIGN, getCurSDLoc(),
LHS.getValueType(), LHS, RHS)); LHS.getValueType(), LHS, RHS));
return; return;
} }
break; break;
case LibFunc::fabs: case LibFunc_fabs:
case LibFunc::fabsf: case LibFunc_fabsf:
case LibFunc::fabsl: case LibFunc_fabsl:
if (visitUnaryFloatCall(I, ISD::FABS)) if (visitUnaryFloatCall(I, ISD::FABS))
return; return;
break; break;
case LibFunc::fmin: case LibFunc_fmin:
case LibFunc::fminf: case LibFunc_fminf:
case LibFunc::fminl: case LibFunc_fminl:
if (visitBinaryFloatCall(I, ISD::FMINNUM)) if (visitBinaryFloatCall(I, ISD::FMINNUM))
return; return;
break; break;
case LibFunc::fmax: case LibFunc_fmax:
case LibFunc::fmaxf: case LibFunc_fmaxf:
case LibFunc::fmaxl: case LibFunc_fmaxl:
if (visitBinaryFloatCall(I, ISD::FMAXNUM)) if (visitBinaryFloatCall(I, ISD::FMAXNUM))
return; return;
break; break;
case LibFunc::sin: case LibFunc_sin:
case LibFunc::sinf: case LibFunc_sinf:
case LibFunc::sinl: case LibFunc_sinl:
if (visitUnaryFloatCall(I, ISD::FSIN)) if (visitUnaryFloatCall(I, ISD::FSIN))
return; return;
break; break;
case LibFunc::cos: case LibFunc_cos:
case LibFunc::cosf: case LibFunc_cosf:
case LibFunc::cosl: case LibFunc_cosl:
if (visitUnaryFloatCall(I, ISD::FCOS)) if (visitUnaryFloatCall(I, ISD::FCOS))
return; return;
break; break;
case LibFunc::sqrt: case LibFunc_sqrt:
case LibFunc::sqrtf: case LibFunc_sqrtf:
case LibFunc::sqrtl: case LibFunc_sqrtl:
case LibFunc::sqrt_finite: case LibFunc_sqrt_finite:
case LibFunc::sqrtf_finite: case LibFunc_sqrtf_finite:
case LibFunc::sqrtl_finite: case LibFunc_sqrtl_finite:
if (visitUnaryFloatCall(I, ISD::FSQRT)) if (visitUnaryFloatCall(I, ISD::FSQRT))
return; return;
break; break;
case LibFunc::floor: case LibFunc_floor:
case LibFunc::floorf: case LibFunc_floorf:
case LibFunc::floorl: case LibFunc_floorl:
if (visitUnaryFloatCall(I, ISD::FFLOOR)) if (visitUnaryFloatCall(I, ISD::FFLOOR))
return; return;
break; break;
case LibFunc::nearbyint: case LibFunc_nearbyint:
case LibFunc::nearbyintf: case LibFunc_nearbyintf:
case LibFunc::nearbyintl: case LibFunc_nearbyintl:
if (visitUnaryFloatCall(I, ISD::FNEARBYINT)) if (visitUnaryFloatCall(I, ISD::FNEARBYINT))
return; return;
break; break;
case LibFunc::ceil: case LibFunc_ceil:
case LibFunc::ceilf: case LibFunc_ceilf:
case LibFunc::ceill: case LibFunc_ceill:
if (visitUnaryFloatCall(I, ISD::FCEIL)) if (visitUnaryFloatCall(I, ISD::FCEIL))
return; return;
break; break;
case LibFunc::rint: case LibFunc_rint:
case LibFunc::rintf: case LibFunc_rintf:
case LibFunc::rintl: case LibFunc_rintl:
if (visitUnaryFloatCall(I, ISD::FRINT)) if (visitUnaryFloatCall(I, ISD::FRINT))
return; return;
break; break;
case LibFunc::round: case LibFunc_round:
case LibFunc::roundf: case LibFunc_roundf:
case LibFunc::roundl: case LibFunc_roundl:
if (visitUnaryFloatCall(I, ISD::FROUND)) if (visitUnaryFloatCall(I, ISD::FROUND))
return; return;
break; break;
case LibFunc::trunc: case LibFunc_trunc:
case LibFunc::truncf: case LibFunc_truncf:
case LibFunc::truncl: case LibFunc_truncl:
if (visitUnaryFloatCall(I, ISD::FTRUNC)) if (visitUnaryFloatCall(I, ISD::FTRUNC))
return; return;
break; break;
case LibFunc::log2: case LibFunc_log2:
case LibFunc::log2f: case LibFunc_log2f:
case LibFunc::log2l: case LibFunc_log2l:
if (visitUnaryFloatCall(I, ISD::FLOG2)) if (visitUnaryFloatCall(I, ISD::FLOG2))
return; return;
break; break;
case LibFunc::exp2: case LibFunc_exp2:
case LibFunc::exp2f: case LibFunc_exp2f:
case LibFunc::exp2l: case LibFunc_exp2l:
if (visitUnaryFloatCall(I, ISD::FEXP2)) if (visitUnaryFloatCall(I, ISD::FEXP2))
return; return;
break; break;
case LibFunc::memcmp: case LibFunc_memcmp:
if (visitMemCmpCall(I)) if (visitMemCmpCall(I))
return; return;
break; break;
case LibFunc::mempcpy: case LibFunc_mempcpy:
if (visitMemPCpyCall(I)) if (visitMemPCpyCall(I))
return; return;
break; break;
case LibFunc::memchr: case LibFunc_memchr:
if (visitMemChrCall(I)) if (visitMemChrCall(I))
return; return;
break; break;
case LibFunc::strcpy: case LibFunc_strcpy:
if (visitStrCpyCall(I, false)) if (visitStrCpyCall(I, false))
return; return;
break; break;
case LibFunc::stpcpy: case LibFunc_stpcpy:
if (visitStrCpyCall(I, true)) if (visitStrCpyCall(I, true))
return; return;
break; break;
case LibFunc::strcmp: case LibFunc_strcmp:
if (visitStrCmpCall(I)) if (visitStrCmpCall(I))
return; return;
break; break;
case LibFunc::strlen: case LibFunc_strlen:
if (visitStrLenCall(I)) if (visitStrLenCall(I))
return; return;
break; break;
case LibFunc::strnlen: case LibFunc_strnlen:
if (visitStrNLenCall(I)) if (visitStrNLenCall(I))
return; return;
break; break;
} }
} }
} }
SDValue Callee; SDValue Callee;
▲ Show 20 Lines • Show All 2,873 Lines • Show Last 20 Lines

lib/LTO/UpdateCompilerUsed.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Linesprivate:
void initializeLibCalls(const Module &TheModule) { void initializeLibCalls(const Module &TheModule) {
TargetLibraryInfoImpl TLII(Triple(TM.getTargetTriple())); TargetLibraryInfoImpl TLII(Triple(TM.getTargetTriple()));
TargetLibraryInfo TLI(TLII); TargetLibraryInfo TLI(TLII);
// TargetLibraryInfo has info on C runtime library calls on the current // TargetLibraryInfo has info on C runtime library calls on the current
// target. // target.
for (unsigned I = 0, E = static_cast<unsigned>(LibFunc::NumLibFuncs); for (unsigned I = 0, E = static_cast<unsigned>(LibFunc::NumLibFuncs);
I != E; ++I) { I != E; ++I) {
LibFunc::Func F = static_cast<LibFunc::Func>(I); LibFunc F = static_cast<LibFunc>(I);
if (TLI.has(F)) if (TLI.has(F))
Libcalls.insert(TLI.getName(F)); Libcalls.insert(TLI.getName(F));
} }
SmallPtrSet<const TargetLowering *, 1> TLSet; SmallPtrSet<const TargetLowering *, 1> TLSet;
for (const Function &F : TheModule) { for (const Function &F : TheModule) {
const TargetLowering *Lowering = const TargetLowering *Lowering =
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lib/Target/PowerPC/PPCCTRLoops.cpp

Show First 20 Lines • Show All 309 Lines • ▼ Show 20 Lines#endif
} }
} }
// PowerPC does not use [US]DIVREM or other library calls for // PowerPC does not use [US]DIVREM or other library calls for
// operations on regular types which are not otherwise library calls // operations on regular types which are not otherwise library calls
// (i.e. soft float or atomics). If adapting for targets that do, // (i.e. soft float or atomics). If adapting for targets that do,
// additional care is required here. // additional care is required here.
LibFunc::Func Func; LibFunc Func;
if (!F->hasLocalLinkage() && F->hasName() && LibInfo && if (!F->hasLocalLinkage() && F->hasName() && LibInfo &&
LibInfo->getLibFunc(F->getName(), Func) && LibInfo->getLibFunc(F->getName(), Func) &&
LibInfo->hasOptimizedCodeGen(Func)) { LibInfo->hasOptimizedCodeGen(Func)) {
// Non-read-only functions are never treated as intrinsics. // Non-read-only functions are never treated as intrinsics.
if (!CI->onlyReadsMemory()) if (!CI->onlyReadsMemory())
return true; return true;
// Conversion happens only for FP calls. // Conversion happens only for FP calls.
if (!CI->getArgOperand(0)->getType()->isFloatingPointTy()) if (!CI->getArgOperand(0)->getType()->isFloatingPointTy())
return true; return true;
switch (Func) { switch (Func) {
default: return true; default: return true;
case LibFunc::copysign: case LibFunc_copysign:
case LibFunc::copysignf: case LibFunc_copysignf:
continue; // ISD::FCOPYSIGN is never a library call. continue; // ISD::FCOPYSIGN is never a library call.
case LibFunc::copysignl: case LibFunc_copysignl:
return true; return true;
case LibFunc::fabs: case LibFunc_fabs:
case LibFunc::fabsf: case LibFunc_fabsf:
case LibFunc::fabsl: case LibFunc_fabsl:
continue; // ISD::FABS is never a library call. continue; // ISD::FABS is never a library call.
case LibFunc::sqrt: case LibFunc_sqrt:
case LibFunc::sqrtf: case LibFunc_sqrtf:
case LibFunc::sqrtl: case LibFunc_sqrtl:
Opcode = ISD::FSQRT; break; Opcode = ISD::FSQRT; break;
case LibFunc::floor: case LibFunc_floor:
case LibFunc::floorf: case LibFunc_floorf:
case LibFunc::floorl: case LibFunc_floorl:
Opcode = ISD::FFLOOR; break; Opcode = ISD::FFLOOR; break;
case LibFunc::nearbyint: case LibFunc_nearbyint:
case LibFunc::nearbyintf: case LibFunc_nearbyintf:
case LibFunc::nearbyintl: case LibFunc_nearbyintl:
Opcode = ISD::FNEARBYINT; break; Opcode = ISD::FNEARBYINT; break;
case LibFunc::ceil: case LibFunc_ceil:
case LibFunc::ceilf: case LibFunc_ceilf:
case LibFunc::ceill: case LibFunc_ceill:
Opcode = ISD::FCEIL; break; Opcode = ISD::FCEIL; break;
case LibFunc::rint: case LibFunc_rint:
case LibFunc::rintf: case LibFunc_rintf:
case LibFunc::rintl: case LibFunc_rintl:
Opcode = ISD::FRINT; break; Opcode = ISD::FRINT; break;
case LibFunc::round: case LibFunc_round:
case LibFunc::roundf: case LibFunc_roundf:
case LibFunc::roundl: case LibFunc_roundl:
Opcode = ISD::FROUND; break; Opcode = ISD::FROUND; break;
case LibFunc::trunc: case LibFunc_trunc:
case LibFunc::truncf: case LibFunc_truncf:
case LibFunc::truncl: case LibFunc_truncl:
Opcode = ISD::FTRUNC; break; Opcode = ISD::FTRUNC; break;
case LibFunc::fmin: case LibFunc_fmin:
case LibFunc::fminf: case LibFunc_fminf:
case LibFunc::fminl: case LibFunc_fminl:
Opcode = ISD::FMINNUM; break; Opcode = ISD::FMINNUM; break;
case LibFunc::fmax: case LibFunc_fmax:
case LibFunc::fmaxf: case LibFunc_fmaxf:
case LibFunc::fmaxl: case LibFunc_fmaxl:
Opcode = ISD::FMAXNUM; break; Opcode = ISD::FMAXNUM; break;
} }
} }
if (Opcode) { if (Opcode) {
auto &DL = CI->getModule()->getDataLayout(); auto &DL = CI->getModule()->getDataLayout();
MVT VTy = TLI->getSimpleValueType(DL, CI->getArgOperand(0)->getType(), MVT VTy = TLI->getSimpleValueType(DL, CI->getArgOperand(0)->getType(),
true); true);
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

lib/Transforms/IPO/GlobalOpt.cpp

Show First 20 Lines • Show All 2,381 Lines • ▼ Show 20 LinesOptimizeGlobalAliases(Module &M,
} }
Used.syncVariablesAndSets(); Used.syncVariablesAndSets();
return Changed; return Changed;
} }
static Function *FindCXAAtExit(Module &M, TargetLibraryInfo *TLI) { static Function *FindCXAAtExit(Module &M, TargetLibraryInfo *TLI) {
LibFunc::Func F = LibFunc::cxa_atexit; LibFunc F = LibFunc_cxa_atexit;
if (!TLI->has(F)) if (!TLI->has(F))
return nullptr; return nullptr;
Function *Fn = M.getFunction(TLI->getName(F)); Function *Fn = M.getFunction(TLI->getName(F));
if (!Fn) if (!Fn)
return nullptr; return nullptr;
// Make sure that the function has the correct prototype. // Make sure that the function has the correct prototype.
if (!TLI->getLibFunc(*Fn, F) || F != LibFunc::cxa_atexit) if (!TLI->getLibFunc(*Fn, F) || F != LibFunc_cxa_atexit)
return nullptr; return nullptr;
return Fn; return Fn;
} }
/// Returns whether the given function is an empty C++ destructor and can /// Returns whether the given function is an empty C++ destructor and can
/// therefore be eliminated. /// therefore be eliminated.
/// Note that we assume that other optimization passes have already simplified /// Note that we assume that other optimization passes have already simplified
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

lib/Transforms/Scalar/DeadStoreElimination.cpp

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
case Intrinsic::init_trampoline: case Intrinsic::init_trampoline:
case Intrinsic::lifetime_end: case Intrinsic::lifetime_end:
return true; return true;
} }
} }
if (auto CS = CallSite(I)) { if (auto CS = CallSite(I)) {
if (Function *F = CS.getCalledFunction()) { if (Function *F = CS.getCalledFunction()) {
StringRef FnName = F->getName(); StringRef FnName = F->getName();
if (TLI.has(LibFunc::strcpy) && FnName == TLI.getName(LibFunc::strcpy)) if (TLI.has(LibFunc_strcpy) && FnName == TLI.getName(LibFunc_strcpy)) {
return true; return true;
if (TLI.has(LibFunc::strncpy) && FnName == TLI.getName(LibFunc::strncpy)) }
if (TLI.has(LibFunc_strncpy) && FnName == TLI.getName(LibFunc_strncpy)) {
return true; return true;
if (TLI.has(LibFunc::strcat) && FnName == TLI.getName(LibFunc::strcat)) }
if (TLI.has(LibFunc_strcat) && FnName == TLI.getName(LibFunc_strcat)) {
return true; return true;
if (TLI.has(LibFunc::strncat) && FnName == TLI.getName(LibFunc::strncat)) }
if (TLI.has(LibFunc_strncat) && FnName == TLI.getName(LibFunc_strncat)) {
efriedmaUnsubmitted
Not Done
ReplyInline Actions

Not sure why you're changing this.

efriedma: Not sure why you're changing this.
dljAuthorUnsubmitted
Not Done
ReplyInline Actions

Looks like a clang-tidy fix to me. (Un-)fixed.

dlj: Looks like a clang-tidy fix to me. (Un-)fixed.
return true; return true;
} }
} }
}
return false; return false;
} }
/// Return a Location stored to by the specified instruction. If isRemovable /// Return a Location stored to by the specified instruction. If isRemovable
/// returns true, this function and getLocForRead completely describe the memory /// returns true, this function and getLocForRead completely describe the memory
/// operations for this instruction. /// operations for this instruction.
static MemoryLocation getLocForWrite(Instruction *Inst, AliasAnalysis &AA) { static MemoryLocation getLocForWrite(Instruction *Inst, AliasAnalysis &AA) {
if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
▲ Show 20 Lines • Show All 1,092 Lines • Show Last 20 Lines

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Linesbool LoopIdiomRecognize::runOnLoop(Loop *L) {
StringRef Name = L->getHeader()->getParent()->getName(); StringRef Name = L->getHeader()->getParent()->getName();
if (Name == "memset" || Name == "memcpy") if (Name == "memset" || Name == "memcpy")
return false; return false;
// Determine if code size heuristics need to be applied. // Determine if code size heuristics need to be applied.
ApplyCodeSizeHeuristics = ApplyCodeSizeHeuristics =
L->getHeader()->getParent()->optForSize() && UseLIRCodeSizeHeurs; L->getHeader()->getParent()->optForSize() && UseLIRCodeSizeHeurs;
HasMemset = TLI->has(LibFunc::memset); HasMemset = TLI->has(LibFunc_memset);
HasMemsetPattern = TLI->has(LibFunc::memset_pattern16); HasMemsetPattern = TLI->has(LibFunc_memset_pattern16);
HasMemcpy = TLI->has(LibFunc::memcpy); HasMemcpy = TLI->has(LibFunc_memcpy);
if (HasMemset || HasMemsetPattern || HasMemcpy) if (HasMemset || HasMemsetPattern || HasMemcpy)
if (SE->hasLoopInvariantBackedgeTakenCount(L)) if (SE->hasLoopInvariantBackedgeTakenCount(L))
return runOnCountableLoop(); return runOnCountableLoop();
return runOnNoncountableLoop(); return runOnNoncountableLoop();
} }
▲ Show 20 Lines • Show All 1,065 Lines • Show Last 20 Lines

lib/Transforms/Scalar/MemCpyOptimizer.cpp

Show First 20 Lines • Show All 1,268 Lines • ▼ Show 20 Linesbool MemCpyOptPass::processMemCpy(MemCpyInst *M) {
return false; return false;
} }
/// Transforms memmove calls to memcpy calls when the src/dst are guaranteed /// Transforms memmove calls to memcpy calls when the src/dst are guaranteed
/// not to alias. /// not to alias.
bool MemCpyOptPass::processMemMove(MemMoveInst *M) { bool MemCpyOptPass::processMemMove(MemMoveInst *M) {
AliasAnalysis &AA = LookupAliasAnalysis(); AliasAnalysis &AA = LookupAliasAnalysis();
if (!TLI->has(LibFunc::memmove)) if (!TLI->has(LibFunc::LibFunc_memmove))
efriedmaUnsubmitted
Done
ReplyInline Actions

?

efriedma: ?
return false; return false;
// See if the pointers alias. // See if the pointers alias.
if (!AA.isNoAlias(MemoryLocation::getForDest(M), if (!AA.isNoAlias(MemoryLocation::getForDest(M),
MemoryLocation::getForSource(M))) MemoryLocation::getForSource(M)))
return false; return false;
DEBUG(dbgs() << "MemCpyOptPass: Optimizing memmove -> memcpy: " << *M DEBUG(dbgs() << "MemCpyOptPass: Optimizing memmove -> memcpy: " << *M
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Linesbool MemCpyOptPass::runImpl(
TLI = TLI_; TLI = TLI_;
LookupAliasAnalysis = std::move(LookupAliasAnalysis_); LookupAliasAnalysis = std::move(LookupAliasAnalysis_);
LookupAssumptionCache = std::move(LookupAssumptionCache_); LookupAssumptionCache = std::move(LookupAssumptionCache_);
LookupDomTree = std::move(LookupDomTree_); LookupDomTree = std::move(LookupDomTree_);
// If we don't have at least memset and memcpy, there is little point of doing // If we don't have at least memset and memcpy, there is little point of doing
// anything here. These are required by a freestanding implementation, so if // anything here. These are required by a freestanding implementation, so if
// even they are disabled, there is no point in trying hard. // even they are disabled, there is no point in trying hard.
if (!TLI->has(LibFunc::memset) || !TLI->has(LibFunc::memcpy)) if (!TLI->has(LibFunc_memset) || !TLI->has(LibFunc_memcpy))
return false; return false;
while (true) { while (true) {
if (!iterateOnFunction(F)) if (!iterateOnFunction(F))
break; break;
MadeChange = true; MadeChange = true;
} }
Show All 25 Lines

lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines for (BasicBlock::iterator II = CurrBB->begin(), IE = CurrBB->end();
CallInst *Call = dyn_cast<CallInst>(&*II); CallInst *Call = dyn_cast<CallInst>(&*II);
Function *CalledFunc; Function *CalledFunc;
if (!Call || !(CalledFunc = Call->getCalledFunction())) if (!Call || !(CalledFunc = Call->getCalledFunction()))
continue; continue;
// Skip if function either has local linkage or is not a known library // Skip if function either has local linkage or is not a known library
// function. // function.
LibFunc::Func LibFunc; LibFunc LF;
if (CalledFunc->hasLocalLinkage() || !CalledFunc->hasName() || if (CalledFunc->hasLocalLinkage() || !CalledFunc->hasName() ||
!TLI->getLibFunc(CalledFunc->getName(), LibFunc)) !TLI->getLibFunc(CalledFunc->getName(), LF))
continue; continue;
switch (LibFunc) { switch (LF) {
case LibFunc::sqrtf: case LibFunc_sqrtf:
case LibFunc::sqrt: case LibFunc_sqrt:
if (TTI->haveFastSqrt(Call->getType()) && if (TTI->haveFastSqrt(Call->getType()) &&
optimizeSQRT(Call, CalledFunc, *CurrBB, BB)) optimizeSQRT(Call, CalledFunc, *CurrBB, BB))
break; break;
continue; continue;
default: default:
continue; continue;
} }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

lib/Transforms/Utils/BuildLibCalls.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Linesstatic bool setNonNull(Function &F, unsigned n) {
if (F.getAttributes().hasAttribute(n, Attribute::NonNull)) if (F.getAttributes().hasAttribute(n, Attribute::NonNull))
return false; return false;
F.addAttribute(n, Attribute::NonNull); F.addAttribute(n, Attribute::NonNull);
++NumNonNull; ++NumNonNull;
return true; return true;
} }
bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) { bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
LibFunc::Func TheLibFunc; LibFunc TheLibFunc;
if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc))) if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
return false; return false;
bool Changed = false; bool Changed = false;
switch (TheLibFunc) { switch (TheLibFunc) {
case LibFunc::strlen: case LibFunc_strlen:
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::strchr: case LibFunc_strchr:
case LibFunc::strrchr: case LibFunc_strrchr:
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
return Changed; return Changed;
case LibFunc::strtol: case LibFunc_strtol:
case LibFunc::strtod: case LibFunc_strtod:
case LibFunc::strtof: case LibFunc_strtof:
case LibFunc::strtoul: case LibFunc_strtoul:
case LibFunc::strtoll: case LibFunc_strtoll:
case LibFunc::strtold: case LibFunc_strtold:
case LibFunc::strtoull: case LibFunc_strtoull:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::strcpy: case LibFunc_strcpy:
case LibFunc::stpcpy: case LibFunc_stpcpy:
case LibFunc::strcat: case LibFunc_strcat:
case LibFunc::strncat: case LibFunc_strncat:
case LibFunc::strncpy: case LibFunc_strncpy:
case LibFunc::stpncpy: case LibFunc_stpncpy:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::strxfrm: case LibFunc_strxfrm:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::strcmp: // 0,1 case LibFunc_strcmp: // 0,1
case LibFunc::strspn: // 0,1 case LibFunc_strspn: // 0,1
case LibFunc::strncmp: // 0,1 case LibFunc_strncmp: // 0,1
case LibFunc::strcspn: // 0,1 case LibFunc_strcspn: // 0,1
case LibFunc::strcoll: // 0,1 case LibFunc_strcoll: // 0,1
case LibFunc::strcasecmp: // 0,1 case LibFunc_strcasecmp: // 0,1
case LibFunc::strncasecmp: // case LibFunc_strncasecmp: //
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::strstr: case LibFunc_strstr:
case LibFunc::strpbrk: case LibFunc_strpbrk:
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::strtok: case LibFunc_strtok:
case LibFunc::strtok_r: case LibFunc_strtok_r:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::scanf: case LibFunc_scanf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::setbuf: case LibFunc_setbuf:
case LibFunc::setvbuf: case LibFunc_setvbuf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::strdup: case LibFunc_strdup:
case LibFunc::strndup: case LibFunc_strndup:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::stat: case LibFunc_stat:
case LibFunc::statvfs: case LibFunc_statvfs:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::sscanf: case LibFunc_sscanf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::sprintf: case LibFunc_sprintf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::snprintf: case LibFunc_snprintf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 3); Changed |= setDoesNotCapture(F, 3);
Changed |= setOnlyReadsMemory(F, 3); Changed |= setOnlyReadsMemory(F, 3);
return Changed; return Changed;
case LibFunc::setitimer: case LibFunc_setitimer:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setDoesNotCapture(F, 3); Changed |= setDoesNotCapture(F, 3);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::system: case LibFunc_system:
// May throw; "system" is a valid pthread cancellation point. // May throw; "system" is a valid pthread cancellation point.
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::malloc: case LibFunc_malloc:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
return Changed; return Changed;
case LibFunc::memcmp: case LibFunc_memcmp:
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::memchr: case LibFunc_memchr:
case LibFunc::memrchr: case LibFunc_memrchr:
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
return Changed; return Changed;
case LibFunc::modf: case LibFunc_modf:
case LibFunc::modff: case LibFunc_modff:
case LibFunc::modfl: case LibFunc_modfl:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::memcpy: case LibFunc_memcpy:
case LibFunc::mempcpy: case LibFunc_mempcpy:
case LibFunc::memccpy: case LibFunc_memccpy:
case LibFunc::memmove: case LibFunc_memmove:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::memcpy_chk: case LibFunc_memcpy_chk:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
return Changed; return Changed;
case LibFunc::memalign: case LibFunc_memalign:
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
return Changed; return Changed;
case LibFunc::mkdir: case LibFunc_mkdir:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::mktime: case LibFunc_mktime:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::realloc: case LibFunc_realloc:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::read: case LibFunc_read:
// May throw; "read" is a valid pthread cancellation point. // May throw; "read" is a valid pthread cancellation point.
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::rewind: case LibFunc_rewind:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::rmdir: case LibFunc_rmdir:
case LibFunc::remove: case LibFunc_remove:
case LibFunc::realpath: case LibFunc_realpath:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::rename: case LibFunc_rename:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::readlink: case LibFunc_readlink:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::write: case LibFunc_write:
// May throw; "write" is a valid pthread cancellation point. // May throw; "write" is a valid pthread cancellation point.
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::bcopy: case LibFunc_bcopy:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::bcmp: case LibFunc_bcmp:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::bzero: case LibFunc_bzero:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::calloc: case LibFunc_calloc:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
return Changed; return Changed;
case LibFunc::chmod: case LibFunc_chmod:
case LibFunc::chown: case LibFunc_chown:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::ctermid: case LibFunc_ctermid:
case LibFunc::clearerr: case LibFunc_clearerr:
case LibFunc::closedir: case LibFunc_closedir:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::atoi: case LibFunc_atoi:
case LibFunc::atol: case LibFunc_atol:
case LibFunc::atof: case LibFunc_atof:
case LibFunc::atoll: case LibFunc_atoll:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::access: case LibFunc_access:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::fopen: case LibFunc_fopen:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::fdopen: case LibFunc_fdopen:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::feof: case LibFunc_feof:
case LibFunc::free: case LibFunc_free:
case LibFunc::fseek: case LibFunc_fseek:
case LibFunc::ftell: case LibFunc_ftell:
case LibFunc::fgetc: case LibFunc_fgetc:
case LibFunc::fseeko: case LibFunc_fseeko:
case LibFunc::ftello: case LibFunc_ftello:
case LibFunc::fileno: case LibFunc_fileno:
case LibFunc::fflush: case LibFunc_fflush:
case LibFunc::fclose: case LibFunc_fclose:
case LibFunc::fsetpos: case LibFunc_fsetpos:
case LibFunc::flockfile: case LibFunc_flockfile:
case LibFunc::funlockfile: case LibFunc_funlockfile:
case LibFunc::ftrylockfile: case LibFunc_ftrylockfile:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::ferror: case LibFunc_ferror:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
return Changed; return Changed;
case LibFunc::fputc: case LibFunc_fputc:
case LibFunc::fstat: case LibFunc_fstat:
case LibFunc::frexp: case LibFunc_frexp:
case LibFunc::frexpf: case LibFunc_frexpf:
case LibFunc::frexpl: case LibFunc_frexpl:
case LibFunc::fstatvfs: case LibFunc_fstatvfs:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::fgets: case LibFunc_fgets:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 3); Changed |= setDoesNotCapture(F, 3);
return Changed; return Changed;
case LibFunc::fread: case LibFunc_fread:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 4); Changed |= setDoesNotCapture(F, 4);
return Changed; return Changed;
case LibFunc::fwrite: case LibFunc_fwrite:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 4); Changed |= setDoesNotCapture(F, 4);
// FIXME: readonly #1? // FIXME: readonly #1?
return Changed; return Changed;
case LibFunc::fputs: case LibFunc_fputs:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::fscanf: case LibFunc_fscanf:
case LibFunc::fprintf: case LibFunc_fprintf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::fgetpos: case LibFunc_fgetpos:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::getc: case LibFunc_getc:
case LibFunc::getlogin_r: case LibFunc_getlogin_r:
case LibFunc::getc_unlocked: case LibFunc_getc_unlocked:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::getenv: case LibFunc_getenv:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::gets: case LibFunc_gets:
case LibFunc::getchar: case LibFunc_getchar:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
return Changed; return Changed;
case LibFunc::getitimer: case LibFunc_getitimer:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::getpwnam: case LibFunc_getpwnam:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::ungetc: case LibFunc_ungetc:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::uname: case LibFunc_uname:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::unlink: case LibFunc_unlink:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::unsetenv: case LibFunc_unsetenv:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::utime: case LibFunc_utime:
case LibFunc::utimes: case LibFunc_utimes:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::putc: case LibFunc_putc:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::puts: case LibFunc_puts:
case LibFunc::printf: case LibFunc_printf:
case LibFunc::perror: case LibFunc_perror:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::pread: case LibFunc_pread:
// May throw; "pread" is a valid pthread cancellation point. // May throw; "pread" is a valid pthread cancellation point.
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::pwrite: case LibFunc_pwrite:
// May throw; "pwrite" is a valid pthread cancellation point. // May throw; "pwrite" is a valid pthread cancellation point.
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::putchar: case LibFunc_putchar:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
return Changed; return Changed;
case LibFunc::popen: case LibFunc_popen:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::pclose: case LibFunc_pclose:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::vscanf: case LibFunc_vscanf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::vsscanf: case LibFunc_vsscanf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::vfscanf: case LibFunc_vfscanf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::valloc: case LibFunc_valloc:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
return Changed; return Changed;
case LibFunc::vprintf: case LibFunc_vprintf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::vfprintf: case LibFunc_vfprintf:
case LibFunc::vsprintf: case LibFunc_vsprintf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::vsnprintf: case LibFunc_vsnprintf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 3); Changed |= setDoesNotCapture(F, 3);
Changed |= setOnlyReadsMemory(F, 3); Changed |= setOnlyReadsMemory(F, 3);
return Changed; return Changed;
case LibFunc::open: case LibFunc_open:
// May throw; "open" is a valid pthread cancellation point. // May throw; "open" is a valid pthread cancellation point.
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::opendir: case LibFunc_opendir:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::tmpfile: case LibFunc_tmpfile:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
return Changed; return Changed;
case LibFunc::times: case LibFunc_times:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::htonl: case LibFunc_htonl:
case LibFunc::htons: case LibFunc_htons:
case LibFunc::ntohl: case LibFunc_ntohl:
case LibFunc::ntohs: case LibFunc_ntohs:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAccessMemory(F); Changed |= setDoesNotAccessMemory(F);
return Changed; return Changed;
case LibFunc::lstat: case LibFunc_lstat:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::lchown: case LibFunc_lchown:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::qsort: case LibFunc_qsort:
// May throw; places call through function pointer. // May throw; places call through function pointer.
Changed |= setDoesNotCapture(F, 4); Changed |= setDoesNotCapture(F, 4);
return Changed; return Changed;
case LibFunc::dunder_strdup: case LibFunc_dunder_strdup:
case LibFunc::dunder_strndup: case LibFunc_dunder_strndup:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::dunder_strtok_r: case LibFunc_dunder_strtok_r:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::under_IO_getc: case LibFunc_under_IO_getc:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::under_IO_putc: case LibFunc_under_IO_putc:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::dunder_isoc99_scanf: case LibFunc_dunder_isoc99_scanf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::stat64: case LibFunc_stat64:
case LibFunc::lstat64: case LibFunc_lstat64:
case LibFunc::statvfs64: case LibFunc_statvfs64:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::dunder_isoc99_sscanf: case LibFunc_dunder_isoc99_sscanf:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::fopen64: case LibFunc_fopen64:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc::fseeko64: case LibFunc_fseeko64:
case LibFunc::ftello64: case LibFunc_ftello64:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc::tmpfile64: case LibFunc_tmpfile64:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
return Changed; return Changed;
case LibFunc::fstat64: case LibFunc_fstat64:
case LibFunc::fstatvfs64: case LibFunc_fstatvfs64:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::open64: case LibFunc_open64:
// May throw; "open" is a valid pthread cancellation point. // May throw; "open" is a valid pthread cancellation point.
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc::gettimeofday: case LibFunc_gettimeofday:
// Currently some platforms have the restrict keyword on the arguments to // Currently some platforms have the restrict keyword on the arguments to
// gettimeofday. To be conservative, do not add noalias to gettimeofday's // gettimeofday. To be conservative, do not add noalias to gettimeofday's
// arguments. // arguments.
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
return Changed; return Changed;
case LibFunc::Znwj: // new(unsigned int) case LibFunc_Znwj: // new(unsigned int)
case LibFunc::Znwm: // new(unsigned long) case LibFunc_Znwm: // new(unsigned long)
case LibFunc::Znaj: // new[](unsigned int) case LibFunc_Znaj: // new[](unsigned int)
case LibFunc::Znam: // new[](unsigned long) case LibFunc_Znam: // new[](unsigned long)
case LibFunc::msvc_new_int: // new(unsigned int) case LibFunc_msvc_new_int: // new(unsigned int)
case LibFunc::msvc_new_longlong: // new(unsigned long long) case LibFunc_msvc_new_longlong: // new(unsigned long long)
case LibFunc::msvc_new_array_int: // new[](unsigned int) case LibFunc_msvc_new_array_int: // new[](unsigned int)
case LibFunc::msvc_new_array_longlong: // new[](unsigned long long) case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
// Operator new always returns a nonnull noalias pointer // Operator new always returns a nonnull noalias pointer
Changed |= setNonNull(F, AttributeSet::ReturnIndex); Changed |= setNonNull(F, AttributeSet::ReturnIndex);
Changed |= setDoesNotAlias(F, AttributeSet::ReturnIndex); Changed |= setDoesNotAlias(F, AttributeSet::ReturnIndex);
return Changed; return Changed;
//TODO: add LibFunc entries for: //TODO: add LibFunc entries for:
//case LibFunc::memset_pattern4: //case LibFunc_memset_pattern4:
//case LibFunc::memset_pattern8: //case LibFunc_memset_pattern8:
case LibFunc::memset_pattern16: case LibFunc_memset_pattern16:
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
// int __nvvm_reflect(const char *) // int __nvvm_reflect(const char *)
case LibFunc::nvvm_reflect: case LibFunc_nvvm_reflect:
Changed |= setDoesNotAccessMemory(F); Changed |= setDoesNotAccessMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
return Changed; return Changed;
default: default:
// FIXME: It'd be really nice to cover all the library functions we're // FIXME: It'd be really nice to cover all the library functions we're
// aware of here. // aware of here.
return false; return false;
} }
} }
//- Emit LibCalls ------------------------------------------------------------// //- Emit LibCalls ------------------------------------------------------------//
Value *llvm::castToCStr(Value *V, IRBuilder<> &B) { Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
unsigned AS = V->getType()->getPointerAddressSpace(); unsigned AS = V->getType()->getPointerAddressSpace();
return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr"); return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
} }
Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL, Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::strlen)) if (!TLI->has(LibFunc_strlen))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Constant *StrLen = M->getOrInsertFunction("strlen", DL.getIntPtrType(Context), Constant *StrLen = M->getOrInsertFunction("strlen", DL.getIntPtrType(Context),
B.getInt8PtrTy(), nullptr); B.getInt8PtrTy(), nullptr);
inferLibFuncAttributes(*M->getFunction("strlen"), *TLI); inferLibFuncAttributes(*M->getFunction("strlen"), *TLI);
CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), "strlen"); CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), "strlen");
if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B, Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::strchr)) if (!TLI->has(LibFunc_strchr))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
Type *I8Ptr = B.getInt8PtrTy(); Type *I8Ptr = B.getInt8PtrTy();
Type *I32Ty = B.getInt32Ty(); Type *I32Ty = B.getInt32Ty();
Constant *StrChr = Constant *StrChr =
M->getOrInsertFunction("strchr", I8Ptr, I8Ptr, I32Ty, nullptr); M->getOrInsertFunction("strchr", I8Ptr, I8Ptr, I32Ty, nullptr);
inferLibFuncAttributes(*M->getFunction("strchr"), *TLI); inferLibFuncAttributes(*M->getFunction("strchr"), *TLI);
CallInst *CI = B.CreateCall( CallInst *CI = B.CreateCall(
StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, "strchr"); StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, "strchr");
if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) { const DataLayout &DL, const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::strncmp)) if (!TLI->has(LibFunc_strncmp))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *StrNCmp = M->getOrInsertFunction("strncmp", B.getInt32Ty(), Value *StrNCmp = M->getOrInsertFunction("strncmp", B.getInt32Ty(),
B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt8PtrTy(),
DL.getIntPtrType(Context), nullptr); DL.getIntPtrType(Context), nullptr);
inferLibFuncAttributes(*M->getFunction("strncmp"), *TLI); inferLibFuncAttributes(*M->getFunction("strncmp"), *TLI);
CallInst *CI = B.CreateCall( CallInst *CI = B.CreateCall(
StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "strncmp"); StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "strncmp");
if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B, Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
const TargetLibraryInfo *TLI, StringRef Name) { const TargetLibraryInfo *TLI, StringRef Name) {
if (!TLI->has(LibFunc::strcpy)) if (!TLI->has(LibFunc_strcpy))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
Type *I8Ptr = B.getInt8PtrTy(); Type *I8Ptr = B.getInt8PtrTy();
Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr, nullptr); Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr, nullptr);
inferLibFuncAttributes(*M->getFunction(Name), *TLI); inferLibFuncAttributes(*M->getFunction(Name), *TLI);
CallInst *CI = CallInst *CI =
B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name); B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);
if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B, Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
const TargetLibraryInfo *TLI, StringRef Name) { const TargetLibraryInfo *TLI, StringRef Name) {
if (!TLI->has(LibFunc::strncpy)) if (!TLI->has(LibFunc_strncpy))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
Type *I8Ptr = B.getInt8PtrTy(); Type *I8Ptr = B.getInt8PtrTy();
Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr, Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,
Len->getType(), nullptr); Len->getType(), nullptr);
inferLibFuncAttributes(*M->getFunction(Name), *TLI); inferLibFuncAttributes(*M->getFunction(Name), *TLI);
CallInst *CI = B.CreateCall( CallInst *CI = B.CreateCall(
StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, "strncpy"); StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, "strncpy");
if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
IRBuilder<> &B, const DataLayout &DL, IRBuilder<> &B, const DataLayout &DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::memcpy_chk)) if (!TLI->has(LibFunc_memcpy_chk))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
AttributeSet AS; AttributeSet AS;
AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
Attribute::NoUnwind); Attribute::NoUnwind);
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemCpy = M->getOrInsertFunction( Value *MemCpy = M->getOrInsertFunction(
"__memcpy_chk", AttributeSet::get(M->getContext(), AS), B.getInt8PtrTy(), "__memcpy_chk", AttributeSet::get(M->getContext(), AS), B.getInt8PtrTy(),
B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context), B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
DL.getIntPtrType(Context), nullptr); DL.getIntPtrType(Context), nullptr);
Dst = castToCStr(Dst, B); Dst = castToCStr(Dst, B);
Src = castToCStr(Src, B); Src = castToCStr(Src, B);
CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize}); CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B, Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) { const DataLayout &DL, const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::memchr)) if (!TLI->has(LibFunc_memchr))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemChr = M->getOrInsertFunction("memchr", B.getInt8PtrTy(), Value *MemChr = M->getOrInsertFunction("memchr", B.getInt8PtrTy(),
B.getInt8PtrTy(), B.getInt32Ty(), B.getInt8PtrTy(), B.getInt32Ty(),
DL.getIntPtrType(Context), nullptr); DL.getIntPtrType(Context), nullptr);
inferLibFuncAttributes(*M->getFunction("memchr"), *TLI); inferLibFuncAttributes(*M->getFunction("memchr"), *TLI);
CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, "memchr"); CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, "memchr");
if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) { const DataLayout &DL, const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::memcmp)) if (!TLI->has(LibFunc_memcmp))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemCmp = M->getOrInsertFunction("memcmp", B.getInt32Ty(), Value *MemCmp = M->getOrInsertFunction("memcmp", B.getInt32Ty(),
B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt8PtrTy(),
DL.getIntPtrType(Context), nullptr); DL.getIntPtrType(Context), nullptr);
inferLibFuncAttributes(*M->getFunction("memcmp"), *TLI); inferLibFuncAttributes(*M->getFunction("memcmp"), *TLI);
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 LinesValue *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B, Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::putchar)) if (!TLI->has(LibFunc_putchar))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(), Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(),
B.getInt32Ty(), nullptr); B.getInt32Ty(), nullptr);
CallInst *CI = B.CreateCall(PutChar, CallInst *CI = B.CreateCall(PutChar,
B.CreateIntCast(Char, B.CreateIntCast(Char,
B.getInt32Ty(), B.getInt32Ty(),
/*isSigned*/true, /*isSigned*/true,
"chari"), "chari"),
"putchar"); "putchar");
if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitPutS(Value *Str, IRBuilder<> &B, Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::puts)) if (!TLI->has(LibFunc_puts))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
Value *PutS = Value *PutS =
M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy(), nullptr); M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy(), nullptr);
inferLibFuncAttributes(*M->getFunction("puts"), *TLI); inferLibFuncAttributes(*M->getFunction("puts"), *TLI);
CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), "puts"); CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), "puts");
if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B, Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::fputc)) if (!TLI->has(LibFunc_fputc))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
Constant *F = M->getOrInsertFunction("fputc", B.getInt32Ty(), B.getInt32Ty(), Constant *F = M->getOrInsertFunction("fputc", B.getInt32Ty(), B.getInt32Ty(),
File->getType(), nullptr); File->getType(), nullptr);
if (File->getType()->isPointerTy()) if (File->getType()->isPointerTy())
inferLibFuncAttributes(*M->getFunction("fputc"), *TLI); inferLibFuncAttributes(*M->getFunction("fputc"), *TLI);
Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true, Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
"chari"); "chari");
CallInst *CI = B.CreateCall(F, {Char, File}, "fputc"); CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");
if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts())) if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
CI->setCallingConv(Fn->getCallingConv()); CI->setCallingConv(Fn->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B, Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::fputs)) if (!TLI->has(LibFunc_fputs))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
StringRef FPutsName = TLI->getName(LibFunc::fputs); StringRef FPutsName = TLI->getName(LibFunc_fputs);
Constant *F = M->getOrInsertFunction( Constant *F = M->getOrInsertFunction(
FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType(), nullptr); FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType(), nullptr);
if (File->getType()->isPointerTy()) if (File->getType()->isPointerTy())
inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI); inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI);
CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs"); CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs");
if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts())) if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
CI->setCallingConv(Fn->getCallingConv()); CI->setCallingConv(Fn->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B, Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) { const DataLayout &DL, const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::fwrite)) if (!TLI->has(LibFunc_fwrite))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
StringRef FWriteName = TLI->getName(LibFunc::fwrite); StringRef FWriteName = TLI->getName(LibFunc_fwrite);
Constant *F = M->getOrInsertFunction( Constant *F = M->getOrInsertFunction(
FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(), FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType(), DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType(),
nullptr); nullptr);
if (File->getType()->isPointerTy()) if (File->getType()->isPointerTy())
inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI); inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);
CallInst *CI = CallInst *CI =
B.CreateCall(F, {castToCStr(Ptr, B), Size, B.CreateCall(F, {castToCStr(Ptr, B), Size,
ConstantInt::get(DL.getIntPtrType(Context), 1), File}); ConstantInt::get(DL.getIntPtrType(Context), 1), File});
if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts())) if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
CI->setCallingConv(Fn->getCallingConv()); CI->setCallingConv(Fn->getCallingConv());
return CI; return CI;
} }

lib/Transforms/Utils/LibCallsShrinkWrap.cpp

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines for (auto &CI : WorkList) {
} }
} }
} }
private: private:
bool perform(CallInst *CI); bool perform(CallInst *CI);
void checkCandidate(CallInst &CI); void checkCandidate(CallInst &CI);
void shrinkWrapCI(CallInst *CI, Value *Cond); void shrinkWrapCI(CallInst *CI, Value *Cond);
bool performCallDomainErrorOnly(CallInst *CI, const LibFunc::Func &Func); bool performCallDomainErrorOnly(CallInst *CI, const LibFunc &Func);
bool performCallErrors(CallInst *CI, const LibFunc::Func &Func); bool performCallErrors(CallInst *CI, const LibFunc &Func);
bool performCallRangeErrorOnly(CallInst *CI, const LibFunc::Func &Func); bool performCallRangeErrorOnly(CallInst *CI, const LibFunc &Func);
Value *generateOneRangeCond(CallInst *CI, const LibFunc::Func &Func); Value *generateOneRangeCond(CallInst *CI, const LibFunc &Func);
Value *generateTwoRangeCond(CallInst *CI, const LibFunc::Func &Func); Value *generateTwoRangeCond(CallInst *CI, const LibFunc &Func);
Value *generateCondForPow(CallInst *CI, const LibFunc::Func &Func); Value *generateCondForPow(CallInst *CI, const LibFunc &Func);
// Create an OR of two conditions. // Create an OR of two conditions.
Value *createOrCond(CallInst *CI, CmpInst::Predicate Cmp, float Val, Value *createOrCond(CallInst *CI, CmpInst::Predicate Cmp, float Val,
CmpInst::Predicate Cmp2, float Val2) { CmpInst::Predicate Cmp2, float Val2) {
IRBuilder<> BBBuilder(CI); IRBuilder<> BBBuilder(CI);
Value *Arg = CI->getArgOperand(0); Value *Arg = CI->getArgOperand(0);
auto Cond2 = createCond(BBBuilder, Arg, Cmp2, Val2); auto Cond2 = createCond(BBBuilder, Arg, Cmp2, Val2);
auto Cond1 = createCond(BBBuilder, Arg, Cmp, Val); auto Cond1 = createCond(BBBuilder, Arg, Cmp, Val);
Show All 19 Linesprivate:
const TargetLibraryInfo &TLI; const TargetLibraryInfo &TLI;
SmallVector<CallInst *, 16> WorkList; SmallVector<CallInst *, 16> WorkList;
bool Changed; bool Changed;
}; };
} // end anonymous namespace } // end anonymous namespace
// Perform the transformation to calls with errno set by domain error. // Perform the transformation to calls with errno set by domain error.
bool LibCallsShrinkWrap::performCallDomainErrorOnly(CallInst *CI, bool LibCallsShrinkWrap::performCallDomainErrorOnly(CallInst *CI,
const LibFunc::Func &Func) { const LibFunc &Func) {
Value *Cond = nullptr; Value *Cond = nullptr;
switch (Func) { switch (Func) {
case LibFunc::acos: // DomainError: (x < -1 || x > 1) case LibFunc_acos: // DomainError: (x < -1 || x > 1)
case LibFunc::acosf: // Same as acos case LibFunc_acosf: // Same as acos
case LibFunc::acosl: // Same as acos case LibFunc_acosl: // Same as acos
case LibFunc::asin: // DomainError: (x < -1 || x > 1) case LibFunc_asin: // DomainError: (x < -1 || x > 1)
case LibFunc::asinf: // Same as asin case LibFunc_asinf: // Same as asin
case LibFunc::asinl: // Same as asin case LibFunc_asinl: // Same as asin
{ {
++NumWrappedTwoCond; ++NumWrappedTwoCond;
Cond = createOrCond(CI, CmpInst::FCMP_OLT, -1.0f, CmpInst::FCMP_OGT, 1.0f); Cond = createOrCond(CI, CmpInst::FCMP_OLT, -1.0f, CmpInst::FCMP_OGT, 1.0f);
break; break;
} }
case LibFunc::cos: // DomainError: (x == +inf || x == -inf) case LibFunc_cos: // DomainError: (x == +inf || x == -inf)
case LibFunc::cosf: // Same as cos case LibFunc_cosf: // Same as cos
case LibFunc::cosl: // Same as cos case LibFunc_cosl: // Same as cos
case LibFunc::sin: // DomainError: (x == +inf || x == -inf) case LibFunc_sin: // DomainError: (x == +inf || x == -inf)
case LibFunc::sinf: // Same as sin case LibFunc_sinf: // Same as sin
case LibFunc::sinl: // Same as sin case LibFunc_sinl: // Same as sin
{ {
++NumWrappedTwoCond; ++NumWrappedTwoCond;
Cond = createOrCond(CI, CmpInst::FCMP_OEQ, INFINITY, CmpInst::FCMP_OEQ, Cond = createOrCond(CI, CmpInst::FCMP_OEQ, INFINITY, CmpInst::FCMP_OEQ,
-INFINITY); -INFINITY);
break; break;
} }
case LibFunc::acosh: // DomainError: (x < 1) case LibFunc_acosh: // DomainError: (x < 1)
case LibFunc::acoshf: // Same as acosh case LibFunc_acoshf: // Same as acosh
case LibFunc::acoshl: // Same as acosh case LibFunc_acoshl: // Same as acosh
{ {
++NumWrappedOneCond; ++NumWrappedOneCond;
Cond = createCond(CI, CmpInst::FCMP_OLT, 1.0f); Cond = createCond(CI, CmpInst::FCMP_OLT, 1.0f);
break; break;
} }
case LibFunc::sqrt: // DomainError: (x < 0) case LibFunc_sqrt: // DomainError: (x < 0)
case LibFunc::sqrtf: // Same as sqrt case LibFunc_sqrtf: // Same as sqrt
case LibFunc::sqrtl: // Same as sqrt case LibFunc_sqrtl: // Same as sqrt
{ {
++NumWrappedOneCond; ++NumWrappedOneCond;
Cond = createCond(CI, CmpInst::FCMP_OLT, 0.0f); Cond = createCond(CI, CmpInst::FCMP_OLT, 0.0f);
break; break;
} }
default: default:
return false; return false;
} }
shrinkWrapCI(CI, Cond); shrinkWrapCI(CI, Cond);
return true; return true;
} }
// Perform the transformation to calls with errno set by range error. // Perform the transformation to calls with errno set by range error.
bool LibCallsShrinkWrap::performCallRangeErrorOnly(CallInst *CI, bool LibCallsShrinkWrap::performCallRangeErrorOnly(CallInst *CI,
const LibFunc::Func &Func) { const LibFunc &Func) {
Value *Cond = nullptr; Value *Cond = nullptr;
switch (Func) { switch (Func) {
case LibFunc::cosh: case LibFunc_cosh:
case LibFunc::coshf: case LibFunc_coshf:
case LibFunc::coshl: case LibFunc_coshl:
case LibFunc::exp: case LibFunc_exp:
case LibFunc::expf: case LibFunc_expf:
case LibFunc::expl: case LibFunc_expl:
case LibFunc::exp10: case LibFunc_exp10:
case LibFunc::exp10f: case LibFunc_exp10f:
case LibFunc::exp10l: case LibFunc_exp10l:
case LibFunc::exp2: case LibFunc_exp2:
case LibFunc::exp2f: case LibFunc_exp2f:
case LibFunc::exp2l: case LibFunc_exp2l:
case LibFunc::sinh: case LibFunc_sinh:
case LibFunc::sinhf: case LibFunc_sinhf:
case LibFunc::sinhl: { case LibFunc_sinhl: {
Cond = generateTwoRangeCond(CI, Func); Cond = generateTwoRangeCond(CI, Func);
break; break;
} }
case LibFunc::expm1: // RangeError: (709, inf) case LibFunc_expm1: // RangeError: (709, inf)
case LibFunc::expm1f: // RangeError: (88, inf) case LibFunc_expm1f: // RangeError: (88, inf)
case LibFunc::expm1l: // RangeError: (11356, inf) case LibFunc_expm1l: // RangeError: (11356, inf)
{ {
Cond = generateOneRangeCond(CI, Func); Cond = generateOneRangeCond(CI, Func);
break; break;
} }
default: default:
return false; return false;
} }
shrinkWrapCI(CI, Cond); shrinkWrapCI(CI, Cond);
return true; return true;
} }
// Perform the transformation to calls with errno set by combination of errors. // Perform the transformation to calls with errno set by combination of errors.
bool LibCallsShrinkWrap::performCallErrors(CallInst *CI, bool LibCallsShrinkWrap::performCallErrors(CallInst *CI,
const LibFunc::Func &Func) { const LibFunc &Func) {
Value *Cond = nullptr; Value *Cond = nullptr;
switch (Func) { switch (Func) {
case LibFunc::atanh: // DomainError: (x < -1 || x > 1) case LibFunc_atanh: // DomainError: (x < -1 || x > 1)
// PoleError: (x == -1 || x == 1) // PoleError: (x == -1 || x == 1)
// Overall Cond: (x <= -1 || x >= 1) // Overall Cond: (x <= -1 || x >= 1)
case LibFunc::atanhf: // Same as atanh case LibFunc_atanhf: // Same as atanh
case LibFunc::atanhl: // Same as atanh case LibFunc_atanhl: // Same as atanh
{ {
if (!LibCallsShrinkWrapDoDomainError || !LibCallsShrinkWrapDoPoleError) if (!LibCallsShrinkWrapDoDomainError || !LibCallsShrinkWrapDoPoleError)
return false; return false;
++NumWrappedTwoCond; ++NumWrappedTwoCond;
Cond = createOrCond(CI, CmpInst::FCMP_OLE, -1.0f, CmpInst::FCMP_OGE, 1.0f); Cond = createOrCond(CI, CmpInst::FCMP_OLE, -1.0f, CmpInst::FCMP_OGE, 1.0f);
break; break;
} }
case LibFunc::log: // DomainError: (x < 0) case LibFunc_log: // DomainError: (x < 0)
// PoleError: (x == 0) // PoleError: (x == 0)
// Overall Cond: (x <= 0) // Overall Cond: (x <= 0)
case LibFunc::logf: // Same as log case LibFunc_logf: // Same as log
case LibFunc::logl: // Same as log case LibFunc_logl: // Same as log
case LibFunc::log10: // Same as log case LibFunc_log10: // Same as log
case LibFunc::log10f: // Same as log case LibFunc_log10f: // Same as log
case LibFunc::log10l: // Same as log case LibFunc_log10l: // Same as log
case LibFunc::log2: // Same as log case LibFunc_log2: // Same as log
case LibFunc::log2f: // Same as log case LibFunc_log2f: // Same as log
case LibFunc::log2l: // Same as log case LibFunc_log2l: // Same as log
case LibFunc::logb: // Same as log case LibFunc_logb: // Same as log
case LibFunc::logbf: // Same as log case LibFunc_logbf: // Same as log
case LibFunc::logbl: // Same as log case LibFunc_logbl: // Same as log
{ {
if (!LibCallsShrinkWrapDoDomainError || !LibCallsShrinkWrapDoPoleError) if (!LibCallsShrinkWrapDoDomainError || !LibCallsShrinkWrapDoPoleError)
return false; return false;
++NumWrappedOneCond; ++NumWrappedOneCond;
Cond = createCond(CI, CmpInst::FCMP_OLE, 0.0f); Cond = createCond(CI, CmpInst::FCMP_OLE, 0.0f);
break; break;
} }
case LibFunc::log1p: // DomainError: (x < -1) case LibFunc_log1p: // DomainError: (x < -1)
// PoleError: (x == -1) // PoleError: (x == -1)
// Overall Cond: (x <= -1) // Overall Cond: (x <= -1)
case LibFunc::log1pf: // Same as log1p case LibFunc_log1pf: // Same as log1p
case LibFunc::log1pl: // Same as log1p case LibFunc_log1pl: // Same as log1p
{ {
if (!LibCallsShrinkWrapDoDomainError || !LibCallsShrinkWrapDoPoleError) if (!LibCallsShrinkWrapDoDomainError || !LibCallsShrinkWrapDoPoleError)
return false; return false;
++NumWrappedOneCond; ++NumWrappedOneCond;
Cond = createCond(CI, CmpInst::FCMP_OLE, -1.0f); Cond = createCond(CI, CmpInst::FCMP_OLE, -1.0f);
break; break;
} }
case LibFunc::pow: // DomainError: x < 0 and y is noninteger case LibFunc_pow: // DomainError: x < 0 and y is noninteger
// PoleError: x == 0 and y < 0 // PoleError: x == 0 and y < 0
// RangeError: overflow or underflow // RangeError: overflow or underflow
case LibFunc::powf: case LibFunc_powf:
case LibFunc::powl: { case LibFunc_powl: {
if (!LibCallsShrinkWrapDoDomainError || !LibCallsShrinkWrapDoPoleError || if (!LibCallsShrinkWrapDoDomainError || !LibCallsShrinkWrapDoPoleError ||
!LibCallsShrinkWrapDoRangeError) !LibCallsShrinkWrapDoRangeError)
return false; return false;
Cond = generateCondForPow(CI, Func); Cond = generateCondForPow(CI, Func);
if (Cond == nullptr) if (Cond == nullptr)
return false; return false;
break; break;
} }
Show All 12 Lines if (CI.isNoBuiltin())
return; return;
// A possible improvement is to handle the calls with the return value being // A possible improvement is to handle the calls with the return value being
// used. If there is API for fast libcall implementation without setting // used. If there is API for fast libcall implementation without setting
// errno, we can use the same framework to direct/wrap the call to the fast // errno, we can use the same framework to direct/wrap the call to the fast
// API in the error free path, and leave the original call in the slow path. // API in the error free path, and leave the original call in the slow path.
if (!CI.use_empty()) if (!CI.use_empty())
return; return;
LibFunc::Func Func; LibFunc Func;
Function *Callee = CI.getCalledFunction(); Function *Callee = CI.getCalledFunction();
if (!Callee) if (!Callee)
return; return;
if (!TLI.getLibFunc(*Callee, Func) || !TLI.has(Func)) if (!TLI.getLibFunc(*Callee, Func) || !TLI.has(Func))
return; return;
if (CI.getNumArgOperands() == 0) if (CI.getNumArgOperands() == 0)
return; return;
// TODO: Handle long double in other formats. // TODO: Handle long double in other formats.
Type *ArgType = CI.getArgOperand(0)->getType(); Type *ArgType = CI.getArgOperand(0)->getType();
if (!(ArgType->isFloatTy() || ArgType->isDoubleTy() || if (!(ArgType->isFloatTy() || ArgType->isDoubleTy() ||
ArgType->isX86_FP80Ty())) ArgType->isX86_FP80Ty()))
return; return;
WorkList.push_back(&CI); WorkList.push_back(&CI);
} }
// Generate the upper bound condition for RangeError. // Generate the upper bound condition for RangeError.
Value *LibCallsShrinkWrap::generateOneRangeCond(CallInst *CI, Value *LibCallsShrinkWrap::generateOneRangeCond(CallInst *CI,
const LibFunc::Func &Func) { const LibFunc &Func) {
float UpperBound; float UpperBound;
switch (Func) { switch (Func) {
case LibFunc::expm1: // RangeError: (709, inf) case LibFunc_expm1: // RangeError: (709, inf)
UpperBound = 709.0f; UpperBound = 709.0f;
break; break;
case LibFunc::expm1f: // RangeError: (88, inf) case LibFunc_expm1f: // RangeError: (88, inf)
UpperBound = 88.0f; UpperBound = 88.0f;
break; break;
case LibFunc::expm1l: // RangeError: (11356, inf) case LibFunc_expm1l: // RangeError: (11356, inf)
UpperBound = 11356.0f; UpperBound = 11356.0f;
break; break;
default: default:
llvm_unreachable("Should be reach here"); llvm_unreachable("Should be reach here");
} }
++NumWrappedOneCond; ++NumWrappedOneCond;
return createCond(CI, CmpInst::FCMP_OGT, UpperBound); return createCond(CI, CmpInst::FCMP_OGT, UpperBound);
} }
// Generate the lower and upper bound condition for RangeError. // Generate the lower and upper bound condition for RangeError.
Value *LibCallsShrinkWrap::generateTwoRangeCond(CallInst *CI, Value *LibCallsShrinkWrap::generateTwoRangeCond(CallInst *CI,
const LibFunc::Func &Func) { const LibFunc &Func) {
float UpperBound, LowerBound; float UpperBound, LowerBound;
switch (Func) { switch (Func) {
case LibFunc::cosh: // RangeError: (x < -710 || x > 710) case LibFunc_cosh: // RangeError: (x < -710 || x > 710)
case LibFunc::sinh: // Same as cosh case LibFunc_sinh: // Same as cosh
LowerBound = -710.0f; LowerBound = -710.0f;
UpperBound = 710.0f; UpperBound = 710.0f;
break; break;
case LibFunc::coshf: // RangeError: (x < -89 || x > 89) case LibFunc_coshf: // RangeError: (x < -89 || x > 89)
case LibFunc::sinhf: // Same as coshf case LibFunc_sinhf: // Same as coshf
LowerBound = -89.0f; LowerBound = -89.0f;
UpperBound = 89.0f; UpperBound = 89.0f;
break; break;
case LibFunc::coshl: // RangeError: (x < -11357 || x > 11357) case LibFunc_coshl: // RangeError: (x < -11357 || x > 11357)
case LibFunc::sinhl: // Same as coshl case LibFunc_sinhl: // Same as coshl
LowerBound = -11357.0f; LowerBound = -11357.0f;
UpperBound = 11357.0f; UpperBound = 11357.0f;
break; break;
case LibFunc::exp: // RangeError: (x < -745 || x > 709) case LibFunc_exp: // RangeError: (x < -745 || x > 709)
LowerBound = -745.0f; LowerBound = -745.0f;
UpperBound = 709.0f; UpperBound = 709.0f;
break; break;
case LibFunc::expf: // RangeError: (x < -103 || x > 88) case LibFunc_expf: // RangeError: (x < -103 || x > 88)
LowerBound = -103.0f; LowerBound = -103.0f;
UpperBound = 88.0f; UpperBound = 88.0f;
break; break;
case LibFunc::expl: // RangeError: (x < -11399 || x > 11356) case LibFunc_expl: // RangeError: (x < -11399 || x > 11356)
LowerBound = -11399.0f; LowerBound = -11399.0f;
UpperBound = 11356.0f; UpperBound = 11356.0f;
break; break;
case LibFunc::exp10: // RangeError: (x < -323 || x > 308) case LibFunc_exp10: // RangeError: (x < -323 || x > 308)
LowerBound = -323.0f; LowerBound = -323.0f;
UpperBound = 308.0f; UpperBound = 308.0f;
break; break;
case LibFunc::exp10f: // RangeError: (x < -45 || x > 38) case LibFunc_exp10f: // RangeError: (x < -45 || x > 38)
LowerBound = -45.0f; LowerBound = -45.0f;
UpperBound = 38.0f; UpperBound = 38.0f;
break; break;
case LibFunc::exp10l: // RangeError: (x < -4950 || x > 4932) case LibFunc_exp10l: // RangeError: (x < -4950 || x > 4932)
LowerBound = -4950.0f; LowerBound = -4950.0f;
UpperBound = 4932.0f; UpperBound = 4932.0f;
break; break;
case LibFunc::exp2: // RangeError: (x < -1074 || x > 1023) case LibFunc_exp2: // RangeError: (x < -1074 || x > 1023)
LowerBound = -1074.0f; LowerBound = -1074.0f;
UpperBound = 1023.0f; UpperBound = 1023.0f;
break; break;
case LibFunc::exp2f: // RangeError: (x < -149 || x > 127) case LibFunc_exp2f: // RangeError: (x < -149 || x > 127)
LowerBound = -149.0f; LowerBound = -149.0f;
UpperBound = 127.0f; UpperBound = 127.0f;
break; break;
case LibFunc::exp2l: // RangeError: (x < -16445 || x > 11383) case LibFunc_exp2l: // RangeError: (x < -16445 || x > 11383)
LowerBound = -16445.0f; LowerBound = -16445.0f;
UpperBound = 11383.0f; UpperBound = 11383.0f;
break; break;
default: default:
llvm_unreachable("Should be reach here"); llvm_unreachable("Should be reach here");
} }
++NumWrappedTwoCond; ++NumWrappedTwoCond;
Show All 12 Lines
// (2.3) if x's bit_size is 32 // (2.3) if x's bit_size is 32
// Cond: (x <= 0 || y > 32) // Cond: (x <= 0 || y > 32)
// Support for powl(x,y) and powf(x,y) are TBD. // Support for powl(x,y) and powf(x,y) are TBD.
// //
// Note that condition can be more conservative than the actual condition // Note that condition can be more conservative than the actual condition
// (i.e. we might invoke the calls that will not set the errno.). // (i.e. we might invoke the calls that will not set the errno.).
// //
Value *LibCallsShrinkWrap::generateCondForPow(CallInst *CI, Value *LibCallsShrinkWrap::generateCondForPow(CallInst *CI,
const LibFunc::Func &Func) { const LibFunc &Func) {
// FIXME: LibFunc::powf and powl TBD. // FIXME: LibFunc_powf and powl TBD.
if (Func != LibFunc::pow) { if (Func != LibFunc_pow) {
DEBUG(dbgs() << "Not handled powf() and powl()\n"); DEBUG(dbgs() << "Not handled powf() and powl()\n");
return nullptr; return nullptr;
} }
Value *Base = CI->getArgOperand(0); Value *Base = CI->getArgOperand(0);
Value *Exp = CI->getArgOperand(1); Value *Exp = CI->getArgOperand(1);
IRBuilder<> BBBuilder(CI); IRBuilder<> BBBuilder(CI);
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Linesvoid LibCallsShrinkWrap::shrinkWrapCI(CallInst *CI, Value *Cond) {
CallBB->getInstList().insert(CallBB->getFirstInsertionPt(), CI); CallBB->getInstList().insert(CallBB->getFirstInsertionPt(), CI);
DEBUG(dbgs() << "== Basic Block After =="); DEBUG(dbgs() << "== Basic Block After ==");
DEBUG(dbgs() << *CallBB->getSinglePredecessor() << *CallBB DEBUG(dbgs() << *CallBB->getSinglePredecessor() << *CallBB
<< *CallBB->getSingleSuccessor() << "\n"); << *CallBB->getSingleSuccessor() << "\n");
} }
// Perform the transformation to a single candidate. // Perform the transformation to a single candidate.
bool LibCallsShrinkWrap::perform(CallInst *CI) { bool LibCallsShrinkWrap::perform(CallInst *CI) {
LibFunc::Func Func; LibFunc Func;
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
assert(Callee && "perform() should apply to a non-empty callee"); assert(Callee && "perform() should apply to a non-empty callee");
TLI.getLibFunc(*Callee, Func); TLI.getLibFunc(*Callee, Func);
assert(Func && "perform() is not expecting an empty function"); assert(Func && "perform() is not expecting an empty function");
if (LibCallsShrinkWrapDoDomainError && performCallDomainErrorOnly(CI, Func)) if (LibCallsShrinkWrapDoDomainError && performCallDomainErrorOnly(CI, Func))
return true; return true;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lib/Transforms/Utils/Local.cpp

Show First 20 Lines • Show All 2,062 Lines • ▼ Show 20 Lines
// CodeGen has special handling for some string functions that may replace // CodeGen has special handling for some string functions that may replace
// them with target-specific intrinsics. Since that'd skip our interceptors // them with target-specific intrinsics. Since that'd skip our interceptors
// in ASan/MSan/TSan/DFSan, and thus make us miss some memory accesses, // in ASan/MSan/TSan/DFSan, and thus make us miss some memory accesses,
// we mark affected calls as NoBuiltin, which will disable optimization // we mark affected calls as NoBuiltin, which will disable optimization
// in CodeGen. // in CodeGen.
void llvm::maybeMarkSanitizerLibraryCallNoBuiltin( void llvm::maybeMarkSanitizerLibraryCallNoBuiltin(
CallInst *CI, const TargetLibraryInfo *TLI) { CallInst *CI, const TargetLibraryInfo *TLI) {
Function *F = CI->getCalledFunction(); Function *F = CI->getCalledFunction();
LibFunc::Func Func; LibFunc Func;
if (F && !F->hasLocalLinkage() && F->hasName() && if (F && !F->hasLocalLinkage() && F->hasName() &&
TLI->getLibFunc(F->getName(), Func) && TLI->hasOptimizedCodeGen(Func) && TLI->getLibFunc(F->getName(), Func) && TLI->hasOptimizedCodeGen(Func) &&
!F->doesNotAccessMemory()) !F->doesNotAccessMemory())
CI->addAttribute(AttributeSet::FunctionIndex, Attribute::NoBuiltin); CI->addAttribute(AttributeSet::FunctionIndex, Attribute::NoBuiltin);
} }

lib/Transforms/Utils/SimplifyLibCalls.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines EnableUnsafeFPShrink("enable-double-float-shrink", cl::Hidden,
cl::desc("Enable unsafe double to float " cl::desc("Enable unsafe double to float "
"shrinking for math lib calls")); "shrinking for math lib calls"));
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Helper Functions // Helper Functions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static bool ignoreCallingConv(LibFunc::Func Func) { static bool ignoreCallingConv(LibFunc Func) {
return Func == LibFunc::abs || Func == LibFunc::labs || return Func == LibFunc_abs || Func == LibFunc_labs ||
Func == LibFunc::llabs || Func == LibFunc::strlen; Func == LibFunc_llabs || Func == LibFunc_strlen;
} }
static bool isCallingConvCCompatible(CallInst *CI) { static bool isCallingConvCCompatible(CallInst *CI) {
switch(CI->getCallingConv()) { switch(CI->getCallingConv()) {
default: default:
return false; return false;
case llvm::CallingConv::C: case llvm::CallingConv::C:
return true; return true;
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesstatic bool callHasFloatingPointArgument(const CallInst *CI) {
return any_of(CI->operands(), [](const Use &OI) { return any_of(CI->operands(), [](const Use &OI) {
return OI->getType()->isFloatingPointTy(); return OI->getType()->isFloatingPointTy();
}); });
} }
/// \brief Check whether the overloaded unary floating point function /// \brief Check whether the overloaded unary floating point function
/// corresponding to \a Ty is available. /// corresponding to \a Ty is available.
static bool hasUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty, static bool hasUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
LibFunc::Func DoubleFn, LibFunc::Func FloatFn, LibFunc DoubleFn, LibFunc FloatFn,
LibFunc::Func LongDoubleFn) { LibFunc LongDoubleFn) {
switch (Ty->getTypeID()) { switch (Ty->getTypeID()) {
case Type::FloatTyID: case Type::FloatTyID:
return TLI->has(FloatFn); return TLI->has(FloatFn);
case Type::DoubleTyID: case Type::DoubleTyID:
return TLI->has(DoubleFn); return TLI->has(DoubleFn);
default: default:
return TLI->has(LongDoubleFn); return TLI->has(LongDoubleFn);
} }
▲ Show 20 Lines • Show All 670 Lines • ▼ Show 20 Lines B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
CI->getArgOperand(2), 1); CI->getArgOperand(2), 1);
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
// TODO: Does this belong in BuildLibCalls or should all of those similar // TODO: Does this belong in BuildLibCalls or should all of those similar
// functions be moved here? // functions be moved here?
static Value *emitCalloc(Value *Num, Value *Size, const AttributeSet &Attrs, static Value *emitCalloc(Value *Num, Value *Size, const AttributeSet &Attrs,
IRBuilder<> &B, const TargetLibraryInfo &TLI) { IRBuilder<> &B, const TargetLibraryInfo &TLI) {
LibFunc::Func Func; LibFunc Func;
if (!TLI.getLibFunc("calloc", Func) || !TLI.has(Func)) if (!TLI.getLibFunc("calloc", Func) || !TLI.has(Func))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
const DataLayout &DL = M->getDataLayout(); const DataLayout &DL = M->getDataLayout();
IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext())); IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
Value *Calloc = M->getOrInsertFunction("calloc", Attrs, B.getInt8PtrTy(), Value *Calloc = M->getOrInsertFunction("calloc", Attrs, B.getInt8PtrTy(),
PtrType, PtrType, nullptr); PtrType, PtrType, nullptr);
Show All 18 Linesstatic Value *foldMallocMemset(CallInst *Memset, IRBuilder<> &B,
// the malloc is checked against null or when a memset intrinsic is used in // the malloc is checked against null or when a memset intrinsic is used in
// place of a memset library call. // place of a memset library call.
auto *Malloc = dyn_cast<CallInst>(Memset->getArgOperand(0)); auto *Malloc = dyn_cast<CallInst>(Memset->getArgOperand(0));
if (!Malloc || !Malloc->hasOneUse()) if (!Malloc || !Malloc->hasOneUse())
return nullptr; return nullptr;
// Is the inner call really malloc()? // Is the inner call really malloc()?
Function *InnerCallee = Malloc->getCalledFunction(); Function *InnerCallee = Malloc->getCalledFunction();
LibFunc::Func Func; LibFunc Func;
if (!TLI.getLibFunc(*InnerCallee, Func) || !TLI.has(Func) || if (!TLI.getLibFunc(*InnerCallee, Func) || !TLI.has(Func) ||
Func != LibFunc::malloc) Func != LibFunc_malloc)
return nullptr; return nullptr;
// The memset must cover the same number of bytes that are malloc'd. // The memset must cover the same number of bytes that are malloc'd.
if (Memset->getArgOperand(2) != Malloc->getArgOperand(0)) if (Memset->getArgOperand(2) != Malloc->getArgOperand(0))
return nullptr; return nullptr;
// Replace the malloc with a calloc. We need the data layout to know what the // Replace the malloc with a calloc. We need the data layout to know what the
// actual size of a 'size_t' parameter is. // actual size of a 'size_t' parameter is.
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Lines if (match(Op1, m_SpecificFP(2.0))) {
return B.CreateCall(Exp2, Op2, "exp2"); return B.CreateCall(Exp2, Op2, "exp2");
} }
// There's no llvm.exp10 intrinsic yet, but, maybe, some day there will // There's no llvm.exp10 intrinsic yet, but, maybe, some day there will
// be one. // be one.
if (ConstantFP *Op1C = dyn_cast<ConstantFP>(Op1)) { if (ConstantFP *Op1C = dyn_cast<ConstantFP>(Op1)) {
// pow(10.0, x) -> exp10(x) // pow(10.0, x) -> exp10(x)
if (Op1C->isExactlyValue(10.0) && if (Op1C->isExactlyValue(10.0) &&
hasUnaryFloatFn(TLI, Op1->getType(), LibFunc::exp10, LibFunc::exp10f, hasUnaryFloatFn(TLI, Op1->getType(), LibFunc_exp10, LibFunc_exp10f,
LibFunc::exp10l)) LibFunc_exp10l))
return emitUnaryFloatFnCall(Op2, TLI->getName(LibFunc::exp10), B, return emitUnaryFloatFnCall(Op2, TLI->getName(LibFunc_exp10), B,
Callee->getAttributes()); Callee->getAttributes());
} }
// pow(exp(x), y) -> exp(x * y) // pow(exp(x), y) -> exp(x * y)
// pow(exp2(x), y) -> exp2(x * y) // pow(exp2(x), y) -> exp2(x * y)
// We enable these only with fast-math. Besides rounding differences, the // We enable these only with fast-math. Besides rounding differences, the
// transformation changes overflow and underflow behavior quite dramatically. // transformation changes overflow and underflow behavior quite dramatically.
// Example: x = 1000, y = 0.001. // Example: x = 1000, y = 0.001.
// pow(exp(x), y) = pow(inf, 0.001) = inf, whereas exp(x*y) = exp(1). // pow(exp(x), y) = pow(inf, 0.001) = inf, whereas exp(x*y) = exp(1).
auto *OpC = dyn_cast<CallInst>(Op1); auto *OpC = dyn_cast<CallInst>(Op1);
if (OpC && OpC->hasUnsafeAlgebra() && CI->hasUnsafeAlgebra()) { if (OpC && OpC->hasUnsafeAlgebra() && CI->hasUnsafeAlgebra()) {
LibFunc::Func Func; LibFunc Func;
Function *OpCCallee = OpC->getCalledFunction(); Function *OpCCallee = OpC->getCalledFunction();
if (OpCCallee && TLI->getLibFunc(OpCCallee->getName(), Func) && if (OpCCallee && TLI->getLibFunc(OpCCallee->getName(), Func) &&
TLI->has(Func) && (Func == LibFunc::exp || Func == LibFunc::exp2)) { TLI->has(Func) && (Func == LibFunc_exp || Func == LibFunc_exp2)) {
IRBuilder<>::FastMathFlagGuard Guard(B); IRBuilder<>::FastMathFlagGuard Guard(B);
B.setFastMathFlags(CI->getFastMathFlags()); B.setFastMathFlags(CI->getFastMathFlags());
Value *FMul = B.CreateFMul(OpC->getArgOperand(0), Op2, "mul"); Value *FMul = B.CreateFMul(OpC->getArgOperand(0), Op2, "mul");
return emitUnaryFloatFnCall(FMul, OpCCallee->getName(), B, return emitUnaryFloatFnCall(FMul, OpCCallee->getName(), B,
OpCCallee->getAttributes()); OpCCallee->getAttributes());
} }
} }
ConstantFP *Op2C = dyn_cast<ConstantFP>(Op2); ConstantFP *Op2C = dyn_cast<ConstantFP>(Op2);
if (!Op2C) if (!Op2C)
return Ret; return Ret;
if (Op2C->getValueAPF().isZero()) // pow(x, 0.0) -> 1.0 if (Op2C->getValueAPF().isZero()) // pow(x, 0.0) -> 1.0
return ConstantFP::get(CI->getType(), 1.0); return ConstantFP::get(CI->getType(), 1.0);
if (Op2C->isExactlyValue(-0.5) && if (Op2C->isExactlyValue(-0.5) &&
hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::sqrt, LibFunc::sqrtf, hasUnaryFloatFn(TLI, Op2->getType(), LibFunc_sqrt, LibFunc_sqrtf,
LibFunc::sqrtl)) { LibFunc_sqrtl)) {
// If -ffast-math: // If -ffast-math:
// pow(x, -0.5) -> 1.0 / sqrt(x) // pow(x, -0.5) -> 1.0 / sqrt(x)
if (CI->hasUnsafeAlgebra()) { if (CI->hasUnsafeAlgebra()) {
IRBuilder<>::FastMathFlagGuard Guard(B); IRBuilder<>::FastMathFlagGuard Guard(B);
B.setFastMathFlags(CI->getFastMathFlags()); B.setFastMathFlags(CI->getFastMathFlags());
// Here we cannot lower to an intrinsic because C99 sqrt() and llvm.sqrt // Here we cannot lower to an intrinsic because C99 sqrt() and llvm.sqrt
// are not guaranteed to have the same semantics. // are not guaranteed to have the same semantics.
Value *Sqrt = emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc::sqrt), B, Value *Sqrt = emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc_sqrt), B,
Callee->getAttributes()); Callee->getAttributes());
return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), Sqrt, "sqrtrecip"); return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), Sqrt, "sqrtrecip");
} }
} }
if (Op2C->isExactlyValue(0.5) && if (Op2C->isExactlyValue(0.5) &&
hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::sqrt, LibFunc::sqrtf, hasUnaryFloatFn(TLI, Op2->getType(), LibFunc_sqrt, LibFunc_sqrtf,
LibFunc::sqrtl)) { LibFunc_sqrtl)) {
// In -ffast-math, pow(x, 0.5) -> sqrt(x). // In -ffast-math, pow(x, 0.5) -> sqrt(x).
if (CI->hasUnsafeAlgebra()) { if (CI->hasUnsafeAlgebra()) {
IRBuilder<>::FastMathFlagGuard Guard(B); IRBuilder<>::FastMathFlagGuard Guard(B);
B.setFastMathFlags(CI->getFastMathFlags()); B.setFastMathFlags(CI->getFastMathFlags());
// Unlike other math intrinsics, sqrt has differerent semantics // Unlike other math intrinsics, sqrt has differerent semantics
// from the libc function. See LangRef for details. // from the libc function. See LangRef for details.
return emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc::sqrt), B, return emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc_sqrt), B,
Callee->getAttributes()); Callee->getAttributes());
} }
// Expand pow(x, 0.5) to (x == -infinity ? +infinity : fabs(sqrt(x))). // Expand pow(x, 0.5) to (x == -infinity ? +infinity : fabs(sqrt(x))).
// This is faster than calling pow, and still handles negative zero // This is faster than calling pow, and still handles negative zero
// and negative infinity correctly. // and negative infinity correctly.
// TODO: In finite-only mode, this could be just fabs(sqrt(x)). // TODO: In finite-only mode, this could be just fabs(sqrt(x)).
Value *Inf = ConstantFP::getInfinity(CI->getType()); Value *Inf = ConstantFP::getInfinity(CI->getType());
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeExp2(CallInst *CI, IRBuilder<> &B) {
Value *Ret = nullptr; Value *Ret = nullptr;
StringRef Name = Callee->getName(); StringRef Name = Callee->getName();
if (UnsafeFPShrink && Name == "exp2" && hasFloatVersion(Name)) if (UnsafeFPShrink && Name == "exp2" && hasFloatVersion(Name))
Ret = optimizeUnaryDoubleFP(CI, B, true); Ret = optimizeUnaryDoubleFP(CI, B, true);
Value *Op = CI->getArgOperand(0); Value *Op = CI->getArgOperand(0);
// Turn exp2(sitofp(x)) -> ldexp(1.0, sext(x)) if sizeof(x) <= 32 // Turn exp2(sitofp(x)) -> ldexp(1.0, sext(x)) if sizeof(x) <= 32
// Turn exp2(uitofp(x)) -> ldexp(1.0, zext(x)) if sizeof(x) < 32 // Turn exp2(uitofp(x)) -> ldexp(1.0, zext(x)) if sizeof(x) < 32
LibFunc::Func LdExp = LibFunc::ldexpl; LibFunc LdExp = LibFunc_ldexpl;
if (Op->getType()->isFloatTy()) if (Op->getType()->isFloatTy())
LdExp = LibFunc::ldexpf; LdExp = LibFunc_ldexpf;
else if (Op->getType()->isDoubleTy()) else if (Op->getType()->isDoubleTy())
LdExp = LibFunc::ldexp; LdExp = LibFunc_ldexp;
if (TLI->has(LdExp)) { if (TLI->has(LdExp)) {
Value *LdExpArg = nullptr; Value *LdExpArg = nullptr;
if (SIToFPInst *OpC = dyn_cast<SIToFPInst>(Op)) { if (SIToFPInst *OpC = dyn_cast<SIToFPInst>(Op)) {
if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() <= 32) if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() <= 32)
LdExpArg = B.CreateSExt(OpC->getOperand(0), B.getInt32Ty()); LdExpArg = B.CreateSExt(OpC->getOperand(0), B.getInt32Ty());
} else if (UIToFPInst *OpC = dyn_cast<UIToFPInst>(Op)) { } else if (UIToFPInst *OpC = dyn_cast<UIToFPInst>(Op)) {
if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() < 32) if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() < 32)
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeLog(CallInst *CI, IRBuilder<> &B) {
if (Name != "log" && Name != "log2" && Name != "log10") if (Name != "log" && Name != "log2" && Name != "log10")
return Ret; return Ret;
IRBuilder<>::FastMathFlagGuard Guard(B); IRBuilder<>::FastMathFlagGuard Guard(B);
FastMathFlags FMF; FastMathFlags FMF;
FMF.setUnsafeAlgebra(); FMF.setUnsafeAlgebra();
B.setFastMathFlags(FMF); B.setFastMathFlags(FMF);
LibFunc::Func Func; LibFunc Func;
Function *F = OpC->getCalledFunction(); Function *F = OpC->getCalledFunction();
if (F && ((TLI->getLibFunc(F->getName(), Func) && TLI->has(Func) && if (F && ((TLI->getLibFunc(F->getName(), Func) && TLI->has(Func) &&
Func == LibFunc::pow) || F->getIntrinsicID() == Intrinsic::pow)) Func == LibFunc_pow) || F->getIntrinsicID() == Intrinsic::pow))
return B.CreateFMul(OpC->getArgOperand(1), return B.CreateFMul(OpC->getArgOperand(1),
emitUnaryFloatFnCall(OpC->getOperand(0), Callee->getName(), B, emitUnaryFloatFnCall(OpC->getOperand(0), Callee->getName(), B,
Callee->getAttributes()), "mul"); Callee->getAttributes()), "mul");
// log(exp2(y)) -> y*log(2) // log(exp2(y)) -> y*log(2)
if (F && Name == "log" && TLI->getLibFunc(F->getName(), Func) && if (F && Name == "log" && TLI->getLibFunc(F->getName(), Func) &&
TLI->has(Func) && Func == LibFunc::exp2) TLI->has(Func) && Func == LibFunc_exp2)
return B.CreateFMul( return B.CreateFMul(
OpC->getArgOperand(0), OpC->getArgOperand(0),
emitUnaryFloatFnCall(ConstantFP::get(CI->getType(), 2.0), emitUnaryFloatFnCall(ConstantFP::get(CI->getType(), 2.0),
Callee->getName(), B, Callee->getAttributes()), Callee->getName(), B, Callee->getAttributes()),
"logmul"); "logmul");
return Ret; return Ret;
} }
Value *LibCallSimplifier::optimizeSqrt(CallInst *CI, IRBuilder<> &B) { Value *LibCallSimplifier::optimizeSqrt(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
Value *Ret = nullptr; Value *Ret = nullptr;
if (TLI->has(LibFunc::sqrtf) && (Callee->getName() == "sqrt" || if (TLI->has(LibFunc_sqrtf) && (Callee->getName() == "sqrt" ||
Callee->getIntrinsicID() == Intrinsic::sqrt)) Callee->getIntrinsicID() == Intrinsic::sqrt))
Ret = optimizeUnaryDoubleFP(CI, B, true); Ret = optimizeUnaryDoubleFP(CI, B, true);
if (!CI->hasUnsafeAlgebra()) if (!CI->hasUnsafeAlgebra())
return Ret; return Ret;
Instruction *I = dyn_cast<Instruction>(CI->getArgOperand(0)); Instruction *I = dyn_cast<Instruction>(CI->getArgOperand(0));
if (!I || I->getOpcode() != Instruction::FMul || !I->hasUnsafeAlgebra()) if (!I || I->getOpcode() != Instruction::FMul || !I->hasUnsafeAlgebra())
return Ret; return Ret;
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeTan(CallInst *CI, IRBuilder<> &B) {
// Both calls must allow unsafe optimizations in order to remove them. // Both calls must allow unsafe optimizations in order to remove them.
if (!CI->hasUnsafeAlgebra() || !OpC->hasUnsafeAlgebra()) if (!CI->hasUnsafeAlgebra() || !OpC->hasUnsafeAlgebra())
return Ret; return Ret;
// tan(atan(x)) -> x // tan(atan(x)) -> x
// tanf(atanf(x)) -> x // tanf(atanf(x)) -> x
// tanl(atanl(x)) -> x // tanl(atanl(x)) -> x
LibFunc::Func Func; LibFunc Func;
Function *F = OpC->getCalledFunction(); Function *F = OpC->getCalledFunction();
if (F && TLI->getLibFunc(F->getName(), Func) && TLI->has(Func) && if (F && TLI->getLibFunc(F->getName(), Func) && TLI->has(Func) &&
((Func == LibFunc::atan && Callee->getName() == "tan") || ((Func == LibFunc_atan && Callee->getName() == "tan") ||
(Func == LibFunc::atanf && Callee->getName() == "tanf") || (Func == LibFunc_atanf && Callee->getName() == "tanf") ||
(Func == LibFunc::atanl && Callee->getName() == "tanl"))) (Func == LibFunc_atanl && Callee->getName() == "tanl")))
Ret = OpC->getArgOperand(0); Ret = OpC->getArgOperand(0);
return Ret; return Ret;
} }
static bool isTrigLibCall(CallInst *CI) { static bool isTrigLibCall(CallInst *CI) {
// We can only hope to do anything useful if we can ignore things like errno // We can only hope to do anything useful if we can ignore things like errno
// and floating-point exceptions. // and floating-point exceptions.
// We already checked the prototype. // We already checked the prototype.
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Linesvoid LibCallSimplifier::classifyArgUse(
if (!CI) if (!CI)
return; return;
// Don't consider calls in other functions. // Don't consider calls in other functions.
if (CI->getFunction() != F) if (CI->getFunction() != F)
return; return;
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
LibFunc::Func Func; LibFunc Func;
if (!Callee || !TLI->getLibFunc(*Callee, Func) || !TLI->has(Func) || if (!Callee || !TLI->getLibFunc(*Callee, Func) || !TLI->has(Func) ||
!isTrigLibCall(CI)) !isTrigLibCall(CI))
return; return;
if (IsFloat) { if (IsFloat) {
if (Func == LibFunc::sinpif) if (Func == LibFunc_sinpif)
SinCalls.push_back(CI); SinCalls.push_back(CI);
else if (Func == LibFunc::cospif) else if (Func == LibFunc_cospif)
CosCalls.push_back(CI); CosCalls.push_back(CI);
else if (Func == LibFunc::sincospif_stret) else if (Func == LibFunc_sincospif_stret)
SinCosCalls.push_back(CI); SinCosCalls.push_back(CI);
} else { } else {
if (Func == LibFunc::sinpi) if (Func == LibFunc_sinpi)
SinCalls.push_back(CI); SinCalls.push_back(CI);
else if (Func == LibFunc::cospi) else if (Func == LibFunc_cospi)
CosCalls.push_back(CI); CosCalls.push_back(CI);
else if (Func == LibFunc::sincospi_stret) else if (Func == LibFunc_sincospi_stret)
SinCosCalls.push_back(CI); SinCosCalls.push_back(CI);
} }
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Integer Library Call Optimizations // Integer Library Call Optimizations
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizePrintF(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
FunctionType *FT = Callee->getFunctionType(); FunctionType *FT = Callee->getFunctionType();
if (Value *V = optimizePrintFString(CI, B)) { if (Value *V = optimizePrintFString(CI, B)) {
return V; return V;
} }
// printf(format, ...) -> iprintf(format, ...) if no floating point // printf(format, ...) -> iprintf(format, ...) if no floating point
// arguments. // arguments.
if (TLI->has(LibFunc::iprintf) && !callHasFloatingPointArgument(CI)) { if (TLI->has(LibFunc_iprintf) && !callHasFloatingPointArgument(CI)) {
Module *M = B.GetInsertBlock()->getParent()->getParent(); Module *M = B.GetInsertBlock()->getParent()->getParent();
Constant *IPrintFFn = Constant *IPrintFFn =
M->getOrInsertFunction("iprintf", FT, Callee->getAttributes()); M->getOrInsertFunction("iprintf", FT, Callee->getAttributes());
CallInst *New = cast<CallInst>(CI->clone()); CallInst *New = cast<CallInst>(CI->clone());
New->setCalledFunction(IPrintFFn); New->setCalledFunction(IPrintFFn);
B.Insert(New); B.Insert(New);
return New; return New;
} }
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeSPrintF(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
FunctionType *FT = Callee->getFunctionType(); FunctionType *FT = Callee->getFunctionType();
if (Value *V = optimizeSPrintFString(CI, B)) { if (Value *V = optimizeSPrintFString(CI, B)) {
return V; return V;
} }
// sprintf(str, format, ...) -> siprintf(str, format, ...) if no floating // sprintf(str, format, ...) -> siprintf(str, format, ...) if no floating
// point arguments. // point arguments.
if (TLI->has(LibFunc::siprintf) && !callHasFloatingPointArgument(CI)) { if (TLI->has(LibFunc_siprintf) && !callHasFloatingPointArgument(CI)) {
Module *M = B.GetInsertBlock()->getParent()->getParent(); Module *M = B.GetInsertBlock()->getParent()->getParent();
Constant *SIPrintFFn = Constant *SIPrintFFn =
M->getOrInsertFunction("siprintf", FT, Callee->getAttributes()); M->getOrInsertFunction("siprintf", FT, Callee->getAttributes());
CallInst *New = cast<CallInst>(CI->clone()); CallInst *New = cast<CallInst>(CI->clone());
New->setCalledFunction(SIPrintFFn); New->setCalledFunction(SIPrintFFn);
B.Insert(New); B.Insert(New);
return New; return New;
} }
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeFPrintF(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
FunctionType *FT = Callee->getFunctionType(); FunctionType *FT = Callee->getFunctionType();
if (Value *V = optimizeFPrintFString(CI, B)) { if (Value *V = optimizeFPrintFString(CI, B)) {
return V; return V;
} }
// fprintf(stream, format, ...) -> fiprintf(stream, format, ...) if no // fprintf(stream, format, ...) -> fiprintf(stream, format, ...) if no
// floating point arguments. // floating point arguments.
if (TLI->has(LibFunc::fiprintf) && !callHasFloatingPointArgument(CI)) { if (TLI->has(LibFunc_fiprintf) && !callHasFloatingPointArgument(CI)) {
Module *M = B.GetInsertBlock()->getParent()->getParent(); Module *M = B.GetInsertBlock()->getParent()->getParent();
Constant *FIPrintFFn = Constant *FIPrintFFn =
M->getOrInsertFunction("fiprintf", FT, Callee->getAttributes()); M->getOrInsertFunction("fiprintf", FT, Callee->getAttributes());
CallInst *New = cast<CallInst>(CI->clone()); CallInst *New = cast<CallInst>(CI->clone());
New->setCalledFunction(FIPrintFFn); New->setCalledFunction(FIPrintFFn);
B.Insert(New); B.Insert(New);
return New; return New;
} }
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines if (CI->use_empty() || !Res)
return Res; return Res;
return B.CreateIntCast(Res, CI->getType(), true); return B.CreateIntCast(Res, CI->getType(), true);
} }
return nullptr; return nullptr;
} }
bool LibCallSimplifier::hasFloatVersion(StringRef FuncName) { bool LibCallSimplifier::hasFloatVersion(StringRef FuncName) {
LibFunc::Func Func; LibFunc Func;
SmallString<20> FloatFuncName = FuncName; SmallString<20> FloatFuncName = FuncName;
FloatFuncName += 'f'; FloatFuncName += 'f';
if (TLI->getLibFunc(FloatFuncName, Func)) if (TLI->getLibFunc(FloatFuncName, Func))
return TLI->has(Func); return TLI->has(Func);
return false; return false;
} }
Value *LibCallSimplifier::optimizeStringMemoryLibCall(CallInst *CI, Value *LibCallSimplifier::optimizeStringMemoryLibCall(CallInst *CI,
IRBuilder<> &Builder) { IRBuilder<> &Builder) {
LibFunc::Func Func; LibFunc Func;
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
// Check for string/memory library functions. // Check for string/memory library functions.
if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) { if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
// Make sure we never change the calling convention. // Make sure we never change the calling convention.
assert((ignoreCallingConv(Func) || assert((ignoreCallingConv(Func) ||
isCallingConvCCompatible(CI)) && isCallingConvCCompatible(CI)) &&
"Optimizing string/memory libcall would change the calling convention"); "Optimizing string/memory libcall would change the calling convention");
switch (Func) { switch (Func) {
case LibFunc::strcat: case LibFunc_strcat:
return optimizeStrCat(CI, Builder); return optimizeStrCat(CI, Builder);
case LibFunc::strncat: case LibFunc_strncat:
return optimizeStrNCat(CI, Builder); return optimizeStrNCat(CI, Builder);
case LibFunc::strchr: case LibFunc_strchr:
return optimizeStrChr(CI, Builder); return optimizeStrChr(CI, Builder);
case LibFunc::strrchr: case LibFunc_strrchr:
return optimizeStrRChr(CI, Builder); return optimizeStrRChr(CI, Builder);
case LibFunc::strcmp: case LibFunc_strcmp:
return optimizeStrCmp(CI, Builder); return optimizeStrCmp(CI, Builder);
case LibFunc::strncmp: case LibFunc_strncmp:
return optimizeStrNCmp(CI, Builder); return optimizeStrNCmp(CI, Builder);
case LibFunc::strcpy: case LibFunc_strcpy:
return optimizeStrCpy(CI, Builder); return optimizeStrCpy(CI, Builder);
case LibFunc::stpcpy: case LibFunc_stpcpy:
return optimizeStpCpy(CI, Builder); return optimizeStpCpy(CI, Builder);
case LibFunc::strncpy: case LibFunc_strncpy:
return optimizeStrNCpy(CI, Builder); return optimizeStrNCpy(CI, Builder);
case LibFunc::strlen: case LibFunc_strlen:
return optimizeStrLen(CI, Builder); return optimizeStrLen(CI, Builder);
case LibFunc::strpbrk: case LibFunc_strpbrk:
return optimizeStrPBrk(CI, Builder); return optimizeStrPBrk(CI, Builder);
case LibFunc::strtol: case LibFunc_strtol:
case LibFunc::strtod: case LibFunc_strtod:
case LibFunc::strtof: case LibFunc_strtof:
case LibFunc::strtoul: case LibFunc_strtoul:
case LibFunc::strtoll: case LibFunc_strtoll:
case LibFunc::strtold: case LibFunc_strtold:
case LibFunc::strtoull: case LibFunc_strtoull:
return optimizeStrTo(CI, Builder); return optimizeStrTo(CI, Builder);
case LibFunc::strspn: case LibFunc_strspn:
return optimizeStrSpn(CI, Builder); return optimizeStrSpn(CI, Builder);
case LibFunc::strcspn: case LibFunc_strcspn:
return optimizeStrCSpn(CI, Builder); return optimizeStrCSpn(CI, Builder);
case LibFunc::strstr: case LibFunc_strstr:
return optimizeStrStr(CI, Builder); return optimizeStrStr(CI, Builder);
case LibFunc::memchr: case LibFunc_memchr:
return optimizeMemChr(CI, Builder); return optimizeMemChr(CI, Builder);
case LibFunc::memcmp: case LibFunc_memcmp:
return optimizeMemCmp(CI, Builder); return optimizeMemCmp(CI, Builder);
case LibFunc::memcpy: case LibFunc_memcpy:
return optimizeMemCpy(CI, Builder); return optimizeMemCpy(CI, Builder);
case LibFunc::memmove: case LibFunc_memmove:
return optimizeMemMove(CI, Builder); return optimizeMemMove(CI, Builder);
case LibFunc::memset: case LibFunc_memset:
return optimizeMemSet(CI, Builder); return optimizeMemSet(CI, Builder);
default: default:
break; break;
} }
} }
return nullptr; return nullptr;
} }
Value *LibCallSimplifier::optimizeCall(CallInst *CI) { Value *LibCallSimplifier::optimizeCall(CallInst *CI) {
if (CI->isNoBuiltin()) if (CI->isNoBuiltin())
return nullptr; return nullptr;
LibFunc::Func Func; LibFunc Func;
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
StringRef FuncName = Callee->getName(); StringRef FuncName = Callee->getName();
SmallVector<OperandBundleDef, 2> OpBundles; SmallVector<OperandBundleDef, 2> OpBundles;
CI->getOperandBundlesAsDefs(OpBundles); CI->getOperandBundlesAsDefs(OpBundles);
IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles); IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles);
bool isCallingConvC = isCallingConvCCompatible(CI); bool isCallingConvC = isCallingConvCCompatible(CI);
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeCall(CallInst *CI) {
// Then check for known library functions. // Then check for known library functions.
if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) { if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
// We never change the calling convention. // We never change the calling convention.
if (!ignoreCallingConv(Func) && !isCallingConvC) if (!ignoreCallingConv(Func) && !isCallingConvC)
return nullptr; return nullptr;
if (Value *V = optimizeStringMemoryLibCall(CI, Builder)) if (Value *V = optimizeStringMemoryLibCall(CI, Builder))
return V; return V;
switch (Func) { switch (Func) {
case LibFunc::cosf: case LibFunc_cosf:
case LibFunc::cos: case LibFunc_cos:
case LibFunc::cosl: case LibFunc_cosl:
return optimizeCos(CI, Builder); return optimizeCos(CI, Builder);
case LibFunc::sinpif: case LibFunc_sinpif:
case LibFunc::sinpi: case LibFunc_sinpi:
case LibFunc::cospif: case LibFunc_cospif:
case LibFunc::cospi: case LibFunc_cospi:
return optimizeSinCosPi(CI, Builder); return optimizeSinCosPi(CI, Builder);
case LibFunc::powf: case LibFunc_powf:
case LibFunc::pow: case LibFunc_pow:
case LibFunc::powl: case LibFunc_powl:
return optimizePow(CI, Builder); return optimizePow(CI, Builder);
case LibFunc::exp2l: case LibFunc_exp2l:
case LibFunc::exp2: case LibFunc_exp2:
case LibFunc::exp2f: case LibFunc_exp2f:
return optimizeExp2(CI, Builder); return optimizeExp2(CI, Builder);
case LibFunc::fabsf: case LibFunc_fabsf:
case LibFunc::fabs: case LibFunc_fabs:
case LibFunc::fabsl: case LibFunc_fabsl:
return optimizeFabs(CI, Builder); return optimizeFabs(CI, Builder);
case LibFunc::sqrtf: case LibFunc_sqrtf:
case LibFunc::sqrt: case LibFunc_sqrt:
case LibFunc::sqrtl: case LibFunc_sqrtl:
return optimizeSqrt(CI, Builder); return optimizeSqrt(CI, Builder);
case LibFunc::ffs: case LibFunc_ffs:
case LibFunc::ffsl: case LibFunc_ffsl:
case LibFunc::ffsll: case LibFunc_ffsll:
return optimizeFFS(CI, Builder); return optimizeFFS(CI, Builder);
case LibFunc::fls: case LibFunc_fls:
case LibFunc::flsl: case LibFunc_flsl:
case LibFunc::flsll: case LibFunc_flsll:
return optimizeFls(CI, Builder); return optimizeFls(CI, Builder);
case LibFunc::abs: case LibFunc_abs:
case LibFunc::labs: case LibFunc_labs:
case LibFunc::llabs: case LibFunc_llabs:
return optimizeAbs(CI, Builder); return optimizeAbs(CI, Builder);
case LibFunc::isdigit: case LibFunc_isdigit:
return optimizeIsDigit(CI, Builder); return optimizeIsDigit(CI, Builder);
case LibFunc::isascii: case LibFunc_isascii:
return optimizeIsAscii(CI, Builder); return optimizeIsAscii(CI, Builder);
case LibFunc::toascii: case LibFunc_toascii:
return optimizeToAscii(CI, Builder); return optimizeToAscii(CI, Builder);
case LibFunc::printf: case LibFunc_printf:
return optimizePrintF(CI, Builder); return optimizePrintF(CI, Builder);
case LibFunc::sprintf: case LibFunc_sprintf:
return optimizeSPrintF(CI, Builder); return optimizeSPrintF(CI, Builder);
case LibFunc::fprintf: case LibFunc_fprintf:
return optimizeFPrintF(CI, Builder); return optimizeFPrintF(CI, Builder);
case LibFunc::fwrite: case LibFunc_fwrite:
return optimizeFWrite(CI, Builder); return optimizeFWrite(CI, Builder);
case LibFunc::fputs: case LibFunc_fputs:
return optimizeFPuts(CI, Builder); return optimizeFPuts(CI, Builder);
case LibFunc::log: case LibFunc_log:
case LibFunc::log10: case LibFunc_log10:
case LibFunc::log1p: case LibFunc_log1p:
case LibFunc::log2: case LibFunc_log2:
case LibFunc::logb: case LibFunc_logb:
return optimizeLog(CI, Builder); return optimizeLog(CI, Builder);
case LibFunc::puts: case LibFunc_puts:
return optimizePuts(CI, Builder); return optimizePuts(CI, Builder);
case LibFunc::tan: case LibFunc_tan:
case LibFunc::tanf: case LibFunc_tanf:
case LibFunc::tanl: case LibFunc_tanl:
return optimizeTan(CI, Builder); return optimizeTan(CI, Builder);
case LibFunc::perror: case LibFunc_perror:
return optimizeErrorReporting(CI, Builder); return optimizeErrorReporting(CI, Builder);
case LibFunc::vfprintf: case LibFunc_vfprintf:
case LibFunc::fiprintf: case LibFunc_fiprintf:
return optimizeErrorReporting(CI, Builder, 0); return optimizeErrorReporting(CI, Builder, 0);
case LibFunc::fputc: case LibFunc_fputc:
return optimizeErrorReporting(CI, Builder, 1); return optimizeErrorReporting(CI, Builder, 1);
case LibFunc::ceil: case LibFunc_ceil:
case LibFunc::floor: case LibFunc_floor:
case LibFunc::rint: case LibFunc_rint:
case LibFunc::round: case LibFunc_round:
case LibFunc::nearbyint: case LibFunc_nearbyint:
case LibFunc::trunc: case LibFunc_trunc:
if (hasFloatVersion(FuncName)) if (hasFloatVersion(FuncName))
return optimizeUnaryDoubleFP(CI, Builder, false); return optimizeUnaryDoubleFP(CI, Builder, false);
return nullptr; return nullptr;
case LibFunc::acos: case LibFunc_acos:
case LibFunc::acosh: case LibFunc_acosh:
case LibFunc::asin: case LibFunc_asin:
case LibFunc::asinh: case LibFunc_asinh:
case LibFunc::atan: case LibFunc_atan:
case LibFunc::atanh: case LibFunc_atanh:
case LibFunc::cbrt: case LibFunc_cbrt:
case LibFunc::cosh: case LibFunc_cosh:
case LibFunc::exp: case LibFunc_exp:
case LibFunc::exp10: case LibFunc_exp10:
case LibFunc::expm1: case LibFunc_expm1:
case LibFunc::sin: case LibFunc_sin:
case LibFunc::sinh: case LibFunc_sinh:
case LibFunc::tanh: case LibFunc_tanh:
if (UnsafeFPShrink && hasFloatVersion(FuncName)) if (UnsafeFPShrink && hasFloatVersion(FuncName))
return optimizeUnaryDoubleFP(CI, Builder, true); return optimizeUnaryDoubleFP(CI, Builder, true);
return nullptr; return nullptr;
case LibFunc::copysign: case LibFunc_copysign:
if (hasFloatVersion(FuncName)) if (hasFloatVersion(FuncName))
return optimizeBinaryDoubleFP(CI, Builder); return optimizeBinaryDoubleFP(CI, Builder);
return nullptr; return nullptr;
case LibFunc::fminf: case LibFunc_fminf:
case LibFunc::fmin: case LibFunc_fmin:
case LibFunc::fminl: case LibFunc_fminl:
case LibFunc::fmaxf: case LibFunc_fmaxf:
case LibFunc::fmax: case LibFunc_fmax:
case LibFunc::fmaxl: case LibFunc_fmaxl:
return optimizeFMinFMax(CI, Builder); return optimizeFMinFMax(CI, Builder);
default: default:
return nullptr; return nullptr;
} }
} }
return nullptr; return nullptr;
} }
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines if (isFortifiedCallFoldable(CI, 3, 2, false)) {
B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1); B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
return nullptr; return nullptr;
} }
Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI, Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI,
IRBuilder<> &B, IRBuilder<> &B,
LibFunc::Func Func) { LibFunc Func) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
StringRef Name = Callee->getName(); StringRef Name = Callee->getName();
const DataLayout &DL = CI->getModule()->getDataLayout(); const DataLayout &DL = CI->getModule()->getDataLayout();
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1), Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1),
*ObjSize = CI->getArgOperand(2); *ObjSize = CI->getArgOperand(2);
// __stpcpy_chk(x,x,...) -> x+strlen(x) // __stpcpy_chk(x,x,...) -> x+strlen(x)
if (Func == LibFunc::stpcpy_chk && !OnlyLowerUnknownSize && Dst == Src) { if (Func == LibFunc_stpcpy_chk && !OnlyLowerUnknownSize && Dst == Src) {
Value *StrLen = emitStrLen(Src, B, DL, TLI); Value *StrLen = emitStrLen(Src, B, DL, TLI);
return StrLen ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, StrLen) : nullptr; return StrLen ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, StrLen) : nullptr;
} }
// If a) we don't have any length information, or b) we know this will // If a) we don't have any length information, or b) we know this will
// fit then just lower to a plain st[rp]cpy. Otherwise we'll keep our // fit then just lower to a plain st[rp]cpy. Otherwise we'll keep our
// st[rp]cpy_chk call which may fail at runtime if the size is too long. // st[rp]cpy_chk call which may fail at runtime if the size is too long.
// TODO: It might be nice to get a maximum length out of the possible // TODO: It might be nice to get a maximum length out of the possible
Show All 9 LinesValue *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI,
if (Len == 0) if (Len == 0)
return nullptr; return nullptr;
Type *SizeTTy = DL.getIntPtrType(CI->getContext()); Type *SizeTTy = DL.getIntPtrType(CI->getContext());
Value *LenV = ConstantInt::get(SizeTTy, Len); Value *LenV = ConstantInt::get(SizeTTy, Len);
Value *Ret = emitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI); Value *Ret = emitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI);
// If the function was an __stpcpy_chk, and we were able to fold it into // If the function was an __stpcpy_chk, and we were able to fold it into
// a __memcpy_chk, we still need to return the correct end pointer. // a __memcpy_chk, we still need to return the correct end pointer.
if (Ret && Func == LibFunc::stpcpy_chk) if (Ret && Func == LibFunc_stpcpy_chk)
return B.CreateGEP(B.getInt8Ty(), Dst, ConstantInt::get(SizeTTy, Len - 1)); return B.CreateGEP(B.getInt8Ty(), Dst, ConstantInt::get(SizeTTy, Len - 1));
return Ret; return Ret;
} }
Value *FortifiedLibCallSimplifier::optimizeStrpNCpyChk(CallInst *CI, Value *FortifiedLibCallSimplifier::optimizeStrpNCpyChk(CallInst *CI,
IRBuilder<> &B, IRBuilder<> &B,
LibFunc::Func Func) { LibFunc Func) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
StringRef Name = Callee->getName(); StringRef Name = Callee->getName();
if (isFortifiedCallFoldable(CI, 3, 2, false)) { if (isFortifiedCallFoldable(CI, 3, 2, false)) {
Value *Ret = emitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1), Value *Ret = emitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
CI->getArgOperand(2), B, TLI, Name.substr(2, 7)); CI->getArgOperand(2), B, TLI, Name.substr(2, 7));
return Ret; return Ret;
} }
return nullptr; return nullptr;
} }
Value *FortifiedLibCallSimplifier::optimizeCall(CallInst *CI) { Value *FortifiedLibCallSimplifier::optimizeCall(CallInst *CI) {
// FIXME: We shouldn't be changing "nobuiltin" or TLI unavailable calls here. // FIXME: We shouldn't be changing "nobuiltin" or TLI unavailable calls here.
// Some clang users checked for _chk libcall availability using: // Some clang users checked for _chk libcall availability using:
// __has_builtin(__builtin___memcpy_chk) // __has_builtin(__builtin___memcpy_chk)
// When compiling with -fno-builtin, this is always true. // When compiling with -fno-builtin, this is always true.
// When passing -ffreestanding/-mkernel, which both imply -fno-builtin, we // When passing -ffreestanding/-mkernel, which both imply -fno-builtin, we
// end up with fortified libcalls, which isn't acceptable in a freestanding // end up with fortified libcalls, which isn't acceptable in a freestanding
// environment which only provides their non-fortified counterparts. // environment which only provides their non-fortified counterparts.
// //
// Until we change clang and/or teach external users to check for availability // Until we change clang and/or teach external users to check for availability
// differently, disregard the "nobuiltin" attribute and TLI::has. // differently, disregard the "nobuiltin" attribute and TLI::has.
// //
// PR23093. // PR23093.
LibFunc::Func Func; LibFunc Func;
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
SmallVector<OperandBundleDef, 2> OpBundles; SmallVector<OperandBundleDef, 2> OpBundles;
CI->getOperandBundlesAsDefs(OpBundles); CI->getOperandBundlesAsDefs(OpBundles);
IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles); IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles);
bool isCallingConvC = isCallingConvCCompatible(CI); bool isCallingConvC = isCallingConvCCompatible(CI);
// First, check that this is a known library functions and that the prototype // First, check that this is a known library functions and that the prototype
// is correct. // is correct.
if (!TLI->getLibFunc(*Callee, Func)) if (!TLI->getLibFunc(*Callee, Func))
return nullptr; return nullptr;
// We never change the calling convention. // We never change the calling convention.
if (!ignoreCallingConv(Func) && !isCallingConvC) if (!ignoreCallingConv(Func) && !isCallingConvC)
return nullptr; return nullptr;
switch (Func) { switch (Func) {
case LibFunc::memcpy_chk: case LibFunc_memcpy_chk:
return optimizeMemCpyChk(CI, Builder); return optimizeMemCpyChk(CI, Builder);
case LibFunc::memmove_chk: case LibFunc_memmove_chk:
return optimizeMemMoveChk(CI, Builder); return optimizeMemMoveChk(CI, Builder);
case LibFunc::memset_chk: case LibFunc_memset_chk:
return optimizeMemSetChk(CI, Builder); return optimizeMemSetChk(CI, Builder);
case LibFunc::stpcpy_chk: case LibFunc_stpcpy_chk:
case LibFunc::strcpy_chk: case LibFunc_strcpy_chk:
return optimizeStrpCpyChk(CI, Builder, Func); return optimizeStrpCpyChk(CI, Builder, Func);
case LibFunc::stpncpy_chk: case LibFunc_stpncpy_chk:
case LibFunc::strncpy_chk: case LibFunc_strncpy_chk:
return optimizeStrpNCpyChk(CI, Builder, Func); return optimizeStrpNCpyChk(CI, Builder, Func);
default: default:
break; break;
} }
return nullptr; return nullptr;
} }
FortifiedLibCallSimplifier::FortifiedLibCallSimplifier( FortifiedLibCallSimplifier::FortifiedLibCallSimplifier(
const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize) const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize)
: TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {} : TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {}

unittests/Analysis/TargetLibraryInfoTest.cpp

Show All 36 Lines void parseAssembly(const char *Assembly) {
raw_string_ostream os(errMsg); raw_string_ostream os(errMsg);
Error.print("", os); Error.print("", os);
if (!M) if (!M)
report_fatal_error(os.str()); report_fatal_error(os.str());
} }
::testing::AssertionResult isLibFunc(const Function *FDecl, ::testing::AssertionResult isLibFunc(const Function *FDecl,
LibFunc::Func ExpectedLF) { LibFunc ExpectedLF) {
StringRef ExpectedLFName = TLI.getName(ExpectedLF); StringRef ExpectedLFName = TLI.getName(ExpectedLF);
if (!FDecl) if (!FDecl)
return ::testing::AssertionFailure() << ExpectedLFName << " not found"; return ::testing::AssertionFailure() << ExpectedLFName << " not found";
LibFunc::Func F; LibFunc F;
if (!TLI.getLibFunc(*FDecl, F)) if (!TLI.getLibFunc(*FDecl, F))
return ::testing::AssertionFailure() << ExpectedLFName << " invalid"; return ::testing::AssertionFailure() << ExpectedLFName << " invalid";
return ::testing::AssertionSuccess() << ExpectedLFName << " is LibFunc"; return ::testing::AssertionSuccess() << ExpectedLFName << " is LibFunc";
} }
}; };
} // end anonymous namespace } // end anonymous namespace
// Check that we don't accept egregiously incorrect prototypes. // Check that we don't accept egregiously incorrect prototypes.
TEST_F(TargetLibraryInfoTest, InvalidProto) { TEST_F(TargetLibraryInfoTest, InvalidProto) {
parseAssembly("%foo = type { %foo }\n"); parseAssembly("%foo = type { %foo }\n");
auto *StructTy = M->getTypeByName("foo"); auto *StructTy = M->getTypeByName("foo");
auto *InvalidFTy = FunctionType::get(StructTy, /*isVarArg=*/false); auto *InvalidFTy = FunctionType::get(StructTy, /*isVarArg=*/false);
for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) { for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
LibFunc::Func LF = (LibFunc::Func)FI; LibFunc LF = (LibFunc)FI;
auto *F = cast<Function>( auto *F = cast<Function>(
M->getOrInsertFunction(TLI.getName(LF), InvalidFTy)); M->getOrInsertFunction(TLI.getName(LF), InvalidFTy));
EXPECT_FALSE(isLibFunc(F, LF)); EXPECT_FALSE(isLibFunc(F, LF));
} }
} }
// Check that we do accept know-correct prototypes. // Check that we do accept know-correct prototypes.
TEST_F(TargetLibraryInfoTest, ValidProto) { TEST_F(TargetLibraryInfoTest, ValidProto) {
▲ Show 20 Lines • Show All 389 Lines • ▼ Show 20 Lines parseAssembly(
"declare i16 @ntohs(i16)\n" "declare i16 @ntohs(i16)\n"
"declare i32 @isascii(i32)\n" "declare i32 @isascii(i32)\n"
"declare i32 @isdigit(i32)\n" "declare i32 @isdigit(i32)\n"
"declare i32 @toascii(i32)\n" "declare i32 @toascii(i32)\n"
); );
for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) { for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
LibFunc::Func LF = (LibFunc::Func)FI; LibFunc LF = (LibFunc)FI;
// Make sure everything is available; we're not testing target defaults. // Make sure everything is available; we're not testing target defaults.
TLII.setAvailable(LF); TLII.setAvailable(LF);
Function *F = M->getFunction(TLI.getName(LF)); Function *F = M->getFunction(TLI.getName(LF));
EXPECT_TRUE(isLibFunc(F, LF)); EXPECT_TRUE(isLibFunc(F, LF));
} }
} }