Merge branch 'main' of https://github.com/llvm/llvm-project into inferas_for_spirv

Author: AlexVlx

libc/config/linux/riscv/entrypoints.txt

@@ -251,7 +251,8 @@ set(TARGET_LIBC_ENTRYPOINTS
     libc.src.sys.mman.munmap
     libc.src.sys.mman.remap_file_pages
     libc.src.sys.mman.posix_madvise
-    libc.src.sys.mman.process_mrelease
+    # TODO: disabled due to buildbot failure. further investigation needed.
+    # libc.src.sys.mman.process_mrelease
     libc.src.sys.mman.shm_open
     libc.src.sys.mman.shm_unlink
 

libc/src/sys/mman/linux/process_mrelease.cpp

@@ -19,6 +19,7 @@
 namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(int, process_mrelease, (int pidfd, unsigned int flags)) {
+#ifdef SYS_process_mrelease
   long ret =
       LIBC_NAMESPACE::syscall_impl<int>(SYS_process_mrelease, pidfd, flags);
 
@@ -28,6 +29,13 @@ LLVM_LIBC_FUNCTION(int, process_mrelease, (int pidfd, unsigned int flags)) {
   }
 
   return 0;
+#else
+  // The system call is not available.
+  (void)pidfd;
+  (void)flags;
+  libc_errno = ENOSYS;
+  return -1;
+#endif
 }
 
 } // namespace LIBC_NAMESPACE_DECL

libc/test/src/sys/mman/linux/CMakeLists.txt

