[builtins] Turn StoreIC_Miss and StoreIC_Slow builtins to TurboFan code stubs.

This CL also combines Runtime::GetGlobalInsideTypeof and Runtime::kGetGlobalNotInsideTypeof
to Runtime::GetGlobal with explicit typeof_mode parameter.

Drive-by-fix: tail call to correct Slow builtin from LoadCallback handlers when --runtime-call-stats is on.

BUG=chromium:576312

Review-Url: https://codereview.chromium.org/2144643004
Cr-Commit-Position: refs/heads/master@{#37710}

src/builtins.cc

@@ -6145,26 +6145,24 @@ void Generate_LoadIC_Slow(CodeStubAssembler* assembler) {
   assembler->TailCallRuntime(Runtime::kGetProperty, context, receiver, name);
 }
 
-void Generate_LoadGlobalIC_SlowInsideTypeof(CodeStubAssembler* assembler) {
+void Generate_LoadGlobalIC_Slow(CodeStubAssembler* assembler, TypeofMode mode) {
   typedef compiler::Node Node;
 
   Node* slot = assembler->Parameter(0);
   Node* vector = assembler->Parameter(1);
   Node* context = assembler->Parameter(2);
+  Node* typeof_mode = assembler->SmiConstant(Smi::FromInt(mode));
 
-  assembler->TailCallRuntime(Runtime::kGetGlobalInsideTypeof, context, slot,
-                             vector);
+  assembler->TailCallRuntime(Runtime::kGetGlobal, context, slot, vector,
+                             typeof_mode);
 }
 
-void Generate_LoadGlobalIC_SlowNotInsideTypeof(CodeStubAssembler* assembler) {
-  typedef compiler::Node Node;
-
-  Node* slot = assembler->Parameter(0);
-  Node* vector = assembler->Parameter(1);
-  Node* context = assembler->Parameter(2);
+void Generate_LoadGlobalIC_SlowInsideTypeof(CodeStubAssembler* assembler) {
+  Generate_LoadGlobalIC_Slow(assembler, INSIDE_TYPEOF);
+}
 
-  assembler->TailCallRuntime(Runtime::kGetGlobalNotInsideTypeof, context, slot,
-                             vector);
+void Generate_LoadGlobalIC_SlowNotInsideTypeof(CodeStubAssembler* assembler) {
+  Generate_LoadGlobalIC_Slow(assembler, NOT_INSIDE_TYPEOF);
 }
 
 void Generate_KeyedLoadIC_Slow(MacroAssembler* masm) {
@@ -6179,16 +6177,48 @@ void Generate_KeyedLoadIC_Megamorphic(MacroAssembler* masm) {
   KeyedLoadIC::GenerateMegamorphic(masm);
 }
 
-void Generate_StoreIC_Miss(MacroAssembler* masm) {
-  StoreIC::GenerateMiss(masm);
+void Generate_StoreIC_Miss(CodeStubAssembler* assembler) {
+  typedef compiler::Node Node;
+
+  Node* receiver = assembler->Parameter(0);
+  Node* name = assembler->Parameter(1);
+  Node* value = assembler->Parameter(2);
+  Node* slot = assembler->Parameter(3);
+  Node* vector = assembler->Parameter(4);
+  Node* context = assembler->Parameter(5);
+
+  assembler->TailCallRuntime(Runtime::kStoreIC_Miss, context, receiver, name,
+                             value, slot, vector);
 }
 
 void Generate_StoreIC_Normal(MacroAssembler* masm) {
   StoreIC::GenerateNormal(masm);
 }
 
-void Generate_StoreIC_Slow(MacroAssembler* masm) {
-  NamedStoreHandlerCompiler::GenerateSlow(masm);
+void Generate_StoreIC_Slow(CodeStubAssembler* assembler,
+                           LanguageMode language_mode) {
+  typedef compiler::Node Node;
+
+  Node* receiver = assembler->Parameter(0);
+  Node* name = assembler->Parameter(1);
+  Node* value = assembler->Parameter(2);
+  // Node* slot = assembler->Parameter(3);
+  // Node* vector = assembler->Parameter(4);
+  Node* context = assembler->Parameter(5);
+  Node* lang_mode = assembler->SmiConstant(Smi::FromInt(language_mode));
+
+  // The slow case calls into the runtime to complete the store without causing
+  // an IC miss that would otherwise cause a transition to the generic stub.
+  assembler->TailCallRuntime(Runtime::kSetProperty, context, receiver, name,
+                             value, lang_mode);
+}
+
+void Generate_StoreIC_SlowSloppy(CodeStubAssembler* assembler) {
+  Generate_StoreIC_Slow(assembler, SLOPPY);
+}
+
+void Generate_StoreIC_SlowStrict(CodeStubAssembler* assembler) {
+  Generate_StoreIC_Slow(assembler, STRICT);
 }
 
 void Generate_KeyedStoreIC_Slow(MacroAssembler* masm) {

src/builtins.h

@@ -251,7 +251,6 @@ class CodeStubAssembler;
   V(InterpreterEnterBytecodeDispatch, BUILTIN, kNoExtraICState)              \
                                                                              \
   V(KeyedLoadIC_Miss, BUILTIN, kNoExtraICState)                              \
-  V(StoreIC_Miss, BUILTIN, kNoExtraICState)                                  \
   V(KeyedStoreIC_Miss, BUILTIN, kNoExtraICState)                             \
   V(LoadIC_Getter_ForDeopt, LOAD_IC, kNoExtraICState)                        \
   V(KeyedLoadIC_Megamorphic, KEYED_LOAD_IC, kNoExtraICState)                 \
@@ -372,12 +371,14 @@ class CodeStubAssembler;
   V(LoadGlobalIC_SlowInsideTypeof, HANDLER, Code::LOAD_GLOBAL_IC,      \
     LoadGlobalWithVector)                                              \
   V(LoadIC_Miss, BUILTIN, kNoExtraICState, LoadWithVector)             \
-  V(LoadIC_Slow, HANDLER, Code::LOAD_IC, LoadWithVector)
+  V(LoadIC_Slow, HANDLER, Code::LOAD_IC, LoadWithVector)               \
+  V(StoreIC_Miss, BUILTIN, kNoExtraICState, VectorStoreIC)             \
+  V(StoreIC_SlowSloppy, HANDLER, Code::STORE_IC, VectorStoreIC)        \
+  V(StoreIC_SlowStrict, HANDLER, Code::STORE_IC, VectorStoreIC)
 
 // Define list of builtin handlers implemented in assembly.
 #define BUILTIN_LIST_H(V)                    \
   V(KeyedLoadIC_Slow,        KEYED_LOAD_IC)  \
-  V(StoreIC_Slow,            STORE_IC)       \
   V(KeyedStoreIC_Slow,       KEYED_STORE_IC) \
   V(LoadIC_Normal,           LOAD_IC)        \
   V(StoreIC_Normal,          STORE_IC)

src/compiler/code-assembler.cc

@@ -394,6 +394,13 @@ Node* CodeAssembler::TailCallRuntime(Runtime::FunctionId function_id,
                                           context);
 }
 
+Node* CodeAssembler::TailCallRuntime(Runtime::FunctionId function_id,
+                                     Node* context, Node* arg1, Node* arg2,
+                                     Node* arg3, Node* arg4, Node* arg5) {
+  return raw_assembler_->TailCallRuntime5(function_id, arg1, arg2, arg3, arg4,
+                                          arg5, context);
+}
+
 Node* CodeAssembler::CallStub(Callable const& callable, Node* context,
                               Node* arg1, size_t result_size) {
   Node* target = HeapConstant(callable.code());

src/compiler/code-assembler.h

@@ -319,6 +319,9 @@ class CodeAssembler {
                         Node* arg1, Node* arg2, Node* arg3);
   Node* TailCallRuntime(Runtime::FunctionId function_id, Node* context,
                         Node* arg1, Node* arg2, Node* arg3, Node* arg4);
+  Node* TailCallRuntime(Runtime::FunctionId function_id, Node* context,
+                        Node* arg1, Node* arg2, Node* arg3, Node* arg4,
+                        Node* arg5);
 
   Node* CallStub(Callable const& callable, Node* context, Node* arg1,
                  size_t result_size = 1);

src/compiler/raw-machine-assembler.cc

@@ -372,6 +372,29 @@ Node* RawMachineAssembler::TailCallRuntime4(Runtime::FunctionId function,
   return tail_call;
 }
 
+Node* RawMachineAssembler::TailCallRuntime5(Runtime::FunctionId function,
+                                            Node* arg1, Node* arg2, Node* arg3,
+                                            Node* arg4, Node* arg5,
+                                            Node* context) {
+  const int kArity = 5;
+  CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(
+      zone(), function, kArity, Operator::kNoProperties,
+      CallDescriptor::kSupportsTailCalls);
+  int return_count = static_cast<int>(desc->ReturnCount());
+
+  Node* centry = HeapConstant(CEntryStub(isolate(), return_count).GetCode());
+  Node* ref = AddNode(
+      common()->ExternalConstant(ExternalReference(function, isolate())));
+  Node* arity = Int32Constant(kArity);
+
+  Node* nodes[] = {centry, arg1, arg2, arg3, arg4, arg5, ref, arity, context};
+  Node* tail_call = MakeNode(common()->TailCall(desc), arraysize(nodes), nodes);
+
+  schedule()->AddTailCall(CurrentBlock(), tail_call);
+  current_block_ = nullptr;
+  return tail_call;
+}
+
 Node* RawMachineAssembler::CallCFunction0(MachineType return_type,
                                           Node* function) {
   MachineSignature::Builder builder(zone(), 1, 0);

src/compiler/raw-machine-assembler.h

@@ -706,6 +706,9 @@ class RawMachineAssembler {
   // Tail call to a runtime function with four arguments.
   Node* TailCallRuntime4(Runtime::FunctionId function, Node* arg1, Node* arg2,
                          Node* arg3, Node* arg4, Node* context);
+  // Tail call to a runtime function with five arguments.
+  Node* TailCallRuntime5(Runtime::FunctionId function, Node* arg1, Node* arg2,
+                         Node* arg3, Node* arg4, Node* arg5, Node* context);
 
   // ===========================================================================
   // The following utility methods deal with control flow, hence might switch

src/ic/arm/handler-compiler-arm.cc

@@ -339,15 +339,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
 }
 
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  StoreIC_PushArgs(masm);
-
-  // The slow case calls into the runtime to complete the store without causing
-  // an IC miss that would otherwise cause a transition to the generic stub.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   StoreIC_PushArgs(masm);
 

src/ic/arm64/handler-compiler-arm64.cc

@@ -332,15 +332,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
 }
 
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  StoreIC_PushArgs(masm);
-
-  // The slow case calls into the runtime to complete the store without causing
-  // an IC miss that would otherwise cause a transition to the generic stub.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   ASM_LOCATION("ElementHandlerCompiler::GenerateStoreSlow");
   StoreIC_PushArgs(masm);

src/ic/handler-compiler.cc

@@ -221,30 +221,26 @@ Handle<Code> NamedLoadHandlerCompiler::CompileLoadNonexistent(
   return GetCode(kind(), name);
 }
 
-
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
-    Handle<Name> name, Handle<AccessorInfo> callback) {
-  Register reg = Frontend(name);
+    Handle<Name> name, Handle<AccessorInfo> callback, Handle<Code> slow_stub) {
   if (FLAG_runtime_call_stats) {
-    TailCallBuiltin(masm(), Builtins::kLoadIC_Slow);
-  } else {
-    GenerateLoadCallback(reg, callback);
+    GenerateTailCall(masm(), slow_stub);
   }
+  Register reg = Frontend(name);
+  GenerateLoadCallback(reg, callback);
   return GetCode(kind(), name);
 }
 
-
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
     Handle<Name> name, const CallOptimization& call_optimization,
-    int accessor_index) {
+    int accessor_index, Handle<Code> slow_stub) {
   DCHECK(call_optimization.is_simple_api_call());
-  Register holder = Frontend(name);
   if (FLAG_runtime_call_stats) {
-    TailCallBuiltin(masm(), Builtins::kLoadIC_Slow);
-  } else {
-    GenerateApiAccessorCall(masm(), call_optimization, map(), receiver(),
-                            scratch2(), false, no_reg, holder, accessor_index);
+    GenerateTailCall(masm(), slow_stub);
   }
+  Register holder = Frontend(name);
+  GenerateApiAccessorCall(masm(), call_optimization, map(), receiver(),
+                          scratch2(), false, no_reg, holder, accessor_index);
   return GetCode(kind(), name);
 }
 
@@ -563,19 +559,17 @@ Handle<Code> NamedStoreHandlerCompiler::CompileStoreViaSetter(
   return GetCode(kind(), name);
 }
 
-
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(
     Handle<JSObject> object, Handle<Name> name,
-    const CallOptimization& call_optimization, int accessor_index) {
-  Register holder = Frontend(name);
+    const CallOptimization& call_optimization, int accessor_index,
+    Handle<Code> slow_stub) {
   if (FLAG_runtime_call_stats) {
-    GenerateRestoreName(name);
-    TailCallBuiltin(masm(), Builtins::kStoreIC_Slow);
-  } else {
-    GenerateApiAccessorCall(masm(), call_optimization, handle(object->map()),
-                            receiver(), scratch2(), true, value(), holder,
-                            accessor_index);
+    GenerateTailCall(masm(), slow_stub);
   }
+  Register holder = Frontend(name);
+  GenerateApiAccessorCall(masm(), call_optimization, handle(object->map()),
+                          receiver(), scratch2(), true, value(), holder,
+                          accessor_index);
   return GetCode(kind(), name);
 }
 

src/ic/handler-compiler.h

@@ -123,11 +123,12 @@ class NamedLoadHandlerCompiler : public PropertyHandlerCompiler {
   Handle<Code> CompileLoadField(Handle<Name> name, FieldIndex index);
 
   Handle<Code> CompileLoadCallback(Handle<Name> name,
-                                   Handle<AccessorInfo> callback);
+                                   Handle<AccessorInfo> callback,
+                                   Handle<Code> slow_stub);
 
   Handle<Code> CompileLoadCallback(Handle<Name> name,
                                    const CallOptimization& call_optimization,
-                                   int accessor_index);
+                                   int accessor_index, Handle<Code> slow_stub);
 
   Handle<Code> CompileLoadConstant(Handle<Name> name, int constant_index);
 
@@ -226,7 +227,7 @@ class NamedStoreHandlerCompiler : public PropertyHandlerCompiler {
                                     LanguageMode language_mode);
   Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name,
                                     const CallOptimization& call_optimization,
-                                    int accessor_index);
+                                    int accessor_index, Handle<Code> slow_stub);
   Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, Handle<Name> name,
                                      int accessor_index,
                                      int expected_arguments);
@@ -241,8 +242,6 @@ class NamedStoreHandlerCompiler : public PropertyHandlerCompiler {
                            no_reg);
   }
 
