2 * Copyright (C) 2009 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * Dalvik instruction fragments, useful when porting mterp.
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.
24 * % gcc -c -O2 -save-temps -fverbose-asm porting-proto.c
25 * % less porting-proto.s
38 s4 iadd32(s4 x, s4 y) { return x + y; }
39 s8 iadd64(s8 x, s8 y) { return x + y; }
40 float fadd32(float x, float y) { return x + y; }
41 double fadd64(double x, double y) { return x + y; }
43 s4 isub32(s4 x, s4 y) { return x - y; }
44 s8 isub64(s8 x, s8 y) { return x - y; }
45 float fsub32(float x, float y) { return x - y; }
46 double fsub64(double x, double y) { return x - y; }
48 s4 irsub32lit8(s4 x) { return 25 - x; }
50 s4 imul32(s4 x, s4 y) { return x * y; }
51 s8 imul64(s8 x, s8 y) { return x * y; }
52 float fmul32(float x, float y) { return x * y; }
53 double fmul64(double x, double y) { return x * y; }
55 s4 idiv32(s4 x, s4 y) { return x / y; }
56 s8 idiv64(s8 x, s8 y) { return x / y; }
57 float fdiv32(float x, float y) { return x / y; }
58 double fdiv64(double x, double y) { return x / y; }
60 s4 irem32(s4 x, s4 y) { return x % y; }
61 s8 irem64(s8 x, s8 y) { return x % y; }
63 s4 iand32(s4 x, s4 y) { return x & y; }
64 s8 iand64(s8 x, s8 y) { return x & y; }
66 s4 ior32(s4 x, s4 y) { return x | y; }
67 s8 ior64(s8 x, s8 y) { return x | y; }
69 s4 ixor32(s4 x, s4 y) { return x ^ y; }
70 s8 ixor64(s8 x, s8 y) { return x ^ y; }
72 s4 iasl32(s4 x, s4 count) { return x << (count & 0x1f); }
73 s8 iasl64(s8 x, s4 count) { return x << (count & 0x3f); }
75 s4 iasr32(s4 x, s4 count) { return x >> (count & 0x1f); }
76 s8 iasr64(s8 x, s4 count) { return x >> (count & 0x3f); }
78 s4 ilsr32(s4 x, s4 count) { return ((u4)x) >> (count & 0x1f); } // unsigned
79 s8 ilsr64(s8 x, s4 count) { return ((u8)x) >> (count & 0x3f); } // unsigned
81 s4 ineg32(s4 x) { return -x; }
82 s8 ineg64(s8 x) { return -x; }
83 float fneg32(float x) { return -x; }
84 double fneg64(double x) { return -x; }
86 s4 inot32(s4 x) { return x ^ -1; }
87 s8 inot64(s8 x) { return x ^ -1LL; }
89 s4 float2int(float x) { return (s4) x; }
90 s8 float2long(float x) { return (s8) x; }
91 double float2double(float x) { return (double) x; }
92 s4 double2int(double x) { return (s4) x; }
93 s8 double2long(double x) { return (s8) x; }
94 float double2float(double x) { return (float) x; }
96 s1 int2byte(s4 x) { return (s1) x; }
97 s2 int2short(s4 x) { return (s2) x; }
98 u2 int2char(s4 x) { return (u2) x; }
99 s8 int2long(s4 x) { return (s8) x; }
100 float int2float(s4 x) { return (float) x; }
101 double int2double(s4 x) { return (double) x; }
103 s4 long2int(s8 x) { return (s4) x; }
104 float long2float(s8 x) { return (float) x; }
105 double long2double(s8 x) { return (double) x; }
107 int cmpl_float(float x, float y)
115 else /* (x < y) or NaN */
120 int cmpg_float(float x, float y)
128 else /* (x > y) or NaN */
133 int cmpl_double(double x, double y)
141 else /* (x < y) or NaN */
146 int cmpg_double(double x, double y)
154 else /* (x > y) or NaN */
159 int cmp_long(s8 x, s8 y)
172 /* instruction decoding fragments */
173 u1 unsignedAA(u2 x) { return x >> 8; }
174 s1 signedAA(u2 x) { return (s4)(x << 16) >> 24; }
175 s2 signedBB(u2 x) { return (s2) x; }
176 u1 unsignedA(u2 x) { return (x >> 8) & 0x0f; }
177 u1 unsignedB(u2 x) { return x >> 12; }
179 /* some handy immediate constants when working with float/double */
180 u4 const_43e00000(u4 highword) { return 0x43e00000; }
181 u4 const_c3e00000(u4 highword) { return 0xc3e00000; }
182 u4 const_ffc00000(u4 highword) { return 0xffc00000; }
183 u4 const_41dfffff(u4 highword) { return 0x41dfffff; }
184 u4 const_c1e00000(u4 highword) { return 0xc1e00000; }
187 * Test for some gcc-defined symbols. If you're frequently switching
188 * between different cross-compiler architectures or CPU feature sets,
189 * this can help you keep track of which one you're compiling for.
192 # warning "found __arm__"
195 # warning "found __ARM_EABI__"
198 # warning "found __VFP_FP__" /* VFP-format doubles used; may not have VFP */
200 #if defined(__VFP_FP__) && !defined(__SOFTFP__)
201 # warning "VFP in use"
203 #ifdef __ARM_ARCH_5TE__
204 # warning "found __ARM_ARCH_5TE__"
206 #ifdef __ARM_ARCH_7A__
207 # warning "found __ARM_ARCH_7A__"