Method wasm_load

winch/codegen/src/isa/x64/masm.rs:363–424

(&mut self, src: Self::Address, dst: WritableReg, kind: LoadKind)

    }

    fn wasm_load(&mut self, src: Self::Address, dst: WritableReg, kind: LoadKind) -> Result<()> {
        let size = kind.derive_operand_size();

        match kind {
            LoadKind::ScalarExtend(ext) => match ext {
                ExtendKind::Signed(ext) => {
                    self.asm.movsx_mr(&src, dst, ext, UNTRUSTED_FLAGS);
                }
                ExtendKind::Unsigned(_) => self.load_impl(src, dst, size, UNTRUSTED_FLAGS)?,
            },
            LoadKind::Operand(_) | LoadKind::Atomic(_, _) => {
                // The guarantees of the x86-64 memory model ensure that `SeqCst`
                // loads are equivalent to normal loads.
                if kind.is_atomic() && size == OperandSize::S128 {
                    bail!(CodeGenError::unexpected_operand_size());
                }

                self.load_impl(src, dst, size, UNTRUSTED_FLAGS)?;
            }
            LoadKind::VectorExtend(ext) => {
                self.ensure_has_avx()?;
                self.asm
                    .xmm_vpmov_mr(&src, dst, ext.into(), UNTRUSTED_FLAGS)
            }
            LoadKind::Splat(_) => {
                self.ensure_has_avx()?;

                if size == OperandSize::S64 {
                    self.asm
                        .xmm_mov_mr(&src, dst, OperandSize::S64, UNTRUSTED_FLAGS);
                    self.asm.xmm_vpshuf_rr(
                        dst.to_reg(),
                        dst,
                        Self::vpshuf_mask_for_64_bit_splats(),
                        OperandSize::S32,
                    );
                } else {
                    self.asm
                        .xmm_vpbroadcast_mr(&src, dst, size, UNTRUSTED_FLAGS);
                }
            }
            LoadKind::VectorLane(LaneSelector { lane, size }) => {
                self.ensure_has_avx()?;
                self.with_scratch::<IntScratch, _>(|masm, byte_tmp| {
                    masm.load_impl(src, byte_tmp.writable(), size, UNTRUSTED_FLAGS)?;
                    masm.asm
                        .xmm_vpinsr_rrr(dst, dst.to_reg(), byte_tmp.inner(), lane, size);
                    wasmtime_environ::error::Ok(())
                })?;
            }
            LoadKind::VectorZero(size) => {
                self.ensure_has_avx()?;
                self.with_scratch::<IntScratch, _>(|masm, scratch| {
                    masm.load_impl(src, scratch.writable(), size, UNTRUSTED_FLAGS)?;
                    masm.asm.avx_gpr_to_xmm(scratch.inner(), dst, size);
                    wasmtime_environ::error::Ok(())
                })?;
            }