v8::internal::TypeImpl< Config >::BitsetType Class Reference

#include <types.h>

Inheritance diagram for v8::internal::TypeImpl< Config >::BitsetType:

Collaboration diagram for v8::internal::TypeImpl< Config >::BitsetType:

Classes
struct	BitsetMin

Protected Member Functions
bitset	Bitset ()
Protected Member Functions inherited from v8::internal::TypeImpl< Config >
TypeImpl *	unhandle ()
bool	IsNone ()
bool	IsAny ()
bool	IsBitset ()
bool	IsUnion ()
bitset	AsBitset ()
UnionType *	AsUnion ()
bitset	BitsetGlb ()
bitset	BitsetLub ()
bool	SlowIs (TypeImpl *that)
RangeType *	GetRange ()
bool	SimplyEquals (TypeImpl *that)
template<class TypeHandle >
bool	SimplyEquals (TypeHandle that)

Static Protected Member Functions
static TypeImpl *	New (bitset bits)
static TypeHandle	New (bitset bits, Region *region)
static bool	IsInhabited (bitset bits)
static bool	Is (bitset bits1, bitset bits2)
static double	Min (bitset)
static double	Max (bitset)
static bitset	Glb (TypeImpl *type)
static bitset	Lub (TypeImpl *type)
static bitset	Lub (i::Object *value)
static bitset	Lub (double value)
static bitset	Lub (int32_t value)
static bitset	Lub (uint32_t value)
static bitset	Lub (i::Map *map)
static bitset	Lub (Limits lim)
static const char *	Name (bitset)
static void	Print (OStream &os, bitset)
Static Protected Member Functions inherited from v8::internal::TypeImpl< Config >
template<class T >
static Config::template Handle< T >::type	handle (T *type)
static bool	IsInteger (double x)
static bool	IsInteger (i::Object *x)
static Limits	Intersect (Limits lhs, Limits rhs)
static Limits	Union (Limits lhs, Limits rhs)
static bool	Overlap (RangeType *lhs, RangeType *rhs)
static bool	Contains (RangeType *lhs, RangeType *rhs)
static bool	Contains (RangeType *range, i::Object *val)
static int	UpdateRange (RangeHandle type, UnionHandle result, int size, Region *region)
static int	AddToUnion (TypeHandle type, UnionHandle result, int size, Region *region)
static int	IntersectAux (TypeHandle type, TypeHandle other, UnionHandle result, int size, Region *region)
static TypeHandle	NormalizeUnion (UnionHandle unioned, int size)

Static Private Member Functions
static const BitsetMin *	BitsetMins ()
static size_t	BitsetMinsSize ()

Static Private Attributes
static const BitsetMin	BitsetMins31 []
static const BitsetMin	BitsetMins32 []

Friends
class	TypeImpl< Config >

