clang 17.0.0git
APValue.cpp
Go to the documentation of this file.
1//===--- APValue.cpp - Union class for APFloat/APSInt/Complex -------------===//
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// This file implements the APValue class.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/APValue.h"
14#include "Linkage.h"
16#include "clang/AST/CharUnits.h"
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/ExprCXX.h"
20#include "clang/AST/Type.h"
21#include "llvm/Support/ErrorHandling.h"
22#include "llvm/Support/raw_ostream.h"
23using namespace clang;
24
25/// The identity of a type_info object depends on the canonical unqualified
26/// type only.
28 : T(T->getCanonicalTypeUnqualified().getTypePtr()) {}
29
30void TypeInfoLValue::print(llvm::raw_ostream &Out,
31 const PrintingPolicy &Policy) const {
32 Out << "typeid(";
33 QualType(getType(), 0).print(Out, Policy);
34 Out << ")";
35}
36
37static_assert(
39 alignof(Type),
40 "Type is insufficiently aligned");
41
42APValue::LValueBase::LValueBase(const ValueDecl *P, unsigned I, unsigned V)
43 : Ptr(P ? cast<ValueDecl>(P->getCanonicalDecl()) : nullptr), Local{I, V} {}
44APValue::LValueBase::LValueBase(const Expr *P, unsigned I, unsigned V)
45 : Ptr(P), Local{I, V} {}
46
48 QualType Type) {
50 Base.Ptr = LV;
51 Base.DynamicAllocType = Type.getAsOpaquePtr();
52 return Base;
53}
54
58 Base.Ptr = LV;
59 Base.TypeInfoType = TypeInfo.getAsOpaquePtr();
60 return Base;
61}
62
64 if (!*this) return QualType();
65 if (const ValueDecl *D = dyn_cast<const ValueDecl*>()) {
66 // FIXME: It's unclear where we're supposed to take the type from, and
67 // this actually matters for arrays of unknown bound. Eg:
68 //
69 // extern int arr[]; void f() { extern int arr[3]; };
70 // constexpr int *p = &arr[1]; // valid?
71 //
72 // For now, we take the most complete type we can find.
73 for (auto *Redecl = cast<ValueDecl>(D->getMostRecentDecl()); Redecl;
74 Redecl = cast_or_null<ValueDecl>(Redecl->getPreviousDecl())) {
75 QualType T = Redecl->getType();
76 if (!T->isIncompleteArrayType())
77 return T;
78 }
79 return D->getType();
80 }
81
82 if (is<TypeInfoLValue>())
83 return getTypeInfoType();
84
85 if (is<DynamicAllocLValue>())
86 return getDynamicAllocType();
87
88 const Expr *Base = get<const Expr*>();
89
90 // For a materialized temporary, the type of the temporary we materialized
91 // may not be the type of the expression.
92 if (const MaterializeTemporaryExpr *MTE =
93 clang::dyn_cast<MaterializeTemporaryExpr>(Base)) {
96 const Expr *Temp = MTE->getSubExpr();
97 const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs,
98 Adjustments);
99 // Keep any cv-qualifiers from the reference if we generated a temporary
100 // for it directly. Otherwise use the type after adjustment.
101 if (!Adjustments.empty())
102 return Inner->getType();
103 }
104
105 return Base->getType();
106}
107
109 return (is<TypeInfoLValue>() || is<DynamicAllocLValue>()) ? 0
110 : Local.CallIndex;
111}
112
114 return (is<TypeInfoLValue>() || is<DynamicAllocLValue>()) ? 0 : Local.Version;
115}
116
118 assert(is<TypeInfoLValue>() && "not a type_info lvalue");
119 return QualType::getFromOpaquePtr(TypeInfoType);
120}
121
123 assert(is<DynamicAllocLValue>() && "not a dynamic allocation lvalue");
124 return QualType::getFromOpaquePtr(DynamicAllocType);
125}
126
127void APValue::LValueBase::Profile(llvm::FoldingSetNodeID &ID) const {
128 ID.AddPointer(Ptr.getOpaqueValue());
129 if (is<TypeInfoLValue>() || is<DynamicAllocLValue>())
130 return;
131 ID.AddInteger(Local.CallIndex);
132 ID.AddInteger(Local.Version);
133}
134
135namespace clang {
137 const APValue::LValueBase &RHS) {
138 if (LHS.Ptr != RHS.Ptr)
139 return false;
140 if (LHS.is<TypeInfoLValue>() || LHS.is<DynamicAllocLValue>())
141 return true;
142 return LHS.Local.CallIndex == RHS.Local.CallIndex &&
143 LHS.Local.Version == RHS.Local.Version;
144}
145}
146
148 if (const Decl *D = BaseOrMember.getPointer())
149 BaseOrMember.setPointer(D->getCanonicalDecl());
150 Value = reinterpret_cast<uintptr_t>(BaseOrMember.getOpaqueValue());
151}
152
153void APValue::LValuePathEntry::Profile(llvm::FoldingSetNodeID &ID) const {
154 ID.AddInteger(Value);
155}
156
159 : Ty((const void *)ElemTy.getTypePtrOrNull()), Path(Path) {}
160
163}
164
165namespace {
166 struct LVBase {
169 unsigned PathLength;
170 bool IsNullPtr : 1;
171 bool IsOnePastTheEnd : 1;
172 };
173}
174
176 return Ptr.getOpaqueValue();
177}
178
180 return Ptr.isNull();
181}
182
183APValue::LValueBase::operator bool () const {
184 return static_cast<bool>(Ptr);
185}
186
188llvm::DenseMapInfo<clang::APValue::LValueBase>::getEmptyKey() {
190 B.Ptr = DenseMapInfo<const ValueDecl*>::getEmptyKey();
191 return B;
192}
193
195llvm::DenseMapInfo<clang::APValue::LValueBase>::getTombstoneKey() {
197 B.Ptr = DenseMapInfo<const ValueDecl*>::getTombstoneKey();
198 return B;
199}
200
201namespace clang {
202llvm::hash_code hash_value(const APValue::LValueBase &Base) {
203 if (Base.is<TypeInfoLValue>() || Base.is<DynamicAllocLValue>())
204 return llvm::hash_value(Base.getOpaqueValue());
205 return llvm::hash_combine(Base.getOpaqueValue(), Base.getCallIndex(),
206 Base.getVersion());
207}
208}
209
210unsigned llvm::DenseMapInfo<clang::APValue::LValueBase>::getHashValue(
212 return hash_value(Base);
213}
214
215bool llvm::DenseMapInfo<clang::APValue::LValueBase>::isEqual(
217 const clang::APValue::LValueBase &RHS) {
218 return LHS == RHS;
219}
220
221struct APValue::LV : LVBase {
222 static const unsigned InlinePathSpace =
223 (DataSize - sizeof(LVBase)) / sizeof(LValuePathEntry);
224
225 /// Path - The sequence of base classes, fields and array indices to follow to
226 /// walk from Base to the subobject. When performing GCC-style folding, there
227 /// may not be such a path.
228 union {
229 LValuePathEntry Path[InlinePathSpace];
231 };
232
233 LV() { PathLength = (unsigned)-1; }
234 ~LV() { resizePath(0); }
235
236 void resizePath(unsigned Length) {
237 if (Length == PathLength)
238 return;
239 if (hasPathPtr())
240 delete [] PathPtr;
241 PathLength = Length;
242 if (hasPathPtr())
243 PathPtr = new LValuePathEntry[Length];
244 }
245
246 bool hasPath() const { return PathLength != (unsigned)-1; }
247 bool hasPathPtr() const { return hasPath() && PathLength > InlinePathSpace; }
248
249 LValuePathEntry *getPath() { return hasPathPtr() ? PathPtr : Path; }
250 const LValuePathEntry *getPath() const {
251 return hasPathPtr() ? PathPtr : Path;
252 }
253};
254
255namespace {
256 struct MemberPointerBase {
257 llvm::PointerIntPair<const ValueDecl*, 1, bool> MemberAndIsDerivedMember;
258 unsigned PathLength;
259 };
260}
261
262struct APValue::MemberPointerData : MemberPointerBase {
263 static const unsigned InlinePathSpace =
264 (DataSize - sizeof(MemberPointerBase)) / sizeof(const CXXRecordDecl*);
265 typedef const CXXRecordDecl *PathElem;
266 union {
267 PathElem Path[InlinePathSpace];
269 };
270
271 MemberPointerData() { PathLength = 0; }
272 ~MemberPointerData() { resizePath(0); }
273
274 void resizePath(unsigned Length) {
275 if (Length == PathLength)
276 return;
277 if (hasPathPtr())
278 delete [] PathPtr;
279 PathLength = Length;
280 if (hasPathPtr())
281 PathPtr = new PathElem[Length];
282 }
283
284 bool hasPathPtr() const { return PathLength > InlinePathSpace; }
285
286 PathElem *getPath() { return hasPathPtr() ? PathPtr : Path; }
287 const PathElem *getPath() const {
288 return hasPathPtr() ? PathPtr : Path;
289 }
290};
291
292// FIXME: Reduce the malloc traffic here.
293
294APValue::Arr::Arr(unsigned NumElts, unsigned Size) :
295 Elts(new APValue[NumElts + (NumElts != Size ? 1 : 0)]),
296 NumElts(NumElts), ArrSize(Size) {}
297APValue::Arr::~Arr() { delete [] Elts; }
298
299APValue::StructData::StructData(unsigned NumBases, unsigned NumFields) :
300 Elts(new APValue[NumBases+NumFields]),
301 NumBases(NumBases), NumFields(NumFields) {}
302APValue::StructData::~StructData() {
303 delete [] Elts;
304}
305
306APValue::UnionData::UnionData() : Field(nullptr), Value(new APValue) {}
307APValue::UnionData::~UnionData () {
308 delete Value;
309}
310
311APValue::APValue(const APValue &RHS) : Kind(None) {
312 switch (RHS.getKind()) {
313 case None:
314 case Indeterminate:
315 Kind = RHS.getKind();
316 break;
317 case Int:
318 MakeInt();
319 setInt(RHS.getInt());
320 break;
321 case Float:
322 MakeFloat();
323 setFloat(RHS.getFloat());
324 break;
325 case FixedPoint: {
326 APFixedPoint FXCopy = RHS.getFixedPoint();
327 MakeFixedPoint(std::move(FXCopy));
328 break;
329 }
330 case Vector:
331 MakeVector();
332 setVector(((const Vec *)(const char *)&RHS.Data)->Elts,
333 RHS.getVectorLength());
334 break;
335 case ComplexInt:
336 MakeComplexInt();
338 break;
339 case ComplexFloat:
340 MakeComplexFloat();
342 break;
343 case LValue:
344 MakeLValue();
345 if (RHS.hasLValuePath())
348 else
350 RHS.isNullPointer());
351 break;
352 case Array:
353 MakeArray(RHS.getArrayInitializedElts(), RHS.getArraySize());
354 for (unsigned I = 0, N = RHS.getArrayInitializedElts(); I != N; ++I)
356 if (RHS.hasArrayFiller())
358 break;
359 case Struct:
360 MakeStruct(RHS.getStructNumBases(), RHS.getStructNumFields());
361 for (unsigned I = 0, N = RHS.getStructNumBases(); I != N; ++I)
362 getStructBase(I) = RHS.getStructBase(I);
363 for (unsigned I = 0, N = RHS.getStructNumFields(); I != N; ++I)
364 getStructField(I) = RHS.getStructField(I);
365 break;
366 case Union:
367 MakeUnion();
369 break;
370 case MemberPointer:
371 MakeMemberPointer(RHS.getMemberPointerDecl(),
374 break;
375 case AddrLabelDiff:
376 MakeAddrLabelDiff();
378 break;
379 }
380}
381
382APValue::APValue(APValue &&RHS) : Kind(RHS.Kind), Data(RHS.Data) {
383 RHS.Kind = None;
384}
385
387 if (this != &RHS)
388 *this = APValue(RHS);
389 return *this;
390}
391
393 if (Kind != None && Kind != Indeterminate)
394 DestroyDataAndMakeUninit();
395 Kind = RHS.Kind;
396 Data = RHS.Data;
397 RHS.Kind = None;
398 return *this;
399}
400
401void APValue::DestroyDataAndMakeUninit() {
402 if (Kind == Int)
403 ((APSInt *)(char *)&Data)->~APSInt();
404 else if (Kind == Float)
405 ((APFloat *)(char *)&Data)->~APFloat();
406 else if (Kind == FixedPoint)
407 ((APFixedPoint *)(char *)&Data)->~APFixedPoint();
408 else if (Kind == Vector)
409 ((Vec *)(char *)&Data)->~Vec();
410 else if (Kind == ComplexInt)
411 ((ComplexAPSInt *)(char *)&Data)->~ComplexAPSInt();
412 else if (Kind == ComplexFloat)
413 ((ComplexAPFloat *)(char *)&Data)->~ComplexAPFloat();
414 else if (Kind == LValue)
415 ((LV *)(char *)&Data)->~LV();
416 else if (Kind == Array)
417 ((Arr *)(char *)&Data)->~Arr();
418 else if (Kind == Struct)
419 ((StructData *)(char *)&Data)->~StructData();
420 else if (Kind == Union)
421 ((UnionData *)(char *)&Data)->~UnionData();
422 else if (Kind == MemberPointer)
423 ((MemberPointerData *)(char *)&Data)->~MemberPointerData();
424 else if (Kind == AddrLabelDiff)
425 ((AddrLabelDiffData *)(char *)&Data)->~AddrLabelDiffData();
426 Kind = None;
427}
428
430 switch (getKind()) {
431 case None:
432 case Indeterminate:
433 case AddrLabelDiff:
434 return false;
435 case Struct:
436 case Union:
437 case Array:
438 case Vector:
439 return true;
440 case Int:
441 return getInt().needsCleanup();
442 case Float:
443 return getFloat().needsCleanup();
444 case FixedPoint:
445 return getFixedPoint().getValue().needsCleanup();
446 case ComplexFloat:
449 "In _Complex float types, real and imaginary values always have the "
450 "same size.");
451 return getComplexFloatReal().needsCleanup();
452 case ComplexInt:
453 assert(getComplexIntImag().needsCleanup() ==
455 "In _Complex int types, real and imaginary values must have the "
456 "same size.");
457 return getComplexIntReal().needsCleanup();
458 case LValue:
459 return reinterpret_cast<const LV *>(&Data)->hasPathPtr();
460 case MemberPointer:
461 return reinterpret_cast<const MemberPointerData *>(&Data)->hasPathPtr();
462 }
463 llvm_unreachable("Unknown APValue kind!");
464}
465
467 std::swap(Kind, RHS.Kind);
468 std::swap(Data, RHS.Data);
469}
470
471/// Profile the value of an APInt, excluding its bit-width.
472static void profileIntValue(llvm::FoldingSetNodeID &ID, const llvm::APInt &V) {
473 for (unsigned I = 0, N = V.getBitWidth(); I < N; I += 32)
474 ID.AddInteger((uint32_t)V.extractBitsAsZExtValue(std::min(32u, N - I), I));
475}
476
477void APValue::Profile(llvm::FoldingSetNodeID &ID) const {
478 // Note that our profiling assumes that only APValues of the same type are
479 // ever compared. As a result, we don't consider collisions that could only
480 // happen if the types are different. (For example, structs with different
481 // numbers of members could profile the same.)
482
483 ID.AddInteger(Kind);
484
485 switch (Kind) {
486 case None:
487 case Indeterminate:
488 return;
489
490 case AddrLabelDiff:
491 ID.AddPointer(getAddrLabelDiffLHS()->getLabel()->getCanonicalDecl());
492 ID.AddPointer(getAddrLabelDiffRHS()->getLabel()->getCanonicalDecl());
493 return;
494
495 case Struct:
496 for (unsigned I = 0, N = getStructNumBases(); I != N; ++I)
497 getStructBase(I).Profile(ID);
498 for (unsigned I = 0, N = getStructNumFields(); I != N; ++I)
499 getStructField(I).Profile(ID);
500 return;
501
502 case Union:
503 if (!getUnionField()) {
504 ID.AddInteger(0);
505 return;
506 }
507 ID.AddInteger(getUnionField()->getFieldIndex() + 1);
509 return;
510
511 case Array: {
512 if (getArraySize() == 0)
513 return;
514
515 // The profile should not depend on whether the array is expanded or
516 // not, but we don't want to profile the array filler many times for
517 // a large array. So treat all equal trailing elements as the filler.
518 // Elements are profiled in reverse order to support this, and the
519 // first profiled element is followed by a count. For example:
520 //
521 // ['a', 'c', 'x', 'x', 'x'] is profiled as
522 // [5, 'x', 3, 'c', 'a']
523 llvm::FoldingSetNodeID FillerID;
526 .Profile(FillerID);
527 ID.AddNodeID(FillerID);
528 unsigned NumFillers = getArraySize() - getArrayInitializedElts();
529 unsigned N = getArrayInitializedElts();
530
531 // Count the number of elements equal to the last one. This loop ends
532 // by adding an integer indicating the number of such elements, with
533 // N set to the number of elements left to profile.
534 while (true) {
535 if (N == 0) {
536 // All elements are fillers.
537 assert(NumFillers == getArraySize());
538 ID.AddInteger(NumFillers);
539 break;
540 }
541
542 // No need to check if the last element is equal to the last
543 // element.
544 if (N != getArraySize()) {
545 llvm::FoldingSetNodeID ElemID;
546 getArrayInitializedElt(N - 1).Profile(ElemID);
547 if (ElemID != FillerID) {
548 ID.AddInteger(NumFillers);
549 ID.AddNodeID(ElemID);
550 --N;
551 break;
552 }
553 }
554
555 // This is a filler.
556 ++NumFillers;
557 --N;
558 }
559
560 // Emit the remaining elements.
561 for (; N != 0; --N)
563 return;
564 }
565
566 case Vector:
567 for (unsigned I = 0, N = getVectorLength(); I != N; ++I)
568 getVectorElt(I).Profile(ID);
569 return;
570
571 case Int:
572 profileIntValue(ID, getInt());
573 return;
574
575 case Float:
576 profileIntValue(ID, getFloat().bitcastToAPInt());
577 return;
578
579 case FixedPoint:
581 return;
582
583 case ComplexFloat:
584 profileIntValue(ID, getComplexFloatReal().bitcastToAPInt());
585 profileIntValue(ID, getComplexFloatImag().bitcastToAPInt());
586 return;
587
588 case ComplexInt:
591 return;
592
593 case LValue:
595 ID.AddInteger(getLValueOffset().getQuantity());
596 ID.AddInteger((isNullPointer() ? 1 : 0) |
597 (isLValueOnePastTheEnd() ? 2 : 0) |
598 (hasLValuePath() ? 4 : 0));
599 if (hasLValuePath()) {
600 ID.AddInteger(getLValuePath().size());
601 // For uniqueness, we only need to profile the entries corresponding
602 // to union members, but we don't have the type here so we don't know
603 // how to interpret the entries.
605 E.Profile(ID);
606 }
607 return;
608
609 case MemberPointer:
610 ID.AddPointer(getMemberPointerDecl());
611 ID.AddInteger(isMemberPointerToDerivedMember());
612 for (const CXXRecordDecl *D : getMemberPointerPath())
613 ID.AddPointer(D);
614 return;
615 }
616
617 llvm_unreachable("Unknown APValue kind!");
618}
619
620static double GetApproxValue(const llvm::APFloat &F) {
621 llvm::APFloat V = F;
622 bool ignored;
623 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
624 &ignored);
625 return V.convertToDouble();
626}
627
628static bool TryPrintAsStringLiteral(raw_ostream &Out,
629 const PrintingPolicy &Policy,
630 const ArrayType *ATy,
631 ArrayRef<APValue> Inits) {
632 if (Inits.empty())
633 return false;
634
635 QualType Ty = ATy->getElementType();
636 if (!Ty->isAnyCharacterType())
637 return false;
638
639 // Nothing we can do about a sequence that is not null-terminated
640 if (!Inits.back().isInt() || !Inits.back().getInt().isZero())
641 return false;
642
643 Inits = Inits.drop_back();
644
646 Buf.push_back('"');
647
648 // Better than printing a two-digit sequence of 10 integers.
649 constexpr size_t MaxN = 36;
650 StringRef Ellipsis;
651 if (Inits.size() > MaxN && !Policy.EntireContentsOfLargeArray) {
652 Ellipsis = "[...]";
653 Inits =
654 Inits.take_front(std::min(MaxN - Ellipsis.size() / 2, Inits.size()));
655 }
656
657 for (auto &Val : Inits) {
658 if (!Val.isInt())
659 return false;
660 int64_t Char64 = Val.getInt().getExtValue();
661 if (!isASCII(Char64))
662 return false; // Bye bye, see you in integers.
663 auto Ch = static_cast<unsigned char>(Char64);
664 // The diagnostic message is 'quoted'
665 StringRef Escaped = escapeCStyle<EscapeChar::SingleAndDouble>(Ch);
666 if (Escaped.empty()) {
667 if (!isPrintable(Ch))
668 return false;
669 Buf.emplace_back(Ch);
670 } else {
671 Buf.append(Escaped);
672 }
673 }
674
675 Buf.append(Ellipsis);
676 Buf.push_back('"');
677
678 if (Ty->isWideCharType())
679 Out << 'L';
680 else if (Ty->isChar8Type())
681 Out << "u8";
682 else if (Ty->isChar16Type())
683 Out << 'u';
684 else if (Ty->isChar32Type())
685 Out << 'U';
686
687 Out << Buf;
688 return true;
689}
690
691void APValue::printPretty(raw_ostream &Out, const ASTContext &Ctx,
692 QualType Ty) const {
693 printPretty(Out, Ctx.getPrintingPolicy(), Ty, &Ctx);
694}
695
696void APValue::printPretty(raw_ostream &Out, const PrintingPolicy &Policy,
697 QualType Ty, const ASTContext *Ctx) const {
698 // There are no objects of type 'void', but values of this type can be
699 // returned from functions.
700 if (Ty->isVoidType()) {
701 Out << "void()";
702 return;
703 }
704
705 switch (getKind()) {
706 case APValue::None:
707 Out << "<out of lifetime>";
708 return;
710 Out << "<uninitialized>";
711 return;
712 case APValue::Int:
713 if (Ty->isBooleanType())
714 Out << (getInt().getBoolValue() ? "true" : "false");
715 else
716 Out << getInt();
717 return;
718 case APValue::Float:
719 Out << GetApproxValue(getFloat());
720 return;
722 Out << getFixedPoint();
723 return;
724 case APValue::Vector: {
725 Out << '{';
726 QualType ElemTy = Ty->castAs<VectorType>()->getElementType();
727 getVectorElt(0).printPretty(Out, Policy, ElemTy, Ctx);
728 for (unsigned i = 1; i != getVectorLength(); ++i) {
729 Out << ", ";
730 getVectorElt(i).printPretty(Out, Policy, ElemTy, Ctx);
731 }
732 Out << '}';
733 return;
734 }
736 Out << getComplexIntReal() << "+" << getComplexIntImag() << "i";
737 return;
739 Out << GetApproxValue(getComplexFloatReal()) << "+"
741 return;
742 case APValue::LValue: {
743 bool IsReference = Ty->isReferenceType();
744 QualType InnerTy
745 = IsReference ? Ty.getNonReferenceType() : Ty->getPointeeType();
746 if (InnerTy.isNull())
747 InnerTy = Ty;
748
750 if (!Base) {
751 if (isNullPointer()) {
752 Out << (Policy.Nullptr ? "nullptr" : "0");
753 } else if (IsReference) {
754 Out << "*(" << InnerTy.stream(Policy) << "*)"
756 } else {
757 Out << "(" << Ty.stream(Policy) << ")"
759 }
760 return;
761 }
762
763 if (!hasLValuePath()) {
764 // No lvalue path: just print the offset.
766 CharUnits S = Ctx ? Ctx->getTypeSizeInCharsIfKnown(InnerTy).value_or(
768 : CharUnits::Zero();
769 if (!O.isZero()) {
770 if (IsReference)
771 Out << "*(";
772 if (S.isZero() || O % S) {
773 Out << "(char*)";
774 S = CharUnits::One();
775 }
776 Out << '&';
777 } else if (!IsReference) {
778 Out << '&';
779 }
780
781 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
782 Out << *VD;
783 else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
784 TI.print(Out, Policy);
785 } else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
786 Out << "{*new "
787 << Base.getDynamicAllocType().stream(Policy) << "#"
788 << DA.getIndex() << "}";
789 } else {
790 assert(Base.get<const Expr *>() != nullptr &&
791 "Expecting non-null Expr");
792 Base.get<const Expr*>()->printPretty(Out, nullptr, Policy);
793 }
794
795 if (!O.isZero()) {
796 Out << " + " << (O / S);
797 if (IsReference)
798 Out << ')';
799 }
800 return;
801 }
802
803 // We have an lvalue path. Print it out nicely.
804 if (!IsReference)
805 Out << '&';
806 else if (isLValueOnePastTheEnd())
807 Out << "*(&";
808
809 QualType ElemTy = Base.getType();
810 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
811 Out << *VD;
812 } else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
813 TI.print(Out, Policy);
814 } else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
815 Out << "{*new " << Base.getDynamicAllocType().stream(Policy) << "#"
816 << DA.getIndex() << "}";
817 } else {
818 const Expr *E = Base.get<const Expr*>();
819 assert(E != nullptr && "Expecting non-null Expr");
820 E->printPretty(Out, nullptr, Policy);
821 }
822
824 const CXXRecordDecl *CastToBase = nullptr;
825 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
826 if (ElemTy->isRecordType()) {
827 // The lvalue refers to a class type, so the next path entry is a base
828 // or member.
829 const Decl *BaseOrMember = Path[I].getAsBaseOrMember().getPointer();
830 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
831 CastToBase = RD;
832 // Leave ElemTy referring to the most-derived class. The actual type
833 // doesn't matter except for array types.
834 } else {
835 const ValueDecl *VD = cast<ValueDecl>(BaseOrMember);
836 Out << ".";
837 if (CastToBase)
838 Out << *CastToBase << "::";
839 Out << *VD;
840 ElemTy = VD->getType();
841 }
842 } else {
843 // The lvalue must refer to an array.
844 Out << '[' << Path[I].getAsArrayIndex() << ']';
845 ElemTy = ElemTy->castAsArrayTypeUnsafe()->getElementType();
846 }
847 }
848
849 // Handle formatting of one-past-the-end lvalues.
850 if (isLValueOnePastTheEnd()) {
851 // FIXME: If CastToBase is non-0, we should prefix the output with
852 // "(CastToBase*)".
853 Out << " + 1";
854 if (IsReference)
855 Out << ')';
856 }
857 return;
858 }
859 case APValue::Array: {
860 const ArrayType *AT = Ty->castAsArrayTypeUnsafe();
861 unsigned N = getArrayInitializedElts();
862 if (N != 0 && TryPrintAsStringLiteral(Out, Policy, AT,
863 {&getArrayInitializedElt(0), N}))
864 return;
865 QualType ElemTy = AT->getElementType();
866 Out << '{';
867 unsigned I = 0;
868 switch (N) {
869 case 0:
870 for (; I != N; ++I) {
871 Out << ", ";
872 if (I == 10 && !Policy.EntireContentsOfLargeArray) {
873 Out << "...}";
874 return;
875 }
876 [[fallthrough]];
877 default:
878 getArrayInitializedElt(I).printPretty(Out, Policy, ElemTy, Ctx);
879 }
880 }
881 Out << '}';
882 return;
883 }
884 case APValue::Struct: {
885 Out << '{';
886 const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
887 bool First = true;
888 if (unsigned N = getStructNumBases()) {
889 const CXXRecordDecl *CD = cast<CXXRecordDecl>(RD);
891 for (unsigned I = 0; I != N; ++I, ++BI) {
892 assert(BI != CD->bases_end());
893 if (!First)
894 Out << ", ";
895 getStructBase(I).printPretty(Out, Policy, BI->getType(), Ctx);
896 First = false;
897 }
898 }
899 for (const auto *FI : RD->fields()) {
900 if (!First)
901 Out << ", ";
902 if (FI->isUnnamedBitfield()) continue;
903 getStructField(FI->getFieldIndex()).
904 printPretty(Out, Policy, FI->getType(), Ctx);
905 First = false;
906 }
907 Out << '}';
908 return;
909 }
910 case APValue::Union:
911 Out << '{';
912 if (const FieldDecl *FD = getUnionField()) {
913 Out << "." << *FD << " = ";
914 getUnionValue().printPretty(Out, Policy, FD->getType(), Ctx);
915 }
916 Out << '}';
917 return;
919 // FIXME: This is not enough to unambiguously identify the member in a
920 // multiple-inheritance scenario.
921 if (const ValueDecl *VD = getMemberPointerDecl()) {
922 Out << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD;
923 return;
924 }
925 Out << "0";
926 return;
928 Out << "&&" << getAddrLabelDiffLHS()->getLabel()->getName();
929 Out << " - ";
930 Out << "&&" << getAddrLabelDiffRHS()->getLabel()->getName();
931 return;
932 }
933 llvm_unreachable("Unknown APValue kind!");
934}
935
936std::string APValue::getAsString(const ASTContext &Ctx, QualType Ty) const {
937 std::string Result;
938 llvm::raw_string_ostream Out(Result);
939 printPretty(Out, Ctx, Ty);
940 Out.flush();
941 return Result;
942}
943
945 const ASTContext &Ctx) const {
946 if (isInt()) {
947 Result = getInt();
948 return true;
949 }
950
951 if (isLValue() && isNullPointer()) {
952 Result = Ctx.MakeIntValue(Ctx.getTargetNullPointerValue(SrcTy), SrcTy);
953 return true;
954 }
955
956 if (isLValue() && !getLValueBase()) {
957 Result = Ctx.MakeIntValue(getLValueOffset().getQuantity(), SrcTy);
958 return true;
959 }
960
961 return false;
962}
963
965 assert(isLValue() && "Invalid accessor");
966 return ((const LV *)(const void *)&Data)->Base;
967}
968
970 assert(isLValue() && "Invalid accessor");
971 return ((const LV *)(const void *)&Data)->IsOnePastTheEnd;
972}
973
975 assert(isLValue() && "Invalid accessor");
976 return ((LV *)(void *)&Data)->Offset;
977}
978
980 assert(isLValue() && "Invalid accessor");
981 return ((const LV *)(const char *)&Data)->hasPath();
982}
983
985 assert(isLValue() && hasLValuePath() && "Invalid accessor");
986 const LV &LVal = *((const LV *)(const char *)&Data);
987 return llvm::ArrayRef(LVal.getPath(), LVal.PathLength);
988}
989
991 assert(isLValue() && "Invalid accessor");
992 return ((const LV *)(const char *)&Data)->Base.getCallIndex();
993}
994
996 assert(isLValue() && "Invalid accessor");
997 return ((const LV *)(const char *)&Data)->Base.getVersion();
998}
999
1001 assert(isLValue() && "Invalid usage");
1002 return ((const LV *)(const char *)&Data)->IsNullPtr;
1003}
1004
1006 bool IsNullPtr) {
1007 assert(isLValue() && "Invalid accessor");
1008 LV &LVal = *((LV *)(char *)&Data);
1009 LVal.Base = B;
1010 LVal.IsOnePastTheEnd = false;
1011 LVal.Offset = O;
1012 LVal.resizePath((unsigned)-1);
1013 LVal.IsNullPtr = IsNullPtr;
1014}
1015
1017APValue::setLValueUninit(LValueBase B, const CharUnits &O, unsigned Size,
1018 bool IsOnePastTheEnd, bool IsNullPtr) {
1019 assert(isLValue() && "Invalid accessor");
1020 LV &LVal = *((LV *)(char *)&Data);
1021 LVal.Base = B;
1022 LVal.IsOnePastTheEnd = IsOnePastTheEnd;
1023 LVal.Offset = O;
1024 LVal.IsNullPtr = IsNullPtr;
1025 LVal.resizePath(Size);
1026 return {LVal.getPath(), Size};
1027}
1028
1030 ArrayRef<LValuePathEntry> Path, bool IsOnePastTheEnd,
1031 bool IsNullPtr) {
1033 setLValueUninit(B, O, Path.size(), IsOnePastTheEnd, IsNullPtr);
1034 if (Path.size()) {
1035 memcpy(InternalPath.data(), Path.data(),
1036 Path.size() * sizeof(LValuePathEntry));
1037 }
1038}
1039
1040void APValue::setUnion(const FieldDecl *Field, const APValue &Value) {
1041 assert(isUnion() && "Invalid accessor");
1042 ((UnionData *)(char *)&Data)->Field =
1043 Field ? Field->getCanonicalDecl() : nullptr;
1044 *((UnionData *)(char *)&Data)->Value = Value;
1045}
1046
1048 assert(isMemberPointer() && "Invalid accessor");
1049 const MemberPointerData &MPD =
1050 *((const MemberPointerData *)(const char *)&Data);
1051 return MPD.MemberAndIsDerivedMember.getPointer();
1052}
1053
1055 assert(isMemberPointer() && "Invalid accessor");
1056 const MemberPointerData &MPD =
1057 *((const MemberPointerData *)(const char *)&Data);
1058 return MPD.MemberAndIsDerivedMember.getInt();
1059}
1060
1062 assert(isMemberPointer() && "Invalid accessor");
1063 const MemberPointerData &MPD =
1064 *((const MemberPointerData *)(const char *)&Data);
1065 return llvm::ArrayRef(MPD.getPath(), MPD.PathLength);
1066}
1067
1068void APValue::MakeLValue() {
1069 assert(isAbsent() && "Bad state change");
1070 static_assert(sizeof(LV) <= DataSize, "LV too big");
1071 new ((void *)(char *)&Data) LV();
1072 Kind = LValue;
1073}
1074
1075void APValue::MakeArray(unsigned InitElts, unsigned Size) {
1076 assert(isAbsent() && "Bad state change");
1077 new ((void *)(char *)&Data) Arr(InitElts, Size);
1078 Kind = Array;
1079}
1080
1083 bool OnePastTheEnd, bool IsNullPtr);
1084
1086APValue::setMemberPointerUninit(const ValueDecl *Member, bool IsDerivedMember,
1087 unsigned Size) {
1088 assert(isAbsent() && "Bad state change");
1089 MemberPointerData *MPD = new ((void *)(char *)&Data) MemberPointerData;
1090 Kind = MemberPointer;
1091 MPD->MemberAndIsDerivedMember.setPointer(
1092 Member ? cast<ValueDecl>(Member->getCanonicalDecl()) : nullptr);
1093 MPD->MemberAndIsDerivedMember.setInt(IsDerivedMember);
1094 MPD->resizePath(Size);
1095 return {MPD->getPath(), MPD->PathLength};
1096}
1097
1098void APValue::MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
1101 setMemberPointerUninit(Member, IsDerivedMember, Path.size());
1102 for (unsigned I = 0; I != Path.size(); ++I)
1103 InternalPath[I] = Path[I]->getCanonicalDecl();
1104}
1105
1106LinkageInfo LinkageComputer::getLVForValue(const APValue &V,
1107 LVComputationKind computation) {
1109
1110 auto MergeLV = [&](LinkageInfo MergeLV) {
1111 LV.merge(MergeLV);
1112 return LV.getLinkage() == InternalLinkage;
1113 };
1114 auto Merge = [&](const APValue &V) {
1115 return MergeLV(getLVForValue(V, computation));
1116 };
1117
1118 switch (V.getKind()) {
1119 case APValue::None:
1121 case APValue::Int:
1122 case APValue::Float:
1126 case APValue::Vector:
1127 break;
1128
1130 // Even for an inline function, it's not reasonable to treat a difference
1131 // between the addresses of labels as an external value.
1132 return LinkageInfo::internal();
1133
1134 case APValue::Struct: {
1135 for (unsigned I = 0, N = V.getStructNumBases(); I != N; ++I)
1136 if (Merge(V.getStructBase(I)))
1137 break;
1138 for (unsigned I = 0, N = V.getStructNumFields(); I != N; ++I)
1139 if (Merge(V.getStructField(I)))
1140 break;
1141 break;
1142 }
1143
1144 case APValue::Union:
1145 if (V.getUnionField())
1146 Merge(V.getUnionValue());
1147 break;
1148
1149 case APValue::Array: {
1150 for (unsigned I = 0, N = V.getArrayInitializedElts(); I != N; ++I)
1151 if (Merge(V.getArrayInitializedElt(I)))
1152 break;
1153 if (V.hasArrayFiller())
1154 Merge(V.getArrayFiller());
1155 break;
1156 }
1157
1158 case APValue::LValue: {
1159 if (!V.getLValueBase()) {
1160 // Null or absolute address: this is external.
1161 } else if (const auto *VD =
1162 V.getLValueBase().dyn_cast<const ValueDecl *>()) {
1163 if (VD && MergeLV(getLVForDecl(VD, computation)))
1164 break;
1165 } else if (const auto TI = V.getLValueBase().dyn_cast<TypeInfoLValue>()) {
1166 if (MergeLV(getLVForType(*TI.getType(), computation)))
1167 break;
1168 } else if (const Expr *E = V.getLValueBase().dyn_cast<const Expr *>()) {
1169 // Almost all expression bases are internal. The exception is
1170 // lifetime-extended temporaries.
1171 // FIXME: These should be modeled as having the
1172 // LifetimeExtendedTemporaryDecl itself as the base.
1173 // FIXME: If we permit Objective-C object literals in template arguments,
1174 // they should not imply internal linkage.
1175 auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E);
1176 if (!MTE || MTE->getStorageDuration() == SD_FullExpression)
1177 return LinkageInfo::internal();
1178 if (MergeLV(getLVForDecl(MTE->getExtendingDecl(), computation)))
1179 break;
1180 } else {
1181 assert(V.getLValueBase().is<DynamicAllocLValue>() &&
1182 "unexpected LValueBase kind");
1183 return LinkageInfo::internal();
1184 }
1185 // The lvalue path doesn't matter: pointers to all subobjects always have
1186 // the same visibility as pointers to the complete object.
1187 break;
1188 }
1189
1191 if (const NamedDecl *D = V.getMemberPointerDecl())
1192 MergeLV(getLVForDecl(D, computation));
1193 // Note that we could have a base-to-derived conversion here to a member of
1194 // a derived class with less linkage/visibility. That's covered by the
1195 // linkage and visibility of the value's type.
1196 break;
1197 }
1198
1199 return LV;
1200}
static double GetApproxValue(const llvm::APFloat &F)
Definition: APValue.cpp:620
static void profileIntValue(llvm::FoldingSetNodeID &ID, const llvm::APInt &V)
Profile the value of an APInt, excluding its bit-width.
Definition: APValue.cpp:472
static bool TryPrintAsStringLiteral(raw_ostream &Out, const PrintingPolicy &Policy, const ArrayType *ATy, ArrayRef< APValue > Inits)
Definition: APValue.cpp:628
MutableArrayRef< APValue::LValuePathEntry > setLValueUninit(APValue::LValueBase B, const CharUnits &O, unsigned Size, bool OnePastTheEnd, bool IsNullPtr)
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3217
StringRef P
static SVal getValue(SVal val, SValBuilder &svalBuilder)
llvm::APSInt APSInt
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
unsigned Offset
Definition: Format.cpp:2776
static const Decl * getCanonicalDecl(const Decl *D)
const char * Data
C Language Family Type Representation.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: APValue.cpp:127
QualType getType() const
Definition: APValue.cpp:63
unsigned getVersion() const
Definition: APValue.cpp:113
QualType getDynamicAllocType() const
Definition: APValue.cpp:122
QualType getTypeInfoType() const
Definition: APValue.cpp:117
static LValueBase getTypeInfo(TypeInfoLValue LV, QualType TypeInfo)
Definition: APValue.cpp:55
static LValueBase getDynamicAlloc(DynamicAllocLValue LV, QualType Type)
Definition: APValue.cpp:47
void * getOpaqueValue() const
Definition: APValue.cpp:175
unsigned getCallIndex() const
Definition: APValue.cpp:108
A non-discriminated union of a base, field, or array index.
Definition: APValue.h:208
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: APValue.cpp:153
LValuePathSerializationHelper(ArrayRef< LValuePathEntry >, QualType)
Definition: APValue.cpp:157
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
bool hasArrayFiller() const
Definition: APValue.h:510
const LValueBase getLValueBase() const
Definition: APValue.cpp:964
void setFloat(APFloat F)
Definition: APValue.h:584
APValue & getArrayInitializedElt(unsigned I)
Definition: APValue.h:502
ArrayRef< LValuePathEntry > getLValuePath() const
Definition: APValue.cpp:984
void swap(APValue &RHS)
Swaps the contents of this and the given APValue.
Definition: APValue.cpp:466
APSInt & getInt()
Definition: APValue.h:415
APValue & getStructField(unsigned i)
Definition: APValue.h:543
void setInt(APSInt I)
Definition: APValue.h:580
const FieldDecl * getUnionField() const
Definition: APValue.h:555
APSInt & getComplexIntImag()
Definition: APValue.h:453
unsigned getStructNumFields() const
Definition: APValue.h:534
bool isAbsent() const
Definition: APValue.h:389
llvm::PointerIntPair< const Decl *, 1, bool > BaseOrMemberType
A FieldDecl or CXXRecordDecl, along with a flag indicating whether we mean a virtual or non-virtual b...
Definition: APValue.h:205
ValueKind getKind() const
Definition: APValue.h:387
bool isLValueOnePastTheEnd() const
Definition: APValue.cpp:969
unsigned getLValueVersion() const
Definition: APValue.cpp:995
bool isMemberPointerToDerivedMember() const
Definition: APValue.cpp:1054
unsigned getArrayInitializedElts() const
Definition: APValue.h:521
void setComplexInt(APSInt R, APSInt I)
Definition: APValue.h:597
void Profile(llvm::FoldingSetNodeID &ID) const
profile this value.
Definition: APValue.cpp:477
unsigned getStructNumBases() const
Definition: APValue.h:530
APFixedPoint & getFixedPoint()
Definition: APValue.h:437
bool needsCleanup() const
Returns whether the object performed allocations.
Definition: APValue.cpp:429
bool hasLValuePath() const
Definition: APValue.cpp:979
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:1047
APValue & getUnionValue()
Definition: APValue.h:559
const AddrLabelExpr * getAddrLabelDiffRHS() const
Definition: APValue.h:575
CharUnits & getLValueOffset()
Definition: APValue.cpp:974
void printPretty(raw_ostream &OS, const ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:691
void setAddrLabelDiff(const AddrLabelExpr *LHSExpr, const AddrLabelExpr *RHSExpr)
Definition: APValue.h:617
void setComplexFloat(APFloat R, APFloat I)
Definition: APValue.h:604
APValue & getVectorElt(unsigned I)
Definition: APValue.h:489
APValue & getArrayFiller()
Definition: APValue.h:513
unsigned getVectorLength() const
Definition: APValue.h:497
bool isLValue() const
Definition: APValue.h:398
void setUnion(const FieldDecl *Field, const APValue &Value)
Definition: APValue.cpp:1040
void setLValue(LValueBase B, const CharUnits &O, NoLValuePath, bool IsNullPtr)
Definition: APValue.cpp:1005
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:1061
bool isMemberPointer() const
Definition: APValue.h:403
bool isInt() const
Definition: APValue.h:393
unsigned getArraySize() const
Definition: APValue.h:525
bool isUnion() const
Definition: APValue.h:402
bool toIntegralConstant(APSInt &Result, QualType SrcTy, const ASTContext &Ctx) const
Try to convert this value to an integral constant.
Definition: APValue.cpp:944
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:936
APValue & operator=(const APValue &RHS)
Definition: APValue.cpp:386
unsigned getLValueCallIndex() const
Definition: APValue.cpp:990
void setVector(const APValue *E, unsigned N)
Definition: APValue.h:592
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
Definition: APValue.h:131
@ None
There is no such object (it's outside its lifetime).
Definition: APValue.h:129
bool isNullPointer() const
Definition: APValue.cpp:1000
APSInt & getComplexIntReal()
Definition: APValue.h:445
APFloat & getComplexFloatImag()
Definition: APValue.h:469
APFloat & getComplexFloatReal()
Definition: APValue.h:461
APFloat & getFloat()
Definition: APValue.h:429
APValue & getStructBase(unsigned i)
Definition: APValue.h:538
const AddrLabelExpr * getAddrLabelDiffLHS() const
Definition: APValue.h:571
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
uint64_t getTargetNullPointerValue(QualType QT) const
Get target-dependent integer value for null pointer which is used for constant folding.
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:684
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const
Make an APSInt of the appropriate width and signedness for the given Value and integer Type.
Definition: ASTContext.h:2957
std::optional< CharUnits > getTypeSizeInCharsIfKnown(QualType Ty) const
Definition: ASTContext.h:2298
LabelDecl * getLabel() const
Definition: Expr.h:4334
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:3031
QualType getElementType() const
Definition: Type.h:3052
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:245
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
base_class_iterator bases_end()
Definition: DeclCXX.h:611
base_class_iterator bases_begin()
Definition: DeclCXX.h:609
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 One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
Symbolic representation of a dynamic allocation.
Definition: APValue.h:65
This represents one expression.
Definition: Expr.h:110
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...
Definition: Expr.cpp:82
Represents a member of a struct/union/class.
Definition: Decl.h:2941
LinkageInfo getLVForDecl(const NamedDecl *D, LVComputationKind computation)
getLVForDecl - Get the linkage and visibility for the given declaration.
Definition: Decl.cpp:1531
static LinkageInfo external()
Definition: Visibility.h:67
Linkage getLinkage() const
Definition: Visibility.h:83
static LinkageInfo internal()
Definition: Visibility.h:70
void merge(LinkageInfo other)
Merge both linkage and visibility.
Definition: Visibility.h:132
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4562
This represents a decl that may have a name.
Definition: Decl.h:247
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:274
A (possibly-)qualified type.
Definition: Type.h:736
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:803
static QualType getFromOpaquePtr(const void *Ptr)
Definition: Type.h:785
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6858
StreamedQualTypeHelper stream(const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Definition: Type.h:1145
Represents a struct/union/class.
Definition: Decl.h:3998
field_range fields() const
Definition: Decl.h:4225
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4835
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
Symbolic representation of typeid(T) for some type T.
Definition: APValue.h:44
const Type * getType() const
Definition: APValue.h:51
void print(llvm::raw_ostream &Out, const PrintingPolicy &Policy) const
Definition: APValue.cpp:30
The base class of the type hierarchy.
Definition: Type.h:1566
bool isVoidType() const
Definition: Type.h:7218
bool isBooleanType() const
Definition: Type.h:7334
bool isIncompleteArrayType() const
Definition: Type.h:6984
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
Definition: Type.h:7500
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7491
bool isReferenceType() const
Definition: Type.h:6922
bool isChar8Type() const
Definition: Type.cpp:2001
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:629
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:2021
bool isChar16Type() const
Definition: Type.cpp:2007
bool isChar32Type() const
Definition: Type.cpp:2013
bool isWideCharType() const
Definition: Type.cpp:1994
bool isRecordType() const
Definition: Type.h:7000
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:701
QualType getType() const
Definition: Decl.h:712
Represents a GCC generic vector type.
Definition: Type.h:3377
LLVM_READNONE bool isASCII(char c)
Returns true if a byte is an ASCII character.
Definition: CharInfo.h:42
LLVM_READONLY bool isPrintable(unsigned char c)
Return true if this character is an ASCII printable character; that is, a character that should take ...
Definition: CharInfo.h:145
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
Definition: CallGraph.h:207
@ InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
@ SD_FullExpression
Full-expression storage duration (for temporaries).
Definition: Specifiers.h:312
@ Result
The result type of a method or function.
llvm::hash_code hash_value(const CustomizableOptional< T > &O)
U cast(CodeGen::Address addr)
Definition: Address.h:151
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
#define bool
Definition: stdbool.h:20
bool hasPathPtr() const
Definition: APValue.cpp:247
void resizePath(unsigned Length)
Definition: APValue.cpp:236
bool hasPath() const
Definition: APValue.cpp:246
LValuePathEntry * PathPtr
Definition: APValue.cpp:230
const LValuePathEntry * getPath() const
Definition: APValue.cpp:250
LValuePathEntry * getPath()
Definition: APValue.cpp:249
const CXXRecordDecl * PathElem
Definition: APValue.cpp:265
void resizePath(unsigned Length)
Definition: APValue.cpp:274
const PathElem * getPath() const
Definition: APValue.cpp:287
Kinds of LV computation.
Definition: Linkage.h:29
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
unsigned Nullptr
Whether we should use 'nullptr' rather than '0' as a null pointer constant.
unsigned EntireContentsOfLargeArray
Whether to print the entire array initializers, especially on non-type template parameters,...