reference, declarationdefinition
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;