Lines Matching full:address
167 Address ReturnValue;
230 /// \brief The base address of the captured record, passed in as the first
331 SmallVector<Address, 1> SEHCodeSlotStack;
414 "Cleanup will be allocated on misaligned address");
426 /// given address. Does nothing if T is not a C++ class type with a
428 void PushDestructorCleanup(QualType T, Address Addr);
432 /// the given address.
433 void PushDestructorCleanup(const CXXDestructorDecl *Dtor, Address Addr);
563 typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
582 /// \a PrivateGen returns an address of the generated private variable.
587 llvm::function_ref<Address()> PrivateGen) {
598 SavedLocals.insert({LocalVD, Address::invalid()});
602 Address Addr = PrivateGen();
605 Address Temp = CGF.CreateMemTemp(VarTy);
738 void setBeforeOutermostConditional(llvm::Value *value, Address addr) {
910 /// with an indirect branch. Every time we see the address of a label taken,
1022 FieldConstructionScope(CodeGenFunction &CGF, Address This)
1032 Address OldCXXDefaultInitExprThis;
1067 Address CXXDefaultInitExprThis = Address::invalid();
1129 Address getExceptionSlot();
1130 Address getEHSelectorSlot();
1137 Address getNormalCleanupDestSlot();
1164 typedef void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty);
1167 Address arrayEndPointer,
1178 Address addr, QualType type);
1180 Address addr, QualType type);
1181 void pushDestroy(CleanupKind kind, Address addr, QualType type,
1183 void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr,
1189 void pushStackRestore(CleanupKind kind, Address SPMem);
1190 void emitDestroy(Address addr, QualType type, Destroyer *destroyer,
1192 llvm::Function *generateDestroyHelper(Address addr, QualType type,
1281 Address LoadBlockStruct();
1282 Address GetAddrOfBlockDecl(const VarDecl *var, bool ByRef);
1286 Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V,
1288 Address emitBlockByrefAddress(Address baseAddr,
1383 llvm::Value *GetVTablePtr(Address This, llvm::Type *VTableTy,
1393 /// \brief Derived is the presumed address of an object of type T after a
1551 LValue MakeAddrLValue(Address Addr, QualType T,
1559 return LValue::MakeAddr(Address(V, Alignment), T, getContext(),
1571 Address EmitLoadOfReference(Address Ref, const ReferenceType *RefTy,
1573 LValue EmitLoadOfReferenceLValue(Address Ref, const ReferenceType *RefTy);
1580 Address CreateTempAlloca(llvm::Type *Ty, CharUnits align,
1590 /// not hand this address off to arbitrary IRGen routines, and especially
1593 Address CreateDefaultAlignTempAlloca(llvm::Type *Ty,
1599 /// The address should be something that was returned from one of
1603 void InitTempAlloca(Address Alloca, llvm::Value *Value);
1613 Address CreateIRTemp(QualType T, const Twine &Name = "tmp");
1617 Address CreateMemTemp(QualType T, const Twine &Name = "tmp");
1618 Address CreateMemTemp(QualType T, CharUnits Align, const Twine &Name = "tmp");
1630 /// Emit a cast to void* in the appropriate address space.
1650 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
1652 Address EmitVAListRef(const Expr *E);
1657 Address EmitMSVAListRef(const Expr *E);
1665 void EmitAnyExprToMem(const Expr *E, Address Location,
1668 void EmitAnyExprToExn(const Expr *E, Address Addr);
1688 void EmitAggregateAssign(Address DestPtr, Address SrcPtr,
1694 void EmitAggregateCopyCtor(Address DestPtr, Address SrcPtr,
1706 void EmitAggregateCopy(Address DestPtr, Address SrcPtr,
1710 /// GetAddrOfLocalVar - Return the address of a local variable.
1711 Address GetAddrOfLocalVar(const VarDecl *VD) {
1750 void EmitNullInitialization(Address DestPtr, QualType Ty);
1768 Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr);
1774 Address &addr);
1795 Address LoadCXXThisAddress();
1808 Address
1809 GetAddressOfDirectBaseInCompleteClass(Address Value,
1817 /// load of 'this' and returns address of the base class.
1818 Address GetAddressOfBaseClass(Address Value,
1824 Address GetAddressOfDerivedClass(Address Value,
1850 Address This, const CXXConstructExpr *E);
1854 void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This);
1857 void EmitVTableAssumptionLoad(const VPtr &vptr, Address This);
1860 Address This, Address Src,
1865 Address ArrayPtr,
1871 Address ArrayPtr,
1879 Address This);
1882 llvm::Type *ElementTy, Address NewPtr,
1887 Address Ptr);
1902 llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE);
1903 Address EmitCXXUuidofExpr(const CXXUuidofExpr *E);
1942 /// \brief Emit a check that \p V is the address of storage of the
1984 llvm::Value *Address);
2000 /// The address of the alloca. Invalid if the variable was emitted
2002 Address Addr;
2017 AutoVarEmission(Invalid) : Variable(nullptr), Addr(Address::invalid()) {}
2020 : Variable(&variable), Addr(Address::invalid()), NRVOFlag(nullptr),
2037 /// Returns the raw, allocated address, which is not necessarily
2038 /// the address of the object itself.
2039 Address getAllocatedAddress() const {
2043 /// Returns the address of the object within this declaration.
2046 Address getObjectAddress(CodeGenFunction &CGF) const {
2069 static ParamValue forIndirect(Address addr) {
2082 Address getIndirectAddress() const {
2084 return Address(Value, CharUnits::fromQuantity(Alignment));
2126 Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
2128 Address EmitCompoundStmtWithoutScope(const CompoundStmt &S,
2195 /// Recovers the address of a local in a parent function. ParentVar is the
2196 /// address of the variable used in the immediate parent function. It can
2200 Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF,
2201 Address ParentVar,
2210 Address GenerateCapturedStmtArgument(const CapturedStmt &S);
2218 /// \param DestAddr Address of the destination array.
2219 /// \param SrcAddr Address of the source array.
2224 Address DestAddr, Address SrcAddr, QualType OriginalType,
2225 const llvm::function_ref<void(Address, Address)> &CopyGen);
2229 /// \param DestAddr Destination address.
2230 /// \param SrcAddr Source address.
2238 Address DestAddr, Address SrcAddr,
2377 Address LB, Address UB, Address ST,
2378 Address IL, llvm::Value *Chunk);
2405 /// This can return one of two things: a simple address or a bitfield
2413 /// If this returns a normal address, and if the lvalue's C type is fixed
2422 /// that the address will be used to access the object.
2425 RValue convertTempToRValue(Address addr, QualType type,
2463 /// EmitLoadOfScalar - Load a scalar value from an address, taking
2466 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
2475 /// EmitLoadOfScalar - Load a scalar value from an address, taking
2481 /// EmitStoreOfScalar - Store a scalar value to an address, taking
2484 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
2491 /// EmitStoreOfScalar - Store a scalar value to an address, taking
2499 /// this method emits the address of the lvalue, then loads the result as an
2554 Address EmitExtVectorElementLValue(LValue V);
2558 Address EmitArrayToPointerDecay(const Expr *Array,
2603 /// if the Field is a reference, this will return the address of the reference
2604 /// and not the address of the value stored in the reference.
2695 Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
2733 Address PtrOp0, Address PtrOp1);
2777 void EmitARCInitWeak(Address addr, llvm::Value *value);
2778 void EmitARCDestroyWeak(Address addr);
2779 llvm::Value *EmitARCLoadWeak(Address addr);
2780 llvm::Value *EmitARCLoadWeakRetained(Address addr);
2781 llvm::Value *EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored);
2782 void EmitARCCopyWeak(Address dst, Address src);
2783 void EmitARCMoveWeak(Address dst, Address src);
2788 llvm::Value *EmitARCStoreStrongCall(Address addr, llvm::Value *value,
2793 void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise);
2878 Address emitAddrOfRealComponent(Address complex, QualType complexType);
2879 Address emitAddrOfImagComponent(Address complex, QualType complexType);
2915 Address Guard = Address::invalid());
2930 void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
2959 Address EmitFieldAnnotations(const FieldDecl *D, Address V);
3052 /// Set the address of a local variable.
3053 Address Addr) {
3183 /// miscompiled; for example, a placement new into the address of
3187 Address EmitPointerWithAlignment(const Expr *Addr,
3229 Address alloca =
3255 /// A specialization of DominatingValue for Address.
3256 template <> struct DominatingValue<Address> {
3257 typedef Address type;
3272 return Address(DominatingLLVMValue::restore(CGF, value.SavedValue),
