[libc] Add signal

[abrachet]

Summary

This patch adds a Linux implementation for signal
It also fixes ASSERT|EXPECT_THAT macros

[sivachandra]

OK with one naming fix suggested inline.

libc/spec/stdc.td

19

Neither POSIX nor std C prescribe it. Is it present merely as a convenience or because there is no way to describe function types using tablegen? Either way, I think this is OK. But to avoid name pollution, we should name this type with __ prefix.

libc/src/signal/linux/signal.cpp

22

Add a note that sigaction sets the errno value on error?

[abrachet]

Rename sighandler_t to __sighandler_t. Internally called __llvm_libc::sighandler_t (we could put it in global scope in internal headers or not use it all)

[abrachet]

libc/spec/stdc.td

19

Will you take another look to make sure its ok? Specifically that I put the using sighandler_t = __sighandler_t in src/signal/signal.h inside __llvm_libc.

[sivachandra]

libc/spec/stdc.td

19

LGTM

libc/config/linux/api.td

struct __sigaction {
       };
       sigset_t sa_mask;
       int sa_flags;
       void (*sa_restorer)(void);
     };
   }];
 }
 
+def SighandlerTDefn : TypeDecl<"__sighandler_t"> {
+  let Decl = [{
+    typedef void(*__sighandler_t)(int);
+  }];
+}
+
 def SignalAPI : PublicAPI<"signal.h"> {
   let TypeDeclarations = [
     StructSigactionDefn,
+    SighandlerTDefn,
   ];
 
   let Functions = [
     "raise",
     "sigaction",
     "sigprocmask",
     "sigemptyset",
     "sigaddset",
+    "signal",
   ];
 }
 
 def MtxT : TypeDecl<"mtx_t"> {
   let Decl = [{
     typedef struct {
       unsigned char __internal_data[4];
       int __mtx_type;

libc/lib/CMakeLists.txt

DEPENDS
     munmap
 
     # signal.h entrypoints
     raise
     sigaction
     sigaddset
     sigemptyset
     sigprocmask
+    signal
 
     # stdlib.h entrypoints
     _Exit
     abort
 
     # threads.h entrypoints
     mtx_init
     mtx_lock

libc/spec/stdc.td

def StdC : StandardSpec<"stdc"> {
   NamedType MtxTType = NamedType<"mtx_t">;
   PtrType MtxTTypePtr = PtrType<MtxTType>;
   NamedType ThrdStartTType = NamedType<"thrd_start_t">;
   NamedType ThrdTType = NamedType<"thrd_t">;
   PtrType ThrdTTypePtr = PtrType<ThrdTType>;
 
   PtrType IntPtr = PtrType<IntType>;
 
+  NamedType SigHandlerT = NamedType<"__sighandler_t">;
+
   HeaderSpec Assert = HeaderSpec<
       "assert.h",
       [
           Macro<"static_assert">,
           Macro<"assert">,
       ],
       [], // Types
       [], // Enumerations
HeaderSpec Signal = HeaderSpec<
         Macro<"SIGFPE">,
         Macro<"SIGILL">,
         Macro<"SIGINT">,
         Macro<"SIGSEGV">,
         Macro<"SIGTERM">
       ],
       [
         SizeTType,
+        SigHandlerT,
       ],
       [], // Enumerations
       [
         FunctionSpec<"raise", RetValSpec<IntType>, [ArgSpec<IntType>]>,
+        FunctionSpec<
+          "signal",
+          RetValSpec<SigHandlerT>,
+          [ArgSpec<IntType>, ArgSpec<SigHandlerT>]
+        >,
       ]
   >;
 
   HeaderSpec Threads = HeaderSpec<
       "threads.h",
       [], // Macros
       [
           MtxTType,

libc/src/signal/linux/CMakeLists.txt

add_entrypoint_object(
   HDRS
     signal.h
     ../sigaddset.h
   DEPENDS
     __errno_location
     errno_h
     signal_h
 )
+
+add_entrypoint_object(
+  signal
+  SRCS
+    signal.cpp
+  HDRS
+    signal.h
+    ../signal.h
+  DEPENDS
+    sigaction
+    signal_h
+)

libc/src/signal/linux/signal.cpp

+//===------------------ Linux implementation of signal --------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#define __LLVM_LIBC_INTERNAL_SIGACTION
+#include "src/signal/signal.h"
+#include "src/signal/sigaction.h"
+
+#include "src/__support/common.h"
+
+namespace __llvm_libc {
+
+sighandler_t LLVM_LIBC_ENTRYPOINT(signal)(int signum, sighandler_t handler) {
+  struct __sigaction action, old;
+  action.sa_handler = handler;
+  action.sa_flags = SA_RESTART;
+  // Errno will already be set so no need to worry about changing errno here.
+  return __llvm_libc::sigaction(signum, &action, &old) == -1 ? SIG_ERR
+                                                             : old.sa_handler;
+}
+
+} // namespace __llvm_libc

libc/src/signal/signal.h

+//===------------- Implementation header for signal ------------*- 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_SIGNAL_SIGNAL_H
+#define LLVM_LIBC_SRC_SIGNAL_SIGNAL_H
+
+#include "include/signal.h"
+
+namespace __llvm_libc {
+
+using sighandler_t = __sighandler_t;
+
+sighandler_t signal(int signum, sighandler_t handler);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SIGNAL_SIGNAL_H

libc/test/src/signal/CMakeLists.txt

SUITE
     libc_signal_unittests
   SRCS
     sigaddset_test.cpp
   DEPENDS
     sigaddset
     signal_h
     __errno_location
 )
+
+add_libc_unittest(
+  signal_test
+  SUITE
+    libc_signal_unittests
+  SRCS
+    signal_test.cpp
+  DEPENDS
+    signal
+    signal_h
+    sigaction
+    raise
+    __errno_location
+    errno_h
+)

libc/test/src/signal/signal_test.cpp

+//===------------------------ Unittests for signal ------------------------===//
+//
+// 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 "include/errno.h"
+#include "include/signal.h"
+#include "src/errno/llvmlibc_errno.h"
+#include "src/signal/raise.h"
+#include "src/signal/signal.h"
+
+#include "utils/UnitTest/ErrnoSetterMatcher.h"
+#include "utils/UnitTest/Test.h"
+
+using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
+using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
+
+TEST(Signal, Invalid) {
+  llvmlibc_errno = 0;
+  __llvm_libc::sighandler_t valid = +[](int) {};
+  EXPECT_THAT((void *)__llvm_libc::signal(0, valid),
+              Fails(EINVAL, (void *)SIG_ERR));
+  EXPECT_THAT((void *)__llvm_libc::signal(65, valid),
+              Fails(EINVAL, (void *)SIG_ERR));
+}
+
+static int sum;
+TEST(Signal, Basic) {
+  // In case test get run multiple times.
+  sum = 0;
+  ASSERT_NE(__llvm_libc::signal(SIGUSR1, +[](int) { sum++; }),
+            SIG_ERR);
+  ASSERT_THAT(__llvm_libc::raise(SIGUSR1), Succeeds());
+  EXPECT_EQ(sum, 1);
+  for (int i = 0; i < 10; i++)
+    ASSERT_THAT(__llvm_libc::raise(SIGUSR1), Succeeds());
+  EXPECT_EQ(sum, 11);
+}

libc/utils/UnitTest/Test.h

#define ASSERT_DEATH(FUNC, EXIT)                                               \
   if (!EXPECT_DEATH(FUNC, EXIT))                                               \
   return
 
 #define __CAT1(a, b) a##b
 #define __CAT(a, b) __CAT1(a, b)
 #define UNIQUE_VAR(prefix) __CAT(prefix, __LINE__)
 
 #define EXPECT_THAT(MATCH, MATCHER)                                            \
-  auto UNIQUE_VAR(__matcher) = (MATCHER);                                      \
-  __llvm_libc::testing::Test::testMatch(                                       \
-      Ctx, UNIQUE_VAR(__matcher).match((MATCH)), UNIQUE_VAR(__matcher),        \
-      #MATCH, #MATCHER, __FILE__, __LINE__)
+  do {                                                                         \
+    auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
+    __llvm_libc::testing::Test::testMatch(                                     \
+        Ctx, UNIQUE_VAR(__matcher).match((MATCH)), UNIQUE_VAR(__matcher),      \
+        #MATCH, #MATCHER, __FILE__, __LINE__);                                 \
+  } while (0)
 
 #define ASSERT_THAT(MATCH, MATCHER)                                            \
-  if (!EXPECT_THAT(MATCH, MATCHER))                                            \
-  return
+  do {                                                                         \
+    auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
+    if (!__llvm_libc::testing::Test::testMatch(                                \
+            Ctx, UNIQUE_VAR(__matcher).match((MATCH)), UNIQUE_VAR(__matcher),  \
+            #MATCH, #MATCHER, __FILE__, __LINE__))                             \
+      return;                                                                  \
+  } while (0)
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_H