Support System Value retrieval functions.

include/dxc/HlslIntrinsicOp.h

@@ -28,6 +28,7 @@ import hctdb_instrhelp
   IOP_CallShader,
   IOP_CheckAccessFullyMapped,
   IOP_CommitHitAndStopRay,
+  IOP_CurrentRayT,
   IOP_D3DCOLORtoUBYTE4,
   IOP_DeviceMemoryBarrier,
   IOP_DeviceMemoryBarrierWithGroupSync,
@@ -39,6 +40,9 @@ import hctdb_instrhelp
   IOP_GetRenderTargetSamplePosition,
   IOP_GroupMemoryBarrier,
   IOP_GroupMemoryBarrierWithGroupSync,
+  IOP_HitKind,
+  IOP_InstanceID,
+  IOP_InstanceIndex,
   IOP_InterlockedAdd,
   IOP_InterlockedAnd,
   IOP_InterlockedCompareExchange,
@@ -49,6 +53,10 @@ import hctdb_instrhelp
   IOP_InterlockedOr,
   IOP_InterlockedXor,
   IOP_NonUniformResourceIndex,
+  IOP_ObjectRayDirection,
+  IOP_ObjectRayOrigin,
+  IOP_ObjectToWorld,
+  IOP_PrimitiveID,
   IOP_Process2DQuadTessFactorsAvg,
   IOP_Process2DQuadTessFactorsMax,
   IOP_Process2DQuadTessFactorsMin,
@@ -63,6 +71,10 @@ import hctdb_instrhelp
   IOP_QuadReadAcrossX,
   IOP_QuadReadAcrossY,
   IOP_QuadReadLaneAt,
+  IOP_RayDispatchDimension,
+  IOP_RayDispatchIndex,
+  IOP_RayFlag,
+  IOP_RayTMin,
   IOP_ReportHit,
   IOP_TraceRay,
   IOP_WaveActiveAllEqual,
@@ -85,6 +97,9 @@ import hctdb_instrhelp
   IOP_WavePrefixSum,
   IOP_WaveReadLaneAt,
   IOP_WaveReadLaneFirst,
+  IOP_WorldRayDirection,
+  IOP_WorldRayOrigin,
+  IOP_WorldToObject,
   IOP_abort,
   IOP_abs,
   IOP_acos,

lib/HLSL/HLOperationLower.cpp

@@ -887,6 +887,19 @@ Value *TrivialNoArgOperation(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
   return dxilOp;
 }
 
+Value *TrivialNoArgWithRetOperation(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
+                             HLOperationLowerHelper &helper,  HLObjectOperationLowerHelper *pObjHelper, bool &Translated) {
+  hlsl::OP *hlslOP = &helper.hlslOP;
+  Type *Ty = CI->getType();
+
+  Constant *opArg = hlslOP->GetU32Const((unsigned)opcode);
+  Value *args[] = {opArg};
+  IRBuilder<> Builder(CI);
+  Value *dxilOp = TrivialDxilOperation(opcode, args, Ty, Ty, hlslOP, Builder);
+
+  return dxilOp;
+}
+
 Value *TranslateGetRTSamplePos(CallInst *CI, IntrinsicOp IOP, OP::OpCode op,
                                HLOperationLowerHelper &helper,  HLObjectOperationLowerHelper *pObjHelper, bool &Translated) {
   hlsl::OP *hlslOP = &helper.hlslOP;
@@ -4326,6 +4339,26 @@ Value *TranslateTraceRay(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
 
   return Builder.CreateCall(F, Args);
 }
+
+Value *TranslateNoArgVectorOperation(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
+                         HLOperationLowerHelper &helper,
+                         HLObjectOperationLowerHelper *pObjHelper,
+                         bool &Translated) {
+  hlsl::OP *hlslOP = &helper.hlslOP;
+  VectorType *Ty = cast<VectorType>(CI->getType());
+  uint8_t vals[] = {0,1,2,3};
+  Constant *src = ConstantDataVector::get(CI->getContext(), vals);
+  Value *retVal = TrivialDxilOperation(opcode, {nullptr, src}, Ty, CI, hlslOP);
+  return retVal;
+}
+
+Value *TranslateNoArgMatrixOperation(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
+                         HLOperationLowerHelper &helper,
+                         HLObjectOperationLowerHelper *pObjHelper,
+                         bool &Translated) {
+  return nullptr;
+}
+
 } // namespace
 
 // Lower table.
