static bool DecodeCallWithSig(FunctionDecoder& f, const Sig& sig, ExprType expected) { for (ValType argType : sig.args()) { if (!DecodeExpr(f, ToExprType(argType))) return false; } return CheckType(f, sig.ret(), expected); }
static bool CheckTypeForJS(JSContext* cx, Decoder& d, const Sig& sig) { for (ValType argType : sig.args()) { if (argType == ValType::I64) return Fail(cx, d, "cannot import/export i64 argument"); } if (sig.ret() == ExprType::I64) return Fail(cx, d, "cannot import/export i64 return type"); return true; }
static bool DecodeCallWithSig(FunctionDecoder& f, const Sig& sig, ExprType* type) { for (ValType argType : sig.args()) { ExprType exprType; if (!DecodeExpr(f, &exprType)) return false; if (!CheckType(f, exprType, argType)) return false; } *type = sig.ret(); return true; }
static size_t SizeOfSigExcludingThis(const Sig& sig, MallocSizeOf mallocSizeOf) { return sig.args().sizeOfExcludingThis(mallocSizeOf); }
static size_t SerializedSigSize(const Sig& sig) { return sizeof(ExprType) + SerializedPodVectorSize(sig.args()); }
// Generate a stub that enters wasm from a C++ caller via the native ABI. // The signature of the entry point is Module::CodePtr. The exported wasm // function has an ABI derived from its specific signature, so this function // must map from the ABI of CodePtr to the export's signature's ABI. Offsets wasm::GenerateEntry(MacroAssembler& masm, unsigned target, const Sig& sig, bool usesHeap) { masm.haltingAlign(CodeAlignment); Offsets offsets; offsets.begin = masm.currentOffset(); // Save the return address if it wasn't already saved by the call insn. #if defined(JS_CODEGEN_ARM) masm.push(lr); #elif defined(JS_CODEGEN_MIPS32) || defined(JS_CODEGEN_MIPS64) masm.push(ra); #elif defined(JS_CODEGEN_X86) static const unsigned EntryFrameSize = sizeof(void*); #endif // Save all caller non-volatile registers before we clobber them here and in // the asm.js callee (which does not preserve non-volatile registers). masm.setFramePushed(0); masm.PushRegsInMask(NonVolatileRegs); MOZ_ASSERT(masm.framePushed() == FramePushedAfterSave); // ARM and MIPS/MIPS64 have a globally-pinned GlobalReg (x64 uses RIP-relative // addressing, x86 uses immediates in effective addresses). For the // AsmJSGlobalRegBias addition, see Assembler-(mips,arm).h. #if defined(JS_CODEGEN_ARM) || defined(JS_CODEGEN_MIPS32) || defined(JS_CODEGEN_MIPS64) masm.movePtr(IntArgReg1, GlobalReg); masm.addPtr(Imm32(AsmJSGlobalRegBias), GlobalReg); #endif // ARM, MIPS/MIPS64 and x64 have a globally-pinned HeapReg (x86 uses immediates in // effective addresses). Loading the heap register depends on the global // register already having been loaded. if (usesHeap) masm.loadAsmJSHeapRegisterFromGlobalData(); // Put the 'argv' argument into a non-argument/return register so that we // can use 'argv' while we fill in the arguments for the asm.js callee. // Also, save 'argv' on the stack so that we can recover it after the call. // Use a second non-argument/return register as temporary scratch. Register argv = ABIArgGenerator::NonArgReturnReg0; Register scratch = ABIArgGenerator::NonArgReturnReg1; #if defined(JS_CODEGEN_X86) masm.loadPtr(Address(masm.getStackPointer(), EntryFrameSize + masm.framePushed()), argv); #else masm.movePtr(IntArgReg0, argv); #endif masm.Push(argv); // Save the stack pointer to the saved non-volatile registers. We will use // this on two paths: normal return and exceptional return. Since // loadWasmActivation uses GlobalReg, we must do this after loading // GlobalReg. MOZ_ASSERT(masm.framePushed() == FramePushedForEntrySP); masm.loadWasmActivation(scratch); masm.storeStackPtr(Address(scratch, WasmActivation::offsetOfEntrySP())); // Dynamically align the stack since ABIStackAlignment is not necessarily // AsmJSStackAlignment. We'll use entrySP to recover the original stack // pointer on return. masm.andToStackPtr(Imm32(~(AsmJSStackAlignment - 1))); // Bump the stack for the call. masm.reserveStack(AlignBytes(StackArgBytes(sig.args()), AsmJSStackAlignment)); // Copy parameters out of argv and into the registers/stack-slots specified by // the system ABI. for (ABIArgValTypeIter iter(sig.args()); !iter.done(); iter++) { unsigned argOffset = iter.index() * Module::SizeOfEntryArg; Address src(argv, argOffset); MIRType type = iter.mirType(); switch (iter->kind()) { case ABIArg::GPR: masm.load32(src, iter->gpr()); break; #ifdef JS_CODEGEN_REGISTER_PAIR case ABIArg::GPR_PAIR: MOZ_CRASH("wasm uses hardfp for function calls."); break; #endif case ABIArg::FPU: { static_assert(Module::SizeOfEntryArg >= jit::Simd128DataSize, "EntryArg must be big enough to store SIMD values"); switch (type) { case MIRType_Int32x4: case MIRType_Bool32x4: masm.loadUnalignedInt32x4(src, iter->fpu()); break; case MIRType_Float32x4: masm.loadUnalignedFloat32x4(src, iter->fpu()); break; case MIRType_Double: masm.loadDouble(src, iter->fpu()); break; case MIRType_Float32: masm.loadFloat32(src, iter->fpu()); break; default: MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("unexpected FPU type"); break; } break; } case ABIArg::Stack: switch (type) { case MIRType_Int32: masm.load32(src, scratch); masm.storePtr(scratch, Address(masm.getStackPointer(), iter->offsetFromArgBase())); break; case MIRType_Double: masm.loadDouble(src, ScratchDoubleReg); masm.storeDouble(ScratchDoubleReg, Address(masm.getStackPointer(), iter->offsetFromArgBase())); break; case MIRType_Float32: masm.loadFloat32(src, ScratchFloat32Reg); masm.storeFloat32(ScratchFloat32Reg, Address(masm.getStackPointer(), iter->offsetFromArgBase())); break; case MIRType_Int32x4: case MIRType_Bool32x4: masm.loadUnalignedInt32x4(src, ScratchSimd128Reg); masm.storeAlignedInt32x4(ScratchSimd128Reg, Address(masm.getStackPointer(), iter->offsetFromArgBase())); break; case MIRType_Float32x4: masm.loadUnalignedFloat32x4(src, ScratchSimd128Reg); masm.storeAlignedFloat32x4(ScratchSimd128Reg, Address(masm.getStackPointer(), iter->offsetFromArgBase())); break; default: MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("unexpected stack arg type"); } break; } } // Call into the real function. masm.assertStackAlignment(AsmJSStackAlignment); masm.call(CallSiteDesc(CallSiteDesc::Relative), AsmJSInternalCallee(target)); // Recover the stack pointer value before dynamic alignment. masm.loadWasmActivation(scratch); masm.loadStackPtr(Address(scratch, WasmActivation::offsetOfEntrySP())); masm.setFramePushed(FramePushedForEntrySP); // Recover the 'argv' pointer which was saved before aligning the stack. masm.Pop(argv); // Store the return value in argv[0] switch (sig.ret()) { case ExprType::Void: break; case ExprType::I32: masm.storeValue(JSVAL_TYPE_INT32, ReturnReg, Address(argv, 0)); break; case ExprType::I64: MOZ_CRASH("no int64 in asm.js"); case ExprType::F32: masm.convertFloat32ToDouble(ReturnFloat32Reg, ReturnDoubleReg); MOZ_FALLTHROUGH; // as ReturnDoubleReg now contains a Double case ExprType::F64: masm.canonicalizeDouble(ReturnDoubleReg); masm.storeDouble(ReturnDoubleReg, Address(argv, 0)); break; case ExprType::I32x4: case ExprType::B32x4: // We don't have control on argv alignment, do an unaligned access. masm.storeUnalignedInt32x4(ReturnSimd128Reg, Address(argv, 0)); break; case ExprType::F32x4: // We don't have control on argv alignment, do an unaligned access. masm.storeUnalignedFloat32x4(ReturnSimd128Reg, Address(argv, 0)); break; case ExprType::Limit: MOZ_CRASH("Limit"); } // Restore clobbered non-volatile registers of the caller. masm.PopRegsInMask(NonVolatileRegs); MOZ_ASSERT(masm.framePushed() == 0); masm.move32(Imm32(true), ReturnReg); masm.ret(); offsets.end = masm.currentOffset(); return offsets; }