[libc] Add a definition of pthread_attr_t and its getters and setters.

[sivachandra]

Summary

Not all attributes have been added to phtread_attr_t in this patch. They
will be added gradually in future patches.

[michaelrj]

libc/src/pthread/pthread_attr_destroy.cpp

19

since this function doesn't appear to have an implementation yet, does it need to be in this patch?

[sivachandra]

Add a comment in the destroy function clarifying that there is nothing to cleanup.

[sivachandra]

libc/src/pthread/pthread_attr_destroy.cpp

19

That is the implementation. I have added a comment to make it clear.

libc/config/linux/aarch64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.threads.mtx_destroy
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
 
     # pthread.h entrypoints
+    libc.src.pthread.pthread_attr_destroy
+    libc.src.pthread.pthread_attr_init
+    libc.src.pthread.pthread_attr_getdetachstate
+    libc.src.pthread.pthread_attr_getguardsize
+    libc.src.pthread.pthread_attr_getstack
+    libc.src.pthread.pthread_attr_getstacksize
+    libc.src.pthread.pthread_attr_setdetachstate
+    libc.src.pthread.pthread_attr_setguardsize
+    libc.src.pthread.pthread_attr_setstack
+    libc.src.pthread.pthread_attr_setstacksize
     libc.src.pthread.pthread_mutexattr_destroy
     libc.src.pthread.pthread_mutexattr_init
     libc.src.pthread.pthread_mutexattr_getpshared
     libc.src.pthread.pthread_mutexattr_getrobust
     libc.src.pthread.pthread_mutexattr_gettype
     libc.src.pthread.pthread_mutexattr_setpshared
     libc.src.pthread.pthread_mutexattr_setrobust
     libc.src.pthread.pthread_mutexattr_settype
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/config/linux/api.td

let Enumerations = [
     "thrd_success",
     "thrd_busy",
     "thrd_error",
     "thrd_nomem",
   ];
 }
 
 def PThreadAPI : PublicAPI<"pthread.h"> {
-  let Types = ["pthread_mutexattr_t"];
+  let Types = [
+      "pthread_attr_t",
+      "pthread_mutexattr_t"
+  ];
 }
 
 def UniStdAPI : PublicAPI<"unistd.h"> {
   let Types = ["off_t", "size_t", "ssize_t"];
 }
 
 def SysStatAPI : PublicAPI<"sys/stat.h"> {
   let Types = ["mode_t"];
 }

libc/config/linux/x86_64/entrypoints.txt

 )
 
 if(LLVM_LIBC_FULL_BUILD)
   list(APPEND TARGET_LIBC_ENTRYPOINTS
     # assert.h entrypoints
     # libc.src.assert.__assert_fail
 
     # pthread.h entrypoints
+    libc.src.pthread.pthread_attr_destroy
+    libc.src.pthread.pthread_attr_init
+    libc.src.pthread.pthread_attr_getdetachstate
+    libc.src.pthread.pthread_attr_getguardsize
+    libc.src.pthread.pthread_attr_getstack
+    libc.src.pthread.pthread_attr_getstacksize
+    libc.src.pthread.pthread_attr_setdetachstate
+    libc.src.pthread.pthread_attr_setguardsize
+    libc.src.pthread.pthread_attr_setstack
+    libc.src.pthread.pthread_attr_setstacksize
+    libc.src.pthread.pthread_attr_init
     libc.src.pthread.pthread_mutexattr_destroy
     libc.src.pthread.pthread_mutexattr_init
     libc.src.pthread.pthread_mutexattr_getpshared
     libc.src.pthread.pthread_mutexattr_getrobust
     libc.src.pthread.pthread_mutexattr_gettype
     libc.src.pthread.pthread_mutexattr_setpshared
     libc.src.pthread.pthread_mutexattr_setrobust
     libc.src.pthread.pthread_mutexattr_settype

libc/include/CMakeLists.txt

 )
 
 add_gen_header(
   pthread
   DEF_FILE pthread.h.def
   GEN_HDR pthread.h
   DEPENDS
     .llvm_libc_common_h
+    .llvm-libc-types.pthread_attr_t
     .llvm-libc-types.pthread_mutexattr_t
 )
 
 # TODO: Not all platforms will have a include/sys directory. Add the sys
 # directory and the targets for sys/*.h files conditional to the OS requiring
 # them.
 file(MAKE_DIRECTORY "sys")
 

