xref: /freebsd/contrib/llvm-project/llvm/lib/Target/DirectX/DXILOpBuilder.cpp (revision b64c5a0ace59af62eff52bfe110a521dc73c937b) 
1 //===- DXILOpBuilder.cpp - Helper class for build DIXLOp functions --------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file This file contains class to help build DXIL op functions.
10 //===----------------------------------------------------------------------===//
11 
12 #include "DXILOpBuilder.h"
13 #include "DXILConstants.h"
14 #include "llvm/IR/IRBuilder.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/Support/DXILABI.h"
17 #include "llvm/Support/ErrorHandling.h"
18 
19 using namespace llvm;
20 using namespace llvm::dxil;
21 
22 constexpr StringLiteral DXILOpNamePrefix = "dx.op.";
23 
24 namespace {
25 
26 enum OverloadKind : uint16_t {
27   VOID = 1,
28   HALF = 1 << 1,
29   FLOAT = 1 << 2,
30   DOUBLE = 1 << 3,
31   I1 = 1 << 4,
32   I8 = 1 << 5,
33   I16 = 1 << 6,
34   I32 = 1 << 7,
35   I64 = 1 << 8,
36   UserDefineType = 1 << 9,
37   ObjectType = 1 << 10,
38 };
39 
40 } // namespace
41 
42 static const char *getOverloadTypeName(OverloadKind Kind) {
43   switch (Kind) {
44   case OverloadKind::HALF:
45     return "f16";
46   case OverloadKind::FLOAT:
47     return "f32";
48   case OverloadKind::DOUBLE:
49     return "f64";
50   case OverloadKind::I1:
51     return "i1";
52   case OverloadKind::I8:
53     return "i8";
54   case OverloadKind::I16:
55     return "i16";
56   case OverloadKind::I32:
57     return "i32";
58   case OverloadKind::I64:
59     return "i64";
60   case OverloadKind::VOID:
61   case OverloadKind::ObjectType:
62   case OverloadKind::UserDefineType:
63     break;
64   }
65   llvm_unreachable("invalid overload type for name");
66   return "void";
67 }
68 
69 static OverloadKind getOverloadKind(Type *Ty) {
70   Type::TypeID T = Ty->getTypeID();
71   switch (T) {
72   case Type::VoidTyID:
73     return OverloadKind::VOID;
74   case Type::HalfTyID:
75     return OverloadKind::HALF;
76   case Type::FloatTyID:
77     return OverloadKind::FLOAT;
78   case Type::DoubleTyID:
79     return OverloadKind::DOUBLE;
80   case Type::IntegerTyID: {
81     IntegerType *ITy = cast<IntegerType>(Ty);
82     unsigned Bits = ITy->getBitWidth();
83     switch (Bits) {
84     case 1:
85       return OverloadKind::I1;
86     case 8:
87       return OverloadKind::I8;
88     case 16:
89       return OverloadKind::I16;
90     case 32:
91       return OverloadKind::I32;
92     case 64:
93       return OverloadKind::I64;
94     default:
95       llvm_unreachable("invalid overload type");
96       return OverloadKind::VOID;
97     }
98   }
99   case Type::PointerTyID:
100     return OverloadKind::UserDefineType;
101   case Type::StructTyID:
102     return OverloadKind::ObjectType;
103   default:
104     llvm_unreachable("invalid overload type");
105     return OverloadKind::VOID;
106   }
107 }
108 
109 static std::string getTypeName(OverloadKind Kind, Type *Ty) {
110   if (Kind < OverloadKind::UserDefineType) {
111     return getOverloadTypeName(Kind);
112   } else if (Kind == OverloadKind::UserDefineType) {
113     StructType *ST = cast<StructType>(Ty);
114     return ST->getStructName().str();
115   } else if (Kind == OverloadKind::ObjectType) {
116     StructType *ST = cast<StructType>(Ty);
117     return ST->getStructName().str();
118   } else {
119     std::string Str;
120     raw_string_ostream OS(Str);
121     Ty->print(OS);
122     return OS.str();
123   }
124 }
125 
126 // Static properties.
127 struct OpCodeProperty {
128   dxil::OpCode OpCode;
129   // Offset in DXILOpCodeNameTable.
130   unsigned OpCodeNameOffset;
131   dxil::OpCodeClass OpCodeClass;
132   // Offset in DXILOpCodeClassNameTable.
133   unsigned OpCodeClassNameOffset;
134   uint16_t OverloadTys;
135   llvm::Attribute::AttrKind FuncAttr;
136   int OverloadParamIndex;        // parameter index which control the overload.
137                                  // When < 0, should be only 1 overload type.
138   unsigned NumOfParameters;      // Number of parameters include return value.
139   unsigned ParameterTableOffset; // Offset in ParameterTable.
140 };
141 
142 // Include getOpCodeClassName getOpCodeProperty, getOpCodeName and
143 // getOpCodeParameterKind which generated by tableGen.
144 #define DXIL_OP_OPERATION_TABLE
145 #include "DXILOperation.inc"
146 #undef DXIL_OP_OPERATION_TABLE
147 
148 static std::string constructOverloadName(OverloadKind Kind, Type *Ty,
149                                          const OpCodeProperty &Prop) {
150   if (Kind == OverloadKind::VOID) {
151     return (Twine(DXILOpNamePrefix) + getOpCodeClassName(Prop)).str();
152   }
153   return (Twine(DXILOpNamePrefix) + getOpCodeClassName(Prop) + "." +
154           getTypeName(Kind, Ty))
155       .str();
156 }
157 
158 static std::string constructOverloadTypeName(OverloadKind Kind,
159                                              StringRef TypeName) {
160   if (Kind == OverloadKind::VOID)
161     return TypeName.str();
162 
163   assert(Kind < OverloadKind::UserDefineType && "invalid overload kind");
164   return (Twine(TypeName) + getOverloadTypeName(Kind)).str();
165 }
166 
167 static StructType *getOrCreateStructType(StringRef Name,
168                                          ArrayRef<Type *> EltTys,
169                                          LLVMContext &Ctx) {
170   StructType *ST = StructType::getTypeByName(Ctx, Name);
171   if (ST)
172     return ST;
173 
174   return StructType::create(Ctx, EltTys, Name);
175 }
176 
177 static StructType *getResRetType(Type *OverloadTy, LLVMContext &Ctx) {
178   OverloadKind Kind = getOverloadKind(OverloadTy);
179   std::string TypeName = constructOverloadTypeName(Kind, "dx.types.ResRet.");
180   Type *FieldTypes[5] = {OverloadTy, OverloadTy, OverloadTy, OverloadTy,
181                          Type::getInt32Ty(Ctx)};
182   return getOrCreateStructType(TypeName, FieldTypes, Ctx);
183 }
184 
185 static StructType *getHandleType(LLVMContext &Ctx) {
186   return getOrCreateStructType("dx.types.Handle", PointerType::getUnqual(Ctx),
187                                Ctx);
188 }
189 
190 static Type *getTypeFromParameterKind(ParameterKind Kind, Type *OverloadTy) {
191   auto &Ctx = OverloadTy->getContext();
192   switch (Kind) {
193   case ParameterKind::Void:
194     return Type::getVoidTy(Ctx);
195   case ParameterKind::Half:
196     return Type::getHalfTy(Ctx);
197   case ParameterKind::Float:
198     return Type::getFloatTy(Ctx);
199   case ParameterKind::Double:
200     return Type::getDoubleTy(Ctx);
201   case ParameterKind::I1:
202     return Type::getInt1Ty(Ctx);
203   case ParameterKind::I8:
204     return Type::getInt8Ty(Ctx);
205   case ParameterKind::I16:
206     return Type::getInt16Ty(Ctx);
207   case ParameterKind::I32:
208     return Type::getInt32Ty(Ctx);
209   case ParameterKind::I64:
210     return Type::getInt64Ty(Ctx);
211   case ParameterKind::Overload:
212     return OverloadTy;
213   case ParameterKind::ResourceRet:
214     return getResRetType(OverloadTy, Ctx);
215   case ParameterKind::DXILHandle:
216     return getHandleType(Ctx);
217   default:
218     break;
219   }
220   llvm_unreachable("Invalid parameter kind");
221   return nullptr;
222 }
223 
224 /// Construct DXIL function type. This is the type of a function with
225 /// the following prototype
226 ///     OverloadType dx.op.<opclass>.<return-type>(int opcode, <param types>)
227 /// <param-types> are constructed from types in Prop.
228 /// \param Prop  Structure containing DXIL Operation properties based on
229 ///               its specification in DXIL.td.
230 /// \param OverloadTy Return type to be used to construct DXIL function type.
231 static FunctionType *getDXILOpFunctionType(const OpCodeProperty *Prop,
232                                            Type *ReturnTy, Type *OverloadTy) {
233   SmallVector<Type *> ArgTys;
234 
235   auto ParamKinds = getOpCodeParameterKind(*Prop);
236 
237   // Add ReturnTy as return type of the function
238   ArgTys.emplace_back(ReturnTy);
239 
240   // Add DXIL Opcode value type viz., Int32 as first argument
241   ArgTys.emplace_back(Type::getInt32Ty(OverloadTy->getContext()));
242 
243   // Add DXIL Operation parameter types as specified in DXIL properties
244   for (unsigned I = 0; I < Prop->NumOfParameters; ++I) {
245     ParameterKind Kind = ParamKinds[I];
246     ArgTys.emplace_back(getTypeFromParameterKind(Kind, OverloadTy));
247   }
248   return FunctionType::get(
249       ArgTys[0], ArrayRef<Type *>(&ArgTys[1], ArgTys.size() - 1), false);
250 }
251 
252 namespace llvm {
253 namespace dxil {
254 
255 CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode, Type *ReturnTy,
256                                           Type *OverloadTy,
257                                           SmallVector<Value *> Args) {
258   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
259 
260   OverloadKind Kind = getOverloadKind(OverloadTy);
261   if ((Prop->OverloadTys & (uint16_t)Kind) == 0) {
262     report_fatal_error("Invalid Overload Type", /* gen_crash_diag=*/false);
263   }
264 
265   std::string DXILFnName = constructOverloadName(Kind, OverloadTy, *Prop);
266   FunctionCallee DXILFn;
267   // Get the function with name DXILFnName, if one exists
268   if (auto *Func = M.getFunction(DXILFnName)) {
269     DXILFn = FunctionCallee(Func);
270   } else {
271     // Construct and add a function with name DXILFnName
272     FunctionType *DXILOpFT = getDXILOpFunctionType(Prop, ReturnTy, OverloadTy);
273     DXILFn = M.getOrInsertFunction(DXILFnName, DXILOpFT);
274   }
275 
276   return B.CreateCall(DXILFn, Args);
277 }
278 
279 Type *DXILOpBuilder::getOverloadTy(dxil::OpCode OpCode, FunctionType *FT) {
280 
281   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
282   // If DXIL Op has no overload parameter, just return the
283   // precise return type specified.
284   if (Prop->OverloadParamIndex < 0) {
285     auto &Ctx = FT->getContext();
286     switch (Prop->OverloadTys) {
287     case OverloadKind::VOID:
288       return Type::getVoidTy(Ctx);
289     case OverloadKind::HALF:
290       return Type::getHalfTy(Ctx);
291     case OverloadKind::FLOAT:
292       return Type::getFloatTy(Ctx);
293     case OverloadKind::DOUBLE:
294       return Type::getDoubleTy(Ctx);
295     case OverloadKind::I1:
296       return Type::getInt1Ty(Ctx);
297     case OverloadKind::I8:
298       return Type::getInt8Ty(Ctx);
299     case OverloadKind::I16:
300       return Type::getInt16Ty(Ctx);
301     case OverloadKind::I32:
302       return Type::getInt32Ty(Ctx);
303     case OverloadKind::I64:
304       return Type::getInt64Ty(Ctx);
305     default:
306       llvm_unreachable("invalid overload type");
307       return nullptr;
308     }
309   }
310 
311   // Prop->OverloadParamIndex is 0, overload type is FT->getReturnType().
312   Type *OverloadType = FT->getReturnType();
313   if (Prop->OverloadParamIndex != 0) {
314     // Skip Return Type.
315     OverloadType = FT->getParamType(Prop->OverloadParamIndex - 1);
316   }
317 
318   auto ParamKinds = getOpCodeParameterKind(*Prop);
319   auto Kind = ParamKinds[Prop->OverloadParamIndex];
320   // For ResRet and CBufferRet, OverloadTy is in field of StructType.
321   if (Kind == ParameterKind::CBufferRet ||
322       Kind == ParameterKind::ResourceRet) {
323     auto *ST = cast<StructType>(OverloadType);
324     OverloadType = ST->getElementType(0);
325   }
326   return OverloadType;
327 }
328 
329 const char *DXILOpBuilder::getOpCodeName(dxil::OpCode DXILOp) {
330   return ::getOpCodeName(DXILOp);
331 }
332 } // namespace dxil
333 } // namespace llvm
334