clang 22.0.0git
CGHLSLBuiltins.cpp
Go to the documentation of this file.
1//===------- CGHLSLBuiltins.cpp - Emit LLVM Code for HLSL builtins --------===//
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// This contains code to emit HLSL Builtin calls as LLVM code.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGBuiltin.h"
14#include "CGHLSLRuntime.h"
15#include "CodeGenFunction.h"
16
17using namespace clang;
18using namespace CodeGen;
19using namespace llvm;
20
24 "asdouble operands types mismatch");
25 Value *OpLowBits = CGF.EmitScalarExpr(E->getArg(0));
26 Value *OpHighBits = CGF.EmitScalarExpr(E->getArg(1));
27
28 llvm::Type *ResultType = CGF.DoubleTy;
29 int N = 1;
30 if (auto *VTy = E->getArg(0)->getType()->getAs<clang::VectorType>()) {
31 N = VTy->getNumElements();
32 ResultType = llvm::FixedVectorType::get(CGF.DoubleTy, N);
33 }
34
35 if (CGF.CGM.getTarget().getTriple().isDXIL())
36 return CGF.Builder.CreateIntrinsic(
37 /*ReturnType=*/ResultType, Intrinsic::dx_asdouble,
38 {OpLowBits, OpHighBits}, nullptr, "hlsl.asdouble");
39
40 if (!E->getArg(0)->getType()->isVectorType()) {
41 OpLowBits = CGF.Builder.CreateVectorSplat(1, OpLowBits);
42 OpHighBits = CGF.Builder.CreateVectorSplat(1, OpHighBits);
43 }
44
46 for (int i = 0; i < N; i++) {
47 Mask.push_back(i);
48 Mask.push_back(i + N);
49 }
50
51 Value *BitVec = CGF.Builder.CreateShuffleVector(OpLowBits, OpHighBits, Mask);
52
53 return CGF.Builder.CreateBitCast(BitVec, ResultType);
54}
55
57 Value *Op0 = CGF->EmitScalarExpr(E->getArg(0));
58
59 Constant *FZeroConst = ConstantFP::getZero(CGF->FloatTy);
60 Value *CMP;
61 Value *LastInstr;
62
63 if (const auto *VecTy = E->getArg(0)->getType()->getAs<clang::VectorType>()) {
64 FZeroConst = ConstantVector::getSplat(
65 ElementCount::getFixed(VecTy->getNumElements()), FZeroConst);
66 auto *FCompInst = CGF->Builder.CreateFCmpOLT(Op0, FZeroConst);
67 CMP = CGF->Builder.CreateIntrinsic(
68 CGF->Builder.getInt1Ty(), CGF->CGM.getHLSLRuntime().getAnyIntrinsic(),
69 {FCompInst});
70 } else {
71 CMP = CGF->Builder.CreateFCmpOLT(Op0, FZeroConst);
72 }
73
74 if (CGF->CGM.getTarget().getTriple().isDXIL()) {
75 LastInstr = CGF->Builder.CreateIntrinsic(Intrinsic::dx_discard, {CMP});
76 } else if (CGF->CGM.getTarget().getTriple().isSPIRV()) {
77 BasicBlock *LT0 = CGF->createBasicBlock("lt0", CGF->CurFn);
78 BasicBlock *End = CGF->createBasicBlock("end", CGF->CurFn);
79
80 CGF->Builder.CreateCondBr(CMP, LT0, End);
81
82 CGF->Builder.SetInsertPoint(LT0);
83
84 CGF->Builder.CreateIntrinsic(Intrinsic::spv_discard, {});
85
86 LastInstr = CGF->Builder.CreateBr(End);
87 CGF->Builder.SetInsertPoint(End);
88 } else {
89 llvm_unreachable("Backend Codegen not supported.");
90 }
91
92 return LastInstr;
93}
94
96 Value *Op0 = CGF->EmitScalarExpr(E->getArg(0));
97 const auto *OutArg1 = dyn_cast<HLSLOutArgExpr>(E->getArg(1));
98 const auto *OutArg2 = dyn_cast<HLSLOutArgExpr>(E->getArg(2));
99
100 CallArgList Args;
101 LValue Op1TmpLValue =
102 CGF->EmitHLSLOutArgExpr(OutArg1, Args, OutArg1->getType());
103 LValue Op2TmpLValue =
104 CGF->EmitHLSLOutArgExpr(OutArg2, Args, OutArg2->getType());
105
107 Args.reverseWritebacks();
108
109 Value *LowBits = nullptr;
110 Value *HighBits = nullptr;
111
112 if (CGF->CGM.getTarget().getTriple().isDXIL()) {
113 llvm::Type *RetElementTy = CGF->Int32Ty;
114 if (auto *Op0VecTy = E->getArg(0)->getType()->getAs<clang::VectorType>())
115 RetElementTy = llvm::VectorType::get(
116 CGF->Int32Ty, ElementCount::getFixed(Op0VecTy->getNumElements()));
117 auto *RetTy = llvm::StructType::get(RetElementTy, RetElementTy);
118
119 CallInst *CI = CGF->Builder.CreateIntrinsic(
120 RetTy, Intrinsic::dx_splitdouble, {Op0}, nullptr, "hlsl.splitdouble");
121
122 LowBits = CGF->Builder.CreateExtractValue(CI, 0);
123 HighBits = CGF->Builder.CreateExtractValue(CI, 1);
124 } else {
125 // For Non DXIL targets we generate the instructions.
126
127 if (!Op0->getType()->isVectorTy()) {
128 FixedVectorType *DestTy = FixedVectorType::get(CGF->Int32Ty, 2);
129 Value *Bitcast = CGF->Builder.CreateBitCast(Op0, DestTy);
130
131 LowBits = CGF->Builder.CreateExtractElement(Bitcast, (uint64_t)0);
132 HighBits = CGF->Builder.CreateExtractElement(Bitcast, 1);
133 } else {
134 int NumElements = 1;
135 if (const auto *VecTy =
137 NumElements = VecTy->getNumElements();
138
139 FixedVectorType *Uint32VecTy =
140 FixedVectorType::get(CGF->Int32Ty, NumElements * 2);
141 Value *Uint32Vec = CGF->Builder.CreateBitCast(Op0, Uint32VecTy);
142 if (NumElements == 1) {
143 LowBits = CGF->Builder.CreateExtractElement(Uint32Vec, (uint64_t)0);
144 HighBits = CGF->Builder.CreateExtractElement(Uint32Vec, 1);
145 } else {
146 SmallVector<int> EvenMask, OddMask;
147 for (int I = 0, E = NumElements; I != E; ++I) {
148 EvenMask.push_back(I * 2);
149 OddMask.push_back(I * 2 + 1);
150 }
151 LowBits = CGF->Builder.CreateShuffleVector(Uint32Vec, EvenMask);
152 HighBits = CGF->Builder.CreateShuffleVector(Uint32Vec, OddMask);
153 }
154 }
155 }
156 CGF->Builder.CreateStore(LowBits, Op1TmpLValue.getAddress());
157 auto *LastInst =
158 CGF->Builder.CreateStore(HighBits, Op2TmpLValue.getAddress());
159 CGF->EmitWritebacks(Args);
160 return LastInst;
161}
162
163// Return dot product intrinsic that corresponds to the QT scalar type
164static Intrinsic::ID getDotProductIntrinsic(CGHLSLRuntime &RT, QualType QT) {
165 if (QT->isFloatingType())
166 return RT.getFDotIntrinsic();
167 if (QT->isSignedIntegerType())
168 return RT.getSDotIntrinsic();
169 assert(QT->isUnsignedIntegerType());
170 return RT.getUDotIntrinsic();
171}
172
173static Intrinsic::ID getFirstBitHighIntrinsic(CGHLSLRuntime &RT, QualType QT) {
175 return RT.getFirstBitSHighIntrinsic();
176 }
177
179 return RT.getFirstBitUHighIntrinsic();
180}
181
182// Return wave active sum that corresponds to the QT scalar type
183static Intrinsic::ID getWaveActiveSumIntrinsic(llvm::Triple::ArchType Arch,
184 CGHLSLRuntime &RT, QualType QT) {
185 switch (Arch) {
186 case llvm::Triple::spirv:
187 return Intrinsic::spv_wave_reduce_sum;
188 case llvm::Triple::dxil: {
189 if (QT->isUnsignedIntegerType())
190 return Intrinsic::dx_wave_reduce_usum;
191 return Intrinsic::dx_wave_reduce_sum;
192 }
193 default:
194 llvm_unreachable("Intrinsic WaveActiveSum"
195 " not supported by target architecture");
196 }
197}
198
199// Return wave active sum that corresponds to the QT scalar type
200static Intrinsic::ID getWaveActiveMaxIntrinsic(llvm::Triple::ArchType Arch,
201 CGHLSLRuntime &RT, QualType QT) {
202 switch (Arch) {
203 case llvm::Triple::spirv:
204 if (QT->isUnsignedIntegerType())
205 return Intrinsic::spv_wave_reduce_umax;
206 return Intrinsic::spv_wave_reduce_max;
207 case llvm::Triple::dxil: {
208 if (QT->isUnsignedIntegerType())
209 return Intrinsic::dx_wave_reduce_umax;
210 return Intrinsic::dx_wave_reduce_max;
211 }
212 default:
213 llvm_unreachable("Intrinsic WaveActiveMax"
214 " not supported by target architecture");
215 }
216}
217
218// Returns the mangled name for a builtin function that the SPIR-V backend
219// will expand into a spec Constant.
220static std::string getSpecConstantFunctionName(clang::QualType SpecConstantType,
221 ASTContext &Context) {
222 // The parameter types for our conceptual intrinsic function.
223 QualType ClangParamTypes[] = {Context.IntTy, SpecConstantType};
224
225 // Create a temporary FunctionDecl for the builtin fuction. It won't be
226 // added to the AST.
228 QualType FnType =
229 Context.getFunctionType(SpecConstantType, ClangParamTypes, EPI);
230 DeclarationName FuncName = &Context.Idents.get("__spirv_SpecConstant");
231 FunctionDecl *FnDeclForMangling = FunctionDecl::Create(
232 Context, Context.getTranslationUnitDecl(), SourceLocation(),
233 SourceLocation(), FuncName, FnType, /*TSI=*/nullptr, SC_Extern);
234
235 // Attach the created parameter declarations to the function declaration.
237 for (QualType ParamType : ClangParamTypes) {
239 Context, FnDeclForMangling, SourceLocation(), SourceLocation(),
240 /*IdentifierInfo*/ nullptr, ParamType, /*TSI*/ nullptr, SC_None,
241 /*DefaultArg*/ nullptr);
242 ParamDecls.push_back(PD);
243 }
244 FnDeclForMangling->setParams(ParamDecls);
245
246 // Get the mangled name.
247 std::string Name;
248 llvm::raw_string_ostream MangledNameStream(Name);
249 std::unique_ptr<MangleContext> Mangler(Context.createMangleContext());
250 Mangler->mangleName(FnDeclForMangling, MangledNameStream);
251 MangledNameStream.flush();
252
253 return Name;
254}
255
257 const CallExpr *E,
259 if (!getLangOpts().HLSL)
260 return nullptr;
261
262 switch (BuiltinID) {
263 case Builtin::BI__builtin_hlsl_adduint64: {
264 Value *OpA = EmitScalarExpr(E->getArg(0));
265 Value *OpB = EmitScalarExpr(E->getArg(1));
266 QualType Arg0Ty = E->getArg(0)->getType();
267 uint64_t NumElements = Arg0Ty->castAs<VectorType>()->getNumElements();
268 assert(Arg0Ty == E->getArg(1)->getType() &&
269 "AddUint64 operand types must match");
270 assert(Arg0Ty->hasIntegerRepresentation() &&
271 "AddUint64 operands must have an integer representation");
272 assert((NumElements == 2 || NumElements == 4) &&
273 "AddUint64 operands must have 2 or 4 elements");
274
275 llvm::Value *LowA;
276 llvm::Value *HighA;
277 llvm::Value *LowB;
278 llvm::Value *HighB;
279
280 // Obtain low and high words of inputs A and B
281 if (NumElements == 2) {
282 LowA = Builder.CreateExtractElement(OpA, (uint64_t)0, "LowA");
283 HighA = Builder.CreateExtractElement(OpA, (uint64_t)1, "HighA");
284 LowB = Builder.CreateExtractElement(OpB, (uint64_t)0, "LowB");
285 HighB = Builder.CreateExtractElement(OpB, (uint64_t)1, "HighB");
286 } else {
287 LowA = Builder.CreateShuffleVector(OpA, {0, 2}, "LowA");
288 HighA = Builder.CreateShuffleVector(OpA, {1, 3}, "HighA");
289 LowB = Builder.CreateShuffleVector(OpB, {0, 2}, "LowB");
290 HighB = Builder.CreateShuffleVector(OpB, {1, 3}, "HighB");
291 }
292
293 // Use an uadd_with_overflow to compute the sum of low words and obtain a
294 // carry value
295 llvm::Value *Carry;
296 llvm::Value *LowSum = EmitOverflowIntrinsic(
297 *this, Intrinsic::uadd_with_overflow, LowA, LowB, Carry);
298 llvm::Value *ZExtCarry =
299 Builder.CreateZExt(Carry, HighA->getType(), "CarryZExt");
300
301 // Sum the high words and the carry
302 llvm::Value *HighSum = Builder.CreateAdd(HighA, HighB, "HighSum");
303 llvm::Value *HighSumPlusCarry =
304 Builder.CreateAdd(HighSum, ZExtCarry, "HighSumPlusCarry");
305
306 if (NumElements == 4) {
307 return Builder.CreateShuffleVector(LowSum, HighSumPlusCarry, {0, 2, 1, 3},
308 "hlsl.AddUint64");
309 }
310
311 llvm::Value *Result = PoisonValue::get(OpA->getType());
312 Result = Builder.CreateInsertElement(Result, LowSum, (uint64_t)0,
313 "hlsl.AddUint64.upto0");
314 Result = Builder.CreateInsertElement(Result, HighSumPlusCarry, (uint64_t)1,
315 "hlsl.AddUint64");
316 return Result;
317 }
318 case Builtin::BI__builtin_hlsl_resource_getpointer: {
319 Value *HandleOp = EmitScalarExpr(E->getArg(0));
320 Value *IndexOp = EmitScalarExpr(E->getArg(1));
321
322 llvm::Type *RetTy = ConvertType(E->getType());
323 return Builder.CreateIntrinsic(
324 RetTy, CGM.getHLSLRuntime().getCreateResourceGetPointerIntrinsic(),
325 ArrayRef<Value *>{HandleOp, IndexOp});
326 }
327 case Builtin::BI__builtin_hlsl_resource_uninitializedhandle: {
328 llvm::Type *HandleTy = CGM.getTypes().ConvertType(E->getType());
329 return llvm::PoisonValue::get(HandleTy);
330 }
331 case Builtin::BI__builtin_hlsl_resource_handlefrombinding: {
332 llvm::Type *HandleTy = CGM.getTypes().ConvertType(E->getType());
333 Value *RegisterOp = EmitScalarExpr(E->getArg(1));
334 Value *SpaceOp = EmitScalarExpr(E->getArg(2));
335 Value *RangeOp = EmitScalarExpr(E->getArg(3));
336 Value *IndexOp = EmitScalarExpr(E->getArg(4));
337 Value *Name = EmitScalarExpr(E->getArg(5));
338 llvm::Intrinsic::ID IntrinsicID =
339 CGM.getHLSLRuntime().getCreateHandleFromBindingIntrinsic();
340 SmallVector<Value *> Args{SpaceOp, RegisterOp, RangeOp, IndexOp, Name};
341 return Builder.CreateIntrinsic(HandleTy, IntrinsicID, Args);
342 }
343 case Builtin::BI__builtin_hlsl_resource_handlefromimplicitbinding: {
344 llvm::Type *HandleTy = CGM.getTypes().ConvertType(E->getType());
345 Value *OrderID = EmitScalarExpr(E->getArg(1));
346 Value *SpaceOp = EmitScalarExpr(E->getArg(2));
347 Value *RangeOp = EmitScalarExpr(E->getArg(3));
348 Value *IndexOp = EmitScalarExpr(E->getArg(4));
349 Value *Name = EmitScalarExpr(E->getArg(5));
350 llvm::Intrinsic::ID IntrinsicID =
351 CGM.getHLSLRuntime().getCreateHandleFromImplicitBindingIntrinsic();
352 SmallVector<Value *> Args{OrderID, SpaceOp, RangeOp, IndexOp, Name};
353 return Builder.CreateIntrinsic(HandleTy, IntrinsicID, Args);
354 }
355 case Builtin::BI__builtin_hlsl_resource_nonuniformindex: {
356 Value *IndexOp = EmitScalarExpr(E->getArg(0));
357 llvm::Type *RetTy = ConvertType(E->getType());
358 return Builder.CreateIntrinsic(
359 RetTy, CGM.getHLSLRuntime().getNonUniformResourceIndexIntrinsic(),
360 ArrayRef<Value *>{IndexOp});
361 }
362 case Builtin::BI__builtin_hlsl_all: {
363 Value *Op0 = EmitScalarExpr(E->getArg(0));
364 return Builder.CreateIntrinsic(
365 /*ReturnType=*/llvm::Type::getInt1Ty(getLLVMContext()),
366 CGM.getHLSLRuntime().getAllIntrinsic(), ArrayRef<Value *>{Op0}, nullptr,
367 "hlsl.all");
368 }
369 case Builtin::BI__builtin_hlsl_and: {
370 Value *Op0 = EmitScalarExpr(E->getArg(0));
371 Value *Op1 = EmitScalarExpr(E->getArg(1));
372 return Builder.CreateAnd(Op0, Op1, "hlsl.and");
373 }
374 case Builtin::BI__builtin_hlsl_or: {
375 Value *Op0 = EmitScalarExpr(E->getArg(0));
376 Value *Op1 = EmitScalarExpr(E->getArg(1));
377 return Builder.CreateOr(Op0, Op1, "hlsl.or");
378 }
379 case Builtin::BI__builtin_hlsl_any: {
380 Value *Op0 = EmitScalarExpr(E->getArg(0));
381 return Builder.CreateIntrinsic(
382 /*ReturnType=*/llvm::Type::getInt1Ty(getLLVMContext()),
383 CGM.getHLSLRuntime().getAnyIntrinsic(), ArrayRef<Value *>{Op0}, nullptr,
384 "hlsl.any");
385 }
386 case Builtin::BI__builtin_hlsl_asdouble:
387 return handleAsDoubleBuiltin(*this, E);
388 case Builtin::BI__builtin_hlsl_elementwise_clamp: {
389 Value *OpX = EmitScalarExpr(E->getArg(0));
390 Value *OpMin = EmitScalarExpr(E->getArg(1));
391 Value *OpMax = EmitScalarExpr(E->getArg(2));
392
393 QualType Ty = E->getArg(0)->getType();
394 if (auto *VecTy = Ty->getAs<VectorType>())
395 Ty = VecTy->getElementType();
396
397 Intrinsic::ID Intr;
398 if (Ty->isFloatingType()) {
399 Intr = CGM.getHLSLRuntime().getNClampIntrinsic();
400 } else if (Ty->isUnsignedIntegerType()) {
401 Intr = CGM.getHLSLRuntime().getUClampIntrinsic();
402 } else {
403 assert(Ty->isSignedIntegerType());
404 Intr = CGM.getHLSLRuntime().getSClampIntrinsic();
405 }
406 return Builder.CreateIntrinsic(
407 /*ReturnType=*/OpX->getType(), Intr,
408 ArrayRef<Value *>{OpX, OpMin, OpMax}, nullptr, "hlsl.clamp");
409 }
410 case Builtin::BI__builtin_hlsl_crossf16:
411 case Builtin::BI__builtin_hlsl_crossf32: {
412 Value *Op0 = EmitScalarExpr(E->getArg(0));
413 Value *Op1 = EmitScalarExpr(E->getArg(1));
414 assert(E->getArg(0)->getType()->hasFloatingRepresentation() &&
416 "cross operands must have a float representation");
417 // make sure each vector has exactly 3 elements
418 assert(
419 E->getArg(0)->getType()->castAs<VectorType>()->getNumElements() == 3 &&
420 E->getArg(1)->getType()->castAs<VectorType>()->getNumElements() == 3 &&
421 "input vectors must have 3 elements each");
422 return Builder.CreateIntrinsic(
423 /*ReturnType=*/Op0->getType(), CGM.getHLSLRuntime().getCrossIntrinsic(),
424 ArrayRef<Value *>{Op0, Op1}, nullptr, "hlsl.cross");
425 }
426 case Builtin::BI__builtin_hlsl_dot: {
427 Value *Op0 = EmitScalarExpr(E->getArg(0));
428 Value *Op1 = EmitScalarExpr(E->getArg(1));
429 llvm::Type *T0 = Op0->getType();
430 llvm::Type *T1 = Op1->getType();
431
432 // If the arguments are scalars, just emit a multiply
433 if (!T0->isVectorTy() && !T1->isVectorTy()) {
434 if (T0->isFloatingPointTy())
435 return Builder.CreateFMul(Op0, Op1, "hlsl.dot");
436
437 if (T0->isIntegerTy())
438 return Builder.CreateMul(Op0, Op1, "hlsl.dot");
439
440 llvm_unreachable(
441 "Scalar dot product is only supported on ints and floats.");
442 }
443 // For vectors, validate types and emit the appropriate intrinsic
444 assert(CGM.getContext().hasSameUnqualifiedType(E->getArg(0)->getType(),
445 E->getArg(1)->getType()) &&
446 "Dot product operands must have the same type.");
447
448 auto *VecTy0 = E->getArg(0)->getType()->castAs<VectorType>();
449 assert(VecTy0 && "Dot product argument must be a vector.");
450
451 return Builder.CreateIntrinsic(
452 /*ReturnType=*/T0->getScalarType(),
453 getDotProductIntrinsic(CGM.getHLSLRuntime(), VecTy0->getElementType()),
454 ArrayRef<Value *>{Op0, Op1}, nullptr, "hlsl.dot");
455 }
456 case Builtin::BI__builtin_hlsl_dot4add_i8packed: {
457 Value *X = EmitScalarExpr(E->getArg(0));
458 Value *Y = EmitScalarExpr(E->getArg(1));
459 Value *Acc = EmitScalarExpr(E->getArg(2));
460
461 Intrinsic::ID ID = CGM.getHLSLRuntime().getDot4AddI8PackedIntrinsic();
462 // Note that the argument order disagrees between the builtin and the
463 // intrinsic here.
464 return Builder.CreateIntrinsic(
465 /*ReturnType=*/Acc->getType(), ID, ArrayRef<Value *>{Acc, X, Y},
466 nullptr, "hlsl.dot4add.i8packed");
467 }
468 case Builtin::BI__builtin_hlsl_dot4add_u8packed: {
469 Value *X = EmitScalarExpr(E->getArg(0));
470 Value *Y = EmitScalarExpr(E->getArg(1));
471 Value *Acc = EmitScalarExpr(E->getArg(2));
472
473 Intrinsic::ID ID = CGM.getHLSLRuntime().getDot4AddU8PackedIntrinsic();
474 // Note that the argument order disagrees between the builtin and the
475 // intrinsic here.
476 return Builder.CreateIntrinsic(
477 /*ReturnType=*/Acc->getType(), ID, ArrayRef<Value *>{Acc, X, Y},
478 nullptr, "hlsl.dot4add.u8packed");
479 }
480 case Builtin::BI__builtin_hlsl_elementwise_firstbithigh: {
481 Value *X = EmitScalarExpr(E->getArg(0));
482
483 return Builder.CreateIntrinsic(
484 /*ReturnType=*/ConvertType(E->getType()),
485 getFirstBitHighIntrinsic(CGM.getHLSLRuntime(), E->getArg(0)->getType()),
486 ArrayRef<Value *>{X}, nullptr, "hlsl.firstbithigh");
487 }
488 case Builtin::BI__builtin_hlsl_elementwise_firstbitlow: {
489 Value *X = EmitScalarExpr(E->getArg(0));
490
491 return Builder.CreateIntrinsic(
492 /*ReturnType=*/ConvertType(E->getType()),
493 CGM.getHLSLRuntime().getFirstBitLowIntrinsic(), ArrayRef<Value *>{X},
494 nullptr, "hlsl.firstbitlow");
495 }
496 case Builtin::BI__builtin_hlsl_lerp: {
497 Value *X = EmitScalarExpr(E->getArg(0));
498 Value *Y = EmitScalarExpr(E->getArg(1));
499 Value *S = EmitScalarExpr(E->getArg(2));
501 llvm_unreachable("lerp operand must have a float representation");
502 return Builder.CreateIntrinsic(
503 /*ReturnType=*/X->getType(), CGM.getHLSLRuntime().getLerpIntrinsic(),
504 ArrayRef<Value *>{X, Y, S}, nullptr, "hlsl.lerp");
505 }
506 case Builtin::BI__builtin_hlsl_normalize: {
507 Value *X = EmitScalarExpr(E->getArg(0));
508
509 assert(E->getArg(0)->getType()->hasFloatingRepresentation() &&
510 "normalize operand must have a float representation");
511
512 return Builder.CreateIntrinsic(
513 /*ReturnType=*/X->getType(),
514 CGM.getHLSLRuntime().getNormalizeIntrinsic(), ArrayRef<Value *>{X},
515 nullptr, "hlsl.normalize");
516 }
517 case Builtin::BI__builtin_hlsl_elementwise_degrees: {
518 Value *X = EmitScalarExpr(E->getArg(0));
519
520 assert(E->getArg(0)->getType()->hasFloatingRepresentation() &&
521 "degree operand must have a float representation");
522
523 return Builder.CreateIntrinsic(
524 /*ReturnType=*/X->getType(), CGM.getHLSLRuntime().getDegreesIntrinsic(),
525 ArrayRef<Value *>{X}, nullptr, "hlsl.degrees");
526 }
527 case Builtin::BI__builtin_hlsl_elementwise_frac: {
528 Value *Op0 = EmitScalarExpr(E->getArg(0));
530 llvm_unreachable("frac operand must have a float representation");
531 return Builder.CreateIntrinsic(
532 /*ReturnType=*/Op0->getType(), CGM.getHLSLRuntime().getFracIntrinsic(),
533 ArrayRef<Value *>{Op0}, nullptr, "hlsl.frac");
534 }
535 case Builtin::BI__builtin_hlsl_elementwise_isinf: {
536 Value *Op0 = EmitScalarExpr(E->getArg(0));
537 llvm::Type *Xty = Op0->getType();
538 llvm::Type *retType = llvm::Type::getInt1Ty(this->getLLVMContext());
539 if (Xty->isVectorTy()) {
540 auto *XVecTy = E->getArg(0)->getType()->castAs<VectorType>();
541 retType = llvm::VectorType::get(
542 retType, ElementCount::getFixed(XVecTy->getNumElements()));
543 }
545 llvm_unreachable("isinf operand must have a float representation");
546 return Builder.CreateIntrinsic(
547 retType, CGM.getHLSLRuntime().getIsInfIntrinsic(),
548 ArrayRef<Value *>{Op0}, nullptr, "hlsl.isinf");
549 }
550 case Builtin::BI__builtin_hlsl_mad: {
551 Value *M = EmitScalarExpr(E->getArg(0));
552 Value *A = EmitScalarExpr(E->getArg(1));
553 Value *B = EmitScalarExpr(E->getArg(2));
555 return Builder.CreateIntrinsic(
556 /*ReturnType*/ M->getType(), Intrinsic::fmuladd,
557 ArrayRef<Value *>{M, A, B}, nullptr, "hlsl.fmad");
558
560 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::dxil)
561 return Builder.CreateIntrinsic(
562 /*ReturnType*/ M->getType(), Intrinsic::dx_imad,
563 ArrayRef<Value *>{M, A, B}, nullptr, "dx.imad");
564
565 Value *Mul = Builder.CreateNSWMul(M, A);
566 return Builder.CreateNSWAdd(Mul, B);
567 }
569 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::dxil)
570 return Builder.CreateIntrinsic(
571 /*ReturnType=*/M->getType(), Intrinsic::dx_umad,
572 ArrayRef<Value *>{M, A, B}, nullptr, "dx.umad");
573
574 Value *Mul = Builder.CreateNUWMul(M, A);
575 return Builder.CreateNUWAdd(Mul, B);
576 }
577 case Builtin::BI__builtin_hlsl_elementwise_rcp: {
578 Value *Op0 = EmitScalarExpr(E->getArg(0));
580 llvm_unreachable("rcp operand must have a float representation");
581 llvm::Type *Ty = Op0->getType();
582 llvm::Type *EltTy = Ty->getScalarType();
583 Constant *One = Ty->isVectorTy()
584 ? ConstantVector::getSplat(
585 ElementCount::getFixed(
586 cast<FixedVectorType>(Ty)->getNumElements()),
587 ConstantFP::get(EltTy, 1.0))
588 : ConstantFP::get(EltTy, 1.0);
589 return Builder.CreateFDiv(One, Op0, "hlsl.rcp");
590 }
591 case Builtin::BI__builtin_hlsl_elementwise_rsqrt: {
592 Value *Op0 = EmitScalarExpr(E->getArg(0));
594 llvm_unreachable("rsqrt operand must have a float representation");
595 return Builder.CreateIntrinsic(
596 /*ReturnType=*/Op0->getType(), CGM.getHLSLRuntime().getRsqrtIntrinsic(),
597 ArrayRef<Value *>{Op0}, nullptr, "hlsl.rsqrt");
598 }
599 case Builtin::BI__builtin_hlsl_elementwise_saturate: {
600 Value *Op0 = EmitScalarExpr(E->getArg(0));
601 assert(E->getArg(0)->getType()->hasFloatingRepresentation() &&
602 "saturate operand must have a float representation");
603 return Builder.CreateIntrinsic(
604 /*ReturnType=*/Op0->getType(),
605 CGM.getHLSLRuntime().getSaturateIntrinsic(), ArrayRef<Value *>{Op0},
606 nullptr, "hlsl.saturate");
607 }
608 case Builtin::BI__builtin_hlsl_select: {
609 Value *OpCond = EmitScalarExpr(E->getArg(0));
610 RValue RValTrue = EmitAnyExpr(E->getArg(1));
611 Value *OpTrue =
612 RValTrue.isScalar()
613 ? RValTrue.getScalarVal()
614 : Builder.CreateLoad(RValTrue.getAggregateAddress(), "true_val");
615 RValue RValFalse = EmitAnyExpr(E->getArg(2));
616 Value *OpFalse =
617 RValFalse.isScalar()
618 ? RValFalse.getScalarVal()
619 : Builder.CreateLoad(RValFalse.getAggregateAddress(), "false_val");
620 if (auto *VTy = E->getType()->getAs<VectorType>()) {
621 if (!OpTrue->getType()->isVectorTy())
622 OpTrue =
623 Builder.CreateVectorSplat(VTy->getNumElements(), OpTrue, "splat");
624 if (!OpFalse->getType()->isVectorTy())
625 OpFalse =
626 Builder.CreateVectorSplat(VTy->getNumElements(), OpFalse, "splat");
627 }
628
629 Value *SelectVal =
630 Builder.CreateSelect(OpCond, OpTrue, OpFalse, "hlsl.select");
631 if (!RValTrue.isScalar())
632 Builder.CreateStore(SelectVal, ReturnValue.getAddress(),
633 ReturnValue.isVolatile());
634
635 return SelectVal;
636 }
637 case Builtin::BI__builtin_hlsl_step: {
638 Value *Op0 = EmitScalarExpr(E->getArg(0));
639 Value *Op1 = EmitScalarExpr(E->getArg(1));
640 assert(E->getArg(0)->getType()->hasFloatingRepresentation() &&
642 "step operands must have a float representation");
643 return Builder.CreateIntrinsic(
644 /*ReturnType=*/Op0->getType(), CGM.getHLSLRuntime().getStepIntrinsic(),
645 ArrayRef<Value *>{Op0, Op1}, nullptr, "hlsl.step");
646 }
647 case Builtin::BI__builtin_hlsl_wave_active_all_true: {
648 Value *Op = EmitScalarExpr(E->getArg(0));
649 assert(Op->getType()->isIntegerTy(1) &&
650 "Intrinsic WaveActiveAllTrue operand must be a bool");
651
652 Intrinsic::ID ID = CGM.getHLSLRuntime().getWaveActiveAllTrueIntrinsic();
653 return EmitRuntimeCall(
654 Intrinsic::getOrInsertDeclaration(&CGM.getModule(), ID), {Op});
655 }
656 case Builtin::BI__builtin_hlsl_wave_active_any_true: {
657 Value *Op = EmitScalarExpr(E->getArg(0));
658 assert(Op->getType()->isIntegerTy(1) &&
659 "Intrinsic WaveActiveAnyTrue operand must be a bool");
660
661 Intrinsic::ID ID = CGM.getHLSLRuntime().getWaveActiveAnyTrueIntrinsic();
662 return EmitRuntimeCall(
663 Intrinsic::getOrInsertDeclaration(&CGM.getModule(), ID), {Op});
664 }
665 case Builtin::BI__builtin_hlsl_wave_active_count_bits: {
666 Value *OpExpr = EmitScalarExpr(E->getArg(0));
667 Intrinsic::ID ID = CGM.getHLSLRuntime().getWaveActiveCountBitsIntrinsic();
668 return EmitRuntimeCall(
669 Intrinsic::getOrInsertDeclaration(&CGM.getModule(), ID),
670 ArrayRef{OpExpr});
671 }
672 case Builtin::BI__builtin_hlsl_wave_active_sum: {
673 // Due to the use of variadic arguments, explicitly retreive argument
674 Value *OpExpr = EmitScalarExpr(E->getArg(0));
675 Intrinsic::ID IID = getWaveActiveSumIntrinsic(
676 getTarget().getTriple().getArch(), CGM.getHLSLRuntime(),
677 E->getArg(0)->getType());
678
679 return EmitRuntimeCall(Intrinsic::getOrInsertDeclaration(
680 &CGM.getModule(), IID, {OpExpr->getType()}),
681 ArrayRef{OpExpr}, "hlsl.wave.active.sum");
682 }
683 case Builtin::BI__builtin_hlsl_wave_active_max: {
684 // Due to the use of variadic arguments, explicitly retreive argument
685 Value *OpExpr = EmitScalarExpr(E->getArg(0));
686 Intrinsic::ID IID = getWaveActiveMaxIntrinsic(
687 getTarget().getTriple().getArch(), CGM.getHLSLRuntime(),
688 E->getArg(0)->getType());
689
690 return EmitRuntimeCall(Intrinsic::getOrInsertDeclaration(
691 &CGM.getModule(), IID, {OpExpr->getType()}),
692 ArrayRef{OpExpr}, "hlsl.wave.active.max");
693 }
694 case Builtin::BI__builtin_hlsl_wave_get_lane_index: {
695 // We don't define a SPIR-V intrinsic, instead it is a SPIR-V built-in
696 // defined in SPIRVBuiltins.td. So instead we manually get the matching name
697 // for the DirectX intrinsic and the demangled builtin name
698 switch (CGM.getTarget().getTriple().getArch()) {
699 case llvm::Triple::dxil:
700 return EmitRuntimeCall(Intrinsic::getOrInsertDeclaration(
701 &CGM.getModule(), Intrinsic::dx_wave_getlaneindex));
702 case llvm::Triple::spirv:
703 return EmitRuntimeCall(CGM.CreateRuntimeFunction(
704 llvm::FunctionType::get(IntTy, {}, false),
705 "__hlsl_wave_get_lane_index", {}, false, true));
706 default:
707 llvm_unreachable(
708 "Intrinsic WaveGetLaneIndex not supported by target architecture");
709 }
710 }
711 case Builtin::BI__builtin_hlsl_wave_is_first_lane: {
712 Intrinsic::ID ID = CGM.getHLSLRuntime().getWaveIsFirstLaneIntrinsic();
713 return EmitRuntimeCall(
714 Intrinsic::getOrInsertDeclaration(&CGM.getModule(), ID));
715 }
716 case Builtin::BI__builtin_hlsl_wave_get_lane_count: {
717 Intrinsic::ID ID = CGM.getHLSLRuntime().getWaveGetLaneCountIntrinsic();
718 return EmitRuntimeCall(
719 Intrinsic::getOrInsertDeclaration(&CGM.getModule(), ID));
720 }
721 case Builtin::BI__builtin_hlsl_wave_read_lane_at: {
722 // Due to the use of variadic arguments we must explicitly retreive them and
723 // create our function type.
724 Value *OpExpr = EmitScalarExpr(E->getArg(0));
725 Value *OpIndex = EmitScalarExpr(E->getArg(1));
726 return EmitRuntimeCall(
727 Intrinsic::getOrInsertDeclaration(
728 &CGM.getModule(), CGM.getHLSLRuntime().getWaveReadLaneAtIntrinsic(),
729 {OpExpr->getType()}),
730 ArrayRef{OpExpr, OpIndex}, "hlsl.wave.readlane");
731 }
732 case Builtin::BI__builtin_hlsl_elementwise_sign: {
733 auto *Arg0 = E->getArg(0);
734 Value *Op0 = EmitScalarExpr(Arg0);
735 llvm::Type *Xty = Op0->getType();
736 llvm::Type *retType = llvm::Type::getInt32Ty(this->getLLVMContext());
737 if (Xty->isVectorTy()) {
738 auto *XVecTy = Arg0->getType()->castAs<VectorType>();
739 retType = llvm::VectorType::get(
740 retType, ElementCount::getFixed(XVecTy->getNumElements()));
741 }
742 assert((Arg0->getType()->hasFloatingRepresentation() ||
743 Arg0->getType()->hasIntegerRepresentation()) &&
744 "sign operand must have a float or int representation");
745
746 if (Arg0->getType()->hasUnsignedIntegerRepresentation()) {
747 Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::get(Xty, 0));
748 return Builder.CreateSelect(Cmp, ConstantInt::get(retType, 0),
749 ConstantInt::get(retType, 1), "hlsl.sign");
750 }
751
752 return Builder.CreateIntrinsic(
753 retType, CGM.getHLSLRuntime().getSignIntrinsic(),
754 ArrayRef<Value *>{Op0}, nullptr, "hlsl.sign");
755 }
756 case Builtin::BI__builtin_hlsl_elementwise_radians: {
757 Value *Op0 = EmitScalarExpr(E->getArg(0));
758 assert(E->getArg(0)->getType()->hasFloatingRepresentation() &&
759 "radians operand must have a float representation");
760 return Builder.CreateIntrinsic(
761 /*ReturnType=*/Op0->getType(),
762 CGM.getHLSLRuntime().getRadiansIntrinsic(), ArrayRef<Value *>{Op0},
763 nullptr, "hlsl.radians");
764 }
765 case Builtin::BI__builtin_hlsl_buffer_update_counter: {
766 Value *ResHandle = EmitScalarExpr(E->getArg(0));
767 Value *Offset = EmitScalarExpr(E->getArg(1));
768 Value *OffsetI8 = Builder.CreateIntCast(Offset, Int8Ty, true);
769 return Builder.CreateIntrinsic(
770 /*ReturnType=*/Offset->getType(),
771 CGM.getHLSLRuntime().getBufferUpdateCounterIntrinsic(),
772 ArrayRef<Value *>{ResHandle, OffsetI8}, nullptr);
773 }
774 case Builtin::BI__builtin_hlsl_elementwise_splitdouble: {
775
776 assert((E->getArg(0)->getType()->hasFloatingRepresentation() &&
779 "asuint operands types mismatch");
780 return handleHlslSplitdouble(E, this);
781 }
782 case Builtin::BI__builtin_hlsl_elementwise_clip:
783 assert(E->getArg(0)->getType()->hasFloatingRepresentation() &&
784 "clip operands types mismatch");
785 return handleHlslClip(E, this);
786 case Builtin::BI__builtin_hlsl_group_memory_barrier_with_group_sync: {
787 Intrinsic::ID ID =
788 CGM.getHLSLRuntime().getGroupMemoryBarrierWithGroupSyncIntrinsic();
789 return EmitRuntimeCall(
790 Intrinsic::getOrInsertDeclaration(&CGM.getModule(), ID));
791 }
792 case Builtin::BI__builtin_get_spirv_spec_constant_bool:
793 case Builtin::BI__builtin_get_spirv_spec_constant_short:
794 case Builtin::BI__builtin_get_spirv_spec_constant_ushort:
795 case Builtin::BI__builtin_get_spirv_spec_constant_int:
796 case Builtin::BI__builtin_get_spirv_spec_constant_uint:
797 case Builtin::BI__builtin_get_spirv_spec_constant_longlong:
798 case Builtin::BI__builtin_get_spirv_spec_constant_ulonglong:
799 case Builtin::BI__builtin_get_spirv_spec_constant_half:
800 case Builtin::BI__builtin_get_spirv_spec_constant_float:
801 case Builtin::BI__builtin_get_spirv_spec_constant_double: {
802 llvm::Function *SpecConstantFn = getSpecConstantFunction(E->getType());
803 llvm::Value *SpecId = EmitScalarExpr(E->getArg(0));
804 llvm::Value *DefaultVal = EmitScalarExpr(E->getArg(1));
805 llvm::Value *Args[] = {SpecId, DefaultVal};
806 return Builder.CreateCall(SpecConstantFn, Args);
807 }
808 }
809 return nullptr;
810}
811
813 const clang::QualType &SpecConstantType) {
814
815 // Find or create the declaration for the function.
816 llvm::Module *M = &CGM.getModule();
817 std::string MangledName =
818 getSpecConstantFunctionName(SpecConstantType, getContext());
819 llvm::Function *SpecConstantFn = M->getFunction(MangledName);
820
821 if (!SpecConstantFn) {
822 llvm::Type *IntType = ConvertType(getContext().IntTy);
823 llvm::Type *RetTy = ConvertType(SpecConstantType);
824 llvm::Type *ArgTypes[] = {IntType, RetTy};
825 llvm::FunctionType *FnTy = llvm::FunctionType::get(RetTy, ArgTypes, false);
826 SpecConstantFn = llvm::Function::Create(
827 FnTy, llvm::GlobalValue::ExternalLinkage, MangledName, M);
828 }
829 return SpecConstantFn;
830}
llvm::Value * EmitOverflowIntrinsic(CodeGenFunction &CGF, const Intrinsic::ID IntrinsicID, llvm::Value *X, llvm::Value *Y, llvm::Value *&Carry)
Emit a call to llvm.
static Intrinsic::ID getWaveActiveSumIntrinsic(llvm::Triple::ArchType Arch, CGHLSLRuntime &RT, QualType QT)
static Intrinsic::ID getWaveActiveMaxIntrinsic(llvm::Triple::ArchType Arch, CGHLSLRuntime &RT, QualType QT)
static Intrinsic::ID getDotProductIntrinsic(CGHLSLRuntime &RT, QualType QT)
static std::string getSpecConstantFunctionName(clang::QualType SpecConstantType, ASTContext &Context)
static Value * handleHlslSplitdouble(const CallExpr *E, CodeGenFunction *CGF)
static Intrinsic::ID getFirstBitHighIntrinsic(CGHLSLRuntime &RT, QualType QT)
static Value * handleAsDoubleBuiltin(CodeGenFunction &CGF, const CallExpr *E)
static Value * handleHlslClip(const CallExpr *E, CodeGenFunction *CGF)
#define X(type, name)
Definition Value.h:97
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:188
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition Expr.h:2877
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition Expr.h:3081
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition CGBuilder.h:140
CallArgList - Type for representing both the value and type of arguments in a call.
Definition CGCall.h:274
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
const LangOptions & getLangOpts() const
const TargetInfo & getTarget() const
llvm::Function * getSpecConstantFunction(const clang::QualType &SpecConstantType)
LValue EmitHLSLOutArgExpr(const HLSLOutArgExpr *E, CallArgList &Args, QualType Ty)
Definition CGExpr.cpp:5853
void EmitWritebacks(const CallArgList &Args)
EmitWriteback - Emit callbacks for function.
Definition CGCall.cpp:4875
RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
EmitAnyExpr - Emit code to compute the specified expression which can have any type.
Definition CGExpr.cpp:264
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
llvm::LLVMContext & getLLVMContext()
llvm::Value * EmitHLSLBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
const TargetInfo & getTarget() const
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
Definition CGValue.h:42
bool isScalar() const
Definition CGValue.h:64
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition CGValue.h:83
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition CGValue.h:71
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
Definition CGCall.h:379
The name of a declaration.
QualType getType() const
Definition Expr.h:144
Represents a function declaration or definition.
Definition Decl.h:1999
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, const AssociatedConstraint &TrailingRequiresClause={})
Definition Decl.h:2188
Represents a parameter to a function.
Definition Decl.h:1789
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition Decl.cpp:2946
A (possibly-)qualified type.
Definition TypeBase.h:937
Encodes a location in the source.
bool areArgsDestroyedLeftToRightInCallee() const
Are arguments to a call destroyed left to right in the callee?
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
Definition Type.cpp:2205
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
Definition Type.cpp:2066
const T * castAs() const
Member-template castAs<specific type>.
Definition TypeBase.h:9165
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
Definition Type.cpp:2291
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
Definition Type.cpp:2243
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
Definition Type.cpp:2312
bool isVectorType() const
Definition TypeBase.h:8661
bool isFloatingType() const
Definition Type.cpp:2304
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition Type.cpp:2253
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9098
QualType getType() const
Definition Value.cpp:237
Represents a GCC generic vector type.
Definition TypeBase.h:4173
unsigned getNumElements() const
Definition TypeBase.h:4188
The JSON file list parser is used to communicate input to InstallAPI.
@ SC_Extern
Definition Specifiers.h:251
@ SC_None
Definition Specifiers.h:250
@ Result
The result type of a method or function.
Definition TypeBase.h:905
U cast(CodeGen::Address addr)
Definition Address.h:327
Diagnostic wrappers for TextAPI types for error reporting.
Definition Dominators.h:30
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Extra information about a function prototype.
Definition TypeBase.h:5349