Bug 1444303 : [MIPS] Fix build failures after Bug 1425580 part 17; r=jandem

Gbp-Pq: Topic porting
Gbp-Pq: Name Bug-1444303-MIPS-Fix-build-failures-after-Bug-142558.patch

diff --git a/js/src/jit/mips-shared/LIR-mips-shared.h b/js/src/jit/mips-shared/LIR-mips-shared.h
index 780530b4458a1a7a089cfb60ca6a385a74085697..928c4f500169d81e7ba7670b3a06cb5d816bf2ad 100644 (file)
--- a/js/src/jit/mips-shared/LIR-mips-shared.h
+++ b/js/src/jit/mips-shared/LIR-mips-shared.h
@@ -15,7 +15,10 @@ class LWasmUint32ToDouble : public LInstructionHelper<1, 1, 0> {
  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 LInstructionHelper<1, 1, 0> {
  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 LInstructionHelper<1, 1, 1> {
   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 LInstructionHelper<1, 1, 0> {
 
  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 LInstructionHelper<1, 1, 2> {
 
   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 LInstructionHelper<0, 1, 2> {
   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 LInstructionHelper<0, 1, 2> {
   }
 
   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 LInstructionHelper<0, BOX_PIECES, 3> {
 
   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 details::LWasmLoadBase<NumDefs, 2> {
  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 details::LWasmLoadBase<NumDefs, 2> {
 
 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 LInstructionHelper<0, NumOps, 2> {
   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 LInstructionHelper<0, NumOps, 2> {
 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();
   }

diff --git a/js/src/jit/mips32/LIR-mips32.h b/js/src/jit/mips32/LIR-mips32.h
index d8a79d0b60dece39ee71e3e6d5a2873cffeaa257..929a83cdc24820c5217398c1ebe7e4ca22269c45 100644 (file)
--- a/js/src/jit/mips32/LIR-mips32.h
+++ b/js/src/jit/mips32/LIR-mips32.h
@@ -18,7 +18,7 @@ class LBoxFloatingPoint : public LInstructionHelper<2, 1, 1> {
 
   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<1, 2, 0> {
  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 LInstructionHelper<1, 2, 0> {
 
   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 LCallInstructionHelper<INT64_PIECES, 1, 0> {
  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 LInstructionHelper<INT64_PIECES, 1, 0> {
  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 LInstructionHelper<0, 1 + INT64_PIECES, 1> {
   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);

diff --git a/js/src/jit/mips64/LIR-mips64.h b/js/src/jit/mips64/LIR-mips64.h
index 948098293dc619d091e26d5d6548866234a4ad30..4e912f172a8690f5002ee1bdd674178bd09aa85c 100644 (file)
--- a/js/src/jit/mips64/LIR-mips64.h
+++ b/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 LUnbox {
   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<1> {
   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<1> {
   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<1> {
     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 LInstructionHelper<1, 1, 0> {
  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 LInstructionHelper<1, 1, 0> {
  public:
   LIR_HEADER(Int64ToFloatingPoint);
 
-  explicit LInt64ToFloatingPoint(const LInt64Allocation& in) {
+  explicit LInt64ToFloatingPoint(const LInt64Allocation& in)
+      : LInstructionHelper(classOpcode) {
     setInt64Operand(0, in);
   }