blob: 58aace754ab1183b202a46afdd868d63a1ca56ae [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SKY_ENGINE_WTF_ASM_SATURATEDARITHMETICARM_H_
#define SKY_ENGINE_WTF_ASM_SATURATEDARITHMETICARM_H_
#include <stdint.h>
#include <limits>
#include "sky/engine/wtf/CPU.h"
ALWAYS_INLINE int32_t saturatedAddition(int32_t a, int32_t b)
{
int32_t result;
asm("qadd %[output],%[first],%[second]"
: [output] "=r" (result)
: [first] "r" (a),
[second] "r" (b));
return result;
}
ALWAYS_INLINE int32_t saturatedSubtraction(int32_t a, int32_t b)
{
int32_t result;
asm("qsub %[output],%[first],%[second]"
: [output] "=r" (result)
: [first] "r" (a),
[second] "r" (b));
return result;
}
inline int getMaxSaturatedSetResultForTesting(int FractionalShift)
{
// For ARM Asm version the set function maxes out to the biggest
// possible integer part with the fractional part zero'd out.
// e.g. 0x7fffffc0.
return std::numeric_limits<int>::max() & ~((1 << FractionalShift)-1);
}
inline int getMinSaturatedSetResultForTesting(int FractionalShift)
{
return std::numeric_limits<int>::min();
}
ALWAYS_INLINE int saturatedSet(int value, int FractionalShift)
{
// Figure out how many bits are left for storing the integer part of
// the fixed point number, and saturate our input to that
const int saturate = 32 - FractionalShift;
int result;
// The following ARM code will Saturate the passed value to the number of
// bits used for the whole part of the fixed point representation, then
// shift it up into place. This will result in the low <FractionShift> bits
// all being 0's. When the value saturates this gives a different result
// to from the C++ case; in the C++ code a saturated value has all the low
// bits set to 1 (for a +ve number at least). This cannot be done rapidly
// in ARM ... we live with the difference, for the sake of speed.
asm("ssat %[output],%[saturate],%[value]\n\t"
"lsl %[output],%[shift]"
: [output] "=r" (result)
: [value] "r" (value),
[saturate] "n" (saturate),
[shift] "n" (FractionalShift));
return result;
}
ALWAYS_INLINE int saturatedSet(unsigned value, int FractionalShift)
{
// Here we are being passed an unsigned value to saturate,
// even though the result is returned as a signed integer. The ARM
// instruction for unsigned saturation therefore needs to be given one
// less bit (i.e. the sign bit) for the saturation to work correctly; hence
// the '31' below.
const int saturate = 31 - FractionalShift;
// The following ARM code will Saturate the passed value to the number of
// bits used for the whole part of the fixed point representation, then
// shift it up into place. This will result in the low <FractionShift> bits
// all being 0's. When the value saturates this gives a different result
// to from the C++ case; in the C++ code a saturated value has all the low
// bits set to 1. This cannot be done rapidly in ARM, so we live with the
// difference, for the sake of speed.
int result;
asm("usat %[output],%[saturate],%[value]\n\t"
"lsl %[output],%[shift]"
: [output] "=r" (result)
: [value] "r" (value),
[saturate] "n" (saturate),
[shift] "n" (FractionalShift));
return result;
}
#endif // SKY_ENGINE_WTF_ASM_SATURATEDARITHMETICARM_H_