--- a/js/src/jit/mips-shared/Architecture-mips-shared.cpp
+++ b/js/src/jit/mips-shared/Architecture-mips-shared.cpp
@@ -25,29 +25,33 @@ get_mips_flags()
     uint32_t flags = HWCAP_MIPS;
 
 #if defined(JS_SIMULATOR_MIPS32) || defined(JS_SIMULATOR_MIPS64)
     flags |= HWCAP_FPU;
     flags |= HWCAP_R2;
 #else
 # ifdef __linux__
     FILE* fp = fopen("/proc/cpuinfo", "r");
-    if (!fp)
+    if (!fp) {
         return flags;
+    }
 
     char buf[1024];
     memset(buf, 0, sizeof(buf));
     (void)fread(buf, sizeof(char), sizeof(buf) - 1, fp);
     fclose(fp);
-    if (strstr(buf, "FPU"))
+    if (strstr(buf, "FPU")) {
         flags |= HWCAP_FPU;
-    if (strstr(buf, "Loongson"))
+    }
+    if (strstr(buf, "Loongson")) {
         flags |= HWCAP_LOONGSON;
-    if (strstr(buf, "mips32r2") || strstr(buf, "mips64r2"))
+    }
+    if (strstr(buf, "mips32r2") || strstr(buf, "mips64r2")) {
         flags |= HWCAP_R2;
+    }
 # endif
 #endif // JS_SIMULATOR_MIPS32 || JS_SIMULATOR_MIPS64
     return flags;
 }
 
 static bool check_fpu()
 {
     return mips_private::Flags & HWCAP_FPU;
@@ -70,18 +74,19 @@ namespace mips_private {
     bool isLoongson = check_loongson();
     bool hasR2 = check_r2();
 }
 
 Registers::Code
 Registers::FromName(const char* name)
 {
     for (size_t i = 0; i < Total; i++) {
-        if (strcmp(GetName(i), name) == 0)
+        if (strcmp(GetName(i), name) == 0) {
             return Code(i);
+        }
     }
 
     return Invalid;
 }
 
 } // namespace ion
 } // namespace js
 

