wasmtime 16.0.0 → 17.0.0

data/ext/cargo-vendor/cranelift-codegen-0.103.0/src/machinst/pcc.rs

@@ -1,160 +0,0 @@
-//! Common helpers for ISA-specific proof-carrying-code implementations.
-
-use crate::ir::pcc::{Fact, FactContext, PccError, PccResult};
-use crate::machinst::{Reg, VCode, VCodeInst, Writable};
-use crate::trace;
-
-pub(crate) fn get_fact_or_default<I: VCodeInst>(vcode: &VCode<I>, reg: Reg, width: u16) -> Fact {
-    trace!(
-        "get_fact_or_default: reg v{} -> {:?}",
-        reg.to_virtual_reg().unwrap().index(),
-        vcode.vreg_fact(reg.into())
-    );
-    vcode
-        .vreg_fact(reg.into())
-        .map(|f| f.clone())
-        .unwrap_or_else(|| Fact::max_range_for_width(width))
-}
-
-pub(crate) fn has_fact<I: VCodeInst>(vcode: &VCode<I>, reg: Reg) -> bool {
-    vcode.vreg_fact(reg.into()).is_some()
-}
-
-pub(crate) fn fail_if_missing(fact: Option<Fact>) -> PccResult<Fact> {
-    fact.ok_or(PccError::UnsupportedFact)
-}
-
-pub(crate) fn clamp_range(
-    ctx: &FactContext,
-    to_bits: u16,
-    from_bits: u16,
-    fact: Option<Fact>,
-) -> PccResult<Fact> {
-    let max = if from_bits == 64 {
-        u64::MAX
-    } else {
-        (1u64 << from_bits) - 1
-    };
-    trace!(
-        "clamp_range: fact {:?} from {} to {}",
-        fact,
-        from_bits,
-        to_bits
-    );
-    Ok(fact
-        .and_then(|f| ctx.uextend(&f, from_bits, to_bits))
-        .unwrap_or_else(|| {
-            let result = Fact::Range {
-                bit_width: to_bits,
-                min: 0,
-                max,
-            };
-            trace!(" -> clamping to {:?}", result);
-            result
-        }))
-}
-
-pub(crate) fn check_subsumes(ctx: &FactContext, subsumer: &Fact, subsumee: &Fact) -> PccResult<()> {
-    trace!(
-        "checking if derived fact {:?} subsumes stated fact {:?}",
-        subsumer,
-        subsumee
-    );
-
-    if ctx.subsumes(subsumer, subsumee) {
-        Ok(())
-    } else {
-        Err(PccError::UnsupportedFact)
-    }
-}
-
-pub(crate) fn check_output<I: VCodeInst, F: FnOnce(&VCode<I>) -> PccResult<Fact>>(
-    ctx: &FactContext,
-    vcode: &mut VCode<I>,
-    out: Writable<Reg>,
-    ins: &[Reg],
-    f: F,
-) -> PccResult<()> {
-    if let Some(fact) = vcode.vreg_fact(out.to_reg().into()) {
-        let result = f(vcode)?;
-        check_subsumes(ctx, &result, fact)
-    } else if ins.iter().any(|r| {
-        vcode
-            .vreg_fact(r.into())
-            .map(|fact| fact.propagates())
-            .unwrap_or(false)
-    }) {
-        if let Ok(fact) = f(vcode) {
-            trace!("setting vreg {:?} to {:?}", out, fact);
-            vcode.set_vreg_fact(out.to_reg().into(), fact);
-        }
-        Ok(())
-    } else {
-        Ok(())
-    }
-}
-
-pub(crate) fn check_unop<I: VCodeInst, F: FnOnce(&Fact) -> PccResult<Fact>>(
-    ctx: &FactContext,
-    vcode: &mut VCode<I>,
-    reg_width: u16,
-    out: Writable<Reg>,
-    ra: Reg,
-    f: F,
-) -> PccResult<()> {
-    check_output(ctx, vcode, out, &[ra], |vcode| {
-        let ra = get_fact_or_default(vcode, ra, reg_width);
-        f(&ra)
-    })
-}
-
-pub(crate) fn check_binop<I: VCodeInst, F: FnOnce(&Fact, &Fact) -> PccResult<Fact>>(
-    ctx: &FactContext,
-    vcode: &mut VCode<I>,
-    reg_width: u16,
-    out: Writable<Reg>,
-    ra: Reg,
-    rb: Reg,
-    f: F,
-) -> PccResult<()> {
-    check_output(ctx, vcode, out, &[ra, rb], |vcode| {
-        let ra = get_fact_or_default(vcode, ra, reg_width);
-        let rb = get_fact_or_default(vcode, rb, reg_width);
-        f(&ra, &rb)
-    })
-}
-
-pub(crate) fn check_constant<I: VCodeInst>(
-    ctx: &FactContext,
-    vcode: &mut VCode<I>,
-    out: Writable<Reg>,
-    bit_width: u16,
-    value: u64,
-) -> PccResult<()> {
-    let result = Fact::constant(bit_width, value);
-    if let Some(fact) = vcode.vreg_fact(out.to_reg().into()) {
-        check_subsumes(ctx, &result, fact)
-    } else {
-        trace!("setting vreg {:?} to {:?}", out, result);
-        vcode.set_vreg_fact(out.to_reg().into(), result);
-        Ok(())
-    }
-}
-
-/// The operation we're checking against an amode: either
-///
-/// - a *load*, and we need to validate that the field's fact subsumes
-///   the load result's fact, OR
-///
-/// - a *store*, and we need to validate that the stored data's fact
-///   subsumes the field's fact.
-pub(crate) enum LoadOrStore<'a> {
-    Load {
-        result_fact: Option<&'a Fact>,
-        from_bits: u16,
-        to_bits: u16,
-    },
-    Store {
-        stored_fact: Option<&'a Fact>,
-    },
-}

