clang 19.0.0git
RecordOps.cpp
Go to the documentation of this file.
1//===-- RecordOps.cpp -------------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Operations on records (structs, classes, and unions).
10//
11//===----------------------------------------------------------------------===//
12
14
15#define DEBUG_TYPE "dataflow"
16
17namespace clang::dataflow {
18
19static void copyField(const ValueDecl &Field, StorageLocation *SrcFieldLoc,
20 StorageLocation *DstFieldLoc, RecordStorageLocation &Dst,
22 assert(Field.getType()->isReferenceType() ||
23 (SrcFieldLoc != nullptr && DstFieldLoc != nullptr));
24
25 if (Field.getType()->isRecordType()) {
26 copyRecord(cast<RecordStorageLocation>(*SrcFieldLoc),
27 cast<RecordStorageLocation>(*DstFieldLoc), Env);
28 } else if (Field.getType()->isReferenceType()) {
29 Dst.setChild(Field, SrcFieldLoc);
30 } else {
31 if (Value *Val = Env.getValue(*SrcFieldLoc))
32 Env.setValue(*DstFieldLoc, *Val);
33 else
34 Env.clearValue(*DstFieldLoc);
35 }
36}
37
38static void copySyntheticField(QualType FieldType, StorageLocation &SrcFieldLoc,
39 StorageLocation &DstFieldLoc, Environment &Env) {
40 if (FieldType->isRecordType()) {
41 copyRecord(cast<RecordStorageLocation>(SrcFieldLoc),
42 cast<RecordStorageLocation>(DstFieldLoc), Env);
43 } else {
44 if (Value *Val = Env.getValue(SrcFieldLoc))
45 Env.setValue(DstFieldLoc, *Val);
46 else
47 Env.clearValue(DstFieldLoc);
48 }
49}
50
53 auto SrcType = Src.getType().getCanonicalType().getUnqualifiedType();
54 auto DstType = Dst.getType().getCanonicalType().getUnqualifiedType();
55
56 auto SrcDecl = SrcType->getAsCXXRecordDecl();
57 auto DstDecl = DstType->getAsCXXRecordDecl();
58
59 [[maybe_unused]] bool compatibleTypes =
60 SrcType == DstType ||
61 (SrcDecl != nullptr && DstDecl != nullptr &&
62 (SrcDecl->isDerivedFrom(DstDecl) || DstDecl->isDerivedFrom(SrcDecl)));
63
64 LLVM_DEBUG({
65 if (!compatibleTypes) {
66 llvm::dbgs() << "Source type " << Src.getType() << "\n";
67 llvm::dbgs() << "Destination type " << Dst.getType() << "\n";
68 }
69 });
70 assert(compatibleTypes);
71
72 if (SrcType == DstType || (SrcDecl != nullptr && DstDecl != nullptr &&
73 SrcDecl->isDerivedFrom(DstDecl))) {
74 for (auto [Field, DstFieldLoc] : Dst.children())
75 copyField(*Field, Src.getChild(*Field), DstFieldLoc, Dst, Env);
76 for (const auto &[Name, DstFieldLoc] : Dst.synthetic_fields())
77 copySyntheticField(DstFieldLoc->getType(), Src.getSyntheticField(Name),
78 *DstFieldLoc, Env);
79 } else {
80 for (auto [Field, SrcFieldLoc] : Src.children())
81 copyField(*Field, SrcFieldLoc, Dst.getChild(*Field), Dst, Env);
82 for (const auto &[Name, SrcFieldLoc] : Src.synthetic_fields())
83 copySyntheticField(SrcFieldLoc->getType(), *SrcFieldLoc,
84 Dst.getSyntheticField(Name), Env);
85 }
86}
87
88bool recordsEqual(const RecordStorageLocation &Loc1, const Environment &Env1,
89 const RecordStorageLocation &Loc2, const Environment &Env2) {
90 LLVM_DEBUG({
93 llvm::dbgs() << "Loc1 type " << Loc1.getType() << "\n";
94 llvm::dbgs() << "Loc2 type " << Loc2.getType() << "\n";
95 }
96 });
99
100 for (auto [Field, FieldLoc1] : Loc1.children()) {
101 StorageLocation *FieldLoc2 = Loc2.getChild(*Field);
102
103 assert(Field->getType()->isReferenceType() ||
104 (FieldLoc1 != nullptr && FieldLoc2 != nullptr));
105
106 if (Field->getType()->isRecordType()) {
107 if (!recordsEqual(cast<RecordStorageLocation>(*FieldLoc1), Env1,
108 cast<RecordStorageLocation>(*FieldLoc2), Env2))
109 return false;
110 } else if (Field->getType()->isReferenceType()) {
111 if (FieldLoc1 != FieldLoc2)
112 return false;
113 } else if (Env1.getValue(*FieldLoc1) != Env2.getValue(*FieldLoc2)) {
114 return false;
115 }
116 }
117
118 for (const auto &[Name, SynthFieldLoc1] : Loc1.synthetic_fields()) {
119 if (SynthFieldLoc1->getType()->isRecordType()) {
120 if (!recordsEqual(
121 *cast<RecordStorageLocation>(SynthFieldLoc1), Env1,
122 cast<RecordStorageLocation>(Loc2.getSyntheticField(Name)), Env2))
123 return false;
124 } else if (Env1.getValue(*SynthFieldLoc1) !=
125 Env2.getValue(Loc2.getSyntheticField(Name))) {
126 return false;
127 }
128 }
129
130 return true;
131}
132
133} // namespace clang::dataflow
const Environment & Env
Definition: HTMLLogger.cpp:148
A (possibly-)qualified type.
Definition: Type.h:942
QualType getCanonicalType() const
Definition: Type.h:7796
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:7838
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1881
bool isRecordType() const
Definition: Type.h:8093
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:706
Holds the state of the program (store and heap) at a given program point.
void clearValue(const StorageLocation &Loc)
Clears any association between Loc and a value in the environment.
Value * getValue(const StorageLocation &Loc) const
Returns the value assigned to Loc in the environment or null if Loc isn't assigned a value in the env...
void setValue(const StorageLocation &Loc, Value &Val)
Assigns Val as the value of Loc in the environment.
A storage location for a record (struct, class, or union).
llvm::iterator_range< SyntheticFieldMap::const_iterator > synthetic_fields() const
StorageLocation * getChild(const ValueDecl &D) const
Returns the child storage location for D.
void setChild(const ValueDecl &D, StorageLocation *Loc)
Changes the child storage location for a field D of reference type.
StorageLocation & getSyntheticField(llvm::StringRef Name) const
Returns the storage location for the synthetic field Name.
llvm::iterator_range< FieldToLoc::const_iterator > children() const
Base class for elements of the local variable store and of the heap.
Base class for all values computed by abstract interpretation.
Definition: Value.h:33
Dataflow Directional Tag Classes.
Definition: AdornedCFG.h:28
bool recordsEqual(const RecordStorageLocation &Loc1, const Environment &Env1, const RecordStorageLocation &Loc2, const Environment &Env2)
Returns whether the records Loc1 and Loc2 are equal.
Definition: RecordOps.cpp:88
void copyRecord(RecordStorageLocation &Src, RecordStorageLocation &Dst, Environment &Env)
Copies a record (struct, class, or union) from Src to Dst.
Definition: RecordOps.cpp:51
static void copyField(const ValueDecl &Field, StorageLocation *SrcFieldLoc, StorageLocation *DstFieldLoc, RecordStorageLocation &Dst, Environment &Env)
Definition: RecordOps.cpp:19
static void copySyntheticField(QualType FieldType, StorageLocation &SrcFieldLoc, StorageLocation &DstFieldLoc, Environment &Env)
Definition: RecordOps.cpp:38