| OLD | NEW |
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef SaturatedArithmeticARM_h | |
| 6 #define SaturatedArithmeticARM_h | |
| 7 | |
| 8 #include "wtf/CPU.h" | |
| 9 #include <limits> | |
| 10 #include <stdint.h> | |
| 11 | |
| 12 ALWAYS_INLINE int32_t saturatedAddition(int32_t a, int32_t b) { | |
| 13 int32_t result; | |
| 14 | |
| 15 asm("qadd %[output],%[first],%[second]" | |
| 16 : [output] "=r"(result) | |
| 17 : [first] "r"(a), [second] "r"(b)); | |
| 18 | |
| 19 return result; | |
| 20 } | |
| 21 | |
| 22 ALWAYS_INLINE int32_t saturatedSubtraction(int32_t a, int32_t b) { | |
| 23 int32_t result; | |
| 24 | |
| 25 asm("qsub %[output],%[first],%[second]" | |
| 26 : [output] "=r"(result) | |
| 27 : [first] "r"(a), [second] "r"(b)); | |
| 28 | |
| 29 return result; | |
| 30 } | |
| 31 | |
| 32 ALWAYS_INLINE int32_t saturatedNegative(int32_t a) { | |
| 33 return saturatedSubtraction(0, a); | |
| 34 } | |
| 35 | |
| 36 inline int getMaxSaturatedSetResultForTesting(int FractionalShift) { | |
| 37 // For ARM Asm version the set function maxes out to the biggest | |
| 38 // possible integer part with the fractional part zero'd out. | |
| 39 // e.g. 0x7fffffc0. | |
| 40 return std::numeric_limits<int>::max() & ~((1 << FractionalShift) - 1); | |
| 41 } | |
| 42 | |
| 43 inline int getMinSaturatedSetResultForTesting(int FractionalShift) { | |
| 44 return std::numeric_limits<int>::min(); | |
| 45 } | |
| 46 | |
| 47 template <int FractionalShift> | |
| 48 ALWAYS_INLINE int saturatedSet(int value) { | |
| 49 // Figure out how many bits are left for storing the integer part of | |
| 50 // the fixed point number, and saturate our input to that | |
| 51 enum { Saturate = 32 - FractionalShift }; | |
| 52 | |
| 53 int result; | |
| 54 | |
| 55 // The following ARM code will Saturate the passed value to the number of | |
| 56 // bits used for the whole part of the fixed point representation, then | |
| 57 // shift it up into place. This will result in the low <FractionShift> bits | |
| 58 // all being 0's. When the value saturates this gives a different result | |
| 59 // to from the C++ case; in the C++ code a saturated value has all the low | |
| 60 // bits set to 1 (for a +ve number at least). This cannot be done rapidly | |
| 61 // in ARM ... we live with the difference, for the sake of speed. | |
| 62 | |
| 63 asm("ssat %[output],%[saturate],%[value]\n\t" | |
| 64 "lsl %[output],%[shift]" | |
| 65 : [output] "=r"(result) | |
| 66 : [value] "r"(value), [saturate] "n"(Saturate), | |
| 67 [shift] "n"(FractionalShift)); | |
| 68 | |
| 69 return result; | |
| 70 } | |
| 71 | |
| 72 template <int FractionalShift> | |
| 73 ALWAYS_INLINE int saturatedSet(unsigned value) { | |
| 74 // Here we are being passed an unsigned value to saturate, | |
| 75 // even though the result is returned as a signed integer. The ARM | |
| 76 // instruction for unsigned saturation therefore needs to be given one | |
| 77 // less bit (i.e. the sign bit) for the saturation to work correctly; hence | |
| 78 // the '31' below. | |
| 79 enum { Saturate = 31 - FractionalShift }; | |
| 80 | |
| 81 // The following ARM code will Saturate the passed value to the number of | |
| 82 // bits used for the whole part of the fixed point representation, then | |
| 83 // shift it up into place. This will result in the low <FractionShift> bits | |
| 84 // all being 0's. When the value saturates this gives a different result | |
| 85 // to from the C++ case; in the C++ code a saturated value has all the low | |
| 86 // bits set to 1. This cannot be done rapidly in ARM, so we live with the | |
| 87 // difference, for the sake of speed. | |
| 88 | |
| 89 int result; | |
| 90 | |
| 91 asm("usat %[output],%[saturate],%[value]\n\t" | |
| 92 "lsl %[output],%[shift]" | |
| 93 : [output] "=r"(result) | |
| 94 : [value] "r"(value), [saturate] "n"(Saturate), | |
| 95 [shift] "n"(FractionalShift)); | |
| 96 | |
| 97 return result; | |
| 98 } | |
| 99 | |
| 100 #endif // SaturatedArithmeticARM_h | |
| OLD | NEW |