From 1c4e856d3220852baf62596bec951c7f83794951 Mon Sep 17 00:00:00 2001 From: Ramkumar Ramachandra Date: Thu, 2 Oct 2025 18:05:11 +0100 Subject: [PATCH 1/5] [LV] Pre-commit test for constantfolder-binaryintrinsic --- .../LoopVectorize/constantfolder.ll | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/llvm/test/Transforms/LoopVectorize/constantfolder.ll b/llvm/test/Transforms/LoopVectorize/constantfolder.ll index 66592b0ccf677..4bc26a7d19a9b 100644 --- a/llvm/test/Transforms/LoopVectorize/constantfolder.ll +++ b/llvm/test/Transforms/LoopVectorize/constantfolder.ll @@ -288,3 +288,80 @@ loop.latch: exit: ret void } + +define void @const_fold_binaryintrinsic(ptr %dst, i64 %d) { +; CHECK-LABEL: define void @const_fold_binaryintrinsic( +; CHECK-SAME: ptr [[DST:%.*]], i64 [[D:%.*]]) { +; CHECK-NEXT: [[ENTRY:.*:]] +; CHECK-NEXT: br label %[[VECTOR_PH:.*]] +; CHECK: [[VECTOR_PH]]: +; CHECK-NEXT: [[TMP0:%.*]] = call <4 x i64> @llvm.umax.v4i64(<4 x i64> zeroinitializer, <4 x i64> splat (i64 3)) +; CHECK-NEXT: [[TMP1:%.*]] = extractelement <4 x i64> [[TMP0]], i32 3 +; CHECK-NEXT: br label %[[VECTOR_BODY:.*]] +; CHECK: [[VECTOR_BODY]]: +; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] +; CHECK-NEXT: store i64 [[TMP1]], ptr [[DST]], align 2 +; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 4 +; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i64 [[INDEX_NEXT]], 100 +; CHECK-NEXT: br i1 [[TMP2]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP9:![0-9]+]] +; CHECK: [[MIDDLE_BLOCK]]: +; CHECK-NEXT: br label %[[EXIT:.*]] +; CHECK: [[EXIT]]: +; CHECK-NEXT: ret void +; +entry: + br label %loop + +loop: + %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] + %const.0 = xor i64 %d, %d + %trunc = call i64 @llvm.umax.i64(i64 %const.0, i64 3) + store i64 %trunc, ptr %dst, align 2 + %iv.next = add i64 %iv, 1 + %cmp = icmp ult i64 %iv.next, 100 + br i1 %cmp, label %loop, label %exit + +exit: + ret void +} + +define void @const_fold_widegep(ptr noalias %A, ptr noalias %B) { +; CHECK-LABEL: define void @const_fold_widegep( +; CHECK-SAME: ptr noalias [[A:%.*]], ptr noalias [[B:%.*]]) { +; CHECK-NEXT: [[ENTRY:.*:]] +; CHECK-NEXT: br label %[[VECTOR_PH:.*]] +; CHECK: [[VECTOR_PH]]: +; CHECK-NEXT: br label %[[VECTOR_BODY:.*]] +; CHECK: [[VECTOR_BODY]]: +; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] +; CHECK-NEXT: store ptr [[A]], ptr [[B]], align 8 +; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 4 +; CHECK-NEXT: [[TMP0:%.*]] = icmp eq i64 [[INDEX_NEXT]], 100 +; CHECK-NEXT: br i1 [[TMP0]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP10:![0-9]+]] +; CHECK: [[MIDDLE_BLOCK]]: +; CHECK-NEXT: br label %[[EXIT:.*]] +; CHECK: [[EXIT]]: +; CHECK-NEXT: ret void +; +entry: + br label %loop.header + +loop.header: + %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ] + br i1 true, label %loop.latch, label %else + +else: + br label %loop.latch + +loop.latch: + %const.0 = phi i64 [ 0, %loop.header ], [ %iv, %else ] + %gep.A = getelementptr i64, ptr %A, i64 %const.0 + %gep.B = getelementptr i64, ptr %B, i64 %const.0 + store ptr %gep.A, ptr %gep.B + %iv.next = add nuw nsw i64 %iv, 1 + %exit.cond = icmp ult i64 %iv.next, 100 + br i1 %exit.cond, label %loop.header, label %exit + +exit: + ret void +} From 670430abf781c7e5a7a58bb0438b6a3998f228ad Mon Sep 17 00:00:00 2001 From: Ramkumar Ramachandra Date: Thu, 2 Oct 2025 18:07:40 +0100 Subject: [PATCH 2/5] [VPlan] Extend tryToFoldLiveIns to fold binary intrinsics InstSimplifyFolder can fold binary intrinsics, so take the opportunity to unify code with getOpcodeOrIntrinsicID, and handle the case. The additional handling of WidenGEP is non-functional, as the GEP is simplified before it is widened, as the included test shows. --- .../llvm/Analysis/InstSimplifyFolder.h | 2 +- .../Transforms/Vectorize/VPlanTransforms.cpp | 83 ++++++++++--------- .../LoopVectorize/constantfolder.ll | 4 +- 3 files changed, 46 insertions(+), 43 deletions(-) diff --git a/llvm/include/llvm/Analysis/InstSimplifyFolder.h b/llvm/include/llvm/Analysis/InstSimplifyFolder.h index 58793ed977f68..2832beb9e337c 100644 --- a/llvm/include/llvm/Analysis/InstSimplifyFolder.h +++ b/llvm/include/llvm/Analysis/InstSimplifyFolder.h @@ -120,7 +120,7 @@ class LLVM_ABI InstSimplifyFolder final : public IRBuilderFolder { } Value *FoldBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, Type *Ty, - Instruction *FMFSource) const override { + Instruction *FMFSource = nullptr) const override { return simplifyBinaryIntrinsic(ID, Ty, LHS, RHS, SQ, dyn_cast_if_present(FMFSource)); } diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp index e060e7081042a..f88c49a02a28b 100644 --- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp +++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp @@ -943,12 +943,41 @@ static void recursivelyDeleteDeadRecipes(VPValue *V) { } } +namespace { +/// Get any instruction opcode or intrinsic ID data embedded in recipe \p R. +/// Returns an optional pair, where the first element indicates whether it is +/// an intrinsic ID. +static std::optional> +getOpcodeOrIntrinsicID(const VPSingleDefRecipe *R) { + return TypeSwitch>>(R) + .Case( + [](auto *I) { return std::make_pair(false, I->getOpcode()); }) + .Case([](auto *I) { + return std::make_pair(true, I->getVectorIntrinsicID()); + }) + .Case([](auto *I) { + // For recipes that do not directly map to LLVM IR instructions, + // assign opcodes after the last VPInstruction opcode (which is also + // after the last IR Instruction opcode), based on the VPDefID. + return std::make_pair(false, + VPInstruction::OpsEnd + 1 + I->getVPDefID()); + }) + .Default([](auto *) { return std::nullopt; }); +} +} // namespace + /// Try to fold \p R using InstSimplifyFolder. Will succeed and return a -/// non-nullptr Value for a handled \p Opcode if corresponding \p Operands are -/// foldable live-ins. -static Value *tryToFoldLiveIns(const VPRecipeBase &R, unsigned Opcode, +/// non-nullptr Value for a handled opcode or intrinsic ID if corresponding \p +/// Operands are foldable live-ins. +static Value *tryToFoldLiveIns(VPSingleDefRecipe &R, ArrayRef Operands, const DataLayout &DL, VPTypeAnalysis &TypeInfo) { + auto OpcodeOrIID = getOpcodeOrIntrinsicID(&R); + if (!OpcodeOrIID) + return nullptr; + SmallVector Ops; for (VPValue *Op : Operands) { if (!Op->isLiveIn() || !Op->getLiveInIRValue()) @@ -957,6 +986,14 @@ static Value *tryToFoldLiveIns(const VPRecipeBase &R, unsigned Opcode, } InstSimplifyFolder Folder(DL); + if (OpcodeOrIID->first) { + if (R.getNumOperands() != 2) + return nullptr; + unsigned ID = OpcodeOrIID->second; + return Folder.FoldBinaryIntrinsic(ID, Ops[0], Ops[1], + TypeInfo.inferScalarType(&R)); + } + unsigned Opcode = OpcodeOrIID->second; if (Instruction::isBinaryOp(Opcode)) return Folder.FoldBinOp(static_cast(Opcode), Ops[0], Ops[1]); @@ -1006,19 +1043,10 @@ static void simplifyRecipe(VPRecipeBase &R, VPTypeAnalysis &TypeInfo) { // Simplification of live-in IR values for SingleDef recipes using // InstSimplifyFolder. - if (TypeSwitch(&R) - .Case([&](auto *I) { - const DataLayout &DL = - Plan->getScalarHeader()->getIRBasicBlock()->getDataLayout(); - Value *V = tryToFoldLiveIns(*I, I->getOpcode(), I->operands(), DL, - TypeInfo); - if (V) - I->replaceAllUsesWith(Plan->getOrAddLiveIn(V)); - return V; - }) - .Default([](auto *) { return false; })) - return; + const DataLayout &DL = + Plan->getScalarHeader()->getIRBasicBlock()->getDataLayout(); + if (Value *V = tryToFoldLiveIns(*Def, Def->operands(), DL, TypeInfo)) + return Def->replaceAllUsesWith(Plan->getOrAddLiveIn(V)); // Fold PredPHI LiveIn -> LiveIn. if (auto *PredPHI = dyn_cast(&R)) { @@ -1999,29 +2027,6 @@ struct VPCSEDenseMapInfo : public DenseMapInfo { return Def == getEmptyKey() || Def == getTombstoneKey(); } - /// Get any instruction opcode or intrinsic ID data embedded in recipe \p R. - /// Returns an optional pair, where the first element indicates whether it is - /// an intrinsic ID. - static std::optional> - getOpcodeOrIntrinsicID(const VPSingleDefRecipe *R) { - return TypeSwitch>>(R) - .Case( - [](auto *I) { return std::make_pair(false, I->getOpcode()); }) - .Case([](auto *I) { - return std::make_pair(true, I->getVectorIntrinsicID()); - }) - .Case([](auto *I) { - // For recipes that do not directly map to LLVM IR instructions, - // assign opcodes after the last VPInstruction opcode (which is also - // after the last IR Instruction opcode), based on the VPDefID. - return std::make_pair(false, - VPInstruction::OpsEnd + 1 + I->getVPDefID()); - }) - .Default([](auto *) { return std::nullopt; }); - } - /// If recipe \p R will lower to a GEP with a non-i8 source element type, /// return that source element type. static Type *getGEPSourceElementType(const VPSingleDefRecipe *R) { diff --git a/llvm/test/Transforms/LoopVectorize/constantfolder.ll b/llvm/test/Transforms/LoopVectorize/constantfolder.ll index 4bc26a7d19a9b..0d6578532e815 100644 --- a/llvm/test/Transforms/LoopVectorize/constantfolder.ll +++ b/llvm/test/Transforms/LoopVectorize/constantfolder.ll @@ -295,12 +295,10 @@ define void @const_fold_binaryintrinsic(ptr %dst, i64 %d) { ; CHECK-NEXT: [[ENTRY:.*:]] ; CHECK-NEXT: br label %[[VECTOR_PH:.*]] ; CHECK: [[VECTOR_PH]]: -; CHECK-NEXT: [[TMP0:%.*]] = call <4 x i64> @llvm.umax.v4i64(<4 x i64> zeroinitializer, <4 x i64> splat (i64 3)) -; CHECK-NEXT: [[TMP1:%.*]] = extractelement <4 x i64> [[TMP0]], i32 3 ; CHECK-NEXT: br label %[[VECTOR_BODY:.*]] ; CHECK: [[VECTOR_BODY]]: ; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] -; CHECK-NEXT: store i64 [[TMP1]], ptr [[DST]], align 2 +; CHECK-NEXT: store i64 3, ptr [[DST]], align 2 ; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 4 ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i64 [[INDEX_NEXT]], 100 ; CHECK-NEXT: br i1 [[TMP2]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP9:![0-9]+]] From 7b0aa59e05b90cc6689595aeccb16b2aa36411e7 Mon Sep 17 00:00:00 2001 From: Ramkumar Ramachandra Date: Tue, 21 Oct 2025 10:49:24 +0100 Subject: [PATCH 3/5] [VPlan] Strip anon namespace --- llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp index f88c49a02a28b..229d72519f0b2 100644 --- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp +++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp @@ -943,7 +943,6 @@ static void recursivelyDeleteDeadRecipes(VPValue *V) { } } -namespace { /// Get any instruction opcode or intrinsic ID data embedded in recipe \p R. /// Returns an optional pair, where the first element indicates whether it is /// an intrinsic ID. @@ -966,7 +965,6 @@ getOpcodeOrIntrinsicID(const VPSingleDefRecipe *R) { }) .Default([](auto *) { return std::nullopt; }); } -} // namespace /// Try to fold \p R using InstSimplifyFolder. Will succeed and return a /// non-nullptr Value for a handled opcode or intrinsic ID if corresponding \p From 56f9d2171d785512d135f9f5e6b1b877280e3b5c Mon Sep 17 00:00:00 2001 From: Ramkumar Ramachandra Date: Tue, 21 Oct 2025 17:50:09 +0100 Subject: [PATCH 4/5] [VPlan] Return VPValue from tryToFoldLiveIns --- .../Transforms/Vectorize/VPlanTransforms.cpp | 111 ++++++++++-------- 1 file changed, 59 insertions(+), 52 deletions(-) diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp index 229d72519f0b2..b4fccf14cd2dc 100644 --- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp +++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp @@ -969,12 +969,62 @@ getOpcodeOrIntrinsicID(const VPSingleDefRecipe *R) { /// Try to fold \p R using InstSimplifyFolder. Will succeed and return a /// non-nullptr Value for a handled opcode or intrinsic ID if corresponding \p /// Operands are foldable live-ins. -static Value *tryToFoldLiveIns(VPSingleDefRecipe &R, - ArrayRef Operands, - const DataLayout &DL, VPTypeAnalysis &TypeInfo) { - auto OpcodeOrIID = getOpcodeOrIntrinsicID(&R); - if (!OpcodeOrIID) +static VPValue *tryToFoldLiveIns(VPSingleDefRecipe &R, + ArrayRef Operands, + const DataLayout &DL, + VPTypeAnalysis &TypeInfo) { + auto FoldIROperands = [&R, &DL, &TypeInfo](ArrayRef Ops) -> Value * { + auto OpcodeOrIID = getOpcodeOrIntrinsicID(&R); + if (!OpcodeOrIID) + return nullptr; + + InstSimplifyFolder Folder(DL); + if (OpcodeOrIID->first) { + if (R.getNumOperands() != 2) + return nullptr; + unsigned ID = OpcodeOrIID->second; + return Folder.FoldBinaryIntrinsic(ID, Ops[0], Ops[1], + TypeInfo.inferScalarType(&R)); + } + unsigned Opcode = OpcodeOrIID->second; + if (Instruction::isBinaryOp(Opcode)) + return Folder.FoldBinOp(static_cast(Opcode), + Ops[0], Ops[1]); + if (Instruction::isCast(Opcode)) + return Folder.FoldCast(static_cast(Opcode), Ops[0], + TypeInfo.inferScalarType(R.getVPSingleValue())); + switch (Opcode) { + case VPInstruction::LogicalAnd: + return Folder.FoldSelect(Ops[0], Ops[1], + ConstantInt::getNullValue(Ops[1]->getType())); + case VPInstruction::Not: + return Folder.FoldBinOp(Instruction::BinaryOps::Xor, Ops[0], + Constant::getAllOnesValue(Ops[0]->getType())); + case Instruction::Select: + return Folder.FoldSelect(Ops[0], Ops[1], Ops[2]); + case Instruction::ICmp: + case Instruction::FCmp: + return Folder.FoldCmp(cast(R).getPredicate(), Ops[0], + Ops[1]); + case Instruction::GetElementPtr: { + auto &RFlags = cast(R); + auto *GEP = cast(RFlags.getUnderlyingInstr()); + return Folder.FoldGEP(GEP->getSourceElementType(), Ops[0], + Ops.drop_front(), RFlags.getGEPNoWrapFlags()); + } + case VPInstruction::PtrAdd: + case VPInstruction::WidePtrAdd: + return Folder.FoldGEP(IntegerType::getInt8Ty(TypeInfo.getContext()), + Ops[0], Ops[1], + cast(R).getGEPNoWrapFlags()); + // An extract of a live-in is an extract of a broadcast, so return the + // broadcasted element. + case Instruction::ExtractElement: + assert(!Ops[0]->getType()->isVectorTy() && "Live-ins should be scalar"); + return Ops[0]; + } return nullptr; + }; SmallVector Ops; for (VPValue *Op : Operands) { @@ -983,51 +1033,8 @@ static Value *tryToFoldLiveIns(VPSingleDefRecipe &R, Ops.push_back(Op->getLiveInIRValue()); } - InstSimplifyFolder Folder(DL); - if (OpcodeOrIID->first) { - if (R.getNumOperands() != 2) - return nullptr; - unsigned ID = OpcodeOrIID->second; - return Folder.FoldBinaryIntrinsic(ID, Ops[0], Ops[1], - TypeInfo.inferScalarType(&R)); - } - unsigned Opcode = OpcodeOrIID->second; - if (Instruction::isBinaryOp(Opcode)) - return Folder.FoldBinOp(static_cast(Opcode), Ops[0], - Ops[1]); - if (Instruction::isCast(Opcode)) - return Folder.FoldCast(static_cast(Opcode), Ops[0], - TypeInfo.inferScalarType(R.getVPSingleValue())); - switch (Opcode) { - case VPInstruction::LogicalAnd: - return Folder.FoldSelect(Ops[0], Ops[1], - ConstantInt::getNullValue(Ops[1]->getType())); - case VPInstruction::Not: - return Folder.FoldBinOp(Instruction::BinaryOps::Xor, Ops[0], - Constant::getAllOnesValue(Ops[0]->getType())); - case Instruction::Select: - return Folder.FoldSelect(Ops[0], Ops[1], Ops[2]); - case Instruction::ICmp: - case Instruction::FCmp: - return Folder.FoldCmp(cast(R).getPredicate(), Ops[0], - Ops[1]); - case Instruction::GetElementPtr: { - auto &RFlags = cast(R); - auto *GEP = cast(RFlags.getUnderlyingInstr()); - return Folder.FoldGEP(GEP->getSourceElementType(), Ops[0], drop_begin(Ops), - RFlags.getGEPNoWrapFlags()); - } - case VPInstruction::PtrAdd: - case VPInstruction::WidePtrAdd: - return Folder.FoldGEP(IntegerType::getInt8Ty(TypeInfo.getContext()), Ops[0], - Ops[1], - cast(R).getGEPNoWrapFlags()); - // An extract of a live-in is an extract of a broadcast, so return the - // broadcasted element. - case Instruction::ExtractElement: - assert(!Ops[0]->getType()->isVectorTy() && "Live-ins should be scalar"); - return Ops[0]; - } + if (Value *V = FoldIROperands(Ops)) + return R.getParent()->getPlan()->getOrAddLiveIn(V); return nullptr; } @@ -1043,8 +1050,8 @@ static void simplifyRecipe(VPRecipeBase &R, VPTypeAnalysis &TypeInfo) { // InstSimplifyFolder. const DataLayout &DL = Plan->getScalarHeader()->getIRBasicBlock()->getDataLayout(); - if (Value *V = tryToFoldLiveIns(*Def, Def->operands(), DL, TypeInfo)) - return Def->replaceAllUsesWith(Plan->getOrAddLiveIn(V)); + if (VPValue *V = tryToFoldLiveIns(*Def, Def->operands(), DL, TypeInfo)) + return Def->replaceAllUsesWith(V); // Fold PredPHI LiveIn -> LiveIn. if (auto *PredPHI = dyn_cast(&R)) { From a1b85306e70f033011e4bc0d2137c2d1de11e8c7 Mon Sep 17 00:00:00 2001 From: Ramkumar Ramachandra Date: Tue, 21 Oct 2025 21:49:12 +0100 Subject: [PATCH 5/5] [VPlan] Refactor to FoldToIRValue --- .../Transforms/Vectorize/VPlanTransforms.cpp | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp index b4fccf14cd2dc..93b2188163378 100644 --- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp +++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp @@ -973,11 +973,18 @@ static VPValue *tryToFoldLiveIns(VPSingleDefRecipe &R, ArrayRef Operands, const DataLayout &DL, VPTypeAnalysis &TypeInfo) { - auto FoldIROperands = [&R, &DL, &TypeInfo](ArrayRef Ops) -> Value * { + auto FoldToIRValue = [&]() -> Value * { auto OpcodeOrIID = getOpcodeOrIntrinsicID(&R); if (!OpcodeOrIID) return nullptr; + SmallVector Ops; + for (VPValue *Op : Operands) { + if (!Op->isLiveIn() || !Op->getLiveInIRValue()) + return nullptr; + Ops.push_back(Op->getLiveInIRValue()); + } + InstSimplifyFolder Folder(DL); if (OpcodeOrIID->first) { if (R.getNumOperands() != 2) @@ -1010,7 +1017,7 @@ static VPValue *tryToFoldLiveIns(VPSingleDefRecipe &R, auto &RFlags = cast(R); auto *GEP = cast(RFlags.getUnderlyingInstr()); return Folder.FoldGEP(GEP->getSourceElementType(), Ops[0], - Ops.drop_front(), RFlags.getGEPNoWrapFlags()); + drop_begin(Ops), RFlags.getGEPNoWrapFlags()); } case VPInstruction::PtrAdd: case VPInstruction::WidePtrAdd: @@ -1026,14 +1033,7 @@ static VPValue *tryToFoldLiveIns(VPSingleDefRecipe &R, return nullptr; }; - SmallVector Ops; - for (VPValue *Op : Operands) { - if (!Op->isLiveIn() || !Op->getLiveInIRValue()) - return nullptr; - Ops.push_back(Op->getLiveInIRValue()); - } - - if (Value *V = FoldIROperands(Ops)) + if (Value *V = FoldToIRValue()) return R.getParent()->getPlan()->getOrAddLiveIn(V); return nullptr; }