Skip to content

Commit 9e65f10

Browse files
qiaojbaoqiaojbao
committed
[AMDGPU] Add intrinsic and MI for image_bvh_dual_intersect_ray llvm#130038 
1 parent 9980507 commit 9e65f10

14 files changed

+291
-30
lines changed

‎llvm/include/llvm/IR/Intrinsics.td

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -561,6 +561,7 @@ def llvm_v3i32_ty : LLVMType<v3i32>; // 3 x i32
561561
def llvm_v4i32_ty : LLVMType<v4i32>; // 4 x i32
562562
def llvm_v6i32_ty : LLVMType<v6i32>; // 6 x i32
563563
def llvm_v8i32_ty : LLVMType<v8i32>; // 8 x i32
564+
def llvm_v10i32_ty : LLVMType<v10i32>; // 10 x i32
564565
def llvm_v16i32_ty : LLVMType<v16i32>; // 16 x i32
565566
def llvm_v32i32_ty : LLVMType<v32i32>; // 32 x i32
566567
def llvm_v64i32_ty : LLVMType<v64i32>; // 64 x i32
@@ -590,6 +591,7 @@ def llvm_v2f32_ty : LLVMType<v2f32>; // 2 x float
590591
def llvm_v3f32_ty : LLVMType<v3f32>; // 3 x float
591592
def llvm_v4f32_ty : LLVMType<v4f32>; // 4 x float
592593
def llvm_v8f32_ty : LLVMType<v8f32>; // 8 x float
594+
def llvm_v10f32_ty : LLVMType<v10f32>; // 10 x float
593595
def llvm_v16f32_ty : LLVMType<v16f32>; // 16 x float
594596
def llvm_v32f32_ty : LLVMType<v32f32>; // 32 x float
595597
def llvm_v1f64_ty : LLVMType<v1f64>; // 1 x double

‎llvm/include/llvm/IR/IntrinsicsAMDGPU.td

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2868,6 +2868,17 @@ def int_amdgcn_wmma_bf16_16x16x16_bf16 : AMDGPUWmmaIntrinsicOPSEL<llvm_anyint_ty
28682868
// GFX12 Intrinsics
28692869
//===----------------------------------------------------------------------===//
28702870

2871+
// <vdata>, <ray_origin>, <ray_dir>
2872+
// llvm.amdgcn.image.bvh.dual.intersect.ray <node_ptr>, <ray_extent>,
2873+
// <instance_mask>, <ray_origin>,
2874+
// <ray_dir>, <offsets>,
2875+
// <texture_descr>
2876+
def int_amdgcn_image_bvh_dual_intersect_ray :
2877+
Intrinsic<[llvm_v10i32_ty, llvm_v3f32_ty, llvm_v3f32_ty],
2878+
[llvm_i64_ty, llvm_float_ty, llvm_i8_ty, llvm_v3f32_ty,
2879+
llvm_v3f32_ty, llvm_v2i32_ty, llvm_v4i32_ty],
2880+
[IntrReadMem, IntrWillReturn]>;
2881+
28712882
def int_amdgcn_ds_bvh_stack_push4_pop1_rtn : IntDSBVHStackRtn;
28722883

28732884
def int_amdgcn_ds_bvh_stack_push8_pop1_rtn :

‎llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3580,11 +3580,14 @@ bool AMDGPUInstructionSelector::selectGlobalLoadLds(MachineInstr &MI) const{
35803580
return constrainSelectedInstRegOperands(*MIB, TII, TRI, RBI);
35813581
}
35823582

