clang  16.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"
15 #include "clang/AST/ASTContext.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"
23 using 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 
30 void 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 
37 static_assert(
39  alignof(Type),
40  "Type is insufficiently aligned");
41 
42 APValue::LValueBase::LValueBase(const ValueDecl *P, unsigned I, unsigned V)
43  : Ptr(P ? cast<ValueDecl>(P->getCanonicalDecl()) : nullptr), Local{I, V} {}
44 APValue::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 
127 void 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 
135 namespace 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 
153 void APValue::LValuePathEntry::Profile(llvm::FoldingSetNodeID &ID) const {
154  ID.AddInteger(Value);
155 }
156 
158  ArrayRef<LValuePathEntry> Path, QualType ElemTy)
159  : ElemTy((const void *)ElemTy.getTypePtrOrNull()), Path(Path) {}
160 
162  return QualType::getFromOpaquePtr(ElemTy);
163 }
164 
165 namespace {
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 
183 APValue::LValueBase::operator bool () const {
184  return static_cast<bool>(Ptr);
185 }
186 
190  B.Ptr = DenseMapInfo<const ValueDecl*>::getEmptyKey();
191  return B;
192 }
193 
197  B.Ptr = DenseMapInfo<const ValueDecl*>::getTombstoneKey();
198  return B;
199 }
200 
201 namespace clang {
202 llvm::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 
212  return hash_value(Base);
213 }
214 
216  const clang::APValue::LValueBase &LHS,
217  const clang::APValue::LValueBase &RHS) {
218  return LHS == RHS;
219 }
220 
221 struct 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 
255 namespace {
256  struct MemberPointerBase {
257  llvm::PointerIntPair<const ValueDecl*, 1, bool> MemberAndIsDerivedMember;
258  unsigned PathLength;
259  };
260 }
261 
262 struct 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];
268  PathElem *PathPtr;
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 
294 APValue::Arr::Arr(unsigned NumElts, unsigned Size) :
295  Elts(new APValue[NumElts + (NumElts != Size ? 1 : 0)]),
296  NumElts(NumElts), ArrSize(Size) {}
297 APValue::Arr::~Arr() { delete [] Elts; }
298 
299 APValue::StructData::StructData(unsigned NumBases, unsigned NumFields) :
300  Elts(new APValue[NumBases+NumFields]),
301  NumBases(NumBases), NumFields(NumFields) {}
302 APValue::StructData::~StructData() {
303  delete [] Elts;
304 }
305 
306 APValue::UnionData::UnionData() : Field(nullptr), Value(new APValue) {}
307 APValue::UnionData::~UnionData () {
308  delete Value;
309 }
310 
311 APValue::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())
347  RHS.isLValueOnePastTheEnd(), RHS.isNullPointer());
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())
357  getArrayFiller() = RHS.getArrayFiller();
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();
368  setUnion(RHS.getUnionField(), RHS.getUnionValue());
369  break;
370  case MemberPointer:
371  MakeMemberPointer(RHS.getMemberPointerDecl(),
373  RHS.getMemberPointerPath());
374  break;
375  case AddrLabelDiff:
376  MakeAddrLabelDiff();
378  break;
379  }
380 }
381 
382 APValue::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 
401 void 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 
429 bool APValue::needsCleanup() const {
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:
447  assert(getComplexFloatImag().needsCleanup() ==
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 
466 void APValue::swap(APValue &RHS) {
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.
472 static 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 
477 void 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)
498  for (unsigned I = 0, N = getStructNumFields(); I != N; ++I)
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:
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.
604  for (LValuePathEntry E : getLValuePath())
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 
620 static 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 
628 static 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 
691 void APValue::printPretty(raw_ostream &Out, const ASTContext &Ctx,
692  QualType Ty) const {
693  printPretty(Out, Ctx.getPrintingPolicy(), Ty, &Ctx);
694 }
695 
696 void 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;
721  case APValue::FixedPoint:
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  }
735  case APValue::ComplexInt:
736  Out << getComplexIntReal() << "+" << getComplexIntImag() << "i";
737  return;
739  Out << GetApproxValue(getComplexFloatReal()) << "+"
740  << GetApproxValue(getComplexFloatImag()) << "i";
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(
767  CharUnits::Zero())
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 
937  std::string Result;
938  llvm::raw_string_ostream Out(Result);
939  printPretty(Out, Ctx, Ty);
940  Out.flush();
941  return Result;
942 }
943 
944 bool APValue::toIntegralConstant(APSInt &Result, QualType SrcTy,
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::makeArrayRef(LVal.getPath(), LVal.PathLength);
988 }
989 
990 unsigned APValue::getLValueCallIndex() const {
991  assert(isLValue() && "Invalid accessor");
992  return ((const LV *)(const char *)&Data)->Base.getCallIndex();
993 }
994 
995 unsigned APValue::getLValueVersion() const {
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 
1017 APValue::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 
1040 void 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::makeArrayRef(MPD.getPath(), MPD.PathLength);
1066 }
1067 
1068 void 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 
1075 void 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 
1081 MutableArrayRef<APValue::LValuePathEntry>
1082 setLValueUninit(APValue::LValueBase B, const CharUnits &O, unsigned Size,
1083  bool OnePastTheEnd, bool IsNullPtr);
1084 
1085 MutableArrayRef<const CXXRecordDecl *>
1086 APValue::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 
1098 void APValue::MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
1100  MutableArrayRef<const CXXRecordDecl *> InternalPath =
1101  setMemberPointerUninit(Member, IsDerivedMember, Path.size());
1102  for (unsigned I = 0; I != Path.size(); ++I)
1103  InternalPath[I] = Path[I]->getCanonicalDecl();
1104 }
1105 
1106 LinkageInfo 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:
1123  case APValue::FixedPoint:
1124  case APValue::ComplexInt:
1125  case APValue::ComplexFloat:
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 }
clang::APValue::setComplexInt
void setComplexInt(APSInt R, APSInt I)
Definition: APValue.h:597
clang::InternalLinkage
@ InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
profileIntValue
static void profileIntValue(llvm::FoldingSetNodeID &ID, const llvm::APInt &V)
Profile the value of an APInt, excluding its bit-width.
Definition: APValue.cpp:472
clang::APValue::LV::hasPath
bool hasPath() const
Definition: APValue.cpp:246
clang::APValue::LValuePathEntry::LValuePathEntry
LValuePathEntry()
Definition: APValue.h:214
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6973
clang::APValue::getKind
ValueKind getKind() const
Definition: APValue.h:387
clang::APValue::LValueBase
Definition: APValue.h:146
clang::CXXBaseSpecifier::getType
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:245
clang::isPrintable
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
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::APValue::getLValueOffset
CharUnits & getLValueOffset()
Definition: APValue.cpp:974
clang::APValue::LValueBase::getCallIndex
unsigned getCallIndex() const
Definition: APValue.cpp:108
clang::APValue::operator=
APValue & operator=(const APValue &RHS)
Definition: APValue.cpp:386
clang::APValue::getStructNumFields
unsigned getStructNumFields() const
Definition: APValue.h:534
clang::APValue::LValueBase::is
bool is() const
Definition: APValue.h:161
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::APValue::MemberPointerData::MemberPointerData
MemberPointerData()
Definition: APValue.cpp:271
clang::APValue::LValueBase::getTypeInfoType
QualType getTypeInfoType() const
Definition: APValue.cpp:117
clang::APValue::FixedPoint
@ FixedPoint
Definition: APValue.h:134
clang::APValue::getLValuePath
ArrayRef< LValuePathEntry > getLValuePath() const
Definition: APValue.cpp:984
clang::APValue::MemberPointerData::PathElem
const typedef CXXRecordDecl * PathElem
Definition: APValue.cpp:265
clang::APValue::setUnion
void setUnion(const FieldDecl *Field, const APValue &Value)
Definition: APValue.cpp:1040
llvm::SmallVector
Definition: LLVM.h:38
clang::APValue::getInt
APSInt & getInt()
Definition: APValue.h:415
clang::APValue::isLValueOnePastTheEnd
bool isLValueOnePastTheEnd() const
Definition: APValue.cpp:969
GetApproxValue
static double GetApproxValue(const llvm::APFloat &F)
Definition: APValue.cpp:620
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::QualType::getNonReferenceType
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:6831
clang::Type::isWideCharType
bool isWideCharType() const
Definition: Type.cpp:1971
clang::APValue::getFixedPoint
APFixedPoint & getFixedPoint()
Definition: APValue.h:437
clang::APValue::Struct
@ Struct
Definition: APValue.h:140
clang::APValue::setComplexFloat
void setComplexFloat(APFloat R, APFloat I)
Definition: APValue.h:604
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:737
llvm::DenseMapInfo< clang::APValue::LValueBase >::isEqual
static bool isEqual(const clang::APValue::LValueBase &LHS, const clang::APValue::LValueBase &RHS)
Definition: APValue.cpp:215
clang::cast
U cast(CodeGen::Address addr)
Definition: Address.h:174
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2930
clang::APValue::LV::LV
LV()
Definition: APValue.cpp:233
DeclCXX.h
memcpy
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Definition: __clang_cuda_device_functions.h:1549
clang::APValue::LValueBase::getOpaqueValue
void * getOpaqueValue() const
Definition: APValue.cpp:175
clang::APValue::ComplexFloat
@ ComplexFloat
Definition: APValue.h:136
clang::APValue::LV::~LV
~LV()
Definition: APValue.cpp:234
clang::APValue::needsCleanup
bool needsCleanup() const
Returns whether the object performed allocations.
Definition: APValue.cpp:429
clang::ComparisonCategoryType::First
@ First
clang::APValue::getArraySize
unsigned getArraySize() const
Definition: APValue.h:525
clang::Type::isVoidType
bool isVoidType() const
Definition: Type.h:7180
llvm::DenseMapInfo< clang::APValue::LValueBase >::getTombstoneKey
static clang::APValue::LValueBase getTombstoneKey()
Definition: APValue.cpp:195
clang::APValue::LValueBase::getDynamicAllocType
QualType getDynamicAllocType() const
Definition: APValue.cpp:122
clang::APValue::None
@ None
There is no such object (it's outside its lifetime).
Definition: APValue.h:129
clang::APValue::LValueBase::getDynamicAlloc
static LValueBase getDynamicAlloc(DynamicAllocLValue LV, QualType Type)
Definition: APValue.cpp:47
clang::PrintingPolicy
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
clang::QualType::stream
StreamedQualTypeHelper stream(const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Definition: Type.h:1144
clang::CXXRecordDecl::bases_end
base_class_iterator bases_end()
Definition: DeclCXX.h:606
clang::APValue::getMemberPointerDecl
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:1047
clang::LVComputationKind
Kinds of LV computation.
Definition: Linkage.h:29
clang::APValue::LV::hasPathPtr
bool hasPathPtr() const
Definition: APValue.cpp:247
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1565
getValue
static SVal getValue(SVal val, SValBuilder &svalBuilder)
Definition: ArrayBoundCheckerV2.cpp:276
clang::APValue::LValueBase::getType
QualType getType() const
Definition: APValue.cpp:63
Offset
unsigned Offset
Definition: Format.cpp:2717
clang::APValue::LV
Definition: APValue.cpp:221
clang::APValue::MemberPointerData::getPath
const PathElem * getPath() const
Definition: APValue.cpp:287
APSInt
llvm::APSInt APSInt
Definition: ByteCodeEmitter.cpp:19
llvm::DenseMapInfo< clang::APValue::LValueBase >::getHashValue
static unsigned getHashValue(const clang::APValue::LValueBase &Base)
Definition: APValue.cpp:210
clang::hash_value
llvm::hash_code hash_value(const clang::SanitizerMask &Arg)
Definition: Sanitizers.cpp:68
clang::TypeInfo
Definition: ASTContext.h:179
clang::Expr::skipRValueSubobjectAdjustments
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:81
llvm::MutableArrayRef
Definition: LLVM.h:35
clang::LinkageInfo::merge
void merge(LinkageInfo other)
Merge both linkage and visibility.
Definition: Visibility.h:132
clang::Type::isReferenceType
bool isReferenceType() const
Definition: Type.h:6895
V
#define V(N, I)
Definition: ASTContext.h:3237
clang::APValue::getComplexFloatReal
APFloat & getComplexFloatReal()
Definition: APValue.h:461
clang::APValue::MemberPointerData::getPath
PathElem * getPath()
Definition: APValue.cpp:286
Linkage.h
min
__DEVICE__ int min(int __a, int __b)
Definition: __clang_cuda_math.h:197
clang::LinkageInfo::internal
static LinkageInfo internal()
Definition: Visibility.h:70
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4816
clang::APValue::hasLValuePath
bool hasLValuePath() const
Definition: APValue.cpp:979
clang::TypeInfoLValue::getType
const Type * getType() const
Definition: APValue.h:51
clang::APValue::LValuePathSerializationHelper::LValuePathSerializationHelper
LValuePathSerializationHelper(ArrayRef< LValuePathEntry >, QualType)
Definition: APValue.cpp:157
clang::Stmt::printPretty
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
Definition: StmtPrinter.cpp:2737
clang::APValue::Union
@ Union
Definition: APValue.h:141
clang::Type::isAnyCharacterType
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1998
clang::APValue::LValueBase::getTypeInfo
static LValueBase getTypeInfo(TypeInfoLValue LV, QualType TypeInfo)
Definition: APValue.cpp:55
clang::VectorType
Represents a GCC generic vector type.
Definition: Type.h:3358
clang::ASTContext::getTargetNullPointerValue
uint64_t getTargetNullPointerValue(QualType QT) const
Get target-dependent integer value for null pointer which is used for constant folding.
Definition: ASTContext.cpp:12220
clang::MaterializeTemporaryExpr
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4513
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
clang::APValue::Array
@ Array
Definition: APValue.h:139
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:3012
clang::DeclaratorContext::Member
@ Member
clang::hash_value
llvm::hash_code hash_value(const APValue::LValueBase &Base)
Definition: APValue.cpp:202
clang::APValue::getStructNumBases
unsigned getStructNumBases() const
Definition: APValue.h:530
clang::APValue::getStructBase
APValue & getStructBase(unsigned i)
Definition: APValue.h:538
clang::APValue::LV::getPath
const LValuePathEntry * getPath() const
Definition: APValue.cpp:250
APValue.h
clang::Type::isChar8Type
bool isChar8Type() const
Definition: Type.cpp:1978
clang::RISCV::Policy
Policy
Definition: RISCVVIntrinsicUtils.h:96
clang::APValue::LV::getPath
LValuePathEntry * getPath()
Definition: APValue.cpp:249
clang::APValue::getComplexIntReal
APSInt & getComplexIntReal()
Definition: APValue.h:445
clang::CharUnits::One
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
clang::index::SymbolKind::Field
@ Field
uintptr_t
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c-base.h:140
clang::APValue::getLValueCallIndex
unsigned getLValueCallIndex() const
Definition: APValue.cpp:990
Type.h
Expr.h
llvm::SmallString
Definition: LLVM.h:37
bool
#define bool
Definition: stdbool.h:20
ASTContext.h
clang::APValue::getVectorElt
APValue & getVectorElt(unsigned I)
Definition: APValue.h:489
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:625
clang::LinkageInfo
Definition: Visibility.h:52
clang::SD_FullExpression
@ SD_FullExpression
Full-expression storage duration (for temporaries).
Definition: Specifiers.h:312
clang::APValue::getUnionField
const FieldDecl * getUnionField() const
Definition: APValue.h:555
setLValueUninit
MutableArrayRef< APValue::LValuePathEntry > setLValueUninit(APValue::LValueBase B, const CharUnits &O, unsigned Size, bool OnePastTheEnd, bool IsNullPtr)
clang::APValue::LValue
@ LValue
Definition: APValue.h:137
clang::CharUnits::Zero
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
clang::APValue::hasArrayFiller
bool hasArrayFiller() const
Definition: APValue.h:510
ExprCXX.h
Base
clang::APValue::LValueBase::isNull
bool isNull() const
Definition: APValue.cpp:179
clang::APValue::getArrayInitializedElt
APValue & getArrayInitializedElt(unsigned I)
Definition: APValue.h:502
clang::APValue::getAsString
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:936
clang::APValue::isInt
bool isInt() const
Definition: APValue.h:393
clang::format::hash_combine
static void hash_combine(std::size_t &seed, const T &v)
Definition: UnwrappedLineParser.cpp:781
clang::APValue::setLValue
void setLValue(LValueBase B, const CharUnits &O, NoLValuePath, bool IsNullPtr)
Definition: APValue.cpp:1005
CharUnits.h
clang::APValue::getLValueVersion
unsigned getLValueVersion() const
Definition: APValue.cpp:995
clang::APValue::Indeterminate
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
Definition: APValue.h:131
clang::APValue::AddrLabelDiff
@ AddrLabelDiff
Definition: APValue.h:143
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7453
clang::APValue::isUnion
bool isUnion() const
Definition: APValue.h:402
clang::APValue::getArrayFiller
APValue & getArrayFiller()
Definition: APValue.h:513
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
clang::APValue::swap
void swap(APValue &RHS)
Swaps the contents of this and the given APValue.
Definition: APValue.cpp:466
clang::APValue::setAddrLabelDiff
void setAddrLabelDiff(const AddrLabelExpr *LHSExpr, const AddrLabelExpr *RHSExpr)
Definition: APValue.h:617
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::APValue::LV::resizePath
void resizePath(unsigned Length)
Definition: APValue.cpp:236
clang::APValue::Profile
void Profile(llvm::FoldingSetNodeID &ID) const
profile this value.
Definition: APValue.cpp:477
clang::APValue::printPretty
void printPretty(raw_ostream &OS, const ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:691
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:701
TryPrintAsStringLiteral
static bool TryPrintAsStringLiteral(raw_ostream &Out, const PrintingPolicy &Policy, const ArrayType *ATy, ArrayRef< APValue > Inits)
Definition: APValue.cpp:628
clang::DynamicAllocLValue
Symbolic representation of a dynamic allocation.
Definition: APValue.h:65
clang::CharUnits::isZero
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
getCanonicalDecl
static const Decl * getCanonicalDecl(const Decl *D)
Definition: IndexingContext.cpp:297
clang::APValue::setVector
void setVector(const APValue *E, unsigned N)
Definition: APValue.h:592
clang::APValue::MemberPointerData
Definition: APValue.cpp:262
clang::Type::isIncompleteArrayType
bool isIncompleteArrayType() const
Definition: Type.h:6957
clang::ASTContext::getPrintingPolicy
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:713
clang::RecordDecl::fields
field_range fields() const
Definition: Decl.h:4209
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:802
clang::APValue::ComplexInt
@ ComplexInt
Definition: APValue.h:135
llvm::ArrayRef
Definition: LLVM.h:34
Value
Value
Definition: UninitializedValues.cpp:103
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::APValue::MemberPointerData::PathPtr
PathElem * PathPtr
Definition: APValue.cpp:268
clang::APValue::getLValueBase
const LValueBase getLValueBase() const
Definition: APValue.cpp:964
clang::APValue::isAbsent
bool isAbsent() const
Definition: APValue.h:389
clang::APValue::setInt
void setInt(APSInt I)
Definition: APValue.h:580
clang::LinkageInfo::getLinkage
Linkage getLinkage() const
Definition: Visibility.h:83
clang::APValue::getStructField
APValue & getStructField(unsigned i)
Definition: APValue.h:543
clang::APValue::getUnionValue
APValue & getUnionValue()
Definition: APValue.h:559
clang::APValue::getFloat
APFloat & getFloat()
Definition: APValue.h:429
clang::TypeInfoLValue
Symbolic representation of typeid(T) for some type T.
Definition: APValue.h:44
clang::ASTContext::MakeIntValue
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:2980
clang::APValue::Vector
@ Vector
Definition: APValue.h:138
clang::APValue::isNullPointer
bool isNullPointer() const
Definition: APValue.cpp:1000
clang::APValue::isMemberPointer
bool isMemberPointer() const
Definition: APValue.h:403
clang::APValue::getComplexIntImag
APSInt & getComplexIntImag()
Definition: APValue.h:453
clang::APValue::toIntegralConstant
bool toIntegralConstant(APSInt &Result, QualType SrcTy, const ASTContext &Ctx) const
Try to convert this value to an integral constant.
Definition: APValue.cpp:944
clang::QualType::getFromOpaquePtr
static QualType getFromOpaquePtr(const void *Ptr)
Definition: Type.h:784
clang::APValue::MemberPointerData::resizePath
void resizePath(unsigned Length)
Definition: APValue.cpp:274
clang::Type::isBooleanType
bool isBooleanType() const
Definition: Type.h:7296
clang::APValue::LValueBase::LValueBase
LValueBase()
Definition: APValue.h:152
clang::APValue::LV::PathPtr
LValuePathEntry * PathPtr
Definition: APValue.cpp:230
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::LinkageInfo::external
static LinkageInfo external()
Definition: Visibility.h:67
clang::Type::castAsArrayTypeUnsafe
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
Definition: Type.h:7462
clang::Builtin::ID
ID
Definition: Builtins.h:52
clang::APValue::getAddrLabelDiffRHS
const AddrLabelExpr * getAddrLabelDiffRHS() const
Definition: APValue.h:575
clang
Definition: CalledOnceCheck.h:17
hlsl::int64_t
long int64_t
Definition: hlsl_basic_types.h:26
clang::TypeInfoLValue::TypeInfoLValue
TypeInfoLValue()
Definition: APValue.h:48
llvm::DenseMapInfo< clang::APValue::LValueBase >::getEmptyKey
static clang::APValue::LValueBase getEmptyKey()
Definition: APValue.cpp:188
clang::APValue::LValueBase::Profile
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: APValue.cpp:127
clang::APValue::MemberPointerData::~MemberPointerData
~MemberPointerData()
Definition: APValue.cpp:272
clang::APValue::getComplexFloatImag
APFloat & getComplexFloatImag()
Definition: APValue.h:469
clang::APValue::Int
@ Int
Definition: APValue.h:132
clang::CXXRecordDecl::bases_begin
base_class_iterator bases_begin()
Definition: DeclCXX.h:604
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::APValue::BaseOrMemberType
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
clang::APValue::getVectorLength
unsigned getVectorLength() const
Definition: APValue.h:497
clang::APValue::MemberPointerData::hasPathPtr
bool hasPathPtr() const
Definition: APValue.cpp:284
unsigned
clang::APValue::LValueBase::Local
LocalState Local
Definition: APValue.h:195
clang::APValue::getMemberPointerPath
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:1061
llvm::PointerLikeTypeTraits
Definition: DeclGroup.h:139
clang::APValue::isLValue
bool isLValue() const
Definition: APValue.h:398
clang::APValue::NoLValuePath
Definition: APValue.h:249
clang::APValue::setFloat
void setFloat(APFloat F)
Definition: APValue.h:584
clang::APValue::isMemberPointerToDerivedMember
bool isMemberPointerToDerivedMember() const
Definition: APValue.cpp:1054
clang::APValue::MemberPointer
@ MemberPointer
Definition: APValue.h:142
clang::ASTContext::getTypeSizeInCharsIfKnown
Optional< CharUnits > getTypeSizeInCharsIfKnown(QualType Ty) const
Definition: ASTContext.h:2321
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
clang::QualType::print
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Definition: TypePrinter.cpp:2320
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
clang::LinkageComputer::getLVForDecl
LinkageInfo getLVForDecl(const NamedDecl *D, LVComputationKind computation)
getLVForDecl - Get the linkage and visibility for the given declaration.
Definition: Decl.cpp:1513
clang::APValue::APValue
APValue()
Definition: APValue.h:309
clang::APValue::LValuePathSerializationHelper::getType
QualType getType()
Definition: APValue.cpp:161
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:3033
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::APValue::getArrayInitializedElts
unsigned getArrayInitializedElts() const
Definition: APValue.h:521
clang::Type::isChar16Type
bool isChar16Type() const
Definition: Type.cpp:1984
clang::APValue::LValueBase::getVersion
unsigned getVersion() const
Definition: APValue.cpp:113
clang::APValue::LValuePathEntry
A non-discriminated union of a base, field, or array index.
Definition: APValue.h:208
GCCTypeClass::None
@ None
clang::AddrLabelExpr::getLabel
LabelDecl * getLabel() const
Definition: Expr.h:4332
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3983
clang::Type::isChar32Type
bool isChar32Type() const
Definition: Type.cpp:1990
clang::APValue::LValuePathEntry::Profile
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: APValue.cpp:153
clang::operator==
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
Definition: CallGraph.h:207
clang::CharUnits::getQuantity
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
clang::isASCII
LLVM_READNONE bool isASCII(char c)
Returns true if a byte is an ASCII character.
Definition: CharInfo.h:42
clang::APValue::getAddrLabelDiffLHS
const AddrLabelExpr * getAddrLabelDiffLHS() const
Definition: APValue.h:571
clang::APValue::Float
@ Float
Definition: APValue.h:133
clang::TypeInfoLValue::print
void print(llvm::raw_ostream &Out, const PrintingPolicy &Policy) const
Definition: APValue.cpp:30
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:274