52#include "llvm/IR/IntrinsicsSPIRV.h"
59class SPIRVLegalizePointerCastImpl {
66 {Arg->
getType()}, OfType, Arg, {},
B);
67 GR->addAssignPtrTypeInstr(Arg, AssignCI);
70 static FixedVectorType *makeVectorFromTotalBits(
Type *ElemTy,
73 assert(ElemBits && TotalBits % ElemBits == 0 &&
74 "TotalBits must be divisible by element bit size");
79 FixedVectorType *DstTy) {
82 "shuffle resize expects identical element types");
85 const unsigned NumSource = SrcTy->getNumElements();
87 SmallVector<int>
Mask(NumNeeded);
88 for (
unsigned I = 0;
I < NumNeeded; ++
I)
89 Mask[
I] = (
I < NumSource) ?
static_cast<int>(
I) : -1;
91 Value *Resized =
B.CreateShuffleVector(
V,
V, Mask);
92 buildAssignType(
B, DstTy, Resized);
101 FixedVectorType *TargetType,
Value *Source,
102 Align OriginalAlign) {
103 LoadInst *NewLoad =
B.CreateLoad(SourceType, Source);
105 buildAssignType(
B, SourceType, NewLoad);
106 Value *AssignValue = NewLoad;
108 const DataLayout &
DL =
B.getDataLayout();
109 TypeSize TargetTypeSize =
DL.getTypeSizeInBits(TargetType);
110 TypeSize SourceTypeSize =
DL.getTypeSizeInBits(SourceType);
112 Value *BitcastSrcVal = NewLoad;
113 FixedVectorType *BitcastSrcTy =
117 if (TargetTypeSize != SourceTypeSize) {
118 unsigned TargetElemBits =
119 TargetType->getElementType()->getScalarSizeInBits();
120 if (SourceTypeSize % TargetElemBits == 0) {
123 BitcastDstTy = makeVectorFromTotalBits(
TargetType->getElementType(),
127 BitcastSrcTy = makeVectorFromTotalBits(SourceType->
getElementType(),
129 BitcastSrcVal = resizeVectorBitsWithShuffle(
B, NewLoad, BitcastSrcTy);
133 B.CreateIntrinsic(Intrinsic::spv_bitcast,
134 {BitcastDstTy, BitcastSrcTy}, {BitcastSrcVal});
135 buildAssignType(
B, BitcastDstTy, AssignValue);
136 if (BitcastDstTy == TargetType)
141 const unsigned NumTarget =
TargetType->getNumElements();
142 const unsigned NumSource = AssignVecTy->getNumElements();
148 if (NumTarget > NumSource) {
150 buildAssignType(
B, TargetType, Result);
151 for (
unsigned I = 0;
I < NumSource; ++
I) {
153 Result = makeInsertElement(
B, Result, Scalar,
I);
158 assert(NumTarget < NumSource);
159 SmallVector<int>
Mask( NumTarget);
160 for (
unsigned I = 0;
I < NumTarget; ++
I)
162 Value *
Output =
B.CreateShuffleVector(AssignValue, AssignValue, Mask);
163 buildAssignType(
B, TargetType, Output);
169 bool isCompatibleMemoryLayout(
Type *ToTy,
Type *FromTy) {
181 if (
SAT->getElementType() == DVT->getElementType())
184 if (MAT->getElementType() == DVT->getElementType())
192 std::optional<std::pair<Value *, Type *>>
194 Type *PointerType,
Type *TargetElemType,
196 Type *CurrentTy = GR->findDeducedElementType(BasePtr);
197 assert(CurrentTy &&
"Could not deduce aggregate type");
198 SmallVector<Value *, 8>
Args{
B.getInt1(IsInBounds),
200 Args.push_back(
B.getInt32(0));
202 while (!isCompatibleMemoryLayout(TargetElemType, CurrentTy)) {
204 if (
ST->getNumElements() == 0)
206 CurrentTy =
ST->getTypeAtIndex(0u);
208 CurrentTy = AT->getElementType();
210 CurrentTy = VT->getElementType();
214 Args.push_back(
B.getInt32(0));
218 if (
Args.size() > 3) {
220 GEP =
B.CreateIntrinsic(Intrinsic::spv_gep, {
Types}, {
Args});
221 GR->buildAssignPtr(
B, CurrentTy,
GEP);
224 return std::make_pair(
GEP, CurrentTy);
227 static IntrinsicInst *getResourceGetPointer(
Value *Ptr) {
229 if (
II->getIntrinsicID() == Intrinsic::spv_resource_getpointer)
238 if (IntrinsicInst *ResourcePtr = getResourceGetPointer(BasePtr)) {
239 Value *Handle = ResourcePtr->getOperand(0);
240 Value *BaseOffset = ResourcePtr->getOperand(1);
244 ConstantInt::get(CI->getType(), CI->getZExtValue() + ByteOffset);
246 NewOffset =
B.CreateAdd(
247 BaseOffset, ConstantInt::get(BaseOffset->
getType(), ByteOffset));
248 buildAssignType(
B, NewOffset->
getType(), NewOffset);
251 ResourcePtr->getOperandBundlesAsDefs(OpBundles);
252 CallInst *ResourcePtrAtOffset =
B.CreateCall(
253 ResourcePtr->getFunctionType(), ResourcePtr->getCalledOperand(),
254 {Handle, NewOffset}, OpBundles);
255 ResourcePtrAtOffset->
setAttributes(ResourcePtr->getAttributes());
256 ResourcePtrAtOffset->
setCallingConv(ResourcePtr->getCallingConv());
257 Type *I8Ty = Type::getInt8Ty(
B.getContext());
258 GR->buildAssignPtr(
B, I8Ty, ResourcePtrAtOffset);
259 return ResourcePtrAtOffset;
262 "byte layout pointer must come from spv.resource.getpointer");
267 const DataLayout &
DL =
B.getDataLayout();
273 return B.CreateIntCast(Scalar, IntTy,
false);
274 return B.CreateIntrinsic(Intrinsic::spv_bitcast, {IntTy, Ty}, {
Scalar});
278 if (
IntVal->getType() == ScalarTy)
281 return B.CreateIntCast(IntVal, ScalarTy,
false);
282 return B.CreateIntrinsic(Intrinsic::spv_bitcast,
288 LLVMContext &Ctx =
B.getContext();
289 Type *I8Ty = Type::getInt8Ty(Ctx);
290 const DataLayout &
DL =
B.getDataLayout();
293 buildAssignType(
B,
IntVal->getType(), IntVal);
294 unsigned NumBytes =
DL.getTypeStoreSize(Src->getType());
296 auto StoreByte = [&](
unsigned I,
Value *Shifted) {
298 buildAssignType(
B, I8Ty, Byte);
299 Value *Ptr = gepByteOffset(
B, Dst,
I);
300 StoreInst *
SI =
B.CreateStore(Byte, Ptr);
305 StoreByte(0, IntVal);
307 for (
unsigned I = 1;
I < NumBytes; ++
I) {
309 B.CreateLShr(IntVal, ConstantInt::get(
IntVal->getType(), 8 *
I));
310 StoreByte(
I, Shifted);
316 LLVMContext &Ctx =
B.getContext();
317 Type *I8Ty = Type::getInt8Ty(Ctx);
318 const DataLayout &
DL =
B.getDataLayout();
319 unsigned NumBytes =
DL.getTypeStoreSize(AccessTy);
323 for (
unsigned I = 0;
I < NumBytes; ++
I) {
324 Value *Ptr = gepByteOffset(
B, Src,
I);
325 LoadInst *LI =
B.CreateLoad(I8Ty, Ptr);
327 buildAssignType(
B, I8Ty, LI);
329 buildAssignType(
B, IntTy, Extended);
334 Value *Shifted =
B.CreateShl(Extended, ConstantInt::get(IntTy, 8 *
I));
335 buildAssignType(
B, IntTy, Shifted);
336 IntVal =
B.CreateOr(IntVal, Shifted);
338 buildAssignType(
B, IntTy, IntVal);
342 if (Result != IntVal)
343 buildAssignType(
B, AccessTy, Result);
351 Value *OriginalPtr) {
352 Type *OriginalElemTy = GR->findDeducedElementType(OriginalPtr);
353 const DataLayout &
DL =
B.getDataLayout();
354 if (getResourceGetPointer(OriginalPtr) &&
355 OriginalElemTy == Type::getInt8Ty(
B.getContext()) &&
362 static bool canReinterpretType(
Type *FromTy,
Type *ToTy) {
367 Value *CastedPtr, LoadInst *IllegalLoad) {
368 Type *CastedElemTy = GR->findDeducedElementType(CastedPtr);
369 if (!CastedElemTy || CastedElemTy != AccessTy)
373 if (shouldReinterpretByteWise(
B, AccessTy, OriginalPtr)) {
374 const DataLayout &
DL =
B.getDataLayout();
377 unsigned ElemSize =
DL.getTypeStoreSize(VT->getElementType());
378 SmallVector<Value *, 4> LoadedElements;
379 for (
unsigned I = 0;
I < VT->getNumElements(); ++
I) {
380 Value *ElemPtr = gepByteOffset(
B, OriginalPtr,
I * ElemSize);
381 LoadedElements.
push_back(loadScalarFromByteLayout(
382 B, VT->getElementType(), ElemPtr,
385 Loaded = buildVectorFromLoadedElements(
B, VT, LoadedElements);
387 Loaded = loadScalarFromByteLayout(
B, AccessTy, OriginalPtr, Alignment);
388 buildAssignType(
B, AccessTy, Loaded);
390 GR->replaceAllUsesWith(IllegalLoad, Loaded,
true);
391 DeadInstructions.push_back(IllegalLoad);
395 Type *OriginalTy = GR->findDeducedElementType(OriginalPtr);
396 if (!canReinterpretType(OriginalTy, AccessTy))
398 "Cannot lower a pointer cast without equal-width numeric types for "
401 LoadInst *LI =
B.CreateLoad(OriginalTy, OriginalPtr);
405 buildAssignType(
B, OriginalTy, LI);
407 B.CreateIntrinsic(Intrinsic::spv_bitcast, {AccessTy, OriginalTy}, {LI});
408 buildAssignType(
B, AccessTy, Loaded);
409 GR->replaceAllUsesWith(IllegalLoad, Loaded,
true);
410 DeadInstructions.push_back(IllegalLoad);
415 Value *CastedPtr,
Value *StoreSrc, Align Alignment,
416 Instruction *IllegalStore) {
417 Type *CastedElemTy = GR->findDeducedElementType(CastedPtr);
418 if (!CastedElemTy || CastedElemTy != AccessTy)
421 if (shouldReinterpretByteWise(
B, AccessTy, OriginalPtr)) {
422 const DataLayout &
DL =
B.getDataLayout();
424 unsigned ElemSize =
DL.getTypeStoreSize(VT->getElementType());
425 for (
unsigned I = 0;
I < VT->getNumElements(); ++
I) {
426 Value *Elem = extractScalarFromVector(
B, StoreSrc,
I);
427 Value *ElemPtr = gepByteOffset(
B, OriginalPtr,
I * ElemSize);
428 storeScalarToByteLayout(
B, Elem, ElemPtr,
432 storeScalarToByteLayout(
B, StoreSrc, OriginalPtr, Alignment);
437 Type *OriginalTy = GR->findDeducedElementType(OriginalPtr);
438 if (!canReinterpretType(AccessTy, OriginalTy))
440 "Cannot lower a pointer cast without equal-width numeric types for "
443 Value *Stored =
B.CreateIntrinsic(Intrinsic::spv_bitcast,
444 {OriginalTy, AccessTy}, {StoreSrc});
445 buildAssignType(
B, OriginalTy, Stored);
446 StoreInst *
SI =
B.CreateStore(Stored, OriginalPtr);
447 SI->setAlignment(Alignment);
449 SI->setVolatile(OldSI->isVolatile());
450 SI->setAtomic(OldSI->getOrdering(), OldSI->getSyncScopeID());
459 LoadInst *IllegalLoad,
Value *CastedPtr) {
460 auto ResultOpt = getPointerToFirstCompatibleType(
463 if (tryReinterpretLoad(
B, ElementType, Source, CastedPtr, IllegalLoad))
466 "Could not find compatible memory layout.");
468 auto [
GEP, CurrentTy] = *ResultOpt;
476 if (ElementType == CurrentTy) {
477 LoadInst *LI =
B.CreateLoad(ElementType,
GEP);
479 buildAssignType(
B, ElementType, LI);
483 LoadInst *LI =
B.CreateLoad(CurrentTy,
GEP);
485 buildAssignType(
B, CurrentTy, LI);
486 Value *
Result =
B.CreateIntrinsic(Intrinsic::spv_bitcast,
488 buildAssignType(
B, ElementType, Result);
492 return loadVectorFromVector(
B, SVT, DVT,
GEP, IllegalLoad->
getAlign());
493 if (
SAT && DVT &&
SAT->getElementType() == DVT->getElementType())
494 return loadVectorFromArray(
B, DVT,
GEP, IllegalLoad->
getAlign());
495 if (MAT && DVT && MAT->getElementType() == DVT->getElementType())
496 return loadVectorFromMatrixArray(
B, DVT,
GEP, MAT,
503 buildVectorFromLoadedElements(
IRBuilder<> &
B, FixedVectorType *TargetType,
504 SmallVector<Value *, 4> &LoadedElements) {
508 bool CanUseAnyVectorRank = TM.getSubtargetImpl()->canUseExtension(
509 SPIRV::Extension::SPV_EXT_long_vector);
510 if (
TargetType->getNumElements() == 1 && !CanUseAnyVectorRank) {
512 Value *NewVector =
B.CreateIntrinsic(
514 buildAssignType(
B, TargetType, NewVector);
520 buildAssignType(
B, TargetType, NewVector);
528 NewVector =
B.CreateIntrinsic(Intrinsic::spv_insertelt, {
Types}, {
Args});
529 buildAssignType(
B, TargetType, NewVector);
537 Value *Source, FixedVectorType *ArrElemVecTy,
538 Align OriginalAlign) {
541 const DataLayout &
DL =
B.getDataLayout();
542 uint64_t ArrElemVecSize =
DL.getTypeAllocSize(ArrElemVecTy);
544 SmallVector<Value *, 4> LoadedElements;
547 unsigned ArrayIndex =
I / ScalarsPerArrayElement;
548 unsigned ElementIndexInArrayElem =
I % ScalarsPerArrayElement;
550 std::array<Value *, 4>
Args = {
551 B.getInt1(
false),
Source,
B.getInt32(0),
552 ConstantInt::get(
B.getInt32Ty(), ArrayIndex)};
553 auto *ElementPtr =
B.CreateIntrinsic(Intrinsic::spv_gep, {
Types}, {
Args});
554 GR->buildAssignPtr(
B, ArrElemVecTy, ElementPtr);
555 LoadInst *LoadVec =
B.CreateLoad(ArrElemVecTy, ElementPtr);
558 buildAssignType(
B, ArrElemVecTy, LoadVec);
559 LoadedElements.
push_back(makeExtractElement(
B, TargetElemTy, LoadVec,
560 ElementIndexInArrayElem));
562 return buildVectorFromLoadedElements(
B, TargetType, LoadedElements);
567 Value *Source, Align OriginalAlign) {
569 SmallVector<Value *, 4> LoadedElements;
571 const DataLayout &
DL =
B.getDataLayout();
575 std::array<Value *, 4>
Args = {
B.getInt1(
false),
Source,
577 ConstantInt::get(
B.getInt32Ty(),
I)};
578 auto *ElementPtr =
B.CreateIntrinsic(Intrinsic::spv_gep, {
Types}, {
Args});
579 GR->buildAssignPtr(
B,
TargetType->getElementType(), ElementPtr);
582 LoadInst *
Load =
B.CreateLoad(
TargetType->getElementType(), ElementPtr);
587 return buildVectorFromLoadedElements(
B, TargetType, LoadedElements);
592 Value *DstArrayPtr, ArrayType *ArrTy,
598 unsigned SrcNumElements = SrcVecTy->getNumElements();
600 SrcNumElements % ScalarsPerArrayElement == 0 &&
601 "Source vector size must be a multiple of array element vector size");
605 const DataLayout &
DL =
B.getDataLayout();
606 uint64_t ArrElemVecSize =
DL.getTypeAllocSize(ArrElemVecTy);
608 for (
unsigned I = 0;
I < SrcNumElements;
I += ScalarsPerArrayElement) {
609 unsigned ArrayIndex =
I / ScalarsPerArrayElement;
611 std::array<Value *, 4>
Args = {
612 B.getInt1(
false), DstArrayPtr,
B.getInt32(0),
613 ConstantInt::get(
B.getInt32Ty(), ArrayIndex)};
614 auto *ElementPtr =
B.CreateIntrinsic(Intrinsic::spv_gep, {
Types}, {
Args});
615 GR->buildAssignPtr(
B, ArrElemVecTy, ElementPtr);
619 for (
unsigned J = 0; J < ScalarsPerArrayElement; ++J)
620 Elements.push_back(makeExtractElement(
B, ElemTy, SrcVector,
I + J));
623 Value *Vec = buildVectorFromLoadedElements(
B, ArrElemVecTy, Elements);
624 StoreInst *
SI =
B.CreateStore(Vec, ElementPtr);
631 Value *DstArrayPtr, ArrayType *ArrTy,
634 Type *ElemTy = ArrTy->getElementType();
637 assert(VecTy->getElementType() == ElemTy &&
638 "Element types of array and vector must be the same.");
641 const DataLayout &
DL =
B.getDataLayout();
642 uint64_t ElemSize =
DL.getTypeAllocSize(ElemTy);
644 for (
unsigned I = 0,
E = VecTy->getNumElements();
I <
E; ++
I) {
646 std::array<Value *, 4>
Args = {
B.getInt1(
false), DstArrayPtr,
648 ConstantInt::get(
B.getInt32Ty(),
I)};
649 auto *ElementPtr =
B.CreateIntrinsic(Intrinsic::spv_gep, {
Types}, {
Args});
650 GR->buildAssignPtr(
B, ElemTy, ElementPtr);
653 bool CanUseAnyVectorRank = TM.getSubtargetImpl()->canUseExtension(
654 SPIRV::Extension::SPV_EXT_long_vector);
655 Value *Element = (
E == 1 && !CanUseAnyVectorRank)
657 : makeExtractElement(
B, ElemTy, SrcVector,
I);
658 StoreInst *
SI =
B.CreateStore(Element, ElementPtr);
666 Value *OriginalOperand) {
667 Type *ToTy = GR->findDeducedElementType(CastedOperand);
668 B.SetInsertPoint(LI);
671 buildLegalizedLoad(
B, ToTy, OriginalOperand, LI, CastedOperand);
675 GR->replaceAllUsesWith(LI, Output,
true);
676 DeadInstructions.push_back(LI);
682 Type *Int32Ty = Type::getInt32Ty(
B.getContext());
686 Value *NewI =
B.CreateIntrinsic(Intrinsic::spv_insertelt, {
Types}, {
Args});
687 buildAssignType(
B,
Vector->getType(), NewI);
695 Type *Int32Ty = Type::getInt32Ty(
B.getContext());
698 Value *NewI =
B.CreateIntrinsic(Intrinsic::spv_extractelt, {
Types}, {
Args});
699 buildAssignType(
B, ElementType, NewI);
709 Type *ElemTy = VecTy->getElementType();
710 if (VecTy->getNumElements() == 1) {
712 B.CreateIntrinsic(Intrinsic::spv_bitcast, {ElemTy, VecTy}, {
Vector});
713 buildAssignType(
B, ElemTy, Scalar);
716 return makeExtractElement(
B, ElemTy,
Vector, Index);
724 FixedVectorType *DstType =
733 [[maybe_unused]]
auto dstBitWidth =
735 [[maybe_unused]]
auto srcBitWidth =
737 assert(dstBitWidth == srcBitWidth &&
738 "Unsupported bitcast between vectors of different sizes.");
741 B.CreateIntrinsic(Intrinsic::spv_bitcast, {DstType, SrcType}, {Src});
742 buildAssignType(
B, DstType, Src);
744 StoreInst *
SI =
B.CreateStore(Src, Dst);
745 SI->setAlignment(Alignment);
750 LoadInst *LI =
B.CreateLoad(DstType, Dst);
752 Value *OldValues = LI;
753 buildAssignType(
B, OldValues->
getType(), OldValues);
756 Value *Element = extractScalarFromVector(
B, Src,
I);
757 OldValues = makeInsertElement(
B, OldValues, Element,
I);
760 StoreInst *
SI =
B.CreateStore(OldValues, Dst);
761 SI->setAlignment(Alignment);
768 Align Alignment,
Value *CastedPtr,
769 Instruction *IllegalStore) {
770 auto ResultOpt = getPointerToFirstCompatibleType(
B, Dst, Dst->getType(),
771 Src->getType(),
true);
773 if (tryReinterpretStore(
B, Src->getType(), Dst, CastedPtr, Src, Alignment,
777 "Could not find compatible memory layout.");
779 auto [
GEP, CurrentTy] = *ResultOpt;
787 if (Src->getType() == CurrentTy) {
788 StoreInst *
SI =
B.CreateStore(Src,
GEP);
789 SI->setAlignment(Alignment);
793 Value *
Result =
B.CreateIntrinsic(Intrinsic::spv_bitcast,
794 {CurrentTy, Src->getType()}, {Src});
795 buildAssignType(
B, CurrentTy, Result);
796 StoreInst *
SI =
B.CreateStore(Result,
GEP);
797 SI->setAlignment(Alignment);
801 storeVectorFromVector(
B, Src,
GEP, Alignment);
804 if (DAT && SVT && SVT->getElementType() == DAT->getElementType()) {
805 storeArrayFromVector(
B, Src,
GEP, DAT, Alignment);
808 if (DMAT && SVT && DMAT->getElementType() == SVT->getElementType()) {
809 storeMatrixArrayFromVector(
B, Src,
GEP, DAT, Alignment);
819 Value *Dst,
Value *CastedOperand, Align Alignment) {
820 B.SetInsertPoint(IllegalStore);
821 buildLegalizedStore(
B, Src, Dst, Alignment, CastedOperand, IllegalStore);
822 DeadInstructions.push_back(IllegalStore);
825 void legalizePointerCast(IntrinsicInst *
II) {
827 Value *OriginalOperand =
II->getOperand(0);
830 std::vector<Value *>
Users;
831 for (Use &U :
II->uses())
832 Users.push_back(
U.getUser());
836 transformLoad(
B, LI, CastedOperand, OriginalOperand);
841 transformStore(
B, SI,
SI->getValueOperand(), OriginalOperand,
842 CastedOperand,
SI->getAlign());
847 if (Intrin->getIntrinsicID() == Intrinsic::spv_assign_ptr_type) {
848 DeadInstructions.push_back(Intrin);
852 if (Intrin->getIntrinsicID() == Intrinsic::spv_gep) {
853 GR->replaceAllUsesWith(CastedOperand, OriginalOperand,
858 if (Intrin->getIntrinsicID() == Intrinsic::spv_store) {
862 transformStore(
B, Intrin, Intrin->getArgOperand(0), OriginalOperand,
863 CastedOperand, Alignment);
871 DeadInstructions.push_back(
II);
875 SPIRVLegalizePointerCastImpl(
const SPIRVTargetMachine &TM) : TM(TM) {}
878 const SPIRVSubtarget &
ST = TM.getSubtarget<SPIRVSubtarget>(
F);
879 GR =
ST.getSPIRVGlobalRegistry();
880 DeadInstructions.clear();
882 std::vector<IntrinsicInst *> WorkList;
886 if (
II &&
II->getIntrinsicID() == Intrinsic::spv_ptrcast)
887 WorkList.push_back(
II);
891 for (IntrinsicInst *
II : WorkList)
892 legalizePointerCast(
II);
894 for (Instruction *
I : DeadInstructions)
895 I->eraseFromParent();
897 return DeadInstructions.size() != 0;
901 const SPIRVTargetMachine &TM;
902 SPIRVGlobalRegistry *GR =
nullptr;
903 std::vector<Instruction *> DeadInstructions;
906class SPIRVLegalizePointerCastLegacy :
public FunctionPass {
909 SPIRVLegalizePointerCastLegacy(
const SPIRVTargetMachine &TM)
910 : FunctionPass(ID), TM(TM) {}
913 return SPIRVLegalizePointerCastImpl(TM).run(
F);
917 const SPIRVTargetMachine &TM;
927char SPIRVLegalizePointerCastLegacy::ID = 0;
929 "SPIRV legalize pointer cast pass",
false,
false)
932 return new SPIRVLegalizePointerCastLegacy(*TM);
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static bool runOnFunction(Function &F, bool PostInlining)
iv Induction Variable Users
uint64_t IntrinsicInst * II
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
void setCallingConv(CallingConv::ID CC)
void setAttributes(AttributeList A)
Set the attributes for this call.
static LLVM_ABI bool isBitCastable(Type *SrcTy, Type *DestTy)
Check whether a bitcast between these types is valid.
unsigned getNumElements() const
static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)
FunctionPass class - This class is used to implement most global optimizations.
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
void setAlignment(Align Align)
bool isVolatile() const
Return true if this is a load from a volatile memory location.
void setAtomic(AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Sets the ordering constraint and the synchronization scope ID of this load instruction.
AtomicOrdering getOrdering() const
Returns the ordering constraint of this load instruction.
Type * getPointerOperandType() const
void setVolatile(bool V)
Specify whether this is a volatile load or not.
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this load instruction.
Align getAlign() const
Return the alignment of the access that is being performed.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
void push_back(const T &Elt)
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isSingleValueType() const
Return true if the type is a valid type for a register in codegen.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
bool isIntegerTy() const
True if this is an instance of IntegerType.
Type * getType() const
All values are typed, get the type of this value.
Type * getElementType() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
ElementType
The element type of an SRV or UAV resource.
This is an optimization pass for GlobalISel generic memory operations.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
@ Load
The value being inserted comes from a load (InsertElement only).
CallInst * buildIntrWithMD(Intrinsic::ID IntrID, ArrayRef< Type * > Types, Value *Arg, Value *Arg2, ArrayRef< Constant * > Imms, IRBuilder<> &B)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
IRBuilder(LLVMContext &, FolderTy, InserterTy) -> IRBuilder< FolderTy, InserterTy >
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Align commonAlignment(Align A, uint64_t Offset)
Returns the alignment that satisfies both alignments.
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
FunctionPass * createSPIRVLegalizePointerCastPass(SPIRVTargetMachine *TM)