mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-25 00:29:20 +00:00
In the process of fixing the noalias parameter -> metadata conversion process that will take place during inlining (which will be committed soon, but not turned on by default), I have come to realize that the semantics provided by yesterday's commit are not really what we want. Here's why: void foo(noalias a, noalias b, noalias c, bool x) { *q = x ? a : b; *c = *q; } Generically, we know that *c does not alias with *a and with *b (so there is an 'and' in what we know we're not), and we know that *q might be derived from *a or from *b (so there is an 'or' in what we know that we are). So we do not want the semantics currently, where any noalias scope matching any alias.scope causes a NoAlias return. What we want to know is that the noalias scopes form a superset of the alias.scope list (meaning that all the things we know we're not is a superset of all of things the other instruction might be). Making that change, however, introduces a composibility problem. If we inline once, adding the noalias metadata, and then inline again adding more, and we append new scopes onto the noalias and alias.scope lists each time. But, this means that we could change what was a NoAlias result previously into a MayAlias result because we appended an additional scope onto one of the alias.scope lists. So, instead of giving scopes the ability to have parents (which I had borrowed from the TBAA implementation, but seems increasingly unlikely to be useful in practice), I've given them domains. The subset/superset condition now applies within each domain independently, and we only need it to hold in one domain. Each time we inline, we add the new scopes in a new scope domain, and everything now composes nicely. In addition, this simplifies the implementation. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213948 91177308-0d34-0410-b5e6-96231b3b80d8
248 lines
8.5 KiB
C++
248 lines
8.5 KiB
C++
//===- ScopedNoAliasAA.cpp - Scoped No-Alias Alias Analysis ---------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the ScopedNoAlias alias-analysis pass, which implements
|
|
// metadata-based scoped no-alias support.
|
|
//
|
|
// Alias-analysis scopes are defined by an id (which can be a string or some
|
|
// other metadata node), a domain node, and an optional descriptive string.
|
|
// A domain is defined by an id (which can be a string or some other metadata
|
|
// node), and an optional descriptive string.
|
|
//
|
|
// !dom0 = metadata !{ metadata !"domain of foo()" }
|
|
// !scope1 = metadata !{ metadata !scope1, metadata !dom0, metadata !"scope 1" }
|
|
// !scope2 = metadata !{ metadata !scope2, metadata !dom0, metadata !"scope 2" }
|
|
//
|
|
// Loads and stores can be tagged with an alias-analysis scope, and also, with
|
|
// a noalias tag for a specific scope:
|
|
//
|
|
// ... = load %ptr1, !alias.scope !{ !scope1 }
|
|
// ... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
|
|
//
|
|
// When evaluating an aliasing query, if one of the instructions is associated
|
|
// has a set of noalias scopes in some domain that is superset of the alias
|
|
// scopes in that domain of some other instruction, then the two memory
|
|
// accesses are assumed not to alias.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/Analysis/Passes.h"
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/Metadata.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
using namespace llvm;
|
|
|
|
// A handy option for disabling scoped no-alias functionality. The same effect
|
|
// can also be achieved by stripping the associated metadata tags from IR, but
|
|
// this option is sometimes more convenient.
|
|
static cl::opt<bool>
|
|
EnableScopedNoAlias("enable-scoped-noalias", cl::init(true));
|
|
|
|
namespace {
|
|
/// AliasScopeNode - This is a simple wrapper around an MDNode which provides
|
|
/// a higher-level interface by hiding the details of how alias analysis
|
|
/// information is encoded in its operands.
|
|
class AliasScopeNode {
|
|
const MDNode *Node;
|
|
|
|
public:
|
|
AliasScopeNode() : Node(0) {}
|
|
explicit AliasScopeNode(const MDNode *N) : Node(N) {}
|
|
|
|
/// getNode - Get the MDNode for this AliasScopeNode.
|
|
const MDNode *getNode() const { return Node; }
|
|
|
|
/// getDomain - Get the MDNode for this AliasScopeNode's domain.
|
|
const MDNode *getDomain() const {
|
|
if (Node->getNumOperands() < 2)
|
|
return nullptr;
|
|
return dyn_cast_or_null<MDNode>(Node->getOperand(1));
|
|
}
|
|
};
|
|
|
|
/// ScopedNoAliasAA - This is a simple alias analysis
|
|
/// implementation that uses scoped-noalias metadata to answer queries.
|
|
class ScopedNoAliasAA : public ImmutablePass, public AliasAnalysis {
|
|
public:
|
|
static char ID; // Class identification, replacement for typeinfo
|
|
ScopedNoAliasAA() : ImmutablePass(ID) {
|
|
initializeScopedNoAliasAAPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
virtual void initializePass() {
|
|
InitializeAliasAnalysis(this);
|
|
}
|
|
|
|
/// getAdjustedAnalysisPointer - This method is used when a pass implements
|
|
/// an analysis interface through multiple inheritance. If needed, it
|
|
/// should override this to adjust the this pointer as needed for the
|
|
/// specified pass info.
|
|
virtual void *getAdjustedAnalysisPointer(const void *PI) {
|
|
if (PI == &AliasAnalysis::ID)
|
|
return (AliasAnalysis*)this;
|
|
return this;
|
|
}
|
|
|
|
protected:
|
|
bool mayAliasInScopes(const MDNode *Scopes, const MDNode *NoAlias) const;
|
|
void collectMDInDomain(const MDNode *List, const MDNode *Domain,
|
|
SmallPtrSetImpl<const MDNode *> &Nodes) const;
|
|
|
|
private:
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
|
|
virtual AliasResult alias(const Location &LocA, const Location &LocB);
|
|
virtual bool pointsToConstantMemory(const Location &Loc, bool OrLocal);
|
|
virtual ModRefBehavior getModRefBehavior(ImmutableCallSite CS);
|
|
virtual ModRefBehavior getModRefBehavior(const Function *F);
|
|
virtual ModRefResult getModRefInfo(ImmutableCallSite CS,
|
|
const Location &Loc);
|
|
virtual ModRefResult getModRefInfo(ImmutableCallSite CS1,
|
|
ImmutableCallSite CS2);
|
|
};
|
|
} // End of anonymous namespace
|
|
|
|
// Register this pass...
|
|
char ScopedNoAliasAA::ID = 0;
|
|
INITIALIZE_AG_PASS(ScopedNoAliasAA, AliasAnalysis, "scoped-noalias",
|
|
"Scoped NoAlias Alias Analysis", false, true, false)
|
|
|
|
ImmutablePass *llvm::createScopedNoAliasAAPass() {
|
|
return new ScopedNoAliasAA();
|
|
}
|
|
|
|
void
|
|
ScopedNoAliasAA::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.setPreservesAll();
|
|
AliasAnalysis::getAnalysisUsage(AU);
|
|
}
|
|
|
|
void
|
|
ScopedNoAliasAA::collectMDInDomain(const MDNode *List, const MDNode *Domain,
|
|
SmallPtrSetImpl<const MDNode *> &Nodes) const {
|
|
for (unsigned i = 0, ie = List->getNumOperands(); i != ie; ++i)
|
|
if (const MDNode *MD = dyn_cast<MDNode>(List->getOperand(i)))
|
|
if (AliasScopeNode(MD).getDomain() == Domain)
|
|
Nodes.insert(MD);
|
|
}
|
|
|
|
bool
|
|
ScopedNoAliasAA::mayAliasInScopes(const MDNode *Scopes,
|
|
const MDNode *NoAlias) const {
|
|
if (!Scopes || !NoAlias)
|
|
return true;
|
|
|
|
// Collect the set of scope domains relevant to the noalias scopes.
|
|
SmallPtrSet<const MDNode *, 16> Domains;
|
|
for (unsigned i = 0, ie = NoAlias->getNumOperands(); i != ie; ++i)
|
|
if (const MDNode *NAMD = dyn_cast<MDNode>(NoAlias->getOperand(i)))
|
|
if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain())
|
|
Domains.insert(Domain);
|
|
|
|
// We alias unless, for some domain, the set of noalias scopes in that domain
|
|
// is a superset of the set of alias scopes in that domain.
|
|
for (const MDNode *Domain : Domains) {
|
|
SmallPtrSet<const MDNode *, 16> NANodes, ScopeNodes;
|
|
collectMDInDomain(NoAlias, Domain, NANodes);
|
|
collectMDInDomain(Scopes, Domain, ScopeNodes);
|
|
if (!ScopeNodes.size())
|
|
continue;
|
|
|
|
// To not alias, all of the nodes in ScopeNodes must be in NANodes.
|
|
bool FoundAll = true;
|
|
for (const MDNode *SMD : ScopeNodes)
|
|
if (!NANodes.count(SMD)) {
|
|
FoundAll = false;
|
|
break;
|
|
}
|
|
|
|
if (FoundAll)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
AliasAnalysis::AliasResult
|
|
ScopedNoAliasAA::alias(const Location &LocA, const Location &LocB) {
|
|
if (!EnableScopedNoAlias)
|
|
return AliasAnalysis::alias(LocA, LocB);
|
|
|
|
// Get the attached MDNodes.
|
|
const MDNode *AScopes = LocA.AATags.Scope,
|
|
*BScopes = LocB.AATags.Scope;
|
|
|
|
const MDNode *ANoAlias = LocA.AATags.NoAlias,
|
|
*BNoAlias = LocB.AATags.NoAlias;
|
|
|
|
if (!mayAliasInScopes(AScopes, BNoAlias))
|
|
return NoAlias;
|
|
|
|
if (!mayAliasInScopes(BScopes, ANoAlias))
|
|
return NoAlias;
|
|
|
|
// If they may alias, chain to the next AliasAnalysis.
|
|
return AliasAnalysis::alias(LocA, LocB);
|
|
}
|
|
|
|
bool ScopedNoAliasAA::pointsToConstantMemory(const Location &Loc,
|
|
bool OrLocal) {
|
|
return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
|
|
}
|
|
|
|
AliasAnalysis::ModRefBehavior
|
|
ScopedNoAliasAA::getModRefBehavior(ImmutableCallSite CS) {
|
|
return AliasAnalysis::getModRefBehavior(CS);
|
|
}
|
|
|
|
AliasAnalysis::ModRefBehavior
|
|
ScopedNoAliasAA::getModRefBehavior(const Function *F) {
|
|
return AliasAnalysis::getModRefBehavior(F);
|
|
}
|
|
|
|
AliasAnalysis::ModRefResult
|
|
ScopedNoAliasAA::getModRefInfo(ImmutableCallSite CS, const Location &Loc) {
|
|
if (!EnableScopedNoAlias)
|
|
return AliasAnalysis::getModRefInfo(CS, Loc);
|
|
|
|
if (!mayAliasInScopes(Loc.AATags.Scope,
|
|
CS.getInstruction()->getMetadata(LLVMContext::MD_noalias)))
|
|
return NoModRef;
|
|
|
|
if (!mayAliasInScopes(
|
|
CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
|
|
Loc.AATags.NoAlias))
|
|
return NoModRef;
|
|
|
|
return AliasAnalysis::getModRefInfo(CS, Loc);
|
|
}
|
|
|
|
AliasAnalysis::ModRefResult
|
|
ScopedNoAliasAA::getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) {
|
|
if (!EnableScopedNoAlias)
|
|
return AliasAnalysis::getModRefInfo(CS1, CS2);
|
|
|
|
if (!mayAliasInScopes(
|
|
CS1.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
|
|
CS2.getInstruction()->getMetadata(LLVMContext::MD_noalias)))
|
|
return NoModRef;
|
|
|
|
if (!mayAliasInScopes(
|
|
CS2.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
|
|
CS1.getInstruction()->getMetadata(LLVMContext::MD_noalias)))
|
|
return NoModRef;
|
|
|
|
return AliasAnalysis::getModRefInfo(CS1, CS2);
|
|
}
|
|
|