void-packages/srcpkgs/mozjs60/patches/0010-mips-LIR.patch

From: Dragan Mladjenovic <dragan.mladjenovic@rt-rk.com>
Date: Fri, 9 Mar 2018 07:58:43 +0100
Subject: Bug 1444303 : [MIPS] Fix build failures after Bug 1425580 part 17

From upstream, via firefox-esr 60.2.0esr-1.

Reviewed-by: jandem
Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1444303
Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=908486
Applied-upstream: 61, commit:https://hg.mozilla.org/mozilla-central/rev/7de4ca7b082a
---
 js/src/jit/mips-shared/LIR-mips-shared.h | 88 +++++++++++++++++++++-----------
 js/src/jit/mips32/LIR-mips32.h           | 26 ++++++++--
 js/src/jit/mips64/LIR-mips64.h           | 33 ++++++++----
 3 files changed, 102 insertions(+), 45 deletions(-)

Index: mozjs-60.8.0/js/src/jit/mips-shared/LIR-mips-shared.h
===================================================================
--- mozjs-60.8.0.orig/js/src/jit/mips-shared/LIR-mips-shared.h
+++ mozjs-60.8.0/js/src/jit/mips-shared/LIR-mips-shared.h
@@ -15,7 +15,10 @@ class LWasmUint32ToDouble : public LInst
  public:
   LIR_HEADER(WasmUint32ToDouble)
 
-  LWasmUint32ToDouble(const LAllocation& input) { setOperand(0, input); }
+  LWasmUint32ToDouble(const LAllocation& input)
+      : LInstructionHelper(classOpcode) {
+    setOperand(0, input);
+  }
 };
 
 // Convert a 32-bit unsigned integer to a float32.
@@ -23,15 +26,18 @@ class LWasmUint32ToFloat32 : public LIns
  public:
   LIR_HEADER(WasmUint32ToFloat32)
 
