lib/Analysis/TargetLibraryInfo.cpp

   1 //===-- TargetLibraryInfo.cpp - Runtime library information ----------------==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the TargetLibraryInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Analysis/TargetLibraryInfo.h"
  15 #include "llvm/ADT/Triple.h"
  16 using namespace llvm;
  17
  18 const char* TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
  19   {
  20     "_IO_getc",
  21     "_IO_putc",
  22     "_ZdaPv",
  23     "_ZdaPvRKSt9nothrow_t",
  24     "_ZdaPvj",
  25     "_ZdaPvm",
  26     "_ZdlPv",
  27     "_ZdlPvRKSt9nothrow_t",
  28     "_ZdlPvj",
  29     "_ZdlPvm",
  30     "_Znaj",
  31     "_ZnajRKSt9nothrow_t",
  32     "_Znam",
  33     "_ZnamRKSt9nothrow_t",
  34     "_Znwj",
  35     "_ZnwjRKSt9nothrow_t",
  36     "_Znwm",
  37     "_ZnwmRKSt9nothrow_t",
  38     "__cospi",
  39     "__cospif",
  40     "__cxa_atexit",
  41     "__cxa_guard_abort",
  42     "__cxa_guard_acquire",
  43     "__cxa_guard_release",
  44     "__isoc99_scanf",
  45     "__isoc99_sscanf",
  46     "__memcpy_chk",
  47     "__memmove_chk",
  48     "__memset_chk",
  49     "__sincospi_stret",
  50     "__sincospif_stret",
  51     "__sinpi",
  52     "__sinpif",
  53     "__sqrt_finite",
  54     "__sqrtf_finite",
  55     "__sqrtl_finite",
  56     "__stpcpy_chk",
  57     "__stpncpy_chk",
  58     "__strcpy_chk",
  59     "__strdup",
  60     "__strncpy_chk",
  61     "__strndup",
  62     "__strtok_r",
  63     "abs",
  64     "access",
  65     "acos",
  66     "acosf",
  67     "acosh",
  68     "acoshf",
  69     "acoshl",
  70     "acosl",
  71     "asin",
  72     "asinf",
  73     "asinh",
  74     "asinhf",
  75     "asinhl",
  76     "asinl",
  77     "atan",
  78     "atan2",
  79     "atan2f",
  80     "atan2l",
  81     "atanf",
  82     "atanh",
  83     "atanhf",
  84     "atanhl",
  85     "atanl",
  86     "atof",
  87     "atoi",
  88     "atol",
  89     "atoll",
  90     "bcmp",
  91     "bcopy",
  92     "bzero",
  93     "calloc",
  94     "cbrt",
  95     "cbrtf",
  96     "cbrtl",
  97     "ceil",
  98     "ceilf",
  99     "ceill",
 100     "chmod",
 101     "chown",
 102     "clearerr",
 103     "closedir",
 104     "copysign",
 105     "copysignf",
 106     "copysignl",
 107     "cos",
 108     "cosf",
 109     "cosh",
 110     "coshf",
 111     "coshl",
 112     "cosl",
 113     "ctermid",
 114     "exp",
 115     "exp10",
 116     "exp10f",
 117     "exp10l",
 118     "exp2",
 119     "exp2f",
 120     "exp2l",
 121     "expf",
 122     "expl",
 123     "expm1",
 124     "expm1f",
 125     "expm1l",
 126     "fabs",
 127     "fabsf",
 128     "fabsl",
 129     "fclose",
 130     "fdopen",
 131     "feof",
 132     "ferror",
 133     "fflush",
 134     "ffs",
 135     "ffsl",
 136     "ffsll",
 137     "fgetc",
 138     "fgetpos",
 139     "fgets",
 140     "fileno",
 141     "fiprintf",
 142     "flockfile",
 143     "floor",
 144     "floorf",
 145     "floorl",
 146     "fmax",
 147     "fmaxf",
 148     "fmaxl",
 149     "fmin",
 150     "fminf",
 151     "fminl",
 152     "fmod",
 153     "fmodf",
 154     "fmodl",
 155     "fopen",
 156     "fopen64",
 157     "fprintf",
 158     "fputc",
 159     "fputs",
 160     "fread",
 161     "free",
 162     "frexp",
 163     "frexpf",
 164     "frexpl",
 165     "fscanf",
 166     "fseek",
 167     "fseeko",
 168     "fseeko64",
 169     "fsetpos",
 170     "fstat",
 171     "fstat64",
 172     "fstatvfs",
 173     "fstatvfs64",
 174     "ftell",
 175     "ftello",
 176     "ftello64",
 177     "ftrylockfile",
 178     "funlockfile",
 179     "fwrite",
 180     "getc",
 181     "getc_unlocked",
 182     "getchar",
 183     "getenv",
 184     "getitimer",
 185     "getlogin_r",
 186     "getpwnam",
 187     "gets",
 188     "gettimeofday",
 189     "htonl",
 190     "htons",
 191     "iprintf",
 192     "isascii",
 193     "isdigit",
 194     "labs",
 195     "lchown",
 196     "ldexp",
 197     "ldexpf",
 198     "ldexpl",
 199     "llabs",
 200     "log",
 201     "log10",
 202     "log10f",
 203     "log10l",
 204     "log1p",
 205     "log1pf",
 206     "log1pl",
 207     "log2",
 208     "log2f",
 209     "log2l",
 210     "logb",
 211     "logbf",
 212     "logbl",
 213     "logf",
 214     "logl",
 215     "lstat",
 216     "lstat64",
 217     "malloc",
 218     "memalign",
 219     "memccpy",
 220     "memchr",
 221     "memcmp",
 222     "memcpy",
 223     "memmove",
 224     "memrchr",
 225     "memset",
 226     "memset_pattern16",
 227     "mkdir",
 228     "mktime",
 229     "modf",
 230     "modff",
 231     "modfl",
 232     "nearbyint",
 233     "nearbyintf",
 234     "nearbyintl",
 235     "ntohl",
 236     "ntohs",
 237     "open",
 238     "open64",
 239     "opendir",
 240     "pclose",
 241     "perror",
 242     "popen",
 243     "posix_memalign",
 244     "pow",
 245     "powf",
 246     "powl",
 247     "pread",
 248     "printf",
 249     "putc",
 250     "putchar",
 251     "puts",
 252     "pwrite",
 253     "qsort",
 254     "read",
 255     "readlink",
 256     "realloc",
 257     "reallocf",
 258     "realpath",
 259     "remove",
 260     "rename",
 261     "rewind",
 262     "rint",
 263     "rintf",
 264     "rintl",
 265     "rmdir",
 266     "round",
 267     "roundf",
 268     "roundl",
 269     "scanf",
 270     "setbuf",
 271     "setitimer",
 272     "setvbuf",
 273     "sin",
 274     "sinf",
 275     "sinh",
 276     "sinhf",
 277     "sinhl",
 278     "sinl",
 279     "siprintf",
 280     "snprintf",
 281     "sprintf",
 282     "sqrt",
 283     "sqrtf",
 284     "sqrtl",
 285     "sscanf",
 286     "stat",
 287     "stat64",
 288     "statvfs",
 289     "statvfs64",
 290     "stpcpy",
 291     "stpncpy",
 292     "strcasecmp",
 293     "strcat",
 294     "strchr",
 295     "strcmp",
 296     "strcoll",
 297     "strcpy",
 298     "strcspn",
 299     "strdup",
 300     "strlen",
 301     "strncasecmp",
 302     "strncat",
 303     "strncmp",
 304     "strncpy",
 305     "strndup",
 306     "strnlen",
 307     "strpbrk",
 308     "strrchr",
 309     "strspn",
 310     "strstr",
 311     "strtod",
 312     "strtof",
 313     "strtok",
 314     "strtok_r",
 315     "strtol",
 316     "strtold",
 317     "strtoll",
 318     "strtoul",
 319     "strtoull",
 320     "strxfrm",
 321     "system",
 322     "tan",
 323     "tanf",
 324     "tanh",
 325     "tanhf",
 326     "tanhl",
 327     "tanl",
 328     "times",
 329     "tmpfile",
 330     "tmpfile64",
 331     "toascii",
 332     "trunc",
 333     "truncf",
 334     "truncl",
 335     "uname",
 336     "ungetc",
 337     "unlink",
 338     "unsetenv",
 339     "utime",
 340     "utimes",
 341     "valloc",
 342     "vfprintf",
 343     "vfscanf",
 344     "vprintf",
 345     "vscanf",
 346     "vsnprintf",
 347     "vsprintf",
 348     "vsscanf",
 349     "write"
 350   };
 351
 352 static bool hasSinCosPiStret(const Triple &T) {
 353   // Only Darwin variants have _stret versions of combined trig functions.
 354   if (!T.isOSDarwin())
 355     return false;
 356
 357   // The ABI is rather complicated on x86, so don't do anything special there.
 358   if (T.getArch() == Triple::x86)
 359     return false;
 360
 361   if (T.isMacOSX() && T.isMacOSXVersionLT(10, 9))
 362     return false;
 363
 364   if (T.isiOS() && T.isOSVersionLT(7, 0))
 365     return false;
 366
 367   return true;
 368 }
 369
 370 /// initialize - Initialize the set of available library functions based on the
 371 /// specified target triple.  This should be carefully written so that a missing
 372 /// target triple gets a sane set of defaults.
 373 static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
 374                        const char **StandardNames) {
 375 #ifndef NDEBUG
 376   // Verify that the StandardNames array is in alphabetical order.
 377   for (unsigned F = 1; F < LibFunc::NumLibFuncs; ++F) {
 378     if (strcmp(StandardNames[F-1], StandardNames[F]) >= 0)
 379       llvm_unreachable("TargetLibraryInfoImpl function names must be sorted");
 380   }
 381 #endif // !NDEBUG
 382
 383   // There are no library implementations of mempcy and memset for AMD gpus and
 384   // these can be difficult to lower in the backend.
 385   if (T.getArch() == Triple::r600 ||
 386       T.getArch() == Triple::amdgcn) {
 387     TLI.setUnavailable(LibFunc::memcpy);
 388     TLI.setUnavailable(LibFunc::memset);
 389     TLI.setUnavailable(LibFunc::memset_pattern16);
 390     return;
 391   }
 392
 393   // memset_pattern16 is only available on iOS 3.0 and Mac OS X 10.5 and later.
 394   if (T.isMacOSX()) {
 395     if (T.isMacOSXVersionLT(10, 5))
 396       TLI.setUnavailable(LibFunc::memset_pattern16);
 397   } else if (T.isiOS()) {
 398     if (T.isOSVersionLT(3, 0))
 399       TLI.setUnavailable(LibFunc::memset_pattern16);
 400   } else {
 401     TLI.setUnavailable(LibFunc::memset_pattern16);
 402   }
 403
 404   if (!hasSinCosPiStret(T)) {
 405     TLI.setUnavailable(LibFunc::sinpi);
 406     TLI.setUnavailable(LibFunc::sinpif);
 407     TLI.setUnavailable(LibFunc::cospi);
 408     TLI.setUnavailable(LibFunc::cospif);
 409     TLI.setUnavailable(LibFunc::sincospi_stret);
 410     TLI.setUnavailable(LibFunc::sincospif_stret);
 411   }
 412
 413   if (T.isMacOSX() && T.getArch() == Triple::x86 &&
 414       !T.isMacOSXVersionLT(10, 7)) {
 415     // x86-32 OSX has a scheme where fwrite and fputs (and some other functions
 416     // we don't care about) have two versions; on recent OSX, the one we want
 417     // has a $UNIX2003 suffix. The two implementations are identical except
 418     // for the return value in some edge cases.  However, we don't want to
 419     // generate code that depends on the old symbols.
 420     TLI.setAvailableWithName(LibFunc::fwrite, "fwrite$UNIX2003");
 421     TLI.setAvailableWithName(LibFunc::fputs, "fputs$UNIX2003");
 422   }
 423
 424   // iprintf and friends are only available on XCore and TCE.
 425   if (T.getArch() != Triple::xcore && T.getArch() != Triple::tce) {
 426     TLI.setUnavailable(LibFunc::iprintf);
 427     TLI.setUnavailable(LibFunc::siprintf);
 428     TLI.setUnavailable(LibFunc::fiprintf);
 429   }
 430
 431   if (T.isOSWindows() && !T.isOSCygMing()) {
 432     // Win32 does not support long double
 433     TLI.setUnavailable(LibFunc::acosl);
 434     TLI.setUnavailable(LibFunc::asinl);
 435     TLI.setUnavailable(LibFunc::atanl);
 436     TLI.setUnavailable(LibFunc::atan2l);
 437     TLI.setUnavailable(LibFunc::ceill);
 438     TLI.setUnavailable(LibFunc::copysignl);
 439     TLI.setUnavailable(LibFunc::cosl);
 440     TLI.setUnavailable(LibFunc::coshl);
 441     TLI.setUnavailable(LibFunc::expl);
 442     TLI.setUnavailable(LibFunc::fabsf); // Win32 and Win64 both lack fabsf
 443     TLI.setUnavailable(LibFunc::fabsl);
 444     TLI.setUnavailable(LibFunc::floorl);
 445     TLI.setUnavailable(LibFunc::fmaxl);
 446     TLI.setUnavailable(LibFunc::fminl);
 447     TLI.setUnavailable(LibFunc::fmodl);
 448     TLI.setUnavailable(LibFunc::frexpl);
 449     TLI.setUnavailable(LibFunc::ldexpf);
 450     TLI.setUnavailable(LibFunc::ldexpl);
 451     TLI.setUnavailable(LibFunc::logl);
 452     TLI.setUnavailable(LibFunc::modfl);
 453     TLI.setUnavailable(LibFunc::powl);
 454     TLI.setUnavailable(LibFunc::sinl);
 455     TLI.setUnavailable(LibFunc::sinhl);
 456     TLI.setUnavailable(LibFunc::sqrtl);
 457     TLI.setUnavailable(LibFunc::tanl);
 458     TLI.setUnavailable(LibFunc::tanhl);
 459
 460     // Win32 only has C89 math
 461     TLI.setUnavailable(LibFunc::acosh);
 462     TLI.setUnavailable(LibFunc::acoshf);
 463     TLI.setUnavailable(LibFunc::acoshl);
 464     TLI.setUnavailable(LibFunc::asinh);
 465     TLI.setUnavailable(LibFunc::asinhf);
 466     TLI.setUnavailable(LibFunc::asinhl);
 467     TLI.setUnavailable(LibFunc::atanh);
 468     TLI.setUnavailable(LibFunc::atanhf);
 469     TLI.setUnavailable(LibFunc::atanhl);
 470     TLI.setUnavailable(LibFunc::cbrt);
 471     TLI.setUnavailable(LibFunc::cbrtf);
 472     TLI.setUnavailable(LibFunc::cbrtl);
 473     TLI.setUnavailable(LibFunc::exp2);
 474     TLI.setUnavailable(LibFunc::exp2f);
 475     TLI.setUnavailable(LibFunc::exp2l);
 476     TLI.setUnavailable(LibFunc::expm1);
 477     TLI.setUnavailable(LibFunc::expm1f);
 478     TLI.setUnavailable(LibFunc::expm1l);
 479     TLI.setUnavailable(LibFunc::log2);
 480     TLI.setUnavailable(LibFunc::log2f);
 481     TLI.setUnavailable(LibFunc::log2l);
 482     TLI.setUnavailable(LibFunc::log1p);
 483     TLI.setUnavailable(LibFunc::log1pf);
 484     TLI.setUnavailable(LibFunc::log1pl);
 485     TLI.setUnavailable(LibFunc::logb);
 486     TLI.setUnavailable(LibFunc::logbf);
 487     TLI.setUnavailable(LibFunc::logbl);
 488     TLI.setUnavailable(LibFunc::nearbyint);
 489     TLI.setUnavailable(LibFunc::nearbyintf);
 490     TLI.setUnavailable(LibFunc::nearbyintl);
 491     TLI.setUnavailable(LibFunc::rint);
 492     TLI.setUnavailable(LibFunc::rintf);
 493     TLI.setUnavailable(LibFunc::rintl);
 494     TLI.setUnavailable(LibFunc::round);
 495     TLI.setUnavailable(LibFunc::roundf);
 496     TLI.setUnavailable(LibFunc::roundl);
 497     TLI.setUnavailable(LibFunc::trunc);
 498     TLI.setUnavailable(LibFunc::truncf);
 499     TLI.setUnavailable(LibFunc::truncl);
 500
 501     // Win32 provides some C99 math with mangled names
 502     TLI.setAvailableWithName(LibFunc::copysign, "_copysign");
 503
 504     if (T.getArch() == Triple::x86) {
 505       // Win32 on x86 implements single-precision math functions as macros
 506       TLI.setUnavailable(LibFunc::acosf);
 507       TLI.setUnavailable(LibFunc::asinf);
 508       TLI.setUnavailable(LibFunc::atanf);
 509       TLI.setUnavailable(LibFunc::atan2f);
 510       TLI.setUnavailable(LibFunc::ceilf);
 511       TLI.setUnavailable(LibFunc::copysignf);
 512       TLI.setUnavailable(LibFunc::cosf);
 513       TLI.setUnavailable(LibFunc::coshf);
 514       TLI.setUnavailable(LibFunc::expf);
 515       TLI.setUnavailable(LibFunc::floorf);
 516       TLI.setUnavailable(LibFunc::fminf);
 517       TLI.setUnavailable(LibFunc::fmaxf);
 518       TLI.setUnavailable(LibFunc::fmodf);
 519       TLI.setUnavailable(LibFunc::logf);
 520       TLI.setUnavailable(LibFunc::powf);
 521       TLI.setUnavailable(LibFunc::sinf);
 522       TLI.setUnavailable(LibFunc::sinhf);
 523       TLI.setUnavailable(LibFunc::sqrtf);
 524       TLI.setUnavailable(LibFunc::tanf);
 525       TLI.setUnavailable(LibFunc::tanhf);
 526     }
 527
 528     // Win32 does *not* provide provide these functions, but they are
 529     // generally available on POSIX-compliant systems:
 530     TLI.setUnavailable(LibFunc::access);
 531     TLI.setUnavailable(LibFunc::bcmp);
 532     TLI.setUnavailable(LibFunc::bcopy);
 533     TLI.setUnavailable(LibFunc::bzero);
 534     TLI.setUnavailable(LibFunc::chmod);
 535     TLI.setUnavailable(LibFunc::chown);
 536     TLI.setUnavailable(LibFunc::closedir);
 537     TLI.setUnavailable(LibFunc::ctermid);
 538     TLI.setUnavailable(LibFunc::fdopen);
 539     TLI.setUnavailable(LibFunc::ffs);
 540     TLI.setUnavailable(LibFunc::fileno);
 541     TLI.setUnavailable(LibFunc::flockfile);
 542     TLI.setUnavailable(LibFunc::fseeko);
 543     TLI.setUnavailable(LibFunc::fstat);
 544     TLI.setUnavailable(LibFunc::fstatvfs);
 545     TLI.setUnavailable(LibFunc::ftello);
 546     TLI.setUnavailable(LibFunc::ftrylockfile);
 547     TLI.setUnavailable(LibFunc::funlockfile);
 548     TLI.setUnavailable(LibFunc::getc_unlocked);
 549     TLI.setUnavailable(LibFunc::getitimer);
 550     TLI.setUnavailable(LibFunc::getlogin_r);
 551     TLI.setUnavailable(LibFunc::getpwnam);
 552     TLI.setUnavailable(LibFunc::gettimeofday);
 553     TLI.setUnavailable(LibFunc::htonl);
 554     TLI.setUnavailable(LibFunc::htons);
 555     TLI.setUnavailable(LibFunc::lchown);
 556     TLI.setUnavailable(LibFunc::lstat);
 557     TLI.setUnavailable(LibFunc::memccpy);
 558     TLI.setUnavailable(LibFunc::mkdir);
 559     TLI.setUnavailable(LibFunc::ntohl);
 560     TLI.setUnavailable(LibFunc::ntohs);
 561     TLI.setUnavailable(LibFunc::open);
 562     TLI.setUnavailable(LibFunc::opendir);
 563     TLI.setUnavailable(LibFunc::pclose);
 564     TLI.setUnavailable(LibFunc::popen);
 565     TLI.setUnavailable(LibFunc::pread);
 566     TLI.setUnavailable(LibFunc::pwrite);
 567     TLI.setUnavailable(LibFunc::read);
 568     TLI.setUnavailable(LibFunc::readlink);
 569     TLI.setUnavailable(LibFunc::realpath);
 570     TLI.setUnavailable(LibFunc::rmdir);
 571     TLI.setUnavailable(LibFunc::setitimer);
 572     TLI.setUnavailable(LibFunc::stat);
 573     TLI.setUnavailable(LibFunc::statvfs);
 574     TLI.setUnavailable(LibFunc::stpcpy);
 575     TLI.setUnavailable(LibFunc::stpncpy);
 576     TLI.setUnavailable(LibFunc::strcasecmp);
 577     TLI.setUnavailable(LibFunc::strncasecmp);
 578     TLI.setUnavailable(LibFunc::times);
 579     TLI.setUnavailable(LibFunc::uname);
 580     TLI.setUnavailable(LibFunc::unlink);
 581     TLI.setUnavailable(LibFunc::unsetenv);
 582     TLI.setUnavailable(LibFunc::utime);
 583     TLI.setUnavailable(LibFunc::utimes);
 584     TLI.setUnavailable(LibFunc::write);
 585
 586     // Win32 does *not* provide provide these functions, but they are
 587     // specified by C99:
 588     TLI.setUnavailable(LibFunc::atoll);
 589     TLI.setUnavailable(LibFunc::frexpf);
 590     TLI.setUnavailable(LibFunc::llabs);
 591   }
 592
 593   switch (T.getOS()) {
 594   case Triple::MacOSX:
 595     // exp10 and exp10f are not available on OS X until 10.9 and iOS until 7.0
 596     // and their names are __exp10 and __exp10f. exp10l is not available on
 597     // OS X or iOS.
 598     TLI.setUnavailable(LibFunc::exp10l);
 599     if (T.isMacOSXVersionLT(10, 9)) {
 600       TLI.setUnavailable(LibFunc::exp10);
 601       TLI.setUnavailable(LibFunc::exp10f);
 602     } else {
 603       TLI.setAvailableWithName(LibFunc::exp10, "__exp10");
 604       TLI.setAvailableWithName(LibFunc::exp10f, "__exp10f");
 605     }
 606     break;
 607   case Triple::IOS:
 608     TLI.setUnavailable(LibFunc::exp10l);
 609     if (T.isOSVersionLT(7, 0)) {
 610       TLI.setUnavailable(LibFunc::exp10);
 611       TLI.setUnavailable(LibFunc::exp10f);
 612     } else {
 613       TLI.setAvailableWithName(LibFunc::exp10, "__exp10");
 614       TLI.setAvailableWithName(LibFunc::exp10f, "__exp10f");
 615     }
 616     break;
 617   case Triple::Linux:
 618     // exp10, exp10f, exp10l is available on Linux (GLIBC) but are extremely
 619     // buggy prior to glibc version 2.18. Until this version is widely deployed
 620     // or we have a reasonable detection strategy, we cannot use exp10 reliably
 621     // on Linux.
 622     //
 623     // Fall through to disable all of them.
 624   default:
 625     TLI.setUnavailable(LibFunc::exp10);
 626     TLI.setUnavailable(LibFunc::exp10f);
 627     TLI.setUnavailable(LibFunc::exp10l);
 628   }
 629
 630   // ffsl is available on at least Darwin, Mac OS X, iOS, FreeBSD, and
 631   // Linux (GLIBC):
 632   // http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/ffsl.3.html
 633   // http://svn.freebsd.org/base/user/eri/pf45/head/lib/libc/string/ffsl.c
 634   // http://www.gnu.org/software/gnulib/manual/html_node/ffsl.html
 635   switch (T.getOS()) {
 636   case Triple::Darwin:
 637   case Triple::MacOSX:
 638   case Triple::IOS:
 639   case Triple::FreeBSD:
 640   case Triple::Linux:
 641     break;
 642   default:
 643     TLI.setUnavailable(LibFunc::ffsl);
 644   }
 645
 646   // ffsll is available on at least FreeBSD and Linux (GLIBC):
 647   // http://svn.freebsd.org/base/user/eri/pf45/head/lib/libc/string/ffsll.c
 648   // http://www.gnu.org/software/gnulib/manual/html_node/ffsll.html
 649   switch (T.getOS()) {
 650   case Triple::FreeBSD:
 651   case Triple::Linux:
 652     break;
 653   default:
 654     TLI.setUnavailable(LibFunc::ffsll);
 655   }
 656
 657   // The following functions are available on at least Linux:
 658   if (!T.isOSLinux()) {
 659     TLI.setUnavailable(LibFunc::dunder_strdup);
 660     TLI.setUnavailable(LibFunc::dunder_strtok_r);
 661     TLI.setUnavailable(LibFunc::dunder_isoc99_scanf);
 662     TLI.setUnavailable(LibFunc::dunder_isoc99_sscanf);
 663     TLI.setUnavailable(LibFunc::under_IO_getc);
 664     TLI.setUnavailable(LibFunc::under_IO_putc);
 665     TLI.setUnavailable(LibFunc::memalign);
 666     TLI.setUnavailable(LibFunc::fopen64);
 667     TLI.setUnavailable(LibFunc::fseeko64);
 668     TLI.setUnavailable(LibFunc::fstat64);
 669     TLI.setUnavailable(LibFunc::fstatvfs64);
 670     TLI.setUnavailable(LibFunc::ftello64);
 671     TLI.setUnavailable(LibFunc::lstat64);
 672     TLI.setUnavailable(LibFunc::open64);
 673     TLI.setUnavailable(LibFunc::stat64);
 674     TLI.setUnavailable(LibFunc::statvfs64);
 675     TLI.setUnavailable(LibFunc::tmpfile64);
 676   }
 677 }
 678
 679 TargetLibraryInfoImpl::TargetLibraryInfoImpl() {
 680   // Default to everything being available.
 681   memset(AvailableArray, -1, sizeof(AvailableArray));
 682
 683   initialize(*this, Triple(), StandardNames);
 684 }
 685
 686 TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) {
 687   // Default to everything being available.
 688   memset(AvailableArray, -1, sizeof(AvailableArray));
 689
 690   initialize(*this, T, StandardNames);
 691 }
 692
 693 TargetLibraryInfoImpl::TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI)
 694     : CustomNames(TLI.CustomNames) {
 695   memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
 696 }
 697
 698 TargetLibraryInfoImpl::TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI)
 699     : CustomNames(std::move(TLI.CustomNames)) {
 700   std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
 701             AvailableArray);
 702 }
 703
 704 TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(const TargetLibraryInfoImpl &TLI) {
 705   CustomNames = TLI.CustomNames;
 706   memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
 707   return *this;
 708 }
 709
 710 TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl &&TLI) {
 711   CustomNames = std::move(TLI.CustomNames);
 712   std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
 713             AvailableArray);
 714   return *this;
 715 }
 716
 717 namespace {
 718 struct StringComparator {
 719   /// Compare two strings and return true if LHS is lexicographically less than
 720   /// RHS. Requires that RHS doesn't contain any zero bytes.
 721   bool operator()(const char *LHS, StringRef RHS) const {
 722     // Compare prefixes with strncmp. If prefixes match we know that LHS is
 723     // greater or equal to RHS as RHS can't contain any '\0'.
 724     return std::strncmp(LHS, RHS.data(), RHS.size()) < 0;
 725   }
 726
 727   // Provided for compatibility with MSVC's debug mode.
 728   bool operator()(StringRef LHS, const char *RHS) const { return LHS < RHS; }
 729   bool operator()(StringRef LHS, StringRef RHS) const { return LHS < RHS; }
 730   bool operator()(const char *LHS, const char *RHS) const {
 731     return std::strcmp(LHS, RHS) < 0;
 732   }
 733 };
 734 }
 735
 736 bool TargetLibraryInfoImpl::getLibFunc(StringRef funcName,
 737                                    LibFunc::Func &F) const {
 738   const char **Start = &StandardNames[0];
 739   const char **End = &StandardNames[LibFunc::NumLibFuncs];
 740
 741   // Filter out empty names and names containing null bytes, those can't be in
 742   // our table.
 743   if (funcName.empty() || funcName.find('\0') != StringRef::npos)
 744     return false;
 745
 746   // Check for \01 prefix that is used to mangle __asm declarations and
 747   // strip it if present.
 748   if (funcName.front() == '\01')
 749     funcName = funcName.substr(1);
 750   const char **I = std::lower_bound(Start, End, funcName, StringComparator());
 751   if (I != End && *I == funcName) {
 752     F = (LibFunc::Func)(I - Start);
 753     return true;
 754   }
 755   return false;
 756 }
 757
 758 void TargetLibraryInfoImpl::disableAllFunctions() {
 759   memset(AvailableArray, 0, sizeof(AvailableArray));
 760 }
 761
 762 TargetLibraryInfo TargetLibraryAnalysis::run(Module &M) {
 763   if (PresetInfoImpl)
 764     return TargetLibraryInfo(*PresetInfoImpl);
 765
 766   return TargetLibraryInfo(lookupInfoImpl(Triple(M.getTargetTriple())));
 767 }
 768
 769 TargetLibraryInfo TargetLibraryAnalysis::run(Function &F) {
 770   if (PresetInfoImpl)
 771     return TargetLibraryInfo(*PresetInfoImpl);
 772
 773   return TargetLibraryInfo(
 774       lookupInfoImpl(Triple(F.getParent()->getTargetTriple())));
 775 }
 776
 777 TargetLibraryInfoImpl &TargetLibraryAnalysis::lookupInfoImpl(Triple T) {
 778   std::unique_ptr<TargetLibraryInfoImpl> &Impl =
 779       Impls[T.normalize()];
 780   if (!Impl)
 781     Impl.reset(new TargetLibraryInfoImpl(T));
 782
 783   return *Impl;
 784 }
 785
 786
 787 TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass()
 788     : ImmutablePass(ID), TLIImpl(), TLI(TLIImpl) {
 789   initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 790 }
 791
 792 TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(const Triple &T)
 793     : ImmutablePass(ID), TLIImpl(T), TLI(TLIImpl) {
 794   initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 795 }
 796
 797 TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(
 798     const TargetLibraryInfoImpl &TLIImpl)
 799     : ImmutablePass(ID), TLIImpl(TLIImpl), TLI(this->TLIImpl) {
 800   initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 801 }
 802
 803 char TargetLibraryAnalysis::PassID;
 804
 805 // Register the basic pass.
 806 INITIALIZE_PASS(TargetLibraryInfoWrapperPass, "targetlibinfo",
 807                 "Target Library Information", false, true)
 808 char TargetLibraryInfoWrapperPass::ID = 0;
 809
 810 void TargetLibraryInfoWrapperPass::anchor() {}