libc/include/llvm-libc-types/CMakeLists.txt

 add_header(fenv_t HDR fenv_t.h)
 add_header(fexcept_t HDR fexcept_t.h)
 add_header(float_t HDR float_t.h)
 add_header(imaxdiv_t HDR imaxdiv_t.h)
 add_header(mode_t HDR mode_t.h)
 add_header(mtx_t HDR mtx_t.h DEPENDS .__futex_word .__mutex_type)
 add_header(off_t HDR off_t.h)
 add_header(once_flag HDR once_flag.h DEPENDS .__futex_word)
+add_header(pthread_attr_t HDR pthread_attr_t.h)
 add_header(pthread_mutexattr_t HDR pthread_mutexattr_t.h)
 add_header(size_t HDR size_t.h)
 add_header(ssize_t HDR ssize_t.h)
 add_header(struct_sigaction HDR struct_sigaction.h)
 add_header(struct_tm HDR struct_tm.h)
 add_header(thrd_start_t HDR thrd_start_t.h)
 add_header(thrd_t HDR thrd_t.h)
 add_header(time_t HDR time_t.h)
 add_header(__atexithandler_t HDR __atexithandler_t.h)

libc/include/llvm-libc-types/pthread_attr_t.h

+//===-- Definition of pthread_attr_t type ---------------------------------===//
+//
+// 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_TYPES_PTHREAD_ATTR_T_H
+#define __LLVM_LIBC_TYPES_PTHREAD_ATTR_T_H
+
+#include <llvm-libc-types/size_t.h>
+
+typedef struct {
+  int __detachstate;
+  void *__stack;
+  size_t __stacksize;
+  size_t __guardsize;
+} pthread_attr_t;
+
+#endif // __LLVM_LIBC_TYPES_PTHREAD_ATTR_T_H

libc/include/pthread.h.def

 //===-- POSIX header pthread.h --------------------------------------------===//
 //
 // 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_PTHREAD_H
 #define LLVM_LIBC_PTHREAD_H
 
 #include <__llvm-libc-common.h>
 
+#define PTHREAD_STACK_MIN (1 << 14) // 16KB
+
 enum {
+  PTHREAD_CREATE_JOINABLE = 0x0,
+  PTHREAD_CREATE_DETACHED = 0x1,
+
   PTHREAD_MUTEX_NORMAL = 0x0,
   PTHREAD_MUTEX_ERRORCHECK = 0x1,
   PTHREAD_MUTEX_RECURSIVE = 0x2,
   PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL,
 
   PTHREAD_PROCESS_PRIVATE = 0x0,
   PTHREAD_PROCESS_SHARED = 0x1,
 
   PTHREAD_MUTEX_STALLED = 0x0,
   PTHREAD_MUTEX_ROBUST = 0x1,
 };
 
 %%public_api()
 
 #endif // LLVM_LIBC_PTHREAD_H

libc/spec/posix.td

