X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FIntrinsicInst.h;h=9b2afd56e05f5b098b3b10d4722795216757c497;hb=b09c146b116359616f6cbd4c8b3328607e00ff42;hp=245cbfb08c400304cb2747462483aadecd608d28;hpb=9769ab22265b313171d201b5928688524a01bd87;p=oota-llvm.git diff --git a/include/llvm/IntrinsicInst.h b/include/llvm/IntrinsicInst.h index 245cbfb08c4..9b2afd56e05 100644 --- a/include/llvm/IntrinsicInst.h +++ b/include/llvm/IntrinsicInst.h @@ -1,9 +1,9 @@ -//===-- llvm/InstrinsicInst.h - Intrinsic Instruction Wrappers --*- C++ -*-===// +//===-- llvm/IntrinsicInst.h - Intrinsic Instruction Wrappers ---*- 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. // //===----------------------------------------------------------------------===// // @@ -30,220 +30,287 @@ #include "llvm/Intrinsics.h" namespace llvm { + /// IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic + /// functions. This allows the standard isa/dyncast/cast functionality to + /// work with calls to intrinsic functions. class IntrinsicInst : public CallInst { - IntrinsicInst(); // DO NOT IMPLEMENT - IntrinsicInst(const IntrinsicInst&); // DO NOT IMPLEMENT - void operator=(const IntrinsicInst&); // DO NOT IMPLEMENT + IntrinsicInst() LLVM_DELETED_FUNCTION; + IntrinsicInst(const IntrinsicInst&) LLVM_DELETED_FUNCTION; + void operator=(const IntrinsicInst&) LLVM_DELETED_FUNCTION; public: - - /// StripPointerCasts - This static method strips off any unneeded pointer - /// casts from the specified value, returning the original uncasted value. - /// Note that the returned value is guaranteed to have pointer type. - static Value *StripPointerCasts(Value *Ptr); - }; - - /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics - /// - struct DbgInfoIntrinsic : public IntrinsicInst { - - Value *getChain() const { return const_cast(getOperand(1)); } + /// getIntrinsicID - Return the intrinsic ID of this intrinsic. + /// + Intrinsic::ID getIntrinsicID() const { + return (Intrinsic::ID)getCalledFunction()->getIntrinsicID(); + } // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const DbgInfoIntrinsic *) { return true; } static inline bool classof(const CallInst *I) { if (const Function *CF = I->getCalledFunction()) - switch (CF->getIntrinsicID()) { - case Intrinsic::dbg_stoppoint: - case Intrinsic::dbg_region_start: - case Intrinsic::dbg_region_end: - case Intrinsic::dbg_func_start: - case Intrinsic::dbg_declare: - return true; - default: break; - } + return CF->getIntrinsicID() != 0; return false; } static inline bool classof(const Value *V) { return isa(V) && classof(cast(V)); } }; + + /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics + /// + class DbgInfoIntrinsic : public IntrinsicInst { + public: + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const IntrinsicInst *I) { + switch (I->getIntrinsicID()) { + case Intrinsic::dbg_declare: + case Intrinsic::dbg_value: + return true; + default: return false; + } + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } - /// DbgStopPointInst - This represent llvm.dbg.stoppoint instructions. + static Value *StripCast(Value *C); + }; + + /// DbgDeclareInst - This represents the llvm.dbg.declare instruction. /// - struct DbgStopPointInst : public DbgInfoIntrinsic { + class DbgDeclareInst : public DbgInfoIntrinsic { + public: + Value *getAddress() const; + MDNode *getVariable() const { return cast(getArgOperand(1)); } - unsigned getLineNo() const { - return unsigned(cast(getOperand(2))->getRawValue()); + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::dbg_declare; } - unsigned getColNo() const { - return unsigned(cast(getOperand(3))->getRawValue()); + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); } - Value *getContext() const { return const_cast(getOperand(4)); } + }; + /// DbgValueInst - This represents the llvm.dbg.value instruction. + /// + class DbgValueInst : public DbgInfoIntrinsic { + public: + const Value *getValue() const; + Value *getValue(); + uint64_t getOffset() const { + return cast( + const_cast(getArgOperand(1)))->getZExtValue(); + } + MDNode *getVariable() const { return cast(getArgOperand(2)); } // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const DbgStopPointInst *) { return true; } - static inline bool classof(const CallInst *I) { - if (const Function *CF = I->getCalledFunction()) - return CF->getIntrinsicID() == Intrinsic::dbg_stoppoint; - return false; + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::dbg_value; } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } }; /// MemIntrinsic - This is the common base class for memset/memcpy/memmove. /// - struct MemIntrinsic : public IntrinsicInst { - Value *getRawDest() const { return const_cast(getOperand(1)); } + class MemIntrinsic : public IntrinsicInst { + public: + Value *getRawDest() const { return const_cast(getArgOperand(0)); } - Value *getLength() const { return const_cast(getOperand(3)); } - ConstantInt *getAlignment() const { - return cast(const_cast(getOperand(4))); + Value *getLength() const { return const_cast(getArgOperand(2)); } + ConstantInt *getAlignmentCst() const { + return cast(const_cast(getArgOperand(3))); + } + + unsigned getAlignment() const { + return getAlignmentCst()->getZExtValue(); + } + + ConstantInt *getVolatileCst() const { + return cast(const_cast(getArgOperand(4))); + } + bool isVolatile() const { + return !getVolatileCst()->isZero(); + } + + unsigned getDestAddressSpace() const { + return cast(getRawDest()->getType())->getAddressSpace(); } /// getDest - This is just like getRawDest, but it strips off any cast /// instructions that feed it, giving the original input. The returned /// value is guaranteed to be a pointer. - Value *getDest() const { return StripPointerCasts(getRawDest()); } + Value *getDest() const { return getRawDest()->stripPointerCasts(); } /// set* - Set the specified arguments of the instruction. /// void setDest(Value *Ptr) { assert(getRawDest()->getType() == Ptr->getType() && "setDest called with pointer of wrong type!"); - setOperand(1, Ptr); + setArgOperand(0, Ptr); } void setLength(Value *L) { assert(getLength()->getType() == L->getType() && "setLength called with value of wrong type!"); - setOperand(3, L); + setArgOperand(2, L); } - void setAlignment(ConstantInt *A) { - assert(getAlignment()->getType() == A->getType() && - "setAlignment called with value of wrong type!"); - setOperand(4, A); + + void setAlignment(Constant* A) { + setArgOperand(3, A); + } + + void setVolatile(Constant* V) { + setArgOperand(4, V); + } + + Type *getAlignmentType() const { + return getArgOperand(3)->getType(); } // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const MemIntrinsic *) { return true; } - static inline bool classof(const CallInst *I) { - if (const Function *CF = I->getCalledFunction()) - switch (CF->getIntrinsicID()) { - case Intrinsic::memcpy: - case Intrinsic::memmove: - case Intrinsic::memset: - return true; - default: break; - } - return false; + static inline bool classof(const IntrinsicInst *I) { + switch (I->getIntrinsicID()) { + case Intrinsic::memcpy: + case Intrinsic::memmove: + case Intrinsic::memset: + return true; + default: return false; + } } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } }; - - /// MemCpyInst - This class wraps the llvm.memcpy intrinsic. + /// MemSetInst - This class wraps the llvm.memset intrinsic. /// - struct MemCpyInst : public MemIntrinsic { + class MemSetInst : public MemIntrinsic { + public: /// get* - Return the arguments to the instruction. /// - Value *getRawSource() const { return const_cast(getOperand(2)); } - - /// getSource - This is just like getRawSource, but it strips off any cast - /// instructions that feed it, giving the original input. The returned - /// value is guaranteed to be a pointer. - Value *getSource() const { return StripPointerCasts(getRawSource()); } + Value *getValue() const { return const_cast(getArgOperand(1)); } - - void setSource(Value *Ptr) { - assert(getRawSource()->getType() == Ptr->getType() && - "setSource called with pointer of wrong type!"); - setOperand(2, Ptr); + void setValue(Value *Val) { + assert(getValue()->getType() == Val->getType() && + "setValue called with value of wrong type!"); + setArgOperand(1, Val); } // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const MemCpyInst *) { return true; } - static inline bool classof(const MemIntrinsic *I) { - return I->getCalledFunction()->getIntrinsicID() == Intrinsic::memcpy; - } - static inline bool classof(const CallInst *I) { - if (const Function *CF = I->getCalledFunction()) - if (CF->getIntrinsicID() == Intrinsic::memcpy) - return true; - return false; + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::memset; } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } }; - /// MemMoveInst - This class wraps the llvm.memmove intrinsic. + /// MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics. /// - struct MemMoveInst : public MemIntrinsic { + class MemTransferInst : public MemIntrinsic { + public: /// get* - Return the arguments to the instruction. /// - Value *getRawSource() const { return const_cast(getOperand(2)); } + Value *getRawSource() const { return const_cast(getArgOperand(1)); } /// getSource - This is just like getRawSource, but it strips off any cast /// instructions that feed it, giving the original input. The returned /// value is guaranteed to be a pointer. - Value *getSource() const { return StripPointerCasts(getRawSource()); } + Value *getSource() const { return getRawSource()->stripPointerCasts(); } + + unsigned getSourceAddressSpace() const { + return cast(getRawSource()->getType())->getAddressSpace(); + } void setSource(Value *Ptr) { assert(getRawSource()->getType() == Ptr->getType() && "setSource called with pointer of wrong type!"); - setOperand(2, Ptr); + setArgOperand(1, Ptr); } // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const MemMoveInst *) { return true; } - static inline bool classof(const MemIntrinsic *I) { - return I->getCalledFunction()->getIntrinsicID() == Intrinsic::memmove; + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::memcpy || + I->getIntrinsicID() == Intrinsic::memmove; } - static inline bool classof(const CallInst *I) { - if (const Function *CF = I->getCalledFunction()) - if (CF->getIntrinsicID() == Intrinsic::memmove) - return true; - return false; + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; + + + /// MemCpyInst - This class wraps the llvm.memcpy intrinsic. + /// + class MemCpyInst : public MemTransferInst { + public: + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::memcpy; } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } }; - /// MemSetInst - This class wraps the llvm.memcpy intrinsic. + /// MemMoveInst - This class wraps the llvm.memmove intrinsic. /// - struct MemSetInst : public MemIntrinsic { - /// get* - Return the arguments to the instruction. - /// - Value *getValue() const { return const_cast(getOperand(2)); } + class MemMoveInst : public MemTransferInst { + public: + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::memmove; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; - void setValue(Value *Val) { - assert(getValue()->getType() == Val->getType() && - "setSource called with pointer of wrong type!"); - setOperand(2, Val); + /// VAStartInst - This represents the llvm.va_start intrinsic. + /// + class VAStartInst : public IntrinsicInst { + public: + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::vastart; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); } - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const MemSetInst *) { return true; } - static inline bool classof(const MemIntrinsic *I) { - return I->getCalledFunction()->getIntrinsicID() == Intrinsic::memset; + Value *getArgList() const { return const_cast(getArgOperand(0)); } + }; + + /// VAEndInst - This represents the llvm.va_end intrinsic. + /// + class VAEndInst : public IntrinsicInst { + public: + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::vaend; } - static inline bool classof(const CallInst *I) { - if (const Function *CF = I->getCalledFunction()) - if (CF->getIntrinsicID() == Intrinsic::memset) - return true; - return false; + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + + Value *getArgList() const { return const_cast(getArgOperand(0)); } + }; + + /// VACopyInst - This represents the llvm.va_copy intrinsic. + /// + class VACopyInst : public IntrinsicInst { + public: + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::vacopy; } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } + + Value *getDest() const { return const_cast(getArgOperand(0)); } + Value *getSrc() const { return const_cast(getArgOperand(1)); } }; + } #endif