// Copyright 2016 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 BASE_NUMERICS_SATURATED_ARITHMETIC_ARM_H_
#define BASE_NUMERICS_SATURATED_ARITHMETIC_ARM_H_

#include <limits>

namespace base {

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;
}

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 int32_t SaturatedNegative(int32_t a) {
  return SaturatedSubtraction(0, a);
}

inline int32_t SaturatedAbsolute(int32_t a) {
  if (a >= 0)
    return a;
  return SaturatedNegative(a);
}

inline int GetMaxSaturatedSetResultForTesting(int fractional_shift) {
  // 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 << fractional_shift) - 1);
}

inline int GetMinSaturatedSetResultForTesting(int fractional_shift) {
  return std::numeric_limits<int>::min();
}

template <int fractional_shift>
inline int SaturatedSet(int value) {
  // Figure out how many bits are left for storing the integer part of
  // the fixed point number, and saturate our input to that
  enum { Saturate = 32 - fractional_shift };

  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"(fractional_shift));

  return result;
}

template <int fractional_shift>
inline int SaturatedSet(unsigned value) {
  // 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.
  enum { Saturate = 31 - fractional_shift };

  // 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"(fractional_shift));

  return result;
}

}  // namespace base

#endif  // BASE_NUMERICS_SATURATED_ARITHMETIC_ARM_H_