OLD | NEW |
1 // Copyright 2013 the V8 project authors. All rights reserved. | 1 // Copyright 2013 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef V8_COMPILER_MACHINE_OPERATOR_H_ | 5 #ifndef V8_COMPILER_MACHINE_OPERATOR_H_ |
6 #define V8_COMPILER_MACHINE_OPERATOR_H_ | 6 #define V8_COMPILER_MACHINE_OPERATOR_H_ |
7 | 7 |
8 #include "src/compiler/machine-type.h" | 8 #include "src/compiler/machine-type.h" |
9 #include "src/compiler/opcodes.h" | 9 #include "src/compiler/opcodes.h" |
10 #include "src/compiler/operator.h" | 10 #include "src/compiler/operator.h" |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
114 Operator* Int64Add() { BINOP_AC(Int64Add); } | 114 Operator* Int64Add() { BINOP_AC(Int64Add); } |
115 Operator* Int64Sub() { BINOP(Int64Sub); } | 115 Operator* Int64Sub() { BINOP(Int64Sub); } |
116 Operator* Int64Mul() { BINOP_AC(Int64Mul); } | 116 Operator* Int64Mul() { BINOP_AC(Int64Mul); } |
117 Operator* Int64Div() { BINOP(Int64Div); } | 117 Operator* Int64Div() { BINOP(Int64Div); } |
118 Operator* Int64UDiv() { BINOP(Int64UDiv); } | 118 Operator* Int64UDiv() { BINOP(Int64UDiv); } |
119 Operator* Int64Mod() { BINOP(Int64Mod); } | 119 Operator* Int64Mod() { BINOP(Int64Mod); } |
120 Operator* Int64UMod() { BINOP(Int64UMod); } | 120 Operator* Int64UMod() { BINOP(Int64UMod); } |
121 Operator* Int64LessThan() { BINOP(Int64LessThan); } | 121 Operator* Int64LessThan() { BINOP(Int64LessThan); } |
122 Operator* Int64LessThanOrEqual() { BINOP(Int64LessThanOrEqual); } | 122 Operator* Int64LessThanOrEqual() { BINOP(Int64LessThanOrEqual); } |
123 | 123 |
124 Operator* ConvertInt32ToInt64() { UNOP(ConvertInt32ToInt64); } | |
125 Operator* ConvertInt64ToInt32() { UNOP(ConvertInt64ToInt32); } | |
126 | |
127 // Convert representation of integers between float64 and int32/uint32. | 124 // Convert representation of integers between float64 and int32/uint32. |
128 // The precise rounding mode and handling of out of range inputs are *not* | 125 // The precise rounding mode and handling of out of range inputs are *not* |
129 // defined for these operators, since they are intended only for use with | 126 // defined for these operators, since they are intended only for use with |
130 // integers. | 127 // integers. |
131 // TODO(titzer): rename ConvertXXX to ChangeXXX in machine operators. | |
132 Operator* ChangeInt32ToFloat64() { UNOP(ChangeInt32ToFloat64); } | 128 Operator* ChangeInt32ToFloat64() { UNOP(ChangeInt32ToFloat64); } |
133 Operator* ChangeUint32ToFloat64() { UNOP(ChangeUint32ToFloat64); } | 129 Operator* ChangeUint32ToFloat64() { UNOP(ChangeUint32ToFloat64); } |
134 Operator* ChangeFloat64ToInt32() { UNOP(ChangeFloat64ToInt32); } | 130 Operator* ChangeFloat64ToInt32() { UNOP(ChangeFloat64ToInt32); } |
135 Operator* ChangeFloat64ToUint32() { UNOP(ChangeFloat64ToUint32); } | 131 Operator* ChangeFloat64ToUint32() { UNOP(ChangeFloat64ToUint32); } |
136 | 132 |
| 133 // Sign/zero extend int32/uint32 to int64/uint64. |
| 134 Operator* ChangeInt32ToInt64() { UNOP(ChangeInt32ToInt64); } |
| 135 Operator* ChangeUint32ToUint64() { UNOP(ChangeUint32ToUint64); } |
| 136 |
| 137 // Truncate the high order bits and convert the remaining bits to int32. |
| 138 Operator* TruncateInt64ToInt32() { UNOP(TruncateInt64ToInt32); } |
| 139 |
137 // Floating point operators always operate with IEEE 754 round-to-nearest. | 140 // Floating point operators always operate with IEEE 754 round-to-nearest. |
138 Operator* Float64Add() { BINOP_C(Float64Add); } | 141 Operator* Float64Add() { BINOP_C(Float64Add); } |
139 Operator* Float64Sub() { BINOP(Float64Sub); } | 142 Operator* Float64Sub() { BINOP(Float64Sub); } |
140 Operator* Float64Mul() { BINOP_C(Float64Mul); } | 143 Operator* Float64Mul() { BINOP_C(Float64Mul); } |
141 Operator* Float64Div() { BINOP(Float64Div); } | 144 Operator* Float64Div() { BINOP(Float64Div); } |
142 Operator* Float64Mod() { BINOP(Float64Mod); } | 145 Operator* Float64Mod() { BINOP(Float64Mod); } |
143 | 146 |
144 // Floating point comparisons complying to IEEE 754. | 147 // Floating point comparisons complying to IEEE 754. |
145 Operator* Float64Equal() { BINOP_C(Float64Equal); } | 148 Operator* Float64Equal() { BINOP_C(Float64Equal); } |
146 Operator* Float64LessThan() { BINOP(Float64LessThan); } | 149 Operator* Float64LessThan() { BINOP(Float64LessThan); } |
(...skipping 15 matching lines...) Expand all Loading... |
162 | 165 |
163 private: | 166 private: |
164 Zone* zone_; | 167 Zone* zone_; |
165 MachineType word_; | 168 MachineType word_; |
166 }; | 169 }; |
167 } | 170 } |
168 } | 171 } |
169 } // namespace v8::internal::compiler | 172 } // namespace v8::internal::compiler |
170 | 173 |
171 #endif // V8_COMPILER_MACHINE_OPERATOR_H_ | 174 #endif // V8_COMPILER_MACHINE_OPERATOR_H_ |
OLD | NEW |