--- a/js/src/jit/mips-shared/Assembler-mips-shared.cpp
+++ b/js/src/jit/mips-shared/Assembler-mips-shared.cpp
@@ -118,18 +118,19 @@ AssemblerMIPSShared::reserve(size_t size
 
 bool
 AssemblerMIPSShared::swapBuffer(wasm::Bytes& bytes)
 {
     // For now, specialize to the one use case. As long as wasm::Bytes is a
     // Vector, not a linked-list of chunks, there's not much we can do other
     // than copy.
     MOZ_ASSERT(bytes.empty());
-    if (!bytes.resize(bytesNeeded()))
+    if (!bytes.resize(bytesNeeded())) {
         return false;
+    }
     m_buffer.executableCopy(bytes.begin());
     return true;
 }
 
 uint32_t
 AssemblerMIPSShared::actualIndex(uint32_t idx_) const
 {
     return idx_;
@@ -139,25 +140,27 @@ uint8_t*
 AssemblerMIPSShared::PatchableJumpAddress(JitCode* code, uint32_t pe_)
 {
     return code->raw() + pe_;
 }
 
 void
 AssemblerMIPSShared::copyJumpRelocationTable(uint8_t* dest)
 {
-    if (jumpRelocations_.length())
+    if (jumpRelocations_.length()) {
         memcpy(dest, jumpRelocations_.buffer(), jumpRelocations_.length());
+    }
 }
 
 void
 AssemblerMIPSShared::copyDataRelocationTable(uint8_t* dest)
 {
-    if (dataRelocations_.length())
+    if (dataRelocations_.length()) {
         memcpy(dest, dataRelocations_.buffer(), dataRelocations_.length());
+    }
 }
 
 AssemblerMIPSShared::Condition
 AssemblerMIPSShared::InvertCondition(Condition cond)
 {
     switch (cond) {
       case Equal:
         return NotEqual;
@@ -277,18 +280,19 @@ AssemblerMIPSShared::bytesNeeded() const
            jumpRelocationTableBytes() +
            dataRelocationTableBytes();
 }
 
 // write a blob of binary into the instruction stream
 BufferOffset
 AssemblerMIPSShared::writeInst(uint32_t x, uint32_t* dest)
 {
-    if (dest == nullptr)
+    if (dest == nullptr) {
         return m_buffer.putInt(x);
+    }
 
     WriteInstStatic(x, dest);
     return BufferOffset();
 }
 
 void
 AssemblerMIPSShared::WriteInstStatic(uint32_t x, uint32_t* dest)
 {
@@ -306,25 +310,27 @@ AssemblerMIPSShared::haltingAlign(int al
 BufferOffset
 AssemblerMIPSShared::nopAlign(int alignment)
 {
     BufferOffset ret;
     MOZ_ASSERT(m_buffer.isAligned(4));
     if (alignment == 8) {
         if (!m_buffer.isAligned(alignment)) {
             BufferOffset tmp = as_nop();
-            if (!ret.assigned())
+            if (!ret.assigned()) {
                 ret = tmp;
+            }
         }
     } else {
         MOZ_ASSERT((alignment & (alignment - 1)) == 0);
         while (size() & (alignment - 1)) {
             BufferOffset tmp = as_nop();
-            if (!ret.assigned())
+            if (!ret.assigned()) {
                 ret = tmp;
+            }
         }
     }
     return ret;
 }
 
 BufferOffset
 AssemblerMIPSShared::as_nop()
 {
@@ -408,18 +414,19 @@ AssemblerMIPSShared::as_b(BOffImm16 off)
     spew("b      %d", off.decode());
     BufferOffset bo = writeInst(InstImm(op_beq, zero, zero, off).encode());
     return bo;
 }
 
 InstImm
 AssemblerMIPSShared::getBranchCode(JumpOrCall jumpOrCall)
 {
-    if (jumpOrCall == BranchIsCall)
+    if (jumpOrCall == BranchIsCall) {
         return InstImm(op_regimm, zero, rt_bgezal, BOffImm16(0));
+    }
 
     return InstImm(op_beq, zero, zero, BOffImm16(0));
 }
 
 InstImm
 AssemblerMIPSShared::getBranchCode(Register s, Register t, Condition c)
 {
     MOZ_ASSERT(c == AssemblerMIPSShared::Equal || c == AssemblerMIPSShared::NotEqual);
@@ -1865,18 +1872,19 @@ AssemblerMIPSShared::bind(Label* label, 
     BufferOffset dest = boff.assigned() ? boff : nextOffset();
     if (label->used()) {
         int32_t next;
 
         // A used label holds a link to branch that uses it.
         BufferOffset b(label);
         do {
             // Even a 0 offset may be invalid if we're out of memory.
-            if (oom())
+            if (oom()) {
                 return;
+            }
 
             Instruction* inst = editSrc(b);
 
             // Second word holds a pointer to the next branch in label's chain.
             next = inst[1].encode();
             bind(reinterpret_cast<InstImm*>(inst), b.getOffset(), dest.getOffset());
 
             b = BufferOffset(next);
@@ -1953,18 +1961,19 @@ AssemblerMIPSShared::PatchWrite_Imm32(Co
     // end up being the call instruction.
     *(raw - 1) = imm.value;
 }
 
 uint8_t*
 AssemblerMIPSShared::NextInstruction(uint8_t* inst_, uint32_t* count)
 {
     Instruction* inst = reinterpret_cast<Instruction*>(inst_);
-    if (count != nullptr)
+    if (count != nullptr) {
         *count += sizeof(Instruction);
+    }
     return reinterpret_cast<uint8_t*>(inst->next());
 }
 
 // Since there are no pools in MIPS implementation, this should be simple.
 Instruction*
 Instruction::next()
 {
     return this + 1;
@@ -2005,20 +2014,21 @@ InstImm AssemblerMIPSShared::invertBranc
 
         MOZ_CRASH("Error creating long branch.");
 
       case op_cop1:
         MOZ_ASSERT(branch.extractRS() == rs_bc1 >> RSShift);
 
         branch.setBOffImm16(skipOffset);
         rt = branch.extractRT();
-        if (rt & 0x1)
+        if (rt & 0x1) {
             branch.setRT((RTField) ((rt & ~0x1) << RTShift));
-        else
+        } else {
             branch.setRT((RTField) ((rt | 0x1) << RTShift));
+        }
         return branch;
       default:
         MOZ_CRASH("Error creating long branch.");
     }
 }
 
 void
 AssemblerMIPSShared::ToggleToJmp(CodeLocationLabel inst_)

--- a/js/src/jit/mips-shared/Assembler-mips-shared.h
+++ b/js/src/jit/mips-shared/Assembler-mips-shared.h
@@ -482,20 +482,22 @@ class BOffImm16
 
     explicit BOffImm16(int offset)
       : data ((offset - 4) >> 2 & Imm16Mask)
     {
         MOZ_ASSERT((offset & 0x3) == 0);
         MOZ_ASSERT(IsInRange(offset));
     }
     static bool IsInRange(int offset) {
-        if ((offset - 4) < int(unsigned(INT16_MIN) << 2))
+        if ((offset - 4) < int(unsigned(INT16_MIN) << 2)) {
             return false;
-        if ((offset - 4) > (INT16_MAX << 2))
+        }
+        if ((offset - 4) > (INT16_MAX << 2)) {
             return false;
+        }
         return true;
     }
     static const uint32_t INVALID = 0x00020000;
     BOffImm16()
       : data(INVALID)
     { }
 
     bool isInvalid() {
@@ -523,20 +525,22 @@ class JOffImm26
 
     explicit JOffImm26(int offset)
       : data ((offset - 4) >> 2 & Imm26Mask)
     {
         MOZ_ASSERT((offset & 0x3) == 0);
         MOZ_ASSERT(IsInRange(offset));
     }
     static bool IsInRange(int offset) {
-        if ((offset - 4) < -536870912)
+        if ((offset - 4) < -536870912) {
             return false;
-        if ((offset - 4) > 536870908)
+        }
+        if ((offset - 4) > 536870908) {
             return false;
+        }
         return true;
     }
     static const uint32_t INVALID = 0x20000000;
     JOffImm26()
       : data(INVALID)
     { }
 
     bool isInvalid() {
@@ -723,28 +727,30 @@ PatchJump(CodeLocationJump& jump_, CodeL
 
 static constexpr int32_t SliceSize = 1024;
 typedef js::jit::AssemblerBuffer<SliceSize, Instruction> MIPSBuffer;
 
 class MIPSBufferWithExecutableCopy : public MIPSBuffer
 {
   public:
     void executableCopy(uint8_t* buffer) {
-        if (this->oom())
+        if (this->oom()) {
             return;
+        }
 
         for (Slice* cur = head; cur != nullptr; cur = cur->getNext()) {
             memcpy(buffer, &cur->instructions, cur->length());
             buffer += cur->length();
         }
     }
 
     bool appendRawCode(const uint8_t* code, size_t numBytes) {
-        if (this->oom())
+        if (this->oom()) {
             return false;
+        }
         while (numBytes > SliceSize) {
             this->putBytes(SliceSize, code);
             numBytes -= SliceSize;
             code += SliceSize;
         }
         this->putBytes(numBytes, code);
         return !this->oom();
     }
@@ -896,27 +902,29 @@ class AssemblerMIPSShared : public Assem
     void writeRelocation(BufferOffset src) {
         jumpRelocations_.writeUnsigned(src.getOffset());
     }
 
     // As opposed to x86/x64 version, the data relocation has to be executed
     // before to recover the pointer, and not after.
     void writeDataRelocation(ImmGCPtr ptr) {
         if (ptr.value) {
-            if (gc::IsInsideNursery(ptr.value))
+            if (gc::IsInsideNursery(ptr.value)) {
                 embedsNurseryPointers_ = true;
+            }
             dataRelocations_.writeUnsigned(nextOffset().getOffset());
         }
     }
 
     void assertNoGCThings() const {
 #ifdef DEBUG
         MOZ_ASSERT(dataRelocations_.length() == 0);
-        for (auto& j : jumps_)
+        for (auto& j : jumps_) {
             MOZ_ASSERT(j.kind == RelocationKind::HARDCODED);
+        }
 #endif
     }
 
   public:
     bool oom() const;
 
     void setPrinter(Sprinter* sp) {
 #ifdef JS_JITSPEW
@@ -943,18 +951,19 @@ class AssemblerMIPSShared : public Assem
 #ifdef JS_JITSPEW
     MOZ_COLD void spew(const char* fmt, va_list va) MOZ_FORMAT_PRINTF(2, 0) {
         // Buffer to hold the formatted string. Note that this may contain
         // '%' characters, so do not pass it directly to printf functions.
         char buf[200];
 
         int i = VsprintfLiteral(buf, fmt, va);
         if (i > -1) {
-            if (printer)
+            if (printer) {
                 printer->printf("%s\n", buf);
+            }
             js::jit::JitSpew(js::jit::JitSpew_Codegen, "%s", buf);
         }
     }
 #endif
 
     static const Register getStackPointer() {
         return StackPointer;
     }
@@ -1282,18 +1291,19 @@ class AssemblerMIPSShared : public Assem
     static bool HasRoundInstruction(RoundingMode mode) {
         return false;
     }
 
   protected:
     InstImm invertBranch(InstImm branch, BOffImm16 skipOffset);
     void addPendingJump(BufferOffset src, ImmPtr target, RelocationKind kind) {
         enoughMemory_ &= jumps_.append(RelativePatch(src, target.value, kind));
-        if (kind == RelocationKind::JITCODE)
+        if (kind == RelocationKind::JITCODE) {
             writeRelocation(src);
+        }
     }
 
     void addLongJump(BufferOffset src, BufferOffset dst) {
         CodeLabel cl;
         cl.patchAt()->bind(src.getOffset());
         cl.target()->bind(dst.getOffset());
         cl.setLinkMode(CodeLabel::JumpImmediate);
         addCodeLabel(std::move(cl));
@@ -1564,22 +1574,24 @@ class InstGS : public Instruction
     InstGS(Opcode op, Register rs, FloatRegister rt, Imm8 off, FunctionField ff)
       : Instruction(op | RS(rs) | RT(rt) | off.encode(6) | ff)
     { }
 };
 
 inline bool
 IsUnaligned(const wasm::MemoryAccessDesc& access)
 {
-    if (!access.align())
+    if (!access.align()) {
         return false;
+    }
 
 #ifdef JS_CODEGEN_MIPS32
-    if (access.type() == Scalar::Int64 && access.align() >= 4)
+    if (access.type() == Scalar::Int64 && access.align() >= 4) {
         return false;
+    }
 #endif
 
     return access.align() < access.byteSize();
 }
 
 } // namespace jit
 } // namespace js
 

--- a/js/src/jit/mips-shared/AtomicOperations-mips-shared.h
+++ b/js/src/jit/mips-shared/AtomicOperations-mips-shared.h
@@ -169,29 +169,31 @@ namespace js { namespace jit {
 #if defined(JS_CODEGEN_MIPS32)
 
 template<>
 inline int64_t
 js::jit::AtomicOperations::compareExchangeSeqCst(int64_t* addr, int64_t oldval, int64_t newval)
 {
     AddressGuard guard(addr);
     int64_t val = *addr;
-    if (val == oldval)
+    if (val == oldval) {
         *addr = newval;
+    }
     return val;
 }
 
 template<>
 inline uint64_t
 js::jit::AtomicOperations::compareExchangeSeqCst(uint64_t* addr, uint64_t oldval, uint64_t newval)
 {
     AddressGuard guard(addr);
     uint64_t val = *addr;
-    if (val == oldval)
+    if (val == oldval) {
         *addr = newval;
+    }
     return val;
 }
 
 #endif
 
 } }
 
 template<typename T>

--- a/js/src/jit/mips-shared/CodeGenerator-mips-shared.cpp
+++ b/js/src/jit/mips-shared/CodeGenerator-mips-shared.cpp
@@ -39,20 +39,22 @@ using JS::ToInt32;
 CodeGeneratorMIPSShared::CodeGeneratorMIPSShared(MIRGenerator* gen, LIRGraph* graph, MacroAssembler* masm)
   : CodeGeneratorShared(gen, graph, masm)
 {
 }
 
 Operand
 CodeGeneratorMIPSShared::ToOperand(const LAllocation& a)
 {
-    if (a.isGeneralReg())
+    if (a.isGeneralReg()) {
         return Operand(a.toGeneralReg()->reg());
-    if (a.isFloatReg())
+    }
+    if (a.isFloatReg()) {
         return Operand(a.toFloatReg()->reg());
+    }
     return Operand(masm.getStackPointer(), ToStackOffset(&a));
 }
 
 Operand
 CodeGeneratorMIPSShared::ToOperand(const LAllocation* a)
 {
     return ToOperand(*a);
 }
@@ -78,20 +80,21 @@ CodeGeneratorMIPSShared::ToOperandOrRegi
 #endif
 
 void
 CodeGeneratorMIPSShared::branchToBlock(Assembler::FloatFormat fmt, FloatRegister lhs, FloatRegister rhs,
                                        MBasicBlock* mir, Assembler::DoubleCondition cond)
 {
     // Skip past trivial blocks.
     Label* label = skipTrivialBlocks(mir)->lir()->label();
-    if (fmt == Assembler::DoubleFloat)
+    if (fmt == Assembler::DoubleFloat) {
         masm.branchDouble(cond, lhs, rhs, label);
-    else
+    } else {
         masm.branchFloat(cond, lhs, rhs, label);
+    }
 }
 
 FrameSizeClass
 FrameSizeClass::FromDepth(uint32_t frameDepth)
 {
     return FrameSizeClass::None();
 }
 
@@ -131,30 +134,32 @@ CodeGenerator::visitCompare(LCompare* co
     const LAllocation* left = comp->getOperand(0);
     const LAllocation* right = comp->getOperand(1);
     const LDefinition* def = comp->getDef(0);
 
 #ifdef JS_CODEGEN_MIPS64
     if (mir->compareType() == MCompare::Compare_Object ||
         mir->compareType() == MCompare::Compare_Symbol)
     {
-        if (right->isGeneralReg())
+        if (right->isGeneralReg()) {
             masm.cmpPtrSet(cond, ToRegister(left), ToRegister(right), ToRegister(def));
-        else
+        } else {
             masm.cmpPtrSet(cond, ToRegister(left), ToAddress(right), ToRegister(def));
+        }
         return;
     }
 #endif
 
-    if (right->isConstant())
+    if (right->isConstant()) {
         masm.cmp32Set(cond, ToRegister(left), Imm32(ToInt32(right)), ToRegister(def));
-    else if (right->isGeneralReg())
+    } else if (right->isGeneralReg()) {
         masm.cmp32Set(cond, ToRegister(left), ToRegister(right), ToRegister(def));
-    else
+    } else {
         masm.cmp32Set(cond, ToRegister(left), ToAddress(right), ToRegister(def));
+    }
 }
 
 void
 CodeGenerator::visitCompareAndBranch(LCompareAndBranch* comp)
 {
     MCompare* mir = comp->cmpMir();
     Assembler::Condition cond = JSOpToCondition(mir->compareType(), comp->jsop());
 
@@ -184,18 +189,19 @@ CodeGenerator::visitCompareAndBranch(LCo
         emitBranch(ToRegister(comp->left()), ScratchRegister, cond,
                    comp->ifTrue(), comp->ifFalse());
     }
 }
 
 bool
 CodeGeneratorMIPSShared::generateOutOfLineCode()
 {
-    if (!CodeGeneratorShared::generateOutOfLineCode())
+    if (!CodeGeneratorShared::generateOutOfLineCode()) {
         return false;
+    }
 
     if (deoptLabel_.used()) {
         // All non-table-based bailouts will go here.
         masm.bind(&deoptLabel_);
 
         // Push the frame size, so the handler can recover the IonScript.
         // Frame size is stored in 'ra' and pushed by GenerateBailoutThunk
         // We have to use 'ra' because generateBailoutTable will implicitly do
@@ -207,18 +213,19 @@ CodeGeneratorMIPSShared::generateOutOfLi
     }
 
     return !masm.oom();
 }
 
 void
 CodeGeneratorMIPSShared::bailoutFrom(Label* label, LSnapshot* snapshot)
 {
-    if (masm.bailed())
+    if (masm.bailed()) {
         return;
+    }
 
     MOZ_ASSERT_IF(!masm.oom(), label->used());
     MOZ_ASSERT_IF(!masm.oom(), !label->bound());
 
     encode(snapshot);
 
     // Though the assembler doesn't track all frame pushes, at least make sure
     // the known value makes sense. We can't use bailout tables if the stack
@@ -245,34 +252,36 @@ CodeGeneratorMIPSShared::bailout(LSnapsh
 void
 CodeGenerator::visitMinMaxD(LMinMaxD* ins)
 {
     FloatRegister first = ToFloatRegister(ins->first());
     FloatRegister second = ToFloatRegister(ins->second());
 
     MOZ_ASSERT(first == ToFloatRegister(ins->output()));
 
-    if (ins->mir()->isMax())
+    if (ins->mir()->isMax()) {
         masm.maxDouble(second, first, true);
-    else
+    } else {
         masm.minDouble(second, first, true);
+    }
 }
 
 void
 CodeGenerator::visitMinMaxF(LMinMaxF* ins)
 {
     FloatRegister first = ToFloatRegister(ins->first());
     FloatRegister second = ToFloatRegister(ins->second());
 
     MOZ_ASSERT(first == ToFloatRegister(ins->output()));
 
-    if (ins->mir()->isMax())
+    if (ins->mir()->isMax()) {
         masm.maxFloat32(second, first, true);
-    else
+    } else {
         masm.minFloat32(second, first, true);
+    }
 }
 
 void
 CodeGenerator::visitAbsD(LAbsD* ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
     MOZ_ASSERT(input == ToFloatRegister(ins->output()));
     masm.as_absd(input, input);
@@ -308,28 +317,30 @@ CodeGenerator::visitAddI(LAddI* ins)
     const LAllocation* lhs = ins->getOperand(0);
     const LAllocation* rhs = ins->getOperand(1);
     const LDefinition* dest = ins->getDef(0);
 
     MOZ_ASSERT(rhs->isConstant() || rhs->isGeneralReg());
 
     // If there is no snapshot, we don't need to check for overflow
     if (!ins->snapshot()) {
-        if (rhs->isConstant())
+        if (rhs->isConstant()) {
             masm.ma_addu(ToRegister(dest), ToRegister(lhs), Imm32(ToInt32(rhs)));
-        else
+        } else {
             masm.as_addu(ToRegister(dest), ToRegister(lhs), ToRegister(rhs));
+        }
         return;
     }
 
     Label overflow;
-    if (rhs->isConstant())
+    if (rhs->isConstant()) {
         masm.ma_addTestOverflow(ToRegister(dest), ToRegister(lhs), Imm32(ToInt32(rhs)), &overflow);
-    else
+    } else {
         masm.ma_addTestOverflow(ToRegister(dest), ToRegister(lhs), ToRegister(rhs), &overflow);
+    }
 
     bailoutFrom(&overflow, ins->snapshot());
 }
 
 void
 CodeGenerator::visitAddI64(LAddI64* lir)
 {
     const LInt64Allocation lhs = lir->getInt64Operand(LAddI64::Lhs);
@@ -351,28 +362,30 @@ CodeGenerator::visitSubI(LSubI* ins)
     const LAllocation* lhs = ins->getOperand(0);
     const LAllocation* rhs = ins->getOperand(1);
     const LDefinition* dest = ins->getDef(0);
 
     MOZ_ASSERT(rhs->isConstant() || rhs->isGeneralReg());
 
     // If there is no snapshot, we don't need to check for overflow
     if (!ins->snapshot()) {
-        if (rhs->isConstant())
+        if (rhs->isConstant()) {
             masm.ma_subu(ToRegister(dest), ToRegister(lhs), Imm32(ToInt32(rhs)));
-        else
+        } else {
             masm.as_subu(ToRegister(dest), ToRegister(lhs), ToRegister(rhs));
+        }
         return;
     }
 
     Label overflow;
-    if (rhs->isConstant())
+    if (rhs->isConstant()) {
         masm.ma_subTestOverflow(ToRegister(dest), ToRegister(lhs), Imm32(ToInt32(rhs)), &overflow);
-    else
+    } else {
         masm.ma_subTestOverflow(ToRegister(dest), ToRegister(lhs), ToRegister(rhs), &overflow);
+    }
 
     bailoutFrom(&overflow, ins->snapshot());
 }
 
 void
 CodeGenerator::visitSubI64(LSubI64* lir)
 {
     const LInt64Allocation lhs = lir->getInt64Operand(LSubI64::Lhs);
@@ -405,18 +418,19 @@ CodeGenerator::visitMulI(LMulI* ins)
         // Bailout on -0.0
         if (mul->canBeNegativeZero() && constant <= 0) {
             Assembler::Condition cond = (constant == 0) ? Assembler::LessThan : Assembler::Equal;
             bailoutCmp32(cond, src, Imm32(0), ins->snapshot());
         }
 
         switch (constant) {
           case -1:
-            if (mul->canOverflow())
+            if (mul->canOverflow()) {
                 bailoutCmp32(Assembler::Equal, src, Imm32(INT32_MIN), ins->snapshot());
+            }
 
             masm.ma_negu(dest, src);
             break;
           case 0:
             masm.move32(Imm32(0), dest);
             break;
           case 1:
             masm.move32(src, dest);
@@ -447,18 +461,19 @@ CodeGenerator::visitMulI(LMulI* ins)
 
                 // If the constant cannot be encoded as (1<<C1), see if it can
                 // be encoded as (1<<C1) | (1<<C2), which can be computed
                 // using an add and a shift.
                 uint32_t shift_rest = FloorLog2(rest);
                 if (src != dest && (1u << shift_rest) == rest) {
                     masm.ma_sll(dest, src, Imm32(shift - shift_rest));
                     masm.add32(src, dest);
-                    if (shift_rest != 0)
+                    if (shift_rest != 0) {
                         masm.ma_sll(dest, dest, Imm32(shift_rest));
+                    }
                     return;
                 }
             }
 
             if (mul->canOverflow() && (constant > 0) && (src != dest)) {
                 // To stay on the safe side, only optimize things that are a
                 // power of 2.
 
@@ -850,64 +865,70 @@ void
 CodeGenerator::visitBitOpI(LBitOpI* ins)
 {
     const LAllocation* lhs = ins->getOperand(0);
     const LAllocation* rhs = ins->getOperand(1);
     const LDefinition* dest = ins->getDef(0);
     // all of these bitops should be either imm32's, or integer registers.
     switch (ins->bitop()) {
       case JSOP_BITOR:
-        if (rhs->isConstant())
+        if (rhs->isConstant()) {
             masm.ma_or(ToRegister(dest), ToRegister(lhs), Imm32(ToInt32(rhs)));
-        else
+        } else {
             masm.as_or(ToRegister(dest), ToRegister(lhs), ToRegister(rhs));
+        }
         break;
       case JSOP_BITXOR:
-        if (rhs->isConstant())
+        if (rhs->isConstant()) {
             masm.ma_xor(ToRegister(dest), ToRegister(lhs), Imm32(ToInt32(rhs)));
-        else
+        } else {
             masm.as_xor(ToRegister(dest), ToRegister(lhs), ToRegister(rhs));
+        }
         break;
       case JSOP_BITAND:
-        if (rhs->isConstant())
+        if (rhs->isConstant()) {
             masm.ma_and(ToRegister(dest), ToRegister(lhs), Imm32(ToInt32(rhs)));
-        else
+        } else {
             masm.as_and(ToRegister(dest), ToRegister(lhs), ToRegister(rhs));
+        }
         break;
       default:
         MOZ_CRASH("unexpected binary opcode");
     }
 }
 
 void
 CodeGenerator::visitBitOpI64(LBitOpI64* lir)
 {
     const LInt64Allocation lhs = lir->getInt64Operand(LBitOpI64::Lhs);
     const LInt64Allocation rhs = lir->getInt64Operand(LBitOpI64::Rhs);
 
     MOZ_ASSERT(ToOutRegister64(lir) == ToRegister64(lhs));
 
     switch (lir->bitop()) {
       case JSOP_BITOR:
-        if (IsConstant(rhs))
+        if (IsConstant(rhs)) {
             masm.or64(Imm64(ToInt64(rhs)), ToRegister64(lhs));
-        else
+        } else {
             masm.or64(ToOperandOrRegister64(rhs), ToRegister64(lhs));
+        }
         break;
       case JSOP_BITXOR:
-        if (IsConstant(rhs))
+        if (IsConstant(rhs)) {
             masm.xor64(Imm64(ToInt64(rhs)), ToRegister64(lhs));
-        else
+        } else {
             masm.xor64(ToOperandOrRegister64(rhs), ToRegister64(lhs));
+        }
         break;
       case JSOP_BITAND:
-        if (IsConstant(rhs))
+        if (IsConstant(rhs)) {
             masm.and64(Imm64(ToInt64(rhs)), ToRegister64(lhs));
-        else
+        } else {
             masm.and64(ToOperandOrRegister64(rhs), ToRegister64(lhs));
+        }
         break;
       default:
         MOZ_CRASH("unexpected binary opcode");
     }
 }
 
 void
 CodeGenerator::visitShiftI(LShiftI* ins)
@@ -915,34 +936,37 @@ CodeGenerator::visitShiftI(LShiftI* ins)
     Register lhs = ToRegister(ins->lhs());
     const LAllocation* rhs = ins->rhs();
     Register dest = ToRegister(ins->output());
 
     if (rhs->isConstant()) {
         int32_t shift = ToInt32(rhs) & 0x1F;
         switch (ins->bitop()) {
           case JSOP_LSH:
-            if (shift)
+            if (shift) {
                 masm.ma_sll(dest, lhs, Imm32(shift));
-            else
+            } else {
                 masm.move32(lhs, dest);
+            }
             break;
           case JSOP_RSH:
-            if (shift)
+            if (shift) {
                 masm.ma_sra(dest, lhs, Imm32(shift));
-            else
+            } else {
                 masm.move32(lhs, dest);
+            }
             break;
           case JSOP_URSH:
             if (shift) {
                 masm.ma_srl(dest, lhs, Imm32(shift));
             } else {
                 // x >>> 0 can overflow.
-                if (ins->mir()->toUrsh()->fallible())
+                if (ins->mir()->toUrsh()->fallible()) {
                     bailoutCmp32(Assembler::LessThan, lhs, Imm32(0), ins->snapshot());
+                }
                 masm.move32(lhs, dest);
             }
             break;
           default:
             MOZ_CRASH("Unexpected shift op");
         }
     } else {
         // The shift amounts should be AND'ed into the 0-31 range
@@ -975,26 +999,29 @@ CodeGenerator::visitShiftI64(LShiftI64* 
     LAllocation* rhs = lir->getOperand(LShiftI64::Rhs);
 
     MOZ_ASSERT(ToOutRegister64(lir) == ToRegister64(lhs));
 
     if (rhs->isConstant()) {
         int32_t shift = int32_t(rhs->toConstant()->toInt64() & 0x3F);
         switch (lir->bitop()) {
           case JSOP_LSH:
-            if (shift)
+            if (shift) {
                 masm.lshift64(Imm32(shift), ToRegister64(lhs));
+            }
             break;
           case JSOP_RSH:
-            if (shift)
+            if (shift) {
                 masm.rshift64Arithmetic(Imm32(shift), ToRegister64(lhs));
+            }
             break;
           case JSOP_URSH:
-            if (shift)
+            if (shift) {
                 masm.rshift64(Imm32(shift), ToRegister64(lhs));
+            }
             break;
           default:
             MOZ_CRASH("Unexpected shift op");
         }
         return;
     }
 
     switch (lir->bitop()) {
@@ -1029,25 +1056,27 @@ CodeGenerator::visitRotateI64(LRotateI64
     if (count->isConstant()) {
         int32_t c = int32_t(count->toConstant()->toInt64() & 0x3F);
         if (!c) {
 #ifdef JS_CODEGEN_MIPS32
             masm.move64(input, output);
 #endif
             return;
         }
-        if (mir->isLeftRotate())
+        if (mir->isLeftRotate()) {
             masm.rotateLeft64(Imm32(c), input, output, temp);
-        else
+        } else {
             masm.rotateRight64(Imm32(c), input, output, temp);
+        }
     } else {
-        if (mir->isLeftRotate())
+        if (mir->isLeftRotate()) {
             masm.rotateLeft64(ToRegister(count), input, output, temp);
-        else
+        } else {
             masm.rotateRight64(ToRegister(count), input, output, temp);
+        }
     }
 }
 
 void
 CodeGenerator::visitUrshD(LUrshD* ins)
 {
     Register lhs = ToRegister(ins->lhs());
     Register temp = ToRegister(ins->temp());
@@ -1124,18 +1153,19 @@ CodeGenerator::visitPowHalfD(LPowHalfD* 
     masm.as_sqrtd(output, output);
 
     masm.bind(&done);
 }
 
 MoveOperand
 CodeGeneratorMIPSShared::toMoveOperand(LAllocation a) const
 {
-    if (a.isGeneralReg())
+    if (a.isGeneralReg()) {
         return MoveOperand(ToRegister(a));
+    }
     if (a.isFloatReg()) {
         return MoveOperand(ToFloatRegister(a));
     }
     int32_t offset = ToStackOffset(a);
     MOZ_ASSERT((offset & 3) == 0);
 
     return MoveOperand(StackPointer, offset);
 }
@@ -1519,33 +1549,35 @@ CodeGenerator::visitWasmTruncateToInt32(
 
     MOZ_ASSERT(fromType == MIRType::Double || fromType == MIRType::Float32);
 
     auto* ool = new (alloc()) OutOfLineWasmTruncateCheck(mir, input, output);
     addOutOfLineCode(ool, mir);
 
     Label* oolEntry = ool->entry();
     if (mir->isUnsigned()) {
-        if (fromType == MIRType::Double)
+        if (fromType == MIRType::Double) {
             masm.wasmTruncateDoubleToUInt32(input, output, mir->isSaturating(), oolEntry);
-        else if (fromType == MIRType::Float32)
+        } else if (fromType == MIRType::Float32) {
             masm.wasmTruncateFloat32ToUInt32(input, output, mir->isSaturating(), oolEntry);
-        else
+        } else {
             MOZ_CRASH("unexpected type");
+        }
 
         masm.bind(ool->rejoin());
         return;
     }
 
-    if (fromType == MIRType::Double)
+    if (fromType == MIRType::Double) {
         masm.wasmTruncateDoubleToInt32(input, output, mir->isSaturating(), oolEntry);
-    else if (fromType == MIRType::Float32)
+    } else if (fromType == MIRType::Float32) {
         masm.wasmTruncateFloat32ToInt32(input, output, mir->isSaturating(), oolEntry);
-    else
+    } else {
         MOZ_CRASH("unexpected type");
+    }
 
     masm.bind(ool->rejoin());
 }
 
 
 void
 CodeGeneratorMIPSShared::visitOutOfLineBailout(OutOfLineBailout* ool)
 {
@@ -1732,20 +1764,21 @@ CodeGenerator::visitCompareFAndBranch(LC
                       Assembler::InvertCondition(cond));
         jumpToBlock(ifTrue);
     }
 }
 
 void
 CodeGenerator::visitBitAndAndBranch(LBitAndAndBranch* lir)
 {
-    if (lir->right()->isConstant())
+    if (lir->right()->isConstant()) {
         masm.ma_and(ScratchRegister, ToRegister(lir->left()), Imm32(ToInt32(lir->right())));
-    else
+    } else {
         masm.as_and(ScratchRegister, ToRegister(lir->left()), ToRegister(lir->right()));
+    }
     emitBranch(ScratchRegister, ScratchRegister, lir->cond(), lir->ifTrue(),
                lir->ifFalse());
 }
 
 void
 CodeGenerator::visitWasmUint32ToDouble(LWasmUint32ToDouble* lir)
 {
     masm.convertUInt32ToDouble(ToRegister(lir->input()), ToFloatRegister(lir->output()));
@@ -1795,18 +1828,19 @@ CodeGenerator::visitMemoryBarrier(LMemor
 }
 
 void
 CodeGeneratorMIPSShared::generateInvalidateEpilogue()
 {
     // Ensure that there is enough space in the buffer for the OsiPoint
     // patching to occur. Otherwise, we could overwrite the invalidation
     // epilogue.
-    for (size_t i = 0; i < sizeof(void*); i += Assembler::NopSize())
+    for (size_t i = 0; i < sizeof(void*); i += Assembler::NopSize()) {
         masm.nop();
+    }
 
     masm.bind(&invalidate_);
 
     // Push the return address of the point that we bailed out at to the stack
     masm.Push(ra);
 
     // Push the Ion script onto the stack (when we determine what that
     // pointer is).
@@ -1868,18 +1902,19 @@ CodeGeneratorMIPSShared::visitOutOfLineT
 
 void
 CodeGeneratorMIPSShared::emitTableSwitchDispatch(MTableSwitch* mir, Register index,
                                            Register base)
 {
     Label* defaultcase = skipTrivialBlocks(mir->getDefault())->lir()->label();
 
     // Lower value with low value
-    if (mir->low() != 0)
+    if (mir->low() != 0) {
         masm.subPtr(Imm32(mir->low()), index);
+    }
 
     // Jump to default case if input is out of range
     int32_t cases = mir->numCases();
     masm.branchPtr(Assembler::AboveOrEqual, index, ImmWord(cases), defaultcase);
 
     // To fill in the CodeLabels for the case entries, we need to first
     // generate the case entries (we don't yet know their offsets in the
     // instruction stream).
@@ -2029,32 +2064,34 @@ CodeGenerator::visitAsmJSLoadHeap(LAsmJS
         return;
     }
 
     Label done, outOfRange;
     masm.wasmBoundsCheck(Assembler::AboveOrEqual, ptrReg, ToRegister(boundsCheckLimit),
                          &outOfRange);
     // Offset is ok, let's load value.
     if (isFloat) {
-        if (size == 32)
+        if (size == 32) {
             masm.loadFloat32(BaseIndex(HeapReg, ptrReg, TimesOne), ToFloatRegister(out));
-        else
+        } else {
             masm.loadDouble(BaseIndex(HeapReg, ptrReg, TimesOne), ToFloatRegister(out));
+        }
     } else {
         masm.ma_load(ToRegister(out), BaseIndex(HeapReg, ptrReg, TimesOne),
                      static_cast<LoadStoreSize>(size), isSigned ? SignExtend : ZeroExtend);
     }
     masm.ma_b(&done, ShortJump);
     masm.bind(&outOfRange);
     // Offset is out of range. Load default values.
     if (isFloat) {
-        if (size == 32)
+        if (size == 32) {
             masm.loadConstantFloat32(float(GenericNaN()), ToFloatRegister(out));
-        else
+        } else {
             masm.loadConstantDouble(GenericNaN(), ToFloatRegister(out));
+        }
     } else {
         masm.move32(Imm32(0), ToRegister(out));
     }
     masm.bind(&done);
 }
 
 void
 CodeGenerator::visitAsmJSStoreHeap(LAsmJSStoreHeap* ins)
@@ -2082,38 +2119,40 @@ CodeGenerator::visitAsmJSStoreHeap(LAsmJ
     if (ptr->isConstant()) {
         MOZ_ASSERT(!mir->needsBoundsCheck());
         int32_t ptrImm = ptr->toConstant()->toInt32();
         MOZ_ASSERT(ptrImm >= 0);
 
         if (isFloat) {
             FloatRegister freg = ToFloatRegister(value);
             Address addr(HeapReg, ptrImm);
-            if (size == 32)
+            if (size == 32) {
                 masm.storeFloat32(freg, addr);
-            else
+            } else {
                 masm.storeDouble(freg, addr);
+            }
         }  else {
             masm.ma_store(ToRegister(value), Address(HeapReg, ptrImm),
                           static_cast<LoadStoreSize>(size), isSigned ? SignExtend : ZeroExtend);
         }
         return;
     }
 
     Register ptrReg = ToRegister(ptr);
     Address dstAddr(ptrReg, 0);
 
     if (!mir->needsBoundsCheck()) {
         if (isFloat) {
             FloatRegister freg = ToFloatRegister(value);
             BaseIndex bi(HeapReg, ptrReg, TimesOne);
-            if (size == 32)
+            if (size == 32) {
                 masm.storeFloat32(freg, bi);
-            else
+            } else {
                 masm.storeDouble(freg, bi);
+            }
         } else {
             masm.ma_store(ToRegister(value), BaseIndex(HeapReg, ptrReg, TimesOne),
                           static_cast<LoadStoreSize>(size), isSigned ? SignExtend : ZeroExtend);
         }
         return;
     }
 
     Label outOfRange;
@@ -2223,20 +2262,21 @@ CodeGenerator::visitWasmStackArg(LWasmSt
     }
 }
 
 void
 CodeGenerator::visitWasmStackArgI64(LWasmStackArgI64* ins)
 {
     const MWasmStackArg* mir = ins->mir();
     Address dst(StackPointer, mir->spOffset());
-    if (IsConstant(ins->arg()))
+    if (IsConstant(ins->arg())) {
         masm.store64(Imm64(ToInt64(ins->arg())), dst);
-    else
+    } else {
         masm.store64(ToRegister64(ins->arg()), dst);
+    }
 }
 
 void
 CodeGenerator::visitWasmSelect(LWasmSelect* ins)
 {
     MIRType mirType = ins->mir()->type();
 
     Register cond = ToRegister(ins->condExpr());
@@ -2248,32 +2288,34 @@ CodeGenerator::visitWasmSelect(LWasmSele
         masm.as_movz(out, ToRegister(falseExpr), cond);
         return;
     }
 
     FloatRegister out = ToFloatRegister(ins->output());
     MOZ_ASSERT(ToFloatRegister(ins->trueExpr()) == out, "true expr input is reused for output");
 
     if (falseExpr->isFloatReg()) {
-        if (mirType == MIRType::Float32)
+        if (mirType == MIRType::Float32) {
             masm.as_movz(Assembler::SingleFloat, out, ToFloatRegister(falseExpr), cond);
-        else if (mirType == MIRType::Double)
+        } else if (mirType == MIRType::Double) {
             masm.as_movz(Assembler::DoubleFloat, out, ToFloatRegister(falseExpr), cond);
-        else
+        } else {
             MOZ_CRASH("unhandled type in visitWasmSelect!");
+        }
     } else {
         Label done;
         masm.ma_b(cond, cond, &done, Assembler::NonZero, ShortJump);
 
-        if (mirType == MIRType::Float32)
+        if (mirType == MIRType::Float32) {
             masm.loadFloat32(ToAddress(falseExpr), out);
-        else if (mirType == MIRType::Double)
+        } else if (mirType == MIRType::Double) {
             masm.loadDouble(ToAddress(falseExpr), out);
-        else
+        } else {
             MOZ_CRASH("unhandled type in visitWasmSelect!");
+        }
 
         masm.bind(&done);
     }
 }
 
 void
 CodeGenerator::visitWasmReinterpret(LWasmReinterpret* lir)
 {
@@ -2329,24 +2371,26 @@ CodeGenerator::visitUDivOrMod(LUDivOrMod
         }
     }
 
     masm.as_divu(lhs, rhs);
     masm.as_mfhi(output);
 
     // If the remainder is > 0, bailout since this must be a double.
     if (ins->mir()->isDiv()) {
-        if (!ins->mir()->toDiv()->canTruncateRemainder())
+        if (!ins->mir()->toDiv()->canTruncateRemainder()) {
           bailoutCmp32(Assembler::NonZero, output, output, ins->snapshot());
+        }
         // Get quotient
         masm.as_mflo(output);
     }
 
-    if (!ins->mir()->isTruncated())
+    if (!ins->mir()->isTruncated()) {
         bailoutCmp32(Assembler::LessThan, output, Imm32(0), ins->snapshot());
+    }
 
     masm.bind(&done);
 }
 
 void
 CodeGenerator::visitEffectiveAddress(LEffectiveAddress* ins)
 {
     const MEffectiveAddress* mir = ins->mir();

--- a/js/src/jit/mips-shared/LIR-mips-shared.h
+++ b/js/src/jit/mips-shared/LIR-mips-shared.h
@@ -239,31 +239,34 @@ class LUDivOrMod : public LBinaryMath<0>
     {}
 
     MBinaryArithInstruction* mir() const {
         MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
         return static_cast<MBinaryArithInstruction*>(mir_);
     }
 
     bool canBeDivideByZero() const {
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->canBeDivideByZero();
+        }
         return mir_->toDiv()->canBeDivideByZero();
     }
 
     bool trapOnError() const {
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->trapOnError();
+        }
         return mir_->toDiv()->trapOnError();
     }
 
     wasm::BytecodeOffset bytecodeOffset() const {
         MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->bytecodeOffset();
+        }
         return mir_->toDiv()->bytecodeOffset();
     }
 };
 
 namespace details {
 
 // Base class for the int64 and non-int64 variants.
 template<size_t NumDefs>

--- a/js/src/jit/mips-shared/Lowering-mips-shared.cpp
+++ b/js/src/jit/mips-shared/Lowering-mips-shared.cpp
@@ -80,64 +80,70 @@ LIRGeneratorMIPSShared::lowerForMulInt64
 
 #ifdef JS_CODEGEN_MIPS32
     needsTemp = true;
     cannotAliasRhs = true;
     if (rhs->isConstant()) {
         int64_t constant = rhs->toConstant()->toInt64();
         int32_t shift = mozilla::FloorLog2(constant);
         // See special cases in CodeGeneratorMIPSShared::visitMulI64
-        if (constant >= -1 && constant <= 2)
+        if (constant >= -1 && constant <= 2) {
             needsTemp = false;
-        if (int64_t(1) << shift == constant)
+        }
+        if (int64_t(1) << shift == constant) {
             needsTemp = false;
+        }
         if (mozilla::IsPowerOfTwo(static_cast<uint32_t>(constant + 1)) ||
             mozilla::IsPowerOfTwo(static_cast<uint32_t>(constant - 1)))
             reuseInput = false;
     }
 #endif
     ins->setInt64Operand(0, useInt64RegisterAtStart(lhs));
     ins->setInt64Operand(INT64_PIECES,
                          (lhs != rhs || cannotAliasRhs) ? useInt64OrConstant(rhs) : useInt64OrConstantAtStart(rhs));
 
-    if (needsTemp)
+    if (needsTemp) {
         ins->setTemp(0, temp());
-    if(reuseInput)
+    }
+    if (reuseInput) {
         defineInt64ReuseInput(ins, mir, 0);
-    else
+    } else {
         defineInt64(ins, mir);
+    }
 }
 
 template<size_t Temps>
 void
 LIRGeneratorMIPSShared::lowerForShiftInt64(LInstructionHelper<INT64_PIECES, INT64_PIECES + 1, Temps>* ins,
                                            MDefinition* mir, MDefinition* lhs, MDefinition* rhs)
 {
 #ifdef JS_CODEGEN_MIPS32
     if (mir->isRotate()) {
-        if (!rhs->isConstant())
+        if (!rhs->isConstant()) {
             ins->setTemp(0, temp());
+        }
         ins->setInt64Operand(0, useInt64Register(lhs));
     } else {
         ins->setInt64Operand(0, useInt64RegisterAtStart(lhs));
     }
 #else
     ins->setInt64Operand(0, useInt64RegisterAtStart(lhs));
 #endif
 
     static_assert(LShiftI64::Rhs == INT64_PIECES, "Assume Rhs is located at INT64_PIECES.");
     static_assert(LRotateI64::Count == INT64_PIECES, "Assume Count is located at INT64_PIECES.");
 
     ins->setOperand(INT64_PIECES, useRegisterOrConstant(rhs));
 
 #ifdef JS_CODEGEN_MIPS32
-    if (mir->isRotate())
+    if (mir->isRotate()) {
         defineInt64(ins, mir);
-    else
+    } else {
         defineInt64ReuseInput(ins, mir, 0);
+    }
 #else
     defineInt64ReuseInput(ins, mir, 0);
 #endif
 }
 
 template void LIRGeneratorMIPSShared::lowerForShiftInt64(
     LInstructionHelper<INT64_PIECES, INT64_PIECES+1, 0>* ins, MDefinition* mir,
     MDefinition* lhs, MDefinition* rhs);
@@ -201,35 +207,38 @@ LIRGeneratorMIPSShared::lowerDivI(MDiv* 
         // Check for division by a positive power of two, which is an easy and
         // important case to optimize. Note that other optimizations are also
         // possible; division by negative powers of two can be optimized in a
         // similar manner as positive powers of two, and division by other
         // constants can be optimized by a reciprocal multiplication technique.
         int32_t shift = FloorLog2(rhs);
         if (rhs > 0 && 1 << shift == rhs) {
             LDivPowTwoI* lir = new(alloc()) LDivPowTwoI(useRegister(div->lhs()), shift, temp());
-            if (div->fallible())
+            if (div->fallible()) {
                 assignSnapshot(lir, Bailout_DoubleOutput);
+            }
             define(lir, div);
             return;
         }
     }
 
     LDivI* lir = new(alloc()) LDivI(useRegister(div->lhs()), useRegister(div->rhs()), temp());
-    if (div->fallible())
+    if (div->fallible()) {
         assignSnapshot(lir, Bailout_DoubleOutput);
+    }
     define(lir, div);
 }
 
 void
 LIRGeneratorMIPSShared::lowerMulI(MMul* mul, MDefinition* lhs, MDefinition* rhs)
 {
     LMulI* lir = new(alloc()) LMulI;
-    if (mul->fallible())
+    if (mul->fallible()) {
         assignSnapshot(lir, Bailout_DoubleOutput);
+    }
 
     lowerForALU(lir, mul, lhs, rhs);
 }
 
 void
 LIRGeneratorMIPSShared::lowerModI(MMod* mod)
 {
     if (mod->isUnsigned()) {
@@ -237,36 +246,39 @@ LIRGeneratorMIPSShared::lowerModI(MMod* 
         return;
     }
 
     if (mod->rhs()->isConstant()) {
         int32_t rhs = mod->rhs()->toConstant()->toInt32();
         int32_t shift = FloorLog2(rhs);
         if (rhs > 0 && 1 << shift == rhs) {
             LModPowTwoI* lir = new(alloc()) LModPowTwoI(useRegister(mod->lhs()), shift);
-            if (mod->fallible())
+            if (mod->fallible()) {
                 assignSnapshot(lir, Bailout_DoubleOutput);
+            }
             define(lir, mod);
             return;
         } else if (shift < 31 && (1 << (shift + 1)) - 1 == rhs) {
             LModMaskI* lir = new(alloc()) LModMaskI(useRegister(mod->lhs()),
                                                     temp(LDefinition::GENERAL),
                                                     temp(LDefinition::GENERAL),
                                                     shift + 1);
-            if (mod->fallible())
+            if (mod->fallible()) {
                 assignSnapshot(lir, Bailout_DoubleOutput);
+            }
             define(lir, mod);
             return;
         }
     }
     LModI* lir = new(alloc()) LModI(useRegister(mod->lhs()), useRegister(mod->rhs()),
                            temp(LDefinition::GENERAL));
 
-    if (mod->fallible())
+    if (mod->fallible()) {
         assignSnapshot(lir, Bailout_DoubleOutput);
+    }
     define(lir, mod);
 }
 
 void
 LIRGenerator::visitPowHalf(MPowHalf* ins)
 {
     MDefinition* input = ins->input();
     MOZ_ASSERT(input->type() == MIRType::Double);
@@ -317,60 +329,67 @@ LIRGenerator::visitWasmNeg(MWasmNeg* ins
 void
 LIRGenerator::visitWasmLoad(MWasmLoad* ins)
 {
     MDefinition* base = ins->base();
     MOZ_ASSERT(base->type() == MIRType::Int32);
 
     LAllocation ptr;
 #ifdef JS_CODEGEN_MIPS32
-    if (ins->type() == MIRType::Int64)
+    if (ins->type() == MIRType::Int64) {
         ptr = useRegister(base);
-    else
+    } else {
+        ptr = useRegisterAtStart(base);
+    }
+#else
+    ptr = useRegisterAtStart(base);
 #endif
-        ptr = useRegisterAtStart(base);
 
     if (IsUnaligned(ins->access())) {
         if (ins->type() == MIRType::Int64) {
             auto* lir = new(alloc()) LWasmUnalignedLoadI64(ptr, temp());
-            if (ins->access().offset())
+            if (ins->access().offset()) {
                 lir->setTemp(0, tempCopy(base, 0));
+            }
 
             defineInt64(lir, ins);
             return;
         }
 
         auto* lir = new(alloc()) LWasmUnalignedLoad(ptr, temp());
-        if (ins->access().offset())
+        if (ins->access().offset()) {
             lir->setTemp(0, tempCopy(base, 0));
+        }
 
         define(lir, ins);
         return;
     }
 
     if (ins->type() == MIRType::Int64) {
 
 #ifdef JS_CODEGEN_MIPS32
         if(ins->access().isAtomic()) {
             auto* lir = new(alloc()) LWasmAtomicLoadI64(ptr);
             defineInt64(lir, ins);
             return;
         }
 #endif
         auto* lir = new(alloc()) LWasmLoadI64(ptr);
-        if (ins->access().offset())
+        if (ins->access().offset()) {
             lir->setTemp(0, tempCopy(base, 0));
+        }
 
         defineInt64(lir, ins);
         return;
     }
 
     auto* lir = new(alloc()) LWasmLoad(ptr);
-    if (ins->access().offset())
+    if (ins->access().offset()) {
         lir->setTemp(0, tempCopy(base, 0));
+    }
 
     define(lir, ins);
 }
 
 void
 LIRGenerator::visitWasmStore(MWasmStore* ins)
 {
     MDefinition* base = ins->base();
@@ -378,27 +397,29 @@ LIRGenerator::visitWasmStore(MWasmStore*
 
     MDefinition* value = ins->value();
 
     if (IsUnaligned(ins->access())) {
         LAllocation baseAlloc = useRegisterAtStart(base);
         if (ins->access().type() == Scalar::Int64) {
             LInt64Allocation valueAlloc = useInt64RegisterAtStart(value);
             auto* lir = new(alloc()) LWasmUnalignedStoreI64(baseAlloc, valueAlloc, temp());
-            if (ins->access().offset())
+            if (ins->access().offset()) {
                 lir->setTemp(0, tempCopy(base, 0));
+            }
 
             add(lir, ins);
             return;
         }
 
         LAllocation valueAlloc = useRegisterAtStart(value);
         auto* lir = new(alloc()) LWasmUnalignedStore(baseAlloc, valueAlloc, temp());
-        if (ins->access().offset())
+        if (ins->access().offset()) {
             lir->setTemp(0, tempCopy(base, 0));
+        }
 
         add(lir, ins);
         return;
     }
 
     if (ins->access().type() == Scalar::Int64) {
 
 #ifdef JS_CODEGEN_MIPS32
@@ -407,28 +428,30 @@ LIRGenerator::visitWasmStore(MWasmStore*
             add(lir, ins);
             return;
         }
 #endif
 
         LAllocation baseAlloc = useRegisterAtStart(base);
         LInt64Allocation valueAlloc = useInt64RegisterAtStart(value);
         auto* lir = new(alloc()) LWasmStoreI64(baseAlloc, valueAlloc);
-        if (ins->access().offset())
+        if (ins->access().offset()) {
             lir->setTemp(0, tempCopy(base, 0));
+        }
 
         add(lir, ins);
         return;
     }
 
     LAllocation baseAlloc = useRegisterAtStart(base);
     LAllocation valueAlloc = useRegisterAtStart(value);
     auto* lir = new(alloc()) LWasmStore(baseAlloc, valueAlloc);
-    if (ins->access().offset())
+    if (ins->access().offset()) {
         lir->setTemp(0, tempCopy(base, 0));
+    }
 
     add(lir, ins);
 }
 
 void
 LIRGenerator::visitWasmSelect(MWasmSelect* ins)
 {
     if (ins->type() == MIRType::Int64) {
@@ -451,33 +474,35 @@ void
 LIRGeneratorMIPSShared::lowerUDiv(MDiv* div)
 {
     MDefinition* lhs = div->getOperand(0);
     MDefinition* rhs = div->getOperand(1);
 
     LUDivOrMod* lir = new(alloc()) LUDivOrMod;
     lir->setOperand(0, useRegister(lhs));
     lir->setOperand(1, useRegister(rhs));
-    if (div->fallible())
+    if (div->fallible()) {
         assignSnapshot(lir, Bailout_DoubleOutput);
+    }
 
     define(lir, div);
 }
 
 void
 LIRGeneratorMIPSShared::lowerUMod(MMod* mod)
 {
     MDefinition* lhs = mod->getOperand(0);
     MDefinition* rhs = mod->getOperand(1);
 
     LUDivOrMod* lir = new(alloc()) LUDivOrMod;
     lir->setOperand(0, useRegister(lhs));
     lir->setOperand(1, useRegister(rhs));
-    if (mod->fallible())
+    if (mod->fallible()) {
         assignSnapshot(lir, Bailout_DoubleOutput);
+    }
 
     define(lir, mod);
 }
 
 void
 LIRGenerator::visitWasmUnsignedToDouble(MWasmUnsignedToDouble* ins)
 {
     MOZ_ASSERT(ins->input()->type() == MIRType::Int32);
@@ -575,18 +600,19 @@ LIRGenerator::visitCompareExchangeTypedA
     const LAllocation newval = useRegister(ins->newval());
     const LAllocation oldval = useRegister(ins->oldval());
 
     LDefinition outTemp = LDefinition::BogusTemp();
     LDefinition valueTemp = LDefinition::BogusTemp();
     LDefinition offsetTemp = LDefinition::BogusTemp();
     LDefinition maskTemp = LDefinition::BogusTemp();
 
-    if (ins->arrayType() == Scalar::Uint32 && IsFloatingPointType(ins->type()))
+    if (ins->arrayType() == Scalar::Uint32 && IsFloatingPointType(ins->type())) {
         outTemp = temp();
+    }
 
     if (Scalar::byteSize(ins->arrayType()) < 4) {
         valueTemp = temp();
         offsetTemp = temp();
         maskTemp = temp();
     }
 
     LCompareExchangeTypedArrayElement* lir =
@@ -770,18 +796,19 @@ LIRGenerator::visitAtomicTypedArrayEleme
         return;
     }
 
     // For a Uint32Array with a known double result we need a temp for
     // the intermediate output.
 
     LDefinition outTemp = LDefinition::BogusTemp();
 
-    if (ins->arrayType() == Scalar::Uint32 && IsFloatingPointType(ins->type()))
+    if (ins->arrayType() == Scalar::Uint32 && IsFloatingPointType(ins->type())) {
         outTemp = temp();
+    }
 
     LAtomicTypedArrayElementBinop* lir =
         new(alloc()) LAtomicTypedArrayElementBinop(elements, index, value, outTemp,
                                                    valueTemp, offsetTemp, maskTemp);
     define(lir, ins);
 }
 
 void
@@ -790,20 +817,21 @@ LIRGenerator::visitCopySign(MCopySign* i
     MDefinition* lhs = ins->lhs();
     MDefinition* rhs = ins->rhs();
 
     MOZ_ASSERT(IsFloatingPointType(lhs->type()));
     MOZ_ASSERT(lhs->type() == rhs->type());
     MOZ_ASSERT(lhs->type() == ins->type());
 
     LInstructionHelper<1, 2, 2>* lir;
-    if (lhs->type() == MIRType::Double)
+    if (lhs->type() == MIRType::Double) {
         lir = new(alloc()) LCopySignD();
-    else
+    } else {
         lir = new(alloc()) LCopySignF();
+    }
 
     lir->setTemp(0, temp());
     lir->setTemp(1, temp());
 
     lir->setOperand(0, useRegisterAtStart(lhs));
     lir->setOperand(1, useRegister(rhs));
     defineReuseInput(lir, ins, 0);
 }

--- a/js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
+++ b/js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
@@ -226,30 +226,32 @@ MacroAssembler::mulDoublePtr(ImmPtr imm,
     movePtr(imm, ScratchRegister);
     loadDouble(Address(ScratchRegister, 0), ScratchDoubleReg);
     mulDouble(ScratchDoubleReg, dest);
 }
 
 void
 MacroAssembler::quotient32(Register rhs, Register srcDest, bool isUnsigned)
 {
-    if (isUnsigned)
+    if (isUnsigned) {
         as_divu(srcDest, rhs);
-    else
+    } else {
         as_div(srcDest, rhs);
+    }
     as_mflo(srcDest);
 }
 
 void
 MacroAssembler::remainder32(Register rhs, Register srcDest, bool isUnsigned)
 {
-    if (isUnsigned)
+    if (isUnsigned) {
         as_divu(srcDest, rhs);
-    else
+    } else {
         as_div(srcDest, rhs);
+    }
     as_mfhi(srcDest);
 }
 
 void
 MacroAssembler::divFloat32(FloatRegister src, FloatRegister dest)
 {
     as_divs(dest, dest, src);
 }
@@ -383,33 +385,35 @@ MacroAssembler::rshift32Arithmetic(Imm32
     ma_sra(dest, dest, imm);
 }
 
 // ===============================================================
 // Rotation functions
 void
 MacroAssembler::rotateLeft(Imm32 count, Register input, Register dest)
 {
-    if (count.value)
+    if (count.value) {
         ma_rol(dest, input, count);
-    else
+    } else {
         ma_move(dest, input);
+    }
 }
 void
 MacroAssembler::rotateLeft(Register count, Register input, Register dest)
 {
     ma_rol(dest, input, count);
 }
 void
 MacroAssembler::rotateRight(Imm32 count, Register input, Register dest)
 {
-    if (count.value)
+    if (count.value) {
         ma_ror(dest, input, count);
-    else
+    } else {
         ma_move(dest, input);
+    }
 }
 void
 MacroAssembler::rotateRight(Register count, Register input, Register dest)
 {
     ma_ror(dest, input, count);
 }
 
 // ===============================================================
@@ -1079,18 +1083,19 @@ void
 MacroAssembler::storeUncanonicalizedFloat32(FloatRegister src, const BaseIndex& addr)
 {
     ma_ss(src, addr);
 }
 
 void
 MacroAssembler::memoryBarrier(MemoryBarrierBits barrier)
 {
-    if (barrier)
+    if (barrier) {
         as_sync();
+    }
 }
 
 // ===============================================================
 // Clamping functions.
 
 void
 MacroAssembler::clampIntToUint8(Register reg)
 {

--- a/js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
+++ b/js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
@@ -559,29 +559,31 @@ MacroAssemblerMIPSShared::ma_load_unalig
         base = ScratchRegister;
         lowOffset = Imm16(0).encode();
         hiOffset = Imm16(size / 8 - 1).encode();
     }
 
     BufferOffset load;
     switch (size) {
       case SizeHalfWord:
-        if (extension != ZeroExtend)
+        if (extension != ZeroExtend) {
             load = as_lbu(temp, base, hiOffset);
-        else
+        } else {
             load = as_lb(temp, base, hiOffset);
+        }
         as_lbu(dest, base, lowOffset);
         ma_ins(dest, temp, 8, 24);
         break;
       case SizeWord:
         load = as_lwl(dest, base, hiOffset);
         as_lwr(dest, base, lowOffset);
 #ifdef JS_CODEGEN_MIPS64
-        if (extension != ZeroExtend)
+        if (extension != ZeroExtend) {
             as_dext(dest, dest, 0, 32);
+        }
 #endif
         break;
 #ifdef JS_CODEGEN_MIPS64
       case SizeDouble:
         load = as_ldl(dest, base, hiOffset);
         as_ldr(dest, base, lowOffset);
         break;
 #endif
@@ -764,22 +766,23 @@ MacroAssemblerMIPSShared::ma_b(Register 
     }
 }
 
 void
 MacroAssemblerMIPSShared::ma_b(Register lhs, Imm32 imm, Label* label, Condition c, JumpKind jumpKind)
 {
     MOZ_ASSERT(c != Overflow);
     if (imm.value == 0) {
-        if (c == Always || c == AboveOrEqual)
+        if (c == Always || c == AboveOrEqual) {
             ma_b(label, jumpKind);
-        else if (c == Below)
+        } else if (c == Below) {
             ; // This condition is always false. No branch required.
-        else
+        } else {
             asMasm().branchWithCode(getBranchCode(lhs, c), label, jumpKind);
+        }
     } else {
       switch (c) {
         case Equal:
         case NotEqual:
           MOZ_ASSERT(lhs != ScratchRegister);
           ma_li(ScratchRegister, imm);
           ma_b(lhs, ScratchRegister, label, c, jumpKind);
           break;
@@ -1075,35 +1078,37 @@ void
 MacroAssemblerMIPSShared::ma_cmp_set_double(Register dest, FloatRegister lhs, FloatRegister rhs,
                                             DoubleCondition c)
 {
     FloatTestKind moveCondition;
     compareFloatingPoint(DoubleFloat, lhs, rhs, c, &moveCondition);
 
     ma_li(dest, Imm32(1));
 
-    if (moveCondition == TestForTrue)
+    if (moveCondition == TestForTrue) {
         as_movf(dest, zero);
-    else
+    } else {
         as_movt(dest, zero);
+    }
 }
 
 void
 MacroAssemblerMIPSShared::ma_cmp_set_float32(Register dest, FloatRegister lhs, FloatRegister rhs,
                                              DoubleCondition c)
 {
     FloatTestKind moveCondition;
     compareFloatingPoint(SingleFloat, lhs, rhs, c, &moveCondition);
 
     ma_li(dest, Imm32(1));
 
-    if (moveCondition == TestForTrue)
+    if (moveCondition == TestForTrue) {
         as_movf(dest, zero);
-    else
+    } else {
         as_movt(dest, zero);
+    }
 }
 
 void
 MacroAssemblerMIPSShared::ma_cmp_set(Register rd, Register rs, Imm32 imm, Condition c)
 {
     if (imm.value == 0) {
         switch (c) {
           case Equal :
@@ -1116,24 +1121,26 @@ MacroAssemblerMIPSShared::ma_cmp_set(Reg
             break;
           case AboveOrEqual:
           case Below:
             as_ori(rd, zero, c == AboveOrEqual ? 1: 0);
             break;
           case GreaterThan:
           case LessThanOrEqual:
             as_slt(rd, zero, rs);
-            if (c == LessThanOrEqual)
+            if (c == LessThanOrEqual) {
                 as_xori(rd, rd, 1);
+            }
             break;
           case LessThan:
           case GreaterThanOrEqual:
             as_slt(rd, rs, zero);
-            if (c == GreaterThanOrEqual)
+            if (c == GreaterThanOrEqual) {
                 as_xori(rd, rd, 1);
+            }
             break;
           case Zero:
             as_sltiu(rd, rs, 1);
             break;
           case NonZero:
             as_sltu(rd, zero, rs);
             break;
           case Signed:
@@ -1149,20 +1156,21 @@ MacroAssemblerMIPSShared::ma_cmp_set(Reg
         return;
     }
 
     switch (c) {
       case Equal:
       case NotEqual:
         MOZ_ASSERT(rs != ScratchRegister);
         ma_xor(rd, rs, imm);
-        if (c == Equal)
+        if (c == Equal) {
             as_sltiu(rd, rd, 1);
-        else
+        } else {
             as_sltu(rd, zero, rd);
+        }
         break;
       case Zero:
       case NonZero:
       case Signed:
       case NotSigned:
         MOZ_CRASH("Invalid condition.");
       default:
         Condition cond = ma_cmp(rd, rs, imm, c);
@@ -1703,18 +1711,19 @@ MacroAssembler::pushFakeReturnAddress(Re
 
     addCodeLabel(cl);
     return retAddr;
 }
 
 void
 MacroAssembler::loadStoreBuffer(Register ptr, Register buffer)
 {
-    if (ptr != buffer)
+    if (ptr != buffer) {
         movePtr(ptr, buffer);
+    }
     orPtr(Imm32(gc::ChunkMask), buffer);
     loadPtr(Address(buffer, gc::ChunkStoreBufferOffsetFromLastByte), buffer);
 }
 
 void
 MacroAssembler::branchPtrInNurseryChunk(Condition cond, Register ptr, Register temp,
                                         Label* label)
 {
@@ -1804,22 +1813,23 @@ void
 MacroAssemblerMIPSShared::outOfLineWasmTruncateToInt32Check(FloatRegister input, Register output,
                                                             MIRType fromType, TruncFlags flags,
                                                             Label* rejoin,
                                                             wasm::BytecodeOffset trapOffset)
 {
     bool isUnsigned = flags & TRUNC_UNSIGNED;
     bool isSaturating = flags & TRUNC_SATURATING;
 
-    if(isSaturating) {
-
-        if(fromType == MIRType::Double)
+    if (isSaturating) {
+
+        if (fromType == MIRType::Double) {
             asMasm().loadConstantDouble(0.0, ScratchDoubleReg);
-        else
+        } else {
             asMasm().loadConstantFloat32(0.0f, ScratchFloat32Reg);
+        }
 
         if(isUnsigned) {
 
             ma_li(output, Imm32(UINT32_MAX));
 
             FloatTestKind moveCondition;
             compareFloatingPoint(fromType == MIRType::Double ? DoubleFloat : SingleFloat,
                                  input,
@@ -1854,20 +1864,21 @@ MacroAssemblerMIPSShared::outOfLineWasmT
 
         MOZ_ASSERT(rejoin->bound());
         asMasm().jump(rejoin);
         return;
     }
 
     Label inputIsNaN;
 
-    if (fromType == MIRType::Double)
+    if (fromType == MIRType::Double) {
         asMasm().branchDouble(Assembler::DoubleUnordered, input, input, &inputIsNaN);
-    else if (fromType == MIRType::Float32)
+    } else if (fromType == MIRType::Float32) {
         asMasm().branchFloat(Assembler::DoubleUnordered, input, input, &inputIsNaN);
+    }
 
     asMasm().wasmTrap(wasm::Trap::IntegerOverflow, trapOffset);
     asMasm().bind(&inputIsNaN);
     asMasm().wasmTrap(wasm::Trap::InvalidConversionToInteger, trapOffset);
 }
 
 void
 MacroAssemblerMIPSShared::outOfLineWasmTruncateToInt64Check(FloatRegister input, Register64 output_,
@@ -1881,20 +1892,21 @@ MacroAssemblerMIPSShared::outOfLineWasmT
 
     if(isSaturating) {
 #if defined(JS_CODEGEN_MIPS32)
         // Saturating callouts don't use ool path.
         return;
 #else
         Register output = output_.reg;
 
-        if(fromType == MIRType::Double)
+        if (fromType == MIRType::Double) {
             asMasm().loadConstantDouble(0.0, ScratchDoubleReg);
-        else
+        } else {
             asMasm().loadConstantFloat32(0.0f, ScratchFloat32Reg);
+        }
 
         if(isUnsigned) {
 
             asMasm().ma_li(output, ImmWord(UINT64_MAX));
 
             FloatTestKind moveCondition;
             compareFloatingPoint(fromType == MIRType::Double ? DoubleFloat : SingleFloat,
                                  input,
@@ -1931,20 +1943,21 @@ MacroAssemblerMIPSShared::outOfLineWasmT
         asMasm().jump(rejoin);
         return;
 #endif
 
     }
 
     Label inputIsNaN;
 
-    if (fromType == MIRType::Double)
+    if (fromType == MIRType::Double) {
         asMasm().branchDouble(Assembler::DoubleUnordered, input, input, &inputIsNaN);
-    else if (fromType == MIRType::Float32)
+    } else if (fromType == MIRType::Float32) {
         asMasm().branchFloat(Assembler::DoubleUnordered, input, input, &inputIsNaN);
+    }
 
 #if defined(JS_CODEGEN_MIPS32)
 
     // Only possible valid input that produces INT64_MIN result.
     double validInput = isUnsigned ? double(uint64_t(INT64_MIN)) : double(int64_t(INT64_MIN));
 
     if (fromType == MIRType::Double) {
         asMasm().loadConstantDouble(validInput, ScratchDoubleReg);
@@ -2038,34 +2051,36 @@ MacroAssemblerMIPSShared::wasmLoadImpl(c
       case Scalar::Float32: isFloat  = true;  break;
       default: MOZ_CRASH("unexpected array type");
     }
 
     BaseIndex address(memoryBase, ptr, TimesOne);
     if (IsUnaligned(access)) {
         MOZ_ASSERT(tmp != InvalidReg);
         if (isFloat) {
-            if (byteSize == 4)
+            if (byteSize == 4) {
                 asMasm().loadUnalignedFloat32(access, address, tmp, output.fpu());
-            else
+            } else {
                 asMasm().loadUnalignedDouble(access, address, tmp, output.fpu());
+            }
         } else {
             asMasm().ma_load_unaligned(access, output.gpr(), address, tmp,
                                        static_cast<LoadStoreSize>(8 * byteSize),
                                        isSigned ? SignExtend : ZeroExtend);
         }
         return;
     }
 
     asMasm().memoryBarrierBefore(access.sync());
     if (isFloat) {
-        if (byteSize == 4)
+        if (byteSize == 4) {
             asMasm().ma_ls(output.fpu(), address);
-         else
+         } else {
             asMasm().ma_ld(output.fpu(), address);
+         }
     } else {
         asMasm().ma_load(output.gpr(), address, static_cast<LoadStoreSize>(8 * byteSize),
                          isSigned ? SignExtend : ZeroExtend);
     }
     asMasm().append(access, asMasm().size() - 4);
     asMasm().memoryBarrierAfter(access.sync());
 }
 
@@ -2100,34 +2115,36 @@ MacroAssemblerMIPSShared::wasmStoreImpl(
       case Scalar::Float32: isFloat  = true;  break;
       default: MOZ_CRASH("unexpected array type");
     }
 
     BaseIndex address(memoryBase, ptr, TimesOne);
     if (IsUnaligned(access)) {
         MOZ_ASSERT(tmp != InvalidReg);
         if (isFloat) {
-            if (byteSize == 4)
+            if (byteSize == 4) {
                 asMasm().storeUnalignedFloat32(access, value.fpu(), tmp, address);
-            else
+            } else {
                 asMasm().storeUnalignedDouble(access, value.fpu(), tmp, address);
+            }
         } else {
             asMasm().ma_store_unaligned(access, value.gpr(), address, tmp,
                                         static_cast<LoadStoreSize>(8 * byteSize),
                                         isSigned ? SignExtend : ZeroExtend);
         }
         return;
     }
 
     asMasm().memoryBarrierBefore(access.sync());
     if (isFloat) {
-        if (byteSize == 4)
+        if (byteSize == 4) {
             asMasm().ma_ss(value.fpu(), address);
-        else
+        } else {
             asMasm().ma_sd(value.fpu(), address);
+        }
     } else {
         asMasm().ma_store(value.gpr(), address,
                       static_cast<LoadStoreSize>(8 * byteSize),
                       isSigned ? SignExtend : ZeroExtend);
     }
     // Only the last emitted instruction is a memory access.
     asMasm().append(access, asMasm().size() - 4);
     asMasm().memoryBarrierAfter(access.sync());
@@ -2863,20 +2880,21 @@ MacroAssembler::flexibleRemainder32(Regi
 {
     remainder32(rhs, srcDest, isUnsigned);
 }
 
 void
 MacroAssembler::flexibleDivMod32(Register rhs, Register srcDest, Register remOutput,
                                  bool isUnsigned, const LiveRegisterSet&)
 {
-    if (isUnsigned)
+    if (isUnsigned) {
         as_divu(srcDest, rhs);
-    else
+    } else {
         as_div(srcDest, rhs);
+    }
     as_mfhi(remOutput);
     as_mflo(srcDest);
 }
 
 // ========================================================================
 // Spectre Mitigations.
 
 void

--- a/js/src/jit/mips-shared/MoveEmitter-mips-shared.cpp
+++ b/js/src/jit/mips-shared/MoveEmitter-mips-shared.cpp
@@ -15,34 +15,36 @@ void
 MoveEmitterMIPSShared::emit(const MoveResolver& moves)
 {
     if (moves.numCycles()) {
         // Reserve stack for cycle resolution
         masm.reserveStack(moves.numCycles() * sizeof(double));
         pushedAtCycle_ = masm.framePushed();
     }
 
-    for (size_t i = 0; i < moves.numMoves(); i++)
+    for (size_t i = 0; i < moves.numMoves(); i++) {
         emit(moves.getMove(i));
+    }
 }
 
 Address
 MoveEmitterMIPSShared::cycleSlot(uint32_t slot, uint32_t subslot) const
 {
     int32_t offset = masm.framePushed() - pushedAtCycle_;
     MOZ_ASSERT(Imm16::IsInSignedRange(offset));
     return Address(StackPointer, offset + slot * sizeof(double) + subslot);
 }
 
 int32_t
 MoveEmitterMIPSShared::getAdjustedOffset(const MoveOperand& operand)
 {
     MOZ_ASSERT(operand.isMemoryOrEffectiveAddress());
-    if (operand.base() != StackPointer)
+    if (operand.base() != StackPointer) {
         return operand.disp();
+    }
 
     // Adjust offset if stack pointer has been moved.
     return operand.disp() + masm.framePushed() - pushedAtStart_;
 }
 
 Address
 MoveEmitterMIPSShared::getAdjustedAddress(const MoveOperand& operand)
 {
@@ -59,22 +61,23 @@ MoveEmitterMIPSShared::tempReg()
 
 void
 MoveEmitterMIPSShared::emitMove(const MoveOperand& from, const MoveOperand& to)
 {
     if (from.isGeneralReg()) {
         // Second scratch register should not be moved by MoveEmitter.
         MOZ_ASSERT(from.reg() != spilledReg_);
 
-        if (to.isGeneralReg())
+        if (to.isGeneralReg()) {
             masm.movePtr(from.reg(), to.reg());
-        else if (to.isMemory())
+        } else if (to.isMemory()) {
             masm.storePtr(from.reg(), getAdjustedAddress(to));
-        else
+        } else {
             MOZ_CRASH("Invalid emitMove arguments.");
+        }
     } else if (from.isMemory()) {
         if (to.isGeneralReg()) {
             masm.loadPtr(getAdjustedAddress(from), to.reg());
         } else if (to.isMemory()) {
             masm.loadPtr(getAdjustedAddress(from), tempReg());
             masm.storePtr(tempReg(), getAdjustedAddress(to));
         } else {
             MOZ_CRASH("Invalid emitMove arguments.");
@@ -95,22 +98,23 @@ MoveEmitterMIPSShared::emitMove(const Mo
 
 void
 MoveEmitterMIPSShared::emitInt32Move(const MoveOperand &from, const MoveOperand &to)
 {
     if (from.isGeneralReg()) {
         // Second scratch register should not be moved by MoveEmitter.
         MOZ_ASSERT(from.reg() != spilledReg_);
 
-        if (to.isGeneralReg())
+        if (to.isGeneralReg()) {
             masm.move32(from.reg(), to.reg());
-        else if (to.isMemory())
+        } else if (to.isMemory()) {
             masm.store32(from.reg(), getAdjustedAddress(to));
-        else
+        } else {
             MOZ_CRASH("Invalid emitInt32Move arguments.");
+        }
     } else if (from.isMemory()) {
         if (to.isGeneralReg()) {
             masm.load32(getAdjustedAddress(from), to.reg());
         } else if (to.isMemory()) {
             masm.load32(getAdjustedAddress(from), tempReg());
             masm.store32(tempReg(), getAdjustedAddress(to));
         } else {
             MOZ_CRASH("Invalid emitInt32Move arguments.");

--- a/js/src/jit/mips32/Architecture-mips32.cpp
+++ b/js/src/jit/mips32/Architecture-mips32.cpp
@@ -27,38 +27,41 @@ const Registers::SetType Registers::JSCa
 const Registers::SetType Registers::CallMask =
     (1 << Registers::v0) |
     (1 << Registers::v1);  // used for double-size returns
 
 FloatRegisters::Encoding
 FloatRegisters::FromName(const char* name)
 {
     for (size_t i = 0; i < RegisterIdLimit; i++) {
-        if (strcmp(GetName(i), name) == 0)
+        if (strcmp(GetName(i), name) == 0) {
             return Encoding(i);
+        }
     }
 
     return Invalid;
 }
 
 FloatRegister
 FloatRegister::doubleOverlay() const
 {
     MOZ_ASSERT(isNotOdd());
-    if (isSingle())
+    if (isSingle()) {
         return FloatRegister(code_, Double);
+    }
     return *this;
 }
 
 FloatRegister
 FloatRegister::singleOverlay() const
 {
     MOZ_ASSERT(isNotOdd());
-    if (isDouble())
+    if (isDouble()) {
         return FloatRegister(code_, Single);
+    }
     return *this;
 }
 
 FloatRegisterSet
 FloatRegister::ReduceSetForPush(const FloatRegisterSet& s)
 {
     LiveFloatRegisterSet mod;
     for (FloatRegisterIterator iter(s); iter.more(); ++iter) {
@@ -74,18 +77,19 @@ FloatRegister::GetPushSizeInBytes(const 
     FloatRegisterSet ss = s.reduceSetForPush();
     uint64_t bits = ss.bits();
     // We are only pushing double registers.
     MOZ_ASSERT((bits & 0xFFFF) == 0);
     uint32_t ret =  mozilla::CountPopulation32(bits) * sizeof(double);
 
     // Additional space needed by MacroAssembler::PushRegsInMask to ensure
     // correct alignment of double values.
-    if (ret)
+    if (ret) {
         ret += sizeof(double);
+    }
 
     return ret;
 }
 uint32_t
 FloatRegister::getRegisterDumpOffsetInBytes()
 {
     MOZ_ASSERT(isNotOdd());
     return id() * sizeof(float);

--- a/js/src/jit/mips32/Architecture-mips32.h
+++ b/js/src/jit/mips32/Architecture-mips32.h
@@ -186,35 +186,39 @@ class FloatRegister : public FloatRegist
     }
     uint32_t numAliased() const {
         MOZ_ASSERT(isNotOdd());
         return 2;
     }
     FloatRegister aliased(uint32_t aliasIdx) {
         MOZ_ASSERT(isNotOdd());
 
-        if (aliasIdx == 0)
+        if (aliasIdx == 0) {
             return *this;
+        }
         MOZ_ASSERT(aliasIdx == 1);
-        if (isDouble())
+        if (isDouble()) {
             return singleOverlay();
+        }
         return doubleOverlay();
     }
     uint32_t numAlignedAliased() const {
         MOZ_ASSERT(isNotOdd());
         return 2;
     }
     FloatRegister alignedAliased(uint32_t aliasIdx) {
         MOZ_ASSERT(isNotOdd());
 
-        if (aliasIdx == 0)
+        if (aliasIdx == 0) {
             return *this;
+        }
         MOZ_ASSERT(aliasIdx == 1);
-        if (isDouble())
+        if (isDouble()) {
             return singleOverlay();
+        }
         return doubleOverlay();
     }
 
     SetType alignedOrDominatedAliasedSet() const {
         MOZ_ASSERT(isNotOdd());
         return (SetType(1) << (code_ >> 1)) * ((1 << FloatRegisters::TotalSingle) + 1);
     }
 

--- a/js/src/jit/mips32/Assembler-mips32.cpp
+++ b/js/src/jit/mips32/Assembler-mips32.cpp
@@ -22,66 +22,70 @@ ABIArgGenerator::ABIArgGenerator()
 
 ABIArg
 ABIArgGenerator::next(MIRType type)
 {
     Register destReg;
     switch (type) {
       case MIRType::Int32:
       case MIRType::Pointer:
-        if (GetIntArgReg(usedArgSlots_, &destReg))
+        if (GetIntArgReg(usedArgSlots_, &destReg)) {
             current_ = ABIArg(destReg);
-        else
+        } else {
             current_ = ABIArg(usedArgSlots_ * sizeof(intptr_t));
+        }
         usedArgSlots_++;
         break;
       case MIRType::Int64:
         if (!usedArgSlots_) {
             current_ = ABIArg(a0, a1);
             usedArgSlots_ = 2;
         } else if (usedArgSlots_ <= 2) {
             current_ = ABIArg(a2, a3);
             usedArgSlots_ = 4;
         } else {
-            if (usedArgSlots_ < NumIntArgRegs)
+            if (usedArgSlots_ < NumIntArgRegs) {
                 usedArgSlots_ = NumIntArgRegs;
+            }
             usedArgSlots_ += usedArgSlots_ % 2;
             current_ = ABIArg(usedArgSlots_ * sizeof(intptr_t));
             usedArgSlots_ += 2;
         }
         break;
       case MIRType::Float32:
         if (!usedArgSlots_) {
             current_ = ABIArg(f12.asSingle());
             firstArgFloatSize_ = 1;
         } else if (usedArgSlots_ == firstArgFloatSize_) {
             current_ = ABIArg(f14.asSingle());
         } else if (useGPRForFloats_ && GetIntArgReg(usedArgSlots_, &destReg)) {
             current_ = ABIArg(destReg);
         } else {
-            if (usedArgSlots_ < NumIntArgRegs)
+            if (usedArgSlots_ < NumIntArgRegs) {
                 usedArgSlots_ = NumIntArgRegs;
+            }
             current_ = ABIArg(usedArgSlots_ * sizeof(intptr_t));
         }
         usedArgSlots_++;
         break;
       case MIRType::Double:
         if (!usedArgSlots_) {
             current_ = ABIArg(f12);
             usedArgSlots_ = 2;
             firstArgFloatSize_ = 2;
         } else if (usedArgSlots_ == firstArgFloatSize_) {
             current_ = ABIArg(f14);
             usedArgSlots_ = 4;
         } else if (useGPRForFloats_ && usedArgSlots_ <= 2) {
             current_ = ABIArg(a2, a3);
             usedArgSlots_ = 4;
         } else {
-            if (usedArgSlots_ < NumIntArgRegs)
+            if (usedArgSlots_ < NumIntArgRegs) {
                 usedArgSlots_ = NumIntArgRegs;
+            }
             usedArgSlots_ += usedArgSlots_ % 2;
             current_ = ABIArg(usedArgSlots_ * sizeof(intptr_t));
             usedArgSlots_ += 2;
         }
         break;
       default:
         MOZ_CRASH("Unexpected argument type");
     }
@@ -129,18 +133,19 @@ jit::PatchJump(CodeLocationJump& jump_, 
 }
 
 void
 Assembler::executableCopy(uint8_t* buffer, bool flushICache)
 {
     MOZ_ASSERT(isFinished);
     m_buffer.executableCopy(buffer);
 
-    if (flushICache)
+    if (flushICache) {
         AutoFlushICache::setRange(uintptr_t(buffer), m_buffer.size());
+    }
 }
 
 uintptr_t
 Assembler::GetPointer(uint8_t* instPtr)
 {
     Instruction* inst = (Instruction*)instPtr;
     return Assembler::ExtractLuiOriValue(inst, inst->next());
 }

--- a/js/src/jit/mips32/Assembler-mips32.h
+++ b/js/src/jit/mips32/Assembler-mips32.h
@@ -34,18 +34,19 @@ class ABIArgGenerator
     ABIArg next(MIRType argType);
     ABIArg& current() { return current_; }
 
     void enforceO32ABI() {
         useGPRForFloats_ = true;
     }
 
     uint32_t stackBytesConsumedSoFar() const {
-        if (usedArgSlots_ <= 4)
+        if (usedArgSlots_ <= 4) {
             return ShadowStackSpace;
+        }
 
         return usedArgSlots_ * sizeof(intptr_t);
     }
 };
 
 // These registers may be volatile or nonvolatile.
 static constexpr Register ABINonArgReg0 = t0;
 static constexpr Register ABINonArgReg1 = t1;
@@ -219,24 +220,26 @@ GetIntArgReg(uint32_t usedArgSlots, Regi
 // run out too.
 static inline bool
 GetTempRegForIntArg(uint32_t usedIntArgs, uint32_t usedFloatArgs, Register* out)
 {
     // NOTE: We can't properly determine which regs are used if there are
     // float arguments. If this is needed, we will have to guess.
     MOZ_ASSERT(usedFloatArgs == 0);
 
-    if (GetIntArgReg(usedIntArgs, out))
+    if (GetIntArgReg(usedIntArgs, out)) {
         return true;
+    }
     // Unfortunately, we have to assume things about the point at which
     // GetIntArgReg returns false, because we need to know how many registers it
     // can allocate.
     usedIntArgs -= NumIntArgRegs;
-    if (usedIntArgs >= NumCallTempNonArgRegs)
+    if (usedIntArgs >= NumCallTempNonArgRegs) {
         return false;
+    }
     *out = CallTempNonArgRegs[usedIntArgs];
     return true;
 }
 
 static inline uint32_t
 GetArgStackDisp(uint32_t usedArgSlots)
 {
     MOZ_ASSERT(usedArgSlots >= NumIntArgRegs);

--- a/js/src/jit/mips32/Bailouts-mips32.h
+++ b/js/src/jit/mips32/Bailouts-mips32.h
@@ -36,30 +36,32 @@ class BailoutStack
     FrameSizeClass frameClass() const {
         return FrameSizeClass::FromClass(frameClassId_);
     }
     uintptr_t tableOffset() const {
         MOZ_ASSERT(frameClass() != FrameSizeClass::None());
         return tableOffset_;
     }
     uint32_t frameSize() const {
-        if (frameClass() == FrameSizeClass::None())
+        if (frameClass() == FrameSizeClass::None()) {
             return frameSize_;
+        }
         return frameClass().frameSize();
     }
     MachineState machine() {
         return MachineState::FromBailout(regs_, fpregs_);
     }
     SnapshotOffset snapshotOffset() const {
         MOZ_ASSERT(frameClass() == FrameSizeClass::None());
         return snapshotOffset_;
     }
     uint8_t* parentStackPointer() const {
-        if (frameClass() == FrameSizeClass::None())
+        if (frameClass() == FrameSizeClass::None()) {
             return (uint8_t*)this + sizeof(BailoutStack);
+        }
         return (uint8_t*)this + offsetof(BailoutStack, snapshotOffset_);
     }
     static size_t offsetOfFrameClass() {
         return offsetof(BailoutStack, frameClassId_);
     }
     static size_t offsetOfFrameSize() {
         return offsetof(BailoutStack, frameSize_);
     }

--- a/js/src/jit/mips32/CodeGenerator-mips32.cpp
+++ b/js/src/jit/mips32/CodeGenerator-mips32.cpp
@@ -91,20 +91,21 @@ CodeGenerator::visitCompareB(LCompareB* 
     const Register output = ToRegister(lir->output());
 
     MOZ_ASSERT(mir->jsop() == JSOP_STRICTEQ || mir->jsop() == JSOP_STRICTNE);
     Assembler::Condition cond = JSOpToCondition(mir->compareType(), mir->jsop());
 
     Label notBoolean, done;
     masm.branchTestBoolean(Assembler::NotEqual, lhs, &notBoolean);
     {
-        if (rhs->isConstant())
+        if (rhs->isConstant()) {
             masm.cmp32Set(cond, lhs.payloadReg(), Imm32(rhs->toConstant()->toBoolean()), output);
-        else
+        } else {
             masm.cmp32Set(cond, lhs.payloadReg(), ToRegister(rhs), output);
+        }
         masm.jump(&done);
     }
 
     masm.bind(&notBoolean);
     {
         masm.move32(Imm32(mir->jsop() == JSOP_STRICTNE), output);
     }
 
@@ -119,21 +120,22 @@ CodeGenerator::visitCompareBAndBranch(LC
     const LAllocation* rhs = lir->rhs();
 
     MOZ_ASSERT(mir->jsop() == JSOP_STRICTEQ || mir->jsop() == JSOP_STRICTNE);
 
     MBasicBlock* mirNotBoolean = (mir->jsop() == JSOP_STRICTEQ) ? lir->ifFalse() : lir->ifTrue();
     branchToBlock(lhs.typeReg(), ImmType(JSVAL_TYPE_BOOLEAN), mirNotBoolean, Assembler::NotEqual);
 
     Assembler::Condition cond = JSOpToCondition(mir->compareType(), mir->jsop());
-    if (rhs->isConstant())
+    if (rhs->isConstant()) {
         emitBranch(lhs.payloadReg(), Imm32(rhs->toConstant()->toBoolean()), cond, lir->ifTrue(),
                    lir->ifFalse());
-    else
+    } else {
         emitBranch(lhs.payloadReg(), ToRegister(rhs), cond, lir->ifTrue(), lir->ifFalse());
+    }
 }
 
 void
 CodeGenerator::visitCompareBitwise(LCompareBitwise* lir)
 {
     MCompare* mir = lir->mir();
     Assembler::Condition cond = JSOpToCondition(mir->compareType(), mir->jsop());
     const ValueOperand lhs = ToValue(lir, LCompareBitwise::LhsInput);
@@ -250,35 +252,37 @@ CodeGenerator::visitDivOrModI64(LDivOrMo
         masm.bind(&nonZero);
     }
 
     // Handle an integer overflow exception from INT64_MIN / -1.
     if (lir->canBeNegativeOverflow()) {
         Label notOverflow;
         masm.branch64(Assembler::NotEqual, lhs, Imm64(INT64_MIN), &notOverflow);
         masm.branch64(Assembler::NotEqual, rhs, Imm64(-1), &notOverflow);
-        if (lir->mir()->isMod())
+        if (lir->mir()->isMod()) {
             masm.xor64(output, output);
-        else
+        } else {
             masm.wasmTrap(wasm::Trap::IntegerOverflow, lir->bytecodeOffset());
+        }
         masm.jump(&done);
         masm.bind(&notOverflow);
     }
 
     masm.setupWasmABICall();
     masm.passABIArg(lhs.high);
     masm.passABIArg(lhs.low);
     masm.passABIArg(rhs.high);
     masm.passABIArg(rhs.low);
 
     MOZ_ASSERT(gen->compilingWasm());
-    if (lir->mir()->isMod())
+    if (lir->mir()->isMod()) {
         masm.callWithABI(lir->bytecodeOffset(), wasm::SymbolicAddress::ModI64);
-    else
+    } else {
         masm.callWithABI(lir->bytecodeOffset(), wasm::SymbolicAddress::DivI64);
+    }
     MOZ_ASSERT(ReturnReg64 == output);
 
     masm.bind(&done);
 }
 
 void
 CodeGenerator::visitUDivOrModI64(LUDivOrModI64* lir)
 {
@@ -297,20 +301,21 @@ CodeGenerator::visitUDivOrModI64(LUDivOr
 
     masm.setupWasmABICall();
     masm.passABIArg(lhs.high);
     masm.passABIArg(lhs.low);
     masm.passABIArg(rhs.high);
     masm.passABIArg(rhs.low);
 
     MOZ_ASSERT(gen->compilingWasm());
-    if (lir->mir()->isMod())
+    if (lir->mir()->isMod()) {
         masm.callWithABI(lir->bytecodeOffset(), wasm::SymbolicAddress::UModI64);
-    else
+    } else {
         masm.callWithABI(lir->bytecodeOffset(), wasm::SymbolicAddress::UDivI64);
+    }
 }
 
 template <typename T>
 void
 CodeGeneratorMIPS::emitWasmLoadI64(T* lir)
 {
     const MWasmLoad* mir = lir->mir();
 
@@ -421,34 +426,37 @@ CodeGenerator::visitWasmReinterpretToI64
 }
 
 void
 CodeGenerator::visitExtendInt32ToInt64(LExtendInt32ToInt64* lir)
 {
     Register input = ToRegister(lir->input());
     Register64 output = ToOutRegister64(lir);
 
-    if (input != output.low)
+    if (input != output.low) {
         masm.move32(input, output.low);
-    if (lir->mir()->isUnsigned())
+    }
+    if (lir->mir()->isUnsigned()) {
         masm.move32(Imm32(0), output.high);
-    else
+    } else {
         masm.ma_sra(output.high, output.low, Imm32(31));
+    }
 }
 
 void
 CodeGenerator::visitWrapInt64ToInt32(LWrapInt64ToInt32* lir)
 {
     const LInt64Allocation& input = lir->getInt64Operand(0);
     Register output = ToRegister(lir->output());
 
-    if (lir->mir()->bottomHalf())
+    if (lir->mir()->bottomHalf()) {
         masm.move32(ToRegister(input.low()), output);
-    else
+    } else {
         masm.move32(ToRegister(input.high()), output);
+    }
 }
 
 void
 CodeGenerator::visitSignExtendInt64(LSignExtendInt64* lir)
 {
     Register64 input = ToRegister64(lir->getInt64Operand(0));
     Register64 output = ToOutRegister64(lir);
     switch (lir->mode()) {
@@ -511,35 +519,37 @@ CodeGenerator::visitWasmTruncateToInt64(
     }
 
     if (!lir->mir()->isSaturating()) {
         masm.Push(input);
 
         masm.setupWasmABICall();
         masm.passABIArg(arg, MoveOp::DOUBLE);
 
-        if (lir->mir()->isUnsigned())
+        if (lir->mir()->isUnsigned()) {
             masm.callWithABI(mir->bytecodeOffset(), wasm::SymbolicAddress::TruncateDoubleToUint64);
-        else
+        } else {
             masm.callWithABI(mir->bytecodeOffset(), wasm::SymbolicAddress::TruncateDoubleToInt64);
+        }
 
         masm.Pop(input);
 
         masm.ma_xor(ScratchRegister, output.high, Imm32(0x80000000));
         masm.ma_or(ScratchRegister, output.low);
         masm.ma_b(ScratchRegister, Imm32(0), ool->entry(), Assembler::Equal);
 
         masm.bind(ool->rejoin());
     } else {
         masm.setupWasmABICall();
         masm.passABIArg(arg, MoveOp::DOUBLE);
-        if (lir->mir()->isUnsigned())
+        if (lir->mir()->isUnsigned()) {
             masm.callWithABI(mir->bytecodeOffset(), wasm::SymbolicAddress::SaturatingTruncateDoubleToUint64);
-        else
+        } else {
             masm.callWithABI(mir->bytecodeOffset(), wasm::SymbolicAddress::SaturatingTruncateDoubleToInt64);
+        }
     }
 
     MOZ_ASSERT(ReturnReg64 == output);
 }
 
 void
 CodeGenerator::visitInt64ToFloatingPoint(LInt64ToFloatingPoint* lir)
 {
@@ -548,26 +558,29 @@ CodeGenerator::visitInt64ToFloatingPoint
 
     MInt64ToFloatingPoint* mir = lir->mir();
     MIRType toType = mir->type();
 
     masm.setupWasmABICall();
     masm.passABIArg(input.high);
     masm.passABIArg(input.low);
 
-    if (lir->mir()->isUnsigned())
-        if (toType == MIRType::Double)
+    if (lir->mir()->isUnsigned()) {
+        if (toType == MIRType::Double) {
             masm.callWithABI(mir->bytecodeOffset(), wasm::SymbolicAddress::Uint64ToDouble, MoveOp::DOUBLE);
-        else
+        } else {
             masm.callWithABI(mir->bytecodeOffset(), wasm::SymbolicAddress::Uint64ToFloat32, MoveOp::FLOAT32);
-    else
-        if (toType == MIRType::Double)
+        }
+    } else {
+        if (toType == MIRType::Double) {
             masm.callWithABI(mir->bytecodeOffset(), wasm::SymbolicAddress::Int64ToDouble, MoveOp::DOUBLE);
-        else
+        } else {
             masm.callWithABI(mir->bytecodeOffset(), wasm::SymbolicAddress::Int64ToFloat32, MoveOp::FLOAT32);
+        }
+    }
 
     MOZ_ASSERT_IF(toType == MIRType::Double, *(&output) == ReturnDoubleReg);
     MOZ_ASSERT_IF(toType == MIRType::Float32, *(&output) == ReturnFloat32Reg);
 }
 
 void
 CodeGenerator::visitTestI64AndBranch(LTestI64AndBranch* lir)
 {

--- a/js/src/jit/mips32/LIR-mips32.h
+++ b/js/src/jit/mips32/LIR-mips32.h
@@ -99,29 +99,32 @@ class LDivOrModI64 : public LCallInstruc
     }
 
     MBinaryArithInstruction* mir() const {
         MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
         return static_cast<MBinaryArithInstruction*>(mir_);
     }
 
     bool canBeDivideByZero() const {
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->canBeDivideByZero();
+        }
         return mir_->toDiv()->canBeDivideByZero();
     }
     bool canBeNegativeOverflow() const {
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->canBeNegativeDividend();
+        }
         return mir_->toDiv()->canBeNegativeOverflow();
     }
     wasm::BytecodeOffset bytecodeOffset() const {
         MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->bytecodeOffset();
+        }
         return mir_->toDiv()->bytecodeOffset();
     }
 };
 
 class LUDivOrModI64 : public LCallInstructionHelper<INT64_PIECES, INT64_PIECES*2, 0>
 {
   public:
     LIR_HEADER(UDivOrModI64)
@@ -136,29 +139,32 @@ class LUDivOrModI64 : public LCallInstru
         setInt64Operand(Rhs, rhs);
     }
     MBinaryArithInstruction* mir() const {
         MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
         return static_cast<MBinaryArithInstruction*>(mir_);
     }
 
     bool canBeDivideByZero() const {
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->canBeDivideByZero();
+        }
         return mir_->toDiv()->canBeDivideByZero();
     }
     bool canBeNegativeOverflow() const {
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->canBeNegativeDividend();
+        }
         return mir_->toDiv()->canBeNegativeOverflow();
     }
     wasm::BytecodeOffset bytecodeOffset() const {
         MOZ_ASSERT(mir_->isDiv() || mir_->isMod());
-        if (mir_->isMod())
+        if (mir_->isMod()) {
             return mir_->toMod()->bytecodeOffset();
+        }
         return mir_->toDiv()->bytecodeOffset();
     }
 };
 
 class LWasmTruncateToInt64 : public LCallInstructionHelper<INT64_PIECES, 1, 0>
 {
   public:
     LIR_HEADER(WasmTruncateToInt64);

--- a/js/src/jit/mips32/Lowering-mips32.cpp
+++ b/js/src/jit/mips32/Lowering-mips32.cpp
@@ -68,45 +68,48 @@ LIRGenerator::visitBox(MBox* box)
 
 void
 LIRGenerator::visitUnbox(MUnbox* unbox)
 {
     MDefinition* inner = unbox->getOperand(0);
 
     if (inner->type() == MIRType::ObjectOrNull) {
         LUnboxObjectOrNull* lir = new(alloc()) LUnboxObjectOrNull(useRegisterAtStart(inner));
-        if (unbox->fallible())
+        if (unbox->fallible()) {
             assignSnapshot(lir, unbox->bailoutKind());
+        }
         defineReuseInput(lir, unbox, 0);
         return;
     }
 
     // An unbox on mips reads in a type tag (either in memory or a register) and
     // a payload. Unlike most instructions consuming a box, we ask for the type
     // second, so that the result can re-use the first input.
     MOZ_ASSERT(inner->type() == MIRType::Value);
 
     ensureDefined(inner);
 
     if (IsFloatingPointType(unbox->type())) {
         LUnboxFloatingPoint* lir = new(alloc()) LUnboxFloatingPoint(useBox(inner), unbox->type());
-        if (unbox->fallible())
+        if (unbox->fallible()) {
             assignSnapshot(lir, unbox->bailoutKind());
+        }
         define(lir, unbox);
         return;
     }
 
     // Swap the order we use the box pieces so we can re-use the payload
     // register.
     LUnbox* lir = new(alloc()) LUnbox;
     lir->setOperand(0, usePayloadInRegisterAtStart(inner));
     lir->setOperand(1, useType(inner, LUse::REGISTER));
 
-    if (unbox->fallible())
+    if (unbox->fallible()) {
         assignSnapshot(lir, unbox->bailoutKind());
+    }
 
     // Types and payloads form two separate intervals. If the type becomes dead
     // before the payload, it could be used as a Value without the type being
     // recoverable. Unbox's purpose is to eagerly kill the definition of a type
     // tag, so keeping both alive (for the purpose of gcmaps) is unappealing.
     // Instead, we create a new virtual register.
     defineReuseInput(lir, unbox, 0);
 }

--- a/js/src/jit/mips32/MacroAssembler-mips32-inl.h
+++ b/js/src/jit/mips32/MacroAssembler-mips32-inl.h
@@ -42,25 +42,27 @@ MacroAssembler::moveGPR64ToDouble(Regist
 {
     moveToDoubleHi(src.high, dest);
     moveToDoubleLo(src.low, dest);
 }
 
 void
 MacroAssembler::move64To32(Register64 src, Register dest)
 {
-    if (src.low != dest)
+    if (src.low != dest) {
         move32(src.low, dest);
+    }
 }
 
 void
 MacroAssembler::move32To64ZeroExtend(Register src, Register64 dest)
 {
-    if (src != dest.low)
+    if (src != dest.low) {
         move32(src, dest.low);
+    }
     move32(Imm32(0), dest.high);
 }
 
 void
 MacroAssembler::move8To64SignExtend(Register src, Register64 dest)
 {
     move8SignExtend(src, dest.low);
     move32To64SignExtend(dest.low, dest);
@@ -71,18 +73,19 @@ MacroAssembler::move16To64SignExtend(Reg
 {
     move16SignExtend(src, dest.low);
     move32To64SignExtend(dest.low, dest);
 }
 
 void
 MacroAssembler::move32To64SignExtend(Register src, Register64 dest)
 {
-    if (src != dest.low)
+    if (src != dest.low) {
         move32(src, dest.low);
+    }
     ma_sra(dest.high, dest.low, Imm32(31));
 }
 
 // ===============================================================
 // Logical instructions
 
 void
 MacroAssembler::andPtr(Register src, Register dest)
@@ -94,45 +97,51 @@ void
 MacroAssembler::andPtr(Imm32 imm, Register dest)
 {
     ma_and(dest, imm);
 }
 
 void
 MacroAssembler::and64(Imm64 imm, Register64 dest)
 {
-    if (imm.low().value != int32_t(0xFFFFFFFF))
+    if (imm.low().value != int32_t(0xFFFFFFFF)) {
         and32(imm.low(), dest.low);
-    if (imm.hi().value != int32_t(0xFFFFFFFF))
+    }
+    if (imm.hi().value != int32_t(0xFFFFFFFF)) {
         and32(imm.hi(), dest.high);
+    }
 }
 
 void
 MacroAssembler::and64(Register64 src, Register64 dest)
 {
     and32(src.low, dest.low);
     and32(src.high, dest.high);
 }
 
 void
 MacroAssembler::or64(Imm64 imm, Register64 dest)
 {
-    if (imm.low().value)
+    if (imm.low().value) {
         or32(imm.low(), dest.low);
-    if (imm.hi().value)
+    }
+    if (imm.hi().value) {
         or32(imm.hi(), dest.high);
+    }
 }
 
 void
 MacroAssembler::xor64(Imm64 imm, Register64 dest)
 {
-    if (imm.low().value)
+    if (imm.low().value) {
         xor32(imm.low(), dest.low);
-    if (imm.hi().value)
+    }
+    if (imm.hi().value) {
         xor32(imm.hi(), dest.high);
+    }
 }
 
 void
 MacroAssembler::orPtr(Register src, Register dest)
 {
     ma_or(dest, src);
 }
 
@@ -825,27 +834,29 @@ MacroAssembler::branch64(Condition cond,
           default:
             MOZ_CRASH("Condition code not supported");
         }
         return;
     }
 
     Condition c = ma_cmp64(cond, lhs, val, SecondScratchReg);
     ma_b(SecondScratchReg, SecondScratchReg, success, c);
-    if (fail)
+    if (fail) {
         jump(fail);
+    }
 }
 
 void
 MacroAssembler::branch64(Condition cond, Register64 lhs, Register64 rhs, Label* success, Label* fail)
 {
     Condition c = ma_cmp64(cond, lhs, rhs, SecondScratchReg);
     ma_b(SecondScratchReg, SecondScratchReg, success, c);
-    if (fail)
+    if (fail) {
         jump(fail);
+    }
 }
 
 void
 MacroAssembler::branchPrivatePtr(Condition cond, const Address& lhs, Register rhs, Label* label)
 {
     branchPtr(cond, lhs, rhs, label);
 }
 
@@ -964,20 +975,21 @@ MacroAssembler::branchTestMagic(Conditio
 }
 
 void
 MacroAssembler::branchTestMagic(Condition cond, const Address& valaddr, JSWhyMagic why, Label* label)
 {
     MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual);
 
     Label notMagic;
-    if (cond == Assembler::Equal)
+    if (cond == Assembler::Equal) {
         branchTestMagic(Assembler::NotEqual, valaddr, &notMagic);
-    else
+    } else {
         branchTestMagic(Assembler::NotEqual, valaddr, label);
+    }
 
     branch32(cond, ToPayload(valaddr), Imm32(why), label);
     bind(&notMagic);
 }
 
 void
 MacroAssembler::branchTruncateDoubleMaybeModUint32(FloatRegister src, Register dest, Label* fail)
 {
@@ -1006,18 +1018,19 @@ MacroAssemblerMIPSCompat::incrementInt32
 {
     asMasm().add32(Imm32(1), ToPayload(addr));
 }
 
 void
 MacroAssemblerMIPSCompat::computeEffectiveAddress(const BaseIndex& address, Register dest)
 {
     computeScaledAddress(address, dest);
-    if (address.offset)
+    if (address.offset) {
         asMasm().addPtr(Imm32(address.offset), dest);
+    }
 }
 
 void
 MacroAssemblerMIPSCompat::retn(Imm32 n) {
     // pc <- [sp]; sp += n
     loadPtr(Address(StackPointer, 0), ra);
     asMasm().addPtr(n, StackPointer);
     as_jr(ra);

--- a/js/src/jit/mips32/MacroAssembler-mips32.cpp
+++ b/js/src/jit/mips32/MacroAssembler-mips32.cpp
@@ -320,26 +320,28 @@ MacroAssemblerMIPS::ma_load(Register des
         encodedOffset = Imm16(0).encode();
     } else {
         encodedOffset = Imm16(address.offset).encode();
         base = address.base;
     }
 
     switch (size) {
       case SizeByte:
-        if (ZeroExtend == extension)
+        if (ZeroExtend == extension) {
             as_lbu(dest, base, encodedOffset);
-        else
+        } else {
             as_lb(dest, base, encodedOffset);
+        }
         break;
       case SizeHalfWord:
-        if (ZeroExtend == extension)
+        if (ZeroExtend == extension) {
             as_lhu(dest, base, encodedOffset);
-        else
+        } else {
             as_lh(dest, base, encodedOffset);
+        }
         break;
       case SizeWord:
         as_lw(dest, base, encodedOffset);
         break;
       default:
         MOZ_CRASH("Invalid argument for ma_load");
     }
 }
@@ -495,50 +497,54 @@ MacroAssemblerMIPS::ma_bal(Label* label,
 {
     spew("branch .Llabel %p\n", label);
     if (label->bound()) {
         // Generate the long jump for calls because return address has to be
         // the address after the reserved block.
         addLongJump(nextOffset(), BufferOffset(label->offset()));
         ma_liPatchable(ScratchRegister, Imm32(LabelBase::INVALID_OFFSET));
         as_jalr(ScratchRegister);
-        if (delaySlotFill == FillDelaySlot)
+        if (delaySlotFill == FillDelaySlot) {
             as_nop();
+        }
         return;
     }
 
     // Second word holds a pointer to the next branch in label's chain.
     uint32_t nextInChain = label->used() ? label->offset() : LabelBase::INVALID_OFFSET;
 
     // Make the whole branch continous in the buffer.
     m_buffer.ensureSpace(4 * sizeof(uint32_t));
 
     spew("bal .Llabel %p\n", label);
     BufferOffset bo = writeInst(getBranchCode(BranchIsCall).encode());
     writeInst(nextInChain);
-    if (!oom())
+    if (!oom()) {
         label->use(bo.getOffset());
+    }
     // Leave space for long jump.
     as_nop();
-    if (delaySlotFill == FillDelaySlot)
+    if (delaySlotFill == FillDelaySlot) {
         as_nop();
+    }
 }
 
 void
 MacroAssemblerMIPS::branchWithCode(InstImm code, Label* label, JumpKind jumpKind)
 {
     spew("branch .Llabel %p", label);
     MOZ_ASSERT(code.encode() != InstImm(op_regimm, zero, rt_bgezal, BOffImm16(0)).encode());
     InstImm inst_beq = InstImm(op_beq, zero, zero, BOffImm16(0));
 
     if (label->bound()) {
         int32_t offset = label->offset() - m_buffer.nextOffset().getOffset();
 
-        if (BOffImm16::IsInRange(offset))
+        if (BOffImm16::IsInRange(offset)) {
             jumpKind = ShortJump;
+        }
 
         if (jumpKind == ShortJump) {
             MOZ_ASSERT(BOffImm16::IsInRange(offset));
             code.setBOffImm16(BOffImm16(offset));
 #ifdef JS_JITSPEW
             decodeBranchInstAndSpew(code);
 #endif
             writeInst(code.encode());
@@ -582,38 +588,41 @@ MacroAssemblerMIPS::branchWithCode(InstI
 
         // Indicate that this is short jump with offset 4.
         code.setBOffImm16(BOffImm16(4));
 #ifdef JS_JITSPEW
         decodeBranchInstAndSpew(code);
 #endif
         BufferOffset bo = writeInst(code.encode());
         writeInst(nextInChain);
-        if (!oom())
+        if (!oom()) {
             label->use(bo.getOffset());
+        }
         return;
     }
 
     bool conditional = code.encode() != inst_beq.encode();
 
     // Make the whole branch continous in the buffer.
     m_buffer.ensureSpace((conditional ? 5 : 4) * sizeof(uint32_t));
 
 #ifdef JS_JITSPEW
     decodeBranchInstAndSpew(code);
 #endif
     BufferOffset bo = writeInst(code.encode());
     writeInst(nextInChain);
-    if (!oom())
+    if (!oom()) {
         label->use(bo.getOffset());
+    }
     // Leave space for potential long jump.
     as_nop();
     as_nop();
-    if (conditional)
+    if (conditional) {
         as_nop();
+    }
 }
 
 
 void
 MacroAssemblerMIPSCompat::cmp64Set(Condition cond, Register64 lhs, Imm64 val, Register dest) {
 
     if (val.value == 0) {
         switch(cond){
@@ -625,26 +634,28 @@ MacroAssemblerMIPSCompat::cmp64Set(Condi
           case Assembler::NotEqual:
           case Assembler::Above:
             as_or(dest, lhs.high, lhs.low);
             as_sltu(dest, zero, dest);
             break;
           case Assembler::LessThan:
           case Assembler::GreaterThanOrEqual:
             as_slt(dest, lhs.high, zero);
-            if (cond == Assembler::GreaterThanOrEqual)
+            if (cond == Assembler::GreaterThanOrEqual) {
                 as_xori(dest, dest, 1);
+            }
             break;
           case Assembler::GreaterThan:
           case Assembler::LessThanOrEqual:
             as_or(SecondScratchReg, lhs.high, lhs.low);
             as_sra(ScratchRegister, lhs.high, 31);
             as_sltu(dest, ScratchRegister, SecondScratchReg);
-            if (cond == Assembler::LessThanOrEqual)
+            if (cond == Assembler::LessThanOrEqual) {
                 as_xori(dest, dest, 1);
+            }
             break;
           case Assembler::Below:
           case Assembler::AboveOrEqual:
             as_ori(dest, zero, cond == Assembler::AboveOrEqual ? 1 : 0);
             break;
           default:
             MOZ_CRASH("Condition code not supported");
             break;
@@ -935,33 +946,35 @@ MacroAssemblerMIPS::ma_sdc1WordAligned(F
 
     as_swc1(ft, base, off + PAYLOAD_OFFSET);
     as_swc1(getOddPair(ft), base, off + TAG_OFFSET);
 }
 
 void
 MacroAssemblerMIPS::ma_pop(FloatRegister f)
 {
-    if (f.isDouble())
+    if (f.isDouble()) {
         ma_ldc1WordAligned(f, StackPointer, 0);
-    else
+    } else {
         as_lwc1(f, StackPointer, 0);
+    }
 
     as_addiu(StackPointer, StackPointer, f.size());
 }
 
 void
 MacroAssemblerMIPS::ma_push(FloatRegister f)
 {
     as_addiu(StackPointer, StackPointer, -f.size());
 
-    if(f.isDouble())
+    if (f.isDouble()) {
         ma_sdc1WordAligned(f, StackPointer, 0);
-    else
+    } else {
         as_swc1(f, StackPointer, 0);
+    }
 }
 
 bool
 MacroAssemblerMIPSCompat::buildOOLFakeExitFrame(void* fakeReturnAddr)
 {
     uint32_t descriptor = MakeFrameDescriptor(asMasm().framePushed(), FrameType::IonJS,
                                               ExitFrameLayout::Size());
 
@@ -1400,18 +1413,19 @@ MacroAssemblerMIPSCompat::testUndefinedS
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     ma_cmp_set(dest, value.typeReg(), ImmType(JSVAL_TYPE_UNDEFINED), cond);
 }
 
 // unboxing code
 void
 MacroAssemblerMIPSCompat::unboxNonDouble(const ValueOperand& operand, Register dest, JSValueType)
 {
-    if (operand.payloadReg() != dest)
+    if (operand.payloadReg() != dest) {
         ma_move(dest, operand.payloadReg());
+    }
 }
 
 void
 MacroAssemblerMIPSCompat::unboxNonDouble(const Address& src, Register dest, JSValueType)
 {
     ma_lw(dest, Address(src.base, src.offset + PAYLOAD_OFFSET));
 }
 
@@ -1514,18 +1528,19 @@ MacroAssemblerMIPSCompat::boxDouble(Floa
     moveFromDoubleLo(src, dest.payloadReg());
     moveFromDoubleHi(src, dest.typeReg());
 }
 
 void
 MacroAssemblerMIPSCompat::boxNonDouble(JSValueType type, Register src,
                                        const ValueOperand& dest)
 {
-    if (src != dest.payloadReg())
+    if (src != dest.payloadReg()) {
         ma_move(dest.payloadReg(), src);
+    }
     ma_li(dest.typeReg(), ImmType(type));
 }
 
 void
 MacroAssemblerMIPSCompat::boolValueToDouble(const ValueOperand& operand, FloatRegister dest)
 {
     convertBoolToInt32(operand.payloadReg(), ScratchRegister);
     convertInt32ToDouble(ScratchRegister, dest);
@@ -1636,20 +1651,21 @@ uint32_t
 MacroAssemblerMIPSCompat::getType(const Value& val)
 {
     return val.toNunboxTag();
 }
 
 void
 MacroAssemblerMIPSCompat::moveData(const Value& val, Register data)
 {
-    if (val.isGCThing())
+    if (val.isGCThing()) {
         ma_li(data, ImmGCPtr(val.toGCThing()));
-    else
+    } else {
         ma_li(data, Imm32(val.toNunboxPayload()));
+    }
 }
 
 CodeOffsetJump
 MacroAssemblerMIPSCompat::jumpWithPatch(RepatchLabel* label)
 {
     // Only one branch per label.
     MOZ_ASSERT(!label->used());
 
@@ -1757,18 +1773,19 @@ MacroAssemblerMIPSCompat::loadValue(Addr
     }
 }
 
 void
 MacroAssemblerMIPSCompat::tagValue(JSValueType type, Register payload, ValueOperand dest)
 {
     MOZ_ASSERT(payload != dest.typeReg());
     ma_li(dest.typeReg(), ImmType(type));
-    if (payload != dest.payloadReg())
+    if (payload != dest.payloadReg()) {
         ma_move(dest.payloadReg(), payload);
+    }
 }
 
 void
 MacroAssemblerMIPSCompat::pushValue(ValueOperand val)
 {
     // Allocate stack slots for type and payload. One for each.
     asMasm().subPtr(Imm32(sizeof(Value)), StackPointer);
     // Store type and payload.
@@ -2049,18 +2066,19 @@ void
 MacroAssemblerMIPSCompat::profilerExitFrame()
 {
     jump(GetJitContext()->runtime->jitRuntime()->getProfilerExitFrameTail());
 }
 
 void
 MacroAssembler::subFromStackPtr(Imm32 imm32)
 {
-    if (imm32.value)
+    if (imm32.value) {
         asMasm().subPtr(imm32, StackPointer);
+    }
 }
 
 //{{{ check_macroassembler_style
 // ===============================================================
 // Stack manipulation functions.
 
 void
 MacroAssembler::PushRegsInMask(LiveRegisterSet set)
@@ -2105,28 +2123,30 @@ MacroAssembler::PopRegsInMaskIgnore(Live
         // Read the buffer form the first aligned location.
         ma_addu(SecondScratchReg, sp, Imm32(reservedF));
         ma_and(SecondScratchReg, SecondScratchReg, Imm32(~(ABIStackAlignment - 1)));
 
         diffF -= sizeof(double);
 
         LiveFloatRegisterSet fpignore(ignore.fpus().reduceSetForPush());
         for (FloatRegisterForwardIterator iter(set.fpus().reduceSetForPush()); iter.more(); ++iter) {
-            if (!ignore.has(*iter))
+            if (!ignore.has(*iter)) {
                 as_ldc1(*iter, SecondScratchReg, -diffF);
+            }
             diffF -= sizeof(double);
         }
         freeStack(reservedF);
         MOZ_ASSERT(diffF == 0);
     }
 
     for (GeneralRegisterBackwardIterator iter(set.gprs()); iter.more(); ++iter) {
         diffG -= sizeof(intptr_t);
-        if (!ignore.has(*iter))
+        if (!ignore.has(*iter)) {
             loadPtr(Address(StackPointer, diffG), *iter);
+        }
     }
     freeStack(reservedG);
     MOZ_ASSERT(diffG == 0);
 }
 
 void
 MacroAssembler::storeRegsInMask(LiveRegisterSet set, Address dest, Register scratch)
 {
@@ -2198,18 +2218,19 @@ MacroAssembler::callWithABIPre(uint32_t*
     // Save $ra because call is going to clobber it. Restore it in
     // callWithABIPost. NOTE: This is needed for calls from SharedIC.
     // Maybe we can do this differently.
     storePtr(ra, Address(StackPointer, stackForCall - sizeof(intptr_t)));
 
     // Position all arguments.
     {
         enoughMemory_ &= moveResolver_.resolve();
-        if (!enoughMemory_)
+        if (!enoughMemory_) {
             return;
+        }
 
         MoveEmitter emitter(*this);
         emitter.emit(moveResolver_);
         emitter.finish();
     }
 
     assertStackAlignment(ABIStackAlignment);
 }
@@ -2269,18 +2290,19 @@ MacroAssembler::moveValue(const TypedOrV
         return;
     }
 
     MIRType type = src.type();
     AnyRegister reg = src.typedReg();
 
     if (!IsFloatingPointType(type)) {
         mov(ImmWord(MIRTypeToTag(type)), dest.typeReg());
-        if (reg.gpr() != dest.payloadReg())
+        if (reg.gpr() != dest.payloadReg()) {
             move32(reg.gpr(), dest.payloadReg());
+        }
         return;
     }
 
     ScratchDoubleScope scratch(*this);
     FloatRegister freg = reg.fpu();
     if (type == MIRType::Float32) {
         convertFloat32ToDouble(freg, scratch);
         freg = scratch;
@@ -2309,30 +2331,33 @@ MacroAssembler::moveValue(const ValueOpe
             move32(scratch, d0);
             return;
         }
         // If only one is, copy that source first.
         mozilla::Swap(s0, s1);
         mozilla::Swap(d0, d1);
     }
 
-    if (s0 != d0)
+    if (s0 != d0) {
         move32(s0, d0);
-    if (s1 != d1)
+    }
+    if (s1 != d1) {
         move32(s1, d1);
+    }
 }
 
 void
 MacroAssembler::moveValue(const Value& src, const ValueOperand& dest)
 {
     move32(Imm32(src.toNunboxTag()), dest.typeReg());
-    if (src.isGCThing())
+    if (src.isGCThing()) {
         movePtr(ImmGCPtr(src.toGCThing()), dest.payloadReg());
-    else
+    } else {
         move32(Imm32(src.toNunboxPayload()), dest.payloadReg());
+    }
 }
 
 // ===============================================================
 // Branch functions
 
 void
 MacroAssembler::branchValueIsNurseryCell(Condition cond, const Address& address,
                                          Register temp, Label* label)
@@ -2409,24 +2434,26 @@ MacroAssembler::storeUnboxedValue(const 
                                   const T& dest, MIRType slotType)
 {
     if (valueType == MIRType::Double) {
         storeDouble(value.reg().typedReg().fpu(), dest);
         return;
     }
 
     // Store the type tag if needed.
-    if (valueType != slotType)
+    if (valueType != slotType) {
         storeTypeTag(ImmType(ValueTypeFromMIRType(valueType)), dest);
+    }
 
     // Store the payload.
-    if (value.constant())
+    if (value.constant()) {
         storePayload(value.value(), dest);
-    else
+    } else {
         storePayload(value.reg().typedReg().gpr(), dest);
+    }
 }
 
 template void
 MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
                                   const Address& dest, MIRType slotType);
 template void
 MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
                                   const BaseObjectElementIndex& dest, MIRType slotType);
@@ -2567,39 +2594,41 @@ MacroAssemblerMIPSCompat::wasmLoadI64Imp
     BaseIndex address(memoryBase, ptr, TimesOne);
     MOZ_ASSERT(INT64LOW_OFFSET == 0);
     if (IsUnaligned(access)) {
         MOZ_ASSERT(tmp != InvalidReg);
         if (byteSize <= 4) {
             asMasm().ma_load_unaligned(access, output.low, address, tmp,
                                        static_cast<LoadStoreSize>(8 * byteSize),
                                        isSigned ? SignExtend : ZeroExtend);
-            if (!isSigned)
+            if (!isSigned) {
                 asMasm().move32(Imm32(0), output.high);
-            else
+            } else {
                 asMasm().ma_sra(output.high, output.low, Imm32(31));
+            }
         } else {
             MOZ_ASSERT(output.low != ptr);
             asMasm().ma_load_unaligned(access, output.low, address, tmp, SizeWord, ZeroExtend);
             asMasm().ma_load_unaligned(access, output.high,
                                        BaseIndex(HeapReg, ptr, TimesOne, INT64HIGH_OFFSET),
                                        tmp, SizeWord, SignExtend);
         }
         return;
     }
 
     asMasm().memoryBarrierBefore(access.sync());
     if (byteSize <= 4) {
         asMasm().ma_load(output.low, address, static_cast<LoadStoreSize>(8 * byteSize),
                          isSigned ? SignExtend : ZeroExtend);
         asMasm().append(access, asMasm().size() - 4);
-        if (!isSigned)
+        if (!isSigned) {
             asMasm().move32(Imm32(0), output.high);
-        else
+        } else {
             asMasm().ma_sra(output.high, output.low, Imm32(31));
+        }
     } else {
         MOZ_ASSERT(output.low != ptr);
         asMasm().ma_load(output.low, BaseIndex(HeapReg, ptr, TimesOne), SizeWord);
         asMasm().append(access, asMasm().size() - 4);
         asMasm().ma_load(output.high, BaseIndex(HeapReg, ptr, TimesOne, INT64HIGH_OFFSET), SizeWord);
         asMasm().append(access, asMasm().size() - 4);
     }
     asMasm().memoryBarrierAfter(access.sync());

--- a/js/src/jit/mips32/MacroAssembler-mips32.h
+++ b/js/src/jit/mips32/MacroAssembler-mips32.h
@@ -455,27 +455,29 @@ class MacroAssemblerMIPSCompat : public 
     void moveData(const Value& val, Register data);
 
   public:
     void moveValue(const Value& val, Register type, Register data);
 
     CodeOffsetJump jumpWithPatch(RepatchLabel* label);
 
     void loadUnboxedValue(Address address, MIRType type, AnyRegister dest) {
-        if (dest.isFloat())
+        if (dest.isFloat()) {
             loadInt32OrDouble(address, dest.fpu());
-        else
+        } else {
             ma_lw(dest.gpr(), ToPayload(address));
+        }
     }
 
     void loadUnboxedValue(BaseIndex address, MIRType type, AnyRegister dest) {
-        if (dest.isFloat())
+        if (dest.isFloat()) {
             loadInt32OrDouble(address.base, address.index, dest.fpu(), address.scale);
-        else
+        } else {
             load32(ToPayload(address), dest.gpr());
+        }
     }
 
     template <typename T>
     void storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const T& dest,
                            MIRType slotType);
 
     template <typename T>
     void storeUnboxedPayload(ValueOperand value, T address, size_t nbytes, JSValueType) {
@@ -508,20 +510,22 @@ class MacroAssemblerMIPSCompat : public 
                 move32(ScratchRegister, d0);
                 return;
             }
             // If only one is, copy that source first.
             mozilla::Swap(s0, s1);
             mozilla::Swap(d0, d1);
         }
 
-        if (s0 != d0)
+        if (s0 != d0) {
             move32(s0, d0);
-        if (s1 != d1)
+        }
+        if (s1 != d1) {
             move32(s1, d1);
+        }
     }
 
     void storeValue(ValueOperand val, Operand dst);
     void storeValue(ValueOperand val, const BaseIndex& dest);
     void storeValue(JSValueType type, Register reg, BaseIndex dest);
     void storeValue(ValueOperand val, const Address& dest);
     void storeValue(JSValueType type, Register reg, Address dest);
     void storeValue(const Value& val, Address dest);
@@ -541,31 +545,33 @@ class MacroAssemblerMIPSCompat : public 
     void loadValue(const BaseIndex& addr, ValueOperand val);
     void tagValue(JSValueType type, Register payload, ValueOperand dest);
 
     void pushValue(ValueOperand val);
     void popValue(ValueOperand val);
 #if MOZ_LITTLE_ENDIAN
     void pushValue(const Value& val) {
         push(Imm32(val.toNunboxTag()));
-        if (val.isGCThing())
+        if (val.isGCThing()) {
             push(ImmGCPtr(val.toGCThing()));
-        else
+        } else {
             push(Imm32(val.toNunboxPayload()));
+        }
     }
     void pushValue(JSValueType type, Register reg) {
         push(ImmTag(JSVAL_TYPE_TO_TAG(type)));
         ma_push(reg);
     }
 #else
     void pushValue(const Value& val) {
-        if (val.isGCThing())
+        if (val.isGCThing()) {
             push(ImmGCPtr(val.toGCThing()));
-        else
+        } else {
             push(Imm32(val.toNunboxPayload()));
+        }
         push(Imm32(val.toNunboxTag()));
     }
     void pushValue(JSValueType type, Register reg) {
         ma_push(reg);
         push(ImmTag(JSVAL_TYPE_TO_TAG(type)));
     }
 #endif
     void pushValue(const Address& addr);