Lines Matching refs:Value
63 explicit AllocaInst(Type *Ty, Value *ArraySize = nullptr,
66 AllocaInst(Type *Ty, Value *ArraySize,
72 AllocaInst(Type *Ty, Value *ArraySize, unsigned Align,
74 AllocaInst(Type *Ty, Value *ArraySize, unsigned Align,
88 const Value *getArraySize() const { return getOperand(0); }
89 Value *getArraySize() { return getOperand(0); }
133 static inline bool classof(const Value *V) {
150 /// SubclassData field in Value to store whether or not the load is volatile.
157 LoadInst(Value *Ptr, const Twine &NameStr, Instruction *InsertBefore);
158 LoadInst(Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
159 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile = false,
161 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
163 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
165 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
167 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
171 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
176 LoadInst(Value *Ptr, const char *NameStr, Instruction *InsertBefore);
177 LoadInst(Value *Ptr, const char *NameStr, BasicBlock *InsertAtEnd);
178 explicit LoadInst(Value *Ptr, const char *NameStr = nullptr,
181 LoadInst(Value *Ptr, const char *NameStr, bool isVolatile,
240 Value *getPointerOperand() { return getOperand(0); }
241 const Value *getPointerOperand() const { return getOperand(0); }
254 static inline bool classof(const Value *V) {
282 StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
283 StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
284 StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
286 StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
287 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
289 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
291 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
295 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
314 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
360 Value *getValueOperand() { return getOperand(0); }
361 const Value *getValueOperand() const { return getOperand(0); }
363 Value *getPointerOperand() { return getOperand(1); }
364 const Value *getPointerOperand() const { return getOperand(1); }
376 static inline bool classof(const Value *V) {
391 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)
447 static inline bool classof(const Value *V) {
468 void Init(Value *Ptr, Value *Cmp, Value *NewVal,
478 AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
483 AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
514 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
555 Value *getPointerOperand() { return getOperand(0); }
556 const Value *getPointerOperand() const { return getOperand(0); }
559 Value *getCompareOperand() { return getOperand(1); }
560 const Value *getCompareOperand() const { return getOperand(1); }
562 Value *getNewValOperand() { return getOperand(2); }
563 const Value *getNewValOperand() const { return getOperand(2); }
596 static inline bool classof(const Value *V) {
612 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicCmpXchgInst, Value)
664 AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
667 AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
695 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
724 Value *getPointerOperand() { return getOperand(0); }
725 const Value *getPointerOperand() const { return getOperand(0); }
728 Value *getValOperand() { return getOperand(1); }
729 const Value *getValOperand() const { return getOperand(1); }
740 static inline bool classof(const Value *V) {
744 void Init(BinOp Operation, Value *Ptr, Value *Val,
758 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicRMWInst, Value)
777 void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
783 inline GetElementPtrInst(Value *Ptr, ArrayRef<Value *> IdxList,
786 inline GetElementPtrInst(Value *Ptr, ArrayRef<Value *> IdxList,
792 static GetElementPtrInst *Create(Value *Ptr, ArrayRef<Value *> IdxList,
799 static GetElementPtrInst *Create(Value *Ptr, ArrayRef<Value *> IdxList,
809 static GetElementPtrInst *CreateInBounds(Value *Ptr,
810 ArrayRef<Value *> IdxList,
817 static GetElementPtrInst *CreateInBounds(Value *Ptr,
818 ArrayRef<Value *> IdxList,
827 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
847 static Type *getIndexedType(Type *Ptr, ArrayRef<Value *> IdxList);
856 Value *getPointerOperand() {
859 const Value *getPointerOperand() const {
879 static Type *getGEPReturnType(Value *Ptr, ArrayRef<Value *> IdxList) {
932 static inline bool classof(const Value *V) {
942 GetElementPtrInst::GetElementPtrInst(Value *Ptr,
943 ArrayRef<Value *> IdxList,
953 GetElementPtrInst::GetElementPtrInst(Value *Ptr,
954 ArrayRef<Value *> IdxList,
966 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)
998 Value *LHS, ///< The left-hand-side of the expression
999 Value *RHS, ///< The right-hand-side of the expression
1013 Value *LHS, ///< The left-hand-side of the expression
1014 Value *RHS, ///< The right-hand-side of the expression
1027 Value *LHS, ///< The left-hand-side of the expression
1028 Value *RHS, ///< The right-hand-side of the expression
1107 static inline bool classof(const Value *V) {
1130 Value *LHS, ///< The left-hand-side of the expression
1131 Value *RHS, ///< The right-hand-side of the expression
1149 Value *LHS, ///< The left-hand-side of the expression
1150 Value *RHS, ///< The right-hand-side of the expression
1167 Value *LHS, ///< The left-hand-side of the expression
1168 Value *RHS, ///< The right-hand-side of the expression
1216 static inline bool classof(const Value *V) {
1230 void init(Value *Func, ArrayRef<Value *> Args, const Twine &NameStr);
1231 void init(Value *Func, const Twine &NameStr);
1235 inline CallInst(Value *Func, ArrayRef<Value *> Args,
1240 inline CallInst(Value *Func, ArrayRef<Value *> Args,
1243 explicit CallInst(Value *F, const Twine &NameStr,
1245 CallInst(Value *F, const Twine &NameStr, BasicBlock *InsertAtEnd);
1249 static CallInst *Create(Value *Func,
1250 ArrayRef<Value *> Args,
1256 static CallInst *Create(Value *Func,
1257 ArrayRef<Value *> Args,
1262 static CallInst *Create(Value *F, const Twine &NameStr = "",
1266 static CallInst *Create(Value *F, const Twine &NameStr,
1278 Value *AllocSize, Value *ArraySize = nullptr,
1283 Value *AllocSize, Value *ArraySize = nullptr,
1287 static Instruction* CreateFree(Value* Source, Instruction *InsertBefore);
1288 static Instruction* CreateFree(Value* Source, BasicBlock *InsertAtEnd);
1313 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1321 Value *getArgOperand(unsigned i) const { return getOperand(i); }
1322 void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
1455 const Value *getCalledValue() const { return Op<-1>(); }
1456 Value *getCalledValue() { return Op<-1>(); }
1459 void setCalledFunction(Value* Fn) {
1472 static inline bool classof(const Value *V) {
1490 CallInst::CallInst(Value *Func, ArrayRef<Value *> Args,
1500 CallInst::CallInst(Value *Func, ArrayRef<Value *> Args,
1514 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallInst, Value)
1523 void init(Value *C, Value *S1, Value *S2) {
1530 SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1537 SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1547 static SelectInst *Create(Value *C, Value *S1, Value *S2,
1552 static SelectInst *Create(Value *C, Value *S1, Value *S2,
1558 const Value *getCondition() const { return Op<0>(); }
1559 const Value *getTrueValue() const { return Op<1>(); }
1560 const Value *getFalseValue() const { return Op<2>(); }
1561 Value *getCondition() { return Op<0>(); }
1562 Value *getTrueValue() { return Op<1>(); }
1563 Value *getFalseValue() { return Op<2>(); }
1567 static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);
1570 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1580 static inline bool classof(const Value *V) {
1589 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectInst, Value)
1603 VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
1608 VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
1614 Value *getPointerOperand() { return getOperand(0); }
1615 const Value *getPointerOperand() const { return getOperand(0); }
1622 static inline bool classof(const Value *V) {
1635 ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
1637 ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
1643 static ExtractElementInst *Create(Value *Vec, Value *Idx,
1648 static ExtractElementInst *Create(Value *Vec, Value *Idx,
1656 static bool isValidOperands(const Value *Vec, const Value *Idx);
1658 Value *getVectorOperand() { return Op<0>(); }
1659 Value *getIndexOperand() { return Op<1>(); }
1660 const Value *getVectorOperand() const { return Op<0>(); }
1661 const Value *getIndexOperand() const { return Op<1>(); }
1669 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1675 static inline bool classof(const Value *V) {
1685 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)
1695 InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
1698 InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
1704 static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1709 static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1717 static bool isValidOperands(const Value *Vec, const Value *NewElt,
1718 const Value *Idx);
1727 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1733 static inline bool classof(const Value *V) {
1743 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)
1761 ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
1764 ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
1769 static bool isValidOperands(const Value *V1, const Value *V2,
1770 const Value *Mask);
1779 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1813 static inline bool classof(const Value *V) {
1823 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
1842 inline ExtractValueInst(Value *Agg,
1846 inline ExtractValueInst(Value *Agg,
1858 static ExtractValueInst *Create(Value *Agg,
1865 static ExtractValueInst *Create(Value *Agg,
1882 Value *getAggregateOperand() {
1885 const Value *getAggregateOperand() const {
1908 static inline bool classof(const Value *V) {
1913 ExtractValueInst::ExtractValueInst(Value *Agg,
1921 ExtractValueInst::ExtractValueInst(Value *Agg,
1943 void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
1950 inline InsertValueInst(Value *Agg, Value *Val,
1954 inline InsertValueInst(Value *Agg, Value *Val,
1960 InsertValueInst(Value *Agg, Value *Val,
1963 InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
1973 static InsertValueInst *Create(Value *Agg, Value *Val,
1979 static InsertValueInst *Create(Value *Agg, Value *Val,
1987 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1993 Value *getAggregateOperand() {
1996 const Value *getAggregateOperand() const {
2003 Value *getInsertedValueOperand() {
2006 const Value *getInsertedValueOperand() const {
2029 static inline bool classof(const Value *V) {
2039 InsertValueInst::InsertValueInst(Value *Agg,
2040 Value *Val,
2049 InsertValueInst::InsertValueInst(Value *Agg,
2050 Value *Val,
2060 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)
2118 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2152 Value *getIncomingValue(unsigned i) const {
2155 void setIncomingValue(unsigned i, Value *V) {
2182 BasicBlock *getIncomingBlock(Value::const_user_iterator I) const {
2192 void addIncoming(Value *V, BasicBlock *BB) {
2213 Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);
2215 Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
2231 Value *getIncomingValueForBlock(const BasicBlock *BB) const {
2239 Value *hasConstantValue() const;
2245 static inline bool classof(const Value *V) {
2256 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PHINode, Value)
2267 /// SubclassData field in Value to store whether or not the landingpad is a
2284 void init(Value *PersFn, unsigned NumReservedValues, const Twine &NameStr);
2286 explicit LandingPadInst(Type *RetTy, Value *PersonalityFn,
2289 explicit LandingPadInst(Type *RetTy, Value *PersonalityFn,
2297 static LandingPadInst *Create(Type *RetTy, Value *PersonalityFn,
2301 static LandingPadInst *Create(Type *RetTy, Value *PersonalityFn,
2307 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2311 Value *getPersonalityFn() const { return getOperand(0); }
2354 static inline bool classof(const Value *V) {
2363 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(LandingPadInst, Value)
2380 // ReturnInst(Value* X) - 'ret X' instruction
2382 // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I
2384 // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of B
2386 // NOTE: If the Value* passed is of type void then the constructor behaves as
2388 explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
2390 ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
2395 static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
2399 static ReturnInst* Create(LLVMContext &C, Value *retVal,
2409 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2412 Value *getReturnValue() const {
2422 static inline bool classof(const Value *V) {
2435 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ReturnInst, Value)
2453 // BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F'
2455 // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
2457 // BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end
2459 BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
2462 BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
2472 Value *Cond, Instruction *InsertBefore = nullptr) {
2479 Value *Cond, BasicBlock *InsertAtEnd) {
2484 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2489 Value *getCondition() const {
2494 void setCondition(Value *V) {
2508 *(&Op<-1>() - idx) = (Value*)NewSucc;
2522 static inline bool classof(const Value *V) {
2535 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst, Value)
2547 // Operand[0] = Value to switch on
2549 // Operand[2n ] = Value to match
2552 void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
2562 SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
2569 SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
2684 SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
2693 static SwitchInst *Create(Value *Value, BasicBlock *Default,
2696 return new SwitchInst(Value, Default, NumCases, InsertBefore);
2698 static SwitchInst *Create(Value *Value, BasicBlock *Default,
2700 return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
2706 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2709 Value *getCondition() const { return getOperand(0); }
2710 void setCondition(Value *V) { setOperand(0, V); }
2717 setOperand(1, reinterpret_cast<Value*>(DefaultCase));
2823 setOperand(idx*2+1, (Value*)NewSucc);
2830 static inline bool classof(const Value *V) {
2843 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst, Value)
2856 // Operand[0] = Value to switch on
2858 // Operand[2n ] = Value to match
2861 void init(Value *Address, unsigned NumDests);
2871 IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);
2877 IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
2881 static IndirectBrInst *Create(Value *Address, unsigned NumDests,
2885 static IndirectBrInst *Create(Value *Address, unsigned NumDests,
2892 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2895 Value *getAddress() { return getOperand(0); }
2896 const Value *getAddress() const { return getOperand(0); }
2897 void setAddress(Value *V) { setOperand(0, V); }
2921 setOperand(i+1, (Value*)NewSucc);
2928 static inline bool classof(const Value *V) {
2941 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst, Value)
2954 void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2955 ArrayRef<Value *> Args, const Twine &NameStr);
2960 inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2961 ArrayRef<Value *> Args, unsigned Values,
2967 inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
2968 ArrayRef<Value *> Args, unsigned Values,
2973 static InvokeInst *Create(Value *Func,
2975 ArrayRef<Value *> Args, const Twine &NameStr = "",
2981 static InvokeInst *Create(Value *Func,
2983 ArrayRef<Value *> Args, const Twine &NameStr,
2991 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2999 Value *getArgOperand(unsigned i) const { return getOperand(i); }
3000 void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
3124 const Value *getCalledValue() const { return Op<-3>(); }
3125 Value *getCalledValue() { return Op<-3>(); }
3128 void setCalledFunction(Value* Fn) {
3140 Op<-2>() = reinterpret_cast<Value*>(B);
3143 Op<-1>() = reinterpret_cast<Value*>(B);
3157 *(&Op<-2>() + idx) = reinterpret_cast<Value*>(NewSucc);
3166 static inline bool classof(const Value *V) {
3188 InvokeInst::InvokeInst(Value *Func,
3190 ArrayRef<Value *> Args, unsigned Values,
3199 InvokeInst::InvokeInst(Value *Func,
3201 ArrayRef<Value *> Args, unsigned Values,
3211 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InvokeInst, Value)
3223 explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
3224 ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
3228 static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
3231 static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
3236 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
3239 Value *getValue() const { return Op<0>(); }
3247 static inline bool classof(const Value *V) {
3261 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
3291 static inline bool classof(const Value *V) {
3313 Value *S, ///< The value to be truncated
3321 Value *S, ///< The value to be truncated
3331 static inline bool classof(const Value *V) {
3349 Value *S, ///< The value to be zero extended
3357 Value *S, ///< The value to be zero extended
3367 static inline bool classof(const Value *V) {
3385 Value *S, ///< The value to be sign extended
3393 Value *S, ///< The value to be sign extended
3403 static inline bool classof(const Value *V) {
3421 Value *S, ///< The value to be truncated
3429 Value *S, ///< The value to be truncated
3439 static inline bool classof(const Value *V) {
3457 Value *S, ///< The value to be extended
3465 Value *S, ///< The value to be extended
3475 static inline bool classof(const Value *V) {
3493 Value *S, ///< The value to be converted
3501 Value *S, ///< The value to be converted
3511 static inline bool classof(const Value *V) {
3529 Value *S, ///< The value to be converted
3537 Value *S, ///< The value to be converted
3547 static inline bool classof(const Value *V) {
3565 Value *S, ///< The value to be converted
3573 Value *S, ///< The value to be converted
3583 static inline bool classof(const Value *V) {
3601 Value *S, ///< The value to be converted
3609 Value *S, ///< The value to be converted
3619 static inline bool classof(const Value *V) {
3633 Value *S, ///< The value to be converted
3641 Value *S, ///< The value to be converted
3659 static inline bool classof(const Value *V) {
3677 Value *S, ///< The value to be converted
3685 Value *S, ///< The value to be converted
3692 Value *getPointerOperand() { return getOperand(0); }
3694 const Value *getPointerOperand() const { return getOperand(0); }
3707 static inline bool classof(const Value *V) {
3725 Value *S, ///< The value to be casted
3733 Value *S, ///< The value to be casted
3743 static inline bool classof(const Value *V) {
3762 Value *S, ///< The value to be casted
3770 Value *S, ///< The value to be casted
3780 static inline bool classof(const Value *V) {