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
17#include "clang/AST/ASTContext.h"
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.
73 Address getAggregateAddress() const {
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?
124enum ARCPreciseLifetime_t {
125 ARCImpreciseLifetime, ARCPreciseLifetime
126};
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.
139 AttributedType,
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?
148static inline AlignmentSource getFieldAlignmentSource(AlignmentSource Source) {
149 // For now, we don't distinguish fields of opaque pointers from
150 // top-level declarations, but maybe we should.
151 return AlignmentSource::Decl;
152}
153
154class LValueBaseInfo {
155 AlignmentSource AlignSource;
156
157public:
158 explicit LValueBaseInfo(AlignmentSource Source = AlignmentSource::Type)
159 : AlignSource(Source) {}
160 AlignmentSource getAlignmentSource() const { return AlignSource; }
161 void setAlignmentSource(AlignmentSource Source) { AlignSource = Source; }
162
163 void mergeForCast(const LValueBaseInfo &Info) {
164 setAlignmentSource(Info.getAlignmentSource());
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
192 const CGBitFieldInfo *BitFieldInfo;
193 };
194
195 QualType Type;
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 LValueBaseInfo BaseInfo;
229 TBAAAccessInfo TBAAInfo;
230
231 Expr *BaseIvarExp;
232
233private:
234 void Initialize(QualType Type, Qualifiers Quals, CharUnits Alignment,
235 LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo) {
236 assert((!Alignment.isZero() || Type->isIncompleteType()) &&
237 "initializing l-value with zero alignment!");
238 if (isGlobalReg())
239 assert(ElementType == nullptr && "Global reg does not store elem type");
240 else
241 assert(llvm::cast<llvm::PointerType>(V->getType())
242 ->isOpaqueOrPointeeTypeMatches(ElementType) &&
243 "Pointer element type mismatch");
244
245 this->Type = Type;
246 this->Quals = Quals;
247 const unsigned MaxAlign = 1U << 31;
248 this->Alignment = Alignment.getQuantity() <= MaxAlign
249 ? Alignment.getQuantity()
250 : MaxAlign;
251 assert(this->Alignment == Alignment.getQuantity() &&
252 "Alignment exceeds allowed max!");
253 this->BaseInfo = BaseInfo;
254 this->TBAAInfo = TBAAInfo;
255
256 // Initialize Objective-C flags.
257 this->Ivar = this->ObjIsArray = this->NonGC = this->GlobalObjCRef = false;
258 this->ImpreciseLifetime = false;
259 this->Nontemporal = false;
260 this->ThreadLocalRef = false;
261 this->BaseIvarExp = nullptr;
262 }
263
264public:
265 bool isSimple() const { return LVType == Simple; }
266 bool isVectorElt() const { return LVType == VectorElt; }
267 bool isBitField() const { return LVType == BitField; }
268 bool isExtVectorElt() const { return LVType == ExtVectorElt; }
269 bool isGlobalReg() const { return LVType == GlobalReg; }
270 bool isMatrixElt() const { return LVType == MatrixElt; }
271
272 bool isVolatileQualified() const { return Quals.hasVolatile(); }
273 bool isRestrictQualified() const { return Quals.hasRestrict(); }
274 unsigned getVRQualifiers() const {
275 return Quals.getCVRQualifiers() & ~Qualifiers::Const;
276 }
277
278 QualType getType() const { return Type; }
279
280 Qualifiers::ObjCLifetime getObjCLifetime() const {
281 return Quals.getObjCLifetime();
282 }
283
284 bool isObjCIvar() const { return Ivar; }
285 void setObjCIvar(bool Value) { Ivar = Value; }
286
287 bool isObjCArray() const { return ObjIsArray; }
288 void setObjCArray(bool Value) { ObjIsArray = Value; }
289
290 bool isNonGC () const { return NonGC; }
291 void setNonGC(bool Value) { NonGC = Value; }
292
293 bool isGlobalObjCRef() const { return GlobalObjCRef; }
294 void setGlobalObjCRef(bool Value) { GlobalObjCRef = Value; }
295
296 bool isThreadLocalRef() const { return ThreadLocalRef; }
297 void setThreadLocalRef(bool Value) { ThreadLocalRef = Value;}
298
299 ARCPreciseLifetime_t isARCPreciseLifetime() const {
300 return ARCPreciseLifetime_t(!ImpreciseLifetime);
301 }
302 void setARCPreciseLifetime(ARCPreciseLifetime_t value) {
303 ImpreciseLifetime = (value == ARCImpreciseLifetime);
304 }
305 bool isNontemporal() const { return Nontemporal; }
306 void setNontemporal(bool Value) { Nontemporal = Value; }
307
308 bool isObjCWeak() const {
309 return Quals.getObjCGCAttr() == Qualifiers::Weak;
310 }
311 bool isObjCStrong() const {
312 return Quals.getObjCGCAttr() == Qualifiers::Strong;
313 }
314
315 bool isVolatile() const {
316 return Quals.hasVolatile();
317 }
318
319 Expr *getBaseIvarExp() const { return BaseIvarExp; }
320 void setBaseIvarExp(Expr *V) { BaseIvarExp = V; }
321
322 TBAAAccessInfo getTBAAInfo() const { return TBAAInfo; }
323 void setTBAAInfo(TBAAAccessInfo Info) { TBAAInfo = Info; }
324
325 const Qualifiers &getQuals() const { return Quals; }
326 Qualifiers &getQuals() { return Quals; }
327
328 LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
329
330 CharUnits getAlignment() const { return CharUnits::fromQuantity(Alignment); }
331 void setAlignment(CharUnits A) { Alignment = A.getQuantity(); }
332
333 LValueBaseInfo getBaseInfo() const { return BaseInfo; }
334 void setBaseInfo(LValueBaseInfo Info) { BaseInfo = Info; }
335
336 // simple lvalue
337 llvm::Value *getPointer(CodeGenFunction &CGF) const {
338 assert(isSimple());
339 return V;
340 }
341 Address getAddress(CodeGenFunction &CGF) const {
342 return Address(getPointer(CGF), ElementType, getAlignment());
343 }
344 void setAddress(Address address) {
345 assert(isSimple());
346 V = address.getPointer();
347 ElementType = address.getElementType();
348 Alignment = address.getAlignment().getQuantity();
349 }
350
351 // vector elt lvalue
352 Address getVectorAddress() const {
353 return Address(getVectorPointer(), ElementType, getAlignment());
354 }
355 llvm::Value *getVectorPointer() const {
356 assert(isVectorElt());
357 return V;
358 }
359 llvm::Value *getVectorIdx() const {
360 assert(isVectorElt());
361 return VectorIdx;
362 }
363
364 Address getMatrixAddress() const {
365 return Address(getMatrixPointer(), ElementType, getAlignment());
366 }
367 llvm::Value *getMatrixPointer() const {
368 assert(isMatrixElt());
369 return V;
370 }
371 llvm::Value *getMatrixIdx() const {
372 assert(isMatrixElt());
373 return VectorIdx;
374 }
375
376 // extended vector elements.
377 Address getExtVectorAddress() const {
378 return Address(getExtVectorPointer(), ElementType, getAlignment());
379 }
380 llvm::Value *getExtVectorPointer() const {
381 assert(isExtVectorElt());
382 return V;
383 }
384 llvm::Constant *getExtVectorElts() const {
385 assert(isExtVectorElt());
386 return VectorElts;
387 }
388
389 // bitfield lvalue
390 Address getBitFieldAddress() const {
391 return Address(getBitFieldPointer(), ElementType, getAlignment());
392 }
393 llvm::Value *getBitFieldPointer() const { assert(isBitField()); return V; }
394 const CGBitFieldInfo &getBitFieldInfo() const {
395 assert(isBitField());
396 return *BitFieldInfo;
397 }
398
399 // global register lvalue
400 llvm::Value *getGlobalReg() const { assert(isGlobalReg()); return V; }
401
402 static LValue MakeAddr(Address address, QualType type, ASTContext &Context,
403 LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo) {
404 Qualifiers qs = type.getQualifiers();
405 qs.setObjCGCAttr(Context.getObjCGCAttrKind(type));
406
407 LValue R;
408 R.LVType = Simple;
409 assert(address.getPointer()->getType()->isPointerTy());
410 R.V = address.getPointer();
411 R.ElementType = address.getElementType();
412 R.Initialize(type, qs, address.getAlignment(), BaseInfo, TBAAInfo);
413 return R;
414 }
415
416 static LValue MakeVectorElt(Address vecAddress, llvm::Value *Idx,
417 QualType type, LValueBaseInfo BaseInfo,
418 TBAAAccessInfo TBAAInfo) {
419 LValue R;
420 R.LVType = VectorElt;
421 R.V = vecAddress.getPointer();
422 R.ElementType = vecAddress.getElementType();
423 R.VectorIdx = Idx;
424 R.Initialize(type, type.getQualifiers(), vecAddress.getAlignment(),
425 BaseInfo, TBAAInfo);
426 return R;
427 }
428
429 static LValue MakeExtVectorElt(Address vecAddress, llvm::Constant *Elts,
430 QualType type, LValueBaseInfo BaseInfo,
431 TBAAAccessInfo TBAAInfo) {
432 LValue R;
433 R.LVType = ExtVectorElt;
434 R.V = vecAddress.getPointer();
435 R.ElementType = vecAddress.getElementType();
436 R.VectorElts = Elts;
437 R.Initialize(type, type.getQualifiers(), vecAddress.getAlignment(),
438 BaseInfo, TBAAInfo);
439 return R;
440 }
441
442 /// Create a new object to represent a bit-field access.
443 ///
444 /// \param Addr - The base address of the bit-field sequence this
445 /// bit-field refers to.
446 /// \param Info - The information describing how to perform the bit-field
447 /// access.
448 static LValue MakeBitfield(Address Addr, const CGBitFieldInfo &Info,
449 QualType type, LValueBaseInfo BaseInfo,
450 TBAAAccessInfo TBAAInfo) {
451 LValue R;
452 R.LVType = BitField;
453 R.V = Addr.getPointer();
454 R.ElementType = Addr.getElementType();
455 R.BitFieldInfo = &Info;
456 R.Initialize(type, type.getQualifiers(), Addr.getAlignment(), BaseInfo,
457 TBAAInfo);
458 return R;
459 }
460
461 static LValue MakeGlobalReg(llvm::Value *V, CharUnits alignment,
462 QualType type) {
463 LValue R;
464 R.LVType = GlobalReg;
465 R.V = V;
466 R.ElementType = nullptr;
467 R.Initialize(type, type.getQualifiers(), alignment,
468 LValueBaseInfo(AlignmentSource::Decl), TBAAAccessInfo());
469 return R;
470 }
471
472 static LValue MakeMatrixElt(Address matAddress, llvm::Value *Idx,
473 QualType type, LValueBaseInfo BaseInfo,
474 TBAAAccessInfo TBAAInfo) {
475 LValue R;
476 R.LVType = MatrixElt;
477 R.V = matAddress.getPointer();
478 R.ElementType = matAddress.getElementType();
479 R.VectorIdx = Idx;
480 R.Initialize(type, type.getQualifiers(), matAddress.getAlignment(),
481 BaseInfo, TBAAInfo);
482 return R;
483 }
484
485 RValue asAggregateRValue(CodeGenFunction &CGF) const {
486 return RValue::getAggregate(getAddress(CGF), isVolatileQualified());
487 }
488};
489
490/// An aggregate value slot.
491class AggValueSlot {
492 /// The address.
493 Address Addr;
494
495 // Qualifiers
496 Qualifiers Quals;
497
498 /// DestructedFlag - This is set to true if some external code is
499 /// responsible for setting up a destructor for the slot. Otherwise
500 /// the code which constructs it should push the appropriate cleanup.
501 bool DestructedFlag : 1;
502
503 /// ObjCGCFlag - This is set to true if writing to the memory in the
504 /// slot might require calling an appropriate Objective-C GC
505 /// barrier. The exact interaction here is unnecessarily mysterious.
506 bool ObjCGCFlag : 1;
507
508 /// ZeroedFlag - This is set to true if the memory in the slot is
509 /// known to be zero before the assignment into it. This means that
510 /// zero fields don't need to be set.
511 bool ZeroedFlag : 1;
512
513 /// AliasedFlag - This is set to true if the slot might be aliased
514 /// and it's not undefined behavior to access it through such an
515 /// alias. Note that it's always undefined behavior to access a C++
516 /// object that's under construction through an alias derived from
517 /// outside the construction process.
518 ///
519 /// This flag controls whether calls that produce the aggregate
520 /// value may be evaluated directly into the slot, or whether they
521 /// must be evaluated into an unaliased temporary and then memcpy'ed
522 /// over. Since it's invalid in general to memcpy a non-POD C++
523 /// object, it's important that this flag never be set when
524 /// evaluating an expression which constructs such an object.
525 bool AliasedFlag : 1;
526
527 /// This is set to true if the tail padding of this slot might overlap
528 /// another object that may have already been initialized (and whose
529 /// value must be preserved by this initialization). If so, we may only
530 /// store up to the dsize of the type. Otherwise we can widen stores to
531 /// the size of the type.
532 bool OverlapFlag : 1;
533
534 /// If is set to true, sanitizer checks are already generated for this address
535 /// or not required. For instance, if this address represents an object
536 /// created in 'new' expression, sanitizer checks for memory is made as a part
537 /// of 'operator new' emission and object constructor should not generate
538 /// them.
539 bool SanitizerCheckedFlag : 1;
540
541 AggValueSlot(Address Addr, Qualifiers Quals, bool DestructedFlag,
542 bool ObjCGCFlag, bool ZeroedFlag, bool AliasedFlag,
543 bool OverlapFlag, bool SanitizerCheckedFlag)
544 : Addr(Addr), Quals(Quals), DestructedFlag(DestructedFlag),
545 ObjCGCFlag(ObjCGCFlag), ZeroedFlag(ZeroedFlag),
546 AliasedFlag(AliasedFlag), OverlapFlag(OverlapFlag),
547 SanitizerCheckedFlag(SanitizerCheckedFlag) {}
548
549public:
550 enum IsAliased_t { IsNotAliased, IsAliased };
551 enum IsDestructed_t { IsNotDestructed, IsDestructed };
552 enum IsZeroed_t { IsNotZeroed, IsZeroed };
553 enum Overlap_t { DoesNotOverlap, MayOverlap };
554 enum NeedsGCBarriers_t { DoesNotNeedGCBarriers, NeedsGCBarriers };
555 enum IsSanitizerChecked_t { IsNotSanitizerChecked, IsSanitizerChecked };
556
557 /// ignored - Returns an aggregate value slot indicating that the
558 /// aggregate value is being ignored.
559 static AggValueSlot ignored() {
560 return forAddr(Address::invalid(), Qualifiers(), IsNotDestructed,
561 DoesNotNeedGCBarriers, IsNotAliased, DoesNotOverlap);
562 }
563
564 /// forAddr - Make a slot for an aggregate value.
565 ///
566 /// \param quals - The qualifiers that dictate how the slot should
567 /// be initialied. Only 'volatile' and the Objective-C lifetime
568 /// qualifiers matter.
569 ///
570 /// \param isDestructed - true if something else is responsible
571 /// for calling destructors on this object
572 /// \param needsGC - true if the slot is potentially located
573 /// somewhere that ObjC GC calls should be emitted for
574 static AggValueSlot forAddr(Address addr,
575 Qualifiers quals,
576 IsDestructed_t isDestructed,
577 NeedsGCBarriers_t needsGC,
578 IsAliased_t isAliased,
579 Overlap_t mayOverlap,
580 IsZeroed_t isZeroed = IsNotZeroed,
581 IsSanitizerChecked_t isChecked = IsNotSanitizerChecked) {
582 return AggValueSlot(addr, quals, isDestructed, needsGC, isZeroed, isAliased,
583 mayOverlap, isChecked);
584 }
585
586 static AggValueSlot
587 forLValue(const LValue &LV, CodeGenFunction &CGF, IsDestructed_t isDestructed,
588 NeedsGCBarriers_t needsGC, IsAliased_t isAliased,
589 Overlap_t mayOverlap, IsZeroed_t isZeroed = IsNotZeroed,
590 IsSanitizerChecked_t isChecked = IsNotSanitizerChecked) {
591 return forAddr(LV.getAddress(CGF), LV.getQuals(), isDestructed, needsGC,
592 isAliased, mayOverlap, isZeroed, isChecked);
593 }
594
595 IsDestructed_t isExternallyDestructed() const {
596 return IsDestructed_t(DestructedFlag);
597 }
598 void setExternallyDestructed(bool destructed = true) {
599 DestructedFlag = destructed;
600 }
601
602 Qualifiers getQualifiers() const { return Quals; }
603
604 bool isVolatile() const {
605 return Quals.hasVolatile();
606 }
607
608 void setVolatile(bool flag) {
609 if (flag)
610 Quals.addVolatile();
611 else
612 Quals.removeVolatile();
613 }
614
615 Qualifiers::ObjCLifetime getObjCLifetime() const {
616 return Quals.getObjCLifetime();
617 }
618
619 NeedsGCBarriers_t requiresGCollection() const {
620 return NeedsGCBarriers_t(ObjCGCFlag);
621 }
622
623 llvm::Value *getPointer() const {
624 return Addr.getPointer();
625 }
626
627 Address getAddress() const {
628 return Addr;
629 }
630
631 bool isIgnored() const {
632 return !Addr.isValid();
633 }
634
635 CharUnits getAlignment() const {
636 return Addr.getAlignment();
637 }
638
639 IsAliased_t isPotentiallyAliased() const {
640 return IsAliased_t(AliasedFlag);
641 }
642
643 Overlap_t mayOverlap() const {
644 return Overlap_t(OverlapFlag);
645 }
646
647 bool isSanitizerChecked() const {
648 return SanitizerCheckedFlag;
649 }
650
651 RValue asRValue() const {
652 if (isIgnored()) {
653 return RValue::getIgnored();
654 } else {
655 return RValue::getAggregate(getAddress(), isVolatile());
656 }
657 }
658
659 void setZeroed(bool V = true) { ZeroedFlag = V; }
660 IsZeroed_t isZeroed() const {
661 return IsZeroed_t(ZeroedFlag);
662 }
663
664 /// Get the preferred size to use when storing a value to this slot. This
665 /// is the type size unless that might overlap another object, in which
666 /// case it's the dsize.
667 CharUnits getPreferredSize(ASTContext &Ctx, QualType Type) const {
668 return mayOverlap() ? Ctx.getTypeInfoDataSizeInChars(Type).Width
669 : Ctx.getTypeSizeInChars(Type);
670 }
671};
672
673} // end namespace CodeGen
674} // end namespace clang
675
676#endif
677

source code of clang/lib/CodeGen/CGValue.h