logic moves to constantfolding.cpp

Author: Pratheek Gowda BS

.github/workflows/bazel-checks.yml

@@ -22,40 +22,11 @@ jobs:
     if: github.repository == 'llvm/llvm-project'
     steps:
       - name: Fetch LLVM sources
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Setup Buildifier
         run: |
-          sudo curl -L https://github.com/bazelbuild/buildtools/releases/download/v8.2.1/buildifier-linux-amd64 -o /usr/bin/buildifier --fail
+          sudo curl -L https://github.com/bazelbuild/buildtools/releases/download/v8.2.1/buildifier-linux-amd64 -o /usr/bin/buildifier
           sudo chmod +x /usr/bin/buildifier
       - name: Run Buildifier
         run: |
           buildifier --mode=check $(find ./utils/bazel -name *BUILD*)
-  
-  bazel-build:
-    name: "Bazel Build/Test"
-    # Only run on US Central workers so we only have to keep one cache warm as
-    # the cache buckets are per cluster.
-    runs-on:
-      group: llvm-premerge-cluster-us-central
-      labels: llvm-premerge-linux-runners
-    if: github.repository == 'llvm/llvm-project'
-    steps:
-      - name: Fetch LLVM sources
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
-        # TODO(boomanaiden154): We should use a purpose built container for this. Move
-        # over when we have fixed the issues with using custom containers with Github
-        # ARC in GKE.
-      - name: Setup System Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libmpfr-dev libpfm4-dev m4 libedit-dev
-          sudo curl -L https://github.com/bazelbuild/bazelisk/releases/download/v1.27.0/bazelisk-amd64.deb --fail > /tmp/bazelisk.deb
-          sudo apt-get install -y /tmp/bazelisk.deb
-          rm /tmp/bazelisk.deb
-      - name: Build/Test
-        working-directory: utils/bazel
-        run: |
-          bazelisk test --config=ci --sandbox_base="" \
-            --remote_cache=https://storage.googleapis.com/$CACHE_GCS_BUCKET-bazel \
-            --google_default_credentials \
-            @llvm-project//... //...

llvm/include/llvm/Transforms/Utils/SimplifyLibCalls.h

