github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code.
:warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff origin/main HEAD --extensions cpp,c --
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/ime-config.c
clang/test/Sema/riscv-ime-vsetlambda.c
clang/lib/CodeGen/TargetBuiltins/RISCV.cpp clang/lib/Sema/SemaRISCV.cpp
llvm/lib/Target/RISCV/RISCVISelLowering.cpp --diff_from_common_commit
``````````
:warning:
The reproduction instructions above might return results for more than one PR
in a stack if you are using a stacked PR workflow. You can limit the results by
changing `origin/main` to the base branch/commit you want to compare against.
:warning:
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
b/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
index 6fb35cb79..fa7cb036a 100644
--- a/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
+++ b/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
@@ -343,12 +343,9 @@ emitRVVIMEBuiltin(CodeGenFunction *CGF, const CallExpr *E,
// selected-lambda query, so emit real control flow instead of an
// unconditional vsetvl guarded only by a selected vtype value.
llvm::Function *Fn = Builder.GetInsertBlock()->getParent();
- llvm::BasicBlock *ReadBB =
- CGF->createBasicBlock("ime.vsetlambda.read", Fn);
- llvm::BasicBlock *SetBB =
- CGF->createBasicBlock("ime.vsetlambda.set", Fn);
- llvm::BasicBlock *ContBB =
- CGF->createBasicBlock("ime.vsetlambda.cont", Fn);
+ llvm::BasicBlock *ReadBB = CGF->createBasicBlock("ime.vsetlambda.read",
Fn);
+ llvm::BasicBlock *SetBB = CGF->createBasicBlock("ime.vsetlambda.set", Fn);
+ llvm::BasicBlock *ContBB = CGF->createBasicBlock("ime.vsetlambda.cont",
Fn);
Value *IsZero =
Builder.CreateICmpEQ(Req, llvm::ConstantInt::get(ResultType, 0));
@@ -362,8 +359,8 @@ emitRVVIMEBuiltin(CodeGenFunction *CGF, const CallExpr *E,
ReadBB = Builder.GetInsertBlock();
Builder.SetInsertPoint(SetBB);
- llvm::Function *SetF = CGM.getIntrinsic(
- Intrinsic::riscv_ime_vsetlambda_nonzero, {ResultType});
+ llvm::Function *SetF =
+ CGM.getIntrinsic(Intrinsic::riscv_ime_vsetlambda_nonzero,
{ResultType});
Value *SetVal = Builder.CreateCall(SetF, {Req});
Builder.CreateBr(ContBB);
SetBB = Builder.GetInsertBlock();
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index 83b3b1b5b..1093bf7a0 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -11619,9 +11619,10 @@ static unsigned
getKnownIMEImplementationLambda(unsigned VLenBits) {
//
// encoded 0 -> lambda 0
// encoded n -> lambda 1 << (n - 1), for n in [1, 7]
-static SDValue decodeSelectedIMELambdaFromVType(
- SDValue VType, const SDLoc &DL, SelectionDAG &DAG,
- const RISCVSubtarget &Subtarget) {
+static SDValue
+decodeSelectedIMELambdaFromVType(SDValue VType, const SDLoc &DL,
+ SelectionDAG &DAG,
+ const RISCVSubtarget &Subtarget) {
MVT XLenVT = Subtarget.getXLenVT();
SDValue Encoded =
DAG.getNode(ISD::SRL, DL, XLenVT, VType,
@@ -11631,14 +11632,12 @@ static SDValue decodeSelectedIMELambdaFromVType(
SDValue Zero = DAG.getConstant(0, DL, XLenVT);
SDValue IsZero = DAG.getSetCC(DL, XLenVT, Encoded, Zero, ISD::SETEQ);
- SDValue ShiftAmt =
- DAG.getNode(ISD::SUB, DL, XLenVT, Encoded,
- DAG.getConstant(1, DL, XLenVT));
+ SDValue ShiftAmt = DAG.getNode(ISD::SUB, DL, XLenVT, Encoded,
+ DAG.getConstant(1, DL, XLenVT));
ShiftAmt = DAG.getSelect(DL, XLenVT, IsZero, Zero, ShiftAmt);
- SDValue Lambda =
- DAG.getNode(ISD::SHL, DL, XLenVT, DAG.getConstant(1, DL, XLenVT),
- ShiftAmt);
+ SDValue Lambda = DAG.getNode(ISD::SHL, DL, XLenVT,
+ DAG.getConstant(1, DL, XLenVT), ShiftAmt);
return DAG.getSelect(DL, XLenVT, IsZero, Zero, Lambda);
}
@@ -11702,29 +11701,26 @@ static SDValue lowerIMEImplementationLambda(SDValue
Op, SelectionDAG &DAG,
SDValue Lambda;
if (std::optional<unsigned> KnownVLen = Subtarget.getRealVLen()) {
- Lambda =
- DAG.getConstant(getKnownIMEImplementationLambda(*KnownVLen), DL,
XLenVT);
+ Lambda = DAG.getConstant(getKnownIMEImplementationLambda(*KnownVLen), DL,
+ XLenVT);
} else {
SDValue VLenB = DAG.getNode(RISCVISD::READ_VLENB, DL, XLenVT);
SDValue Ctz = DAG.getNode(ISD::CTTZ_ZERO_POISON, DL, XLenVT, VLenB);
SDValue Three = DAG.getConstant(3, DL, XLenVT);
SDValue IsSmall = DAG.getSetCC(DL, XLenVT, Ctz, Three, ISD::SETULT);
- SDValue LambdaLog2 =
- DAG.getNode(ISD::SUB, DL, XLenVT, Ctz, Three);
+ SDValue LambdaLog2 = DAG.getNode(ISD::SUB, DL, XLenVT, Ctz, Three);
LambdaLog2 = DAG.getSelect(DL, XLenVT, IsSmall,
DAG.getConstant(0, DL, XLenVT), LambdaLog2);
- LambdaLog2 =
- DAG.getNode(ISD::SRL, DL, XLenVT, LambdaLog2,
- DAG.getConstant(1, DL, XLenVT));
+ LambdaLog2 = DAG.getNode(ISD::SRL, DL, XLenVT, LambdaLog2,
+ DAG.getConstant(1, DL, XLenVT));
SDValue Six = DAG.getConstant(6, DL, XLenVT);
- SDValue IsTooLarge =
- DAG.getSetCC(DL, XLenVT, LambdaLog2, Six, ISD::SETUGT);
+ SDValue IsTooLarge = DAG.getSetCC(DL, XLenVT, LambdaLog2, Six,
ISD::SETUGT);
LambdaLog2 = DAG.getSelect(DL, XLenVT, IsTooLarge, Six, LambdaLog2);
- Lambda = DAG.getNode(ISD::SHL, DL, XLenVT,
- DAG.getConstant(1, DL, XLenVT), LambdaLog2);
+ Lambda = DAG.getNode(ISD::SHL, DL, XLenVT, DAG.getConstant(1, DL, XLenVT),
+ LambdaLog2);
}
return Lambda;
@@ -11769,11 +11765,10 @@ static SDValue encodeRuntimeIMELambda(SDValue
Requested, const SDLoc &DL,
SDValue Encoded = DAG.getConstant(0, DL, XLenVT);
auto SelectIfEq = [&](uint64_t Value, unsigned Enc) {
- SDValue IsEq =
- DAG.getSetCC(DL, XLenVT, Requested,
- DAG.getConstant(Value, DL, XLenVT), ISD::SETEQ);
- Encoded = DAG.getSelect(DL, XLenVT, IsEq,
- DAG.getConstant(Enc, DL, XLenVT), Encoded);
+ SDValue IsEq = DAG.getSetCC(DL, XLenVT, Requested,
+ DAG.getConstant(Value, DL, XLenVT),
ISD::SETEQ);
+ Encoded = DAG.getSelect(DL, XLenVT, IsEq, DAG.getConstant(Enc, DL, XLenVT),
+ Encoded);
};
SelectIfEq(1, 1);
@@ -11815,26 +11810,23 @@ static SDValue lowerIMEVSetLambdaNonZero(SDValue Op,
SelectionDAG &DAG,
if (auto *C = dyn_cast<ConstantSDNode>(Requested)) {
uint64_t Value = C->getZExtValue();
if (!isValidIMELambdaValue(Value))
- report_fatal_error(
- "invalid constant requested lambda for "
- "llvm.riscv.ime.vsetlambda.nonzero");
+ report_fatal_error("invalid constant requested lambda for "
+ "llvm.riscv.ime.vsetlambda.nonzero");
Encoded = DAG.getConstant(Log2_64(Value) + 1, DL, XLenVT);
} else {
Encoded = encodeRuntimeIMELambda(Requested, DL, DAG, Subtarget, XLenVT);
}
- SDValue Cleared =
- DAG.getNode(ISD::AND, DL, XLenVT, OldVType,
- DAG.getConstant(getIMEClearLambdaMask(Subtarget), DL,
- XLenVT));
+ SDValue Cleared = DAG.getNode(
+ ISD::AND, DL, XLenVT, OldVType,
+ DAG.getConstant(getIMEClearLambdaMask(Subtarget), DL, XLenVT));
SDValue EncodedBits =
DAG.getNode(ISD::SHL, DL, XLenVT, Encoded,
DAG.getConstant(getIMELambdaShift(Subtarget), DL, XLenVT));
SDValue NewVType = DAG.getNode(ISD::OR, DL, XLenVT, Cleared, EncodedBits);
- Chain = DAG.getNode(RISCVISD::IME_VSETVTYPE, DL, MVT::Other, Chain,
- NewVType);
+ Chain = DAG.getNode(RISCVISD::IME_VSETVTYPE, DL, MVT::Other, Chain,
NewVType);
SDValue UpdatedVType = readIMEVType(Chain, DL, DAG, Subtarget);
Chain = UpdatedVType.getValue(1);
``````````
</details>
https://github.com/llvm/llvm-project/pull/203774
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
