1
0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 11:02:59 +02:00

Add new getLibFunc method to TargetLibraryInfo.

This just provides a way to look up a LibFunc::Func enum value for a
function name.  Alphabetize the enums and function names so we can use a
binary search.

llvm-svn: 161231
This commit is contained in:
Bob Wilson 2012-08-03 04:06:22 +00:00
parent ca5d760bf2
commit 627fc538a7
2 changed files with 130 additions and 107 deletions

View File

@ -18,36 +18,47 @@ namespace llvm {
namespace LibFunc {
enum Func {
/// 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,
/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
memcpy_chk,
/// double acos(double x);
acos,
/// long double acosl(long double x);
acosl,
/// float acosf(float x);
acosf,
/// long double acosl(long double x);
acosl,
/// double asin(double x);
asin,
/// long double asinl(long double x);
asinl,
/// float asinf(float x);
asinf,
/// long double asinl(long double x);
asinl,
/// 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,
/// long double atan2l(long double y, long double x);
atan2l,
/// float atanf(float x);
atanf,
/// long double atanl(long double x);
atanl,
/// double ceil(double x);
ceil,
/// long double ceill(long double x);
ceill,
/// float ceilf(float x);
ceilf,
/// long double ceill(long double x);
ceill,
/// double copysign(double x, double y);
copysign,
/// float copysignf(float x, float y);
@ -56,54 +67,54 @@ namespace llvm {
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,
/// long double coshl(long double x);
coshl,
/// long double cosl(long double x);
cosl,
/// 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,
/// long double exp2l(long double x);
exp2l,
/// float expf(float x);
expf,
/// long double expl(long double x);
expl,
/// double expm1(double x);
expm1,
/// long double expm1l(long double x);
expm1l,
/// float expm1f(float x);
expm1f,
/// long double expm1l(long double x);
expm1l,
/// 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,
/// long double fabsl(long double x);
fabsl,
/// int fiprintf(FILE *stream, const char *format, ...);
fiprintf,
/// double floor(double x);
floor,
/// float floorf(float x);
floorf,
/// long double floorl(long double x);
floorl,
/// double fmod(double x, double y);
fmod,
/// long double fmodl(long double x, long double y);
fmodl,
/// float fmodf(float x, float y);
fmodf,
/// long double fmodl(long double x, long double y);
fmodl,
/// int fputc(int c, FILE *stream);
fputc,
/// int fputs(const char *s, FILE *stream);
@ -115,28 +126,28 @@ namespace llvm {
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,
/// long double log10l(long double x);
log10l,
/// double log1p(double x);
log1p,
/// long double log1pl(long double x);
log1pl,
/// float log1pf(float x);
log1pf,
/// long double log1pl(long double x);
log1pl,
/// double log2(double x);
log2,
/// float log2f(float x);
log2f,
/// double long double log2l(long double x);
log2l,
/// float logf(float x);
logf,
/// long double logl(long double x);
logl,
/// void *memchr(const void *s, int c, size_t n);
memchr,
/// int memcmp(const void *s1, const void *s2, size_t n);
@ -179,24 +190,24 @@ namespace llvm {
roundl,
/// 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,
/// long double sinhl(long double x);
sinhl,
/// long double sinl(long double x);
sinl,
/// 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,
/// long double sqrtl(long double x);
sqrtl,
/// char *strcat(char *s1, const char *s2);
strcat,
/// char *strchr(const char *s, int c);
@ -215,33 +226,22 @@ namespace llvm {
strnlen,
/// 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,
/// long double tanhl(long double x);
tanhl,
/// long double tanl(long double x);
tanl,
/// 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,
/// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
memcpy_chk,
NumLibFuncs
};
@ -275,6 +275,10 @@ public:
TargetLibraryInfo(const Triple &T);
explicit TargetLibraryInfo(const TargetLibraryInfo &TLI);
/// getLibFunc - Search for a particular function name. If it is one of the
/// known library functions, return true and set F to the corresponding value.
bool getLibFunc(StringRef funcName, LibFunc::Func &F) const;
/// has - This function is used by optimizations that want to match on or form
/// a given library function.
bool has(LibFunc::Func F) const {

View File

@ -24,65 +24,70 @@ void TargetLibraryInfo::anchor() { }
const char* TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
{
"__cxa_atexit",
"__cxa_guard_abort",
"__cxa_guard_acquire",
"__cxa_guard_release",
"__memcpy_chk",
"acos",
"acosl",
"acosf",
"acosl",
"asin",
"asinl",
"asinf",
"asinl",
"atan",
"atanl",
"atanf",
"atan2",
"atan2l",
"atan2f",
"atan2l",
"atanf",
"atanl",
"ceil",
"ceill",
"ceilf",
"ceill",
"copysign",
"copysignf",
"copysignl",
"cos",
"cosl",
"cosf",
"cosh",
"coshl",
"coshf",
"coshl",
"cosl",
"exp",
"expl",
"expf",
"exp2",
"exp2l",
"exp2f",
"exp2l",
"expf",
"expl",
"expm1",
"expm1l",
"expm1f",
"expm1l",
"fabs",
"fabsl",
"fabsf",
"floor",
"floorl",
"floorf",
"fabsl",
"fiprintf",
"floor",
"floorf",
"floorl",
"fmod",
"fmodl",
"fmodf",
"fmodl",
"fputc",
"fputs",
"fwrite",
"iprintf",
"log",
"logl",
"logf",
"log2",
"log2l",
"log2f",
"log10",
"log10l",
"log10f",
"log10l",
"log1p",
"log1pl",
"log1pf",
"log1pl",
"log2",
"log2f",
"log2l",
"logf",
"logl",
"memchr",
"memcmp",
"memcpy",
@ -104,15 +109,15 @@ const char* TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
"roundf",
"roundl",
"sin",
"sinl",
"sinf",
"sinh",
"sinhl",
"sinhf",
"sinhl",
"sinl",
"siprintf",
"sqrt",
"sqrtl",
"sqrtf",
"sqrtl",
"strcat",
"strchr",
"strcpy",
@ -122,27 +127,30 @@ const char* TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
"strncpy",
"strnlen",
"tan",
"tanl",
"tanf",
"tanh",
"tanhl",
"tanhf",
"tanhl",
"tanl",
"trunc",
"truncf",
"truncl",
"__cxa_atexit",
"__cxa_guard_abort",
"__cxa_guard_acquire",
"__cxa_guard_release",
"__memcpy_chk"
"truncl"
};
/// initialize - Initialize the set of available library functions based on the
/// specified target triple. This should be carefully written so that a missing
/// target triple gets a sane set of defaults.
static void initialize(TargetLibraryInfo &TLI, const Triple &T) {
static void initialize(TargetLibraryInfo &TLI, const Triple &T,
const char **StandardNames) {
initializeTargetLibraryInfoPass(*PassRegistry::getPassRegistry());
#ifndef NDEBUG
// Verify that the StandardNames array is in alphabetical order.
for (unsigned F = 1; F < LibFunc::NumLibFuncs; ++F) {
if (strcmp(StandardNames[F-1], StandardNames[F]) >= 0)
llvm_unreachable("TargetLibraryInfo function names must be sorted");
}
#endif // !NDEBUG
// memset_pattern16 is only available on iOS 3.0 and Mac OS/X 10.5 and later.
if (T.isMacOSX()) {
@ -254,14 +262,14 @@ TargetLibraryInfo::TargetLibraryInfo() : ImmutablePass(ID) {
// Default to everything being available.
memset(AvailableArray, -1, sizeof(AvailableArray));
initialize(*this, Triple());
initialize(*this, Triple(), StandardNames);
}
TargetLibraryInfo::TargetLibraryInfo(const Triple &T) : ImmutablePass(ID) {
// Default to everything being available.
memset(AvailableArray, -1, sizeof(AvailableArray));
initialize(*this, T);
initialize(*this, T, StandardNames);
}
TargetLibraryInfo::TargetLibraryInfo(const TargetLibraryInfo &TLI)
@ -270,6 +278,17 @@ TargetLibraryInfo::TargetLibraryInfo(const TargetLibraryInfo &TLI)
CustomNames = TLI.CustomNames;
}
bool TargetLibraryInfo::getLibFunc(StringRef funcName,
LibFunc::Func &F) const {
const char **Start = &StandardNames[0];
const char **End = &StandardNames[LibFunc::NumLibFuncs];
const char **I = std::lower_bound(Start, End, funcName);
if (I != End && *I == funcName) {
F = (LibFunc::Func)(I - Start);
return true;
}
return false;
}
/// disableAllFunctions - This disables all builtins, which is used for options
/// like -fno-builtin.