X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FIntrinsicInst.h;h=8f5e05f70cd797d9c3a291f48fc11edf5bfaf9c1;hb=50564ebc9e3d7ff806062023e6511e91065df0d2;hp=911ae1031fc785e4e0d055497190f8ba01faac3c;hpb=84e48b860d9d864ccdbfa9c7b35a9ee4d74650f6;p=oota-llvm.git diff --git a/include/llvm/IntrinsicInst.h b/include/llvm/IntrinsicInst.h index 911ae1031fc..8f5e05f70cd 100644 --- a/include/llvm/IntrinsicInst.h +++ b/include/llvm/IntrinsicInst.h @@ -1,10 +1,10 @@ -//===-- 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. +// //===----------------------------------------------------------------------===// // // This file defines classes that make it really easy to deal with intrinsic @@ -30,18 +30,145 @@ #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 public: + /// 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 IntrinsicInst *) { return true; } + static inline bool classof(const CallInst *I) { + if (const Function *CF = I->getCalledFunction()) + return CF->getIntrinsicID() != 0; + return false; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; - /// 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 { + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const DbgInfoIntrinsic *) { return true; } + static inline bool classof(const IntrinsicInst *I) { + switch (I->getIntrinsicID()) { + case Intrinsic::dbg_stoppoint: + case Intrinsic::dbg_func_start: + case Intrinsic::dbg_region_start: + case Intrinsic::dbg_region_end: + case Intrinsic::dbg_declare: + return true; + default: return false; + } + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + + static Value *StripCast(Value *C); }; + /// DbgStopPointInst - This represents the llvm.dbg.stoppoint instruction. + /// + struct DbgStopPointInst : public DbgInfoIntrinsic { + Value *getLineValue() const { return const_cast(getOperand(1)); } + Value *getColumnValue() const { return const_cast(getOperand(2)); } + Value *getContext() const { + return StripCast(getOperand(3)); + } + + unsigned getLine() const { + return unsigned(cast(getOperand(1))->getZExtValue()); + } + unsigned getColumn() const { + return unsigned(cast(getOperand(2))->getZExtValue()); + } + + Value* getFileName() const; + Value* getDirectory() const; + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const DbgStopPointInst *) { return true; } + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::dbg_stoppoint; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; + + /// DbgFuncStartInst - This represents the llvm.dbg.func.start instruction. + /// + struct DbgFuncStartInst : public DbgInfoIntrinsic { + Value *getSubprogram() const { return StripCast(getOperand(1)); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const DbgFuncStartInst *) { return true; } + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::dbg_func_start; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; + + /// DbgRegionStartInst - This represents the llvm.dbg.region.start + /// instruction. + struct DbgRegionStartInst : public DbgInfoIntrinsic { + Value *getContext() const { return StripCast(getOperand(1)); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const DbgRegionStartInst *) { return true; } + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::dbg_region_start; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; + + /// DbgRegionEndInst - This represents the llvm.dbg.region.end instruction. + /// + struct DbgRegionEndInst : public DbgInfoIntrinsic { + Value *getContext() const { return StripCast(getOperand(1)); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const DbgRegionEndInst *) { return true; } + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::dbg_region_end; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; + + /// DbgDeclareInst - This represents the llvm.dbg.declare instruction. + /// + struct DbgDeclareInst : public DbgInfoIntrinsic { + Value *getAddress() const { return getOperand(1); } + Value *getVariable() const { return StripCast(getOperand(2)); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const DbgDeclareInst *) { return true; } + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::dbg_declare; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } + }; /// MemIntrinsic - This is the common base class for memset/memcpy/memmove. /// @@ -49,14 +176,18 @@ namespace llvm { Value *getRawDest() const { return const_cast(getOperand(1)); } Value *getLength() const { return const_cast(getOperand(3)); } - ConstantInt *getAlignment() const { + ConstantInt *getAlignmentCst() const { return cast(const_cast(getOperand(4))); } + + unsigned getAlignment() const { + return getAlignmentCst()->getZExtValue(); + } /// 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. /// @@ -71,128 +202,120 @@ namespace llvm { "setLength called with value of wrong type!"); setOperand(3, L); } - void setAlignment(ConstantInt *A) { - assert(getAlignment()->getType() == A->getType() && - "setAlignment called with value of wrong type!"); - setOperand(4, A); + void setAlignment(unsigned A) { + const Type *Int32Ty = getOperand(4)->getType(); + setOperand(4, ConstantInt::get(Int32Ty, A)); } - + // 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 { + struct MemSetInst : public MemIntrinsic { /// 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(getOperand(2)); } - void setSource(Value *Ptr) { - assert(getRawSource()->getType() == Ptr->getType() && + void setValue(Value *Val) { + assert(getValue()->getType() == Val->getType() && "setSource called with pointer of wrong type!"); - setOperand(2, Ptr); + setOperand(2, 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 MemSetInst *) { return true; } + 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 { + struct MemTransferInst : public MemIntrinsic { /// 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 *getSource() const { return getRawSource()->stripPointerCasts(); } + void setSource(Value *Ptr) { assert(getRawSource()->getType() == Ptr->getType() && "setSource called with pointer of wrong type!"); setOperand(2, 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 MemTransferInst *) { return true; } + 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. + /// + struct MemCpyInst : public MemTransferInst { + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const MemCpyInst *) { return true; } + 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)); } - - void setValue(Value *Val) { - assert(getValue()->getType() == Val->getType() && - "setSource called with pointer of wrong type!"); - setOperand(2, Val); + struct MemMoveInst : public MemTransferInst { + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const MemMoveInst *) { return true; } + 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)); } + }; + /// EHSelectorInst - This represents the llvm.eh.selector instruction. + /// + struct EHSelectorInst : public IntrinsicInst { // 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; - } - 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 EHSelectorInst *) { return true; } + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::eh_selector_i32 || + I->getIntrinsicID() == Intrinsic::eh_selector_i64; } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } }; + } #endif