def POSIX : StandardSpec<"POSIX"> {
   RestrictedPtrType RestrictedCharPtr = RestrictedPtrType<CharType>;
   RestrictedPtrType CharRestrictedDoublePtr = RestrictedPtrType<CharPtr>;
   ConstType ConstCharPtr = ConstType<CharPtr>;
   ConstType ConstRestrictedCharPtr = ConstType<RestrictedCharPtr>;
 
   NamedType ModeTType = NamedType<"mode_t">;
   NamedType OffTType = NamedType<"off_t">;
   NamedType SSizeTType = NamedType<"ssize_t">;
+
+  NamedType PThreadAttrTType = NamedType<"pthread_attr_t">;
+  PtrType PThreadAttrTPtr = PtrType<PThreadAttrTType>;
+  RestrictedPtrType RestrictedPThreadAttrTPtr = RestrictedPtrType<PThreadAttrTType>;
+  ConstType ConstPThreadAttrTPtr = ConstType<PThreadAttrTPtr>;
+  ConstType ConstRestrictedPThreadAttrTPtr = ConstType<RestrictedPThreadAttrTPtr>;
+
   NamedType PThreadMutexAttrTType = NamedType<"pthread_mutexattr_t">;
   PtrType PThreadMutexAttrTPtr = PtrType<PThreadMutexAttrTType>;
   RestrictedPtrType RestrictedPThreadMutexAttrTPtr = RestrictedPtrType<PThreadMutexAttrTType>;
   ConstType ConstPThreadMutexAttrTPtr = ConstType<PThreadMutexAttrTPtr>;
   ConstType ConstRestrictedPThreadMutexAttrTPtr = ConstType<RestrictedPThreadMutexAttrTPtr>;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
[
             [ArgSpec<IntType>, ArgSpec<ConstCharPtr>, ArgSpec<ModeTType>]
         >,
     ]
   >;
 
   HeaderSpec PThread = HeaderSpec<
     "pthread.h",
     [], // Macros
-    [PThreadMutexAttrTType], // Types
+    [PThreadAttrTType, PThreadMutexAttrTType], // Types
     [], // Enumerations
     [
       FunctionSpec<
+          "pthread_attr_init",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadAttrTPtr>]
+      >,
+      FunctionSpec<
+          "pthread_attr_destroy",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadAttrTPtr>]
+      >,
+      FunctionSpec<
+          "pthread_attr_getdetachstate",
+          RetValSpec<IntType>,
+          [ArgSpec<ConstPThreadAttrTPtr>, ArgSpec<IntPtr>]
+      >,
+      FunctionSpec<
+          "pthread_attr_setdetachstate",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadAttrTPtr>, ArgSpec<IntType>]
+      >,
+      FunctionSpec<
+          "pthread_attr_getguardsize",
+          RetValSpec<IntType>,
+          [ArgSpec<ConstRestrictedPThreadAttrTPtr>, ArgSpec<RestrictedSizeTPtr>]
+      >,
+      FunctionSpec<
+          "pthread_attr_setguardsize",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadAttrTPtr>, ArgSpec<SizeTType>]
+      >,
+      FunctionSpec<
+          "pthread_attr_getstacksize",
+          RetValSpec<IntType>,
+          [ArgSpec<ConstRestrictedPThreadAttrTPtr>, ArgSpec<RestrictedSizeTPtr>]
+      >,
+      FunctionSpec<
+          "pthread_attr_setstacksize",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadAttrTPtr>, ArgSpec<SizeTType>]
+      >,
+      FunctionSpec<
+          "pthread_attr_getstack",
+          RetValSpec<IntType>,
+          [ArgSpec<ConstRestrictedPThreadAttrTPtr>, ArgSpec<RestrictedVoidPtrPtr>, ArgSpec<RestrictedSizeTPtr>]
+      >,
+      FunctionSpec<
+          "pthread_attr_setstack",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadAttrTPtr>, ArgSpec<VoidPtr>, ArgSpec<SizeTType>]
+      >,
+      FunctionSpec<
           "pthread_mutexattr_init",
           RetValSpec<IntType>,
           [ArgSpec<PThreadMutexAttrTPtr>]
       >,
       FunctionSpec<
           "pthread_mutexattr_destroy",
           RetValSpec<IntType>,
           [ArgSpec<PThreadMutexAttrTPtr>]

libc/spec/spec.td

 def UnsignedLongLongType : NamedType<"unsigned long long">;
 def FloatType : NamedType<"float">;
 def DoubleType : NamedType<"double">;
 def LongDoubleType : NamedType<"long double">;
 def CharType : NamedType<"char">;
 
 // Common types
 def VoidPtr : PtrType<VoidType>;
