|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/clang/lib/CodeGen/Address.h 74 class ConstantAddress : public Address {
Declarations
tools/clang/lib/CodeGen/ABIInfo.h 31 class Address;
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 48 class Address;
References
gen/tools/clang/include/clang/Basic/arm_mve_builtin_cg.inc 16 Address Val0 = EmitPointerWithAlignment(E->getArg(0));
26 Address Val0 = EmitPointerWithAlignment(E->getArg(0));
169 Address Val2 = EmitPointerWithAlignment(E->getArg(2));
216 Address Val3 = EmitPointerWithAlignment(E->getArg(3));
247 Address Val13 = EmitPointerWithAlignment(E->getArg(3));
262 Address Val9 = EmitPointerWithAlignment(E->getArg(2));
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>;
123 is_trivially_copyable<ValueT>::value) {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
219 InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
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)...);
129 Ret operator()(Params ...params) const {
129 Ret operator()(Params ...params) const {
130 return callback(callable, std::forward<Params>(params)...);
include/llvm/ADT/SmallVector.h 75 AlignedCharArrayUnion<T> FirstEl;
114 using value_type = T;
115 using iterator = T *;
116 using const_iterator = const T *;
121 using reference = T &;
122 using const_reference = const T &;
123 using pointer = T *;
124 using const_pointer = const T *;
259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
264 static void destroy_range(T *, T *) {}
264 static void destroy_range(T *, T *) {}
299 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
302 void push_back(const T &Elt) {
305 memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
316 using SuperClass = SmallVectorTemplateBase<T>;
357 void resize(size_type N, const T &NV) {
374 LLVM_NODISCARD T pop_back_val() {
397 void append(size_type NumInputs, const T &Elt) {
405 void append(std::initializer_list<T> IL) {
412 void assign(size_type NumElts, const T &Elt) {
429 void assign(std::initializer_list<T> IL) {
467 iterator insert(iterator I, T &&Elt) {
497 iterator insert(iterator I, const T &Elt) {
526 iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
637 void insert(iterator I, std::initializer_list<T> IL) {
641 template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
820 AlignedCharArrayUnion<T> InlineElts[N];
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
846 explicit SmallVector(size_t Size, const T &Value = T())
865 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
884 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/Support/AlignOf.h 30 T t;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
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/ABIInfo.h 85 virtual CodeGen::Address EmitVAArg(CodeGen::CodeGenFunction &CGF,
86 CodeGen::Address VAListAddr,
93 virtual CodeGen::Address EmitMSVAArg(CodeGen::CodeGenFunction &CGF,
94 CodeGen::Address VAListAddr,
tools/clang/lib/CodeGen/Address.h 34 static Address invalid() { return Address(nullptr, CharUnits()); }
74 class ConstantAddress : public Address {
96 static bool isaImpl(Address addr) {
99 static ConstantAddress castImpl(Address addr) {
108 template <class U> inline U cast(CodeGen::Address addr) {
111 template <class U> inline bool isa(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGAtomic.cpp 150 Address getAtomicAddress() const {
154 Address getAtomicAddressAsAtomicIntPointer() const {
177 Address emitCastToAtomicIntPointer(Address Addr) const;
177 Address emitCastToAtomicIntPointer(Address Addr) const;
182 Address convertToAtomicIntPointer(Address Addr) const;
182 Address convertToAtomicIntPointer(Address Addr) const;
185 RValue convertAtomicTempToRValue(Address addr, AggValueSlot resultSlot,
201 Address addr = getAtomicAddress();
243 Address materializeRValue(RValue rvalue) const;
246 Address CreateTempAlloca() const;
289 Address AtomicInfo::CreateTempAlloca() const {
290 Address TempAlloca = CGF.CreateMemTemp(
358 Address Dest, Address Ptr,
358 Address Dest, Address Ptr,
359 Address Val1, Address Val2,
359 Address Val1, Address Val2,
408 bool IsWeak, Address Dest, Address Ptr,
408 bool IsWeak, Address Dest, Address Ptr,
409 Address Val1, Address Val2,
409 Address Val1, Address Val2,
491 static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, Address Dest,
492 Address Ptr, Address Val1, Address Val2,
492 Address Ptr, Address Val1, Address Val2,
492 Address Ptr, Address Val1, Address Val2,
655 static Address
657 Address DeclPtr = CGF.CreateMemTemp(E->getType(), ".atomictmp");
663 static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *Expr, Address Dest,
664 Address Ptr, Address Val1, Address Val2,
664 Address Ptr, Address Val1, Address Val2,
664 Address Ptr, Address Val1, Address Val2,
733 Address Ptr = Address(CGF.Builder.CreateBitCast(Val, IPtrTy), Align);
753 Address Val1 = Address::invalid();
753 Address Val1 = Address::invalid();
754 Address Val2 = Address::invalid();
754 Address Val2 = Address::invalid();
755 Address Dest = Address::invalid();
755 Address Dest = Address::invalid();
756 Address Ptr = EmitPointerWithAlignment(E->getPtr());
837 auto Temp = CreateMemTemp(Val1Ty, ".atomictmp");
1330 Address AtomicInfo::emitCastToAtomicIntPointer(Address addr) const {
1330 Address AtomicInfo::emitCastToAtomicIntPointer(Address addr) const {
1338 Address AtomicInfo::convertToAtomicIntPointer(Address Addr) const {
1338 Address AtomicInfo::convertToAtomicIntPointer(Address Addr) const {
1342 Address Tmp = CreateTempAlloca();
1351 RValue AtomicInfo::convertAtomicTempToRValue(Address addr,
1409 Address Temp = Address::invalid();
1409 Address Temp = Address::invalid();
1420 Address CastTemp = emitCastToAtomicIntPointer(Temp);
1445 Address Addr = getAtomicAddressAsAtomicIntPointer();
1490 Address TempAddr = Address::invalid();
1490 Address TempAddr = Address::invalid();
1509 return RValue::getAggregate(Address::invalid(), false);
1563 Address AtomicInfo::materializeRValue(RValue rvalue) const {
1595 Address Addr = materializeRValue(RVal);
1606 Address Addr = getAtomicAddressAsAtomicIntPointer();
1658 Address ExpectedAddr = materializeRValue(Expected);
1659 Address DesiredAddr = materializeRValue(Desired);
1684 Address DesiredAddr) {
1693 Address Ptr = Atomics.materializeRValue(OldRVal);
1741 Address ExpectedAddr = CreateTempAlloca();
1747 Address DesiredAddr = CreateTempAlloca();
1780 Address NewAtomicAddr = CreateTempAlloca();
1781 Address NewAtomicIntAddr = emitCastToAtomicIntPointer(NewAtomicAddr);
1798 RValue UpdateRVal, Address DesiredAddr) {
1827 Address ExpectedAddr = CreateTempAlloca();
1833 Address DesiredAddr = CreateTempAlloca();
1862 Address NewAtomicAddr = CreateTempAlloca();
1863 Address NewAtomicIntAddr = emitCastToAtomicIntPointer(NewAtomicAddr);
1936 Address srcAddr = atomics.materializeRValue(rvalue);
1957 Address addr =
tools/clang/lib/CodeGen/CGBlocks.cpp 37 CapturesNonExternalType(false), LocalAddress(Address::invalid()),
841 Address addr =
947 Address blockAddr = blockInfo.LocalAddress;
1032 Address addr =
1049 Address blockField = projectField(capture.getIndex(), "block.captured");
1053 Address src = Address::invalid();
1053 Address src = Address::invalid();
1058 src = Address::invalid();
1318 Address CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable) {
1325 Address addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(),
1482 Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr");
1508 Address CodeGenFunction::LoadBlockStruct() {
1598 Address Alloca = CreateTempAlloca(BlockPointer->getType(),
1611 Address addr = Builder.CreateStructGEP(
1623 Address alloca =
1662 auto addr = LocalDeclMap.find(variable)->second;
1777 Address Addr;
1781 CallBlockRelease(Address Addr, BlockFieldFlags Flags, bool LoadValue,
1929 Address Field, QualType CaptureType,
2042 Address src = GetAddrOfLocalVar(&SrcDecl);
2046 Address dst = GetAddrOfLocalVar(&DstDecl);
2057 Address srcField = Builder.CreateStructGEP(src, index);
2058 Address dstField = Builder.CreateStructGEP(dst, index);
2237 Address src = GetAddrOfLocalVar(&SrcDecl);
2248 Address srcField = Builder.CreateStructGEP(src, capture.getIndex());
2272 void emitCopy(CodeGenFunction &CGF, Address destField,
2273 Address srcField) override {
2288 void emitDispose(CodeGenFunction &CGF, Address field) override {
2305 void emitCopy(CodeGenFunction &CGF, Address destField,
2306 Address srcField) override {
2310 void emitDispose(CodeGenFunction &CGF, Address field) override {
2326 void emitCopy(CodeGenFunction &CGF, Address destField,
2327 Address srcField) override {
2346 void emitDispose(CodeGenFunction &CGF, Address field) override {
2363 void emitCopy(CodeGenFunction &CGF, Address destField,
2364 Address srcField) override {
2373 void emitDispose(CodeGenFunction &CGF, Address field) override {
2395 void emitCopy(CodeGenFunction &CGF, Address destField,
2396 Address srcField) override {
2401 void emitDispose(CodeGenFunction &CGF, Address field) override {
2421 void emitCopy(CodeGenFunction &CGF, Address destField,
2422 Address srcField) override {
2431 void emitDispose(CodeGenFunction &CGF, Address field) override {
2488 Address destField = CGF.GetAddrOfLocalVar(&Dst);
2496 Address srcField = CGF.GetAddrOfLocalVar(&Src);
2560 Address addr = CGF.GetAddrOfLocalVar(&Src);
2695 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr,
2695 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr,
2702 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr,
2702 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr,
2708 Address forwardingAddr = Builder.CreateStructGEP(baseAddr, 1, "forwarding");
2820 Address addr = emission.Addr;
2830 auto fieldAddr = Builder.CreateStructGEP(addr, nextHeaderIndex, name);
2938 void CodeGenFunction::enterByrefCleanup(CleanupKind Kind, Address Addr,
tools/clang/lib/CodeGen/CGBlocks.h 244 Address LocalAddress;
tools/clang/lib/CodeGen/CGBuilder.h 69 llvm::LoadInst *CreateLoad(Address Addr, const llvm::Twine &Name = "") {
74 llvm::LoadInst *CreateLoad(Address Addr, const char *Name) {
81 llvm::LoadInst *CreateLoad(Address Addr, bool IsVolatile,
107 llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr,
141 Address CreateBitCast(Address Addr, llvm::Type *Ty,
141 Address CreateBitCast(Address Addr, llvm::Type *Ty,
148 Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty,
148 Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty,
156 Address CreateElementBitCast(Address Addr, llvm::Type *Ty,
156 Address CreateElementBitCast(Address Addr, llvm::Type *Ty,
163 Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty,
163 Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty,
178 Address CreateStructGEP(Address Addr, unsigned Index,
178 Address CreateStructGEP(Address Addr, unsigned Index,
198 Address CreateConstArrayGEP(Address Addr, uint64_t Index,
198 Address CreateConstArrayGEP(Address Addr, uint64_t Index,
216 Address CreateConstInBoundsGEP(Address Addr, uint64_t Index,
216 Address CreateConstInBoundsGEP(Address Addr, uint64_t Index,
232 Address CreateConstGEP(Address Addr, uint64_t Index,
232 Address CreateConstGEP(Address Addr, uint64_t Index,
244 Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset,
244 Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset,
250 Address CreateConstByteGEP(Address Addr, CharUnits Offset,
250 Address CreateConstByteGEP(Address Addr, CharUnits Offset,
258 Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
258 Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
274 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size,
274 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size,
280 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size,
280 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size,
288 llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size,
288 llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size,
296 llvm::CallInst *CreateMemSet(Address Dest, llvm::Value *Value,
303 Address CreatePreserveStructAccessIndex(Address Addr,
303 Address CreatePreserveStructAccessIndex(Address Addr,
tools/clang/lib/CodeGen/CGBuiltin.cpp 763 Address ByteAddr(CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, BitBaseI8,
939 Address IndexAddress = EmitPointerWithAlignment(E->getArg(0));
1190 Address BufAddr(Builder.CreateLoad(GetAddrOfLocalVar(Args[0]), "buf"),
1210 Address Arg = GetAddrOfLocalVar(Args[I]);
1211 Address Addr = Builder.CreateConstByteGEP(BufAddr, Offset, "argData");
1230 Address BufAddr = EmitPointerWithAlignment(E.getArg(0));
1334 Address ResultPtr = CGF.EmitPointerWithAlignment(ResultArg);
1464 Address FieldAddress = Address(FieldPtr, Align);
2386 Address Dest = EmitPointerWithAlignment(E->getArg(0));
2395 Address Dest = EmitPointerWithAlignment(E->getArg(0));
2396 Address Src = EmitPointerWithAlignment(E->getArg(1));
2420 Address Dest = EmitPointerWithAlignment(E->getArg(0));
2421 Address Src = EmitPointerWithAlignment(E->getArg(1));
2428 Address DestAddr = EmitPointerWithAlignment(E->getArg(0));
2429 Address SrcAddr = EmitPointerWithAlignment(E->getArg(1));
2446 Address Dest = EmitPointerWithAlignment(E->getArg(0));
2447 Address Src = EmitPointerWithAlignment(E->getArg(1));
2455 Address Dest = EmitPointerWithAlignment(E->getArg(0));
2456 Address Src = EmitPointerWithAlignment(E->getArg(1));
2467 Address Dest = EmitPointerWithAlignment(E->getArg(0));
2486 Address Dest = EmitPointerWithAlignment(E->getArg(0));
2656 Address Buf = EmitPointerWithAlignment(E->getArg(0));
2667 Address StackSaveSlot = Builder.CreateConstInBoundsGEP(Buf, 2);
2982 Address Ptr = EmitPointerWithAlignment(E->getArg(0));
3176 Address CarryOutPtr = EmitPointerWithAlignment(E->getArg(3));
3266 Address ResultPtr = EmitPointerWithAlignment(ResultArg);
3324 Address SumOutPtr = EmitPointerWithAlignment(E->getArg(2));
3793 auto Tmp = CreateMemTemp(SizeArrayTy, "block_sizes");
3979 Address Address = EmitPointerWithAlignment(E->getArg(1));
3984 Address Address = EmitPointerWithAlignment(E->getArg(0));
3989 Address Address = EmitPointerWithAlignment(E->getArg(0));
4094 Address DestAddr = EmitMSVAListRef(E->getArg(0));
4095 Address SrcAddr = EmitMSVAListRef(E->getArg(1));
5238 SmallVectorImpl<llvm::Value *> &Ops, Address PtrOp0, Address PtrOp1,
5238 SmallVectorImpl<llvm::Value *> &Ops, Address PtrOp0, Address PtrOp1,
6217 Address Tmp = CreateMemTemp(E->getArg(0)->getType());
6221 Address LdPtr = Builder.CreateBitCast(Tmp,llvm::PointerType::getUnqual(STy));
6351 Address PtrOp0 = Address::invalid();
6351 Address PtrOp0 = Address::invalid();
6352 Address PtrOp1 = Address::invalid();
6352 Address PtrOp1 = Address::invalid();
7206 Address Tmp = CreateMemTemp(E->getArg(0)->getType());
8328 /*never use addresses*/ Address::invalid(), Address::invalid(), Arch);
8328 /*never use addresses*/ Address::invalid(), Address::invalid(), Arch);
10309 Address Tmp = CreateMemTemp(E->getArg(0)->getType());
10316 Address Tmp = CreateMemTemp(E->getType());
12202 Address HighBitsAddress = EmitPointerWithAlignment(E->getArg(2));
12276 Address ComparandResult(Builder.CreateBitCast(Ops[3], Int128PtrTy),
12831 Address FlagOutPtr = EmitPointerWithAlignment(E->getArg(3));
13025 Address CCPtr = CGF.EmitPointerWithAlignment(E->getArg(NumArgs));
13856 Address PredOutPtr = EmitPointerWithAlignment(E->getArg(2));
13907 Address Dst = EmitPointerWithAlignment(E->getArg(0));
13952 Address Src = EmitPointerWithAlignment(E->getArg(1));
14000 Address Dst = EmitPointerWithAlignment(E->getArg(0));
14001 Address SrcA = EmitPointerWithAlignment(E->getArg(1));
14002 Address SrcB = EmitPointerWithAlignment(E->getArg(2));
14003 Address SrcC = EmitPointerWithAlignment(E->getArg(3));
14454 Address BP = EmitPointerWithAlignment(E->getArg(0));
14470 Address Dest = EmitPointerWithAlignment(E->getArg(0));
14479 Address BP = EmitPointerWithAlignment(E->getArg(0));
14494 Address Dest = EmitPointerWithAlignment(E->getArg(0));
14513 Address DestAddr = EmitPointerWithAlignment(E->getArg(1));
14542 Address Dest = EmitPointerWithAlignment(E->getArg(2));
14564 Address Dest = EmitPointerWithAlignment(E->getArg(2));
tools/clang/lib/CodeGen/CGCUDANV.cpp 255 Address KernelArgs = CGF.CreateTempAlloca(
294 Address GridDim =
296 Address BlockDim =
298 Address ShmemSize =
300 Address Stream =
635 Address GpuBinaryAddr(
772 Address GpuBinaryAddr(GpuBinaryHandle, CharUnits::fromQuantity(
tools/clang/lib/CodeGen/CGCXXABI.cpp 41 CodeGenFunction &CGF, const Expr *E, Address This,
59 Address Base, llvm::Value *MemPtr,
172 Address CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
173 Address NewPtr,
179 return Address::invalid();
201 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, Address ptr,
217 Address allocAddr =
224 Address ptr,
tools/clang/lib/CodeGen/CGCXXABI.h 58 Address getThisAddress(CodeGenFunction &CGF) {
155 CodeGenFunction &CGF, const Expr *E, Address This,
162 Address Base, llvm::Value *MemPtr,
229 Address Ptr, QualType ElementType,
255 Address ThisPtr,
262 EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
267 Address Value,
274 Address This,
340 virtual Address
342 Address This, bool VirtualCall) {
381 Address This, QualType ThisTy) = 0;
420 GlobalDecl GD, Address This,
431 Address This,
448 Address This,
452 Address Ret,
492 virtual Address InitializeArrayCookie(CodeGenFunction &CGF,
493 Address NewPtr,
511 virtual void ReadArrayCookie(CodeGenFunction &CGF, Address Ptr,
534 virtual llvm::Value *readArrayCookieImpl(CodeGenFunction &IGF, Address ptr,
597 LoadVTablePtr(CodeGenFunction &CGF, Address This,
tools/clang/lib/CodeGen/CGCall.cpp 1003 Address BaseAddr,
1004 llvm::function_ref<void(Address)> Fn) {
1029 Address This = LV.getAddress();
1032 Address Base =
1060 Address Addr = Arg.hasLValue() ? Arg.getKnownLValue().getAddress()
1071 Address This = Arg.hasLValue() ? Arg.getKnownLValue().getAddress()
1075 Address Base =
1113 static Address CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty,
1126 static Address
1127 EnterStructPointerForCoercedAccess(Address SrcPtr,
1217 static llvm::Value *CreateCoercedLoad(Address Src, llvm::Type *Ty,
1256 Address Tmp = CreateTempAllocaForCoercion(CGF, Ty, Src.getAlignment());
1257 Address Casted = CGF.Builder.CreateElementBitCast(Tmp,CGF.Int8Ty);
1258 Address SrcCasted = CGF.Builder.CreateElementBitCast(Src,CGF.Int8Ty);
1270 Address Dest, bool DestIsVolatile) {
1275 Address EltPtr = CGF.Builder.CreateStructGEP(Dest, i);
1291 Address Dst,
1333 Address Tmp = CreateTempAllocaForCoercion(CGF, SrcTy, Dst.getAlignment());
1335 Address Casted = CGF.Builder.CreateElementBitCast(Tmp,CGF.Int8Ty);
1336 Address DstCasted = CGF.Builder.CreateElementBitCast(Dst,CGF.Int8Ty);
1343 static Address emitAddressAtOffset(CodeGenFunction &CGF, Address addr,
1343 static Address emitAddressAtOffset(CodeGenFunction &CGF, Address addr,
2212 Address Temp;
2213 Address Arg;
2214 CopyBackSwiftError(Address temp, Address arg) : Temp(temp), Arg(arg) {}
2214 CopyBackSwiftError(Address temp, Address arg) : Temp(temp), Arg(arg) {}
2256 Address ArgStruct = Address::invalid();
2256 Address ArgStruct = Address::invalid();
2306 Address V =
2314 Address ParamAddr = Address(FnArgs[FirstIRArg], ArgI.getIndirectAlign());
2319 Address V = ParamAddr;
2321 Address AlignedTemp = CreateMemTemp(Ty, "coerce");
2330 Address Dst = Builder.CreateBitCast(AlignedTemp, Int8PtrTy);
2331 Address Src = Builder.CreateBitCast(ParamAddr, Int8PtrTy);
2424 Address temp =
2426 Address arg = Address(V, getContext().getTypeAlignInChars(pointeeTy));
2456 Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg),
2460 Address Ptr = emitAddressAtOffset(*this, Alloca, ArgI);
2471 Address AddrToStoreInto = Address::invalid();
2471 Address AddrToStoreInto = Address::invalid();
2483 Address EltPtr = Builder.CreateStructGEP(AddrToStoreInto, i);
2514 Address alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg));
2526 auto eltAddr = Builder.CreateStructGEP(alloca, i);
2538 Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg));
2884 Address V = emitAddressAtOffset(*this, ReturnValue, RetAI);
2925 Address addr = Builder.CreateElementBitCast(ReturnValue, coercionType);
2931 auto eltAddr = Builder.CreateStructGEP(addr, i);
3024 ReturnLocation = Address::invalid();
3060 Address local = GetAddrOfLocalVar(param);
3115 Address srcAddr = srcLV.getAddress();
3217 Address srcAddr = CGF.EmitPointerWithAlignment(CRE->getSubExpr());
3223 Address srcAddr = srcLV.getAddress();
3239 Address temp = CGF.CreateTempAlloca(destType->getElementType(),
3496 DestroyUnpassedArg(Address Addr, QualType Ty)
3499 Address Addr;
3540 void CallArg::copyInto(CodeGenFunction &CGF, Address Addr) const {
3547 auto Addr = HasLV ? LV.getAddress() : RV.getAggregateAddress();
3831 Address ArgMemory = Address::invalid();
3831 Address ArgMemory = Address::invalid();
3855 Address SRetPtr = Address::invalid();
3855 Address SRetPtr = Address::invalid();
3856 Address SRetAlloca = Address::invalid();
3856 Address SRetAlloca = Address::invalid();
3872 Address Addr =
3878 Address swiftErrorTemp = Address::invalid();
3878 Address swiftErrorTemp = Address::invalid();
3879 Address swiftErrorArg = Address::invalid();
3879 Address swiftErrorArg = Address::invalid();
3909 Address Addr = I->hasLValue()
3922 Address Addr =
3940 Address Addr = CreateMemTempWithoutCast(
3954 Address Addr = I->hasLValue()
3999 Address AI = CreateMemTempWithoutCast(
4080 Address Src = Address::invalid();
4080 Address Src = Address::invalid();
4106 Address TempAlloca
4118 Address EltPtr = Builder.CreateStructGEP(Src, i);
4137 Address addr = Address::invalid();
4137 Address addr = Address::invalid();
4138 Address AllocaAddr = Address::invalid();
4138 Address AllocaAddr = Address::invalid();
4169 Address eltAddr = Builder.CreateStructGEP(addr, i);
4472 Address addr = SRetPtr;
4482 Address eltAddr = Builder.CreateStructGEP(addr, i);
4518 Address DestPtr = ReturnValue.getValue();
4540 Address DestPtr = ReturnValue.getValue();
4549 Address StorePtr = emitAddressAtOffset(*this, DestPtr, RetAI);
4603 Address CodeGenFunction::EmitVAArg(VAArgExpr *VE, Address &VAListAddr) {
4603 Address CodeGenFunction::EmitVAArg(VAArgExpr *VE, Address &VAListAddr) {
tools/clang/lib/CodeGen/CGCall.h 86 Address Addr;
144 static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr,
203 Address getThisAddress() const {
257 void copyInto(CodeGenFunction &CGF, Address A) const;
273 Address Temporary;
308 void addWriteback(LValue srcLV, Address temporary,
375 ReturnValueSlot(Address Addr, bool IsVolatile, bool IsUnused = false)
383 Address getValue() const { return Address(Value.getPointer(), Alignment); }
tools/clang/lib/CodeGen/CGClass.cpp 109 Address CodeGenFunction::LoadCXXThisAddress() {
128 Address
129 CodeGenFunction::EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
198 Address
199 CodeGenFunction::GetAddressOfDirectBaseInCompleteClass(Address This,
216 Address V = This;
226 static Address
227 ApplyNonVirtualAndVirtualOffset(CodeGenFunction &CGF, Address addr,
268 Address CodeGenFunction::GetAddressOfBaseClass(
269 Address Value, const CXXRecordDecl *Derived,
375 Address
376 CodeGenFunction::GetAddressOfDerivedClass(Address BaseAddr,
500 Address Addr =
539 Address ThisPtr = CGF.LoadCXXThisAddress();
555 Address V =
957 Address ThisPtr = CGF.LoadCXXThisAddress();
979 void emitMemcpyIR(Address DestPtr, Address SrcPtr, CharUnits Size) {
979 void emitMemcpyIR(Address DestPtr, Address SrcPtr, CharUnits Size) {
1108 Address ThisPtr = CGF.LoadCXXThisAddress();
1624 Address thisValue = CGF.LoadCXXThisAddress();
1893 Address arrayBegin, const CXXConstructExpr *E, bool NewPointerIsChecked,
1914 Address arrayBase,
1965 Address curAddr = Address(cur, eltAlignment);
2018 Address addr,
2035 Address This = ThisAVS.getAddress();
2107 Address This,
2130 Address Src(Args[1].getRValue(*this).getScalarVal(),
2181 const CXXConstructorDecl *D, bool ForVirtualBase, Address This,
2272 void CodeGenFunction::EmitVTableAssumptionLoad(const VPtr &Vptr, Address This) {
2294 Address This) {
2302 Address This, Address Src,
2302 Address This, Address Src,
2338 Address This = LoadCXXThisAddress();
2367 Address Addr;
2370 CallDelegatingCtorDtor(const CXXDestructorDecl *D, Address Addr,
2389 Address ThisPtr = LoadCXXThisAddress();
2417 bool Delegating, Address This,
2426 Address Addr;
2429 CallLocalDtor(const CXXDestructorDecl *D, Address Addr, QualType Ty)
2441 QualType T, Address Addr) {
2445 void CodeGenFunction::PushDestructorCleanup(QualType T, Address Addr) {
2481 Address VTableField = LoadCXXThisAddress();
2588 llvm::Value *CodeGenFunction::GetVTablePtr(Address This,
2591 Address VTablePtrSrc = Builder.CreateElementBitCast(This, VTableTy);
2891 Address ThisPtr = GetAddrOfBlockDecl(variable);
tools/clang/lib/CodeGen/CGCleanup.cpp 44 Address addr =
54 Address addr = CGF.CreateDefaultAlignTempAlloca(ComplexTy, "saved-complex");
61 Address V = rv.getAggregateAddress(); // TODO: volatile?
66 Address addr =
93 Address address = getSavingAddress(Value);
277 Address CodeGenFunction::createCleanupActiveFlag() {
279 Address active = CreateTempAllocaWithoutCast(
292 void CodeGenFunction::initFullExprCleanupWithFlag(Address ActiveFlag) {
304 static void createStoreInstBefore(llvm::Value *value, Address addr,
310 static llvm::LoadInst *createLoadInstBefore(Address addr, const Twine &name,
455 Address Tmp =
496 Address ActiveFlag =
558 Address ActiveFlag) {
652 Address NormalActiveFlag =
654 : Address::invalid();
655 Address EHActiveFlag =
657 : Address::invalid();
841 NormalCleanupDest = Address::invalid();
1203 Address var = Scope.getActiveFlag();
1264 Address CodeGenFunction::getNormalCleanupDestSlot() {
1274 Address Ptr) {
tools/clang/lib/CodeGen/CGCleanup.h 324 Address getActiveFlag() const {
327 void setActiveFlag(Address Var) {
tools/clang/lib/CodeGen/CGCoroutine.cpp 474 Address GroActiveFlag;
478 : CGF(CGF), Builder(CGF.Builder), S(S), GroActiveFlag(Address::invalid()),
620 Address PromiseAddr = GetAddrOfLocalVar(S.getPromiseDecl());
tools/clang/lib/CodeGen/CGDecl.cpp 455 DestroyObject(Address addr, QualType type,
461 Address addr;
477 DestroyNRVOVariable(Address addr, QualType type, llvm::Value *NRVOFlag)
481 Address Loc;
509 DestroyNRVOVariableCXX(Address addr, QualType type,
525 DestroyNRVOVariableC(Address addr, llvm::Value *NRVOFlag, QualType Ty)
534 Address Stack;
535 CallStackRestore(Address Stack) : Stack(Stack) {}
596 Address addr,
687 auto srcAddr = srcLV.getAddress();
898 llvm::Constant *Init, Address Loc,
1077 Address CodeGenModule::createUnnamedGlobalFrom(const VarDecl &D,
1127 static Address createUnnamedGlobalForMemcpyFrom(CodeGenModule &CGM,
1132 Address SrcPtr = CGM.createUnnamedGlobalFrom(D, Constant, Align);
1141 Address Loc, bool isVolatile,
1194 Address EltPtr = Builder.CreateStructGEP(Loc, i);
1205 Address EltPtr = Builder.CreateConstArrayGEP(Loc, i);
1223 Address Loc, bool isVolatile,
1232 Address Loc, bool isVolatile,
1332 auto SizeExprAddr =
1396 Address address = Address::invalid();
1396 Address address = Address::invalid();
1397 Address AllocaAddr = Address::invalid();
1397 Address AllocaAddr = Address::invalid();
1398 Address OpenMPLocalAddr =
1401 : Address::invalid();
1433 emission.Addr = Address::invalid();
1461 Address NRVOFlag =
1526 Address Stack =
1559 Address DebugAddr = address;
1663 Address Loc) {
1720 Address Begin = Builder.CreateElementBitCast(Loc, Int8Ty, "vla.begin");
1786 const Address Loc =
1918 Address addr = emission.getObjectAddress(*this);
2044 Address addr, QualType type) {
2054 Address addr, QualType type) {
2062 void CodeGenFunction::pushDestroy(CleanupKind cleanupKind, Address addr,
2069 void CodeGenFunction::pushStackRestore(CleanupKind Kind, Address SPMem) {
2074 CleanupKind cleanupKind, Address addr, QualType type,
2101 void CodeGenFunction::emitDestroy(Address addr, QualType type,
2250 Address ArrayEndPointer;
2256 Address arrayEndPointer,
2279 Address arrayEndPointer,
2368 Address DeclPtr = Address::invalid();
2368 Address DeclPtr = Address::invalid();
2413 Address OpenMPLocalAddr =
2416 : Address::invalid();
tools/clang/lib/CodeGen/CGDeclCXX.cpp 758 Address addr, QualType type, Destroyer *destroyer,
tools/clang/lib/CodeGen/CGException.cpp 377 void CodeGenFunction::EmitAnyExprToExn(const Expr *e, Address addr) {
386 Address typedAddr = Builder.CreateBitCast(addr, ty);
403 Address CodeGenFunction::getExceptionSlot() {
409 Address CodeGenFunction::getEHSelectorSlot() {
1658 Address SEHCodeSlot = Address::invalid();
1658 Address SEHCodeSlot = Address::invalid();
1711 Address CodeGenFunction::recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF,
1712 Address ParentVar,
1816 Address ParentVar = I->second;
tools/clang/lib/CodeGen/CGExpr.cpp 64 Address CodeGenFunction::CreateTempAllocaWithoutCast(llvm::Type *Ty,
75 Address CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, CharUnits Align,
78 Address *AllocaAddr) {
79 auto Alloca = CreateTempAllocaWithoutCast(Ty, Align, Name, ArraySize);
119 Address CodeGenFunction::CreateDefaultAlignTempAlloca(llvm::Type *Ty,
126 void CodeGenFunction::InitTempAlloca(Address Var, llvm::Value *Init) {
134 Address CodeGenFunction::CreateIRTemp(QualType Ty, const Twine &Name) {
139 Address CodeGenFunction::CreateMemTemp(QualType Ty, const Twine &Name,
140 Address *Alloca) {
145 Address CodeGenFunction::CreateMemTemp(QualType Ty, CharUnits Align,
146 const Twine &Name, Address *Alloca) {
151 Address CodeGenFunction::CreateMemTempWithoutCast(QualType Ty, CharUnits Align,
156 Address CodeGenFunction::CreateMemTempWithoutCast(QualType Ty,
224 Address Location,
255 const Expr *E, Address ReferenceTemporary) {
370 static Address createReferenceTemporary(CodeGenFunction &CGF,
373 Address *Alloca = nullptr) {
431 Address Object = createReferenceTemporary(*this, M, E);
487 Address Alloca = Address::invalid();
487 Address Alloca = Address::invalid();
488 Address Object = createReferenceTemporary(*this, M, E, &Alloca);
812 Address VPtrAddr(Builder.CreateBitCast(Ptr, VPtrTy), getPointerAlign());
917 Address AddrOfSize = LocalDeclMap.find(PassedSizeDecl)->second;
1036 Address CodeGenFunction::EmitPointerWithAlignment(const Expr *E,
1060 Address Addr = EmitPointerWithAlignment(CE->getSubExpr(),
1111 Address Addr = EmitPointerWithAlignment(CE->getSubExpr(), BaseInfo);
1160 Address DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
1634 llvm::Value *CodeGenFunction::EmitLoadOfScalar(Address Addr, bool Volatile,
1653 Address Cast = Builder.CreateElementBitCast(Addr, vec4Ty, "castToVec4");
1716 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, Address Addr,
1777 Address AddrWeakObj = LV.getAddress();
1827 Address Ptr = LV.getBitFieldAddress();
1881 Address CodeGenFunction::EmitExtVectorElementLValue(LValue LV) {
1882 Address VectorAddress = LV.getExtVectorAddress();
1887 Address CastToPointerElement =
1894 Address VectorBasePtrPlusIx =
1989 Address LvalueDst = Dst.getAddress();
1997 Address LvalueDst = Dst.getAddress();
2002 Address dst = EmitPointerWithAlignment(Dst.getBaseIvarExp());
2028 Address Ptr = Dst.getBitFieldAddress();
2293 CodeGenFunction &CGF, const VarDecl *VD, QualType T, Address Addr,
2300 static Address emitDeclTargetVarDeclLValue(CodeGenFunction &CGF,
2309 return Address::invalid();
2315 Address Addr = CGF.CGM.getOpenMPRuntime().getAddrOfDeclareTargetVar(VD);
2319 Address
2336 Address PointeeAddr = EmitLoadOfReference(RefLVal, &PointeeBaseInfo,
2342 Address CodeGenFunction::EmitLoadOfPointer(Address Ptr,
2342 Address CodeGenFunction::EmitLoadOfPointer(Address Ptr,
2352 LValue CodeGenFunction::EmitLoadOfPointerLValue(Address PtrAddr,
2356 Address Addr = EmitLoadOfPointer(PtrAddr, PtrTy, &BaseInfo, &TBAAInfo);
2371 Address Addr = emitDeclTargetVarDeclLValue(CGF, VD, T);
2380 Address Addr(V, Alignment);
2539 Address Addr = Address::invalid();
2539 Address Addr = Address::invalid();
2586 Address addr = GetAddrOfBlockDecl(VD);
2609 Address addr = Address::invalid();
2609 Address addr = Address::invalid();
2692 Address Addr = EmitPointerWithAlignment(E->getSubExpr(), &BaseInfo,
2722 Address Component =
2856 Address Ptr = CreateDefaultAlignTempAlloca(V->getType());
3234 Address CheckKindAddr(V, getIntAlign());
3314 Address CodeGenFunction::EmitArrayToPointerDecay(const Expr *E,
3322 Address Addr = LV.getAddress();
3405 static Address emitArraySubscriptGEP(CodeGenFunction &CGF, Address addr,
3405 static Address emitArraySubscriptGEP(CodeGenFunction &CGF, Address addr,
3496 Address Addr = EmitExtVectorElementLValue(LV);
3507 Address Addr = Address::invalid();
3507 Address Addr = Address::invalid();
3607 static Address emitOMPArraySectionBase(CodeGenFunction &CGF, const Expr *Base,
3616 Address Addr = BaseLVal.getAddress();
3741 Address EltPtr = Address::invalid();
3741 Address EltPtr = Address::invalid();
3748 Address Base =
3788 Address Base = emitOMPArraySectionBase(*this, E->getBase(), BaseInfo,
3810 Address Ptr = EmitPointerWithAlignment(E->getBase(), &BaseInfo, &TBAAInfo);
3826 Address VecMem = CreateMemTemp(E->getBase()->getType());
3869 Address Addr = EmitPointerWithAlignment(BaseExpr, &BaseInfo, &TBAAInfo);
3926 static Address emitAddrOfZeroSizeField(CodeGenFunction &CGF, Address Base,
3926 static Address emitAddrOfZeroSizeField(CodeGenFunction &CGF, Address Base,
3940 static Address emitAddrOfFieldStorage(CodeGenFunction &CGF, Address base,
3940 static Address emitAddrOfFieldStorage(CodeGenFunction &CGF, Address base,
3953 static Address emitPreserveStructAccess(CodeGenFunction &CGF, Address base,
3953 static Address emitPreserveStructAccess(CodeGenFunction &CGF, Address base,
3993 Address Addr = base.getAddress();
4060 Address addr = base.getAddress();
4146 Address V = emitAddrOfFieldStorage(*this, Base.getAddress(), Field);
4171 Address DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
4268 Address result(phi, std::min(lhs->getAlignment(), rhs->getAlignment()));
4350 Address V = LV.getAddress();
4370 Address This = LV.getAddress();
4373 Address Base = GetAddressOfBaseClass(
4392 Address Derived =
4417 Address V = Builder.CreateBitCast(LV.getAddress(),
4439 Address V = Builder.CreateElementBitCast(LV.getAddress(),
4689 Address CodeGenFunction::EmitCXXUuidofExpr(const CXXUuidofExpr *E) {
4723 Address V =
4959 Address BaseAddr = Address::invalid();
4959 Address BaseAddr = Address::invalid();
4973 Address MemberAddr =
4982 RValue CodeGenFunction::convertTempToRValue(Address addr,
tools/clang/lib/CodeGen/CGExprAgg.cpp 88 void EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
262 Address RetAddr = Address::invalid();
262 Address RetAddr = Address::invalid();
263 Address RetAllocaAddr = Address::invalid();
263 Address RetAllocaAddr = Address::invalid();
389 Address ArrayPtr = Array.getAddress();
469 void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
517 Address endOfInit = Address::invalid();
517 Address endOfInit = Address::invalid();
710 Address CastPtr =
725 Address SourceAddress =
727 Address DestAddress =
784 Address valueAddr =
805 Address valueAddr = Builder.CreateStructGEP(atomicSlot.getAddress(), 0);
1247 Address ArgValue = Address::invalid();
1247 Address ArgValue = Address::invalid();
1248 Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
1518 Address V = CGF.GetAddressOfDirectBaseInCompleteClass(
1642 Address destPtr = EnsureSlot(E->getType()).getAddress();
1836 Address Loc = Slot.getAddress();
1865 Address Temp = CreateMemTemp(E->getType());
1919 Address DestPtr = Dest.getAddress();
1920 Address SrcPtr = Src.getAddress();
tools/clang/lib/CodeGen/CGExprCXX.cpp 126 Address BaseValue = Address::invalid();
126 Address BaseValue = Address::invalid();
261 Address ThisValue = EmitPointerWithAlignment(Base, &BaseInfo, &TBAAInfo);
402 Address NewThisAddr =
427 Address This = Address::invalid();
427 Address This = Address::invalid();
479 Address DestPtr,
537 Address SrcPtr = Address(CGF.EmitCastToVoidPtr(NullVariable), Align);
638 void CodeGenFunction::EmitSynthesizedCXXCopyCtor(Address Dest, Address Src,
638 void CodeGenFunction::EmitSynthesizedCXXCopyCtor(Address Dest, Address Src,
936 QualType AllocType, Address NewPtr,
965 Address BeginPtr, llvm::Value *NumElements,
972 Address CurPtr = BeginPtr;
977 Address EndOfInit = Address::invalid();
977 Address EndOfInit = Address::invalid();
1272 Address NewPtr, llvm::Value *NumElements,
1468 Address NewPtr,
1562 Address allocation = Address::invalid();
1562 Address allocation = Address::invalid();
1692 Address result = Builder.CreateElementBitCast(allocation, elementTy);
1846 const CXXDeleteExpr *DE, Address Ptr,
1859 Address Ptr,
1972 Address deletedPtr,
2016 Address Ptr = EmitPointerWithAlignment(Arg);
2106 Address ThisPtr = CGF.EmitLValue(E).getAddress();
2182 llvm::Value *CodeGenFunction::EmitDynamicCast(Address ThisAddr,
tools/clang/lib/CodeGen/CGExprComplex.cpp 333 Address CodeGenFunction::emitAddrOfRealComponent(Address addr,
333 Address CodeGenFunction::emitAddrOfRealComponent(Address addr,
338 Address CodeGenFunction::emitAddrOfImagComponent(Address addr,
338 Address CodeGenFunction::emitAddrOfImagComponent(Address addr,
351 Address SrcPtr = lvalue.getAddress();
357 Address RealP = CGF.emitAddrOfRealComponent(SrcPtr, lvalue.getType());
362 Address ImagP = CGF.emitAddrOfImagComponent(SrcPtr, lvalue.getType());
377 Address Ptr = lvalue.getAddress();
378 Address RealPtr = CGF.emitAddrOfRealComponent(Ptr, lvalue.getType());
379 Address ImagPtr = CGF.emitAddrOfImagComponent(Ptr, lvalue.getType());
415 Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(), true);
466 Address V = origLV.getAddress();
473 Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(),
1085 Address ArgValue = Address::invalid();
1085 Address ArgValue = Address::invalid();
1086 Address ArgPtr = CGF.EmitVAArg(E, ArgValue);
tools/clang/lib/CodeGen/CGExprScalar.cpp 1975 Address Addr = EmitLValue(E).getAddress();
1983 Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(),
2065 Address Base = CGF.EmitPointerWithAlignment(E);
2066 Address Derived =
2093 Address V = CGF.EmitPointerWithAlignment(E);
2295 Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(),
4298 Address ArgValue = Address::invalid();
4298 Address ArgValue = Address::invalid();
4299 Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
4482 Address Addr = Address::invalid();
4482 Address Addr = Address::invalid();
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp 228 static llvm::Constant *getNullForVariable(Address Addr) {
325 std::array<Address, N> Addrs) {
333 std::array<Address, N> Addrs) {
345 std::array<Address, N> StartAddrs = Addrs;
348 Address DstAddr = StartAddrs[DstIdx];
355 Address BC = CGF.Builder.CreateBitCast(DstAddr, CGF.CGM.Int8PtrTy);
386 std::array<Address, N> NewAddrs = Addrs;
389 NewAddrs[I] = Address(
411 Address getAddrWithOffset(Address Addr, CharUnits Offset) {
411 Address getAddrWithOffset(Address Addr, CharUnits Offset) {
420 Address getAddrWithOffset(Address Addr, CharUnits StructFieldOffset,
420 Address getAddrWithOffset(Address Addr, CharUnits StructFieldOffset,
428 getFunction(StringRef FuncName, QualType QT, std::array<Address, N> Addrs,
472 Addrs[I] = Address(V, Alignments[I]);
481 void callFunc(StringRef FuncName, QualType QT, std::array<Address, N> Addrs,
510 void flushTrivialFields(std::array<Address, 2> Addrs) {
516 Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], this->Start);
517 Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], this->Start);
543 std::array<Address, 2> Addrs) {
548 Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], Offset);
552 Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], Offset);
558 Address DstAddr = this->CGF->Builder.CreateBitCast(Addrs[DstIdx], Ty);
559 Address SrcAddr = this->CGF->Builder.CreateBitCast(Addrs[SrcIdx], Ty);
577 std::array<Address, 1> Addrs) {
587 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
593 std::array<Address, 1> Addrs) {
599 std::array<Address, 1> Addrs) {
617 std::array<Address, 1> Addrs) {
628 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
634 std::array<Address, 1> Addrs) {
642 std::array<Address, 1> Addrs) {
656 Address DstAddr = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
657 Address Loc = CGF->Builder.CreateElementBitCast(DstAddr, CGF->Int8Ty);
663 std::array<Address, 1> Addrs) {
674 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
684 std::array<Address, 2> Addrs) {
691 std::array<Address, 2> Addrs) {
704 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
716 std::array<Address, 2> Addrs) {
723 std::array<Address, 2> Addrs) {
736 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
746 std::array<Address, 2> Addrs) {
753 std::array<Address, 2> Addrs) {
767 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
782 std::array<Address, 2> Addrs) {
789 std::array<Address, 2> Addrs) {
801 Address Addr, QualType Type) {
809 Address DstPtr = Builder.CreateBitCast(Dst.getAddress(), CGM.Int8PtrPtrTy);
819 std::array<Address, N> Addrs) {
826 template <size_t N> static std::array<Address, N> createNullAddressArray();
828 template <> std::array<Address, 1> createNullAddressArray() {
832 template <> std::array<Address, 2> createNullAddressArray() {
852 Address DstPtr = Dst.getAddress();
876 Address DstPtr = Dst.getAddress();
887 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
901 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
912 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
926 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
tools/clang/lib/CodeGen/CGObjC.cpp 39 static llvm::Constant *getNullForVariable(Address addr) {
90 Address Temporary = CreateMemTemp(SubExpr->getType());
92 Address BitCast = Builder.CreateBitCast(Temporary, ConvertType(ArgQT));
150 Address Objects = CreateMemTemp(ElementArrayType, "objects");
151 Address Keys = Address::invalid();
151 Address Keys = Address::invalid();
594 Address selfAddr =
629 Address selfAddr =
730 Address src =
738 Address dest = CGF.Builder.CreateBitCast(CGF.ReturnValue, CGF.VoidPtrTy);
1065 Address ivarAddr = LV.getAddress();
1338 Address argAddr = GetAddrOfLocalVar(*setterMethod->param_begin());
1342 Address ivarAddr = ivarLValue.getAddress();
1394 Address argAddr = GetAddrOfLocalVar(*setterMethod->param_begin());
1528 Address addr,
1647 Address StatePtr = CreateMemTemp(StateTy, "state.ptr");
1666 Address ItemsPtr = CreateMemTemp(ItemsTy, "items.ptr");
1732 Address StateMutationsPtrPtr =
1814 Address StateItemsPtr =
2009 static llvm::Value *emitARCLoadOperation(CodeGenFunction &CGF, Address addr,
2033 static llvm::Value *emitARCStoreOperation(CodeGenFunction &CGF, Address addr,
2060 static void emitARCCopyOperation(CodeGenFunction &CGF, Address dst, Address src,
2060 static void emitARCCopyOperation(CodeGenFunction &CGF, Address dst, Address src,
2262 void CodeGenFunction::EmitARCDestroyStrong(Address addr,
2276 llvm::Value *CodeGenFunction::EmitARCStoreStrongCall(Address addr,
2391 llvm::Value *CodeGenFunction::EmitARCLoadWeak(Address addr) {
2398 llvm::Value *CodeGenFunction::EmitARCLoadWeakRetained(Address addr) {
2406 llvm::Value *CodeGenFunction::EmitARCStoreWeak(Address addr,
2418 void CodeGenFunction::EmitARCInitWeak(Address addr, llvm::Value *value) {
2436 void CodeGenFunction::EmitARCDestroyWeak(Address addr) {
2452 void CodeGenFunction::EmitARCMoveWeak(Address dst, Address src) {
2452 void CodeGenFunction::EmitARCMoveWeak(Address dst, Address src) {
2461 void CodeGenFunction::EmitARCCopyWeak(Address dst, Address src) {
2461 void CodeGenFunction::EmitARCCopyWeak(Address dst, Address src) {
2467 void CodeGenFunction::emitARCCopyAssignWeak(QualType Ty, Address DstAddr,
2468 Address SrcAddr) {
2474 void CodeGenFunction::emitARCMoveAssignWeak(QualType Ty, Address DstAddr,
2475 Address SrcAddr) {
2587 Address addr,
2593 Address addr,
2599 Address addr,
2604 void CodeGenFunction::emitARCIntrinsicUse(CodeGenFunction &CGF, Address addr,
tools/clang/lib/CodeGen/CGObjCGNU.cpp 328 Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) {
328 Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) {
555 Address ObjCSuper,
594 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
634 Address AddrWeakObj) override;
636 llvm::Value *src, Address dst) override;
638 llvm::Value *src, Address dest,
641 Address dest, llvm::Value *ivarOffset) override;
643 llvm::Value *src, Address dest) override;
644 void EmitGCMemmoveCollectable(CodeGenFunction &CGF, Address DestPtr,
645 Address SrcPtr,
698 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
755 Address ReceiverPtr =
789 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
1196 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
2055 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
2338 Address CGObjCGNU::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
2343 Address tmp = CGF.CreateTempAlloca(SelValue->getType(),
2584 Address ObjCSuper = CGF.CreateTempAlloca(ObjCSuperTy,
2739 Address v = msgRet.getAggregateAddress();
2742 Address NullVal = CGF.CreateTempAlloca(RetTy, v.getAlignment(), "null");
3969 Address AddrWeakObj) {
3976 llvm::Value *src, Address dst) {
3984 llvm::Value *src, Address dst,
3995 llvm::Value *src, Address dst,
4004 llvm::Value *src, Address dst) {
4012 Address DestPtr,
4013 Address SrcPtr,
tools/clang/lib/CodeGen/CGObjCMac.cpp 1306 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1335 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1371 Address AddrWeakObj) override;
1373 llvm::Value *src, Address dst) override;
1375 llvm::Value *src, Address dest,
1378 llvm::Value *src, Address dest,
1381 llvm::Value *src, Address dest) override;
1383 Address dest, Address src,
1383 Address dest, Address src,
1534 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1621 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1680 Address AddrWeakObj) override;
1682 llvm::Value *src, Address edst) override;
1684 llvm::Value *src, Address dest,
1687 llvm::Value *src, Address dest,
1690 llvm::Value *src, Address dest) override;
1692 Address dest, Address src,
1692 Address dest, Address src,
1889 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
2064 Address ObjCSuper =
4122 Address SyncArgSlot;
4123 Address CallTryExitVar;
4124 Address ExceptionData;
4127 Address SyncArgSlot,
4128 Address CallTryExitVar,
4129 Address ExceptionData,
4303 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4460 Address SyncArgSlot = Address::invalid();
4460 Address SyncArgSlot = Address::invalid();
4474 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4492 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4498 Address PropagatingExnVar = Address::invalid();
4498 Address PropagatingExnVar = Address::invalid();
4788 Address AddrWeakObj) {
4803 llvm::Value *src, Address dst) {
4823 llvm::Value *src, Address dst,
4848 llvm::Value *src, Address dst,
4869 llvm::Value *src, Address dst) {
4886 Address DestPtr,
4887 Address SrcPtr,
5124 Address CGObjCMac::EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel) {
7204 Address mref =
7212 Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0);
7442 Address ObjCSuper =
7477 Address Addr = EmitSelectorAddr(CGF, Sel);
7485 Address CGObjCNonFragileABIMac::EmitSelectorAddr(CodeGenFunction &CGF,
7514 Address dst,
7535 llvm::Value *src, Address dst) {
7553 Address DestPtr,
7554 Address SrcPtr,
7567 Address AddrWeakObj) {
7581 llvm::Value *src, Address dst) {
7601 llvm::Value *src, Address dst,
tools/clang/lib/CodeGen/CGObjCRuntime.cpp 108 Address Addr(V, Alignment);
291 Address paramAddr = CGF.GetAddrOfLocalVar(paramDecl);
tools/clang/lib/CodeGen/CGObjCRuntime.h 131 virtual Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) = 0;
251 Address AddrWeakObj) = 0;
253 llvm::Value *src, Address dest) = 0;
255 llvm::Value *src, Address dest,
258 llvm::Value *src, Address dest,
261 llvm::Value *src, Address dest) = 0;
272 Address DestPtr,
273 Address SrcPtr,
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 805 Address Private, Address Original,
805 Address Private, Address Original,
859 static void EmitOMPAggregateInit(CodeGenFunction &CGF, Address DestAddr,
863 Address SrcAddr = Address::invalid()) {
863 Address SrcAddr = Address::invalid()) {
896 Address SrcElementCurrent = Address::invalid();
896 Address SrcElementCurrent = Address::invalid();
908 Address DestElementCurrent =
955 CodeGenFunction &CGF, unsigned N, Address PrivateAddr, LValue SharedLVal,
1053 CodeGenFunction &CGF, unsigned N, Address PrivateAddr, LValue SharedLVal,
1092 Address PrivateAddr) {
1124 static Address castToBase(CodeGenFunction &CGF, QualType BaseTy, QualType ElTy,
1127 Address Tmp = Address::invalid();
1127 Address Tmp = Address::invalid();
1128 Address TopTmp = Address::invalid();
1128 Address TopTmp = Address::invalid();
1129 Address MostTopTmp = Address::invalid();
1129 Address MostTopTmp = Address::invalid();
1172 Address ReductionCodeGen::adjustPrivateAddress(CodeGenFunction &CGF, unsigned N,
1173 Address PrivateAddr) {
1380 Address AddrIn = CGF.GetAddrOfLocalVar(&OmpInParm);
1385 Address AddrOut = CGF.GetAddrOfLocalVar(&OmpOutParm);
1567 Address CGOpenMPRuntime::getOrCreateDefaultLocation(unsigned Flags) {
1637 Address LocValue = Address::invalid();
1637 Address LocValue = Address::invalid();
1646 Address AI = CGF.CreateMemTemp(IdentQTy, ".kmpc_loc.addr");
2669 Address CGOpenMPRuntime::getAddrOfDeclareTargetVar(const VarDecl *VD) {
2671 return Address::invalid();
2705 return Address::invalid();
2718 Address CGOpenMPRuntime::getAddrOfThreadPrivate(CodeGenFunction &CGF,
2720 Address VDAddr,
2738 CodeGenFunction &CGF, Address VDAddr, llvm::Value *Ctor,
2755 const VarDecl *VD, Address VDAddr, SourceLocation Loc,
2788 Address Arg = Address(ArgVal, VDAddr.getAlignment());
2987 Address CGOpenMPRuntime::getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
3084 Address ThreadIDAddr = RT.emitThreadIDAddress(CGF, Loc);
3085 Address ZeroAddrBound =
3116 Address CGOpenMPRuntime::emitThreadIDAddress(CodeGenFunction &CGF,
3126 Address ThreadIDTemp = CGF.CreateMemTemp(Int32Ty, /*Name*/ ".threadid_temp.");
3275 static Address emitAddrOfVarFromArray(CodeGenFunction &CGF, Address Array,
3275 static Address emitAddrOfVarFromArray(CodeGenFunction &CGF, Address Array,
3278 Address PtrAddr = CGF.Builder.CreateConstArrayGEP(Array, Index);
3281 Address Addr = Address(Ptr, CGF.getContext().getDeclAlign(Var));
3314 Address LHS(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
3317 Address RHS(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
3327 Address DestAddr = emitAddrOfVarFromArray(CGF, LHS, I, DestVar);
3331 Address SrcAddr = emitAddrOfVarFromArray(CGF, RHS, I, SrcVar);
3363 Address DidIt = Address::invalid();
3363 Address DidIt = Address::invalid();
3391 Address CopyprivateList =
3394 Address Elem = CGF.Builder.CreateConstArrayGEP(CopyprivateList, I);
3406 Address CL =
3774 bool IVSigned, Address IL,
3775 Address LB, Address UB,
3775 Address LB, Address UB,
3776 Address ST) {
4749 Address KmpTaskSharedsPtr, LValue TDBase,
4926 Address KmpTaskSharedsPtr = Address::invalid();
4926 Address KmpTaskSharedsPtr = Address::invalid();
4965 Address Shareds, const OMPTaskDataTy &Data) {
5121 Address KmpTaskSharedsPtr = Address::invalid();
5121 Address KmpTaskSharedsPtr = Address::invalid();
5184 QualType SharedsTy, Address Shareds,
5199 Address DependenciesArray = Address::invalid();
5199 Address DependenciesArray = Address::invalid();
5379 QualType SharedsTy, Address Shareds,
5475 Address LHSAddr = CGF.GetAddrOfLocalVar(LHSVar);
5476 Address RHSAddr = CGF.GetAddrOfLocalVar(RHSVar);
5502 Address RHSElementCurrent =
5509 Address LHSElementCurrent =
5585 Address LHS(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5588 Address RHS(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5613 Address Elem = CGF.Builder.CreateConstArrayGEP(LHS, Idx);
5746 Address ReductionList =
5751 Address Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
5903 Address LHSTemp = CGF.CreateMemTemp(VD->getType());
6018 Address PrivateAddr = CGF.EmitLoadOfPointer(
6025 Address SizeAddr = CGM.getOpenMPRuntime().getAddrOfArtificialThreadPrivate(
6037 Address SharedAddr =
6099 Address SizeAddr = CGM.getOpenMPRuntime().getAddrOfArtificialThreadPrivate(
6112 Address PtrAddr = CGF.EmitLoadOfPointer(
6120 Address PtrAddr = CGF.EmitLoadOfPointer(
6165 Address PrivateAddr = CGF.EmitLoadOfPointer(
6172 Address SizeAddr = CGM.getOpenMPRuntime().getAddrOfArtificialThreadPrivate(
6218 Address TaskRedInput = CGF.CreateMemTemp(ArrayRDType, ".rd_input.");
6301 Address SizeAddr = getAddrOfArtificialThreadPrivate(
6308 Address SharedAddr = getAddrOfArtificialThreadPrivate(
6318 Address CGOpenMPRuntime::getTaskReductionItem(CodeGenFunction &CGF,
7112 std::pair<unsigned /*FieldIndex*/, Address /*Pointer*/> LowestElem = {
7113 0, Address::invalid()};
7114 std::pair<unsigned /*FieldIndex*/, Address /*Pointer*/> HighestElem = {
7115 0, Address::invalid()};
7116 Address Base = Address::invalid();
7116 Address Base = Address::invalid();
7500 Address BP = Address::invalid();
7500 Address BP = Address::invalid();
7610 Address LB =
7632 Address HB = CGF.Builder.CreateConstGEP(
7652 Address ComponentLB = Address::invalid();
7652 Address ComponentLB = Address::invalid();
8174 Address VDAddr = Address(Arg, CGF.getContext().getDeclAlign(VD));
8529 Address PtrAddr = CGF.EmitLoadOfReference(CGF.MakeAddrLValue(
8638 Address BPAddr(BP, Ctx.getTypeAlignInChars(Ctx.VoidPtrTy));
8651 Address PAddr(P, Ctx.getTypeAlignInChars(Ctx.VoidPtrTy));
8660 Address SAddr(S, Ctx.getTypeAlignInChars(Int64Ty));
8920 Address PtrCurrent =
10834 Address DimsAddr = CGF.CreateMemTemp(ArrayTy, "dims");
10884 Address CntAddr = CGF.CreateMemTemp(ArrayTy, ".cnt.addr");
10935 Address CGOpenMPRuntime::getParameterAddress(CodeGenFunction &CGF,
10967 Address CGOpenMPRuntime::getAddressOfLocalVariable(CodeGenFunction &CGF,
10970 return Address::invalid();
10973 return Address::invalid();
10978 return Address::invalid();
11256 Address IL, Address LB,
11256 Address IL, Address LB,
11257 Address UB, Address ST) {
11257 Address UB, Address ST) {
11273 Address CGOpenMPSIMDRuntime::getAddrOfThreadPrivate(CodeGenFunction &CGF,
11275 Address VDAddr,
11281 const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit,
11286 Address CGOpenMPSIMDRuntime::getAddrOfArtificialThreadPrivate(
11300 QualType SharedsTy, Address Shareds,
11308 llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds,
11335 Address CGOpenMPSIMDRuntime::getTaskReductionItem(CodeGenFunction &CGF,
11432 Address
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 146 Address PrivateAddr, LValue SharedLVal,
170 emitInitialization(CodeGenFunction &CGF, unsigned N, Address PrivateAddr,
178 void emitCleanups(CodeGenFunction &CGF, unsigned N, Address PrivateAddr);
183 Address adjustPrivateAddress(CodeGenFunction &CGF, unsigned N,
184 Address PrivateAddr);
280 virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc);
327 Address getOrCreateDefaultLocation(unsigned Flags);
754 void emitThreadPrivateVarInit(CodeGenFunction &CGF, Address VDAddr,
799 Address Shareds, const OMPTaskDataTy &Data);
1047 Address IL = Address::invalid();
1047 Address IL = Address::invalid();
1050 Address LB = Address::invalid();
1050 Address LB = Address::invalid();
1053 Address UB = Address::invalid();
1053 Address UB = Address::invalid();
1056 Address ST = Address::invalid();
1056 Address ST = Address::invalid();
1060 StaticRTInput(unsigned IVSize, bool IVSigned, bool Ordered, Address IL,
1061 Address LB, Address UB, Address ST,
1061 Address LB, Address UB, Address ST,
1061 Address LB, Address UB, Address ST,
1135 Address IL, Address LB,
1135 Address IL, Address LB,
1136 Address UB, Address ST);
1136 Address UB, Address ST);
1158 virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
1160 Address VDAddr,
1165 virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD);
1176 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
1192 virtual Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
1231 Address Shareds, const Expr *IfCond,
1266 QualType SharedsTy, Address Shareds,
1397 virtual Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc,
1531 llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;
1608 virtual Address getParameterAddress(CodeGenFunction &CGF,
1636 virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF,
1881 unsigned IVSize, bool IVSigned, Address IL,
1882 Address LB, Address UB, Address ST) override;
1882 Address LB, Address UB, Address ST) override;
1882 Address LB, Address UB, Address ST) override;
1903 Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD,
1904 Address VDAddr, SourceLocation Loc) override;
1915 emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr,
1923 Address getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
1962 Address Shareds, const Expr *IfCond,
1996 QualType SharedsTy, Address Shareds, const Expr *IfCond,
2088 Address getTaskReductionItem(CodeGenFunction &CGF, SourceLocation Loc,
2227 Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
2231 Address getAddressOfLocalVariable(CodeGenFunction &CGF,
2233 return Address::invalid();
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 1428 Address WorkFn =
1430 Address ExecStatus =
2158 Address RecPtr = Address(llvm::ConstantPointerNull::get(GlobalRecPtrTy),
2259 Address FrameAddr = CGF.EmitLoadOfPointer(
2341 Address GlobalPtr = Rec.second.PrivateAddr;
2342 Address LocalAddr = CGF.CreateMemTemp(VarTy, Rec.second.FD->getName());
2463 Address ZeroAddr = CGF.CreateDefaultAlignTempAlloca(CGF.Int32Ty,
2493 Address ZeroAddr = CGF.CreateDefaultAlignTempAlloca(CGF.Int32Ty,
2497 Address ThreadIDAddr = ZeroAddr;
2502 Address ZeroAddr =
2549 Address SharedArgs =
2563 Address SharedArgListAddress = CGF.EmitLoadOfPointer(
2567 Address Dst = Bld.CreateConstInBoundsGEP(SharedArgListAddress, Idx);
2662 Address ZeroAddr = CGF.CreateDefaultAlignTempAlloca(CGF.Int32Ty,
2666 Address ThreadIDAddr = ZeroAddr;
2671 Address ZeroAddr =
2765 Address Counter = CGF.CreateMemTemp(Int32Ty, "critical_counter");
2826 Address CastItem = CGF.CreateMemTemp(CastTy);
2827 Address ValCastItem = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
2866 static void shuffleAndStore(CodeGenFunction &CGF, Address SrcAddr,
2867 Address DestAddr, QualType ElemType,
2882 Address ElemPtr = DestAddr;
2883 Address Ptr = SrcAddr;
2884 Address PtrEnd = Bld.CreatePointerBitCastOrAddrSpaceCast(
2920 Address LocalPtr = Bld.CreateConstGEP(Ptr, 1);
2921 Address LocalElemPtr = Bld.CreateConstGEP(ElemPtr, 1);
2963 ArrayRef<const Expr *> Privates, Address SrcBase, Address DestBase,
2963 ArrayRef<const Expr *> Privates, Address SrcBase, Address DestBase,
2979 Address SrcElementAddr = Address::invalid();
2979 Address SrcElementAddr = Address::invalid();
2980 Address DestElementAddr = Address::invalid();
2980 Address DestElementAddr = Address::invalid();
2981 Address DestElementPtrAddr = Address::invalid();
2981 Address DestElementPtrAddr = Address::invalid();
2995 Address SrcElementPtrAddr = Bld.CreateConstArrayGEP(SrcBase, Idx);
3011 Address SrcElementPtrAddr = Bld.CreateConstArrayGEP(SrcBase, Idx);
3026 Address SrcElementPtrAddr = Bld.CreateConstArrayGEP(SrcBase, Idx);
3229 Address AddrReduceListArg = CGF.GetAddrOfLocalVar(&ReduceListArg);
3230 Address LocalReduceList(
3256 Address CntAddr = Address::invalid();
3256 Address CntAddr = Address::invalid();
3289 Address ElemPtrPtrAddr = Bld.CreateConstArrayGEP(LocalReduceList, Idx);
3293 Address ElemPtr = Address(ElemPtrPtr, Align);
3304 Address MediumPtr(MediumPtrVal, Align);
3335 Address AddrNumWarpsArg = CGF.GetAddrOfLocalVar(&NumWarpsArg);
3350 Address SrcMediumPtr(SrcMediumPtrVal, Align);
3355 Address TargetElemPtrPtr = Bld.CreateConstArrayGEP(LocalReduceList, Idx);
3358 Address TargetElemPtr = Address(TargetElemPtrVal, Align);
3500 Address AddrReduceListArg = CGF.GetAddrOfLocalVar(&ReduceListArg);
3501 Address LocalReduceList(
3508 Address AddrLaneIDArg = CGF.GetAddrOfLocalVar(&LaneIDArg);
3512 Address AddrRemoteLaneOffsetArg = CGF.GetAddrOfLocalVar(&RemoteLaneOffsetArg);
3516 Address AddrAlgoVerArg = CGF.GetAddrOfLocalVar(&AlgoVerArg);
3522 Address RemoteReduceList =
3655 Address AddrReduceListArg = CGF.GetAddrOfLocalVar(&ReduceListArg);
3656 Address AddrBufferArg = CGF.GetAddrOfLocalVar(&BufferArg);
3657 Address LocalReduceList(
3676 Address ElemPtrPtrAddr = Bld.CreateConstArrayGEP(LocalReduceList, Idx);
3682 Address ElemPtr =
3761 Address AddrBufferArg = CGF.GetAddrOfLocalVar(&BufferArg);
3771 Address ReductionList =
3780 Address Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
3806 Address AddrReduceListArg = CGF.GetAddrOfLocalVar(&ReduceListArg);
3855 Address AddrReduceListArg = CGF.GetAddrOfLocalVar(&ReduceListArg);
3856 Address AddrBufferArg = CGF.GetAddrOfLocalVar(&BufferArg);
3857 Address LocalReduceList(
3877 Address ElemPtrPtrAddr = Bld.CreateConstArrayGEP(LocalReduceList, Idx);
3883 Address ElemPtr =
3961 Address AddrBufferArg = CGF.GetAddrOfLocalVar(&BufferArg);
3971 Address ReductionList =
3980 Address Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
4006 Address AddrReduceListArg = CGF.GetAddrOfLocalVar(&ReduceListArg);
4301 Address ReductionList =
4306 Address Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
4477 Address
4484 Address LocalAddr = CGF.GetAddrOfLocalVar(TargetParam);
4502 Address NativeParamAddr = CGF.CreateMemTemp(NativeParamType);
4575 Address ZeroAddr = CGF.CreateDefaultAlignTempAlloca(CGF.Int32Ty,
4589 Address GlobalArgs =
4599 Address SharedArgListAddress = Address::invalid();
4599 Address SharedArgListAddress = Address::invalid();
4610 Address Src = Bld.CreateConstInBoundsGEP(SharedArgListAddress, Idx);
4611 Address TypedAddress = Bld.CreatePointerBitCastOrAddrSpaceCast(
4635 Address Src = Bld.CreateConstInBoundsGEP(SharedArgListAddress, I + Idx);
4636 Address TypedAddress = Bld.CreatePointerBitCastOrAddrSpaceCast(
4734 Address CGOpenMPRuntimeNVPTX::getAddressOfLocalVariable(CodeGenFunction &CGF,
4746 return Address::invalid();
4749 return Address::invalid();
4789 return Address::invalid();
4794 return Address::invalid();
4810 return Address::invalid();
4862 Address VDAddr = CGF.GetAddrOfLocalVar(VD);
4887 Address VDAddr = CGF.GetAddrOfLocalVar(VD);
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.h 349 Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
363 Address getAddressOfLocalVariable(CodeGenFunction &CGF,
443 Address PrivateAddr = Address::invalid();
443 Address PrivateAddr = Address::invalid();
tools/clang/lib/CodeGen/CGStmt.cpp 379 Address CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast,
390 Address
399 Address RetAlloca = Address::invalid();
399 Address RetAlloca = Address::invalid();
2333 Address A = Builder.CreateBitCast(Dest.getAddress(),
2391 Address CodeGenFunction::GenerateCapturedStmtArgument(const CapturedStmt &S) {
2427 Address DeclPtr = GetAddrOfLocalVar(CD->getContextParam());
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 306 Address DstAddr = CreateMemTemp(
331 static Address castValueFromUintptr(CodeGenFunction &CGF, SourceLocation Loc,
339 Address TmpAddr =
385 llvm::MapVector<const Decl *, std::pair<const VarDecl *, Address>>
487 Address LocalAddr(Address::invalid());
487 Address LocalAddr(Address::invalid());
520 Address ArgAddr = ArgLVal.getAddress();
567 llvm::MapVector<const Decl *, std::pair<const VarDecl *, Address>> LocalAddrs;
640 Address DestAddr, Address SrcAddr, QualType OriginalType,
640 Address DestAddr, Address SrcAddr, QualType OriginalType,
641 const llvm::function_ref<void(Address, Address)> CopyGen) {
641 const llvm::function_ref<void(Address, Address)> CopyGen) {
670 Address SrcElementCurrent =
677 Address DestElementCurrent =
700 void CodeGenFunction::EmitOMPCopy(QualType OriginalType, Address DestAddr,
701 Address SrcAddr, const VarDecl *DestVD,
850 Address OriginalAddr = OriginalLVal.getAddress();
920 Address MasterAddr = Address::invalid();
920 Address MasterAddr = Address::invalid();
936 Address PrivateAddr = EmitLValue(*IRef).getAddress();
1081 Address OriginalAddr = GetAddrOfLocalVar(DestVD);
1083 Address PrivateAddr = GetAddrOfLocalVar(PrivateVD);
1146 Address BaseAddr = RedCG.adjustPrivateAddress(
1181 Address OriginalAddr = RedCG.getSharedLValue(Count).getAddress();
1503 Address OrigAddr = EmitLValue(&DRE).getAddress();
1625 Address CounterAddr =
1734 Address OrigAddr = Address::invalid();
1734 Address OrigAddr = Address::invalid();
2186 Address LB, Address UB) {
2186 Address LB, Address UB) {
2551 Address LB, Address UB) {
2551 Address LB, Address UB) {
2995 llvm::SmallVector<std::pair<const VarDecl *, Address>, 16> PrivatePtrs;
3000 Address PrivatePtr = CGF.CreateMemTemp(
3007 Address PrivatePtr =
3015 Address PrivatePtr =
3035 Address Replacement(CGF.Builder.CreateLoad(Pair.second),
3054 Address Replacement = CGF.CGM.getOpenMPRuntime().getTaskReductionItem(
3106 Address Replacement = CGF.CGM.getOpenMPRuntime().getTaskReductionItem(
3167 Address CapturedStruct = GenerateCapturedStmtArgument(*CS);
3233 llvm::SmallVector<std::pair<const VarDecl *, Address>, 16> PrivatePtrs;
3238 Address PrivatePtr =
3247 Address Replacement(CGF.Builder.CreateLoad(Pair.second),
3282 Address CapturedStruct = GenerateCapturedStmtArgument(*CS);
4635 const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap) {
4674 Address InitAddr = Builder.CreateBitCast(InitAddrIt->second, AddrTy);
4968 Address CapturedStruct = GenerateCapturedStmtArgument(*CS);
tools/clang/lib/CodeGen/CGVTables.cpp 200 Address ThisPtr(&*AI, CGM.getClassPointerAlignment(MD->getParent()));
411 Address ThisAddr = GetAddrOfLocalVar(CXXABIThisDecl);
tools/clang/lib/CodeGen/CGValue.h 70 Address getAggregateAddress() const {
106 static RValue getAggregate(Address addr, bool isVolatile = false) {
326 Address getAddress() const { return Address(getPointer(), getAlignment()); }
327 void setAddress(Address address) {
334 Address getVectorAddress() const {
341 Address getExtVectorAddress() const {
354 Address getBitFieldAddress() const {
366 static LValue MakeAddr(Address address, QualType type, ASTContext &Context,
379 static LValue MakeVectorElt(Address vecAddress, llvm::Value *Idx,
391 static LValue MakeExtVectorElt(Address vecAddress, llvm::Constant *Elts,
409 static LValue MakeBitfield(Address Addr, const CGBitFieldInfo &Info,
421 static LValue MakeGlobalReg(Address Reg, QualType type) {
499 return forAddr(Address::invalid(), Qualifiers(), IsNotDestructed,
513 static AggValueSlot forAddr(Address addr,
582 Address getAddress() const {
tools/clang/lib/CodeGen/CodeGenFunction.cpp 428 NormalCleanupDest = Address::invalid();
460 ReturnValue = Address::invalid();
897 ReturnValue = Address::invalid();
1575 Address dest, Address src,
1575 Address dest, Address src,
1583 Address begin =
1619 CodeGenFunction::EmitNullInitialization(Address DestPtr, QualType Ty) {
1675 Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
1722 Address &addr) {
2000 Address CodeGenFunction::EmitVAListRef(const Expr* E) {
2006 Address CodeGenFunction::EmitMSVAListRef(const Expr *E) {
2096 Address CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D,
2097 Address Addr) {
tools/clang/lib/CodeGen/CodeGenFunction.h 172 typedef Address type;
283 CodeGenFunction &, const OMPExecutableDirective &S, Address LB,
284 Address UB)>
328 Address ReturnValue = Address::invalid();
328 Address ReturnValue = Address::invalid();
332 Address ReturnValuePointer = Address::invalid();
332 Address ReturnValuePointer = Address::invalid();
508 CallLifetimeEnd(Address addr, llvm::Value *size)
531 Address NormalCleanupDest = Address::invalid();
531 Address NormalCleanupDest = Address::invalid();
552 SmallVector<Address, 1> SEHCodeSlotStack;
563 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
563 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
564 return DominatingValue<T>::save(*this, value);
607 void pushFullExprCleanup(CleanupKind kind, As... A) {
614 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
617 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
625 void pushCleanupAfterFullExpr(CleanupKind Kind, As... A) {
627 return pushCleanupAfterFullExprImpl<T>(Kind, Address::invalid(), A...);
629 Address ActiveFlag = createCleanupActiveFlag();
633 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
636 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
641 void pushCleanupAfterFullExprImpl(CleanupKind Kind, Address ActiveFlag,
642 As... A) {
657 new (Buffer + sizeof(Header) + sizeof(T)) Address(ActiveFlag);
666 void initFullExprCleanupWithFlag(Address ActiveFlag);
667 Address createCleanupActiveFlag();
673 void PushDestructorCleanup(QualType T, Address Addr);
679 Address Addr);
820 typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
839 Address TempAddr) {
849 SavedLocals.try_emplace(LocalVD, Address::invalid());
854 Address Temp = CGF.CreateMemTemp(VarTy);
917 const llvm::function_ref<Address()> PrivateGen) {
1033 void setBeforeOutermostConditional(llvm::Value *value, Address addr) {
1417 FieldConstructionScope(CodeGenFunction &CGF, Address This)
1427 Address OldCXXDefaultInitExprThis;
1496 CGF.ReturnValue = Address::invalid();
1525 Address OldReturnValue;
1541 Address CXXDefaultInitExprThis = Address::invalid();
1541 Address CXXDefaultInitExprThis = Address::invalid();
1584 Address ReturnLocation = Address::invalid();
1584 Address ReturnLocation = Address::invalid();
1634 Address getExceptionSlot();
1635 Address getEHSelectorSlot();
1642 Address getNormalCleanupDestSlot();
1669 typedef void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty);
1672 Address arrayEndPointer,
1683 Address addr, QualType type);
1685 Address addr, QualType type);
1686 void pushDestroy(CleanupKind kind, Address addr, QualType type,
1688 void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr,
1694 void pushStackRestore(CleanupKind kind, Address SPMem);
1695 void emitDestroy(Address addr, QualType type, Destroyer *destroyer,
1697 llvm::Function *generateDestroyHelper(Address addr, QualType type,
1807 void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags,
1813 Address LoadBlockStruct();
1814 Address GetAddrOfBlockDecl(const VarDecl *var);
1818 Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V,
1818 Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V,
1820 Address emitBlockByrefAddress(Address baseAddr,
1820 Address emitBlockByrefAddress(Address baseAddr,
1927 llvm::Value *GetVTablePtr(Address This, llvm::Type *VTableTy,
2123 LValue MakeAddrLValue(Address Addr, QualType T,
2129 LValue MakeAddrLValue(Address Addr, QualType T, LValueBaseInfo BaseInfo,
2156 Address EmitLoadOfReference(LValue RefLVal,
2160 LValue EmitLoadOfReferenceLValue(Address RefAddr, QualType RefTy,
2168 Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy,
2168 Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy,
2171 LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy);
2201 Address CreateTempAlloca(llvm::Type *Ty, CharUnits align,
2204 Address *Alloca = nullptr);
2205 Address CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align,
2219 Address CreateDefaultAlignTempAlloca(llvm::Type *Ty,
2229 void InitTempAlloca(Address Alloca, llvm::Value *Value);
2239 Address CreateIRTemp(QualType T, const Twine &Name = "tmp");
2244 Address CreateMemTemp(QualType T, const Twine &Name = "tmp",
2245 Address *Alloca = nullptr);
2246 Address CreateMemTemp(QualType T, CharUnits Align, const Twine &Name = "tmp",
2247 Address *Alloca = nullptr);
2251 Address CreateMemTempWithoutCast(QualType T, const Twine &Name = "tmp");
2252 Address CreateMemTempWithoutCast(QualType T, CharUnits Align,
2288 Address EmitVAListRef(const Expr *E);
2293 Address EmitMSVAListRef(const Expr *E);
2301 void EmitAnyExprToMem(const Expr *E, Address Location,
2304 void EmitAnyExprToExn(const Expr *E, Address Addr);
2361 Address GetAddrOfLocalVar(const VarDecl *VD) {
2392 void EmitNullInitialization(Address DestPtr, QualType Ty);
2410 Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr);
2410 Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr);
2416 Address &addr);
2449 Address LoadCXXThisAddress();
2462 Address
2463 GetAddressOfDirectBaseInCompleteClass(Address Value,
2472 Address GetAddressOfBaseClass(Address Value,
2472 Address GetAddressOfBaseClass(Address Value,
2478 Address GetAddressOfDerivedClass(Address Value,
2478 Address GetAddressOfDerivedClass(Address Value,
2516 bool ForVirtualBase, Address This,
2526 Address This, CallArgList &Args,
2532 void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This);
2535 void EmitVTableAssumptionLoad(const VPtr &vptr, Address This);
2538 Address This, Address Src,
2538 Address This, Address Src,
2543 Address ArrayPtr,
2550 Address ArrayPtr,
2558 bool ForVirtualBase, bool Delegating, Address This,
2562 llvm::Type *ElementTy, Address NewPtr,
2567 Address Ptr);
2583 llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE);
2584 Address EmitCXXUuidofExpr(const CXXUuidofExpr *E);
2698 Address Addr;
2715 Address AllocaAddr;
2719 : Variable(nullptr), Addr(Address::invalid()),
2720 AllocaAddr(Address::invalid()) {}
2723 : Variable(&variable), Addr(Address::invalid()), NRVOFlag(nullptr),
2725 SizeForLifetimeMarkers(nullptr), AllocaAddr(Address::invalid()) {}
2743 Address getAllocatedAddress() const {
2748 Address getOriginalAllocatedAddress() const { return AllocaAddr; }
2753 Address getObjectAddress(CodeGenFunction &CGF) const {
2785 static ParamValue forIndirect(Address addr) {
2798 Address getIndirectAddress() const {
2859 Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
2861 Address EmitCompoundStmtWithoutScope(const CompoundStmt &S,
2950 Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF,
2951 Address ParentVar,
2975 Address GenerateCapturedStmtArgument(const CapturedStmt &S);
2991 Address DestAddr, Address SrcAddr, QualType OriginalType,
2991 Address DestAddr, Address SrcAddr, QualType OriginalType,
2992 const llvm::function_ref<void(Address, Address)> CopyGen);
2992 const llvm::function_ref<void(Address, Address)> CopyGen);
3005 Address DestAddr, Address SrcAddr,
3005 Address DestAddr, Address SrcAddr,
3031 const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap);
3109 Address BasePointersArray = Address::invalid();
3109 Address BasePointersArray = Address::invalid();
3110 Address PointersArray = Address::invalid();
3110 Address PointersArray = Address::invalid();
3111 Address SizesArray = Address::invalid();
3111 Address SizesArray = Address::invalid();
3114 OMPTargetDataInfo(Address BasePointersArray, Address PointersArray,
3114 OMPTargetDataInfo(Address BasePointersArray, Address PointersArray,
3115 Address SizesArray, unsigned NumberOfTargetItems)
3280 Address LB = Address::invalid();
3280 Address LB = Address::invalid();
3282 Address UB = Address::invalid();
3282 Address UB = Address::invalid();
3284 Address ST = Address::invalid();
3284 Address ST = Address::invalid();
3286 Address IL = Address::invalid();
3286 Address IL = Address::invalid();
3302 OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
3302 OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
3302 OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
3302 OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
3372 RValue convertTempToRValue(Address addr, QualType type,
3421 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
3429 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
3443 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
3451 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
3519 Address EmitExtVectorElementLValue(LValue V);
3523 Address EmitArrayToPointerDecay(const Expr *Array,
3694 Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
3694 Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
3750 Address PtrOp0, Address PtrOp1,
3750 Address PtrOp0, Address PtrOp1,
3807 void EmitARCInitWeak(Address addr, llvm::Value *value);
3808 void EmitARCDestroyWeak(Address addr);
3809 llvm::Value *EmitARCLoadWeak(Address addr);
3810 llvm::Value *EmitARCLoadWeakRetained(Address addr);
3811 llvm::Value *EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored);
3812 void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
3812 void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
3813 void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
3813 void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
3814 void EmitARCCopyWeak(Address dst, Address src);
3814 void EmitARCCopyWeak(Address dst, Address src);
3815 void EmitARCMoveWeak(Address dst, Address src);
3815 void EmitARCMoveWeak(Address dst, Address src);
3820 llvm::Value *EmitARCStoreStrongCall(Address addr, llvm::Value *value,
3825 void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise);
3929 Address emitAddrOfRealComponent(Address complex, QualType complexType);
3929 Address emitAddrOfRealComponent(Address complex, QualType complexType);
3930 Address emitAddrOfImagComponent(Address complex, QualType complexType);
3930 Address emitAddrOfImagComponent(Address complex, QualType complexType);
3996 void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
3996 void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
4025 Address EmitFieldAnnotations(const FieldDecl *D, Address V);
4025 Address EmitFieldAnnotations(const FieldDecl *D, Address V);
4167 void setAddrOfLocalVar(const VarDecl *VD, Address Addr) {
4213 Address Loc);
4317 Address EmitPointerWithAlignment(const Expr *Addr,
4379 Address alloca =
tools/clang/lib/CodeGen/CodeGenModule.cpp 5756 Address Addr(GetAddrOfGlobalVar(VD), getContext().getDeclAlign(VD));
tools/clang/lib/CodeGen/CodeGenModule.h 269 virtual void emitCopy(CodeGenFunction &CGF, Address dest, Address src) = 0;
269 virtual void emitCopy(CodeGenFunction &CGF, Address dest, Address src) = 0;
272 virtual void emitDispose(CodeGenFunction &CGF, Address field) = 0;
630 Address createUnnamedGlobalFrom(const VarDecl &D, llvm::Constant *Constant,
tools/clang/lib/CodeGen/EHScopeStack.h 198 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
205 return T{DominatingValue<As>::restore(CGF, std::get<Is>(Saved))...};
213 ConditionalCleanup(typename DominatingValue<As>::saved_type... A)
272 template <class T, class... As> void pushCleanup(CleanupKind Kind, As... A) {
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 122 Address This,
129 Address Base,
158 Address Ptr, QualType ElementType,
181 Address ThisPtr,
187 llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
192 llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
199 GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
231 bool Delegating, Address This,
264 Address This, llvm::Type *Ty,
269 CXXDtorType DtorType, Address This,
288 llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
291 llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
305 Address InitializeArrayCookie(CodeGenFunction &CGF,
306 Address NewPtr,
311 Address allocPtr,
405 LoadVTablePtr(CodeGenFunction &CGF, Address This,
471 Address InitializeArrayCookie(CodeGenFunction &CGF,
472 Address NewPtr,
476 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, Address allocPtr,
576 CodeGenFunction &CGF, const Expr *E, Address ThisAddr,
787 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
1171 Address Ptr,
1381 Address ThisPtr,
1399 CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1442 Address ThisAddr,
1480 Address This,
1616 bool Delegating, Address This,
1776 Address This,
1818 Address This, DeleteOrMemberCallExpr E) {
1907 Address InitialPtr,
1914 Address V = CGF.Builder.CreateElementBitCast(InitialPtr, CGF.Int8Ty);
1928 Address VTablePtrPtr = CGF.Builder.CreateElementBitCast(V, CGF.Int8PtrTy);
1958 Address This,
1966 ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
1993 Address ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1994 Address NewPtr,
2011 Address CookiePtr = NewPtr;
2017 Address NumElementsPtr =
2040 Address allocPtr,
2043 Address numElementsPtr = allocPtr;
2078 Address ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2079 Address newPtr,
2086 Address cookie = newPtr;
2105 Address allocPtr,
2109 Address numElementsPtr
2254 Address guardAddr = Address(guard, guardAlignment);
4090 Address ParamAddr,
4144 Address ExnPtrTmp =
4223 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4237 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4370 ItaniumCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 115 Address Ptr, QualType ElementType,
138 Address ThisPtr,
144 llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
149 llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
159 GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
244 Address
246 Address This,
261 bool Delegating, Address This,
295 Address This, llvm::Type *Ty,
300 CXXDtorType DtorType, Address This,
378 llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
381 llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
429 Address InitializeArrayCookie(CodeGenFunction &CGF,
430 Address NewPtr,
435 Address allocPtr,
574 Address Base,
580 Address Base,
590 std::tuple<Address, llvm::Value *, const CXXRecordDecl *>
591 performBaseAdjustment(CodeGenFunction &CGF, Address Value,
597 const CXXRecordDecl *RD, Address Base,
651 Address Base, llvm::Value *MemPtr,
674 Address This, llvm::Value *&ThisPtrForCall,
759 LoadVTablePtr(CodeGenFunction &CGF, Address This,
842 Address Ptr,
891 std::tuple<Address, llvm::Value *, const CXXRecordDecl *>
892 MicrosoftCXXABI::performBaseAdjustment(CodeGenFunction &CGF, Address Value,
951 Address ThisPtr,
967 CodeGenFunction &CGF, Address This, QualType SrcRecordTy,
1001 MicrosoftCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
1022 CodeGenFunction &CGF, Address This, const CXXRecordDecl *ClassDecl,
1235 Address This = getThisAddress(CGF);
1250 Address VBPtr = CGF.Builder.CreateConstInBoundsByteGEP(This, Offs);
1379 Address MicrosoftCXXABI::adjustThisArgumentForVirtualFunctionCall(
1380 CodeGenFunction &CGF, GlobalDecl GD, Address This,
1418 Address Result = This;
1573 bool Delegating, Address This,
1858 Address This,
1864 Address VPtr =
1905 Address This, DeleteOrMemberCallExpr E) {
2127 Address This,
2140 Address VtorDispPtr =
2179 MicrosoftCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
2227 Address allocPtr,
2229 Address numElementsPtr =
2234 Address MicrosoftCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2235 Address newPtr,
2245 Address cookiePtr = newPtr;
2248 Address numElementsPtr
2400 Address Guard;
2402 ResetGuardBit(Address Guard, unsigned GuardNum)
2418 CallInitThreadAbort(Address Guard) : Guard(Guard.getPointer()) {}
2940 Address This,
2979 Address Base, llvm::Value *VBTableOffset, llvm::Value *VBPtrOffset) {
3034 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
3324 CodeGenFunction &CGF, const Expr *E, Address This,
4277 Address AI = CGF.CreateMemTemp(ThrowType);
4294 MicrosoftCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
tools/clang/lib/CodeGen/TargetInfo.cpp 92 Address ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
92 Address ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
94 return Address::invalid();
287 static Address emitVoidPtrDirectVAArg(CodeGenFunction &CGF,
288 Address VAListAddr,
302 Address Addr = Address::invalid();
302 Address Addr = Address::invalid();
312 Address NextPtr =
340 static Address emitVoidPtrVAArg(CodeGenFunction &CGF, Address VAListAddr,
340 static Address emitVoidPtrVAArg(CodeGenFunction &CGF, Address VAListAddr,
360 Address Addr = emitVoidPtrDirectVAArg(CGF, VAListAddr, DirectTy,
373 static Address emitMergePHI(CodeGenFunction &CGF,
374 Address Addr1, llvm::BasicBlock *Block1,
375 Address Addr2, llvm::BasicBlock *Block2,
607 Address EmitVAArgInstr(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
607 Address EmitVAArgInstr(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
648 Address Temp = CGF.CreateMemTemp(Ty, "varet");
673 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
673 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
747 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
747 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
834 Address WebAssemblyABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
834 Address WebAssemblyABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
860 Address EmitVAArg(CodeGenFunction &CGF,
861 Address VAListAddr, QualType Ty) const override;
878 Address PNaClABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
878 Address PNaClABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
1073 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
1073 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
1936 Address X86_32ABIInfo::EmitVAArg(CodeGenFunction &CGF,
1937 Address VAListAddr, QualType Ty) const {
2220 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
2220 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
2222 Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
2222 Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
2247 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
2247 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
3680 static Address EmitX86_64VAArgFromMemory(CodeGenFunction &CGF,
3681 Address VAListAddr, QualType Ty) {
3682 Address overflow_arg_area_p =
3719 Address X86_64ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
3719 Address X86_64ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
3751 Address gp_offset_p = Address::invalid(), fp_offset_p = Address::invalid();
3751 Address gp_offset_p = Address::invalid(), fp_offset_p = Address::invalid();
3751 Address gp_offset_p = Address::invalid(), fp_offset_p = Address::invalid();
3792 Address RegAddr = Address::invalid();
3792 Address RegAddr = Address::invalid();
3797 Address Tmp = CGF.CreateMemTemp(Ty);
3839 Address Tmp = CGF.CreateMemTemp(Ty);
3856 Address RegAddrLo = Address(CGF.Builder.CreateGEP(RegSaveArea, fp_offset),
3858 Address RegAddrHi =
3865 Address Tmp = CGF.CreateMemTemp(Ty);
3895 Address MemAddr = EmitX86_64VAArgFromMemory(CGF, VAListAddr, Ty);
3900 Address ResAddr = emitMergePHI(CGF, RegAddr, InRegBlock, MemAddr, InMemBlock,
3905 Address X86_64ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
3905 Address X86_64ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
4106 Address WinX86_64ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4106 Address WinX86_64ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4136 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4136 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4181 Address PPC32_SVR4_ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAList,
4181 Address PPC32_SVR4_ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAList,
4197 return Address::invalid(); // FIXME?
4220 Address NumRegsAddr = Address::invalid();
4220 Address NumRegsAddr = Address::invalid();
4248 Address RegAddr = Address::invalid();
4248 Address RegAddr = Address::invalid();
4252 Address RegSaveAreaPtr = Builder.CreateStructGEP(VAList, 4);
4283 Address MemAddr = Address::invalid();
4283 Address MemAddr = Address::invalid();
4300 Address OverflowAreaAddr = Builder.CreateStructGEP(VAList, 3);
4301 Address OverflowArea(Builder.CreateLoad(OverflowAreaAddr, "argp.cur"),
4322 Address Result = emitMergePHI(CGF, RegAddr, UsingRegs, MemAddr, UsingOverflow,
4464 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4464 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4858 Address PPC64_SVR4_ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4858 Address PPC64_SVR4_ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
4874 Address Addr = emitVoidPtrDirectVAArg(CGF, VAListAddr, CGF.Int8Ty,
4878 Address RealAddr = Addr;
4879 Address ImagAddr = RealAddr;
4895 Address Temp = CGF.CreateMemTemp(Ty, "vacplx");
5010 Address EmitDarwinVAArg(Address VAListAddr, QualType Ty,
5010 Address EmitDarwinVAArg(Address VAListAddr, QualType Ty,
5013 Address EmitAAPCSVAArg(Address VAListAddr, QualType Ty,
5013 Address EmitAAPCSVAArg(Address VAListAddr, QualType Ty,
5016 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
5016 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
5023 Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
5023 Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
5299 Address AArch64ABIInfo::EmitAAPCSVAArg(Address VAListAddr,
5299 Address AArch64ABIInfo::EmitAAPCSVAArg(Address VAListAddr,
5337 Address reg_offs_p = Address::invalid();
5337 Address reg_offs_p = Address::invalid();
5413 Address reg_top_p =
5416 Address BaseAddr(CGF.Builder.CreateInBoundsGEP(reg_top, reg_offs),
5418 Address RegAddr = Address::invalid();
5418 Address RegAddr = Address::invalid();
5439 Address Tmp = CGF.CreateTempAlloca(HFATy,
5450 Address LoadAddr =
5454 Address StoreAddr = CGF.Builder.CreateConstArrayGEP(Tmp, i);
5483 Address stack_p = CGF.Builder.CreateStructGEP(VAListAddr, 0, "stack_p");
5502 Address OnStackAddr(OnStackPtr,
5535 Address ResAddr = emitMergePHI(CGF, RegAddr, InRegBlock,
5545 Address AArch64ABIInfo::EmitDarwinVAArg(Address VAListAddr, QualType Ty,
5545 Address AArch64ABIInfo::EmitDarwinVAArg(Address VAListAddr, QualType Ty,
5557 Address Addr(CGF.Builder.CreateLoad(VAListAddr, "ap.cur"), SlotSize);
5579 Address AArch64ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
5579 Address AArch64ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
5658 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
5658 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6285 Address ARMABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6285 Address ARMABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6291 Address Addr(CGF.Builder.CreateLoad(VAListAddr), SlotSize);
6348 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6348 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6457 Address NVPTXABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6457 Address NVPTXABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6564 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6564 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6674 Address SystemZABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6674 Address SystemZABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6723 Address OverflowArgAreaPtr =
6725 Address OverflowArgArea =
6728 Address MemAddr =
6756 Address RegCountPtr =
6779 Address RegSaveAreaPtr =
6783 Address RawRegAddr(CGF.Builder.CreateGEP(RegSaveArea, RegOffset,
6786 Address RegAddr =
6800 Address OverflowArgAreaPtr =
6802 Address OverflowArgArea =
6805 Address RawMemAddr =
6807 Address MemAddr =
6819 Address ResAddr = emitMergePHI(CGF, RegAddr, InRegBlock,
6949 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
6949 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7247 Address MipsABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7247 Address MipsABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7274 Address Addr = emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*indirect*/ false,
7281 Address Temp = CGF.CreateMemTemp(OrigTy, "vaarg.promotion-temp");
7446 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7446 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7537 Address HexagonABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7537 Address HexagonABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7697 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7697 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7762 Address AMDGPUABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
7762 Address AMDGPUABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8192 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8192 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8351 Address SparcV9ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8351 Address SparcV9ABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8361 Address Addr(Builder.CreateLoad(VAListAddr, "ap.cur"), SlotSize);
8366 Address ArgAddr = Address::invalid();
8366 Address ArgAddr = Address::invalid();
8400 Address NextPtr = Builder.CreateConstInBoundsByteGEP(Addr, Stride, "ap.next");
8469 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8469 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8526 Address ARCABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8526 Address ARCABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8694 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8694 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8711 Address XCoreABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8711 Address XCoreABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
8717 Address AP(Builder.CreateLoad(VAListAddr), SlotSize);
8727 Address Val = Address::invalid();
8727 Address Val = Address::invalid();
8754 Address APN = Builder.CreateConstInBoundsByteGEP(AP, ArgSize);
9272 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
9272 Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
9634 Address RISCVABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
9634 Address RISCVABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
9640 Address Addr(CGF.Builder.CreateLoad(VAListAddr), SlotSize);
usr/include/c++/7.4.0/array 50 typedef _Tp _Type[_Nm];
51 typedef __is_swappable<_Tp> _Is_swappable;
52 typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;
54 static constexpr _Tp&
58 static constexpr _Tp*
96 typedef _Tp value_type;
109 typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;
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 101 is_constructible<_T2, const _U2&>>::value;
101 is_constructible<_T2, const _U2&>>::value;
108 is_convertible<const _U2&, _T2>>::value;
108 is_convertible<const _U2&, _T2>>::value;
115 is_constructible<_T2, _U2&&>>::value;
115 is_constructible<_T2, _U2&&>>::value;
122 is_convertible<_U2&&, _T2>>::value;
122 is_convertible<_U2&&, _T2>>::value;
129 is_convertible<_U2&&, _T2>>;
129 is_convertible<_U2&&, _T2>>;
134 is_constructible<_T2, _U2&&>,
134 is_constructible<_T2, _U2&&>,
143 is_convertible<const _U2&, _T2>>;
143 is_convertible<const _U2&, _T2>>;
148 is_constructible<_T2, const _U2&&>,
148 is_constructible<_T2, const _U2&&>,
209 : private __pair_base<_T1, _T2>
212 typedef _T2 second_type; /// @c second_type is the second bound type
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
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)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
380 is_copy_assignable<_T2>>::value,
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)
usr/include/c++/7.4.0/tuple 56 struct __is_empty_non_tuple : is_empty<_Tp> { };
125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
133 : _M_head_impl(std::forward<_UHead>(__h)) { }
159 static constexpr _Head&
162 static constexpr const _Head&
165 _Head _M_head_impl;
187 private _Head_base<_Idx, _Head>
192 typedef _Head_base<_Idx, _Head> _Base;
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)
218 _Base(std::forward<_UHead>(__head)) { }
227 _Base(std::forward<_Head>(_M_head(__in))) { }
230 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
237 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
238 _Base(std::forward<_UHead>
239 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
248 const _Head& __head, const _Tail&... __tail)
322 _M_head(*this) = std::forward<_UHead>
323 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
325 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
508 return __not_<is_same<tuple<_Elements...>,
556 class tuple : public _Tuple_impl<0, _Elements...>
558 typedef _Tuple_impl<0, _Elements...> _Inherited;
598 _Elements...>;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
628 _Elements...>;
636 _Elements...>;
646 constexpr tuple(_UElements&&... __elements)
647 : _Inherited(std::forward<_UElements>(__elements)...) { }
668 _Elements...>;
678 constexpr tuple(const tuple<_UElements...>& __in)
702 constexpr tuple(tuple<_UElements...>&& __in)
730 const _Elements&... __elements)
741 const _Elements&... __elements)
853 operator=(const tuple<_UElements...>& __in)
863 operator=(tuple<_UElements...>&& __in)
1447 constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
1448 make_tuple(_Elements&&... __args)
1450 typedef tuple<typename __decay_and_strip<_Elements>::__type...>
1452 return __result_type(std::forward<_Elements>(__args)...);
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
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>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1358 : public __is_nt_move_assignable_impl<_Tp>
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; };
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; };
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;