return false;
}
-bool RISCVDAGToDAGISel::SelectRVVBaseAddr(SDValue Addr, SDValue &Base) {
+bool RISCVDAGToDAGISel::SelectBaseAddr(SDValue Addr, SDValue &Base) {
// If this is FrameIndex, select it directly. Otherwise just let it get
// selected to a register independently.
if (auto *FIN = dyn_cast<FrameIndexSDNode>(Addr))
std::vector<SDValue> &OutOps) override;
bool SelectAddrFI(SDValue Addr, SDValue &Base);
- bool SelectRVVBaseAddr(SDValue Addr, SDValue &Base);
+ bool SelectBaseAddr(SDValue Addr, SDValue &Base);
bool selectShiftMask(SDValue N, unsigned ShiftWidth, SDValue &ShAmt);
bool selectShiftMaskXLen(SDValue N, SDValue &ShAmt) {
// Addressing modes.
// Necessary because a frameindex can't be matched directly in a pattern.
def AddrFI : ComplexPattern<iPTR, 1, "SelectAddrFI", [frameindex], []>;
+def BaseAddr : ComplexPattern<iPTR, 1, "SelectBaseAddr">;
// Extract least significant 12 bits from an immediate value and sign extend
// them.
/// Loads
multiclass LdPat<PatFrag LoadOp, RVInst Inst> {
- def : Pat<(LoadOp GPR:$rs1), (Inst GPR:$rs1, 0)>;
- def : Pat<(LoadOp AddrFI:$rs1), (Inst AddrFI:$rs1, 0)>;
- def : Pat<(LoadOp (add GPR:$rs1, simm12:$imm12)),
- (Inst GPR:$rs1, simm12:$imm12)>;
- def : Pat<(LoadOp (add AddrFI:$rs1, simm12:$imm12)),
- (Inst AddrFI:$rs1, simm12:$imm12)>;
+ def : Pat<(LoadOp BaseAddr:$rs1), (Inst BaseAddr:$rs1, 0)>;
+ def : Pat<(LoadOp (add BaseAddr:$rs1, simm12:$imm12)),
+ (Inst BaseAddr:$rs1, simm12:$imm12)>;
def : Pat<(LoadOp (IsOrAdd AddrFI:$rs1, simm12:$imm12)),
(Inst AddrFI:$rs1, simm12:$imm12)>;
}
/// Stores
multiclass StPat<PatFrag StoreOp, RVInst Inst, RegisterClass StTy> {
- def : Pat<(StoreOp StTy:$rs2, GPR:$rs1), (Inst StTy:$rs2, GPR:$rs1, 0)>;
- def : Pat<(StoreOp StTy:$rs2, AddrFI:$rs1), (Inst StTy:$rs2, AddrFI:$rs1, 0)>;
- def : Pat<(StoreOp StTy:$rs2, (add GPR:$rs1, simm12:$imm12)),
- (Inst StTy:$rs2, GPR:$rs1, simm12:$imm12)>;
- def : Pat<(StoreOp StTy:$rs2, (add AddrFI:$rs1, simm12:$imm12)),
- (Inst StTy:$rs2, AddrFI:$rs1, simm12:$imm12)>;
+ def : Pat<(StoreOp StTy:$rs2, BaseAddr:$rs1), (Inst StTy:$rs2, BaseAddr:$rs1, 0)>;
+ def : Pat<(StoreOp StTy:$rs2, (add BaseAddr:$rs1, simm12:$imm12)),
+ (Inst StTy:$rs2, BaseAddr:$rs1, simm12:$imm12)>;
def : Pat<(StoreOp StTy:$rs2, (IsOrAdd AddrFI:$rs1, simm12:$imm12)),
(Inst StTy:$rs2, AddrFI:$rs1, simm12:$imm12)>;
}
}
multiclass AtomicStPat<PatFrag StoreOp, RVInst Inst, RegisterClass StTy> {
- def : Pat<(StoreOp GPR:$rs1, StTy:$rs2), (Inst StTy:$rs2, GPR:$rs1, 0)>;
- def : Pat<(StoreOp AddrFI:$rs1, StTy:$rs2), (Inst StTy:$rs2, AddrFI:$rs1, 0)>;
- def : Pat<(StoreOp (add GPR:$rs1, simm12:$imm12), StTy:$rs2),
- (Inst StTy:$rs2, GPR:$rs1, simm12:$imm12)>;
- def : Pat<(StoreOp (add AddrFI:$rs1, simm12:$imm12), StTy:$rs2),
- (Inst StTy:$rs2, AddrFI:$rs1, simm12:$imm12)>;
+ def : Pat<(StoreOp BaseAddr:$rs1, StTy:$rs2), (Inst StTy:$rs2, BaseAddr:$rs1, 0)>;
+ def : Pat<(StoreOp (add BaseAddr:$rs1, simm12:$imm12), StTy:$rs2),
+ (Inst StTy:$rs2, BaseAddr:$rs1, simm12:$imm12)>;
def : Pat<(StoreOp (IsOrAdd AddrFI:$rs1, simm12:$imm12), StTy:$rs2),
(Inst StTy:$rs2, AddrFI:$rs1, simm12:$imm12)>;
}
def SplatPat_simm5 : ComplexPattern<vAny, 1, "selectVSplatSimm5", [splat_vector, rv32_splat_i64], [], 2>;
def SplatPat_uimm5 : ComplexPattern<vAny, 1, "selectVSplatUimm5", [splat_vector, rv32_splat_i64], [], 2>;
-def RVVBaseAddr : ComplexPattern<iPTR, 1, "SelectRVVBaseAddr">;
-
class SwapHelper<dag Prefix, dag A, dag B, dag Suffix, bit swap> {
dag Value = !con(Prefix, !if(swap, B, A), !if(swap, A, B), Suffix);
}
defvar load_instr = !cast<Instruction>("PseudoVLE"#sew#"_V_"#vlmul.MX);
defvar store_instr = !cast<Instruction>("PseudoVSE"#sew#"_V_"#vlmul.MX);
// Load
- def : Pat<(type (load RVVBaseAddr:$rs1)),
- (load_instr RVVBaseAddr:$rs1, avl, sew)>;
+ def : Pat<(type (load BaseAddr:$rs1)),
+ (load_instr BaseAddr:$rs1, avl, sew)>;
// Store
- def : Pat<(store type:$rs2, RVVBaseAddr:$rs1),
- (store_instr reg_class:$rs2, RVVBaseAddr:$rs1, avl, sew)>;
+ def : Pat<(store type:$rs2, BaseAddr:$rs1),
+ (store_instr reg_class:$rs2, BaseAddr:$rs1, avl, sew)>;
}
multiclass VPatUSLoadStoreWholeVRSDNode<LLVMType type,
!eq(vlmul.value, V_M8.value): VS8R_V);
// Load
- def : Pat<(type (load RVVBaseAddr:$rs1)),
- (load_instr RVVBaseAddr:$rs1)>;
+ def : Pat<(type (load BaseAddr:$rs1)),
+ (load_instr BaseAddr:$rs1)>;
// Store
- def : Pat<(store type:$rs2, RVVBaseAddr:$rs1),
- (store_instr reg_class:$rs2, RVVBaseAddr:$rs1)>;
+ def : Pat<(store type:$rs2, BaseAddr:$rs1),
+ (store_instr reg_class:$rs2, BaseAddr:$rs1)>;
}
multiclass VPatUSLoadStoreMaskSDNode<MTypeInfo m>
defvar load_instr = !cast<Instruction>("PseudoVLE1_V_"#m.BX);
defvar store_instr = !cast<Instruction>("PseudoVSE1_V_"#m.BX);
// Load
- def : Pat<(m.Mask (load RVVBaseAddr:$rs1)),
- (load_instr RVVBaseAddr:$rs1, m.AVL, m.SEW)>;
+ def : Pat<(m.Mask (load BaseAddr:$rs1)),
+ (load_instr BaseAddr:$rs1, m.AVL, m.SEW)>;
// Store
- def : Pat<(store m.Mask:$rs2, RVVBaseAddr:$rs1),
- (store_instr VR:$rs2, RVVBaseAddr:$rs1, m.AVL, m.SEW)>;
+ def : Pat<(store m.Mask:$rs2, BaseAddr:$rs1),
+ (store_instr VR:$rs2, BaseAddr:$rs1, m.AVL, m.SEW)>;
}
class VPatBinarySDNode_VV<SDNode vop,
defvar load_instr = !cast<Instruction>("PseudoVLE"#vti.SEW#"_V_"#vti.LMul.MX);
defvar store_instr = !cast<Instruction>("PseudoVSE"#vti.SEW#"_V_"#vti.LMul.MX);
// Load
- def : Pat<(vti.Vector (riscv_vle_vl RVVBaseAddr:$rs1, (XLenVT (VLOp GPR:$vl)))),
- (load_instr RVVBaseAddr:$rs1, GPR:$vl, vti.SEW)>;
+ def : Pat<(vti.Vector (riscv_vle_vl BaseAddr:$rs1, (XLenVT (VLOp GPR:$vl)))),
+ (load_instr BaseAddr:$rs1, GPR:$vl, vti.SEW)>;
// Store
- def : Pat<(riscv_vse_vl (vti.Vector vti.RegClass:$rs2), RVVBaseAddr:$rs1,
+ def : Pat<(riscv_vse_vl (vti.Vector vti.RegClass:$rs2), BaseAddr:$rs1,
(XLenVT (VLOp GPR:$vl))),
- (store_instr vti.RegClass:$rs2, RVVBaseAddr:$rs1, GPR:$vl, vti.SEW)>;
+ (store_instr vti.RegClass:$rs2, BaseAddr:$rs1, GPR:$vl, vti.SEW)>;
}
foreach mti = AllMasks in {
defvar load_instr = !cast<Instruction>("PseudoVLE1_V_"#mti.BX);
defvar store_instr = !cast<Instruction>("PseudoVSE1_V_"#mti.BX);
- def : Pat<(mti.Mask (riscv_vle_vl RVVBaseAddr:$rs1, (XLenVT (VLOp GPR:$vl)))),
- (load_instr RVVBaseAddr:$rs1, GPR:$vl, mti.SEW)>;
- def : Pat<(riscv_vse_vl (mti.Mask VR:$rs2), RVVBaseAddr:$rs1,
+ def : Pat<(mti.Mask (riscv_vle_vl BaseAddr:$rs1, (XLenVT (VLOp GPR:$vl)))),
+ (load_instr BaseAddr:$rs1, GPR:$vl, mti.SEW)>;
+ def : Pat<(riscv_vse_vl (mti.Mask VR:$rs2), BaseAddr:$rs1,
(XLenVT (VLOp GPR:$vl))),
- (store_instr VR:$rs2, RVVBaseAddr:$rs1, GPR:$vl, mti.SEW)>;
+ (store_instr VR:$rs2, BaseAddr:$rs1, GPR:$vl, mti.SEW)>;
}
// 12.1. Vector Single-Width Integer Add and Subtract