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