v8::base::internal Namespace Reference

Classes
struct	MaxExponent
struct	StaticDstRangeRelationToSrcRange
struct	StaticDstRangeRelationToSrcRange< Dst, Src, Sign, Sign >
struct	StaticDstRangeRelationToSrcRange< Dst, Src, INTEGER_REPRESENTATION_SIGNED, INTEGER_REPRESENTATION_UNSIGNED >
struct	StaticDstRangeRelationToSrcRange< Dst, Src, INTEGER_REPRESENTATION_UNSIGNED, INTEGER_REPRESENTATION_SIGNED >
struct	DstRangeRelationToSrcRangeImpl
struct	DstRangeRelationToSrcRangeImpl< Dst, Src, DstSign, SrcSign, NUMERIC_RANGE_CONTAINED >
struct	DstRangeRelationToSrcRangeImpl< Dst, Src, INTEGER_REPRESENTATION_SIGNED, INTEGER_REPRESENTATION_SIGNED, NUMERIC_RANGE_NOT_CONTAINED >
struct	DstRangeRelationToSrcRangeImpl< Dst, Src, INTEGER_REPRESENTATION_UNSIGNED, INTEGER_REPRESENTATION_UNSIGNED, NUMERIC_RANGE_NOT_CONTAINED >
struct	DstRangeRelationToSrcRangeImpl< Dst, Src, INTEGER_REPRESENTATION_SIGNED, INTEGER_REPRESENTATION_UNSIGNED, NUMERIC_RANGE_NOT_CONTAINED >
struct	DstRangeRelationToSrcRangeImpl< Dst, Src, INTEGER_REPRESENTATION_UNSIGNED, INTEGER_REPRESENTATION_SIGNED, NUMERIC_RANGE_NOT_CONTAINED >
class	CheckedNumeric
struct	integral_constant
struct	is_same
struct	is_same< T, T >
struct	enable_if
struct	enable_if< true, T >
struct	IntegerForSizeAndSign
struct	IntegerForSizeAndSign< 1, true >
struct	IntegerForSizeAndSign< 1, false >
struct	IntegerForSizeAndSign< 2, true >
struct	IntegerForSizeAndSign< 2, false >
struct	IntegerForSizeAndSign< 4, true >
struct	IntegerForSizeAndSign< 4, false >
struct	IntegerForSizeAndSign< 8, true >
struct	IntegerForSizeAndSign< 8, false >
struct	UnsignedIntegerForSize
struct	SignedIntegerForSize
struct	TwiceWiderInteger
struct	PositionOfSignBit
struct	GetNumericRepresentation
class	CheckedNumericState
class	CheckedNumericState< T, NUMERIC_INTEGER >
class	CheckedNumericState< T, NUMERIC_FLOATING >
struct	ArithmeticPromotion
struct	ArithmeticPromotion< Lhs, Rhs, LEFT_PROMOTION >
struct	ArithmeticPromotion< Lhs, Rhs, RIGHT_PROMOTION >
struct	ArithmeticPromotion< Lhs, Rhs, DEFAULT_PROMOTION >
struct	IsIntegerArithmeticSafe

Typedefs
typedef integral_constant< bool, true >	true_type
typedef integral_constant< bool, false >	false_type

Enumerations
enum	IntegerRepresentation { INTEGER_REPRESENTATION_UNSIGNED , INTEGER_REPRESENTATION_SIGNED }
enum	NumericRangeRepresentation { NUMERIC_RANGE_NOT_CONTAINED , NUMERIC_RANGE_CONTAINED }
enum	RangeConstraint { RANGE_VALID = 0x0 , RANGE_UNDERFLOW = 0x1 , RANGE_OVERFLOW = 0x2 , RANGE_INVALID = RANGE_UNDERFLOW | RANGE_OVERFLOW }
enum	NumericRepresentation { NUMERIC_INTEGER , NUMERIC_FLOATING , NUMERIC_UNKNOWN }
enum	ArithmeticPromotionCategory { LEFT_PROMOTION , RIGHT_PROMOTION , DEFAULT_PROMOTION }