@@ -197,6 +197,7 @@ add_libc_unittest(
     libc.src.signal.kill
     libc.include.signal
     libc.src.stdlib.exit
+    libc.src.signal.raise
     libc.src.__support.OSUtil.osutil
     libc.src.__support.threads.sleep
     libc.test.UnitTest.ErrnoSetterMatcher

libc/test/src/sys/mman/linux/process_mrelease_test.cpp

@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
-#include "src/__support/threads/sleep.h"
 #include "src/errno/libc_errno.h"
 #include "src/signal/kill.h"
+#include "src/signal/raise.h"
 #include "src/stdlib/exit.h"
 #include "src/sys/mman/process_mrelease.h"
 #include "src/unistd/close.h"
@@ -18,7 +18,7 @@
 #include "test/UnitTest/LibcTest.h"
 
 #include <sys/syscall.h>
-
+#if defined(SYS_process_mrelease) && defined(SYS_pidfd_open)
 using namespace LIBC_NAMESPACE::testing::ErrnoSetterMatcher;
 
 int pidfd_open(pid_t pid, unsigned int flags) {
@@ -30,13 +30,11 @@ TEST(LlvmLibcProcessMReleaseTest, NoError) {
   EXPECT_GE(child_pid, 0);
 
   if (child_pid == 0) {
-    // Child process: wait a bit then exit gracefully.
-    LIBC_NAMESPACE::sleep_briefly();
-    LIBC_NAMESPACE::exit(0);
+    // pause the child process
+    LIBC_NAMESPACE::raise(SIGSTOP);
   } else {
     // Parent process: wait a bit and then kill the child.
     // Give child process some time to start.
-    LIBC_NAMESPACE::sleep_briefly();
     int pidfd = pidfd_open(child_pid, 0);
     EXPECT_GE(pidfd, 0);
 
@@ -54,12 +52,9 @@ TEST(LlvmLibcProcessMReleaseTest, ErrorNotKilled) {
   EXPECT_GE(child_pid, 0);
 
   if (child_pid == 0) {
-    // Child process: wait a bit then exit gracefully.
-    LIBC_NAMESPACE::sleep_briefly();
-    LIBC_NAMESPACE::exit(0);
+    // pause the child process
+    LIBC_NAMESPACE::raise(SIGSTOP);
   } else {
-    // Give child process some time to start.
-    LIBC_NAMESPACE::sleep_briefly();
     int pidfd = pidfd_open(child_pid, 0);
     EXPECT_GE(pidfd, 0);
 
@@ -72,3 +67,4 @@ TEST(LlvmLibcProcessMReleaseTest, ErrorNotKilled) {
 TEST(LlvmLibcProcessMReleaseTest, ErrorNonExistingPidfd) {
   EXPECT_THAT(LIBC_NAMESPACE::process_mrelease(-1, 0), Fails(EBADF));
 }
+#endif

llvm/lib/Analysis/VectorUtils.cpp

@@ -118,9 +118,13 @@ bool llvm::isVectorIntrinsicWithScalarOpAtArg(Intrinsic::ID ID,
                                               unsigned ScalarOpdIdx) {
   switch (ID) {
   case Intrinsic::abs:
+  case Intrinsic::vp_abs:
   case Intrinsic::ctlz:
+  case Intrinsic::vp_ctlz:
   case Intrinsic::cttz:
+  case Intrinsic::vp_cttz:
   case Intrinsic::is_fpclass:
+  case Intrinsic::vp_is_fpclass:
   case Intrinsic::powi:
     return (ScalarOpdIdx == 1);
   case Intrinsic::smul_fix:
@@ -145,10 +149,13 @@ bool llvm::isVectorIntrinsicWithOverloadTypeAtArg(
   case Intrinsic::fptoui_sat:
   case Intrinsic::lrint:
   case Intrinsic::llrint:
+  case Intrinsic::vp_lrint:
+  case Intrinsic::vp_llrint:
   case Intrinsic::ucmp:
   case Intrinsic::scmp:
     return OpdIdx == -1 || OpdIdx == 0;
   case Intrinsic::is_fpclass:
+  case Intrinsic::vp_is_fpclass:
     return OpdIdx == 0;
   case Intrinsic::powi:
     return OpdIdx == -1 || OpdIdx == 1;

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -993,6 +993,15 @@ InstructionCost VPWidenIntrinsicRecipe::computeCost(ElementCount VF,
   for (const auto &[Idx, Op] : enumerate(operands())) {
     auto *V = Op->getUnderlyingValue();
     if (!V) {
+      // Push all the VP Intrinsic's ops into the Argments even if is nullptr.
+      // Some VP Intrinsic's cost will assert the number of parameters.
+      // Mainly appears in the following two scenarios:
+      // 1. EVL Op is nullptr
+      // 2. The Argmunt of the VP Intrinsic is also the VP Intrinsic
+      if (VPIntrinsic::isVPIntrinsic(VectorIntrinsicID)) {
+        Arguments.push_back(V);
+        continue;
+      }
       if (auto *UI = dyn_cast_or_null<CallBase>(getUnderlyingValue())) {
         Arguments.push_back(UI->getArgOperand(Idx));
         continue;

llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp

@@ -1481,6 +1481,26 @@ static void transformRecipestoEVLRecipes(VPlan &Plan, VPValue &EVL) {
                 VPValue *NewMask = GetNewMask(Red->getCondOp());
                 return new VPReductionEVLRecipe(*Red, EVL, NewMask);
               })
+              .Case<VPWidenIntrinsicRecipe>(
+                  [&](VPWidenIntrinsicRecipe *CInst) -> VPRecipeBase * {
+                    auto *CI = cast<CallInst>(CInst->getUnderlyingInstr());
+                    Intrinsic::ID VPID = VPIntrinsic::getForIntrinsic(
+                        CI->getCalledFunction()->getIntrinsicID());
+                    if (VPID == Intrinsic::not_intrinsic)
+                      return nullptr;
+
+                    SmallVector<VPValue *> Ops(CInst->operands());
+                    assert(VPIntrinsic::getMaskParamPos(VPID) &&
+                           VPIntrinsic::getVectorLengthParamPos(VPID) &&
+                           "Expected VP intrinsic");
+                    VPValue *Mask = Plan.getOrAddLiveIn(ConstantInt::getTrue(
+                        IntegerType::getInt1Ty(CI->getContext())));
+                    Ops.push_back(Mask);
+                    Ops.push_back(&EVL);
+                    return new VPWidenIntrinsicRecipe(
+                        *CI, VPID, Ops, TypeInfo.inferScalarType(CInst),
+                        CInst->getDebugLoc());
+                  })
               .Case<VPWidenSelectRecipe>([&](VPWidenSelectRecipe *Sel) {
                 SmallVector<VPValue *> Ops(Sel->operands());
                 Ops.push_back(&EVL);