[DirectX backend] Add createHandle BufferLoad/Store DXIL operation

[python3kgae]

Summary

New DXIL operations for createHandle BufferLoad/Store are added.
A new helper class DXILOpBuilder is added to create DXIL op function calls.

TableGen backend for DXILOperation will create table for DXIL op function parameter types.
When create DXIL op function, these parameter types will used to create the function type.

[beanz]

llvm/include/llvm/IR/IntrinsicsDXIL.td

22 ↗

(On Diff #441076)

Do you have a plan for taking LLVM load instructions and converting them to these intrinsics?

I think we need to think about how we want to translate LLVM gep/load/store instructions into DXIL ops, and I don't think we should add these intrinsics until we know what that is going to look like.

[python3kgae]

llvm/include/llvm/IR/IntrinsicsDXIL.td

22 ↗

(On Diff #441076)

These intrinsics are trying to make the distance from hlsl to DXIL shorter.
They're just wrapper for DXIL operation functions so generate DXIL is easier.

I did experiment to generate DXIL directly from GEP/load/store, then found create intrinsic might help the translation.

[beanz]

llvm/include/llvm/IR/IntrinsicsDXIL.td

22 ↗

(On Diff #441076)

I still don't know that these are the _right_ intrinsics. How are we going to map GEP/load/store to these intrinsics?

[python3kgae]

llvm/include/llvm/IR/IntrinsicsDXIL.td

22 ↗

(On Diff #441076)

It will not be a simple map, we'll need a pass to translate GEP/load/store to these intrinsics.
These intrinsics are to make the pass easier to write and leave the details like DXIL opcode, DXIL struct type to DXILOpLowering pass.

Maybe we can allow GEP/load/store in final DXIL for future DXIL version, but to generate early version of DXIL, these intrinsics will be
helpful.

[beanz]

llvm/include/llvm/IR/IntrinsicsDXIL.td

22 ↗

(On Diff #441076)

I didn't mean to imply it would be a simple map (as in map data structure), but it is a mapping operation. GEPs get folded in with loads and stores to form load and store DXIL Ops.

Clang will generate GEPs, loads, and stores through known handle pointers. Unlike in DXC we won't map those to "high level" intrinsics during codegen, instead we'll emit the GEPs, loads and stores. That will allow LLVM's optimization passes (like SROA) to run without needing to be taught about all of the special intrinsics for HLSL.

If the input to our backend is expected to be GEPs, loads and stores, I fail to see why we would translate those to an intrinsic that has an identical signature to the DXIL Op (minus the opcode) instead of just translating it to the DXIL Op directly.

[python3kgae]

Remove intrinsic, add DXILOpBuilder to create DXIL op function calls.

[nlopes]

Please avoid using UndefValue::get whenever possible as we are trying to get rid of undef. Please use PoisonValue. Thank you!

[python3kgae]

Change UndefValue to PoisonValue.

[nhaehnle]

llvm/include/llvm/IR/IntrinsicsDXIL.td

22 ↗

(On Diff #441076)

FWIW, we have a similar issue in LLPC, our SPIR-V-to-AMDGPU-backend shader compiler. The backend has a family of llvm.amdgcn.buffer.load/store intrinsics that take a buffer descriptor and offset arguments. We generate those from load/store/atomic/gep on a "fat pointer" address space in this pass: https://github.com/GPUOpen-Drivers/llpc/blob/dev/lgc/patch/PatchBufferOp.cpp

I don't really have more thoughts on the issue right now, but I believe it is a very similar problem and so a future exchange of thoughts may well be helpful.

For example, it is not clear to me what the "correct" place for lowering these loads and store is. What AMDGPU and LLPC do has evolved historically. I'd say it's fairly reasonable, we did learn that pushing the lowering to be later is helpful in our case but pushing it all the way to a MIR pass (which the DXIL backend doesn't use anyway) would have been a painful amount of work.

[beanz]

This change adds a bunch of functionality with no tests. How are the new dxil ops generated?

I feel like you have two changes going in here at once. One is a refactor that is probably NFC, and the other is adding some operations that aren't used anywhere. These should be two separate changes, and we shouldn't add the operations until we have codegen in place so that we know how we're going to generate them.

llvm/lib/Target/DirectX/CMakeLists.txt

 add_public_tablegen_target(DirectXCommonTableGen)
 
 add_llvm_target(DirectXCodeGen
   DirectXAsmPrinter.cpp
   DirectXInstrInfo.cpp
   DirectXRegisterInfo.cpp
   DirectXSubtarget.cpp
   DirectXTargetMachine.cpp
+  DXILOpBuilder.cpp
   DXILOpLowering.cpp
   DXILPointerType.cpp
   DXILPrepare.cpp
   DXILTranslateMetadata.cpp
   PointerTypeAnalysis.cpp
 
   LINK_COMPONENTS
   Core

llvm/lib/Target/DirectX/DXIL.td

 }
 
 def Unary : dxil_class<"Unary">;
 def Binary : dxil_class<"Binary">;
 def FlattenedThreadIdInGroupClass : dxil_class<"FlattenedThreadIdInGroup">;
 def ThreadIdInGroupClass : dxil_class<"ThreadIdInGroup">;
 def ThreadIdClass : dxil_class<"ThreadId">;
 def GroupIdClass : dxil_class<"GroupId">;
+def BufferLoadClass : dxil_class<"BufferLoad">;
+def BufferStoreClass : dxil_class<"BufferStore">;
+def CreateHandleClass : dxil_class<"CreateHandle">;
 
 def binary_uint : dxil_category<"Binary uint">;
 def unary_float : dxil_category<"Unary float">;
 def ComputeID : dxil_category<"Compute/Mesh/Amplification shader">;
-
+def Resources : dxil_category<"Resources">;
 
 // The parameter description for a DXIL instruction
 class dxil_param<int _pos, string type, string _name, string _doc,
                  bit _is_const = 0, string _enum_name = "",
                  int _max_value = 0> {
   int pos = _pos;           // position in parameter list
   string llvm_type = type; // llvm type name, $o for overload, $r for resource
                            // type, $cb for legacy cbuffer, $u4 for u4 struct

 
 def FlattenedThreadIdInGroup :dxil_op< "FlattenedThreadIdInGroup", 96,  FlattenedThreadIdInGroupClass, ComputeID,
    "provides a flattened index for a given thread within a given group (SV_GroupIndex)", "i32;",  "rn",
   [
     dxil_param<0,  "i32",  "",  "result">,
     dxil_param<1,  "i32",  "opcode",  "DXIL opcode">
   ]>,
   dxil_map_intrinsic<int_dxil_flattened_thread_id_in_group>;
+
+def BufferLoad : dxil_op< "BufferLoad", 68, BufferLoadClass,Resources, "reads from a TypedBuffer", "half;float;i16;i32;", "ro",
+  [
+    dxil_param<0, "dx.types.ResRet", "", "the loaded value">,
+    dxil_param<1, "i32",  "opcode",  "DXIL opcode">,
+    dxil_param<2, "dx.types.Handle", "srv", "handle of TypedBuffer SRV to sample">,
+    dxil_param<3, "i32", "index", "element index">,
+    dxil_param<4, "i32", "wot", "coordinate">
+  ],
+  ["tex_load"]>;
+
+def BufferStore : dxil_op< "BufferStore", 69, BufferStoreClass, Resources, "writes to a RWTypedBuffer", "half;float;i16;i32;", "",
+  [
+    dxil_param<0, "void", "", "">,
+    dxil_param<1, "i32",  "opcode",  "DXIL opcode">,
+    dxil_param<2, "dx.types.Handle", "uav", "handle of UAV to store to">,
+    dxil_param<3, "i32", "coord0", "coordinate in elements">,
+    dxil_param<4, "i32", "coord1", "coordinate (unused?)">,
+    dxil_param<5, "$o", "value0", "value">,
+    dxil_param<6, "$o", "value1", "value">,
+    dxil_param<7, "$o", "value2", "value">,
+    dxil_param<8, "$o", "value3", "value">,
+    dxil_param<9, "i8", "mask", "written value mask">
+  ],
+  ["tex_store"]>;
+
+def CreateHandle : dxil_op< "CreateHandle", 57, CreateHandleClass, Resources, "creates the handle to a resource",
+  "void;", "ro",
+  [
+    dxil_param<0, "dx.types.Handle", "", "the handle to the resource">,
+    dxil_param<1, "i32",  "opcode",  "DXIL opcode">,
+    dxil_param<2, "i8", "resourceClass", "the class of resource to create (SRV, UAV, CBuffer, Sampler)", 1>, // maps to DxilResourceBase::Class
+    dxil_param<3, "i32", "rangeId", "range identifier for resource", 1>,
+    dxil_param<4, "i32", "index", "zero-based index into range">,
+    dxil_param<5, "i1", "nonUniformIndex", "non-uniform resource index", 1>
+  ]>;

llvm/lib/Target/DirectX/DXILConstants.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_DIRECTX_DXILCONSTANTS_H
 #define LLVM_LIB_TARGET_DIRECTX_DXILCONSTANTS_H
 
 namespace llvm {
 namespace DXIL {
 
+enum class ResourceClass { SRV = 0, UAV, CBuffer, Sampler, Invalid };
+
 #define DXIL_OP_ENUM
 #include "DXILOperation.inc"
 #undef DXIL_OP_ENUM
 
 } // namespace DXIL
 } // namespace llvm
 
 #endif

llvm/lib/Target/DirectX/DXILOpBuilder.h

+//===- DXILOpBuilder.h - Helper class for build DIXLOp functions ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This file contains class to help build DXIL op functions.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_DIRECTX_DXILOPBUILDER_H
+#define LLVM_LIB_TARGET_DIRECTX_DXILOPBUILDER_H
+
+#include "DXILConstants.h"
+#include "llvm/ADT/iterator_range.h"
+
+namespace llvm {
+class Module;
+class IRBuilderBase;
+class CallInst;
+class Value;
+class Type;
+class FunctionType;
+class Use;
+
+namespace DXIL {
+
+class DXILOpBuilder {
+public:
+  DXILOpBuilder(Module &M, IRBuilderBase &B) : M(M), B(B) {}
+  CallInst *createCreateHandle(Type *OverloadTy, int8_t ResClass, int RangeID,
+                               Value *Index, bool NonUniformIndex);
+  CallInst *createBufferLoad(Type *OverloadTy, Value *Hdl, Value *Coord0,
+                             Value *Coord1);
+  CallInst *createBufferStore(Type *OverloadTy, Value *Hdl, Value *Coord0,
+                              Value *Coord1, Value *V0, Value *V1, Value *V2,
+                              Value *V3, Value *Mask);
+  CallInst *createDXILOpCall(DXIL::OpCode OpCode, Type *OverloadTy,
+                             llvm::iterator_range<Use *> Args);
+  Type *getOverloadTy(DXIL::OpCode OpCode, FunctionType *FT,
+                      bool NoOpCodeParam);
+  static const char *getOpCodeName(DXIL::OpCode DXILOp);
+
+private:
+  Module &M;
+  IRBuilderBase &B;
+};
+
+} // namespace DXIL
+} // namespace llvm
+
+#endif

llvm/lib/Target/DirectX/DXILOpBuilder.cpp

+//===- DXILOpBuilder.cpp - Helper class for build DIXLOp functions --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This file contains class to help build DXIL op functions.
+//===----------------------------------------------------------------------===//
+
+#include "DXILOpBuilder.h"
+#include "DXILConstants.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/ErrorHandling.h"
+
+using namespace llvm;
+using namespace llvm::DXIL;
+
+constexpr StringLiteral DXILOpNamePrefix = "dx.op.";
+
+namespace {
+
+enum OverloadKind : uint16_t {
+  VOID = 1,
+  HALF = 1 << 1,
+  FLOAT = 1 << 2,
+  DOUBLE = 1 << 3,
+  I1 = 1 << 4,
+  I8 = 1 << 5,
+  I16 = 1 << 6,
+  I32 = 1 << 7,
+  I64 = 1 << 8,
+  UserDefineType = 1 << 9,
+  ObjectType = 1 << 10,
+};
+// NOTE: keep sync with ParameterKind in utils/TableGen/DXILEmitter.cpp.
+enum class ParameterKind : uint8_t {
+  INVALID = 0,
+  VOID,
+  HALF,
+  FLOAT,
+  DOUBLE,
+  I1,
+  I8,
+  I16,
+  I32,
+  I64,
+  OVERLOAD,
+  CBUFFER_RET,
+  RESOURCE_RET,
+  DXIL_HANDLE,
+};
+} // namespace
+
+static const char *getOverloadTypeName(OverloadKind Kind) {
+  switch (Kind) {
+  case OverloadKind::HALF:
+    return "f16";
+  case OverloadKind::FLOAT:
+    return "f32";
+  case OverloadKind::DOUBLE:
+    return "f64";
+  case OverloadKind::I1:
+    return "i1";
+  case OverloadKind::I8:
+    return "i8";
+  case OverloadKind::I16:
+    return "i16";
+  case OverloadKind::I32:
+    return "i32";
+  case OverloadKind::I64:
+    return "i64";
+  case OverloadKind::VOID:
+  case OverloadKind::ObjectType:
+  case OverloadKind::UserDefineType:
+    break;
+  }
+  llvm_unreachable("invalid overload type for name");
+  return "void";
+}
+
+static OverloadKind getOverloadKind(Type *Ty) {
+  Type::TypeID T = Ty->getTypeID();
+  switch (T) {
+  case Type::VoidTyID:
+    return OverloadKind::VOID;
+  case Type::HalfTyID:
+    return OverloadKind::HALF;
+  case Type::FloatTyID:
+    return OverloadKind::FLOAT;
+  case Type::DoubleTyID:
+    return OverloadKind::DOUBLE;
+  case Type::IntegerTyID: {
+    IntegerType *ITy = cast<IntegerType>(Ty);
+    unsigned Bits = ITy->getBitWidth();
+    switch (Bits) {
+    case 1:
+      return OverloadKind::I1;
+    case 8:
+      return OverloadKind::I8;
+    case 16:
+      return OverloadKind::I16;
+    case 32:
+      return OverloadKind::I32;
+    case 64:
+      return OverloadKind::I64;
+    default:
+      llvm_unreachable("invalid overload type");
+      return OverloadKind::VOID;
+    }
+  }
+  case Type::PointerTyID:
+    return OverloadKind::UserDefineType;
+  case Type::StructTyID:
+    return OverloadKind::ObjectType;
+  default:
+    llvm_unreachable("invalid overload type");
+    return OverloadKind::VOID;
+  }
+}
+
+static std::string getTypeName(OverloadKind Kind, Type *Ty) {
+  if (Kind < OverloadKind::UserDefineType) {
+    return getOverloadTypeName(Kind);
+  } else if (Kind == OverloadKind::UserDefineType) {
+    StructType *ST = cast<StructType>(Ty);
+    return ST->getStructName().str();
+  } else if (Kind == OverloadKind::ObjectType) {
+    StructType *ST = cast<StructType>(Ty);
+    return ST->getStructName().str();
+  } else {
+    std::string Str;
+    raw_string_ostream OS(Str);
+    Ty->print(OS);
+    return OS.str();
+  }
+}
+
+// Static properties.
+struct OpCodeProperty {
+  DXIL::OpCode OpCode;
+  // Offset in DXILOpCodeNameTable.
+  unsigned OpCodeNameOffset;
+  DXIL::OpCodeClass OpCodeClass;
+  // Offset in DXILOpCodeClassNameTable.
+  unsigned OpCodeClassNameOffset;
+  uint16_t OverloadTys;
+  llvm::Attribute::AttrKind FuncAttr;
+  int OverloadParamIndex;        // parameter index which control the overload.
+                                 // When < 0, should be only 1 overload type.
+  unsigned NumOfParameters;      // Number of parameters include return value.
+  unsigned ParameterTableOffset; // Offset in ParameterTable.
+};
+
+// Include getOpCodeClassName getOpCodeProperty, getOpCodeName and
+// getOpCodeParameterKind which generated by tableGen.
+#define DXIL_OP_OPERATION_TABLE
+#include "DXILOperation.inc"
+#undef DXIL_OP_OPERATION_TABLE
+
+static std::string constructOverloadName(OverloadKind Kind, Type *Ty,
+                                         const OpCodeProperty &Prop) {
+  if (Kind == OverloadKind::VOID) {
+    return (Twine(DXILOpNamePrefix) + getOpCodeClassName(Prop)).str();
+  }
+  return (Twine(DXILOpNamePrefix) + getOpCodeClassName(Prop) + "." +
+          getTypeName(Kind, Ty))
+      .str();
+}
+
+static std::string constructOverloadTypeName(OverloadKind Kind,
+                                             StringRef TypeName) {
+  if (Kind == OverloadKind::VOID)
+    return TypeName.str();
+
+  assert(Kind < OverloadKind::UserDefineType && "invalid overload kind");
+  return (Twine(TypeName) + getOverloadTypeName(Kind)).str();
+}
+
+static StructType *getOrCreateStructType(StringRef Name,
+                                         ArrayRef<Type *> EltTys,
+                                         LLVMContext &Ctx) {
+  StructType *ST = StructType::getTypeByName(Ctx, Name);
+  if (ST)
+    return ST;
+
+  return StructType::create(Ctx, EltTys, Name);
+}
+
+static StructType *getResRetType(Type *OverloadTy, LLVMContext &Ctx) {
+  OverloadKind Kind = getOverloadKind(OverloadTy);
+  std::string TypeName = constructOverloadTypeName(Kind, "dx.types.ResRet.");
+  Type *FieldTypes[5] = {OverloadTy, OverloadTy, OverloadTy, OverloadTy,
+                         Type::getInt32Ty(Ctx)};
+  return getOrCreateStructType(TypeName, FieldTypes, Ctx);
+}
+
+static StructType *getHandleType(LLVMContext &Ctx) {
+  return getOrCreateStructType("dx.types.Handle", Type::getInt8PtrTy(Ctx), Ctx);
+}
+
+static Type *getTypeFromParameterKind(ParameterKind Kind, Type *OverloadTy) {
+  auto &Ctx = OverloadTy->getContext();
+  switch (Kind) {
+  case ParameterKind::VOID:
+    return Type::getVoidTy(Ctx);
+  case ParameterKind::HALF:
+    return Type::getHalfTy(Ctx);
+  case ParameterKind::FLOAT:
+    return Type::getFloatTy(Ctx);
+  case ParameterKind::DOUBLE:
+    return Type::getDoubleTy(Ctx);
+  case ParameterKind::I1:
+    return Type::getInt1Ty(Ctx);
+  case ParameterKind::I8:
+    return Type::getInt8Ty(Ctx);
+  case ParameterKind::I16:
+    return Type::getInt16Ty(Ctx);
+  case ParameterKind::I32:
+    return Type::getInt32Ty(Ctx);
+  case ParameterKind::I64:
+    return Type::getInt64Ty(Ctx);
+  case ParameterKind::OVERLOAD:
+    return OverloadTy;
+  case ParameterKind::RESOURCE_RET:
+    return getResRetType(OverloadTy, Ctx);
+  case ParameterKind::DXIL_HANDLE:
+    return getHandleType(Ctx);
+  default:
+    break;
+  }
+  llvm_unreachable("Invalid parameter kind");
+  return nullptr;
+}
+
+static FunctionType *getDXILOpFunctionType(const OpCodeProperty *Prop,
+                                           Type *OverloadTy) {
+  SmallVector<Type *> ArgTys;
+
+  auto ParamKinds = getOpCodeParameterKind(*Prop);
+
+  for (unsigned I = 0; I < Prop->NumOfParameters; ++I) {
+    ParameterKind Kind = ParamKinds[I];
+    ArgTys.emplace_back(getTypeFromParameterKind(Kind, OverloadTy));
+  }
+  return FunctionType::get(
+      ArgTys[0], ArrayRef<Type *>(&ArgTys[1], ArgTys.size() - 1), false);
+}
+
+static FunctionCallee getOrCreateDXILOpFunction(DXIL::OpCode DXILOp,
+                                                Type *OverloadTy, Module &M) {
+  const OpCodeProperty *Prop = getOpCodeProperty(DXILOp);
+
+  OverloadKind Kind = getOverloadKind(OverloadTy);
+  // FIXME: find the issue and report error in clang instead of check it in
+  // backend.
+  if ((Prop->OverloadTys & (uint16_t)Kind) == 0) {
+    llvm_unreachable("invalid overload");
+  }
+
+  std::string FnName = constructOverloadName(Kind, OverloadTy, *Prop);
+  // Dependent on name to dedup.
+  if (auto *Fn = M.getFunction(FnName))
+    return FunctionCallee(Fn);
+
+  FunctionType *DXILOpFT = getDXILOpFunctionType(Prop, OverloadTy);
+  return M.getOrInsertFunction(FnName, DXILOpFT);
+}
+
+namespace llvm {
+namespace DXIL {
+
+CallInst *DXILOpBuilder::createCreateHandle(Type *OverloadTy, int8_t ResClass,
+                                            int RangeID, Value *Index,
+                                            bool NonUniformIndex) {
+  auto Fn =
+      getOrCreateDXILOpFunction(DXIL::OpCode::CreateHandle, OverloadTy, M);
+  return B.CreateCall(Fn, {B.getInt32((int32_t)DXIL::OpCode::CreateHandle),
+                           B.getInt8(ResClass), B.getInt32(RangeID), Index,
+                           B.getInt1(NonUniformIndex)});
+}
+
+CallInst *DXILOpBuilder::createBufferLoad(Type *OverloadTy, Value *Hdl,
+                                          Value *Coord0, Value *Coord1) {
+  auto Fn = getOrCreateDXILOpFunction(DXIL::OpCode::BufferLoad, OverloadTy, M);
+  return B.CreateCall(
+      Fn, {B.getInt32((int32_t)DXIL::OpCode::BufferLoad), Hdl, Coord0, Coord1});
+}
+CallInst *DXILOpBuilder::createBufferStore(Type *OverloadTy, Value *Hdl,
+                                           Value *Coord0, Value *Coord1,
+                                           Value *V0, Value *V1, Value *V2,
+                                           Value *V3, Value *Mask) {
+  auto Fn = getOrCreateDXILOpFunction(DXIL::OpCode::BufferStore, OverloadTy, M);
+  return B.CreateCall(Fn, {B.getInt32((int32_t)DXIL::OpCode::BufferStore), Hdl,
+                           Coord0, Coord1, V0, V1, V2, V3, Mask});
+}
+
+CallInst *DXILOpBuilder::createDXILOpCall(DXIL::OpCode OpCode, Type *OverloadTy,
+                                          llvm::iterator_range<Use *> Args) {
+  auto Fn = getOrCreateDXILOpFunction(OpCode, OverloadTy, M);
+  SmallVector<Value *> FullArgs;
+  FullArgs.emplace_back(B.getInt32((int32_t)OpCode));
+  FullArgs.append(Args.begin(), Args.end());
+  return B.CreateCall(Fn, FullArgs);
+}
+
+Type *DXILOpBuilder::getOverloadTy(DXIL::OpCode OpCode, FunctionType *FT,
+                                   bool NoOpCodeParam) {
+
+  const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
+  if (Prop->OverloadParamIndex < 0) {
+    auto &Ctx = FT->getContext();
+    // When only has 1 overload type, just return it.
+    switch (Prop->OverloadTys) {
+    case OverloadKind::VOID:
+      return Type::getVoidTy(Ctx);
+    case OverloadKind::HALF:
+      return Type::getHalfTy(Ctx);
+    case OverloadKind::FLOAT:
+      return Type::getFloatTy(Ctx);
+    case OverloadKind::DOUBLE:
+      return Type::getDoubleTy(Ctx);
+    case OverloadKind::I1:
+      return Type::getInt1Ty(Ctx);
+    case OverloadKind::I8:
+      return Type::getInt8Ty(Ctx);
+    case OverloadKind::I16:
+      return Type::getInt16Ty(Ctx);
+    case OverloadKind::I32:
+      return Type::getInt32Ty(Ctx);
+    case OverloadKind::I64:
+      return Type::getInt64Ty(Ctx);
+    default:
+      llvm_unreachable("invalid overload type");
+      return nullptr;
+    }
+  }
+
+  // Prop->OverloadParamIndex is 0, overload type is FT->getReturnType().
+  Type *OverloadType = FT->getReturnType();
+  if (Prop->OverloadParamIndex != 0) {
+    // Skip Return Type and Type for DXIL opcode.
+    const unsigned SkipedParam = NoOpCodeParam ? 2 : 1;
+    OverloadType = FT->getParamType(Prop->OverloadParamIndex - SkipedParam);
+  }
+
+  auto ParamKinds = getOpCodeParameterKind(*Prop);
+  auto Kind = ParamKinds[Prop->OverloadParamIndex];
+  // For ResRet and CBufferRet, OverloadTy is in field of StructType.
+  if (Kind == ParameterKind::CBUFFER_RET ||
+      Kind == ParameterKind::RESOURCE_RET) {
+    auto *ST = cast<StructType>(OverloadType);
+    OverloadType = ST->getElementType(0);
+  }
+  return OverloadType;
+}
+
+const char *DXILOpBuilder::getOpCodeName(DXIL::OpCode DXILOp) {
+  return ::getOpCodeName(DXILOp);
+}
+} // namespace DXIL
+} // namespace llvm

llvm/lib/Target/DirectX/DXILOpLowering.cpp

 //===- DXILOpLower.cpp - Lowering LLVM intrinsic to DIXLOp function -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file This file contains passes and utilities to lower llvm intrinsic call
 /// to DXILOp function call.
 //===----------------------------------------------------------------------===//
 
 #include "DXILConstants.h"
+#include "DXILOpBuilder.h"
 #include "DirectX.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/IntrinsicsDirectX.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/ErrorHandling.h"
 
 #define DEBUG_TYPE "dxil-op-lower"
 
 using namespace llvm;
 using namespace llvm::DXIL;
 
-constexpr StringLiteral DXILOpNamePrefix = "dx.op.";
-
-enum OverloadKind : uint16_t {
-  VOID = 1,
-  HALF = 1 << 1,
-  FLOAT = 1 << 2,
-  DOUBLE = 1 << 3,
-  I1 = 1 << 4,
-  I8 = 1 << 5,
-  I16 = 1 << 6,
-  I32 = 1 << 7,
-  I64 = 1 << 8,
-  UserDefineType = 1 << 9,
-  ObjectType = 1 << 10,
-};
-
-static const char *getOverloadTypeName(OverloadKind Kind) {
-  switch (Kind) {
-  case OverloadKind::HALF:
-    return "f16";
-  case OverloadKind::FLOAT:
-    return "f32";
-  case OverloadKind::DOUBLE:
-    return "f64";
-  case OverloadKind::I1:
-    return "i1";
-  case OverloadKind::I8:
-    return "i8";
-  case OverloadKind::I16:
-    return "i16";
-  case OverloadKind::I32:
-    return "i32";
-  case OverloadKind::I64:
-    return "i64";
-  case OverloadKind::VOID:
-  case OverloadKind::ObjectType:
-  case OverloadKind::UserDefineType:
-    break;
-  }
-  llvm_unreachable("invalid overload type for name");
-  return "void";
-}
-
-static OverloadKind getOverloadKind(Type *Ty) {
-  Type::TypeID T = Ty->getTypeID();
-  switch (T) {
-  case Type::VoidTyID:
-    return OverloadKind::VOID;
-  case Type::HalfTyID:
-    return OverloadKind::HALF;
-  case Type::FloatTyID:
-    return OverloadKind::FLOAT;
-  case Type::DoubleTyID:
-    return OverloadKind::DOUBLE;
-  case Type::IntegerTyID: {
-    IntegerType *ITy = cast<IntegerType>(Ty);
-    unsigned Bits = ITy->getBitWidth();
-    switch (Bits) {
-    case 1:
-      return OverloadKind::I1;
-    case 8:
-      return OverloadKind::I8;
-    case 16:
-      return OverloadKind::I16;
-    case 32:
-      return OverloadKind::I32;
-    case 64:
-      return OverloadKind::I64;
-    default:
-      llvm_unreachable("invalid overload type");
-      return OverloadKind::VOID;
-    }
-  }
-  case Type::PointerTyID:
-    return OverloadKind::UserDefineType;
-  case Type::StructTyID:
-    return OverloadKind::ObjectType;
-  default:
-    llvm_unreachable("invalid overload type");
-    return OverloadKind::VOID;
-  }
-}
-
-static std::string getTypeName(OverloadKind Kind, Type *Ty) {
-  if (Kind < OverloadKind::UserDefineType) {
-    return getOverloadTypeName(Kind);
-  } else if (Kind == OverloadKind::UserDefineType) {
-    StructType *ST = cast<StructType>(Ty);
-    return ST->getStructName().str();
-  } else if (Kind == OverloadKind::ObjectType) {
-    StructType *ST = cast<StructType>(Ty);
-    return ST->getStructName().str();
-  } else {
-    std::string Str;
-    raw_string_ostream OS(Str);
-    Ty->print(OS);
-    return OS.str();
-  }
-}
-
-// Static properties.
-struct OpCodeProperty {
-  DXIL::OpCode OpCode;
-  // Offset in DXILOpCodeNameTable.
-  unsigned OpCodeNameOffset;
-  DXIL::OpCodeClass OpCodeClass;
-  // Offset in DXILOpCodeClassNameTable.
-  unsigned OpCodeClassNameOffset;
-  uint16_t OverloadTys;
-  llvm::Attribute::AttrKind FuncAttr;
-};
-
-// Include getOpCodeClassName getOpCodeProperty and getOpCodeName which
-// generated by tableGen.
-#define DXIL_OP_OPERATION_TABLE
-#include "DXILOperation.inc"
-#undef DXIL_OP_OPERATION_TABLE
-
-static std::string constructOverloadName(OverloadKind Kind, Type *Ty,
-                                         const OpCodeProperty &Prop) {
-  if (Kind == OverloadKind::VOID) {
-    return (Twine(DXILOpNamePrefix) + getOpCodeClassName(Prop)).str();
-  }
-  return (Twine(DXILOpNamePrefix) + getOpCodeClassName(Prop) + "." +
-          getTypeName(Kind, Ty))
-      .str();
-}
-
-static FunctionCallee createDXILOpFunction(DXIL::OpCode DXILOp, Function &F,
-                                           Module &M) {
-  const OpCodeProperty *Prop = getOpCodeProperty(DXILOp);
-
-  // Get return type as overload type for DXILOp.
-  // Only simple mapping case here, so return type is good enough.
-  Type *OverloadTy = F.getReturnType();
-
-  OverloadKind Kind = getOverloadKind(OverloadTy);
-  // FIXME: find the issue and report error in clang instead of check it in
-  // backend.
-  if ((Prop->OverloadTys & (uint16_t)Kind) == 0) {
-    llvm_unreachable("invalid overload");
-  }
-
-  std::string FnName = constructOverloadName(Kind, OverloadTy, *Prop);
-  assert(!M.getFunction(FnName) && "Function already exists");
-
-  auto &Ctx = M.getContext();
-  Type *OpCodeTy = Type::getInt32Ty(Ctx);
-
-  SmallVector<Type *> ArgTypes;
-  // DXIL has i32 opcode as first arg.
-  ArgTypes.emplace_back(OpCodeTy);
-  FunctionType *FT = F.getFunctionType();
-  ArgTypes.append(FT->param_begin(), FT->param_end());
-  FunctionType *DXILOpFT = FunctionType::get(OverloadTy, ArgTypes, false);
-  return M.getOrInsertFunction(FnName, DXILOpFT);
-}
-
 static void lowerIntrinsic(DXIL::OpCode DXILOp, Function &F, Module &M) {
-  auto DXILOpFn = createDXILOpFunction(DXILOp, F, M);
   IRBuilder<> B(M.getContext());
   Value *DXILOpArg = B.getInt32(static_cast<unsigned>(DXILOp));
+  DXILOpBuilder DXILB(M, B);
+  Type *OverloadTy =
+      DXILB.getOverloadTy(DXILOp, F.getFunctionType(), /*NoOpCodeParam*/ true);
   for (User *U : make_early_inc_range(F.users())) {
     CallInst *CI = dyn_cast<CallInst>(U);
     if (!CI)
       continue;
 
     SmallVector<Value *> Args;
     Args.emplace_back(DXILOpArg);
     Args.append(CI->arg_begin(), CI->arg_end());
     B.SetInsertPoint(CI);
-    CallInst *DXILCI = B.CreateCall(DXILOpFn, Args);
-    LLVM_DEBUG(DXILCI->setName(getOpCodeName(DXILOp)));
+    CallInst *DXILCI = DXILB.createDXILOpCall(DXILOp, OverloadTy, CI->args());
+
     CI->replaceAllUsesWith(DXILCI);
     CI->eraseFromParent();
   }
   if (F.user_empty())
     F.eraseFromParent();
 }
 
 static bool lowerIntrinsics(Module &M) {

llvm/unittests/Target/DirectX/CMakeLists.txt

 include_directories(
   ${LLVM_MAIN_SRC_DIR}/lib/Target/DirectX
   ${LLVM_BINARY_DIR}/lib/Target/DirectX
   )
 
 set(LLVM_LINK_COMPONENTS
   AsmParser
   Core
   DirectXCodeGen
   Support
 )
 
 add_llvm_target_unittest(DirectXTests
+  DXILOpBuilderTest.cpp
   PointerTypeAnalysisTests.cpp
   )

llvm/unittests/Target/DirectX/DXILOpBuilderTest.cpp

+//===- llvm/unittest/Target/DirectX/DXILOpBuilderTest.cpp -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "DXILOpBuilder.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/IntrinsicsDirectX.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::DXIL;
+using ::testing::UnorderedElementsAre;
+
+namespace {
+
+class DXILOpBuilderTest : public testing::Test {
+protected:
+  void SetUp() override {
+    M.reset(new Module("MyModule", Ctx));
+    FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
+                                          /*isVarArg=*/false);
+    F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
+    BB = BasicBlock::Create(Ctx, "", F);
+    GV = new GlobalVariable(*M, Type::getFloatTy(Ctx), true,
+                            GlobalValue::ExternalLinkage, nullptr);
+  }
+
+  void TearDown() override {
+    BB = nullptr;
+    M.reset();
+  }
+
+  LLVMContext Ctx;
+  std::unique_ptr<Module> M;
+  Function *F;
+  BasicBlock *BB;
+  GlobalVariable *GV;
+};
+
+TEST_F(DXILOpBuilderTest, createDXILOpCall) {
+  IRBuilder<> Builder(BB);
+  Value *V;
+  Instruction *I;
+  CallInst *Call;
+  V = Builder.CreateLoad(GV->getValueType(), GV);
+  I = cast<Instruction>(Builder.CreateFAdd(V, V));
+  Call = Builder.CreateUnaryIntrinsic(Intrinsic::sin, V, I);
+
+  DXILOpBuilder B(*M, Builder);
+  auto *Sin = B.createDXILOpCall(DXIL::OpCode::Sin, Type::getFloatTy(Ctx),
+                                 Call->args());
+  auto *SinFn = cast<Function>(Sin->getCalledFunction());
+  EXPECT_STREQ(SinFn->getName().str().data(), "dx.op.unary.f32");
+  auto *FT = SinFn->getFunctionType();
+  EXPECT_EQ(FT->getNumParams(), (unsigned)2);
+  EXPECT_TRUE(FT->getReturnType()->isFloatTy());
+  EXPECT_TRUE(FT->getParamType(0)->isIntegerTy(32));
+  EXPECT_TRUE(FT->getParamType(1)->isFloatTy());
+}
+
+TEST_F(DXILOpBuilderTest, createBufferLoad) {
+  IRBuilder<> Builder(BB);
+
+  DXILOpBuilder B(*M, Builder);
+  CallInst *Hdl = B.createCreateHandle(Type::getVoidTy(Ctx),
+                                       (int8_t)DXIL::ResourceClass::SRV, 0,
+                                       Builder.getInt32(0),
+                                       /*NonUniformIndex*/ false);
+  CallInst *BufLoad =
+      B.createBufferLoad(Type::getInt32Ty(Ctx), Hdl, Builder.getInt32(0),
+                         PoisonValue::get(Builder.getInt32Ty()));
+  Type *HdlTy = Hdl->getType();
+  EXPECT_TRUE(HdlTy->isStructTy());
+  if (StructType *ST = dyn_cast<StructType>(HdlTy))
+    EXPECT_STREQ(ST->getName().str().data(), "dx.types.Handle");
+  EXPECT_STREQ(Hdl->getCalledFunction()->getName().str().data(),
+               "dx.op.createHandle");
+
+  Type *ResRetTy = BufLoad->getType();
+  EXPECT_TRUE(ResRetTy->isStructTy());
+  if (StructType *ST = dyn_cast<StructType>(ResRetTy))
+    EXPECT_STREQ(ST->getName().str().data(), "dx.types.ResRet.i32");
+  EXPECT_STREQ(BufLoad->getCalledFunction()->getName().str().data(),
+               "dx.op.bufferLoad.i32");
+}
+
+TEST_F(DXILOpBuilderTest, createBufferStore) {
+  IRBuilder<> Builder(BB);
+
+  DXILOpBuilder B(*M, Builder);
+  CallInst *Hdl = B.createCreateHandle(Type::getVoidTy(Ctx),
+                                       (int8_t)DXIL::ResourceClass::UAV, 0,
+                                       Builder.getInt32(0),
+                                       /*NonUniformIndex*/ false);
+  Value *V = Builder.CreateLoad(GV->getValueType(), GV);
+  auto *UndefV = PoisonValue::get(V->getType());
+
+  CallInst *BufStore =
+      B.createBufferStore(Type::getFloatTy(Ctx), Hdl, Builder.getInt32(0),
+                          PoisonValue::get(Builder.getInt32Ty()), V, UndefV,
+                          UndefV, UndefV, Builder.getInt8(1));
+
+  Type *HdlTy = Hdl->getType();
+  EXPECT_TRUE(HdlTy->isStructTy());
+  if (StructType *ST = dyn_cast<StructType>(HdlTy))
+    EXPECT_STREQ(ST->getName().str().data(), "dx.types.Handle");
+  EXPECT_STREQ(Hdl->getCalledFunction()->getName().str().data(),
+               "dx.op.createHandle");
+
+  EXPECT_TRUE(BufStore->getType()->isVoidTy());
+  EXPECT_STREQ(BufStore->getCalledFunction()->getName().str().data(),
+               "dx.op.bufferStore.f32");
+}
+
+TEST_F(DXILOpBuilderTest, getOverloadTy) {
+  IRBuilder<> Builder(BB);
+  Function *ThreadID =
+      Intrinsic::getDeclaration(M.get(), Intrinsic::dxil_thread_id);
+  DXILOpBuilder B(*M, Builder);
+  Type *OverloadTy =
+      B.getOverloadTy(DXIL::OpCode::ThreadId, ThreadID->getFunctionType(),
+                      /*NoOpCodeParam*/ false);
+  EXPECT_TRUE(OverloadTy->isIntegerTy(32));
+}
+
+TEST_F(DXILOpBuilderTest, getOpCodeName) {
+  IRBuilder<> Builder(BB);
+  DXILOpBuilder B(*M, Builder);
+  auto UMax = B.getOpCodeName(DXIL::OpCode::UMax);
+  EXPECT_STREQ(UMax, "UMax");
+}
+
+} // namespace

llvm/utils/TableGen/DXILEmitter.cpp

 using namespace llvm;
 
 namespace {
 
 struct DXILShaderModel {
   int Major;
   int Minor;
 };
+
+enum class ParameterKind : uint8_t {
+  INVALID = 0,
+  VOID,
+  HALF,
+  FLOAT,
+  DOUBLE,
+  I1,
+  I8,
+  I16,
+  I32,
+  I64,
+  OVERLOAD,
+  CBUFFER_RET,
+  RESOURCE_RET,
+  DXIL_HANDLE,
+};
+
 struct DXILParam {
-  int Pos;        // position in parameter list
-  StringRef Type; // llvm type name, $o for overload, $r for resource
-                  // type, $cb for legacy cbuffer, $u4 for u4 struct
+  int Pos; // position in parameter list
+  ParameterKind Kind;
   StringRef Name; // short, unique name
   StringRef Doc;  // the documentation description of this parameter
   bool IsConst;   // whether this argument requires a constant value in the IR
   StringRef EnumName; // the name of the enum type if applicable
   int MaxValue;       // the maximum value for this parameter if applicable
-  DXILParam(const Record *R) {
-    Name = R->getValueAsString("name");
-    Pos = R->getValueAsInt("pos");
-    Type = R->getValueAsString("llvm_type");
-    if (R->getValue("doc"))
-      Doc = R->getValueAsString("doc");
-    IsConst = R->getValueAsBit("is_const");
-    EnumName = R->getValueAsString("enum_name");
-    MaxValue = R->getValueAsInt("max_value");
-  }
+  DXILParam(const Record *R);
 };
 
 struct DXILOperationData {
   StringRef Name; // short, unique name
 
   StringRef DXILOp;    // name of DXIL operation
   int DXILOpID;        // ID of DXIL operation
   StringRef DXILClass; // name of the opcode class
struct DXILOperationData {
   bool IsWave; // whether this requires in-wave, cross-lane functionality
   bool RequiresUniformInputs; // whether this operation requires that all
                               // of its inputs are uniform across the wave
   SmallVector<StringRef, 4>
       ShaderStages; // shader stages to which this applies, empty for all.
   DXILShaderModel ShaderModel;           // minimum shader model required
   DXILShaderModel ShaderModelTranslated; // minimum shader model required with
                                          // translation by linker
-  SmallVector<StringRef, 4> counters;    // counters for this inst.
+  int OverloadParamIndex; // parameter index which control the overload.
+                          // When < 0, should be only 1 overload type.
+  SmallVector<StringRef, 4> counters; // counters for this inst.
   DXILOperationData(const Record *R) {
     Name = R->getValueAsString("name");
     DXILOp = R->getValueAsString("dxil_op");
     DXILOpID = R->getValueAsInt("dxil_opid");
     DXILClass = R->getValueAsDef("op_class")->getValueAsString("name");
     Category = R->getValueAsDef("category")->getValueAsString("name");
 
     if (R->getValue("llvm_intrinsic")) {
       auto *IntrinsicDef = R->getValueAsDef("llvm_intrinsic");
       auto DefName = IntrinsicDef->getName();
       assert(DefName.startswith("int_") && "invalid intrinsic name");
       // Remove the int_ from intrinsic name.
       Intrinsic = DefName.substr(4);
     }
 
     Doc = R->getValueAsString("doc");
 
     ListInit *ParamList = R->getValueAsListInit("ops");
-    for (unsigned i = 0; i < ParamList->size(); ++i) {
-      Record *Param = ParamList->getElementAsRecord(i);
+    OverloadParamIndex = -1;
+    for (unsigned I = 0; I < ParamList->size(); ++I) {
+      Record *Param = ParamList->getElementAsRecord(I);
       Params.emplace_back(DXILParam(Param));
+      auto &CurParam = Params.back();
+      if (CurParam.Kind >= ParameterKind::OVERLOAD)
+        OverloadParamIndex = I;
     }
     OverloadTypes = R->getValueAsString("oload_types");
     FnAttr = R->getValueAsString("fn_attr");
   }
 };
 } // end anonymous namespace
 
+static ParameterKind parameterTypeNameToKind(StringRef Name) {
+  return StringSwitch<ParameterKind>(Name)
+      .Case("void", ParameterKind::VOID)
+      .Case("half", ParameterKind::HALF)
+      .Case("float", ParameterKind::FLOAT)
+      .Case("double", ParameterKind::DOUBLE)
+      .Case("i1", ParameterKind::I1)
+      .Case("i8", ParameterKind::I8)
+      .Case("i16", ParameterKind::I16)
+      .Case("i32", ParameterKind::I32)
+      .Case("i64", ParameterKind::I64)
+      .Case("$o", ParameterKind::OVERLOAD)
+      .Case("dx.types.Handle", ParameterKind::DXIL_HANDLE)
+      .Case("dx.types.CBufRet", ParameterKind::CBUFFER_RET)
+      .Case("dx.types.ResRet", ParameterKind::RESOURCE_RET)
+      .Default(ParameterKind::INVALID);
+}
+
+DXILParam::DXILParam(const Record *R) {
+  Name = R->getValueAsString("name");
+  Pos = R->getValueAsInt("pos");
+  Kind = parameterTypeNameToKind(R->getValueAsString("llvm_type"));
+  if (R->getValue("doc"))
+    Doc = R->getValueAsString("doc");
+  IsConst = R->getValueAsBit("is_const");
+  EnumName = R->getValueAsString("enum_name");
+  MaxValue = R->getValueAsInt("max_value");
+}
+
+static std::string parameterKindToString(ParameterKind Kind) {
+  switch (Kind) {
+  case ParameterKind::INVALID:
+    return "INVALID";
+  case ParameterKind::VOID:
+    return "VOID";
+  case ParameterKind::HALF:
+    return "HALF";
+  case ParameterKind::FLOAT:
+    return "FLOAT";
+  case ParameterKind::DOUBLE:
+    return "DOUBLE";
+  case ParameterKind::I1:
+    return "I1";
+  case ParameterKind::I8:
+    return "I8";
+  case ParameterKind::I16:
+    return "I16";
+  case ParameterKind::I32:
+    return "I32";
+  case ParameterKind::I64:
+    return "I64";
+  case ParameterKind::OVERLOAD:
+    return "OVERLOAD";
+  case ParameterKind::CBUFFER_RET:
+    return "CBUFFER_RET";
+  case ParameterKind::RESOURCE_RET:
+    return "RESOURCE_RET";
+  case ParameterKind::DXIL_HANDLE:
+    return "DXIL_HANDLE";
+  }
+}
+
 static void emitDXILOpEnum(DXILOperationData &DXILOp, raw_ostream &OS) {
   // Name = ID, // Doc
   OS << DXILOp.Name << " = " << DXILOp.DXILOpID << ", // " << DXILOp.Doc
      << "\n";
 }
 
 static std::string buildCategoryStr(StringSet<> &Cetegorys) {
   std::string Str;
static void emitDXILOperationTable(std::vector<DXILOperationData> &DXILOps,
   std::sort(DXILOps.begin(), DXILOps.end(),
             [](DXILOperationData &A, DXILOperationData &B) {
               return A.DXILOpID < B.DXILOpID;
             });
 
   // Collect Names.
   SequenceToOffsetTable<std::string> OpClassStrings;
   SequenceToOffsetTable<std::string> OpStrings;
+  SequenceToOffsetTable<SmallVector<ParameterKind>> Parameters;
 
+  StringMap<SmallVector<ParameterKind>> ParameterMap;
   StringSet<> ClassSet;
   for (auto &DXILOp : DXILOps) {
     OpStrings.add(DXILOp.DXILOp.str());
 
     if (ClassSet.find(DXILOp.DXILClass) != ClassSet.end())
       continue;
     ClassSet.insert(DXILOp.DXILClass);
     OpClassStrings.add(getDXILOpClassName(DXILOp.DXILClass));
+    SmallVector<ParameterKind> ParamKindVec;
+    for (auto &Param : DXILOp.Params) {
+      ParamKindVec.emplace_back(Param.Kind);
+    }
+    ParameterMap[DXILOp.DXILClass] = ParamKindVec;
+    Parameters.add(ParamKindVec);
   }
 
   // Layout names.
   OpStrings.layout();
   OpClassStrings.layout();
+  Parameters.layout();
 
   // Emit the DXIL operation table.
   //{DXIL::OpCode::Sin, OpCodeNameIndex, OpCodeClass::Unary,
   // OpCodeClassNameIndex,
-  // OverloadKind::FLOAT | OverloadKind::HALF, Attribute::AttrKind::ReadNone},
+  // OverloadKind::FLOAT | OverloadKind::HALF, Attribute::AttrKind::ReadNone, 0,
+  // 3, ParameterTableOffset},
   OS << "static const OpCodeProperty *getOpCodeProperty(DXIL::OpCode DXILOp) "
         "{\n";
 
   OS << "  static const OpCodeProperty OpCodeProps[] = {\n";
   for (auto &DXILOp : DXILOps) {
     OS << "  { DXIL::OpCode::" << DXILOp.DXILOp << ", "
        << OpStrings.get(DXILOp.DXILOp.str())
        << ", OpCodeClass::" << DXILOp.DXILClass << ", "
        << OpClassStrings.get(getDXILOpClassName(DXILOp.DXILClass)) << ", "
        << getDXILOperationOverload(DXILOp.OverloadTypes) << ", "
-       << emitDXILOperationFnAttr(DXILOp.FnAttr) << " },\n";
+       << emitDXILOperationFnAttr(DXILOp.FnAttr) << ", "
+       << DXILOp.OverloadParamIndex << ", " << DXILOp.Params.size() << ", "
+       << Parameters.get(ParameterMap[DXILOp.DXILClass]) << " },\n";
   }
   OS << "  };\n";
 
   OS << "  // FIXME: change search to indexing with\n";
   OS << "  // DXILOp once all DXIL op is added.\n";
   OS << "  OpCodeProperty TmpProp;\n";
   OS << "  TmpProp.OpCode = DXILOp;\n";
   OS << "  const OpCodeProperty *Prop =\n";
OS << "static const char *getOpCodeClassName(const OpCodeProperty &Prop) "
         "{\n\n";
 
   OpClassStrings.emitStringLiteralDef(
       OS, "  static const char DXILOpCodeClassNameTable[]");
 
   OS << "  unsigned Index = Prop.OpCodeClassNameOffset;\n";
   OS << "  return DXILOpCodeClassNameTable + Index;\n";
   OS << "}\n ";
+
+  OS << "static const ParameterKind *getOpCodeParameterKind(const "
+        "OpCodeProperty &Prop) "
+        "{\n\n";
+  OS << "  static const ParameterKind DXILOpParameterKindTable[] = {\n";
+  Parameters.emit(
+      OS,
+      [](raw_ostream &ParamOS, ParameterKind Kind) {
+        ParamOS << "ParameterKind::" << parameterKindToString(Kind);
+      },
+      "ParameterKind::INVALID");
+  OS << "  };\n\n";
+  OS << "  unsigned Index = Prop.ParameterTableOffset;\n";
+  OS << "  return DXILOpParameterKindTable + Index;\n";
+  OS << "}\n ";
 }
 
 namespace llvm {
 
 void EmitDXILOperation(RecordKeeper &Records, raw_ostream &OS) {
   std::vector<Record *> Ops = Records.getAllDerivedDefinitions("dxil_op");
   OS << "// Generated code, do not edit.\n";
   OS << "\n";