[ic] Encode LoadGlobalIC's typeof mode in slot kind instead of code object's flags.

src/type-feedback-vector.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_TYPE_FEEDBACK_VECTOR_H_
 #define V8_TYPE_FEEDBACK_VECTOR_H_
 
 #include <vector>
 
 #include "src/base/logging.h"
 #include "src/elements-kind.h"
 #include "src/objects.h"
 #include "src/type-hints.h"
 #include "src/zone/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 
 enum class FeedbackVectorSlotKind {
   // This kind means that the slot points to the middle of other slot
   // which occupies more than one feedback vector element.
   // There must be no such slots in the system.
   INVALID,
 
   CALL_IC,
   LOAD_IC,
-  LOAD_GLOBAL_IC,
+  LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC,
+  LOAD_GLOBAL_INSIDE_TYPEOF_IC,
   KEYED_LOAD_IC,
   STORE_SLOPPY_IC,
   STORE_STRICT_IC,
   KEYED_STORE_SLOPPY_IC,
   KEYED_STORE_STRICT_IC,
   INTERPRETER_BINARYOP_IC,
   INTERPRETER_COMPARE_IC,
   STORE_DATA_PROPERTY_IN_LITERAL_IC,
   CREATE_CLOSURE,
   LITERAL,
   // This is a general purpose slot that occupies one feedback vector element.
   GENERAL,
 
   KINDS_NUMBER  // Last value indicating number of kinds.
 };
 
 inline bool IsCallICKind(FeedbackVectorSlotKind kind) {
   return kind == FeedbackVectorSlotKind::CALL_IC;
 }
 
 inline bool IsLoadICKind(FeedbackVectorSlotKind kind) {
   return kind == FeedbackVectorSlotKind::LOAD_IC;
 }
 
 inline bool IsLoadGlobalICKind(FeedbackVectorSlotKind kind) {
-  return kind == FeedbackVectorSlotKind::LOAD_GLOBAL_IC;
+  return kind == FeedbackVectorSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC ||
+         kind == FeedbackVectorSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC;
 }
 
 inline bool IsKeyedLoadICKind(FeedbackVectorSlotKind kind) {
   return kind == FeedbackVectorSlotKind::KEYED_LOAD_IC;
 }
 
 inline bool IsStoreICKind(FeedbackVectorSlotKind kind) {
   return kind == FeedbackVectorSlotKind::STORE_SLOPPY_IC ||
          kind == FeedbackVectorSlotKind::STORE_STRICT_IC;
 }
 
 inline bool IsKeyedStoreICKind(FeedbackVectorSlotKind kind) {
   return kind == FeedbackVectorSlotKind::KEYED_STORE_SLOPPY_IC ||
          kind == FeedbackVectorSlotKind::KEYED_STORE_STRICT_IC;
 }
 
