|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
tools/clang/lib/CodeGen/CGCUDARuntime.h 36 class RValue;
References
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
45 ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
46 const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
66 using mapped_type = ValueT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
219 InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
299 ValueT &operator[](const KeyT &Key) {
311 ValueT &operator[](KeyT &&Key) {
380 ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
516 ValueArgs &&... Values) {
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
526 ValueT &&Value, LookupKeyT &Lookup) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
include/llvm/ADT/STLExtras.h 108 Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
108 Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
112 static Ret callback_fn(intptr_t callable, Params ...params) {
112 static Ret callback_fn(intptr_t callable, Params ...params) {
114 std::forward<Params>(params)...);
122 function_ref(Callable &&callable,
129 Ret operator()(Params ...params) const {
129 Ret operator()(Params ...params) const {
130 return callback(callable, std::forward<Params>(params)...);
tools/clang/lib/CodeGen/CGAtomic.cpp 185 RValue convertAtomicTempToRValue(Address addr, AggValueSlot resultSlot,
189 llvm::Value *convertRValueToInt(RValue RVal) const;
191 RValue ConvertIntToValueOrAtomic(llvm::Value *IntVal,
196 void emitCopyIntoMemory(RValue rvalue) const;
211 RValue EmitAtomicLoad(AggValueSlot ResultSlot, SourceLocation Loc,
223 std::pair<RValue, llvm::Value *>
224 EmitAtomicCompareExchange(RValue Expected, RValue Desired,
224 EmitAtomicCompareExchange(RValue Expected, RValue Desired,
235 const llvm::function_ref<RValue(RValue)> &UpdateOp,
235 const llvm::function_ref<RValue(RValue)> &UpdateOp,
239 void EmitAtomicUpdate(llvm::AtomicOrdering AO, RValue UpdateRVal,
243 Address materializeRValue(RValue rvalue) const;
274 const llvm::function_ref<RValue(RValue)> &UpdateOp,
274 const llvm::function_ref<RValue(RValue)> &UpdateOp,
278 const llvm::function_ref<RValue(RValue)> &UpdateOp,
278 const llvm::function_ref<RValue(RValue)> &UpdateOp,
281 void EmitAtomicUpdateLibcall(llvm::AtomicOrdering AO, RValue UpdateRVal,
284 void EmitAtomicUpdateOp(llvm::AtomicOrdering AO, RValue UpdateRal,
302 static RValue emitAtomicLibcall(CodeGenFunction &CGF,
738 Args.add(RValue::get(Val), ValTy);
741 Args.add(RValue::get(CGF.EmitCastToVoidPtr(Val)),
746 RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
762 return RValue::get(nullptr);
964 Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)),
984 Args.add(RValue::get(CastToGenericAddrSpace(
1016 RValue::get(CastToGenericAddrSpace(
1021 Args.add(RValue::get(Order), getContext().IntTy);
1161 Args.add(RValue::get(EmitCastToVoidPtr(Dest.getPointer())),
1166 Args.add(RValue::get(Order),
1169 Args.add(RValue::get(Scope), getContext().IntTy);
1176 RValue Res = emitAtomicLibcall(*this, LibCallName, RetTy, Args);
1198 return RValue::get(nullptr);
1249 return RValue::get(nullptr);
1321 return RValue::get(nullptr);
1351 RValue AtomicInfo::convertAtomicTempToRValue(Address addr,
1369 return RValue::get(CGF.Builder.CreateLoad(addr));
1384 RValue AtomicInfo::ConvertIntToValueOrAtomic(llvm::Value *IntVal,
1400 return RValue::get(CGF.EmitFromMemory(IntVal, ValueTy));
1402 return RValue::get(CGF.Builder.CreateIntToPtr(IntVal, ValTy));
1404 return RValue::get(CGF.Builder.CreateBitCast(IntVal, ValTy));
1431 Args.add(RValue::get(getAtomicSizeValue()), CGF.getContext().getSizeType());
1432 Args.add(RValue::get(CGF.EmitCastToVoidPtr(getAtomicPointer())),
1434 Args.add(RValue::get(CGF.EmitCastToVoidPtr(AddForLoaded)),
1437 RValue::get(llvm::ConstantInt::get(CGF.IntTy, (int)llvm::toCABI(AO))),
1472 RValue CodeGenFunction::EmitAtomicLoad(LValue LV, SourceLocation SL,
1485 RValue AtomicInfo::EmitAtomicLoad(AggValueSlot ResultSlot, SourceLocation Loc,
1509 return RValue::getAggregate(Address::invalid(), false);
1518 RValue CodeGenFunction::EmitAtomicLoad(LValue src, SourceLocation loc,
1528 void AtomicInfo::emitCopyIntoMemory(RValue rvalue) const {
1563 Address AtomicInfo::materializeRValue(RValue rvalue) const {
1576 llvm::Value *AtomicInfo::convertRValueToInt(RValue RVal) const {
1628 Args.add(RValue::get(getAtomicSizeValue()), CGF.getContext().getSizeType());
1629 Args.add(RValue::get(CGF.EmitCastToVoidPtr(getAtomicPointer())),
1631 Args.add(RValue::get(CGF.EmitCastToVoidPtr(ExpectedAddr)),
1633 Args.add(RValue::get(CGF.EmitCastToVoidPtr(DesiredAddr)),
1635 Args.add(RValue::get(
1638 Args.add(RValue::get(
1641 auto SuccessFailureRVal = emitAtomicLibcall(CGF, "__atomic_compare_exchange",
1647 std::pair<RValue, llvm::Value *> AtomicInfo::EmitAtomicCompareExchange(
1648 RValue Expected, RValue Desired, llvm::AtomicOrdering Success,
1648 RValue Expected, RValue Desired, llvm::AtomicOrdering Success,
1682 EmitAtomicUpdateValue(CodeGenFunction &CGF, AtomicInfo &Atomics, RValue OldRVal,
1683 const llvm::function_ref<RValue(RValue)> &UpdateOp,
1683 const llvm::function_ref<RValue(RValue)> &UpdateOp,
1685 RValue UpRVal;
1726 RValue NewRVal = UpdateOp(UpRVal);
1737 llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
1737 llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
1753 auto OldRVal = convertAtomicTempToRValue(ExpectedAddr,
1766 llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
1766 llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
1786 auto OldRVal = ConvertIntToValueOrAtomic(PHI, AggValueSlot::ignored(),
1798 RValue UpdateRVal, Address DesiredAddr) {
1824 RValue UpdateRVal, bool IsVolatile) {
1848 void AtomicInfo::EmitAtomicUpdateOp(llvm::AtomicOrdering AO, RValue UpdateRVal,
1878 llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
1878 llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp,
1887 void AtomicInfo::EmitAtomicUpdate(llvm::AtomicOrdering AO, RValue UpdateRVal,
1896 void CodeGenFunction::EmitAtomicStore(RValue rvalue, LValue lvalue,
1914 void CodeGenFunction::EmitAtomicStore(RValue rvalue, LValue dest,
1940 args.add(RValue::get(atomics.getAtomicSizeValue()),
1942 args.add(RValue::get(EmitCastToVoidPtr(atomics.getAtomicPointer())),
1944 args.add(RValue::get(EmitCastToVoidPtr(srcAddr.getPointer())),
1947 RValue::get(llvm::ConstantInt::get(IntTy, (int)llvm::toCABI(AO))),
1980 std::pair<RValue, llvm::Value *> CodeGenFunction::EmitAtomicCompareExchange(
1981 LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
1981 LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
2000 const llvm::function_ref<RValue(RValue)> &UpdateOp, bool IsVolatile) {
2000 const llvm::function_ref<RValue(RValue)> &UpdateOp, bool IsVolatile) {
2011 atomics.emitCopyIntoMemory(RValue::get(value));
2017 atomics.emitCopyIntoMemory(RValue::getComplex(value));
tools/clang/lib/CodeGen/CGBlocks.cpp 1254 RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E,
1273 Args.add(RValue::get(BlockDescriptor), VoidPtrQualTy);
1293 Args.add(RValue::get(BlockPtr), Ctx.VoidPtrTy);
tools/clang/lib/CodeGen/CGBuiltin.cpp 167 static RValue EmitBinaryAtomic(CodeGenFunction &CGF,
170 return RValue::get(MakeBinaryAtomicValue(CGF, Kind, E));
176 static RValue EmitBinaryAtomicPost(CodeGenFunction &CGF,
208 return RValue::get(Result);
445 static RValue emitLibraryCall(CodeGenFunction &CGF, const FunctionDecl *FD,
831 static RValue EmitMSVCRTSetJmp(CodeGenFunction &CGF, MSVCSetJmpKind SJKind,
868 return RValue::get(CB);
1224 RValue CodeGenFunction::emitBuiltinOSLogFormat(const CallExpr &E) {
1235 Args.add(RValue::get(BufAddr.getPointer()), Ctx.VoidPtrTy);
1273 Args.add(RValue::get(ArgVal), ArgTy);
1293 return RValue::get(BufAddr.getPointer());
1308 static RValue
1393 return RValue::get(Overflow);
1516 RValue CodeGenFunction::emitRotate(const CallExpr *E, bool IsRotateRight) {
1528 return RValue::get(Builder.CreateCall(F, { Src, Src, ShiftAmt }));
1531 RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
1540 return RValue::get(llvm::ConstantInt::get(getLLVMContext(),
1543 return RValue::get(llvm::ConstantFP::get(getLLVMContext(),
1561 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::ceil));
1571 return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::copysign));
1580 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::cos));
1589 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp));
1598 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp2));
1608 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::fabs));
1617 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::floor));
1626 return RValue::get(emitTernaryBuiltin(*this, E, Intrinsic::fma));
1635 return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::maxnum));
1644 return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::minnum));
1657 return RValue::get(Builder.CreateFRem(Arg1, Arg2, "fmod"));
1667 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log));
1676 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log10));
1685 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log2));
1693 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::nearbyint));
1702 return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::pow));
1711 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::rint));
1720 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::round));
1729 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sin));
1738 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sqrt));
1747 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::trunc));
1755 return RValue::get(emitFPToIntRoundBuiltin(*this, E, Intrinsic::lround));
1763 return RValue::get(emitFPToIntRoundBuiltin(*this, E, Intrinsic::llround));
1771 return RValue::get(emitFPToIntRoundBuiltin(*this, E, Intrinsic::lrint));
1779 return RValue::get(emitFPToIntRoundBuiltin(*this, E, Intrinsic::llrint));
1790 return RValue::get(ConstantEmitter(*this).emitAbstract(E, E->getType()));
1795 return RValue::get(
1808 return RValue::get(Builder.CreateCall(CGM.getIntrinsic(Intrinsic::vacopy),
1821 return RValue::get(Result);
1835 return RValue::getComplex(std::make_pair(Real, Imag));
1844 return RValue::get(ComplexVal.first);
1861 return RValue::get(Res);
1870 return RValue::get(EmitScalarExpr(E->getArg(0)));
1876 return RValue::get(EmitScalarExpr(E->getArg(0)));
1882 return RValue::get(Res);
1892 return RValue::get(ComplexVal.second);
1913 return RValue::get(Result);
1930 return RValue::get(Result);
1947 return RValue::get(Result);
1968 return RValue::get(Result);
1985 return RValue::get(Result);
2000 return RValue::get(Result);
2018 return RValue::get(Result);
2024 return RValue::get(EmitScalarExpr(E->getArg(0)));
2035 return RValue::get(ArgValue);
2040 return RValue::get(Result);
2057 return RValue::get(PtrValue);
2062 return RValue::get(nullptr);
2066 return RValue::get(Builder.CreateCall(FnAssume, ArgValue));
2071 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::bswap));
2077 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::bitreverse));
2112 return RValue::get(ConstantInt::get(ResultType, 0));
2117 return RValue::get(ConstantInt::get(ResultType, 0));
2131 return RValue::get(Result);
2142 return RValue::get(emitBuiltinObjectSize(E->getArg(0), Type, ResType,
2154 return RValue::get(Builder.CreateCall(F, {Address, RW, Locality, Data}));
2158 return RValue::get(Builder.CreateCall(F));
2164 return RValue::get(Builder.CreateCall(F, {Begin, End}));
2167 return RValue::get(EmitTrapCall(Intrinsic::trap));
2169 return RValue::get(EmitTrapCall(Intrinsic::debugtrap));
2176 return RValue::get(nullptr);
2186 return RValue::get(Builder.CreateCall(F, {Base, Exponent}));
2222 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType())));
2227 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
2248 return RValue::get(Builder.CreateZExt(FCmp, ConvertType(E->getType())));
2265 return RValue::get(Result);
2283 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
2294 return RValue::get(Result);
2352 return RValue::get(Result);
2368 return RValue::get(AI);
2381 return RValue::get(AI);
2388 EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
2391 return RValue::get(nullptr);
2398 EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
2400 EmitNonNullArgCheck(RValue::get(Src.getPointer()), E->getArg(1)->getType(),
2403 return RValue::get(Dest.getPointer());
2424 return RValue::get(Dest.getPointer());
2433 return RValue::get(DestAddr.getPointer());
2450 return RValue::get(Dest.getPointer());
2458 EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
2460 EmitNonNullArgCheck(RValue::get(Src.getPointer()), E->getArg(1)->getType(),
2463 return RValue::get(Dest.getPointer());
2471 EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
2474 return RValue::get(Dest.getPointer());
2491 return RValue::get(Dest.getPointer());
2548 return RValue::get(Ret);
2562 return RValue::get(Builder.CreateCall(F,
2569 return RValue::get(Builder.CreateCall(F, Depth));
2573 return RValue::get(Builder.CreateCall(F, Builder.getInt32(0)));
2579 return RValue::get(Builder.CreateCall(F, Depth));
2584 return RValue::get(Result);
2589 return RValue::get(Result);
2597 return RValue::get(llvm::UndefValue::get(Ty));
2599 return RValue::get(llvm::ConstantInt::get(Ty, Column, true));
2605 return RValue::get(llvm::UndefValue::get(ConvertType(E->getType())));
2623 return RValue::get(nullptr);
2627 return RValue::get(Builder.CreateCall(F));
2646 return RValue::get(Result);
2650 return RValue::get(Builder.CreateSExt(Result, Int64Ty, "extend.sext"));
2652 return RValue::get(Builder.CreateZExt(Result, Int64Ty, "extend.zext"));
2673 return RValue::get(Builder.CreateCall(F, Buf.getPointer()));
2688 return RValue::get(nullptr);
2697 return RValue::get(Ptr);
2812 return RValue::get(MakeAtomicCmpXchgValue(*this, E, false));
2819 return RValue::get(MakeAtomicCmpXchgValue(*this, E, true));
2850 return RValue::get(nullptr);
2862 return RValue::get(nullptr);
2866 return RValue::get(EmitNontemporalLoad(*this, E));
2868 return RValue::get(EmitNontemporalStore(*this, E));
2876 Args.add(RValue::get(EmitScalarExpr(E->getArg(0))),
2879 Args.add(RValue::get(EmitScalarExpr(E->getArg(1))),
2882 Args.add(RValue::get(llvm::Constant::getNullValue(VoidPtrTy)),
2934 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
2974 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
3002 return RValue::get(nullptr);
3031 return RValue::get(nullptr);
3065 return RValue::get(nullptr);
3100 return RValue::get(nullptr);
3106 return RValue::get(
3131 return RValue::getIgnored();
3142 return RValue::get(EmitAnnotationCall(F, AnnVal, Str, E->getExprLoc()));
3208 return RValue::get(Sum2);
3297 return RValue::get(Overflow);
3367 return RValue::get(Carry);
3370 return RValue::get(EmitLValue(E->getArg(0)).getPointer());
3380 return RValue::get(ConstantInt::get(IntTy, 0));
3392 return RValue::get(
3420 return RValue::get(Builder.CreateIntToPtr(Builder.CreateExtractValue(Result,
3428 return RValue::get(EmitAtomicCmpXchgForMSIntrin(*this, E));
3431 return RValue::get(
3435 return RValue::get(
3440 return RValue::get(EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedAnd, E));
3444 return RValue::get(
3449 return RValue::get(
3454 return RValue::get(EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedOr, E));
3458 return RValue::get(EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedXor, E));
3478 return RValue::get(EmitBitTestIntrinsic(*this, BuiltinID, E));
3486 return RValue::get(EmitISOVolatileLoad(*this, E));
3491 return RValue::get(EmitISOVolatileStore(*this, E));
3495 return RValue::get(EmitSEHExceptionCode());
3498 return RValue::get(EmitSEHExceptionInfo());
3501 return RValue::get(EmitSEHAbnormalTermination());
3519 return RValue::get(llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy));
3524 return RValue::get(EmitMSVCBuiltinExpr(MSVCIntrin::__fastfail, E));
3531 return RValue::get(Builder.CreateCall(F));
3586 return RValue::get(
3606 return RValue::get(Builder.CreateCall(
3649 return RValue::get(
3687 return RValue::get(
3712 return RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3736 return RValue::get(Builder.CreateBitOrPointerCast(NewCall,
3781 return RValue::get(RTCall);
3838 auto Call =
3839 RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3897 return RValue::get(
3914 auto Call =
3915 RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3932 return RValue::get(Builder.CreateCall(
3946 return RValue::get(Builder.CreateCall(
3967 return RValue::get(Builder.CreateCall(
3981 return RValue::get(Builder.CreateStore(HalfVal, Address));
3986 return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getDoubleTy()));
3991 return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getFloatTy()));
4001 return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::canonicalize));
4014 return RValue::getIgnored();
4018 return RValue::getIgnored();
4022 return RValue::getIgnored();
4040 return RValue::get(Builder.CreateCall(F, {Arg0Val, Arg1}));
4048 return RValue::getIgnored();
4052 return RValue::getIgnored();
4056 return RValue::getIgnored();
4078 return RValue::get(Builder.CreateCall(F, {Arg0, Arg1Val, Arg2}));
4083 return RValue::get(
4105 return RValue::get(Builder.CreateStore(ArgPtr, DestAddr));
4217 return RValue::get(V);
4222 return RValue::get(V);
tools/clang/lib/CodeGen/CGCUDANV.cpp 318 LaunchKernelArgs.add(RValue::get(Kernel),
320 LaunchKernelArgs.add(RValue::getAggregate(GridDim), Dim3Ty);
321 LaunchKernelArgs.add(RValue::getAggregate(BlockDim), Dim3Ty);
322 LaunchKernelArgs.add(RValue::get(KernelArgs.getPointer()),
324 LaunchKernelArgs.add(RValue::get(CGF.Builder.CreateLoad(ShmemSize)),
326 LaunchKernelArgs.add(RValue::get(CGF.Builder.CreateLoad(Stream)),
tools/clang/lib/CodeGen/CGCUDARuntime.cpp 26 RValue CGCUDARuntime::EmitCUDAKernelCallExpr(CodeGenFunction &CGF,
44 return RValue::get(nullptr);
tools/clang/lib/CodeGen/CGCUDARuntime.h 52 virtual RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF,
tools/clang/lib/CodeGen/CGCXXABI.cpp 157 RValue RV, QualType ResultType) {
tools/clang/lib/CodeGen/CGCXXABI.h 456 RValue RV, QualType ResultType);
tools/clang/lib/CodeGen/CGCall.cpp 1051 EmitStoreThroughLValue(RValue::get(*AI++), LV);
1078 CallArg BaseArg = CallArg(RValue::getAggregate(Base), BS->getType());
1098 auto RV = Arg.getKnownRValue();
3071 args.add(RValue::get(Builder.CreateLoad(local)), type);
3085 args.add(RValue::get(ptr), type);
3170 CGF.EmitStoreThroughLValue(RValue::get(value), srcLV);
3233 args.add(RValue::get(llvm::ConstantPointerNull::get(destType)),
3291 RValue srcRV = CGF.EmitLoadOfLValue(srcLV, SourceLocation());
3331 args.add(RValue::get(finalArgument), CRE->getType());
3350 void CodeGenFunction::EmitNonNullArgCheck(RValue RV, QualType ArgType,
3434 Args.add(RValue::get(V), SizeTy);
3476 RValue RVArg = Args.back().getKnownRValue();
3530 RValue CallArg::getRValue(CodeGenFunction &CGF) const {
3537 return RValue::getAggregate(Copy.getAddress());
3599 RValue RV = Slot.asRValue();
3779 RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
4144 RValue RV = I->getKnownRValue();
4467 RValue Ret = [&] {
4496 RValue ret = convertTempToRValue(SRetPtr, RetTy, SourceLocation());
4515 return RValue::getComplex(std::make_pair(Real, Imag));
4526 return RValue::getAggregate(DestPtr);
4534 return RValue::get(V);
tools/clang/lib/CodeGen/CGCall.h 220 RValue RV;
231 CallArg(RValue rv, QualType ty)
240 RValue getRValue(CodeGenFunction &CGF) const;
246 RValue getKnownRValue() const {
250 void setRValue(RValue _RV) {
287 void add(RValue rvalue, QualType type) { push_back(CallArg(rvalue, type)); }
tools/clang/lib/CodeGen/CGClass.cpp 676 RValue RHS = RValue::get(EmitScalarExpr(Init));
676 RValue RHS = RValue::get(EmitScalarExpr(Init));
2050 Args.add(RValue::get(ThisPtr), D->getThisType());
2184 CallArg ThisArg(RValue::get(This.getPointer()), D->getThisType());
2250 const RValue &RV = Args[I].getRValue(*this);
2309 Args.add(RValue::get(This.getPointer()), D->getThisType());
2315 Args.add(RValue::get(Src.getPointer()), QT);
2339 DelegateArgs.add(RValue::get(This.getPointer()), (*I)->getType());
2861 RValue RV = EmitCall(calleeFnInfo, callee, returnSlot, callArgs);
2866 RV = RValue::get(EmitARCRetainAutoreleasedReturnValue(RV.getScalarVal()));
2892 CallArgs.add(RValue::get(ThisPtr.getPointer()), ThisType);
2911 CallArgs.add(RValue::get(ThisPtr), ThisType);
tools/clang/lib/CodeGen/CGCleanup.cpp 26 bool DominatingValue<RValue>::saved_type::needsSaving(RValue rv) {
34 DominatingValue<RValue>::saved_type
35 DominatingValue<RValue>::saved_type::save(CodeGenFunction &CGF, RValue rv) {
76 RValue DominatingValue<RValue>::saved_type::restore(CodeGenFunction &CGF) {
83 return RValue::get(Value);
85 return RValue::get(CGF.Builder.CreateLoad(getSavingAddress(Value)));
87 return RValue::getAggregate(Address(Value, CharUnits::fromQuantity(Align)));
90 return RValue::getAggregate(Address(addr, CharUnits::fromQuantity(Align)));
98 return RValue::getComplex(real, imag);
tools/clang/lib/CodeGen/CGCoroutine.cpp 172 RValue RV;
261 RValue CodeGenFunction::EmitCoawaitExpr(const CoawaitExpr &E,
268 RValue CodeGenFunction::EmitCoyieldExpr(const CoyieldExpr &E,
696 RValue CodeGenFunction::EmitCoroutineIntrinsic(const CallExpr *E,
706 return RValue::get(CurCoro.Data->CoroBegin);
711 return RValue::get(NullPtr);
757 return RValue::get(Call);
tools/clang/lib/CodeGen/CGDecl.cpp 585 Args.add(RValue::get(Arg),
748 EmitStoreThroughLValue(RValue::get(value), lvalue, true);
1846 return EmitStoreThroughLValue(RValue::get(constant), lv, true);
1872 RValue rvalue = EmitReferenceBindingToExpr(init);
tools/clang/lib/CodeGen/CGDeclCXX.cpp 222 RValue RV = EmitReferenceBindingToExpr(Init);
tools/clang/lib/CodeGen/CGException.cpp 1639 Args.add(RValue::get(IsForEH), ArgTys[0]);
1640 Args.add(RValue::get(FP), ArgTys[1]);
tools/clang/lib/CodeGen/CGExpr.cpp 194 RValue CodeGenFunction::EmitAnyExpr(const Expr *E,
199 return RValue::get(EmitScalarExpr(E, ignoreResult));
201 return RValue::getComplex(EmitComplexExpr(E, ignoreResult, ignoreResult));
213 RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
244 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
244 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
592 RValue
609 return RValue::get(Value);
1144 RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
1146 return RValue::get(nullptr);
1153 return RValue::getComplex(std::make_pair(U, U));
1161 return RValue::getAggregate(DestPtr);
1165 return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
1170 RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
1749 EmitAtomicStore(RValue::get(Value), AtomicLValue, isInit);
1774 RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, SourceLocation Loc) {
1778 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
1784 return RValue::get(EmitARCLoadWeak(LV.getAddress()));
1790 return RValue::get(Object);
1797 return RValue::get(EmitLoadOfScalar(LV, Loc));
1803 return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(),
1820 RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV,
1847 return RValue::get(Val);
1852 RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) {
1864 return RValue::get(Builder.CreateExtractElement(Vec, Elt));
1877 return RValue::get(Vec);
1902 RValue CodeGenFunction::EmitLoadOfGlobalRegLValue(LValue LV) {
1920 return RValue::get(Call);
1927 void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
1965 Src = RValue::get(EmitARCRetain(Dst.getType(), Src.getScalarVal()));
1980 Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(),
2024 void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
2091 void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
2162 void CodeGenFunction::EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst) {
4470 RValue
4474 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator
4484 RValue CodeGenFunction::EmitRValueForField(LValue LV,
4491 return RValue::getComplex(EmitLoadOfComplex(FieldLV, Loc));
4498 return RValue::get(FieldLV.getPointer());
4508 RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
4540 RValue CodeGenFunction::EmitSimpleCallExpr(const CallExpr *E,
4640 RValue RV = EmitAnyExpr(E->getRHS());
4658 RValue RV = EmitCallExpr(E);
4709 RValue RV = EmitObjCMessageExpr(E);
4767 RValue RV = EmitAnyExprToTemp(E);
4772 RValue CodeGenFunction::EmitCall(QualType CalleeType, const CGCallee &OrigCallee,
4878 Args.add(RValue::get(Builder.CreateBitCast(Chain, CGM.VoidPtrTy)),
4943 RValue Call = EmitCall(FnInfo, Callee, ReturnValue, Args, &CallOrInvoke,
4982 RValue CodeGenFunction::convertTempToRValue(Address addr,
4988 return RValue::getComplex(EmitLoadOfComplex(lvalue, loc));
4992 return RValue::get(EmitLoadOfScalar(lvalue, loc));
5011 RValue RV;
5087 RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E,
tools/clang/lib/CodeGen/CGExprAgg.cpp 57 llvm::function_ref<RValue(ReturnValueSlot)> Fn);
82 void EmitFinalDestCopy(QualType type, RValue src);
86 void EmitMoveFromReturnSlot(const Expr *E, RValue Src);
205 RValue Res = CGF.EmitAtomicExpr(E);
248 const Expr *E, llvm::function_ref<RValue(ReturnValueSlot)> EmitCall) {
288 RValue Src =
310 void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) {
418 CGF.EmitStoreThroughLValue(RValue::get(ArrayStart), Start);
435 CGF.EmitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength);
438 CGF.EmitStoreThroughLValue(RValue::get(Size), EndOrLength);
806 RValue rvalue = RValue::getAggregate(valueAddr, atomicSlot.isVolatile());
806 RValue rvalue = RValue::getAggregate(valueAddr, atomicSlot.isVolatile());
997 RValue RV = CGF.EmitAnyExpr(E);
1054 CGF.EmitStoreThroughLValue(RValue::get(Select), FieldLV, /*IsInit*/ true);
1402 RValue RV = CGF.EmitReferenceBindingToExpr(E);
1422 CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV);
1443 CGF.EmitStoreThroughBitfieldLValue(RValue::get(null), lv);
tools/clang/lib/CodeGen/CGExprCXX.cpp 48 Args.add(RValue::get(This), CGF.getTypes().DeriveThisType(RD, MD));
52 Args.add(RValue::get(ImplicitParam), ImplicitParamTy);
78 RValue CodeGenFunction::EmitCXXMemberOrOperatorCall(
93 RValue CodeGenFunction::EmitCXXDestructorCall(
118 RValue CodeGenFunction::EmitCXXPseudoDestructorExpr(
166 return RValue::get(nullptr);
179 RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
206 RValue CodeGenFunction::EmitCXXMemberOrOperatorMemberCallExpr(
281 return RValue::get(nullptr);
285 if (isa<CXXDestructorDecl>(MD)) return RValue::get(nullptr);
296 return RValue::get(This.getPointer());
369 return RValue::get(nullptr);
413 RValue
451 Args.add(RValue::get(ThisPtrForCall), ThisType);
462 RValue
473 RValue CodeGenFunction::EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
1285 static RValue EmitNewDeleteCall(CodeGenFunction &CGF,
1292 RValue RV =
1312 RValue CodeGenFunction::EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
1448 DeleteArgs.add(RValue::get(llvm::ConstantInt::get(
1479 typedef RValue RValueTy;
1480 static RValue get(CodeGenFunction &, ValueTy V) { return RValue::get(V); }
1480 static RValue get(CodeGenFunction &, ValueTy V) { return RValue::get(V); }
1481 static RValue get(CodeGenFunction &, RValueTy V) { return V; }
1503 DominatingValue<RValue>::saved_type SavedNewPtr =
1504 DominatingValue<RValue>::save(CGF, RValue::get(NewPtr.getPointer()));
1504 DominatingValue<RValue>::save(CGF, RValue::get(NewPtr.getPointer()));
1505 DominatingValue<RValue>::saved_type SavedAllocSize =
1506 DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
1506 DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
1509 typedef DominatingValue<RValue>::saved_type ValueTy;
1510 typedef DominatingValue<RValue>::saved_type RValueTy;
1511 static RValue get(CodeGenFunction &CGF, ValueTy V) {
1528 I, DominatingValue<RValue>::save(CGF, Arg.getRValue(CGF)), Arg.Ty);
1581 allocatorArgs.add(RValue::get(allocSize), getContext().getSizeType());
1582 allocatorArgs.add(RValue::get(allocation.getPointer()), arg->getType());
1592 allocatorArgs.add(RValue::get(allocSize), sizeType);
1615 RValue::get(llvm::ConstantInt::get(SizeTy, allocAlign.getQuantity())),
1623 RValue RV =
1769 DeleteArgs.add(RValue::get(DeletePtr), ArgTy);
1776 DeleteArgs.add(RValue::get(V), DDTag);
1795 DeleteArgs.add(RValue::get(Size), SizeType);
1805 DeleteArgs.add(RValue::get(Align), AlignValType);
tools/clang/lib/CodeGen/CGExprComplex.cpp 375 return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit);
618 Args.add(RValue::get(Op.LHS.first),
620 Args.add(RValue::get(Op.LHS.second),
622 Args.add(RValue::get(Op.RHS.first),
624 Args.add(RValue::get(Op.RHS.second),
648 RValue Res = CGF.EmitCall(FuncInfo, Callee, ReturnValueSlot(), Args, &Call);
943 Val = RValue::getComplex(ResVal);
948 Val = RValue::get(ResVal);
958 RValue Val;
1159 RValue Val;
1167 RValue Val;
tools/clang/lib/CodeGen/CGExprScalar.cpp 2563 LV, RValue::get(atomicPHI), RValue::get(value), E->getExprLoc());
2563 LV, RValue::get(atomicPHI), RValue::get(value), E->getExprLoc());
2574 CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value);
2576 CGF.EmitStoreThroughLValue(RValue::get(value), LV);
2919 LHSLV, RValue::get(atomicPHI), RValue::get(Result), E->getExprLoc());
2919 LHSLV, RValue::get(atomicPHI), RValue::get(Result), E->getExprLoc());
2933 CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result);
2935 CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV);
3939 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS);
3942 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS);
tools/clang/lib/CodeGen/CGGPUBuiltin.cpp 68 RValue
89 return RValue::get(llvm::ConstantInt::get(IntTy, 0));
120 return RValue::get(Builder.CreateCall(
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp 563 RValue SrcVal = this->CGF->EmitLoadOfLValue(SrcLV, SourceLocation());
tools/clang/lib/CodeGen/CGObjC.cpp 33 static RValue AdjustObjCObjectType(CodeGenFunction &CGF,
35 RValue Result);
93 Args.add(RValue::get(BitCast.getPointer()), ArgQT);
105 Args.add(RValue::get(Cast), EncodingQT);
110 RValue result = Runtime.GenerateMessageSend(
171 EmitStoreThroughLValue(RValue::get(value), LV, true);
181 EmitStoreThroughLValue(RValue::get(keyValue), KeyLV, /*isInit=*/true);
188 EmitStoreThroughLValue(RValue::get(valueValue), ValueLV, /*isInit=*/true);
201 Args.add(RValue::get(Objects.getPointer()), ArgQT);
205 Args.add(RValue::get(Keys.getPointer()), ArgQT);
211 Args.add(RValue::get(Count), ArgQT);
224 RValue result = Runtime.GenerateMessageSend(
266 static RValue AdjustObjCObjectType(CodeGenFunction &CGF, QualType ExpT,
267 RValue Result) {
277 return RValue::get(CGF.Builder.CreateBitCast(Result.getScalarVal(),
484 RValue CodeGenFunction::EmitObjCMessageExpr(const ObjCMessageExpr *E,
501 return AdjustObjCObjectType(*this, E->getType(), RValue::get(result));
506 return AdjustObjCObjectType(*this, E->getType(), RValue::get(*Val));
599 RValue result;
618 result = RValue::get(SpecializedResult.getValue());
739 args.add(RValue::get(dest.getPointer()), Context.VoidPtrTy);
742 args.add(RValue::get(src.getPointer()), Context.VoidPtrTy);
745 args.add(RValue::get(CGF.CGM.getSize(size)), Context.getSizeType());
746 args.add(RValue::get(CGF.Builder.getInt1(isAtomic)), Context.BoolTy);
747 args.add(RValue::get(CGF.Builder.getInt1(hasStrong)), Context.BoolTy);
1001 args.add(RValue::get(returnAddr), CGF.getContext().VoidPtrTy);
1008 args.add(RValue::get(ivarAddr), CGF.getContext().VoidPtrTy);
1011 args.add(RValue::get(AtomicHelperFn), CGF.getContext().VoidPtrTy);
1108 args.add(RValue::get(self), getContext().getObjCIdType());
1109 args.add(RValue::get(cmd), getContext().getObjCSelType());
1110 args.add(RValue::get(ivarOffset), getContext().getPointerDiffType());
1111 args.add(RValue::get(Builder.getInt1(strategy.isAtomic())),
1117 RValue RV = EmitCall(getTypes().arrangeBuiltinFunctionCall(
1126 RV = RValue::get(Builder.CreateBitCast(
1187 EmitReturnOfRValue(RValue::get(value), propType);
1211 args.add(RValue::get(ivarAddr), CGF.getContext().VoidPtrTy);
1220 args.add(RValue::get(argAddr), CGF.getContext().VoidPtrTy);
1225 args.add(RValue::get(size), CGF.getContext().getSizeType());
1228 args.add(RValue::get(CGF.Builder.getTrue()), CGF.getContext().BoolTy);
1232 args.add(RValue::get(CGF.Builder.getFalse()), CGF.getContext().BoolTy);
1257 args.add(RValue::get(ivarAddr), CGF.getContext().VoidPtrTy);
1266 args.add(RValue::get(argAddr), CGF.getContext().VoidPtrTy);
1269 args.add(RValue::get(AtomicHelperFn), CGF.getContext().VoidPtrTy);
1399 args.add(RValue::get(self), getContext().getObjCIdType());
1400 args.add(RValue::get(cmd), getContext().getObjCSelType());
1402 args.add(RValue::get(arg), getContext().getObjCIdType());
1403 args.add(RValue::get(ivarOffset), getContext().getPointerDiffType());
1408 args.add(RValue::get(ivarOffset), getContext().getPointerDiffType());
1409 args.add(RValue::get(arg), getContext().getObjCIdType());
1410 args.add(RValue::get(Builder.getInt1(strategy.isAtomic())),
1412 args.add(RValue::get(Builder.getInt1(strategy.isCopy())),
1597 EmitReturnOfRValue(RValue::get(SelfAsId), IdTy);
1687 Args.add(RValue::get(StatePtr.getPointer()),
1695 Args.add(RValue::get(ItemsPtr.getPointer()),
1701 Args.add(RValue::get(Count), getContext().getNSUIntegerType());
1704 RValue CountRV =
1776 Args2.add(RValue::get(V), getContext().getObjCIdType());
1833 EmitStoreThroughLValue(RValue::get(CurrentItem), elementLValue);
1835 EmitStoreThroughLValue(RValue::get(CurrentItem), elementLValue,
1901 EmitStoreThroughLValue(RValue::get(null), elementLValue);
2535 RValue AllocRV =
2544 RValue InitRV =
2948 RValue::get(asImpl().getValueOfResult(result)));
3065 CGF.EmitStoreThroughLValue(RValue::get(asImpl().getValueOfResult(result)),
3655 RValue DV = EmitAnyExpr(&DstExpr);
3685 RValue Result;
tools/clang/lib/CodeGen/CGObjCGNU.cpp 578 RValue
584 RValue
2492 RValue
2506 return RValue::get(EnforceType(Builder, Receiver,
2510 return RValue::get(nullptr);
2517 ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);
2518 ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
2606 RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
2612 RValue
2626 return RValue::get(EnforceType(Builder, Receiver,
2630 return RValue::get(nullptr);
2680 ActualArgs.add(RValue::get(Receiver), ASTIdTy);
2681 ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
2718 ActualArgs[0] = CallArg(RValue::get(Receiver), ASTIdTy);
2724 RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
2737 msgRet = RValue::get(phi);
2746 msgRet = RValue::getAggregate(Address(phi, v.getAlignment()));
2757 msgRet = RValue::getComplex(phi, phi2);
tools/clang/lib/CodeGen/CGObjCMac.cpp 1065 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1315 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1323 CodeGen::RValue
1478 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1600 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1608 CodeGen::RValue
1727 RValue complete(CodeGenFunction &CGF,
1729 RValue result,
1757 RValue RV = I->getRValue(CGF);
1781 if (!contBB) return RValue::get(null);
1788 return RValue::get(phi);
1818 return RValue::getComplex(real, imag);
2051 CodeGen::RValue
2113 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2136 CodeGen::RValue
2151 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2152 ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType());
2238 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
7112 RValue
7128 args.add(RValue::get(arg0), arg0Type);
7132 args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7209 args[1].setRValue(RValue::get(mref.getPointer()));
7218 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7224 CodeGen::RValue
7428 CodeGen::RValue
tools/clang/lib/CodeGen/CGObjCRuntime.h 162 virtual CodeGen::RValue
178 virtual CodeGen::RValue
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 824 RValue Func = RValue::get(Reduction.second);
824 RValue Func = RValue::get(Reduction.second);
834 RValue InitRVal;
841 RValue::getComplex(CGF.EmitLoadOfComplex(LV, DRD->getLocation()));
844 InitRVal = RValue::getAggregate(LV.getAddress());
1029 RValue::get(Size));
1048 RValue::get(Size));
4592 CGF.EmitStoreThroughLValue(RValue::get(CGF.Builder.getInt32(/*C=*/0)),
5550 RValue Func = RValue::get(Reduction.first);
5550 RValue Func = RValue::get(Reduction.first);
5619 CGF, OVE, RValue::get(CGF.Builder.CreatePtrToInt(Ptr, CGF.SizeTy)));
5893 RValue E;
8212 RValue VarRVal = CGF.EmitLoadOfLValue(VarLVal, RD->getLocation());
tools/clang/lib/CodeGen/CGStmt.cpp 1036 void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) {
1107 RValue Result = EmitReferenceBindingToExpr(RV);
2345 EmitStoreThroughLValue(RValue::get(Tmp), Dest);
2364 EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 318 EmitStoreThroughLValue(RValue::get(CV), SrcLV);
1681 RValue Len = CGF.EmitAnyExpr(C->getSimdlen(), AggValueSlot::ignored(),
1691 RValue Len = CGF.EmitAnyExpr(C->getSafelen(), AggValueSlot::ignored(),
2603 CGF.EmitStoreThroughLValue(RValue::get(Init), LVal, /*isInit*/ true);
3640 static llvm::Value *convertToScalarValue(CodeGenFunction &CGF, RValue Val,
3653 convertToComplexValue(CodeGenFunction &CGF, RValue Val, QualType SrcType,
3680 LValue LVal, RValue RVal) {
3691 void CodeGenFunction::emitOMPSimpleStore(LValue LVal, RValue RVal,
3695 EmitStoreThroughLValue(RValue::get(convertToScalarValue(
3717 RValue Res = XLValue.isGlobalReg()
3747 static std::pair<bool, RValue> emitOMPAtomicRMW(CodeGenFunction &CGF, LValue X,
3748 RValue Update,
3764 return std::make_pair(false, RValue::get(nullptr));
3773 return std::make_pair(false, RValue::get(nullptr));
3809 return std::make_pair(false, RValue::get(nullptr));
3838 return std::make_pair(true, RValue::get(Res));
3841 std::pair<bool, RValue> CodeGenFunction::EmitOMPAtomicSimpleUpdateExpr(
3842 LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
3844 const llvm::function_ref<RValue(RValue)> CommonGen) {
3844 const llvm::function_ref<RValue(RValue)> CommonGen) {
3880 RValue ExprRValue = CGF.EmitAnyExpr(E);
3903 static RValue convertToType(CodeGenFunction &CGF, RValue Value,
3903 static RValue convertToType(CodeGenFunction &CGF, RValue Value,
3908 return RValue::get(
3912 return RValue::getComplex(Res.first, Res.second);
3927 RValue NewVVal;
3930 RValue ExprRValue = CGF.EmitAnyExpr(E);
3955 RValue Res = CGF.EmitAnyExpr(UE);
tools/clang/lib/CodeGen/CGVTables.cpp 68 static RValue PerformReturnAdjustment(CodeGenFunction &CGF,
69 QualType ResultType, RValue RV,
109 return RValue::get(ReturnValue);
222 RValue RV = RValue::get(T->getOperand(0));
222 RValue RV = RValue::get(T->getOperand(0));
326 CallArgs.add(RValue::get(AdjustedThisPtr), ThisType);
370 RValue RV = EmitCall(*CurFnInfo, CGCallee::forDirect(Callee, CurGD), Slot,
tools/clang/lib/CodeGen/CGValue.h 80 static RValue getIgnored() {
85 static RValue get(llvm::Value *V) {
86 RValue ER;
92 static RValue getComplex(llvm::Value *V1, llvm::Value *V2) {
93 RValue ER;
100 static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) {
106 static RValue getAggregate(Address addr, bool isVolatile = false) {
107 RValue ER;
430 RValue asAggregateRValue() const {
431 return RValue::getAggregate(getAddress(), isVolatileQualified());
606 RValue asRValue() const {
608 return RValue::getIgnored();
610 return RValue::getAggregate(getAddress(), isVolatile());
tools/clang/lib/CodeGen/CodeGenFunction.cpp 2019 CodeGenFunction::protectFromPeepholes(RValue rvalue) {
tools/clang/lib/CodeGen/CodeGenFunction.h 194 typedef RValue type;
206 static bool needsSaving(RValue value);
207 static saved_type save(CodeGenFunction &CGF, RValue value);
208 RValue restore(CodeGenFunction &CGF);
1119 const RValue &rv) {
1193 RValue rvalue)
1382 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
1861 EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
2282 RValue EmitAnyExpr(const Expr *E,
2297 RValue EmitAnyExprToTemp(const Expr *E);
2374 RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e);
2579 RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
2816 PeepholeProtection protectFromPeepholes(RValue rvalue);
2899 RValue EmitCoawaitExpr(const CoawaitExpr &E,
2903 RValue EmitCoyieldExpr(const CoyieldExpr &E,
2907 RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID);
2979 void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy,
3021 std::pair<bool, RValue> EmitOMPAtomicSimpleUpdateExpr(
3022 LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
3024 const llvm::function_ref<RValue(RValue)> CommonGen);
3024 const llvm::function_ref<RValue(RValue)> CommonGen);
3336 RValue GetUndefRValue(QualType Ty);
3341 RValue EmitUnsupportedRValue(const Expr *E,
3372 RValue convertTempToRValue(Address addr, QualType type,
3379 RValue EmitAtomicLoad(LValue LV, SourceLocation SL,
3382 RValue EmitAtomicLoad(LValue lvalue, SourceLocation loc,
3386 void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit);
3388 void EmitAtomicStore(RValue rvalue, LValue lvalue, llvm::AtomicOrdering AO,
3391 std::pair<RValue, llvm::Value *> EmitAtomicCompareExchange(
3392 LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
3392 LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
3400 const llvm::function_ref<RValue(RValue)> &UpdateOp,
3400 const llvm::function_ref<RValue(RValue)> &UpdateOp,
3466 RValue EmitLoadOfLValue(LValue V, SourceLocation Loc);
3467 RValue EmitLoadOfExtVectorElementLValue(LValue V);
3468 RValue EmitLoadOfBitfieldLValue(LValue LV, SourceLocation Loc);
3469 RValue EmitLoadOfGlobalRegLValue(LValue LV);
3474 void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit = false);
3475 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst);
3476 void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst);
3484 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
3521 RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc);
3561 RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e,
3599 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
3602 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
3608 RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E,
3610 RValue EmitCallExpr(const CallExpr *E,
3612 RValue EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
3674 RValue
3681 RValue EmitCXXDestructorCall(GlobalDecl Dtor, const CGCallee &Callee,
3685 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E,
3687 RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE,
3699 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
3702 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
3705 RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E);
3707 RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
3710 RValue EmitNVPTXDevicePrintfCallExpr(const CallExpr *E,
3713 RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
3716 RValue emitRotate(const CallExpr *E, bool IsRotateRight);
3719 RValue emitBuiltinOSLogFormat(const CallExpr &E);
3725 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
3796 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E,
3877 RValue EmitReferenceBindingToExpr(const Expr *E);
4008 RValue EmitAtomicExpr(AtomicExpr *E);
4141 void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc,
4159 void EmitReturnOfRValue(RValue RV, QualType Ty);
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 467 void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV,
1609 Args.insert(Args.begin() + 1, CallArg(RValue::get(VTT), VTTTy));
1974 RValue RV, QualType ResultType) {
1980 RValue Undef = RValue::get(llvm::UndefValue::get(T));
1980 RValue Undef = RValue::get(llvm::UndefValue::get(T));
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 307 CallArgs.add(RValue::get(getStructorImplicitParamValue(CGF)),
1561 RValue RV = RValue::get(MostDerivedArg);
1561 RValue RV = RValue::get(MostDerivedArg);
1933 RValue RV = CGF.EmitCXXDestructorCall(GD, Callee, This.getPointer(), ThisTy,
3958 Args.add(RValue::get(This), CD->getThisType());
3962 Args.add(RValue::get(SrcVal), SrcParam.getType());
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
98 move(_Tp&& __t) noexcept
usr/include/c++/7.4.0/bits/stl_pair.h 100 return __and_<is_constructible<_T1, const _U1&>,
100 return __and_<is_constructible<_T1, const _U1&>,
101 is_constructible<_T2, const _U2&>>::value;
101 is_constructible<_T2, const _U2&>>::value;
107 return __and_<is_convertible<const _U1&, _T1>,
107 return __and_<is_convertible<const _U1&, _T1>,
108 is_convertible<const _U2&, _T2>>::value;
108 is_convertible<const _U2&, _T2>>::value;
114 return __and_<is_constructible<_T1, _U1&&>,
114 return __and_<is_constructible<_T1, _U1&&>,
115 is_constructible<_T2, _U2&&>>::value;
115 is_constructible<_T2, _U2&&>>::value;
121 return __and_<is_convertible<_U1&&, _T1>,
121 return __and_<is_convertible<_U1&&, _T1>,
122 is_convertible<_U2&&, _T2>>::value;
122 is_convertible<_U2&&, _T2>>::value;
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
129 is_convertible<_U2&&, _T2>>;
129 is_convertible<_U2&&, _T2>>;
133 return __and_<is_constructible<_T1, const _U1&>,
133 return __and_<is_constructible<_T1, const _U1&>,
134 is_constructible<_T2, _U2&&>,
134 is_constructible<_T2, _U2&&>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
143 is_convertible<const _U2&, _T2>>;
143 is_convertible<const _U2&, _T2>>;
147 return __and_<is_constructible<_T1, _U1&&>,
147 return __and_<is_constructible<_T1, _U1&&>,
148 is_constructible<_T2, const _U2&&>,
148 is_constructible<_T2, const _U2&&>,
209 : private __pair_base<_T1, _T2>
209 : private __pair_base<_T1, _T2>
211 typedef _T1 first_type; /// @c first_type is the first bound type
212 typedef _T2 second_type; /// @c second_type is the second bound type
214 _T1 first; /// @c first is a copy of the first object
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
283 _T1, _T2>;
311 constexpr pair(_U1&& __x, const _T2& __y)
311 constexpr pair(_U1&& __x, const _T2& __y)
318 explicit constexpr pair(_U1&& __x, const _T2& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
332 explicit pair(const _T1& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
379 __and_<is_copy_assignable<_T1>,
380 is_copy_assignable<_T2>>::value,
390 __and_<is_move_assignable<_T1>,
391 is_move_assignable<_T2>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
405 operator=(const pair<_U1, _U2>& __p)
414 is_assignable<_T2&, _U2&&>>::value,
414 is_assignable<_T2&, _U2&&>>::value,
416 operator=(pair<_U1, _U2>&& __p)
522 constexpr pair<typename __decay_and_strip<_T1>::__type,
523 typename __decay_and_strip<_T2>::__type>
524 make_pair(_T1&& __x, _T2&& __y)
524 make_pair(_T1&& __x, _T2&& __y)
526 typedef typename __decay_and_strip<_T1>::__type __ds_type1;
527 typedef typename __decay_and_strip<_T2>::__type __ds_type2;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
762 typename add_rvalue_reference<_Tp>::type declval() noexcept;
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
889 typedef decltype(__test<_Tp>(0)) type;
894 : public __and_<__not_<is_void<_Tp>>,
895 __is_default_constructible_impl<_Tp>>
915 : public __is_default_constructible_atom<_Tp>::type
921 : public __is_default_constructible_safe<_Tp>::type
984 typedef decltype(__test<_Tp, _Arg>(0)) type;
989 : public __and_<is_destructible<_Tp>,
990 __is_direct_constructible_impl<_Tp, _Arg>>
1072 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 __is_direct_constructible_new_safe<_Tp, _Arg>
1079 : public __is_direct_constructible_new<_Tp, _Arg>::type
1119 : public __is_direct_constructible<_Tp, _Arg>
1130 : public __is_constructible_impl<_Tp, _Args...>::type
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_Tp>
1304 : public is_assignable<_Tp&, _Tp&&>
1304 : public is_assignable<_Tp&, _Tp&&>
1310 : public __is_move_assignable_impl<_Tp>
1377 static void __helper(const _Tp&);
1380 static true_type __test(const _Tp&,
1381 decltype(__helper<const _Tp&>({}))* = 0);
1390 typedef decltype(__test(declval<_Tp>())) type;
1395 : public __is_implicitly_default_constructible_impl<_Tp>::type
1400 : public __and_<is_default_constructible<_Tp>,
1401 __is_implicitly_default_constructible_safe<_Tp>>
1526 static void __test_aux(_To1);
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp type; };
2104 { typedef typename remove_cv<_Up>::type __type; };
2118 typedef typename remove_reference<_Tp>::type __remove_type;
2131 typedef _Tp __type;
2144 typename decay<_Tp>::type>::__type __type;