|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
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/Optional.h 144 T value;
160 explicit OptionalStorage(in_place_t, Args &&... args)
161 : value(std::forward<Args>(args)...), hasVal(true) {}
172 T &getValue() LLVM_LVALUE_FUNCTION noexcept {
176 T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
181 T &&getValue() && noexcept {
216 optional_detail::OptionalStorage<T> Storage;
219 using value_type = T;
224 Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
227 Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
230 Optional &operator=(T &&y) {
241 static inline Optional create(const T *y) {
245 Optional &operator=(const T &y) {
253 const T *getPointer() const { return &Storage.getValue(); }
254 T *getPointer() { return &Storage.getValue(); }
255 const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
256 T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
260 const T *operator->() const { return getPointer(); }
261 T *operator->() { return getPointer(); }
262 const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
263 T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
266 constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
271 T &&getValue() && { return std::move(Storage.getValue()); }
272 T &&operator*() && { return std::move(Storage.getValue()); }
275 T getValueOr(U &&value) && {
include/llvm/ADT/SmallVector.h 641 template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
include/llvm/Support/type_traits.h 91 T t;
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
145 std::is_copy_constructible<detail::trivial_helper<T>>::value;
147 !std::is_copy_constructible<T>::value;
151 std::is_move_constructible<detail::trivial_helper<T>>::value;
153 !std::is_move_constructible<T>::value;
157 is_copy_assignable<detail::trivial_helper<T>>::value;
159 !is_copy_assignable<T>::value;
163 is_move_assignable<detail::trivial_helper<T>>::value;
165 !is_move_assignable<T>::value;
169 std::is_destructible<detail::trivial_helper<T>>::value;
tools/clang/lib/CodeGen/CGAtomic.cpp 40 LValue LVal;
43 AtomicInfo(CodeGenFunction &CGF, LValue &lvalue)
97 LVal = LValue::MakeBitfield(Address(Addr, lvalue.getAlignment()),
139 const LValue &getAtomicLValue() const { return LVal; }
199 LValue projectValue() const {
205 return LValue::MakeAddr(addr, getValueType(), CGF.getContext(),
760 LValue lvalue = MakeAddrLValue(Ptr, AtomicTy);
880 LValue AtomicVal = MakeAddrLValue(Ptr, AtomicTy);
1372 LValue::MakeBitfield(addr, LVal.getBitFieldInfo(), LVal.getType(),
1376 LValue::MakeVectorElt(addr, LVal.getVectorIdx(), LVal.getType(),
1379 return CGF.EmitLoadOfExtVectorElementLValue(LValue::MakeExtVectorElt(
1459 bool CodeGenFunction::LValueIsSuitableForInlineAtomic(LValue LV) {
1472 RValue CodeGenFunction::EmitAtomicLoad(LValue LV, SourceLocation SL,
1518 RValue CodeGenFunction::EmitAtomicLoad(LValue src, SourceLocation loc,
1534 LValue Dest = CGF.MakeAddrLValue(getAtomicAddress(), getAtomicType());
1535 LValue Src = CGF.MakeAddrLValue(rvalue.getAggregateAddress(),
1550 LValue TempLVal = projectValue();
1570 LValue TempLV = CGF.MakeAddrLValue(CreateTempAlloca(), getAtomicType());
1686 LValue AtomicLVal = Atomics.getAtomicLValue();
1687 LValue DesiredLVal;
1694 LValue UpdateLVal;
1697 LValue::MakeBitfield(Ptr, AtomicLVal.getBitFieldInfo(),
1702 LValue::MakeBitfield(DesiredAddr, AtomicLVal.getBitFieldInfo(),
1706 UpdateLVal = LValue::MakeVectorElt(Ptr, AtomicLVal.getVectorIdx(),
1710 DesiredLVal = LValue::MakeVectorElt(
1715 UpdateLVal = LValue::MakeExtVectorElt(Ptr, AtomicLVal.getExtVectorElts(),
1719 DesiredLVal = LValue::MakeExtVectorElt(
1799 LValue AtomicLVal = Atomics.getAtomicLValue();
1800 LValue DesiredLVal;
1804 LValue::MakeBitfield(DesiredAddr, AtomicLVal.getBitFieldInfo(),
1809 LValue::MakeVectorElt(DesiredAddr, AtomicLVal.getVectorIdx(),
1814 DesiredLVal = LValue::MakeExtVectorElt(
1896 void CodeGenFunction::EmitAtomicStore(RValue rvalue, LValue lvalue,
1914 void CodeGenFunction::EmitAtomicStore(RValue rvalue, LValue dest,
1924 LValue LVal = atomics.getAtomicLValue();
1981 LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
1999 LValue LVal, llvm::AtomicOrdering AO,
2005 void CodeGenFunction::EmitAtomicInit(Expr *init, LValue dest) {
tools/clang/lib/CodeGen/CGBuiltin.cpp 153 LValue LV = CGF.MakeNaturalAlignAddrLValue(BC, E->getArg(0)->getType());
162 LValue LV = CGF.MakeNaturalAlignAddrLValue(Address, E->getType());
3752 LValue NDRangeL = EmitAggExprToLValue(E->getArg(2));
3957 LValue NDRangeL = EmitAggExprToLValue(E->getArg(0));
tools/clang/lib/CodeGen/CGCXXABI.h 585 virtual LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
tools/clang/lib/CodeGen/CGCall.cpp 1017 QualType Ty, LValue LV, SmallVectorImpl<llvm::Value *>::iterator &AI) {
1025 LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy);
1035 LValue SubLV = MakeAddrLValue(Base, BS->getType());
1042 LValue SubLV = EmitLValueForFieldInitialization(LV, FD);
1085 LValue LV = MakeAddrLValue(This, Ty);
2539 LValue LV = MakeAddrLValue(Alloca, Ty);
3114 const LValue &srcLV = writeback.Source;
3208 LValue srcLV;
3533 LValue Copy = CGF.MakeAddrLValue(CGF.CreateMemTemp(Ty), Ty);
3541 LValue Dst = CGF.MakeAddrLValue(Addr, Ty);
3548 LValue SrcLV = CGF.MakeAddrLValue(Addr, Ty);
3617 LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr());
3973 auto LV = I->getKnownLValue();
tools/clang/lib/CodeGen/CGCall.h 221 LValue LV; /// The argument is semantically a load from this l-value.
233 CallArg(LValue lv, QualType ty)
242 LValue getKnownLValue() const {
270 LValue Source;
289 void addUncopiedAggregate(LValue LV, QualType type) {
308 void addWriteback(LValue srcLV, Address temporary,
tools/clang/lib/CodeGen/CGClass.cpp 594 LValue &LHS) {
622 LValue LHS;
650 LValue ThisRHSLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);
651 LValue Src = CGF.EmitLValueForFieldInitialization(ThisRHSLV, Field);
668 void CodeGenFunction::EmitInitializerForField(FieldDecl *Field, LValue LHS,
958 LValue DestLV = CGF.MakeAddrLValue(ThisPtr, RecordTy);
959 LValue Dest = CGF.EmitLValueForFieldInitialization(DestLV, FirstField);
961 LValue SrcLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);
962 LValue Src = CGF.EmitLValueForFieldInitialization(SrcLV, FirstField);
1110 LValue LHS = CGF.MakeAddrLValue(ThisPtr, RecordTy);
1118 LValue FieldLHS = LHS;
1626 LValue ThisLV = CGF.MakeAddrLValue(thisValue, RecordTy);
1627 LValue LV = CGF.EmitLValueForField(ThisLV, field);
2059 LValue Src = EmitLValue(Arg);
2061 LValue Dest = MakeAddrLValue(This, DestTy);
2132 LValue SrcLVal = MakeAddrLValue(Src, SrcTy);
2134 LValue DestLVal = MakeAddrLValue(This, DestTy);
tools/clang/lib/CodeGen/CGCoroutine.cpp 171 LValue LV;
300 LValue
310 LValue
tools/clang/lib/CodeGen/CGDecl.cpp 664 const LValue &destLV, const Expr *init) {
684 LValue srcLV = CGF.EmitLValue(srcExpr);
714 LValue &lvalue,
719 void CodeGenFunction::EmitNullabilityCheck(LValue LHS, llvm::Value *RHS,
741 LValue lvalue, bool capturedByInit) {
771 LValue tempLV = lvalue;
1772 LValue Dst = MakeAddrLValue(emission.getAllocatedAddress(), type);
1837 LValue lv = MakeAddrLValue(Loc, type);
1844 LValue lv = MakeAddrLValue(Loc, type);
1868 LValue lvalue, bool capturedByInit) {
2429 LValue lv = MakeAddrLValue(DeclPtr, Ty);
tools/clang/lib/CodeGen/CGDeclCXX.cpp 37 LValue lv = CGF.MakeAddrLValue(DeclPtr, type);
tools/clang/lib/CodeGen/CGExpr.cpp 245 LValue LV = MakeAddrLValue(Location, E->getType());
418 LValue CodeGenFunction::
449 LValue RefTempDst = MakeAddrLValue(Object, M->getType(),
572 LValue LV = MakeAddrLValue(Object, E->getType(), AlignmentSource::Decl);
595 LValue LV = EmitLValue(E);
988 EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
1129 LValue LV = EmitLValue(UO->getSubExpr());
1176 LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
1207 LValue CodeGenFunction::EmitCheckedLValue(const Expr *E, TypeCheckKind TCK) {
1208 LValue LV;
1243 LValue CodeGenFunction::EmitLValue(const Expr *E) {
1306 LValue LV = EmitLValue(cleanups->getSubExpr());
1312 return LValue::MakeAddr(Address(V, LV.getAlignment()), LV.getType(),
1524 llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue,
1666 LValue AtomicLValue =
1667 LValue::MakeAddr(Addr, Ty, getContext(), BaseInfo, TBAAInfo);
1745 LValue AtomicLValue =
1746 LValue::MakeAddr(Addr, Ty, getContext(), BaseInfo, TBAAInfo);
1764 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue,
1774 RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, SourceLocation Loc) {
1820 RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV,
1852 RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) {
1881 Address CodeGenFunction::EmitExtVectorElementLValue(LValue LV) {
1902 RValue CodeGenFunction::EmitLoadOfGlobalRegLValue(LValue LV) {
1927 void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
2024 void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
2092 LValue Dst) {
2162 void CodeGenFunction::EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst) {
2188 LValue &LV,
2292 static LValue EmitThreadPrivateVarDeclLValue(
2320 CodeGenFunction::EmitLoadOfReference(LValue RefLVal,
2333 LValue CodeGenFunction::EmitLoadOfReferenceLValue(LValue RefLVal) {
2333 LValue CodeGenFunction::EmitLoadOfReferenceLValue(LValue RefLVal) {
2352 LValue CodeGenFunction::EmitLoadOfPointerLValue(Address PtrAddr,
2360 static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
2388 LValue LV = VD->getType()->isReferenceType() ?
2420 static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
2428 static LValue EmitCapturedFieldLValue(CodeGenFunction &CGF, const FieldDecl *FD,
2431 LValue LV = CGF.MakeNaturalAlignAddrLValue(ThisValue, TagType);
2441 static LValue EmitGlobalNamedRegister(const VarDecl *VD, CodeGenModule &CGM) {
2460 return LValue::MakeGlobalReg(Address(Ptr, Alignment), VD->getType());
2514 LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
2576 LValue CapLVal =
2644 LValue LV = VD->getType()->isReferenceType() ?
2678 LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
2694 LValue LV = MakeAddrLValue(Addr, T, BaseInfo, TBAAInfo);
2709 LValue LV = EmitLValue(E->getSubExpr());
2726 LValue ElemLV = MakeAddrLValue(Component, T, LV.getBaseInfo(),
2733 LValue LV = EmitLValue(E->getSubExpr());
2745 LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
2750 LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
2755 LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
3321 LValue LV = EmitLValue(E);
3449 LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E,
3483 LValue LHS = EmitLValue(E->getBase());
3486 return LValue::MakeVectorElt(LHS.getAddress(), Idx, E->getBase()->getType(),
3494 LValue LV = EmitLValue(E->getBase());
3570 LValue ArrayLV;
3597 LValue LV = MakeAddrLValue(Addr, E->getType(), EltBaseInfo, EltTBAAInfo);
3612 LValue BaseLVal;
3646 LValue CodeGenFunction::EmitOMPArraySectionExpr(const OMPArraySectionExpr *E,
3772 LValue ArrayLV;
3799 LValue CodeGenFunction::
3802 LValue Base;
3842 return LValue::MakeExtVectorElt(Base.getAddress(), CV, type,
3853 return LValue::MakeExtVectorElt(Base.getExtVectorAddress(), CV, type,
3857 LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
3865 LValue BaseLV;
3885 LValue LV = EmitLValueForField(BaseLV, Field);
3898 LValue CodeGenFunction::EmitLValueForLambdaField(const FieldDecl *Field) {
3903 LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue, LambdaTagType);
3985 LValue CodeGenFunction::EmitLValueForField(LValue base,
3985 LValue CodeGenFunction::EmitLValueForField(LValue base,
4018 return LValue::MakeBitfield(Addr, Info, fieldType, FieldBaseInfo,
4107 LValue RefLVal =
4128 LValue LV = MakeAddrLValue(addr, FieldType, FieldBaseInfo, FieldTBAAInfo);
4138 LValue
4139 CodeGenFunction::EmitLValueForFieldInitialization(LValue Base,
4162 LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
4173 LValue Result = MakeAddrLValue(DeclPtr, E->getType(), AlignmentSource::Decl);
4181 LValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) {
4194 static Optional<LValue> EmitLValueOrThrowExpression(CodeGenFunction &CGF,
4204 LValue CodeGenFunction::
4240 Optional<LValue> lhs =
4254 Optional<LValue> rhs =
4290 LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
4349 LValue LV = EmitLValue(E->getSubExpr());
4369 LValue LV = EmitLValue(E->getSubExpr());
4389 LValue LV = EmitLValue(E->getSubExpr());
4416 LValue LV = EmitLValue(E->getSubExpr());
4429 LValue LV = EmitLValue(E->getSubExpr());
4438 LValue LV = EmitLValue(E->getSubExpr());
4451 LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) {
4456 LValue
4460 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
4484 RValue CodeGenFunction::EmitRValueForField(LValue LV,
4488 LValue FieldLV = EmitLValueForField(LV, FD);
4607 LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
4641 LValue LV = EmitCheckedLValue(E->getLHS(), TCK_Store);
4657 LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
4671 LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
4676 LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
4684 LValue
4694 LValue CodeGenFunction::EmitCXXUuidofLValue(const CXXUuidofExpr *E) {
4699 LValue
4708 LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
4722 LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
4733 LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
4741 LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
4752 LValue BaseLV = EmitLValue(BaseExpr);
4758 LValue LV =
4765 LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
4957 LValue CodeGenFunction::
4985 LValue lvalue = MakeAddrLValue(addr, type, AlignmentSource::Decl);
5010 LValue LV;
5046 LValue LV = CGF.MakeAddrLValue(slot.getAddress(), ov->getType(),
5092 LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) {
tools/clang/lib/CodeGen/CGExprAgg.cpp 80 void EmitFinalDestCopy(QualType type, const LValue &src,
191 LValue LV = CGF.EmitPseudoObjectLValue(E);
200 void EmitInitializationToLValue(Expr *E, LValue Address);
201 void EmitNullInitializationToLValue(LValue Address);
219 LValue LV = CGF.EmitLValue(E);
312 LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type);
317 void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src,
327 LValue DstLV = CGF.MakeAddrLValue(
374 LValue DestLV = CGF.MakeAddrLValue(dest.getAddress(), type);
375 LValue SrcLV = CGF.MakeAddrLValue(src.getAddress(), type);
387 LValue Array = CGF.EmitLValue(E->getSubExpr());
412 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
413 LValue Start = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
427 LValue EndOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
559 LValue elementLV =
606 LValue elementLV =
687 LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(),
724 LValue SourceLV = CGF.EmitLValue(E->getSubExpr());
1048 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1052 LValue FieldLV = CGF.EmitLValueForFieldInitialization(
1068 LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
1156 LValue LHS = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
1174 LValue LHS = CGF.EmitLValue(E->getLHS());
1292 LValue SlotLV = CGF.MakeAddrLValue(Slot.getAddress(), E->getType());
1304 LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField);
1389 AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {
1429 void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
1479 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1558 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field);
1589 LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, field);
1696 LValue elementLV =
1734 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1863 LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
1866 LValue LV = MakeAddrLValue(Temp, E->getType());
1914 void CodeGenFunction::EmitAggregateCopy(LValue Dest, LValue Src, QualType Ty,
1914 void CodeGenFunction::EmitAggregateCopy(LValue Dest, LValue Src, QualType Ty,
tools/clang/lib/CodeGen/CGExprCXX.cpp 135 LValue BaseLV = EmitLValue(BaseExpr);
257 LValue This;
290 LValue RHS = isa<CXXOperatorCallExpr>(CE)
tools/clang/lib/CodeGen/CGExprComplex.cpp 76 ComplexPairTy EmitLoadOfLValue(LValue LV, SourceLocation Loc);
80 void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit);
188 LValue LV = CGF.EmitLValue(E->getSubExpr());
253 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
305 LValue EmitBinAssignLValue(const BinaryOperator *E,
345 ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue,
371 void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, LValue lvalue,
465 LValue origLV = CGF.EmitLValue(Op);
472 LValue SourceLVal = CGF.EmitLValue(Op);
475 LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
885 LValue ComplexExprEmitter::
915 LValue LHS = CGF.EmitLValue(E->getLHS());
959 LValue LV = EmitCompoundAssignLValue(E, Func, Val);
972 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
984 LValue LHS = CGF.EmitLValue(E->getLHS());
994 LValue LV = EmitBinAssignLValue(E, Val);
1115 void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest,
1125 void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest,
1131 ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src,
1136 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
1156 LValue CodeGenFunction::
1163 LValue CodeGenFunction::
1168 LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
tools/clang/lib/CodeGen/CGExprScalar.cpp 253 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
254 LValue EmitCheckedLValue(const Expr *E, CodeGenFunction::TypeCheckKind TCK) {
261 Value *EmitLoadOfLValue(LValue LV, SourceLocation Loc) {
527 LValue LV = CGF.EmitObjCIsaExpr(E);
590 LValue LV = EmitLValue(E->getSubExpr());
594 LValue LV = EmitLValue(E->getSubExpr());
598 LValue LV = EmitLValue(E->getSubExpr());
602 LValue LV = EmitLValue(E->getSubExpr());
610 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
768 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
1977 LValue LV = CGF.MakeAddrLValue(Addr, DestTy);
1982 LValue SourceLVal = CGF.EmitLValue(E);
1985 LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
2350 ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
2824 LValue ScalarExprEmitter::EmitCompoundAssignLValue(
2842 LValue LHSLV = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
2944 LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);
3907 LValue LHS;
4472 EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
4477 LValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) {
4495 LValue CodeGenFunction::EmitCompoundAssignmentLValue(
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp 544 LValue DstLV, SrcLV;
549 LValue DstBase = this->CGF->MakeAddrLValue(
553 LValue SrcBase = this->CGF->MakeAddrLValue(
707 LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
770 LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
774 LValue DstLV = CGF->MakeAddrLValue(Addrs[DstIdx], QT);
807 void CodeGenFunction::defaultInitNonTrivialCStructVar(LValue Dst) {
850 void CodeGenFunction::callCStructDefaultConstructor(LValue Dst) {
874 void CodeGenFunction::callCStructDestructor(LValue Dst) {
885 void CodeGenFunction::callCStructCopyConstructor(LValue Dst, LValue Src) {
885 void CodeGenFunction::callCStructCopyConstructor(LValue Dst, LValue Src) {
897 void CodeGenFunction::callCStructCopyAssignmentOperator(LValue Dst, LValue Src
897 void CodeGenFunction::callCStructCopyAssignmentOperator(LValue Dst, LValue Src
910 void CodeGenFunction::callCStructMoveConstructor(LValue Dst, LValue Src) {
910 void CodeGenFunction::callCStructMoveConstructor(LValue Dst, LValue Src) {
922 void CodeGenFunction::callCStructMoveAssignmentOperator(LValue Dst, LValue Src
922 void CodeGenFunction::callCStructMoveAssignmentOperator(LValue Dst, LValue Src
tools/clang/lib/CodeGen/CGObjC.cpp 133 LValue LV = MakeNaturalAlignAddrLValue(Constant, IdTy);
167 LValue LV = MakeAddrLValue(Builder.CreateConstArrayGEP(Objects, i),
178 LValue KeyLV = MakeAddrLValue(Builder.CreateConstArrayGEP(Keys, i),
185 LValue ValueLV = MakeAddrLValue(Builder.CreateConstArrayGEP(Objects, i),
499 LValue lvalue = EmitLValue(lvalueExpr);
711 LValue lvalue, QualType type);
1056 LValue LV = EmitLValueForIvar(TypeOfSelfObject(), LoadObjCSelf(), ivar, 0);
1145 LValue LV = EmitLValueForIvar(TypeOfSelfObject(), LoadObjCSelf(), ivar, 0);
1340 LValue ivarLValue =
1518 LValue lvalue
1584 LValue LV = EmitLValueForIvar(TypeOfSelfObject(),
1789 LValue elementLValue;
2300 llvm::Value *CodeGenFunction::EmitARCStoreStrong(LValue dst,
2728 LValue lv = CGF.EmitLValue(e);
3063 LValue lvalue =
3227 LValue lvalue,
3378 std::pair<LValue,llvm::Value*>
3391 LValue lvalue = EmitLValue(e->getLHS());
3397 std::pair<LValue,llvm::Value*>
3414 LValue lvalue = EmitLValue(e->getLHS());
3428 std::pair<LValue,llvm::Value*>
3431 LValue lvalue = EmitLValue(e->getLHS());
tools/clang/lib/CodeGen/CGObjCGNU.cpp 647 LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy,
4037 LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF,
tools/clang/lib/CodeGen/CGObjCMac.cpp 1386 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1694 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
4897 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
7049 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
tools/clang/lib/CodeGen/CGObjCRuntime.cpp 52 LValue CGObjCRuntime::EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF,
70 LValue LV = CGF.MakeNaturalAlignAddrLValue(V, IvarTy);
112 return LValue::MakeBitfield(Addr, *Info, IvarTy,
tools/clang/lib/CodeGen/CGObjCRuntime.h 85 LValue EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF,
263 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 74 virtual LValue getThreadIDVariableLValue(CodeGenFunction &CGF);
146 LValue PartIdLVal = CGF.EmitLoadOfPointerLValue(
163 LValue PartIdLVal = CGF.EmitLoadOfPointerLValue(
196 LValue getThreadIDVariableLValue(CodeGenFunction &CGF) override;
269 LValue getThreadIDVariableLValue(CodeGenFunction &CGF) override {
833 LValue LV = CGF.MakeNaturalAlignAddrLValue(GV, Ty);
943 LValue ReductionCodeGen::emitSharedLValue(CodeGenFunction &CGF, const Expr *E) {
947 LValue ReductionCodeGen::emitSharedLValueUB(CodeGenFunction &CGF,
955 CodeGenFunction &CGF, unsigned N, Address PrivateAddr, LValue SharedLVal,
990 LValue First = emitSharedLValue(CGF, ClausesData[N].Ref);
991 LValue Second = emitSharedLValueUB(CGF, ClausesData[N].Ref);
1053 CodeGenFunction &CGF, unsigned N, Address PrivateAddr, LValue SharedLVal,
1104 static LValue loadToBegin(CodeGenFunction &CGF, QualType BaseTy, QualType ElTy,
1105 LValue BaseLV) {
1112 LValue RefLVal = CGF.MakeAddrLValue(BaseLV.getAddress(), BaseTy);
1177 LValue OriginalBaseLValue = CGF.EmitLValue(DE);
1178 LValue BaseLValue =
1204 LValue CGOpenMPRegionInfo::getThreadIDVariableLValue(CodeGenFunction &CGF) {
1223 LValue CGOpenMPTaskOutlinedRegionInfo::getThreadIDVariableLValue(
1660 LValue Base = CGF.MakeAddrLValue(LocValue, IdentQTy);
1662 LValue PSource =
1704 LValue LVal = OMPRegionInfo->getThreadIDVariableLValue(CGF);
4530 LValue TDBase = CGF.EmitLoadOfPointerLValue(
4535 LValue Base =
4539 LValue PartIdLVal = CGF.EmitLValueForField(Base, *PartIdFI);
4543 LValue SharedsLVal = CGF.EmitLValueForField(Base, *SharedsFI);
4551 LValue PrivatesLVal = CGF.EmitLValueForField(TDBase, *PrivatesFI);
4568 LValue LBLVal = CGF.EmitLValueForField(Base, *LBFI);
4571 LValue UBLVal = CGF.EmitLValueForField(Base, *UBFI);
4574 LValue StLVal = CGF.EmitLValueForField(Base, *StFI);
4577 LValue LILVal = CGF.EmitLValueForField(Base, *LIFI);
4580 LValue RLVal = CGF.EmitLValueForField(Base, *RFI);
4628 LValue Base = CGF.EmitLoadOfPointerLValue(
4639 LValue FieldLValue = CGF.EmitLValueForField(Base, Field);
4727 LValue Base = CGF.EmitLoadOfPointerLValue(
4733 LValue FieldLVal = CGF.EmitLValueForField(Base, Field);
4735 LValue RefLVal =
4737 LValue RefLoadLVal = CGF.EmitLoadOfPointerLValue(
4749 Address KmpTaskSharedsPtr, LValue TDBase,
4756 LValue PrivatesBase = CGF.EmitLValueForField(TDBase, *FI);
4762 LValue SrcBase;
4782 LValue PrivateLValue = CGF.EmitLValueForField(PrivatesBase, *FI);
4787 LValue SharedRefLValue;
4910 LValue TDBase = CGF.EmitLoadOfPointerLValue(
4916 LValue Base = CGF.EmitLValueForField(
4918 LValue LILVal = CGF.EmitLValueForField(Base, *LIFI);
4928 LValue TDBase = CGF.EmitLoadOfPointerLValue(
4931 LValue Base = CGF.EmitLValueForField(
5115 LValue Base = CGF.MakeNaturalAlignAddrLValue(NewTaskNewTaskTTy,
5117 LValue TDBase =
5130 LValue Dest = CGF.MakeAddrLValue(KmpTaskSharedsPtr, SharedsTy);
5131 LValue Src = CGF.MakeAddrLValue(Shareds, SharedsTy);
5158 LValue Data1LV = CGF.EmitLValueForField(TDBase, *FI);
5159 LValue DestructorsLV = CGF.EmitLValueForField(
5167 LValue Data2LV = CGF.EmitLValueForField(
5169 LValue PriorityLV = CGF.EmitLValueForField(
5195 LValue TDBase = Result.TDBase;
5229 LValue Addr = CGF.EmitLValue(E);
5234 LValue UpAddrLVal =
5245 LValue Base = CGF.MakeAddrLValue(
5249 LValue BaseAddrLVal = CGF.EmitLValueForField(
5255 LValue LenLVal = CGF.EmitLValueForField(
5277 LValue FlagsLVal = CGF.EmitLValueForField(
5310 LValue PartIdLVal = CGF.EmitLValueForField(TDBase, *PartIdFI);
5401 LValue LBLVal = CGF.EmitLValueForField(
5408 LValue UBLVal = CGF.EmitLValueForField(
5415 LValue StLVal = CGF.EmitLValueForField(
5423 LValue RedLVal = CGF.EmitLValueForField(
5892 LValue X = CGF.EmitLValue(XExpr);
6032 LValue SharedLVal;
6229 LValue ElemLVal = CGF.MakeNaturalAlignAddrLValue(GEP, RDType);
6231 LValue SharedLVal = CGF.EmitLValueForField(ElemLVal, SharedFD);
6249 LValue SizeLVal = CGF.EmitLValueForField(ElemLVal, SizeFD);
6252 LValue InitLVal = CGF.EmitLValueForField(ElemLVal, InitFD);
6258 LValue FiniLVal = CGF.EmitLValueForField(ElemLVal, FiniFD);
6265 LValue CombLVal = CGF.EmitLValueForField(ElemLVal, CombFD);
6271 LValue FlagsLVal = CGF.EmitLValueForField(ElemLVal, FlagsFD);
6321 LValue SharedLVal) {
8175 LValue VDLVal = CGF.MakeAddrLValue(
8181 LValue ThisLVal =
8183 LValue ThisLValVal = CGF.EmitLValueForField(VDLVal, ThisCapture);
8201 LValue VarLVal = CGF.EmitLValueForFieldInitialization(VDLVal, It->second);
8203 LValue VarLValVal = CGF.EmitLValueForField(VDLVal, It->second);
10839 LValue DimsLVal = CGF.MakeAddrLValue(
10842 LValue UpperLVal = CGF.EmitLValueForField(
10850 LValue StrideLVal = CGF.EmitLValueForField(
11338 LValue SharedLVal) {
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 130 SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
130 SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
137 LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
139 LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);
146 Address PrivateAddr, LValue SharedLVal,
171 LValue SharedLVal,
186 LValue getSharedLValue(unsigned N) const { return SharedAddresses[N].first; }
770 LValue TDBase;
1399 LValue SharedLVal);
2090 LValue SharedLVal) override;
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 2285 LValue Base =
2290 LValue SecBase;
2306 LValue ParLVal =
2310 LValue VarAddr = CGF.EmitLValueForField(Base, Rec.second.FD);
2334 LValue SecVarAddr = CGF.EmitLValueForField(SecBase, SecIt->second.FD);
2381 LValue Base = CGF.MakeAddrLValue(GlobalRecCastAddr, VD->getType(),
2766 LValue CounterLVal = CGF.MakeAddrLValue(Counter, Int32Ty);
3687 LValue GlobLVal = CGF.EmitLValueForField(
3784 LValue GlobLVal = CGF.EmitLValueForField(
3888 LValue GlobLVal = CGF.EmitLValueForField(
3984 LValue GlobLVal = CGF.EmitLValueForField(
4863 LValue VDLVal;
4873 LValue ThisLVal =
4886 LValue VarLVal = CGF.EmitLValueForFieldInitialization(VDLVal, It->second);
tools/clang/lib/CodeGen/CGStmt.cpp 1040 LValue Dest = MakeAddrLValue(ReturnValue, Ty);
1041 LValue Src = MakeAddrLValue(RV.getAggregateAddress(), Ty);
1819 LValue InputValue, QualType InputType,
1876 LValue Dest = EmitLValue(InputExpr);
1992 std::vector<LValue> ResultRegDests;
2031 LValue Dest = EmitLValue(OutExpr);
2130 LValue ReturnSlot = MakeAddrLValue(ReturnValue, FnRetTy);
2328 LValue Dest = ResultRegDests[i];
2349 LValue CodeGenFunction::InitCapturedStruct(const CapturedStmt &S) {
2354 LValue SlotLV =
2361 LValue LV = EmitLValueForFieldInitialization(SlotLV, *CurField);
2377 LValue CapStruct = InitCapturedStruct(S);
2392 LValue CapStruct = InitCapturedStruct(S);
2431 LValue Base = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(),
2446 LValue ThisLValue = EmitLValueForField(Base, FD);
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 249 LValue CodeGenFunction::EmitOMPSharedLValue(const Expr *E) {
309 LValue DstLV = MakeAddrLValue(DstAddr, Ctx.getUIntPtrType());
314 LValue SrcLV =
333 LValue AddrLV) {
505 LValue ArgLVal = CGF.MakeAddrLValue(LocalAddr, Args[Cnt]->getType(),
612 LValue LV = WrapperCGF.MakeAddrLValue(
622 LValue LV = WrapperCGF.MakeAddrLValue(WrapperCGF.GetAddrOfLocalVar(Arg),
707 LValue Dest = MakeAddrLValue(DestAddr, OriginalType);
708 LValue Src = MakeAddrLValue(SrcAddr, OriginalType);
795 LValue OriginalLVal;
826 LValue Dest =
1763 static LValue EmitOMPHelperVar(CodeGenFunction &CGF,
2140 static std::pair<LValue, LValue>
2140 static std::pair<LValue, LValue>
2144 LValue LB =
2146 LValue UB =
2155 LValue PrevLB = CGF.EmitLValue(LS.getPrevLowerBoundVariable());
2156 LValue PrevUB = CGF.EmitLValue(LS.getPrevUpperBoundVariable());
2205 LValue LB =
2210 LValue UB =
2367 std::pair<LValue, LValue> Bounds = CodeGenLoopBounds(*this, S);
2367 std::pair<LValue, LValue> Bounds = CodeGenLoopBounds(*this, S);
2368 LValue LB = Bounds.first;
2369 LValue UB = Bounds.second;
2370 LValue ST =
2372 LValue IL =
2535 static std::pair<LValue, LValue>
2535 static std::pair<LValue, LValue>
2538 LValue LB =
2540 LValue UB =
2598 static LValue createSectionLVal(CodeGenFunction &CGF, QualType Ty,
2601 LValue LVal = CGF.MakeAddrLValue(CGF.CreateMemTemp(Ty, Name), Ty);
2617 LValue LB = createSectionLVal(CGF, KmpInt32Ty, ".omp.sections.lb.",
2622 LValue UB =
2624 LValue ST = createSectionLVal(CGF, KmpInt32Ty, ".omp.sections.st.",
2626 LValue IL = createSectionLVal(CGF, KmpInt32Ty, ".omp.sections.il.",
2629 LValue IV = createSectionLVal(CGF, KmpInt32Ty, ".omp.sections.iv.");
3418 LValue LB = EmitOMPHelperVar(
3423 LValue UB = EmitOMPHelperVar(
3428 LValue ST =
3430 LValue IL =
3680 LValue LVal, RValue RVal) {
3691 void CodeGenFunction::emitOMPSimpleStore(LValue LVal, RValue RVal,
3715 LValue XLValue = CGF.EmitLValue(X);
3716 LValue VLValue = CGF.EmitLValue(V);
3747 static std::pair<bool, RValue> emitOMPAtomicRMW(CodeGenFunction &CGF, LValue X,
3842 LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
3879 LValue XLValue = CGF.EmitLValue(X);
3928 LValue VLValue = CGF.EmitLValue(V);
3929 LValue XLValue = CGF.EmitLValue(X);
5185 LValue GlobLVal = CGF.EmitLValue(E);
tools/clang/lib/CodeGen/CGValue.h 366 static LValue MakeAddr(Address address, QualType type, ASTContext &Context,
371 LValue R;
379 static LValue MakeVectorElt(Address vecAddress, llvm::Value *Idx,
382 LValue R;
391 static LValue MakeExtVectorElt(Address vecAddress, llvm::Constant *Elts,
394 LValue R;
409 static LValue MakeBitfield(Address Addr, const CGBitFieldInfo &Info,
412 LValue R;
421 static LValue MakeGlobalReg(Address Reg, QualType type) {
422 LValue R;
539 static AggValueSlot forLValue(const LValue &LV,
tools/clang/lib/CodeGen/CodeGenFunction.cpp 160 LValue CodeGenFunction::MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T) {
164 return LValue::MakeAddr(Address(V, Alignment), T, getContext(), BaseInfo,
170 LValue
963 LValue ThisFieldLValue = EmitLValueForLambdaField(LambdaThisCaptureField);
tools/clang/lib/CodeGen/CodeGenFunction.h 277 typedef llvm::function_ref<std::pair<LValue, LValue>(
277 typedef llvm::function_ref<std::pair<LValue, LValue>(
1111 const LValue &lv) {
1187 LValue lvalue)
1381 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1860 void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV) {
1899 void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init);
2123 LValue MakeAddrLValue(Address Addr, QualType T,
2125 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2129 LValue MakeAddrLValue(Address Addr, QualType T, LValueBaseInfo BaseInfo,
2131 return LValue::MakeAddr(Addr, T, getContext(), BaseInfo, TBAAInfo);
2134 LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2136 return LValue::MakeAddr(Address(V, Alignment), T, getContext(),
2140 LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2142 return LValue::MakeAddr(Address(V, Alignment), T, getContext(),
2146 LValue MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T);
2147 LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T);
2156 Address EmitLoadOfReference(LValue RefLVal,
2159 LValue EmitLoadOfReferenceLValue(LValue RefLVal);
2159 LValue EmitLoadOfReferenceLValue(LValue RefLVal);
2160 LValue EmitLoadOfReferenceLValue(Address RefAddr, QualType RefTy,
2163 LValue RefLVal = MakeAddrLValue(RefAddr, RefTy, LValueBaseInfo(Source),
2171 LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy);
2308 void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2339 void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy) {
2339 void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy) {
2344 void EmitAggregateCopyCtor(LValue Dest, LValue Src,
2344 void EmitAggregateCopyCtor(LValue Dest, LValue Src,
2356 void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy,
2356 void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy,
2370 LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e);
2648 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
2650 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
2674 void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2902 LValue EmitCoawaitLValue(const CoawaitExpr *E);
2906 LValue EmitCoyieldLValue(const CoyieldExpr *E);
2972 LValue InitCapturedStruct(const CapturedStmt &S);
2979 void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy,
3022 LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
3271 LValue EmitOMPSharedLValue(const Expr *E);
3346 LValue EmitUnsupportedLValue(const Expr *E,
3365 LValue EmitLValue(const Expr *E);
3370 LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK);
3375 void EmitAtomicInit(Expr *E, LValue lvalue);
3377 bool LValueIsSuitableForInlineAtomic(LValue Src);
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,
3392 LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
3399 void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO,
3438 llvm::Value *EmitLoadOfScalar(LValue lvalue, SourceLocation Loc);
3461 void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false);
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,
3488 LValue EmitComplexAssignmentLValue(const BinaryOperator *E);
3489 LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E);
3490 LValue EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E,
3494 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
3495 LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E);
3497 LValue EmitCallExprLValue(const CallExpr *E);
3499 LValue EmitVAArgExprLValue(const VAArgExpr *E);
3500 LValue EmitDeclRefLValue(const DeclRefExpr *E);
3501 LValue EmitStringLiteralLValue(const StringLiteral *E);
3502 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
3503 LValue EmitPredefinedLValue(const PredefinedExpr *E);
3504 LValue EmitUnaryOpLValue(const UnaryOperator *E);
3505 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E,
3507 LValue EmitOMPArraySectionExpr(const OMPArraySectionExpr *E,
3509 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
3510 LValue EmitMemberExpr(const MemberExpr *E);
3511 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
3512 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
3513 LValue EmitInitListLValue(const InitListExpr *E);
3514 LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E);
3515 LValue EmitCastLValue(const CastExpr *E);
3516 LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
3517 LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e);
3519 Address EmitExtVectorElementLValue(LValue V);
3521 RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc);
3545 LValue getReferenceLValue(CodeGenFunction &CGF, Expr *refExpr) const {
3563 LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e);
3567 LValue EmitLValueForField(LValue Base, const FieldDecl* Field);
3567 LValue EmitLValueForField(LValue Base, const FieldDecl* Field);
3568 LValue EmitLValueForLambdaField(const FieldDecl *Field);
3573 LValue EmitLValueForFieldInitialization(LValue Base,
3573 LValue EmitLValueForFieldInitialization(LValue Base,
3576 LValue EmitLValueForIvar(QualType ObjectTy,
3580 LValue EmitCXXConstructLValue(const CXXConstructExpr *E);
3581 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E);
3582 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E);
3583 LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E);
3585 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
3586 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
3587 LValue EmitStmtExprLValue(const StmtExpr *E);
3588 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E);
3589 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E);
3666 void defaultInitNonTrivialCStructVar(LValue Dst);
3667 void callCStructDefaultConstructor(LValue Dst);
3668 void callCStructDestructor(LValue Dst);
3669 void callCStructCopyConstructor(LValue Dst, LValue Src);
3669 void callCStructCopyConstructor(LValue Dst, LValue Src);
3670 void callCStructMoveConstructor(LValue Dst, LValue Src);
3670 void callCStructMoveConstructor(LValue Dst, LValue Src);
3671 void callCStructCopyAssignmentOperator(LValue Dst, LValue Src);
3671 void callCStructCopyAssignmentOperator(LValue Dst, LValue Src);
3672 void callCStructMoveAssignmentOperator(LValue Dst, LValue Src);
3672 void callCStructMoveAssignmentOperator(LValue Dst, LValue Src);
3818 llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value,
3838 std::pair<LValue,llvm::Value*>
3840 std::pair<LValue,llvm::Value*>
3842 std::pair<LValue,llvm::Value*>
3907 LValue EmitAggExprToLValue(const Expr *E);
3921 void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit);
3924 void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit);
3927 ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc);
4067 void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc);
4176 void ExpandTypeFromArgs(QualType Ty, LValue Dst,
4190 LValue InputValue, QualType InputType,
tools/clang/lib/CodeGen/CodeGenModule.h 744 TBAAAccessInfo getTBAAInfoForSubobject(LValue Base, QualType AccessType) {
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 366 LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
2716 LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2725 LValue LV;
4194 LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType);
4195 LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType);
4225 LValue Dest = CGF.MakeAddrLValue(ParamAddr, CatchType);
4226 LValue Src = CGF.MakeAddrLValue(adjustedExn, CatchType);
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 392 LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
2341 LValue MicrosoftCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
tools/clang/lib/CodeGen/TargetInfo.cpp 1131 void addReturnRegisterOutputs(CodeGenFunction &CGF, LValue ReturnValue,
1135 std::vector<LValue> &ResultRegDests,
1203 CodeGenFunction &CGF, LValue ReturnSlot, std::string &Constraints,
1206 std::vector<LValue> &ResultRegDests, std::string &AsmString,
tools/clang/lib/CodeGen/TargetInfo.h 135 CodeGen::CodeGenFunction &CGF, CodeGen::LValue ReturnValue,
138 std::vector<CodeGen::LValue> &ResultRegDests, std::string &AsmString,
usr/include/c++/7.4.0/bits/alloc_traits.h 387 using allocator_type = allocator<_Tp>;
389 using value_type = _Tp;
392 using pointer = _Tp*;
395 using const_pointer = const _Tp*;
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
486 destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h 108 class allocator: public __allocator_base<_Tp>
113 typedef _Tp* pointer;
114 typedef const _Tp* const_pointer;
115 typedef _Tp& reference;
116 typedef const _Tp& const_reference;
117 typedef _Tp value_type;
137 allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h 46 inline _GLIBCXX_CONSTEXPR _Tp*
47 __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
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
104 : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
105 is_copy_constructible<_Tp>>::type { };
usr/include/c++/7.4.0/bits/stl_construct.h 74 _Construct(_T1* __p, _Args&&... __args)
74 _Construct(_T1* __p, _Args&&... __args)
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
204 allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_iterator.h 1224 __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 181 typedef _Tp value_type;
183 typedef _Tp* pointer;
184 typedef _Tp& reference;
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)) { }
379 __and_<is_copy_assignable<_T1>,
380 is_copy_assignable<_T2>>::value,
390 __and_<is_move_assignable<_T1>,
391 is_move_assignable<_T2>>::value,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
403 is_assignable<_T2&, const _U2&>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
405 operator=(const pair<_U1, _U2>& __p)
405 operator=(const pair<_U1, _U2>& __p)
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
414 is_assignable<_T2&, _U2&&>>::value,
414 is_assignable<_T2&, _U2&&>>::value,
416 operator=(pair<_U1, _U2>&& __p)
416 operator=(pair<_U1, _U2>&& __p)
524 make_pair(_T1&& __x, _T2&& __y)
usr/include/c++/7.4.0/bits/stl_uninitialized.h 288 _ForwardIterator __result, allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_vector.h 77 rebind<_Tp>::other _Tp_alloc_type;
216 class vector : protected _Vector_base<_Tp, _Alloc>
227 typedef _Vector_base<_Tp, _Alloc> _Base;
232 typedef _Tp value_type;
919 _Tp*
923 const _Tp*
1483 _M_realloc_insert(iterator __position, _Args&&... __args);
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 63 typedef _Tp* pointer;
64 typedef const _Tp* const_pointer;
65 typedef _Tp& reference;
66 typedef const _Tp& const_reference;
67 typedef _Tp value_type;
111 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
130 { return size_t(-1) / sizeof(_Tp); }
135 construct(_Up* __p, _Args&&... __args)
135 construct(_Up* __p, _Args&&... __args)
136 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
140 destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/tuple 125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
159 static constexpr _Head&
162 static constexpr const _Head&
194 static constexpr _Head&
197 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
248 const _Head& __head, const _Tail&... __tail)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
1078 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1241 operator=(const pair<_U1, _U2>& __in)
1250 operator=(pair<_U1, _U2>&& __in)
1252 this->_M_head(*this) = std::forward<_U1>(__in.first);
1588 constexpr tuple<_Elements&...>
1589 tie(_Elements&... __args) noexcept
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
1142 : public is_constructible<_Tp, const _Tp&>
1142 : public is_constructible<_Tp, const _Tp&>
1148 : public __is_copy_constructible_impl<_Tp>
1160 : public is_constructible<_Tp, _Tp&&>
1160 : public is_constructible<_Tp, _Tp&&>
1166 : public __is_move_constructible_impl<_Tp>
1215 : public __and_<is_constructible<_Tp, _Args...>,
1216 __is_nt_constructible_impl<_Tp, _Args...>>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1252 : public __is_nothrow_move_constructible_impl<_Tp>
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; };
2131 typedef _Tp __type;