-  static void GenerateSlow(MacroAssembler* masm);
-
  protected:
   virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
                                   Label* miss, ReturnHolder return_what);
@@ -267,18 +266,6 @@ class NamedStoreHandlerCompiler : public PropertyHandlerCompiler {
   void GenerateFieldTypeChecks(FieldType* field_type, Register value_reg,
                                Label* miss_label);
 
-  static Builtins::Name SlowBuiltin(Code::Kind kind) {
-    switch (kind) {
-      case Code::STORE_IC:
-        return Builtins::kStoreIC_Slow;
-      case Code::KEYED_STORE_IC:
-        return Builtins::kKeyedStoreIC_Slow;
-      default:
-        UNREACHABLE();
-    }
-    return Builtins::kStoreIC_Slow;
-  }
-
   static Register value();
 };
 

src/ic/ia32/handler-compiler-ia32.cc

@@ -333,15 +333,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
 }
 
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  // Return address is on the stack.
-  StoreIC_PushArgs(masm);
-
-  // Do tail-call to runtime routine.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   // Return address is on the stack.
   StoreIC_PushArgs(masm);

src/ic/ic.cc

@@ -1240,7 +1240,7 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator* lookup,
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadCallback);
           int index = lookup->GetAccessorIndex();
           Handle<Code> code = compiler.CompileLoadCallback(
-              lookup->name(), call_optimization, index);
+              lookup->name(), call_optimization, index, slow_stub());
           return code;
         }
         TRACE_HANDLER_STATS(isolate(), LoadIC_LoadViaGetter);