+def VoidPtrPtr : PtrType<VoidPtr>;
+def RestrictedVoidPtrPtr : RestrictedPtrType<VoidPtr>;
 def ConstVoidPtr : ConstType<VoidPtr>;
+
 def SizeTType : NamedType<"size_t">;
+def SizeTPtr : PtrType<SizeTType>;
+def RestrictedSizeTPtr : RestrictedPtrType<SizeTType>;
+
 def LongDoublePtr : PtrType<LongDoubleType>;
 
 def IntMaxTType : NamedType<"intmax_t">;
 def UIntMaxTType : NamedType<"uintmax_t">;
 
 // _Noreturn is really not a type, but it is convenient to treat it as a type.
 def NoReturn : NamedType<"_Noreturn void">;
 

libc/src/pthread/CMakeLists.txt

+add_entrypoint_object(
+  pthread_attr_init
+  SRCS
+    pthread_attr_init.cpp
+  HDRS
+    pthread_attr_init.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_destroy
+  SRCS
+    pthread_attr_destroy.cpp
+  HDRS
+    pthread_attr_destroy.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_getdetachstate
+  SRCS
+    pthread_attr_getdetachstate.cpp
+  HDRS
+    pthread_attr_getdetachstate.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_setdetachstate
+  SRCS
+    pthread_attr_setdetachstate.cpp
+  HDRS
+    pthread_attr_setdetachstate.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_getguardsize
+  SRCS
+    pthread_attr_getguardsize.cpp
+  HDRS
+    pthread_attr_getguardsize.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_setguardsize
+  SRCS
+    pthread_attr_setguardsize.cpp
+  HDRS
+    pthread_attr_setguardsize.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_getstacksize
+  SRCS
+    pthread_attr_getstacksize.cpp
+  HDRS
+    pthread_attr_getstacksize.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_setstacksize
+  SRCS
+    pthread_attr_setstacksize.cpp
+  HDRS
+    pthread_attr_setstacksize.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_getstack
+  SRCS
+    pthread_attr_getstack.cpp
+  HDRS
+    pthread_attr_getstack.h
+  DEPENDS
+    libc.include.pthread
+)
+
+add_entrypoint_object(
+  pthread_attr_setstack
+  SRCS
+    pthread_attr_setstack.cpp
+  HDRS
+    pthread_attr_setstack.h
+  DEPENDS
+    libc.include.pthread
+)
+
 add_header_library(
   pthread_mutexattr
   HDRS
     pthread_mutexattr.h
   DEPENDS
     libc.include.pthread
 )
 

libc/src/pthread/pthread_attr_destroy.h

+//===-- Implementation header for pthread_attr_destroy ----------*- 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_PTHREAD_PTHREAD_ATTR_DESTROY_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_DESTROY_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_destroy(pthread_attr_t *attr);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_DESTROY_H

libc/src/pthread/pthread_attr_destroy.cpp

+//===-- Implementation of the pthread_attr_destroy ------------------------===//
+//
+// 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 "pthread_attr_destroy.h"
+
+#include "src/__support/common.h"
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_destroy, (pthread_attr_t * attr)) {
+  // There is nothing to cleanup.
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_getdetachstate.h

+//===-- Implementation header for pthread_attr_getdetachstate ---*- 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_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detach_state);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H

libc/src/pthread/pthread_attr_getdetachstate.cpp

+//===-- Implementation of the pthread_attr_getdetachstate -----------------===//
+//
+// 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 "pthread_attr_getdetachstate.h"
+
+#include "src/__support/common.h"
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_getdetachstate,
+                   (const pthread_attr_t *attr, int *detachstate)) {
+  *detachstate = attr->__detachstate;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_getguardsize.h

+//===-- Implementation header for pthread_attr_getguardsize -----*- 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_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_getguardsize(const pthread_attr_t *__restrict attr,
+                              size_t *__restrict guardsize);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H

libc/src/pthread/pthread_attr_getguardsize.cpp

