Make fortified (_chk) library functions LibFuncs in TLI.

[ab]

Summary

One of them was already there, the others were checked by
comparing function names.
Note that the fortified libfuncs are now part of TLI, but are always
available, because they aren't generated, only optimized into the
non-checking versions.

NFC.
Needed for D5982.

[echristo]

LGTM. Thanks!

-eric

[ab]

Closed by commit rL221817 (authored by @ab).

llvm/trunk/include/llvm/Target/TargetLibraryInfo.h

enum Func {
       /// void __cxa_guard_release(guard_t *guard);
       cxa_guard_release,
       /// int __isoc99_scanf (const char *format, ...)
       dunder_isoc99_scanf,
       /// int __isoc99_sscanf(const char *s, const char *format, ...)
       dunder_isoc99_sscanf,
       /// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
       memcpy_chk,
+      /// void *__memmove_chk(void *s1, const void *s2, size_t n,
+      ///                     size_t s1size);
+      memmove_chk,
+      /// void *__memset_chk(void *s, char v, size_t n, size_t s1size);
+      memset_chk,
       /// double __sincospi_stret(double x);
       sincospi_stret,
       /// float __sincospif_stret(float x);
       sincospif_stret,
       /// double __sinpi(double x);
       sinpi,
       /// float __sinpif(float x);
       sinpif,
       /// double __sqrt_finite(double x);
       sqrt_finite,
       /// float __sqrt_finite(float x);
       sqrtf_finite,
       /// long double __sqrt_finite(long double x);
       sqrtl_finite,
+      /// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size);
+      stpcpy_chk,
+      /// char *__stpncpy_chk(char *s1, const char *s2, size_t n,
+      ///                     size_t s1size);
+      stpncpy_chk,
+      /// char *__strcpy_chk(char *s1, const char *s2, size_t s1size);
+      strcpy_chk,
       /// char * __strdup(const char *s);
       dunder_strdup,
+      /// char *__strncpy_chk(char *s1, const char *s2, size_t n,
+      ///                     size_t s1size);
+      strncpy_chk,
       /// char *__strndup(const char *s, size_t n);
       dunder_strndup,
       /// char * __strtok_r(char *s, const char *delim, char **save_ptr);
       dunder_strtok_r,
       /// int abs(int j);
       abs,
       /// int access(const char *path, int amode);
       access,

llvm/trunk/lib/Target/TargetLibraryInfo.cpp

const char* TargetLibraryInfo::StandardNames[LibFunc::NumLibFuncs] =
     "__cospif",
     "__cxa_atexit",
     "__cxa_guard_abort",
     "__cxa_guard_acquire",
     "__cxa_guard_release",
     "__isoc99_scanf",
     "__isoc99_sscanf",
     "__memcpy_chk",
+    "__memmove_chk",
+    "__memset_chk",
     "__sincospi_stret",
     "__sincospif_stret",
     "__sinpi",
     "__sinpif",
     "__sqrt_finite",
     "__sqrtf_finite",
     "__sqrtl_finite",
+    "__stpcpy_chk",
+    "__stpncpy_chk",
+    "__strcpy_chk",
     "__strdup",
+    "__strncpy_chk",
     "__strndup",
     "__strtok_r",
     "abs",
     "access",
     "acos",
     "acosf",
     "acosh",
     "acoshf",

llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp

case LibFunc::tanh:
       return nullptr;
     case LibFunc::fmin:
     case LibFunc::fmax:
       if (hasFloatVersion(FuncName))
         return optimizeBinaryDoubleFP(CI, Builder);
       return nullptr;
     case LibFunc::memcpy_chk:
       return optimizeMemCpyChk(CI, Builder);
-    default:
-      return nullptr;
-    }
-  }
-
-  if (!isCallingConvC)
-    return nullptr;
-
-  // Finally check for fortified library calls.
-  if (FuncName.endswith("_chk")) {
-    if (FuncName == "__memmove_chk")
+    case LibFunc::memmove_chk:
       return optimizeMemMoveChk(CI, Builder);
-    else if (FuncName == "__memset_chk")
+    case LibFunc::memset_chk:
       return optimizeMemSetChk(CI, Builder);
-    else if (FuncName == "__strcpy_chk")
+    case LibFunc::strcpy_chk:
       return optimizeStrCpyChk(CI, Builder);
-    else if (FuncName == "__stpcpy_chk")
+    case LibFunc::stpcpy_chk:
       return optimizeStpCpyChk(CI, Builder);
-    else if (FuncName == "__strncpy_chk")
-      return optimizeStrNCpyChk(CI, Builder);
-    else if (FuncName == "__stpncpy_chk")
+    case LibFunc::stpncpy_chk:
+    case LibFunc::strncpy_chk:
       return optimizeStrNCpyChk(CI, Builder);
+    default:
+      return nullptr;
+    }
   }
 
   return nullptr;
 }
 
 LibCallSimplifier::LibCallSimplifier(const DataLayout *DL,
                                      const TargetLibraryInfo *TLI) :
                                      DL(DL),