Lines Matching defs:Op
85 void insertTodoType(Value *Op) {
86 // TODO: add isa<CallInst>(Op) to no-insert
87 if (CanTodoType && !isa<GetElementPtrInst>(Op)) {
88 auto It = TodoType.try_emplace(Op, true);
93 void eraseTodoType(Value *Op) {
94 auto It = TodoType.find(Op);
96 TodoType[Op] = false;
100 bool isTodoType(Value *Op) {
101 if (isa<GetElementPtrInst>(Op))
103 auto It = TodoType.find(Op);
124 Type *deduceElementTypeByUsersDeep(Value *Op,
156 Type *reconstructType(Value *Op, bool UnknownElemTypeI8,
192 Type *&KnownElemTy, Value *Op, Function *F);
194 CallInst *buildSpvPtrcast(Function *F, Value *Op, Type *ElemTy);
195 void replaceUsesOfWithSpvPtrcast(Value *Op, Type *ElemTy, Instruction *I,
197 void propagateElemType(Value *Op, Type *ElemTy,
200 propagateElemTypeRec(Value *Op, Type *PtrElemTy, Type *CastElemTy,
202 void propagateElemTypeRec(Value *Op, Type *PtrElemTy, Type *CastElemTy,
403 Type *SPIRVEmitIntrinsics::reconstructType(Value *Op, bool UnknownElemTypeI8,
405 Type *Ty = Op->getType();
406 if (auto *OpI = dyn_cast<Instruction>(Op))
411 if (Type *NestedTy = GR->findDeducedElementType(Op))
414 CallInst *CI = GR->findAssignPtrTypeInstr(Op);
421 insertTodoType(Op);
422 return getTypedPointerWrapper(IntegerType::getInt8Ty(Op->getContext()),
478 CallInst *SPIRVEmitIntrinsics::buildSpvPtrcast(Function *F, Value *Op,
480 IRBuilder<> B(Op->getContext());
481 if (auto *OpI = dyn_cast<Instruction>(Op)) {
482 // spv_ptrcast's argument Op denotes an instruction that generates
485 } else if (auto *OpA = dyn_cast<Argument>(Op)) {
491 Type *OpTy = Op->getType();
493 SmallVector<Value *, 2> Args = {Op, buildMD(PoisonValue::get(ElemTy)),
502 Value *Op, Type *ElemTy, Instruction *I,
508 PtrCastedI = buildSpvPtrcast(F, Op, ElemTy);
513 I->replaceUsesOfWith(Op, PtrCastedI);
517 Value *Op, Type *ElemTy,
520 SmallVector<User *> Users(Op->users());
524 if (!VisitedSubst.insert(std::make_pair(U, Op)).second)
528 // keeping current Op type.
531 replaceUsesOfWithSpvPtrcast(Op, ElemTy, UI, Ptrcasts);
536 Value *Op, Type *PtrElemTy, Type *CastElemTy,
540 propagateElemTypeRec(Op, PtrElemTy, CastElemTy, VisitedSubst, Visited,
545 Value *Op, Type *PtrElemTy, Type *CastElemTy,
549 if (!Visited.insert(Op).second)
551 SmallVector<User *> Users(Op->users());
555 if (!VisitedSubst.insert(std::make_pair(U, Op)).second)
559 // keeping current Op type.
562 replaceUsesOfWithSpvPtrcast(Op, CastElemTy, UI, Ptrcasts);
596 Value *Op, std::unordered_set<Value *> &Visited, bool UnknownElemTypeI8) {
597 if (!Op || !isPointerTy(Op->getType()) || isa<ConstantPointerNull>(Op) ||
598 isa<UndefValue>(Op))
601 if (auto ElemTy = getPointeeType(Op->getType()))
605 if (Type *KnownTy = GR->findDeducedElementType(Op))
608 for (User *OpU : Op->users()) {
638 void SPIRVEmitIntrinsics::maybeAssignPtrType(Type *&Ty, Value *Op, Type *RefTy,
643 insertTodoType(Op);
680 Value *Op = Ref->getPointerOperand();
681 Type *KnownTy = GR->findDeducedElementType(Op);
683 KnownTy = Op->getType();
701 Value *Op = Ref->getNewValOperand();
702 if (isPointerTy(Op->getType()))
703 Ty = deduceElementTypeHelper(Op, Visited, UnknownElemTypeI8);
705 Value *Op = Ref->getValOperand();
706 if (isPointerTy(Op->getType()))
707 Ty = deduceElementTypeHelper(Op, Visited, UnknownElemTypeI8);
729 for (Value *Op : {Ref->getTrueValue(), Ref->getFalseValue()}) {
730 Ty = deduceElementTypeByUsersDeep(Op, Visited, UnknownElemTypeI8);
802 Value *Op = U->getOperand(i);
803 Type *OpTy = Op->getType();
805 if (Op) {
808 deduceElementTypeHelper(Op, Visited, UnknownElemTypeI8))
811 Ty = deduceNestedTypeHelper(dyn_cast<User>(Op), OpTy, Visited,
824 if (Value *Op = U->getNumOperands() > 0 ? U->getOperand(0) : nullptr) {
829 deduceElementTypeHelper(Op, Visited, UnknownElemTypeI8))
832 Ty = deduceNestedTypeHelper(dyn_cast<User>(Op), OpTy, Visited,
842 if (Value *Op = U->getNumOperands() > 0 ? U->getOperand(0) : nullptr) {
847 deduceElementTypeHelper(Op, Visited, UnknownElemTypeI8))
850 Ty = deduceNestedTypeHelper(dyn_cast<User>(Op), OpTy, Visited,
903 Value *Op = CI->getArgOperand(i);
904 if (!isPointerTy(Op->getType()))
907 if (Type *ElemTy = GR->findDeducedElementType(Op))
909 Ops.push_back(std::make_pair(Op, i));
914 Value *Op = CI->getArgOperand(0);
915 if (!isPointerTy(Op->getType()))
931 KnownElemTy = getAtomicElemTy(GR, CI, Op);
934 Ops.push_back(std::make_pair(Op, 0));
946 Value *Op = CI->getCalledOperand();
947 if (!Op || !isPointerTy(Op->getType()))
949 Ops.push_back(std::make_pair(Op, std::numeric_limits<unsigned>::max()));
980 insertTodoType(Op);
988 Type *&KnownElemTy, Value *Op, Function *F) {
992 if (Type *OpElemTy = GR->findDeducedElementType(Op)) {
998 DenseSet<std::pair<Value *, Value *>> VisitedSubst{std::make_pair(I, Op)};
1043 Value *Op = Ref->getIncomingValue(i);
1044 if (isPointerTy(Op->getType()))
1045 Ops.push_back(std::make_pair(Op, i));
1103 Value *Op = Ref->getOperand(i);
1104 if (isPointerTy(Op->getType()))
1105 Ops.push_back(std::make_pair(Op, i));
1110 Value *Op = Ref->getReturnValue();
1111 if (!Op)
1114 IsPostprocessing, KnownElemTy, Op,
1118 Ops.push_back(std::make_pair(Op, 0));
1150 Value *Op = OpIt.first;
1151 if (Op->use_empty())
1153 if (AskOps && !AskOps->contains(Op))
1158 AskTy = GR->findDeducedElementType(Op);
1159 AskCI = GR->findAssignPtrTypeInstr(Op);
1162 Type *Ty = AskTy ? AskTy : GR->findDeducedElementType(Op);
1166 Type *OpTy = Op->getType();
1167 if (!Ty || AskTy || isUntypedPointerTy(Ty) || isTodoType(Op)) {
1168 Type *PrevElemTy = GR->findDeducedElementType(Op);
1169 GR->addDeducedElementType(Op, KnownElemTy);
1172 eraseTodoType(Op);
1174 insertTodoType(Op);
1176 CallInst *AssignCI = AskCI ? AskCI : GR->findAssignPtrTypeInstr(Op);
1178 Instruction *User = dyn_cast<Instruction>(Op->use_begin()->get());
1181 buildIntrWithMD(Intrinsic::spv_assign_ptr_type, {OpTy}, OpTyVal, Op,
1183 GR->addAssignPtrTypeInstr(Op, CI);
1185 updateAssignType(AssignCI, Op, OpTyVal);
1187 std::make_pair(I, Op)};
1188 propagateElemTypeRec(Op, KnownElemTy, PrevElemTy, VisitedSubst);
1191 eraseTodoType(Op);
1193 buildSpvPtrcast(I->getParent()->getParent(), Op, KnownElemTy);
1235 for (auto &Op : I->operands()) {
1236 auto *AggrUndef = dyn_cast<UndefValue>(Op);
1237 if (!AggrUndef || !Op->getType()->isAggregateType())
1246 I->replaceUsesOfWith(Op, IntrUndef);
1263 for (const auto &Op : I->operands()) {
1266 if (auto *COp = dyn_cast<ConstantVector>(Op)) {
1269 } else if (auto *COp = dyn_cast<ConstantArray>(Op)) {
1272 } else if (auto *COp = dyn_cast<ConstantStruct>(Op)) {
1275 } else if (auto *COp = dyn_cast<ConstantDataArray>(Op)) {
1278 } else if (auto *COp = dyn_cast<ConstantAggregateZero>(Op)) {
1280 ResTy = Op->getType()->isVectorTy() ? COp->getType() : B.getInt32Ty();
1284 if (auto *COp = dyn_cast<ConstantDataSequential>(Op))
1298 I->replaceUsesOfWith(Op, CI);
1401 for (auto &Op : I.operands()) {
1402 if (Op.get()->getType()->isSized()) {
1403 Args.push_back(Op);
1404 } else if (BasicBlock *BB = dyn_cast<BasicBlock>(Op.get())) {
1434 for (auto &Op : I.operands())
1435 Args.push_back(Op);
1593 Value *Op = SI->getValueOperand();
1595 Type *OpTy = Op->getType();
1596 if (auto *OpI = dyn_cast<Instruction>(Op))
1598 if (OpTy == Op->getType())
1599 OpTy = deduceElementTypeByValueDeep(OpTy, Op, false);
1735 for (auto &Op : I.operands())
1736 if (isa<UndefValue>(Op))
1739 Args.push_back(Op);
1740 for (auto &Op : I.indices())
1741 Args.push_back(B.getInt32(Op));
1754 for (auto &Op : I.operands())
1755 Args.push_back(Op);
1756 for (auto &Op : I.indices())
1757 Args.push_back(B.getInt32(Op));
1831 for (auto &Op : I.operands())
1832 Args.push_back(Op);
1967 for (const auto &Op : I->operands()) {
1968 if (isa<ConstantPointerNull>(Op) || isa<UndefValue>(Op) ||
1970 (isa<ConstantExpr>(Op) && isa<GEPOperator>(Op))) {
1972 Type *OpTy = Op->getType();
1973 if (isa<UndefValue>(Op) && OpTy->isAggregateType()) {
1975 buildIntrWithMD(Intrinsic::spv_assign_type, {B.getInt32Ty()}, Op,
1977 GR->addAssignPtrTypeInstr(Op, AssignCI);
1978 } else if (!isa<Instruction>(Op)) {
1979 Type *OpTy = Op->getType();
1982 buildAssignPtr(B, OpTyElem, Op);
1984 Type *ElemTy = GR->findDeducedElementType(Op);
1985 buildAssignPtr(B, ElemTy ? ElemTy : deduceElementType(Op, true), Op);
1988 {OpTy}, Op, Op, {}, B);
1989 GR->addAssignPtrTypeInstr(Op, AssignCI);
2021 for (const auto &Op : I->operands()) {
2024 if ((isa<ConstantData>(Op) || isa<ConstantExpr>(Op)) && TrackConstants) {
2025 unsigned OpNo = Op.getOperandNo();
2034 Type *OpTy = Op->getType();
2035 Value *OpTyVal = Op;
2040 {OpTy, OpTyVal->getType()}, Op, OpTyVal, {}, B);
2043 (OpElemTy = GR->findDeducedElementType(Op)) != nullptr &&
2416 for (auto [Op, Enabled] : TodoType) {
2417 // TODO: add isa<CallInst>(Op) to continue
2418 if (!Enabled || isa<GetElementPtrInst>(Op))
2420 CallInst *AssignCI = GR->findAssignPtrTypeInstr(Op);
2421 Type *KnownTy = GR->findDeducedElementType(Op);
2424 assert(Op == AssignCI->getArgOperand(0));
2426 if (auto *CI = dyn_cast<Instruction>(Op)) {
2429 if (Type *ElemTy = deduceElementTypeHelper(Op, Visited, false, true)) {
2433 eraseTodoType(Op);
2438 for (User *U : Op->users()) {
2441 ToProcess[Inst].insert(Op);