+//===-- Implementation of the pthread_attr_getguardsize -----------------===//
+//
+// 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 "pthread_attr_getguardsize.h"
+
+#include "src/__support/common.h"
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_getguardsize,
+                   (const pthread_attr_t *__restrict attr,
+                    size_t *__restrict guardsize)) {
+  *guardsize = attr->__guardsize;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_getstack.h

+//===-- Implementation header for pthread_attr_getstack ---------*- 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_PTHREAD_PTHREAD_ATTR_GETSTACK_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACK_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_getstack(const pthread_attr_t *__restrict attr,
+                          void **__restrict stack,
+                          size_t *__restrict stacksize);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACK_H

libc/src/pthread/pthread_attr_getstack.cpp

+//===-- Implementation of the pthread_attr_getstack -----------------===//
+//
+// 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 "pthread_attr_getstack.h"
+
+#include "src/__support/common.h"
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_getstack,
+                   (const pthread_attr_t *__restrict attr,
+                    void **__restrict stack, size_t *__restrict stacksize)) {
+  *stack = attr->__stack;
+  *stacksize = attr->__stacksize;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_getstacksize.h

+//===-- Implementation header for pthread_attr_getstacksize -----*- 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_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_getstacksize(const pthread_attr_t *__restrict attr,
+                              size_t *__restrict stacksize);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H

libc/src/pthread/pthread_attr_getstacksize.cpp

