Backed out changeset 8a1df23b6a3f (bug 1187094) for build failures
authorWes Kocher <wkocher@mozilla.com>
Fri, 24 Jul 2015 12:11:13 -0700
changeset 287885 be62b4f7b24cfad7039bd159553d0e49a8e853dc
parent 287884 2f4e74c011cfdc081f2899de5e8fa034187a37bd
child 287886 8bae34af92eaf3b9d63b867b45557f250d0cdbfb
push id934
push userraliiev@mozilla.com
push dateMon, 26 Oct 2015 12:58:05 +0000
treeherdermozilla-release@05704e35c1d0 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1187094
milestone42.0a1
backs out8a1df23b6a3f4f7498ae554dc12d505f5db67628
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out changeset 8a1df23b6a3f (bug 1187094) for build failures
js/src/jit/arm/Lowering-arm.cpp
js/src/jit/arm/Lowering-arm.h
js/src/jit/arm64/Lowering-arm64.cpp
js/src/jit/arm64/Lowering-arm64.h
js/src/jit/mips/Lowering-mips.cpp
js/src/jit/mips/Lowering-mips.h
js/src/jit/shared/Lowering-shared.cpp
js/src/jit/shared/Lowering-shared.h
js/src/jit/x86-shared/Lowering-x86-shared.cpp
js/src/jit/x86-shared/Lowering-x86-shared.h
--- a/js/src/jit/arm/Lowering-arm.cpp
+++ b/js/src/jit/arm/Lowering-arm.cpp
@@ -43,16 +43,41 @@ LIRGeneratorARM::useByteOpRegisterOrNonD
 
 LDefinition
 LIRGeneratorARM::tempByteOpRegister()
 {
     return temp();
 }
 
 void
