llvm-6502/include/llvm/Target/TargetLibraryInfo.h
Nick Lewycky 6a7df9aae6 Remove redundant getAnalysis<> calls in GlobalOpt. Add a few Itanium ABI calls
to TargetLibraryInfo and use one of them in GlobalOpt.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@150323 91177308-0d34-0410-b5e6-96231b3b80d8
2012-02-12 02:15:20 +00:00

288 lines
7.9 KiB
C++

//===-- llvm/Target/TargetLibraryInfo.h - Library information ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TARGET_TARGETLIBRARYINFO_H
#define LLVM_TARGET_TARGETLIBRARYINFO_H
#include "llvm/Pass.h"
#include "llvm/ADT/DenseMap.h"
namespace llvm {
class Triple;
namespace LibFunc {
enum Func {
/// double acos(double x);
acos,
/// long double acosl(long double x);
acosl,
/// float acosf(float x);
acosf,
/// double asin(double x);
asin,
/// long double asinl(long double x);
asinl,
/// float asinf(float x);
asinf,
/// double atan(double x);
atan,
/// long double atanl(long double x);
atanl,
/// float atanf(float x);
atanf,
/// double atan2(double y, double x);
atan2,
/// long double atan2l(long double y, long double x);
atan2l,
/// float atan2f(float y, float x);
atan2f,
/// double ceil(double x);
ceil,
/// long double ceill(long double x);
ceill,
/// float ceilf(float x);
ceilf,
/// double copysign(double x, double y);
copysign,
/// float copysignf(float x, float y);
copysignf,
/// long double copysignl(long double x, long double y);
copysignl,
/// double cos(double x);
cos,
/// long double cosl(long double x);
cosl,
/// float cosf(float x);
cosf,
/// double cosh(double x);
cosh,
/// long double coshl(long double x);
coshl,
/// float coshf(float x);
coshf,
/// double exp(double x);
exp,
/// long double expl(long double x);
expl,
/// float expf(float x);
expf,
/// double exp2(double x);
exp2,
/// long double exp2l(long double x);
exp2l,
/// float exp2f(float x);
exp2f,
/// double expm1(double x);
expm1,
/// long double expm1l(long double x);
expm1l,
/// float expm1f(float x);
expl1f,
/// double fabs(double x);
fabs,
/// long double fabsl(long double x);
fabsl,
/// float fabsf(float x);
fabsf,
/// double floor(double x);
floor,
/// long double floorl(long double x);
floorl,
/// float floorf(float x);
floorf,
/// int fiprintf(FILE *stream, const char *format, ...);
fiprintf,
/// double fmod(double x, double y);
fmod,
/// long double fmodl(long double x, long double y);
fmodl,
/// float fmodf(float x, float y);
fmodf,
/// int fputs(const char *s, FILE *stream);
fputs,
/// size_t fwrite(const void *ptr, size_t size, size_t nitems,
/// FILE *stream);
fwrite,
/// int iprintf(const char *format, ...);
iprintf,
/// double log(double x);
log,
/// long double logl(long double x);
logl,
/// float logf(float x);
logf,
/// double log2(double x);
log2,
/// double long double log2l(long double x);
log2l,
/// float log2f(float x);
log2f,
/// double log10(double x);
log10,
/// long double log10l(long double x);
log10l,
/// float log10f(float x);
log10f,
/// double log1p(double x);
log1p,
/// long double log1pl(long double x);
log1pl,
/// float log1pf(float x);
log1pf,
/// void *memcpy(void *s1, const void *s2, size_t n);
memcpy,
/// void *memmove(void *s1, const void *s2, size_t n);
memmove,
/// void *memset(void *b, int c, size_t len);
memset,
/// void memset_pattern16(void *b, const void *pattern16, size_t len);
memset_pattern16,
/// double nearbyint(double x);
nearbyint,
/// float nearbyintf(float x);
nearbyintf,
/// long double nearbyintl(long double x);
nearbyintl,
/// double pow(double x, double y);
pow,
/// float powf(float x, float y);
powf,
/// long double powl(long double x, long double y);
powl,
/// double rint(double x);
rint,
/// float rintf(float x);
rintf,
/// long dobule rintl(long double x);
rintl,
/// double sin(double x);
sin,
/// long double sinl(long double x);
sinl,
/// float sinf(float x);
sinf,
/// double sinh(double x);
sinh,
/// long double sinhl(long double x);
sinhl,
/// float sinhf(float x);
sinhf,
/// int siprintf(char *str, const char *format, ...);
siprintf,
/// double sqrt(double x);
sqrt,
/// long double sqrtl(long double x);
sqrtl,
/// float sqrtf(float x);
sqrtf,
/// double tan(double x);
tan,
/// long double tanl(long double x);
tanl,
/// float tanf(float x);
tanf,
/// double tanh(double x);
tanh,
/// long double tanhl(long double x);
tanhl,
/// float tanhf(float x);
tanhf,
/// double trunc(double x);
trunc,
/// float truncf(float x);
truncf,
/// long double truncl(long double x);
truncl,
/// int __cxa_atexit(void (*f)(void *), void *p, void *d);
cxa_atexit,
/// void __cxa_guard_abort(guard_t *guard);
/// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
cxa_guard_abort,
/// int __cxa_guard_acquire(guard_t *guard);
cxa_guard_acquire,
/// void __cxa_guard_release(guard_t *guard);
cxa_guard_release,
NumLibFuncs
};
}
/// TargetLibraryInfo - This immutable pass captures information about what
/// library functions are available for the current target, and allows a
/// frontend to disable optimizations through -fno-builtin etc.
class TargetLibraryInfo : public ImmutablePass {
virtual void anchor();
unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4];
llvm::DenseMap<unsigned, std::string> CustomNames;
static const char* StandardNames[LibFunc::NumLibFuncs];
enum AvailabilityState {
StandardName = 3, // (memset to all ones)
CustomName = 1,
Unavailable = 0 // (memset to all zeros)
};
void setState(LibFunc::Func F, AvailabilityState State) {
AvailableArray[F/4] &= ~(3 << 2*(F&3));
AvailableArray[F/4] |= State << 2*(F&3);
}
AvailabilityState getState(LibFunc::Func F) const {
return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
}
public:
static char ID;
TargetLibraryInfo();
TargetLibraryInfo(const Triple &T);
explicit TargetLibraryInfo(const TargetLibraryInfo &TLI);
/// has - This function is used by optimizations that want to match on or form
/// a given library function.
bool has(LibFunc::Func F) const {
return getState(F) != Unavailable;
}
StringRef getName(LibFunc::Func F) const {
AvailabilityState State = getState(F);
if (State == Unavailable)
return StringRef();
if (State == StandardName)
return StandardNames[F];
assert(State == CustomName);
return CustomNames.find(F)->second;
}
/// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to
/// ban use of specific library functions.
void setUnavailable(LibFunc::Func F) {
setState(F, Unavailable);
}
void setAvailable(LibFunc::Func F) {
setState(F, StandardName);
}
void setAvailableWithName(LibFunc::Func F, StringRef Name) {
if (StandardNames[F] != Name) {
setState(F, CustomName);
CustomNames[F] = Name;
assert(CustomNames.find(F) != CustomNames.end());
} else {
setState(F, StandardName);
}
}
/// disableAllFunctions - This disables all builtins, which is used for
/// options like -fno-builtin.
void disableAllFunctions();
};
} // end namespace llvm
#endif