[libc] Add a skeleton for C standard condition variable functions.

[sivachandra]

Summary

This patch adds a skeleton as a preparatory step for the next patch which
adds the actual implementations of the condition variable functions.

[michaelrj]

LGTM

libc/config/linux/api.td

def MtxT : TypeDecl<"mtx_t"> {
   let Decl = [{
     typedef struct {
       unsigned char __internal_data[4];
       int __mtx_type;
     } mtx_t;
   }];
 }
 
+def CndT : TypeDecl<"cnd_t"> {
+  let Decl = [{
+    typedef struct {
+      void *__qfront;
+      void *__qback;
+      struct {
+        unsigned char __w[4];
+        int __t;
+      } __qmtx;
+    } cnd_t;
+  }];
+}
+
 def ThreadStartT : TypeDecl<"thrd_start_t"> {
   let Decl = "typedef int (*thrd_start_t)(void *);";
 }
 
 def CallOnceFuncT : TypeDecl<"__call_once_func_t"> {
   let Decl = [{
     typedef void(*__call_once_func_t)(void);
   }];
 }
 
 def ThreadsAPI : PublicAPI<"threads.h"> {
   let Macros = [
     SimpleMacroDef<"ONCE_FLAG_INIT", "0">,
   ];
 
   let TypeDeclarations = [
     OnceFlag,
     CallOnceFuncT,
     MtxT,
+    CndT,
     ThreadStartT,
   ];
 
   let Enumerations = [
     "mtx_plain",
     "mtx_recursive",
     "mtx_timed",
     "thrd_timedout",

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.signal.signal
 
     # sys/mman.h entrypoints
     libc.src.sys.mman.mmap
     libc.src.sys.mman.munmap
 
     # threads.h entrypoints
     libc.src.threads.call_once
+    libc.src.threads.cnd_broadcast
+    libc.src.threads.cnd_destroy
+    libc.src.threads.cnd_init
+    libc.src.threads.cnd_signal
+    libc.src.threads.cnd_wait
     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
 
     # time.h entrypoints

libc/spec/spec.td

 
 def OnceFlagType : NamedType<"once_flag">;
 def OnceFlagTypePtr : PtrType<OnceFlagType>;
 // TODO(sivachandra): Remove this non-standard type when a formal
 // way to describe callable types is available.
 def CallOnceFuncType : NamedType<"__call_once_func_t">;
 def MtxTType : NamedType<"mtx_t">;
 def MtxTTypePtr : PtrType<MtxTType>;
+def CndTType : NamedType<"cnd_t">;
+def CndTTypePtr : PtrType<CndTType>;
 def ThrdStartTType : NamedType<"thrd_start_t">;
 def ThrdTType : NamedType<"thrd_t">;
 def ThrdTTypePtr : PtrType<ThrdTType>;
 
 def IntPtr : PtrType<IntType>;
 def FloatPtr : PtrType<FloatType>;
 def DoublePtr : PtrType<DoubleType>;
 

libc/spec/stdc.td

def StdC : StandardSpec<"stdc"> {
   HeaderSpec Threads = HeaderSpec<
       "threads.h",
       [
           Macro<"ONCE_FLAG_INIT">,
       ],
       [
           OnceFlagType,
           CallOnceFuncType,
+          CndTType,
           MtxTType,
           ThrdStartTType,
           ThrdTType,
       ],
       [
           EnumeratedNameValue<"mtx_plain">,
           EnumeratedNameValue<"mtx_recursive">,
           EnumeratedNameValue<"mtx_timed">,
           EnumeratedNameValue<"thrd_timedout">,
           EnumeratedNameValue<"thrd_success">,
           EnumeratedNameValue<"thrd_busy">,
           EnumeratedNameValue<"thrd_error">,
           EnumeratedNameValue<"thrd_nomem">,
       ],
       [
           FunctionSpec<
               "call_once",
               RetValSpec<VoidType>,
               [
                   ArgSpec<OnceFlagTypePtr>,
                   ArgSpec<CallOnceFuncType>,
               ]
           >,
           FunctionSpec<
+              "cnd_broadcast",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<CndTTypePtr>,
+              ]
+          >,
+          FunctionSpec<
+              "cnd_destroy",
+              RetValSpec<VoidType>,
+              [
+                  ArgSpec<CndTTypePtr>,
+              ]
+          >,
+          FunctionSpec<
+              "cnd_init",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<CndTTypePtr>,
+              ]
+          >,
+          FunctionSpec<
+              "cnd_signal",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<CndTTypePtr>,
+              ]
+          >,
+          FunctionSpec<
+              "cnd_wait",
+              RetValSpec<IntType>,
+              [
+                  ArgSpec<CndTTypePtr>,
+                  ArgSpec<MtxTTypePtr>,
+              ]
+          >,
+          FunctionSpec<
               "mtx_init",
               RetValSpec<IntType>,
               [
                   ArgSpec<MtxTTypePtr>,
                   ArgSpec<IntType>,
               ]
           >,
           FunctionSpec<

libc/src/threads/CMakeLists.txt

 )
 
 add_entrypoint_object(
   mtx_unlock
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.mtx_unlock
 )