Additional Inherited Members
Public Types inherited from v8::internal::TypeImpl< Config >
enum	PrintDimension { BOTH_DIMS , SEMANTIC_DIM , REPRESENTATION_DIM }
typedef uint32_t	bitset
typedef Config::template Handle< TypeImpl >::type	TypeHandle
typedef Config::template Handle< ClassType >::type	ClassHandle
typedef Config::template Handle< ConstantType >::type	ConstantHandle
typedef Config::template Handle< RangeType >::type	RangeHandle
typedef Config::template Handle< ContextType >::type	ContextHandle
typedef Config::template Handle< ArrayType >::type	ArrayHandle
typedef Config::template Handle< FunctionType >::type	FunctionHandle
typedef Config::template Handle< UnionType >::type	UnionHandle
typedef Config::Region	Region
Public Member Functions inherited from v8::internal::TypeImpl< Config >
bool	IsInhabited ()
bool	Is (TypeImpl *that)
template<class TypeHandle >
bool	Is (TypeHandle that)
bool	Maybe (TypeImpl *that)
template<class TypeHandle >
bool	Maybe (TypeHandle that)
bool	Equals (TypeImpl *that)
template<class TypeHandle >
bool	Equals (TypeHandle that)
bool	Contains (i::Object *val)
bool	Contains (i::Handle< i::Object > val)
bool	NowIs (TypeImpl *that)
template<class TypeHandle >
bool	NowIs (TypeHandle that)
bool	NowContains (i::Object *val)
bool	NowContains (i::Handle< i::Object > val)
bool	NowStable ()
bool	IsClass ()
bool	IsConstant ()
bool	IsRange ()
bool	IsContext ()
bool	IsArray ()
bool	IsFunction ()
ClassType *	AsClass ()
ConstantType *	AsConstant ()
RangeType *	AsRange ()
ContextType *	AsContext ()
ArrayType *	AsArray ()
FunctionType *	AsFunction ()
double	Min ()
double	Max ()
int	NumClasses ()
int	NumConstants ()
Iterator< i::Map >	Classes ()
Iterator< i::Object >	Constants ()
void	PrintTo (OStream &os, PrintDimension dim=BOTH_DIMS)
template<class OtherType >
TypeImpl< Config >::TypeHandle	Convert (typename OtherType::TypeHandle type, Region *region)
Static Public Member Functions inherited from v8::internal::TypeImpl< Config >
static TypeHandle	Class (i::Handle< i::Map > map, Region *region)
static TypeHandle	Constant (i::Handle< i::Object > value, Region *region)
static TypeHandle	Range (i::Handle< i::Object > min, i::Handle< i::Object > max, Region *region)
static TypeHandle	Context (TypeHandle outer, Region *region)
static TypeHandle	Array (TypeHandle element, Region *region)
static FunctionHandle	Function (TypeHandle result, TypeHandle receiver, int arity, Region *region)
static TypeHandle	Function (TypeHandle result, Region *region)
static TypeHandle	Function (TypeHandle result, TypeHandle param0, Region *region)
static TypeHandle	Function (TypeHandle result, TypeHandle param0, TypeHandle param1, Region *region)
static TypeHandle	Function (TypeHandle result, TypeHandle param0, TypeHandle param1, TypeHandle param2, Region *region)
static TypeHandle	Union (TypeHandle type1, TypeHandle type2, Region *reg)
static TypeHandle	Intersect (TypeHandle type1, TypeHandle type2, Region *reg)
static TypeHandle	Of (double value, Region *region)
static TypeHandle	Of (i::Object *value, Region *region)
static TypeHandle	Of (i::Handle< i::Object > value, Region *region)
static TypeHandle	NowOf (i::Object *value, Region *region)
static TypeHandle	NowOf (i::Handle< i::Object > value, Region *region)
static TypeImpl *	cast (typename Config::Base *object)
template<class OtherTypeImpl >
static TypeHandle	Convert (typename OtherTypeImpl::TypeHandle type, Region *region)

Detailed Description

template<class Config>
class v8::internal::TypeImpl< Config >::BitsetType

Definition at line 564 of file types.h.

Member Function Documentation

Bitset()

template<class Config >

bitset v8::internal::TypeImpl< Config >::BitsetType::Bitset ( )

inlineprotected

Definition at line 575 of file types.h.

{ return Config::as_bitset(this); }

BitsetMins()

template<class Config >

static const BitsetMin* v8::internal::TypeImpl< Config >::BitsetType::BitsetMins ( )

inlinestaticprivate

Definition at line 621 of file types.h.

                                       {
    return i::SmiValuesAre31Bits() ? BitsetMins31 : BitsetMins32;
  }

References v8::internal::SmiValuesAre31Bits().

Here is the call graph for this function:

BitsetMinsSize()

template<class Config >

static size_t v8::internal::TypeImpl< Config >::BitsetType::BitsetMinsSize ( )

inlinestaticprivate

Definition at line 624 of file types.h.

                                 {
    return i::SmiValuesAre31Bits() ? 7 : 5;
    /* arraysize(BitsetMins31) : arraysize(BitsetMins32); */
    // Using arraysize here doesn't compile on Windows.
  }

References v8::internal::SmiValuesAre31Bits().

Here is the call graph for this function:

Glb()

template<class Config >

TypeImpl< Config >::bitset v8::internal::TypeImpl< Config >::BitsetType::Glb ( TypeImpl *  type )

staticprotected

Definition at line 120 of file types.cc.

                                              {
  DisallowHeapAllocation no_allocation;
  if (type->IsBitset()) {
    return type->AsBitset();
  } else if (type->IsUnion()) {
    SLOW_DCHECK(type->AsUnion()->Wellformed());
    return type->AsUnion()->Get(0)->BitsetGlb();  // Shortcut.
    // (The remaining BitsetGlb's are None anyway).
  } else {
    return kNone;
  }
}

