safe_math_shared_impl.h File Reference

#include <concepts>
#include <type_traits>
#include "build/build_config.h"
#include "src/base/numerics/safe_conversions.h"

Include dependency graph for safe_math_shared_impl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	v8::base::internal::CheckedAddFastOp< T, U >
struct	v8::base::internal::CheckedSubFastOp< T, U >
struct	v8::base::internal::CheckedMulFastOp< T, U >
struct	v8::base::internal::ClampedAddFastOp< T, U >
struct	v8::base::internal::ClampedSubFastOp< T, U >
struct	v8::base::internal::ClampedMulFastOp< T, U >
struct	v8::base::internal::ClampedNegFastOp< T >
struct	v8::base::internal::UnsignedOrFloatForSize< Numeric >
struct	v8::base::internal::MathWrapper< M, L, R, Math >

Namespaces
namespace	v8
namespace	v8::base
namespace	v8::base::internal

Macros
#define	BASE_HAS_OPTIMIZED_SAFE_MATH   (0)
#define	BASE_NUMERIC_ARITHMETIC_VARIADIC(CLASS, CL_ABBR, OP_NAME)
#define	BASE_NUMERIC_ARITHMETIC_OPERATORS(CLASS, CL_ABBR, OP_NAME, OP, CMP_OP)

Functions
template<typename T > requires (std::integral<T>)
constexpr T	v8::base::internal::NegateWrapper (T value)
template<typename T > requires (std::floating_point<T>)
constexpr T	v8::base::internal::NegateWrapper (T value)
template<typename T > requires (std::integral<T>)
constexpr std::make_unsigned< T >::type	v8::base::internal::InvertWrapper (T value)
template<typename T > requires (std::integral<T>)
constexpr T	v8::base::internal::AbsWrapper (T value)
template<typename T > requires (std::floating_point<T>)
constexpr T	v8::base::internal::AbsWrapper (T value)

Macro Definition Documentation

BASE_HAS_OPTIMIZED_SAFE_MATH

#define BASE_HAS_OPTIMIZED_SAFE_MATH   (0)

Definition at line 31 of file safe_math_shared_impl.h.

BASE_NUMERIC_ARITHMETIC_OPERATORS

#define BASE_NUMERIC_ARITHMETIC_OPERATORS	(		CLASS,
			CL_ABBR,
			OP_NAME,
			OP,
			CMP_OP )

Value:

  /* Binary arithmetic operator for all CLASS##Numeric operations. */          \
  template <typename L, typename R>                                            \
    requires(Is##CLASS##Op<L, R>)                                              \
  constexpr CLASS##Numeric<typename MathWrapper<CLASS##OP_NAME##Op, L,         \
                                                R>::type> operator OP(L lhs,   \
                                                                      R rhs) { \
    return decltype(lhs OP rhs)::template MathOp<CLASS##OP_NAME##Op>(lhs,      \
                                                                     rhs);     \
  }                                                                            \
  /* Assignment arithmetic operator implementation from CLASS##Numeric. */     \
  template <typename L>                                                        \
    requires std::is_arithmetic_v<L>                                           \
  template <typename R>                                                        \
  constexpr CLASS##Numeric<L>& CLASS##Numeric<L>::operator CMP_OP(R rhs) {     \
    return MathOp<CLASS##OP_NAME##Op>(rhs);                                    \
  }                                                                            \
  /* Variadic arithmetic functions that return CLASS##Numeric. */              \
  BASE_NUMERIC_ARITHMETIC_VARIADIC(CLASS, CL_ABBR, OP_NAME)

Definition at line 185 of file safe_math_shared_impl.h.

BASE_NUMERIC_ARITHMETIC_VARIADIC

#define BASE_NUMERIC_ARITHMETIC_VARIADIC	(		CLASS,
			CL_ABBR,
			OP_NAME )

Value:

  template <typename L, typename R, typename... Args>                   \
  constexpr auto CL_ABBR##OP_NAME(L lhs, R rhs, Args... args) {         \
    return CL_ABBR##MathOp<CLASS##OP_NAME##Op, L, R, Args...>(lhs, rhs, \
                                                              args...); \
  }

Definition at line 178 of file safe_math_shared_impl.h.