+inline TypeofMode GetTypeofModeFromICKind(FeedbackVectorSlotKind kind) {
+  DCHECK(IsLoadGlobalICKind(kind));
+  return (kind == FeedbackVectorSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC)
+             ? INSIDE_TYPEOF
+             : NOT_INSIDE_TYPEOF;
+}
+
 inline LanguageMode GetLanguageModeFromICKind(FeedbackVectorSlotKind kind) {
   DCHECK(IsStoreICKind(kind) || IsKeyedStoreICKind(kind));
   return (kind == FeedbackVectorSlotKind::STORE_SLOPPY_IC ||
           kind == FeedbackVectorSlotKind::KEYED_STORE_SLOPPY_IC)
              ? SLOPPY
              : STRICT;
 }
 
 std::ostream& operator<<(std::ostream& os, FeedbackVectorSlotKind kind);
 
 
 template <typename Derived>
 class FeedbackVectorSpecBase {
  public:
   FeedbackVectorSlot AddCallICSlot() {
     return AddSlot(FeedbackVectorSlotKind::CALL_IC);
   }
 
   FeedbackVectorSlot AddLoadICSlot() {
     return AddSlot(FeedbackVectorSlotKind::LOAD_IC);
   }
 
-  FeedbackVectorSlot AddLoadGlobalICSlot() {
-    return AddSlot(FeedbackVectorSlotKind::LOAD_GLOBAL_IC);
+  FeedbackVectorSlot AddLoadGlobalICSlot(TypeofMode typeof_mode) {
+    return AddSlot(
+        typeof_mode == INSIDE_TYPEOF
+            ? FeedbackVectorSlotKind::LOAD_GLOBAL_INSIDE_TYPEOF_IC
+            : FeedbackVectorSlotKind::LOAD_GLOBAL_NOT_INSIDE_TYPEOF_IC);
   }
 
   FeedbackVectorSlot AddCreateClosureSlot() {
     return AddSlot(FeedbackVectorSlotKind::CREATE_CLOSURE);
   }
 
   FeedbackVectorSlot AddKeyedLoadICSlot() {
     return AddSlot(FeedbackVectorSlotKind::KEYED_LOAD_IC);
   }
 
@@ skipping 201 matching lines @@
   bool Name(FeedbackVectorSlot slot) const { return Name##Kind(GetKind(slot)); }
 
   DEFINE_SLOT_KIND_PREDICATE(IsCallIC)
   DEFINE_SLOT_KIND_PREDICATE(IsLoadIC)
   DEFINE_SLOT_KIND_PREDICATE(IsLoadGlobalIC)
   DEFINE_SLOT_KIND_PREDICATE(IsKeyedLoadIC)
   DEFINE_SLOT_KIND_PREDICATE(IsStoreIC)
   DEFINE_SLOT_KIND_PREDICATE(IsKeyedStoreIC)
 #undef DEFINE_SLOT_KIND_PREDICATE
 
+  // Returns typeof mode encoded into kind of given slot.
+  inline TypeofMode GetTypeofMode(FeedbackVectorSlot slot) const {
+    return GetTypeofModeFromICKind(GetKind(slot));
+  }
+
   // Returns language mode encoded into kind of given slot.
   inline LanguageMode GetLanguageMode(FeedbackVectorSlot slot) const {
     return GetLanguageModeFromICKind(GetKind(slot));
   }
 
 #ifdef OBJECT_PRINT
   // For gdb debugging.
   void Print();
 #endif  // OBJECT_PRINT
 
@@ skipping 12 matching lines @@
   // The object that indicates a megamorphic state.
   static inline Handle<Symbol> MegamorphicSentinel(Isolate* isolate);
 
   // The object that indicates a premonomorphic state.
   static inline Handle<Symbol> PremonomorphicSentinel(Isolate* isolate);
 
   // A raw version of the uninitialized sentinel that's safe to read during
   // garbage collection (e.g., for patching the cache).
   static inline Symbol* RawUninitializedSentinel(Isolate* isolate);
 
-  static const int kDummyLoadICSlot = 0;
-
-  static Handle<TypeFeedbackVector> DummyVector(Isolate* isolate);
-
  private:
   void ClearSlotsImpl(SharedFunctionInfo* shared, bool force_clear);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeFeedbackVector);
 };
 
 
 // The following asserts protect an optimization in type feedback vector
 // code that looks into the contents of a slot assuming to find a String,
 // a Symbol, an AllocationSite, a WeakCell, or a FixedArray.
@@ skipping 161 matching lines @@
   float ComputeCallFrequency();
 };
 
 
 class LoadICNexus : public FeedbackNexus {
  public:
   LoadICNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorSlot slot)
       : FeedbackNexus(vector, slot) {
     DCHECK(vector->IsLoadIC(slot));
   }
-  explicit LoadICNexus(Isolate* isolate)
-      : FeedbackNexus(
-            TypeFeedbackVector::DummyVector(isolate),
-            FeedbackVectorSlot(TypeFeedbackVector::kDummyLoadICSlot)) {}
   LoadICNexus(TypeFeedbackVector* vector, FeedbackVectorSlot slot)
       : FeedbackNexus(vector, slot) {
     DCHECK(vector->IsLoadIC(slot));
   }
 
   void Clear(Code* host);
 
   void ConfigureMonomorphic(Handle<Map> receiver_map, Handle<Object> handler);
 
   void ConfigurePolymorphic(MapHandleList* maps,
@@ skipping 200 matching lines @@
   InlineCacheState StateFromFeedback() const override;
 };
 
 inline BinaryOperationHint BinaryOperationHintFromFeedback(int type_feedback);
 inline CompareOperationHint CompareOperationHintFromFeedback(int type_feedback);
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TRANSITIONS_H_