References v8::internal::TypeImpl< Config >::AsBitset(), v8::internal::TypeImpl< Config >::AsUnion(), v8::internal::TypeImpl< Config >::StructuralType::Get(), v8::internal::TypeImpl< Config >::IsBitset(), v8::internal::TypeImpl< Config >::IsUnion(), SLOW_DCHECK, and v8::internal::TypeImpl< Config >::UnionType::Wellformed().

Referenced by v8::internal::TypeImpl< Config >::BitsetGlb().

Here is the call graph for this function:

Here is the caller graph for this function:

Is()

template<class Config >

static bool v8::internal::TypeImpl< Config >::BitsetType::Is ( bitset  bits1, bitset  bits2  )

inlinestaticprotected

Definition at line 592 of file types.h.

                                             {
    return (bits1 | bits2) == bits2;
  }

Referenced by v8::internal::TypeImpl< Config >::SlowIs().

Here is the caller graph for this function:

IsInhabited()

template<class Config >

static bool v8::internal::TypeImpl< Config >::BitsetType::IsInhabited ( bitset  bits )

inlinestaticprotected

Definition at line 588 of file types.h.

                                       {
    return bits & kSemantic;
  }

Lub() [1/7]

template<class Config >

TypeImpl< Config >::bitset v8::internal::TypeImpl< Config >::BitsetType::Lub ( double  value )

staticprotected

Definition at line 273 of file types.cc.

                                            {
  DisallowHeapAllocation no_allocation;
  if (i::IsMinusZero(value)) return kMinusZero;
  if (std::isnan(value)) return kNaN;
  if (IsUint32Double(value)) return Lub(FastD2UI(value));
  if (IsInt32Double(value)) return Lub(FastD2I(value));
  return kOtherNumber;
}

References v8::internal::FastD2I(), v8::internal::FastD2UI(), v8::internal::IsInt32Double(), v8::internal::IsMinusZero(), and v8::internal::IsUint32Double().

Here is the call graph for this function:

Lub() [2/7]

template<class Config >

TypeImpl< Config >::bitset v8::internal::TypeImpl< Config >::BitsetType::Lub ( i::Map *  map )

staticprotected

Definition at line 164 of file types.cc.

                                         {
  DisallowHeapAllocation no_allocation;
  switch (map->instance_type()) {
    case STRING_TYPE:
    case ONE_BYTE_STRING_TYPE:
    case CONS_STRING_TYPE:
    case CONS_ONE_BYTE_STRING_TYPE:
    case SLICED_STRING_TYPE:
    case SLICED_ONE_BYTE_STRING_TYPE:
    case EXTERNAL_STRING_TYPE:
    case EXTERNAL_ONE_BYTE_STRING_TYPE:
    case EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
    case SHORT_EXTERNAL_STRING_TYPE:
    case SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE:
    case SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
      return kOtherString;
    case INTERNALIZED_STRING_TYPE:
    case ONE_BYTE_INTERNALIZED_STRING_TYPE:
    case EXTERNAL_INTERNALIZED_STRING_TYPE:
    case EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE:
    case EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE:
    case SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE:
    case SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE:
    case SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE:
      return kInternalizedString;
    case SYMBOL_TYPE:
      return kSymbol;
    case ODDBALL_TYPE: {
      Heap* heap = map->GetHeap();
      if (map == heap->undefined_map()) return kUndefined;
      if (map == heap->null_map()) return kNull;
      if (map == heap->boolean_map()) return kBoolean;
      DCHECK(map == heap->the_hole_map() ||
             map == heap->uninitialized_map() ||
             map == heap->no_interceptor_result_sentinel_map() ||
             map == heap->termination_exception_map() ||
             map == heap->arguments_marker_map());
      return kInternal & kTaggedPtr;
    }
    case HEAP_NUMBER_TYPE:
      return kNumber & kTaggedPtr;
    case JS_VALUE_TYPE:
    case JS_DATE_TYPE:
    case JS_OBJECT_TYPE:
    case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
    case JS_GENERATOR_OBJECT_TYPE:
    case JS_MODULE_TYPE:
    case JS_GLOBAL_OBJECT_TYPE:
    case JS_BUILTINS_OBJECT_TYPE:
    case JS_GLOBAL_PROXY_TYPE:
    case JS_ARRAY_BUFFER_TYPE:
    case JS_TYPED_ARRAY_TYPE:
    case JS_DATA_VIEW_TYPE:
    case JS_SET_TYPE:
    case JS_MAP_TYPE:
    case JS_SET_ITERATOR_TYPE:
    case JS_MAP_ITERATOR_TYPE:
    case JS_WEAK_MAP_TYPE:
    case JS_WEAK_SET_TYPE:
      if (map->is_undetectable()) return kUndetectable;
      return kOtherObject;
    case JS_ARRAY_TYPE:
      return kArray;
    case JS_FUNCTION_TYPE:
      return kFunction;
    case JS_REGEXP_TYPE:
      return kRegExp;
    case JS_PROXY_TYPE:
    case JS_FUNCTION_PROXY_TYPE:
      return kProxy;
    case MAP_TYPE:
      // When compiling stub templates, the meta map is used as a place holder
      // for the actual map with which the template is later instantiated.
      // We treat it as a kind of type variable whose upper bound is Any.
      // TODO(rossberg): for caching of CompareNilIC stubs to work correctly,
      // we must exclude Undetectable here. This makes no sense, really,
      // because it means that the template isn't actually parametric.
      // Also, it doesn't apply elsewhere. 8-(
      // We ought to find a cleaner solution for compiling stubs parameterised
      // over type or class variables, esp ones with bounds...
      return kDetectable;
    case DECLARED_ACCESSOR_INFO_TYPE:
    case EXECUTABLE_ACCESSOR_INFO_TYPE:
    case SHARED_FUNCTION_INFO_TYPE:
    case ACCESSOR_PAIR_TYPE:
    case FIXED_ARRAY_TYPE:
    case FOREIGN_TYPE:
    case CODE_TYPE:
      return kInternal & kTaggedPtr;
    default:
      UNREACHABLE();
      return kNone;
  }
}