+//===-- Implementation of the pthread_attr_getstacksize -----------------===//
+//
+// 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 "pthread_attr_getstacksize.h"
+
+#include "src/__support/common.h"
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_getstacksize,
+                   (const pthread_attr_t *__restrict attr,
+                    size_t *__restrict stacksize)) {
+  *stacksize = attr->__stacksize;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_init.h

+//===-- Implementation header for pthread_attr_init -------------*- 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_PTHREAD_PTHREAD_ATTR_INIT_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_INIT_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_init(pthread_attr_t *attr);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_INIT_H

libc/src/pthread/pthread_attr_init.cpp

+//===-- Implementation of the pthread_attr_init ---------------------------===//
+//
+// 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 "pthread_attr_init.h"
+
+#include "src/__support/common.h"
+
+#include <linux/param.h> // For EXEC_PAGESIZE.
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_init, (pthread_attr_t * attr)) {
+  *attr = pthread_attr_t{
+      false,         // Not detached
+      nullptr,       // Let the thread manage its stack
+      1 << 16,       // 64KB stack size
+      EXEC_PAGESIZE, // Default page size for the guard size.
+  };
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_setdetachstate.h

+//===-- Implementation header for pthread_attr_setdetachstate ---*- 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_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_setdetachstate(pthread_attr_t *attr, int detach_state);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H

libc/src/pthread/pthread_attr_setdetachstate.cpp

+//===-- Implementation of the pthread_attr_setdetachstate -----------------===//
+//
+// 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 "pthread_attr_setdetachstate.h"
+
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_setdetachstate,
+                   (pthread_attr_t * attr, int detachstate)) {
+  if (detachstate != PTHREAD_CREATE_DETACHED &&
+      detachstate != PTHREAD_CREATE_JOINABLE)
+    return EINVAL;
+  attr->__detachstate = detachstate;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_setguardsize.h

+//===-- Implementation header for pthread_attr_setguardsize -----*- 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_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H

libc/src/pthread/pthread_attr_setguardsize.cpp

+//===-- Implementation of the pthread_attr_setguardsize -----------------===//
+//
+// 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 "pthread_attr_setguardsize.h"
+
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <linux/param.h> // For EXEC_PAGESIZE.
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_setguardsize,
+                   (pthread_attr_t *__restrict attr, size_t guardsize)) {
+  if (guardsize % EXEC_PAGESIZE != 0)
+    return EINVAL;
+  attr->__guardsize = guardsize;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_setstack.h

+//===-- Implementation header for pthread_attr_setstack ---------*- 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_PTHREAD_PTHREAD_ATTR_SETSTACK_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACK_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_setstack(pthread_attr_t *attr, void *stack, size_t stacksize);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACK_H

libc/src/pthread/pthread_attr_setstack.cpp

+//===-- Implementation of the pthread_attr_setstack -----------------===//
+//
+// 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 "pthread_attr_setstack.h"
+
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <linux/param.h> // For EXEC_PAGESIZE.
+#include <pthread.h>
+#include <stdint.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_setstack,
+                   (pthread_attr_t *__restrict attr, void *stack,
+                    size_t stacksize)) {
+  if (stacksize < PTHREAD_STACK_MIN)
+    return EINVAL;
+  uintptr_t stackaddr = reinterpret_cast<uintptr_t>(stack);
+  if ((stackaddr % 16 != 0) || ((stackaddr + stacksize) % 16 != 0))
+    return EINVAL;
+  attr->__stack = stack;
+  attr->__stacksize = stacksize;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_attr_setstacksize.h

+//===-- Implementation header for pthread_attr_setstacksize -----*- 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_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H

libc/src/pthread/pthread_attr_setstacksize.cpp

+//===-- Implementation of the pthread_attr_setstacksize -----------------===//
+//
+// 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 "pthread_attr_setstacksize.h"
+
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <linux/param.h> // For EXEC_PAGESIZE.
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_attr_setstacksize,
+                   (pthread_attr_t *__restrict attr, size_t stacksize)) {
+  if (stacksize < PTHREAD_STACK_MIN)
+    return EINVAL;
+  attr->__stack = nullptr;
+  attr->__stacksize = stacksize;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/test/src/pthread/CMakeLists.txt

 add_libc_testsuite(libc_pthread_unittests)
 
 add_libc_unittest(
+  pthread_attr_test
+  SUITE
+    libc_pthread_unittests
+  SRCS
+    pthread_attr_test.cpp
+  DEPENDS
+    libc.include.errno
+    libc.include.pthread
+    libc.src.pthread.pthread_attr_destroy
+    libc.src.pthread.pthread_attr_init
+    libc.src.pthread.pthread_attr_getdetachstate
+    libc.src.pthread.pthread_attr_getguardsize
+    libc.src.pthread.pthread_attr_getstacksize
+    libc.src.pthread.pthread_attr_getstack
+    libc.src.pthread.pthread_attr_setdetachstate
+    libc.src.pthread.pthread_attr_setguardsize
+    libc.src.pthread.pthread_attr_setstacksize
+    libc.src.pthread.pthread_attr_setstack
+)
+
+add_libc_unittest(
   pthread_mutexattr_test
   SUITE
     libc_pthread_unittests
   SRCS
     pthread_mutexattr_test.cpp
   DEPENDS
     libc.include.errno
     libc.include.pthread

libc/test/src/pthread/pthread_attr_test.cpp

+//===-- Unittests for pthread_attr_t --------------------------------------===//
+//
+// 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/pthread/pthread_attr_destroy.h"
+#include "src/pthread/pthread_attr_getdetachstate.h"
+#include "src/pthread/pthread_attr_getguardsize.h"
+#include "src/pthread/pthread_attr_getstack.h"
+#include "src/pthread/pthread_attr_getstacksize.h"
+#include "src/pthread/pthread_attr_init.h"
+#include "src/pthread/pthread_attr_setdetachstate.h"
+#include "src/pthread/pthread_attr_setguardsize.h"
+#include "src/pthread/pthread_attr_setstack.h"
+#include "src/pthread/pthread_attr_setstacksize.h"
+
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <linux/param.h> // For EXEC_PAGESIZE.
+#include <pthread.h>
+
+TEST(LlvmLibcPThreadAttrTest, InitAndDestroy) {
+  pthread_attr_t attr;
+  ASSERT_EQ(__llvm_libc::pthread_attr_init(&attr), 0);
+
+  int detachstate;
+  ASSERT_EQ(__llvm_libc::pthread_attr_getdetachstate(&attr, &detachstate), 0);
+  ASSERT_EQ(detachstate, int(PTHREAD_CREATE_JOINABLE));
+
+  size_t guardsize;
+  ASSERT_EQ(__llvm_libc::pthread_attr_getguardsize(&attr, &guardsize), 0);
+  ASSERT_EQ(guardsize, size_t(EXEC_PAGESIZE));
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_destroy(&attr), 0);
+}
+
+TEST(LlvmLibcPThreadattrTest, SetAndGetDetachState) {
+  pthread_attr_t attr;
+  ASSERT_EQ(__llvm_libc::pthread_attr_init(&attr), 0);
+
+  int detachstate;
+  __llvm_libc::pthread_attr_getdetachstate(&attr, &detachstate);
+  ASSERT_EQ(detachstate, int(PTHREAD_CREATE_JOINABLE));
+  ASSERT_EQ(
+      __llvm_libc::pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED),
+      0);
+  ASSERT_EQ(__llvm_libc::pthread_attr_getdetachstate(&attr, &detachstate), 0);
+  ASSERT_EQ(detachstate, int(PTHREAD_CREATE_DETACHED));
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_setdetachstate(&attr, 0xBAD), EINVAL);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_destroy(&attr), 0);
+}
+
+TEST(LlvmLibcPThreadattrTest, SetAndGetGuardSize) {
+  pthread_attr_t attr;
+  ASSERT_EQ(__llvm_libc::pthread_attr_init(&attr), 0);
+
+  size_t guardsize;
+  ASSERT_EQ(__llvm_libc::pthread_attr_getguardsize(&attr, &guardsize), 0);
+  ASSERT_EQ(guardsize, size_t(EXEC_PAGESIZE));
+  ASSERT_EQ(__llvm_libc::pthread_attr_setguardsize(&attr, 2 * EXEC_PAGESIZE),
+            0);
+  ASSERT_EQ(__llvm_libc::pthread_attr_getguardsize(&attr, &guardsize), 0);
+  ASSERT_EQ(guardsize, size_t(2 * EXEC_PAGESIZE));
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_setguardsize(&attr, EXEC_PAGESIZE / 2),
+            EINVAL);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_destroy(&attr), 0);
+}
+
+TEST(LlvmLibcPThreadattrTest, SetAndGetStackSize) {
+  pthread_attr_t attr;
+  ASSERT_EQ(__llvm_libc::pthread_attr_init(&attr), 0);
+
+  size_t stacksize;
+  ASSERT_EQ(
+      __llvm_libc::pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN << 2), 0);
+  ASSERT_EQ(__llvm_libc::pthread_attr_getstacksize(&attr, &stacksize), 0);
+  ASSERT_EQ(stacksize, size_t(PTHREAD_STACK_MIN << 2));
+
+  ASSERT_EQ(
+      __llvm_libc::pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN / 2),
+      EINVAL);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_destroy(&attr), 0);
+}
+
+TEST(LlvmLibcPThreadattrTest, SetAndGetStack) {
+  pthread_attr_t attr;
+  ASSERT_EQ(__llvm_libc::pthread_attr_init(&attr), 0);
+
+  void *stack;
+  size_t stacksize;
+  ASSERT_EQ(
+      __llvm_libc::pthread_attr_setstack(&attr, 0, PTHREAD_STACK_MIN << 2), 0);
+  ASSERT_EQ(__llvm_libc::pthread_attr_getstack(&attr, &stack, &stacksize), 0);
+  ASSERT_EQ(stacksize, size_t(PTHREAD_STACK_MIN << 2));
+  ASSERT_EQ(reinterpret_cast<uintptr_t>(stack), uintptr_t(0));
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_setstack(
+                &attr, reinterpret_cast<void *>(1), PTHREAD_STACK_MIN << 2),
+            EINVAL);
+  ASSERT_EQ(__llvm_libc::pthread_attr_setstack(&attr, 0, PTHREAD_STACK_MIN / 2),
+            EINVAL);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_destroy(&attr), 0);
+}