@@ -4367,7 +4400,8 @@ IntrinsicLower gLowerTable[static_cast<unsigned>(IntrinsicOp::Num_Intrinsics)] =
     {IntrinsicOp::IOP_AllMemoryBarrierWithGroupSync, TrivialBarrier, DXIL::OpCode::Barrier},
     {IntrinsicOp::IOP_CallShader, TranslateCallShader, DXIL::OpCode::CallShader},
     {IntrinsicOp::IOP_CheckAccessFullyMapped, TranslateCheckAccess, DXIL::OpCode::CheckAccessFullyMapped},
-    {IntrinsicOp::IOP_CommitHitAndStopRay, TrivialNoArgOperation, DXIL::OpCode::CommitHitAndStopRay},
+    {IntrinsicOp::IOP_CommitHitAndStopRay, TrivialNoArgOperation, DXIL::OpCode::CommitHitAndStopRay},
+    {IntrinsicOp::IOP_CurrentRayT, TrivialNoArgWithRetOperation, DXIL::OpCode::CurrentRayT},
     {IntrinsicOp::IOP_D3DCOLORtoUBYTE4, TranslateD3DColorToUByte4, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_DeviceMemoryBarrier, TrivialBarrier, DXIL::OpCode::Barrier},
     {IntrinsicOp::IOP_DeviceMemoryBarrierWithGroupSync, TrivialBarrier, DXIL::OpCode::Barrier},
@@ -4378,7 +4412,10 @@ IntrinsicLower gLowerTable[static_cast<unsigned>(IntrinsicOp::Num_Intrinsics)] =
     {IntrinsicOp::IOP_GetRenderTargetSampleCount, TrivialNoArgOperation, DXIL::OpCode::RenderTargetGetSampleCount},
     {IntrinsicOp::IOP_GetRenderTargetSamplePosition, TranslateGetRTSamplePos, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_GroupMemoryBarrier, TrivialBarrier, DXIL::OpCode::Barrier},
-    {IntrinsicOp::IOP_GroupMemoryBarrierWithGroupSync, TrivialBarrier, DXIL::OpCode::Barrier},
+    {IntrinsicOp::IOP_GroupMemoryBarrierWithGroupSync, TrivialBarrier, DXIL::OpCode::Barrier},
+    {IntrinsicOp::IOP_HitKind, TrivialNoArgWithRetOperation, DXIL::OpCode::HitKind},
+    {IntrinsicOp::IOP_InstanceID, TrivialNoArgWithRetOperation, DXIL::OpCode::InstanceID},
+    {IntrinsicOp::IOP_InstanceIndex, TrivialNoArgWithRetOperation, DXIL::OpCode::InstanceIndex},
     {IntrinsicOp::IOP_InterlockedAdd, TranslateIopAtomicBinaryOperation, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_InterlockedAnd, TranslateIopAtomicBinaryOperation, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_InterlockedCompareExchange, TranslateIopAtomicCmpXChg, DXIL::OpCode::NumOpCodes},
@@ -4388,7 +4425,11 @@ IntrinsicLower gLowerTable[static_cast<unsigned>(IntrinsicOp::Num_Intrinsics)] =
     {IntrinsicOp::IOP_InterlockedMin, TranslateIopAtomicBinaryOperation, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_InterlockedOr, TranslateIopAtomicBinaryOperation, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_InterlockedXor, TranslateIopAtomicBinaryOperation, DXIL::OpCode::NumOpCodes},
-    {IntrinsicOp::IOP_NonUniformResourceIndex, TranslateNonUniformResourceIndex, DXIL::OpCode::NumOpCodes},
+    {IntrinsicOp::IOP_NonUniformResourceIndex, TranslateNonUniformResourceIndex, DXIL::OpCode::NumOpCodes},
+    {IntrinsicOp::IOP_ObjectRayDirection, TranslateNoArgVectorOperation, DXIL::OpCode::ObjectRayDirection},
+    {IntrinsicOp::IOP_ObjectRayOrigin, TranslateNoArgVectorOperation, DXIL::OpCode::ObjectRayOrigin},
+    {IntrinsicOp::IOP_ObjectToWorld, TranslateNoArgMatrixOperation, DXIL::OpCode::ObjectToWorld},
+    {IntrinsicOp::IOP_PrimitiveID, TrivialNoArgWithRetOperation, DXIL::OpCode::PrimitiveID},
     {IntrinsicOp::IOP_Process2DQuadTessFactorsAvg, TranslateProcessTessFactors, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_Process2DQuadTessFactorsMax, TranslateProcessTessFactors, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_Process2DQuadTessFactorsMin, TranslateProcessTessFactors, DXIL::OpCode::NumOpCodes},
