Make the strict-mode calling convention for contextual calls the default one.

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4669 matching lines @@
   HValue* context = environment()->context();
   int length = current_info()->scope()->ContextChainLength(var->scope());
   while (length-- > 0) {
     context = Add<HOuterContext>(context);
   }
   return context;
 }
 
 
 void HOptimizedGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
+  if (expr->is_this()) {
+    current_info()->set_this_has_uses(true);
+  }
+
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   Variable* variable = expr->var();
   switch (variable->location()) {
     case Variable::UNALLOCATED: {
       if (IsLexicalVariableMode(variable->mode())) {
         // TODO(rossberg): should this be an ASSERT?
         return Bailout(kReferenceToGlobalLexicalVariable);
       }
@@ skipping 2503 matching lines @@
   ASSERT(target_shared->has_deoptimization_support());
   AstTyper::Run(&target_info);
 
   // Save the pending call context. Set up new one for the inlined function.
   // The function state is new-allocated because we need to delete it
   // in two different places.
   FunctionState* target_state = new FunctionState(
       this, &target_info, inlining_kind);
 
   HConstant* undefined = graph()->GetConstantUndefined();
-  bool undefined_receiver = HEnvironment::UseUndefinedReceiver(
-      target, function, call_kind, inlining_kind);
+
   HEnvironment* inner_env =
       environment()->CopyForInlining(target,
                                      arguments_count,
                                      function,
                                      undefined,
-                                     function_state()->inlining_kind(),
-                                     undefined_receiver);
+                                     function_state()->inlining_kind());
 
   HConstant* context = Add<HConstant>(Handle<Context>(target->context()));
   inner_env->BindContext(context);
 
   Add<HSimulate>(return_id);
   current_block()->UpdateEnvironment(inner_env);
   HArgumentsObject* arguments_object = NULL;
 
   // If the function uses arguments object create and bind one, also copy
   // current arguments values to use them for materialization.
   if (function->scope()->arguments() != NULL) {
     ASSERT(function->scope()->arguments()->IsStackAllocated());
     HEnvironment* arguments_env = inner_env->arguments_environment();
     int arguments_count = arguments_env->parameter_count();
     arguments_object = Add<HArgumentsObject>(arguments_count);
     inner_env->Bind(function->scope()->arguments(), arguments_object);
     for (int i = 0; i < arguments_count; i++) {
       arguments_object->AddArgument(arguments_env->Lookup(i), zone());
     }
   }
 
   HEnterInlined* enter_inlined =
       Add<HEnterInlined>(target, arguments_count, function,
                          function_state()->inlining_kind(),
                          function->scope()->arguments(),
-                         arguments_object, undefined_receiver);
+                         arguments_object);
   function_state()->set_entry(enter_inlined);
 
   VisitDeclarations(target_info.scope()->declarations());
   VisitStatements(function->body());
   if (HasStackOverflow()) {
     // Bail out if the inline function did, as we cannot residualize a call
     // instead.
     TraceInline(target, caller, "inline graph construction failed");
     target_shared->DisableOptimization(kInliningBailedOut);
     inline_bailout_ = true;
@@ skipping 402 matching lines @@
     HInvokeFunction* call = New<HInvokeFunction>(function,
                                                  known_function,
                                                  arguments_count);
     Drop(arguments_count);
     ast_context()->ReturnInstruction(call, expr->id());
     return true;
   }
 }
 
 
