[llvm] r275122 - [CFLAA] Simplify CFLGraphBuilder. NFC.
George Burgess IV via llvm-commits
llvm-commits at lists.llvm.org
Mon Jul 11 15:59:10 PDT 2016
Author: gbiv
Date: Mon Jul 11 17:59:09 2016
New Revision: 275122
URL: http://llvm.org/viewvc/llvm-project?rev=275122&view=rev
Log:
[CFLAA] Simplify CFLGraphBuilder. NFC.
This patch simplifies the graph builder by encoding nodes as {Value,
Dereference Level} pairs. This lets us kill edge types, and allows us to
get rid of hacks in StratifiedSets (like addAttrsBelow/...). This
simplification also allows us to remove InstantiatedRelations and
InstantiatedAttrs.
Patch by Jia Chen.
Differential Revision: http://reviews.llvm.org/D22080
Modified:
llvm/trunk/lib/Analysis/AliasAnalysisSummary.h
llvm/trunk/lib/Analysis/CFLGraph.h
llvm/trunk/lib/Analysis/CFLSteensAliasAnalysis.cpp
llvm/trunk/lib/Analysis/StratifiedSets.h
Modified: llvm/trunk/lib/Analysis/AliasAnalysisSummary.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/AliasAnalysisSummary.h?rev=275122&r1=275121&r2=275122&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/AliasAnalysisSummary.h (original)
+++ llvm/trunk/lib/Analysis/AliasAnalysisSummary.h Mon Jul 11 17:59:09 2016
@@ -35,6 +35,7 @@
#ifndef LLVM_ANALYSIS_ALIASANALYSISSUMMARY_H
#define LLVM_ANALYSIS_ALIASANALYSISSUMMARY_H
+#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/IR/CallSite.h"
@@ -166,6 +167,25 @@ struct InstantiatedAttr {
Optional<InstantiatedAttr> instantiateExternalAttribute(ExternalAttribute,
CallSite);
}
+
+template <> struct DenseMapInfo<cflaa::InstantiatedValue> {
+ static inline cflaa::InstantiatedValue getEmptyKey() {
+ return cflaa::InstantiatedValue{DenseMapInfo<Value *>::getEmptyKey(),
+ DenseMapInfo<unsigned>::getEmptyKey()};
+ }
+ static inline cflaa::InstantiatedValue getTombstoneKey() {
+ return cflaa::InstantiatedValue{DenseMapInfo<Value *>::getTombstoneKey(),
+ DenseMapInfo<unsigned>::getTombstoneKey()};
+ }
+ static unsigned getHashValue(const cflaa::InstantiatedValue &IV) {
+ return DenseMapInfo<std::pair<Value *, unsigned>>::getHashValue(
+ std::make_pair(IV.Val, IV.DerefLevel));
+ }
+ static bool isEqual(const cflaa::InstantiatedValue &LHS,
+ const cflaa::InstantiatedValue &RHS) {
+ return LHS.Val == RHS.Val && LHS.DerefLevel == RHS.DerefLevel;
+ }
+};
}
#endif
Modified: llvm/trunk/lib/Analysis/CFLGraph.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/CFLGraph.h?rev=275122&r1=275121&r2=275122&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/CFLGraph.h (original)
+++ llvm/trunk/lib/Analysis/CFLGraph.h Mon Jul 11 17:59:09 2016
@@ -16,45 +16,29 @@
#define LLVM_ANALYSIS_CFLGRAPH_H
#include "AliasAnalysisSummary.h"
-#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/IR/InstVisitor.h"
#include "llvm/IR/Instructions.h"
namespace llvm {
namespace cflaa {
-/// Edges can be one of four "weights" -- each weight must have an inverse
-/// weight (Assign has Assign; Reference has Dereference).
-enum class EdgeType {
- /// The weight assigned when assigning from or to a value. For example, in:
- /// %b = getelementptr %a, 0
- /// ...The relationships are %b assign %a, and %a assign %b. This used to be
- /// two edges, but having a distinction bought us nothing.
- Assign,
-
- /// The edge used when we have an edge going from some handle to a Value.
- /// Examples of this include:
- /// %b = load %a (%b Dereference %a)
- /// %b = extractelement %a, 0 (%a Dereference %b)
- Dereference,
-
- /// The edge used when our edge goes from a value to a handle that may have
- /// contained it at some point. Examples:
- /// %b = load %a (%a Reference %b)
- /// %b = extractelement %a, 0 (%b Reference %a)
- Reference
-};
/// \brief The Program Expression Graph (PEG) of CFL analysis
/// CFLGraph is auxiliary data structure used by CFL-based alias analysis to
/// describe flow-insensitive pointer-related behaviors. Given an LLVM function,
/// the main purpose of this graph is to abstract away unrelated facts and
/// translate the rest into a form that can be easily digested by CFL analyses.
+/// Each Node in the graph is an InstantiatedValue, and each edge represent a
+/// pointer assignment between InstantiatedValue. Pointer
+/// references/dereferences are not explicitly stored in the graph: we
+/// implicitly assume that for each node (X, I) it has a dereference edge to (X,
+/// I+1) and a reference edge to (X, I-1).
class CFLGraph {
- typedef Value *Node;
+public:
+ typedef InstantiatedValue Node;
struct Edge {
- EdgeType Type;
Node Other;
};
@@ -65,48 +49,56 @@ class CFLGraph {
AliasAttrs Attr;
};
- typedef DenseMap<Node, NodeInfo> NodeMap;
- NodeMap NodeImpls;
+ class ValueInfo {
+ std::vector<NodeInfo> Levels;
- // Gets the inverse of a given EdgeType.
- static EdgeType flipWeight(EdgeType Initial) {
- switch (Initial) {
- case EdgeType::Assign:
- return EdgeType::Assign;
- case EdgeType::Dereference:
- return EdgeType::Reference;
- case EdgeType::Reference:
- return EdgeType::Dereference;
+ public:
+ bool addNodeToLevel(unsigned Level) {
+ auto NumLevels = Levels.size();
+ if (NumLevels > Level)
+ return false;
+ Levels.resize(Level + 1);
+ return true;
+ }
+
+ NodeInfo &getNodeInfoAtLevel(unsigned Level) {
+ assert(Level < Levels.size());
+ return Levels[Level];
+ }
+ const NodeInfo &getNodeInfoAtLevel(unsigned Level) const {
+ assert(Level < Levels.size());
+ return Levels[Level];
}
- llvm_unreachable("Incomplete coverage of EdgeType enum");
- }
+
+ unsigned getNumLevels() const { return Levels.size(); }
+ };
+
+private:
+ typedef DenseMap<Value *, ValueInfo> ValueMap;
+ ValueMap ValueImpls;
const NodeInfo *getNode(Node N) const {
- auto Itr = NodeImpls.find(N);
- if (Itr == NodeImpls.end())
+ auto Itr = ValueImpls.find(N.Val);
+ if (Itr == ValueImpls.end() || Itr->second.getNumLevels() <= N.DerefLevel)
return nullptr;
- return &Itr->second;
+ return &Itr->second.getNodeInfoAtLevel(N.DerefLevel);
}
NodeInfo *getNode(Node N) {
- auto Itr = NodeImpls.find(N);
- if (Itr == NodeImpls.end())
+ auto Itr = ValueImpls.find(N.Val);
+ if (Itr == ValueImpls.end() || Itr->second.getNumLevels() <= N.DerefLevel)
return nullptr;
- return &Itr->second;
+ return &Itr->second.getNodeInfoAtLevel(N.DerefLevel);
}
- static Node nodeDeref(const NodeMap::value_type &P) { return P.first; }
- typedef std::pointer_to_unary_function<const NodeMap::value_type &, Node>
- NodeDerefFun;
-
public:
- typedef EdgeList::const_iterator const_edge_iterator;
- typedef mapped_iterator<NodeMap::const_iterator, NodeDerefFun>
- const_node_iterator;
-
- bool addNode(Node N) {
- return NodeImpls
- .insert(std::make_pair(N, NodeInfo{EdgeList(), getAttrNone()}))
- .second;
+ typedef ValueMap::const_iterator const_value_iterator;
+
+ bool addNode(Node N, AliasAttrs Attr = AliasAttrs()) {
+ assert(N.Val != nullptr);
+ auto &ValInfo = ValueImpls[N.Val];
+ auto Changed = ValInfo.addNodeToLevel(N.DerefLevel);
+ ValInfo.getNodeInfoAtLevel(N.DerefLevel).Attr |= Attr;
+ return Changed;
}
void addAttr(Node N, AliasAttrs Attr) {
@@ -115,14 +107,13 @@ public:
Info->Attr |= Attr;
}
- void addEdge(Node From, Node To, EdgeType Type) {
+ void addEdge(Node From, Node To, int64_t Offset = 0) {
auto *FromInfo = getNode(From);
assert(FromInfo != nullptr);
auto *ToInfo = getNode(To);
assert(ToInfo != nullptr);
- FromInfo->Edges.push_back(Edge{Type, To});
- ToInfo->Edges.push_back(Edge{flipWeight(Type), From});
+ FromInfo->Edges.push_back(Edge{To});
}
AliasAttrs attrFor(Node N) const {
@@ -131,21 +122,10 @@ public:
return Info->Attr;
}
- iterator_range<const_edge_iterator> edgesFor(Node N) const {
- auto *Info = getNode(N);
- assert(Info != nullptr);
- auto &Edges = Info->Edges;
- return make_range(Edges.begin(), Edges.end());
- }
-
- iterator_range<const_node_iterator> nodes() const {
- return make_range<const_node_iterator>(
- map_iterator(NodeImpls.begin(), NodeDerefFun(nodeDeref)),
- map_iterator(NodeImpls.end(), NodeDerefFun(nodeDeref)));
+ iterator_range<const_value_iterator> value_mappings() const {
+ return make_range<const_value_iterator>(ValueImpls.begin(),
+ ValueImpls.end());
}
-
- bool empty() const { return NodeImpls.empty(); }
- std::size_t size() const { return NodeImpls.size(); }
};
///\brief A builder class used to create CFLGraph instance from a given function
@@ -165,10 +145,6 @@ template <typename CFLAA> class CFLGraph
CFLGraph Graph;
SmallVector<Value *, 4> ReturnedValues;
- // Auxiliary structures used by the builder
- SmallVector<InstantiatedRelation, 8> InstantiatedRelations;
- SmallVector<InstantiatedAttr, 8> InstantiatedAttrs;
-
// Helper class
/// Gets the edges our graph should have, based on an Instruction*
class GetEdgesVisitor : public InstVisitor<GetEdgesVisitor, void> {
@@ -177,8 +153,6 @@ template <typename CFLAA> class CFLGraph
CFLGraph &Graph;
SmallVectorImpl<Value *> &ReturnValues;
- SmallVectorImpl<InstantiatedRelation> &InstantiatedRelations;
- SmallVectorImpl<InstantiatedAttr> &InstantiatedAttrs;
static bool hasUsefulEdges(ConstantExpr *CE) {
// ConstantExpr doesn't have terminators, invokes, or fences, so only
@@ -203,42 +177,47 @@ template <typename CFLAA> class CFLGraph
return false;
}
- void addNode(Value *Val) {
- assert(Val != nullptr);
- if (!Graph.addNode(Val))
- return;
-
- if (isa<GlobalValue>(Val)) {
- Graph.addAttr(Val, getGlobalOrArgAttrFromValue(*Val));
- // Currently we do not attempt to be smart on globals
- InstantiatedAttrs.push_back(
- InstantiatedAttr{InstantiatedValue{Val, 1}, getAttrUnknown()});
- } else if (auto CExpr = dyn_cast<ConstantExpr>(Val))
- if (hasUsefulEdges(CExpr))
- visitConstantExpr(CExpr);
- }
-
- void addNodeWithAttr(Value *Val, AliasAttrs Attr) {
- addNode(Val);
- Graph.addAttr(Val, Attr);
+ void addNode(Value *Val, AliasAttrs Attr = AliasAttrs()) {
+ assert(Val != nullptr && Val->getType()->isPointerTy());
+ if (auto GVal = dyn_cast<GlobalValue>(Val)) {
+ if (Graph.addNode(InstantiatedValue{GVal, 0},
+ getGlobalOrArgAttrFromValue(*GVal)))
+ Graph.addNode(InstantiatedValue{GVal, 1}, getAttrUnknown());
+ } else if (auto CExpr = dyn_cast<ConstantExpr>(Val)) {
+ if (hasUsefulEdges(CExpr)) {
+ if (Graph.addNode(InstantiatedValue{CExpr, 0}))
+ visitConstantExpr(CExpr);
+ }
+ } else
+ Graph.addNode(InstantiatedValue{Val, 0}, Attr);
}
- void addEdge(Value *From, Value *To, EdgeType Type) {
+ void addAssignEdge(Value *From, Value *To, int64_t Offset = 0) {
assert(From != nullptr && To != nullptr);
if (!From->getType()->isPointerTy() || !To->getType()->isPointerTy())
return;
addNode(From);
- if (To != From)
+ if (To != From) {
addNode(To);
- Graph.addEdge(From, To, Type);
+ Graph.addEdge(InstantiatedValue{From, 0}, InstantiatedValue{To, 0},
+ Offset);
+ }
+ }
+
+ void addDerefEdge(Value *From, Value *To) {
+ assert(From != nullptr && To != nullptr);
+ if (!From->getType()->isPointerTy() || !To->getType()->isPointerTy())
+ return;
+ addNode(From);
+ addNode(To);
+ Graph.addNode(InstantiatedValue{From, 1});
+ Graph.addEdge(InstantiatedValue{From, 1}, InstantiatedValue{To, 0});
}
public:
GetEdgesVisitor(CFLGraphBuilder &Builder)
: AA(Builder.Analysis), TLI(Builder.TLI), Graph(Builder.Graph),
- ReturnValues(Builder.ReturnedValues),
- InstantiatedRelations(Builder.InstantiatedRelations),
- InstantiatedAttrs(Builder.InstantiatedAttrs) {}
+ ReturnValues(Builder.ReturnedValues) {}
void visitInstruction(Instruction &) {
llvm_unreachable("Unsupported instruction encountered");
@@ -255,46 +234,46 @@ template <typename CFLAA> class CFLGraph
void visitPtrToIntInst(PtrToIntInst &Inst) {
auto *Ptr = Inst.getOperand(0);
- addNodeWithAttr(Ptr, getAttrEscaped());
+ addNode(Ptr, getAttrEscaped());
}
void visitIntToPtrInst(IntToPtrInst &Inst) {
auto *Ptr = &Inst;
- addNodeWithAttr(Ptr, getAttrUnknown());
+ addNode(Ptr, getAttrUnknown());
}
void visitCastInst(CastInst &Inst) {
auto *Src = Inst.getOperand(0);
- addEdge(Src, &Inst, EdgeType::Assign);
+ addAssignEdge(Src, &Inst);
}
void visitBinaryOperator(BinaryOperator &Inst) {
auto *Op1 = Inst.getOperand(0);
auto *Op2 = Inst.getOperand(1);
- addEdge(Op1, &Inst, EdgeType::Assign);
- addEdge(Op2, &Inst, EdgeType::Assign);
+ addAssignEdge(Op1, &Inst);
+ addAssignEdge(Op2, &Inst);
}
void visitAtomicCmpXchgInst(AtomicCmpXchgInst &Inst) {
auto *Ptr = Inst.getPointerOperand();
auto *Val = Inst.getNewValOperand();
- addEdge(Ptr, Val, EdgeType::Dereference);
+ addDerefEdge(Ptr, Val);
}
void visitAtomicRMWInst(AtomicRMWInst &Inst) {
auto *Ptr = Inst.getPointerOperand();
auto *Val = Inst.getValOperand();
- addEdge(Ptr, Val, EdgeType::Dereference);
+ addDerefEdge(Ptr, Val);
}
void visitPHINode(PHINode &Inst) {
for (Value *Val : Inst.incoming_values())
- addEdge(Val, &Inst, EdgeType::Assign);
+ addAssignEdge(Val, &Inst);
}
void visitGetElementPtrInst(GetElementPtrInst &Inst) {
auto *Op = Inst.getPointerOperand();
- addEdge(Op, &Inst, EdgeType::Assign);
+ addAssignEdge(Op, &Inst);
}
void visitSelectInst(SelectInst &Inst) {
@@ -305,22 +284,22 @@ template <typename CFLAA> class CFLGraph
auto *TrueVal = Inst.getTrueValue();
auto *FalseVal = Inst.getFalseValue();
- addEdge(TrueVal, &Inst, EdgeType::Assign);
- addEdge(FalseVal, &Inst, EdgeType::Assign);
+ addAssignEdge(TrueVal, &Inst);
+ addAssignEdge(FalseVal, &Inst);
}
- void visitAllocaInst(AllocaInst &Inst) { Graph.addNode(&Inst); }
+ void visitAllocaInst(AllocaInst &Inst) { addNode(&Inst); }
void visitLoadInst(LoadInst &Inst) {
auto *Ptr = Inst.getPointerOperand();
auto *Val = &Inst;
- addEdge(Val, Ptr, EdgeType::Reference);
+ addDerefEdge(Ptr, Val);
}
void visitStoreInst(StoreInst &Inst) {
auto *Ptr = Inst.getPointerOperand();
auto *Val = Inst.getValueOperand();
- addEdge(Ptr, Val, EdgeType::Dereference);
+ addDerefEdge(Ptr, Val);
}
void visitVAArgInst(VAArgInst &Inst) {
@@ -332,7 +311,7 @@ template <typename CFLAA> class CFLGraph
// For now, we'll handle this like a landingpad instruction (by placing
// the
// result in its own group, and having that group alias externals).
- addNodeWithAttr(&Inst, getAttrUnknown());
+ addNode(&Inst, getAttrUnknown());
}
static bool isFunctionExternal(Function *Fn) {
@@ -363,15 +342,18 @@ template <typename CFLAA> class CFLGraph
auto &RetParamRelations = Summary->RetParamRelations;
for (auto &Relation : RetParamRelations) {
auto IRelation = instantiateExternalRelation(Relation, CS);
- if (IRelation.hasValue())
- InstantiatedRelations.push_back(*IRelation);
+ if (IRelation.hasValue()) {
+ Graph.addNode(IRelation->From);
+ Graph.addNode(IRelation->To);
+ Graph.addEdge(IRelation->From, IRelation->To);
+ }
}
auto &RetParamAttributes = Summary->RetParamAttributes;
for (auto &Attribute : RetParamAttributes) {
auto IAttr = instantiateExternalAttribute(Attribute, CS);
if (IAttr.hasValue())
- InstantiatedAttrs.push_back(*IAttr);
+ Graph.addNode(IAttr->IValue, IAttr->Attr);
}
}
@@ -383,7 +365,8 @@ template <typename CFLAA> class CFLGraph
// Make sure all arguments and return value are added to the graph first
for (Value *V : CS.args())
- addNode(V);
+ if (V->getType()->isPointerTy())
+ addNode(V);
if (Inst->getType()->isPointerTy())
addNode(Inst);
@@ -413,23 +396,20 @@ template <typename CFLAA> class CFLGraph
for (Value *V : CS.args()) {
if (V->getType()->isPointerTy()) {
// The argument itself escapes.
- addNodeWithAttr(V, getAttrEscaped());
+ Graph.addAttr(InstantiatedValue{V, 0}, getAttrEscaped());
// The fate of argument memory is unknown. Note that since
- // AliasAttrs
- // is transitive with respect to dereference, we only need to
- // specify
- // it for the first-level memory.
- InstantiatedAttrs.push_back(
- InstantiatedAttr{InstantiatedValue{V, 1}, getAttrUnknown()});
+ // AliasAttrs is transitive with respect to dereference, we only
+ // need to specify it for the first-level memory.
+ Graph.addNode(InstantiatedValue{V, 1}, getAttrUnknown());
}
}
if (Inst->getType()->isPointerTy()) {
auto *Fn = CS.getCalledFunction();
if (Fn == nullptr || !Fn->doesNotAlias(0))
- // No need to call addNodeWithAttr() since we've added Inst at the
+ // No need to call addNode() since we've added Inst at the
// beginning of this function and we know it is not a global.
- Graph.addAttr(Inst, getAttrUnknown());
+ Graph.addAttr(InstantiatedValue{Inst, 0}, getAttrUnknown());
}
}
@@ -440,40 +420,40 @@ template <typename CFLAA> class CFLGraph
void visitExtractElementInst(ExtractElementInst &Inst) {
auto *Ptr = Inst.getVectorOperand();
auto *Val = &Inst;
- addEdge(Val, Ptr, EdgeType::Reference);
+ addDerefEdge(Ptr, Val);
}
void visitInsertElementInst(InsertElementInst &Inst) {
auto *Vec = Inst.getOperand(0);
auto *Val = Inst.getOperand(1);
- addEdge(Vec, &Inst, EdgeType::Assign);
- addEdge(&Inst, Val, EdgeType::Dereference);
+ addAssignEdge(Vec, &Inst);
+ addDerefEdge(&Inst, Val);
}
void visitLandingPadInst(LandingPadInst &Inst) {
// Exceptions come from "nowhere", from our analysis' perspective.
// So we place the instruction its own group, noting that said group may
// alias externals
- addNodeWithAttr(&Inst, getAttrUnknown());
+ addNode(&Inst, getAttrUnknown());
}
void visitInsertValueInst(InsertValueInst &Inst) {
auto *Agg = Inst.getOperand(0);
auto *Val = Inst.getOperand(1);
- addEdge(Agg, &Inst, EdgeType::Assign);
- addEdge(&Inst, Val, EdgeType::Dereference);
+ addAssignEdge(Agg, &Inst);
+ addDerefEdge(&Inst, Val);
}
void visitExtractValueInst(ExtractValueInst &Inst) {
auto *Ptr = Inst.getAggregateOperand();
- addEdge(&Inst, Ptr, EdgeType::Reference);
+ addDerefEdge(Ptr, &Inst);
}
void visitShuffleVectorInst(ShuffleVectorInst &Inst) {
auto *From1 = Inst.getOperand(0);
auto *From2 = Inst.getOperand(1);
- addEdge(From1, &Inst, EdgeType::Assign);
- addEdge(From2, &Inst, EdgeType::Assign);
+ addAssignEdge(From1, &Inst);
+ addAssignEdge(From2, &Inst);
}
void visitConstantExpr(ConstantExpr *CE) {
@@ -504,11 +484,10 @@ template <typename CFLAA> class CFLGraph
void addArgumentToGraph(Argument &Arg) {
if (Arg.getType()->isPointerTy()) {
- Graph.addNode(&Arg);
- Graph.addAttr(&Arg, getGlobalOrArgAttrFromValue(Arg));
+ Graph.addNode(InstantiatedValue{&Arg, 0},
+ getGlobalOrArgAttrFromValue(Arg));
// Pointees of a formal parameter is known to the caller
- InstantiatedAttrs.push_back(
- InstantiatedAttr{InstantiatedValue{&Arg, 1}, getAttrCaller()});
+ Graph.addNode(InstantiatedValue{&Arg, 1}, getAttrCaller());
}
}
@@ -518,19 +497,21 @@ template <typename CFLAA> class CFLGraph
// %0 = load i16* getelementptr ([1 x i16]* @a, 0, 0), align 2
// addInstructionToGraph would add both the `load` and `getelementptr`
// instructions to the graph appropriately.
- void addInstructionToGraph(Instruction &Inst) {
+ void addInstructionToGraph(GetEdgesVisitor &Visitor, Instruction &Inst) {
if (!hasUsefulEdges(&Inst))
return;
- GetEdgesVisitor(*this).visit(Inst);
+ Visitor.visit(Inst);
}
// Builds the graph needed for constructing the StratifiedSets for the given
// function
void buildGraphFrom(Function &Fn) {
+ GetEdgesVisitor Visitor(*this);
+
for (auto &Bb : Fn.getBasicBlockList())
for (auto &Inst : Bb.getInstList())
- addInstructionToGraph(Inst);
+ addInstructionToGraph(Visitor, Inst);
for (auto &Arg : Fn.args())
addArgumentToGraph(Arg);
@@ -546,12 +527,6 @@ public:
const SmallVector<Value *, 4> &getReturnValues() const {
return ReturnedValues;
}
- const SmallVector<InstantiatedRelation, 8> &getInstantiatedRelations() const {
- return InstantiatedRelations;
- }
- const SmallVector<InstantiatedAttr, 8> &getInstantiatedAttrs() const {
- return InstantiatedAttrs;
- }
};
}
}
Modified: llvm/trunk/lib/Analysis/CFLSteensAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/CFLSteensAliasAnalysis.cpp?rev=275122&r1=275121&r2=275122&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/CFLSteensAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/CFLSteensAliasAnalysis.cpp Mon Jul 11 17:59:09 2016
@@ -67,14 +67,16 @@ CFLSteensAAResult::~CFLSteensAAResult()
/// Information we have about a function and would like to keep around.
class CFLSteensAAResult::FunctionInfo {
- StratifiedSets<Value *> Sets;
+ StratifiedSets<InstantiatedValue> Sets;
AliasSummary Summary;
public:
FunctionInfo(Function &Fn, const SmallVectorImpl<Value *> &RetVals,
- StratifiedSets<Value *> S);
+ StratifiedSets<InstantiatedValue> S);
- const StratifiedSets<Value *> &getStratifiedSets() const { return Sets; }
+ const StratifiedSets<InstantiatedValue> &getStratifiedSets() const {
+ return Sets;
+ }
const AliasSummary &getAliasSummary() const { return Summary; }
};
@@ -84,21 +86,10 @@ static Optional<Function *> parentFuncti
const StratifiedIndex StratifiedLink::SetSentinel =
std::numeric_limits<StratifiedIndex>::max();
-namespace {
-
-/// StratifiedSets call for knowledge of "direction", so this is how we
-/// represent that locally.
-enum class Level { Same, Above, Below };
-}
-
//===----------------------------------------------------------------------===//
// Function declarations that require types defined in the namespace above
//===----------------------------------------------------------------------===//
-/// Gets the "Level" that one should travel in StratifiedSets
-/// given an EdgeType.
-static Level directionOfEdgeType(EdgeType);
-
/// Determines whether it would be pointless to add the given Value to our sets.
static bool canSkipAddingToSets(Value *Val);
@@ -113,18 +104,6 @@ static Optional<Function *> parentFuncti
return None;
}
-static Level directionOfEdgeType(EdgeType Weight) {
- switch (Weight) {
- case EdgeType::Reference:
- return Level::Above;
- case EdgeType::Dereference:
- return Level::Below;
- case EdgeType::Assign:
- return Level::Same;
- }
- llvm_unreachable("Incomplete switch coverage");
-}
-
static bool canSkipAddingToSets(Value *Val) {
// Constants can share instances, which may falsely unify multiple
// sets, e.g. in
@@ -148,7 +127,7 @@ static bool canSkipAddingToSets(Value *V
CFLSteensAAResult::FunctionInfo::FunctionInfo(
Function &Fn, const SmallVectorImpl<Value *> &RetVals,
- StratifiedSets<Value *> S)
+ StratifiedSets<InstantiatedValue> S)
: Sets(std::move(S)) {
// Historically, an arbitrary upper-bound of 50 args was selected. We may want
// to remove this if it doesn't really matter in practice.
@@ -197,7 +176,7 @@ CFLSteensAAResult::FunctionInfo::Functio
for (auto *RetVal : RetVals) {
assert(RetVal != nullptr);
assert(RetVal->getType()->isPointerTy());
- auto RetInfo = Sets.find(RetVal);
+ auto RetInfo = Sets.find(InstantiatedValue{RetVal, 0});
if (RetInfo.hasValue())
AddToRetParamRelations(0, RetInfo->Index);
}
@@ -206,7 +185,7 @@ CFLSteensAAResult::FunctionInfo::Functio
unsigned I = 0;
for (auto &Param : Fn.args()) {
if (Param.getType()->isPointerTy()) {
- auto ParamInfo = Sets.find(&Param);
+ auto ParamInfo = Sets.find(InstantiatedValue{&Param, 0});
if (ParamInfo.hasValue())
AddToRetParamRelations(I + 1, ParamInfo->Index);
}
@@ -217,62 +196,41 @@ CFLSteensAAResult::FunctionInfo::Functio
// Builds the graph + StratifiedSets for a function.
CFLSteensAAResult::FunctionInfo CFLSteensAAResult::buildSetsFrom(Function *Fn) {
CFLGraphBuilder<CFLSteensAAResult> GraphBuilder(*this, TLI, *Fn);
- StratifiedSetsBuilder<Value *> SetBuilder;
+ StratifiedSetsBuilder<InstantiatedValue> SetBuilder;
+ // Add all CFLGraph nodes and all Dereference edges to StratifiedSets
auto &Graph = GraphBuilder.getCFLGraph();
- SmallVector<Value *, 16> Worklist;
- for (auto Node : Graph.nodes())
- Worklist.push_back(Node);
-
- while (!Worklist.empty()) {
- auto *CurValue = Worklist.pop_back_val();
- SetBuilder.add(CurValue);
- if (canSkipAddingToSets(CurValue))
+ for (const auto &Mapping : Graph.value_mappings()) {
+ auto Val = Mapping.first;
+ if (canSkipAddingToSets(Val))
continue;
+ auto &ValueInfo = Mapping.second;
- auto Attr = Graph.attrFor(CurValue);
- SetBuilder.noteAttributes(CurValue, Attr);
-
- for (const auto &Edge : Graph.edgesFor(CurValue)) {
- auto Label = Edge.Type;
- auto *OtherValue = Edge.Other;
-
- if (canSkipAddingToSets(OtherValue))
- continue;
-
- bool Added;
- switch (directionOfEdgeType(Label)) {
- case Level::Above:
- Added = SetBuilder.addAbove(CurValue, OtherValue);
- break;
- case Level::Below:
- Added = SetBuilder.addBelow(CurValue, OtherValue);
- break;
- case Level::Same:
- Added = SetBuilder.addWith(CurValue, OtherValue);
- break;
- }
-
- if (Added)
- Worklist.push_back(OtherValue);
+ assert(ValueInfo.getNumLevels() > 0);
+ SetBuilder.add(InstantiatedValue{Val, 0});
+ SetBuilder.noteAttributes(InstantiatedValue{Val, 0},
+ ValueInfo.getNodeInfoAtLevel(0).Attr);
+ for (unsigned I = 0, E = ValueInfo.getNumLevels() - 1; I < E; ++I) {
+ SetBuilder.add(InstantiatedValue{Val, I + 1});
+ SetBuilder.noteAttributes(InstantiatedValue{Val, I + 1},
+ ValueInfo.getNodeInfoAtLevel(I + 1).Attr);
+ SetBuilder.addBelow(InstantiatedValue{Val, I},
+ InstantiatedValue{Val, I + 1});
}
}
- // Special handling for interprocedural aliases
- for (auto &Edge : GraphBuilder.getInstantiatedRelations()) {
- auto FromVal = Edge.From.Val;
- auto ToVal = Edge.To.Val;
- SetBuilder.add(FromVal);
- SetBuilder.add(ToVal);
- SetBuilder.addBelowWith(FromVal, Edge.From.DerefLevel, ToVal,
- Edge.To.DerefLevel);
- }
+ // Add all assign edges to StratifiedSets
+ for (const auto &Mapping : Graph.value_mappings()) {
+ auto Val = Mapping.first;
+ if (canSkipAddingToSets(Val))
+ continue;
+ auto &ValueInfo = Mapping.second;
- // Special handling for interprocedural attributes
- for (auto &IPAttr : GraphBuilder.getInstantiatedAttrs()) {
- auto Val = IPAttr.IValue.Val;
- SetBuilder.add(Val);
- SetBuilder.addAttributesBelow(Val, IPAttr.IValue.DerefLevel, IPAttr.Attr);
+ for (unsigned I = 0, E = ValueInfo.getNumLevels(); I < E; ++I) {
+ auto Src = InstantiatedValue{Val, I};
+ for (auto &Edge : ValueInfo.getNodeInfoAtLevel(I).Edges)
+ SetBuilder.addWith(Src, Edge.Other);
+ }
}
return FunctionInfo(*Fn, GraphBuilder.getReturnValues(), SetBuilder.build());
@@ -349,11 +307,11 @@ AliasResult CFLSteensAAResult::query(con
assert(MaybeInfo.hasValue());
auto &Sets = MaybeInfo->getStratifiedSets();
- auto MaybeA = Sets.find(ValA);
+ auto MaybeA = Sets.find(InstantiatedValue{ValA, 0});
if (!MaybeA.hasValue())
return MayAlias;
- auto MaybeB = Sets.find(ValB);
+ auto MaybeB = Sets.find(InstantiatedValue{ValB, 0});
if (!MaybeB.hasValue())
return MayAlias;
Modified: llvm/trunk/lib/Analysis/StratifiedSets.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/StratifiedSets.h?rev=275122&r1=275121&r2=275122&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/StratifiedSets.h (original)
+++ llvm/trunk/lib/Analysis/StratifiedSets.h Mon Jul 11 17:59:09 2016
@@ -386,46 +386,12 @@ public:
return addAtMerging(ToAdd, Below);
}
- /// \brief Set the AliasAttrs of the set "Level"-levels below "Main". If
- /// there is no set below "Main", create one for it.
- void addAttributesBelow(const T &Main, unsigned Level, AliasAttrs Attr) {
- assert(has(Main));
- auto Index = *indexOf(Main);
- auto *Link = &linksAt(Index);
-
- for (unsigned I = 0; I < Level; ++I) {
- Index = Link->hasBelow() ? Link->getBelow() : addLinkBelow(Index);
- Link = &linksAt(Index);
- }
- Link->setAttrs(Attr);
- }
-
bool addWith(const T &Main, const T &ToAdd) {
assert(has(Main));
auto MainIndex = *indexOf(Main);
return addAtMerging(ToAdd, MainIndex);
}
- /// \brief Merge the set "MainBelow"-levels below "Main" and the set
- /// "ToAddBelow"-levels below "ToAdd".
- void addBelowWith(const T &Main, unsigned MainBelow, const T &ToAdd,
- unsigned ToAddBelow) {
- assert(has(Main));
- assert(has(ToAdd));
-
- auto GetIndexBelow = [&](StratifiedIndex Index, unsigned NumLevel) {
- for (unsigned I = 0; I < NumLevel; ++I) {
- auto Link = linksAt(Index);
- Index = Link.hasBelow() ? Link.getBelow() : addLinkBelow(Index);
- }
- return Index;
- };
- auto MainIndex = GetIndexBelow(*indexOf(Main), MainBelow);
- auto ToAddIndex = GetIndexBelow(*indexOf(ToAdd), ToAddBelow);
- if (&linksAt(MainIndex) != &linksAt(ToAddIndex))
- merge(MainIndex, ToAddIndex);
- }
-
void noteAttributes(const T &Main, AliasAttrs NewAttrs) {
assert(has(Main));
auto *Info = *get(Main);
@@ -545,6 +511,7 @@ private:
NewBelow.setAbove(LinksInto->Number);
}
+ LinksInto->setAttrs(LinksFrom->getAttrs());
LinksFrom->remapTo(LinksInto->Number);
}
More information about the llvm-commits
mailing list