#define DEBUG_TYPE "lexicalscopes"
-/// ~LexicalScopes - final cleanup after ourselves.
-LexicalScopes::~LexicalScopes() { reset(); }
-
/// reset - Reset the instance so that it's prepared for another function.
void LexicalScopes::reset() {
MF = nullptr;
CurrentFnLexicalScope = nullptr;
+ LexicalScopeMap.clear();
+ AbstractScopeMap.clear();
InlinedLexicalScopeMap.clear();
AbstractScopesList.clear();
}
}
}
+LexicalScope *LexicalScopes::findInlinedScope(DebugLoc DL) {
+ MDNode *Scope = nullptr;
+ MDNode *IA = nullptr;
+ DL.getScopeAndInlinedAt(Scope, IA, MF->getFunction()->getContext());
+ auto I = InlinedLexicalScopeMap.find(std::make_pair(Scope, IA));
+ return I != InlinedLexicalScopeMap.end() ? &I->second : nullptr;
+}
+
/// findLexicalScope - Find lexical scope, either regular or inlined, for the
/// given DebugLoc. Return NULL if not found.
LexicalScope *LexicalScopes::findLexicalScope(DebugLoc DL) {
if (D.isLexicalBlockFile())
Scope = DILexicalBlockFile(Scope).getScope();
- if (IA)
- return InlinedLexicalScopeMap.lookup(DebugLoc::getFromDILocation(IA));
- auto I = LexicalScopeMap.find(Scope);
- return I != LexicalScopeMap.end() ? I->second.get() : nullptr;
+ if (IA) {
+ auto I = InlinedLexicalScopeMap.find(std::make_pair(Scope, IA));
+ return I != InlinedLexicalScopeMap.end() ? &I->second : nullptr;
+ }
+ return findLexicalScope(Scope);
}
/// getOrCreateLexicalScope - Find lexical scope for the given DebugLoc. If
D = DIDescriptor(Scope);
}
- auto IterBool = LexicalScopeMap.insert(
- std::make_pair(Scope, std::unique_ptr<LexicalScope>()));
- auto &MapValue = *IterBool.first;
- if (!IterBool.second)
- return MapValue.second.get();
+ auto I = LexicalScopeMap.find(Scope);
+ if (I != LexicalScopeMap.end())
+ return &I->second;
LexicalScope *Parent = nullptr;
if (D.isLexicalBlock())
Parent = getOrCreateLexicalScope(DebugLoc::getFromDILexicalBlock(Scope));
- MapValue.second =
- make_unique<LexicalScope>(Parent, DIDescriptor(Scope), nullptr, false);
+ // FIXME: Use forward_as_tuple instead of make_tuple, once MSVC2012
+ // compatibility is no longer required.
+ I = LexicalScopeMap.emplace(std::piecewise_construct, std::make_tuple(Scope),
+ std::make_tuple(Parent, DIDescriptor(Scope),
+ nullptr, false)).first;
+
if (!Parent && DIDescriptor(Scope).isSubprogram() &&
DISubprogram(Scope).describes(MF->getFunction()))
- CurrentFnLexicalScope = MapValue.second.get();
+ CurrentFnLexicalScope = &I->second;
- return MapValue.second.get();
+ return &I->second;
}
/// getOrCreateInlinedScope - Find or create an inlined lexical scope.
-LexicalScope *LexicalScopes::getOrCreateInlinedScope(MDNode *Scope,
+LexicalScope *LexicalScopes::getOrCreateInlinedScope(MDNode *ScopeNode,
MDNode *InlinedAt) {
- auto IterBool = LexicalScopeMap.insert(
- std::make_pair(InlinedAt, std::unique_ptr<LexicalScope>()));
- auto &MapValue = *IterBool.first;
- if (!IterBool.second)
- return MapValue.second.get();
-
- DebugLoc InlinedLoc = DebugLoc::getFromDILocation(InlinedAt);
- MapValue.second =
- make_unique<LexicalScope>(getOrCreateLexicalScope(InlinedLoc),
- DIDescriptor(Scope), InlinedAt, false);
- InlinedLexicalScopeMap[InlinedLoc] = MapValue.second.get();
- return MapValue.second.get();
+ std::pair<const MDNode*, const MDNode*> P(ScopeNode, InlinedAt);
+ auto I = InlinedLexicalScopeMap.find(P);
+ if (I != InlinedLexicalScopeMap.end())
+ return &I->second;
+
+ LexicalScope *Parent;
+ DILexicalBlock Scope(ScopeNode);
+ if (Scope.isSubprogram())
+ Parent = getOrCreateLexicalScope(DebugLoc::getFromDILocation(InlinedAt));
+ else
+ Parent = getOrCreateInlinedScope(Scope.getContext(), InlinedAt);
+
+ // FIXME: Use forward_as_tuple instead of make_tuple, once MSVC2012
+ // compatibility is no longer required.
+ I = InlinedLexicalScopeMap.emplace(std::piecewise_construct,
+ std::make_tuple(P),
+ std::make_tuple(Parent, Scope, InlinedAt,
+ false)).first;
+ return &I->second;
}
/// getOrCreateAbstractScope - Find or create an abstract lexical scope.
DIDescriptor Scope(N);
if (Scope.isLexicalBlockFile())
Scope = DILexicalBlockFile(Scope).getScope();
- auto IterBool = AbstractScopeMap.insert(
- std::make_pair(N, std::unique_ptr<LexicalScope>()));
- auto &MapEntry = *IterBool.first;
- if (!IterBool.second)
- return MapEntry.second.get();
+ auto I = AbstractScopeMap.find(Scope);
+ if (I != AbstractScopeMap.end())
+ return &I->second;
LexicalScope *Parent = nullptr;
if (Scope.isLexicalBlock()) {
- DILexicalBlock DB(N);
+ DILexicalBlock DB(Scope);
DIDescriptor ParentDesc = DB.getContext();
Parent = getOrCreateAbstractScope(ParentDesc);
}
- MapEntry.second =
- make_unique<LexicalScope>(Parent, DIDescriptor(N), nullptr, true);
- if (DIDescriptor(N).isSubprogram())
- AbstractScopesList.push_back(MapEntry.second.get());
- return MapEntry.second.get();
+ I = AbstractScopeMap.emplace(std::piecewise_construct,
+ std::forward_as_tuple(Scope),
+ std::forward_as_tuple(Parent, Scope,
+ nullptr, true)).first;
+ if (Scope.isSubprogram())
+ AbstractScopesList.push_back(&I->second);
+ return &I->second;
}
/// constructScopeNest