References v8::internal::ACCESSOR_PAIR_TYPE, v8::internal::CODE_TYPE, v8::internal::CONS_ONE_BYTE_STRING_TYPE, v8::internal::CONS_STRING_TYPE, DCHECK, v8::internal::DECLARED_ACCESSOR_INFO_TYPE, v8::internal::EXECUTABLE_ACCESSOR_INFO_TYPE, v8::internal::EXTERNAL_INTERNALIZED_STRING_TYPE, v8::internal::EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE, v8::internal::EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE, v8::internal::EXTERNAL_ONE_BYTE_STRING_TYPE, v8::internal::EXTERNAL_STRING_TYPE, v8::internal::EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, v8::internal::FIXED_ARRAY_TYPE, v8::internal::FOREIGN_TYPE, v8::internal::HEAP_NUMBER_TYPE, v8::internal::INTERNALIZED_STRING_TYPE, v8::internal::JS_ARRAY_BUFFER_TYPE, v8::internal::JS_ARRAY_TYPE, v8::internal::JS_BUILTINS_OBJECT_TYPE, v8::internal::JS_CONTEXT_EXTENSION_OBJECT_TYPE, v8::internal::JS_DATA_VIEW_TYPE, v8::internal::JS_DATE_TYPE, v8::internal::JS_FUNCTION_PROXY_TYPE, v8::internal::JS_FUNCTION_TYPE, v8::internal::JS_GENERATOR_OBJECT_TYPE, v8::internal::JS_GLOBAL_OBJECT_TYPE, v8::internal::JS_GLOBAL_PROXY_TYPE, v8::internal::JS_MAP_ITERATOR_TYPE, v8::internal::JS_MAP_TYPE, v8::internal::JS_MODULE_TYPE, v8::internal::JS_OBJECT_TYPE, v8::internal::JS_PROXY_TYPE, v8::internal::JS_REGEXP_TYPE, v8::internal::JS_SET_ITERATOR_TYPE, v8::internal::JS_SET_TYPE, v8::internal::JS_TYPED_ARRAY_TYPE, v8::internal::JS_VALUE_TYPE, v8::internal::JS_WEAK_MAP_TYPE, v8::internal::JS_WEAK_SET_TYPE, map, v8::internal::MAP_TYPE, v8::internal::ODDBALL_TYPE, v8::internal::ONE_BYTE_INTERNALIZED_STRING_TYPE, v8::internal::ONE_BYTE_STRING_TYPE, v8::internal::SHARED_FUNCTION_INFO_TYPE, v8::internal::SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE, v8::internal::SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE, v8::internal::SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE, v8::internal::SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE, v8::internal::SHORT_EXTERNAL_STRING_TYPE, v8::internal::SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, v8::internal::SLICED_ONE_BYTE_STRING_TYPE, v8::internal::SLICED_STRING_TYPE, v8::internal::STRING_TYPE, v8::internal::SYMBOL_TYPE, and UNREACHABLE.