@@ -4403,6 +4444,10 @@ IntrinsicLower gLowerTable[static_cast<unsigned>(IntrinsicOp::Num_Intrinsics)] =
     {IntrinsicOp::IOP_QuadReadAcrossX, TranslateQuadReadAcross, DXIL::OpCode::QuadOp},
     {IntrinsicOp::IOP_QuadReadAcrossY, TranslateQuadReadAcross, DXIL::OpCode::QuadOp},
     {IntrinsicOp::IOP_QuadReadLaneAt,  TranslateQuadReadLaneAt, DXIL::OpCode::NumOpCodes},
+    {IntrinsicOp::IOP_RayDispatchDimension, TranslateNoArgVectorOperation, DXIL::OpCode::RayDispatchDimension},
+    {IntrinsicOp::IOP_RayDispatchIndex, TranslateNoArgVectorOperation, DXIL::OpCode::RayDispatchIndex},
+    {IntrinsicOp::IOP_RayFlag, TrivialNoArgWithRetOperation, DXIL::OpCode::RayFlag},
+    {IntrinsicOp::IOP_RayTMin, TrivialNoArgWithRetOperation, DXIL::OpCode::RayTMin},
     {IntrinsicOp::IOP_ReportHit, TranslateReportIntersection, DXIL::OpCode::ReportHit},
     {IntrinsicOp::IOP_TraceRay, TranslateTraceRay, DXIL::OpCode::TraceRay},
     {IntrinsicOp::IOP_WaveActiveAllEqual, TranslateWaveAllEqual, DXIL::OpCode::WaveActiveAllEqual},
@@ -4424,7 +4469,10 @@ IntrinsicLower gLowerTable[static_cast<unsigned>(IntrinsicOp::Num_Intrinsics)] =
     {IntrinsicOp::IOP_WavePrefixProduct, TranslateWaveA2A, DXIL::OpCode::WavePrefixOp},
     {IntrinsicOp::IOP_WavePrefixSum, TranslateWaveA2A, DXIL::OpCode::WavePrefixOp},
     {IntrinsicOp::IOP_WaveReadLaneAt, TranslateWaveReadLaneAt, DXIL::OpCode::WaveReadLaneAt},
-    {IntrinsicOp::IOP_WaveReadLaneFirst, TranslateWaveReadLaneFirst, DXIL::OpCode::WaveReadLaneFirst},
+    {IntrinsicOp::IOP_WaveReadLaneFirst, TranslateWaveReadLaneFirst, DXIL::OpCode::WaveReadLaneFirst},
+    {IntrinsicOp::IOP_WorldRayDirection, TranslateNoArgVectorOperation, DXIL::OpCode::WorldRayDirection},
+    {IntrinsicOp::IOP_WorldRayOrigin, TranslateNoArgVectorOperation, DXIL::OpCode::WorldRayOrigin},
+    {IntrinsicOp::IOP_WorldToObject, TranslateNoArgMatrixOperation, DXIL::OpCode::WorldToObject},
     {IntrinsicOp::IOP_abort, EmptyLower, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_abs, TransalteAbs, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_acos, TrivialUnaryOperation, DXIL::OpCode::Acos},

tools/clang/test/CodeGenHLSL/abs1.hlsl

@@ -2,7 +2,7 @@
 
 // CHECK: main
 // After lowering, these would turn into multiple abs calls rather than a 4 x float