-  LWasmUint32ToFloat32(const LAllocation& input) { setOperand(0, input); }
+  LWasmUint32ToFloat32(const LAllocation& input)
+      : LInstructionHelper(classOpcode) {
+    setOperand(0, input);
+  }
 };
 
 class LDivI : public LBinaryMath<1> {
  public:
   LIR_HEADER(DivI);
 
-  LDivI(const LAllocation& lhs, const LAllocation& rhs,
-        const LDefinition& temp) {
+  LDivI(const LAllocation& lhs, const LAllocation& rhs, const LDefinition& temp)
+      : LBinaryMath(classOpcode) {
     setOperand(0, lhs);
     setOperand(1, rhs);
     setTemp(0, temp);
@@ -47,15 +53,13 @@ class LDivPowTwoI : public LInstructionH
   LIR_HEADER(DivPowTwoI)
 
   LDivPowTwoI(const LAllocation& lhs, int32_t shift, const LDefinition& temp)
-      : shift_(shift) {
+      : LInstructionHelper(classOpcode), shift_(shift) {
     setOperand(0, lhs);
     setTemp(0, temp);
   }
 
   const LAllocation* numerator() { return getOperand(0); }
-
-  int32_t shift() { return shift_; }
-
+  int32_t shift() const { return shift_; }
   MDiv* mir() const { return mir_->toDiv(); }
 };
 
@@ -64,14 +68,14 @@ class LModI : public LBinaryMath<1> {
   LIR_HEADER(ModI);
 
   LModI(const LAllocation& lhs, const LAllocation& rhs,
-        const LDefinition& callTemp) {
+        const LDefinition& callTemp)
+      : LBinaryMath(classOpcode) {
     setOperand(0, lhs);
     setOperand(1, rhs);
     setTemp(0, callTemp);
   }
 
   const LDefinition* callTemp() { return getTemp(0); }
-
   MMod* mir() const { return mir_->toMod(); }
 };
 
@@ -80,12 +84,13 @@ class LModPowTwoI : public LInstructionH
 
  public:
   LIR_HEADER(ModPowTwoI);
-  int32_t shift() { return shift_; }
 
-  LModPowTwoI(const LAllocation& lhs, int32_t shift) : shift_(shift) {
+  LModPowTwoI(const LAllocation& lhs, int32_t shift)
+      : LInstructionHelper(classOpcode), shift_(shift) {
     setOperand(0, lhs);
   }
 
+  int32_t shift() const { return shift_; }
   MMod* mir() const { return mir_->toMod(); }
 };
 
@@ -97,14 +102,13 @@ class LModMaskI : public LInstructionHel
 
   LModMaskI(const LAllocation& lhs, const LDefinition& temp0,
             const LDefinition& temp1, int32_t shift)
-      : shift_(shift) {
+      : LInstructionHelper(classOpcode), shift_(shift) {
     setOperand(0, lhs);
     setTemp(0, temp0);
     setTemp(1, temp1);
   }
 
   int32_t shift() const { return shift_; }
-
   MMod* mir() const { return mir_->toMod(); }
 };
 
@@ -114,7 +118,8 @@ class LTableSwitch : public LInstruction
   LIR_HEADER(TableSwitch);
 
   LTableSwitch(const LAllocation& in, const LDefinition& inputCopy,
-               const LDefinition& jumpTablePointer, MTableSwitch* ins) {
+               const LDefinition& jumpTablePointer, MTableSwitch* ins)
+      : LInstructionHelper(classOpcode) {
     setOperand(0, in);
     setTemp(0, inputCopy);
     setTemp(1, jumpTablePointer);
@@ -122,7 +127,6 @@ class LTableSwitch : public LInstruction
   }
 
   MTableSwitch* mir() const { return mir_->toTableSwitch(); }
-
   const LAllocation* index() { return getOperand(0); }
   const LDefinition* tempInt() { return getTemp(0); }
   // This is added to share the same CodeGenerator prefixes.
@@ -136,7 +140,8 @@ class LTableSwitchV : public LInstructio
 
   LTableSwitchV(const LBoxAllocation& input, const LDefinition& inputCopy,
                 const LDefinition& floatCopy,
-                const LDefinition& jumpTablePointer, MTableSwitch* ins) {
+                const LDefinition& jumpTablePointer, MTableSwitch* ins)
+      : LInstructionHelper(classOpcode) {
     setBoxOperand(InputValue, input);
     setTemp(0, inputCopy);
     setTemp(1, floatCopy);
@@ -157,6 +162,8 @@ class LMulI : public LBinaryMath<0> {
  public:
   LIR_HEADER(MulI);
 
+  LMulI() : LBinaryMath(classOpcode) {}
+
   MMul* mir() { return mir_->toMul(); }
 };
 
@@ -164,6 +171,8 @@ class LUDivOrMod : public LBinaryMath<0>
  public:
   LIR_HEADER(UDivOrMod);
 
+  LUDivOrMod() : LBinaryMath(classOpcode) {}
+
   MBinaryArithInstruction* mir() const {
     MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
     return static_cast<MBinaryArithInstruction*>(mir_);
@@ -194,12 +203,13 @@ class LWasmUnalignedLoadBase : public de
  public:
   typedef LWasmLoadBase<NumDefs, 2> Base;
 
-  explicit LWasmUnalignedLoadBase(const LAllocation& ptr,
+  explicit LWasmUnalignedLoadBase(LNode::Opcode opcode, const LAllocation& ptr,
                                   const LDefinition& valueHelper)
-      : Base(ptr, LAllocation()) {
+      : Base(opcode, ptr, LAllocation()) {
     Base::setTemp(0, LDefinition::BogusTemp());
     Base::setTemp(1, valueHelper);
   }
+
   const LAllocation* ptr() { return Base::getOperand(0); }
   const LDefinition* ptrCopy() { return Base::getTemp(0); }
 };
@@ -208,19 +218,21 @@ class LWasmUnalignedLoadBase : public de
 
 class LWasmUnalignedLoad : public details::LWasmUnalignedLoadBase<1> {
  public:
+  LIR_HEADER(WasmUnalignedLoad);
+
   explicit LWasmUnalignedLoad(const LAllocation& ptr,
                               const LDefinition& valueHelper)
-      : LWasmUnalignedLoadBase(ptr, valueHelper) {}
-  LIR_HEADER(WasmUnalignedLoad);
+      : LWasmUnalignedLoadBase(classOpcode, ptr, valueHelper) {}
 };
 
 class LWasmUnalignedLoadI64
     : public details::LWasmUnalignedLoadBase<INT64_PIECES> {
  public:
+  LIR_HEADER(WasmUnalignedLoadI64);
+
   explicit LWasmUnalignedLoadI64(const LAllocation& ptr,
                                  const LDefinition& valueHelper)
-      : LWasmUnalignedLoadBase(ptr, valueHelper) {}
-  LIR_HEADER(WasmUnalignedLoadI64);
+      : LWasmUnalignedLoadBase(classOpcode, ptr, valueHelper) {}
 };
 
 namespace details {
@@ -234,12 +246,14 @@ class LWasmUnalignedStoreBase : public L
   static const size_t PtrIndex = 0;
   static const size_t ValueIndex = 1;
 
-  LWasmUnalignedStoreBase(const LAllocation& ptr,
-                          const LDefinition& valueHelper) {
+  LWasmUnalignedStoreBase(LNode::Opcode opcode, const LAllocation& ptr,
+                          const LDefinition& valueHelper)
+      : Base(opcode) {
     Base::setOperand(0, ptr);
     Base::setTemp(0, LDefinition::BogusTemp());
     Base::setTemp(1, valueHelper);
   }
+
   MWasmStore* mir() const { return Base::mir_->toWasmStore(); }
   const LAllocation* ptr() { return Base::getOperand(PtrIndex); }
   const LDefinition* ptrCopy() { return Base::getTemp(0); }
@@ -250,11 +264,13 @@ class LWasmUnalignedStoreBase : public L
 class LWasmUnalignedStore : public details::LWasmUnalignedStoreBase<2> {
  public:
   LIR_HEADER(WasmUnalignedStore);
+
   LWasmUnalignedStore(const LAllocation& ptr, const LAllocation& value,
                       const LDefinition& valueHelper)
-      : LWasmUnalignedStoreBase(ptr, valueHelper) {
+      : LWasmUnalignedStoreBase(classOpcode, ptr, valueHelper) {
     setOperand(1, value);
   }
+
   const LAllocation* value() { return Base::getOperand(ValueIndex); }
 };
 
@@ -264,9 +280,10 @@ class LWasmUnalignedStoreI64
   LIR_HEADER(WasmUnalignedStoreI64);
   LWasmUnalignedStoreI64(const LAllocation& ptr, const LInt64Allocation& value,
                          const LDefinition& valueHelper)
-      : LWasmUnalignedStoreBase(ptr, valueHelper) {
+      : LWasmUnalignedStoreBase(classOpcode, ptr, valueHelper) {
     setInt64Operand(1, value);
   }
+
   const LInt64Allocation value() { return getInt64Operand(ValueIndex); }
 };
 
@@ -278,7 +295,8 @@ class LWasmCompareExchangeI64
 
   LWasmCompareExchangeI64(const LAllocation& ptr,
                           const LInt64Allocation& oldValue,
-                          const LInt64Allocation& newValue) {
+                          const LInt64Allocation& newValue)
+      : LInstructionHelper(classOpcode) {
     setOperand(0, ptr);
     setInt64Operand(1, oldValue);
     setInt64Operand(1 + INT64_PIECES, newValue);
@@ -299,8 +317,8 @@ class LWasmAtomicExchangeI64
  public:
   LIR_HEADER(WasmAtomicExchangeI64);
 
-  LWasmAtomicExchangeI64(const LAllocation& ptr,
-                         const LInt64Allocation& value) {
+  LWasmAtomicExchangeI64(const LAllocation& ptr, const LInt64Allocation& value)
+      : LInstructionHelper(classOpcode) {
     setOperand(0, ptr);
     setInt64Operand(1, value);
   }
@@ -317,14 +335,14 @@ class LWasmAtomicBinopI64
  public:
   LIR_HEADER(WasmAtomicBinopI64);
 
-  LWasmAtomicBinopI64(const LAllocation& ptr, const LInt64Allocation& value) {
+  LWasmAtomicBinopI64(const LAllocation& ptr, const LInt64Allocation& value)
+      : LInstructionHelper(classOpcode) {
     setOperand(0, ptr);
     setInt64Operand(1, value);
   }
 
   const LAllocation* ptr() { return getOperand(0); }
   const LInt64Allocation value() { return getInt64Operand(1); }
-
   const MWasmAtomicBinopHeap* mir() const {
     return mir_->toWasmAtomicBinopHeap();
   }
Index: mozjs-60.8.0/js/src/jit/mips32/LIR-mips32.h
===================================================================
--- mozjs-60.8.0.orig/js/src/jit/mips32/LIR-mips32.h
+++ mozjs-60.8.0/js/src/jit/mips32/LIR-mips32.h
@@ -18,7 +18,7 @@ class LBoxFloatingPoint : public LInstru
 
   LBoxFloatingPoint(const LAllocation& in, const LDefinition& temp,
                     MIRType type)
-      : type_(type) {
+      : LInstructionHelper(classOpcode), type_(type) {
     setOperand(0, in);
     setTemp(0, temp);
   }
@@ -31,6 +31,8 @@ class LUnbox : public LInstructionHelper
  public:
   LIR_HEADER(Unbox);
 
+  LUnbox() : LInstructionHelper(classOpcode) {}
+
   MUnbox* mir() const { return mir_->toUnbox(); }
   const LAllocation* payload() { return getOperand(0); }
   const LAllocation* type() { return getOperand(1); }
@@ -45,12 +47,12 @@ class LUnboxFloatingPoint : public LInst
 
   static const size_t Input = 0;
 
-  LUnboxFloatingPoint(const LBoxAllocation& input, MIRType type) : type_(type) {
+  LUnboxFloatingPoint(const LBoxAllocation& input, MIRType type)
+      : LInstructionHelper(classOpcode), type_(type) {
     setBoxOperand(Input, input);
   }
 
   MUnbox* mir() const { return mir_->toUnbox(); }
-
   MIRType type() const { return type_; }
   const char* extraName() const { return StringFromMIRType(type_); }
 };
@@ -63,14 +65,17 @@ class LDivOrModI64
   static const size_t Lhs = 0;
   static const size_t Rhs = INT64_PIECES;
 
-  LDivOrModI64(const LInt64Allocation& lhs, const LInt64Allocation& rhs) {
+  LDivOrModI64(const LInt64Allocation& lhs, const LInt64Allocation& rhs)
+      : LCallInstructionHelper(classOpcode) {
     setInt64Operand(Lhs, lhs);
     setInt64Operand(Rhs, rhs);
   }
+
   MBinaryArithInstruction* mir() const {
     MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
     return static_cast<MBinaryArithInstruction*>(mir_);
   }
+
   bool canBeDivideByZero() const {
     if (mir_->isMod()) return mir_->toMod()->canBeDivideByZero();
     return mir_->toDiv()->canBeDivideByZero();
@@ -94,7 +99,8 @@ class LUDivOrModI64
   static const size_t Lhs = 0;
   static const size_t Rhs = INT64_PIECES;
 
-  LUDivOrModI64(const LInt64Allocation& lhs, const LInt64Allocation& rhs) {
+  LUDivOrModI64(const LInt64Allocation& lhs, const LInt64Allocation& rhs)
+      : LCallInstructionHelper(classOpcode) {
     setInt64Operand(Lhs, lhs);
     setInt64Operand(Rhs, rhs);
   }
@@ -102,6 +108,7 @@ class LUDivOrModI64
     MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
     return static_cast<MBinaryArithInstruction*>(mir_);
   }
+
   bool canBeDivideByZero() const {
     if (mir_->isMod()) return mir_->toMod()->canBeDivideByZero();
     return mir_->toDiv()->canBeDivideByZero();
@@ -121,7 +128,10 @@ class LWasmTruncateToInt64 : public LCal
  public:
   LIR_HEADER(WasmTruncateToInt64);
 
-  explicit LWasmTruncateToInt64(const LAllocation& in) { setOperand(0, in); }
+  explicit LWasmTruncateToInt64(const LAllocation& in)
+      : LCallInstructionHelper(classOpcode) {
+    setOperand(0, in);
+  }
 
   MWasmTruncateToInt64* mir() const { return mir_->toWasmTruncateToInt64(); }
 };
@@ -131,7 +141,8 @@ class LInt64ToFloatingPoint
  public:
   LIR_HEADER(Int64ToFloatingPoint);
 
-  explicit LInt64ToFloatingPoint(const LInt64Allocation& in) {
+  explicit LInt64ToFloatingPoint(const LInt64Allocation& in)
+      : LCallInstructionHelper(classOpcode) {
     setInt64Operand(0, in);
   }
 
@@ -142,7 +153,9 @@ class LWasmAtomicLoadI64 : public LInstr
  public:
   LIR_HEADER(WasmAtomicLoadI64);
 
-  LWasmAtomicLoadI64(const LAllocation& ptr) { setOperand(0, ptr); }
+  LWasmAtomicLoadI64(const LAllocation& ptr) : LInstructionHelper(classOpcode) {
+    setOperand(0, ptr);
+  }
 
   const LAllocation* ptr() { return getOperand(0); }
   const MWasmLoad* mir() const { return mir_->toWasmLoad(); }
@@ -153,7 +166,8 @@ class LWasmAtomicStoreI64 : public LInst
   LIR_HEADER(WasmAtomicStoreI64);
 
   LWasmAtomicStoreI64(const LAllocation& ptr, const LInt64Allocation& value,
-                      const LDefinition& tmp) {
+                      const LDefinition& tmp)
+      : LInstructionHelper(classOpcode) {
     setOperand(0, ptr);
     setInt64Operand(1, value);
     setTemp(0, tmp);
Index: mozjs-60.8.0/js/src/jit/mips64/LIR-mips64.h
===================================================================
--- mozjs-60.8.0.orig/js/src/jit/mips64/LIR-mips64.h
+++ mozjs-60.8.0/js/src/jit/mips64/LIR-mips64.h
@@ -11,10 +11,18 @@ namespace js {
 namespace jit {
 
 class LUnbox : public LInstructionHelper<1, 1, 0> {
+ protected:
+  LUnbox(LNode::Opcode opcode, const LAllocation& input)
+      : LInstructionHelper(opcode) {
+    setOperand(0, input);
+  }
+
  public:
   LIR_HEADER(Unbox);
 
-  explicit LUnbox(const LAllocation& input) { setOperand(0, input); }
+  explicit LUnbox(const LAllocation& input) : LInstructionHelper(classOpcode) {
+    setOperand(0, input);
+  }
 
   static const size_t Input = 0;
 
@@ -29,7 +37,7 @@ class LUnboxFloatingPoint : public LUnbo
   LIR_HEADER(UnboxFloatingPoint);
 
   LUnboxFloatingPoint(const LAllocation& input, MIRType type)
-      : LUnbox(input), type_(type) {}
+      : LUnbox(classOpcode, input), type_(type) {}
 
   MIRType type() const { return type_; }
 };
@@ -39,18 +47,19 @@ class LDivOrModI64 : public LBinaryMath<
   LIR_HEADER(DivOrModI64)
 
   LDivOrModI64(const LAllocation& lhs, const LAllocation& rhs,
-               const LDefinition& temp) {
+               const LDefinition& temp)
+      : LBinaryMath(classOpcode) {
     setOperand(0, lhs);
     setOperand(1, rhs);
     setTemp(0, temp);
   }
 
   const LDefinition* remainder() { return getTemp(0); }
-
   MBinaryArithInstruction* mir() const {
     MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
     return static_cast<MBinaryArithInstruction*>(mir_);
   }
+
   bool canBeDivideByZero() const {
     if (mir_->isMod()) return mir_->toMod()->canBeDivideByZero();
     return mir_->toDiv()->canBeDivideByZero();
@@ -71,14 +80,14 @@ class LUDivOrModI64 : public LBinaryMath
   LIR_HEADER(UDivOrModI64);
 
   LUDivOrModI64(const LAllocation& lhs, const LAllocation& rhs,
-                const LDefinition& temp) {
+                const LDefinition& temp)
+      : LBinaryMath(classOpcode) {
     setOperand(0, lhs);
     setOperand(1, rhs);
     setTemp(0, temp);
   }
 
   const LDefinition* remainder() { return getTemp(0); }
-
   const char* extraName() const {
     return mir()->isTruncated() ? "Truncated" : nullptr;
   }
@@ -87,7 +96,6 @@ class LUDivOrModI64 : public LBinaryMath
     MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
     return static_cast<MBinaryArithInstruction*>(mir_);
   }
-
   bool canBeDivideByZero() const {
     if (mir_->isMod()) return mir_->toMod()->canBeDivideByZero();
     return mir_->toDiv()->canBeDivideByZero();
@@ -103,7 +111,10 @@ class LWasmTruncateToInt64 : public LIns
  public:
   LIR_HEADER(WasmTruncateToInt64);
 
-  explicit LWasmTruncateToInt64(const LAllocation& in) { setOperand(0, in); }
+  explicit LWasmTruncateToInt64(const LAllocation& in)
+      : LInstructionHelper(classOpcode) {
+    setOperand(0, in);
+  }
 
   MWasmTruncateToInt64* mir() const { return mir_->toWasmTruncateToInt64(); }
 };
@@ -112,7 +123,8 @@ class LInt64ToFloatingPoint : public LIn
  public:
   LIR_HEADER(Int64ToFloatingPoint);
 
-  explicit LInt64ToFloatingPoint(const LInt64Allocation& in) {
+  explicit LInt64ToFloatingPoint(const LInt64Allocation& in)
+      : LInstructionHelper(classOpcode) {
     setInt64Operand(0, in);
   }