Bug Summary

File:clang/lib/AST/APValue.cpp
Warning:line 249, column 32
Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name APValue.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-12/lib/clang/12.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST -I /build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/include -I /build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/build-llvm/include -I /build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-12/lib/clang/12.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2021-01-26-035717-31997-1 -x c++ /build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp
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"
23using namespace clang;
24
25/// The identity of a type_info object depends on the canonical unqualified
26/// type only.
27TypeInfoLValue::TypeInfoLValue(const Type *T)
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(
38 1 << llvm::PointerLikeTypeTraits<TypeInfoLValue>::NumLowBitsAvailable <=
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
47APValue::LValueBase APValue::LValueBase::getDynamicAlloc(DynamicAllocLValue LV,
48 QualType Type) {
49 LValueBase Base;
50 Base.Ptr = LV;
51 Base.DynamicAllocType = Type.getAsOpaquePtr();
52 return Base;
53}
54
55APValue::LValueBase APValue::LValueBase::getTypeInfo(TypeInfoLValue LV,
56 QualType TypeInfo) {
57 LValueBase Base;
58 Base.Ptr = LV;
59 Base.TypeInfoType = TypeInfo.getAsOpaquePtr();
60 return Base;
61}
62
63QualType APValue::LValueBase::getType() const {
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)) {
94 SmallVector<const Expr *, 2> CommaLHSs;
95 SmallVector<SubobjectAdjustment, 2> Adjustments;
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
108unsigned APValue::LValueBase::getCallIndex() const {
109 return (is<TypeInfoLValue>() || is<DynamicAllocLValue>()) ? 0
110 : Local.CallIndex;
111}
112
113unsigned APValue::LValueBase::getVersion() const {
114 return (is<TypeInfoLValue>() || is<DynamicAllocLValue>()) ? 0 : Local.Version;
115}
116
117QualType APValue::LValueBase::getTypeInfoType() const {
118 assert(is<TypeInfoLValue>() && "not a type_info lvalue")((is<TypeInfoLValue>() && "not a type_info lvalue"
) ? static_cast<void> (0) : __assert_fail ("is<TypeInfoLValue>() && \"not a type_info lvalue\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 118, __PRETTY_FUNCTION__));
119 return QualType::getFromOpaquePtr(TypeInfoType);
120}
121
122QualType APValue::LValueBase::getDynamicAllocType() const {
123 assert(is<DynamicAllocLValue>() && "not a dynamic allocation lvalue")((is<DynamicAllocLValue>() && "not a dynamic allocation lvalue"
) ? static_cast<void> (0) : __assert_fail ("is<DynamicAllocLValue>() && \"not a dynamic allocation lvalue\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 123, __PRETTY_FUNCTION__));
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 {
136bool operator==(const APValue::LValueBase &LHS,
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
147APValue::LValuePathEntry::LValuePathEntry(BaseOrMemberType BaseOrMember) {
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
157APValue::LValuePathSerializationHelper::LValuePathSerializationHelper(
158 ArrayRef<LValuePathEntry> Path, QualType ElemTy)
159 : ElemTy((const void *)ElemTy.getTypePtrOrNull()), Path(Path) {}
160
161QualType APValue::LValuePathSerializationHelper::getType() {
162 return QualType::getFromOpaquePtr(ElemTy);
163}
164
165namespace {
166 struct LVBase {
167 APValue::LValueBase Base;
168 CharUnits Offset;
169 unsigned PathLength;
170 bool IsNullPtr : 1;
171 bool IsOnePastTheEnd : 1;
172 };
173}
174
175void *APValue::LValueBase::getOpaqueValue() const {
176 return Ptr.getOpaqueValue();
177}
178
179bool APValue::LValueBase::isNull() const {
180 return Ptr.isNull();
181}
182
183APValue::LValueBase::operator bool () const {
184 return static_cast<bool>(Ptr);
185}
186
187clang::APValue::LValueBase
188llvm::DenseMapInfo<clang::APValue::LValueBase>::getEmptyKey() {
189 clang::APValue::LValueBase B;
190 B.Ptr = DenseMapInfo<const ValueDecl*>::getEmptyKey();
191 return B;
192}
193
194clang::APValue::LValueBase
195llvm::DenseMapInfo<clang::APValue::LValueBase>::getTombstoneKey() {
196 clang::APValue::LValueBase B;
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(
211 const clang::APValue::LValueBase &Base) {
212 return hash_value(Base);
213}
214
215bool llvm::DenseMapInfo<clang::APValue::LValueBase>::isEqual(
216 const clang::APValue::LValueBase &LHS,
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];
230 LValuePathEntry *PathPtr;
231 };
232
233 LV() { PathLength = (unsigned)-1; }
234 ~LV() { resizePath(0); }
235
236 void resizePath(unsigned Length) {
237 if (Length == PathLength)
11
←
Assuming 'Length' is not equal to field 'PathLength'
→
12
←
Taking false branch
→
238 return;
239 if (hasPathPtr())
13
←
Assuming the condition is true
→
14
←
Taking true branch
→
240 delete [] PathPtr;
15
←
Memory is released
→
241 PathLength = Length;
242 if (hasPathPtr())
16
←
Assuming the condition is false
→
17
←
Taking false branch
→
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; }
20
←
Assuming the condition is true
→
21
←
'?' condition is true
→
22
←
Use of memory after it is freed
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];
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
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()) {
5
←
Control jumps to 'case LValue:' at line 343
→
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();
337 setComplexInt(RHS.getComplexIntReal(), RHS.getComplexIntImag());
338 break;
339 case ComplexFloat:
340 MakeComplexFloat();
341 setComplexFloat(RHS.getComplexFloatReal(), RHS.getComplexFloatImag());
342 break;
343 case LValue:
344 MakeLValue();
345 if (RHS.hasLValuePath())
6
←
Taking true branch
→
346 setLValue(RHS.getLValueBase(), RHS.getLValueOffset(), RHS.getLValuePath(),
7
←
Calling 'APValue::setLValue'
→
347 RHS.isLValueOnePastTheEnd(), RHS.isNullPointer());
348 else
349 setLValue(RHS.getLValueBase(), RHS.getLValueOffset(), NoLValuePath(),
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)
355 getArrayInitializedElt(I) = RHS.getArrayInitializedElt(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(),
372 RHS.isMemberPointerToDerivedMember(),
373 RHS.getMemberPointerPath());
374 break;
375 case AddrLabelDiff:
376 MakeAddrLabelDiff();
377 setAddrLabelDiff(RHS.getAddrLabelDiffLHS(), RHS.getAddrLabelDiffRHS());
378 break;
379 }
380}
381
382APValue::APValue(APValue &&RHS) : Kind(RHS.Kind), Data(RHS.Data) {
383 RHS.Kind = None;
384}
385
386APValue &APValue::operator=(const APValue &RHS) {
1
Assuming RHS != *this
→
387 if (this != &RHS)
2
←
Assuming the condition is true
→
3
←
Taking true branch
→
388 *this = APValue(RHS);
4
←
Calling copy constructor for 'APValue'
→
389 return *this;
390}
391
392APValue &APValue::operator=(APValue &&RHS) {
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
429bool 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() ==((getComplexFloatImag().needsCleanup() == getComplexFloatReal
().needsCleanup() && "In _Complex float types, real and imaginary values always have the "
"same size.") ? static_cast<void> (0) : __assert_fail (
"getComplexFloatImag().needsCleanup() == getComplexFloatReal().needsCleanup() && \"In _Complex float types, real and imaginary values always have the \" \"same size.\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 450, __PRETTY_FUNCTION__))
448 getComplexFloatReal().needsCleanup() &&((getComplexFloatImag().needsCleanup() == getComplexFloatReal
().needsCleanup() && "In _Complex float types, real and imaginary values always have the "
"same size.") ? static_cast<void> (0) : __assert_fail (
"getComplexFloatImag().needsCleanup() == getComplexFloatReal().needsCleanup() && \"In _Complex float types, real and imaginary values always have the \" \"same size.\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 450, __PRETTY_FUNCTION__))
449 "In _Complex float types, real and imaginary values always have the "((getComplexFloatImag().needsCleanup() == getComplexFloatReal
().needsCleanup() && "In _Complex float types, real and imaginary values always have the "
"same size.") ? static_cast<void> (0) : __assert_fail (
"getComplexFloatImag().needsCleanup() == getComplexFloatReal().needsCleanup() && \"In _Complex float types, real and imaginary values always have the \" \"same size.\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 450, __PRETTY_FUNCTION__))
450 "same size.")((getComplexFloatImag().needsCleanup() == getComplexFloatReal
().needsCleanup() && "In _Complex float types, real and imaginary values always have the "
"same size.") ? static_cast<void> (0) : __assert_fail (
"getComplexFloatImag().needsCleanup() == getComplexFloatReal().needsCleanup() && \"In _Complex float types, real and imaginary values always have the \" \"same size.\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 450, __PRETTY_FUNCTION__));
451 return getComplexFloatReal().needsCleanup();
452 case ComplexInt:
453 assert(getComplexIntImag().needsCleanup() ==((getComplexIntImag().needsCleanup() == getComplexIntReal().needsCleanup
() && "In _Complex int types, real and imaginary values must have the "
"same size.") ? static_cast<void> (0) : __assert_fail (
"getComplexIntImag().needsCleanup() == getComplexIntReal().needsCleanup() && \"In _Complex int types, real and imaginary values must have the \" \"same size.\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 456, __PRETTY_FUNCTION__))
454 getComplexIntReal().needsCleanup() &&((getComplexIntImag().needsCleanup() == getComplexIntReal().needsCleanup
() && "In _Complex int types, real and imaginary values must have the "
"same size.") ? static_cast<void> (0) : __assert_fail (
"getComplexIntImag().needsCleanup() == getComplexIntReal().needsCleanup() && \"In _Complex int types, real and imaginary values must have the \" \"same size.\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 456, __PRETTY_FUNCTION__))
455 "In _Complex int types, real and imaginary values must have the "((getComplexIntImag().needsCleanup() == getComplexIntReal().needsCleanup
() && "In _Complex int types, real and imaginary values must have the "
"same size.") ? static_cast<void> (0) : __assert_fail (
"getComplexIntImag().needsCleanup() == getComplexIntReal().needsCleanup() && \"In _Complex int types, real and imaginary values must have the \" \"same size.\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 456, __PRETTY_FUNCTION__))
456 "same size.")((getComplexIntImag().needsCleanup() == getComplexIntReal().needsCleanup
() && "In _Complex int types, real and imaginary values must have the "
"same size.") ? static_cast<void> (0) : __assert_fail (
"getComplexIntImag().needsCleanup() == getComplexIntReal().needsCleanup() && \"In _Complex int types, real and imaginary values must have the \" \"same size.\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 456, __PRETTY_FUNCTION__));
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!")::llvm::llvm_unreachable_internal("Unknown APValue kind!", "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 463);
464}
465
466void 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.
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);
508 getUnionValue().Profile(ID);
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;
524 (hasArrayFiller() ? getArrayFiller()
525 : getArrayInitializedElt(getArrayInitializedElts() - 1))
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())((NumFillers == getArraySize()) ? static_cast<void> (0)
: __assert_fail ("NumFillers == getArraySize()", "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 537, __PRETTY_FUNCTION__));
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)
562 getArrayInitializedElt(N - 1).Profile(ID);
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:
580 profileIntValue(ID, getFixedPoint().getValue());
581 return;
582
583 case ComplexFloat:
584 profileIntValue(ID, getComplexFloatReal().bitcastToAPInt());
585 profileIntValue(ID, getComplexFloatImag().bitcastToAPInt());
586 return;
587
588 case ComplexInt:
589 profileIntValue(ID, getComplexIntReal());
590 profileIntValue(ID, getComplexIntImag());
591 return;
592
593 case LValue:
594 getLValueBase().Profile(ID);
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!")::llvm::llvm_unreachable_internal("Unknown APValue kind!", "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 617);
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
628void APValue::printPretty(raw_ostream &Out, const ASTContext &Ctx,
629 QualType Ty) const {
630 printPretty(Out, Ctx.getPrintingPolicy(), Ty, &Ctx);
631}
632
633void APValue::printPretty(raw_ostream &Out, const PrintingPolicy &Policy,
634 QualType Ty, const ASTContext *Ctx) const {
635 // There are no objects of type 'void', but values of this type can be
636 // returned from functions.
637 if (Ty->isVoidType()) {
638 Out << "void()";
639 return;
640 }
641
642 switch (getKind()) {
643 case APValue::None:
644 Out << "<out of lifetime>";
645 return;
646 case APValue::Indeterminate:
647 Out << "<uninitialized>";
648 return;
649 case APValue::Int:
650 if (Ty->isBooleanType())
651 Out << (getInt().getBoolValue() ? "true" : "false");
652 else
653 Out << getInt();
654 return;
655 case APValue::Float:
656 Out << GetApproxValue(getFloat());
657 return;
658 case APValue::FixedPoint:
659 Out << getFixedPoint();
660 return;
661 case APValue::Vector: {
662 Out << '{';
663 QualType ElemTy = Ty->castAs<VectorType>()->getElementType();
664 getVectorElt(0).printPretty(Out, Policy, ElemTy, Ctx);
665 for (unsigned i = 1; i != getVectorLength(); ++i) {
666 Out << ", ";
667 getVectorElt(i).printPretty(Out, Policy, ElemTy, Ctx);
668 }
669 Out << '}';
670 return;
671 }
672 case APValue::ComplexInt:
673 Out << getComplexIntReal() << "+" << getComplexIntImag() << "i";
674 return;
675 case APValue::ComplexFloat:
676 Out << GetApproxValue(getComplexFloatReal()) << "+"
677 << GetApproxValue(getComplexFloatImag()) << "i";
678 return;
679 case APValue::LValue: {
680 bool IsReference = Ty->isReferenceType();
681 QualType InnerTy
682 = IsReference ? Ty.getNonReferenceType() : Ty->getPointeeType();
683 if (InnerTy.isNull())
684 InnerTy = Ty;
685
686 LValueBase Base = getLValueBase();
687 if (!Base) {
688 if (isNullPointer()) {
689 Out << (Policy.Nullptr ? "nullptr" : "0");
690 } else if (IsReference) {
691 Out << "*(" << InnerTy.stream(Policy) << "*)"
692 << getLValueOffset().getQuantity();
693 } else {
694 Out << "(" << Ty.stream(Policy) << ")"
695 << getLValueOffset().getQuantity();
696 }
697 return;
698 }
699
700 if (!hasLValuePath()) {
701 // No lvalue path: just print the offset.
702 CharUnits O = getLValueOffset();
703 CharUnits S = Ctx ? Ctx->getTypeSizeInChars(InnerTy) : CharUnits::Zero();
704 if (!O.isZero()) {
705 if (IsReference)
706 Out << "*(";
707 if (S.isZero() || O % S) {
708 Out << "(char*)";
709 S = CharUnits::One();
710 }
711 Out << '&';
712 } else if (!IsReference) {
713 Out << '&';
714 }
715
716 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
717 Out << *VD;
718 else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
719 TI.print(Out, Policy);
720 } else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
721 Out << "{*new "
722 << Base.getDynamicAllocType().stream(Policy) << "#"
723 << DA.getIndex() << "}";
724 } else {
725 assert(Base.get<const Expr *>() != nullptr &&((Base.get<const Expr *>() != nullptr && "Expecting non-null Expr"
) ? static_cast<void> (0) : __assert_fail ("Base.get<const Expr *>() != nullptr && \"Expecting non-null Expr\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 726, __PRETTY_FUNCTION__))
726 "Expecting non-null Expr")((Base.get<const Expr *>() != nullptr && "Expecting non-null Expr"
) ? static_cast<void> (0) : __assert_fail ("Base.get<const Expr *>() != nullptr && \"Expecting non-null Expr\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 726, __PRETTY_FUNCTION__));
727 Base.get<const Expr*>()->printPretty(Out, nullptr, Policy);
728 }
729
730 if (!O.isZero()) {
731 Out << " + " << (O / S);
732 if (IsReference)
733 Out << ')';
734 }
735 return;
736 }
737
738 // We have an lvalue path. Print it out nicely.
739 if (!IsReference)
740 Out << '&';
741 else if (isLValueOnePastTheEnd())
742 Out << "*(&";
743
744 QualType ElemTy = Base.getType();
745 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
746 Out << *VD;
747 } else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
748 TI.print(Out, Policy);
749 } else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
750 Out << "{*new " << Base.getDynamicAllocType().stream(Policy) << "#"
751 << DA.getIndex() << "}";
752 } else {
753 const Expr *E = Base.get<const Expr*>();
754 assert(E != nullptr && "Expecting non-null Expr")((E != nullptr && "Expecting non-null Expr") ? static_cast
<void> (0) : __assert_fail ("E != nullptr && \"Expecting non-null Expr\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 754, __PRETTY_FUNCTION__));
755 E->printPretty(Out, nullptr, Policy);
756 }
757
758 ArrayRef<LValuePathEntry> Path = getLValuePath();
759 const CXXRecordDecl *CastToBase = nullptr;
760 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
761 if (ElemTy->isRecordType()) {
762 // The lvalue refers to a class type, so the next path entry is a base
763 // or member.
764 const Decl *BaseOrMember = Path[I].getAsBaseOrMember().getPointer();
765 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
766 CastToBase = RD;
767 // Leave ElemTy referring to the most-derived class. The actual type
768 // doesn't matter except for array types.
769 } else {
770 const ValueDecl *VD = cast<ValueDecl>(BaseOrMember);
771 Out << ".";
772 if (CastToBase)
773 Out << *CastToBase << "::";
774 Out << *VD;
775 ElemTy = VD->getType();
776 }
777 } else {
778 // The lvalue must refer to an array.
779 Out << '[' << Path[I].getAsArrayIndex() << ']';
780 ElemTy = ElemTy->castAsArrayTypeUnsafe()->getElementType();
781 }
782 }
783
784 // Handle formatting of one-past-the-end lvalues.
785 if (isLValueOnePastTheEnd()) {
786 // FIXME: If CastToBase is non-0, we should prefix the output with
787 // "(CastToBase*)".
788 Out << " + 1";
789 if (IsReference)
790 Out << ')';
791 }
792 return;
793 }
794 case APValue::Array: {
795 const ArrayType *AT = Ty->castAsArrayTypeUnsafe();
796 QualType ElemTy = AT->getElementType();
797 Out << '{';
798 if (unsigned N = getArrayInitializedElts()) {
799 getArrayInitializedElt(0).printPretty(Out, Policy, ElemTy, Ctx);
800 for (unsigned I = 1; I != N; ++I) {
801 Out << ", ";
802 if (I == 10) {
803 // Avoid printing out the entire contents of large arrays.
804 Out << "...";
805 break;
806 }
807 getArrayInitializedElt(I).printPretty(Out, Policy, ElemTy, Ctx);
808 }
809 }
810 Out << '}';
811 return;
812 }
813 case APValue::Struct: {
814 Out << '{';
815 const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
816 bool First = true;
817 if (unsigned N = getStructNumBases()) {
818 const CXXRecordDecl *CD = cast<CXXRecordDecl>(RD);
819 CXXRecordDecl::base_class_const_iterator BI = CD->bases_begin();
820 for (unsigned I = 0; I != N; ++I, ++BI) {
821 assert(BI != CD->bases_end())((BI != CD->bases_end()) ? static_cast<void> (0) : __assert_fail
("BI != CD->bases_end()", "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 821, __PRETTY_FUNCTION__));
822 if (!First)
823 Out << ", ";
824 getStructBase(I).printPretty(Out, Policy, BI->getType(), Ctx);
825 First = false;
826 }
827 }
828 for (const auto *FI : RD->fields()) {
829 if (!First)
830 Out << ", ";
831 if (FI->isUnnamedBitfield()) continue;
832 getStructField(FI->getFieldIndex()).
833 printPretty(Out, Policy, FI->getType(), Ctx);
834 First = false;
835 }
836 Out << '}';
837 return;
838 }
839 case APValue::Union:
840 Out << '{';
841 if (const FieldDecl *FD = getUnionField()) {
842 Out << "." << *FD << " = ";
843 getUnionValue().printPretty(Out, Policy, FD->getType(), Ctx);
844 }
845 Out << '}';
846 return;
847 case APValue::MemberPointer:
848 // FIXME: This is not enough to unambiguously identify the member in a
849 // multiple-inheritance scenario.
850 if (const ValueDecl *VD = getMemberPointerDecl()) {
851 Out << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD;
852 return;
853 }
854 Out << "0";
855 return;
856 case APValue::AddrLabelDiff:
857 Out << "&&" << getAddrLabelDiffLHS()->getLabel()->getName();
858 Out << " - ";
859 Out << "&&" << getAddrLabelDiffRHS()->getLabel()->getName();
860 return;
861 }
862 llvm_unreachable("Unknown APValue kind!")::llvm::llvm_unreachable_internal("Unknown APValue kind!", "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 862);
863}
864
865std::string APValue::getAsString(const ASTContext &Ctx, QualType Ty) const {
866 std::string Result;
867 llvm::raw_string_ostream Out(Result);
868 printPretty(Out, Ctx, Ty);
869 Out.flush();
870 return Result;
871}
872
873bool APValue::toIntegralConstant(APSInt &Result, QualType SrcTy,
874 const ASTContext &Ctx) const {
875 if (isInt()) {
876 Result = getInt();
877 return true;
878 }
879
880 if (isLValue() && isNullPointer()) {
881 Result = Ctx.MakeIntValue(Ctx.getTargetNullPointerValue(SrcTy), SrcTy);
882 return true;
883 }
884
885 if (isLValue() && !getLValueBase()) {
886 Result = Ctx.MakeIntValue(getLValueOffset().getQuantity(), SrcTy);
887 return true;
888 }
889
890 return false;
891}
892
893const APValue::LValueBase APValue::getLValueBase() const {
894 assert(isLValue() && "Invalid accessor")((isLValue() && "Invalid accessor") ? static_cast<
void> (0) : __assert_fail ("isLValue() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 894, __PRETTY_FUNCTION__));
895 return ((const LV *)(const void *)&Data)->Base;
896}
897
898bool APValue::isLValueOnePastTheEnd() const {
899 assert(isLValue() && "Invalid accessor")((isLValue() && "Invalid accessor") ? static_cast<
void> (0) : __assert_fail ("isLValue() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 899, __PRETTY_FUNCTION__));
900 return ((const LV *)(const void *)&Data)->IsOnePastTheEnd;
901}
902
903CharUnits &APValue::getLValueOffset() {
904 assert(isLValue() && "Invalid accessor")((isLValue() && "Invalid accessor") ? static_cast<
void> (0) : __assert_fail ("isLValue() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 904, __PRETTY_FUNCTION__));
905 return ((LV *)(void *)&Data)->Offset;
906}
907
908bool APValue::hasLValuePath() const {
909 assert(isLValue() && "Invalid accessor")((isLValue() && "Invalid accessor") ? static_cast<
void> (0) : __assert_fail ("isLValue() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 909, __PRETTY_FUNCTION__));
910 return ((const LV *)(const char *)&Data)->hasPath();
911}
912
913ArrayRef<APValue::LValuePathEntry> APValue::getLValuePath() const {
914 assert(isLValue() && hasLValuePath() && "Invalid accessor")((isLValue() && hasLValuePath() && "Invalid accessor"
) ? static_cast<void> (0) : __assert_fail ("isLValue() && hasLValuePath() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 914, __PRETTY_FUNCTION__));
915 const LV &LVal = *((const LV *)(const char *)&Data);
916 return llvm::makeArrayRef(LVal.getPath(), LVal.PathLength);
917}
918
919unsigned APValue::getLValueCallIndex() const {
920 assert(isLValue() && "Invalid accessor")((isLValue() && "Invalid accessor") ? static_cast<
void> (0) : __assert_fail ("isLValue() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 920, __PRETTY_FUNCTION__));
921 return ((const LV *)(const char *)&Data)->Base.getCallIndex();
922}
923
924unsigned APValue::getLValueVersion() const {
925 assert(isLValue() && "Invalid accessor")((isLValue() && "Invalid accessor") ? static_cast<
void> (0) : __assert_fail ("isLValue() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 925, __PRETTY_FUNCTION__));
926 return ((const LV *)(const char *)&Data)->Base.getVersion();
927}
928
929bool APValue::isNullPointer() const {
930 assert(isLValue() && "Invalid usage")((isLValue() && "Invalid usage") ? static_cast<void
> (0) : __assert_fail ("isLValue() && \"Invalid usage\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 930, __PRETTY_FUNCTION__));
931 return ((const LV *)(const char *)&Data)->IsNullPtr;
932}
933
934void APValue::setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
935 bool IsNullPtr) {
936 assert(isLValue() && "Invalid accessor")((isLValue() && "Invalid accessor") ? static_cast<
void> (0) : __assert_fail ("isLValue() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 936, __PRETTY_FUNCTION__));
937 LV &LVal = *((LV *)(char *)&Data);
938 LVal.Base = B;
939 LVal.IsOnePastTheEnd = false;
940 LVal.Offset = O;
941 LVal.resizePath((unsigned)-1);
942 LVal.IsNullPtr = IsNullPtr;
943}
944
945MutableArrayRef<APValue::LValuePathEntry>
946APValue::setLValueUninit(LValueBase B, const CharUnits &O, unsigned Size,
947 bool IsOnePastTheEnd, bool IsNullPtr) {
948 assert(isLValue() && "Invalid accessor")((isLValue() && "Invalid accessor") ? static_cast<
void> (0) : __assert_fail ("isLValue() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 948, __PRETTY_FUNCTION__));
9
←
'?' condition is true
→
949 LV &LVal = *((LV *)(char *)&Data);
950 LVal.Base = B;
951 LVal.IsOnePastTheEnd = IsOnePastTheEnd;
952 LVal.Offset = O;
953 LVal.IsNullPtr = IsNullPtr;
954 LVal.resizePath(Size);
10
←
Calling 'LV::resizePath'
→
18
←
Returning; memory was released
→
955 return {LVal.getPath(), Size};
19
←
Calling 'LV::getPath'
→
956}
957
958void APValue::setLValue(LValueBase B, const CharUnits &O,
959 ArrayRef<LValuePathEntry> Path, bool IsOnePastTheEnd,
960 bool IsNullPtr) {
961 MutableArrayRef<APValue::LValuePathEntry> InternalPath =
962 setLValueUninit(B, O, Path.size(), IsOnePastTheEnd, IsNullPtr);
8
←
Calling 'APValue::setLValueUninit'
→
963 if (Path.size()) {
964 memcpy(InternalPath.data(), Path.data(),
965 Path.size() * sizeof(LValuePathEntry));
966 }
967}
968
969void APValue::setUnion(const FieldDecl *Field, const APValue &Value) {
970 assert(isUnion() && "Invalid accessor")((isUnion() && "Invalid accessor") ? static_cast<void
> (0) : __assert_fail ("isUnion() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 970, __PRETTY_FUNCTION__));
971 ((UnionData *)(char *)&Data)->Field =
972 Field ? Field->getCanonicalDecl() : nullptr;
973 *((UnionData *)(char *)&Data)->Value = Value;
974}
975
976const ValueDecl *APValue::getMemberPointerDecl() const {
977 assert(isMemberPointer() && "Invalid accessor")((isMemberPointer() && "Invalid accessor") ? static_cast
<void> (0) : __assert_fail ("isMemberPointer() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 977, __PRETTY_FUNCTION__));
978 const MemberPointerData &MPD =
979 *((const MemberPointerData *)(const char *)&Data);
980 return MPD.MemberAndIsDerivedMember.getPointer();
981}
982
983bool APValue::isMemberPointerToDerivedMember() const {
984 assert(isMemberPointer() && "Invalid accessor")((isMemberPointer() && "Invalid accessor") ? static_cast
<void> (0) : __assert_fail ("isMemberPointer() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 984, __PRETTY_FUNCTION__));
985 const MemberPointerData &MPD =
986 *((const MemberPointerData *)(const char *)&Data);
987 return MPD.MemberAndIsDerivedMember.getInt();
988}
989
990ArrayRef<const CXXRecordDecl*> APValue::getMemberPointerPath() const {
991 assert(isMemberPointer() && "Invalid accessor")((isMemberPointer() && "Invalid accessor") ? static_cast
<void> (0) : __assert_fail ("isMemberPointer() && \"Invalid accessor\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 991, __PRETTY_FUNCTION__));
992 const MemberPointerData &MPD =
993 *((const MemberPointerData *)(const char *)&Data);
994 return llvm::makeArrayRef(MPD.getPath(), MPD.PathLength);
995}
996
997void APValue::MakeLValue() {
998 assert(isAbsent() && "Bad state change")((isAbsent() && "Bad state change") ? static_cast<
void> (0) : __assert_fail ("isAbsent() && \"Bad state change\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 998, __PRETTY_FUNCTION__));
999 static_assert(sizeof(LV) <= DataSize, "LV too big");
1000 new ((void *)(char *)&Data) LV();
1001 Kind = LValue;
1002}
1003
1004void APValue::MakeArray(unsigned InitElts, unsigned Size) {
1005 assert(isAbsent() && "Bad state change")((isAbsent() && "Bad state change") ? static_cast<
void> (0) : __assert_fail ("isAbsent() && \"Bad state change\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 1005, __PRETTY_FUNCTION__));
1006 new ((void *)(char *)&Data) Arr(InitElts, Size);
1007 Kind = Array;
1008}
1009
1010MutableArrayRef<APValue::LValuePathEntry>
1011setLValueUninit(APValue::LValueBase B, const CharUnits &O, unsigned Size,
1012 bool OnePastTheEnd, bool IsNullPtr);
1013
1014MutableArrayRef<const CXXRecordDecl *>
1015APValue::setMemberPointerUninit(const ValueDecl *Member, bool IsDerivedMember,
1016 unsigned Size) {
1017 assert(isAbsent() && "Bad state change")((isAbsent() && "Bad state change") ? static_cast<
void> (0) : __assert_fail ("isAbsent() && \"Bad state change\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 1017, __PRETTY_FUNCTION__));
1018 MemberPointerData *MPD = new ((void *)(char *)&Data) MemberPointerData;
1019 Kind = MemberPointer;
1020 MPD->MemberAndIsDerivedMember.setPointer(
1021 Member ? cast<ValueDecl>(Member->getCanonicalDecl()) : nullptr);
1022 MPD->MemberAndIsDerivedMember.setInt(IsDerivedMember);
1023 MPD->resizePath(Size);
1024 return {MPD->getPath(), MPD->PathLength};
1025}
1026
1027void APValue::MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
1028 ArrayRef<const CXXRecordDecl *> Path) {
1029 MutableArrayRef<const CXXRecordDecl *> InternalPath =
1030 setMemberPointerUninit(Member, IsDerivedMember, Path.size());
1031 for (unsigned I = 0; I != Path.size(); ++I)
1032 InternalPath[I] = Path[I]->getCanonicalDecl();
1033}
1034
1035LinkageInfo LinkageComputer::getLVForValue(const APValue &V,
1036 LVComputationKind computation) {
1037 LinkageInfo LV = LinkageInfo::external();
1038
1039 auto MergeLV = [&](LinkageInfo MergeLV) {
1040 LV.merge(MergeLV);
1041 return LV.getLinkage() == InternalLinkage;
1042 };
1043 auto Merge = [&](const APValue &V) {
1044 return MergeLV(getLVForValue(V, computation));
1045 };
1046
1047 switch (V.getKind()) {
1048 case APValue::None:
1049 case APValue::Indeterminate:
1050 case APValue::Int:
1051 case APValue::Float:
1052 case APValue::FixedPoint:
1053 case APValue::ComplexInt:
1054 case APValue::ComplexFloat:
1055 case APValue::Vector:
1056 break;
1057
1058 case APValue::AddrLabelDiff:
1059 // Even for an inline function, it's not reasonable to treat a difference
1060 // between the addresses of labels as an external value.
1061 return LinkageInfo::internal();
1062
1063 case APValue::Struct: {
1064 for (unsigned I = 0, N = V.getStructNumBases(); I != N; ++I)
1065 if (Merge(V.getStructBase(I)))
1066 break;
1067 for (unsigned I = 0, N = V.getStructNumFields(); I != N; ++I)
1068 if (Merge(V.getStructField(I)))
1069 break;
1070 break;
1071 }
1072
1073 case APValue::Union:
1074 if (V.getUnionField())
1075 Merge(V.getUnionValue());
1076 break;
1077
1078 case APValue::Array: {
1079 for (unsigned I = 0, N = V.getArrayInitializedElts(); I != N; ++I)
1080 if (Merge(V.getArrayInitializedElt(I)))
1081 break;
1082 if (V.hasArrayFiller())
1083 Merge(V.getArrayFiller());
1084 break;
1085 }
1086
1087 case APValue::LValue: {
1088 if (!V.getLValueBase()) {
1089 // Null or absolute address: this is external.
1090 } else if (const auto *VD =
1091 V.getLValueBase().dyn_cast<const ValueDecl *>()) {
1092 if (VD && MergeLV(getLVForDecl(VD, computation)))
1093 break;
1094 } else if (const auto TI = V.getLValueBase().dyn_cast<TypeInfoLValue>()) {
1095 if (MergeLV(getLVForType(*TI.getType(), computation)))
1096 break;
1097 } else if (const Expr *E = V.getLValueBase().dyn_cast<const Expr *>()) {
1098 // Almost all expression bases are internal. The exception is
1099 // lifetime-extended temporaries.
1100 // FIXME: These should be modeled as having the
1101 // LifetimeExtendedTemporaryDecl itself as the base.
1102 // FIXME: If we permit Objective-C object literals in template arguments,
1103 // they should not imply internal linkage.
1104 auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E);
1105 if (!MTE || MTE->getStorageDuration() == SD_FullExpression)
1106 return LinkageInfo::internal();
1107 if (MergeLV(getLVForDecl(MTE->getExtendingDecl(), computation)))
1108 break;
1109 } else {
1110 assert(V.getLValueBase().is<DynamicAllocLValue>() &&((V.getLValueBase().is<DynamicAllocLValue>() &&
"unexpected LValueBase kind") ? static_cast<void> (0) :
__assert_fail ("V.getLValueBase().is<DynamicAllocLValue>() && \"unexpected LValueBase kind\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 1111, __PRETTY_FUNCTION__))
1111 "unexpected LValueBase kind")((V.getLValueBase().is<DynamicAllocLValue>() &&
"unexpected LValueBase kind") ? static_cast<void> (0) :
__assert_fail ("V.getLValueBase().is<DynamicAllocLValue>() && \"unexpected LValueBase kind\""
, "/build/llvm-toolchain-snapshot-12~++20210125100614+2cdb34efdac5/clang/lib/AST/APValue.cpp"
, 1111, __PRETTY_FUNCTION__));
1112 return LinkageInfo::internal();
1113 }
1114 // The lvalue path doesn't matter: pointers to all subobjects always have
1115 // the same visibility as pointers to the complete object.
1116 break;
1117 }
1118
1119 case APValue::MemberPointer:
1120 if (const NamedDecl *D = V.getMemberPointerDecl())
1121 MergeLV(getLVForDecl(D, computation));
1122 // Note that we could have a base-to-derived conversion here to a member of
1123 // a derived class with less linkage/visibility. That's covered by the
1124 // linkage and visibility of the value's type.
1125 break;
1126 }
1127
1128 return LV;
1129}