Replace test_not.cpp by test_not.py so that it can be tested under emulation

Author: iamlouk

CMakeLists.txt

@@ -319,6 +319,12 @@ if (TEST_SUITE_USER_MODE_EMULATION)
   set(FPCMP fpcmp)
 endif()
 
+# Shortcut for the path to the not executable
+set(NOT_TOOL not)
+if (TEST_SUITE_USER_MODE_EMULATION AND TEST_SUITE_RUN_UNDER)
+  set(NOT_TOOL not-spawning-emulator)
+endif()
+
 add_subdirectory(litsupport)
 
 option(TEST_SUITE_COLLECT_COMPILE_TIME

Fortran/gfortran/CMakeLists.txt

@@ -716,14 +716,6 @@ function(gfortran_add_execute_test expect_error main others fflags ldflags)
   gfortran_make_working_dir("${target}" working_dir)
   get_filename_component(working_dir_name "${working_dir}" NAME)
 
-  # When running in an emulator, use the version of 'not' that will
-  # spawn the subprocess under that emulator as well.
-  if(TEST_SUITE_USER_MODE_EMULATION AND TEST_SUITE_RUN_UNDER)
-    set(NOT_TOOL "not-spawning-emulator")
-  else()
-    set(NOT_TOOL "not")
-  endif()
-
   llvm_test_executable_no_test(${target} ${main} ${others})
   if (expect_error)
     llvm_test_run(

tools/test/CMakeLists.txt

@@ -1,8 +1,3 @@
-# Copy these files to the build directory so that the tests can be run even
-# without the source directory.
-configure_file(test_not.py test_not.py
-  COPYONLY)
-
 llvm_test_executable_no_test(ret1 ret1.c)
 add_dependencies(ret1 not)
 llvm_test_run(EXECUTABLE "$<TARGET_FILE:not>" "$<TARGET_FILE:ret1>")
@@ -13,25 +8,15 @@ add_dependencies(ret0 not)
 llvm_test_run(EXECUTABLE "$<TARGET_FILE:not>" "$<TARGET_FILE:not>" "$<TARGET_FILE:ret0>")
 llvm_add_test_for_target(ret0)
 
-if(TEST_SUITE_USER_MODE_EMULATION AND TEST_SUITE_RUN_UNDER)
-  # Check that expected crashes are handled correctly under user-mode emulation.
-  llvm_test_executable_no_test(abrt abort.c)
-  add_dependencies(abrt not-spawning-emulator)
-  llvm_test_run(EXECUTABLE "$<TARGET_FILE:not-spawning-emulator>" "--crash" "$<TARGET_FILE:abrt>")
-  llvm_add_test_for_target(abrt)
-else()
-  # Check that expected crashes are handled correctly.
-  llvm_test_executable_no_test(abrt abort.c)
-  add_dependencies(abrt not)
-  llvm_test_run(EXECUTABLE "$<TARGET_FILE:not>" "--crash" "$<TARGET_FILE:abrt>")
-  llvm_add_test_for_target(abrt)
+# Check that expected crashes are handled correctly under user-mode emulation.
+llvm_test_executable_no_test(abrt abort.c)
+add_dependencies(abrt ${NOT_TOOL})
+llvm_test_run(EXECUTABLE "$<TARGET_FILE:${NOT_TOOL}>" "--crash" "$<TARGET_FILE:abrt>")
+llvm_add_test_for_target(abrt)
 
-  # Check that not passes environment variables to the called executable.
-  # This test is disabled in case of user-mode emulation because it would otherwise run the
-  # host python interpreter under the target emulator.
-  find_package(Python COMPONENTS Interpreter)
-  llvm_test_executable_no_test(check_env check_env.c)
-  add_dependencies(check_env not)
-  llvm_test_run(EXECUTABLE ${Python_EXECUTABLE} "%b/test/test_not.py" "$<TARGET_FILE:not>" "$<TARGET_FILE:check_env>")
-  llvm_add_test_For_target(check_env)
-endif()
+# Check that not passes environment variables to the called executable.
+llvm_test_executable_no_test(test_not test_not.cpp)
+llvm_test_executable_no_test(check_env check_env.c)
+add_dependencies(check_env not test_not)
+llvm_test_run(EXECUTABLE ${Python_EXECUTABLE} "$<TARGET_FILE:test_not>" "$<TARGET_FILE:${NOT_TOOL}>" "$<TARGET_FILE:check_env>")
+llvm_add_test_For_target(check_env)

tools/test/test_not.cpp

@@ -0,0 +1,88 @@
+//===- test_not.cpp - Test for enviroment variables in the not tool -------===//
+//
+// 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 <cstdlib>
+#include <iostream>
+#include <sstream>
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#endif
+
+#if defined(__unix__) || defined(__APPLE__)
+#include <spawn.h>
+#include <sys/wait.h>
+#endif
+
+int main(int argc, char *const *argv) {
+  ++argv;
+  --argc;
+  if (argc == 0)
+    return EXIT_FAILURE;
+
+#ifdef _WIN32
+  SetEnvironmentVariableA("SET_IN_PARENT", "something");
+#else
+  setenv("SET_IN_PARENT", "something", 0);
+#endif
+
+  int result;
+
+#if defined(__unix__) || defined(__APPLE__)
+  pid_t pid;
+  extern char **environ;
+  if (posix_spawn(&pid, argv[0], NULL, NULL, argv, environ))
+    return EXIT_FAILURE;
+  if (waitpid(pid, &result, WUNTRACED | WCONTINUED) == -1)
+    return EXIT_FAILURE;
+#else
+  std::stringstream ss;
+  ss << argv[0];
+  for (int i = 1; i < argc; ++i)
+    ss << " " << argv[i];
+  std::string cmd = ss.str();
+  result = std::system(cmd.c_str());
+#endif
+
+  int retcode = 0;
+  int signal = 0;
+
+#ifdef _WIN32
+  // Handle abort() in msvcrt -- It has exit code as 3.  abort(), aka
+  // unreachable, should be recognized as a crash.  However, some binaries use
+  // exit code 3 on non-crash failure paths, so only do this if we expect a
+  // crash.
+  if (errno) {
+    // If the command interpreter was not found, errno will be set and 0 will
+    // be returned. It is unlikely that this will happen in our use case, but
+    // check anyway.
+    retcode = 1;
+    signal = 1;
+  } else {
+    // On Windows, result is the exit code, except for the special case above.
+    retcode = result;
+    signal = 0;
+  }
+#elif defined(WIFEXITED) && defined(WEXITSTATUS) && defined(WIFSIGNALED) &&    \
+    defined(WTERMSIG)
+  // On POSIX systems and Solaris, result is a composite value of the exit code
+  // and, potentially, the signal that caused termination of the command.
+  if (WIFEXITED(result))
+    retcode = WEXITSTATUS(result);
+  if (WIFSIGNALED(result))
+    signal = WTERMSIG(result);
+#else
+#error "Unsupported system"
+#endif
+
+  if (!signal && retcode == EXIT_SUCCESS)
+    return EXIT_SUCCESS;
+  return EXIT_FAILURE;
+}