lib/Sema/Scope.cpp

   1 //===- Scope.cpp - Lexical scope information --------------------*- C++ -*-===//
   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 the Scope class, which is used for recording
  11 // information about a lexical scope.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Sema/Scope.h"
  16 #include "clang/AST/Decl.h"
  17 #include "llvm/Support/raw_ostream.h"
  18
  19 using namespace clang;
  20
  21 void Scope::setFlags(Scope *parent, unsigned flags) {
  22   AnyParent = parent;
  23   Flags = flags;
  24
  25   if (parent && !(flags & FnScope)) {
  26     BreakParent    = parent->BreakParent;
  27     ContinueParent = parent->ContinueParent;
  28   } else {
  29     // Control scopes do not contain the contents of nested function scopes for
  30     // control flow purposes.
  31     BreakParent = ContinueParent = nullptr;
  32   }
  33
  34   if (parent) {
  35     Depth = parent->Depth + 1;
  36     PrototypeDepth = parent->PrototypeDepth;
  37     PrototypeIndex = 0;
  38     FnParent       = parent->FnParent;
  39     BlockParent    = parent->BlockParent;
  40     TemplateParamParent = parent->TemplateParamParent;
  41     MSLastManglingParent = parent->MSLastManglingParent;
  42     MSCurManglingNumber = getMSLastManglingNumber();
  43     if ((Flags & (FnScope | ClassScope | BlockScope | TemplateParamScope |
  44                   FunctionPrototypeScope | AtCatchScope | ObjCMethodScope)) ==
  45         0)
  46       Flags |= parent->getFlags() & OpenMPSimdDirectiveScope;
  47   } else {
  48     Depth = 0;
  49     PrototypeDepth = 0;
  50     PrototypeIndex = 0;
  51     MSLastManglingParent = FnParent = BlockParent = nullptr;
  52     TemplateParamParent = nullptr;
  53     MSLastManglingNumber = 1;
  54     MSCurManglingNumber = 1;
  55   }
  56
  57   // If this scope is a function or contains breaks/continues, remember it.
  58   if (flags & FnScope)            FnParent = this;
  59   // The MS mangler uses the number of scopes that can hold declarations as
  60   // part of an external name.
  61   if (Flags & (ClassScope | FnScope)) {
  62     MSLastManglingNumber = getMSLastManglingNumber();
  63     MSLastManglingParent = this;
  64     MSCurManglingNumber = 1;
  65   }
  66   if (flags & BreakScope)         BreakParent = this;
  67   if (flags & ContinueScope)      ContinueParent = this;
  68   if (flags & BlockScope)         BlockParent = this;
  69   if (flags & TemplateParamScope) TemplateParamParent = this;
  70
  71   // If this is a prototype scope, record that.
  72   if (flags & FunctionPrototypeScope) PrototypeDepth++;
  73
  74   if (flags & DeclScope) {
  75     if (flags & FunctionPrototypeScope)
  76       ; // Prototype scopes are uninteresting.
  77     else if ((flags & ClassScope) && getParent()->isClassScope())
  78       ; // Nested class scopes aren't ambiguous.
  79     else if ((flags & ClassScope) && getParent()->getFlags() == DeclScope)
  80       ; // Classes inside of namespaces aren't ambiguous.
  81     else if ((flags & EnumScope))
  82       ; // Don't increment for enum scopes.
  83     else
  84       incrementMSManglingNumber();
  85   }
  86 }
  87
  88 void Scope::Init(Scope *parent, unsigned flags) {
  89   setFlags(parent, flags);
  90
  91   DeclsInScope.clear();
  92   UsingDirectives.clear();
  93   Entity = nullptr;
  94   ErrorTrap.reset();
  95   NRVO.setPointerAndInt(nullptr, 0);
  96 }
  97
  98 bool Scope::containedInPrototypeScope() const {
  99   const Scope *S = this;
 100   while (S) {
 101     if (S->isFunctionPrototypeScope())
 102       return true;
 103     S = S->getParent();
 104   }
 105   return false;
 106 }
 107
 108 void Scope::AddFlags(unsigned FlagsToSet) {
 109   assert((FlagsToSet & ~(BreakScope | ContinueScope)) == 0 &&
 110          "Unsupported scope flags");
 111   if (FlagsToSet & BreakScope) {
 112     assert((Flags & BreakScope) == 0 && "Already set");
 113     BreakParent = this;
 114   }
 115   if (FlagsToSet & ContinueScope) {
 116     assert((Flags & ContinueScope) == 0 && "Already set");
 117     ContinueParent = this;
 118   }
 119   Flags |= FlagsToSet;
 120 }
 121
 122 void Scope::mergeNRVOIntoParent() {
 123   if (VarDecl *Candidate = NRVO.getPointer()) {
 124     if (isDeclScope(Candidate))
 125       Candidate->setNRVOVariable(true);
 126   }
 127
 128   if (getEntity())
 129     return;
 130
 131   if (NRVO.getInt())
 132     getParent()->setNoNRVO();
 133   else if (NRVO.getPointer())
 134     getParent()->addNRVOCandidate(NRVO.getPointer());
 135 }
 136
 137 LLVM_DUMP_METHOD void Scope::dump() const { dumpImpl(llvm::errs()); }
 138
 139 void Scope::dumpImpl(raw_ostream &OS) const {
 140   unsigned Flags = getFlags();
 141   bool HasFlags = Flags != 0;
 142
 143   if (HasFlags)
 144     OS << "Flags: ";
 145
 146   std::pair<unsigned, const char *> FlagInfo[] = {
 147       {FnScope, "FnScope"},
 148       {BreakScope, "BreakScope"},
 149       {ContinueScope, "ContinueScope"},
 150       {DeclScope, "DeclScope"},
 151       {ControlScope, "ControlScope"},
 152       {ClassScope, "ClassScope"},
 153       {BlockScope, "BlockScope"},
 154       {TemplateParamScope, "TemplateParamScope"},
 155       {FunctionPrototypeScope, "FunctionPrototypeScope"},
 156       {FunctionDeclarationScope, "FunctionDeclarationScope"},
 157       {AtCatchScope, "AtCatchScope"},
 158       {ObjCMethodScope, "ObjCMethodScope"},
 159       {SwitchScope, "SwitchScope"},
 160       {TryScope, "TryScope"},
 161       {FnTryCatchScope, "FnTryCatchScope"},
 162       {OpenMPDirectiveScope, "OpenMPDirectiveScope"},
 163       {OpenMPLoopDirectiveScope, "OpenMPLoopDirectiveScope"},
 164       {OpenMPSimdDirectiveScope, "OpenMPSimdDirectiveScope"},
 165       {EnumScope, "EnumScope"},
 166       {SEHTryScope, "SEHTryScope"},
 167       {SEHExceptScope, "SEHExceptScope"},
 168       {SEHFilterScope, "SEHFilterScope"},
 169       {CompoundStmtScope, "CompoundStmtScope"},
 170       {ClassInheritanceScope, "ClassInheritanceScope"}};
 171
 172   for (auto Info : FlagInfo) {
 173     if (Flags & Info.first) {
 174       OS << Info.second;
 175       Flags &= ~Info.first;
 176       if (Flags)
 177         OS << " | ";
 178     }
 179   }
 180
 181   assert(Flags == 0 && "Unknown scope flags");
 182
 183   if (HasFlags)
 184     OS << '\n';
 185
 186   if (const Scope *Parent = getParent())
 187     OS << "Parent: (clang::Scope*)" << Parent << '\n';
 188
 189   OS << "Depth: " << Depth << '\n';
 190   OS << "MSLastManglingNumber: " << getMSLastManglingNumber() << '\n';
 191   OS << "MSCurManglingNumber: " << getMSCurManglingNumber() << '\n';
 192   if (const DeclContext *DC = getEntity())
 193     OS << "Entity : (clang::DeclContext*)" << DC << '\n';
 194
 195   if (NRVO.getInt())
 196     OS << "NRVO not allowed\n";
 197   else if (NRVO.getPointer())
 198     OS << "NRVO candidate : (clang::VarDecl*)" << NRVO.getPointer() << '\n';
 199 }