+LIRGeneratorARM::lowerConstantDouble(double d, MInstruction* mir)
+{
+    define(new(alloc()) LDouble(d), mir);
+}
+
+void
+LIRGeneratorARM::lowerConstantFloat32(float d, MInstruction* mir)
+{
+    define(new(alloc()) LFloat32(d), mir);
+}
+
+void
+LIRGeneratorARM::visitConstant(MConstant* ins)
+{
+    if (ins->type() == MIRType_Double)
+        lowerConstantDouble(ins->value().toDouble(), ins);
+    else if (ins->type() == MIRType_Float32)
+        lowerConstantFloat32(ins->value().toDouble(), ins);
+    else if (ins->canEmitAtUses())
+        emitAtUses(ins);
+    else
+        LIRGeneratorShared::visitConstant(ins);
+}
+
+void
 LIRGeneratorARM::visitBox(MBox* box)
 {
     MDefinition* inner = box->getOperand(0);
 
     // If the box wrapped a double, it needs a new register.
     if (IsFloatingPointType(inner->type())) {
         defineBox(new(alloc()) LBoxFloatingPoint(useRegisterAtStart(inner), tempCopy(inner, 0),
                                                  inner->type()), box);
--- a/js/src/jit/arm/Lowering-arm.h
+++ b/js/src/jit/arm/Lowering-arm.h
@@ -61,31 +61,34 @@ class LIRGeneratorARM : public LIRGenera
     void lowerForCompFx4(LSimdBinaryCompFx4* ins, MSimdBinaryComp* mir,
                          MDefinition* lhs, MDefinition* rhs)
     {
         return lowerForFPU(ins, mir, lhs, rhs);
     }
 
     void lowerForBitAndAndBranch(LBitAndAndBranch* baab, MInstruction* mir,
                                  MDefinition* lhs, MDefinition* rhs);
+    void lowerConstantDouble(double d, MInstruction* ins);
+    void lowerConstantFloat32(float d, MInstruction* ins);
     void lowerTruncateDToInt32(MTruncateToInt32* ins);
     void lowerTruncateFToInt32(MTruncateToInt32* ins);
     void lowerDivI(MDiv* div);
     void lowerModI(MMod* mod);
     void lowerMulI(MMul* mul, MDefinition* lhs, MDefinition* rhs);
     void lowerUDiv(MDiv* div);
     void lowerUMod(MMod* mod);
     void visitPowHalf(MPowHalf* ins);
     void visitAsmJSNeg(MAsmJSNeg* ins);
 
     LTableSwitch* newLTableSwitch(const LAllocation& in, const LDefinition& inputCopy,
                                   MTableSwitch* ins);
     LTableSwitchV* newLTableSwitchV(MTableSwitch* ins);
 
   public:
+    void visitConstant(MConstant* ins);
     void visitBox(MBox* box);
     void visitUnbox(MUnbox* unbox);
     void visitReturn(MReturn* ret);
     void lowerPhi(MPhi* phi);
     void visitGuardShape(MGuardShape* ins);
     void visitGuardObjectGroup(MGuardObjectGroup* ins);
     void visitAsmJSUnsignedToDouble(MAsmJSUnsignedToDouble* ins);
     void visitAsmJSUnsignedToFloat32(MAsmJSUnsignedToFloat32* ins);
--- a/js/src/jit/arm64/Lowering-arm64.cpp
+++ b/js/src/jit/arm64/Lowering-arm64.cpp
@@ -38,16 +38,34 @@ LIRGeneratorARM64::useByteOpRegister(MDe
 
 LAllocation
 LIRGeneratorARM64::useByteOpRegisterOrNonDoubleConstant(MDefinition* mir)
 {
     MOZ_CRASH("useByteOpRegisterOrNonDoubleConstant");
 }
 
 void
+LIRGeneratorARM64::lowerConstantDouble(double d, MInstruction* mir)
+{
+    MOZ_CRASH("lowerConstantDouble");
+}
+
+void
+LIRGeneratorARM64::lowerConstantFloat32(float d, MInstruction* mir)
+{
+    MOZ_CRASH("lowerConstantFloat32");
+}
+
+void
+LIRGeneratorARM64::visitConstant(MConstant* ins)
+{
+    MOZ_CRASH("visitConstant");
+}
+
+void
 LIRGeneratorARM64::visitBox(MBox* box)
 {
     MOZ_CRASH("visitBox");
 }
 
 void
 LIRGeneratorARM64::visitUnbox(MUnbox* unbox)
 {
--- a/js/src/jit/arm64/Lowering-arm64.h
+++ b/js/src/jit/arm64/Lowering-arm64.h
@@ -65,32 +65,35 @@ class LIRGeneratorARM64 : public LIRGene
     void lowerForCompFx4(LSimdBinaryCompFx4* ins, MSimdBinaryComp* mir,
                          MDefinition* lhs, MDefinition* rhs)
     {
         return lowerForFPU(ins, mir, lhs, rhs);
     }
 
     void lowerForBitAndAndBranch(LBitAndAndBranch* baab, MInstruction* mir,
                                  MDefinition* lhs, MDefinition* rhs);
+    void lowerConstantDouble(double d, MInstruction* ins);
+    void lowerConstantFloat32(float d, MInstruction* ins);
     void lowerTruncateDToInt32(MTruncateToInt32* ins);
     void lowerTruncateFToInt32(MTruncateToInt32* ins);
     void lowerDivI(MDiv* div);
     void lowerModI(MMod* mod);
     void lowerMulI(MMul* mul, MDefinition* lhs, MDefinition* rhs);
     void lowerUDiv(MDiv* div);
     void lowerUMod(MMod* mod);
     void visitPowHalf(MPowHalf* ins);
     void visitAsmJSNeg(MAsmJSNeg* ins);
 
     LTableSwitchV* newLTableSwitchV(MTableSwitch* ins);
     LTableSwitch* newLTableSwitch(const LAllocation& in,
                                   const LDefinition& inputCopy,
                                   MTableSwitch* ins);
 
   public:
+    void visitConstant(MConstant* ins);
     void visitBox(MBox* box);
     void visitUnbox(MUnbox* unbox);
     void visitReturn(MReturn* ret);
     void lowerPhi(MPhi* phi);
     void visitGuardShape(MGuardShape* ins);
     void visitGuardObjectGroup(MGuardObjectGroup* ins);
     void visitAsmJSUnsignedToDouble(MAsmJSUnsignedToDouble* ins);
     void visitAsmJSUnsignedToFloat32(MAsmJSUnsignedToFloat32* ins);
--- a/js/src/jit/mips/Lowering-mips.cpp
+++ b/js/src/jit/mips/Lowering-mips.cpp
@@ -44,16 +44,41 @@ LIRGeneratorMIPS::useByteOpRegisterOrNon
 
 LDefinition
 LIRGeneratorMIPS::tempByteOpRegister()
 {
     return temp();
 }
 
 void
+LIRGeneratorMIPS::lowerConstantDouble(double d, MInstruction* mir)
+{
+    return define(new(alloc()) LDouble(d), mir);
+}
+
+void
+LIRGeneratorMIPS::lowerConstantFloat32(float d, MInstruction* mir)
+{
+    define(new(alloc()) LFloat32(d), mir);
+}
+
+void
+LIRGeneratorMIPS::visitConstant(MConstant* ins)
+{
+    if (ins->type() == MIRType_Double)
+        lowerConstantDouble(ins->value().toDouble(), ins);
+    else if (ins->type() == MIRType_Float32)
+        lowerConstantFloat32(ins->value().toDouble(), ins);
+    else if (ins->canEmitAtUses())
+        emitAtUses(ins);
+    else
+        LIRGeneratorShared::visitConstant(ins);
+}
+
+void
 LIRGeneratorMIPS::visitBox(MBox* box)
 {
     MDefinition* inner = box->getOperand(0);
 
     // If the box wrapped a double, it needs a new register.
     if (IsFloatingPointType(inner->type())) {
         defineBox(new(alloc()) LBoxFloatingPoint(useRegisterAtStart(inner),
                                                  tempCopy(inner, 0), inner->type()), box);
--- a/js/src/jit/mips/Lowering-mips.h
+++ b/js/src/jit/mips/Lowering-mips.h
@@ -61,31 +61,34 @@ class LIRGeneratorMIPS : public LIRGener
     void lowerForCompFx4(LSimdBinaryCompFx4* ins, MSimdBinaryComp* mir,
                          MDefinition* lhs, MDefinition* rhs)
     {
         return lowerForFPU(ins, mir, lhs, rhs);
     }
 
     void lowerForBitAndAndBranch(LBitAndAndBranch* baab, MInstruction* mir,
                                  MDefinition* lhs, MDefinition* rhs);
+    void lowerConstantDouble(double d, MInstruction* ins);
+    void lowerConstantFloat32(float d, MInstruction* ins);
     void lowerTruncateDToInt32(MTruncateToInt32* ins);
     void lowerTruncateFToInt32(MTruncateToInt32* ins);
     void lowerDivI(MDiv* div);
     void lowerModI(MMod* mod);
     void lowerMulI(MMul* mul, MDefinition* lhs, MDefinition* rhs);
     void lowerUDiv(MDiv* div);
     void lowerUMod(MMod* mod);
     void visitPowHalf(MPowHalf* ins);
     void visitAsmJSNeg(MAsmJSNeg* ins);
 
     LTableSwitch* newLTableSwitch(const LAllocation& in, const LDefinition& inputCopy,
                                   MTableSwitch* ins);
     LTableSwitchV* newLTableSwitchV(MTableSwitch* ins);
 
   public:
+    void visitConstant(MConstant* ins);
     void visitBox(MBox* box);
     void visitUnbox(MUnbox* unbox);
     void visitReturn(MReturn* ret);
     void lowerPhi(MPhi* phi);
     void visitGuardShape(MGuardShape* ins);
     void visitGuardObjectGroup(MGuardObjectGroup* ins);
     void visitAsmJSUnsignedToDouble(MAsmJSUnsignedToDouble* ins);
     void visitAsmJSUnsignedToFloat32(MAsmJSUnsignedToFloat32* ins);
--- a/js/src/jit/shared/Lowering-shared.cpp
+++ b/js/src/jit/shared/Lowering-shared.cpp
@@ -69,29 +69,18 @@ LIRGeneratorShared::ReorderCommutative(M
         *rhsp = lhs;
         *lhsp = rhs;
     }
 }
 
 void
 LIRGeneratorShared::visitConstant(MConstant* ins)
 {
-    if (!IsFloatingPointType(ins->type()) && ins->canEmitAtUses()) {
-        emitAtUses(ins);
-        return;
-    }
-
     const Value& v = ins->value();
     switch (ins->type()) {
-      case MIRType_Double:
-        define(new(alloc()) LDouble(v.toDouble()), ins);
-        break;
-      case MIRType_Float32:
-        define(new(alloc()) LFloat32(v.toDouble()), ins);
-        break;
       case MIRType_Boolean:
         define(new(alloc()) LInteger(v.toBoolean()), ins);
         break;
       case MIRType_Int32:
         define(new(alloc()) LInteger(v.toInt32()), ins);
         break;
       case MIRType_String:
         define(new(alloc()) LPointer(v.toString()), ins);
--- a/js/src/jit/shared/Lowering-shared.h
+++ b/js/src/jit/shared/Lowering-shared.h
@@ -203,23 +203,16 @@ class LIRGeneratorShared : public MDefin
 
     // Marks this instruction as needing to call into either the VM or GC. This
     // function may build a snapshot that captures the result of its own
     // instruction, and as such, should generally be called after define*().
     void assignSafepoint(LInstruction* ins, MInstruction* mir,
                          BailoutKind kind = Bailout_DuringVMCall);
 
   public:
-    void lowerConstantDouble(double d, MInstruction* mir) {
-        define(new(alloc()) LDouble(d), mir);
-    }
-    void lowerConstantFloat32(float f, MInstruction* mir) {
-        define(new(alloc()) LFloat32(f), mir);
-    }
-
     void visitConstant(MConstant* ins);
 
     // Whether to generate typed reads for element accesses with hole checks.
     static bool allowTypedElementHoleCheck() {
         return false;
     }
 
     // Whether to generate typed array accesses on statically known objects.
--- a/js/src/jit/x86-shared/Lowering-x86-shared.cpp
+++ b/js/src/jit/x86-shared/Lowering-x86-shared.cpp
@@ -349,16 +349,41 @@ LIRGeneratorX86Shared::lowerUrshD(MUrsh*
     LUse lhsUse = useRegisterAtStart(lhs);
     LAllocation rhsAlloc = rhs->isConstant() ? useOrConstant(rhs) : useFixed(rhs, ecx);
 
     LUrshD* lir = new(alloc()) LUrshD(lhsUse, rhsAlloc, tempCopy(lhs, 0));
     define(lir, mir);
 }
 
 void
+LIRGeneratorX86Shared::lowerConstantDouble(double d, MInstruction* mir)
+{
+    define(new(alloc()) LDouble(d), mir);
+}
+
+void
+LIRGeneratorX86Shared::lowerConstantFloat32(float f, MInstruction* mir)
+{
+    define(new(alloc()) LFloat32(f), mir);
+}
+
+void
+LIRGeneratorX86Shared::visitConstant(MConstant* ins)
+{
+    if (ins->type() == MIRType_Double)
+        lowerConstantDouble(ins->value().toDouble(), ins);
+    else if (ins->type() == MIRType_Float32)
+        lowerConstantFloat32(ins->value().toDouble(), ins);
+    else if (ins->canEmitAtUses())
+        emitAtUses(ins); // Emit non-double constants at their uses.
+    else
+        LIRGeneratorShared::visitConstant(ins);
+}
+
+void
 LIRGeneratorX86Shared::lowerTruncateDToInt32(MTruncateToInt32* ins)
 {
     MDefinition* opd = ins->input();
     MOZ_ASSERT(opd->type() == MIRType_Double);
 
     LDefinition maybeTemp = Assembler::HasSSE3() ? LDefinition::BogusTemp() : tempDouble();
     define(new(alloc()) LTruncateDToInt32(useRegister(opd), maybeTemp), ins);
 }
--- a/js/src/jit/x86-shared/Lowering-x86-shared.h
+++ b/js/src/jit/x86-shared/Lowering-x86-shared.h
@@ -35,23 +35,26 @@ class LIRGeneratorX86Shared : public LIR
     void lowerForFPU(LInstructionHelper<1, 2, Temps>* ins, MDefinition* mir, MDefinition* lhs,
                      MDefinition* rhs);
     void lowerForCompIx4(LSimdBinaryCompIx4* ins, MSimdBinaryComp* mir,
                          MDefinition* lhs, MDefinition* rhs);
     void lowerForCompFx4(LSimdBinaryCompFx4* ins, MSimdBinaryComp* mir,
                          MDefinition* lhs, MDefinition* rhs);
     void lowerForBitAndAndBranch(LBitAndAndBranch* baab, MInstruction* mir,
                                  MDefinition* lhs, MDefinition* rhs);
+    void visitConstant(MConstant* ins);
     void visitAsmJSNeg(MAsmJSNeg* ins);
     void lowerMulI(MMul* mul, MDefinition* lhs, MDefinition* rhs);
     void lowerDivI(MDiv* div);
     void lowerModI(MMod* mod);
     void lowerUDiv(MDiv* div);
     void lowerUMod(MMod* mod);
     void lowerUrshD(MUrsh* mir);
+    void lowerConstantDouble(double d, MInstruction* ins);
+    void lowerConstantFloat32(float d, MInstruction* ins);
     void lowerTruncateDToInt32(MTruncateToInt32* ins);
     void lowerTruncateFToInt32(MTruncateToInt32* ins);
     void visitSimdBinaryArith(MSimdBinaryArith* ins);
     void visitSimdSelect(MSimdSelect* ins);
     void visitSimdSplatX4(MSimdSplatX4* ins);
     void visitSimdValueX4(MSimdValueX4* ins);
     void lowerCompareExchangeTypedArrayElement(MCompareExchangeTypedArrayElement* ins,
                                                bool useI386ByteRegisters);