wasmtime 16.0.0 → 17.0.0

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

@@ -0,0 +1,159 @@
+//! 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 {reg:?} -> {:?}",
+        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.104.0/src/opts/arithmetic.isle

@@ -0,0 +1,169 @@
+;; 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_u ty 0)))
+      (subsume x))
+;; x-0 == x.
+(rule (simplify (isub ty
+                      x
+                      (iconst_u ty 0)))
+      (subsume x))
+;; 0-x == (ineg x).
+(rule (simplify (isub ty
+                      (iconst_u ty 0)
+                      x))
+      (ineg ty x))
+
+;; x + -y == -y + x == -(y - x) == x - y
+(rule (simplify (iadd ty x (ineg ty y)))
+      (isub ty x y))
+(rule (simplify (iadd ty (ineg ty y) x))
+      (isub ty x y))
+(rule (simplify (ineg ty (isub ty y x)))
+      (isub ty x y))
+;; x - -y == x + y
+(rule (simplify (isub ty x (ineg ty y)))
+      (iadd ty x y))
+
+;; 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 (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+
+;; x*1 == x.
+(rule (simplify (imul ty
+                      x
+                      (iconst_u ty 1)))
+      (subsume x))
+
+;; x*0 == 0.
+(rule (simplify (imul ty
+                      _
+                      zero @ (iconst_u ty 0)))
+      (subsume zero))
+
+;; x*-1 == ineg(x).
+(rule (simplify (imul ty x (iconst_s ty -1)))
+      (ineg ty x))
+
+;; (!x) + 1 == ineg(x)
+(rule (simplify (iadd ty (bnot ty x) (iconst_u ty 1)))
+      (ineg ty x))
+
+;; !(x - 1) == !(x + (-1)) == ineg(x)
+(rule (simplify (bnot ty (isub ty x (iconst_s ty 1))))
+      (ineg ty x))
+(rule (simplify (bnot ty (iadd ty x (iconst_s ty -1))))
+      (ineg ty x))
+
+;; x/1 == x.
+(rule (simplify (sdiv ty
+                      x
+                      (iconst_u ty 1)))
+      (subsume x))
+(rule (simplify (udiv ty
+                      x
+                      (iconst_u ty 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_u _ 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))))
+
+;; Detect people open-coding `mulhi`: (x as big * y as big) >> bits
+;; LLVM doesn't have an intrinsic for it, so you'll see it in code like
+;; <https://github.com/rust-lang/rust/blob/767453eb7ca188e991ac5568c17b984dd4893e77/library/core/src/num/mod.rs#L174-L180>
+(rule (simplify (sshr ty (imul ty (sextend _ x@(value_type half_ty))
+                                  (sextend _ y@(value_type half_ty)))
+                         (iconst_u _ k)))
+      (if-let $true (ty_equal half_ty (ty_half_width ty)))
+      (if-let $true (u64_eq k (ty_bits_u64 half_ty)))
+      (sextend ty (smulhi half_ty x y)))
+(rule (simplify (ushr ty (imul ty (uextend _ x@(value_type half_ty))
+                                  (uextend _ y@(value_type half_ty)))
+                         (iconst_u _ k)))
+      (if-let $true (ty_equal half_ty (ty_half_width ty)))
+      (if-let $true (u64_eq k (ty_bits_u64 half_ty)))
+      (uextend ty (umulhi half_ty x y)))

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

@@ -0,0 +1,188 @@
+;; Rewrites for `band`, `bnot`, `bor`, `bxor`
+
+;; x | 0 == x | x == x.
+(rule (simplify (bor ty
+                     x
+                     (iconst_u ty 0)))
+      (subsume x))
+(rule (simplify (bor ty x x))
+      (subsume x))
+
+;; x ^ 0 == x.
+(rule (simplify (bxor ty
+                     x
+                     (iconst_u ty 0)))
+      (subsume x))
+
+;; x ^ x == 0.
+(rule (simplify (bxor (ty_int ty) x x))
+      (subsume (iconst_u ty 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.
+(rule (simplify (bxor (ty_int ty) x (bnot ty x))) (subsume (iconst_s ty -1)))
+(rule (simplify (bxor (ty_int ty) (bnot ty x) x)) (subsume (iconst_s ty -1)))
+(rule (simplify (bor (ty_int ty) x (bnot ty x))) (subsume (iconst_s ty -1)))
+(rule (simplify (bor (ty_int ty) (bnot ty x) x)) (subsume (iconst_s ty -1)))
+
+;; x & x == x & -1 == x.
+(rule (simplify (band ty x x)) (subsume x))
+(rule (simplify (band ty x (iconst_s ty -1)))
+      (subsume x))
+
+;; x & 0 == x & not(x) == not(x) & x == 0.
+(rule (simplify (band ty _ zero @ (iconst_u ty 0))) (subsume zero))
+(rule (simplify (band (ty_int ty) x (bnot ty x))) (subsume (iconst_u ty 0)))
+(rule (simplify (band (ty_int ty) (bnot ty x) x)) (subsume (iconst_u ty 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_u ty y))
+                     z @ (iconst_u ty 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_s ty -1)))
+  (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_u ty 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_u ty shift_amt)))
+      (if-let $true (u64_eq shift_amt (ty_shift_mask ty)))
+      (bmask ty x))
+
+;; Since icmp is always 0 or 1, bmask is just a negation.
+;; TODO: Explore whether this makes sense for things needing extension too.
+(rule (simplify (bmask $I8 cmp@(icmp $I8 _ _ _)))
+      (ineg $I8 cmp))
+
+;; 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_u _ (u64_nonzero _)) (iconst_u _ 0))) x)
+;; (ne ty (iconst 0) v) is also canonicalized into this form via another rule
+(rule (truthy (ne _ x (iconst_u _ 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_u _ 0)))
+      (if-let c (truthy v))
+      (if-let (value_type (ty_int_ref_scalar_64 ty)) c)
+      (ne cty c (iconst_u ty 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_u ty 24))
+      (ishl ty
+        (band ty x (iconst_u ty 0xff00))
+        (iconst_u ty 8)))
+    (bor ty
+      (band ty
+        (ushr ty x (iconst_u ty 8))
+        (iconst_u ty 0xff00))
+      (ushr ty x (iconst_u ty 24)))))
+  (bswap ty x))
+
+(rule (simplify (bor ty @ $I64
+    (bor ty
+      (bor ty
+        (ishl ty x (iconst_u ty 56))
+        (ishl ty
+          (band ty x (iconst_u ty 0xff00))
+          (iconst_u ty 40)))
+      (bor ty
+        (ishl ty
+          (band ty x (iconst_u ty 0xff_0000))
+          (iconst_u ty 24))
+        (ishl ty
+          (band ty x (iconst_u ty 0xff00_0000))
+          (iconst_u ty 8))))
+    (bor ty
+      (bor ty
+        (band ty
+          (ushr ty x (iconst_u ty 8))
+          (iconst_u ty 0xff00_0000))
+        (band ty
+          (ushr ty x (iconst_u ty 24))
+          (iconst_u ty 0xff_0000)))
+      (bor ty
+        (band ty
+          (ushr ty x (iconst_u ty 40))
+          (iconst_u ty 0xff00))
+        (ushr ty x (iconst_u ty 56))))))
+  (bswap ty x))