From 953f25078959d2517c88bf903a8270dc11f1403f Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Thu, 1 May 2014 00:46:58 +0000 Subject: [PATCH] Speculatively roll back r207724-r207726, which are code cleanup changes and appear to be breaking a bootstrapped build of compiler-rt. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207732 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/LexicalScopes.h | 11 ++---- lib/CodeGen/LexicalScopes.cpp | 55 +++++++++++++--------------- 2 files changed, 29 insertions(+), 37 deletions(-) diff --git a/include/llvm/CodeGen/LexicalScopes.h b/include/llvm/CodeGen/LexicalScopes.h index f5561a1b120..d6468bd75c2 100644 --- a/include/llvm/CodeGen/LexicalScopes.h +++ b/include/llvm/CodeGen/LexicalScopes.h @@ -25,7 +25,6 @@ #include "llvm/IR/Metadata.h" #include "llvm/IR/ValueHandle.h" #include -#include namespace llvm { class MachineInstr; @@ -90,8 +89,7 @@ public: /// findAbstractScope - Find an abstract scope or return NULL. LexicalScope *findAbstractScope(const MDNode *N) { - auto I = AbstractScopeMap.find(N); - return I != AbstractScopeMap.end() ? I->second.get() : nullptr; + return AbstractScopeMap.lookup(N); } /// findInlinedScope - Find an inlined scope for the given DebugLoc or return @@ -102,8 +100,7 @@ public: /// findLexicalScope - Find regular lexical scope or return NULL. LexicalScope *findLexicalScope(const MDNode *N) { - auto I = LexicalScopeMap.find(N); - return I != LexicalScopeMap.end() ? I->second.get() : nullptr; + return LexicalScopeMap.lookup(N); } /// dump - Print data structures to dbgs(). @@ -137,7 +134,7 @@ private: /// LexicalScopeMap - Tracks the scopes in the current function. Owns the /// contained LexicalScope*s. - DenseMap> LexicalScopeMap; + DenseMap LexicalScopeMap; /// InlinedLexicalScopeMap - Tracks inlined function scopes in current /// function. @@ -145,7 +142,7 @@ private: /// AbstractScopeMap - These scopes are not included LexicalScopeMap. /// AbstractScopes owns its LexicalScope*s. - DenseMap> AbstractScopeMap; + DenseMap AbstractScopeMap; /// AbstractScopesList - Tracks abstract scopes constructed while processing /// a function. diff --git a/lib/CodeGen/LexicalScopes.cpp b/lib/CodeGen/LexicalScopes.cpp index d4f3b70995b..f01dec28e52 100644 --- a/lib/CodeGen/LexicalScopes.cpp +++ b/lib/CodeGen/LexicalScopes.cpp @@ -33,6 +33,8 @@ LexicalScopes::~LexicalScopes() { reset(); } void LexicalScopes::reset() { MF = nullptr; CurrentFnLexicalScope = nullptr; + DeleteContainerSeconds(LexicalScopeMap); + DeleteContainerSeconds(AbstractScopeMap); InlinedLexicalScopeMap.clear(); AbstractScopesList.clear(); } @@ -122,8 +124,7 @@ LexicalScope *LexicalScopes::findLexicalScope(DebugLoc DL) { if (IA) return InlinedLexicalScopeMap.lookup(DebugLoc::getFromDILocation(IA)); - auto I = LexicalScopeMap.find(Scope); - return I != LexicalScopeMap.end() ? I->second.get() : nullptr; + return LexicalScopeMap.lookup(Scope); } /// getOrCreateLexicalScope - Find lexical scope for the given DebugLoc. If @@ -151,39 +152,35 @@ LexicalScope *LexicalScopes::getOrCreateRegularScope(MDNode *Scope) { D = DIDescriptor(Scope); } - auto IterBool = LexicalScopeMap.insert( - std::make_pair(Scope, std::unique_ptr())); - auto &MapValue = *IterBool.first; - if (!IterBool.second) - return MapValue.second.get(); + LexicalScope *WScope = LexicalScopeMap.lookup(Scope); + if (WScope) + return WScope; LexicalScope *Parent = nullptr; if (D.isLexicalBlock()) Parent = getOrCreateLexicalScope(DebugLoc::getFromDILexicalBlock(Scope)); - MapValue.second = - make_unique(Parent, DIDescriptor(Scope), nullptr, false); + WScope = new LexicalScope(Parent, DIDescriptor(Scope), nullptr, false); + LexicalScopeMap.insert(std::make_pair(Scope, WScope)); if (!Parent && DIDescriptor(Scope).isSubprogram() && DISubprogram(Scope).describes(MF->getFunction())) - CurrentFnLexicalScope = MapValue.second.get(); + CurrentFnLexicalScope = WScope; - return MapValue.second.get(); + return WScope; } /// getOrCreateInlinedScope - Find or create an inlined lexical scope. LexicalScope *LexicalScopes::getOrCreateInlinedScope(MDNode *Scope, MDNode *InlinedAt) { - auto IterBool = LexicalScopeMap.insert( - std::make_pair(InlinedAt, std::unique_ptr())); - auto &MapValue = *IterBool.first; - if (!IterBool.second) - return MapValue.second.get(); + LexicalScope *InlinedScope = LexicalScopeMap.lookup(InlinedAt); + if (InlinedScope) + return InlinedScope; DebugLoc InlinedLoc = DebugLoc::getFromDILocation(InlinedAt); - MapValue.second = - make_unique(getOrCreateLexicalScope(InlinedLoc), - DIDescriptor(Scope), InlinedAt, false); - InlinedLexicalScopeMap[InlinedLoc] = MapValue.second.get(); - return MapValue.second.get(); + InlinedScope = new LexicalScope(getOrCreateLexicalScope(InlinedLoc), + DIDescriptor(Scope), InlinedAt, false); + InlinedLexicalScopeMap[InlinedLoc] = InlinedScope; + LexicalScopeMap[InlinedAt] = InlinedScope; + return InlinedScope; } /// getOrCreateAbstractScope - Find or create an abstract lexical scope. @@ -193,11 +190,9 @@ LexicalScope *LexicalScopes::getOrCreateAbstractScope(const MDNode *N) { DIDescriptor Scope(N); if (Scope.isLexicalBlockFile()) Scope = DILexicalBlockFile(Scope).getScope(); - auto IterBool = AbstractScopeMap.insert( - std::make_pair(N, std::unique_ptr())); - auto &MapEntry = *IterBool.first; - if (!IterBool.second) - return MapEntry.second.get(); + LexicalScope *AScope = AbstractScopeMap.lookup(N); + if (AScope) + return AScope; LexicalScope *Parent = nullptr; if (Scope.isLexicalBlock()) { @@ -205,11 +200,11 @@ LexicalScope *LexicalScopes::getOrCreateAbstractScope(const MDNode *N) { DIDescriptor ParentDesc = DB.getContext(); Parent = getOrCreateAbstractScope(ParentDesc); } - MapEntry.second = - make_unique(Parent, DIDescriptor(N), nullptr, true); + AScope = new LexicalScope(Parent, DIDescriptor(N), nullptr, true); + AbstractScopeMap[N] = AScope; if (DIDescriptor(N).isSubprogram()) - AbstractScopesList.push_back(MapEntry.second.get()); - return MapEntry.second.get(); + AbstractScopesList.push_back(AScope); + return AScope; } /// constructScopeNest