#ifndef LLVM_IR_USE_H
#define LLVM_IR_USE_H
-#include "llvm-c/Core.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/Support/CBindingWrapping.h"
#include "llvm/Support/Compiler.h"
class Value;
class User;
class Use;
-template<typename>
-struct simplify_type;
+template <typename> struct simplify_type;
// Use** is only 4-byte aligned.
-template<>
-class PointerLikeTypeTraits<Use**> {
+template <> class PointerLikeTypeTraits<Use **> {
public:
- static inline void *getAsVoidPointer(Use** P) { return P; }
+ static inline void *getAsVoidPointer(Use **P) { return P; }
static inline Use **getFromVoidPointer(void *P) {
- return static_cast<Use**>(P);
+ return static_cast<Use **>(P);
}
enum { NumLowBitsAvailable = 2 };
};
/// implicit. The implicit pointer is found via a waymarking algorithm
/// described in the programmer's manual:
///
-/// http://www.llvm.org/docs/ProgrammersManual.html#UserLayout
+/// http://www.llvm.org/docs/ProgrammersManual.html#the-waymarking-algorithm
///
/// This is essentially the single most memory intensive object in LLVM because
/// of the number of uses in the system. At the same time, the constant time
// A type for the word following an array of hung-off Uses in memory, which is
// a pointer back to their User with the bottom bit set.
- typedef PointerIntPair<User*, 1, unsigned> UserRef;
+ typedef PointerIntPair<User *, 1, unsigned> UserRef;
private:
- Use(const Use &U) LLVM_DELETED_FUNCTION;
+ Use(const Use &U) = delete;
/// Destructor - Only for zap()
~Use() {
- if (Val) removeFromList();
+ if (Val)
+ removeFromList();
}
- enum PrevPtrTag { zeroDigitTag
- , oneDigitTag
- , stopTag
- , fullStopTag };
+ enum PrevPtrTag { zeroDigitTag, oneDigitTag, stopTag, fullStopTag };
/// Constructor
- Use(PrevPtrTag tag) : Val(0) {
- Prev.setInt(tag);
- }
+ Use(PrevPtrTag tag) : Val(nullptr) { Prev.setInt(tag); }
public:
- operator Value*() const { return Val; }
+ operator Value *() const { return Val; }
Value *get() const { return Val; }
/// \brief Returns the User that contains this Use.
return *this;
}
- Value *operator->() { return Val; }
+ Value *operator->() { return Val; }
const Value *operator->() const { return Val; }
Use *getNext() const { return Next; }
+ /// \brief Return the operand # of this use in its User.
+ unsigned getOperandNo() const;
+
/// \brief Initializes the waymarking tags on an array of Uses.
///
/// This sets up the array of Uses such that getUser() can find the User from
static void zap(Use *Start, const Use *Stop, bool del = false);
private:
- const Use* getImpliedUser() const;
+ const Use *getImpliedUser() const;
Value *Val;
Use *Next;
- PointerIntPair<Use**, 2, PrevPtrTag> Prev;
+ PointerIntPair<Use **, 2, PrevPtrTag> Prev;
- void setPrev(Use **NewPrev) {
- Prev.setPointer(NewPrev);
- }
+ void setPrev(Use **NewPrev) { Prev.setPointer(NewPrev); }
void addToList(Use **List) {
Next = *List;
- if (Next) Next->setPrev(&Next);
+ if (Next)
+ Next->setPrev(&Next);
setPrev(List);
*List = this;
}
void removeFromList() {
Use **StrippedPrev = Prev.getPointer();
*StrippedPrev = Next;
- if (Next) Next->setPrev(StrippedPrev);
+ if (Next)
+ Next->setPrev(StrippedPrev);
}
friend class Value;
/// \brief Allow clients to treat uses just like values when using
/// casting operators.
-template<> struct simplify_type<Use> {
- typedef Value* SimpleType;
- static SimpleType getSimplifiedValue(Use &Val) {
- return Val.get();
- }
-};
-template<> struct simplify_type<const Use> {
- typedef /*const*/ Value* SimpleType;
- static SimpleType getSimplifiedValue(const Use &Val) {
- return Val.get();
- }
+template <> struct simplify_type<Use> {
+ typedef Value *SimpleType;
+ static SimpleType getSimplifiedValue(Use &Val) { return Val.get(); }
};
-
-
-
-template<typename UserTy> // UserTy == 'User' or 'const User'
-class value_use_iterator : public std::iterator<std::forward_iterator_tag,
- UserTy*, ptrdiff_t> {
- typedef std::iterator<std::forward_iterator_tag, UserTy*, ptrdiff_t> super;
- typedef value_use_iterator<UserTy> _Self;
-
- Use *U;
- explicit value_use_iterator(Use *u) : U(u) {}
- friend class Value;
-public:
- typedef typename super::reference reference;
- typedef typename super::pointer pointer;
-
- value_use_iterator() {}
-
- bool operator==(const _Self &x) const {
- return U == x.U;
- }
- bool operator!=(const _Self &x) const {
- return !operator==(x);
- }
-
- /// \brief Returns true if this iterator is equal to use_end() on the value.
- bool atEnd() const { return U == 0; }
-
- // Iterator traversal: forward iteration only
- _Self &operator++() { // Preincrement
- assert(U && "Cannot increment end iterator!");
- U = U->getNext();
- return *this;
- }
- _Self operator++(int) { // Postincrement
- _Self tmp = *this; ++*this; return tmp;
- }
-
- // Retrieve a pointer to the current User.
- UserTy *operator*() const {
- assert(U && "Cannot dereference end iterator!");
- return U->getUser();
- }
-
- UserTy *operator->() const { return operator*(); }
-
- Use &getUse() const { return *U; }
-
- /// \brief Return the operand # of this use in its User.
- ///
- /// Defined in User.h
- unsigned getOperandNo() const;
+template <> struct simplify_type<const Use> {
+ typedef /*const*/ Value *SimpleType;
+ static SimpleType getSimplifiedValue(const Use &Val) { return Val.get(); }
};
// Create wrappers for C Binding types (see CBindingWrapping.h).
projects / oota-llvm.git / blobdiff