-void HOptimizedGraphBuilder::InstallGlobalReceiverInExpressionStack(
-    int receiver_index,
-    Handle<JSFunction> function) {
-  // TODO(dcarney): Fix deserializer to be able to hookup the global receiver
-  // and object during deserialization and embed the global receiver here
-  // directly.
-  // Install global receiver on stack.
-  HValue* function_constant = Add<HConstant>(function);
-  HValue* context = Add<HLoadNamedField>(
-      function_constant,
-      HObjectAccess::ForJSObjectOffset(JSFunction::kContextOffset));
-  HValue* global_object = Add<HLoadNamedField>(
-      context,
-      HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
-  HValue* global_receiver = Add<HLoadNamedField>(
-      global_object,
-      HObjectAccess::ForJSObjectOffset(GlobalObject::kGlobalReceiverOffset));
-  environment()->SetExpressionStackAt(receiver_index, global_receiver);
-}
-
-
 void HOptimizedGraphBuilder::VisitCall(Call* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   Expression* callee = expr->expression();
   int argument_count = expr->arguments()->length() + 1;  // Plus receiver.
   HInstruction* call = NULL;
 
   Property* prop = callee->AsProperty();
   if (prop != NULL) {
@@ skipping 94 matching lines @@
       if (type == kUseCell &&
           !current_info()->global_object()->IsAccessCheckNeeded()) {
         Handle<GlobalObject> global(current_info()->global_object());
         known_global_function = expr->ComputeGlobalTarget(global, &lookup);
       }
       if (known_global_function) {
         // Push the global object instead of the global receiver because
         // code generated by the full code generator expects it.
         HGlobalObject* global_object = Add<HGlobalObject>();
         Push(global_object);
+
         CHECK_ALIVE(VisitExpressions(expr->arguments()));
 
         CHECK_ALIVE(VisitForValue(expr->expression()));
         HValue* function = Pop();
         Add<HCheckValue>(function, expr->target());
 
-        // Install global receiver on stack.
+        // Patch the global object on the stack by the expected receiver.
+        Handle<JSFunction> target = expr->target();
+        SharedFunctionInfo* shared = target->shared();
+        HValue* receiver;
         const int receiver_index = argument_count - 1;
-        ASSERT(environment()->ExpressionStackAt(receiver_index)->
-               IsGlobalObject());
-        InstallGlobalReceiverInExpressionStack(receiver_index, expr->target());
+        if (shared->is_classic_mode() && !shared->native()) {

[dcarney, 2014/01/13 18:35:03]

not really for this patch maybe, but:

is_classic_mode && !native

is used so much it should really be a function on shared
it would also allow us to find all these places much more easier

+          HValue* context = Add<HLoadNamedField>(
+              function,
+              HObjectAccess::ForJSObjectOffset(JSFunction::kContextOffset));
+          HValue* global_object = Add<HLoadNamedField>(
+              context,
+              HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
+          receiver = Add<HLoadNamedField>(
+              global_object,
+              HObjectAccess::ForJSObjectOffset(
+                  GlobalObject::kGlobalReceiverOffset));
+        } else {
+          receiver = graph()->GetConstantUndefined();
+        }
+        environment()->SetExpressionStackAt(receiver_index, receiver);
 
         if (TryInlineBuiltinFunctionCall(expr, false)) {  // Nothing to drop.
           if (FLAG_trace_inlining) {
             PrintF("Inlining builtin ");
             expr->target()->ShortPrint();
             PrintF("\n");
           }
           return;
         }
         if (TryInlineCall(expr)) return;
 
         if (expr->target().is_identical_to(current_info()->closure())) {
           graph()->MarkRecursive();
         }
 
         if (CallStubCompiler::HasCustomCallGenerator(expr->target())) {
           // We're about to install a contextual IC, which expects the global
           // object as receiver rather than the global proxy.
+          HGlobalObject* global_object = Add<HGlobalObject>();
+          const int receiver_index = argument_count - 1;
           environment()->SetExpressionStackAt(receiver_index, global_object);
           // When the target has a custom call IC generator, use the IC,
           // because it is likely to generate better code.
           call = PreProcessCall(New<HCallGlobal>(var->name(), argument_count));
         } else {
           call = PreProcessCall(New<HCallKnownGlobal>(
               expr->target(), argument_count));
         }
       } else {
         HGlobalObject* receiver = Add<HGlobalObject>();
         Push(Add<HPushArgument>(receiver));
         CHECK_ALIVE(VisitArgumentList(expr->arguments()));
 
         call = New<HCallGlobal>(var->name(), argument_count);
         Drop(argument_count);
       }
 
     } else if (expr->IsMonomorphic()) {
       // The function is on the stack in the unoptimized code during
       // evaluation of the arguments.
       CHECK_ALIVE(VisitForValue(expr->expression()));
       HValue* function = Top();
-      HGlobalObject* global = Add<HGlobalObject>();
-      HGlobalReceiver* receiver = Add<HGlobalReceiver>(global);
-      Push(receiver);
-      CHECK_ALIVE(VisitExpressions(expr->arguments()));
+
       Add<HCheckValue>(function, expr->target());
 
-      // Install global receiver on stack.
-      const int receiver_index = argument_count - 1;
-      ASSERT(environment()->ExpressionStackAt(receiver_index)->
-             IsGlobalReceiver());
-      InstallGlobalReceiverInExpressionStack(receiver_index, expr->target());
+      Handle<JSFunction> target = expr->target();
+      SharedFunctionInfo* shared = target->shared();
+      if (shared->is_classic_mode() && !shared->native()) {

[dcarney, 2014/01/13 18:35:03]

this block is identical to the above except for the pushes  -- extract into a
function returning the receiver

+        HValue* context = Add<HLoadNamedField>(
+            function,
+            HObjectAccess::ForJSObjectOffset(JSFunction::kContextOffset));
+        HValue* global_object = Add<HLoadNamedField>(
+            context,
+            HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
+        HValue* global_receiver = Add<HLoadNamedField>(
+            global_object,
+            HObjectAccess::ForJSObjectOffset(
+                GlobalObject::kGlobalReceiverOffset));
+        Push(global_receiver);
+      } else {
+        Push(graph()->GetConstantUndefined());
+      }
+
+      CHECK_ALIVE(VisitExpressions(expr->arguments()));
 
       if (TryInlineBuiltinFunctionCall(expr, true)) {  // Drop the function.
         if (FLAG_trace_inlining) {
           PrintF("Inlining builtin ");
           expr->target()->ShortPrint();
           PrintF("\n");
         }
         return;
       }
 
       if (TryInlineCall(expr, true)) {   // Drop function from environment.
         return;
       } else {
         call = PreProcessCall(New<HInvokeFunction>(function, expr->target(),
                                                    argument_count));
         Drop(1);  // The function.
       }
 
     } else {
       CHECK_ALIVE(VisitForValue(expr->expression()));
       HValue* function = Top();
-      HValue* receiver = graph()->GetConstantHole();
+      HValue* receiver = graph()->GetConstantUndefined();
       Push(Add<HPushArgument>(receiver));
       CHECK_ALIVE(VisitArgumentList(expr->arguments()));
       call = New<HCallFunction>(
           function, argument_count, NORMAL_CONTEXTUAL_CALL);
       Drop(argument_count + 1);
     }
   }
 
   return ast_context()->ReturnInstruction(call, expr->id());
 }
@@ skipping 2665 matching lines @@
   new_env->ClearHistory();
   return new_env;
 }
 
 
 HEnvironment* HEnvironment::CopyForInlining(
     Handle<JSFunction> target,
     int arguments,
     FunctionLiteral* function,
     HConstant* undefined,
-    InliningKind inlining_kind,
-    bool undefined_receiver) const {
+    InliningKind inlining_kind) const {
   ASSERT(frame_type() == JS_FUNCTION);
 
   // Outer environment is a copy of this one without the arguments.
   int arity = function->scope()->num_parameters();
 
   HEnvironment* outer = Copy();
   outer->Drop(arguments + 1);  // Including receiver.
   outer->ClearHistory();
 
   if (inlining_kind == CONSTRUCT_CALL_RETURN) {
@@ skipping 17 matching lines @@
   }
 
   HEnvironment* inner =
       new(zone()) HEnvironment(outer, function->scope(), target, zone());
   // Get the argument values from the original environment.
   for (int i = 0; i <= arity; ++i) {  // Include receiver.
     HValue* push = (i <= arguments) ?
         ExpressionStackAt(arguments - i) : undefined;
     inner->SetValueAt(i, push);
   }
-  // If the function we are inlining is a strict mode function or a
-  // builtin function, pass undefined as the receiver for function
-  // calls (instead of the global receiver).
-  if (undefined_receiver) {
-    inner->SetValueAt(0, undefined);
-  }
   inner->SetValueAt(arity + 1, context());
   for (int i = arity + 2; i < inner->length(); ++i) {
     inner->SetValueAt(i, undefined);
   }
 
   inner->set_ast_id(BailoutId::FunctionEntry());
   return inner;
 }
 
 
@@ skipping 346 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal