Extricate the "reverse" support from the depth-first iterator. This is really
[oota-llvm.git] / include / llvm / iOther.h
1 //===-- llvm/iOther.h - "Other" instruction node definitions ----*- C++ -*-===//
2 //
3 // This file contains the declarations for instructions that fall into the 
4 // grandiose 'other' catagory...
5 //
6 //===----------------------------------------------------------------------===//
7
8 #ifndef LLVM_IOTHER_H
9 #define LLVM_IOTHER_H
10
11 #include "llvm/InstrTypes.h"
12
13 //===----------------------------------------------------------------------===//
14 //                                 CastInst Class
15 //===----------------------------------------------------------------------===//
16
17 /// CastInst - This class represents a cast from Operand[0] to the type of
18 /// the instruction (i->getType()).
19 ///
20 class CastInst : public Instruction {
21   CastInst(const CastInst &CI) : Instruction(CI.getType(), Cast) {
22     Operands.reserve(1);
23     Operands.push_back(Use(CI.Operands[0], this));
24   }
25 public:
26   CastInst(Value *S, const Type *Ty, const std::string &Name = "",
27            Instruction *InsertBefore = 0)
28     : Instruction(Ty, Cast, Name, InsertBefore) {
29     Operands.reserve(1);
30     Operands.push_back(Use(S, this));
31   }
32
33   virtual Instruction *clone() const { return new CastInst(*this); }
34
35   // Methods for support type inquiry through isa, cast, and dyn_cast:
36   static inline bool classof(const CastInst *) { return true; }
37   static inline bool classof(const Instruction *I) {
38     return I->getOpcode() == Cast;
39   }
40   static inline bool classof(const Value *V) {
41     return isa<Instruction>(V) && classof(cast<Instruction>(V));
42   }
43 };
44
45
46 //===----------------------------------------------------------------------===//
47 //                                 CallInst Class
48 //===----------------------------------------------------------------------===//
49
50 class CallInst : public Instruction {
51   CallInst(const CallInst &CI);
52 public:
53   CallInst(Value *F, const std::vector<Value*> &Par,
54            const std::string &Name = "", Instruction *InsertBefore = 0);
55
56   // Alternate CallInst ctors w/ no actuals & one actual, respectively.
57   CallInst(Value *F, const std::string &Name = "",
58            Instruction  *InsertBefore = 0);
59   CallInst(Value *F, Value *Actual, const std::string& Name = "",
60            Instruction* InsertBefore = 0);
61
62   virtual Instruction *clone() const { return new CallInst(*this); }
63   bool mayWriteToMemory() const { return true; }
64
65   const Function *getCalledFunction() const {
66     return dyn_cast<Function>(Operands[0].get());
67   }
68   Function *getCalledFunction() {
69     return dyn_cast<Function>(Operands[0].get());
70   }
71
72   // getCalledValue - Get a pointer to a method that is invoked by this inst.
73   inline const Value *getCalledValue() const { return Operands[0]; }
74   inline       Value *getCalledValue()       { return Operands[0]; }
75
76   // Methods for support type inquiry through isa, cast, and dyn_cast:
77   static inline bool classof(const CallInst *) { return true; }
78   static inline bool classof(const Instruction *I) {
79     return I->getOpcode() == Instruction::Call; 
80   }
81   static inline bool classof(const Value *V) {
82     return isa<Instruction>(V) && classof(cast<Instruction>(V));
83   }
84 };
85
86
87 //===----------------------------------------------------------------------===//
88 //                                 ShiftInst Class
89 //===----------------------------------------------------------------------===//
90
91 // ShiftInst - This class represents left and right shift instructions.
92 //
93 class ShiftInst : public Instruction {
94   ShiftInst(const ShiftInst &SI) : Instruction(SI.getType(), SI.getOpcode()) {
95     Operands.reserve(2);
96     Operands.push_back(Use(SI.Operands[0], this));
97     Operands.push_back(Use(SI.Operands[1], this));
98   }
99 public:
100   ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "",
101             Instruction *InsertBefore = 0)
102     : Instruction(S->getType(), Opcode, Name, InsertBefore) {
103     assert((Opcode == Shl || Opcode == Shr) && "ShiftInst Opcode invalid!");
104     Operands.reserve(2);
105     Operands.push_back(Use(S, this));
106     Operands.push_back(Use(SA, this));
107   }
108
109   OtherOps getOpcode() const { return (OtherOps)Instruction::getOpcode(); }
110
111   virtual Instruction *clone() const { return new ShiftInst(*this); }
112
113   // Methods for support type inquiry through isa, cast, and dyn_cast:
114   static inline bool classof(const ShiftInst *) { return true; }
115   static inline bool classof(const Instruction *I) {
116     return (I->getOpcode() == Instruction::Shr) | 
117            (I->getOpcode() == Instruction::Shl);
118   }
119   static inline bool classof(const Value *V) {
120     return isa<Instruction>(V) && classof(cast<Instruction>(V));
121   }
122 };
123
124
125 //===----------------------------------------------------------------------===//
126 //                               VarArgInst Class
127 //===----------------------------------------------------------------------===//
128
129 /// VarArgInst - This class represents the va_arg llvm instruction, which reads
130 /// an argument of the destination type from the va_list operand pointed to by
131 /// the only operand.
132 ///
133 class VarArgInst : public Instruction {
134   VarArgInst(const VarArgInst &VAI) : Instruction(VAI.getType(), VarArg) {
135     Operands.reserve(1);
136     Operands.push_back(Use(VAI.Operands[0], this));
137   }
138 public:
139   VarArgInst(Value *S, const Type *Ty, const std::string &Name = "",
140              Instruction *InsertBefore = 0)
141     : Instruction(Ty, VarArg, Name, InsertBefore) {
142     Operands.reserve(1);
143     Operands.push_back(Use(S, this));
144   }
145
146   virtual Instruction *clone() const { return new VarArgInst(*this); }
147
148   bool mayWriteToMemory() const { return true; }
149
150   // Methods for support type inquiry through isa, cast, and dyn_cast:
151   static inline bool classof(const VarArgInst *) { return true; }
152   static inline bool classof(const Instruction *I) {
153     return I->getOpcode() == VarArg;
154   }
155   static inline bool classof(const Value *V) {
156     return isa<Instruction>(V) && classof(cast<Instruction>(V));
157   }
158 };
159
160 #endif