[libc] Add POSIX execv and execve functions.

[sivachandra]

Summary

The POSIX global variable environ has also been added.

[michaelrj]

LGTM

libc/cmake/modules/LLVMLibCTestRules.cmake

function(add_integration_test test_name)
   # So, we need to link in the threads implementation. Likewise, the startup
   # code also has to run init_array callbacks which potentially register
   # their own atexit callbacks. So, link in exit and atexit also with all
   # integration tests.
   list(
       APPEND fq_deps_list
       libc.src.__support.threads.thread
       libc.src.stdlib.atexit
-      libc.src.stdlib.exit)
+      libc.src.stdlib.exit
+      libc.src.unistd.environ)
   list(REMOVE_DUPLICATES fq_deps_list)
 
   # We don't want memory functions to be dependencies on integration tests.
   # Memory functions should be tested using unittests. The main reason
   # however is that compiler codegen can emit calls to memory functions. So,
   # we add them explicitly to the integration test libc.a (see below). Adding
   # explicit deps on the memory functions can potentially cause duplicate
   # symbol errors.
function(add_integration_test test_name)
   # Also, we restrict the integration tests to fully static executables. The
   # rtlib is set to compiler-rt to make the compiler drivers pick up the compiler
   # runtime binaries using full paths. Otherwise, files like crtbegin.o are passed
   # as is (and not as paths like /usr/lib/.../crtbegin.o).
   target_link_options(${fq_target_name} PRIVATE --sysroot=${sysroot} -static -stdlib=libc++ --rtlib=compiler-rt)
   add_dependencies(${fq_target_name}
                    ${fq_target_name}.__copy_loader__
                    ${fq_libc_target_name}
-                   libc.utils.IntegrationTest.test)
+                   libc.utils.IntegrationTest.test
+                   ${INTEGRATION_TEST_DEPENDS})
 
   add_custom_command(
     TARGET ${fq_target_name}
     POST_BUILD
     COMMAND ${INTEGRATION_TEST_ENV} $<TARGET_FILE:${fq_target_name}> ${INTEGRATION_TEST_ARGS}
   )
 
   add_dependencies(${INTEGRATION_TEST_SUITE} ${fq_target_name})
 endfunction(add_integration_test)

libc/config/linux/aarch64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     # time.h entrypoints
     libc.src.time.asctime
     libc.src.time.asctime_r
     libc.src.time.gmtime
     libc.src.time.gmtime_r
     libc.src.time.mktime
     libc.src.time.nanosleep
     libc.src.time.clock_gettime
+
+    # unistd.h entrypoints
+    libc.src.unistd.environ
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/config/linux/api.td

