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 29 typedef int8_t s1; 30 typedef uint8_t u1; 31 typedef int16_t s2; 32 typedef uint16_t u2; 33 typedef int32_t s4; 34 typedef uint32_t u4; 35 typedef int64_t s8; 36 typedef uint64_t u8; 37 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; } 42 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; } 47 48 s4 irsub32lit8(s4 x) { return 25 - x; } 49 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; } 54 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; } 59 60 s4 irem32(s4 x, s4 y) { return x % y; } 61 s8 irem64(s8 x, s8 y) { return x % y; } 62 63 s4 iand32(s4 x, s4 y) { return x & y; } 64 s8 iand64(s8 x, s8 y) { return x & y; } 65 66 s4 ior32(s4 x, s4 y) { return x | y; } 67 s8 ior64(s8 x, s8 y) { return x | y; } 68 69 s4 ixor32(s4 x, s4 y) { return x ^ y; } 70 s8 ixor64(s8 x, s8 y) { return x ^ y; } 71 72 s4 iasl32(s4 x, s4 count) { return x << (count & 0x1f); } 73 s8 iasl64(s8 x, s4 count) { return x << (count & 0x3f); } 74 75 s4 iasr32(s4 x, s4 count) { return x >> (count & 0x1f); } 76 s8 iasr64(s8 x, s4 count) { return x >> (count & 0x3f); } 77 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 80 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; } 85 86 s4 inot32(s4 x) { return x ^ -1; } 87 s8 inot64(s8 x) { return x ^ -1LL; } 88 89 s4 float2int(float x) { return (s4) x; } 90 double float2double(float x) { return (double) x; } 91 s4 double2int(double x) { return (s4) x; } 92 float 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 */ 99 s8 float2long(float x) { return (s8) x; } 100 s8 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 } 115 s8 double2long(double x) { return (s8) x; } 116 s8 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 132 s1 int2byte(s4 x) { return (s1) x; } 133 s2 int2short(s4 x) { return (s2) x; } 134 u2 int2char(s4 x) { return (u2) x; } 135 s8 int2long(s4 x) { return (s8) x; } 136 float int2float(s4 x) { return (float) x; } 137 double int2double(s4 x) { return (double) x; } 138 139 s4 long2int(s8 x) { return (s4) x; } 140 float long2float(s8 x) { return (float) x; } 141 double long2double(s8 x) { return (double) x; } 142 143 int 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 156 int 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 169 int 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 182 int 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 195 int 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 */ 209 u1 unsignedAA(u2 x) { return x >> 8; } 210 s1 signedAA(u2 x) { return (s4)(x << 16) >> 24; } 211 s2 signedBB(u2 x) { return (s2) x; } 212 u1 unsignedA(u2 x) { return (x >> 8) & 0x0f; } 213 u1 unsignedB(u2 x) { return x >> 12; } 214 215 /* some handy immediate constants when working with float/double */ 216 u4 const_43e00000(u4 highword) { return 0x43e00000; } 217 u4 const_c3e00000(u4 highword) { return 0xc3e00000; } 218 u4 const_ffc00000(u4 highword) { return 0xffc00000; } 219 u4 const_41dfffff(u4 highword) { return 0x41dfffff; } 220 u4 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