@@ -1259,7 +1259,8 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator* lookup,
         DCHECK(!info->is_sloppy() || receiver->IsJSReceiver());
         TRACE_HANDLER_STATS(isolate(), LoadIC_LoadCallback);
         NamedLoadHandlerCompiler compiler(isolate(), map, holder, cache_holder);
-        Handle<Code> code = compiler.CompileLoadCallback(lookup->name(), info);
+        Handle<Code> code =
+            compiler.CompileLoadCallback(lookup->name(), info, slow_stub());
         return code;
       }
       UNREACHABLE();
@@ -1821,7 +1822,7 @@ Handle<Code> StoreIC::CompileHandler(LookupIterator* lookup,
           TRACE_HANDLER_STATS(isolate(), StoreIC_StoreCallback);
           Handle<Code> code = compiler.CompileStoreCallback(
               receiver, lookup->name(), call_optimization,
-              lookup->GetAccessorIndex());
+              lookup->GetAccessorIndex(), slow_stub());
           return code;
         }
         TRACE_HANDLER_STATS(isolate(), StoreIC_StoreViaSetter);
@@ -2488,22 +2489,6 @@ RUNTIME_FUNCTION(Runtime_KeyedStoreIC_MissFromStubFailure) {
 }
 
 
-RUNTIME_FUNCTION(Runtime_StoreIC_Slow) {
-  HandleScope scope(isolate);
-  DCHECK(args.length() == 5);
-  Handle<Object> object = args.at<Object>(0);
-  Handle<Object> key = args.at<Object>(1);
-  Handle<Object> value = args.at<Object>(2);
-  LanguageMode language_mode;
-  StoreICNexus nexus(isolate);
-  StoreIC ic(IC::NO_EXTRA_FRAME, isolate, &nexus);
-  language_mode = ic.language_mode();
-  RETURN_RESULT_OR_FAILURE(
-      isolate,
-      Runtime::SetObjectProperty(isolate, object, key, value, language_mode));
-}
-
-
 RUNTIME_FUNCTION(Runtime_KeyedStoreIC_Slow) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 5);