Lub() [3/7]

template<class Config >

TypeImpl< Config >::bitset v8::internal::TypeImpl< Config >::BitsetType::Lub ( i::Object *  value )

staticprotected

Definition at line 262 of file types.cc.

                                              {
  DisallowHeapAllocation no_allocation;
  if (value->IsNumber()) {
    return Lub(value->Number()) & (value->IsSmi() ? kTaggedInt : kTaggedPtr);
  }
  return Lub(i::HeapObject::cast(value)->map());
}

References map, and v8::internal::Object::Number().

Here is the call graph for this function:

Lub() [4/7]

template<class Config >

TypeImpl< Config >::bitset v8::internal::TypeImpl< Config >::BitsetType::Lub ( int32_t  value )

staticprotected

Definition at line 285 of file types.cc.

                                             {
  DisallowHeapAllocation no_allocation;
  if (value >= 0x40000000) {
    return i::SmiValuesAre31Bits() ? kOtherUnsigned31 : kUnsignedSmall;
  }
  if (value >= 0) return kUnsignedSmall;
  if (value >= -0x40000000) return kOtherSignedSmall;
  return i::SmiValuesAre31Bits() ? kOtherSigned32 : kOtherSignedSmall;
}

References v8::internal::SmiValuesAre31Bits().

Here is the call graph for this function:

Lub() [5/7]

template<class Config >

TypeImpl< Config >::bitset v8::internal::TypeImpl< Config >::BitsetType::Lub ( Limits  lim )

staticprotected

Definition at line 337 of file types.cc.

                                          {
  DisallowHeapAllocation no_allocation;
  double min = lim.min->Number();
  double max = lim.max->Number();
  int lub = kNone;
  const BitsetMin* mins = BitsetMins();
 
  for (size_t i = 1; i < BitsetMinsSize(); ++i) {
    if (min < mins[i].min) {
      lub |= mins[i-1].bits;
      if (max < mins[i].min) return lub;
    }
  }
  return lub |= mins[BitsetMinsSize()-1].bits;
}

References v8::internal::TypeImpl< Config >::BitsetType::BitsetMin::bits, v8::internal::TypeImpl< Config >::Limits::max, v8::internal::min(), and v8::internal::TypeImpl< Config >::Limits::min.

Here is the call graph for this function:

Lub() [6/7]

template<class Config >

TypeImpl< Config >::bitset v8::internal::TypeImpl< Config >::BitsetType::Lub ( TypeImpl *  type )

staticprotected

Definition at line 137 of file types.cc.

                                              {
  DisallowHeapAllocation no_allocation;
  if (type->IsBitset()) return type->AsBitset();
  if (type->IsUnion()) {
    int bitset = kNone;
    for (int i = 0, n = type->AsUnion()->Length(); i < n; ++i) {
      bitset |= type->AsUnion()->Get(i)->BitsetLub();
    }
    return bitset;
  }
  if (type->IsClass()) {
    // Little hack to avoid the need for a region for handlification here...
    return Config::is_class(type) ? Lub(*Config::as_class(type)) :
        type->AsClass()->Bound(NULL)->AsBitset();
  }
  if (type->IsConstant()) return type->AsConstant()->Bound()->AsBitset();
  if (type->IsRange()) return type->AsRange()->BitsetLub();
  if (type->IsContext()) return kInternal & kTaggedPtr;
  if (type->IsArray()) return kArray;
  if (type->IsFunction()) return kFunction;
  UNREACHABLE();
  return kNone;
}

References v8::internal::TypeImpl< Config >::AsBitset(), v8::internal::TypeImpl< Config >::AsClass(), v8::internal::TypeImpl< Config >::AsConstant(), v8::internal::TypeImpl< Config >::AsRange(), v8::internal::TypeImpl< Config >::AsUnion(), v8::internal::TypeImpl< Config >::RangeType::BitsetLub(), v8::internal::TypeImpl< Config >::ConstantType::Bound(), v8::internal::TypeImpl< Config >::ClassType::Bound(), v8::internal::TypeImpl< Config >::StructuralType::Get(), v8::internal::TypeImpl< Config >::IsArray(), v8::internal::TypeImpl< Config >::IsBitset(), v8::internal::TypeImpl< Config >::IsClass(), v8::internal::TypeImpl< Config >::IsConstant(), v8::internal::TypeImpl< Config >::IsContext(), v8::internal::TypeImpl< Config >::IsFunction(), v8::internal::TypeImpl< Config >::IsRange(), v8::internal::TypeImpl< Config >::IsUnion(), v8::internal::TypeImpl< Config >::StructuralType::Length(), NULL, and UNREACHABLE.