Functions
RangeConstraint	GetRangeConstraint (int integer_range_constraint)
RangeConstraint	GetRangeConstraint (bool is_in_upper_bound, bool is_in_lower_bound)
template<typename Dst , typename Src >
RangeConstraint	DstRangeRelationToSrcRange (Src value)
template<typename T >
bool	HasSignBit (T x)
template<typename T >
T	BinaryComplement (T x)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer, T >::type	CheckedAdd (T x, T y, RangeConstraint *validity)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer, T >::type	CheckedSub (T x, T y, RangeConstraint *validity)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer &&!std::numeric_limits< T >::is_signed &&(sizeof(T) *2 > sizeof(uintmax_t)), T >::type	CheckedMul (T x, T y, RangeConstraint *validity)
template<typename T >
T	CheckedDiv (T x, T y, RangeConstraint *validity, typename enable_if< std::numeric_limits< T >::is_integer, int >::type=0)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer &&std::numeric_limits< T >::is_signed, T >::type	CheckedMod (T x, T y, RangeConstraint *validity)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer &&!std::numeric_limits< T >::is_signed, T >::type	CheckedMod (T x, T y, RangeConstraint *validity)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer &&std::numeric_limits< T >::is_signed, T >::type	CheckedNeg (T value, RangeConstraint *validity)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer &&!std::numeric_limits< T >::is_signed, T >::type	CheckedNeg (T value, RangeConstraint *validity)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer &&std::numeric_limits< T >::is_signed, T >::type	CheckedAbs (T value, RangeConstraint *validity)
template<typename T >
enable_if< std::numeric_limits< T >::is_integer &&!std::numeric_limits< T >::is_signed, T >::type	CheckedAbs (T value, RangeConstraint *validity)
template<typename T >
enable_if< std::numeric_limits< T >::is_iec559, T >::type	CheckedNeg (T value, RangeConstraint *)
template<typename T >
enable_if< std::numeric_limits< T >::is_iec559, T >::type	CheckedAbs (T value, RangeConstraint *)

Variables
else *	validity
return x *	y

Typedef Documentation

false_type

typedef integral_constant<bool, false> v8::base::internal::false_type

Definition at line 37 of file safe_math_impl.h.

true_type

typedef integral_constant<bool, true> v8::base::internal::true_type

Definition at line 36 of file safe_math_impl.h.

Enumeration Type Documentation

ArithmeticPromotionCategory

enum v8::base::internal::ArithmeticPromotionCategory

Enumerator
LEFT_PROMOTION
RIGHT_PROMOTION
DEFAULT_PROMOTION

Definition at line 479 of file safe_math_impl.h.

                                 {
  LEFT_PROMOTION,
  RIGHT_PROMOTION,
  DEFAULT_PROMOTION
};

IntegerRepresentation

enum v8::base::internal::IntegerRepresentation

Enumerator
INTEGER_REPRESENTATION_UNSIGNED
INTEGER_REPRESENTATION_SIGNED

Definition at line 31 of file safe_conversions_impl.h.

                           {
  INTEGER_REPRESENTATION_UNSIGNED,
  INTEGER_REPRESENTATION_SIGNED
};

NumericRangeRepresentation

enum v8::base::internal::NumericRangeRepresentation

Enumerator
NUMERIC_RANGE_NOT_CONTAINED
NUMERIC_RANGE_CONTAINED

Definition at line 41 of file safe_conversions_impl.h.

                                {
  NUMERIC_RANGE_NOT_CONTAINED,
  NUMERIC_RANGE_CONTAINED
};

NumericRepresentation

enum v8::base::internal::NumericRepresentation

Enumerator
NUMERIC_INTEGER
NUMERIC_FLOATING
NUMERIC_UNKNOWN

Definition at line 359 of file safe_math_impl.h.

                           {
  NUMERIC_INTEGER,
  NUMERIC_FLOATING,
  NUMERIC_UNKNOWN
};

RangeConstraint

enum v8::base::internal::RangeConstraint

Enumerator
RANGE_VALID
RANGE_UNDERFLOW
RANGE_OVERFLOW
RANGE_INVALID

Definition at line 93 of file safe_conversions_impl.h.

                     {
  RANGE_VALID = 0x0,  // Value can be represented by the destination type.
  RANGE_UNDERFLOW = 0x1,  // Value would overflow.
  RANGE_OVERFLOW = 0x2,  // Value would underflow.
  RANGE_INVALID = RANGE_UNDERFLOW | RANGE_OVERFLOW  // Invalid (i.e. NaN).
};

Function Documentation

BinaryComplement()

template<typename T >

T v8::base::internal::BinaryComplement

(

T

x

)

Definition at line 135 of file safe_math_impl.h.

                        {
  return ~x;
}

Referenced by CheckedAdd(), and CheckedSub().

Here is the caller graph for this function:

CheckedAbs() [1/3]

template<typename T >

enable_if<std::numeric_limits<T>::is_iec559, T>::type v8::base::internal::CheckedAbs	(	T	value,
		RangeConstraint *
	)

Definition at line 350 of file safe_math_impl.h.

                      {
  return std::abs(value);
}

CheckedAbs() [2/3]

template<typename T >

enable_if< std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed, T>::type v8::base::internal::CheckedAbs	(	T	value,
		RangeConstraint *	validity
	)

Definition at line 308 of file safe_math_impl.h.

                                               {
  *validity =
      value != std::numeric_limits<T>::min() ? RANGE_VALID : RANGE_OVERFLOW;
  return std::abs(value);
}

References v8::internal::min(), RANGE_OVERFLOW, RANGE_VALID, and validity.

Referenced by v8::base::internal::CheckedNumeric< T >::Abs().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckedAbs() [3/3]

template<typename T >

enable_if< std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed, T>::type v8::base::internal::CheckedAbs	(	T	value,
		RangeConstraint *	validity
	)

Definition at line 318 of file safe_math_impl.h.

                                               {
  // Absolute value of a positive is just its identiy.
  *validity = RANGE_VALID;
  return value;
}

References RANGE_VALID, and validity.

CheckedAdd()

template<typename T >

enable_if<std::numeric_limits<T>::is_integer, T>::type v8::base::internal::CheckedAdd	(	T	x,
		T	y,
		RangeConstraint *	validity
	)

Definition at line 145 of file safe_math_impl.h.

                                                {
  // Since the value of x+y is undefined if we have a signed type, we compute
  // it using the unsigned type of the same size.
  typedef typename UnsignedIntegerForSize<T>::type UnsignedDst;
  UnsignedDst ux = static_cast<UnsignedDst>(x);
  UnsignedDst uy = static_cast<UnsignedDst>(y);
  UnsignedDst uresult = ux + uy;
  // Addition is valid if the sign of (x + y) is equal to either that of x or
  // that of y.
  if (std::numeric_limits<T>::is_signed) {
    if (HasSignBit(BinaryComplement((uresult ^ ux) & (uresult ^ uy))))
      *validity = RANGE_VALID;
    else  // Direction of wrap is inverse of result sign.
      *validity = HasSignBit(uresult) ? RANGE_OVERFLOW : RANGE_UNDERFLOW;
 
  } else {  // Unsigned is either valid or overflow.
    *validity = BinaryComplement(x) >= y ? RANGE_VALID : RANGE_OVERFLOW;
  }
  return static_cast<T>(uresult);
}

References BinaryComplement(), HasSignBit(), RANGE_OVERFLOW, RANGE_UNDERFLOW, RANGE_VALID, T, validity, and y.

Here is the call graph for this function:

CheckedDiv()

template<typename T >

T v8::base::internal::CheckedDiv	(	T	x,
		T	y,
		RangeConstraint *	validity,
		typename enable_if< std::numeric_limits< T >::is_integer, int >::type	= 0
	)

Definition at line 249 of file safe_math_impl.h.

                                                                     {
  if (std::numeric_limits<T>::is_signed && x == std::numeric_limits<T>::min() &&
      y == static_cast<T>(-1)) {
    *validity = RANGE_OVERFLOW;
    return std::numeric_limits<T>::min();
  }
 
  *validity = RANGE_VALID;
  return x / y;
}

References v8::internal::min(), RANGE_OVERFLOW, RANGE_VALID, T, validity, and y.

Here is the call graph for this function:

CheckedMod() [1/2]

template<typename T >

enable_if< std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed, T>::type v8::base::internal::CheckedMod	(	T	x,
		T	y,
		RangeConstraint *	validity
	)

Definition at line 268 of file safe_math_impl.h.

                                                {
  *validity = y > 0 ? RANGE_VALID : RANGE_INVALID;
  return x % y;
}

References RANGE_INVALID, RANGE_VALID, validity, and y.

CheckedMod() [2/2]

template<typename T >

