6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-29 10:32:47 +00:00
Code Issues Projects Releases Wiki Activity

Speculatively roll back r207724-r207726, which are code cleanup changes and

Browse Source 
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
This commit is contained in:
Richard Smith 2014-05-01 00:46:58 +00:00
parent 2b7e17bcbd
commit 953f250789
2 changed files with 29 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/llvm/CodeGen/LexicalScopes.h
View File

@ -25,7 +25,6 @@
#include "llvm/IR/Metadata.h"
#include "llvm/IR/ValueHandle.h"
#include <utility>
#include <memory>
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<const MDNode *, std::unique_ptr<LexicalScope>> LexicalScopeMap;
DenseMap<const MDNode *, LexicalScope *> 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<const MDNode *, std::unique_ptr<LexicalScope>> AbstractScopeMap;
DenseMap<const MDNode *, LexicalScope *> AbstractScopeMap;
/// AbstractScopesList - Tracks abstract scopes constructed while processing
/// a function.

55
lib/CodeGen/LexicalScopes.cpp
View File

@ -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<LexicalScope>()));
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<LexicalScope>(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<LexicalScope>()));
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<LexicalScope>(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<LexicalScope>()));
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<LexicalScope>(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