Referenced by v8::internal::TypeImpl< Config >::BitsetLub(), v8::internal::TypeImpl< Config >::ClassType::Bound(), v8::internal::TypeImpl< Config >::Contains(), v8::internal::TypeImpl< Config >::ClassType::New(), v8::internal::TypeImpl< Config >::Of(), and v8::internal::TypeImpl< Config >::PrintTo().

Here is the call graph for this function:

Here is the caller graph for this function:

Lub() [7/7]

template<class Config >

TypeImpl< Config >::bitset v8::internal::TypeImpl< Config >::BitsetType::Lub ( uint32_t  value )

staticprotected

Definition at line 298 of file types.cc.

                                              {
  DisallowHeapAllocation no_allocation;
  if (value >= 0x80000000u) return kOtherUnsigned32;
  if (value >= 0x40000000u) {
    return i::SmiValuesAre31Bits() ? kOtherUnsigned31 : kUnsignedSmall;
  }
  return kUnsignedSmall;
}

References v8::internal::SmiValuesAre31Bits().

Here is the call graph for this function:

Max()

template<class Config >

double v8::internal::TypeImpl< Config >::BitsetType::Max ( bitset  bits )

staticprotected

Definition at line 371 of file types.cc.

                                                  {
  DisallowHeapAllocation no_allocation;
  DCHECK(Is(bits, kNumber));
  const BitsetMin* mins = BitsetMins();
  bool mz = bits & kMinusZero;
  if (BitsetType::Is(mins[BitsetMinsSize()-1].bits, bits)) {
    return +V8_INFINITY;
  }
  for (size_t i = BitsetMinsSize()-1; i-- > 0; ) {
    if (Is(SEMANTIC(mins[i].bits), bits)) {
      return mz ?
          std::max(0.0, mins[i+1].min - 1) : mins[i+1].min - 1;
    }
  }
  if (mz) return 0;
  return base::OS::nan_value();
}

Min()

template<class Config >

double v8::internal::TypeImpl< Config >::BitsetType::Min ( bitset  bits )

staticprotected

Definition at line 355 of file types.cc.

                                                  {
  DisallowHeapAllocation no_allocation;
  DCHECK(Is(bits, kNumber));
  const BitsetMin* mins = BitsetMins();
  bool mz = SEMANTIC(bits & kMinusZero);
  for (size_t i = 0; i < BitsetMinsSize(); ++i) {
    if (Is(SEMANTIC(mins[i].bits), bits)) {
      return mz ? std::min(0.0, mins[i].min) : mins[i].min;
    }
  }
  if (mz) return 0;
  return base::OS::nan_value();
}

References DCHECK, v8::internal::TypeImpl< Config >::Is(), v8::internal::min(), v8::internal::TypeImpl< Config >::BitsetType::BitsetMin::min, v8::base::OS::nan_value(), and SEMANTIC.

Here is the call graph for this function:

Name()

template<class Config >

const char * v8::internal::TypeImpl< Config >::BitsetType::Name ( bitset  bits )

staticprotected

