• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/*
18 * Dalvik instruction fragments, useful when porting mterp.
19 *
20 * Compile this and examine the output to see what your compiler generates.
21 * This can give you a head start on some of the more complicated operations.
22 *
23 * Example:
24 *   % gcc -c -O2 -save-temps -fverbose-asm porting-proto.c
25 *   % less porting-proto.s
26 */
27#include <stdint.h>
28
29typedef int8_t s1;
30typedef uint8_t u1;
31typedef int16_t s2;
32typedef uint16_t u2;
33typedef int32_t s4;
34typedef uint32_t u4;
35typedef int64_t s8;
36typedef uint64_t u8;
37
38s4 iadd32(s4 x, s4 y) { return x + y; }
39s8 iadd64(s8 x, s8 y) { return x + y; }
40float fadd32(float x, float y) { return x + y; }
41double fadd64(double x, double y) { return x + y; }
42
43s4 isub32(s4 x, s4 y) { return x - y; }
44s8 isub64(s8 x, s8 y) { return x - y; }
45float fsub32(float x, float y) { return x - y; }
46double fsub64(double x, double y) { return x - y; }
47
48s4 irsub32lit8(s4 x) { return 25 - x; }
49
50s4 imul32(s4 x, s4 y) { return x * y; }
51s8 imul64(s8 x, s8 y) { return x * y; }
52float fmul32(float x, float y) { return x * y; }
53double fmul64(double x, double y) { return x * y; }
54
55s4 idiv32(s4 x, s4 y) { return x / y; }
56s8 idiv64(s8 x, s8 y) { return x / y; }
57float fdiv32(float x, float y) { return x / y; }
58double fdiv64(double x, double y) { return x / y; }
59
60s4 irem32(s4 x, s4 y) { return x % y; }
61s8 irem64(s8 x, s8 y) { return x % y; }
62
63s4 iand32(s4 x, s4 y) { return x & y; }
64s8 iand64(s8 x, s8 y) { return x & y; }
65
66s4 ior32(s4 x, s4 y) { return x | y; }
67s8 ior64(s8 x, s8 y) { return x | y; }
68
69s4 ixor32(s4 x, s4 y) { return x ^ y; }
70s8 ixor64(s8 x, s8 y) { return x ^ y; }
71
72s4 iasl32(s4 x, s4 count) { return x << (count & 0x1f); }
73s8 iasl64(s8 x, s4 count) { return x << (count & 0x3f); }
74
75s4 iasr32(s4 x, s4 count) { return x >> (count & 0x1f); }
76s8 iasr64(s8 x, s4 count) { return x >> (count & 0x3f); }
77
78s4 ilsr32(s4 x, s4 count) { return ((u4)x) >> (count & 0x1f); } // unsigned
79s8 ilsr64(s8 x, s4 count) { return ((u8)x) >> (count & 0x3f); } // unsigned
80
81s4 ineg32(s4 x) { return -x; }
82s8 ineg64(s8 x) { return -x; }
83float fneg32(float x) { return -x; }
84double fneg64(double x) { return -x; }
85
86s4 inot32(s4 x) { return x ^ -1; }
87s8 inot64(s8 x) { return x ^ -1LL; }
88
89s4 float2int(float x) { return (s4) x; }
90double float2double(float x) { return (double) x; }
91s4 double2int(double x) { return (s4) x; }
92float double2float(double x) { return (float) x; }
93
94/*
95 * ARM lib doesn't clamp large values or NaN the way we want on these two.
96 * If the simple version isn't correct, use the long version.  (You can use
97 * dalvik/tests/041-narrowing to verify.)
98 */
99s8 float2long(float x) { return (s8) x; }
100s8 float2long_clamp(float x)
101{
102    static const float kMaxLong = (float)0x7fffffffffffffffULL;
103    static const float kMinLong = (float)0x8000000000000000ULL;
104
105    if (x >= kMaxLong) {
106        return 0x7fffffffffffffffULL;
107    } else if (x <= kMinLong) {
108        return 0x8000000000000000ULL;
109    } else if (x != x) {
110        return 0;
111    } else {
112        return (s8) x;
113    }
114}
115s8 double2long(double x) { return (s8) x; }
116s8 double2long_clamp(double x)
117{
118    static const double kMaxLong = (double)0x7fffffffffffffffULL;
119    static const double kMinLong = (double)0x8000000000000000ULL;
120
121    if (x >= kMaxLong) {
122        return 0x7fffffffffffffffULL;
123    } else if (x <= kMinLong) {
124        return 0x8000000000000000ULL;
125    } else if (x != x) {
126        return 0;
127    } else {
128        return (s8) x;
129    }
130}
131
132s1 int2byte(s4 x) { return (s1) x; }
133s2 int2short(s4 x) { return (s2) x; }
134u2 int2char(s4 x) { return (u2) x; }
135s8 int2long(s4 x) { return (s8) x; }
136float int2float(s4 x) { return (float) x; }
137double int2double(s4 x) { return (double) x; }
138
139s4 long2int(s8 x) { return (s4) x; }
140float long2float(s8 x) { return (float) x; }
141double long2double(s8 x) { return (double) x; }
142
143int cmpl_float(float x, float y)
144{
145    int result;
146
147    if (x == y)
148        result = 0;
149    else if (x > y)
150        result = 1;
151    else /* (x < y) or NaN */
152        result = -1;
153    return result;
154}
155
156int cmpg_float(float x, float y)
157{
158    int result;
159
160    if (x == y)
161        result = 0;
162    else if (x < y)
163        result = -1;
164    else /* (x > y) or NaN */
165        result = 1;
166    return result;
167}
168
169int cmpl_double(double x, double y)
170{
171    int result;
172
173    if (x == y)
174        result = 0;
175    else if (x > y)
176        result = 1;
177    else /* (x < y) or NaN */
178        result = -1;
179    return result;
180}
181
182int cmpg_double(double x, double y)
183{
184    int result;
185
186    if (x == y)
187        result = 0;
188    else if (x < y)
189        result = -1;
190    else /* (x > y) or NaN */
191        result = 1;
192    return result;
193}
194
195int cmp_long(s8 x, s8 y)
196{
197    int result;
198
199    if (x == y)
200        result = 0;
201    else if (x < y)
202        result = -1;
203    else /* (x > y) */
204        result = 1;
205    return result;
206}
207
208/* instruction decoding fragments */
209u1 unsignedAA(u2 x) { return x >> 8; }
210s1 signedAA(u2 x) { return (s4)(x << 16) >> 24; }
211s2 signedBB(u2 x) { return (s2) x; }
212u1 unsignedA(u2 x) { return (x >> 8) & 0x0f; }
213u1 unsignedB(u2 x) { return x >> 12; }
214
215/* some handy immediate constants when working with float/double */
216u4 const_43e00000(u4 highword) { return 0x43e00000; }
217u4 const_c3e00000(u4 highword) { return 0xc3e00000; }
218u4 const_ffc00000(u4 highword) { return 0xffc00000; }
219u4 const_41dfffff(u4 highword) { return 0x41dfffff; }
220u4 const_c1e00000(u4 highword) { return 0xc1e00000; }
221
222/*
223 * Test for some gcc-defined symbols.  If you're frequently switching
224 * between different cross-compiler architectures or CPU feature sets,
225 * this can help you keep track of which one you're compiling for.
226 */
227#ifdef __arm__
228# warning "found __arm__"
229#endif
230#ifdef __ARM_EABI__
231# warning "found __ARM_EABI__"
232#endif
233#ifdef __VFP_FP__
234# warning "found __VFP_FP__"    /* VFP-format doubles used; may not have VFP */
235#endif
236#if defined(__VFP_FP__) && !defined(__SOFTFP__)
237# warning "VFP in use"
238#endif
239#ifdef __ARM_ARCH_5TE__
240# warning "found __ARM_ARCH_5TE__"
241#endif
242#ifdef __ARM_ARCH_7A__
243# warning "found __ARM_ARCH_7A__"
244#endif
245