xref: /freebsd/contrib/llvm-project/clang/lib/AST/APValue.cpp (revision 7029da5c36f2d3cf6bb6c81bf551229f416399e8) 
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 "clang/AST/ASTContext.h"
15 #include "clang/AST/CharUnits.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/Expr.h"
18 #include "clang/AST/Type.h"
19 #include "llvm/Support/ErrorHandling.h"
20 #include "llvm/Support/raw_ostream.h"
21 using namespace clang;
22 
23 /// The identity of a type_info object depends on the canonical unqualified
24 /// type only.
25 TypeInfoLValue::TypeInfoLValue(const Type *T)
26     : T(T->getCanonicalTypeUnqualified().getTypePtr()) {}
27 
28 void TypeInfoLValue::print(llvm::raw_ostream &Out,
29                            const PrintingPolicy &Policy) const {
30   Out << "typeid(";
31   QualType(getType(), 0).print(Out, Policy);
32   Out << ")";
33 }
34 
35 static_assert(
36     1 << llvm::PointerLikeTypeTraits<TypeInfoLValue>::NumLowBitsAvailable <=
37         alignof(Type),
38     "Type is insufficiently aligned");
39 
40 APValue::LValueBase::LValueBase(const ValueDecl *P, unsigned I, unsigned V)
41     : Ptr(P), Local{I, V} {}
42 APValue::LValueBase::LValueBase(const Expr *P, unsigned I, unsigned V)
43     : Ptr(P), Local{I, V} {}
44 
45 APValue::LValueBase APValue::LValueBase::getTypeInfo(TypeInfoLValue LV,
46                                                      QualType TypeInfo) {
47   LValueBase Base;
48   Base.Ptr = LV;
49   Base.TypeInfoType = TypeInfo.getAsOpaquePtr();
50   return Base;
51 }
52 
53 unsigned APValue::LValueBase::getCallIndex() const {
54   return is<TypeInfoLValue>() ? 0 : Local.CallIndex;
55 }
56 
57 unsigned APValue::LValueBase::getVersion() const {
58   return is<TypeInfoLValue>() ? 0 : Local.Version;
59 }
60 
61 QualType APValue::LValueBase::getTypeInfoType() const {
62   assert(is<TypeInfoLValue>() && "not a type_info lvalue");
63   return QualType::getFromOpaquePtr(TypeInfoType);
64 }
65 
66 namespace clang {
67 bool operator==(const APValue::LValueBase &LHS,
68                 const APValue::LValueBase &RHS) {
69   if (LHS.Ptr != RHS.Ptr)
70     return false;
71   if (LHS.is<TypeInfoLValue>())
72     return true;
73   return LHS.Local.CallIndex == RHS.Local.CallIndex &&
74          LHS.Local.Version == RHS.Local.Version;
75 }
76 }
77 
78 namespace {
79   struct LVBase {
80     APValue::LValueBase Base;
81     CharUnits Offset;
82     unsigned PathLength;
83     bool IsNullPtr : 1;
84     bool IsOnePastTheEnd : 1;
85   };
86 }
87 
88 void *APValue::LValueBase::getOpaqueValue() const {
89   return Ptr.getOpaqueValue();
90 }
91 
92 bool APValue::LValueBase::isNull() const {
93   return Ptr.isNull();
94 }
95 
96 APValue::LValueBase::operator bool () const {
97   return static_cast<bool>(Ptr);
98 }
99 
100 clang::APValue::LValueBase
101 llvm::DenseMapInfo<clang::APValue::LValueBase>::getEmptyKey() {
102   return clang::APValue::LValueBase(
103       DenseMapInfo<const ValueDecl*>::getEmptyKey());
104 }
105 
106 clang::APValue::LValueBase
107 llvm::DenseMapInfo<clang::APValue::LValueBase>::getTombstoneKey() {
108   return clang::APValue::LValueBase(
109       DenseMapInfo<const ValueDecl*>::getTombstoneKey());
110 }
111 
112 namespace clang {
113 llvm::hash_code hash_value(const APValue::LValueBase &Base) {
114   if (Base.is<TypeInfoLValue>())
115     return llvm::hash_value(Base.getOpaqueValue());
116   return llvm::hash_combine(Base.getOpaqueValue(), Base.getCallIndex(),
117                             Base.getVersion());
118 }
119 }
120 
121 unsigned llvm::DenseMapInfo<clang::APValue::LValueBase>::getHashValue(
122     const clang::APValue::LValueBase &Base) {
123   return hash_value(Base);
124 }
125 
126 bool llvm::DenseMapInfo<clang::APValue::LValueBase>::isEqual(
127     const clang::APValue::LValueBase &LHS,
128     const clang::APValue::LValueBase &RHS) {
129   return LHS == RHS;
130 }
131 
132 struct APValue::LV : LVBase {
133   static const unsigned InlinePathSpace =
134       (DataSize - sizeof(LVBase)) / sizeof(LValuePathEntry);
135 
136   /// Path - The sequence of base classes, fields and array indices to follow to
137   /// walk from Base to the subobject. When performing GCC-style folding, there
138   /// may not be such a path.
139   union {
140     LValuePathEntry Path[InlinePathSpace];
141     LValuePathEntry *PathPtr;
142   };
143 
144   LV() { PathLength = (unsigned)-1; }
145   ~LV() { resizePath(0); }
146 
147   void resizePath(unsigned Length) {
148     if (Length == PathLength)
149       return;
150     if (hasPathPtr())
151       delete [] PathPtr;
152     PathLength = Length;
153     if (hasPathPtr())
154       PathPtr = new LValuePathEntry[Length];
155   }
156 
157   bool hasPath() const { return PathLength != (unsigned)-1; }
158   bool hasPathPtr() const { return hasPath() && PathLength > InlinePathSpace; }
159 
160   LValuePathEntry *getPath() { return hasPathPtr() ? PathPtr : Path; }
161   const LValuePathEntry *getPath() const {
162     return hasPathPtr() ? PathPtr : Path;
163   }
164 };
165 
166 namespace {
167   struct MemberPointerBase {
168     llvm::PointerIntPair<const ValueDecl*, 1, bool> MemberAndIsDerivedMember;
169     unsigned PathLength;
170   };
171 }
172 
173 struct APValue::MemberPointerData : MemberPointerBase {
174   static const unsigned InlinePathSpace =
175       (DataSize - sizeof(MemberPointerBase)) / sizeof(const CXXRecordDecl*);
176   typedef const CXXRecordDecl *PathElem;
177   union {
178     PathElem Path[InlinePathSpace];
179     PathElem *PathPtr;
180   };
181 
182   MemberPointerData() { PathLength = 0; }
183   ~MemberPointerData() { resizePath(0); }
184 
185   void resizePath(unsigned Length) {
186     if (Length == PathLength)
187       return;
188     if (hasPathPtr())
189       delete [] PathPtr;
190     PathLength = Length;
191     if (hasPathPtr())
192       PathPtr = new PathElem[Length];
193   }
194 
195   bool hasPathPtr() const { return PathLength > InlinePathSpace; }
196 
197   PathElem *getPath() { return hasPathPtr() ? PathPtr : Path; }
198   const PathElem *getPath() const {
199     return hasPathPtr() ? PathPtr : Path;
200   }
201 };
202 
203 // FIXME: Reduce the malloc traffic here.
204 
205 APValue::Arr::Arr(unsigned NumElts, unsigned Size) :
206   Elts(new APValue[NumElts + (NumElts != Size ? 1 : 0)]),
207   NumElts(NumElts), ArrSize(Size) {}
208 APValue::Arr::~Arr() { delete [] Elts; }
209 
210 APValue::StructData::StructData(unsigned NumBases, unsigned NumFields) :
211   Elts(new APValue[NumBases+NumFields]),
212   NumBases(NumBases), NumFields(NumFields) {}
213 APValue::StructData::~StructData() {
214   delete [] Elts;
215 }
216 
217 APValue::UnionData::UnionData() : Field(nullptr), Value(new APValue) {}
218 APValue::UnionData::~UnionData () {
219   delete Value;
220 }
221 
222 APValue::APValue(const APValue &RHS) : Kind(None) {
223   switch (RHS.getKind()) {
224   case None:
225   case Indeterminate:
226     Kind = RHS.getKind();
227     break;
228   case Int:
229     MakeInt();
230     setInt(RHS.getInt());
231     break;
232   case Float:
233     MakeFloat();
234     setFloat(RHS.getFloat());
235     break;
236   case FixedPoint: {
237     APFixedPoint FXCopy = RHS.getFixedPoint();
238     MakeFixedPoint(std::move(FXCopy));
239     break;
240   }
241   case Vector:
242     MakeVector();
243     setVector(((const Vec *)(const char *)RHS.Data.buffer)->Elts,
244               RHS.getVectorLength());
245     break;
246   case ComplexInt:
247     MakeComplexInt();
248     setComplexInt(RHS.getComplexIntReal(), RHS.getComplexIntImag());
249     break;
250   case ComplexFloat:
251     MakeComplexFloat();
252     setComplexFloat(RHS.getComplexFloatReal(), RHS.getComplexFloatImag());
253     break;
254   case LValue:
255     MakeLValue();
256     if (RHS.hasLValuePath())
257       setLValue(RHS.getLValueBase(), RHS.getLValueOffset(), RHS.getLValuePath(),
258                 RHS.isLValueOnePastTheEnd(), RHS.isNullPointer());
259     else
260       setLValue(RHS.getLValueBase(), RHS.getLValueOffset(), NoLValuePath(),
261                 RHS.isNullPointer());
262     break;
263   case Array:
264     MakeArray(RHS.getArrayInitializedElts(), RHS.getArraySize());
265     for (unsigned I = 0, N = RHS.getArrayInitializedElts(); I != N; ++I)
266       getArrayInitializedElt(I) = RHS.getArrayInitializedElt(I);
267     if (RHS.hasArrayFiller())
268       getArrayFiller() = RHS.getArrayFiller();
269     break;
270   case Struct:
271     MakeStruct(RHS.getStructNumBases(), RHS.getStructNumFields());
272     for (unsigned I = 0, N = RHS.getStructNumBases(); I != N; ++I)
273       getStructBase(I) = RHS.getStructBase(I);
274     for (unsigned I = 0, N = RHS.getStructNumFields(); I != N; ++I)
275       getStructField(I) = RHS.getStructField(I);
276     break;
277   case Union:
278     MakeUnion();
279     setUnion(RHS.getUnionField(), RHS.getUnionValue());
280     break;
281   case MemberPointer:
282     MakeMemberPointer(RHS.getMemberPointerDecl(),
283                       RHS.isMemberPointerToDerivedMember(),
284                       RHS.getMemberPointerPath());
285     break;
286   case AddrLabelDiff:
287     MakeAddrLabelDiff();
288     setAddrLabelDiff(RHS.getAddrLabelDiffLHS(), RHS.getAddrLabelDiffRHS());
289     break;
290   }
291 }
292 
293 void APValue::DestroyDataAndMakeUninit() {
294   if (Kind == Int)
295     ((APSInt*)(char*)Data.buffer)->~APSInt();
296   else if (Kind == Float)
297     ((APFloat*)(char*)Data.buffer)->~APFloat();
298   else if (Kind == FixedPoint)
299     ((APFixedPoint *)(char *)Data.buffer)->~APFixedPoint();
300   else if (Kind == Vector)
301     ((Vec*)(char*)Data.buffer)->~Vec();
302   else if (Kind == ComplexInt)
303     ((ComplexAPSInt*)(char*)Data.buffer)->~ComplexAPSInt();
304   else if (Kind == ComplexFloat)
305     ((ComplexAPFloat*)(char*)Data.buffer)->~ComplexAPFloat();
306   else if (Kind == LValue)
307     ((LV*)(char*)Data.buffer)->~LV();
308   else if (Kind == Array)
309     ((Arr*)(char*)Data.buffer)->~Arr();
310   else if (Kind == Struct)
311     ((StructData*)(char*)Data.buffer)->~StructData();
312   else if (Kind == Union)
313     ((UnionData*)(char*)Data.buffer)->~UnionData();
314   else if (Kind == MemberPointer)
315     ((MemberPointerData*)(char*)Data.buffer)->~MemberPointerData();
316   else if (Kind == AddrLabelDiff)
317     ((AddrLabelDiffData*)(char*)Data.buffer)->~AddrLabelDiffData();
318   Kind = None;
319 }
320 
321 bool APValue::needsCleanup() const {
322   switch (getKind()) {
323   case None:
324   case Indeterminate:
325   case AddrLabelDiff:
326     return false;
327   case Struct:
328   case Union:
329   case Array:
330   case Vector:
331     return true;
332   case Int:
333     return getInt().needsCleanup();
334   case Float:
335     return getFloat().needsCleanup();
336   case FixedPoint:
337     return getFixedPoint().getValue().needsCleanup();
338   case ComplexFloat:
339     assert(getComplexFloatImag().needsCleanup() ==
340                getComplexFloatReal().needsCleanup() &&
341            "In _Complex float types, real and imaginary values always have the "
342            "same size.");
343     return getComplexFloatReal().needsCleanup();
344   case ComplexInt:
345     assert(getComplexIntImag().needsCleanup() ==
346                getComplexIntReal().needsCleanup() &&
347            "In _Complex int types, real and imaginary values must have the "
348            "same size.");
349     return getComplexIntReal().needsCleanup();
350   case LValue:
351     return reinterpret_cast<const LV *>(Data.buffer)->hasPathPtr();
352   case MemberPointer:
353     return reinterpret_cast<const MemberPointerData *>(Data.buffer)
354         ->hasPathPtr();
355   }
356   llvm_unreachable("Unknown APValue kind!");
357 }
358 
359 void APValue::swap(APValue &RHS) {
360   std::swap(Kind, RHS.Kind);
361   char TmpData[DataSize];
362   memcpy(TmpData, Data.buffer, DataSize);
363   memcpy(Data.buffer, RHS.Data.buffer, DataSize);
364   memcpy(RHS.Data.buffer, TmpData, DataSize);
365 }
366 
367 LLVM_DUMP_METHOD void APValue::dump() const {
368   dump(llvm::errs());
369   llvm::errs() << '\n';
370 }
371 
372 static double GetApproxValue(const llvm::APFloat &F) {
373   llvm::APFloat V = F;
374   bool ignored;
375   V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
376             &ignored);
377   return V.convertToDouble();
378 }
379 
380 void APValue::dump(raw_ostream &OS) const {
381   switch (getKind()) {
382   case None:
383     OS << "None";
384     return;
385   case Indeterminate:
386     OS << "Indeterminate";
387     return;
388   case Int:
389     OS << "Int: " << getInt();
390     return;
391   case Float:
392     OS << "Float: " << GetApproxValue(getFloat());
393     return;
394   case FixedPoint:
395     OS << "FixedPoint : " << getFixedPoint();
396     return;
397   case Vector:
398     OS << "Vector: ";
399     getVectorElt(0).dump(OS);
400     for (unsigned i = 1; i != getVectorLength(); ++i) {
401       OS << ", ";
402       getVectorElt(i).dump(OS);
403     }
404     return;
405   case ComplexInt:
406     OS << "ComplexInt: " << getComplexIntReal() << ", " << getComplexIntImag();
407     return;
408   case ComplexFloat:
409     OS << "ComplexFloat: " << GetApproxValue(getComplexFloatReal())
410        << ", " << GetApproxValue(getComplexFloatImag());
411     return;
412   case LValue:
413     OS << "LValue: <todo>";
414     return;
415   case Array:
416     OS << "Array: ";
417     for (unsigned I = 0, N = getArrayInitializedElts(); I != N; ++I) {
418       getArrayInitializedElt(I).dump(OS);
419       if (I != getArraySize() - 1) OS << ", ";
420     }
421     if (hasArrayFiller()) {
422       OS << getArraySize() - getArrayInitializedElts() << " x ";
423       getArrayFiller().dump(OS);
424     }
425     return;
426   case Struct:
427     OS << "Struct ";
428     if (unsigned N = getStructNumBases()) {
429       OS << " bases: ";
430       getStructBase(0).dump(OS);
431       for (unsigned I = 1; I != N; ++I) {
432         OS << ", ";
433         getStructBase(I).dump(OS);
434       }
435     }
436     if (unsigned N = getStructNumFields()) {
437       OS << " fields: ";
438       getStructField(0).dump(OS);
439       for (unsigned I = 1; I != N; ++I) {
440         OS << ", ";
441         getStructField(I).dump(OS);
442       }
443     }
444     return;
445   case Union:
446     OS << "Union: ";
447     getUnionValue().dump(OS);
448     return;
449   case MemberPointer:
450     OS << "MemberPointer: <todo>";
451     return;
452   case AddrLabelDiff:
453     OS << "AddrLabelDiff: <todo>";
454     return;
455   }
456   llvm_unreachable("Unknown APValue kind!");
457 }
458 
459 void APValue::printPretty(raw_ostream &Out, const ASTContext &Ctx,
460                           QualType Ty) const {
461   switch (getKind()) {
462   case APValue::None:
463     Out << "<out of lifetime>";
464     return;
465   case APValue::Indeterminate:
466     Out << "<uninitialized>";
467     return;
468   case APValue::Int:
469     if (Ty->isBooleanType())
470       Out << (getInt().getBoolValue() ? "true" : "false");
471     else
472       Out << getInt();
473     return;
474   case APValue::Float:
475     Out << GetApproxValue(getFloat());
476     return;
477   case APValue::FixedPoint:
478     Out << getFixedPoint();
479     return;
480   case APValue::Vector: {
481     Out << '{';
482     QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
483     getVectorElt(0).printPretty(Out, Ctx, ElemTy);
484     for (unsigned i = 1; i != getVectorLength(); ++i) {
485       Out << ", ";
486       getVectorElt(i).printPretty(Out, Ctx, ElemTy);
487     }
488     Out << '}';
489     return;
490   }
491   case APValue::ComplexInt:
492     Out << getComplexIntReal() << "+" << getComplexIntImag() << "i";
493     return;
494   case APValue::ComplexFloat:
495     Out << GetApproxValue(getComplexFloatReal()) << "+"
496         << GetApproxValue(getComplexFloatImag()) << "i";
497     return;
498   case APValue::LValue: {
499     bool IsReference = Ty->isReferenceType();
500     QualType InnerTy
501       = IsReference ? Ty.getNonReferenceType() : Ty->getPointeeType();
502     if (InnerTy.isNull())
503       InnerTy = Ty;
504 
505     LValueBase Base = getLValueBase();
506     if (!Base) {
507       if (isNullPointer()) {
508         Out << (Ctx.getLangOpts().CPlusPlus11 ? "nullptr" : "0");
509       } else if (IsReference) {
510         Out << "*(" << InnerTy.stream(Ctx.getPrintingPolicy()) << "*)"
511             << getLValueOffset().getQuantity();
512       } else {
513         Out << "(" << Ty.stream(Ctx.getPrintingPolicy()) << ")"
514             << getLValueOffset().getQuantity();
515       }
516       return;
517     }
518 
519     if (!hasLValuePath()) {
520       // No lvalue path: just print the offset.
521       CharUnits O = getLValueOffset();
522       CharUnits S = Ctx.getTypeSizeInChars(InnerTy);
523       if (!O.isZero()) {
524         if (IsReference)
525           Out << "*(";
526         if (O % S) {
527           Out << "(char*)";
528           S = CharUnits::One();
529         }
530         Out << '&';
531       } else if (!IsReference)
532         Out << '&';
533 
534       if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
535         Out << *VD;
536       else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
537         TI.print(Out, Ctx.getPrintingPolicy());
538       } else {
539         assert(Base.get<const Expr *>() != nullptr &&
540                "Expecting non-null Expr");
541         Base.get<const Expr*>()->printPretty(Out, nullptr,
542                                              Ctx.getPrintingPolicy());
543       }
544 
545       if (!O.isZero()) {
546         Out << " + " << (O / S);
547         if (IsReference)
548           Out << ')';
549       }
550       return;
551     }
552 
553     // We have an lvalue path. Print it out nicely.
554     if (!IsReference)
555       Out << '&';
556     else if (isLValueOnePastTheEnd())
557       Out << "*(&";
558 
559     QualType ElemTy;
560     if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
561       Out << *VD;
562       ElemTy = VD->getType();
563     } else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
564       TI.print(Out, Ctx.getPrintingPolicy());
565       ElemTy = Base.getTypeInfoType();
566     } else {
567       const Expr *E = Base.get<const Expr*>();
568       assert(E != nullptr && "Expecting non-null Expr");
569       E->printPretty(Out, nullptr, Ctx.getPrintingPolicy());
570       ElemTy = E->getType();
571     }
572 
573     ArrayRef<LValuePathEntry> Path = getLValuePath();
574     const CXXRecordDecl *CastToBase = nullptr;
575     for (unsigned I = 0, N = Path.size(); I != N; ++I) {
576       if (ElemTy->getAs<RecordType>()) {
577         // The lvalue refers to a class type, so the next path entry is a base
578         // or member.
579         const Decl *BaseOrMember = Path[I].getAsBaseOrMember().getPointer();
580         if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
581           CastToBase = RD;
582           ElemTy = Ctx.getRecordType(RD);
583         } else {
584           const ValueDecl *VD = cast<ValueDecl>(BaseOrMember);
585           Out << ".";
586           if (CastToBase)
587             Out << *CastToBase << "::";
588           Out << *VD;
589           ElemTy = VD->getType();
590         }
591       } else {
592         // The lvalue must refer to an array.
593         Out << '[' << Path[I].getAsArrayIndex() << ']';
594         ElemTy = Ctx.getAsArrayType(ElemTy)->getElementType();
595       }
596     }
597 
598     // Handle formatting of one-past-the-end lvalues.
599     if (isLValueOnePastTheEnd()) {
600       // FIXME: If CastToBase is non-0, we should prefix the output with
601       // "(CastToBase*)".
602       Out << " + 1";
603       if (IsReference)
604         Out << ')';
605     }
606     return;
607   }
608   case APValue::Array: {
609     const ArrayType *AT = Ctx.getAsArrayType(Ty);
610     QualType ElemTy = AT->getElementType();
611     Out << '{';
612     if (unsigned N = getArrayInitializedElts()) {
613       getArrayInitializedElt(0).printPretty(Out, Ctx, ElemTy);
614       for (unsigned I = 1; I != N; ++I) {
615         Out << ", ";
616         if (I == 10) {
617           // Avoid printing out the entire contents of large arrays.
618           Out << "...";
619           break;
620         }
621         getArrayInitializedElt(I).printPretty(Out, Ctx, ElemTy);
622       }
623     }
624     Out << '}';
625     return;
626   }
627   case APValue::Struct: {
628     Out << '{';
629     const RecordDecl *RD = Ty->getAs<RecordType>()->getDecl();
630     bool First = true;
631     if (unsigned N = getStructNumBases()) {
632       const CXXRecordDecl *CD = cast<CXXRecordDecl>(RD);
633       CXXRecordDecl::base_class_const_iterator BI = CD->bases_begin();
634       for (unsigned I = 0; I != N; ++I, ++BI) {
635         assert(BI != CD->bases_end());
636         if (!First)
637           Out << ", ";
638         getStructBase(I).printPretty(Out, Ctx, BI->getType());
639         First = false;
640       }
641     }
642     for (const auto *FI : RD->fields()) {
643       if (!First)
644         Out << ", ";
645       if (FI->isUnnamedBitfield()) continue;
646       getStructField(FI->getFieldIndex()).
647         printPretty(Out, Ctx, FI->getType());
648       First = false;
649     }
650     Out << '}';
651     return;
652   }
653   case APValue::Union:
654     Out << '{';
655     if (const FieldDecl *FD = getUnionField()) {
656       Out << "." << *FD << " = ";
657       getUnionValue().printPretty(Out, Ctx, FD->getType());
658     }
659     Out << '}';
660     return;
661   case APValue::MemberPointer:
662     // FIXME: This is not enough to unambiguously identify the member in a
663     // multiple-inheritance scenario.
664     if (const ValueDecl *VD = getMemberPointerDecl()) {
665       Out << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD;
666       return;
667     }
668     Out << "0";
669     return;
670   case APValue::AddrLabelDiff:
671     Out << "&&" << getAddrLabelDiffLHS()->getLabel()->getName();
672     Out << " - ";
673     Out << "&&" << getAddrLabelDiffRHS()->getLabel()->getName();
674     return;
675   }
676   llvm_unreachable("Unknown APValue kind!");
677 }
678 
679 std::string APValue::getAsString(const ASTContext &Ctx, QualType Ty) const {
680   std::string Result;
681   llvm::raw_string_ostream Out(Result);
682   printPretty(Out, Ctx, Ty);
683   Out.flush();
684   return Result;
685 }
686 
687 bool APValue::toIntegralConstant(APSInt &Result, QualType SrcTy,
688                                  const ASTContext &Ctx) const {
689   if (isInt()) {
690     Result = getInt();
691     return true;
692   }
693 
694   if (isLValue() && isNullPointer()) {
695     Result = Ctx.MakeIntValue(Ctx.getTargetNullPointerValue(SrcTy), SrcTy);
696     return true;
697   }
698 
699   if (isLValue() && !getLValueBase()) {
700     Result = Ctx.MakeIntValue(getLValueOffset().getQuantity(), SrcTy);
701     return true;
702   }
703 
704   return false;
705 }
706 
707 const APValue::LValueBase APValue::getLValueBase() const {
708   assert(isLValue() && "Invalid accessor");
709   return ((const LV*)(const void*)Data.buffer)->Base;
710 }
711 
712 bool APValue::isLValueOnePastTheEnd() const {
713   assert(isLValue() && "Invalid accessor");
714   return ((const LV*)(const void*)Data.buffer)->IsOnePastTheEnd;
715 }
716 
717 CharUnits &APValue::getLValueOffset() {
718   assert(isLValue() && "Invalid accessor");
719   return ((LV*)(void*)Data.buffer)->Offset;
720 }
721 
722 bool APValue::hasLValuePath() const {
723   assert(isLValue() && "Invalid accessor");
724   return ((const LV*)(const char*)Data.buffer)->hasPath();
725 }
726 
727 ArrayRef<APValue::LValuePathEntry> APValue::getLValuePath() const {
728   assert(isLValue() && hasLValuePath() && "Invalid accessor");
729   const LV &LVal = *((const LV*)(const char*)Data.buffer);
730   return llvm::makeArrayRef(LVal.getPath(), LVal.PathLength);
731 }
732 
733 unsigned APValue::getLValueCallIndex() const {
734   assert(isLValue() && "Invalid accessor");
735   return ((const LV*)(const char*)Data.buffer)->Base.getCallIndex();
736 }
737 
738 unsigned APValue::getLValueVersion() const {
739   assert(isLValue() && "Invalid accessor");
740   return ((const LV*)(const char*)Data.buffer)->Base.getVersion();
741 }
742 
743 bool APValue::isNullPointer() const {
744   assert(isLValue() && "Invalid usage");
745   return ((const LV*)(const char*)Data.buffer)->IsNullPtr;
746 }
747 
748 void APValue::setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
749                         bool IsNullPtr) {
750   assert(isLValue() && "Invalid accessor");
751   LV &LVal = *((LV*)(char*)Data.buffer);
752   LVal.Base = B;
753   LVal.IsOnePastTheEnd = false;
754   LVal.Offset = O;
755   LVal.resizePath((unsigned)-1);
756   LVal.IsNullPtr = IsNullPtr;
757 }
758 
759 void APValue::setLValue(LValueBase B, const CharUnits &O,
760                         ArrayRef<LValuePathEntry> Path, bool IsOnePastTheEnd,
761                         bool IsNullPtr) {
762   assert(isLValue() && "Invalid accessor");
763   LV &LVal = *((LV*)(char*)Data.buffer);
764   LVal.Base = B;
765   LVal.IsOnePastTheEnd = IsOnePastTheEnd;
766   LVal.Offset = O;
767   LVal.resizePath(Path.size());
768   memcpy(LVal.getPath(), Path.data(), Path.size() * sizeof(LValuePathEntry));
769   LVal.IsNullPtr = IsNullPtr;
770 }
771 
772 const ValueDecl *APValue::getMemberPointerDecl() const {
773   assert(isMemberPointer() && "Invalid accessor");
774   const MemberPointerData &MPD =
775       *((const MemberPointerData *)(const char *)Data.buffer);
776   return MPD.MemberAndIsDerivedMember.getPointer();
777 }
778 
779 bool APValue::isMemberPointerToDerivedMember() const {
780   assert(isMemberPointer() && "Invalid accessor");
781   const MemberPointerData &MPD =
782       *((const MemberPointerData *)(const char *)Data.buffer);
783   return MPD.MemberAndIsDerivedMember.getInt();
784 }
785 
786 ArrayRef<const CXXRecordDecl*> APValue::getMemberPointerPath() const {
787   assert(isMemberPointer() && "Invalid accessor");
788   const MemberPointerData &MPD =
789       *((const MemberPointerData *)(const char *)Data.buffer);
790   return llvm::makeArrayRef(MPD.getPath(), MPD.PathLength);
791 }
792 
793 void APValue::MakeLValue() {
794   assert(isAbsent() && "Bad state change");
795   static_assert(sizeof(LV) <= DataSize, "LV too big");
796   new ((void*)(char*)Data.buffer) LV();
797   Kind = LValue;
798 }
799 
800 void APValue::MakeArray(unsigned InitElts, unsigned Size) {
801   assert(isAbsent() && "Bad state change");
802   new ((void*)(char*)Data.buffer) Arr(InitElts, Size);
803   Kind = Array;
804 }
805 
806 void APValue::MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
807                                 ArrayRef<const CXXRecordDecl*> Path) {
808   assert(isAbsent() && "Bad state change");
809   MemberPointerData *MPD = new ((void*)(char*)Data.buffer) MemberPointerData;
810   Kind = MemberPointer;
811   MPD->MemberAndIsDerivedMember.setPointer(Member);
812   MPD->MemberAndIsDerivedMember.setInt(IsDerivedMember);
813   MPD->resizePath(Path.size());
814   memcpy(MPD->getPath(), Path.data(), Path.size()*sizeof(const CXXRecordDecl*));
815 }
816