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
130
131
132
133
134
135
136
137
138
|
//===-- iOperators.cpp - Implement the Binary & Unary Operators --*- C++ -*--=//
//
// This file implements the nontrivial binary & unary operator instructions.
//
//===----------------------------------------------------------------------===//
#include "llvm/iOperators.h"
#include "llvm/Type.h"
#include <iostream>
using std::cerr;
//===----------------------------------------------------------------------===//
// UnaryOperator Class
//===----------------------------------------------------------------------===//
UnaryOperator *UnaryOperator::create(UnaryOps Op, Value *Source) {
switch (Op) {
case Not: return new GenericUnaryInst(Op, Source);
default:
cerr << "Don't know how to Create UnaryOperator " << Op << "\n";
return 0;
}
}
//===----------------------------------------------------------------------===//
// GenericUnaryOperator Class
//===----------------------------------------------------------------------===//
const char *GenericUnaryInst::getOpcodeName() const {
switch (getOpcode()) {
case Not: return "not";
case Cast: return "cast";
default:
cerr << "Invalid unary operator type!" << getOpcode() << "\n";
abort();
}
return 0;
}
//===----------------------------------------------------------------------===//
// BinaryOperator Class
//===----------------------------------------------------------------------===//
BinaryOperator *BinaryOperator::create(BinaryOps Op, Value *S1, Value *S2,
const std::string &Name) {
switch (Op) {
// Binary comparison operators...
case SetLT: case SetGT: case SetLE:
case SetGE: case SetEQ: case SetNE:
return new SetCondInst(Op, S1, S2, Name);
default:
return new GenericBinaryInst(Op, S1, S2, Name);
}
}
// 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.
//
bool BinaryOperator::swapOperands() {
switch (getOpcode()) {
// Instructions that don't need opcode modification
case Add: case Mul:
case And: case Xor:
case Or:
case SetEQ: case SetNE:
break;
// Instructions that need opcode modification
case SetGT: iType = SetLT; break;
case SetLT: iType = SetGT; break;
case SetGE: iType = SetLE; break;
case SetLE: iType = SetGE; break;
// Error on the side of caution
default:
return true;
}
std::swap(Operands[0], Operands[1]);
return false;
}
//===----------------------------------------------------------------------===//
// GenericBinaryInst Class
//===----------------------------------------------------------------------===//
const char *GenericBinaryInst::getOpcodeName() const {
switch (getOpcode()) {
// Standard binary operators...
case Add: return "add";
case Sub: return "sub";
case Mul: return "mul";
case Div: return "div";
case Rem: return "rem";
// Logical operators...
case And: return "and";
case Or : return "or";
case Xor: return "xor";
default:
cerr << "Invalid binary operator type!" << getOpcode() << "\n";
abort();
}
return 0;
}
//===----------------------------------------------------------------------===//
// SetCondInst Class
//===----------------------------------------------------------------------===//
SetCondInst::SetCondInst(BinaryOps opType, Value *S1, Value *S2,
const std::string &Name)
: BinaryOperator(opType, S1, S2, Name) {
OpType = opType;
setType(Type::BoolTy); // setcc instructions always return bool type.
// Make sure it's a valid type...
assert(getOpcodeName() != 0);
}
const char *SetCondInst::getOpcodeName() const {
switch (OpType) {
case SetLE: return "setle";
case SetGE: return "setge";
case SetLT: return "setlt";
case SetGT: return "setgt";
case SetEQ: return "seteq";
case SetNE: return "setne";
default:
assert(0 && "Invalid opcode type to SetCondInst class!");
return "invalid opcode type to SetCondInst";
}
}
|
