mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-29 13:29:28 +00:00
into their new header subdirectory: include/llvm/IR. This matches the directory structure of lib, and begins to correct a long standing point of file layout clutter in LLVM. There are still more header files to move here, but I wanted to handle them in separate commits to make tracking what files make sense at each layer easier. The only really questionable files here are the target intrinsic tablegen files. But that's a battle I'd rather not fight today. I've updated both CMake and Makefile build systems (I think, and my tests think, but I may have missed something). I've also re-sorted the includes throughout the project. I'll be committing updates to Clang, DragonEgg, and Polly momentarily. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171366 91177308-0d34-0410-b5e6-96231b3b80d8
301 lines
10 KiB
C++
301 lines
10 KiB
C++
//===- TypeBasedAliasAnalysis.cpp - Type-Based 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 TypeBasedAliasAnalysis pass, which implements
|
|
// metadata-based TBAA.
|
|
//
|
|
// In LLVM IR, memory does not have types, so LLVM's own type system is not
|
|
// suitable for doing TBAA. Instead, metadata is added to the IR to describe
|
|
// a type system of a higher level language. This can be used to implement
|
|
// typical C/C++ TBAA, but it can also be used to implement custom alias
|
|
// analysis behavior for other languages.
|
|
//
|
|
// The current metadata format is very simple. TBAA MDNodes have up to
|
|
// three fields, e.g.:
|
|
// !0 = metadata !{ metadata !"an example type tree" }
|
|
// !1 = metadata !{ metadata !"int", metadata !0 }
|
|
// !2 = metadata !{ metadata !"float", metadata !0 }
|
|
// !3 = metadata !{ metadata !"const float", metadata !2, i64 1 }
|
|
//
|
|
// The first field is an identity field. It can be any value, usually
|
|
// an MDString, which uniquely identifies the type. The most important
|
|
// name in the tree is the name of the root node. Two trees with
|
|
// different root node names are entirely disjoint, even if they
|
|
// have leaves with common names.
|
|
//
|
|
// The second field identifies the type's parent node in the tree, or
|
|
// is null or omitted for a root node. A type is considered to alias
|
|
// all of its descendants and all of its ancestors in the tree. Also,
|
|
// a type is considered to alias all types in other trees, so that
|
|
// bitcode produced from multiple front-ends is handled conservatively.
|
|
//
|
|
// If the third field is present, it's an integer which if equal to 1
|
|
// indicates that the type is "constant" (meaning pointsToConstantMemory
|
|
// should return true; see
|
|
// http://llvm.org/docs/AliasAnalysis.html#OtherItfs).
|
|
//
|
|
// TODO: The current metadata format doesn't support struct
|
|
// fields. For example:
|
|
// struct X {
|
|
// double d;
|
|
// int i;
|
|
// };
|
|
// void foo(struct X *x, struct X *y, double *p) {
|
|
// *x = *y;
|
|
// *p = 0.0;
|
|
// }
|
|
// Struct X has a double member, so the store to *x can alias the store to *p.
|
|
// Currently it's not possible to precisely describe all the things struct X
|
|
// aliases, so struct assignments must use conservative TBAA nodes. There's
|
|
// no scheme for attaching metadata to @llvm.memcpy yet either.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#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 TBAA functionality. The same effect can also be
|
|
// achieved by stripping the !tbaa tags from IR, but this option is sometimes
|
|
// more convenient.
|
|
static cl::opt<bool> EnableTBAA("enable-tbaa", cl::init(true));
|
|
|
|
namespace {
|
|
/// TBAANode - 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 TBAANode {
|
|
const MDNode *Node;
|
|
|
|
public:
|
|
TBAANode() : Node(0) {}
|
|
explicit TBAANode(const MDNode *N) : Node(N) {}
|
|
|
|
/// getNode - Get the MDNode for this TBAANode.
|
|
const MDNode *getNode() const { return Node; }
|
|
|
|
/// getParent - Get this TBAANode's Alias tree parent.
|
|
TBAANode getParent() const {
|
|
if (Node->getNumOperands() < 2)
|
|
return TBAANode();
|
|
MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
|
|
if (!P)
|
|
return TBAANode();
|
|
// Ok, this node has a valid parent. Return it.
|
|
return TBAANode(P);
|
|
}
|
|
|
|
/// TypeIsImmutable - Test if this TBAANode represents a type for objects
|
|
/// which are not modified (by any means) in the context where this
|
|
/// AliasAnalysis is relevant.
|
|
bool TypeIsImmutable() const {
|
|
if (Node->getNumOperands() < 3)
|
|
return false;
|
|
ConstantInt *CI = dyn_cast<ConstantInt>(Node->getOperand(2));
|
|
if (!CI)
|
|
return false;
|
|
return CI->getValue()[0];
|
|
}
|
|
};
|
|
}
|
|
|
|
namespace {
|
|
/// TypeBasedAliasAnalysis - This is a simple alias analysis
|
|
/// implementation that uses TypeBased to answer queries.
|
|
class TypeBasedAliasAnalysis : public ImmutablePass,
|
|
public AliasAnalysis {
|
|
public:
|
|
static char ID; // Class identification, replacement for typeinfo
|
|
TypeBasedAliasAnalysis() : ImmutablePass(ID) {
|
|
initializeTypeBasedAliasAnalysisPass(*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;
|
|
}
|
|
|
|
bool Aliases(const MDNode *A, const MDNode *B) 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 TypeBasedAliasAnalysis::ID = 0;
|
|
INITIALIZE_AG_PASS(TypeBasedAliasAnalysis, AliasAnalysis, "tbaa",
|
|
"Type-Based Alias Analysis", false, true, false)
|
|
|
|
ImmutablePass *llvm::createTypeBasedAliasAnalysisPass() {
|
|
return new TypeBasedAliasAnalysis();
|
|
}
|
|
|
|
void
|
|
TypeBasedAliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.setPreservesAll();
|
|
AliasAnalysis::getAnalysisUsage(AU);
|
|
}
|
|
|
|
/// Aliases - Test whether the type represented by A may alias the
|
|
/// type represented by B.
|
|
bool
|
|
TypeBasedAliasAnalysis::Aliases(const MDNode *A,
|
|
const MDNode *B) const {
|
|
// Keep track of the root node for A and B.
|
|
TBAANode RootA, RootB;
|
|
|
|
// Climb the tree from A to see if we reach B.
|
|
for (TBAANode T(A); ; ) {
|
|
if (T.getNode() == B)
|
|
// B is an ancestor of A.
|
|
return true;
|
|
|
|
RootA = T;
|
|
T = T.getParent();
|
|
if (!T.getNode())
|
|
break;
|
|
}
|
|
|
|
// Climb the tree from B to see if we reach A.
|
|
for (TBAANode T(B); ; ) {
|
|
if (T.getNode() == A)
|
|
// A is an ancestor of B.
|
|
return true;
|
|
|
|
RootB = T;
|
|
T = T.getParent();
|
|
if (!T.getNode())
|
|
break;
|
|
}
|
|
|
|
// Neither node is an ancestor of the other.
|
|
|
|
// If they have different roots, they're part of different potentially
|
|
// unrelated type systems, so we must be conservative.
|
|
if (RootA.getNode() != RootB.getNode())
|
|
return true;
|
|
|
|
// If they have the same root, then we've proved there's no alias.
|
|
return false;
|
|
}
|
|
|
|
AliasAnalysis::AliasResult
|
|
TypeBasedAliasAnalysis::alias(const Location &LocA,
|
|
const Location &LocB) {
|
|
if (!EnableTBAA)
|
|
return AliasAnalysis::alias(LocA, LocB);
|
|
|
|
// Get the attached MDNodes. If either value lacks a tbaa MDNode, we must
|
|
// be conservative.
|
|
const MDNode *AM = LocA.TBAATag;
|
|
if (!AM) return AliasAnalysis::alias(LocA, LocB);
|
|
const MDNode *BM = LocB.TBAATag;
|
|
if (!BM) return AliasAnalysis::alias(LocA, LocB);
|
|
|
|
// If they may alias, chain to the next AliasAnalysis.
|
|
if (Aliases(AM, BM))
|
|
return AliasAnalysis::alias(LocA, LocB);
|
|
|
|
// Otherwise return a definitive result.
|
|
return NoAlias;
|
|
}
|
|
|
|
bool TypeBasedAliasAnalysis::pointsToConstantMemory(const Location &Loc,
|
|
bool OrLocal) {
|
|
if (!EnableTBAA)
|
|
return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
|
|
|
|
const MDNode *M = Loc.TBAATag;
|
|
if (!M) return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
|
|
|
|
// If this is an "immutable" type, we can assume the pointer is pointing
|
|
// to constant memory.
|
|
if (TBAANode(M).TypeIsImmutable())
|
|
return true;
|
|
|
|
return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
|
|
}
|
|
|
|
AliasAnalysis::ModRefBehavior
|
|
TypeBasedAliasAnalysis::getModRefBehavior(ImmutableCallSite CS) {
|
|
if (!EnableTBAA)
|
|
return AliasAnalysis::getModRefBehavior(CS);
|
|
|
|
ModRefBehavior Min = UnknownModRefBehavior;
|
|
|
|
// If this is an "immutable" type, we can assume the call doesn't write
|
|
// to memory.
|
|
if (const MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
|
|
if (TBAANode(M).TypeIsImmutable())
|
|
Min = OnlyReadsMemory;
|
|
|
|
return ModRefBehavior(AliasAnalysis::getModRefBehavior(CS) & Min);
|
|
}
|
|
|
|
AliasAnalysis::ModRefBehavior
|
|
TypeBasedAliasAnalysis::getModRefBehavior(const Function *F) {
|
|
// Functions don't have metadata. Just chain to the next implementation.
|
|
return AliasAnalysis::getModRefBehavior(F);
|
|
}
|
|
|
|
AliasAnalysis::ModRefResult
|
|
TypeBasedAliasAnalysis::getModRefInfo(ImmutableCallSite CS,
|
|
const Location &Loc) {
|
|
if (!EnableTBAA)
|
|
return AliasAnalysis::getModRefInfo(CS, Loc);
|
|
|
|
if (const MDNode *L = Loc.TBAATag)
|
|
if (const MDNode *M =
|
|
CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
|
|
if (!Aliases(L, M))
|
|
return NoModRef;
|
|
|
|
return AliasAnalysis::getModRefInfo(CS, Loc);
|
|
}
|
|
|
|
AliasAnalysis::ModRefResult
|
|
TypeBasedAliasAnalysis::getModRefInfo(ImmutableCallSite CS1,
|
|
ImmutableCallSite CS2) {
|
|
if (!EnableTBAA)
|
|
return AliasAnalysis::getModRefInfo(CS1, CS2);
|
|
|
|
if (const MDNode *M1 =
|
|
CS1.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
|
|
if (const MDNode *M2 =
|
|
CS2.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
|
|
if (!Aliases(M1, M2))
|
|
return NoModRef;
|
|
|
|
return AliasAnalysis::getModRefInfo(CS1, CS2);
|
|
}
|