GPUOcelot

LLVMInstruction.h

Go to the documentation of this file.
00001 
00007 #ifndef LLVM_INSTRUCTION_H_INCLUDED
00008 #define LLVM_INSTRUCTION_H_INCLUDED
00009 
00010 #include <ocelot/ir/interface/Instruction.h>
00011 #include <vector>
00012 
00013 namespace ir
00014 {
00015   typedef bool LLVMI1;
00016   typedef char LLVMI8;
00017   typedef short LLVMI16;
00018   typedef int LLVMI32;
00019   typedef long long LLVMI64;
00020   typedef long long LLVMI128;
00021   
00022   typedef float LLVMF32;
00023   typedef double LLVMF64;
00024   typedef LLVMI128 LLVMF128;
00025 
00027   class LLVMInstruction : public Instruction
00028   {
00029     public:
00031       enum Opcode
00032       {
00033         Add,
00034         Alloca,
00035         And,
00036         Ashr,
00037         Bitcast,  
00038         Br,
00039         Call,
00040         Extractelement,
00041         Extractvalue,
00042         Fadd,
00043         Fcmp,
00044         Fdiv,
00045         Fmul,
00046         Fpext,  
00047         Fptosi, 
00048         Fptoui,
00049         Fptrunc,  
00050         Free,
00051         Frem,
00052         Fsub,
00053         Getelementptr,
00054         Icmp,
00055         Insertelement,
00056         Insertvalue,
00057         Inttoptr,
00058         Invoke,
00059         Load,
00060         Lshr,
00061         Malloc,
00062         Mul,
00063         Or,
00064         Phi,
00065         Ptrtoint,
00066         Ret,
00067         Sdiv,
00068         Select,
00069         Sext,
00070         Shl,
00071         Shufflevector,
00072         Sitofp,
00073         Srem,
00074         Store,
00075         Sub,
00076         Switch,
00077         Trunc,
00078         Udiv,
00079         Uitofp, 
00080         Unreachable,
00081         Unwind,
00082         Urem,
00083         VaArg,
00084         Xor,
00085         Zext,
00086         InvalidOpcode
00087       };
00088       
00090       enum DataType
00091       {
00092         I1,
00093         I8,
00094         I16,
00095         I32,
00096         I64,
00097         I128,
00098         F32,
00099         F64,
00100         F128,
00101         InvalidDataType
00102       };
00103       
00105       enum Comparison
00106       {
00107         False, // no comparison, always returns false
00108         Oeq, // ordered and equal
00109         Ogt, // ordered and greater than
00110         Oge, // ordered and greater than or equal
00111         Olt, // ordered and less than
00112         Ole, // ordered and less than or equal
00113         One, // ordered and not equal
00114         Ord, // ordered (no nans)
00115         Ueq, // unordered or equal
00116         Ugt, // unordered or greater than
00117         Uge, // unordered or greater than or equal
00118         Ult, // unordered or less than
00119         Ule, // unordered or less than or equal
00120         Une, // unordered or not equal
00121         Uno, // unordered (either nans)
00122         True, // no comparison, always returns true
00123         Eq, // Integer equal
00124         Ne, // Integer not equal
00125         Sgt, // Signed greater than
00126         Sge, // Signed greater equal
00127         Slt, // Signed less than
00128         Sle // Signed less or equal
00129       };
00130       
00132       enum CallingConvention
00133       {
00134         CCallingConvention,
00135         FastCallingConvention,
00136         ColdCallingConvention,
00137         DefaultCallingConvention,
00138         InvalidCallingConvention
00139       };
00140       
00142       enum ParameterAttribute
00143       {
00144         ZeroExtend,
00145         SignExtend,
00146         InRegister,
00147         ByValue,
00148         StructureReturn,
00149         NoAlias,
00150         NoCapture,
00151         Nested,
00152         InvalidParameterAttribute
00153       };
00154       
00156       enum FunctionAttribute
00157       {
00158         AlwaysInline = 1,
00159         NoInline = 2,
00160         OptimizeSize = 4,
00161         NoReturn = 8,
00162         NoUnwind = 16,
00163         ReadNone = 32,
00164         ReadOnly = 64,
00165         StackSmashingProtector = 128,
00166         StackSmashingProtectorRequired = 256,
00167         NoRedZone = 512,
00168         NoImplicitFloat = 1024,
00169         Naked = 2048
00170       };
00171       
00173       class Type
00174       {
00175         public:
00177           enum Category
00178           {
00179             Element, 
00180             Array, 
00181             Function, 
00182             Structure, 
00183             PackedStructure, 
00184             Pointer, 
00185             Vector, 
00186             Opaque, 
00187             InvalidCategory
00188           };
00189         
00190         public:
00192           typedef std::vector< Type > TypeVector;
00193       
00194         public:
00196           TypeVector members;
00197               
00198         public:
00200           DataType type;
00202           Category category;
00204           std::string label;
00206           LLVMI32 vector;
00207         
00208         public:
00210           Type( DataType t = InvalidDataType, 
00211             Category c = InvalidCategory, LLVMI32 v = 1 );      
00212         
00213         public:     
00215           std::string toString() const;
00216       };
00217             
00219       union Value
00220       {
00221         LLVMI1 i1;
00222         LLVMI8 i8;
00223         LLVMI16 i16;
00224         LLVMI32 i32;
00225         LLVMI64 i64;
00226         LLVMI128 i128;
00227         LLVMF32 f32;
00228         LLVMF64 f64;
00229         LLVMF128 f128;
00230       };
00231       
00233       class Operand
00234       {
00235         public:
00237           std::string name;
00239           bool constant;
00241           Type type;
00243           union
00244           {
00245             LLVMI1 i1;
00246             LLVMI8 i8;
00247             LLVMI16 i16;
00248             LLVMI32 i32;
00249             LLVMI64 i64;
00250             LLVMI128 i128;
00251             LLVMF32 f32;
00252             LLVMF64 f64;
00253             LLVMF128 f128;
00254           };
00255           
00257           typedef std::vector< Value > ValueVector;
00258           
00260           ValueVector values;
00261           
00262         public:
00264           Operand( const std::string& n = std::string(), 
00265             const Type& t = Type() );
00267           Operand( LLVMI64 value );
00269           Operand( LLVMI32 value );
00271           Operand( LLVMF32 value );
00273           Operand( LLVMF64 value );
00275           Operand( LLVMI1 value );
00277           bool valid() const;
00279           std::string toString() const;
00280       };
00281       
00283       class Parameter : public Operand
00284       {
00285         public:
00287           ParameterAttribute attribute;
00288           
00289         public:
00291           Parameter();
00293           Parameter( const Operand& op );
00295           const Parameter& operator=( const Operand& op );
00297           const Parameter& operator=( const Parameter& op );
00298       };
00299       
00301       typedef std::vector< Operand > OperandVector;
00302       
00304       typedef std::vector< Parameter > ParameterVector;
00305       
00306     public:
00308         const Opcode opcode;
00309     
00310     public:
00312       static std::string toString( Opcode o );
00314       static std::string toString( DataType d );
00316       static std::string toString( CallingConvention cc );
00318       static std::string toString( ParameterAttribute attribute );
00320       static std::string toString( Comparison comp );
00322       static std::string functionAttributesToString( int attributes );
00324       static bool isInt( DataType d );
00326       static DataType getIntOfSize( unsigned int bits );
00328       static unsigned int bits( DataType type );
00329       
00330     public:
00332       LLVMInstruction( Opcode op = InvalidOpcode );
00333       
00335       LLVMInstruction( const LLVMInstruction& i );
00336       
00338       const LLVMInstruction& operator=( const LLVMInstruction& i );
00339                 
00340     public:
00342       virtual Instruction* clone(bool copy=true) const = 0;
00343   
00344     public:
00345       virtual std::string toString() const = 0;
00346       virtual std::string valid() const = 0;
00347   };
00348   
00350   class LLVMUnaryInstruction : public LLVMInstruction
00351   {
00352     public:
00354       Operand d;
00355       
00357       Operand a;
00358   
00359     public:
00361       LLVMUnaryInstruction( Opcode op = InvalidOpcode, 
00362         const Operand& d = Operand(), 
00363         const Operand& a = Operand() );
00364       
00365     public:
00366       virtual std::string toString() const;
00367       virtual std::string valid() const;
00368 
00369     public:
00370       virtual Instruction* clone(bool copy = true) const = 0;
00371   };
00372   
00374   class LLVMBinaryInstruction : public LLVMInstruction
00375   {
00376     public:
00378       Operand d;
00379       
00381       Operand a;
00382 
00384       Operand b;
00385 
00386     public:
00388       LLVMBinaryInstruction( Opcode op = InvalidOpcode, 
00389         const Operand& _d = Operand(), const Operand& _a = Operand(), 
00390         const Operand& _b = Operand() );
00391       
00392     public:
00393       virtual std::string toString() const;
00394       virtual std::string valid() const;
00395 
00396     public:
00397       virtual Instruction* clone(bool copy=true) const = 0;
00398   };
00399   
00401   class LLVMConversionInstruction : public LLVMUnaryInstruction
00402   {
00403     public:
00405       LLVMConversionInstruction( Opcode op = InvalidOpcode,
00406         const Operand& d = Operand(), 
00407         const Operand& a = Operand() );
00408       
00409     public:
00410       virtual std::string toString() const;
00411       virtual std::string valid() const;
00412 
00413     public:
00414       virtual Instruction* clone(bool copy=true) const = 0;
00415   };
00416   
00418   class LLVMComparisonInstruction : public LLVMBinaryInstruction
00419   {
00420     public:
00422       Comparison comparison;
00423     
00424     public:
00426       LLVMComparisonInstruction( Opcode op = InvalidOpcode );
00427       
00428     public:
00429       virtual std::string toString() const;
00430       virtual std::string valid() const;
00431 
00432     public:
00433       virtual Instruction* clone(bool copy=true) const = 0;
00434   };
00435   
00437   class LLVMAdd : public LLVMBinaryInstruction
00438   {
00439     public:
00441       LLVMI1 noUnsignedWrap;
00442       
00444       LLVMI1 noSignedWrap;
00445   
00446     public:
00448       LLVMAdd( const Operand& d = Operand(), 
00449         const Operand& a = Operand(), const Operand& b = Operand(),
00450         bool nur = false, bool nsr = false );
00451       
00452     public:
00453       std::string toString() const;
00454       std::string valid() const;
00455 
00456     public:
00457       Instruction* clone(bool copy=true) const;
00458   };
00459   
00461   class LLVMAlloca : public LLVMInstruction
00462   {
00463     public:
00465       LLVMI32 elements;
00466       
00468       LLVMI32 alignment;
00469       
00471       Operand d;
00472       
00473     public:
00475       LLVMAlloca( LLVMI32 e = 1, LLVMI32 a = 1);
00476       
00477     public:
00478       std::string toString() const;
00479       std::string valid() const;
00480 
00481     public:
00482       Instruction* clone(bool copy=true) const;
00483   };
00484   
00486   class LLVMAnd : public LLVMBinaryInstruction
00487   {
00488     public:
00490       LLVMAnd();
00491 
00492     public:
00493       Instruction* clone(bool copy=true) const;
00494   };
00495   
00497   class LLVMAshr : public LLVMBinaryInstruction
00498   {
00499     public:
00501       LLVMAshr();
00502 
00503     public:
00504       std::string valid() const;
00505     
00506     public:
00507       Instruction* clone(bool copy=true) const;
00508   };
00509   
00511   class LLVMBitcast : public LLVMConversionInstruction
00512   {
00513     public:
00515       LLVMBitcast();
00516 
00517     public:
00518       Instruction* clone(bool copy=true) const;
00519   };
00520     
00522   class LLVMBr : public LLVMInstruction
00523   {
00524     public:
00526       Operand condition;
00527       
00529       std::string iftrue;
00530       
00532       std::string iffalse;
00533   
00534     public:
00536       LLVMBr();
00537       
00538     public:
00539       std::string toString() const;
00540       std::string valid() const;  
00541 
00542     public:
00543       Instruction* clone(bool copy=true) const;
00544   };
00545   
00547   class LLVMCall : public LLVMInstruction
00548   {
00549     public:
00551       LLVMI1 tail;
00552       
00554       CallingConvention convention;
00555       
00557       Parameter d;
00558       
00560       std::string signature;
00561       
00563       std::string name;
00564       
00566       ParameterVector parameters;
00567       
00569       LLVMI32 functionAttributes;     
00570       
00571     public:
00573       LLVMCall();
00574       
00575     public:
00576       std::string toString() const;
00577       std::string valid() const;
00578 
00579     public:
00580       Instruction* clone(bool copy=true) const;
00581   };
00582   
00584   class LLVMExtractelement : public LLVMBinaryInstruction
00585   {
00586     public:
00588       LLVMExtractelement();
00589       
00590     public:
00591       std::string toString() const;
00592       std::string valid() const;
00593 
00594     public:
00595       Instruction* clone(bool copy=true) const;
00596   };
00597   
00599   class LLVMExtractvalue : public LLVMInstruction
00600   {
00601     public:
00603       typedef std::vector< LLVMI32 > IndexVector;
00604   
00605     public:
00607       Operand d;
00608       
00610       Operand a;
00611       
00613       IndexVector indices;
00614   
00615     public:
00617       LLVMExtractvalue();
00618       
00619     public:
00620       std::string toString() const;
00621       std::string valid() const;
00622 
00623     public:
00624       Instruction* clone(bool copy=true) const;
00625   };
00626   
00628   class LLVMFadd : public LLVMBinaryInstruction
00629   {
00630     public:
00632       LLVMFadd();
00633 
00634     public:
00635       Instruction* clone(bool copy=true) const;
00636   };
00637   
00639   class LLVMFcmp : public LLVMComparisonInstruction
00640   {
00641     public:
00643       LLVMFcmp();
00644 
00645     public:
00646       Instruction* clone(bool copy=true) const;
00647   };
00648   
00650   class LLVMFdiv : public LLVMBinaryInstruction
00651   {
00652     public:
00654       LLVMFdiv();
00655 
00656     public:
00657       Instruction* clone(bool copy=true) const;
00658   };
00659   
00661   class LLVMFmul : public LLVMBinaryInstruction
00662   {
00663     public:
00665       LLVMFmul();
00666 
00667     public:
00668       Instruction* clone(bool copy=true) const;
00669   };
00670   
00672   class LLVMFpext : public LLVMConversionInstruction
00673   {
00674     public:
00676       LLVMFpext();
00677 
00678     public:
00679       Instruction* clone(bool copy=true) const;
00680   };
00681     
00683   class LLVMFptosi : public LLVMConversionInstruction
00684   {
00685     public:
00687       LLVMFptosi();
00688 
00689     public:
00690       Instruction* clone(bool copy=true) const;
00691   };
00692     
00694   class LLVMFptoui : public LLVMConversionInstruction
00695   {
00696     public:
00698       LLVMFptoui();
00699 
00700     public:
00701       Instruction* clone(bool copy=true) const;
00702   };
00703   
00705   class LLVMFptrunc : public LLVMConversionInstruction
00706   {
00707     public:
00709       LLVMFptrunc();
00710 
00711     public:
00712       Instruction* clone(bool copy=true) const;
00713   };
00714     
00716   class LLVMFree : public LLVMInstruction
00717   {
00718     public:
00720       Operand a;
00721   
00722     public:
00724       LLVMFree();
00725       
00726     public:
00727       std::string toString() const;
00728       std::string valid() const;
00729 
00730     public:
00731       Instruction* clone(bool copy=true) const;
00732   };
00733   
00735   class LLVMFrem : public LLVMBinaryInstruction
00736   {
00737     public:
00739       LLVMFrem();
00740 
00741     public:
00742       Instruction* clone(bool copy=true) const;
00743   };
00744   
00746   class LLVMFsub : public LLVMBinaryInstruction
00747   {
00748     public:
00750       LLVMFsub();
00751 
00752     public:
00753       Instruction* clone(bool copy=true) const;
00754   };
00755   
00757   class LLVMGetelementptr : public LLVMInstruction
00758   {
00759     public:
00761       typedef std::vector< LLVMI32 > IndexVector;
00762   
00763     public:
00765       Operand d;
00766       
00768       Operand a;
00769       
00771       IndexVector indices;
00772   
00773     public:
00775       LLVMGetelementptr();
00776       
00777     public:
00778       std::string toString() const;
00779       std::string valid() const;
00780 
00781     public:
00782       Instruction* clone(bool copy=true) const;
00783   };
00784   
00786   class LLVMIcmp : public LLVMComparisonInstruction
00787   {
00788     public:
00790       LLVMIcmp();
00791 
00792     public:
00793       Instruction* clone(bool copy=true) const;
00794   };
00795   
00797   class LLVMInsertelement : public LLVMBinaryInstruction
00798   {
00799     public:
00801       Operand c;
00802         
00803     public:
00805       LLVMInsertelement();
00806       
00807     public:
00808       std::string toString() const;
00809       std::string valid() const;
00810 
00811     public:
00812       Instruction* clone(bool copy=true) const;
00813   };
00814   
00816   class LLVMInsertvalue : public LLVMInstruction
00817   {
00818     public:
00820       typedef std::vector< LLVMI32 > IndexVector;
00821   
00822     public:
00824       Operand d;
00825       
00827       Operand a;
00828       
00830       Operand b;
00831       
00833       IndexVector indices;
00834       
00835     public:
00837       LLVMInsertvalue();
00838       
00839     public:
00840       std::string toString() const;
00841       std::string valid() const;
00842 
00843     public:
00844       Instruction* clone(bool copy=true) const;
00845   };
00846   
00848   class LLVMInttoptr : public LLVMConversionInstruction
00849   {
00850     public:
00852       LLVMInttoptr();
00853 
00854     public:
00855       Instruction* clone(bool copy=true) const;
00856   };
00857   
00859   class LLVMInvoke : public LLVMInstruction
00860   {
00861     public:
00863       Parameter d;
00864       
00866       CallingConvention convention;
00867       
00869       ParameterAttribute returnAttributes;
00870       
00872       ParameterVector parameters;
00873       
00875       std::string name;
00876       
00878       std::string signature;
00879       
00881       LLVMI32 functionAttributes;
00882       
00884       std::string tolabel;
00885       
00887       std::string unwindlabel;
00888 
00889     public:
00891       LLVMInvoke();
00892       
00893     public:
00894       std::string toString() const;
00895       std::string valid() const;
00896 
00897     public:
00898       Instruction* clone(bool copy=true) const;
00899   };
00900   
00902   class LLVMLoad : public LLVMUnaryInstruction
00903   {
00904     public:
00906       LLVMI1 isVolatile;
00907   
00909       LLVMI32 alignment;
00910   
00911     public:
00913       LLVMLoad();
00914       
00915     public:
00916       std::string toString() const;
00917       std::string valid() const;
00918 
00919     public:
00920       Instruction* clone(bool copy=true) const;
00921   };
00922   
00924   class LLVMLshr : public LLVMBinaryInstruction
00925   {
00926     public:
00928       LLVMLshr();
00929       
00930     public:
00931       std::string valid() const;
00932       
00933     public:
00934       Instruction* clone(bool copy=true) const;
00935   };
00936   
00938   class LLVMMalloc : public LLVMInstruction
00939   {
00940     public:
00942       Operand elements;
00943       
00945       LLVMI32 alignment;
00946       
00948       Operand d;
00949 
00950     public:
00952       LLVMMalloc();
00953       
00954     public:
00955       std::string toString() const;
00956       std::string valid() const;
00957 
00958     public:
00959       Instruction* clone(bool copy=true) const;
00960   };
00961   
00963   class LLVMMul : public LLVMBinaryInstruction
00964   {
00965     public:
00967       LLVMI1 noUnsignedWrap;
00968       
00970       LLVMI1 noSignedWrap;
00971     
00972     public:
00974       LLVMMul();
00975       
00976     public:
00977       std::string toString() const;
00978 
00979     public:
00980       Instruction* clone(bool copy=true) const;
00981   };
00982   
00984   class LLVMOr : public LLVMBinaryInstruction
00985   {
00986     public:
00988       LLVMOr();
00989 
00990     public:
00991       Instruction* clone(bool copy=true) const;
00992   };
00993   
00995   class LLVMPhi : public LLVMInstruction
00996   {
00997     public:
00999       class Node
01000       {
01001         public:
01003           Operand operand;
01005           std::string label;
01007           Instruction::RegisterType reg; 
01008       };
01009       
01011       typedef std::vector< Node > NodeVector;
01012     
01013     public:
01015       Operand d;
01017       NodeVector nodes;
01018           
01019     public:
01021       LLVMPhi();
01022       
01023     public:
01024       std::string toString() const;
01025       std::string valid() const;
01026 
01027     public:
01028       Instruction* clone(bool copy=true) const;
01029   };
01030   
01032   class LLVMPtrtoint : public LLVMConversionInstruction
01033   {
01034     public:
01036       LLVMPtrtoint();
01037 
01038     public:
01039       Instruction* clone(bool copy=true) const;
01040   };
01041   
01043   class LLVMRet : public LLVMInstruction
01044   {
01045     public:
01047       Operand d;
01048     
01049     public:
01051       LLVMRet();
01052       
01053     public:
01054       std::string toString() const;
01055       std::string valid() const;
01056 
01057     public:
01058       Instruction* clone(bool copy=true) const;
01059   };
01060   
01062   class LLVMSdiv : public LLVMBinaryInstruction
01063   {
01064     public:
01066       LLVMI1 exact;
01067       
01068     public:
01070       LLVMSdiv();
01071       
01072     public:
01073       std::string toString() const;
01074 
01075     public:
01076       Instruction* clone(bool copy=true) const;
01077   };
01078   
01080   class LLVMSelect : public LLVMBinaryInstruction
01081   {
01082     public:
01084       Operand condition;
01085   
01086     public:
01088       LLVMSelect();
01089       
01090     public:
01091       std::string toString() const;
01092       std::string valid() const;
01093 
01094     public:
01095       Instruction* clone(bool copy=true) const;
01096   };
01097   
01099   class LLVMSext : public LLVMConversionInstruction
01100   {
01101     public:
01103       LLVMSext();
01104 
01105     public:
01106       Instruction* clone(bool copy=true) const;
01107   };
01108   
01110   class LLVMShl : public LLVMBinaryInstruction
01111   {
01112     public:
01114       LLVMShl();
01115     
01116     public:
01117       std::string valid() const;
01118 
01119     public:
01120       Instruction* clone(bool copy=true) const;
01121   };
01122   
01124   class LLVMShufflevector : public LLVMBinaryInstruction
01125   {
01126     public:
01128       typedef std::vector< LLVMI32 > Mask;
01129   
01130     public:
01132       Mask mask;
01133     
01134     public:
01136       LLVMShufflevector();
01137       
01138     public:
01139       std::string toString() const;
01140       std::string valid() const;
01141 
01142     public:
01143       Instruction* clone(bool copy=true) const;
01144   };
01145   
01147   class LLVMSitofp : public LLVMConversionInstruction
01148   {
01149     public:
01151       LLVMSitofp();
01152 
01153     public:
01154       Instruction* clone(bool copy=true) const;
01155   };
01156   
01158   class LLVMSrem : public LLVMBinaryInstruction
01159   {
01160     public:
01162       LLVMSrem();
01163 
01164     public:
01165       Instruction* clone(bool copy=true) const;
01166   };
01167   
01169   class LLVMStore: public LLVMUnaryInstruction
01170   {
01171     public:
01173       LLVMI1 isVolatile;
01174   
01176       LLVMI32 alignment;
01177       
01178     public:
01180       LLVMStore();
01181       
01182     public:
01183       std::string toString() const;
01184       std::string valid() const;
01185 
01186     public:
01187       Instruction* clone(bool copy=true) const;
01188   };
01189   
01191   class LLVMSub: public LLVMBinaryInstruction
01192   {
01193     public:
01195       LLVMI1 noUnsignedWrap;
01196       
01198       LLVMI1 noSignedWrap;
01199       
01200     public:
01202       LLVMSub();
01203       
01204     public:
01205       std::string toString() const;
01206 
01207     public:
01208       Instruction* clone(bool copy=true) const;
01209   };
01210   
01212   class LLVMSwitch : public LLVMInstruction
01213   {
01214     public:
01216       class Node
01217       {
01218         public:
01220           Operand operand;
01222           std::string label; 
01223       };
01224       
01226       typedef std::vector< Node > NodeVector;
01227       
01228     public:
01230       Operand comparison;
01231       
01233       std::string defaultTarget;
01234       
01236       NodeVector targets;
01237     
01238     public:
01240       LLVMSwitch();
01241       
01242     public:
01243       std::string toString() const;
01244       std::string valid() const;
01245 
01246     public:
01247       Instruction* clone(bool copy=true) const;
01248   };
01249   
01251   class LLVMTrunc : public LLVMConversionInstruction
01252   {
01253     public:
01255       LLVMTrunc();
01256 
01257     public:
01258       Instruction* clone(bool copy=true) const;
01259   };
01260   
01262   class LLVMUdiv : public LLVMBinaryInstruction
01263   {
01264     public:
01266       LLVMUdiv();
01267 
01268     public:
01269       Instruction* clone(bool copy=true) const;
01270   };
01271   
01273   class LLVMUitofp : public LLVMConversionInstruction
01274   {
01275     public:
01277       LLVMUitofp();
01278 
01279     public:
01280       Instruction* clone(bool copy=true) const;
01281   };
01282     
01284   class LLVMUnreachable : public LLVMInstruction
01285   {
01286     public:
01288       LLVMUnreachable();
01289       
01290     public:
01291       std::string toString() const;
01292       std::string valid() const;
01293 
01294     public:
01295       Instruction* clone(bool copy=true) const;
01296   };
01297   
01299   class LLVMUnwind : public LLVMInstruction
01300   {
01301     public:
01303       LLVMUnwind();
01304       
01305     public:
01306       std::string toString() const;
01307       std::string valid() const;
01308 
01309     public:
01310       Instruction* clone(bool copy=true) const;
01311   };
01312   
01314   class LLVMUrem : public LLVMBinaryInstruction
01315   {
01316     public:
01318       LLVMUrem();
01319 
01320     public:
01321       Instruction* clone(bool copy=true) const;
01322   };
01323   
01325   class LLVMVaArg : public LLVMUnaryInstruction
01326   {
01327     public:
01329       LLVMVaArg();
01330       
01331     public:
01332       std::string toString() const;
01333       std::string valid() const;
01334 
01335     public:
01336       Instruction* clone(bool copy=true) const;
01337   };
01338   
01340   class LLVMXor : public LLVMBinaryInstruction
01341   {
01342     public:
01344       LLVMXor();
01345 
01346     public:
01347       Instruction* clone(bool copy=true) const;
01348   };
01349   
01351   class LLVMZext : public LLVMConversionInstruction
01352   {
01353     public:
01355       LLVMZext();
01356 
01357     public:
01358       Instruction* clone(bool copy=true) const;
01359   };
01360   
01361 }
01362 
01363 #endif
01364 
01365 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines