Revert "[turbofan] Remove the representation dimension from Type."

src/compiler/types.cc

 // 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.
 
 #include <iomanip>
 
 #include "src/compiler/types.h"
 
 #include "src/handles-inl.h"
 #include "src/ostreams.h"
@@ skipping 101 matching lines @@
   // Fast case.
   if (IsBitset(type)) {
     return type->AsBitset();
   } else if (type->IsUnion()) {
     SLOW_DCHECK(type->AsUnion()->Wellformed());
     return type->AsUnion()->Get(0)->BitsetGlb() |
            SEMANTIC(type->AsUnion()->Get(1)->BitsetGlb());  // Shortcut.
   } else if (type->IsRange()) {
     bitset glb = SEMANTIC(
         BitsetType::Glb(type->AsRange()->Min(), type->AsRange()->Max()));
-    return glb;
+    return glb | REPRESENTATION(type->BitsetLub());
   } else {
-    return kNone;
+    return type->Representation();
   }
 }
 
 // The smallest bitset subsuming this type, possibly not a proper one.
 Type::bitset BitsetType::Lub(Type* type) {
   DisallowHeapAllocation no_allocation;
   if (IsBitset(type)) return type->AsBitset();
   if (type->IsUnion()) {
     // Take the representation from the first element, which is always
     // a bitset.
@@ skipping 43 matching lines @@
       if (map == heap->undefined_map()) return kUndefined;
       if (map == heap->null_map()) return kNull;
       if (map == heap->boolean_map()) return kBoolean;
       if (map == heap->the_hole_map()) return kHole;
       DCHECK(map == heap->uninitialized_map() ||
              map == heap->no_interceptor_result_sentinel_map() ||
              map == heap->termination_exception_map() ||
              map == heap->arguments_marker_map() ||
              map == heap->optimized_out_map() ||
              map == heap->stale_register_map());
-      return kOtherInternal;
+      return kOtherInternal & kTaggedPointer;
     }
     case HEAP_NUMBER_TYPE:
-      return kNumber;
+      return kNumber & kTaggedPointer;
     case SIMD128_VALUE_TYPE:
       return kSimd;
     case JS_OBJECT_TYPE:
     case JS_ARGUMENTS_TYPE:
     case JS_ERROR_TYPE:
     case JS_GLOBAL_OBJECT_TYPE:
     case JS_GLOBAL_PROXY_TYPE:
     case JS_API_OBJECT_TYPE:
     case JS_SPECIAL_API_OBJECT_TYPE:
       if (map->is_undetectable()) return kOtherUndetectable;
@@ skipping 33 matching lines @@
     case FIXED_ARRAY_TYPE:
     case FIXED_DOUBLE_ARRAY_TYPE:
     case BYTE_ARRAY_TYPE:
     case BYTECODE_ARRAY_TYPE:
     case TRANSITION_ARRAY_TYPE:
     case FOREIGN_TYPE:
     case SCRIPT_TYPE:
     case CODE_TYPE:
     case PROPERTY_CELL_TYPE:
     case MODULE_TYPE:
-      return kOtherInternal;
+      return kOtherInternal & kTaggedPointer;
 
     // Remaining instance types are unsupported for now. If any of them do
-    // require bit set types, they should get kOtherInternal.
+    // require bit set types, they should get kOtherInternal & kTaggedPointer.
     case MUTABLE_HEAP_NUMBER_TYPE:
     case FREE_SPACE_TYPE:
 #define FIXED_TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case FIXED_##TYPE##_ARRAY_TYPE:
 
       TYPED_ARRAYS(FIXED_TYPED_ARRAY_CASE)
 #undef FIXED_TYPED_ARRAY_CASE
     case FILLER_TYPE:
     case ACCESS_CHECK_INFO_TYPE:
     case INTERCEPTOR_INFO_TYPE:
@@ skipping 16 matching lines @@
       UNREACHABLE();
       return kNone;
   }
   UNREACHABLE();
   return kNone;
 }
 
 Type::bitset BitsetType::Lub(i::Object* value) {
   DisallowHeapAllocation no_allocation;
   if (value->IsNumber()) {
-    return Lub(value->Number());
+    return Lub(value->Number()) &
+           (value->IsSmi() ? kTaggedSigned : kTaggedPointer);
   }
   return Lub(i::HeapObject::cast(value)->map());
 }
 
 Type::bitset BitsetType::Lub(double value) {
   DisallowHeapAllocation no_allocation;
   if (i::IsMinusZero(value)) return kMinusZero;
   if (std::isnan(value)) return kNaN;
   if (IsUint32Double(value) || IsInt32Double(value)) return Lub(value, value);
   return kOtherNumber;
@@ skipping 115 matching lines @@
     }
     for (int i = 0, n = this_tuple->Arity(); i < n; ++i) {
       if (!this_tuple->Element(i)->Equals(that_tuple->Element(i))) return false;
     }
     return true;
   }
   UNREACHABLE();
   return false;
 }
 
