| //===- 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/DXILOperationCommon.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, |
| }; |
| |
| } // 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::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 |