Lines Matching refs:Value
31 typedef llvm::PointerIntPair<llvm::Value*,1,bool> TryEmitResult;
46 llvm::Value *CodeGenFunction::EmitObjCStringLiteral(const ObjCStringLiteral *E)
59 llvm::Value *
74 llvm::Value *Receiver = Runtime.GetClass(*this, ClassDecl);
85 // and cast value to correct type
99 llvm::Value *Cast = Builder.CreateBitCast(GV, ConvertType(EncodingQT));
113 llvm::Value *CodeGenFunction::EmitObjCCollectionLiteral(const Expr *E,
139 SmallVector<llvm::Value *, 16> NeededObjects;
153 llvm::Value *value = EmitScalarExpr(Rhs);
154 EmitStoreThroughLValue(RValue::get(value), LV, true);
156 NeededObjects.push_back(value);
164 llvm::Value *keyValue = EmitScalarExpr(Key);
167 // Emit the value and store it to the appropriate array slot.
168 const Expr *Value = DLE->getKeyValueElement(i).Value;
172 llvm::Value *valueValue = EmitScalarExpr(Value);
194 llvm::Value *Count =
206 llvm::Value *Receiver = Runtime.GetClass(*this, Class);
225 llvm::Value *CodeGenFunction::EmitObjCArrayLiteral(const ObjCArrayLiteral *E) {
229 llvm::Value *CodeGenFunction::EmitObjCDictionaryLiteral(
235 llvm::Value *CodeGenFunction::EmitObjCSelectorExpr(const ObjCSelectorExpr *E) {
243 llvm::Value *CodeGenFunction::EmitObjCProtocolExpr(const ObjCProtocolExpr *E) {
327 /// immediately loaded from an ARC __weak l-value.
357 llvm::Value *result = EmitARCLoadWeakRetained(lvalue.getAddress());
363 // safe because the receiver value is always loaded from 'self',
378 llvm::Value *Receiver = nullptr;
434 // value. We have to do this after emitting the other call
470 // the call back into self. This takes ownership of the value.
474 llvm::Value *newSelf = result.getScalarVal();
499 llvm::Value *self = CGF.LoadObjCSelf();
553 static llvm::Value *emitARCRetainLoadOfScalar(CodeGenFunction &CGF,
568 /// into the return value slot.
592 llvm::Value *fn = CGF.CGM.getObjCRuntime().GetGetStructFunction();
819 // reference, in which case the result will be a gl-value. We should
837 llvm::Value *returnAddr,
848 llvm::Value *ivarAddr =
857 llvm::Value *copyCppAtomicObjectFn =
915 // Store that value into the return address. Doing this with a
926 llvm::Value *getPropertyFn =
936 llvm::Value *cmd =
938 llvm::Value *self = Builder.CreateBitCast(LoadObjCSelf(), VoidPtrTy);
939 llvm::Value *ivarOffset =
993 // The return value slot is guaranteed to not be aliased, but
999 llvm::Value *value;
1001 value = LV.getAddress().getPointer();
1006 value = emitARCRetainLoadOfScalar(*this, LV, ivarType);
1008 value = EmitARCLoadWeak(LV.getAddress());
1014 value = EmitLoadOfLValue(LV, SourceLocation()).getScalarVal();
1018 value = Builder.CreateBitCast(value, ConvertType(propType));
1019 value = Builder.CreateBitCast(
1020 value, ConvertType(GetterMethodDecl->getReturnType()));
1023 EmitReturnOfRValue(RValue::get(value), propType);
1034 /// emitStructSetterCall - Call the runtime function to store the value
1043 llvm::Value *ivarAddr = CGF.EmitLValueForIvar(CGF.TypeOfSelfObject(),
1053 llvm::Value *argAddr = CGF.EmitLValue(&argRef).getPointer();
1058 llvm::Value *size =
1069 llvm::Value *copyStructFn = CGF.CGM.getObjCRuntime().GetSetStructFunction();
1078 /// the value from the first formal parameter into the given ivar, using
1089 llvm::Value *ivarAddr =
1099 llvm::Value *argAddr = CGF.EmitLValue(&argRef).getPointer();
1106 llvm::Value *copyCppAtomicObjectFn =
1191 llvm::Value *load = Builder.CreateLoad(argAddr);
1202 llvm::Value *setOptimizedPropertyFn = nullptr;
1203 llvm::Value *setPropertyFn = nullptr;
1225 llvm::Value *cmd =
1227 llvm::Value *self =
1229 llvm::Value *ivarOffset =
1232 llvm::Value *arg = Builder.CreateLoad(argAddr, "arg");
1344 llvm::Value *addr;
1349 DestroyIvar(llvm::Value *addr, const ObjCIvarDecl *ivar,
1368 llvm::Value *null = getNullForVariable(addr);
1376 llvm::Value *self = CGF.LoadObjCSelf();
1432 llvm::Value *SelfAsId =
1443 llvm::Value *CodeGenFunction::LoadObjCSelf() {
1502 llvm::Value *Collection;
1544 llvm::Value *initialBufferLimit = CountRV.getScalarVal();
1549 llvm::Value *zero = llvm::Constant::getNullValue(UnsignedLongLTy);
1563 // Save the initial mutations value. This is the value at an
1568 llvm::Value *StateMutationsPtr
1571 llvm::Value *initialMutations =
1590 // Check whether the mutations value has changed from where it was
1594 llvm::Value *currentMutations
1606 llvm::Value *V =
1651 llvm::Value *EnumStateItems =
1654 // Fetch the value
1655 llvm::Value *CurrentItemPtr =
1657 llvm::Value *CurrentItem =
1660 // Cast that value to the right type.
1664 // Make sure we have an l-value. Yes, this gets evaluated every
1695 llvm::Value *indexPlusOne
1719 llvm::Value *refetchCount = CountRV.getScalarVal();
1734 llvm::Value *null = llvm::Constant::getNullValue(convertedElementType);
1764 CallObjCRelease(llvm::Value *object) : object(object) {}
1765 llvm::Value *object;
1776 llvm::Value *CodeGenFunction::EmitObjCConsumeObject(QualType type,
1777 llvm::Value *object) {
1784 llvm::Value *CodeGenFunction::EmitObjCExtendObjectLifetime(QualType type,
1785 llvm::Value *value) {
1786 return EmitARCRetainAutorelease(type, value);
1791 void CodeGenFunction::EmitARCIntrinsicUse(ArrayRef<llvm::Value*> values) {
1829 static llvm::Value *emitARCValueOperation(CodeGenFunction &CGF,
1830 llvm::Value *value,
1834 if (isa<llvm::ConstantPointerNull>(value)) return value;
1843 llvm::Type *origType = value->getType();
1844 value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy);
1847 llvm::CallInst *call = CGF.EmitNounwindRuntimeCall(fn, value);
1857 static llvm::Value *emitARCLoadOperation(CodeGenFunction &CGF,
1872 llvm::Value *result = CGF.EmitNounwindRuntimeCall(fn, addr.getPointer());
1883 static llvm::Value *emitARCStoreOperation(CodeGenFunction &CGF,
1885 llvm::Value *value,
1889 assert(addr.getElementType() == value->getType());
1899 llvm::Type *origType = value->getType();
1901 llvm::Value *args[] = {
1903 CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy)
1929 llvm::Value *args[] = {
1937 /// call i8* \@objc_retain(i8* %value)
1938 /// call i8* \@objc_retainBlock(i8* %value)
1939 llvm::Value *CodeGenFunction::EmitARCRetain(QualType type, llvm::Value *value) {
1941 return EmitARCRetainBlock(value, /*mandatory*/ false);
1943 return EmitARCRetainNonBlock(value);
1947 /// call i8* \@objc_retain(i8* %value)
1948 llvm::Value *CodeGenFunction::EmitARCRetainNonBlock(llvm::Value *value) {
1949 return emitARCValueOperation(*this, value,
1955 /// call i8* \@objc_retainBlock(i8* %value)
1960 llvm::Value *CodeGenFunction::EmitARCRetainBlock(llvm::Value *value,
1962 llvm::Value *result
1963 = emitARCValueOperation(*this, value,
1984 /// call i8* \@objc_retainAutoreleasedReturnValue(i8* %value)
1988 llvm::Value *
1989 CodeGenFunction::EmitARCRetainAutoreleasedReturnValue(llvm::Value *value) {
1991 // retain the autoreleased return value.
2029 return emitARCValueOperation(*this, value,
2035 /// call void \@objc_release(i8* %value)
2036 void CodeGenFunction::EmitARCRelease(llvm::Value *value,
2038 if (isa<llvm::ConstantPointerNull>(value)) return;
2048 value = Builder.CreateBitCast(value, Int8PtrTy);
2051 llvm::CallInst *call = EmitNounwindRuntimeCall(fn, value);
2071 llvm::Value *null = getNullForVariable(addr);
2076 llvm::Value *value = Builder.CreateLoad(addr);
2077 EmitARCRelease(value, precise);
2081 /// call void \@objc_storeStrong(i8** %addr, i8* %value)
2082 llvm::Value *CodeGenFunction::EmitARCStoreStrongCall(Address addr,
2083 llvm::Value *value,
2085 assert(addr.getElementType() == value->getType());
2095 llvm::Value *args[] = {
2097 Builder.CreateBitCast(value, Int8PtrTy)
2102 return value;
2106 /// call void \@objc_storeStrong(i8** %addr, i8* %value)
2108 llvm::Value *CodeGenFunction::EmitARCStoreStrong(LValue dst,
2109 llvm::Value *newValue,
2125 // Retain the new value.
2128 // Read the old value.
2129 llvm::Value *oldValue = EmitLoadOfScalar(dst, SourceLocation());
2132 // see the old value.
2135 // Finally, release the old value.
2142 /// call i8* \@objc_autorelease(i8* %value)
2143 llvm::Value *CodeGenFunction::EmitARCAutorelease(llvm::Value *value) {
2144 return emitARCValueOperation(*this, value,
2150 /// call i8* \@objc_autoreleaseReturnValue(i8* %value)
2151 llvm::Value *
2152 CodeGenFunction::EmitARCAutoreleaseReturnValue(llvm::Value *value) {
2153 return emitARCValueOperation(*this, value,
2160 /// call i8* \@objc_retainAutoreleaseReturnValue(i8* %value)
2161 llvm::Value *
2162 CodeGenFunction::EmitARCRetainAutoreleaseReturnValue(llvm::Value *value) {
2163 return emitARCValueOperation(*this, value,
2170 /// call i8* \@objc_retainAutorelease(i8* %value)
2172 /// %retain = call i8* \@objc_retainBlock(i8* %value)
2174 llvm::Value *CodeGenFunction::EmitARCRetainAutorelease(QualType type,
2175 llvm::Value *value) {
2177 return EmitARCRetainAutoreleaseNonBlock(value);
2179 if (isa<llvm::ConstantPointerNull>(value)) return value;
2181 llvm::Type *origType = value->getType();
2182 value = Builder.CreateBitCast(value, Int8PtrTy);
2183 value = EmitARCRetainBlock(value, /*mandatory*/ true);
2184 value = EmitARCAutorelease(value);
2185 return Builder.CreateBitCast(value, origType);
2189 /// call i8* \@objc_retainAutorelease(i8* %value)
2190 llvm::Value *
2191 CodeGenFunction::EmitARCRetainAutoreleaseNonBlock(llvm::Value *value) {
2192 return emitARCValueOperation(*this, value,
2199 llvm::Value *CodeGenFunction::EmitARCLoadWeak(Address addr) {
2206 llvm::Value *CodeGenFunction::EmitARCLoadWeakRetained(Address addr) {
2212 /// i8* \@objc_storeWeak(i8** %addr, i8* %value)
2213 /// Returns %value.
2214 llvm::Value *CodeGenFunction::EmitARCStoreWeak(Address addr,
2215 llvm::Value *value,
2217 return emitARCStoreOperation(*this, addr, value,
2222 /// i8* \@objc_initWeak(i8** %addr, i8* %value)
2223 /// Returns %value. %addr is known to not have a current weak entry.
2225 /// *addr = nil; objc_storeWeak(addr, value);
2226 void CodeGenFunction::EmitARCInitWeak(Address addr, llvm::Value *value) {
2231 if (isa<llvm::ConstantPointerNull>(value) &&
2233 Builder.CreateStore(value, addr);
2237 emitARCStoreOperation(*this, addr, value,
2259 /// Disregards the current value in %dest. Leaves %src pointing to nothing.
2268 /// Disregards the current value in %dest. Essentially
2278 llvm::Value *CodeGenFunction::EmitObjCAutoreleasePoolPush() {
2291 void CodeGenFunction::EmitObjCAutoreleasePoolPop(llvm::Value *value) {
2292 assert(value->getType() == Int8PtrTy);
2305 EmitRuntimeCallOrInvoke(fn, value);
2313 llvm::Value *CodeGenFunction::EmitObjCMRRAutoreleasePoolPush() {
2315 llvm::Value *Receiver = Runtime.EmitNSAutoreleasePoolClassRef(*this);
2338 void CodeGenFunction::EmitObjCMRRAutoreleasePoolPop(llvm::Value *Arg) {
2366 llvm::Value *Token;
2368 CallObjCAutoreleasePoolObject(llvm::Value *token) : Token(token) {}
2375 llvm::Value *Token;
2377 CallObjCMRRAutoreleasePoolObject(llvm::Value *token) : Token(token) {}
2385 void CodeGenFunction::EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr) {
2427 llvm::Value *result = CGF.EmitLoadOfLValue(lv,
2436 // As a very special optimization, in ARC++, if the l-value is the
2449 static llvm::Value *emitARCRetainAfterCall(CodeGenFunction &CGF,
2450 llvm::Value *value);
2454 static llvm::Value *emitARCRetainCall(CodeGenFunction &CGF, const Expr *e) {
2455 llvm::Value *value = CGF.EmitScalarExpr(e);
2456 return emitARCRetainAfterCall(CGF, value);
2459 static llvm::Value *emitARCRetainAfterCall(CodeGenFunction &CGF,
2460 llvm::Value *value) {
2461 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(value)) {
2467 value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
2470 return value;
2471 } else if (llvm::InvokeInst *invoke = dyn_cast<llvm::InvokeInst>(value)) {
2477 value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
2480 return value;
2484 } else if (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(value)) {
2485 llvm::Value *operand = bitcast->getOperand(0);
2494 return CGF.EmitARCRetainNonBlock(value);
2550 // If this semantic expression is an opaque value, bind it
2614 llvm::Value *value = loadResult.getPointer();
2615 value = CGF.Builder.CreateBitCast(value, resultType);
2616 loadResult.setPointer(value);
2637 llvm::Value *result = CGF.EmitScalarExpr(ce->getSubExpr());
2644 // value is copied as a block, so there's a little filter here.
2646 llvm::Value *result; // will be a +0 value
2649 // block-copied value, emit the sub-expression at +0.
2659 // If that produced a retained value, just use that,
2679 llvm::Value *result = emitARCRetainCall(CGF, ce->getSubExpr());
2702 llvm::Value *result = emitARCRetainCall(CGF, e);
2711 llvm::Value *value = result.getPointer();
2712 value = CGF.Builder.CreateBitCast(value, resultType);
2713 result.setPointer(value);
2724 llvm::Value *result = CGF.EmitScalarExpr(e);
2729 static llvm::Value *emitARCRetainLoadOfScalar(CodeGenFunction &CGF,
2733 llvm::Value *value = result.getPointer();
2735 value = CGF.EmitARCRetain(type, value);
2736 return value;
2743 llvm::Value *CodeGenFunction::EmitARCRetainScalarExpr(const Expr *e) {
2752 llvm::Value *value = result.getPointer();
2754 value = EmitARCRetain(e->getType(), value);
2755 return value;
2758 llvm::Value *
2768 llvm::Value *value = result.getPointer();
2770 value = EmitARCAutorelease(value);
2772 value = EmitARCRetainAutorelease(e->getType(), value);
2773 return value;
2776 llvm::Value *CodeGenFunction::EmitARCExtendBlockObject(const Expr *e) {
2777 llvm::Value *result;
2794 llvm::Value *CodeGenFunction::EmitObjCThrowOperand(const Expr *expr) {
2810 std::pair<LValue,llvm::Value*>
2815 llvm::Value *value = result.getPointer();
2819 // If we didn't emit a retained object, and the l-value is of block
2821 // it invalidates the l-value.
2823 value = EmitARCRetainBlock(value, /*mandatory*/ false);
2831 llvm::Value *oldValue = EmitLoadOfScalar(lvalue, SourceLocation());
2832 EmitStoreOfScalar(value, lvalue);
2835 value = EmitARCStoreStrong(lvalue, value, ignored);
2838 return std::pair<LValue,llvm::Value*>(lvalue, value);
2841 std::pair<LValue,llvm::Value*>
2843 llvm::Value *value = EmitARCRetainAutoreleaseScalarExpr(e->getRHS());
2846 EmitStoreOfScalar(value, lvalue);
2848 return std::pair<LValue,llvm::Value*>(lvalue, value);
2863 llvm::Value *token = EmitObjCAutoreleasePoolPush();
2866 llvm::Value *token = EmitObjCMRRAutoreleasePoolPush();
2879 void CodeGenFunction::EmitExtendGCLifetime(llvm::Value *object) {
2883 llvm::Value *extender
3077 llvm::Value *
3078 CodeGenFunction::EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty) {
3089 llvm::Value *Val = Block;