data/ext/cargo-vendor/cranelift-codegen-0.103.0/src/opts/arithmetic.isle

@@ -1,152 +0,0 @@
-;; rewrites for integer and floating-point arithmetic
-;; eg: `iadd`, `isub`, `ineg`, `imul`, `fadd`, `fsub`, `fmul`
-
-;; For commutative instructions, we depend on cprop.isle pushing immediates to
-;; the right, and thus only simplify patterns like `x+0`, not `0+x`.
-
-;; x+0 == x.
-(rule (simplify (iadd ty
-                      x
-                      (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-;; x-0 == x.
-(rule (simplify (isub ty
-                      x
-                      (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-;; 0-x == (ineg x).
-(rule (simplify (isub ty
-                      (iconst ty (u64_from_imm64 0))
-                      x))
-      (ineg ty x))
-
-;; ineg(ineg(x)) == x.
-(rule (simplify (ineg ty (ineg ty x))) (subsume x))
-
-;; ineg(x) * ineg(y) == x*y.
-(rule (simplify (imul ty (ineg ty x) (ineg ty y)))
-      (subsume (imul ty x y)))
-
-;; iabs(ineg(x)) == iabs(x).
-(rule (simplify (iabs ty (ineg ty x)))
-      (iabs ty x))
-
-;; iabs(iabs(x)) == iabs(x).
-(rule (simplify (iabs ty inner @ (iabs ty x)))
-      (subsume inner))
-
-;; x-x == 0.
-(rule (simplify (isub (fits_in_64 (ty_int ty)) x x)) (subsume (iconst ty (imm64 0))))
-
-;; x*1 == x.
-(rule (simplify (imul ty
-                      x
-                      (iconst ty (u64_from_imm64 1))))
-      (subsume x))
-
-;; x*0 == 0.
-(rule (simplify (imul ty
-                      _
-                      zero @ (iconst ty (u64_from_imm64 0))))
-      (subsume zero))
-
-;; x*-1 == ineg(x).
-(rule (simplify (imul ty x (iconst ty c)))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-
-;; (!x) + 1 == 1 + (!x) == !(x) - (-1) == ineg(x)
-(rule (simplify (iadd ty (bnot ty x) (iconst ty (u64_from_imm64 1))))
-      (ineg ty x))
-(rule (simplify (iadd ty (iconst ty (u64_from_imm64 1)) (bnot ty x)))
-      (ineg ty x))
-(rule (simplify (isub ty (bnot ty x) (iconst ty c)))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-
-;; !(x - 1) == !(x + (-1)) == !((-1) + x) == ineg(x)
-(rule (simplify (bnot ty (isub ty x (iconst ty (u64_from_imm64 1)))))
-      (ineg ty x))
-(rule (simplify (bnot ty (iadd ty x (iconst ty c))))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-(rule (simplify (bnot ty (iadd ty (iconst ty c) x)))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-
-;; x/1 == x.
-(rule (simplify (sdiv ty
-                      x
-                      (iconst ty (u64_from_imm64 1))))
-      (subsume x))
-(rule (simplify (udiv ty
-                      x
-                      (iconst ty (u64_from_imm64 1))))
-      (subsume x))
-
-;; TODO: strength reduction: div to shifts
-;; TODO: div/rem by constants -> magic multiplications
-
-;; x*2 == x+x.
-(rule (simplify (imul ty x (iconst _ (simm32 2))))
-      (iadd ty x x))
-
-;; x*c == x<<log2(c) when c is a power of two.
-;; Note that the type of `iconst` must be the same as the type of `imul`,
-;; so these rules can only fire in situations where it's safe to construct an
-;; `iconst` of that type.
-(rule (simplify (imul ty x (iconst _ (imm64_power_of_two c))))
-      (ishl ty x (iconst ty (imm64 c))))
-(rule (simplify (imul ty (iconst _ (imm64_power_of_two c)) x))
-      (ishl ty x (iconst ty (imm64 c))))
-
-;; fneg(fneg(x)) == x.
-(rule (simplify (fneg ty (fneg ty x))) (subsume x))
-
-;; If both of the multiplied arguments to an `fma` are negated then remove
-;; both of them since they cancel out.
-(rule (simplify (fma ty (fneg ty x) (fneg ty y) z))
-      (fma ty x y z))
-
-;; If both of the multiplied arguments to an `fmul` are negated then remove
-;; both of them since they cancel out.
-(rule (simplify (fmul ty (fneg ty x) (fneg ty y)))
-      (fmul ty x y))
-
-;; (a op (b op (c op d))) ==> ((a op b) op (c op d))
-;;
-;; and
-;;
-;; (((a op b) op c) op d) ==> ((a op b) op (c op d))
-;;
-;; where `op` is an associative operation: `iadd`, `imul`, `band`, or `bxor`.
-;;
-;; This increases instruction-level parallelism and shrinks live ranges. It also
-;; canonicalizes into the shallow-and-wide form for reassociating constants
-;; together for cprop.
-;;
-;; NB: We subsume to avoid exponential e-node blow up due to reassociating very
-;; large chains of operations.
-;;
-;; TODO: We should add `bor` rules for this as well. Unfortunately, they
-;; conflict with our `bswap` recognizing rules when we `subsume`.
-
-(rule (simplify (iadd ty a (iadd ty b (iadd ty c d))))
-      (subsume (iadd ty (iadd ty a b) (iadd ty c d))))
-(rule (simplify (iadd ty (iadd ty (iadd ty a b) c) d))
-      (subsume (iadd ty (iadd ty a b) (iadd ty c d))))
-
-(rule (simplify (imul ty a (imul ty b (imul ty c d))))
-      (subsume (imul ty (imul ty a b) (imul ty c d))))
-(rule (simplify (imul ty (imul ty (imul ty a b) c) d))
-      (subsume (imul ty (imul ty a b) (imul ty c d))))
-
-(rule (simplify (band ty a (band ty b (band ty c d))))
-      (subsume (band ty (band ty a b) (band ty c d))))
-(rule (simplify (band ty (band ty (band ty a b) c) d))
-      (subsume (band ty (band ty a b) (band ty c d))))
-
-(rule (simplify (bxor ty a (bxor ty b (bxor ty c d))))
-      (subsume (bxor ty (bxor ty a b) (bxor ty c d))))
-(rule (simplify (bxor ty (bxor ty (bxor ty a b) c) d))
-      (subsume (bxor ty (bxor ty a b) (bxor ty c d))))

data/ext/cargo-vendor/cranelift-codegen-0.103.0/src/opts/bitops.isle

@@ -1,198 +0,0 @@
-;; Rewrites for `band`, `bnot`, `bor`, `bxor`
-
-;; x | 0 == 0 | x == x | x == x.
-(rule (simplify (bor ty
-                     x
-                     (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-(rule (simplify (bor ty
-                     (iconst ty (u64_from_imm64 0))
-                     x))
-      (subsume x))
-(rule (simplify (bor ty x x))
-      (subsume x))
-
-;; x ^ 0 == 0 ^ x == x.
-(rule (simplify (bxor ty
-                     x
-                     (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-(rule (simplify (bxor ty
-                     (iconst ty (u64_from_imm64 0))
-                     x))
-      (subsume x))
-
-;; x ^ x == 0.
-(rule (simplify (bxor (fits_in_64 (ty_int ty)) x x))
-      (subsume (iconst ty (imm64 0))))
-
-;; x ^ not(x) == not(x) ^ x == x | not(x) == not(x) | x == -1.
-;; This identity also holds for non-integer types, vectors, and wider types.
-;; But `iconst` is only valid for integers up to 64 bits wide.
-(rule (simplify (bxor (fits_in_64 (ty_int ty)) x (bnot ty x))) (subsume (iconst ty (imm64 (ty_mask ty)))))
-(rule (simplify (bxor (fits_in_64 (ty_int ty)) (bnot ty x) x)) (subsume (iconst ty (imm64 (ty_mask ty)))))
-(rule (simplify (bor (fits_in_64 (ty_int ty)) x (bnot ty x))) (subsume (iconst ty (imm64 (ty_mask ty)))))
-(rule (simplify (bor (fits_in_64 (ty_int ty)) (bnot ty x) x)) (subsume (iconst ty (imm64 (ty_mask ty)))))
-
-;; x & -1 == -1 & x == x & x == x.
-(rule (simplify (band ty x x)) (subsume x))
-(rule (simplify (band ty x (iconst ty k)))
-      (if-let -1 (i64_sextend_imm64 ty k))
-      (subsume x))
-(rule (simplify (band ty (iconst ty k) x))
-      (if-let -1 (i64_sextend_imm64 ty k))
-      (subsume x))
-
-;; x & 0 == 0 & x == x & not(x) == not(x) & x == 0.
-(rule (simplify (band ty _ zero @ (iconst ty (u64_from_imm64 0)))) (subsume zero))
-(rule (simplify (band ty zero @ (iconst ty (u64_from_imm64 0)) _)) (subsume zero))
-(rule (simplify (band (fits_in_64 (ty_int ty)) x (bnot ty x))) (subsume (iconst ty (imm64 0))))
-(rule (simplify (band (fits_in_64 (ty_int ty)) (bnot ty x) x)) (subsume (iconst ty (imm64 0))))
-
-;; not(not(x)) == x.
-(rule (simplify (bnot ty (bnot ty x))) (subsume x))
-
-;; DeMorgan's rule (two versions):
-;; bnot(bor(x, y)) == band(bnot(x), bnot(y))
-(rule (simplify (bnot ty (bor ty x y)))
-      (band ty (bnot ty x) (bnot ty y)))
-;; bnot(band(x, y)) == bor(bnot(x), bnot(y))
-(rule (simplify (bnot ty (band t x y)))
-      (bor ty (bnot ty x) (bnot ty y)))
-
-;; `or(and(x, y), not(y)) == or(x, not(y))`
-(rule (simplify (bor ty
-                     (band ty x y)
-                     z @ (bnot ty y)))
-      (bor ty x z))
-;; Duplicate the rule but swap the `bor` operands because `bor` is
-;; commutative. We could, of course, add a `simplify` rule to do the commutative
-;; swap for all `bor`s but this will bloat the e-graph with many e-nodes. It is
-;; cheaper to have additional rules, rather than additional e-nodes, because we
-;; amortize their cost via ISLE's smart codegen.
-(rule (simplify (bor ty
-                     z @ (bnot ty y)
-                     (band ty x y)))
-      (bor ty x z))
-
-;; `or(and(x, y), not(y)) == or(x, not(y))` specialized for constants, since
-;; otherwise we may not know that `z == not(y)` since we don't generally expand
-;; constants in the e-graph.
-;;
-;; (No need to duplicate for commutative `bor` for this constant version because
-;; we move constants to the right.)
-(rule (simplify (bor ty
-                     (band ty x (iconst ty (u64_from_imm64 y)))
-                     z @ (iconst ty (u64_from_imm64 zk))))
-      (if-let $true (u64_eq (u64_and (ty_mask ty) zk)
-                            (u64_and (ty_mask ty) (u64_not y))))
-      (bor ty x z))
-
-;; (x ^ -1) can be replaced with the `bnot` instruction
-(rule (simplify (bxor ty x (iconst ty k)))
-  (if-let -1 (i64_sextend_imm64 ty k))
-  (bnot ty x))
-
-;; sshr((x | -x), N) == bmask(x) where N = ty_bits(ty) - 1.
-;;
-;; (x | -x) sets the sign bit to 1 if x is nonzero, and 0 if x is zero. sshr propagates
-;; the sign bit to the rest of the value.
-(rule (simplify (sshr ty (bor ty x (ineg ty x)) (iconst ty (u64_from_imm64 shift_amt))))
-      (if-let $true (u64_eq shift_amt (ty_shift_mask ty)))
-      (bmask ty x))
-
-(rule (simplify (sshr ty (bor ty (ineg ty x) x) (iconst ty (u64_from_imm64 shift_amt))))
-      (if-let $true (u64_eq shift_amt (ty_shift_mask ty)))
-      (bmask ty x))
-
-;; Matches any expressions that preserve "truthiness".
-;; i.e. If the input is zero it remains zero, and if it is nonzero it can have
-;; a different value as long as it is still nonzero.
-(decl pure multi truthy (Value) Value)
-(rule (truthy (sextend _ x)) x)
-(rule (truthy (uextend _ x)) x)
-(rule (truthy (bmask _ x)) x)
-(rule (truthy (ineg _ x)) x)
-(rule (truthy (bswap _ x)) x)
-(rule (truthy (bitrev _ x)) x)
-(rule (truthy (popcnt _ x)) x)
-(rule (truthy (rotl _ x _)) x)
-(rule (truthy (rotr _ x _)) x)
-(rule (truthy (select _ x (iconst _ (u64_from_imm64 (u64_nonzero _))) (iconst _ (u64_from_imm64 0)))) x)
-;; (ne ty (iconst 0) v) is also canonicalized into this form via another rule
-(rule (truthy (ne _ x (iconst _ (u64_from_imm64 0)))) x)
-
-;; All of these expressions don't care about their input as long as it is truthy.
-;; so we can remove expressions that preserve that property from the input.
-(rule (simplify (bmask ty v)) (if-let x (truthy v)) (bmask ty x))
-(rule (simplify (select ty v t f)) (if-let c (truthy v)) (select ty c t f))
-;; (ne ty (iconst 0) v) is also canonicalized into this form via another rule
-(rule (simplify (ne cty v (iconst _ (u64_from_imm64 0))))
-      (if-let c (truthy v))
-      (if-let (value_type (ty_int_ref_scalar_64 ty)) c)
-      (ne cty c (iconst ty (imm64 0))))
-
-
-
-;; (sextend (bmask x)) can be replaced with (bmask x) since bmask
-;; supports any size of output type, regardless of input.
-;; Same with `ireduce`
-(rule (simplify (sextend ty (bmask _ x))) (bmask ty x))
-(rule (simplify (ireduce ty (bmask _ x))) (bmask ty x))
-
-;; (bswap (bswap x)) == x
-(rule (simplify (bswap ty (bswap ty x))) (subsume x))
-
-;; (bitrev (bitrev x)) == x
-(rule (simplify (bitrev ty (bitrev ty x))) (subsume x))
-
-;; WebAssembly doesn't have a native byte-swapping instruction at this time so
-;; languages which have a byte-swapping operation will compile it down to bit
-;; shifting and twiddling. This attempts to pattern match what LLVM currently
-;; generates today for the Rust code `a.swap_bytes()`. This might be a bit
-;; brittle over time and/or with other possible LLVM backend optimizations, but
-;; it's at least one way to generate a byte swap.
-;;
-;; Technically this could be permuted quite a few ways and currently there's no
-;; easy way to match all of them, so only one is matched here.
-(rule (simplify (bor ty @ $I32
-    (bor ty
-      (ishl ty x (iconst ty (u64_from_imm64 24)))
-      (ishl ty
-        (band ty x (iconst ty (u64_from_imm64 0xff00)))
-        (iconst ty (u64_from_imm64 8))))
-    (bor ty
-      (band ty
-        (ushr ty x (iconst ty (u64_from_imm64 8)))
-        (iconst ty (u64_from_imm64 0xff00)))
-      (ushr ty x (iconst ty (u64_from_imm64 24))))))
-  (bswap ty x))
-
-(rule (simplify (bor ty @ $I64
-    (bor ty
-      (bor ty
-        (ishl ty x (iconst ty (u64_from_imm64 56)))
-        (ishl ty
-          (band ty x (iconst ty (u64_from_imm64 0xff00)))
-          (iconst ty (u64_from_imm64 40))))
-      (bor ty
-        (ishl ty
-          (band ty x (iconst ty (u64_from_imm64 0xff_0000)))
-          (iconst ty (u64_from_imm64 24)))
-        (ishl ty
-          (band ty x (iconst ty (u64_from_imm64 0xff00_0000)))
-          (iconst ty (u64_from_imm64 8)))))
-    (bor ty
-      (bor ty
-        (band ty
-          (ushr ty x (iconst ty (u64_from_imm64 8)))
-          (iconst ty (u64_from_imm64 0xff00_0000)))
-        (band ty
-          (ushr ty x (iconst ty (u64_from_imm64 24)))
-          (iconst ty (u64_from_imm64 0xff_0000))))
-      (bor ty
-        (band ty
-          (ushr ty x (iconst ty (u64_from_imm64 40)))
-          (iconst ty (u64_from_imm64 0xff00)))
-        (ushr ty x (iconst ty (u64_from_imm64 56)))))))
-  (bswap ty x))