[turbofan] Make TyperCache global and thread safe.

src/compiler/typer.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 "src/compiler/typer.h"
+
 #include "src/base/flags.h"
+#include "src/base/lazy-instance.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
-#include "src/compiler/typer.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-#define NATIVE_TYPES(V) \
-  V(Int8)               \
-  V(Uint8)              \
-  V(Int16)              \
-  V(Uint16)             \
-  V(Int32)              \
-  V(Uint32)             \
-  V(Float32)            \
-  V(Float64)
+class TyperCache final {
+ private:
+  // This has to be first for the initialization magic to work.
+  Zone zone_;
 
-enum LazyCachedType {
-  kInteger,
-  kWeakint,
-  kWeakintFunc1,
-  kRandomFunc0,
-  kAnyFunc0,
-  kAnyFunc1,
-  kAnyFunc2,
-  kAnyFunc3,
-  kNumberFunc0,
-  kNumberFunc1,
-  kNumberFunc2,
-  kImulFunc,
-  kClz32Func,
-  kArrayBufferFunc,
-#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
-  k##Type, k##Type##Array, k##Type##ArrayFunc,
-  TYPED_ARRAYS(TYPED_ARRAY_CASE)
-#undef TYPED_ARRAY_CASE
-      kNumLazyCachedTypes
-};
+ public:
+  TyperCache() = default;
 
+  Type* const kInt8 =
+      CreateNative(CreateRange<int8_t>(), Type::UntaggedSigned8());
+  Type* const kUint8 =
+      CreateNative(CreateRange<uint8_t>(), Type::UntaggedUnsigned8());
+  Type* const kUint8Clamped = kUint8;
+  Type* const kInt16 =
+      CreateNative(CreateRange<int16_t>(), Type::UntaggedSigned16());
+  Type* const kUint16 =
+      CreateNative(CreateRange<uint16_t>(), Type::UntaggedUnsigned16());
+  Type* const kInt32 = CreateNative(Type::Signed32(), Type::UntaggedSigned32());
+  Type* const kUint32 =
+      CreateNative(Type::Unsigned32(), Type::UntaggedUnsigned32());
+  Type* const kFloat32 = CreateNative(Type::Number(), Type::UntaggedFloat32());
+  Type* const kFloat64 = CreateNative(Type::Number(), Type::UntaggedFloat64());
 
-// Constructs and caches types lazily.
-// TODO(turbofan): these types could be globally cached or cached per isolate.
-class LazyTypeCache final : public ZoneObject {
- public:
-  explicit LazyTypeCache(Isolate* isolate, Zone* zone)
-      : isolate_(isolate), zone_(zone) {
-    memset(cache_, 0, sizeof(cache_));
-  }
+  Type* const kSingletonZero = CreateRange(0.0, 0.0);
+  Type* const kSingletonOne = CreateRange(1.0, 1.0);
+  Type* const kZeroOrOne = CreateRange(0.0, 1.0);
+  Type* const kZeroish =
+      Type::Union(kSingletonZero, Type::MinusZeroOrNaN(), zone());
+  Type* const kInteger = CreateRange(-V8_INFINITY, V8_INFINITY);
+  Type* const kWeakint = Type::Union(kInteger, Type::MinusZeroOrNaN(), zone());
+  Type* const kWeakintFunc1 = Type::Function(kWeakint, Type::Number(), zone());
 
-  V8_INLINE Type* Get(LazyCachedType type) {
-    int const index = static_cast<int>(type);
-    DCHECK_LT(index, kNumLazyCachedTypes);
-    if (cache_[index] == NULL) cache_[index] = Create(type);
-    return cache_[index];
-  }
+  Type* const kRandomFunc0 = Type::Function(Type::OrderedNumber(), zone());
+  Type* const kAnyFunc0 = Type::Function(Type::Any(), zone());
+  Type* const kAnyFunc1 = Type::Function(Type::Any(), Type::Any(), zone());
+  Type* const kAnyFunc2 =
+      Type::Function(Type::Any(), Type::Any(), Type::Any(), zone());
+  Type* const kAnyFunc3 = Type::Function(Type::Any(), Type::Any(), Type::Any(),
+                                         Type::Any(), zone());
+  Type* const kNumberFunc0 = Type::Function(Type::Number(), zone());
+  Type* const kNumberFunc1 =
+      Type::Function(Type::Number(), Type::Number(), zone());
+  Type* const kNumberFunc2 =
+      Type::Function(Type::Number(), Type::Number(), Type::Number(), zone());
+  Type* const kImulFunc = Type::Function(Type::Signed32(), Type::Integral32(),
+                                         Type::Integral32(), zone());
+  Type* const kClz32Func =
+      Type::Function(CreateRange(0, 32), Type::Number(), zone());
+  Type* const kArrayBufferFunc =
+      Type::Function(Type::Object(zone()), Type::Unsigned32(), zone());
+
+#define TYPED_ARRAY(TypeName, type_name, TYPE_NAME, ctype, size) \
+  Type* const k##TypeName##Array = CreateArray(k##TypeName);     \
+  Type* const k##TypeName##ArrayFunc = CreateArrayFunction(k##TypeName##Array);
+  TYPED_ARRAYS(TYPED_ARRAY)
+#undef TYPED_ARRAY
 
  private:
-  Type* Create(LazyCachedType type) {
-    switch (type) {
-      case kInt8:
-        return CreateNative(CreateRange<int8_t>(), Type::UntaggedSigned8());
-      case kUint8:
-        return CreateNative(CreateRange<uint8_t>(), Type::UntaggedUnsigned8());
-      case kInt16:
-        return CreateNative(CreateRange<int16_t>(), Type::UntaggedSigned16());
-      case kUint16:
-        return CreateNative(CreateRange<uint16_t>(),
-                            Type::UntaggedUnsigned16());
-      case kInt32:
-        return CreateNative(Type::Signed32(), Type::UntaggedSigned32());
-      case kUint32:
-        return CreateNative(Type::Unsigned32(), Type::UntaggedUnsigned32());
-      case kFloat32:
-        return CreateNative(Type::Number(), Type::UntaggedFloat32());
-      case kFloat64:
-        return CreateNative(Type::Number(), Type::UntaggedFloat64());
-      case kUint8Clamped:
-        return Get(kUint8);
-      case kInteger:
-        return CreateRange(-V8_INFINITY, V8_INFINITY);
-      case kWeakint:
-        return Type::Union(Get(kInteger), Type::MinusZeroOrNaN(), zone());
-      case kWeakintFunc1:
-        return Type::Function(Get(kWeakint), Type::Number(), zone());
-      case kRandomFunc0:
-        return Type::Function(Type::OrderedNumber(), zone());
-      case kAnyFunc0:
-        return Type::Function(Type::Any(), zone());
-      case kAnyFunc1:
-        return Type::Function(Type::Any(), Type::Any(), zone());
-      case kAnyFunc2:
-        return Type::Function(Type::Any(), Type::Any(), Type::Any(), zone());
-      case kAnyFunc3:
-        return Type::Function(Type::Any(), Type::Any(), Type::Any(),
-                              Type::Any(), zone());
-      case kNumberFunc0:
-        return Type::Function(Type::Number(), zone());
-      case kNumberFunc1:
-        return Type::Function(Type::Number(), Type::Number(), zone());
-      case kNumberFunc2:
-        return Type::Function(Type::Number(), Type::Number(), Type::Number(),
-                              zone());
-      case kImulFunc:
-        return Type::Function(Type::Signed32(), Type::Integral32(),
-                              Type::Integral32(), zone());
-      case kClz32Func:
-        return Type::Function(CreateRange(0, 32), Type::Number(), zone());
-      case kArrayBufferFunc:
-        return Type::Function(Type::Object(zone()), Type::Unsigned32(), zone());
-#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
-  case k##Type##Array:                                  \
-    return CreateArray(Get(k##Type));                   \
-  case k##Type##ArrayFunc:                              \
-    return CreateArrayFunction(Get(k##Type##Array));
-        TYPED_ARRAYS(TYPED_ARRAY_CASE)
-#undef TYPED_ARRAY_CASE
-      case kNumLazyCachedTypes:
-        break;
-    }
-    UNREACHABLE();
-    return NULL;
-  }
+  Type* CreateArray(Type* element) { return Type::Array(element, zone()); }
 
-  Type* CreateArray(Type* element) const {
-    return Type::Array(element, zone());
-  }
-
-  Type* CreateArrayFunction(Type* array) const {
+  Type* CreateArrayFunction(Type* array) {
     Type* arg1 = Type::Union(Type::Unsigned32(), Type::Object(), zone());
     Type* arg2 = Type::Union(Type::Unsigned32(), Type::Undefined(), zone());
     Type* arg3 = arg2;
     return Type::Function(array, arg1, arg2, arg3, zone());
   }
 
-  Type* CreateNative(Type* semantic, Type* representation) const {
+  Type* CreateNative(Type* semantic, Type* representation) {
     return Type::Intersect(semantic, representation, zone());
   }
 
   template <typename T>
-  Type* CreateRange() const {
+  Type* CreateRange() {
     return CreateRange(std::numeric_limits<T>::min(),
                        std::numeric_limits<T>::max());
   }
 
-  Type* CreateRange(double min, double max) const {
+  Type* CreateRange(double min, double max) {
     return Type::Range(min, max, zone());
   }
 
-  Factory* factory() const { return isolate()->factory(); }
-  Isolate* isolate() const { return isolate_; }
-  Zone* zone() const { return zone_; }
+  Zone* zone() { return &zone_; }
+};
 
-  Type* cache_[kNumLazyCachedTypes];
-  Isolate* isolate_;
-  Zone* zone_;
-};
+
+namespace {
+
+base::LazyInstance<TyperCache>::type kCache = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
 
 
 class Typer::Decorator final : public GraphDecorator {
  public:
   explicit Decorator(Typer* typer) : typer_(typer) {}
   void Decorate(Node* node) final;
 
  private:
-  Typer* typer_;
+  Typer* const typer_;
 };
 
 
 Typer::Typer(Isolate* isolate, Graph* graph, Type::FunctionType* function_type,
              MaybeHandle<Context> context)
     : isolate_(isolate),
       graph_(graph),
       function_type_(function_type),
       context_(context),
-      decorator_(NULL),
-      cache_(new (graph->zone()) LazyTypeCache(isolate, graph->zone())) {
+      decorator_(nullptr),
+      cache_(kCache.Get()) {
   Zone* zone = this->zone();
   Factory* const factory = isolate->factory();
 
   Type* infinity = Type::Constant(factory->infinity_value(), zone);
   Type* minus_infinity = Type::Constant(factory->minus_infinity_value(), zone);
   Type* truncating_to_zero =
       Type::Union(Type::Union(infinity, minus_infinity, zone),
                   Type::MinusZeroOrNaN(), zone);
 
   singleton_false_ = Type::Constant(factory->false_value(), zone);
   singleton_true_ = Type::Constant(factory->true_value(), zone);
-  singleton_zero_ = Type::Range(0.0, 0.0, zone);
-  singleton_one_ = Type::Range(1.0, 1.0, zone);
-  zero_or_one_ = Type::Range(0.0, 1.0, zone);
-  zeroish_ = Type::Union(singleton_zero_, Type::MinusZeroOrNaN(), zone);
   signed32ish_ = Type::Union(Type::Signed32(), truncating_to_zero, zone);
   unsigned32ish_ = Type::Union(Type::Unsigned32(), truncating_to_zero, zone);
-  falsish_ =
-      Type::Union(Type::Undetectable(),
-                  Type::Union(Type::Union(singleton_false_, zeroish_, zone),
-                              Type::NullOrUndefined(), zone),
-                  zone);
+  falsish_ = Type::Union(
+      Type::Undetectable(),
+      Type::Union(Type::Union(singleton_false_, cache_.kZeroish, zone),
+                  Type::NullOrUndefined(), zone),
+      zone);
   truish_ = Type::Union(
       singleton_true_,
       Type::Union(Type::DetectableReceiver(), Type::Symbol(), zone), zone);
 
   decorator_ = new (zone) Decorator(this);
   graph_->AddDecorator(decorator_);
 }
 
 
 Typer::~Typer() {
@@ skipping 301 matching lines @@
                                             : t->singleton_false_;
   }
   // Type should be non empty, so we know it should be true.
   DCHECK((outcome & kComparisonTrue) != 0);
   return t->singleton_true_;
 }
 
 
 Type* Typer::Visitor::Rangify(Type* type, Typer* t) {
   if (type->IsRange()) return type;        // Shortcut.
-  if (!type->Is(t->cache_->Get(kInteger))) {
+  if (!type->Is(t->cache_.kInteger)) {
     return type;  // Give up on non-integer types.
   }
   double min = type->Min();
   double max = type->Max();
   // Handle the degenerate case of empty bitset types (such as
   // OtherUnsigned31 and OtherSigned32 on 64-bit architectures).
   if (std::isnan(min)) {
     DCHECK(std::isnan(max));
     return type;
   }
@@ skipping 19 matching lines @@
   if (type->Is(Type::PlainNumber()) && (type->Max() < 0 || 0 < type->Min())) {
     return t->singleton_true_;  // Ruled out nan, -0 and +0.
   }
   return Type::Boolean();
 }
 
 
 Type* Typer::Visitor::ToNumber(Type* type, Typer* t) {
   if (type->Is(Type::Number())) return type;
   if (type->Is(Type::NullOrUndefined())) {
-    if (type->Is(Type::Null())) return t->singleton_zero_;
+    if (type->Is(Type::Null())) return t->cache_.kSingletonZero;
     if (type->Is(Type::Undefined())) return Type::NaN();
-    return Type::Union(Type::NaN(), t->singleton_zero_, t->zone());
+    return Type::Union(Type::NaN(), t->cache_.kSingletonZero, t->zone());
   }
   if (type->Is(Type::NumberOrUndefined())) {
     return Type::Union(Type::Intersect(type, Type::Number(), t->zone()),
                        Type::NaN(), t->zone());
   }
-  if (type->Is(t->singleton_false_)) return t->singleton_zero_;
-  if (type->Is(t->singleton_true_)) return t->singleton_one_;
-  if (type->Is(Type::Boolean())) return t->zero_or_one_;
+  if (type->Is(t->singleton_false_)) return t->cache_.kSingletonZero;
+  if (type->Is(t->singleton_true_)) return t->cache_.kSingletonOne;
+  if (type->Is(Type::Boolean())) return t->cache_.kZeroOrOne;
   if (type->Is(Type::BooleanOrNumber())) {
     return Type::Union(Type::Intersect(type, Type::Number(), t->zone()),
-                       t->zero_or_one_, t->zone());
+                       t->cache_.kZeroOrOne, t->zone());
   }
   return Type::Number();
 }
 
 
 Type* Typer::Visitor::ToString(Type* type, Typer* t) {
   if (type->Is(Type::String())) return type;
   return Type::String();
 }
 
 
 Type* Typer::Visitor::NumberToInt32(Type* type, Typer* t) {
   // TODO(neis): DCHECK(type->Is(Type::Number()));
   if (type->Is(Type::Signed32())) return type;
-  if (type->Is(t->zeroish_)) return t->singleton_zero_;
+  if (type->Is(t->cache_.kZeroish)) return t->cache_.kSingletonZero;
   if (type->Is(t->signed32ish_)) {
-    return Type::Intersect(Type::Union(type, t->singleton_zero_, t->zone()),
-                           Type::Signed32(), t->zone());
+    return Type::Intersect(
+        Type::Union(type, t->cache_.kSingletonZero, t->zone()),
+        Type::Signed32(), t->zone());
   }
   return Type::Signed32();
 }
 
 
 Type* Typer::Visitor::NumberToUint32(Type* type, Typer* t) {
   // TODO(neis): DCHECK(type->Is(Type::Number()));
   if (type->Is(Type::Unsigned32())) return type;
-  if (type->Is(t->zeroish_)) return t->singleton_zero_;
+  if (type->Is(t->cache_.kZeroish)) return t->cache_.kSingletonZero;
   if (type->Is(t->unsigned32ish_)) {
-    return Type::Intersect(Type::Union(type, t->singleton_zero_, t->zone()),
-                           Type::Unsigned32(), t->zone());
+    return Type::Intersect(
+        Type::Union(type, t->cache_.kSingletonZero, t->zone()),
+        Type::Unsigned32(), t->zone());
   }
   return Type::Unsigned32();
 }
 
 
 // -----------------------------------------------------------------------------
 
 
 // Control operators.
 
@@ skipping 534 matching lines @@
   double rmin = rhs->Min();
   double rmax = rhs->Max();
   results[0] = lmin * rmin;
   results[1] = lmin * rmax;
   results[2] = lmax * rmin;
   results[3] = lmax * rmax;
   // If the result may be nan, we give up on calculating a precise type, because
   // the discontinuity makes it too complicated.  Note that even if none of the
   // "results" above is nan, the actual result may still be, so we have to do a
   // different check:
-  bool maybe_nan = (lhs->Maybe(t->singleton_zero_) &&
+  bool maybe_nan = (lhs->Maybe(t->cache_.kSingletonZero) &&
                     (rmin == -V8_INFINITY || rmax == +V8_INFINITY)) ||
-                   (rhs->Maybe(t->singleton_zero_) &&
+                   (rhs->Maybe(t->cache_.kSingletonZero) &&
                     (lmin == -V8_INFINITY || lmax == +V8_INFINITY));
-  if (maybe_nan) return t->cache_->Get(kWeakint);  // Giving up.
-  bool maybe_minuszero = (lhs->Maybe(t->singleton_zero_) && rmin < 0) ||
-                         (rhs->Maybe(t->singleton_zero_) && lmin < 0);
+  if (maybe_nan) return t->cache_.kWeakint;  // Giving up.
+  bool maybe_minuszero = (lhs->Maybe(t->cache_.kSingletonZero) && rmin < 0) ||
+                         (rhs->Maybe(t->cache_.kSingletonZero) && lmin < 0);
   Type* range =
       Type::Range(array_min(results, 4), array_max(results, 4), t->zone());
   return maybe_minuszero ? Type::Union(range, Type::MinusZero(), t->zone())
                          : range;
 }
 
 
 Type* Typer::Visitor::JSMultiplyTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = Rangify(ToNumber(lhs, t), t);
   rhs = Rangify(ToNumber(rhs, t), t);
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
   if (lhs->IsRange() && rhs->IsRange()) {
     return JSMultiplyRanger(lhs->AsRange(), rhs->AsRange(), t);
   }
   return Type::Number();
 }
 
 
 Type* Typer::Visitor::JSDivideTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = ToNumber(lhs, t);
   rhs = ToNumber(rhs, t);
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
   // Division is tricky, so all we do is try ruling out nan.
   // TODO(neis): try ruling out -0 as well?
   bool maybe_nan =
-      lhs->Maybe(Type::NaN()) || rhs->Maybe(t->zeroish_) ||
+      lhs->Maybe(Type::NaN()) || rhs->Maybe(t->cache_.kZeroish) ||
       ((lhs->Min() == -V8_INFINITY || lhs->Max() == +V8_INFINITY) &&
        (rhs->Min() == -V8_INFINITY || rhs->Max() == +V8_INFINITY));
   return maybe_nan ? Type::Number() : Type::OrderedNumber();
 }
 
 
 Type* Typer::Visitor::JSModulusRanger(Type::RangeType* lhs,
                                       Type::RangeType* rhs, Typer* t) {
   double lmin = lhs->Min();
   double lmax = lhs->Max();
@@ skipping 24 matching lines @@
     result = Type::Union(result, Type::MinusZero(), t->zone());
   return result;
 }
 
 
 Type* Typer::Visitor::JSModulusTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = ToNumber(lhs, t);
   rhs = ToNumber(rhs, t);
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
 
-  if (lhs->Maybe(Type::NaN()) || rhs->Maybe(t->zeroish_) ||
+  if (lhs->Maybe(Type::NaN()) || rhs->Maybe(t->cache_.kZeroish) ||
       lhs->Min() == -V8_INFINITY || lhs->Max() == +V8_INFINITY) {
     // Result maybe NaN.
     return Type::Number();
   }
 
   lhs = Rangify(lhs, t);
   rhs = Rangify(rhs, t);
   if (lhs->IsRange() && rhs->IsRange()) {
     return JSModulusRanger(lhs->AsRange(), rhs->AsRange(), t);
   }
@@ skipping 112 matching lines @@
   static const double kWeakenMaxLimits[] = {
       0.0, 1073741823.0, 2147483647.0, 4294967295.0, 8589934591.0,
       17179869183.0, 34359738367.0, 68719476735.0, 137438953471.0,
       274877906943.0, 549755813887.0, 1099511627775.0, 2199023255551.0,
       4398046511103.0, 8796093022207.0, 17592186044415.0, 35184372088831.0,
       70368744177663.0, 140737488355327.0, 281474976710655.0,
       562949953421311.0};
   STATIC_ASSERT(arraysize(kWeakenMinLimits) == arraysize(kWeakenMaxLimits));
 
   // If the types have nothing to do with integers, return the types.
-  Type* const integer = typer_->cache_->Get(kInteger);
+  Type* const integer = typer_->cache_.kInteger;
   if (!previous_type->Maybe(integer)) {
     return current_type;
   }
   DCHECK(current_type->Maybe(integer));
 
   Type* current_integer = Type::Intersect(current_type, integer, zone());
   Type* previous_integer = Type::Intersect(previous_type, integer, zone());
 
   // Once we start weakening a node, we should always weaken.
   if (!IsWeakened(node->id())) {
@@ skipping 443 matching lines @@
   return Bounds(FieldAccessOf(node->op()).type);
 }
 
 
 Bounds Typer::Visitor::TypeLoadBuffer(Node* node) {
   // TODO(bmeurer): This typing is not yet correct. Since we can still access
   // out of bounds, the type in the general case has to include Undefined.
   switch (BufferAccessOf(node->op()).external_array_type()) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case kExternal##Type##Array:                          \
-    return Bounds(typer_->cache_->Get(k##Type));
+    return Bounds(typer_->cache_.k##Type);
     TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
   }
   UNREACHABLE();
   return Bounds();
 }
 
 
 Bounds Typer::Visitor::TypeLoadElement(Node* node) {
   return Bounds(ElementAccessOf(node->op()).type);
@@ skipping 486 matching lines @@
 
 
 // Heap constants.
 
 
 Type* Typer::Visitor::TypeConstant(Handle<Object> value) {
   if (value->IsJSFunction()) {
     if (JSFunction::cast(*value)->shared()->HasBuiltinFunctionId()) {
       switch (JSFunction::cast(*value)->shared()->builtin_function_id()) {
         case kMathRandom:
-          return typer_->cache_->Get(kRandomFunc0);
+          return typer_->cache_.kRandomFunc0;
         case kMathFloor:
         case kMathRound:
         case kMathCeil:
-          return typer_->cache_->Get(kWeakintFunc1);
+          return typer_->cache_.kWeakintFunc1;
         // Unary math functions.
         case kMathAbs:  // TODO(rossberg): can't express overloading
         case kMathLog:
         case kMathExp:
         case kMathSqrt:
         case kMathCos:
         case kMathSin:
         case kMathTan:
         case kMathAcos:
         case kMathAsin:
         case kMathAtan:
         case kMathFround:
-          return typer_->cache_->Get(kNumberFunc1);
+          return typer_->cache_.kNumberFunc1;
         // Binary math functions.
         case kMathAtan2:
         case kMathPow:
         case kMathMax:
         case kMathMin:
-          return typer_->cache_->Get(kNumberFunc2);
+          return typer_->cache_.kNumberFunc2;
         case kMathImul:
-          return typer_->cache_->Get(kImulFunc);
+          return typer_->cache_.kImulFunc;
         case kMathClz32:
-          return typer_->cache_->Get(kClz32Func);
+          return typer_->cache_.kClz32Func;
         default:
           break;
       }
     } else if (JSFunction::cast(*value)->IsBuiltin() && !context().is_null()) {
       Handle<Context> native =
           handle(context().ToHandleChecked()->native_context(), isolate());
       if (*value == native->array_buffer_fun()) {
-        return typer_->cache_->Get(kArrayBufferFunc);
+        return typer_->cache_.kArrayBufferFunc;
       } else if (*value == native->int8_array_fun()) {
-        return typer_->cache_->Get(kInt8ArrayFunc);
+        return typer_->cache_.kInt8ArrayFunc;
       } else if (*value == native->int16_array_fun()) {
-        return typer_->cache_->Get(kInt16ArrayFunc);
+        return typer_->cache_.kInt16ArrayFunc;
       } else if (*value == native->int32_array_fun()) {
-        return typer_->cache_->Get(kInt32ArrayFunc);
+        return typer_->cache_.kInt32ArrayFunc;
       } else if (*value == native->uint8_array_fun()) {
-        return typer_->cache_->Get(kUint8ArrayFunc);
+        return typer_->cache_.kUint8ArrayFunc;
       } else if (*value == native->uint16_array_fun()) {
-        return typer_->cache_->Get(kUint16ArrayFunc);
+        return typer_->cache_.kUint16ArrayFunc;
       } else if (*value == native->uint32_array_fun()) {
-        return typer_->cache_->Get(kUint32ArrayFunc);
+        return typer_->cache_.kUint32ArrayFunc;
       } else if (*value == native->float32_array_fun()) {
-        return typer_->cache_->Get(kFloat32ArrayFunc);
+        return typer_->cache_.kFloat32ArrayFunc;
       } else if (*value == native->float64_array_fun()) {
-        return typer_->cache_->Get(kFloat64ArrayFunc);
+        return typer_->cache_.kFloat64ArrayFunc;
       }
     }
     int const arity =
         JSFunction::cast(*value)->shared()->internal_formal_parameter_count();
     switch (arity) {
       case SharedFunctionInfo::kDontAdaptArgumentsSentinel:
         // Some smart optimization at work... &%$!&@+$!
         return Type::Any(zone());
       case 0:
-        return typer_->cache_->Get(kAnyFunc0);
+        return typer_->cache_.kAnyFunc0;
       case 1:
-        return typer_->cache_->Get(kAnyFunc1);
+        return typer_->cache_.kAnyFunc1;
       case 2:
-        return typer_->cache_->Get(kAnyFunc2);
+        return typer_->cache_.kAnyFunc2;
       case 3:
-        return typer_->cache_->Get(kAnyFunc3);
+        return typer_->cache_.kAnyFunc3;
       default: {
         DCHECK_LT(3, arity);
         Type** const params = zone()->NewArray<Type*>(arity);
         std::fill(&params[0], &params[arity], Type::Any(zone()));
         return Type::Function(Type::Any(zone()), arity, params, zone());
       }
     }
   } else if (value->IsJSTypedArray()) {
     switch (JSTypedArray::cast(*value)->type()) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case kExternal##Type##Array:                          \
-    return typer_->cache_->Get(k##Type##Array);
+    return typer_->cache_.k##Type##Array;
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8