+Type::bitset Type::Representation() {
+  return REPRESENTATION(this->BitsetLub());
+}
+
 // Check if [this] <= [that].
 bool Type::SlowIs(Type* that) {
   DisallowHeapAllocation no_allocation;
 
   // Fast bitset cases
   if (that->IsBitset()) {
     return BitsetType::Is(this->BitsetLub(), that->AsBitset());
   }
 
   if (this->IsBitset()) {
     return BitsetType::Is(this->AsBitset(), that->BitsetGlb());
   }
 
+  // Check the representations.
+  if (!BitsetType::Is(Representation(), that->Representation())) {
+    return false;
+  }
+
   // Check the semantic part.
   return SemanticIs(that);
 }
 
 // Check if SEMANTIC([this]) <= SEMANTIC([that]). The result of the method
 // should be independent of the representation axis of the types.
 bool Type::SemanticIs(Type* that) {
   DisallowHeapAllocation no_allocation;
 
   if (this == that) return true;
@@ skipping 161 matching lines @@
   // Fast case: top or bottom types.
   if (type1->IsNone() || type2->IsAny()) return type1;  // Shortcut.
   if (type2->IsNone() || type1->IsAny()) return type2;  // Shortcut.
 
   // Semi-fast case.
   if (type1->Is(type2)) return type1;
   if (type2->Is(type1)) return type2;
 
   // Slow case: create union.
 
+  // Figure out the representation of the result first.
+  // The rest of the method should not change this representation and
+  // it should not make any decisions based on representations (i.e.,
+  // it should only use the semantic part of types).
+  const bitset representation =
+      type1->Representation() & type2->Representation();
+
   // Semantic subtyping check - this is needed for consistency with the
-  // semi-fast case above.
+  // semi-fast case above - we should behave the same way regardless of
+  // representations. Intersection with a universal bitset should only update
+  // the representations.
   if (type1->SemanticIs(type2)) {
     type2 = Any();
   } else if (type2->SemanticIs(type1)) {
     type1 = Any();
   }
 
-  bitset bits = SEMANTIC(type1->BitsetGlb() & type2->BitsetGlb());
+  bitset bits =
+      SEMANTIC(type1->BitsetGlb() & type2->BitsetGlb()) | representation;
   int size1 = type1->IsUnion() ? type1->AsUnion()->Length() : 1;
   int size2 = type2->IsUnion() ? type2->AsUnion()->Length() : 1;
   if (!AddIsSafe(size1, size2)) return Any();
   int size = size1 + size2;
   if (!AddIsSafe(size, 2)) return Any();
   size += 2;
   Type* result_type = UnionType::New(size, zone);
   UnionType* result = result_type->AsUnion();
   size = 0;
 
   // Deal with bitsets.
   result->Set(size++, BitsetType::New(bits));
 
   RangeType::Limits lims = RangeType::Limits::Empty();
   size = IntersectAux(type1, type2, result, size, &lims, zone);
 
   // If the range is not empty, then insert it into the union and
   // remove the number bits from the bitset.
   if (!lims.IsEmpty()) {
-    size = UpdateRange(RangeType::New(lims, zone), result, size, zone);
+    size = UpdateRange(RangeType::New(lims, representation, zone), result, size,
+                       zone);
 
     // Remove the number bits.
     bitset number_bits = BitsetType::NumberBits(bits);
     bits &= ~number_bits;
     result->Set(0, BitsetType::New(bits));
   }
   return NormalizeUnion(result_type, size, zone);
 }
 
 int Type::UpdateRange(Type* range, UnionType* result, int size, Zone* zone) {
@@ skipping 124 matching lines @@
     // Bitset is contained within the range, just return the range.
     return range;
   }
 
   if (bitset_min < range_min) {
     range_min = bitset_min;
   }
   if (bitset_max > range_max) {
     range_max = bitset_max;
   }
-  return RangeType::New(range_min, range_max, zone);
+  return RangeType::New(range_min, range_max, BitsetType::kNone, zone);
 }
 
 Type* Type::Union(Type* type1, Type* type2, Zone* zone) {
   // Fast case: bit sets.
   if (type1->IsBitset() && type2->IsBitset()) {
     return BitsetType::New(type1->AsBitset() | type2->AsBitset());
   }
 
   // Fast case: top or bottom types.
   if (type1->IsAny() || type2->IsNone()) return type1;
   if (type2->IsAny() || type1->IsNone()) return type2;
 
   // Semi-fast case.
   if (type1->Is(type2)) return type2;
   if (type2->Is(type1)) return type1;
 
+  // Figure out the representation of the result.
+  // The rest of the method should not change this representation and
+  // it should not make any decisions based on representations (i.e.,
+  // it should only use the semantic part of types).
+  const bitset representation =
+      type1->Representation() | type2->Representation();
+
   // Slow case: create union.
   int size1 = type1->IsUnion() ? type1->AsUnion()->Length() : 1;
   int size2 = type2->IsUnion() ? type2->AsUnion()->Length() : 1;
   if (!AddIsSafe(size1, size2)) return Any();
   int size = size1 + size2;
   if (!AddIsSafe(size, 2)) return Any();
   size += 2;
   Type* result_type = UnionType::New(size, zone);
   UnionType* result = result_type->AsUnion();
   size = 0;
 
   // Compute the new bitset.
   bitset new_bitset = SEMANTIC(type1->BitsetGlb() | type2->BitsetGlb());
 
   // Deal with ranges.
   Type* range = None();
   Type* range1 = type1->GetRange();
   Type* range2 = type2->GetRange();
   if (range1 != NULL && range2 != NULL) {
     RangeType::Limits lims =
         RangeType::Limits::Union(RangeType::Limits(range1->AsRange()),
                                  RangeType::Limits(range2->AsRange()));
-    Type* union_range = RangeType::New(lims, zone);
+    Type* union_range = RangeType::New(lims, representation, zone);
     range = NormalizeRangeAndBitset(union_range, &new_bitset, zone);
   } else if (range1 != NULL) {
     range = NormalizeRangeAndBitset(range1, &new_bitset, zone);
   } else if (range2 != NULL) {
     range = NormalizeRangeAndBitset(range2, &new_bitset, zone);
   }
-  new_bitset = SEMANTIC(new_bitset);
+  new_bitset = SEMANTIC(new_bitset) | representation;
   Type* bits = BitsetType::New(new_bitset);
   result->Set(size++, bits);
   if (!range->IsNone()) result->Set(size++, range);
 
   size = AddToUnion(type1, result, size, zone);
   size = AddToUnion(type2, result, size, zone);
   return NormalizeUnion(result_type, size, zone);
 }
 
 // Add [type] to [result] unless [type] is bitset, range, or already subsumed.
@@ skipping 17 matching lines @@
   UnionType* unioned = union_type->AsUnion();
   DCHECK(size >= 1);
   DCHECK(unioned->Get(0)->IsBitset());
   // If the union has just one element, return it.
   if (size == 1) {
     return unioned->Get(0);
   }
   bitset bits = unioned->Get(0)->AsBitset();
   // If the union only consists of a range, we can get rid of the union.
   if (size == 2 && SEMANTIC(bits) == BitsetType::kNone) {
+    bitset representation = REPRESENTATION(bits);
+    if (representation == unioned->Get(1)->Representation()) {
+      return unioned->Get(1);
+    }
     if (unioned->Get(1)->IsRange()) {
       return RangeType::New(unioned->Get(1)->AsRange()->Min(),
-                            unioned->Get(1)->AsRange()->Max(), zone);
+                            unioned->Get(1)->AsRange()->Max(),
+                            unioned->Get(0)->AsBitset(), zone);
     }
   }
   unioned->Shrink(size);
   SLOW_DCHECK(unioned->Wellformed());
   return union_type;
 }
 
 // -----------------------------------------------------------------------------
 // Component extraction
 
 // static
