50 #include <forward_list>
56 #define DEBUG_TYPE "cfl-aa"
66 template <
typename Inst>
81 std::numeric_limits<StratifiedIndex>::max();
85 typedef unsigned StratifiedAttr;
92 LLVM_CONSTEXPR unsigned AttrMaxNumArgs = AttrLastArgIndex - AttrFirstArgIndex;
100 enum class Level { Same, Above, Below };
141 : From(From), To(To), Weight(W), AdditionalAttrs(A) {}
145 struct FunctionInfo {
151 : Sets(std::move(S)), ReturnedValues(std::move(RV)) {}
154 struct CFLAliasAnalysis;
157 FunctionHandle(
Function *Fn, CFLAliasAnalysis *CFLAA)
159 assert(Fn !=
nullptr);
160 assert(CFLAA !=
nullptr);
163 ~FunctionHandle()
override {}
165 void deleted()
override { removeSelfFromCache(); }
166 void allUsesReplacedWith(
Value *)
override { removeSelfFromCache(); }
169 CFLAliasAnalysis *CFLAA;
171 void removeSelfFromCache();
182 std::forward_list<FunctionHandle> Handles;
191 ~CFLAliasAnalysis()
override {}
206 void evict(
Function *Fn) { Cache.erase(Fn); }
211 auto Iter = Cache.find(Fn);
212 if (Iter == Cache.end()) {
214 Iter = Cache.find(Fn);
215 assert(Iter != Cache.end());
216 assert(Iter->second.hasValue());
225 if (LocA.
Ptr == LocB.
Ptr) {
239 if (isa<Constant>(LocA.
Ptr) && isa<Constant>(LocB.
Ptr)) {
253 void FunctionHandle::removeSelfFromCache() {
254 assert(CFLAA !=
nullptr);
255 auto *Val = getValPtr();
256 CFLAA->evict(cast<Function>(Val));
261 class GetEdgesVisitor :
public InstVisitor<GetEdgesVisitor, void> {
262 CFLAliasAnalysis &AA;
267 : AA(AA), Output(Output) {}
275 Output.push_back(Edge(Ptr, Ptr, EdgeType::Assign, AttrUnknown));
280 Output.push_back(Edge(Ptr, Ptr, EdgeType::Assign, AttrUnknown));
283 void visitCastInst(
CastInst &Inst) {
285 Edge(&Inst, Inst.
getOperand(0), EdgeType::Assign, AttrNone));
291 Output.push_back(Edge(&Inst, Op1, EdgeType::Assign, AttrNone));
292 Output.push_back(Edge(&Inst, Op2, EdgeType::Assign, AttrNone));
298 Output.push_back(Edge(Ptr, Val, EdgeType::Dereference, AttrNone));
304 Output.push_back(Edge(Ptr, Val, EdgeType::Dereference, AttrNone));
307 void visitPHINode(
PHINode &Inst) {
309 Output.push_back(Edge(&Inst, Val, EdgeType::Assign, AttrNone));
315 Output.push_back(Edge(&Inst, Op, EdgeType::Assign, AttrNone));
317 Output.push_back(Edge(&Inst, *
I, EdgeType::Assign, AttrNone));
327 Output.push_back(Edge(&Inst, TrueVal, EdgeType::Assign, AttrNone));
329 Output.push_back(Edge(&Inst, FalseVal, EdgeType::Assign, AttrNone));
334 void visitLoadInst(
LoadInst &Inst) {
337 Output.push_back(Edge(Val, Ptr, EdgeType::Reference, AttrNone));
343 Output.push_back(Edge(Ptr, Val, EdgeType::Dereference, AttrNone));
354 Output.push_back(Edge(Val, Val, EdgeType::Assign, AttrAll));
357 static bool isFunctionExternal(
Function *Fn) {
366 if (Index1 == Index2)
369 const auto *Current = &Sets.
getLink(Index1);
370 while (Current->hasBelow()) {
371 if (Current->Below == Index2)
373 Current = &Sets.
getLink(Current->Below);
376 Current = &Sets.
getLink(Index1);
377 while (Current->hasAbove()) {
378 if (Current->Above == Index2)
380 Current = &Sets.
getLink(Current->Above);
390 const unsigned ExpectedMaxArgs = 8;
391 const unsigned MaxSupportedArgs = 50;
392 assert(Fns.
size() > 0);
396 if (std::distance(Args.
begin(), Args.
end()) > (
int)MaxSupportedArgs)
400 for (
auto *Fn : Fns) {
401 if (isFunctionExternal(Fn) || Fn->
isVarArg())
403 auto &MaybeInfo = AA.ensureCached(Fn);
404 if (!MaybeInfo.hasValue())
410 for (
auto *Fn : Fns) {
411 auto &Info = *AA.ensureCached(Fn);
412 auto &Sets = Info.Sets;
413 auto &RetVals = Info.ReturnedValues;
419 if (!MaybeInfo.hasValue())
426 for (
unsigned I = 0, E = Parameters.
size();
I != E; ++
I) {
427 auto &ParamInfo = Parameters[
I];
428 auto &ArgVal = Arguments[
I];
429 bool AddEdge =
false;
431 for (
unsigned X = 0, XE = RetVals.size();
X != XE; ++
X) {
432 auto MaybeInfo = Sets.
find(RetVals[
X]);
433 if (!MaybeInfo.hasValue())
436 auto &RetInfo = *MaybeInfo;
440 getIndexRelation(Sets, ParamInfo.Index, RetInfo.Index);
441 if (MaybeRelation.hasValue()) {
443 Externals |= RetAttrs | ParamAttrs;
447 Output.push_back(Edge(FuncValue, ArgVal, EdgeType::Assign,
451 if (Parameters.
size() != Arguments.size())
460 for (
unsigned I = 0, E = Arguments.size();
I != E; ++
I) {
461 auto &MainVal = Arguments[
I];
462 auto &MainInfo = Parameters[
I];
464 for (
unsigned X =
I + 1; X != E; ++
X) {
465 auto &SubInfo = Parameters[
X];
466 auto &SubVal = Arguments[
X];
469 getIndexRelation(Sets, MainInfo.Index, SubInfo.Index);
471 if (!MaybeRelation.hasValue())
474 auto NewAttrs = SubAttrs | MainAttrs;
475 Output.push_back(Edge(MainVal, SubVal, EdgeType::Assign, NewAttrs));
482 template <
typename InstT>
void visitCallLikeInst(InstT &Inst) {
485 if (tryInterproceduralAnalysis(Targets, &Inst, Inst.arg_operands()))
491 for (
Value *V : Inst.arg_operands())
492 Output.push_back(Edge(&Inst, V, EdgeType::Assign, AttrAll));
495 void visitCallInst(
CallInst &Inst) { visitCallLikeInst(Inst); }
497 void visitInvokeInst(
InvokeInst &Inst) { visitCallLikeInst(Inst); }
507 Output.push_back(Edge(Val, Ptr, EdgeType::Reference, AttrNone));
513 Output.push_back(Edge(&Inst, Vec, EdgeType::Assign, AttrNone));
514 Output.push_back(Edge(&Inst, Val, EdgeType::Dereference, AttrNone));
521 Output.push_back(Edge(&Inst, &Inst, EdgeType::Assign, AttrAll));
527 Output.push_back(Edge(&Inst, Agg, EdgeType::Assign, AttrNone));
528 Output.push_back(Edge(&Inst, Val, EdgeType::Dereference, AttrNone));
533 Output.push_back(Edge(&Inst, Ptr, EdgeType::Reference, AttrNone));
539 Output.push_back(Edge(&Inst, From1, EdgeType::Assign, AttrNone));
540 Output.push_back(Edge(&Inst, From2, EdgeType::Assign, AttrNone));
548 #define HANDLE_INST(NUM, OPCODE, CLASS) \
549 case Instruction::OPCODE: \
550 visit##OPCODE(*(CLASS *)CE); \
552 #include "llvm/IR/Instruction.def"
567 class GetTargetValueVisitor
568 :
public InstVisitor<GetTargetValueVisitor, Value *> {
592 template <
typename EdgeTypeT>
class WeightedBidirectionalGraph {
594 typedef std::size_t Node;
597 const static Node StartNode = Node(0);
603 Edge(
const EdgeTypeT &W,
const Node &
N) : Weight(W),
Other(N) {}
606 return Weight == E.Weight &&
Other == E.Other;
613 std::vector<Edge> Edges;
616 std::vector<NodeImpl> NodeImpls;
618 bool inbounds(Node NodeIndex)
const {
return NodeIndex < NodeImpls.size(); }
620 const NodeImpl &getNode(Node
N)
const {
return NodeImpls[
N]; }
621 NodeImpl &getNode(Node
N) {
return NodeImpls[
N]; }
630 struct EdgeIterator :
public std::iterator<std::forward_iterator_tag,
631 std::tuple<EdgeTypeT, Node *>> {
632 EdgeIterator(
const typename std::vector<Edge>::const_iterator &Iter)
635 EdgeIterator(NodeImpl &Impl) : Current(Impl.
begin()) {}
637 EdgeIterator &operator++() {
642 EdgeIterator operator++(
int) {
643 EdgeIterator Copy(Current);
648 std::tuple<EdgeTypeT, Node> &
operator*() {
649 Store = std::make_tuple(Current->Weight, Current->Other);
654 return Current == Other.Current;
662 typename std::vector<Edge>::const_iterator Current;
663 std::tuple<EdgeTypeT, Node>
Store;
667 struct EdgeIterable {
668 EdgeIterable(
const std::vector<Edge> &Edges)
669 : BeginIter(Edges.
begin()), EndIter(Edges.
end()) {}
671 EdgeIterator
begin() {
return EdgeIterator(BeginIter); }
673 EdgeIterator
end() {
return EdgeIterator(EndIter); }
676 typename std::vector<Edge>::const_iterator BeginIter;
677 typename std::vector<Edge>::const_iterator EndIter;
682 WeightedBidirectionalGraph() {}
684 WeightedBidirectionalGraph(WeightedBidirectionalGraph<EdgeTypeT> &&
Other)
685 : NodeImpls(std::move(
Other.NodeImpls)) {}
687 WeightedBidirectionalGraph<EdgeTypeT> &
688 operator=(WeightedBidirectionalGraph<EdgeTypeT> &&
Other) {
689 NodeImpls = std::move(
Other.NodeImpls);
694 auto Index = NodeImpls.size();
695 auto NewNode = Node(Index);
696 NodeImpls.push_back(NodeImpl());
700 void addEdge(Node From, Node To,
const EdgeTypeT &Weight,
701 const EdgeTypeT &ReverseWeight) {
702 assert(inbounds(From));
703 assert(inbounds(To));
704 auto &FromNode = getNode(From);
705 auto &ToNode = getNode(To);
706 FromNode.Edges.push_back(Edge(Weight, To));
707 ToNode.Edges.push_back(Edge(ReverseWeight, From));
710 EdgeIterable edgesFor(
const Node &
N)
const {
711 const auto &Node = getNode(N);
712 return EdgeIterable(Node.Edges);
715 bool empty()
const {
return NodeImpls.empty(); }
716 std::size_t
size()
const {
return NodeImpls.size(); }
720 Node getEntryNode() {
721 assert(inbounds(StartNode));
726 typedef WeightedBidirectionalGraph<std::pair<EdgeType, StratifiedAttrs>> GraphT;
734 "CFL-Based AA implementation",
false,
true,
false)
737 return new CFLAliasAnalysis();
793 if (
auto *Inst = dyn_cast<Instruction>(Val)) {
798 if (
auto *Arg = dyn_cast<Argument>(Val))
803 template <
typename Inst>
806 if (
auto *Fn = Call->getCalledFunction()) {
817 GetTargetValueVisitor V;
818 return V.visit(Inst);
822 bool IsNonInvokeTerminator =
823 isa<TerminatorInst>(Inst) && !isa<InvokeInst>(Inst);
824 return !isa<CmpInst>(Inst) && !isa<FenceInst>(Inst) && !IsNonInvokeTerminator;
830 return CE->
getOpcode() != Instruction::ICmp &&
835 if (isa<GlobalValue>(Val))
836 return AttrGlobalIndex;
838 if (
auto *Arg = dyn_cast<Argument>(Val))
842 if (!Arg->hasNoAliasAttr() && Arg->getType()->isPointerTy())
848 if (ArgNum >= AttrMaxNumArgs)
850 return ArgNum + AttrFirstArgIndex;
855 case EdgeType::Assign:
856 return EdgeType::Assign;
857 case EdgeType::Dereference:
858 return EdgeType::Reference;
859 case EdgeType::Reference:
860 return EdgeType::Dereference;
868 "Expected instructions to have 'useful' edges");
869 GetEdgesVisitor v(Analysis, Output);
875 assert(
hasUsefulEdges(CE) &&
"Expected constant expr to have 'useful' edges");
876 GetEdgesVisitor v(Analysis, Output);
877 v.visitConstantExpr(CE);
882 case EdgeType::Reference:
884 case EdgeType::Dereference:
886 case EdgeType::Assign:
900 while (!Worklist.
empty()) {
906 ConstexprEdges.
clear();
908 for (
auto &Edge : ConstexprEdges) {
909 if (
auto *Nested = dyn_cast<ConstantExpr>(Edge.From))
910 if (Visited.
insert(Nested).second)
913 if (
auto *Nested = dyn_cast<ConstantExpr>(Edge.To))
914 if (Visited.
insert(Nested).second)
918 Results.
append(ConstexprEdges.begin(), ConstexprEdges.end());
924 NodeMapT &Map, GraphT &Graph) {
925 const auto findOrInsertNode = [&Map, &Graph](
Value *Val) {
926 auto Pair = Map.insert(std::make_pair(Val, GraphT::Node()));
927 auto &Iter = Pair.first;
929 auto NewNode = Graph.addNode();
930 Iter->second = NewNode;
937 if (isa<ReturnInst>(&Inst))
950 assert(MaybeVal.hasValue());
952 findOrInsertNode(Target);
956 const auto addEdgeToGraph = [&Graph, &findOrInsertNode](
const Edge &E) {
957 auto To = findOrInsertNode(E.To);
958 auto From = findOrInsertNode(E.From);
960 auto Attrs = E.AdditionalAttrs;
961 Graph.addEdge(From, To, std::make_pair(E.Weight, Attrs),
962 std::make_pair(FlippedWeight, Attrs));
966 for (
const Edge &E : Edges) {
968 if (
auto *Constexpr = dyn_cast<ConstantExpr>(E.To))
970 if (
auto *Constexpr = dyn_cast<ConstantExpr>(E.From))
977 std::for_each(Edges.begin(), Edges.end(), addEdgeToGraph);
987 NodeMapT &Map, GraphT &Graph) {
989 for (
auto &Inst : Bb.getInstList())
1001 if (isa<Constant>(Val)) {
1002 bool Container = isa<ConstantVector>(Val) || isa<ConstantArray>(Val) ||
1003 isa<ConstantStruct>(Val);
1007 bool CanStoreMutableData =
1008 isa<GlobalValue>(Val) || isa<ConstantExpr>(Val) || Container;
1009 return !CanStoreMutableData;
1023 NodeValueMap.
resize(Map.size());
1024 for (
const auto &Pair : Map)
1025 NodeValueMap.
insert(std::make_pair(Pair.second, Pair.first));
1027 const auto findValueOrDie = [&NodeValueMap](GraphT::Node Node) {
1028 auto ValIter = NodeValueMap.
find(Node);
1029 assert(ValIter != NodeValueMap.
end());
1030 return ValIter->second;
1036 for (
auto &Pair : Map) {
1039 auto *
Value = Pair.first;
1041 auto InitialNode = Pair.second;
1043 while (!Worklist.
empty()) {
1045 auto *CurValue = findValueOrDie(Node);
1049 for (
const auto &EdgeTuple : Graph.edgesFor(Node)) {
1050 auto Weight = std::get<0>(EdgeTuple);
1051 auto Label = Weight.first;
1052 auto &OtherNode = std::get<1>(EdgeTuple);
1053 auto *OtherValue = findValueOrDie(OtherNode);
1061 Added = Builder.
addAbove(CurValue, OtherValue);
1064 Added = Builder.
addBelow(CurValue, OtherValue);
1067 Added = Builder.
addWith(CurValue, OtherValue);
1071 auto Aliasing = Weight.second;
1073 Aliasing.set(*MaybeCurIndex);
1075 Aliasing.set(*MaybeOtherIndex);
1089 for (
auto &Arg : Fn->
args()) {
1090 if (!Builder.
add(&Arg))
1094 if (Attrs.hasValue())
1098 return FunctionInfo(Builder.
build(), std::move(ReturnedValues));
1101 void CFLAliasAnalysis::scan(
Function *Fn) {
1104 assert(InsertPair.second &&
1105 "Trying to scan a function that has already been cached");
1108 Cache[Fn] = std::move(Info);
1109 Handles.push_front(FunctionHandle(Fn,
this));
1114 auto *ValA =
const_cast<Value *
>(LocA.
Ptr);
1115 auto *ValB =
const_cast<Value *
>(LocB.
Ptr);
1120 if (!MaybeFnA.hasValue() && !MaybeFnB.hasValue()) {
1123 DEBUG(
dbgs() <<
"CFLAA: could not extract parent function information.\n");
1127 if (MaybeFnA.hasValue()) {
1129 assert((!MaybeFnB.hasValue() || *MaybeFnB == *MaybeFnA) &&
1130 "Interprocedural queries not supported");
1135 assert(Fn !=
nullptr);
1136 auto &MaybeInfo = ensureCached(Fn);
1137 assert(MaybeInfo.hasValue());
1139 auto &Sets = MaybeInfo->Sets;
1140 auto MaybeA = Sets.
find(ValA);
1141 if (!MaybeA.hasValue())
1144 auto MaybeB = Sets.find(ValB);
1145 if (!MaybeB.hasValue())
1148 auto SetA = *MaybeA;
1149 auto SetB = *MaybeB;
1150 auto AttrsA = Sets.getLink(SetA.Index).Attrs;
1151 auto AttrsB = Sets.getLink(SetB.Index).Attrs;
1162 if (AttrsA.any() && AttrsB.any())
1173 if (SetA.Index == SetB.Index)
1179 bool CFLAliasAnalysis::doInitialization(
Module &M) {
The two locations precisely alias each other.
StratifiedSets< T > build()
Value * getValueOperand()
void push_back(const T &Elt)
const_iterator end(StringRef path)
Get end iterator over path.
Value * getPointerOperand()
static Level directionOfEdgeType(EdgeType)
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
static bool getPossibleTargets(Inst *, SmallVectorImpl< Function * > &)
Base class for instruction visitors.
Value * getAggregateOperand()
A Module instance is used to store all the information related to an LLVM module. ...
AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory lo...
NoneType
A simple null object to allow implicit construction of Optional<T> and similar types without having to ...
static StratifiedAttr argNumberToAttrIndex(StratifiedAttr)
The two locations alias, but only due to a partial overlap.
static const unsigned NumStratifiedAttrs
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
CallInst - This class represents a function call, abstracting a target machine's calling convention...
ShuffleVectorInst - This instruction constructs a fixed permutation of two input vectors.
const_iterator begin(StringRef path)
Get begin iterator over path.
const Function * getParent() const
Return the enclosing method, or null if none.
Value * getNewValOperand()
The two locations do not alias at all.
LoadInst - an instruction for reading from memory.
AtomicRMWInst - an instruction that atomically reads a memory location, combines it with another valu...
unsigned getOpcode() const
getOpcode - Return the opcode at the root of this constant expression
The two locations may or may not alias. This is the least precise result.
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
static void argsToEdges(CFLAliasAnalysis &, Instruction *, SmallVectorImpl< Edge > &)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
SelectInst - This class represents the LLVM 'select' instruction.
This is the base class for all instructions that perform data casts.
T LLVM_ATTRIBUTE_UNUSED_RESULT pop_back_val()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool addAbove(const T &Main, const T &ToAdd)
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
const StratifiedLink & getLink(StratifiedIndex Index) const
This class represents a cast from a pointer to an integer.
Value * getPointerOperand()
ConstantExpr - a constant value that is initialized with an expression using other constant values...
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
StoreInst - an instruction for storing to memory.
ImmutablePass * createCFLAliasAnalysisPass()
static void constexprToEdges(CFLAliasAnalysis &, ConstantExpr &, SmallVectorImpl< Edge > &)
static void addInstructionToGraph(CFLAliasAnalysis &, Instruction &, SmallVectorImpl< Value * > &, NodeMapT &, GraphT &)
static void buildGraphFrom(CFLAliasAnalysis &, Function *, SmallVectorImpl< Value * > &, NodeMapT &, GraphT &)
virtual bool doInitialization(Module &)
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
GetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and ...
InsertElementInst - This instruction inserts a single (scalar) element into a VectorType value...
LandingPadInst - The landingpad instruction holds all of the information necessary to generate correc...
static bool hasUsefulEdges(Instruction *)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static Optional< StratifiedAttr > valueToAttrIndex(Value *Val)
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
AliasResult
The possible results of an alias query.
Represent the analysis usage information of a pass.
static bool canSkipAddingToSets(Value *Val)
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
Optional< StratifiedInfo > find(const T &Elem) const
Value * getOperand(unsigned i) const
Value * getPointerOperand()
static Optional< Value * > getTargetValue(Instruction *)
void noteAttributes(const T &Main, const StratifiedAttrs &NewAttrs)
This class represents a cast from an integer to a pointer.
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
VAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the speci...
const Value * getTrueValue() const
void resize(size_type Size)
Grow the densemap so that it has at least Size buckets. Does not shrink.
bool addWith(const T &Main, const T &ToAdd)
INITIALIZE_AG_PASS(CFLAliasAnalysis, AliasAnalysis,"cfl-aa","CFL-Based AA implementation", false, true, false) ImmutablePass *llvm
const Value * Ptr
The address of the start of the location.
Representation for a specific memory location.
static Optional< Function * > parentFunctionOfValue(Value *)
const BasicBlockListType & getBasicBlockList() const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
ImmutablePass class - This class is used to provide information that does not need to be run...
bool addBelow(const T &Main, const T &ToAdd)
BlockMass operator*(const BlockMass &L, const BranchProbability &R)
virtual AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
Alias Queries...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
static const StratifiedIndex SetSentinel
static EdgeType flipWeight(EdgeType)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
A range adaptor for a pair of iterators.
Target - Wrapper for Target specific information.
bool operator!=(uint64_t V1, const APInt &V2)
std::bitset< NumStratifiedAttrs > StratifiedAttrs
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
block Block Frequency Analysis
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Value * getPointerOperand()
iterator find(const KeyT &Val)
static FunctionInfo buildSetsFrom(CFLAliasAnalysis &, Function *)
bool hasLocalLinkage() const
Module * getParent()
Get the module that this global value is contained inside of...
LLVM Value Representation.
void initializeCFLAliasAnalysisPass(PassRegistry &)
virtual void getAnalysisUsage(AnalysisUsage &AU) const
getAnalysisUsage - All alias analysis implementations should invoke this directly (using AliasAnalysi...
virtual void * getAdjustedAnalysisPointer(AnalysisID ID)
getAdjustedAnalysisPointer - This method is used when a pass implements an analysis interface through...
InvokeInst - Invoke instruction.
const Value * getFalseValue() const
Value handle with callbacks on RAUW and destruction.
bool operator==(uint64_t V1, const APInt &V2)
op_range incoming_values()
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
Value * getPointerOperand()
const BasicBlock * getParent() const
iterator_range< arg_iterator > args()
AllocaInst - an instruction to allocate memory on the stack.
InsertValueInst - This instruction inserts a struct field of array element value into an aggregate va...
uint64_t Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known...