X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FIntrinsicInst.h;h=c674e47b3a00689e5eadd32377b648f7c74a2678;hb=a6fb5b54f3a35fdefbb03b9c7be4c6d6d53cdd35;hp=857e4cbeb135afe1578b6450612180e2a5afee88;hpb=00dcbaa6e5d2f44ee0d0a7dc5bceabda6b30b504;p=oota-llvm.git diff --git a/include/llvm/IntrinsicInst.h b/include/llvm/IntrinsicInst.h index 857e4cbeb13..c674e47b3a0 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,67 +30,143 @@ #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: - - /// 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); + /// 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)); + } }; /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics /// struct DbgInfoIntrinsic : public IntrinsicInst { - Value *getChain() const { return const_cast(getOperand(1)); } - // 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 false; + 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)); + return isa(V) && classof(cast(V)); } + + static Value *StripCast(Value *C); }; - - /// DbgStopPointInst - This represent llvm.dbg.stoppoint instructions. + /// 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 getLineNo() const { - return unsigned(cast(getOperand(2))->getRawValue()); + unsigned getLine() const { + return unsigned(cast(getOperand(1))->getZExtValue()); } - unsigned getColNo() const { - return unsigned(cast(getOperand(3))->getRawValue()); + unsigned getColumn() const { + return unsigned(cast(getOperand(2))->getZExtValue()); } - Value *getContext() const { return const_cast(getOperand(4)); } + + std::string getFileName() const; + std::string 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 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_stoppoint; } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(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)); } }; @@ -107,7 +183,7 @@ namespace llvm { /// 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. /// @@ -130,19 +206,20 @@ namespace llvm { // 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_i32: + case Intrinsic::memcpy_i64: + case Intrinsic::memmove_i32: + case Intrinsic::memmove_i64: + case Intrinsic::memset_i32: + case Intrinsic::memset_i64: + return true; + default: return false; + } } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } }; @@ -157,9 +234,9 @@ namespace llvm { /// 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!"); @@ -168,17 +245,12 @@ namespace llvm { // 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::memcpy_i32 || + I->getIntrinsicID() == Intrinsic::memcpy_i64; } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } }; @@ -192,7 +264,7 @@ namespace llvm { /// 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() && @@ -202,21 +274,16 @@ namespace llvm { // 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 CallInst *I) { - if (const Function *CF = I->getCalledFunction()) - if (CF->getIntrinsicID() == Intrinsic::memmove) - return true; - return false; + static inline bool classof(const IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::memmove_i32 || + I->getIntrinsicID() == Intrinsic::memmove_i64; } 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. + /// MemSetInst - This class wraps the llvm.memset intrinsic. /// struct MemSetInst : public MemIntrinsic { /// get* - Return the arguments to the instruction. @@ -231,19 +298,15 @@ namespace llvm { // 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 IntrinsicInst *I) { + return I->getIntrinsicID() == Intrinsic::memset_i32 || + I->getIntrinsicID() == Intrinsic::memset_i64; } static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return isa(V) && classof(cast(V)); } }; + } #endif