+Type* Type::Representation(Type* t, Zone* zone) {
+  return BitsetType::New(t->Representation());
+}
+
+// static
 Type* Type::Semantic(Type* t, Zone* zone) {
   return Intersect(t, BitsetType::New(BitsetType::kSemantic), zone);
 }
 
 // -----------------------------------------------------------------------------
 // Iteration.
 
 int Type::NumConstants() {
   DisallowHeapAllocation no_allocation;
   if (this->IsConstant()) {
@@ skipping 53 matching lines @@
     return;
   }
   index_ = -1;
 }
 
 // -----------------------------------------------------------------------------
 // Printing.
 
 const char* BitsetType::Name(bitset bits) {
   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)
     INTERNAL_BITSET_TYPE_LIST(RETURN_NAMED_SEMANTIC_TYPE)
 #undef RETURN_NAMED_SEMANTIC_TYPE
 
     default:
       return NULL;
   }
 }
 
 void BitsetType::Print(std::ostream& os,  // NOLINT
                        bitset bits) {
   DisallowHeapAllocation no_allocation;
   const char* name = Name(bits);
   if (name != NULL) {
     os << name;
     return;
   }
 
   // clang-format off
   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),
     INTERNAL_BITSET_TYPE_LIST(BITSET_CONSTANT)
     SEMANTIC_BITSET_TYPE_LIST(BITSET_CONSTANT)
 #undef BITSET_CONSTANT
   };
   // clang-format on
 
   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 << ")";
 }
 
-void Type::PrintTo(std::ostream& os) {
+void Type::PrintTo(std::ostream& os, PrintDimension dim) {
   DisallowHeapAllocation no_allocation;
-  if (this->IsBitset()) {
-    BitsetType::Print(os, SEMANTIC(this->AsBitset()));
-  } else if (this->IsConstant()) {
-    os << "Constant(" << Brief(*this->AsConstant()->Value()) << ")";
-  } else if (this->IsRange()) {
-    std::ostream::fmtflags saved_flags = os.setf(std::ios::fixed);
-    std::streamsize saved_precision = os.precision(0);
-    os << "Range(" << this->AsRange()->Min() << ", " << this->AsRange()->Max()
-       << ")";
-    os.flags(saved_flags);
-    os.precision(saved_precision);
-  } else if (this->IsUnion()) {
-    os << "(";
-    for (int i = 0, n = this->AsUnion()->Length(); i < n; ++i) {
-      Type* type_i = this->AsUnion()->Get(i);
-      if (i > 0) os << " | ";
-      type_i->PrintTo(os);
+  if (dim != REPRESENTATION_DIM) {
+    if (this->IsBitset()) {
+      BitsetType::Print(os, SEMANTIC(this->AsBitset()));
+    } else if (this->IsConstant()) {
+      os << "Constant(" << Brief(*this->AsConstant()->Value()) << ")";
+    } else if (this->IsRange()) {
+      std::ostream::fmtflags saved_flags = os.setf(std::ios::fixed);
+      std::streamsize saved_precision = os.precision(0);
+      os << "Range(" << this->AsRange()->Min() << ", " << this->AsRange()->Max()
+         << ")";
+      os.flags(saved_flags);
+      os.precision(saved_precision);
+    } else if (this->IsUnion()) {
+      os << "(";
+      for (int i = 0, n = this->AsUnion()->Length(); i < n; ++i) {
+        Type* type_i = this->AsUnion()->Get(i);
+        if (i > 0) os << " | ";
+        type_i->PrintTo(os, dim);
+      }
+      os << ")";
+    } else if (this->IsTuple()) {
+      os << "<";
+      for (int i = 0, n = this->AsTuple()->Arity(); i < n; ++i) {
+        Type* type_i = this->AsTuple()->Element(i);
+        if (i > 0) os << ", ";
+        type_i->PrintTo(os, dim);
+      }
+      os << ">";
+    } else {
+      UNREACHABLE();
     }
-    os << ")";
-  } else if (this->IsTuple()) {
-    os << "<";
-    for (int i = 0, n = this->AsTuple()->Arity(); i < n; ++i) {
-      Type* type_i = this->AsTuple()->Element(i);
-      if (i > 0) os << ", ";
-      type_i->PrintTo(os);
-    }
-    os << ">";
-  } else {
-    UNREACHABLE();
+  }
+  if (dim == BOTH_DIMS) os << "/";
+  if (dim != SEMANTIC_DIM) {
+    BitsetType::Print(os, REPRESENTATION(this->BitsetLub()));
   }
 }
 
 #ifdef DEBUG
 void Type::Print() {
   OFStream os(stdout);
   PrintTo(os);
   os << std::endl;
 }
 void BitsetType::Print(bitset bits) {
@@ skipping 12 matching lines @@
 }
 
 // -----------------------------------------------------------------------------
 // Instantiations.
 
 template class Type::Iterator<i::Object>;
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8