mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-10-31 08:16:47 +00:00
6a7df9aae6
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
288 lines
7.9 KiB
C++
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
|