contrib/llvm/tools/clang/lib/Analysis/ConstructionContext.cpp

   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
  19 using namespace clang;
  20
  21 const ConstructionContextLayer *
  22 ConstructionContextLayer::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
  30 bool 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
  44 const ConstructionContext *
  45 ConstructionContext::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>(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, 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, BTE, MTE);
  85     }
  86     return create<ElidedTemporaryObjectConstructionContext>(
  87         C, BTE, MTE, ElidedCE, ElidedCC);
  88   }
  89
  90   // This is a normal temporary.
  91   assert(!ParentLayer);
  92   return create<SimpleTemporaryObjectConstructionContext>(C, BTE, MTE);
  93 }
  94
  95 const 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, BTE,
 104                                                             /*MTE=*/nullptr);
 105   }
 106
 107   const ConstructionContextItem &ParentItem = ParentLayer->getItem();
 108   switch (ParentItem.getKind()) {
 109   case ConstructionContextItem::VariableKind: {
 110     const auto *DS = cast<DeclStmt>(ParentItem.getStmt());
 111     assert(!cast<VarDecl>(DS->getSingleDecl())->getType().getCanonicalType()
 112                             ->getAsCXXRecordDecl()->hasTrivialDestructor());
 113     return create<CXX17ElidedCopyVariableConstructionContext>(C, DS, 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>(ParentItem.getStmt());
 121     assert(!RS->getRetValue()->getType().getCanonicalType()
 122               ->getAsCXXRecordDecl()->hasTrivialDestructor());
 123     return create<CXX17ElidedCopyReturnedValueConstructionContext>(C, RS,
 124                                                                    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>(ParentItem.getStmt());
 130     return createMaterializedTemporaryFromLayers(C, MTE, BTE,
 131                                                  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>(ParentItem.getStmt());
 146     assert(isa<CallExpr>(E) || isa<CXXConstructExpr>(E) ||
 147            isa<ObjCMessageExpr>(E));
 148     return create<ArgumentConstructionContext>(C, E, ParentItem.getIndex(),
 149                                                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, I, BTE);
 158   }
 159   } // switch (ParentItem.getKind())
 160
 161   llvm_unreachable("Unexpected construction context with destructor!");
 162 }
 163
 164 const ConstructionContext *ConstructionContext::createFromLayers(
 165     BumpVectorContext &C, const ConstructionContextLayer *TopLayer) {
 166   // Before this point all we've had was a stockpile of arbitrary layers.
 167   // Now validate that it is shaped as one of the finite amount of expected
 168   // patterns.
 169   const ConstructionContextItem &TopItem = TopLayer->getItem();
 170   switch (TopItem.getKind()) {
 171   case ConstructionContextItem::VariableKind: {
 172     assert(TopLayer->isLast());
 173     const auto *DS = cast<DeclStmt>(TopItem.getStmt());
 174     return create<SimpleVariableConstructionContext>(C, DS);
 175   }
 176   case ConstructionContextItem::NewAllocatorKind: {
 177     assert(TopLayer->isLast());
 178     const auto *NE = cast<CXXNewExpr>(TopItem.getStmt());
 179     return create<NewAllocatedObjectConstructionContext>(C, NE);
 180   }
 181   case ConstructionContextItem::ReturnKind: {
 182     assert(TopLayer->isLast());
 183     const auto *RS = cast<ReturnStmt>(TopItem.getStmt());
 184     return create<SimpleReturnedValueConstructionContext>(C, RS);
 185   }
 186   case ConstructionContextItem::MaterializationKind: {
 187     const auto *MTE = cast<MaterializeTemporaryExpr>(TopItem.getStmt());
 188     return createMaterializedTemporaryFromLayers(C, MTE, /*BTE=*/nullptr,
 189                                                  TopLayer->getParent());
 190   }
 191   case ConstructionContextItem::TemporaryDestructorKind: {
 192     const auto *BTE = cast<CXXBindTemporaryExpr>(TopItem.getStmt());
 193     assert(BTE->getType().getCanonicalType()->getAsCXXRecordDecl()
 194               ->hasNonTrivialDestructor());
 195     return createBoundTemporaryFromLayers(C, BTE, TopLayer->getParent());
 196   }
 197   case ConstructionContextItem::ElidedDestructorKind: {
 198     llvm_unreachable("Elided destructor items are not produced by the CFG!");
 199   }
 200   case ConstructionContextItem::ElidableConstructorKind: {
 201     llvm_unreachable("The argument needs to be materialized first!");
 202   }
 203   case ConstructionContextItem::InitializerKind: {
 204     assert(TopLayer->isLast());
 205     const CXXCtorInitializer *I = TopItem.getCXXCtorInitializer();
 206     return create<SimpleConstructorInitializerConstructionContext>(C, I);
 207   }
 208   case ConstructionContextItem::ArgumentKind: {
 209     assert(TopLayer->isLast());
 210     const auto *E = cast<Expr>(TopItem.getStmt());
 211     return create<ArgumentConstructionContext>(C, E, TopItem.getIndex(),
 212                                                /*BTE=*/nullptr);
 213   }
 214   } // switch (TopItem.getKind())
 215   llvm_unreachable("Unexpected construction context!");
 216 }