src/ic/ic.h

@@ -403,7 +403,15 @@ class StoreIC : public IC {
  protected:
   // Stub accessors.
   Handle<Code> slow_stub() const {
-    return isolate()->builtins()->StoreIC_Slow();
+    switch (language_mode()) {
+      case SLOPPY:
+        return isolate()->builtins()->StoreIC_SlowSloppy();
+      case STRICT:
+        return isolate()->builtins()->StoreIC_SlowStrict();
+      default:
+        UNREACHABLE();
+        return Handle<Code>();
+    }
   }
 
   // Update the inline cache and the global stub cache based on the

src/ic/mips/handler-compiler-mips.cc

@@ -326,15 +326,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
 }
 
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  StoreIC_PushArgs(masm);
-
-  // The slow case calls into the runtime to complete the store without causing
-  // an IC miss that would otherwise cause a transition to the generic stub.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   StoreIC_PushArgs(masm);
 

src/ic/mips64/handler-compiler-mips64.cc

@@ -326,15 +326,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
 }
 
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  StoreIC_PushArgs(masm);
-
-  // The slow case calls into the runtime to complete the store without causing
-  // an IC miss that would otherwise cause a transition to the generic stub.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   StoreIC_PushArgs(masm);
 

src/ic/ppc/handler-compiler-ppc.cc