def DirentAPI : PublicAPI<"dirent.h"> {
   let Types = [
     "ino_t",
     "DIR",
     "struct dirent",
   ];
 }
 
 def UniStdAPI : PublicAPI<"unistd.h"> {
-  let Types = ["off_t", "pid_t", "size_t", "ssize_t", "uid_t"];
+  let Types = ["__exec_argv_t", "__exec_envp_t", "off_t", "pid_t", "size_t", "ssize_t", "uid_t"];
 }
 
 def SysResourceAPI : PublicAPI<"sys/resource.h"> {
   let Types = ["rlim_t", "struct rlimit"];
 }
 
 def SysStatAPI : PublicAPI<"sys/stat.h"> {
   let Types = ["mode_t", "dev_t", "ino_t", "nlink_t", "uid_t", "gid_t", "off_t",

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
 
     # unistd.h entrypoints
     libc.src.unistd.access
     libc.src.unistd.chdir
     libc.src.unistd.close
     libc.src.unistd.dup
     libc.src.unistd.dup2
     libc.src.unistd.dup3
+    libc.src.unistd.execve
     libc.src.unistd.fchdir
     libc.src.unistd.fsync
     libc.src.unistd.ftruncate
     libc.src.unistd.geteuid
     libc.src.unistd.getpid
     libc.src.unistd.getppid
     libc.src.unistd.getuid
     libc.src.unistd.link
list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.time.asctime_r
     libc.src.time.gmtime
     libc.src.time.gmtime_r
     libc.src.time.mktime
     libc.src.time.nanosleep
     libc.src.time.clock_gettime
 
     # unistd.h entrypoints
+    libc.src.unistd.environ
+    libc.src.unistd.execv
     libc.src.unistd.fork
     libc.src.unistd.__llvm_libc_syscall
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/include/CMakeLists.txt

 add_gen_header(
   unistd
   DEF_FILE unistd.h.def
   GEN_HDR unistd.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-macros.file_seek_macros
     .llvm-libc-macros.unistd_macros
+    .llvm-libc-types.__exec_argv_t
+    .llvm-libc-types.__exec_envp_t
     .llvm-libc-types.off_t
     .llvm-libc-types.pid_t
     .llvm-libc-types.size_t
     .llvm-libc-types.ssize_t
     .llvm-libc-types.uid_t
 )
 
 add_gen_header(

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

 add_header(off64_t HDR off64_t.h)
 add_header(size_t HDR size_t.h)
 add_header(__bsearchcompare_t HDR __bsearchcompare_t.h)
 add_header(__call_once_func_t HDR __call_once_func_t.h)
+add_header(__exec_argv_t HDR __exec_argv_t.h)
+add_header(__exec_envp_t HDR __exec_envp_t.h)
 add_header(__futex_word HDR __futex_word.h)
 add_header(__mutex_type HDR __mutex_type.h DEPENDS .__futex_word)
 add_header(__pthread_once_func_t HDR __pthread_once_func_t.h)
 add_header(__pthread_start_t HDR __pthread_start_t.h)
 add_header(__pthread_tss_dtor_t HDR __pthread_tss_dtor_t.h)
 add_header(__qsortcompare_t HDR __qsortcompare_t.h)
 add_header(__sighandler_t HDR __sighandler_t.h)
 add_header(__thread_type HDR __thread_type.h)

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

+//===-- Definition of type __exec_argv_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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_EXEC_ARGV_T_H__
+#define __LLVM_LIBC_TYPES_EXEC_ARGV_T_H__
+
+typedef char *const __exec_argv_t[];
+
+#endif // __LLVM_LIBC_TYPES_EXEC_ARGV_T_H__

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

+//===-- Definition of type __exec_envp_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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_EXEC_ENVP_T_H__
+#define __LLVM_LIBC_TYPES_EXEC_ENVP_T_H__
+
+typedef char *const __exec_envp_t[];
+
+#endif // __LLVM_LIBC_TYPES_EXEC_ENVP_T_H__

libc/loader/linux/aarch64/start.cpp

 
 #include <arm_acle.h>
 
 #include <linux/auxvec.h>
 #include <linux/elf.h>
 #include <stdint.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
+#include <unistd.h>
 
 extern "C" int main(int, char **, char **);
 
 // Source documentation:
 // https://github.com/ARM-software/abi-aa/tree/main/sysvabi64
 
 namespace __llvm_libc {
 
__attribute__((noinline)) static void do_start() {
   // values. The end of the env values is marked by another 8-byte long NULL
   // value. We step over it (the "+ 1" below) to get to the env values.
   uint64_t *env_ptr = app.args->argv + app.args->argc + 1;
   uint64_t *env_end_marker = env_ptr;
   app.envPtr = env_ptr;
   while (*env_end_marker)
     ++env_end_marker;
 
+  // Initialize the POSIX global declared in unistd.h
+  environ = reinterpret_cast<char **>(env_ptr);
+
   // After the env array, is the aux-vector. The end of the aux-vector is
   // denoted by an AT_NULL entry.
   Elf64_Phdr *programHdrTable = nullptr;
   uintptr_t programHdrCount;
   for (AuxEntry *aux_entry = reinterpret_cast<AuxEntry *>(env_end_marker + 1);
        aux_entry->type != AT_NULL; ++aux_entry) {
     switch (aux_entry->type) {
     case AT_PHDR:

libc/loader/linux/x86_64/CMakeLists.txt

 add_loader_object(
   crt1
   SRC
     start.cpp
   DEPENDS
     libc.config.linux.app_h
     libc.include.sys_mman
     libc.include.sys_syscall
+    libc.include.unistd
     libc.src.__support.threads.thread
     libc.src.__support.OSUtil.osutil
     libc.src.stdlib.exit
     libc.src.stdlib.atexit
     libc.src.string.memory_utils.memcpy_implementation
+    libc.src.unistd.environ
   COMPILE_OPTIONS
     -fno-omit-frame-pointer
     -ffreestanding # To avoid compiler warnings about calling the main function.
     -fno-builtin
 )

libc/loader/linux/x86_64/start.cpp

 #include "src/string/memory_utils/memcpy_implementations.h"
 
 #include <asm/prctl.h>
 #include <linux/auxvec.h>
 #include <linux/elf.h>
 #include <stdint.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
+#include <unistd.h>
 
 extern "C" int main(int, char **, char **);
 
 namespace __llvm_libc {
 
 #ifdef SYS_mmap2
 static constexpr long mmapSyscallNumber = SYS_mmap2;
 #elif SYS_mmap
extern "C" void _start() {
   // values. The end of the env values is marked by another 8-byte long NULL
   // value. We step over it (the "+ 1" below) to get to the env values.
   uint64_t *env_ptr = app.args->argv + app.args->argc + 1;
   uint64_t *env_end_marker = env_ptr;
   app.envPtr = env_ptr;
   while (*env_end_marker)
     ++env_end_marker;
 
+  // Initialize the POSIX global declared in unistd.h
+  environ = reinterpret_cast<char **>(env_ptr);
+
   // After the env array, is the aux-vector. The end of the aux-vector is
   // denoted by an AT_NULL entry.
   Elf64_Phdr *programHdrTable = nullptr;
   uintptr_t programHdrCount;
   for (AuxEntry *aux_entry = reinterpret_cast<AuxEntry *>(env_end_marker + 1);
        aux_entry->type != AT_NULL; ++aux_entry) {
     switch (aux_entry->type) {
     case AT_PHDR:

libc/spec/posix.td

 def StructDirent : NamedType<"struct dirent">;
 def StructDirentPtr : PtrType<StructDirent>;
 def StructDirentPtrPtr : PtrType<StructDirentPtr>;
 def ConstStructDirentPtrPtr : ConstType<StructDirentPtrPtr>;
 
 def StructTimeSpec : NamedType<"struct timespec">;
 def StructTimeSpecPtr : PtrType<StructTimeSpec>;
 
+def ExecArgvT : NamedType<"__exec_argv_t">;
+def ExecEnvpT : NamedType<"__exec_envp_t">;
+
 def POSIX : StandardSpec<"POSIX"> {
   PtrType CharPtr = PtrType<CharType>;
   RestrictedPtrType RestrictedCharPtr = RestrictedPtrType<CharType>;
   RestrictedPtrType CharRestrictedDoublePtr = RestrictedPtrType<CharPtr>;
   ConstType ConstCharPtr = ConstType<CharPtr>;
   ConstType ConstRestrictedCharPtr = ConstType<RestrictedCharPtr>;
 
   NamedType ModeTType = NamedType<"mode_t">;
HeaderSpec Signal = HeaderSpec<
         >,
       ]
   >;
 
   HeaderSpec UniStd = HeaderSpec<
     "unistd.h",
     [], // Macros
     [
+      ExecArgvT,
+      ExecEnvpT,
       OffTType,
       SSizeTType,
       SizeTType,
       PidT,
       UidT,
     ],
     [], // Enumerations
     [
[
           [ArgSpec<IntType>]
         >,
         FunctionSpec<
           "close",
           RetValSpec<IntType>,
           [ArgSpec<IntType>]
         >,
         FunctionSpec<
+          "execv",
+          RetValSpec<IntType>,
+          [ArgSpec<ConstCharPtr>, ArgSpec<ExecArgvT>]
+        >,
+        FunctionSpec<
+          "execve",
+          RetValSpec<IntType>,
+          [ArgSpec<ConstCharPtr>, ArgSpec<ExecArgvT>, ArgSpec<ExecEnvpT>]
+        >,
+        FunctionSpec<
           "fork",
           RetValSpec<PidT>,
           [ArgSpec<VoidType>]
         >,
         FunctionSpec<
           "fsync",
           RetValSpec<IntType>,
           [ArgSpec<IntType>]
[
           RetValSpec<IntType>,
           [ArgSpec<IntType>, ArgSpec<ConstCharPtr>, ArgSpec<IntType>]
         >,
         FunctionSpec<
           "write",
           RetValSpec<SSizeTType>,
           [ArgSpec<IntType>, ArgSpec<ConstVoidPtr>, ArgSpec<SizeTType>]
         >,
+    ],
+    [
+        ObjectSpec<"environ", "char **">,
     ]
   >;
 
   HeaderSpec StdLib = HeaderSpec<
     "stdlib.h",
     [], // Macros
     [], // Types
     [], // Enumerations

libc/src/unistd/CMakeLists.txt

 add_entrypoint_object(
   fork
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.fork
 )
 
 add_entrypoint_object(
+  execv
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.execv
+)
+
+add_entrypoint_object(
+  execve
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.execve
+)
+
+add_entrypoint_object(
   fsync
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.fsync
 )
 
 add_entrypoint_object(
   ftruncate

 )
 
 add_entrypoint_object(
   write
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.write
 )
+
+add_entrypoint_object(
+  environ
+  SRCS
+    environ.cpp
+  HDRS
+    environ.h
+)

libc/src/unistd/environ.h

+//===-- Declaration of POSIX environ ----------------------------*- 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_UNISTD_ENVIRON_H
+#define LLVM_LIBC_SRC_UNISTD_ENVIRON_H
+
+namespace __llvm_libc {
+
+extern "C" char **environ;
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_UNISTD_ENVIRON_H

libc/src/unistd/environ.cpp

+//===-- Declaration of POSIX environ --------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+namespace __llvm_libc {
+
+// This is initialized to the correct value by the statup code.
+extern "C" char **environ = nullptr;
+
+} // namespace __llvm_libc

libc/src/unistd/execv.h

+//===-- Implementation header for execv -------------------------*- 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_UNISTD_EXECV_H
+#define LLVM_LIBC_SRC_UNISTD_EXECV_H
+
+namespace __llvm_libc {
+
+int execv(const char *path, char *const argv[]);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_UNISTD_EXECV_H

libc/src/unistd/execve.h

+//===-- Implementation header for execve ------------------------*- 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_UNISTD_EXECVE_H
+#define LLVM_LIBC_SRC_UNISTD_EXECVE_H
+
+namespace __llvm_libc {
+
+int execve(const char *path, char *const argv[], char *const envp[]);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_UNISTD_EXECVE_H

libc/src/unistd/linux/CMakeLists.txt

DEPENDS
     libc.include.unistd
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.src.__support.threads.thread
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
+  execv
+  SRCS
+    execv.cpp
+  HDRS
+    ../execv.h
+  DEPENDS
+    libc.include.errno
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
+    libc.src.unistd.environ
+)
+
+add_entrypoint_object(
+  execve
+  SRCS
+    execve.cpp
+  HDRS
+    ../execve.h
+  DEPENDS
+    libc.include.errno
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
+)
+
+add_entrypoint_object(
   fsync
   SRCS
     fsync.cpp
   HDRS
     ../fsync.h
   DEPENDS
     libc.include.unistd
     libc.include.sys_syscall

libc/src/unistd/linux/execv.cpp

+//===-- Linux implementation of execv -------------------------------------===//
+//
+// 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/unistd/execv.h"
+#include "src/unistd/environ.h"
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <sys/syscall.h> // For syscall numbers.
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, execv, (const char *path, char *const argv[])) {
+  long ret =
+      __llvm_libc::syscall_impl(SYS_execve, path, argv, __llvm_libc::environ);
+  if (ret < 0) {
+    errno = -ret;
+    return -1;
+  }
+
+  // Control will not reach here on success but have a return statement will
+  // keep the compilers happy.
+  return ret;
+}
+
+} // namespace __llvm_libc

libc/src/unistd/linux/execve.cpp

+//===-- Linux implementation of execve ------------------------------------===//
+//
+// 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/unistd/execve.h"
+#include "src/unistd/environ.h"
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <sys/syscall.h> // For syscall numbers.
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, execve,
+                   (const char *path, char *const argv[], char *const envp[])) {
+  long ret = __llvm_libc::syscall_impl(SYS_execve, path, argv, envp);
+  if (ret < 0) {
+    errno = -ret;
+    return -1;
+  }
+
+  // Control will not reach here on success but have a return statement will
+  // keep the compilers happy.
+  return ret;
+}
+
+} // namespace __llvm_libc

libc/test/integration/src/unistd/CMakeLists.txt

DEPENDS
     libc.include.sys_wait
     libc.include.unistd
     libc.src.signal.raise
     libc.src.sys.wait.wait
     libc.src.sys.wait.wait4
     libc.src.sys.wait.waitpid
     libc.src.unistd.fork
 )
+
+add_executable(
+  libc_execv_test_normal_exit
+  EXCLUDE_FROM_ALL
+  execv_test_normal_exit.cpp
+)
+set_target_properties(
+  libc_execv_test_normal_exit
+  PROPERTIES
+    OUTPUT_NAME libc_execv_test_normal_exit
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+add_executable(
+  libc_execv_test_signal_exit
+  EXCLUDE_FROM_ALL
+  execv_test_signal_exit.cpp
+)
+set_target_properties(
+  libc_execv_test_signal_exit
+  PROPERTIES
+    OUTPUT_NAME libc_execv_test_signal_exit
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+add_integration_test(
+  execv_test
+  SUITE
+    unistd-integration-tests
+  SRCS
+    execv_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc_execv_test_normal_exit
+    libc_execv_test_signal_exit
+    libc.include.errno
+    libc.src.sys.wait.waitpid
+    libc.src.unistd.execv
+    libc.src.unistd.fork
+  ENV
+    EXECV_TEST=PASS
+)
+
+add_integration_test(
+  execve_test
+  SUITE
+    unistd-integration-tests
+  SRCS
+    execve_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc_execv_test_normal_exit
+    libc_execv_test_signal_exit
+    libc.include.errno
+    libc.src.sys.wait.waitpid
+    libc.src.unistd.execve
+    libc.src.unistd.fork
+  ENV
+    EXECV_TEST=PASS
+)

libc/test/integration/src/unistd/execv_test.cpp

+//===-- Unittests for execv -----------------------------------------------===//
+//
+// 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/sys/wait/waitpid.h"
+#include "src/unistd/execv.h"
+#include "src/unistd/fork.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <signal.h>
+#include <sys/wait.h>
+
+void fork_and_execv_normal_exit() {
+  pid_t pid = __llvm_libc::fork();
+  if (pid == 0) {
+    const char *path = "libc_execv_test_normal_exit";
+    char *const argv[] = {
+        const_cast<char *>("execv_test_normal_exit"),
+        nullptr,
+    };
+    __llvm_libc::execv(path, argv);
+  }
+  ASSERT_TRUE(pid > 0);
+  int status;
+  pid_t cpid = __llvm_libc::waitpid(pid, &status, 0);
+  ASSERT_TRUE(cpid > 0);
+  ASSERT_EQ(cpid, pid);
+  ASSERT_TRUE(WIFEXITED(status));
+}
+
+void fork_and_execv_signal_exit() {
+  pid_t pid = __llvm_libc::fork();
+  if (pid == 0) {
+    const char *path = "libc_execv_test_signal_exit";
+    char *const argv[] = {
+        const_cast<char *>("execv_test_normal_exit"),
+        nullptr,
+    };
+    __llvm_libc::execv(path, argv);
+  }
+  ASSERT_TRUE(pid > 0);
+  int status;
+  pid_t cpid = __llvm_libc::waitpid(pid, &status, 0);
+  ASSERT_TRUE(cpid > 0);
+  ASSERT_EQ(cpid, pid);
+  ASSERT_FALSE(WIFEXITED(status));
+  ASSERT_TRUE(WTERMSIG(status) == SIGUSR1);
+}
+
+TEST_MAIN(int argc, char **argv, char **envp) {
+  fork_and_execv_normal_exit();
+  fork_and_execv_signal_exit();
+  return 0;
+}

libc/test/integration/src/unistd/execv_test_normal_exit.cpp

+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int main() {
+  char *env = getenv("EXECV_TEST");
+  if (env == nullptr)
+    raise(SIGUSR1);
+  return 0;
+}

libc/test/integration/src/unistd/execv_test_signal_exit.cpp

+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int main() {
+  char *env = getenv("__MISSING_ENV_VAR__");
+  if (env == nullptr)
+    raise(SIGUSR1);
+  return 0;
+}

libc/test/integration/src/unistd/execve_test.cpp

+//===-- Unittests for execve ----------------------------------------------===//
+//
+// 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/sys/wait/waitpid.h"
+#include "src/unistd/execve.h"
+#include "src/unistd/fork.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <signal.h>
+#include <sys/wait.h>
+
+void fork_and_execv_normal_exit(char **envp) {
+  pid_t pid = __llvm_libc::fork();
+  if (pid == 0) {
+    const char *path = "libc_execv_test_normal_exit";
+    char *const argv[] = {
+        const_cast<char *>("execv_test_normal_exit"),
+        nullptr,
+    };
+    __llvm_libc::execve(path, argv, envp);
+  }
+  ASSERT_TRUE(pid > 0);
+  int status;
+  pid_t cpid = __llvm_libc::waitpid(pid, &status, 0);
+  ASSERT_TRUE(cpid > 0);
+  ASSERT_EQ(cpid, pid);
+  ASSERT_TRUE(WIFEXITED(status));
+}
+
+void fork_and_execv_signal_exit(char **envp) {
+  pid_t pid = __llvm_libc::fork();
+  if (pid == 0) {
+    const char *path = "libc_execv_test_signal_exit";
+    char *const argv[] = {
+        const_cast<char *>("execv_test_normal_exit"),
+        nullptr,
+    };
+    __llvm_libc::execve(path, argv, envp);
+  }
+  ASSERT_TRUE(pid > 0);
+  int status;
+  pid_t cpid = __llvm_libc::waitpid(pid, &status, 0);
+  ASSERT_TRUE(cpid > 0);
+  ASSERT_EQ(cpid, pid);
+  ASSERT_FALSE(WIFEXITED(status));
+  ASSERT_TRUE(WTERMSIG(status) == SIGUSR1);
+}
+
+TEST_MAIN(int argc, char **argv, char **envp) {
+  fork_and_execv_normal_exit(envp);
+  fork_and_execv_signal_exit(envp);
+  return 0;
+}