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