//===- ConstructionContext.cpp - CFG constructor information --------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file defines the ConstructionContext class and its sub-classes,

// which represent various different ways of constructing C++ objects

// with the additional information the users may want to know about

// the constructor.

//

//===----------------------------------------------------------------------===//

#include "clang/Analysis/ConstructionContext.h"

#include "clang/AST/ExprObjC.h"

using namespace clang;

const ConstructionContextLayer *

ConstructionContextLayer::create(BumpVectorContext &C,

                                 const ConstructionContextItem &Item,

                                 const ConstructionContextLayer *Parent) {

  ConstructionContextLayer *CC =

      C.getAllocator().Allocate<ConstructionContextLayer>();

  return new (CC) ConstructionContextLayer(Item, Parent);

}

bool ConstructionContextLayer::isStrictlyMoreSpecificThan(

    const ConstructionContextLayer *Other) const {

  const ConstructionContextLayer *Self = this;

  while (true) {

    if (!Other)

      return Self;

    if (!Self || !(Self->Item == Other->Item))

      return false;

    Self = Self->getParent();

    Other = Other->getParent();

  }

  llvm_unreachable("The above loop can only be terminated via return!");

}

const ConstructionContext *

ConstructionContext::createMaterializedTemporaryFromLayers(

    BumpVectorContext &C, const MaterializeTemporaryExpr *MTE,

    const CXXBindTemporaryExpr *BTE,

    const ConstructionContextLayer *ParentLayer) {

  assert(MTE);

  // If the object requires destruction and is not lifetime-extended,

  // then it must have a BTE within its MTE, otherwise it shouldn't.

  // FIXME: This should be an assertion.

  if (!BTE && !(MTE->getType().getCanonicalType()->getAsCXXRecordDecl()

                    ->hasTrivialDestructor() ||

                MTE->getStorageDuration() != SD_FullExpression)) {

    return nullptr;

  }

  // If the temporary is lifetime-extended, don't save the BTE,

  // because we don't need a temporary destructor, but an automatic

  // destructor.

  if (MTE->getStorageDuration() != SD_FullExpression) {

    BTE = nullptr;

  }

  // Handle pre-C++17 copy and move elision.

  const CXXConstructExpr *ElidedCE = nullptr;

  const ConstructionContext *ElidedCC = nullptr;

  if (ParentLayer) {

    const ConstructionContextItem &ElidedItem = ParentLayer->getItem();

    assert(ElidedItem.getKind() ==

           ConstructionContextItem::ElidableConstructorKind);

    ElidedCE = cast<CXXConstructExpr>(ElidedItem.getStmt());

    assert(ElidedCE->isElidable());

    // We're creating a construction context that might have already

    // been created elsewhere. Maybe we should unique our construction

    // contexts. That's what we often do, but in this case it's unlikely

    // to bring any benefits.

    ElidedCC = createFromLayers(C, ParentLayer->getParent());

    if (!ElidedCC) {

      // We may fail to create the elided construction context.

      // In this case, skip copy elision entirely.

      return create<SimpleTemporaryObjectConstructionContext>(C, BTE, MTE);

    }

    return create<ElidedTemporaryObjectConstructionContext>(

        C, BTE, MTE, ElidedCE, ElidedCC);

  }

  // This is a normal temporary.

  assert(!ParentLayer);

  return create<SimpleTemporaryObjectConstructionContext>(C, BTE, MTE);

}

