mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-29 10:32:47 +00:00
Revert "Try simplifying LexicalScopes ownership again."
Speculatively reverting due to a suspicious failure on a Windows
buildbot.
This reverts commit 10c37a012e.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@208131 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Blaikie
parent
d2ba53bdaa
commit
ccad744d4a
@ -25,12 +25,12 @@
|
||||
#include "llvm/IR/Metadata.h"
|
||||
#include "llvm/IR/ValueHandle.h"
|
||||
#include <utility>
|
||||
#include <unordered_map>
|
||||
namespace llvm {
|
||||
|
||||
class MachineInstr;
|
||||
class MachineBasicBlock;
|
||||
class MachineFunction;
|
||||
class LexicalScope;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// InsnRange - This is used to track range of instructions with identical
|
||||
@ -38,6 +38,121 @@ class MachineFunction;
|
||||
///
|
||||
typedef std::pair<const MachineInstr *, const MachineInstr *> InsnRange;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// LexicalScopes - This class provides interface to collect and use lexical
|
||||
/// scoping information from machine instruction.
|
||||
///
|
||||
class LexicalScopes {
|
||||
public:
|
||||
LexicalScopes() : MF(nullptr), CurrentFnLexicalScope(nullptr) {}
|
||||
~LexicalScopes();
|
||||
|
||||
/// initialize - Scan machine function and constuct lexical scope nest, resets
|
||||
/// the instance if necessary.
|
||||
void initialize(const MachineFunction &);
|
||||
|
||||
/// releaseMemory - release memory.
|
||||
void reset();
|
||||
|
||||
/// empty - Return true if there is any lexical scope information available.
|
||||
bool empty() { return CurrentFnLexicalScope == nullptr; }
|
||||
|
||||
/// isCurrentFunctionScope - Return true if given lexical scope represents
|
||||
/// current function.
|
||||
bool isCurrentFunctionScope(const LexicalScope *LS) {
|
||||
return LS == CurrentFnLexicalScope;
|
||||
}
|
||||
|
||||
/// getCurrentFunctionScope - Return lexical scope for the current function.
|
||||
LexicalScope *getCurrentFunctionScope() const {
|
||||
return CurrentFnLexicalScope;
|
||||
}
|
||||
|
||||
/// getMachineBasicBlocks - Populate given set using machine basic blocks
|
||||
/// which have machine instructions that belong to lexical scope identified by
|
||||
/// DebugLoc.
|
||||
void getMachineBasicBlocks(DebugLoc DL,
|
||||
SmallPtrSet<const MachineBasicBlock *, 4> &MBBs);
|
||||
|
||||
/// dominates - Return true if DebugLoc's lexical scope dominates at least one
|
||||
/// machine instruction's lexical scope in a given machine basic block.
|
||||
bool dominates(DebugLoc DL, MachineBasicBlock *MBB);
|
||||
|
||||
/// findLexicalScope - Find lexical scope, either regular or inlined, for the
|
||||
/// given DebugLoc. Return NULL if not found.
|
||||
LexicalScope *findLexicalScope(DebugLoc DL);
|
||||
|
||||
/// getAbstractScopesList - Return a reference to list of abstract scopes.
|
||||
ArrayRef<LexicalScope *> getAbstractScopesList() const {
|
||||
return AbstractScopesList;
|
||||
}
|
||||
|
||||
/// findAbstractScope - Find an abstract scope or return NULL.
|
||||
LexicalScope *findAbstractScope(const MDNode *N) {
|
||||
return AbstractScopeMap.lookup(N);
|
||||
}
|
||||
|
||||
/// findInlinedScope - Find an inlined scope for the given DebugLoc or return
|
||||
/// NULL.
|
||||
LexicalScope *findInlinedScope(DebugLoc DL) {
|
||||
return InlinedLexicalScopeMap.lookup(DL);
|
||||
}
|
||||
|
||||
/// findLexicalScope - Find regular lexical scope or return NULL.
|
||||
LexicalScope *findLexicalScope(const MDNode *N) {
|
||||
return LexicalScopeMap.lookup(N);
|
||||
}
|
||||
|
||||
/// dump - Print data structures to dbgs().
|
||||
void dump();
|
||||
|
||||
private:
|
||||
/// getOrCreateLexicalScope - Find lexical scope for the given DebugLoc. If
|
||||
/// not available then create new lexical scope.
|
||||
LexicalScope *getOrCreateLexicalScope(DebugLoc DL);
|
||||
|
||||
/// getOrCreateRegularScope - Find or create a regular lexical scope.
|
||||
LexicalScope *getOrCreateRegularScope(MDNode *Scope);
|
||||
|
||||
/// getOrCreateInlinedScope - Find or create an inlined lexical scope.
|
||||
LexicalScope *getOrCreateInlinedScope(MDNode *Scope, MDNode *InlinedAt);
|
||||
|
||||
/// getOrCreateAbstractScope - Find or create an abstract lexical scope.
|
||||
LexicalScope *getOrCreateAbstractScope(const MDNode *N);
|
||||
|
||||
/// extractLexicalScopes - Extract instruction ranges for each lexical scopes
|
||||
/// for the given machine function.
|
||||
void extractLexicalScopes(SmallVectorImpl<InsnRange> &MIRanges,
|
||||
DenseMap<const MachineInstr *, LexicalScope *> &M);
|
||||
void constructScopeNest(LexicalScope *Scope);
|
||||
void
|
||||
assignInstructionRanges(SmallVectorImpl<InsnRange> &MIRanges,
|
||||
DenseMap<const MachineInstr *, LexicalScope *> &M);
|
||||
|
||||
private:
|
||||
const MachineFunction *MF;
|
||||
|
||||
/// LexicalScopeMap - Tracks the scopes in the current function. Owns the
|
||||
/// contained LexicalScope*s.
|
||||
DenseMap<const MDNode *, LexicalScope *> LexicalScopeMap;
|
||||
|
||||
/// InlinedLexicalScopeMap - Tracks inlined function scopes in current
|
||||
/// function.
|
||||
DenseMap<DebugLoc, LexicalScope *> InlinedLexicalScopeMap;
|
||||
|
||||
/// AbstractScopeMap - These scopes are not included LexicalScopeMap.
|
||||
/// AbstractScopes owns its LexicalScope*s.
|
||||
DenseMap<const MDNode *, LexicalScope *> AbstractScopeMap;
|
||||
|
||||
/// AbstractScopesList - Tracks abstract scopes constructed while processing
|
||||
/// a function.
|
||||
SmallVector<LexicalScope *, 4> AbstractScopesList;
|
||||
|
||||
/// CurrentFnLexicalScope - Top level scope for the current function.
|
||||
///
|
||||
LexicalScope *CurrentFnLexicalScope;
|
||||
};
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// LexicalScope - This class is used to track scope information.
|
||||
///
|
||||
@ -129,122 +244,6 @@ private:
|
||||
// scope nesting.
|
||||
};
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// LexicalScopes - This class provides interface to collect and use lexical
|
||||
/// scoping information from machine instruction.
|
||||
///
|
||||
class LexicalScopes {
|
||||
public:
|
||||
LexicalScopes() : MF(nullptr), CurrentFnLexicalScope(nullptr) {}
|
||||
|
||||
/// initialize - Scan machine function and constuct lexical scope nest, resets
|
||||
/// the instance if necessary.
|
||||
void initialize(const MachineFunction &);
|
||||
|
||||
/// releaseMemory - release memory.
|
||||
void reset();
|
||||
|
||||
/// empty - Return true if there is any lexical scope information available.
|
||||
bool empty() { return CurrentFnLexicalScope == nullptr; }
|
||||
|
||||
/// isCurrentFunctionScope - Return true if given lexical scope represents
|
||||
/// current function.
|
||||
bool isCurrentFunctionScope(const LexicalScope *LS) {
|
||||
return LS == CurrentFnLexicalScope;
|
||||
}
|
||||
|
||||
/// getCurrentFunctionScope - Return lexical scope for the current function.
|
||||
LexicalScope *getCurrentFunctionScope() const {
|
||||
return CurrentFnLexicalScope;
|
||||
}
|
||||
|
||||
/// getMachineBasicBlocks - Populate given set using machine basic blocks
|
||||
/// which have machine instructions that belong to lexical scope identified by
|
||||
/// DebugLoc.
|
||||
void getMachineBasicBlocks(DebugLoc DL,
|
||||
SmallPtrSet<const MachineBasicBlock *, 4> &MBBs);
|
||||
|
||||
/// dominates - Return true if DebugLoc's lexical scope dominates at least one
|
||||
/// machine instruction's lexical scope in a given machine basic block.
|
||||
bool dominates(DebugLoc DL, MachineBasicBlock *MBB);
|
||||
|
||||
/// findLexicalScope - Find lexical scope, either regular or inlined, for the
|
||||
/// given DebugLoc. Return NULL if not found.
|
||||
LexicalScope *findLexicalScope(DebugLoc DL);
|
||||
|
||||
/// getAbstractScopesList - Return a reference to list of abstract scopes.
|
||||
ArrayRef<LexicalScope *> getAbstractScopesList() const {
|
||||
return AbstractScopesList;
|
||||
}
|
||||
|
||||
/// findAbstractScope - Find an abstract scope or return null.
|
||||
LexicalScope *findAbstractScope(const MDNode *N) {
|
||||
auto I = AbstractScopeMap.find(N);
|
||||
return I != AbstractScopeMap.end() ? &I->second : nullptr;
|
||||
}
|
||||
|
||||
/// findInlinedScope - Find an inlined scope for the given DebugLoc or return
|
||||
/// NULL.
|
||||
LexicalScope *findInlinedScope(DebugLoc DL) {
|
||||
return InlinedLexicalScopeMap.lookup(DL);
|
||||
}
|
||||
|
||||
/// findLexicalScope - Find regular lexical scope or return null.
|
||||
LexicalScope *findLexicalScope(const MDNode *N) {
|
||||
auto I = LexicalScopeMap.find(N);
|
||||
return I != LexicalScopeMap.end() ? &I->second : nullptr;
|
||||
}
|
||||
|
||||
/// dump - Print data structures to dbgs().
|
||||
void dump();
|
||||
|
||||
private:
|
||||
/// getOrCreateLexicalScope - Find lexical scope for the given DebugLoc. If
|
||||
/// not available then create new lexical scope.
|
||||
LexicalScope *getOrCreateLexicalScope(DebugLoc DL);
|
||||
|
||||
/// getOrCreateRegularScope - Find or create a regular lexical scope.
|
||||
LexicalScope *getOrCreateRegularScope(MDNode *Scope);
|
||||
|
||||
/// getOrCreateInlinedScope - Find or create an inlined lexical scope.
|
||||
LexicalScope *getOrCreateInlinedScope(MDNode *Scope, MDNode *InlinedAt);
|
||||
|
||||
/// getOrCreateAbstractScope - Find or create an abstract lexical scope.
|
||||
LexicalScope *getOrCreateAbstractScope(const MDNode *N);
|
||||
|
||||
/// extractLexicalScopes - Extract instruction ranges for each lexical scopes
|
||||
/// for the given machine function.
|
||||
void extractLexicalScopes(SmallVectorImpl<InsnRange> &MIRanges,
|
||||
DenseMap<const MachineInstr *, LexicalScope *> &M);
|
||||
void constructScopeNest(LexicalScope *Scope);
|
||||
void
|
||||
assignInstructionRanges(SmallVectorImpl<InsnRange> &MIRanges,
|
||||
DenseMap<const MachineInstr *, LexicalScope *> &M);
|
||||
|
||||
private:
|
||||
const MachineFunction *MF;
|
||||
|
||||
/// LexicalScopeMap - Tracks the scopes in the current function.
|
||||
// Use an unordered_map to ensure value pointer validity over insertion.
|
||||
std::unordered_map<const MDNode *, LexicalScope> LexicalScopeMap;
|
||||
|
||||
/// InlinedLexicalScopeMap - Tracks inlined function scopes in current
|
||||
/// function.
|
||||
DenseMap<DebugLoc, LexicalScope *> InlinedLexicalScopeMap;
|
||||
|
||||
/// AbstractScopeMap - These scopes are not included LexicalScopeMap.
|
||||
// Use an unordered_map to ensure value pointer validity over insertion.
|
||||
std::unordered_map<const MDNode *, LexicalScope> AbstractScopeMap;
|
||||
|
||||
/// AbstractScopesList - Tracks abstract scopes constructed while processing
|
||||
/// a function.
|
||||
SmallVector<LexicalScope *, 4> AbstractScopesList;
|
||||
|
||||
/// CurrentFnLexicalScope - Top level scope for the current function.
|
||||
///
|
||||
LexicalScope *CurrentFnLexicalScope;
|
||||
};
|
||||
|
||||
} // end llvm namespace
|
||||
|
||||
#endif
|
||||
|
||||
@ -26,12 +26,15 @@ using namespace llvm;
|
||||
|
||||
#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();
|
||||
DeleteContainerSeconds(LexicalScopeMap);
|
||||
DeleteContainerSeconds(AbstractScopeMap);
|
||||
InlinedLexicalScopeMap.clear();
|
||||
AbstractScopesList.clear();
|
||||
}
|
||||
@ -121,7 +124,7 @@ LexicalScope *LexicalScopes::findLexicalScope(DebugLoc DL) {
|
||||
|
||||
if (IA)
|
||||
return InlinedLexicalScopeMap.lookup(DebugLoc::getFromDILocation(IA));
|
||||
return findLexicalScope(Scope);
|
||||
return LexicalScopeMap.lookup(Scope);
|
||||
}
|
||||
|
||||
/// getOrCreateLexicalScope - Find lexical scope for the given DebugLoc. If
|
||||
@ -149,40 +152,35 @@ LexicalScope *LexicalScopes::getOrCreateRegularScope(MDNode *Scope) {
|
||||
D = DIDescriptor(Scope);
|
||||
}
|
||||
|
||||
auto I = LexicalScopeMap.find(Scope);
|
||||
if (I != LexicalScopeMap.end())
|
||||
return &I->second;
|
||||
LexicalScope *WScope = LexicalScopeMap.lookup(Scope);
|
||||
if (WScope)
|
||||
return WScope;
|
||||
|
||||
LexicalScope *Parent = nullptr;
|
||||
if (D.isLexicalBlock())
|
||||
Parent = getOrCreateLexicalScope(DebugLoc::getFromDILexicalBlock(Scope));
|
||||
I = LexicalScopeMap.emplace(std::piecewise_construct,
|
||||
std::forward_as_tuple(Scope),
|
||||
std::forward_as_tuple(Parent, DIDescriptor(Scope),
|
||||
nullptr, false)).first;
|
||||
|
||||
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 = &I->second;
|
||||
CurrentFnLexicalScope = WScope;
|
||||
|
||||
return &I->second;
|
||||
return WScope;
|
||||
}
|
||||
|
||||
/// getOrCreateInlinedScope - Find or create an inlined lexical scope.
|
||||
LexicalScope *LexicalScopes::getOrCreateInlinedScope(MDNode *Scope,
|
||||
MDNode *InlinedAt) {
|
||||
auto I = LexicalScopeMap.find(InlinedAt);
|
||||
if (I != LexicalScopeMap.end())
|
||||
return &I->second;
|
||||
LexicalScope *InlinedScope = LexicalScopeMap.lookup(InlinedAt);
|
||||
if (InlinedScope)
|
||||
return InlinedScope;
|
||||
|
||||
DebugLoc InlinedLoc = DebugLoc::getFromDILocation(InlinedAt);
|
||||
I = LexicalScopeMap.emplace(std::piecewise_construct,
|
||||
std::forward_as_tuple(InlinedAt),
|
||||
std::forward_as_tuple(
|
||||
getOrCreateLexicalScope(InlinedLoc),
|
||||
DIDescriptor(Scope), InlinedAt, false)).first;
|
||||
InlinedLexicalScopeMap[InlinedLoc] = &I->second;
|
||||
return &I->second;
|
||||
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.
|
||||
@ -192,9 +190,9 @@ LexicalScope *LexicalScopes::getOrCreateAbstractScope(const MDNode *N) {
|
||||
DIDescriptor Scope(N);
|
||||
if (Scope.isLexicalBlockFile())
|
||||
Scope = DILexicalBlockFile(Scope).getScope();
|
||||
auto I = AbstractScopeMap.find(N);
|
||||
if (I != AbstractScopeMap.end())
|
||||
return &I->second;
|
||||
LexicalScope *AScope = AbstractScopeMap.lookup(N);
|
||||
if (AScope)
|
||||
return AScope;
|
||||
|
||||
LexicalScope *Parent = nullptr;
|
||||
if (Scope.isLexicalBlock()) {
|
||||
@ -202,13 +200,11 @@ LexicalScope *LexicalScopes::getOrCreateAbstractScope(const MDNode *N) {
|
||||
DIDescriptor ParentDesc = DB.getContext();
|
||||
Parent = getOrCreateAbstractScope(ParentDesc);
|
||||
}
|
||||
I = AbstractScopeMap.emplace(std::piecewise_construct,
|
||||
std::forward_as_tuple(N),
|
||||
std::forward_as_tuple(Parent, DIDescriptor(N),
|
||||
nullptr, true)).first;
|
||||
AScope = new LexicalScope(Parent, DIDescriptor(N), nullptr, true);
|
||||
AbstractScopeMap[N] = AScope;
|
||||
if (DIDescriptor(N).isSubprogram())
|
||||
AbstractScopesList.push_back(&I->second);
|
||||
return &I->second;
|
||||
AbstractScopesList.push_back(AScope);
|
||||
return AScope;
|
||||
}
|
||||
|
||||
/// constructScopeNest
|
||||
|
||||
Loading…
Reference in New Issue
Block a user