@@ -334,15 +334,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
 }
 
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  StoreIC_PushArgs(masm);
-
-  // The slow case calls into the runtime to complete the store without causing
-  // an IC miss that would otherwise cause a transition to the generic stub.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   StoreIC_PushArgs(masm);
 

src/ic/s390/handler-compiler-s390.cc

@@ -317,14 +317,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
           VectorStoreICDescriptor::VectorRegister());
 }
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  StoreIC_PushArgs(masm);
-
-  // The slow case calls into the runtime to complete the store without causing
-  // an IC miss that would otherwise cause a transition to the generic stub.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   StoreIC_PushArgs(masm);
 

src/ic/x64/handler-compiler-x64.cc

@@ -340,15 +340,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
 }
 
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  // Return address is on the stack.
-  StoreIC_PushArgs(masm);
-
-  // Do tail-call to runtime routine.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   // Return address is on the stack.
   StoreIC_PushArgs(masm);

src/ic/x87/handler-compiler-x87.cc

@@ -333,15 +333,6 @@ static void StoreIC_PushArgs(MacroAssembler* masm) {
 }
 
 
-void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
-  // Return address is on the stack.
-  StoreIC_PushArgs(masm);
-
-  // Do tail-call to runtime routine.
-  __ TailCallRuntime(Runtime::kStoreIC_Slow);
-}
-
-
 void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
   // Return address is on the stack.
   StoreIC_PushArgs(masm);

src/runtime/runtime-object.cc

