Bug 1640211 - Rename function to callee in MCall. r=iain

Differential Revision: https://phabricator.services.mozilla.com/D76524
dothq · May 22, 2020 · 1895e30 · 1895e30
1 parent f6bf58a
commit 1895e30
Show file tree

Hide file tree

Showing 5 changed files with 15 additions and 18 deletions.
diff --git a/js/src/jit/IonBuilder.cpp b/js/src/jit/IonBuilder.cpp
@@ -6268,7 +6268,7 @@ AbortReasonOr<MCall*> IonBuilder::makeCallHelper(
     }
   }
 
-  call->initFunction(callInfo.callee());
+  call->initCallee(callInfo.callee());
 
   current->add(call);
   return call;

diff --git a/js/src/jit/Lowering.cpp b/js/src/jit/Lowering.cpp
@@ -405,7 +405,7 @@ bool LIRGenerator::lowerCallArguments(MCall* call) {
 }
 
 void LIRGenerator::visitCall(MCall* call) {
-  MOZ_ASSERT(call->getFunction()->type() == MIRType::Object);
+  MOZ_ASSERT(call->getCallee()->type() == MIRType::Object);
 
   // In case of oom, skip the rest of the allocations.
   if (!lowerCallArguments(call)) {
@@ -445,13 +445,13 @@ void LIRGenerator::visitCall(MCall* call) {
                                       tempFixed(vpReg), tempFixed(tmpReg));
     } else {
       lir = new (alloc())
-          LCallKnown(useFixedAtStart(call->getFunction(), CallTempReg0),
+          LCallKnown(useFixedAtStart(call->getCallee(), CallTempReg0),
                      tempFixed(CallTempReg2));
     }
   } else {
     // Call anything, using the most generic code.
     lir = new (alloc())
-        LCallGeneric(useFixedAtStart(call->getFunction(), CallTempReg0),
+        LCallGeneric(useFixedAtStart(call->getCallee(), CallTempReg0),
                      tempFixed(CallTempReg1), tempFixed(CallTempReg2));
   }
   defineReturn(lir, call);

diff --git a/js/src/jit/MIR.h b/js/src/jit/MIR.h
@@ -2663,13 +2663,12 @@ class WrappedFunction : public TempObject {
 
 class MCall : public MVariadicInstruction, public CallPolicy::Data {
  private:
-  // An MCall uses the MPrepareCall, MDefinition for the function, and
-  // MPassArg instructions. They are stored in the same list.
-  static const size_t FunctionOperandIndex = 0;
+  // The callee, this, and the actual arguments are all operands of MCall.
+  static const size_t CalleeOperandIndex = 0;
   static const size_t NumNonArgumentOperands = 1;
 
  protected:
-  // Monomorphic cache of single target from TI, or nullptr.
+  // Monomorphic cache for MCalls with a single JSFunction target.
   WrappedFunction* target_;
 
   // Original value of argc from the bytecode.
@@ -2707,9 +2706,7 @@ class MCall : public MVariadicInstruction, public CallPolicy::Data {
                     bool ignoresReturnValue, bool isDOMCall,
                     DOMObjectKind objectKind);
 
-  void initFunction(MDefinition* func) {
-    initOperand(FunctionOperandIndex, func);
-  }
+  void initCallee(MDefinition* func) { initOperand(CalleeOperandIndex, func); }
 
   bool needsArgCheck() const { return needsArgCheck_; }
   void disableArgCheck() { needsArgCheck_ = false; }
@@ -2726,9 +2723,9 @@ class MCall : public MVariadicInstruction, public CallPolicy::Data {
     needsThisCheck_ = true;
   }
 
-  MDefinition* getFunction() const { return getOperand(FunctionOperandIndex); }
-  void replaceFunction(MInstruction* newfunc) {
-    replaceOperand(FunctionOperandIndex, newfunc);
+  MDefinition* getCallee() const { return getOperand(CalleeOperandIndex); }
+  void replaceCallee(MInstruction* newfunc) {
+    replaceOperand(CalleeOperandIndex, newfunc);
   }
 
   void addArg(size_t argnum, MDefinition* arg);
@@ -2745,7 +2742,7 @@ class MCall : public MVariadicInstruction, public CallPolicy::Data {
     return NumNonArgumentOperands + index;
   }
 
-  // For TI-informed monomorphic callsites.
+  // For monomorphic callsites.
   WrappedFunction* getSingleTarget() const { return target_; }
 
   bool isConstructing() const { return construct_; }

diff --git a/js/src/jit/TypePolicy.cpp b/js/src/jit/TypePolicy.cpp
@@ -910,12 +910,12 @@ template bool ObjectPolicy<3>::staticAdjustInputs(TempAllocator& alloc,
 bool CallPolicy::adjustInputs(TempAllocator& alloc, MInstruction* ins) const {
   MCall* call = ins->toCall();
 
-  MDefinition* func = call->getFunction();
+  MDefinition* func = call->getCallee();
   if (func->type() != MIRType::Object) {
     MInstruction* unbox =
         MUnbox::New(alloc, func, MIRType::Object, MUnbox::Fallible);
     call->block()->insertBefore(call, unbox);
-    call->replaceFunction(unbox);
+    call->replaceCallee(unbox);
 
     if (!unbox->typePolicy()->adjustInputs(alloc, unbox)) {
       return false;

diff --git a/js/src/jit/WarpBuilderShared.cpp b/js/src/jit/WarpBuilderShared.cpp
@@ -81,7 +81,7 @@ MCall* WarpBuilderShared::makeCall(CallInfo& callInfo, bool needsThisCheck,
 
   // Pass |this| and callee.
   call->addArg(0, callInfo.thisArg());
-  call->initFunction(callInfo.callee());
+  call->initCallee(callInfo.callee());
 
   return call;
 }