1//===- ConstructionContext.cpp - CFG constructor information --------------===//
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 defines the ConstructionContext class and its sub-classes,
10// which represent various different ways of constructing C++ objects
11// with the additional information the users may want to know about
12// the constructor.
13//
14//===----------------------------------------------------------------------===//
15
16#include "clang/Analysis/ConstructionContext.h"
17#include "clang/AST/ExprObjC.h"
18
19using namespace clang;
20
21const ConstructionContextLayer *
22ConstructionContextLayer::create(BumpVectorContext &C,
23 const ConstructionContextItem &Item,
24 const ConstructionContextLayer *Parent) {
25 ConstructionContextLayer *CC =
26 C.getAllocator().Allocate<ConstructionContextLayer>();
27 return new (CC) ConstructionContextLayer(Item, Parent);
28}
29
30bool ConstructionContextLayer::isStrictlyMoreSpecificThan(
31 const ConstructionContextLayer *Other) const {
32 const ConstructionContextLayer *Self = this;
33 while (true) {
34 if (!Other)
35 return Self;
36 if (!Self || !(Self->Item == Other->Item))
37 return false;
38 Self = Self->getParent();
39 Other = Other->getParent();
40 }
41 llvm_unreachable("The above loop can only be terminated via return!");
42}
43
44const ConstructionContext *
45ConstructionContext::createMaterializedTemporaryFromLayers(
46 BumpVectorContext &C, const MaterializeTemporaryExpr *MTE,
47 const CXXBindTemporaryExpr *BTE,
48 const ConstructionContextLayer *ParentLayer) {
49 assert(MTE);
50
51 // If the object requires destruction and is not lifetime-extended,
52 // then it must have a BTE within its MTE, otherwise it shouldn't.
53 // FIXME: This should be an assertion.
54 if (!BTE && !(MTE->getType().getCanonicalType()->getAsCXXRecordDecl()
55 ->hasTrivialDestructor() ||
56 MTE->getStorageDuration() != SD_FullExpression)) {
57 return nullptr;
58 }
59
60 // If the temporary is lifetime-extended, don't save the BTE,
61 // because we don't need a temporary destructor, but an automatic
62 // destructor.
63 if (MTE->getStorageDuration() != SD_FullExpression) {
64 BTE = nullptr;
65 }
66
67 // Handle pre-C++17 copy and move elision.
68 const CXXConstructExpr *ElidedCE = nullptr;
69 const ConstructionContext *ElidedCC = nullptr;
70 if (ParentLayer) {
71 const ConstructionContextItem &ElidedItem = ParentLayer->getItem();
72 assert(ElidedItem.getKind() ==
73 ConstructionContextItem::ElidableConstructorKind);
74 ElidedCE = cast<CXXConstructExpr>(Val: ElidedItem.getStmt());
75 assert(ElidedCE->isElidable());
76 // We're creating a construction context that might have already
77 // been created elsewhere. Maybe we should unique our construction
78 // contexts. That's what we often do, but in this case it's unlikely
79 // to bring any benefits.
80 ElidedCC = createFromLayers(C, TopLayer: ParentLayer->getParent());
81 if (!ElidedCC) {
82 // We may fail to create the elided construction context.
83 // In this case, skip copy elision entirely.
84 return create<SimpleTemporaryObjectConstructionContext>(C, Args: BTE, Args: MTE);
85 }
86 return create<ElidedTemporaryObjectConstructionContext>(
87 C, Args: BTE, Args: MTE, Args: ElidedCE, Args: ElidedCC);
88 }
89
90 // This is a normal temporary.
91 assert(!ParentLayer);
92 return create<SimpleTemporaryObjectConstructionContext>(C, Args: BTE, Args: MTE);
93}
94
95const ConstructionContext *ConstructionContext::createBoundTemporaryFromLayers(
96 BumpVectorContext &C, const CXXBindTemporaryExpr *BTE,
97 const ConstructionContextLayer *ParentLayer) {
98 if (!ParentLayer) {
99 // A temporary object that doesn't require materialization.
100 // In particular, it shouldn't require copy elision, because
101 // copy/move constructors take a reference, which requires
102 // materialization to obtain the glvalue.
103 return create<SimpleTemporaryObjectConstructionContext>(C, Args: BTE,
104 /*MTE=*/Args: nullptr);
105 }
106
107 const ConstructionContextItem &ParentItem = ParentLayer->getItem();
108 switch (ParentItem.getKind()) {
109 case ConstructionContextItem::VariableKind: {
110 const auto *DS = cast<DeclStmt>(Val: ParentItem.getStmt());
111 assert(!cast<VarDecl>(DS->getSingleDecl())->getType().getCanonicalType()
112 ->getAsCXXRecordDecl()->hasTrivialDestructor());
113 return create<CXX17ElidedCopyVariableConstructionContext>(C, Args: DS, Args: BTE);
114 }
115 case ConstructionContextItem::NewAllocatorKind: {
116 llvm_unreachable("This context does not accept a bound temporary!");
117 }
118 case ConstructionContextItem::ReturnKind: {
119 assert(ParentLayer->isLast());
120 const auto *RS = cast<ReturnStmt>(Val: ParentItem.getStmt());
121 assert(!RS->getRetValue()->getType().getCanonicalType()
122 ->getAsCXXRecordDecl()->hasTrivialDestructor());
123 return create<CXX17ElidedCopyReturnedValueConstructionContext>(C, Args: RS,
124 Args: BTE);
125 }
126
127 case ConstructionContextItem::MaterializationKind: {
128 // No assert. We may have an elidable copy on the grandparent layer.
129 const auto *MTE = cast<MaterializeTemporaryExpr>(Val: ParentItem.getStmt());
130 return createMaterializedTemporaryFromLayers(C, MTE, BTE,
131 ParentLayer: ParentLayer->getParent());
132 }
133 case ConstructionContextItem::TemporaryDestructorKind: {
134 llvm_unreachable("Duplicate CXXBindTemporaryExpr in the AST!");
135 }
136 case ConstructionContextItem::ElidedDestructorKind: {
137 llvm_unreachable("Elided destructor items are not produced by the CFG!");
138 }
139 case ConstructionContextItem::ElidableConstructorKind: {
140 llvm_unreachable("Materialization is necessary to put temporary into a "
141 "copy or move constructor!");
142 }
143 case ConstructionContextItem::ArgumentKind: {
144 assert(ParentLayer->isLast());
145 const auto *E = cast<Expr>(Val: ParentItem.getStmt());
146 assert(isa<CallExpr>(E) || isa<CXXConstructExpr>(E) ||
147 isa<ObjCMessageExpr>(E));
148 return create<ArgumentConstructionContext>(C, Args: E, Args: ParentItem.getIndex(),
149 Args: BTE);
150 }
151 case ConstructionContextItem::InitializerKind: {
152 assert(ParentLayer->isLast());
153 const auto *I = ParentItem.getCXXCtorInitializer();
154 assert(!I->getAnyMember()->getType().getCanonicalType()
155 ->getAsCXXRecordDecl()->hasTrivialDestructor());
156 return create<CXX17ElidedCopyConstructorInitializerConstructionContext>(
157 C, Args: I, Args: BTE);
158 }
159 case ConstructionContextItem::LambdaCaptureKind: {
160 assert(ParentLayer->isLast());
161 const auto *E = cast<LambdaExpr>(Val: ParentItem.getStmt());
162 return create<LambdaCaptureConstructionContext>(C, Args: E,
163 Args: ParentItem.getIndex());
164 }
165 } // switch (ParentItem.getKind())
166
167 llvm_unreachable("Unexpected construction context with destructor!");
168}
169
170const ConstructionContext *ConstructionContext::createFromLayers(
171 BumpVectorContext &C, const ConstructionContextLayer *TopLayer) {
172 // Before this point all we've had was a stockpile of arbitrary layers.
173 // Now validate that it is shaped as one of the finite amount of expected
174 // patterns.
175 const ConstructionContextItem &TopItem = TopLayer->getItem();
176 switch (TopItem.getKind()) {
177 case ConstructionContextItem::VariableKind: {
178 assert(TopLayer->isLast());
179 const auto *DS = cast<DeclStmt>(Val: TopItem.getStmt());
180 return create<SimpleVariableConstructionContext>(C, Args: DS);
181 }
182 case ConstructionContextItem::NewAllocatorKind: {
183 assert(TopLayer->isLast());
184 const auto *NE = cast<CXXNewExpr>(Val: TopItem.getStmt());
185 return create<NewAllocatedObjectConstructionContext>(C, Args: NE);
186 }
187 case ConstructionContextItem::ReturnKind: {
188 assert(TopLayer->isLast());
189 const auto *RS = cast<ReturnStmt>(Val: TopItem.getStmt());
190 return create<SimpleReturnedValueConstructionContext>(C, Args: RS);
191 }
192 case ConstructionContextItem::MaterializationKind: {
193 const auto *MTE = cast<MaterializeTemporaryExpr>(Val: TopItem.getStmt());
194 return createMaterializedTemporaryFromLayers(C, MTE, /*BTE=*/nullptr,
195 ParentLayer: TopLayer->getParent());
196 }
197 case ConstructionContextItem::TemporaryDestructorKind: {
198 const auto *BTE = cast<CXXBindTemporaryExpr>(Val: TopItem.getStmt());
199 assert(BTE->getType().getCanonicalType()->getAsCXXRecordDecl()
200 ->hasNonTrivialDestructor());
201 return createBoundTemporaryFromLayers(C, BTE, ParentLayer: TopLayer->getParent());
202 }
203 case ConstructionContextItem::ElidedDestructorKind: {
204 llvm_unreachable("Elided destructor items are not produced by the CFG!");
205 }
206 case ConstructionContextItem::ElidableConstructorKind: {
207 llvm_unreachable("The argument needs to be materialized first!");
208 }
209 case ConstructionContextItem::LambdaCaptureKind: {
210 assert(TopLayer->isLast());
211 const auto *E = cast<LambdaExpr>(Val: TopItem.getStmt());
212 return create<LambdaCaptureConstructionContext>(C, Args: E, Args: TopItem.getIndex());
213 }
214 case ConstructionContextItem::InitializerKind: {
215 assert(TopLayer->isLast());
216 const CXXCtorInitializer *I = TopItem.getCXXCtorInitializer();
217 return create<SimpleConstructorInitializerConstructionContext>(C, Args: I);
218 }
219 case ConstructionContextItem::ArgumentKind: {
220 assert(TopLayer->isLast());
221 const auto *E = cast<Expr>(Val: TopItem.getStmt());
222 return create<ArgumentConstructionContext>(C, Args: E, Args: TopItem.getIndex(),
223 /*BTE=*/Args: nullptr);
224 }
225 } // switch (TopItem.getKind())
226 llvm_unreachable("Unexpected construction context!");
227}
228