enable_if< std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed, T>::type v8::base::internal::CheckedMod	(	T	x,
		T	y,
		RangeConstraint *	validity
	)

Definition at line 277 of file safe_math_impl.h.

                                                {
  *validity = RANGE_VALID;
  return x % y;
}

References RANGE_VALID, validity, and y.

CheckedMul()

template<typename T >

enable_if<std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed && (sizeof(T) * 2 > sizeof(uintmax_t)), T>::type v8::base::internal::CheckedMul	(	T	x,
		T	y,
		RangeConstraint *	validity
	)

Definition at line 240 of file safe_math_impl.h.

                                                {
  *validity = (y == 0 || x <= std::numeric_limits<T>::max() / y)
                  ? RANGE_VALID
                  : RANGE_OVERFLOW;
  return x * y;
}

References RANGE_OVERFLOW, RANGE_VALID, validity, and y.

CheckedNeg() [1/3]

template<typename T >

enable_if<std::numeric_limits<T>::is_iec559, T>::type v8::base::internal::CheckedNeg	(	T	value,
		RangeConstraint *
	)

Definition at line 343 of file safe_math_impl.h.

                      {
  return -value;
}

CheckedNeg() [2/3]

template<typename T >

enable_if< std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed, T>::type v8::base::internal::CheckedNeg	(	T	value,
		RangeConstraint *	validity
	)

Definition at line 286 of file safe_math_impl.h.

                                               {
  *validity =
      value != std::numeric_limits<T>::min() ? RANGE_VALID : RANGE_OVERFLOW;
  // The negation of signed min is min, so catch that one.
  return -value;
}

References v8::internal::min(), RANGE_OVERFLOW, RANGE_VALID, and validity.

Referenced by v8::base::internal::CheckedNumeric< T >::operator-().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckedNeg() [3/3]

template<typename T >

enable_if< std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed, T>::type v8::base::internal::CheckedNeg	(	T	value,
		RangeConstraint *	validity
	)

Definition at line 297 of file safe_math_impl.h.

                                               {
  // The only legal unsigned negation is zero.
  *validity = value ? RANGE_UNDERFLOW : RANGE_VALID;
  return static_cast<T>(
      -static_cast<typename SignedIntegerForSize<T>::type>(value));
}

References RANGE_UNDERFLOW, RANGE_VALID, T, and validity.

CheckedSub()

template<typename T >

enable_if<std::numeric_limits<T>::is_integer, T>::type v8::base::internal::CheckedSub	(	T	x,
		T	y,
		RangeConstraint *	validity
	)

Definition at line 168 of file safe_math_impl.h.

                                                {
  // Since the value of x+y is undefined if we have a signed type, we compute
  // it using the unsigned type of the same size.
  typedef typename UnsignedIntegerForSize<T>::type UnsignedDst;
  UnsignedDst ux = static_cast<UnsignedDst>(x);
  UnsignedDst uy = static_cast<UnsignedDst>(y);
  UnsignedDst uresult = ux - uy;
  // Subtraction is valid if either x and y have same sign, or (x-y) and x have
  // the same sign.
  if (std::numeric_limits<T>::is_signed) {
    if (HasSignBit(BinaryComplement((uresult ^ ux) & (ux ^ uy))))
      *validity = RANGE_VALID;
    else  // Direction of wrap is inverse of result sign.
      *validity = HasSignBit(uresult) ? RANGE_OVERFLOW : RANGE_UNDERFLOW;
 
  } else {  // Unsigned is either valid or underflow.
    *validity = x >= y ? RANGE_VALID : RANGE_UNDERFLOW;
  }
  return static_cast<T>(uresult);
}

References BinaryComplement(), HasSignBit(), RANGE_OVERFLOW, RANGE_UNDERFLOW, RANGE_VALID, T, validity, and y.

Here is the call graph for this function:

DstRangeRelationToSrcRange()

template<typename Dst , typename Src >

RangeConstraint v8::base::internal::DstRangeRelationToSrcRange ( Src  value )

inline

Definition at line 209 of file safe_conversions_impl.h.

                                                             {
  // Both source and destination must be numeric.
  STATIC_ASSERT(std::numeric_limits<Src>::is_specialized);
  STATIC_ASSERT(std::numeric_limits<Dst>::is_specialized);
  return DstRangeRelationToSrcRangeImpl<Dst, Src>::Check(value);
}