+
+add_entrypoint_object(
+  cnd_init
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.cnd_init
+)
+
+add_entrypoint_object(
+  cnd_destroy
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.cnd_destroy
+)
+
+add_entrypoint_object(
+  cnd_wait
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.cnd_wait
+)
+
+add_entrypoint_object(
+  cnd_signal
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.cnd_signal
+)
+
+add_entrypoint_object(
+  cnd_broadcast
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.cnd_broadcast
+)

libc/src/threads/cnd_broadcast.h

+//===-- Implementation header for cnd_broadcast function --------*- 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_THREADS_CND_BROADCAST_H
+#define LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H
+
+#include "include/threads.h"
+
+namespace __llvm_libc {
+
+int cnd_broadcast(cnd_t *cond);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H

libc/src/threads/cnd_destroy.h

+//===-- Implementation header for cnd_destroy function ----------*- 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_THREADS_CND_DESTROY_H
+#define LLVM_LIBC_SRC_THREADS_CND_DESTROY_H
+
+#include "include/threads.h"
+
+namespace __llvm_libc {
+
+int cnd_destroy(cnd_t *cond);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_CND_DESTROY_H

libc/src/threads/cnd_init.h

+//===-- Implementation header for cnd_init function -------------*- 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_THREADS_CND_INIT_H
+#define LLVM_LIBC_SRC_THREADS_CND_INIT_H
+
+#include "include/threads.h"
+
+namespace __llvm_libc {
+
+int cnd_init(cnd_t *cond);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_CND_INIT_H

libc/src/threads/cnd_signal.h

+//===-- Implementation header for cnd_signal function -----------*- 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_THREADS_CND_SIGNAL_H
+#define LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H
+
+#include "include/threads.h"
+
+namespace __llvm_libc {
+
+int cnd_signal(cnd_t *cond);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H

libc/src/threads/cnd_wait.h

+//===-- Implementation header for cnd_wait function -------------*- 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_THREADS_CND_WAIT_H
+#define LLVM_LIBC_SRC_THREADS_CND_WAIT_H
+
+#include "include/threads.h"
+
+namespace __llvm_libc {
+
+int cnd_wait(cnd_t *cond, mtx_t *mutex);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_CND_WAIT_H

libc/src/threads/linux/CMakeLists.txt

add_entrypoint_object(
   SRCS
     mtx_unlock.cpp
   HDRS
     ../mtx_unlock.h
   DEPENDS
     .threads_utils
     libc.include.threads
 )
+
+add_entrypoint_object(
+  cnd_init
+  SRCS
+    cnd_init.cpp
+  HDRS
+    ../cnd_init.h
+  DEPENDS
+    .threads_utils
+    libc.include.threads
+)
+
+add_entrypoint_object(
+  cnd_destroy
+  SRCS
+    cnd_destroy.cpp
+  HDRS
+    ../cnd_destroy.h
+  DEPENDS
+    .threads_utils
+    libc.include.threads
+)
+
+add_entrypoint_object(
+  cnd_wait
+  SRCS
+    cnd_wait.cpp
+  HDRS
+    ../cnd_wait.h
+  DEPENDS
+    .threads_utils
+    libc.include.threads
+)
+
+add_entrypoint_object(
+  cnd_signal
+  SRCS
+    cnd_signal.cpp
+  HDRS
+    ../cnd_signal.h
+  DEPENDS
+    .threads_utils
+    libc.include.threads
+)
+
+add_entrypoint_object(
+  cnd_broadcast
+  SRCS
+    cnd_broadcast.cpp
+  HDRS
+    ../cnd_broadcast.h
+  DEPENDS
+    .threads_utils
+    libc.include.threads
+)

libc/src/threads/linux/cnd_broadcast.cpp

+//===-- Linux implementation of the cnd_broadcast function ----------------===//
+//
+// 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/threads/cnd_broadcast.h"
+#include "src/__support/common.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, cnd_broadcast, (cnd_t * cond)) { return thrd_success; }
+
+} // namespace __llvm_libc

libc/src/threads/linux/cnd_destroy.cpp

+//===-- Linux implementation of the cnd_destroy function ------------------===//
+//
+// 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/threads/cnd_destroy.h"
+#include "src/__support/common.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, cnd_destroy, (cnd_t * cond)) { return thrd_success; }
+
+} // namespace __llvm_libc

libc/src/threads/linux/cnd_init.cpp

+//===-- Linux implementation of the cnd_init function ---------------------===//
+//
+// 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/threads/cnd_init.h"
+#include "src/__support/common.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, cnd_init, (cnd_t * cond)) { return thrd_success; }
+
+} // namespace __llvm_libc

libc/src/threads/linux/cnd_signal.cpp

+//===-- Linux implementation of the cnd_signal function -------------------===//
+//
+// 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/threads/cnd_signal.h"
+#include "src/__support/common.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, cnd_signal, (cnd_t * cond)) { return thrd_success; }
+
+} // namespace __llvm_libc

libc/src/threads/linux/cnd_wait.cpp

+//===-- Linux implementation of the cnd_wait function ---------------------===//
+//
+// 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/threads/cnd_wait.h"
+#include "src/__support/common.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, cnd_wait, (cnd_t * cond, mtx_t *mutex)) {
+  return thrd_success;
+}
+
+} // namespace __llvm_libc