@@ -348,10 +348,15 @@ RUNTIME_FUNCTION(Runtime_GetProperty) {
                            Runtime::GetObjectProperty(isolate, object, key));
 }
 
-namespace {
+RUNTIME_FUNCTION(Runtime_GetGlobal) {
+  HandleScope scope(isolate);
+  DCHECK_EQ(3, args.length());
+  CONVERT_SMI_ARG_CHECKED(slot, 0);
+  CONVERT_ARG_HANDLE_CHECKED(TypeFeedbackVector, vector, 1);
+  CONVERT_SMI_ARG_CHECKED(typeof_mode_value, 2);
+  TypeofMode typeof_mode = static_cast<TypeofMode>(typeof_mode_value);
+  bool should_throw_reference_error = typeof_mode == NOT_INSIDE_TYPEOF;
 
-Object* GetGlobal(Isolate* isolate, int slot, Handle<TypeFeedbackVector> vector,
-                  bool should_throw_reference_error) {
   FeedbackVectorSlot vector_slot = vector->ToSlot(slot);
   DCHECK_EQ(FeedbackVectorSlotKind::LOAD_GLOBAL_IC,
             vector->GetKind(vector_slot));
@@ -384,24 +389,6 @@ Object* GetGlobal(Isolate* isolate, int slot, Handle<TypeFeedbackVector> vector,
   return *result;
 }
 
-}  // namespace
-
-RUNTIME_FUNCTION(Runtime_GetGlobalInsideTypeof) {
-  HandleScope scope(isolate);
-  DCHECK_EQ(2, args.length());
-  CONVERT_SMI_ARG_CHECKED(slot, 0);
-  CONVERT_ARG_HANDLE_CHECKED(TypeFeedbackVector, vector, 1);
-  return GetGlobal(isolate, slot, vector, false);
-}
-
-RUNTIME_FUNCTION(Runtime_GetGlobalNotInsideTypeof) {
-  HandleScope scope(isolate);
-  DCHECK_EQ(2, args.length());
-  CONVERT_SMI_ARG_CHECKED(slot, 0);
-  CONVERT_ARG_HANDLE_CHECKED(TypeFeedbackVector, vector, 1);
-  return GetGlobal(isolate, slot, vector, true);
-}
-
 // KeyedGetProperty is called from KeyedLoadIC::GenerateGeneric.
 RUNTIME_FUNCTION(Runtime_KeyedGetProperty) {
   HandleScope scope(isolate);
@@ -414,7 +401,6 @@ RUNTIME_FUNCTION(Runtime_KeyedGetProperty) {
       isolate, KeyedGetObjectProperty(isolate, receiver_obj, key_obj));
 }
 
-
 RUNTIME_FUNCTION(Runtime_AddNamedProperty) {
   HandleScope scope(isolate);
   DCHECK_EQ(4, args.length());
@@ -493,8 +479,7 @@ RUNTIME_FUNCTION(Runtime_SetProperty) {
   CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
   CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
-  CONVERT_LANGUAGE_MODE_ARG_CHECKED(language_mode_arg, 3);
-  LanguageMode language_mode = language_mode_arg;
+  CONVERT_LANGUAGE_MODE_ARG_CHECKED(language_mode, 3);
 
   RETURN_RESULT_OR_FAILURE(
       isolate,

src/runtime/runtime.h

@@ -376,8 +376,7 @@ namespace internal {
   F(SetPrototype, 2, 1)                              \
   F(OptimizeObjectForAddingMultipleProperties, 2, 1) \
   F(GetProperty, 2, 1)                               \
-  F(GetGlobalInsideTypeof, 2, 1)                     \
-  F(GetGlobalNotInsideTypeof, 2, 1)                  \
+  F(GetGlobal, 3, 1)                                 \
   F(KeyedGetProperty, 2, 1)                          \
   F(StoreGlobalViaContext_Sloppy, 2, 1)              \
   F(StoreGlobalViaContext_Strict, 2, 1)              \
@@ -951,7 +950,6 @@ namespace internal {
   F(StoreCallbackProperty, 6, 1)             \
   F(StoreIC_Miss, 5, 1)                      \
   F(StoreIC_MissFromStubFailure, 5, 1)       \
-  F(StoreIC_Slow, 5, 1)                      \
   F(StorePropertyWithInterceptor, 3, 1)      \
   F(ToBooleanIC_Miss, 1, 1)                  \
   F(Unreachable, 0, 1)