const ConstructionContext *ConstructionContext::createBoundTemporaryFromLayers(

    BumpVectorContext &C, const CXXBindTemporaryExpr *BTE,

    const ConstructionContextLayer *ParentLayer) {

  if (!ParentLayer) {

    // A temporary object that doesn't require materialization.

    // In particular, it shouldn't require copy elision, because

    // copy/move constructors take a reference, which requires

    // materialization to obtain the glvalue.

    return create<SimpleTemporaryObjectConstructionContext>(C, BTE,

                                                            /*MTE=*/nullptr);

  }

  const ConstructionContextItem &ParentItem = ParentLayer->getItem();

  switch (ParentItem.getKind()) {

  case ConstructionContextItem::VariableKind: {

    const auto *DS = cast<DeclStmt>(ParentItem.getStmt());

    assert(!cast<VarDecl>(DS->getSingleDecl())->getType().getCanonicalType()

                            ->getAsCXXRecordDecl()->hasTrivialDestructor());

    return create<CXX17ElidedCopyVariableConstructionContext>(C, DS, BTE);

  }

  case ConstructionContextItem::NewAllocatorKind: {

    llvm_unreachable("This context does not accept a bound temporary!");

  }

  case ConstructionContextItem::ReturnKind: {

    assert(ParentLayer->isLast());

    const auto *RS = cast<ReturnStmt>(ParentItem.getStmt());

    assert(!RS->getRetValue()->getType().getCanonicalType()

              ->getAsCXXRecordDecl()->hasTrivialDestructor());

    return create<CXX17ElidedCopyReturnedValueConstructionContext>(C, RS,

                                                                   BTE);

  }

  case ConstructionContextItem::MaterializationKind: {

    // No assert. We may have an elidable copy on the grandparent layer.

    const auto *MTE = cast<MaterializeTemporaryExpr>(ParentItem.getStmt());

    return createMaterializedTemporaryFromLayers(C, MTE, BTE,

                                                 ParentLayer->getParent());

  }

  case ConstructionContextItem::TemporaryDestructorKind: {

    llvm_unreachable("Duplicate CXXBindTemporaryExpr in the AST!");

  }

  case ConstructionContextItem::ElidedDestructorKind: {

    llvm_unreachable("Elided destructor items are not produced by the CFG!");

  }

  case ConstructionContextItem::ElidableConstructorKind: {

    llvm_unreachable("Materialization is necessary to put temporary into a "

                     "copy or move constructor!");

  }

  case ConstructionContextItem::ArgumentKind: {

    assert(ParentLayer->isLast());

    const auto *E = cast<Expr>(ParentItem.getStmt());

    assert(isa<CallExpr>(E) || isa<CXXConstructExpr>(E) ||

           isa<ObjCMessageExpr>(E));

    return create<ArgumentConstructionContext>(C, E, ParentItem.getIndex(),

                                               BTE);

  }

  case ConstructionContextItem::InitializerKind: {

    assert(ParentLayer->isLast());

    const auto *I = ParentItem.getCXXCtorInitializer();

    assert(!I->getAnyMember()->getType().getCanonicalType()

             ->getAsCXXRecordDecl()->hasTrivialDestructor());

    return create<CXX17ElidedCopyConstructorInitializerConstructionContext>(

        C, I, BTE);

  }

  case ConstructionContextItem::LambdaCaptureKind: {

    assert(ParentLayer->isLast());

    const auto *E = cast<LambdaExpr>(ParentItem.getStmt());

    return create<LambdaCaptureConstructionContext>(C, E,

                                                    ParentItem.getIndex());

  }

  } // switch (ParentItem.getKind())

  llvm_unreachable("Unexpected construction context with destructor!");

}

const ConstructionContext *ConstructionContext::createFromLayers(

    BumpVectorContext &C, const ConstructionContextLayer *TopLayer) {

  // Before this point all we've had was a stockpile of arbitrary layers.

  // Now validate that it is shaped as one of the finite amount of expected

  // patterns.

  const ConstructionContextItem &TopItem = TopLayer->getItem();

  switch (TopItem.getKind()) {

  case ConstructionContextItem::VariableKind: {

    assert(TopLayer->isLast());

    const auto *DS = cast<DeclStmt>(TopItem.getStmt());

    return create<SimpleVariableConstructionContext>(C, DS);

  }

  case ConstructionContextItem::NewAllocatorKind: {

    assert(TopLayer->isLast());

    const auto *NE = cast<CXXNewExpr>(TopItem.getStmt());

    return create<NewAllocatedObjectConstructionContext>(C, NE);

  }

  case ConstructionContextItem::ReturnKind: {

    assert(TopLayer->isLast());

    const auto *RS = cast<ReturnStmt>(TopItem.getStmt());

    return create<SimpleReturnedValueConstructionContext>(C, RS);

  }

  case ConstructionContextItem::MaterializationKind: {

    const auto *MTE = cast<MaterializeTemporaryExpr>(TopItem.getStmt());

    return createMaterializedTemporaryFromLayers(C, MTE, /*BTE=*/nullptr,

                                                 TopLayer->getParent());

  }

  case ConstructionContextItem::TemporaryDestructorKind: {

    const auto *BTE = cast<CXXBindTemporaryExpr>(TopItem.getStmt());

    assert(BTE->getType().getCanonicalType()->getAsCXXRecordDecl()

              ->hasNonTrivialDestructor());

    return createBoundTemporaryFromLayers(C, BTE, TopLayer->getParent());

  }

  case ConstructionContextItem::ElidedDestructorKind: {

    llvm_unreachable("Elided destructor items are not produced by the CFG!");

  }

  case ConstructionContextItem::ElidableConstructorKind: {

    llvm_unreachable("The argument needs to be materialized first!");

  }

  case ConstructionContextItem::LambdaCaptureKind: {

    assert(TopLayer->isLast());

    const auto *E = cast<LambdaExpr>(TopItem.getStmt());

    return create<LambdaCaptureConstructionContext>(C, E, TopItem.getIndex());

  }

  case ConstructionContextItem::InitializerKind: {

    assert(TopLayer->isLast());

    const CXXCtorInitializer *I = TopItem.getCXXCtorInitializer();

    return create<SimpleConstructorInitializerConstructionContext>(C, I);

  }

  case ConstructionContextItem::ArgumentKind: {

    assert(TopLayer->isLast());

    const auto *E = cast<Expr>(TopItem.getStmt());

    return create<ArgumentConstructionContext>(C, E, TopItem.getIndex(),

                                               /*BTE=*/nullptr);

  }

  } // switch (TopItem.getKind())

  llvm_unreachable("Unexpected construction context!");

}