mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-26 07:29:55 +00:00
This requires a number of steps. 1) Move value_use_iterator into the Value class as an implementation detail 2) Change it to actually be a *Use* iterator rather than a *User* iterator. 3) Add an adaptor which is a User iterator that always looks through the Use to the User. 4) Wrap these in Value::use_iterator and Value::user_iterator typedefs. 5) Add the range adaptors as Value::uses() and Value::users(). 6) Update *all* of the callers to correctly distinguish between whether they wanted a use_iterator (and to explicitly dig out the User when needed), or a user_iterator which makes the Use itself totally opaque. Because #6 requires churning essentially everything that walked the Use-Def chains, I went ahead and added all of the range adaptors and switched them to range-based loops where appropriate. Also because the renaming requires at least churning every line of code, it didn't make any sense to split these up into multiple commits -- all of which would touch all of the same lies of code. The result is still not quite optimal. The Value::use_iterator is a nice regular iterator, but Value::user_iterator is an iterator over User*s rather than over the User objects themselves. As a consequence, it fits a bit awkwardly into the range-based world and it has the weird extra-dereferencing 'operator->' that so many of our iterators have. I think this could be fixed by providing something which transforms a range of T&s into a range of T*s, but that *can* be separated into another patch, and it isn't yet 100% clear whether this is the right move. However, this change gets us most of the benefit and cleans up a substantial amount of code around Use and User. =] git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@203364 91177308-0d34-0410-b5e6-96231b3b80d8
182 lines
6.7 KiB
C++
182 lines
6.7 KiB
C++
//===-- GlobalStatus.cpp - Compute status info for globals -----------------==//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/IR/BasicBlock.h"
|
|
#include "llvm/IR/CallSite.h"
|
|
#include "llvm/IR/GlobalVariable.h"
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
#include "llvm/Transforms/Utils/GlobalStatus.h"
|
|
|
|
using namespace llvm;
|
|
|
|
/// Return the stronger of the two ordering. If the two orderings are acquire
|
|
/// and release, then return AcquireRelease.
|
|
///
|
|
static AtomicOrdering strongerOrdering(AtomicOrdering X, AtomicOrdering Y) {
|
|
if (X == Acquire && Y == Release)
|
|
return AcquireRelease;
|
|
if (Y == Acquire && X == Release)
|
|
return AcquireRelease;
|
|
return (AtomicOrdering)std::max(X, Y);
|
|
}
|
|
|
|
/// It is safe to destroy a constant iff it is only used by constants itself.
|
|
/// Note that constants cannot be cyclic, so this test is pretty easy to
|
|
/// implement recursively.
|
|
///
|
|
bool llvm::isSafeToDestroyConstant(const Constant *C) {
|
|
if (isa<GlobalValue>(C))
|
|
return false;
|
|
|
|
for (const User *U : C->users())
|
|
if (const Constant *CU = dyn_cast<Constant>(U)) {
|
|
if (!isSafeToDestroyConstant(CU))
|
|
return false;
|
|
} else
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
static bool analyzeGlobalAux(const Value *V, GlobalStatus &GS,
|
|
SmallPtrSet<const PHINode *, 16> &PhiUsers) {
|
|
for (const Use &U : V->uses()) {
|
|
const User *UR = U.getUser();
|
|
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(UR)) {
|
|
GS.HasNonInstructionUser = true;
|
|
|
|
// If the result of the constantexpr isn't pointer type, then we won't
|
|
// know to expect it in various places. Just reject early.
|
|
if (!isa<PointerType>(CE->getType()))
|
|
return true;
|
|
|
|
if (analyzeGlobalAux(CE, GS, PhiUsers))
|
|
return true;
|
|
} else if (const Instruction *I = dyn_cast<Instruction>(UR)) {
|
|
if (!GS.HasMultipleAccessingFunctions) {
|
|
const Function *F = I->getParent()->getParent();
|
|
if (GS.AccessingFunction == 0)
|
|
GS.AccessingFunction = F;
|
|
else if (GS.AccessingFunction != F)
|
|
GS.HasMultipleAccessingFunctions = true;
|
|
}
|
|
if (const LoadInst *LI = dyn_cast<LoadInst>(I)) {
|
|
GS.IsLoaded = true;
|
|
// Don't hack on volatile loads.
|
|
if (LI->isVolatile())
|
|
return true;
|
|
GS.Ordering = strongerOrdering(GS.Ordering, LI->getOrdering());
|
|
} else if (const StoreInst *SI = dyn_cast<StoreInst>(I)) {
|
|
// Don't allow a store OF the address, only stores TO the address.
|
|
if (SI->getOperand(0) == V)
|
|
return true;
|
|
|
|
// Don't hack on volatile stores.
|
|
if (SI->isVolatile())
|
|
return true;
|
|
|
|
GS.Ordering = strongerOrdering(GS.Ordering, SI->getOrdering());
|
|
|
|
// If this is a direct store to the global (i.e., the global is a scalar
|
|
// value, not an aggregate), keep more specific information about
|
|
// stores.
|
|
if (GS.StoredType != GlobalStatus::Stored) {
|
|
if (const GlobalVariable *GV =
|
|
dyn_cast<GlobalVariable>(SI->getOperand(1))) {
|
|
Value *StoredVal = SI->getOperand(0);
|
|
|
|
if (Constant *C = dyn_cast<Constant>(StoredVal)) {
|
|
if (C->isThreadDependent()) {
|
|
// The stored value changes between threads; don't track it.
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (StoredVal == GV->getInitializer()) {
|
|
if (GS.StoredType < GlobalStatus::InitializerStored)
|
|
GS.StoredType = GlobalStatus::InitializerStored;
|
|
} else if (isa<LoadInst>(StoredVal) &&
|
|
cast<LoadInst>(StoredVal)->getOperand(0) == GV) {
|
|
if (GS.StoredType < GlobalStatus::InitializerStored)
|
|
GS.StoredType = GlobalStatus::InitializerStored;
|
|
} else if (GS.StoredType < GlobalStatus::StoredOnce) {
|
|
GS.StoredType = GlobalStatus::StoredOnce;
|
|
GS.StoredOnceValue = StoredVal;
|
|
} else if (GS.StoredType == GlobalStatus::StoredOnce &&
|
|
GS.StoredOnceValue == StoredVal) {
|
|
// noop.
|
|
} else {
|
|
GS.StoredType = GlobalStatus::Stored;
|
|
}
|
|
} else {
|
|
GS.StoredType = GlobalStatus::Stored;
|
|
}
|
|
}
|
|
} else if (isa<BitCastInst>(I)) {
|
|
if (analyzeGlobalAux(I, GS, PhiUsers))
|
|
return true;
|
|
} else if (isa<GetElementPtrInst>(I)) {
|
|
if (analyzeGlobalAux(I, GS, PhiUsers))
|
|
return true;
|
|
} else if (isa<SelectInst>(I)) {
|
|
if (analyzeGlobalAux(I, GS, PhiUsers))
|
|
return true;
|
|
} else if (const PHINode *PN = dyn_cast<PHINode>(I)) {
|
|
// PHI nodes we can check just like select or GEP instructions, but we
|
|
// have to be careful about infinite recursion.
|
|
if (PhiUsers.insert(PN)) // Not already visited.
|
|
if (analyzeGlobalAux(I, GS, PhiUsers))
|
|
return true;
|
|
} else if (isa<CmpInst>(I)) {
|
|
GS.IsCompared = true;
|
|
} else if (const MemTransferInst *MTI = dyn_cast<MemTransferInst>(I)) {
|
|
if (MTI->isVolatile())
|
|
return true;
|
|
if (MTI->getArgOperand(0) == V)
|
|
GS.StoredType = GlobalStatus::Stored;
|
|
if (MTI->getArgOperand(1) == V)
|
|
GS.IsLoaded = true;
|
|
} else if (const MemSetInst *MSI = dyn_cast<MemSetInst>(I)) {
|
|
assert(MSI->getArgOperand(0) == V && "Memset only takes one pointer!");
|
|
if (MSI->isVolatile())
|
|
return true;
|
|
GS.StoredType = GlobalStatus::Stored;
|
|
} else if (ImmutableCallSite C = I) {
|
|
if (!C.isCallee(&U))
|
|
return true;
|
|
GS.IsLoaded = true;
|
|
} else {
|
|
return true; // Any other non-load instruction might take address!
|
|
}
|
|
} else if (const Constant *C = dyn_cast<Constant>(UR)) {
|
|
GS.HasNonInstructionUser = true;
|
|
// We might have a dead and dangling constant hanging off of here.
|
|
if (!isSafeToDestroyConstant(C))
|
|
return true;
|
|
} else {
|
|
GS.HasNonInstructionUser = true;
|
|
// Otherwise must be some other user.
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool GlobalStatus::analyzeGlobal(const Value *V, GlobalStatus &GS) {
|
|
SmallPtrSet<const PHINode *, 16> PhiUsers;
|
|
return analyzeGlobalAux(V, GS, PhiUsers);
|
|
}
|
|
|
|
GlobalStatus::GlobalStatus()
|
|
: IsCompared(false), IsLoaded(false), StoredType(NotStored),
|
|
StoredOnceValue(0), AccessingFunction(0),
|
|
HasMultipleAccessingFunctions(false), HasNonInstructionUser(false),
|
|
Ordering(NotAtomic) {}
|