| /* | |
| * Copyright (C) 2009 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| /* | |
| * Dalvik instruction fragments, useful when porting mterp. | |
| * | |
| * Compile this and examine the output to see what your compiler generates. | |
| * This can give you a head start on some of the more complicated operations. | |
| * | |
| * Example: | |
| * % gcc -c -O2 -save-temps -fverbose-asm porting-proto.c | |
| * % less porting-proto.s | |
| */ | |
| #include <stdint.h> | |
| typedef int8_t s1; | |
| typedef uint8_t u1; | |
| typedef int16_t s2; | |
| typedef uint16_t u2; | |
| typedef int32_t s4; | |
| typedef uint32_t u4; | |
| typedef int64_t s8; | |
| typedef uint64_t u8; | |
| s4 iadd32(s4 x, s4 y) { return x + y; } | |
| s8 iadd64(s8 x, s8 y) { return x + y; } | |
| float fadd32(float x, float y) { return x + y; } | |
| double fadd64(double x, double y) { return x + y; } | |
| s4 isub32(s4 x, s4 y) { return x - y; } | |
| s8 isub64(s8 x, s8 y) { return x - y; } | |
| float fsub32(float x, float y) { return x - y; } | |
| double fsub64(double x, double y) { return x - y; } | |
| s4 irsub32lit8(s4 x) { return 25 - x; } | |
| s4 imul32(s4 x, s4 y) { return x * y; } | |
| s8 imul64(s8 x, s8 y) { return x * y; } | |
| float fmul32(float x, float y) { return x * y; } | |
| double fmul64(double x, double y) { return x * y; } | |
| s4 idiv32(s4 x, s4 y) { return x / y; } | |
| s8 idiv64(s8 x, s8 y) { return x / y; } | |
| float fdiv32(float x, float y) { return x / y; } | |
| double fdiv64(double x, double y) { return x / y; } | |
| s4 irem32(s4 x, s4 y) { return x % y; } | |
| s8 irem64(s8 x, s8 y) { return x % y; } | |
| s4 iand32(s4 x, s4 y) { return x & y; } | |
| s8 iand64(s8 x, s8 y) { return x & y; } | |
| s4 ior32(s4 x, s4 y) { return x | y; } | |
| s8 ior64(s8 x, s8 y) { return x | y; } | |
| s4 ixor32(s4 x, s4 y) { return x ^ y; } | |
| s8 ixor64(s8 x, s8 y) { return x ^ y; } | |
| s4 iasl32(s4 x, s4 count) { return x << (count & 0x1f); } | |
| s8 iasl64(s8 x, s4 count) { return x << (count & 0x3f); } | |
| s4 iasr32(s4 x, s4 count) { return x >> (count & 0x1f); } | |
| s8 iasr64(s8 x, s4 count) { return x >> (count & 0x3f); } | |
| s4 ilsr32(s4 x, s4 count) { return ((u4)x) >> (count & 0x1f); } // unsigned | |
| s8 ilsr64(s8 x, s4 count) { return ((u8)x) >> (count & 0x3f); } // unsigned | |
| s4 ineg32(s4 x) { return -x; } | |
| s8 ineg64(s8 x) { return -x; } | |
| float fneg32(float x) { return -x; } | |
| double fneg64(double x) { return -x; } | |
| s4 inot32(s4 x) { return x ^ -1; } | |
| s8 inot64(s8 x) { return x ^ -1LL; } | |
| s4 float2int(float x) { return (s4) x; } | |
| double float2double(float x) { return (double) x; } | |
| s4 double2int(double x) { return (s4) x; } | |
| float double2float(double x) { return (float) x; } | |
| /* | |
| * ARM lib doesn't clamp large values or NaN the way we want on these two. | |
| * If the simple version isn't correct, use the long version. (You can use | |
| * dalvik/tests/041-narrowing to verify.) | |
| */ | |
| s8 float2long(float x) { return (s8) x; } | |
| s8 float2long_clamp(float x) | |
| { | |
| static const float kMaxLong = (float)0x7fffffffffffffffULL; | |
| static const float kMinLong = (float)0x8000000000000000ULL; | |
| if (x >= kMaxLong) { | |
| return 0x7fffffffffffffffULL; | |
| } else if (x <= kMinLong) { | |
| return 0x8000000000000000ULL; | |
| } else if (x != x) { | |
| return 0; | |
| } else { | |
| return (s8) x; | |
| } | |
| } | |
| s8 double2long(double x) { return (s8) x; } | |
| s8 double2long_clamp(double x) | |
| { | |
| static const double kMaxLong = (double)0x7fffffffffffffffULL; | |
| static const double kMinLong = (double)0x8000000000000000ULL; | |
| if (x >= kMaxLong) { | |
| return 0x7fffffffffffffffULL; | |
| } else if (x <= kMinLong) { | |
| return 0x8000000000000000ULL; | |
| } else if (x != x) { | |
| return 0; | |
| } else { | |
| return (s8) x; | |
| } | |
| } | |
| s1 int2byte(s4 x) { return (s1) x; } | |
| s2 int2short(s4 x) { return (s2) x; } | |
| u2 int2char(s4 x) { return (u2) x; } | |
| s8 int2long(s4 x) { return (s8) x; } | |
| float int2float(s4 x) { return (float) x; } | |
| double int2double(s4 x) { return (double) x; } | |
| s4 long2int(s8 x) { return (s4) x; } | |
| float long2float(s8 x) { return (float) x; } | |
| double long2double(s8 x) { return (double) x; } | |
| int cmpl_float(float x, float y) | |
| { | |
| int result; | |
| if (x == y) | |
| result = 0; | |
| else if (x > y) | |
| result = 1; | |
| else /* (x < y) or NaN */ | |
| result = -1; | |
| return result; | |
| } | |
| int cmpg_float(float x, float y) | |
| { | |
| int result; | |
| if (x == y) | |
| result = 0; | |
| else if (x < y) | |
| result = -1; | |
| else /* (x > y) or NaN */ | |
| result = 1; | |
| return result; | |
| } | |
| int cmpl_double(double x, double y) | |
| { | |
| int result; | |
| if (x == y) | |
| result = 0; | |
| else if (x > y) | |
| result = 1; | |
| else /* (x < y) or NaN */ | |
| result = -1; | |
| return result; | |
| } | |
| int cmpg_double(double x, double y) | |
| { | |
| int result; | |
| if (x == y) | |
| result = 0; | |
| else if (x < y) | |
| result = -1; | |
| else /* (x > y) or NaN */ | |
| result = 1; | |
| return result; | |
| } | |
| int cmp_long(s8 x, s8 y) | |
| { | |
| int result; | |
| if (x == y) | |
| result = 0; | |
| else if (x < y) | |
| result = -1; | |
| else /* (x > y) */ | |
| result = 1; | |
| return result; | |
| } | |
| /* instruction decoding fragments */ | |
| u1 unsignedAA(u2 x) { return x >> 8; } | |
| s1 signedAA(u2 x) { return (s4)(x << 16) >> 24; } | |
| s2 signedBB(u2 x) { return (s2) x; } | |
| u1 unsignedA(u2 x) { return (x >> 8) & 0x0f; } | |
| u1 unsignedB(u2 x) { return x >> 12; } | |
| /* some handy immediate constants when working with float/double */ | |
| u4 const_43e00000(u4 highword) { return 0x43e00000; } | |
| u4 const_c3e00000(u4 highword) { return 0xc3e00000; } | |
| u4 const_ffc00000(u4 highword) { return 0xffc00000; } | |
| u4 const_41dfffff(u4 highword) { return 0x41dfffff; } | |
| u4 const_c1e00000(u4 highword) { return 0xc1e00000; } | |
| /* | |
| * Test for some gcc-defined symbols. If you're frequently switching | |
| * between different cross-compiler architectures or CPU feature sets, | |
| * this can help you keep track of which one you're compiling for. | |
| */ | |
| #ifdef __arm__ | |
| # warning "found __arm__" | |
| #endif | |
| #ifdef __ARM_EABI__ | |
| # warning "found __ARM_EABI__" | |
| #endif | |
| #ifdef __VFP_FP__ | |
| # warning "found __VFP_FP__" /* VFP-format doubles used; may not have VFP */ | |
| #endif | |
| #if defined(__VFP_FP__) && !defined(__SOFTFP__) | |
| # warning "VFP in use" | |
| #endif | |
| #ifdef __ARM_ARCH_5TE__ | |
| # warning "found __ARM_ARCH_5TE__" | |
| #endif | |
| #ifdef __ARM_ARCH_7A__ | |
| # warning "found __ARM_ARCH_7A__" | |
| #endif |