[csa] Remove context inputs from StrictEqual, SameValue and Typeof.

src/code-stub-assembler.cc

 // Copyright 2016 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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 7232 matching lines @@
   Bind(&if_notequal);
   {
     result.Bind(FalseConstant());
     Goto(&end);
   }
 
   Bind(&end);
   return result.value();
 }
 
-Node* CodeStubAssembler::StrictEqual(Node* lhs, Node* rhs, Node* context) {
+Node* CodeStubAssembler::StrictEqual(Node* lhs, Node* rhs) {
   // Here's pseudo-code for the algorithm below in case of kDontNegateResult
   // mode; for kNegateResult mode we properly negate the result.
   //
   // if (lhs == rhs) {
   //   if (lhs->IsHeapNumber()) return HeapNumber::cast(lhs)->value() != NaN;
   //   return true;
   // }
   // if (!lhs->IsSmi()) {
   //   if (lhs->IsHeapNumber()) {
   //     if (rhs->IsSmi()) {
@@ skipping 129 matching lines @@
 
             // Check if {rhs} is also a String.
             Label if_rhsisstring(this, Label::kDeferred),
                 if_rhsisnotstring(this);
             Branch(IsStringInstanceType(rhs_instance_type), &if_rhsisstring,
                    &if_rhsisnotstring);
 
             Bind(&if_rhsisstring);
             {
               Callable callable = CodeFactory::StringEqual(isolate());
-              result.Bind(CallStub(callable, context, lhs, rhs));
+              result.Bind(CallStub(callable, NoContextConstant(), lhs, rhs));
               Goto(&end);
             }
 
             Bind(&if_rhsisnotstring);
             Goto(&if_notequal);
           }
 
           Bind(&if_lhsisnotstring);
           Goto(&if_notequal);
         }
@@ skipping 50 matching lines @@
     Goto(&end);
   }
 
   Bind(&end);
   return result.value();
 }
 
 // ECMA#sec-samevalue
 // This algorithm differs from the Strict Equality Comparison Algorithm in its
 // treatment of signed zeroes and NaNs.
-Node* CodeStubAssembler::SameValue(Node* lhs, Node* rhs, Node* context) {
+Node* CodeStubAssembler::SameValue(Node* lhs, Node* rhs) {
   Variable var_result(this, MachineRepresentation::kWord32);
   Label strict_equal(this), out(this);
 
   Node* const int_false = Int32Constant(0);
   Node* const int_true = Int32Constant(1);
 
   Label if_equal(this), if_notequal(this);
   Branch(WordEqual(lhs, rhs), &if_equal, &if_notequal);
 
   Bind(&if_equal);
@@ skipping 53 matching lines @@
       Bind(&if_floatnotequal);
       {
         var_result.Bind(int_false);
         Goto(&out);
       }
     }
   }
 
   Bind(&strict_equal);
   {
-    Node* const is_equal = StrictEqual(lhs, rhs, context);
+    Node* const is_equal = StrictEqual(lhs, rhs);
     Node* const result = WordEqual(is_equal, TrueConstant());
     var_result.Bind(result);
     Goto(&out);
   }
 
   Bind(&out);
   return var_result.value();
 }
 
 Node* CodeStubAssembler::HasProperty(
@@ skipping 90 matching lines @@
   Goto(&return_result);
 
   Bind(&if_primitive);
   var_result.Bind(NullConstant());
   Goto(&return_result);
 
   Bind(&return_result);
   return var_result.value();
 }
 
-Node* CodeStubAssembler::Typeof(Node* value, Node* context) {
+Node* CodeStubAssembler::Typeof(Node* value) {
   Variable result_var(this, MachineRepresentation::kTagged);
 
   Label return_number(this, Label::kDeferred), if_oddball(this),
       return_function(this), return_undefined(this), return_object(this),
       return_string(this), return_result(this);
 
   GotoIf(TaggedIsSmi(value), &return_number);
 
   Node* map = LoadMap(value);
 
@@ skipping 642 matching lines @@
         formatted.c_str(), TENURED);
     CallRuntime(Runtime::kGlobalPrint, NoContextConstant(),
                 HeapConstant(string));
   }
   CallRuntime(Runtime::kDebugPrint, NoContextConstant(), tagged_value);
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8