6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 04:30:23 +00:00
Code Issues Projects Releases Wiki Activity

Clean up some unnecessary mutex guards.

Browse Source 
These were being used as unreferenced parameters to enforce that
the methods must not be called without holding a mutex, but all
of the methods in question were internal, and the methods were
only exposed through an interface whose entire purpose was to
serialize access to these structures, so expecting the methods
to be accessed under a mutex is reasonable enough.

Reviewed by: blaikie

Differential Revision: http://reviews.llvm.org/D4162

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@211054 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Zachary Turner 2014-06-16 20:54:28 +00:00
parent 163eb0990c
commit 4031acb4cd
2 changed files with 28 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/llvm/ExecutionEngine/ExecutionEngine.h
View File

@ -54,7 +54,7 @@ namespace object {
} }
/// \brief Helper class for helping synchronize access to the global address map /// \brief Helper class for helping synchronize access to the global address map
/// table. /// table. Access to this class should be serialized under a mutex.
class ExecutionEngineState { class ExecutionEngineState {
public: public:
struct AddressMapConfig : public ValueMapConfig<const GlobalValue*> { struct AddressMapConfig : public ValueMapConfig<const GlobalValue*> {
@ -84,19 +84,19 @@ private:
public: public:
ExecutionEngineState(ExecutionEngine &EE); ExecutionEngineState(ExecutionEngine &EE);
GlobalAddressMapTy &getGlobalAddressMap(const MutexGuard &) { GlobalAddressMapTy &getGlobalAddressMap() {
return GlobalAddressMap; return GlobalAddressMap;
} }
std::map<void*, AssertingVH<const GlobalValue> > & std::map<void*, AssertingVH<const GlobalValue> > &
getGlobalAddressReverseMap(const MutexGuard &) { getGlobalAddressReverseMap() {
return GlobalAddressReverseMap; return GlobalAddressReverseMap;
} }
/// \brief Erase an entry from the mapping table. /// \brief Erase an entry from the mapping table.
/// ///
/// \returns The address that \p ToUnmap was happed to. /// \returns The address that \p ToUnmap was happed to.
void *RemoveMapping(const MutexGuard &, const GlobalValue *ToUnmap); void *RemoveMapping(const GlobalValue *ToUnmap);
}; };
/// \brief Abstract interface for implementation execution of LLVM modules, /// \brief Abstract interface for implementation execution of LLVM modules,

49
lib/ExecutionEngine/ExecutionEngine.cpp
View File

@ -148,8 +148,7 @@ Function *ExecutionEngine::FindFunctionNamed(const char *FnName) {
} }
void *ExecutionEngineState::RemoveMapping(const MutexGuard &, void *ExecutionEngineState::RemoveMapping(const GlobalValue *ToUnmap) {
const GlobalValue *ToUnmap) {
GlobalAddressMapTy::iterator I = GlobalAddressMap.find(ToUnmap); GlobalAddressMapTy::iterator I = GlobalAddressMap.find(ToUnmap);
void *OldVal; void *OldVal;
@ -171,14 +170,14 @@ void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
DEBUG(dbgs() << "JIT: Map \'" << GV->getName() DEBUG(dbgs() << "JIT: Map \'" << GV->getName()
<< "\' to [" << Addr << "]\n";); << "\' to [" << Addr << "]\n";);
void *&CurVal = EEState.getGlobalAddressMap(locked)[GV]; void *&CurVal = EEState.getGlobalAddressMap()[GV];
assert((!CurVal || !Addr) && "GlobalMapping already established!"); assert((!CurVal || !Addr) && "GlobalMapping already established!");
CurVal = Addr; CurVal = Addr;
// If we are using the reverse mapping, add it too. // If we are using the reverse mapping, add it too.
if (!EEState.getGlobalAddressReverseMap(locked).empty()) { if (!EEState.getGlobalAddressReverseMap().empty()) {
AssertingVH<const GlobalValue> &V = AssertingVH<const GlobalValue> &V =
EEState.getGlobalAddressReverseMap(locked)[Addr]; EEState.getGlobalAddressReverseMap()[Addr];
assert((!V || !GV) && "GlobalMapping already established!"); assert((!V || !GV) && "GlobalMapping already established!");
V = GV; V = GV;
} }
@ -187,41 +186,41 @@ void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
void ExecutionEngine::clearAllGlobalMappings() { void ExecutionEngine::clearAllGlobalMappings() {
MutexGuard locked(lock); MutexGuard locked(lock);
EEState.getGlobalAddressMap(locked).clear(); EEState.getGlobalAddressMap().clear();
EEState.getGlobalAddressReverseMap(locked).clear(); EEState.getGlobalAddressReverseMap().clear();
} }
void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) { void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) {
MutexGuard locked(lock); MutexGuard locked(lock);
for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI) for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
EEState.RemoveMapping(locked, FI); EEState.RemoveMapping(FI);
for (Module::global_iterator GI = M->global_begin(), GE = M->global_end(); for (Module::global_iterator GI = M->global_begin(), GE = M->global_end();
GI != GE; ++GI) GI != GE; ++GI)
EEState.RemoveMapping(locked, GI); EEState.RemoveMapping(GI);
} }
void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) { void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) {
MutexGuard locked(lock); MutexGuard locked(lock);
ExecutionEngineState::GlobalAddressMapTy &Map = ExecutionEngineState::GlobalAddressMapTy &Map =
EEState.getGlobalAddressMap(locked); EEState.getGlobalAddressMap();
// Deleting from the mapping? // Deleting from the mapping?
if (!Addr) if (!Addr)
return EEState.RemoveMapping(locked, GV); return EEState.RemoveMapping(GV);
void *&CurVal = Map[GV]; void *&CurVal = Map[GV];
void *OldVal = CurVal; void *OldVal = CurVal;
if (CurVal && !EEState.getGlobalAddressReverseMap(locked).empty()) if (CurVal && !EEState.getGlobalAddressReverseMap().empty())
EEState.getGlobalAddressReverseMap(locked).erase(CurVal); EEState.getGlobalAddressReverseMap().erase(CurVal);
CurVal = Addr; CurVal = Addr;
// If we are using the reverse mapping, add it too. // If we are using the reverse mapping, add it too.
if (!EEState.getGlobalAddressReverseMap(locked).empty()) { if (!EEState.getGlobalAddressReverseMap().empty()) {
AssertingVH<const GlobalValue> &V = AssertingVH<const GlobalValue> &V =
EEState.getGlobalAddressReverseMap(locked)[Addr]; EEState.getGlobalAddressReverseMap()[Addr];
assert((!V || !GV) && "GlobalMapping already established!"); assert((!V || !GV) && "GlobalMapping already established!");
V = GV; V = GV;
} }
@ -232,25 +231,25 @@ void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) {
MutexGuard locked(lock); MutexGuard locked(lock);
ExecutionEngineState::GlobalAddressMapTy::iterator I = ExecutionEngineState::GlobalAddressMapTy::iterator I =
EEState.getGlobalAddressMap(locked).find(GV); EEState.getGlobalAddressMap().find(GV);
return I != EEState.getGlobalAddressMap(locked).end() ? I->second : nullptr; return I != EEState.getGlobalAddressMap().end() ? I->second : nullptr;
} }
const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) { const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) {
MutexGuard locked(lock); MutexGuard locked(lock);
// If we haven't computed the reverse mapping yet, do so first. // If we haven't computed the reverse mapping yet, do so first.
if (EEState.getGlobalAddressReverseMap(locked).empty()) { if (EEState.getGlobalAddressReverseMap().empty()) {
for (ExecutionEngineState::GlobalAddressMapTy::iterator for (ExecutionEngineState::GlobalAddressMapTy::iterator
I = EEState.getGlobalAddressMap(locked).begin(), I = EEState.getGlobalAddressMap().begin(),
E = EEState.getGlobalAddressMap(locked).end(); I != E; ++I) E = EEState.getGlobalAddressMap().end(); I != E; ++I)
EEState.getGlobalAddressReverseMap(locked).insert(std::make_pair( EEState.getGlobalAddressReverseMap().insert(std::make_pair(
I->second, I->first)); I->second, I->first));
} }
std::map<void *, AssertingVH<const GlobalValue> >::iterator I = std::map<void *, AssertingVH<const GlobalValue> >::iterator I =
EEState.getGlobalAddressReverseMap(locked).find(Addr); EEState.getGlobalAddressReverseMap().find(Addr);
return I != EEState.getGlobalAddressReverseMap(locked).end() ? I->second : nullptr; return I != EEState.getGlobalAddressReverseMap().end() ? I->second : nullptr;
} }
namespace { namespace {
@ -557,7 +556,7 @@ void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) {
return getPointerToFunction(F); return getPointerToFunction(F);
MutexGuard locked(lock); MutexGuard locked(lock);
if (void *P = EEState.getGlobalAddressMap(locked)[GV]) if (void *P = EEState.getGlobalAddressMap()[GV])
return P; return P;
// Global variable might have been added since interpreter started. // Global variable might have been added since interpreter started.
@ -567,7 +566,7 @@ void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) {
else else
llvm_unreachable("Global hasn't had an address allocated yet!"); llvm_unreachable("Global hasn't had an address allocated yet!");
return EEState.getGlobalAddressMap(locked)[GV]; return EEState.getGlobalAddressMap()[GV];
} }
/// \brief Converts a Constant* into a GenericValue, including handling of /// \brief Converts a Constant* into a GenericValue, including handling of