Definition at line 978 of file types.cc.

                                                        {
  switch (bits) {
    case REPRESENTATION(kAny): return "Any";
    #define RETURN_NAMED_REPRESENTATION_TYPE(type, value) \
    case REPRESENTATION(k##type): return #type;
    REPRESENTATION_BITSET_TYPE_LIST(RETURN_NAMED_REPRESENTATION_TYPE)
    #undef RETURN_NAMED_REPRESENTATION_TYPE
 
    #define RETURN_NAMED_SEMANTIC_TYPE(type, value) \
    case SEMANTIC(k##type): return #type;
    SEMANTIC_BITSET_TYPE_LIST(RETURN_NAMED_SEMANTIC_TYPE)
    #undef RETURN_NAMED_SEMANTIC_TYPE
 
    default:
      return NULL;
  }
}

References NULL, REPRESENTATION, REPRESENTATION_BITSET_TYPE_LIST, RETURN_NAMED_REPRESENTATION_TYPE, RETURN_NAMED_SEMANTIC_TYPE, and SEMANTIC_BITSET_TYPE_LIST.

New() [1/2]

template<class Config >

static TypeImpl* v8::internal::TypeImpl< Config >::BitsetType::New ( bitset  bits )

inlinestaticprotected

Definition at line 577 of file types.h.

                                    {
    DCHECK(bits == kNone || IsInhabited(bits));
    return Config::from_bitset(bits);
  }

References DCHECK, and v8::internal::TypeImpl< Config >::IsInhabited().

Referenced by v8::internal::TypeImpl< Config >::ClassType::Bound(), v8::internal::TypeImpl< Config >::Contains(), v8::internal::TypeImpl< Config >::Convert(), v8::internal::TypeImpl< Config >::ClassType::New(), v8::internal::TypeImpl< ZoneTypeConfig >::BitsetType::Print(), v8::internal::TypeImpl< Config >::PrintTo(), and v8::internal::TypeImpl< Config >::Union().

Here is the call graph for this function:

Here is the caller graph for this function:

New() [2/2]

template<class Config >

static TypeHandle v8::internal::TypeImpl< Config >::BitsetType::New ( bitset  bits, Region *  region  )

inlinestaticprotected

Definition at line 581 of file types.h.

                                                     {
    DCHECK(bits == kNone || IsInhabited(bits));
    return Config::from_bitset(bits, region);
  }

References DCHECK, and v8::internal::TypeImpl< Config >::IsInhabited().

Here is the call graph for this function:

Print()

template<class Config >

void v8::internal::TypeImpl< Config >::BitsetType::Print ( OStream &  os, bitset  bits  )

staticprotected

Definition at line 998 of file types.cc.

                                                      {
  DisallowHeapAllocation no_allocation;
  const char* name = Name(bits);
  if (name != NULL) {
    os << name;
    return;
  }
 
  static const bitset named_bitsets[] = {
#define BITSET_CONSTANT(type, value) REPRESENTATION(k##type),
      REPRESENTATION_BITSET_TYPE_LIST(BITSET_CONSTANT)
#undef BITSET_CONSTANT
 
#define BITSET_CONSTANT(type, value) SEMANTIC(k##type),
      SEMANTIC_BITSET_TYPE_LIST(BITSET_CONSTANT)
#undef BITSET_CONSTANT
  };
 
  bool is_first = true;
  os << "(";
  for (int i(arraysize(named_bitsets) - 1); bits != 0 && i >= 0; --i) {
    bitset subset = named_bitsets[i];
    if ((bits & subset) == subset) {
      if (!is_first) os << " | ";
      is_first = false;
      os << Name(subset);
      bits -= subset;
    }
  }
  DCHECK(bits == 0);
  os << ")";
}

References arraysize, BITSET_CONSTANT, DCHECK, name, NULL, REPRESENTATION_BITSET_TYPE_LIST, and SEMANTIC_BITSET_TYPE_LIST.

Referenced by v8::internal::TypeImpl< Config >::PrintTo().

Here is the caller graph for this function:

Friends And Related Function Documentation

TypeImpl< Config >

template<class Config >

friend class TypeImpl< Config >

friend

Definition at line 533 of file types.h.

Member Data Documentation

BitsetMins31

template<class Config >

const TypeImpl< Config >::BitsetType::BitsetMin v8::internal::TypeImpl< Config >::BitsetType::BitsetMins31

staticprivate

Initial value:

= {
    {kOtherNumber, -V8_INFINITY},
    {kOtherSigned32, kMinInt},
    {kOtherSignedSmall, -0x40000000},
    {kUnsignedSmall, 0},
    {kOtherUnsigned31, 0x40000000},
    {kOtherUnsigned32, 0x80000000},
    {kOtherNumber, static_cast<double>(kMaxUInt32) + 1}
}

Definition at line 619 of file types.h.

BitsetMins32

template<class Config >

const TypeImpl< Config >::BitsetType::BitsetMin v8::internal::TypeImpl< Config >::BitsetType::BitsetMins32

staticprivate

Initial value:

= {
    {kOtherNumber, -V8_INFINITY},
    {kOtherSignedSmall, kMinInt},
    {kUnsignedSmall, 0},
    {kOtherUnsigned32, 0x80000000},
    {kOtherNumber, static_cast<double>(kMaxUInt32) + 1}
}

Definition at line 620 of file types.h.

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/types.h
• /mnt/V8SourceCode/src/types.cc