Re-revert "Use unsigned type bitsets to limit undefined behaviour"

src/types-inl.h

 // Copyright 2014 the V8 project 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 V8_TYPES_INL_H_
 #define V8_TYPES_INL_H_
 
 #include "src/types.h"
 
 #include "src/factory.h"
@@ skipping 52 matching lines @@
 
 // static
 template<class T>
 T* ZoneTypeConfig::cast(Type* type) {
   return static_cast<T*>(type);
 }
 
 
 // static
 bool ZoneTypeConfig::is_bitset(Type* type) {
-  return reinterpret_cast<uintptr_t>(type) & 1;
+  return reinterpret_cast<intptr_t>(type) & 1;
 }
 
 
 // static
 bool ZoneTypeConfig::is_struct(Type* type, int tag) {
   return !is_bitset(type) && struct_tag(as_struct(type)) == tag;
 }
 
 
 // static
 bool ZoneTypeConfig::is_class(Type* type) {
   return false;
 }
 
 
 // static
-ZoneTypeConfig::Type::bitset ZoneTypeConfig::as_bitset(Type* type) {
+int ZoneTypeConfig::as_bitset(Type* type) {
   DCHECK(is_bitset(type));
-  return reinterpret_cast<Type::bitset>(type) ^ 1u;
+  return static_cast<int>(reinterpret_cast<intptr_t>(type) >> 1);
 }
 
 
 // static
 ZoneTypeConfig::Struct* ZoneTypeConfig::as_struct(Type* type) {
   DCHECK(!is_bitset(type));
   return reinterpret_cast<Struct*>(type);
 }
 
 
 // static
 i::Handle<i::Map> ZoneTypeConfig::as_class(Type* type) {
   UNREACHABLE();
   return i::Handle<i::Map>();
 }
 
 
 // static
-ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(Type::bitset bitset) {
-  return reinterpret_cast<Type*>(bitset | 1u);
+ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(int bitset) {
+  return reinterpret_cast<Type*>((bitset << 1) | 1);
 }
 
 
 // static
-ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(
-    Type::bitset bitset, Zone* Zone) {
+ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(int bitset, Zone* Zone) {
   return from_bitset(bitset);
 }
 
 
 // static
 ZoneTypeConfig::Type* ZoneTypeConfig::from_struct(Struct* structure) {
   return reinterpret_cast<Type*>(structure);
 }
 
 
@@ skipping 94 matching lines @@
 }
 
 
 // static
 bool HeapTypeConfig::is_struct(Type* type, int tag) {
   return type->IsFixedArray() && struct_tag(as_struct(type)) == tag;
 }
 
 
 // static
-HeapTypeConfig::Type::bitset HeapTypeConfig::as_bitset(Type* type) {
-  // TODO(rossberg): Breaks the Smi abstraction. Fix once there is a better way.
-  return reinterpret_cast<Type::bitset>(type);
+int HeapTypeConfig::as_bitset(Type* type) {
+  return i::Smi::cast(type)->value();
 }
 
 
 // static
 i::Handle<i::Map> HeapTypeConfig::as_class(Type* type) {
   return i::handle(i::Map::cast(type));
 }
 
 
 // static
 i::Handle<HeapTypeConfig::Struct> HeapTypeConfig::as_struct(Type* type) {
   return i::handle(Struct::cast(type));
 }
 
 
 // static
-HeapTypeConfig::Type* HeapTypeConfig::from_bitset(Type::bitset bitset) {
-  // TODO(rossberg): Breaks the Smi abstraction. Fix once there is a better way.
-  return reinterpret_cast<Type*>(bitset);
+HeapTypeConfig::Type* HeapTypeConfig::from_bitset(int bitset) {
+  return Type::cast(i::Smi::FromInt(bitset));
 }
 
 
 // static
 i::Handle<HeapTypeConfig::Type> HeapTypeConfig::from_bitset(
-    Type::bitset bitset, Isolate* isolate) {
+    int bitset, Isolate* isolate) {
   return i::handle(from_bitset(bitset), isolate);
 }
 
 
 // static
 i::Handle<HeapTypeConfig::Type> HeapTypeConfig::from_class(
     i::Handle<i::Map> map, Isolate* isolate) {
   return i::Handle<Type>::cast(i::Handle<Object>::cast(map));
 }
 
@@ skipping 59 matching lines @@
 // static
 template<class V>
 void HeapTypeConfig::struct_set_value(
     i::Handle<Struct> structure, int i, i::Handle<V> x) {
   structure->set(i + 1, *x);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_INL_H_