References STATIC_ASSERT.

GetRangeConstraint() [1/2]

RangeConstraint v8::base::internal::GetRangeConstraint ( bool  is_in_upper_bound, bool  is_in_lower_bound  )

inline

Definition at line 110 of file safe_conversions_impl.h.

                                                           {
  return GetRangeConstraint((is_in_upper_bound ? 0 : RANGE_OVERFLOW) |
                            (is_in_lower_bound ? 0 : RANGE_UNDERFLOW));
}

References GetRangeConstraint(), RANGE_OVERFLOW, and RANGE_UNDERFLOW.

Here is the call graph for this function:

GetRangeConstraint() [2/2]

RangeConstraint v8::base::internal::GetRangeConstraint ( int  integer_range_constraint )

inline

Definition at line 101 of file safe_conversions_impl.h.

                                                                        {
  DCHECK(integer_range_constraint >= RANGE_VALID &&
         integer_range_constraint <= RANGE_INVALID);
  return static_cast<RangeConstraint>(integer_range_constraint);
}

References DCHECK, RANGE_INVALID, and RANGE_VALID.

Referenced by v8::base::internal::CheckedNumeric< T >::Abs(), v8::base::internal::DstRangeRelationToSrcRangeImpl< Dst, Src, INTEGER_REPRESENTATION_SIGNED, INTEGER_REPRESENTATION_SIGNED, NUMERIC_RANGE_NOT_CONTAINED >::Check(), v8::base::internal::DstRangeRelationToSrcRangeImpl< Dst, Src, INTEGER_REPRESENTATION_UNSIGNED, INTEGER_REPRESENTATION_UNSIGNED, NUMERIC_RANGE_NOT_CONTAINED >::Check(), v8::base::internal::DstRangeRelationToSrcRangeImpl< Dst, Src, INTEGER_REPRESENTATION_SIGNED, INTEGER_REPRESENTATION_UNSIGNED, NUMERIC_RANGE_NOT_CONTAINED >::Check(), v8::base::internal::DstRangeRelationToSrcRangeImpl< Dst, Src, INTEGER_REPRESENTATION_UNSIGNED, INTEGER_REPRESENTATION_SIGNED, NUMERIC_RANGE_NOT_CONTAINED >::Check(), GetRangeConstraint(), v8::base::internal::CheckedNumeric< T >::operator-(), and v8::base::internal::CheckedNumericState< T, NUMERIC_FLOATING >::validity().

Here is the caller graph for this function:

HasSignBit()

template<typename T >

bool v8::base::internal::HasSignBit

(

T

x

)

Definition at line 127 of file safe_math_impl.h.

                     {
  // Cast to unsigned since right shift on signed is undefined.
  return !!(static_cast<typename UnsignedIntegerForSize<T>::type>(x) >>
            PositionOfSignBit<T>::value);
}

Referenced by CheckedAdd(), and CheckedSub().

Here is the caller graph for this function:

Variable Documentation

validity

else* v8::base::internal::validity

Initial value:

=
          y >= std::numeric_limits<T>::max() / x ? RANGE_VALID : RANGE_OVERFLOW

Definition at line 228 of file safe_math_impl.h.

Referenced by CheckedAbs(), CheckedAdd(), CheckedDiv(), CheckedMod(), CheckedMul(), CheckedNeg(), and CheckedSub().

y

return x* v8::base::internal::y

Definition at line 232 of file safe_math_impl.h.

Referenced by v8::internal::ElementsAccessorBase< ElementsAccessorSubclass, ElementsTraitsParam >::AddElementsToFixedArray(), CheckedAdd(), CheckedDiv(), CheckedMod(), CheckedMul(), CheckedSub(), v8::internal::Variable::CompareIndex(), v8::internal::MakePair(), v8::internal::modulo(), v8::internal::ParserBase< Traits >::ParseBinaryExpression(), v8::internal::power_double_double(), v8::internal::power_double_int(), v8::internal::power_helper(), v8::internal::RUNTIME_FUNCTION(), v8::internal::ParserTraits::ShortcutNumericLiteralBinaryExpression(), v8::Value::StrictEquals(), v8::internal::CompareICState::TargetState(), v8::internal::compiler::TEST_F(), and v8::internal::CompareIC::UpdateCaches().