aboutsummaryrefslogtreecommitdiffstats
path: root/include
diff options
context:
space:
mode:
Diffstat (limited to 'include')
-rw-r--r--include/Support/Casting.h256
-rw-r--r--include/Support/ilist492
-rw-r--r--include/llvm/ADT/ilist492
-rw-r--r--include/llvm/Analysis/CallGraph.h2
-rw-r--r--include/llvm/Analysis/DataStructure.h2
-rw-r--r--include/llvm/Analysis/DataStructure/DataStructure.h2
-rw-r--r--include/llvm/Analysis/Dominators.h12
-rw-r--r--include/llvm/Analysis/FindUnsafePointerTypes.h2
-rw-r--r--include/llvm/Analysis/FindUsedTypes.h2
-rw-r--r--include/llvm/Analysis/InstForest.h14
-rw-r--r--include/llvm/Analysis/IntervalIterator.h2
-rw-r--r--include/llvm/Analysis/IntervalPartition.h2
-rw-r--r--include/llvm/Analysis/LoopInfo.h10
-rw-r--r--include/llvm/Analysis/Verifier.h4
-rw-r--r--include/llvm/Assembly/PrintModulePass.h8
-rw-r--r--include/llvm/Support/CFG.h8
-rw-r--r--include/llvm/Support/Casting.h256
-rw-r--r--include/llvm/Support/InstIterator.h28
-rw-r--r--include/llvm/Support/InstVisitor.h92
-rw-r--r--include/llvm/Transforms/MutateStructTypes.h6
20 files changed, 1553 insertions, 139 deletions
diff --git a/include/Support/Casting.h b/include/Support/Casting.h
index e59b7c2..2c072d1 100644
--- a/include/Support/Casting.h
+++ b/include/Support/Casting.h
@@ -8,51 +8,196 @@
#ifndef SUPPORT_CASTING_H
#define SUPPORT_CASTING_H
-// real_type - Provide a macro to get the real type of a value that might be
-// a use. This provides a typedef 'Type' that is the argument type for all
-// non UseTy types, and is the contained pointer type of the use if it is a
-// UseTy.
-//
-template <class X> class real_type { typedef X Type; };
+#include <assert.h>
//===----------------------------------------------------------------------===//
-// Type Checking Templates
+// isa<x> Support Templates
//===----------------------------------------------------------------------===//
+template<typename FromCl> struct isa_impl_cl;
+
+// Define a template that can be specialized by smart pointers to reflect the
+// fact that they are automatically dereferenced, and are not involved with the
+// template selection process... the default implementation is a noop.
+//
+template<typename From> struct simplify_type {
+ typedef From SimpleType; // The real type this represents...
+
+ // An accessor to get the real value...
+ static SimpleType &getSimplifiedValue(From &Val) { return Val; }
+};
+
+template<typename From> struct simplify_type<const From> {
+ typedef const From SimpleType;
+ static SimpleType &getSimplifiedValue(const From &Val) {
+ return simplify_type<From>::getSimplifiedValue((From&)Val);
+ }
+};
+
+
// isa<X> - Return true if the parameter to the template is an instance of the
// template type argument. Used like this:
//
-// if (isa<Type>(myVal)) { ... }
+// if (isa<Type*>(myVal)) { ... }
+//
+template <typename To, typename From>
+inline bool isa_impl(const From &Val) {
+ return To::classof(&Val);
+}
+
+template<typename To, typename From, typename SimpleType>
+struct isa_impl_wrap {
+ // When From != SimplifiedType, we can simplify the type some more by using
+ // the simplify_type template.
+ static bool doit(const From &Val) {
+ return isa_impl_cl<const SimpleType>::template
+ isa<To>(simplify_type<const From>::getSimplifiedValue(Val));
+ }
+};
+
+template<typename To, typename FromTy>
+struct isa_impl_wrap<To, const FromTy, const FromTy> {
+ // When From == SimpleType, we are as simple as we are going to get.
+ static bool doit(const FromTy &Val) {
+ return isa_impl<To,FromTy>(Val);
+ }
+};
+
+// isa_impl_cl - Use class partial specialization to transform types to a single
+// cannonical form for isa_impl.
//
+template<typename FromCl>
+struct isa_impl_cl {
+ template<class ToCl>
+ static bool isa(const FromCl &Val) {
+ return isa_impl_wrap<ToCl,const FromCl,
+ simplify_type<const FromCl>::SimpleType>::doit(Val);
+ }
+};
+
+// Specialization used to strip const qualifiers off of the FromCl type...
+template<typename FromCl>
+struct isa_impl_cl<const FromCl> {
+ template<class ToCl>
+ static bool isa(const FromCl &Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(Val);
+ }
+};
+
+// Define pointer traits in terms of base traits...
+template<class FromCl>
+struct isa_impl_cl<FromCl*> {
+ template<class ToCl>
+ static bool isa(FromCl *Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(*Val);
+ }
+};
+
+// Define reference traits in terms of base traits...
+template<class FromCl>
+struct isa_impl_cl<FromCl&> {
+ template<class ToCl>
+ static bool isa(FromCl &Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(&Val);
+ }
+};
+
template <class X, class Y>
-inline bool isa(Y Val) {
- assert(Val && "isa<Ty>(NULL) invoked!");
- return X::classof(Val);
+inline bool isa(const Y &Val) {
+ return isa_impl_cl<Y>::template isa<X>(Val);
}
+//===----------------------------------------------------------------------===//
+// cast<x> Support Templates
+//===----------------------------------------------------------------------===//
+
+template<class To, class From> struct cast_retty;
+
+
+// Calculate what type the 'cast' function should return, based on a requested
+// type of To and a source type of From.
+template<class To, class From> struct cast_retty_impl {
+ typedef To& ret_type; // Normal case, return Ty&
+};
+template<class To, class From> struct cast_retty_impl<To, const From> {
+ typedef const To &ret_type; // Normal case, return Ty&
+};
+
+template<class To, class From> struct cast_retty_impl<To, From*> {
+ typedef To* ret_type; // Pointer arg case, return Ty*
+};
+
+template<class To, class From> struct cast_retty_impl<To, const From*> {
+ typedef const To* ret_type; // Constant pointer arg case, return const Ty*
+};
+
+template<class To, class From> struct cast_retty_impl<To, const From*const> {
+ typedef const To* ret_type; // Constant pointer arg case, return const Ty*
+};
+
+
+template<class To, class From, class SimpleFrom>
+struct cast_retty_wrap {
+ // When the simplified type and the from type are not the same, use the type
+ // simplifier to reduce the type, then reuse cast_retty_impl to get the
+ // resultant type.
+ typedef typename cast_retty<To, SimpleFrom>::ret_type ret_type;
+};
+
+template<class To, class FromTy>
+struct cast_retty_wrap<To, FromTy, FromTy> {
+ // When the simplified type is equal to the from type, use it directly.
+ typedef typename cast_retty_impl<To,FromTy>::ret_type ret_type;
+};
+
+template<class To, class From>
+struct cast_retty {
+ typedef typename cast_retty_wrap<To, From,
+ simplify_type<From>::SimpleType>::ret_type ret_type;
+};
+
+// Ensure the non-simple values are converted using the simplify_type template
+// that may be specialized by smart pointers...
+//
+template<class To, class From, class SimpleFrom> struct cast_convert_val {
+ // This is not a simple type, use the template to simplify it...
+ static cast_retty<To, From>::ret_type doit(const From &Val) {
+ return cast_convert_val<To, SimpleFrom,
+ simplify_type<SimpleFrom>::SimpleType>::doit(
+ simplify_type<From>::getSimplifiedValue(Val));
+ }
+};
+
+template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
+ // This _is_ a simple type, just cast it.
+ static cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
+ return (cast_retty<To, FromTy>::ret_type)Val;
+ }
+};
+
+
// cast<X> - Return the argument parameter cast to the specified type. This
// casting operator asserts that the type is correct, so it does not return null
// on failure. But it will correctly return NULL when the input is NULL.
// Used Like this:
//
-// cast< Instruction>(myVal)->getParent()
-// cast<const Instruction>(myVal)->getParent()
+// cast<Instruction>(myVal)->getParent()
//
template <class X, class Y>
-inline X *cast(Y Val) {
+inline cast_retty<X, Y>::ret_type cast(const Y &Val) {
assert(isa<X>(Val) && "cast<Ty>() argument of uncompatible type!");
- return (X*)(real_type<Y>::Type)Val;
+ return cast_convert_val<X, Y, simplify_type<Y>::SimpleType>::doit(Val);
}
// cast_or_null<X> - Functionally identical to cast, except that a null value is
// accepted.
//
template <class X, class Y>
-inline X *cast_or_null(Y Val) {
- assert((Val == 0 || isa<X>(Val)) &&
- "cast_or_null<Ty>() argument of uncompatible type!");
- return (X*)(real_type<Y>::Type)Val;
+inline cast_retty<X, Y*>::ret_type cast_or_null(Y *Val) {
+ if (Val == 0) return 0;
+ assert(isa<X>(Val) && "cast_or_null<Ty>() argument of uncompatible type!");
+ return cast<X>(Val);
}
@@ -65,16 +210,81 @@ inline X *cast_or_null(Y Val) {
//
template <class X, class Y>
-inline X *dyn_cast(Y Val) {
- return isa<X>(Val) ? cast<X>(Val) : 0;
+inline cast_retty<X, Y*>::ret_type dyn_cast(Y *Val) {
+ return isa<X>(Val) ? cast<X, Y*>(Val) : 0;
}
// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
// value is accepted.
//
template <class X, class Y>
-inline X *dyn_cast_or_null(Y Val) {
- return (Val && isa<X>(Val)) ? cast<X>(Val) : 0;
+inline cast_retty<X, Y*>::ret_type dyn_cast_or_null(Y *Val) {
+ return (Val && isa<X>(Val)) ? cast<X, Y*>(Val) : 0;
+}
+
+
+#ifdef DEBUG_CAST_OPERATORS
+#include <iostream>
+
+struct bar {
+ bar() {}
+private:
+ bar(const bar &);
+};
+struct foo {
+ void ext() const;
+ /* static bool classof(const bar *X) {
+ cerr << "Classof: " << X << "\n";
+ return true;
+ }*/
+};
+
+template <> inline bool isa_impl<foo,bar>(const bar &Val) {
+ cerr << "Classof: " << &Val << "\n";
+ return true;
+}
+
+
+bar *fub();
+void test(bar &B1, const bar *B2) {
+ // test various configurations of const
+ const bar &B3 = B1;
+ const bar *const B4 = B2;
+
+ // test isa
+ if (!isa<foo>(B1)) return;
+ if (!isa<foo>(B2)) return;
+ if (!isa<foo>(B3)) return;
+ if (!isa<foo>(B4)) return;
+
+ // test cast
+ foo &F1 = cast<foo>(B1);
+ const foo *F3 = cast<foo>(B2);
+ const foo *F4 = cast<foo>(B2);
+ const foo &F8 = cast<foo>(B3);
+ const foo *F9 = cast<foo>(B4);
+ foo *F10 = cast<foo>(fub());
+
+ // test cast_or_null
+ const foo *F11 = cast_or_null<foo>(B2);
+ const foo *F12 = cast_or_null<foo>(B2);
+ const foo *F13 = cast_or_null<foo>(B4);
+ const foo *F14 = cast_or_null<foo>(fub()); // Shouldn't print.
+
+ // These lines are errors...
+ //foo *F20 = cast<foo>(B2); // Yields const foo*
+ //foo &F21 = cast<foo>(B3); // Yields const foo&
+ //foo *F22 = cast<foo>(B4); // Yields const foo*
+ //foo &F23 = cast_or_null<foo>(B1);
+ //const foo &F24 = cast_or_null<foo>(B3);
+}
+
+bar *fub() { return 0; }
+void main() {
+ bar B;
+ test(B, &B);
}
#endif
+
+#endif
diff --git a/include/Support/ilist b/include/Support/ilist
new file mode 100644
index 0000000..04cf596
--- /dev/null
+++ b/include/Support/ilist
@@ -0,0 +1,492 @@
+//===-- <Support/ilist> - Intrusive Linked List Template ---------*- C++ -*--=//
+//
+// This file defines classes to implement an intrusive doubly linked list class
+// (ie each node of the list must contain a next and previous field for the
+// list.
+//
+// The ilist_traits trait class is used to gain access to the next and previous
+// fields of the node type that the list is instantiated with. If it is not
+// specialized, the list defaults to using the getPrev(), getNext() method calls
+// to get the next and previous pointers.
+//
+// The ilist class itself, should be a plug in replacement for list, assuming
+// that the nodes contain next/prev pointers. This list replacement does not
+// provides a constant time size() method, so be careful to use empty() when you
+// really want to know if I'm empty.
+//
+// The ilist class is implemented by allocating a 'tail' node when the list is
+// created (using ilist_traits<>::createEndMarker()). This tail node is
+// absolutely required because the user must be able to compute end()-1. Because
+// of this, users of the direct next/prev links will see an extra link on the
+// end of the list, which should be ignored.
+//
+// Requirements for a user of this list:
+//
+// 1. The user must provide {g|s}et{Next|Prev} methods, or specialize
+// ilist_traits to provide an alternate way of getting and setting next and
+// prev links.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef INCLUDED_SUPPORT_ILIST
+#define INCLUDED_SUPPORT_ILIST
+
+#include <assert.h>
+#include <iterator>
+
+template<typename NodeTy, typename Traits> class iplist;
+template<typename NodeTy> class ilist_iterator;
+
+// Template traits for intrusive list. By specializing this template class, you
+// can change what next/prev fields are used to store the links...
+template<typename NodeTy>
+struct ilist_traits {
+ static NodeTy *getPrev(NodeTy *N) { return N->getPrev(); }
+ static NodeTy *getNext(NodeTy *N) { return N->getNext(); }
+ static const NodeTy *getPrev(const NodeTy *N) { return N->getPrev(); }
+ static const NodeTy *getNext(const NodeTy *N) { return N->getNext(); }
+
+ static void setPrev(NodeTy *N, NodeTy *Prev) { N->setPrev(Prev); }
+ static void setNext(NodeTy *N, NodeTy *Next) { N->setNext(Next); }
+
+ static NodeTy *createNode() { return new NodeTy(); }
+ static NodeTy *createNode(const NodeTy &V) { return new NodeTy(V); }
+
+
+ void addNodeToList(NodeTy *NTy) {}
+ void removeNodeFromList(NodeTy *NTy) {}
+ void transferNodesFromList(iplist<NodeTy, ilist_traits> &L2,
+ ilist_iterator<NodeTy> first,
+ ilist_iterator<NodeTy> last) {}
+};
+
+// Const traits are the same as nonconst traits...
+template<typename Ty>
+struct ilist_traits<const Ty> : public ilist_traits<Ty> {};
+
+
+//===----------------------------------------------------------------------===//
+// ilist_iterator<Node> - Iterator for intrusive list.
+//
+template<typename NodeTy>
+class ilist_iterator : public std::bidirectional_iterator<NodeTy, ptrdiff_t> {
+ typedef ilist_traits<NodeTy> Traits;
+ pointer NodePtr;
+public:
+ typedef size_t size_type;
+
+ ilist_iterator(pointer NP) : NodePtr(NP) {}
+ ilist_iterator() : NodePtr(0) {}
+
+ // This is templated so that we can allow constructing a const iterator from
+ // a nonconst iterator...
+ template<class node_ty>
+ ilist_iterator(const ilist_iterator<node_ty> &RHS)
+ : NodePtr(RHS.getNodePtrUnchecked()) {}
+
+ // This is templated so that we can allow assigning to a const iterator from
+ // a nonconst iterator...
+ template<class node_ty>
+ const ilist_iterator &operator=(const ilist_iterator<node_ty> &RHS) {
+ NodePtr = RHS.getNodePtrUnchecked();
+ return *this;
+ }
+
+ // Accessors...
+ operator pointer() const {
+ assert(Traits::getNext(NodePtr) != 0 && "Dereferencing end()!");
+ return NodePtr;
+ }
+
+ reference operator*() const {
+ assert(Traits::getNext(NodePtr) != 0 && "Dereferencing end()!");
+ return *NodePtr;
+ }
+ pointer operator->() { return &operator*(); }
+ const pointer operator->() const { return &operator*(); }
+
+ // Comparison operators
+ bool operator==(const ilist_iterator &RHS) const {
+ return NodePtr == RHS.NodePtr;
+ }
+ bool operator!=(const ilist_iterator &RHS) const {
+ return NodePtr != RHS.NodePtr;
+ }
+
+ // Increment and decrement operators...
+ ilist_iterator &operator--() { // predecrement - Back up
+ NodePtr = Traits::getPrev(NodePtr);
+ assert(NodePtr && "--'d off the beginning of an ilist!");
+ return *this;
+ }
+ ilist_iterator &operator++() { // preincrement - Advance
+ NodePtr = Traits::getNext(NodePtr);
+ assert(NodePtr && "++'d off the end of an ilist!");
+ return *this;
+ }
+ ilist_iterator operator--(int) { // postdecrement operators...
+ ilist_iterator tmp = *this;
+ --*this;
+ return tmp;
+ }
+ ilist_iterator operator++(int) { // postincrement operators...
+ ilist_iterator tmp = *this;
+ ++*this;
+ return tmp;
+ }
+
+
+ // Dummy operators to make errors apparent...
+ template<class X> void operator+(X Val) {}
+ template<class X> void operator-(X Val) {}
+
+ // Internal interface, do not use...
+ pointer getNodePtrUnchecked() const { return NodePtr; }
+};
+
+
+//===----------------------------------------------------------------------===//
+//
+// iplist - The subset of list functionality that can safely be used on nodes of
+// polymorphic types, ie a heterogeneus list with a common base class that holds
+// the next/prev pointers...
+//
+template<typename NodeTy, typename Traits=ilist_traits<NodeTy> >
+class iplist : public Traits {
+ NodeTy *Head, *Tail;
+
+ static bool op_less(NodeTy &L, NodeTy &R) { return L < R; }
+ static bool op_equal(NodeTy &L, NodeTy &R) { return L == R; }
+public:
+ typedef NodeTy *pointer;
+ typedef const NodeTy *const_pointer;
+ typedef NodeTy &reference;
+ typedef const NodeTy &const_reference;
+ typedef NodeTy value_type;
+ typedef ilist_iterator<NodeTy> iterator;
+ typedef ilist_iterator<const NodeTy> const_iterator;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef reverse_iterator<iterator> reverse_iterator;
+
+ iplist() : Head(createNode()), Tail(Head) {
+ setNext(Head, 0);
+ setPrev(Head, 0);
+ }
+ ~iplist() { clear(); delete Tail; }
+
+ // Iterator creation methods...
+ iterator begin() { return iterator(Head); }
+ const_iterator begin() const { return const_iterator(Head); }
+ iterator end() { return iterator(Tail); }
+ const_iterator end() const { return const_iterator(Tail); }
+
+ // reverse iterator creation methods...
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const {return const_reverse_iterator(begin());}
+
+ // Miscellaneous inspection routines...
+ size_type max_size() const { return size_type(-1); }
+ bool empty() const { return Head == Tail; }
+
+ // Front and back accessor functions...
+ reference front() {
+ assert(!empty() && "Called front() on empty list!");
+ return *Head;
+ }
+ const_reference front() const {
+ assert(!empty() && "Called front() on empty list!");
+ return *Head;
+ }
+ reference back() {
+ assert(!empty() && "Called back() on empty list!");
+ return *getPrev(Tail);
+ }
+ const_reference back() const {
+ assert(!empty() && "Called back() on empty list!");
+ return *getPrev(Tail);
+ }
+
+ void swap(iplist &RHS) {
+ abort(); // Swap does not use list traits callback correctly yet!
+ std::swap(Head, RHS.Head);
+ std::swap(Tail, RHS.Tail);
+ }
+
+ iterator insert(iterator where, NodeTy *New) {
+ NodeTy *CurNode = where.getNodePtrUnchecked(), *PrevNode = getPrev(CurNode);
+ setNext(New, CurNode);
+ setPrev(New, PrevNode);
+
+ if (PrevNode)
+ setNext(PrevNode, New);
+ else
+ Head = New;
+ setPrev(CurNode, New);
+
+ addNodeToList(New); // Notify traits that we added a node...
+ return New;
+ }
+
+ NodeTy *remove(iterator &IT) {
+ assert(IT != end() && "Cannot remove end of list!");
+ NodeTy *Node = &*IT;
+ NodeTy *NextNode = getNext(Node);
+ NodeTy *PrevNode = getPrev(Node);
+
+ if (PrevNode)
+ setNext(PrevNode, NextNode);
+ else
+ Head = NextNode;
+ setPrev(NextNode, PrevNode);
+ IT = NextNode;
+ removeNodeFromList(Node); // Notify traits that we added a node...
+ return Node;
+ }
+
+ NodeTy *remove(const iterator &IT) {
+ iterator MutIt = IT;
+ return remove(MutIt);
+ }
+
+ // erase - remove a node from the controlled sequence... and delete it.
+ iterator erase(iterator where) {
+ delete remove(where);
+ return where;
+ }
+
+
+private:
+ // transfer - The heart of the splice function. Move linked list nodes from
+ // [first, last) into position.
+ //
+ void transfer(iterator position, iplist &L2, iterator first, iterator last) {
+ assert(first != last && "Should be checked by callers");
+ if (position != last) {
+ // Remove [first, last) from its old position.
+ NodeTy *First = &*first, *Prev = getPrev(First);
+ NodeTy *Next = last.getNodePtrUnchecked(), *Last = getPrev(Next);
+ if (Prev)
+ setNext(Prev, Next);
+ else
+ L2.Head = Next;
+ setPrev(Next, Prev);
+
+ // Splice [first, last) into its new position.
+ NodeTy *PosNext = position.getNodePtrUnchecked();
+ NodeTy *PosPrev = getPrev(PosNext);
+
+ // Fix head of list...
+ if (PosPrev)
+ setNext(PosPrev, First);
+ else
+ Head = First;
+ setPrev(First, PosPrev);
+
+ // Fix end of list...
+ setNext(Last, PosNext);
+ setPrev(PosNext, Last);
+
+ transferNodesFromList(L2, First, PosNext);
+ }
+ }
+
+public:
+
+ //===----------------------------------------------------------------------===
+ // Functionality derived from other functions defined above...
+ //
+
+ size_type size() const {
+ size_type Result = 0;
+ std::distance(begin(), end(), Result);
+ return Result;
+ }
+
+ iterator erase(iterator first, iterator last) {
+ while (first != last)
+ first = erase(first);
+ return last;
+ }
+
+ void clear() { erase(begin(), end()); }
+
+ // Front and back inserters...
+ void push_front(NodeTy *val) { insert(begin(), val); }
+ void push_back(NodeTy *val) { insert(end(), val); }
+ void pop_front() {
+ assert(!empty() && "pop_front() on empty list!");
+ erase(begin());
+ }
+ void pop_back() {
+ assert(!empty() && "pop_back() on empty list!");
+ iterator t = end(); erase(--t);
+ }
+
+ // Special forms of insert...
+ template<class InIt> void insert(iterator where, InIt first, InIt last) {
+ for (; first != last; ++first) insert(where, *first);
+ }
+
+ // Splice members - defined in terms of transfer...
+ void splice(iterator where, iplist &L2) {
+ if (!L2.empty())
+ transfer(where, L2, L2.begin(), L2.end());
+ }
+ void splice(iterator where, iplist &L2, iterator first) {
+ iterator last = first; ++last;
+ if (where == first || where == last) return; // No change
+ transfer(where, L2, first, last);
+ }
+ void splice(iterator where, iplist &L2, iterator first, iterator last) {
+ if (first != last) transfer(where, L2, first, last);
+ }
+
+
+
+ //===----------------------------------------------------------------------===
+ // High-Level Functionality that shouldn't really be here, but is part of list
+ //
+
+ // These two functions are actually called remove/remove_if in list<>, but
+ // they actually do the job of erase, rename them accordingly.
+ //
+ void erase(const NodeTy &val) {
+ for (iterator I = begin(), E = end(); I != E; ) {
+ iterator next = I; ++next;
+ if (*I == val) erase(I);
+ I = next;
+ }
+ }
+ template<class Pr1> void erase_if(Pr1 pred) {
+ for (iterator I = begin(), E = end(); I != E; ) {
+ iterator next = I; ++next;
+ if (pred(*I)) erase(I);
+ I = next;
+ }
+ }
+
+ template<class Pr2> void unique(Pr2 pred) {
+ if (empty()) return;
+ for (iterator I = begin(), E = end(), Next = begin(); ++Next != E;) {
+ if (pred(*I))
+ erase(Next);
+ else
+ I = Next;
+ Next = I;
+ }
+ }
+ void unique() { unique(op_equal); }
+
+ template<class Pr3> void merge(iplist &right, Pr3 pred) {
+ iterator first1 = begin(), last1 = end();
+ iterator first2 = right.begin(), last2 = right.end();
+ while (first1 != last1 && first2 != last2)
+ if (pred(*first2, *first1)) {
+ iterator next = first2;
+ transfer(first1, right, first2, ++next);
+ first2 = next;
+ } else {
+ ++first1;
+ }
+ if (first2 != last2) transfer(last1, right, first2, last2);
+ }
+ void merge(iplist &right) { return merge(right, op_less); }
+
+ template<class Pr3> void sort(Pr3 pred);
+ void sort() { sort(op_less); }
+ void reverse();
+};
+
+
+template<typename NodeTy>
+struct ilist : public iplist<NodeTy> {
+ ilist() {}
+ ilist(const ilist &right) {
+ insert(begin(), right.begin(), right.end());
+ }
+ explicit ilist(size_type count) {
+ insert(begin(), count, NodeTy());
+ }
+ ilist(size_type count, const NodeTy &val) {
+ insert(begin(), count, val);
+ }
+ template<class InIt> ilist(InIt first, InIt last) {
+ insert(begin(), first, last);
+ }
+
+
+ // Forwarding functions: A workaround for GCC 2.95 which does not correctly
+ // support 'using' declarations to bring a hidden member into scope.
+ //
+ iterator insert(iterator a, NodeTy *b){ return iplist<NodeTy>::insert(a, b); }
+ void push_front(NodeTy *a) { iplist<NodeTy>::push_front(a); }
+ void push_back(NodeTy *a) { iplist<NodeTy>::push_back(a); }
+
+
+ // Main implementation here - Insert for a node passed by value...
+ iterator insert(iterator where, const NodeTy &val) {
+ return insert(where, createNode(val));
+ }
+
+
+ // Front and back inserters...
+ void push_front(const NodeTy &val) { insert(begin(), val); }
+ void push_back(const NodeTy &val) { insert(end(), val); }
+
+ // Special forms of insert...
+ template<class InIt> void insert(iterator where, InIt first, InIt last) {
+ for (; first != last; ++first) insert(where, *first);
+ }
+ void insert(iterator where, size_type count, const NodeTy &val) {
+ for (; count != 0; --count) insert(where, val);
+ }
+
+ // Assign special forms...
+ void assign(size_type count, const NodeTy &val) {
+ iterator I = begin();
+ for (; I != end() && count != 0; ++I, --count)
+ *I = val;
+ if (count != 0)
+ insert(end(), n, val);
+ else
+ erase(I, end());
+ }
+ template<class InIt> void assign(InIt first, InIt last) {
+ iterator first1 = begin(), last1 = end();
+ for ( ; first1 != last1 && first2 != last2; ++first1, ++first2)
+ *first1 = *first2;
+ if (first2 == last2)
+ erase(first1, last1);
+ else
+ insert(last1, first2, last2);
+ }
+
+
+ // Resize members...
+ void resize(size_type newsize, NodeTy val) {
+ iterator i = begin();
+ size_type len = 0;
+ for ( ; i != end() && len < newsize; ++i, ++len) /* empty*/ ;
+
+ if (len == newsize)
+ erase(i, end());
+ else // i == end()
+ insert(end(), newsize - len, val);
+ }
+ void resize(size_type newsize) { resize(newsize, NodeTy()); }
+
+};
+
+namespace std {
+ // Ensure that swap uses the fast list swap...
+ template<class Ty>
+ void swap(iplist<Ty> &Left, iplist<Ty> &Right) {
+ Left.swap(Right);
+ }
+} // End 'std' extensions...
+
+#endif
diff --git a/include/llvm/ADT/ilist b/include/llvm/ADT/ilist
new file mode 100644
index 0000000..04cf596
--- /dev/null
+++ b/include/llvm/ADT/ilist
@@ -0,0 +1,492 @@
+//===-- <Support/ilist> - Intrusive Linked List Template ---------*- C++ -*--=//
+//
+// This file defines classes to implement an intrusive doubly linked list class
+// (ie each node of the list must contain a next and previous field for the
+// list.
+//
+// The ilist_traits trait class is used to gain access to the next and previous
+// fields of the node type that the list is instantiated with. If it is not
+// specialized, the list defaults to using the getPrev(), getNext() method calls
+// to get the next and previous pointers.
+//
+// The ilist class itself, should be a plug in replacement for list, assuming
+// that the nodes contain next/prev pointers. This list replacement does not
+// provides a constant time size() method, so be careful to use empty() when you
+// really want to know if I'm empty.
+//
+// The ilist class is implemented by allocating a 'tail' node when the list is
+// created (using ilist_traits<>::createEndMarker()). This tail node is
+// absolutely required because the user must be able to compute end()-1. Because
+// of this, users of the direct next/prev links will see an extra link on the
+// end of the list, which should be ignored.
+//
+// Requirements for a user of this list:
+//
+// 1. The user must provide {g|s}et{Next|Prev} methods, or specialize
+// ilist_traits to provide an alternate way of getting and setting next and
+// prev links.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef INCLUDED_SUPPORT_ILIST
+#define INCLUDED_SUPPORT_ILIST
+
+#include <assert.h>
+#include <iterator>
+
+template<typename NodeTy, typename Traits> class iplist;
+template<typename NodeTy> class ilist_iterator;
+
+// Template traits for intrusive list. By specializing this template class, you
+// can change what next/prev fields are used to store the links...
+template<typename NodeTy>
+struct ilist_traits {
+ static NodeTy *getPrev(NodeTy *N) { return N->getPrev(); }
+ static NodeTy *getNext(NodeTy *N) { return N->getNext(); }
+ static const NodeTy *getPrev(const NodeTy *N) { return N->getPrev(); }
+ static const NodeTy *getNext(const NodeTy *N) { return N->getNext(); }
+
+ static void setPrev(NodeTy *N, NodeTy *Prev) { N->setPrev(Prev); }
+ static void setNext(NodeTy *N, NodeTy *Next) { N->setNext(Next); }
+
+ static NodeTy *createNode() { return new NodeTy(); }
+ static NodeTy *createNode(const NodeTy &V) { return new NodeTy(V); }
+
+
+ void addNodeToList(NodeTy *NTy) {}
+ void removeNodeFromList(NodeTy *NTy) {}
+ void transferNodesFromList(iplist<NodeTy, ilist_traits> &L2,
+ ilist_iterator<NodeTy> first,
+ ilist_iterator<NodeTy> last) {}
+};
+
+// Const traits are the same as nonconst traits...
+template<typename Ty>
+struct ilist_traits<const Ty> : public ilist_traits<Ty> {};
+
+
+//===----------------------------------------------------------------------===//
+// ilist_iterator<Node> - Iterator for intrusive list.
+//
+template<typename NodeTy>
+class ilist_iterator : public std::bidirectional_iterator<NodeTy, ptrdiff_t> {
+ typedef ilist_traits<NodeTy> Traits;
+ pointer NodePtr;
+public:
+ typedef size_t size_type;
+
+ ilist_iterator(pointer NP) : NodePtr(NP) {}
+ ilist_iterator() : NodePtr(0) {}
+
+ // This is templated so that we can allow constructing a const iterator from
+ // a nonconst iterator...
+ template<class node_ty>
+ ilist_iterator(const ilist_iterator<node_ty> &RHS)
+ : NodePtr(RHS.getNodePtrUnchecked()) {}
+
+ // This is templated so that we can allow assigning to a const iterator from
+ // a nonconst iterator...
+ template<class node_ty>
+ const ilist_iterator &operator=(const ilist_iterator<node_ty> &RHS) {
+ NodePtr = RHS.getNodePtrUnchecked();
+ return *this;
+ }
+
+ // Accessors...
+ operator pointer() const {
+ assert(Traits::getNext(NodePtr) != 0 && "Dereferencing end()!");
+ return NodePtr;
+ }
+
+ reference operator*() const {
+ assert(Traits::getNext(NodePtr) != 0 && "Dereferencing end()!");
+ return *NodePtr;
+ }
+ pointer operator->() { return &operator*(); }
+ const pointer operator->() const { return &operator*(); }
+
+ // Comparison operators
+ bool operator==(const ilist_iterator &RHS) const {
+ return NodePtr == RHS.NodePtr;
+ }
+ bool operator!=(const ilist_iterator &RHS) const {
+ return NodePtr != RHS.NodePtr;
+ }
+
+ // Increment and decrement operators...
+ ilist_iterator &operator--() { // predecrement - Back up
+ NodePtr = Traits::getPrev(NodePtr);
+ assert(NodePtr && "--'d off the beginning of an ilist!");
+ return *this;
+ }
+ ilist_iterator &operator++() { // preincrement - Advance
+ NodePtr = Traits::getNext(NodePtr);
+ assert(NodePtr && "++'d off the end of an ilist!");
+ return *this;
+ }
+ ilist_iterator operator--(int) { // postdecrement operators...
+ ilist_iterator tmp = *this;
+ --*this;
+ return tmp;
+ }
+ ilist_iterator operator++(int) { // postincrement operators...
+ ilist_iterator tmp = *this;
+ ++*this;
+ return tmp;
+ }
+
+
+ // Dummy operators to make errors apparent...
+ template<class X> void operator+(X Val) {}
+ template<class X> void operator-(X Val) {}
+
+ // Internal interface, do not use...
+ pointer getNodePtrUnchecked() const { return NodePtr; }
+};
+
+
+//===----------------------------------------------------------------------===//
+//
+// iplist - The subset of list functionality that can safely be used on nodes of
+// polymorphic types, ie a heterogeneus list with a common base class that holds
+// the next/prev pointers...
+//
+template<typename NodeTy, typename Traits=ilist_traits<NodeTy> >
+class iplist : public Traits {
+ NodeTy *Head, *Tail;
+
+ static bool op_less(NodeTy &L, NodeTy &R) { return L < R; }
+ static bool op_equal(NodeTy &L, NodeTy &R) { return L == R; }
+public:
+ typedef NodeTy *pointer;
+ typedef const NodeTy *const_pointer;
+ typedef NodeTy &reference;
+ typedef const NodeTy &const_reference;
+ typedef NodeTy value_type;
+ typedef ilist_iterator<NodeTy> iterator;
+ typedef ilist_iterator<const NodeTy> const_iterator;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef reverse_iterator<iterator> reverse_iterator;
+
+ iplist() : Head(createNode()), Tail(Head) {
+ setNext(Head, 0);
+ setPrev(Head, 0);
+ }
+ ~iplist() { clear(); delete Tail; }
+
+ // Iterator creation methods...
+ iterator begin() { return iterator(Head); }
+ const_iterator begin() const { return const_iterator(Head); }
+ iterator end() { return iterator(Tail); }
+ const_iterator end() const { return const_iterator(Tail); }
+
+ // reverse iterator creation methods...
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const {return const_reverse_iterator(begin());}
+
+ // Miscellaneous inspection routines...
+ size_type max_size() const { return size_type(-1); }
+ bool empty() const { return Head == Tail; }
+
+ // Front and back accessor functions...
+ reference front() {
+ assert(!empty() && "Called front() on empty list!");
+ return *Head;
+ }
+ const_reference front() const {
+ assert(!empty() && "Called front() on empty list!");
+ return *Head;
+ }
+ reference back() {
+ assert(!empty() && "Called back() on empty list!");
+ return *getPrev(Tail);
+ }
+ const_reference back() const {
+ assert(!empty() && "Called back() on empty list!");
+ return *getPrev(Tail);
+ }
+
+ void swap(iplist &RHS) {
+ abort(); // Swap does not use list traits callback correctly yet!
+ std::swap(Head, RHS.Head);
+ std::swap(Tail, RHS.Tail);
+ }
+
+ iterator insert(iterator where, NodeTy *New) {
+ NodeTy *CurNode = where.getNodePtrUnchecked(), *PrevNode = getPrev(CurNode);
+ setNext(New, CurNode);
+ setPrev(New, PrevNode);
+
+ if (PrevNode)
+ setNext(PrevNode, New);
+ else
+ Head = New;
+ setPrev(CurNode, New);
+
+ addNodeToList(New); // Notify traits that we added a node...
+ return New;
+ }
+
+ NodeTy *remove(iterator &IT) {
+ assert(IT != end() && "Cannot remove end of list!");
+ NodeTy *Node = &*IT;
+ NodeTy *NextNode = getNext(Node);
+ NodeTy *PrevNode = getPrev(Node);
+
+ if (PrevNode)
+ setNext(PrevNode, NextNode);
+ else
+ Head = NextNode;
+ setPrev(NextNode, PrevNode);
+ IT = NextNode;
+ removeNodeFromList(Node); // Notify traits that we added a node...
+ return Node;
+ }
+
+ NodeTy *remove(const iterator &IT) {
+ iterator MutIt = IT;
+ return remove(MutIt);
+ }
+
+ // erase - remove a node from the controlled sequence... and delete it.
+ iterator erase(iterator where) {
+ delete remove(where);
+ return where;
+ }
+
+
+private:
+ // transfer - The heart of the splice function. Move linked list nodes from
+ // [first, last) into position.
+ //
+ void transfer(iterator position, iplist &L2, iterator first, iterator last) {
+ assert(first != last && "Should be checked by callers");
+ if (position != last) {
+ // Remove [first, last) from its old position.
+ NodeTy *First = &*first, *Prev = getPrev(First);
+ NodeTy *Next = last.getNodePtrUnchecked(), *Last = getPrev(Next);
+ if (Prev)
+ setNext(Prev, Next);
+ else
+ L2.Head = Next;
+ setPrev(Next, Prev);
+
+ // Splice [first, last) into its new position.
+ NodeTy *PosNext = position.getNodePtrUnchecked();
+ NodeTy *PosPrev = getPrev(PosNext);
+
+ // Fix head of list...
+ if (PosPrev)
+ setNext(PosPrev, First);
+ else
+ Head = First;
+ setPrev(First, PosPrev);
+
+ // Fix end of list...
+ setNext(Last, PosNext);
+ setPrev(PosNext, Last);
+
+ transferNodesFromList(L2, First, PosNext);
+ }
+ }
+
+public:
+
+ //===----------------------------------------------------------------------===
+ // Functionality derived from other functions defined above...
+ //
+
+ size_type size() const {
+ size_type Result = 0;
+ std::distance(begin(), end(), Result);
+ return Result;
+ }
+
+ iterator erase(iterator first, iterator last) {
+ while (first != last)
+ first = erase(first);
+ return last;
+ }
+
+ void clear() { erase(begin(), end()); }
+
+ // Front and back inserters...
+ void push_front(NodeTy *val) { insert(begin(), val); }
+ void push_back(NodeTy *val) { insert(end(), val); }
+ void pop_front() {
+ assert(!empty() && "pop_front() on empty list!");
+ erase(begin());
+ }
+ void pop_back() {
+ assert(!empty() && "pop_back() on empty list!");
+ iterator t = end(); erase(--t);
+ }
+
+ // Special forms of insert...
+ template<class InIt> void insert(iterator where, InIt first, InIt last) {
+ for (; first != last; ++first) insert(where, *first);
+ }
+
+ // Splice members - defined in terms of transfer...
+ void splice(iterator where, iplist &L2) {
+ if (!L2.empty())
+ transfer(where, L2, L2.begin(), L2.end());
+ }
+ void splice(iterator where, iplist &L2, iterator first) {
+ iterator last = first; ++last;
+ if (where == first || where == last) return; // No change
+ transfer(where, L2, first, last);
+ }
+ void splice(iterator where, iplist &L2, iterator first, iterator last) {
+ if (first != last) transfer(where, L2, first, last);
+ }
+
+
+
+ //===----------------------------------------------------------------------===
+ // High-Level Functionality that shouldn't really be here, but is part of list
+ //
+
+ // These two functions are actually called remove/remove_if in list<>, but
+ // they actually do the job of erase, rename them accordingly.
+ //
+ void erase(const NodeTy &val) {
+ for (iterator I = begin(), E = end(); I != E; ) {
+ iterator next = I; ++next;
+ if (*I == val) erase(I);
+ I = next;
+ }
+ }
+ template<class Pr1> void erase_if(Pr1 pred) {
+ for (iterator I = begin(), E = end(); I != E; ) {
+ iterator next = I; ++next;
+ if (pred(*I)) erase(I);
+ I = next;
+ }
+ }
+
+ template<class Pr2> void unique(Pr2 pred) {
+ if (empty()) return;
+ for (iterator I = begin(), E = end(), Next = begin(); ++Next != E;) {
+ if (pred(*I))
+ erase(Next);
+ else
+ I = Next;
+ Next = I;
+ }
+ }
+ void unique() { unique(op_equal); }
+
+ template<class Pr3> void merge(iplist &right, Pr3 pred) {
+ iterator first1 = begin(), last1 = end();
+ iterator first2 = right.begin(), last2 = right.end();
+ while (first1 != last1 && first2 != last2)
+ if (pred(*first2, *first1)) {
+ iterator next = first2;
+ transfer(first1, right, first2, ++next);
+ first2 = next;
+ } else {
+ ++first1;
+ }
+ if (first2 != last2) transfer(last1, right, first2, last2);
+ }
+ void merge(iplist &right) { return merge(right, op_less); }
+
+ template<class Pr3> void sort(Pr3 pred);
+ void sort() { sort(op_less); }
+ void reverse();
+};
+
+
+template<typename NodeTy>
+struct ilist : public iplist<NodeTy> {
+ ilist() {}
+ ilist(const ilist &right) {
+ insert(begin(), right.begin(), right.end());
+ }
+ explicit ilist(size_type count) {
+ insert(begin(), count, NodeTy());
+ }
+ ilist(size_type count, const NodeTy &val) {
+ insert(begin(), count, val);
+ }
+ template<class InIt> ilist(InIt first, InIt last) {
+ insert(begin(), first, last);
+ }
+
+
+ // Forwarding functions: A workaround for GCC 2.95 which does not correctly
+ // support 'using' declarations to bring a hidden member into scope.
+ //
+ iterator insert(iterator a, NodeTy *b){ return iplist<NodeTy>::insert(a, b); }
+ void push_front(NodeTy *a) { iplist<NodeTy>::push_front(a); }
+ void push_back(NodeTy *a) { iplist<NodeTy>::push_back(a); }
+
+
+ // Main implementation here - Insert for a node passed by value...
+ iterator insert(iterator where, const NodeTy &val) {
+ return insert(where, createNode(val));
+ }
+
+
+ // Front and back inserters...
+ void push_front(const NodeTy &val) { insert(begin(), val); }
+ void push_back(const NodeTy &val) { insert(end(), val); }
+
+ // Special forms of insert...
+ template<class InIt> void insert(iterator where, InIt first, InIt last) {
+ for (; first != last; ++first) insert(where, *first);
+ }
+ void insert(iterator where, size_type count, const NodeTy &val) {
+ for (; count != 0; --count) insert(where, val);
+ }
+
+ // Assign special forms...
+ void assign(size_type count, const NodeTy &val) {
+ iterator I = begin();
+ for (; I != end() && count != 0; ++I, --count)
+ *I = val;
+ if (count != 0)
+ insert(end(), n, val);
+ else
+ erase(I, end());
+ }
+ template<class InIt> void assign(InIt first, InIt last) {
+ iterator first1 = begin(), last1 = end();
+ for ( ; first1 != last1 && first2 != last2; ++first1, ++first2)
+ *first1 = *first2;
+ if (first2 == last2)
+ erase(first1, last1);
+ else
+ insert(last1, first2, last2);
+ }
+
+
+ // Resize members...
+ void resize(size_type newsize, NodeTy val) {
+ iterator i = begin();
+ size_type len = 0;
+ for ( ; i != end() && len < newsize; ++i, ++len) /* empty*/ ;
+
+ if (len == newsize)
+ erase(i, end());
+ else // i == end()
+ insert(end(), newsize - len, val);
+ }
+ void resize(size_type newsize) { resize(newsize, NodeTy()); }
+
+};
+
+namespace std {
+ // Ensure that swap uses the fast list swap...
+ template<class Ty>
+ void swap(iplist<Ty> &Left, iplist<Ty> &Right) {
+ Left.swap(Right);
+ }
+} // End 'std' extensions...
+
+#endif
diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h
index d44fa5f..d8fadc1 100644
--- a/include/llvm/Analysis/CallGraph.h
+++ b/include/llvm/Analysis/CallGraph.h
@@ -118,7 +118,7 @@ public:
virtual const char *getPassName() const { return "Call Graph Construction"; }
// run - Compute the call graph for the specified module.
- virtual bool run(Module *TheModule);
+ virtual bool run(Module &M);
// getAnalysisUsage - This obviously provides a call graph
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
diff --git a/include/llvm/Analysis/DataStructure.h b/include/llvm/Analysis/DataStructure.h
index f6b60b8..5f1617c 100644
--- a/include/llvm/Analysis/DataStructure.h
+++ b/include/llvm/Analysis/DataStructure.h
@@ -442,7 +442,7 @@ public:
virtual const char *getPassName() const { return "Data Structure Analysis"; }
// run - Do nothing, because methods are analyzed lazily
- virtual bool run(Module *TheModule) { return false; }
+ virtual bool run(Module &TheModule) { return false; }
// getDSGraph - Return the data structure graph for the specified method.
// Since method graphs are lazily computed, we may have to create one on the
diff --git a/include/llvm/Analysis/DataStructure/DataStructure.h b/include/llvm/Analysis/DataStructure/DataStructure.h
index f6b60b8..5f1617c 100644
--- a/include/llvm/Analysis/DataStructure/DataStructure.h
+++ b/include/llvm/Analysis/DataStructure/DataStructure.h
@@ -442,7 +442,7 @@ public:
virtual const char *getPassName() const { return "Data Structure Analysis"; }
// run - Do nothing, because methods are analyzed lazily
- virtual bool run(Module *TheModule) { return false; }
+ virtual bool run(Module &TheModule) { return false; }
// getDSGraph - Return the data structure graph for the specified method.
// Since method graphs are lazily computed, we may have to create one on the
diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h
index 796a779..f5a7b76 100644
--- a/include/llvm/Analysis/Dominators.h
+++ b/include/llvm/Analysis/Dominators.h
@@ -53,8 +53,8 @@ public:
private:
DomSetMapType Doms;
- void calcForwardDominatorSet(Function *F);
- void calcPostDominatorSet(Function *F);
+ void calcForwardDominatorSet(Function &F);
+ void calcPostDominatorSet(Function &F);
public:
// DominatorSet ctor - Build either the dominator set or the post-dominator
// set for a function...
@@ -69,7 +69,7 @@ public:
else return "Dominator Set Construction";
}
- virtual bool runOnFunction(Function *F);
+ virtual bool runOnFunction(Function &F);
// Accessor interface:
typedef DomSetMapType::const_iterator const_iterator;
@@ -132,7 +132,7 @@ public:
else return "Immediate Dominators Construction";
}
- virtual bool runOnFunction(Function *F) {
+ virtual bool runOnFunction(Function &F) {
IDoms.clear(); // Reset from the last time we were run...
DominatorSet *DS;
if (isPostDominator())
@@ -228,7 +228,7 @@ public:
else return "Dominator Tree Construction";
}
- virtual bool runOnFunction(Function *F) {
+ virtual bool runOnFunction(Function &F) {
reset();
DominatorSet *DS;
if (isPostDominator())
@@ -289,7 +289,7 @@ public:
else return "Dominance Frontier Construction";
}
- virtual bool runOnFunction(Function *) {
+ virtual bool runOnFunction(Function &) {
Frontiers.clear();
DominatorTree *DT;
if (isPostDominator())
diff --git a/include/llvm/Analysis/FindUnsafePointerTypes.h b/include/llvm/Analysis/FindUnsafePointerTypes.h
index 98f530c..d88b59a 100644
--- a/include/llvm/Analysis/FindUnsafePointerTypes.h
+++ b/include/llvm/Analysis/FindUnsafePointerTypes.h
@@ -41,7 +41,7 @@ public:
// values of various types. If they are deemed to be 'unsafe' note that the
// type is not safe to transform.
//
- virtual bool run(Module *M);
+ virtual bool run(Module &M);
// printResults - Loop over the results of the analysis, printing out unsafe
// types.
diff --git a/include/llvm/Analysis/FindUsedTypes.h b/include/llvm/Analysis/FindUsedTypes.h
index ece390e..55937d7 100644
--- a/include/llvm/Analysis/FindUsedTypes.h
+++ b/include/llvm/Analysis/FindUsedTypes.h
@@ -51,7 +51,7 @@ private:
public:
// run - This incorporates all types used by the specified module
//
- bool run(Module *M);
+ bool run(Module &M);
// getAnalysisUsage - Of course, we provide ourself...
//
diff --git a/include/llvm/Analysis/InstForest.h b/include/llvm/Analysis/InstForest.h
index 6e19c37..f48466b 100644
--- a/include/llvm/Analysis/InstForest.h
+++ b/include/llvm/Analysis/InstForest.h
@@ -162,22 +162,18 @@ class InstForest : public std::vector<InstTreeNode<Payload> *> {
public:
// ctor - Create an instruction forest for the specified method...
InstForest(Function *F) {
- for (Function::iterator MI = F->begin(), ME = F->end(); MI != ME; ++MI) {
- BasicBlock *BB = *MI;
- for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
- Instruction *Inst = *I;
- if (!getInstNode(Inst)) { // Do we already have a tree for this inst?
+ for (Function::iterator BB = F->begin(), BBE = F->end(); BB != BBE; ++BB)
+ for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
+ if (!getInstNode(I)) { // Do we already have a tree for this inst?
// No, create one! InstTreeNode ctor automatically adds the
// created node into our InstMap
- push_back(new InstTreeNode<Payload>(*this, Inst, 0));
+ push_back(new InstTreeNode<Payload>(*this, I, 0));
}
- }
- }
}
// dtor - Free the trees...
~InstForest() {
- for (unsigned i = size(); i > 0; --i)
+ for (unsigned i = size(); i != 0; --i)
delete operator[](i-1);
}
diff --git a/include/llvm/Analysis/IntervalIterator.h b/include/llvm/Analysis/IntervalIterator.h
index 64c1b60..5417aa7 100644
--- a/include/llvm/Analysis/IntervalIterator.h
+++ b/include/llvm/Analysis/IntervalIterator.h
@@ -93,7 +93,7 @@ public:
IntervalIterator() {} // End iterator, empty stack
IntervalIterator(Function *M, bool OwnMemory) : IOwnMem(OwnMemory) {
OrigContainer = M;
- if (!ProcessInterval(M->front())) {
+ if (!ProcessInterval(&M->front())) {
assert(0 && "ProcessInterval should never fail for first interval!");
}
}
diff --git a/include/llvm/Analysis/IntervalPartition.h b/include/llvm/Analysis/IntervalPartition.h
index ab16250..bf72286 100644
--- a/include/llvm/Analysis/IntervalPartition.h
+++ b/include/llvm/Analysis/IntervalPartition.h
@@ -42,7 +42,7 @@ public:
const char *getPassName() const { return "Interval Partition Construction"; }
// run - Calculate the interval partition for this function
- virtual bool runOnFunction(Function *F);
+ virtual bool runOnFunction(Function &F);
// IntervalPartition ctor - Build a reduced interval partition from an
// existing interval graph. This takes an additional boolean parameter to
diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index 16605e5..d5721ae 100644
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -79,16 +79,16 @@ public:
// getLoopFor - Return the inner most loop that BB lives in. If a basic block
// is in no loop (for example the entry node), null is returned.
//
- const Loop *getLoopFor(BasicBlock *BB) const {
- std::map<BasicBlock *, Loop*>::const_iterator I = BBMap.find(BB);
+ const Loop *getLoopFor(const BasicBlock *BB) const {
+ std::map<BasicBlock *, Loop*>::const_iterator I=BBMap.find((BasicBlock*)BB);
return I != BBMap.end() ? I->second : 0;
}
- inline const Loop *operator[](BasicBlock *BB) const {
+ inline const Loop *operator[](const BasicBlock *BB) const {
return getLoopFor(BB);
}
// getLoopDepth - Return the loop nesting level of the specified block...
- unsigned getLoopDepth(BasicBlock *BB) const {
+ unsigned getLoopDepth(const BasicBlock *BB) const {
const Loop *L = getLoopFor(BB);
return L ? L->getLoopDepth() : 0;
}
@@ -105,7 +105,7 @@ public:
#endif
// runOnFunction - Pass framework implementation
- virtual bool runOnFunction(Function *F);
+ virtual bool runOnFunction(Function &F);
virtual void releaseMemory();
diff --git a/include/llvm/Analysis/Verifier.h b/include/llvm/Analysis/Verifier.h
index 03de4ba..76aea04 100644
--- a/include/llvm/Analysis/Verifier.h
+++ b/include/llvm/Analysis/Verifier.h
@@ -25,10 +25,10 @@ Pass *createVerifierPass();
// verifyModule - Check a module for errors, printing messages on stderr.
// Return true if the module is corrupt.
//
-bool verifyModule(const Module *M);
+bool verifyModule(const Module &M);
// verifyFunction - Check a function for errors, useful for use when debugging a
// pass.
-bool verifyFunction(const Function *F);
+bool verifyFunction(const Function &F);
#endif
diff --git a/include/llvm/Assembly/PrintModulePass.h b/include/llvm/Assembly/PrintModulePass.h
index 83cd852..7daea4c 100644
--- a/include/llvm/Assembly/PrintModulePass.h
+++ b/include/llvm/Assembly/PrintModulePass.h
@@ -29,8 +29,8 @@ public:
if (DeleteStream) delete Out;
}
- bool run(Module *M) {
- (*Out) << M;
+ bool run(Module &M) {
+ (*Out) << (Value&)M;
return false;
}
@@ -58,8 +58,8 @@ public:
// runOnFunction - This pass just prints a banner followed by the function as
// it's processed.
//
- bool runOnFunction(Function *F) {
- (*Out) << Banner << (Value*)F;
+ bool runOnFunction(Function &F) {
+ (*Out) << Banner << (Value&)F;
return false;
}
diff --git a/include/llvm/Support/CFG.h b/include/llvm/Support/CFG.h
index db4c0c3..c2a4775 100644
--- a/include/llvm/Support/CFG.h
+++ b/include/llvm/Support/CFG.h
@@ -209,11 +209,11 @@ template <> struct GraphTraits<Inverse<const BasicBlock*> > {
// except that the root node is implicitly the first node of the function.
//
template <> struct GraphTraits<Function*> : public GraphTraits<BasicBlock*> {
- static NodeType *getEntryNode(Function *F) { return F->getEntryNode(); }
+ static NodeType *getEntryNode(Function *F) { return &F->getEntryNode(); }
};
template <> struct GraphTraits<const Function*> :
public GraphTraits<const BasicBlock*> {
- static NodeType *getEntryNode(const Function *F) { return F->getEntryNode(); }
+ static NodeType *getEntryNode(const Function *F) { return &F->getEntryNode();}
};
@@ -225,13 +225,13 @@ template <> struct GraphTraits<const Function*> :
template <> struct GraphTraits<Inverse<Function*> > :
public GraphTraits<Inverse<BasicBlock*> > {
static NodeType *getEntryNode(Inverse<Function*> G) {
- return G.Graph->front();
+ return &G.Graph->getEntryNode();
}
};
template <> struct GraphTraits<Inverse<const Function*> > :
public GraphTraits<Inverse<const BasicBlock*> > {
static NodeType *getEntryNode(Inverse<const Function *> G) {
- return G.Graph->front();
+ return &G.Graph->getEntryNode();
}
};
diff --git a/include/llvm/Support/Casting.h b/include/llvm/Support/Casting.h
index e59b7c2..2c072d1 100644
--- a/include/llvm/Support/Casting.h
+++ b/include/llvm/Support/Casting.h
@@ -8,51 +8,196 @@
#ifndef SUPPORT_CASTING_H
#define SUPPORT_CASTING_H
-// real_type - Provide a macro to get the real type of a value that might be
-// a use. This provides a typedef 'Type' that is the argument type for all
-// non UseTy types, and is the contained pointer type of the use if it is a
-// UseTy.
-//
-template <class X> class real_type { typedef X Type; };
+#include <assert.h>
//===----------------------------------------------------------------------===//
-// Type Checking Templates
+// isa<x> Support Templates
//===----------------------------------------------------------------------===//
+template<typename FromCl> struct isa_impl_cl;
+
+// Define a template that can be specialized by smart pointers to reflect the
+// fact that they are automatically dereferenced, and are not involved with the
+// template selection process... the default implementation is a noop.
+//
+template<typename From> struct simplify_type {
+ typedef From SimpleType; // The real type this represents...
+
+ // An accessor to get the real value...
+ static SimpleType &getSimplifiedValue(From &Val) { return Val; }
+};
+
+template<typename From> struct simplify_type<const From> {
+ typedef const From SimpleType;
+ static SimpleType &getSimplifiedValue(const From &Val) {
+ return simplify_type<From>::getSimplifiedValue((From&)Val);
+ }
+};
+
+
// isa<X> - Return true if the parameter to the template is an instance of the
// template type argument. Used like this:
//
-// if (isa<Type>(myVal)) { ... }
+// if (isa<Type*>(myVal)) { ... }
+//
+template <typename To, typename From>
+inline bool isa_impl(const From &Val) {
+ return To::classof(&Val);
+}
+
+template<typename To, typename From, typename SimpleType>
+struct isa_impl_wrap {
+ // When From != SimplifiedType, we can simplify the type some more by using
+ // the simplify_type template.
+ static bool doit(const From &Val) {
+ return isa_impl_cl<const SimpleType>::template
+ isa<To>(simplify_type<const From>::getSimplifiedValue(Val));
+ }
+};
+
+template<typename To, typename FromTy>
+struct isa_impl_wrap<To, const FromTy, const FromTy> {
+ // When From == SimpleType, we are as simple as we are going to get.
+ static bool doit(const FromTy &Val) {
+ return isa_impl<To,FromTy>(Val);
+ }
+};
+
+// isa_impl_cl - Use class partial specialization to transform types to a single
+// cannonical form for isa_impl.
//
+template<typename FromCl>
+struct isa_impl_cl {
+ template<class ToCl>
+ static bool isa(const FromCl &Val) {
+ return isa_impl_wrap<ToCl,const FromCl,
+ simplify_type<const FromCl>::SimpleType>::doit(Val);
+ }
+};
+
+// Specialization used to strip const qualifiers off of the FromCl type...
+template<typename FromCl>
+struct isa_impl_cl<const FromCl> {
+ template<class ToCl>
+ static bool isa(const FromCl &Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(Val);
+ }
+};
+
+// Define pointer traits in terms of base traits...
+template<class FromCl>
+struct isa_impl_cl<FromCl*> {
+ template<class ToCl>
+ static bool isa(FromCl *Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(*Val);
+ }
+};
+
+// Define reference traits in terms of base traits...
+template<class FromCl>
+struct isa_impl_cl<FromCl&> {
+ template<class ToCl>
+ static bool isa(FromCl &Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(&Val);
+ }
+};
+
template <class X, class Y>
-inline bool isa(Y Val) {
- assert(Val && "isa<Ty>(NULL) invoked!");
- return X::classof(Val);
+inline bool isa(const Y &Val) {
+ return isa_impl_cl<Y>::template isa<X>(Val);
}
+//===----------------------------------------------------------------------===//
+// cast<x> Support Templates
+//===----------------------------------------------------------------------===//
+
+template<class To, class From> struct cast_retty;
+
+
+// Calculate what type the 'cast' function should return, based on a requested
+// type of To and a source type of From.
+template<class To, class From> struct cast_retty_impl {
+ typedef To& ret_type; // Normal case, return Ty&
+};
+template<class To, class From> struct cast_retty_impl<To, const From> {
+ typedef const To &ret_type; // Normal case, return Ty&
+};
+
+template<class To, class From> struct cast_retty_impl<To, From*> {
+ typedef To* ret_type; // Pointer arg case, return Ty*
+};
+
+template<class To, class From> struct cast_retty_impl<To, const From*> {
+ typedef const To* ret_type; // Constant pointer arg case, return const Ty*
+};
+
+template<class To, class From> struct cast_retty_impl<To, const From*const> {
+ typedef const To* ret_type; // Constant pointer arg case, return const Ty*
+};
+
+
+template<class To, class From, class SimpleFrom>
+struct cast_retty_wrap {
+ // When the simplified type and the from type are not the same, use the type
+ // simplifier to reduce the type, then reuse cast_retty_impl to get the
+ // resultant type.
+ typedef typename cast_retty<To, SimpleFrom>::ret_type ret_type;
+};
+
+template<class To, class FromTy>
+struct cast_retty_wrap<To, FromTy, FromTy> {
+ // When the simplified type is equal to the from type, use it directly.
+ typedef typename cast_retty_impl<To,FromTy>::ret_type ret_type;
+};
+
+template<class To, class From>
+struct cast_retty {
+ typedef typename cast_retty_wrap<To, From,
+ simplify_type<From>::SimpleType>::ret_type ret_type;
+};
+
+// Ensure the non-simple values are converted using the simplify_type template
+// that may be specialized by smart pointers...
+//
+template<class To, class From, class SimpleFrom> struct cast_convert_val {
+ // This is not a simple type, use the template to simplify it...
+ static cast_retty<To, From>::ret_type doit(const From &Val) {
+ return cast_convert_val<To, SimpleFrom,
+ simplify_type<SimpleFrom>::SimpleType>::doit(
+ simplify_type<From>::getSimplifiedValue(Val));
+ }
+};
+
+template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
+ // This _is_ a simple type, just cast it.
+ static cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
+ return (cast_retty<To, FromTy>::ret_type)Val;
+ }
+};
+
+
// cast<X> - Return the argument parameter cast to the specified type. This
// casting operator asserts that the type is correct, so it does not return null
// on failure. But it will correctly return NULL when the input is NULL.
// Used Like this:
//
-// cast< Instruction>(myVal)->getParent()
-// cast<const Instruction>(myVal)->getParent()
+// cast<Instruction>(myVal)->getParent()
//
template <class X, class Y>
-inline X *cast(Y Val) {
+inline cast_retty<X, Y>::ret_type cast(const Y &Val) {
assert(isa<X>(Val) && "cast<Ty>() argument of uncompatible type!");
- return (X*)(real_type<Y>::Type)Val;
+ return cast_convert_val<X, Y, simplify_type<Y>::SimpleType>::doit(Val);
}
// cast_or_null<X> - Functionally identical to cast, except that a null value is
// accepted.
//
template <class X, class Y>
-inline X *cast_or_null(Y Val) {
- assert((Val == 0 || isa<X>(Val)) &&
- "cast_or_null<Ty>() argument of uncompatible type!");
- return (X*)(real_type<Y>::Type)Val;
+inline cast_retty<X, Y*>::ret_type cast_or_null(Y *Val) {
+ if (Val == 0) return 0;
+ assert(isa<X>(Val) && "cast_or_null<Ty>() argument of uncompatible type!");
+ return cast<X>(Val);
}
@@ -65,16 +210,81 @@ inline X *cast_or_null(Y Val) {
//
template <class X, class Y>
-inline X *dyn_cast(Y Val) {
- return isa<X>(Val) ? cast<X>(Val) : 0;
+inline cast_retty<X, Y*>::ret_type dyn_cast(Y *Val) {
+ return isa<X>(Val) ? cast<X, Y*>(Val) : 0;
}
// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
// value is accepted.
//
template <class X, class Y>
-inline X *dyn_cast_or_null(Y Val) {
- return (Val && isa<X>(Val)) ? cast<X>(Val) : 0;
+inline cast_retty<X, Y*>::ret_type dyn_cast_or_null(Y *Val) {
+ return (Val && isa<X>(Val)) ? cast<X, Y*>(Val) : 0;
+}
+
+
+#ifdef DEBUG_CAST_OPERATORS
+#include <iostream>
+
+struct bar {
+ bar() {}
+private:
+ bar(const bar &);
+};
+struct foo {
+ void ext() const;
+ /* static bool classof(const bar *X) {
+ cerr << "Classof: " << X << "\n";
+ return true;
+ }*/
+};
+
+template <> inline bool isa_impl<foo,bar>(const bar &Val) {
+ cerr << "Classof: " << &Val << "\n";
+ return true;
+}
+
+
+bar *fub();
+void test(bar &B1, const bar *B2) {
+ // test various configurations of const
+ const bar &B3 = B1;
+ const bar *const B4 = B2;
+
+ // test isa
+ if (!isa<foo>(B1)) return;
+ if (!isa<foo>(B2)) return;
+ if (!isa<foo>(B3)) return;
+ if (!isa<foo>(B4)) return;
+
+ // test cast
+ foo &F1 = cast<foo>(B1);
+ const foo *F3 = cast<foo>(B2);
+ const foo *F4 = cast<foo>(B2);
+ const foo &F8 = cast<foo>(B3);
+ const foo *F9 = cast<foo>(B4);
+ foo *F10 = cast<foo>(fub());
+
+ // test cast_or_null
+ const foo *F11 = cast_or_null<foo>(B2);
+ const foo *F12 = cast_or_null<foo>(B2);
+ const foo *F13 = cast_or_null<foo>(B4);
+ const foo *F14 = cast_or_null<foo>(fub()); // Shouldn't print.
+
+ // These lines are errors...
+ //foo *F20 = cast<foo>(B2); // Yields const foo*
+ //foo &F21 = cast<foo>(B3); // Yields const foo&
+ //foo *F22 = cast<foo>(B4); // Yields const foo*
+ //foo &F23 = cast_or_null<foo>(B1);
+ //const foo &F24 = cast_or_null<foo>(B3);
+}
+
+bar *fub() { return 0; }
+void main() {
+ bar B;
+ test(B, &B);
}
#endif
+
+#endif
diff --git a/include/llvm/Support/InstIterator.h b/include/llvm/Support/InstIterator.h
index b2b1058..eb64113 100644
--- a/include/llvm/Support/InstIterator.h
+++ b/include/llvm/Support/InstIterator.h
@@ -35,22 +35,22 @@ public:
typedef IIty reference;
template<class M> InstIterator(M &m)
- : BBs(m.getBasicBlocks()), BB(BBs.begin()) { // begin ctor
+ : BBs(m.getBasicBlockList()), BB(BBs.begin()) { // begin ctor
if (BB != BBs.end()) {
- BI = (*BB)->begin();
+ BI = BB->begin();
advanceToNextBB();
}
}
template<class M> InstIterator(M &m, bool)
- : BBs(m.getBasicBlocks()), BB(BBs.end()) { // end ctor
+ : BBs(m.getBasicBlockList()), BB(BBs.end()) { // end ctor
}
// Accessors to get at the underlying iterators...
inline BBIty &getBasicBlockIterator() { return BB; }
inline BIty &getInstructionIterator() { return BI; }
- inline IIty operator*() const { return *BI; }
+ inline IIty operator*() const { return &*BI; }
inline IIty operator->() const { return operator*(); }
inline bool operator==(const InstIterator &y) const {
@@ -70,9 +70,9 @@ public:
}
InstIterator& operator--() {
- while (BB == BBs.end() || BI == (*BB)->begin()) {
+ while (BB == BBs.end() || BI == BB->begin()) {
--BB;
- BI = (*BB)->end();
+ BI = BB->end();
}
--BI;
return *this;
@@ -87,19 +87,19 @@ private:
inline void advanceToNextBB() {
// The only way that the II could be broken is if it is now pointing to
// the end() of the current BasicBlock and there are successor BBs.
- while (BI == (*BB)->end()) {
+ while (BI == BB->end()) {
++BB;
if (BB == BBs.end()) break;
- BI = (*BB)->begin();
+ BI = BB->begin();
}
}
};
-typedef InstIterator<ValueHolder<BasicBlock, Function, Function>,
+typedef InstIterator<iplist<BasicBlock>,
Function::iterator, BasicBlock::iterator,
Instruction*> inst_iterator;
-typedef InstIterator<const ValueHolder<BasicBlock, Function, Function>,
+typedef InstIterator<const iplist<BasicBlock>,
Function::const_iterator,
BasicBlock::const_iterator,
const Instruction*> const_inst_iterator;
@@ -112,5 +112,13 @@ inline const_inst_iterator inst_begin(const Function *F) {
inline const_inst_iterator inst_end(const Function *F) {
return const_inst_iterator(*F, true);
}
+inline inst_iterator inst_begin(Function &F) { return inst_iterator(F); }
+inline inst_iterator inst_end(Function &F) { return inst_iterator(F, true); }
+inline const_inst_iterator inst_begin(const Function &F) {
+ return const_inst_iterator(F);
+}
+inline const_inst_iterator inst_end(const Function &F) {
+ return const_inst_iterator(F, true);
+}
#endif
diff --git a/include/llvm/Support/InstVisitor.h b/include/llvm/Support/InstVisitor.h
index fdf6731..883a6fe 100644
--- a/include/llvm/Support/InstVisitor.h
+++ b/include/llvm/Support/InstVisitor.h
@@ -57,7 +57,7 @@ class AllocationInst; class MemAccessInst;
#define DELEGATE(CLASS_TO_VISIT) \
- return ((SubClass*)this)->visit##CLASS_TO_VISIT((CLASS_TO_VISIT*)I)
+ return ((SubClass*)this)->visit##CLASS_TO_VISIT((CLASS_TO_VISIT&)I)
template<typename SubClass, typename RetTy=void>
@@ -78,26 +78,32 @@ struct InstVisitor {
// Define visitors for modules, functions and basic blocks...
//
- void visit(Module *M) {
+ void visit(Module &M) {
((SubClass*)this)->visitModule(M);
- visit(M->begin(), M->end());
+ visit(M.begin(), M.end());
}
- void visit(Function *F) {
+ void visit(Function &F) {
((SubClass*)this)->visitFunction(F);
- visit(F->begin(), F->end());
+ visit(F.begin(), F.end());
}
- void visit(BasicBlock *BB) {
+ void visit(BasicBlock &BB) {
((SubClass*)this)->visitBasicBlock(BB);
- visit(BB->begin(), BB->end());
+ visit(BB.begin(), BB.end());
}
+ // Forwarding functions so that the user can visit with pointers AND refs.
+ void visit(Module *M) { visit(*M); }
+ void visit(Function *F) { visit(*F); }
+ void visit(BasicBlock *BB) { visit(*BB); }
+ RetTy visit(Instruction *I) { return visit(*I); }
+
// visit - Finally, code to visit an instruction...
//
- RetTy visit(Instruction *I) {
- switch (I->getOpcode()) {
+ RetTy visit(Instruction &I) {
+ switch (I.getOpcode()) {
// Build the switch statement using the Instruction.def file...
#define HANDLE_INST(NUM, OPCODE, CLASS) \
- case Instruction::OPCODE:return ((SubClass*)this)->visit##OPCODE((CLASS*)I);
+ case Instruction::OPCODE:return ((SubClass*)this)->visit##OPCODE((CLASS&)I);
#include "llvm/Instruction.def"
default: assert(0 && "Unknown instruction type encountered!");
@@ -116,9 +122,9 @@ struct InstVisitor {
// When visiting a module, function or basic block directly, these methods get
// called to indicate when transitioning into a new unit.
//
- void visitModule (Module *M) {}
- void visitFunction (Function *F) {}
- void visitBasicBlock(BasicBlock *BB) {}
+ void visitModule (Module &M) {}
+ void visitFunction (Function &F) {}
+ void visitBasicBlock(BasicBlock &BB) {}
// Define instruction specific visitor functions that can be overridden to
@@ -133,49 +139,49 @@ struct InstVisitor {
// this, we do not autoexpand "Other" instructions, we do it manually.
//
#define HANDLE_INST(NUM, OPCODE, CLASS) \
- RetTy visit##OPCODE(CLASS *I) { DELEGATE(CLASS); }
+ RetTy visit##OPCODE(CLASS &I) { DELEGATE(CLASS); }
#define HANDLE_OTHER_INST(NUM, OPCODE, CLASS) // Ignore "other" instructions
#include "llvm/Instruction.def"
// Implement all "other" instructions, except for PHINode
- RetTy visitCast(CastInst *I) { DELEGATE(CastInst); }
- RetTy visitCall(CallInst *I) { DELEGATE(CallInst); }
- RetTy visitShr(ShiftInst *I) { DELEGATE(ShiftInst); }
- RetTy visitShl(ShiftInst *I) { DELEGATE(ShiftInst); }
- RetTy visitUserOp1(Instruction *I) { DELEGATE(Instruction); }
- RetTy visitUserOp2(Instruction *I) { DELEGATE(Instruction); }
+ RetTy visitCast(CastInst &I) { DELEGATE(CastInst); }
+ RetTy visitCall(CallInst &I) { DELEGATE(CallInst); }
+ RetTy visitShr(ShiftInst &I) { DELEGATE(ShiftInst); }
+ RetTy visitShl(ShiftInst &I) { DELEGATE(ShiftInst); }
+ RetTy visitUserOp1(Instruction &I) { DELEGATE(Instruction); }
+ RetTy visitUserOp2(Instruction &I) { DELEGATE(Instruction); }
// Specific Instruction type classes... note that all of the casts are
// neccesary because we use the instruction classes as opaque types...
//
- RetTy visitReturnInst(ReturnInst *I) { DELEGATE(TerminatorInst);}
- RetTy visitBranchInst(BranchInst *I) { DELEGATE(TerminatorInst);}
- RetTy visitSwitchInst(SwitchInst *I) { DELEGATE(TerminatorInst);}
- RetTy visitInvokeInst(InvokeInst *I) { DELEGATE(TerminatorInst);}
- RetTy visitGenericUnaryInst(GenericUnaryInst *I) { DELEGATE(UnaryOperator); }
- RetTy visitGenericBinaryInst(GenericBinaryInst *I){ DELEGATE(BinaryOperator);}
- RetTy visitSetCondInst(SetCondInst *I) { DELEGATE(BinaryOperator);}
- RetTy visitMallocInst(MallocInst *I) { DELEGATE(AllocationInst);}
- RetTy visitAllocaInst(AllocaInst *I) { DELEGATE(AllocationInst);}
- RetTy visitFreeInst(FreeInst *I) { DELEGATE(Instruction); }
- RetTy visitLoadInst(LoadInst *I) { DELEGATE(MemAccessInst); }
- RetTy visitStoreInst(StoreInst *I) { DELEGATE(MemAccessInst); }
- RetTy visitGetElementPtrInst(GetElementPtrInst *I){ DELEGATE(MemAccessInst); }
- RetTy visitPHINode(PHINode *I) { DELEGATE(Instruction); }
- RetTy visitCastInst(CastInst *I) { DELEGATE(Instruction); }
- RetTy visitCallInst(CallInst *I) { DELEGATE(Instruction); }
- RetTy visitShiftInst(ShiftInst *I) { DELEGATE(Instruction); }
+ RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitInvokeInst(InvokeInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitGenericUnaryInst(GenericUnaryInst &I) { DELEGATE(UnaryOperator); }
+ RetTy visitGenericBinaryInst(GenericBinaryInst &I){ DELEGATE(BinaryOperator);}
+ RetTy visitSetCondInst(SetCondInst &I) { DELEGATE(BinaryOperator);}
+ RetTy visitMallocInst(MallocInst &I) { DELEGATE(AllocationInst);}
+ RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(AllocationInst);}
+ RetTy visitFreeInst(FreeInst &I) { DELEGATE(Instruction); }
+ RetTy visitLoadInst(LoadInst &I) { DELEGATE(MemAccessInst); }
+ RetTy visitStoreInst(StoreInst &I) { DELEGATE(MemAccessInst); }
+ RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(MemAccessInst); }
+ RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction); }
+ RetTy visitCastInst(CastInst &I) { DELEGATE(Instruction); }
+ RetTy visitCallInst(CallInst &I) { DELEGATE(Instruction); }
+ RetTy visitShiftInst(ShiftInst &I) { DELEGATE(Instruction); }
// Next level propogators... if the user does not overload a specific
// instruction type, they can overload one of these to get the whole class
// of instructions...
//
- RetTy visitTerminatorInst(TerminatorInst *I) { DELEGATE(Instruction); }
- RetTy visitUnaryOperator (UnaryOperator *I) { DELEGATE(Instruction); }
- RetTy visitBinaryOperator(BinaryOperator *I) { DELEGATE(Instruction); }
- RetTy visitAllocationInst(AllocationInst *I) { DELEGATE(Instruction); }
- RetTy visitMemAccessInst (MemAccessInst *I) { DELEGATE(Instruction); }
+ RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction); }
+ RetTy visitUnaryOperator (UnaryOperator &I) { DELEGATE(Instruction); }
+ RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction); }
+ RetTy visitAllocationInst(AllocationInst &I) { DELEGATE(Instruction); }
+ RetTy visitMemAccessInst (MemAccessInst &I) { DELEGATE(Instruction); }
// If the user wants a 'default' case, they can choose to override this
// function. If this function is not overloaded in the users subclass, then
@@ -183,7 +189,7 @@ struct InstVisitor {
//
// Note that you MUST override this function if your return type is not void.
//
- void visitInstruction(Instruction *I) {} // Ignore unhandled instructions
+ void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
};
#undef DELEGATE
diff --git a/include/llvm/Transforms/MutateStructTypes.h b/include/llvm/Transforms/MutateStructTypes.h
index e1fbeda..26da666 100644
--- a/include/llvm/Transforms/MutateStructTypes.h
+++ b/include/llvm/Transforms/MutateStructTypes.h
@@ -58,7 +58,7 @@ public:
}
// run - do the transformation
- virtual bool run(Module *M);
+ virtual bool run(Module &M);
protected:
@@ -76,7 +76,7 @@ private:
// functions for functions than need to be copied because they have a new
// signature type.
//
- void processGlobals(Module *M);
+ void processGlobals(Module &M);
// transformFunction - This transforms the instructions of the function to use
// the new types.
@@ -86,7 +86,7 @@ private:
// removeDeadGlobals - This removes the old versions of functions that are no
// longer needed.
//
- void removeDeadGlobals(Module *M);
+ void removeDeadGlobals(Module &M);
private:
// ConvertType - Convert from the old type system to the new one...
generated by cgit v1.1 at 2025-02-02 14:48:26 +0000