clang 19.0.0git
CGValue.h
Go to the documentation of this file.
1//===-- CGValue.h - LLVM CodeGen wrappers for llvm::Value* ------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// These classes implement wrappers around llvm::Value in order to
10// fully represent the range of values for C L- and R- values.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_LIB_CODEGEN_CGVALUE_H
15#define LLVM_CLANG_LIB_CODEGEN_CGVALUE_H
16
18#include "clang/AST/Type.h"
19#include "llvm/IR/Value.h"
20#include "llvm/IR/Type.h"
21#include "Address.h"
22#include "CodeGenTBAA.h"
23
24namespace llvm {
25 class Constant;
26 class MDNode;
27}
28
29namespace clang {
30namespace CodeGen {
31 class AggValueSlot;
32 class CodeGenFunction;
33 struct CGBitFieldInfo;
34
35/// RValue - This trivial value class is used to represent the result of an
36/// expression that is evaluated. It can be one of three things: either a
37/// simple LLVM SSA value, a pair of SSA values for complex numbers, or the
38/// address of an aggregate value in memory.
39class RValue {
40 enum Flavor { Scalar, Complex, Aggregate };
41
42 // The shift to make to an aggregate's alignment to make it look
43 // like a pointer.
44 enum { AggAlignShift = 4 };
45
46 // Stores first value and flavor.
47 llvm::PointerIntPair<llvm::Value *, 2, Flavor> V1;
48 // Stores second value and volatility.
49 llvm::PointerIntPair<llvm::Value *, 1, bool> V2;
50 // Stores element type for aggregate values.
51 llvm::Type *ElementType;
52
53public:
54 bool isScalar() const { return V1.getInt() == Scalar; }
55 bool isComplex() const { return V1.getInt() == Complex; }
56 bool isAggregate() const { return V1.getInt() == Aggregate; }
57
58 bool isVolatileQualified() const { return V2.getInt(); }
59
60 /// getScalarVal() - Return the Value* of this scalar value.
61 llvm::Value *getScalarVal() const {
62 assert(isScalar() && "Not a scalar!");
63 return V1.getPointer();
64 }
65
66 /// getComplexVal - Return the real/imag components of this complex value.
67 ///
68 std::pair<llvm::Value *, llvm::Value *> getComplexVal() const {
69 return std::make_pair(V1.getPointer(), V2.getPointer());
70 }
71
72 /// getAggregateAddr() - Return the Value* of the address of the aggregate.
74 assert(isAggregate() && "Not an aggregate!");
75 auto align = reinterpret_cast<uintptr_t>(V2.getPointer()) >> AggAlignShift;
76 return Address(
77 V1.getPointer(), ElementType, CharUnits::fromQuantity(align));
78 }
79 llvm::Value *getAggregatePointer() const {
80 assert(isAggregate() && "Not an aggregate!");
81 return V1.getPointer();
82 }
83
84 static RValue getIgnored() {
85 // FIXME: should we make this a more explicit state?
86 return get(nullptr);
87 }
88
89 static RValue get(llvm::Value *V) {
90 RValue ER;
91 ER.V1.setPointer(V);
92 ER.V1.setInt(Scalar);
93 ER.V2.setInt(false);
94 return ER;
95 }
96 static RValue getComplex(llvm::Value *V1, llvm::Value *V2) {
97 RValue ER;
98 ER.V1.setPointer(V1);
99 ER.V2.setPointer(V2);
100 ER.V1.setInt(Complex);
101 ER.V2.setInt(false);
102 return ER;
103 }
104 static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) {
105 return getComplex(C.first, C.second);
106 }
107 // FIXME: Aggregate rvalues need to retain information about whether they are
108 // volatile or not. Remove default to find all places that probably get this
109 // wrong.
110 static RValue getAggregate(Address addr, bool isVolatile = false) {
111 RValue ER;
112 ER.V1.setPointer(addr.getPointer());
113 ER.V1.setInt(Aggregate);
114 ER.ElementType = addr.getElementType();
115
116 auto align = static_cast<uintptr_t>(addr.getAlignment().getQuantity());
117 ER.V2.setPointer(reinterpret_cast<llvm::Value*>(align << AggAlignShift));
118 ER.V2.setInt(isVolatile);
119 return ER;
120 }
121};
122
123/// Does an ARC strong l-value have precise lifetime?
127
128/// The source of the alignment of an l-value; an expression of
129/// confidence in the alignment actually matching the estimate.
130enum class AlignmentSource {
131 /// The l-value was an access to a declared entity or something
132 /// equivalently strong, like the address of an array allocated by a
133 /// language runtime.
134 Decl,
135
136 /// The l-value was considered opaque, so the alignment was
137 /// determined from a type, but that type was an explicitly-aligned
138 /// typedef.
140
141 /// The l-value was considered opaque, so the alignment was
142 /// determined from a type.
143 Type
144};
145
146/// Given that the base address has the given alignment source, what's
147/// our confidence in the alignment of the field?
149 // For now, we don't distinguish fields of opaque pointers from
150 // top-level declarations, but maybe we should.
152}
153
155 AlignmentSource AlignSource;
156
157public:
159 : AlignSource(Source) {}
160 AlignmentSource getAlignmentSource() const { return AlignSource; }
161 void setAlignmentSource(AlignmentSource Source) { AlignSource = Source; }
162
163 void mergeForCast(const LValueBaseInfo &Info) {
165 }
166};
167
168/// LValue - This represents an lvalue references. Because C/C++ allow
169/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a
170/// bitrange.
171class LValue {
172 enum {
173 Simple, // This is a normal l-value, use getAddress().
174 VectorElt, // This is a vector element l-value (V[i]), use getVector*
175 BitField, // This is a bitfield l-value, use getBitfield*.
176 ExtVectorElt, // This is an extended vector subset, use getExtVectorComp
177 GlobalReg, // This is a register l-value, use getGlobalReg()
178 MatrixElt // This is a matrix element, use getVector*
179 } LVType;
180
181 llvm::Value *V;
182 llvm::Type *ElementType;
183
184 union {
185 // Index into a vector subscript: V[i]
186 llvm::Value *VectorIdx;
187
188 // ExtVector element subset: V.xyx
189 llvm::Constant *VectorElts;
190
191 // BitField start bit and size
193 };
194
196
197 // 'const' is unused here
198 Qualifiers Quals;
199
200 // The alignment to use when accessing this lvalue. (For vector elements,
201 // this is the alignment of the whole vector.)
202 unsigned Alignment;
203
204 // objective-c's ivar
205 bool Ivar:1;
206
207 // objective-c's ivar is an array
208 bool ObjIsArray:1;
209
210 // LValue is non-gc'able for any reason, including being a parameter or local
211 // variable.
212 bool NonGC: 1;
213
214 // Lvalue is a global reference of an objective-c object
215 bool GlobalObjCRef : 1;
216
217 // Lvalue is a thread local reference
218 bool ThreadLocalRef : 1;
219
220 // Lvalue has ARC imprecise lifetime. We store this inverted to try
221 // to make the default bitfield pattern all-zeroes.
222 bool ImpreciseLifetime : 1;
223
224 // This flag shows if a nontemporal load/stores should be used when accessing
225 // this lvalue.
226 bool Nontemporal : 1;
227
228 // The pointer is known not to be null.
229 bool IsKnownNonNull : 1;
230
231 LValueBaseInfo BaseInfo;
232 TBAAAccessInfo TBAAInfo;
233
234 Expr *BaseIvarExp;
235
236private:
237 void Initialize(QualType Type, Qualifiers Quals, CharUnits Alignment,
238 LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo) {
239 assert((!Alignment.isZero() || Type->isIncompleteType()) &&
240 "initializing l-value with zero alignment!");
241 if (isGlobalReg())
242 assert(ElementType == nullptr && "Global reg does not store elem type");
243 else
244 assert(ElementType != nullptr && "Must have elem type");
245
246 this->Type = Type;
247 this->Quals = Quals;
248 const unsigned MaxAlign = 1U << 31;
249 this->Alignment = Alignment.getQuantity() <= MaxAlign
250 ? Alignment.getQuantity()
251 : MaxAlign;
252 assert(this->Alignment == Alignment.getQuantity() &&
253 "Alignment exceeds allowed max!");
254 this->BaseInfo = BaseInfo;
255 this->TBAAInfo = TBAAInfo;
256
257 // Initialize Objective-C flags.
258 this->Ivar = this->ObjIsArray = this->NonGC = this->GlobalObjCRef = false;
259 this->ImpreciseLifetime = false;
260 this->Nontemporal = false;
261 this->ThreadLocalRef = false;
262 this->BaseIvarExp = nullptr;
263 }
264
265public:
266 bool isSimple() const { return LVType == Simple; }
267 bool isVectorElt() const { return LVType == VectorElt; }
268 bool isBitField() const { return LVType == BitField; }
269 bool isExtVectorElt() const { return LVType == ExtVectorElt; }
270 bool isGlobalReg() const { return LVType == GlobalReg; }
271 bool isMatrixElt() const { return LVType == MatrixElt; }
272
273 bool isVolatileQualified() const { return Quals.hasVolatile(); }
274 bool isRestrictQualified() const { return Quals.hasRestrict(); }
275 unsigned getVRQualifiers() const {
276 return Quals.getCVRQualifiers() & ~Qualifiers::Const;
277 }
278
279 QualType getType() const { return Type; }
280
282 return Quals.getObjCLifetime();
283 }
284
285 bool isObjCIvar() const { return Ivar; }
286 void setObjCIvar(bool Value) { Ivar = Value; }
287
288 bool isObjCArray() const { return ObjIsArray; }
289 void setObjCArray(bool Value) { ObjIsArray = Value; }
290
291 bool isNonGC () const { return NonGC; }
292 void setNonGC(bool Value) { NonGC = Value; }
293
294 bool isGlobalObjCRef() const { return GlobalObjCRef; }
295 void setGlobalObjCRef(bool Value) { GlobalObjCRef = Value; }
296
297 bool isThreadLocalRef() const { return ThreadLocalRef; }
298 void setThreadLocalRef(bool Value) { ThreadLocalRef = Value;}
299
301 return ARCPreciseLifetime_t(!ImpreciseLifetime);
302 }
304 ImpreciseLifetime = (value == ARCImpreciseLifetime);
305 }
306 bool isNontemporal() const { return Nontemporal; }
307 void setNontemporal(bool Value) { Nontemporal = Value; }
308
309 bool isObjCWeak() const {
310 return Quals.getObjCGCAttr() == Qualifiers::Weak;
311 }
312 bool isObjCStrong() const {
313 return Quals.getObjCGCAttr() == Qualifiers::Strong;
314 }
315
316 bool isVolatile() const {
317 return Quals.hasVolatile();
318 }
319
320 Expr *getBaseIvarExp() const { return BaseIvarExp; }
321 void setBaseIvarExp(Expr *V) { BaseIvarExp = V; }
322
323 TBAAAccessInfo getTBAAInfo() const { return TBAAInfo; }
324 void setTBAAInfo(TBAAAccessInfo Info) { TBAAInfo = Info; }
325
326 const Qualifiers &getQuals() const { return Quals; }
327 Qualifiers &getQuals() { return Quals; }
328
329 LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
330
331 CharUnits getAlignment() const { return CharUnits::fromQuantity(Alignment); }
332 void setAlignment(CharUnits A) { Alignment = A.getQuantity(); }
333
334 LValueBaseInfo getBaseInfo() const { return BaseInfo; }
335 void setBaseInfo(LValueBaseInfo Info) { BaseInfo = Info; }
336
338 return (KnownNonNull_t)IsKnownNonNull;
339 }
341 IsKnownNonNull = true;
342 return *this;
343 }
344
345 // simple lvalue
346 llvm::Value *getPointer(CodeGenFunction &CGF) const {
347 assert(isSimple());
348 return V;
349 }
351 return Address(getPointer(CGF), ElementType, getAlignment(),
353 }
354 void setAddress(Address address) {
355 assert(isSimple());
356 V = address.getPointer();
357 ElementType = address.getElementType();
358 Alignment = address.getAlignment().getQuantity();
359 IsKnownNonNull = address.isKnownNonNull();
360 }
361
362 // vector elt lvalue
364 return Address(getVectorPointer(), ElementType, getAlignment(),
366 }
367 llvm::Value *getVectorPointer() const {
368 assert(isVectorElt());
369 return V;
370 }
371 llvm::Value *getVectorIdx() const {
372 assert(isVectorElt());
373 return VectorIdx;
374 }
375
377 return Address(getMatrixPointer(), ElementType, getAlignment(),
379 }
380 llvm::Value *getMatrixPointer() const {
381 assert(isMatrixElt());
382 return V;
383 }
384 llvm::Value *getMatrixIdx() const {
385 assert(isMatrixElt());
386 return VectorIdx;
387 }
388
389 // extended vector elements.
391 return Address(getExtVectorPointer(), ElementType, getAlignment(),
393 }
394 llvm::Value *getExtVectorPointer() const {
395 assert(isExtVectorElt());
396 return V;
397 }
398 llvm::Constant *getExtVectorElts() const {
399 assert(isExtVectorElt());
400 return VectorElts;
401 }
402
403 // bitfield lvalue
405 return Address(getBitFieldPointer(), ElementType, getAlignment(),
407 }
408 llvm::Value *getBitFieldPointer() const { assert(isBitField()); return V; }
410 assert(isBitField());
411 return *BitFieldInfo;
412 }
413
414 // global register lvalue
415 llvm::Value *getGlobalReg() const { assert(isGlobalReg()); return V; }
416
417 static LValue MakeAddr(Address address, QualType type, ASTContext &Context,
418 LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo) {
419 Qualifiers qs = type.getQualifiers();
420 qs.setObjCGCAttr(Context.getObjCGCAttrKind(type));
421
422 LValue R;
423 R.LVType = Simple;
424 assert(address.getPointer()->getType()->isPointerTy());
425 R.V = address.getPointer();
426 R.ElementType = address.getElementType();
427 R.IsKnownNonNull = address.isKnownNonNull();
428 R.Initialize(type, qs, address.getAlignment(), BaseInfo, TBAAInfo);
429 return R;
430 }
431
432 static LValue MakeVectorElt(Address vecAddress, llvm::Value *Idx,
433 QualType type, LValueBaseInfo BaseInfo,
434 TBAAAccessInfo TBAAInfo) {
435 LValue R;
436 R.LVType = VectorElt;
437 R.V = vecAddress.getPointer();
438 R.ElementType = vecAddress.getElementType();
439 R.VectorIdx = Idx;
440 R.IsKnownNonNull = vecAddress.isKnownNonNull();
441 R.Initialize(type, type.getQualifiers(), vecAddress.getAlignment(),
442 BaseInfo, TBAAInfo);
443 return R;
444 }
445
446 static LValue MakeExtVectorElt(Address vecAddress, llvm::Constant *Elts,
447 QualType type, LValueBaseInfo BaseInfo,
448 TBAAAccessInfo TBAAInfo) {
449 LValue R;
450 R.LVType = ExtVectorElt;
451 R.V = vecAddress.getPointer();
452 R.ElementType = vecAddress.getElementType();
453 R.VectorElts = Elts;
454 R.IsKnownNonNull = vecAddress.isKnownNonNull();
455 R.Initialize(type, type.getQualifiers(), vecAddress.getAlignment(),
456 BaseInfo, TBAAInfo);
457 return R;
458 }
459
460 /// Create a new object to represent a bit-field access.
461 ///
462 /// \param Addr - The base address of the bit-field sequence this
463 /// bit-field refers to.
464 /// \param Info - The information describing how to perform the bit-field
465 /// access.
466 static LValue MakeBitfield(Address Addr, const CGBitFieldInfo &Info,
467 QualType type, LValueBaseInfo BaseInfo,
468 TBAAAccessInfo TBAAInfo) {
469 LValue R;
470 R.LVType = BitField;
471 R.V = Addr.getPointer();
472 R.ElementType = Addr.getElementType();
473 R.BitFieldInfo = &Info;
474 R.IsKnownNonNull = Addr.isKnownNonNull();
475 R.Initialize(type, type.getQualifiers(), Addr.getAlignment(), BaseInfo,
476 TBAAInfo);
477 return R;
478 }
479
480 static LValue MakeGlobalReg(llvm::Value *V, CharUnits alignment,
481 QualType type) {
482 LValue R;
483 R.LVType = GlobalReg;
484 R.V = V;
485 R.ElementType = nullptr;
486 R.IsKnownNonNull = true;
487 R.Initialize(type, type.getQualifiers(), alignment,
489 return R;
490 }
491
492 static LValue MakeMatrixElt(Address matAddress, llvm::Value *Idx,
493 QualType type, LValueBaseInfo BaseInfo,
494 TBAAAccessInfo TBAAInfo) {
495 LValue R;
496 R.LVType = MatrixElt;
497 R.V = matAddress.getPointer();
498 R.ElementType = matAddress.getElementType();
499 R.VectorIdx = Idx;
500 R.IsKnownNonNull = matAddress.isKnownNonNull();
501 R.Initialize(type, type.getQualifiers(), matAddress.getAlignment(),
502 BaseInfo, TBAAInfo);
503 return R;
504 }
505
508 }
509};
510
511/// An aggregate value slot.
513 /// The address.
514 Address Addr;
515
516 // Qualifiers
517 Qualifiers Quals;
518
519 /// DestructedFlag - This is set to true if some external code is
520 /// responsible for setting up a destructor for the slot. Otherwise
521 /// the code which constructs it should push the appropriate cleanup.
522 bool DestructedFlag : 1;
523
524 /// ObjCGCFlag - This is set to true if writing to the memory in the
525 /// slot might require calling an appropriate Objective-C GC
526 /// barrier. The exact interaction here is unnecessarily mysterious.
527 bool ObjCGCFlag : 1;
528
529 /// ZeroedFlag - This is set to true if the memory in the slot is
530 /// known to be zero before the assignment into it. This means that
531 /// zero fields don't need to be set.
532 bool ZeroedFlag : 1;
533
534 /// AliasedFlag - This is set to true if the slot might be aliased
535 /// and it's not undefined behavior to access it through such an
536 /// alias. Note that it's always undefined behavior to access a C++
537 /// object that's under construction through an alias derived from
538 /// outside the construction process.
539 ///
540 /// This flag controls whether calls that produce the aggregate
541 /// value may be evaluated directly into the slot, or whether they
542 /// must be evaluated into an unaliased temporary and then memcpy'ed
543 /// over. Since it's invalid in general to memcpy a non-POD C++
544 /// object, it's important that this flag never be set when
545 /// evaluating an expression which constructs such an object.
546 bool AliasedFlag : 1;
547
548 /// This is set to true if the tail padding of this slot might overlap
549 /// another object that may have already been initialized (and whose
550 /// value must be preserved by this initialization). If so, we may only
551 /// store up to the dsize of the type. Otherwise we can widen stores to
552 /// the size of the type.
553 bool OverlapFlag : 1;
554
555 /// If is set to true, sanitizer checks are already generated for this address
556 /// or not required. For instance, if this address represents an object
557 /// created in 'new' expression, sanitizer checks for memory is made as a part
558 /// of 'operator new' emission and object constructor should not generate
559 /// them.
560 bool SanitizerCheckedFlag : 1;
561
562 AggValueSlot(Address Addr, Qualifiers Quals, bool DestructedFlag,
563 bool ObjCGCFlag, bool ZeroedFlag, bool AliasedFlag,
564 bool OverlapFlag, bool SanitizerCheckedFlag)
565 : Addr(Addr), Quals(Quals), DestructedFlag(DestructedFlag),
566 ObjCGCFlag(ObjCGCFlag), ZeroedFlag(ZeroedFlag),
567 AliasedFlag(AliasedFlag), OverlapFlag(OverlapFlag),
568 SanitizerCheckedFlag(SanitizerCheckedFlag) {}
569
570public:
577
578 /// ignored - Returns an aggregate value slot indicating that the
579 /// aggregate value is being ignored.
583 }
584
585 /// forAddr - Make a slot for an aggregate value.
586 ///
587 /// \param quals - The qualifiers that dictate how the slot should
588 /// be initialied. Only 'volatile' and the Objective-C lifetime
589 /// qualifiers matter.
590 ///
591 /// \param isDestructed - true if something else is responsible
592 /// for calling destructors on this object
593 /// \param needsGC - true if the slot is potentially located
594 /// somewhere that ObjC GC calls should be emitted for
596 Qualifiers quals,
597 IsDestructed_t isDestructed,
598 NeedsGCBarriers_t needsGC,
599 IsAliased_t isAliased,
603 if (addr.isValid())
604 addr.setKnownNonNull();
605 return AggValueSlot(addr, quals, isDestructed, needsGC, isZeroed, isAliased,
606 mayOverlap, isChecked);
607 }
608
609 static AggValueSlot
610 forLValue(const LValue &LV, CodeGenFunction &CGF, IsDestructed_t isDestructed,
611 NeedsGCBarriers_t needsGC, IsAliased_t isAliased,
614 return forAddr(LV.getAddress(CGF), LV.getQuals(), isDestructed, needsGC,
615 isAliased, mayOverlap, isZeroed, isChecked);
616 }
617
619 return IsDestructed_t(DestructedFlag);
620 }
621 void setExternallyDestructed(bool destructed = true) {
622 DestructedFlag = destructed;
623 }
624
625 Qualifiers getQualifiers() const { return Quals; }
626
627 bool isVolatile() const {
628 return Quals.hasVolatile();
629 }
630
631 void setVolatile(bool flag) {
632 if (flag)
633 Quals.addVolatile();
634 else
635 Quals.removeVolatile();
636 }
637
639 return Quals.getObjCLifetime();
640 }
641
643 return NeedsGCBarriers_t(ObjCGCFlag);
644 }
645
646 llvm::Value *getPointer() const {
647 return Addr.getPointer();
648 }
649
651 return Addr;
652 }
653
654 bool isIgnored() const {
655 return !Addr.isValid();
656 }
657
659 return Addr.getAlignment();
660 }
661
663 return IsAliased_t(AliasedFlag);
664 }
665
667 return Overlap_t(OverlapFlag);
668 }
669
670 bool isSanitizerChecked() const {
671 return SanitizerCheckedFlag;
672 }
673
674 RValue asRValue() const {
675 if (isIgnored()) {
676 return RValue::getIgnored();
677 } else {
679 }
680 }
681
682 void setZeroed(bool V = true) { ZeroedFlag = V; }
684 return IsZeroed_t(ZeroedFlag);
685 }
686
687 /// Get the preferred size to use when storing a value to this slot. This
688 /// is the type size unless that might overlap another object, in which
689 /// case it's the dsize.
693 }
694};
695
696} // end namespace CodeGen
697} // end namespace clang
698
699#endif
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3255
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
TypeInfoChars getTypeInfoDataSizeInChars(QualType T) const
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:122
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:185
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
An aligned address.
Definition: Address.h:29
static Address invalid()
Definition: Address.h:46
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:78
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:62
KnownNonNull_t isKnownNonNull() const
Whether the pointer is known not to be null.
Definition: Address.h:105
Address setKnownNonNull()
Set the non-null bit.
Definition: Address.h:111
llvm::Value * getPointer() const
Definition: Address.h:51
bool isValid() const
Definition: Address.h:47
An aggregate value slot.
Definition: CGValue.h:512
void setVolatile(bool flag)
Definition: CGValue.h:631
static AggValueSlot ignored()
ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored.
Definition: CGValue.h:580
bool isSanitizerChecked() const
Definition: CGValue.h:670
Address getAddress() const
Definition: CGValue.h:650
CharUnits getPreferredSize(ASTContext &Ctx, QualType Type) const
Get the preferred size to use when storing a value to this slot.
Definition: CGValue.h:690
CharUnits getAlignment() const
Definition: CGValue.h:658
static AggValueSlot forLValue(const LValue &LV, CodeGenFunction &CGF, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
Definition: CGValue.h:610
NeedsGCBarriers_t requiresGCollection() const
Definition: CGValue.h:642
void setExternallyDestructed(bool destructed=true)
Definition: CGValue.h:621
void setZeroed(bool V=true)
Definition: CGValue.h:682
llvm::Value * getPointer() const
Definition: CGValue.h:646
IsZeroed_t isZeroed() const
Definition: CGValue.h:683
Qualifiers getQualifiers() const
Definition: CGValue.h:625
IsAliased_t isPotentiallyAliased() const
Definition: CGValue.h:662
Qualifiers::ObjCLifetime getObjCLifetime() const
Definition: CGValue.h:638
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
Definition: CGValue.h:595
IsDestructed_t isExternallyDestructed() const
Definition: CGValue.h:618
Overlap_t mayOverlap() const
Definition: CGValue.h:666
RValue asRValue() const
Definition: CGValue.h:674
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void setAlignmentSource(AlignmentSource Source)
Definition: CGValue.h:161
void mergeForCast(const LValueBaseInfo &Info)
Definition: CGValue.h:163
AlignmentSource getAlignmentSource() const
Definition: CGValue.h:160
LValueBaseInfo(AlignmentSource Source=AlignmentSource::Type)
Definition: CGValue.h:158
LValue - This represents an lvalue references.
Definition: CGValue.h:171
bool isBitField() const
Definition: CGValue.h:268
bool isMatrixElt() const
Definition: CGValue.h:271
Expr * getBaseIvarExp() const
Definition: CGValue.h:320
llvm::Constant * getExtVectorElts() const
Definition: CGValue.h:398
static LValue MakeGlobalReg(llvm::Value *V, CharUnits alignment, QualType type)
Definition: CGValue.h:480
void setObjCIvar(bool Value)
Definition: CGValue.h:286
bool isObjCArray() const
Definition: CGValue.h:288
static LValue MakeExtVectorElt(Address vecAddress, llvm::Constant *Elts, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Definition: CGValue.h:446
bool isObjCStrong() const
Definition: CGValue.h:312
bool isRestrictQualified() const
Definition: CGValue.h:274
void setAlignment(CharUnits A)
Definition: CGValue.h:332
llvm::Value * getBitFieldPointer() const
Definition: CGValue.h:408
bool isGlobalObjCRef() const
Definition: CGValue.h:294
bool isVectorElt() const
Definition: CGValue.h:267
void setObjCArray(bool Value)
Definition: CGValue.h:289
bool isSimple() const
Definition: CGValue.h:266
llvm::Value * getMatrixPointer() const
Definition: CGValue.h:380
bool isVolatileQualified() const
Definition: CGValue.h:273
llvm::Constant * VectorElts
Definition: CGValue.h:189
static LValue MakeAddr(Address address, QualType type, ASTContext &Context, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Definition: CGValue.h:417
void setTBAAInfo(TBAAAccessInfo Info)
Definition: CGValue.h:324
LangAS getAddressSpace() const
Definition: CGValue.h:329
CharUnits getAlignment() const
Definition: CGValue.h:331
llvm::Value * getMatrixIdx() const
Definition: CGValue.h:384
Address getAddress(CodeGenFunction &CGF) const
Definition: CGValue.h:350
llvm::Value * getGlobalReg() const
Definition: CGValue.h:415
bool isVolatile() const
Definition: CGValue.h:316
const Qualifiers & getQuals() const
Definition: CGValue.h:326
bool isGlobalReg() const
Definition: CGValue.h:270
llvm::Value * getVectorPointer() const
Definition: CGValue.h:367
bool isObjCWeak() const
Definition: CGValue.h:309
unsigned getVRQualifiers() const
Definition: CGValue.h:275
Qualifiers & getQuals()
Definition: CGValue.h:327
void setThreadLocalRef(bool Value)
Definition: CGValue.h:298
const CGBitFieldInfo * BitFieldInfo
Definition: CGValue.h:192
LValue setKnownNonNull()
Definition: CGValue.h:340
bool isNonGC() const
Definition: CGValue.h:291
void setGlobalObjCRef(bool Value)
Definition: CGValue.h:295
bool isExtVectorElt() const
Definition: CGValue.h:269
llvm::Value * getVectorIdx() const
Definition: CGValue.h:371
void setNontemporal(bool Value)
Definition: CGValue.h:307
LValueBaseInfo getBaseInfo() const
Definition: CGValue.h:334
llvm::Value * getPointer(CodeGenFunction &CGF) const
Definition: CGValue.h:346
ARCPreciseLifetime_t isARCPreciseLifetime() const
Definition: CGValue.h:300
void setARCPreciseLifetime(ARCPreciseLifetime_t value)
Definition: CGValue.h:303
QualType getType() const
Definition: CGValue.h:279
llvm::Value * getExtVectorPointer() const
Definition: CGValue.h:394
const CGBitFieldInfo & getBitFieldInfo() const
Definition: CGValue.h:409
bool isThreadLocalRef() const
Definition: CGValue.h:297
KnownNonNull_t isKnownNonNull() const
Definition: CGValue.h:337
TBAAAccessInfo getTBAAInfo() const
Definition: CGValue.h:323
void setNonGC(bool Value)
Definition: CGValue.h:292
void setBaseInfo(LValueBaseInfo Info)
Definition: CGValue.h:335
Address getVectorAddress() const
Definition: CGValue.h:363
bool isNontemporal() const
Definition: CGValue.h:306
static LValue MakeBitfield(Address Addr, const CGBitFieldInfo &Info, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Create a new object to represent a bit-field access.
Definition: CGValue.h:466
bool isObjCIvar() const
Definition: CGValue.h:285
static LValue MakeVectorElt(Address vecAddress, llvm::Value *Idx, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Definition: CGValue.h:432
void setAddress(Address address)
Definition: CGValue.h:354
Qualifiers::ObjCLifetime getObjCLifetime() const
Definition: CGValue.h:281
void setBaseIvarExp(Expr *V)
Definition: CGValue.h:321
RValue asAggregateRValue(CodeGenFunction &CGF) const
Definition: CGValue.h:506
Address getExtVectorAddress() const
Definition: CGValue.h:390
llvm::Value * VectorIdx
Definition: CGValue.h:186
static LValue MakeMatrixElt(Address matAddress, llvm::Value *Idx, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Definition: CGValue.h:492
Address getMatrixAddress() const
Definition: CGValue.h:376
Address getBitFieldAddress() const
Definition: CGValue.h:404
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
Definition: CGValue.h:39
bool isScalar() const
Definition: CGValue.h:54
static RValue getIgnored()
Definition: CGValue.h:84
static RValue get(llvm::Value *V)
Definition: CGValue.h:89
llvm::Value * getAggregatePointer() const
Definition: CGValue.h:79
static RValue getComplex(const std::pair< llvm::Value *, llvm::Value * > &C)
Definition: CGValue.h:104
static RValue getAggregate(Address addr, bool isVolatile=false)
Definition: CGValue.h:110
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
Definition: CGValue.h:96
bool isAggregate() const
Definition: CGValue.h:56
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:73
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:61
bool isComplex() const
Definition: CGValue.h:55
bool isVolatileQualified() const
Definition: CGValue.h:58
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
Definition: CGValue.h:68
This represents one expression.
Definition: Expr.h:110
A (possibly-)qualified type.
Definition: Type.h:737
The collection of all-type qualifiers we support.
Definition: Type.h:147
unsigned getCVRQualifiers() const
Definition: Type.h:295
GC getObjCGCAttr() const
Definition: Type.h:326
bool hasRestrict() const
Definition: Type.h:284
bool hasVolatile() const
Definition: Type.h:274
void setObjCGCAttr(GC type)
Definition: Type.h:327
ObjCLifetime getObjCLifetime() const
Definition: Type.h:352
void removeVolatile()
Definition: Type.h:276
LangAS getAddressSpace() const
Definition: Type.h:378
void addVolatile()
Definition: Type.h:277
The base class of the type hierarchy.
Definition: Type.h:1606
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Definition: Type.cpp:2299
AlignmentSource
The source of the alignment of an l-value; an expression of confidence in the alignment actually matc...
Definition: CGValue.h:130
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
ARCPreciseLifetime_t
Does an ARC strong l-value have precise lifetime?
Definition: CGValue.h:124
@ ARCPreciseLifetime
Definition: CGValue.h:125
@ ARCImpreciseLifetime
Definition: CGValue.h:125
static AlignmentSource getFieldAlignmentSource(AlignmentSource Source)
Given that the base address has the given alignment source, what's our confidence in the alignment of...
Definition: CGValue.h:148
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
The JSON file list parser is used to communicate input to InstallAPI.
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
YAML serialization mapping.
Definition: Dominators.h:30
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Structure with information about how a bitfield should be accessed.