contrib/llvm/tools/clang/lib/Sema/ScopeInfo.cpp

   1 //===--- ScopeInfo.cpp - Information about a semantic context -------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements FunctionScopeInfo and its subclasses, which contain
  11 // information about a single function, block, lambda, or method body.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Sema/ScopeInfo.h"
  16 #include "clang/AST/Decl.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "clang/AST/Expr.h"
  19 #include "clang/AST/ExprCXX.h"
  20 #include "clang/AST/ExprObjC.h"
  21
  22 using namespace clang;
  23 using namespace sema;
  24
  25 void FunctionScopeInfo::Clear() {
  26   HasBranchProtectedScope = false;
  27   HasBranchIntoScope = false;
  28   HasIndirectGoto = false;
  29   HasDroppedStmt = false;
  30   ObjCShouldCallSuper = false;
  31   ObjCIsDesignatedInit = false;
  32   ObjCWarnForNoDesignatedInitChain = false;
  33   ObjCIsSecondaryInit = false;
  34   ObjCWarnForNoInitDelegation = false;
  35
  36   SwitchStack.clear();
  37   Returns.clear();
  38   ErrorTrap.reset();
  39   PossiblyUnreachableDiags.clear();
  40   WeakObjectUses.clear();
  41 }
  42
  43 static const NamedDecl *getBestPropertyDecl(const ObjCPropertyRefExpr *PropE) {
  44   if (PropE->isExplicitProperty())
  45     return PropE->getExplicitProperty();
  46
  47   return PropE->getImplicitPropertyGetter();
  48 }
  49
  50 FunctionScopeInfo::WeakObjectProfileTy::BaseInfoTy
  51 FunctionScopeInfo::WeakObjectProfileTy::getBaseInfo(const Expr *E) {
  52   E = E->IgnoreParenCasts();
  53
  54   const NamedDecl *D = nullptr;
  55   bool IsExact = false;
  56
  57   switch (E->getStmtClass()) {
  58   case Stmt::DeclRefExprClass:
  59     D = cast<DeclRefExpr>(E)->getDecl();
  60     IsExact = isa<VarDecl>(D);
  61     break;
  62   case Stmt::MemberExprClass: {
  63     const MemberExpr *ME = cast<MemberExpr>(E);
  64     D = ME->getMemberDecl();
  65     IsExact = isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts());
  66     break;
  67   }
  68   case Stmt::ObjCIvarRefExprClass: {
  69     const ObjCIvarRefExpr *IE = cast<ObjCIvarRefExpr>(E);
  70     D = IE->getDecl();
  71     IsExact = IE->getBase()->isObjCSelfExpr();
  72     break;
  73   }
  74   case Stmt::PseudoObjectExprClass: {
  75     const PseudoObjectExpr *POE = cast<PseudoObjectExpr>(E);
  76     const ObjCPropertyRefExpr *BaseProp =
  77       dyn_cast<ObjCPropertyRefExpr>(POE->getSyntacticForm());
  78     if (BaseProp) {
  79       D = getBestPropertyDecl(BaseProp);
  80
  81       const Expr *DoubleBase = BaseProp->getBase();
  82       if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(DoubleBase))
  83         DoubleBase = OVE->getSourceExpr();
  84
  85       IsExact = DoubleBase->isObjCSelfExpr();
  86     }
  87     break;
  88   }
  89   default:
  90     break;
  91   }
  92
  93   return BaseInfoTy(D, IsExact);
  94 }
  95
  96 FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy(
  97                                           const ObjCPropertyRefExpr *PropE)
  98     : Base(nullptr, true), Property(getBestPropertyDecl(PropE)) {
  99
 100   if (PropE->isObjectReceiver()) {
 101     const OpaqueValueExpr *OVE = cast<OpaqueValueExpr>(PropE->getBase());
 102     const Expr *E = OVE->getSourceExpr();
 103     Base = getBaseInfo(E);
 104   } else if (PropE->isClassReceiver()) {
 105     Base.setPointer(PropE->getClassReceiver());
 106   } else {
 107     assert(PropE->isSuperReceiver());
 108   }
 109 }
 110
 111 FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy(const Expr *BaseE,
 112                                                 const ObjCPropertyDecl *Prop)
 113     : Base(nullptr, true), Property(Prop) {
 114   if (BaseE)
 115     Base = getBaseInfo(BaseE);
 116   // else, this is a message accessing a property on super.
 117 }
 118
 119 FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy(
 120                                                       const DeclRefExpr *DRE)
 121   : Base(nullptr, true), Property(DRE->getDecl()) {
 122   assert(isa<VarDecl>(Property));
 123 }
 124
 125 FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy(
 126                                                   const ObjCIvarRefExpr *IvarE)
 127   : Base(getBaseInfo(IvarE->getBase())), Property(IvarE->getDecl()) {
 128 }
 129
 130 void FunctionScopeInfo::recordUseOfWeak(const ObjCMessageExpr *Msg,
 131                                         const ObjCPropertyDecl *Prop) {
 132   assert(Msg && Prop);
 133   WeakUseVector &Uses =
 134     WeakObjectUses[WeakObjectProfileTy(Msg->getInstanceReceiver(), Prop)];
 135   Uses.push_back(WeakUseTy(Msg, Msg->getNumArgs() == 0));
 136 }
 137
 138 void FunctionScopeInfo::markSafeWeakUse(const Expr *E) {
 139   E = E->IgnoreParenCasts();
 140
 141   if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
 142     markSafeWeakUse(POE->getSyntacticForm());
 143     return;
 144   }
 145
 146   if (const ConditionalOperator *Cond = dyn_cast<ConditionalOperator>(E)) {
 147     markSafeWeakUse(Cond->getTrueExpr());
 148     markSafeWeakUse(Cond->getFalseExpr());
 149     return;
 150   }
 151
 152   if (const BinaryConditionalOperator *Cond =
 153         dyn_cast<BinaryConditionalOperator>(E)) {
 154     markSafeWeakUse(Cond->getCommon());
 155     markSafeWeakUse(Cond->getFalseExpr());
 156     return;
 157   }
 158
 159   // Has this weak object been seen before?
 160   FunctionScopeInfo::WeakObjectUseMap::iterator Uses;
 161   if (const ObjCPropertyRefExpr *RefExpr = dyn_cast<ObjCPropertyRefExpr>(E)) {
 162     if (isa<OpaqueValueExpr>(RefExpr->getBase()))
 163      Uses = WeakObjectUses.find(WeakObjectProfileTy(RefExpr));
 164     else {
 165       markSafeWeakUse(RefExpr->getBase());
 166       return;
 167     }
 168   }
 169   else if (const ObjCIvarRefExpr *IvarE = dyn_cast<ObjCIvarRefExpr>(E))
 170     Uses = WeakObjectUses.find(WeakObjectProfileTy(IvarE));
 171   else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
 172     Uses = WeakObjectUses.find(WeakObjectProfileTy(DRE));
 173   else if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E)) {
 174     Uses = WeakObjectUses.end();
 175     if (const ObjCMethodDecl *MD = MsgE->getMethodDecl()) {
 176       if (const ObjCPropertyDecl *Prop = MD->findPropertyDecl()) {
 177         Uses =
 178           WeakObjectUses.find(WeakObjectProfileTy(MsgE->getInstanceReceiver(),
 179                                                   Prop));
 180       }
 181     }
 182   }
 183   else
 184     return;
 185
 186   if (Uses == WeakObjectUses.end())
 187     return;
 188
 189   // Has there been a read from the object using this Expr?
 190   FunctionScopeInfo::WeakUseVector::reverse_iterator ThisUse =
 191     std::find(Uses->second.rbegin(), Uses->second.rend(), WeakUseTy(E, true));
 192   if (ThisUse == Uses->second.rend())
 193     return;
 194
 195   ThisUse->markSafe();
 196 }
 197
 198 void LambdaScopeInfo::getPotentialVariableCapture(unsigned Idx, VarDecl *&VD,
 199                                                   Expr *&E) const {
 200   assert(Idx < getNumPotentialVariableCaptures() &&
 201          "Index of potential capture must be within 0 to less than the "
 202          "number of captures!");
 203   E = PotentiallyCapturingExprs[Idx];
 204   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
 205     VD = dyn_cast<VarDecl>(DRE->getFoundDecl());
 206   else if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
 207     VD = dyn_cast<VarDecl>(ME->getMemberDecl());
 208   else
 209     llvm_unreachable("Only DeclRefExprs or MemberExprs should be added for "
 210     "potential captures");
 211   assert(VD);
 212 }
 213
 214 FunctionScopeInfo::~FunctionScopeInfo() { }
 215 BlockScopeInfo::~BlockScopeInfo() { }
 216 LambdaScopeInfo::~LambdaScopeInfo() { }
 217 CapturedRegionScopeInfo::~CapturedRegionScopeInfo() { }