-// CHECK: call <4 x float> @"dx.hl.op..<4 x float> (i32, <4 x float>)"(i32 65,
+// CHECK: call <4 x float> @"dx.hl.op..<4 x float> (i32, <4 x float>)"(i32 80,
 
 float4 main(float4 a : A) : SV_TARGET {
   return abs(a*a.yxxx);

tools/clang/test/CodeGenHLSL/quick-test/ray_trace7.hlsl

@@ -0,0 +1,53 @@
+// RUN: %dxc -T lib_6_2 %s | FileCheck %s
+
+// CHECK: call i32 @dx.op.rayDispatchIndex.i32(i32 145, i8 0)
+// CHECK: call i32 @dx.op.rayDispatchIndex.i32(i32 145, i8 1)
+
+// CHECK: call i32 @dx.op.rayDispatchDimension.i32(i32 146, i8 0)
+// CHECK: call i32 @dx.op.rayDispatchDimension.i32(i32 146, i8 1)
+
+// CHECK: call float @dx.op.worldRayOrigin.f32(i32 147, i8 0)
+// CHECK: call float @dx.op.worldRayOrigin.f32(i32 147, i8 1)
+// CHECK: call float @dx.op.worldRayOrigin.f32(i32 147, i8 2)
+
+// CHECK: call float @dx.op.worldRayDirection.f32(i32 148, i8 0)
+// CHECK: call float @dx.op.worldRayDirection.f32(i32 148, i8 1)
+// CHECK: call float @dx.op.worldRayDirection.f32(i32 148, i8 2)
+
+// CHECK: call float @dx.op.objectRayOrigin.f32(i32 149, i8 0)
+// CHECK: call float @dx.op.objectRayOrigin.f32(i32 149, i8 1)
+// CHECK: call float @dx.op.objectRayOrigin.f32(i32 149, i8 2)
+
+// CHECK: call float @dx.op.objectRayDirection.f32(i32 150, i8 0)
+// CHECK: call float @dx.op.objectRayDirection.f32(i32 150, i8 1)
+// CHECK: call float @dx.op.objectRayDirection.f32(i32 150, i8 2)
+
+// CHECK: call float @dx.op.rayTMin.f32(i32 153)
+// CHECK: call float @dx.op.currentRayT.f32(i32 154)
+// CHECK: call i32 @dx.op.primitiveID.i32(i32 108)
+// CHECK: call i32 @dx.op.instanceID.i32(i32 141)
+// CHECK: call i32 @dx.op.instanceIndex.i32(i32 142)
+// CHECK: call i32 @dx.op.hitKind.i32(i32 143)
+// CHECK: call i32 @dx.op.rayFlag.i32(i32 144)
+
+float4 emit(uint shader)  {
+  uint2 a = RayDispatchIndex();
+  a += RayDispatchDimension();
+  float3 b = WorldRayOrigin();
+  b += WorldRayDirection();
+  b += ObjectRayOrigin();
+  b += ObjectRayDirection();
+
+  float4 r = float4(b, a.x+a.y);
+
+  r.w += RayTMin();
+  r.w += CurrentRayT();
+  r.w += PrimitiveID();
+  r.w += InstanceID();
+  r.w += InstanceIndex();
+  r.w += HitKind();
+  r.w += RayFlag();
+  
+
+   return r;
+}

tools/clang/unittests/HLSL/ExtensionTest.cpp

@@ -735,7 +735,7 @@ TEST_F(ExtensionTest, UnsignedOpcodeIsUnchanged) {
   // changes the test will need to be updated to reflect the new opcode.
   VERIFY_IS_TRUE(
     disassembly.npos !=
-    disassembly.find("call i32 @test_unsigned(i32 122, "));
+    disassembly.find("call i32 @test_unsigned(i32 137, "));
 }
 
 TEST_F(ExtensionTest, ResourceExtensionIntrinsic) {

utils/hct/gen_intrin_main.txt

@@ -274,6 +274,25 @@ bool [[]]  ReportHit(in float THit, in uint HitKind, in udt Attributes);
 void [[]]  CallShader(in uint ShaderIndex, inout udt Parameter);
 void [[]]  AcceptHitAndEndSearch();
 void [[]]  CommitHitAndStopRay();
+uint<2> [[rn]] RayDispatchIndex();
+uint<2> [[rn]] RayDispatchDimension();
+// group: Ray Vectors
+float<3> [[rn]] WorldRayOrigin();
+float<3> [[rn]] WorldRayDirection();
+float<3> [[rn]] ObjectRayOrigin();
+float<3> [[rn]] ObjectRayDirection();
+// group: RayT
+float [[rn]] RayTMin();
+float [[rn]] CurrentRayT();
+// group: Raytracing uint System Values
+uint [[rn]] PrimitiveID();
+uint [[rn]] InstanceID();
+uint [[rn]] InstanceIndex();
+uint [[rn]] HitKind();
+uint [[rn]] RayFlag();
+// group: Ray Transforms
+row_major float<3,4> [[rn]] ObjectToWorld();
+row_major float<3,4> [[rn]] WorldToObject();
 } namespace
 
 namespace StreamMethods {