1/*
2 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2007, 2010 Red Hat, Inc.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26#ifndef CPU_ZERO_VM_BYTECODEINTERPRETER_ZERO_INLINE_HPP
27#define CPU_ZERO_VM_BYTECODEINTERPRETER_ZERO_INLINE_HPP
28
29// Inline interpreter functions for zero
30
31inline jfloat BytecodeInterpreter::VMfloatAdd(jfloat op1, jfloat op2) {
32  return op1 + op2;
33}
34
35inline jfloat BytecodeInterpreter::VMfloatSub(jfloat op1, jfloat op2) {
36  return op1 - op2;
37}
38
39inline jfloat BytecodeInterpreter::VMfloatMul(jfloat op1, jfloat op2) {
40  return op1 * op2;
41}
42
43inline jfloat BytecodeInterpreter::VMfloatDiv(jfloat op1, jfloat op2) {
44  return op1 / op2;
45}
46
47inline jfloat BytecodeInterpreter::VMfloatRem(jfloat op1, jfloat op2) {
48  return fmod(op1, op2);
49}
50
51inline jfloat BytecodeInterpreter::VMfloatNeg(jfloat op) {
52  return -op;
53}
54
55inline int32_t BytecodeInterpreter::VMfloatCompare(jfloat  op1,
56                                                   jfloat  op2,
57                                                   int32_t direction) {
58  return ( op1 < op2 ? -1 :
59               op1 > op2 ? 1 :
60                   op1 == op2 ? 0 :
61                       (direction == -1 || direction == 1) ? direction : 0);
62
63}
64
65inline void BytecodeInterpreter::VMmemCopy64(uint32_t       to[2],
66                                             const uint32_t from[2]) {
67  *(uint64_t *) to = *(uint64_t *) from;
68}
69
70inline jlong BytecodeInterpreter::VMlongAdd(jlong op1, jlong op2) {
71  return op1 + op2;
72}
73
74inline jlong BytecodeInterpreter::VMlongAnd(jlong op1, jlong op2) {
75  return op1 & op2;
76}
77
78inline jlong BytecodeInterpreter::VMlongDiv(jlong op1, jlong op2) {
79  /* it's possible we could catch this special case implicitly */
80  if (op1 == (jlong) 0x8000000000000000LL && op2 == -1) return op1;
81  else return op1 / op2;
82}
83
84inline jlong BytecodeInterpreter::VMlongMul(jlong op1, jlong op2) {
85  return op1 * op2;
86}
87
88inline jlong BytecodeInterpreter::VMlongOr(jlong op1, jlong op2) {
89  return op1 | op2;
90}
91
92inline jlong BytecodeInterpreter::VMlongSub(jlong op1, jlong op2) {
93  return op1 - op2;
94}
95
96inline jlong BytecodeInterpreter::VMlongXor(jlong op1, jlong op2) {
97  return op1 ^ op2;
98}
99
100inline jlong BytecodeInterpreter::VMlongRem(jlong op1, jlong op2) {
101  /* it's possible we could catch this special case implicitly */
102  if (op1 == (jlong) 0x8000000000000000LL && op2 == -1) return 0;
103  else return op1 % op2;
104}
105
106inline jlong BytecodeInterpreter::VMlongUshr(jlong op1, jint op2) {
107  return ((unsigned long long) op1) >> (op2 & 0x3F);
108}
109
110inline jlong BytecodeInterpreter::VMlongShr(jlong op1, jint op2) {
111  return op1 >> (op2 & 0x3F);
112}
113
114inline jlong BytecodeInterpreter::VMlongShl(jlong op1, jint op2) {
115  return op1 << (op2 & 0x3F);
116}
117
118inline jlong BytecodeInterpreter::VMlongNeg(jlong op) {
119  return -op;
120}
121
122inline jlong BytecodeInterpreter::VMlongNot(jlong op) {
123  return ~op;
124}
125
126inline int32_t BytecodeInterpreter::VMlongLtz(jlong op) {
127  return (op <= 0);
128}
129
130inline int32_t BytecodeInterpreter::VMlongGez(jlong op) {
131  return (op >= 0);
132}
133
134inline int32_t BytecodeInterpreter::VMlongEqz(jlong op) {
135  return (op == 0);
136}
137
138inline int32_t BytecodeInterpreter::VMlongEq(jlong op1, jlong op2) {
139  return (op1 == op2);
140}
141
142inline int32_t BytecodeInterpreter::VMlongNe(jlong op1, jlong op2) {
143  return (op1 != op2);
144}
145
146inline int32_t BytecodeInterpreter::VMlongGe(jlong op1, jlong op2) {
147  return (op1 >= op2);
148}
149
150inline int32_t BytecodeInterpreter::VMlongLe(jlong op1, jlong op2) {
151  return (op1 <= op2);
152}
153
154inline int32_t BytecodeInterpreter::VMlongLt(jlong op1, jlong op2) {
155  return (op1 < op2);
156}
157
158inline int32_t BytecodeInterpreter::VMlongGt(jlong op1, jlong op2) {
159  return (op1 > op2);
160}
161
162inline int32_t BytecodeInterpreter::VMlongCompare(jlong op1, jlong op2) {
163  return (VMlongLt(op1, op2) ? -1 : VMlongGt(op1, op2) ? 1 : 0);
164}
165
166// Long conversions
167
168inline jdouble BytecodeInterpreter::VMlong2Double(jlong val) {
169  return (jdouble) val;
170}
171
172inline jfloat BytecodeInterpreter::VMlong2Float(jlong val) {
173  return (jfloat) val;
174}
175
176inline jint BytecodeInterpreter::VMlong2Int(jlong val) {
177  return (jint) val;
178}
179
180// Double Arithmetic
181
182inline jdouble BytecodeInterpreter::VMdoubleAdd(jdouble op1, jdouble op2) {
183  return op1 + op2;
184}
185
186inline jdouble BytecodeInterpreter::VMdoubleDiv(jdouble op1, jdouble op2) {
187  // Divide by zero... QQQ
188  return op1 / op2;
189}
190
191inline jdouble BytecodeInterpreter::VMdoubleMul(jdouble op1, jdouble op2) {
192  return op1 * op2;
193}
194
195inline jdouble BytecodeInterpreter::VMdoubleNeg(jdouble op) {
196  return -op;
197}
198
199inline jdouble BytecodeInterpreter::VMdoubleRem(jdouble op1, jdouble op2) {
200  return fmod(op1, op2);
201}
202
203inline jdouble BytecodeInterpreter::VMdoubleSub(jdouble op1, jdouble op2) {
204  return op1 - op2;
205}
206
207inline int32_t BytecodeInterpreter::VMdoubleCompare(jdouble op1,
208                                                    jdouble op2,
209                                                    int32_t direction) {
210  return ( op1 < op2 ? -1 :
211               op1 > op2 ? 1 :
212                   op1 == op2 ? 0 :
213                       (direction == -1 || direction == 1) ? direction : 0);
214}
215
216// Double Conversions
217
218inline jfloat BytecodeInterpreter::VMdouble2Float(jdouble val) {
219  return (jfloat) val;
220}
221
222// Float Conversions
223
224inline jdouble BytecodeInterpreter::VMfloat2Double(jfloat op) {
225  return (jdouble) op;
226}
227
228// Integer Arithmetic
229
230inline jint BytecodeInterpreter::VMintAdd(jint op1, jint op2) {
231  return op1 + op2;
232}
233
234inline jint BytecodeInterpreter::VMintAnd(jint op1, jint op2) {
235  return op1 & op2;
236}
237
238inline jint BytecodeInterpreter::VMintDiv(jint op1, jint op2) {
239  /* it's possible we could catch this special case implicitly */
240  if (op1 == (jint) 0x80000000 && op2 == -1) return op1;
241  else return op1 / op2;
242}
243
244inline jint BytecodeInterpreter::VMintMul(jint op1, jint op2) {
245  return op1 * op2;
246}
247
248inline jint BytecodeInterpreter::VMintNeg(jint op) {
249  return -op;
250}
251
252inline jint BytecodeInterpreter::VMintOr(jint op1, jint op2) {
253  return op1 | op2;
254}
255
256inline jint BytecodeInterpreter::VMintRem(jint op1, jint op2) {
257  /* it's possible we could catch this special case implicitly */
258  if (op1 == (jint) 0x80000000 && op2 == -1) return 0;
259  else return op1 % op2;
260}
261
262inline jint BytecodeInterpreter::VMintShl(jint op1, jint op2) {
263  return op1 << (op2 & 0x1F);
264}
265
266inline jint BytecodeInterpreter::VMintShr(jint op1, jint op2) {
267  return op1 >> (op2 & 0x1F);
268}
269
270inline jint BytecodeInterpreter::VMintSub(jint op1, jint op2) {
271  return op1 - op2;
272}
273
274inline juint BytecodeInterpreter::VMintUshr(jint op1, jint op2) {
275  return ((juint) op1) >> (op2 & 0x1F);
276}
277
278inline jint BytecodeInterpreter::VMintXor(jint op1, jint op2) {
279  return op1 ^ op2;
280}
281
282inline jdouble BytecodeInterpreter::VMint2Double(jint val) {
283  return (jdouble) val;
284}
285
286inline jfloat BytecodeInterpreter::VMint2Float(jint val) {
287  return (jfloat) val;
288}
289
290inline jlong BytecodeInterpreter::VMint2Long(jint val) {
291  return (jlong) val;
292}
293
294inline jchar BytecodeInterpreter::VMint2Char(jint val) {
295  return (jchar) val;
296}
297
298inline jshort BytecodeInterpreter::VMint2Short(jint val) {
299  return (jshort) val;
300}
301
302inline jbyte BytecodeInterpreter::VMint2Byte(jint val) {
303  return (jbyte) val;
304}
305
306#endif // CPU_ZERO_VM_BYTECODEINTERPRETER_ZERO_INLINE_HPP
307