@@ -209,7 +209,6 @@ class LibCallSimplifier {
   Value *optimizeLog(CallInst *CI, IRBuilderBase &B);
   Value *optimizeSqrt(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFMod(CallInst *CI, IRBuilderBase &B);
-  Value *optimizellrint(CallInst *CI,IRBuilderBase &B);
   Value *mergeSqrtToExp(CallInst *CI, IRBuilderBase &B);
   Value *optimizeSinCosPi(CallInst *CI, bool IsSin, IRBuilderBase &B);
   Value *optimizeTrigInversionPairs(CallInst *CI, IRBuilderBase &B);

llvm/lib/Analysis/ConstantFolding.cpp

@@ -1943,6 +1943,7 @@ bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
   // environment, they can be folded in any case.
   case Intrinsic::ceil:
   case Intrinsic::floor:
+  case Intrinsic::llrint:
   case Intrinsic::round:
   case Intrinsic::roundeven:
   case Intrinsic::trunc:
@@ -2007,7 +2008,8 @@ bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
     return Name == "log" || Name == "logf" || Name == "logl" ||
            Name == "log2" || Name == "log2f" || Name == "log10" ||
            Name == "log10f" || Name == "logb" || Name == "logbf" ||
-           Name == "log1p" || Name == "log1pf";
+           Name == "log1p" || Name == "log1pf" || Name=="llrint" ||
+           Name=="llrintf";
   case 'n':
     return Name == "nearbyint" || Name == "nearbyintf";
   case 'p':
@@ -2521,9 +2523,34 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
 
     if (IntrinsicID == Intrinsic::nearbyint || IntrinsicID == Intrinsic::rint ||
         IntrinsicID == Intrinsic::roundeven) {
-      U.roundToIntegral(APFloat::rmNearestTiesToEven);
-      return ConstantFP::get(Ty->getContext(), U);
-    }
+      if (IntrinsicID == Intrinsic::llrint) {
+
+        // Use IEEE round-to-nearest, ties-to-even
+        unsigned Width = Ty->getIntegerBitWidth();
+
+        // llrint returns a signed long long, so result is signed.
+        APSInt Result(Width, /*isUnsigned=*/false);
+
+        bool IsExact = false;
+
+        // convertToInteger mutates, so use a temporary APFloat.
+        APFloat Tmp = U;
+        APFloat::opStatus Status = Tmp.convertToInteger(
+            Result, APFloat::rmNearestTiesToEven, &IsExact);
+
+        // Allowed: opOK or opInexact
+        // Disallowed: opInvalidOp (overflow)
+        if (Status == APFloat::opOK || Status == APFloat::opInexact)
+          return ConstantInt::get(Ty, Result);
+
+        return nullptr;
+      }
+
+      if (IntrinsicID == Intrinsic::nearbyint ||
+          IntrinsicID == Intrinsic::rint) {
+        U.roundToIntegral(APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(Ty->getContext(), U);
+      }
 
     if (IntrinsicID == Intrinsic::round) {
       U.roundToIntegral(APFloat::rmNearestTiesToAway);
@@ -2940,6 +2967,12 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
         return ConstantFP::get(Ty->getContext(), U);
       }
       break;
+    case LibFunc_llrint:
+    case LibFunc_llrintf:
+      if (TLI->has(Func)) {
+        return ConstantFP::get(Ty->getContext(), U);
+      }
+      break;
     case LibFunc_log:
     case LibFunc_logf:
     case LibFunc_log_finite:

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

@@ -1361,6 +1361,9 @@ bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
   case LibFunc_fminimum_numl:
   case LibFunc_labs:
   case LibFunc_llabs:
+  case LibFunc_llrintf:
+  case LibFunc_llrintl:
+  case LibFunc_llrint:
   case LibFunc_nearbyint:
   case LibFunc_nearbyintf:
   case LibFunc_nearbyintl:
@@ -1383,13 +1386,6 @@ bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
     Changed |= setDoesNotFreeMemory(F);
     Changed |= setWillReturn(F);
     break;
-  case LibFunc_llrintf:
-  case LibFunc_llrintl:
-  case LibFunc_llrint:
-    Changed|=setDoesNotThrow(F);
-    Changed|=setDoesNotAccessMemory(F);
-    Changed|=setWillReturn(F);
-    break;  
   case LibFunc_sincos:
   case LibFunc_sincosf:
   case LibFunc_sincosl:

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

@@ -3188,28 +3188,6 @@ Value *LibCallSimplifier::optimizeRemquo(CallInst *CI, IRBuilderBase &B) {
   return ConstantFP::get(CI->getType(), Rem);
 }
 
-Value *LibCallSimplifier::optimizellrint(CallInst *CI,IRBuilderBase &B){
-  const APFloat *X;
-  if(!match(CI->getOperand(0),m_APFloat(X))){
-    return nullptr;
-  }
-  Type *type=CI->getType();
-
-  unsigned width=type->getIntegerBitWidth();
-
-  APSInt Result(width,false);
-  bool Isexact;
-
-  APFloat::opStatus Status=X->convertToInteger(Result,APFloat::rmNearestTiesToEven,&Isexact);
-
-  if(Status==APFloat::opOK || Status==APFloat::opInexact){
-    return ConstantInt::get(type,Result);
-  }
-
-  return nullptr;
-
-}
-
 /// Constant folds fdim
 Value *LibCallSimplifier::optimizeFdim(CallInst *CI, IRBuilderBase &B) {
   // Cannot perform the fold unless the call has attribute memory(none)
@@ -4130,6 +4108,8 @@ Value *LibCallSimplifier::optimizeFloatingPointLibCall(CallInst *CI,
     return replaceUnaryCall(CI, Builder, Intrinsic::ceil);
   case LibFunc_floor:
     return replaceUnaryCall(CI, Builder, Intrinsic::floor);
+  case LibFunc_llrint:
+    return replaceUnaryCall(CI, Builder, Intrinsic::llrint);
   case LibFunc_round:
     return replaceUnaryCall(CI, Builder, Intrinsic::round);
   case LibFunc_roundeven:

llvm/test/Transforms/InferFunctionAttrs/annotate.ll

@@ -1250,7 +1250,6 @@ declare void @memset_pattern16(ptr, ptr, i64)
 ; CHECK-DAG: attributes [[NOFREE_NOUNWIND_READONLY_WILLRETURN]] = { mustprogress nocallback nofree nounwind willreturn memory(read) }
 ; CHECK-DAG: attributes [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN]] = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
 ; CHECK-DAG: attributes [[NOFREE_NOUNWIND_READONLY]] = { nofree nounwind memory(read) }
-; CHECK-DAG: attributes [[MATH_NOACCESS]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
 ; CHECK-DAG: attributes [[INACCESSIBLEMEMORARGMEMONLY_NOUNWIND_WILLRETURN_ALLOCKIND_FREE_FAMILY_MALLOC]] = { mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" }
 ; CHECK-DAG: attributes [[INACCESSIBLEMEMONLY_NOFREE_NOUNWIND_WILLRETURN_ALLOCKIND_ALLOCUNINIT_ALLOCSIZE0_FAMILY_MALLOC]] = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" }
 ; CHECK-DAG: attributes [[INACCESSIBLEMEMONLY_NOFREE_NOUNWIND_WILLRETURN_ALLOCKIND_ALLOCUNINIT_FAMILY_MALLOC]] = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") memory(inaccessiblemem: readwrite) "alloc-family"="malloc" }

llvm/test/Transforms/InstCombine/llrint_fold.ll

@@ -1,87 +1,46 @@
-; RUN: opt -S -passes=instcombine %s -o - | FileCheck %s
-
-
-declare i64 @llrint(double)
-
-; Positive number test
-; CHECK-LABEL: define i64 @test_llrint_pos()
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret i64 4
-define i64 @test_llrint_pos() {
-entry:
-  %val = call i64 @llrint(double 3.5)
-  ret i64 %val
-}
-
-; Negative number test
-; CHECK-LABEL: define i64 @test_llrint_neg()
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret i64 -2
-define i64 @test_llrint_neg() {
-entry:
-  %val = call i64 @llrint(double -2.5)
-  ret i64 %val
-}
-
-; Zero test
-; CHECK-LABEL: define i64 @test_llrint_zero()
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret i64 0
-define i64 @test_llrint_zero() {
-entry:
-  %val = call i64 @llrint(double 0.0)
-  ret i64 %val
-}
-
-; Large value test
-; CHECK-LABEL: define i64 @test_llrint_large()
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret i64 1000000
-define i64 @test_llrint_large() {
-entry:
-  %val = call i64 @llrint(double 1.0e6)
-  ret i64 %val
+; RUN: opt -S -passes=instcombine %s | FileCheck %s
+
+; ============================================================
+;  Test constant folding of overloaded @llvm.llrint intrinsic
+; ============================================================
+
+; LLVM intrinsic declarations (typed overloads)
+declare i64 @llvm.llrint.f32(float)
+declare i64 @llvm.llrint.f64(double)
+declare i64 @llvm.llrint.f80(x86_fp80)
+declare i64 @llvm.llrint.f128(fp128)
+
+; ============================================================
+; float overload
+; ============================================================
+define i64 @test_f32_pos() {
+; CHECK-LABEL: @test_f32_pos(
+; CHECK-NEXT: ret i64 4
+  %v = call i64 @llvm.llrint.f32(float 3.5)
+  ret i64 %v
 }
 
-; Rounding test (check ties-to-even)
-; CHECK-LABEL: define i64 @test_llrint_round_even()
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret i64 2
-define i64 @test_llrint_round_even() {
-entry:
-  %val = call i64 @llrint(double 2.5)
-  ret i64 %val
+define i64 @test_f32_neg() {
+; CHECK-LABEL: @test_f32_neg(
+; CHECK-NEXT: ret i64 -2
+  %v = call i64 @llvm.llrint.f32(float -2.5)
+  ret i64 %v
 }
 
-; NaN test
-; CHECK-LABEL: define i64 @test_llrint_nan()
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %val = call i64 @llrint(double 0x7FF8000000000000)
-; CHECK-NEXT:    ret i64 %val
-define i64 @test_llrint_nan() {
-entry:
-  %val = call i64 @llrint(double 0x7FF8000000000000) ; NaN
-  ret i64 %val
+; ============================================================
+; double overload
+; ============================================================
+define i64 @test_f64_pos() {
+; CHECK-LABEL: @test_f64_pos(
+; CHECK-NEXT: ret i64 4
+  %v = call i64 @llvm.llrint.f64(double 3.5)
+  ret i64 %v
 }
 
-; +Inf test
-; CHECK-LABEL: define i64 @test_llrint_posinf()
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %val = call i64 @llrint(double 0x7FF0000000000000)
-; CHECK-NEXT:    ret i64 %val
-define i64 @test_llrint_posinf() {
-entry:
-  %val = call i64 @llrint(double 0x7FF0000000000000) ; +Inf
-  ret i64 %val
+define i64 @test_f64_neg() {
+; CHECK-LABEL: @test_f64_neg(
+; CHECK-NEXT: ret i64 -2
+  %v = call i64 @llvm.llrint.f64(double -2.5)
+  ret i64 %v
 }
 
-; -Inf test
-; CHECK-LABEL: define i64 @test_llrint_neginf()
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %val = call i64 @llrint(double 0xFFF0000000000000)
-; CHECK-NEXT:    ret i64 %val
-define i64 @test_llrint_neginf() {
-entry:
-  %val = call i64 @llrint(double 0xFFF0000000000000) ; -Inf
-  ret i64 %val
-}