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
|
//===-- 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"
#include <list>
#include <vector>
class Method;
class SymTabValue;
//===----------------------------------------------------------------------===//
// 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 {
public:
TerminatorInst(unsigned iType);
inline ~TerminatorInst() {}
// Terminators must implement the methods required by Instruction...
virtual Instruction *clone() const = 0;
virtual const char *getOpcodeName() const = 0;
// Additionally, they must provide a method to get at the successors of this
// terminator instruction. If 'idx' is out of range, a null pointer shall be
// returned.
//
virtual const BasicBlock *getSuccessor(unsigned idx) const = 0;
virtual unsigned getNumSuccessors() const = 0;
inline BasicBlock *getSuccessor(unsigned idx) {
return (BasicBlock*)((const TerminatorInst *)this)->getSuccessor(idx);
}
};
//===----------------------------------------------------------------------===//
// UnaryOperator Class
//===----------------------------------------------------------------------===//
class UnaryOperator : public Instruction {
public:
// create() - Construct a unary instruction, given the opcode
// and its operand.
//
static UnaryOperator *create(UnaryOps Op, Value *Source);
UnaryOperator(Value *S, UnaryOps iType, const string &Name = "")
: Instruction(S->getType(), iType, Name) {
Operands.reserve(1);
Operands.push_back(Use(S, this));
}
inline UnaryOps getOpcode() const {
return (UnaryOps)Instruction::getOpcode();
}
virtual Instruction *clone() const {
return create(getOpcode(), Operands[0]);
}
virtual const char *getOpcodeName() const = 0;
};
//===----------------------------------------------------------------------===//
// BinaryOperator Class
//===----------------------------------------------------------------------===//
class BinaryOperator : public Instruction {
public:
// create() - Construct a binary instruction, given the opcode
// and the two operands.
//
static BinaryOperator *create(BinaryOps Op, Value *S1, Value *S2,
const string &Name = "");
BinaryOperator(BinaryOps iType, Value *S1, Value *S2,
const 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());
}
inline BinaryOps getOpcode() const {
return (BinaryOps)Instruction::getOpcode();
}
virtual Instruction *clone() const {
return create(getOpcode(), Operands[0], Operands[1]);
}
virtual const char *getOpcodeName() const = 0;
// swapOperands - Exchange the two operands to this instruction
void swapOperands() {
swap(Operands[0], Operands[1]);
}
};
#endif
|
