Lines Matching defs:I
84 Type *deduceElementType(Value *I, bool UnknownElemTypeI8);
85 Type *deduceElementTypeHelper(Value *I, bool UnknownElemTypeI8);
86 Type *deduceElementTypeHelper(Value *I, std::unordered_set<Value *> &Visited,
96 void maybeAssignPtrType(Type *&Ty, Value *I, Type *RefTy,
106 void deduceOperandElementType(Instruction *I, Instruction *AskOp = 0,
128 void processInstrAfterVisit(Instruction *I, IRBuilder<> &B);
129 bool insertAssignPtrTypeIntrs(Instruction *I, IRBuilder<> &B,
131 void insertAssignTypeIntrs(Instruction *I, IRBuilder<> &B);
134 void replacePointerOperandWithPtrCast(Instruction *I, Value *Pointer,
138 void insertPtrCastOrAssignTypeInstr(Instruction *I, IRBuilder<> &B);
139 void insertSpirvDecorations(Instruction *I, IRBuilder<> &B);
155 Instruction *visitInstruction(Instruction &I) { return &I; }
156 Instruction *visitSwitchInst(SwitchInst &I);
157 Instruction *visitGetElementPtrInst(GetElementPtrInst &I);
158 Instruction *visitBitCastInst(BitCastInst &I);
159 Instruction *visitInsertElementInst(InsertElementInst &I);
160 Instruction *visitExtractElementInst(ExtractElementInst &I);
161 Instruction *visitInsertValueInst(InsertValueInst &I);
162 Instruction *visitExtractValueInst(ExtractValueInst &I);
163 Instruction *visitLoadInst(LoadInst &I);
164 Instruction *visitStoreInst(StoreInst &I);
165 Instruction *visitAllocaInst(AllocaInst &I);
166 Instruction *visitAtomicCmpXchgInst(AtomicCmpXchgInst &I);
167 Instruction *visitUnreachableInst(UnreachableInst &I);
168 Instruction *visitCallInst(CallInst &I);
181 bool isConvergenceIntrinsic(const Instruction *I) {
182 const auto *II = dyn_cast<IntrinsicInst>(I);
197 static inline bool isAssignTypeInstr(const Instruction *I) {
198 return isa<IntrinsicInst>(I) &&
199 cast<IntrinsicInst>(I)->getIntrinsicID() == Intrinsic::spv_assign_type;
202 static bool isMemInstrToReplace(Instruction *I) {
203 return isa<StoreInst>(I) || isa<LoadInst>(I) || isa<InsertValueInst>(I) ||
204 isa<ExtractValueInst>(I) || isa<AtomicCmpXchgInst>(I);
213 static void setInsertPointSkippingPhis(IRBuilder<> &B, Instruction *I) {
214 if (isa<PHINode>(I))
215 B.SetInsertPoint(I->getParent()->getFirstNonPHIOrDbgOrAlloca());
217 B.SetInsertPoint(I);
220 static void setInsertPointAfterDef(IRBuilder<> &B, Instruction *I) {
221 B.SetCurrentDebugLocation(I->getDebugLoc());
222 if (I->getType()->isVoidTy())
223 B.SetInsertPoint(I->getNextNode());
225 B.SetInsertPoint(*I->getInsertionPointAfterDef());
228 static bool requireAssignType(Instruction *I) {
229 IntrinsicInst *Intr = dyn_cast<IntrinsicInst>(I);
240 static inline void reportFatalOnTokenType(const Instruction *I) {
241 if (I->getType()->isTokenTy())
254 static inline Type *restoreMutatedType(SPIRVGlobalRegistry *GR, Instruction *I,
256 CallInst *CI = dyn_cast<CallInst>(I);
384 Type *SPIRVEmitIntrinsics::deduceElementTypeHelper(Value *I,
387 return deduceElementTypeHelper(I, Visited, UnknownElemTypeI8);
395 if (auto *I = dyn_cast<Instruction>(Op)) {
396 UncompleteTypeInfo.insert(I);
397 PostprocessWorklist.push_back(I);
404 Value *I, std::unordered_set<Value *> &Visited, bool UnknownElemTypeI8) {
406 if (!I)
410 if (Type *KnownTy = GR->findDeducedElementType(I))
414 if (Visited.find(I) != Visited.end())
416 Visited.insert(I);
421 if (auto *Ref = dyn_cast<AllocaInst>(I)) {
422 maybeAssignPtrType(Ty, I, Ref->getAllocatedType(), UnknownElemTypeI8);
423 } else if (auto *Ref = dyn_cast<GetElementPtrInst>(I)) {
425 } else if (auto *Ref = dyn_cast<GlobalValue>(I)) {
430 } else if (auto *Ref = dyn_cast<AddrSpaceCastInst>(I)) {
433 maybeAssignPtrType(Ty, I, RefTy, UnknownElemTypeI8);
434 } else if (auto *Ref = dyn_cast<BitCastInst>(I)) {
439 } else if (auto *Ref = dyn_cast<AtomicCmpXchgInst>(I)) {
443 } else if (auto *Ref = dyn_cast<AtomicRMWInst>(I)) {
447 } else if (auto *Ref = dyn_cast<PHINode>(I)) {
454 } else if (auto *Ref = dyn_cast<SelectInst>(I)) {
460 } else if (auto *CI = dyn_cast<CallInst>(I)) {
488 GR->addDeducedElementType(I, Ty);
584 Type *SPIRVEmitIntrinsics::deduceElementType(Value *I, bool UnknownElemTypeI8) {
585 if (Type *Ty = deduceElementTypeHelper(I, UnknownElemTypeI8))
589 if (auto *Instr = dyn_cast<Instruction>(I)) {
593 return IntegerType::getInt8Ty(I->getContext());
596 static inline Type *getAtomicElemTy(SPIRVGlobalRegistry *GR, Instruction *I,
601 auto *PtrTy = dyn_cast<PointerType>(I->getType());
603 return I->getType();
604 if (Type *NestedTy = GR->findDeducedElementType(I))
613 void SPIRVEmitIntrinsics::deduceOperandElementType(Instruction *I,
620 if (auto *Ref = dyn_cast<PHINode>(I)) {
621 if (!isPointerTy(I->getType()) ||
622 !(KnownElemTy = GR->findDeducedElementType(I)))
629 } else if (auto *Ref = dyn_cast<AddrSpaceCastInst>(I)) {
630 KnownElemTy = GR->findDeducedElementType(I);
634 } else if (auto *Ref = dyn_cast<GetElementPtrInst>(I)) {
643 } else if (auto *Ref = dyn_cast<LoadInst>(I)) {
644 KnownElemTy = I->getType();
652 } else if (auto *Ref = dyn_cast<StoreInst>(I)) {
662 } else if (auto *Ref = dyn_cast<AtomicCmpXchgInst>(I)) {
663 KnownElemTy = getAtomicElemTy(GR, I, Ref->getPointerOperand());
668 } else if (auto *Ref = dyn_cast<AtomicRMWInst>(I)) {
669 KnownElemTy = getAtomicElemTy(GR, I, Ref->getPointerOperand());
674 } else if (auto *Ref = dyn_cast<SelectInst>(I)) {
675 if (!isPointerTy(I->getType()) ||
676 !(KnownElemTy = GR->findDeducedElementType(I)))
683 } else if (auto *Ref = dyn_cast<ReturnInst>(I)) {
700 } else if (auto *Ref = dyn_cast<ICmpInst>(I)) {
714 } else if (auto *CI = dyn_cast<CallInst>(I)) {
753 KnownElemTy = getAtomicElemTy(GR, I, Op);
786 setInsertPointSkippingPhis(B, User ? User->getNextNode() : I);
811 I->setOperand(OpIt.second, PtrCastI);
840 for (auto &I : instructions(F))
841 Worklist.push(&I);
844 Instruction *I = Worklist.front();
848 for (auto &Op : I->operands()) {
854 setInsertPointSkippingPhis(B, I);
859 I->replaceUsesOfWith(Op, IntrUndef);
868 for (auto &I : instructions(F))
869 Worklist.push(&I);
872 auto *I = Worklist.front();
873 bool IsPhi = isa<PHINode>(I), BPrepared = false;
874 assert(I);
876 for (const auto &Op : I->operands()) {
904 IsPhi ? B.SetInsertPointPastAllocas(I->getParent()->getParent())
905 : B.SetInsertPoint(I);
911 I->replaceUsesOfWith(Op, CI);
943 Instruction *SPIRVEmitIntrinsics::visitSwitchInst(SwitchInst &I) {
944 BasicBlock *ParentBB = I.getParent();
946 B.SetInsertPoint(&I);
949 for (auto &Op : I.operands()) {
960 {I.getOperand(0)->getType()}, {Args});
963 I.replaceAllUsesWith(NewI);
964 I.eraseFromParent();
976 Instruction *SPIRVEmitIntrinsics::visitGetElementPtrInst(GetElementPtrInst &I) {
977 IRBuilder<> B(I.getParent());
978 B.SetInsertPoint(&I);
979 SmallVector<Type *, 2> Types = {I.getType(), I.getOperand(0)->getType()};
981 Args.push_back(B.getInt1(I.isInBounds()));
982 for (auto &Op : I.operands())
985 I.replaceAllUsesWith(NewI);
986 I.eraseFromParent();
990 Instruction *SPIRVEmitIntrinsics::visitBitCastInst(BitCastInst &I) {
991 IRBuilder<> B(I.getParent());
992 B.SetInsertPoint(&I);
993 Value *Source = I.getOperand(0);
999 if (isPointerTy(I.getType())) {
1000 I.replaceAllUsesWith(Source);
1001 I.eraseFromParent();
1005 SmallVector<Type *, 2> Types = {I.getType(), Source->getType()};
1006 SmallVector<Value *> Args(I.op_begin(), I.op_end());
1008 std::string InstName = I.hasName() ? I.getName().str() : "";
1009 I.replaceAllUsesWith(NewI);
1010 I.eraseFromParent();
1051 Instruction *I, Value *Pointer, Type *ExpectedElementType,
1064 setInsertPointSkippingPhis(B, I);
1094 // as I. Otherwise, search for other spv_ptrcast/spv_assign_ptr_type.
1095 if (II->getParent() != I->getParent())
1098 I->setOperand(OperandToReplace, II);
1119 I->setOperand(OperandToReplace, PtrCastI);
1122 void SPIRVEmitIntrinsics::insertPtrCastOrAssignTypeInstr(Instruction *I,
1125 StoreInst *SI = dyn_cast<StoreInst>(I);
1128 I, SI->getValueOperand(), IntegerType::getInt8Ty(F->getContext()), 0,
1137 return replacePointerOperandWithPtrCast(I, SI->getPointerOperand(), OpTy, 1,
1139 } else if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
1140 return replacePointerOperandWithPtrCast(I, LI->getPointerOperand(),
1142 } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) {
1143 return replacePointerOperandWithPtrCast(I, GEPI->getPointerOperand(),
1148 CallInst *CI = dyn_cast<CallInst>(I);
1211 DemangledName, OpIdx, I->getContext());
1223 Instruction *SPIRVEmitIntrinsics::visitInsertElementInst(InsertElementInst &I) {
1224 SmallVector<Type *, 4> Types = {I.getType(), I.getOperand(0)->getType(),
1225 I.getOperand(1)->getType(),
1226 I.getOperand(2)->getType()};
1227 IRBuilder<> B(I.getParent());
1228 B.SetInsertPoint(&I);
1229 SmallVector<Value *> Args(I.op_begin(), I.op_end());
1231 std::string InstName = I.hasName() ? I.getName().str() : "";
1232 I.replaceAllUsesWith(NewI);
1233 I.eraseFromParent();
1239 SPIRVEmitIntrinsics::visitExtractElementInst(ExtractElementInst &I) {
1240 IRBuilder<> B(I.getParent());
1241 B.SetInsertPoint(&I);
1242 SmallVector<Type *, 3> Types = {I.getType(), I.getVectorOperandType(),
1243 I.getIndexOperand()->getType()};
1244 SmallVector<Value *, 2> Args = {I.getVectorOperand(), I.getIndexOperand()};
1246 std::string InstName = I.hasName() ? I.getName().str() : "";
1247 I.replaceAllUsesWith(NewI);
1248 I.eraseFromParent();
1253 Instruction *SPIRVEmitIntrinsics::visitInsertValueInst(InsertValueInst &I) {
1254 IRBuilder<> B(I.getParent());
1255 B.SetInsertPoint(&I);
1256 SmallVector<Type *, 1> Types = {I.getInsertedValueOperand()->getType()};
1258 for (auto &Op : I.operands())
1263 for (auto &Op : I.indices())
1267 replaceMemInstrUses(&I, NewI, B);
1271 Instruction *SPIRVEmitIntrinsics::visitExtractValueInst(ExtractValueInst &I) {
1272 IRBuilder<> B(I.getParent());
1273 B.SetInsertPoint(&I);
1275 for (auto &Op : I.operands())
1277 for (auto &Op : I.indices())
1280 B.CreateIntrinsic(Intrinsic::spv_extractv, {I.getType()}, {Args});
1281 I.replaceAllUsesWith(NewI);
1282 I.eraseFromParent();
1286 Instruction *SPIRVEmitIntrinsics::visitLoadInst(LoadInst &I) {
1287 if (!I.getType()->isAggregateType())
1288 return &I;
1289 IRBuilder<> B(I.getParent());
1290 B.SetInsertPoint(&I);
1294 TLI->getLoadMemOperandFlags(I, F->getDataLayout());
1296 B.CreateIntrinsic(Intrinsic::spv_load, {I.getOperand(0)->getType()},
1297 {I.getPointerOperand(), B.getInt16(Flags),
1298 B.getInt8(I.getAlign().value())});
1299 replaceMemInstrUses(&I, NewI, B);
1303 Instruction *SPIRVEmitIntrinsics::visitStoreInst(StoreInst &I) {
1304 if (!AggrStores.contains(&I))
1305 return &I;
1306 IRBuilder<> B(I.getParent());
1307 B.SetInsertPoint(&I);
1311 TLI->getStoreMemOperandFlags(I, F->getDataLayout());
1312 auto *PtrOp = I.getPointerOperand();
1314 Intrinsic::spv_store, {I.getValueOperand()->getType(), PtrOp->getType()},
1315 {I.getValueOperand(), PtrOp, B.getInt16(Flags),
1316 B.getInt8(I.getAlign().value())});
1317 I.eraseFromParent();
1321 Instruction *SPIRVEmitIntrinsics::visitAllocaInst(AllocaInst &I) {
1323 if (I.isArrayAllocation()) {
1324 const SPIRVSubtarget *STI = TM->getSubtargetImpl(*I.getFunction());
1331 ArraySize = I.getArraySize();
1333 IRBuilder<> B(I.getParent());
1334 B.SetInsertPoint(&I);
1336 Type *PtrTy = I.getType();
1341 std::string InstName = I.hasName() ? I.getName().str() : "";
1342 I.replaceAllUsesWith(NewI);
1343 I.eraseFromParent();
1348 Instruction *SPIRVEmitIntrinsics::visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) {
1349 assert(I.getType()->isAggregateType() && "Aggregate result is expected");
1350 IRBuilder<> B(I.getParent());
1351 B.SetInsertPoint(&I);
1353 for (auto &Op : I.operands())
1355 Args.push_back(B.getInt32(I.getSyncScopeID()));
1357 static_cast<uint32_t>(getMemSemantics(I.getSuccessOrdering()))));
1359 static_cast<uint32_t>(getMemSemantics(I.getFailureOrdering()))));
1361 {I.getPointerOperand()->getType()}, {Args});
1362 replaceMemInstrUses(&I, NewI, B);
1366 Instruction *SPIRVEmitIntrinsics::visitUnreachableInst(UnreachableInst &I) {
1367 IRBuilder<> B(I.getParent());
1368 B.SetInsertPoint(&I);
1370 return &I;
1398 bool SPIRVEmitIntrinsics::insertAssignPtrTypeIntrs(Instruction *I,
1401 reportFatalOnTokenType(I);
1402 if (!isPointerTy(I->getType()) || !requireAssignType(I) ||
1403 isa<BitCastInst>(I))
1406 setInsertPointAfterDef(B, I);
1407 if (Type *ElemTy = deduceElementType(I, UnknownElemTypeI8)) {
1408 buildAssignPtr(B, ElemTy, I);
1414 void SPIRVEmitIntrinsics::insertAssignTypeIntrs(Instruction *I,
1422 reportFatalOnTokenType(I);
1425 if (auto *CI = dyn_cast<CallInst>(I)) {
1436 setInsertPointAfterDef(B, I);
1439 buildAssignType(B, TargetExtType::get(I->getContext(), "spirv.Event"),
1440 I);
1447 Type *Ty = I->getType();
1448 if (!IsKnown && !Ty->isVoidTy() && !isPointerTy(Ty) && requireAssignType(I)) {
1449 setInsertPointAfterDef(B, I);
1451 if (auto *II = dyn_cast<IntrinsicInst>(I)) {
1460 TypeToAssign = restoreMutatedType(GR, I, TypeToAssign);
1461 buildAssignType(B, TypeToAssign, I);
1463 for (const auto &Op : I->operands()) {
1467 setInsertPointSkippingPhis(B, I);
1491 void SPIRVEmitIntrinsics::insertSpirvDecorations(Instruction *I,
1493 if (MDNode *MD = I->getMetadata("spirv.Decorations")) {
1494 setInsertPointAfterDef(B, I);
1495 B.CreateIntrinsic(Intrinsic::spv_assign_decoration, {I->getType()},
1496 {I, MetadataAsValue::get(I->getContext(), MD)});
1500 void SPIRVEmitIntrinsics::processInstrAfterVisit(Instruction *I,
1502 auto *II = dyn_cast<IntrinsicInst>(I);
1505 setInsertPointAfterDef(B, I);
1506 auto t = AggrConsts.find(I);
1510 {II->getType(), II->getType()}, t->second, I, {}, B);
1511 I->replaceAllUsesWith(NewOp);
1512 NewOp->setArgOperand(0, I);
1514 bool IsPhi = isa<PHINode>(I), BPrepared = false;
1515 for (const auto &Op : I->operands()) {
1516 if (isa<PHINode>(I) || isa<SwitchInst>(I))
1524 IsPhi ? B.SetInsertPointPastAllocas(I->getParent()->getParent())
1525 : B.SetInsertPoint(I);
1534 I->setOperand(OpNo, NewOp);
1537 if (I->hasName()) {
1538 reportFatalOnTokenType(I);
1539 setInsertPointAfterDef(B, I);
1540 std::vector<Value *> Args = {I};
1541 addStringImm(I->getName(), B, Args);
1542 B.CreateIntrinsic(Intrinsic::spv_assign_name, {I->getType()}, Args);
1653 for (auto &I : instructions(Func)) {
1654 StoreInst *SI = dyn_cast<StoreInst>(&I);
1659 AggrStores.insert(&I);
1669 for (auto &I : instructions(Func))
1670 Worklist.push_back(&I);
1672 for (auto &I : Worklist) {
1674 if (isConvergenceIntrinsic(I))
1677 bool Postpone = insertAssignPtrTypeIntrs(I, B, false);
1679 insertAssignTypeIntrs(I, B);
1680 insertPtrCastOrAssignTypeInstr(I, B);
1681 insertSpirvDecorations(I, B);
1684 if (Postpone && !GR->findAssignPtrTypeInstr(I))
1685 insertAssignPtrTypeIntrs(I, B, true);
1688 for (auto &I : instructions(Func))
1689 deduceOperandElementType(&I);
1691 for (auto *I : Worklist) {
1693 if (!I->getType()->isVoidTy() || isa<StoreInst>(I))
1694 setInsertPointAfterDef(B, I);
1697 I = visit(*I);
1698 if (!I)
1702 if (isConvergenceIntrinsic(I))
1705 processInstrAfterVisit(I, B);
1722 Instruction *I = cast<Instruction>(AssignCI->getArgOperand(0));
1723 for (User *U : I->users()) {
1727 deduceOperandElementType(Inst, I, KnownTy, AssignCI);
1728 if (KnownTy != GR->findDeducedElementType(I)) {