1 //===- Scope.cpp - Lexical scope information --------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Scope class, which is used for recording
11 // information about a lexical scope.
13 //===----------------------------------------------------------------------===//
15 #include "clang/Sema/Scope.h"
16 #include "clang/AST/Decl.h"
17 #include "llvm/Support/raw_ostream.h"
19 using namespace clang;
21 void Scope::setFlags(Scope *parent, unsigned flags) {
25 if (parent && !(flags & FnScope)) {
26 BreakParent = parent->BreakParent;
27 ContinueParent = parent->ContinueParent;
29 // Control scopes do not contain the contents of nested function scopes for
30 // control flow purposes.
31 BreakParent = ContinueParent = nullptr;
35 Depth = parent->Depth + 1;
36 PrototypeDepth = parent->PrototypeDepth;
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)) ==
46 Flags |= parent->getFlags() & OpenMPSimdDirectiveScope;
51 MSLastManglingParent = FnParent = BlockParent = nullptr;
52 TemplateParamParent = nullptr;
53 MSLastManglingNumber = 1;
54 MSCurManglingNumber = 1;
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;
66 if (flags & BreakScope) BreakParent = this;
67 if (flags & ContinueScope) ContinueParent = this;
68 if (flags & BlockScope) BlockParent = this;
69 if (flags & TemplateParamScope) TemplateParamParent = this;
71 // If this is a prototype scope, record that.
72 if (flags & FunctionPrototypeScope) PrototypeDepth++;
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.
84 incrementMSManglingNumber();
88 void Scope::Init(Scope *parent, unsigned flags) {
89 setFlags(parent, flags);
92 UsingDirectives.clear();
95 NRVO.setPointerAndInt(nullptr, 0);
98 bool Scope::containedInPrototypeScope() const {
99 const Scope *S = this;
101 if (S->isFunctionPrototypeScope())
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");
115 if (FlagsToSet & ContinueScope) {
116 assert((Flags & ContinueScope) == 0 && "Already set");
117 ContinueParent = this;
122 void Scope::mergeNRVOIntoParent() {
123 if (VarDecl *Candidate = NRVO.getPointer()) {
124 if (isDeclScope(Candidate))
125 Candidate->setNRVOVariable(true);
132 getParent()->setNoNRVO();
133 else if (NRVO.getPointer())
134 getParent()->addNRVOCandidate(NRVO.getPointer());
137 LLVM_DUMP_METHOD void Scope::dump() const { dumpImpl(llvm::errs()); }
139 void Scope::dumpImpl(raw_ostream &OS) const {
140 unsigned Flags = getFlags();
141 bool HasFlags = Flags != 0;
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"}};
172 for (auto Info : FlagInfo) {
173 if (Flags & Info.first) {
175 Flags &= ~Info.first;
181 assert(Flags == 0 && "Unknown scope flags");
186 if (const Scope *Parent = getParent())
187 OS << "Parent: (clang::Scope*)" << Parent << '\n';
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';
196 OS << "NRVO not allowed\n";
197 else if (NRVO.getPointer())
198 OS << "NRVO candidate : (clang::VarDecl*)" << NRVO.getPointer() << '\n';