/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * vim: set ts=8 sts=4 et sw=4 tw=99: * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #ifndef jit_arm64_CodeGenerator_arm64_h #define jit_arm64_CodeGenerator_arm64_h #include "jit/arm64/Assembler-arm64.h" #include "jit/shared/CodeGenerator-shared.h" namespace js { namespace jit { class OutOfLineBailout; class OutOfLineTableSwitch; class CodeGeneratorARM64 : public CodeGeneratorShared { friend class MoveResolverARM64; CodeGeneratorARM64* thisFromCtor() { return this; } public: CodeGeneratorARM64(MIRGenerator* gen, LIRGraph* graph, MacroAssembler* masm); protected: NonAssertingLabel deoptLabel_; MoveOperand toMoveOperand(const LAllocation a) const; void bailoutIf(Assembler::Condition condition, LSnapshot* snapshot); void bailoutFrom(Label* label, LSnapshot* snapshot); void bailout(LSnapshot* snapshot); template void bailoutCmpPtr(Assembler::Condition c, T1 lhs, T2 rhs, LSnapshot* snapshot) { masm.cmpPtr(lhs, rhs); return bailoutIf(c, snapshot); } void bailoutTestPtr(Assembler::Condition c, Register lhs, Register rhs, LSnapshot* snapshot) { masm.testPtr(lhs, rhs); return bailoutIf(c, snapshot); } template void bailoutCmp32(Assembler::Condition c, T1 lhs, T2 rhs, LSnapshot* snapshot) { masm.cmp32(lhs, rhs); return bailoutIf(c, snapshot); } template void bailoutTest32(Assembler::Condition c, T1 lhs, T2 rhs, LSnapshot* snapshot) { masm.test32(lhs, rhs); return bailoutIf(c, snapshot); } void bailoutIfFalseBool(Register reg, LSnapshot* snapshot) { masm.test32(reg, Imm32(0xFF)); return bailoutIf(Assembler::Zero, snapshot); } protected: bool generateOutOfLineCode(); void emitRoundDouble(FloatRegister src, Register dest, Label* fail); // Emits a branch that directs control flow to the true block if |cond| is // true, and the false block if |cond| is false. void emitBranch(Assembler::Condition cond, MBasicBlock* ifTrue, MBasicBlock* ifFalse); void testNullEmitBranch(Assembler::Condition cond, const ValueOperand& value, MBasicBlock* ifTrue, MBasicBlock* ifFalse) { cond = masm.testNull(cond, value); emitBranch(cond, ifTrue, ifFalse); } void testUndefinedEmitBranch(Assembler::Condition cond, const ValueOperand& value, MBasicBlock* ifTrue, MBasicBlock* ifFalse) { cond = masm.testUndefined(cond, value); emitBranch(cond, ifTrue, ifFalse); } void testObjectEmitBranch(Assembler::Condition cond, const ValueOperand& value, MBasicBlock* ifTrue, MBasicBlock* ifFalse) { cond = masm.testObject(cond, value); emitBranch(cond, ifTrue, ifFalse); } void testZeroEmitBranch(Assembler::Condition cond, Register reg, MBasicBlock* ifTrue, MBasicBlock* ifFalse) { MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual); masm.cmpPtr(reg, ImmWord(0)); emitBranch(cond, ifTrue, ifFalse); } void emitTableSwitchDispatch(MTableSwitch* mir, Register index, Register base); public: // Instruction visitors. virtual void visitMinMaxD(LMinMaxD* ins) override; virtual void visitMinMaxF(LMinMaxF* math) override; virtual void visitAbsD(LAbsD* ins) override; virtual void visitAbsF(LAbsF* ins) override; virtual void visitSqrtD(LSqrtD* ins) override; virtual void visitSqrtF(LSqrtF* ins) override; virtual void visitAddI(LAddI* ins) override; virtual void visitSubI(LSubI* ins) override; virtual void visitBitNotI(LBitNotI* ins) override; virtual void visitBitOpI(LBitOpI* ins) override; virtual void visitMulI(LMulI* ins) override; virtual void visitDivI(LDivI* ins) override; virtual void visitDivPowTwoI(LDivPowTwoI* ins) override; virtual void visitModI(LModI* ins) override; virtual void visitModPowTwoI(LModPowTwoI* ins) override; virtual void visitModMaskI(LModMaskI* ins) override; virtual void visitPowHalfD(LPowHalfD* ins) override; virtual void visitShiftI(LShiftI* ins) override; virtual void visitUrshD(LUrshD* ins) override; virtual void visitTestIAndBranch(LTestIAndBranch* test) override; virtual void visitCompare(LCompare* comp) override; virtual void visitCompareAndBranch(LCompareAndBranch* comp) override; virtual void visitTestDAndBranch(LTestDAndBranch* test) override; virtual void visitTestFAndBranch(LTestFAndBranch* test) override; virtual void visitCompareD(LCompareD* comp) override; virtual void visitCompareF(LCompareF* comp) override; virtual void visitCompareDAndBranch(LCompareDAndBranch* comp) override; virtual void visitCompareFAndBranch(LCompareFAndBranch* comp) override; virtual void visitCompareB(LCompareB* lir) override; virtual void visitCompareBAndBranch(LCompareBAndBranch* lir) override; virtual void visitCompareBitwise(LCompareBitwise* lir) override; virtual void visitCompareBitwiseAndBranch(LCompareBitwiseAndBranch* lir) override; virtual void visitBitAndAndBranch(LBitAndAndBranch* baab) override; virtual void visitWasmUint32ToDouble(LWasmUint32ToDouble* lir) override; virtual void visitWasmUint32ToFloat32(LWasmUint32ToFloat32* lir) override; virtual void visitNotI(LNotI* ins) override; virtual void visitNotD(LNotD* ins) override; virtual void visitNotF(LNotF* ins) override; virtual void visitMathD(LMathD* math) override; virtual void visitMathF(LMathF* math) override; virtual void visitFloor(LFloor* lir) override; virtual void visitFloorF(LFloorF* lir) override; virtual void visitCeil(LCeil* lir) override; virtual void visitCeilF(LCeilF* lir) override; virtual void visitRound(LRound* lir) override; virtual void visitRoundF(LRoundF* lir) override; virtual void visitTruncateDToInt32(LTruncateDToInt32* ins) override; virtual void visitTruncateFToInt32(LTruncateFToInt32* ins) override; virtual void visitClzI(LClzI* lir) override; virtual void visitCtzI(LCtzI* lir) override; // Out of line visitors. void visitOutOfLineBailout(OutOfLineBailout* ool); void visitOutOfLineTableSwitch(OutOfLineTableSwitch* ool); protected: ValueOperand ToValue(LInstruction* ins, size_t pos); ValueOperand ToOutValue(LInstruction* ins); ValueOperand ToTempValue(LInstruction* ins, size_t pos); // Functions for LTestVAndBranch. Register splitTagForTest(const ValueOperand& value); void storeElementTyped(const LAllocation* value, MIRType valueType, MIRType elementType, Register elements, const LAllocation* index); void divICommon(MDiv* mir, Register lhs, Register rhs, Register output, LSnapshot* snapshot, Label& done); void modICommon(MMod* mir, Register lhs, Register rhs, Register output, LSnapshot* snapshot, Label& done); public: void visitBox(LBox* box) override; void visitUnbox(LUnbox* unbox) override; void visitValue(LValue* value) override; void visitDouble(LDouble* ins) override; void visitFloat32(LFloat32* ins) override; void visitLoadSlotV(LLoadSlotV* load) override; void visitLoadSlotT(LLoadSlotT* load) override; void visitStoreSlotT(LStoreSlotT* load) override; void visitLoadElementT(LLoadElementT* load) override; void visitGuardShape(LGuardShape* guard) override; void visitGuardObjectGroup(LGuardObjectGroup* guard) override; void visitGuardClass(LGuardClass* guard) override; void visitInterruptCheck(LInterruptCheck* lir) override; void visitNegI(LNegI* lir) override; void visitNegD(LNegD* lir) override; void visitNegF(LNegF* lir) override; void visitLoadTypedArrayElementStatic(LLoadTypedArrayElementStatic* ins) override; void visitStoreTypedArrayElementStatic(LStoreTypedArrayElementStatic* ins) override; void visitCompareExchangeTypedArrayElement(LCompareExchangeTypedArrayElement* lir) override; void visitAtomicExchangeTypedArrayElement(LAtomicExchangeTypedArrayElement* lir) override; void visitAsmJSLoadHeap(LAsmJSLoadHeap* ins) override; void visitAsmJSStoreHeap(LAsmJSStoreHeap* ins) override; void visitWasmCompareExchangeHeap(LWasmCompareExchangeHeap* ins) override; void visitWasmAtomicBinopHeap(LWasmAtomicBinopHeap* ins) override; void visitWasmStackArg(LWasmStackArg* ins) override; void generateInvalidateEpilogue(); void setReturnDoubleRegs(LiveRegisterSet* regs); protected: void postWasmCall(LWasmCall* lir) { MOZ_CRASH("postWasmCall"); } void visitEffectiveAddress(LEffectiveAddress* ins) override; void visitUDiv(LUDiv* ins) override; void visitUMod(LUMod* ins) override; public: // Unimplemented SIMD instructions. void visitSimdSplatX4(LSimdSplatX4* lir) override { MOZ_CRASH("NYI"); } void visitSimd128Int(LSimd128Int* ins) override { MOZ_CRASH("NYI"); } void visitSimd128Float(LSimd128Float* ins) override { MOZ_CRASH("NYI"); } void visitSimdExtractElementI(LSimdExtractElementI* ins) override { MOZ_CRASH("NYI"); } void visitSimdExtractElementF(LSimdExtractElementF* ins) override { MOZ_CRASH("NYI"); } void visitSimdBinaryCompIx4(LSimdBinaryCompIx4* lir) override { MOZ_CRASH("NYI"); } void visitSimdBinaryCompFx4(LSimdBinaryCompFx4* lir) override { MOZ_CRASH("NYI"); } void visitSimdBinaryArithIx4(LSimdBinaryArithIx4* lir) override { MOZ_CRASH("NYI"); } void visitSimdBinaryArithFx4(LSimdBinaryArithFx4* lir) override { MOZ_CRASH("NYI"); } void visitSimdBinaryBitwise(LSimdBinaryBitwise* lir) override { MOZ_CRASH("NYI"); } }; typedef CodeGeneratorARM64 CodeGeneratorSpecific; // An out-of-line bailout thunk. class OutOfLineBailout : public OutOfLineCodeBase { protected: // Silence Clang warning. LSnapshot* snapshot_; public: OutOfLineBailout(LSnapshot* snapshot) : snapshot_(snapshot) { } void accept(CodeGeneratorARM64* codegen) override; LSnapshot* snapshot() const { return snapshot_; } }; } // namespace jit } // namespace js #endif /* jit_arm64_CodeGenerator_arm64_h */