1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
//===-- llvm/InstrTypes.h - Important Instruction subclasses -----*- C++ -*--=//
//
// This file defines various meta classes of instructions that exist in the VM
// representation. Specific concrete subclasses of these may be found in the
// i*.h files...
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_INSTRUCTION_TYPES_H
#define LLVM_INSTRUCTION_TYPES_H
#include "llvm/Instruction.h"
//===----------------------------------------------------------------------===//
// TerminatorInst Class
//===----------------------------------------------------------------------===//
// TerminatorInst - Subclasses of this class are all able to terminate a basic
// block. Thus, these are all the flow control type of operations.
//
class TerminatorInst : public Instruction {
protected:
TerminatorInst(Instruction::TermOps iType);
TerminatorInst(const Type *Ty, Instruction::TermOps iType,
const std::string &Name = "");
public:
// Terminators must implement the methods required by Instruction...
virtual Instruction *clone() const = 0;
// Additionally, they must provide a method to get at the successors of this
// terminator instruction. 'idx' may not be >= the number of successors
// returned by getNumSuccessors()!
//
virtual const BasicBlock *getSuccessor(unsigned idx) const = 0;
virtual unsigned getNumSuccessors() const = 0;
// Set a successor at a given index
virtual void setSuccessor(unsigned idx, BasicBlock *B) = 0;
inline BasicBlock *getSuccessor(unsigned idx) {
return (BasicBlock*)((const TerminatorInst *)this)->getSuccessor(idx);
}
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const TerminatorInst *) { return true; }
static inline bool classof(const Instruction *I) {
return I->getOpcode() >= FirstTermOp && I->getOpcode() < NumTermOps;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
};
//===----------------------------------------------------------------------===//
// BinaryOperator Class
//===----------------------------------------------------------------------===//
class BinaryOperator : public Instruction {
protected:
BinaryOperator(BinaryOps iType, Value *S1, Value *S2,
const std::string &Name = "")
: Instruction(S1->getType(), iType, Name) {
Operands.reserve(2);
Operands.push_back(Use(S1, this));
Operands.push_back(Use(S2, this));
assert(Operands[0] && Operands[1] &&
Operands[0]->getType() == Operands[1]->getType());
}
public:
// create() - Construct a binary instruction, given the opcode
// and the two operands.
//
static BinaryOperator *create(BinaryOps Op, Value *S1, Value *S2,
const std::string &Name = "");
// Helper functions to construct and inspect unary operations (NEG and NOT)
// via binary operators SUB and XOR:
//
// createNeg, createNot - Create the NEG and NOT
// instructions out of SUB and XOR instructions.
//
// isNeg, isNot - Check if the given Value is a NEG or NOT instruction.
//
// getNegArgument, getNotArgument - Helper functions to extract the
// unary argument of a NEG or NOT operation implemented via Sub or Xor.
//
static BinaryOperator *createNeg(Value *Op, const std::string &Name = "");
static BinaryOperator *createNot(Value *Op, const std::string &Name = "");
static bool isNeg(const Value *V);
static bool isNot(const Value *V);
static const Value* getNegArgument(const BinaryOperator* Bop);
static Value* getNegArgument( BinaryOperator* Bop);
static const Value* getNotArgument(const BinaryOperator* Bop);
static Value* getNotArgument( BinaryOperator* Bop);
BinaryOps getOpcode() const {
return (BinaryOps)Instruction::getOpcode();
}
virtual Instruction *clone() const {
return create(getOpcode(), Operands[0], Operands[1]);
}
// swapOperands - Exchange the two operands to this instruction.
// This instruction is safe to use on any binary instruction and
// does not modify the semantics of the instruction. If the
// instruction is order dependant (SetLT f.e.) the opcode is
// changed. If the instruction cannot be reversed (ie, it's a Div),
// then return true.
//
bool swapOperands();
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const BinaryOperator *) { return true; }
static inline bool classof(const Instruction *I) {
return I->getOpcode() >= FirstBinaryOp && I->getOpcode() < NumBinaryOps;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
};
#endif
|
