[RISCV] Override TargetLowering::BuildSDIVPow2 to generate SELECT

[• pcwang-thead]

Summary

When Zbt is enabled, we can generate SELECT for division by power
of 2, so that there is no data dependency.

[craig.topper]

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

10357

Capitalize 'only'

10367

Is i64 correct here for RV32? I don't see a test case.

10368

Use APInt::isNegatedPowerOf2

llvm/test/CodeGen/RISCV/rv32zbt-div-pow2.ll

1 ↗

(On Diff #390952)

Can you add test cases for dividing by 2 and -2 as well? X86 does not use BuildSDIVPow2 for those cases so we should check those.

[luismarques]

This should probably be disabled for minsize.

[jrtc27]

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

10358

Should say *why*, ie need conditional move

10362

X86 prioritises isIntDivCheap over a lack of conditional move; what's the justification for doing it the other way round?

10368

X86 asserts it's one of the two, so this check seems bogus given the function name...

llvm/test/CodeGen/RISCV/rv32zbt-div-pow2.ll

7 ↗

(On Diff #390952)

No positive power of 2 tests, and no tests for isIntDivCheap being true?

llvm/test/CodeGen/RISCV/rv64zbt-div-pow2.ll

8 ↗

(On Diff #390952)

Don't duplicate tests, just add rv64 check lines to your existing rv32-only test

31 ↗

(On Diff #390952)

And we should test we don't do stupid things for i64 on RV32

[craig.topper]

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

10362

I agree with @jrtc27. The isIntDivCheap check should be at the top.

10368

I think AArch64 explicitly checks it. I wrote X86 later and used an assert.

llvm/test/CodeGen/RISCV/rv32zbt-div-pow2.ll

7 ↗

(On Diff #390952)

isIntDivCheap is never true for RISCV today.

We should also add a test for dividing by 4096 or larger for RV32 and RV64. And probably something larger than 2^32 for RV64. The constant materialization will add additional instructions not seen in the 1024 case.

[craig.topper]

In D114856#3179772, @luismarques wrote:

This should probably be disabled for minsize.

That's what several targets use isIntDivCheap for. I don't think RISCV does. The patch here doesn't make that situation worse.

[• pcwang-thead]

• Address comments.
• Only apply to divisors whose absolute value is less than 2^12.

[jrtc27]

Some of the i32 ones look like they might not be profitable on RV64 unless you have a wide out-of-order processor; 50% more instructions in some cases

[• pcwang-thead]

In D114856#3188850, @jrtc27 wrote:

Some of the i32 ones look like they might not be profitable on RV64 unless you have a wide out-of-order processor; 50% more instructions in some cases

For i32 on RV64, sign extension is needed, so there are sext.w. And the only case with 50% more instructions is when divisor is 2.
Maybe we should skip these divisors, any ideas?

llvm/test/CodeGen/RISCV/rv32zbt-div-pow2.ll

7 ↗

(On Diff #390952)

isIntDivCheap is never true for RISCV today.

We should also add a test for dividing by 4096 or larger for RV32 and RV64. And probably something larger than 2^32 for RV64. The constant materialization will add additional instructions not seen in the 1024 case.

7 ↗

(On Diff #390952)

Thanks.

I added tests divided by n (|n| ≥ 2^12) and two materialization instructions were generated. So it may be non-profitable when absolute values of divisors are larger than 2^12.

[craig.topper]

llvm/test/CodeGen/RISCV/div-pow2.ll

15

I think it makes sense to keep the old codegen when dividing by 2.

59

Original code is less instructions and has the same critical path instruction count.

356

Original code looks better.

407

Original code looks better

[• pcwang-thead]

• Address comments.

[• pcwang-thead]

ping

[jrtc27]

From the LLVM Code-Review Policy and Practices (https://llvm.org/docs/CodeReview.html):

If it is urgent, provide reasons why it is important to you to get this patch landed and ping it every couple of days. If it is not urgent, the common courtesy ping rate is one week. Remember that you’re asking for valuable time from other professional developers.

It's only been 3 days for this and other patches you've just pinged

[• pcwang-thead]

In D114856#3196325, @jrtc27 wrote:

From the LLVM Code-Review Policy and Practices (https://llvm.org/docs/CodeReview.html):

If it is urgent, provide reasons why it is important to you to get this patch landed and ping it every couple of days. If it is not urgent, the common courtesy ping rate is one week. Remember that you’re asking for valuable time from other professional developers.

It's only been 3 days for this and other patches you've just pinged

Sorry, my bad. It's not so urgent.

[craig.topper]

LGTM

llvm/lib/Target/RISCV/RISCVISelLowering.h

public:
   MVT getContainerForFixedLengthVector(MVT VT) const;
 
   bool shouldRemoveExtendFromGSIndex(EVT VT) const override;
 
   bool isLegalElementTypeForRVV(Type *ScalarTy) const;
 
   bool shouldConvertFpToSat(unsigned Op, EVT FPVT, EVT VT) const override;
 
+  SDValue BuildSDIVPow2(SDNode *N, const APInt &Divisor, SelectionDAG &DAG,
+                        SmallVectorImpl<SDNode *> &Created) const override;
+
 private:
   /// RISCVCCAssignFn - This target-specific function extends the default
   /// CCValAssign with additional information used to lower RISC-V calling
   /// conventions.
   typedef bool RISCVCCAssignFn(const DataLayout &DL, RISCVABI::ABI,
                                unsigned ValNo, MVT ValVT, MVT LocVT,
                                CCValAssign::LocInfo LocInfo,
                                ISD::ArgFlagsTy ArgFlags, CCState &State,

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

if (PartVTBitSize % ValueVTBitSize == 0) {
       Val = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ValueVT, Val,
                         DAG.getVectorIdxConstant(0, DL));
       return Val;
     }
   }
   return SDValue();
 }
 
+SDValue
+RISCVTargetLowering::BuildSDIVPow2(SDNode *N, const APInt &Divisor,
+                                   SelectionDAG &DAG,
+                                   SmallVectorImpl<SDNode *> &Created) const {
+  AttributeList Attr = DAG.getMachineFunction().getFunction().getAttributes();
+  if (isIntDivCheap(N->getValueType(0), Attr))
+    return SDValue(N, 0); // Lower SDIV as SDIV
+
+  assert((Divisor.isPowerOf2() || Divisor.isNegatedPowerOf2()) &&
+         "Unexpected divisor!");
+
+  // Conditional move is needed, so do the transformation iff Zbt is enabled.
+  if (!Subtarget.hasStdExtZbt())
+    return SDValue();
+
+  // When |Divisor| >= 2 ^ 12, it isn't profitable to do such transformation.
+  // Besides, more critical path instructions will be generated when dividing
+  // by 2. So we keep using the original DAGs for these cases.
+  unsigned Lg2 = Divisor.countTrailingZeros();
+  if (Lg2 == 1 || Lg2 >= 12)
+    return SDValue();
+
+  // fold (sdiv X, pow2)
+  EVT VT = N->getValueType(0);
+  if (VT != MVT::i32 && !(Subtarget.is64Bit() && VT == MVT::i64))
+    return SDValue();
+
+  SDLoc DL(N);
+  SDValue N0 = N->getOperand(0);
+  SDValue Zero = DAG.getConstant(0, DL, VT);
+  SDValue Pow2MinusOne = DAG.getConstant((1ULL << Lg2) - 1, DL, VT);
+
+  // Add (N0 < 0) ? Pow2 - 1 : 0;
+  SDValue Cmp = DAG.getSetCC(DL, VT, N0, Zero, ISD::SETLT);
+  SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0, Pow2MinusOne);
+  SDValue Sel = DAG.getNode(ISD::SELECT, DL, VT, Cmp, Add, N0);
+
+  Created.push_back(Cmp.getNode());
+  Created.push_back(Add.getNode());
+  Created.push_back(Sel.getNode());
+
+  // Divide by pow2.
+  SDValue SRA =
+      DAG.getNode(ISD::SRA, DL, VT, Sel, DAG.getConstant(Lg2, DL, VT));
+
+  // If we're dividing by a positive value, we're done.  Otherwise, we must
+  // negate the result.
+  if (Divisor.isNonNegative())
+    return SRA;
+
+  Created.push_back(SRA.getNode());
+  return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), SRA);
+}
+
 #define GET_REGISTER_MATCHER
 #include "RISCVGenAsmMatcher.inc"
 
 Register
 RISCVTargetLowering::getRegisterByName(const char *RegName, LLT VT,
                                        const MachineFunction &MF) const {
   Register Reg = MatchRegisterAltName(RegName);
   if (Reg == RISCV::NoRegister)

llvm/test/CodeGen/RISCV/div-pow2.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -mtriple=riscv32 -verify-machineinstrs < %s \
+; RUN:   | FileCheck %s -check-prefix=RV32I
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbt -verify-machineinstrs < %s \
+; RUN:   | FileCheck %s -check-prefix=RV32ZBT
+; RUN: llc -mtriple=riscv64 -verify-machineinstrs < %s \
+; RUN:   | FileCheck %s -check-prefix=RV64I
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbt -verify-machineinstrs < %s \
+; RUN:   | FileCheck %s -check-prefix=RV64ZBT
+
+define i32 @sdiv32_pow2_2(i32 %a) {
+; RV32I-LABEL: sdiv32_pow2_2:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srli a1, a0, 31
+; RV32I-NEXT:    add a0, a0, a1
+; RV32I-NEXT:    srai a0, a0, 1
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv32_pow2_2:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srli a1, a0, 31
+; RV32ZBT-NEXT:    add a0, a0, a1
+; RV32ZBT-NEXT:    srai a0, a0, 1
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv32_pow2_2:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srliw a1, a0, 31
+; RV64I-NEXT:    addw a0, a0, a1
+; RV64I-NEXT:    sraiw a0, a0, 1
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv32_pow2_2:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srliw a1, a0, 31
+; RV64ZBT-NEXT:    addw a0, a0, a1
+; RV64ZBT-NEXT:    sraiw a0, a0, 1
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i32 %a, 2
+  ret i32 %div
+}
+
+define i32 @sdiv32_pow2_negative_2(i32 %a) {
+; RV32I-LABEL: sdiv32_pow2_negative_2:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srli a1, a0, 31
+; RV32I-NEXT:    add a0, a0, a1
+; RV32I-NEXT:    srai a0, a0, 1
+; RV32I-NEXT:    neg a0, a0
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv32_pow2_negative_2:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srli a1, a0, 31
+; RV32ZBT-NEXT:    add a0, a0, a1
+; RV32ZBT-NEXT:    srai a0, a0, 1
+; RV32ZBT-NEXT:    neg a0, a0
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv32_pow2_negative_2:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srliw a1, a0, 31
+; RV64I-NEXT:    addw a0, a0, a1
+; RV64I-NEXT:    sraiw a0, a0, 1
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv32_pow2_negative_2:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srliw a1, a0, 31
+; RV64ZBT-NEXT:    addw a0, a0, a1
+; RV64ZBT-NEXT:    sraiw a0, a0, 1
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i32 %a, -2
+  ret i32 %div
+}
+
+define i32 @sdiv32_pow2_2048(i32 %a) {
+; RV32I-LABEL: sdiv32_pow2_2048:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a1, a0, 31
+; RV32I-NEXT:    srli a1, a1, 21
+; RV32I-NEXT:    add a0, a0, a1
+; RV32I-NEXT:    srai a0, a0, 11
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv32_pow2_2048:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    slti a1, a0, 0
+; RV32ZBT-NEXT:    addi a2, a0, 2047
+; RV32ZBT-NEXT:    cmov a0, a1, a2, a0
+; RV32ZBT-NEXT:    srai a0, a0, 11
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv32_pow2_2048:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    sraiw a1, a0, 31
+; RV64I-NEXT:    srliw a1, a1, 21
+; RV64I-NEXT:    addw a0, a0, a1
+; RV64I-NEXT:    sraiw a0, a0, 11
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv32_pow2_2048:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    sext.w a1, a0
+; RV64ZBT-NEXT:    addi a2, a0, 2047
+; RV64ZBT-NEXT:    slti a1, a1, 0
+; RV64ZBT-NEXT:    cmov a0, a1, a2, a0
+; RV64ZBT-NEXT:    sraiw a0, a0, 11
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i32 %a, 2048
+  ret i32 %div
+}
+
+define i32 @sdiv32_pow2_negative_2048(i32 %a) {
+; RV32I-LABEL: sdiv32_pow2_negative_2048:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a1, a0, 31
+; RV32I-NEXT:    srli a1, a1, 21
+; RV32I-NEXT:    add a0, a0, a1
+; RV32I-NEXT:    srai a0, a0, 11
+; RV32I-NEXT:    neg a0, a0
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv32_pow2_negative_2048:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    slti a1, a0, 0
+; RV32ZBT-NEXT:    addi a2, a0, 2047
+; RV32ZBT-NEXT:    cmov a0, a1, a2, a0
+; RV32ZBT-NEXT:    srai a0, a0, 11
+; RV32ZBT-NEXT:    neg a0, a0
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv32_pow2_negative_2048:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    sraiw a1, a0, 31
+; RV64I-NEXT:    srliw a1, a1, 21
+; RV64I-NEXT:    addw a0, a0, a1
+; RV64I-NEXT:    sraiw a0, a0, 11
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv32_pow2_negative_2048:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    sext.w a1, a0
+; RV64ZBT-NEXT:    addi a2, a0, 2047
+; RV64ZBT-NEXT:    slti a1, a1, 0
+; RV64ZBT-NEXT:    cmov a0, a1, a2, a0
+; RV64ZBT-NEXT:    sraiw a0, a0, 11
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i32 %a, -2048
+  ret i32 %div
+}
+
+define i32 @sdiv32_pow2_4096(i32 %a) {
+; RV32I-LABEL: sdiv32_pow2_4096:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a1, a0, 31
+; RV32I-NEXT:    srli a1, a1, 20
+; RV32I-NEXT:    add a0, a0, a1
+; RV32I-NEXT:    srai a0, a0, 12
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv32_pow2_4096:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a1, a0, 31
+; RV32ZBT-NEXT:    srli a1, a1, 20
+; RV32ZBT-NEXT:    add a0, a0, a1
+; RV32ZBT-NEXT:    srai a0, a0, 12
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv32_pow2_4096:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    sraiw a1, a0, 31
+; RV64I-NEXT:    srliw a1, a1, 20
+; RV64I-NEXT:    addw a0, a0, a1
+; RV64I-NEXT:    sraiw a0, a0, 12
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv32_pow2_4096:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    sraiw a1, a0, 31
+; RV64ZBT-NEXT:    srliw a1, a1, 20
+; RV64ZBT-NEXT:    addw a0, a0, a1
+; RV64ZBT-NEXT:    sraiw a0, a0, 12
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i32 %a, 4096
+  ret i32 %div
+}
+
+define i32 @sdiv32_pow2_negative_4096(i32 %a) {
+; RV32I-LABEL: sdiv32_pow2_negative_4096:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a1, a0, 31
+; RV32I-NEXT:    srli a1, a1, 20
+; RV32I-NEXT:    add a0, a0, a1
+; RV32I-NEXT:    srai a0, a0, 12
+; RV32I-NEXT:    neg a0, a0
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv32_pow2_negative_4096:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a1, a0, 31
+; RV32ZBT-NEXT:    srli a1, a1, 20
+; RV32ZBT-NEXT:    add a0, a0, a1
+; RV32ZBT-NEXT:    srai a0, a0, 12
+; RV32ZBT-NEXT:    neg a0, a0
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv32_pow2_negative_4096:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    sraiw a1, a0, 31
+; RV64I-NEXT:    srliw a1, a1, 20
+; RV64I-NEXT:    addw a0, a0, a1
+; RV64I-NEXT:    sraiw a0, a0, 12
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv32_pow2_negative_4096:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    sraiw a1, a0, 31
+; RV64ZBT-NEXT:    srliw a1, a1, 20
+; RV64ZBT-NEXT:    addw a0, a0, a1
+; RV64ZBT-NEXT:    sraiw a0, a0, 12
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i32 %a, -4096
+  ret i32 %div
+}
+
+define i32 @sdiv32_pow2_65536(i32 %a) {
+; RV32I-LABEL: sdiv32_pow2_65536:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a1, a0, 31
+; RV32I-NEXT:    srli a1, a1, 16
+; RV32I-NEXT:    add a0, a0, a1
+; RV32I-NEXT:    srai a0, a0, 16
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv32_pow2_65536:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a1, a0, 31
+; RV32ZBT-NEXT:    srli a1, a1, 16
+; RV32ZBT-NEXT:    add a0, a0, a1
+; RV32ZBT-NEXT:    srai a0, a0, 16
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv32_pow2_65536:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    sraiw a1, a0, 31
+; RV64I-NEXT:    srliw a1, a1, 16
+; RV64I-NEXT:    addw a0, a0, a1
+; RV64I-NEXT:    sraiw a0, a0, 16
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv32_pow2_65536:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    sraiw a1, a0, 31
+; RV64ZBT-NEXT:    srliw a1, a1, 16
+; RV64ZBT-NEXT:    addw a0, a0, a1
+; RV64ZBT-NEXT:    sraiw a0, a0, 16
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i32 %a, 65536
+  ret i32 %div
+}
+
+define i32 @sdiv32_pow2_negative_65536(i32 %a) {
+; RV32I-LABEL: sdiv32_pow2_negative_65536:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a1, a0, 31
+; RV32I-NEXT:    srli a1, a1, 16
+; RV32I-NEXT:    add a0, a0, a1
+; RV32I-NEXT:    srai a0, a0, 16
+; RV32I-NEXT:    neg a0, a0
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv32_pow2_negative_65536:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a1, a0, 31
+; RV32ZBT-NEXT:    srli a1, a1, 16
+; RV32ZBT-NEXT:    add a0, a0, a1
+; RV32ZBT-NEXT:    srai a0, a0, 16
+; RV32ZBT-NEXT:    neg a0, a0
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv32_pow2_negative_65536:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    sraiw a1, a0, 31
+; RV64I-NEXT:    srliw a1, a1, 16
+; RV64I-NEXT:    addw a0, a0, a1
+; RV64I-NEXT:    sraiw a0, a0, 16
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv32_pow2_negative_65536:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    sraiw a1, a0, 31
+; RV64ZBT-NEXT:    srliw a1, a1, 16
+; RV64ZBT-NEXT:    addw a0, a0, a1
+; RV64ZBT-NEXT:    sraiw a0, a0, 16
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i32 %a, -65536
+  ret i32 %div
+}
+
+define i64 @sdiv64_pow2_2(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_2:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srli a2, a1, 31
+; RV32I-NEXT:    add a2, a0, a2
+; RV32I-NEXT:    srli a3, a2, 1
+; RV32I-NEXT:    sltu a0, a2, a0
+; RV32I-NEXT:    add a1, a1, a0
+; RV32I-NEXT:    slli a0, a1, 31
+; RV32I-NEXT:    or a0, a3, a0
+; RV32I-NEXT:    srai a1, a1, 1
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_2:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srli a2, a1, 31
+; RV32ZBT-NEXT:    add a2, a0, a2
+; RV32ZBT-NEXT:    sltu a0, a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a0
+; RV32ZBT-NEXT:    fsri a0, a2, a1, 1
+; RV32ZBT-NEXT:    srai a1, a1, 1
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_2:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srli a1, a0, 63
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 1
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_2:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srli a1, a0, 63
+; RV64ZBT-NEXT:    add a0, a0, a1
+; RV64ZBT-NEXT:    srai a0, a0, 1
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, 2
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_negative_2(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_negative_2:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srli a2, a1, 31
+; RV32I-NEXT:    add a2, a0, a2
+; RV32I-NEXT:    srli a3, a2, 1
+; RV32I-NEXT:    sltu a0, a2, a0
+; RV32I-NEXT:    add a1, a1, a0
+; RV32I-NEXT:    slli a0, a1, 31
+; RV32I-NEXT:    or a2, a3, a0
+; RV32I-NEXT:    neg a0, a2
+; RV32I-NEXT:    snez a2, a2
+; RV32I-NEXT:    srai a1, a1, 1
+; RV32I-NEXT:    add a1, a1, a2
+; RV32I-NEXT:    neg a1, a1
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_negative_2:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srli a2, a1, 31
+; RV32ZBT-NEXT:    add a2, a0, a2
+; RV32ZBT-NEXT:    sltu a0, a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a0
+; RV32ZBT-NEXT:    fsri a2, a2, a1, 1
+; RV32ZBT-NEXT:    neg a0, a2
+; RV32ZBT-NEXT:    snez a2, a2
+; RV32ZBT-NEXT:    srai a1, a1, 1
+; RV32ZBT-NEXT:    add a1, a1, a2
+; RV32ZBT-NEXT:    neg a1, a1
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_negative_2:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srli a1, a0, 63
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 1
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_negative_2:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srli a1, a0, 63
+; RV64ZBT-NEXT:    add a0, a0, a1
+; RV64ZBT-NEXT:    srai a0, a0, 1
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, -2
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_2048(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_2048:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a2, a1, 31
+; RV32I-NEXT:    srli a2, a2, 21
+; RV32I-NEXT:    add a2, a0, a2
+; RV32I-NEXT:    srli a3, a2, 11
+; RV32I-NEXT:    sltu a0, a2, a0
+; RV32I-NEXT:    add a1, a1, a0
+; RV32I-NEXT:    slli a0, a1, 21
+; RV32I-NEXT:    or a0, a3, a0
+; RV32I-NEXT:    srai a1, a1, 11
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_2048:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a2, a1, 31
+; RV32ZBT-NEXT:    srli a2, a2, 21
+; RV32ZBT-NEXT:    add a2, a0, a2
+; RV32ZBT-NEXT:    sltu a0, a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a0
+; RV32ZBT-NEXT:    fsri a0, a2, a1, 11
+; RV32ZBT-NEXT:    srai a1, a1, 11
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_2048:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srai a1, a0, 63
+; RV64I-NEXT:    srli a1, a1, 53
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 11
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_2048:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    slti a1, a0, 0
+; RV64ZBT-NEXT:    addi a2, a0, 2047
+; RV64ZBT-NEXT:    cmov a0, a1, a2, a0
+; RV64ZBT-NEXT:    srai a0, a0, 11
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, 2048
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_negative_2048(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_negative_2048:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a2, a1, 31
+; RV32I-NEXT:    srli a2, a2, 21
+; RV32I-NEXT:    add a2, a0, a2
+; RV32I-NEXT:    srli a3, a2, 11
+; RV32I-NEXT:    sltu a0, a2, a0
+; RV32I-NEXT:    add a1, a1, a0
+; RV32I-NEXT:    slli a0, a1, 21
+; RV32I-NEXT:    or a2, a3, a0
+; RV32I-NEXT:    neg a0, a2
+; RV32I-NEXT:    snez a2, a2
+; RV32I-NEXT:    srai a1, a1, 11
+; RV32I-NEXT:    add a1, a1, a2
+; RV32I-NEXT:    neg a1, a1
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_negative_2048:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a2, a1, 31
+; RV32ZBT-NEXT:    srli a2, a2, 21
+; RV32ZBT-NEXT:    add a2, a0, a2
+; RV32ZBT-NEXT:    sltu a0, a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a0
+; RV32ZBT-NEXT:    fsri a2, a2, a1, 11
+; RV32ZBT-NEXT:    neg a0, a2
+; RV32ZBT-NEXT:    snez a2, a2
+; RV32ZBT-NEXT:    srai a1, a1, 11
+; RV32ZBT-NEXT:    add a1, a1, a2
+; RV32ZBT-NEXT:    neg a1, a1
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_negative_2048:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srai a1, a0, 63
+; RV64I-NEXT:    srli a1, a1, 53
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 11
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_negative_2048:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    slti a1, a0, 0
+; RV64ZBT-NEXT:    addi a2, a0, 2047
+; RV64ZBT-NEXT:    cmov a0, a1, a2, a0
+; RV64ZBT-NEXT:    srai a0, a0, 11
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, -2048
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_4096(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_4096:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a2, a1, 31
+; RV32I-NEXT:    srli a2, a2, 20
+; RV32I-NEXT:    add a2, a0, a2
+; RV32I-NEXT:    srli a3, a2, 12
+; RV32I-NEXT:    sltu a0, a2, a0
+; RV32I-NEXT:    add a1, a1, a0
+; RV32I-NEXT:    slli a0, a1, 20
+; RV32I-NEXT:    or a0, a3, a0
+; RV32I-NEXT:    srai a1, a1, 12
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_4096:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a2, a1, 31
+; RV32ZBT-NEXT:    srli a2, a2, 20
+; RV32ZBT-NEXT:    add a2, a0, a2
+; RV32ZBT-NEXT:    sltu a0, a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a0
+; RV32ZBT-NEXT:    fsri a0, a2, a1, 12
+; RV32ZBT-NEXT:    srai a1, a1, 12
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_4096:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srai a1, a0, 63
+; RV64I-NEXT:    srli a1, a1, 52
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 12
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_4096:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srai a1, a0, 63
+; RV64ZBT-NEXT:    srli a1, a1, 52
+; RV64ZBT-NEXT:    add a0, a0, a1
+; RV64ZBT-NEXT:    srai a0, a0, 12
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, 4096
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_negative_4096(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_negative_4096:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a2, a1, 31
+; RV32I-NEXT:    srli a2, a2, 20
+; RV32I-NEXT:    add a2, a0, a2
+; RV32I-NEXT:    srli a3, a2, 12
+; RV32I-NEXT:    sltu a0, a2, a0
+; RV32I-NEXT:    add a1, a1, a0
+; RV32I-NEXT:    slli a0, a1, 20
+; RV32I-NEXT:    or a2, a3, a0
+; RV32I-NEXT:    neg a0, a2
+; RV32I-NEXT:    snez a2, a2
+; RV32I-NEXT:    srai a1, a1, 12
+; RV32I-NEXT:    add a1, a1, a2
+; RV32I-NEXT:    neg a1, a1
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_negative_4096:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a2, a1, 31
+; RV32ZBT-NEXT:    srli a2, a2, 20
+; RV32ZBT-NEXT:    add a2, a0, a2
+; RV32ZBT-NEXT:    sltu a0, a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a0
+; RV32ZBT-NEXT:    fsri a2, a2, a1, 12
+; RV32ZBT-NEXT:    neg a0, a2
+; RV32ZBT-NEXT:    snez a2, a2
+; RV32ZBT-NEXT:    srai a1, a1, 12
+; RV32ZBT-NEXT:    add a1, a1, a2
+; RV32ZBT-NEXT:    neg a1, a1
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_negative_4096:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srai a1, a0, 63
+; RV64I-NEXT:    srli a1, a1, 52
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 12
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_negative_4096:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srai a1, a0, 63
+; RV64ZBT-NEXT:    srli a1, a1, 52
+; RV64ZBT-NEXT:    add a0, a0, a1
+; RV64ZBT-NEXT:    srai a0, a0, 12
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, -4096
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_65536(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_65536:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a2, a1, 31
+; RV32I-NEXT:    srli a2, a2, 16
+; RV32I-NEXT:    add a2, a0, a2
+; RV32I-NEXT:    srli a3, a2, 16
+; RV32I-NEXT:    sltu a0, a2, a0
+; RV32I-NEXT:    add a1, a1, a0
+; RV32I-NEXT:    slli a0, a1, 16
+; RV32I-NEXT:    or a0, a3, a0
+; RV32I-NEXT:    srai a1, a1, 16
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_65536:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a2, a1, 31
+; RV32ZBT-NEXT:    srli a2, a2, 16
+; RV32ZBT-NEXT:    add a2, a0, a2
+; RV32ZBT-NEXT:    sltu a0, a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a0
+; RV32ZBT-NEXT:    fsri a0, a2, a1, 16
+; RV32ZBT-NEXT:    srai a1, a1, 16
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_65536:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srai a1, a0, 63
+; RV64I-NEXT:    srli a1, a1, 48
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 16
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_65536:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srai a1, a0, 63
+; RV64ZBT-NEXT:    srli a1, a1, 48
+; RV64ZBT-NEXT:    add a0, a0, a1
+; RV64ZBT-NEXT:    srai a0, a0, 16
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, 65536
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_negative_65536(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_negative_65536:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srai a2, a1, 31
+; RV32I-NEXT:    srli a2, a2, 16
+; RV32I-NEXT:    add a2, a0, a2
+; RV32I-NEXT:    srli a3, a2, 16
+; RV32I-NEXT:    sltu a0, a2, a0
+; RV32I-NEXT:    add a1, a1, a0
+; RV32I-NEXT:    slli a0, a1, 16
+; RV32I-NEXT:    or a2, a3, a0
+; RV32I-NEXT:    neg a0, a2
+; RV32I-NEXT:    snez a2, a2
+; RV32I-NEXT:    srai a1, a1, 16
+; RV32I-NEXT:    add a1, a1, a2
+; RV32I-NEXT:    neg a1, a1
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_negative_65536:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srai a2, a1, 31
+; RV32ZBT-NEXT:    srli a2, a2, 16
+; RV32ZBT-NEXT:    add a2, a0, a2
+; RV32ZBT-NEXT:    sltu a0, a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a0
+; RV32ZBT-NEXT:    fsri a2, a2, a1, 16
+; RV32ZBT-NEXT:    neg a0, a2
+; RV32ZBT-NEXT:    snez a2, a2
+; RV32ZBT-NEXT:    srai a1, a1, 16
+; RV32ZBT-NEXT:    add a1, a1, a2
+; RV32ZBT-NEXT:    neg a1, a1
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_negative_65536:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srai a1, a0, 63
+; RV64I-NEXT:    srli a1, a1, 48
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 16
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_negative_65536:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srai a1, a0, 63
+; RV64ZBT-NEXT:    srli a1, a1, 48
+; RV64ZBT-NEXT:    add a0, a0, a1
+; RV64ZBT-NEXT:    srai a0, a0, 16
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, -65536
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_8589934592(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_8589934592:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srli a2, a1, 31
+; RV32I-NEXT:    add a2, a1, a2
+; RV32I-NEXT:    srai a1, a1, 31
+; RV32I-NEXT:    add a1, a0, a1
+; RV32I-NEXT:    sltu a0, a1, a0
+; RV32I-NEXT:    add a1, a2, a0
+; RV32I-NEXT:    srai a0, a1, 1
+; RV32I-NEXT:    srai a1, a1, 31
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_8589934592:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srli a2, a1, 31
+; RV32ZBT-NEXT:    add a2, a1, a2
+; RV32ZBT-NEXT:    srai a1, a1, 31
+; RV32ZBT-NEXT:    fsri a1, a1, a1, 31
+; RV32ZBT-NEXT:    add a1, a0, a1
+; RV32ZBT-NEXT:    sltu a0, a1, a0
+; RV32ZBT-NEXT:    add a1, a2, a0
+; RV32ZBT-NEXT:    srai a0, a1, 1
+; RV32ZBT-NEXT:    srai a1, a1, 31
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_8589934592:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srai a1, a0, 63
+; RV64I-NEXT:    srli a1, a1, 31
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 33
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_8589934592:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srai a1, a0, 63
+; RV64ZBT-NEXT:    srli a1, a1, 31
+; RV64ZBT-NEXT:    add a0, a0, a1
+; RV64ZBT-NEXT:    srai a0, a0, 33
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, 8589934592 ; 2^33
+  ret i64 %div
+}
+
+define i64 @sdiv64_pow2_negative_8589934592(i64 %a) {
+; RV32I-LABEL: sdiv64_pow2_negative_8589934592:
+; RV32I:       # %bb.0: # %entry
+; RV32I-NEXT:    srli a2, a1, 31
+; RV32I-NEXT:    add a2, a1, a2
+; RV32I-NEXT:    srai a1, a1, 31
+; RV32I-NEXT:    add a1, a0, a1
+; RV32I-NEXT:    sltu a0, a1, a0
+; RV32I-NEXT:    add a0, a2, a0
+; RV32I-NEXT:    srai a1, a0, 31
+; RV32I-NEXT:    srai a0, a0, 1
+; RV32I-NEXT:    snez a2, a0
+; RV32I-NEXT:    add a1, a1, a2
+; RV32I-NEXT:    neg a1, a1
+; RV32I-NEXT:    neg a0, a0
+; RV32I-NEXT:    ret
+;
+; RV32ZBT-LABEL: sdiv64_pow2_negative_8589934592:
+; RV32ZBT:       # %bb.0: # %entry
+; RV32ZBT-NEXT:    srli a2, a1, 31
+; RV32ZBT-NEXT:    add a2, a1, a2
+; RV32ZBT-NEXT:    srai a1, a1, 31
+; RV32ZBT-NEXT:    fsri a1, a1, a1, 31
+; RV32ZBT-NEXT:    add a1, a0, a1
+; RV32ZBT-NEXT:    sltu a0, a1, a0
+; RV32ZBT-NEXT:    add a0, a2, a0
+; RV32ZBT-NEXT:    srai a1, a0, 31
+; RV32ZBT-NEXT:    srai a0, a0, 1
+; RV32ZBT-NEXT:    snez a2, a0
+; RV32ZBT-NEXT:    add a1, a1, a2
+; RV32ZBT-NEXT:    neg a1, a1
+; RV32ZBT-NEXT:    neg a0, a0
+; RV32ZBT-NEXT:    ret
+;
+; RV64I-LABEL: sdiv64_pow2_negative_8589934592:
+; RV64I:       # %bb.0: # %entry
+; RV64I-NEXT:    srai a1, a0, 63
+; RV64I-NEXT:    srli a1, a1, 31
+; RV64I-NEXT:    add a0, a0, a1
+; RV64I-NEXT:    srai a0, a0, 33
+; RV64I-NEXT:    neg a0, a0
+; RV64I-NEXT:    ret
+;
+; RV64ZBT-LABEL: sdiv64_pow2_negative_8589934592:
+; RV64ZBT:       # %bb.0: # %entry
+; RV64ZBT-NEXT:    srai a1, a0, 63
+; RV64ZBT-NEXT:    srli a1, a1, 31
+; RV64ZBT-NEXT:    add a0, a0, a1
+; RV64ZBT-NEXT:    srai a0, a0, 33
+; RV64ZBT-NEXT:    neg a0, a0
+; RV64ZBT-NEXT:    ret
+entry:
+  %div = sdiv i64 %a, -8589934592 ; -2^33
+  ret i64 %div
+}