X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FUser.h;h=df303d0dd5f289e24accff8608da0dd1b486d868;hb=7f00f87767036e74445aad0164eea13cf2642610;hp=aba56d5819ef1242a8cc643832165517bbad936f;hpb=6fbcc26f1460eaee4e0eb8b426fc1ff0c7af11be;p=oota-llvm.git diff --git a/include/llvm/User.h b/include/llvm/User.h index aba56d5819e..df303d0dd5f 100644 --- a/include/llvm/User.h +++ b/include/llvm/User.h @@ -1,17 +1,17 @@ //===-- llvm/User.h - User class definition ---------------------*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// // -// This class defines the interface that one who 'use's a Value must implement. +// This class defines the interface that one who uses a Value must implement. // Each instance of the Value class keeps track of what User's have handles // to it. // -// * Instructions are the largest class of User's. +// * Instructions are the largest class of Users. // * Constants may be users of other constants (think arrays and stuff) // //===----------------------------------------------------------------------===// @@ -19,61 +19,155 @@ #ifndef LLVM_USER_H #define LLVM_USER_H +#include "llvm/Support/ErrorHandling.h" #include "llvm/Value.h" -#include + +namespace llvm { + +/// OperandTraits - Compile-time customization of +/// operand-related allocators and accessors +/// for use of the User class +template +struct OperandTraits; class User : public Value { - User(const User &); // Do not implement + User(const User &) LLVM_DELETED_FUNCTION; + void *operator new(size_t) LLVM_DELETED_FUNCTION; + template + friend struct HungoffOperandTraits; + virtual void anchor(); protected: - std::vector Operands; -public: - User(const Type *Ty, ValueTy vty, const std::string &name = ""); + /// OperandList - This is a pointer to the array of Uses for this User. + /// For nodes of fixed arity (e.g. a binary operator) this array will live + /// prefixed to some derived class instance. For nodes of resizable variable + /// arity (e.g. PHINodes, SwitchInst etc.), this memory will be dynamically + /// allocated and should be destroyed by the classes' virtual dtor. + Use *OperandList; + + /// NumOperands - The number of values used by this User. + /// + unsigned NumOperands; - inline Value *getOperand(unsigned i) { - assert(i < Operands.size() && "getOperand() out of range!"); - return Operands[i]; + void *operator new(size_t s, unsigned Us); + User(Type *ty, unsigned vty, Use *OpList, unsigned NumOps) + : Value(ty, vty), OperandList(OpList), NumOperands(NumOps) {} + Use *allocHungoffUses(unsigned) const; + void dropHungoffUses() { + Use::zap(OperandList, OperandList + NumOperands, true); + OperandList = 0; + // Reset NumOperands so User::operator delete() does the right thing. + NumOperands = 0; + } +public: + ~User() { + Use::zap(OperandList, OperandList + NumOperands); + } + /// operator delete - free memory allocated for User and Use objects + void operator delete(void *Usr); + /// placement delete - required by std, but never called. + void operator delete(void*, unsigned) { + llvm_unreachable("Constructor throws?"); + } + /// placement delete - required by std, but never called. + void operator delete(void*, unsigned, bool) { + llvm_unreachable("Constructor throws?"); + } +protected: + template static Use &OpFrom(const U *that) { + return Idx < 0 + ? OperandTraits::op_end(const_cast(that))[Idx] + : OperandTraits::op_begin(const_cast(that))[Idx]; + } + template Use &Op() { + return OpFrom(this); + } + template const Use &Op() const { + return OpFrom(this); + } +public: + Value *getOperand(unsigned i) const { + assert(i < NumOperands && "getOperand() out of range!"); + return OperandList[i]; + } + void setOperand(unsigned i, Value *Val) { + assert(i < NumOperands && "setOperand() out of range!"); + assert((!isa((const Value*)this) || + isa((const Value*)this)) && + "Cannot mutate a constant with setOperand!"); + OperandList[i] = Val; } - inline const Value *getOperand(unsigned i) const { - assert(i < Operands.size() && "getOperand() const out of range!"); - return Operands[i]; + const Use &getOperandUse(unsigned i) const { + assert(i < NumOperands && "getOperandUse() out of range!"); + return OperandList[i]; } - inline void setOperand(unsigned i, Value *Val) { - assert(i < Operands.size() && "setOperand() out of range!"); - Operands[i] = Val; + Use &getOperandUse(unsigned i) { + assert(i < NumOperands && "getOperandUse() out of range!"); + return OperandList[i]; } - inline unsigned getNumOperands() const { return Operands.size(); } + + unsigned getNumOperands() const { return NumOperands; } // --------------------------------------------------------------------------- // Operand Iterator interface... // - typedef std::vector::iterator op_iterator; - typedef std::vector::const_iterator const_op_iterator; + typedef Use* op_iterator; + typedef const Use* const_op_iterator; - void op_reserve(unsigned NumElements) { Operands.reserve(NumElements); } + inline op_iterator op_begin() { return OperandList; } + inline const_op_iterator op_begin() const { return OperandList; } + inline op_iterator op_end() { return OperandList+NumOperands; } + inline const_op_iterator op_end() const { return OperandList+NumOperands; } - inline op_iterator op_begin() { return Operands.begin(); } - inline const_op_iterator op_begin() const { return Operands.begin(); } - inline op_iterator op_end() { return Operands.end(); } - inline const_op_iterator op_end() const { return Operands.end(); } + /// Convenience iterator for directly iterating over the Values in the + /// OperandList + class value_op_iterator : public std::iterator { + op_iterator OI; + public: + explicit value_op_iterator(Use *U) : OI(U) {} - /// op_erase - This method is used to remove one of the arguments from the - /// operands list. Only use this if you know what you are doing. - /// - op_iterator op_erase(op_iterator I) { return Operands.erase(I); } - op_iterator op_erase(op_iterator I, op_iterator E) { - return Operands.erase(I, E); + bool operator==(const value_op_iterator &x) const { + return OI == x.OI; + } + bool operator!=(const value_op_iterator &x) const { + return !operator==(x); + } + + /// Iterator traversal: forward iteration only + value_op_iterator &operator++() { // Preincrement + ++OI; + return *this; + } + value_op_iterator operator++(int) { // Postincrement + value_op_iterator tmp = *this; ++*this; return tmp; + } + + /// Retrieve a pointer to the current Value. + Value *operator*() const { + return *OI; + } + + Value *operator->() const { return operator*(); } + }; + + inline value_op_iterator value_op_begin() { + return value_op_iterator(op_begin()); + } + inline value_op_iterator value_op_end() { + return value_op_iterator(op_end()); } // dropAllReferences() - This function is in charge of "letting go" of all // objects that this User refers to. This allows one to // 'delete' a whole class at a time, even though there may be circular - // references... first all references are dropped, and all use counts go to - // zero. Then everything is delete'd for real. Note that no operations are - // valid on an object that has "dropped all references", except operator + // references... First all references are dropped, and all use counts go to + // zero. Then everything is deleted for real. Note that no operations are + // valid on an object that has "dropped all references", except operator // delete. // - inline void dropAllReferences() { - Operands.clear(); + void dropAllReferences() { + for (op_iterator i = op_begin(), e = op_end(); i != e; ++i) + i->set(0); } /// replaceUsesOfWith - Replaces all references to the "From" definition with @@ -82,32 +176,40 @@ public: void replaceUsesOfWith(Value *From, Value *To); // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const User *) { return true; } static inline bool classof(const Value *V) { - return V->getValueType() == Value::GlobalVariableVal || - V->getValueType() == Value::ConstantVal || - V->getValueType() == Value::InstructionVal; + return isa(V) || isa(V); } }; template<> struct simplify_type { typedef Value* SimpleType; - + static SimpleType getSimplifiedValue(const User::op_iterator &Val) { - return (SimpleType)Val->get(); + return static_cast(Val->get()); } }; + template<> struct simplify_type : public simplify_type {}; template<> struct simplify_type { typedef Value* SimpleType; - + static SimpleType getSimplifiedValue(const User::const_op_iterator &Val) { - return (SimpleType)Val->get(); + return static_cast(Val->get()); } }; + template<> struct simplify_type : public simplify_type {}; + +// value_use_iterator::getOperandNo - Requires the definition of the User class. +template +unsigned value_use_iterator::getOperandNo() const { + return U - U->getUser()->op_begin(); +} + +} // End llvm namespace + #endif