[libc] Add restrict qualifiers to string library; give consistent naming scheme to TableGen files.

libc/spec/posix.td

 def SigSetType : NamedType<"sigset_t">;
 def SigSetPtrType : PtrType<SigSetType>;
 def ConstSigSetPtrType : ConstType<SigSetPtrType>;
-def RestrictSigSetType : RestrictedPtrType<SigSetType>;
-def ConstRestrictSigSetType : ConstType<RestrictSigSetType>;
+def RestrictedSigSetType : RestrictedPtrType<SigSetType>;
+def ConstRestrictedSigSetType : ConstType<RestrictedSigSetType>;
 
 def StructSigaction : NamedType<"struct sigaction">;
 def StructSigactionPtr : PtrType<StructSigaction>;
 def ConstStructSigactionPtr : ConstType<StructSigactionPtr>;
-def RestrictStructSigactionPtr : RestrictedPtrType<StructSigaction>;
-def ConstRestrictStructSigactionPtr : ConstType<RestrictStructSigactionPtr>;
+def RestrictedStructSigactionPtr : RestrictedPtrType<StructSigaction>;
+def ConstRestrictedStructSigactionPtr : ConstType<RestrictedStructSigactionPtr>;
 
 def POSIX : StandardSpec<"POSIX"> {
-  // TODO: Change naming so that they're consistent with other files.
   PtrType CharPtr = PtrType<CharType>;
-  ConstType ConstCharPtr = ConstType<CharPtr>;
   RestrictedPtrType RestrictedCharPtr = RestrictedPtrType<CharType>;
-  ConstType ConstRestrictedCharPtr = ConstType<RestrictedCharPtr>;
   RestrictedPtrType CharRestrictedDoublePtr = RestrictedPtrType<CharPtr>;
+  ConstType ConstCharPtr = ConstType<CharPtr>;
+  ConstType ConstRestrictedCharPtr = ConstType<RestrictedCharPtr>;
+
   NamedType OffTType = NamedType<"off_t">;
   NamedType SSizeTType = NamedType<"ssize_t">;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [
         Macro<"E2BIG">,
         Macro<"EACCES">,
HeaderSpec Signal = HeaderSpec<
         StructSigaction,
       ],
       [], // Enumerations
       [
         FunctionSpec<
           "sigaction",
           RetValSpec<IntType>,
           [ArgSpec<IntType>,
-           ArgSpec<ConstRestrictStructSigactionPtr>,
-           ArgSpec<RestrictStructSigactionPtr>]
+           ArgSpec<ConstRestrictedStructSigactionPtr>,
+           ArgSpec<RestrictedStructSigactionPtr>]
         >,
         FunctionSpec<
           "sigdelset",
           RetValSpec<IntType>,
           [ArgSpec<SigSetPtrType>,
            ArgSpec<IntType>]
         >,
         FunctionSpec<
           "sigprocmask",
           RetValSpec<IntType>,
-          [ArgSpec<IntType>, ArgSpec<ConstRestrictSigSetType>, ArgSpec<RestrictSigSetType>]
+          [ArgSpec<IntType>, ArgSpec<ConstRestrictedSigSetType>, ArgSpec<RestrictedSigSetType>]
         >,
         FunctionSpec<
           "sigemptyset",
           RetValSpec<IntType>,
           [ArgSpec<SigSetPtrType>]
         >,
         FunctionSpec<
           "sigaddset",

libc/src/string/strcat.h

 //===-- Implementation header for strcat ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STRING_STRCAT_H
 #define LLVM_LIBC_SRC_STRING_STRCAT_H
 
 #include "include/string.h"
 
 namespace __llvm_libc {
 
-char *strcat(char *dest, const char *src);
+char *strcat(char *__restrict dest, const char *__restrict src);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRCAT_H

libc/src/string/strcat.cpp

 //===-- Implementation of strcat ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strcat.h"
 #include "src/string/strcpy.h"
 #include "src/string/strlen.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-char *LLVM_LIBC_ENTRYPOINT(strcat)(char *dest, const char *src) {
+char *LLVM_LIBC_ENTRYPOINT(strcat)(char *__restrict dest,
+                                   const char *__restrict src) {
   __llvm_libc::strcpy(dest + __llvm_libc::strlen(dest), src);
   return dest;
 }
 
 } // namespace __llvm_libc

libc/src/string/strcpy.h

 //===-- Implementation header for strcpy ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STRING_STRCPY_H
 #define LLVM_LIBC_SRC_STRING_STRCPY_H
 
 #include "include/string.h"
 
 namespace __llvm_libc {
 
-char *strcpy(char *dest, const char *src);
+char *strcpy(char *__restrict dest, const char *__restrict src);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRCPY_H

libc/src/string/strcpy.cpp

 //===-- Implementation of strcpy ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strcpy.h"
 #include "src/string/strlen.h"
 #include "src/string/memcpy.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-char *LLVM_LIBC_ENTRYPOINT(strcpy)(char *dest, const char *src) {
+char *LLVM_LIBC_ENTRYPOINT(strcpy)(char *__restrict dest,
+                                   const char *__restrict src) {
   return reinterpret_cast<char *>(
       __llvm_libc::memcpy(dest, src, __llvm_libc::strlen(src) + 1));
 }
 
 } // namespace __llvm_libc

libc/src/string/string_utils.h

 // using a utility function. On the first call, 'src' is scanned for the
 // first character not found in 'delimiter_string'. Once found, it scans until
 // the first character in the 'delimiter_string' or the null terminator is
 // found. We define this span as a token. The end of the token is appended with
 // a null terminator, and the token is returned. The point where the last token
 // is found is then stored within 'context' for subsequent calls. Subsequent
 // calls will use 'context' when a nullptr is passed in for 'src'. Once the null
 // terminating character is reached, returns a nullptr.
-static inline char *string_token(char *src, const char *delimiter_string,
-                                 char **saveptr) {
+static inline char *string_token(char *__restrict src,
+                                 const char *__restrict delimiter_string,
+                                 char **__restrict saveptr) {
   cpp::Bitset<256> delimiter_set;
   for (; *delimiter_string; ++delimiter_string)
     delimiter_set.set(*delimiter_string);
 
   src = src ? src : *saveptr;
   for (; *src && delimiter_set.test(*src); ++src)
     ;
   if (!*src) {

libc/src/string/strtok.h

 //===-- Implementation header for strtok ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STRING_STRTOK_H
 #define LLVM_LIBC_SRC_STRING_STRTOK_H
 
 namespace __llvm_libc {
 
-char *strtok(char *src, const char *delimiter_string);
+char *strtok(char *__restrict src, const char *__restrict delimiter_string);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRTOK_H

libc/src/string/strtok.cpp

 
 #include "src/__support/common.h"
 #include "src/string/string_utils.h"
 
 namespace __llvm_libc {
 
 static char *strtok_str = nullptr;
 
-// TODO: Place restrict qualifier where necessary for this and other function
-// arguments.
-char *LLVM_LIBC_ENTRYPOINT(strtok)(char *src, const char *delimiter_string) {
+char *LLVM_LIBC_ENTRYPOINT(strtok)(char *__restrict src,
+                                   const char *__restrict delimiter_string) {
   return internal::string_token(src, delimiter_string, &strtok_str);
 }
 
 } // namespace __llvm_libc

libc/src/string/strtok_r.h

 //===-- Implementation header for strtok_r ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STRING_STRTOK_R_H
 #define LLVM_LIBC_SRC_STRING_STRTOK_R_H
 
 namespace __llvm_libc {
 
-char *strtok_r(char *src, const char *delimiter_string, char **saveptr);
+char *strtok_r(char *__restrict src, const char *__restrict delimiter_string,
+               char **__restrict saveptr);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRTOK_R_H

libc/src/string/strtok_r.cpp

 //===-- Implementation of strtok_r ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strtok_r.h"
 
 #include "src/__support/common.h"
 #include "src/string/string_utils.h"
 
 namespace __llvm_libc {
 
-char *LLVM_LIBC_ENTRYPOINT(strtok_r)(char *src, const char *delimiter_string,
-                                     char **saveptr) {
+char *LLVM_LIBC_ENTRYPOINT(strtok_r)(char *__restrict src,
+                                     const char *__restrict delimiter_string,
+                                     char **__restrict saveptr) {
   return internal::string_token(src, delimiter_string, saveptr);
 }
 
 } // namespace __llvm_libc