3583-
bool AMDGPUInstructionSelector::selectBVHIntrinsic(MachineInstr &MI) const{
3584-
MI.setDesc(TII.get(MI.getOperand(1).getImm()));
3585-
MI.removeOperand(1);
3583+
bool AMDGPUInstructionSelector::selectBVHIntersectRayIntrinsic(
3584+
MachineInstr &MI) const {
3585+
unsigned OpcodeOpIdx =
3586+
MI.getOpcode() == AMDGPU::G_AMDGPU_BVH_INTERSECT_RAY ? 1 : 3;
3587+
MI.setDesc(TII.get(MI.getOperand(OpcodeOpIdx).getImm()));
3588+
MI.removeOperand(OpcodeOpIdx);
35863589
MI.addImplicitDefUseOperands(*MI.getParent()->getParent());
3587-
return true;
3590+
return constrainSelectedInstRegOperands(MI, TII, TRI, RBI);
35883591
}
35893592

35903593
// FIXME: This should be removed and let the patterns select. We just need the
@@ -4098,6 +4101,7 @@ bool AMDGPUInstructionSelector::select(MachineInstr &I) {
40984101
assert(Intr && "not an image intrinsic with image pseudo");
40994102
return selectImageIntrinsic(I, Intr);
41004103
}
4104+
case AMDGPU::G_AMDGPU_BVH_DUAL_INTERSECT_RAY:
41014105
case AMDGPU::G_AMDGPU_INTRIN_BVH_INTERSECT_RAY:
41024106
return selectBVHIntrinsic(I);
41034107
case AMDGPU::G_SBFX:

‎llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7173,6 +7173,61 @@ bool AMDGPULegalizerInfo::legalizeBVHIntrinsic(MachineInstr &MI,
71737173
return true;
71747174
}
71757175

7176+
bool AMDGPULegalizerInfo::legalizeBVHDualIntrinsic(MachineInstr &MI,
7177+
MachineIRBuilder &B) const {
7178+
const LLT S32 = LLT::scalar(32);
7179+
const LLT V2S32 = LLT::fixed_vector(2, 32);
7180+
7181+
Register DstReg = MI.getOperand(0).getReg();
7182+
Register DstOrigin = MI.getOperand(1).getReg();
7183+
Register DstDir = MI.getOperand(2).getReg();
7184+
Register NodePtr = MI.getOperand(4).getReg();
7185+
Register RayExtent = MI.getOperand(5).getReg();
7186+
Register InstanceMask = MI.getOperand(6).getReg();
7187+
Register RayOrigin = MI.getOperand(7).getReg();
7188+
Register RayDir = MI.getOperand(8).getReg();
7189+
Register Offsets = MI.getOperand(9).getReg();
7190+
Register TDescr = MI.getOperand(10).getReg();
7191+
7192+
if (!AMDGPU::isGFX12Plus(ST)) {
7193+
DiagnosticInfoUnsupported BadIntrin(B.getMF().getFunction(),
7194+
"intrinsic not supported on subtarget",
7195+
MI.getDebugLoc());
7196+
B.getMF().getFunction().getContext().diagnose(BadIntrin);
7197+
return false;
7198+
}
7199+
7200+
const unsigned NumVDataDwords = 10;
7201+
const unsigned NumVAddrDwords = 12;
7202+
int Opcode = AMDGPU::getMIMGOpcode(AMDGPU::IMAGE_BVH_DUAL_INTERSECT_RAY,
7203+
AMDGPU::MIMGEncGfx12, NumVDataDwords,
7204+
NumVAddrDwords);
7205+
assert(Opcode != -1);
7206+
7207+
SmallVector<Register, 12> Ops;
7208+
Ops.push_back(NodePtr);
7209+
Ops.push_back(B.buildMergeLikeInstr(
7210+
V2S32, {RayExtent, B.buildAnyExt(S32, InstanceMask)})
7211+
.getReg(0));
7212+
Ops.push_back(RayOrigin);
7213+
Ops.push_back(RayDir);
7214+
Ops.push_back(Offsets);
7215+
7216+
auto MIB = B.buildInstr(AMDGPU::G_AMDGPU_BVH_DUAL_INTERSECT_RAY)
7217+
.addDef(DstReg)
7218+
.addDef(DstOrigin)
7219+
.addDef(DstDir)
7220+
.addImm(Opcode);
7221+
7222+
for (Register R : Ops)
7223+
MIB.addUse(R);
7224+
7225+
MIB.addUse(TDescr).cloneMemRefs(MI);
7226+
7227+
MI.eraseFromParent();
7228+
return true;
7229+
}
7230+
71767231
bool AMDGPULegalizerInfo::legalizeStackSave(MachineInstr &MI,
71777232
MachineIRBuilder &B) const {
71787233
const SITargetLowering *TLI = ST.getTargetLowering();
@@ -7526,6 +7581,8 @@ bool AMDGPULegalizerInfo::legalizeIntrinsic(LegalizerHelper &Helper,
75267581
return legalizeRsqClampIntrinsic(MI, MRI, B);
75277582
case Intrinsic::amdgcn_image_bvh_intersect_ray:
75287583
return legalizeBVHIntrinsic(MI, B);
7584+
case Intrinsic::amdgcn_image_bvh_dual_intersect_ray:
7585+
return legalizeBVHDualIntrinsic(MI, B);
75297586
case Intrinsic::amdgcn_swmmac_f16_16x16x32_f16:
75307587
case Intrinsic::amdgcn_swmmac_bf16_16x16x32_bf16:
75317588
case Intrinsic::amdgcn_swmmac_f32_16x16x32_bf16:

‎llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -205,6 +205,8 @@ class AMDGPULegalizerInfo final : public LegalizerInfo {
205205
bool legalizeBufferAtomic(MachineInstr &MI, MachineIRBuilder &B,
206206
Intrinsic::ID IID) const;
207207

208+
bool legalizeBVHDualIntrinsic(MachineInstr &MI, MachineIRBuilder &B) const;
209+
208210
bool legalizeLaneOp(LegalizerHelper &Helper, MachineInstr &MI,
209211
Intrinsic::ID IID) const;
210212

‎llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp

Lines changed: 26 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -3217,10 +3217,13 @@ void AMDGPURegisterBankInfo::applyMappingImpl(
32173217
applyMappingImage(B, MI, OpdMapper, RSrcIntrin->RsrcArg);
32183218
return;
32193219
}
3220-
case AMDGPU::G_AMDGPU_INTRIN_BVH_INTERSECT_RAY: {
3221-
unsigned N = MI.getNumExplicitOperands() - 2;
3220+
case AMDGPU::G_AMDGPU_BVH_INTERSECT_RAY:
3221+
case AMDGPU::G_AMDGPU_BVH_DUAL_INTERSECT_RAY: {
3222+
bool IsDual = MI.getOpcode() == AMDGPU::G_AMDGPU_BVH_DUAL_INTERSECT_RAY;
3223+
unsigned NumMods = IsDual ? 0 : 1; // Has A16 modifier
3224+
unsigned LastRegOpIdx = MI.getNumExplicitOperands() - 1 - NumMods;
32223225
applyDefaultMapping(OpdMapper);
3223-
executeInWaterfallLoop(B, MI, {N});
3226+
executeInWaterfallLoop(B, MI, {LastRegOpIdx});
32243227
return;
32253228
}
32263229
case AMDGPU::G_INTRINSIC_W_SIDE_EFFECTS:
@@ -5013,19 +5016,33 @@ AMDGPURegisterBankInfo::getInstrMapping(const MachineInstr &MI) const {
50135016
assert(RSrcIntrin->IsImage);
50145017
return getImageMapping(MRI, MI, RSrcIntrin->RsrcArg);
50155018
}
5016-
case AMDGPU::G_AMDGPU_INTRIN_BVH_INTERSECT_RAY: {
5017-
unsigned N = MI.getNumExplicitOperands() - 2;
5018-
OpdsMapping[0] = AMDGPU::getValueMapping(AMDGPU::VGPRRegBankID, 128);
5019-
OpdsMapping[N] = getSGPROpMapping(MI.getOperand(N).getReg(), MRI, *TRI);
5020-
if (N == 3) {
5019+
case AMDGPU::G_AMDGPU_INTRIN_BVH_INTERSECT_RAY:
5020+
case AMDGPU::G_AMDGPU_BVH_DUAL_INTERSECT_RAY: {
5021+
bool IsDual = MI.getOpcode() == AMDGPU::G_AMDGPU_BVH_DUAL_INTERSECT_RAY;
5022+
unsigned NumMods = IsDual ? 0 : 1; // Has A16 modifier
5023+
unsigned LastRegOpIdx = MI.getNumExplicitOperands() - 1 - NumMods;
5024+
unsigned DstSize = MRI.getType(MI.getOperand(0).getReg()).getSizeInBits();
5025+
OpdsMapping[0] = AMDGPU::getValueMapping(AMDGPU::VGPRRegBankID, DstSize);
5026+
if (IsDual) {
5027+
OpdsMapping[1] = AMDGPU::getValueMapping(
5028+
AMDGPU::VGPRRegBankID,
5029+
MRI.getType(MI.getOperand(1).getReg()).getSizeInBits());
5030+
OpdsMapping[2] = AMDGPU::getValueMapping(
5031+
AMDGPU::VGPRRegBankID,
5032+
MRI.getType(MI.getOperand(2).getReg()).getSizeInBits());
5033+
}
5034+
OpdsMapping[LastRegOpIdx] =
5035+
getSGPROpMapping(MI.getOperand(LastRegOpIdx).getReg(), MRI, *TRI);
5036+
if (LastRegOpIdx == 3) {
50215037
// Sequential form: all operands combined into VGPR256/VGPR512
50225038
unsigned Size = MRI.getType(MI.getOperand(2).getReg()).getSizeInBits();
50235039
if (Size > 256)
50245040
Size = 512;
50255041
OpdsMapping[2] = AMDGPU::getValueMapping(AMDGPU::VGPRRegBankID, Size);
50265042
} else {
50275043
// NSA form
5028-
for (unsigned I = 2; I < N; ++I) {
5044+
unsigned FirstSrcOpIdx = IsDual ? 4 : 2;
5045+
for (unsigned I = FirstSrcOpIdx; I < LastRegOpIdx; ++I) {
50295046
unsigned Size = MRI.getType(MI.getOperand(I).getReg()).getSizeInBits();
50305047
OpdsMapping[I] = AMDGPU::getValueMapping(AMDGPU::VGPRRegBankID, Size);
50315048
}

‎llvm/lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -265,6 +265,7 @@ DECODE_OPERAND_REG_8(VReg_128)
265265
DECODE_OPERAND_REG_8(VReg_192)
266266
DECODE_OPERAND_REG_8(VReg_256)
267267
DECODE_OPERAND_REG_8(VReg_288)
268+
DECODE_OPERAND_REG_8(VReg_320)
268269
DECODE_OPERAND_REG_8(VReg_352)
269270
DECODE_OPERAND_REG_8(VReg_384)
270271
DECODE_OPERAND_REG_8(VReg_512)

‎llvm/lib/Target/AMDGPU/MIMGInstructions.td

Lines changed: 31 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1509,17 +1509,18 @@ multiclass MIMG_Gather <mimgopc op, AMDGPUSampleVariant sample, bit wqm = 0,
15091509
multiclass MIMG_Gather_WQM <mimgopc op, AMDGPUSampleVariant sample>
15101510
: MIMG_Gather<op, sample, 1>;
15111511

1512-
class MIMG_IntersectRay_Helper<bit Is64, bit IsA16> {
1512+
class MIMG_IntersectRay_Helper<bit Is64, bit IsA16, bit isDual> {
15131513
int num_addrs = !if(Is64, !if(IsA16, 9, 12), !if(IsA16, 8, 11));
15141514
RegisterClass RegClass = MIMGAddrSize<num_addrs, 0>.RegClass;
15151515
int VAddrDwords = !srl(RegClass.Size, 5);
15161516

15171517
int GFX11PlusNSAAddrs = !if(IsA16, 4, 5);
15181518
RegisterClass node_ptr_type = !if(Is64, VReg_64, VGPR_32);
15191519
list<RegisterClass> GFX11PlusAddrTypes =
1520-
!if(IsA16,
1520+
!if(isDual, [VReg_64, VReg_64, VReg_96, VReg_96, VReg_64],
1521+
!if(IsA16,
15211522
[node_ptr_type, VGPR_32, VReg_96, VReg_96],
1522-
[node_ptr_type, VGPR_32, VReg_96, VReg_96, VReg_96]);
1523+
[node_ptr_type, VGPR_32, VReg_96, VReg_96, VReg_96]));
15231524
}
15241525

15251526
class MIMG_IntersectRay_gfx10<mimgopc op, string opcode, RegisterClass AddrRC>
@@ -1553,15 +1554,26 @@ class MIMG_IntersectRay_nsa_gfx11<mimgopc op, string opcode, int num_addrs,
15531554
}
15541555

15551556
class VIMAGE_IntersectRay_gfx12<mimgopc op, string opcode, int num_addrs,
1557+
bit isDual,
15561558
list<RegisterClass> addr_types>
1557-
: VIMAGE_gfx12<op.GFX12, (outs VReg_128:$vdata),
1559+
: VIMAGE_gfx12<op.GFX12, !if(isDual,
1560+
(outs VReg_320:$vdata, VReg_96:$ray_origin_out,
1561+
VReg_96:$ray_dir_out),
1562+
(outs VReg_128:$vdata)),
15581563
num_addrs, "GFX12", addr_types> {
1559-
let InOperandList = !con(nsah.AddrIns, (ins SReg_128_XNULL:$rsrc, A16:$a16));
1560-
let AsmString = opcode#" $vdata, "#nsah.AddrAsm#", $rsrc$a16";
1561-
}
1562-
1563-
multiclass MIMG_IntersectRay<mimgopc op, string opcode, bit Is64, bit IsA16> {
1564-
defvar info = MIMG_IntersectRay_Helper<Is64, IsA16>;
1564+
let Constraints = !if(isDual,
1565+
"$ray_origin_out = $vaddr2, $ray_dir_out = $vaddr3", "");
1566+
let InOperandList = !con(nsah.AddrIns, (ins SReg_128_XNULL:$rsrc),
1567+
!if(isDual, (ins), (ins A16:$a16)));
1568+
let AsmString = opcode#" $vdata, "#nsah.AddrAsm#", $rsrc"#
1569+
!if(isDual, "", "$a16");
1570+
let SchedRW = !if(isDual,
1571+
[WriteVMEM, WriteVMEM, WriteVMEM], [WriteVMEM]);
1572+
}
1573+
1574+
multiclass MIMG_IntersectRay<mimgopc op, string opcode, bit Is64, bit IsA16,
1575+
bit isDual> {
1576+
defvar info = MIMG_IntersectRay_Helper<Is64, IsA16, isDual>;
15651577
def "" : MIMGBaseOpcode {
15661578
let BVH = 1;
15671579
let A16 = IsA16;
@@ -1599,7 +1611,8 @@ multiclass MIMG_IntersectRay<mimgopc op, string opcode, bit Is64, bit IsA16> {
15991611
}
16001612
}
16011613
def _gfx12 : VIMAGE_IntersectRay_gfx12<op, opcode, info.GFX11PlusNSAAddrs,
1602-
info.GFX11PlusAddrTypes> {
1614+
isDual, info.GFX11PlusAddrTypes> {
1615+
let VDataDwords = !if(isDual, 10, 4);
16031616
let VAddrDwords = info.num_addrs;
16041617
}
16051618
}
@@ -1771,15 +1784,18 @@ defm IMAGE_MSAA_LOAD_X : MIMG_NoSampler <mimgopc<MIMG.NOP, MIMG.NOP, 0x80>, "ima
17711784
let OtherPredicates = [HasImageInsts, HasGFX10_AEncoding] in {
17721785
defm IMAGE_MSAA_LOAD : MIMG_MSAA_Load <mimgopc<0x18, 0x18, MIMG.NOP>, "image_msaa_load">;
17731786

1774-
defm IMAGE_BVH_INTERSECT_RAY : MIMG_IntersectRay<mimgopc<0x19, 0x19, 0xe6>, "image_bvh_intersect_ray", 0, 0>;
1775-
defm IMAGE_BVH_INTERSECT_RAY_a16 : MIMG_IntersectRay<mimgopc<0x19, 0x19, 0xe6>, "image_bvh_intersect_ray", 0, 1>;
1776-
defm IMAGE_BVH64_INTERSECT_RAY : MIMG_IntersectRay<mimgopc<0x1a, 0x1a, 0xe7>, "image_bvh64_intersect_ray", 1, 0>;
1777-
defm IMAGE_BVH64_INTERSECT_RAY_a16 : MIMG_IntersectRay<mimgopc<0x1a, 0x1a, 0xe7>, "image_bvh64_intersect_ray", 1, 1>;
1787+
defm IMAGE_BVH_INTERSECT_RAY : MIMG_IntersectRay<mimgopc<0x19, 0x19, 0xe6>, "image_bvh_intersect_ray", 0, 0, 0>;
1788+
defm IMAGE_BVH_INTERSECT_RAY_a16 : MIMG_IntersectRay<mimgopc<0x19, 0x19, 0xe6>, "image_bvh_intersect_ray", 0, 1, 0>;
1789+
defm IMAGE_BVH64_INTERSECT_RAY : MIMG_IntersectRay<mimgopc<0x1a, 0x1a, 0xe7>, "image_bvh64_intersect_ray", 1, 0, 0>;
1790+
defm IMAGE_BVH64_INTERSECT_RAY_a16 : MIMG_IntersectRay<mimgopc<0x1a, 0x1a, 0xe7>, "image_bvh64_intersect_ray", 1, 1, 0>;
17781791
} // End OtherPredicates = [HasImageInsts, HasGFX10_AEncoding]
17791792

1793+
defm IMAGE_BVH_DUAL_INTERSECT_RAY : MIMG_IntersectRay<mimgopc<0x80, MIMG.NOP, MIMG.NOP>, "image_bvh_dual_intersect_ray", 1, 0, 1>;
1794+
17801795
let SubtargetPredicate = isGFX12Plus in {
17811796
def : AMDGPUMnemonicAlias<"bvh_intersect_ray", "image_bvh_intersect_ray">;
17821797
def : AMDGPUMnemonicAlias<"bvh64_intersect_ray", "image_bvh64_intersect_ray">;
1798+
def : AMDGPUMnemonicAlias<"bvh_dual_intersect_ray", "image_bvh_dual_intersect_ray">;
17831799
}
17841800

17851801
} // End let OtherPredicates = [HasImageInsts]

‎llvm/lib/Target/AMDGPU/SIISelLowering.cpp

Lines changed: 48 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1380,9 +1380,14 @@ bool SITargetLowering::getTgtMemIntrinsic(IntrinsicInfo &Info,
13801380
MachineMemOperand::MOVolatile;
13811381
return true;
13821382
}
1383+
case Intrinsic::amdgcn_image_bvh_dual_intersect_ray:
13831384
case Intrinsic::amdgcn_image_bvh_intersect_ray: {
13841385
Info.opc = ISD::INTRINSIC_W_CHAIN;
1385-
Info.memVT = MVT::getVT(CI.getType()); // XXX: what is correct VT?
1386+
Info.memVT =
1387+
MVT::getVT(IntrID == Intrinsic::amdgcn_image_bvh_intersect_ray
1388+
? CI.getType()
1389+
: cast<StructType>(CI.getType())
1390+
->getElementType(0)); // XXX: what is correct VT?
13861391

13871392
Info.fallbackAddressSpace = AMDGPUAS::BUFFER_RESOURCE;
13881393
Info.align.reset();
@@ -9430,6 +9435,48 @@ SDValue SITargetLowering::LowerINTRINSIC_W_CHAIN(SDValue Op,
94309435
Op->getVTList(), Ops, VT,
94319436
M->getMemOperand());
94329437
}
9438+
case Intrinsic::amdgcn_image_bvh_dual_intersect_ray: {
9439+
MemSDNode *M = cast<MemSDNode>(Op);
9440+
SDValue NodePtr = M->getOperand(2);
9441+
SDValue RayExtent = M->getOperand(3);
9442+
SDValue InstanceMask = M->getOperand(4);
9443+
SDValue RayOrigin = M->getOperand(5);
9444+
SDValue RayDir = M->getOperand(6);
9445+
SDValue Offsets = M->getOperand(7);
9446+
SDValue TDescr = M->getOperand(8);
9447+
9448+
assert(NodePtr.getValueType() == MVT::i64);
9449+
assert(RayDir.getValueType() == MVT::v3f32);
9450+
9451+
if (!AMDGPU::isGFX12Plus(*Subtarget)) {
9452+
emitRemovedIntrinsicError(DAG, DL, Op.getValueType());
9453+
return SDValue();
9454+
}
9455+
9456+
const unsigned NumVDataDwords = 10;
9457+
const unsigned NumVAddrDwords = 12;
9458+
int Opcode = AMDGPU::getMIMGOpcode(AMDGPU::IMAGE_BVH_DUAL_INTERSECT_RAY,
9459+
AMDGPU::MIMGEncGfx12, NumVDataDwords,
9460+
NumVAddrDwords);
9461+
assert(Opcode != -1);
9462+
9463+
SmallVector<SDValue, 16> Ops;
9464+
Ops.push_back(NodePtr);
9465+
Ops.push_back(DAG.getBuildVector(
9466+
MVT::v2i32, DL,
9467+
{DAG.getBitcast(MVT::i32, RayExtent),
9468+
DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, InstanceMask)}));
9469+
Ops.push_back(RayOrigin);
9470+
Ops.push_back(RayDir);
9471+
Ops.push_back(Offsets);
9472+
Ops.push_back(TDescr);
9473+
Ops.push_back(M->getChain());
9474+
9475+
auto *NewNode = DAG.getMachineNode(Opcode, DL, M->getVTList(), Ops);
9476+
MachineMemOperand *MemRef = M->getMemOperand();
9477+
DAG.setNodeMemRefs(NewNode, {MemRef});
9478+
return SDValue(NewNode, 0);
9479+
}
94339480
case Intrinsic::amdgcn_image_bvh_intersect_ray: {
94349481
MemSDNode *M = cast<MemSDNode>(Op);
94359482
SDValue NodePtr = M->getOperand(2);

‎llvm/lib/Target/AMDGPU/SIInstructions.td

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4314,7 +4314,15 @@ def G_AMDGPU_INTRIN_IMAGE_STORE_D16 : AMDGPUGenericInstruction {
43144314

43154315
def G_AMDGPU_INTRIN_BVH_INTERSECT_RAY : AMDGPUGenericInstruction {
43164316
let OutOperandList = (outs type0:$dst);
4317-
let InOperandList = (ins unknown:$intrin, variable_ops);
4317+
let InOperandList = (ins unknown:$opcode, variable_ops);
4318+
let hasSideEffects = 0;
4319+
let mayLoad = 1;
4320+
let mayStore = 0;
4321+
}
4322+
4323+
def G_AMDGPU_BVH_DUAL_INTERSECT_RAY : AMDGPUGenericInstruction {
4324+
let OutOperandList = (outs type0:$dst, type1:$ray_origin, type1:$ray_dir);
4325+
let InOperandList = (ins unknown:$opcode, variable_ops);
43184326
let hasSideEffects = 0;
43194327
let mayLoad = 1;
43204328
let mayStore = 0;

0 commit comments

Comments
 (0)